@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/transport/bidi-connection.ts

@@ -1,256 +0,0 @@
-import EventEmitter from "node:events";
-import type { BiDiCommands, BiDiEvents } from "../types/bidi.js";
-import logger from "../logger/index.js";
-import { WaitTimeoutError } from "../wait/wait-until.js";
-import { BiDiError } from "./bidi-error.js";
-import {
-  SubscriptionManager,
-  type EventName,
-  type Subscription,
-  type SubscribeOptions,
-} from "./subscriptions.js";
-
-/** Time (ms) a command may wait for its reply before it fails with code "timeout" */
-const DEFAULT_COMMAND_TIMEOUT = 30000;
-
-export interface ConnectorOptions {
-  /** @default 30000 */
-  commandTimeout?: number;
-}
-
-export interface SendOptions {
-  /** Overrides the connector's commandTimeout for this command */
-  timeout?: number;
-}
-
-interface BiDiMessage {
-  id: number;
-  method: string;
-  params?: object | undefined;
-}
-
-export class BiDiConnector {
-  private resolveMap: Map<
-    number,
-    {
-      method: string;
-      resolve: <M extends keyof BiDiCommands>(
-        value: BiDiCommands[M]["result"],
-      ) => void;
-      reject: (reason: unknown) => void;
-    }
-  > = new Map();
-  private currentId: number = 0;
-  private webSocket: WebSocket;
-  private eventEmitter: EventEmitter;
-  private commandTimeout: number;
-  private subscriptions: SubscriptionManager;
-
-  constructor(ws: WebSocket, options: ConnectorOptions = {}) {
-    this.commandTimeout = options.commandTimeout ?? DEFAULT_COMMAND_TIMEOUT;
-    this.subscriptions = new SubscriptionManager({
-      subscribe: (params) => this.send("session.subscribe", params),
-      unsubscribe: (params) => this.send("session.unsubscribe", params),
-    });
-    this.webSocket = ws;
-    this.webSocket.addEventListener("message", this.messageListener);
-    this.webSocket.addEventListener("close", this.onWebsocketClose);
-    this.webSocket.addEventListener("error", this.onWebsocketError);
-    this.eventEmitter = new EventEmitter();
-    console.info("BiDiConnector: Websocket handshake finished");
-  }
-
-  public static async connect(url: string, options?: ConnectorOptions) {
-    console.log("Connecting to WebSocket");
-    const ws = new WebSocket(url);
-    return new Promise<BiDiConnector>((resolve, reject) => {
-      console.log("Waiting for WebSocket handshake");
-      ws.addEventListener("open", () => {
-        console.log("WebSocket handshake finished");
-        resolve(new BiDiConnector(ws, options));
-      });
-      ws.addEventListener("error", (err) => {
-        console.error(err);
-        reject(new Error("WebSocket connection failed"));
-      });
-    });
-  }
-
-  private onWebsocketClose = () => {
-    this.rejectAll(
-      (pending) => new Error(`Websocket closed${pendingSuffix(pending)}`),
-    );
-  };
-
-  private onWebsocketError = (ev: Event) => {
-    this.rejectAll((pending) =>
-      Object.assign(new Error(`Websocket error${pendingSuffix(pending)}`), {
-        cause: ev,
-      }),
-    );
-  };
-
-  /** Rejects every pending command; `reason` gets the pending method names for its message */
-  private rejectAll(reason: (pendingMethods: string[]) => unknown) {
-    const entries = [...this.resolveMap.values()];
-    const error = reason(entries.map((entry) => entry.method));
-    this.resolveMap.clear();
-    entries.forEach(({ reject }) => reject(error));
-  }
-
-  private getId() {
-    return this.currentId++;
-  }
-
-  public send<M extends keyof BiDiCommands>(
-    method: M,
-    params?: BiDiCommands[M]["params"],
-    options: SendOptions = {},
-  ): Promise<BiDiCommands[M]["result"]> {
-    return new Promise((resolve, reject) => {
-      try {
-        const id = this.getId();
-        const timeout = options.timeout ?? this.commandTimeout;
-        const timer = setTimeout(() => {
-          this.resolveMap.delete(id);
-          reject(
-            new BiDiError(method, "timeout", `no reply within ${timeout}ms`),
-          );
-        }, timeout);
-        this.resolveMap.set(id, {
-          method,
-          resolve: (value) => {
-            clearTimeout(timer);
-            resolve(value);
-          },
-          reject: (reason) => {
-            clearTimeout(timer);
-            reject(reason);
-          },
-        });
-        const commandBody: BiDiMessage = {
-          id,
-          method,
-          params,
-        };
-        logger.debug("Sending message to BiDi Websocket", commandBody);
-        this.webSocket.send(JSON.stringify(commandBody));
-      } catch (err: unknown) {
-        reject(err);
-      }
-    });
-  }
-
-  /**
-   * Subscribes to events. Unscoped subscriptions are refcounted per event, so features can
-   * subscribe independently; scoped ones (`contexts`) always send their own command.
-   */
-  public subscribe(
-    events: EventName[],
-    options?: SubscribeOptions,
-  ): Promise<Subscription> {
-    return this.subscriptions.subscribe(events, options);
-  }
-
-  /**
-   * Resolves with the params of the first `event` for which `predicate` is true.
-   * The listener is registered before this returns, so start the triggering command afterwards.
-   * Rejects with WaitTimeoutError after `timeout` ms, or with the abort reason.
-   */
-  public waitForEvent<E extends keyof BiDiEvents>(
-    event: E,
-    predicate: (params: BiDiEvents[E]["params"]) => boolean,
-    options: { timeout: number; signal?: AbortSignal },
-  ): Promise<BiDiEvents[E]["params"]> {
-    const { timeout, signal } = options;
-    return new Promise((resolve, reject) => {
-      if (signal?.aborted) {
-        reject(signal.reason);
-        return;
-      }
-      const cleanup = () => {
-        clearTimeout(timer);
-        this.offEvent(event, listener);
-        signal?.removeEventListener("abort", onAbort);
-      };
-      const listener = (params: BiDiEvents[E]["params"]) => {
-        if (!predicate(params)) return;
-        cleanup();
-        resolve(params);
-      };
-      const onAbort = () => {
-        cleanup();
-        reject(signal?.reason);
-      };
-      const timer = setTimeout(() => {
-        cleanup();
-        reject(new WaitTimeoutError<undefined>(timeout, undefined));
-      }, timeout);
-      this.onEvent(event, listener);
-      signal?.addEventListener("abort", onAbort, { once: true });
-    });
-  }
-
-  /** Register an event listener */
-  public onEvent<E extends keyof BiDiEvents>(
-    event: E,
-    listener: (params: BiDiEvents[E]["params"]) => void,
-  ): void {
-    this.eventEmitter.on(event, listener);
-  }
-
-  /** Remove an event listener */
-  public offEvent<E extends keyof BiDiEvents>(
-    event: E,
-    listener: (params: BiDiEvents[E]["params"]) => void,
-  ): void {
-    this.eventEmitter.off(event, listener);
-  }
-
-  private messageListener = (ev: MessageEvent) => {
-    const message = JSON.parse(ev.data);
-    logger.debug("Received message from BiDi Websocket: ", message);
-    if (message.type === "success" && message.id !== undefined) {
-      const targetToResolve = this.resolveMap.get(message.id);
-      if (targetToResolve) {
-        this.resolveMap.delete(message.id);
-        targetToResolve.resolve(message.result);
-      }
-    } else if (message.type === "error") {
-      const target =
-        message.id === null || message.id === undefined
-          ? undefined
-          : this.resolveMap.get(message.id);
-      if (!target) {
-        logger.debug("BiDi error reply without a pending command", message);
-        return;
-      }
-      this.resolveMap.delete(message.id);
-      target.reject(
-        new BiDiError(
-          target.method,
-          message.error,
-          message.message,
-          message.stacktrace,
-        ),
-      );
-    } else if (message.type === "event") {
-      this.eventEmitter.emit(message.method, message.params);
-    }
-  };
-
-  public kill() {
-    this.webSocket.removeEventListener("message", this.messageListener);
-    this.webSocket.removeEventListener("close", this.onWebsocketClose);
-    this.webSocket.removeEventListener("error", this.onWebsocketError);
-    this.rejectAll(
-      (pending) => new Error(`BiDiConnector killed${pendingSuffix(pending)}`),
-    );
-    this.eventEmitter.removeAllListeners();
-    this.webSocket.close();
-  }
-}
-
-function pendingSuffix(pending: string[]) {
-  return pending.length > 0 ? ` (pending: ${pending.join(", ")})` : "";
-}

package/src/transport/bidi-error.ts

@@ -1,23 +0,0 @@
-import type { ErrorCode } from "../types/bidi-protocols/error.js";
-
-/** A failed BiDi command: an error reply from the browser, or `"timeout"` when none came in time */
-export class BiDiError extends Error {
-  /** BiDi error code such as "no such node", or "timeout" */
-  public readonly code: ErrorCode | "timeout";
-  /** The command that failed, e.g. "script.callFunction" */
-  public readonly command: string;
-  public readonly remoteStack?: string | undefined;
-
-  constructor(
-    command: string,
-    code: ErrorCode | "timeout",
-    message: string,
-    remoteStack?: string,
-  ) {
-    super(`${command} failed (${code}): ${message}`);
-    this.name = "BiDiError";
-    this.command = command;
-    this.code = code;
-    this.remoteStack = remoteStack;
-  }
-}

package/src/transport/foundation.browser-test.ts

@@ -1,73 +0,0 @@
-import assert from "node:assert/strict";
-import { after, before, test } from "node:test";
-import { Browser } from "../browser/browser.js";
-import type Page from "../browser/page.js";
-import { BiDiError } from "./bidi-error.js";
-
-let browser: Browser;
-let page: Page;
-
-before(async () => {
-  ({ browser, page } = await Browser.launch("firefox", { port: 9232, headless: true }));
-  await page.navigateTo("about:blank", "complete");
-});
-
-after(async () => {
-  await browser?.close();
-});
-
-const OPTIONS = { timeout: 15000 };
-
-test("newPage returns a page that can navigate", OPTIONS, async () => {
-  const created = await browser.newPage({ type: "tab" });
-  assert.notEqual(created.contextId, "");
-  assert.notEqual(created.contextId, page.contextId);
-  await created.navigateTo("about:blank", "complete");
-});
-
-test("a failing command rejects with the BiDi error code instead of hanging", OPTIONS, async () => {
-  const connector = (page as unknown as { biDiConnector: import("./bidi-connection.js").BiDiConnector })
-    .biDiConnector;
-  await assert.rejects(
-    connector.send("script.evaluate", {
-      expression: "1",
-      awaitPromise: false,
-      target: { context: "does-not-exist" },
-    }),
-    (err: unknown) => err instanceof BiDiError && err.code === "no such frame",
-  );
-});
-
-test("context tree attributes iframe contexts to the page", OPTIONS, async () => {
-  await page.navigateTo("about:blank", "complete");
-  const tree = await page.tree();
-  const connector = (page as unknown as { biDiConnector: import("./bidi-connection.js").BiDiConnector })
-    .biDiConnector;
-  const created = connector.waitForEvent("browsingContext.contextCreated", (info) => info.parent === page.contextId, {
-    timeout: 5000,
-  });
-  await connector.send("script.evaluate", {
-    expression: `document.body.appendChild(document.createElement("iframe")).src = "about:blank"; 1`,
-    awaitPromise: false,
-    target: { context: page.contextId },
-  });
-  const frame = await created;
-  assert.equal(tree.isWithin(frame.context, page.contextId), true);
-  assert.equal(tree.rootOf(frame.context), page.contextId);
-});
-
-test("refcounted subscriptions deliver events to every subscriber", OPTIONS, async () => {
-  const connector = (page as unknown as { biDiConnector: import("./bidi-connection.js").BiDiConnector })
-    .biDiConnector;
-  const a = await connector.subscribe(["browsingContext.load"]);
-  const b = await connector.subscribe(["browsingContext.load"]);
-  const seen = connector.waitForEvent("browsingContext.load", (p) => p.context === page.contextId, { timeout: 5000 });
-  await page.navigateTo("about:blank?again", "none");
-  await seen;
-  await a.unsubscribe();
-  // b still holds the subscription, so events keep flowing
-  const again = connector.waitForEvent("browsingContext.load", (p) => p.context === page.contextId, { timeout: 5000 });
-  await page.navigateTo("about:blank?third", "none");
-  await again;
-  await b.unsubscribe();
-});

package/src/transport/subscriptions.test.ts

@@ -1,140 +0,0 @@
-import assert from "node:assert/strict";
-import { describe, it } from "node:test";
-import { tick } from "../testing/fake-websocket.js";
-import { SubscriptionManager, type SessionCommands } from "./subscriptions.js";
-
-function setup(options: { failSubscribe?: boolean; delay?: number } = {}) {
-  const calls: Array<{ command: "subscribe" | "unsubscribe"; params: any }> = [];
-  let next = 0;
-  const commands: SessionCommands = {
-    async subscribe(params) {
-      calls.push({ command: "subscribe", params });
-      await tick(options.delay ?? 0);
-      if (options.failSubscribe) throw new Error("subscribe failed");
-      return { subscription: `s${++next}` };
-    },
-    async unsubscribe(params) {
-      calls.push({ command: "unsubscribe", params });
-      await tick(options.delay ?? 0);
-      return {};
-    },
-  };
-  return { calls, manager: new SubscriptionManager(commands) };
-}
-
-describe("SubscriptionManager", () => {
-  it("shares one subscribe between concurrent first subscribers", async () => {
-    const { calls, manager } = setup({ delay: 5 });
-    const [a, b] = await Promise.all([
-      manager.subscribe(["browsingContext.load"]),
-      manager.subscribe(["browsingContext.load"]),
-    ]);
-    assert.equal(calls.filter((c) => c.command === "subscribe").length, 1);
-    await a.unsubscribe();
-    await b.unsubscribe();
-    assert.deepEqual(calls[calls.length - 1], { command: "unsubscribe", params: { subscriptions: ["s1"] } });
-  });
-
-  it("subscribes each event separately and releases them together", async () => {
-    const { calls, manager } = setup();
-    const sub = await manager.subscribe(["network.beforeRequestSent", "network.fetchError"]);
-    assert.deepEqual(
-      calls.map((c) => c.params.events),
-      [["network.beforeRequestSent"], ["network.fetchError"]],
-    );
-    await sub.unsubscribe();
-    assert.equal(calls.filter((c) => c.command === "unsubscribe").length, 2);
-  });
-
-  it("keeps an event subscribed while another subscriber still needs it", async () => {
-    const { calls, manager } = setup();
-    const a = await manager.subscribe(["network.fetchError", "network.responseCompleted"]);
-    const b = await manager.subscribe(["network.fetchError"]);
-    await a.unsubscribe();
-    // only responseCompleted was released
-    assert.deepEqual(
-      calls.filter((c) => c.command === "unsubscribe").map((c) => c.params.subscriptions),
-      [["s2"]],
-    );
-    await b.unsubscribe();
-    assert.equal(calls.filter((c) => c.command === "unsubscribe").length, 2);
-  });
-
-  it("keeps the subscription when a new subscriber arrives while the last one is leaving", async () => {
-    const { calls, manager } = setup({ delay: 5 });
-    const first = await manager.subscribe(["log.entryAdded"]);
-    const leaving = first.unsubscribe();
-    const again = manager.subscribe(["log.entryAdded"]); // arrives before the queued unsubscribe runs
-    const second = await again;
-    await leaving;
-    assert.deepEqual(calls.map((c) => c.command), ["subscribe"]);
-    await second.unsubscribe();
-    assert.deepEqual(calls.map((c) => c.command), ["subscribe", "unsubscribe"]);
-  });
-
-  it("resubscribes when a subscriber arrives after the last one fully left", async () => {
-    const { calls, manager } = setup();
-    const first = await manager.subscribe(["log.entryAdded"]);
-    await first.unsubscribe();
-    const again = await manager.subscribe(["log.entryAdded"]);
-    assert.deepEqual(calls.map((c) => c.command), ["subscribe", "unsubscribe", "subscribe"]);
-    await again.unsubscribe();
-  });
-
-  it("unsubscribe is idempotent", async () => {
-    const { calls, manager } = setup();
-    const a = await manager.subscribe(["log.entryAdded"]);
-    const b = await manager.subscribe(["log.entryAdded"]);
-    await a.unsubscribe();
-    await a.unsubscribe();
-    assert.equal(calls.filter((c) => c.command === "unsubscribe").length, 0); // b still holds it
-    await b.unsubscribe();
-    assert.equal(calls.filter((c) => c.command === "unsubscribe").length, 1);
-  });
-
-  it("scoped subscriptions send their own command and are not shared", async () => {
-    const { calls, manager } = setup();
-    const a = await manager.subscribe(["log.entryAdded"], { contexts: ["c1"] });
-    const b = await manager.subscribe(["log.entryAdded"], { contexts: ["c1"] });
-    assert.equal(calls.filter((c) => c.command === "subscribe").length, 2);
-    assert.deepEqual(calls[0]!.params, { events: ["log.entryAdded"], contexts: ["c1"] });
-    await a.unsubscribe();
-    await a.unsubscribe();
-    assert.deepEqual(
-      calls.filter((c) => c.command === "unsubscribe").map((c) => c.params.subscriptions),
-      [["s1"]],
-    );
-    await b.unsubscribe();
-  });
-
-  it("a failed subscribe rolls back and lets a later subscribe try again", async () => {
-    const { calls, manager } = setup({ failSubscribe: true });
-    await assert.rejects(manager.subscribe(["log.entryAdded"]), /subscribe failed/);
-    await assert.rejects(manager.subscribe(["log.entryAdded"]), /subscribe failed/);
-    assert.equal(calls.filter((c) => c.command === "subscribe").length, 2);
-    assert.equal(calls.filter((c) => c.command === "unsubscribe").length, 0);
-  });
-
-  it("rolls back events already acquired when a later one fails", async () => {
-    const calls: Array<{ command: string; params: any }> = [];
-    let count = 0;
-    const flaky = new SubscriptionManager({
-      async subscribe(params) {
-        calls.push({ command: "subscribe", params });
-        if (++count === 2) throw new Error("second failed");
-        return { subscription: "ok" };
-      },
-      async unsubscribe(params) {
-        calls.push({ command: "unsubscribe", params });
-        return {};
-      },
-    });
-    await assert.rejects(
-      flaky.subscribe(["network.fetchError", "network.responseCompleted"]),
-      /second failed/,
-    );
-    assert.deepEqual(calls.filter((c) => c.command === "unsubscribe").map((c) => c.params), [
-      { subscriptions: ["ok"] },
-    ]);
-  });
-});

package/src/transport/subscriptions.ts

@@ -1,110 +0,0 @@
-import type { BiDiEvents } from "../types/bidi.js";
-
-export type EventName = keyof BiDiEvents;
-
-export interface Subscription {
-  /** Idempotent */
-  unsubscribe(): Promise<void>;
-}
-
-export interface SubscribeOptions {
-  /** Scope to these browsing contexts. Scoped subscriptions are never shared */
-  contexts?: string[];
-}
-
-/** Sends the two session commands; the connector provides it */
-export interface SessionCommands {
-  subscribe(params: { events: string[]; contexts?: string[] }): Promise<{ subscription: string }>;
-  unsubscribe(params: { subscriptions: string[] }): Promise<unknown>;
-}
-
-interface Shared {
-  count: number;
-  id: string | undefined;
-  /** Serialises subscribe/unsubscribe commands for this event so they never interleave */
-  chain: Promise<void>;
-}
-
-/**
- * Global (unscoped) subscriptions are refcounted per event name: the first subscriber sends
- * `session.subscribe`, the last one leaving sends `session.unsubscribe`.
- */
-export class SubscriptionManager {
-  private shared = new Map<EventName, Shared>();
-
-  constructor(private commands: SessionCommands) {}
-
-  public async subscribe(events: EventName[], options: SubscribeOptions = {}): Promise<Subscription> {
-    if (options.contexts) return this.subscribeScoped(events, options.contexts);
-
-    const acquired: EventName[] = [];
-    try {
-      for (const event of events) {
-        await this.acquire(event);
-        acquired.push(event);
-      }
-    } catch (err) {
-      await Promise.allSettled(acquired.map((event) => this.release(event)));
-      throw err;
-    }
-
-    let released = false;
-    return {
-      unsubscribe: async () => {
-        if (released) return;
-        released = true;
-        await Promise.all(acquired.map((event) => this.release(event)));
-      },
-    };
-  }
-
-  private async subscribeScoped(events: EventName[], contexts: string[]): Promise<Subscription> {
-    const { subscription } = await this.commands.subscribe({ events, contexts });
-    let released = false;
-    return {
-      unsubscribe: async () => {
-        if (released) return;
-        released = true;
-        await this.commands.unsubscribe({ subscriptions: [subscription] });
-      },
-    };
-  }
-
-  private state(event: EventName): Shared {
-    let state = this.shared.get(event);
-    if (!state) {
-      state = { count: 0, id: undefined, chain: Promise.resolve() };
-      this.shared.set(event, state);
-    }
-    return state;
-  }
-
-  private acquire(event: EventName): Promise<void> {
-    const state = this.state(event);
-    state.count++;
-    const step = state.chain.then(async () => {
-      if (state.count > 0 && state.id === undefined) {
-        state.id = (await this.commands.subscribe({ events: [event] })).subscription;
-      }
-    });
-    state.chain = step.catch(() => {});
-    return step.catch((err) => {
-      state.count--;
-      throw err;
-    });
-  }
-
-  private release(event: EventName): Promise<void> {
-    const state = this.state(event);
-    state.count--;
-    const step = state.chain.then(async () => {
-      if (state.count === 0 && state.id !== undefined) {
-        const id = state.id;
-        state.id = undefined;
-        await this.commands.unsubscribe({ subscriptions: [id] });
-      }
-    });
-    state.chain = step.catch(() => {});
-    return step;
-  }
-}

package/src/types/bidi-commands.test-d.ts

@@ -1,55 +0,0 @@
-// Compile-time check, run by `tsc --noEmit`: every command the BiDi specs rely on is typed.
-import type { BiDiCommands } from "./bidi.js";
-
-type Expect<T extends true> = T;
-type HasCommand<M extends string> = M extends keyof BiDiCommands
-  ? BiDiCommands[M] extends { params: unknown; result: unknown }
-    ? true
-    : false
-  : false;
-
-type Commands = [
-  Expect<HasCommand<"script.callFunction">>,
-  Expect<HasCommand<"script.disown">>,
-  Expect<HasCommand<"script.addPreloadScript">>,
-  Expect<HasCommand<"script.removePreloadScript">>,
-  Expect<HasCommand<"browsingContext.locateNodes">>,
-  Expect<HasCommand<"browsingContext.handleUserPrompt">>,
-  Expect<HasCommand<"browsingContext.setViewport">>,
-  Expect<HasCommand<"browsingContext.reload">>,
-  Expect<HasCommand<"browsingContext.traverseHistory">>,
-  Expect<HasCommand<"browsingContext.close">>,
-  Expect<HasCommand<"browsingContext.print">>,
-  Expect<HasCommand<"input.setFiles">>,
-  Expect<HasCommand<"network.addIntercept">>,
-  Expect<HasCommand<"network.removeIntercept">>,
-  Expect<HasCommand<"network.continueRequest">>,
-  Expect<HasCommand<"network.continueResponse">>,
-  Expect<HasCommand<"network.continueWithAuth">>,
-  Expect<HasCommand<"network.provideResponse">>,
-  Expect<HasCommand<"network.failRequest">>,
-  Expect<HasCommand<"network.setCacheBehavior">>,
-  Expect<HasCommand<"network.addDataCollector">>,
-  Expect<HasCommand<"network.removeDataCollector">>,
-  Expect<HasCommand<"network.getData">>,
-  Expect<HasCommand<"network.disownData">>,
-  Expect<HasCommand<"browser.createUserContext">>,
-  Expect<HasCommand<"browser.removeUserContext">>,
-  Expect<HasCommand<"browser.getUserContexts">>,
-  Expect<HasCommand<"browser.setDownloadBehavior">>,
-  Expect<HasCommand<"session.unsubscribe">>,
-  Expect<HasCommand<"emulation.setForcedColorsModeThemeOverride">>,
-  Expect<HasCommand<"emulation.setGeolocationOverride">>,
-  Expect<HasCommand<"emulation.setLocaleOverride">>,
-  Expect<HasCommand<"emulation.setNetworkConditions">>,
-  Expect<HasCommand<"emulation.setScreenOrientationOverride">>,
-  Expect<HasCommand<"emulation.setScreenSettingsOverride">>,
-  Expect<HasCommand<"emulation.setScriptingEnabled">>,
-  Expect<HasCommand<"emulation.setScrollbarTypeOverride">>,
-  Expect<HasCommand<"emulation.setTimezoneOverride">>,
-  Expect<HasCommand<"emulation.setTouchOverride">>,
-  Expect<HasCommand<"emulation.setUserAgentOverride">>,
-  Expect<HasCommand<"permissions.setPermission">>,
-];
-
-export type { Commands };