automation_model 1.0.783-dev → 1.0.783-stage

package/lib/stable_browser.js

@@ -1,4 +1,5 @@
 // @ts-nocheck
+import { check_performance } from "./check_performance.js";
 import { expect } from "@playwright/test";
 import dayjs from "dayjs";
 import fs from "fs";
@@ -10,6 +11,7 @@ import { getDateTimeValue } from "./date_time.js";
 import drawRectangle from "./drawRect.js";
 //import { closeUnexpectedPopups } from "./popups.js";
 import { getTableCells, getTableData } from "./table_analyze.js";
+import errorStackParser from "error-stack-parser";
 import { _convertToRegexQuery, _copyContext, _fixLocatorUsingParams, _fixUsingParams, _getServerUrl, extractStepExampleParameters, KEYBOARD_EVENTS, maskValue, replaceWithLocalTestData, scrollPageToLoadLazyElements, unEscapeString, _getDataFile, testForRegex, performAction, _getTestData, } from "./utils.js";
 import csv from "csv-parser";
 import { Readable } from "node:stream";
@@ -26,6 +28,7 @@ import { _findCellArea, findElementsInArea } from "./table_helper.js";
 import { highlightSnapshot, snapshotValidation } from "./snapshot_validation.js";
 import { loadBrunoParams } from "./bruno.js";
 import { registerAfterStepRoutes, registerBeforeStepRoutes } from "./route.js";
+import { existsSync } from "node:fs";
 export const Types = {
     CLICK: "click_element",
     WAIT_ELEMENT: "wait_element",
@@ -44,6 +47,7 @@ export const Types = {
     VERIFY_PAGE_CONTAINS_NO_TEXT: "verify_page_contains_no_text",
     ANALYZE_TABLE: "analyze_table",
     SELECT: "select_combobox", //
+    VERIFY_PROPERTY: "verify_element_property",
     VERIFY_PAGE_PATH: "verify_page_path",
     VERIFY_PAGE_TITLE: "verify_page_title",
     TYPE_PRESS: "type_press",
@@ -62,12 +66,11 @@ export const Types = {
     SET_INPUT: "set_input",
     WAIT_FOR_TEXT_TO_DISAPPEAR: "wait_for_text_to_disappear",
     VERIFY_ATTRIBUTE: "verify_element_attribute",
-    VERIFY_PROPERTY: "verify_element_property",
     VERIFY_TEXT_WITH_RELATION: "verify_text_with_relation",
     BRUNO: "bruno",
-    SNAPSHOT_VALIDATION: "snapshot_validation",
     VERIFY_FILE_EXISTS: "verify_file_exists",
     SET_INPUT_FILES: "set_input_files",
+    SNAPSHOT_VALIDATION: "snapshot_validation",
     REPORT_COMMAND: "report_command",
     STEP_COMPLETE: "step_complete",
     SLEEP: "sleep",
@@ -84,6 +87,7 @@ class StableBrowser {
     context;
     world;
     fastMode;
+    stepTags;
     project_path = null;
     webLogFile = null;
     networkLogger = null;
@@ -92,13 +96,17 @@ class StableBrowser {
     tags = null;
     isRecording = false;
     initSnapshotTaken = false;
-    constructor(browser, page, logger = null, context = null, world = null, fastMode = false) {
+    onlyFailuresScreenshot = process.env.SCREENSHOT_ON_FAILURE_ONLY === "true";
+    // set to true if the step issue a report
+    inStepReport = false;
+    constructor(browser, page, logger = null, context = null, world = null, fastMode = false, stepTags = []) {
         this.browser = browser;
         this.page = page;
         this.logger = logger;
         this.context = context;
         this.world = world;
         this.fastMode = fastMode;
+        this.stepTags = stepTags;
         if (!this.logger) {
             this.logger = console;
         }
@@ -131,7 +139,7 @@ class StableBrowser {
             this.fastMode = true;
         }
         if (process.env.FAST_MODE === "true") {
-            console.log("Fast mode enabled from environment variable");
+            // console.log("Fast mode enabled from environment variable");
             this.fastMode = true;
         }
         if (process.env.FAST_MODE === "false") {
@@ -174,6 +182,7 @@ class StableBrowser {
             registerNetworkEvents(this.world, this, context, this.page);
             registerDownloadEvent(this.page, this.world, context);
             page.on("close", async () => {
+                // return if browser context is already closed
                 if (this.context && this.context.pages && this.context.pages.length > 1) {
                     this.context.pages.pop();
                     this.page = this.context.pages[this.context.pages.length - 1];
@@ -183,7 +192,12 @@ class StableBrowser {
                         console.log("Switched to page " + title);
                     }
                     catch (error) {
-                        console.error("Error on page close", error);
+                        if (error?.message?.includes("Target page, context or browser has been closed")) {
+                            // Ignore this error
+                        }
+                        else {
+                            console.error("Error on page close", error);
+                        }
                     }
                 }
             });
@@ -192,7 +206,12 @@ class StableBrowser {
                 console.log("Switch page: " + (await page.title()));
             }
             catch (e) {
-                this.logger.error("error on page load " + e);
+                if (e?.message?.includes("Target page, context or browser has been closed")) {
+                    // Ignore this error
+                }
+                else {
+                    this.logger.error("error on page load " + e);
+                }
             }
             context.pageLoading.status = false;
         }.bind(this));
@@ -220,7 +239,7 @@ class StableBrowser {
         if (newContextCreated) {
             this.registerEventListeners(this.context);
             await this.goto(this.context.environment.baseUrl);
-            if (!this.fastMode) {
+            if (!this.fastMode && !this.stepTags.includes("fast-mode")) {
                 await this.waitForPageLoad();
             }
         }
@@ -312,7 +331,7 @@ class StableBrowser {
     // async closeUnexpectedPopups() {
     //   await closeUnexpectedPopups(this.page);
     // }
-    async goto(url, world = null) {
+    async goto(url, world = null, options = {}) {
         if (!url) {
             throw new Error("url is null, verify that the environment file is correct");
         }
@@ -333,10 +352,14 @@ class StableBrowser {
             screenshot: false,
             highlight: false,
         };
+        let timeout = 60000;
+        if (options && options["timeout"]) {
+            timeout = options["timeout"];
+        }
         try {
             await _preCommand(state, this);
             await this.page.goto(url, {
-                timeout: 60000,
+                timeout: timeout,
             });
             await _screenshot(state, this);
         }
@@ -504,12 +527,6 @@ class StableBrowser {
                 if (!el.setAttribute) {
                     el = el.parentElement;
                 }
-                // remove any attributes start with data-blinq-id
-                // for (let i = 0; i < el.attributes.length; i++) {
-                //   if (el.attributes[i].name.startsWith("data-blinq-id")) {
-                //     el.removeAttribute(el.attributes[i].name);
-                //   }
-                // }
                 el.setAttribute("data-blinq-id-" + randomToken, "");
                 return true;
             }, [tag1, randomToken]))) {
@@ -679,40 +696,186 @@ class StableBrowser {
         }
         return { rerun: false };
     }
+    getFilePath() {
+        const stackFrames = errorStackParser.parse(new Error());
+        const mjsFrames = stackFrames.filter((frame) => frame.fileName && frame.fileName.endsWith(".mjs"));
+        const stackFrame = mjsFrames[mjsFrames.length - 2];
+        const filepath = stackFrame?.fileName;
+        if (filepath) {
+            let jsonFilePath = filepath.replace(".mjs", ".json");
+            if (existsSync(jsonFilePath)) {
+                return jsonFilePath;
+            }
+            const config = this.configuration ?? {};
+            if (!config?.locatorsMetadataDir) {
+                config.locatorsMetadataDir = "features/step_definitions/locators";
+            }
+            if (config && config.locatorsMetadataDir) {
+                jsonFilePath = path.join(config.locatorsMetadataDir, path.basename(jsonFilePath));
+            }
+            if (existsSync(jsonFilePath)) {
+                return jsonFilePath;
+            }
+            return null;
+        }
+        return null;
+    }
+    getFullElementLocators(selectors, filePath) {
+        if (!filePath || !existsSync(filePath)) {
+            return null;
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        try {
+            const allElements = JSON.parse(content);
+            const element_key = selectors?.element_key;
+            if (element_key && allElements[element_key]) {
+                return allElements[element_key];
+            }
+            for (const elementKey in allElements) {
+                const element = allElements[elementKey];
+                let foundStrategy = null;
+                for (const key in element) {
+                    if (key === "strategy") {
+                        continue;
+                    }
+                    const locators = element[key];
+                    if (!locators || !locators.length) {
+                        continue;
+                    }
+                    for (const locator of locators) {
+                        delete locator.score;
+                    }
+                    if (JSON.stringify(locators) === JSON.stringify(selectors.locators)) {
+                        foundStrategy = key;
+                        break;
+                    }
+                }
+                if (foundStrategy) {
+                    return element;
+                }
+            }
+        }
+        catch (error) {
+            console.error("Error parsing locators from file: " + filePath, error);
+        }
+        return null;
+    }
     async _locate(selectors, info, _params, timeout, allowDisabled = false) {
         if (!timeout) {
             timeout = 30000;
         }
+        let element = null;
+        let allStrategyLocators = null;
+        let selectedStrategy = null;
+        if (this.tryAllStrategies) {
+            allStrategyLocators = this.getFullElementLocators(selectors, this.getFilePath());
+            selectedStrategy = allStrategyLocators?.strategy;
+        }
         for (let i = 0; i < 3; i++) {
             info.log += "attempt " + i + ": total locators " + selectors.locators.length + "\n";
             for (let j = 0; j < selectors.locators.length; j++) {
                 let selector = selectors.locators[j];
                 info.log += "searching for locator " + j + ":" + JSON.stringify(selector) + "\n";
             }
-            let element = await this._locate_internal(selectors, info, _params, timeout, allowDisabled);
+            if (this.tryAllStrategies && selectedStrategy) {
+                const strategyLocators = allStrategyLocators[selectedStrategy];
+                let err;
+                if (strategyLocators && strategyLocators.length) {
+                    try {
+                        selectors.locators = strategyLocators;
+                        element = await this._locate_internal(selectors, info, _params, 10_000, allowDisabled);
+                        info.selectedStrategy = selectedStrategy;
+                        info.log += "element found using strategy " + selectedStrategy + "\n";
+                    }
+                    catch (error) {
+                        err = error;
+                    }
+                }
+                if (!element) {
+                    for (const key in allStrategyLocators) {
+                        if (key === "strategy" || key === selectedStrategy) {
+                            continue;
+                        }
+                        const strategyLocators = allStrategyLocators[key];
+                        if (strategyLocators && strategyLocators.length) {
+                            try {
+                                info.log += "using strategy " + key + " with locators " + JSON.stringify(strategyLocators) + "\n";
+                                selectors.locators = strategyLocators;
+                                element = await this._locate_internal(selectors, info, _params, 10_000, allowDisabled);
+                                err = null;
+                                info.selectedStrategy = key;
+                                info.log += "element found using strategy " + key + "\n";
+                                break;
+                            }
+                            catch (error) {
+                                err = error;
+                            }
+                        }
+                    }
+                }
+                if (err) {
+                    throw err;
+                }
+            }
+            else {
+                element = await this._locate_internal(selectors, info, _params, timeout, allowDisabled);
+            }
             if (!element.rerun) {
-                const randomToken = Math.random().toString(36).substring(7);
-                await element.evaluate((el, randomToken) => {
-                    el.setAttribute("data-blinq-id-" + randomToken, "");
-                }, randomToken);
-                // if (element._frame) {
-                //   return element;
-                // }
+                let newElementSelector = "";
+                if (this.configuration && this.configuration.stableLocatorStrategy === "csschain") {
+                    const cssSelector = await element.evaluate((el) => {
+                        function getCssSelector(el) {
+                            if (!el || el.nodeType !== 1 || el === document.body)
+                                return el.tagName.toLowerCase();
+                            const parent = el.parentElement;
+                            const tag = el.tagName.toLowerCase();
+                            // Find the index of the element among its siblings of the same tag
+                            let index = 1;
+                            for (let sibling = el.previousElementSibling; sibling; sibling = sibling.previousElementSibling) {
+                                if (sibling.tagName === el.tagName) {
+                                    index++;
+                                }
+                            }
+                            // Use nth-child if necessary (i.e., if there's more than one of the same tag)
+                            const siblings = Array.from(parent.children).filter((child) => child.tagName === el.tagName);
+                            const needsNthChild = siblings.length > 1;
+                            const selector = needsNthChild ? `${tag}:nth-child(${[...parent.children].indexOf(el) + 1})` : tag;
+                            return getCssSelector(parent) + " > " + selector;
+                        }
+                        const cssSelector = getCssSelector(el);
+                        return cssSelector;
+                    });
+                    newElementSelector = cssSelector;
+                }
+                else {
+                    const randomToken = "blinq_" + Math.random().toString(36).substring(7);
+                    if (this.configuration && this.configuration.stableLocatorStrategy === "data-attribute") {
+                        const dataAttribute = "data-blinq-id";
+                        await element.evaluate((el, [dataAttribute, randomToken]) => {
+                            el.setAttribute(dataAttribute, randomToken);
+                        }, [dataAttribute, randomToken]);
+                        newElementSelector = `[${dataAttribute}="${randomToken}"]`;
+                    }
+                    else {
+                        // the default case just return the located element
+                        // will not work for click and type if the locator is placeholder and the placeholder change due to the click event
+                        return element;
+                    }
+                }
                 const scope = element._frame ?? element.page();
-                let newElementSelector = "[data-blinq-id-" + randomToken + "]";
                 let prefixSelector = "";
                 const frameControlSelector = " >> internal:control=enter-frame";
                 const frameSelectorIndex = element._selector.lastIndexOf(frameControlSelector);
                 if (frameSelectorIndex !== -1) {
                     // remove everything after the >> internal:control=enter-frame
                     const frameSelector = element._selector.substring(0, frameSelectorIndex);
-                    prefixSelector = frameSelector + " >> internal:control=enter-frame >>";
+                    prefixSelector = frameSelector + " >> internal:control=enter-frame >> ";
                 }
                 // if (element?._frame?._selector) {
                 //   prefixSelector = element._frame._selector + " >> " + prefixSelector;
                 // }
                 const newSelector = prefixSelector + newElementSelector;
-                return scope.locator(newSelector);
+                return scope.locator(newSelector).first();
             }
         }
         throw new Error("unable to locate element " + JSON.stringify(selectors));
@@ -733,7 +896,7 @@ class StableBrowser {
                 for (let i = 0; i < frame.selectors.length; i++) {
                     let frameLocator = frame.selectors[i];
                     if (frameLocator.css) {
-                        let testframescope = framescope.frameLocator(frameLocator.css);
+                        let testframescope = framescope.frameLocator(`${frameLocator.css} >> visible=true`);
                         if (frameLocator.index) {
                             testframescope = framescope.nth(frameLocator.index);
                         }
@@ -811,6 +974,15 @@ class StableBrowser {
         });
     }
     async _locate_internal(selectors, info, _params, timeout = 30000, allowDisabled = false) {
+        if (selectors.locators && Array.isArray(selectors.locators)) {
+            selectors.locators.forEach((locator) => {
+                locator.index = locator.index ?? 0;
+                locator.visible = locator.visible ?? true;
+                if (locator.visible && locator.css && !locator.css.endsWith(">> visible=true")) {
+                    locator.css = locator.css + " >> visible=true";
+                }
+            });
+        }
         if (!info) {
             info = {};
             info.failCause = {};
@@ -823,7 +995,6 @@ class StableBrowser {
         let locatorsCount = 0;
         let lazy_scroll = false;
         //let arrayMode = Array.isArray(selectors);
-        let scope = await this._findFrameScope(selectors, timeout, info);
         let selectorsLocators = null;
         selectorsLocators = selectors.locators;
         // group selectors by priority
@@ -851,6 +1022,7 @@ class StableBrowser {
         let highPriorityOnly = true;
         let visibleOnly = true;
         while (true) {
+            let scope = await this._findFrameScope(selectors, timeout, info);
             locatorsCount = 0;
             let result = [];
             let popupResult = await this.closeUnexpectedPopups(info, _params);
@@ -966,9 +1138,13 @@ class StableBrowser {
                 }
             }
             if (foundLocators.length === 1) {
+                let box = null;
+                if (!this.onlyFailuresScreenshot) {
+                    box = await foundLocators[0].boundingBox();
+                }
                 result.foundElements.push({
                     locator: foundLocators[0],
-                    box: await foundLocators[0].boundingBox(),
+                    box: box,
                     unique: true,
                 });
                 result.locatorIndex = i;
@@ -1123,11 +1299,22 @@ class StableBrowser {
             operation: "click",
             log: "***** click on " + selectors.element_name + " *****\n",
         };
+        check_performance("click_all ***", this.context, true);
+        let stepFastMode = this.stepTags.includes("fast-mode");
+        if (stepFastMode) {
+            state.onlyFailuresScreenshot = true;
+            state.scroll = false;
+            state.highlight = false;
+        }
         try {
+            check_performance("click_preCommand", this.context, true);
             await _preCommand(state, this);
+            check_performance("click_preCommand", this.context, false);
             await performAction("click", state.element, options, this, state, _params);
-            if (!this.fastMode) {
-                await this.waitForPageLoad();
+            if (!this.fastMode && !this.stepTags.includes("fast-mode")) {
+                check_performance("click_waitForPageLoad", this.context, true);
+                await this.waitForPageLoad({ noSleep: true });
+                check_performance("click_waitForPageLoad", this.context, false);
             }
             return state.info;
         }
@@ -1135,7 +1322,13 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
+            check_performance("click_commandFinally", this.context, true);
             await _commandFinally(state, this);
+            check_performance("click_commandFinally", this.context, false);
+            check_performance("click_all ***", this.context, false);
+            if (this.context.profile) {
+                console.log(JSON.stringify(this.context.profile, null, 2));
+            }
         }
     }
     async waitForElement(selectors, _params, options = {}, world = null) {
@@ -1227,7 +1420,7 @@ class StableBrowser {
                     }
                 }
             }
-            await this.waitForPageLoad();
+            //await this.waitForPageLoad();
             return state.info;
         }
         catch (e) {
@@ -1253,7 +1446,7 @@ class StableBrowser {
             await _preCommand(state, this);
             await performAction("hover", state.element, options, this, state, _params);
             await _screenshot(state, this);
-            await this.waitForPageLoad();
+            //await this.waitForPageLoad();
             return state.info;
         }
         catch (e) {
@@ -1289,7 +1482,7 @@ class StableBrowser {
                 state.info.log += "selectOption failed, will try force" + "\n";
                 await state.element.selectOption(values, { timeout: 10000, force: true });
             }
-            await this.waitForPageLoad();
+            //await this.waitForPageLoad();
             return state.info;
         }
         catch (e) {
@@ -1475,6 +1668,14 @@ class StableBrowser {
         }
         try {
             await _preCommand(state, this);
+            const randomToken = "blinq_" + Math.random().toString(36).substring(7);
+            // tag the element
+            let newElementSelector = await state.element.evaluate((el, token) => {
+                // use attribute and not id
+                const attrName = `data-blinq-id-${token}`;
+                el.setAttribute(attrName, "");
+                return `[${attrName}]`;
+            }, randomToken);
             state.info.value = _value;
             if (!options.press) {
                 try {
@@ -1500,6 +1701,25 @@ class StableBrowser {
                 }
             }
             await new Promise((resolve) => setTimeout(resolve, 500));
+            // check if the element exist after the click (no wait)
+            const count = await state.element.count({ timeout: 0 });
+            if (count === 0) {
+                // the locator changed after the click (placeholder) we need to locate the element using the data-blinq-id
+                const scope = state.element._frame ?? element.page();
+                let prefixSelector = "";
+                const frameControlSelector = " >> internal:control=enter-frame";
+                const frameSelectorIndex = state.element._selector.lastIndexOf(frameControlSelector);
+                if (frameSelectorIndex !== -1) {
+                    // remove everything after the >> internal:control=enter-frame
+                    const frameSelector = state.element._selector.substring(0, frameSelectorIndex);
+                    prefixSelector = frameSelector + " >> internal:control=enter-frame >> ";
+                }
+                // if (element?._frame?._selector) {
+                //   prefixSelector = element._frame._selector + " >> " + prefixSelector;
+                // }
+                const newSelector = prefixSelector + newElementSelector;
+                state.element = scope.locator(newSelector).first();
+            }
             const valueSegment = state.value.split("&&");
             for (let i = 0; i < valueSegment.length; i++) {
                 if (i > 0) {
@@ -1571,8 +1791,8 @@ class StableBrowser {
             if (enter) {
                 await new Promise((resolve) => setTimeout(resolve, 2000));
                 await this.page.keyboard.press("Enter");
+                await this.waitForPageLoad();
             }
-            await this.waitForPageLoad();
             return state.info;
         }
         catch (e) {
@@ -1831,11 +2051,12 @@ class StableBrowser {
             throw new Error("referanceSnapshot is null");
         }
         let text = null;
-        if (fs.existsSync(path.join(this.project_path, "data", "snapshots", this.context.environment.name, referanceSnapshot + ".yml"))) {
-            text = fs.readFileSync(path.join(this.project_path, "data", "snapshots", this.context.environment.name, referanceSnapshot + ".yml"), "utf8");
+        const snapshotsFolder = process.env.BVT_TEMP_SNAPSHOTS_FOLDER ?? this.context.snapshotFolder; //path .join(this.project_path, "data", "snapshots");
+        if (fs.existsSync(path.join(snapshotsFolder, referanceSnapshot + ".yml"))) {
+            text = fs.readFileSync(path.join(snapshotsFolder, referanceSnapshot + ".yml"), "utf8");
         }
-        else if (fs.existsSync(path.join(this.project_path, "data", "snapshots", this.context.environment.name, referanceSnapshot + ".yaml"))) {
-            text = fs.readFileSync(path.join(this.project_path, "data", "snapshots", this.context.environment.name, referanceSnapshot + ".yaml"), "utf8");
+        else if (fs.existsSync(path.join(snapshotsFolder, referanceSnapshot + ".yaml"))) {
+            text = fs.readFileSync(path.join(snapshotsFolder, referanceSnapshot + ".yaml"), "utf8");
         }
         else if (referanceSnapshot.startsWith("yaml:")) {
             text = referanceSnapshot.substring(5);
@@ -1859,7 +2080,13 @@ class StableBrowser {
                         scope = await this._findFrameScope(frameSelectors, timeout, state.info);
                     }
                     const snapshot = await scope.locator("body").ariaSnapshot({ timeout });
+                    if (snapshot && snapshot.length <= 10) {
+                        console.log("Page snapshot length is suspiciously small:", snapshot);
+                    }
                     matchResult = snapshotValidation(snapshot, newValue, referanceSnapshot);
+                    if (matchResult === undefined) {
+                        console.log("snapshotValidation returned undefined");
+                    }
                     if (matchResult.errorLine !== -1) {
                         throw new Error("Snapshot validation failed at line " + matchResult.errorLineText);
                     }
@@ -2030,6 +2257,9 @@ class StableBrowser {
         return _getTestData(world, this.context, this);
     }
     async _screenShot(options = {}, world = null, info = null) {
+        if (!options) {
+            options = {};
+        }
         // collect url/path/title
         if (info) {
             if (!info.title) {
@@ -2058,7 +2288,7 @@ class StableBrowser {
             const uuidStr = "id_" + randomUUID();
             const screenshotPath = path.join(world.screenshotPath, uuidStr + ".png");
             try {
-                await this.takeScreenshot(screenshotPath);
+                await this.takeScreenshot(screenshotPath, options.fullPage === true);
                 // let buffer = await this.page.screenshot({ timeout: 4000 });
                 // // save the buffer to the screenshot path asynchrously
                 // fs.writeFile(screenshotPath, buffer, (err) => {
@@ -2079,7 +2309,7 @@ class StableBrowser {
         else if (options && options.screenshot) {
             result.screenshotPath = options.screenshotPath;
             try {
-                await this.takeScreenshot(options.screenshotPath);
+                await this.takeScreenshot(options.screenshotPath, options.fullPage === true);
                 // let buffer = await this.page.screenshot({ timeout: 4000 });
                 // // save the buffer to the screenshot path asynchrously
                 // fs.writeFile(options.screenshotPath, buffer, (err) => {
@@ -2097,7 +2327,7 @@ class StableBrowser {
         }
         return result;
     }
-    async takeScreenshot(screenshotPath) {
+    async takeScreenshot(screenshotPath, fullPage = false) {
         const playContext = this.context.playContext;
         // Using CDP to capture the screenshot
         const viewportWidth = Math.max(...(await this.page.evaluate(() => [
@@ -2122,13 +2352,7 @@ class StableBrowser {
             const client = await playContext.newCDPSession(this.page);
             const { data } = await client.send("Page.captureScreenshot", {
                 format: "png",
-                // clip: {
-                //   x: 0,
-                //   y: 0,
-                //   width: viewportWidth,
-                //   height: viewportHeight,
-                //   scale: 1,
-                // },
+                captureBeyondViewport: fullPage,
             });
             await client.detach();
             if (!screenshotPath) {
@@ -2137,7 +2361,7 @@ class StableBrowser {
             screenshotBuffer = Buffer.from(data, "base64");
         }
         else {
-            screenshotBuffer = await this.page.screenshot();
+            screenshotBuffer = await this.page.screenshot({ fullPage: fullPage });
         }
         // if (focusedElement) {
         //   // console.log(`Focused element ${JSON.stringify(focusedElement._selector)}`)
@@ -2438,7 +2662,7 @@ class StableBrowser {
         let expectedValue;
         try {
             await _preCommand(state, this);
-            expectedValue = await replaceWithLocalTestData(state.value, world);
+            expectedValue = await this._replaceWithLocalData(value, world);
             state.info.expectedValue = expectedValue;
             switch (property) {
                 case "innerText":
@@ -2486,47 +2710,54 @@ class StableBrowser {
             }
             state.info.value = val;
             let regex;
-            if (expectedValue.startsWith("/") && expectedValue.endsWith("/")) {
-                const patternBody = expectedValue.slice(1, -1);
-                const processedPattern = patternBody.replace(/\n/g, ".*");
-                regex = new RegExp(processedPattern, "gs");
-                state.info.regex = true;
-            }
-            else {
-                const escapedPattern = expectedValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-                regex = new RegExp(escapedPattern, "g");
-            }
-            if (property === "innerText") {
-                if (state.info.regex) {
-                    if (!regex.test(val)) {
-                        let errorMessage = `The ${property} property has a value of "${val}", but the expected value is "${expectedValue}"`;
-                        state.info.failCause.assertionFailed = true;
-                        state.info.failCause.lastError = errorMessage;
-                        throw new Error(errorMessage);
-                    }
+            state.info.value = val;
+            const isRegex = expectedValue.startsWith("regex:");
+            const isContains = expectedValue.startsWith("contains:");
+            const isExact = expectedValue.startsWith("exact:");
+            let matchPassed = false;
+            if (isRegex) {
+                const rawPattern = expectedValue.slice(6); // remove "regex:"
+                const lastSlashIndex = rawPattern.lastIndexOf("/");
+                if (rawPattern.startsWith("/") && lastSlashIndex > 0) {
+                    const patternBody = rawPattern.slice(1, lastSlashIndex).replace(/\n/g, ".*");
+                    const flags = rawPattern.slice(lastSlashIndex + 1) || "gs";
+                    const regex = new RegExp(patternBody, flags);
+                    state.info.regex = true;
+                    matchPassed = regex.test(val);
                 }
                 else {
-                    // Fix: Replace escaped newlines with actual newlines before splitting
-                    const normalizedExpectedValue = expectedValue.replace(/\\n/g, "\n");
-                    const valLines = val.split("\n");
-                    const expectedLines = normalizedExpectedValue.split("\n");
-                    // Check if all expected lines are present in the actual lines
-                    const isPart = expectedLines.every((expectedLine) => valLines.some((valLine) => valLine.trim() === expectedLine.trim()));
-                    if (!isPart) {
-                        let errorMessage = `The ${property} property has a value of "${val}", but the expected value is "${expectedValue}"`;
-                        state.info.failCause.assertionFailed = true;
-                        state.info.failCause.lastError = errorMessage;
-                        throw new Error(errorMessage);
-                    }
+                    // Fallback: treat as literal
+                    const escapedPattern = rawPattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                    const regex = new RegExp(escapedPattern, "g");
+                    matchPassed = regex.test(val);
                 }
             }
+            else if (isContains) {
+                const containsValue = expectedValue.slice(9); // remove "contains:"
+                matchPassed = val.includes(containsValue);
+            }
+            else if (isExact) {
+                const exactValue = expectedValue.slice(6); // remove "exact:"
+                matchPassed = val === exactValue;
+            }
+            else if (property === "innerText") {
+                // Default innerText logic
+                const normalizedExpectedValue = expectedValue.replace(/\\n/g, "\n");
+                const valLines = val.split("\n");
+                const expectedLines = normalizedExpectedValue.split("\n");
+                matchPassed = expectedLines.every((expectedLine) => valLines.some((valLine) => valLine.trim() === expectedLine.trim()));
+            }
             else {
-                if (!val.match(regex)) {
-                    let errorMessage = `The ${property} property has a value of "${val}", but the expected value is "${expectedValue}"`;
-                    state.info.failCause.assertionFailed = true;
-                    state.info.failCause.lastError = errorMessage;
-                    throw new Error(errorMessage);
-                }
+                // Fallback exact or loose match
+                const escapedPattern = expectedValue.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                const regex = new RegExp(escapedPattern, "g");
+                matchPassed = regex.test(val);
+            }
+            if (!matchPassed) {
+                let errorMessage = `The ${property} property has a value of "${val}", but the expected value is "${expectedValue}"`;
+                state.info.failCause.assertionFailed = true;
+                state.info.failCause.lastError = errorMessage;
+                throw new Error(errorMessage);
             }
             return state.info;
         }
@@ -2557,6 +2788,7 @@ class StableBrowser {
             allowDisabled: true,
             info: {},
         };
+        state.options ??= { timeout: timeoutMs };
         // Initialize startTime outside try block to ensure it's always accessible
         const startTime = Date.now();
         let conditionMet = false;
@@ -3132,7 +3364,16 @@ class StableBrowser {
             text = text.replace(/\\"/g, '"');
         }
         const timeout = this._getFindElementTimeout(options);
-        await new Promise((resolve) => setTimeout(resolve, 2000));
+        //if (!this.fastMode && !this.stepTags.includes("fast-mode")) {
+        let stepFastMode = this.stepTags.includes("fast-mode");
+        if (!stepFastMode) {
+            if (!this.fastMode) {
+                await new Promise((resolve) => setTimeout(resolve, 2000));
+            }
+            else {
+                await new Promise((resolve) => setTimeout(resolve, 500));
+            }
+        }
         const newValue = await this._replaceWithLocalData(text, world);
         if (newValue !== text) {
             this.logger.info(text + "=" + newValue);
@@ -3140,6 +3381,11 @@ class StableBrowser {
         }
         let dateAlternatives = findDateAlternatives(text);
         let numberAlternatives = findNumberAlternatives(text);
+        if (stepFastMode) {
+            state.onlyFailuresScreenshot = true;
+            state.scroll = false;
+            state.highlight = false;
+        }
         try {
             await _preCommand(state, this);
             state.info.text = text;
@@ -3259,6 +3505,8 @@ class StableBrowser {
             operation: "verify_text_with_relation",
             log: "***** search for " + textAnchor + " climb " + climb + " and verify " + textToVerify + " found *****\n",
         };
+        const cmdStartTime = Date.now();
+        let cmdEndTime = null;
         const timeout = this._getFindElementTimeout(options);
         await new Promise((resolve) => setTimeout(resolve, 2000));
         let newValue = await this._replaceWithLocalData(textAnchor, world);
@@ -3294,6 +3542,17 @@ class StableBrowser {
                     await new Promise((resolve) => setTimeout(resolve, 1000));
                     continue;
                 }
+                else {
+                    cmdEndTime = Date.now();
+                    if (cmdEndTime - cmdStartTime > 55000) {
+                        if (foundAncore) {
+                            throw new Error(`Text ${textToVerify} not found in page`);
+                        }
+                        else {
+                            throw new Error(`Text ${textAnchor} not found in page`);
+                        }
+                    }
+                }
                 try {
                     for (let i = 0; i < resultWithElementsFound.length; i++) {
                         foundAncore = true;
@@ -3432,7 +3691,7 @@ class StableBrowser {
             Object.assign(e, { info: info });
             error = e;
             // throw e;
-            await _commandError({ text: "visualVerification", operation: "visualVerification", text, info }, e, this);
+            await _commandError({ text: "visualVerification", operation: "visualVerification", info }, e, this);
         }
         finally {
             const endTime = Date.now();
@@ -3781,6 +4040,22 @@ class StableBrowser {
         }
     }
     async waitForPageLoad(options = {}, world = null) {
+        // try {
+        //   let currentPagePath = null;
+        //   currentPagePath = new URL(this.page.url()).pathname;
+        //   if (this.latestPagePath) {
+        //     // get the currect page path and compare with the latest page path
+        //     if (this.latestPagePath === currentPagePath) {
+        //       // if the page path is the same, do not wait for page load
+        //       console.log("No page change: " + currentPagePath);
+        //       return;
+        //     }
+        //   }
+        //   this.latestPagePath = currentPagePath;
+        // } catch (e) {
+        //   console.debug("Error getting current page path: ", e);
+        // }
+        //console.log("Waiting for page load");
         let timeout = this._getLoadTimeout(options);
         const promiseArray = [];
         // let waitForNetworkIdle = true;
@@ -3815,7 +4090,10 @@ class StableBrowser {
             }
         }
         finally {
-            await new Promise((resolve) => setTimeout(resolve, 2000));
+            await new Promise((resolve) => setTimeout(resolve, 500));
+            if (options && !options.noSleep) {
+                await new Promise((resolve) => setTimeout(resolve, 1500));
+            }
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world));
             const endTime = Date.now();
             _reportToWorld(world, {
@@ -3869,7 +4147,7 @@ class StableBrowser {
         }
         operation = options.operation;
         // validate operation is one of the supported operations
-        if (operation != "click" && operation != "hover+click") {
+        if (operation != "click" && operation != "hover+click" && operation != "hover") {
             throw new Error("operation is not supported");
         }
         const state = {
@@ -3938,6 +4216,17 @@ class StableBrowser {
                     state.element = results[0];
                     await performAction("hover+click", state.element, options, this, state, _params);
                     break;
+                case "hover":
+                    if (!options.css) {
+                        throw new Error("css is not defined");
+                    }
+                    const result1 = await findElementsInArea(options.css, cellArea, this, options);
+                    if (result1.length === 0) {
+                        throw new Error(`Element not found in cell area`);
+                    }
+                    state.element = result1[0];
+                    await performAction("hover", state.element, options, this, state, _params);
+                    break;
                 default:
                     throw new Error("operation is not supported");
             }
@@ -3951,6 +4240,12 @@ class StableBrowser {
     }
     saveTestDataAsGlobal(options, world) {
         const dataFile = _getDataFile(world, this.context, this);
+        if (process.env.MODE === "executions") {
+            const globalDataFile = path.join(this.project_path, "global_test_data.json");
+            fs.copyFileSync(dataFile, globalDataFile);
+            this.logger.info("Save the scenario test data to " + globalDataFile + " as global for the following scenarios.");
+            return;
+        }
         process.env.GLOBAL_TEST_DATA_FILE = dataFile;
         this.logger.info("Save the scenario test data as global for the following scenarios.");
     }
@@ -4053,6 +4348,7 @@ class StableBrowser {
         if (world && world.attach) {
             world.attach(this.context.reportFolder, { mediaType: "text/plain" });
         }
+        this.context.loadedRoutes = null;
         this.beforeScenarioCalled = true;
         if (scenario && scenario.pickle && scenario.pickle.name) {
             this.scenarioName = scenario.pickle.name;
@@ -4079,11 +4375,32 @@ class StableBrowser {
             await getTestData(envName, world, undefined, this.featureName, this.scenarioName, this.context);
         }
         await loadBrunoParams(this.context, this.context.environment.name);
+        if ((process.env.TRACE === "true" || this.configuration.trace === true) && this.context) {
+            this.trace = true;
+            const traceFolder = path.join(this.context.reportFolder, "trace");
+            if (!fs.existsSync(traceFolder)) {
+                fs.mkdirSync(traceFolder, { recursive: true });
+            }
+            this.traceFolder = traceFolder;
+            await this.context.playContext.tracing.start({ screenshots: true, snapshots: true });
+        }
+    }
+    async afterScenario(world, scenario) {
+        const id = scenario.testCaseStartedId;
+        if (this.trace) {
+            await this.context.playContext.tracing.stop({
+                path: path.join(this.traceFolder, `trace-${id}.zip`),
+            });
+        }
     }
-    async afterScenario(world, scenario) { }
     async beforeStep(world, step) {
+        if (step?.pickleStep && this.trace) {
+            await this.context.playContext.tracing.group(`Step: ${step.pickleStep.text}`);
+        }
+        this.stepTags = [];
         if (!this.beforeScenarioCalled) {
             this.beforeScenario(world, step);
+            this.context.loadedRoutes = null;
         }
         if (this.stepIndex === undefined) {
             this.stepIndex = 0;
@@ -4093,7 +4410,12 @@ class StableBrowser {
         }
         if (step && step.pickleStep && step.pickleStep.text) {
             this.stepName = step.pickleStep.text;
-            this.logger.info("step: " + this.stepName);
+            let printableStepName = this.stepName;
+            // take the printableStepName and replace quated value with \x1b[33m and \x1b[0m
+            printableStepName = printableStepName.replace(/"([^"]*)"/g, (match, p1) => {
+                return `\x1b[33m"${p1}"\x1b[0m`;
+            });
+            this.logger.info("\x1b[38;5;208mstep:\x1b[0m " + printableStepName);
         }
         else if (step && step.text) {
             this.stepName = step.text;
@@ -4108,7 +4430,10 @@ class StableBrowser {
         }
         if (this.initSnapshotTaken === false) {
             this.initSnapshotTaken = true;
-            if (world && world.attach && !process.env.DISABLE_SNAPSHOT && !this.fastMode) {
+            if (world &&
+                world.attach &&
+                !process.env.DISABLE_SNAPSHOT &&
+                (!this.fastMode || this.stepTags.includes("fast-mode"))) {
                 const snapshot = await this.getAriaSnapshot();
                 if (snapshot) {
                     await world.attach(JSON.stringify(snapshot), "application/json+snapshot-before");
@@ -4118,7 +4443,11 @@ class StableBrowser {
         this.context.routeResults = null;
         this.context.loadedRoutes = null;
         await registerBeforeStepRoutes(this.context, this.stepName, world);
-        networkBeforeStep(this.stepName);
+        networkBeforeStep(this.stepName, this.context);
+        this.inStepReport = false;
+    }
+    setStepTags(tags) {
+        this.stepTags = tags;
     }
     async getAriaSnapshot() {
         try {
@@ -4192,7 +4521,7 @@ class StableBrowser {
             state.payload = payload;
             if (commandStatus === "FAILED") {
                 state.throwError = true;
-                throw new Error("Command failed");
+                throw new Error(commandText);
             }
         }
         catch (e) {
@@ -4202,26 +4531,22 @@ class StableBrowser {
             await _commandFinally(state, this);
         }
     }
-    async afterStep(world, step) {
+    async afterStep(world, step, result) {
         this.stepName = null;
-        if (this.context && this.context.browserObject && this.context.browserObject.trace === true) {
-            if (this.context.browserObject.context) {
-                await this.context.browserObject.context.tracing.stopChunk({
-                    path: path.join(this.context.browserObject.traceFolder, `trace-${this.stepIndex}.zip`),
-                });
-                if (world && world.attach) {
-                    await world.attach(JSON.stringify({
-                        type: "trace",
-                        traceFilePath: `trace-${this.stepIndex}.zip`,
-                    }), "application/json+trace");
-                }
-                // console.log("trace file created", `trace-${this.stepIndex}.zip`);
-            }
-        }
         if (this.context) {
             this.context.examplesRow = null;
         }
-        if (world && world.attach && !process.env.DISABLE_SNAPSHOT) {
+        if (!this.inStepReport) {
+            // check the step result
+            if (result && result.status === "FAILED" && world && world.attach) {
+                await this.addCommandToReport(result.message ? result.message : "Step failed", "FAILED", `${result.message}`, { type: "text", screenshot: true }, world);
+            }
+        }
+        if (world &&
+            world.attach &&
+            !process.env.DISABLE_SNAPSHOT &&
+            !this.fastMode &&
+            !this.stepTags.includes("fast-mode")) {
             const snapshot = await this.getAriaSnapshot();
             if (snapshot) {
                 const obj = {};
@@ -4229,6 +4554,11 @@ class StableBrowser {
             }
         }
         this.context.routeResults = await registerAfterStepRoutes(this.context, world);
+        if (this.context.routeResults) {
+            if (world && world.attach) {
+                await world.attach(JSON.stringify(this.context.routeResults), "application/json+intercept-results");
+            }
+        }
         if (!process.env.TEMP_RUN) {
             const state = {
                 world,
@@ -4252,7 +4582,16 @@ class StableBrowser {
                 await _commandFinally(state, this);
             }
         }
-        networkAfterStep(this.stepName);
+        networkAfterStep(this.stepName, this.context);
+        if (process.env.TEMP_RUN === "true") {
+            // Put a sleep for some time to allow the browser to finish processing
+            if (!this.stepTags.includes("fast-mode")) {
+                await new Promise((resolve) => setTimeout(resolve, 3000));
+            }
+        }
+        if (this.trace) {
+            await this.context.playContext.tracing.groupEnd();
+        }
     }
 }
 function createTimedPromise(promise, label) {