@alumnium/selenium 0.0.0-stage → 0.24.0-alpha.1

package/src/index.cjs

@@ -0,0 +1,1229 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode
+      ? (__toESMCache_node ??= new WeakMap())
+      : (__toESMCache_esm ??= new WeakMap());
+    var cached = cache.get(mod);
+    if (cached) return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to =
+    isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default")
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target;
+  if ((mod && typeof mod === "object") || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true,
+        });
+  }
+  if (canCache) cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap()).get(from),
+    desc;
+  if (entry) return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name),
+    });
+};
+var __legacyDecorateClassTS = function (decorators, target, key, desc) {
+  var c = arguments.length,
+    r =
+      c < 3
+        ? target
+        : desc === null
+          ? (desc = Object.getOwnPropertyDescriptor(target, key))
+          : desc,
+    d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if ((d = decorators[i]))
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return (c > 3 && r && Object.defineProperty(target, key, r), r);
+};
+
+// selenium/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  Alumni: () => Alumni,
+  SeleniumDriver: () => SeleniumDriver,
+});
+module.exports = __toCommonJS(exports_src);
+
+// selenium/src/Alumni.ts
+var import_selenium_webdriver2 = require("selenium-webdriver");
+var import_core = require("@alumnium/core");
+
+// selenium/src/drivers/SeleniumDriver.ts
+var fs = __toESM(require("fs/promises"), 1);
+var import_alwaysly = require("alwaysly");
+var import_selenium_webdriver = require("selenium-webdriver");
+var import_error = require("selenium-webdriver/lib/error.js");
+var import_internal = require("@alumnium/core/internal");
+
+// selenium/src/drivers/SeleniumCdpConnection.ts
+var AUTO_ATTACH_PARAMS = {
+  autoAttach: true,
+  waitForDebuggerOnStart: true,
+  flatten: true,
+};
+var TIMEOUT_MS = 5000;
+
+class SeleniumCdpConnection {
+  #socket;
+  #waiterScript;
+  #nextId = 1;
+  #pending = new Map();
+  #targetSessions = new Map();
+  #sessionConfigurations = new Map();
+  #closed = false;
+  constructor(socket, waiterScript) {
+    this.#socket = socket;
+    this.#waiterScript = waiterScript;
+    socket.addEventListener("message", (event) => this.#onMessage(event.data));
+    socket.addEventListener("close", () => this.#failConnection());
+    socket.addEventListener("error", () => this.#failConnection());
+  }
+  static async connect(capabilities, waiterScript) {
+    const url = await websocketUrl(capabilities);
+    const socket = new WebSocket(url);
+    try {
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(
+          () => reject(new Error("Timed out connecting to Chrome CDP")),
+          TIMEOUT_MS,
+        );
+        socket.addEventListener(
+          "open",
+          () => {
+            clearTimeout(timeout);
+            resolve();
+          },
+          { once: true },
+        );
+        socket.addEventListener(
+          "error",
+          () => {
+            clearTimeout(timeout);
+            reject(new Error("Could not connect to Chrome CDP"));
+          },
+          { once: true },
+        );
+      });
+    } catch (error) {
+      socket.close();
+      throw error;
+    }
+    const connection = new SeleniumCdpConnection(socket, waiterScript);
+    try {
+      await connection.#send("Target.setAutoAttach", AUTO_ATTACH_PARAMS);
+      await connection.#send("Target.setDiscoverTargets", { discover: true });
+      const targets = await connection.#send("Target.getTargets");
+      for (const target of targets.targetInfos ?? []) {
+        if (target.type === "page")
+          await connection.#awaitSession(target.targetId);
+      }
+      return connection;
+    } catch (error) {
+      connection.close();
+      throw error;
+    }
+  }
+  close() {
+    if (this.#closed) return;
+    this.#closed = true;
+    this.#failPending(new Error("CDP connection closed"));
+    this.#socket.close();
+    this.#targetSessions.clear();
+    this.#sessionConfigurations.clear();
+  }
+  #send(method, params = {}, sessionId = "", wait = true) {
+    if (this.#closed) return Promise.reject(new Error("CDP connection closed"));
+    const id = this.#nextId++;
+    const message = { id, method, params, ...(sessionId ? { sessionId } : {}) };
+    if (!wait) {
+      this.#socket.send(JSON.stringify(message));
+      return Promise.resolve({});
+    }
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.#pending.delete(id);
+        reject(new Error(`Timed out sending CDP command ${method}`));
+      }, TIMEOUT_MS);
+      this.#pending.set(id, { resolve, reject, timeout });
+      try {
+        this.#socket.send(JSON.stringify(message));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.#pending.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    });
+  }
+  #onMessage(data) {
+    if (data instanceof Blob) {
+      data.text().then((text) => this.#onMessage(text));
+      return;
+    }
+    const text =
+      typeof data === "string" ? data : new TextDecoder().decode(data);
+    const message = JSON.parse(text);
+    if (message.id) {
+      const command = this.#pending.get(message.id);
+      if (!command) return;
+      this.#pending.delete(message.id);
+      clearTimeout(command.timeout);
+      if (message.error) command.reject(new Error(message.error.message));
+      else command.resolve(message.result ?? {});
+      return;
+    }
+    const method = message.method ?? "";
+    const params = message.params ?? {};
+    if (method === "Target.attachedToTarget") {
+      const targetInfo = params.targetInfo;
+      const sessionId = String(params.sessionId);
+      let configuration = Promise.resolve();
+      if (targetInfo?.type === "page" || targetInfo?.type === "iframe") {
+        if (targetInfo.targetId)
+          this.#targetSessions.set(targetInfo.targetId, sessionId);
+        configuration = this.#configureSession(sessionId);
+      }
+      configuration
+        .finally(() =>
+          this.#send("Runtime.runIfWaitingForDebugger", {}, sessionId),
+        )
+        .catch(() => {
+          return;
+        });
+    } else if (method === "Target.detachedFromTarget") {
+      this.#detachSession(String(params.sessionId ?? ""));
+    }
+  }
+  #configureSession(sessionId) {
+    const existing = this.#sessionConfigurations.get(sessionId);
+    if (existing) return existing;
+    const configuration = this.#configureNewSession(sessionId);
+    this.#sessionConfigurations.set(sessionId, configuration);
+    return configuration;
+  }
+  async #configureNewSession(sessionId) {
+    await this.#send("Target.setAutoAttach", AUTO_ATTACH_PARAMS, sessionId);
+    await this.#send("Page.enable", {}, sessionId);
+    await this.#send(
+      "Page.addScriptToEvaluateOnNewDocument",
+      { source: this.#waiterScript, runImmediately: true },
+      sessionId,
+    );
+  }
+  async #awaitSession(targetId) {
+    const deadline = Date.now() + TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      const sessionId = this.#targetSessions.get(targetId);
+      const configuration = sessionId
+        ? this.#sessionConfigurations.get(sessionId)
+        : undefined;
+      if (sessionId && configuration) {
+        await configuration;
+        return sessionId;
+      }
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    return "";
+  }
+  #detachSession(sessionId) {
+    if (!sessionId) return;
+    this.#sessionConfigurations.delete(sessionId);
+    for (const [targetId, attachedSession] of this.#targetSessions) {
+      if (attachedSession === sessionId) this.#targetSessions.delete(targetId);
+    }
+  }
+  #failConnection() {
+    this.#closed = true;
+    this.#failPending(new Error("CDP connection closed"));
+  }
+  #failPending(error) {
+    for (const command of this.#pending.values()) {
+      clearTimeout(command.timeout);
+      command.reject(error);
+    }
+    this.#pending.clear();
+  }
+}
+async function websocketUrl(capabilities) {
+  const cdpUrl = capabilities.get("se:cdp");
+  if (typeof cdpUrl === "string") return cdpUrl;
+  const options =
+    capabilities.get("goog:chromeOptions") ??
+    capabilities.get("ms:edgeOptions");
+  if (!options?.debuggerAddress) {
+    throw new Error("Chromium did not expose a CDP debugger address");
+  }
+  const response = await fetch(
+    `http://${options.debuggerAddress}/json/version`,
+    {
+      signal: AbortSignal.timeout(TIMEOUT_MS),
+    },
+  );
+  if (!response.ok) throw new Error(`CDP discovery failed: ${response.status}`);
+  const version = await response.json();
+  return version.webSocketDebuggerUrl;
+}
+
+// selenium/src/drivers/SeleniumDriver.ts
+var { tracer, logger } = import_internal.Telemetry.get(
+  "packages/typescript/selenium/src/drivers/SeleniumDriver.ts",
+);
+var { span } = tracer.dec();
+var stateful = import_internal.BaseDriver.stateful;
+var WAITER_SCRIPT = import_internal.waiterScriptSource;
+
+class SeleniumDriver extends import_internal.BaseDriver {
+  driver;
+  kind = "selenium";
+  platform = "chromium";
+  autoswitchToNewTab = true;
+  #shadowChildToHostMap = {};
+  #cdpConnection = null;
+  #cdpReady;
+  fullPageScreenshot = import_internal.Env.ALUMNIUM_FULL_PAGE_SCREENSHOT;
+  supportedTools = new Set([
+    import_internal.ClickTool,
+    import_internal.DragAndDropTool,
+    import_internal.HoverTool,
+    import_internal.PressKeyTool,
+    import_internal.TypeTool,
+    import_internal.UploadTool,
+  ]);
+  constructor(driver) {
+    super();
+    this.driver = driver;
+    this.#cdpReady = this.initCdpConnection();
+  }
+  async fetchAccessibilityTree() {
+    await this.driver.switchTo().defaultContent();
+    await this.driver.switchTo().window(await this.driver.getWindowHandle());
+    logger.debug("Waiting for page to load before getting accessibility tree");
+    await this.waitForPageToLoad();
+    logger.debug("Page loaded, retrieving accessibility tree");
+    const frameTree = await this.executeCdpCommand("Page.getFrameTree", {});
+    const frameIds = this.getAllFrameIds(frameTree.frameTree);
+    const mainFrameId = frameTree.frameTree.frame.id;
+    logger.debug(`Found ${frameIds.length} frames`);
+    await this.executeCdpCommand("DOM.enable", {});
+    const domResponse = await this.executeCdpCommand(
+      "DOM.getFlattenedDocument",
+      { depth: -1, pierce: true },
+    );
+    const domNodes = domResponse.nodes || [];
+    const frameToIframeMap = new Map();
+    const frameParentMap = new Map();
+    await this.buildFrameHierarchy(
+      frameTree.frameTree,
+      mainFrameId,
+      frameToIframeMap,
+      frameParentMap,
+    );
+    const allNodes = [];
+    for (const frameId of frameIds) {
+      try {
+        const response = await this.executeCdpCommand(
+          "Accessibility.getFullAXTree",
+          { frameId },
+        );
+        const nodes = response.nodes || [];
+        logger.debug(
+          `  -> Frame ${frameId.slice(0, 20)}...: ${nodes.length} nodes`,
+        );
+        const frameChain = this.getFrameChain(
+          frameId,
+          frameToIframeMap,
+          frameParentMap,
+        );
+        for (const node of nodes) {
+          if (frameChain.length > 0) {
+            node._frame_chain = frameChain;
+          }
+        }
+        allNodes.push(...nodes);
+      } catch (error) {
+        logger.debug(
+          `  -> Frame ${frameId.slice(0, 20)}...: failed (${error instanceof Error ? error.message : String(error)})`,
+        );
+      }
+    }
+    logger.debug(`Total accessibility nodes collected: ${allNodes.length}`);
+    try {
+      const frameChainsByBackendId = {};
+      for (const node of allNodes) {
+        if (node.backendDOMNodeId && node._frame_chain)
+          frameChainsByBackendId[node.backendDOMNodeId] = node._frame_chain;
+      }
+      const shadowNodes = await this.buildShadowHierarchy(
+        domNodes,
+        frameChainsByBackendId,
+      );
+      allNodes.push(...shadowNodes);
+      if (shadowNodes.length > 0) {
+        logger.debug(`  -> Shadow DOM: ${shadowNodes.length} nodes added`);
+      }
+    } catch (error) {
+      logger.debug(
+        `  -> Shadow DOM failed (${error instanceof Error ? error.message : String(error)})`,
+      );
+    }
+    return new import_internal.ChromiumAccessibilityTree({ nodes: allNodes });
+  }
+  async click(id) {
+    await this.#autoswitchToNewTabAction(async () => {
+      const element = await this.findElement(id);
+      await this.#scrollElementIntoCenter(element);
+      try {
+        const actions = this.driver.actions({ async: true });
+        await actions.move({ origin: element }).click().perform();
+      } catch (error) {
+        if (error instanceof import_error.ElementNotInteractableError) {
+          await element.click();
+        } else {
+          throw error;
+        }
+      }
+    });
+  }
+  async dragSlider(id, value) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIntoCenter(element);
+    await this.driver.executeScript(
+      "arguments[0].value = arguments[1];" +
+        "arguments[0].dispatchEvent(new Event('input', {bubbles: true}));" +
+        "arguments[0].dispatchEvent(new Event('change', {bubbles: true}));",
+      element,
+      String(value),
+    );
+  }
+  async dragAndDrop(fromId, toId) {
+    const fromElement = await this.findElement(fromId);
+    const toElement = await this.findElement(toId);
+    await this.#scrollElementIntoCenter(fromElement);
+    const actions = this.driver.actions({ async: true });
+    await actions.dragAndDrop(fromElement, toElement).perform();
+  }
+  async hover(id) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIntoCenter(element);
+    const actions = this.driver.actions({ async: true });
+    await actions.move({ origin: element }).perform();
+  }
+  pressKey(key) {
+    return this.#autoswitchToNewTabAction(async () => {
+      const keyMap = {
+        Backspace: import_selenium_webdriver.Key.BACK_SPACE,
+        Enter: import_selenium_webdriver.Key.ENTER,
+        Escape: import_selenium_webdriver.Key.ESCAPE,
+        Space: import_selenium_webdriver.Key.SPACE,
+        Tab: import_selenium_webdriver.Key.TAB,
+        ArrowDown: import_selenium_webdriver.Key.ARROW_DOWN,
+        ArrowUp: import_selenium_webdriver.Key.ARROW_UP,
+        ArrowLeft: import_selenium_webdriver.Key.ARROW_LEFT,
+        ArrowRight: import_selenium_webdriver.Key.ARROW_RIGHT,
+      };
+      const actions = this.driver.actions({ async: true });
+      await actions.sendKeys(keyMap[key]).perform();
+    });
+  }
+  async quit() {
+    await this.#cdpReady;
+    this.#cdpConnection?.close();
+    try {
+      await this.driver.quit();
+    } catch (error) {
+      if (error instanceof import_error.NoSuchSessionError) {
+        logger.info("Selenium session already closed, ignoring quit error");
+      } else {
+        throw error;
+      }
+    }
+  }
+  async back() {
+    await this.driver.navigate().back();
+  }
+  async visit(url) {
+    await this.checkNavigationPolicy(url);
+    await this.driver.get(url);
+  }
+  async scrollTo(id) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIntoCenter(element);
+  }
+  async screenshot() {
+    if (this.fullPageScreenshot) {
+      const result = await this.executeCdpCommand("Page.captureScreenshot", {
+        format: "png",
+        captureBeyondViewport: true,
+      });
+      return result.data;
+    } else {
+      return await this.driver.takeScreenshot();
+    }
+  }
+  title() {
+    return this.driver.getTitle();
+  }
+  async type(id, text) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIntoCenter(element);
+    await element.clear();
+    await element.sendKeys(text);
+  }
+  async upload(id, paths) {
+    const element = await this.findElement(id);
+    await element.sendKeys(
+      paths.join(`
+`),
+    );
+  }
+  url() {
+    return this.driver.getCurrentUrl();
+  }
+  async app() {
+    const currentUrl = await this.driver.getCurrentUrl();
+    return import_internal.AppId.parse(currentUrl);
+  }
+  async findElement(id) {
+    const tree = await this.getAccessibilityTree();
+    const accessibilityElement = tree.elementById(id);
+    const backendNodeId = accessibilityElement.backendNodeId;
+    const frameChain = accessibilityElement.frameChain;
+    if (frameChain && frameChain.length > 0) {
+      await this.switchToFrameChain(frameChain);
+    }
+    await this.executeCdpCommand("DOM.enable", {});
+    await this.executeCdpCommand("DOM.getFlattenedDocument", {});
+    const { nodeIds } = await this.executeCdpCommand(
+      "DOM.pushNodesByBackendIdsToFrontend",
+      { backendNodeIds: [backendNodeId] },
+    );
+    const nodeId = nodeIds[0];
+    await this.executeCdpCommand("DOM.setAttributeValue", {
+      nodeId,
+      name: "data-alumnium-id",
+      value: String(backendNodeId),
+    });
+    const selector = `[data-alumnium-id='${backendNodeId}']`;
+    const hostBackendNodeId = this.#shadowChildToHostMap[backendNodeId];
+    const searchContext =
+      hostBackendNodeId !== undefined
+        ? await this.findShadowRoot(hostBackendNodeId)
+        : this.driver;
+    const element = await searchContext.findElement(
+      import_selenium_webdriver.By.css(selector),
+    );
+    await this.executeCdpCommand("DOM.removeAttribute", {
+      nodeId,
+      name: "data-alumnium-id",
+    });
+    return element;
+  }
+  async executeScript(script) {
+    await this.driver.executeScript(script);
+  }
+  async printToPdf(filepath) {
+    const { data } = await this.executeCdpCommand("Page.printToPDF", {});
+    await fs.writeFile(filepath, Buffer.from(data, "base64"));
+  }
+  async switchToNextTab() {
+    const handles = await this.driver.getAllWindowHandles();
+    if (handles.length <= 1) return;
+    const current = await this.driver.getWindowHandle();
+    const currentIndex = handles.indexOf(current);
+    const nextIndex = (currentIndex + 1) % handles.length;
+    await this.switchToTab(handles, nextIndex);
+    logger.debug(
+      `Switched to next tab: ${await this.driver.getTitle()} (${await this.driver.getCurrentUrl()})`,
+    );
+  }
+  async switchToPreviousTab() {
+    const handles = await this.driver.getAllWindowHandles();
+    if (handles.length <= 1) return;
+    const current = await this.driver.getWindowHandle();
+    const currentIndex = handles.indexOf(current);
+    const prevIndex = (currentIndex - 1 + handles.length) % handles.length;
+    await this.switchToTab(handles, prevIndex);
+    logger.debug(
+      `Switched to previous tab: ${await this.driver.getTitle()} (${await this.driver.getCurrentUrl()})`,
+    );
+  }
+  async wait(seconds) {
+    const clampedSeconds = Math.max(1, Math.min(30, seconds));
+    await new Promise((resolve) => setTimeout(resolve, clampedSeconds * 1000));
+  }
+  async waitForSelector() {
+    throw new Error("waitForSelector not supported for this driver");
+  }
+  async #scrollElementIntoCenter(element) {
+    await this.driver.executeScript(
+      "arguments[0].scrollIntoView({block: 'center'});",
+      element,
+    );
+  }
+  async checkNavigationPolicy(url) {
+    const currentUrl = url ?? (await this.url());
+    this.navigationPolicy.check(currentUrl);
+  }
+  executeCdpCommand(cmd, params) {
+    return this.driver.sendAndGetDevToolsCommand(cmd, params);
+  }
+  async waitForPageToLoad() {
+    await this.#cdpReady;
+    try {
+      const result = await import_internal.waitForPageStability(() =>
+        this.waiterSnapshot(),
+      );
+      if (!result.loaded) {
+        logger.warn(
+          `Timed out waiting for page to load; pending requests: ${result.pending.join(", ")}`,
+        );
+      }
+    } catch (error) {
+      try {
+        await import_internal.waitForPageStability(() => this.waiterSnapshot());
+      } catch (retryError) {
+        logger.warn(
+          `Failed to wait for page to load after retry (${String(error)}): ${String(retryError)}`,
+        );
+      }
+    }
+  }
+  async switchToTab(handles, tabIndex) {
+    import_alwaysly.always(handles[tabIndex]);
+    await this.driver.switchTo().window(handles[tabIndex]);
+  }
+  async initCdpConnection() {
+    try {
+      const capabilities = await this.driver.getCapabilities();
+      this.#cdpConnection = await SeleniumCdpConnection.connect(
+        capabilities,
+        WAITER_SCRIPT,
+      );
+    } catch (error) {
+      logger.debug(
+        `Could not connect to CDP to inject the waiter script: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      try {
+        await this.executeCdpCommand("Page.addScriptToEvaluateOnNewDocument", {
+          source: WAITER_SCRIPT,
+          runImmediately: true,
+        });
+      } catch (fallbackError) {
+        logger.debug(
+          `Could not install waiter script through Selenium: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}`,
+        );
+      }
+    }
+  }
+  async waiterSnapshot() {
+    let snapshot = await this.driver.executeScript(
+      `return ${import_internal.WAITER_SNAPSHOT_SCRIPT}`,
+    );
+    if (!snapshot) {
+      await this.driver.executeScript(WAITER_SCRIPT);
+      snapshot = await this.driver.executeScript(
+        `return ${import_internal.WAITER_SNAPSHOT_SCRIPT}`,
+      );
+    }
+    return snapshot;
+  }
+  async #autoswitchToNewTabAction(fn) {
+    if (!this.autoswitchToNewTab) {
+      return await fn();
+    }
+    return tracer.span("driver.internal.switch_to_new_tab", async () => {
+      const currentHandles = await this.driver.getAllWindowHandles();
+      const result = await fn();
+      const newHandles = await this.driver.getAllWindowHandles();
+      const newTabs = newHandles.filter((h) => !currentHandles.includes(h));
+      if (newTabs.length) {
+        const lastNewTab = newTabs[newTabs.length - 1];
+        import_alwaysly.always(lastNewTab);
+        if (lastNewTab !== (await this.driver.getWindowHandle())) {
+          await this.driver.switchTo().window(lastNewTab);
+          logger.debug(
+            `Auto-switching to new tab: ${await this.driver.getTitle()} (${await this.driver.getCurrentUrl()})`,
+          );
+        }
+      }
+      return result;
+    });
+  }
+  async switchToFrameChain(frameChain) {
+    await this.driver.switchTo().defaultContent();
+    for (const iframeBackendNodeId of frameChain) {
+      await this.switchToSingleFrame(iframeBackendNodeId);
+    }
+  }
+  async switchToSingleFrame(iframeBackendNodeId) {
+    await this.executeCdpCommand("DOM.enable", {});
+    await this.executeCdpCommand("DOM.getFlattenedDocument", {});
+    const { nodeIds } = await this.executeCdpCommand(
+      "DOM.pushNodesByBackendIdsToFrontend",
+      { backendNodeIds: [iframeBackendNodeId] },
+    );
+    const nodeId = nodeIds[0];
+    let iframeElement;
+    let set = false;
+    let failure;
+    try {
+      await this.executeCdpCommand("DOM.setAttributeValue", {
+        nodeId,
+        name: "data-alumnium-iframe-id",
+        value: String(iframeBackendNodeId),
+      });
+      set = true;
+      iframeElement = await this.driver.findElement(
+        import_selenium_webdriver.By.css(
+          `[data-alumnium-iframe-id='${iframeBackendNodeId}']`,
+        ),
+      );
+    } catch (error) {
+      failure = error;
+    } finally {
+      if (set) {
+        try {
+          await this.executeCdpCommand("DOM.removeAttribute", {
+            nodeId,
+            name: "data-alumnium-iframe-id",
+          });
+        } catch (error) {
+          failure ??= error;
+        }
+      }
+    }
+    if (failure) throw failure;
+    import_alwaysly.always(iframeElement);
+    await this.driver.switchTo().frame(iframeElement);
+    logger.debug(
+      `Switched to iframe with backendNodeId=${iframeBackendNodeId}`,
+    );
+  }
+  async buildFrameHierarchy(
+    frameInfo,
+    mainFrameId,
+    frameToIframeMap,
+    frameParentMap,
+    parentFrameId,
+  ) {
+    const frameId = frameInfo.frame.id;
+    if (frameId !== mainFrameId) {
+      await this.executeCdpCommand("DOM.enable", {});
+      try {
+        const ownerInfo = await this.executeCdpCommand("DOM.getFrameOwner", {
+          frameId,
+        });
+        frameToIframeMap.set(frameId, ownerInfo.backendNodeId);
+        logger.debug(
+          `Frame ${frameId.slice(0, 20)}... owned by iframe backendNodeId=${ownerInfo.backendNodeId}`,
+        );
+      } catch (error) {
+        logger.debug(
+          `Could not get frame owner for ${frameId.slice(0, 20)}...: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+      if (parentFrameId) {
+        frameParentMap.set(frameId, parentFrameId);
+      }
+    }
+    for (const child of frameInfo.childFrames || []) {
+      await this.buildFrameHierarchy(
+        child,
+        mainFrameId,
+        frameToIframeMap,
+        frameParentMap,
+        frameId,
+      );
+    }
+  }
+  getFrameChain(frameId, frameToIframeMap, frameParentMap) {
+    const chain = [];
+    let currentFrameId = frameId;
+    while (frameToIframeMap.has(currentFrameId)) {
+      const iframeBackendNodeId = frameToIframeMap.get(currentFrameId);
+      chain.unshift(iframeBackendNodeId);
+      if (frameParentMap.has(currentFrameId)) {
+        currentFrameId = frameParentMap.get(currentFrameId);
+      } else {
+        break;
+      }
+    }
+    return chain;
+  }
+  getAllFrameIds(frameInfo) {
+    const frameIds = [frameInfo.frame.id];
+    for (const child of frameInfo.childFrames || []) {
+      frameIds.push(...this.getAllFrameIds(child));
+    }
+    return frameIds;
+  }
+  async findShadowRoot(hostBackendNodeId) {
+    const { nodeIds: hostNodeIds } = await this.executeCdpCommand(
+      "DOM.pushNodesByBackendIdsToFrontend",
+      { backendNodeIds: [hostBackendNodeId] },
+    );
+    await this.executeCdpCommand("DOM.setAttributeValue", {
+      nodeId: hostNodeIds[0],
+      name: "data-alumnium-host",
+      value: String(hostBackendNodeId),
+    });
+    const hostElement = await this.driver.findElement(
+      import_selenium_webdriver.By.css(
+        `[data-alumnium-host='${hostBackendNodeId}']`,
+      ),
+    );
+    await this.executeCdpCommand("DOM.removeAttribute", {
+      nodeId: hostNodeIds[0],
+      name: "data-alumnium-host",
+    });
+    return hostElement.getShadowRoot();
+  }
+  async buildShadowHierarchy(domNodes, frameChainsByBackendId) {
+    const shadowNodes = [];
+    const processedNodes = new Set();
+    const nodeIdToBackendId = {};
+    const parentIdMap = {};
+    const shadowRootToHostBackendId = {};
+    for (const domNode of domNodes) {
+      nodeIdToBackendId[domNode.nodeId] = domNode.backendNodeId;
+      if (domNode.parentId !== undefined) {
+        parentIdMap[domNode.nodeId] = domNode.parentId;
+      }
+      if (domNode.shadowRoots) {
+        for (const sr of domNode.shadowRoots) {
+          shadowRootToHostBackendId[sr.nodeId] = domNode.backendNodeId;
+          parentIdMap[sr.nodeId] = domNode.nodeId;
+        }
+      }
+    }
+    this.#shadowChildToHostMap = {};
+    for (const domNode of domNodes) {
+      const nodeBackendId = domNode.backendNodeId;
+      let currentId = domNode.nodeId;
+      while (currentId !== undefined) {
+        if (currentId in shadowRootToHostBackendId) {
+          this.#shadowChildToHostMap[nodeBackendId] =
+            shadowRootToHostBackendId[currentId];
+          break;
+        }
+        currentId = parentIdMap[currentId];
+      }
+    }
+    for (const domNode of domNodes) {
+      if (domNode.shadowRoots && domNode.shadowRoots.length > 0) {
+        const frameChain = frameChainsByBackendId[domNode.backendNodeId];
+        try {
+          const axResponse = await this.executeCdpCommand(
+            "Accessibility.queryAXTree",
+            { nodeId: domNode.nodeId },
+          );
+          if (axResponse.nodes) {
+            for (const axNode of axResponse.nodes) {
+              if (processedNodes.has(axNode.nodeId)) continue;
+              processedNodes.add(axNode.nodeId);
+              axNode._is_shadow_dom = true;
+              if (frameChain) axNode._frame_chain = frameChain;
+              if (!axNode.backendDOMNodeId) {
+                const backendId =
+                  nodeIdToBackendId[Number.parseInt(axNode.nodeId)];
+                if (backendId !== undefined) {
+                  axNode.backendDOMNodeId = backendId;
+                }
+              }
+              shadowNodes.push(axNode);
+              if (axNode.childIds && Array.isArray(axNode.childIds)) {
+                for (const childId of axNode.childIds) {
+                  const childNodes = await this.getShadowChildNodes(
+                    String(childId),
+                    processedNodes,
+                    nodeIdToBackendId,
+                    frameChain,
+                  );
+                  shadowNodes.push(...childNodes);
+                }
+              }
+            }
+          }
+        } catch {}
+      }
+    }
+    return shadowNodes;
+  }
+  async getShadowChildNodes(
+    nodeId,
+    processedNodes,
+    nodeIdToBackendId,
+    frameChain,
+  ) {
+    const nodes = [];
+    if (processedNodes.has(nodeId)) return nodes;
+    processedNodes.add(nodeId);
+    try {
+      const response = await this.executeCdpCommand(
+        "Accessibility.queryAXTree",
+        { nodeId: Number.parseInt(nodeId) },
+      );
+      if (response.nodes) {
+        for (const node of response.nodes) {
+          node._is_shadow_dom = true;
+          if (frameChain) node._frame_chain = frameChain;
+          if (!node.backendDOMNodeId) {
+            const backendId = nodeIdToBackendId[Number.parseInt(node.nodeId)];
+            if (backendId !== undefined) {
+              node.backendDOMNodeId = backendId;
+            }
+          }
+          nodes.push(node);
+          if (node.childIds && Array.isArray(node.childIds)) {
+            for (const childId of node.childIds) {
+              const childNodes = await this.getShadowChildNodes(
+                String(childId),
+                processedNodes,
+                nodeIdToBackendId,
+                frameChain,
+              );
+              nodes.push(...childNodes);
+            }
+          }
+        }
+      }
+    } catch {}
+    return nodes;
+  }
+  async devDrillProbeTree(tree, rawId) {
+    let accessibilityElement;
+    try {
+      accessibilityElement = tree.elementById(rawId);
+    } catch (error) {
+      throw new import_internal.TreeDevDrillError("resolve", error);
+    }
+    const backendNodeId = accessibilityElement.backendNodeId;
+    if (backendNodeId === undefined) {
+      throw new import_internal.TreeDevDrillError(
+        "resolve",
+        new Error(`Element with raw_id=${rawId} has no backend node ID`),
+      );
+    }
+    const attribute = "data-alumnium-drill";
+    let nodeId;
+    let set = false;
+    let failure;
+    try {
+      const frameChain = accessibilityElement.frameChain;
+      if (frameChain?.length) await this.switchToFrameChain(frameChain);
+      else await this.driver.switchTo().defaultContent();
+      await this.executeCdpCommand("DOM.enable", {});
+      await this.executeCdpCommand("DOM.getFlattenedDocument", {});
+      const response = await this.executeCdpCommand(
+        "DOM.pushNodesByBackendIdsToFrontend",
+        { backendNodeIds: [backendNodeId] },
+      );
+      nodeId = response.nodeIds[0];
+      if (!nodeId) {
+        throw new import_internal.TreeDevDrillError(
+          "resolve",
+          new Error(`No frontend node for backend node ID ${backendNodeId}`),
+          backendNodeId,
+        );
+      }
+      try {
+        await this.executeCdpCommand("DOM.setAttributeValue", {
+          nodeId,
+          name: attribute,
+          value: crypto.randomUUID(),
+        });
+        set = true;
+      } catch (error) {
+        throw new import_internal.TreeDevDrillError(
+          "probe",
+          error,
+          backendNodeId,
+        );
+      }
+    } catch (error) {
+      failure =
+        error instanceof import_internal.TreeDevDrillError
+          ? error
+          : new import_internal.TreeDevDrillError(
+              "resolve",
+              error,
+              backendNodeId,
+            );
+    } finally {
+      if (set && nodeId) {
+        try {
+          await this.executeCdpCommand("DOM.removeAttribute", {
+            nodeId,
+            name: attribute,
+          });
+        } catch (error) {
+          failure ??= new import_internal.TreeDevDrillError(
+            "probe",
+            error,
+            backendNodeId,
+          );
+        }
+      }
+      try {
+        await this.driver.switchTo().defaultContent();
+      } catch (error) {
+        failure ??= new import_internal.TreeDevDrillError(
+          "resolve",
+          error,
+          backendNodeId,
+        );
+      }
+    }
+    if (failure) throw failure;
+    return backendNodeId;
+  }
+}
+__legacyDecorateClassTS(
+  [
+    span(
+      "driver.fetch_accessibility_tree",
+      import_internal.BaseDriver.spanAttrs,
+    ),
+  ],
+  SeleniumDriver.prototype,
+  "fetchAccessibilityTree",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.click", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "click",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.drag_slider", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "dragSlider",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.drag_and_drop", import_internal.BaseDriver.spanAttrs),
+    stateful,
+  ],
+  SeleniumDriver.prototype,
+  "dragAndDrop",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.hover", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "hover",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.press_key", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "pressKey",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.quit", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "quit",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.back", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "back",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.visit", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "visit",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.scroll_to", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "scrollTo",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.screenshot", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "screenshot",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.title", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "title",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.type", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "type",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.upload", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "upload",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.url", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "url",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.app", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "app",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.find_element", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "findElement",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.execute_script", import_internal.BaseDriver.spanAttrs),
+    stateful,
+  ],
+  SeleniumDriver.prototype,
+  "executeScript",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.print_to_pdf", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "printToPdf",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.switch_to_next_tab", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "switchToNextTab",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.switch_to_previous_tab", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "switchToPreviousTab",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.wait", import_internal.BaseDriver.spanAttrs), stateful],
+  SeleniumDriver.prototype,
+  "wait",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.wait_for_selector", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "waitForSelector",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.internal.cdp_command", (cmd) => ({
+      "driver.kind": "selenium",
+      "driver.platform": "chromium",
+      "driver.internal.cdp_command.name": cmd,
+    })),
+  ],
+  SeleniumDriver.prototype,
+  "executeCdpCommand",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.wait_for_page_to_load", import_internal.BaseDriver.spanAttrs)],
+  SeleniumDriver.prototype,
+  "waitForPageToLoad",
+  null,
+);
+__legacyDecorateClassTS(
+  [stateful("switchToTab")],
+  SeleniumDriver.prototype,
+  "switchToTab",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.internal.switch_to_frame_chain")],
+  SeleniumDriver.prototype,
+  "switchToFrameChain",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.internal.switch_to_single_frame")],
+  SeleniumDriver.prototype,
+  "switchToSingleFrame",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.internal.build_frame_hierarchy")],
+  SeleniumDriver.prototype,
+  "buildFrameHierarchy",
+  null,
+);
+
+// selenium/src/Alumni.ts
+class Alumni extends import_core.Alumni {
+  constructor(driver, options = {}) {
+    super(new SeleniumDriver(driver), options);
+  }
+  static accepts(driver) {
+    return driver instanceof import_selenium_webdriver2.WebDriver;
+  }
+}
+
+//# debugId=556752DC5E7931C764756E2164756E21
+//# sourceMappingURL=index.cjs.map