@alumnium/playwright 0.0.0-stage → 0.24.0-alpha.2

package/src/index.cjs

@@ -0,0 +1,1005 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+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);
+};
+
+// playwright/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  Alumni: () => Alumni,
+  PlaywrightDriver: () => PlaywrightDriver,
+});
+module.exports = __toCommonJS(exports_src);
+
+// playwright/src/Alumni.ts
+var import_core = require("@alumnium/core");
+
+// playwright/src/drivers/PlaywrightDriver.ts
+var import_alwaysly = require("alwaysly");
+var import_internal = require("@alumnium/core/internal");
+var { tracer, logger } = import_internal.Telemetry.get(
+  "packages/typescript/playwright/src/drivers/PlaywrightDriver.ts",
+);
+var { span } = tracer.dec();
+var stateful = import_internal.BaseDriver.stateful;
+var CONTEXT_WAS_DESTROYED_ERROR = "Execution context was destroyed";
+var NEW_TAB_DELAY = 200;
+var WAITER_SCRIPT = import_internal.waiterScriptSource;
+var RETRY_OPTIONS = {
+  maxAttempts: 2,
+  backOff: 500,
+  doRetry: (error) => error.message.includes(CONTEXT_WAS_DESTROYED_ERROR),
+};
+
+class PlaywrightDriver extends import_internal.BaseDriver {
+  client;
+  cdpReady;
+  #pageSessions = new Map();
+  #pageOopifFrameIds = new WeakMap();
+  cdpGeneration = 0;
+  page;
+  trackedPages = new Set();
+  #previousPage;
+  newTabAction;
+  oopifFrameIds = new Map();
+  oopifFrames = new Set();
+  kind = "playwright";
+  platform = "chromium";
+  supportedTools = new Set([
+    import_internal.ClickTool,
+    import_internal.DragAndDropTool,
+    import_internal.HoverTool,
+    import_internal.PressKeyTool,
+    import_internal.TypeTool,
+    import_internal.UploadTool,
+  ]);
+  newTabTimeout = 1e4;
+  autoswitchToNewTab = true;
+  fullPageScreenshot = import_internal.Env.ALUMNIUM_FULL_PAGE_SCREENSHOT;
+  constructor(page) {
+    super();
+    this.page = page;
+    this.cdpReady = Promise.resolve(
+      this.page.context().addInitScript({ content: WAITER_SCRIPT }),
+    ).then(() => this.initCDPSession());
+    this.page.context().on("page", (opened) => this.onPageOpened(opened));
+    this.trackPage(page);
+  }
+  trackPage(page) {
+    if (this.trackedPages.has(page)) return;
+    this.trackedPages.add(page);
+    page.on("close", () => this.onPageClose(page));
+  }
+  onPageOpened(page) {
+    logger.debug(`New tab opened: ${page.url()}`);
+    this.trackPage(page);
+    this.newTabAction?.pages.push(page);
+    this.#initPageSession(page).catch((error) => {
+      logger.debug(
+        `Could not initialize new tab CDP session: ${String(error)}`,
+      );
+    });
+  }
+  onPageClose(page) {
+    logger.debug(`Page closed: ${page.url()}`);
+    this.trackedPages.delete(page);
+    const session = this.#pageSessions.get(page);
+    this.#pageSessions.delete(page);
+    this.#pageOopifFrameIds.delete(page);
+    session
+      ?.then((client) => client.detach())
+      .catch(() => {
+        return;
+      });
+    if (this.newTabAction)
+      this.newTabAction.pages = this.newTabAction.pages.filter(
+        (opened) => opened !== page,
+      );
+    if (page !== this.page) return;
+    const previous = this.#previousPage;
+    if (!previous || previous.isClosed()) return;
+    this.page = previous;
+    this.#previousPage = undefined;
+    this.resetAccessibilityTree();
+    this.cdpReady = this.initCDPSession().catch((error) => {
+      logger.info(`Failed to initialize CDP session: ${String(error)}`);
+    });
+  }
+  async initCDPSession() {
+    const generation = ++this.cdpGeneration;
+    const page = this.page;
+    this.oopifFrames.clear();
+    const client = await this.#initPageSession(page);
+    if (generation !== this.cdpGeneration || page !== this.page) {
+      return;
+    }
+    this.client = client;
+    this.oopifFrameIds = this.#pageOopifFrameIds.get(page);
+  }
+  #initPageSession(page) {
+    let session = this.#pageSessions.get(page);
+    if (!session) {
+      session = this.#createPageSession(page).catch((error) => {
+        this.#pageSessions.delete(page);
+        throw error;
+      });
+      this.#pageSessions.set(page, session);
+    }
+    return session;
+  }
+  async #createPageSession(page) {
+    const frameIds = new Map();
+    this.#pageOopifFrameIds.set(page, frameIds);
+    const session = await page.context().newCDPSession(page);
+    try {
+      await this.configurePageSession(session, page);
+      await this.enableTargetAutoAttach(session, frameIds);
+      return session;
+    } catch (error) {
+      await session.detach().catch(() => {
+        return;
+      });
+      throw error;
+    }
+  }
+  async configurePageSession(session, page) {
+    await session.send("Page.enable");
+    await session.send("Page.addScriptToEvaluateOnNewDocument", {
+      source: WAITER_SCRIPT,
+      runImmediately: true,
+    });
+    session.on("Page.windowOpen", () => {
+      if (page === this.page && this.newTabAction)
+        this.newTabAction.announced = true;
+    });
+  }
+  async enableTargetAutoAttach(client, frameIds) {
+    try {
+      client.on("Target.attachedToTarget", (event) => {
+        if (event.targetInfo.type === "iframe") {
+          logger.debug(
+            `OOPIF attached: frameId=${event.targetInfo.targetId} url=${event.targetInfo.url || "(empty)"}`,
+          );
+          frameIds.set(event.targetInfo.targetId, event.targetInfo.url);
+        }
+      });
+      client.on("Target.detachedFromTarget", (event) => {
+        if (event.targetId && frameIds.has(event.targetId)) {
+          logger.debug(`OOPIF detached: frameId=${event.targetId}`);
+          frameIds.delete(event.targetId);
+        }
+      });
+      client.on("Page.frameNavigated", (event) => {
+        if (frameIds.has(event.frame.id)) {
+          logger.debug(
+            `OOPIF navigated: frameId=${event.frame.id} url=${event.frame.url}`,
+          );
+          frameIds.set(event.frame.id, event.frame.url);
+        }
+      });
+      await client.send("Target.setAutoAttach", {
+        autoAttach: true,
+        waitForDebuggerOnStart: false,
+        flatten: true,
+      });
+      logger.debug("Enabled Target.setAutoAttach for OOPIF support");
+    } catch (error) {
+      logger.debug(
+        `Could not enable Target.setAutoAttach: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+  async fetchAccessibilityTree() {
+    await this.cdpReady;
+    await this.waitForPageToLoad();
+    const frameTree = await this.client.send("Page.getFrameTree");
+    const frameIds = this.getAllFrameIds(frameTree.frameTree);
+    const mainFrameId = frameTree.frameTree.frame.id;
+    logger.debug(
+      `Found ${frameIds.length} same-process frames, ${this.oopifFrameIds.size} OOPIFs`,
+    );
+    const frameToIframeMap = await this.buildFrameOwnerMap(
+      frameTree.frameTree,
+      mainFrameId,
+    );
+    const frameIdToPlaywrightFrame =
+      await this.buildPlaywrightFrameMap(frameTree);
+    const allNodes = [];
+    let frameIndex = 0;
+    for (const frameId of frameIds) {
+      const playwrightFrame =
+        frameIdToPlaywrightFrame.get(frameId) ?? this.page.mainFrame();
+      const nodes = await this.getFrameNodes(frameId, playwrightFrame);
+      this.mergeFrameNodes(
+        nodes,
+        frameId,
+        frameToIframeMap,
+        playwrightFrame,
+        frameIndex++,
+        allNodes,
+      );
+    }
+    for (const oopifFrameId of this.oopifFrameIds.keys()) {
+      const playwrightFrame = frameIdToPlaywrightFrame.get(oopifFrameId);
+      if (!playwrightFrame) continue;
+      const nodes = await this.getOopifNodes(oopifFrameId, playwrightFrame);
+      this.mergeFrameNodes(
+        nodes,
+        oopifFrameId,
+        frameToIframeMap,
+        playwrightFrame,
+        frameIndex++,
+        allNodes,
+      );
+    }
+    return new import_internal.ChromiumAccessibilityTree({ nodes: allNodes });
+  }
+  async click(id) {
+    const element = await this.findElement(id);
+    const tagName = await element.evaluate((el) => el.tagName);
+    if (tagName?.toLowerCase() === "option") {
+      const value = await element.evaluate((el) => el.value);
+      await this.autoswitchToNewTabAction(async () => {
+        await element.locator("xpath=ancestor::select").selectOption(value);
+      });
+    } else {
+      await this.autoswitchToNewTabAction(async () => {
+        await this.#scrollElementIfNeeded(element);
+        await element.click({ force: true });
+      });
+    }
+  }
+  async dragSlider(id, value) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIfNeeded(element);
+    await element.fill(String(value));
+  }
+  async dragAndDrop(fromId, toId) {
+    const fromElement = await this.findElement(fromId);
+    const toElement = await this.findElement(toId);
+    await this.#scrollElementIfNeeded(fromElement);
+    await fromElement.dragTo(toElement);
+  }
+  async hover(id) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIntoCenter(element);
+    await element.hover();
+  }
+  async pressKey(key) {
+    const keyMap = {
+      Backspace: "Backspace",
+      Enter: "Enter",
+      Escape: "Escape",
+      Space: "Space",
+      Tab: "Tab",
+      ArrowDown: "ArrowDown",
+      ArrowUp: "ArrowUp",
+      ArrowLeft: "ArrowLeft",
+      ArrowRight: "ArrowRight",
+    };
+    await this.autoswitchToNewTabAction(() =>
+      this.page.keyboard.press(keyMap[key]),
+    );
+  }
+  async quit() {
+    await this.cdpReady;
+    await this.page.close();
+  }
+  async back() {
+    await this.page.goBack();
+  }
+  async visit(url) {
+    await this.checkNavigationPolicy(url);
+    await this.page.goto(url);
+  }
+  async scrollTo(id) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIntoCenter(element);
+  }
+  async screenshot() {
+    return import_internal.retry(RETRY_OPTIONS, async () => {
+      const buffer = await this.page.screenshot({
+        fullPage: this.fullPageScreenshot,
+      });
+      return buffer.toString("base64");
+    });
+  }
+  async title() {
+    return import_internal.retry(RETRY_OPTIONS, () => this.page.title());
+  }
+  async type(id, text) {
+    const element = await this.findElement(id);
+    await this.#scrollElementIfNeeded(element);
+    await element.fill(text);
+  }
+  async upload(id, paths) {
+    const element = await this.findElement(id);
+    const [fileChooser] = await Promise.all([
+      this.page.waitForEvent("filechooser", { timeout: 5000 }),
+      element.click({ force: true }),
+    ]);
+    await fileChooser.setFiles(paths);
+  }
+  url() {
+    return import_internal.retry(RETRY_OPTIONS, async () => this.page.url());
+  }
+  async app() {
+    return import_internal.AppId.parse(this.page.url());
+  }
+  async findElement(id) {
+    const tree = await this.getAccessibilityTree();
+    const accessibilityElement = tree.elementById(id);
+    const frame = accessibilityElement.frame || this.page.mainFrame();
+    const backendNodeId = accessibilityElement.backendNodeId;
+    const isOopif = frame !== this.page.mainFrame() && this.isOopifFrame(frame);
+    const session = isOopif
+      ? await this.page.context().newCDPSession(frame)
+      : this.client;
+    try {
+      await session.send("DOM.enable");
+      await session.send("DOM.getFlattenedDocument");
+      const nodeIds = await session.send(
+        "DOM.pushNodesByBackendIdsToFrontend",
+        {
+          backendNodeIds: [backendNodeId],
+        },
+      );
+      const nodeId = nodeIds.nodeIds[0];
+      import_alwaysly.ensure(nodeId);
+      await session.send("DOM.setAttributeValue", {
+        nodeId,
+        name: "data-alumnium-id",
+        value: String(backendNodeId),
+      });
+    } finally {
+      if (isOopif) await session.detach();
+    }
+    return frame.locator(`css=[data-alumnium-id='${backendNodeId}']`);
+  }
+  async #scrollElementIfNeeded(element) {
+    try {
+      logger.debug(`Attempting to hover over element`);
+      await element.hover({ trial: true, timeout: 200 });
+    } catch (error) {
+      logger.debug(error instanceof Error ? error.message : String(error));
+      logger.debug(`Hover failed, scrolling into view instead`);
+      await this.#scrollElementIntoCenter(element);
+    }
+  }
+  async #scrollElementIntoCenter(element) {
+    await element.evaluate((el) => {
+      el.scrollIntoView({ block: "center" });
+    });
+  }
+  isOopifFrame(frame) {
+    return this.oopifFrames.has(frame);
+  }
+  async buildFrameOwnerMap(frameInfo, mainFrameId) {
+    const map = new Map();
+    await this.client.send("DOM.enable");
+    const walk = async (fi) => {
+      if (fi.frame.id !== mainFrameId) {
+        try {
+          const owner = await this.client.send("DOM.getFrameOwner", {
+            frameId: fi.frame.id,
+          });
+          map.set(fi.frame.id, owner.backendNodeId);
+          logger.debug(
+            `Frame ${fi.frame.id.slice(0, 20)}... owned by iframe backendNodeId=${owner.backendNodeId}`,
+          );
+        } catch (error) {
+          logger.debug(
+            `Could not get frame owner for ${fi.frame.id.slice(0, 20)}...: ${error instanceof Error ? error.message : String(error)}`,
+          );
+        }
+      }
+      for (const child of fi.childFrames || []) await walk(child);
+    };
+    await walk(frameInfo);
+    for (const oopifFrameId of this.oopifFrameIds.keys()) {
+      try {
+        const owner = await this.client.send("DOM.getFrameOwner", {
+          frameId: oopifFrameId,
+        });
+        map.set(oopifFrameId, owner.backendNodeId);
+        logger.debug(
+          `OOPIF ${oopifFrameId.slice(0, 20)}... owned by iframe backendNodeId=${owner.backendNodeId}`,
+        );
+      } catch (error) {
+        logger.debug(
+          `Could not get frame owner for OOPIF ${oopifFrameId.slice(0, 20)}...: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      }
+    }
+    return map;
+  }
+  async buildPlaywrightFrameMap(frameTree) {
+    const map = new Map();
+    this.mapFrameTree(frameTree.frameTree, this.page.mainFrame(), map);
+    const unmappedOopifs = new Set(
+      [...this.oopifFrameIds.keys()].filter((id) => !map.has(id)),
+    );
+    if (unmappedOopifs.size > 0) {
+      for (const playwrightFrame of this.page.frames()) {
+        if (playwrightFrame === this.page.mainFrame()) continue;
+        if ([...map.values()].includes(playwrightFrame)) continue;
+        let frameSession;
+        try {
+          frameSession = await this.page
+            .context()
+            .newCDPSession(playwrightFrame);
+          const ft = await frameSession.send("Page.getFrameTree");
+          const rootFrameId = ft.frameTree.frame.id;
+          if (unmappedOopifs.has(rootFrameId)) {
+            map.set(rootFrameId, playwrightFrame);
+            this.oopifFrames.add(playwrightFrame);
+            unmappedOopifs.delete(rootFrameId);
+            logger.debug(
+              `Mapped OOPIF ${rootFrameId.slice(0, 20)}... to Playwright frame`,
+            );
+          }
+        } catch {
+        } finally {
+          await frameSession?.detach().catch(() => {
+            return;
+          });
+        }
+      }
+    }
+    return map;
+  }
+  mapFrameTree(frameInfo, playwrightFrame, map) {
+    map.set(frameInfo.frame.id, playwrightFrame);
+    const unmatched = [...(frameInfo.childFrames || [])];
+    const pending = playwrightFrame.childFrames();
+    const take = (matches) => {
+      for (const frame of [...pending]) {
+        const index = unmatched.findIndex((child) => matches(child, frame));
+        if (index === -1) continue;
+        const [child] = unmatched.splice(index, 1);
+        pending.splice(pending.indexOf(frame), 1);
+        this.mapFrameTree(child, frame, map);
+      }
+    };
+    take(
+      (child, frame) =>
+        child.frame.url === frame.url() &&
+        (child.frame.name || "") === frame.name(),
+    );
+    take((child, frame) => child.frame.url === frame.url());
+  }
+  mergeFrameNodes(
+    nodes,
+    frameId,
+    frameToIframeMap,
+    playwrightFrame,
+    frameIndex,
+    allNodes,
+  ) {
+    const prefix = `f${frameIndex}:`;
+    for (const node of nodes) {
+      node.nodeId = prefix + node.nodeId;
+      if (node.parentId != null) node.parentId = prefix + node.parentId;
+      if (node.childIds) node.childIds = node.childIds.map((id) => prefix + id);
+      node._frame = playwrightFrame;
+      if (node.parentId === undefined && frameToIframeMap.has(frameId)) {
+        node._parent_iframe_backend_node_id = frameToIframeMap.get(frameId);
+      }
+      allNodes.push(node);
+    }
+  }
+  async executeScript(script) {
+    logger.debug("Executing script: {script}", { script });
+    await this.page.evaluate(script);
+  }
+  async printToPdf(filepath) {
+    await this.page.pdf({ path: filepath });
+  }
+  async switchToNextTab() {
+    await this.page.waitForTimeout(100).catch(() => {
+      return;
+    });
+    const pages = this.openTabs();
+    if (pages.length <= 1) {
+      return;
+    }
+    const currentIndex = pages.indexOf(this.page);
+    const nextIndex = (currentIndex + 1) % pages.length;
+    await this.switchToTab(pages[nextIndex]);
+  }
+  async switchToPreviousTab() {
+    await this.page.waitForTimeout(100).catch(() => {
+      return;
+    });
+    const pages = this.openTabs();
+    if (pages.length <= 1) {
+      return;
+    }
+    const currentIndex = pages.indexOf(this.page);
+    const prevIndex = (currentIndex - 1 + pages.length) % pages.length;
+    await this.switchToTab(pages[prevIndex]);
+  }
+  async switchToTab(page) {
+    if (!page) return;
+    await this.activatePage(page);
+    await this.page.waitForLoadState();
+  }
+  async activatePage(page) {
+    await this.cdpReady;
+    if (page !== this.page) this.#previousPage = this.page;
+    this.page = page;
+    this.trackPage(page);
+    this.resetAccessibilityTree();
+    this.cdpReady = this.initCDPSession();
+    await this.cdpReady;
+  }
+  openTabs() {
+    return this.page
+      .context()
+      .pages()
+      .filter((page) => !page.isClosed());
+  }
+  async wait(seconds) {
+    const clampedSeconds = Math.max(1, Math.min(30, seconds));
+    logger.debug("Waiting for {clampedSeconds} seconds", {
+      seconds: clampedSeconds,
+    });
+    await new Promise((resolve) => setTimeout(resolve, clampedSeconds * 1000));
+  }
+  async waitForSelector(selector, timeout) {
+    const timeoutMs = (timeout ?? 10) * 1000;
+    logger.debug(
+      "Waiting for selector {selector} with timeout {timeoutMs} ms",
+      { selector, timeoutMs },
+    );
+    await this.page.waitForSelector(selector, {
+      state: "visible",
+      timeout: timeoutMs,
+    });
+  }
+  async grantPermissions(permissions) {
+    await this.page.context().grantPermissions(permissions);
+  }
+  async checkNavigationPolicy(url) {
+    const currentUrl = url ?? (await this.url());
+    this.navigationPolicy.check(currentUrl);
+  }
+  async waitForPageToLoad() {
+    return import_internal.retry(RETRY_OPTIONS, async () => {
+      await this.cdpReady;
+      logger.debug("Waiting for page to finish loading:");
+      const result = await import_internal.waitForPageStability(() =>
+        this.page.evaluate(import_internal.WAITER_SNAPSHOT_SCRIPT),
+      );
+      if (!result.loaded) {
+        logger.debug(
+          `  <- Timed out waiting for page to load; pending requests: ${result.pending.join(", ")}`,
+        );
+      } else {
+        logger.debug("  <- Page finished loading");
+      }
+    });
+  }
+  async autoswitchToNewTabAction(action) {
+    if (!this.autoswitchToNewTab) {
+      await action();
+      return;
+    }
+    await this.cdpReady;
+    const context = this.page.context();
+    const newTabAction = { announced: false, pages: [] };
+    this.newTabAction = newTabAction;
+    try {
+      await action();
+      if (!newTabAction.pages.length)
+        await new Promise((resolve) => setTimeout(resolve, NEW_TAB_DELAY));
+      let newPage = newTabAction.pages.findLast((page) => !page.isClosed());
+      if (!newPage && newTabAction.announced) {
+        newPage = await this.waitForAnnouncedTab(context, newTabAction);
+      }
+      if (!newPage) return;
+      logger.debug(`Auto-switching to new tab: ${newPage.url()}`);
+      await this.activatePage(newPage);
+    } finally {
+      if (this.newTabAction === newTabAction) this.newTabAction = undefined;
+    }
+  }
+  async waitForAnnouncedTab(context, action) {
+    const deadline = Date.now() + this.newTabTimeout;
+    while (Date.now() < deadline) {
+      const page = await context
+        .waitForEvent("page", {
+          timeout: Math.max(1, Math.min(100, deadline - Date.now())),
+        })
+        .catch(() => {
+          return;
+        });
+      if (page) return page;
+      const captured = action.pages.findLast(
+        (candidate) => !candidate.isClosed(),
+      );
+      if (captured) return captured;
+    }
+  }
+  getAllFrameIds(frameInfo) {
+    const frameIds = [frameInfo.frame.id];
+    for (const child of frameInfo.childFrames || []) {
+      frameIds.push(...this.getAllFrameIds(child));
+    }
+    return frameIds;
+  }
+  async getFrameNodes(frameId, _playwrightFrame) {
+    let nodes;
+    try {
+      const response = await this.client.send("Accessibility.getFullAXTree", {
+        frameId,
+      });
+      nodes = response.nodes || [];
+      logger.debug(
+        `  -> Frame ${frameId.slice(0, 20)}...: ${nodes.length} nodes`,
+      );
+    } catch (error) {
+      logger.debug(
+        `  -> Frame ${frameId.slice(0, 20)}...: failed (${error instanceof Error ? error.message : String(error)})`,
+      );
+      return [];
+    }
+    return nodes;
+  }
+  async getOopifNodes(frameId, playwrightFrame) {
+    let frameSession;
+    try {
+      frameSession = await this.page.context().newCDPSession(playwrightFrame);
+      const response = await frameSession.send(
+        "Accessibility.getFullAXTree",
+        {},
+      );
+      const nodes = response.nodes || [];
+      logger.debug(
+        `  -> OOPIF ${frameId.slice(0, 20)}...: got ${nodes.length} nodes`,
+      );
+      return nodes;
+    } catch (oopifError) {
+      logger.debug(
+        `  -> OOPIF ${frameId.slice(0, 20)}...: failed (${oopifError instanceof Error ? oopifError.message : String(oopifError)})`,
+      );
+      return [];
+    } finally {
+      await frameSession?.detach().catch(() => {
+        return;
+      });
+    }
+  }
+  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 frame = accessibilityElement.frame ?? this.page.mainFrame();
+    const isOopif = frame !== this.page.mainFrame() && this.isOopifFrame(frame);
+    let session;
+    try {
+      session = isOopif
+        ? await this.page.context().newCDPSession(frame)
+        : this.client;
+    } catch (error) {
+      throw new import_internal.TreeDevDrillError(
+        "resolve",
+        error,
+        backendNodeId,
+      );
+    }
+    const attribute = "data-alumnium-drill";
+    let nodeId;
+    let set = false;
+    let failure;
+    try {
+      try {
+        await session.send("DOM.enable");
+        await session.send("DOM.getFlattenedDocument");
+        const response = await session.send(
+          "DOM.pushNodesByBackendIdsToFrontend",
+          { backendNodeIds: [backendNodeId] },
+        );
+        nodeId = response.nodeIds[0];
+        if (!nodeId) {
+          throw new Error(
+            `No frontend node for backend node ID ${backendNodeId}`,
+          );
+        }
+      } catch (error) {
+        throw new import_internal.TreeDevDrillError(
+          "resolve",
+          error,
+          backendNodeId,
+        );
+      }
+      try {
+        await session.send("DOM.setAttributeValue", {
+          nodeId,
+          name: attribute,
+          value: crypto.randomUUID(),
+        });
+        set = true;
+      } catch (error) {
+        throw new import_internal.TreeDevDrillError(
+          "probe",
+          error,
+          backendNodeId,
+        );
+      }
+    } catch (error) {
+      failure = error;
+    } finally {
+      if (set && nodeId) {
+        try {
+          await session.send("DOM.removeAttribute", {
+            nodeId,
+            name: attribute,
+          });
+        } catch (error) {
+          failure ??= new import_internal.TreeDevDrillError(
+            "probe",
+            error,
+            backendNodeId,
+          );
+        }
+      }
+      if (isOopif) {
+        try {
+          await session.detach();
+        } 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,
+    ),
+  ],
+  PlaywrightDriver.prototype,
+  "fetchAccessibilityTree",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.click", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "click",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.drag_slider", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "dragSlider",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.drag_and_drop", import_internal.BaseDriver.spanAttrs),
+    stateful,
+  ],
+  PlaywrightDriver.prototype,
+  "dragAndDrop",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.hover", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "hover",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.press_key", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "pressKey",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.quit", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "quit",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.back", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "back",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.visit", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "visit",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.scroll_to", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "scrollTo",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.screenshot", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "screenshot",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.title", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "title",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.type", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "type",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.upload", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "upload",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.url", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "url",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.app", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "app",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.find_element", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "findElement",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.execute_script", import_internal.BaseDriver.spanAttrs),
+    stateful,
+  ],
+  PlaywrightDriver.prototype,
+  "executeScript",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.print_to_pdf", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "printToPdf",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.switch_to_next_tab", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "switchToNextTab",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.switch_to_previous_tab", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "switchToPreviousTab",
+  null,
+);
+__legacyDecorateClassTS(
+  [stateful("switchToTab")],
+  PlaywrightDriver.prototype,
+  "switchToTab",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.wait", import_internal.BaseDriver.spanAttrs), stateful],
+  PlaywrightDriver.prototype,
+  "wait",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.wait_for_selector", import_internal.BaseDriver.spanAttrs),
+    stateful,
+  ],
+  PlaywrightDriver.prototype,
+  "waitForSelector",
+  null,
+);
+__legacyDecorateClassTS(
+  [stateful],
+  PlaywrightDriver.prototype,
+  "grantPermissions",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.wait_for_page_to_load", import_internal.BaseDriver.spanAttrs)],
+  PlaywrightDriver.prototype,
+  "waitForPageToLoad",
+  null,
+);
+
+// playwright/src/Alumni.ts
+class Alumni extends import_core.Alumni {
+  constructor(driver, options = {}) {
+    super(new PlaywrightDriver(driver), options);
+  }
+  static accepts(driver) {
+    return !!driver && typeof driver.context === "function";
+  }
+}
+
+//# debugId=C00EE79AFCA7353864756E2164756E21
+//# sourceMappingURL=index.cjs.map