@kritchoff/agent-browser 1.0.5 → 1.0.7

package/dist/daemon.js

@@ -30,15 +30,15 @@ function parseRef(arg) {
 }
 
 // src/taxtree.ts
-async function getDualModeSnapshot(page2, options = {}) {
-  const session = await page2.context().newCDPSession(page2);
+async function getDualModeSnapshot(page, options = {}) {
+  const session = await page.context().newCDPSession(page);
   let nodes = [];
   let isDualMode = false;
   try {
     const result = await session.send("Accessibility.getDualModeAXTree");
     nodes = result.nodes;
     isDualMode = true;
-  } catch (e) {
+  } catch {
     try {
       const result = await session.send("Accessibility.getFullAXTree");
       nodes = result.nodes;
@@ -315,8 +315,8 @@ var BrowserManager = class {
    * Get enhanced snapshot with refs and cache the ref map
    */
   async getSnapshot(options) {
-    const page2 = this.getPage();
-    const snapshot = await getDualModeSnapshot(page2, options);
+    const page = this.getPage();
+    const snapshot = await getDualModeSnapshot(page, options);
     this.refMap = snapshot.refs;
     this.lastSnapshot = snapshot.tree;
     return snapshot;
@@ -336,20 +336,20 @@ var BrowserManager = class {
     if (!ref) return null;
     const refData = this.refMap[ref];
     if (!refData) return null;
-    const page2 = this.getPage();
+    const page = this.getPage();
     if (refData.role === "clickable" || refData.role === "focusable") {
-      return page2.locator(refData.selector);
+      return page.locator(refData.selector);
     }
-    let locator2;
+    let locator;
     if (refData.name) {
-      locator2 = page2.getByRole(refData.role, { name: refData.name, exact: true });
+      locator = page.getByRole(refData.role, { name: refData.name, exact: true });
     } else {
-      locator2 = page2.getByRole(refData.role);
+      locator = page.getByRole(refData.role);
     }
     if (refData.nth !== void 0) {
-      locator2 = locator2.nth(refData.nth);
+      locator = locator.nth(refData.nth);
     }
-    return locator2;
+    return locator;
   }
   /**
    * Check if a selector looks like a ref
@@ -369,10 +369,10 @@ var BrowserManager = class {
    * Get locator - supports both refs and regular selectors
    */
   getLocator(selectorOrRef) {
-    const locator2 = this.getLocatorFromRef(selectorOrRef);
-    if (locator2) return locator2;
-    const page2 = this.getPage();
-    return page2.locator(selectorOrRef);
+    const locator = this.getLocatorFromRef(selectorOrRef);
+    if (locator) return locator;
+    const page = this.getPage();
+    return page.locator(selectorOrRef);
   }
   /**
    * Get the current active page, throws if not launched
@@ -396,9 +396,9 @@ var BrowserManager = class {
    * Switch to a frame by selector, name, or URL
    */
   async switchToFrame(options) {
-    const page2 = this.getPage();
+    const page = this.getPage();
     if (options.selector) {
-      const frameElement = await page2.$(options.selector);
+      const frameElement = await page.$(options.selector);
       if (!frameElement) {
         throw new Error(`Frame not found: ${options.selector}`);
       }
@@ -408,13 +408,13 @@ var BrowserManager = class {
       }
       this.activeFrame = frame;
     } else if (options.name) {
-      const frame = page2.frame({ name: options.name });
+      const frame = page.frame({ name: options.name });
       if (!frame) {
         throw new Error(`Frame not found with name: ${options.name}`);
       }
       this.activeFrame = frame;
     } else if (options.url) {
-      const frame = page2.frame({ url: options.url });
+      const frame = page.frame({ url: options.url });
       if (!frame) {
         throw new Error(`Frame not found with URL: ${options.url}`);
       }
@@ -431,9 +431,9 @@ var BrowserManager = class {
    * Set up dialog handler
    */
   setDialogHandler(response, promptText) {
-    const page2 = this.getPage();
+    const page = this.getPage();
     if (this.dialogHandler) {
-      page2.removeListener("dialog", this.dialogHandler);
+      page.removeListener("dialog", this.dialogHandler);
     }
     this.dialogHandler = async (dialog) => {
       if (response === "accept") {
@@ -442,15 +442,15 @@ var BrowserManager = class {
         await dialog.dismiss();
       }
     };
-    page2.on("dialog", this.dialogHandler);
+    page.on("dialog", this.dialogHandler);
   }
   /**
    * Clear dialog handler
    */
   clearDialogHandler() {
     if (this.dialogHandler) {
-      const page2 = this.getPage();
-      page2.removeListener("dialog", this.dialogHandler);
+      const page = this.getPage();
+      page.removeListener("dialog", this.dialogHandler);
       this.dialogHandler = null;
     }
   }
@@ -458,8 +458,8 @@ var BrowserManager = class {
    * Start tracking requests
    */
   startRequestTracking() {
-    const page2 = this.getPage();
-    page2.on("request", (request) => {
+    const page = this.getPage();
+    page.on("request", (request) => {
       this.trackedRequests.push({
         url: request.url(),
         method: request.method(),
@@ -488,7 +488,7 @@ var BrowserManager = class {
    * Add a route to intercept requests
    */
   async addRoute(url, options) {
-    const page2 = this.getPage();
+    const page = this.getPage();
     const handler = async (route) => {
       if (options.abort) {
         await route.abort();
@@ -504,22 +504,22 @@ var BrowserManager = class {
       }
     };
     this.routes.set(url, handler);
-    await page2.route(url, handler);
+    await page.route(url, handler);
   }
   /**
    * Remove a route
    */
   async removeRoute(url) {
-    const page2 = this.getPage();
+    const page = this.getPage();
     if (url) {
       const handler = this.routes.get(url);
       if (handler) {
-        await page2.unroute(url, handler);
+        await page.unroute(url, handler);
         this.routes.delete(url);
       }
     } else {
       for (const [routeUrl, handler] of this.routes) {
-        await page2.unroute(routeUrl, handler);
+        await page.unroute(routeUrl, handler);
       }
       this.routes.clear();
     }
@@ -550,8 +550,8 @@ var BrowserManager = class {
    * Set viewport
    */
   async setViewport(width, height) {
-    const page2 = this.getPage();
-    await page2.setViewportSize({ width, height });
+    const page = this.getPage();
+    await page.setViewportSize({ width, height });
   }
   /**
    * Set device scale factor (devicePixelRatio) via CDP
@@ -596,8 +596,8 @@ var BrowserManager = class {
    * Start console message tracking
    */
   startConsoleTracking() {
-    const page2 = this.getPage();
-    page2.on("console", (msg) => {
+    const page = this.getPage();
+    page.on("console", (msg) => {
       this.consoleMessages.push({
         type: msg.type(),
         text: msg.text(),
@@ -621,8 +621,8 @@ var BrowserManager = class {
    * Start error tracking
    */
   startErrorTracking() {
-    const page2 = this.getPage();
-    page2.on("pageerror", (error) => {
+    const page = this.getPage();
+    page.on("pageerror", (error) => {
       this.pageErrors.push({
         message: error.message,
         timestamp: Date.now()
@@ -676,7 +676,7 @@ var BrowserManager = class {
    * Uses route interception to add headers only to matching requests
    */
   async setScopedHeaders(origin, headers) {
-    const page2 = this.getPage();
+    const page = this.getPage();
     let urlPattern;
     try {
       const url = new URL(origin.startsWith("http") ? origin : `https://${origin}`);
@@ -686,7 +686,7 @@ var BrowserManager = class {
     }
     const existingHandler = this.scopedHeaderRoutes.get(urlPattern);
     if (existingHandler) {
-      await page2.unroute(urlPattern, existingHandler);
+      await page.unroute(urlPattern, existingHandler);
     }
     const handler = async (route) => {
       const requestHeaders = route.request().headers();
@@ -698,13 +698,13 @@ var BrowserManager = class {
       });
     };
     this.scopedHeaderRoutes.set(urlPattern, handler);
-    await page2.route(urlPattern, handler);
+    await page.route(urlPattern, handler);
   }
   /**
    * Clear scoped headers for an origin (or all if no origin specified)
    */
   async clearScopedHeaders(origin) {
-    const page2 = this.getPage();
+    const page = this.getPage();
     if (origin) {
       let urlPattern;
       try {
@@ -715,12 +715,12 @@ var BrowserManager = class {
       }
       const handler = this.scopedHeaderRoutes.get(urlPattern);
       if (handler) {
-        await page2.unroute(urlPattern, handler);
+        await page.unroute(urlPattern, handler);
         this.scopedHeaderRoutes.delete(urlPattern);
       }
     } else {
       for (const [pattern, handler] of this.scopedHeaderRoutes) {
-        await page2.unroute(pattern, handler);
+        await page.unroute(pattern, handler);
       }
       this.scopedHeaderRoutes.clear();
     }
@@ -863,26 +863,26 @@ var BrowserManager = class {
       throw new Error(`Failed to create Browserbase session: ${response.statusText}`);
     }
     const session = await response.json();
-    const browser2 = await chromium.connectOverCDP(session.connectUrl).catch(() => {
+    const browser = await chromium.connectOverCDP(session.connectUrl).catch(() => {
       throw new Error("Failed to connect to Browserbase session via CDP");
     });
     try {
-      const contexts = browser2.contexts();
+      const contexts = browser.contexts();
       if (contexts.length === 0) {
         throw new Error("No browser context found in Browserbase session");
       }
       const context = contexts[0];
       const pages = context.pages();
-      const page2 = pages[0] ?? await context.newPage();
+      const page = pages[0] ?? await context.newPage();
       this.browserbaseSessionId = session.id;
       this.browserbaseApiKey = browserbaseApiKey;
-      this.browser = browser2;
+      this.browser = browser;
       context.setDefaultTimeout(1e4);
       this.contexts.push(context);
       this.setupContextTracking(context);
-      this.pages.push(page2);
+      this.pages.push(page);
       this.activePageIndex = 0;
-      this.setupPageTracking(page2);
+      this.setupPageTracking(page);
     } catch (error) {
       await this.closeBrowserbaseSession(session.id, browserbaseApiKey).catch((sessionError) => {
         console.error("Failed to close Browserbase session during cleanup:", sessionError);
@@ -977,29 +977,29 @@ var BrowserManager = class {
         `Invalid Kernel session response: missing ${!session.session_id ? "session_id" : "cdp_ws_url"}`
       );
     }
-    const browser2 = await chromium.connectOverCDP(session.cdp_ws_url).catch(() => {
+    const browser = await chromium.connectOverCDP(session.cdp_ws_url).catch(() => {
       throw new Error("Failed to connect to Kernel session via CDP");
     });
     try {
-      const contexts = browser2.contexts();
+      const contexts = browser.contexts();
       let context;
-      let page2;
+      let page;
       if (contexts.length === 0) {
-        context = await browser2.newContext();
-        page2 = await context.newPage();
+        context = await browser.newContext();
+        page = await context.newPage();
       } else {
         context = contexts[0];
         const pages = context.pages();
-        page2 = pages[0] ?? await context.newPage();
+        page = pages[0] ?? await context.newPage();
       }
       this.kernelSessionId = session.session_id;
       this.kernelApiKey = kernelApiKey;
-      this.browser = browser2;
+      this.browser = browser;
       context.setDefaultTimeout(6e4);
       this.contexts.push(context);
-      this.pages.push(page2);
+      this.pages.push(page);
       this.activePageIndex = 0;
-      this.setupPageTracking(page2);
+      this.setupPageTracking(page);
       this.setupContextTracking(context);
     } catch (error) {
       await this.closeKernelSession(session.session_id, kernelApiKey).catch((sessionError) => {
@@ -1041,29 +1041,29 @@ var BrowserManager = class {
         `Invalid Browser Use session response: missing ${!session.id ? "id" : "cdpUrl"}`
       );
     }
-    const browser2 = await chromium.connectOverCDP(session.cdpUrl).catch(() => {
+    const browser = await chromium.connectOverCDP(session.cdpUrl).catch(() => {
       throw new Error("Failed to connect to Browser Use session via CDP");
     });
     try {
-      const contexts = browser2.contexts();
+      const contexts = browser.contexts();
       let context;
-      let page2;
+      let page;
       if (contexts.length === 0) {
-        context = await browser2.newContext();
-        page2 = await context.newPage();
+        context = await browser.newContext();
+        page = await context.newPage();
       } else {
         context = contexts[0];
         const pages = context.pages();
-        page2 = pages[0] ?? await context.newPage();
+        page = pages[0] ?? await context.newPage();
       }
       this.browserUseSessionId = session.id;
       this.browserUseApiKey = browserUseApiKey;
-      this.browser = browser2;
+      this.browser = browser;
       context.setDefaultTimeout(6e4);
       this.contexts.push(context);
-      this.pages.push(page2);
+      this.pages.push(page);
       this.activePageIndex = 0;
-      this.setupPageTracking(page2);
+      this.setupPageTracking(page);
       this.setupContextTracking(context);
     } catch (error) {
       await this.closeBrowserUseSession(session.id, browserUseApiKey).catch((sessionError) => {
@@ -1185,10 +1185,10 @@ var BrowserManager = class {
     context.setDefaultTimeout(6e4);
     this.contexts.push(context);
     this.setupContextTracking(context);
-    const page2 = context.pages()[0] ?? await context.newPage();
-    if (!this.pages.includes(page2)) {
-      this.pages.push(page2);
-      this.setupPageTracking(page2);
+    const page = context.pages()[0] ?? await context.newPage();
+    if (!this.pages.includes(page)) {
+      this.pages.push(page);
+      this.setupPageTracking(page);
     }
     this.activePageIndex = this.pages.length > 0 ? this.pages.length - 1 : 0;
   }
@@ -1208,34 +1208,34 @@ var BrowserManager = class {
     } else {
       cdpUrl = `http://localhost:${cdpEndpoint}`;
     }
-    const browser2 = await chromium.connectOverCDP(cdpUrl).catch(() => {
+    const browser = await chromium.connectOverCDP(cdpUrl).catch(() => {
       throw new Error(
         `Failed to connect via CDP to ${cdpUrl}. ` + (cdpUrl.includes("localhost") ? `Make sure the app is running with --remote-debugging-port=${cdpEndpoint}` : "Make sure the remote browser is accessible and the URL is correct.")
       );
     });
     try {
-      const contexts = browser2.contexts();
+      const contexts = browser.contexts();
       if (contexts.length === 0) {
         throw new Error("No browser context found. Make sure the app has an open window.");
       }
-      const allPages = contexts.flatMap((context) => context.pages()).filter((page2) => page2.url());
+      const allPages = contexts.flatMap((context) => context.pages()).filter((page) => page.url());
       if (allPages.length === 0) {
         throw new Error("No page found. Make sure the app has loaded content.");
       }
-      this.browser = browser2;
+      this.browser = browser;
       this.cdpEndpoint = cdpEndpoint;
       for (const context of contexts) {
         context.setDefaultTimeout(1e4);
         this.contexts.push(context);
         this.setupContextTracking(context);
       }
-      for (const page2 of allPages) {
-        this.pages.push(page2);
-        this.setupPageTracking(page2);
+      for (const page of allPages) {
+        this.pages.push(page);
+        this.setupPageTracking(page);
       }
       this.activePageIndex = 0;
     } catch (error) {
-      await browser2.close().catch(() => {
+      await browser.close().catch(() => {
       });
       throw error;
     }
@@ -1243,22 +1243,22 @@ var BrowserManager = class {
   /**
    * Set up console, error, and close tracking for a page
    */
-  setupPageTracking(page2) {
-    page2.on("console", (msg) => {
+  setupPageTracking(page) {
+    page.on("console", (msg) => {
       this.consoleMessages.push({
         type: msg.type(),
         text: msg.text(),
         timestamp: Date.now()
       });
     });
-    page2.on("pageerror", (error) => {
+    page.on("pageerror", (error) => {
       this.pageErrors.push({
         message: error.message,
         timestamp: Date.now()
       });
     });
-    page2.on("close", () => {
-      const index = this.pages.indexOf(page2);
+    page.on("close", () => {
+      const index = this.pages.indexOf(page);
       if (index !== -1) {
         this.pages.splice(index, 1);
         if (this.activePageIndex >= this.pages.length) {
@@ -1272,12 +1272,12 @@ var BrowserManager = class {
    * This handles pages created externally (e.g., via target="_blank" links, window.open)
    */
   setupContextTracking(context) {
-    context.on("page", (page2) => {
-      if (!this.pages.includes(page2)) {
-        this.pages.push(page2);
-        this.setupPageTracking(page2);
+    context.on("page", (page) => {
+      if (!this.pages.includes(page)) {
+        this.pages.push(page);
+        this.setupPageTracking(page);
       }
-      const newIndex = this.pages.indexOf(page2);
+      const newIndex = this.pages.indexOf(page);
       if (newIndex !== -1 && newIndex !== this.activePageIndex) {
         this.activePageIndex = newIndex;
         this.invalidateCDPSession().catch(() => {
@@ -1294,10 +1294,10 @@ var BrowserManager = class {
     }
     await this.invalidateCDPSession();
     const context = this.contexts[0];
-    const page2 = await context.newPage();
-    if (!this.pages.includes(page2)) {
-      this.pages.push(page2);
-      this.setupPageTracking(page2);
+    const page = await context.newPage();
+    if (!this.pages.includes(page)) {
+      this.pages.push(page);
+      this.setupPageTracking(page);
     }
     this.activePageIndex = this.pages.length - 1;
     return { index: this.activePageIndex, total: this.pages.length };
@@ -1315,10 +1315,10 @@ var BrowserManager = class {
     context.setDefaultTimeout(6e4);
     this.contexts.push(context);
     this.setupContextTracking(context);
-    const page2 = await context.newPage();
-    if (!this.pages.includes(page2)) {
-      this.pages.push(page2);
-      this.setupPageTracking(page2);
+    const page = await context.newPage();
+    if (!this.pages.includes(page)) {
+      this.pages.push(page);
+      this.setupPageTracking(page);
     }
     this.activePageIndex = this.pages.length - 1;
     return { index: this.activePageIndex, total: this.pages.length };
@@ -1348,10 +1348,10 @@ var BrowserManager = class {
       await this.invalidateCDPSession();
     }
     this.activePageIndex = index;
-    const page2 = this.pages[index];
+    const page = this.pages[index];
     return {
       index: this.activePageIndex,
-      url: page2.url(),
+      url: page.url(),
       title: ""
       // Title requires async, will be fetched separately
     };
@@ -1370,8 +1370,8 @@ var BrowserManager = class {
     if (targetIndex === this.activePageIndex) {
       await this.invalidateCDPSession();
     }
-    const page2 = this.pages[targetIndex];
-    await page2.close();
+    const page = this.pages[targetIndex];
+    await page.close();
     this.pages.splice(targetIndex, 1);
     if (this.activePageIndex >= this.pages.length) {
       this.activePageIndex = this.pages.length - 1;
@@ -1385,10 +1385,10 @@ var BrowserManager = class {
    */
   async listTabs() {
     const tabs = await Promise.all(
-      this.pages.map(async (page2, index) => ({
+      this.pages.map(async (page, index) => ({
         index,
-        url: page2.url(),
-        title: await page2.title().catch(() => ""),
+        url: page.url(),
+        title: await page.title().catch(() => ""),
         active: index === this.activePageIndex
       }))
     );
@@ -1402,9 +1402,9 @@ var BrowserManager = class {
     if (this.cdpSession) {
       return this.cdpSession;
     }
-    const page2 = this.getPage();
-    const context = page2.context();
-    this.cdpSession = await context.newCDPSession(page2);
+    const page = this.getPage();
+    const context = page.context();
+    this.cdpSession = await context.newCDPSession(page);
     return this.cdpSession;
   }
   /**
@@ -1692,8 +1692,8 @@ var BrowserManager = class {
         this.browser = null;
       }
     } else {
-      for (const page2 of this.pages) {
-        await page2.close().catch(() => {
+      for (const page of this.pages) {
+        await page.close().catch(() => {
         });
       }
       for (const context of this.contexts) {
@@ -2096,8 +2096,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    await element2.click();
+    const element = await this.getElement(selector);
+    await element.click();
   }
   /**
    * Alias for click (semantic clarity for touch)
@@ -2112,17 +2112,17 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
+    const element = await this.getElement(selector);
     if (options?.clear) {
-      await element2.clearValue();
+      await element.clearValue();
     }
     if (options?.delay && options.delay > 0) {
       for (const char of text) {
-        await element2.addValue(char);
+        await element.addValue(char);
         await new Promise((r) => setTimeout(r, options.delay));
       }
     } else {
-      await element2.addValue(text);
+      await element.addValue(text);
     }
   }
   /**
@@ -2132,9 +2132,9 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    await element2.clearValue();
-    await element2.setValue(value);
+    const element = await this.getElement(selector);
+    await element.clearValue();
+    await element.setValue(value);
   }
   /**
    * Get element by selector or ref
@@ -2224,12 +2224,12 @@ var IOSManager = class _IOSManager {
         "DETAILS",
         "SUMMARY"
       ]);
-      function getXPath(element2) {
-        if (element2.id) {
-          return `//*[@id="${element2.id}"]`;
+      function getXPath(element) {
+        if (element.id) {
+          return `//*[@id="${element.id}"]`;
         }
         const parts = [];
-        let current = element2;
+        let current = element;
         while (current && current.nodeType === 1) {
           let index = 1;
           let sibling = current.previousElementSibling;
@@ -2245,36 +2245,36 @@ var IOSManager = class _IOSManager {
         }
         return "/" + parts.join("/");
       }
-      function getAccessibleName(element2) {
-        const ariaLabel = element2.getAttribute("aria-label");
+      function getAccessibleName(element) {
+        const ariaLabel = element.getAttribute("aria-label");
         if (ariaLabel) return ariaLabel;
-        const tagName = element2.tagName;
+        const tagName = element.tagName;
         if (tagName === "INPUT" || tagName === "TEXTAREA") {
-          const id = element2.id;
+          const id = element.id;
           if (id) {
             const label = document.querySelector(`label[for="${id}"]`);
             if (label) return label.textContent?.trim() || "";
           }
-          if (element2.placeholder) return element2.placeholder;
+          if (element.placeholder) return element.placeholder;
         }
         if (tagName === "BUTTON" || tagName === "A") {
-          return element2.textContent?.trim() || "";
+          return element.textContent?.trim() || "";
         }
-        const labelledBy = element2.getAttribute("aria-labelledby");
+        const labelledBy = element.getAttribute("aria-labelledby");
         if (labelledBy) {
           const labelElement = document.getElementById(labelledBy);
           if (labelElement) return labelElement.textContent?.trim() || "";
         }
-        return element2.textContent?.trim().slice(0, 50) || "";
+        return element.textContent?.trim().slice(0, 50) || "";
       }
-      function getRole(element2) {
-        const role = element2.getAttribute("role");
+      function getRole(element) {
+        const role = element.getAttribute("role");
         if (role) return role;
-        const tag = element2.tagName;
-        if (tag === "A" && element2.hasAttribute("href")) return "link";
+        const tag = element.tagName;
+        if (tag === "A" && element.hasAttribute("href")) return "link";
         if (tag === "BUTTON") return "button";
         if (tag === "INPUT") {
-          const type = element2.type;
+          const type = element.type;
           if (type === "checkbox") return "checkbox";
           if (type === "radio") return "radio";
           if (type === "text" || type === "email" || type === "password" || type === "search")
@@ -2292,18 +2292,18 @@ var IOSManager = class _IOSManager {
         if (tag === "FOOTER") return "contentinfo";
         return null;
       }
-      function traverse(element2, depth) {
+      function traverse(element, depth) {
         if (depth > 10) return null;
-        const tag = element2.tagName;
-        const role = getRole(element2);
-        const name = getAccessibleName(element2);
+        const tag = element.tagName;
+        const role = getRole(element);
+        const name = getAccessibleName(element);
         const isInteractive = INTERACTIVE_TAGS.has(tag) || role !== null && INTERACTIVE_ROLES2.has(role);
-        const style = window.getComputedStyle(element2);
+        const style = window.getComputedStyle(element);
         if (style.display === "none" || style.visibility === "hidden") {
           return null;
         }
         const children = [];
-        for (const child of element2.children) {
+        for (const child of element.children) {
           const childInfo = traverse(child, depth + 1);
           if (childInfo) {
             children.push(childInfo);
@@ -2316,9 +2316,9 @@ var IOSManager = class _IOSManager {
           tag,
           role,
           name,
-          text: element2.textContent?.trim().slice(0, 100) || "",
+          text: element.textContent?.trim().slice(0, 100) || "",
           isInteractive,
-          xpath: getXPath(element2),
+          xpath: getXPath(element),
           children
         };
       }
@@ -2372,8 +2372,8 @@ var IOSManager = class _IOSManager {
     }
     const amount = options?.amount ?? 300;
     if (options?.selector) {
-      const element2 = await this.getElement(options.selector);
-      await element2.scrollIntoView();
+      const element = await this.getElement(options.selector);
+      await element.scrollIntoView();
       return;
     }
     let deltaX = options?.x ?? 0;
@@ -2421,16 +2421,16 @@ var IOSManager = class _IOSManager {
   /**
    * Execute JavaScript
    */
-  async evaluate(script2, ...args) {
+  async evaluate(script, ...args) {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
     const result = await this.browser.execute(
       function(code, evalArgs) {
-        const fn2 = new Function(...evalArgs.map((_, i) => `arg${i}`), code);
-        return fn2(...evalArgs);
+        const fn = new Function(...evalArgs.map((_, i) => `arg${i}`), code);
+        return fn(...evalArgs);
       },
-      script2.includes("return") ? script2 : `return (${script2})`,
+      script.includes("return") ? script : `return (${script})`,
       args
     );
     return result;
@@ -2444,20 +2444,20 @@ var IOSManager = class _IOSManager {
     }
     const timeout = options.timeout ?? 3e4;
     if (options.selector) {
-      const element2 = await this.getElement(options.selector);
+      const element = await this.getElement(options.selector);
       switch (options.state) {
         case "detached":
-          await element2.waitForExist({ timeout, reverse: true });
+          await element.waitForExist({ timeout, reverse: true });
           break;
         case "hidden":
-          await element2.waitForDisplayed({ timeout, reverse: true });
+          await element.waitForDisplayed({ timeout, reverse: true });
           break;
         case "visible":
-          await element2.waitForDisplayed({ timeout });
+          await element.waitForDisplayed({ timeout });
           break;
         case "attached":
         default:
-          await element2.waitForExist({ timeout });
+          await element.waitForExist({ timeout });
           break;
       }
     } else {
@@ -2492,8 +2492,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    await element2.scrollIntoView();
+    const element = await this.getElement(selector);
+    await element.scrollIntoView();
   }
   /**
    * Get page content (HTML)
@@ -2503,8 +2503,8 @@ var IOSManager = class _IOSManager {
       throw new Error("iOS browser not launched");
     }
     if (selector) {
-      const element2 = await this.getElement(selector);
-      return element2.getHTML();
+      const element = await this.getElement(selector);
+      return element.getHTML();
     }
     return this.browser.getPageSource();
   }
@@ -2515,8 +2515,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    return element2.getText();
+    const element = await this.getElement(selector);
+    return element.getText();
   }
   /**
    * Get attribute value
@@ -2525,8 +2525,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    return element2.getAttribute(attribute);
+    const element = await this.getElement(selector);
+    return element.getAttribute(attribute);
   }
   /**
    * Check if element is visible
@@ -2536,8 +2536,8 @@ var IOSManager = class _IOSManager {
       throw new Error("iOS browser not launched");
     }
     try {
-      const element2 = await this.getElement(selector);
-      return element2.isDisplayed();
+      const element = await this.getElement(selector);
+      return element.isDisplayed();
     } catch {
       return false;
     }
@@ -2549,8 +2549,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    return element2.isEnabled();
+    const element = await this.getElement(selector);
+    return element.isEnabled();
   }
   /**
    * Navigate back
@@ -2586,10 +2586,10 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
+    const element = await this.getElement(selector);
     const valueArray = Array.isArray(values) ? values : [values];
     for (const value of valueArray) {
-      await element2.selectByAttribute("value", value);
+      await element.selectByAttribute("value", value);
     }
   }
   /**
@@ -2599,10 +2599,10 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    const isChecked = await element2.isSelected();
+    const element = await this.getElement(selector);
+    const isChecked = await element.isSelected();
     if (!isChecked) {
-      await element2.click();
+      await element.click();
     }
   }
   /**
@@ -2612,10 +2612,10 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    const isChecked = await element2.isSelected();
+    const element = await this.getElement(selector);
+    const isChecked = await element.isSelected();
     if (isChecked) {
-      await element2.click();
+      await element.click();
     }
   }
   /**
@@ -2625,10 +2625,10 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    await this.browser.execute(function(el2) {
-      el2.focus();
-    }, element2);
+    const element = await this.getElement(selector);
+    await this.browser.execute(function(el) {
+      el.focus();
+    }, element);
   }
   /**
    * Clear input field
@@ -2637,8 +2637,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const element2 = await this.getElement(selector);
-    await element2.clearValue();
+    const element = await this.getElement(selector);
+    await element.clearValue();
   }
   /**
    * Get element count
@@ -2647,8 +2647,8 @@ var IOSManager = class _IOSManager {
     if (!this.browser) {
       throw new Error("iOS browser not launched");
     }
-    const elements2 = await this.browser.$$(selector);
-    return elements2.length;
+    const elements = await this.browser.$$(selector);
+    return elements.length;
   }
   /**
    * Get bounding box
@@ -2658,9 +2658,9 @@ var IOSManager = class _IOSManager {
       throw new Error("iOS browser not launched");
     }
     try {
-      const element2 = await this.getElement(selector);
-      const location = await element2.getLocation();
-      const size = await element2.getSize();
+      const element = await this.getElement(selector);
+      const location = await element.getLocation();
+      const size = await element.getSize();
       return {
         x: location.x,
         y: location.y,
@@ -3548,357 +3548,357 @@ function toAIFriendlyError(error, selector) {
   }
   return error instanceof Error ? error : new Error(message);
 }
-async function executeCommand(command2, browser2) {
+async function executeCommand(command, browser) {
   try {
-    switch (command2.action) {
+    switch (command.action) {
       case "launch":
-        return await handleLaunch(command2, browser2);
+        return await handleLaunch(command, browser);
       case "navigate":
-        return await handleNavigate(command2, browser2);
+        return await handleNavigate(command, browser);
       case "click":
-        return await handleClick(command2, browser2);
+        return await handleClick(command, browser);
       case "type":
-        return await handleType(command2, browser2);
+        return await handleType(command, browser);
       case "fill":
-        return await handleFill(command2, browser2);
+        return await handleFill(command, browser);
       case "check":
-        return await handleCheck(command2, browser2);
+        return await handleCheck(command, browser);
       case "uncheck":
-        return await handleUncheck(command2, browser2);
+        return await handleUncheck(command, browser);
       case "upload":
-        return await handleUpload(command2, browser2);
+        return await handleUpload(command, browser);
       case "dblclick":
-        return await handleDoubleClick(command2, browser2);
+        return await handleDoubleClick(command, browser);
       case "focus":
-        return await handleFocus(command2, browser2);
+        return await handleFocus(command, browser);
       case "drag":
-        return await handleDrag(command2, browser2);
+        return await handleDrag(command, browser);
       case "frame":
-        return await handleFrame(command2, browser2);
+        return await handleFrame(command, browser);
       case "mainframe":
-        return await handleMainFrame(command2, browser2);
+        return await handleMainFrame(command, browser);
       case "getbyrole":
-        return await handleGetByRole(command2, browser2);
+        return await handleGetByRole(command, browser);
       case "getbytext":
-        return await handleGetByText(command2, browser2);
+        return await handleGetByText(command, browser);
       case "getbylabel":
-        return await handleGetByLabel(command2, browser2);
+        return await handleGetByLabel(command, browser);
       case "getbyplaceholder":
-        return await handleGetByPlaceholder(command2, browser2);
+        return await handleGetByPlaceholder(command, browser);
       case "press":
-        return await handlePress(command2, browser2);
+        return await handlePress(command, browser);
       case "screenshot":
-        return await handleScreenshot(command2, browser2);
+        return await handleScreenshot(command, browser);
       case "snapshot":
-        return await handleSnapshot(command2, browser2);
+        return await handleSnapshot(command, browser);
       case "evaluate":
-        return await handleEvaluate(command2, browser2);
+        return await handleEvaluate(command, browser);
       case "wait":
-        return await handleWait(command2, browser2);
+        return await handleWait(command, browser);
       case "scroll":
-        return await handleScroll(command2, browser2);
+        return await handleScroll(command, browser);
       case "select":
-        return await handleSelect(command2, browser2);
+        return await handleSelect(command, browser);
       case "hover":
-        return await handleHover(command2, browser2);
+        return await handleHover(command, browser);
       case "content":
-        return await handleContent(command2, browser2);
+        return await handleContent(command, browser);
       case "close":
-        return await handleClose(command2, browser2);
+        return await handleClose(command, browser);
       case "tab_new":
-        return await handleTabNew(command2, browser2);
+        return await handleTabNew(command, browser);
       case "tab_list":
-        return await handleTabList(command2, browser2);
+        return await handleTabList(command, browser);
       case "tab_switch":
-        return await handleTabSwitch(command2, browser2);
+        return await handleTabSwitch(command, browser);
       case "tab_close":
-        return await handleTabClose(command2, browser2);
+        return await handleTabClose(command, browser);
       case "window_new":
-        return await handleWindowNew(command2, browser2);
+        return await handleWindowNew(command, browser);
       case "cookies_get":
-        return await handleCookiesGet(command2, browser2);
+        return await handleCookiesGet(command, browser);
       case "cookies_set":
-        return await handleCookiesSet(command2, browser2);
+        return await handleCookiesSet(command, browser);
       case "cookies_clear":
-        return await handleCookiesClear(command2, browser2);
+        return await handleCookiesClear(command, browser);
       case "storage_get":
-        return await handleStorageGet(command2, browser2);
+        return await handleStorageGet(command, browser);
       case "storage_set":
-        return await handleStorageSet(command2, browser2);
+        return await handleStorageSet(command, browser);
       case "storage_clear":
-        return await handleStorageClear(command2, browser2);
+        return await handleStorageClear(command, browser);
       case "dialog":
-        return await handleDialog(command2, browser2);
+        return await handleDialog(command, browser);
       case "pdf":
-        return await handlePdf(command2, browser2);
+        return await handlePdf(command, browser);
       case "route":
-        return await handleRoute(command2, browser2);
+        return await handleRoute(command, browser);
       case "unroute":
-        return await handleUnroute(command2, browser2);
+        return await handleUnroute(command, browser);
       case "requests":
-        return await handleRequests(command2, browser2);
+        return await handleRequests(command, browser);
       case "download":
-        return await handleDownload(command2, browser2);
+        return await handleDownload(command, browser);
       case "geolocation":
-        return await handleGeolocation(command2, browser2);
+        return await handleGeolocation(command, browser);
       case "permissions":
-        return await handlePermissions(command2, browser2);
+        return await handlePermissions(command, browser);
       case "viewport":
-        return await handleViewport(command2, browser2);
+        return await handleViewport(command, browser);
       case "useragent":
-        return await handleUserAgent(command2, browser2);
+        return await handleUserAgent(command, browser);
       case "device":
-        return await handleDevice(command2, browser2);
+        return await handleDevice(command, browser);
       case "back":
-        return await handleBack(command2, browser2);
+        return await handleBack(command, browser);
       case "forward":
-        return await handleForward(command2, browser2);
+        return await handleForward(command, browser);
       case "reload":
-        return await handleReload(command2, browser2);
+        return await handleReload(command, browser);
       case "url":
-        return await handleUrl(command2, browser2);
+        return await handleUrl(command, browser);
       case "title":
-        return await handleTitle(command2, browser2);
+        return await handleTitle(command, browser);
       case "getattribute":
-        return await handleGetAttribute(command2, browser2);
+        return await handleGetAttribute(command, browser);
       case "gettext":
-        return await handleGetText(command2, browser2);
+        return await handleGetText(command, browser);
       case "isvisible":
-        return await handleIsVisible(command2, browser2);
+        return await handleIsVisible(command, browser);
       case "isenabled":
-        return await handleIsEnabled(command2, browser2);
+        return await handleIsEnabled(command, browser);
       case "ischecked":
-        return await handleIsChecked(command2, browser2);
+        return await handleIsChecked(command, browser);
       case "count":
-        return await handleCount(command2, browser2);
+        return await handleCount(command, browser);
       case "boundingbox":
-        return await handleBoundingBox(command2, browser2);
+        return await handleBoundingBox(command, browser);
       case "styles":
-        return await handleStyles(command2, browser2);
+        return await handleStyles(command, browser);
       case "video_start":
-        return await handleVideoStart(command2, browser2);
+        return await handleVideoStart(command, browser);
       case "video_stop":
-        return await handleVideoStop(command2, browser2);
+        return await handleVideoStop(command, browser);
       case "trace_start":
-        return await handleTraceStart(command2, browser2);
+        return await handleTraceStart(command, browser);
       case "trace_stop":
-        return await handleTraceStop(command2, browser2);
+        return await handleTraceStop(command, browser);
       case "har_start":
-        return await handleHarStart(command2, browser2);
+        return await handleHarStart(command, browser);
       case "har_stop":
-        return await handleHarStop(command2, browser2);
+        return await handleHarStop(command, browser);
       case "state_save":
-        return await handleStateSave(command2, browser2);
+        return await handleStateSave(command, browser);
       case "state_load":
-        return await handleStateLoad(command2, browser2);
+        return await handleStateLoad(command, browser);
       case "console":
-        return await handleConsole(command2, browser2);
+        return await handleConsole(command, browser);
       case "errors":
-        return await handleErrors(command2, browser2);
+        return await handleErrors(command, browser);
       case "keyboard":
-        return await handleKeyboard(command2, browser2);
+        return await handleKeyboard(command, browser);
       case "wheel":
-        return await handleWheel(command2, browser2);
+        return await handleWheel(command, browser);
       case "tap":
-        return await handleTap(command2, browser2);
+        return await handleTap(command, browser);
       case "clipboard":
-        return await handleClipboard(command2, browser2);
+        return await handleClipboard(command, browser);
       case "highlight":
-        return await handleHighlight(command2, browser2);
+        return await handleHighlight(command, browser);
       case "clear":
-        return await handleClear(command2, browser2);
+        return await handleClear(command, browser);
       case "selectall":
-        return await handleSelectAll(command2, browser2);
+        return await handleSelectAll(command, browser);
       case "innertext":
-        return await handleInnerText(command2, browser2);
+        return await handleInnerText(command, browser);
       case "innerhtml":
-        return await handleInnerHtml(command2, browser2);
+        return await handleInnerHtml(command, browser);
       case "inputvalue":
-        return await handleInputValue(command2, browser2);
+        return await handleInputValue(command, browser);
       case "setvalue":
-        return await handleSetValue(command2, browser2);
+        return await handleSetValue(command, browser);
       case "dispatch":
-        return await handleDispatch(command2, browser2);
+        return await handleDispatch(command, browser);
       case "evalhandle":
-        return await handleEvalHandle(command2, browser2);
+        return await handleEvalHandle(command, browser);
       case "expose":
-        return await handleExpose(command2, browser2);
+        return await handleExpose(command, browser);
       case "addscript":
-        return await handleAddScript(command2, browser2);
+        return await handleAddScript(command, browser);
       case "addstyle":
-        return await handleAddStyle(command2, browser2);
+        return await handleAddStyle(command, browser);
       case "emulatemedia":
-        return await handleEmulateMedia(command2, browser2);
+        return await handleEmulateMedia(command, browser);
       case "offline":
-        return await handleOffline(command2, browser2);
+        return await handleOffline(command, browser);
       case "headers":
-        return await handleHeaders(command2, browser2);
+        return await handleHeaders(command, browser);
       case "pause":
-        return await handlePause(command2, browser2);
+        return await handlePause(command, browser);
       case "getbyalttext":
-        return await handleGetByAltText(command2, browser2);
+        return await handleGetByAltText(command, browser);
       case "getbytitle":
-        return await handleGetByTitle(command2, browser2);
+        return await handleGetByTitle(command, browser);
       case "getbytestid":
-        return await handleGetByTestId(command2, browser2);
+        return await handleGetByTestId(command, browser);
       case "nth":
-        return await handleNth(command2, browser2);
+        return await handleNth(command, browser);
       case "waitforurl":
-        return await handleWaitForUrl(command2, browser2);
+        return await handleWaitForUrl(command, browser);
       case "waitforloadstate":
-        return await handleWaitForLoadState(command2, browser2);
+        return await handleWaitForLoadState(command, browser);
       case "setcontent":
-        return await handleSetContent(command2, browser2);
+        return await handleSetContent(command, browser);
       case "timezone":
-        return await handleTimezone(command2, browser2);
+        return await handleTimezone(command, browser);
       case "locale":
-        return await handleLocale(command2, browser2);
+        return await handleLocale(command, browser);
       case "credentials":
-        return await handleCredentials(command2, browser2);
+        return await handleCredentials(command, browser);
       case "mousemove":
-        return await handleMouseMove(command2, browser2);
+        return await handleMouseMove(command, browser);
       case "mousedown":
-        return await handleMouseDown(command2, browser2);
+        return await handleMouseDown(command, browser);
       case "mouseup":
-        return await handleMouseUp(command2, browser2);
+        return await handleMouseUp(command, browser);
       case "bringtofront":
-        return await handleBringToFront(command2, browser2);
+        return await handleBringToFront(command, browser);
       case "waitforfunction":
-        return await handleWaitForFunction(command2, browser2);
+        return await handleWaitForFunction(command, browser);
       case "scrollintoview":
-        return await handleScrollIntoView(command2, browser2);
+        return await handleScrollIntoView(command, browser);
       case "addinitscript":
-        return await handleAddInitScript(command2, browser2);
+        return await handleAddInitScript(command, browser);
       case "keydown":
-        return await handleKeyDown(command2, browser2);
+        return await handleKeyDown(command, browser);
       case "keyup":
-        return await handleKeyUp(command2, browser2);
+        return await handleKeyUp(command, browser);
       case "inserttext":
-        return await handleInsertText(command2, browser2);
+        return await handleInsertText(command, browser);
       case "multiselect":
-        return await handleMultiSelect(command2, browser2);
+        return await handleMultiSelect(command, browser);
       case "waitfordownload":
-        return await handleWaitForDownload(command2, browser2);
+        return await handleWaitForDownload(command, browser);
       case "responsebody":
-        return await handleResponseBody(command2, browser2);
+        return await handleResponseBody(command, browser);
       case "screencast_start":
-        return await handleScreencastStart(command2, browser2);
+        return await handleScreencastStart(command, browser);
       case "screencast_stop":
-        return await handleScreencastStop(command2, browser2);
+        return await handleScreencastStop(command, browser);
       case "input_mouse":
-        return await handleInputMouse(command2, browser2);
+        return await handleInputMouse(command, browser);
       case "input_keyboard":
-        return await handleInputKeyboard(command2, browser2);
+        return await handleInputKeyboard(command, browser);
       case "input_touch":
-        return await handleInputTouch(command2, browser2);
+        return await handleInputTouch(command, browser);
       case "recording_start":
-        return await handleRecordingStart(command2, browser2);
+        return await handleRecordingStart(command, browser);
       case "recording_stop":
-        return await handleRecordingStop(command2, browser2);
+        return await handleRecordingStop(command, browser);
       case "recording_restart":
-        return await handleRecordingRestart(command2, browser2);
+        return await handleRecordingRestart(command, browser);
       default: {
-        const unknownCommand = command2;
+        const unknownCommand = command;
         return errorResponse(unknownCommand.id, `Unknown action: ${unknownCommand.action}`);
       }
     }
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    return errorResponse(command2.id, message);
+    return errorResponse(command.id, message);
   }
 }
-async function handleLaunch(command2, browser2) {
-  await browser2.launch(command2);
-  return successResponse(command2.id, { launched: true });
+async function handleLaunch(command, browser) {
+  await browser.launch(command);
+  return successResponse(command.id, { launched: true });
 }
-async function handleNavigate(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.headers && Object.keys(command2.headers).length > 0) {
-    await browser2.setScopedHeaders(command2.url, command2.headers);
+async function handleNavigate(command, browser) {
+  const page = browser.getPage();
+  if (command.headers && Object.keys(command.headers).length > 0) {
+    await browser.setScopedHeaders(command.url, command.headers);
   }
-  await page2.goto(command2.url, {
-    waitUntil: command2.waitUntil ?? "load"
+  await page.goto(command.url, {
+    waitUntil: command.waitUntil ?? "load"
   });
-  return successResponse(command2.id, {
-    url: page2.url(),
-    title: await page2.title()
+  return successResponse(command.id, {
+    url: page.url(),
+    title: await page.title()
   });
 }
-async function handleClick(command2, browser2) {
-  if (browser2.isRef(command2.selector)) {
-    const refData = browser2.getRefData(command2.selector);
+async function handleClick(command, browser) {
+  if (browser.isRef(command.selector)) {
+    const refData = browser.getRefData(command.selector);
     if (refData && refData.bounds) {
       const b = refData.bounds;
       const centerX = b.left + (b.right - b.left) / 2;
       const centerY = b.top + (b.bottom - b.top) / 2;
-      await browser2.injectMouseEvent({
+      await browser.injectMouseEvent({
         type: "mousePressed",
         x: centerX,
         y: centerY,
-        button: command2.button || "left",
-        clickCount: command2.clickCount || 1
+        button: command.button || "left",
+        clickCount: command.clickCount || 1
       });
-      await browser2.injectMouseEvent({
+      await browser.injectMouseEvent({
         type: "mouseReleased",
         x: centerX,
         y: centerY,
-        button: command2.button || "left"
+        button: command.button || "left"
       });
-      return successResponse(command2.id, { clicked: true, method: "cdp_coordinates" });
+      return successResponse(command.id, { clicked: true, method: "cdp_coordinates" });
     }
   }
-  const locator2 = browser2.getLocator(command2.selector);
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.click({
-      button: command2.button,
-      clickCount: command2.clickCount,
-      delay: command2.delay
+    await locator.click({
+      button: command.button,
+      clickCount: command.clickCount,
+      delay: command.delay
     });
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { clicked: true, method: "playwright_locator" });
+  return successResponse(command.id, { clicked: true, method: "playwright_locator" });
 }
-async function handleType(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleType(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    if (command2.clear) {
-      await locator2.fill("");
+    if (command.clear) {
+      await locator.fill("");
     }
-    await locator2.pressSequentially(command2.text, {
-      delay: command2.delay
+    await locator.pressSequentially(command.text, {
+      delay: command.delay
     });
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { typed: true });
+  return successResponse(command.id, { typed: true });
 }
-async function handlePress(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.selector) {
-    await page2.press(command2.selector, command2.key);
+async function handlePress(command, browser) {
+  const page = browser.getPage();
+  if (command.selector) {
+    await page.press(command.selector, command.key);
   } else {
-    await page2.keyboard.press(command2.key);
+    await page.keyboard.press(command.key);
   }
-  return successResponse(command2.id, { pressed: true });
+  return successResponse(command.id, { pressed: true });
 }
-async function handleScreenshot(command2, browser2) {
-  const page2 = browser2.getPage();
+async function handleScreenshot(command, browser) {
+  const page = browser.getPage();
   const options = {
-    fullPage: command2.fullPage,
-    type: command2.format ?? "png"
+    fullPage: command.fullPage,
+    type: command.format ?? "png"
   };
-  if (command2.format === "jpeg" && command2.quality !== void 0) {
-    options.quality = command2.quality;
+  if (command.format === "jpeg" && command.quality !== void 0) {
+    options.quality = command.quality;
   }
-  let target = page2;
-  if (command2.selector) {
-    target = browser2.getLocator(command2.selector);
+  let target = page;
+  if (command.selector) {
+    target = browser.getLocator(command.selector);
   }
   try {
-    let savePath = command2.path;
+    let savePath = command.path;
     if (!savePath) {
-      const ext = command2.format === "jpeg" ? "jpg" : "png";
+      const ext = command.format === "jpeg" ? "jpg" : "png";
       const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
       const random = Math.random().toString(36).substring(2, 8);
       const filename = `screenshot-${timestamp}-${random}.${ext}`;
@@ -3907,69 +3907,69 @@ async function handleScreenshot(command2, browser2) {
       savePath = path3.join(screenshotDir, filename);
     }
     await target.screenshot({ ...options, path: savePath });
-    return successResponse(command2.id, { path: savePath });
+    return successResponse(command.id, { path: savePath });
   } catch (error) {
-    if (command2.selector) {
-      throw toAIFriendlyError(error, command2.selector);
+    if (command.selector) {
+      throw toAIFriendlyError(error, command.selector);
     }
     throw error;
   }
 }
-async function handleSnapshot(command2, browser2) {
-  const { tree, refs } = await browser2.getSnapshot({
-    interactive: command2.interactive,
-    cursor: command2.cursor,
-    maxDepth: command2.maxDepth,
-    compact: command2.compact,
-    selector: command2.selector
+async function handleSnapshot(command, browser) {
+  const { tree, refs } = await browser.getSnapshot({
+    interactive: command.interactive,
+    cursor: command.cursor,
+    maxDepth: command.maxDepth,
+    compact: command.compact,
+    selector: command.selector
   });
   const simpleRefs = {};
   for (const [ref, data] of Object.entries(refs)) {
     simpleRefs[ref] = { role: data.role, name: data.name };
   }
-  return successResponse(command2.id, {
+  return successResponse(command.id, {
     snapshot: tree || "Empty page",
     refs: Object.keys(simpleRefs).length > 0 ? simpleRefs : void 0
   });
 }
-async function handleEvaluate(command2, browser2) {
-  const page2 = browser2.getPage();
-  const result = await page2.evaluate(command2.script);
-  return successResponse(command2.id, { result });
-}
-async function handleWait(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.selector) {
-    await page2.waitForSelector(command2.selector, {
-      state: command2.state ?? "visible",
-      timeout: command2.timeout
+async function handleEvaluate(command, browser) {
+  const page = browser.getPage();
+  const result = await page.evaluate(command.script);
+  return successResponse(command.id, { result });
+}
+async function handleWait(command, browser) {
+  const page = browser.getPage();
+  if (command.selector) {
+    await page.waitForSelector(command.selector, {
+      state: command.state ?? "visible",
+      timeout: command.timeout
     });
-  } else if (command2.timeout) {
-    await page2.waitForTimeout(command2.timeout);
+  } else if (command.timeout) {
+    await page.waitForTimeout(command.timeout);
   } else {
-    await page2.waitForLoadState("load");
-  }
-  return successResponse(command2.id, { waited: true });
-}
-async function handleScroll(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.selector) {
-    const element2 = page2.locator(command2.selector);
-    await element2.scrollIntoViewIfNeeded();
-    if (command2.x !== void 0 || command2.y !== void 0) {
-      await element2.evaluate(
-        (el2, { x, y }) => {
-          el2.scrollBy(x ?? 0, y ?? 0);
+    await page.waitForLoadState("load");
+  }
+  return successResponse(command.id, { waited: true });
+}
+async function handleScroll(command, browser) {
+  const page = browser.getPage();
+  if (command.selector) {
+    const element = page.locator(command.selector);
+    await element.scrollIntoViewIfNeeded();
+    if (command.x !== void 0 || command.y !== void 0) {
+      await element.evaluate(
+        (el, { x, y }) => {
+          el.scrollBy(x ?? 0, y ?? 0);
         },
-        { x: command2.x, y: command2.y }
+        { x: command.x, y: command.y }
       );
     }
   } else {
-    let deltaX = command2.x ?? 0;
-    let deltaY = command2.y ?? 0;
-    if (command2.direction) {
-      const amount = command2.amount ?? 100;
-      switch (command2.direction) {
+    let deltaX = command.x ?? 0;
+    let deltaY = command.y ?? 0;
+    if (command.direction) {
+      const amount = command.amount ?? 100;
+      switch (command.direction) {
         case "up":
           deltaY = -amount;
           break;
@@ -3984,236 +3984,236 @@ async function handleScroll(command2, browser2) {
           break;
       }
     }
-    await page2.evaluate(`window.scrollBy(${deltaX}, ${deltaY})`);
+    await page.evaluate(`window.scrollBy(${deltaX}, ${deltaY})`);
   }
-  return successResponse(command2.id, { scrolled: true });
+  return successResponse(command.id, { scrolled: true });
 }
-async function handleSelect(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const values = Array.isArray(command2.values) ? command2.values : [command2.values];
+async function handleSelect(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const values = Array.isArray(command.values) ? command.values : [command.values];
   try {
-    await locator2.selectOption(values);
+    await locator.selectOption(values);
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { selected: values });
+  return successResponse(command.id, { selected: values });
 }
-async function handleHover(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleHover(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.hover();
+    await locator.hover();
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { hovered: true });
+  return successResponse(command.id, { hovered: true });
 }
-async function handleContent(command2, browser2) {
-  const page2 = browser2.getPage();
+async function handleContent(command, browser) {
+  const page = browser.getPage();
   let html;
-  if (command2.selector) {
-    html = await page2.locator(command2.selector).innerHTML();
+  if (command.selector) {
+    html = await page.locator(command.selector).innerHTML();
   } else {
-    html = await page2.content();
+    html = await page.content();
   }
-  return successResponse(command2.id, { html });
+  return successResponse(command.id, { html });
 }
-async function handleClose(command2, browser2) {
-  await browser2.close();
-  return successResponse(command2.id, { closed: true });
+async function handleClose(command, browser) {
+  await browser.close();
+  return successResponse(command.id, { closed: true });
 }
-async function handleTabNew(command2, browser2) {
-  const result = await browser2.newTab();
-  if (command2.url) {
-    const page2 = browser2.getPage();
-    await page2.goto(command2.url, { waitUntil: "domcontentloaded" });
+async function handleTabNew(command, browser) {
+  const result = await browser.newTab();
+  if (command.url) {
+    const page = browser.getPage();
+    await page.goto(command.url, { waitUntil: "domcontentloaded" });
   }
-  return successResponse(command2.id, result);
+  return successResponse(command.id, result);
 }
-async function handleTabList(command2, browser2) {
-  const tabs = await browser2.listTabs();
-  return successResponse(command2.id, {
+async function handleTabList(command, browser) {
+  const tabs = await browser.listTabs();
+  return successResponse(command.id, {
     tabs,
-    active: browser2.getActiveIndex()
+    active: browser.getActiveIndex()
   });
 }
-async function handleTabSwitch(command2, browser2) {
-  const result = await browser2.switchTo(command2.index);
-  const page2 = browser2.getPage();
-  return successResponse(command2.id, {
+async function handleTabSwitch(command, browser) {
+  const result = await browser.switchTo(command.index);
+  const page = browser.getPage();
+  return successResponse(command.id, {
     ...result,
-    title: await page2.title()
+    title: await page.title()
   });
 }
-async function handleTabClose(command2, browser2) {
-  const result = await browser2.closeTab(command2.index);
-  return successResponse(command2.id, result);
+async function handleTabClose(command, browser) {
+  const result = await browser.closeTab(command.index);
+  return successResponse(command.id, result);
 }
-async function handleWindowNew(command2, browser2) {
-  const result = await browser2.newWindow(command2.viewport);
-  return successResponse(command2.id, result);
+async function handleWindowNew(command, browser) {
+  const result = await browser.newWindow(command.viewport);
+  return successResponse(command.id, result);
 }
-async function handleFill(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleFill(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.fill(command2.value);
+    await locator.fill(command.value);
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { filled: true });
+  return successResponse(command.id, { filled: true });
 }
-async function handleCheck(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleCheck(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.check();
+    await locator.check();
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { checked: true });
+  return successResponse(command.id, { checked: true });
 }
-async function handleUncheck(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleUncheck(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.uncheck();
+    await locator.uncheck();
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { unchecked: true });
+  return successResponse(command.id, { unchecked: true });
 }
-async function handleUpload(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const files = Array.isArray(command2.files) ? command2.files : [command2.files];
+async function handleUpload(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const files = Array.isArray(command.files) ? command.files : [command.files];
   try {
-    await locator2.setInputFiles(files);
+    await locator.setInputFiles(files);
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { uploaded: files });
+  return successResponse(command.id, { uploaded: files });
 }
-async function handleDoubleClick(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleDoubleClick(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.dblclick();
+    await locator.dblclick();
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { clicked: true });
+  return successResponse(command.id, { clicked: true });
 }
-async function handleFocus(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
+async function handleFocus(command, browser) {
+  const locator = browser.getLocator(command.selector);
   try {
-    await locator2.focus();
+    await locator.focus();
   } catch (error) {
-    throw toAIFriendlyError(error, command2.selector);
+    throw toAIFriendlyError(error, command.selector);
   }
-  return successResponse(command2.id, { focused: true });
+  return successResponse(command.id, { focused: true });
 }
-async function handleDrag(command2, browser2) {
-  const frame = browser2.getFrame();
-  await frame.dragAndDrop(command2.source, command2.target);
-  return successResponse(command2.id, { dragged: true });
+async function handleDrag(command, browser) {
+  const frame = browser.getFrame();
+  await frame.dragAndDrop(command.source, command.target);
+  return successResponse(command.id, { dragged: true });
 }
-async function handleFrame(command2, browser2) {
-  await browser2.switchToFrame({
-    selector: command2.selector,
-    name: command2.name,
-    url: command2.url
+async function handleFrame(command, browser) {
+  await browser.switchToFrame({
+    selector: command.selector,
+    name: command.name,
+    url: command.url
   });
-  return successResponse(command2.id, { switched: true });
+  return successResponse(command.id, { switched: true });
 }
-async function handleMainFrame(command2, browser2) {
-  browser2.switchToMainFrame();
-  return successResponse(command2.id, { switched: true });
+async function handleMainFrame(command, browser) {
+  browser.switchToMainFrame();
+  return successResponse(command.id, { switched: true });
 }
-async function handleGetByRole(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByRole(command2.role, { name: command2.name, exact: command2.exact });
-  switch (command2.subaction) {
+async function handleGetByRole(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByRole(command.role, { name: command.name, exact: command.exact });
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "fill":
-      await locator2.fill(command2.value ?? "");
-      return successResponse(command2.id, { filled: true });
+      await locator.fill(command.value ?? "");
+      return successResponse(command.id, { filled: true });
     case "check":
-      await locator2.check();
-      return successResponse(command2.id, { checked: true });
+      await locator.check();
+      return successResponse(command.id, { checked: true });
     case "hover":
-      await locator2.hover();
-      return successResponse(command2.id, { hovered: true });
+      await locator.hover();
+      return successResponse(command.id, { hovered: true });
   }
 }
-async function handleGetByText(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByText(command2.text, { exact: command2.exact });
-  switch (command2.subaction) {
+async function handleGetByText(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByText(command.text, { exact: command.exact });
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "hover":
-      await locator2.hover();
-      return successResponse(command2.id, { hovered: true });
+      await locator.hover();
+      return successResponse(command.id, { hovered: true });
   }
 }
-async function handleGetByLabel(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByLabel(command2.label, { exact: command2.exact });
-  switch (command2.subaction) {
+async function handleGetByLabel(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByLabel(command.label, { exact: command.exact });
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "fill":
-      await locator2.fill(command2.value ?? "");
-      return successResponse(command2.id, { filled: true });
+      await locator.fill(command.value ?? "");
+      return successResponse(command.id, { filled: true });
     case "check":
-      await locator2.check();
-      return successResponse(command2.id, { checked: true });
+      await locator.check();
+      return successResponse(command.id, { checked: true });
   }
 }
-async function handleGetByPlaceholder(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByPlaceholder(command2.placeholder, { exact: command2.exact });
-  switch (command2.subaction) {
+async function handleGetByPlaceholder(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByPlaceholder(command.placeholder, { exact: command.exact });
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "fill":
-      await locator2.fill(command2.value ?? "");
-      return successResponse(command2.id, { filled: true });
+      await locator.fill(command.value ?? "");
+      return successResponse(command.id, { filled: true });
   }
 }
-async function handleCookiesGet(command2, browser2) {
-  const page2 = browser2.getPage();
-  const context = page2.context();
-  const cookies = await context.cookies(command2.urls);
-  return successResponse(command2.id, { cookies });
+async function handleCookiesGet(command, browser) {
+  const page = browser.getPage();
+  const context = page.context();
+  const cookies = await context.cookies(command.urls);
+  return successResponse(command.id, { cookies });
 }
-async function handleCookiesSet(command2, browser2) {
-  const page2 = browser2.getPage();
-  const context = page2.context();
-  const pageUrl = page2.url();
-  const cookies = command2.cookies.map((cookie) => {
+async function handleCookiesSet(command, browser) {
+  const page = browser.getPage();
+  const context = page.context();
+  const pageUrl = page.url();
+  const cookies = command.cookies.map((cookie) => {
     if (!cookie.url && !cookie.domain && !cookie.path) {
       return { ...cookie, url: pageUrl };
     }
     return cookie;
   });
   await context.addCookies(cookies);
-  return successResponse(command2.id, { set: true });
+  return successResponse(command.id, { set: true });
 }
-async function handleCookiesClear(command2, browser2) {
-  const page2 = browser2.getPage();
-  const context = page2.context();
+async function handleCookiesClear(command, browser) {
+  const page = browser.getPage();
+  const context = page.context();
   await context.clearCookies();
-  return successResponse(command2.id, { cleared: true });
-}
-async function handleStorageGet(command2, browser2) {
-  const page2 = browser2.getPage();
-  const storageType = command2.type === "local" ? "localStorage" : "sessionStorage";
-  if (command2.key) {
-    const value = await page2.evaluate(`${storageType}.getItem(${JSON.stringify(command2.key)})`);
-    return successResponse(command2.id, { key: command2.key, value });
+  return successResponse(command.id, { cleared: true });
+}
+async function handleStorageGet(command, browser) {
+  const page = browser.getPage();
+  const storageType = command.type === "local" ? "localStorage" : "sessionStorage";
+  if (command.key) {
+    const value = await page.evaluate(`${storageType}.getItem(${JSON.stringify(command.key)})`);
+    return successResponse(command.id, { key: command.key, value });
   } else {
-    const data = await page2.evaluate(`
+    const data = await page.evaluate(`
       (() => {
         const storage = ${storageType};
         const result = {};
@@ -4224,102 +4224,102 @@ async function handleStorageGet(command2, browser2) {
         return result;
       })()
     `);
-    return successResponse(command2.id, { data });
+    return successResponse(command.id, { data });
   }
 }
-async function handleStorageSet(command2, browser2) {
-  const page2 = browser2.getPage();
-  const storageType = command2.type === "local" ? "localStorage" : "sessionStorage";
-  await page2.evaluate(
-    `${storageType}.setItem(${JSON.stringify(command2.key)}, ${JSON.stringify(command2.value)})`
+async function handleStorageSet(command, browser) {
+  const page = browser.getPage();
+  const storageType = command.type === "local" ? "localStorage" : "sessionStorage";
+  await page.evaluate(
+    `${storageType}.setItem(${JSON.stringify(command.key)}, ${JSON.stringify(command.value)})`
   );
-  return successResponse(command2.id, { set: true });
-}
-async function handleStorageClear(command2, browser2) {
-  const page2 = browser2.getPage();
-  const storageType = command2.type === "local" ? "localStorage" : "sessionStorage";
-  await page2.evaluate(`${storageType}.clear()`);
-  return successResponse(command2.id, { cleared: true });
-}
-async function handleDialog(command2, browser2) {
-  browser2.setDialogHandler(command2.response, command2.promptText);
-  return successResponse(command2.id, { handler: "set", response: command2.response });
-}
-async function handlePdf(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.pdf({
-    path: command2.path,
-    format: command2.format ?? "Letter"
+  return successResponse(command.id, { set: true });
+}
+async function handleStorageClear(command, browser) {
+  const page = browser.getPage();
+  const storageType = command.type === "local" ? "localStorage" : "sessionStorage";
+  await page.evaluate(`${storageType}.clear()`);
+  return successResponse(command.id, { cleared: true });
+}
+async function handleDialog(command, browser) {
+  browser.setDialogHandler(command.response, command.promptText);
+  return successResponse(command.id, { handler: "set", response: command.response });
+}
+async function handlePdf(command, browser) {
+  const page = browser.getPage();
+  await page.pdf({
+    path: command.path,
+    format: command.format ?? "Letter"
   });
-  return successResponse(command2.id, { path: command2.path });
+  return successResponse(command.id, { path: command.path });
 }
-async function handleRoute(command2, browser2) {
-  await browser2.addRoute(command2.url, {
-    response: command2.response,
-    abort: command2.abort
+async function handleRoute(command, browser) {
+  await browser.addRoute(command.url, {
+    response: command.response,
+    abort: command.abort
   });
-  return successResponse(command2.id, { routed: command2.url });
-}
-async function handleUnroute(command2, browser2) {
-  await browser2.removeRoute(command2.url);
-  return successResponse(command2.id, { unrouted: command2.url ?? "all" });
-}
-async function handleRequests(command2, browser2) {
-  if (command2.clear) {
-    browser2.clearRequests();
-    return successResponse(command2.id, { cleared: true });
-  }
-  browser2.startRequestTracking();
-  const requests = browser2.getRequests(command2.filter);
-  return successResponse(command2.id, { requests });
-}
-async function handleDownload(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = browser2.getLocator(command2.selector);
-  const [download] = await Promise.all([page2.waitForEvent("download"), locator2.click()]);
-  await download.saveAs(command2.path);
-  return successResponse(command2.id, {
-    path: command2.path,
+  return successResponse(command.id, { routed: command.url });
+}
+async function handleUnroute(command, browser) {
+  await browser.removeRoute(command.url);
+  return successResponse(command.id, { unrouted: command.url ?? "all" });
+}
+async function handleRequests(command, browser) {
+  if (command.clear) {
+    browser.clearRequests();
+    return successResponse(command.id, { cleared: true });
+  }
+  browser.startRequestTracking();
+  const requests = browser.getRequests(command.filter);
+  return successResponse(command.id, { requests });
+}
+async function handleDownload(command, browser) {
+  const page = browser.getPage();
+  const locator = browser.getLocator(command.selector);
+  const [download] = await Promise.all([page.waitForEvent("download"), locator.click()]);
+  await download.saveAs(command.path);
+  return successResponse(command.id, {
+    path: command.path,
     suggestedFilename: download.suggestedFilename()
   });
 }
-async function handleGeolocation(command2, browser2) {
-  await browser2.setGeolocation(command2.latitude, command2.longitude, command2.accuracy);
-  return successResponse(command2.id, {
-    latitude: command2.latitude,
-    longitude: command2.longitude
+async function handleGeolocation(command, browser) {
+  await browser.setGeolocation(command.latitude, command.longitude, command.accuracy);
+  return successResponse(command.id, {
+    latitude: command.latitude,
+    longitude: command.longitude
   });
 }
-async function handlePermissions(command2, browser2) {
-  await browser2.setPermissions(command2.permissions, command2.grant);
-  return successResponse(command2.id, {
-    permissions: command2.permissions,
-    granted: command2.grant
+async function handlePermissions(command, browser) {
+  await browser.setPermissions(command.permissions, command.grant);
+  return successResponse(command.id, {
+    permissions: command.permissions,
+    granted: command.grant
   });
 }
-async function handleViewport(command2, browser2) {
-  await browser2.setViewport(command2.width, command2.height);
-  return successResponse(command2.id, {
-    width: command2.width,
-    height: command2.height
+async function handleViewport(command, browser) {
+  await browser.setViewport(command.width, command.height);
+  return successResponse(command.id, {
+    width: command.width,
+    height: command.height
   });
 }
-async function handleUserAgent(command2, browser2) {
-  const page2 = browser2.getPage();
-  const context = page2.context();
-  return successResponse(command2.id, {
+async function handleUserAgent(command, browser) {
+  const page = browser.getPage();
+  const context = page.context();
+  return successResponse(command.id, {
     note: "User agent can only be set at launch time. Use device command instead."
   });
 }
-async function handleDevice(command2, browser2) {
-  const device = browser2.getDevice(command2.device);
+async function handleDevice(command, browser) {
+  const device = browser.getDevice(command.device);
   if (!device) {
-    const available = browser2.listDevices().slice(0, 10).join(", ");
-    throw new Error(`Unknown device: ${command2.device}. Available: ${available}...`);
+    const available = browser.listDevices().slice(0, 10).join(", ");
+    throw new Error(`Unknown device: ${command.device}. Available: ${available}...`);
   }
-  await browser2.setViewport(device.viewport.width, device.viewport.height);
+  await browser.setViewport(device.viewport.width, device.viewport.height);
   if (device.deviceScaleFactor && device.deviceScaleFactor !== 1) {
-    await browser2.setDeviceScaleFactor(
+    await browser.setDeviceScaleFactor(
       device.deviceScaleFactor,
       device.viewport.width,
       device.viewport.height,
@@ -4327,79 +4327,79 @@ async function handleDevice(command2, browser2) {
     );
   } else {
     try {
-      await browser2.clearDeviceMetricsOverride();
+      await browser.clearDeviceMetricsOverride();
     } catch {
     }
   }
-  return successResponse(command2.id, {
-    device: command2.device,
+  return successResponse(command.id, {
+    device: command.device,
     viewport: device.viewport,
     userAgent: device.userAgent,
     deviceScaleFactor: device.deviceScaleFactor
   });
 }
-async function handleBack(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.goBack();
-  return successResponse(command2.id, { url: page2.url() });
-}
-async function handleForward(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.goForward();
-  return successResponse(command2.id, { url: page2.url() });
-}
-async function handleReload(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.reload();
-  return successResponse(command2.id, { url: page2.url() });
-}
-async function handleUrl(command2, browser2) {
-  const page2 = browser2.getPage();
-  return successResponse(command2.id, { url: page2.url() });
-}
-async function handleTitle(command2, browser2) {
-  const page2 = browser2.getPage();
-  const title = await page2.title();
-  return successResponse(command2.id, { title });
-}
-async function handleGetAttribute(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const value = await locator2.getAttribute(command2.attribute);
-  return successResponse(command2.id, { attribute: command2.attribute, value });
-}
-async function handleGetText(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const text = await locator2.textContent();
-  return successResponse(command2.id, { text });
-}
-async function handleIsVisible(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const visible = await locator2.isVisible();
-  return successResponse(command2.id, { visible });
-}
-async function handleIsEnabled(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const enabled = await locator2.isEnabled();
-  return successResponse(command2.id, { enabled });
-}
-async function handleIsChecked(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const checked = await locator2.isChecked();
-  return successResponse(command2.id, { checked });
-}
-async function handleCount(command2, browser2) {
-  const page2 = browser2.getPage();
-  const count = await page2.locator(command2.selector).count();
-  return successResponse(command2.id, { count });
-}
-async function handleBoundingBox(command2, browser2) {
-  const page2 = browser2.getPage();
-  const box = await page2.locator(command2.selector).boundingBox();
-  return successResponse(command2.id, { box });
+async function handleBack(command, browser) {
+  const page = browser.getPage();
+  await page.goBack();
+  return successResponse(command.id, { url: page.url() });
+}
+async function handleForward(command, browser) {
+  const page = browser.getPage();
+  await page.goForward();
+  return successResponse(command.id, { url: page.url() });
+}
+async function handleReload(command, browser) {
+  const page = browser.getPage();
+  await page.reload();
+  return successResponse(command.id, { url: page.url() });
+}
+async function handleUrl(command, browser) {
+  const page = browser.getPage();
+  return successResponse(command.id, { url: page.url() });
+}
+async function handleTitle(command, browser) {
+  const page = browser.getPage();
+  const title = await page.title();
+  return successResponse(command.id, { title });
+}
+async function handleGetAttribute(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const value = await locator.getAttribute(command.attribute);
+  return successResponse(command.id, { attribute: command.attribute, value });
+}
+async function handleGetText(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const text = await locator.textContent();
+  return successResponse(command.id, { text });
+}
+async function handleIsVisible(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const visible = await locator.isVisible();
+  return successResponse(command.id, { visible });
+}
+async function handleIsEnabled(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const enabled = await locator.isEnabled();
+  return successResponse(command.id, { enabled });
+}
+async function handleIsChecked(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const checked = await locator.isChecked();
+  return successResponse(command.id, { checked });
+}
+async function handleCount(command, browser) {
+  const page = browser.getPage();
+  const count = await page.locator(command.selector).count();
+  return successResponse(command.id, { count });
+}
+async function handleBoundingBox(command, browser) {
+  const page = browser.getPage();
+  const box = await page.locator(command.selector).boundingBox();
+  return successResponse(command.id, { box });
 }
 async function handleStyles(command, browser) {
   const page = browser.getPage();
-  const extractStylesScript = `(function(el) {
+  const extractStyles = (el) => {
     const s = getComputedStyle(el);
     const r = el.getBoundingClientRect();
     return {
@@ -4409,408 +4409,424 @@ async function handleStyles(command, browser) {
         x: Math.round(r.x),
         y: Math.round(r.y),
         width: Math.round(r.width),
-        height: Math.round(r.height),
+        height: Math.round(r.height)
       },
       styles: {
         fontSize: s.fontSize,
         fontWeight: s.fontWeight,
-        fontFamily: s.fontFamily.split(',')[0].trim().replace(/"/g, ''),
+        fontFamily: s.fontFamily.split(",")[0].trim().replace(/"/g, ""),
         color: s.color,
         backgroundColor: s.backgroundColor,
         borderRadius: s.borderRadius,
-        border: s.border !== 'none' && s.borderWidth !== '0px' ? s.border : null,
-        boxShadow: s.boxShadow !== 'none' ? s.boxShadow : null,
-        padding: s.padding,
-      },
+        border: s.border !== "none" && s.borderWidth !== "0px" ? s.border : null,
+        boxShadow: s.boxShadow !== "none" ? s.boxShadow : null,
+        padding: s.padding
+      }
     };
-  })`;
+  };
   if (browser.isRef(command.selector)) {
     const locator = browser.getLocator(command.selector);
-    const element = await locator.evaluate((el, script) => {
-      const fn = eval(script);
-      return fn(el);
-    }, extractStylesScript);
+    const element = await locator.evaluate(extractStyles);
     return successResponse(command.id, { elements: [element] });
   }
-  const elements = await page.$$eval(
-    command.selector,
-    (els, script) => {
-      const fn = eval(script);
-      return els.map((el2) => fn(el2));
-    },
-    extractStylesScript
-  );
+  const elements = await page.$$eval(command.selector, (els) => {
+    return els.map((el) => {
+      const s = getComputedStyle(el);
+      const r = el.getBoundingClientRect();
+      return {
+        tag: el.tagName.toLowerCase(),
+        text: el.innerText?.trim().slice(0, 80) || null,
+        box: {
+          x: Math.round(r.x),
+          y: Math.round(r.y),
+          width: Math.round(r.width),
+          height: Math.round(r.height)
+        },
+        styles: {
+          fontSize: s.fontSize,
+          fontWeight: s.fontWeight,
+          fontFamily: s.fontFamily.split(",")[0].trim().replace(/"/g, ""),
+          color: s.color,
+          backgroundColor: s.backgroundColor,
+          borderRadius: s.borderRadius,
+          border: s.border !== "none" && s.borderWidth !== "0px" ? s.border : null,
+          boxShadow: s.boxShadow !== "none" ? s.boxShadow : null,
+          padding: s.padding
+        }
+      };
+    });
+  });
   return successResponse(command.id, { elements });
 }
-async function handleVideoStart(command2, browser2) {
-  return successResponse(command2.id, {
+async function handleVideoStart(command, browser) {
+  return successResponse(command.id, {
     note: "Video recording must be enabled at browser launch. Use --video flag when starting.",
-    path: command2.path
+    path: command.path
   });
 }
-async function handleVideoStop(command2, browser2) {
-  const page2 = browser2.getPage();
-  const video = page2.video();
+async function handleVideoStop(command, browser) {
+  const page = browser.getPage();
+  const video = page.video();
   if (video) {
     const path5 = await video.path();
-    return successResponse(command2.id, { path: path5 });
+    return successResponse(command.id, { path: path5 });
   }
-  return successResponse(command2.id, { note: "No video recording active" });
+  return successResponse(command.id, { note: "No video recording active" });
 }
-async function handleTraceStart(command2, browser2) {
-  await browser2.startTracing({
-    screenshots: command2.screenshots,
-    snapshots: command2.snapshots
+async function handleTraceStart(command, browser) {
+  await browser.startTracing({
+    screenshots: command.screenshots,
+    snapshots: command.snapshots
   });
-  return successResponse(command2.id, { started: true });
+  return successResponse(command.id, { started: true });
 }
-async function handleTraceStop(command2, browser2) {
-  await browser2.stopTracing(command2.path);
-  return successResponse(command2.id, { path: command2.path });
+async function handleTraceStop(command, browser) {
+  await browser.stopTracing(command.path);
+  return successResponse(command.id, { path: command.path });
 }
-async function handleHarStart(command2, browser2) {
-  await browser2.startHarRecording();
-  browser2.startRequestTracking();
-  return successResponse(command2.id, { started: true });
+async function handleHarStart(command, browser) {
+  await browser.startHarRecording();
+  browser.startRequestTracking();
+  return successResponse(command.id, { started: true });
 }
-async function handleHarStop(command2, browser2) {
-  const requests = browser2.getRequests();
-  return successResponse(command2.id, {
-    path: command2.path,
+async function handleHarStop(command, browser) {
+  const requests = browser.getRequests();
+  return successResponse(command.id, {
+    path: command.path,
     requestCount: requests.length
   });
 }
-async function handleStateSave(command2, browser2) {
-  await browser2.saveStorageState(command2.path);
-  return successResponse(command2.id, { path: command2.path });
+async function handleStateSave(command, browser) {
+  await browser.saveStorageState(command.path);
+  return successResponse(command.id, { path: command.path });
 }
-async function handleStateLoad(command2, browser2) {
-  return successResponse(command2.id, {
+async function handleStateLoad(command, browser) {
+  return successResponse(command.id, {
     note: "Storage state must be loaded at browser launch. Use --state flag.",
-    path: command2.path
+    path: command.path
   });
 }
-async function handleConsole(command2, browser2) {
-  if (command2.clear) {
-    browser2.clearConsoleMessages();
-    return successResponse(command2.id, { cleared: true });
+async function handleConsole(command, browser) {
+  if (command.clear) {
+    browser.clearConsoleMessages();
+    return successResponse(command.id, { cleared: true });
   }
-  const messages = browser2.getConsoleMessages();
-  return successResponse(command2.id, { messages });
+  const messages = browser.getConsoleMessages();
+  return successResponse(command.id, { messages });
 }
-async function handleErrors(command2, browser2) {
-  if (command2.clear) {
-    browser2.clearPageErrors();
-    return successResponse(command2.id, { cleared: true });
+async function handleErrors(command, browser) {
+  if (command.clear) {
+    browser.clearPageErrors();
+    return successResponse(command.id, { cleared: true });
   }
-  const errors = browser2.getPageErrors();
-  return successResponse(command2.id, { errors });
+  const errors = browser.getPageErrors();
+  return successResponse(command.id, { errors });
 }
-async function handleKeyboard(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.keyboard.press(command2.keys);
-  return successResponse(command2.id, { pressed: command2.keys });
+async function handleKeyboard(command, browser) {
+  const page = browser.getPage();
+  await page.keyboard.press(command.keys);
+  return successResponse(command.id, { pressed: command.keys });
 }
-async function handleWheel(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.selector) {
-    const element2 = page2.locator(command2.selector);
-    await element2.hover();
+async function handleWheel(command, browser) {
+  const page = browser.getPage();
+  if (command.selector) {
+    const element = page.locator(command.selector);
+    await element.hover();
   }
-  await page2.mouse.wheel(command2.deltaX ?? 0, command2.deltaY ?? 0);
-  return successResponse(command2.id, { scrolled: true });
+  await page.mouse.wheel(command.deltaX ?? 0, command.deltaY ?? 0);
+  return successResponse(command.id, { scrolled: true });
 }
-async function handleTap(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.tap(command2.selector);
-  return successResponse(command2.id, { tapped: true });
+async function handleTap(command, browser) {
+  const page = browser.getPage();
+  await page.tap(command.selector);
+  return successResponse(command.id, { tapped: true });
 }
-async function handleClipboard(command2, browser2) {
-  const page2 = browser2.getPage();
-  switch (command2.operation) {
+async function handleClipboard(command, browser) {
+  const page = browser.getPage();
+  switch (command.operation) {
     case "copy":
-      await page2.keyboard.press("Control+c");
-      return successResponse(command2.id, { copied: true });
+      await page.keyboard.press("Control+c");
+      return successResponse(command.id, { copied: true });
     case "paste":
-      await page2.keyboard.press("Control+v");
-      return successResponse(command2.id, { pasted: true });
+      await page.keyboard.press("Control+v");
+      return successResponse(command.id, { pasted: true });
     case "read":
-      const text = await page2.evaluate("navigator.clipboard.readText()");
-      return successResponse(command2.id, { text });
+      const text = await page.evaluate("navigator.clipboard.readText()");
+      return successResponse(command.id, { text });
     default:
-      return errorResponse(command2.id, "Unknown clipboard operation");
-  }
-}
-async function handleHighlight(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.locator(command2.selector).highlight();
-  return successResponse(command2.id, { highlighted: true });
-}
-async function handleClear(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.locator(command2.selector).clear();
-  return successResponse(command2.id, { cleared: true });
-}
-async function handleSelectAll(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.locator(command2.selector).selectText();
-  return successResponse(command2.id, { selected: true });
-}
-async function handleInnerText(command2, browser2) {
-  const page2 = browser2.getPage();
-  const text = await page2.locator(command2.selector).innerText();
-  return successResponse(command2.id, { text });
-}
-async function handleInnerHtml(command2, browser2) {
-  const page2 = browser2.getPage();
-  const html = await page2.locator(command2.selector).innerHTML();
-  return successResponse(command2.id, { html });
-}
-async function handleInputValue(command2, browser2) {
-  const locator2 = browser2.getLocator(command2.selector);
-  const value = await locator2.inputValue();
-  return successResponse(command2.id, { value });
-}
-async function handleSetValue(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.locator(command2.selector).fill(command2.value);
-  return successResponse(command2.id, { set: true });
-}
-async function handleDispatch(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.locator(command2.selector).dispatchEvent(command2.event, command2.eventInit);
-  return successResponse(command2.id, { dispatched: command2.event });
-}
-async function handleEvalHandle(command2, browser2) {
-  const page2 = browser2.getPage();
-  const handle = await page2.evaluateHandle(command2.script);
+      return errorResponse(command.id, "Unknown clipboard operation");
+  }
+}
+async function handleHighlight(command, browser) {
+  const page = browser.getPage();
+  await page.locator(command.selector).highlight();
+  return successResponse(command.id, { highlighted: true });
+}
+async function handleClear(command, browser) {
+  const page = browser.getPage();
+  await page.locator(command.selector).clear();
+  return successResponse(command.id, { cleared: true });
+}
+async function handleSelectAll(command, browser) {
+  const page = browser.getPage();
+  await page.locator(command.selector).selectText();
+  return successResponse(command.id, { selected: true });
+}
+async function handleInnerText(command, browser) {
+  const page = browser.getPage();
+  const text = await page.locator(command.selector).innerText();
+  return successResponse(command.id, { text });
+}
+async function handleInnerHtml(command, browser) {
+  const page = browser.getPage();
+  const html = await page.locator(command.selector).innerHTML();
+  return successResponse(command.id, { html });
+}
+async function handleInputValue(command, browser) {
+  const locator = browser.getLocator(command.selector);
+  const value = await locator.inputValue();
+  return successResponse(command.id, { value });
+}
+async function handleSetValue(command, browser) {
+  const page = browser.getPage();
+  await page.locator(command.selector).fill(command.value);
+  return successResponse(command.id, { set: true });
+}
+async function handleDispatch(command, browser) {
+  const page = browser.getPage();
+  await page.locator(command.selector).dispatchEvent(command.event, command.eventInit);
+  return successResponse(command.id, { dispatched: command.event });
+}
+async function handleEvalHandle(command, browser) {
+  const page = browser.getPage();
+  const handle = await page.evaluateHandle(command.script);
   const result = await handle.jsonValue().catch(() => "Handle (non-serializable)");
-  return successResponse(command2.id, { result });
+  return successResponse(command.id, { result });
 }
-async function handleExpose(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.exposeFunction(command2.name, () => {
-    return `Function ${command2.name} called`;
+async function handleExpose(command, browser) {
+  const page = browser.getPage();
+  await page.exposeFunction(command.name, () => {
+    return `Function ${command.name} called`;
   });
-  return successResponse(command2.id, { exposed: command2.name });
-}
-async function handleAddScript(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.content) {
-    await page2.addScriptTag({ content: command2.content });
-  } else if (command2.url) {
-    await page2.addScriptTag({ url: command2.url });
-  }
-  return successResponse(command2.id, { added: true });
-}
-async function handleAddStyle(command2, browser2) {
-  const page2 = browser2.getPage();
-  if (command2.content) {
-    await page2.addStyleTag({ content: command2.content });
-  } else if (command2.url) {
-    await page2.addStyleTag({ url: command2.url });
-  }
-  return successResponse(command2.id, { added: true });
-}
-async function handleEmulateMedia(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.emulateMedia({
-    media: command2.media,
-    colorScheme: command2.colorScheme,
-    reducedMotion: command2.reducedMotion,
-    forcedColors: command2.forcedColors
+  return successResponse(command.id, { exposed: command.name });
+}
+async function handleAddScript(command, browser) {
+  const page = browser.getPage();
+  if (command.content) {
+    await page.addScriptTag({ content: command.content });
+  } else if (command.url) {
+    await page.addScriptTag({ url: command.url });
+  }
+  return successResponse(command.id, { added: true });
+}
+async function handleAddStyle(command, browser) {
+  const page = browser.getPage();
+  if (command.content) {
+    await page.addStyleTag({ content: command.content });
+  } else if (command.url) {
+    await page.addStyleTag({ url: command.url });
+  }
+  return successResponse(command.id, { added: true });
+}
+async function handleEmulateMedia(command, browser) {
+  const page = browser.getPage();
+  await page.emulateMedia({
+    media: command.media,
+    colorScheme: command.colorScheme,
+    reducedMotion: command.reducedMotion,
+    forcedColors: command.forcedColors
   });
-  return successResponse(command2.id, { emulated: true });
+  return successResponse(command.id, { emulated: true });
 }
-async function handleOffline(command2, browser2) {
-  await browser2.setOffline(command2.offline);
-  return successResponse(command2.id, { offline: command2.offline });
+async function handleOffline(command, browser) {
+  await browser.setOffline(command.offline);
+  return successResponse(command.id, { offline: command.offline });
 }
-async function handleHeaders(command2, browser2) {
-  await browser2.setExtraHeaders(command2.headers);
-  return successResponse(command2.id, { set: true });
+async function handleHeaders(command, browser) {
+  await browser.setExtraHeaders(command.headers);
+  return successResponse(command.id, { set: true });
 }
-async function handlePause(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.pause();
-  return successResponse(command2.id, { paused: true });
+async function handlePause(command, browser) {
+  const page = browser.getPage();
+  await page.pause();
+  return successResponse(command.id, { paused: true });
 }
-async function handleGetByAltText(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByAltText(command2.text, { exact: command2.exact });
-  switch (command2.subaction) {
+async function handleGetByAltText(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByAltText(command.text, { exact: command.exact });
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "hover":
-      await locator2.hover();
-      return successResponse(command2.id, { hovered: true });
+      await locator.hover();
+      return successResponse(command.id, { hovered: true });
   }
 }
-async function handleGetByTitle(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByTitle(command2.text, { exact: command2.exact });
-  switch (command2.subaction) {
+async function handleGetByTitle(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByTitle(command.text, { exact: command.exact });
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "hover":
-      await locator2.hover();
-      return successResponse(command2.id, { hovered: true });
+      await locator.hover();
+      return successResponse(command.id, { hovered: true });
   }
 }
-async function handleGetByTestId(command2, browser2) {
-  const page2 = browser2.getPage();
-  const locator2 = page2.getByTestId(command2.testId);
-  switch (command2.subaction) {
+async function handleGetByTestId(command, browser) {
+  const page = browser.getPage();
+  const locator = page.getByTestId(command.testId);
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "fill":
-      await locator2.fill(command2.value ?? "");
-      return successResponse(command2.id, { filled: true });
+      await locator.fill(command.value ?? "");
+      return successResponse(command.id, { filled: true });
     case "check":
-      await locator2.check();
-      return successResponse(command2.id, { checked: true });
+      await locator.check();
+      return successResponse(command.id, { checked: true });
     case "hover":
-      await locator2.hover();
-      return successResponse(command2.id, { hovered: true });
+      await locator.hover();
+      return successResponse(command.id, { hovered: true });
   }
 }
-async function handleNth(command2, browser2) {
-  const page2 = browser2.getPage();
-  const base = page2.locator(command2.selector);
-  const locator2 = command2.index === -1 ? base.last() : base.nth(command2.index);
-  switch (command2.subaction) {
+async function handleNth(command, browser) {
+  const page = browser.getPage();
+  const base = page.locator(command.selector);
+  const locator = command.index === -1 ? base.last() : base.nth(command.index);
+  switch (command.subaction) {
     case "click":
-      await locator2.click();
-      return successResponse(command2.id, { clicked: true });
+      await locator.click();
+      return successResponse(command.id, { clicked: true });
     case "fill":
-      await locator2.fill(command2.value ?? "");
-      return successResponse(command2.id, { filled: true });
+      await locator.fill(command.value ?? "");
+      return successResponse(command.id, { filled: true });
     case "check":
-      await locator2.check();
-      return successResponse(command2.id, { checked: true });
+      await locator.check();
+      return successResponse(command.id, { checked: true });
     case "hover":
-      await locator2.hover();
-      return successResponse(command2.id, { hovered: true });
+      await locator.hover();
+      return successResponse(command.id, { hovered: true });
     case "text":
-      const text = await locator2.textContent();
-      return successResponse(command2.id, { text });
+      const text = await locator.textContent();
+      return successResponse(command.id, { text });
   }
 }
-async function handleWaitForUrl(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.waitForURL(command2.url, { timeout: command2.timeout });
-  return successResponse(command2.id, { url: page2.url() });
+async function handleWaitForUrl(command, browser) {
+  const page = browser.getPage();
+  await page.waitForURL(command.url, { timeout: command.timeout });
+  return successResponse(command.id, { url: page.url() });
 }
-async function handleWaitForLoadState(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.waitForLoadState(command2.state, { timeout: command2.timeout });
-  return successResponse(command2.id, { state: command2.state });
+async function handleWaitForLoadState(command, browser) {
+  const page = browser.getPage();
+  await page.waitForLoadState(command.state, { timeout: command.timeout });
+  return successResponse(command.id, { state: command.state });
 }
-async function handleSetContent(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.setContent(command2.html);
-  return successResponse(command2.id, { set: true });
+async function handleSetContent(command, browser) {
+  const page = browser.getPage();
+  await page.setContent(command.html);
+  return successResponse(command.id, { set: true });
 }
-async function handleTimezone(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.context().setGeolocation({ latitude: 0, longitude: 0 });
-  return successResponse(command2.id, {
+async function handleTimezone(command, browser) {
+  const page = browser.getPage();
+  await page.context().setGeolocation({ latitude: 0, longitude: 0 });
+  return successResponse(command.id, {
     note: "Timezone must be set at browser launch. Use --timezone flag.",
-    timezone: command2.timezone
+    timezone: command.timezone
   });
 }
-async function handleLocale(command2, browser2) {
-  return successResponse(command2.id, {
+async function handleLocale(command, browser) {
+  return successResponse(command.id, {
     note: "Locale must be set at browser launch. Use --locale flag.",
-    locale: command2.locale
+    locale: command.locale
   });
 }
-async function handleCredentials(command2, browser2) {
-  const context = browser2.getPage().context();
+async function handleCredentials(command, browser) {
+  const context = browser.getPage().context();
   await context.setHTTPCredentials({
-    username: command2.username,
-    password: command2.password
+    username: command.username,
+    password: command.password
   });
-  return successResponse(command2.id, { set: true });
-}
-async function handleMouseMove(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.mouse.move(command2.x, command2.y);
-  return successResponse(command2.id, { moved: true, x: command2.x, y: command2.y });
-}
-async function handleMouseDown(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.mouse.down({ button: command2.button ?? "left" });
-  return successResponse(command2.id, { down: true });
-}
-async function handleMouseUp(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.mouse.up({ button: command2.button ?? "left" });
-  return successResponse(command2.id, { up: true });
-}
-async function handleBringToFront(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.bringToFront();
-  return successResponse(command2.id, { focused: true });
-}
-async function handleWaitForFunction(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.waitForFunction(command2.expression, { timeout: command2.timeout });
-  return successResponse(command2.id, { waited: true });
-}
-async function handleScrollIntoView(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.locator(command2.selector).scrollIntoViewIfNeeded();
-  return successResponse(command2.id, { scrolled: true });
-}
-async function handleAddInitScript(command2, browser2) {
-  const context = browser2.getPage().context();
-  await context.addInitScript(command2.script);
-  return successResponse(command2.id, { added: true });
-}
-async function handleKeyDown(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.keyboard.down(command2.key);
-  return successResponse(command2.id, { down: true, key: command2.key });
-}
-async function handleKeyUp(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.keyboard.up(command2.key);
-  return successResponse(command2.id, { up: true, key: command2.key });
-}
-async function handleInsertText(command2, browser2) {
-  const page2 = browser2.getPage();
-  await page2.keyboard.insertText(command2.text);
-  return successResponse(command2.id, { inserted: true });
-}
-async function handleMultiSelect(command2, browser2) {
-  const page2 = browser2.getPage();
-  const selected = await page2.locator(command2.selector).selectOption(command2.values);
-  return successResponse(command2.id, { selected });
-}
-async function handleWaitForDownload(command2, browser2) {
-  const page2 = browser2.getPage();
-  const download = await page2.waitForEvent("download", { timeout: command2.timeout });
+  return successResponse(command.id, { set: true });
+}
+async function handleMouseMove(command, browser) {
+  const page = browser.getPage();
+  await page.mouse.move(command.x, command.y);
+  return successResponse(command.id, { moved: true, x: command.x, y: command.y });
+}
+async function handleMouseDown(command, browser) {
+  const page = browser.getPage();
+  await page.mouse.down({ button: command.button ?? "left" });
+  return successResponse(command.id, { down: true });
+}
+async function handleMouseUp(command, browser) {
+  const page = browser.getPage();
+  await page.mouse.up({ button: command.button ?? "left" });
+  return successResponse(command.id, { up: true });
+}
+async function handleBringToFront(command, browser) {
+  const page = browser.getPage();
+  await page.bringToFront();
+  return successResponse(command.id, { focused: true });
+}
+async function handleWaitForFunction(command, browser) {
+  const page = browser.getPage();
+  await page.waitForFunction(command.expression, { timeout: command.timeout });
+  return successResponse(command.id, { waited: true });
+}
+async function handleScrollIntoView(command, browser) {
+  const page = browser.getPage();
+  await page.locator(command.selector).scrollIntoViewIfNeeded();
+  return successResponse(command.id, { scrolled: true });
+}
+async function handleAddInitScript(command, browser) {
+  const context = browser.getPage().context();
+  await context.addInitScript(command.script);
+  return successResponse(command.id, { added: true });
+}
+async function handleKeyDown(command, browser) {
+  const page = browser.getPage();
+  await page.keyboard.down(command.key);
+  return successResponse(command.id, { down: true, key: command.key });
+}
+async function handleKeyUp(command, browser) {
+  const page = browser.getPage();
+  await page.keyboard.up(command.key);
+  return successResponse(command.id, { up: true, key: command.key });
+}
+async function handleInsertText(command, browser) {
+  const page = browser.getPage();
+  await page.keyboard.insertText(command.text);
+  return successResponse(command.id, { inserted: true });
+}
+async function handleMultiSelect(command, browser) {
+  const page = browser.getPage();
+  const selected = await page.locator(command.selector).selectOption(command.values);
+  return successResponse(command.id, { selected });
+}
+async function handleWaitForDownload(command, browser) {
+  const page = browser.getPage();
+  const download = await page.waitForEvent("download", { timeout: command.timeout });
   let filePath;
-  if (command2.path) {
-    filePath = command2.path;
+  if (command.path) {
+    filePath = command.path;
     await download.saveAs(filePath);
   } else {
     filePath = await download.path() || download.suggestedFilename();
   }
-  return successResponse(command2.id, {
+  return successResponse(command.id, {
     path: filePath,
     filename: download.suggestedFilename(),
     url: download.url()
   });
 }
-async function handleResponseBody(command2, browser2) {
-  const page2 = browser2.getPage();
-  const response = await page2.waitForResponse((resp) => resp.url().includes(command2.url), {
-    timeout: command2.timeout
+async function handleResponseBody(command, browser) {
+  const page = browser.getPage();
+  const response = await page.waitForResponse((resp) => resp.url().includes(command.url), {
+    timeout: command.timeout
   });
   const body = await response.text();
   let parsed = body;
@@ -4818,80 +4834,80 @@ async function handleResponseBody(command2, browser2) {
     parsed = JSON.parse(body);
   } catch {
   }
-  return successResponse(command2.id, {
+  return successResponse(command.id, {
     url: response.url(),
     status: response.status(),
     body: parsed
   });
 }
-async function handleScreencastStart(command2, browser2) {
+async function handleScreencastStart(command, browser) {
   if (!screencastFrameCallback) {
     throw new Error("Screencast frame callback not set. Start the streaming server first.");
   }
-  await browser2.startScreencast(screencastFrameCallback, {
-    format: command2.format,
-    quality: command2.quality,
-    maxWidth: command2.maxWidth,
-    maxHeight: command2.maxHeight,
-    everyNthFrame: command2.everyNthFrame
+  await browser.startScreencast(screencastFrameCallback, {
+    format: command.format,
+    quality: command.quality,
+    maxWidth: command.maxWidth,
+    maxHeight: command.maxHeight,
+    everyNthFrame: command.everyNthFrame
   });
-  return successResponse(command2.id, {
+  return successResponse(command.id, {
     started: true,
-    format: command2.format ?? "jpeg",
-    quality: command2.quality ?? 80
+    format: command.format ?? "jpeg",
+    quality: command.quality ?? 80
   });
 }
-async function handleScreencastStop(command2, browser2) {
-  await browser2.stopScreencast();
-  return successResponse(command2.id, { stopped: true });
-}
-async function handleInputMouse(command2, browser2) {
-  await browser2.injectMouseEvent({
-    type: command2.type,
-    x: command2.x,
-    y: command2.y,
-    button: command2.button,
-    clickCount: command2.clickCount,
-    deltaX: command2.deltaX,
-    deltaY: command2.deltaY,
-    modifiers: command2.modifiers
+async function handleScreencastStop(command, browser) {
+  await browser.stopScreencast();
+  return successResponse(command.id, { stopped: true });
+}
+async function handleInputMouse(command, browser) {
+  await browser.injectMouseEvent({
+    type: command.type,
+    x: command.x,
+    y: command.y,
+    button: command.button,
+    clickCount: command.clickCount,
+    deltaX: command.deltaX,
+    deltaY: command.deltaY,
+    modifiers: command.modifiers
   });
-  return successResponse(command2.id, { injected: true });
-}
-async function handleInputKeyboard(command2, browser2) {
-  await browser2.injectKeyboardEvent({
-    type: command2.type,
-    key: command2.key,
-    code: command2.code,
-    text: command2.text,
-    modifiers: command2.modifiers
+  return successResponse(command.id, { injected: true });
+}
+async function handleInputKeyboard(command, browser) {
+  await browser.injectKeyboardEvent({
+    type: command.type,
+    key: command.key,
+    code: command.code,
+    text: command.text,
+    modifiers: command.modifiers
   });
-  return successResponse(command2.id, { injected: true });
+  return successResponse(command.id, { injected: true });
 }
-async function handleInputTouch(command2, browser2) {
-  await browser2.injectTouchEvent({
-    type: command2.type,
-    touchPoints: command2.touchPoints,
-    modifiers: command2.modifiers
+async function handleInputTouch(command, browser) {
+  await browser.injectTouchEvent({
+    type: command.type,
+    touchPoints: command.touchPoints,
+    modifiers: command.modifiers
   });
-  return successResponse(command2.id, { injected: true });
+  return successResponse(command.id, { injected: true });
 }
-async function handleRecordingStart(command2, browser2) {
-  await browser2.startRecording(command2.path, command2.url);
-  return successResponse(command2.id, {
+async function handleRecordingStart(command, browser) {
+  await browser.startRecording(command.path, command.url);
+  return successResponse(command.id, {
     started: true,
-    path: command2.path
+    path: command.path
   });
 }
-async function handleRecordingStop(command2, browser2) {
-  const result = await browser2.stopRecording();
-  return successResponse(command2.id, result);
+async function handleRecordingStop(command, browser) {
+  const result = await browser.stopRecording();
+  return successResponse(command.id, result);
 }
-async function handleRecordingRestart(command2, browser2) {
-  const result = await browser2.restartRecording(command2.path, command2.url);
-  return successResponse(command2.id, {
+async function handleRecordingRestart(command, browser) {
+  const result = await browser.restartRecording(command.path, command.url);
+  return successResponse(command.id, {
     started: true,
-    path: command2.path,
+    path: command.path,
     previousPath: result.previousPath,
     stopped: result.stopped
   });
@@ -4904,12 +4920,12 @@ function successResponse2(id, data) {
 function errorResponse2(id, error) {
   return { id, success: false, error };
 }
-async function executeIOSCommand(command2, manager) {
-  const { id, action } = command2;
+async function executeIOSCommand(command, manager) {
+  const { id, action } = command;
   try {
     switch (action) {
       case "launch": {
-        const cmd = command2;
+        const cmd = command;
         await manager.launch({
           device: cmd.device,
           udid: cmd.udid
@@ -4922,22 +4938,22 @@ async function executeIOSCommand(command2, manager) {
         });
       }
       case "navigate": {
-        const cmd = command2;
+        const cmd = command;
         const result = await manager.navigate(cmd.url);
         return successResponse2(id, result);
       }
       case "click": {
-        const cmd = command2;
+        const cmd = command;
         await manager.click(cmd.selector);
         return successResponse2(id, { clicked: true });
       }
       case "tap": {
-        const cmd = command2;
+        const cmd = command;
         await manager.tap(cmd.selector);
         return successResponse2(id, { tapped: true });
       }
       case "type": {
-        const cmd = command2;
+        const cmd = command;
         await manager.type(cmd.selector, cmd.text, {
           delay: cmd.delay,
           clear: cmd.clear
@@ -4945,12 +4961,12 @@ async function executeIOSCommand(command2, manager) {
         return successResponse2(id, { typed: true });
       }
       case "fill": {
-        const cmd = command2;
+        const cmd = command;
         await manager.fill(cmd.selector, cmd.value);
         return successResponse2(id, { filled: true });
       }
       case "screenshot": {
-        const cmd = command2;
+        const cmd = command;
         const result = await manager.screenshot({
           path: cmd.path,
           fullPage: cmd.fullPage
@@ -4958,14 +4974,14 @@ async function executeIOSCommand(command2, manager) {
         return successResponse2(id, result);
       }
       case "snapshot": {
-        const cmd = command2;
+        const cmd = command;
         const result = await manager.getSnapshot({
           interactive: cmd.interactive
         });
         return successResponse2(id, { snapshot: result.tree, refs: result.refs });
       }
       case "scroll": {
-        const cmd = command2;
+        const cmd = command;
         await manager.scroll({
           selector: cmd.selector,
           x: cmd.x,
@@ -4976,17 +4992,17 @@ async function executeIOSCommand(command2, manager) {
         return successResponse2(id, { scrolled: true });
       }
       case "swipe": {
-        const cmd = command2;
+        const cmd = command;
         await manager.swipe(cmd.direction, { distance: cmd.distance });
         return successResponse2(id, { swiped: true });
       }
       case "evaluate": {
-        const cmd = command2;
+        const cmd = command;
         const result = await manager.evaluate(cmd.script, ...cmd.args ?? []);
         return successResponse2(id, { result });
       }
       case "wait": {
-        const cmd = command2;
+        const cmd = command;
         await manager.wait({
           selector: cmd.selector,
           timeout: cmd.timeout,
@@ -4995,37 +5011,37 @@ async function executeIOSCommand(command2, manager) {
         return successResponse2(id, { waited: true });
       }
       case "press": {
-        const cmd = command2;
+        const cmd = command;
         await manager.press(cmd.key);
         return successResponse2(id, { pressed: true });
       }
       case "hover": {
-        const cmd = command2;
+        const cmd = command;
         await manager.hover(cmd.selector);
         return successResponse2(id, { hovered: true });
       }
       case "content": {
-        const cmd = command2;
+        const cmd = command;
         const html = await manager.getContent(cmd.selector);
         return successResponse2(id, { html });
       }
       case "gettext": {
-        const cmd = command2;
+        const cmd = command;
         const text = await manager.getText(cmd.selector);
         return successResponse2(id, { text });
       }
       case "getattribute": {
-        const cmd = command2;
+        const cmd = command;
         const value = await manager.getAttribute(cmd.selector, cmd.attribute);
         return successResponse2(id, { value });
       }
       case "isvisible": {
-        const cmd = command2;
+        const cmd = command;
         const visible = await manager.isVisible(cmd.selector);
         return successResponse2(id, { visible });
       }
       case "isenabled": {
-        const cmd = command2;
+        const cmd = command;
         const enabled = await manager.isEnabled(cmd.selector);
         return successResponse2(id, { enabled });
       }
@@ -5050,37 +5066,37 @@ async function executeIOSCommand(command2, manager) {
         return successResponse2(id, { reloaded: true });
       }
       case "select": {
-        const cmd = command2;
+        const cmd = command;
         await manager.select(cmd.selector, cmd.values);
         return successResponse2(id, { selected: true });
       }
       case "check": {
-        const cmd = command2;
+        const cmd = command;
         await manager.check(cmd.selector);
         return successResponse2(id, { checked: true });
       }
       case "uncheck": {
-        const cmd = command2;
+        const cmd = command;
         await manager.uncheck(cmd.selector);
         return successResponse2(id, { unchecked: true });
       }
       case "focus": {
-        const cmd = command2;
+        const cmd = command;
         await manager.focus(cmd.selector);
         return successResponse2(id, { focused: true });
       }
       case "clear": {
-        const cmd = command2;
+        const cmd = command;
         await manager.clear(cmd.selector);
         return successResponse2(id, { cleared: true });
       }
       case "count": {
-        const cmd = command2;
+        const cmd = command;
         const count = await manager.count(cmd.selector);
         return successResponse2(id, { count });
       }
       case "boundingbox": {
-        const cmd = command2;
+        const cmd = command;
         const box = await manager.getBoundingBox(cmd.selector);
         return successResponse2(id, { box });
       }
@@ -5146,8 +5162,8 @@ var StreamServer = class {
   browser;
   port;
   isScreencasting = false;
-  constructor(browser2, port = 9223) {
-    this.browser = browser2;
+  constructor(browser, port = 9223) {
+    this.browser = browser;
     this.port = port;
   }
   /**
@@ -5310,8 +5326,8 @@ var StreamServer = class {
     let viewportWidth;
     let viewportHeight;
     try {
-      const page2 = this.browser.getPage();
-      const viewport = page2.viewportSize();
+      const page = this.browser.getPage();
+      const viewport = page.viewportSize();
       viewportWidth = viewport?.width;
       viewportHeight = viewport?.height;
     } catch {