automation_model 1.0.658-dev → 1.0.658-stage

package/lib/stable_browser.js

@@ -10,11 +10,12 @@ 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 { _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";
 import { getContext, refreshBrowser } from "./init_browser.js";
+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";
@@ -22,23 +23,27 @@ import { registerDownloadEvent, registerNetworkEvents } from "./network.js";
 import { LocatorLog } from "./locator_log.js";
 import axios from "axios";
 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";
 export const Types = {
     CLICK: "click_element",
     WAIT_ELEMENT: "wait_element",
-    NAVIGATE: "navigate",
+    NAVIGATE: "navigate", ///
     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_PAGE_PATH: "verify_page_path",
+    VERIFY_PAGE_TITLE: "verify_page_title",
     TYPE_PRESS: "type_press",
     PRESS: "press_key",
     HOVER: "hover_element",
@@ -55,6 +60,13 @@ export const Types = {
     WAIT_FOR_TEXT_TO_DISAPPEAR: "wait_for_text_to_disappear",
     VERIFY_ATTRIBUTE: "verify_element_attribute",
     VERIFY_TEXT_WITH_RELATION: "verify_text_with_relation",
+    BRUNO: "bruno",
+    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",
 };
 export const apps = {};
 const formatElementName = (elementName) => {
@@ -66,6 +78,7 @@ class StableBrowser {
     logger;
     context;
     world;
+    fastMode;
     project_path = null;
     webLogFile = null;
     networkLogger = null;
@@ -74,12 +87,13 @@ class StableBrowser {
     tags = null;
     isRecording = false;
     initSnapshotTaken = false;
-    constructor(browser, page, logger = null, context = null, world = null) {
+    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;
         }
@@ -108,6 +122,18 @@ 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") {
+            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);
@@ -118,6 +144,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");
@@ -126,6 +155,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);
@@ -177,9 +214,35 @@ 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) {
+        // first check if the tabNameOrIndex is a number
+        let index = parseInt(tabTitleOrIndex);
+        if (!isNaN(index)) {
+            if (index >= 0 && index < this.context.pages.length) {
+                this.page = this.context.pages[index];
+                this.context.page = this.page;
+                await this.page.bringToFront();
+                return;
+            }
+        }
+        // if the tabNameOrIndex is a string, find the tab by name
+        for (let i = 0; i < this.context.pages.length; i++) {
+            let page = this.context.pages[i];
+            let title = await page.title();
+            if (title.includes(tabTitleOrIndex)) {
+                this.page = page;
+                this.context.page = this.page;
+                await this.page.bringToFront();
+                return;
+            }
+        }
+        throw new Error("Tab not found: " + tabTitleOrIndex);
+    }
     registerConsoleLogListener(page, context) {
         if (!this.context.webLogger) {
             this.context.webLogger = [];
@@ -247,6 +310,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;
         }
@@ -275,7 +339,7 @@ class StableBrowser {
             _commandError(state, error, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async _getLocator(locator, scope, _params) {
@@ -391,7 +455,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 = {};
         }
@@ -458,7 +522,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++) {
@@ -473,7 +537,7 @@ class StableBrowser {
                     info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
                 }
             }
-            else {
+            else if (logErrors) {
                 info.failCause.visible = visible;
                 info.failCause.enabled = enabled;
                 if (!info.printMessages) {
@@ -565,7 +629,7 @@ class StableBrowser {
             let 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, "");
                 }, randomToken);
                 // if (element._frame) {
@@ -579,7 +643,7 @@ class StableBrowser {
                 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;
@@ -814,7 +878,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,
@@ -833,7 +897,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) {
@@ -874,7 +940,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");
@@ -926,7 +992,7 @@ class StableBrowser {
                         await _commandError(state, "timeout looking for " + elementDescription, this);
                     }
                     finally {
-                        _commandFinally(state, this);
+                        await _commandFinally(state, this);
                     }
                 }
             }
@@ -975,7 +1041,7 @@ class StableBrowser {
                         await _commandError(state, "timeout looking for " + elementDescription, this);
                     }
                     finally {
-                        _commandFinally(state, this);
+                        await _commandFinally(state, this);
                     }
                 }
             }
@@ -997,14 +1063,16 @@ 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) {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async waitForElement(selectors, _params, options = {}, world = null) {
@@ -1035,7 +1103,7 @@ class StableBrowser {
             // await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
         return found;
     }
@@ -1060,7 +1128,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);
                 // }
@@ -1072,11 +1140,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();
@@ -1086,7 +1171,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async hover(selectors, _params, options = {}, world = null) {
@@ -1112,7 +1197,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async selectOption(selectors, values, _params = null, options = {}, world = null) {
@@ -1148,7 +1233,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async type(_value, _params = null, options = {}, world = null) {
@@ -1194,7 +1279,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async setInputValue(selectors, value, _params = null, options = {}, world = null) {
@@ -1230,7 +1315,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async setDateTime(selectors, value, format = null, enter = false, _params = null, options = {}, world = null) {
@@ -1299,7 +1384,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async clickType(selectors, _value, enter = false, _params = null, options = {}, world = null) {
@@ -1372,7 +1457,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");
@@ -1399,7 +1486,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async fill(selectors, value, enter = false, _params = null, options = {}, world = null) {
@@ -1429,7 +1516,42 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
+        }
+    }
+    async setInputFiles(selectors, files, _params = null, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            files,
+            value: '"' + files.join('", "') + '"',
+            options,
+            world,
+            type: Types.SET_INPUT_FILES,
+            text: `Set input files`,
+            _text: `Set input files on ${selectors.element_name}`,
+            operation: "setInputFiles",
+            log: "***** set input files " + selectors.element_name + " *****\n",
+        };
+        const uploadsFolder = this.configuration.uploadsFolder ?? "data/uploads";
+        try {
+            await _preCommand(state, this);
+            for (let i = 0; i < files.length; i++) {
+                const file = files[i];
+                const filePath = path.join(uploadsFolder, file);
+                if (!fs.existsSync(filePath)) {
+                    throw new Error(`File not found: ${filePath}`);
+                }
+                state.files[i] = filePath;
+            }
+            await state.element.setInputFiles(files);
+            return state.info;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
         }
     }
     async getText(selectors, _params = null, options = {}, info = {}, world = null) {
@@ -1545,7 +1667,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async containsText(selectors, text, climb, _params = null, options = {}, world = null) {
@@ -1622,7 +1744,84 @@ class StableBrowser {
             throw e;
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
+        }
+    }
+    async snapshotValidation(frameSelectors, referanceSnapshot, _params = null, options = {}, world = null) {
+        const timeout = this._getFindElementTimeout(options);
+        const startTime = Date.now();
+        const state = {
+            _params,
+            value: referanceSnapshot,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            screenshot: true,
+            highlight: false,
+            type: Types.SNAPSHOT_VALIDATION,
+            text: `verify snapshot: ${referanceSnapshot}`,
+            operation: "snapshotValidation",
+            log: "***** verify snapshot *****\n",
+        };
+        if (!referanceSnapshot) {
+            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");
+        }
+        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("referenceSnapshot file not found: " + referanceSnapshot);
+        }
+        state.text = text;
+        const newValue = await this._replaceWithLocalData(text, world);
+        await _preCommand(state, this);
+        let foundObj = null;
+        try {
+            let matchResult = null;
+            while (Date.now() - startTime < timeout) {
+                try {
+                    let scope = null;
+                    if (!frameSelectors) {
+                        scope = this.page;
+                    }
+                    else {
+                        scope = await this._findFrameScope(frameSelectors, timeout, state.info);
+                    }
+                    const snapshot = await scope.locator("body").ariaSnapshot({ timeout });
+                    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 snapshot validation due to: " + e.message);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 2000)); // Wait 1 second before retrying
+            }
+            throw new Error("No snapshot match " + matchResult?.errorLineText);
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+            throw e;
+        }
+        finally {
+            await _commandFinally(state, this);
         }
     }
     async waitForUserInput(message, world = null) {
@@ -1765,12 +1964,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
@@ -1921,7 +2115,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async extractAttribute(selectors, attribute, variable, _params = null, options = {}, world = null) {
@@ -1952,10 +2146,102 @@ class StableBrowser {
                 case "value":
                     state.value = await state.element.inputValue();
                     break;
+                case "text":
+                    state.value = await state.element.textContent();
+                    break;
                 default:
                     state.value = await state.element.getAttribute(attribute);
                     break;
             }
+            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 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);
@@ -1966,7 +2252,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async verifyAttribute(selectors, attribute, value, _params = null, options = {}, world = null) {
@@ -1991,12 +2277,15 @@ class StableBrowser {
         let expectedValue;
         try {
             await _preCommand(state, this);
-            expectedValue = state.value;
+            expectedValue = await replaceWithLocalTestData(state.value, world);
             state.info.expectedValue = expectedValue;
             switch (attribute) {
                 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;
@@ -2018,17 +2307,42 @@ 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}"`;
-                state.info.failCause.assertionFailed = true;
-                state.info.failCause.lastError = errorMessage;
-                throw new Error(errorMessage);
+            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;
         }
@@ -2036,7 +2350,128 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            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;
+            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);
+                    }
+                }
+                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);
+                    }
+                }
+            }
+            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);
+                }
+            }
+            return state.info;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
         }
     }
     async extractEmailData(emailAddress, options, world) {
@@ -2196,56 +2631,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;
@@ -2259,113 +2687,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) {
@@ -2407,7 +2934,7 @@ class StableBrowser {
             scroll: false,
             highlight: false,
             type: Types.VERIFY_PAGE_CONTAINS_TEXT,
-            text: `Verify the text '${text}' exists in page`,
+            text: `Verify the text '${maskValue(text)}' exists in page`,
             _text: `Verify the text '${text}' exists in page`,
             operation: "verifyTextExistInPage",
             log: "***** verify text " + text + " exists in page *****\n",
@@ -2449,27 +2976,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);
@@ -2479,13 +2989,12 @@ class StableBrowser {
                     console.error(error);
                 }
             }
-            // await expect(element).toHaveCount(1, { timeout: 10000 });
         }
         catch (e) {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async waitForTextToDisappear(text, options = {}, world = null) {
@@ -2498,7 +3007,7 @@ class StableBrowser {
             scroll: false,
             highlight: false,
             type: Types.WAIT_FOR_TEXT_TO_DISAPPEAR,
-            text: `Verify the text '${text}' does not exist in page`,
+            text: `Verify the text '${maskValue(text)}' does not exist in page`,
             _text: `Verify the text '${text}' does not exist in page`,
             operation: "verifyTextNotExistInPage",
             log: "***** verify text " + text + " does not exist in page *****\n",
@@ -2542,7 +3051,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async verifyTextRelatedToText(textAnchor, climb, textToVerify, options = {}, world = null) {
@@ -2612,7 +3121,7 @@ class StableBrowser {
                         const count = await frame.locator(css).count();
                         for (let j = 0; j < count; j++) {
                             const continer = await frame.locator(css).nth(j);
-                            const result = await this._locateElementByText(continer, textToVerify, "*:not(script, style, head)", false, false, true, {});
+                            const result = await this._locateElementByText(continer, textToVerify, "*:not(script, style, head)", false, true, true, {});
                             if (result.elementCount > 0) {
                                 const dataAttribute = "[data-blinq-id-" + result.randomToken + "]";
                                 await this._highlightElements(frame, dataAttribute);
@@ -2653,7 +3162,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async findRelatedTextInAllFrames(textAnchor, climb, textToVerify, params = {}, options = {}, world = null) {
@@ -2995,8 +3504,51 @@ 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) {
-        return await replaceWithLocalTestData(value, world, _decrypt, totpWait, this.context, this);
+        try {
+            return await replaceWithLocalTestData(value, world, _decrypt, totpWait, this.context, this);
+        }
+        catch (error) {
+            this.logger.debug(error);
+            throw error;
+        }
     }
     _getLoadTimeout(options) {
         let timeout = 15000;
@@ -3019,6 +3571,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
@@ -3029,10 +3582,14 @@ 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);
         registerDownloadEvent(this.page, this.world, this.context);
+        if (this.onRestoreSaveState) {
+            this.onRestoreSaveState(path);
+        }
     }
     async waitForPageLoad(options = {}, world = null) {
         let timeout = this._getLoadTimeout(options);
@@ -3115,7 +3672,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async tableCellOperation(headerText, rowText, options, _params, world = null) {
@@ -3202,7 +3759,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     saveTestDataAsGlobal(options, world) {
@@ -3307,7 +3864,39 @@ class StableBrowser {
             console.log("#-#");
         }
     }
+    async beforeScenario(world, scenario) {
+        this.beforeScenarioCalled = true;
+        if (scenario && scenario.pickle && scenario.pickle.name) {
+            this.scenarioName = scenario.pickle.name;
+        }
+        if (scenario && scenario.gherkinDocument && scenario.gherkinDocument.feature) {
+            this.featureName = scenario.gherkinDocument.feature.name;
+        }
+        if (this.context) {
+            this.context.examplesRow = extractStepExampleParameters(scenario);
+        }
+        if (this.tags === null && scenario && scenario.pickle && scenario.pickle.tags) {
+            this.tags = scenario.pickle.tags.map((tag) => tag.name);
+            // check if @global_test_data tag is present
+            if (this.tags.includes("@global_test_data")) {
+                this.saveTestDataAsGlobal({}, world);
+            }
+        }
+        // update test data based on feature/scenario
+        let envName = null;
+        if (this.context && this.context.environment) {
+            envName = this.context.environment.name;
+        }
+        if (!process.env.TEMP_RUN) {
+            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.beforeScenarioCalled) {
+            this.beforeScenario(world, step);
+        }
         if (this.stepIndex === undefined) {
             this.stepIndex = 0;
         }
@@ -3324,30 +3913,22 @@ class StableBrowser {
         else {
             this.stepName = "step " + this.stepIndex;
         }
-        if (this.context) {
-            this.context.examplesRow = extractStepExampleParameters(step);
-        }
         if (this.context && this.context.browserObject && this.context.browserObject.trace === true) {
             if (this.context.browserObject.context) {
                 await this.context.browserObject.context.tracing.startChunk({ title: this.stepName });
             }
         }
-        if (this.tags === null && step && step.pickle && step.pickle.tags) {
-            this.tags = step.pickle.tags.map((tag) => tag.name);
-            // check if @global_test_data tag is present
-            if (this.tags.includes("@global_test_data")) {
-                this.saveTestDataAsGlobal({}, world);
-            }
-        }
         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);
     }
     async getAriaSnapshot() {
         try {
@@ -3363,18 +3944,68 @@ class StableBrowser {
             const content = [`- path: ${path}`, `- title: ${title}`];
             const timeout = this.configuration.ariaSnapshotTimeout ? this.configuration.ariaSnapshotTimeout : 3000;
             for (let i = 0; i < frames.length; i++) {
-                content.push(`- frame: ${i}`);
                 const frame = frames[i];
-                const snapshot = await frame.locator("body").ariaSnapshot({ timeout });
-                content.push(snapshot);
+                try {
+                    // Ensure frame is attached and has body
+                    const body = frame.locator("body");
+                    await body.waitFor({ timeout: 200 }); // wait explicitly
+                    const snapshot = await body.ariaSnapshot({ timeout });
+                    content.push(`- frame: ${i}`);
+                    content.push(snapshot);
+                }
+                catch (innerErr) { }
             }
             return content.join("\n");
         }
         catch (e) {
-            console.error(e);
+            console.log("Error in getAriaSnapshot");
+            //console.debug(e);
         }
         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) {
@@ -3382,6 +4013,13 @@ class StableBrowser {
                 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) {
@@ -3394,6 +4032,30 @@ class StableBrowser {
                 await world.attach(JSON.stringify(snapshot), "application/json+snapshot-after");
             }
         }
+        this.context.routeResults = await registerAfterStepRoutes(this.context, world);
+        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);
+            }
+        }
     }
 }
 function createTimedPromise(promise, label) {