@midscene/web 0.7.1 → 0.7.2-beta-20241024094141.0

package/dist/lib/playwright.js

@@ -46,6 +46,26 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
 
 // ../../node_modules/.pnpm/dayjs@1.11.11/node_modules/dayjs/dayjs.min.js
 var require_dayjs_min = __commonJS({
@@ -352,32 +372,32 @@ __export(playwright_exports, {
 module.exports = __toCommonJS(playwright_exports);
 
 // src/playwright/ai-fixture.ts
-var import_node_crypto2 = require("crypto");
+var import_node_crypto = require("crypto");
 
 // src/common/agent.ts
-var import_utils5 = require("@midscene/core/utils");
+var import_utils7 = require("@midscene/core/utils");
 
 // src/common/tasks.ts
 var import_node_assert2 = __toESM(require("assert"));
 var import_core = require("@midscene/core");
-var import_utils3 = require("@midscene/core/utils");
-var import_img3 = require("@midscene/shared/img");
+var import_utils5 = require("@midscene/core/utils");
 
 // src/common/task-cache.ts
 var import_node_fs2 = require("fs");
 var import_node_path2 = require("path");
-var import_utils = require("@midscene/core/utils");
+var import_utils2 = require("@midscene/core/utils");
 var import_fs2 = require("@midscene/shared/fs");
+var import_utils3 = require("@midscene/shared/utils");
 
 // src/common/utils.ts
 var import_node_assert = __toESM(require("assert"));
-var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
 var import_node_path = __toESM(require("path"));
 var import_constants = require("@midscene/shared/constants");
 var import_fs = require("@midscene/shared/fs");
 var import_img = require("@midscene/shared/img");
 var import_img2 = require("@midscene/shared/img");
+var import_utils = require("@midscene/shared/utils");
 var import_dayjs = __toESM(require_dayjs_min());
 
 // src/web-element.ts
@@ -406,63 +426,68 @@ var WebElementInfo = class {
 };
 
 // src/common/utils.ts
-async function parseContextFromWebPage(page, _opt) {
-  (0, import_node_assert.default)(page, "page is required");
-  if (page._forceUsePageContext) {
-    return await page._forceUsePageContext();
-  }
-  const url = page.url();
-  const file = await page.screenshot();
-  const screenshotBase64 = (0, import_img.base64Encoded)(file);
-  const captureElementSnapshot = await page.getElementInfos();
-  const elementsInfo = await alignElements(captureElementSnapshot, page);
-  const elementsPositionInfoWithoutText = elementsInfo.filter((elementInfo) => {
-    if (elementInfo.attributes.nodeType === import_constants.NodeType.TEXT) {
-      return false;
+function parseContextFromWebPage(page, _opt) {
+  return __async(this, null, function* () {
+    (0, import_node_assert.default)(page, "page is required");
+    if (page._forceUsePageContext) {
+      return yield page._forceUsePageContext();
     }
-    return true;
-  });
-  const size = await (0, import_img.imageInfoOfBase64)(screenshotBase64);
-  const screenshotBase64WithElementMarker = await (0, import_img2.compositeElementInfoImg)({
-    inputImgBase64: screenshotBase64.split(";base64,").pop(),
-    elementsPositionInfo: elementsPositionInfoWithoutText
+    const url = page.url();
+    const screenshotBase64 = yield page.screenshotBase64();
+    const captureElementSnapshot = yield page.getElementInfos();
+    const elementsInfo = yield alignElements(captureElementSnapshot, page);
+    const elementsPositionInfoWithoutText = elementsInfo.filter((elementInfo) => {
+      if (elementInfo.attributes.nodeType === import_constants.NodeType.TEXT) {
+        return false;
+      }
+      return true;
+    });
+    const size = yield (0, import_img.imageInfoOfBase64)(screenshotBase64);
+    const screenshotBase64WithElementMarker = yield (0, import_img2.compositeElementInfoImg)({
+      inputImgBase64: screenshotBase64,
+      elementsPositionInfo: elementsPositionInfoWithoutText
+    });
+    return {
+      content: elementsInfo,
+      size,
+      screenshotBase64,
+      screenshotBase64WithElementMarker: `data:image/png;base64,${screenshotBase64WithElementMarker}`,
+      url
+    };
   });
-  return {
-    content: elementsInfo,
-    size,
-    screenshotBase64,
-    screenshotBase64WithElementMarker: `data:image/png;base64,${screenshotBase64WithElementMarker}`,
-    url
-  };
 }
-async function getExtraReturnLogic() {
-  const pathDir = (0, import_fs.findNearestPackageJson)(__dirname);
-  (0, import_node_assert.default)(pathDir, `can't find pathDir, with ${__dirname}`);
-  const scriptPath = import_node_path.default.join(pathDir, "./dist/script/htmlElement.js");
-  const elementInfosScriptContent = (0, import_node_fs.readFileSync)(scriptPath, "utf-8");
-  return `${elementInfosScriptContent}midscene_element_inspector.webExtractTextWithPosition()`;
+function getExtraReturnLogic() {
+  return __async(this, null, function* () {
+    const pathDir = (0, import_fs.findNearestPackageJson)(__dirname);
+    (0, import_node_assert.default)(pathDir, `can't find pathDir, with ${__dirname}`);
+    const scriptPath = import_node_path.default.join(pathDir, "./dist/script/htmlElement.js");
+    const elementInfosScriptContent = (0, import_node_fs.readFileSync)(scriptPath, "utf-8");
+    return `${elementInfosScriptContent}midscene_element_inspector.webExtractTextWithPosition()`;
+  });
 }
 var sizeThreshold = 3;
-async function alignElements(elements, page) {
-  const validElements = elements.filter((item) => {
-    return item.rect.height >= sizeThreshold && item.rect.width >= sizeThreshold;
+function alignElements(elements, page) {
+  return __async(this, null, function* () {
+    const validElements = elements.filter((item) => {
+      return item.rect.height >= sizeThreshold && item.rect.width >= sizeThreshold;
+    });
+    const textsAligned = [];
+    for (const item of validElements) {
+      const { rect, id, content, attributes, locator, indexId } = item;
+      textsAligned.push(
+        new WebElementInfo({
+          rect,
+          locator,
+          id,
+          content,
+          attributes,
+          page,
+          indexId
+        })
+      );
+    }
+    return textsAligned;
   });
-  const textsAligned = [];
-  for (const item of validElements) {
-    const { rect, id, content, attributes, locator, indexId } = item;
-    textsAligned.push(
-      new WebElementInfo({
-        rect,
-        locator,
-        id,
-        content,
-        attributes,
-        page,
-        indexId
-      })
-    );
-  }
-  return textsAligned;
 }
 function reportFileName(tag = "web") {
   const dateTimeInFileName = (0, import_dayjs.default)().format("YYYY-MM-DD_HH-mm-ss-SSS");
@@ -493,7 +518,7 @@ var testFileIndex = /* @__PURE__ */ new Map();
 function generateCacheId(fileName) {
   let taskFile = fileName || getCurrentExecutionFile();
   if (!taskFile) {
-    taskFile = (0, import_node_crypto.randomUUID)();
+    taskFile = (0, import_utils.uuid)();
     console.warn(
       "Midscene - using random UUID for cache id. Cache may be invalid."
     );
@@ -512,7 +537,7 @@ function generateCacheId(fileName) {
 // src/common/task-cache.ts
 var TaskCache = class {
   constructor(opts) {
-    this.midscenePkgInfo = (0, import_fs2.getMidscenePkgInfo)(__dirname);
+    this.midscenePkgInfo = (0, import_fs2.getRunningPkgInfo)();
     this.cacheId = generateCacheId(opts == null ? void 0 : opts.fileName);
     this.cache = this.readCacheFromFile() || {
       aiTasks: []
@@ -594,11 +619,17 @@ var TaskCache = class {
     return this.newCache;
   }
   readCacheFromFile() {
-    const cacheFile = (0, import_node_path2.join)((0, import_utils.getLogDirByType)("cache"), `${this.cacheId}.json`);
+    if (import_utils3.ifInBrowser) {
+      return void 0;
+    }
+    const cacheFile = (0, import_node_path2.join)((0, import_utils2.getLogDirByType)("cache"), `${this.cacheId}.json`);
     if (process.env.MIDSCENE_CACHE === "true" && (0, import_node_fs2.existsSync)(cacheFile)) {
       try {
         const data = (0, import_node_fs2.readFileSync)(cacheFile, "utf8");
         const jsonData = JSON.parse(data);
+        if (!this.midscenePkgInfo) {
+          return void 0;
+        }
         if (jsonData.pkgName !== this.midscenePkgInfo.name || jsonData.pkgVersion !== this.midscenePkgInfo.version) {
           return void 0;
         }
@@ -610,11 +641,14 @@ var TaskCache = class {
     return void 0;
   }
   writeCacheToFile() {
-    const midscenePkgInfo = (0, import_fs2.getMidscenePkgInfo)(__dirname);
-    (0, import_utils.writeLogFile)({
+    const midscenePkgInfo = (0, import_fs2.getRunningPkgInfo)();
+    if (!midscenePkgInfo) {
+      return;
+    }
+    (0, import_utils2.writeLogFile)({
       fileName: `${this.cacheId}`,
       fileExt: "json",
-      fileContent: (0, import_utils.stringifyDumpData)(
+      fileContent: (0, import_utils2.stringifyDumpData)(
         __spreadValues({
           pkgName: midscenePkgInfo.name,
           pkgVersion: midscenePkgInfo.version,
@@ -631,423 +665,435 @@ var TaskCache = class {
 var PageTaskExecutor = class {
   constructor(page, opts) {
     this.page = page;
-    this.insight = new import_core.Insight(async () => {
-      return await parseContextFromWebPage(page);
-    });
+    this.insight = new import_core.Insight(() => __async(this, null, function* () {
+      return yield parseContextFromWebPage(page);
+    }));
     this.taskCache = new TaskCache({
       fileName: opts == null ? void 0 : opts.cacheId
     });
   }
-  async recordScreenshot(timing) {
-    const file = await this.page.screenshot();
-    const item = {
-      type: "screenshot",
-      ts: Date.now(),
-      screenshot: (0, import_img3.base64Encoded)(file),
-      timing
-    };
-    return item;
+  recordScreenshot(timing) {
+    return __async(this, null, function* () {
+      const base64 = yield this.page.screenshotBase64();
+      const item = {
+        type: "screenshot",
+        ts: Date.now(),
+        screenshot: base64,
+        timing
+      };
+      return item;
+    });
   }
   wrapExecutorWithScreenshot(taskApply) {
     const taskWithScreenshot = __spreadProps(__spreadValues({}, taskApply), {
-      executor: async (param, context, ...args) => {
+      executor: (param, context, ...args) => __async(this, null, function* () {
         const recorder = [];
         const { task } = context;
         task.recorder = recorder;
-        const shot = await this.recordScreenshot(`before ${task.type}`);
+        const shot = yield this.recordScreenshot(`before ${task.type}`);
         recorder.push(shot);
-        const result = await taskApply.executor(param, context, ...args);
+        const result = yield taskApply.executor(param, context, ...args);
         if (taskApply.type === "Action") {
-          await (0, import_utils3.sleep)(1e3);
-          const shot2 = await this.recordScreenshot("after Action");
+          yield (0, import_utils5.sleep)(1e3);
+          const shot2 = yield this.recordScreenshot("after Action");
           recorder.push(shot2);
         }
         return result;
-      }
+      })
     });
     return taskWithScreenshot;
   }
-  async convertPlanToExecutable(plans, cacheGroup) {
-    const tasks = plans.map((plan2) => {
-      if (plan2.type === "Locate") {
-        const taskFind = {
-          type: "Insight",
-          subType: "Locate",
-          param: plan2.param,
-          executor: async (param, taskContext) => {
-            const { task } = taskContext;
-            let insightDump;
-            const dumpCollector = (dump) => {
-              insightDump = dump;
-            };
-            this.insight.onceDumpUpdatedFn = dumpCollector;
-            const pageContext = await this.insight.contextRetrieverFn();
-            const locateCache = cacheGroup == null ? void 0 : cacheGroup.readCache(
-              pageContext,
-              "locate",
-              param.prompt
-            );
-            let locateResult;
-            const callAI = this.insight.aiVendorFn;
-            const element = await this.insight.locate(param.prompt, {
-              quickAnswer: plan2.quickAnswer,
-              callAI: async (...message) => {
-                if (locateCache) {
-                  locateResult = locateCache;
-                  return Promise.resolve(locateCache);
-                }
-                locateResult = await callAI(...message);
-                (0, import_node_assert2.default)(locateResult);
-                return locateResult;
-              }
-            });
-            if (locateResult) {
-              cacheGroup == null ? void 0 : cacheGroup.saveCache({
-                type: "locate",
-                pageContext: {
-                  url: pageContext.url,
-                  size: pageContext.size
-                },
-                prompt: param.prompt,
-                response: locateResult
-              });
-            }
-            if (!element) {
-              task.log = {
-                dump: insightDump
+  convertPlanToExecutable(plans, cacheGroup) {
+    return __async(this, null, function* () {
+      const tasks = plans.map((plan2) => {
+        if (plan2.type === "Locate") {
+          const taskFind = {
+            type: "Insight",
+            subType: "Locate",
+            param: plan2.param,
+            executor: (param, taskContext) => __async(this, null, function* () {
+              const { task } = taskContext;
+              let insightDump;
+              const dumpCollector = (dump) => {
+                insightDump = dump;
               };
-              throw new Error(`Element not found: ${param.prompt}`);
-            }
-            return {
-              output: {
-                element
-              },
-              log: {
-                dump: insightDump
-              },
-              cache: {
-                hit: Boolean(locateCache)
+              this.insight.onceDumpUpdatedFn = dumpCollector;
+              const pageContext = yield this.insight.contextRetrieverFn();
+              const locateCache = cacheGroup == null ? void 0 : cacheGroup.readCache(
+                pageContext,
+                "locate",
+                param.prompt
+              );
+              let locateResult;
+              const callAI = this.insight.aiVendorFn;
+              const element = yield this.insight.locate(param.prompt, {
+                quickAnswer: plan2.quickAnswer,
+                callAI: (...message) => __async(this, null, function* () {
+                  if (locateCache) {
+                    locateResult = locateCache;
+                    return Promise.resolve(locateCache);
+                  }
+                  locateResult = yield callAI(...message);
+                  (0, import_node_assert2.default)(locateResult);
+                  return locateResult;
+                })
+              });
+              if (locateResult) {
+                cacheGroup == null ? void 0 : cacheGroup.saveCache({
+                  type: "locate",
+                  pageContext: {
+                    url: pageContext.url,
+                    size: pageContext.size
+                  },
+                  prompt: param.prompt,
+                  response: locateResult
+                });
               }
-            };
-          }
-        };
-        return taskFind;
-      }
-      if (plan2.type === "Assert" || plan2.type === "AssertWithoutThrow") {
-        const assertPlan = plan2;
-        const taskAssert = {
-          type: "Insight",
-          subType: "Assert",
-          param: assertPlan.param,
-          executor: async (param, taskContext) => {
-            const { task } = taskContext;
-            let insightDump;
-            const dumpCollector = (dump) => {
-              insightDump = dump;
-            };
-            this.insight.onceDumpUpdatedFn = dumpCollector;
-            const assertion = await this.insight.assert(
-              assertPlan.param.assertion
-            );
-            if (!assertion.pass) {
-              if (plan2.type === "Assert") {
-                task.output = assertion;
+              if (!element) {
                 task.log = {
                   dump: insightDump
                 };
-                throw new Error(
-                  assertion.thought || "Assertion failed without reason"
-                );
+                throw new Error(`Element not found: ${param.prompt}`);
               }
-              task.error = assertion.thought;
-            }
-            return {
-              output: assertion,
-              log: {
-                dump: insightDump
+              return {
+                output: {
+                  element
+                },
+                log: {
+                  dump: insightDump
+                },
+                cache: {
+                  hit: Boolean(locateCache)
+                }
+              };
+            })
+          };
+          return taskFind;
+        }
+        if (plan2.type === "Assert" || plan2.type === "AssertWithoutThrow") {
+          const assertPlan = plan2;
+          const taskAssert = {
+            type: "Insight",
+            subType: "Assert",
+            param: assertPlan.param,
+            executor: (param, taskContext) => __async(this, null, function* () {
+              const { task } = taskContext;
+              let insightDump;
+              const dumpCollector = (dump) => {
+                insightDump = dump;
+              };
+              this.insight.onceDumpUpdatedFn = dumpCollector;
+              const assertion = yield this.insight.assert(
+                assertPlan.param.assertion
+              );
+              if (!assertion.pass) {
+                if (plan2.type === "Assert") {
+                  task.output = assertion;
+                  task.log = {
+                    dump: insightDump
+                  };
+                  throw new Error(
+                    assertion.thought || "Assertion failed without reason"
+                  );
+                }
+                task.error = assertion.thought;
               }
-            };
-          }
-        };
-        return taskAssert;
-      }
-      if (plan2.type === "Input") {
-        const taskActionInput = {
-          type: "Action",
-          subType: "Input",
-          param: plan2.param,
-          executor: async (taskParam, { element }) => {
-            if (element) {
-              await this.page.clearInput(element);
-              if (taskParam.value === "") {
-                return;
+              return {
+                output: assertion,
+                log: {
+                  dump: insightDump
+                }
+              };
+            })
+          };
+          return taskAssert;
+        }
+        if (plan2.type === "Input") {
+          const taskActionInput = {
+            type: "Action",
+            subType: "Input",
+            param: plan2.param,
+            executor: (_0, _1) => __async(this, [_0, _1], function* (taskParam, { element }) {
+              if (element) {
+                yield this.page.clearInput(element);
+                if (taskParam.value === "") {
+                  return;
+                }
+                yield this.page.keyboard.type(taskParam.value);
               }
-              await this.page.keyboard.type(taskParam.value);
-            }
-          }
-        };
-        return taskActionInput;
-      }
-      if (plan2.type === "KeyboardPress") {
-        const taskActionKeyboardPress = {
-          type: "Action",
-          subType: "KeyboardPress",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            (0, import_node_assert2.default)(taskParam.value, "No key to press");
-            await this.page.keyboard.press(taskParam.value);
-          }
-        };
-        return taskActionKeyboardPress;
-      }
-      if (plan2.type === "Tap") {
-        const taskActionTap = {
-          type: "Action",
-          subType: "Tap",
-          executor: async (param, { element }) => {
-            (0, import_node_assert2.default)(element, "Element not found, cannot tap");
-            await this.page.mouse.click(
-              element.center[0],
-              element.center[1]
-            );
-          }
-        };
-        return taskActionTap;
-      }
-      if (plan2.type === "Hover") {
-        const taskActionHover = {
-          type: "Action",
-          subType: "Hover",
-          executor: async (param, { element }) => {
-            (0, import_node_assert2.default)(element, "Element not found, cannot hover");
-            await this.page.mouse.move(
-              element.center[0],
-              element.center[1]
-            );
-          }
-        };
-        return taskActionHover;
-      }
-      if (plan2.type === "Scroll") {
-        const taskActionScroll = {
-          type: "Action",
-          subType: "Scroll",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            const scrollToEventName = taskParam.scrollType;
-            switch (scrollToEventName) {
-              case "scrollUntilTop":
-                await this.page.scrollUntilTop();
-                break;
-              case "scrollUntilBottom":
-                await this.page.scrollUntilBottom();
-                break;
-              case "scrollUpOneScreen":
-                await this.page.scrollUpOneScreen();
-                break;
-              case "scrollDownOneScreen":
-                await this.page.scrollDownOneScreen();
-                break;
-              default:
-                console.error(
-                  "Unknown scroll event type:",
-                  scrollToEventName
-                );
-            }
-          }
-        };
-        return taskActionScroll;
-      }
-      if (plan2.type === "Sleep") {
-        const taskActionSleep = {
-          type: "Action",
-          subType: "Sleep",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            await (0, import_utils3.sleep)(taskParam.timeMs || 3e3);
-          }
-        };
-        return taskActionSleep;
-      }
-      if (plan2.type === "Error") {
-        const taskActionError = {
-          type: "Action",
-          subType: "Error",
-          param: plan2.param,
-          executor: async (taskParam) => {
-            (0, import_node_assert2.default)(
-              taskParam.thought,
-              "An error occurred, but no thought provided"
-            );
-            throw new Error(taskParam.thought);
-          }
-        };
-        return taskActionError;
-      }
-      throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
-    }).map((task) => {
-      return this.wrapExecutorWithScreenshot(task);
+            })
+          };
+          return taskActionInput;
+        }
+        if (plan2.type === "KeyboardPress") {
+          const taskActionKeyboardPress = {
+            type: "Action",
+            subType: "KeyboardPress",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              (0, import_node_assert2.default)(taskParam.value, "No key to press");
+              yield this.page.keyboard.press(taskParam.value);
+            })
+          };
+          return taskActionKeyboardPress;
+        }
+        if (plan2.type === "Tap") {
+          const taskActionTap = {
+            type: "Action",
+            subType: "Tap",
+            executor: (_0, _1) => __async(this, [_0, _1], function* (param, { element }) {
+              (0, import_node_assert2.default)(element, "Element not found, cannot tap");
+              yield this.page.mouse.click(
+                element.center[0],
+                element.center[1]
+              );
+            })
+          };
+          return taskActionTap;
+        }
+        if (plan2.type === "Hover") {
+          const taskActionHover = {
+            type: "Action",
+            subType: "Hover",
+            executor: (_0, _1) => __async(this, [_0, _1], function* (param, { element }) {
+              (0, import_node_assert2.default)(element, "Element not found, cannot hover");
+              yield this.page.mouse.move(
+                element.center[0],
+                element.center[1]
+              );
+            })
+          };
+          return taskActionHover;
+        }
+        if (plan2.type === "Scroll") {
+          const taskActionScroll = {
+            type: "Action",
+            subType: "Scroll",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              const scrollToEventName = taskParam.scrollType;
+              switch (scrollToEventName) {
+                case "scrollUntilTop":
+                  yield this.page.scrollUntilTop();
+                  break;
+                case "scrollUntilBottom":
+                  yield this.page.scrollUntilBottom();
+                  break;
+                case "scrollUpOneScreen":
+                  yield this.page.scrollUpOneScreen();
+                  break;
+                case "scrollDownOneScreen":
+                  yield this.page.scrollDownOneScreen();
+                  break;
+                default:
+                  console.error(
+                    "Unknown scroll event type:",
+                    scrollToEventName
+                  );
+              }
+            })
+          };
+          return taskActionScroll;
+        }
+        if (plan2.type === "Sleep") {
+          const taskActionSleep = {
+            type: "Action",
+            subType: "Sleep",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              yield (0, import_utils5.sleep)(taskParam.timeMs || 3e3);
+            })
+          };
+          return taskActionSleep;
+        }
+        if (plan2.type === "Error") {
+          const taskActionError = {
+            type: "Action",
+            subType: "Error",
+            param: plan2.param,
+            executor: (taskParam) => __async(this, null, function* () {
+              (0, import_node_assert2.default)(
+                taskParam.thought,
+                "An error occurred, but no thought provided"
+              );
+              throw new Error(taskParam.thought);
+            })
+          };
+          return taskActionError;
+        }
+        throw new Error(`Unknown or Unsupported task type: ${plan2.type}`);
+      }).map((task) => {
+        return this.wrapExecutorWithScreenshot(task);
+      });
+      return tasks;
     });
-    return tasks;
   }
-  async action(userPrompt) {
-    const taskExecutor = new import_core.Executor(userPrompt);
-    const cacheGroup = this.taskCache.getCacheGroupByPrompt(userPrompt);
-    let plans = [];
-    const planningTask = {
-      type: "Planning",
-      param: {
-        userPrompt
-      },
-      executor: async (param) => {
-        const pageContext = await this.insight.contextRetrieverFn();
-        let planResult;
-        const planCache = cacheGroup.readCache(pageContext, "plan", userPrompt);
-        if (planCache) {
-          planResult = planCache;
-        } else {
-          planResult = await (0, import_core.plan)(param.userPrompt, {
-            context: pageContext
+  action(userPrompt) {
+    return __async(this, null, function* () {
+      const taskExecutor = new import_core.Executor(userPrompt);
+      const cacheGroup = this.taskCache.getCacheGroupByPrompt(userPrompt);
+      let plans = [];
+      const planningTask = {
+        type: "Planning",
+        param: {
+          userPrompt
+        },
+        executor: (param) => __async(this, null, function* () {
+          const pageContext = yield this.insight.contextRetrieverFn();
+          let planResult;
+          const planCache = cacheGroup.readCache(pageContext, "plan", userPrompt);
+          if (planCache) {
+            planResult = planCache;
+          } else {
+            planResult = yield (0, import_core.plan)(param.userPrompt, {
+              context: pageContext
+            });
+          }
+          (0, import_node_assert2.default)(planResult.plans.length > 0, "No plans found");
+          plans = planResult.plans;
+          cacheGroup.saveCache({
+            type: "plan",
+            pageContext: {
+              url: pageContext.url,
+              size: pageContext.size
+            },
+            prompt: userPrompt,
+            response: planResult
           });
-        }
-        (0, import_node_assert2.default)(planResult.plans.length > 0, "No plans found");
-        plans = planResult.plans;
-        cacheGroup.saveCache({
-          type: "plan",
-          pageContext: {
-            url: pageContext.url,
-            size: pageContext.size
-          },
-          prompt: userPrompt,
-          response: planResult
-        });
+          return {
+            output: planResult,
+            cache: {
+              hit: Boolean(planCache)
+            }
+          };
+        })
+      };
+      yield taskExecutor.append(this.wrapExecutorWithScreenshot(planningTask));
+      let output = yield taskExecutor.flush();
+      if (taskExecutor.isInErrorState()) {
         return {
-          output: planResult,
-          cache: {
-            hit: Boolean(planCache)
-          }
+          output,
+          executor: taskExecutor
         };
       }
-    };
-    await taskExecutor.append(this.wrapExecutorWithScreenshot(planningTask));
-    let output = await taskExecutor.flush();
-    if (taskExecutor.isInErrorState()) {
+      const executables = yield this.convertPlanToExecutable(plans, cacheGroup);
+      yield taskExecutor.append(executables);
+      output = yield taskExecutor.flush();
       return {
         output,
         executor: taskExecutor
       };
-    }
-    const executables = await this.convertPlanToExecutable(plans, cacheGroup);
-    await taskExecutor.append(executables);
-    output = await taskExecutor.flush();
-    return {
-      output,
-      executor: taskExecutor
-    };
-  }
-  async query(demand) {
-    const description = typeof demand === "string" ? demand : JSON.stringify(demand);
-    const taskExecutor = new import_core.Executor(description);
-    const queryTask = {
-      type: "Insight",
-      subType: "Query",
-      param: {
-        dataDemand: demand
-      },
-      executor: async (param) => {
-        let insightDump;
-        const dumpCollector = (dump) => {
-          insightDump = dump;
-        };
-        this.insight.onceDumpUpdatedFn = dumpCollector;
-        const data = await this.insight.extract(param.dataDemand);
-        return {
-          output: data,
-          log: { dump: insightDump }
-        };
-      }
-    };
-    await taskExecutor.append(this.wrapExecutorWithScreenshot(queryTask));
-    const output = await taskExecutor.flush();
-    return {
-      output,
-      executor: taskExecutor
-    };
+    });
   }
-  async assert(assertion) {
-    const description = `assert: ${assertion}`;
-    const taskExecutor = new import_core.Executor(description);
-    const assertionPlan = {
-      type: "Assert",
-      param: {
-        assertion
-      }
-    };
-    const assertTask = await this.convertPlanToExecutable([assertionPlan]);
-    await taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
-    const output = await taskExecutor.flush();
-    return {
-      output,
-      executor: taskExecutor
-    };
+  query(demand) {
+    return __async(this, null, function* () {
+      const description = typeof demand === "string" ? demand : JSON.stringify(demand);
+      const taskExecutor = new import_core.Executor(description);
+      const queryTask = {
+        type: "Insight",
+        subType: "Query",
+        param: {
+          dataDemand: demand
+        },
+        executor: (param) => __async(this, null, function* () {
+          let insightDump;
+          const dumpCollector = (dump) => {
+            insightDump = dump;
+          };
+          this.insight.onceDumpUpdatedFn = dumpCollector;
+          const data = yield this.insight.extract(param.dataDemand);
+          return {
+            output: data,
+            log: { dump: insightDump }
+          };
+        })
+      };
+      yield taskExecutor.append(this.wrapExecutorWithScreenshot(queryTask));
+      const output = yield taskExecutor.flush();
+      return {
+        output,
+        executor: taskExecutor
+      };
+    });
   }
-  async waitFor(assertion, opt) {
-    const description = `waitFor: ${assertion}`;
-    const taskExecutor = new import_core.Executor(description);
-    const { timeoutMs, checkIntervalMs } = opt;
-    (0, import_node_assert2.default)(assertion, "No assertion for waitFor");
-    (0, import_node_assert2.default)(timeoutMs, "No timeoutMs for waitFor");
-    (0, import_node_assert2.default)(checkIntervalMs, "No checkIntervalMs for waitFor");
-    const overallStartTime = Date.now();
-    let startTime = Date.now();
-    let errorThought = "";
-    while (Date.now() - overallStartTime < timeoutMs) {
-      startTime = Date.now();
-      const assertPlan = {
-        type: "AssertWithoutThrow",
+  assert(assertion) {
+    return __async(this, null, function* () {
+      const description = `assert: ${assertion}`;
+      const taskExecutor = new import_core.Executor(description);
+      const assertionPlan = {
+        type: "Assert",
         param: {
           assertion
         }
       };
-      const assertTask = await this.convertPlanToExecutable([assertPlan]);
-      await taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
-      const output = await taskExecutor.flush();
-      if (output == null ? void 0 : output.pass) {
-        return {
-          output: void 0,
-          executor: taskExecutor
-        };
-      }
-      errorThought = (output == null ? void 0 : output.thought) || "unknown error";
-      const now = Date.now();
-      if (now - startTime < checkIntervalMs) {
-        const timeRemaining = checkIntervalMs - (now - startTime);
-        const sleepPlan = {
-          type: "Sleep",
+      const assertTask = yield this.convertPlanToExecutable([assertionPlan]);
+      yield taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+      const output = yield taskExecutor.flush();
+      return {
+        output,
+        executor: taskExecutor
+      };
+    });
+  }
+  waitFor(assertion, opt) {
+    return __async(this, null, function* () {
+      const description = `waitFor: ${assertion}`;
+      const taskExecutor = new import_core.Executor(description);
+      const { timeoutMs, checkIntervalMs } = opt;
+      (0, import_node_assert2.default)(assertion, "No assertion for waitFor");
+      (0, import_node_assert2.default)(timeoutMs, "No timeoutMs for waitFor");
+      (0, import_node_assert2.default)(checkIntervalMs, "No checkIntervalMs for waitFor");
+      const overallStartTime = Date.now();
+      let startTime = Date.now();
+      let errorThought = "";
+      while (Date.now() - overallStartTime < timeoutMs) {
+        startTime = Date.now();
+        const assertPlan = {
+          type: "AssertWithoutThrow",
           param: {
-            timeMs: timeRemaining
+            assertion
           }
         };
-        const sleepTask = await this.convertPlanToExecutable([sleepPlan]);
-        await taskExecutor.append(
-          this.wrapExecutorWithScreenshot(sleepTask[0])
-        );
-        await taskExecutor.flush();
-      }
-    }
-    const errorPlan = {
-      type: "Error",
-      param: {
-        thought: `waitFor timeout: ${errorThought}`
+        const assertTask = yield this.convertPlanToExecutable([assertPlan]);
+        yield taskExecutor.append(this.wrapExecutorWithScreenshot(assertTask[0]));
+        const output = yield taskExecutor.flush();
+        if (output == null ? void 0 : output.pass) {
+          return {
+            output: void 0,
+            executor: taskExecutor
+          };
+        }
+        errorThought = (output == null ? void 0 : output.thought) || "unknown error";
+        const now = Date.now();
+        if (now - startTime < checkIntervalMs) {
+          const timeRemaining = checkIntervalMs - (now - startTime);
+          const sleepPlan = {
+            type: "Sleep",
+            param: {
+              timeMs: timeRemaining
+            }
+          };
+          const sleepTask = yield this.convertPlanToExecutable([sleepPlan]);
+          yield taskExecutor.append(
+            this.wrapExecutorWithScreenshot(sleepTask[0])
+          );
+          yield taskExecutor.flush();
+        }
       }
-    };
-    const errorTask = await this.convertPlanToExecutable([errorPlan]);
-    await taskExecutor.append(errorTask[0]);
-    await taskExecutor.flush();
-    return {
-      output: void 0,
-      executor: taskExecutor
-    };
+      const errorPlan = {
+        type: "Error",
+        param: {
+          thought: `waitFor timeout: ${errorThought}`
+        }
+      };
+      const errorTask = yield this.convertPlanToExecutable([errorPlan]);
+      yield taskExecutor.append(errorTask[0]);
+      yield taskExecutor.flush();
+      return {
+        output: void 0,
+        executor: taskExecutor
+      };
+    });
   }
 };
 
@@ -1081,83 +1127,94 @@ var PageAgent = class {
   dumpDataString() {
     this.dump.groupName = this.opts.groupName;
     this.dump.groupDescription = this.opts.groupDescription;
-    return (0, import_utils5.stringifyDumpData)(this.dump);
+    return (0, import_utils7.stringifyDumpData)(this.dump);
   }
   writeOutActionDumps() {
     const { generateReport, autoPrintReportMsg } = this.opts;
-    this.reportFile = (0, import_utils5.writeLogFile)({
+    this.reportFile = (0, import_utils7.writeLogFile)({
       fileName: this.reportFileName,
-      fileExt: import_utils5.groupedActionDumpFileExt,
+      fileExt: import_utils7.groupedActionDumpFileExt,
       fileContent: this.dumpDataString(),
       type: "dump",
       generateReport
     });
-    if (generateReport && autoPrintReportMsg) {
+    if (generateReport && autoPrintReportMsg && this.reportFile) {
       printReportMsg(this.reportFile);
     }
   }
-  async aiAction(taskPrompt) {
-    const { executor } = await this.taskExecutor.action(taskPrompt);
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (executor.isInErrorState()) {
-      const errorTask = executor.latestErrorTask();
-      throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+  aiAction(taskPrompt) {
+    return __async(this, null, function* () {
+      const { executor } = yield this.taskExecutor.action(taskPrompt);
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (executor.isInErrorState()) {
+        const errorTask = executor.latestErrorTask();
+        throw new Error(`${errorTask == null ? void 0 : errorTask.error}
 ${errorTask == null ? void 0 : errorTask.errorStack}`);
-    }
+      }
+    });
   }
-  async aiQuery(demand) {
-    const { output, executor } = await this.taskExecutor.query(demand);
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (executor.isInErrorState()) {
-      const errorTask = executor.latestErrorTask();
-      throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+  aiQuery(demand) {
+    return __async(this, null, function* () {
+      const { output, executor } = yield this.taskExecutor.query(demand);
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (executor.isInErrorState()) {
+        const errorTask = executor.latestErrorTask();
+        throw new Error(`${errorTask == null ? void 0 : errorTask.error}
 ${errorTask == null ? void 0 : errorTask.errorStack}`);
-    }
-    return output;
-  }
-  async aiAssert(assertion, msg, opt) {
-    const { output, executor } = await this.taskExecutor.assert(assertion);
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (opt == null ? void 0 : opt.keepRawResponse) {
+      }
       return output;
-    }
-    if (!(output == null ? void 0 : output.pass)) {
-      const errMsg = msg || `Assertion failed: ${assertion}`;
-      const reasonMsg = `Reason: ${(output == null ? void 0 : output.thought) || "(no_reason)"}`;
-      throw new Error(`${errMsg}
-${reasonMsg}`);
-    }
+    });
   }
-  async aiWaitFor(assertion, opt) {
-    const { executor } = await this.taskExecutor.waitFor(assertion, {
-      timeoutMs: (opt == null ? void 0 : opt.timeoutMs) || 15 * 1e3,
-      checkIntervalMs: (opt == null ? void 0 : opt.checkIntervalMs) || 3 * 1e3,
-      assertion
+  aiAssert(assertion, msg, opt) {
+    return __async(this, null, function* () {
+      var _a;
+      const { output, executor } = yield this.taskExecutor.assert(assertion);
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (opt == null ? void 0 : opt.keepRawResponse) {
+        return output;
+      }
+      if (!(output == null ? void 0 : output.pass)) {
+        const errMsg = msg || `Assertion failed: ${assertion}`;
+        const reasonMsg = `Reason: ${(output == null ? void 0 : output.thought) || ((_a = executor.latestErrorTask()) == null ? void 0 : _a.error) || "(no_reason)"}`;
+        throw new Error(`${errMsg}
+${reasonMsg}`);
+      }
     });
-    this.appendExecutionDump(executor.dump());
-    this.writeOutActionDumps();
-    if (executor.isInErrorState()) {
-      const errorTask = executor.latestErrorTask();
-      throw new Error(`${errorTask == null ? void 0 : errorTask.error}
+  }
+  aiWaitFor(assertion, opt) {
+    return __async(this, null, function* () {
+      const { executor } = yield this.taskExecutor.waitFor(assertion, {
+        timeoutMs: (opt == null ? void 0 : opt.timeoutMs) || 15 * 1e3,
+        checkIntervalMs: (opt == null ? void 0 : opt.checkIntervalMs) || 3 * 1e3,
+        assertion
+      });
+      this.appendExecutionDump(executor.dump());
+      this.writeOutActionDumps();
+      if (executor.isInErrorState()) {
+        const errorTask = executor.latestErrorTask();
+        throw new Error(`${errorTask == null ? void 0 : errorTask.error}
 ${errorTask == null ? void 0 : errorTask.errorStack}`);
-    }
+      }
+    });
   }
-  async ai(taskPrompt, type = "action") {
-    if (type === "action") {
-      return this.aiAction(taskPrompt);
-    }
-    if (type === "query") {
-      return this.aiQuery(taskPrompt);
-    }
-    if (type === "assert") {
-      return this.aiAssert(taskPrompt);
-    }
-    throw new Error(
-      `Unknown type: ${type}, only support 'action', 'query', 'assert'`
-    );
+  ai(taskPrompt, type = "action") {
+    return __async(this, null, function* () {
+      if (type === "action") {
+        return this.aiAction(taskPrompt);
+      }
+      if (type === "query") {
+        return this.aiQuery(taskPrompt);
+      }
+      if (type === "assert") {
+        return this.aiAssert(taskPrompt);
+      }
+      throw new Error(
+        `Unknown type: ${type}, only support 'action', 'query', 'assert'`
+      );
+    });
   }
 };
 
@@ -1186,7 +1243,7 @@ var PlaywrightAiFixture = () => {
   const agentForPage = (page, testInfo) => {
     let idForPage = page[midsceneAgentKeyId];
     if (!idForPage) {
-      idForPage = (0, import_node_crypto2.randomUUID)();
+      idForPage = (0, import_node_crypto.randomUUID)();
       page[midsceneAgentKeyId] = idForPage;
       const { testId } = testInfo;
       const { taskFile, taskTitle } = groupAndCaseForTest(testInfo);
@@ -1215,70 +1272,94 @@ var PlaywrightAiFixture = () => {
     }
   };
   return {
-    ai: async ({ page }, use, testInfo) => {
+    ai: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(
-        async (taskPrompt, opts) => {
+      yield use(
+        (taskPrompt, opts) => __async(void 0, null, function* () {
           return new Promise((resolve, reject) => {
-            import_test.test.step(`ai - ${taskPrompt}`, async () => {
-              await waitForNetworkIdle(page);
+            import_test.test.step(`ai - ${taskPrompt}`, () => __async(void 0, null, function* () {
+              yield waitForNetworkIdle(page);
               const actionType = (opts == null ? void 0 : opts.type) || "action";
-              const result = await agent.ai(taskPrompt, actionType);
-              resolve(result);
-            });
+              try {
+                const result = yield agent.ai(taskPrompt, actionType);
+                resolve(result);
+              } catch (error) {
+                reject(error);
+              }
+            }));
           });
-        }
+        })
       );
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiAction: async ({ page }, use, testInfo) => {
+    }),
+    aiAction: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (taskPrompt) => {
-        import_test.test.step(`aiAction - ${taskPrompt}`, async () => {
-          await waitForNetworkIdle(page);
-          await agent.aiAction(taskPrompt);
+      yield use((taskPrompt) => __async(void 0, null, function* () {
+        return new Promise((resolve, reject) => {
+          import_test.test.step(`aiAction - ${taskPrompt}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              const result = yield agent.aiAction(taskPrompt);
+              resolve(result);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiQuery: async ({ page }, use, testInfo) => {
+    }),
+    aiQuery: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (demand) => {
+      yield use((demand) => __async(void 0, null, function* () {
         return new Promise((resolve, reject) => {
-          import_test.test.step(`aiQuery - ${JSON.stringify(demand)}`, async () => {
-            await waitForNetworkIdle(page);
-            const result = await agent.aiQuery(demand);
-            resolve(result);
-          });
+          import_test.test.step(`aiQuery - ${JSON.stringify(demand)}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              const result = yield agent.aiQuery(demand);
+              resolve(result);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiAssert: async ({ page }, use, testInfo) => {
+    }),
+    aiAssert: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (assertion, errorMsg) => {
+      yield use((assertion, errorMsg) => __async(void 0, null, function* () {
         return new Promise((resolve, reject) => {
-          import_test.test.step(`aiAssert - ${assertion}`, async () => {
-            await waitForNetworkIdle(page);
-            await agent.aiAssert(assertion, errorMsg);
-            resolve(null);
-          });
+          import_test.test.step(`aiAssert - ${assertion}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              yield agent.aiAssert(assertion, errorMsg);
+              resolve(null);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    },
-    aiWaitFor: async ({ page }, use, testInfo) => {
+    }),
+    aiWaitFor: (_0, _1, _2) => __async(void 0, [_0, _1, _2], function* ({ page }, use, testInfo) {
       const agent = agentForPage(page, testInfo);
-      await use(async (assertion, opt) => {
+      yield use((assertion, opt) => __async(void 0, null, function* () {
         return new Promise((resolve, reject) => {
-          import_test.test.step(`aiWaitFor - ${assertion}`, async () => {
-            await agent.aiWaitFor(assertion, opt);
-            resolve(null);
-          });
+          import_test.test.step(`aiWaitFor - ${assertion}`, () => __async(void 0, null, function* () {
+            yield waitForNetworkIdle(page);
+            try {
+              yield agent.aiWaitFor(assertion, opt);
+              resolve(null);
+            } catch (error) {
+              reject(error);
+            }
+          }));
         });
-      });
+      }));
       updateDumpAnnotation(testInfo, agent.dumpDataString());
-    }
+    })
   };
 };
 function waitForNetworkIdle(page) {
@@ -1291,87 +1372,113 @@ function waitForNetworkIdle(page) {
 
 // src/puppeteer/base-page.ts
 var import_node_fs3 = require("fs");
-var import_utils7 = require("@midscene/core/utils");
-var import_img4 = require("@midscene/shared/img");
+var import_utils9 = require("@midscene/core/utils");
+var import_img3 = require("@midscene/shared/img");
 var Page = class {
   evaluate(pageFunction, arg) {
     if (this.pageType === "puppeteer") {
-      return this.page.evaluate(pageFunction, arg);
+      return this.underlyingPage.evaluate(pageFunction, arg);
     }
-    return this.page.evaluate(pageFunction, arg);
+    return this.underlyingPage.evaluate(pageFunction, arg);
   }
-  constructor(page, pageType) {
-    this.page = page;
+  constructor(underlyingPage, pageType) {
+    this.underlyingPage = underlyingPage;
     this.pageType = pageType;
   }
-  async getElementInfos() {
-    const scripts = await getExtraReturnLogic();
-    const captureElementSnapshot = await this.evaluate(scripts);
-    return captureElementSnapshot;
-  }
-  async screenshot() {
-    const viewportSize = await this.evaluate(() => {
-      return {
-        width: document.documentElement.clientWidth,
-        height: document.documentElement.clientHeight,
-        deviceScaleFactor: window.devicePixelRatio
-      };
+  getElementInfos() {
+    return __async(this, null, function* () {
+      const scripts = yield getExtraReturnLogic();
+      const captureElementSnapshot = yield this.evaluate(scripts);
+      return captureElementSnapshot;
     });
-    const path2 = (0, import_utils7.getTmpFile)("png");
-    await this.page.screenshot({
-      path: path2,
-      type: "png"
-    });
-    let buf;
-    if (viewportSize.deviceScaleFactor > 1) {
-      buf = await (0, import_img4.resizeImg)((0, import_node_fs3.readFileSync)(path2), {
-        width: viewportSize.width,
-        height: viewportSize.height
+  }
+  screenshotBase64() {
+    return __async(this, null, function* () {
+      const viewportSize = yield this.evaluate(() => {
+        return {
+          width: document.documentElement.clientWidth,
+          height: document.documentElement.clientHeight,
+          deviceScaleFactor: window.devicePixelRatio
+        };
       });
-      (0, import_node_fs3.writeFileSync)(path2, buf);
-    }
-    return path2;
+      const path2 = (0, import_utils9.getTmpFile)("png");
+      yield this.underlyingPage.screenshot({
+        path: path2,
+        type: "png"
+      });
+      let buf;
+      if (viewportSize.deviceScaleFactor > 1) {
+        buf = yield (0, import_img3.resizeImg)((0, import_node_fs3.readFileSync)(path2), {
+          width: viewportSize.width,
+          height: viewportSize.height
+        });
+        (0, import_node_fs3.writeFileSync)(path2, buf);
+      }
+      return (0, import_img3.base64Encoded)(path2, true);
+    });
   }
   url() {
-    return this.page.url();
+    return this.underlyingPage.url();
   }
   get mouse() {
     return {
-      click: async (x, y, options) => this.page.mouse.click(x, y, { button: (options == null ? void 0 : options.button) || "left" }),
-      wheel: async (deltaX, deltaY) => {
+      click: (x, y, options) => __async(this, null, function* () {
+        return this.underlyingPage.mouse.click(x, y, {
+          button: (options == null ? void 0 : options.button) || "left"
+        });
+      }),
+      wheel: (deltaX, deltaY) => __async(this, null, function* () {
         if (this.pageType === "puppeteer") {
-          await this.page.mouse.wheel({ deltaX, deltaY });
+          yield this.underlyingPage.mouse.wheel({
+            deltaX,
+            deltaY
+          });
         } else if (this.pageType === "playwright") {
-          await this.page.mouse.wheel(deltaX, deltaY);
+          yield this.underlyingPage.mouse.wheel(
+            deltaX,
+            deltaY
+          );
         }
-      },
-      move: async (x, y) => this.page.mouse.move(x, y)
+      }),
+      move: (x, y) => __async(this, null, function* () {
+        return this.underlyingPage.mouse.move(x, y);
+      })
     };
   }
   get keyboard() {
     return {
-      type: async (text) => this.page.keyboard.type(text),
-      press: async (key) => this.page.keyboard.press(key),
-      down: async (key) => this.page.keyboard.down(key),
-      up: async (key) => this.page.keyboard.up(key)
+      type: (text) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.type(text);
+      }),
+      press: (key) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.press(key);
+      }),
+      down: (key) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.down(key);
+      }),
+      up: (key) => __async(this, null, function* () {
+        return this.underlyingPage.keyboard.up(key);
+      })
     };
   }
-  async clearInput(element) {
-    if (!element) {
-      return;
-    }
-    await this.mouse.click(element.center[0], element.center[1]);
-    const isMac = process.platform === "darwin";
-    if (isMac) {
-      await this.page.keyboard.down("Meta");
-      await this.page.keyboard.press("a");
-      await this.page.keyboard.up("Meta");
-    } else {
-      await this.page.keyboard.down("Control");
-      await this.page.keyboard.press("a");
-      await this.page.keyboard.up("Control");
-    }
-    await this.keyboard.press("Backspace");
+  clearInput(element) {
+    return __async(this, null, function* () {
+      if (!element) {
+        return;
+      }
+      yield this.mouse.click(element.center[0], element.center[1]);
+      const isMac = process.platform === "darwin";
+      if (isMac) {
+        yield this.underlyingPage.keyboard.down("Meta");
+        yield this.underlyingPage.keyboard.press("a");
+        yield this.underlyingPage.keyboard.up("Meta");
+      } else {
+        yield this.underlyingPage.keyboard.down("Control");
+        yield this.underlyingPage.keyboard.press("a");
+        yield this.underlyingPage.keyboard.up("Control");
+      }
+      yield this.keyboard.press("Backspace");
+    });
   }
   scrollUntilTop() {
     return this.mouse.wheel(0, -9999999);
@@ -1379,15 +1486,19 @@ var Page = class {
   scrollUntilBottom() {
     return this.mouse.wheel(0, 9999999);
   }
-  async scrollUpOneScreen() {
-    const innerHeight = await this.evaluate(() => window.innerHeight);
-    const distance = innerHeight * 0.7;
-    await this.mouse.wheel(0, -distance);
+  scrollUpOneScreen() {
+    return __async(this, null, function* () {
+      const innerHeight = yield this.evaluate(() => window.innerHeight);
+      const distance = innerHeight * 0.7;
+      yield this.mouse.wheel(0, -distance);
+    });
   }
-  async scrollDownOneScreen() {
-    const innerHeight = await this.evaluate(() => window.innerHeight);
-    const distance = innerHeight * 0.7;
-    await this.mouse.wheel(0, distance);
+  scrollDownOneScreen() {
+    return __async(this, null, function* () {
+      const innerHeight = yield this.evaluate(() => window.innerHeight);
+      const distance = innerHeight * 0.7;
+      yield this.mouse.wheel(0, distance);
+    });
   }
 };