Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

125 files changed, 21485 insertions, 0 deletions

diff --git a/remote/shared/AppInfo.sys.mjs b/remote/shared/AppInfo.sys.mjs
new file mode 100644
index 0000000000..300041987b
--- /dev/null
+++ b/remote/shared/AppInfo.sys.mjs
@@ -0,0 +1,63 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const ID_FIREFOX = "{ec8030f7-c20a-464f-9b0e-13a3a9e97384}";
+const ID_THUNDERBIRD = "{3550f703-e582-4d05-9a08-453d09bdfdc6}";
+
+/**
+ * Extends Services.appinfo with further properties that are
+ * used by different protocols as handled by the Remote Agent.
+ *
+ * @typedef {object} RemoteAgent.AppInfo
+ * @property {boolean} isAndroid - Whether the application runs on Android.
+ * @property {boolean} isLinux - Whether the application runs on Linux.
+ * @property {boolean} isMac - Whether the application runs on Mac OS.
+ * @property {boolean} isWindows - Whether the application runs on Windows.
+ * @property {boolean} isFirefox - Whether the application is Firefox.
+ * @property {boolean} isThunderbird - Whether the application is Thunderbird.
+ *
+ * @since 88
+ */
+export const AppInfo = new Proxy(
+  {},
+  {
+    get(target, prop, receiver) {
+      if (target.hasOwnProperty(prop)) {
+        return target[prop];
+      }
+
+      return Services.appinfo[prop];
+    },
+  }
+);
+
+// Platform support
+
+XPCOMUtils.defineLazyGetter(AppInfo, "isAndroid", () => {
+  return Services.appinfo.OS === "Android";
+});
+
+XPCOMUtils.defineLazyGetter(AppInfo, "isLinux", () => {
+  return Services.appinfo.OS === "Linux";
+});
+
+XPCOMUtils.defineLazyGetter(AppInfo, "isMac", () => {
+  return Services.appinfo.OS === "Darwin";
+});
+
+XPCOMUtils.defineLazyGetter(AppInfo, "isWindows", () => {
+  return Services.appinfo.OS === "WINNT";
+});
+
+// Application type
+
+XPCOMUtils.defineLazyGetter(AppInfo, "isFirefox", () => {
+  return Services.appinfo.ID == ID_FIREFOX;
+});
+
+XPCOMUtils.defineLazyGetter(AppInfo, "isThunderbird", () => {
+  return Services.appinfo.ID == ID_THUNDERBIRD;
+});
diff --git a/remote/shared/Capture.sys.mjs b/remote/shared/Capture.sys.mjs
new file mode 100644
index 0000000000..1d0ef00e75
--- /dev/null
+++ b/remote/shared/Capture.sys.mjs
@@ -0,0 +1,205 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+const CONTEXT_2D = "2d";
+const BG_COLOUR = "rgb(255,255,255)";
+const MAX_CANVAS_DIMENSION = 32767;
+const MAX_CANVAS_AREA = 472907776;
+const PNG_MIME = "image/png";
+const XHTML_NS = "http://www.w3.org/1999/xhtml";
+
+/**
+ * Provides primitives to capture screenshots.
+ *
+ * @namespace
+ */
+export const capture = {};
+
+capture.Format = {
+  Base64: 0,
+  Hash: 1,
+};
+
+/**
+ * Draw a rectangle off the framebuffer.
+ *
+ * @param {DOMWindow} win
+ *     The DOM window used for the framebuffer, and providing the interfaces
+ *     for creating an HTMLCanvasElement.
+ * @param {BrowsingContext} browsingContext
+ *     The BrowsingContext from which the snapshot should be taken.
+ * @param {number} left
+ *     The left, X axis offset of the rectangle.
+ * @param {number} top
+ *     The top, Y axis offset of the rectangle.
+ * @param {number} width
+ *     The width dimension of the rectangle to paint.
+ * @param {number} height
+ *     The height dimension of the rectangle to paint.
+ * @param {object=} options
+ * @param {HTMLCanvasElement=} options.canvas
+ *     Optional canvas to reuse for the screenshot.
+ * @param {number=} options.flags
+ *     Optional integer representing flags to pass to drawWindow; these
+ *     are defined on CanvasRenderingContext2D.
+ * @param {number=} options.dX
+ *     Horizontal offset between the browser window and content area. Defaults to 0.
+ * @param {number=} options.dY
+ *     Vertical offset between the browser window and content area. Defaults to 0.
+ * @param {boolean=} options.readback
+ *     If true, read back a snapshot of the pixel data currently in the
+ *     compositor/window. Defaults to false.
+ *
+ * @returns {HTMLCanvasElement}
+ *     The canvas on which the selection from the window's framebuffer
+ *     has been painted on.
+ */
+capture.canvas = async function (
+  win,
+  browsingContext,
+  left,
+  top,
+  width,
+  height,
+  { canvas = null, flags = null, dX = 0, dY = 0, readback = false } = {}
+) {
+  // FIXME(bug 1761032): This looks a bit sketchy, overrideDPPX doesn't
+  // influence rendering...
+  const scale = win.browsingContext.overrideDPPX || win.devicePixelRatio;
+
+  let canvasHeight = height * scale;
+  let canvasWidth = width * scale;
+
+  // Cap the screenshot size for width and height at 2^16 pixels,
+  // which is the maximum allowed canvas size. Higher dimensions will
+  // trigger exceptions in Gecko.
+  if (canvasWidth > MAX_CANVAS_DIMENSION) {
+    lazy.logger.warn(
+      "Limiting screen capture width to maximum allowed " +
+        MAX_CANVAS_DIMENSION +
+        " pixels"
+    );
+    width = Math.floor(MAX_CANVAS_DIMENSION / scale);
+    canvasWidth = width * scale;
+  }
+
+  if (canvasHeight > MAX_CANVAS_DIMENSION) {
+    lazy.logger.warn(
+      "Limiting screen capture height to maximum allowed " +
+        MAX_CANVAS_DIMENSION +
+        " pixels"
+    );
+    height = Math.floor(MAX_CANVAS_DIMENSION / scale);
+    canvasHeight = height * scale;
+  }
+
+  // If the area is larger, reduce the height to keep the full width.
+  if (canvasWidth * canvasHeight > MAX_CANVAS_AREA) {
+    lazy.logger.warn(
+      "Limiting screen capture area to maximum allowed " +
+        MAX_CANVAS_AREA +
+        " pixels"
+    );
+    height = Math.floor(MAX_CANVAS_AREA / (canvasWidth * scale));
+    canvasHeight = height * scale;
+  }
+
+  if (canvas === null) {
+    canvas = win.document.createElementNS(XHTML_NS, "canvas");
+    canvas.width = canvasWidth;
+    canvas.height = canvasHeight;
+  }
+
+  const ctx = canvas.getContext(CONTEXT_2D);
+
+  if (readback) {
+    if (flags === null) {
+      flags =
+        ctx.DRAWWINDOW_DRAW_CARET |
+        ctx.DRAWWINDOW_DRAW_VIEW |
+        ctx.DRAWWINDOW_USE_WIDGET_LAYERS;
+    }
+
+    // drawWindow doesn't take scaling into account.
+    ctx.scale(scale, scale);
+    ctx.drawWindow(win, left + dX, top + dY, width, height, BG_COLOUR, flags);
+  } else {
+    let rect = new DOMRect(left, top, width, height);
+    let snapshot = await browsingContext.currentWindowGlobal.drawSnapshot(
+      rect,
+      scale,
+      BG_COLOUR
+    );
+
+    ctx.drawImage(snapshot, 0, 0);
+
+    // Bug 1574935 - Huge dimensions can trigger an OOM because multiple copies
+    // of the bitmap will exist in memory. Force the removal of the snapshot
+    // because it is no longer needed.
+    snapshot.close();
+  }
+
+  return canvas;
+};
+
+/**
+ * Encode the contents of an HTMLCanvasElement to a Base64 encoded string.
+ *
+ * @param {HTMLCanvasElement} canvas
+ *     The canvas to encode.
+ *
+ * @returns {string}
+ *     A Base64 encoded string.
+ */
+capture.toBase64 = function (canvas) {
+  let u = canvas.toDataURL(PNG_MIME);
+  return u.substring(u.indexOf(",") + 1);
+};
+
+/**
+ * Hash the contents of an HTMLCanvasElement to a SHA-256 hex digest.
+ *
+ * @param {HTMLCanvasElement} canvas
+ *     The canvas to encode.
+ *
+ * @returns {string}
+ *     A hex digest of the SHA-256 hash of the base64 encoded string.
+ */
+capture.toHash = function (canvas) {
+  let u = capture.toBase64(canvas);
+  let buffer = new TextEncoder().encode(u);
+  return crypto.subtle.digest("SHA-256", buffer).then(hash => hex(hash));
+};
+
+/**
+ * Convert buffer into to hex.
+ *
+ * @param {ArrayBuffer} buffer
+ *     The buffer containing the data to convert to hex.
+ *
+ * @returns {string}
+ *     A hex digest of the input buffer.
+ */
+function hex(buffer) {
+  let hexCodes = [];
+  let view = new DataView(buffer);
+  for (let i = 0; i < view.byteLength; i += 4) {
+    let value = view.getUint32(i);
+    let stringValue = value.toString(16);
+    let padding = "00000000";
+    let paddedValue = (padding + stringValue).slice(-padding.length);
+    hexCodes.push(paddedValue);
+  }
+  return hexCodes.join("");
+}
diff --git a/remote/shared/Format.sys.mjs b/remote/shared/Format.sys.mjs
new file mode 100644
index 0000000000..95e9ff339f
--- /dev/null
+++ b/remote/shared/Format.sys.mjs
@@ -0,0 +1,186 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "truncateLog",
+  "remote.log.truncate",
+  false
+);
+
+const ELEMENT_NODE = 1;
+const MAX_STRING_LENGTH = 250;
+
+/**
+ * Pretty-print values passed to template strings.
+ *
+ * Usage::
+ *
+ *     let bool = {value: true};
+ *     pprint`Expected boolean, got ${bool}`;
+ *     => 'Expected boolean, got [object Object] {"value": true}'
+ *
+ *     let htmlElement = document.querySelector("input#foo");
+ *     pprint`Expected element ${htmlElement}`;
+ *     => 'Expected element <input id="foo" class="bar baz" type="input">'
+ *
+ *     pprint`Current window: ${window}`;
+ *     => '[object Window https://www.mozilla.org/]'
+ */
+export function pprint(ss, ...values) {
+  function pretty(val) {
+    let proto = Object.prototype.toString.call(val);
+    if (
+      typeof val == "object" &&
+      val !== null &&
+      "nodeType" in val &&
+      val.nodeType === ELEMENT_NODE
+    ) {
+      return prettyElement(val);
+    } else if (["[object Window]", "[object ChromeWindow]"].includes(proto)) {
+      return prettyWindowGlobal(val);
+    } else if (proto == "[object Attr]") {
+      return prettyAttr(val);
+    }
+    return prettyObject(val);
+  }
+
+  function prettyElement(el) {
+    let attrs = ["id", "class", "href", "name", "src", "type"];
+
+    let idents = "";
+    for (let attr of attrs) {
+      if (el.hasAttribute(attr)) {
+        idents += ` ${attr}="${el.getAttribute(attr)}"`;
+      }
+    }
+
+    return `<${el.localName}${idents}>`;
+  }
+
+  function prettyWindowGlobal(win) {
+    let proto = Object.prototype.toString.call(win);
+    return `[${proto.substring(1, proto.length - 1)} ${win.location}]`;
+  }
+
+  function prettyAttr(obj) {
+    return `[object Attr ${obj.name}="${obj.value}"]`;
+  }
+
+  function prettyObject(obj) {
+    let proto = Object.prototype.toString.call(obj);
+    let s = "";
+    try {
+      s = JSON.stringify(obj);
+    } catch (e) {
+      if (e instanceof TypeError) {
+        s = `<${e.message}>`;
+      } else {
+        throw e;
+      }
+    }
+    return `${proto} ${s}`;
+  }
+
+  let res = [];
+  for (let i = 0; i < ss.length; i++) {
+    res.push(ss[i]);
+    if (i < values.length) {
+      let s;
+      try {
+        s = pretty(values[i]);
+      } catch (e) {
+        lazy.logger.warn("Problem pretty printing:", e);
+        s = typeof values[i];
+      }
+      res.push(s);
+    }
+  }
+  return res.join("");
+}
+
+/**
+ * Template literal that truncates string values in arbitrary objects.
+ *
+ * Given any object, the template will walk the object and truncate
+ * any strings it comes across to a reasonable limit.  This is suitable
+ * when you have arbitrary data and data integrity is not important.
+ *
+ * The strings are truncated in the middle so that the beginning and
+ * the end is preserved.  This will make a long, truncated string look
+ * like "X <...> Y", where X and Y are half the number of characters
+ * of the maximum string length from either side of the string.
+ *
+ *
+ * Usage::
+ *
+ *     truncate`Hello ${"x".repeat(260)}!`;
+ *     // Hello xxx ... xxx!
+ *
+ * Functions named `toJSON` or `toString` on objects will be called.
+ */
+export function truncate(strings, ...values) {
+  function walk(obj) {
+    const typ = Object.prototype.toString.call(obj);
+
+    switch (typ) {
+      case "[object Undefined]":
+      case "[object Null]":
+      case "[object Boolean]":
+      case "[object Number]":
+        return obj;
+
+      case "[object String]":
+        if (lazy.truncateLog && obj.length > MAX_STRING_LENGTH) {
+          let s1 = obj.substring(0, MAX_STRING_LENGTH / 2);
+          let s2 = obj.substring(obj.length - MAX_STRING_LENGTH / 2);
+          return `${s1} ... ${s2}`;
+        }
+        return obj;
+
+      case "[object Array]":
+        return obj.map(walk);
+
+      // arbitrary object
+      default:
+        if (
+          Object.getOwnPropertyNames(obj).includes("toString") &&
+          typeof obj.toString == "function"
+        ) {
+          return walk(obj.toString());
+        }
+
+        let rv = {};
+        for (let prop in obj) {
+          rv[prop] = walk(obj[prop]);
+        }
+        return rv;
+    }
+  }
+
+  let res = [];
+  for (let i = 0; i < strings.length; ++i) {
+    res.push(strings[i]);
+    if (i < values.length) {
+      let obj = walk(values[i]);
+      let t = Object.prototype.toString.call(obj);
+      if (t == "[object Array]" || t == "[object Object]") {
+        res.push(JSON.stringify(obj));
+      } else {
+        res.push(obj);
+      }
+    }
+  }
+  return res.join("");
+}
diff --git a/remote/shared/Log.sys.mjs b/remote/shared/Log.sys.mjs
new file mode 100644
index 0000000000..e79e9f640f
--- /dev/null
+++ b/remote/shared/Log.sys.mjs
@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+import { Log as StdLog } from "resource://gre/modules/Log.sys.mjs";
+
+const PREF_REMOTE_LOG_LEVEL = "remote.log.level";
+
+const lazy = {};
+
+// Lazy getter which returns a cached value of the remote log level. Should be
+// used for static getters used to guard hot paths for logging, eg
+// isTraceLevelOrMore.
+XPCOMUtils.defineLazyGetter(lazy, "logLevel", () =>
+  Services.prefs.getCharPref(PREF_REMOTE_LOG_LEVEL, StdLog.Level.Fatal)
+);
+
+/** E10s compatible wrapper for the standard logger from Log.sys.mjs. */
+export class Log {
+  static TYPES = {
+    CDP: "CDP",
+    MARIONETTE: "Marionette",
+    REMOTE_AGENT: "RemoteAgent",
+    WEBDRIVER_BIDI: "WebDriver BiDi",
+  };
+
+  /**
+   * Get a logger instance. For each provided type, a dedicated logger instance
+   * will be returned, but all loggers are relying on the same preference.
+   *
+   * @param {string} type
+   *     The type of logger to use. Protocol-specific modules should use the
+   *     corresponding logger type. Eg. files under /marionette should use
+   *     Log.TYPES.MARIONETTE.
+   */
+  static get(type = Log.TYPES.REMOTE_AGENT) {
+    const logger = StdLog.repository.getLogger(type);
+    if (!logger.ownAppenders.length) {
+      logger.addAppender(new StdLog.DumpAppender());
+      logger.manageLevelFromPref(PREF_REMOTE_LOG_LEVEL);
+    }
+    return logger;
+  }
+
+  /**
+   * Check if the current log level matches the Debug log level, or any level
+   * above that. This should be used to guard logger.debug calls and avoid
+   * instanciating logger instances unnecessarily.
+   */
+  static get isDebugLevelOrMore() {
+    // Debug is assigned 20, more verbose log levels have lower values.
+    return StdLog.Level[lazy.logLevel] <= StdLog.Level.Debug;
+  }
+
+  /**
+   * Check if the current log level matches the Trace log level, or any level
+   * above that. This should be used to guard logger.trace calls and avoid
+   * instanciating logger instances unnecessarily.
+   */
+  static get isTraceLevelOrMore() {
+    // Trace is assigned 10, more verbose log levels have lower values.
+    return StdLog.Level[lazy.logLevel] <= StdLog.Level.Trace;
+  }
+
+  static get verbose() {
+    // we can't use Preferences.sys.mjs before first paint,
+    // see ../browser/base/content/test/performance/browser_startup.js
+    const level = Services.prefs.getStringPref(PREF_REMOTE_LOG_LEVEL, "Info");
+    return StdLog.Level[level] >= StdLog.Level.Info;
+  }
+}
diff --git a/remote/shared/MobileTabBrowser.sys.mjs b/remote/shared/MobileTabBrowser.sys.mjs
new file mode 100644
index 0000000000..491b96633e
--- /dev/null
+++ b/remote/shared/MobileTabBrowser.sys.mjs
@@ -0,0 +1,90 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  windowManager: "chrome://remote/content/shared/WindowManager.sys.mjs",
+});
+
+XPCOMUtils.defineLazyModuleGetters(lazy, {
+  GeckoViewTabUtil: "resource://gre/modules/GeckoViewTestUtils.jsm",
+});
+
+// GeckoView shim for Desktop's gBrowser
+export class MobileTabBrowser {
+  constructor(window) {
+    this.window = window;
+  }
+
+  get tabs() {
+    return [this.window.tab];
+  }
+
+  get selectedTab() {
+    return this.window.tab;
+  }
+
+  set selectedTab(tab) {
+    if (tab != this.selectedTab) {
+      throw new Error("GeckoView only supports a single tab");
+    }
+
+    // Synthesize a custom TabSelect event to indicate that a tab has been
+    // selected even when we don't change it.
+    const event = this.window.CustomEvent("TabSelect", {
+      bubbles: true,
+      cancelable: false,
+      detail: {
+        previousTab: this.selectedTab,
+      },
+    });
+    this.window.document.dispatchEvent(event);
+  }
+
+  get selectedBrowser() {
+    return this.selectedTab.linkedBrowser;
+  }
+
+  addEventListener() {
+    this.window.addEventListener(...arguments);
+  }
+
+  /**
+   * Create a new tab.
+   *
+   * @param {string} uriString
+   *     The URI string to load within the newly opened tab.
+   *
+   * @returns {Promise<Tab>}
+   *     The created tab.
+   * @throws {Error}
+   *     Throws an error if the tab cannot be created.
+   */
+  addTab(uriString) {
+    return lazy.GeckoViewTabUtil.createNewTab(uriString);
+  }
+
+  getTabForBrowser(browser) {
+    if (browser != this.selectedBrowser) {
+      throw new Error("GeckoView only supports a single tab");
+    }
+
+    return this.selectedTab;
+  }
+
+  removeEventListener() {
+    this.window.removeEventListener(...arguments);
+  }
+
+  removeTab(tab) {
+    if (tab != this.selectedTab) {
+      throw new Error("GeckoView only supports a single tab");
+    }
+
+    return lazy.windowManager.closeWindow(this.window);
+  }
+}
diff --git a/remote/shared/Navigate.sys.mjs b/remote/shared/Navigate.sys.mjs
new file mode 100644
index 0000000000..ee185f9d24
--- /dev/null
+++ b/remote/shared/Navigate.sys.mjs
@@ -0,0 +1,437 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+import { AppConstants } from "resource://gre/modules/AppConstants.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  clearTimeout: "resource://gre/modules/Timer.sys.mjs",
+  setTimeout: "resource://gre/modules/Timer.sys.mjs",
+
+  Deferred: "chrome://remote/content/shared/Sync.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  truncate: "chrome://remote/content/shared/Format.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () =>
+  lazy.Log.get(lazy.Log.TYPES.REMOTE_AGENT)
+);
+
+// Define a custom multiplier to apply to the unload timer on various platforms.
+// This multiplier should only reflect the navigation performance of the
+// platform and not the overall performance.
+XPCOMUtils.defineLazyGetter(lazy, "UNLOAD_TIMEOUT_MULTIPLIER", () => {
+  if (AppConstants.MOZ_CODE_COVERAGE) {
+    // Navigation on ccov platforms can be extremely slow because new processes
+    // need to be instrumented for coverage on startup.
+    return 16;
+  }
+
+  if (AppConstants.ASAN || AppConstants.DEBUG || AppConstants.TSAN) {
+    // Use an extended timeout on slow platforms.
+    return 8;
+  }
+
+  return 1;
+});
+
+export const DEFAULT_UNLOAD_TIMEOUT = 200;
+
+/**
+ * Returns the multiplier used for the unload timer. Useful for tests which
+ * assert the behavior of this timeout.
+ */
+export function getUnloadTimeoutMultiplier() {
+  return lazy.UNLOAD_TIMEOUT_MULTIPLIER;
+}
+
+// Used to keep weak references of webProgressListeners alive.
+const webProgressListeners = new Set();
+
+/**
+ * Wait until the initial load of the given WebProgress is done.
+ *
+ * @param {WebProgress} webProgress
+ *     The WebProgress instance to observe.
+ * @param {object=} options
+ * @param {boolean=} options.resolveWhenStarted
+ *     Flag to indicate that the Promise has to be resolved when the
+ *     page load has been started. Otherwise wait until the page has
+ *     finished loading. Defaults to `false`.
+ * @param {number=} options.unloadTimeout
+ *     Time to allow before the page gets unloaded. See ProgressListener options.
+ * @returns {Promise}
+ *     Promise which resolves when the page load is in the expected state.
+ *     Values as returned:
+ *       - {nsIURI} currentURI The current URI of the page
+ *       - {nsIURI} targetURI Target URI of the navigation
+ */
+export async function waitForInitialNavigationCompleted(
+  webProgress,
+  options = {}
+) {
+  const { resolveWhenStarted = false, unloadTimeout } = options;
+
+  const browsingContext = webProgress.browsingContext;
+
+  // Start the listener right away to avoid race conditions.
+  const listener = new ProgressListener(webProgress, {
+    resolveWhenStarted,
+    unloadTimeout,
+  });
+  const navigated = listener.start();
+
+  // Right after a browsing context has been attached it could happen that
+  // no window global has been set yet. Consider this as nothing has been
+  // loaded yet.
+  let isInitial = true;
+  if (browsingContext.currentWindowGlobal) {
+    isInitial = browsingContext.currentWindowGlobal.isInitialDocument;
+  }
+
+  // If the current document is not the initial "about:blank" and is also
+  // no longer loading, assume the navigation is done and return.
+  if (!isInitial && !listener.isLoadingDocument) {
+    lazy.logger.trace(
+      lazy.truncate`[${browsingContext.id}] Document already finished loading: ${browsingContext.currentURI?.spec}`
+    );
+
+    // Will resolve the navigated promise.
+    listener.stop();
+  }
+
+  await navigated;
+
+  return {
+    currentURI: listener.currentURI,
+    targetURI: listener.targetURI,
+  };
+}
+
+/**
+ * WebProgressListener to observe for page loads.
+ */
+export class ProgressListener {
+  #expectNavigation;
+  #resolveWhenStarted;
+  #unloadTimeout;
+  #waitForExplicitStart;
+  #webProgress;
+
+  #deferredNavigation;
+  #seenStartFlag;
+  #targetURI;
+  #unloadTimerId;
+
+  /**
+   * Create a new WebProgressListener instance.
+   *
+   * @param {WebProgress} webProgress
+   *     The web progress to attach the listener to.
+   * @param {object=} options
+   * @param {boolean=} options.expectNavigation
+   *     Flag to indicate that a navigation is guaranteed to happen.
+   *     When set to `true`, the ProgressListener will ignore options.unloadTimeout
+   *     and will only resolve when the expected navigation happens.
+   *     Defaults to `false`.
+   * @param {boolean=} options.resolveWhenStarted
+   *     Flag to indicate that the Promise has to be resolved when the
+   *     page load has been started. Otherwise wait until the page has
+   *     finished loading. Defaults to `false`.
+   * @param {number=} options.unloadTimeout
+   *     Time to allow before the page gets unloaded. Defaults to 200ms on
+   *     regular platforms. A multiplier will be applied on slower platforms
+   *     (eg. debug, ccov...).
+   *     Ignored if options.expectNavigation is set to `true`
+   * @param {boolean=} options.waitForExplicitStart
+   *     Flag to indicate that the Promise can only resolve after receiving a
+   *     STATE_START state change. In other words, if the webProgress is already
+   *     navigating, the Promise will only resolve for the next navigation.
+   *     Defaults to `false`.
+   */
+  constructor(webProgress, options = {}) {
+    const {
+      expectNavigation = false,
+      resolveWhenStarted = false,
+      unloadTimeout = DEFAULT_UNLOAD_TIMEOUT,
+      waitForExplicitStart = false,
+    } = options;
+
+    this.#expectNavigation = expectNavigation;
+    this.#resolveWhenStarted = resolveWhenStarted;
+    this.#unloadTimeout = unloadTimeout * lazy.UNLOAD_TIMEOUT_MULTIPLIER;
+    this.#waitForExplicitStart = waitForExplicitStart;
+    this.#webProgress = webProgress;
+
+    this.#deferredNavigation = null;
+    this.#seenStartFlag = false;
+    this.#targetURI = null;
+    this.#unloadTimerId = null;
+  }
+
+  get #messagePrefix() {
+    return `[${this.browsingContext.id}] ${this.constructor.name}`;
+  }
+
+  get browsingContext() {
+    return this.#webProgress.browsingContext;
+  }
+
+  get currentURI() {
+    return this.#webProgress.browsingContext.currentURI;
+  }
+
+  get isLoadingDocument() {
+    return this.#webProgress.isLoadingDocument;
+  }
+
+  get isStarted() {
+    return !!this.#deferredNavigation;
+  }
+
+  get targetURI() {
+    return this.#targetURI;
+  }
+
+  #checkLoadingState(request, options = {}) {
+    const { isStart = false, isStop = false, status = 0 } = options;
+
+    this.#trace(`Check loading state: isStart=${isStart} isStop=${isStop}`);
+    if (isStart && !this.#seenStartFlag) {
+      this.#seenStartFlag = true;
+
+      this.#targetURI = this.#getTargetURI(request);
+
+      this.#trace(`state=start: ${this.targetURI?.spec}`);
+
+      if (this.#unloadTimerId !== null) {
+        lazy.clearTimeout(this.#unloadTimerId);
+        this.#trace("Cleared the unload timer");
+        this.#unloadTimerId = null;
+      }
+
+      if (this.#resolveWhenStarted) {
+        this.#trace("Request to stop listening when navigation started");
+        this.stop();
+        return;
+      }
+    }
+
+    if (isStop && this.#seenStartFlag) {
+      // Treat NS_ERROR_PARSED_DATA_CACHED as a success code
+      // since navigation happened and content has been loaded.
+      if (
+        !Components.isSuccessCode(status) &&
+        status != Cr.NS_ERROR_PARSED_DATA_CACHED
+      ) {
+        if (
+          status == Cr.NS_BINDING_ABORTED &&
+          this.browsingContext.currentWindowGlobal.isInitialDocument
+        ) {
+          this.#trace(
+            "Ignore aborted navigation error to the initial document, real document will be loaded."
+          );
+          return;
+        }
+
+        // The navigation request caused an error.
+        const errorName = ChromeUtils.getXPCOMErrorName(status);
+        this.#trace(
+          `state=stop: error=0x${status.toString(16)} (${errorName})`
+        );
+        this.stop({ error: new Error(errorName) });
+        return;
+      }
+
+      this.#trace(`state=stop: ${this.currentURI.spec}`);
+
+      // If a non initial page finished loading the navigation is done.
+      if (!this.browsingContext.currentWindowGlobal.isInitialDocument) {
+        this.stop();
+        return;
+      }
+
+      // Otherwise wait for a potential additional page load.
+      this.#trace(
+        "Initial document loaded. Wait for a potential further navigation."
+      );
+      this.#seenStartFlag = false;
+      this.#setUnloadTimer();
+    }
+  }
+
+  #getTargetURI(request) {
+    try {
+      return request.QueryInterface(Ci.nsIChannel).originalURI;
+    } catch (e) {}
+
+    return null;
+  }
+
+  #setUnloadTimer() {
+    if (this.#expectNavigation) {
+      this.#trace("Skip setting the unload timer");
+    } else {
+      this.#trace(`Setting unload timer (${this.#unloadTimeout}ms)`);
+
+      this.#unloadTimerId = lazy.setTimeout(() => {
+        this.#trace(`No navigation detected: ${this.currentURI?.spec}`);
+        // Assume the target is the currently loaded URI.
+        this.#targetURI = this.currentURI;
+        this.stop();
+      }, this.#unloadTimeout);
+    }
+  }
+
+  #trace(message) {
+    lazy.logger.trace(lazy.truncate`${this.#messagePrefix} ${message}`);
+  }
+
+  onStateChange(progress, request, flag, status) {
+    this.#checkLoadingState(request, {
+      isStart: flag & Ci.nsIWebProgressListener.STATE_START,
+      isStop: flag & Ci.nsIWebProgressListener.STATE_STOP,
+      status,
+    });
+  }
+
+  onLocationChange(progress, request, location, flag) {
+    // If an error page has been loaded abort the navigation.
+    if (flag & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE) {
+      this.#trace(`location=errorPage: ${location.spec}`);
+      this.stop({ error: new Error("Address restricted") });
+      return;
+    }
+
+    // If location has changed in the same document the navigation is done.
+    if (flag & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT) {
+      this.#targetURI = location;
+      this.#trace(`location=sameDocument: ${this.targetURI?.spec}`);
+      this.stop();
+    }
+  }
+
+  /**
+   * Start observing web progress changes.
+   *
+   * @returns {Promise}
+   *     A promise that will resolve when the navigation has been finished.
+   */
+  start() {
+    if (this.#deferredNavigation) {
+      throw new Error(`Progress listener already started`);
+    }
+
+    this.#trace(
+      `Start: expectNavigation=${this.#expectNavigation} resolveWhenStarted=${
+        this.#resolveWhenStarted
+      } unloadTimeout=${this.#unloadTimeout} waitForExplicitStart=${
+        this.#waitForExplicitStart
+      }`
+    );
+
+    if (this.#webProgress.isLoadingDocument) {
+      this.#targetURI = this.#getTargetURI(this.#webProgress.documentRequest);
+      this.#trace(`Document already loading ${this.#targetURI?.spec}`);
+
+      if (this.#resolveWhenStarted && !this.#waitForExplicitStart) {
+        this.#trace(
+          "Resolve on document loading if not waiting for a load or a new navigation"
+        );
+        return Promise.resolve();
+      }
+    }
+
+    this.#deferredNavigation = new lazy.Deferred();
+
+    // Enable all location change and state notifications to get informed about an upcoming load
+    // as early as possible.
+    this.#webProgress.addProgressListener(
+      this,
+      Ci.nsIWebProgress.NOTIFY_LOCATION | Ci.nsIWebProgress.NOTIFY_STATE_ALL
+    );
+
+    webProgressListeners.add(this);
+
+    if (this.#webProgress.isLoadingDocument && !this.#waitForExplicitStart) {
+      this.#checkLoadingState(this.#webProgress.documentRequest, {
+        isStart: true,
+      });
+    } else {
+      // If the document is not loading yet wait some time for the navigation
+      // to be started.
+      this.#setUnloadTimer();
+    }
+
+    return this.#deferredNavigation.promise;
+  }
+
+  /**
+   * Stop observing web progress changes.
+   *
+   * @param {object=} options
+   * @param {Error=} options.error
+   *     If specified the navigation promise will be rejected with this error.
+   */
+  stop(options = {}) {
+    const { error } = options;
+
+    this.#trace(`Stop: has error=${!!error}`);
+
+    if (!this.#deferredNavigation) {
+      throw new Error("Progress listener not yet started");
+    }
+
+    lazy.clearTimeout(this.#unloadTimerId);
+    this.#unloadTimerId = null;
+
+    this.#webProgress.removeProgressListener(
+      this,
+      Ci.nsIWebProgress.NOTIFY_LOCATION | Ci.nsIWebProgress.NOTIFY_STATE_ALL
+    );
+    webProgressListeners.delete(this);
+
+    if (!this.#targetURI) {
+      // If no target URI has been set yet it should be the current URI
+      this.#targetURI = this.browsingContext.currentURI;
+    }
+
+    if (error) {
+      this.#deferredNavigation.reject(error);
+    } else {
+      this.#deferredNavigation.resolve();
+    }
+
+    this.#deferredNavigation = null;
+  }
+
+  /**
+   * Stop the progress listener if and only if we already detected a navigation
+   * start.
+   *
+   * @param {object=} options
+   * @param {Error=} options.error
+   *     If specified the navigation promise will be rejected with this error.
+   */
+  stopIfStarted(options) {
+    this.#trace(`Stop if started: seenStartFlag=${this.#seenStartFlag}`);
+    if (this.#seenStartFlag) {
+      this.stop(options);
+    }
+  }
+
+  toString() {
+    return `[object ${this.constructor.name}]`;
+  }
+
+  get QueryInterface() {
+    return ChromeUtils.generateQI([
+      "nsIWebProgressListener",
+      "nsISupportsWeakReference",
+    ]);
+  }
+}
diff --git a/remote/shared/PDF.sys.mjs b/remote/shared/PDF.sys.mjs
new file mode 100644
index 0000000000..e0dd2ee060
--- /dev/null
+++ b/remote/shared/PDF.sys.mjs
@@ -0,0 +1,245 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  assert: "chrome://remote/content/shared/webdriver/Assert.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+export const print = {
+  maxScaleValue: 2.0,
+  minScaleValue: 0.1,
+};
+
+print.defaults = {
+  // The size of the page in centimeters.
+  page: {
+    width: 21.59,
+    height: 27.94,
+  },
+  margin: {
+    top: 1.0,
+    bottom: 1.0,
+    left: 1.0,
+    right: 1.0,
+  },
+  orientationValue: ["landscape", "portrait"],
+};
+
+print.addDefaultSettings = function (settings) {
+  const {
+    background = false,
+    margin = {},
+    orientation = "portrait",
+    page = {},
+    pageRanges = [],
+    scale = 1.0,
+    shrinkToFit = true,
+  } = settings;
+
+  lazy.assert.object(page, `Expected "page" to be a object, got ${page}`);
+  lazy.assert.object(margin, `Expected "margin" to be a object, got ${margin}`);
+
+  if (!("width" in page)) {
+    page.width = print.defaults.page.width;
+  }
+
+  if (!("height" in page)) {
+    page.height = print.defaults.page.height;
+  }
+
+  if (!("top" in margin)) {
+    margin.top = print.defaults.margin.top;
+  }
+
+  if (!("bottom" in margin)) {
+    margin.bottom = print.defaults.margin.bottom;
+  }
+
+  if (!("right" in margin)) {
+    margin.right = print.defaults.margin.right;
+  }
+
+  if (!("left" in margin)) {
+    margin.left = print.defaults.margin.left;
+  }
+
+  return {
+    background,
+    margin,
+    orientation,
+    page,
+    pageRanges,
+    scale,
+    shrinkToFit,
+  };
+};
+
+print.getPrintSettings = function (settings) {
+  const psService = Cc["@mozilla.org/gfx/printsettings-service;1"].getService(
+    Ci.nsIPrintSettingsService
+  );
+
+  let cmToInches = cm => cm / 2.54;
+  const printSettings = psService.createNewPrintSettings();
+  printSettings.isInitializedFromPrinter = true;
+  printSettings.isInitializedFromPrefs = true;
+  printSettings.outputFormat = Ci.nsIPrintSettings.kOutputFormatPDF;
+  printSettings.printerName = "marionette";
+  printSettings.printSilent = true;
+
+  // Setting the paperSizeUnit to kPaperSizeMillimeters doesn't work on mac
+  printSettings.paperSizeUnit = Ci.nsIPrintSettings.kPaperSizeInches;
+  printSettings.paperWidth = cmToInches(settings.page.width);
+  printSettings.paperHeight = cmToInches(settings.page.height);
+
+  printSettings.marginBottom = cmToInches(settings.margin.bottom);
+  printSettings.marginLeft = cmToInches(settings.margin.left);
+  printSettings.marginRight = cmToInches(settings.margin.right);
+  printSettings.marginTop = cmToInches(settings.margin.top);
+
+  printSettings.printBGColors = settings.background;
+  printSettings.printBGImages = settings.background;
+  printSettings.scaling = settings.scale;
+  printSettings.shrinkToFit = settings.shrinkToFit;
+
+  printSettings.headerStrCenter = "";
+  printSettings.headerStrLeft = "";
+  printSettings.headerStrRight = "";
+  printSettings.footerStrCenter = "";
+  printSettings.footerStrLeft = "";
+  printSettings.footerStrRight = "";
+
+  // Override any os-specific unwriteable margins
+  printSettings.unwriteableMarginTop = 0;
+  printSettings.unwriteableMarginLeft = 0;
+  printSettings.unwriteableMarginBottom = 0;
+  printSettings.unwriteableMarginRight = 0;
+
+  if (settings.orientation === "landscape") {
+    printSettings.orientation = Ci.nsIPrintSettings.kLandscapeOrientation;
+  }
+
+  if (settings.pageRanges?.length) {
+    printSettings.pageRanges = parseRanges(settings.pageRanges);
+  }
+
+  return printSettings;
+};
+
+/**
+ * Convert array of strings of the form ["1-3", "2-4", "7", "9-"] to an flat array of
+ * limits, like [1, 4, 7, 7, 9, 2**31 - 1] (meaning 1-4, 7, 9-end)
+ *
+ * @param {Array.<string|number>} ranges
+ *     Page ranges to print, e.g., ['1-5', '8', '11-13'].
+ *     Defaults to the empty string, which means print all pages.
+ *
+ * @returns {Array.<number>}
+ *     Even-length array containing page range limits
+ */
+function parseRanges(ranges) {
+  const MAX_PAGES = 0x7fffffff;
+
+  if (ranges.length === 0) {
+    return [];
+  }
+
+  let allLimits = [];
+
+  for (let range of ranges) {
+    let limits;
+    if (typeof range !== "string") {
+      // We got a single integer so the limits are just that page
+      lazy.assert.positiveInteger(range);
+      limits = [range, range];
+    } else {
+      // We got a string presumably of the form <int> | <int>? "-" <int>?
+      const msg = `Expected a range of the form <int> or <int>-<int>, got ${range}`;
+
+      limits = range.split("-").map(x => x.trim());
+      lazy.assert.that(o => [1, 2].includes(o.length), msg)(limits);
+
+      // Single numbers map to a range with that page at the start and the end
+      if (limits.length == 1) {
+        limits.push(limits[0]);
+      }
+
+      // Need to check that both limits are strings conisting only of
+      // decimal digits (or empty strings)
+      const assertNumeric = lazy.assert.that(o => /^\d*$/.test(o), msg);
+      limits.every(x => assertNumeric(x));
+
+      // Convert from strings representing numbers to actual numbers
+      // If we don't have an upper bound, choose something very large;
+      // the print code will later truncate this to the number of pages
+      limits = limits.map((limitStr, i) => {
+        if (limitStr == "") {
+          return i == 0 ? 1 : MAX_PAGES;
+        }
+        return parseInt(limitStr);
+      });
+    }
+    lazy.assert.that(
+      x => x[0] <= x[1],
+      "Lower limit ${parts[0]} is higher than upper limit ${parts[1]}"
+    )(limits);
+
+    allLimits.push(limits);
+  }
+  // Order by lower limit
+  allLimits.sort((a, b) => a[0] - b[0]);
+  let parsedRanges = [allLimits.shift()];
+  for (let limits of allLimits) {
+    let prev = parsedRanges[parsedRanges.length - 1];
+    let prevMax = prev[1];
+    let [min, max] = limits;
+    if (min <= prevMax) {
+      // min is inside previous range, so extend the max if needed
+      if (max > prevMax) {
+        prev[1] = max;
+      }
+    } else {
+      // Otherwise we have a new range
+      parsedRanges.push(limits);
+    }
+  }
+
+  let rv = parsedRanges.flat();
+  lazy.logger.debug(`Got page ranges [${rv.join(", ")}]`);
+  return rv;
+}
+
+print.printToBinaryString = async function (browsingContext, printSettings) {
+  // Create a stream to write to.
+  const stream = Cc["@mozilla.org/storagestream;1"].createInstance(
+    Ci.nsIStorageStream
+  );
+  stream.init(4096, 0xffffffff);
+
+  printSettings.outputDestination =
+    Ci.nsIPrintSettings.kOutputDestinationStream;
+  printSettings.outputStream = stream.getOutputStream(0);
+
+  await browsingContext.print(printSettings);
+
+  const inputStream = Cc["@mozilla.org/binaryinputstream;1"].createInstance(
+    Ci.nsIBinaryInputStream
+  );
+
+  inputStream.setInputStream(stream.newInputStream(0));
+
+  const available = inputStream.available();
+  const bytes = inputStream.readBytes(available);
+
+  stream.close();
+
+  return bytes;
+};
diff --git a/remote/shared/Realm.sys.mjs b/remote/shared/Realm.sys.mjs
new file mode 100644
index 0000000000..986615375f
--- /dev/null
+++ b/remote/shared/Realm.sys.mjs
@@ -0,0 +1,353 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+  addDebuggerToGlobal: "resource://gre/modules/jsdebugger.sys.mjs",
+
+  generateUUID: "chrome://remote/content/shared/UUID.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "dbg", () => {
+  // eslint-disable-next-line mozilla/reject-globalThis-modification
+  lazy.addDebuggerToGlobal(globalThis);
+  return new Debugger();
+});
+
+/**
+ * @typedef {string} RealmType
+ */
+
+/**
+ * Enum of realm types.
+ *
+ * @readonly
+ * @enum {RealmType}
+ */
+export const RealmType = {
+  AudioWorklet: "audio-worklet",
+  DedicatedWorker: "dedicated-worker",
+  PaintWorklet: "paint-worklet",
+  ServiceWorker: "service-worker",
+  SharedWorker: "shared-worker",
+  Window: "window",
+  Worker: "worker",
+  Worklet: "worklet",
+};
+
+/**
+ * Base class that wraps any kind of WebDriver BiDi realm.
+ */
+export class Realm {
+  #handleObjectMap;
+  #id;
+
+  constructor() {
+    this.#id = lazy.generateUUID();
+
+    // Map of unique handles (UUIDs) to objects belonging to this realm.
+    this.#handleObjectMap = new Map();
+  }
+
+  destroy() {
+    this.#handleObjectMap = null;
+  }
+
+  /**
+   * Get the browsing context of the realm instance.
+   */
+  get browsingContext() {
+    return null;
+  }
+
+  /**
+   * Get the unique identifier of the realm instance.
+   *
+   * @returns {string} The unique identifier.
+   */
+  get id() {
+    return this.#id;
+  }
+
+  /**
+   * A getter to get a realm origin.
+   *
+   * It's required to be implemented in the sub class.
+   */
+  get origin() {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Ensure the provided object can be used within this realm.
+
+   * @param {object} obj
+   *     Any non-primitive object.
+
+   * @returns {object}
+   *     An object usable in the current realm.
+   */
+  cloneIntoRealm(obj) {
+    return obj;
+  }
+
+  /**
+   * Remove the reference corresponding to the provided unique handle.
+   *
+   * @param {string} handle
+   *     The unique handle of an object reference tracked in this realm.
+   */
+  removeObjectHandle(handle) {
+    this.#handleObjectMap.delete(handle);
+  }
+
+  /**
+   * Get a new unique handle for the provided object, creating a strong
+   * reference on the object.
+   *
+   * @param {object} object
+   *     Any non-primitive object.
+   * @returns {string} The unique handle created for this strong reference.
+   */
+  getHandleForObject(object) {
+    const handle = lazy.generateUUID();
+    this.#handleObjectMap.set(handle, object);
+    return handle;
+  }
+
+  /**
+   * Get the basic realm information.
+   *
+   * @returns {BaseRealmInfo}
+   */
+  getInfo() {
+    return {
+      realm: this.#id,
+      origin: this.origin,
+    };
+  }
+
+  /**
+   * Retrieve the object corresponding to the provided unique handle.
+   *
+   * @param {string} handle
+   *     The unique handle of an object reference tracked in this realm.
+   * @returns {object} object
+   *     Any non-primitive object.
+   */
+  getObjectForHandle(handle) {
+    return this.#handleObjectMap.get(handle);
+  }
+}
+
+/**
+ * Wrapper for Window realms including sandbox objects.
+ */
+export class WindowRealm extends Realm {
+  #realmAutomationFeaturesEnabled;
+  #globalObject;
+  #globalObjectReference;
+  #sandboxName;
+  #window;
+
+  static type = RealmType.Window;
+
+  /**
+   *
+   * @param {Window} window
+   *     The window global to wrap.
+   * @param {object} options
+   * @param {string=} options.sandboxName
+   *     Name of the sandbox to create if specified. Defaults to `null`.
+   */
+  constructor(window, options = {}) {
+    const { sandboxName = null } = options;
+
+    super();
+
+    this.#sandboxName = sandboxName;
+    this.#window = window;
+    this.#globalObject =
+      sandboxName === null ? this.#window : this.#createSandbox();
+    this.#globalObjectReference = lazy.dbg.makeGlobalObjectReference(
+      this.#globalObject
+    );
+    this.#realmAutomationFeaturesEnabled = false;
+  }
+
+  destroy() {
+    if (this.#realmAutomationFeaturesEnabled) {
+      lazy.dbg.disableAsyncStack(this.#globalObject);
+      lazy.dbg.disableUnlimitedStacksCapturing(this.#globalObject);
+      this.#realmAutomationFeaturesEnabled = false;
+    }
+
+    this.#globalObjectReference = null;
+    this.#globalObject = null;
+    this.#window = null;
+
+    super.destroy();
+  }
+
+  get browsingContext() {
+    return this.#window.browsingContext;
+  }
+
+  get globalObjectReference() {
+    return this.#globalObjectReference;
+  }
+
+  get origin() {
+    return this.#window.origin;
+  }
+
+  #createDebuggerObject(obj) {
+    return this.#globalObjectReference.makeDebuggeeValue(obj);
+  }
+
+  #createSandbox() {
+    const win = this.#window;
+    const opts = {
+      sameZoneAs: win,
+      sandboxPrototype: win,
+      wantComponents: false,
+      wantXrays: true,
+    };
+
+    return new Cu.Sandbox(win, opts);
+  }
+
+  #enableRealmAutomationFeatures() {
+    if (!this.#realmAutomationFeaturesEnabled) {
+      lazy.dbg.enableAsyncStack(this.#globalObject);
+      lazy.dbg.enableUnlimitedStacksCapturing(this.#globalObject);
+      this.#realmAutomationFeaturesEnabled = true;
+    }
+  }
+
+  /**
+   * Clone the provided object into the scope of this Realm (either a window
+   * global, or a sandbox).
+   *
+   * @param {object} obj
+   *     Any non-primitive object.
+   *
+   * @returns {object}
+   *     The cloned object.
+   */
+  cloneIntoRealm(obj) {
+    return Cu.cloneInto(obj, this.#globalObject, { cloneFunctions: true });
+  }
+
+  /**
+   * Evaluates a provided expression in the context of the current realm.
+   *
+   * @param {string} expression
+   *     The expression to evaluate.
+   *
+   * @returns {object}
+   *     - evaluationStatus {EvaluationStatus} One of "normal", "throw".
+   *     - exceptionDetails {ExceptionDetails=} the details of the exception if
+   *       the evaluation status was "throw".
+   *     - result {RemoteValue=} the result of the evaluation serialized as a
+   *       RemoteValue if the evaluation status was "normal".
+   */
+  executeInGlobal(expression) {
+    this.#enableRealmAutomationFeatures();
+    return this.#globalObjectReference.executeInGlobal(expression, {
+      url: this.#window.document.baseURI,
+    });
+  }
+
+  /**
+   * Call a function in the context of the current realm.
+   *
+   * @param {string} functionDeclaration
+   *     The body of the function to call.
+   * @param {Array<object>} functionArguments
+   *     The arguments to pass to the function call.
+   * @param {object} thisParameter
+   *     The value of the `this` keyword for the function call.
+   *
+   * @returns {object}
+   *     - evaluationStatus {EvaluationStatus} One of "normal", "throw".
+   *     - exceptionDetails {ExceptionDetails=} the details of the exception if
+   *       the evaluation status was "throw".
+   *     - result {RemoteValue=} the result of the evaluation serialized as a
+   *       RemoteValue if the evaluation status was "normal".
+   */
+  executeInGlobalWithBindings(
+    functionDeclaration,
+    functionArguments,
+    thisParameter
+  ) {
+    this.#enableRealmAutomationFeatures();
+    const expression = `(${functionDeclaration}).apply(__bidi_this, __bidi_args)`;
+
+    const args = this.cloneIntoRealm([]);
+    for (const arg of functionArguments) {
+      args.push(arg);
+    }
+
+    return this.#globalObjectReference.executeInGlobalWithBindings(
+      expression,
+      {
+        __bidi_args: this.#createDebuggerObject(args),
+        __bidi_this: this.#createDebuggerObject(thisParameter),
+      },
+      {
+        url: this.#window.document.baseURI,
+      }
+    );
+  }
+
+  /**
+   * Get the realm information.
+   *
+   * @returns {object}
+   *     - context {BrowsingContext} The browsing context, associated with the realm.
+   *     - id {string} The realm unique identifier.
+   *     - origin {string} The serialization of an origin.
+   *     - sandbox {string|null} The name of the sandbox.
+   *     - type {RealmType.Window} The window realm type.
+   */
+  getInfo() {
+    const baseInfo = super.getInfo();
+    return {
+      ...baseInfo,
+      context: this.#window.browsingContext,
+      sandbox: this.#sandboxName,
+      type: WindowRealm.type,
+    };
+  }
+
+  /**
+   * Log an error caused by a script evaluation.
+   *
+   * @param {string} message
+   *     The error message.
+   * @param {Stack} stack
+   *     The JavaScript stack trace.
+   */
+  reportError(message, stack) {
+    const { column, line, source: sourceLine } = stack;
+
+    const scriptErrorClass = Cc["@mozilla.org/scripterror;1"];
+    const scriptError = scriptErrorClass.createInstance(Ci.nsIScriptError);
+
+    scriptError.initWithWindowID(
+      message,
+      this.#window.document.baseURI,
+      sourceLine,
+      line,
+      column,
+      Ci.nsIScriptError.errorFlag,
+      "content javascript",
+      this.#window.windowGlobalChild.innerWindowId
+    );
+    Services.console.logMessage(scriptError);
+  }
+}
diff --git a/remote/shared/RecommendedPreferences.sys.mjs b/remote/shared/RecommendedPreferences.sys.mjs
new file mode 100644
index 0000000000..27991e2332
--- /dev/null
+++ b/remote/shared/RecommendedPreferences.sys.mjs
@@ -0,0 +1,428 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Preferences: "resource://gre/modules/Preferences.sys.mjs",
+
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyPreferenceGetter(
+  lazy,
+  "useRecommendedPrefs",
+  "remote.prefs.recommended",
+  false
+);
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+// Ensure we are in the parent process.
+if (Services.appinfo.processType != Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT) {
+  throw new Error(
+    "RecommendedPreferences should only be loaded in the parent process"
+  );
+}
+
+// ALL CHANGES TO THIS LIST MUST HAVE REVIEW FROM A WEBDRIVER PEER!
+//
+// Preferences are set for automation on startup, unless
+// remote.prefs.recommended has been set to false.
+//
+// Note: Clients do not always use the latest version of the application. As
+// such backward compatibility has to be ensured at least for the last three
+// releases.
+
+// INSTRUCTIONS TO ADD A NEW PREFERENCE
+//
+// Preferences for remote control and automation can be set from several entry
+// points:
+// - remote/shared/RecommendedPreferences.sys.mjs
+// - remote/test/puppeteer/packages/browsers/src/browser-data/firefox.ts
+// - testing/geckodriver/src/prefs.rs
+// - testing/marionette/client/marionette_driver/geckoinstance.py
+//
+// The preferences in `firefox.ts`, `prefs.rs` and `geckoinstance.py`
+// will be applied before the application starts, and should typically be used
+// for preferences which cannot be updated during the lifetime of the application.
+//
+// The preferences in `RecommendedPreferences.sys.mjs` are applied after
+// the application has started, which means that the application must apply this
+// change dynamically and behave correctly. Note that you can also define
+// protocol specific preferences (CDP, WebDriver, ...) which are merged with the
+// COMMON_PREFERENCES from `RecommendedPreferences.sys.mjs`.
+//
+// Additionally, users relying on the Marionette Python client (ie. using
+// geckoinstance.py) set `remote.prefs.recommended = false`. This means that
+// preferences from `RecommendedPreferences.sys.mjs` are not applied and have to
+// be added to the list of preferences in that Python file. Note that there are
+// several lists of preferences, either common or specific to a given application
+// (Firefox Desktop, Fennec, Thunderbird).
+//
+// Depending on how users interact with the Remote Agent, they will use different
+// combinations of preferences. So it's important to update the preferences files
+// so that all users have the proper preferences.
+//
+// When adding a new preference, follow this guide to decide where to add it:
+// - Add the preference to `geckoinstance.py`
+// - If the preference has to be set before startup:
+//   - Add the preference to `prefs.rs`
+//   - Add the preference `browser-data/firefox.ts` in the puppeteer folder
+//   - Create a PR to upstream the change on `browser-data/firefox.ts` to puppeteer
+// - Otherwise, if the preference can be set after startup:
+//   - Add the preference to `RecommendedPreferences.sys.mjs`
+const COMMON_PREFERENCES = new Map([
+  // Make sure Shield doesn't hit the network.
+  ["app.normandy.api_url", ""],
+
+  // Disable automatically upgrading Firefox
+  //
+  // Note: This preference should have already been set by the client when
+  // creating the profile. But if not and to absolutely make sure that updates
+  // of Firefox aren't downloaded and applied, enforce its presence.
+  ["app.update.disabledForTesting", true],
+
+  // Increase the APZ content response timeout in tests to 1 minute.
+  // This is to accommodate the fact that test environments tends to be
+  // slower than production environments (with the b2g emulator being
+  // the slowest of them all), resulting in the production timeout value
+  // sometimes being exceeded and causing false-positive test failures.
+  //
+  // (bug 1176798, bug 1177018, bug 1210465)
+  ["apz.content_response_timeout", 60000],
+
+  // Don't show the content blocking introduction panel.
+  // We use a larger number than the default 22 to have some buffer
+  // This can be removed once Firefox 69 and 68 ESR and are no longer supported.
+  ["browser.contentblocking.introCount", 99],
+
+  // Indicate that the download panel has been shown once so that
+  // whichever download test runs first doesn't show the popup
+  // inconsistently.
+  ["browser.download.panel.shown", true],
+
+  // Always display a blank page
+  ["browser.newtabpage.enabled", false],
+
+  // Background thumbnails in particular cause grief, and disabling
+  // thumbnails in general cannot hurt
+  ["browser.pagethumbnails.capturing_disabled", true],
+
+  // Disable geolocation ping(#1)
+  ["browser.region.network.url", ""],
+
+  // Disable safebrowsing components.
+  //
+  // These should also be set in the profile prior to starting Firefox,
+  // as it is picked up at runtime.
+  ["browser.safebrowsing.blockedURIs.enabled", false],
+  ["browser.safebrowsing.downloads.enabled", false],
+  ["browser.safebrowsing.malware.enabled", false],
+  ["browser.safebrowsing.passwords.enabled", false],
+  ["browser.safebrowsing.phishing.enabled", false],
+
+  // Disable updates to search engines.
+  //
+  // Should be set in profile.
+  ["browser.search.update", false],
+
+  // Do not restore the last open set of tabs if the browser has crashed
+  ["browser.sessionstore.resume_from_crash", false],
+
+  // Don't check for the default web browser during startup.
+  //
+  // These should also be set in the profile prior to starting Firefox,
+  // as it is picked up at runtime.
+  ["browser.shell.checkDefaultBrowser", false],
+
+  // Disable session restore infobar
+  ["browser.startup.couldRestoreSession.count", -1],
+
+  // Do not redirect user when a milstone upgrade of Firefox is detected
+  ["browser.startup.homepage_override.mstone", "ignore"],
+
+  // Do not close the window when the last tab gets closed
+  ["browser.tabs.closeWindowWithLastTab", false],
+
+  // Do not allow background tabs to be zombified on Android, otherwise for
+  // tests that open additional tabs, the test harness tab itself might get
+  // unloaded
+  ["browser.tabs.disableBackgroundZombification", false],
+
+  // Don't unload tabs when available memory is running low
+  ["browser.tabs.unloadOnLowMemory", false],
+
+  // Do not warn when closing all open tabs
+  ["browser.tabs.warnOnClose", false],
+
+  // Do not warn when closing all other open tabs
+  ["browser.tabs.warnOnCloseOtherTabs", false],
+
+  // Do not warn when multiple tabs will be opened
+  ["browser.tabs.warnOnOpen", false],
+
+  // Don't show the Bookmarks Toolbar on any tab (the above pref that
+  // disables the New Tab Page ends up showing the toolbar on about:blank).
+  ["browser.toolbars.bookmarks.visibility", "never"],
+
+  // Make sure Topsites doesn't hit the network to retrieve tiles from Contile.
+  ["browser.topsites.contile.enabled", false],
+
+  // Disable first run splash page on Windows 10
+  ["browser.usedOnWindows10.introURL", ""],
+
+  // Turn off Merino suggestions in the location bar so as not to trigger
+  // network connections.
+  ["browser.urlbar.merino.endpointURL", ""],
+
+  // Turn off search suggestions in the location bar so as not to trigger
+  // network connections.
+  ["browser.urlbar.suggest.searches", false],
+
+  // Do not warn on quitting Firefox
+  ["browser.warnOnQuit", false],
+
+  // Do not show datareporting policy notifications which can
+  // interfere with tests
+  [
+    "datareporting.healthreport.documentServerURI",
+    "http://%(server)s/dummy/healthreport/",
+  ],
+  ["datareporting.healthreport.logging.consoleEnabled", false],
+  ["datareporting.healthreport.service.enabled", false],
+  ["datareporting.healthreport.service.firstRun", false],
+  ["datareporting.healthreport.uploadEnabled", false],
+  ["datareporting.policy.dataSubmissionEnabled", false],
+  ["datareporting.policy.dataSubmissionPolicyAccepted", false],
+  ["datareporting.policy.dataSubmissionPolicyBypassNotification", true],
+
+  // Disable popup-blocker
+  ["dom.disable_open_during_load", false],
+
+  // Enabling the support for File object creation in the content process
+  ["dom.file.createInChild", true],
+
+  // Disable delayed user input event handling
+  ["dom.input_events.security.minNumTicks", 0],
+  ["dom.input_events.security.minTimeElapsedInMS", 0],
+
+  // Disable the ProcessHangMonitor
+  ["dom.ipc.reportProcessHangs", false],
+
+  // Disable slow script dialogues
+  ["dom.max_chrome_script_run_time", 0],
+  ["dom.max_script_run_time", 0],
+
+  // Disable location change rate limitation
+  ["dom.navigation.locationChangeRateLimit.count", 0],
+
+  // DOM Push
+  ["dom.push.connection.enabled", false],
+
+  // Screen Orientation API
+  ["dom.screenorientation.allow-lock", true],
+
+  // Disable dialog abuse if alerts are triggered too quickly.
+  ["dom.successive_dialog_time_limit", 0],
+
+  // Only load extensions from the application and user profile
+  // AddonManager.SCOPE_PROFILE + AddonManager.SCOPE_APPLICATION
+  //
+  // Should be set in profile.
+  ["extensions.autoDisableScopes", 0],
+  ["extensions.enabledScopes", 5],
+
+  // Disable metadata caching for installed add-ons by default
+  ["extensions.getAddons.cache.enabled", false],
+
+  // Disable installing any distribution extensions or add-ons.
+  // Should be set in profile.
+  ["extensions.installDistroAddons", false],
+
+  // Turn off extension updates so they do not bother tests
+  ["extensions.update.enabled", false],
+  ["extensions.update.notifyUser", false],
+
+  // Make sure opening about:addons will not hit the network
+  ["extensions.getAddons.discovery.api_url", "data:, "],
+
+  // Redirect various extension update URLs
+  [
+    "extensions.blocklist.detailsURL",
+    "http://%(server)s/extensions-dummy/blocklistDetailsURL",
+  ],
+  [
+    "extensions.blocklist.itemURL",
+    "http://%(server)s/extensions-dummy/blocklistItemURL",
+  ],
+  ["extensions.hotfix.url", "http://%(server)s/extensions-dummy/hotfixURL"],
+  [
+    "extensions.systemAddon.update.url",
+    "http://%(server)s/dummy-system-addons.xml",
+  ],
+  [
+    "extensions.update.background.url",
+    "http://%(server)s/extensions-dummy/updateBackgroundURL",
+  ],
+  ["extensions.update.url", "http://%(server)s/extensions-dummy/updateURL"],
+
+  // Make sure opening about: addons won't hit the network
+  ["extensions.getAddons.discovery.api_url", "data:, "],
+  [
+    "extensions.getAddons.get.url",
+    "http://%(server)s/extensions-dummy/repositoryGetURL",
+  ],
+  [
+    "extensions.getAddons.search.browseURL",
+    "http://%(server)s/extensions-dummy/repositoryBrowseURL",
+  ],
+
+  // Allow the application to have focus even it runs in the background
+  ["focusmanager.testmode", true],
+
+  // Disable useragent updates
+  ["general.useragent.updates.enabled", false],
+
+  // Disable geolocation ping(#2)
+  ["geo.provider.network.url", ""],
+
+  // Always use network provider for geolocation tests so we bypass the
+  // macOS dialog raised by the corelocation provider
+  ["geo.provider.testing", true],
+
+  // Do not scan Wifi
+  ["geo.wifi.scan", false],
+
+  // Disable Firefox accounts ping
+  ["identity.fxaccounts.auth.uri", "https://{server}/dummy/fxa"],
+
+  // Disable connectivity service pings
+  ["network.connectivity-service.enabled", false],
+
+  // Do not prompt with long usernames or passwords in URLs
+  ["network.http.phishy-userpass-length", 255],
+
+  // Do not prompt for temporary redirects
+  ["network.http.prompt-temp-redirect", false],
+
+  // Do not automatically switch between offline and online
+  ["network.manage-offline-status", false],
+
+  // Make sure SNTP requests do not hit the network
+  ["network.sntp.pools", "%(server)s"],
+
+  // Privacy and Tracking Protection
+  ["privacy.trackingprotection.enabled", false],
+
+  // Don't do network connections for mitm priming
+  ["security.certerrors.mitm.priming.enabled", false],
+
+  // Local documents have access to all other local documents,
+  // including directory listings
+  ["security.fileuri.strict_origin_policy", false],
+
+  // Tests do not wait for the notification button security delay
+  ["security.notification_enable_delay", 0],
+
+  // Do not download intermediate certificates
+  ["security.remote_settings.intermediates.enabled", false],
+
+  // Ensure remote settings do not hit the network
+  ["services.settings.server", "data:,#remote-settings-dummy/v1"],
+
+  // Do not automatically fill sign-in forms with known usernames and
+  // passwords
+  ["signon.autofillForms", false],
+
+  // Disable password capture, so that tests that include forms are not
+  // influenced by the presence of the persistent doorhanger notification
+  ["signon.rememberSignons", false],
+
+  // Disable first-run welcome page
+  ["startup.homepage_welcome_url", "about:blank"],
+  ["startup.homepage_welcome_url.additional", ""],
+
+  // Prevent starting into safe mode after application crashes
+  ["toolkit.startup.max_resumed_crashes", -1],
+
+  // Disable all telemetry pings
+  ["toolkit.telemetry.server", "https://%(server)s/telemetry-dummy/"],
+
+  // Disable window occlusion on Windows, which can prevent webdriver commands
+  // such as WebDriver:FindElements from working properly (Bug 1802473).
+  ["widget.windows.window_occlusion_tracking.enabled", false],
+]);
+
+export const RecommendedPreferences = {
+  alteredPrefs: new Set(),
+
+  isInitialized: false,
+
+  /**
+   * Apply the provided map of preferences.
+   * They will be automatically reset on application shutdown.
+   *
+   * @param {Map} preferences
+   *     Map of preference key to preference value.
+   */
+  applyPreferences(preferences) {
+    if (!lazy.useRecommendedPrefs) {
+      // If remote.prefs.recommended is set to false, do not set any preference
+      // here. Needed for our Firefox CI.
+      return;
+    }
+
+    // Only apply common recommended preferences on first call to
+    // applyPreferences.
+    if (!this.isInitialized) {
+      // Merge common preferences and provided preferences in a single map.
+      preferences = new Map([...COMMON_PREFERENCES, ...preferences]);
+      Services.obs.addObserver(this, "quit-application");
+      this.isInitialized = true;
+    }
+
+    for (const [k, v] of preferences) {
+      if (!lazy.Preferences.isSet(k)) {
+        lazy.logger.debug(`Setting recommended pref ${k} to ${v}`);
+        lazy.Preferences.set(k, v);
+
+        // Keep track all the altered preferences to restore them on
+        // quit-application.
+        this.alteredPrefs.add(k);
+      }
+    }
+  },
+
+  observe(subject, topic) {
+    if (topic === "quit-application") {
+      Services.obs.removeObserver(this, "quit-application");
+      this.restoreAllPreferences();
+    }
+  },
+
+  /**
+   * Restore all the altered preferences.
+   */
+  restoreAllPreferences() {
+    this.restorePreferences(this.alteredPrefs);
+    this.isInitialized = false;
+  },
+
+  /**
+   * Restore provided preferences.
+   *
+   * @param {Map} preferences
+   *     Map of preferences that should be restored.
+   */
+  restorePreferences(preferences) {
+    for (const k of preferences.keys()) {
+      lazy.logger.debug(`Resetting recommended pref ${k}`);
+      lazy.Preferences.reset(k);
+      this.alteredPrefs.delete(k);
+    }
+  },
+};
diff --git a/remote/shared/RemoteError.sys.mjs b/remote/shared/RemoteError.sys.mjs
new file mode 100644
index 0000000000..2e326d5d18
--- /dev/null
+++ b/remote/shared/RemoteError.sys.mjs
@@ -0,0 +1,19 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Base class for all remote protocol errors.
+ */
+export class RemoteError extends Error {
+  get isRemoteError() {
+    return true;
+  }
+
+  /**
+   * Convert to a serializable object. Should be implemented by subclasses.
+   */
+  toJSON() {
+    throw new Error("Not implemented");
+  }
+}
diff --git a/remote/shared/Stack.sys.mjs b/remote/shared/Stack.sys.mjs
new file mode 100644
index 0000000000..d0c7f9407d
--- /dev/null
+++ b/remote/shared/Stack.sys.mjs
@@ -0,0 +1,73 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * An object that contains details of a stack frame.
+ *
+ * @typedef {object} StackFrame
+ * @see nsIStackFrame
+ *
+ * @property {string=} asyncCause
+ *     Type of asynchronous call by which this frame was invoked.
+ * @property {number} columnNumber
+ *     The column number for this stack frame.
+ * @property {string} filename
+ *     The source URL for this stack frame.
+ * @property {string} function
+ *     SpiderMonkey’s inferred name for this stack frame’s function, or null.
+ * @property {number} lineNumber
+ *     The line number for this stack frame (starts with 1).
+ * @property {number} sourceId
+ *     The process-unique internal integer ID of this source.
+ */
+
+/**
+ * Return a list of stack frames from the given stack.
+ *
+ * Convert stack objects to the JSON attributes expected by consumers.
+ *
+ * @param {object} stack
+ *     The native stack object to process.
+ *
+ * @returns {Array<StackFrame>=}
+ */
+export function getFramesFromStack(stack) {
+  if (!stack || (Cu && Cu.isDeadWrapper(stack))) {
+    // If the global from which this error came from has been nuked,
+    // stack is going to be a dead wrapper.
+    return null;
+  }
+
+  const frames = [];
+  while (stack) {
+    frames.push({
+      asyncCause: stack.asyncCause,
+      columnNumber: stack.column,
+      filename: stack.source,
+      functionName: stack.functionDisplayName || "",
+      lineNumber: stack.line,
+      sourceId: stack.sourceId,
+    });
+
+    stack = stack.parent || stack.asyncParent;
+  }
+
+  return frames;
+}
+
+/**
+ * Check if a frame is from chrome scope.
+ *
+ * @param {object} frame
+ *     The frame to check
+ *
+ * @returns {boolean}
+ *     True, if frame is from chrome scope
+ */
+export function isChromeFrame(frame) {
+  return (
+    frame.filename.startsWith("chrome://") ||
+    frame.filename.startsWith("resource://")
+  );
+}
diff --git a/remote/shared/Sync.sys.mjs b/remote/shared/Sync.sys.mjs
new file mode 100644
index 0000000000..a76d5d4242
--- /dev/null
+++ b/remote/shared/Sync.sys.mjs
@@ -0,0 +1,324 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+const { TYPE_ONE_SHOT, TYPE_REPEATING_SLACK } = Ci.nsITimer;
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () =>
+  lazy.Log.get(lazy.Log.TYPES.REMOTE_AGENT)
+);
+
+/**
+ * Throttle until the `window` has performed an animation frame.
+ *
+ * @param {ChromeWindow} win
+ *     Window to request the animation frame from.
+ *
+ * @returns {Promise}
+ */
+export function AnimationFramePromise(win) {
+  const animationFramePromise = new Promise(resolve => {
+    win.requestAnimationFrame(resolve);
+  });
+
+  // Abort if the underlying window gets closed
+  const windowClosedPromise = new PollPromise(resolve => {
+    if (win.closed) {
+      resolve();
+    }
+  });
+
+  return Promise.race([animationFramePromise, windowClosedPromise]);
+}
+
+/**
+ * Create a helper object to defer a promise.
+ *
+ * @returns {object}
+ *     An object that returns the following properties:
+ *       - fulfilled Flag that indicates that the promise got resolved
+ *       - pending Flag that indicates a not yet fulfilled/rejected promise
+ *       - promise The actual promise
+ *       - reject Callback to reject the promise
+ *       - rejected Flag that indicates that the promise got rejected
+ *       - resolve Callback to resolve the promise
+ */
+export function Deferred() {
+  const deferred = {};
+
+  deferred.promise = new Promise((resolve, reject) => {
+    deferred.fulfilled = false;
+    deferred.pending = true;
+    deferred.rejected = false;
+
+    deferred.resolve = (...args) => {
+      deferred.fulfilled = true;
+      deferred.pending = false;
+      resolve(...args);
+    };
+
+    deferred.reject = (...args) => {
+      deferred.pending = false;
+      deferred.rejected = true;
+      reject(...args);
+    };
+  });
+
+  return deferred;
+}
+
+/**
+ * Wait for an event to be fired on a specified element.
+ *
+ * The returned promise is guaranteed to not resolve before the
+ * next event tick after the event listener is called, so that all
+ * other event listeners for the element are executed before the
+ * handler is executed.  For example:
+ *
+ *     const promise = new EventPromise(element, "myEvent");
+ *     // same event tick here
+ *     await promise;
+ *     // next event tick here
+ *
+ * @param {Element} subject
+ *     The element that should receive the event.
+ * @param {string} eventName
+ *     Case-sensitive string representing the event name to listen for.
+ * @param {object=} options
+ * @param {boolean=} options.capture
+ *     Indicates the event will be despatched to this subject,
+ *     before it bubbles down to any EventTarget beneath it in the
+ *     DOM tree. Defaults to false.
+ * @param {Function=} options.checkFn
+ *     Called with the Event object as argument, should return true if the
+ *     event is the expected one, or false if it should be ignored and
+ *     listening should continue. If not specified, the first event with
+ *     the specified name resolves the returned promise. Defaults to null.
+ * @param {number=} options.timeout
+ *     Timeout duration in milliseconds, if provided.
+ *     If specified, then the returned promise will be rejected with
+ *     TimeoutError, if not already resolved, after this duration has elapsed.
+ *     If not specified, then no timeout is used. Defaults to null.
+ * @param {boolean=} options.mozSystemGroup
+ *     Determines whether to add listener to the system group. Defaults to
+ *     false.
+ * @param {boolean=} options.wantUntrusted
+ *     Receive synthetic events despatched by web content. Defaults to false.
+ *
+ * @returns {Promise<Event>}
+ *     Either fulfilled with the first described event, satisfying
+ *     options.checkFn if specified, or rejected with TimeoutError after
+ *     options.timeout milliseconds if specified.
+ *
+ * @throws {TypeError}
+ * @throws {RangeError}
+ */
+export function EventPromise(subject, eventName, options = {}) {
+  const {
+    capture = false,
+    checkFn = null,
+    timeout = null,
+    mozSystemGroup = false,
+    wantUntrusted = false,
+  } = options;
+  if (
+    !subject ||
+    !("addEventListener" in subject) ||
+    typeof eventName != "string" ||
+    typeof capture != "boolean" ||
+    (checkFn && typeof checkFn != "function") ||
+    (timeout !== null && typeof timeout != "number") ||
+    typeof mozSystemGroup != "boolean" ||
+    typeof wantUntrusted != "boolean"
+  ) {
+    throw new TypeError();
+  }
+  if (timeout < 0) {
+    throw new RangeError();
+  }
+
+  return new Promise((resolve, reject) => {
+    let timer;
+
+    function cleanUp() {
+      subject.removeEventListener(eventName, listener, capture);
+      timer?.cancel();
+    }
+
+    function listener(event) {
+      lazy.logger.trace(`Received DOM event ${event.type} for ${event.target}`);
+      try {
+        if (checkFn && !checkFn(event)) {
+          return;
+        }
+      } catch (e) {
+        // Treat an exception in the callback as a falsy value
+        lazy.logger.warn(`Event check failed: ${e.message}`);
+      }
+
+      cleanUp();
+      executeSoon(() => resolve(event));
+    }
+
+    subject.addEventListener(eventName, listener, {
+      capture,
+      mozSystemGroup,
+      wantUntrusted,
+    });
+
+    if (timeout !== null) {
+      timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+      timer.init(
+        () => {
+          cleanUp();
+          reject(
+            new lazy.error.TimeoutError(
+              `EventPromise timed out after ${timeout} ms`
+            )
+          );
+        },
+        timeout,
+        TYPE_ONE_SHOT
+      );
+    }
+  });
+}
+
+/**
+ * Wait for the next tick in the event loop to execute a callback.
+ *
+ * @param {Function} fn
+ *     Function to be executed.
+ */
+export function executeSoon(fn) {
+  if (typeof fn != "function") {
+    throw new TypeError();
+  }
+
+  Services.tm.dispatchToMainThread(fn);
+}
+
+/**
+ * Runs a Promise-like function off the main thread until it is resolved
+ * through ``resolve`` or ``rejected`` callbacks.  The function is
+ * guaranteed to be run at least once, irregardless of the timeout.
+ *
+ * The ``func`` is evaluated every ``interval`` for as long as its
+ * runtime duration does not exceed ``interval``.  Evaluations occur
+ * sequentially, meaning that evaluations of ``func`` are queued if
+ * the runtime evaluation duration of ``func`` is greater than ``interval``.
+ *
+ * ``func`` is given two arguments, ``resolve`` and ``reject``,
+ * of which one must be called for the evaluation to complete.
+ * Calling ``resolve`` with an argument indicates that the expected
+ * wait condition was met and will return the passed value to the
+ * caller.  Conversely, calling ``reject`` will evaluate ``func``
+ * again until the ``timeout`` duration has elapsed or ``func`` throws.
+ * The passed value to ``reject`` will also be returned to the caller
+ * once the wait has expired.
+ *
+ * Usage::
+ *
+ *     let els = new PollPromise((resolve, reject) => {
+ *       let res = document.querySelectorAll("p");
+ *       if (res.length > 0) {
+ *         resolve(Array.from(res));
+ *       } else {
+ *         reject([]);
+ *       }
+ *     }, {timeout: 1000});
+ *
+ * @param {Condition} func
+ *     Function to run off the main thread.
+ * @param {object=} options
+ * @param {number=} options.timeout
+ *     Desired timeout if wanted.  If 0 or less than the runtime evaluation
+ *     time of ``func``, ``func`` is guaranteed to run at least once.
+ *     Defaults to using no timeout.
+ * @param {number=} options.interval
+ *     Duration between each poll of ``func`` in milliseconds.
+ *     Defaults to 10 milliseconds.
+ *
+ * @returns {Promise.<*>}
+ *     Yields the value passed to ``func``'s
+ *     ``resolve`` or ``reject`` callbacks.
+ *
+ * @throws {*}
+ *     If ``func`` throws, its error is propagated.
+ * @throws {TypeError}
+ *     If `timeout` or `interval`` are not numbers.
+ * @throws {RangeError}
+ *     If `timeout` or `interval` are not unsigned integers.
+ */
+export function PollPromise(func, { timeout = null, interval = 10 } = {}) {
+  const timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+
+  if (typeof func != "function") {
+    throw new TypeError();
+  }
+  if (timeout != null && typeof timeout != "number") {
+    throw new TypeError();
+  }
+  if (typeof interval != "number") {
+    throw new TypeError();
+  }
+  if (
+    (timeout && (!Number.isInteger(timeout) || timeout < 0)) ||
+    !Number.isInteger(interval) ||
+    interval < 0
+  ) {
+    throw new RangeError();
+  }
+
+  return new Promise((resolve, reject) => {
+    let start, end;
+
+    if (Number.isInteger(timeout)) {
+      start = new Date().getTime();
+      end = start + timeout;
+    }
+
+    let evalFn = () => {
+      new Promise(func)
+        .then(resolve, rejected => {
+          if (typeof rejected != "undefined") {
+            throw rejected;
+          }
+
+          // return if there is a timeout and set to 0,
+          // allowing |func| to be evaluated at least once
+          if (
+            typeof end != "undefined" &&
+            (start == end || new Date().getTime() >= end)
+          ) {
+            resolve(rejected);
+          }
+        })
+        .catch(reject);
+    };
+
+    // the repeating slack timer waits |interval|
+    // before invoking |evalFn|
+    evalFn();
+
+    timer.init(evalFn, interval, TYPE_REPEATING_SLACK);
+  }).then(
+    res => {
+      timer.cancel();
+      return res;
+    },
+    err => {
+      timer.cancel();
+      throw err;
+    }
+  );
+}
diff --git a/remote/shared/TabManager.sys.mjs b/remote/shared/TabManager.sys.mjs
new file mode 100644
index 0000000000..bd0f7ae910
--- /dev/null
+++ b/remote/shared/TabManager.sys.mjs
@@ -0,0 +1,341 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AppInfo: "chrome://remote/content/shared/AppInfo.sys.mjs",
+  EventPromise: "chrome://remote/content/shared/Sync.sys.mjs",
+  generateUUID: "chrome://remote/content/shared/UUID.sys.mjs",
+  MobileTabBrowser: "chrome://remote/content/shared/MobileTabBrowser.sys.mjs",
+});
+
+// Maps browser's permanentKey to uuid: WeakMap.<Object, string>
+const browserUniqueIds = new WeakMap();
+
+export var TabManager = {
+  /**
+   * Retrieve all the browser elements from tabs as contained in open windows.
+   *
+   * @returns {Array<XULBrowser>}
+   *     All the found <xul:browser>s. Will return an empty array if
+   *     no windows and tabs can be found.
+   */
+  get browsers() {
+    const browsers = [];
+
+    for (const win of this.windows) {
+      const tabBrowser = this.getTabBrowser(win);
+
+      if (tabBrowser && tabBrowser.tabs) {
+        const contentBrowsers = tabBrowser.tabs.map(tab => {
+          return this.getBrowserForTab(tab);
+        });
+        browsers.push(...contentBrowsers);
+      }
+    }
+
+    return browsers;
+  },
+
+  get windows() {
+    return Services.wm.getEnumerator(null);
+  },
+
+  /**
+   * Array of unique browser ids (UUIDs) for all content browsers of all
+   * windows.
+   *
+   * TODO: Similarly to getBrowserById, we should improve the performance of
+   * this getter in Bug 1750065.
+   *
+   * @returns {Array<string>}
+   *     Array of UUIDs for all content browsers.
+   */
+  get allBrowserUniqueIds() {
+    const browserIds = [];
+
+    for (const win of this.windows) {
+      const tabBrowser = this.getTabBrowser(win);
+
+      // Only return handles for browser windows
+      if (tabBrowser && tabBrowser.tabs) {
+        for (const tab of tabBrowser.tabs) {
+          const contentBrowser = this.getBrowserForTab(tab);
+          const winId = this.getIdForBrowser(contentBrowser);
+          if (winId !== null) {
+            browserIds.push(winId);
+          }
+        }
+      }
+    }
+
+    return browserIds;
+  },
+
+  /**
+   * Get the <code>&lt;xul:browser&gt;</code> for the specified tab.
+   *
+   * @param {Tab} tab
+   *     The tab whose browser needs to be returned.
+   *
+   * @returns {XULBrowser}
+   *     The linked browser for the tab or null if no browser can be found.
+   */
+  getBrowserForTab(tab) {
+    if (tab && "linkedBrowser" in tab) {
+      return tab.linkedBrowser;
+    }
+
+    return null;
+  },
+
+  /**
+   * Return the tab browser for the specified chrome window.
+   *
+   * @param {ChromeWindow} win
+   *     Window whose <code>tabbrowser</code> needs to be accessed.
+   *
+   * @returns {Tab}
+   *     Tab browser or null if it's not a browser window.
+   */
+  getTabBrowser(win) {
+    if (lazy.AppInfo.isAndroid) {
+      return new lazy.MobileTabBrowser(win);
+    } else if (lazy.AppInfo.isFirefox) {
+      return win.gBrowser;
+    }
+
+    return null;
+  },
+
+  /**
+   * Create a new tab.
+   *
+   * @param {object} options
+   * @param {boolean=} options.focus
+   *     Set to true if the new tab should be focused (selected). Defaults to
+   *     false.
+   * @param {Tab=} options.referenceTab
+   *     The reference tab after which the new tab will be added. If no
+   *     reference tab is provided, the new tab will be added after all the
+   *     other tabs.
+   * @param {number} options.userContextId
+   *     The user context (container) id.
+   * @param {window=} options.window
+   *     The window where the new tab will open. Defaults to Services.wm.getMostRecentWindow
+   *     if no window is provided. Will be ignored if referenceTab is provided.
+   */
+  async addTab(options = {}) {
+    let {
+      focus = false,
+      referenceTab = null,
+      userContextId,
+      window = Services.wm.getMostRecentWindow(null),
+    } = options;
+
+    let index;
+    if (referenceTab != null) {
+      // If a reference tab was specified, the window should be the window
+      // owning the reference tab.
+      window = this._getWindowForTab(referenceTab);
+    }
+
+    const tabBrowser = this.getTabBrowser(window);
+    if (referenceTab != null) {
+      index = tabBrowser.tabs.indexOf(referenceTab) + 1;
+    }
+
+    const tab = await tabBrowser.addTab("about:blank", {
+      index,
+      triggeringPrincipal: Services.scriptSecurityManager.getSystemPrincipal(),
+      userContextId,
+    });
+
+    if (focus) {
+      await this.selectTab(tab);
+    }
+
+    return tab;
+  },
+
+  /**
+   * Retrieve the browser element corresponding to the provided unique id,
+   * previously generated via getIdForBrowser.
+   *
+   * TODO: To avoid creating strong references on browser elements and
+   * potentially leaking those elements, this method loops over all windows and
+   * all tabs. It should be replaced by a faster implementation in Bug 1750065.
+   *
+   * @param {string} id
+   *     A browser unique id created by getIdForBrowser.
+   * @returns {XULBrowser}
+   *     The <xul:browser> corresponding to the provided id. Will return null if
+   *     no matching browser element is found.
+   */
+  getBrowserById(id) {
+    for (const win of this.windows) {
+      const tabBrowser = this.getTabBrowser(win);
+      if (tabBrowser && tabBrowser.tabs) {
+        for (let i = 0; i < tabBrowser.tabs.length; ++i) {
+          const contentBrowser = this.getBrowserForTab(tabBrowser.tabs[i]);
+          if (this.getIdForBrowser(contentBrowser) == id) {
+            return contentBrowser;
+          }
+        }
+      }
+    }
+    return null;
+  },
+
+  /**
+   * Retrieve the browsing context corresponding to the provided unique id.
+   *
+   * @param {string} id
+   *     A browsing context unique id (created by getIdForBrowsingContext).
+   * @returns {BrowsingContext=}
+   *     The browsing context found for this id, null if none was found.
+   */
+  getBrowsingContextById(id) {
+    const browser = this.getBrowserById(id);
+    if (browser) {
+      return browser.browsingContext;
+    }
+
+    return BrowsingContext.get(id);
+  },
+
+  /**
+   * Retrieve the unique id for the given xul browser element. The id is a
+   * dynamically generated uuid associated with the permanentKey property of the
+   * given browser element. This method is preferable over getIdForBrowsingContext
+   * in case of working with browser element of a tab, since we can not guarantee
+   * that browsing context is attached to it.
+   *
+   * @param {XULBrowser} browserElement
+   *     The <xul:browser> for which we want to retrieve the id.
+   * @returns {string} The unique id for this browser.
+   */
+  getIdForBrowser(browserElement) {
+    if (browserElement === null) {
+      return null;
+    }
+
+    const key = browserElement.permanentKey;
+    if (!browserUniqueIds.has(key)) {
+      browserUniqueIds.set(key, lazy.generateUUID());
+    }
+    return browserUniqueIds.get(key);
+  },
+
+  /**
+   * Retrieve the id of a Browsing Context.
+   *
+   * For a top-level browsing context a custom unique id will be returned.
+   *
+   * @param {BrowsingContext=} browsingContext
+   *     The browsing context to get the id from.
+   *
+   * @returns {string}
+   *     The id of the browsing context.
+   */
+  getIdForBrowsingContext(browsingContext) {
+    if (!browsingContext) {
+      return null;
+    }
+
+    if (!browsingContext.parent) {
+      // Top-level browsing contexts have their own custom unique id.
+      return this.getIdForBrowser(browsingContext.embedderElement);
+    }
+
+    return browsingContext.id.toString();
+  },
+
+  getTabCount() {
+    let count = 0;
+    for (const win of this.windows) {
+      // For browser windows count the tabs. Otherwise take the window itself.
+      const tabbrowser = this.getTabBrowser(win);
+      if (tabbrowser?.tabs) {
+        count += tabbrowser.tabs.length;
+      } else {
+        count += 1;
+      }
+    }
+    return count;
+  },
+
+  /**
+   * Retrieve the tab owning a Browsing Context.
+   *
+   * @param {BrowsingContext=} browsingContext
+   *     The browsing context to get the tab from.
+   *
+   * @returns {Tab|null}
+   *     The tab owning the Browsing Context.
+   */
+  getTabForBrowsingContext(browsingContext) {
+    const browser = browsingContext?.top.embedderElement;
+    if (!browser) {
+      return null;
+    }
+
+    const tabBrowser = this.getTabBrowser(browser.ownerGlobal);
+    return tabBrowser.getTabForBrowser(browser);
+  },
+
+  /**
+   * Remove the given tab.
+   *
+   * @param {Tab} tab
+   *     Tab to remove.
+   */
+  async removeTab(tab) {
+    if (!tab) {
+      return;
+    }
+
+    const ownerWindow = this._getWindowForTab(tab);
+    const tabBrowser = this.getTabBrowser(ownerWindow);
+    await tabBrowser.removeTab(tab);
+  },
+
+  /**
+   * Select the given tab.
+   *
+   * @param {Tab} tab
+   *     Tab to select.
+   *
+   * @returns {Promise}
+   *     Promise that resolves when the given tab has been selected.
+   */
+  selectTab(tab) {
+    if (!tab) {
+      return Promise.resolve();
+    }
+
+    const ownerWindow = this._getWindowForTab(tab);
+    const tabBrowser = this.getTabBrowser(ownerWindow);
+
+    if (tab === tabBrowser.selectedTab) {
+      return Promise.resolve();
+    }
+
+    const selected = new lazy.EventPromise(ownerWindow, "TabSelect");
+    tabBrowser.selectedTab = tab;
+    return selected;
+  },
+
+  supportsTabs() {
+    return lazy.AppInfo.isAndroid || lazy.AppInfo.isFirefox;
+  },
+
+  _getWindowForTab(tab) {
+    // `.linkedBrowser.ownerGlobal` works both with Firefox Desktop and Mobile.
+    // Other accessors (eg `.ownerGlobal` or `.browser.ownerGlobal`) fail on one
+    // of the platforms.
+    return tab.linkedBrowser.ownerGlobal;
+  },
+};
diff --git a/remote/shared/UUID.sys.mjs b/remote/shared/UUID.sys.mjs
new file mode 100644
index 0000000000..b77ed7a562
--- /dev/null
+++ b/remote/shared/UUID.sys.mjs
@@ -0,0 +1,14 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/**
+ * Creates a unique UUID without enclosing curly brackets
+ * Example: '86c832d2-cf1c-4001-b3e0-8628fdd41b29'
+ *
+ * @returns {string}
+ *     The generated UUID as a string.
+ */
+export function generateUUID() {
+  return Services.uuid.generateUUID().toString().slice(1, -1);
+}
diff --git a/remote/shared/WebSocketConnection.sys.mjs b/remote/shared/WebSocketConnection.sys.mjs
new file mode 100644
index 0000000000..d8a2ac7fcb
--- /dev/null
+++ b/remote/shared/WebSocketConnection.sys.mjs
@@ -0,0 +1,149 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  generateUUID: "chrome://remote/content/shared/UUID.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  truncate: "chrome://remote/content/shared/Format.sys.mjs",
+  WebSocketTransport:
+    "chrome://remote/content/server/WebSocketTransport.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+export class WebSocketConnection {
+  /**
+   * @param {WebSocket} webSocket
+   *     The WebSocket server connection to wrap.
+   * @param {Connection} httpdConnection
+   *     Reference to the httpd.js's connection needed for clean-up.
+   */
+  constructor(webSocket, httpdConnection) {
+    this.id = lazy.generateUUID();
+
+    this.httpdConnection = httpdConnection;
+
+    this.transport = new lazy.WebSocketTransport(webSocket);
+    this.transport.hooks = this;
+    this.transport.ready();
+
+    lazy.logger.debug(`${this.constructor.name} ${this.id} accepted`);
+  }
+
+  _log(direction, data) {
+    if (lazy.Log.isDebugLevelOrMore) {
+      function replacer(key, value) {
+        if (typeof value === "string") {
+          return lazy.truncate`${value}`;
+        }
+        return value;
+      }
+
+      const payload = JSON.stringify(
+        data,
+        replacer,
+        lazy.Log.verbose ? "\t" : null
+      );
+
+      lazy.logger.debug(
+        `${this.constructor.name} ${this.id} ${direction} ${payload}`
+      );
+    }
+  }
+
+  /**
+   * Close the WebSocket connection.
+   */
+  close() {
+    this.transport.close();
+
+    // In addition to the WebSocket transport, we also have to close the
+    // connection used internally within httpd.js. Otherwise the server doesn't
+    // shut down correctly, and keeps these Connection instances alive.
+    this.httpdConnection.close();
+  }
+
+  /**
+   * Register a new Session to forward the messages to.
+   *
+   * Needs to be implemented in the sub class.
+   *
+   * @param {Session} session
+   *     The session to register.
+   */
+  registerSession(session) {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Send the JSON-serializable object to the client.
+   *
+   * @param {object} data
+   *     The object to be sent.
+   */
+  send(data) {
+    this._log("<-", data);
+    this.transport.send(data);
+  }
+
+  /**
+   * Send an error back to the client.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  sendError() {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Send an event back to the client.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  sendEvent() {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Send the result of a call to a method back to the client.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  sendResult() {
+    throw new Error("Not implemented");
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} ${this.id}]`;
+  }
+
+  // Transport hooks
+
+  /**
+   * Called by the `transport` when the connection is closed.
+   */
+  onClosed(status) {
+    lazy.logger.debug(`${this.constructor.name} ${this.id} closed`);
+  }
+
+  /**
+   * Receive a packet from the WebSocket layer.
+   *
+   * This packet is sent by a WebSocket client and is meant to execute
+   * a particular method.
+   *
+   * Needs to be implemented in the sub class.
+   *
+   * @param {object} packet
+   *     JSON-serializable object sent by the client.
+   */
+  async onPacket(packet) {
+    this._log("->", packet);
+  }
+}
diff --git a/remote/shared/WindowManager.sys.mjs b/remote/shared/WindowManager.sys.mjs
new file mode 100644
index 0000000000..af21a70862
--- /dev/null
+++ b/remote/shared/WindowManager.sys.mjs
@@ -0,0 +1,273 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AppInfo: "chrome://remote/content/shared/AppInfo.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  EventPromise: "chrome://remote/content/shared/Sync.sys.mjs",
+  generateUUID: "chrome://remote/content/shared/UUID.sys.mjs",
+  TabManager: "chrome://remote/content/shared/TabManager.sys.mjs",
+  TimedPromise: "chrome://remote/content/marionette/sync.sys.mjs",
+  waitForObserverTopic: "chrome://remote/content/marionette/sync.sys.mjs",
+});
+
+/**
+ * Provides helpers to interact with Window objects.
+ *
+ * @class WindowManager
+ */
+class WindowManager {
+  constructor() {
+    // Maps ChromeWindow to uuid: WeakMap.<Object, string>
+    this._chromeWindowHandles = new WeakMap();
+  }
+
+  get chromeWindowHandles() {
+    const chromeWindowHandles = [];
+
+    for (const win of this.windows) {
+      chromeWindowHandles.push(this.getIdForWindow(win));
+    }
+
+    return chromeWindowHandles;
+  }
+
+  get windows() {
+    return Services.wm.getEnumerator(null);
+  }
+
+  /**
+   * Find a specific window matching the provided window handle.
+   *
+   * @param {string} handle
+   *     The unique handle of either a chrome window or a content browser, as
+   *     returned by :js:func:`#getIdForBrowser` or :js:func:`#getIdForWindow`.
+   *
+   * @returns {object} A window properties object,
+   *     @see :js:func:`GeckoDriver#getWindowProperties`
+   */
+  findWindowByHandle(handle) {
+    for (const win of this.windows) {
+      // In case the wanted window is a chrome window, we are done.
+      const chromeWindowId = this.getIdForWindow(win);
+      if (chromeWindowId == handle) {
+        return this.getWindowProperties(win);
+      }
+
+      // Otherwise check if the chrome window has a tab browser, and that it
+      // contains a tab with the wanted window handle.
+      const tabBrowser = lazy.TabManager.getTabBrowser(win);
+      if (tabBrowser && tabBrowser.tabs) {
+        for (let i = 0; i < tabBrowser.tabs.length; ++i) {
+          let contentBrowser = lazy.TabManager.getBrowserForTab(
+            tabBrowser.tabs[i]
+          );
+          let contentWindowId = lazy.TabManager.getIdForBrowser(contentBrowser);
+
+          if (contentWindowId == handle) {
+            return this.getWindowProperties(win, { tabIndex: i });
+          }
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * A set of properties describing a window and that should allow to uniquely
+   * identify it. The described window can either be a Chrome Window or a
+   * Content Window.
+   *
+   * @typedef {object} WindowProperties
+   * @property {Window} win - The Chrome Window containing the window.
+   *     When describing a Chrome Window, this is the window itself.
+   * @property {string} id - The unique id of the containing Chrome Window.
+   * @property {boolean} hasTabBrowser - `true` if the Chrome Window has a
+   *     tabBrowser.
+   * @property {number} tabIndex - Optional, the index of the specific tab
+   *     within the window.
+   */
+
+  /**
+   * Returns a WindowProperties object, that can be used with :js:func:`GeckoDriver#setWindowHandle`.
+   *
+   * @param {Window} win
+   *     The Chrome Window for which we want to create a properties object.
+   * @param {object} options
+   * @param {number} options.tabIndex
+   *     Tab index of a specific Content Window in the specified Chrome Window.
+   * @returns {WindowProperties} A window properties object.
+   */
+  getWindowProperties(win, options = {}) {
+    if (!Window.isInstance(win)) {
+      throw new TypeError("Invalid argument, expected a Window object");
+    }
+
+    return {
+      win,
+      id: this.getIdForWindow(win),
+      hasTabBrowser: !!lazy.TabManager.getTabBrowser(win),
+      tabIndex: options.tabIndex,
+    };
+  }
+
+  /**
+   * Retrieves an id for the given chrome window. The id is a dynamically
+   * generated uuid associated with the window object.
+   *
+   * @param {window} win
+   *     The window object for which we want to retrieve the id.
+   * @returns {string} The unique id for this chrome window.
+   */
+  getIdForWindow(win) {
+    if (!this._chromeWindowHandles.has(win)) {
+      this._chromeWindowHandles.set(win, lazy.generateUUID());
+    }
+    return this._chromeWindowHandles.get(win);
+  }
+
+  /**
+   * Close the specified window.
+   *
+   * @param {window} win
+   *     The window to close.
+   * @returns {Promise}
+   *     A promise which is resolved when the current window has been closed.
+   */
+  async closeWindow(win) {
+    const destroyed = lazy.waitForObserverTopic("xul-window-destroyed", {
+      checkFn: () => win && win.closed,
+    });
+
+    win.close();
+
+    return destroyed;
+  }
+
+  /**
+   * Focus the specified window.
+   *
+   * @param {window} win
+   *     The window to focus.
+   * @returns {Promise}
+   *     A promise which is resolved when the window has been focused.
+   */
+  async focusWindow(win) {
+    if (Services.focus.activeWindow != win) {
+      let activated = new lazy.EventPromise(win, "activate");
+      let focused = new lazy.EventPromise(win, "focus", { capture: true });
+
+      win.focus();
+
+      await Promise.all([activated, focused]);
+    }
+  }
+
+  /**
+   * Open a new browser window.
+   *
+   * @param {object=} options
+   * @param {boolean=} options.focus
+   *     If true, the opened window will receive the focus. Defaults to false.
+   * @param {boolean=} options.isPrivate
+   *     If true, the opened window will be a private window. Defaults to false.
+   * @param {ChromeWindow=} options.openerWindow
+   *     Use this window as the opener of the new window. Defaults to the
+   *     topmost window.
+   * @returns {Promise}
+   *     A promise resolving to the newly created chrome window.
+   */
+  async openBrowserWindow(options = {}) {
+    let { focus = false, isPrivate = false, openerWindow = null } = options;
+
+    switch (lazy.AppInfo.name) {
+      case "Firefox":
+        if (openerWindow === null) {
+          // If no opener was provided, fallback to the topmost window.
+          openerWindow = Services.wm.getMostRecentBrowserWindow();
+        }
+
+        if (!openerWindow) {
+          throw new lazy.error.UnsupportedOperationError(
+            `openWindow() could not find a valid opener window`
+          );
+        }
+
+        // Open new browser window, and wait until it is fully loaded.
+        // Also wait for the window to be focused and activated to prevent a
+        // race condition when promptly focusing to the original window again.
+        const win = openerWindow.OpenBrowserWindow({ private: isPrivate });
+
+        const activated = new lazy.EventPromise(win, "activate");
+        const focused = new lazy.EventPromise(win, "focus", { capture: true });
+        const startup = lazy.waitForObserverTopic(
+          "browser-delayed-startup-finished",
+          {
+            checkFn: subject => subject == win,
+          }
+        );
+
+        // TODO: Both for WebDriver BiDi and classic, opening a new window
+        // should not run the focus steps. When focus is false we should avoid
+        // focusing the new window completely. See Bug 1766329
+        win.focus();
+
+        await Promise.all([activated, focused, startup]);
+
+        // The new window shouldn't get focused. As such set the
+        // focus back to the opening window.
+        if (!focus) {
+          await this.focusWindow(openerWindow);
+        }
+
+        return win;
+
+      default:
+        throw new lazy.error.UnsupportedOperationError(
+          `openWindow() not supported in ${lazy.AppInfo.name}`
+        );
+    }
+  }
+
+  /**
+   * Wait until the initial application window has been opened and loaded.
+   *
+   * @returns {Promise<WindowProxy>}
+   *     A promise that resolved to the application window.
+   */
+  waitForInitialApplicationWindowLoaded() {
+    return new lazy.TimedPromise(
+      async resolve => {
+        // This call includes a fallback to "mail3:pane" as well.
+        const win = Services.wm.getMostRecentBrowserWindow();
+
+        const windowLoaded = lazy.waitForObserverTopic(
+          "browser-delayed-startup-finished",
+          {
+            checkFn: subject => (win !== null ? subject == win : true),
+          }
+        );
+
+        // The current window has already been finished loading.
+        if (win && win.document.readyState == "complete") {
+          resolve(win);
+          return;
+        }
+
+        // Wait for the next browser/mail window to open and finished loading.
+        const { subject } = await windowLoaded;
+        resolve(subject);
+      },
+      {
+        errorMessage: "No applicable application window found",
+      }
+    );
+  }
+}
+
+// Expose a shared singleton.
+export const windowManager = new WindowManager();
diff --git a/remote/shared/listeners/BrowsingContextListener.sys.mjs b/remote/shared/listeners/BrowsingContextListener.sys.mjs
new file mode 100644
index 0000000000..b7334e3d4f
--- /dev/null
+++ b/remote/shared/listeners/BrowsingContextListener.sys.mjs
@@ -0,0 +1,121 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  EventEmitter: "resource://gre/modules/EventEmitter.sys.mjs",
+});
+
+const OBSERVER_TOPIC_ATTACHED = "browsing-context-attached";
+const OBSERVER_TOPIC_DISCARDED = "browsing-context-discarded";
+
+const OBSERVER_TOPIC_SET_EMBEDDER = "browsing-context-did-set-embedder";
+
+/**
+ * The BrowsingContextListener can be used to listen for notifications coming
+ * from browsing contexts that get attached or discarded.
+ *
+ * Example:
+ * ```
+ * const listener = new BrowsingContextListener();
+ * listener.on("attached", onAttached);
+ * listener.startListening();
+ *
+ * const onAttached = (eventName, data = {}) => {
+ *   const { browsingContext, why } = data;
+ *   ...
+ * };
+ * ```
+ *
+ * @fires message
+ *    The BrowsingContextListener emits "attached" and "discarded" events,
+ *    with the following object as payload:
+ *      - {BrowsingContext} browsingContext
+ *            Browsing context the notification relates to.
+ *      - {string} why
+ *            Usually "attach" or "discard", but will contain "replace" if the
+ *            browsing context gets replaced by a cross-group navigation.
+ */
+export class BrowsingContextListener {
+  #listening;
+  #topContextsToAttach;
+
+  /**
+   * Create a new BrowsingContextListener instance.
+   */
+  constructor() {
+    lazy.EventEmitter.decorate(this);
+
+    // A map that temporarily holds attached top-level browsing contexts until
+    // their embedder element is set, which is required to successfully
+    // retrieve a unique id for the content browser by the TabManager.
+    this.#topContextsToAttach = new Map();
+
+    this.#listening = false;
+  }
+
+  destroy() {
+    this.stopListening();
+  }
+
+  observe(subject, topic, data) {
+    switch (topic) {
+      case OBSERVER_TOPIC_ATTACHED:
+        // Delay emitting the event for top-level browsing contexts until
+        // the embedder element has been set.
+        if (!subject.parent) {
+          this.#topContextsToAttach.set(subject, data);
+          return;
+        }
+
+        this.emit("attached", { browsingContext: subject, why: data });
+        break;
+
+      case OBSERVER_TOPIC_DISCARDED:
+        // Remove a recently attached top-level browsing context if it's
+        // immediately discarded.
+        if (this.#topContextsToAttach.has(subject)) {
+          this.#topContextsToAttach.delete(subject);
+        }
+
+        this.emit("discarded", { browsingContext: subject, why: data });
+        break;
+
+      case OBSERVER_TOPIC_SET_EMBEDDER:
+        const why = this.#topContextsToAttach.get(subject);
+        if (why !== undefined) {
+          this.emit("attached", { browsingContext: subject, why });
+          this.#topContextsToAttach.delete(subject);
+        }
+        break;
+    }
+  }
+
+  startListening() {
+    if (this.#listening) {
+      return;
+    }
+
+    Services.obs.addObserver(this, OBSERVER_TOPIC_ATTACHED);
+    Services.obs.addObserver(this, OBSERVER_TOPIC_DISCARDED);
+    Services.obs.addObserver(this, OBSERVER_TOPIC_SET_EMBEDDER);
+
+    this.#listening = true;
+  }
+
+  stopListening() {
+    if (!this.#listening) {
+      return;
+    }
+
+    Services.obs.removeObserver(this, OBSERVER_TOPIC_ATTACHED);
+    Services.obs.removeObserver(this, OBSERVER_TOPIC_DISCARDED);
+    Services.obs.removeObserver(this, OBSERVER_TOPIC_SET_EMBEDDER);
+
+    this.#topContextsToAttach.clear();
+
+    this.#listening = false;
+  }
+}
diff --git a/remote/shared/listeners/ConsoleAPIListener.sys.mjs b/remote/shared/listeners/ConsoleAPIListener.sys.mjs
new file mode 100644
index 0000000000..2c8d4d047c
--- /dev/null
+++ b/remote/shared/listeners/ConsoleAPIListener.sys.mjs
@@ -0,0 +1,126 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  EventEmitter: "resource://gre/modules/EventEmitter.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "ConsoleAPIStorage", () => {
+  return Cc["@mozilla.org/consoleAPI-storage;1"].getService(
+    Ci.nsIConsoleAPIStorage
+  );
+});
+
+/**
+ * The ConsoleAPIListener can be used to listen for messages coming from console
+ * API usage in a given windowGlobal, eg. console.log, console.error, ...
+ *
+ * Example:
+ * ```
+ * const listener = new ConsoleAPIListener(innerWindowId);
+ * listener.on("message", onConsoleAPIMessage);
+ * listener.startListening();
+ *
+ * const onConsoleAPIMessage = (eventName, data = {}) => {
+ *   const { arguments: msgArguments, level, stacktrace, timeStamp } = data;
+ *   ...
+ * };
+ * ```
+ *
+ * @fires message
+ *    The ConsoleAPIListener emits "message" events, with the following object as
+ *    payload:
+ *      - {Array<Object>} arguments - Arguments as passed-in when the method was called.
+ *      - {String} level - Importance, one of `info`, `warn`, `error`, `debug`, `trace`.
+ *      - {Array<Object>} stacktrace - List of stack frames, starting from most recent.
+ *      - {Number} timeStamp - Timestamp when the method was called.
+ */
+export class ConsoleAPIListener {
+  #emittedMessages;
+  #innerWindowId;
+  #listening;
+
+  /**
+   * Create a new ConsolerListener instance.
+   *
+   * @param {number} innerWindowId
+   *     The inner window id to filter the messages for.
+   */
+  constructor(innerWindowId) {
+    lazy.EventEmitter.decorate(this);
+
+    this.#emittedMessages = new Set();
+    this.#innerWindowId = innerWindowId;
+    this.#listening = false;
+  }
+
+  destroy() {
+    this.stopListening();
+    this.#emittedMessages = null;
+  }
+
+  startListening() {
+    if (this.#listening) {
+      return;
+    }
+
+    lazy.ConsoleAPIStorage.addLogEventListener(
+      this.#onConsoleAPIMessage,
+      Cc["@mozilla.org/systemprincipal;1"].createInstance(Ci.nsIPrincipal)
+    );
+
+    // Emit cached messages after registering the listener, to make sure we
+    // don't miss any message.
+    this.#emitCachedMessages();
+
+    this.#listening = true;
+  }
+
+  stopListening() {
+    if (!this.#listening) {
+      return;
+    }
+
+    lazy.ConsoleAPIStorage.removeLogEventListener(this.#onConsoleAPIMessage);
+    this.#listening = false;
+  }
+
+  #emitCachedMessages() {
+    const cachedMessages = lazy.ConsoleAPIStorage.getEvents(
+      this.#innerWindowId
+    );
+    for (const message of cachedMessages) {
+      this.#onConsoleAPIMessage(message);
+    }
+  }
+
+  #onConsoleAPIMessage = message => {
+    const messageObject = message.wrappedJSObject;
+
+    // Bail if this message was already emitted, useful to filter out cached
+    // messages already received by the consumer.
+    if (this.#emittedMessages.has(messageObject)) {
+      return;
+    }
+
+    this.#emittedMessages.add(messageObject);
+
+    if (messageObject.innerID !== this.#innerWindowId) {
+      // If the message doesn't match the innerWindowId of the current context
+      // ignore it.
+      return;
+    }
+
+    this.emit("message", {
+      arguments: messageObject.arguments,
+      level: messageObject.level,
+      stacktrace: messageObject.stacktrace,
+      timeStamp: messageObject.timeStamp,
+    });
+  };
+}
diff --git a/remote/shared/listeners/ConsoleListener.sys.mjs b/remote/shared/listeners/ConsoleListener.sys.mjs
new file mode 100644
index 0000000000..aef41692c0
--- /dev/null
+++ b/remote/shared/listeners/ConsoleListener.sys.mjs
@@ -0,0 +1,156 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  EventEmitter: "resource://gre/modules/EventEmitter.sys.mjs",
+
+  getFramesFromStack: "chrome://remote/content/shared/Stack.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * The ConsoleListener can be used to listen for console messages related to
+ * Javascript errors, certain warnings which all happen within a specific
+ * windowGlobal. Consumers can listen for the message types "error",
+ * "warn" and "info".
+ *
+ * Example:
+ * ```
+ * const onJavascriptError = (eventName, data = {}) => {
+ *   const { level, message, stacktrace, timestamp } = data;
+ *   ...
+ * };
+ *
+ * const listener = new ConsoleListener(innerWindowId);
+ * listener.on("error", onJavascriptError);
+ * listener.startListening();
+ * ...
+ * listener.stopListening();
+ * ```
+ *
+ * @fires message
+ *    The ConsoleListener emits "error", "warn" and "info" events, with the
+ *    following object as payload:
+ *      - {String} level - Importance, one of `info`, `warn`, `error`,
+ *        `debug`, `trace`.
+ *      - {String} message - Actual message from the console entry.
+ *      - {Array<StackFrame>} stacktrace - List of stack frames,
+ *        starting from most recent.
+ *      - {Number} timeStamp - Timestamp when the method was called.
+ */
+export class ConsoleListener {
+  #emittedMessages;
+  #innerWindowId;
+  #listening;
+
+  /**
+   * Create a new ConsolerListener instance.
+   *
+   * @param {number} innerWindowId
+   *     The inner window id to filter the messages for.
+   */
+  constructor(innerWindowId) {
+    lazy.EventEmitter.decorate(this);
+
+    this.#emittedMessages = new Set();
+    this.#innerWindowId = innerWindowId;
+    this.#listening = false;
+  }
+
+  get listening() {
+    return this.#listening;
+  }
+
+  destroy() {
+    this.stopListening();
+    this.#emittedMessages = null;
+  }
+
+  startListening() {
+    if (this.#listening) {
+      return;
+    }
+
+    Services.console.registerListener(this.#onConsoleMessage);
+
+    // Emit cached messages after registering the listener, to make sure we
+    // don't miss any message.
+    this.#emitCachedMessages();
+
+    this.#listening = true;
+  }
+
+  stopListening() {
+    if (!this.#listening) {
+      return;
+    }
+
+    Services.console.unregisterListener(this.#onConsoleMessage);
+    this.#listening = false;
+  }
+
+  #emitCachedMessages() {
+    const cachedMessages = Services.console.getMessageArray() || [];
+
+    for (const message of cachedMessages) {
+      this.#onConsoleMessage(message);
+    }
+  }
+
+  #onConsoleMessage = message => {
+    if (!(message instanceof Ci.nsIScriptError)) {
+      // For now ignore basic nsIConsoleMessage instances, which are only
+      // relevant to Chrome code and do not have a valid window reference.
+      return;
+    }
+
+    // Bail if this message was already emitted, useful to filter out cached
+    // messages already received by the consumer.
+    if (this.#emittedMessages.has(message)) {
+      return;
+    }
+
+    this.#emittedMessages.add(message);
+
+    if (message.innerWindowID !== this.#innerWindowId) {
+      // If the message doesn't match the innerWindowId of the current context
+      // ignore it.
+      return;
+    }
+
+    const { errorFlag, warningFlag, infoFlag } = Ci.nsIScriptError;
+    let level;
+
+    if ((message.flags & warningFlag) == warningFlag) {
+      level = "warn";
+    } else if ((message.flags & infoFlag) == infoFlag) {
+      level = "info";
+    } else if ((message.flags & errorFlag) == errorFlag) {
+      level = "error";
+    } else {
+      lazy.logger.warn(
+        `Not able to process console message with unknown flags ${message.flags}`
+      );
+      return;
+    }
+
+    // Send event when actively listening.
+    this.emit(level, {
+      level,
+      message: message.errorMessage,
+      stacktrace: lazy.getFramesFromStack(message.stack),
+      timeStamp: message.timeStamp,
+    });
+  };
+
+  get QueryInterface() {
+    return ChromeUtils.generateQI(["nsIConsoleListener"]);
+  }
+}
diff --git a/remote/shared/listeners/LoadListener.sys.mjs b/remote/shared/listeners/LoadListener.sys.mjs
new file mode 100644
index 0000000000..cccfca7a90
--- /dev/null
+++ b/remote/shared/listeners/LoadListener.sys.mjs
@@ -0,0 +1,103 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  EventEmitter: "resource://gre/modules/EventEmitter.sys.mjs",
+});
+
+/**
+ * The LoadListener can be used to listen for load events.
+ *
+ * Example:
+ * ```
+ * const listener = new LoadListener();
+ * listener.on("DOMContentLoaded", onDOMContentLoaded);
+ * listener.startListening();
+ *
+ * const onDOMContentLoaded = (eventName, data = {}) => {
+ *   const { target } = data;
+ *   ...
+ * };
+ * ```
+ *
+ * @fires message
+ *    The LoadListener emits "DOMContentLoaded" and "load" events,
+ *    with the following object as payload:
+ *      - {Document} target
+ *            The target document.
+ */
+export class LoadListener {
+  #abortController;
+  #window;
+
+  /**
+   * Create a new LoadListener instance.
+   */
+  constructor(win) {
+    lazy.EventEmitter.decorate(this);
+
+    // Use an abort controller instead of removeEventListener because destroy
+    // might be called close to the window global destruction.
+    this.#abortController = null;
+
+    this.#window = win;
+  }
+
+  destroy() {
+    this.stopListening();
+  }
+
+  startListening() {
+    if (this.#abortController) {
+      return;
+    }
+
+    this.#abortController = new AbortController();
+
+    // Events are attached to the windowRoot instead of the regular window to
+    // avoid issues with document.open (Bug 1822772).
+    this.#window.windowRoot.addEventListener(
+      "DOMContentLoaded",
+      this.#onDOMContentLoaded,
+      {
+        capture: true,
+        mozSystemGroup: true,
+        signal: this.#abortController.signal,
+      }
+    );
+
+    this.#window.windowRoot.addEventListener("load", this.#onLoad, {
+      capture: true,
+      mozSystemGroup: true,
+      signal: this.#abortController.signal,
+    });
+  }
+
+  stopListening() {
+    if (!this.#abortController) {
+      return;
+    }
+
+    this.#abortController.abort();
+    this.#abortController = null;
+  }
+
+  #onDOMContentLoaded = event => {
+    // Check that this event was emitted for the relevant window, because events
+    // from inner frames can bubble to the windowRoot.
+    if (event.target.defaultView === this.#window) {
+      this.emit("DOMContentLoaded", { target: event.target });
+    }
+  };
+
+  #onLoad = event => {
+    // Check that this event was emitted for the relevant window, because events
+    // from inner frames can bubble to the windowRoot.
+    if (event.target.defaultView === this.#window) {
+      this.emit("load", { target: event.target });
+    }
+  };
+}
diff --git a/remote/shared/listeners/NetworkEventRecord.sys.mjs b/remote/shared/listeners/NetworkEventRecord.sys.mjs
new file mode 100644
index 0000000000..cc3e0d1001
--- /dev/null
+++ b/remote/shared/listeners/NetworkEventRecord.sys.mjs
@@ -0,0 +1,370 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+ChromeUtils.defineESModuleGetters(lazy, {
+  NetworkUtils:
+    "resource://devtools/shared/network-observer/NetworkUtils.sys.mjs",
+
+  TabManager: "chrome://remote/content/shared/TabManager.sys.mjs",
+});
+
+/**
+ * The NetworkEventRecord implements the interface expected from network event
+ * owners for consumers of the DevTools NetworkObserver.
+ *
+ * The NetworkEventRecord emits the before-request-sent event on behalf of the
+ * NetworkListener instance which created it.
+ */
+export class NetworkEventRecord {
+  #channel;
+  #fromCache;
+  #networkListener;
+  #redirectCount;
+  #requestData;
+  #requestId;
+  #responseData;
+  #wrappedChannel;
+
+  /**
+   *
+   * @param {object} networkEvent
+   *     The initial network event information (see createNetworkEvent() in
+   *     NetworkUtils.sys.mjs).
+   * @param {nsIChannel} channel
+   *     The nsIChannel behind this network event.
+   * @param {NetworkListener} networkListener
+   *     The NetworkListener which created this NetworkEventRecord.
+   */
+  constructor(networkEvent, channel, networkListener) {
+    this.#channel = channel;
+    this.#fromCache = networkEvent.fromCache;
+
+    this.#wrappedChannel = ChannelWrapper.get(channel);
+
+    this.#networkListener = networkListener;
+
+    // The wrappedChannel id remains identical across redirects, whereas
+    // nsIChannel.channelId is different for each and every request.
+    this.#requestId = this.#wrappedChannel.id.toString();
+
+    const { cookies, headers } =
+      lazy.NetworkUtils.fetchRequestHeadersAndCookies(channel);
+
+    // See the RequestData type definition for the full list of properties that
+    // should be set on this object.
+    this.#requestData = {
+      bodySize: null,
+      cookies,
+      headers,
+      headersSize: networkEvent.rawHeaders ? networkEvent.rawHeaders.length : 0,
+      method: channel.requestMethod,
+      request: this.#requestId,
+      timings: {},
+      url: channel.URI.spec,
+    };
+
+    // See the ResponseData type definition for the full list of properties that
+    // should be set on this object.
+    this.#responseData = {
+      // encoded size (body)
+      bodySize: null,
+      content: {
+        // decoded size
+        size: null,
+      },
+      // encoded size (headers)
+      headersSize: null,
+      url: channel.URI.spec,
+    };
+
+    // NetworkObserver creates a network event when request headers have been
+    // parsed.
+    // According to the BiDi spec, we should emit beforeRequestSent when adding
+    // request headers, see https://whatpr.org/fetch/1540.html#http-network-or-cache-fetch
+    // step 8.17
+    // Bug 1802181: switch the NetworkObserver to an event-based API.
+    this.#emitBeforeRequestSent();
+  }
+
+  /**
+   * Add network request POST data.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   * @param {object} postData
+   *     The request POST data.
+   */
+  addRequestPostData(postData) {
+    // Only the postData size is needed for RemoteAgent consumers.
+    this.#requestData.bodySize = postData.size;
+  }
+
+  /**
+   * Add the initial network response information.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   *
+   * @param {object} options
+   * @param {nsIChannel} options.channel
+   *     The channel.
+   * @param {boolean} options.fromCache
+   * @param {string} options.rawHeaders
+   */
+  addResponseStart(options) {
+    const { channel, fromCache, rawHeaders = "" } = options;
+    const { headers } =
+      lazy.NetworkUtils.fetchResponseHeadersAndCookies(channel);
+
+    const headersSize = rawHeaders.length;
+    this.#responseData = {
+      ...this.#responseData,
+      bodySize: 0,
+      bytesReceived: headersSize,
+      fromCache: this.#fromCache || !!fromCache,
+      headers,
+      headersSize,
+      mimeType: this.#getMimeType(),
+      protocol: lazy.NetworkUtils.getProtocol(channel),
+      status: channel.responseStatus,
+      statusText: channel.responseStatusText,
+    };
+
+    // This should be triggered when all headers have been received, matching
+    // the WebDriverBiDi response started trigger in `4.6. HTTP-network fetch`
+    // from the fetch specification, based on the PR visible at
+    // https://github.com/whatwg/fetch/pull/1540
+    this.#emitResponseStarted();
+  }
+
+  /**
+   * Add connection security information.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   * Not used for RemoteAgent.
+   *
+   * @param {object} info
+   *     The object containing security information.
+   * @param {boolean} isRacing
+   *     True if the corresponding channel raced the cache and network requests.
+   */
+  addSecurityInfo(info, isRacing) {}
+
+  /**
+   * Add network event timings.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   * Not used for RemoteAgent.
+   *
+   * @param {number} total
+   *     The total time for the request.
+   * @param {object} timings
+   *     The har-like timings.
+   * @param {object} offsets
+   *     The har-like timings, but as offset from the request start.
+   * @param {Array} serverTimings
+   *     The server timings.
+   */
+  addEventTimings(total, timings, offsets, serverTimings) {}
+
+  /**
+   * Add response cache entry.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   * Not used for RemoteAgent.
+   *
+   * @param {object} options
+   *     An object which contains a single responseCache property.
+   */
+  addResponseCache(options) {}
+
+  /**
+   * Add response content.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   * @param {object} response
+   *     An object which represents the response content.
+   * @param {object} responseInfo
+   *     Additional meta data about the response.
+   */
+  addResponseContent(response, responseInfo) {
+    // Update content-related sizes with the latest data from addResponseContent.
+    this.#responseData = {
+      ...this.#responseData,
+      bodySize: response.bodySize,
+      bytesReceived: response.transferredSize,
+      content: {
+        size: response.decodedBodySize,
+      },
+    };
+
+    this.#emitResponseCompleted();
+  }
+
+  /**
+   * Add server timings.
+   *
+   * Required API for a NetworkObserver event owner.
+   *
+   * Not used for RemoteAgent.
+   *
+   * @param {Array} serverTimings
+   *     The server timings.
+   */
+  addServerTimings(serverTimings) {}
+
+  #emitBeforeRequestSent() {
+    this.#updateDataFromTimedChannel();
+
+    this.#networkListener.emit("before-request-sent", {
+      contextId: this.#getContextId(),
+      redirectCount: this.#redirectCount,
+      requestData: this.#requestData,
+      timestamp: Date.now(),
+    });
+  }
+
+  #emitResponseCompleted() {
+    this.#updateDataFromTimedChannel();
+
+    this.#networkListener.emit("response-completed", {
+      contextId: this.#getContextId(),
+      redirectCount: this.#redirectCount,
+      requestData: this.#requestData,
+      responseData: this.#responseData,
+      timestamp: Date.now(),
+    });
+  }
+
+  #emitResponseStarted() {
+    this.#updateDataFromTimedChannel();
+
+    this.#networkListener.emit("response-started", {
+      contextId: this.#getContextId(),
+      redirectCount: this.#redirectCount,
+      requestData: this.#requestData,
+      responseData: this.#responseData,
+      timestamp: Date.now(),
+    });
+  }
+
+  /**
+   * Convert the provided request timing to a timing relative to the beginning
+   * of the request. All timings are numbers representing high definition
+   * timestamps.
+   *
+   * @param {number} timing
+   *     High definition timestamp for a request timing relative from the time
+   *     origin.
+   * @param {number} requestTime
+   *     High definition timestamp for the request start time relative from the
+   *     time origin.
+   * @returns {number}
+   *     High definition timestamp for the request timing relative to the start
+   *     time of the request, or 0 if the provided timing was 0.
+   */
+  #convertTimestamp(timing, requestTime) {
+    if (timing == 0) {
+      return 0;
+    }
+
+    return timing - requestTime;
+  }
+
+  /**
+   * Retrieve the context id corresponding to the current channel, this could
+   * change dynamically during a cross group navigation for an iframe, so this
+   * should always be retrieved dynamically.
+   */
+  #getContextId() {
+    const id = lazy.NetworkUtils.getChannelBrowsingContextID(this.#channel);
+    const browsingContext = BrowsingContext.get(id);
+    return lazy.TabManager.getIdForBrowsingContext(browsingContext);
+  }
+
+  #getMimeType() {
+    // TODO: DevTools NetworkObserver is computing a similar value in
+    // addResponseContent, but uses an inconsistent implementation in
+    // addResponseStart. This approach can only be used as early as in
+    // addResponseHeaders. We should move this logic to the NetworkObserver and
+    // expose mimeType in addResponseStart. Bug 1809670.
+    let mimeType = "";
+
+    try {
+      mimeType = this.#wrappedChannel.contentType;
+      const contentCharset = this.#channel.contentCharset;
+      if (contentCharset) {
+        mimeType += `;charset=${contentCharset}`;
+      }
+    } catch (e) {
+      // Ignore exceptions when reading contentType/contentCharset
+    }
+
+    return mimeType;
+  }
+
+  #getTimingsFromTimedChannel(timedChannel) {
+    const {
+      channelCreationTime,
+      redirectStartTime,
+      redirectEndTime,
+      dispatchFetchEventStartTime,
+      cacheReadStartTime,
+      domainLookupStartTime,
+      domainLookupEndTime,
+      connectStartTime,
+      connectEndTime,
+      secureConnectionStartTime,
+      requestStartTime,
+      responseStartTime,
+      responseEndTime,
+    } = timedChannel;
+
+    // fetchStart should be the post-redirect start time, which should be the
+    // first non-zero timing from: dispatchFetchEventStart, cacheReadStart and
+    // domainLookupStart. See https://www.w3.org/TR/navigation-timing-2/#processing-model
+    const fetchStartTime =
+      dispatchFetchEventStartTime ||
+      cacheReadStartTime ||
+      domainLookupStartTime;
+
+    // Bug 1805478: Per spec, the origin time should match Performance API's
+    // originTime for the global which initiated the request. This is not
+    // available in the parent process, so for now we will use 0.
+    const originTime = 0;
+
+    return {
+      originTime,
+      requestTime: this.#convertTimestamp(channelCreationTime, originTime),
+      redirectStart: this.#convertTimestamp(redirectStartTime, originTime),
+      redirectEnd: this.#convertTimestamp(redirectEndTime, originTime),
+      fetchStart: this.#convertTimestamp(fetchStartTime, originTime),
+      dnsStart: this.#convertTimestamp(domainLookupStartTime, originTime),
+      dnsEnd: this.#convertTimestamp(domainLookupEndTime, originTime),
+      connectStart: this.#convertTimestamp(connectStartTime, originTime),
+      connectEnd: this.#convertTimestamp(connectEndTime, originTime),
+      tlsStart: this.#convertTimestamp(secureConnectionStartTime, originTime),
+      tlsEnd: this.#convertTimestamp(connectEndTime, originTime),
+      requestStart: this.#convertTimestamp(requestStartTime, originTime),
+      responseStart: this.#convertTimestamp(responseStartTime, originTime),
+      responseEnd: this.#convertTimestamp(responseEndTime, originTime),
+    };
+  }
+
+  /**
+   * Update the timings and the redirect count from the nsITimedChannel
+   * corresponding to the current channel. This should be called before emitting
+   * any event from this class.
+   */
+  #updateDataFromTimedChannel() {
+    const timedChannel = this.#channel.QueryInterface(Ci.nsITimedChannel);
+    this.#redirectCount = timedChannel.redirectCount;
+    this.#requestData.timings = this.#getTimingsFromTimedChannel(timedChannel);
+  }
+}
diff --git a/remote/shared/listeners/NetworkListener.sys.mjs b/remote/shared/listeners/NetworkListener.sys.mjs
new file mode 100644
index 0000000000..d4d24f155e
--- /dev/null
+++ b/remote/shared/listeners/NetworkListener.sys.mjs
@@ -0,0 +1,99 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  EventEmitter: "resource://gre/modules/EventEmitter.sys.mjs",
+  NetworkObserver:
+    "resource://devtools/shared/network-observer/NetworkObserver.sys.mjs",
+
+  NetworkEventRecord:
+    "chrome://remote/content/shared/listeners/NetworkEventRecord.sys.mjs",
+});
+
+/**
+ * The NetworkListener listens to all network activity from the parent
+ * process.
+ *
+ * Example:
+ * ```
+ * const listener = new NetworkListener();
+ * listener.on("before-request-sent", onBeforeRequestSent);
+ * listener.startListening();
+ *
+ * const onBeforeRequestSent = (eventName, data = {}) => {
+ *   const { cntextId, redirectCount, requestData, requestId, timestamp } = data;
+ *   ...
+ * };
+ * ```
+ *
+ * @fires before-request-sent
+ *    The NetworkListener emits "before-request-sent" events, with the
+ *    following object as payload:
+ *      - {number} browsingContextId - The browsing context id of the browsing
+ *        context where this request was performed.
+ *      - {number} redirectCount - The request's redirect count.
+ *      - {RequestData} requestData - The request's data as expected by
+ *        WebDriver BiDi.
+ *      - {string} requestId - The id of the request, consistent across
+ *        redirects.
+ *      - {number} timestamp - Timestamp when the event was generated.
+ */
+export class NetworkListener {
+  #devtoolsNetworkObserver;
+  #listening;
+
+  constructor() {
+    lazy.EventEmitter.decorate(this);
+
+    this.#listening = false;
+  }
+
+  destroy() {
+    this.stopListening();
+  }
+
+  startListening() {
+    if (this.#listening) {
+      return;
+    }
+
+    this.#devtoolsNetworkObserver = new lazy.NetworkObserver({
+      ignoreChannelFunction: this.#ignoreChannelFunction,
+      onNetworkEvent: this.#onNetworkEvent,
+    });
+
+    this.#listening = true;
+  }
+
+  stopListening() {
+    if (!this.#listening) {
+      return;
+    }
+
+    this.#devtoolsNetworkObserver.destroy();
+    this.#devtoolsNetworkObserver = null;
+
+    this.#listening = false;
+  }
+
+  #ignoreChannelFunction = channel => {
+    // Ignore chrome-privileged or DevTools-initiated requests
+    if (
+      channel.loadInfo?.loadingDocument === null &&
+      (channel.loadInfo.loadingPrincipal ===
+        Services.scriptSecurityManager.getSystemPrincipal() ||
+        channel.loadInfo.isInDevToolsContext)
+    ) {
+      return true;
+    }
+
+    return false;
+  };
+
+  #onNetworkEvent = (networkEvent, channel) => {
+    return new lazy.NetworkEventRecord(networkEvent, channel, this);
+  };
+}
diff --git a/remote/shared/listeners/test/browser/browser.ini b/remote/shared/listeners/test/browser/browser.ini
new file mode 100644
index 0000000000..1833cc1ded
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser.ini
@@ -0,0 +1,14 @@
+[DEFAULT]
+tags = remote
+subsuite = remote
+support-files =
+  head.js
+prefs =
+  remote.messagehandler.modulecache.useBrowserTestRoot=true
+
+[browser_BrowsingContextListener.js]
+[browser_ConsoleAPIListener.js]
+[browser_ConsoleAPIListener_cached_messages.js]
+[browser_ConsoleListener.js]
+[browser_ConsoleListener_cached_messages.js]
+[browser_NetworkListener.js]
diff --git a/remote/shared/listeners/test/browser/browser_BrowsingContextListener.js b/remote/shared/listeners/test/browser/browser_BrowsingContextListener.js
new file mode 100644
index 0000000000..9a08df7857
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser_BrowsingContextListener.js
@@ -0,0 +1,117 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { BrowsingContextListener } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/listeners/BrowsingContextListener.sys.mjs"
+);
+
+add_task(async function test_attachedOnNewTab() {
+  const listener = new BrowsingContextListener();
+  const attached = listener.once("attached");
+
+  listener.startListening();
+
+  const tab = BrowserTestUtils.addTab(gBrowser, "about:blank");
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  const { browsingContext, why } = await attached;
+
+  is(
+    browsingContext.id,
+    tab.linkedBrowser.browsingContext.id,
+    "Received expected browsing context"
+  );
+  is(why, "attach", "Browsing context has been attached");
+
+  listener.stopListening();
+  gBrowser.removeTab(tab);
+});
+
+add_task(async function test_attachedValidEmbedderElement() {
+  const listener = new BrowsingContextListener();
+
+  let hasEmbedderElement = false;
+  listener.on(
+    "attached",
+    (evtName, { browsingContext }) => {
+      hasEmbedderElement = !!browsingContext.embedderElement;
+    },
+    { once: true }
+  );
+
+  listener.startListening();
+
+  const tab = BrowserTestUtils.addTab(gBrowser, "about:blank");
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  ok(
+    hasEmbedderElement,
+    "Attached browsing context has a valid embedder element"
+  );
+
+  listener.stopListening();
+  gBrowser.removeTab(tab);
+});
+
+add_task(async function test_discardedOnCloseTab() {
+  const listener = new BrowsingContextListener();
+  const discarded = listener.once("discarded");
+
+  const tab = BrowserTestUtils.addTab(gBrowser, "about:blank");
+  const browsingContext = tab.linkedBrowser.browsingContext;
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  listener.startListening();
+  gBrowser.removeTab(tab);
+  const { browsingContext: discardedBrowsingContext, why } = await discarded;
+
+  is(
+    discardedBrowsingContext.id,
+    browsingContext.id,
+    "Received expected browsing context"
+  );
+  is(why, "discard", "Browsing context has been discarded");
+
+  listener.stopListening();
+});
+
+add_task(async function test_replaceTopLevelOnNavigation() {
+  const listener = new BrowsingContextListener();
+  const attached = listener.once("attached");
+  const discarded = listener.once("discarded");
+
+  const tab = BrowserTestUtils.addTab(gBrowser, "about:blank");
+  const browsingContext = tab.linkedBrowser.browsingContext;
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+
+  listener.startListening();
+
+  await loadURL(tab.linkedBrowser, "about:mozilla");
+
+  const discardEvent = await discarded;
+  const attachEvent = await attached;
+
+  is(
+    discardEvent.browsingContext.id,
+    browsingContext.id,
+    "Received expected browsing context for discarded"
+  );
+  is(discardEvent.why, "replace", "Browsing context has been replaced");
+
+  is(
+    attachEvent.browsingContext.id,
+    tab.linkedBrowser.browsingContext.id,
+    "Received expected browsing context for attached"
+  );
+  is(discardEvent.why, "replace", "Browsing context has been replaced");
+
+  isnot(
+    discardEvent.browsingContext,
+    attachEvent.browsingContext,
+    "Got different browsing contexts"
+  );
+
+  listener.stopListening();
+  gBrowser.removeTab(gBrowser.selectedTab);
+});
diff --git a/remote/shared/listeners/test/browser/browser_ConsoleAPIListener.js b/remote/shared/listeners/test/browser/browser_ConsoleAPIListener.js
new file mode 100644
index 0000000000..ccff78c7a0
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser_ConsoleAPIListener.js
@@ -0,0 +1,162 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const TESTS = [
+  { method: "log", args: ["log1"] },
+  { method: "log", args: ["log2", "log3"] },
+  { method: "log", args: [[1, 2, 3], { someProperty: "someValue" }] },
+  { method: "warn", args: ["warn1"] },
+  { method: "error", args: ["error1"] },
+  { method: "info", args: ["info1"] },
+  { method: "debug", args: ["debug1"] },
+  { method: "trace", args: ["trace1"] },
+  { method: "assert", args: [false, "assert1"] },
+];
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+add_task(async function test_method_and_arguments() {
+  for (const { method, args } of TESTS) {
+    // Use a dedicated tab for each test to avoid cached messages.
+    gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+    await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+
+    info(`Test ConsoleApiListener for ${JSON.stringify({ method, args })}`);
+
+    const listenerId = await listenToConsoleAPIMessage();
+    await useConsoleInContent(method, args);
+    const {
+      arguments: msgArguments,
+      level,
+      timeStamp,
+      stacktrace,
+    } = await getConsoleAPIMessage(listenerId);
+
+    if (method == "assert") {
+      // console.assert() consumes first argument.
+      args.shift();
+    }
+
+    is(
+      msgArguments.length,
+      args.length,
+      "Message event has the expected number of arguments"
+    );
+    for (let i = 0; i < args.length; i++) {
+      Assert.deepEqual(
+        msgArguments[i],
+        args[i],
+        `Message event has the expected argument at index ${i}`
+      );
+    }
+    is(level, method, "Message event has the expected level");
+    ok(Number.isInteger(timeStamp), "Message event has a valid timestamp");
+
+    if (["assert", "error", "warn", "trace"].includes(method)) {
+      // Check stacktrace if method is allowed to contain one.
+      if (method === "warn") {
+        todo(
+          Array.isArray(stacktrace),
+          "stacktrace is of expected type Array (Bug 1744705)"
+        );
+      } else {
+        ok(Array.isArray(stacktrace), "stacktrace is of expected type Array");
+        Assert.greaterOrEqual(
+          stacktrace.length,
+          1,
+          "stack trace contains at least one frame"
+        );
+      }
+    } else {
+      is(typeof stacktrace, "undefined", "stack trace is is not present");
+    }
+
+    gBrowser.removeTab(gBrowser.selectedTab);
+  }
+});
+
+add_task(async function test_stacktrace() {
+  const script = `
+    function foo() { console.error("cheese"); }
+    function bar() { foo(); }
+    bar();
+  `;
+
+  const listenerId = await listenToConsoleAPIMessage();
+  await createScriptNode(script);
+  const { stacktrace } = await getConsoleAPIMessage(listenerId);
+
+  ok(Array.isArray(stacktrace), "stacktrace is of expected type Array");
+
+  // First 3 frames are from the test script.
+  Assert.greaterOrEqual(
+    stacktrace.length,
+    3,
+    "stack trace contains at least 3 frames"
+  );
+  checkStackFrame(stacktrace[0], "about:blank", "foo", 2, 30);
+  checkStackFrame(stacktrace[1], "about:blank", "bar", 3, 22);
+  checkStackFrame(stacktrace[2], "about:blank", "", 4, 5);
+});
+
+function useConsoleInContent(method, args) {
+  info(`Call console API: console.${method}("${args.join('", "')}");`);
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [method, args],
+    (_method, _args) => {
+      content.console[_method].apply(content.console, _args);
+    }
+  );
+}
+
+function listenToConsoleAPIMessage() {
+  info("Listen to a console api message in content");
+  return SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const innerWindowId = content.windowGlobalChild.innerWindowId;
+    const { ConsoleAPIListener } = ChromeUtils.importESModule(
+      "chrome://remote/content/shared/listeners/ConsoleAPIListener.sys.mjs"
+    );
+    const consoleAPIListener = new ConsoleAPIListener(innerWindowId);
+    const onMessage = consoleAPIListener.once("message");
+    consoleAPIListener.startListening();
+
+    const listenerId = Math.random();
+    content[listenerId] = { consoleAPIListener, onMessage };
+    return listenerId;
+  });
+}
+
+function getConsoleAPIMessage(listenerId) {
+  info("Retrieve the message event captured for listener: " + listenerId);
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [listenerId],
+    async _listenerId => {
+      const { consoleAPIListener, onMessage } = content[_listenerId];
+      const message = await onMessage;
+
+      consoleAPIListener.destroy();
+
+      return message;
+    }
+  );
+}
+
+function checkStackFrame(
+  frame,
+  filename,
+  functionName,
+  lineNumber,
+  columnNumber
+) {
+  is(frame.filename, filename, "Received expected filename for frame");
+  is(
+    frame.functionName,
+    functionName,
+    "Received expected function name for frame"
+  );
+  is(frame.lineNumber, lineNumber, "Received expected line for frame");
+  is(frame.columnNumber, columnNumber, "Received expected column for frame");
+}
diff --git a/remote/shared/listeners/test/browser/browser_ConsoleAPIListener_cached_messages.js b/remote/shared/listeners/test/browser/browser_ConsoleAPIListener_cached_messages.js
new file mode 100644
index 0000000000..dae35a0b9a
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser_ConsoleAPIListener_cached_messages.js
@@ -0,0 +1,100 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+add_task(async function test_cached_messages() {
+  gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+  await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const innerWindowId = content.windowGlobalChild.innerWindowId;
+    const { ConsoleAPIListener } = ChromeUtils.importESModule(
+      "chrome://remote/content/shared/listeners/ConsoleAPIListener.sys.mjs"
+    );
+
+    info("Log two messages before starting the ConsoleAPIListener");
+    content.console.log("message_1");
+    content.console.log("message_2");
+
+    const listener = new ConsoleAPIListener(innerWindowId);
+    const messages = [];
+
+    // We will keep the onMessage callback attached to the ConsoleAPIListener
+    // during the whole test to catch all the emitted events.
+    const onMessage = (evtName, message) => messages.push(message.arguments[0]);
+
+    listener.on("message", onMessage);
+    listener.startListening();
+
+    info("Wait until the 2 cached messages have been emitted");
+    await ContentTaskUtils.waitForCondition(() => messages.length == 2);
+    is(messages[0], "message_1");
+    is(messages[1], "message_2");
+
+    info("Stop listening and log another message");
+    listener.stopListening();
+    content.backup = { listener, messages, onMessage };
+  });
+
+  // Force a GC to check that old cached messages which have been garbage
+  // collected are not re-displayed.
+  await doGC();
+
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const { listener, messages, onMessage } = content.backup;
+    content.console.log("message_3");
+
+    info("Start listening again and check the previous message is emitted");
+    listener.startListening();
+    await ContentTaskUtils.waitForCondition(() => messages.length == 3);
+    is(messages[2], "message_3");
+
+    info("Log another message and wait until it is emitted");
+    content.console.log("message_4");
+    await ContentTaskUtils.waitForCondition(() => messages.length == 4);
+    is(messages[3], "message_4");
+
+    listener.off("message", onMessage);
+    listener.destroy();
+
+    is(messages.length, 4, "Received 4 messages in total");
+  });
+
+  info("Reload the current tab and check only new messages are emitted");
+  await BrowserTestUtils.reloadTab(gBrowser.selectedTab);
+
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const innerWindowId = content.windowGlobalChild.innerWindowId;
+    const { ConsoleAPIListener } = ChromeUtils.importESModule(
+      "chrome://remote/content/shared/listeners/ConsoleAPIListener.sys.mjs"
+    );
+
+    info("Log a message before creating the ConsoleAPIListener");
+    content.console.log("new_message_1");
+
+    const listener = new ConsoleAPIListener(innerWindowId);
+    const newMessages = [];
+    const onMessage = (evtName, message) =>
+      newMessages.push(message.arguments[0]);
+    listener.on("message", onMessage);
+
+    info("Start listening and wait for the cached message");
+    listener.startListening();
+    await ContentTaskUtils.waitForCondition(() => newMessages.length == 1);
+    is(newMessages[0], "new_message_1");
+
+    info("Log another message and wait until it is emitted");
+    content.console.log("new_message_2");
+    await ContentTaskUtils.waitForCondition(() => newMessages.length == 2);
+    is(newMessages[1], "new_message_2");
+
+    listener.off("message", onMessage);
+    listener.destroy();
+
+    is(newMessages.length, 2, "Received 2 messages in total");
+  });
+
+  gBrowser.removeTab(gBrowser.selectedTab);
+});
diff --git a/remote/shared/listeners/test/browser/browser_ConsoleListener.js b/remote/shared/listeners/test/browser/browser_ConsoleListener.js
new file mode 100644
index 0000000000..41936a6c0d
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser_ConsoleListener.js
@@ -0,0 +1,148 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+add_task(async function test_message_properties() {
+  const listenerId = await listenToConsoleMessage("error");
+  await logConsoleMessage({ message: "foo" });
+  const { level, message, timeStamp, stack } = await getConsoleMessage(
+    listenerId
+  );
+
+  is(level, "error", "Received expected log level");
+  is(message, "foo", "Received expected log message");
+  // Services.console.logMessage() doesn't include a stack.
+  is(stack, undefined, "No stack present");
+  is(typeof timeStamp, "number", "timestamp is of expected type number");
+
+  // Clear the console to avoid side effects with other tests in this file.
+  await clearConsole();
+});
+
+add_task(async function test_level() {
+  for (const level of ["error", "info", "warn"]) {
+    const listenerId = await listenToConsoleMessage(level);
+    await logConsoleMessage({ message: "foo", level });
+    const message = await getConsoleMessage(listenerId);
+
+    is(message.level, level, "Received expected log level");
+  }
+
+  // Clear the console to avoid side effects with other tests in this file.
+  await clearConsole();
+});
+
+add_task(async function test_stacktrace() {
+  const script = `
+    function foo() { throw new Error("cheese"); }
+    function bar() { foo(); }
+    bar();
+  `;
+
+  const listenerId = await listenToConsoleMessage("error");
+  await createScriptNode(script);
+  const { message, level, stacktrace } = await getConsoleMessage(listenerId);
+  is(level, "error", "Received expected log level");
+  is(message, "Error: cheese", "Received expected log message");
+  ok(Array.isArray(stacktrace), "frames is of expected type Array");
+  Assert.greaterOrEqual(stacktrace.length, 4, "Got at least 4 stack frames");
+
+  // First 3 stack frames are from the injected script and one more frame comes
+  // from head.js (chrome scope) where we inject the script.
+  checkStackFrame(stacktrace[0], "about:blank", "foo", 2, 28);
+  checkStackFrame(stacktrace[1], "about:blank", "bar", 3, 22);
+  checkStackFrame(stacktrace[2], "about:blank", "", 4, 5);
+  checkStackFrame(
+    stacktrace[3],
+    "chrome://mochitests/content/browser/remote/shared/listeners/test/browser/head.js",
+    "",
+    34,
+    29
+  );
+
+  // Clear the console to avoid side effects with other tests in this file.
+  await clearConsole();
+});
+
+function logConsoleMessage(options = {}) {
+  info(`Log console message ${options.message}`);
+  return SpecialPowers.spawn(gBrowser.selectedBrowser, [options], _options => {
+    const { level = "error" } = _options;
+
+    const levelToFlags = {
+      error: Ci.nsIScriptError.errorFlag,
+      info: Ci.nsIScriptError.infoFlag,
+      warn: Ci.nsIScriptError.warningFlag,
+    };
+
+    const scriptError = Cc["@mozilla.org/scripterror;1"].createInstance(
+      Ci.nsIScriptError
+    );
+    scriptError.initWithWindowID(
+      _options.message,
+      _options.sourceName || "sourceName",
+      null,
+      _options.lineNumber || 0,
+      _options.columnNumber || 0,
+      levelToFlags[level],
+      _options.category || "javascript",
+      content.windowGlobalChild.innerWindowId
+    );
+
+    Services.console.logMessage(scriptError);
+  });
+}
+
+function listenToConsoleMessage(level) {
+  info("Listen to a console message in content");
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [level],
+    async _level => {
+      const innerWindowId = content.windowGlobalChild.innerWindowId;
+      const { ConsoleListener } = ChromeUtils.importESModule(
+        "chrome://remote/content/shared/listeners/ConsoleListener.sys.mjs"
+      );
+      const consoleListener = new ConsoleListener(innerWindowId);
+      const onMessage = consoleListener.once(_level);
+      consoleListener.startListening();
+
+      const listenerId = Math.random();
+      content[listenerId] = { consoleListener, onMessage };
+      return listenerId;
+    }
+  );
+}
+
+function getConsoleMessage(listenerId) {
+  info("Retrieve the message event captured for listener: " + listenerId);
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [listenerId],
+    async _listenerId => {
+      const { consoleListener, onMessage } = content[_listenerId];
+      const message = await onMessage;
+
+      consoleListener.destroy();
+
+      return message;
+    }
+  );
+}
+
+function checkStackFrame(
+  frame,
+  filename,
+  functionName,
+  lineNumber,
+  columnNumber
+) {
+  is(frame.filename, filename, "Received expected filename for frame");
+  is(
+    frame.functionName,
+    functionName,
+    "Received expected function name for frame"
+  );
+  is(frame.lineNumber, lineNumber, "Received expected line for frame");
+  is(frame.columnNumber, columnNumber, "Received expected column for frame");
+}
diff --git a/remote/shared/listeners/test/browser/browser_ConsoleListener_cached_messages.js b/remote/shared/listeners/test/browser/browser_ConsoleListener_cached_messages.js
new file mode 100644
index 0000000000..1020aee661
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser_ConsoleListener_cached_messages.js
@@ -0,0 +1,82 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const TEST_PAGE =
+  "https://example.com/document-builder.sjs?html=<meta charset=utf8></meta>";
+
+add_task(async function test_cached_javascript_errors() {
+  gBrowser.selectedTab = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+  await BrowserTestUtils.browserLoaded(gBrowser.selectedBrowser);
+
+  await createScriptNode(`(() => {throw "error1"})()`);
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const innerWindowId = content.windowGlobalChild.innerWindowId;
+    const { ConsoleListener } = ChromeUtils.importESModule(
+      "chrome://remote/content/shared/listeners/ConsoleListener.sys.mjs"
+    );
+
+    const listener = new ConsoleListener(innerWindowId);
+
+    const errors = [];
+    // Do not push the whole error object in the array. It would create a strong
+    // reference preventing from reproducing GC-related bugs.
+    const onError = (evtName, error) => errors.push(error.message);
+    listener.on("error", onError);
+
+    const waitForMessage = listener.once("error");
+    listener.startListening();
+    const error = await waitForMessage;
+    is(error.message, "uncaught exception: error1");
+    is(errors.length, 1);
+
+    listener.stopListening();
+    content.backup = { listener, errors, onError };
+  });
+
+  // Force a GC to check that old cached messages which have been garbage
+  // collected are not re-displayed.
+  await doGC();
+  await createScriptNode(`(() => {throw "error2"})()`);
+
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const { listener, errors, onError } = content.backup;
+
+    const waitForMessage = listener.once("error");
+    listener.startListening();
+    const { message } = await waitForMessage;
+    is(message, "uncaught exception: error2");
+    is(errors.length, 2);
+
+    listener.off("error", onError);
+    listener.destroy();
+  });
+
+  info("Reload the current tab and check only new messages are emitted");
+  await BrowserTestUtils.reloadTab(gBrowser.selectedTab);
+
+  await createScriptNode(`(() => {throw "error3"})()`);
+  await SpecialPowers.spawn(gBrowser.selectedBrowser, [], async () => {
+    const innerWindowId = content.windowGlobalChild.innerWindowId;
+    const { ConsoleListener } = ChromeUtils.importESModule(
+      "chrome://remote/content/shared/listeners/ConsoleListener.sys.mjs"
+    );
+
+    const listener = new ConsoleListener(innerWindowId);
+
+    const errors = [];
+    const onError = (evtName, error) => errors.push(error.message);
+    listener.on("error", onError);
+
+    const waitForMessage = listener.once("error");
+    listener.startListening();
+    const error = await waitForMessage;
+    is(error.message, "uncaught exception: error3");
+    is(errors.length, 1);
+
+    listener.off("error", onError);
+    listener.destroy();
+  });
+
+  gBrowser.removeTab(gBrowser.selectedTab);
+});
diff --git a/remote/shared/listeners/test/browser/browser_NetworkListener.js b/remote/shared/listeners/test/browser/browser_NetworkListener.js
new file mode 100644
index 0000000000..d756c4ffac
--- /dev/null
+++ b/remote/shared/listeners/test/browser/browser_NetworkListener.js
@@ -0,0 +1,84 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { NetworkListener } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/listeners/NetworkListener.sys.mjs"
+);
+const { TabManager } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/TabManager.sys.mjs"
+);
+
+add_task(async function test_beforeRequestSent() {
+  const listener = new NetworkListener();
+  const events = [];
+  const onEvent = (name, data) => events.push(data);
+  listener.on("before-request-sent", onEvent);
+
+  const tab1 = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab1.linkedBrowser);
+  const contextId1 = TabManager.getIdForBrowser(tab1.linkedBrowser);
+
+  const tab2 = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab2"
+  );
+  await BrowserTestUtils.browserLoaded(tab2.linkedBrowser);
+  const contextId2 = TabManager.getIdForBrowser(tab2.linkedBrowser);
+
+  listener.startListening();
+
+  await fetch(tab1.linkedBrowser, "https://example.com/?1");
+  ok(events.length == 1, "One event was received");
+  assertNetworkEvent(events[0], contextId1, "https://example.com/?1");
+
+  info("Check that events are no longer emitted after calling stopListening");
+  listener.stopListening();
+  await fetch(tab1.linkedBrowser, "https://example.com/?2");
+  ok(events.length == 1, "No new event was received");
+
+  listener.startListening();
+  await fetch(tab1.linkedBrowser, "https://example.com/?3");
+  ok(events.length == 2, "A new event was received");
+  assertNetworkEvent(events[1], contextId1, "https://example.com/?3");
+
+  info("Check network event from the new tab");
+  await fetch(tab2.linkedBrowser, "https://example.com/?4");
+  ok(events.length == 3, "A new event was received");
+  assertNetworkEvent(events[2], contextId2, "https://example.com/?4");
+
+  gBrowser.removeTab(tab1);
+  gBrowser.removeTab(tab2);
+  listener.off("before-request-sent", onEvent);
+  listener.destroy();
+});
+
+add_task(async function test_beforeRequestSent_newTab() {
+  const listener = new NetworkListener();
+  const onBeforeRequestSent = listener.once("before-request-sent");
+  listener.startListening();
+
+  info("Check network event related to loading a new tab");
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const contextId = TabManager.getIdForBrowser(tab.linkedBrowser);
+  const event = await onBeforeRequestSent;
+
+  assertNetworkEvent(
+    event,
+    contextId,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  gBrowser.removeTab(tab);
+});
+
+function assertNetworkEvent(event, expectedContextId, expectedUrl) {
+  is(event.contextId, expectedContextId, "Event has the expected context id");
+  is(event.requestData.url, expectedUrl, "Event has the expected url");
+}
diff --git a/remote/shared/listeners/test/browser/head.js b/remote/shared/listeners/test/browser/head.js
new file mode 100644
index 0000000000..77b18515f3
--- /dev/null
+++ b/remote/shared/listeners/test/browser/head.js
@@ -0,0 +1,89 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+async function clearConsole() {
+  for (const tab of gBrowser.tabs) {
+    await SpecialPowers.spawn(tab.linkedBrowser, [], () => {
+      Services.console.reset();
+    });
+  }
+  Services.console.reset();
+}
+
+/**
+ * Execute the provided script content by generating a dynamic script tag and
+ * inserting it in the page for the current selected browser.
+ *
+ * @param {string} script
+ *     The script to execute.
+ * @returns {Promise}
+ *     A promise that resolves when the script node was added and removed from
+ *     the content page.
+ */
+function createScriptNode(script) {
+  return SpecialPowers.spawn(
+    gBrowser.selectedBrowser,
+    [script],
+    function (_script) {
+      var script = content.document.createElement("script");
+      script.append(content.document.createTextNode(_script));
+      content.document.body.append(script);
+    }
+  );
+}
+
+registerCleanupFunction(async () => {
+  await clearConsole();
+});
+
+async function doGC() {
+  // Run GC and CC a few times to make sure that as much as possible is freed.
+  const numCycles = 3;
+  for (let i = 0; i < numCycles; i++) {
+    Cu.forceGC();
+    Cu.forceCC();
+    await new Promise(resolve => Cu.schedulePreciseShrinkingGC(resolve));
+  }
+
+  const MemoryReporter = Cc[
+    "@mozilla.org/memory-reporter-manager;1"
+  ].getService(Ci.nsIMemoryReporterManager);
+  await new Promise(resolve => MemoryReporter.minimizeMemoryUsage(resolve));
+}
+
+/**
+ * Load the provided url in an existing browser.
+ * Returns a promise which will resolve when the page is loaded.
+ *
+ * @param {Browser} browser
+ *     The browser element where the URL should be loaded.
+ * @param {string} url
+ *     The URL to load.
+ */
+async function loadURL(browser, url) {
+  const loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.loadURIString(browser, url);
+  return loaded;
+}
+
+/**
+ * Create a fetch request to `url` from the content page loaded in the provided
+ * `browser`.
+ *
+ *
+ * @param {Browser} browser
+ *     The browser element where the fetch should be performed.
+ * @param {string} url
+ *     The URL to fetch.
+ */
+function fetch(browser, url) {
+  return SpecialPowers.spawn(browser, [url], async _url => {
+    const response = await content.fetch(_url);
+    // Wait for response.text() to resolve as well to make sure the response
+    // has completed before returning.
+    await response.text();
+  });
+}
diff --git a/remote/shared/messagehandler/Errors.sys.mjs b/remote/shared/messagehandler/Errors.sys.mjs
new file mode 100644
index 0000000000..69c65acd09
--- /dev/null
+++ b/remote/shared/messagehandler/Errors.sys.mjs
@@ -0,0 +1,90 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { RemoteError } from "chrome://remote/content/shared/RemoteError.sys.mjs";
+
+class MessageHandlerError extends RemoteError {
+  /**
+   * @param {(string|Error)=} x
+   *     Optional string describing error situation or Error instance
+   *     to propagate.
+   */
+  constructor(x) {
+    super(x);
+    this.name = this.constructor.name;
+    this.status = "message handler error";
+
+    // Error's ctor does not preserve x' stack
+    if (typeof x?.stack !== "undefined") {
+      this.stack = x.stack;
+    }
+  }
+
+  get isMessageHandlerError() {
+    return true;
+  }
+
+  /**
+   * @returns {Object<string, string>}
+   *     JSON serialisation of error prototype.
+   */
+  toJSON() {
+    return {
+      error: this.status,
+      message: this.message || "",
+      stacktrace: this.stack || "",
+    };
+  }
+
+  /**
+   * Unmarshals a JSON error representation to the appropriate MessageHandler
+   * error type.
+   *
+   * @param {Object<string, string>} json
+   *     Error object.
+   *
+   * @returns {Error}
+   *     Error prototype.
+   */
+  static fromJSON(json) {
+    if (typeof json.error == "undefined") {
+      let s = JSON.stringify(json);
+      throw new TypeError("Undeserialisable error type: " + s);
+    }
+    if (!STATUSES.has(json.error)) {
+      throw new TypeError("Not of MessageHandlerError descent: " + json.error);
+    }
+
+    let cls = STATUSES.get(json.error);
+    let err = new cls();
+    if ("message" in json) {
+      err.message = json.message;
+    }
+    if ("stacktrace" in json) {
+      err.stack = json.stacktrace;
+    }
+    return err;
+  }
+}
+
+/**
+ * A command could not be handled by the message handler network.
+ */
+class UnsupportedCommandError extends MessageHandlerError {
+  constructor(message) {
+    super(message);
+    this.status = "unsupported message handler command";
+  }
+}
+
+const STATUSES = new Map([
+  ["message handler error", MessageHandlerError],
+  ["unsupported message handler command", UnsupportedCommandError],
+]);
+
+/** @namespace */
+export const error = {
+  MessageHandlerError,
+  UnsupportedCommandError,
+};
diff --git a/remote/shared/messagehandler/EventsDispatcher.sys.mjs b/remote/shared/messagehandler/EventsDispatcher.sys.mjs
new file mode 100644
index 0000000000..b5db49ee7c
--- /dev/null
+++ b/remote/shared/messagehandler/EventsDispatcher.sys.mjs
@@ -0,0 +1,237 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ContextDescriptorType:
+    "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  SessionDataCategory:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+  SessionDataMethod:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+  TabManager: "chrome://remote/content/shared/TabManager.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * Helper to listen to events which rely on SessionData.
+ * In order to support the EventsDispatcher, a module emitting events should
+ * subscribe and unsubscribe to those events based on SessionData updates
+ * and should use the "event" SessionData category.
+ */
+export class EventsDispatcher {
+  // The MessageHandler owning this EventsDispatcher.
+  #messageHandler;
+
+  /**
+   * @typedef {object} EventListenerInfo
+   * @property {ContextDescriptor} contextDescriptor
+   *     The ContextDescriptor to which those callbacks are associated
+   * @property {Set<Function>} callbacks
+   *     The callbacks to trigger when an event matching the ContextDescriptor
+   *     is received.
+   */
+
+  // Map from event name to map of strings (context keys) to EventListenerInfo.
+  #listenersByEventName;
+
+  /**
+   * Create a new EventsDispatcher instance.
+   *
+   * @param {MessageHandler} messageHandler
+   *     The MessageHandler owning this EventsDispatcher.
+   */
+  constructor(messageHandler) {
+    this.#messageHandler = messageHandler;
+
+    this.#listenersByEventName = new Map();
+  }
+
+  destroy() {
+    for (const event of this.#listenersByEventName.keys()) {
+      this.#messageHandler.off(event, this.#onMessageHandlerEvent);
+    }
+
+    this.#listenersByEventName = null;
+  }
+
+  /**
+   * Stop listening for an event relying on SessionData and relayed by the
+   * message handler.
+   *
+   * @param {string} event
+   *     Name of the event to unsubscribe from.
+   * @param {ContextDescriptor} contextDescriptor
+   *     Context descriptor for this event.
+   * @param {Function} callback
+   *     Event listener callback.
+   * @returns {Promise}
+   *     Promise which resolves when the event fully unsubscribed, including
+   *     propagating the necessary session data.
+   */
+  async off(event, contextDescriptor, callback) {
+    return this.update([{ event, contextDescriptor, callback, enable: false }]);
+  }
+
+  /**
+   * Listen for an event relying on SessionData and relayed by the message
+   * handler.
+   *
+   * @param {string} event
+   *     Name of the event to subscribe to.
+   * @param {ContextDescriptor} contextDescriptor
+   *     Context descriptor for this event.
+   * @param {Function} callback
+   *     Event listener callback.
+   * @returns {Promise}
+   *     Promise which resolves when the event fully subscribed to, including
+   *     propagating the necessary session data.
+   */
+  async on(event, contextDescriptor, callback) {
+    return this.update([{ event, contextDescriptor, callback, enable: true }]);
+  }
+
+  /**
+   * An object that holds information about subscription/unsubscription
+   * of an event.
+   *
+   * @typedef Subscription
+   *
+   * @param {string} event
+   *     Name of the event to subscribe/unsubscribe to.
+   * @param {ContextDescriptor} contextDescriptor
+   *     Context descriptor for this event.
+   * @param {Function} callback
+   *     Event listener callback.
+   * @param {boolean} enable
+   *     True, if we need to subscribe to an event.
+   *     Otherwise false.
+   */
+
+  /**
+   * Start or stop listening to a list of events relying on SessionData
+   * and relayed by the message handler.
+   *
+   * @param {Array<Subscription>} subscriptions
+   *     The list of information to subscribe/unsubscribe to.
+   *
+   * @returns {Promise}
+   *     Promise which resolves when the events fully subscribed/unsubscribed to,
+   *     including propagating the necessary session data.
+   */
+  async update(subscriptions) {
+    const sessionDataItemUpdates = [];
+    subscriptions.forEach(({ event, contextDescriptor, callback, enable }) => {
+      if (enable) {
+        // Setup listeners.
+        if (!this.#listenersByEventName.has(event)) {
+          this.#listenersByEventName.set(event, new Map());
+          this.#messageHandler.on(event, this.#onMessageHandlerEvent);
+        }
+
+        const key = this.#getContextKey(contextDescriptor);
+        const listeners = this.#listenersByEventName.get(event);
+        if (listeners.has(key)) {
+          const { callbacks } = listeners.get(key);
+          callbacks.add(callback);
+        } else {
+          const callbacks = new Set([callback]);
+          listeners.set(key, { callbacks, contextDescriptor });
+
+          sessionDataItemUpdates.push({
+            ...this.#getSessionDataItem(event, contextDescriptor),
+            method: lazy.SessionDataMethod.Add,
+          });
+        }
+      } else {
+        // Remove listeners.
+        const listeners = this.#listenersByEventName.get(event);
+        if (!listeners) {
+          return;
+        }
+
+        const key = this.#getContextKey(contextDescriptor);
+        if (!listeners.has(key)) {
+          return;
+        }
+
+        const { callbacks } = listeners.get(key);
+        if (callbacks.has(callback)) {
+          callbacks.delete(callback);
+          if (callbacks.size === 0) {
+            listeners.delete(key);
+            if (listeners.size === 0) {
+              this.#messageHandler.off(event, this.#onMessageHandlerEvent);
+              this.#listenersByEventName.delete(event);
+            }
+
+            sessionDataItemUpdates.push({
+              ...this.#getSessionDataItem(event, contextDescriptor),
+              method: lazy.SessionDataMethod.Remove,
+            });
+          }
+        }
+      }
+    });
+
+    // Update all sessionData at once.
+    await this.#messageHandler.updateSessionData(sessionDataItemUpdates);
+  }
+
+  #getContextKey(contextDescriptor) {
+    const { id, type } = contextDescriptor;
+    return `${type}-${id}`;
+  }
+
+  #getSessionDataItem(event, contextDescriptor) {
+    const [moduleName] = event.split(".");
+    return {
+      moduleName,
+      category: lazy.SessionDataCategory.Event,
+      contextDescriptor,
+      values: [event],
+    };
+  }
+
+  #matchesContext(contextInfo, contextDescriptor) {
+    if (contextDescriptor.type === lazy.ContextDescriptorType.All) {
+      return true;
+    }
+
+    if (
+      contextDescriptor.type === lazy.ContextDescriptorType.TopBrowsingContext
+    ) {
+      const eventBrowsingContext = lazy.TabManager.getBrowsingContextById(
+        contextInfo.contextId
+      );
+      return eventBrowsingContext?.browserId === contextDescriptor.id;
+    }
+
+    return false;
+  }
+
+  #onMessageHandlerEvent = (name, event, contextInfo) => {
+    const listeners = this.#listenersByEventName.get(name);
+    for (const { callbacks, contextDescriptor } of listeners.values()) {
+      if (!this.#matchesContext(contextInfo, contextDescriptor)) {
+        continue;
+      }
+
+      for (const callback of callbacks) {
+        try {
+          callback(name, event);
+        } catch (e) {
+          lazy.logger.debug(
+            `Error while executing callback for ${name}: ${e.message}`
+          );
+        }
+      }
+    }
+  };
+}
diff --git a/remote/shared/messagehandler/MessageHandler.sys.mjs b/remote/shared/messagehandler/MessageHandler.sys.mjs
new file mode 100644
index 0000000000..ed15ed29b8
--- /dev/null
+++ b/remote/shared/messagehandler/MessageHandler.sys.mjs
@@ -0,0 +1,357 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+import { EventEmitter } from "resource://gre/modules/EventEmitter.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  error: "chrome://remote/content/shared/messagehandler/Errors.sys.mjs",
+  EventsDispatcher:
+    "chrome://remote/content/shared/messagehandler/EventsDispatcher.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  ModuleCache:
+    "chrome://remote/content/shared/messagehandler/ModuleCache.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * A ContextDescriptor object provides information to decide if a broadcast or
+ * a session data item should be applied to a specific MessageHandler context.
+ *
+ * @typedef {object} ContextDescriptor
+ * @property {ContextDescriptorType} type
+ *     The type of context
+ * @property {string=} id
+ *     Unique id of a given context for the provided type.
+ *     For ContextDescriptorType.All, id can be ommitted.
+ *     For ContextDescriptorType.TopBrowsingContext, the id should be the
+ *     browserId corresponding to a top-level browsing context.
+ */
+
+/**
+ * Enum of ContextDescriptor types.
+ *
+ * @enum {string}
+ */
+export const ContextDescriptorType = {
+  All: "All",
+  TopBrowsingContext: "TopBrowsingContext",
+};
+
+/**
+ * A ContextInfo identifies a given context that can be linked to a MessageHandler
+ * instance. It should be used to identify events coming from this context.
+ *
+ * It can either be provided by the MessageHandler itself, when the event is
+ * emitted from the context it relates to.
+ *
+ * Or it can be assembled manually, for instance when emitting an event which
+ * relates to a window global from the root layer (eg browsingContext.contextCreated).
+ *
+ * @typedef {object} ContextInfo
+ * @property {string} contextId
+ *     Unique id of the MessageHandler corresponding to this context.
+ * @property {string} type
+ *     One of MessageHandler.type.
+ */
+
+/**
+ * MessageHandler instances are dedicated to handle both Commands and Events
+ * to enable automation and introspection for remote control protocols.
+ *
+ * MessageHandler instances are designed to form a network, where each instance
+ * should allow to inspect a specific context (eg. a BrowsingContext, a Worker,
+ * etc). Those instances might live in different processes and threads but
+ * should be linked together by the usage of a single sessionId, shared by all
+ * the instances of a single MessageHandler network.
+ *
+ * MessageHandler instances will be dynamically spawned depending on which
+ * Command or which Event needs to be processed and should therefore not be
+ * explicitly created by consumers, nor used directly.
+ *
+ * The only exception is the ROOT MessageHandler. This MessageHandler will be
+ * the entry point to send commands to the rest of the network. It will also
+ * emit all the relevant events captured by the network.
+ *
+ * However, even to create this ROOT MessageHandler, consumers should use the
+ * RootMessageHandlerRegistry. This singleton will ensure that MessageHandler
+ * instances are properly registered and can be retrieved based on a given
+ * session id as well as some other context information.
+ */
+export class MessageHandler extends EventEmitter {
+  #context;
+  #contextId;
+  #eventsDispatcher;
+  #moduleCache;
+  #registry;
+  #sessionId;
+
+  /**
+   * Create a new MessageHandler instance.
+   *
+   * @param {string} sessionId
+   *     ID of the session the handler is used for.
+   * @param {object} context
+   *     The context linked to this MessageHandler instance.
+   * @param {MessageHandlerRegistry} registry
+   *     The MessageHandlerRegistry which owns this MessageHandler instance.
+   */
+  constructor(sessionId, context, registry) {
+    super();
+
+    this.#moduleCache = new lazy.ModuleCache(this);
+
+    this.#sessionId = sessionId;
+    this.#context = context;
+    this.#contextId = this.constructor.getIdFromContext(context);
+    this.#eventsDispatcher = new lazy.EventsDispatcher(this);
+    this.#registry = registry;
+  }
+
+  get context() {
+    return this.#context;
+  }
+
+  get contextId() {
+    return this.#contextId;
+  }
+
+  get eventsDispatcher() {
+    return this.#eventsDispatcher;
+  }
+
+  get moduleCache() {
+    return this.#moduleCache;
+  }
+
+  get name() {
+    return [this.sessionId, this.constructor.type, this.contextId].join("-");
+  }
+
+  get registry() {
+    return this.#registry;
+  }
+
+  get sessionId() {
+    return this.#sessionId;
+  }
+
+  destroy() {
+    lazy.logger.trace(
+      `MessageHandler ${this.constructor.type} for session ${this.sessionId} is being destroyed`
+    );
+    this.#eventsDispatcher.destroy();
+    this.#moduleCache.destroy();
+
+    // At least the MessageHandlerRegistry will be expecting this event in order
+    // to remove the instance from the registry when destroyed.
+    this.emit("message-handler-destroyed", this);
+  }
+
+  /**
+   * Emit a message handler event.
+   *
+   * Such events should bubble up to the root of a MessageHandler network.
+   *
+   * @param {string} name
+   *     Name of the event. Protocol level events should be of the
+   *     form [module name].[event name].
+   * @param {object} data
+   *     The event's data.
+   * @param {ContextInfo=} contextInfo
+   *     The event's context info, used to identify the origin of the event.
+   *     If not provided, the context info of the current MessageHandler will be
+   *     used.
+   */
+  emitEvent(name, data, contextInfo) {
+    // If no contextInfo field is provided on the event, extract it from the
+    // MessageHandler instance.
+    contextInfo = contextInfo || this.#getContextInfo();
+
+    // Events are emitted both under their own name for consumers listening to
+    // a specific and as `message-handler-event` for consumers which need to
+    // catch all events.
+    this.emit(name, data, contextInfo);
+    this.emit("message-handler-event", {
+      name,
+      contextInfo,
+      data,
+      sessionId: this.sessionId,
+    });
+  }
+
+  /**
+   * @typedef {object} CommandDestination
+   * @property {string} type
+   *     One of MessageHandler.type.
+   * @property {string=} id
+   *     Unique context identifier. The format depends on the type.
+   *     For WINDOW_GLOBAL destinations, this is a browsing context id.
+   *     Optional, should only be provided if `contextDescriptor` is missing.
+   * @property {ContextDescriptor=} contextDescriptor
+   *     Descriptor used to match several contexts, which will all receive the
+   *     command.
+   *     Optional, should only be provided if `id` is missing.
+   */
+
+  /**
+   * @typedef {object} Command
+   * @property {string} commandName
+   *     The name of the command to execute.
+   * @property {string} moduleName
+   *     The name of the module.
+   * @property {object} params
+   *     Optional command parameters.
+   * @property {CommandDestination} destination
+   *     The destination describing a debuggable context.
+   * @property {boolean=} retryOnAbort
+   *     Optional. When true, commands will be retried upon AbortError, which
+   *     can occur when the underlying JSWindowActor pair is destroyed.
+   *     Defaults to `false`.
+   */
+
+  /**
+   * Retrieve all module classes matching the moduleName and destination.
+   * See `getAllModuleClasses` (ModuleCache.jsm) for more details.
+   *
+   * @param {string} moduleName
+   *     The name of the module.
+   * @param {Destination} destination
+   *     The destination.
+   * @returns {Array.<class<Module>|null>}
+   *     An array of Module classes.
+   */
+  getAllModuleClasses(moduleName, destination) {
+    return this.#moduleCache.getAllModuleClasses(moduleName, destination);
+  }
+
+  /**
+   * Handle a command, either in one of the modules owned by this MessageHandler
+   * or in a another MessageHandler after forwarding the command.
+   *
+   * @param {Command} command
+   *     The command that should be either handled in this layer or forwarded to
+   *     the next layer leading to the destination.
+   * @returns {Promise} A Promise that will resolve with the return value of the
+   *     command once it has been executed.
+   */
+  handleCommand(command) {
+    const { moduleName, commandName, params, destination } = command;
+    lazy.logger.trace(
+      `Received command ${moduleName}.${commandName} for destination ${destination.type}`
+    );
+
+    if (!this.supportsCommand(moduleName, commandName, destination)) {
+      throw new lazy.error.UnsupportedCommandError(
+        `${moduleName}.${commandName} not supported for destination ${destination?.type}`
+      );
+    }
+
+    const module = this.#moduleCache.getModuleInstance(moduleName, destination);
+    if (module && module.supportsMethod(commandName)) {
+      return module[commandName](params, destination);
+    }
+
+    return this.forwardCommand(command);
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} ${this.name}]`;
+  }
+
+  /**
+   * Apply the initial session data items provided to this MessageHandler on
+   * startup. Implementation is specific to each MessageHandler class.
+   *
+   * By default the implementation is a no-op.
+   *
+   * @param {Array<SessionDataItem>} sessionDataItems
+   *     Initial session data items for this MessageHandler.
+   */
+  async applyInitialSessionDataItems(sessionDataItems) {}
+
+  /**
+   * Returns the module path corresponding to this MessageHandler class.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  static get modulePath() {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Returns the type corresponding to this MessageHandler class.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  static get type() {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Returns the id corresponding to a context compatible with this
+   * MessageHandler class.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  static getIdFromContext(context) {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Forward a command to other MessageHandlers.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  forwardCommand(command) {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Check if contextDescriptor matches the context linked
+   * to this MessageHandler instance.
+   *
+   * Needs to be implemented in the sub class.
+   */
+  matchesContext(contextDescriptor) {
+    throw new Error("Not implemented");
+  }
+
+  /**
+   * Check if the given command is supported in the module
+   * for the destination
+   *
+   * @param {string} moduleName
+   *     The name of the module.
+   * @param {string} commandName
+   *     The name of the command.
+   * @param {Destination} destination
+   *     The destination.
+   * @returns {boolean}
+   *     True if the command is supported.
+   */
+  supportsCommand(moduleName, commandName, destination) {
+    return this.getAllModuleClasses(moduleName, destination).some(cls =>
+      cls.supportsMethod(commandName)
+    );
+  }
+
+  /**
+   * Return the context information for this MessageHandler instance, which
+   * can be used to identify the origin of an event.
+   *
+   * @returns {ContextInfo}
+   *     The context information for this MessageHandler.
+   */
+  #getContextInfo() {
+    return {
+      contextId: this.contextId,
+      type: this.constructor.type,
+    };
+  }
+}
diff --git a/remote/shared/messagehandler/MessageHandlerRegistry.sys.mjs b/remote/shared/messagehandler/MessageHandlerRegistry.sys.mjs
new file mode 100644
index 0000000000..02a2514fee
--- /dev/null
+++ b/remote/shared/messagehandler/MessageHandlerRegistry.sys.mjs
@@ -0,0 +1,238 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+import { EventEmitter } from "resource://gre/modules/EventEmitter.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  readSessionData:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionDataReader.sys.mjs",
+  RootMessageHandler:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs",
+  WindowGlobalMessageHandler:
+    "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * Map of MessageHandler type to MessageHandler subclass.
+ */
+XPCOMUtils.defineLazyGetter(
+  lazy,
+  "MessageHandlerClasses",
+  () =>
+    new Map([
+      [lazy.RootMessageHandler.type, lazy.RootMessageHandler],
+      [lazy.WindowGlobalMessageHandler.type, lazy.WindowGlobalMessageHandler],
+    ])
+);
+
+/**
+ * Get the MessageHandler subclass corresponding to the provided type.
+
+ * @param {string} type
+ *     MessageHandler type, one of MessageHandler.type.
+ * @returns {Class}
+ *     A MessageHandler subclass
+ * @throws {Error}
+ *      Throws if no MessageHandler subclass is found for the provided type.
+ */
+export function getMessageHandlerClass(type) {
+  if (!lazy.MessageHandlerClasses.has(type)) {
+    throw new Error(`No MessageHandler class available for type "${type}"`);
+  }
+  return lazy.MessageHandlerClasses.get(type);
+}
+
+/**
+ * The MessageHandlerRegistry allows to create and retrieve MessageHandler
+ * instances for different session ids.
+ *
+ * A MessageHandlerRegistry instance is bound to a specific MessageHandler type
+ * and context. All MessageHandler instances created by the same registry will
+ * use the type and context of the registry, but each will be associated to a
+ * different session id.
+ *
+ * The registry is useful to retrieve the appropriate MessageHandler instance
+ * after crossing a technical boundary (eg process, thread...).
+ */
+export class MessageHandlerRegistry extends EventEmitter {
+  /*
+   * @param {String} type
+   *     MessageHandler type, one of MessageHandler.type.
+   * @param {Object} context
+   *     The context object, which depends on the type.
+   */
+  constructor(type, context) {
+    super();
+
+    this._messageHandlerClass = getMessageHandlerClass(type);
+    this._context = context;
+    this._type = type;
+
+    /**
+     * Map of session id to MessageHandler instance
+     */
+    this._messageHandlersMap = new Map();
+
+    this._onMessageHandlerDestroyed =
+      this._onMessageHandlerDestroyed.bind(this);
+    this._onMessageHandlerEvent = this._onMessageHandlerEvent.bind(this);
+  }
+
+  /**
+   * Create all message handlers for the current context, based on the content
+   * of the session data.
+   * This should typically be called when the context is ready to be used and
+   * to receive/send commands.
+   */
+  createAllMessageHandlers() {
+    const data = lazy.readSessionData();
+    for (const [sessionId, sessionDataItems] of data) {
+      // Create a message handler for this context for each active message
+      // handler session.
+      // TODO: In the future, to support debugging use cases we might want to
+      // only create a message handler if there is relevant data.
+      // For automation scenarios, this is less critical.
+      this._createMessageHandler(sessionId, sessionDataItems);
+    }
+  }
+
+  destroy() {
+    this._messageHandlersMap.forEach(messageHandler => {
+      messageHandler.destroy();
+    });
+  }
+
+  /**
+   * Retrieve all MessageHandler instances held in this registry, for all
+   * session IDs.
+   *
+   * @returns {Iterable.<MessageHandler>}
+   *     Iterator of MessageHandler instances
+   */
+  getAllMessageHandlers() {
+    return this._messageHandlersMap.values();
+  }
+
+  /**
+   * Retrieve an existing MessageHandler instance matching the provided session
+   * id. Returns null if no MessageHandler was found.
+   *
+   * @param {string} sessionId
+   *     ID of the session the handler is used for.
+   * @returns {MessageHandler=}
+   *     A MessageHandler instance, null if not found.
+   */
+  getExistingMessageHandler(sessionId) {
+    return this._messageHandlersMap.get(sessionId);
+  }
+
+  /**
+   * Retrieve the MessageHandler instance registered for the provided session
+   * id. Will create and register a MessageHander if no instance was found.
+   *
+   * @param {string} sessionId
+   *     ID of the session the handler is used for.
+   * @returns {MessageHandler}
+   *     A MessageHandler instance.
+   */
+  getOrCreateMessageHandler(sessionId) {
+    let messageHandler = this.getExistingMessageHandler(sessionId);
+    if (!messageHandler) {
+      messageHandler = this._createMessageHandler(sessionId);
+    }
+
+    return messageHandler;
+  }
+
+  /**
+   * Retrieve an already registered RootMessageHandler instance matching the
+   * provided sessionId.
+   *
+   * @param {string} sessionId
+   *     ID of the session the handler is used for.
+   * @returns {RootMessageHandler}
+   *     A RootMessageHandler instance.
+   * @throws {Error}
+   *     If no root MessageHandler can be found for the provided session id.
+   */
+  getRootMessageHandler(sessionId) {
+    const rootMessageHandler = this.getExistingMessageHandler(
+      sessionId,
+      lazy.RootMessageHandler.type
+    );
+    if (!rootMessageHandler) {
+      throw new Error(
+        `Unable to find a root MessageHandler for session id ${sessionId}`
+      );
+    }
+    return rootMessageHandler;
+  }
+
+  toString() {
+    return `[object ${this.constructor.name}]`;
+  }
+
+  /**
+   * Create a new MessageHandler instance.
+   *
+   * @param {string} sessionId
+   *     ID of the session the handler will be used for.
+   * @param {Array<SessionDataItem>=} sessionDataItems
+   *     Optional array of session data items to be applied automatically to the
+   *     MessageHandler.
+   * @returns {MessageHandler}
+   *     A new MessageHandler instance.
+   */
+  _createMessageHandler(sessionId, sessionDataItems) {
+    const messageHandler = new this._messageHandlerClass(
+      sessionId,
+      this._context,
+      this
+    );
+
+    messageHandler.on(
+      "message-handler-destroyed",
+      this._onMessageHandlerDestroyed
+    );
+    messageHandler.on("message-handler-event", this._onMessageHandlerEvent);
+
+    messageHandler.applyInitialSessionDataItems(sessionDataItems);
+
+    this._messageHandlersMap.set(sessionId, messageHandler);
+
+    lazy.logger.trace(
+      `Created MessageHandler ${this._type} for session ${sessionId}`
+    );
+
+    return messageHandler;
+  }
+
+  // Event handlers
+
+  _onMessageHandlerDestroyed(eventName, messageHandler) {
+    messageHandler.off(
+      "message-handler-destroyed",
+      this._onMessageHandlerDestroyed
+    );
+    messageHandler.off("message-handler-event", this._onMessageHandlerEvent);
+    this._messageHandlersMap.delete(messageHandler.sessionId);
+
+    lazy.logger.trace(
+      `Unregistered MessageHandler ${messageHandler.constructor.type} for session ${messageHandler.sessionId}`
+    );
+  }
+
+  _onMessageHandlerEvent(eventName, messageHandlerEvent) {
+    // The registry simply re-emits MessageHandler events so that consumers
+    // don't have to attach listeners to individual MessageHandler instances.
+    this.emit("message-handler-registry-event", messageHandlerEvent);
+  }
+}
diff --git a/remote/shared/messagehandler/Module.sys.mjs b/remote/shared/messagehandler/Module.sys.mjs
new file mode 100644
index 0000000000..7b121f054d
--- /dev/null
+++ b/remote/shared/messagehandler/Module.sys.mjs
@@ -0,0 +1,137 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "disabledExperimentalAPI", () => {
+  return !Services.prefs.getBoolPref("remote.experimental.enabled");
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+export class Module {
+  #messageHandler;
+
+  /**
+   * Create a new module instance.
+   *
+   * @param {MessageHandler} messageHandler
+   *     The MessageHandler instance which owns this Module instance.
+   */
+  constructor(messageHandler) {
+    this.#messageHandler = messageHandler;
+  }
+
+  /**
+   * Clean-up the module instance.
+   */
+  destroy() {
+    lazy.logger.warn(
+      `Module ${this.constructor.name} is missing a destroy method`
+    );
+  }
+
+  /**
+   * Emit a message handler event.
+   *
+   * Such events should bubble up to the root of a MessageHandler network.
+   *
+   * @param {string} name
+   *     Name of the event. Protocol level events should be of the
+   *     form [module name].[event name].
+   * @param {object} data
+   *     The event's data.
+   * @param {ContextInfo=} contextInfo
+   *     The event's context info, see MessageHandler:emitEvent. Optional.
+   */
+  emitEvent(name, data, contextInfo) {
+    this.messageHandler.emitEvent(name, data, contextInfo);
+  }
+
+  /**
+   * Intercept an event and modify the payload.
+   *
+   * It's required to be implemented in windowglobal-in-root modules.
+   *
+   * @param {string} name
+   *     Name of the event.
+   * @param {object} payload
+   *    The event's payload.
+   * @returns {object}
+   *     The modified event payload.
+   */
+  interceptEvent(name, payload) {
+    throw new Error(
+      `Could not intercept event ${name}, interceptEvent is not implemented in windowglobal-in-root module`
+    );
+  }
+
+  /**
+   * Assert if experimental commands are enabled.
+   *
+   * @param {string} methodName
+   *     Name of the command.
+   *
+   * @throws {UnknownCommandError}
+   *     If experimental commands are disabled.
+   */
+  assertExperimentalCommandsEnabled(methodName) {
+    // TODO: 1778987. Move it to a BiDi specific place.
+    if (lazy.disabledExperimentalAPI) {
+      throw new lazy.error.UnknownCommandError(methodName);
+    }
+  }
+
+  /**
+   * Assert if experimental events are enabled.
+   *
+   * @param {string} moduleName
+   *     Name of the module.
+   *
+   * @param {string} event
+   *     Name of the event.
+   *
+   * @throws {InvalidArgumentError}
+   *     If experimental events are disabled.
+   */
+  assertExperimentalEventsEnabled(moduleName, event) {
+    // TODO: 1778987. Move it to a BiDi specific place.
+    if (lazy.disabledExperimentalAPI) {
+      throw new lazy.error.InvalidArgumentError(
+        `Module ${moduleName} does not support event ${event}`
+      );
+    }
+  }
+
+  /**
+   * Instance shortcut for supportsMethod to avoid reaching the constructor for
+   * consumers which directly deal with an instance.
+   */
+  supportsMethod(methodName) {
+    return this.constructor.supportsMethod(methodName);
+  }
+
+  get messageHandler() {
+    return this.#messageHandler;
+  }
+
+  static get supportedEvents() {
+    return [];
+  }
+
+  static supportsEvent(event) {
+    return this.supportedEvents.includes(event);
+  }
+
+  static supportsMethod(methodName) {
+    return typeof this.prototype[methodName] === "function";
+  }
+}
diff --git a/remote/shared/messagehandler/ModuleCache.sys.mjs b/remote/shared/messagehandler/ModuleCache.sys.mjs
new file mode 100644
index 0000000000..559429ddd1
--- /dev/null
+++ b/remote/shared/messagehandler/ModuleCache.sys.mjs
@@ -0,0 +1,265 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  getMessageHandlerClass:
+    "chrome://remote/content/shared/messagehandler/MessageHandlerRegistry.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  RootMessageHandler:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs",
+});
+
+const protocols = {
+  bidi: {},
+  test: {},
+};
+// eslint-disable-next-line mozilla/lazy-getter-object-name
+ChromeUtils.defineESModuleGetters(protocols.bidi, {
+  // Additional protocols might use a different registry for their modules,
+  // in which case this will no longer be a constant but will instead depend on
+  // the protocol owning the MessageHandler. See Bug 1722464.
+  modules:
+    "chrome://remote/content/webdriver-bidi/modules/ModuleRegistry.sys.mjs",
+});
+// eslint-disable-next-line mozilla/lazy-getter-object-name
+ChromeUtils.defineESModuleGetters(protocols.test, {
+  modules:
+    "chrome://mochitests/content/browser/remote/shared/messagehandler/test/browser/resources/modules/ModuleRegistry.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * ModuleCache instances are dedicated to lazily create and cache the instances
+ * of all the modules related to a specific MessageHandler instance.
+ *
+ * ModuleCache also implements the logic to resolve the path to the file for a
+ * given module, which depends both on the current MessageHandler context and on
+ * the expected destination.
+ *
+ * In order to implement module logic in any context, separate module files
+ * should be created for each situation. For instance, for a given module,
+ * - ${MODULES_FOLDER}/root/{ModuleName}.jsm contains the implementation for
+ *   commands intended for the destination ROOT, and will be created for a ROOT
+ *   MessageHandler only. Typically, they will run in the parent process.
+ * - ${MODULES_FOLDER}/windowglobal/{ModuleName}.jsm contains the implementation
+ *   for commands intended for a WINDOW_GLOBAL destination, and will be created
+ *   for a WINDOW_GLOBAL MessageHandler only. Those will usually run in a
+ *   content process.
+ * - ${MODULES_FOLDER}/windowglobal-in-root/{ModuleName}.jsm also handles
+ *   commands intended for a WINDOW_GLOBAL destination, but they will be created
+ *   for the ROOT MessageHandler and will run in the parent process. This can be
+ *   useful if some code has to be executed in the parent process, even though
+ *   the final destination is a WINDOW_GLOBAL.
+ * - And so on, as more MessageHandler types get added, more combinations will
+ *   follow based on the same pattern:
+ *   - {contextName}/{ModuleName}.jsm
+ *   - or {destinationType}-in-{currentType}/{ModuleName}.jsm
+ *
+ * All those implementations are optional. If a module cannot be found, based on
+ * the logic detailed above, the MessageHandler will assume that the command
+ * should simply be forwarded to the next layer of the network.
+ */
+export class ModuleCache {
+  #messageHandler;
+  #messageHandlerType;
+  #modules;
+  #protocol;
+
+  /*
+   * @param {MessageHandler} messageHandler
+   *     The MessageHandler instance which owns this ModuleCache instance.
+   */
+  constructor(messageHandler) {
+    this.#messageHandler = messageHandler;
+    this.#messageHandlerType = messageHandler.constructor.type;
+
+    // Map of absolute module paths to module instances.
+    this.#modules = new Map();
+
+    // Use the module class from the WebDriverBiDi ModuleRegistry if we
+    // are not using test modules.
+    this.#protocol = Services.prefs.getBoolPref(
+      "remote.messagehandler.modulecache.useBrowserTestRoot",
+      false
+    )
+      ? protocols.test
+      : protocols.bidi;
+  }
+
+  /**
+   * Destroy all instantiated modules.
+   */
+  destroy() {
+    this.#modules.forEach(module => module?.destroy());
+  }
+
+  /**
+   * Retrieve all module classes matching the provided module name to reach the
+   * provided destination, from the current context.
+   *
+   * This corresponds to the path a command can take to reach its destination.
+   * A command's method must be implemented in one of the classes returned by
+   * getAllModuleClasses in order to be successfully handled.
+   *
+   * @param {string} moduleName
+   *     The name of the module.
+   * @param {Destination} destination
+   *     The destination.
+   * @returns {Array<class<Module>|null>}
+   *     An array of Module classes.
+   */
+  getAllModuleClasses(moduleName, destination) {
+    const destinationType = destination.type;
+    const classes = [
+      this.#getModuleClass(
+        moduleName,
+        this.#messageHandlerType,
+        destinationType
+      ),
+    ];
+
+    // Bug 1733242: Extend the implementation of this method to handle workers.
+    // It assumes layers have at most one level of nesting, for instance
+    // "root -> windowglobal", but it wouldn't work for something such as
+    // "root -> windowglobal -> worker".
+    if (destinationType !== this.#messageHandlerType) {
+      classes.push(
+        this.#getModuleClass(moduleName, destinationType, destinationType)
+      );
+    }
+
+    return classes.filter(cls => !!cls);
+  }
+
+  /**
+   * Get a module instance corresponding to the provided moduleName and
+   * destination. If no existing module can be found in the cache, ModuleCache
+   * will attempt to import the module file and create a new instance, which
+   * will then be cached and returned for subsequent calls.
+   *
+   * @param {string} moduleName
+   *     The name of the module which should implement the command.
+   * @param {CommandDestination} destination
+   *     The destination of the command for which we need to instantiate a
+   *     module. See MessageHandler.jsm for the CommandDestination typedef.
+   * @returns {object=}
+   *     A module instance corresponding to the provided moduleName and
+   *     destination, or null if it could not be instantiated.
+   */
+  getModuleInstance(moduleName, destination) {
+    const key = `${moduleName}-${destination.type}`;
+
+    if (this.#modules.has(key)) {
+      // If there is already a cached instance (potentially null) for the
+      // module name + destination type pair, return it.
+      return this.#modules.get(key);
+    }
+
+    const ModuleClass = this.#getModuleClass(
+      moduleName,
+      this.#messageHandlerType,
+      destination.type
+    );
+
+    let module = null;
+    if (ModuleClass) {
+      module = new ModuleClass(this.#messageHandler);
+    }
+
+    this.#modules.set(key, module);
+    return module;
+  }
+
+  /**
+   * Check if the given module exists for the destination.
+   *
+   * @param {string} moduleName
+   *     The name of the module.
+   * @param {Destination} destination
+   *     The destination.
+   * @returns {boolean}
+   *     True if the module exists.
+   */
+  hasModuleClass(moduleName, destination) {
+    const classes = this.getAllModuleClasses(moduleName, destination);
+    return !!classes.length;
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} ${this.#messageHandler.name}]`;
+  }
+
+  /**
+   * Retrieve the module class matching the provided module name and folder.
+   *
+   * @param {string} moduleName
+   *     The name of the module to get the class for.
+   * @param {string} originType
+   *     The MessageHandler type from where the command comes.
+   * @param {string} destinationType
+   *     The MessageHandler type where the command should go to.
+   * @returns {Class=}
+   *     The class corresponding to the module name and folder, null if no match
+   *     was found.
+   * @throws {Error}
+   *     If the provided module folder is unexpected.
+   */
+  #getModuleClass = function (moduleName, originType, destinationType) {
+    if (
+      destinationType === lazy.RootMessageHandler.type &&
+      originType !== destinationType
+    ) {
+      // If we are trying to reach the root layer from a lower layer, no module
+      // class should attempt to handle the command in the current layer and
+      // the command should be forwarded unconditionally.
+      return null;
+    }
+
+    const moduleFolder = this.#getModuleFolder(originType, destinationType);
+    if (!this.#protocol.modules[moduleFolder]) {
+      throw new Error(
+        `Invalid module folder "${moduleFolder}", expected one of "${Object.keys(
+          this.#protocol.modules
+        )}"`
+      );
+    }
+
+    let moduleClass = null;
+    if (this.#protocol.modules[moduleFolder][moduleName]) {
+      moduleClass = this.#protocol.modules[moduleFolder][moduleName];
+    }
+
+    if (moduleClass) {
+      lazy.logger.trace(
+        `Module ${moduleFolder}/${moduleName}.jsm found for ${destinationType}`
+      );
+    } else {
+      lazy.logger.trace(
+        `Module ${moduleFolder}/${moduleName}.jsm not found for ${destinationType}`
+      );
+    }
+
+    return moduleClass;
+  };
+
+  #getModuleFolder(originType, destinationType) {
+    const originPath = lazy.getMessageHandlerClass(originType).modulePath;
+    if (originType === destinationType) {
+      // If the command is targeting the current type, the module is expected to
+      // be in eg "windowglobal/${moduleName}.jsm".
+      return originPath;
+    }
+
+    // If the command is targeting another type, the module is expected to
+    // be in a composed folder eg "windowglobal-in-root/${moduleName}.jsm".
+    const destinationPath =
+      lazy.getMessageHandlerClass(destinationType).modulePath;
+    return `${destinationPath}-in-${originPath}`;
+  }
+}
diff --git a/remote/shared/messagehandler/RootMessageHandler.sys.mjs b/remote/shared/messagehandler/RootMessageHandler.sys.mjs
new file mode 100644
index 0000000000..17c2b86b65
--- /dev/null
+++ b/remote/shared/messagehandler/RootMessageHandler.sys.mjs
@@ -0,0 +1,154 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { MessageHandler } from "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  RootTransport:
+    "chrome://remote/content/shared/messagehandler/transports/RootTransport.sys.mjs",
+  SessionData:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+  SessionDataMethod:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+  WindowGlobalMessageHandler:
+    "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
+});
+
+/**
+ * A RootMessageHandler is the root node of a MessageHandler network. It lives
+ * in the parent process. It can forward commands to MessageHandlers in other
+ * layers (at the moment WindowGlobalMessageHandlers in content processes).
+ */
+export class RootMessageHandler extends MessageHandler {
+  #rootTransport;
+  #sessionData;
+
+  /**
+   * Returns the RootMessageHandler module path.
+   *
+   * @returns {string}
+   */
+  static get modulePath() {
+    return "root";
+  }
+
+  /**
+   * Returns the RootMessageHandler type.
+   *
+   * @returns {string}
+   */
+  static get type() {
+    return "ROOT";
+  }
+
+  /**
+   * The ROOT MessageHandler is unique for a given MessageHandler network
+   * (ie for a given sessionId). Reuse the type as context id here.
+   */
+  static getIdFromContext(context) {
+    return RootMessageHandler.type;
+  }
+
+  /**
+   * Create a new RootMessageHandler instance.
+   *
+   * @param {string} sessionId
+   *     ID of the session the handler is used for.
+   */
+  constructor(sessionId) {
+    super(sessionId, null);
+
+    this.#rootTransport = new lazy.RootTransport(this);
+    this.#sessionData = new lazy.SessionData(this);
+  }
+
+  get sessionData() {
+    return this.#sessionData;
+  }
+
+  destroy() {
+    this.#sessionData.destroy();
+    super.destroy();
+  }
+
+  /**
+   * Add new session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * Forwards the call to the SessionData instance owned by this
+   * RootMessageHandler and propagates the information via a command to existing
+   * MessageHandlers.
+   */
+  addSessionDataItem(sessionData = {}) {
+    sessionData.method = lazy.SessionDataMethod.Add;
+    return this.updateSessionData([sessionData]);
+  }
+
+  /**
+   * Emit a public protocol event. This event will be sent over to the client.
+   *
+   * @param {string} name
+   *     Name of the event. Protocol level events should be of the
+   *     form [module name].[event name].
+   * @param {object} data
+   *     The event's data.
+   */
+  emitProtocolEvent(name, data) {
+    this.emit("message-handler-protocol-event", {
+      name,
+      data,
+      sessionId: this.sessionId,
+    });
+  }
+
+  /**
+   * Forward the provided command to WINDOW_GLOBAL MessageHandlers via the
+   * RootTransport.
+   *
+   * @param {Command} command
+   *     The command to forward. See type definition in MessageHandler.js
+   * @returns {Promise}
+   *     Returns a promise that resolves with the result of the command.
+   */
+  forwardCommand(command) {
+    switch (command.destination.type) {
+      case lazy.WindowGlobalMessageHandler.type:
+        return this.#rootTransport.forwardCommand(command);
+      default:
+        throw new Error(
+          `Cannot forward command to "${command.destination.type}" from "${this.constructor.type}".`
+        );
+    }
+  }
+
+  matchesContext() {
+    return true;
+  }
+
+  /**
+   * Remove session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * Forwards the call to the SessionData instance owned by this
+   * RootMessageHandler and propagates the information via a command to existing
+   * MessageHandlers.
+   */
+  removeSessionDataItem(sessionData = {}) {
+    sessionData.method = lazy.SessionDataMethod.Remove;
+    return this.updateSessionData([sessionData]);
+  }
+
+  /**
+   * Update session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * Forwards the call to the SessionData instance owned by this
+   * RootMessageHandler.
+   */
+  async updateSessionData(sessionData = []) {
+    await this.#sessionData.updateSessionData(sessionData);
+  }
+}
diff --git a/remote/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs b/remote/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs
new file mode 100644
index 0000000000..09ac489182
--- /dev/null
+++ b/remote/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs
@@ -0,0 +1,17 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { MessageHandlerRegistry } from "chrome://remote/content/shared/messagehandler/MessageHandlerRegistry.sys.mjs";
+
+import { RootMessageHandler } from "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs";
+
+/**
+ * In the parent process, only one Root MessageHandlerRegistry should ever be
+ * created. All consumers can safely use this singleton to retrieve the Root
+ * registry and from there either create or retrieve Root MessageHandler
+ * instances for a specific session.
+ */
+export var RootMessageHandlerRegistry = new MessageHandlerRegistry(
+  RootMessageHandler.type
+);
diff --git a/remote/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs b/remote/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs
new file mode 100644
index 0000000000..1e0164cf44
--- /dev/null
+++ b/remote/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs
@@ -0,0 +1,242 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import {
+  ContextDescriptorType,
+  MessageHandler,
+} from "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  getMessageHandlerFrameChildActor:
+    "chrome://remote/content/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameChild.sys.mjs",
+  RootMessageHandler:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs",
+  WindowRealm: "chrome://remote/content/shared/Realm.sys.mjs",
+});
+
+/**
+ * A WindowGlobalMessageHandler is dedicated to debugging a single window
+ * global. It follows the lifecycle of the corresponding window global and will
+ * therefore not survive any navigation. This MessageHandler cannot forward
+ * commands further to other MessageHandlers and represents a leaf node in a
+ * MessageHandler network.
+ */
+export class WindowGlobalMessageHandler extends MessageHandler {
+  #innerWindowId;
+  #realms;
+
+  constructor() {
+    super(...arguments);
+
+    this.#innerWindowId = this.context.window.windowGlobalChild.innerWindowId;
+
+    // Maps sandbox names to instances of window realms,
+    // the default realm is mapped to an empty string sandbox name.
+    this.#realms = new Map([["", new lazy.WindowRealm(this.context.window)]]);
+  }
+
+  destroy() {
+    for (const realm of this.#realms.values()) {
+      realm.destroy();
+    }
+    this.#realms = null;
+
+    super.destroy();
+  }
+
+  /**
+   * Returns the WindowGlobalMessageHandler module path.
+   *
+   * @returns {string}
+   */
+  static get modulePath() {
+    return "windowglobal";
+  }
+
+  /**
+   * Returns the WindowGlobalMessageHandler type.
+   *
+   * @returns {string}
+   */
+  static get type() {
+    return "WINDOW_GLOBAL";
+  }
+
+  /**
+   * For WINDOW_GLOBAL MessageHandlers, `context` is a BrowsingContext,
+   * and BrowsingContext.id can be used as the context id.
+   *
+   * @param {BrowsingContext} context
+   *     WindowGlobalMessageHandler contexts are expected to be
+   *     BrowsingContexts.
+   * @returns {string}
+   *     The browsing context id.
+   */
+  static getIdFromContext(context) {
+    return context.id;
+  }
+
+  get innerWindowId() {
+    return this.#innerWindowId;
+  }
+
+  get realms() {
+    return this.#realms;
+  }
+
+  get window() {
+    return this.context.window;
+  }
+
+  #getRealmFromSandboxName(sandboxName = null) {
+    if (sandboxName === null || sandboxName === "") {
+      return this.#realms.get("");
+    }
+
+    if (this.#realms.has(sandboxName)) {
+      return this.#realms.get(sandboxName);
+    }
+
+    const realm = new lazy.WindowRealm(this.context.window, {
+      sandboxName,
+    });
+
+    this.#realms.set(sandboxName, realm);
+
+    return realm;
+  }
+
+  async applyInitialSessionDataItems(sessionDataItems) {
+    if (!Array.isArray(sessionDataItems)) {
+      return;
+    }
+
+    const destination = {
+      type: WindowGlobalMessageHandler.type,
+    };
+
+    // Create a Map with the structure moduleName -> category -> relevant session data items.
+    const structuredUpdates = new Map();
+    for (const sessionDataItem of sessionDataItems) {
+      const { category, contextDescriptor, moduleName } = sessionDataItem;
+
+      if (!this.matchesContext(contextDescriptor)) {
+        continue;
+      }
+      if (!structuredUpdates.has(moduleName)) {
+        // Skip session data item if the module is not present
+        // for the destination.
+        if (!this.moduleCache.hasModuleClass(moduleName, destination)) {
+          continue;
+        }
+        structuredUpdates.set(moduleName, new Map());
+      }
+
+      if (!structuredUpdates.get(moduleName).has(category)) {
+        structuredUpdates.get(moduleName).set(category, new Set());
+      }
+
+      structuredUpdates.get(moduleName).get(category).add(sessionDataItem);
+    }
+
+    const sessionDataPromises = [];
+
+    for (const [moduleName, categories] of structuredUpdates.entries()) {
+      for (const [category, relevantSessionData] of categories.entries()) {
+        sessionDataPromises.push(
+          this.handleCommand({
+            moduleName,
+            commandName: "_applySessionData",
+            params: {
+              category,
+              initial: true,
+              sessionData: Array.from(relevantSessionData),
+            },
+            destination,
+          })
+        );
+      }
+    }
+
+    await Promise.all(sessionDataPromises);
+
+    // With the session data applied the handler is now ready to be used.
+    this.emitEvent("window-global-handler-created", {
+      contextId: this.contextId,
+      innerWindowId: this.#innerWindowId,
+    });
+  }
+
+  forwardCommand(command) {
+    switch (command.destination.type) {
+      case lazy.RootMessageHandler.type:
+        return lazy
+          .getMessageHandlerFrameChildActor(this)
+          .sendCommand(command, this.sessionId);
+      default:
+        throw new Error(
+          `Cannot forward command to "${command.destination.type}" from "${this.constructor.type}".`
+        );
+    }
+  }
+
+  /**
+   * If <var>realmId</var> is null or not provided get the realm for
+   * a given <var>sandboxName</var>, otherwise find the realm
+   * in the cache with the realm id equal given <var>realmId</var>.
+   *
+   * @param {object} options
+   * @param {string|null=} options.realmId
+   *     The realm id.
+   * @param {string=} options.sandboxName
+   *     The name of sandbox
+   *
+   * @returns {Realm}
+   *     The realm object.
+   */
+  getRealm(options = {}) {
+    const { realmId = null, sandboxName } = options;
+    if (realmId === null) {
+      return this.#getRealmFromSandboxName(sandboxName);
+    }
+
+    const realm = Array.from(this.#realms.values()).find(
+      realm => realm.id === realmId
+    );
+
+    if (realm) {
+      return realm;
+    }
+
+    throw new lazy.error.NoSuchFrameError(`Realm with id ${realmId} not found`);
+  }
+
+  matchesContext(contextDescriptor) {
+    return (
+      contextDescriptor.type === ContextDescriptorType.All ||
+      (contextDescriptor.type === ContextDescriptorType.TopBrowsingContext &&
+        contextDescriptor.id === this.context.browserId)
+    );
+  }
+
+  /**
+   * Send a command to the root MessageHandler.
+   *
+   * @param {Command} command
+   *     The command to send to the root MessageHandler.
+   * @returns {Promise}
+   *     A promise which resolves with the return value of the command.
+   */
+  sendRootCommand(command) {
+    return this.handleCommand({
+      ...command,
+      destination: {
+        type: lazy.RootMessageHandler.type,
+      },
+    });
+  }
+}
diff --git a/remote/shared/messagehandler/sessiondata/SessionData.sys.mjs b/remote/shared/messagehandler/sessiondata/SessionData.sys.mjs
new file mode 100644
index 0000000000..4a85585a90
--- /dev/null
+++ b/remote/shared/messagehandler/sessiondata/SessionData.sys.mjs
@@ -0,0 +1,394 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ContextDescriptorType:
+    "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  RootMessageHandler:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs",
+  WindowGlobalMessageHandler:
+    "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * @typedef {string} SessionDataCategory
+ */
+
+/**
+ * Enum of session data categories.
+ *
+ * @readonly
+ * @enum {SessionDataCategory}
+ */
+export const SessionDataCategory = {
+  Event: "event",
+  PreloadScript: "preload-script",
+};
+
+/**
+ * @typedef {string} SessionDataMethod
+ */
+
+/**
+ * Enum of session data methods.
+ *
+ * @readonly
+ * @enum {SessionDataMethod}
+ */
+export const SessionDataMethod = {
+  Add: "add",
+  Remove: "remove",
+};
+
+export const SESSION_DATA_SHARED_DATA_KEY = "MessageHandlerSessionData";
+
+// This is a map from session id to session data, which will be persisted and
+// propagated to all processes using Services' sharedData.
+// We have to store this as a unique object under a unique shared data key
+// because new MessageHandlers in other processes will need to access this data
+// without any notion of a specific session.
+// This is a singleton.
+const sessionDataMap = new Map();
+
+/**
+ * @typedef {object} SessionDataItem
+ * @property {string} moduleName
+ *     The name of the module responsible for this data item.
+ * @property {SessionDataCategory} category
+ *     The category of data. The supported categories depend on the module.
+ * @property {(string|number|boolean)} value
+ *     Value of the session data item.
+ * @property {ContextDescriptor} contextDescriptor
+ *     ContextDescriptor to which this session data applies.
+ */
+
+/**
+ * @typedef SessionDataItemUpdate
+ * @property {SessionDataMethod} method
+ *     The way sessionData is updated.
+ * @property {string} moduleName
+ *     The name of the module responsible for this data item.
+ * @property {SessionDataCategory} category
+ *     The category of data. The supported categories depend on the module.
+ * @property {Array<(string|number|boolean)>} values
+ *     Values of the session data item update.
+ * @property {ContextDescriptor} contextDescriptor
+ *     ContextDescriptor to which this session data applies.
+ */
+
+/**
+ * SessionData provides APIs to read and write the session data for a specific
+ * ROOT message handler. It holds the session data as a property and acts as the
+ * source of truth for this session data.
+ *
+ * The session data of a given message handler network should contain all the
+ * information that might be needed to setup new contexts, for instance a list
+ * of subscribed events, a list of breakpoints etc.
+ *
+ * The actual session data is an array of SessionDataItems. Example below:
+ * ```
+ * data: [
+ *   {
+ *     moduleName: "log",
+ *     category: "event",
+ *     value: "log.entryAdded",
+ *     contextDescriptor: { type: "all" }
+ *   },
+ *   {
+ *     moduleName: "browsingContext",
+ *     category: "event",
+ *     value: "browsingContext.contextCreated",
+ *     contextDescriptor: { type: "browser-element", id: "7"}
+ *   },
+ *   {
+ *     moduleName: "browsingContext",
+ *     category: "event",
+ *     value: "browsingContext.contextCreated",
+ *     contextDescriptor: { type: "browser-element", id: "12"}
+ *   },
+ * ]
+ * ```
+ *
+ * The session data will be persisted using Services.ppmm.sharedData, so that
+ * new contexts living in different processes can also access the information
+ * during their startup.
+ *
+ * This class should only be used from a ROOT MessageHandler, or from modules
+ * owned by a ROOT MessageHandler. Other MessageHandlers should rely on
+ * SessionDataReader's readSessionData to get read-only access to session data.
+ *
+ */
+export class SessionData {
+  constructor(messageHandler) {
+    if (messageHandler.constructor.type != lazy.RootMessageHandler.type) {
+      throw new Error(
+        "SessionData should only be used from a ROOT MessageHandler"
+      );
+    }
+
+    this._messageHandler = messageHandler;
+
+    /*
+     * The actual data for this session. This is an array of SessionDataItems.
+     */
+    this._data = [];
+  }
+
+  destroy() {
+    // Update the sessionDataMap singleton.
+    sessionDataMap.delete(this._messageHandler.sessionId);
+
+    // Update sharedData and flush to force consistency.
+    Services.ppmm.sharedData.set(SESSION_DATA_SHARED_DATA_KEY, sessionDataMap);
+    Services.ppmm.sharedData.flush();
+  }
+
+  /**
+   * Update session data items of a given module, category and
+   * contextDescriptor.
+   *
+   * A SessionDataItem will be added or removed for each value of each update
+   * in the provided array.
+   *
+   * Attempting to add a duplicate SessionDataItem or to remove an unknown
+   * SessionDataItem will be silently skipped (no-op).
+   *
+   * The data will be persisted across processes at the end of this method.
+   *
+   * @param {Array<SessionDataItemUpdate>} sessionDataItemUpdates
+   *     Array of session data item updates.
+   *
+   * @returns {Array<SessionDataItemUpdate>}
+   *     The subset of session data item updates which want to be applied.
+   */
+  applySessionData(sessionDataItemUpdates = []) {
+    // The subset of session data item updates, which are cleaned up from
+    // duplicates and unknown items.
+    let updates = [];
+    for (const sessionDataItemUpdate of sessionDataItemUpdates) {
+      const { category, contextDescriptor, method, moduleName, values } =
+        sessionDataItemUpdate;
+      const updatedValues = [];
+      for (const value of values) {
+        const item = { moduleName, category, contextDescriptor, value };
+
+        if (method === SessionDataMethod.Add) {
+          const hasItem = this._findIndex(item) != -1;
+
+          if (!hasItem) {
+            this._data.push(item);
+            updatedValues.push(value);
+          } else {
+            lazy.logger.warn(
+              `Duplicated session data item was not added: ${JSON.stringify(
+                item
+              )}`
+            );
+          }
+        } else {
+          const itemIndex = this._findIndex(item);
+
+          if (itemIndex != -1) {
+            // The item was found in the session data, remove it.
+            this._data.splice(itemIndex, 1);
+            updatedValues.push(value);
+          } else {
+            lazy.logger.warn(
+              `Missing session data item was not removed: ${JSON.stringify(
+                item
+              )}`
+            );
+          }
+        }
+      }
+
+      if (updatedValues.length) {
+        updates.push({
+          ...sessionDataItemUpdate,
+          values: updatedValues,
+        });
+      }
+    }
+    // Persist the sessionDataMap.
+    this._persist();
+
+    return updates;
+  }
+
+  /**
+   * Retrieve the SessionDataItems for a given module and type.
+   *
+   * @param {string} moduleName
+   *     The name of the module responsible for this data item.
+   * @param {string} category
+   *     The session data category.
+   * @param {ContextDescriptor=} contextDescriptor
+   *     Optional context descriptor, to retrieve only session data items added
+   *     for a specific context descriptor.
+   * @returns {Array<SessionDataItem>}
+   *     Array of SessionDataItems for the provided module and type.
+   */
+  getSessionData(moduleName, category, contextDescriptor) {
+    return this._data.filter(
+      item =>
+        item.moduleName === moduleName &&
+        item.category === category &&
+        (!contextDescriptor ||
+          this._isSameContextDescriptor(
+            item.contextDescriptor,
+            contextDescriptor
+          ))
+    );
+  }
+
+  /**
+   * Update session data items of a given module, category and
+   * contextDescriptor and propagate the information
+   * via a command to existing MessageHandlers.
+   *
+   * @param {Array<SessionDataItemUpdate>} sessionDataItemUpdates
+   *     Array of session data item updates.
+   */
+  async updateSessionData(sessionDataItemUpdates = []) {
+    const updates = this.applySessionData(sessionDataItemUpdates);
+
+    if (!updates.length) {
+      // Avoid unnecessary broadcast if no items were updated.
+      return;
+    }
+
+    // Create a Map with the structure moduleName -> category -> list of descriptors.
+    const structuredUpdates = new Map();
+    for (const { moduleName, category, contextDescriptor } of updates) {
+      if (!structuredUpdates.has(moduleName)) {
+        structuredUpdates.set(moduleName, new Map());
+      }
+      if (!structuredUpdates.get(moduleName).has(category)) {
+        structuredUpdates.get(moduleName).set(category, new Set());
+      }
+      const descriptors = structuredUpdates.get(moduleName).get(category);
+      // If there is at least one update for all contexts,
+      // keep only this descriptor in the list of descriptors
+      if (contextDescriptor.type === lazy.ContextDescriptorType.All) {
+        structuredUpdates
+          .get(moduleName)
+          .set(category, new Set([contextDescriptor]));
+      }
+      // Add an individual descriptor if there is no descriptor for all contexts.
+      else if (
+        descriptors.size !== 1 ||
+        Array.from(descriptors)[0]?.type !== lazy.ContextDescriptorType.All
+      ) {
+        descriptors.add(contextDescriptor);
+      }
+    }
+
+    const rootDestination = {
+      type: lazy.RootMessageHandler.type,
+    };
+    const sessionDataPromises = [];
+
+    for (const [moduleName, categories] of structuredUpdates.entries()) {
+      for (const [category, contextDescriptors] of categories.entries()) {
+        // Find sessionData for the category and the moduleName.
+        const relevantSessionData = this._data.filter(
+          item => item.category == category && item.moduleName === moduleName
+        );
+        for (const contextDescriptor of contextDescriptors.values()) {
+          const windowGlobalDestination = {
+            type: lazy.WindowGlobalMessageHandler.type,
+            contextDescriptor,
+          };
+
+          for (const destination of [
+            windowGlobalDestination,
+            rootDestination,
+          ]) {
+            // Only apply session data if the module is present for the destination.
+            if (
+              this._messageHandler.supportsCommand(
+                moduleName,
+                "_applySessionData",
+                destination
+              )
+            ) {
+              sessionDataPromises.push(
+                this._messageHandler
+                  .handleCommand({
+                    moduleName,
+                    commandName: "_applySessionData",
+                    params: {
+                      sessionData: relevantSessionData,
+                      category,
+                      contextDescriptor,
+                    },
+                    destination,
+                  })
+                  ?.catch(reason =>
+                    lazy.logger.error(
+                      `_applySessionData for module: ${moduleName} failed, reason: ${reason}`
+                    )
+                  )
+              );
+            }
+          }
+        }
+      }
+    }
+
+    await Promise.allSettled(sessionDataPromises);
+  }
+
+  _isSameItem(item1, item2) {
+    const descriptor1 = item1.contextDescriptor;
+    const descriptor2 = item2.contextDescriptor;
+
+    return (
+      item1.moduleName === item2.moduleName &&
+      item1.category === item2.category &&
+      this._isSameContextDescriptor(descriptor1, descriptor2) &&
+      this._isSameValue(item1.category, item1.value, item2.value)
+    );
+  }
+
+  _isSameContextDescriptor(contextDescriptor1, contextDescriptor2) {
+    if (contextDescriptor1.type === lazy.ContextDescriptorType.All) {
+      // Ignore the id for type "all" since we made the id optional for this type.
+      return contextDescriptor1.type === contextDescriptor2.type;
+    }
+
+    return (
+      contextDescriptor1.type === contextDescriptor2.type &&
+      contextDescriptor1.id === contextDescriptor2.id
+    );
+  }
+
+  _isSameValue(category, value1, value2) {
+    if (category === SessionDataCategory.PreloadScript) {
+      return value1.script === value2.script;
+    }
+
+    return value1 === value2;
+  }
+
+  _findIndex(item) {
+    return this._data.findIndex(_item => this._isSameItem(item, _item));
+  }
+
+  _persist() {
+    // Update the sessionDataMap singleton.
+    sessionDataMap.set(this._messageHandler.sessionId, this._data);
+
+    // Update sharedData and flush to force consistency.
+    Services.ppmm.sharedData.set(SESSION_DATA_SHARED_DATA_KEY, sessionDataMap);
+    Services.ppmm.sharedData.flush();
+  }
+}
diff --git a/remote/shared/messagehandler/sessiondata/SessionDataReader.sys.mjs b/remote/shared/messagehandler/sessiondata/SessionDataReader.sys.mjs
new file mode 100644
index 0000000000..c96409fb94
--- /dev/null
+++ b/remote/shared/messagehandler/sessiondata/SessionDataReader.sys.mjs
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  SESSION_DATA_SHARED_DATA_KEY:
+    "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "sharedData", () => {
+  const isInParent =
+    Services.appinfo.processType == Ci.nsIXULRuntime.PROCESS_TYPE_DEFAULT;
+
+  return isInParent ? Services.ppmm.sharedData : Services.cpmm.sharedData;
+});
+
+/**
+ * Returns a snapshot of the session data map, which is cloned from the
+ * sessionDataMap singleton of SessionData.jsm.
+ *
+ *  @returns {Map.<string, Array<SessionDataItem>>}
+ *     Map of session id to arrays of SessionDataItems.
+ */
+export const readSessionData = () =>
+  lazy.sharedData.get(lazy.SESSION_DATA_SHARED_DATA_KEY) || new Map();
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser.ini b/remote/shared/messagehandler/test/browser/broadcast/browser.ini
new file mode 100644
index 0000000000..a2f989aaf0
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser.ini
@@ -0,0 +1,17 @@
+[DEFAULT]
+tags = remote
+subsuite = remote
+support-files =
+  doc_messagehandler_broadcasting_xul.xhtml
+  head.js
+  !/remote/shared/messagehandler/test/browser/head.js
+  !/remote/shared/messagehandler/test/browser/resources/*
+prefs =
+  remote.messagehandler.modulecache.useBrowserTestRoot=true
+
+[browser_filter_top_browsing_context.js]
+[browser_only_content_process.js]
+[browser_two_tabs.js]
+[browser_two_tabs_with_params.js]
+[browser_two_windows.js]
+[browser_with_frames.js]
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser_filter_top_browsing_context.js b/remote/shared/messagehandler/test/browser/broadcast/browser_filter_top_browsing_context.js
new file mode 100644
index 0000000000..c140c26fc6
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser_filter_top_browsing_context.js
@@ -0,0 +1,84 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const COM_TEST_PAGE = "https://example.com/document-builder.sjs?html=COM";
+const FRAME_TEST_PAGE = createTestMarkupWithFrames();
+
+add_task(async function test_broadcasting_filter_top_browsing_context() {
+  info("Navigate the initial tab to the COM test URL");
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, COM_TEST_PAGE);
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  info("Open a second tab on the frame test URL");
+  const tab2 = await addTab(FRAME_TEST_PAGE);
+  const browsingContext2 = tab2.linkedBrowser.browsingContext;
+
+  const contextsForTab2 =
+    tab2.linkedBrowser.browsingContext.getAllBrowsingContextsInSubtree();
+  is(
+    contextsForTab2.length,
+    4,
+    "Frame test tab has 3 children contexts (4 in total)"
+  );
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-broadcasting_filter_top_browsing_context"
+  );
+
+  const broadcastValue1 = await sendBroadcastForTopBrowsingContext(
+    browsingContext1,
+    rootMessageHandler
+  );
+
+  ok(
+    Array.isArray(broadcastValue1),
+    "The broadcast returned an array of values"
+  );
+
+  is(broadcastValue1.length, 1, "The broadcast returned one value as expected");
+
+  ok(
+    broadcastValue1.includes("broadcast-" + browsingContext1.id),
+    "The broadcast returned the expected value from tab1"
+  );
+
+  const broadcastValue2 = await sendBroadcastForTopBrowsingContext(
+    browsingContext2,
+    rootMessageHandler
+  );
+
+  ok(
+    Array.isArray(broadcastValue2),
+    "The broadcast returned an array of values"
+  );
+
+  is(broadcastValue2.length, 4, "The broadcast returned 4 values as expected");
+
+  for (const context of contextsForTab2) {
+    ok(
+      broadcastValue2.includes("broadcast-" + context.id),
+      "The broadcast contains the value for browsing context " + context.id
+    );
+  }
+
+  rootMessageHandler.destroy();
+});
+
+function sendBroadcastForTopBrowsingContext(
+  topBrowsingContext,
+  rootMessageHandler
+) {
+  return sendTestBroadcastCommand(
+    "commandwindowglobalonly",
+    "testBroadcast",
+    {},
+    {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: topBrowsingContext.browserId,
+    },
+    rootMessageHandler
+  );
+}
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser_only_content_process.js b/remote/shared/messagehandler/test/browser/broadcast/browser_only_content_process.js
new file mode 100644
index 0000000000..d5090c701e
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser_only_content_process.js
@@ -0,0 +1,46 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_broadcasting_only_content_process() {
+  info("Navigate the initial tab to the test URL");
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(
+    tab1.linkedBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  info("Open a new tab on a parent process about: page");
+  await addTab("about:robots");
+
+  info("Open a new tab on a XUL page");
+  await addTab(
+    getRootDirectory(gTestPath) + "doc_messagehandler_broadcasting_xul.xhtml"
+  );
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-broadcasting_only_content_process"
+  );
+  const broadcastValue = await sendTestBroadcastCommand(
+    "commandwindowglobalonly",
+    "testBroadcast",
+    {},
+    contextDescriptorAll,
+    rootMessageHandler
+  );
+
+  ok(
+    Array.isArray(broadcastValue),
+    "The broadcast returned an array of values"
+  );
+
+  is(broadcastValue.length, 1, "The broadcast returned 1 value as expected");
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext1.id),
+    "The broadcast returned the expected value from tab1"
+  );
+
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser_two_tabs.js b/remote/shared/messagehandler/test/browser/broadcast/browser_two_tabs.js
new file mode 100644
index 0000000000..16b97e2a0a
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser_two_tabs.js
@@ -0,0 +1,46 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+add_task(async function test_broadcasting_two_tabs_command() {
+  info("Navigate the initial tab to the test URL");
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, TEST_PAGE);
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  info("Open a new tab on the same test URL");
+  const tab2 = await addTab(TEST_PAGE);
+  const browsingContext2 = tab2.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-broadcasting_two_tabs_command"
+  );
+
+  const broadcastValue = await sendTestBroadcastCommand(
+    "commandwindowglobalonly",
+    "testBroadcast",
+    {},
+    contextDescriptorAll,
+    rootMessageHandler
+  );
+
+  ok(
+    Array.isArray(broadcastValue),
+    "The broadcast returned an array of values"
+  );
+
+  is(broadcastValue.length, 2, "The broadcast returned 2 values as expected");
+
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext1.id),
+    "The broadcast returned the expected value from tab1"
+  );
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext2.id),
+    "The broadcast returned the expected value from tab2"
+  );
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser_two_tabs_with_params.js b/remote/shared/messagehandler/test/browser/broadcast/browser_two_tabs_with_params.js
new file mode 100644
index 0000000000..261b8c4cd6
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser_two_tabs_with_params.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+add_task(async function test_broadcasting_two_tabs_with_params_command() {
+  info("Navigate the initial tab to the test URL");
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, TEST_PAGE);
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  info("Open a new tab on the same test URL");
+  const tab2 = await addTab(TEST_PAGE);
+  const browsingContext2 = tab2.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-broadcasting_two_tabs_command"
+  );
+
+  const broadcastValue = await sendTestBroadcastCommand(
+    "commandwindowglobalonly",
+    "testBroadcastWithParameter",
+    {
+      value: "some-value",
+    },
+    contextDescriptorAll,
+    rootMessageHandler
+  );
+  ok(
+    Array.isArray(broadcastValue),
+    "The broadcast returned an array of values"
+  );
+
+  is(broadcastValue.length, 2, "The broadcast returned 2 values as expected");
+
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext1.id + "-some-value"),
+    "The broadcast returned the expected value from tab1"
+  );
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext2.id + "-some-value"),
+    "The broadcast returned the expected value from tab2"
+  );
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser_two_windows.js b/remote/shared/messagehandler/test/browser/broadcast/browser_two_windows.js
new file mode 100644
index 0000000000..f59bebba69
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser_two_windows.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+add_task(async function test_broadcasting_two_windows_command() {
+  const window1Browser = gBrowser.selectedTab.linkedBrowser;
+  await loadURL(window1Browser, TEST_PAGE);
+  const browsingContext1 = window1Browser.browsingContext;
+
+  const window2 = await BrowserTestUtils.openNewBrowserWindow();
+  registerCleanupFunction(() => BrowserTestUtils.closeWindow(window2));
+
+  const window2Browser = window2.gBrowser.selectedBrowser;
+  await loadURL(window2Browser, TEST_PAGE);
+  const browsingContext2 = window2Browser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-broadcasting_two_windows_command"
+  );
+  const broadcastValue = await sendTestBroadcastCommand(
+    "commandwindowglobalonly",
+    "testBroadcast",
+    {},
+    contextDescriptorAll,
+    rootMessageHandler
+  );
+
+  ok(
+    Array.isArray(broadcastValue),
+    "The broadcast returned an array of values"
+  );
+  is(broadcastValue.length, 2, "The broadcast returned 2 values as expected");
+
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext1.id),
+    "The broadcast returned the expected value from tab1"
+  );
+  ok(
+    broadcastValue.includes("broadcast-" + browsingContext2.id),
+    "The broadcast returned the expected value from tab2"
+  );
+
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/broadcast/browser_with_frames.js b/remote/shared/messagehandler/test/browser/broadcast/browser_with_frames.js
new file mode 100644
index 0000000000..50326d3885
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/browser_with_frames.js
@@ -0,0 +1,40 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+add_task(async function test_broadcasting_with_frames() {
+  info("Navigate the initial tab to the test URL");
+  const tab = gBrowser.selectedTab;
+  await loadURL(tab.linkedBrowser, createTestMarkupWithFrames());
+
+  const contexts =
+    tab.linkedBrowser.browsingContext.getAllBrowsingContextsInSubtree();
+  is(contexts.length, 4, "Test tab has 3 children contexts (4 in total)");
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-broadcasting_with_frames"
+  );
+  const broadcastValue = await sendTestBroadcastCommand(
+    "commandwindowglobalonly",
+    "testBroadcast",
+    {},
+    contextDescriptorAll,
+    rootMessageHandler
+  );
+
+  ok(
+    Array.isArray(broadcastValue),
+    "The broadcast returned an array of values"
+  );
+  is(broadcastValue.length, 4, "The broadcast returned 4 values as expected");
+
+  for (const context of contexts) {
+    ok(
+      broadcastValue.includes("broadcast-" + context.id),
+      "The broadcast contains the value for browsing context " + context.id
+    );
+  }
+
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/broadcast/doc_messagehandler_broadcasting_xul.xhtml b/remote/shared/messagehandler/test/browser/broadcast/doc_messagehandler_broadcasting_xul.xhtml
new file mode 100644
index 0000000000..91f3503ac3
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/doc_messagehandler_broadcasting_xul.xhtml
@@ -0,0 +1,3 @@
+<window xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
+  <box id="box" style="background-color: red;">Test chrome broadcasting</box>
+</window>
diff --git a/remote/shared/messagehandler/test/browser/broadcast/head.js b/remote/shared/messagehandler/test/browser/broadcast/head.js
new file mode 100644
index 0000000000..eb97549c26
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/broadcast/head.js
@@ -0,0 +1,48 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+Services.scriptloader.loadSubScript(
+  "chrome://mochitests/content/browser/remote/shared/messagehandler/test/browser/head.js",
+  this
+);
+
+/**
+ * Broadcast the provided method to WindowGlobal contexts on a MessageHandler
+ * network.
+ * Returns a promise which will resolve the result of the command broadcast.
+ *
+ * @param {string} module
+ *     The name of the module implementing the command to broadcast.
+ * @param {string} command
+ *     The name of the command to broadcast.
+ * @param {object} params
+ *     The parameters for the command.
+ * @param {ContextDescriptor} contextDescriptor
+ *     The context descriptor to use for this broadcast
+ * @param {RootMessageHandler} rootMessageHandler
+ *     The root of the MessageHandler network.
+ * @returns {Promise.<Array>}
+ *     Promise which resolves an array where each item is the result of the
+ *     command handled by an individual context.
+ */
+function sendTestBroadcastCommand(
+  module,
+  command,
+  params,
+  contextDescriptor,
+  rootMessageHandler
+) {
+  info("Send a test broadcast command");
+  return rootMessageHandler.handleCommand({
+    moduleName: module,
+    commandName: command,
+    params,
+    destination: {
+      contextDescriptor,
+      type: WindowGlobalMessageHandler.type,
+    },
+  });
+}
diff --git a/remote/shared/messagehandler/test/browser/browser.ini b/remote/shared/messagehandler/test/browser/browser.ini
new file mode 100644
index 0000000000..8d93cdb795
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser.ini
@@ -0,0 +1,25 @@
+[DEFAULT]
+tags = remote
+subsuite = remote
+support-files =
+  head.js
+  resources/*
+prefs =
+  remote.messagehandler.modulecache.useBrowserTestRoot=true
+
+[browser_bfcache.js]
+[browser_events_dispatcher.js]
+[browser_events_handler.js]
+[browser_events_module.js]
+[browser_frame_context_utils.js]
+[browser_handle_command_errors.js]
+[browser_handle_command_retry.js]
+[browser_handle_simple_command.js]
+[browser_registry.js]
+[browser_session_data.js]
+[browser_session_data_browser_element.js]
+[browser_session_data_constructor_race.js]
+[browser_session_data_update.js]
+[browser_session_data_update_categories.js]
+[browser_session_data_update_contexts.js]
+[browser_windowglobal_to_root.js]
diff --git a/remote/shared/messagehandler/test/browser/browser_bfcache.js b/remote/shared/messagehandler/test/browser/browser_bfcache.js
new file mode 100644
index 0000000000..f829d8b58d
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_bfcache.js
@@ -0,0 +1,98 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+
+const TEST_PREF = "remote.messagehandler.test.pref";
+
+// Check that pages in bfcache no longer have message handlers attached to them,
+// and that they will not emit unexpected events.
+add_task(async function test_bfcache_broadcast() {
+  const tab = await addTab("https://example.com/document-builder.sjs?html=tab");
+  const rootMessageHandler = createRootMessageHandler("session-id-bfcache");
+
+  try {
+    const browsingContext = tab.linkedBrowser.browsingContext;
+    const contextDescriptor = {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext.browserId,
+    };
+
+    // Whenever a "preference-changed" event from the eventonprefchange module
+    // will be received on the root MessageHandler, increment a counter.
+    let preferenceChangeEventCount = 0;
+    const onEvent = (evtName, wrappedEvt) => {
+      if (wrappedEvt.name === "preference-changed") {
+        preferenceChangeEventCount++;
+      }
+    };
+    rootMessageHandler.on("message-handler-event", onEvent);
+
+    // Initialize the preference, no eventonprefchange module should be created
+    // yet so preferenceChangeEventCount is not expected to be updated.
+    Services.prefs.setIntPref(TEST_PREF, 0);
+    await TestUtils.waitForCondition(() => preferenceChangeEventCount >= 0);
+    is(preferenceChangeEventCount, 0);
+
+    // Broadcast a "ping" command to force the creation of the eventonprefchange
+    // module
+    let values = await sendPingCommand(rootMessageHandler, contextDescriptor);
+    is(values.length, 1, "Broadcast returned a single value");
+
+    Services.prefs.setIntPref(TEST_PREF, 1);
+    await TestUtils.waitForCondition(() => preferenceChangeEventCount >= 1);
+    is(preferenceChangeEventCount, 1);
+
+    info("Navigate to another page");
+    await loadURL(
+      tab.linkedBrowser,
+      "https://example.com/document-builder.sjs?html=othertab"
+    );
+
+    values = await sendPingCommand(rootMessageHandler, contextDescriptor);
+    is(values.length, 1, "Broadcast returned a single value after navigation");
+
+    info("Update the preference and check we only receive 1 event");
+    Services.prefs.setIntPref(TEST_PREF, 2);
+    await TestUtils.waitForCondition(() => preferenceChangeEventCount >= 2);
+    is(preferenceChangeEventCount, 2);
+
+    info("Navigate to another origin");
+    await loadURL(
+      tab.linkedBrowser,
+      "https://example.org/document-builder.sjs?html=otherorigin"
+    );
+
+    values = await sendPingCommand(rootMessageHandler, contextDescriptor);
+    is(
+      values.length,
+      1,
+      "Broadcast returned a single value after cross origin navigation"
+    );
+
+    info("Update the preference and check again that we only receive 1 event");
+    Services.prefs.setIntPref(TEST_PREF, 3);
+    await TestUtils.waitForCondition(() => preferenceChangeEventCount >= 3);
+    is(preferenceChangeEventCount, 3);
+  } finally {
+    rootMessageHandler.destroy();
+    gBrowser.removeTab(tab);
+    Services.prefs.clearUserPref(TEST_PREF);
+  }
+});
+
+function sendPingCommand(rootMessageHandler, contextDescriptor) {
+  return rootMessageHandler.handleCommand({
+    moduleName: "eventonprefchange",
+    commandName: "ping",
+    params: {},
+    destination: {
+      contextDescriptor,
+      type: WindowGlobalMessageHandler.type,
+    },
+  });
+}
diff --git a/remote/shared/messagehandler/test/browser/browser_events_dispatcher.js b/remote/shared/messagehandler/test/browser/browser_events_dispatcher.js
new file mode 100644
index 0000000000..ea75167bf2
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_events_dispatcher.js
@@ -0,0 +1,449 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Check the basic behavior of on/off.
+ */
+add_task(async function test_add_remove_event_listener() {
+  const tab = await addTab("https://example.com/document-builder.sjs?html=tab");
+  const browsingContext = tab.linkedBrowser.browsingContext;
+  const contextDescriptor = {
+    type: ContextDescriptorType.TopBrowsingContext,
+    id: browsingContext.browserId,
+  };
+
+  const root = createRootMessageHandler("session-id-event");
+  const monitoringEvents = await setupEventMonitoring(root);
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(await isSubscribed(root, browsingContext), false);
+
+  info("Add an listener for eventemitter.testEvent");
+  const events = [];
+  const onEvent = (event, data) => events.push(data.text);
+  await root.eventsDispatcher.on(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+  is(await isSubscribed(root, browsingContext), true);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 1);
+
+  info(
+    "Remove a listener for a callback not added before and check that the first one is still registered"
+  );
+  const anotherCallback = () => {};
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    anotherCallback
+  );
+  is(await isSubscribed(root, browsingContext), true);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 2);
+
+  info("Remove the listener for eventemitter.testEvent");
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+  is(await isSubscribed(root, browsingContext), false);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 2);
+
+  info("Add the listener for eventemitter.testEvent again");
+  await root.eventsDispatcher.on(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+  is(await isSubscribed(root, browsingContext), true);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 3);
+
+  info("Remove the listener for eventemitter.testEvent");
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+  is(await isSubscribed(root, browsingContext), false);
+
+  info("Remove the listener again to check the API will not throw");
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+
+  root.destroy();
+  gBrowser.removeTab(tab);
+});
+
+/**
+ * Check that two callbacks can subscribe to the same event in the same context
+ * in parallel.
+ */
+add_task(async function test_two_callbacks() {
+  const tab = await addTab("https://example.com/document-builder.sjs?html=tab");
+  const browsingContext = tab.linkedBrowser.browsingContext;
+  const contextDescriptor = {
+    type: ContextDescriptorType.TopBrowsingContext,
+    id: browsingContext.browserId,
+  };
+
+  const root = createRootMessageHandler("session-id-event");
+  const monitoringEvents = await setupEventMonitoring(root);
+
+  info("Add an listener for eventemitter.testEvent");
+  const events = [];
+  const onEvent = (event, data) => events.push(data.text);
+  await root.eventsDispatcher.on(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 1);
+
+  info("Add another listener for eventemitter.testEvent");
+  const otherevents = [];
+  const otherCallback = (event, data) => otherevents.push(data.text);
+  await root.eventsDispatcher.on(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    otherCallback
+  );
+  is(await isSubscribed(root, browsingContext), true);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 2);
+  is(otherevents.length, 1);
+
+  info("Remove the other listener for eventemitter.testEvent");
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    otherCallback
+  );
+  is(await isSubscribed(root, browsingContext), true);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 3);
+  is(otherevents.length, 1);
+
+  info("Remove the first listener for eventemitter.testEvent");
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor,
+    onEvent
+  );
+  is(await isSubscribed(root, browsingContext), false);
+
+  await emitTestEvent(root, browsingContext, monitoringEvents);
+  is(events.length, 3);
+  is(otherevents.length, 1);
+
+  root.destroy();
+  gBrowser.removeTab(tab);
+});
+
+/**
+ * Check that two callbacks can subscribe to the same event in the two contexts.
+ */
+add_task(async function test_two_contexts() {
+  const tab1 = await addTab("https://example.com/document-builder.sjs?html=1");
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  const tab2 = await addTab("https://example.com/document-builder.sjs?html=2");
+  const browsingContext2 = tab2.linkedBrowser.browsingContext;
+
+  const contextDescriptor1 = {
+    type: ContextDescriptorType.TopBrowsingContext,
+    id: browsingContext1.browserId,
+  };
+  const contextDescriptor2 = {
+    type: ContextDescriptorType.TopBrowsingContext,
+    id: browsingContext2.browserId,
+  };
+
+  const root = createRootMessageHandler("session-id-event");
+
+  const monitoringEvents = await setupEventMonitoring(root);
+
+  const events1 = [];
+  const onEvent1 = (event, data) => events1.push(data.text);
+  await root.eventsDispatcher.on(
+    "eventemitter.testEvent",
+    contextDescriptor1,
+    onEvent1
+  );
+  is(await isSubscribed(root, browsingContext1), true);
+  is(await isSubscribed(root, browsingContext2), false);
+
+  const events2 = [];
+  const onEvent2 = (event, data) => events2.push(data.text);
+  await root.eventsDispatcher.on(
+    "eventemitter.testEvent",
+    contextDescriptor2,
+    onEvent2
+  );
+  is(await isSubscribed(root, browsingContext1), true);
+  is(await isSubscribed(root, browsingContext2), true);
+
+  await emitTestEvent(root, browsingContext1, monitoringEvents);
+  is(events1.length, 1);
+  is(events2.length, 0);
+
+  await emitTestEvent(root, browsingContext2, monitoringEvents);
+  is(events1.length, 1);
+  is(events2.length, 1);
+
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor1,
+    onEvent1
+  );
+  is(await isSubscribed(root, browsingContext1), false);
+  is(await isSubscribed(root, browsingContext2), true);
+
+  // No event expected here since the module for browsingContext1 is no longer
+  // subscribed
+  await emitTestEvent(root, browsingContext1, monitoringEvents);
+  is(events1.length, 1);
+  is(events2.length, 1);
+
+  // Whereas the module for browsingContext2 is still subscribed
+  await emitTestEvent(root, browsingContext2, monitoringEvents);
+  is(events1.length, 1);
+  is(events2.length, 2);
+
+  await root.eventsDispatcher.off(
+    "eventemitter.testEvent",
+    contextDescriptor2,
+    onEvent2
+  );
+  is(await isSubscribed(root, browsingContext1), false);
+  is(await isSubscribed(root, browsingContext2), false);
+
+  await emitTestEvent(root, browsingContext1, monitoringEvents);
+  await emitTestEvent(root, browsingContext2, monitoringEvents);
+  is(events1.length, 1);
+  is(events2.length, 2);
+
+  root.destroy();
+  gBrowser.removeTab(tab2);
+  gBrowser.removeTab(tab1);
+});
+
+/**
+ * Check that adding and removing first listener for the specific context and then
+ * for the global context works as expected.
+ */
+add_task(
+  async function test_remove_context_event_listener_and_then_global_event_listener() {
+    const tab = await addTab(
+      "https://example.com/document-builder.sjs?html=tab"
+    );
+    const browsingContext = tab.linkedBrowser.browsingContext;
+    const contextDescriptor = {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext.browserId,
+    };
+    const contextDescriptorAll = {
+      type: ContextDescriptorType.All,
+    };
+
+    const root = createRootMessageHandler("session-id-event");
+    const monitoringEvents = await setupEventMonitoring(root);
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(await isSubscribed(root, browsingContext), false);
+
+    info("Add an listener for eventemitter.testEvent");
+    const events = [];
+    const onEvent = (event, data) => events.push(data.text);
+    await root.eventsDispatcher.on(
+      "eventemitter.testEvent",
+      contextDescriptor,
+      onEvent
+    );
+    is(await isSubscribed(root, browsingContext), true);
+
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(events.length, 1);
+
+    info(
+      "Add another listener for eventemitter.testEvent, using global context"
+    );
+    const eventsAll = [];
+    const onEventAll = (event, data) => eventsAll.push(data.text);
+    await root.eventsDispatcher.on(
+      "eventemitter.testEvent",
+      contextDescriptorAll,
+      onEventAll
+    );
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(eventsAll.length, 1);
+    is(events.length, 2);
+
+    info("Remove the first listener for eventemitter.testEvent");
+    await root.eventsDispatcher.off(
+      "eventemitter.testEvent",
+      contextDescriptor,
+      onEvent
+    );
+
+    info("Check that we are still subscribed to eventemitter.testEvent");
+    is(await isSubscribed(root, browsingContext), true);
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(eventsAll.length, 2);
+    is(events.length, 2);
+
+    await root.eventsDispatcher.off(
+      "eventemitter.testEvent",
+      contextDescriptorAll,
+      onEventAll
+    );
+    is(await isSubscribed(root, browsingContext), false);
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(eventsAll.length, 2);
+    is(events.length, 2);
+
+    root.destroy();
+    gBrowser.removeTab(tab);
+  }
+);
+
+/**
+ * Check that adding and removing first listener for the global context and then
+ * for the specific context works as expected.
+ */
+add_task(
+  async function test_global_event_listener_and_then_remove_context_event_listener() {
+    const tab = await addTab(
+      "https://example.com/document-builder.sjs?html=tab"
+    );
+    const browsingContext = tab.linkedBrowser.browsingContext;
+    const contextDescriptor = {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext.browserId,
+    };
+    const contextDescriptorAll = {
+      type: ContextDescriptorType.All,
+    };
+
+    const root = createRootMessageHandler("session-id-event");
+    const monitoringEvents = await setupEventMonitoring(root);
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(await isSubscribed(root, browsingContext), false);
+
+    info("Add an listener for eventemitter.testEvent");
+    const events = [];
+    const onEvent = (event, data) => events.push(data.text);
+    await root.eventsDispatcher.on(
+      "eventemitter.testEvent",
+      contextDescriptor,
+      onEvent
+    );
+    is(await isSubscribed(root, browsingContext), true);
+
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(events.length, 1);
+
+    info(
+      "Add another listener for eventemitter.testEvent, using global context"
+    );
+    const eventsAll = [];
+    const onEventAll = (event, data) => eventsAll.push(data.text);
+    await root.eventsDispatcher.on(
+      "eventemitter.testEvent",
+      contextDescriptorAll,
+      onEventAll
+    );
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(eventsAll.length, 1);
+    is(events.length, 2);
+
+    info("Remove the global listener for eventemitter.testEvent");
+    await root.eventsDispatcher.off(
+      "eventemitter.testEvent",
+      contextDescriptorAll,
+      onEventAll
+    );
+
+    info(
+      "Check that we are still subscribed to eventemitter.testEvent for the specific context"
+    );
+    is(await isSubscribed(root, browsingContext), true);
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(eventsAll.length, 1);
+    is(events.length, 3);
+
+    await root.eventsDispatcher.off(
+      "eventemitter.testEvent",
+      contextDescriptor,
+      onEvent
+    );
+
+    is(await isSubscribed(root, browsingContext), false);
+    await emitTestEvent(root, browsingContext, monitoringEvents);
+    is(eventsAll.length, 1);
+    is(events.length, 3);
+
+    root.destroy();
+    gBrowser.removeTab(tab);
+  }
+);
+
+async function setupEventMonitoring(root) {
+  const monitoringEvents = [];
+  const onMonitoringEvent = (event, data) => monitoringEvents.push(data.text);
+  root.on("eventemitter.monitoringEvent", onMonitoringEvent);
+
+  registerCleanupFunction(() =>
+    root.off("eventemitter.monitoringEvent", onMonitoringEvent)
+  );
+
+  return monitoringEvents;
+}
+
+async function emitTestEvent(root, browsingContext, monitoringEvents) {
+  const count = monitoringEvents.length;
+  info("Call eventemitter.emitTestEvent");
+  await root.handleCommand({
+    moduleName: "eventemitter",
+    commandName: "emitTestEvent",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContext.id,
+    },
+  });
+
+  // The monitoring event is always emitted, regardless of the status of the
+  // module. Wait for catching this event before resuming the assertions.
+  info("Wait for the monitoring event");
+  await BrowserTestUtils.waitForCondition(
+    () => monitoringEvents.length >= count + 1
+  );
+  is(monitoringEvents.length, count + 1);
+}
+
+function isSubscribed(root, browsingContext) {
+  info("Call eventemitter.isSubscribed");
+  return root.handleCommand({
+    moduleName: "eventemitter",
+    commandName: "isSubscribed",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContext.id,
+    },
+  });
+}
diff --git a/remote/shared/messagehandler/test/browser/browser_events_handler.js b/remote/shared/messagehandler/test/browser/browser_events_handler.js
new file mode 100644
index 0000000000..705c306de3
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_events_handler.js
@@ -0,0 +1,57 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+/**
+ * Test that the window-global-handler-created event gets emitted for each
+ * individual frame's browsing context.
+ */
+add_task(async function test_windowGlobalHandlerCreated() {
+  const events = [];
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-event_with_frames"
+  );
+
+  info("Add a new session data item to get window global handlers created");
+  await rootMessageHandler.addSessionDataItem({
+    moduleName: "command",
+    category: "browser_session_data_browser_element",
+    contextDescriptor: {
+      type: ContextDescriptorType.All,
+    },
+    values: [true],
+  });
+
+  const onEvent = (evtName, wrappedEvt) => {
+    if (wrappedEvt.name === "window-global-handler-created") {
+      console.info(`Received event for context ${wrappedEvt.data.contextId}`);
+      events.push(wrappedEvt.data);
+    }
+  };
+  rootMessageHandler.on("message-handler-event", onEvent);
+
+  info("Navigate the initial tab to the test URL");
+  const browser = gBrowser.selectedTab.linkedBrowser;
+  await loadURL(browser, createTestMarkupWithFrames());
+
+  const contexts = browser.browsingContext.getAllBrowsingContextsInSubtree();
+  is(contexts.length, 4, "Test tab has 3 children contexts (4 in total)");
+
+  // Wait for all the events
+  await TestUtils.waitForCondition(() => events.length >= 4);
+
+  for (const context of contexts) {
+    const contextEvents = events.filter(evt => {
+      return (
+        evt.contextId === context.id &&
+        evt.innerWindowId === context.currentWindowGlobal.innerWindowId
+      );
+    });
+    is(contextEvents.length, 1, `Found event for context ${context.id}`);
+  }
+
+  rootMessageHandler.off("message-handler-event", onEvent);
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_events_module.js b/remote/shared/messagehandler/test/browser/browser_events_module.js
new file mode 100644
index 0000000000..536c1d9754
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_events_module.js
@@ -0,0 +1,281 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { RootMessageHandlerRegistry } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs"
+);
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+
+/**
+ * Emit an event from a WindowGlobal module triggered by a specific command.
+ * Check that the event is emitted on the RootMessageHandler as well as on
+ * the parent process MessageHandlerRegistry.
+ */
+add_task(async function test_event() {
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContext = tab.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler("session-id-event");
+
+  // Events are emitted both as generic message-handler-event events as well
+  // as under their own name. We expect to receive the event for both.
+  const onHandlerEvent = rootMessageHandler.once("message-handler-event");
+  const onNamedEvent = rootMessageHandler.once("event-from-window-global");
+  // MessageHandlerRegistry should forward all the message-handler-events.
+  const onRegistryEvent = RootMessageHandlerRegistry.once(
+    "message-handler-registry-event"
+  );
+
+  callTestEmitEvent(rootMessageHandler, browsingContext.id);
+
+  const messageHandlerEvent = await onHandlerEvent;
+  is(
+    messageHandlerEvent.name,
+    "event-from-window-global",
+    "Received event on the ROOT MessageHandler"
+  );
+  is(
+    messageHandlerEvent.data.text,
+    `event from ${browsingContext.id}`,
+    "Received the expected payload"
+  );
+
+  const namedEvent = await onNamedEvent;
+  is(
+    namedEvent.text,
+    `event from ${browsingContext.id}`,
+    "Received the expected payload"
+  );
+
+  const registryEvent = await onRegistryEvent;
+  is(
+    registryEvent,
+    messageHandlerEvent,
+    "The event forwarded by the MessageHandlerRegistry is identical to the MessageHandler event"
+  );
+
+  rootMessageHandler.destroy();
+  gBrowser.removeTab(tab);
+});
+
+/**
+ * Emit an event from a Root module triggered by a specific command.
+ * Check that the event is emitted on the RootMessageHandler.
+ */
+add_task(async function test_root_event() {
+  const rootMessageHandler = createRootMessageHandler("session-id-root_event");
+
+  // events are emitted both as generic message-handler-event events as
+  // well as under their own name. We expect to receive the event for both.
+  const onHandlerEvent = rootMessageHandler.once("message-handler-event");
+  const onNamedEvent = rootMessageHandler.once("event-from-root");
+
+  rootMessageHandler.handleCommand({
+    moduleName: "event",
+    commandName: "testEmitRootEvent",
+    destination: {
+      type: RootMessageHandler.type,
+    },
+  });
+
+  const { name, data } = await onHandlerEvent;
+  is(name, "event-from-root", "Received event on the ROOT MessageHandler");
+  is(data.text, "event from root", "Received the expected payload");
+
+  const namedEvent = await onNamedEvent;
+  is(namedEvent.text, "event from root", "Received the expected payload");
+
+  rootMessageHandler.destroy();
+});
+
+/**
+ * Emit an event from a windowglobal-in-root module triggered by a specific command.
+ * Check that the event is emitted on the RootMessageHandler.
+ */
+add_task(async function test_windowglobal_in_root_event() {
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContext = tab.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-windowglobal_in_root_event"
+  );
+
+  // events are emitted both as generic message-handler-event events as
+  // well as under their own name. We expect to receive the event for both.
+  const onHandlerEvent = rootMessageHandler.once("message-handler-event");
+  const onNamedEvent = rootMessageHandler.once(
+    "event-from-window-global-in-root"
+  );
+  rootMessageHandler.handleCommand({
+    moduleName: "event",
+    commandName: "testEmitWindowGlobalInRootEvent",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContext.id,
+    },
+  });
+
+  const { name, data } = await onHandlerEvent;
+  is(
+    name,
+    "event-from-window-global-in-root",
+    "Received event on the ROOT MessageHandler"
+  );
+  is(
+    data.text,
+    `windowglobal-in-root event for ${browsingContext.id}`,
+    "Received the expected payload"
+  );
+
+  const namedEvent = await onNamedEvent;
+  is(
+    namedEvent.text,
+    `windowglobal-in-root event for ${browsingContext.id}`,
+    "Received the expected payload"
+  );
+
+  rootMessageHandler.destroy();
+  gBrowser.removeTab(tab);
+});
+
+/**
+ * Emit an event from a windowglobal module, but from 2 different sessions.
+ * Check that the event is emitted by the corresponding RootMessageHandler as
+ * well as by the parent process MessageHandlerRegistry.
+ */
+add_task(async function test_event_multisession() {
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContextId = tab.linkedBrowser.browsingContext.id;
+
+  const root1 = createRootMessageHandler("session-id-event_multisession-1");
+  let root1Events = 0;
+  const onRoot1Event = function (evtName, wrappedEvt) {
+    if (wrappedEvt.name === "event-from-window-global") {
+      root1Events++;
+    }
+  };
+  root1.on("message-handler-event", onRoot1Event);
+
+  const root2 = createRootMessageHandler("session-id-event_multisession-2");
+  let root2Events = 0;
+  const onRoot2Event = function (evtName, wrappedEvt) {
+    if (wrappedEvt.name === "event-from-window-global") {
+      root2Events++;
+    }
+  };
+  root2.on("message-handler-event", onRoot2Event);
+
+  let registryEvents = 0;
+  const onRegistryEvent = function (evtName, wrappedEvt) {
+    if (wrappedEvt.name === "event-from-window-global") {
+      registryEvents++;
+    }
+  };
+  RootMessageHandlerRegistry.on(
+    "message-handler-registry-event",
+    onRegistryEvent
+  );
+
+  callTestEmitEvent(root1, browsingContextId);
+  callTestEmitEvent(root2, browsingContextId);
+
+  info("Wait for root1 event to be received");
+  await TestUtils.waitForCondition(() => root1Events === 1);
+  info("Wait for root2 event to be received");
+  await TestUtils.waitForCondition(() => root2Events === 1);
+
+  await TestUtils.waitForTick();
+  is(root1Events, 1, "Session 1 only received 1 event");
+  is(root2Events, 1, "Session 2 only received 1 event");
+  is(
+    registryEvents,
+    2,
+    "MessageHandlerRegistry forwarded events from both sessions"
+  );
+
+  root1.off("message-handler-event", onRoot1Event);
+  root2.off("message-handler-event", onRoot2Event);
+  RootMessageHandlerRegistry.off(
+    "message-handler-registry-event",
+    onRegistryEvent
+  );
+  root1.destroy();
+  root2.destroy();
+  gBrowser.removeTab(tab);
+});
+
+/**
+ * Test that events can be emitted from individual frame contexts and that
+ * events going through a shared content process MessageHandlerRegistry are not
+ * duplicated.
+ */
+add_task(async function test_event_with_frames() {
+  info("Navigate the initial tab to the test URL");
+  const tab = gBrowser.selectedTab;
+  await loadURL(tab.linkedBrowser, createTestMarkupWithFrames());
+
+  const contexts =
+    tab.linkedBrowser.browsingContext.getAllBrowsingContextsInSubtree();
+  is(contexts.length, 4, "Test tab has 3 children contexts (4 in total)");
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-event_with_frames"
+  );
+
+  const rootEvents = [];
+  const onRootEvent = function (evtName, wrappedEvt) {
+    if (wrappedEvt.name === "event-from-window-global") {
+      rootEvents.push(wrappedEvt.data.text);
+    }
+  };
+  rootMessageHandler.on("message-handler-event", onRootEvent);
+
+  const namedEvents = [];
+  const onNamedEvent = (name, event) => namedEvents.push(event.text);
+  rootMessageHandler.on("event-from-window-global", onNamedEvent);
+
+  for (const context of contexts) {
+    callTestEmitEvent(rootMessageHandler, context.id);
+    info("Wait for root event to be received in both event arrays");
+    await TestUtils.waitForCondition(() =>
+      [namedEvents, rootEvents].every(events =>
+        events.includes(`event from ${context.id}`)
+      )
+    );
+  }
+
+  info("Wait for a bit and check that we did not receive duplicated events");
+  await TestUtils.waitForTick();
+  is(rootEvents.length, 4, "Only received 4 events");
+
+  rootMessageHandler.off("message-handler-event", onRootEvent);
+  rootMessageHandler.off("event-from-window-global", onNamedEvent);
+  rootMessageHandler.destroy();
+});
+
+function callTestEmitEvent(rootMessageHandler, browsingContextId) {
+  rootMessageHandler.handleCommand({
+    moduleName: "event",
+    commandName: "testEmitEvent",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+}
diff --git a/remote/shared/messagehandler/test/browser/browser_frame_context_utils.js b/remote/shared/messagehandler/test/browser/browser_frame_context_utils.js
new file mode 100644
index 0000000000..cddcba3529
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_frame_context_utils.js
@@ -0,0 +1,98 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { isBrowsingContextCompatible } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs"
+);
+const TEST_COM_PAGE = "https://example.com/document-builder.sjs?html=com";
+const TEST_NET_PAGE = "https://example.net/document-builder.sjs?html=net";
+
+// Test helpers from BrowsingContextUtils in various processes.
+add_task(async function () {
+  const tab1 = BrowserTestUtils.addTab(gBrowser, TEST_COM_PAGE);
+  const contentBrowser1 = tab1.linkedBrowser;
+  await BrowserTestUtils.browserLoaded(contentBrowser1);
+  const browserId1 = contentBrowser1.browsingContext.browserId;
+
+  const tab2 = BrowserTestUtils.addTab(gBrowser, TEST_NET_PAGE);
+  const contentBrowser2 = tab2.linkedBrowser;
+  await BrowserTestUtils.browserLoaded(contentBrowser2);
+  const browserId2 = contentBrowser2.browsingContext.browserId;
+
+  const { extension, sidebarBrowser } = await installSidebarExtension();
+
+  const tab3 = BrowserTestUtils.addTab(
+    gBrowser,
+    `moz-extension://${extension.uuid}/tab.html`
+  );
+  const { bcId } = await extension.awaitMessage("tab-loaded");
+  const tabExtensionBrowser = BrowsingContext.get(bcId).top.embedderElement;
+
+  const parentBrowser1 = createParentBrowserElement(tab1, "content");
+  const parentBrowser2 = createParentBrowserElement(tab1, "chrome");
+
+  info("Check browsing context compatibility for content browser 1");
+  await checkBrowsingContextCompatible(contentBrowser1, undefined, true);
+  await checkBrowsingContextCompatible(contentBrowser1, browserId1, true);
+  await checkBrowsingContextCompatible(contentBrowser1, browserId2, false);
+
+  info("Check browsing context compatibility for content browser 2");
+  await checkBrowsingContextCompatible(contentBrowser2, undefined, true);
+  await checkBrowsingContextCompatible(contentBrowser2, browserId1, false);
+  await checkBrowsingContextCompatible(contentBrowser2, browserId2, true);
+
+  info("Check browsing context compatibility for parent browser 1");
+  await checkBrowsingContextCompatible(parentBrowser1, undefined, false);
+  await checkBrowsingContextCompatible(parentBrowser1, browserId1, false);
+  await checkBrowsingContextCompatible(parentBrowser1, browserId2, false);
+
+  info("Check browsing context compatibility for parent browser 2");
+  await checkBrowsingContextCompatible(parentBrowser2, undefined, false);
+  await checkBrowsingContextCompatible(parentBrowser2, browserId1, false);
+  await checkBrowsingContextCompatible(parentBrowser2, browserId2, false);
+
+  info("Check browsing context compatibility for extension");
+  await checkBrowsingContextCompatible(sidebarBrowser, undefined, false);
+  await checkBrowsingContextCompatible(sidebarBrowser, browserId1, false);
+  await checkBrowsingContextCompatible(sidebarBrowser, browserId2, false);
+
+  info("Check browsing context compatibility for extension viewed in a tab");
+  await checkBrowsingContextCompatible(tabExtensionBrowser, undefined, false);
+  await checkBrowsingContextCompatible(tabExtensionBrowser, browserId1, false);
+  await checkBrowsingContextCompatible(tabExtensionBrowser, browserId2, false);
+
+  gBrowser.removeTab(tab1);
+  gBrowser.removeTab(tab2);
+  gBrowser.removeTab(tab3);
+  await extension.unload();
+});
+
+async function checkBrowsingContextCompatible(browser, browserId, expected) {
+  const options = { browserId };
+  info("Check browsing context compatibility from the parent process");
+  is(isBrowsingContextCompatible(browser.browsingContext, options), expected);
+
+  info(
+    "Check browsing context compatibility from the browsing context's process"
+  );
+  await SpecialPowers.spawn(
+    browser,
+    [browserId, expected],
+    (_browserId, _expected) => {
+      const BrowsingContextUtils = ChromeUtils.importESModule(
+        "chrome://remote/content/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs"
+      );
+      is(
+        BrowsingContextUtils.isBrowsingContextCompatible(
+          content.browsingContext,
+          {
+            browserId: _browserId,
+          }
+        ),
+        _expected
+      );
+    }
+  );
+}
diff --git a/remote/shared/messagehandler/test/browser/browser_handle_command_errors.js b/remote/shared/messagehandler/test/browser/browser_handle_command_errors.js
new file mode 100644
index 0000000000..5f0bdb78df
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_handle_command_errors.js
@@ -0,0 +1,218 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+
+// Check that errors from WindowGlobal modules can be caught by the consumer
+// of the RootMessageHandler.
+add_task(async function test_module_error() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+
+  const rootMessageHandler = createRootMessageHandler("session-id-error");
+
+  info("Call a module method which will throw");
+  try {
+    await rootMessageHandler.handleCommand({
+      moduleName: "commandwindowglobalonly",
+      commandName: "testError",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContextId,
+      },
+    });
+    ok(false, "Error from window global module was not caught");
+  } catch (e) {
+    ok(true, "Error from window global module caught");
+  }
+
+  rootMessageHandler.destroy();
+});
+
+// Check that sending commands to incorrect destinations creates an error which
+// can be caught by the consumer of the RootMessageHandler.
+add_task(async function test_destination_error() {
+  const rootMessageHandler = createRootMessageHandler("session-id-error");
+
+  const fakeBrowsingContextId = -1;
+  ok(
+    !BrowsingContext.get(fakeBrowsingContextId),
+    "No browsing context matches fakeBrowsingContextId"
+  );
+
+  info("Call a valid module method, but on a non-existent browsing context id");
+  Assert.throws(
+    () =>
+      rootMessageHandler.handleCommand({
+        moduleName: "commandwindowglobalonly",
+        commandName: "testOnlyInWindowGlobal",
+        destination: {
+          type: WindowGlobalMessageHandler.type,
+          id: fakeBrowsingContextId,
+        },
+      }),
+    err => err.message == `Unable to find a BrowsingContext for id -1`
+  );
+
+  rootMessageHandler.destroy();
+});
+
+add_task(async function test_invalid_module_error() {
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-missing_module"
+  );
+
+  info("Attempt to call a Root module which has a syntax error");
+  Assert.throws(
+    () =>
+      rootMessageHandler.handleCommand({
+        moduleName: "invalid",
+        commandName: "someMethod",
+        destination: {
+          type: RootMessageHandler.type,
+        },
+      }),
+    err =>
+      err.name === "SyntaxError" &&
+      err.message == "expected expression, got ';'"
+  );
+
+  rootMessageHandler.destroy();
+});
+
+add_task(async function test_missing_root_module_error() {
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-missing_module"
+  );
+
+  info("Attempt to call a Root module which doesn't exist");
+  Assert.throws(
+    () =>
+      rootMessageHandler.handleCommand({
+        moduleName: "missingmodule",
+        commandName: "someMethod",
+        destination: {
+          type: RootMessageHandler.type,
+        },
+      }),
+    err =>
+      err.name == "UnsupportedCommandError" &&
+      err.message ==
+        `missingmodule.someMethod not supported for destination ROOT`
+  );
+
+  rootMessageHandler.destroy();
+});
+
+add_task(async function test_missing_windowglobal_module_error() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-missing_windowglobal_module"
+  );
+
+  info("Attempt to call a WindowGlobal module which doesn't exist");
+  Assert.throws(
+    () =>
+      rootMessageHandler.handleCommand({
+        moduleName: "missingmodule",
+        commandName: "someMethod",
+        destination: {
+          type: WindowGlobalMessageHandler.type,
+          id: browsingContextId,
+        },
+      }),
+    err =>
+      err.name == "UnsupportedCommandError" &&
+      err.message ==
+        `missingmodule.someMethod not supported for destination WINDOW_GLOBAL`
+  );
+
+  rootMessageHandler.destroy();
+});
+
+add_task(async function test_missing_root_method_error() {
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-missing_root_method"
+  );
+
+  info("Attempt to call an invalid method on a Root module");
+  Assert.throws(
+    () =>
+      rootMessageHandler.handleCommand({
+        moduleName: "command",
+        commandName: "wrongMethod",
+        destination: {
+          type: RootMessageHandler.type,
+        },
+      }),
+    err =>
+      err.name == "UnsupportedCommandError" &&
+      err.message == `command.wrongMethod not supported for destination ROOT`
+  );
+
+  rootMessageHandler.destroy();
+});
+
+add_task(async function test_missing_windowglobal_method_error() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-missing_windowglobal_method"
+  );
+
+  info("Attempt to call an invalid method on a WindowGlobal module");
+  Assert.throws(
+    () =>
+      rootMessageHandler.handleCommand({
+        moduleName: "commandwindowglobalonly",
+        commandName: "wrongMethod",
+        destination: {
+          type: WindowGlobalMessageHandler.type,
+          id: browsingContextId,
+        },
+      }),
+    err =>
+      err.name == "UnsupportedCommandError" &&
+      err.message ==
+        `commandwindowglobalonly.wrongMethod not supported for destination WINDOW_GLOBAL`
+  );
+
+  rootMessageHandler.destroy();
+});
+
+/**
+ * This test checks that even if a command is rerouted to another command after
+ * the RootMessageHandler, we still check the new command and log a useful
+ * error message.
+ *
+ * This illustrates why it is important to perform the command check at each
+ * layer of the MessageHandler network.
+ */
+add_task(async function test_missing_intermediary_method_error() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-missing_intermediary_method"
+  );
+
+  info(
+    "Call a (valid) command that relies on another (missing) command on a WindowGlobal module"
+  );
+  await Assert.rejects(
+    rootMessageHandler.handleCommand({
+      moduleName: "commandwindowglobalonly",
+      commandName: "testMissingIntermediaryMethod",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContextId,
+      },
+    }),
+    err =>
+      err.name == "UnsupportedCommandError" &&
+      err.message ==
+        `commandwindowglobalonly.missingMethod not supported for destination WINDOW_GLOBAL`
+  );
+
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_handle_command_retry.js b/remote/shared/messagehandler/test/browser/browser_handle_command_retry.js
new file mode 100644
index 0000000000..fc70ae8c4e
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_handle_command_retry.js
@@ -0,0 +1,239 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+// We are forcing the actors to shutdown while queries are unresolved.
+const { PromiseTestUtils } = ChromeUtils.importESModule(
+  "resource://testing-common/PromiseTestUtils.sys.mjs"
+);
+PromiseTestUtils.allowMatchingRejectionsGlobally(
+  /Actor 'MessageHandlerFrame' destroyed before query 'MessageHandlerFrameParent:sendCommand' was resolved/
+);
+
+// The tests in this file assert the retry behavior for MessageHandler commands.
+// We call "blocked" commands from resources/modules/windowglobal/retry.jsm and
+// then trigger reload and navigations to simulate AbortErrors and force the
+// MessageHandler to retry the commands, when possible.
+
+// Test that without retry behavior, a pending command rejects when the
+// underlying JSWindowActor pair is destroyed.
+add_task(async function test_no_retry() {
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContext = tab.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler("session-id-no-retry");
+
+  try {
+    info("Call a module method which will throw");
+    const onBlockedOneTime = rootMessageHandler.handleCommand({
+      moduleName: "retry",
+      commandName: "blockedOneTime",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContext.id,
+      },
+    });
+
+    // Reloading the tab will reject the pending query with an AbortError.
+    await BrowserTestUtils.reloadTab(tab);
+
+    try {
+      await onBlockedOneTime;
+      ok("false", "onBlockedOneTime should not have resolved");
+    } catch (e) {
+      is(
+        e.name,
+        "AbortError",
+        "Caught the expected abort error when reloading"
+      );
+    }
+  } finally {
+    await cleanup(rootMessageHandler, tab);
+  }
+});
+
+// Test various commands, which all need a different number of "retries" to
+// succeed. Check that they only resolve when the expected number of "retries"
+// was reached. For commands which require more "retries" than we allow, check
+// that we still fail with an AbortError once all the attempts are consumed.
+add_task(async function test_retry() {
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContext = tab.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler("session-id-retry");
+
+  try {
+    // This command will return if called twice.
+    const onBlockedOneTime = rootMessageHandler.handleCommand({
+      moduleName: "retry",
+      commandName: "blockedOneTime",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContext.id,
+      },
+      params: {
+        foo: "bar",
+      },
+      retryOnAbort: true,
+    });
+
+    // This command will return if called three times.
+    const onBlockedTenTimes = rootMessageHandler.handleCommand({
+      moduleName: "retry",
+      commandName: "blockedTenTimes",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContext.id,
+      },
+      params: {
+        foo: "baz",
+      },
+      retryOnAbort: true,
+    });
+
+    // This command will return if called twelve times, which is greater than the
+    // maximum amount of retries allowed.
+    const onBlockedElevenTimes = rootMessageHandler.handleCommand({
+      moduleName: "retry",
+      commandName: "blockedElevenTimes",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContext.id,
+      },
+      retryOnAbort: true,
+    });
+
+    info("Reload one time");
+    await BrowserTestUtils.reloadTab(tab);
+
+    info("blockedOneTime should resolve on the first retry");
+    let { callsToCommand, foo } = await onBlockedOneTime;
+    is(
+      callsToCommand,
+      2,
+      "The command was called twice (initial call + 1 retry)"
+    );
+    is(foo, "bar", "The parameter was sent when the command was retried");
+
+    // We already reloaded 1 time. Reload 9 more times to unblock blockedTenTimes.
+    for (let i = 2; i < 11; i++) {
+      info("blockedTenTimes/blockedElevenTimes should not have resolved yet");
+      ok(!(await hasPromiseResolved(onBlockedTenTimes)));
+      ok(!(await hasPromiseResolved(onBlockedElevenTimes)));
+
+      info(`Reload the tab (time: ${i})`);
+      await BrowserTestUtils.reloadTab(tab);
+    }
+
+    info("blockedTenTimes should resolve on the 10th reload");
+    ({ callsToCommand, foo } = await onBlockedTenTimes);
+    is(
+      callsToCommand,
+      11,
+      "The command was called 11 times (initial call + 10 retry)"
+    );
+    is(foo, "baz", "The parameter was sent when the command was retried");
+
+    info("Reload one more time");
+    await BrowserTestUtils.reloadTab(tab);
+
+    try {
+      info(
+        "The call to blockedElevenTimes now exceeds the maximum attempts allowed"
+      );
+      await onBlockedElevenTimes;
+      ok("false", "blockedElevenTimes should not have resolved");
+    } catch (e) {
+      is(
+        e.name,
+        "AbortError",
+        "Caught the expected abort error when reloading"
+      );
+    }
+  } finally {
+    await cleanup(rootMessageHandler, tab);
+  }
+});
+
+// Test cross-group navigations to check that the retry mechanism will
+// transparently switch to the new Browsing Context created by the cross-group
+// navigation.
+add_task(async function test_retry_cross_group() {
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=COM" +
+      // Attach an unload listener to prevent the page from going into bfcache,
+      // so that pending queries will be rejected with an AbortError.
+      "<script type='text/javascript'>window.onunload = function() {};</script>"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContext = tab.linkedBrowser.browsingContext;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-retry-cross-group"
+  );
+
+  try {
+    // This command hangs and only returns if the current domain is example.net.
+    // We send the command while on example.com, perform a series of reload and
+    // navigations, and the retry mechanism should allow onBlockedOnNetDomain to
+    // resolve.
+    const onBlockedOnNetDomain = rootMessageHandler.handleCommand({
+      moduleName: "retry",
+      commandName: "blockedOnNetDomain",
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContext.id,
+      },
+      params: {
+        foo: "bar",
+      },
+      retryOnAbort: true,
+    });
+
+    info("Reload one time");
+    await BrowserTestUtils.reloadTab(tab);
+
+    info("blockedOnNetDomain should not have resolved yet");
+    ok(!(await hasPromiseResolved(onBlockedOnNetDomain)));
+
+    info(
+      "Navigate to example.net with COOP headers to destroy browsing context"
+    );
+    await loadURL(
+      tab.linkedBrowser,
+      "https://example.net/document-builder.sjs?headers=Cross-Origin-Opener-Policy:same-origin&html=NET"
+    );
+
+    info("blockedOnNetDomain should resolve now");
+    let { foo } = await onBlockedOnNetDomain;
+    is(foo, "bar", "The parameter was sent when the command was retried");
+  } finally {
+    await cleanup(rootMessageHandler, tab);
+  }
+});
+
+async function cleanup(rootMessageHandler, tab) {
+  const browsingContext = tab.linkedBrowser.browsingContext;
+  // Cleanup global JSM state in the test module.
+  await rootMessageHandler.handleCommand({
+    moduleName: "retry",
+    commandName: "cleanup",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContext.id,
+    },
+  });
+
+  rootMessageHandler.destroy();
+  gBrowser.removeTab(tab);
+}
diff --git a/remote/shared/messagehandler/test/browser/browser_handle_simple_command.js b/remote/shared/messagehandler/test/browser/browser_handle_simple_command.js
new file mode 100644
index 0000000000..0a086d6f09
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_handle_simple_command.js
@@ -0,0 +1,203 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+
+// Test calling methods only implemented in the root version of a module.
+add_task(async function test_rootModule_command() {
+  const rootMessageHandler = createRootMessageHandler("session-id-rootModule");
+  const rootValue = await rootMessageHandler.handleCommand({
+    moduleName: "command",
+    commandName: "testRootModule",
+    destination: {
+      type: RootMessageHandler.type,
+    },
+  });
+
+  is(
+    rootValue,
+    "root-value",
+    "Retrieved the expected value from testRootModule"
+  );
+
+  rootMessageHandler.destroy();
+});
+
+// Test calling methods only implemented in the windowglobal-in-root version of
+// a module.
+add_task(async function test_windowglobalInRootModule_command() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-windowglobalInRootModule"
+  );
+  const interceptedValue = await rootMessageHandler.handleCommand({
+    moduleName: "command",
+    commandName: "testInterceptModule",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  is(
+    interceptedValue,
+    "intercepted-value",
+    "Retrieved the expected value from testInterceptModule"
+  );
+
+  rootMessageHandler.destroy();
+});
+
+// Test calling methods only implemented in the windowglobal version of a
+// module.
+add_task(async function test_windowglobalModule_command() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-windowglobalModule"
+  );
+  const windowGlobalValue = await rootMessageHandler.handleCommand({
+    moduleName: "command",
+    commandName: "testWindowGlobalModule",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  is(
+    windowGlobalValue,
+    "windowglobal-value",
+    "Retrieved the expected value from testWindowGlobalModule"
+  );
+
+  rootMessageHandler.destroy();
+});
+
+// Test calling a method on a module which is only available in the "windowglobal"
+// folder. This will check that the MessageHandler/ModuleCache correctly moves
+// on to the next layer when no implementation can be found in the root layer.
+add_task(async function test_windowglobalOnlyModule_command() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-windowglobalOnlyModule"
+  );
+  const windowGlobalOnlyValue = await rootMessageHandler.handleCommand({
+    moduleName: "commandwindowglobalonly",
+    commandName: "testOnlyInWindowGlobal",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  is(
+    windowGlobalOnlyValue,
+    "only-in-windowglobal",
+    "Retrieved the expected value from testOnlyInWindowGlobal"
+  );
+
+  rootMessageHandler.destroy();
+});
+
+// Try to create 2 sessions which will both set values in individual modules
+// via a command `testSetValue`, and then retrieve the values via another
+// command `testGetValue`.
+// This will ensure that different sessions use different module instances.
+add_task(async function test_multisession() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+
+  const rootMessageHandler1 = createRootMessageHandler(
+    "session-id-multisession-1"
+  );
+  const rootMessageHandler2 = createRootMessageHandler(
+    "session-id-multisession-2"
+  );
+
+  info("Set value for session 1");
+  await rootMessageHandler1.handleCommand({
+    moduleName: "command",
+    commandName: "testSetValue",
+    params: { value: "session1-value" },
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  info("Set value for session 2");
+  await rootMessageHandler2.handleCommand({
+    moduleName: "command",
+    commandName: "testSetValue",
+    params: { value: "session2-value" },
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  const session1Value = await rootMessageHandler1.handleCommand({
+    moduleName: "command",
+    commandName: "testGetValue",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  is(
+    session1Value,
+    "session1-value",
+    "Retrieved the expected value for session 1"
+  );
+
+  const session2Value = await rootMessageHandler2.handleCommand({
+    moduleName: "command",
+    commandName: "testGetValue",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  is(
+    session2Value,
+    "session2-value",
+    "Retrieved the expected value for session 2"
+  );
+
+  rootMessageHandler1.destroy();
+  rootMessageHandler2.destroy();
+});
+
+// Test calling a method from the windowglobal-in-root module which will
+// internally forward to the windowglobal module and will return a composite
+// result built both in parent and content process.
+add_task(async function test_forwarding_command() {
+  const browsingContextId = gBrowser.selectedBrowser.browsingContext.id;
+
+  const rootMessageHandler = createRootMessageHandler("session-id-forwarding");
+  const interceptAndForwardValue = await rootMessageHandler.handleCommand({
+    moduleName: "command",
+    commandName: "testInterceptAndForwardModule",
+    params: { id: "value" },
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContextId,
+    },
+  });
+
+  is(
+    interceptAndForwardValue,
+    "intercepted-and-forward+forward-to-windowglobal-value",
+    "Retrieved the expected value from testInterceptAndForwardModule"
+  );
+
+  rootMessageHandler.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_registry.js b/remote/shared/messagehandler/test/browser/browser_registry.js
new file mode 100644
index 0000000000..945ac06c19
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_registry.js
@@ -0,0 +1,37 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { MessageHandlerRegistry } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/MessageHandlerRegistry.sys.mjs"
+);
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+
+add_task(async function test_messageHandlerRegistry_API() {
+  const sessionId = 1;
+  const type = RootMessageHandler.type;
+
+  const rootMessageHandlerRegistry = new MessageHandlerRegistry(type);
+
+  const rootMessageHandler =
+    rootMessageHandlerRegistry.getOrCreateMessageHandler(sessionId);
+  ok(rootMessageHandler, "Valid ROOT MessageHandler created");
+
+  const contextId = rootMessageHandler.contextId;
+  ok(contextId, "ROOT MessageHandler has a valid contextId");
+
+  is(
+    rootMessageHandler,
+    rootMessageHandlerRegistry.getExistingMessageHandler(sessionId),
+    "ROOT MessageHandler can be retrieved from the registry"
+  );
+
+  rootMessageHandler.destroy();
+  ok(
+    !rootMessageHandlerRegistry.getExistingMessageHandler(sessionId),
+    "Destroyed ROOT MessageHandler is no longer returned by the Registry"
+  );
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_session_data.js b/remote/shared/messagehandler/test/browser/browser_session_data.js
new file mode 100644
index 0000000000..f0fef31883
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_session_data.js
@@ -0,0 +1,271 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { MessageHandlerRegistry } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/MessageHandlerRegistry.sys.mjs"
+);
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+const { SessionData } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs"
+);
+
+const TEST_PAGE = "http://example.com/document-builder.sjs?html=tab";
+
+add_task(async function test_sessionData() {
+  info("Navigate the initial tab to the test URL");
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, TEST_PAGE);
+
+  const sessionId = "sessionData-test";
+
+  const rootMessageHandlerRegistry = new MessageHandlerRegistry(
+    RootMessageHandler.type
+  );
+
+  const rootMessageHandler =
+    rootMessageHandlerRegistry.getOrCreateMessageHandler(sessionId);
+  ok(rootMessageHandler, "Valid ROOT MessageHandler created");
+
+  const sessionData = rootMessageHandler.sessionData;
+  ok(
+    sessionData instanceof SessionData,
+    "ROOT MessageHandler has a valid sessionData"
+  );
+
+  let sessionDataSnapshot = await getSessionDataFromContent();
+  is(sessionDataSnapshot.size, 0, "session data is empty");
+
+  info("Store a string value in session data");
+  sessionData.updateSessionData([
+    {
+      method: "add",
+      moduleName: "fakemodule",
+      category: "testCategory",
+      contextDescriptor: contextDescriptorAll,
+      values: ["value-1"],
+    },
+  ]);
+
+  sessionDataSnapshot = await getSessionDataFromContent();
+  is(sessionDataSnapshot.size, 1, "session data contains 1 session");
+  ok(sessionDataSnapshot.has(sessionId));
+  let snapshot = sessionDataSnapshot.get(sessionId);
+  ok(Array.isArray(snapshot));
+  is(snapshot.length, 1);
+
+  const stringDataItem = snapshot[0];
+  checkSessionDataItem(
+    stringDataItem,
+    "fakemodule",
+    "testCategory",
+    ContextDescriptorType.All,
+    "value-1"
+  );
+
+  info("Store a number value in session data");
+  sessionData.updateSessionData([
+    {
+      method: "add",
+      moduleName: "fakemodule",
+      category: "testCategory",
+      contextDescriptor: contextDescriptorAll,
+      values: [12],
+    },
+  ]);
+  snapshot = (await getSessionDataFromContent()).get(sessionId);
+  is(snapshot.length, 2);
+
+  const numberDataItem = snapshot[1];
+  checkSessionDataItem(
+    numberDataItem,
+    "fakemodule",
+    "testCategory",
+    ContextDescriptorType.All,
+    12
+  );
+
+  info("Store a boolean value in session data");
+  sessionData.updateSessionData([
+    {
+      method: "add",
+      moduleName: "fakemodule",
+      category: "testCategory",
+      contextDescriptor: contextDescriptorAll,
+      values: [true],
+    },
+  ]);
+  snapshot = (await getSessionDataFromContent()).get(sessionId);
+  is(snapshot.length, 3);
+
+  const boolDataItem = snapshot[2];
+  checkSessionDataItem(
+    boolDataItem,
+    "fakemodule",
+    "testCategory",
+    ContextDescriptorType.All,
+    true
+  );
+
+  info("Remove one value");
+  sessionData.updateSessionData([
+    {
+      method: "remove",
+      moduleName: "fakemodule",
+      category: "testCategory",
+      contextDescriptor: contextDescriptorAll,
+      values: [12],
+    },
+  ]);
+  snapshot = (await getSessionDataFromContent()).get(sessionId);
+  is(snapshot.length, 2);
+  checkSessionDataItem(
+    snapshot[0],
+    "fakemodule",
+    "testCategory",
+    ContextDescriptorType.All,
+    "value-1"
+  );
+  checkSessionDataItem(
+    snapshot[1],
+    "fakemodule",
+    "testCategory",
+    ContextDescriptorType.All,
+    true
+  );
+
+  info("Remove all values");
+  sessionData.updateSessionData([
+    {
+      method: "remove",
+      moduleName: "fakemodule",
+      category: "testCategory",
+      contextDescriptor: contextDescriptorAll,
+      values: ["value-1", true],
+    },
+  ]);
+  snapshot = (await getSessionDataFromContent()).get(sessionId);
+  is(snapshot.length, 0, "Session data is now empty");
+
+  info("Add another value before destroy");
+  sessionData.updateSessionData([
+    {
+      method: "add",
+      moduleName: "fakemodule",
+      category: "testCategory",
+      contextDescriptor: contextDescriptorAll,
+      values: ["value-2"],
+    },
+  ]);
+  snapshot = (await getSessionDataFromContent()).get(sessionId);
+  is(snapshot.length, 1);
+  checkSessionDataItem(
+    snapshot[0],
+    "fakemodule",
+    "testCategory",
+    ContextDescriptorType.All,
+    "value-2"
+  );
+
+  sessionData.destroy();
+  sessionDataSnapshot = await getSessionDataFromContent();
+  is(sessionDataSnapshot.size, 0, "session data should be empty again");
+});
+
+add_task(async function test_sessionDataRootOnlyModule() {
+  const sessionId = "sessionData-test-rootOnly";
+
+  const rootMessageHandler = createRootMessageHandler(sessionId);
+  ok(rootMessageHandler, "Valid ROOT MessageHandler created");
+
+  await BrowserTestUtils.loadURIString(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+
+  const windowGlobalCreated = rootMessageHandler.once("message-handler-event");
+
+  info("Test that adding SessionData items works the root module");
+  // Updating the session data on the root message handler should not cause
+  // failures for other message handlers if the module only exists for root.
+  await rootMessageHandler.addSessionDataItem({
+    moduleName: "rootOnly",
+    category: "session_data_root_only",
+    contextDescriptor: {
+      type: ContextDescriptorType.All,
+    },
+    values: [true],
+  });
+
+  await windowGlobalCreated;
+  ok(true, "Window global has been initialized");
+
+  let sessionDataReceivedByRoot = await rootMessageHandler.handleCommand({
+    moduleName: "rootOnly",
+    commandName: "getSessionDataReceived",
+    destination: {
+      type: RootMessageHandler.type,
+    },
+  });
+
+  is(sessionDataReceivedByRoot.length, 1);
+  is(sessionDataReceivedByRoot[0].category, "session_data_root_only");
+  is(sessionDataReceivedByRoot[0].added.length, 1);
+  is(sessionDataReceivedByRoot[0].added[0], true);
+  is(
+    sessionDataReceivedByRoot[0].contextDescriptor.type,
+    ContextDescriptorType.All
+  );
+
+  info("Now test that removing items also works on the root module");
+  await rootMessageHandler.removeSessionDataItem({
+    moduleName: "rootOnly",
+    category: "session_data_root_only",
+    contextDescriptor: {
+      type: ContextDescriptorType.All,
+    },
+    values: [true],
+  });
+
+  sessionDataReceivedByRoot = await rootMessageHandler.handleCommand({
+    moduleName: "rootOnly",
+    commandName: "getSessionDataReceived",
+    destination: {
+      type: RootMessageHandler.type,
+    },
+  });
+
+  is(sessionDataReceivedByRoot.length, 2);
+  is(sessionDataReceivedByRoot[1].category, "session_data_root_only");
+  is(sessionDataReceivedByRoot[1].removed.length, 1);
+  is(sessionDataReceivedByRoot[1].removed[0], true);
+  is(
+    sessionDataReceivedByRoot[1].contextDescriptor.type,
+    ContextDescriptorType.All
+  );
+
+  rootMessageHandler.destroy();
+});
+
+function checkSessionDataItem(item, moduleName, category, contextType, value) {
+  is(item.moduleName, moduleName, "Data item has the expected module name");
+  is(item.category, category, "Data item has the expected category");
+  is(
+    item.contextDescriptor.type,
+    contextType,
+    "Data item has the expected context type"
+  );
+  is(item.value, value, "Data item has the expected value");
+}
+
+function getSessionDataFromContent() {
+  return SpecialPowers.spawn(gBrowser.selectedBrowser, [], () => {
+    const { readSessionData } = ChromeUtils.importESModule(
+      "chrome://remote/content/shared/messagehandler/sessiondata/SessionDataReader.sys.mjs"
+    );
+    return readSessionData();
+  });
+}
diff --git a/remote/shared/messagehandler/test/browser/browser_session_data_browser_element.js b/remote/shared/messagehandler/test/browser/browser_session_data_browser_element.js
new file mode 100644
index 0000000000..9c15974ae6
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_session_data_browser_element.js
@@ -0,0 +1,94 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+/**
+ * Check that message handlers are not created for parent process browser
+ * elements, even if they have the type="content" attribute (eg used for the
+ * DevTools toolbox), as well as for webextension contexts.
+ */
+add_task(async function test_session_data_broadcast() {
+  // Prepare:
+  // - one content tab
+  // - one browser type content
+  // - one browser type chrome
+  // - one sidebar webextension
+  // We only expect session data to be applied to the content tab
+  const tab1 = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+  const contentBrowser1 = tab1.linkedBrowser;
+  await BrowserTestUtils.browserLoaded(contentBrowser1);
+  const parentBrowser1 = createParentBrowserElement(tab1, "content");
+  const parentBrowser2 = createParentBrowserElement(tab1, "chrome");
+  const { extension: extension1, sidebarBrowser: extSidebarBrowser1 } =
+    await installSidebarExtension();
+
+  const root = createRootMessageHandler("session-id-event");
+
+  // When the windowglobal command.jsm module applies the session data
+  // browser_session_data_browser_element, it will emit an event.
+  // Collect the events to detect which MessageHandlers have been started.
+  info("Watch events emitted when session data is applied");
+  const sessionDataEvents = [];
+  const onRootEvent = function (evtName, wrappedEvt) {
+    if (wrappedEvt.name === "received-session-data") {
+      sessionDataEvents.push(wrappedEvt.data.contextId);
+    }
+  };
+  root.on("message-handler-event", onRootEvent);
+
+  info("Add a new session data item, expect one return value");
+  await root.addSessionDataItem({
+    moduleName: "command",
+    category: "browser_session_data_browser_element",
+    contextDescriptor: {
+      type: ContextDescriptorType.All,
+    },
+    values: [true],
+  });
+
+  function hasSessionData(browsingContext) {
+    return sessionDataEvents.includes(browsingContext.id);
+  }
+
+  info(
+    "Check that only the content tab window global received the session data"
+  );
+  is(hasSessionData(contentBrowser1.browsingContext), true);
+  is(hasSessionData(parentBrowser1.browsingContext), false);
+  is(hasSessionData(parentBrowser2.browsingContext), false);
+  is(hasSessionData(extSidebarBrowser1.browsingContext), false);
+
+  const tab2 = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+  const contentBrowser2 = tab2.linkedBrowser;
+  await BrowserTestUtils.browserLoaded(contentBrowser2);
+  const parentBrowser3 = createParentBrowserElement(contentBrowser2, "content");
+  const parentBrowser4 = createParentBrowserElement(contentBrowser2, "chrome");
+
+  const { extension: extension2, sidebarBrowser: extSidebarBrowser2 } =
+    await installSidebarExtension();
+
+  info("Wait until the session data was applied to the new tab");
+  await TestUtils.waitForCondition(() =>
+    sessionDataEvents.includes(contentBrowser2.browsingContext.id)
+  );
+
+  info("Check that parent browser elements did not apply the session data");
+  is(hasSessionData(parentBrowser3.browsingContext), false);
+  is(hasSessionData(parentBrowser4.browsingContext), false);
+
+  info(
+    "Check that extension did not apply the session data, " +
+      extSidebarBrowser2.browsingContext.id
+  );
+  is(hasSessionData(extSidebarBrowser2.browsingContext), false);
+
+  root.destroy();
+
+  gBrowser.removeTab(tab1);
+  gBrowser.removeTab(tab2);
+  await extension1.unload();
+  await extension2.unload();
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_session_data_constructor_race.js b/remote/shared/messagehandler/test/browser/browser_session_data_constructor_race.js
new file mode 100644
index 0000000000..03ed59166f
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_session_data_constructor_race.js
@@ -0,0 +1,50 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+/**
+ * Check that modules created early for session data are still created with a
+ * fully initialized MessageHandler. See Bug 1743083.
+ */
+add_task(async function () {
+  const tab = BrowserTestUtils.addTab(gBrowser, TEST_PAGE);
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContext = tab.linkedBrowser.browsingContext;
+
+  const root = createRootMessageHandler("session-id-event");
+
+  info("Add some session data for the command module");
+  await root.addSessionDataItem({
+    moduleName: "command",
+    category: "testCategory",
+    contextDescriptor: contextDescriptorAll,
+    values: ["some-value"],
+  });
+
+  info("Reload the current tab to create new message handlers and modules");
+  await BrowserTestUtils.reloadTab(tab);
+
+  info(
+    "Check if the command module was created by the MessageHandler constructor"
+  );
+  const isCreatedByMessageHandlerConstructor = await root.handleCommand({
+    moduleName: "command",
+    commandName: "testIsCreatedByMessageHandlerConstructor",
+    destination: {
+      type: WindowGlobalMessageHandler.type,
+      id: browsingContext.id,
+    },
+  });
+
+  is(
+    isCreatedByMessageHandlerConstructor,
+    false,
+    "The command module from session data should not be created by the MessageHandler constructor"
+  );
+  root.destroy();
+
+  gBrowser.removeTab(tab);
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_session_data_update.js b/remote/shared/messagehandler/test/browser/browser_session_data_update.js
new file mode 100644
index 0000000000..342a4a6139
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_session_data_update.js
@@ -0,0 +1,113 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+const { assertUpdate, createSessionDataUpdate, getUpdates } =
+  SessionDataUpdateHelpers;
+
+// Test various session data update scenarios against a single browsing context.
+add_task(async function test_session_data_update() {
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, TEST_PAGE);
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  const root = createRootMessageHandler("session-data-update");
+
+  info("Add a new session data item, expect one return value");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-1"], "add", "category1"),
+  ]);
+  let processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 1);
+  assertUpdate(processedUpdates.at(-1), ["text-1"], "category1");
+
+  info("Add two session data items, expect one return value with both items");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-2"], "add", "category1"),
+    createSessionDataUpdate(["text-3"], "add", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 2);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-3"],
+    "category1"
+  );
+
+  info("Try to add an existing data item, expect no update broadcast");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-1"], "add", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 2);
+
+  info("Add an existing and a new item");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-2", "text-4"], "add", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 3);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-3", "text-4"],
+    "category1"
+  );
+
+  info("Remove an item, expect only the new item to return");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-3"], "remove", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 4);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-4"],
+    "category1"
+  );
+
+  info("Remove a unknown item, expect no return value");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-unknown"], "remove", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 4);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-4"],
+    "category1"
+  );
+
+  info("Remove an existing and a unknown item");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-2"], "remove", "category1"),
+    createSessionDataUpdate(["text-unknown"], "remove", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 5);
+  assertUpdate(processedUpdates.at(-1), ["text-1", "text-4"], "category1");
+
+  info("Add and remove at once");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-5"], "add", "category1"),
+    createSessionDataUpdate(["text-4"], "remove", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 6);
+  assertUpdate(processedUpdates.at(-1), ["text-1", "text-5"], "category1");
+
+  info("Adding and removing an item does not trigger any update");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-6"], "add", "category1"),
+    createSessionDataUpdate(["text-6"], "remove", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  // TODO: We could detect transactions which can't have any impact and fully
+  // ignore them. See Bug 1810807.
+  todo_is(processedUpdates.length, 6);
+  assertUpdate(processedUpdates.at(-1), ["text-1", "text-5"], "category1");
+
+  root.destroy();
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_session_data_update_categories.js b/remote/shared/messagehandler/test/browser/browser_session_data_update_categories.js
new file mode 100644
index 0000000000..b1cadcf095
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_session_data_update_categories.js
@@ -0,0 +1,91 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+const { assertUpdate, createSessionDataUpdate, getUpdates } =
+  SessionDataUpdateHelpers;
+
+// Test session data update scenarios involving different session data item
+// categories.
+add_task(async function test_session_data_update_categories() {
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, TEST_PAGE);
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  const root = createRootMessageHandler("session-data-update-categories");
+  await root.updateSessionData([
+    createSessionDataUpdate(["value1-1"], "add", "category1"),
+    createSessionDataUpdate(["value1-2"], "add", "category1"),
+  ]);
+
+  let processedUpdates = await getUpdates(root, browsingContext1);
+
+  is(processedUpdates.length, 1);
+  assertUpdate(processedUpdates.at(-1), ["value1-1", "value1-2"], "category1");
+
+  info("Adding a new item in category1 broadcasts all category1 items");
+  await root.updateSessionData([
+    createSessionDataUpdate(["value1-3"], "add", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 2);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["value1-1", "value1-2", "value1-3"],
+    "category1"
+  );
+
+  info("Removing a new item in category1 broadcasts all category1 items");
+  await root.updateSessionData([
+    createSessionDataUpdate(["value1-1"], "remove", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 3);
+  assertUpdate(processedUpdates.at(-1), ["value1-2", "value1-3"], "category1");
+
+  info("Adding a new category does not broadcast category1 items");
+  await root.updateSessionData([
+    createSessionDataUpdate(["value2-1"], "add", "category2"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 4);
+  assertUpdate(processedUpdates.at(-1), ["value2-1"], "category2");
+
+  info("Adding an item in 2 categories triggers an update for each category");
+  await root.updateSessionData([
+    createSessionDataUpdate(["value1-4"], "add", "category1"),
+    createSessionDataUpdate(["value2-2"], "add", "category2"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 6);
+  assertUpdate(
+    processedUpdates.at(-2),
+    ["value1-2", "value1-3", "value1-4"],
+    "category1"
+  );
+  assertUpdate(processedUpdates.at(-1), ["value2-1", "value2-2"], "category2");
+
+  info("Removing an item in 2 categories triggers an update for each category");
+  await root.updateSessionData([
+    createSessionDataUpdate(["value1-4"], "remove", "category1"),
+    createSessionDataUpdate(["value2-2"], "remove", "category2"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 8);
+  assertUpdate(processedUpdates.at(-2), ["value1-2", "value1-3"], "category1");
+  assertUpdate(processedUpdates.at(-1), ["value2-1"], "category2");
+
+  info("Opening a new tab triggers an update for each category");
+  const tab2 = await addTab(TEST_PAGE);
+  const browsingContext2 = tab2.linkedBrowser.browsingContext;
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 2);
+  assertUpdate(processedUpdates.at(-2), ["value1-2", "value1-3"], "category1");
+  assertUpdate(processedUpdates.at(-1), ["value2-1"], "category2");
+
+  root.destroy();
+  gBrowser.removeTab(tab2);
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_session_data_update_contexts.js b/remote/shared/messagehandler/test/browser/browser_session_data_update_contexts.js
new file mode 100644
index 0000000000..711df1fc56
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_session_data_update_contexts.js
@@ -0,0 +1,194 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const TEST_PAGE = "https://example.com/document-builder.sjs?html=tab";
+
+const { assertUpdate, createSessionDataUpdate, getUpdates } =
+  SessionDataUpdateHelpers;
+
+// Test session data update scenarios involving 2 browsing contexts, and using
+// the TopBrowsingContext ContextDescriptor type.
+add_task(async function test_session_data_update_contexts() {
+  const tab1 = gBrowser.selectedTab;
+  await loadURL(tab1.linkedBrowser, TEST_PAGE);
+  const browsingContext1 = tab1.linkedBrowser.browsingContext;
+
+  const root = createRootMessageHandler("session-data-update-contexts");
+
+  info("Add several items over 2 separate updates for all contexts");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-1"], "add", "category1"),
+  ]);
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-2"], "add", "category1"),
+    createSessionDataUpdate(["text-3"], "add", "category1"),
+  ]);
+
+  info("Check we processed two distinct updates in browsingContext 1");
+  let processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 2);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-3"],
+    "category1"
+  );
+
+  info("Open a new tab on the same test URL");
+  const tab2 = await addTab(TEST_PAGE);
+  const browsingContext2 = tab2.linkedBrowser.browsingContext;
+
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 1);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-3"],
+    "category1"
+  );
+
+  info("Add two items: one globally and one in a single context");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-4"], "add", "category1"),
+    createSessionDataUpdate(["text-5"], "add", "category1", {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext2.browserId,
+    }),
+  ]);
+
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 3);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-3", "text-4"],
+    "category1"
+  );
+
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 2);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-1", "text-2", "text-3", "text-4", "text-5"],
+    "category1"
+  );
+
+  info("Remove two items: one globally and one in a single context");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-1"], "remove", "category1"),
+    createSessionDataUpdate(["text-5"], "remove", "category1", {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext2.browserId,
+    }),
+  ]);
+
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 4);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4"],
+    "category1"
+  );
+
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 3);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4"],
+    "category1"
+  );
+
+  info(
+    "Add session data item to all contexts and remove this event for one context (2 steps)"
+  );
+
+  info("First step: add an item to browsingContext1");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-6"], "add", "category1", {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext1.browserId,
+    }),
+  ]);
+
+  info(
+    "Second step: remove the item from browsingContext1, and add it globally"
+  );
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-6"], "remove", "category1", {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext1.browserId,
+    }),
+    createSessionDataUpdate(["text-6"], "add", "category1"),
+  ]);
+
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 6);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4", "text-6"],
+    "category1"
+  );
+
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 4);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4", "text-6"],
+    "category1"
+  );
+
+  info(
+    "Remove the event, which has also an individual subscription, for all contexts (2 steps)"
+  );
+
+  info("First step: Add the same item for browsingContext1 and globally");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-7"], "add", "category1", {
+      type: ContextDescriptorType.TopBrowsingContext,
+      id: browsingContext1.browserId,
+    }),
+    createSessionDataUpdate(["text-7"], "add", "category1"),
+  ]);
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 7);
+  // We will find text-7 twice here, the module is responsible for not applying
+  // the same session data item twice. Each item corresponds to a different
+  // descriptor which matched browsingContext1.
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4", "text-6", "text-7", "text-7"],
+    "category1"
+  );
+
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 5);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4", "text-6", "text-7"],
+    "category1"
+  );
+
+  info("Second step: Remove the item globally");
+  await root.updateSessionData([
+    createSessionDataUpdate(["text-7"], "remove", "category1"),
+  ]);
+
+  processedUpdates = await getUpdates(root, browsingContext1);
+  is(processedUpdates.length, 8);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4", "text-6", "text-7"],
+    "category1"
+  );
+
+  processedUpdates = await getUpdates(root, browsingContext2);
+  is(processedUpdates.length, 6);
+  assertUpdate(
+    processedUpdates.at(-1),
+    ["text-2", "text-3", "text-4", "text-6"],
+    "category1"
+  );
+
+  root.destroy();
+
+  gBrowser.removeTab(tab2);
+});
diff --git a/remote/shared/messagehandler/test/browser/browser_windowglobal_to_root.js b/remote/shared/messagehandler/test/browser/browser_windowglobal_to_root.js
new file mode 100644
index 0000000000..57629e5485
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/browser_windowglobal_to_root.js
@@ -0,0 +1,47 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+
+add_task(async function test_windowGlobal_to_root_command() {
+  // Navigate to a page to make sure that the windowglobal modules run in a
+  // different process than the root module.
+  const tab = BrowserTestUtils.addTab(
+    gBrowser,
+    "https://example.com/document-builder.sjs?html=tab"
+  );
+  await BrowserTestUtils.browserLoaded(tab.linkedBrowser);
+  const browsingContextId = tab.linkedBrowser.browsingContext.id;
+
+  const rootMessageHandler = createRootMessageHandler(
+    "session-id-windowglobal-to-rootModule"
+  );
+
+  for (const commandName of [
+    "testHandleCommandToRoot",
+    "testSendRootCommand",
+  ]) {
+    const valueFromRoot = await rootMessageHandler.handleCommand({
+      moduleName: "windowglobaltoroot",
+      commandName,
+      destination: {
+        type: WindowGlobalMessageHandler.type,
+        id: browsingContextId,
+      },
+    });
+
+    is(
+      valueFromRoot,
+      "root-value-called-from-windowglobal",
+      "Retrieved the expected value from windowglobaltoroot using " +
+        commandName
+    );
+  }
+
+  rootMessageHandler.destroy();
+  gBrowser.removeTab(tab);
+});
diff --git a/remote/shared/messagehandler/test/browser/head.js b/remote/shared/messagehandler/test/browser/head.js
new file mode 100644
index 0000000000..5397fc0761
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/head.js
@@ -0,0 +1,236 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+var { ContextDescriptorType } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs"
+);
+
+var { WindowGlobalMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs"
+);
+
+var contextDescriptorAll = {
+  type: ContextDescriptorType.All,
+};
+
+function createRootMessageHandler(sessionId) {
+  const { RootMessageHandlerRegistry } = ChromeUtils.importESModule(
+    "chrome://remote/content/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs"
+  );
+  return RootMessageHandlerRegistry.getOrCreateMessageHandler(sessionId);
+}
+
+/**
+ * Load the provided url in an existing browser.
+ * Returns a promise which will resolve when the page is loaded.
+ *
+ * @param {Browser} browser
+ *     The browser element where the URL should be loaded.
+ * @param {string} url
+ *     The URL to load in the new tab
+ */
+async function loadURL(browser, url) {
+  const loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.loadURIString(browser, url);
+  return loaded;
+}
+
+/**
+ * Create a new foreground tab loading the provided url.
+ * Returns a promise which will resolve when the page is loaded.
+ *
+ * @param {string} url
+ *     The URL to load in the new tab
+ */
+async function addTab(url) {
+  const tab = await BrowserTestUtils.openNewForegroundTab(gBrowser, url);
+  registerCleanupFunction(() => {
+    gBrowser.removeTab(tab);
+  });
+  return tab;
+}
+
+/**
+ * Create inline markup for a simple iframe that can be used with
+ * document-builder.sjs. The iframe will be served under the provided domain.
+ *
+ * @param {string} domain
+ *     A domain (eg "example.com"), compatible with build/pgo/server-locations.txt
+ */
+function createFrame(domain) {
+  return createFrameForUri(
+    `https://${domain}/document-builder.sjs?html=frame-${domain}`
+  );
+}
+
+function createFrameForUri(uri) {
+  return `<iframe src="${encodeURI(uri)}"></iframe>`;
+}
+
+/**
+ * Create a XUL browser element in the provided XUL tab, with the provided type.
+ *
+ * @param {XULTab} tab
+ *     The XUL tab in which the browser element should be inserted.
+ * @param {string} type
+ *     The type attribute of the browser element, "chrome" or "content".
+ * @returns {XULBrowser}
+ *     The created browser element.
+ */
+function createParentBrowserElement(tab, type) {
+  const parentBrowser = gBrowser.ownerDocument.createXULElement("browser");
+  parentBrowser.setAttribute("type", type);
+  const container = gBrowser.getBrowserContainer(tab.linkedBrowser);
+  container.appendChild(parentBrowser);
+
+  return parentBrowser;
+}
+
+// Create a test page with 2 iframes:
+// - one with a different eTLD+1 (example.com)
+// - one with a nested iframe on a different eTLD+1 (example.net)
+//
+// Overall the document structure should look like:
+//
+// html (example.org)
+//   iframe (example.org)
+//     iframe (example.net)
+//   iframe(example.com)
+//
+// Which means we should have 4 browsing contexts in total.
+function createTestMarkupWithFrames() {
+  // Create the markup for an example.net frame nested in an example.com frame.
+  const NESTED_FRAME_MARKUP = createFrameForUri(
+    `https://example.org/document-builder.sjs?html=${createFrame(
+      "example.net"
+    )}`
+  );
+
+  // Combine the nested frame markup created above with an example.com frame.
+  const TEST_URI_MARKUP = `${NESTED_FRAME_MARKUP}${createFrame("example.com")}`;
+
+  // Create the test page URI on example.org.
+  return `https://example.org/document-builder.sjs?html=${encodeURI(
+    TEST_URI_MARKUP
+  )}`;
+}
+
+const hasPromiseResolved = async function (promise) {
+  let resolved = false;
+  promise.finally(() => (resolved = true));
+  // Make sure microtasks have time to run.
+  await new Promise(resolve => Services.tm.dispatchToMainThread(resolve));
+  return resolved;
+};
+
+/**
+ * Install a sidebar extension.
+ *
+ * @returns {object}
+ *     Return value with two properties:
+ *     - extension: test wrapper as returned by SpecialPowers.loadExtension.
+ *       Make sure to explicitly call extension.unload() before the end of the test.
+ *     - sidebarBrowser: the browser element containing the extension sidebar.
+ */
+async function installSidebarExtension() {
+  info("Load the test extension");
+  let extension = ExtensionTestUtils.loadExtension({
+    manifest: {
+      sidebar_action: {
+        default_panel: "sidebar.html",
+      },
+    },
+    useAddonManager: "temporary",
+
+    files: {
+      "sidebar.html": `
+        <!DOCTYPE html>
+        <html>
+          Test extension
+          <script src="sidebar.js"></script>
+        </html>
+      `,
+      "sidebar.js": function () {
+        const { browser } = this;
+        browser.test.sendMessage("sidebar-loaded", {
+          bcId: SpecialPowers.wrap(window).browsingContext.id,
+        });
+      },
+      "tab.html": `
+        <!DOCTYPE html>
+        <html>
+          Test extension (tab)
+          <script src="tab.js"></script>
+        </html>
+      `,
+      "tab.js": function () {
+        const { browser } = this;
+        browser.test.sendMessage("tab-loaded", {
+          bcId: SpecialPowers.wrap(window).browsingContext.id,
+        });
+      },
+    },
+  });
+
+  info("Wait for the extension to start");
+  await extension.startup();
+
+  info("Wait for the extension browsing context");
+  const { bcId } = await extension.awaitMessage("sidebar-loaded");
+  const sidebarBrowser = BrowsingContext.get(bcId).top.embedderElement;
+  ok(sidebarBrowser, "Got a browser element for the extension sidebar");
+
+  return {
+    extension,
+    sidebarBrowser,
+  };
+}
+
+const SessionDataUpdateHelpers = {
+  getUpdates(rootMessageHandler, browsingContext) {
+    return rootMessageHandler.handleCommand({
+      moduleName: "sessiondataupdate",
+      commandName: "getSessionDataUpdates",
+      destination: {
+        id: browsingContext.id,
+        type: WindowGlobalMessageHandler.type,
+      },
+    });
+  },
+
+  createSessionDataUpdate(
+    values,
+    method,
+    category,
+    descriptor = { type: ContextDescriptorType.All }
+  ) {
+    return {
+      method,
+      values,
+      moduleName: "sessiondataupdate",
+      category,
+      contextDescriptor: descriptor,
+    };
+  },
+
+  assertUpdate(update, expectedValues, expectedCategory) {
+    is(
+      update.length,
+      expectedValues.length,
+      "Update has the expected number of values"
+    );
+
+    for (const item of update) {
+      info(`Check session data update item '${item.value}'`);
+      is(item.category, expectedCategory, "Item has the expected category");
+      is(
+        expectedValues[update.indexOf(item)],
+        item.value,
+        "Item has the expected value"
+      );
+    }
+  },
+};
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/ModuleRegistry.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/ModuleRegistry.sys.mjs
new file mode 100644
index 0000000000..7d93f45b33
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/ModuleRegistry.sys.mjs
@@ -0,0 +1,40 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+export const modules = {
+  root: {},
+  "windowglobal-in-root": {},
+  windowglobal: {},
+};
+
+const BASE_FOLDER =
+  "chrome://mochitests/content/browser/remote/shared/messagehandler/test/browser/resources/modules";
+
+// eslint-disable-next-line mozilla/lazy-getter-object-name
+ChromeUtils.defineESModuleGetters(modules.root, {
+  command: `${BASE_FOLDER}/root/command.sys.mjs`,
+  event: `${BASE_FOLDER}/root/event.sys.mjs`,
+  invalid: `${BASE_FOLDER}/root/invalid.sys.mjs`,
+  rootOnly: `${BASE_FOLDER}/root/rootOnly.sys.mjs`,
+  windowglobaltoroot: `${BASE_FOLDER}/root/windowglobaltoroot.sys.mjs`,
+});
+
+// eslint-disable-next-line mozilla/lazy-getter-object-name
+ChromeUtils.defineESModuleGetters(modules["windowglobal-in-root"], {
+  command: `${BASE_FOLDER}/windowglobal-in-root/command.sys.mjs`,
+  event: `${BASE_FOLDER}/windowglobal-in-root/event.sys.mjs`,
+});
+
+// eslint-disable-next-line mozilla/lazy-getter-object-name
+ChromeUtils.defineESModuleGetters(modules.windowglobal, {
+  command: `${BASE_FOLDER}/windowglobal/command.sys.mjs`,
+  commandwindowglobalonly: `${BASE_FOLDER}/windowglobal/commandwindowglobalonly.sys.mjs`,
+  event: `${BASE_FOLDER}/windowglobal/event.sys.mjs`,
+  eventemitter: `${BASE_FOLDER}/windowglobal/eventemitter.sys.mjs`,
+  eventnointercept: `${BASE_FOLDER}/windowglobal/eventnointercept.sys.mjs`,
+  eventonprefchange: `${BASE_FOLDER}/windowglobal/eventonprefchange.sys.mjs`,
+  retry: `${BASE_FOLDER}/windowglobal/retry.sys.mjs`,
+  sessiondataupdate: `${BASE_FOLDER}/windowglobal/sessiondataupdate.sys.mjs`,
+  windowglobaltoroot: `${BASE_FOLDER}/windowglobal/windowglobaltoroot.sys.mjs`,
+});
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/root/command.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/root/command.sys.mjs
new file mode 100644
index 0000000000..29e4a75828
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/root/command.sys.mjs
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class CommandModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  testRootModule() {
+    return "root-value";
+  }
+
+  testMissingIntermediaryMethod(params, destination) {
+    // Spawn a new internal command, but with a commandName which doesn't match
+    // any method.
+    return this.messageHandler.handleCommand({
+      moduleName: "command",
+      commandName: "missingMethod",
+      destination,
+    });
+  }
+}
+
+export const command = CommandModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/root/event.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/root/event.sys.mjs
new file mode 100644
index 0000000000..e49437e80d
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/root/event.sys.mjs
@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class EventModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  testEmitRootEvent() {
+    this.emitEvent("event-from-root", {
+      text: "event from root",
+    });
+  }
+}
+
+export const event = EventModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/root/invalid.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/root/invalid.sys.mjs
new file mode 100644
index 0000000000..3b74769d06
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/root/invalid.sys.mjs
@@ -0,0 +1,4 @@
+// This module is meant to check error reporting when importing a module fails
+// due to an actual issue (syntax error etc...).
+
+SyntaxError(;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/root/rootOnly.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/root/rootOnly.sys.mjs
new file mode 100644
index 0000000000..0931a7ee8e
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/root/rootOnly.sys.mjs
@@ -0,0 +1,70 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { ContextDescriptorType } from "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs";
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class RootOnlyModule extends Module {
+  #sessionDataReceived;
+  #subscribedEvents;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+
+    this.#sessionDataReceived = [];
+    this.#subscribedEvents = new Set();
+  }
+
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  getSessionDataReceived() {
+    return this.#sessionDataReceived;
+  }
+
+  testCommand(params = {}) {
+    return params;
+  }
+
+  _applySessionData(params) {
+    const added = [];
+    const removed = [];
+
+    const filteredSessionData = params.sessionData.filter(item =>
+      this.messageHandler.matchesContext(item.contextDescriptor)
+    );
+    for (const event of this.#subscribedEvents.values()) {
+      const hasSessionItem = filteredSessionData.some(
+        item => item.value === event
+      );
+      // If there are no session items for this context, we should unsubscribe from the event.
+      if (!hasSessionItem) {
+        this.#subscribedEvents.delete(event);
+        removed.push(event);
+      }
+    }
+
+    // Subscribe to all events, which have an item in SessionData
+    for (const { value } of filteredSessionData) {
+      if (!this.#subscribedEvents.has(value)) {
+        this.#subscribedEvents.add(value);
+        added.push(value);
+      }
+    }
+
+    this.#sessionDataReceived.push({
+      category: params.category,
+      added,
+      removed,
+      contextDescriptor: {
+        type: ContextDescriptorType.All,
+      },
+    });
+  }
+}
+
+export const rootOnly = RootOnlyModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/root/windowglobaltoroot.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/root/windowglobaltoroot.sys.mjs
new file mode 100644
index 0000000000..0975c4abd5
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/root/windowglobaltoroot.sys.mjs
@@ -0,0 +1,29 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class WindowGlobalToRootModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  getValueFromRoot() {
+    this.#assertParentProcess();
+    return "root-value-called-from-windowglobal";
+  }
+
+  #assertParentProcess() {
+    const isParent =
+      Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_DEFAULT;
+
+    if (!isParent) {
+      throw new Error("Can only run in the parent process");
+    }
+  }
+}
+
+export const windowglobaltoroot = WindowGlobalToRootModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal-in-root/command.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal-in-root/command.sys.mjs
new file mode 100644
index 0000000000..f9a2e5d4eb
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal-in-root/command.sys.mjs
@@ -0,0 +1,28 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class CommandModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  testInterceptModule() {
+    return "intercepted-value";
+  }
+
+  async testInterceptAndForwardModule(params, destination) {
+    const windowGlobalValue = await this.messageHandler.handleCommand({
+      moduleName: "command",
+      commandName: "testForwardToWindowGlobal",
+      destination,
+    });
+    return "intercepted-and-forward+" + windowGlobalValue;
+  }
+}
+
+export const command = CommandModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal-in-root/event.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal-in-root/event.sys.mjs
new file mode 100644
index 0000000000..2969e0a3e8
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal-in-root/event.sys.mjs
@@ -0,0 +1,31 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class EventModule extends Module {
+  destroy() {}
+
+  interceptEvent(name, payload) {
+    if (name === "event.testEventWithInterception") {
+      return {
+        ...payload,
+        additionalInformation: "information added through interception",
+      };
+    }
+    return payload;
+  }
+
+  /**
+   * Commands
+   */
+
+  testEmitWindowGlobalInRootEvent(params, destination) {
+    this.emitEvent("event-from-window-global-in-root", {
+      text: `windowglobal-in-root event for ${destination.id}`,
+    });
+  }
+}
+
+export const event = EventModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/command.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/command.sys.mjs
new file mode 100644
index 0000000000..99ee76a4b8
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/command.sys.mjs
@@ -0,0 +1,85 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class CommandModule extends Module {
+  constructor(messageHandler) {
+    super(messageHandler);
+    this._subscribedEvents = new Set();
+
+    this._createdByMessageHandlerConstructor =
+      this._isCreatedByMessageHandlerConstructor();
+  }
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  _applySessionData(params) {
+    if (params.category === "testCategory") {
+      const filteredSessionData = params.sessionData.filter(item =>
+        this.messageHandler.matchesContext(item.contextDescriptor)
+      );
+      for (const event of this._subscribedEvents.values()) {
+        const hasSessionItem = filteredSessionData.some(
+          item => item.value === event
+        );
+        // If there are no session items for this context, we should unsubscribe from the event.
+        if (!hasSessionItem) {
+          this._subscribedEvents.delete(event);
+        }
+      }
+
+      // Subscribe to all events, which have an item in SessionData
+      for (const { value } of filteredSessionData) {
+        if (!this._subscribedEvents.has(value)) {
+          this._subscribedEvents.add(value);
+        }
+      }
+    }
+
+    if (params.category === "browser_session_data_browser_element") {
+      this.emitEvent("received-session-data", {
+        contextId: this.messageHandler.contextId,
+      });
+    }
+  }
+
+  testWindowGlobalModule() {
+    return "windowglobal-value";
+  }
+
+  testSetValue(params) {
+    const { value } = params;
+
+    this._testValue = value;
+  }
+
+  testGetValue() {
+    return this._testValue;
+  }
+
+  testForwardToWindowGlobal() {
+    return "forward-to-windowglobal-value";
+  }
+
+  testIsCreatedByMessageHandlerConstructor() {
+    return this._createdByMessageHandlerConstructor;
+  }
+
+  _isCreatedByMessageHandlerConstructor() {
+    let caller = Components.stack.caller;
+    while (caller) {
+      if (caller.name === this.messageHandler.constructor.name) {
+        return true;
+      }
+      caller = caller.caller;
+    }
+    return false;
+  }
+}
+
+export const command = CommandModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/commandwindowglobalonly.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/commandwindowglobalonly.sys.mjs
new file mode 100644
index 0000000000..1e4e6c1574
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/commandwindowglobalonly.sys.mjs
@@ -0,0 +1,41 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class CommandWindowGlobalOnlyModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  testOnlyInWindowGlobal() {
+    return "only-in-windowglobal";
+  }
+
+  testBroadcast() {
+    return `broadcast-${this.messageHandler.contextId}`;
+  }
+
+  testBroadcastWithParameter(params) {
+    return `broadcast-${this.messageHandler.contextId}-${params.value}`;
+  }
+
+  testError() {
+    throw new Error("error-from-module");
+  }
+
+  testMissingIntermediaryMethod(params, destination) {
+    // Spawn a new internal command, but with a commandName which doesn't match
+    // any method.
+    return this.messageHandler.handleCommand({
+      moduleName: "commandwindowglobalonly",
+      commandName: "missingMethod",
+      destination,
+    });
+  }
+}
+
+export const commandwindowglobalonly = CommandWindowGlobalOnlyModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/event.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/event.sys.mjs
new file mode 100644
index 0000000000..5bb50cb83d
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/event.sys.mjs
@@ -0,0 +1,26 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class EventModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  testEmitEvent() {
+    // Emit a payload including the contextId to check which context emitted
+    // a specific event.
+    const text = `event from ${this.messageHandler.contextId}`;
+    this.emitEvent("event-from-window-global", { text });
+  }
+
+  testEmitEventWithInterception() {
+    this.emitEvent("event.testEventWithInterception", {});
+  }
+}
+
+export const event = EventModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventemitter.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventemitter.sys.mjs
new file mode 100644
index 0000000000..c86954c5e0
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventemitter.sys.mjs
@@ -0,0 +1,81 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class EventEmitterModule extends Module {
+  #isSubscribed;
+  #subscribedEvents;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+    this.#isSubscribed = false;
+    this.#subscribedEvents = new Set();
+  }
+
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  emitTestEvent() {
+    if (this.#isSubscribed) {
+      const text = `event from ${this.messageHandler.contextId}`;
+      this.emitEvent("eventemitter.testEvent", { text });
+    }
+
+    // Emit another event consistently for monitoring during the test.
+    this.emitEvent("eventemitter.monitoringEvent", {});
+  }
+
+  isSubscribed() {
+    return this.#isSubscribed;
+  }
+
+  _applySessionData(params) {
+    const { category } = params;
+    if (category === "event") {
+      const filteredSessionData = params.sessionData.filter(item =>
+        this.messageHandler.matchesContext(item.contextDescriptor)
+      );
+      for (const event of this.#subscribedEvents.values()) {
+        const hasSessionItem = filteredSessionData.some(
+          item => item.value === event
+        );
+        // If there are no session items for this context, we should unsubscribe from the event.
+        if (!hasSessionItem) {
+          this.#unsubscribeEvent(event);
+        }
+      }
+
+      // Subscribe to all events, which have an item in SessionData
+      for (const { value } of filteredSessionData) {
+        this.#subscribeEvent(value);
+      }
+    }
+  }
+
+  #subscribeEvent(event) {
+    if (event === "eventemitter.testEvent") {
+      if (this.#isSubscribed) {
+        throw new Error("Already subscribed to eventemitter.testEvent");
+      }
+      this.#isSubscribed = true;
+      this.#subscribedEvents.add(event);
+    }
+  }
+
+  #unsubscribeEvent(event) {
+    if (event === "eventemitter.testEvent") {
+      if (!this.#isSubscribed) {
+        throw new Error("Not subscribed to eventemitter.testEvent");
+      }
+      this.#isSubscribed = false;
+      this.#subscribedEvents.delete(event);
+    }
+  }
+}
+
+export const eventemitter = EventEmitterModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventnointercept.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventnointercept.sys.mjs
new file mode 100644
index 0000000000..48bbfbf951
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventnointercept.sys.mjs
@@ -0,0 +1,16 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class EventNoInterceptModule extends Module {
+  destroy() {}
+
+  testEvent() {
+    const text = `event no interception`;
+    this.emitEvent("eventnointercept.testEvent", { text });
+  }
+}
+
+export const eventnointercept = EventNoInterceptModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventonprefchange.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventonprefchange.sys.mjs
new file mode 100644
index 0000000000..33cb25d10b
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/eventonprefchange.sys.mjs
@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+const TEST_PREF = "remote.messagehandler.test.pref";
+
+class EventOnPrefChangeModule extends Module {
+  constructor(messageHandler) {
+    super(messageHandler);
+    Services.prefs.addObserver(TEST_PREF, this.#onPreferenceUpdated);
+  }
+
+  destroy() {
+    Services.prefs.removeObserver(TEST_PREF, this.#onPreferenceUpdated);
+  }
+
+  #onPreferenceUpdated = () => {
+    this.emitEvent("preference-changed");
+  };
+
+  /**
+   * Commands
+   */
+
+  ping() {
+    // We only use this command to force creating the module.
+    return 1;
+  }
+}
+
+export const eventonprefchange = EventOnPrefChangeModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/retry.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/retry.sys.mjs
new file mode 100644
index 0000000000..f7b2279018
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/retry.sys.mjs
@@ -0,0 +1,84 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+// Store counters in the JSM scope to persist them across reloads.
+let callsToBlockedOneTime = 0;
+let callsToBlockedTenTimes = 0;
+let callsToBlockedElevenTimes = 0;
+
+// This module provides various commands which all hang for various reasons.
+// The test is supposed to trigger the command and then destroy the
+// JSWindowActor pair by any mean (eg a navigation) in order to trigger an
+// AbortError and a retry.
+class RetryModule extends Module {
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  // Resolves only if called while on the example.net domain.
+  async blockedOnNetDomain(params) {
+    // Note: we do not store a call counter here, because this is used for a
+    // cross-group navigation test, and the JSM will be loaded in different
+    // processes.
+    const uri = this.messageHandler.window.document.baseURI;
+    if (!uri.includes("example.net")) {
+      await new Promise(r => {});
+    }
+
+    return { ...params };
+  }
+
+  // Resolves only if called more than once.
+  async blockedOneTime(params) {
+    callsToBlockedOneTime++;
+    if (callsToBlockedOneTime < 2) {
+      await new Promise(r => {});
+    }
+
+    // Return:
+    // - params sent to the command to check that retries have correct params
+    // - the call counter
+    return { ...params, callsToCommand: callsToBlockedOneTime };
+  }
+
+  // Resolves only if called more than ten times (which is exactly the maximum
+  // of retry attempts).
+  async blockedTenTimes(params) {
+    callsToBlockedTenTimes++;
+    if (callsToBlockedTenTimes < 11) {
+      await new Promise(r => {});
+    }
+
+    // Return:
+    // - params sent to the command to check that retries have correct params
+    // - the call counter
+    return { ...params, callsToCommand: callsToBlockedTenTimes };
+  }
+
+  // Resolves only if called more than eleven times (which is greater than the
+  // maximum of retry attempts).
+  async blockedElevenTimes(params) {
+    callsToBlockedElevenTimes++;
+    if (callsToBlockedElevenTimes < 12) {
+      await new Promise(r => {});
+    }
+
+    // Return:
+    // - params sent to the command to check that retries have correct params
+    // - the call counter
+    return { ...params, callsToCommand: callsToBlockedElevenTimes };
+  }
+
+  cleanup() {
+    callsToBlockedOneTime = 0;
+    callsToBlockedTenTimes = 0;
+    callsToBlockedElevenTimes = 0;
+  }
+}
+
+export const retry = RetryModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/sessiondataupdate.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/sessiondataupdate.sys.mjs
new file mode 100644
index 0000000000..5e9ce00b46
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/sessiondataupdate.sys.mjs
@@ -0,0 +1,33 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+
+class SessionDataUpdateModule extends Module {
+  #sessionDataUpdates;
+
+  constructor(messageHandler) {
+    super(messageHandler);
+    this.#sessionDataUpdates = [];
+  }
+
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  _applySessionData(params) {
+    const filteredSessionData = params.sessionData.filter(item =>
+      this.messageHandler.matchesContext(item.contextDescriptor)
+    );
+    this.#sessionDataUpdates.push(filteredSessionData);
+  }
+
+  getSessionDataUpdates() {
+    return this.#sessionDataUpdates;
+  }
+}
+
+export const sessiondataupdate = SessionDataUpdateModule;
diff --git a/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/windowglobaltoroot.sys.mjs b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/windowglobaltoroot.sys.mjs
new file mode 100644
index 0000000000..815a836d9c
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/resources/modules/windowglobal/windowglobaltoroot.sys.mjs
@@ -0,0 +1,47 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { Module } from "chrome://remote/content/shared/messagehandler/Module.sys.mjs";
+import { RootMessageHandler } from "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs";
+
+class WindowGlobalToRootModule extends Module {
+  constructor(messageHandler) {
+    super(messageHandler);
+    this.#assertContentProcess();
+  }
+
+  destroy() {}
+
+  /**
+   * Commands
+   */
+
+  testHandleCommandToRoot(params, destination) {
+    return this.messageHandler.handleCommand({
+      moduleName: "windowglobaltoroot",
+      commandName: "getValueFromRoot",
+      destination: {
+        type: RootMessageHandler.type,
+      },
+    });
+  }
+
+  testSendRootCommand(params, destination) {
+    return this.messageHandler.sendRootCommand({
+      moduleName: "windowglobaltoroot",
+      commandName: "getValueFromRoot",
+    });
+  }
+
+  #assertContentProcess() {
+    const isContent =
+      Services.appinfo.processType == Services.appinfo.PROCESS_TYPE_CONTENT;
+
+    if (!isContent) {
+      throw new Error("Can only run in a content process");
+    }
+  }
+}
+
+export const windowglobaltoroot = WindowGlobalToRootModule;
diff --git a/remote/shared/messagehandler/test/browser/webdriver/browser.ini b/remote/shared/messagehandler/test/browser/webdriver/browser.ini
new file mode 100644
index 0000000000..a7ece66163
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/webdriver/browser.ini
@@ -0,0 +1,9 @@
+[DEFAULT]
+tags = remote
+subsuite = remote
+support-files =
+  !/remote/shared/messagehandler/test/browser/resources/*
+prefs =
+  remote.messagehandler.modulecache.useBrowserTestRoot=true
+
+[browser_session_execute_command_errors.js]
diff --git a/remote/shared/messagehandler/test/browser/webdriver/browser_session_execute_command_errors.js b/remote/shared/messagehandler/test/browser/webdriver/browser_session_execute_command_errors.js
new file mode 100644
index 0000000000..36a510bb29
--- /dev/null
+++ b/remote/shared/messagehandler/test/browser/webdriver/browser_session_execute_command_errors.js
@@ -0,0 +1,40 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { WebDriverSession } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Session.sys.mjs"
+);
+
+const { error } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Errors.sys.mjs"
+);
+
+add_task(async function test_execute_missing_command_error() {
+  const session = new WebDriverSession();
+
+  info("Attempt to execute an unknown protocol command");
+  await Assert.rejects(
+    session.execute("command", "missingCommand"),
+    err =>
+      err.name == "UnknownCommandError" &&
+      err.message == `command.missingCommand`
+  );
+});
+
+add_task(async function test_execute_missing_internal_command_error() {
+  const session = new WebDriverSession();
+
+  info(
+    "Attempt to execute a protocol command which relies on an unknown internal method"
+  );
+  await Assert.rejects(
+    session.execute("command", "testMissingIntermediaryMethod"),
+    err =>
+      err.name == "UnsupportedCommandError" &&
+      err.message ==
+        `command.missingMethod not supported for destination ROOT` &&
+      !error.isWebDriverError(err)
+  );
+});
diff --git a/remote/shared/messagehandler/test/xpcshell/test_Errors.js b/remote/shared/messagehandler/test/xpcshell/test_Errors.js
new file mode 100644
index 0000000000..26187dac11
--- /dev/null
+++ b/remote/shared/messagehandler/test/xpcshell/test_Errors.js
@@ -0,0 +1,91 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { error } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/Errors.sys.mjs"
+);
+
+// Note: this test file is similar to remote/shared/webdriver/test/xpcshell/test_Errors.js
+// because shared/webdriver/Errors.jsm and shared/messagehandler/Errors.jsm share
+// similar helpers.
+
+add_task(function test_toJSON() {
+  let e0 = new error.MessageHandlerError();
+  let e0s = e0.toJSON();
+  equal(e0s.error, "message handler error");
+  equal(e0s.message, "");
+
+  let e1 = new error.MessageHandlerError("a");
+  let e1s = e1.toJSON();
+  equal(e1s.message, e1.message);
+
+  let e2 = new error.UnsupportedCommandError("foo");
+  let e2s = e2.toJSON();
+  equal(e2.status, e2s.error);
+  equal(e2.message, e2s.message);
+});
+
+add_task(function test_fromJSON() {
+  Assert.throws(
+    () => error.MessageHandlerError.fromJSON({ error: "foo" }),
+    /Not of MessageHandlerError descent/
+  );
+  Assert.throws(
+    () => error.MessageHandlerError.fromJSON({ error: "Error" }),
+    /Not of MessageHandlerError descent/
+  );
+  Assert.throws(
+    () => error.MessageHandlerError.fromJSON({}),
+    /Undeserialisable error type/
+  );
+  Assert.throws(
+    () => error.MessageHandlerError.fromJSON(undefined),
+    /TypeError/
+  );
+
+  let e1 = new error.MessageHandlerError("1");
+  let e1r = error.MessageHandlerError.fromJSON({
+    error: "message handler error",
+    message: "1",
+  });
+  ok(e1r instanceof error.MessageHandlerError);
+  equal(e1r.name, e1.name);
+  equal(e1r.status, e1.status);
+  equal(e1r.message, e1.message);
+
+  let e2 = new error.UnsupportedCommandError("foo");
+  let e2r = error.MessageHandlerError.fromJSON({
+    error: "unsupported message handler command",
+    message: "foo",
+  });
+  ok(e2r instanceof error.MessageHandlerError);
+  ok(e2r instanceof error.UnsupportedCommandError);
+  equal(e2r.name, e2.name);
+  equal(e2r.status, e2.status);
+  equal(e2r.message, e2.message);
+
+  // parity with toJSON
+  let e3 = new error.UnsupportedCommandError("foo");
+  let e3toJSON = e3.toJSON();
+  let e3fromJSON = error.MessageHandlerError.fromJSON(e3toJSON);
+  equal(e3toJSON.error, e3fromJSON.status);
+  equal(e3toJSON.message, e3fromJSON.message);
+  equal(e3toJSON.stacktrace, e3fromJSON.stack);
+});
+
+add_task(function test_MessageHandlerError() {
+  let err = new error.MessageHandlerError("foo");
+  equal("MessageHandlerError", err.name);
+  equal("foo", err.message);
+  equal("message handler error", err.status);
+  ok(err instanceof error.MessageHandlerError);
+});
+
+add_task(function test_UnsupportedCommandError() {
+  let e = new error.UnsupportedCommandError("foo");
+  equal("UnsupportedCommandError", e.name);
+  equal("foo", e.message);
+  equal("unsupported message handler command", e.status);
+  ok(e instanceof error.MessageHandlerError);
+});
diff --git a/remote/shared/messagehandler/test/xpcshell/test_SessionData.js b/remote/shared/messagehandler/test/xpcshell/test_SessionData.js
new file mode 100644
index 0000000000..ef61ce27d4
--- /dev/null
+++ b/remote/shared/messagehandler/test/xpcshell/test_SessionData.js
@@ -0,0 +1,296 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { ContextDescriptorType } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs"
+);
+const { RootMessageHandler } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs"
+);
+const { SessionData, SessionDataMethod } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/messagehandler/sessiondata/SessionData.sys.mjs"
+);
+
+add_task(async function test_sessionData() {
+  const sessionData = new SessionData(new RootMessageHandler("session-id-1"));
+  equal(sessionData.getSessionData("mod", "event").length, 0);
+
+  const globalContext = {
+    type: ContextDescriptorType.All,
+  };
+  const otherContext = { type: "other-type", id: "some-id" };
+
+  info("Add a first event for the global context");
+  let updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, globalContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Add, "One item added");
+  let updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value added");
+  equal(updatedValues[0], "first.event", "Expected value was added");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: globalContext,
+    },
+  ]);
+
+  info("Add the exact same data (same module, type, context, value)");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, globalContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 0, "No new item updated");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: globalContext,
+    },
+  ]);
+
+  info("Add another context for the same event");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, otherContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Add, "One item added");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value added");
+  equal(updatedValues[0], "first.event", "Expected value was added");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: globalContext,
+    },
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+  ]);
+
+  info("Add a second event for the global context");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, globalContext, ["second.event"]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Add, "One item added");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value added");
+  equal(updatedValues[0], "second.event", "Expected value was added");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: globalContext,
+    },
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+    {
+      value: "second.event",
+      contextDescriptor: globalContext,
+    },
+  ]);
+
+  info("Add two events for the global context");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, globalContext, [
+      "third.event",
+      "fourth.event",
+    ]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Add, "One item added");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 2, "Two values added");
+  equal(updatedValues[0], "third.event", "Expected value was added");
+  equal(updatedValues[1], "fourth.event", "Expected value was added");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: globalContext,
+    },
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+    {
+      value: "second.event",
+      contextDescriptor: globalContext,
+    },
+    {
+      value: "third.event",
+      contextDescriptor: globalContext,
+    },
+    {
+      value: "fourth.event",
+      contextDescriptor: globalContext,
+    },
+  ]);
+
+  info("Remove the second, third and fourth events");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Remove, globalContext, [
+      "second.event",
+      "third.event",
+      "fourth.event",
+    ]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Remove, "One item removed");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 3, "Three values removed");
+  equal(updatedValues[0], "second.event", "Expected value was removed");
+  equal(updatedValues[1], "third.event", "Expected value was removed");
+  equal(updatedValues[2], "fourth.event", "Expected value was removed");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: globalContext,
+    },
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+  ]);
+
+  info("Remove the global context from the first event");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Remove, globalContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Remove, "One item removed");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value removed");
+  equal(updatedValues[0], "first.event", "Expected value was removed");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+  ]);
+
+  info("Remove the other context from the first event");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Remove, otherContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Remove, "One item removed");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value removed");
+  equal(updatedValues[0], "first.event", "Expected value was removed");
+  checkEvents(sessionData.getSessionData("mod", "event"), []);
+
+  info("Add two events for different contexts");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, otherContext, ["first.event"]),
+    createUpdate(SessionDataMethod.Add, globalContext, ["second.event"]),
+  ]);
+  equal(updatedItems.length, 2, "Two items updated");
+  equal(updatedItems[0].method, SessionDataMethod.Add, "First item added");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value for first item added");
+  equal(updatedValues[0], "first.event", "Expected value first item was added");
+  equal(updatedItems[1].method, SessionDataMethod.Add, "Second item added");
+  updatedValues = updatedItems[1].values;
+  equal(updatedValues.length, 1, "One value for second item added");
+  equal(
+    updatedValues[0],
+    "second.event",
+    "Expected value second item was added"
+  );
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+    {
+      value: "second.event",
+      contextDescriptor: globalContext,
+    },
+  ]);
+
+  info("Remove two events for different contexts");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Remove, otherContext, ["first.event"]),
+    createUpdate(SessionDataMethod.Remove, globalContext, ["second.event"]),
+  ]);
+  equal(updatedItems.length, 2, "Two items updated");
+  equal(updatedItems[0].method, SessionDataMethod.Remove, "First item removed");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value for first item removed");
+  equal(
+    updatedValues[0],
+    "first.event",
+    "Expected value first item was removed"
+  );
+  equal(
+    updatedItems[1].method,
+    SessionDataMethod.Remove,
+    "Second item removed"
+  );
+  updatedValues = updatedItems[1].values;
+  equal(updatedValues.length, 1, "One value for second item removed");
+  equal(
+    updatedValues[0],
+    "second.event",
+    "Expected value second item was removed"
+  );
+  checkEvents(sessionData.getSessionData("mod", "event"), []);
+
+  info("Add and remove event in different order");
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Remove, otherContext, ["first.event"]),
+    createUpdate(SessionDataMethod.Add, otherContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 1, "One item updated");
+  equal(updatedItems[0].method, SessionDataMethod.Add, "One item added");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value added");
+  equal(updatedValues[0], "first.event", "Expected value was added");
+  checkEvents(sessionData.getSessionData("mod", "event"), [
+    {
+      value: "first.event",
+      contextDescriptor: otherContext,
+    },
+  ]);
+
+  updatedItems = sessionData.applySessionData([
+    createUpdate(SessionDataMethod.Add, otherContext, ["first.event"]),
+    createUpdate(SessionDataMethod.Remove, otherContext, ["first.event"]),
+  ]);
+  equal(updatedItems.length, 1, "No item update");
+  equal(updatedItems[0].method, SessionDataMethod.Remove, "One item removed");
+  updatedValues = updatedItems[0].values;
+  equal(updatedValues.length, 1, "One value removed");
+  equal(updatedValues[0], "first.event", "Expected value was removed");
+  checkEvents(sessionData.getSessionData("mod", "event"), []);
+});
+
+function checkEvents(events, expectedEvents) {
+  // Check the arrays have the same size.
+  equal(events.length, expectedEvents.length);
+
+  // Check all the expectedEvents can be found in the events array.
+  for (const expected of expectedEvents) {
+    ok(
+      events.some(
+        event =>
+          expected.contextDescriptor.type === event.contextDescriptor.type &&
+          expected.contextDescriptor.id === event.contextDescriptor.id &&
+          expected.value == event.value
+      )
+    );
+  }
+}
+
+function createUpdate(method, contextDescriptor, values) {
+  return {
+    method,
+    moduleName: "mod",
+    category: "event",
+    contextDescriptor,
+    values,
+  };
+}
diff --git a/remote/shared/messagehandler/test/xpcshell/xpcshell.ini b/remote/shared/messagehandler/test/xpcshell/xpcshell.ini
new file mode 100644
index 0000000000..9199459e0a
--- /dev/null
+++ b/remote/shared/messagehandler/test/xpcshell/xpcshell.ini
@@ -0,0 +1,6 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+[test_Errors.js]
+[test_SessionData.js]
diff --git a/remote/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs b/remote/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs
new file mode 100644
index 0000000000..482f90948a
--- /dev/null
+++ b/remote/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs
@@ -0,0 +1,57 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+function isExtensionContext(browsingContext) {
+  let principal;
+  if (CanonicalBrowsingContext.isInstance(browsingContext)) {
+    principal = browsingContext.currentWindowGlobal.documentPrincipal;
+  } else {
+    principal = browsingContext.window.document.nodePrincipal;
+  }
+
+  // In practice, note that the principal will never be an expanded principal.
+  // The are only used for content scripts executed in a Sandbox, and do not
+  // have a browsing context on their own.
+  // But we still use this flag because there is no isAddonPrincipal flag.
+  return principal.isAddonOrExpandedAddonPrincipal;
+}
+
+function isParentProcess(browsingContext) {
+  if (CanonicalBrowsingContext.isInstance(browsingContext)) {
+    return browsingContext.currentWindowGlobal.osPid === -1;
+  }
+
+  // If `browsingContext` is not a `CanonicalBrowsingContext`, then we are
+  // necessarily in a content process page.
+  return false;
+}
+
+/**
+ * Check if the given browsing context is valid for the message handler
+ * to use.
+ *
+ * @param {BrowsingContext} browsingContext
+ *     The browsing context to check.
+ * @param {object=} options
+ * @param {string=} options.browserId
+ *    The id of the browser to filter the browsing contexts by (optional).
+ * @returns {boolean}
+ *     True if the browsing context is valid, false otherwise.
+ */
+export function isBrowsingContextCompatible(browsingContext, options = {}) {
+  const { browserId } = options;
+
+  // If a browserId was provided, skip browsing contexts which are not
+  // associated with this browserId.
+  if (browserId !== undefined && browsingContext.browserId !== browserId) {
+    return false;
+  }
+
+  // Skip:
+  // - extension contexts until we support debugging webextensions, see Bug 1755014.
+  // - privileged contexts until we support debugging Chrome context, see Bug 1713440.
+  return (
+    !isExtensionContext(browsingContext) && !isParentProcess(browsingContext)
+  );
+}
diff --git a/remote/shared/messagehandler/transports/RootTransport.sys.mjs b/remote/shared/messagehandler/transports/RootTransport.sys.mjs
new file mode 100644
index 0000000000..2fb206ab93
--- /dev/null
+++ b/remote/shared/messagehandler/transports/RootTransport.sys.mjs
@@ -0,0 +1,190 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ContextDescriptorType:
+    "chrome://remote/content/shared/messagehandler/MessageHandler.sys.mjs",
+  isBrowsingContextCompatible:
+    "chrome://remote/content/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  MessageHandlerFrameActor:
+    "chrome://remote/content/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameActor.sys.mjs",
+  TabManager: "chrome://remote/content/shared/TabManager.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+const MAX_RETRY_ATTEMPTS = 10;
+
+/**
+ * RootTransport is intended to be used from a ROOT MessageHandler to communicate
+ * with WINDOW_GLOBAL MessageHandlers via the MessageHandlerFrame JSWindow
+ * actors.
+ */
+export class RootTransport {
+  /**
+   * @param {MessageHandler} messageHandler
+   *     The MessageHandler instance which owns this RootTransport instance.
+   */
+  constructor(messageHandler) {
+    this._messageHandler = messageHandler;
+
+    // RootTransport will rely on the MessageHandlerFrame JSWindow actors.
+    // Make sure they are registered when instanciating a RootTransport.
+    lazy.MessageHandlerFrameActor.register();
+  }
+
+  /**
+   * Forward the provided command to WINDOW_GLOBAL MessageHandlers via the
+   * MessageHandlerFrame actors.
+   *
+   * @param {Command} command
+   *     The command to forward. See type definition in MessageHandler.js
+   * @returns {Promise}
+   *     Returns a promise that resolves with the result of the command after
+   *     being processed by WINDOW_GLOBAL MessageHandlers.
+   */
+  forwardCommand(command) {
+    if (command.destination.id && command.destination.contextDescriptor) {
+      throw new Error(
+        "Invalid command destination with both 'id' and 'contextDescriptor' properties"
+      );
+    }
+
+    // With an id given forward the command to only this specific destination.
+    if (command.destination.id) {
+      const browsingContext = BrowsingContext.get(command.destination.id);
+      if (!browsingContext) {
+        throw new Error(
+          "Unable to find a BrowsingContext for id " + command.destination.id
+        );
+      }
+      return this._sendCommandToBrowsingContext(command, browsingContext);
+    }
+
+    // ... otherwise broadcast to destinations matching the contextDescriptor.
+    if (command.destination.contextDescriptor) {
+      return this._broadcastCommand(command);
+    }
+
+    throw new Error(
+      "Unrecognized command destination, missing 'id' or 'contextDescriptor' properties"
+    );
+  }
+
+  _broadcastCommand(command) {
+    const { contextDescriptor } = command.destination;
+    const browsingContexts =
+      this._getBrowsingContextsForDescriptor(contextDescriptor);
+
+    return Promise.all(
+      browsingContexts.map(async browsingContext => {
+        try {
+          return await this._sendCommandToBrowsingContext(
+            command,
+            browsingContext
+          );
+        } catch (e) {
+          console.error(
+            `Failed to broadcast a command to browsingContext ${browsingContext.id}`,
+            e
+          );
+          return null;
+        }
+      })
+    );
+  }
+
+  async _sendCommandToBrowsingContext(command, browsingContext) {
+    const name = `${command.moduleName}.${command.commandName}`;
+
+    // The browsing context might be destroyed by a navigation. Keep a reference
+    // to the webProgress, which will persist, and always use it to retrieve the
+    // currently valid browsing context.
+    const webProgress = browsingContext.webProgress;
+
+    const { retryOnAbort = false } = command;
+
+    let attempts = 0;
+    while (true) {
+      try {
+        return await webProgress.browsingContext.currentWindowGlobal
+          .getActor("MessageHandlerFrame")
+          .sendCommand(command, this._messageHandler.sessionId);
+      } catch (e) {
+        if (!retryOnAbort || e.name != "AbortError") {
+          // Only retry if the command supports retryOnAbort and when the
+          // JSWindowActor pair gets destroyed.
+          throw e;
+        }
+
+        if (++attempts > MAX_RETRY_ATTEMPTS) {
+          lazy.logger.trace(
+            `RootTransport reached the limit of retry attempts (${MAX_RETRY_ATTEMPTS})` +
+              ` for command ${name} and browsing context ${webProgress.browsingContext.id}.`
+          );
+          throw e;
+        }
+
+        lazy.logger.trace(
+          `RootTransport retrying command ${name} for ` +
+            `browsing context ${webProgress.browsingContext.id}, attempt: ${attempts}.`
+        );
+        await new Promise(resolve => Services.tm.dispatchToMainThread(resolve));
+      }
+    }
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} ${this._messageHandler.name}]`;
+  }
+
+  _getBrowsingContextsForDescriptor(contextDescriptor) {
+    const { id, type } = contextDescriptor;
+
+    if (type === lazy.ContextDescriptorType.All) {
+      return this._getBrowsingContexts();
+    }
+
+    if (type === lazy.ContextDescriptorType.TopBrowsingContext) {
+      return this._getBrowsingContexts({ browserId: id });
+    }
+
+    // TODO: Handle other types of context descriptors.
+    throw new Error(
+      `Unsupported contextDescriptor type for broadcasting: ${type}`
+    );
+  }
+
+  /**
+   * Get all browsing contexts, optionally matching the provided options.
+   *
+   * @param {object} options
+   * @param {string=} options.browserId
+   *    The id of the browser to filter the browsing contexts by (optional).
+   * @returns {Array<BrowsingContext>}
+   *    The browsing contexts matching the provided options or all browsing contexts
+   *    if no options are provided.
+   */
+  _getBrowsingContexts(options = {}) {
+    // extract browserId from options
+    const { browserId } = options;
+    let browsingContexts = [];
+
+    // Fetch all tab related browsing contexts for top-level windows.
+    for (const { browsingContext } of lazy.TabManager.browsers) {
+      if (lazy.isBrowsingContextCompatible(browsingContext, { browserId })) {
+        browsingContexts = browsingContexts.concat(
+          browsingContext.getAllBrowsingContextsInSubtree()
+        );
+      }
+    }
+
+    return browsingContexts;
+  }
+}
diff --git a/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameActor.sys.mjs b/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameActor.sys.mjs
new file mode 100644
index 0000000000..e516e92614
--- /dev/null
+++ b/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameActor.sys.mjs
@@ -0,0 +1,53 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  ActorManagerParent: "resource://gre/modules/ActorManagerParent.sys.mjs",
+
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+const FRAME_ACTOR_CONFIG = {
+  parent: {
+    esModuleURI:
+      "chrome://remote/content/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameParent.sys.mjs",
+  },
+  child: {
+    esModuleURI:
+      "chrome://remote/content/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameChild.sys.mjs",
+    events: {
+      DOMWindowCreated: {},
+      pagehide: {},
+      pageshow: {},
+    },
+  },
+  allFrames: true,
+  messageManagerGroups: ["browsers"],
+};
+
+/**
+ * MessageHandlerFrameActor exposes a simple registration helper to lazily
+ * register MessageHandlerFrame JSWindow actors.
+ */
+export const MessageHandlerFrameActor = {
+  registered: false,
+
+  register() {
+    if (this.registered) {
+      return;
+    }
+
+    lazy.ActorManagerParent.addJSWindowActors({
+      MessageHandlerFrame: FRAME_ACTOR_CONFIG,
+    });
+    this.registered = true;
+    lazy.logger.trace("Registered MessageHandlerFrame actors");
+  },
+};
diff --git a/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameChild.sys.mjs b/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameChild.sys.mjs
new file mode 100644
index 0000000000..52a8fdc4c9
--- /dev/null
+++ b/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameChild.sys.mjs
@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  isBrowsingContextCompatible:
+    "chrome://remote/content/shared/messagehandler/transports/BrowsingContextUtils.sys.mjs",
+  MessageHandlerRegistry:
+    "chrome://remote/content/shared/messagehandler/MessageHandlerRegistry.sys.mjs",
+  WindowGlobalMessageHandler:
+    "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
+});
+
+/**
+ * Map from MessageHandlerRegistry to MessageHandlerFrameChild actor. This will
+ * allow a WindowGlobalMessageHandler to find the JSWindowActorChild instance to
+ * use to send commands.
+ */
+const registryToActor = new WeakMap();
+
+/**
+ * Retrieve the MessageHandlerFrameChild which is linked to the provided
+ * WindowGlobalMessageHandler instance.
+ *
+ * @param {WindowGlobalMessageHandler} messageHandler
+ *     The WindowGlobalMessageHandler for which to get the JSWindowActor.
+ * @returns {MessageHandlerFrameChild}
+ *     The corresponding MessageHandlerFrameChild instance.
+ */
+export function getMessageHandlerFrameChildActor(messageHandler) {
+  return registryToActor.get(messageHandler.registry);
+}
+
+/**
+ * Child actor for the MessageHandlerFrame JSWindowActor. The
+ * MessageHandlerFrame actor is used by RootTransport to communicate between
+ * ROOT MessageHandlers and WINDOW_GLOBAL MessageHandlers.
+ */
+export class MessageHandlerFrameChild extends JSWindowActorChild {
+  actorCreated() {
+    this.type = lazy.WindowGlobalMessageHandler.type;
+    this.context = this.manager.browsingContext;
+
+    this._registry = new lazy.MessageHandlerRegistry(this.type, this.context);
+    registryToActor.set(this._registry, this);
+
+    this._onRegistryEvent = this._onRegistryEvent.bind(this);
+
+    // MessageHandlerFrameChild is responsible for forwarding events from
+    // WindowGlobalMessageHandler to the parent process.
+    // Such events are re-emitted on the MessageHandlerRegistry to avoid
+    // setting up listeners on individual MessageHandler instances.
+    this._registry.on("message-handler-registry-event", this._onRegistryEvent);
+  }
+
+  handleEvent({ persisted, type }) {
+    if (type == "DOMWindowCreated" || (type == "pageshow" && persisted)) {
+      // When the window is created or is retrieved from BFCache, instantiate
+      // a MessageHandler for all sessions which might need it.
+      if (lazy.isBrowsingContextCompatible(this.manager.browsingContext)) {
+        this._registry.createAllMessageHandlers();
+      }
+    } else if (type == "pagehide" && persisted) {
+      // When the page is moved to BFCache, all the currently created message
+      // handlers should be destroyed.
+      this._registry.destroy();
+    }
+  }
+
+  async receiveMessage(message) {
+    if (message.name === "MessageHandlerFrameParent:sendCommand") {
+      const { sessionId, command } = message.data;
+      const messageHandler =
+        this._registry.getOrCreateMessageHandler(sessionId);
+      try {
+        return await messageHandler.handleCommand(command);
+      } catch (e) {
+        if (e?.isRemoteError) {
+          return {
+            error: e.toJSON(),
+            isMessageHandlerError: e.isMessageHandlerError,
+          };
+        }
+        throw e;
+      }
+    }
+
+    return null;
+  }
+
+  sendCommand(command, sessionId) {
+    return this.sendQuery("MessageHandlerFrameChild:sendCommand", {
+      command,
+      sessionId,
+    });
+  }
+
+  _onRegistryEvent(eventName, wrappedEvent) {
+    this.sendAsyncMessage(
+      "MessageHandlerFrameChild:messageHandlerEvent",
+      wrappedEvent
+    );
+  }
+
+  didDestroy() {
+    this._registry.off("message-handler-registry-event", this._onRegistryEvent);
+    this._registry.destroy();
+  }
+}
diff --git a/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameParent.sys.mjs b/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameParent.sys.mjs
new file mode 100644
index 0000000000..f845b2fa01
--- /dev/null
+++ b/remote/shared/messagehandler/transports/js-window-actors/MessageHandlerFrameParent.sys.mjs
@@ -0,0 +1,120 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  error: "chrome://remote/content/shared/messagehandler/Errors.sys.mjs",
+  RootMessageHandlerRegistry:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs",
+  WindowGlobalMessageHandler:
+    "chrome://remote/content/shared/messagehandler/WindowGlobalMessageHandler.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "WebDriverError", () => {
+  return ChromeUtils.importESModule(
+    "chrome://remote/content/shared/webdriver/Errors.sys.mjs"
+  ).error.WebDriverError;
+});
+
+/**
+ * Parent actor for the MessageHandlerFrame JSWindowActor. The
+ * MessageHandlerFrame actor is used by RootTransport to communicate between
+ * ROOT MessageHandlers and WINDOW_GLOBAL MessageHandlers.
+ */
+export class MessageHandlerFrameParent extends JSWindowActorParent {
+  async receiveMessage(message) {
+    switch (message.name) {
+      case "MessageHandlerFrameChild:sendCommand": {
+        return this.#handleSendCommandMessage(message.data);
+      }
+      case "MessageHandlerFrameChild:messageHandlerEvent": {
+        return this.#handleMessageHandlerEventMessage(message.data);
+      }
+      default:
+        throw new Error("Unsupported message:" + message.name);
+    }
+  }
+
+  /**
+   * Send a command to the corresponding MessageHandlerFrameChild actor via a
+   * JSWindowActor query.
+   *
+   * @param {Command} command
+   *     The command to forward. See type definition in MessageHandler.js
+   * @param {string} sessionId
+   *     ID of the session that sent the command.
+   * @returns {Promise}
+   *     Promise that will resolve with the result of query sent to the
+   *     MessageHandlerFrameChild actor.
+   */
+  async sendCommand(command, sessionId) {
+    const result = await this.sendQuery(
+      "MessageHandlerFrameParent:sendCommand",
+      {
+        command,
+        sessionId,
+      }
+    );
+
+    if (result?.error) {
+      if (result.isMessageHandlerError) {
+        throw lazy.error.MessageHandlerError.fromJSON(result.error);
+      }
+
+      // TODO: Do not assume WebDriver is the session protocol, see Bug 1779026.
+      throw lazy.WebDriverError.fromJSON(result.error);
+    }
+
+    return result;
+  }
+
+  async #handleMessageHandlerEventMessage(messageData) {
+    const { name, contextInfo, data, sessionId } = messageData;
+    const [moduleName] = name.split(".");
+
+    // Re-emit the event on the RootMessageHandler.
+    const messageHandler =
+      lazy.RootMessageHandlerRegistry.getExistingMessageHandler(sessionId);
+    // TODO: getModuleInstance expects a CommandDestination in theory,
+    // but only uses the MessageHandler type in practice, see Bug 1776389.
+    const module = messageHandler.moduleCache.getModuleInstance(moduleName, {
+      type: lazy.WindowGlobalMessageHandler.type,
+    });
+    let eventPayload = data;
+
+    // Modify an event payload if there is a special method in the targeted module.
+    // If present it can be found in windowglobal-in-root module.
+    if (module?.interceptEvent) {
+      eventPayload = await module.interceptEvent(name, data);
+
+      // Make sure that an event payload is returned.
+      if (!eventPayload) {
+        throw new Error(
+          `${moduleName}.interceptEvent doesn't return the event payload`
+        );
+      }
+    }
+    messageHandler.emitEvent(name, eventPayload, contextInfo);
+  }
+
+  async #handleSendCommandMessage(messageData) {
+    const { sessionId, command } = messageData;
+    const messageHandler =
+      lazy.RootMessageHandlerRegistry.getExistingMessageHandler(sessionId);
+    try {
+      return await messageHandler.handleCommand(command);
+    } catch (e) {
+      if (e?.isRemoteError) {
+        return {
+          error: e.toJSON(),
+          isMessageHandlerError: e.isMessageHandlerError,
+        };
+      }
+      throw e;
+    }
+  }
+}
diff --git a/remote/shared/moz.build b/remote/shared/moz.build
new file mode 100644
index 0000000000..56b1c2ff25
--- /dev/null
+++ b/remote/shared/moz.build
@@ -0,0 +1,17 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+BROWSER_CHROME_MANIFESTS += [
+    "listeners/test/browser/browser.ini",
+    "messagehandler/test/browser/broadcast/browser.ini",
+    "messagehandler/test/browser/browser.ini",
+    "messagehandler/test/browser/webdriver/browser.ini",
+    "test/browser/browser.ini",
+]
+
+XPCSHELL_TESTS_MANIFESTS += [
+    "messagehandler/test/xpcshell/xpcshell.ini",
+    "test/xpcshell/xpcshell.ini",
+    "webdriver/test/xpcshell/xpcshell.ini",
+]
diff --git a/remote/shared/test/browser/browser.ini b/remote/shared/test/browser/browser.ini
new file mode 100644
index 0000000000..af0889ca7f
--- /dev/null
+++ b/remote/shared/test/browser/browser.ini
@@ -0,0 +1,5 @@
+[DEFAULT]
+tags = remote
+subsuite = remote
+
+[browser_TabManager.js]
diff --git a/remote/shared/test/browser/browser_TabManager.js b/remote/shared/test/browser/browser_TabManager.js
new file mode 100644
index 0000000000..9229d1762b
--- /dev/null
+++ b/remote/shared/test/browser/browser_TabManager.js
@@ -0,0 +1,148 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { TabManager } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/TabManager.sys.mjs"
+);
+
+const FRAME_URL = "https://example.com/document-builder.sjs?html=frame";
+const FRAME_MARKUP = `<iframe src="${encodeURI(FRAME_URL)}"></iframe>`;
+const TEST_URL = `https://example.com/document-builder.sjs?html=${encodeURI(
+  FRAME_MARKUP
+)}`;
+
+add_task(async function test_getBrowsingContextById() {
+  const browser = gBrowser.selectedBrowser;
+
+  is(TabManager.getBrowsingContextById(null), null);
+  is(TabManager.getBrowsingContextById(undefined), null);
+  is(TabManager.getBrowsingContextById("wrong-id"), null);
+
+  info(`Navigate to ${TEST_URL}`);
+  const loaded = BrowserTestUtils.browserLoaded(browser);
+  BrowserTestUtils.loadURIString(browser, TEST_URL);
+  await loaded;
+
+  const contexts = browser.browsingContext.getAllBrowsingContextsInSubtree();
+  is(contexts.length, 2, "Top context has 1 child");
+
+  const topContextId = TabManager.getIdForBrowsingContext(contexts[0]);
+  is(TabManager.getBrowsingContextById(topContextId), contexts[0]);
+  const childContextId = TabManager.getIdForBrowsingContext(contexts[1]);
+  is(TabManager.getBrowsingContextById(childContextId), contexts[1]);
+});
+
+add_task(async function test_addTab_focus() {
+  let tabsCount = gBrowser.tabs.length;
+
+  let newTab1, newTab2, newTab3;
+  try {
+    newTab1 = await TabManager.addTab({ focus: true });
+
+    ok(gBrowser.tabs.includes(newTab1), "A new tab was created");
+    is(gBrowser.tabs.length, tabsCount + 1);
+    is(gBrowser.selectedTab, newTab1, "Tab added with focus: true is selected");
+
+    newTab2 = await TabManager.addTab({ focus: false });
+
+    ok(gBrowser.tabs.includes(newTab2), "A new tab was created");
+    is(gBrowser.tabs.length, tabsCount + 2);
+    is(
+      gBrowser.selectedTab,
+      newTab1,
+      "Tab added with focus: false is not selected"
+    );
+
+    newTab3 = await TabManager.addTab();
+
+    ok(gBrowser.tabs.includes(newTab3), "A new tab was created");
+    is(gBrowser.tabs.length, tabsCount + 3);
+    is(
+      gBrowser.selectedTab,
+      newTab1,
+      "Tab added with no focus parameter is not selected (defaults to false)"
+    );
+  } finally {
+    gBrowser.removeTab(newTab1);
+    gBrowser.removeTab(newTab2);
+    gBrowser.removeTab(newTab3);
+  }
+});
+
+add_task(async function test_addTab_referenceTab() {
+  let tab1, tab2, tab3, tab4;
+  try {
+    tab1 = await TabManager.addTab();
+    // Add a second tab with no referenceTab, should be added at the end.
+    tab2 = await TabManager.addTab();
+    // Add a third tab with tab1 as referenceTab, should be added right after tab1.
+    tab3 = await TabManager.addTab({ referenceTab: tab1 });
+    // Add a fourth tab with tab2 as referenceTab, should be added right after tab2.
+    tab4 = await TabManager.addTab({ referenceTab: tab2 });
+
+    // Check that the tab order is as expected: tab1 > tab3 > tab2 > tab4
+    const tab1Index = gBrowser.tabs.indexOf(tab1);
+    is(gBrowser.tabs[tab1Index + 1], tab3);
+    is(gBrowser.tabs[tab1Index + 2], tab2);
+    is(gBrowser.tabs[tab1Index + 3], tab4);
+  } finally {
+    gBrowser.removeTab(tab1);
+    gBrowser.removeTab(tab2);
+    gBrowser.removeTab(tab3);
+    gBrowser.removeTab(tab4);
+  }
+});
+
+add_task(async function test_addTab_window() {
+  const win1 = await BrowserTestUtils.openNewBrowserWindow();
+  const win2 = await BrowserTestUtils.openNewBrowserWindow();
+  try {
+    // openNewBrowserWindow should ensure the new window is focused.
+    is(Services.wm.getMostRecentBrowserWindow(null), win2);
+
+    const newTab1 = await TabManager.addTab({ window: win1 });
+    is(
+      newTab1.ownerGlobal,
+      win1,
+      "The new tab was opened in the specified window"
+    );
+
+    const newTab2 = await TabManager.addTab({ window: win2 });
+    is(
+      newTab2.ownerGlobal,
+      win2,
+      "The new tab was opened in the specified window"
+    );
+
+    const newTab3 = await TabManager.addTab();
+    is(
+      newTab3.ownerGlobal,
+      win2,
+      "The new tab was opened in the foreground window"
+    );
+  } finally {
+    await BrowserTestUtils.closeWindow(win1);
+    await BrowserTestUtils.closeWindow(win2);
+  }
+});
+
+add_task(async function test_getTabForBrowsingContext() {
+  const tab = await TabManager.addTab();
+  try {
+    const browser = tab.linkedBrowser;
+
+    info(`Navigate to ${TEST_URL}`);
+    const loaded = BrowserTestUtils.browserLoaded(browser);
+    BrowserTestUtils.loadURIString(browser, TEST_URL);
+    await loaded;
+
+    const contexts = browser.browsingContext.getAllBrowsingContextsInSubtree();
+    is(TabManager.getTabForBrowsingContext(contexts[0]), tab);
+    is(TabManager.getTabForBrowsingContext(contexts[1]), tab);
+    is(TabManager.getTabForBrowsingContext(null), null);
+  } finally {
+    gBrowser.removeTab(tab);
+  }
+});
diff --git a/remote/shared/test/xpcshell/test_AppInfo.js b/remote/shared/test/xpcshell/test_AppInfo.js
new file mode 100644
index 0000000000..a83983aea4
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_AppInfo.js
@@ -0,0 +1,32 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const { AppInfo } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/AppInfo.sys.mjs"
+);
+
+// Minimal xpcshell tests for AppInfo; Services.appinfo.* is not available
+
+add_task(function test_custom_properties() {
+  const properties = [
+    // platforms
+    "isAndroid",
+    "isLinux",
+    "isMac",
+    "isWindows",
+    // applications
+    "isFirefox",
+    "isThunderbird",
+  ];
+
+  for (const prop of properties) {
+    equal(
+      typeof AppInfo[prop],
+      "boolean",
+      `Custom property ${prop} has expected type`
+    );
+  }
+});
diff --git a/remote/shared/test/xpcshell/test_Format.js b/remote/shared/test/xpcshell/test_Format.js
new file mode 100644
index 0000000000..cfdd35be08
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_Format.js
@@ -0,0 +1,108 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { truncate, pprint } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/Format.sys.mjs"
+);
+
+const MAX_STRING_LENGTH = 250;
+const HALF = "x".repeat(MAX_STRING_LENGTH / 2);
+
+add_task(function test_pprint() {
+  equal('[object Object] {"foo":"bar"}', pprint`${{ foo: "bar" }}`);
+
+  equal("[object Number] 42", pprint`${42}`);
+  equal("[object Boolean] true", pprint`${true}`);
+  equal("[object Undefined] undefined", pprint`${undefined}`);
+  equal("[object Null] null", pprint`${null}`);
+
+  let complexObj = { toJSON: () => "foo" };
+  equal('[object Object] "foo"', pprint`${complexObj}`);
+
+  let cyclic = {};
+  cyclic.me = cyclic;
+  equal("[object Object] <cyclic object value>", pprint`${cyclic}`);
+
+  let el = {
+    hasAttribute: attr => attr in el,
+    getAttribute: attr => (attr in el ? el[attr] : null),
+    nodeType: 1,
+    localName: "input",
+    id: "foo",
+    class: "a b",
+    href: "#",
+    name: "bar",
+    src: "s",
+    type: "t",
+  };
+  equal(
+    '<input id="foo" class="a b" href="#" name="bar" src="s" type="t">',
+    pprint`${el}`
+  );
+});
+
+add_task(function test_truncate_empty() {
+  equal(truncate``, "");
+});
+
+add_task(function test_truncate_noFields() {
+  equal(truncate`foo bar`, "foo bar");
+});
+
+add_task(function test_truncate_multipleFields() {
+  equal(truncate`${0}`, "0");
+  equal(truncate`${1}${2}${3}`, "123");
+  equal(truncate`a${1}b${2}c${3}`, "a1b2c3");
+});
+
+add_task(function test_truncate_primitiveFields() {
+  equal(truncate`${123}`, "123");
+  equal(truncate`${true}`, "true");
+  equal(truncate`${null}`, "");
+  equal(truncate`${undefined}`, "");
+});
+
+add_task(function test_truncate_string() {
+  equal(truncate`${"foo"}`, "foo");
+  equal(truncate`${"x".repeat(250)}`, "x".repeat(250));
+  equal(truncate`${"x".repeat(260)}`, `${HALF} ... ${HALF}`);
+});
+
+add_task(function test_truncate_array() {
+  equal(truncate`${["foo"]}`, JSON.stringify(["foo"]));
+  equal(truncate`${"foo"} ${["bar"]}`, `foo ${JSON.stringify(["bar"])}`);
+  equal(
+    truncate`${["x".repeat(260)]}`,
+    JSON.stringify([`${HALF} ... ${HALF}`])
+  );
+});
+
+add_task(function test_truncate_object() {
+  equal(truncate`${{}}`, JSON.stringify({}));
+  equal(truncate`${{ foo: "bar" }}`, JSON.stringify({ foo: "bar" }));
+  equal(
+    truncate`${{ foo: "x".repeat(260) }}`,
+    JSON.stringify({ foo: `${HALF} ... ${HALF}` })
+  );
+  equal(truncate`${{ foo: ["bar"] }}`, JSON.stringify({ foo: ["bar"] }));
+  equal(
+    truncate`${{ foo: ["bar", { baz: 42 }] }}`,
+    JSON.stringify({ foo: ["bar", { baz: 42 }] })
+  );
+
+  let complex = {
+    toString() {
+      return "hello world";
+    },
+  };
+  equal(truncate`${complex}`, "hello world");
+
+  let longComplex = {
+    toString() {
+      return "x".repeat(260);
+    },
+  };
+  equal(truncate`${longComplex}`, `${HALF} ... ${HALF}`);
+});
diff --git a/remote/shared/test/xpcshell/test_Navigate.js b/remote/shared/test/xpcshell/test_Navigate.js
new file mode 100644
index 0000000000..e41508189a
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_Navigate.js
@@ -0,0 +1,879 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { setTimeout } = ChromeUtils.importESModule(
+  "resource://gre/modules/Timer.sys.mjs"
+);
+
+const {
+  DEFAULT_UNLOAD_TIMEOUT,
+  getUnloadTimeoutMultiplier,
+  ProgressListener,
+  waitForInitialNavigationCompleted,
+} = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/Navigate.sys.mjs"
+);
+
+const CURRENT_URI = Services.io.newURI("http://foo.bar/");
+const INITIAL_URI = Services.io.newURI("about:blank");
+const TARGET_URI = Services.io.newURI("http://foo.cheese/");
+const TARGET_URI_IS_ERROR_PAGE = Services.io.newURI("doesnotexist://");
+const TARGET_URI_WITH_HASH = Services.io.newURI("http://foo.cheese/#foo");
+
+function wait(time) {
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  return new Promise(resolve => setTimeout(resolve, time));
+}
+
+class MockRequest {
+  constructor(uri) {
+    this.originalURI = uri;
+  }
+
+  get QueryInterface() {
+    return ChromeUtils.generateQI(["nsIRequest", "nsIChannel"]);
+  }
+}
+
+class MockWebProgress {
+  constructor(browsingContext) {
+    this.browsingContext = browsingContext;
+
+    this.documentRequest = null;
+    this.isLoadingDocument = false;
+    this.listener = null;
+    this.progressListenerRemoved = false;
+  }
+
+  addProgressListener(listener) {
+    if (this.listener) {
+      throw new Error("Cannot register listener twice");
+    }
+
+    this.listener = listener;
+  }
+
+  removeProgressListener(listener) {
+    if (listener === this.listener) {
+      this.listener = null;
+      this.progressListenerRemoved = true;
+    } else {
+      throw new Error("Unknown listener");
+    }
+  }
+
+  sendLocationChange(options = {}) {
+    const { flag = 0 } = options;
+
+    this.documentRequest = null;
+
+    if (flag & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT) {
+      this.browsingContext.currentURI = TARGET_URI_WITH_HASH;
+    } else if (flag & Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE) {
+      this.browsingContext.currentURI = TARGET_URI_IS_ERROR_PAGE;
+    }
+
+    this.listener?.onLocationChange(
+      this,
+      this.documentRequest,
+      TARGET_URI_WITH_HASH,
+      flag
+    );
+
+    return new Promise(executeSoon);
+  }
+
+  sendStartState(options = {}) {
+    const { coop = false, isInitial = false } = options;
+
+    if (coop) {
+      this.browsingContext = new MockTopContext(this);
+    }
+
+    if (!this.browsingContext.currentWindowGlobal) {
+      this.browsingContext.currentWindowGlobal = {};
+    }
+
+    this.browsingContext.currentWindowGlobal.isInitialDocument = isInitial;
+
+    this.isLoadingDocument = true;
+    const uri = isInitial ? INITIAL_URI : TARGET_URI;
+    this.documentRequest = new MockRequest(uri);
+
+    this.listener?.onStateChange(
+      this,
+      this.documentRequest,
+      Ci.nsIWebProgressListener.STATE_START,
+      null
+    );
+
+    return new Promise(executeSoon);
+  }
+
+  sendStopState(options = {}) {
+    const { errorFlag = 0 } = options;
+
+    this.browsingContext.currentURI = this.documentRequest.originalURI;
+
+    this.isLoadingDocument = false;
+    this.documentRequest = null;
+
+    this.listener?.onStateChange(
+      this,
+      this.documentRequest,
+      Ci.nsIWebProgressListener.STATE_STOP,
+      errorFlag
+    );
+
+    return new Promise(executeSoon);
+  }
+}
+
+class MockTopContext {
+  constructor(webProgress = null) {
+    this.currentURI = CURRENT_URI;
+    this.currentWindowGlobal = { isInitialDocument: true };
+    this.id = 7;
+    this.top = this;
+    this.webProgress = webProgress || new MockWebProgress(this);
+  }
+}
+
+const hasPromiseResolved = async function (promise) {
+  let resolved = false;
+  promise.finally(() => (resolved = true));
+  // Make sure microtasks have time to run.
+  await new Promise(resolve => Services.tm.dispatchToMainThread(resolve));
+  return resolved;
+};
+
+const hasPromiseRejected = async function (promise) {
+  let rejected = false;
+  promise.catch(() => (rejected = true));
+  // Make sure microtasks have time to run.
+  await new Promise(resolve => Services.tm.dispatchToMainThread(resolve));
+  return rejected;
+};
+
+add_task(
+  async function test_waitForInitialNavigation_initialDocumentNoWindowGlobal() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    // In some cases there might be no window global yet.
+    delete browsingContext.currentWindowGlobal;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+    await webProgress.sendStartState({ isInitial: true });
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await webProgress.sendStopState();
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is initial document"
+    );
+    equal(
+      currentURI.spec,
+      INITIAL_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, INITIAL_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_initialDocumentNotLoaded() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+
+    await webProgress.sendStartState({ isInitial: true });
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await webProgress.sendStopState();
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is initial document"
+    );
+    equal(
+      currentURI.spec,
+      INITIAL_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, INITIAL_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_initialDocumentLoadingAndNoAdditionalLoad() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    await webProgress.sendStartState({ isInitial: true });
+    ok(webProgress.isLoadingDocument, "Document is loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await webProgress.sendStopState();
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is initial document"
+    );
+    equal(
+      currentURI.spec,
+      INITIAL_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, INITIAL_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_initialDocumentFinishedLoadingNoAdditionalLoad() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    await webProgress.sendStartState({ isInitial: true });
+    await webProgress.sendStopState();
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is initial document"
+    );
+    equal(
+      currentURI.spec,
+      INITIAL_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, INITIAL_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_initialDocumentLoadingAndAdditionalLoad() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    await webProgress.sendStartState({ isInitial: true });
+
+    ok(webProgress.isLoadingDocument, "Document is loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await webProgress.sendStopState();
+
+    await wait(100);
+
+    await webProgress.sendStartState({ isInitial: false });
+    await webProgress.sendStopState();
+
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      !webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is not initial document"
+    );
+    equal(
+      currentURI.spec,
+      TARGET_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, TARGET_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_initialDocumentFinishedLoadingAndAdditionalLoad() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    await webProgress.sendStartState({ isInitial: true });
+    await webProgress.sendStopState();
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await wait(100);
+
+    await webProgress.sendStartState({ isInitial: false });
+    await webProgress.sendStopState();
+
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      !webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is not initial document"
+    );
+    equal(
+      currentURI.spec,
+      TARGET_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, TARGET_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_notInitialDocumentNotLoading() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+    await webProgress.sendStartState({ isInitial: false });
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await webProgress.sendStopState();
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      !browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is not initial document"
+    );
+    equal(
+      currentURI.spec,
+      TARGET_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, TARGET_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_notInitialDocumentAlreadyLoading() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    await webProgress.sendStartState({ isInitial: false });
+    ok(webProgress.isLoadingDocument, "Document is loading");
+
+    const navigated = waitForInitialNavigationCompleted(webProgress);
+
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "waitForInitialNavigationCompleted has not resolved yet"
+    );
+
+    await webProgress.sendStopState();
+    const { currentURI, targetURI } = await navigated;
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      !browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is not initial document"
+    );
+    equal(
+      currentURI.spec,
+      TARGET_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, TARGET_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(
+  async function test_waitForInitialNavigation_notInitialDocumentFinishedLoading() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    await webProgress.sendStartState({ isInitial: false });
+    await webProgress.sendStopState();
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+    const { currentURI, targetURI } = await waitForInitialNavigationCompleted(
+      webProgress
+    );
+
+    ok(!webProgress.isLoadingDocument, "Document is not loading");
+    ok(
+      !webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+      "Is not initial document"
+    );
+    equal(
+      currentURI.spec,
+      TARGET_URI.spec,
+      "Expected current URI has been set"
+    );
+    equal(targetURI.spec, TARGET_URI.spec, "Expected target URI has been set");
+  }
+);
+
+add_task(async function test_waitForInitialNavigation_resolveWhenStarted() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  await webProgress.sendStartState({ isInitial: true });
+  ok(webProgress.isLoadingDocument, "Document is already loading");
+
+  const { currentURI, targetURI } = await waitForInitialNavigationCompleted(
+    webProgress,
+    {
+      resolveWhenStarted: true,
+    }
+  );
+
+  ok(webProgress.isLoadingDocument, "Document is still loading");
+  ok(
+    webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+    "Is initial document"
+  );
+  equal(currentURI.spec, CURRENT_URI.spec, "Expected current URI has been set");
+  equal(targetURI.spec, INITIAL_URI.spec, "Expected target URI has been set");
+});
+
+add_task(async function test_waitForInitialNavigation_crossOrigin() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+  const navigated = waitForInitialNavigationCompleted(webProgress);
+  await webProgress.sendStartState({ coop: true });
+
+  ok(
+    !(await hasPromiseResolved(navigated)),
+    "waitForInitialNavigationCompleted has not resolved yet"
+  );
+
+  await webProgress.sendStopState();
+  const { currentURI, targetURI } = await navigated;
+
+  notEqual(
+    browsingContext,
+    webProgress.browsingContext,
+    "Got new browsing context"
+  );
+  ok(!webProgress.isLoadingDocument, "Document is not loading");
+  ok(
+    !webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+    "Is not initial document"
+  );
+  equal(currentURI.spec, TARGET_URI.spec, "Expected current URI has been set");
+  equal(targetURI.spec, TARGET_URI.spec, "Expected target URI has been set");
+});
+
+add_task(async function test_waitForInitialNavigation_unloadTimeout_default() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  // Stop the navigation on an initial page which is not loading anymore.
+  // This situation happens with new tabs on Android, even though they are on
+  // the initial document, they will not start another navigation on their own.
+  await webProgress.sendStartState({ isInitial: true });
+  await webProgress.sendStopState();
+
+  ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+  const navigated = waitForInitialNavigationCompleted(webProgress);
+
+  // Start a timer longer than the timeout which will be used by
+  // waitForInitialNavigationCompleted, and check that navigated resolves first.
+  const waitForMoreThanDefaultTimeout = wait(
+    DEFAULT_UNLOAD_TIMEOUT * 1.5 * getUnloadTimeoutMultiplier()
+  );
+  await Promise.race([navigated, waitForMoreThanDefaultTimeout]);
+
+  ok(
+    await hasPromiseResolved(navigated),
+    "waitForInitialNavigationCompleted has resolved"
+  );
+
+  ok(!webProgress.isLoadingDocument, "Document is not loading");
+  ok(
+    webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+    "Document is still on the initial document"
+  );
+});
+
+add_task(async function test_waitForInitialNavigation_unloadTimeout_longer() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  // Stop the navigation on an initial page which is not loading anymore.
+  // This situation happens with new tabs on Android, even though they are on
+  // the initial document, they will not start another navigation on their own.
+  await webProgress.sendStartState({ isInitial: true });
+  await webProgress.sendStopState();
+
+  ok(!webProgress.isLoadingDocument, "Document is not loading");
+
+  const navigated = waitForInitialNavigationCompleted(webProgress, {
+    unloadTimeout: DEFAULT_UNLOAD_TIMEOUT * 3,
+  });
+
+  // Start a timer longer than the default timeout of the Navigate module.
+  // However here we used a custom timeout, so we expect that the navigation
+  // will not be done yet by the time this timer is done.
+  const waitForMoreThanDefaultTimeout = wait(
+    DEFAULT_UNLOAD_TIMEOUT * 1.5 * getUnloadTimeoutMultiplier()
+  );
+  await Promise.race([navigated, waitForMoreThanDefaultTimeout]);
+
+  // The promise should not have resolved because we didn't reached the custom
+  // timeout which is 3 times the default one.
+  ok(
+    !(await hasPromiseResolved(navigated)),
+    "waitForInitialNavigationCompleted has not resolved yet"
+  );
+
+  // The navigation should eventually resolve once we reach the custom timeout.
+  await navigated;
+
+  ok(!webProgress.isLoadingDocument, "Document is not loading");
+  ok(
+    webProgress.browsingContext.currentWindowGlobal.isInitialDocument,
+    "Document is still on the initial document"
+  );
+});
+
+add_task(async function test_ProgressListener_expectNavigation() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  const progressListener = new ProgressListener(webProgress, {
+    expectNavigation: true,
+    unloadTimeout: 10,
+  });
+  const navigated = progressListener.start();
+
+  // Wait for unloadTimeout to finish in case it started
+  await wait(30);
+
+  ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved yet");
+
+  await webProgress.sendStartState();
+  await webProgress.sendStopState();
+
+  ok(await hasPromiseResolved(navigated), "Listener has resolved");
+});
+
+add_task(
+  async function test_ProgressListener_expectNavigation_initialDocumentFinishedLoading() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    const progressListener = new ProgressListener(webProgress, {
+      expectNavigation: true,
+      unloadTimeout: 10,
+    });
+    const navigated = progressListener.start();
+
+    ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved yet");
+
+    await webProgress.sendStartState({ isInitial: true });
+    await webProgress.sendStopState();
+
+    // Wait for unloadTimeout to finish in case it started
+    await wait(30);
+
+    ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved yet");
+
+    await webProgress.sendStartState();
+    await webProgress.sendStopState();
+
+    ok(await hasPromiseResolved(navigated), "Listener has resolved");
+  }
+);
+
+add_task(async function test_ProgressListener_isStarted() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  const progressListener = new ProgressListener(webProgress);
+  ok(!progressListener.isStarted);
+
+  progressListener.start();
+  ok(progressListener.isStarted);
+
+  progressListener.stop();
+  ok(!progressListener.isStarted);
+});
+
+add_task(async function test_ProgressListener_notWaitForExplicitStart() {
+  // Create a webprogress and start it before creating the progress listener.
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+  await webProgress.sendStartState();
+
+  // Create the progress listener for a webprogress already in a navigation.
+  const progressListener = new ProgressListener(webProgress, {
+    waitForExplicitStart: false,
+  });
+  const navigated = progressListener.start();
+
+  // Send stop state to complete the initial navigation
+  await webProgress.sendStopState();
+  ok(
+    await hasPromiseResolved(navigated),
+    "Listener has resolved after initial navigation"
+  );
+});
+
+add_task(async function test_ProgressListener_waitForExplicitStart() {
+  // Create a webprogress and start it before creating the progress listener.
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+  await webProgress.sendStartState();
+
+  // Create the progress listener for a webprogress already in a navigation.
+  const progressListener = new ProgressListener(webProgress, {
+    waitForExplicitStart: true,
+  });
+  const navigated = progressListener.start();
+
+  // Send stop state to complete the initial navigation
+  await webProgress.sendStopState();
+  ok(
+    !(await hasPromiseResolved(navigated)),
+    "Listener has not resolved after initial navigation"
+  );
+
+  // Start a new navigation
+  await webProgress.sendStartState();
+  ok(
+    !(await hasPromiseResolved(navigated)),
+    "Listener has not resolved after starting new navigation"
+  );
+
+  // Finish the new navigation
+  await webProgress.sendStopState();
+  ok(
+    await hasPromiseResolved(navigated),
+    "Listener resolved after finishing the new navigation"
+  );
+});
+
+add_task(
+  async function test_ProgressListener_waitForExplicitStartAndResolveWhenStarted() {
+    // Create a webprogress and start it before creating the progress listener.
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+    await webProgress.sendStartState();
+
+    // Create the progress listener for a webprogress already in a navigation.
+    const progressListener = new ProgressListener(webProgress, {
+      resolveWhenStarted: true,
+      waitForExplicitStart: true,
+    });
+    const navigated = progressListener.start();
+
+    // Send stop state to complete the initial navigation
+    await webProgress.sendStopState();
+    ok(
+      !(await hasPromiseResolved(navigated)),
+      "Listener has not resolved after initial navigation"
+    );
+
+    // Start a new navigation
+    await webProgress.sendStartState();
+    ok(
+      await hasPromiseResolved(navigated),
+      "Listener resolved after starting the new navigation"
+    );
+  }
+);
+
+add_task(
+  async function test_ProgressListener_resolveWhenNavigatingInsideDocument() {
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+
+    const progressListener = new ProgressListener(webProgress);
+    const navigated = progressListener.start();
+
+    ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved");
+
+    // Send hash change location change notification to complete the navigation
+    await webProgress.sendLocationChange({
+      flag: Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT,
+    });
+
+    ok(await hasPromiseResolved(navigated), "Listener has resolved");
+
+    const { currentURI, targetURI } = progressListener;
+    equal(
+      currentURI.spec,
+      TARGET_URI_WITH_HASH.spec,
+      "Expected current URI has been set"
+    );
+    equal(
+      targetURI.spec,
+      TARGET_URI_WITH_HASH.spec,
+      "Expected target URI has been set"
+    );
+  }
+);
+
+add_task(async function test_ProgressListener_ignoreCacheError() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  const progressListener = new ProgressListener(webProgress);
+  const navigated = progressListener.start();
+
+  ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved");
+
+  await webProgress.sendStartState();
+  await webProgress.sendStopState({
+    errorFlag: Cr.NS_ERROR_PARSED_DATA_CACHED,
+  });
+
+  ok(await hasPromiseResolved(navigated), "Listener has resolved");
+});
+
+add_task(async function test_ProgressListener_navigationRejectedOnErrorPage() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  const progressListener = new ProgressListener(webProgress, {
+    waitForExplicitStart: false,
+  });
+  const navigated = progressListener.start();
+
+  await webProgress.sendStartState();
+  await webProgress.sendLocationChange({
+    flag:
+      Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT |
+      Ci.nsIWebProgressListener.LOCATION_CHANGE_ERROR_PAGE,
+  });
+
+  ok(
+    await hasPromiseRejected(navigated),
+    "Listener has rejected in location change for error page"
+  );
+});
+
+add_task(async function test_ProgressListener_navigationRejectedOnStopState() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  const progressListener = new ProgressListener(webProgress, {
+    waitForExplicitStart: false,
+  });
+  const navigated = progressListener.start();
+
+  await webProgress.sendStartState();
+  await webProgress.sendStopState({ errorFlag: Cr.NS_BINDING_ABORTED });
+
+  ok(
+    await hasPromiseRejected(navigated),
+    "Listener has rejected in stop state for erroneous navigation"
+  );
+});
+
+add_task(async function test_ProgressListener_stopIfStarted() {
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+
+  const progressListener = new ProgressListener(webProgress);
+  const navigated = progressListener.start();
+
+  progressListener.stopIfStarted();
+  ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved");
+
+  await webProgress.sendStartState();
+  progressListener.stopIfStarted();
+  ok(await hasPromiseResolved(navigated), "Listener has resolved");
+});
+
+add_task(async function test_ProgressListener_stopIfStarted_alreadyStarted() {
+  // Create an already navigating browsing context.
+  const browsingContext = new MockTopContext();
+  const webProgress = browsingContext.webProgress;
+  await webProgress.sendStartState();
+
+  // Create a progress listener which accepts already ongoing navigations.
+  const progressListener = new ProgressListener(webProgress, {
+    waitForExplicitStart: false,
+  });
+  const navigated = progressListener.start();
+
+  // stopIfStarted should stop the listener because of the ongoing navigation.
+  progressListener.stopIfStarted();
+  ok(await hasPromiseResolved(navigated), "Listener has resolved");
+});
+
+add_task(
+  async function test_ProgressListener_stopIfStarted_alreadyStarted_waitForExplicitStart() {
+    // Create an already navigating browsing context.
+    const browsingContext = new MockTopContext();
+    const webProgress = browsingContext.webProgress;
+    await webProgress.sendStartState();
+
+    // Create a progress listener which rejects already ongoing navigations.
+    const progressListener = new ProgressListener(webProgress, {
+      waitForExplicitStart: true,
+    });
+    const navigated = progressListener.start();
+
+    // stopIfStarted will not stop the listener for the existing navigation.
+    progressListener.stopIfStarted();
+    ok(!(await hasPromiseResolved(navigated)), "Listener has not resolved");
+
+    // stopIfStarted will stop the listener when called after starting a new
+    // navigation.
+    await webProgress.sendStartState();
+    progressListener.stopIfStarted();
+    ok(await hasPromiseResolved(navigated), "Listener has resolved");
+  }
+);
diff --git a/remote/shared/test/xpcshell/test_Realm.js b/remote/shared/test/xpcshell/test_Realm.js
new file mode 100644
index 0000000000..36788201ef
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_Realm.js
@@ -0,0 +1,86 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const { Realm } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/Realm.sys.mjs"
+);
+
+add_task(function test_id() {
+  const realm1 = new Realm();
+  const id1 = realm1.id;
+  Assert.equal(typeof id1, "string");
+
+  const realm2 = new Realm();
+  const id2 = realm2.id;
+  Assert.equal(typeof id2, "string");
+
+  Assert.notEqual(id1, id2, "Ids for different realms are different");
+});
+
+add_task(function test_handleObjectMap() {
+  const realm = new Realm();
+
+  // Test an unknown handle.
+  Assert.equal(
+    realm.getObjectForHandle("unknown"),
+    undefined,
+    "Unknown handles return undefined"
+  );
+
+  // Test creating a simple handle.
+  const object = {};
+  const handle = realm.getHandleForObject(object);
+  Assert.equal(typeof handle, "string", "Created a valid handle");
+  Assert.equal(
+    realm.getObjectForHandle(handle),
+    object,
+    "Using the handle returned the original object"
+  );
+
+  // Test another handle for the same object.
+  const secondHandle = realm.getHandleForObject(object);
+  Assert.equal(typeof secondHandle, "string", "Created a valid handle");
+  Assert.notEqual(secondHandle, handle, "A different handle was generated");
+  Assert.equal(
+    realm.getObjectForHandle(secondHandle),
+    object,
+    "Using the second handle also returned the original object"
+  );
+
+  // Test using the handles in another realm.
+  const otherRealm = new Realm();
+  Assert.equal(
+    otherRealm.getObjectForHandle(handle),
+    undefined,
+    "A realm returns undefined for handles from another realm"
+  );
+
+  // Removing an unknown handle should not throw or have any side effect on
+  // existing handles.
+  realm.removeObjectHandle("unknown");
+  Assert.equal(realm.getObjectForHandle(handle), object);
+  Assert.equal(realm.getObjectForHandle(secondHandle), object);
+
+  // Remove the second handle
+  realm.removeObjectHandle(secondHandle);
+  Assert.equal(
+    realm.getObjectForHandle(handle),
+    object,
+    "The first handle is still resolving the object"
+  );
+  Assert.equal(
+    realm.getObjectForHandle(secondHandle),
+    undefined,
+    "The second handle returns undefined after calling removeObjectHandle"
+  );
+
+  // Remove the original handle
+  realm.removeObjectHandle(handle);
+  Assert.equal(
+    realm.getObjectForHandle(handle),
+    undefined,
+    "The first handle returns undefined as well"
+  );
+});
diff --git a/remote/shared/test/xpcshell/test_RecommendedPreferences.js b/remote/shared/test/xpcshell/test_RecommendedPreferences.js
new file mode 100644
index 0000000000..d42482d1d8
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_RecommendedPreferences.js
@@ -0,0 +1,111 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { RecommendedPreferences } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/RecommendedPreferences.sys.mjs"
+);
+
+const COMMON_PREF = "toolkit.startup.max_resumed_crashes";
+
+const MARIONETTE_PREF = "dom.disable_beforeunload";
+const MARIONETTE_RECOMMENDED_PREFS = new Map([[MARIONETTE_PREF, true]]);
+
+const CDP_PREF = "browser.contentblocking.features.standard";
+const CDP_RECOMMENDED_PREFS = new Map([
+  [CDP_PREF, "-tp,tpPrivate,cookieBehavior0,-cm,-fp"],
+]);
+
+function cleanup() {
+  info("Restore recommended preferences and test preferences");
+  Services.prefs.clearUserPref("remote.prefs.recommended");
+  RecommendedPreferences.restoreAllPreferences();
+}
+
+// cleanup() should be called:
+// - explicitly after each test to avoid side effects
+// - via registerCleanupFunction in case a test crashes/times out
+registerCleanupFunction(cleanup);
+
+add_task(async function test_RecommendedPreferences() {
+  info("Check initial values for the test preferences");
+  checkPreferences({ cdp: false, common: false, marionette: false });
+
+  checkPreferences({ cdp: false, common: false, marionette: false });
+
+  info("Apply recommended preferences for a marionette client");
+  RecommendedPreferences.applyPreferences(MARIONETTE_RECOMMENDED_PREFS);
+  checkPreferences({ cdp: false, common: true, marionette: true });
+
+  info("Apply recommended preferences for a cdp client");
+  RecommendedPreferences.applyPreferences(CDP_RECOMMENDED_PREFS);
+  checkPreferences({ cdp: true, common: true, marionette: true });
+
+  info("Restore marionette preferences");
+  RecommendedPreferences.restorePreferences(MARIONETTE_RECOMMENDED_PREFS);
+  checkPreferences({ cdp: true, common: true, marionette: false });
+
+  info("Restore cdp preferences");
+  RecommendedPreferences.restorePreferences(CDP_RECOMMENDED_PREFS);
+  checkPreferences({ cdp: false, common: true, marionette: false });
+
+  info("Restore all the altered preferences");
+  RecommendedPreferences.restoreAllPreferences();
+  checkPreferences({ cdp: false, common: false, marionette: false });
+
+  info("Attemps to restore again");
+  RecommendedPreferences.restoreAllPreferences();
+  checkPreferences({ cdp: false, common: false, marionette: false });
+
+  cleanup();
+});
+
+add_task(async function test_RecommendedPreferences_disabled() {
+  info("Disable RecommendedPreferences");
+  Services.prefs.setBoolPref("remote.prefs.recommended", false);
+
+  info("Check initial values for the test preferences");
+  checkPreferences({ cdp: false, common: false, marionette: false });
+
+  info("Recommended preferences are not applied, applyPreferences is a no-op");
+  RecommendedPreferences.applyPreferences(MARIONETTE_RECOMMENDED_PREFS);
+  checkPreferences({ cdp: false, common: false, marionette: false });
+
+  cleanup();
+});
+
+// Check that protocols can override common preferences.
+add_task(async function test_RecommendedPreferences_override() {
+  info("Make sure the common preference has no user value");
+  Services.prefs.clearUserPref(COMMON_PREF);
+
+  const OVERRIDE_VALUE = 42;
+  const OVERRIDE_COMMON_PREF = new Map([[COMMON_PREF, OVERRIDE_VALUE]]);
+
+  info("Apply a map of preferences overriding a common preference");
+  RecommendedPreferences.applyPreferences(OVERRIDE_COMMON_PREF);
+
+  equal(
+    Services.prefs.getIntPref(COMMON_PREF),
+    OVERRIDE_VALUE,
+    "The common preference was set to the expected value"
+  );
+
+  cleanup();
+});
+
+function checkPreferences({ cdp, common, marionette }) {
+  checkPreference(COMMON_PREF, { hasValue: common });
+  checkPreference(MARIONETTE_PREF, { hasValue: marionette });
+  checkPreference(CDP_PREF, { hasValue: cdp });
+}
+
+function checkPreference(pref, { hasValue }) {
+  equal(
+    Services.prefs.prefHasUserValue(pref),
+    hasValue,
+    hasValue
+      ? `The preference ${pref} has a user value`
+      : `The preference ${pref} has no user value`
+  );
+}
diff --git a/remote/shared/test/xpcshell/test_Stack.js b/remote/shared/test/xpcshell/test_Stack.js
new file mode 100644
index 0000000000..c41c5f0240
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_Stack.js
@@ -0,0 +1,120 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { getFramesFromStack, isChromeFrame } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/Stack.sys.mjs"
+);
+
+const sourceFrames = [
+  {
+    column: 1,
+    functionDisplayName: "foo",
+    line: 2,
+    source: "cheese",
+    sourceId: 1,
+  },
+  {
+    column: 3,
+    functionDisplayName: null,
+    line: 4,
+    source: "cake",
+    sourceId: 2,
+  },
+  {
+    column: 5,
+    functionDisplayName: "chrome",
+    line: 6,
+    source: "chrome://foo",
+    sourceId: 3,
+  },
+];
+
+const targetFrames = [
+  {
+    columnNumber: 1,
+    functionName: "foo",
+    lineNumber: 2,
+    filename: "cheese",
+    sourceId: 1,
+  },
+  {
+    columnNumber: 3,
+    functionName: "",
+    lineNumber: 4,
+    filename: "cake",
+    sourceId: 2,
+  },
+  {
+    columnNumber: 5,
+    functionName: "chrome",
+    lineNumber: 6,
+    filename: "chrome://foo",
+    sourceId: 3,
+  },
+];
+
+add_task(async function test_getFramesFromStack() {
+  const stack = buildStack(sourceFrames);
+  const frames = getFramesFromStack(stack, { includeChrome: false });
+
+  ok(Array.isArray(frames), "frames is of expected type Array");
+  equal(frames.length, 3, "Got expected amount of frames");
+  checkFrame(frames.at(0), targetFrames.at(0));
+  checkFrame(frames.at(1), targetFrames.at(1));
+  checkFrame(frames.at(2), targetFrames.at(2));
+});
+
+add_task(async function test_getFramesFromStack_asyncStack() {
+  const stack = buildStack(sourceFrames, true);
+  const frames = getFramesFromStack(stack);
+
+  ok(Array.isArray(frames), "frames is of expected type Array");
+  equal(frames.length, 3, "Got expected amount of frames");
+  checkFrame(frames.at(0), targetFrames.at(0));
+  checkFrame(frames.at(1), targetFrames.at(1));
+  checkFrame(frames.at(2), targetFrames.at(2));
+});
+
+add_task(async function test_isChromeFrame() {
+  for (const filename of ["chrome://foo/bar", "resource://foo/bar"]) {
+    ok(isChromeFrame({ filename }), "Frame is of expected chrome scope");
+  }
+
+  for (const filename of ["http://foo.bar", "about:blank"]) {
+    ok(!isChromeFrame({ filename }), "Frame is of expected content scope");
+  }
+});
+
+function buildStack(frames, async = false) {
+  const parent = async ? "asyncParent" : "parent";
+
+  let currentFrame, stack;
+  for (const frame of frames) {
+    if (currentFrame) {
+      currentFrame[parent] = Object.assign({}, frame);
+      currentFrame = currentFrame[parent];
+    } else {
+      stack = Object.assign({}, frame);
+      currentFrame = stack;
+    }
+  }
+
+  return stack;
+}
+
+function checkFrame(frame, expectedFrame) {
+  equal(
+    frame.columnNumber,
+    expectedFrame.columnNumber,
+    "Got expected column number"
+  );
+  equal(
+    frame.functionName,
+    expectedFrame.functionName,
+    "Got expected function name"
+  );
+  equal(frame.lineNumber, expectedFrame.lineNumber, "Got expected line number");
+  equal(frame.filename, expectedFrame.filename, "Got expected filename");
+  equal(frame.sourceId, expectedFrame.sourceId, "Got expected source id");
+}
diff --git a/remote/shared/test/xpcshell/test_Sync.js b/remote/shared/test/xpcshell/test_Sync.js
new file mode 100644
index 0000000000..ae9de72718
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_Sync.js
@@ -0,0 +1,389 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { setTimeout } = ChromeUtils.importESModule(
+  "resource://gre/modules/Timer.sys.mjs"
+);
+
+const { AnimationFramePromise, Deferred, EventPromise, PollPromise } =
+  ChromeUtils.importESModule("chrome://remote/content/shared/Sync.sys.mjs");
+
+/**
+ * Mimic a DOM node for listening for events.
+ */
+class MockElement {
+  constructor() {
+    this.capture = false;
+    this.eventName = null;
+    this.func = null;
+    this.mozSystemGroup = false;
+    this.wantUntrusted = false;
+    this.untrusted = false;
+  }
+
+  addEventListener(name, func, options = {}) {
+    const { capture, mozSystemGroup, wantUntrusted } = options;
+
+    this.eventName = name;
+    this.func = func;
+    this.capture = capture ?? false;
+    this.mozSystemGroup = mozSystemGroup ?? false;
+    this.wantUntrusted = wantUntrusted ?? false;
+  }
+
+  click() {
+    if (this.func) {
+      const event = {
+        capture: this.capture,
+        mozSystemGroup: this.mozSystemGroup,
+        target: this,
+        type: this.eventName,
+        untrusted: this.untrusted,
+        wantUntrusted: this.wantUntrusted,
+      };
+      this.func(event);
+    }
+  }
+
+  dispatchEvent(event) {
+    if (this.wantUntrusted) {
+      this.untrusted = true;
+    }
+    this.click();
+  }
+
+  removeEventListener(name, func) {
+    this.capture = false;
+    this.eventName = null;
+    this.func = null;
+    this.mozSystemGroup = false;
+    this.untrusted = false;
+    this.wantUntrusted = false;
+  }
+}
+
+add_task(async function test_AnimationFramePromise() {
+  let called = false;
+  let win = {
+    requestAnimationFrame(callback) {
+      called = true;
+      callback();
+    },
+  };
+  await AnimationFramePromise(win);
+  ok(called);
+});
+
+add_task(async function test_AnimationFramePromiseAbortWhenWindowClosed() {
+  let win = {
+    closed: true,
+    requestAnimationFrame() {},
+  };
+  await AnimationFramePromise(win);
+});
+
+add_task(async function test_DeferredPending() {
+  const deferred = Deferred();
+  ok(deferred.pending);
+
+  deferred.resolve();
+  await deferred.promise;
+  ok(!deferred.pending);
+});
+
+add_task(async function test_DeferredRejected() {
+  const deferred = Deferred();
+
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  setTimeout(() => deferred.reject(new Error("foo")), 100);
+
+  try {
+    await deferred.promise;
+    ok(false);
+  } catch (e) {
+    ok(!deferred.pending);
+
+    ok(!deferred.fulfilled);
+    ok(deferred.rejected);
+    equal(e.message, "foo");
+  }
+});
+
+add_task(async function test_DeferredResolved() {
+  const deferred = Deferred();
+  ok(deferred.pending);
+
+  // eslint-disable-next-line mozilla/no-arbitrary-setTimeout
+  setTimeout(() => deferred.resolve("foo"), 100);
+
+  const result = await deferred.promise;
+  ok(!deferred.pending);
+
+  ok(deferred.fulfilled);
+  ok(!deferred.rejected);
+  equal(result, "foo");
+});
+
+add_task(async function test_EventPromise_subjectTypes() {
+  for (const subject of ["foo", 42, null, undefined, true, [], {}]) {
+    Assert.throws(() => new EventPromise(subject, "click"), /TypeError/);
+  }
+});
+
+add_task(async function test_EventPromise_eventNameTypes() {
+  const element = new MockElement();
+
+  for (const eventName of [42, null, undefined, true, [], {}]) {
+    Assert.throws(() => new EventPromise(element, eventName), /TypeError/);
+  }
+});
+
+add_task(async function test_EventPromise_subjectAndEventNameEvent() {
+  const element = new MockElement();
+
+  const clicked = new EventPromise(element, "click");
+  element.click();
+  const event = await clicked;
+
+  equal(element, event.target);
+});
+
+add_task(async function test_EventPromise_captureTypes() {
+  const element = new MockElement();
+
+  for (const capture of [null, "foo", 42, [], {}]) {
+    Assert.throws(
+      () => new EventPromise(element, "click", { capture }),
+      /TypeError/
+    );
+  }
+});
+
+add_task(async function test_EventPromise_captureEvent() {
+  const element = new MockElement();
+
+  for (const capture of [undefined, false, true]) {
+    const expectedCapture = capture ?? false;
+
+    const clicked = new EventPromise(element, "click", { capture });
+    element.click();
+    const event = await clicked;
+
+    equal(element, event.target);
+    equal(expectedCapture, event.capture);
+  }
+});
+
+add_task(async function test_EventPromise_checkFnTypes() {
+  const element = new MockElement();
+
+  for (const checkFn of ["foo", 42, true, [], {}]) {
+    Assert.throws(
+      () => new EventPromise(element, "click", { checkFn }),
+      /TypeError/
+    );
+  }
+});
+
+add_task(async function test_EventPromise_checkFnCallback() {
+  const element = new MockElement();
+
+  let count;
+  const data = [
+    { checkFn: null, expected_count: 0 },
+    { checkFn: undefined, expected_count: 0 },
+    {
+      checkFn: event => {
+        throw new Error("foo");
+      },
+      expected_count: 0,
+    },
+    { checkFn: event => count++ > 0, expected_count: 2 },
+  ];
+
+  for (const { checkFn, expected_count } of data) {
+    count = 0;
+
+    const clicked = new EventPromise(element, "click", { checkFn });
+    element.click();
+    element.click();
+    const event = await clicked;
+
+    equal(element, event.target);
+    equal(expected_count, count);
+  }
+});
+
+add_task(async function test_EventPromise_mozSystemGroupTypes() {
+  const element = new MockElement();
+
+  for (const mozSystemGroup of [null, "foo", 42, [], {}]) {
+    Assert.throws(
+      () => new EventPromise(element, "click", { mozSystemGroup }),
+      /TypeError/
+    );
+  }
+});
+
+add_task(async function test_EventPromise_mozSystemGroupEvent() {
+  const element = new MockElement();
+
+  for (const mozSystemGroup of [undefined, false, true]) {
+    const expectedMozSystemGroup = mozSystemGroup ?? false;
+
+    const clicked = new EventPromise(element, "click", { mozSystemGroup });
+    element.click();
+    const event = await clicked;
+
+    equal(element, event.target);
+    equal(expectedMozSystemGroup, event.mozSystemGroup);
+  }
+});
+
+add_task(async function test_EventPromise_wantUntrustedTypes() {
+  const element = new MockElement();
+
+  for (let wantUntrusted of [null, "foo", 42, [], {}]) {
+    Assert.throws(
+      () => new EventPromise(element, "click", { wantUntrusted }),
+      /TypeError/
+    );
+  }
+});
+
+add_task(async function test_EventPromise_wantUntrustedEvent() {
+  for (const wantUntrusted of [undefined, false, true]) {
+    let expected_untrusted = wantUntrusted ?? false;
+
+    const element = new MockElement();
+
+    const clicked = new EventPromise(element, "click", { wantUntrusted });
+    element.dispatchEvent(new CustomEvent("click", {}));
+    const event = await clicked;
+
+    equal(element, event.target);
+    equal(expected_untrusted, event.untrusted);
+  }
+});
+
+add_task(function test_executeSoon_callback() {
+  // executeSoon() is already defined for xpcshell in head.js. As such import
+  // our implementation into a custom namespace.
+  let sync = ChromeUtils.importESModule(
+    "chrome://remote/content/shared/Sync.sys.mjs"
+  );
+
+  for (let func of ["foo", null, true, [], {}]) {
+    Assert.throws(() => sync.executeSoon(func), /TypeError/);
+  }
+
+  let a;
+  sync.executeSoon(() => {
+    a = 1;
+  });
+  executeSoon(() => equal(1, a));
+});
+
+add_task(function test_PollPromise_funcTypes() {
+  for (let type of ["foo", 42, null, undefined, true, [], {}]) {
+    Assert.throws(() => new PollPromise(type), /TypeError/);
+  }
+  new PollPromise(() => {});
+  new PollPromise(function () {});
+});
+
+add_task(function test_PollPromise_timeoutTypes() {
+  for (let timeout of ["foo", true, [], {}]) {
+    Assert.throws(() => new PollPromise(() => {}, { timeout }), /TypeError/);
+  }
+  for (let timeout of [1.2, -1]) {
+    Assert.throws(() => new PollPromise(() => {}, { timeout }), /RangeError/);
+  }
+  for (let timeout of [null, undefined, 42]) {
+    new PollPromise(resolve => resolve(1), { timeout });
+  }
+});
+
+add_task(function test_PollPromise_intervalTypes() {
+  for (let interval of ["foo", null, true, [], {}]) {
+    Assert.throws(() => new PollPromise(() => {}, { interval }), /TypeError/);
+  }
+  for (let interval of [1.2, -1]) {
+    Assert.throws(() => new PollPromise(() => {}, { interval }), /RangeError/);
+  }
+  new PollPromise(() => {}, { interval: 42 });
+});
+
+add_task(async function test_PollPromise_retvalTypes() {
+  for (let typ of [true, false, "foo", 42, [], {}]) {
+    strictEqual(typ, await new PollPromise(resolve => resolve(typ)));
+  }
+});
+
+add_task(async function test_PollPromise_rethrowError() {
+  let nevals = 0;
+  let err;
+  try {
+    await PollPromise(() => {
+      ++nevals;
+      throw new Error();
+    });
+  } catch (e) {
+    err = e;
+  }
+  equal(1, nevals);
+  ok(err instanceof Error);
+});
+
+add_task(async function test_PollPromise_noTimeout() {
+  let nevals = 0;
+  await new PollPromise((resolve, reject) => {
+    ++nevals;
+    nevals < 100 ? reject() : resolve();
+  });
+  equal(100, nevals);
+});
+
+add_task(async function test_PollPromise_zeroTimeout() {
+  // run at least once when timeout is 0
+  let nevals = 0;
+  let start = new Date().getTime();
+  await new PollPromise(
+    (resolve, reject) => {
+      ++nevals;
+      reject();
+    },
+    { timeout: 0 }
+  );
+  let end = new Date().getTime();
+  equal(1, nevals);
+  less(end - start, 500);
+});
+
+add_task(async function test_PollPromise_timeoutElapse() {
+  let nevals = 0;
+  let start = new Date().getTime();
+  await new PollPromise(
+    (resolve, reject) => {
+      ++nevals;
+      reject();
+    },
+    { timeout: 100 }
+  );
+  let end = new Date().getTime();
+  lessOrEqual(nevals, 11);
+  greaterOrEqual(end - start, 100);
+});
+
+add_task(async function test_PollPromise_interval() {
+  let nevals = 0;
+  await new PollPromise(
+    (resolve, reject) => {
+      ++nevals;
+      reject();
+    },
+    { timeout: 100, interval: 100 }
+  );
+  equal(2, nevals);
+});
diff --git a/remote/shared/test/xpcshell/test_TabManager.js b/remote/shared/test/xpcshell/test_TabManager.js
new file mode 100644
index 0000000000..e9da02c861
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_TabManager.js
@@ -0,0 +1,56 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { TabManager } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/TabManager.sys.mjs"
+);
+
+class MockTopBrowsingContext {
+  constructor() {
+    this.embedderElement = { permanentKey: {} };
+    this.id = 1;
+    this.top = this;
+  }
+}
+
+class MockBrowsingContext {
+  constructor() {
+    this.id = 2;
+
+    const topContext = new MockTopBrowsingContext();
+    this.parent = topContext;
+    this.top = topContext;
+  }
+}
+
+const mockTopBrowsingContext = new MockTopBrowsingContext();
+const mockBrowsingContext = new MockBrowsingContext();
+
+add_task(async function test_getIdForBrowsingContext() {
+  // Browsing context not set.
+  equal(TabManager.getIdForBrowsingContext(null), null);
+  equal(TabManager.getIdForBrowsingContext(undefined), null);
+
+  // Child browsing context.
+  equal(
+    TabManager.getIdForBrowsingContext(mockBrowsingContext),
+    mockBrowsingContext.id
+  );
+
+  const browser = mockTopBrowsingContext.embedderElement;
+  equal(
+    TabManager.getIdForBrowsingContext(mockTopBrowsingContext),
+    TabManager.getIdForBrowser(browser)
+  );
+});
+
+add_task(async function test_removeTab() {
+  // Tab not defined.
+  await TabManager.removeTab(null);
+});
+
+add_task(async function test_selectTab() {
+  // Tab not defined.
+  await TabManager.selectTab(null);
+});
diff --git a/remote/shared/test/xpcshell/test_UUID.js b/remote/shared/test/xpcshell/test_UUID.js
new file mode 100644
index 0000000000..e929a9e0a8
--- /dev/null
+++ b/remote/shared/test/xpcshell/test_UUID.js
@@ -0,0 +1,21 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { generateUUID } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/UUID.sys.mjs"
+);
+
+add_task(function test_UUID_valid() {
+  const uuid = generateUUID();
+  const regExp = new RegExp(
+    /^[a-f|0-9]{8}-[a-f|0-9]{4}-[a-f|0-9]{4}-[a-f|0-9]{4}-[a-f|0-9]{12}$/g
+  );
+  ok(regExp.test(uuid));
+});
+
+add_task(function test_UUID_unique() {
+  const uuid1 = generateUUID();
+  const uuid2 = generateUUID();
+  notEqual(uuid1, uuid2);
+});
diff --git a/remote/shared/test/xpcshell/xpcshell.ini b/remote/shared/test/xpcshell/xpcshell.ini
new file mode 100644
index 0000000000..3ea41894ea
--- /dev/null
+++ b/remote/shared/test/xpcshell/xpcshell.ini
@@ -0,0 +1,13 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+[test_AppInfo.js]
+[test_Format.js]
+[test_Navigate.js]
+[test_Realm.js]
+[test_RecommendedPreferences.js]
+[test_Stack.js]
+[test_Sync.js]
+[test_TabManager.js]
+[test_UUID.js]
diff --git a/remote/shared/webdriver/Actions.sys.mjs b/remote/shared/webdriver/Actions.sys.mjs
new file mode 100644
index 0000000000..e0d96a1ece
--- /dev/null
+++ b/remote/shared/webdriver/Actions.sys.mjs
@@ -0,0 +1,2137 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* eslint no-dupe-keys:off */
+/* eslint-disable no-restricted-globals */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AppInfo: "chrome://remote/content/shared/AppInfo.sys.mjs",
+  assert: "chrome://remote/content/shared/webdriver/Assert.sys.mjs",
+  element: "chrome://remote/content/marionette/element.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  event: "chrome://remote/content/marionette/event.sys.mjs",
+  keyData: "chrome://remote/content/shared/webdriver/KeyData.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  pprint: "chrome://remote/content/shared/Format.sys.mjs",
+  Sleep: "chrome://remote/content/marionette/sync.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () =>
+  lazy.Log.get(lazy.Log.TYPES.MARIONETTE)
+);
+
+// TODO? With ES 2016 and Symbol you can make a safer approximation
+// to an enum e.g. https://gist.github.com/xmlking/e86e4f15ec32b12c4689
+/**
+ * Implements WebDriver Actions API: a low-level interface for providing
+ * virtualised device input to the web browser.
+ *
+ * Typical usage is to construct an action chain and then dispatch it:
+ * const state = new action.State();
+ * const chain = new action.Chain.fromJSON(state, protocolData);
+ * await chain.dispatch(state, window);
+ *
+ * @namespace
+ */
+export const action = {};
+
+/** Map from normalized key value to UI Events modifier key name */
+const MODIFIER_NAME_LOOKUP = {
+  Alt: "alt",
+  Shift: "shift",
+  Control: "ctrl",
+  Meta: "meta",
+};
+
+/**
+ * State associated with actions
+ *
+ * Typically each top-level browsing context in a session should have a single State object
+ */
+action.State = class {
+  constructor(options = {}) {
+    const { specCompatPointerOrigin = true } = options;
+
+    /** Flag for WebDriver spec conforming pointer origin calculation. */
+    this.specCompatPointerOrigin = specCompatPointerOrigin;
+
+    /**
+     * A map between input ID and the device state for that input
+     * source, with one entry for each active input source.
+     *
+     * Maps string => InputSource
+     */
+    this.inputStateMap = new Map();
+
+    /**
+     * List of {@link Action} associated with current session.  Used to
+     * manage dispatching events when resetting the state of the input sources.
+     * Reset operations are assumed to be idempotent.
+     */
+    this.inputsToCancel = new TickActions();
+
+    /**
+     * Map between string input id and numeric pointer id
+     */
+    this.pointerIdMap = new Map();
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} ${JSON.stringify(this)}]`;
+  }
+
+  /**
+   * Reset state stored in this object.
+   * It is an error to use the State object after calling release().
+   *
+   * @param {WindowProxy} win Current window global.
+   */
+  async release(win) {
+    this.inputsToCancel.reverse();
+    await this.inputsToCancel.dispatch(this, win);
+    lazy.event.DoubleClickTracker.resetClick();
+  }
+
+  /**
+   * Get the state for a given input source.
+   *
+   * @param {string} id Input source id.
+   * @returns {InputSource} Input source state.
+   */
+  getInputSource(id) {
+    return this.inputStateMap.get(id);
+  }
+
+  /**
+   * Find or add state for an input source. The caller should verify
+   * that the returned state is the expected type.
+   *
+   * @param {string} id Input source id.
+   * @param {InputSource} newInputSource Input source state.
+   */
+  getOrAddInputSource(id, newInputSource) {
+    let inputSource = this.getInputSource(id);
+    if (inputSource === undefined) {
+      this.inputStateMap.set(id, newInputSource);
+      inputSource = newInputSource;
+    }
+    return inputSource;
+  }
+
+  /**
+   * Iterate over all input states of a given type
+   *
+   * @param {string} type Input source type name (e.g. "pointer").
+   * @returns {Iterator} Iterator over [id, input source].
+   */
+  *inputSourcesByType(type) {
+    for (const [id, inputSource] of this.inputStateMap) {
+      if (inputSource.type === type) {
+        yield [id, inputSource];
+      }
+    }
+  }
+
+  /**
+   * Get a numerical pointer id for a given pointer
+   *
+   * Pointer ids are positive integers. Mouse pointers are typically
+   * ids 0 or 1. Non-mouse pointers never get assigned id < 2. Each
+   * pointer gets a unique id.
+   *
+   * @param {string} id Pointer id.
+   * @param {string} type Pointer type.
+   * @returns {number} Numerical pointer id.
+   */
+  getPointerId(id, type) {
+    let pointerId = this.pointerIdMap.get(id);
+    if (pointerId === undefined) {
+      // Reserve pointer ids 0 and 1 for mouse pointers
+      const idValues = Array.from(this.pointerIdMap.values());
+      if (type === "mouse") {
+        for (const mouseId of [0, 1]) {
+          if (!idValues.includes(mouseId)) {
+            pointerId = mouseId;
+            break;
+          }
+        }
+      }
+      if (pointerId === undefined) {
+        pointerId = Math.max(1, ...idValues) + 1;
+      }
+      this.pointerIdMap.set(id, pointerId);
+    }
+    return pointerId;
+  }
+};
+
+/**
+ * Device state for an input source.
+ */
+class InputSource {
+  #id;
+  static type = null;
+
+  constructor(id) {
+    this.#id = id;
+    this.type = this.constructor.type;
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} id: ${this.#id} type: ${
+      this.type
+    }]`;
+  }
+
+  /**
+   * @param {State} state Actions state.
+   * @param {Sequence} actionSequence Actions for a specific input source.
+   *
+   * @returns {InputSource}
+   *     An {@link InputSource} object for the type of the
+   *     {@link actionSequence}.
+   *
+   * @throws {InvalidArgumentError}
+   *     If {@link actionSequence.type} is not valid.
+   */
+  static fromJSON(state, actionSequence) {
+    const { id, type } = actionSequence;
+    lazy.assert.string(
+      id,
+      lazy.pprint`Expected 'id' to be a string, got ${id}`
+    );
+    const cls = inputSourceTypes.get(type);
+    if (cls === undefined) {
+      throw new lazy.error.InvalidArgumentError(
+        lazy.pprint`Unknown action type: ${type}`
+      );
+    }
+
+    const sequenceInputSource = cls.fromJSON(state, actionSequence);
+    const inputSource = state.getOrAddInputSource(id, sequenceInputSource);
+    if (inputSource.type !== type) {
+      throw new lazy.error.InvalidArgumentError(
+        `Expected input source ${id} to be type ${inputSource.type}, ` +
+          `got ${type}`
+      );
+    }
+  }
+}
+
+/**
+ * Input state not associated with a specific physical device.
+ */
+class NullInputSource extends InputSource {
+  static type = "none";
+
+  static fromJSON(state, actionSequence) {
+    const { id } = actionSequence;
+    return new this(id);
+  }
+}
+
+/**
+ * Input state associated with a keyboard-type device.
+ */
+class KeyInputSource extends InputSource {
+  static type = "key";
+
+  constructor(id) {
+    super(id);
+    this.pressed = new Set();
+    this.alt = false;
+    this.shift = false;
+    this.ctrl = false;
+    this.meta = false;
+  }
+
+  static fromJSON(state, actionSequence) {
+    const { id } = actionSequence;
+    return new this(id);
+  }
+
+  /**
+   * Update modifier state according to |key|.
+   *
+   * @param {string} key
+   *     Normalized key value of a modifier key.
+   * @param {boolean} value
+   *     Value to set the modifier attribute to.
+   *
+   * @throws {InvalidArgumentError}
+   *     If |key| is not a modifier.
+   */
+  setModState(key, value) {
+    if (key in MODIFIER_NAME_LOOKUP) {
+      this[MODIFIER_NAME_LOOKUP[key]] = value;
+    } else {
+      throw new lazy.error.InvalidArgumentError(
+        "Expected 'key' to be one of " +
+          Object.keys(MODIFIER_NAME_LOOKUP) +
+          lazy.pprint`, got ${key}`
+      );
+    }
+  }
+
+  /**
+   * Check whether |key| is pressed.
+   *
+   * @param {string} key
+   *     Normalized key value.
+   *
+   * @returns {boolean}
+   *     True if |key| is in set of pressed keys.
+   */
+  isPressed(key) {
+    return this.pressed.has(key);
+  }
+
+  /**
+   * Add |key| to the set of pressed keys.
+   *
+   * @param {string} key
+   *     Normalized key value.
+   *
+   * @returns {boolean}
+   *     True if |key| is in list of pressed keys.
+   */
+  press(key) {
+    return this.pressed.add(key);
+  }
+
+  /**
+   * Remove |key| from the set of pressed keys.
+   *
+   * @param {string} key
+   *     Normalized key value.
+   *
+   * @returns {boolean}
+   *     True if |key| was present before removal, false otherwise.
+   */
+  release(key) {
+    return this.pressed.delete(key);
+  }
+}
+
+/**
+ * Input state associated with a pointer-type device.
+ */
+class PointerInputSource extends InputSource {
+  static type = "pointer";
+
+  /**
+   * @param {string} id InputSource id.
+   * @param {Pointer} pointer Object representing the specific pointer
+   * type associated with this input source.
+   */
+  constructor(id, pointer) {
+    super(id);
+    this.pointer = pointer;
+    this.x = 0;
+    this.y = 0;
+    this.pressed = new Set();
+  }
+
+  /**
+   * Check whether |button| is pressed.
+   *
+   * @param {number} button
+   *     Positive integer that refers to a mouse button.
+   *
+   * @returns {boolean}
+   *     True if |button| is in set of pressed buttons.
+   */
+  isPressed(button) {
+    lazy.assert.positiveInteger(button);
+    return this.pressed.has(button);
+  }
+
+  /**
+   * Add |button| to the set of pressed keys.
+   *
+   * @param {number} button
+   *     Positive integer that refers to a mouse button.
+   *
+   * @returns {Set}
+   *     Set of pressed buttons.
+   */
+  press(button) {
+    lazy.assert.positiveInteger(button);
+    this.pressed.add(button);
+  }
+
+  /**
+   * Remove |button| from the set of pressed buttons.
+   *
+   * @param {number} button
+   *     A positive integer that refers to a mouse button.
+   *
+   * @returns {boolean}
+   *     True if |button| was present before removals, false otherwise.
+   */
+  release(button) {
+    lazy.assert.positiveInteger(button);
+    return this.pressed.delete(button);
+  }
+
+  static fromJSON(state, actionSequence) {
+    const { id, parameters } = actionSequence;
+
+    const pointerType = parameters?.pointerType ?? "mouse";
+    const pointerId = state.getPointerId(id, pointerType);
+    const pointer = Pointer.fromJSON(pointerId, pointerType);
+    return new this(id, pointer);
+  }
+}
+
+/**
+ * Input state associated with a wheel-type device.
+ */
+class WheelInputSource extends InputSource {
+  static type = "wheel";
+
+  static fromJSON(state, actionSequence) {
+    const { id } = actionSequence;
+    return new this(id);
+  }
+}
+
+const inputSourceTypes = new Map();
+for (const cls of [
+  NullInputSource,
+  KeyInputSource,
+  PointerInputSource,
+  WheelInputSource,
+]) {
+  inputSourceTypes.set(cls.type, cls);
+}
+
+/**
+ * Representation of a coordinate origin
+ */
+class Origin {
+  /**
+   * Viewport coordinates of the origin of this coordinate system.
+   *
+   * This is overridden in subclasses to provide a class-specific origin.
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of current input device.
+   * @param {WindowProxy} win - Current window global
+   */
+  getOriginCoordinates(state, inputSource, win) {
+    throw new Error(
+      `originCoordinates not defined for ${this.constructor.name}`
+    );
+  }
+
+  /**
+   * Convert [x, y] coordinates to viewport coordinates
+   *
+   * @param {State} state - Actions state
+   * @param {InputSource} inputSource - State of the current input device
+   * @param {Array<number>} coords - [x, y] coordinate of target relative to origin
+   * @param {WindowProxy} win - Current window global
+   */
+  getTargetCoordinates(state, inputSource, coords, win) {
+    const [x, y] = coords;
+    const origin = this.getOriginCoordinates(state, inputSource, win);
+    return [origin.x + x, origin.y + y];
+  }
+
+  /**
+   * @param {Element|string=} origin - Type of orgin, one of "viewport", "pointer", element or undefined.
+   *
+   * @returns {Origin} - An origin object representing the origin.
+   *
+   * @throws {InvalidArgumentError}
+   *     If <code>origin</code> isn't a valid origin.
+   */
+  static fromJSON(origin) {
+    if (origin === undefined || origin === "viewport") {
+      return new ViewportOrigin();
+    }
+    if (origin === "pointer") {
+      return new PointerOrigin();
+    }
+    if (lazy.element.isElement(origin)) {
+      return new ElementOrigin(origin);
+    }
+
+    throw new lazy.error.InvalidArgumentError(
+      `Expected 'origin' to be undefined, "viewport", "pointer", ` +
+        lazy.pprint`or an element, got: ${origin}`
+    );
+  }
+}
+
+class ViewportOrigin extends Origin {
+  getOriginCoordinates(state, inputSource, win) {
+    return { x: 0, y: 0 };
+  }
+}
+
+class PointerOrigin extends Origin {
+  getOriginCoordinates(state, inputSource, win) {
+    return { x: inputSource.x, y: inputSource.y };
+  }
+}
+
+class ElementOrigin extends Origin {
+  /**
+   * @param {Element} element - The element providing the coordinate origin.
+   */
+  constructor(element) {
+    super();
+    this.element = element;
+  }
+
+  getOriginCoordinates(state, inputSource, win) {
+    if (state.specCompatPointerOrigin) {
+      const clientRects = this.element.getClientRects();
+      // The spec doesn't handle this case; https://github.com/w3c/webdriver/issues/1642
+      if (!clientRects.length) {
+        throw new lazy.error.MoveTargetOutOfBoundsError(
+          `Origin element is not displayed`
+        );
+      }
+      return lazy.element.getInViewCentrePoint(clientRects[0], win);
+    }
+    return lazy.element.coordinates(this.element);
+  }
+}
+
+/**
+ * Repesents the behaviour of a single input source at a single
+ * point in time.
+ *
+ * @param {string} id - Input source ID.
+ */
+class Action {
+  /** Type of the input source associated with this action */
+  static type = null;
+  /** Type of action specific to the input source */
+  static subtype = null;
+  /** Whether this kind of action affects the overall duration of a tick */
+  affectsWallClockTime = false;
+
+  constructor(id) {
+    this.id = id;
+    this.type = this.constructor.type;
+    this.subtype = this.constructor.subtype;
+  }
+
+  toString() {
+    return `[${this.constructor.name} ${this.type}:${this.subtype}]`;
+  }
+
+  /**
+   * Dispatch the action to the relevant window.
+   *
+   * This is overridden by subclasses to implement the type-specific
+   * dispatch of the action.
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {number} tickDuration - Length of the current tick, in ms.
+   * @param {WindowProxy} win - Current window global.
+   * @returns {Promise} - Promise that is resolved once the action is complete.
+   */
+  dispatch(state, inputSource, tickDuration, win) {
+    throw new Error(
+      `Action subclass ${this.constructor.name} must override dispatch()`
+    );
+  }
+
+  /**
+   * @param {string} type - Input source type.
+   * @param {string} id - Input source id.
+   * @param {object} actionItem - Object representing a single action.
+   *
+   * @returns {Action} - An action that can be dispatched.
+   *
+   * @throws {InvalidArgumentError}
+   *     If any <code>actionSequence</code> or <code>actionItem</code>
+   *     attributes are invalid.
+   */
+  static fromJSON(type, id, actionItem) {
+    const subtype = actionItem.type;
+    const subtypeMap = actionTypes.get(type);
+    if (subtypeMap === undefined) {
+      throw new lazy.error.InvalidArgumentError(`Unknown action type: ${type}`);
+    }
+    let cls = subtypeMap.get(subtype);
+    // Non-device specific actions can happen for any action type
+    if (cls === undefined) {
+      cls = actionTypes.get("none").get(subtype);
+    }
+    if (cls === undefined) {
+      throw new lazy.error.InvalidArgumentError(
+        `Unknown subtype ${subtype} for type ${type}`
+      );
+    }
+    return cls.fromJSON(id, actionItem);
+  }
+}
+
+/**
+ * Action not associated with a specific input device.
+ */
+class NullAction extends Action {
+  static type = "none";
+}
+
+/**
+ * Action that waits for a given duration.
+ *
+ * @param {string} id - Input source ID.
+ * @param {object} options - Named arguments.
+ * @param {number} options.duration - Time to pause, in ms.
+ */
+class PauseAction extends NullAction {
+  static subtype = "pause";
+  affectsWallClockTime = true;
+
+  constructor(id, options) {
+    super(id);
+    const { duration } = options;
+    this.duration = duration;
+  }
+
+  /**
+   * Dispatch pause action
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {number} tickDuration - Length of the current tick, in ms.
+   * @param {WindowProxy} win - Current window global.
+   * @returns {Promise} - Promise that is resolved once the action is complete.
+   */
+  dispatch(state, inputSource, tickDuration, win) {
+    const ms = this.duration ?? tickDuration;
+    lazy.logger.trace(
+      ` Dispatch ${this.constructor.name} with ${this.id} ${ms}`
+    );
+    return lazy.Sleep(ms);
+  }
+
+  static fromJSON(id, actionItem) {
+    const { duration } = actionItem;
+    if (duration !== undefined) {
+      lazy.assert.positiveInteger(
+        duration,
+        lazy.pprint`Expected 'duration' (${duration}) to be >= 0`
+      );
+    }
+    return new this(id, { duration });
+  }
+}
+
+/**
+ * Action associated with a keyboard input device
+ *
+ * @param {string} id - Input source ID.
+ * @param {object} options - Named arguments.
+ * @param {string} options.value - Key character.
+ */
+class KeyAction extends Action {
+  static type = "key";
+
+  constructor(id, options) {
+    super(id);
+    const { value } = options;
+    this.value = value;
+  }
+
+  getEventData(inputSource) {
+    let value = this.value;
+    if (inputSource.shift) {
+      value = lazy.keyData.getShiftedKey(value);
+    }
+    return new KeyEventData(value);
+  }
+
+  static fromJSON(id, actionItem) {
+    // TODO countGraphemes
+    // TODO key.value could be a single code point like "\uE012"
+    // (see rawKey) or "grapheme cluster"
+    // https://bugzilla.mozilla.org/show_bug.cgi?id=1496323
+    const value = actionItem.value;
+    lazy.assert.string(
+      value,
+      "Expected 'value' to be a string that represents single code point " +
+        lazy.pprint`or grapheme cluster, got ${value}`
+    );
+    return new this(id, { value });
+  }
+}
+
+/**
+ * Action equivalent to pressing a key on a keyboard.
+ *
+ * @param {string} id - Input source ID.
+ * @param {string} value - Key character.
+ */
+class KeyDownAction extends KeyAction {
+  static subtype = "keyDown";
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} with ${this.id} ${this.value}`
+    );
+    return new Promise(resolve => {
+      const keyEvent = this.getEventData(inputSource);
+      keyEvent.repeat = inputSource.isPressed(keyEvent.key);
+      inputSource.press(keyEvent.key);
+      if (keyEvent.key in MODIFIER_NAME_LOOKUP) {
+        inputSource.setModState(keyEvent.key, true);
+      }
+
+      // Append a copy of |a| with keyUp subtype
+      state.inputsToCancel.push(new KeyUpAction(this.id, this));
+      keyEvent.update(state, inputSource);
+      lazy.event.sendKeyDown(keyEvent, win);
+
+      resolve();
+    });
+  }
+}
+
+/**
+ * Action equivalent to releasing a key on a keyboard.
+ *
+ * @param {string} id - Input source ID.
+ * @param {string} value - Key character.
+ */
+class KeyUpAction extends KeyAction {
+  static subtype = "keyUp";
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} with ${this.id} ${this.value}`
+    );
+    return new Promise(resolve => {
+      const keyEvent = this.getEventData(inputSource);
+      if (!inputSource.isPressed(keyEvent.key)) {
+        resolve();
+        return;
+      }
+      if (keyEvent.key in MODIFIER_NAME_LOOKUP) {
+        inputSource.setModState(keyEvent.key, false);
+      }
+      inputSource.release(keyEvent.key);
+      keyEvent.update(state, inputSource);
+
+      lazy.event.sendKeyUp(keyEvent, win);
+      resolve();
+    });
+  }
+}
+
+/**
+ * Action associated with a pointer input device
+ *
+ * @param {string} id - Input source ID.
+ * @param {object} options - Named arguments.
+ * @param {number=} options.width - Pointer width in pixels.
+ * @param {number=} options.height - Pointer height in pixels.
+ * @param {number=} options.pressure - Pointer pressure.
+ * @param {number=} options.tangentialPressure - Pointer tangential pressure.
+ * @param {number=} options.tiltX - Pointer X tilt angle.
+ * @param {number=} options.tiltX - Pointer Y tilt angle.
+ * @param {number=} options.twist - Pointer twist angle.
+ * @param {number=} options.altitudeAngle - Pointer altitude angle.
+ * @param {number=} options.azimuthAngle - Pointer azimuth angle.
+ */
+class PointerAction extends Action {
+  static type = "pointer";
+
+  constructor(id, options) {
+    super(id);
+    const {
+      width,
+      height,
+      pressure,
+      tangentialPressure,
+      tiltX,
+      tiltY,
+      twist,
+      altitudeAngle,
+      azimuthAngle,
+    } = options;
+    this.width = width;
+    this.height = height;
+    this.pressure = pressure;
+    this.tangentialPressure = tangentialPressure;
+    this.tiltX = tiltX;
+    this.tiltY = tiltY;
+    this.twist = twist;
+    this.altitudeAngle = altitudeAngle;
+    this.azimuthAngle = azimuthAngle;
+  }
+
+  /**
+   * Validate properties common to all pointer types
+   *
+   * @param {object} actionItem - Object representing a single action.
+   */
+  static validateCommon(actionItem) {
+    const {
+      width,
+      height,
+      pressure,
+      tangentialPressure,
+      tiltX,
+      tiltY,
+      twist,
+      altitudeAngle,
+      azimuthAngle,
+    } = actionItem;
+    if (width !== undefined) {
+      lazy.assert.positiveInteger(
+        width,
+        lazy.pprint`Expected 'width' (${width}) to be >= 0`
+      );
+    }
+    if (height !== undefined) {
+      lazy.assert.positiveInteger(
+        height,
+        lazy.pprint`Expected 'height' (${height}) to be >= 0`
+      );
+    }
+    if (pressure !== undefined) {
+      lazy.assert.numberInRange(
+        pressure,
+        [0, 1],
+        lazy.pprint`Expected 'pressure' (${pressure}) to be in range 0 to 1`
+      );
+    }
+    if (tangentialPressure !== undefined) {
+      lazy.assert.numberInRange(
+        tangentialPressure,
+        [-1, 1],
+        lazy.pprint`Expected 'tangentialPressure' (${tangentialPressure}) to be in range -1 to 1`
+      );
+    }
+    if (tiltX !== undefined) {
+      lazy.assert.integerInRange(
+        tiltX,
+        [-90, 90],
+        lazy.pprint`Expected 'tiltX' (${tiltX}) to be in range -90 to 90`
+      );
+    }
+    if (tiltY !== undefined) {
+      lazy.assert.integerInRange(
+        tiltY,
+        [-90, 90],
+        lazy.pprint`Expected 'tiltY' (${tiltY}) to be in range -90 to 90`
+      );
+    }
+    if (twist !== undefined) {
+      lazy.assert.integerInRange(
+        twist,
+        [0, 359],
+        lazy.pprint`Expected 'twist' (${twist}) to be in range 0 to 359`
+      );
+    }
+    if (altitudeAngle !== undefined) {
+      lazy.assert.numberInRange(
+        altitudeAngle,
+        [0, Math.PI / 2],
+        lazy.pprint`Expected 'altitudeAngle' (${altitudeAngle}) to be in range 0 to ${
+          Math.PI / 2
+        }`
+      );
+    }
+    if (azimuthAngle !== undefined) {
+      lazy.assert.numberInRange(
+        azimuthAngle,
+        [0, 2 * Math.PI],
+        lazy.pprint`Expected 'azimuthAngle' (${azimuthAngle}) to be in range 0 to ${
+          2 * Math.PI
+        }`
+      );
+    }
+    return {
+      width,
+      height,
+      pressure,
+      tangentialPressure,
+      tiltX,
+      tiltY,
+      twist,
+      altitudeAngle,
+      azimuthAngle,
+    };
+  }
+}
+
+/**
+ * Action associated with a pointer input device being depressed.
+ *
+ * @param {string} id - Input source ID.
+ * @param {object} options - Named arguments.
+ * @param {number} options.button - Button being pressed. For devices without buttons (e.g. touch), this should be 0.
+ * @param {number=} options.width - Pointer width in pixels.
+ * @param {number=} options.height - Pointer height in pixels.
+ * @param {number=} options.pressure - Pointer pressure.
+ * @param {number=} options.tangentialPressure - Pointer tangential pressure.
+ * @param {number=} options.tiltX - Pointer X tilt angle.
+ * @param {number=} options.tiltX - Pointer Y tilt angle.
+ * @param {number=} options.twist - Pointer twist angle.
+ * @param {number=} options.altitudeAngle - Pointer altitude angle.
+ * @param {number=} options.azimuthAngle - Pointer azimuth angle.
+ */
+class PointerDownAction extends PointerAction {
+  static subtype = "pointerDown";
+
+  constructor(id, options) {
+    super(id, options);
+    const { button } = options;
+    this.button = button;
+  }
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} ${inputSource.pointer.type} with id: ${this.id} button: ${this.button}`
+    );
+    return new Promise(resolve => {
+      if (inputSource.isPressed(this.button)) {
+        resolve();
+        return;
+      }
+
+      inputSource.press(this.button);
+      // Append a copy of |a| with pointerUp subtype
+      state.inputsToCancel.push(new PointerUpAction(this.id, this));
+      inputSource.pointer.pointerDown(state, inputSource, this, win);
+      resolve();
+    });
+  }
+
+  static fromJSON(id, actionItem) {
+    const props = PointerAction.validateCommon(actionItem);
+    const { button } = actionItem;
+    lazy.assert.positiveInteger(
+      button,
+      lazy.pprint`Expected 'button' (${button}) to be >= 0`
+    );
+    props.button = button;
+    return new this(id, props);
+  }
+}
+
+/**
+ * Action associated with a pointer input device being released.
+ *
+ * @param {string} id - Input source ID.
+ * @param {object} options - Named arguments.
+ * @param {number} options.button - Button being released. For devices without buttons (e.g. touch), this should be 0.
+ * @param {number=} options.width - Pointer width in pixels.
+ * @param {number=} options.height - Pointer height in pixels.
+ * @param {number=} options.pressure - Pointer pressure.
+ * @param {number=} options.tangentialPressure - Pointer tangential pressure.
+ * @param {number=} options.tiltX - Pointer X tilt angle.
+ * @param {number=} options.tiltX - Pointer Y tilt angle.
+ * @param {number=} options.twist - Pointer twist angle.
+ * @param {number=} options.altitudeAngle - Pointer altitude angle.
+ * @param {number=} options.azimuthAngle - Pointer azimuth angle.
+ */
+class PointerUpAction extends PointerAction {
+  static subtype = "pointerUp";
+
+  constructor(id, options) {
+    super(id, options);
+    const { button } = options;
+    this.button = button;
+  }
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} ${inputSource.pointer.type} with id: ${this.id} button: ${this.button}`
+    );
+    return new Promise(resolve => {
+      if (!inputSource.isPressed(this.button)) {
+        resolve();
+        return;
+      }
+
+      inputSource.release(this.button);
+      inputSource.pointer.pointerUp(state, inputSource, this, win);
+
+      resolve();
+    });
+  }
+
+  static fromJSON(id, actionItem) {
+    const props = PointerAction.validateCommon(actionItem);
+    const { button } = actionItem;
+    lazy.assert.positiveInteger(
+      button,
+      lazy.pprint`Expected 'button' (${button}) to be >= 0`
+    );
+    props.button = button;
+    return new this(id, props);
+  }
+}
+
+/**
+ * Action associated with a pointer input device being moved.
+ *
+ * @param {string} id - Input source ID.
+ * @param {object} options - Named arguments.
+ * @param {number=} options.width - Pointer width in pixels.
+ * @param {number=} options.height - Pointer height in pixels.
+ * @param {number=} options.pressure - Pointer pressure.
+ * @param {number=} options.tangentialPressure - Pointer tangential pressure.
+ * @param {number=} options.tiltX - Pointer X tilt angle.
+ * @param {number=} options.tiltX - Pointer Y tilt angle.
+ * @param {number=} options.twist - Pointer twist angle.
+ * @param {number=} options.altitudeAngle - Pointer altitude angle.
+ * @param {number=} options.azimuthAngle - Pointer azimuth angle.
+ * @param {number=} options.duration - Duration of move in ms.
+ * @param {Origin} options.origin - Origin of target coordinates.
+ * @param {number} options.x - X value of target coordinates.
+ * @param {number} options.y - Y value of target coordinates.
+ */
+class PointerMoveAction extends PointerAction {
+  static subtype = "pointerMove";
+  affectsWallClockTime = true;
+
+  constructor(id, options) {
+    super(id, options);
+    const { duration, origin, x, y } = options;
+    this.duration = duration;
+    this.origin = origin;
+    this.x = x;
+    this.y = y;
+  }
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} ${inputSource.pointer.type} with id: ${this.id} x: ${this.x} y: ${this.y}`
+    );
+    const target = this.origin.getTargetCoordinates(
+      state,
+      inputSource,
+      [this.x, this.y],
+      win
+    );
+
+    assertInViewPort(target, win);
+
+    return moveOverTime(
+      [[inputSource.x, inputSource.y]],
+      [target],
+      this.duration ?? tickDuration,
+      target => this.performPointerMoveStep(state, inputSource, target, win)
+    );
+  }
+
+  /**
+   * Perform one part of a pointer move corresponding to a specific emitted event.
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {Array<Array<number>>} targets - Array of [x, y] arrays
+   * specifying the viewport coordinates to move to.
+   * @param {WindowProxy} win - Current window global.
+   */
+  performPointerMoveStep(state, inputSource, targets, win) {
+    if (targets.length !== 1) {
+      throw new Error(
+        "PointerMoveAction.performPointerMoveStep requires a single target"
+      );
+    }
+    const target = targets[0];
+    lazy.logger.trace(
+      `PointerMoveAction.performPointerMoveStep ${JSON.stringify(target)}`
+    );
+    if (target[0] == inputSource.x && target[1] == inputSource.y) {
+      return;
+    }
+
+    inputSource.pointer.pointerMove(
+      state,
+      inputSource,
+      this,
+      target[0],
+      target[1],
+      win
+    );
+
+    inputSource.x = target[0];
+    inputSource.y = target[1];
+  }
+
+  static fromJSON(id, actionItem) {
+    const props = PointerAction.validateCommon(actionItem);
+    const { duration, origin, x, y } = actionItem;
+    if (duration !== undefined) {
+      lazy.assert.positiveInteger(
+        duration,
+        lazy.pprint`Expected 'duration' (${duration}) to be >= 0`
+      );
+    }
+    const originObject = Origin.fromJSON(origin);
+    lazy.assert.integer(x, lazy.pprint`Expected 'x' (${x}) to be an Integer`);
+    lazy.assert.integer(y, lazy.pprint`Expected 'y' (${y}) to be an Integer`);
+    props.duration = duration;
+    props.origin = originObject;
+    props.x = x;
+    props.y = y;
+    return new this(id, props);
+  }
+}
+
+/**
+ * Action associated with a wheel input device
+ *
+ */
+class WheelAction extends Action {
+  static type = "wheel";
+}
+
+/**
+ * Action associated with scrolling a scroll wheel
+ *
+ * @param {number} duration - Duration of scroll in ms.
+ * @param {Origin} origin - Origin of target coordinates.
+ * @param {number} x - X value of scroll coordinates.
+ * @param {number} y - Y value of scroll coordinates.
+ * @param {number} deltaX - Number of CSS pixels to scroll in X direction.
+ * @param {number} deltaY - Number of CSS pixels to scroll in Y direction
+ */
+class WheelScrollAction extends WheelAction {
+  static subtype = "scroll";
+  affectsWallClockTime = true;
+
+  constructor(id, { duration, origin, x, y, deltaX, deltaY }) {
+    super(id);
+    this.duration = duration;
+    this.origin = origin;
+    this.x = x;
+    this.y = y;
+    this.deltaX = deltaX;
+    this.deltaY = deltaY;
+  }
+
+  static fromJSON(id, actionItem) {
+    const { duration, origin, x, y, deltaX, deltaY } = actionItem;
+    if (duration !== undefined) {
+      lazy.assert.positiveInteger(
+        duration,
+        lazy.pprint`Expected 'duration' (${duration}) to be >= 0`
+      );
+    }
+    const originObject = Origin.fromJSON(origin);
+    lazy.assert.integer(x, lazy.pprint`Expected 'x' (${x}) to be an Integer`);
+    lazy.assert.integer(y, lazy.pprint`Expected 'y' (${y}) to be an Integer`);
+    lazy.assert.integer(
+      deltaX,
+      lazy.pprint`Expected 'deltaX' (${deltaX}) to be an Integer`
+    );
+    lazy.assert.integer(
+      deltaY,
+      lazy.pprint`Expected 'deltaY' (${deltaY}) to be an Integer`
+    );
+
+    return new this(id, {
+      duration,
+      origin: originObject,
+      x,
+      y,
+      deltaX,
+      deltaY,
+    });
+  }
+
+  async dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} with id: ${this.id} deltaX: ${this.deltaX} deltaY: ${this.deltaY}`
+    );
+    const scrollCoordinates = this.origin.getTargetCoordinates(
+      state,
+      inputSource,
+      [this.x, this.y],
+      win
+    );
+    assertInViewPort(scrollCoordinates, win);
+
+    const startX = 0;
+    const startY = 0;
+    // This is an action-local state that holds the amount of scroll completed
+    const deltaPosition = [startX, startY];
+    await moveOverTime(
+      [[startX, startY]],
+      [[this.deltaX, this.deltaY]],
+      this.duration ?? tickDuration,
+      deltaTarget =>
+        this.performOneWheelScroll(
+          scrollCoordinates,
+          deltaPosition,
+          deltaTarget,
+          win
+        )
+    );
+  }
+
+  /**
+   * Perform one part of a wheel scroll corresponding to a specific emitted event.
+   *
+   * @param {Array<number>} scrollCoordinates - [x, y] viewport coordinates of the scroll.
+   * @param {Array<number>} deltaPosition - [deltaX, deltaY] coordinates of the scroll before this event.
+   * @param {Array<Array<number>>} deltaTargets - Array of [deltaX, deltaY] coordinates to scroll to.
+   * @param {WindowProxy} win - Current window global.
+   */
+  performOneWheelScroll(scrollCoordinates, deltaPosition, deltaTargets, win) {
+    if (deltaTargets.length !== 1) {
+      throw new Error("Can only scroll one wheel at a time");
+    }
+    if (deltaPosition[0] == this.deltaX && deltaPosition[1] == this.deltaY) {
+      return;
+    }
+    const deltaTarget = deltaTargets[0];
+    const deltaX = deltaTarget[0] - deltaPosition[0];
+    const deltaY = deltaTarget[1] - deltaPosition[1];
+    const eventData = new WheelEventData({
+      deltaX,
+      deltaY,
+      deltaZ: 0,
+    });
+    lazy.event.synthesizeWheelAtPoint(
+      scrollCoordinates[0],
+      scrollCoordinates[1],
+      eventData,
+      win
+    );
+
+    // Update the current scroll position for the caller
+    deltaPosition[0] = deltaTarget[0];
+    deltaPosition[1] = deltaTarget[1];
+  }
+}
+
+/**
+ * Group of actions representing behaviour of all touch pointers during a single tick.
+ *
+ * For touch pointers, we need to call into the platform once with all
+ * the actions so that they are regarded as simultaneous. This means
+ * we don't use the `dispatch()` method on the underlying actions, but
+ * instead use one on this group object.
+ */
+class TouchActionGroup {
+  static type = null;
+
+  constructor() {
+    this.type = this.constructor.type;
+    this.actions = new Map();
+  }
+
+  static forType(type) {
+    const cls = touchActionGroupTypes.get(type);
+    return new cls();
+  }
+
+  /**
+   * Add action corresponding to a specific pointer to the group.
+   *
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {Action} action - Action to add to the group
+   */
+  addPointer(inputSource, action) {
+    if (action.subtype !== this.type) {
+      throw new Error(
+        `Added action of unexpected type, got ${action.subtype}, expected ${this.type}`
+      );
+    }
+    this.actions.set(action.id, [inputSource, action]);
+  }
+
+  /**
+   * Dispatch the action group to the relevant window.
+   *
+   * This is overridden by subclasses to implement the type-specific
+   * dispatch of the action.
+   *
+   * @param {State} state - Actions state.
+   * @param {null} inputSource
+   *     This is always null; the argument only exists for compatibility
+   *     with {@link Action.dispatch}.
+   * @param {number} tickDuration - Length of the current tick, in ms.
+   * @param {WindowProxy} win - Current window global.
+   * @returns {Promise} - Promise that is resolved once the action is complete.
+   */
+  dispatch(state, inputSource, tickDuration, win) {
+    throw new Error(
+      "TouchActionGroup subclass missing dispatch implementation"
+    );
+  }
+}
+
+/**
+ * Group of actions representing behaviour of all touch pointers
+ * depressed during a single tick.
+ */
+class PointerDownTouchActionGroup extends TouchActionGroup {
+  static type = "pointerDown";
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} with ${Array.from(
+        this.actions.values()
+      ).map(x => x[1].id)}`
+    );
+    return new Promise(resolve => {
+      if (inputSource !== null) {
+        throw new Error(
+          "Expected null inputSource for PointerDownTouchActionGroup.dispatch"
+        );
+      }
+
+      // Only include pointers that are not already depressed
+      const actions = Array.from(this.actions.values()).filter(
+        ([actionInputSource, action]) =>
+          !actionInputSource.isPressed(action.button)
+      );
+      if (actions.length) {
+        const eventData = new MultiTouchEventData("touchstart");
+        for (const [actionInputSource, action] of actions) {
+          // Skip if already pressed
+          eventData.addPointerEventData(actionInputSource, action);
+          actionInputSource.press(action.button);
+          // Append a copy of |action| with pointerUp subtype
+          state.inputsToCancel.push(new PointerUpAction(action.id, action));
+          eventData.update(state, actionInputSource);
+        }
+
+        // Touch start events must include all depressed touch pointers
+        for (const [id, pointerInputSource] of state.inputSourcesByType(
+          "pointer"
+        )) {
+          if (
+            pointerInputSource.pointer.type === "touch" &&
+            !this.actions.has(id) &&
+            pointerInputSource.isPressed(0)
+          ) {
+            eventData.addPointerEventData(pointerInputSource, {});
+            eventData.update(state, pointerInputSource);
+          }
+        }
+        lazy.event.synthesizeMultiTouch(eventData, win);
+      }
+      resolve();
+    });
+  }
+}
+
+/**
+ * Group of actions representing behaviour of all touch pointers
+ * released during a single tick.
+ */
+class PointerUpTouchActionGroup extends TouchActionGroup {
+  static type = "pointerUp";
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} with ${Array.from(
+        this.actions.values()
+      ).map(x => x[1].id)}`
+    );
+    return new Promise(resolve => {
+      if (inputSource !== null) {
+        throw new Error(
+          "Expected null inputSource for PointerUpTouchActionGroup.dispatch"
+        );
+      }
+
+      // Only include pointers that are not already depressed
+      const actions = Array.from(this.actions.values()).filter(
+        ([actionInputSource, action]) =>
+          actionInputSource.isPressed(action.button)
+      );
+      if (actions.length) {
+        const eventData = new MultiTouchEventData("touchend");
+        for (const [actionInputSource, action] of actions) {
+          eventData.addPointerEventData(actionInputSource, action);
+          actionInputSource.release(action.button);
+          eventData.update(state, actionInputSource);
+        }
+        lazy.event.synthesizeMultiTouch(eventData, win);
+      }
+      resolve();
+    });
+  }
+}
+
+/**
+ * Group of actions representing behaviour of all touch pointers
+ * moved during a single tick.
+ */
+class PointerMoveTouchActionGroup extends TouchActionGroup {
+  static type = "pointerMove";
+
+  dispatch(state, inputSource, tickDuration, win) {
+    lazy.logger.trace(
+      `Dispatch ${this.constructor.name} with ${Array.from(this.actions).map(
+        x => x[1].id
+      )}`
+    );
+    if (inputSource !== null) {
+      throw new Error(
+        "Expected null inputSource for PointerMoveTouchActionGroup.dispatch"
+      );
+    }
+
+    let startCoords = [];
+    let targetCoords = [];
+    for (const [actionInputSource, action] of this.actions.values()) {
+      const target = action.origin.getTargetCoordinates(
+        state,
+        actionInputSource,
+        [action.x, action.y],
+        win
+      );
+      assertInViewPort(target, win);
+      startCoords.push([actionInputSource.x, actionInputSource.y]);
+      targetCoords.push(target);
+    }
+    // Touch move events must include all depressed touch pointers, even if they are static
+    // This can end up generating pointermove events even for static pointers, but Gecko
+    // seems to generate a lot of pointermove events anyway, so this seems like the lesser
+    // problem.
+    // See https://bugzilla.mozilla.org/show_bug.cgi?id=1779206
+    const staticTouchPointers = [];
+    for (const [id, pointerInputSource] of state.inputSourcesByType(
+      "pointer"
+    )) {
+      if (
+        pointerInputSource.pointer.type === "touch" &&
+        !this.actions.has(id) &&
+        pointerInputSource.isPressed(0)
+      ) {
+        staticTouchPointers.push(pointerInputSource);
+      }
+    }
+
+    return moveOverTime(
+      startCoords,
+      targetCoords,
+      this.duration ?? tickDuration,
+      currentTargetCoords =>
+        this.performPointerMoveStep(
+          state,
+          staticTouchPointers,
+          currentTargetCoords,
+          win
+        )
+    );
+  }
+
+  /**
+   * Perform one part of a pointer move corresponding to a specific emitted event.
+   *
+   * @param {State} state - Actions state.
+   * @param {Array.<PointerInputSource>} staticTouchPointers
+   *      Array of PointerInputSource objects for pointers that aren't involved in
+   *      the touch move.
+   * @param {Array.<Array>} targetCoords
+   *      Array of [x, y] arrays specifying the viewport coordinates to move to.
+   * @param {WindowProxy} win - Current window global.
+   */
+  performPointerMoveStep(state, staticTouchPointers, targetCoords, win) {
+    if (targetCoords.length !== this.actions.size) {
+      throw new Error("Expected one target per pointer");
+    }
+
+    const perPointerData = Array.from(this.actions.values()).map(
+      ([inputSource, action], i) => {
+        const target = targetCoords[i];
+        return [inputSource, action, target];
+      }
+    );
+    const reachedTarget = perPointerData.every(
+      ([inputSource, action, target]) =>
+        target[0] === inputSource.x && target[1] === inputSource.y
+    );
+    if (reachedTarget) {
+      return;
+    }
+
+    const eventData = new MultiTouchEventData("touchmove");
+    for (const [inputSource, action, target] of perPointerData) {
+      inputSource.x = target[0];
+      inputSource.y = target[1];
+      eventData.addPointerEventData(inputSource, action);
+      eventData.update(state, inputSource);
+    }
+    for (const inputSource of staticTouchPointers) {
+      eventData.addPointerEventData(inputSource, {});
+      eventData.update(state, inputSource);
+    }
+    lazy.event.synthesizeMultiTouch(eventData, win);
+  }
+}
+
+const touchActionGroupTypes = new Map();
+for (const cls of [
+  PointerDownTouchActionGroup,
+  PointerUpTouchActionGroup,
+  PointerMoveTouchActionGroup,
+]) {
+  touchActionGroupTypes.set(cls.type, cls);
+}
+
+/**
+ * Split a transition from startCoord to targetCoord linearly over duration.
+ *
+ * startCoords and targetCoords are lists of [x,y] positions in some space
+ * (e.g. screen position or scroll delta). This function will linearly
+ * interpolate intermediate positions, sending out roughly one event
+ * per frame to simulate moving between startCoord and targetCoord in
+ * a time of tickDuration milliseconds. The callback function is
+ * responsible for actually emitting the event, given the current
+ * position in the coordinate space.
+ *
+ * @param {Array.<Array>} startCoords
+ *    Array of initial [x, y] coordinates for each input source involved
+ *    in the move.
+ * @param {Array.<Array>} targetCoords
+ *    Array of target [x, y] coordinates for each input source involved
+ *    in the move.
+ * @param {number} duration - Time in ms the move will take.
+ * @param {Function} callback
+ *    Function that actually performs the move. This takes a single parameter
+ *    which is an array of [x, y] coordinates corresponding to the move
+ *    targets.
+ */
+async function moveOverTime(startCoords, targetCoords, duration, callback) {
+  lazy.logger.trace(
+    `moveOverTime start: ${startCoords} target: ${targetCoords} duration: ${duration}`
+  );
+
+  if (startCoords.length !== targetCoords.length) {
+    throw new Error(
+      "Expected equal number of start coordinates and target coordinates"
+    );
+  }
+
+  if (
+    !startCoords.every(item => item.length == 2) ||
+    !targetCoords.every(item => item.length == 2)
+  ) {
+    throw new Error(
+      "Expected start coordinates target coordinates to be Array of multiple [x,y] coordinates."
+    );
+  }
+
+  if (duration === 0) {
+    // transition to destination in one step
+    callback(targetCoords);
+    return;
+  }
+
+  const timer = Cc["@mozilla.org/timer;1"].createInstance(Ci.nsITimer);
+  // interval between transitions in ms, based on common vsync
+  const fps60 = 17;
+
+  const distances = targetCoords.map((targetCoord, i) => {
+    const startCoord = startCoords[i];
+    return [targetCoord[0] - startCoord[0], targetCoord[1] - startCoord[1]];
+  });
+  const ONE_SHOT = Ci.nsITimer.TYPE_ONE_SHOT;
+  const startTime = Date.now();
+  const transitions = (async () => {
+    // wait |fps60| ms before performing first incremental transition
+    await new Promise(resolveTimer =>
+      timer.initWithCallback(resolveTimer, fps60, ONE_SHOT)
+    );
+
+    let durationRatio = Math.floor(Date.now() - startTime) / duration;
+    const epsilon = fps60 / duration / 10;
+    while (1 - durationRatio > epsilon) {
+      const intermediateTargets = startCoords.map((startCoord, i) => {
+        let distance = distances[i];
+        return [
+          Math.floor(durationRatio * distance[0] + startCoord[0]),
+          Math.floor(durationRatio * distance[1] + startCoord[1]),
+        ];
+      });
+      callback(intermediateTargets);
+      // wait |fps60| ms before performing next transition
+      await new Promise(resolveTimer =>
+        timer.initWithCallback(resolveTimer, fps60, ONE_SHOT)
+      );
+
+      durationRatio = Math.floor(Date.now() - startTime) / duration;
+    }
+  })();
+
+  await transitions;
+
+  // perform last transitionafter all incremental moves are resolved and
+  // durationRatio is close enough to 1
+  callback(targetCoords);
+}
+
+const actionTypes = new Map();
+for (const cls of [
+  KeyDownAction,
+  KeyUpAction,
+  PauseAction,
+  PointerDownAction,
+  PointerUpAction,
+  PointerMoveAction,
+  WheelScrollAction,
+]) {
+  if (!actionTypes.has(cls.type)) {
+    actionTypes.set(cls.type, new Map());
+  }
+  actionTypes.get(cls.type).set(cls.subtype, cls);
+}
+
+/**
+ * Implementation of the behaviour of a specific type of pointer
+ */
+class Pointer {
+  /** Type of pointer */
+  static type = null;
+
+  constructor(id) {
+    this.id = id;
+    this.type = this.constructor.type;
+  }
+
+  /**
+   * Implementation of depressing the pointer.
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {Action} action - The Action object invoking the pointer
+   * @param {WindowProxy} win - Current window global.
+   */
+  pointerDown(state, inputSource, action, win) {
+    throw new Error(`Unimplemented pointerDown for pointerType ${this.type}`);
+  }
+
+  /**
+   * Implementation of releasing the pointer.
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {Action} action - The Action object invoking the pointer
+   * @param {WindowProxy} win - Current window global.
+   */
+  pointerUp(state, inputSource, action, win) {
+    throw new Error(`Unimplemented pointerUp for pointerType ${this.type}`);
+  }
+
+  /**
+   * Implementation of moving the pointer.
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   * @param {number} targetX - Target X coordinate of the pointer move
+   * @param {number} targetY - Target Y coordinate of the pointer move
+   * @param {WindowProxy} win - Current window global.
+   */
+  pointerMove(state, inputSource, targetX, targetY, win) {
+    throw new Error(`Unimplemented pointerMove for pointerType ${this.type}`);
+  }
+
+  /**
+   * @param {number} pointerId - Numeric pointer id.
+   * @param {string} pointerType - Pointer type.
+   * @returns {Pointer} - The pointer class for {@link pointerType}
+   *
+   * @throws {InvalidArgumentError} - If {@link pointerType} is not a valid pointer type.
+   */
+  static fromJSON(pointerId, pointerType) {
+    const cls = pointerTypes.get(pointerType);
+    if (cls === undefined) {
+      throw new lazy.error.InvalidArgumentError(
+        `Unknown pointerType: ${pointerType}`
+      );
+    }
+    return new cls(pointerId);
+  }
+}
+
+/**
+ * Implementation of mouse pointer behaviour
+ */
+class MousePointer extends Pointer {
+  static type = "mouse";
+
+  pointerDown(state, inputSource, action, win) {
+    const mouseEvent = new MouseEventData("mousedown", {
+      button: action.button,
+    });
+    mouseEvent.update(state, inputSource);
+    if (mouseEvent.ctrlKey) {
+      if (lazy.AppInfo.isMac) {
+        mouseEvent.button = 2;
+        lazy.event.DoubleClickTracker.resetClick();
+      }
+    } else if (lazy.event.DoubleClickTracker.isClicked()) {
+      mouseEvent.clickCount = 2;
+    }
+    lazy.event.synthesizeMouseAtPoint(
+      inputSource.x,
+      inputSource.y,
+      mouseEvent,
+      win
+    );
+    if (
+      lazy.event.MouseButton.isSecondary(mouseEvent.button) ||
+      (mouseEvent.ctrlKey && lazy.AppInfo.isMac)
+    ) {
+      const contextMenuEvent = { ...mouseEvent, type: "contextmenu" };
+      lazy.event.synthesizeMouseAtPoint(
+        inputSource.x,
+        inputSource.y,
+        contextMenuEvent,
+        win
+      );
+    }
+  }
+
+  pointerUp(state, inputSource, action, win) {
+    const mouseEvent = new MouseEventData("mouseup", {
+      button: action.button,
+    });
+    mouseEvent.update(state, inputSource);
+    if (lazy.event.DoubleClickTracker.isClicked()) {
+      mouseEvent.clickCount = 2;
+    }
+    lazy.event.synthesizeMouseAtPoint(
+      inputSource.x,
+      inputSource.y,
+      mouseEvent,
+      win
+    );
+  }
+
+  pointerMove(state, inputSource, action, targetX, targetY, win) {
+    const mouseEvent = new MouseEventData("mousemove");
+    mouseEvent.update(state, inputSource);
+    lazy.event.synthesizeMouseAtPoint(targetX, targetY, mouseEvent, win);
+  }
+}
+
+/*
+ * The implementation here is empty because touch actions have to go via the
+ * TouchActionGroup. So if we end up calling these methods that's a bug in
+ * the code.
+ */
+class TouchPointer extends Pointer {
+  static type = "touch";
+}
+
+/*
+ * Placeholder for future pen type pointer support.
+ */
+class PenPointer extends Pointer {
+  static type = "pen";
+}
+
+const pointerTypes = new Map();
+for (const cls of [MousePointer, TouchPointer, PenPointer]) {
+  pointerTypes.set(cls.type, cls);
+}
+
+/**
+ * Represents a series of ticks, specifying which actions to perform at
+ * each tick.
+ */
+action.Chain = class extends Array {
+  toString() {
+    return `[chain ${super.toString()}]`;
+  }
+
+  /**
+   * Dispatch the action chain to the relevant window.
+   *
+   * @param {State} state - Actions state.
+   * @param {WindowProxy} win - Current window global.
+   * @returns {Promise} - Promise that is resolved once the action
+   * chain is complete.
+   */
+  dispatch(state, win) {
+    let i = 1;
+    const chainEvents = (async () => {
+      for (const tickActions of this) {
+        lazy.logger.trace(`Dispatching tick ${i++}/${this.length}`);
+        await tickActions.dispatch(state, win);
+      }
+    })();
+    return chainEvents;
+  }
+
+  /**
+   * @param {State} state - Actions state.
+   * @param {Array.<object>} actions - Array of objects that each
+   * represent an action sequence.
+   * @returns {action.Chain} - Object that allows dispatching a chain
+   * of actions.
+   * @throws {InvalidArgumentError} - If actions doesn't correspond to
+   * a valid action chain.
+   */
+  static fromJSON(state, actions) {
+    lazy.assert.array(
+      actions,
+      lazy.pprint`Expected 'actions' to be an array, got ${actions}`
+    );
+
+    const actionsByTick = new this();
+    for (const actionSequence of actions) {
+      const inputSourceActions = Sequence.fromJSON(state, actionSequence);
+      for (let i = 0; i < inputSourceActions.length; i++) {
+        // new tick
+        if (actionsByTick.length < i + 1) {
+          actionsByTick.push(new TickActions());
+        }
+        actionsByTick[i].push(inputSourceActions[i]);
+      }
+    }
+    return actionsByTick;
+  }
+};
+
+/**
+ * Represents the action for each input device to perform in a single tick.
+ */
+class TickActions extends Array {
+  /**
+   * Tick duration in milliseconds.
+   *
+   * @returns {number} - Longest action duration in |tickActions| if any, or 0.
+   */
+  getDuration() {
+    let max = 0;
+    for (const action of this) {
+      if (action.affectsWallClockTime && action.duration) {
+        max = Math.max(action.duration, max);
+      }
+    }
+    return max;
+  }
+
+  /**
+   * Dispatch sequence of actions for this tick.
+   *
+   * This creates a Promise for one tick that resolves once the Promise
+   * for each tick-action is resolved, which takes at least |tickDuration|
+   * milliseconds.  The resolved set of events for each tick is followed by
+   * firing of pending DOM events.
+   *
+   * Note that the tick-actions are dispatched in order, but they may have
+   * different durations and therefore may not end in the same order.
+   *
+   * @param {State} state - Actions state.
+   * @param {WindowProxy} win - Current window global.
+   *
+   * @returns {Promise} - Promise that resolves when tick is complete.
+   */
+  dispatch(state, win) {
+    const tickDuration = this.getDuration();
+    const tickActions = this.groupTickActions(state);
+    const pendingEvents = tickActions.map(([inputSource, action]) =>
+      action.dispatch(state, inputSource, tickDuration, win)
+    );
+    return Promise.all(pendingEvents);
+  }
+
+  /**
+   * Group together actions from input sources that have to be
+   * dispatched together.
+   *
+   * The actual transformation here is to group together touch pointer
+   * actions into {@link TouchActionGroup} instances.
+   *
+   * @param {State} state - Actions state.
+   * @returns {Array.<Array.<InputSource?,Action|TouchActionGroup>>}
+   *    Array of pairs. For ungrouped actions each element is
+   *    [InputSource, Action] For touch actions there are multiple
+   *    pointers handled at once, so the first item of the array is
+   *    null, meaning the group has to perform its own handling of the
+   *    relevant state, and the second element is a TouuchActionGroup.
+   */
+  groupTickActions(state) {
+    const touchActions = new Map();
+    const actions = [];
+    for (const action of this) {
+      const inputSource = state.getInputSource(action.id);
+      if (action.type == "pointer" && inputSource.pointer.type === "touch") {
+        lazy.logger.debug(
+          `Grouping action ${action.type} ${action.id} ${action.subtype}`
+        );
+        let group = touchActions.get(action.subtype);
+        if (group === undefined) {
+          group = TouchActionGroup.forType(action.subtype);
+          touchActions.set(action.subtype, group);
+          actions.push([null, group]);
+        }
+        group.addPointer(inputSource, action);
+      } else {
+        actions.push([inputSource, action]);
+      }
+    }
+    return actions;
+  }
+}
+
+/**
+ * Represents one input source action sequence; this is essentially an
+ * |Array.<Action>|.
+ *
+ * This is a temporary object only used when constructing an {@link
+ * action.Chain}.
+ */
+class Sequence extends Array {
+  toString() {
+    return `[sequence ${super.toString()}]`;
+  }
+
+  /**
+   * @param {State} state - Actions state.
+   * @param {object} actionSequence
+   *     Protocol representation of the actions for a specific input source.
+   * @returns {Array.<Array>} - Array of [InputSource?,Action|TouchActionGroup]
+   */
+  static fromJSON(state, actionSequence) {
+    // used here to validate 'type' in addition to InputSource type below
+    const { id, type, actions } = actionSequence;
+
+    // type and id get validated in InputSource.fromJSON
+    lazy.assert.array(
+      actions,
+      "Expected 'actionSequence.actions' to be an array, " +
+        lazy.pprint`got ${actionSequence.actions}`
+    );
+
+    // This sets the input state in the global state map, if it's new
+    InputSource.fromJSON(state, actionSequence);
+
+    const sequence = new this();
+    for (const actionItem of actions) {
+      sequence.push(Action.fromJSON(type, id, actionItem));
+    }
+
+    return sequence;
+  }
+}
+
+/**
+ * Representation of an input event
+ */
+class InputEventData {
+  constructor() {
+    this.altKey = false;
+    this.shiftKey = false;
+    this.ctrlKey = false;
+    this.metaKey = false;
+  }
+
+  /**
+   * Update the input data based on global and input state
+   *
+   * @param {State} state - Actions state.
+   * @param {InputSource} inputSource - State of the current input device.
+   */
+  update(state, inputSource) {}
+
+  toString() {
+    return `${this.constructor.name} ${JSON.stringify(this)}`;
+  }
+}
+
+/**
+ * Representation of a key input event
+ *
+ * @param {string} rawKey - Key value.
+ */
+class KeyEventData extends InputEventData {
+  constructor(rawKey) {
+    super();
+    const { key, code, location, printable } = lazy.keyData.getData(rawKey);
+    this.key = key;
+    this.code = code;
+    this.location = location;
+    this.printable = printable;
+    this.repeat = false;
+    // keyCode will be computed by event.sendKeyDown
+  }
+
+  update(state, inputSource) {
+    this.altKey = inputSource.alt;
+    this.shiftKey = inputSource.shift;
+    this.ctrlKey = inputSource.ctrl;
+    this.metaKey = inputSource.meta;
+  }
+}
+
+/**
+ * Representation of a pointer input event
+ *
+ * @param {string} type - Event type.
+ */
+class PointerEventData extends InputEventData {
+  constructor(type) {
+    super();
+    this.type = type;
+    this.buttons = 0;
+  }
+
+  update(state, inputSource) {
+    // set modifier properties based on whether any corresponding keys are
+    // pressed on any key input source
+    for (const [, otherInputSource] of state.inputSourcesByType("key")) {
+      this.altKey = otherInputSource.alt || this.altKey;
+      this.ctrlKey = otherInputSource.ctrl || this.ctrlKey;
+      this.metaKey = otherInputSource.meta || this.metaKey;
+      this.shiftKey = otherInputSource.shift || this.shiftKey;
+    }
+    const allButtons = Array.from(inputSource.pressed);
+    this.buttons = allButtons.reduce((a, i) => a + Math.pow(2, i), 0);
+  }
+}
+
+/**
+ * Representation of a mouse input event
+ *
+ * @param {string} type - Event type.
+ * @param {number} button - Mouse button number.
+ */
+class MouseEventData extends PointerEventData {
+  constructor(type, options = {}) {
+    super(type);
+    const { button = 0 } = options;
+    lazy.assert.positiveInteger(button);
+    this.button = button;
+    this.buttons = 0;
+  }
+
+  update(state, inputSource) {
+    super.update(state, inputSource);
+    this.id = inputSource.pointer.id;
+  }
+}
+
+/**
+ * Representation of a wheel scroll event
+ *
+ * @param {object} options - Named arguments.
+ * @param {number} options.deltaX - Scroll delta X.
+ * @param {number} options.deltaY - Scroll delta Y.
+ * @param {number} options.deltaY - Scroll delta Z (current always 0).
+ * @param {number=} deltaMode - Scroll delta mode (current always 0).
+ */
+class WheelEventData extends InputEventData {
+  constructor(options) {
+    super();
+    const { deltaX, deltaY, deltaZ, deltaMode = 0 } = options;
+    this.deltaX = deltaX;
+    this.deltaY = deltaY;
+    this.deltaZ = deltaZ;
+    this.deltaMode = deltaMode;
+  }
+}
+
+/**
+ * Representation of a multitouch event
+ *
+ * @param {string} type - Event type.
+ */
+class MultiTouchEventData extends PointerEventData {
+  #setGlobalState;
+
+  constructor(type) {
+    super(type);
+    this.id = [];
+    this.x = [];
+    this.y = [];
+    this.rx = [];
+    this.ry = [];
+    this.angle = [];
+    this.force = [];
+    this.tiltx = [];
+    this.tilty = [];
+    this.twist = [];
+    this.#setGlobalState = false;
+  }
+
+  /**
+   * Add the data from one pointer to the event.
+   *
+   * @param {InputSource} inputSource - State of the pointer.
+   * @param {PointerAction} action - Action for the pointer.
+   */
+  addPointerEventData(inputSource, action) {
+    this.x.push(inputSource.x);
+    this.y.push(inputSource.y);
+    this.id.push(inputSource.pointer.id);
+    this.rx.push(action.width || 1);
+    this.ry.push(action.height || 1);
+    this.angle.push(0);
+    this.force.push(action.pressure || (this.type === "touchend" ? 0 : 1));
+    this.tiltx.push(action.tiltX || 0);
+    this.tilty.push(action.tiltY || 0);
+    this.twist.push(action.twist || 0);
+  }
+
+  update(state, inputSource) {
+    // We call update once per input source, but only want to update global state once.
+    // Instead of introducing a new lifecycle method, or changing the API to allow multiple
+    // input sources in a single call, use a small bit of state to avoid repeatedly setting
+    // global state.
+    if (!this.#setGlobalState) {
+      // set modifier properties based on whether any corresponding keys are
+      // pressed on any key input source
+      for (const [, otherInputSource] of state.inputSourcesByType("key")) {
+        this.altKey = otherInputSource.alt || this.altKey;
+        this.ctrlKey = otherInputSource.ctrl || this.ctrlKey;
+        this.metaKey = otherInputSource.meta || this.metaKey;
+        this.shiftKey = otherInputSource.shift || this.shiftKey;
+      }
+      this.#setGlobalState = true;
+    }
+
+    // Note that we currently emit Touch events that don't have this property
+    // but pointer events should have a `buttons` property, so we'll compute it
+    // anyway.
+    const allButtons = Array.from(inputSource.pressed);
+    this.buttons =
+      this.buttons | allButtons.reduce((a, i) => a + Math.pow(2, i), 0);
+  }
+}
+
+// helpers
+
+/**
+ * Assert that target is in the viewport of win.
+ *
+ * @param {Array.<number>} target - [x, y] coordinates of target
+ * relative to viewport.
+ * @param {WindowProxy} win - target window.
+ * @throws {MoveTargetOutOfBoundsError} - If target is outside the
+ * viewport.
+ */
+function assertInViewPort(target, win) {
+  const [x, y] = target;
+  lazy.assert.number(x, `Expected x to be finite number`);
+  lazy.assert.number(y, `Expected y to be finite number`);
+  // Viewport includes scrollbars if rendered.
+  if (x < 0 || y < 0 || x > win.innerWidth || y > win.innerHeight) {
+    throw new lazy.error.MoveTargetOutOfBoundsError(
+      `(${x}, ${y}) is out of bounds of viewport ` +
+        `width (${win.innerWidth}) ` +
+        `and height (${win.innerHeight})`
+    );
+  }
+}
diff --git a/remote/shared/webdriver/Assert.sys.mjs b/remote/shared/webdriver/Assert.sys.mjs
new file mode 100644
index 0000000000..6c254173aa
--- /dev/null
+++ b/remote/shared/webdriver/Assert.sys.mjs
@@ -0,0 +1,489 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  AppInfo: "chrome://remote/content/shared/AppInfo.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  pprint: "chrome://remote/content/shared/Format.sys.mjs",
+});
+
+/**
+ * Shorthands for common assertions made in WebDriver.
+ *
+ * @namespace
+ */
+export const assert = {};
+
+/**
+ * Asserts that WebDriver has an active session.
+ *
+ * @param {WebDriverSession} session
+ *     WebDriver session instance.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @throws {InvalidSessionIDError}
+ *     If session does not exist, or has an invalid id.
+ */
+assert.session = function (session, msg = "") {
+  msg = msg || "WebDriver session does not exist, or is not active";
+  assert.that(
+    session => session && typeof session.id == "string",
+    msg,
+    lazy.error.InvalidSessionIDError
+  )(session);
+};
+
+/**
+ * Asserts that the current browser is Firefox Desktop.
+ *
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @throws {UnsupportedOperationError}
+ *     If current browser is not Firefox.
+ */
+assert.firefox = function (msg = "") {
+  msg = msg || "Only supported in Firefox";
+  assert.that(
+    isFirefox => isFirefox,
+    msg,
+    lazy.error.UnsupportedOperationError
+  )(lazy.AppInfo.isFirefox);
+};
+
+/**
+ * Asserts that the current application is Firefox Desktop or Thunderbird.
+ *
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @throws {UnsupportedOperationError}
+ *     If current application is not running on desktop.
+ */
+assert.desktop = function (msg = "") {
+  msg = msg || "Only supported in desktop applications";
+  assert.that(
+    isDesktop => isDesktop,
+    msg,
+    lazy.error.UnsupportedOperationError
+  )(!lazy.AppInfo.isAndroid);
+};
+
+/**
+ * Asserts that the current application runs on Android.
+ *
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @throws {UnsupportedOperationError}
+ *     If current application is not running on Android.
+ */
+assert.mobile = function (msg = "") {
+  msg = msg || "Only supported on Android";
+  assert.that(
+    isAndroid => isAndroid,
+    msg,
+    lazy.error.UnsupportedOperationError
+  )(lazy.AppInfo.isAndroid);
+};
+
+/**
+ * Asserts that the current <var>context</var> is content.
+ *
+ * @param {string} context
+ *     Context to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {string}
+ *     <var>context</var> is returned unaltered.
+ *
+ * @throws {UnsupportedOperationError}
+ *     If <var>context</var> is not content.
+ */
+assert.content = function (context, msg = "") {
+  msg = msg || "Only supported in content context";
+  assert.that(
+    c => c.toString() == "content",
+    msg,
+    lazy.error.UnsupportedOperationError
+  )(context);
+};
+
+/**
+ * Asserts that the {@link CanonicalBrowsingContext} is open.
+ *
+ * @param {CanonicalBrowsingContext} browsingContext
+ *     Canonical browsing context to check.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {CanonicalBrowsingContext}
+ *     <var>browsingContext</var> is returned unaltered.
+ *
+ * @throws {NoSuchWindowError}
+ *     If <var>browsingContext</var> is no longer open.
+ */
+assert.open = function (browsingContext, msg = "") {
+  msg = msg || "Browsing context has been discarded";
+  return assert.that(
+    browsingContext => {
+      if (!browsingContext?.currentWindowGlobal) {
+        return false;
+      }
+
+      if (browsingContext.isContent && !browsingContext.top.embedderElement) {
+        return false;
+      }
+
+      return true;
+    },
+    msg,
+    lazy.error.NoSuchWindowError
+  )(browsingContext);
+};
+
+/**
+ * Asserts that there is no current user prompt.
+ *
+ * @param {modal.Dialog} dialog
+ *     Reference to current dialogue.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @throws {UnexpectedAlertOpenError}
+ *     If there is a user prompt.
+ */
+assert.noUserPrompt = function (dialog, msg = "") {
+  assert.that(
+    d => d === null || typeof d == "undefined",
+    msg,
+    lazy.error.UnexpectedAlertOpenError
+  )(dialog);
+};
+
+/**
+ * Asserts that <var>obj</var> is defined.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {?}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not defined.
+ */
+assert.defined = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be defined`;
+  return assert.that(o => typeof o != "undefined", msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is a finite number.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a number.
+ */
+assert.number = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be finite number`;
+  return assert.that(Number.isFinite, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is a positive number.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a positive integer.
+ */
+assert.positiveNumber = function (obj, msg = "") {
+  assert.number(obj, msg);
+  msg = msg || lazy.pprint`Expected ${obj} to be >= 0`;
+  return assert.that(n => n >= 0, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is a number in the inclusive range <var>lower</var> to <var>upper</var>.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {Array<number>} range
+ *     Array range [lower, upper]
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a number in the specified range.
+ */
+assert.numberInRange = function (obj, range, msg = "") {
+  const [lower, upper] = range;
+  assert.number(obj, msg);
+  msg = msg || lazy.pprint`Expected ${obj} to be >= ${lower} and <= ${upper}`;
+  return assert.that(n => n >= lower && n <= upper, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is callable.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {Function}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not callable.
+ */
+assert.callable = function (obj, msg = "") {
+  msg = msg || lazy.pprint`${obj} is not callable`;
+  return assert.that(o => typeof o == "function", msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is an unsigned short number.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not an unsigned short.
+ */
+assert.unsignedShort = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be >= 0 and < 65536`;
+  return assert.that(n => n >= 0 && n < 65536, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is an integer.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not an integer.
+ */
+assert.integer = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be an integer`;
+  return assert.that(Number.isSafeInteger, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is a positive integer.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a positive integer.
+ */
+assert.positiveInteger = function (obj, msg = "") {
+  assert.integer(obj, msg);
+  msg = msg || lazy.pprint`Expected ${obj} to be >= 0`;
+  return assert.that(n => n >= 0, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is an integer in the inclusive range <var>lower</var> to <var>upper</var>.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {Array<number>} range
+ *     Array range [lower, upper]
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {number}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a number in the specified range.
+ */
+assert.integerInRange = function (obj, range, msg = "") {
+  const [lower, upper] = range;
+  assert.integer(obj, msg);
+  msg = msg || lazy.pprint`Expected ${obj} to be >= ${lower} and <= ${upper}`;
+  return assert.that(n => n >= lower && n <= upper, msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is a boolean.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {boolean}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a boolean.
+ */
+assert.boolean = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be boolean`;
+  return assert.that(b => typeof b == "boolean", msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is a string.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {string}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not a string.
+ */
+assert.string = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be a string`;
+  return assert.that(s => typeof s == "string", msg)(obj);
+};
+
+/**
+ * Asserts that <var>obj</var> is an object.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {object}
+ *     obj| is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not an object.
+ */
+assert.object = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be an object`;
+  return assert.that(o => {
+    // unable to use instanceof because LHS and RHS may come from
+    // different globals
+    let s = Object.prototype.toString.call(o);
+    return s == "[object Object]" || s == "[object nsJSIID]";
+  }, msg)(obj);
+};
+
+/**
+ * Asserts that <var>prop</var> is in <var>obj</var>.
+ *
+ * @param {?} prop
+ *     An array element or own property to test if is in <var>obj</var>.
+ * @param {?} obj
+ *     An array or an Object that is being tested.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {?}
+ *     The array element, or the value of <var>obj</var>'s own property
+ *     <var>prop</var>.
+ *
+ * @throws {InvalidArgumentError}
+ *     If the <var>obj</var> was an array and did not contain <var>prop</var>.
+ *     Otherwise if <var>prop</var> is not in <var>obj</var>, or <var>obj</var>
+ *     is not an object.
+ */
+assert.in = function (prop, obj, msg = "") {
+  if (Array.isArray(obj)) {
+    assert.that(p => obj.includes(p), msg)(prop);
+    return prop;
+  }
+  assert.object(obj, msg);
+  msg = msg || lazy.pprint`Expected ${prop} in ${obj}`;
+  assert.that(p => obj.hasOwnProperty(p), msg)(prop);
+  return obj[prop];
+};
+
+/**
+ * Asserts that <var>obj</var> is an Array.
+ *
+ * @param {?} obj
+ *     Value to test.
+ * @param {string=} msg
+ *     Custom error message.
+ *
+ * @returns {object}
+ *     <var>obj</var> is returned unaltered.
+ *
+ * @throws {InvalidArgumentError}
+ *     If <var>obj</var> is not an Array.
+ */
+assert.array = function (obj, msg = "") {
+  msg = msg || lazy.pprint`Expected ${obj} to be an Array`;
+  return assert.that(Array.isArray, msg)(obj);
+};
+
+/**
+ * Returns a function that is used to assert the |predicate|.
+ *
+ * @param {function(?): boolean} predicate
+ *     Evaluated on calling the return value of this function.  If its
+ *     return value of the inner function is false, <var>error</var>
+ *     is thrown with <var>message</var>.
+ * @param {string=} message
+ *     Custom error message.
+ * @param {Error=} err
+ *     Custom error type by its class.
+ *
+ * @returns {function(?): ?}
+ *     Function that takes and returns the passed in value unaltered,
+ *     and which may throw <var>error</var> with <var>message</var>
+ *     if <var>predicate</var> evaluates to false.
+ */
+assert.that = function (
+  predicate,
+  message = "",
+  err = lazy.error.InvalidArgumentError
+) {
+  return obj => {
+    if (!predicate(obj)) {
+      throw new err(message);
+    }
+    return obj;
+  };
+};
diff --git a/remote/shared/webdriver/Capabilities.sys.mjs b/remote/shared/webdriver/Capabilities.sys.mjs
new file mode 100644
index 0000000000..0a41826784
--- /dev/null
+++ b/remote/shared/webdriver/Capabilities.sys.mjs
@@ -0,0 +1,737 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Preferences: "resource://gre/modules/Preferences.sys.mjs",
+
+  AppInfo: "chrome://remote/content/shared/AppInfo.sys.mjs",
+  assert: "chrome://remote/content/shared/webdriver/Assert.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  pprint: "chrome://remote/content/shared/Format.sys.mjs",
+  RemoteAgent: "chrome://remote/content/components/RemoteAgent.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "remoteAgent", () => {
+  return Cc["@mozilla.org/remote/agent;1"].createInstance(Ci.nsIRemoteAgent);
+});
+
+/** Representation of WebDriver session timeouts. */
+export class Timeouts {
+  constructor() {
+    // disabled
+    this.implicit = 0;
+    // five minutes
+    this.pageLoad = 300000;
+    // 30 seconds
+    this.script = 30000;
+  }
+
+  toString() {
+    return "[object Timeouts]";
+  }
+
+  /** Marshals timeout durations to a JSON Object. */
+  toJSON() {
+    return {
+      implicit: this.implicit,
+      pageLoad: this.pageLoad,
+      script: this.script,
+    };
+  }
+
+  static fromJSON(json) {
+    lazy.assert.object(
+      json,
+      lazy.pprint`Expected "timeouts" to be an object, got ${json}`
+    );
+    let t = new Timeouts();
+
+    for (let [type, ms] of Object.entries(json)) {
+      switch (type) {
+        case "implicit":
+          t.implicit = lazy.assert.positiveInteger(
+            ms,
+            lazy.pprint`Expected ${type} to be a positive integer, got ${ms}`
+          );
+          break;
+
+        case "script":
+          if (ms !== null) {
+            lazy.assert.positiveInteger(
+              ms,
+              lazy.pprint`Expected ${type} to be a positive integer, got ${ms}`
+            );
+          }
+          t.script = ms;
+          break;
+
+        case "pageLoad":
+          t.pageLoad = lazy.assert.positiveInteger(
+            ms,
+            lazy.pprint`Expected ${type} to be a positive integer, got ${ms}`
+          );
+          break;
+
+        default:
+          throw new lazy.error.InvalidArgumentError(
+            "Unrecognised timeout: " + type
+          );
+      }
+    }
+
+    return t;
+  }
+}
+
+/**
+ * Enum of page loading strategies.
+ *
+ * @enum
+ */
+export const PageLoadStrategy = {
+  /** No page load strategy.  Navigation will return immediately. */
+  None: "none",
+  /**
+   * Eager, causing navigation to complete when the document reaches
+   * the <code>interactive</code> ready state.
+   */
+  Eager: "eager",
+  /**
+   * Normal, causing navigation to return when the document reaches the
+   * <code>complete</code> ready state.
+   */
+  Normal: "normal",
+};
+
+/** Proxy configuration object representation. */
+export class Proxy {
+  /** @class */
+  constructor() {
+    this.proxyType = null;
+    this.httpProxy = null;
+    this.httpProxyPort = null;
+    this.noProxy = null;
+    this.sslProxy = null;
+    this.sslProxyPort = null;
+    this.socksProxy = null;
+    this.socksProxyPort = null;
+    this.socksVersion = null;
+    this.proxyAutoconfigUrl = null;
+  }
+
+  /**
+   * Sets Firefox proxy settings.
+   *
+   * @returns {boolean}
+   *     True if proxy settings were updated as a result of calling this
+   *     function, or false indicating that this function acted as
+   *     a no-op.
+   */
+  init() {
+    switch (this.proxyType) {
+      case "autodetect":
+        lazy.Preferences.set("network.proxy.type", 4);
+        return true;
+
+      case "direct":
+        lazy.Preferences.set("network.proxy.type", 0);
+        return true;
+
+      case "manual":
+        lazy.Preferences.set("network.proxy.type", 1);
+
+        if (this.httpProxy) {
+          lazy.Preferences.set("network.proxy.http", this.httpProxy);
+          if (Number.isInteger(this.httpProxyPort)) {
+            lazy.Preferences.set("network.proxy.http_port", this.httpProxyPort);
+          }
+        }
+
+        if (this.sslProxy) {
+          lazy.Preferences.set("network.proxy.ssl", this.sslProxy);
+          if (Number.isInteger(this.sslProxyPort)) {
+            lazy.Preferences.set("network.proxy.ssl_port", this.sslProxyPort);
+          }
+        }
+
+        if (this.socksProxy) {
+          lazy.Preferences.set("network.proxy.socks", this.socksProxy);
+          if (Number.isInteger(this.socksProxyPort)) {
+            lazy.Preferences.set(
+              "network.proxy.socks_port",
+              this.socksProxyPort
+            );
+          }
+          if (this.socksVersion) {
+            lazy.Preferences.set(
+              "network.proxy.socks_version",
+              this.socksVersion
+            );
+          }
+        }
+
+        if (this.noProxy) {
+          lazy.Preferences.set(
+            "network.proxy.no_proxies_on",
+            this.noProxy.join(", ")
+          );
+        }
+        return true;
+
+      case "pac":
+        lazy.Preferences.set("network.proxy.type", 2);
+        lazy.Preferences.set(
+          "network.proxy.autoconfig_url",
+          this.proxyAutoconfigUrl
+        );
+        return true;
+
+      case "system":
+        lazy.Preferences.set("network.proxy.type", 5);
+        return true;
+
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * @param {Object<string, ?>} json
+   *     JSON Object to unmarshal.
+   *
+   * @throws {InvalidArgumentError}
+   *     When proxy configuration is invalid.
+   */
+  static fromJSON(json) {
+    function stripBracketsFromIpv6Hostname(hostname) {
+      return hostname.includes(":")
+        ? hostname.replace(/[\[\]]/g, "")
+        : hostname;
+    }
+
+    // Parse hostname and optional port from host
+    function fromHost(scheme, host) {
+      lazy.assert.string(
+        host,
+        lazy.pprint`Expected proxy "host" to be a string, got ${host}`
+      );
+
+      if (host.includes("://")) {
+        throw new lazy.error.InvalidArgumentError(`${host} contains a scheme`);
+      }
+
+      let url;
+      try {
+        // To parse the host a scheme has to be added temporarily.
+        // If the returned value for the port is an empty string it
+        // could mean no port or the default port for this scheme was
+        // specified. In such a case parse again with a different
+        // scheme to ensure we filter out the default port.
+        url = new URL("http://" + host);
+        if (url.port == "") {
+          url = new URL("https://" + host);
+        }
+      } catch (e) {
+        throw new lazy.error.InvalidArgumentError(e.message);
+      }
+
+      let hostname = stripBracketsFromIpv6Hostname(url.hostname);
+
+      // If the port hasn't been set, use the default port of
+      // the selected scheme (except for socks which doesn't have one).
+      let port = parseInt(url.port);
+      if (!Number.isInteger(port)) {
+        if (scheme === "socks") {
+          port = null;
+        } else {
+          port = Services.io.getDefaultPort(scheme);
+        }
+      }
+
+      if (
+        url.username != "" ||
+        url.password != "" ||
+        url.pathname != "/" ||
+        url.search != "" ||
+        url.hash != ""
+      ) {
+        throw new lazy.error.InvalidArgumentError(
+          `${host} was not of the form host[:port]`
+        );
+      }
+
+      return [hostname, port];
+    }
+
+    let p = new Proxy();
+    if (typeof json == "undefined" || json === null) {
+      return p;
+    }
+
+    lazy.assert.object(
+      json,
+      lazy.pprint`Expected "proxy" to be an object, got ${json}`
+    );
+
+    lazy.assert.in(
+      "proxyType",
+      json,
+      lazy.pprint`Expected "proxyType" in "proxy" object, got ${json}`
+    );
+    p.proxyType = lazy.assert.string(
+      json.proxyType,
+      lazy.pprint`Expected "proxyType" to be a string, got ${json.proxyType}`
+    );
+
+    switch (p.proxyType) {
+      case "autodetect":
+      case "direct":
+      case "system":
+        break;
+
+      case "pac":
+        p.proxyAutoconfigUrl = lazy.assert.string(
+          json.proxyAutoconfigUrl,
+          `Expected "proxyAutoconfigUrl" to be a string, ` +
+            lazy.pprint`got ${json.proxyAutoconfigUrl}`
+        );
+        break;
+
+      case "manual":
+        if (typeof json.ftpProxy != "undefined") {
+          throw new lazy.error.InvalidArgumentError(
+            "Since Firefox 90 'ftpProxy' is no longer supported"
+          );
+        }
+        if (typeof json.httpProxy != "undefined") {
+          [p.httpProxy, p.httpProxyPort] = fromHost("http", json.httpProxy);
+        }
+        if (typeof json.sslProxy != "undefined") {
+          [p.sslProxy, p.sslProxyPort] = fromHost("https", json.sslProxy);
+        }
+        if (typeof json.socksProxy != "undefined") {
+          [p.socksProxy, p.socksProxyPort] = fromHost("socks", json.socksProxy);
+          p.socksVersion = lazy.assert.positiveInteger(
+            json.socksVersion,
+            lazy.pprint`Expected "socksVersion" to be a positive integer, got ${json.socksVersion}`
+          );
+        }
+        if (typeof json.noProxy != "undefined") {
+          let entries = lazy.assert.array(
+            json.noProxy,
+            lazy.pprint`Expected "noProxy" to be an array, got ${json.noProxy}`
+          );
+          p.noProxy = entries.map(entry => {
+            lazy.assert.string(
+              entry,
+              lazy.pprint`Expected "noProxy" entry to be a string, got ${entry}`
+            );
+            return stripBracketsFromIpv6Hostname(entry);
+          });
+        }
+        break;
+
+      default:
+        throw new lazy.error.InvalidArgumentError(
+          `Invalid type of proxy: ${p.proxyType}`
+        );
+    }
+
+    return p;
+  }
+
+  /**
+   * @returns {Object<string, (number | string)>}
+   *     JSON serialisation of proxy object.
+   */
+  toJSON() {
+    function addBracketsToIpv6Hostname(hostname) {
+      return hostname.includes(":") ? `[${hostname}]` : hostname;
+    }
+
+    function toHost(hostname, port) {
+      if (!hostname) {
+        return null;
+      }
+
+      // Add brackets around IPv6 addresses
+      hostname = addBracketsToIpv6Hostname(hostname);
+
+      if (port != null) {
+        return `${hostname}:${port}`;
+      }
+
+      return hostname;
+    }
+
+    let excludes = this.noProxy;
+    if (excludes) {
+      excludes = excludes.map(addBracketsToIpv6Hostname);
+    }
+
+    return marshal({
+      proxyType: this.proxyType,
+      httpProxy: toHost(this.httpProxy, this.httpProxyPort),
+      noProxy: excludes,
+      sslProxy: toHost(this.sslProxy, this.sslProxyPort),
+      socksProxy: toHost(this.socksProxy, this.socksProxyPort),
+      socksVersion: this.socksVersion,
+      proxyAutoconfigUrl: this.proxyAutoconfigUrl,
+    });
+  }
+
+  toString() {
+    return "[object Proxy]";
+  }
+}
+
+/**
+ * Enum of unhandled prompt behavior.
+ *
+ * @enum
+ */
+export const UnhandledPromptBehavior = {
+  /** All simple dialogs encountered should be accepted. */
+  Accept: "accept",
+  /**
+   * All simple dialogs encountered should be accepted, and an error
+   * returned that the dialog was handled.
+   */
+  AcceptAndNotify: "accept and notify",
+  /** All simple dialogs encountered should be dismissed. */
+  Dismiss: "dismiss",
+  /**
+   * All simple dialogs encountered should be dismissed, and an error
+   * returned that the dialog was handled.
+   */
+  DismissAndNotify: "dismiss and notify",
+  /** All simple dialogs encountered should be left to the user to handle. */
+  Ignore: "ignore",
+};
+
+/** WebDriver session capabilities representation. */
+export class Capabilities extends Map {
+  /** @class */
+  constructor() {
+    super([
+      // webdriver
+      ["browserName", getWebDriverBrowserName()],
+      ["browserVersion", lazy.AppInfo.version],
+      ["platformName", getWebDriverPlatformName()],
+      ["acceptInsecureCerts", false],
+      ["pageLoadStrategy", PageLoadStrategy.Normal],
+      ["proxy", new Proxy()],
+      ["setWindowRect", !lazy.AppInfo.isAndroid],
+      ["timeouts", new Timeouts()],
+      ["strictFileInteractability", false],
+      ["unhandledPromptBehavior", UnhandledPromptBehavior.DismissAndNotify],
+      ["webSocketUrl", null],
+
+      // proprietary
+      ["moz:accessibilityChecks", false],
+      ["moz:buildID", lazy.AppInfo.appBuildID],
+      [
+        "moz:debuggerAddress",
+        // With bug 1715481 fixed always use the Remote Agent instance
+        lazy.RemoteAgent.running && lazy.RemoteAgent.cdp
+          ? lazy.remoteAgent.debuggerAddress
+          : null,
+      ],
+      [
+        "moz:headless",
+        Cc["@mozilla.org/gfx/info;1"].getService(Ci.nsIGfxInfo).isHeadless,
+      ],
+      ["moz:platformVersion", Services.sysinfo.getProperty("version")],
+      ["moz:processID", lazy.AppInfo.processID],
+      ["moz:profile", maybeProfile()],
+      [
+        "moz:shutdownTimeout",
+        Services.prefs.getIntPref("toolkit.asyncshutdown.crash_timeout"),
+      ],
+      ["moz:useNonSpecCompliantPointerOrigin", false],
+      ["moz:webdriverClick", true],
+      ["moz:windowless", false],
+    ]);
+  }
+
+  /**
+   * @param {string} key
+   *     Capability key.
+   * @param {(string|number|boolean)} value
+   *     JSON-safe capability value.
+   */
+  set(key, value) {
+    if (key === "timeouts" && !(value instanceof Timeouts)) {
+      throw new TypeError();
+    } else if (key === "proxy" && !(value instanceof Proxy)) {
+      throw new TypeError();
+    }
+
+    return super.set(key, value);
+  }
+
+  toString() {
+    return "[object Capabilities]";
+  }
+
+  /**
+   * JSON serialisation of capabilities object.
+   *
+   * @returns {Object<string, ?>}
+   */
+  toJSON() {
+    let marshalled = marshal(this);
+
+    // Always return the proxy capability even if it's empty
+    if (!("proxy" in marshalled)) {
+      marshalled.proxy = {};
+    }
+
+    marshalled.timeouts = super.get("timeouts");
+
+    return marshalled;
+  }
+
+  /**
+   * Unmarshal a JSON object representation of WebDriver capabilities.
+   *
+   * @param {Object<string, *>=} json
+   *     WebDriver capabilities.
+   *
+   * @returns {Capabilities}
+   *     Internal representation of WebDriver capabilities.
+   */
+  static fromJSON(json) {
+    if (typeof json == "undefined" || json === null) {
+      json = {};
+    }
+    lazy.assert.object(
+      json,
+      lazy.pprint`Expected "capabilities" to be an object, got ${json}"`
+    );
+
+    return Capabilities.match_(json);
+  }
+
+  // Matches capabilities as described by WebDriver.
+  static match_(json = {}) {
+    let matched = new Capabilities();
+
+    for (let [k, v] of Object.entries(json)) {
+      switch (k) {
+        case "acceptInsecureCerts":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be a boolean, got ${v}`
+          );
+          break;
+
+        case "pageLoadStrategy":
+          lazy.assert.string(
+            v,
+            lazy.pprint`Expected ${k} to be a string, got ${v}`
+          );
+          if (!Object.values(PageLoadStrategy).includes(v)) {
+            throw new lazy.error.InvalidArgumentError(
+              "Unknown page load strategy: " + v
+            );
+          }
+          break;
+
+        case "proxy":
+          v = Proxy.fromJSON(v);
+          break;
+
+        case "setWindowRect":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be boolean, got ${v}`
+          );
+          if (!lazy.AppInfo.isAndroid && !v) {
+            throw new lazy.error.InvalidArgumentError(
+              "setWindowRect cannot be disabled"
+            );
+          } else if (lazy.AppInfo.isAndroid && v) {
+            throw new lazy.error.InvalidArgumentError(
+              "setWindowRect is only supported on desktop"
+            );
+          }
+          break;
+
+        case "timeouts":
+          v = Timeouts.fromJSON(v);
+          break;
+
+        case "strictFileInteractability":
+          v = lazy.assert.boolean(v);
+          break;
+
+        case "unhandledPromptBehavior":
+          lazy.assert.string(
+            v,
+            lazy.pprint`Expected ${k} to be a string, got ${v}`
+          );
+          if (!Object.values(UnhandledPromptBehavior).includes(v)) {
+            throw new lazy.error.InvalidArgumentError(
+              `Unknown unhandled prompt behavior: ${v}`
+            );
+          }
+          break;
+
+        case "webSocketUrl":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be boolean, got ${v}`
+          );
+
+          if (!v) {
+            throw new lazy.error.InvalidArgumentError(
+              lazy.pprint`Expected ${k} to be true, got ${v}`
+            );
+          }
+          break;
+
+        case "moz:accessibilityChecks":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be boolean, got ${v}`
+          );
+          break;
+
+        // Don't set the value because it's only used to return the address
+        // of the Remote Agent's debugger (HTTP server).
+        case "moz:debuggerAddress":
+          continue;
+
+        case "moz:useNonSpecCompliantPointerOrigin":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be boolean, got ${v}`
+          );
+          break;
+
+        case "moz:webdriverClick":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be boolean, got ${v}`
+          );
+          break;
+
+        case "moz:windowless":
+          lazy.assert.boolean(
+            v,
+            lazy.pprint`Expected ${k} to be boolean, got ${v}`
+          );
+
+          // Only supported on MacOS
+          if (v && !lazy.AppInfo.isMac) {
+            throw new lazy.error.InvalidArgumentError(
+              "moz:windowless only supported on MacOS"
+            );
+          }
+          break;
+      }
+
+      matched.set(k, v);
+    }
+
+    return matched;
+  }
+}
+
+function getWebDriverBrowserName() {
+  // Similar to chromedriver which reports "chrome" as browser name for all
+  // WebView apps, we will report "firefox" for all GeckoView apps.
+  if (lazy.AppInfo.isAndroid) {
+    return "firefox";
+  }
+
+  return lazy.AppInfo.name?.toLowerCase();
+}
+
+function getWebDriverPlatformName() {
+  let name = Services.sysinfo.getProperty("name");
+
+  if (lazy.AppInfo.isAndroid) {
+    return "android";
+  }
+
+  switch (name) {
+    case "Windows_NT":
+      return "windows";
+
+    case "Darwin":
+      return "mac";
+
+    default:
+      return name.toLowerCase();
+  }
+}
+
+// Specialisation of |JSON.stringify| that produces JSON-safe object
+// literals, dropping empty objects and entries which values are undefined
+// or null. Objects are allowed to produce their own JSON representations
+// by implementing a |toJSON| function.
+function marshal(obj) {
+  let rv = Object.create(null);
+
+  function* iter(mapOrObject) {
+    if (mapOrObject instanceof Map) {
+      for (const [k, v] of mapOrObject) {
+        yield [k, v];
+      }
+    } else {
+      for (const k of Object.keys(mapOrObject)) {
+        yield [k, mapOrObject[k]];
+      }
+    }
+  }
+
+  for (let [k, v] of iter(obj)) {
+    // Skip empty values when serialising to JSON.
+    if (typeof v == "undefined" || v === null) {
+      continue;
+    }
+
+    // Recursively marshal objects that are able to produce their own
+    // JSON representation.
+    if (typeof v.toJSON == "function") {
+      v = marshal(v.toJSON());
+
+      // Or do the same for object literals.
+    } else if (isObject(v)) {
+      v = marshal(v);
+    }
+
+    // And finally drop (possibly marshaled) objects which have no
+    // entries.
+    if (!isObjectEmpty(v)) {
+      rv[k] = v;
+    }
+  }
+
+  return rv;
+}
+
+function isObject(obj) {
+  return Object.prototype.toString.call(obj) == "[object Object]";
+}
+
+function isObjectEmpty(obj) {
+  return isObject(obj) && Object.keys(obj).length === 0;
+}
+
+// Services.dirsvc is not accessible from JSWindowActor child,
+// but we should not panic about that.
+function maybeProfile() {
+  try {
+    return Services.dirsvc.get("ProfD", Ci.nsIFile).path;
+  } catch (e) {
+    return "<protected>";
+  }
+}
diff --git a/remote/shared/webdriver/Errors.sys.mjs b/remote/shared/webdriver/Errors.sys.mjs
new file mode 100644
index 0000000000..65c2f0b689
--- /dev/null
+++ b/remote/shared/webdriver/Errors.sys.mjs
@@ -0,0 +1,796 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { RemoteError } from "chrome://remote/content/shared/RemoteError.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  pprint: "chrome://remote/content/shared/Format.sys.mjs",
+});
+
+const ERRORS = new Set([
+  "DetachedShadowRootError",
+  "ElementClickInterceptedError",
+  "ElementNotAccessibleError",
+  "ElementNotInteractableError",
+  "InsecureCertificateError",
+  "InvalidArgumentError",
+  "InvalidCookieDomainError",
+  "InvalidElementStateError",
+  "InvalidSelectorError",
+  "InvalidSessionIDError",
+  "JavaScriptError",
+  "MoveTargetOutOfBoundsError",
+  "NoSuchAlertError",
+  "NoSuchElementError",
+  "NoSuchFrameError",
+  "NoSuchHandleError",
+  "NoSuchNodeError",
+  "NoSuchScriptError",
+  "NoSuchShadowRootError",
+  "NoSuchWindowError",
+  "ScriptTimeoutError",
+  "SessionNotCreatedError",
+  "StaleElementReferenceError",
+  "TimeoutError",
+  "UnableToSetCookieError",
+  "UnexpectedAlertOpenError",
+  "UnknownCommandError",
+  "UnknownError",
+  "UnsupportedOperationError",
+  "WebDriverError",
+]);
+
+const BUILTIN_ERRORS = new Set([
+  "Error",
+  "EvalError",
+  "InternalError",
+  "RangeError",
+  "ReferenceError",
+  "SyntaxError",
+  "TypeError",
+  "URIError",
+]);
+
+/** @namespace */
+export const error = {
+  /**
+   * Check if ``val`` is an instance of the ``Error`` prototype.
+   *
+   * Because error objects may originate from different globals, comparing
+   * the prototype of the left hand side with the prototype property from
+   * the right hand side, which is what ``instanceof`` does, will not work.
+   * If the LHS and RHS come from different globals, this check will always
+   * fail because the two objects will not have the same identity.
+   *
+   * Therefore it is not safe to use ``instanceof`` in any multi-global
+   * situation, e.g. in content across multiple ``Window`` objects or anywhere
+   * in chrome scope.
+   *
+   * This function also contains a special check if ``val`` is an XPCOM
+   * ``nsIException`` because they are special snowflakes and may indeed
+   * cause Firefox to crash if used with ``instanceof``.
+   *
+   * @param {*} val
+   *     Any value that should be undergo the test for errorness.
+   * @returns {boolean}
+   *     True if error, false otherwise.
+   */
+  isError(val) {
+    if (val === null || typeof val != "object") {
+      return false;
+    } else if (val instanceof Ci.nsIException) {
+      return true;
+    }
+
+    // DOMRectList errors on string comparison
+    try {
+      let proto = Object.getPrototypeOf(val);
+      return BUILTIN_ERRORS.has(proto.toString());
+    } catch (e) {
+      return false;
+    }
+  },
+
+  /**
+   * Checks if ``obj`` is an object in the :js:class:`WebDriverError`
+   * prototypal chain.
+   *
+   * @param {*} obj
+   *     Arbitrary object to test.
+   *
+   * @returns {boolean}
+   *     True if ``obj`` is of the WebDriverError prototype chain,
+   *     false otherwise.
+   */
+  isWebDriverError(obj) {
+    // Don't use "instanceof" to compare error objects because of possible
+    // problems when the other instance was created in a different global and
+    // as such won't have the same prototype object.
+    return error.isError(obj) && "name" in obj && ERRORS.has(obj.name);
+  },
+
+  /**
+   * Ensures error instance is a :js:class:`WebDriverError`.
+   *
+   * If the given error is already in the WebDriverError prototype
+   * chain, ``err`` is returned unmodified.  If it is not, it is wrapped
+   * in :js:class:`UnknownError`.
+   *
+   * @param {Error} err
+   *     Error to conditionally turn into a WebDriverError.
+   *
+   * @returns {WebDriverError}
+   *     If ``err`` is a WebDriverError, it is returned unmodified.
+   *     Otherwise an UnknownError type is returned.
+   */
+  wrap(err) {
+    if (error.isWebDriverError(err)) {
+      return err;
+    }
+    return new UnknownError(err);
+  },
+
+  /**
+   * Unhandled error reporter.  Dumps the error and its stacktrace to console,
+   * and reports error to the Browser Console.
+   */
+  report(err) {
+    let msg = "Marionette threw an error: " + error.stringify(err);
+    dump(msg + "\n");
+    console.error(msg);
+  },
+
+  /**
+   * Prettifies an instance of Error and its stacktrace to a string.
+   */
+  stringify(err) {
+    try {
+      let s = err.toString();
+      if ("stack" in err) {
+        s += "\n" + err.stack;
+      }
+      return s;
+    } catch (e) {
+      return "<unprintable error>";
+    }
+  },
+
+  /** Create a stacktrace to the current line in the program. */
+  stack() {
+    let trace = new Error().stack;
+    let sa = trace.split("\n");
+    sa = sa.slice(1);
+    let rv = "stacktrace:\n" + sa.join("\n");
+    return rv.trimEnd();
+  },
+};
+
+/**
+ * WebDriverError is the prototypal parent of all WebDriver errors.
+ * It should not be used directly, as it does not correspond to a real
+ * error in the specification.
+ */
+class WebDriverError extends RemoteError {
+  /**
+   * Base error for WebDriver protocols.
+   *
+   * @param {(string|Error)=} obj
+   *     Optional string describing error situation or Error instance
+   *     to propagate.
+   * @param {object=} data
+   *     Additional error data helpful in diagnosing the error.
+   */
+  constructor(obj, data = {}) {
+    super(obj);
+
+    this.name = this.constructor.name;
+    this.status = "webdriver error";
+    this.data = data;
+
+    // Error's ctor does not preserve x' stack
+    if (error.isError(obj)) {
+      this.stack = obj.stack;
+    }
+
+    if (error.isWebDriverError(obj)) {
+      this.message = obj.message;
+      this.data = obj.data;
+    }
+  }
+
+  /**
+   * @returns {Object<string, string>}
+   *     JSON serialisation of error prototype.
+   */
+  toJSON() {
+    const result = {
+      error: this.status,
+      message: this.message || "",
+      stacktrace: this.stack || "",
+    };
+
+    // Only add the field if additional data has been specified.
+    if (Object.keys(this.data).length) {
+      result.data = this.data;
+    }
+
+    return result;
+  }
+
+  /**
+   * Unmarshals a JSON error representation to the appropriate Marionette
+   * error type.
+   *
+   * @param {Object<string, string>} json
+   *     Error object.
+   *
+   * @returns {Error}
+   *     Error prototype.
+   */
+  static fromJSON(json) {
+    if (typeof json.error == "undefined") {
+      let s = JSON.stringify(json);
+      throw new TypeError("Undeserialisable error type: " + s);
+    }
+    if (!STATUSES.has(json.error)) {
+      throw new TypeError("Not of WebDriverError descent: " + json.error);
+    }
+
+    let cls = STATUSES.get(json.error);
+    let err = new cls();
+    if ("message" in json) {
+      err.message = json.message;
+    }
+    if ("stacktrace" in json) {
+      err.stack = json.stacktrace;
+    }
+    if ("data" in json) {
+      err.data = json.data;
+    }
+
+    return err;
+  }
+}
+
+/**
+ * The Gecko a11y API indicates that the element is not accessible.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class ElementNotAccessibleError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "element not accessible";
+  }
+}
+
+/**
+ * An element click could not be completed because the element receiving
+ * the events is obscuring the element that was requested clicked.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation. Will be replaced if both
+ *     `data.obscuredEl` and `data.coords` are provided.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ * @param {Element=} obscuredEl
+ *     Element obscuring the element receiving the click.  Providing this
+ *     is not required, but will produce a nicer error message.
+ * @param {Map.<string, number>=} coords
+ *     Original click location.  Providing this is not required, but
+ *     will produce a nicer error message.
+ */
+class ElementClickInterceptedError extends WebDriverError {
+  constructor(message, data = {}, obscuredEl = undefined, coords = undefined) {
+    let obscuredElDetails = null;
+    let overlayingElDetails = null;
+
+    if (obscuredEl && coords) {
+      const doc = obscuredEl.ownerDocument;
+      const overlayingEl = doc.elementFromPoint(coords.x, coords.y);
+
+      obscuredElDetails = lazy.pprint`${obscuredEl}`;
+      overlayingElDetails = lazy.pprint`${overlayingEl}`;
+
+      switch (obscuredEl.style.pointerEvents) {
+        case "none":
+          message =
+            `Element ${obscuredElDetails} is not clickable ` +
+            `at point (${coords.x},${coords.y}) ` +
+            `because it does not have pointer events enabled, ` +
+            `and element ${overlayingElDetails} ` +
+            `would receive the click instead`;
+          break;
+
+        default:
+          message =
+            `Element ${obscuredElDetails} is not clickable ` +
+            `at point (${coords.x},${coords.y}) ` +
+            `because another element ${overlayingElDetails} ` +
+            `obscures it`;
+          break;
+      }
+    }
+
+    if (coords) {
+      data.coords = coords;
+    }
+    if (obscuredElDetails) {
+      data.obscuredElement = obscuredElDetails;
+    }
+    if (overlayingElDetails) {
+      data.overlayingElement = overlayingElDetails;
+    }
+
+    super(message, data);
+    this.status = "element click intercepted";
+  }
+}
+
+/**
+ * A command could not be completed because the element is not pointer-
+ * or keyboard interactable.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class ElementNotInteractableError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "element not interactable";
+  }
+}
+
+/**
+ * Navigation caused the user agent to hit a certificate warning, which
+ * is usually the result of an expired or invalid TLS certificate.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class InsecureCertificateError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "insecure certificate";
+  }
+}
+
+/**
+ * The arguments passed to a command are either invalid or malformed.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class InvalidArgumentError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "invalid argument";
+  }
+}
+
+/**
+ * An illegal attempt was made to set a cookie under a different
+ * domain than the current page.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class InvalidCookieDomainError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "invalid cookie domain";
+  }
+}
+
+/**
+ * A command could not be completed because the element is in an
+ * invalid state, e.g. attempting to clear an element that isn't both
+ * editable and resettable.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class InvalidElementStateError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "invalid element state";
+  }
+}
+
+/**
+ * Argument was an invalid selector.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class InvalidSelectorError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "invalid selector";
+  }
+}
+
+/**
+ * Occurs if the given session ID is not in the list of active sessions,
+ * meaning the session either does not exist or that it's not active.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class InvalidSessionIDError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "invalid session id";
+  }
+}
+
+/**
+ * An error occurred whilst executing JavaScript supplied by the user.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class JavaScriptError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "javascript error";
+  }
+}
+
+/**
+ * The target for mouse interaction is not in the browser's viewport
+ * and cannot be brought into that viewport.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class MoveTargetOutOfBoundsError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "move target out of bounds";
+  }
+}
+
+/**
+ * An attempt was made to operate on a modal dialog when one was
+ * not open.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchAlertError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such alert";
+  }
+}
+
+/**
+ * An element could not be located on the page using the given
+ * search parameters.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchElementError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such element";
+  }
+}
+
+/**
+ * A command tried to remove an unknown preload script.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchScriptError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such script";
+  }
+}
+
+/**
+ * A shadow root was not attached to the element.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchShadowRootError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such shadow root";
+  }
+}
+
+/**
+ * A shadow root is no longer attached to the document.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class DetachedShadowRootError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "detached shadow root";
+  }
+}
+
+/**
+ * A command to switch to a frame could not be satisfied because
+ * the frame could not be found.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchFrameError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such frame";
+  }
+}
+
+/**
+ * The handle of a strong object reference could not be found.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchHandleError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such handle";
+  }
+}
+
+/**
+ * A node as given by its unique shared id could not be found within the cache
+ * of known nodes.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchNodeError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such node";
+  }
+}
+
+/**
+ * A command to switch to a window could not be satisfied because
+ * the window could not be found.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class NoSuchWindowError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "no such window";
+  }
+}
+
+/**
+ * A script did not complete before its timeout expired.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class ScriptTimeoutError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "script timeout";
+  }
+}
+
+/**
+ * A new session could not be created.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class SessionNotCreatedError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "session not created";
+  }
+}
+
+/**
+ * A command failed because the referenced element is no longer
+ * attached to the DOM.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class StaleElementReferenceError extends WebDriverError {
+  constructor(message, options = {}) {
+    super(message, options);
+    this.status = "stale element reference";
+  }
+}
+
+/**
+ * An operation did not complete before its timeout expired.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class TimeoutError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "timeout";
+  }
+}
+
+/**
+ * A command to set a cookie's value could not be satisfied.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class UnableToSetCookieError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "unable to set cookie";
+  }
+}
+
+/**
+ * A modal dialog was open, blocking this operation.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class UnexpectedAlertOpenError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "unexpected alert open";
+  }
+}
+
+/**
+ * A command could not be executed because the remote end is not
+ * aware of it.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class UnknownCommandError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "unknown command";
+  }
+}
+
+/**
+ * An unknown error occurred in the remote end while processing
+ * the command.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class UnknownError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "unknown error";
+  }
+}
+
+/**
+ * Indicates that a command that should have executed properly
+ * cannot be supported for some reason.
+ *
+ * @param {string=} message
+ *     Optional string describing error situation.
+ * @param {object=} data
+ *     Additional error data helpful in diagnosing the error.
+ */
+class UnsupportedOperationError extends WebDriverError {
+  constructor(message, data = {}) {
+    super(message, data);
+    this.status = "unsupported operation";
+  }
+}
+
+const STATUSES = new Map([
+  ["detached shadow root", DetachedShadowRootError],
+  ["element click intercepted", ElementClickInterceptedError],
+  ["element not accessible", ElementNotAccessibleError],
+  ["element not interactable", ElementNotInteractableError],
+  ["insecure certificate", InsecureCertificateError],
+  ["invalid argument", InvalidArgumentError],
+  ["invalid cookie domain", InvalidCookieDomainError],
+  ["invalid element state", InvalidElementStateError],
+  ["invalid selector", InvalidSelectorError],
+  ["invalid session id", InvalidSessionIDError],
+  ["javascript error", JavaScriptError],
+  ["move target out of bounds", MoveTargetOutOfBoundsError],
+  ["no such alert", NoSuchAlertError],
+  ["no such element", NoSuchElementError],
+  ["no such frame", NoSuchFrameError],
+  ["no such handle", NoSuchHandleError],
+  ["no such node", NoSuchNodeError],
+  ["no such script", NoSuchScriptError],
+  ["no such shadow root", NoSuchShadowRootError],
+  ["no such window", NoSuchWindowError],
+  ["script timeout", ScriptTimeoutError],
+  ["session not created", SessionNotCreatedError],
+  ["stale element reference", StaleElementReferenceError],
+  ["timeout", TimeoutError],
+  ["unable to set cookie", UnableToSetCookieError],
+  ["unexpected alert open", UnexpectedAlertOpenError],
+  ["unknown command", UnknownCommandError],
+  ["unknown error", UnknownError],
+  ["unsupported operation", UnsupportedOperationError],
+  ["webdriver error", WebDriverError],
+]);
+
+// Errors must be expored on the local this scope so that the
+// EXPORTED_SYMBOLS and the ChromeUtils.import("foo") machinery sees them.
+// We could assign each error definition directly to |this|, but
+// because they are Error prototypes this would mess up their names.
+for (let cls of STATUSES.values()) {
+  error[cls.name] = cls;
+}
diff --git a/remote/shared/webdriver/KeyData.sys.mjs b/remote/shared/webdriver/KeyData.sys.mjs
new file mode 100644
index 0000000000..13ec1f5bd8
--- /dev/null
+++ b/remote/shared/webdriver/KeyData.sys.mjs
@@ -0,0 +1,340 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const KEY_DATA = {
+  " ": { code: "Space" },
+  "!": { code: "Digit1", shifted: true },
+  "#": { code: "Digit3", shifted: true },
+  $: { code: "Digit4", shifted: true },
+  "%": { code: "Digit5", shifted: true },
+  "&": { code: "Digit7", shifted: true },
+  "'": { code: "Quote" },
+  "(": { code: "Digit9", shifted: true },
+  ")": { code: "Digit0", shifted: true },
+  "*": { code: "Digit8", shifted: true },
+  "+": { code: "Equal", shifted: true },
+  ",": { code: "Comma" },
+  "-": { code: "Minus" },
+  ".": { code: "Period" },
+  "/": { code: "Slash" },
+  0: { code: "Digit0" },
+  1: { code: "Digit1" },
+  2: { code: "Digit2" },
+  3: { code: "Digit3" },
+  4: { code: "Digit4" },
+  5: { code: "Digit5" },
+  6: { code: "Digit6" },
+  7: { code: "Digit7" },
+  8: { code: "Digit8" },
+  9: { code: "Digit9" },
+  ":": { code: "Semicolon", shifted: true },
+  ";": { code: "Semicolon" },
+  "<": { code: "Comma", shifted: true },
+  "=": { code: "Equal" },
+  ">": { code: "Period", shifted: true },
+  "?": { code: "Slash", shifted: true },
+  "@": { code: "Digit2", shifted: true },
+  A: { code: "KeyA", shifted: true },
+  B: { code: "KeyB", shifted: true },
+  C: { code: "KeyC", shifted: true },
+  D: { code: "KeyD", shifted: true },
+  E: { code: "KeyE", shifted: true },
+  F: { code: "KeyF", shifted: true },
+  G: { code: "KeyG", shifted: true },
+  H: { code: "KeyH", shifted: true },
+  I: { code: "KeyI", shifted: true },
+  J: { code: "KeyJ", shifted: true },
+  K: { code: "KeyK", shifted: true },
+  L: { code: "KeyL", shifted: true },
+  M: { code: "KeyM", shifted: true },
+  N: { code: "KeyN", shifted: true },
+  O: { code: "KeyO", shifted: true },
+  P: { code: "KeyP", shifted: true },
+  Q: { code: "KeyQ", shifted: true },
+  R: { code: "KeyR", shifted: true },
+  S: { code: "KeyS", shifted: true },
+  T: { code: "KeyT", shifted: true },
+  U: { code: "KeyU", shifted: true },
+  V: { code: "KeyV", shifted: true },
+  W: { code: "KeyW", shifted: true },
+  X: { code: "KeyX", shifted: true },
+  Y: { code: "KeyY", shifted: true },
+  Z: { code: "KeyZ", shifted: true },
+  "[": { code: "BracketLeft" },
+  '"': { code: "Quote", shifted: true },
+  "\\": { code: "Backslash" },
+  "]": { code: "BracketRight" },
+  "^": { code: "Digit6", shifted: true },
+  _: { code: "Minus", shifted: true },
+  "`": { code: "Backquote" },
+  a: { code: "KeyA" },
+  b: { code: "KeyB" },
+  c: { code: "KeyC" },
+  d: { code: "KeyD" },
+  e: { code: "KeyE" },
+  f: { code: "KeyF" },
+  g: { code: "KeyG" },
+  h: { code: "KeyH" },
+  i: { code: "KeyI" },
+  j: { code: "KeyJ" },
+  k: { code: "KeyK" },
+  l: { code: "KeyL" },
+  m: { code: "KeyM" },
+  n: { code: "KeyN" },
+  o: { code: "KeyO" },
+  p: { code: "KeyP" },
+  q: { code: "KeyQ" },
+  r: { code: "KeyR" },
+  s: { code: "KeyS" },
+  t: { code: "KeyT" },
+  u: { code: "KeyU" },
+  v: { code: "KeyV" },
+  w: { code: "KeyW" },
+  x: { code: "KeyX" },
+  y: { code: "KeyY" },
+  z: { code: "KeyZ" },
+  "{": { code: "BracketLeft", shifted: true },
+  "|": { code: "Backslash", shifted: true },
+  "}": { code: "BracketRight", shifted: true },
+  "~": { code: "Backquote", shifted: true },
+  "\uE000": { key: "Unidentified", printable: false },
+  "\uE001": { key: "Cancel", printable: false },
+  "\uE002": { code: "Help", key: "Help", printable: false },
+  "\uE003": { code: "Backspace", key: "Backspace", printable: false },
+  "\uE004": { code: "Tab", key: "Tab", printable: false },
+  "\uE005": { code: "", key: "Clear", printable: false },
+  "\uE006": { code: "Enter", key: "Enter", printable: false },
+  "\uE007": {
+    code: "NumpadEnter",
+    key: "Enter",
+    location: 1,
+    printable: false,
+  },
+  "\uE008": {
+    code: "ShiftLeft",
+    key: "Shift",
+    location: 1,
+    modifier: "shiftKey",
+    printable: false,
+  },
+  "\uE009": {
+    code: "ControlLeft",
+    key: "Control",
+    location: 1,
+    modifier: "ctrlKey",
+    printable: false,
+  },
+  "\uE00A": {
+    code: "AltLeft",
+    key: "Alt",
+    location: 1,
+    modifier: "altKey",
+    printable: false,
+  },
+  "\uE00B": { code: "", key: "Pause", printable: false },
+  "\uE00C": { code: "Escape", key: "Escape", printable: false },
+  "\uE00D": { code: "Space", key: " ", shifted: true },
+  "\uE00E": { code: "PageUp", key: "PageUp", printable: false },
+  "\uE00F": { code: "PageDown", key: "PageDown", printable: false },
+  "\uE010": { code: "End", key: "End", printable: false },
+  "\uE011": { code: "Home", key: "Home", printable: false },
+  "\uE012": { code: "ArrowLeft", key: "ArrowLeft", printable: false },
+  "\uE013": { code: "ArrowUp", key: "ArrowUp", printable: false },
+  "\uE014": { code: "ArrowRight", key: "ArrowRight", printable: false },
+  "\uE015": { code: "ArrowDown", key: "ArrowDown", printable: false },
+  "\uE016": { code: "Insert", key: "Insert", printable: false },
+  "\uE017": { code: "Delete", key: "Delete", printable: false },
+  "\uE018": { code: "", key: ";" },
+  "\uE019": { code: "", key: "=" },
+  "\uE01A": { code: "Numpad0", key: "0", location: 3 },
+  "\uE01B": { code: "Numpad1", key: "1", location: 3 },
+  "\uE01C": { code: "Numpad2", key: "2", location: 3 },
+  "\uE01D": { code: "Numpad3", key: "3", location: 3 },
+  "\uE01E": { code: "Numpad4", key: "4", location: 3 },
+  "\uE01F": { code: "Numpad5", key: "5", location: 3 },
+  "\uE020": { code: "Numpad6", key: "6", location: 3 },
+  "\uE021": { code: "Numpad7", key: "7", location: 3 },
+  "\uE022": { code: "Numpad8", key: "8", location: 3 },
+  "\uE023": { code: "Numpad9", key: "9", location: 3 },
+  "\uE024": { code: "NumpadMultiply", key: "*", location: 3 },
+  "\uE025": { code: "NumpadAdd", key: "+", location: 3 },
+  "\uE026": { code: "NumpadComma", key: ",", location: 3 },
+  "\uE027": { code: "NumpadSubtract", key: "-", location: 3 },
+  "\uE028": { code: "NumpadDecimal", key: ".", location: 3 },
+  "\uE029": { code: "NumpadDivide", key: "/", location: 3 },
+  "\uE031": { code: "F1", key: "F1", printable: false },
+  "\uE032": { code: "F2", key: "F2", printable: false },
+  "\uE033": { code: "F3", key: "F3", printable: false },
+  "\uE034": { code: "F4", key: "F4", printable: false },
+  "\uE035": { code: "F5", key: "F5", printable: false },
+  "\uE036": { code: "F6", key: "F6", printable: false },
+  "\uE037": { code: "F7", key: "F7", printable: false },
+  "\uE038": { code: "F8", key: "F8", printable: false },
+  "\uE039": { code: "F9", key: "F9", printable: false },
+  "\uE03A": { code: "F10", key: "F10", printable: false },
+  "\uE03B": { code: "F11", key: "F11", printable: false },
+  "\uE03C": { code: "F12", key: "F12", printable: false },
+  "\uE03D": {
+    code: "OSLeft",
+    key: "Meta",
+    location: 1,
+    modifier: "metaKey",
+    printable: false,
+  },
+  "\uE040": { code: "", key: "ZenkakuHankaku", printable: false },
+  "\uE050": {
+    code: "ShiftRight",
+    key: "Shift",
+    location: 2,
+    modifier: "shiftKey",
+    printable: false,
+  },
+  "\uE051": {
+    code: "ControlRight",
+    key: "Control",
+    location: 2,
+    modifier: "ctrlKey",
+    printable: false,
+  },
+  "\uE052": {
+    code: "AltRight",
+    key: "Alt",
+    location: 2,
+    modifier: "altKey",
+    printable: false,
+  },
+  "\uE053": {
+    code: "OSRight",
+    key: "Meta",
+    location: 2,
+    modifier: "metaKey",
+    printable: false,
+  },
+  "\uE054": {
+    code: "Numpad9",
+    key: "PageUp",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE055": {
+    code: "Numpad3",
+    key: "PageDown",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE056": {
+    code: "Numpad1",
+    key: "End",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE057": {
+    code: "Numpad7",
+    key: "Home",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE058": {
+    code: "Numpad4",
+    key: "ArrowLeft",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE059": {
+    code: "Numpad8",
+    key: "ArrowUp",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE05A": {
+    code: "Numpad6",
+    key: "ArrowRight",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE05B": {
+    code: "Numpad2",
+    key: "ArrowDown",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE05C": {
+    code: "Numpad0",
+    key: "Insert",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+  "\uE05D": {
+    code: "NumpadDecimal",
+    key: "Delete",
+    location: 3,
+    printable: false,
+    shifted: true,
+  },
+};
+
+const lazy = {};
+
+XPCOMUtils.defineLazyGetter(lazy, "SHIFT_DATA", () => {
+  // Initalize the shift mapping
+  const shiftData = new Map();
+  const byCode = new Map();
+  for (let [key, props] of Object.entries(KEY_DATA)) {
+    if (props.code) {
+      if (!byCode.has(props.code)) {
+        byCode.set(props.code, [null, null]);
+      }
+      byCode.get(props.code)[props.shifted ? 1 : 0] = key;
+    }
+  }
+  for (let [unshifted, shifted] of byCode.values()) {
+    if (unshifted !== null && shifted !== null) {
+      shiftData.set(unshifted, shifted);
+    }
+  }
+  return shiftData;
+});
+
+export const keyData = {
+  /**
+   * Get key event data for a given key character.
+   *
+   * @param {string} rawKey
+   *     Key for which to get data. This can either be the key codepoint
+   *     itself or one of the codepoints in the range U+E000-U+E05D that
+   *     WebDriver uses to represent keys not corresponding directly to
+   *     a codepoint.
+   * @returns {object} Key event data object.
+   */
+  getData(rawKey) {
+    let keyData = { key: rawKey, location: 0, printable: true, shifted: false };
+    if (KEY_DATA.hasOwnProperty(rawKey)) {
+      keyData = { ...keyData, ...KEY_DATA[rawKey] };
+    }
+    return keyData;
+  },
+
+  /**
+   * Get shifted key character for a given key character.
+   *
+   * For characters unaffected by the shift key, this returns the input.
+   *
+   * @param {string} rawKey Key for which to get shifted key.
+   * @returns {string} Key string to use when the shift modifier is set.
+   */
+  getShiftedKey(rawKey) {
+    return lazy.SHIFT_DATA.get(rawKey) ?? rawKey;
+  },
+};
diff --git a/remote/shared/webdriver/NodeCache.sys.mjs b/remote/shared/webdriver/NodeCache.sys.mjs
new file mode 100644
index 0000000000..5290726a8a
--- /dev/null
+++ b/remote/shared/webdriver/NodeCache.sys.mjs
@@ -0,0 +1,169 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  generateUUID: "chrome://remote/content/shared/UUID.sys.mjs",
+});
+
+/**
+ * @typedef {object} NodeReferenceDetails
+ * @property {number} browserId
+ * @property {number} browsingContextGroupId
+ * @property {number} browsingContextId
+ * @property {boolean} isTopBrowsingContext
+ * @property {WeakRef} nodeWeakRef
+ */
+
+/**
+ * The class provides a mapping between DOM nodes and a unique node references.
+ * Supported types of nodes are Element and ShadowRoot.
+ */
+export class NodeCache {
+  #nodeIdMap;
+  #seenNodesMap;
+
+  constructor() {
+    // node => node id
+    this.#nodeIdMap = new WeakMap();
+
+    // Reverse map for faster lookup requests of node references. Values do
+    // not only contain the resolved DOM node but also further details like
+    // browsing context information.
+    //
+    // node id => node details
+    this.#seenNodesMap = new Map();
+  }
+
+  /**
+   * Get the number of nodes in the cache.
+   */
+  get size() {
+    return this.#seenNodesMap.size;
+  }
+
+  /**
+   * Get or if not yet existent create a unique reference for an Element or
+   * ShadowRoot node.
+   *
+   * @param {Node} node
+   *    The node to be added.
+   *
+   * @returns {string}
+   *     The unique node reference for the DOM node.
+   */
+  getOrCreateNodeReference(node) {
+    if (!Node.isInstance(node)) {
+      throw new TypeError(`Failed to create node reference for ${node}`);
+    }
+
+    let nodeId;
+    if (this.#nodeIdMap.has(node)) {
+      // For already known nodes return the cached node id.
+      nodeId = this.#nodeIdMap.get(node);
+    } else {
+      // Bug 1820734: For some Node types like `CDATA` no `ownerGlobal`
+      // property is available, and as such they cannot be deserialized
+      // right now.
+      const browsingContext = node.ownerGlobal?.browsingContext;
+
+      // For not yet cached nodes generate a unique id without curly braces.
+      nodeId = lazy.generateUUID();
+
+      const details = {
+        browserId: browsingContext?.browserId,
+        browsingContextGroupId: browsingContext?.group.id,
+        browsingContextId: browsingContext?.id,
+        isTopBrowsingContext: browsingContext?.parent === null,
+        nodeWeakRef: Cu.getWeakReference(node),
+      };
+
+      this.#nodeIdMap.set(node, nodeId);
+      this.#seenNodesMap.set(nodeId, details);
+    }
+
+    return nodeId;
+  }
+
+  /**
+   * Clear known DOM nodes.
+   *
+   * @param {object=} options
+   * @param {boolean=} options.all
+   *     Clear all references from any browsing context. Defaults to false.
+   * @param {BrowsingContext=} options.browsingContext
+   *     Clear all references living in that browsing context.
+   */
+  clear(options = {}) {
+    const { all = false, browsingContext } = options;
+
+    if (all) {
+      this.#nodeIdMap = new WeakMap();
+      this.#seenNodesMap.clear();
+      return;
+    }
+
+    if (browsingContext) {
+      for (const [nodeId, identifier] of this.#seenNodesMap.entries()) {
+        const { browsingContextId, nodeWeakRef } = identifier;
+        const node = nodeWeakRef.get();
+
+        if (browsingContextId === browsingContext.id) {
+          this.#nodeIdMap.delete(node);
+          this.#seenNodesMap.delete(nodeId);
+        }
+      }
+
+      return;
+    }
+
+    throw new Error(`Requires "browsingContext" or "all" to be set.`);
+  }
+
+  /**
+   * Get a DOM node by its unique reference.
+   *
+   * @param {BrowsingContext} browsingContext
+   *     The browsing context the node should be part of.
+   * @param {string} nodeId
+   *     The unique node reference of the DOM node.
+   *
+   * @returns {Node|null}
+   *     The DOM node that the unique identifier was generated for or
+   *     `null` if the node does not exist anymore.
+   */
+  getNode(browsingContext, nodeId) {
+    const nodeDetails = this.getReferenceDetails(nodeId);
+
+    // Check that the node reference is known, and is associated with a
+    // browsing context that shares the same browsing context group.
+    if (
+      nodeDetails === null ||
+      nodeDetails.browsingContextGroupId !== browsingContext.group.id
+    ) {
+      return null;
+    }
+
+    if (nodeDetails.nodeWeakRef) {
+      return nodeDetails.nodeWeakRef.get();
+    }
+
+    return null;
+  }
+
+  /**
+   * Get detailed information for the node reference.
+   *
+   * @param {string} nodeId
+   *
+   * @returns {NodeReferenceDetails}
+   *     Node details like: browsingContextId
+   */
+  getReferenceDetails(nodeId) {
+    const details = this.#seenNodesMap.get(nodeId);
+
+    return details !== undefined ? details : null;
+  }
+}
diff --git a/remote/shared/webdriver/Session.sys.mjs b/remote/shared/webdriver/Session.sys.mjs
new file mode 100644
index 0000000000..d09ad47e79
--- /dev/null
+++ b/remote/shared/webdriver/Session.sys.mjs
@@ -0,0 +1,344 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  accessibility: "chrome://remote/content/marionette/accessibility.sys.mjs",
+  allowAllCerts: "chrome://remote/content/marionette/cert.sys.mjs",
+  Capabilities: "chrome://remote/content/shared/webdriver/Capabilities.sys.mjs",
+  error: "chrome://remote/content/shared/webdriver/Errors.sys.mjs",
+  generateUUID: "chrome://remote/content/shared/UUID.sys.mjs",
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  registerProcessDataActor:
+    "chrome://remote/content/shared/webdriver/process-actors/WebDriverProcessDataParent.sys.mjs",
+  RootMessageHandler:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandler.sys.mjs",
+  RootMessageHandlerRegistry:
+    "chrome://remote/content/shared/messagehandler/RootMessageHandlerRegistry.sys.mjs",
+  unregisterProcessDataActor:
+    "chrome://remote/content/shared/webdriver/process-actors/WebDriverProcessDataParent.sys.mjs",
+  WebDriverBiDiConnection:
+    "chrome://remote/content/webdriver-bidi/WebDriverBiDiConnection.sys.mjs",
+  WebSocketHandshake:
+    "chrome://remote/content/server/WebSocketHandshake.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * Representation of WebDriver session.
+ */
+export class WebDriverSession {
+  /**
+   * Construct a new WebDriver session.
+   *
+   * It is expected that the caller performs the necessary checks on
+   * the requested capabilities to be WebDriver conforming.  The WebDriver
+   * service offered by Marionette does not match or negotiate capabilities
+   * beyond type- and bounds checks.
+   *
+   * <h3>Capabilities</h3>
+   *
+   * <dl>
+   *  <dt><code>acceptInsecureCerts</code> (boolean)
+   *  <dd>Indicates whether untrusted and self-signed TLS certificates
+   *   are implicitly trusted on navigation for the duration of the session.
+   *
+   *  <dt><code>pageLoadStrategy</code> (string)
+   *  <dd>The page load strategy to use for the current session.  Must be
+   *   one of "<tt>none</tt>", "<tt>eager</tt>", and "<tt>normal</tt>".
+   *
+   *  <dt><code>proxy</code> (Proxy object)
+   *  <dd>Defines the proxy configuration.
+   *
+   *  <dt><code>setWindowRect</code> (boolean)
+   *  <dd>Indicates whether the remote end supports all of the resizing
+   *   and repositioning commands.
+   *
+   *  <dt><code>timeouts</code> (Timeouts object)
+   *  <dd>Describes the timeouts imposed on certian session operations.
+   *
+   *  <dt><code>strictFileInteractability</code> (boolean)
+   *  <dd>Defines the current session’s strict file interactability.
+   *
+   *  <dt><code>unhandledPromptBehavior</code> (string)
+   *  <dd>Describes the current session’s user prompt handler.  Must be one of
+   *   "<tt>accept</tt>", "<tt>accept and notify</tt>", "<tt>dismiss</tt>",
+   *   "<tt>dismiss and notify</tt>", and "<tt>ignore</tt>".  Defaults to the
+   *   "<tt>dismiss and notify</tt>" state.
+   *
+   *  <dt><code>moz:accessibilityChecks</code> (boolean)
+   *  <dd>Run a11y checks when clicking elements.
+   *
+   *  <dt><code>moz:debuggerAddress</code> (boolean)
+   *  <dd>Indicate that the Chrome DevTools Protocol (CDP) has to be enabled.
+   *
+   *  <dt><code>moz:useNonSpecCompliantPointerOrigin</code> (boolean)
+   *  <dd>Use the not WebDriver conforming calculation of the pointer origin
+   *   when the origin is an element, and the element center point is used.
+   *
+   *  <dt><code>moz:webdriverClick</code> (boolean)
+   *  <dd>Use a WebDriver conforming <i>WebDriver::ElementClick</i>.
+   * </dl>
+   *
+   * <h4>Timeouts object</h4>
+   *
+   * <dl>
+   *  <dt><code>script</code> (number)
+   *  <dd>Determines when to interrupt a script that is being evaluates.
+   *
+   *  <dt><code>pageLoad</code> (number)
+   *  <dd>Provides the timeout limit used to interrupt navigation of the
+   *   browsing context.
+   *
+   *  <dt><code>implicit</code> (number)
+   *  <dd>Gives the timeout of when to abort when locating an element.
+   * </dl>
+   *
+   * <h4>Proxy object</h4>
+   *
+   * <dl>
+   *  <dt><code>proxyType</code> (string)
+   *  <dd>Indicates the type of proxy configuration.  Must be one
+   *   of "<tt>pac</tt>", "<tt>direct</tt>", "<tt>autodetect</tt>",
+   *   "<tt>system</tt>", or "<tt>manual</tt>".
+   *
+   *  <dt><code>proxyAutoconfigUrl</code> (string)
+   *  <dd>Defines the URL for a proxy auto-config file if
+   *   <code>proxyType</code> is equal to "<tt>pac</tt>".
+   *
+   *  <dt><code>httpProxy</code> (string)
+   *  <dd>Defines the proxy host for HTTP traffic when the
+   *   <code>proxyType</code> is "<tt>manual</tt>".
+   *
+   *  <dt><code>noProxy</code> (string)
+   *  <dd>Lists the adress for which the proxy should be bypassed when
+   *   the <code>proxyType</code> is "<tt>manual</tt>".  Must be a JSON
+   *   List containing any number of any of domains, IPv4 addresses, or IPv6
+   *   addresses.
+   *
+   *  <dt><code>sslProxy</code> (string)
+   *  <dd>Defines the proxy host for encrypted TLS traffic when the
+   *   <code>proxyType</code> is "<tt>manual</tt>".
+   *
+   *  <dt><code>socksProxy</code> (string)
+   *  <dd>Defines the proxy host for a SOCKS proxy traffic when the
+   *   <code>proxyType</code> is "<tt>manual</tt>".
+   *
+   *  <dt><code>socksVersion</code> (string)
+   *  <dd>Defines the SOCKS proxy version when the <code>proxyType</code> is
+   *   "<tt>manual</tt>".  It must be any integer between 0 and 255
+   *   inclusive.
+   * </dl>
+   *
+   * <h3>Example</h3>
+   *
+   * Input:
+   *
+   * <pre><code>
+   *     {"capabilities": {"acceptInsecureCerts": true}}
+   * </code></pre>
+   *
+   * @param {Object<string, *>=} capabilities
+   *     JSON Object containing any of the recognised capabilities listed
+   *     above.
+   *
+   * @param {WebDriverBiDiConnection=} connection
+   *     An optional existing WebDriver BiDi connection to associate with the
+   *     new session.
+   *
+   * @throws {SessionNotCreatedError}
+   *     If, for whatever reason, a session could not be created.
+   */
+  constructor(capabilities, connection) {
+    // WebSocket connections that use this session. This also accounts for
+    // possible disconnects due to network outages, which require clients
+    // to reconnect.
+    this._connections = new Set();
+
+    this.id = lazy.generateUUID();
+
+    // Define the HTTP path to query this session via WebDriver BiDi
+    this.path = `/session/${this.id}`;
+
+    try {
+      this.capabilities = lazy.Capabilities.fromJSON(capabilities, this.path);
+    } catch (e) {
+      throw new lazy.error.SessionNotCreatedError(e);
+    }
+
+    if (this.capabilities.get("acceptInsecureCerts")) {
+      lazy.logger.warn(
+        "TLS certificate errors will be ignored for this session"
+      );
+      lazy.allowAllCerts.enable();
+    }
+
+    if (this.proxy.init()) {
+      lazy.logger.info(
+        `Proxy settings initialised: ${JSON.stringify(this.proxy)}`
+      );
+    }
+
+    // If we are testing accessibility with marionette, start a11y service in
+    // chrome first. This will ensure that we do not have any content-only
+    // services hanging around.
+    if (this.a11yChecks && lazy.accessibility.service) {
+      lazy.logger.info("Preemptively starting accessibility service in Chrome");
+    }
+
+    // If a connection without an associated session has been specified
+    // immediately register the newly created session for it.
+    if (connection) {
+      connection.registerSession(this);
+      this._connections.add(connection);
+    }
+
+    lazy.registerProcessDataActor();
+  }
+
+  destroy() {
+    lazy.allowAllCerts.disable();
+
+    // Close all open connections which unregister themselves.
+    this._connections.forEach(connection => connection.close());
+    if (this._connections.size > 0) {
+      lazy.logger.warn(
+        `Failed to close ${this._connections.size} WebSocket connections`
+      );
+    }
+
+    // Destroy the dedicated MessageHandler instance if we created one.
+    if (this._messageHandler) {
+      this._messageHandler.off(
+        "message-handler-protocol-event",
+        this._onMessageHandlerProtocolEvent
+      );
+      this._messageHandler.destroy();
+    }
+
+    lazy.unregisterProcessDataActor();
+  }
+
+  async execute(module, command, params) {
+    // XXX: At the moment, commands do not describe consistently their destination,
+    // so we will need a translation step based on a specific command and its params
+    // in order to extract a destination that can be understood by the MessageHandler.
+    //
+    // For now, an option is to send all commands to ROOT, and all BiDi MessageHandler
+    // modules will therefore need to implement this translation step in the root
+    // implementation of their module.
+    const destination = {
+      type: lazy.RootMessageHandler.type,
+    };
+    if (!this.messageHandler.supportsCommand(module, command, destination)) {
+      throw new lazy.error.UnknownCommandError(`${module}.${command}`);
+    }
+
+    return this.messageHandler.handleCommand({
+      moduleName: module,
+      commandName: command,
+      params,
+      destination,
+    });
+  }
+
+  get a11yChecks() {
+    return this.capabilities.get("moz:accessibilityChecks");
+  }
+
+  get messageHandler() {
+    if (!this._messageHandler) {
+      this._messageHandler =
+        lazy.RootMessageHandlerRegistry.getOrCreateMessageHandler(this.id);
+      this._onMessageHandlerProtocolEvent =
+        this._onMessageHandlerProtocolEvent.bind(this);
+      this._messageHandler.on(
+        "message-handler-protocol-event",
+        this._onMessageHandlerProtocolEvent
+      );
+    }
+
+    return this._messageHandler;
+  }
+
+  get pageLoadStrategy() {
+    return this.capabilities.get("pageLoadStrategy");
+  }
+
+  get proxy() {
+    return this.capabilities.get("proxy");
+  }
+
+  get strictFileInteractability() {
+    return this.capabilities.get("strictFileInteractability");
+  }
+
+  get timeouts() {
+    return this.capabilities.get("timeouts");
+  }
+
+  set timeouts(timeouts) {
+    this.capabilities.set("timeouts", timeouts);
+  }
+
+  get unhandledPromptBehavior() {
+    return this.capabilities.get("unhandledPromptBehavior");
+  }
+
+  /**
+   * Remove the specified WebDriver BiDi connection.
+   *
+   * @param {WebDriverBiDiConnection} connection
+   */
+  removeConnection(connection) {
+    if (this._connections.has(connection)) {
+      this._connections.delete(connection);
+    } else {
+      lazy.logger.warn("Trying to remove a connection that doesn't exist.");
+    }
+  }
+
+  toString() {
+    return `[object ${this.constructor.name} ${this.id}]`;
+  }
+
+  // nsIHttpRequestHandler
+
+  /**
+   * Handle new WebSocket connection requests.
+   *
+   * WebSocket clients will attempt to connect to this session at
+   * `/session/:id`.  Hereby a WebSocket upgrade will automatically
+   * be performed.
+   *
+   * @param {Request} request
+   *     HTTP request (httpd.js)
+   * @param {Response} response
+   *     Response to an HTTP request (httpd.js)
+   */
+  async handle(request, response) {
+    const webSocket = await lazy.WebSocketHandshake.upgrade(request, response);
+    const conn = new lazy.WebDriverBiDiConnection(
+      webSocket,
+      response._connection
+    );
+    conn.registerSession(this);
+    this._connections.add(conn);
+  }
+
+  _onMessageHandlerProtocolEvent(eventName, messageHandlerEvent) {
+    const { name, data } = messageHandlerEvent;
+    this._connections.forEach(connection => connection.sendEvent(name, data));
+  }
+
+  // XPCOM
+
+  get QueryInterface() {
+    return ChromeUtils.generateQI(["nsIHttpRequestHandler"]);
+  }
+}
diff --git a/remote/shared/webdriver/process-actors/WebDriverProcessDataChild.sys.mjs b/remote/shared/webdriver/process-actors/WebDriverProcessDataChild.sys.mjs
new file mode 100644
index 0000000000..47e6429035
--- /dev/null
+++ b/remote/shared/webdriver/process-actors/WebDriverProcessDataChild.sys.mjs
@@ -0,0 +1,95 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+  NodeCache: "chrome://remote/content/shared/webdriver/NodeCache.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+// Observer to clean-up element references for closed browsing contexts.
+class BrowsingContextObserver {
+  constructor(actor) {
+    this.actor = actor;
+  }
+
+  async observe(subject, topic, data) {
+    if (topic === "browsing-context-discarded") {
+      this.actor.cleanUp({ browsingContext: subject });
+    }
+  }
+}
+
+export class WebDriverProcessDataChild extends JSProcessActorChild {
+  #browsingContextObserver;
+  #nodeCache;
+
+  constructor() {
+    super();
+
+    // For now have a single reference store only. Once multiple WebDriver
+    // sessions are supported, it needs to be hashed by the session id.
+    this.#nodeCache = new lazy.NodeCache();
+
+    // Register observer to cleanup element references when a browsing context
+    // gets destroyed.
+    this.#browsingContextObserver = new BrowsingContextObserver(this);
+    Services.obs.addObserver(
+      this.#browsingContextObserver,
+      "browsing-context-discarded"
+    );
+  }
+
+  actorCreated() {
+    lazy.logger.trace(
+      `WebDriverProcessData actor created for PID ${Services.appinfo.processID}`
+    );
+  }
+
+  didDestroy() {
+    Services.obs.removeObserver(
+      this.#browsingContextObserver,
+      "browsing-context-discarded"
+    );
+  }
+
+  /**
+   * Clean up all the process specific data.
+   *
+   * @param {object=} options
+   * @param {BrowsingContext=} options.browsingContext
+   *     If specified only clear data living in that browsing context.
+   */
+  cleanUp(options = {}) {
+    const { browsingContext = null } = options;
+
+    this.#nodeCache.clear({ browsingContext });
+  }
+
+  /**
+   * Get the node cache.
+   *
+   * @returns {NodeCache}
+   *     The cache containing DOM node references.
+   */
+  getNodeCache() {
+    return this.#nodeCache;
+  }
+
+  async receiveMessage(msg) {
+    switch (msg.name) {
+      case "WebDriverProcessDataParent:CleanUp":
+        return this.cleanUp(msg.data);
+      default:
+        return Promise.reject(
+          new Error(`Unexpected message received: ${msg.name}`)
+        );
+    }
+  }
+}
diff --git a/remote/shared/webdriver/process-actors/WebDriverProcessDataParent.sys.mjs b/remote/shared/webdriver/process-actors/WebDriverProcessDataParent.sys.mjs
new file mode 100644
index 0000000000..43c48fbec4
--- /dev/null
+++ b/remote/shared/webdriver/process-actors/WebDriverProcessDataParent.sys.mjs
@@ -0,0 +1,39 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import { XPCOMUtils } from "resource://gre/modules/XPCOMUtils.sys.mjs";
+
+const lazy = {};
+
+ChromeUtils.defineESModuleGetters(lazy, {
+  Log: "chrome://remote/content/shared/Log.sys.mjs",
+});
+
+XPCOMUtils.defineLazyGetter(lazy, "logger", () => lazy.Log.get());
+
+/**
+ * Register the WebDriverProcessData actor that holds session data.
+ */
+export function registerProcessDataActor() {
+  try {
+    ChromeUtils.registerProcessActor("WebDriverProcessData", {
+      kind: "JSProcessActor",
+      child: {
+        esModuleURI:
+          "chrome://remote/content/shared/webdriver/process-actors/WebDriverProcessDataChild.sys.mjs",
+      },
+      includeParent: true,
+    });
+  } catch (e) {
+    if (e.name === "NotSupportedError") {
+      lazy.logger.warn(`WebDriverProcessData actor is already registered!`);
+    } else {
+      throw e;
+    }
+  }
+}
+
+export function unregisterProcessDataActor() {
+  ChromeUtils.unregisterProcessActor("WebDriverProcessData");
+}
diff --git a/remote/shared/webdriver/test/xpcshell/head.js b/remote/shared/webdriver/test/xpcshell/head.js
new file mode 100644
index 0000000000..ddc5573d78
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/head.js
@@ -0,0 +1,15 @@
+async function doGC() {
+  // Run GC and CC a few times to make sure that as much as possible is freed.
+  const numCycles = 3;
+  for (let i = 0; i < numCycles; i++) {
+    Cu.forceGC();
+    Cu.forceCC();
+    await new Promise(resolve => Cu.schedulePreciseShrinkingGC(resolve));
+  }
+
+  const MemoryReporter = Cc[
+    "@mozilla.org/memory-reporter-manager;1"
+  ].getService(Ci.nsIMemoryReporterManager);
+
+  await new Promise(resolve => MemoryReporter.minimizeMemoryUsage(resolve));
+}
diff --git a/remote/shared/webdriver/test/xpcshell/test_Actions.js b/remote/shared/webdriver/test/xpcshell/test_Actions.js
new file mode 100644
index 0000000000..01e345e253
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/test_Actions.js
@@ -0,0 +1,706 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const { action } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Actions.sys.mjs"
+);
+
+const XHTMLNS = "http://www.w3.org/1999/xhtml";
+
+const domEl = {
+  nodeType: 1,
+  ELEMENT_NODE: 1,
+  namespaceURI: XHTMLNS,
+};
+
+add_task(function test_createInputState() {
+  for (let type of ["none", "key", "pointer" /*"wheel"*/]) {
+    const state = new action.State();
+    const id = "device";
+    const actionSequence = {
+      type,
+      id,
+      actions: [],
+    };
+    action.Chain.fromJSON(state, [actionSequence]);
+    equal(state.inputStateMap.size, 1);
+    equal(state.inputStateMap.get(id).constructor.type, type);
+  }
+});
+
+add_task(function test_defaultPointerParameters() {
+  let state = new action.State();
+  const inputTickActions = [
+    { type: "pointer", subtype: "pointerDown", button: 0 },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  const pointerAction = chain[0][0];
+  equal(
+    state.getInputSource(pointerAction.id).pointer.constructor.type,
+    "mouse"
+  );
+});
+
+add_task(function test_processPointerParameters() {
+  for (let subtype of ["pointerDown", "pointerUp"]) {
+    for (let pointerType of ["foo", "", "get", "Get", 2, {}]) {
+      const inputTickActions = [
+        {
+          type: "pointer",
+          parameters: { pointerType },
+          subtype,
+          button: 0,
+        },
+      ];
+      let message = `Action sequence with parameters: {pointerType: ${pointerType} subtype: ${subtype}}`;
+      checkFromJSONErrors(inputTickActions, /Unknown pointerType/, message);
+    }
+  }
+
+  for (let pointerType of ["mouse" /*"touch"*/]) {
+    let state = new action.State();
+    const inputTickActions = [
+      {
+        type: "pointer",
+        parameters: { pointerType },
+        subtype: "pointerDown",
+        button: 0,
+      },
+    ];
+    const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+    const pointerAction = chain[0][0];
+    equal(
+      state.getInputSource(pointerAction.id).pointer.constructor.type,
+      pointerType
+    );
+  }
+});
+
+add_task(function test_processPointerDownAction() {
+  for (let button of [-1, "a"]) {
+    const inputTickActions = [
+      { type: "pointer", subtype: "pointerDown", button },
+    ];
+    checkFromJSONErrors(
+      inputTickActions,
+      /Expected 'button' .* to be >= 0/,
+      `pointerDown with {button: ${button}}`
+    );
+  }
+  let state = new action.State();
+  const inputTickActions = [
+    { type: "pointer", subtype: "pointerDown", button: 5 },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  equal(chain[0][0].button, 5);
+});
+
+add_task(function test_validateActionDurationAndCoordinates() {
+  for (let [type, subtype] of [
+    ["none", "pause"],
+    ["pointer", "pointerMove"],
+  ]) {
+    for (let duration of [-1, "a"]) {
+      const inputTickActions = [{ type, subtype, duration }];
+      checkFromJSONErrors(
+        inputTickActions,
+        /Expected 'duration' .* to be >= 0/,
+        `{subtype} with {duration: ${duration}}`
+      );
+    }
+  }
+  for (let name of ["x", "y"]) {
+    const actionItem = {
+      type: "pointer",
+      subtype: "pointerMove",
+      duration: 5000,
+    };
+    actionItem[name] = "a";
+    checkFromJSONErrors(
+      [actionItem],
+      /Expected '.*' \(.*\) to be an Integer/,
+      `${name}: "a", subtype: pointerMove`
+    );
+  }
+});
+
+add_task(function test_processPointerMoveActionOriginValidation() {
+  for (let origin of [-1, { a: "blah" }, []]) {
+    const inputTickActions = [
+      { type: "pointer", duration: 5000, subtype: "pointerMove", origin },
+    ];
+    checkFromJSONErrors(
+      inputTickActions,
+      /Expected \'origin\' to be undefined, "viewport", "pointer", or an element/,
+      `actionItem.origin: (${getTypeString(origin)})`
+    );
+  }
+});
+
+add_task(function test_processPointerMoveActionOriginStringValidation() {
+  for (let origin of ["a", "", "get", "Get"]) {
+    const inputTickActions = [
+      { type: "pointer", duration: 5000, subtype: "pointerMove", origin },
+    ];
+    checkFromJSONErrors(
+      inputTickActions,
+      /Expected 'origin' to be undefined, "viewport", "pointer", or an element/,
+      `actionItem.origin: ${origin}`
+    );
+  }
+});
+
+add_task(function test_processPointerMoveActionElementOrigin() {
+  let state = new action.State();
+  const inputTickActions = [
+    {
+      type: "pointer",
+      duration: 5000,
+      subtype: "pointerMove",
+      origin: domEl,
+      x: 0,
+      y: 0,
+    },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  deepEqual(chain[0][0].origin.element, domEl);
+});
+
+add_task(function test_processPointerMoveActionDefaultOrigin() {
+  let state = new action.State();
+  const inputTickActions = [
+    { type: "pointer", duration: 5000, subtype: "pointerMove", x: 0, y: 0 },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  // The default is viewport coordinates which have an origin at [0,0] and don't depend on inputSource
+  deepEqual(chain[0][0].origin.getOriginCoordinates(state, null, null), {
+    x: 0,
+    y: 0,
+  });
+});
+
+add_task(function test_processPointerMoveAction() {
+  let state = new action.State();
+  const actionItems = [
+    {
+      duration: 5000,
+      type: "pointerMove",
+      origin: undefined,
+      x: 0,
+      y: 0,
+    },
+    {
+      duration: undefined,
+      type: "pointerMove",
+      origin: domEl,
+      x: 0,
+      y: 0,
+    },
+    {
+      duration: 5000,
+      type: "pointerMove",
+      x: 1,
+      y: 2,
+      origin: undefined,
+    },
+  ];
+  const actionSequence = {
+    id: "some_id",
+    type: "pointer",
+    actions: actionItems,
+  };
+  let chain = action.Chain.fromJSON(state, [actionSequence]);
+  equal(chain.length, actionItems.length);
+  for (let i = 0; i < actionItems.length; i++) {
+    let actual = chain[i][0];
+    let expected = actionItems[i];
+    equal(actual.duration, expected.duration);
+    equal(actual.x, expected.x);
+    equal(actual.y, expected.y);
+
+    let originClass;
+    if (expected.origin === undefined || expected.origin == "viewport") {
+      originClass = "ViewportOrigin";
+    } else if (expected.origin === "pointer") {
+      originClass = "PointerOrigin";
+    } else {
+      originClass = "ElementOrigin";
+    }
+    deepEqual(actual.origin.constructor.name, originClass);
+  }
+});
+
+add_task(function test_computePointerDestinationViewport() {
+  const state = new action.State();
+  const inputTickActions = [
+    {
+      type: "pointer",
+      subtype: "pointerMove",
+      x: 100,
+      y: 200,
+      origin: "viewport",
+    },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  const actionItem = chain[0][0];
+  const inputSource = state.getInputSource(actionItem.id);
+  // these values should not affect the outcome
+  inputSource.x = "99";
+  inputSource.y = "10";
+  const target = actionItem.origin.getTargetCoordinates(
+    state,
+    inputSource,
+    [actionItem.x, actionItem.y],
+    null
+  );
+  equal(actionItem.x, target[0]);
+  equal(actionItem.y, target[1]);
+});
+
+add_task(function test_computePointerDestinationPointer() {
+  const state = new action.State();
+  const inputTickActions = [
+    {
+      type: "pointer",
+      subtype: "pointerMove",
+      x: 100,
+      y: 200,
+      origin: "pointer",
+    },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  const actionItem = chain[0][0];
+  const inputSource = state.getInputSource(actionItem.id);
+  inputSource.x = 10;
+  inputSource.y = 99;
+  const target = actionItem.origin.getTargetCoordinates(
+    state,
+    inputSource,
+    [actionItem.x, actionItem.y],
+    null
+  );
+  equal(actionItem.x + inputSource.x, target[0]);
+  equal(actionItem.y + inputSource.y, target[1]);
+});
+
+add_task(function test_processPointerAction() {
+  for (let pointerType of ["mouse", "touch"]) {
+    const actionItems = [
+      {
+        duration: 2000,
+        type: "pause",
+      },
+      {
+        type: "pointerMove",
+        duration: 2000,
+        x: 0,
+        y: 0,
+      },
+      {
+        type: "pointerUp",
+        button: 1,
+      },
+    ];
+    let actionSequence = {
+      type: "pointer",
+      id: "some_id",
+      parameters: {
+        pointerType,
+      },
+      actions: actionItems,
+    };
+    const state = new action.State();
+    const chain = action.Chain.fromJSON(state, [actionSequence]);
+    equal(chain.length, actionItems.length);
+    for (let i = 0; i < actionItems.length; i++) {
+      const actual = chain[i][0];
+      const expected = actionItems[i];
+      equal(actual.type, expected.type === "pause" ? "none" : "pointer");
+      equal(actual.subtype, expected.type);
+      equal(actual.id, actionSequence.id);
+      if (expected.type === "pointerUp") {
+        equal(actual.button, expected.button);
+      } else {
+        equal(actual.duration, expected.duration);
+      }
+      if (expected.type !== "pause") {
+        equal(
+          state.getInputSource(actual.id).pointer.constructor.type,
+          pointerType
+        );
+      }
+    }
+  }
+});
+
+add_task(function test_processPauseAction() {
+  for (let type of ["none", "key", "pointer"]) {
+    const state = new action.State();
+    const actionSequence = {
+      type,
+      id: "some_id",
+      actions: [{ type: "pause", duration: 5000 }],
+    };
+    const actionItem = action.Chain.fromJSON(state, [actionSequence])[0][0];
+    equal(actionItem.type, "none");
+    equal(actionItem.subtype, "pause");
+    equal(actionItem.id, "some_id");
+    equal(actionItem.duration, 5000);
+  }
+  const state = new action.State();
+  const actionSequence = {
+    type: "none",
+    id: "some_id",
+    actions: [{ type: "pause" }],
+  };
+  const actionItem = action.Chain.fromJSON(state, [actionSequence])[0][0];
+  equal(actionItem.duration, undefined);
+});
+
+add_task(function test_processActionSubtypeValidation() {
+  for (let type of ["none", "key", "pointer"]) {
+    const message = `type: ${type}, subtype: dancing`;
+    const inputTickActions = [{ type, subtype: "dancing" }];
+    checkFromJSONErrors(
+      inputTickActions,
+      new RegExp(`Unknown subtype dancing for type ${type}`),
+      message
+    );
+  }
+});
+
+add_task(function test_processKeyActionDown() {
+  for (let value of [-1, undefined, [], ["a"], { length: 1 }, null]) {
+    const inputTickActions = [{ type: "key", subtype: "keyDown", value }];
+    const message = `actionItem.value: (${getTypeString(value)})`;
+    checkFromJSONErrors(
+      inputTickActions,
+      /Expected 'value' to be a string that represents single code point/,
+      message
+    );
+  }
+
+  const state = new action.State();
+  const actionSequence = {
+    type: "key",
+    id: "keyboard",
+    actions: [{ type: "keyDown", value: "\uE004" }],
+  };
+  const actionItem = action.Chain.fromJSON(state, [actionSequence])[0][0];
+
+  equal(actionItem.type, "key");
+  equal(actionItem.id, "keyboard");
+  equal(actionItem.subtype, "keyDown");
+  equal(actionItem.value, "\ue004");
+});
+
+add_task(function test_processInputSourceActionSequenceValidation() {
+  checkFromJSONErrors(
+    [{ type: "swim", subtype: "pause", id: "some id" }],
+    /Unknown action type/,
+    "actionSequence type: swim"
+  );
+
+  checkFromJSONErrors(
+    [{ type: "none", subtype: "pause", id: -1 }],
+    /Expected 'id' to be a string/,
+    "actionSequence id: -1"
+  );
+
+  checkFromJSONErrors(
+    [{ type: "none", subtype: "pause", id: undefined }],
+    /Expected 'id' to be a string/,
+    "actionSequence id: undefined"
+  );
+
+  const state = new action.State();
+  const actionSequence = [
+    { type: "none", subtype: "pause", id: "some_id", actions: -1 },
+  ];
+  const errorRegex = /Expected 'actionSequence.actions' to be an array/;
+  const message = "actionSequence actions: -1";
+
+  Assert.throws(
+    () => action.Chain.fromJSON(state, actionSequence),
+    /InvalidArgumentError/,
+    message
+  );
+  Assert.throws(
+    () => action.Chain.fromJSON(state, actionSequence),
+    errorRegex,
+    message
+  );
+});
+
+add_task(function test_processInputSourceActionSequence() {
+  const state = new action.State();
+  const actionItem = { type: "pause", duration: 5 };
+  const actionSequence = {
+    type: "none",
+    id: "some id",
+    actions: [actionItem],
+  };
+  const chain = action.Chain.fromJSON(state, [actionSequence]);
+  equal(chain.length, 1);
+  const tickActions = chain[0];
+  equal(tickActions.length, 1);
+  equal(tickActions[0].type, "none");
+  equal(tickActions[0].subtype, "pause");
+  equal(tickActions[0].duration, 5);
+  equal(tickActions[0].id, "some id");
+});
+
+add_task(function test_processInputSourceActionSequencePointer() {
+  const state = new action.State();
+  const actionItem = { type: "pointerDown", button: 1 };
+  const actionSequence = {
+    type: "pointer",
+    id: "9",
+    actions: [actionItem],
+    parameters: {
+      pointerType: "mouse", // TODO "pen"
+    },
+  };
+  const chain = action.Chain.fromJSON(state, [actionSequence]);
+  equal(chain.length, 1);
+  const tickActions = chain[0];
+  equal(tickActions.length, 1);
+  equal(tickActions[0].type, "pointer");
+  equal(tickActions[0].subtype, "pointerDown");
+  equal(tickActions[0].button, 1);
+  equal(tickActions[0].id, "9");
+  const inputSource = state.getInputSource(tickActions[0].id);
+  equal(inputSource.constructor.type, "pointer");
+  equal(inputSource.pointer.constructor.type, "mouse");
+});
+
+add_task(function test_processInputSourceActionSequenceKey() {
+  const state = new action.State();
+  const actionItem = { type: "keyUp", value: "a" };
+  const actionSequence = {
+    type: "key",
+    id: "9",
+    actions: [actionItem],
+  };
+  const chain = action.Chain.fromJSON(state, [actionSequence]);
+  equal(chain.length, 1);
+  const tickActions = chain[0];
+  equal(tickActions.length, 1);
+  equal(tickActions[0].type, "key");
+  equal(tickActions[0].subtype, "keyUp");
+  equal(tickActions[0].value, "a");
+  equal(tickActions[0].id, "9");
+});
+
+add_task(function test_processInputSourceActionSequenceInputStateMap() {
+  const state = new action.State();
+  const id = "1";
+  const actionItem = { type: "pause", duration: 5000 };
+  const actionSequence = {
+    type: "key",
+    id,
+    actions: [actionItem],
+  };
+  action.Chain.fromJSON(state, [actionSequence]);
+  equal(state.inputStateMap.size, 1);
+  equal(state.inputStateMap.get(id).constructor.type, "key");
+
+  // Construct a different state with the same input id
+  const state1 = new action.State();
+  const actionItem1 = { type: "pointerDown", button: 0 };
+  const actionSequence1 = {
+    type: "pointer",
+    id,
+    actions: [actionItem1],
+  };
+  action.Chain.fromJSON(state1, [actionSequence1]);
+  equal(state1.inputStateMap.size, 1);
+
+  // Overwrite the state in the initial map with one of a different type
+  state.inputStateMap.set(id, state1.inputStateMap.get(id));
+  equal(state.inputStateMap.get(id).constructor.type, "pointer");
+
+  const message = "Wrong state for input id type";
+  Assert.throws(
+    () => action.Chain.fromJSON(state, [actionSequence]),
+    /InvalidArgumentError/,
+    message
+  );
+  Assert.throws(
+    () => action.Chain.fromJSON(state, [actionSequence]),
+    /Expected input source 1 to be type pointer, got key/,
+    message
+  );
+});
+
+add_task(function test_extractActionChainValidation() {
+  for (let actions of [-1, "a", undefined, null]) {
+    const state = new action.State();
+    let message = `actions: ${getTypeString(actions)}`;
+    Assert.throws(
+      () => action.Chain.fromJSON(state, actions),
+      /InvalidArgumentError/,
+      message
+    );
+    Assert.throws(
+      () => action.Chain.fromJSON(state, actions),
+      /Expected 'actions' to be an array/,
+      message
+    );
+  }
+});
+
+add_task(function test_extractActionChainEmpty() {
+  const state = new action.State();
+  deepEqual(action.Chain.fromJSON(state, []), []);
+});
+
+add_task(function test_extractActionChain_oneTickOneInput() {
+  const state = new action.State();
+  const actionItem = { type: "pause", duration: 5000 };
+  const actionSequence = {
+    type: "none",
+    id: "some id",
+    actions: [actionItem],
+  };
+  const actionsByTick = action.Chain.fromJSON(state, [actionSequence]);
+  equal(1, actionsByTick.length);
+  equal(1, actionsByTick[0].length);
+  equal(actionsByTick[0][0].id, actionSequence.id);
+  equal(actionsByTick[0][0].type, "none");
+  equal(actionsByTick[0][0].subtype, "pause");
+  equal(actionsByTick[0][0].duration, actionItem.duration);
+});
+
+add_task(function test_extractActionChain_twoAndThreeTicks() {
+  const state = new action.State();
+  const mouseActionItems = [
+    {
+      type: "pointerDown",
+      button: 2,
+    },
+    {
+      type: "pointerUp",
+      button: 2,
+    },
+  ];
+  const mouseActionSequence = {
+    type: "pointer",
+    id: "7",
+    actions: mouseActionItems,
+    parameters: {
+      pointerType: "mouse",
+    },
+  };
+  const keyActionItems = [
+    {
+      type: "keyDown",
+      value: "a",
+    },
+    {
+      type: "pause",
+      duration: 4,
+    },
+    {
+      type: "keyUp",
+      value: "a",
+    },
+  ];
+  let keyActionSequence = {
+    type: "key",
+    id: "1",
+    actions: keyActionItems,
+  };
+  let actionsByTick = action.Chain.fromJSON(state, [
+    keyActionSequence,
+    mouseActionSequence,
+  ]);
+  // number of ticks is same as longest action sequence
+  equal(keyActionItems.length, actionsByTick.length);
+  equal(2, actionsByTick[0].length);
+  equal(2, actionsByTick[1].length);
+  equal(1, actionsByTick[2].length);
+
+  equal(actionsByTick[2][0].id, keyActionSequence.id);
+  equal(actionsByTick[2][0].type, "key");
+  equal(actionsByTick[2][0].subtype, "keyUp");
+});
+
+add_task(function test_computeTickDuration() {
+  const state = new action.State();
+  const expected = 8000;
+  const inputTickActions = [
+    { type: "none", subtype: "pause", duration: 5000 },
+    { type: "key", subtype: "pause", duration: 1000 },
+    { type: "pointer", subtype: "pointerMove", duration: 6000, x: 0, y: 0 },
+    // invalid because keyDown should not have duration, so duration should be ignored.
+    { type: "key", subtype: "keyDown", duration: 100000, value: "a" },
+    { type: "pointer", subtype: "pause", duration: expected },
+    { type: "pointer", subtype: "pointerUp", button: 0 },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  equal(1, chain.length);
+  const tickActions = chain[0];
+  equal(expected, tickActions.getDuration());
+});
+
+add_task(function test_computeTickDuration_noDurations() {
+  const state = new action.State();
+  const inputTickActions = [
+    // invalid because keyDown should not have duration, so duration should be ignored.
+    { type: "key", subtype: "keyDown", duration: 100000, value: "a" },
+    // undefined duration permitted
+    { type: "none", subtype: "pause" },
+    { type: "pointer", subtype: "pointerMove", button: 0, x: 0, y: 0 },
+    { type: "pointer", subtype: "pointerDown", button: 0 },
+    { type: "key", subtype: "keyUp", value: "a" },
+  ];
+  const chain = action.Chain.fromJSON(state, chainForTick(inputTickActions));
+  equal(0, chain[0].getDuration());
+});
+
+// helpers
+function getTypeString(obj) {
+  return Object.prototype.toString.call(obj);
+}
+
+function checkFromJSONErrors(inputTickActions, regex, message) {
+  const state = new action.State();
+
+  if (typeof message == "undefined") {
+    message = `fromJSON`;
+  }
+  Assert.throws(
+    () => action.Chain.fromJSON(state, chainForTick(inputTickActions)),
+    /InvalidArgumentError/,
+    message
+  );
+  Assert.throws(
+    () => action.Chain.fromJSON(state, chainForTick(inputTickActions)),
+    regex,
+    message
+  );
+}
+
+function chainForTick(tickActions) {
+  const actions = [];
+  let lastId = 0;
+  for (let { type, subtype, parameters, ...props } of tickActions) {
+    let id;
+    if (!props.hasOwnProperty("id")) {
+      id = `${type}_${lastId++}`;
+    } else {
+      id = props.id;
+      delete props.id;
+    }
+    const inputAction = { type, id, actions: [{ type: subtype, ...props }] };
+    if (parameters !== undefined) {
+      inputAction.parameters = parameters;
+    }
+    actions.push(inputAction);
+  }
+  return actions;
+}
diff --git a/remote/shared/webdriver/test/xpcshell/test_Assert.js b/remote/shared/webdriver/test/xpcshell/test_Assert.js
new file mode 100644
index 0000000000..1673b645f4
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/test_Assert.js
@@ -0,0 +1,183 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+/* eslint-disable no-array-constructor, no-new-object */
+
+const { assert } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Assert.sys.mjs"
+);
+const { error } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Errors.sys.mjs"
+);
+
+add_task(function test_session() {
+  assert.session({ id: "foo" });
+
+  const invalidTypes = [
+    null,
+    undefined,
+    [],
+    {},
+    { id: undefined },
+    { id: null },
+    { id: true },
+    { id: 1 },
+    { id: [] },
+    { id: {} },
+  ];
+
+  for (const invalidType of invalidTypes) {
+    Assert.throws(() => assert.session(invalidType), /InvalidSessionIDError/);
+  }
+
+  Assert.throws(() => assert.session({ id: null }, "custom"), /custom/);
+});
+
+add_task(function test_platforms() {
+  // at least one will fail
+  let raised;
+  for (let fn of [assert.desktop, assert.mobile]) {
+    try {
+      fn();
+    } catch (e) {
+      raised = e;
+    }
+  }
+  ok(raised instanceof error.UnsupportedOperationError);
+});
+
+add_task(function test_noUserPrompt() {
+  assert.noUserPrompt(null);
+  assert.noUserPrompt(undefined);
+  Assert.throws(() => assert.noUserPrompt({}), /UnexpectedAlertOpenError/);
+  Assert.throws(() => assert.noUserPrompt({}, "custom"), /custom/);
+});
+
+add_task(function test_defined() {
+  assert.defined({});
+  Assert.throws(() => assert.defined(undefined), /InvalidArgumentError/);
+  Assert.throws(() => assert.noUserPrompt({}, "custom"), /custom/);
+});
+
+add_task(function test_number() {
+  assert.number(1);
+  assert.number(0);
+  assert.number(-1);
+  assert.number(1.2);
+  for (let i of ["foo", "1", {}, [], NaN, Infinity, undefined]) {
+    Assert.throws(() => assert.number(i), /InvalidArgumentError/);
+  }
+
+  Assert.throws(() => assert.number("foo", "custom"), /custom/);
+});
+
+add_task(function test_callable() {
+  assert.callable(function () {});
+  assert.callable(() => {});
+
+  for (let typ of [undefined, "", true, {}, []]) {
+    Assert.throws(() => assert.callable(typ), /InvalidArgumentError/);
+  }
+
+  Assert.throws(() => assert.callable("foo", "custom"), /custom/);
+});
+
+add_task(function test_integer() {
+  assert.integer(1);
+  assert.integer(0);
+  assert.integer(-1);
+  Assert.throws(() => assert.integer("foo"), /InvalidArgumentError/);
+  Assert.throws(() => assert.integer(1.2), /InvalidArgumentError/);
+
+  Assert.throws(() => assert.integer("foo", "custom"), /custom/);
+});
+
+add_task(function test_positiveInteger() {
+  assert.positiveInteger(1);
+  assert.positiveInteger(0);
+  Assert.throws(() => assert.positiveInteger(-1), /InvalidArgumentError/);
+  Assert.throws(() => assert.positiveInteger("foo"), /InvalidArgumentError/);
+  Assert.throws(() => assert.positiveInteger("foo", "custom"), /custom/);
+});
+
+add_task(function test_positiveNumber() {
+  assert.positiveNumber(1);
+  assert.positiveNumber(0);
+  assert.positiveNumber(1.1);
+  assert.positiveNumber(Number.MAX_VALUE);
+  // eslint-disable-next-line no-loss-of-precision
+  Assert.throws(() => assert.positiveNumber(1.8e308), /InvalidArgumentError/);
+  Assert.throws(() => assert.positiveNumber(-1), /InvalidArgumentError/);
+  Assert.throws(() => assert.positiveNumber(Infinity), /InvalidArgumentError/);
+  Assert.throws(() => assert.positiveNumber("foo"), /InvalidArgumentError/);
+  Assert.throws(() => assert.positiveNumber("foo", "custom"), /custom/);
+});
+
+add_task(function test_boolean() {
+  assert.boolean(true);
+  assert.boolean(false);
+  Assert.throws(() => assert.boolean("false"), /InvalidArgumentError/);
+  Assert.throws(() => assert.boolean(undefined), /InvalidArgumentError/);
+  Assert.throws(() => assert.boolean(undefined, "custom"), /custom/);
+});
+
+add_task(function test_string() {
+  assert.string("foo");
+  assert.string(`bar`);
+  Assert.throws(() => assert.string(42), /InvalidArgumentError/);
+  Assert.throws(() => assert.string(42, "custom"), /custom/);
+});
+
+add_task(function test_open() {
+  assert.open({ currentWindowGlobal: {} });
+
+  for (let typ of [null, undefined, { currentWindowGlobal: null }]) {
+    Assert.throws(() => assert.open(typ), /NoSuchWindowError/);
+  }
+
+  Assert.throws(() => assert.open(null, "custom"), /custom/);
+});
+
+add_task(function test_object() {
+  assert.object({});
+  assert.object(new Object());
+  for (let typ of [42, "foo", true, null, undefined]) {
+    Assert.throws(() => assert.object(typ), /InvalidArgumentError/);
+  }
+
+  Assert.throws(() => assert.object(null, "custom"), /custom/);
+});
+
+add_task(function test_in() {
+  assert.in("foo", { foo: 42 });
+  for (let typ of [{}, 42, true, null, undefined]) {
+    Assert.throws(() => assert.in("foo", typ), /InvalidArgumentError/);
+  }
+
+  Assert.throws(() => assert.in("foo", { bar: 42 }, "custom"), /custom/);
+});
+
+add_task(function test_array() {
+  assert.array([]);
+  assert.array(new Array());
+  Assert.throws(() => assert.array(42), /InvalidArgumentError/);
+  Assert.throws(() => assert.array({}), /InvalidArgumentError/);
+
+  Assert.throws(() => assert.array(42, "custom"), /custom/);
+});
+
+add_task(function test_that() {
+  equal(1, assert.that(n => n + 1)(1));
+  Assert.throws(() => assert.that(() => false)(), /InvalidArgumentError/);
+  Assert.throws(() => assert.that(val => val)(false), /InvalidArgumentError/);
+  Assert.throws(
+    () => assert.that(val => val, "foo", error.SessionNotCreatedError)(false),
+    /SessionNotCreatedError/
+  );
+
+  Assert.throws(() => assert.that(() => false, "custom")(), /custom/);
+});
+
+/* eslint-enable no-array-constructor, no-new-object */
diff --git a/remote/shared/webdriver/test/xpcshell/test_Capabilities.js b/remote/shared/webdriver/test/xpcshell/test_Capabilities.js
new file mode 100644
index 0000000000..e88c0126c9
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/test_Capabilities.js
@@ -0,0 +1,585 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const { Preferences } = ChromeUtils.importESModule(
+  "resource://gre/modules/Preferences.sys.mjs"
+);
+
+const { AppInfo } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/AppInfo.sys.mjs"
+);
+const { error } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Errors.sys.mjs"
+);
+const {
+  Capabilities,
+  PageLoadStrategy,
+  Proxy,
+  Timeouts,
+  UnhandledPromptBehavior,
+} = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Capabilities.sys.mjs"
+);
+
+add_task(function test_Timeouts_ctor() {
+  let ts = new Timeouts();
+  equal(ts.implicit, 0);
+  equal(ts.pageLoad, 300000);
+  equal(ts.script, 30000);
+});
+
+add_task(function test_Timeouts_toString() {
+  equal(new Timeouts().toString(), "[object Timeouts]");
+});
+
+add_task(function test_Timeouts_toJSON() {
+  let ts = new Timeouts();
+  deepEqual(ts.toJSON(), { implicit: 0, pageLoad: 300000, script: 30000 });
+});
+
+add_task(function test_Timeouts_fromJSON() {
+  let json = {
+    implicit: 0,
+    pageLoad: 2.0,
+    script: Number.MAX_SAFE_INTEGER,
+  };
+  let ts = Timeouts.fromJSON(json);
+  equal(ts.implicit, json.implicit);
+  equal(ts.pageLoad, json.pageLoad);
+  equal(ts.script, json.script);
+});
+
+add_task(function test_Timeouts_fromJSON_unrecognised_field() {
+  let json = {
+    sessionId: "foobar",
+  };
+  try {
+    Timeouts.fromJSON(json);
+  } catch (e) {
+    equal(e.name, error.InvalidArgumentError.name);
+    equal(e.message, "Unrecognised timeout: sessionId");
+  }
+});
+
+add_task(function test_Timeouts_fromJSON_invalid_types() {
+  for (let value of [null, [], {}, false, "10", 2.5]) {
+    Assert.throws(
+      () => Timeouts.fromJSON({ implicit: value }),
+      /InvalidArgumentError/
+    );
+  }
+});
+
+add_task(function test_Timeouts_fromJSON_bounds() {
+  for (let value of [-1, Number.MAX_SAFE_INTEGER + 1]) {
+    Assert.throws(
+      () => Timeouts.fromJSON({ script: value }),
+      /InvalidArgumentError/
+    );
+  }
+});
+
+add_task(function test_PageLoadStrategy() {
+  equal(PageLoadStrategy.None, "none");
+  equal(PageLoadStrategy.Eager, "eager");
+  equal(PageLoadStrategy.Normal, "normal");
+});
+
+add_task(function test_Proxy_ctor() {
+  let p = new Proxy();
+  let props = [
+    "proxyType",
+    "httpProxy",
+    "sslProxy",
+    "socksProxy",
+    "socksVersion",
+    "proxyAutoconfigUrl",
+  ];
+  for (let prop of props) {
+    ok(prop in p, `${prop} in ${JSON.stringify(props)}`);
+    equal(p[prop], null);
+  }
+});
+
+add_task(function test_Proxy_init() {
+  let p = new Proxy();
+
+  // no changed made, and 5 (system) is default
+  equal(p.init(), false);
+  equal(Preferences.get("network.proxy.type"), 5);
+
+  // pac
+  p.proxyType = "pac";
+  p.proxyAutoconfigUrl = "http://localhost:1234";
+  ok(p.init());
+
+  equal(Preferences.get("network.proxy.type"), 2);
+  equal(
+    Preferences.get("network.proxy.autoconfig_url"),
+    "http://localhost:1234"
+  );
+
+  // direct
+  p = new Proxy();
+  p.proxyType = "direct";
+  ok(p.init());
+  equal(Preferences.get("network.proxy.type"), 0);
+
+  // autodetect
+  p = new Proxy();
+  p.proxyType = "autodetect";
+  ok(p.init());
+  equal(Preferences.get("network.proxy.type"), 4);
+
+  // system
+  p = new Proxy();
+  p.proxyType = "system";
+  ok(p.init());
+  equal(Preferences.get("network.proxy.type"), 5);
+
+  // manual
+  for (let proxy of ["http", "ssl", "socks"]) {
+    p = new Proxy();
+    p.proxyType = "manual";
+    p.noProxy = ["foo", "bar"];
+    p[`${proxy}Proxy`] = "foo";
+    p[`${proxy}ProxyPort`] = 42;
+    if (proxy === "socks") {
+      p[`${proxy}Version`] = 4;
+    }
+
+    ok(p.init());
+    equal(Preferences.get("network.proxy.type"), 1);
+    equal(Preferences.get("network.proxy.no_proxies_on"), "foo, bar");
+    equal(Preferences.get(`network.proxy.${proxy}`), "foo");
+    equal(Preferences.get(`network.proxy.${proxy}_port`), 42);
+    if (proxy === "socks") {
+      equal(Preferences.get(`network.proxy.${proxy}_version`), 4);
+    }
+  }
+
+  // empty no proxy should reset default exclustions
+  p = new Proxy();
+  p.proxyType = "manual";
+  p.noProxy = [];
+  ok(p.init());
+  equal(Preferences.get("network.proxy.no_proxies_on"), "");
+});
+
+add_task(function test_Proxy_toString() {
+  equal(new Proxy().toString(), "[object Proxy]");
+});
+
+add_task(function test_Proxy_toJSON() {
+  let p = new Proxy();
+  deepEqual(p.toJSON(), {});
+
+  // autoconfig url
+  p = new Proxy();
+  p.proxyType = "pac";
+  p.proxyAutoconfigUrl = "foo";
+  deepEqual(p.toJSON(), { proxyType: "pac", proxyAutoconfigUrl: "foo" });
+
+  // manual proxy
+  p = new Proxy();
+  p.proxyType = "manual";
+  deepEqual(p.toJSON(), { proxyType: "manual" });
+
+  for (let proxy of ["httpProxy", "sslProxy", "socksProxy"]) {
+    let expected = { proxyType: "manual" };
+
+    p = new Proxy();
+    p.proxyType = "manual";
+
+    if (proxy == "socksProxy") {
+      p.socksVersion = 5;
+      expected.socksVersion = 5;
+    }
+
+    // without port
+    p[proxy] = "foo";
+    expected[proxy] = "foo";
+    deepEqual(p.toJSON(), expected);
+
+    // with port
+    p[proxy] = "foo";
+    p[`${proxy}Port`] = 0;
+    expected[proxy] = "foo:0";
+    deepEqual(p.toJSON(), expected);
+
+    p[`${proxy}Port`] = 42;
+    expected[proxy] = "foo:42";
+    deepEqual(p.toJSON(), expected);
+
+    // add brackets for IPv6 address as proxy hostname
+    p[proxy] = "2001:db8::1";
+    p[`${proxy}Port`] = 42;
+    expected[proxy] = "foo:42";
+    expected[proxy] = "[2001:db8::1]:42";
+    deepEqual(p.toJSON(), expected);
+  }
+
+  // noProxy: add brackets for IPv6 address
+  p = new Proxy();
+  p.proxyType = "manual";
+  p.noProxy = ["2001:db8::1"];
+  let expected = { proxyType: "manual", noProxy: "[2001:db8::1]" };
+  deepEqual(p.toJSON(), expected);
+});
+
+add_task(function test_Proxy_fromJSON() {
+  let p = new Proxy();
+  deepEqual(p, Proxy.fromJSON(undefined));
+  deepEqual(p, Proxy.fromJSON(null));
+
+  for (let typ of [true, 42, "foo", []]) {
+    Assert.throws(() => Proxy.fromJSON(typ), /InvalidArgumentError/);
+  }
+
+  // must contain a valid proxyType
+  Assert.throws(() => Proxy.fromJSON({}), /InvalidArgumentError/);
+  Assert.throws(
+    () => Proxy.fromJSON({ proxyType: "foo" }),
+    /InvalidArgumentError/
+  );
+
+  // autoconfig url
+  for (let url of [true, 42, [], {}]) {
+    Assert.throws(
+      () => Proxy.fromJSON({ proxyType: "pac", proxyAutoconfigUrl: url }),
+      /InvalidArgumentError/
+    );
+  }
+
+  p = new Proxy();
+  p.proxyType = "pac";
+  p.proxyAutoconfigUrl = "foo";
+  deepEqual(p, Proxy.fromJSON({ proxyType: "pac", proxyAutoconfigUrl: "foo" }));
+
+  // manual proxy
+  p = new Proxy();
+  p.proxyType = "manual";
+  deepEqual(p, Proxy.fromJSON({ proxyType: "manual" }));
+
+  for (let proxy of ["httpProxy", "sslProxy", "socksProxy"]) {
+    let manual = { proxyType: "manual" };
+
+    // invalid hosts
+    for (let host of [
+      true,
+      42,
+      [],
+      {},
+      null,
+      "http://foo",
+      "foo:-1",
+      "foo:65536",
+      "foo/test",
+      "foo#42",
+      "foo?foo=bar",
+      "2001:db8::1",
+    ]) {
+      manual[proxy] = host;
+      Assert.throws(() => Proxy.fromJSON(manual), /InvalidArgumentError/);
+    }
+
+    p = new Proxy();
+    p.proxyType = "manual";
+    if (proxy == "socksProxy") {
+      manual.socksVersion = 5;
+      p.socksVersion = 5;
+    }
+
+    let host_map = {
+      "foo:1": { hostname: "foo", port: 1 },
+      "foo:21": { hostname: "foo", port: 21 },
+      "foo:80": { hostname: "foo", port: 80 },
+      "foo:443": { hostname: "foo", port: 443 },
+      "foo:65535": { hostname: "foo", port: 65535 },
+      "127.0.0.1:42": { hostname: "127.0.0.1", port: 42 },
+      "[2001:db8::1]:42": { hostname: "2001:db8::1", port: "42" },
+    };
+
+    // valid proxy hosts with port
+    for (let host in host_map) {
+      manual[proxy] = host;
+
+      p[`${proxy}`] = host_map[host].hostname;
+      p[`${proxy}Port`] = host_map[host].port;
+
+      deepEqual(p, Proxy.fromJSON(manual));
+    }
+
+    // Without a port the default port of the scheme is used
+    for (let host of ["foo", "foo:"]) {
+      manual[proxy] = host;
+
+      // For socks no default port is available
+      p[proxy] = `foo`;
+      if (proxy === "socksProxy") {
+        p[`${proxy}Port`] = null;
+      } else {
+        let default_ports = { httpProxy: 80, sslProxy: 443 };
+
+        p[`${proxy}Port`] = default_ports[proxy];
+      }
+
+      deepEqual(p, Proxy.fromJSON(manual));
+    }
+  }
+
+  // missing required socks version
+  Assert.throws(
+    () => Proxy.fromJSON({ proxyType: "manual", socksProxy: "foo:1234" }),
+    /InvalidArgumentError/
+  );
+
+  // Bug 1703805: Since Firefox 90 ftpProxy is no longer supported
+  Assert.throws(
+    () => Proxy.fromJSON({ proxyType: "manual", ftpProxy: "foo:21" }),
+    /InvalidArgumentError/
+  );
+
+  // noProxy: invalid settings
+  for (let noProxy of [true, 42, {}, null, "foo", [true], [42], [{}], [null]]) {
+    Assert.throws(
+      () => Proxy.fromJSON({ proxyType: "manual", noProxy }),
+      /InvalidArgumentError/
+    );
+  }
+
+  // noProxy: valid settings
+  p = new Proxy();
+  p.proxyType = "manual";
+  for (let noProxy of [[], ["foo"], ["foo", "bar"], ["127.0.0.1"]]) {
+    let manual = { proxyType: "manual", noProxy };
+    p.noProxy = noProxy;
+    deepEqual(p, Proxy.fromJSON(manual));
+  }
+
+  // noProxy: IPv6 needs brackets removed
+  p = new Proxy();
+  p.proxyType = "manual";
+  p.noProxy = ["2001:db8::1"];
+  let manual = { proxyType: "manual", noProxy: ["[2001:db8::1]"] };
+  deepEqual(p, Proxy.fromJSON(manual));
+});
+
+add_task(function test_UnhandledPromptBehavior() {
+  equal(UnhandledPromptBehavior.Accept, "accept");
+  equal(UnhandledPromptBehavior.AcceptAndNotify, "accept and notify");
+  equal(UnhandledPromptBehavior.Dismiss, "dismiss");
+  equal(UnhandledPromptBehavior.DismissAndNotify, "dismiss and notify");
+  equal(UnhandledPromptBehavior.Ignore, "ignore");
+});
+
+add_task(function test_Capabilities_ctor() {
+  let caps = new Capabilities();
+  ok(caps.has("browserName"));
+  ok(caps.has("browserVersion"));
+  ok(caps.has("platformName"));
+  ok(["linux", "mac", "windows", "android"].includes(caps.get("platformName")));
+  equal(PageLoadStrategy.Normal, caps.get("pageLoadStrategy"));
+  equal(false, caps.get("acceptInsecureCerts"));
+  ok(caps.get("timeouts") instanceof Timeouts);
+  ok(caps.get("proxy") instanceof Proxy);
+  equal(caps.get("setWindowRect"), !AppInfo.isAndroid);
+  equal(caps.get("strictFileInteractability"), false);
+  equal(caps.get("webSocketUrl"), null);
+
+  equal(false, caps.get("moz:accessibilityChecks"));
+  ok(caps.has("moz:buildID"));
+  ok(caps.has("moz:debuggerAddress"));
+  ok(caps.has("moz:platformVersion"));
+  ok(caps.has("moz:processID"));
+  ok(caps.has("moz:profile"));
+  equal(false, caps.get("moz:useNonSpecCompliantPointerOrigin"));
+  equal(true, caps.get("moz:webdriverClick"));
+});
+
+add_task(function test_Capabilities_toString() {
+  equal("[object Capabilities]", new Capabilities().toString());
+});
+
+add_task(function test_Capabilities_toJSON() {
+  let caps = new Capabilities();
+  let json = caps.toJSON();
+
+  equal(caps.get("browserName"), json.browserName);
+  equal(caps.get("browserVersion"), json.browserVersion);
+  equal(caps.get("platformName"), json.platformName);
+  equal(caps.get("pageLoadStrategy"), json.pageLoadStrategy);
+  equal(caps.get("acceptInsecureCerts"), json.acceptInsecureCerts);
+  deepEqual(caps.get("proxy").toJSON(), json.proxy);
+  deepEqual(caps.get("timeouts").toJSON(), json.timeouts);
+  equal(caps.get("setWindowRect"), json.setWindowRect);
+  equal(caps.get("strictFileInteractability"), json.strictFileInteractability);
+  equal(caps.get("webSocketUrl"), json.webSocketUrl);
+
+  equal(caps.get("moz:accessibilityChecks"), json["moz:accessibilityChecks"]);
+  equal(caps.get("moz:buildID"), json["moz:buildID"]);
+  equal(caps.get("moz:debuggerAddress"), json["moz:debuggerAddress"]);
+  equal(caps.get("moz:platformVersion"), json["moz:platformVersion"]);
+  equal(caps.get("moz:processID"), json["moz:processID"]);
+  equal(caps.get("moz:profile"), json["moz:profile"]);
+  equal(
+    caps.get("moz:useNonSpecCompliantPointerOrigin"),
+    json["moz:useNonSpecCompliantPointerOrigin"]
+  );
+  equal(caps.get("moz:webdriverClick"), json["moz:webdriverClick"]);
+});
+
+add_task(function test_Capabilities_fromJSON() {
+  const { fromJSON } = Capabilities;
+
+  // plain
+  for (let typ of [{}, null, undefined]) {
+    ok(fromJSON(typ).has("browserName"));
+  }
+  for (let typ of [true, 42, "foo", []]) {
+    Assert.throws(() => fromJSON(typ), /InvalidArgumentError/);
+  }
+
+  // matching
+  let caps = new Capabilities();
+
+  caps = fromJSON({ acceptInsecureCerts: true });
+  equal(true, caps.get("acceptInsecureCerts"));
+  caps = fromJSON({ acceptInsecureCerts: false });
+  equal(false, caps.get("acceptInsecureCerts"));
+  Assert.throws(
+    () => fromJSON({ acceptInsecureCerts: "foo" }),
+    /InvalidArgumentError/
+  );
+
+  for (let strategy of Object.values(PageLoadStrategy)) {
+    caps = fromJSON({ pageLoadStrategy: strategy });
+    equal(strategy, caps.get("pageLoadStrategy"));
+  }
+  Assert.throws(
+    () => fromJSON({ pageLoadStrategy: "foo" }),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => fromJSON({ pageLoadStrategy: null }),
+    /InvalidArgumentError/
+  );
+
+  let proxyConfig = { proxyType: "manual" };
+  caps = fromJSON({ proxy: proxyConfig });
+  equal("manual", caps.get("proxy").proxyType);
+
+  let timeoutsConfig = { implicit: 123 };
+  caps = fromJSON({ timeouts: timeoutsConfig });
+  equal(123, caps.get("timeouts").implicit);
+
+  if (!AppInfo.isAndroid) {
+    caps = fromJSON({ setWindowRect: true });
+    equal(true, caps.get("setWindowRect"));
+    Assert.throws(
+      () => fromJSON({ setWindowRect: false }),
+      /InvalidArgumentError/
+    );
+  } else {
+    Assert.throws(
+      () => fromJSON({ setWindowRect: true }),
+      /InvalidArgumentError/
+    );
+  }
+
+  caps = fromJSON({ strictFileInteractability: false });
+  equal(false, caps.get("strictFileInteractability"));
+  caps = fromJSON({ strictFileInteractability: true });
+  equal(true, caps.get("strictFileInteractability"));
+
+  caps = fromJSON({ webSocketUrl: true });
+  equal(true, caps.get("webSocketUrl"));
+  Assert.throws(
+    () => fromJSON({ webSocketUrl: false }),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => fromJSON({ webSocketUrl: "foo" }),
+    /InvalidArgumentError/
+  );
+
+  caps = fromJSON({ "moz:accessibilityChecks": true });
+  equal(true, caps.get("moz:accessibilityChecks"));
+  caps = fromJSON({ "moz:accessibilityChecks": false });
+  equal(false, caps.get("moz:accessibilityChecks"));
+  Assert.throws(
+    () => fromJSON({ "moz:accessibilityChecks": "foo" }),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => fromJSON({ "moz:accessibilityChecks": 1 }),
+    /InvalidArgumentError/
+  );
+
+  // capability is always populated with null if remote agent is not listening
+  caps = fromJSON({});
+  equal(null, caps.get("moz:debuggerAddress"));
+  caps = fromJSON({ "moz:debuggerAddress": "foo" });
+  equal(null, caps.get("moz:debuggerAddress"));
+  caps = fromJSON({ "moz:debuggerAddress": true });
+  equal(null, caps.get("moz:debuggerAddress"));
+
+  caps = fromJSON({ "moz:useNonSpecCompliantPointerOrigin": false });
+  equal(false, caps.get("moz:useNonSpecCompliantPointerOrigin"));
+  caps = fromJSON({ "moz:useNonSpecCompliantPointerOrigin": true });
+  equal(true, caps.get("moz:useNonSpecCompliantPointerOrigin"));
+  Assert.throws(
+    () => fromJSON({ "moz:useNonSpecCompliantPointerOrigin": "foo" }),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => fromJSON({ "moz:useNonSpecCompliantPointerOrigin": 1 }),
+    /InvalidArgumentError/
+  );
+
+  caps = fromJSON({ "moz:webdriverClick": true });
+  equal(true, caps.get("moz:webdriverClick"));
+  caps = fromJSON({ "moz:webdriverClick": false });
+  equal(false, caps.get("moz:webdriverClick"));
+  Assert.throws(
+    () => fromJSON({ "moz:webdriverClick": "foo" }),
+    /InvalidArgumentError/
+  );
+  Assert.throws(
+    () => fromJSON({ "moz:webdriverClick": 1 }),
+    /InvalidArgumentError/
+  );
+});
+
+// use Proxy.toJSON to test marshal
+add_task(function test_marshal() {
+  let proxy = new Proxy();
+
+  // drop empty fields
+  deepEqual({}, proxy.toJSON());
+  proxy.proxyType = "manual";
+  deepEqual({ proxyType: "manual" }, proxy.toJSON());
+  proxy.proxyType = null;
+  deepEqual({}, proxy.toJSON());
+  proxy.proxyType = undefined;
+  deepEqual({}, proxy.toJSON());
+
+  // iterate over object literals
+  proxy.proxyType = { foo: "bar" };
+  deepEqual({ proxyType: { foo: "bar" } }, proxy.toJSON());
+
+  // iterate over complex object that implement toJSON
+  proxy.proxyType = new Proxy();
+  deepEqual({}, proxy.toJSON());
+  proxy.proxyType.proxyType = "manual";
+  deepEqual({ proxyType: { proxyType: "manual" } }, proxy.toJSON());
+
+  // drop objects with no entries
+  proxy.proxyType = { foo: {} };
+  deepEqual({}, proxy.toJSON());
+  proxy.proxyType = { foo: new Proxy() };
+  deepEqual({}, proxy.toJSON());
+});
diff --git a/remote/shared/webdriver/test/xpcshell/test_Errors.js b/remote/shared/webdriver/test/xpcshell/test_Errors.js
new file mode 100644
index 0000000000..e688d529ca
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/test_Errors.js
@@ -0,0 +1,509 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+const { error } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Errors.sys.mjs"
+);
+
+const errors = [
+  error.WebDriverError,
+
+  error.DetachedShadowRootError,
+  error.ElementClickInterceptedError,
+  error.ElementNotAccessibleError,
+  error.ElementNotInteractableError,
+  error.InsecureCertificateError,
+  error.InvalidArgumentError,
+  error.InvalidCookieDomainError,
+  error.InvalidElementStateError,
+  error.InvalidSelectorError,
+  error.InvalidSessionIDError,
+  error.JavaScriptError,
+  error.MoveTargetOutOfBoundsError,
+  error.NoSuchAlertError,
+  error.NoSuchElementError,
+  error.NoSuchFrameError,
+  error.NoSuchHandleError,
+  error.NoSuchNodeError,
+  error.NoSuchScriptError,
+  error.NoSuchShadowRootError,
+  error.NoSuchWindowError,
+  error.ScriptTimeoutError,
+  error.SessionNotCreatedError,
+  error.StaleElementReferenceError,
+  error.TimeoutError,
+  error.UnableToSetCookieError,
+  error.UnexpectedAlertOpenError,
+  error.UnknownCommandError,
+  error.UnknownError,
+  error.UnsupportedOperationError,
+];
+
+function notok(condition) {
+  ok(!condition);
+}
+
+add_task(function test_isError() {
+  notok(error.isError(null));
+  notok(error.isError([]));
+  notok(error.isError(new Date()));
+
+  ok(error.isError(new Components.Exception()));
+  ok(error.isError(new Error()));
+  ok(error.isError(new EvalError()));
+  ok(error.isError(new InternalError()));
+  ok(error.isError(new RangeError()));
+  ok(error.isError(new ReferenceError()));
+  ok(error.isError(new SyntaxError()));
+  ok(error.isError(new TypeError()));
+  ok(error.isError(new URIError()));
+
+  errors.forEach(err => ok(error.isError(new err())));
+});
+
+add_task(function test_isWebDriverError() {
+  notok(error.isWebDriverError(new Components.Exception()));
+  notok(error.isWebDriverError(new Error()));
+  notok(error.isWebDriverError(new EvalError()));
+  notok(error.isWebDriverError(new InternalError()));
+  notok(error.isWebDriverError(new RangeError()));
+  notok(error.isWebDriverError(new ReferenceError()));
+  notok(error.isWebDriverError(new SyntaxError()));
+  notok(error.isWebDriverError(new TypeError()));
+  notok(error.isWebDriverError(new URIError()));
+
+  errors.forEach(err => ok(error.isWebDriverError(new err())));
+});
+
+add_task(function test_wrap() {
+  // webdriver-derived errors should not be wrapped
+  errors.forEach(err => {
+    const unwrappedError = new err("foo");
+    const wrappedError = error.wrap(unwrappedError);
+
+    ok(wrappedError instanceof error.WebDriverError);
+    ok(wrappedError instanceof err);
+    equal(wrappedError.name, unwrappedError.name);
+    equal(wrappedError.status, unwrappedError.status);
+    equal(wrappedError.message, "foo");
+  });
+
+  // JS errors should be wrapped in UnknownError and retain their type
+  // as part of the message field.
+  const jsErrors = [
+    Error,
+    EvalError,
+    InternalError,
+    RangeError,
+    ReferenceError,
+    SyntaxError,
+    TypeError,
+    URIError,
+  ];
+
+  jsErrors.forEach(err => {
+    const originalError = new err("foo");
+    const wrappedError = error.wrap(originalError);
+
+    ok(wrappedError instanceof error.UnknownError);
+    equal(wrappedError.name, "UnknownError");
+    equal(wrappedError.status, "unknown error");
+    equal(wrappedError.message, `${originalError.name}: foo`);
+  });
+});
+
+add_task(function test_stringify() {
+  equal("<unprintable error>", error.stringify());
+  equal("<unprintable error>", error.stringify("foo"));
+  equal("[object Object]", error.stringify({}));
+  equal("[object Object]\nfoo", error.stringify({ stack: "foo" }));
+  equal("Error: foo", error.stringify(new Error("foo")).split("\n")[0]);
+
+  errors.forEach(err => {
+    const e = new err("foo");
+
+    equal(`${e.name}: foo`, error.stringify(e).split("\n")[0]);
+  });
+});
+
+add_task(function test_constructor_from_error() {
+  const data = { a: 3, b: "bar" };
+  const origError = new error.WebDriverError("foo", data);
+
+  errors.forEach(err => {
+    const newError = new err(origError);
+
+    ok(newError instanceof err);
+    equal(newError.message, origError.message);
+    equal(newError.stack, origError.stack);
+    equal(newError.data, origError.data);
+  });
+});
+
+add_task(function test_stack() {
+  equal("string", typeof error.stack());
+  ok(error.stack().includes("test_stack"));
+  ok(!error.stack().includes("add_task"));
+});
+
+add_task(function test_toJSON() {
+  errors.forEach(err => {
+    const e0 = new err();
+    const e0_json = e0.toJSON();
+    equal(e0_json.error, e0.status);
+    equal(e0_json.message, "");
+    equal(e0_json.stacktrace, e0.stack);
+    equal(e0_json.data, undefined);
+
+    // message property
+    const e1 = new err("a");
+    const e1_json = e1.toJSON();
+
+    equal(e1_json.message, e1.message);
+    equal(e1_json.stacktrace, e1.stack);
+    equal(e1_json.data, undefined);
+
+    // message and optional data property
+    const data = { a: 3, b: "bar" };
+    const e2 = new err("foo", data);
+    const e2_json = e2.toJSON();
+
+    equal(e2.status, e2_json.error);
+    equal(e2.message, e2_json.message);
+    equal(e2_json.data, data);
+  });
+});
+
+add_task(function test_fromJSON() {
+  errors.forEach(err => {
+    Assert.throws(
+      () => err.fromJSON({ error: "foo" }),
+      /Not of WebDriverError descent/
+    );
+    Assert.throws(
+      () => err.fromJSON({ error: "Error" }),
+      /Not of WebDriverError descent/
+    );
+    Assert.throws(() => err.fromJSON({}), /Undeserialisable error type/);
+    Assert.throws(() => err.fromJSON(undefined), /TypeError/);
+
+    // message and stack
+    const e1 = new err("1");
+    const e1_json = { error: e1.status, message: "3", stacktrace: "4" };
+    const e1_fromJSON = error.WebDriverError.fromJSON(e1_json);
+
+    ok(e1_fromJSON instanceof error.WebDriverError);
+    ok(e1_fromJSON instanceof err);
+    equal(e1_fromJSON.name, e1.name);
+    equal(e1_fromJSON.status, e1_json.error);
+    equal(e1_fromJSON.message, e1_json.message);
+    equal(e1_fromJSON.stack, e1_json.stacktrace);
+
+    // message and optional data
+    const e2_data = { a: 3, b: "bar" };
+    const e2 = new err("1", e2_data);
+    const e2_json = { error: e1.status, message: "3", data: e2_data };
+    const e2_fromJSON = error.WebDriverError.fromJSON(e2_json);
+
+    ok(e2_fromJSON instanceof error.WebDriverError);
+    ok(e2_fromJSON instanceof err);
+    equal(e2_fromJSON.name, e2.name);
+    equal(e2_fromJSON.status, e2_json.error);
+    equal(e2_fromJSON.message, e2_json.message);
+    equal(e2_fromJSON.data, e2_json.data);
+
+    // parity with toJSON
+    const e3_data = { a: 3, b: "bar" };
+    const e3 = new err("1", e3_data);
+    const e3_json = e3.toJSON();
+    const e3_fromJSON = error.WebDriverError.fromJSON(e3_json);
+
+    equal(e3_json.error, e3_fromJSON.status);
+    equal(e3_json.message, e3_fromJSON.message);
+    equal(e3_json.stacktrace, e3_fromJSON.stack);
+  });
+});
+
+add_task(function test_WebDriverError() {
+  let err = new error.WebDriverError("foo");
+  equal("WebDriverError", err.name);
+  equal("foo", err.message);
+  equal("webdriver error", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_DetachedShadowRootError() {
+  let err = new error.DetachedShadowRootError("foo");
+  equal("DetachedShadowRootError", err.name);
+  equal("foo", err.message);
+  equal("detached shadow root", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_ElementClickInterceptedError() {
+  let otherEl = {
+    hasAttribute: attr => attr in otherEl,
+    getAttribute: attr => (attr in otherEl ? otherEl[attr] : null),
+    nodeType: 1,
+    localName: "a",
+  };
+  let obscuredEl = {
+    hasAttribute: attr => attr in obscuredEl,
+    getAttribute: attr => (attr in obscuredEl ? obscuredEl[attr] : null),
+    nodeType: 1,
+    localName: "b",
+    ownerDocument: {
+      elementFromPoint() {
+        return otherEl;
+      },
+    },
+    style: {
+      pointerEvents: "auto",
+    },
+  };
+
+  let err1 = new error.ElementClickInterceptedError(
+    undefined,
+    undefined,
+    obscuredEl,
+    { x: 1, y: 2 }
+  );
+  equal("ElementClickInterceptedError", err1.name);
+  equal(
+    "Element <b> is not clickable at point (1,2) " +
+      "because another element <a> obscures it",
+    err1.message
+  );
+  equal("element click intercepted", err1.status);
+  ok(err1 instanceof error.WebDriverError);
+
+  obscuredEl.style.pointerEvents = "none";
+  let err2 = new error.ElementClickInterceptedError(
+    undefined,
+    undefined,
+    obscuredEl,
+    { x: 1, y: 2 }
+  );
+  equal(
+    "Element <b> is not clickable at point (1,2) " +
+      "because it does not have pointer events enabled, " +
+      "and element <a> would receive the click instead",
+    err2.message
+  );
+});
+
+add_task(function test_ElementNotAccessibleError() {
+  let err = new error.ElementNotAccessibleError("foo");
+  equal("ElementNotAccessibleError", err.name);
+  equal("foo", err.message);
+  equal("element not accessible", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_ElementNotInteractableError() {
+  let err = new error.ElementNotInteractableError("foo");
+  equal("ElementNotInteractableError", err.name);
+  equal("foo", err.message);
+  equal("element not interactable", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_InsecureCertificateError() {
+  let err = new error.InsecureCertificateError("foo");
+  equal("InsecureCertificateError", err.name);
+  equal("foo", err.message);
+  equal("insecure certificate", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_InvalidArgumentError() {
+  let err = new error.InvalidArgumentError("foo");
+  equal("InvalidArgumentError", err.name);
+  equal("foo", err.message);
+  equal("invalid argument", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_InvalidCookieDomainError() {
+  let err = new error.InvalidCookieDomainError("foo");
+  equal("InvalidCookieDomainError", err.name);
+  equal("foo", err.message);
+  equal("invalid cookie domain", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_InvalidElementStateError() {
+  let err = new error.InvalidElementStateError("foo");
+  equal("InvalidElementStateError", err.name);
+  equal("foo", err.message);
+  equal("invalid element state", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_InvalidSelectorError() {
+  let err = new error.InvalidSelectorError("foo");
+  equal("InvalidSelectorError", err.name);
+  equal("foo", err.message);
+  equal("invalid selector", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_InvalidSessionIDError() {
+  let err = new error.InvalidSessionIDError("foo");
+  equal("InvalidSessionIDError", err.name);
+  equal("foo", err.message);
+  equal("invalid session id", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_JavaScriptError() {
+  let err = new error.JavaScriptError("foo");
+  equal("JavaScriptError", err.name);
+  equal("foo", err.message);
+  equal("javascript error", err.status);
+  ok(err instanceof error.WebDriverError);
+
+  equal("", new error.JavaScriptError(undefined).message);
+
+  let superErr = new RangeError("foo");
+  let inheritedErr = new error.JavaScriptError(superErr);
+  equal("RangeError: foo", inheritedErr.message);
+  equal(superErr.stack, inheritedErr.stack);
+});
+
+add_task(function test_MoveTargetOutOfBoundsError() {
+  let err = new error.MoveTargetOutOfBoundsError("foo");
+  equal("MoveTargetOutOfBoundsError", err.name);
+  equal("foo", err.message);
+  equal("move target out of bounds", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchAlertError() {
+  let err = new error.NoSuchAlertError("foo");
+  equal("NoSuchAlertError", err.name);
+  equal("foo", err.message);
+  equal("no such alert", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchElementError() {
+  let err = new error.NoSuchElementError("foo");
+  equal("NoSuchElementError", err.name);
+  equal("foo", err.message);
+  equal("no such element", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchFrameError() {
+  let err = new error.NoSuchFrameError("foo");
+  equal("NoSuchFrameError", err.name);
+  equal("foo", err.message);
+  equal("no such frame", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchNodeError() {
+  let err = new error.NoSuchNodeError("foo");
+  equal("NoSuchNodeError", err.name);
+  equal("foo", err.message);
+  equal("no such node", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchScriptError() {
+  let err = new error.NoSuchScriptError("foo");
+  equal("NoSuchScriptError", err.name);
+  equal("foo", err.message);
+  equal("no such script", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchShadowRootError() {
+  let err = new error.NoSuchShadowRootError("foo");
+  equal("NoSuchShadowRootError", err.name);
+  equal("foo", err.message);
+  equal("no such shadow root", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_NoSuchWindowError() {
+  let err = new error.NoSuchWindowError("foo");
+  equal("NoSuchWindowError", err.name);
+  equal("foo", err.message);
+  equal("no such window", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_ScriptTimeoutError() {
+  let err = new error.ScriptTimeoutError("foo");
+  equal("ScriptTimeoutError", err.name);
+  equal("foo", err.message);
+  equal("script timeout", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_SessionNotCreatedError() {
+  let err = new error.SessionNotCreatedError("foo");
+  equal("SessionNotCreatedError", err.name);
+  equal("foo", err.message);
+  equal("session not created", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_StaleElementReferenceError() {
+  let err = new error.StaleElementReferenceError("foo");
+  equal("StaleElementReferenceError", err.name);
+  equal("foo", err.message);
+  equal("stale element reference", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_TimeoutError() {
+  let err = new error.TimeoutError("foo");
+  equal("TimeoutError", err.name);
+  equal("foo", err.message);
+  equal("timeout", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_UnableToSetCookieError() {
+  let err = new error.UnableToSetCookieError("foo");
+  equal("UnableToSetCookieError", err.name);
+  equal("foo", err.message);
+  equal("unable to set cookie", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_UnexpectedAlertOpenError() {
+  let err = new error.UnexpectedAlertOpenError("foo");
+  equal("UnexpectedAlertOpenError", err.name);
+  equal("foo", err.message);
+  equal("unexpected alert open", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_UnknownCommandError() {
+  let err = new error.UnknownCommandError("foo");
+  equal("UnknownCommandError", err.name);
+  equal("foo", err.message);
+  equal("unknown command", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_UnknownError() {
+  let err = new error.UnknownError("foo");
+  equal("UnknownError", err.name);
+  equal("foo", err.message);
+  equal("unknown error", err.status);
+  ok(err instanceof error.WebDriverError);
+});
+
+add_task(function test_UnsupportedOperationError() {
+  let err = new error.UnsupportedOperationError("foo");
+  equal("UnsupportedOperationError", err.name);
+  equal("foo", err.message);
+  equal("unsupported operation", err.status);
+  ok(err instanceof error.WebDriverError);
+});
diff --git a/remote/shared/webdriver/test/xpcshell/test_NodeCache.js b/remote/shared/webdriver/test/xpcshell/test_NodeCache.js
new file mode 100644
index 0000000000..961de2bcf5
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/test_NodeCache.js
@@ -0,0 +1,240 @@
+const { NodeCache } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/NodeCache.sys.mjs"
+);
+
+function setupTest() {
+  const browser = Services.appShell.createWindowlessBrowser(false);
+
+  browser.document.body.innerHTML = `
+    <div id="foo" style="margin: 50px">
+      <iframe></iframe>
+      <video></video>
+      <svg xmlns="http://www.w3.org/2000/svg"></svg>
+      <textarea></textarea>
+    </div>
+    <div id="with-comment"><!-- Comment --></div>
+  `;
+
+  const divEl = browser.document.querySelector("div");
+  const svgEl = browser.document.querySelector("svg");
+  const textareaEl = browser.document.querySelector("textarea");
+  const videoEl = browser.document.querySelector("video");
+
+  const iframeEl = browser.document.querySelector("iframe");
+  const childEl = iframeEl.contentDocument.createElement("div");
+  iframeEl.contentDocument.body.appendChild(childEl);
+
+  const shadowRoot = videoEl.openOrClosedShadowRoot;
+
+  return {
+    browser,
+    nodeCache: new NodeCache(),
+    childEl,
+    divEl,
+    iframeEl,
+    shadowRoot,
+    svgEl,
+    textareaEl,
+    videoEl,
+  };
+}
+
+add_task(function getOrCreateNodeReference_invalid() {
+  const { nodeCache } = setupTest();
+
+  const invalidValues = [null, undefined, "foo", 42, true, [], {}];
+
+  for (const value of invalidValues) {
+    info(`Testing value: ${value}`);
+    Assert.throws(() => nodeCache.getOrCreateNodeReference(value), /TypeError/);
+  }
+});
+
+add_task(function getOrCreateNodeReference_supportedNodeTypes() {
+  const { browser, divEl, nodeCache } = setupTest();
+
+  const xmlDocument = new DOMParser().parseFromString(
+    "<xml></xml>",
+    "application/xml"
+  );
+
+  const values = [
+    { node: divEl, type: Node.ELEMENT_NODE },
+    { node: divEl.attributes[0], type: Node.ATTRIBUTE_NODE },
+    { node: browser.document.createTextNode("foo"), type: Node.TEXT_NODE },
+    {
+      node: xmlDocument.createCDATASection("foo"),
+      type: Node.CDATA_SECTION_NODE,
+    },
+    {
+      node: browser.document.createProcessingInstruction(
+        "xml-stylesheet",
+        "href='foo.css'"
+      ),
+      type: Node.PROCESSING_INSTRUCTION_NODE_NODE,
+    },
+    { node: browser.document.createComment("foo"), type: Node.COMMENT_NODE },
+    { node: browser.document, type: Node.Document_NODE },
+    {
+      node: browser.document.implementation.createDocumentType(
+        "foo",
+        "bar",
+        "dtd"
+      ),
+      type: Node.DOCUMENT_TYPE_NODE_NODE,
+    },
+    {
+      node: browser.document.createDocumentFragment(),
+      type: Node.DOCUMENT_FRAGMENT_NODE,
+    },
+  ];
+
+  values.forEach((value, index) => {
+    info(`Testing value: ${value.type}`);
+    const nodeRef = nodeCache.getOrCreateNodeReference(value.node);
+    equal(nodeCache.size, index + 1);
+    equal(typeof nodeRef, "string");
+  });
+});
+
+add_task(function getOrCreateNodeReference_referenceAlreadyCreated() {
+  const { divEl, nodeCache } = setupTest();
+
+  const divElRef = nodeCache.getOrCreateNodeReference(divEl);
+  const divElRefOther = nodeCache.getOrCreateNodeReference(divEl);
+  equal(nodeCache.size, 1);
+  equal(divElRefOther, divElRef);
+});
+
+add_task(function getOrCreateNodeReference_differentReference() {
+  const { divEl, nodeCache, shadowRoot } = setupTest();
+
+  const divElRef = nodeCache.getOrCreateNodeReference(divEl);
+  equal(nodeCache.size, 1);
+
+  const shadowRootRef = nodeCache.getOrCreateNodeReference(shadowRoot);
+  equal(nodeCache.size, 2);
+
+  notEqual(divElRef, shadowRootRef);
+});
+
+add_task(function getOrCreateNodeReference_differentReferencePerNodeCache() {
+  const { browser, divEl, nodeCache } = setupTest();
+  const nodeCache2 = new NodeCache();
+
+  const divElRef1 = nodeCache.getOrCreateNodeReference(divEl);
+  const divElRef2 = nodeCache2.getOrCreateNodeReference(divEl);
+
+  notEqual(divElRef1, divElRef2);
+  equal(
+    nodeCache.getNode(browser.browsingContext, divElRef1),
+    nodeCache2.getNode(browser.browsingContext, divElRef2)
+  );
+
+  equal(nodeCache.getNode(browser.browsingContext, divElRef2), null);
+});
+
+add_task(function clear() {
+  const { browser, divEl, nodeCache, svgEl } = setupTest();
+
+  nodeCache.getOrCreateNodeReference(divEl);
+  nodeCache.getOrCreateNodeReference(svgEl);
+  equal(nodeCache.size, 2);
+
+  // Clear requires explicit arguments.
+  Assert.throws(() => nodeCache.clear(), /Error/);
+
+  // Clear references for a different browsing context
+  const browser2 = Services.appShell.createWindowlessBrowser(false);
+  const imgEl = browser2.document.createElement("img");
+  const imgElRef = nodeCache.getOrCreateNodeReference(imgEl);
+  equal(nodeCache.size, 3);
+
+  nodeCache.clear({ browsingContext: browser.browsingContext });
+  equal(nodeCache.size, 1);
+  equal(nodeCache.getNode(browser2.browsingContext, imgElRef), imgEl);
+
+  // Clear all references
+  nodeCache.getOrCreateNodeReference(divEl);
+  equal(nodeCache.size, 2);
+
+  nodeCache.clear({ all: true });
+  equal(nodeCache.size, 0);
+});
+
+add_task(function getNode_multiple_nodes() {
+  const { browser, divEl, nodeCache, svgEl } = setupTest();
+
+  const divElRef = nodeCache.getOrCreateNodeReference(divEl);
+  const svgElRef = nodeCache.getOrCreateNodeReference(svgEl);
+
+  equal(nodeCache.getNode(browser.browsingContext, svgElRef), svgEl);
+  equal(nodeCache.getNode(browser.browsingContext, divElRef), divEl);
+});
+
+add_task(function getNode_differentBrowsingContextInSameGroup() {
+  const { iframeEl, divEl, nodeCache } = setupTest();
+
+  const divElRef = nodeCache.getOrCreateNodeReference(divEl);
+  equal(nodeCache.size, 1);
+
+  equal(
+    nodeCache.getNode(iframeEl.contentWindow.browsingContext, divElRef),
+    divEl
+  );
+});
+
+add_task(function getNode_differentBrowsingContextInOtherGroup() {
+  const { divEl, nodeCache } = setupTest();
+
+  const divElRef = nodeCache.getOrCreateNodeReference(divEl);
+  equal(nodeCache.size, 1);
+
+  const browser2 = Services.appShell.createWindowlessBrowser(false);
+  equal(nodeCache.getNode(browser2.browsingContext, divElRef), null);
+});
+
+add_task(async function getNode_nodeDeleted() {
+  const { browser, nodeCache } = setupTest();
+  let el = browser.document.createElement("div");
+
+  const elRef = nodeCache.getOrCreateNodeReference(el);
+
+  // Delete element and force a garbage collection
+  el = null;
+
+  await doGC();
+
+  equal(nodeCache.getNode(browser.browsingContext, elRef), null);
+});
+
+add_task(function getNodeDetails_forTopBrowsingContext() {
+  const { browser, divEl, nodeCache } = setupTest();
+
+  const divElRef = nodeCache.getOrCreateNodeReference(divEl);
+
+  const nodeDetails = nodeCache.getReferenceDetails(divElRef);
+  equal(nodeDetails.browserId, browser.browsingContext.browserId);
+  equal(nodeDetails.browsingContextGroupId, browser.browsingContext.group.id);
+  equal(nodeDetails.browsingContextId, browser.browsingContext.id);
+  ok(nodeDetails.isTopBrowsingContext);
+  ok(nodeDetails.nodeWeakRef);
+  equal(nodeDetails.nodeWeakRef.get(), divEl);
+});
+
+add_task(async function getNodeDetails_forChildBrowsingContext() {
+  const { browser, iframeEl, childEl, nodeCache } = setupTest();
+
+  const childElRef = nodeCache.getOrCreateNodeReference(childEl);
+
+  const nodeDetails = nodeCache.getReferenceDetails(childElRef);
+  equal(nodeDetails.browserId, browser.browsingContext.browserId);
+  equal(nodeDetails.browsingContextGroupId, browser.browsingContext.group.id);
+  equal(
+    nodeDetails.browsingContextId,
+    iframeEl.contentWindow.browsingContext.id
+  );
+  ok(!nodeDetails.isTopBrowsingContext);
+  ok(nodeDetails.nodeWeakRef);
+  equal(nodeDetails.nodeWeakRef.get(), childEl);
+});
diff --git a/remote/shared/webdriver/test/xpcshell/test_Session.js b/remote/shared/webdriver/test/xpcshell/test_Session.js
new file mode 100644
index 0000000000..c7d40c7720
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/test_Session.js
@@ -0,0 +1,49 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+"use strict";
+
+const { Capabilities, Timeouts } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Capabilities.sys.mjs"
+);
+const { WebDriverSession } = ChromeUtils.importESModule(
+  "chrome://remote/content/shared/webdriver/Session.sys.mjs"
+);
+
+add_task(function test_WebDriverSession_ctor() {
+  const session = new WebDriverSession();
+
+  equal(typeof session.id, "string");
+  ok(session.capabilities instanceof Capabilities);
+});
+
+add_task(function test_WebDriverSession_getters() {
+  const session = new WebDriverSession();
+
+  equal(
+    session.a11yChecks,
+    session.capabilities.get("moz:accessibilityChecks")
+  );
+  equal(session.pageLoadStrategy, session.capabilities.get("pageLoadStrategy"));
+  equal(session.proxy, session.capabilities.get("proxy"));
+  equal(
+    session.strictFileInteractability,
+    session.capabilities.get("strictFileInteractability")
+  );
+  equal(session.timeouts, session.capabilities.get("timeouts"));
+  equal(
+    session.unhandledPromptBehavior,
+    session.capabilities.get("unhandledPromptBehavior")
+  );
+});
+
+add_task(function test_WebDriverSession_setters() {
+  const session = new WebDriverSession();
+
+  const timeouts = new Timeouts();
+  timeouts.pageLoad = 45;
+
+  session.timeouts = timeouts;
+  equal(session.timeouts, session.capabilities.get("timeouts"));
+});
diff --git a/remote/shared/webdriver/test/xpcshell/xpcshell.ini b/remote/shared/webdriver/test/xpcshell/xpcshell.ini
new file mode 100644
index 0000000000..c52f25c605
--- /dev/null
+++ b/remote/shared/webdriver/test/xpcshell/xpcshell.ini
@@ -0,0 +1,13 @@
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+[DEFAULT]
+head = head.js
+
+[test_Actions.js]
+[test_Assert.js]
+[test_Capabilities.js]
+[test_Errors.js]
+[test_NodeCache.js]
+[test_Session.js]