automation_model 1.0.478-dev → 1.0.478-stage

package/lib/stable_browser.js

@@ -10,15 +10,17 @@ import { getDateTimeValue } from "./date_time.js";
 import drawRectangle from "./drawRect.js";
 //import { closeUnexpectedPopups } from "./popups.js";
 import { getTableCells, getTableData } from "./table_analyze.js";
-import objectPath from "object-path";
-import { decrypt } from "./utils.js";
+import { maskValue, replaceWithLocalTestData } from "./utils.js";
 import csv from "csv-parser";
 import { Readable } from "node:stream";
 import readline from "readline";
 import { getContext } from "./init_browser.js";
 import { locate_element } from "./locate_element.js";
-import { _commandError, _commandFinally, _preCommand, _validateSelectors, _screenshot } from "./command_common.js";
-const Types = {
+import { randomUUID } from "crypto";
+import { _commandError, _commandFinally, _preCommand, _validateSelectors, _screenshot, _reportToWorld, } from "./command_common.js";
+import { registerDownloadEvent, registerNetworkEvents } from "./network.js";
+import { LocatorLog } from "./locator_log.js";
+export const Types = {
     CLICK: "click_element",
     NAVIGATE: "navigate",
     FILL: "fill_element",
@@ -44,20 +46,28 @@ const Types = {
     VERIFY_VISUAL: "verify_visual",
     LOAD_DATA: "load_data",
     SET_INPUT: "set_input",
+    WAIT_FOR_TEXT_TO_DISAPPEAR: "wait_for_text_to_disappear",
+    VERIFY_ATTRIBUTE: "verify_element_attribute",
 };
 export const apps = {};
 class StableBrowser {
+    browser;
+    page;
+    logger;
+    context;
+    world;
+    project_path = null;
+    webLogFile = null;
+    networkLogger = null;
+    configuration = null;
+    appName = "main";
+    tags = null;
     constructor(browser, page, logger = null, context = null, world = null) {
         this.browser = browser;
         this.page = page;
         this.logger = logger;
         this.context = context;
         this.world = world;
-        this.project_path = null;
-        this.webLogFile = null;
-        this.networkLogger = null;
-        this.configuration = null;
-        this.appName = "main";
         if (!this.logger) {
             this.logger = console;
         }
@@ -82,23 +92,50 @@ class StableBrowser {
         catch (e) {
             this.logger.error("unable to read ai_config.json");
         }
-        context.pageLoading = { status: false };
-        context.pages = [this.page];
         const logFolder = path.join(this.project_path, "logs", "web");
         this.world = world;
+        context.pages = [this.page];
+        context.pageLoading = { status: false };
         this.registerEventListeners(this.context);
+        registerNetworkEvents(this.world, this, this.context, this.page);
+        registerDownloadEvent(this.page, this.world, this.context);
+    }
+    async scrollPageToLoadLazyElements() {
+        let lastHeight = await this.page.evaluate(() => document.body.scrollHeight);
+        let retry = 0;
+        while (true) {
+            await this.page.evaluate(() => window.scrollBy(0, window.innerHeight));
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+            let newHeight = await this.page.evaluate(() => document.body.scrollHeight);
+            if (newHeight === lastHeight) {
+                break;
+            }
+            lastHeight = newHeight;
+            retry++;
+            if (retry > 10) {
+                break;
+            }
+        }
+        await this.page.evaluate(() => window.scrollTo(0, 0));
     }
     registerEventListeners(context) {
         this.registerConsoleLogListener(this.page, context);
-        this.registerRequestListener(this.page, context, this.webLogFile);
+        // this.registerRequestListener(this.page, context, this.webLogFile);
         if (!context.pageLoading) {
             context.pageLoading = { status: false };
         }
         context.playContext.on("page", async function (page) {
+            if (this.configuration && this.configuration.closePopups === true) {
+                console.log("close unexpected popups");
+                await page.close();
+                return;
+            }
             context.pageLoading.status = true;
             this.page = page;
             context.page = page;
             context.pages.push(page);
+            registerNetworkEvents(this.world, this, context, this.page);
+            registerDownloadEvent(this.page, this.world, context);
             page.on("close", async () => {
                 if (this.context && this.context.pages && this.context.pages.length > 1) {
                     this.context.pages.pop();
@@ -128,9 +165,9 @@ class StableBrowser {
         if (this.appName === appName) {
             return;
         }
-        let newContextCreated = false;
+        let navigate = false;
         if (!apps[appName]) {
-            let newContext = await getContext(null, this.context.headless ? this.context.headless : false, this, this.logger, appName, false, this);
+            let newContext = await getContext(null, this.context.headless ? this.context.headless : false, this, this.logger, appName, false, this, -1, this.context.reportFolder);
             newContextCreated = true;
             apps[appName] = {
                 context: newContext,
@@ -143,8 +180,7 @@ class StableBrowser {
         this._copyContext(apps[appName], this);
         apps[this.appName] = tempContext;
         this.appName = appName;
-        if (newContextCreated) {
-            this.registerEventListeners(this.context);
+        if (navigate) {
             await this.goto(this.context.environment.baseUrl);
             await this.waitForPageLoad();
         }
@@ -170,7 +206,6 @@ class StableBrowser {
             this.context.webLogger = [];
         }
         page.on("console", async (msg) => {
-            var _a;
             const obj = {
                 type: msg.type(),
                 text: msg.text(),
@@ -179,7 +214,7 @@ class StableBrowser {
             };
             this.context.webLogger.push(obj);
             if (msg.type() === "error") {
-                (_a = this.world) === null || _a === void 0 ? void 0 : _a.attach(JSON.stringify(obj), { mediaType: "application/json+log" });
+                this.world?.attach(JSON.stringify(obj), { mediaType: "application/json+log" });
             }
         });
     }
@@ -188,7 +223,6 @@ class StableBrowser {
             this.context.networkLogger = [];
         }
         page.on("request", async (data) => {
-            var _a;
             const startTime = new Date().getTime();
             try {
                 const pageUrl = new URL(page.url());
@@ -213,10 +247,10 @@ class StableBrowser {
                     startTime,
                 };
                 context.networkLogger.push(obj);
-                (_a = this.world) === null || _a === void 0 ? void 0 : _a.attach(JSON.stringify(obj), { mediaType: "application/json+network" });
+                this.world?.attach(JSON.stringify(obj), { mediaType: "application/json+network" });
             }
             catch (error) {
-                console.error("Error in request listener", error);
+                // console.error("Error in request listener", error);
                 context.networkLogger.push({
                     error: "not able to listen",
                     message: error.message,
@@ -305,7 +339,7 @@ class StableBrowser {
                 locatorReturn = scope.getByRole(role, { name }, { exact: flags === "i" });
             }
         }
-        if (locator === null || locator === void 0 ? void 0 : locator.engine) {
+        if (locator?.engine) {
             if (locator.engine === "css") {
                 locatorReturn = scope.locator(locator.selector);
             }
@@ -329,7 +363,7 @@ class StableBrowser {
         if (css && css.locator) {
             css = css.locator;
         }
-        let result = await this._locateElementByText(scope, this._fixUsingParams(text, _params), "*", false, false, _params);
+        let result = await this._locateElementByText(scope, this._fixUsingParams(text, _params), "*:not(script, style, head)", false, false, _params);
         if (result.elementCount === 0) {
             return;
         }
@@ -381,7 +415,7 @@ class StableBrowser {
             }
             document.collectAllShadowDomElements = collectAllShadowDomElements;
             if (!tag) {
-                tag = "*";
+                tag = "*:not(script, style, head)";
             }
             let regexpSearch = document.getRegex(text);
             if (regexpSearch) {
@@ -463,9 +497,21 @@ class StableBrowser {
         }, [text1, tag1, regex1, partial1]);
     }
     async _collectLocatorInformation(selectorHierarchy, index = 0, scope, foundLocators, _params, info, visibleOnly = true) {
+        if (!info) {
+            info = {};
+        }
+        if (!info.failCause) {
+            info.failCause = {};
+        }
+        if (!info.log) {
+            info.log = "";
+            info.locatorLog = new LocatorLog(selectorHierarchy);
+        }
         let locatorSearch = selectorHierarchy[index];
+        let originalLocatorSearch = "";
         try {
-            locatorSearch = JSON.parse(this._fixUsingParams(JSON.stringify(locatorSearch), _params));
+            originalLocatorSearch = this._fixUsingParams(JSON.stringify(locatorSearch), _params);
+            locatorSearch = JSON.parse(originalLocatorSearch);
         }
         catch (e) {
             console.error(e);
@@ -475,13 +521,18 @@ class StableBrowser {
         if (locatorSearch.climb && locatorSearch.climb >= 0) {
             let locatorString = await this._locateElmentByTextClimbCss(scope, locatorSearch.text, locatorSearch.climb, locatorSearch.css, _params);
             if (!locatorString) {
+                info.failCause.textNotFound = true;
+                info.failCause.lastError = "failed to locate element by text: " + locatorSearch.text;
                 return;
             }
             locator = this._getLocator({ css: locatorString }, scope, _params);
         }
         else if (locatorSearch.text) {
-            let result = await this._locateElementByText(scope, this._fixUsingParams(locatorSearch.text, _params), locatorSearch.tag, false, locatorSearch.partial === true, _params);
+            let text = this._fixUsingParams(locatorSearch.text, _params);
+            let result = await this._locateElementByText(scope, text, locatorSearch.tag, false, locatorSearch.partial === true, _params);
             if (result.elementCount === 0) {
+                info.failCause.textNotFound = true;
+                info.failCause.lastError = "failed to locate element by text: " + text;
                 return;
             }
             locatorSearch.css = "[data-blinq-id='blinq-id-" + result.randomToken + "']";
@@ -498,13 +549,22 @@ class StableBrowser {
         //   cssHref = true;
         // }
         let count = await locator.count();
+        if (count > 0 && !info.failCause.count) {
+            info.failCause.count = count;
+        }
         //info.log += "total elements found " + count + "\n";
         //let visibleCount = 0;
         let visibleLocator = null;
-        if (locatorSearch.index && locatorSearch.index < count) {
+        if (typeof locatorSearch.index === "number" && locatorSearch.index < count) {
             foundLocators.push(locator.nth(locatorSearch.index));
+            if (info.locatorLog) {
+                info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
+            }
             return;
         }
+        if (info.locatorLog && count === 0) {
+            info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "NOT_FOUND");
+        }
         for (let j = 0; j < count; j++) {
             let visible = await locator.nth(j).isVisible();
             const enabled = await locator.nth(j).isEnabled();
@@ -513,24 +573,40 @@ class StableBrowser {
             }
             if (visible && enabled) {
                 foundLocators.push(locator.nth(j));
+                if (info.locatorLog) {
+                    info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND");
+                }
             }
             else {
+                info.failCause.visible = visible;
+                info.failCause.enabled = enabled;
                 if (!info.printMessages) {
                     info.printMessages = {};
                 }
+                if (info.locatorLog && !visible) {
+                    info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND_NOT_VISIBLE");
+                }
+                if (info.locatorLog && !enabled) {
+                    info.locatorLog.setLocatorSearchStatus(originalLocatorSearch, "FOUND_NOT_ENABLED");
+                }
                 if (!info.printMessages[j.toString()]) {
-                    info.log += "element " + locator + " visible " + visible + " enabled " + enabled + "\n";
+                    //info.log += "element " + locator + " visible " + visible + " enabled " + enabled + "\n";
                     info.printMessages[j.toString()] = true;
                 }
             }
         }
     }
     async closeUnexpectedPopups(info, _params) {
+        if (!info) {
+            info = {};
+            info.failCause = {};
+            info.log = "";
+        }
         if (this.configuration.popupHandlers && this.configuration.popupHandlers.length > 0) {
             if (!info) {
                 info = {};
             }
-            info.log += "scan for popup handlers" + "\n";
+            //info.log += "scan for popup handlers" + "\n";
             const handlerGroup = [];
             for (let i = 0; i < this.configuration.popupHandlers.length; i++) {
                 handlerGroup.push(this.configuration.popupHandlers[i].locator);
@@ -557,9 +633,21 @@ class StableBrowser {
                 }
                 if (result.foundElements.length > 0) {
                     let dialogCloseLocator = result.foundElements[0].locator;
-                    await dialogCloseLocator.click();
-                    // wait for the dialog to close
-                    await dialogCloseLocator.waitFor({ state: "hidden" });
+                    try {
+                        await scope?.evaluate(() => {
+                            window.__isClosingPopups = true;
+                        });
+                        await dialogCloseLocator.click();
+                        // wait for the dialog to close
+                        await dialogCloseLocator.waitFor({ state: "hidden" });
+                    }
+                    catch (e) {
+                    }
+                    finally {
+                        await scope?.evaluate(() => {
+                            window.__isClosingPopups = false;
+                        });
+                    }
                     return { rerun: true };
                 }
             }
@@ -583,7 +671,13 @@ class StableBrowser {
         }
         throw new Error("unable to locate element " + JSON.stringify(selectors));
     }
-    async _findFrameScope(selectors, timeout = 30000) {
+    async _findFrameScope(selectors, timeout = 30000, info) {
+        if (!info) {
+            info = {};
+            info.failCause = {};
+            info.log = "";
+        }
+        let startTime = Date.now();
         let scope = this.page;
         if (selectors.frame) {
             return selectors.frame;
@@ -614,9 +708,11 @@ class StableBrowser {
                 }
                 return framescope;
             };
+            let fLocator = null;
             while (true) {
                 let frameFound = false;
                 if (selectors.nestFrmLoc) {
+                    fLocator = selectors.nestFrmLoc;
                     scope = await findFrame(selectors.nestFrmLoc, scope);
                     frameFound = true;
                     break;
@@ -625,6 +721,7 @@ class StableBrowser {
                     for (let i = 0; i < selectors.frameLocators.length; i++) {
                         let frameLocator = selectors.frameLocators[i];
                         if (frameLocator.css) {
+                            fLocator = frameLocator.css;
                             scope = scope.frameLocator(frameLocator.css);
                             frameFound = true;
                             break;
@@ -632,16 +729,25 @@ class StableBrowser {
                     }
                 }
                 if (!frameFound && selectors.iframe_src) {
+                    fLocator = selectors.iframe_src;
                     scope = this.page.frame({ url: selectors.iframe_src });
                 }
                 if (!scope) {
-                    info.log += "unable to locate iframe " + selectors.iframe_src + "\n";
-                    if (performance.now() - startTime > timeout) {
+                    if (info && info.locatorLog) {
+                        info.locatorLog.setFrameSearchStatus("frame-" + fLocator, "NOT_FOUND");
+                    }
+                    //info.log += "unable to locate iframe " + selectors.iframe_src + "\n";
+                    if (Date.now() - startTime > timeout) {
+                        info.failCause.iframeNotFound = true;
+                        info.failCause.lastError = "unable to locate iframe " + selectors.iframe_src;
                         throw new Error("unable to locate iframe " + selectors.iframe_src);
                     }
                     await new Promise((resolve) => setTimeout(resolve, 1000));
                 }
                 else {
+                    if (info && info.locatorLog) {
+                        info.locatorLog.setFrameSearchStatus("frame-" + fLocator, "FOUND");
+                    }
                     break;
                 }
             }
@@ -651,20 +757,27 @@ class StableBrowser {
         }
         return scope;
     }
-    async _getDocumentBody(selectors, timeout = 30000) {
-        let scope = await this._findFrameScope(selectors, timeout);
+    async _getDocumentBody(selectors, timeout = 30000, info) {
+        let scope = await this._findFrameScope(selectors, timeout, info);
         return scope.evaluate(() => {
             var bodyContent = document.body.innerHTML;
             return bodyContent;
         });
     }
     async _locate_internal(selectors, info, _params, timeout = 30000) {
+        if (!info) {
+            info = {};
+            info.failCause = {};
+            info.log = "";
+            info.locatorLog = new LocatorLog(selectors);
+        }
         let highPriorityTimeout = 5000;
         let visibleOnlyTimeout = 6000;
-        let startTime = performance.now();
+        let startTime = Date.now();
         let locatorsCount = 0;
+        let lazy_scroll = false;
         //let arrayMode = Array.isArray(selectors);
-        let scope = await this._findFrameScope(selectors, timeout);
+        let scope = await this._findFrameScope(selectors, timeout, info);
         let selectorsLocators = null;
         selectorsLocators = selectors.locators;
         // group selectors by priority
@@ -751,21 +864,33 @@ class StableBrowser {
                     return maxCountElement.locator;
                 }
             }
-            if (performance.now() - startTime > timeout) {
+            if (Date.now() - startTime > timeout) {
                 break;
             }
-            if (performance.now() - startTime > highPriorityTimeout) {
+            if (Date.now() - startTime > highPriorityTimeout) {
                 info.log += "high priority timeout, will try all elements" + "\n";
                 highPriorityOnly = false;
+                if (this.configuration && this.configuration.load_all_lazy === true && !lazy_scroll) {
+                    lazy_scroll = true;
+                    await this.scrollPageToLoadLazyElements();
+                }
             }
-            if (performance.now() - startTime > visibleOnlyTimeout) {
+            if (Date.now() - startTime > visibleOnlyTimeout) {
                 info.log += "visible only timeout, will try all elements" + "\n";
                 visibleOnly = false;
             }
             await new Promise((resolve) => setTimeout(resolve, 1000));
         }
         this.logger.debug("unable to locate unique element, total elements found " + locatorsCount);
-        info.log += "failed to locate unique element, total elements found " + locatorsCount + "\n";
+        // if (info.locatorLog) {
+        //   const lines = info.locatorLog.toString().split("\n");
+        //   for (let line of lines) {
+        //     this.logger.debug(line);
+        //   }
+        // }
+        //info.log += "failed to locate unique element, total elements found " + locatorsCount + "\n";
+        info.failCause.locatorNotFound = true;
+        info.failCause.lastError = "failed to locate unique element";
         throw new Error("failed to locate first element no elements found, " + info.log);
     }
     async _scanLocatorsGroup(locatorsGroup, scope, _params, info, visibleOnly) {
@@ -797,10 +922,29 @@ class StableBrowser {
                 });
                 result.locatorIndex = i;
             }
+            if (foundLocators.length > 1) {
+                info.failCause.foundMultiple = true;
+                if (info.locatorLog) {
+                    info.locatorLog.setLocatorSearchStatus(locatorsGroup[i], "FOUND_NOT_UNIQUE");
+                }
+            }
         }
         return result;
     }
     async simpleClick(elementDescription, _params, options = {}, world = null) {
+        const state = {
+            locate: false,
+            scroll: false,
+            highlight: false,
+            _params,
+            options,
+            world,
+            type: Types.CLICK,
+            text: "Click element",
+            operation: "simpleClick",
+            log: "***** click on " + elementDescription + " *****\n",
+        };
+        _preCommand(state, this);
         const startTime = Date.now();
         let timeout = 30000;
         if (options && options.timeout) {
@@ -809,12 +953,12 @@ class StableBrowser {
         while (true) {
             try {
                 const result = await locate_element(this.context, elementDescription, "click");
-                if ((result === null || result === void 0 ? void 0 : result.elementNumber) >= 0) {
+                if (result?.elementNumber >= 0) {
                     const selectors = {
-                        frame: result === null || result === void 0 ? void 0 : result.frame,
+                        frame: result?.frame,
                         locators: [
                             {
-                                css: result === null || result === void 0 ? void 0 : result.css,
+                                css: result?.css,
                             },
                         ],
                     };
@@ -824,13 +968,32 @@ class StableBrowser {
             }
             catch (e) {
                 if (performance.now() - startTime > timeout) {
-                    throw e;
+                    // throw e;
+                    try {
+                        await _commandError(state, "timeout looking for " + elementDescription, this);
+                    }
+                    finally {
+                        _commandFinally(state, this);
+                    }
                 }
             }
             await new Promise((resolve) => setTimeout(resolve, 3000));
         }
     }
     async simpleClickType(elementDescription, value, _params, options = {}, world = null) {
+        const state = {
+            locate: false,
+            scroll: false,
+            highlight: false,
+            _params,
+            options,
+            world,
+            type: Types.FILL,
+            text: "Fill element",
+            operation: "simpleClickType",
+            log: "***** click type on " + elementDescription + " *****\n",
+        };
+        _preCommand(state, this);
         const startTime = Date.now();
         let timeout = 30000;
         if (options && options.timeout) {
@@ -839,12 +1002,12 @@ class StableBrowser {
         while (true) {
             try {
                 const result = await locate_element(this.context, elementDescription, "fill", value);
-                if ((result === null || result === void 0 ? void 0 : result.elementNumber) >= 0) {
+                if (result?.elementNumber >= 0) {
                     const selectors = {
-                        frame: result === null || result === void 0 ? void 0 : result.frame,
+                        frame: result?.frame,
                         locators: [
                             {
-                                css: result === null || result === void 0 ? void 0 : result.css,
+                                css: result?.css,
                             },
                         ],
                     };
@@ -854,7 +1017,13 @@ class StableBrowser {
             }
             catch (e) {
                 if (performance.now() - startTime > timeout) {
-                    throw e;
+                    // throw e;
+                    try {
+                        await _commandError(state, "timeout looking for " + elementDescription, this);
+                    }
+                    finally {
+                        _commandFinally(state, this);
+                    }
                 }
             }
             await new Promise((resolve) => setTimeout(resolve, 3000));
@@ -878,13 +1047,13 @@ class StableBrowser {
             }
             try {
                 await state.element.click();
-                await new Promise((resolve) => setTimeout(resolve, 1000));
+                // await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             catch (e) {
                 // await this.closeUnexpectedPopups();
                 state.element = await this._locate(selectors, state.info, _params);
                 await state.element.dispatchEvent("click");
-                await new Promise((resolve) => setTimeout(resolve, 1000));
+                // await new Promise((resolve) => setTimeout(resolve, 1000));
             }
             await this.waitForPageLoad();
             return state.info;
@@ -982,6 +1151,7 @@ class StableBrowser {
             _params,
             options,
             world,
+            value: values.toString(),
             type: Types.SELECT,
             text: `Select option: ${values}`,
             operation: "selectOption",
@@ -1089,33 +1259,30 @@ class StableBrowser {
         }
     }
     async setDateTime(selectors, value, format = null, enter = false, _params = null, options = {}, world = null) {
-        _validateSelectors(selectors);
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
-        info.log = "";
-        info.operation = Types.SET_DATE_TIME;
-        info.selectors = selectors;
-        info.value = value;
+        const state = {
+            selectors,
+            _params,
+            value: await this._replaceWithLocalData(value, this),
+            options,
+            world,
+            type: Types.SET_DATE_TIME,
+            text: `Set date time value: ${value}`,
+            operation: "setDateTime",
+            log: "***** set date time value " + selectors.element_name + " *****\n",
+            throwError: false,
+        };
         try {
-            value = await this._replaceWithLocalData(value, this);
-            let element = await this._locate(selectors, info, _params);
-            //insert red border around the element
-            await this.scrollIfNeeded(element, info);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-            await this._highlightElements(element);
+            await _preCommand(state, this);
             try {
-                await element.click();
+                await state.element.click();
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 if (format) {
-                    value = dayjs(value).format(format);
-                    await element.fill(value);
+                    state.value = dayjs(state.value).format(format);
+                    await state.element.fill(state.value);
                 }
                 else {
-                    const dateTimeValue = await getDateTimeValue({ value, element });
-                    await element.evaluateHandle((el, dateTimeValue) => {
+                    const dateTimeValue = await getDateTimeValue({ value: state.value, element: state.element });
+                    await state.element.evaluateHandle((el, dateTimeValue) => {
                         el.value = ""; // clear input
                         el.value = dateTimeValue;
                     }, dateTimeValue);
@@ -1128,20 +1295,19 @@ class StableBrowser {
             }
             catch (err) {
                 //await this.closeUnexpectedPopups();
-                this.logger.error("setting date time input failed " + JSON.stringify(info));
+                this.logger.error("setting date time input failed " + JSON.stringify(state.info));
                 this.logger.info("Trying again");
-                ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-                info.screenshotPath = screenshotPath;
-                Object.assign(err, { info: info });
+                await _screenshot(state, this);
+                Object.assign(err, { info: state.info });
                 await element.click();
                 await new Promise((resolve) => setTimeout(resolve, 500));
                 if (format) {
-                    value = dayjs(value).format(format);
-                    await element.fill(value);
+                    state.value = dayjs(state.value).format(format);
+                    await state.element.fill(state.value);
                 }
                 else {
-                    const dateTimeValue = await getDateTimeValue({ value, element });
-                    await element.evaluateHandle((el, dateTimeValue) => {
+                    const dateTimeValue = await getDateTimeValue({ value: state.value, element: state.element });
+                    await state.element.evaluateHandle((el, dateTimeValue) => {
                         el.value = ""; // clear input
                         el.value = dateTimeValue;
                     }, dateTimeValue);
@@ -1154,46 +1320,27 @@ class StableBrowser {
             }
         }
         catch (e) {
-            error = e;
-            throw e;
+            await _commandError(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.SET_DATE_TIME,
-                screenshotId,
-                value: value,
-                text: `setDateTime input with value: ${value}`,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async clickType(selectors, _value, enter = false, _params = null, options = {}, world = null) {
+        _value = unEscapeString(_value);
+        const newValue = await this._replaceWithLocalData(_value, world);
         const state = {
             selectors,
             _params,
-            value: unEscapeString(_value),
+            value: newValue,
+            originalValue: _value,
             options,
             world,
             type: Types.FILL,
             text: `Click type input with value: ${_value}`,
             operation: "clickType",
-            log: "***** clickType on " + selectors.element_name + " with value " + _value + "*****\n",
+            log: "***** clickType on " + selectors.element_name + " with value " + maskValue(_value) + "*****\n",
         };
-        const newValue = await this._replaceWithLocalData(state.value, world);
         if (newValue !== _value) {
             //this.logger.info(_value + "=" + newValue);
             _value = newValue;
@@ -1205,7 +1352,7 @@ class StableBrowser {
                 try {
                     let currentValue = await state.element.inputValue();
                     if (currentValue) {
-                        await element.fill("");
+                        await state.element.fill("");
                     }
                 }
                 catch (e) {
@@ -1313,6 +1460,7 @@ class StableBrowser {
         let screenshotPath = null;
         if (!info.log) {
             info.log = "";
+            info.locatorLog = new LocatorLog(selectors);
         }
         info.operation = "getText";
         info.selectors = selectors;
@@ -1352,7 +1500,6 @@ class StableBrowser {
         }
     }
     async containsPattern(selectors, pattern, text, _params = null, options = {}, world = null) {
-        var _a;
         if (!pattern) {
             throw new Error("pattern is null");
         }
@@ -1363,7 +1510,7 @@ class StableBrowser {
             selectors,
             _params,
             pattern,
-            value: text,
+            value: pattern,
             options,
             world,
             locate: false,
@@ -1392,14 +1539,14 @@ class StableBrowser {
             let escapedText = text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
             pattern = pattern.replace("{text}", escapedText);
             let regex = new RegExp(pattern, "im");
-            if (!regex.test(foundObj === null || foundObj === void 0 ? void 0 : foundObj.text) && !((_a = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _a === void 0 ? void 0 : _a.includes(text))) {
-                state.info.foundText = foundObj === null || foundObj === void 0 ? void 0 : foundObj.text;
+            if (!regex.test(foundObj?.text) && !foundObj?.value?.includes(text)) {
+                state.info.foundText = foundObj?.text;
                 throw new Error("element doesn't contain text " + text);
             }
             return state.info;
         }
         catch (e) {
-            this.logger.error("found text " + (foundObj === null || foundObj === void 0 ? void 0 : foundObj.text) + " pattern " + pattern);
+            this.logger.error("found text " + foundObj?.text + " pattern " + pattern);
             await _commandError(state, e, this);
         }
         finally {
@@ -1407,7 +1554,6 @@ class StableBrowser {
         }
     }
     async containsText(selectors, text, climb, _params = null, options = {}, world = null) {
-        var _a, _b, _c;
         const state = {
             selectors,
             _params,
@@ -1444,8 +1590,8 @@ class StableBrowser {
             const numberAlternatives = findNumberAlternatives(text);
             if (dateAlternatives.date) {
                 for (let i = 0; i < dateAlternatives.dates.length; i++) {
-                    if ((foundObj === null || foundObj === void 0 ? void 0 : foundObj.text.includes(dateAlternatives.dates[i])) ||
-                        ((_a = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _a === void 0 ? void 0 : _a.includes(dateAlternatives.dates[i]))) {
+                    if (foundObj?.text.includes(dateAlternatives.dates[i]) ||
+                        foundObj?.value?.includes(dateAlternatives.dates[i])) {
                         return state.info;
                     }
                 }
@@ -1453,16 +1599,16 @@ class StableBrowser {
             }
             else if (numberAlternatives.number) {
                 for (let i = 0; i < numberAlternatives.numbers.length; i++) {
-                    if ((foundObj === null || foundObj === void 0 ? void 0 : foundObj.text.includes(numberAlternatives.numbers[i])) ||
-                        ((_b = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _b === void 0 ? void 0 : _b.includes(numberAlternatives.numbers[i]))) {
+                    if (foundObj?.text.includes(numberAlternatives.numbers[i]) ||
+                        foundObj?.value?.includes(numberAlternatives.numbers[i])) {
                         return state.info;
                     }
                 }
                 throw new Error("element doesn't contain text " + text);
             }
-            else if (!(foundObj === null || foundObj === void 0 ? void 0 : foundObj.text.includes(text)) && !((_c = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value) === null || _c === void 0 ? void 0 : _c.includes(text))) {
-                state.info.foundText = foundObj === null || foundObj === void 0 ? void 0 : foundObj.text;
-                state.info.value = foundObj === null || foundObj === void 0 ? void 0 : foundObj.value;
+            else if (!foundObj?.text.includes(text) && !foundObj?.value?.includes(text)) {
+                state.info.foundText = foundObj?.text;
+                state.info.value = foundObj?.value;
                 throw new Error("element doesn't contain text " + text);
             }
             return state.info;
@@ -1653,11 +1799,9 @@ class StableBrowser {
             if (!fs.existsSync(world.screenshotPath)) {
                 fs.mkdirSync(world.screenshotPath, { recursive: true });
             }
-            let nextIndex = 1;
-            while (fs.existsSync(path.join(world.screenshotPath, nextIndex + ".png"))) {
-                nextIndex++;
-            }
-            const screenshotPath = path.join(world.screenshotPath, nextIndex + ".png");
+            // to make sure the path doesn't start with -
+            const uuidStr = "id_" + randomUUID();
+            const screenshotPath = path.join(world.screenshotPath, uuidStr + ".png");
             try {
                 await this.takeScreenshot(screenshotPath);
                 // let buffer = await this.page.screenshot({ timeout: 4000 });
@@ -1671,7 +1815,7 @@ class StableBrowser {
             catch (e) {
                 this.logger.info("unable to take screenshot, ignored");
             }
-            result.screenshotId = nextIndex;
+            result.screenshotId = uuidStr;
             result.screenshotPath = screenshotPath;
             if (info && info.box) {
                 await drawRectangle(screenshotPath, info.box.x, info.box.y, info.box.width, info.box.height);
@@ -1769,74 +1913,101 @@ class StableBrowser {
         }
     }
     async extractAttribute(selectors, attribute, variable, _params = null, options = {}, world = null) {
-        _validateSelectors(selectors);
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
+        const state = {
+            selectors,
+            _params,
+            attribute,
+            variable,
+            options,
+            world,
+            type: Types.EXTRACT,
+            text: `Extract attribute from element`,
+            operation: "extractAttribute",
+            log: "***** extract attribute " + attribute + " from " + selectors.element_name + " *****\n",
+        };
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        const info = {};
-        info.log = "***** extract attribute " + attribute + " from " + selectors.element_name + " *****\n";
-        info.operation = "extract";
-        info.selectors = selectors;
         try {
-            const element = await this._locate(selectors, info, _params);
-            await this._highlightElements(element);
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
+            await _preCommand(state, this);
             switch (attribute) {
                 case "inner_text":
-                    info.value = await element.innerText();
+                    state.value = await state.element.innerText();
                     break;
                 case "href":
-                    info.value = await element.getAttribute("href");
+                    state.value = await state.element.getAttribute("href");
                     break;
                 case "value":
-                    info.value = await element.inputValue();
+                    state.value = await state.element.inputValue();
                     break;
                 default:
-                    info.value = await element.getAttribute(attribute);
+                    state.value = await state.element.getAttribute(attribute);
                     break;
             }
-            this[variable] = info.value;
-            if (world) {
-                world[variable] = info.value;
+            state.info.value = state.value;
+            this.setTestData({ [variable]: state.value }, world);
+            this.logger.info("set test data: " + variable + "=" + state.value);
+            return state.info;
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            _commandFinally(state, this);
+        }
+    }
+    async verifyAttribute(selectors, attribute, value, _params = null, options = {}, world = null) {
+        const state = {
+            selectors,
+            _params,
+            attribute,
+            value,
+            options,
+            world,
+            type: Types.VERIFY_ATTRIBUTE,
+            text: `Verify element attribute`,
+            operation: "verifyAttribute",
+            log: "***** verify attribute " + attribute + " from " + selectors.element_name + " *****\n",
+        };
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        let val;
+        try {
+            await _preCommand(state, this);
+            switch (attribute) {
+                case "innerText":
+                    val = String(await state.element.innerText());
+                    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;
+                default:
+                    val = String(await state.element.getAttribute(attribute));
+                    break;
             }
-            this.setTestData({ [variable]: info.value }, world);
-            this.logger.info("set test data: " + variable + "=" + info.value);
-            return info;
+            let regex;
+            if (value.startsWith("/") && value.endsWith("/")) {
+                const patternBody = value.slice(1, -1);
+                regex = new RegExp(patternBody, "g");
+            }
+            else {
+                const escapedPattern = value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+                regex = new RegExp(escapedPattern, "g");
+            }
+            if (!val.match(regex)) {
+                throw new Error(`The ${attribute} attribute has a value of "${val}", but the expected value is "${value}"`);
+            }
+            state.info.value = val;
+            return state.info;
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("extract 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(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                element_name: selectors.element_name,
-                type: Types.EXTRACT_ATTRIBUTE,
-                variable: variable,
-                value: info.value,
-                text: "Extract attribute from element",
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
     async extractEmailData(emailAddress, options, world) {
@@ -1913,7 +2084,8 @@ class StableBrowser {
             catch (e) {
                 errorCount++;
                 if (errorCount > 3) {
-                    throw e;
+                    // throw e;
+                    await _commandError({ text: "extractEmailData", operation: "extractEmailData", emailAddress, info: {} }, e, this);
                 }
                 // ignore
             }
@@ -2024,11 +2196,12 @@ class StableBrowser {
             info.screenshotPath = screenshotPath;
             Object.assign(e, { info: info });
             error = e;
-            throw e;
+            // throw e;
+            await _commandError({ text: "verifyPagePath", operation: "verifyPagePath", pathPart, info }, e, this);
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.VERIFY_PAGE_PATH,
                 text: "Verify page path",
                 screenshotId,
@@ -2037,7 +2210,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2050,52 +2223,58 @@ class StableBrowser {
     }
     async verifyTextExistInPage(text, options = {}, world = null) {
         text = unEscapeString(text);
-        const startTime = Date.now();
+        const state = {
+            text_search: text,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
+            text: `Verify text exists in page`,
+            operation: "verifyTextExistInPage",
+            log: "***** verify text " + text + " exists in page *****\n",
+        };
         const timeout = this._getLoadTimeout(options);
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
         await new Promise((resolve) => setTimeout(resolve, 2000));
-        const info = {};
-        info.log = "***** verify text " + text + " exists in page *****\n";
-        info.operation = "verifyTextExistInPage";
         const newValue = await this._replaceWithLocalData(text, world);
         if (newValue !== text) {
             this.logger.info(text + "=" + newValue);
             text = newValue;
         }
-        info.text = text;
         let dateAlternatives = findDateAlternatives(text);
         let numberAlternatives = findNumberAlternatives(text);
         try {
+            await _preCommand(state, this);
+            state.info.text = text;
             while (true) {
                 const frames = this.page.frames();
                 let results = [];
                 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], "*", true, true, {});
+                            const result = await this._locateElementByText(frames[i], dateAlternatives.dates[j], "*:not(script, style, head)", true, true, {});
                             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], "*", true, true, {});
+                            const result = await this._locateElementByText(frames[i], numberAlternatives.numbers[j], "*:not(script, style, head)", true, true, {});
                             result.frame = frames[i];
                             results.push(result);
                         }
                     }
                     else {
-                        const result = await this._locateElementByText(frames[i], text, "*", true, true, {});
+                        const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", true, true, {});
                         result.frame = frames[i];
                         results.push(result);
                     }
                 }
-                info.results = results;
+                state.info.results = results;
                 const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
                 if (resultWithElementsFound.length === 0) {
-                    if (Date.now() - startTime > timeout) {
+                    if (Date.now() - state.startTime > timeout) {
                         throw new Error(`Text ${text} not found in page`);
                     }
                     await new Promise((resolve) => setTimeout(resolve, 1000));
@@ -2107,44 +2286,89 @@ class StableBrowser {
                     await this._highlightElements(frame, dataAttribute);
                     const element = await frame.$(dataAttribute);
                     if (element) {
-                        await this.scrollIfNeeded(element, info);
+                        await this.scrollIfNeeded(element, state.info);
                         await element.dispatchEvent("bvt_verify_page_contains_text");
                     }
                 }
-                ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
-                return info;
+                await _screenshot(state, this);
+                return state.info;
             }
             // await expect(element).toHaveCount(1, { timeout: 10000 });
         }
         catch (e) {
-            //await this.closeUnexpectedPopups();
-            this.logger.error("verify text exist in page 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(state, e, this);
         }
         finally {
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                type: Types.VERIFY_ELEMENT_CONTAINS_TEXT,
-                text: "Verify text exists in page",
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+            _commandFinally(state, this);
+        }
+    }
+    async waitForTextToDisappear(text, options = {}, world = null) {
+        text = unEscapeString(text);
+        const state = {
+            text_search: text,
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.WAIT_FOR_TEXT_TO_DISAPPEAR,
+            text: `Verify text does not exist in page`,
+            operation: "verifyTextNotExistInPage",
+            log: "***** verify text " + text + " does not exist in page *****\n",
+        };
+        const timeout = this._getLoadTimeout(options);
+        await new Promise((resolve) => setTimeout(resolve, 2000));
+        const newValue = await this._replaceWithLocalData(text, world);
+        if (newValue !== text) {
+            this.logger.info(text + "=" + newValue);
+            text = newValue;
+        }
+        let dateAlternatives = findDateAlternatives(text);
+        let numberAlternatives = findNumberAlternatives(text);
+        try {
+            await _preCommand(state, this);
+            state.info.text = text;
+            while (true) {
+                const frames = this.page.frames();
+                let results = [];
+                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)", true, true, {});
+                            result.frame = frames[i];
+                            results.push(result);
+                        }
                     }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+                    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)", true, true, {});
+                            result.frame = frames[i];
+                            results.push(result);
+                        }
+                    }
+                    else {
+                        const result = await this._locateElementByText(frames[i], text, "*:not(script, style, head)", true, true, {});
+                        result.frame = frames[i];
+                        results.push(result);
+                    }
+                }
+                state.info.results = results;
+                const resultWithElementsFound = results.filter((result) => result.elementCount > 0);
+                if (resultWithElementsFound.length === 0) {
+                    await _screenshot(state, this);
+                    return state.info;
+                }
+                if (Date.now() - state.startTime > timeout) {
+                    throw new Error(`Text ${text} found in page`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 1000));
+            }
+        }
+        catch (e) {
+            await _commandError(state, e, this);
+        }
+        finally {
+            _commandFinally(state, this);
         }
     }
     _getServerUrl() {
@@ -2207,11 +2431,12 @@ class StableBrowser {
             info.screenshotPath = screenshotPath;
             Object.assign(e, { info: info });
             error = e;
-            throw e;
+            // throw e;
+            await _commandError({ text: "visualVerification", operation: "visualVerification", text, info }, e, this);
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.VERIFY_VISUAL,
                 text: "Visual verification",
                 screenshotId,
@@ -2220,7 +2445,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2259,6 +2484,7 @@ class StableBrowser {
         let screenshotPath = null;
         const info = {};
         info.log = "";
+        info.locatorLog = new LocatorLog(selectors);
         info.operation = "getTableData";
         info.selectors = selectors;
         try {
@@ -2274,11 +2500,12 @@ class StableBrowser {
             info.screenshotPath = screenshotPath;
             Object.assign(e, { info: info });
             error = e;
-            throw e;
+            // throw e;
+            await _commandError({ text: "getTableData", operation: "getTableData", selectors, info }, e, this);
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 element_name: selectors.element_name,
                 type: Types.GET_TABLE_DATA,
                 text: "Get table data",
@@ -2288,7 +2515,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2439,11 +2666,12 @@ class StableBrowser {
             info.screenshotPath = screenshotPath;
             Object.assign(e, { info: info });
             error = e;
-            throw e;
+            // throw e;
+            await _commandError({ text: "analyzeTable", operation: "analyzeTable", selectors, query, operator, value }, e, this);
         }
         finally {
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 element_name: selectors.element_name,
                 type: Types.ANALYZE_TABLE,
                 text: "Analyze table",
@@ -2453,7 +2681,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2465,27 +2693,7 @@ class StableBrowser {
         }
     }
     async _replaceWithLocalData(value, world, _decrypt = true, totpWait = true) {
-        if (!value) {
-            return value;
-        }
-        // find all the accurance of {{(.*?)}} and replace with the value
-        let regex = /{{(.*?)}}/g;
-        let matches = value.match(regex);
-        if (matches) {
-            const testData = this.getTestData(world);
-            for (let i = 0; i < matches.length; i++) {
-                let match = matches[i];
-                let key = match.substring(2, match.length - 2);
-                let newValue = objectPath.get(testData, key, null);
-                if (newValue !== null) {
-                    value = value.replace(match, newValue);
-                }
-            }
-        }
-        if ((value.startsWith("secret:") || value.startsWith("totp:")) && _decrypt) {
-            return await decrypt(value, null, totpWait);
-        }
-        return value;
+        return await replaceWithLocalTestData(value, world, _decrypt, totpWait, this.context, this);
     }
     _getLoadTimeout(options) {
         let timeout = 15000;
@@ -2536,7 +2744,7 @@ class StableBrowser {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world));
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.GET_PAGE_STATUS,
                 text: "Wait for page load",
                 screenshotId,
@@ -2545,7 +2753,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2556,41 +2764,35 @@ class StableBrowser {
         }
     }
     async closePage(options = {}, world = null) {
-        const startTime = Date.now();
-        let error = null;
-        let screenshotId = null;
-        let screenshotPath = null;
-        const info = {};
+        const state = {
+            options,
+            world,
+            locate: false,
+            scroll: false,
+            highlight: false,
+            type: Types.CLOSE_PAGE,
+            text: `Close page`,
+            operation: "closePage",
+            log: "***** close page *****\n",
+            throwError: false,
+        };
         try {
+            await _preCommand(state, this);
             await this.page.close();
         }
         catch (e) {
             console.log(".");
+            await _commandError(state, e, this);
         }
         finally {
-            await new Promise((resolve) => setTimeout(resolve, 2000));
-            ({ screenshotId, screenshotPath } = await this._screenShot(options, world));
-            const endTime = Date.now();
-            this._reportToWorld(world, {
-                type: Types.CLOSE_PAGE,
-                text: "close page",
-                screenshotId,
-                result: error
-                    ? {
-                        status: "FAILED",
-                        startTime,
-                        endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
-                    }
-                    : {
-                        status: "PASSED",
-                        startTime,
-                        endTime,
-                    },
-                info: info,
-            });
+            _commandFinally(state, this);
         }
     }
+    saveTestDataAsGlobal(options, world) {
+        const dataFile = this._getDataFile(world);
+        process.env.GLOBAL_TEST_DATA_FILE = dataFile;
+        this.logger.info("Save the scenario test data as global for the following scenarios.");
+    }
     async setViewportSize(width, hight, options = {}, world = null) {
         const startTime = Date.now();
         let error = null;
@@ -2608,12 +2810,13 @@ class StableBrowser {
         }
         catch (e) {
             console.log(".");
+            await _commandError({ text: "setViewportSize", operation: "setViewportSize", width, hight, info }, e, this);
         }
         finally {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world));
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.SET_VIEWPORT,
                 text: "set viewport size to " + width + "x" + hight,
                 screenshotId,
@@ -2622,7 +2825,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2644,12 +2847,13 @@ class StableBrowser {
         }
         catch (e) {
             console.log(".");
+            await _commandError({ text: "reloadPage", operation: "reloadPage", info }, e, this);
         }
         finally {
             await new Promise((resolve) => setTimeout(resolve, 2000));
             ({ screenshotId, screenshotPath } = await this._screenShot(options, world, info));
             const endTime = Date.now();
-            this._reportToWorld(world, {
+            _reportToWorld(world, {
                 type: Types.GET_PAGE_STATUS,
                 text: "page relaod",
                 screenshotId,
@@ -2658,7 +2862,7 @@ class StableBrowser {
                         status: "FAILED",
                         startTime,
                         endTime,
-                        message: error === null || error === void 0 ? void 0 : error.message,
+                        message: error?.message,
                     }
                     : {
                         status: "PASSED",
@@ -2685,11 +2889,37 @@ class StableBrowser {
             console.log("#-#");
         }
     }
-    _reportToWorld(world, properties) {
-        if (!world || !world.attach) {
-            return;
+    async beforeStep(world, step) {
+        this.stepName = step.pickleStep.text;
+        this.logger.info("step: " + this.stepName);
+        if (this.stepIndex === undefined) {
+            this.stepIndex = 0;
+        }
+        else {
+            this.stepIndex++;
+        }
+        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);
+            }
+        }
+    }
+    async afterStep(world, step) {
+        this.stepName = null;
+        if (this.context && this.context.browserObject && this.context.browserObject.trace === true) {
+            if (this.context.browserObject.context) {
+                await this.context.browserObject.context.tracing.stopChunk({
+                    path: path.join(this.context.browserObject.traceFolder, `trace-${this.stepIndex}.zip`),
+                });
+            }
         }
-        world.attach(JSON.stringify(properties), { mediaType: "application/json" });
     }
 }
 function createTimedPromise(promise, label) {