automation_model 1.0.705-dev → 1.0.705-stage

package/lib/stable_browser.js

@@ -10,7 +10,8 @@ import { getDateTimeValue } from "./date_time.js";
 import drawRectangle from "./drawRect.js";
 //import { closeUnexpectedPopups } from "./popups.js";
 import { getTableCells, getTableData } from "./table_analyze.js";
-import { _convertToRegexQuery, _copyContext, _fixLocatorUsingParams, _fixUsingParams, _getServerUrl, extractStepExampleParameters, KEYBOARD_EVENTS, maskValue, replaceWithLocalTestData, scrollPageToLoadLazyElements, unEscapeString, _getDataFile, testForRegex, performAction, } from "./utils.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";
 import readline from "readline";
@@ -19,35 +20,42 @@ import { getTestData } from "./auto_page.js";
 import { locate_element } from "./locate_element.js";
 import { randomUUID } from "crypto";
 import { _commandError, _commandFinally, _preCommand, _validateSelectors, _screenshot, _reportToWorld, } from "./command_common.js";
-import { registerDownloadEvent, registerNetworkEvents } from "./network.js";
+import { networkAfterStep, networkBeforeStep, registerDownloadEvent, registerNetworkEvents } from "./network.js";
 import { LocatorLog } from "./locator_log.js";
 import axios from "axios";
 import { _findCellArea, findElementsInArea } from "./table_helper.js";
-import { snapshotValidation } from "./snapshot_validation.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",
     NAVIGATE: "navigate",
+    GO_BACK: "go_back",
+    GO_FORWARD: "go_forward",
     FILL: "fill_element",
-    EXECUTE: "execute_page_method",
-    OPEN: "open_environment",
+    EXECUTE: "execute_page_method", //
+    OPEN: "open_environment", //
     COMPLETE: "step_complete",
     ASK: "information_needed",
-    GET_PAGE_STATUS: "get_page_status",
-    CLICK_ROW_ACTION: "click_row_action",
+    GET_PAGE_STATUS: "get_page_status", ///
+    CLICK_ROW_ACTION: "click_row_action", //
     VERIFY_ELEMENT_CONTAINS_TEXT: "verify_element_contains_text",
     VERIFY_PAGE_CONTAINS_TEXT: "verify_page_contains_text",
     VERIFY_PAGE_CONTAINS_NO_TEXT: "verify_page_contains_no_text",
     ANALYZE_TABLE: "analyze_table",
-    SELECT: "select_combobox",
+    SELECT: "select_combobox", //
+    VERIFY_PROPERTY: "verify_element_property",
     VERIFY_PAGE_PATH: "verify_page_path",
+    VERIFY_PAGE_TITLE: "verify_page_title",
     TYPE_PRESS: "type_press",
     PRESS: "press_key",
     HOVER: "hover_element",
     CHECK: "check_element",
     UNCHECK: "uncheck_element",
     EXTRACT: "extract_attribute",
+    EXTRACT_PROPERTY: "extract_property",
     CLOSE_PAGE: "close_page",
     TABLE_OPERATION: "table_operation",
     SET_DATE_TIME: "set_date_time",
@@ -59,9 +67,13 @@ export const Types = {
     VERIFY_ATTRIBUTE: "verify_element_attribute",
     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",
+    CONDITIONAL_WAIT: "conditional_wait",
 };
 export const apps = {};
 const formatElementName = (elementName) => {
@@ -73,6 +85,7 @@ class StableBrowser {
     logger;
     context;
     world;
+    fastMode;
     project_path = null;
     webLogFile = null;
     networkLogger = null;
@@ -81,12 +94,14 @@ class StableBrowser {
     tags = null;
     isRecording = false;
     initSnapshotTaken = false;
-    constructor(browser, page, logger = null, context = null, world = null) {
+    abortedExecution = false;
+    constructor(browser, page, logger = null, context = null, world = null, fastMode = false) {
         this.browser = browser;
         this.page = page;
         this.logger = logger;
         this.context = context;
         this.world = world;
+        this.fastMode = fastMode;
         if (!this.logger) {
             this.logger = console;
         }
@@ -115,6 +130,19 @@ class StableBrowser {
         context.pages = [this.page];
         const logFolder = path.join(this.project_path, "logs", "web");
         this.world = world;
+        if (this.configuration && this.configuration.fastMode === true) {
+            this.fastMode = true;
+        }
+        if (process.env.FAST_MODE === "true") {
+            // console.log("Fast mode enabled from environment variable");
+            this.fastMode = true;
+        }
+        if (process.env.FAST_MODE === "false") {
+            this.fastMode = false;
+        }
+        if (this.context) {
+            this.context.fastMode = this.fastMode;
+        }
         this.registerEventListeners(this.context);
         registerNetworkEvents(this.world, this, this.context, this.page);
         registerDownloadEvent(this.page, this.world, this.context);
@@ -125,6 +153,9 @@ class StableBrowser {
         if (!context.pageLoading) {
             context.pageLoading = { status: false };
         }
+        if (this.configuration && this.configuration.acceptDialog && this.page) {
+            this.page.on("dialog", (dialog) => dialog.accept());
+        }
         context.playContext.on("page", async function (page) {
             if (this.configuration && this.configuration.closePopups === true) {
                 console.log("close unexpected popups");
@@ -133,6 +164,14 @@ class StableBrowser {
             }
             context.pageLoading.status = true;
             this.page = page;
+            try {
+                if (this.configuration && this.configuration.acceptDialog) {
+                    await page.on("dialog", (dialog) => dialog.accept());
+                }
+            }
+            catch (error) {
+                console.error("Error on dialog accept registration", error);
+            }
             context.page = page;
             context.pages.push(page);
             registerNetworkEvents(this.world, this, context, this.page);
@@ -184,7 +223,9 @@ class StableBrowser {
         if (newContextCreated) {
             this.registerEventListeners(this.context);
             await this.goto(this.context.environment.baseUrl);
-            await this.waitForPageLoad();
+            if (!this.fastMode) {
+                await this.waitForPageLoad();
+            }
         }
     }
     async switchTab(tabTitleOrIndex) {
@@ -278,6 +319,7 @@ class StableBrowser {
         if (!url) {
             throw new Error("url is null, verify that the environment file is correct");
         }
+        url = await this._replaceWithLocalData(url, this.world);
         if (!url.startsWith("http")) {
             url = "https://" + url;
         }
@@ -309,6 +351,64 @@ class StableBrowser {
             await _commandFinally(state, this);
         }
     }
+    async goBack(options, world = null) {
+        const state = {
+            value: "",
+            world: world,
+            type: Types.GO_BACK,
+            text: `Browser navigate back`,
+            operation: "goBack",
+            log: "***** navigate back *****\n",
+            info: {},
+            locate: false,
+            scroll: false,
+            screenshot: false,
+            highlight: false,
+        };
+        try {
+            await _preCommand(state, this);
+            await this.page.goBack({
+                waitUntil: "load",
+            });
+            await _screenshot(state, this);
+        }
+        catch (error) {
+            console.error("Error on goBack", error);
+            _commandError(state, error, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
+    async goForward(options, world = null) {
+        const state = {
+            value: "",
+            world: world,
+            type: Types.GO_FORWARD,
+            text: `Browser navigate forward`,
+            operation: "goForward",
+            log: "***** navigate forward *****\n",
+            info: {},
+            locate: false,
+            scroll: false,
+            screenshot: false,
+            highlight: false,
+        };
+        try {
+            await _preCommand(state, this);
+            await this.page.goForward({
+                waitUntil: "load",
+            });
+            await _screenshot(state, this);
+        }
+        catch (error) {
+            console.error("Error on goForward", error);
+            _commandError(state, error, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
     async _getLocator(locator, scope, _params) {
         locator = _fixLocatorUsingParams(locator, _params);
         // locator = await this._replaceWithLocalData(locator);
@@ -422,7 +522,7 @@ class StableBrowser {
         }
         return { elementCount: tagCount, randomToken };
     }
-    async _collectLocatorInformation(selectorHierarchy, index = 0, scope, foundLocators, _params, info, visibleOnly = true, allowDisabled = false, element_name = null) {
+    async _collectLocatorInformation(selectorHierarchy, index = 0, scope, foundLocators, _params, info, visibleOnly = true, allowDisabled = false, element_name = null, logErrors = false) {
         if (!info) {
             info = {};
         }
@@ -434,14 +534,13 @@ class StableBrowser {
             info.locatorLog = new LocatorLog(selectorHierarchy);
         }
         let locatorSearch = selectorHierarchy[index];
-        let originalLocatorSearch = "";
         try {
-            originalLocatorSearch = _fixUsingParams(JSON.stringify(locatorSearch), _params);
-            locatorSearch = JSON.parse(originalLocatorSearch);
+            locatorSearch = _fixLocatorUsingParams(locatorSearch, _params);
         }
         catch (e) {
             console.error(e);
         }
+        let originalLocatorSearch = JSON.stringify(locatorSearch);
         //info.log += "searching for locator " + JSON.stringify(locatorSearch) + "\n";
         let locator = null;
         if (locatorSearch.climb && locatorSearch.climb >= 0) {
@@ -489,7 +588,7 @@ class StableBrowser {
             }
             return;
         }
-        if (info.locatorLog && count === 0) {
+        if (info.locatorLog && count === 0 && logErrors) {
             info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "NOT_FOUND");
         }
         for (let j = 0; j < count; j++) {
@@ -504,7 +603,7 @@ class StableBrowser {
                     info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
                 }
             }
-            else {
+            else if (logErrors) {
                 info.failCause.visible = visible;
                 info.failCause.enabled = enabled;
                 if (!info.printMessages) {
@@ -583,21 +682,135 @@ class StableBrowser {
         }
         return { rerun: false };
     }
+    getFilePath() {
+        const stackFrames = errorStackParser.parse(new Error());
+        const stackFrame = stackFrames.findLast((frame) => frame.fileName && frame.fileName.endsWith(".mjs"));
+        // return stackFrame?.fileName || null;
+        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);
-                element.evaluate((el, randomToken) => {
+                await element.evaluate((el, randomToken) => {
                     el.setAttribute("data-blinq-id-" + randomToken, "");
+                    console.log("set data-blinq-id-" + randomToken + " on element", el);
                 }, randomToken);
                 // if (element._frame) {
                 //   return element;
@@ -649,7 +862,7 @@ class StableBrowser {
                             break;
                         }
                         catch (error) {
-                            console.error("frame not found " + frameLocator.css);
+                            // console.error("frame not found " + frameLocator.css);
                         }
                     }
                 }
@@ -727,7 +940,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
@@ -755,6 +967,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);
@@ -845,7 +1058,7 @@ class StableBrowser {
         }
         throw new Error("failed to locate first element no elements found, " + info.log);
     }
-    async _scanLocatorsGroup(locatorsGroup, scope, _params, info, visibleOnly, allowDisabled = false, element_name) {
+    async _scanLocatorsGroup(locatorsGroup, scope, _params, info, visibleOnly, allowDisabled = false, element_name, logErrors = false) {
         let foundElements = [];
         const result = {
             foundElements: foundElements,
@@ -864,7 +1077,9 @@ class StableBrowser {
                     await this._collectLocatorInformation(locatorsGroup, i, this.page, foundLocators, _params, info, visibleOnly, allowDisabled, element_name);
                 }
                 catch (e) {
-                    this.logger.info("unable to use locator (second try) " + JSON.stringify(locatorsGroup[i]));
+                    if (logErrors) {
+                        this.logger.info("unable to use locator (second try) " + JSON.stringify(locatorsGroup[i]));
+                    }
                 }
             }
             if (foundLocators.length === 1) {
@@ -905,7 +1120,7 @@ class StableBrowser {
                     });
                     result.locatorIndex = i;
                 }
-                else {
+                else if (logErrors) {
                     info.failCause.foundMultiple = true;
                     if (info.locatorLog) {
                         info.locatorLog.setLocatorSearchStatus(JSON.stringify(locatorsGroup[i]), "FOUND_NOT_UNIQUE");
@@ -1028,7 +1243,9 @@ class StableBrowser {
         try {
             await _preCommand(state, this);
             await performAction("click", state.element, options, this, state, _params);
-            await this.waitForPageLoad();
+            if (!this.fastMode) {
+                await this.waitForPageLoad();
+            }
             return state.info;
         }
         catch (e) {
@@ -1091,7 +1308,7 @@ class StableBrowser {
                 // if (world && world.screenshot && !world.screenshotPath) {
                 // console.log(`Highlighting while running from recorder`);
                 await this._highlightElements(state.element);
-                await state.element.setChecked(checked);
+                await state.element.setChecked(checked, { timeout: 2000 });
                 await new Promise((resolve) => setTimeout(resolve, 1000));
                 // await this._unHighlightElements(element);
                 // }
@@ -1103,11 +1320,28 @@ class StableBrowser {
                     this.logger.info("element did not change its state, ignoring...");
                 }
                 else {
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
                     //await this.closeUnexpectedPopups();
                     state.info.log += "setCheck failed, will try again" + "\n";
-                    state.element = await this._locate(selectors, state.info, _params);
-                    await state.element.setChecked(checked, { timeout: 5000, force: true });
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                    state.element_found = false;
+                    try {
+                        state.element = await this._locate(selectors, state.info, _params, 100);
+                        state.element_found = true;
+                        // check the check state
+                    }
+                    catch (error) {
+                        // element dismissed
+                    }
+                    if (state.element_found) {
+                        const isChecked = await state.element.isChecked();
+                        if (isChecked !== checked) {
+                            // perform click
+                            await state.element.click({ timeout: 2000, force: true });
+                        }
+                        else {
+                            this.logger.info(`Element ${selectors.element_name} is already in the desired state (${checked})`);
+                        }
+                    }
                 }
             }
             await this.waitForPageLoad();
@@ -1403,7 +1637,9 @@ class StableBrowser {
                     await new Promise((resolve) => setTimeout(resolve, 500));
                 }
             }
+            //if (!this.fastMode) {
             await _screenshot(state, this);
+            //}
             if (enter === true) {
                 await new Promise((resolve) => setTimeout(resolve, 2000));
                 await this.page.keyboard.press("Enter");
@@ -1712,14 +1948,17 @@ class StableBrowser {
             throw new Error("referanceSnapshot is null");
         }
         let text = null;
-        if (fs.existsSync(path.join(this.project_path, "snapshots", referanceSnapshot + ".yml"))) {
-            text = fs.readFileSync(path.join(this.project_path, "snapshots", referanceSnapshot + ".yml"), "utf8");
+        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");
+        }
+        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 (referanceSnapshot.startsWith("yaml:")) {
             text = referanceSnapshot.substring(5);
         }
         else {
-            throw new Error("referanceSnapshot file not found: " + referanceSnapshot);
+            throw new Error("referenceSnapshot file not found: " + referanceSnapshot);
         }
         state.text = text;
         const newValue = await this._replaceWithLocalData(text, world);
@@ -1737,18 +1976,23 @@ class StableBrowser {
                         scope = await this._findFrameScope(frameSelectors, timeout, state.info);
                     }
                     const snapshot = await scope.locator("body").ariaSnapshot({ timeout });
-                    matchResult = snapshotValidation(snapshot, newValue);
+                    matchResult = snapshotValidation(snapshot, newValue, referanceSnapshot);
                     if (matchResult.errorLine !== -1) {
                         throw new Error("Snapshot validation failed at line " + matchResult.errorLineText);
                     }
                     // highlight and screenshot
+                    try {
+                        await await highlightSnapshot(newValue, scope);
+                        await _screenshot(state, this);
+                    }
+                    catch (e) { }
                     return state.info;
                 }
                 catch (e) {
                     // Log error but continue retrying until timeout is reached
-                    this.logger.warn("Retrying containsText due to: " + e.message);
+                    //this.logger.warn("Retrying snapshot validation due to: " + e.message);
                 }
-                await new Promise((resolve) => setTimeout(resolve, 1000)); // Wait 1 second before retrying
+                await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait 1 second before retrying
             }
             throw new Error("No snapshot match " + matchResult?.errorLineText);
         }
@@ -1900,12 +2144,7 @@ class StableBrowser {
         }
     }
     getTestData(world = null) {
-        const dataFile = _getDataFile(world, this.context, this);
-        let data = {};
-        if (fs.existsSync(dataFile)) {
-            data = JSON.parse(fs.readFileSync(dataFile, "utf8"));
-        }
-        return data;
+        return _getTestData(world, this.context, this);
     }
     async _screenShot(options = {}, world = null, info = null) {
         // collect url/path/title
@@ -2125,6 +2364,77 @@ class StableBrowser {
             await _commandFinally(state, this);
         }
     }
+    async extractProperty(selectors, property, variable, _params = null, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            property,
+            variable,
+            options,
+            world,
+            type: Types.EXTRACT_PROPERTY,
+            text: `Extract property from element`,
+            _text: `Extract property ${property} from ${selectors.element_name}`,
+            operation: "extractProperty",
+            log: "***** extract property " + property + " from " + selectors.element_name + " *****\n",
+            allowDisabled: true,
+        };
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        try {
+            await _preCommand(state, this);
+            switch (property) {
+                case "inner_text":
+                    state.value = await state.element.innerText();
+                    break;
+                case "href":
+                    state.value = await state.element.getAttribute("href");
+                    break;
+                case "value":
+                    state.value = await state.element.inputValue();
+                    break;
+                case "text":
+                    state.value = await state.element.textContent();
+                    break;
+                default:
+                    if (property.startsWith("dataset.")) {
+                        const dataAttribute = property.substring(8);
+                        state.value = String(await state.element.getAttribute(`data-${dataAttribute}`)) || "";
+                    }
+                    else {
+                        state.value = String(await state.element.evaluate((element, prop) => element[prop], property));
+                    }
+            }
+            if (options !== null) {
+                if (options.regex && options.regex !== "") {
+                    // Construct a regex pattern from the provided string
+                    const regex = options.regex.slice(1, -1);
+                    const regexPattern = new RegExp(regex, "g");
+                    const matches = state.value.match(regexPattern);
+                    if (matches) {
+                        let newValue = "";
+                        for (const match of matches) {
+                            newValue += match;
+                        }
+                        state.value = newValue;
+                    }
+                }
+                if (options.trimSpaces && options.trimSpaces === true) {
+                    state.value = state.value.trim();
+                }
+            }
+            state.info.value = state.value;
+            this.setTestData({ [variable]: state.value }, world);
+            this.logger.info("set test data: " + variable + "=" + state.value);
+            // await new Promise((resolve) => setTimeout(resolve, 500));
+            return state.info;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
     async verifyAttribute(selectors, attribute, value, _params = null, options = {}, world = null) {
         const state = {
             selectors,
@@ -2177,14 +2487,167 @@ class StableBrowser {
             let regex;
             if (expectedValue.startsWith("/") && expectedValue.endsWith("/")) {
                 const patternBody = expectedValue.slice(1, -1);
-                regex = new RegExp(patternBody, "g");
+                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 (!val.match(regex)) {
-                let errorMessage = `The ${attribute} attribute has a value of "${val}", but the expected value is "${expectedValue}"`;
+            if (attribute === "innerText") {
+                if (state.info.regex) {
+                    if (!regex.test(val)) {
+                        let errorMessage = `The ${attribute} attribute 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);
+                    }
+                }
+                else {
+                    const valLines = val.split("\n");
+                    const expectedLines = expectedValue.split("\n");
+                    const isPart = expectedLines.every((expectedLine) => valLines.some((valLine) => valLine === expectedLine));
+                    if (!isPart) {
+                        let errorMessage = `The ${attribute} attribute 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);
+                    }
+                }
+            }
+            else {
+                if (!val.match(regex)) {
+                    let errorMessage = `The ${attribute} attribute 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;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
+    async verifyProperty(selectors, property, value, _params = null, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            property,
+            value,
+            options,
+            world,
+            type: Types.VERIFY_PROPERTY,
+            highlight: true,
+            screenshot: true,
+            text: `Verify element property`,
+            _text: `Verify property ${property} from ${selectors.element_name} is ${value}`,
+            operation: "verifyProperty",
+            log: "***** verify property " + property + " from " + selectors.element_name + " *****\n",
+            allowDisabled: true,
+        };
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let val;
+        let expectedValue;
+        try {
+            await _preCommand(state, this);
+            expectedValue = await replaceWithLocalTestData(state.value, world);
+            state.info.expectedValue = expectedValue;
+            switch (property) {
+                case "innerText":
+                    val = String(await state.element.innerText());
+                    break;
+                case "text":
+                    val = String(await state.element.textContent());
+                    break;
+                case "value":
+                    val = String(await state.element.inputValue());
+                    break;
+                case "checked":
+                    val = String(await state.element.isChecked());
+                    break;
+                case "disabled":
+                    val = String(await state.element.isDisabled());
+                    break;
+                case "readOnly":
+                    const isEditable = await state.element.isEditable();
+                    val = String(!isEditable);
+                    break;
+                case "innerHTML":
+                    val = String(await state.element.innerHTML());
+                    break;
+                case "outerHTML":
+                    val = String(await state.element.evaluate((element) => element.outerHTML));
+                    break;
+                default:
+                    if (property.startsWith("dataset.")) {
+                        const dataAttribute = property.substring(8);
+                        val = String(await state.element.getAttribute(`data-${dataAttribute}`)) || "";
+                    }
+                    else {
+                        val = String(await state.element.evaluate((element, prop) => element[prop], property));
+                    }
+            }
+            // Helper function to remove all style="" attributes
+            const removeStyleAttributes = (htmlString) => {
+                return htmlString.replace(/\s*style\s*=\s*"[^"]*"/gi, "");
+            };
+            // Remove style attributes for innerHTML and outerHTML properties
+            if (property === "innerHTML" || property === "outerHTML") {
+                val = removeStyleAttributes(val);
+                expectedValue = removeStyleAttributes(expectedValue);
+            }
+            state.info.value = val;
+            let regex;
+            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 {
+                    // 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 {
+                // 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);
@@ -2198,6 +2661,132 @@ class StableBrowser {
             await _commandFinally(state, this);
         }
     }
+    async conditionalWait(selectors, condition, timeout = 1000, _params = null, options = {}, world = null) {
+        // Convert timeout from seconds to milliseconds
+        const timeoutMs = timeout * 1000;
+        const state = {
+            selectors,
+            _params,
+            condition,
+            timeout: timeoutMs, // Store as milliseconds for internal use
+            options,
+            world,
+            type: Types.CONDITIONAL_WAIT,
+            highlight: true,
+            screenshot: true,
+            text: `Conditional wait for element`,
+            _text: `Wait for ${selectors.element_name} to be ${condition} (timeout: ${timeout}s)`, // Display original seconds
+            operation: "conditionalWait",
+            log: `***** conditional wait for ${condition} on ${selectors.element_name} *****\n`,
+            allowDisabled: true,
+            info: {},
+        };
+        // Initialize startTime outside try block to ensure it's always accessible
+        const startTime = Date.now();
+        let conditionMet = false;
+        let currentValue = null;
+        let lastError = null;
+        // Main retry loop - continues until timeout or condition is met
+        while (Date.now() - startTime < timeoutMs) {
+            const elapsedTime = Date.now() - startTime;
+            const remainingTime = timeoutMs - elapsedTime;
+            try {
+                // Try to execute _preCommand (element location)
+                await _preCommand(state, this);
+                // If _preCommand succeeds, start condition checking
+                const checkCondition = async () => {
+                    try {
+                        switch (condition.toLowerCase()) {
+                            case "checked":
+                                currentValue = await state.element.isChecked();
+                                return currentValue === true;
+                            case "unchecked":
+                                currentValue = await state.element.isChecked();
+                                return currentValue === false;
+                            case "visible":
+                                currentValue = await state.element.isVisible();
+                                return currentValue === true;
+                            case "hidden":
+                                currentValue = await state.element.isVisible();
+                                return currentValue === false;
+                            case "enabled":
+                                currentValue = await state.element.isDisabled();
+                                return currentValue === false;
+                            case "disabled":
+                                currentValue = await state.element.isDisabled();
+                                return currentValue === true;
+                            case "editable":
+                                // currentValue = await String(await state.element.evaluate((element, prop) => element[prop], "isContentEditable"));
+                                currentValue = await state.element.isContentEditable();
+                                return currentValue === true;
+                            default:
+                                state.info.message = `Unsupported condition: '${condition}'. Supported conditions are: checked, unchecked, visible, hidden, enabled, disabled, editable.`;
+                                state.info.success = false;
+                                return false;
+                        }
+                    }
+                    catch (error) {
+                        // Don't throw here, just return false to continue retrying
+                        return false;
+                    }
+                };
+                // Inner loop for condition checking (once element is located)
+                while (Date.now() - startTime < timeoutMs) {
+                    const currentElapsedTime = Date.now() - startTime;
+                    conditionMet = await checkCondition();
+                    if (conditionMet) {
+                        break;
+                    }
+                    // Check if we still have time for another attempt
+                    if (Date.now() - startTime + 50 < timeoutMs) {
+                        await new Promise((res) => setTimeout(res, 50));
+                    }
+                    else {
+                        break;
+                    }
+                }
+                // If we got here and condition is met, break out of main loop
+                if (conditionMet) {
+                    break;
+                }
+                // If condition not met but no exception, we've timed out
+                break;
+            }
+            catch (e) {
+                lastError = e;
+                const currentElapsedTime = Date.now() - startTime;
+                const timeLeft = timeoutMs - currentElapsedTime;
+                // Check if we have enough time left to retry
+                if (timeLeft > 100) {
+                    await new Promise((resolve) => setTimeout(resolve, 50));
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        const actualWaitTime = Date.now() - startTime;
+        state.info = {
+            success: conditionMet,
+            conditionMet,
+            actualWaitTime,
+            currentValue,
+            lastError: lastError?.message || null,
+            message: conditionMet
+                ? `Condition '${condition}' met after ${(actualWaitTime / 1000).toFixed(2)}s`
+                : `Condition '${condition}' not met within ${timeout}s timeout`,
+        };
+        if (lastError) {
+            state.log += `Last error: ${lastError.message}\n`;
+        }
+        try {
+            await _commandFinally(state, this);
+        }
+        catch (finallyError) {
+            state.log += `Error in _commandFinally: ${finallyError.message}\n`;
+        }
+        return state.info;
+    }
     async extractEmailData(emailAddress, options, world) {
         if (!emailAddress) {
             throw new Error("email address is null");
@@ -2355,56 +2944,49 @@ class StableBrowser {
             console.debug(error);
         }
     }
-    // async _unhighlightElements(scope, css) {
-    //   try {
-    //     if (!scope) {
-    //       return;
-    //     }
-    //     if (!css) {
-    //       scope
-    //         .evaluate((node) => {
-    //           if (node && node.style) {
-    //             if (!node.__previousOutline) {
-    //               node.style.outline = "";
-    //             } else {
-    //               node.style.outline = node.__previousOutline;
-    //             }
-    //           }
-    //         })
-    //         .then(() => {})
-    //         .catch((e) => {
-    //           // console.log(`Error while unhighlighting node ${JSON.stringify(scope)}: ${e}`);
-    //         });
-    //     } else {
-    //       scope
-    //         .evaluate(([css]) => {
-    //           if (!css) {
-    //             return;
-    //           }
-    //           let elements = Array.from(document.querySelectorAll(css));
-    //           for (i = 0; i < elements.length; i++) {
-    //             let element = elements[i];
-    //             if (!element.style) {
-    //               return;
-    //             }
-    //             if (!element.__previousOutline) {
-    //               element.style.outline = "";
-    //             } else {
-    //               element.style.outline = element.__previousOutline;
-    //             }
-    //           }
-    //         })
-    //         .then(() => {})
-    //         .catch((e) => {
-    //           // console.error(`Error while unhighlighting element in css: ${e}`);
-    //         });
-    //     }
-    //   } catch (error) {
-    //     // console.debug(error);
-    //   }
-    // }
+    _matcher(text) {
+        if (!text) {
+            return { matcher: "contains", queryText: "" };
+        }
+        if (text.length < 2) {
+            return { matcher: "contains", queryText: text };
+        }
+        const split = text.split(":");
+        const matcher = split[0].toLowerCase();
+        const queryText = split.slice(1).join(":").trim();
+        return { matcher, queryText };
+    }
+    _getDomain(url) {
+        if (url.length === 0 || (!url.startsWith("http://") && !url.startsWith("https://"))) {
+            return "";
+        }
+        let hostnameFragments = url.split("/")[2].split(".");
+        if (hostnameFragments.some((fragment) => fragment.includes(":"))) {
+            return hostnameFragments.join("-").split(":").join("-");
+        }
+        let n = hostnameFragments.length;
+        let fragments = [...hostnameFragments];
+        while (n > 0 && hostnameFragments[n - 1].length <= 3) {
+            hostnameFragments.pop();
+            n = hostnameFragments.length;
+        }
+        if (n == 0) {
+            if (fragments[0] === "www")
+                fragments = fragments.slice(1);
+            return fragments.length > 1 ? fragments.slice(0, fragments.length - 1).join("-") : fragments.join("-");
+        }
+        if (hostnameFragments[0] === "www")
+            hostnameFragments = hostnameFragments.slice(1);
+        return hostnameFragments.join(".");
+    }
+    /**
+     * Verify the page path matches the given path.
+     * @param {string} pathPart - The path to verify.
+     * @param {object} options - Options for verification.
+     * @param {object} world - The world context.
+     * @returns {Promise<object>} - The state info after verification.
+     */
     async verifyPagePath(pathPart, options = {}, world = null) {
-        const startTime = Date.now();
         let error = null;
         let screenshotId = null;
         let screenshotPath = null;
@@ -2418,113 +3000,212 @@ class StableBrowser {
             pathPart = newValue;
         }
         info.pathPart = pathPart;
+        const { matcher, queryText } = this._matcher(pathPart);
+        const state = {
+            text_search: queryText,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.VERIFY_PAGE_PATH,
+            text: `Verify the page url is ${queryText}`,
+            _text: `Verify the page url is ${queryText}`,
+            operation: "verifyPagePath",
+            log: "***** verify page url is " + queryText + " *****\n",
+        };
         try {
+            await _preCommand(state, this);
+            state.info.text = queryText;
             for (let i = 0; i < 30; i++) {
                 const url = await this.page.url();
-                if (!url.includes(pathPart)) {
-                    if (i === 29) {
-                        throw new Error(`url ${url} doesn't contain ${pathPart}`);
-                    }
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
-                    continue;
+                switch (matcher) {
+                    case "exact":
+                        if (url !== queryText) {
+                            if (i === 29) {
+                                throw new Error(`Page URL ${url} is not equal to ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    case "contains":
+                        if (!url.includes(queryText)) {
+                            if (i === 29) {
+                                throw new Error(`Page URL ${url} doesn't contain ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    case "starts-with":
+                        {
+                            const domain = this._getDomain(url);
+                            if (domain.length > 0 && domain !== queryText) {
+                                if (i === 29) {
+                                    throw new Error(`Page URL ${url} doesn't start with ${queryText}`);
+                                }
+                                await new Promise((resolve) => setTimeout(resolve, 1000));
+                                continue;
+                            }
+                        }
+                        break;
+                    case "ends-with":
+                        {
+                            const urlObj = new URL(url);
+                            let route = "/";
+                            if (urlObj.pathname !== "/") {
+                                route = urlObj.pathname.split("/").slice(-1)[0].trim();
+                            }
+                            else {
+                                route = "/";
+                            }
+                            if (route !== queryText) {
+                                if (i === 29) {
+                                    throw new Error(`Page URL ${url} doesn't end with ${queryText}`);
+                                }
+                                await new Promise((resolve) => setTimeout(resolve, 1000));
+                                continue;
+                            }
+                        }
+                        break;
+                    case "regex":
+                        const regex = new RegExp(queryText.slice(1, -1), "g");
+                        if (!regex.test(url)) {
+                            if (i === 29) {
+                                throw new Error(`Page URL ${url} doesn't match regex ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    default:
+                        console.log("Unknown matching type, defaulting to contains matching");
+                        if (!url.includes(pathPart)) {
+                            if (i === 29) {
+                                throw new Error(`Page URL ${url} does not contain ${pathPart}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
                 }
-                ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-                return info;
+                await _screenshot(state, this);
+                return state.info;
             }
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("verify page path failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            // throw e;
-            await _commandError({ text: "verifyPagePath", operation: "verifyPagePath", pathPart, info }, e, this);
+            state.info.failCause.lastError = e.message;
+            state.info.failCause.assertionFailed = true;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            _reportToWorld(world, {
-                type: Types.VERIFY_PAGE_PATH,
-                text: "Verify page path",
-                _text: "Verify the page path contains " + pathPart,
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error?.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            await _commandFinally(state, this);
         }
     }
+    /**
+     * Verify the page title matches the given title.
+     * @param {string} title - The title to verify.
+     * @param {object} options - Options for verification.
+     * @param {object} world - The world context.
+     * @returns {Promise<object>} - The state info after verification.
+     */
     async verifyPageTitle(title, options = {}, world = null) {
-        const startTime = Date.now();
         let error = null;
         let screenshotId = null;
         let screenshotPath = null;
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        const info = {};
-        info.log = "***** verify page title " + title + " *****\n";
-        info.operation = "verifyPageTitle";
         const newValue = await this._replaceWithLocalData(title, world);
         if (newValue !== title) {
             this.logger.info(title + "=" + newValue);
             title = newValue;
         }
-        info.title = title;
+        const { matcher, queryText } = this._matcher(title);
+        const state = {
+            text_search: queryText,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.VERIFY_PAGE_TITLE,
+            text: `Verify the page title is ${queryText}`,
+            _text: `Verify the page title is ${queryText}`,
+            operation: "verifyPageTitle",
+            log: "***** verify page title is " + queryText + " *****\n",
+        };
         try {
+            await _preCommand(state, this);
+            state.info.text = queryText;
             for (let i = 0; i < 30; i++) {
                 const foundTitle = await this.page.title();
-                if (!foundTitle.includes(title)) {
-                    if (i === 29) {
-                        throw new Error(`url ${foundTitle} doesn't contain ${title}`);
-                    }
-                    await new Promise((resolve) => setTimeout(resolve, 1000));
-                    continue;
+                switch (matcher) {
+                    case "exact":
+                        if (foundTitle !== queryText) {
+                            if (i === 29) {
+                                throw new Error(`Page Title ${foundTitle} is not equal to ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    case "contains":
+                        if (!foundTitle.includes(queryText)) {
+                            if (i === 29) {
+                                throw new Error(`Page Title ${foundTitle} doesn't contain ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    case "starts-with":
+                        if (!foundTitle.startsWith(queryText)) {
+                            if (i === 29) {
+                                throw new Error(`Page title ${foundTitle} doesn't start with ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    case "ends-with":
+                        if (!foundTitle.endsWith(queryText)) {
+                            if (i === 29) {
+                                throw new Error(`Page Title ${foundTitle} doesn't end with ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    case "regex":
+                        const regex = new RegExp(queryText.slice(1, -1), "g");
+                        if (!regex.test(foundTitle)) {
+                            if (i === 29) {
+                                throw new Error(`Page Title ${foundTitle} doesn't match regex ${queryText}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
+                        break;
+                    default:
+                        console.log("Unknown matching type, defaulting to contains matching");
+                        if (!foundTitle.includes(title)) {
+                            if (i === 29) {
+                                throw new Error(`Page Title ${foundTitle} does not contain ${title}`);
+                            }
+                            await new Promise((resolve) => setTimeout(resolve, 1000));
+                            continue;
+                        }
                 }
-                ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-                return info;
+                await _screenshot(state, this);
+                return state.info;
             }
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("verify page title failed " + info.log);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            info.screenshotPath = screenshotPath;
-            Object.assign(e, { info: info });
-            error = e;
-            // throw e;
-            await _commandError({ text: "verifyPageTitle", operation: "verifyPageTitle", title, info, throwError: true }, e, this);
+            state.info.failCause.lastError = e.message;
+            state.info.failCause.assertionFailed = true;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            _reportToWorld(world, {
-                type: Types.VERIFY_PAGE_PATH,
-                text: "Verify page title",
-                _text: "Verify the page title contains " + title,
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error?.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            await _commandFinally(state, this);
         }
     }
     async findTextInAllFrames(dateAlternatives, numberAlternatives, text, state, partial = true, ignoreCase = false) {
@@ -2608,27 +3289,10 @@ class StableBrowser {
                         const frame = resultWithElementsFound[0].frame;
                         const dataAttribute = `[data-blinq-id-${resultWithElementsFound[0].randomToken}]`;
                         await this._highlightElements(frame, dataAttribute);
-                        // if (world && world.screenshot && !world.screenshotPath) {
-                        // console.log(`Highlighting for verify text is found while running from recorder`);
-                        // this._highlightElements(frame, dataAttribute).then(async () => {
-                        // await new Promise((resolve) => setTimeout(resolve, 1000));
-                        // this._unhighlightElements(frame, dataAttribute)
-                        // .then(async () => {
-                        // console.log(`Unhighlighted frame dataAttribute successfully`);
-                        // })
-                        // .catch(
-                        // (e) => {}
-                        //  console.error(e)
-                        // );
-                        // });
-                        // }
                         const element = await frame.locator(dataAttribute).first();
-                        // await new Promise((resolve) => setTimeout(resolve, 100));
-                        // await this._unhighlightElements(frame, dataAttribute);
                         if (element) {
                             await this.scrollIfNeeded(element, state.info);
                             await element.dispatchEvent("bvt_verify_page_contains_text");
-                            // await _screenshot(state, this, element);
                         }
                     }
                     await _screenshot(state, this);
@@ -2638,7 +3302,6 @@ class StableBrowser {
                     console.error(error);
                 }
             }
-            // await expect(element).toHaveCount(1, { timeout: 10000 });
         }
         catch (e) {
             await _commandError(state, e, this);
@@ -2720,6 +3383,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);
@@ -2755,6 +3420,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;
@@ -3154,6 +3830,43 @@ class StableBrowser {
             });
         }
     }
+    /**
+     * Explicit wait/sleep function that pauses execution for a specified duration
+     * @param duration - Duration to sleep in milliseconds (default: 1000ms)
+     * @param options - Optional configuration object
+     * @param world - Optional world context
+     * @returns Promise that resolves after the specified duration
+     */
+    async sleep(duration = 1000, options = {}, world = null) {
+        const state = {
+            duration,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            screenshot: false,
+            highlight: false,
+            type: Types.SLEEP,
+            text: `Sleep for ${duration} ms`,
+            _text: `Sleep for ${duration} ms`,
+            operation: "sleep",
+            log: `***** Sleep for ${duration} ms *****\n`,
+        };
+        try {
+            await _preCommand(state, this);
+            if (duration < 0) {
+                throw new Error("Sleep duration cannot be negative");
+            }
+            await new Promise((resolve) => setTimeout(resolve, duration));
+            return state.info;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
     async _replaceWithLocalData(value, world, _decrypt = true, totpWait = true) {
         try {
             return await replaceWithLocalTestData(value, world, _decrypt, totpWait, this.context, this);
@@ -3184,6 +3897,7 @@ class StableBrowser {
     }
     async saveStoreState(path = null, world = null) {
         const storageState = await this.page.context().storageState();
+        path = await this._replaceWithLocalData(path, this.world);
         //const testDataFile = _getDataFile(world, this.context, this);
         if (path) {
             // save { storageState: storageState } into the path
@@ -3194,6 +3908,7 @@ class StableBrowser {
         }
     }
     async restoreSaveState(path = null, world = null) {
+        path = await this._replaceWithLocalData(path, this.world);
         await refreshBrowser(this, path, world);
         this.registerEventListeners(this.context);
         registerNetworkEvents(this.world, this, this.context, this.page);
@@ -3235,7 +3950,6 @@ class StableBrowser {
             else if (e.label === "domcontentloaded") {
                 console.log("waited for the domcontent loaded timeout");
             }
-            console.log(".");
         }
         finally {
             await new Promise((resolve) => setTimeout(resolve, 2000));
@@ -3279,7 +3993,6 @@ class StableBrowser {
             await this.page.close();
         }
         catch (e) {
-            console.log(".");
             await _commandError(state, e, this);
         }
         finally {
@@ -3394,7 +4107,6 @@ class StableBrowser {
             await this.page.setViewportSize({ width: width, height: hight });
         }
         catch (e) {
-            console.log(".");
             await _commandError({ text: "setViewportSize", operation: "setViewportSize", width, hight, info }, e, this);
         }
         finally {
@@ -3432,7 +4144,6 @@ class StableBrowser {
             await this.page.reload();
         }
         catch (e) {
-            console.log(".");
             await _commandError({ text: "reloadPage", operation: "reloadPage", info }, e, this);
         }
         finally {
@@ -3476,6 +4187,10 @@ class StableBrowser {
         }
     }
     async beforeScenario(world, scenario) {
+        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;
@@ -3499,14 +4214,18 @@ class StableBrowser {
             envName = this.context.environment.name;
         }
         if (!process.env.TEMP_RUN) {
-            await getTestData(envName, world, undefined, this.featureName, this.scenarioName);
+            await getTestData(envName, world, undefined, this.featureName, this.scenarioName, this.context);
         }
         await loadBrunoParams(this.context, this.context.environment.name);
     }
     async afterScenario(world, scenario) { }
     async beforeStep(world, step) {
+        if (this.abortedExecution) {
+            throw new Error("Aborted");
+        }
         if (!this.beforeScenarioCalled) {
             this.beforeScenario(world, step);
+            this.context.loadedRoutes = null;
         }
         if (this.stepIndex === undefined) {
             this.stepIndex = 0;
@@ -3531,13 +4250,16 @@ class StableBrowser {
         }
         if (this.initSnapshotTaken === false) {
             this.initSnapshotTaken = true;
-            if (world && world.attach && !process.env.DISABLE_SNAPSHOT) {
+            if (world && world.attach && !process.env.DISABLE_SNAPSHOT && !this.fastMode) {
                 const snapshot = await this.getAriaSnapshot();
                 if (snapshot) {
                     await world.attach(JSON.stringify(snapshot), "application/json+snapshot-before");
                 }
             }
         }
+        this.context.routeResults = null;
+        await registerBeforeStepRoutes(this.context, this.stepName);
+        networkBeforeStep(this.stepName);
     }
     async getAriaSnapshot() {
         try {
@@ -3557,12 +4279,18 @@ class StableBrowser {
                 try {
                     // Ensure frame is attached and has body
                     const body = frame.locator("body");
-                    await body.waitFor({ timeout }); // wait explicitly
+                    //await body.waitFor({ timeout: 2000 }); // wait explicitly
                     const snapshot = await body.ariaSnapshot({ timeout });
+                    if (!snapshot) {
+                        continue;
+                    }
                     content.push(`- frame: ${i}`);
                     content.push(snapshot);
                 }
-                catch (innerErr) { }
+                catch (innerErr) {
+                    console.warn(`Frame ${i} snapshot failed:`, innerErr);
+                    content.push(`- frame: ${i} - error: ${innerErr.message}`);
+                }
             }
             return content.join("\n");
         }
@@ -3572,6 +4300,49 @@ class StableBrowser {
         }
         return null;
     }
+    /**
+     * Sends command with custom payload to report.
+     * @param commandText - Title of the command to be shown in the report.
+     * @param commandStatus - Status of the command (e.g. "PASSED", "FAILED").
+     * @param content - Content of the command to be shown in the report.
+     * @param options - Options for the command. Example: { type: "json", screenshot: true }
+     * @param world - Optional world context.
+     * @public
+     */
+    async addCommandToReport(commandText, commandStatus, content, options = {}, world = null) {
+        const state = {
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            screenshot: options.screenshot ?? false,
+            highlight: options.highlight ?? false,
+            type: Types.REPORT_COMMAND,
+            text: commandText,
+            _text: commandText,
+            operation: "report_command",
+            log: "***** " + commandText + " *****\n",
+        };
+        try {
+            await _preCommand(state, this);
+            const payload = {
+                type: options.type ?? "text",
+                content: content,
+                screenshotId: null,
+            };
+            state.payload = payload;
+            if (commandStatus === "FAILED") {
+                state.throwError = true;
+                throw new Error("Command failed");
+            }
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
     async afterStep(world, step) {
         this.stepName = null;
         if (this.context && this.context.browserObject && this.context.browserObject.trace === true) {
@@ -3591,13 +4362,43 @@ class StableBrowser {
         if (this.context) {
             this.context.examplesRow = null;
         }
-        if (world && world.attach && !process.env.DISABLE_SNAPSHOT) {
+        if (world && world.attach && !process.env.DISABLE_SNAPSHOT && !this.fastMode) {
             const snapshot = await this.getAriaSnapshot();
             if (snapshot) {
                 const obj = {};
                 await world.attach(JSON.stringify(snapshot), "application/json+snapshot-after");
             }
         }
+        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,
+                locate: false,
+                scroll: false,
+                screenshot: true,
+                highlight: true,
+                type: Types.STEP_COMPLETE,
+                text: "end of scenario",
+                _text: "end of scenario",
+                operation: "step_complete",
+                log: "***** " + "end of scenario" + " *****\n",
+            };
+            try {
+                await _preCommand(state, this);
+            }
+            catch (e) {
+                await _commandError(state, e, this);
+            }
+            finally {
+                await _commandFinally(state, this);
+            }
+        }
+        networkAfterStep(this.stepName);
     }
 }
 function createTimedPromise(promise, label) {