automation_model 1.0.640-dev → 1.0.640-stage

package/lib/stable_browser.js

@@ -15,6 +15,7 @@ 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,26 @@ import { 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 { loadBrunoParams } from "./bruno.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 +59,12 @@ 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",
 };
 export const apps = {};
 const formatElementName = (elementName) => {
@@ -118,6 +128,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 +139,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);
@@ -180,6 +201,30 @@ class StableBrowser {
             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 +292,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 +321,7 @@ class StableBrowser {
             _commandError(state, error, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async _getLocator(locator, scope, _params) {
@@ -391,7 +437,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 +504,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 +519,7 @@ class StableBrowser {
                     info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
                 }
             }
-            else {
+            else if (logErrors) {
                 info.failCause.visible = visible;
                 info.failCause.enabled = enabled;
                 if (!info.printMessages) {
@@ -565,15 +611,27 @@ 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) {
-                    return element;
-                }
-                const scope = element.page();
-                const newSelector = scope.locator("[data-blinq-id-" + randomToken + "]");
-                return newSelector;
+                // if (element._frame) {
+                //   return element;
+                // }
+                const scope = element._frame ?? element.page();
+                let newElementSelector = "[data-blinq-id-" + randomToken + "]";
+                let prefixSelector = "";
+                const frameControlSelector = " >> internal:control=enter-frame";
+                const frameSelectorIndex = element._selector.lastIndexOf(frameControlSelector);
+                if (frameSelectorIndex !== -1) {
+                    // remove everything after the >> internal:control=enter-frame
+                    const frameSelector = element._selector.substring(0, frameSelectorIndex);
+                    prefixSelector = frameSelector + " >> internal:control=enter-frame >>";
+                }
+                // if (element?._frame?._selector) {
+                //   prefixSelector = element._frame._selector + " >> " + prefixSelector;
+                // }
+                const newSelector = prefixSelector + newElementSelector;
+                return scope.locator(newSelector);
             }
         }
         throw new Error("unable to locate element " + JSON.stringify(selectors));
@@ -725,14 +783,9 @@ class StableBrowser {
                 // info.log += "scanning locators in priority 2" + "\n";
                 result = await this._scanLocatorsGroup(locatorsByPriority["2"], scope, _params, info, visibleOnly, allowDisabled, selectors?.element_name);
             }
-            if (result.foundElements.length === 0 && onlyPriority3) {
+            if (result.foundElements.length === 0 && (onlyPriority3 || !highPriorityOnly)) {
                 result = await this._scanLocatorsGroup(locatorsByPriority["3"], scope, _params, info, visibleOnly, allowDisabled, selectors?.element_name);
             }
-            else {
-                if (result.foundElements.length === 0 && !highPriorityOnly) {
-                    result = await this._scanLocatorsGroup(locatorsByPriority["3"], scope, _params, info, visibleOnly, allowDisabled, selectors?.element_name);
-                }
-            }
             let foundElements = result.foundElements;
             if (foundElements.length === 1 && foundElements[0].unique) {
                 info.box = foundElements[0].box;
@@ -787,6 +840,11 @@ class StableBrowser {
                 visibleOnly = false;
             }
             await new Promise((resolve) => setTimeout(resolve, 1000));
+            // sheck of more of half of the timeout has passed
+            if (Date.now() - startTime > timeout / 2) {
+                highPriorityOnly = false;
+                visibleOnly = false;
+            }
         }
         this.logger.debug("unable to locate unique element, total elements found " + locatorsCount);
         // if (info.locatorLog) {
@@ -802,7 +860,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,
@@ -821,7 +879,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) {
@@ -833,9 +893,40 @@ class StableBrowser {
                 result.locatorIndex = i;
             }
             if (foundLocators.length > 1) {
-                info.failCause.foundMultiple = true;
-                if (info.locatorLog) {
-                    info.locatorLog.setLocatorSearchStatus(JSON.stringify(locatorsGroup[i]), "FOUND_NOT_UNIQUE");
+                // remove elements that consume the same space with 10 pixels tolerance
+                const boxes = [];
+                for (let j = 0; j < foundLocators.length; j++) {
+                    boxes.push({ box: await foundLocators[j].boundingBox(), locator: foundLocators[j] });
+                }
+                for (let j = 0; j < boxes.length; j++) {
+                    for (let k = 0; k < boxes.length; k++) {
+                        if (j === k) {
+                            continue;
+                        }
+                        // check if x, y, width, height are the same with 10 pixels tolerance
+                        if (Math.abs(boxes[j].box.x - boxes[k].box.x) < 10 &&
+                            Math.abs(boxes[j].box.y - boxes[k].box.y) < 10 &&
+                            Math.abs(boxes[j].box.width - boxes[k].box.width) < 10 &&
+                            Math.abs(boxes[j].box.height - boxes[k].box.height) < 10) {
+                            // as the element is not unique, will remove it
+                            boxes.splice(k, 1);
+                            k--;
+                        }
+                    }
+                }
+                if (boxes.length === 1) {
+                    result.foundElements.push({
+                        locator: boxes[0].locator.first(),
+                        box: boxes[0].box,
+                        unique: true,
+                    });
+                    result.locatorIndex = i;
+                }
+                else if (logErrors) {
+                    info.failCause.foundMultiple = true;
+                    if (info.locatorLog) {
+                        info.locatorLog.setLocatorSearchStatus(JSON.stringify(locatorsGroup[i]), "FOUND_NOT_UNIQUE");
+                    }
                 }
             }
         }
@@ -883,7 +974,7 @@ class StableBrowser {
                         await _commandError(state, "timeout looking for " + elementDescription, this);
                     }
                     finally {
-                        _commandFinally(state, this);
+                        await _commandFinally(state, this);
                     }
                 }
             }
@@ -932,7 +1023,7 @@ class StableBrowser {
                         await _commandError(state, "timeout looking for " + elementDescription, this);
                     }
                     finally {
-                        _commandFinally(state, this);
+                        await _commandFinally(state, this);
                     }
                 }
             }
@@ -961,7 +1052,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async waitForElement(selectors, _params, options = {}, world = null) {
@@ -992,7 +1083,7 @@ class StableBrowser {
             // await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
         return found;
     }
@@ -1016,8 +1107,8 @@ class StableBrowser {
             try {
                 // if (world && world.screenshot && !world.screenshotPath) {
                 // console.log(`Highlighting while running from recorder`);
-                await this._highlightElements(element);
-                await state.element.setChecked(checked);
+                await this._highlightElements(state.element);
+                await state.element.setChecked(checked, { timeout: 2000 });
                 await new Promise((resolve) => setTimeout(resolve, 1000));
                 // await this._unHighlightElements(element);
                 // }
@@ -1029,11 +1120,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();
@@ -1043,7 +1151,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async hover(selectors, _params, options = {}, world = null) {
@@ -1069,7 +1177,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) {
@@ -1105,7 +1213,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async type(_value, _params = null, options = {}, world = null) {
@@ -1151,7 +1259,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) {
@@ -1187,7 +1295,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) {
@@ -1256,7 +1364,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) {
@@ -1275,6 +1383,9 @@ class StableBrowser {
             operation: "clickType",
             log: "***** clickType on " + selectors.element_name + " with value " + maskValue(_value) + "*****\n",
         };
+        if (!options) {
+            options = {};
+        }
         if (newValue !== _value) {
             //this.logger.info(_value + "=" + newValue);
             _value = newValue;
@@ -1282,7 +1393,7 @@ class StableBrowser {
         try {
             await _preCommand(state, this);
             state.info.value = _value;
-            if (options === null || options === undefined || !options.press) {
+            if (!options.press) {
                 try {
                     let currentValue = await state.element.inputValue();
                     if (currentValue) {
@@ -1293,10 +1404,7 @@ class StableBrowser {
                     this.logger.info("unable to clear input value");
                 }
             }
-            if (options === null || options === undefined || options.press) {
-                if (!options) {
-                    options = {};
-                }
+            if (options.press) {
                 options.timeout = 5000;
                 await performAction("click", state.element, options, this, state, _params);
             }
@@ -1356,7 +1464,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) {
@@ -1386,7 +1494,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) {
@@ -1502,7 +1645,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) {
@@ -1537,7 +1680,7 @@ class StableBrowser {
             while (Date.now() - startTime < timeout) {
                 try {
                     await _preCommand(state, this);
-                    foundObj = await this._getText(selectors, climb, _params, { timeout: 2000 }, state.info, world);
+                    foundObj = await this._getText(selectors, climb, _params, { timeout: 3000 }, state.info, world);
                     if (foundObj && foundObj.element) {
                         await this.scrollIfNeeded(foundObj.element, state.info);
                     }
@@ -1579,7 +1722,79 @@ 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
+                    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) {
@@ -1617,6 +1832,15 @@ class StableBrowser {
         // save the data to the file
         fs.writeFileSync(dataFile, JSON.stringify(data, null, 2));
     }
+    overwriteTestData(testData, world = null) {
+        if (!testData) {
+            return;
+        }
+        // if data file exists, load it
+        const dataFile = _getDataFile(world, this.context, this);
+        // save the data to the file
+        fs.writeFileSync(dataFile, JSON.stringify(testData, null, 2));
+    }
     _getDataFilePath(fileName) {
         let dataFile = path.join(this.project_path, "data", fileName);
         if (fs.existsSync(dataFile)) {
@@ -1869,7 +2093,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) {
@@ -1900,10 +2124,31 @@ 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);
@@ -1914,7 +2159,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) {
@@ -1939,12 +2184,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;
@@ -1966,17 +2214,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;
         }
@@ -1984,7 +2257,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async extractEmailData(emailAddress, options, world) {
@@ -2144,56 +2417,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;
@@ -2207,74 +2473,235 @@ 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);
         }
     }
-    async findTextInAllFrames(dateAlternatives, numberAlternatives, text, state) {
+    /**
+     * 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) {
+        let error = null;
+        let screenshotId = null;
+        let screenshotPath = null;
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const newValue = await this._replaceWithLocalData(title, world);
+        if (newValue !== title) {
+            this.logger.info(title + "=" + newValue);
+            title = newValue;
+        }
+        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();
+                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;
+                        }
+                }
+                await _screenshot(state, this);
+                return state.info;
+            }
+        }
+        catch (e) {
+            state.info.failCause.lastError = e.message;
+            state.info.failCause.assertionFailed = true;
+            await _commandError(state, e, this);
+        }
+        finally {
+            await _commandFinally(state, this);
+        }
+    }
+    async findTextInAllFrames(dateAlternatives, numberAlternatives, text, state, partial = true, ignoreCase = false) {
         const frames = this.page.frames();
         let results = [];
-        let ignoreCase = false;
+        // let ignoreCase = false;
         for (let i = 0; i < frames.length; i++) {
             if (dateAlternatives.date) {
                 for (let j = 0; j < dateAlternatives.dates.length; j++) {
-                    const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*:not(script, style, head)", false, true, ignoreCase, {});
+                    const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*:not(script, style, head)", false, partial, ignoreCase, {});
                     result.frame = frames[i];
                     results.push(result);
                 }
             }
             else if (numberAlternatives.number) {
                 for (let j = 0; j < numberAlternatives.numbers.length; j++) {
-                    const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*:not(script, style, head)", false, true, ignoreCase, {});
+                    const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*:not(script, style, head)", false, partial, ignoreCase, {});
                     result.frame = frames[i];
                     results.push(result);
                 }
             }
             else {
-                const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", false, true, ignoreCase, {});
+                const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", false, partial, ignoreCase, {});
                 result.frame = frames[i];
                 results.push(result);
             }
@@ -2293,7 +2720,7 @@ class StableBrowser {
             scroll: false,
             highlight: false,
             type: Types.VERIFY_PAGE_CONTAINS_TEXT,
-            text: `Verify 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",
@@ -2335,27 +2762,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);
@@ -2365,13 +2775,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) {
@@ -2384,7 +2793,7 @@ class StableBrowser {
             scroll: false,
             highlight: false,
             type: Types.WAIT_FOR_TEXT_TO_DISAPPEAR,
-            text: `Verify 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",
@@ -2428,7 +2837,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async verifyTextRelatedToText(textAnchor, climb, textToVerify, options = {}, world = null) {
@@ -2470,7 +2879,7 @@ class StableBrowser {
             };
             while (true) {
                 try {
-                    resultWithElementsFound = await this.findTextInAllFrames(dateAlternatives, numberAlternatives, textAnchor, state);
+                    resultWithElementsFound = await this.findTextInAllFrames(findDateAlternatives(textAnchor), findNumberAlternatives(textAnchor), textAnchor, state, false);
                 }
                 catch (error) {
                     // ignore
@@ -2498,7 +2907,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, "*", false, true, 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);
@@ -2539,9 +2948,33 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
+    async findRelatedTextInAllFrames(textAnchor, climb, textToVerify, params = {}, options = {}, world = null) {
+        const frames = this.page.frames();
+        let results = [];
+        let ignoreCase = false;
+        for (let i = 0; i < frames.length; i++) {
+            const result = await this._locateElementByText(frames[i], textAnchor, "*:not(script, style, head)", false, true, ignoreCase, {});
+            result.frame = frames[i];
+            const climbArray = [];
+            for (let i = 0; i < climb; i++) {
+                climbArray.push("..");
+            }
+            let climbXpath = "xpath=" + climbArray.join("/");
+            const newLocator = `[data-blinq-id-${result.randomToken}] ${climb > 0 ? ">> " + climbXpath : ""} >> internal:text=${testForRegex(textToVerify) ? textToVerify : unEscapeString(textToVerify)}`;
+            const count = await frames[i].locator(newLocator).count();
+            if (count > 0) {
+                result.elementCount = count;
+                result.locator = newLocator;
+                results.push(result);
+            }
+        }
+        // state.info.results = results;
+        const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+        return resultWithElementsFound;
+    }
     async visualVerification(text, options = {}, world = null) {
         const startTime = Date.now();
         let error = null;
@@ -2858,7 +3291,13 @@ class StableBrowser {
         }
     }
     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;
@@ -2881,6 +3320,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
@@ -2891,10 +3331,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);
@@ -2977,7 +3421,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     async tableCellOperation(headerText, rowText, options, _params, world = null) {
@@ -3064,7 +3508,7 @@ class StableBrowser {
             await _commandError(state, e, this);
         }
         finally {
-            _commandFinally(state, this);
+            await _commandFinally(state, this);
         }
     }
     saveTestDataAsGlobal(options, world) {
@@ -3169,7 +3613,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);
+        }
+        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;
         }
@@ -3186,21 +3662,11 @@ 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) {
@@ -3225,18 +3691,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) {
@@ -3244,6 +3760,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) {
@@ -3256,6 +3779,29 @@ class StableBrowser {
                 await world.attach(JSON.stringify(snapshot), "application/json+snapshot-after");
             }
         }
+        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) {