momentic 0.0.10 → 0.0.11

package/bin/cli.js

@@ -1,4 +1,55 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+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());
+  });
+};
 
 // src/cli.ts
 import exec from "@actions/exec";
@@ -383,11 +434,10 @@ function parseCookieString(cookie) {
   if (!parsedCookie.path && parsedCookie.domain) {
     parsedCookie.path = "/";
   }
-  const result = {
-    ...parsedCookie,
+  const result = __spreadProps(__spreadValues({}, parsedCookie), {
     expires: parsedCookie.expires ? parsedCookie.expires.getTime() / 1e3 : void 0,
     sameSite
-  };
+  });
   return result;
 }
 
@@ -724,18 +774,6 @@ var defaultA11yNodeSerializeParams = {
   noProperties: false
 };
 var ProcessedA11yNode = class {
-  id;
-  role;
-  name;
-  content;
-  properties;
-  // css-like selector from the root of the tree to the current node
-  pathFromRoot;
-  parent;
-  // md5 hash - set lazily in most cases (not used at the moment)
-  // md5Sum: string;
-  children;
-  backendNodeID;
   constructor(params) {
     this.id = params.id;
     this.role = params.role;
@@ -747,10 +785,11 @@ var ProcessedA11yNode = class {
     this.backendNodeID = params.backendNodeID;
   }
   getLogForm() {
+    var _a, _b;
     return JSON.stringify({
       id: this.id,
-      name: this.name ?? "",
-      role: this.role ?? "",
+      name: (_a = this.name) != null ? _a : "",
+      role: (_b = this.role) != null ? _b : "",
       backendNodeId: this.backendNodeID
     });
   }
@@ -843,7 +882,7 @@ function getNodePathIdentifier(node) {
   return `"${node.nodeId}"`;
 }
 function processA11yTreeDFS(node, parent, inputNodeMap, outputNodeMap) {
-  var _a, _b, _c, _d, _e, _f;
+  var _a, _b, _c, _d, _e, _f, _g;
   if (!parent && node.parentId) {
     throw new Error(
       `Got no parent for accessibility node ${node.nodeId}: ${JSON.stringify(
@@ -871,7 +910,7 @@ function processA11yTreeDFS(node, parent, inputNodeMap, outputNodeMap) {
     });
   }
   outputNodeMap.set(processedNode.id, processedNode);
-  const children = node.childIds ?? [];
+  const children = (_f = node.childIds) != null ? _f : [];
   for (const childId of children) {
     if (!childId) {
       continue;
@@ -896,7 +935,7 @@ function processA11yTreeDFS(node, parent, inputNodeMap, outputNodeMap) {
   }
   if (processedNode.children.length === 1 && processedNode.children[0].role === "StaticText") {
     const currentName = processedNode.name;
-    const childName = (_f = processedNode.children[0]) == null ? void 0 : _f.name;
+    const childName = (_g = processedNode.children[0]) == null ? void 0 : _g.name;
     if (currentName === childName || !childName) {
       processedNode.children = [];
     }
@@ -1099,20 +1138,14 @@ function isRequestRelevantForPageLoad(request, currentURL) {
 }
 
 // ../../packages/web-agent/src/browsers/chrome.ts
-async function initCDPSession(cdpClient) {
-  await cdpClient.send("Accessibility.enable");
-  await cdpClient.send("DOM.enable");
-  await cdpClient.send("Overlay.enable");
+function initCDPSession(cdpClient) {
+  return __async(this, null, function* () {
+    yield cdpClient.send("Accessibility.enable");
+    yield cdpClient.send("DOM.enable");
+    yield cdpClient.send("Overlay.enable");
+  });
 }
-var ChromeBrowser = class _ChromeBrowser {
-  browser;
-  context;
-  page;
-  // key is nodeId, according to the a11y tree
-  nodeMap = /* @__PURE__ */ new Map();
-  cdpClient;
-  logger;
-  baseURL;
+var _ChromeBrowser = class _ChromeBrowser {
   constructor({
     browser,
     context,
@@ -1121,6 +1154,8 @@ var ChromeBrowser = class _ChromeBrowser {
     cdpClient,
     logger
   }) {
+    // key is nodeId, according to the a11y tree
+    this.nodeMap = /* @__PURE__ */ new Map();
     this.browser = browser;
     this.context = context;
     this.page = page;
@@ -1128,106 +1163,117 @@ var ChromeBrowser = class _ChromeBrowser {
     this.cdpClient = cdpClient;
     this.logger = logger;
   }
-  static USER_AGENT = devices["Desktop Chrome"].userAgent;
   /**
    * Creates a new browser and waits for navigation to the given test URL.
    */
-  static async init(baseURL, logger, onScreenshot, timeout = MAX_LOAD_TIMEOUT_MS) {
-    const browser = await chromium.launch({ headless: true });
-    const context = await browser.newContext({
-      viewport: {
-        width: 1920,
-        height: 1080
-      },
-      // comment out the below if you are on Mac OS but you're using a monitor
-      deviceScaleFactor: process.platform === "darwin" ? RETINA_WINDOW_SCALE_FACTOR : 1,
-      userAgent: devices["Desktop Chrome"].userAgent,
-      geolocation: { latitude: 37.7749, longitude: -122.4194 },
-      // san francisco
-      locale: "en-US",
-      timezoneId: "America/Los_Angeles"
-    });
-    const page = await context.newPage();
-    const cdpClient = await context.newCDPSession(page);
-    const chrome = new _ChromeBrowser({
-      browser,
-      context,
-      page,
-      baseURL,
-      cdpClient,
-      logger
-    });
-    let completed = false;
-    const navigateAndInitCDP = async () => {
-      try {
-        await chrome.navigate(baseURL, false);
-        await initCDPSession(cdpClient);
-      } catch (err) {
-        logger.error({ err }, "Failed to initialize chrome browser");
-      } finally {
-        completed = true;
-      }
-    };
-    void navigateAndInitCDP();
-    const sendScreenshot = async () => {
-      if (!onScreenshot) {
-        return;
+  static init(_0, _1, _2) {
+    return __async(this, arguments, function* (baseURL, logger, onScreenshot, timeout = MAX_LOAD_TIMEOUT_MS) {
+      const browser = yield chromium.launch({ headless: true });
+      const context = yield browser.newContext({
+        viewport: {
+          width: 1920,
+          height: 1080
+        },
+        // comment out the below if you are on Mac OS but you're using a monitor
+        deviceScaleFactor: process.platform === "darwin" ? RETINA_WINDOW_SCALE_FACTOR : 1,
+        userAgent: devices["Desktop Chrome"].userAgent,
+        geolocation: { latitude: 37.7749, longitude: -122.4194 },
+        // san francisco
+        locale: "en-US",
+        timezoneId: "America/Los_Angeles"
+      });
+      const page = yield context.newPage();
+      const cdpClient = yield context.newCDPSession(page);
+      const chrome = new _ChromeBrowser({
+        browser,
+        context,
+        page,
+        baseURL,
+        cdpClient,
+        logger
+      });
+      let completed = false;
+      const navigateAndInitCDP = () => __async(this, null, function* () {
+        try {
+          yield chrome.navigate(baseURL, false);
+          yield initCDPSession(cdpClient);
+        } catch (err) {
+          logger.error({ err }, "Failed to initialize chrome browser");
+        } finally {
+          completed = true;
+        }
+      });
+      void navigateAndInitCDP();
+      const sendScreenshot = () => __async(this, null, function* () {
+        if (!onScreenshot) {
+          return;
+        }
+        try {
+          onScreenshot({
+            viewport: chrome.viewport,
+            buffer: yield chrome.screenshot()
+          });
+        } catch (err) {
+          logger.error({ err }, "Failed to take screenshot");
+        }
+      });
+      void sendScreenshot();
+      const screenshotInterval = setInterval(() => {
+        void sendScreenshot();
+      }, 250);
+      const startTime = Date.now();
+      while (!completed && Date.now() - startTime < timeout) {
+        yield sleep(CHECK_INTERVAL_MS);
       }
-      try {
-        onScreenshot({
-          viewport: chrome.viewport,
-          buffer: await chrome.screenshot()
-        });
-      } catch (err) {
-        logger.error({ err }, "Failed to take screenshot");
+      clearInterval(screenshotInterval);
+      if (!completed) {
+        logger.warn(
+          "Timeout elapsed waiting for browser to initialize - are you sure this page is accessible?"
+        );
       }
-    };
-    void sendScreenshot();
-    const screenshotInterval = setInterval(() => {
-      void sendScreenshot();
-    }, 250);
-    const startTime = Date.now();
-    while (!completed && Date.now() - startTime < timeout) {
-      await sleep(CHECK_INTERVAL_MS);
-    }
-    clearInterval(screenshotInterval);
-    if (!completed) {
-      logger.warn(
-        "Timeout elapsed waiting for browser to initialize - are you sure this page is accessible?"
-      );
-    }
-    return chrome;
+      return chrome;
+    });
   }
   // Things to do on every page load
-  async pageSetup() {
-    await this.page.evaluate(addCursorScript);
-    await this.page.evaluate(addIDsScript);
+  pageSetup() {
+    return __async(this, null, function* () {
+      yield this.page.evaluate(addCursorScript);
+      yield this.page.evaluate(addIDsScript);
+    });
   }
-  async wait(timeoutMs) {
-    await this.page.waitForTimeout(timeoutMs);
+  wait(timeoutMs) {
+    return __async(this, null, function* () {
+      yield this.page.waitForTimeout(timeoutMs);
+    });
   }
-  async cleanup() {
-    await this.page.close();
-    await this.context.close();
-    await this.browser.close();
+  cleanup() {
+    return __async(this, null, function* () {
+      yield this.page.close();
+      yield this.context.close();
+      yield this.browser.close();
+    });
   }
   get closed() {
     return this.page.isClosed() || !this.browser.isConnected();
   }
-  async html() {
-    return await this.page.content();
+  html() {
+    return __async(this, null, function* () {
+      return yield this.page.content();
+    });
   }
   get url() {
     return this.page.url();
   }
-  async screenshot(quality = 100, scale = "device") {
-    return await this.page.screenshot({
-      fullPage: false,
-      quality,
-      scale,
-      type: "jpeg",
-      // allow the blinking text cursor thing to remain there
-      caret: "initial"
+  screenshot(quality = 100, scale = "device") {
+    return __async(this, null, function* () {
+      return yield this.page.screenshot({
+        fullPage: false,
+        quality,
+        scale,
+        type: "jpeg",
+        // allow the blinking text cursor thing to remain there
+        caret: "initial"
+      });
     });
   }
   get viewport() {
@@ -1237,539 +1283,595 @@ var ChromeBrowser = class _ChromeBrowser {
     }
     return viewport;
   }
-  async navigate(url, wrapPossibleNavigation = true) {
-    this.logger.debug(`Navigating to ${url}`);
-    const startTime = Date.now();
-    const doNav = async () => {
-      try {
-        await this.page.goto(url, {
-          timeout: MAX_LOAD_TIMEOUT_MS
-        });
-        this.logger.debug(
-          { url },
-          `Got load event in ${Math.floor(Date.now() - startTime)}ms`
-        );
-      } catch (e) {
-        this.logger.warn(
-          { url, type: "navigate", err: e },
-          "Timeout elapsed waiting for page to load, continuing anyways..."
+  navigate(url, wrapPossibleNavigation = true) {
+    return __async(this, null, function* () {
+      this.logger.debug(`Navigating to ${url}`);
+      const startTime = Date.now();
+      const doNav = () => __async(this, null, function* () {
+        try {
+          yield this.page.goto(url, {
+            timeout: MAX_LOAD_TIMEOUT_MS
+          });
+          this.logger.debug(
+            { url },
+            `Got load event in ${Math.floor(Date.now() - startTime)}ms`
+          );
+        } catch (e) {
+          this.logger.warn(
+            { url, type: "navigate", err: e },
+            "Timeout elapsed waiting for page to load, continuing anyways..."
+          );
+        }
+      });
+      if (wrapPossibleNavigation) {
+        yield this.wrapPossibleNavigation(doNav);
+      } else {
+        yield doNav();
+      }
+      if (CHROME_INTERNAL_URLS.has(this.url) && process.env.NODE_ENV === "production") {
+        throw new Error(
+          `${url} took too long to load \u{1F61E}. Please ensure the site and your internet are working.`
         );
       }
-    };
-    if (wrapPossibleNavigation) {
-      await this.wrapPossibleNavigation(doNav);
-    } else {
-      await doNav();
-    }
-    if (CHROME_INTERNAL_URLS.has(this.url) && process.env.NODE_ENV === "production") {
-      throw new Error(
-        `${url} took too long to load \u{1F61E}. Please ensure the site and your internet are working.`
-      );
-    }
-    await this.pageSetup();
-    this.logger.debug({ url }, "Navigation complete");
-  }
-  async fill(target, text, options = {}) {
-    const element = await this.click(target, {
-      doubleClick: false,
-      rightClick: false
-    });
-    await this.type(text, options);
-    return element;
-  }
-  async type(text, options = {}) {
-    const { clearContent = true, pressKeysSequentially = false } = options;
-    if (clearContent) {
-      await this.page.keyboard.press("Meta+A");
-      await this.page.keyboard.press("Backspace");
-    }
-    if (pressKeysSequentially) {
-      await this.page.keyboard.type(text);
-    } else {
-      await this.page.keyboard.insertText(text);
-    }
+      yield this.pageSetup();
+      this.logger.debug({ url }, "Navigation complete");
+    });
   }
-  async clickByA11yID(index, options = {}) {
-    const node = this.nodeMap.get(`${index}`);
-    if (!node) {
-      throw new Error(`Could not find node in DOM with index: ${index}`);
-    }
-    const nodeClicked = await this.clickUsingCDP(node, options);
-    await this.highlightNode(nodeClicked);
-    return node.serialize({ noChildren: true, noProperties: true, noID: true });
-  }
-  async selectOptionByA11yID(index, option) {
-    const node = this.nodeMap.get(`${index}`);
-    if (!node) {
-      throw new Error(`Could not find node in DOM with index: ${index}`);
-    }
-    if (!node.backendNodeID) {
-      throw new Error(
-        `Select target missing backend node id: ${node.getLogForm()}`
-      );
-    }
-    const locator = await this.getLocatorFromBackendID(node.backendNodeID);
-    await locator.selectOption(option, {
-      timeout: COMPLICATED_BROWSER_ACTION_TIMEOUT_MS
+  fill(_0, _1) {
+    return __async(this, arguments, function* (target, text, options = {}) {
+      const element = yield this.click(target, {
+        doubleClick: false,
+        rightClick: false
+      });
+      yield this.type(text, options);
+      return element;
     });
-    await this.highlightNode(node);
-    return node.serialize({ noChildren: true, noProperties: true, noID: true });
   }
-  async highlight(target) {
-    try {
-      await this.highlightByA11yID(target.id);
-    } catch (err) {
-      this.logger.warn({ err, target }, "Failed to highlight target");
-    }
+  type(_0) {
+    return __async(this, arguments, function* (text, options = {}) {
+      const { clearContent = true, pressKeysSequentially = false } = options;
+      if (clearContent) {
+        yield this.page.keyboard.press("Meta+A");
+        yield this.page.keyboard.press("Backspace");
+      }
+      if (pressKeysSequentially) {
+        yield this.page.keyboard.type(text);
+      } else {
+        yield this.page.keyboard.insertText(text);
+      }
+    });
   }
-  async highlightByA11yID(index) {
-    const node = this.nodeMap.get(`${index}`);
-    if (!node) {
-      throw new Error(`Could not find node in DOM with index: ${index}`);
-    }
-    if (!node.backendNodeID) {
-      throw new Error(
-        `Select target missing backend node id: ${node.getLogForm()}`
-      );
-    }
-    await this.highlightNode(node);
+  clickByA11yID(_0) {
+    return __async(this, arguments, function* (index, options = {}) {
+      const node = this.nodeMap.get(`${index}`);
+      if (!node) {
+        throw new Error(`Could not find node in DOM with index: ${index}`);
+      }
+      const nodeClicked = yield this.clickUsingCDP(node, options);
+      yield this.highlightNode(nodeClicked);
+      return node.serialize({ noChildren: true, noProperties: true, noID: true });
+    });
   }
-  async highlightNode(node) {
-    try {
-      await this.cdpClient.send("Overlay.highlightNode", {
-        highlightConfig: NODE_HIGHLIGHT_CONFIG,
-        backendNodeId: node.backendNodeID
+  selectOptionByA11yID(index, option) {
+    return __async(this, null, function* () {
+      const node = this.nodeMap.get(`${index}`);
+      if (!node) {
+        throw new Error(`Could not find node in DOM with index: ${index}`);
+      }
+      if (!node.backendNodeID) {
+        throw new Error(
+          `Select target missing backend node id: ${node.getLogForm()}`
+        );
+      }
+      const locator = yield this.getLocatorFromBackendID(node.backendNodeID);
+      yield locator.selectOption(option, {
+        timeout: COMPLICATED_BROWSER_ACTION_TIMEOUT_MS
       });
-    } catch (err) {
-      this.logger.warn({ err }, "Failed to add node highlight");
-    }
-    const hideHighlight = async () => {
+      yield this.highlightNode(node);
+      return node.serialize({ noChildren: true, noProperties: true, noID: true });
+    });
+  }
+  highlight(target) {
+    return __async(this, null, function* () {
+      try {
+        yield this.highlightByA11yID(target.id);
+      } catch (err) {
+        this.logger.warn({ err, target }, "Failed to highlight target");
+      }
+    });
+  }
+  highlightByA11yID(index) {
+    return __async(this, null, function* () {
+      const node = this.nodeMap.get(`${index}`);
+      if (!node) {
+        throw new Error(`Could not find node in DOM with index: ${index}`);
+      }
+      if (!node.backendNodeID) {
+        throw new Error(
+          `Select target missing backend node id: ${node.getLogForm()}`
+        );
+      }
+      yield this.highlightNode(node);
+    });
+  }
+  highlightNode(node) {
+    return __async(this, null, function* () {
       try {
-        await this.cdpClient.send("Overlay.hideHighlight", {
+        yield this.cdpClient.send("Overlay.highlightNode", {
+          highlightConfig: NODE_HIGHLIGHT_CONFIG,
           backendNodeId: node.backendNodeID
         });
       } catch (err) {
-        this.logger.debug({ err }, "Failed to remove node highlight");
+        this.logger.warn({ err }, "Failed to add node highlight");
       }
-    };
-    setTimeout(() => {
-      void hideHighlight();
-    }, HIGHLIGHT_DURATION_MS);
-  }
-  async wrapPossibleNavigation(fn, timeoutMS = MAX_LOAD_TIMEOUT_MS) {
-    const startTime = Date.now();
-    const startURL = this.url;
-    let lastRequestReceived = Date.now();
-    const firedRequests = /* @__PURE__ */ new Map();
-    const finishedRequests = /* @__PURE__ */ new Map();
-    const requestFinishedListener = (request) => {
-      const key = serializeRequest(request);
-      finishedRequests.set(key, (finishedRequests.get(key) ?? 0) + 1);
-    };
-    const requestFiredListener = (request) => {
-      if (!isRequestRelevantForPageLoad(request, this.url)) {
+      const hideHighlight = () => __async(this, null, function* () {
+        try {
+          yield this.cdpClient.send("Overlay.hideHighlight", {
+            backendNodeId: node.backendNodeID
+          });
+        } catch (err) {
+          this.logger.debug({ err }, "Failed to remove node highlight");
+        }
+      });
+      setTimeout(() => {
+        void hideHighlight();
+      }, HIGHLIGHT_DURATION_MS);
+    });
+  }
+  wrapPossibleNavigation(_0) {
+    return __async(this, arguments, function* (fn, timeoutMS = MAX_LOAD_TIMEOUT_MS) {
+      const startTime = Date.now();
+      const startURL = this.url;
+      let lastRequestReceived = Date.now();
+      const firedRequests = /* @__PURE__ */ new Map();
+      const finishedRequests = /* @__PURE__ */ new Map();
+      const requestFinishedListener = (request) => {
+        var _a;
+        const key = serializeRequest(request);
+        finishedRequests.set(key, ((_a = finishedRequests.get(key)) != null ? _a : 0) + 1);
+      };
+      const requestFiredListener = (request) => {
+        var _a;
+        if (!isRequestRelevantForPageLoad(request, this.url)) {
+          this.logger.debug(
+            {
+              uri: serializeRequest(request)
+            },
+            "Ignoring request for page load network stability"
+          );
+          return;
+        }
+        const key = serializeRequest(request);
         this.logger.debug(
           {
-            uri: serializeRequest(request)
+            uri: key
           },
-          "Ignoring request for page load network stability"
+          "Request fired on page load, delaying network stability"
         );
-        return;
-      }
-      const key = serializeRequest(request);
-      this.logger.debug(
-        {
-          uri: key
-        },
-        "Request fired on page load, delaying network stability"
-      );
-      firedRequests.set(key, (firedRequests.get(key) ?? 0) + 1);
-      lastRequestReceived = Date.now();
-    };
-    this.page.on("requestfinished", requestFinishedListener);
-    this.page.on("request", requestFiredListener);
-    let rejected = false;
-    const retPromise = fn().catch((e) => {
-      rejected = true;
-      if (e instanceof Error)
-        return e;
-      return new Error(`${e}`);
-    });
-    await sleep(CHECK_INTERVAL_MS);
-    const unwrapAndThrowError = async (p) => {
-      const v = await p;
-      if (v instanceof Error) {
-        throw v;
-      }
-      return v;
-    };
-    let unfinishedRequests = /* @__PURE__ */ new Set();
-    const waitForNetworkIdle = async () => {
-      while (!rejected && Date.now() - startTime < timeoutMS) {
-        unfinishedRequests = /* @__PURE__ */ new Set();
-        await sleep(CHECK_INTERVAL_MS);
-        if (Date.now() - lastRequestReceived <= NETWORK_STABLE_DURATION_MS) {
-          continue;
+        firedRequests.set(key, ((_a = firedRequests.get(key)) != null ? _a : 0) + 1);
+        lastRequestReceived = Date.now();
+      };
+      this.page.on("requestfinished", requestFinishedListener);
+      this.page.on("request", requestFiredListener);
+      let rejected = false;
+      const retPromise = fn().catch((e) => {
+        rejected = true;
+        if (e instanceof Error)
+          return e;
+        return new Error(`${e}`);
+      });
+      yield sleep(CHECK_INTERVAL_MS);
+      const unwrapAndThrowError = (p) => __async(this, null, function* () {
+        const v = yield p;
+        if (v instanceof Error) {
+          throw v;
         }
-        let anyDifference = false;
-        for (const key of firedRequests.keys()) {
-          if (firedRequests.get(key) !== finishedRequests.get(key)) {
-            this.logger.debug({ uri: key }, "Waiting on request to finish");
-            anyDifference = true;
-            unfinishedRequests.add(key);
+        return v;
+      });
+      let unfinishedRequests = /* @__PURE__ */ new Set();
+      const waitForNetworkIdle = () => __async(this, null, function* () {
+        while (!rejected && Date.now() - startTime < timeoutMS) {
+          unfinishedRequests = /* @__PURE__ */ new Set();
+          yield sleep(CHECK_INTERVAL_MS);
+          if (Date.now() - lastRequestReceived <= NETWORK_STABLE_DURATION_MS) {
+            continue;
+          }
+          let anyDifference = false;
+          for (const key of firedRequests.keys()) {
+            if (firedRequests.get(key) !== finishedRequests.get(key)) {
+              this.logger.debug({ uri: key }, "Waiting on request to finish");
+              anyDifference = true;
+              unfinishedRequests.add(key);
+            }
+          }
+          if (!anyDifference) {
+            this.logger.debug(
+              {
+                url: this.url,
+                requests: JSON.stringify(Array.from(firedRequests.entries()))
+              },
+              `Network idle in ${Math.floor(Date.now() - startTime)}ms`
+            );
+            return true;
           }
         }
-        if (!anyDifference) {
-          this.logger.debug(
+        if (!rejected) {
+          this.logger.warn(
             {
               url: this.url,
-              requests: JSON.stringify(Array.from(firedRequests.entries()))
+              requests: JSON.stringify(Array.from(unfinishedRequests.entries()))
             },
-            `Network idle in ${Math.floor(Date.now() - startTime)}ms`
+            "Timeout elapsed waiting for network idle, continuing anyways..."
           );
-          return true;
         }
+        return false;
+      });
+      const waitResult = yield waitForNetworkIdle();
+      this.page.off("requestfinished", requestFinishedListener);
+      this.page.off("request", requestFiredListener);
+      if (!waitResult) {
+        return unwrapAndThrowError(retPromise);
       }
-      if (!rejected) {
-        this.logger.warn(
-          {
-            url: this.url,
-            requests: JSON.stringify(Array.from(unfinishedRequests.entries()))
-          },
-          "Timeout elapsed waiting for network idle, continuing anyways..."
+      if (!rejected && urlChanged(this.url, startURL)) {
+        this.logger.debug(
+          `Detected url change in wrapPossibleNavigation, waiting for load state`
         );
+        try {
+          yield this.page.waitForLoadState("load", {
+            timeout: timeoutMS - (Date.now() - startTime)
+          });
+        } catch (e) {
+          this.logger.warn(
+            { url: this.url },
+            "Timeout elapsed waiting for load state to fire, continuing anyways..."
+          );
+        }
       }
-      return false;
-    };
-    const waitResult = await waitForNetworkIdle();
-    this.page.off("requestfinished", requestFinishedListener);
-    this.page.off("request", requestFiredListener);
-    if (!waitResult) {
       return unwrapAndThrowError(retPromise);
-    }
-    if (!rejected && urlChanged(this.url, startURL)) {
-      this.logger.debug(
-        `Detected url change in wrapPossibleNavigation, waiting for load state`
-      );
-      try {
-        await this.page.waitForLoadState("load", {
-          timeout: timeoutMS - (Date.now() - startTime)
-        });
-      } catch (e) {
-        this.logger.warn(
-          { url: this.url },
-          "Timeout elapsed waiting for load state to fire, continuing anyways..."
-        );
-      }
-    }
-    return unwrapAndThrowError(retPromise);
+    });
   }
-  async click(target, options = {}) {
-    const elementInteracted = await this.wrapPossibleNavigation(
-      () => this.clickByA11yID(target.id, options)
-    );
-    return elementInteracted;
+  click(_0) {
+    return __async(this, arguments, function* (target, options = {}) {
+      const elementInteracted = yield this.wrapPossibleNavigation(
+        () => this.clickByA11yID(target.id, options)
+      );
+      return elementInteracted;
+    });
   }
-  async selectOption(target, option) {
-    return this.selectOptionByA11yID(target.id, option);
+  selectOption(target, option) {
+    return __async(this, null, function* () {
+      return this.selectOptionByA11yID(target.id, option);
+    });
   }
-  async press(key) {
-    await this.wrapPossibleNavigation(() => this.page.keyboard.press(key));
+  press(key) {
+    return __async(this, null, function* () {
+      yield this.wrapPossibleNavigation(() => this.page.keyboard.press(key));
+    });
   }
-  async refresh() {
-    await this.page.reload();
-    await this.pageSetup();
+  refresh() {
+    return __async(this, null, function* () {
+      yield this.page.reload();
+      yield this.pageSetup();
+    });
   }
-  async getA11yTree() {
-    let processedTree = null;
-    let attempt = 0;
-    const url = this.url;
-    while (!processedTree) {
-      try {
-        this.logger.debug(`Getting a11y tree at ${url}`);
-        const graph = await this.getRawA11yTree();
-        if (!graph.root || graph.allNodes.length === 0) {
-          throw new Error("No a11y tree found on page");
-        }
-        processedTree = processA11yTree(graph);
-      } catch (e) {
-        this.logger.error({ err: e, url }, "Error fetching a11y tree");
-        if (attempt === 0) {
-          await sleep(1e3);
-          attempt++;
-        } else {
-          throw new Error(`Max retries exceeded fetching a11y tree: ${e}`);
+  getA11yTree() {
+    return __async(this, null, function* () {
+      let processedTree = null;
+      let attempt = 0;
+      const url = this.url;
+      while (!processedTree) {
+        try {
+          this.logger.debug(`Getting a11y tree at ${url}`);
+          const graph = yield this.getRawA11yTree();
+          if (!graph.root || graph.allNodes.length === 0) {
+            throw new Error("No a11y tree found on page");
+          }
+          processedTree = processA11yTree(graph);
+        } catch (e) {
+          this.logger.error({ err: e, url }, "Error fetching a11y tree");
+          if (attempt === 0) {
+            yield sleep(1e3);
+            attempt++;
+          } else {
+            throw new Error(`Max retries exceeded fetching a11y tree: ${e}`);
+          }
         }
       }
-    }
-    if (!processedTree.root) {
-      this.logger.warn("A11y tree was pruned entirely");
-    }
-    this.nodeMap = processedTree.nodeMap;
-    return processedTree;
-  }
-  async getRawA11yTree() {
-    const url = this.page.url();
-    let lastTreeUpdateTimestamp = Date.now();
-    const treeUpdateListener = () => {
-      lastTreeUpdateTimestamp = Date.now();
-    };
-    this.cdpClient.addListener(
-      "Accessibility.nodesUpdated",
-      treeUpdateListener
-    );
-    let accessibilityTreeLoadFired = false;
-    const accessibilityLoadListener = () => {
-      this.logger.info({ url }, `A11y tree load event fired`);
-      accessibilityTreeLoadFired = true;
-    };
-    this.cdpClient.addListener(
-      "Accessibility.loadComplete",
-      accessibilityLoadListener
-    );
-    const a11yLoadStart = Date.now();
-    let timeoutTriggered = true;
-    while (Date.now() - a11yLoadStart < A11Y_STABLE_TIMEOUT_MS) {
-      await sleep(CHECK_INTERVAL_MS);
-      if (!accessibilityTreeLoadFired && Date.now() - a11yLoadStart < A11Y_LOAD_TIMEOUT_MS) {
-        this.logger.debug({ url }, `A11y tree not loaded yet, waiting...`);
-        continue;
-      }
-      if (Date.now() - lastTreeUpdateTimestamp >= A11Y_STABLE_DURATION_MS) {
-        this.logger.debug({ url }, `A11y tree not stable yet, waiting...`);
-        continue;
+      if (!processedTree.root) {
+        this.logger.warn("A11y tree was pruned entirely");
       }
-      timeoutTriggered = false;
-      break;
-    }
-    this.logger.debug(
-      {
-        duration: Date.now() - a11yLoadStart,
-        eventReceived: accessibilityTreeLoadFired,
-        timeoutTriggered
-      },
-      "A11y wait phase completed"
-    );
-    const { node: root } = await this.cdpClient.send(
-      "Accessibility.getRootAXNode"
-    );
-    const { nodes } = await this.cdpClient.send("Accessibility.queryAXTree", {
-      backendNodeId: root.backendDOMNodeId
+      this.nodeMap = processedTree.nodeMap;
+      return processedTree;
     });
-    this.cdpClient.removeListener(
-      "Accessibility.loadComplete",
-      accessibilityLoadListener
-    );
-    this.cdpClient.removeListener(
-      "Accessibility.nodesUpdated",
-      treeUpdateListener
-    );
-    return {
-      root,
-      allNodes: nodes
-    };
   }
-  async clickUsingVisualCoordinates(backendNodeId) {
-    const location = await this.getElementLocation(backendNodeId);
-    if (!location) {
-      throw new Error(
-        `Could not find element location with backend node id: ${backendNodeId}`
+  getRawA11yTree() {
+    return __async(this, null, function* () {
+      const url = this.page.url();
+      let lastTreeUpdateTimestamp = Date.now();
+      const treeUpdateListener = () => {
+        lastTreeUpdateTimestamp = Date.now();
+      };
+      this.cdpClient.addListener(
+        "Accessibility.nodesUpdated",
+        treeUpdateListener
       );
-    }
-    this.logger.debug({ location }, "Executing mouse click");
-    await this.page.mouse.click(location.centerX, location.centerY);
-  }
-  // Get the "id" attribute value from an HTML element.
-  async getIDAttributeUsingCDP(objectId) {
-    await this.cdpClient.send("DOM.getDocument", { depth: 0 });
-    const cdpNodeResult = await this.cdpClient.send("DOM.requestNode", {
-      objectId
-    });
-    const attrResult = await this.cdpClient.send("DOM.getAttributes", {
-      nodeId: cdpNodeResult.nodeId
-    });
-    const attributes = attrResult.attributes;
-    const indexAttr = attributes.findIndex((s) => s === "data-momentic-id");
-    if (indexAttr === -1) {
-      return "";
-    }
-    return attributes[indexAttr + 1] || "";
-  }
-  async getLocatorFromBackendID(backendNodeId) {
-    await this.page.evaluate(addIDsScript);
-    const cdpResolveResult = await this.cdpClient.send("DOM.resolveNode", {
-      backendNodeId
-    });
-    if (!cdpResolveResult || !cdpResolveResult.object.objectId) {
-      throw new Error(`Could not resolve backend node ${backendNodeId}`);
-    }
-    try {
-      const id = await this.getIDAttributeUsingCDP(
-        cdpResolveResult.object.objectId
+      let accessibilityTreeLoadFired = false;
+      const accessibilityLoadListener = () => {
+        this.logger.info({ url }, `A11y tree load event fired`);
+        accessibilityTreeLoadFired = true;
+      };
+      this.cdpClient.addListener(
+        "Accessibility.loadComplete",
+        accessibilityLoadListener
       );
-      if (!id) {
-        throw new Error("Failed getting data-momentic-id attribute using CDP");
+      const a11yLoadStart = Date.now();
+      let timeoutTriggered = true;
+      while (Date.now() - a11yLoadStart < A11Y_STABLE_TIMEOUT_MS) {
+        yield sleep(CHECK_INTERVAL_MS);
+        if (!accessibilityTreeLoadFired && Date.now() - a11yLoadStart < A11Y_LOAD_TIMEOUT_MS) {
+          this.logger.debug({ url }, `A11y tree not loaded yet, waiting...`);
+          continue;
+        }
+        if (Date.now() - lastTreeUpdateTimestamp >= A11Y_STABLE_DURATION_MS) {
+          this.logger.debug({ url }, `A11y tree not stable yet, waiting...`);
+          continue;
+        }
+        timeoutTriggered = false;
+        break;
       }
-      return this.page.locator(`[data-momentic-id="${id}"]`);
-    } catch (err) {
-      this.logger.error(
+      this.logger.debug(
         {
-          err
+          duration: Date.now() - a11yLoadStart,
+          eventReceived: accessibilityTreeLoadFired,
+          timeoutTriggered
         },
-        "Failed to get ID attribute"
+        "A11y wait phase completed"
       );
-      throw err;
-    }
+      const { node: root } = yield this.cdpClient.send(
+        "Accessibility.getRootAXNode"
+      );
+      const { nodes } = yield this.cdpClient.send("Accessibility.queryAXTree", {
+        backendNodeId: root.backendDOMNodeId
+      });
+      this.cdpClient.removeListener(
+        "Accessibility.loadComplete",
+        accessibilityLoadListener
+      );
+      this.cdpClient.removeListener(
+        "Accessibility.nodesUpdated",
+        treeUpdateListener
+      );
+      return {
+        root,
+        allNodes: nodes
+      };
+    });
   }
-  async clickUsingCDP(originalNode, options = {}) {
-    let clickAttempts = 0;
-    let candidateNode = originalNode;
-    while (clickAttempts < MAX_BROWSER_ACTION_ATTEMPTS) {
-      if (!candidateNode || candidateNode.role === "RootWebArea") {
+  clickUsingVisualCoordinates(backendNodeId) {
+    return __async(this, null, function* () {
+      const location = yield this.getElementLocation(backendNodeId);
+      if (!location) {
         throw new Error(
-          `Attempted to click node with no clickable surrounding elements: ${originalNode.getLogForm()}`
+          `Could not find element location with backend node id: ${backendNodeId}`
         );
       }
-      if (candidateNode.role === "StaticText") {
-        candidateNode = candidateNode.parent;
-        continue;
+      this.logger.debug({ location }, "Executing mouse click");
+      yield this.page.mouse.click(location.centerX, location.centerY);
+    });
+  }
+  // Get the "id" attribute value from an HTML element.
+  getIDAttributeUsingCDP(objectId) {
+    return __async(this, null, function* () {
+      yield this.cdpClient.send("DOM.getDocument", { depth: 0 });
+      const cdpNodeResult = yield this.cdpClient.send("DOM.requestNode", {
+        objectId
+      });
+      const attrResult = yield this.cdpClient.send("DOM.getAttributes", {
+        nodeId: cdpNodeResult.nodeId
+      });
+      const attributes = attrResult.attributes;
+      const indexAttr = attributes.findIndex((s) => s === "data-momentic-id");
+      if (indexAttr === -1) {
+        return "";
       }
-      const candidateNodeID = candidateNode.backendNodeID;
-      if (!candidateNodeID) {
-        this.logger.warn(
-          { node: candidateNode.getLogForm() },
-          "Click candidate had no backend node ID"
-        );
-        candidateNode = candidateNode.parent;
-        continue;
+      return attributes[indexAttr + 1] || "";
+    });
+  }
+  getLocatorFromBackendID(backendNodeId) {
+    return __async(this, null, function* () {
+      yield this.page.evaluate(addIDsScript);
+      const cdpResolveResult = yield this.cdpClient.send("DOM.resolveNode", {
+        backendNodeId
+      });
+      if (!cdpResolveResult || !cdpResolveResult.object.objectId) {
+        throw new Error(`Could not resolve backend node ${backendNodeId}`);
       }
       try {
-        const locator = await this.getLocatorFromBackendID(candidateNodeID);
-        if (options.doubleClick) {
-          await locator.dblclick({
-            timeout: BROWSER_ACTION_TIMEOUT_MS
-          });
-        } else {
-          await locator.click({
-            timeout: BROWSER_ACTION_TIMEOUT_MS,
-            button: options.rightClick ? "right" : "left"
-          });
-        }
-        if (candidateNode.id !== originalNode.id) {
-          this.logger.info(
-            {
-              oldNode: originalNode.getLogForm(),
-              newNode: candidateNode.getLogForm()
-            },
-            `Redirected click successfully to new element`
-          );
+        const id = yield this.getIDAttributeUsingCDP(
+          cdpResolveResult.object.objectId
+        );
+        if (!id) {
+          throw new Error("Failed getting data-momentic-id attribute using CDP");
         }
-        return candidateNode;
+        return this.page.locator(`[data-momentic-id="${id}"]`);
       } catch (err) {
         this.logger.error(
-          { err, node: candidateNode.getLogForm() },
-          "Failed click or click timed out"
+          {
+            err
+          },
+          "Failed to get ID attribute"
         );
-        clickAttempts++;
-        candidateNode = candidateNode.parent;
+        throw err;
       }
-    }
-    throw new Error(
-      `Max click redirection attempts exhausted on original element: ${originalNode.getLogForm()}`
-    );
+    });
+  }
+  clickUsingCDP(_0) {
+    return __async(this, arguments, function* (originalNode, options = {}) {
+      let clickAttempts = 0;
+      let candidateNode = originalNode;
+      while (clickAttempts < MAX_BROWSER_ACTION_ATTEMPTS) {
+        if (!candidateNode || candidateNode.role === "RootWebArea") {
+          throw new Error(
+            `Attempted to click node with no clickable surrounding elements: ${originalNode.getLogForm()}`
+          );
+        }
+        if (candidateNode.role === "StaticText") {
+          candidateNode = candidateNode.parent;
+          continue;
+        }
+        const candidateNodeID = candidateNode.backendNodeID;
+        if (!candidateNodeID) {
+          this.logger.warn(
+            { node: candidateNode.getLogForm() },
+            "Click candidate had no backend node ID"
+          );
+          candidateNode = candidateNode.parent;
+          continue;
+        }
+        try {
+          const locator = yield this.getLocatorFromBackendID(candidateNodeID);
+          if (options.doubleClick) {
+            yield locator.dblclick({
+              timeout: BROWSER_ACTION_TIMEOUT_MS
+            });
+          } else {
+            yield locator.click({
+              timeout: BROWSER_ACTION_TIMEOUT_MS,
+              button: options.rightClick ? "right" : "left"
+            });
+          }
+          if (candidateNode.id !== originalNode.id) {
+            this.logger.info(
+              {
+                oldNode: originalNode.getLogForm(),
+                newNode: candidateNode.getLogForm()
+              },
+              `Redirected click successfully to new element`
+            );
+          }
+          return candidateNode;
+        } catch (err) {
+          this.logger.error(
+            { err, node: candidateNode.getLogForm() },
+            "Failed click or click timed out"
+          );
+          clickAttempts++;
+          candidateNode = candidateNode.parent;
+        }
+      }
+      throw new Error(
+        `Max click redirection attempts exhausted on original element: ${originalNode.getLogForm()}`
+      );
+    });
   }
   /**
    * Currently unused, but could be useful for vision model integration.
    * Gets x/y position of an a11y node.
    */
-  async getElementLocation(backendNodeId) {
-    const tree = await this.cdpClient.send("DOMSnapshot.captureSnapshot", {
-      computedStyles: [],
-      includeDOMRects: true,
-      includePaintOrder: true
-    });
-    let devicePixelRatio = await this.page.evaluate(
-      () => window.devicePixelRatio
-    );
-    if (process.platform === "darwin" && devicePixelRatio === 1) {
-      devicePixelRatio = RETINA_WINDOW_SCALE_FACTOR;
-    }
-    const document2 = tree["documents"][0];
-    const layout = document2["layout"];
-    const nodes = document2["nodes"];
-    const nodeNames = nodes["nodeName"] || [];
-    const backendNodeIds = nodes["backendNodeId"] || [];
-    const layoutNodeIndex = layout["nodeIndex"];
-    const bounds = layout["bounds"];
-    let cursor2 = -1;
-    for (let i = 0; i < nodeNames.length; i++) {
-      if (backendNodeIds[i] === backendNodeId) {
-        cursor2 = layoutNodeIndex.indexOf(i);
-        break;
-      }
-    }
-    if (cursor2 === -1) {
-      throw new Error(
-        `Could not find any backend node with ID ${backendNodeId}`
+  getElementLocation(backendNodeId) {
+    return __async(this, null, function* () {
+      const tree = yield this.cdpClient.send("DOMSnapshot.captureSnapshot", {
+        computedStyles: [],
+        includeDOMRects: true,
+        includePaintOrder: true
+      });
+      let devicePixelRatio = yield this.page.evaluate(
+        () => window.devicePixelRatio
       );
-    }
-    let [x = 0, y = 0, width = 0, height = 0] = bounds[cursor2];
-    x /= devicePixelRatio;
-    y /= devicePixelRatio;
-    width /= devicePixelRatio;
-    height /= devicePixelRatio;
-    const centerX = x + width / 2;
-    const centerY = y + height / 2;
-    return { centerX, centerY };
+      if (process.platform === "darwin" && devicePixelRatio === 1) {
+        devicePixelRatio = RETINA_WINDOW_SCALE_FACTOR;
+      }
+      const document2 = tree["documents"][0];
+      const layout = document2["layout"];
+      const nodes = document2["nodes"];
+      const nodeNames = nodes["nodeName"] || [];
+      const backendNodeIds = nodes["backendNodeId"] || [];
+      const layoutNodeIndex = layout["nodeIndex"];
+      const bounds = layout["bounds"];
+      let cursor2 = -1;
+      for (let i = 0; i < nodeNames.length; i++) {
+        if (backendNodeIds[i] === backendNodeId) {
+          cursor2 = layoutNodeIndex.indexOf(i);
+          break;
+        }
+      }
+      if (cursor2 === -1) {
+        throw new Error(
+          `Could not find any backend node with ID ${backendNodeId}`
+        );
+      }
+      let [x = 0, y = 0, width = 0, height = 0] = bounds[cursor2];
+      x /= devicePixelRatio;
+      y /= devicePixelRatio;
+      width /= devicePixelRatio;
+      height /= devicePixelRatio;
+      const centerX = x + width / 2;
+      const centerY = y + height / 2;
+      return { centerX, centerY };
+    });
   }
-  async scrollUp() {
-    await this.page.evaluate(() => {
-      (document.scrollingElement || document.body).scrollTop = (document.scrollingElement || document.body).scrollTop - window.innerHeight;
+  scrollUp() {
+    return __async(this, null, function* () {
+      yield this.page.evaluate(() => {
+        (document.scrollingElement || document.body).scrollTop = (document.scrollingElement || document.body).scrollTop - window.innerHeight;
+      });
+      yield this.page.evaluate(() => {
+        (document.scrollingElement || document.body).scrollTop = (document.scrollingElement || document.body).scrollTop + window.innerHeight;
+      });
     });
-    await this.page.evaluate(() => {
-      (document.scrollingElement || document.body).scrollTop = (document.scrollingElement || document.body).scrollTop + window.innerHeight;
+  }
+  scrollDown() {
+    return __async(this, null, function* () {
+      yield this.page.evaluate(() => {
+        (document.scrollingElement || document.body).scrollTop = (document.scrollingElement || document.body).scrollTop + window.innerHeight;
+      });
     });
   }
-  async scrollDown() {
-    await this.page.evaluate(() => {
-      (document.scrollingElement || document.body).scrollTop = (document.scrollingElement || document.body).scrollTop + window.innerHeight;
+  goForward() {
+    return __async(this, null, function* () {
+      yield this.wrapPossibleNavigation(
+        () => this.page.goForward({ timeout: MAX_LOAD_TIMEOUT_MS })
+      );
+      yield this.pageSetup();
     });
   }
-  async goForward() {
-    await this.wrapPossibleNavigation(
-      () => this.page.goForward({ timeout: MAX_LOAD_TIMEOUT_MS })
-    );
-    await this.pageSetup();
+  goBack() {
+    return __async(this, null, function* () {
+      yield this.wrapPossibleNavigation(
+        () => this.page.goBack({ timeout: MAX_LOAD_TIMEOUT_MS })
+      );
+      yield this.pageSetup();
+    });
   }
-  async goBack() {
-    await this.wrapPossibleNavigation(
-      () => this.page.goBack({ timeout: MAX_LOAD_TIMEOUT_MS })
-    );
-    await this.pageSetup();
-  }
-  async switchToPage(urlSubstring) {
-    const allPages = await this.context.pages();
-    for (let i = 0; i < allPages.length; i++) {
-      const page = allPages[i];
-      if (page.url().includes(urlSubstring)) {
-        this.page = page;
-        await page.waitForLoadState("load", {
-          timeout: MAX_LOAD_TIMEOUT_MS
-        });
-        await this.pageSetup();
-        this.cdpClient = await this.context.newCDPSession(page);
-        await initCDPSession(this.cdpClient);
-        this.logger.info(`Switching to tab ${i} with url ${page.url()}`);
-        return;
+  switchToPage(urlSubstring) {
+    return __async(this, null, function* () {
+      const allPages = yield this.context.pages();
+      for (let i = 0; i < allPages.length; i++) {
+        const page = allPages[i];
+        if (page.url().includes(urlSubstring)) {
+          this.page = page;
+          yield page.waitForLoadState("load", {
+            timeout: MAX_LOAD_TIMEOUT_MS
+          });
+          yield this.pageSetup();
+          this.cdpClient = yield this.context.newCDPSession(page);
+          yield initCDPSession(this.cdpClient);
+          this.logger.info(`Switching to tab ${i} with url ${page.url()}`);
+          return;
+        }
       }
-    }
-    throw new Error(`Could not find page with url containing ${urlSubstring}`);
+      throw new Error(`Could not find page with url containing ${urlSubstring}`);
+    });
   }
-  async setCookie(cookie) {
-    const cookieSettings = parseCookieString(cookie);
-    await this.context.addCookies([cookieSettings]);
+  setCookie(cookie) {
+    return __async(this, null, function* () {
+      const cookieSettings = parseCookieString(cookie);
+      yield this.context.addCookies([cookieSettings]);
+    });
   }
 };
+_ChromeBrowser.USER_AGENT = devices["Desktop Chrome"].userAgent;
+var ChromeBrowser = _ChromeBrowser;
 
 // ../../packages/web-agent/src/configs/controller.ts
 var A11Y_CONTROLLER_CONFIG = {
@@ -1785,18 +1887,6 @@ import dedent2 from "dedent";
 import diffLines from "diff-lines";
 var MAX_HISTORY_CHAR_LENGTH = 1e4;
 var AgentController = class {
-  // Instance of browser to interact with
-  browser;
-  // Stack of queued-up instructions
-  pendingInstructions;
-  // manager for all AI generation
-  generator;
-  // Stack of commands previously executed.
-  // Top of stack can be a pending command that hasn't been executed yet.
-  // Should not contain intermediate successes due to granular commands.
-  commandHistory;
-  config;
-  logger;
   constructor({ browser, config, generator, logger }) {
     this.browser = browser;
     this.generator = generator;
@@ -1831,16 +1921,20 @@ var AgentController = class {
   /**
    * Reset controller and browser state.
    */
-  async resetState() {
-    this.resetHistory();
-    await this.browser.navigate(this.browser.baseURL);
+  resetState() {
+    return __async(this, null, function* () {
+      this.resetHistory();
+      yield this.browser.navigate(this.browser.baseURL);
+    });
   }
   /**
    * Get the browser state as a string
    */
-  async getBrowserState() {
-    const a11yTree = await this.browser.getA11yTree();
-    return a11yTree.serialize();
+  getBrowserState() {
+    return __async(this, null, function* () {
+      const a11yTree = yield this.browser.getA11yTree();
+      return a11yTree.serialize();
+    });
   }
   getSerializedHistory(url, currentBrowserState) {
     let history;
@@ -1851,99 +1945,105 @@ var AgentController = class {
     }
     return history;
   }
-  async splitUserGoal(type, goal, disableCache) {
-    if (type === "AI_ACTION" /* AI_ACTION */ && goal.match(/[,!;.]|(?:and)|(?:then)/) && this.config.useGoalSplitter) {
-      const granularInstructions = await this.generator.getGranularGoals(
-        { goal, url: this.browser.url },
-        disableCache
-      );
-      this.pendingInstructions = granularInstructions.reverse();
-    } else {
-      this.pendingInstructions = [goal];
-    }
+  splitUserGoal(type, goal, disableCache) {
+    return __async(this, null, function* () {
+      if (type === "AI_ACTION" /* AI_ACTION */ && goal.match(/[,!;.]|(?:and)|(?:then)/) && this.config.useGoalSplitter) {
+        const granularInstructions = yield this.generator.getGranularGoals(
+          { goal, url: this.browser.url },
+          disableCache
+        );
+        this.pendingInstructions = granularInstructions.reverse();
+      } else {
+        this.pendingInstructions = [goal];
+      }
+    });
   }
   /**
    * Given previously executed commands, generate command for the current prompt.
    * Should only be used for AI action.
    */
-  async promptToCommand(type, goal, disableCache) {
-    if (this.pendingInstructions.length === 0) {
-      await this.splitUserGoal(type, goal, disableCache);
-    }
-    const currInstruction = this.pendingInstructions[this.pendingInstructions.length - 1];
-    this.logger.info({ goal: currInstruction }, "Starting prompt translation");
-    const getBrowserStateStart = Date.now();
-    const url = this.browser.url;
-    const browserState = await this.getBrowserState();
-    this.logger.info(
-      {
-        duration: Date.now() - getBrowserStateStart,
-        url
-      },
-      "Got browser state"
-    );
-    const numPrevious = this.commandHistory.length;
-    this.commandHistory.push({
-      state: "PENDING",
-      browserStateBeforeCommand: browserState,
-      urlBeforeCommand: url,
-      type
-    });
-    const history = this.getSerializedHistory(url, browserState);
-    const getCommandProposalStart = Date.now();
-    const proposedCommand = await this.generator.getProposedCommand(
-      {
-        url,
-        numPrevious,
-        browserState,
-        history,
-        goal: currInstruction,
-        lastCommand: this.lastExecutedCommand
-      },
-      disableCache
-    );
-    this.logger.info(
-      { duration: Date.now() - getCommandProposalStart },
-      "Got proposed command"
-    );
-    if (proposedCommand.type === "SUCCESS" /* SUCCESS */) {
-      const finishedInstruction = this.pendingInstructions.pop();
+  promptToCommand(type, goal, disableCache) {
+    return __async(this, null, function* () {
+      if (this.pendingInstructions.length === 0) {
+        yield this.splitUserGoal(type, goal, disableCache);
+      }
+      const currInstruction = this.pendingInstructions[this.pendingInstructions.length - 1];
+      this.logger.info({ goal: currInstruction }, "Starting prompt translation");
+      const getBrowserStateStart = Date.now();
+      const url = this.browser.url;
+      const browserState = yield this.getBrowserState();
       this.logger.info(
         {
-          finishedInstruction,
-          remainingInstructions: this.pendingInstructions
+          duration: Date.now() - getBrowserStateStart,
+          url
         },
-        "Removing pending instruction due to SUCCESS"
+        "Got browser state"
       );
-      if (this.pendingInstructions.length !== 0) {
-        this.commandHistory.pop();
-        return this.promptToCommand(type, "", disableCache);
-      }
-    } else if (
-      // on failure, we don't continue to execute
-      proposedCommand.type === "FAILURE"
-    ) {
-      this.logger.info(
+      const numPrevious = this.commandHistory.length;
+      this.commandHistory.push({
+        state: "PENDING",
+        browserStateBeforeCommand: browserState,
+        urlBeforeCommand: url,
+        type
+      });
+      const history = this.getSerializedHistory(url, browserState);
+      const getCommandProposalStart = Date.now();
+      const proposedCommand = yield this.generator.getProposedCommand(
         {
-          remainingInstructions: this.pendingInstructions
+          url,
+          numPrevious,
+          browserState,
+          history,
+          goal: currInstruction,
+          lastCommand: this.lastExecutedCommand
         },
-        "Removing pending instructions due to FAILURE"
+        disableCache
       );
-      this.pendingInstructions = [];
-    }
-    return proposedCommand;
+      this.logger.info(
+        { duration: Date.now() - getCommandProposalStart },
+        "Got proposed command"
+      );
+      if (proposedCommand.type === "SUCCESS" /* SUCCESS */) {
+        const finishedInstruction = this.pendingInstructions.pop();
+        this.logger.info(
+          {
+            finishedInstruction,
+            remainingInstructions: this.pendingInstructions
+          },
+          "Removing pending instruction due to SUCCESS"
+        );
+        if (this.pendingInstructions.length !== 0) {
+          this.commandHistory.pop();
+          return this.promptToCommand(type, "", disableCache);
+        }
+      } else if (
+        // on failure, we don't continue to execute
+        proposedCommand.type === "FAILURE"
+      ) {
+        this.logger.info(
+          {
+            remainingInstructions: this.pendingInstructions
+          },
+          "Removing pending instructions due to FAILURE"
+        );
+        this.pendingInstructions = [];
+      }
+      return proposedCommand;
+    });
   }
-  async locateElement(description, disableCache) {
-    const locator = await this.generator.getElementLocation(
-      { browserState: await this.getBrowserState(), goal: description },
-      disableCache
-    );
-    if (locator.id < 0) {
-      throw new Error(
-        `Unable to locate element with description: ${description}`
+  locateElement(description, disableCache) {
+    return __async(this, null, function* () {
+      const locator = yield this.generator.getElementLocation(
+        { browserState: yield this.getBrowserState(), goal: description },
+        disableCache
       );
-    }
-    return locator;
+      if (locator.id < 0) {
+        throw new Error(
+          `Unable to locate element with description: ${description}`
+        );
+      }
+      return locator;
+    });
   }
   /**
    * Construct a detailed history that can be passed to the LLM.
@@ -2001,104 +2101,108 @@ var AgentController = class {
    * @param [stateless=false] Execute this command in a stateless fashion, without modifying any controller state such as
    * pending instructions. Useful when executing cached instructions.
    */
-  async executeCommand(command, disableCache, stateless = false) {
-    const pendingHistory = this.commandHistory[this.commandHistory.length - 1];
-    if (!stateless) {
-      if (!pendingHistory || pendingHistory.state !== "PENDING") {
-        throw new Error(
-          "Executing command but there is no pending entry in the history"
-        );
+  executeCommand(command, disableCache, stateless = false) {
+    return __async(this, null, function* () {
+      const pendingHistory = this.commandHistory[this.commandHistory.length - 1];
+      if (!stateless) {
+        if (!pendingHistory || pendingHistory.state !== "PENDING") {
+          throw new Error(
+            "Executing command but there is no pending entry in the history"
+          );
+        }
+      } else {
+        yield this.browser.getA11yTree();
       }
-    } else {
-      await this.browser.getA11yTree();
-    }
-    let result;
-    try {
-      const executionStart = Date.now();
-      result = await this.executePresetStep(
-        command,
-        disableCache
-      );
-      this.logger.info(
-        { result, duration: Date.now() - executionStart },
-        "Got execution result"
-      );
-    } catch (e) {
-      if (e instanceof Error) {
-        throw new BrowserExecutionError(`Failed to execute command: ${e}`, {
-          cause: e
-        });
+      let result;
+      try {
+        const executionStart = Date.now();
+        result = yield this.executePresetStep(
+          command,
+          disableCache
+        );
+        this.logger.info(
+          { result, duration: Date.now() - executionStart },
+          "Got execution result"
+        );
+      } catch (e) {
+        if (e instanceof Error) {
+          throw new BrowserExecutionError(`Failed to execute command: ${e}`, {
+            cause: e
+          });
+        }
+        throw new BrowserExecutionError(
+          `Unexpected throw from executing command`,
+          {
+            cause: new Error(`${e}`)
+          }
+        );
       }
-      throw new BrowserExecutionError(
-        `Unexpected throw from executing command`,
-        {
-          cause: new Error(`${e}`)
+      if (result.succeedImmediately && !stateless) {
+        this.pendingInstructions.pop();
+        if (this.pendingInstructions.length > 0) {
+          result.succeedImmediately = false;
         }
-      );
-    }
-    if (result.succeedImmediately && !stateless) {
-      this.pendingInstructions.pop();
-      if (this.pendingInstructions.length > 0) {
-        result.succeedImmediately = false;
       }
-    }
-    if (result.elementInteracted && "target" in command && !command.target.elementDescriptor) {
-      command.target.elementDescriptor = result.elementInteracted.trim();
-    }
-    if (!stateless) {
-      pendingHistory.generatedStep = command;
-      pendingHistory.serializedCommand = serializeCommand(command);
-      pendingHistory.state = "DONE";
-    }
-    return result;
+      if (result.elementInteracted && "target" in command && !command.target.elementDescriptor) {
+        command.target.elementDescriptor = result.elementInteracted.trim();
+      }
+      if (!stateless) {
+        pendingHistory.generatedStep = command;
+        pendingHistory.serializedCommand = serializeCommand(command);
+        pendingHistory.state = "DONE";
+      }
+      return result;
+    });
   }
-  async executeAssertion(urlBeforeCommand, command) {
-    let params;
-    if (command.useVision) {
-      params = {
-        goal: command.assertion,
-        url: urlBeforeCommand,
-        // used for vision only
-        screenshot: await this.browser.screenshot(),
-        // unused for visual assertion
-        browserState: "",
-        history: "",
-        numPrevious: -1,
-        lastCommand: null
-      };
-    } else {
-      const browserState = await this.getBrowserState();
-      const history = this.getSerializedHistory(urlBeforeCommand, browserState);
-      params = {
-        goal: command.assertion,
-        url: urlBeforeCommand,
-        // used for text only
-        browserState,
-        history,
-        lastCommand: this.lastExecutedCommand,
-        numPrevious: this.commandHistory.length
-      };
-    }
-    const assertionEval = await this.generator.getAssertionResult(
-      params,
-      command.useVision,
-      command.disableCache
-    );
-    if (assertionEval.relevantElements) {
-      void Promise.all(
-        assertionEval.relevantElements.map(
-          (id) => this.browser.highlight({ id })
-        )
+  executeAssertion(urlBeforeCommand, command) {
+    return __async(this, null, function* () {
+      let params;
+      if (command.useVision) {
+        params = {
+          goal: command.assertion,
+          url: urlBeforeCommand,
+          // used for vision only
+          screenshot: yield this.browser.screenshot(),
+          // unused for visual assertion
+          browserState: "",
+          history: "",
+          numPrevious: -1,
+          lastCommand: null
+        };
+      } else {
+        const browserState = yield this.getBrowserState();
+        const history = this.getSerializedHistory(urlBeforeCommand, browserState);
+        params = {
+          goal: command.assertion,
+          url: urlBeforeCommand,
+          // used for text only
+          browserState,
+          history,
+          lastCommand: this.lastExecutedCommand,
+          numPrevious: this.commandHistory.length
+        };
+      }
+      const assertionEval = yield this.generator.getAssertionResult(
+        params,
+        command.useVision,
+        command.disableCache
       );
-    }
-    if (!assertionEval.result) {
-      throw new Error(assertionEval.thoughts);
-    }
-    return {
-      succeedImmediately: false,
-      thoughts: assertionEval.thoughts,
-      urlAfterCommand: urlBeforeCommand
-    };
+      if (assertionEval.relevantElements) {
+        void Promise.all(
+          assertionEval.relevantElements.map(
+            (id) => this.browser.highlight({ id })
+          )
+        );
+      }
+      if (!assertionEval.result) {
+        throw new Error(assertionEval.thoughts);
+      }
+      return {
+        succeedImmediately: false,
+        thoughts: assertionEval.thoughts,
+        urlAfterCommand: urlBeforeCommand
+      };
+    });
   }
   /**
    * Executes a preset command.
@@ -2106,157 +2210,159 @@ var AgentController = class {
    * For assertions, an AssertionResult with thoughts is returned.
    * Throws on failure.
    */
-  async executePresetStep(command, disableCache) {
-    var _a, _b, _c;
-    const urlBeforeCommand = this.browser.url;
-    switch (command.type) {
-      case "SUCCESS" /* SUCCESS */:
-        if ((_a = command.condition) == null ? void 0 : _a.assertion.trim()) {
-          return this.executeAssertion(urlBeforeCommand, command.condition);
+  executePresetStep(command, disableCache) {
+    return __async(this, null, function* () {
+      var _a, _b, _c;
+      const urlBeforeCommand = this.browser.url;
+      switch (command.type) {
+        case "SUCCESS" /* SUCCESS */:
+          if ((_a = command.condition) == null ? void 0 : _a.assertion.trim()) {
+            return this.executeAssertion(urlBeforeCommand, command.condition);
+          }
+          return {
+            succeedImmediately: false,
+            urlAfterCommand: this.browser.url
+          };
+        case "AI_ASSERTION" /* AI_ASSERTION */: {
+          return this.executeAssertion(urlBeforeCommand, command);
         }
-        return {
-          succeedImmediately: false,
-          urlAfterCommand: this.browser.url
-        };
-      case "AI_ASSERTION" /* AI_ASSERTION */: {
-        return this.executeAssertion(urlBeforeCommand, command);
-      }
-      case "NAVIGATE" /* NAVIGATE */:
-        await this.browser.navigate(command.url);
-        break;
-      case "GO_BACK" /* GO_BACK */:
-        await this.browser.goBack();
-        break;
-      case "GO_FORWARD" /* GO_FORWARD */:
-        await this.browser.goForward();
-        break;
-      case "SCROLL_DOWN" /* SCROLL_DOWN */:
-        await this.browser.scrollDown();
-        break;
-      case "SCROLL_UP" /* SCROLL_UP */:
-        await this.browser.scrollUp();
-        break;
-      case "WAIT" /* WAIT */:
-        await this.browser.wait(command.delay * 1e3);
-        break;
-      case "REFRESH" /* REFRESH */:
-        await this.browser.refresh();
-        break;
-      case "CLICK" /* CLICK */: {
-        let id;
-        if (command.target.a11yData) {
-          id = (_b = command.target.a11yData) == null ? void 0 : _b.id;
-        } else {
-          const locator = await this.locateElement(
-            command.target.elementDescriptor,
-            disableCache
+        case "NAVIGATE" /* NAVIGATE */:
+          yield this.browser.navigate(command.url);
+          break;
+        case "GO_BACK" /* GO_BACK */:
+          yield this.browser.goBack();
+          break;
+        case "GO_FORWARD" /* GO_FORWARD */:
+          yield this.browser.goForward();
+          break;
+        case "SCROLL_DOWN" /* SCROLL_DOWN */:
+          yield this.browser.scrollDown();
+          break;
+        case "SCROLL_UP" /* SCROLL_UP */:
+          yield this.browser.scrollUp();
+          break;
+        case "WAIT" /* WAIT */:
+          yield this.browser.wait(command.delay * 1e3);
+          break;
+        case "REFRESH" /* REFRESH */:
+          yield this.browser.refresh();
+          break;
+        case "CLICK" /* CLICK */: {
+          let id;
+          if (command.target.a11yData) {
+            id = (_b = command.target.a11yData) == null ? void 0 : _b.id;
+          } else {
+            const locator = yield this.locateElement(
+              command.target.elementDescriptor,
+              disableCache
+            );
+            id = locator.id;
+          }
+          const elementInteracted = yield this.browser.click(
+            {
+              id
+            },
+            {
+              doubleClick: command.doubleClick,
+              rightClick: command.rightClick
+            }
           );
-          id = locator.id;
-        }
-        const elementInteracted = await this.browser.click(
-          {
-            id
-          },
-          {
-            doubleClick: command.doubleClick,
-            rightClick: command.rightClick
+          const result2 = {
+            urlAfterCommand: this.browser.url,
+            succeedImmediately: false,
+            elementInteracted
+          };
+          if (urlChanged(urlBeforeCommand, result2.urlAfterCommand)) {
+            result2.succeedImmediately = true;
+            result2.succeedImmediatelyReason = "URL changed";
           }
-        );
-        const result2 = {
-          urlAfterCommand: this.browser.url,
-          succeedImmediately: false,
-          elementInteracted
-        };
-        if (urlChanged(urlBeforeCommand, result2.urlAfterCommand)) {
-          result2.succeedImmediately = true;
-          result2.succeedImmediatelyReason = "URL changed";
+          return result2;
         }
-        return result2;
-      }
-      case "SELECT_OPTION" /* SELECT_OPTION */: {
-        let id;
-        if (command.target.a11yData) {
-          id = (_c = command.target.a11yData) == null ? void 0 : _c.id;
-        } else {
-          const locator = await this.locateElement(
-            command.target.elementDescriptor,
-            disableCache
+        case "SELECT_OPTION" /* SELECT_OPTION */: {
+          let id;
+          if (command.target.a11yData) {
+            id = (_c = command.target.a11yData) == null ? void 0 : _c.id;
+          } else {
+            const locator = yield this.locateElement(
+              command.target.elementDescriptor,
+              disableCache
+            );
+            id = locator.id;
+          }
+          const elementInteracted = yield this.browser.selectOption(
+            {
+              id
+            },
+            command.option
           );
-          id = locator.id;
+          return {
+            succeedImmediately: false,
+            urlAfterCommand: this.browser.url,
+            elementInteracted
+          };
         }
-        const elementInteracted = await this.browser.selectOption(
-          {
-            id
-          },
-          command.option
-        );
-        return {
-          succeedImmediately: false,
-          urlAfterCommand: this.browser.url,
-          elementInteracted
-        };
-      }
-      case "TAB" /* TAB */:
-        await this.browser.switchToPage(command.url);
-        break;
-      case "COOKIE" /* COOKIE */:
-        await this.browser.setCookie(command.value);
-        break;
-      case "TYPE" /* TYPE */: {
-        let elementInteracted;
-        const target = command.target;
-        if (target.a11yData) {
-          elementInteracted = await this.browser.click({
-            id: target.a11yData.id
-          });
-        } else if (target.elementDescriptor.length > 0) {
-          const locator = await this.locateElement(
-            command.target.elementDescriptor,
-            disableCache
-          );
-          elementInteracted = await this.browser.click({
-            id: locator.id
+        case "TAB" /* TAB */:
+          yield this.browser.switchToPage(command.url);
+          break;
+        case "COOKIE" /* COOKIE */:
+          yield this.browser.setCookie(command.value);
+          break;
+        case "TYPE" /* TYPE */: {
+          let elementInteracted;
+          const target = command.target;
+          if (target.a11yData) {
+            elementInteracted = yield this.browser.click({
+              id: target.a11yData.id
+            });
+          } else if (target.elementDescriptor.length > 0) {
+            const locator = yield this.locateElement(
+              command.target.elementDescriptor,
+              disableCache
+            );
+            elementInteracted = yield this.browser.click({
+              id: locator.id
+            });
+          }
+          yield this.browser.type(command.value, {
+            clearContent: command.clearContent,
+            pressKeysSequentially: command.pressKeysSequentially
           });
+          if (command.pressEnter) {
+            yield this.browser.press("Enter");
+          }
+          const result2 = {
+            urlAfterCommand: this.browser.url,
+            succeedImmediately: false,
+            elementInteracted
+          };
+          if (urlChanged(urlBeforeCommand, result2.urlAfterCommand)) {
+            result2.succeedImmediately = true;
+            result2.succeedImmediatelyReason = "URL changed";
+          }
+          return result2;
         }
-        await this.browser.type(command.value, {
-          clearContent: command.clearContent,
-          pressKeysSequentially: command.pressKeysSequentially
-        });
-        if (command.pressEnter) {
-          await this.browser.press("Enter");
-        }
-        const result2 = {
-          urlAfterCommand: this.browser.url,
-          succeedImmediately: false,
-          elementInteracted
-        };
-        if (urlChanged(urlBeforeCommand, result2.urlAfterCommand)) {
-          result2.succeedImmediately = true;
-          result2.succeedImmediatelyReason = "URL changed";
-        }
-        return result2;
+        case "PRESS" /* PRESS */:
+          yield this.browser.press(command.value);
+          const result = {
+            urlAfterCommand: this.browser.url,
+            succeedImmediately: false
+          };
+          if (urlChanged(urlBeforeCommand, result.urlAfterCommand)) {
+            result.succeedImmediately = true;
+            result.succeedImmediatelyReason = "URL changed";
+          }
+          return result;
+        default:
+          const assertUnreachable = (_x) => {
+            throw "If Typescript complains about the line below, you missed a case or break in the switch above";
+          };
+          return assertUnreachable(command);
       }
-      case "PRESS" /* PRESS */:
-        await this.browser.press(command.value);
-        const result = {
-          urlAfterCommand: this.browser.url,
-          succeedImmediately: false
-        };
-        if (urlChanged(urlBeforeCommand, result.urlAfterCommand)) {
-          result.succeedImmediately = true;
-          result.succeedImmediatelyReason = "URL changed";
-        }
-        return result;
-      default:
-        const assertUnreachable = (_x) => {
-          throw "If Typescript complains about the line below, you missed a case or break in the switch above";
-        };
-        return assertUnreachable(command);
-    }
-    return {
-      succeedImmediately: false,
-      urlAfterCommand: this.browser.url
-    };
+      return {
+        succeedImmediately: false,
+        urlAfterCommand: this.browser.url
+      };
+    });
   }
 };
 
@@ -2265,96 +2371,104 @@ import fetchRetry from "fetch-retry";
 var fetch2 = fetchRetry(global.fetch);
 var API_VERSION = "v1";
 var APIGenerator = class {
-  baseURL;
-  apiKey;
   constructor(params) {
     this.baseURL = params.baseURL;
     this.apiKey = params.apiKey;
   }
-  async getElementLocation(context, disableCache) {
-    const result = await this.sendRequest(
-      `/${API_VERSION}/web-agent/locate-element`,
-      {
-        browserState: context.browserState,
-        goal: context.goal,
-        disableCache
-      }
-    );
-    return LocateResponseSchema.parse(result);
+  getElementLocation(context, disableCache) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(
+        `/${API_VERSION}/web-agent/locate-element`,
+        {
+          browserState: context.browserState,
+          goal: context.goal,
+          disableCache
+        }
+      );
+      return LocateResponseSchema.parse(result);
+    });
   }
-  async getAssertionResult(context, useVision, disableCache) {
-    var _a;
-    if (useVision) {
-      const result2 = await this.sendRequest(
+  getAssertionResult(context, useVision, disableCache) {
+    return __async(this, null, function* () {
+      var _a;
+      if (useVision) {
+        const result2 = yield this.sendRequest(
+          `/${API_VERSION}/web-agent/assertion`,
+          {
+            url: context.url,
+            goal: context.goal,
+            screenshot: (_a = context.screenshot) == null ? void 0 : _a.toString("base64"),
+            disableCache,
+            vision: true
+          }
+        );
+        return GetAssertionResponseSchema.parse(result2);
+      }
+      const result = yield this.sendRequest(
         `/${API_VERSION}/web-agent/assertion`,
         {
           url: context.url,
+          browserState: context.browserState,
           goal: context.goal,
-          screenshot: (_a = context.screenshot) == null ? void 0 : _a.toString("base64"),
+          history: context.history,
+          numPrevious: context.numPrevious,
+          lastCommand: context.lastCommand,
           disableCache,
-          vision: true
+          vision: false
         }
       );
-      return GetAssertionResponseSchema.parse(result2);
-    }
-    const result = await this.sendRequest(
-      `/${API_VERSION}/web-agent/assertion`,
-      {
-        url: context.url,
-        browserState: context.browserState,
-        goal: context.goal,
-        history: context.history,
-        numPrevious: context.numPrevious,
-        lastCommand: context.lastCommand,
-        disableCache,
-        vision: false
-      }
-    );
-    return GetAssertionResponseSchema.parse(result);
-  }
-  async getProposedCommand(context, disableCache) {
-    const result = await this.sendRequest(
-      `/${API_VERSION}/web-agent/next-command`,
-      {
-        url: context.url,
-        browserState: context.browserState,
-        goal: context.goal,
-        history: context.history,
-        numPrevious: context.numPrevious,
-        lastCommand: context.lastCommand,
-        disableCache
-      }
-    );
-    return GetNextCommandResponseSchema.parse(result);
-  }
-  async getGranularGoals(context, disableCache) {
-    const result = await this.sendRequest(
-      `/${API_VERSION}/web-agent/split-goal`,
-      {
-        url: context.url,
-        goal: context.goal,
-        disableCache
-      }
-    );
-    return SplitGoalResponseSchema.parse(result);
-  }
-  async sendRequest(path, body) {
-    const response = await fetch2(`${this.baseURL}${path}`, {
-      retries: 3,
-      retryDelay: 1e3,
-      method: "POST",
-      body: JSON.stringify(body),
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
-      }
+      return GetAssertionResponseSchema.parse(result);
     });
-    if (!response.ok) {
-      throw new Error(
-        `Request to ${path} failed with status ${response.status}: ${await response.text()}`
+  }
+  getProposedCommand(context, disableCache) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(
+        `/${API_VERSION}/web-agent/next-command`,
+        {
+          url: context.url,
+          browserState: context.browserState,
+          goal: context.goal,
+          history: context.history,
+          numPrevious: context.numPrevious,
+          lastCommand: context.lastCommand,
+          disableCache
+        }
       );
-    }
-    return response.json();
+      return GetNextCommandResponseSchema.parse(result);
+    });
+  }
+  getGranularGoals(context, disableCache) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(
+        `/${API_VERSION}/web-agent/split-goal`,
+        {
+          url: context.url,
+          goal: context.goal,
+          disableCache
+        }
+      );
+      return SplitGoalResponseSchema.parse(result);
+    });
+  }
+  sendRequest(path, body) {
+    return __async(this, null, function* () {
+      const response = yield fetch2(`${this.baseURL}${path}`, {
+        retries: 3,
+        retryDelay: 1e3,
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Request to ${path} failed with status ${response.status}: ${yield response.text()}`
+        );
+      }
+      return response.json();
+    });
   }
 };
 
@@ -2364,62 +2478,72 @@ var version = "1.0.0";
 // src/api-client.ts
 var API_VERSION2 = "v1";
 var APIClient = class {
-  baseURL;
-  apiKey;
   constructor(params) {
     this.baseURL = params.baseURL;
     this.apiKey = params.apiKey;
   }
-  async getRun(runId) {
-    const result = await this.sendRequest(`/${API_VERSION2}/runs/${runId}`, {
-      method: "GET"
+  getRun(runId) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION2}/runs/${runId}`, {
+        method: "GET"
+      });
+      return GetRunResponseSchema.parse(result);
     });
-    return GetRunResponseSchema.parse(result);
   }
-  async createRun(body) {
-    const result = await this.sendRequest(`/${API_VERSION2}/runs`, {
-      method: "POST",
-      body
+  createRun(body) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION2}/runs`, {
+        method: "POST",
+        body
+      });
+      return CreateRunResponseSchema.parse(result);
     });
-    return CreateRunResponseSchema.parse(result);
   }
-  async updateRun(runId, body) {
-    await this.sendRequest(`/${API_VERSION2}/runs/${runId}`, {
-      method: "PATCH",
-      body
+  updateRun(runId, body) {
+    return __async(this, null, function* () {
+      yield this.sendRequest(`/${API_VERSION2}/runs/${runId}`, {
+        method: "PATCH",
+        body
+      });
     });
   }
-  async getTest(testId) {
-    const result = await this.sendRequest(`/${API_VERSION2}/tests/${testId}`, {
-      method: "GET"
+  getTest(testId) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION2}/tests/${testId}`, {
+        method: "GET"
+      });
+      return GetTestResponseSchema.parse(result);
     });
-    return GetTestResponseSchema.parse(result);
   }
-  async uploadScreenshot(body) {
-    const result = await this.sendRequest(`/${API_VERSION2}/screenshots`, {
-      method: "POST",
-      body
+  uploadScreenshot(body) {
+    return __async(this, null, function* () {
+      const result = yield this.sendRequest(`/${API_VERSION2}/screenshots`, {
+        method: "POST",
+        body
+      });
+      return CreateScreenshotResponseSchema.parse(result);
     });
-    return CreateScreenshotResponseSchema.parse(result);
   }
-  async sendRequest(path, options) {
-    const response = await fetch(`${this.baseURL}${path}`, {
-      method: options.method,
-      body: options.body ? JSON.stringify(options.body) : void 0,
-      headers: {
-        "Content-Type": "application/json",
-        Authorization: `Bearer ${this.apiKey}`
+  sendRequest(path, options) {
+    return __async(this, null, function* () {
+      const response = yield fetch(`${this.baseURL}${path}`, {
+        method: options.method,
+        body: options.body ? JSON.stringify(options.body) : void 0,
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.apiKey}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error(
+          `Request to ${path} failed with status ${response.status}: ${yield response.text()}`
+        );
+      }
+      if (response.status === 204) {
+        return response.text();
       }
+      return response.json();
     });
-    if (!response.ok) {
-      throw new Error(
-        `Request to ${path} failed with status ${response.status}: ${await response.text()}`
-      );
-    }
-    if (response.status === 204) {
-      return response.text();
-    }
-    return response.json();
   }
 };
 
@@ -2427,25 +2551,29 @@ var APIClient = class {
 var MAX_COMMANDS_PER_STEP = 20;
 
 // ../../packages/execute/src/steps/ai.ts
-var executeAIStep = async ({
-  controller,
-  step,
-  logger,
-  advanced,
-  ...callbacks
-}) => {
-  var _a, _b, _c, _d, _e, _f;
-  (_a = callbacks.onStarted) == null ? void 0 : _a.call(callbacks);
+var executeAIStep = (_a) => __async(void 0, null, function* () {
+  var _b = _a, {
+    controller,
+    step,
+    logger,
+    advanced
+  } = _b, callbacks = __objRest(_b, [
+    "controller",
+    "step",
+    "logger",
+    "advanced"
+  ]);
+  var _a2, _b2, _c, _d, _e, _f, _g;
+  (_a2 = callbacks.onStarted) == null ? void 0 : _a2.call(callbacks);
   controller.resetHistory();
-  const result = {
-    ...step,
+  const result = __spreadProps(__spreadValues({}, step), {
     startedAt: /* @__PURE__ */ new Date(),
     userAgent: ChromeBrowser.USER_AGENT,
     // placeholder values
     finishedAt: /* @__PURE__ */ new Date(),
     results: [],
     status: "SUCCESS" /* SUCCESS */
-  };
+  });
   try {
     let commandIndex = 0;
     let useSavedCommands = step.commands && step.commands.length > 0;
@@ -2457,8 +2585,8 @@ var executeAIStep = async ({
       }
       let command;
       const startedAt = /* @__PURE__ */ new Date();
-      const beforeScreenshotBuffer = await controller.browser.screenshot();
-      const beforeScreenshot = await callbacks.onSaveScreenshot(
+      const beforeScreenshotBuffer = yield controller.browser.screenshot();
+      const beforeScreenshot = yield callbacks.onSaveScreenshot(
         beforeScreenshotBuffer
       );
       if (useSavedCommands) {
@@ -2469,7 +2597,7 @@ var executeAIStep = async ({
           );
         }
       } else {
-        command = await controller.promptToCommand(
+        command = yield controller.promptToCommand(
           step.type,
           step.text,
           advanced.disableAICaching
@@ -2481,7 +2609,7 @@ var executeAIStep = async ({
         result.message = command.thoughts;
         break;
       }
-      (_b = callbacks.onCommandGenerated) == null ? void 0 : _b.call(callbacks, {
+      (_b2 = callbacks.onCommandGenerated) == null ? void 0 : _b2.call(callbacks, {
         commandIndex,
         message: CARD_DISPLAY_NAMES[command.type] || `Unknown command (${command.type})`
       });
@@ -2498,7 +2626,7 @@ var executeAIStep = async ({
         `Executing command ${commandIndex}: ${serializeCommand(command)}`
       );
       try {
-        const executionResult = await controller.executeCommand(
+        const executionResult = yield controller.executeCommand(
           command,
           advanced.disableAICaching,
           useSavedCommands
@@ -2509,8 +2637,8 @@ var executeAIStep = async ({
           message: serializeCommand(command),
           command
         });
-        const afterScreenshotBuffer = await controller.browser.screenshot();
-        const afterScreenshot = await callbacks.onSaveScreenshot(
+        const afterScreenshotBuffer = yield controller.browser.screenshot();
+        const afterScreenshot = yield callbacks.onSaveScreenshot(
           afterScreenshotBuffer
         );
         cmdResult.afterScreenshot = afterScreenshot;
@@ -2528,7 +2656,7 @@ var executeAIStep = async ({
         if (command.type === "SUCCESS" /* SUCCESS */) {
           result.finishedAt = /* @__PURE__ */ new Date();
           result.status = "SUCCESS" /* SUCCESS */;
-          result.message = executionResult.thoughts ?? "All commands completed.";
+          result.message = (_d = executionResult.thoughts) != null ? _d : "All commands completed.";
           break;
         }
         if (executionResult.succeedImmediately && !useSavedCommands) {
@@ -2538,15 +2666,14 @@ var executeAIStep = async ({
           command = {
             type: "SUCCESS" /* SUCCESS */
           };
-          (_d = callbacks.onCommandExecuted) == null ? void 0 : _d.call(callbacks, {
+          (_e = callbacks.onCommandExecuted) == null ? void 0 : _e.call(callbacks, {
             commandIndex: commandIndex + 1,
             message: serializeCommand(command),
             command
           });
-          result.results.push({
-            ...presetActionResult,
+          result.results.push(__spreadProps(__spreadValues({}, presetActionResult), {
             command
-          });
+          }));
           break;
         }
       } catch (err) {
@@ -2583,54 +2710,57 @@ var executeAIStep = async ({
     result.status = "FAILED" /* FAILED */;
   }
   if (result.status === "SUCCESS" /* SUCCESS */) {
-    (_e = callbacks.onSuccess) == null ? void 0 : _e.call(callbacks, {
+    (_f = callbacks.onSuccess) == null ? void 0 : _f.call(callbacks, {
       message: result.message || "AI step succeeded.",
       startedAt: result.startedAt.getTime(),
       durationMs: result.finishedAt.getTime() - result.startedAt.getTime()
     });
   } else {
-    (_f = callbacks.onFailure) == null ? void 0 : _f.call(callbacks, {
+    (_g = callbacks.onFailure) == null ? void 0 : _g.call(callbacks, {
       message: result.message || "AI step errored.",
       startedAt: result.startedAt.getTime(),
       durationMs: result.finishedAt.getTime() - result.startedAt.getTime()
     });
   }
   return result;
-};
+});
 
 // ../../packages/execute/src/steps/preset.ts
-var executePresetStep = async ({
-  controller,
-  step,
-  advanced,
-  ...callbacks
-}) => {
-  var _a, _b, _c;
-  (_a = callbacks.onStarted) == null ? void 0 : _a.call(callbacks);
+var executePresetStep = (_a) => __async(void 0, null, function* () {
+  var _b = _a, {
+    controller,
+    step,
+    advanced
+  } = _b, callbacks = __objRest(_b, [
+    "controller",
+    "step",
+    "advanced"
+  ]);
+  var _a2, _b2, _c;
+  (_a2 = callbacks.onStarted) == null ? void 0 : _a2.call(callbacks);
   const startedAt = /* @__PURE__ */ new Date();
   const beforeUrl = controller.browser.url;
-  const beforeScreenshotBuffer = await controller.browser.screenshot();
-  const beforeScreenshot = await callbacks.onSaveScreenshot(
+  const beforeScreenshotBuffer = yield controller.browser.screenshot();
+  const beforeScreenshot = yield callbacks.onSaveScreenshot(
     beforeScreenshotBuffer
   );
   try {
-    const execResult = await controller.executePresetStep(
+    const execResult = yield controller.executePresetStep(
       step.command,
       advanced.disableAICaching
     );
-    const afterScreenshotBuffer = await controller.browser.screenshot();
-    const afterScreenshot = await callbacks.onSaveScreenshot(
+    const afterScreenshotBuffer = yield controller.browser.screenshot();
+    const afterScreenshot = yield callbacks.onSaveScreenshot(
       afterScreenshotBuffer
     );
     const finishedAt = /* @__PURE__ */ new Date();
-    const result = {
-      ...step,
+    const result = __spreadProps(__spreadValues({}, step), {
       startedAt,
       finishedAt,
       // placeholder values
       status: "SUCCESS" /* SUCCESS */,
       results: []
-    };
+    });
     let message = "Successfully executed preset action.";
     if (step.command.type === "AI_ASSERTION" /* AI_ASSERTION */) {
       message = execResult.thoughts || "Assertion passed.";
@@ -2648,7 +2778,7 @@ var executePresetStep = async ({
     result.status = "SUCCESS" /* SUCCESS */;
     result.results = [cmdMetadata];
     result.message = message;
-    (_b = callbacks.onSuccess) == null ? void 0 : _b.call(callbacks, {
+    (_b2 = callbacks.onSuccess) == null ? void 0 : _b2.call(callbacks, {
       message,
       startedAt: startedAt.getTime(),
       durationMs: finishedAt.getTime() - startedAt.getTime()
@@ -2656,8 +2786,7 @@ var executePresetStep = async ({
     return result;
   } catch (err) {
     const finishedAt = /* @__PURE__ */ new Date();
-    const result = {
-      ...step,
+    const result = __spreadProps(__spreadValues({}, step), {
       startedAt,
       finishedAt,
       status: "FAILED" /* FAILED */,
@@ -2675,7 +2804,7 @@ var executePresetStep = async ({
           message: `${err}`
         }
       ]
-    };
+    });
     (_c = callbacks.onFailure) == null ? void 0 : _c.call(callbacks, {
       message: `${err}`,
       startedAt: startedAt.getTime(),
@@ -2683,18 +2812,23 @@ var executePresetStep = async ({
     });
     return result;
   }
-};
+});
 
 // ../../packages/execute/src/steps/module.ts
-var executeModuleStep = async ({
-  controller,
-  step,
-  advanced,
-  logger,
-  ...callbacks
-}) => {
-  var _a, _b, _c;
-  (_a = callbacks.onStarted) == null ? void 0 : _a.call(callbacks);
+var executeModuleStep = (_a) => __async(void 0, null, function* () {
+  var _b = _a, {
+    controller,
+    step,
+    advanced,
+    logger
+  } = _b, callbacks = __objRest(_b, [
+    "controller",
+    "step",
+    "advanced",
+    "logger"
+  ]);
+  var _a2, _b2, _c;
+  (_a2 = callbacks.onStarted) == null ? void 0 : _a2.call(callbacks);
   const result = {
     type: "MODULE" /* MODULE */,
     moduleId: step.moduleId,
@@ -2711,19 +2845,19 @@ var executeModuleStep = async ({
     let moduleStepResult;
     switch (moduleStep.type) {
       case "PRESET_ACTION" /* PRESET_ACTION */:
-        moduleStepResult = await executePresetStep({
+        moduleStepResult = yield executePresetStep({
           controller,
           step: moduleStep,
           advanced,
           logger,
           onSaveScreenshot: callbacks.onSaveScreenshot,
           onStarted() {
-            var _a2;
-            (_a2 = callbacks.onStepStarted) == null ? void 0 : _a2.call(callbacks, { index: i });
+            var _a3;
+            (_a3 = callbacks.onStepStarted) == null ? void 0 : _a3.call(callbacks, { index: i });
           },
           onSuccess({ message, startedAt, durationMs }) {
-            var _a2;
-            (_a2 = callbacks.onStepSuccess) == null ? void 0 : _a2.call(callbacks, {
+            var _a3;
+            (_a3 = callbacks.onStepSuccess) == null ? void 0 : _a3.call(callbacks, {
               index: i,
               message,
               startedAt,
@@ -2731,8 +2865,8 @@ var executeModuleStep = async ({
             });
           },
           onFailure({ message, startedAt, durationMs }) {
-            var _a2;
-            (_a2 = callbacks.onStepFailure) == null ? void 0 : _a2.call(callbacks, {
+            var _a3;
+            (_a3 = callbacks.onStepFailure) == null ? void 0 : _a3.call(callbacks, {
               index: i,
               message,
               startedAt,
@@ -2742,19 +2876,19 @@ var executeModuleStep = async ({
         });
         break;
       case "AI_ACTION" /* AI_ACTION */:
-        moduleStepResult = await executeAIStep({
+        moduleStepResult = yield executeAIStep({
           controller,
           step: moduleStep,
           advanced,
           logger,
           onSaveScreenshot: callbacks.onSaveScreenshot,
           onStarted() {
-            var _a2;
-            (_a2 = callbacks.onStepStarted) == null ? void 0 : _a2.call(callbacks, { index: i });
+            var _a3;
+            (_a3 = callbacks.onStepStarted) == null ? void 0 : _a3.call(callbacks, { index: i });
           },
           onSuccess({ message, startedAt, durationMs }) {
-            var _a2;
-            (_a2 = callbacks.onStepSuccess) == null ? void 0 : _a2.call(callbacks, {
+            var _a3;
+            (_a3 = callbacks.onStepSuccess) == null ? void 0 : _a3.call(callbacks, {
               index: i,
               message,
               startedAt,
@@ -2762,8 +2896,8 @@ var executeModuleStep = async ({
             });
           },
           onFailure({ message, startedAt, durationMs }) {
-            var _a2;
-            (_a2 = callbacks.onStepFailure) == null ? void 0 : _a2.call(callbacks, {
+            var _a3;
+            (_a3 = callbacks.onStepFailure) == null ? void 0 : _a3.call(callbacks, {
               index: i,
               message,
               startedAt,
@@ -2771,12 +2905,12 @@ var executeModuleStep = async ({
             });
           },
           onCommandGenerated({ commandIndex, message }) {
-            var _a2;
-            (_a2 = callbacks.onCommandGenerated) == null ? void 0 : _a2.call(callbacks, { index: i, commandIndex, message });
+            var _a3;
+            (_a3 = callbacks.onCommandGenerated) == null ? void 0 : _a3.call(callbacks, { index: i, commandIndex, message });
           },
           onCommandExecuted({ commandIndex, message, command }) {
-            var _a2;
-            (_a2 = callbacks.onCommandExecuted) == null ? void 0 : _a2.call(callbacks, {
+            var _a3;
+            (_a3 = callbacks.onCommandExecuted) == null ? void 0 : _a3.call(callbacks, {
               index: i,
               commandIndex,
               message,
@@ -2797,22 +2931,21 @@ var executeModuleStep = async ({
       result.finishedAt = /* @__PURE__ */ new Date();
       for (let j = i + 1; j < step.steps.length; j++) {
         const skippedStep = step.steps[j];
-        const skippedResult = {
-          ...skippedStep,
+        const skippedResult = __spreadProps(__spreadValues({}, skippedStep), {
           status: "CANCELLED" /* CANCELLED */,
           startedAt: /* @__PURE__ */ new Date(),
           finishedAt: /* @__PURE__ */ new Date(),
           userAgent: ChromeBrowser.USER_AGENT,
           results: [],
           message: "Cancelled due to previous failure."
-        };
+        });
         result.results.push(skippedResult);
       }
       break;
     }
   }
   if (result.status === "SUCCESS" /* SUCCESS */) {
-    (_b = callbacks.onSuccess) == null ? void 0 : _b.call(callbacks, {
+    (_b2 = callbacks.onSuccess) == null ? void 0 : _b2.call(callbacks, {
       message: "Executed module step.",
       startedAt: result.startedAt.getTime(),
       durationMs: result.finishedAt.getTime() - result.startedAt.getTime()
@@ -2825,20 +2958,20 @@ var executeModuleStep = async ({
     });
   }
   return result;
-};
+});
 
 // ../../packages/execute/src/test.ts
-var executeTest = async ({
+var executeTest = (_0) => __async(void 0, [_0], function* ({
   test,
   runId,
   controller,
   logger,
   onUpdateRun,
   onSaveScreenshot
-}) => {
+}) {
   const advanced = TestAdvancedSettingsSchema.parse(test.advanced);
   logger.info(`Starting run ${runId} for test ${test.id}`);
-  await onUpdateRun({
+  yield onUpdateRun({
     status: "RUNNING",
     startedAt: /* @__PURE__ */ new Date()
   });
@@ -2849,7 +2982,7 @@ var executeTest = async ({
     let result;
     switch (step.type) {
       case "PRESET_ACTION" /* PRESET_ACTION */:
-        result = await executePresetStep({
+        result = yield executePresetStep({
           controller,
           step,
           advanced,
@@ -2858,7 +2991,7 @@ var executeTest = async ({
         });
         break;
       case "AI_ACTION" /* AI_ACTION */:
-        result = await executeAIStep({
+        result = yield executeAIStep({
           controller,
           step,
           advanced,
@@ -2867,7 +3000,7 @@ var executeTest = async ({
         });
         break;
       case "RESOLVED_MODULE":
-        result = await executeModuleStep({
+        result = yield executeModuleStep({
           controller,
           step,
           advanced,
@@ -2882,7 +3015,7 @@ var executeTest = async ({
         return assertUnreachable(step);
     }
     results.push(result);
-    await onUpdateRun({
+    yield onUpdateRun({
       results
     });
     if (result.status === "FAILED" /* FAILED */) {
@@ -2896,28 +3029,26 @@ var executeTest = async ({
             startedAt: /* @__PURE__ */ new Date(),
             userAgent: ChromeBrowser.USER_AGENT,
             results: skippedStep.steps.map((s) => {
-              return {
-                ...s,
+              return __spreadProps(__spreadValues({}, s), {
                 status: "CANCELLED" /* CANCELLED */,
                 startedAt: /* @__PURE__ */ new Date(),
                 finishedAt: /* @__PURE__ */ new Date(),
                 userAgent: ChromeBrowser.USER_AGENT,
                 results: []
-              };
+              });
             }),
             finishedAt: /* @__PURE__ */ new Date(),
             status: "CANCELLED" /* CANCELLED */
           };
           results.push(skippedResult);
         } else {
-          const skippedResult = {
-            ...skippedStep,
+          const skippedResult = __spreadProps(__spreadValues({}, skippedStep), {
             status: "CANCELLED" /* CANCELLED */,
             startedAt: /* @__PURE__ */ new Date(),
             finishedAt: /* @__PURE__ */ new Date(),
             userAgent: ChromeBrowser.USER_AGENT,
             results: []
-          };
+          });
           results.push(skippedResult);
         }
       }
@@ -2926,14 +3057,14 @@ var executeTest = async ({
       break;
     }
   }
-  await onUpdateRun({
+  yield onUpdateRun({
     status: failed ? "FAILED" : "PASSED",
     finishedAt: /* @__PURE__ */ new Date(),
     results
   });
-  await controller.browser.cleanup();
+  yield controller.browser.cleanup();
   return failed;
-};
+});
 
 // src/logger.ts
 var consoleLogger = {
@@ -2947,47 +3078,58 @@ var consoleLogger = {
 };
 
 // src/run-test.ts
-async function runTest({
-  testId,
-  apiClient,
-  generator
-}) {
-  const test = await apiClient.getTest(testId);
-  const browser = await ChromeBrowser.init(test.baseUrl, consoleLogger);
-  const controller = new AgentController({
-    browser,
+function runTest(_0) {
+  return __async(this, arguments, function* ({
+    testId,
+    apiClient,
     generator,
-    config: DEFAULT_CONTROLLER_CONFIG,
-    logger: consoleLogger
-  });
-  const run = await apiClient.createRun({
-    testId
-  });
-  let failed = true;
-  try {
-    failed = await executeTest({
-      test,
-      runId: run.id,
-      controller,
-      logger: consoleLogger,
-      onSaveScreenshot: async (buffer) => {
-        const { key } = await apiClient.uploadScreenshot({
-          screenshot: buffer.toString("base64")
-        });
-        return key;
-      },
-      onUpdateRun: async (data) => {
-        await apiClient.updateRun(run.id, data);
-      }
+    newBaseURL
+  }) {
+    const test = yield apiClient.getTest(testId);
+    const originalURL = new URL(test.baseUrl);
+    const newURL = new URL(newBaseURL);
+    originalURL.hostname = newURL.hostname;
+    originalURL.protocol = newURL.protocol;
+    originalURL.port = newURL.port;
+    const browser = yield ChromeBrowser.init(
+      originalURL.toString(),
+      consoleLogger
+    );
+    const controller = new AgentController({
+      browser,
+      generator,
+      config: DEFAULT_CONTROLLER_CONFIG,
+      logger: consoleLogger
     });
-  } catch (err) {
-    consoleLogger.error(err);
-    await apiClient.updateRun(run.id, {
-      status: "FAILED",
-      finishedAt: /* @__PURE__ */ new Date()
+    const run = yield apiClient.createRun({
+      testId
     });
-  }
-  return failed;
+    let failed = true;
+    try {
+      failed = yield executeTest({
+        test,
+        runId: run.id,
+        controller,
+        logger: consoleLogger,
+        onSaveScreenshot: (buffer) => __async(this, null, function* () {
+          const { key } = yield apiClient.uploadScreenshot({
+            screenshot: buffer.toString("base64")
+          });
+          return key;
+        }),
+        onUpdateRun: (data) => __async(this, null, function* () {
+          yield apiClient.updateRun(run.id, data);
+        })
+      });
+    } catch (err) {
+      consoleLogger.error(err);
+      yield apiClient.updateRun(run.id, {
+        status: "FAILED",
+        finishedAt: /* @__PURE__ */ new Date()
+      });
+    }
+    return failed;
+  });
 }
 
 // src/cli.ts
@@ -3014,10 +3156,10 @@ program.command("run-tests").addOption(
   ).default(60, "one minute")
 ).addOption(
   new Option("--api-key <key>", "API key for authenticating").env("MOMENTIC_API_KEY").makeOptionMandatory(true)
-).action(async (options) => {
+).action((options) => __async(void 0, null, function* () {
   const { tests, start, waitOn, waitOnTimeout, apiKey } = options;
-  await execCommand(start, false);
-  await waitOnFn({
+  yield execCommand(start, false);
+  yield waitOnFn({
     resources: [waitOn],
     timeout: waitOnTimeout * 1e3
   });
@@ -3029,15 +3171,16 @@ program.command("run-tests").addOption(
     baseURL: "https://api.momentic.ai",
     apiKey
   });
-  const promises = tests.map(async (testId) => {
-    const failed = await runTest({
+  const promises = tests.map((testId) => __async(void 0, null, function* () {
+    const failed = yield runTest({
       testId,
       apiClient,
-      generator: apiGenerator
+      generator: apiGenerator,
+      newBaseURL: waitOn
     });
     return { failed, testId };
-  });
-  const results = await Promise.all(promises);
+  }));
+  const results = yield Promise.all(promises);
   const failedResults = results.filter((result) => result.failed);
   if (failedResults.length > 0) {
     console.log(
@@ -3051,17 +3194,19 @@ program.command("run-tests").addOption(
     process.exit(1);
   }
   console.log(chalk.green(`All ${results.length} tests passed!`));
-});
-var execCommand = async (fullCommand, waitToFinish = true) => {
+}));
+var execCommand = (fullCommand, waitToFinish = true) => __async(void 0, null, function* () {
   const args = parseArgsStringToArgv2(fullCommand);
-  const toolPath = await io.which(args[0], true);
+  const toolPath = yield io.which(args[0], true);
   const toolArguments = args.slice(1);
   const promise = exec.exec(quote(toolPath), toolArguments);
   if (waitToFinish) {
     return promise;
   }
-};
-async function main() {
-  await program.parseAsync(process.argv);
+});
+function main() {
+  return __async(this, null, function* () {
+    yield program.parseAsync(process.argv);
+  });
 }
 void main();