@midscene/web 0.9.2 → 0.10.0

package/dist/lib/chrome-extension.js

@@ -1618,6 +1618,9 @@ var ChromeExtensionProxyPageAgent = class extends PageAgent {
   }
 };
 
+// src/chrome-extension/page.ts
+var import_node_assert4 = __toESM(require("assert"));
+
 // src/chrome-extension/cdpInput.ts
 var import_node_assert3 = __toESM(require("assert"));
 
@@ -2203,9 +2206,12 @@ var ChromeExtensionProxyPage = class {
   constructor(trackingActiveTab) {
     this.pageType = "chrome-extension-proxy";
     this.activeTabId = null;
+    this.tabIdOfDebuggerAttached = null;
     this.attachingDebugger = null;
+    this.destroyed = false;
     this.mouse = {
       click: async (x, y) => {
+        await this.showMousePointer(x, y);
         await this.sendCommandToDebugger("Input.dispatchMouseEvent", {
           type: "mousePressed",
           x,
@@ -2222,15 +2228,19 @@ var ChromeExtensionProxyPage = class {
         });
       },
       wheel: async (deltaX, deltaY, startX, startY) => {
+        const finalX = startX || 50;
+        const finalY = startY || 50;
+        await this.showMousePointer(finalX, finalY);
         await this.sendCommandToDebugger("Input.dispatchMouseEvent", {
           type: "mouseWheel",
-          x: startX || 10,
-          y: startY || 10,
+          x: finalX,
+          y: finalY,
           deltaX,
           deltaY
         });
       },
       move: async (x, y) => {
+        await this.showMousePointer(x, y);
         await this.sendCommandToDebugger("Input.dispatchMouseEvent", {
           type: "mouseMoved",
           x,
@@ -2255,8 +2265,7 @@ var ChromeExtensionProxyPage = class {
     this.trackingActiveTab = trackingActiveTab;
   }
   async getTabId() {
-    const trackingActiveTab = this.trackingActiveTab();
-    if (this.activeTabId && !trackingActiveTab) {
+    if (this.activeTabId && !this.trackingActiveTab) {
       return this.activeTabId;
     }
     const tabId = await chrome.tabs.query({ active: true, currentWindow: true }).then((tabs) => {
@@ -2267,6 +2276,7 @@ var ChromeExtensionProxyPage = class {
     return this.activeTabId;
   }
   async attachDebugger() {
+    (0, import_node_assert4.default)(!this.destroyed, "Page is destroyed");
     if (this.attachingDebugger) {
       await this.attachingDebugger;
       return;
@@ -2280,52 +2290,89 @@ var ChromeExtensionProxyPage = class {
       }
       try {
         const currentTabId = await this.getTabId();
-        const targets = await chrome.debugger.getTargets();
-        const target = targets.find(
-          (target2) => target2.tabId === currentTabId && target2.attached === true
-        );
-        if (!target) {
-          await chrome.debugger.attach({ tabId: currentTabId }, "1.3");
-          await sleep2(340);
+        if (this.tabIdOfDebuggerAttached === currentTabId) {
+          return;
         }
+        if (this.tabIdOfDebuggerAttached && this.tabIdOfDebuggerAttached !== currentTabId) {
+          console.log(
+            "detach the previous tab",
+            this.tabIdOfDebuggerAttached,
+            "->",
+            currentTabId
+          );
+          try {
+            await this.detachDebugger(this.tabIdOfDebuggerAttached);
+          } catch (error) {
+            console.error("Failed to detach debugger", error);
+          }
+        }
+        await chrome.debugger.attach({ tabId: currentTabId }, "1.3");
+        await sleep2(500);
+        this.tabIdOfDebuggerAttached = currentTabId;
+        await this.enableWaterFlowAnimation();
+      } catch (error) {
+        console.error("Failed to attach debugger", error);
       } finally {
         this.attachingDebugger = null;
       }
     })();
     await this.attachingDebugger;
   }
-  async enableWaterFlowAnimation(tabId) {
-    const script = await injectWaterFlowAnimation();
-    await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
-      expression: script
+  async showMousePointer(x, y) {
+    const pointerScript = `(() => {
+      if(typeof window.midsceneWaterFlowAnimation !== 'undefined') {
+        window.midsceneWaterFlowAnimation.enable();
+        window.midsceneWaterFlowAnimation.showMousePointer(${x}, ${y});
+      } else {
+        console.log('midsceneWaterFlowAnimation is not defined');
+      }
+    })()`;
+    await this.sendCommandToDebugger("Runtime.evaluate", {
+      expression: `${pointerScript}`
+    });
+  }
+  async hideMousePointer() {
+    await this.sendCommandToDebugger("Runtime.evaluate", {
+      expression: `(() => {
+        if(typeof window.midsceneWaterFlowAnimation !== 'undefined') {
+          window.midsceneWaterFlowAnimation.hideMousePointer();
+        }
+      })()`
     });
   }
+  async detachDebugger(tabId) {
+    const tabIdToDetach = tabId || this.tabIdOfDebuggerAttached;
+    if (!tabIdToDetach) {
+      console.warn("No tab id to detach");
+      return;
+    }
+    await this.disableWaterFlowAnimation(tabIdToDetach);
+    await sleep2(200);
+    await chrome.debugger.detach({ tabId: tabIdToDetach });
+    this.tabIdOfDebuggerAttached = null;
+  }
+  async enableWaterFlowAnimation() {
+    const script = await injectWaterFlowAnimation();
+    await chrome.debugger.sendCommand(
+      { tabId: this.tabIdOfDebuggerAttached },
+      "Runtime.evaluate",
+      {
+        expression: script
+      }
+    );
+  }
   async disableWaterFlowAnimation(tabId) {
     const script = await injectStopWaterFlowAnimation();
     await chrome.debugger.sendCommand({ tabId }, "Runtime.evaluate", {
       expression: script
     });
   }
-  async detachDebugger() {
-    const targets = await chrome.debugger.getTargets();
-    const attendTabs = targets.filter(
-      (target) => target.attached === true && !target.url.startsWith("chrome-extension://")
-    );
-    if (attendTabs.length > 0) {
-      for (const tab of attendTabs) {
-        if (tab.tabId) {
-          await this.disableWaterFlowAnimation(tab.tabId);
-          chrome.debugger.detach({ tabId: tab.tabId });
-        }
-      }
-    }
-  }
   async sendCommandToDebugger(command, params) {
     await this.attachDebugger();
-    const tabId = await this.getTabId();
-    this.enableWaterFlowAnimation(tabId);
+    (0, import_node_assert4.default)(this.tabIdOfDebuggerAttached, "Debugger is not attached");
+    this.enableWaterFlowAnimation();
     return await chrome.debugger.sendCommand(
-      { tabId },
+      { tabId: this.tabIdOfDebuggerAttached },
       command,
       params
     );
@@ -2382,6 +2429,7 @@ var ChromeExtensionProxyPage = class {
     );
   }
   async getElementInfos() {
+    await this.hideMousePointer();
     const content = await this.getPageContentByCDP();
     if (content == null ? void 0 : content.size) {
       this.viewportSize = content.size;
@@ -2395,6 +2443,7 @@ var ChromeExtensionProxyPage = class {
     return content.size;
   }
   async screenshotBase64() {
+    await this.hideMousePointer();
     const base64 = await this.sendCommandToDebugger("Page.captureScreenshot", {
       format: "jpeg",
       quality: 70
@@ -2494,6 +2543,7 @@ var ChromeExtensionProxyPage = class {
   async destroy() {
     this.activeTabId = null;
     await this.detachDebugger();
+    this.destroyed = true;
   }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/dist/lib/index.js

@@ -1845,61 +1845,53 @@ var Page = class {
     }
     await this.keyboard.press("Backspace");
   }
-  async scrollUntilTop(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
+  async moveToPoint(point) {
+    if (point) {
+      await this.mouse.move(point.left, point.top);
+    } else {
+      const size = await this.size();
+      await this.mouse.move(size.width / 2, size.height / 2);
     }
+  }
+  async scrollUntilTop(startingPoint) {
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(0, -9999999);
   }
   async scrollUntilBottom(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(0, 9999999);
   }
   async scrollUntilLeft(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(-9999999, 0);
   }
   async scrollUntilRight(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(9999999, 0);
   }
   async scrollUp(distance, startingPoint) {
     const innerHeight = await this.evaluate(() => window.innerHeight);
     const scrollDistance = distance || innerHeight * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(0, -scrollDistance);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(0, -scrollDistance);
   }
   async scrollDown(distance, startingPoint) {
     const innerHeight = await this.evaluate(() => window.innerHeight);
     const scrollDistance = distance || innerHeight * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(0, scrollDistance);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(0, scrollDistance);
   }
   async scrollLeft(distance, startingPoint) {
     const innerWidth = await this.evaluate(() => window.innerWidth);
     const scrollDistance = distance || innerWidth * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(-scrollDistance, 0);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(-scrollDistance, 0);
   }
   async scrollRight(distance, startingPoint) {
     const innerWidth = await this.evaluate(() => window.innerWidth);
     const scrollDistance = distance || innerWidth * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(scrollDistance, 0);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(scrollDistance, 0);
   }
   async destroy() {
   }

package/dist/lib/playwright.js

@@ -1839,61 +1839,53 @@ var Page = class {
     }
     await this.keyboard.press("Backspace");
   }
-  async scrollUntilTop(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
+  async moveToPoint(point) {
+    if (point) {
+      await this.mouse.move(point.left, point.top);
+    } else {
+      const size = await this.size();
+      await this.mouse.move(size.width / 2, size.height / 2);
     }
+  }
+  async scrollUntilTop(startingPoint) {
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(0, -9999999);
   }
   async scrollUntilBottom(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(0, 9999999);
   }
   async scrollUntilLeft(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(-9999999, 0);
   }
   async scrollUntilRight(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(9999999, 0);
   }
   async scrollUp(distance, startingPoint) {
     const innerHeight = await this.evaluate(() => window.innerHeight);
     const scrollDistance = distance || innerHeight * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(0, -scrollDistance);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(0, -scrollDistance);
   }
   async scrollDown(distance, startingPoint) {
     const innerHeight = await this.evaluate(() => window.innerHeight);
     const scrollDistance = distance || innerHeight * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(0, scrollDistance);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(0, scrollDistance);
   }
   async scrollLeft(distance, startingPoint) {
     const innerWidth = await this.evaluate(() => window.innerWidth);
     const scrollDistance = distance || innerWidth * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(-scrollDistance, 0);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(-scrollDistance, 0);
   }
   async scrollRight(distance, startingPoint) {
     const innerWidth = await this.evaluate(() => window.innerWidth);
     const scrollDistance = distance || innerWidth * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(scrollDistance, 0);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(scrollDistance, 0);
   }
   async destroy() {
   }

package/dist/lib/puppeteer.js

@@ -1684,61 +1684,53 @@ var Page = class {
     }
     await this.keyboard.press("Backspace");
   }
-  async scrollUntilTop(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
+  async moveToPoint(point) {
+    if (point) {
+      await this.mouse.move(point.left, point.top);
+    } else {
+      const size = await this.size();
+      await this.mouse.move(size.width / 2, size.height / 2);
     }
+  }
+  async scrollUntilTop(startingPoint) {
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(0, -9999999);
   }
   async scrollUntilBottom(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(0, 9999999);
   }
   async scrollUntilLeft(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(-9999999, 0);
   }
   async scrollUntilRight(startingPoint) {
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
+    await this.moveToPoint(startingPoint);
     return this.mouse.wheel(9999999, 0);
   }
   async scrollUp(distance, startingPoint) {
     const innerHeight = await this.evaluate(() => window.innerHeight);
     const scrollDistance = distance || innerHeight * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(0, -scrollDistance);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(0, -scrollDistance);
   }
   async scrollDown(distance, startingPoint) {
     const innerHeight = await this.evaluate(() => window.innerHeight);
     const scrollDistance = distance || innerHeight * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(0, scrollDistance);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(0, scrollDistance);
   }
   async scrollLeft(distance, startingPoint) {
     const innerWidth = await this.evaluate(() => window.innerWidth);
     const scrollDistance = distance || innerWidth * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(-scrollDistance, 0);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(-scrollDistance, 0);
   }
   async scrollRight(distance, startingPoint) {
     const innerWidth = await this.evaluate(() => window.innerWidth);
     const scrollDistance = distance || innerWidth * 0.7;
-    if (startingPoint) {
-      await this.mouse.move(startingPoint.left, startingPoint.top);
-    }
-    await this.mouse.wheel(scrollDistance, 0);
+    await this.moveToPoint(startingPoint);
+    return this.mouse.wheel(scrollDistance, 0);
   }
   async destroy() {
   }

package/dist/types/appium.d.ts

@@ -1,6 +1,6 @@
-export { P as AppiumAgent } from './tasks-07be2324.js';
-export { P as AppiumPage } from './page-29b209ea.js';
-import '@midscene/core/dist/lib/types/types-c4bec333';
+export { P as AppiumAgent } from './tasks-54dbbfb4.js';
+export { P as AppiumPage } from './page-a1d76532.js';
+import '@midscene/core/dist/lib/types/types-64c4d87b';
 import '@midscene/core';
 import '@midscene/core/ai-model';
 import '@midscene/shared/fs';

package/dist/types/bridge-mode-browser.d.ts

@@ -1,32 +1,8 @@
-import { C as ChromeExtensionProxyPage } from './page-29b209ea.js';
+export { C as ChromeExtensionPageBrowserSide } from './browser-d3c008c0.js';
+import './page-a1d76532.js';
 import 'playwright';
 import '@midscene/core';
 import 'puppeteer';
 import '@midscene/shared/constants';
-import '@midscene/core/dist/lib/types/types-c4bec333';
+import '@midscene/core/dist/lib/types/types-64c4d87b';
 import 'webdriverio';
-
-declare class BridgeClient {
-    endpoint: string;
-    onBridgeCall: (method: string, args: any[]) => Promise<any>;
-    onDisconnect?: (() => void) | undefined;
-    private socket;
-    serverVersion: string | null;
-    constructor(endpoint: string, onBridgeCall: (method: string, args: any[]) => Promise<any>, onDisconnect?: (() => void) | undefined);
-    connect(): Promise<unknown>;
-    disconnect(): void;
-}
-
-declare class ChromeExtensionPageBrowserSide extends ChromeExtensionProxyPage {
-    onDisconnect: () => void;
-    onLogMessage: (message: string, type: 'log' | 'status') => void;
-    bridgeClient: BridgeClient | null;
-    constructor(onDisconnect?: () => void, onLogMessage?: (message: string, type: 'log' | 'status') => void);
-    private setupBridgeClient;
-    connect(): Promise<void>;
-    connectNewTabWithUrl(url: string): Promise<void>;
-    connectCurrentTab(): Promise<void>;
-    destroy(): Promise<void>;
-}
-
-export { ChromeExtensionPageBrowserSide };

package/dist/types/bridge-mode.d.ts

@@ -1,7 +1,7 @@
-import { P as PageAgent } from './tasks-07be2324.js';
-import { ChromeExtensionPageBrowserSide } from './bridge-mode-browser.js';
-import '@midscene/core/dist/lib/types/types-c4bec333';
-import './page-29b209ea.js';
+import { P as PageAgent } from './tasks-54dbbfb4.js';
+import { B as BridgeConnectTabOptions, C as ChromeExtensionPageBrowserSide } from './browser-d3c008c0.js';
+import '@midscene/core/dist/lib/types/types-64c4d87b';
+import './page-a1d76532.js';
 import 'playwright';
 import '@midscene/core';
 import 'puppeteer';
@@ -15,8 +15,8 @@ interface ChromeExtensionPageCliSide extends ChromeExtensionPageBrowserSide {
 }
 declare class AgentOverChromeBridge extends PageAgent<ChromeExtensionPageCliSide> {
     constructor();
-    connectNewTabWithUrl(url: string): Promise<void>;
-    connectCurrentTab(): Promise<void>;
+    connectNewTabWithUrl(url: string, options?: BridgeConnectTabOptions): Promise<void>;
+    connectCurrentTab(options?: BridgeConnectTabOptions): Promise<void>;
     aiAction(prompt: string, options?: any): Promise<void>;
 }
 

package/dist/types/browser-d3c008c0.d.ts

@@ -0,0 +1,34 @@
+import { C as ChromeExtensionProxyPage } from './page-a1d76532.js';
+
+interface BridgeConnectTabOptions {
+    /**
+     * If true, the page will always track the active tab.
+     * @default false
+     */
+    trackingActiveTab?: boolean;
+}
+
+declare class BridgeClient {
+    endpoint: string;
+    onBridgeCall: (method: string, args: any[]) => Promise<any>;
+    onDisconnect?: (() => void) | undefined;
+    private socket;
+    serverVersion: string | null;
+    constructor(endpoint: string, onBridgeCall: (method: string, args: any[]) => Promise<any>, onDisconnect?: (() => void) | undefined);
+    connect(): Promise<unknown>;
+    disconnect(): void;
+}
+
+declare class ChromeExtensionPageBrowserSide extends ChromeExtensionProxyPage {
+    onDisconnect: () => void;
+    onLogMessage: (message: string, type: 'log' | 'status') => void;
+    bridgeClient: BridgeClient | null;
+    constructor(onDisconnect?: () => void, onLogMessage?: (message: string, type: 'log' | 'status') => void, trackingActiveTab?: boolean);
+    private setupBridgeClient;
+    connect(): Promise<void>;
+    connectNewTabWithUrl(url: string, options?: BridgeConnectTabOptions): Promise<void>;
+    connectCurrentTab(options?: BridgeConnectTabOptions): Promise<void>;
+    destroy(): Promise<void>;
+}
+
+export { type BridgeConnectTabOptions as B, ChromeExtensionPageBrowserSide as C };

package/dist/types/chrome-extension.d.ts

@@ -1,11 +1,11 @@
-import { C as ChromeExtensionProxyPage } from './page-29b209ea.js';
-export { a as ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED } from './page-29b209ea.js';
-import { P as PageAgent } from './tasks-07be2324.js';
+import { C as ChromeExtensionProxyPage } from './page-a1d76532.js';
+export { a as ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED } from './page-a1d76532.js';
+import { P as PageAgent } from './tasks-54dbbfb4.js';
 import 'playwright';
 import '@midscene/core';
 import 'puppeteer';
 import '@midscene/shared/constants';
-import '@midscene/core/dist/lib/types/types-c4bec333';
+import '@midscene/core/dist/lib/types/types-64c4d87b';
 import 'webdriverio';
 import '@midscene/core/ai-model';
 import '@midscene/shared/fs';

package/dist/types/debug.d.ts

@@ -1,10 +1,10 @@
 import { writeFileSync } from 'node:fs';
-import { W as WebPage, E as ElementInfo } from './page-29b209ea.js';
+import { W as WebPage, E as ElementInfo } from './page-a1d76532.js';
 import 'playwright';
 import '@midscene/core';
 import 'puppeteer';
 import '@midscene/shared/constants';
-import '@midscene/core/dist/lib/types/types-c4bec333';
+import '@midscene/core/dist/lib/types/types-64c4d87b';
 import 'webdriverio';
 
 declare function generateExtractData(page: WebPage, targetDir: string, saveImgType?: {

package/dist/types/index.d.ts

@@ -1,15 +1,15 @@
 export { PlayWrightAiFixtureType, PlaywrightAiFixture } from './playwright.js';
-export { P as AppiumAgent, P as PlaywrightAgent } from './tasks-07be2324.js';
-export { P as AppiumPage } from './page-29b209ea.js';
+export { P as AppiumAgent, P as PlaywrightAgent } from './tasks-54dbbfb4.js';
+export { P as AppiumPage } from './page-a1d76532.js';
 export { StaticPageAgent } from './playground.js';
 export { PuppeteerAgent } from './puppeteer.js';
 export { generateExtractData } from './debug.js';
-export { S as ScriptPlayer, f as flowItemBrief, p as parseYamlScript } from './utils-d3597829.js';
+export { S as ScriptPlayer, f as flowItemBrief, p as parseYamlScript } from './utils-7a58a29c.js';
 import '@midscene/core';
 import '@playwright/test';
 import 'playwright';
 import '@midscene/core/env';
-import '@midscene/core/dist/lib/types/types-c4bec333';
+import '@midscene/core/dist/lib/types/types-64c4d87b';
 import '@midscene/core/ai-model';
 import '@midscene/shared/fs';
 import 'puppeteer';

package/dist/types/{page-29b209ea.d.ts → page-a1d76532.d.ts}

@@ -2,7 +2,7 @@ import { Page as Page$3 } from 'playwright';
 import { BaseElement, Rect, UIContext, PlaywrightParserOpt, Size, Point } from '@midscene/core';
 import { KeyInput, Page as Page$2 } from 'puppeteer';
 import { NodeType } from '@midscene/shared/constants';
-import * as _midscene_core_dist_lib_types_types_c4bec333 from '@midscene/core/dist/lib/types/types-c4bec333';
+import * as _midscene_core_dist_lib_types_types_64c4d87b from '@midscene/core/dist/lib/types/types-64c4d87b';
 import { Browser } from 'webdriverio';
 
 declare class WebElementInfo implements BaseElement {
@@ -143,16 +143,20 @@ declare class Page$1 implements AbstractPage {
 
 declare class ChromeExtensionProxyPage implements AbstractPage {
     pageType: string;
-    trackingActiveTab: () => boolean;
+    trackingActiveTab: boolean;
     private viewportSize?;
     private activeTabId;
+    private tabIdOfDebuggerAttached;
     private attachingDebugger;
-    constructor(trackingActiveTab: () => boolean);
+    private destroyed;
+    constructor(trackingActiveTab: boolean);
     getTabId(): Promise<number>;
     private attachDebugger;
+    private showMousePointer;
+    private hideMousePointer;
+    private detachDebugger;
     private enableWaterFlowAnimation;
     private disableWaterFlowAnimation;
-    private detachDebugger;
     private sendCommandToDebugger;
     private getPageContentByCDP;
     waitUntilNetworkIdle(): Promise<void>;
@@ -186,7 +190,7 @@ declare class StaticPage implements AbstractPage {
     private uiContext;
     constructor(uiContext: WebUIContext);
     getElementInfos(): Promise<any>;
-    size(): Promise<_midscene_core_dist_lib_types_types_c4bec333.S>;
+    size(): Promise<_midscene_core_dist_lib_types_types_64c4d87b.S>;
     screenshotBase64(): Promise<string>;
     url(): Promise<string>;
     scrollUntilTop(startingPoint?: Point): Promise<any>;
@@ -235,6 +239,7 @@ declare class Page<AgentType extends 'puppeteer' | 'playwright', PageType extend
         up: (key: WebKeyInput) => Promise<void>;
     };
     clearInput(element: ElementInfo): Promise<void>;
+    private moveToPoint;
     scrollUntilTop(startingPoint?: Point): Promise<void>;
     scrollUntilBottom(startingPoint?: Point): Promise<void>;
     scrollUntilLeft(startingPoint?: Point): Promise<void>;