codeceptjs 4.0.0-beta.4 → 4.0.0-beta.6.esm-aria

package/lib/helper/Playwright.js

@@ -1,18 +1,17 @@
-const path = require('path')
-const fs = require('fs')
-
-const Helper = require('@codeceptjs/helper')
-const { v4: uuidv4 } = require('uuid')
-const assert = require('assert')
-const promiseRetry = require('promise-retry')
-const Locator = require('../locator')
-const recorder = require('../recorder')
-const stringIncludes = require('../assert/include').includes
-const { urlEquals } = require('../assert/equal')
-const { equals } = require('../assert/equal')
-const { empty } = require('../assert/empty')
-const { truth } = require('../assert/truth')
-const {
+import path from 'path'
+import fs from 'fs'
+import Helper from '@codeceptjs/helper'
+import { v4 as uuidv4 } from 'uuid'
+import assert from 'assert'
+import promiseRetry from 'promise-retry'
+import Locator from '../locator.js'
+import recorder from '../recorder.js'
+import store from '../store.js'
+import { includes as stringIncludes } from '../assert/include.js'
+import { urlEquals, equals } from '../assert/equal.js'
+import { empty } from '../assert/empty.js'
+import { truth } from '../assert/truth.js'
+import {
   xpathLocator,
   ucfirst,
   fileExists,
@@ -24,13 +23,14 @@ const {
   clearString,
   requireWithFallback,
   normalizeSpacesInString,
-} = require('../utils')
-const { isColorProperty, convertColorToRGBA } = require('../colorUtils')
-const ElementNotFound = require('./errors/ElementNotFound')
-const RemoteBrowserConnectionRefused = require('./errors/RemoteBrowserConnectionRefused')
-const Popup = require('./extras/Popup')
-const Console = require('./extras/Console')
-const { findReact, findVue, findByPlaywrightLocator } = require('./extras/PlaywrightReactVueLocator')
+  relativeDir,
+} from '../utils.js'
+import { isColorProperty, convertColorToRGBA } from '../colorUtils.js'
+import ElementNotFound from './errors/ElementNotFound.js'
+import RemoteBrowserConnectionRefused from './errors/RemoteBrowserConnectionRefused.js'
+import Popup from './extras/Popup.js'
+import Console from './extras/Console.js'
+import { buildLocatorString, findElements, findElement, getVisibleElements, findReact, findVue, findByPlaywrightLocator, findByRole } from './extras/PlaywrightLocator.js'
 
 let playwright
 let perfTiming
@@ -40,26 +40,10 @@ const popupStore = new Popup()
 const consoleLogStore = new Console()
 const availableBrowsers = ['chromium', 'webkit', 'firefox', 'electron']
 
-const {
-  setRestartStrategy,
-  restartsSession,
-  restartsContext,
-  restartsBrowser,
-} = require('./extras/PlaywrightRestartOpts')
-const { createValueEngine, createDisabledEngine } = require('./extras/PlaywrightPropEngine')
-const {
-  seeElementError,
-  dontSeeElementError,
-  dontSeeElementInDOMError,
-  seeElementInDOMError,
-} = require('./errors/ElementAssertion')
-const {
-  dontSeeTraffic,
-  seeTraffic,
-  grabRecordedNetworkTraffics,
-  stopRecordingTraffic,
-  flushNetworkTraffics,
-} = require('./network/actions')
+import { setRestartStrategy, restartsSession, restartsContext } from './extras/PlaywrightRestartOpts.js'
+import { createValueEngine, createDisabledEngine } from './extras/PlaywrightPropEngine.js'
+import { seeElementError, dontSeeElementError, dontSeeElementInDOMError, seeElementInDOMError } from './errors/ElementAssertion.js'
+import { dontSeeTraffic, seeTraffic, grabRecordedNetworkTraffics, stopRecordingTraffic, flushNetworkTraffics } from './network/actions.js'
 
 const pathSeparator = path.sep
 
@@ -75,7 +59,6 @@ const pathSeparator = path.sep
  * @prop {boolean} [show=true] - show browser window.
  * @prop {string|boolean} [restart=false] - restart strategy between tests. Possible values:
  *   * 'context' or **false** - restarts [browser context](https://playwright.dev/docs/api/class-browsercontext) but keeps running browser. Recommended by Playwright team to keep tests isolated.
- *   * 'browser' or **true** - closes browser and opens it again between tests.
  *   * 'session' or 'keep' - keeps browser context and session, but cleans up cookies and localStorage between tests. The fastest option when running tests in windowed mode. Works with `keepCookies` and `keepBrowserState` options. This behavior was default before CodeceptJS 3.1
  * @prop {number} [timeout=1000] - -  [timeout](https://playwright.dev/docs/api/class-page#page-set-default-timeout) in ms of all Playwright actions .
  * @prop {boolean} [disableScreenshots=false] - don't save screenshot on failure.
@@ -334,7 +317,7 @@ class Playwright extends Helper {
   constructor(config) {
     super(config)
 
-    playwright = requireWithFallback('playwright', 'playwright-core')
+    // playwright will be loaded dynamically in _init method
 
     // set defaults
     this.isRemoteBrowser = false
@@ -358,6 +341,10 @@ class Playwright extends Helper {
     this.recordedWebSocketMessagesAtLeastOnce = false
     this.cdpSession = null
 
+    // Add test failure tracking to prevent false positives
+    this.testFailures = []
+    this.hasCleanupError = false
+
     // override defaults with config
     this._setConfig(config)
   }
@@ -392,9 +379,7 @@ class Playwright extends Helper {
     config = Object.assign(defaults, config)
 
     if (availableBrowsers.indexOf(config.browser) < 0) {
-      throw new Error(
-        `Invalid config. Can't use browser "${config.browser}". Accepted values: ${availableBrowsers.join(', ')}`,
-      )
+      throw new Error(`Invalid config. Can't use browser "${config.browser}". Accepted values: ${availableBrowsers.join(', ')}`)
     }
 
     return config
@@ -440,9 +425,7 @@ class Playwright extends Helper {
     }
     this.isRemoteBrowser = !!this.playwrightOptions.browserWSEndpoint
     this.isElectron = this.options.browser === 'electron'
-    this.userDataDir = this.playwrightOptions.userDataDir
-      ? `${this.playwrightOptions.userDataDir}_${Date.now().toString()}`
-      : undefined
+    this.userDataDir = this.playwrightOptions.userDataDir ? `${this.playwrightOptions.userDataDir}_${Date.now().toString()}` : undefined
     this.isCDPConnection = this.playwrightOptions.cdpConnection
     popupStore.defaultAction = this.options.defaultPopupAction
   }
@@ -458,27 +441,44 @@ class Playwright extends Helper {
         name: 'url',
         message: 'Base url of site to be tested',
         default: 'http://localhost',
-        when: (answers) => answers.Playwright_browser !== 'electron',
+        when: answers => answers.Playwright_browser !== 'electron',
       },
       {
         name: 'show',
         message: 'Show browser window',
         default: true,
         type: 'confirm',
-        when: (answers) => answers.Playwright_browser !== 'electron',
+        when: answers => answers.Playwright_browser !== 'electron',
       },
     ]
   }
 
   static _checkRequirements() {
     try {
-      requireWithFallback('playwright', 'playwright-core')
+      // In ESM, playwright will be checked via dynamic import in constructor
+      // The import will fail at module load time if playwright is missing
+      return null
     } catch (e) {
       return ['playwright@^1.18']
     }
   }
 
   async _init() {
+    // Load playwright dynamically with fallback
+    if (!playwright) {
+      try {
+        playwright = await import('playwright')
+        playwright = playwright.default || playwright
+      } catch (e) {
+        try {
+          playwright = await import('playwright-core')
+          playwright = playwright.default || playwright
+        } catch (e2) {
+          throw new Error('Neither playwright nor playwright-core could be loaded. Please install one of them.')
+        }
+      }
+    }
+
     // register an internal selector engine for reading value property of elements in a selector
     if (defaultSelectorEnginesInitialized) return
     defaultSelectorEnginesInitialized = true
@@ -492,7 +492,9 @@ class Playwright extends Helper {
   }
 
   _beforeSuite() {
-    if ((restartsSession() || restartsContext()) && !this.options.manualStart && !this.isRunning) {
+    // Start browser if not manually started and not already running
+    // Browser should start in singleton mode (restart: false) or when restart strategy is enabled
+    if (!this.options.manualStart && !this.isRunning) {
       this.debugSection('Session', 'Starting singleton browser session')
       return this._startBrowser()
     }
@@ -500,9 +502,22 @@ class Playwright extends Helper {
 
   async _before(test) {
     this.currentRunningTest = test
+
+    // Reset failure tracking for each test to prevent false positives
+    this.hasCleanupError = false
+    this.testFailures = []
+
+    // Reset frame context to ensure clean state for each test
+    this.context = this.page
+    this.frame = null
+    this.contextLocator = null
+
+    // Clear popup state to ensure clean state for each test
+    popupStore.clear()
+
     recorder.retry({
-      retries: process.env.FAILED_STEP_RETRIES || 3,
-      when: (err) => {
+      retries: test?.opts?.conditionalRetries || 3,
+      when: err => {
         if (!err || typeof err.message !== 'string') {
           return false
         }
@@ -511,7 +526,6 @@ class Playwright extends Helper {
       },
     })
 
-    if (restartsBrowser() && !this.options.manualStart) await this._startBrowser()
     if (!this.isRunning && !this.options.manualStart) await this._startBrowser()
 
     this.isAuthenticated = false
@@ -540,12 +554,25 @@ class Playwright extends Helper {
         this.currentRunningTest.artifacts.har = fileName
         contextOptions.recordHar = this.options.recordHar
       }
+
+      // load pre-saved cookies
+      if (test?.opts?.cookies) contextOptions.storageState = { cookies: test.opts.cookies }
+
       if (this.storageState) contextOptions.storageState = this.storageState
       if (this.options.userAgent) contextOptions.userAgent = this.options.userAgent
       if (this.options.locale) contextOptions.locale = this.options.locale
       if (this.options.colorScheme) contextOptions.colorScheme = this.options.colorScheme
       this.contextOptions = contextOptions
       if (!this.browserContext || !restartsSession()) {
+        if (!this.browser) {
+          if (this.options.manualStart) {
+            this.debugSection('Manual Start', 'Browser not started - skipping context creation')
+            return // Skip context creation when manualStart is true
+          } else {
+            throw new Error('Browser not started. This should not happen.')
+          }
+        }
+        this.debugSection('New Session', JSON.stringify(this.contextOptions))
         this.browserContext = await this.browser.newContext(this.contextOptions) // Adding the HTTPSError ignore in the context so that we can ignore those errors
       }
     }
@@ -559,10 +586,7 @@ class Playwright extends Helper {
         mainPage = existingPages[0] || (await this.browserContext.newPage())
       } catch (e) {
         if (this.playwrightOptions.userDataDir) {
-          this.browser = await playwright[this.options.browser].launchPersistentContext(
-            this.userDataDir,
-            this.playwrightOptions,
-          )
+          this.browser = await playwright[this.options.browser].launchPersistentContext(this.userDataDir, this.playwrightOptions)
           this.browserContext = this.browser
           const existingPages = await this.browserContext.pages()
           mainPage = existingPages[0]
@@ -573,6 +597,15 @@ class Playwright extends Helper {
 
     await this._setPage(mainPage)
 
+    try {
+      // set metadata for reporting
+      test.meta.browser = this.browser.browserType().name()
+      test.meta.browserVersion = this.browser.version()
+      test.meta.windowSize = `${this.page.viewportSize().width}x${this.page.viewportSize().height}`
+    } catch (e) {
+      this.debug('Failed to set metadata for reporting')
+    }
+
     if (this.options.trace) await this.browserContext.tracing.start({ screenshots: true, snapshots: true })
 
     return this.browser
@@ -582,8 +615,12 @@ class Playwright extends Helper {
     if (!this.isRunning) return
 
     if (this.isElectron) {
-      this.browser.close()
-      this.electronSessions.forEach((session) => session.close())
+      try {
+        this.browser.close()
+        this.electronSessions.forEach(session => session.close())
+      } catch (e) {
+        console.warn('Warning during electron cleanup:', e.message)
+      }
       return
     }
 
@@ -591,34 +628,154 @@ class Playwright extends Helper {
       return refreshContextSession.bind(this)()
     }
 
-    if (restartsBrowser()) {
-      this.isRunning = false
-      return this._stopBrowser()
+    // close other sessions with timeout protection, but only if restartsContext() is true
+    if (restartsContext()) {
+      try {
+        if ((await this.browser)?._type === 'Browser') {
+          const contexts = await Promise.race([this.browser.contexts(), new Promise((_, reject) => setTimeout(() => reject(new Error('Get contexts timeout')), 3000))])
+          const currentContext = contexts[0]
+          if (currentContext && (this.options.keepCookies || this.options.keepBrowserState)) {
+            try {
+              this.storageState = await currentContext.storageState()
+            } catch (e) {
+              console.warn('Warning during storage state save:', e.message)
+            }
+          }
+
+          await Promise.race([Promise.all(contexts.map(c => c.close())), new Promise((_, reject) => setTimeout(() => reject(new Error('Close contexts timeout')), 5000))])
+        }
+      } catch (e) {
+        console.warn('Warning during context cleanup in _after:', e.message)
+      }
+    }
+
+    return this.browser
+  }
+
+  async _afterSuite() {
+    // Only stop browser if restart strategy requires it
+    if ((restartsSession() || restartsContext()) && this.isRunning) {
+      try {
+        await this._stopBrowser()
+      } catch (e) {
+        console.warn('Warning during suite cleanup:', e.message)
+        // Track suite cleanup failures
+        this.hasCleanupError = true
+        this.testFailures.push(`Suite cleanup failed: ${e.message}`)
+      } finally {
+        this.isRunning = false
+      }
+    }
+
+    // Force cleanup of any remaining browser processes
+    try {
+      if (this.browser && (!this.browser.isConnected || this.browser)) {
+        await Promise.race([Promise.resolve(), new Promise(resolve => setTimeout(resolve, 1000))])
+      }
+    } catch (e) {
+      console.warn('Final cleanup warning:', e.message)
+      this.hasCleanupError = true
+      this.testFailures.push(`Final cleanup failed: ${e.message}`)
     }
 
-    // close other sessions
+    // Clean up session pages explicitly to prevent hanging references
     try {
-      if ((await this.browser)._type === 'Browser') {
-        const contexts = await this.browser.contexts()
-        const currentContext = contexts[0]
-        if (currentContext && (this.options.keepCookies || this.options.keepBrowserState)) {
-          this.storageState = await currentContext.storageState()
+      if (this.sessionPages && Object.keys(this.sessionPages).length > 0) {
+        for (const sessionName in this.sessionPages) {
+          const sessionPage = this.sessionPages[sessionName]
+          if (sessionPage && !sessionPage.isClosed()) {
+            try {
+              // Remove any remaining event listeners from session pages
+              sessionPage.removeAllListeners('dialog')
+              sessionPage.removeAllListeners('crash')
+              sessionPage.removeAllListeners('close')
+              sessionPage.removeAllListeners('error')
+              await sessionPage.close()
+            } catch (e) {
+              console.warn(`Warning closing session page ${sessionName}:`, e.message)
+            }
+          }
         }
+        this.sessionPages = {} // Clear the session pages object
+        this.activeSessionName = '' // Reset active session name
+      }
+    } catch (e) {
+      console.warn('Session pages cleanup warning:', e.message)
+      this.hasCleanupError = true
+      this.testFailures.push(`Session cleanup failed: ${e.message}`)
+    }
 
-        await Promise.all(contexts.map((c) => c.close()))
+    // Clear any lingering DOM timeouts by executing cleanup in browser context
+    try {
+      if (this.page && !this.page.isClosed()) {
+        await this.page
+          .evaluate(() => {
+            // Clear any running highlight timeouts by clearing a range of timeout IDs
+            for (let i = 1; i <= 1000; i++) {
+              clearTimeout(i)
+            }
+          })
+          .catch(() => {
+            // Ignore errors if execution context is destroyed (e.g., due to navigation)
+          })
       }
     } catch (e) {
-      console.log(e)
+      // Only log if it's not an execution context error
+      if (!e.message.includes('Execution context was destroyed')) {
+        console.warn('DOM timeout cleanup warning:', e.message)
+        this.hasCleanupError = true
+        this.testFailures.push(`DOM cleanup failed: ${e.message}`)
+      }
     }
 
-    // await this.closeOtherTabs();
-    return this.browser
+    // If we have cleanup errors, throw to fail the test suite
+    if (this.hasCleanupError && this.testFailures.length > 0) {
+      const errorMessage = `Test suite cleanup failed: ${this.testFailures.join('; ')}`
+      console.error(errorMessage)
+      throw new Error(errorMessage)
+    }
   }
 
-  _afterSuite() {}
-
   async _finishTest() {
-    if ((restartsSession() || restartsContext()) && this.isRunning) return this._stopBrowser()
+    if ((restartsSession() || restartsContext()) && this.isRunning) {
+      try {
+        await Promise.race([this._stopBrowser(), new Promise((_, reject) => setTimeout(() => reject(new Error('Test finish timeout')), 10000))])
+      } catch (e) {
+        console.warn('Warning during test finish cleanup:', e.message)
+        // Track cleanup failures to prevent false positives
+        this.hasCleanupError = true
+        this.testFailures.push(`Test finish cleanup failed: ${e.message}`)
+
+        this.isRunning = false
+        // Set flags to prevent further operations after cleanup failure
+        this.page = null
+        this.browserContext = null
+        this.browser = null
+
+        // Propagate the error to fail the test properly
+        throw new Error(`Test cleanup failed: ${e.message}`)
+      }
+    }
+  }
+
+  async _cleanup() {
+    // Final cleanup when test run completes
+    if (this.isRunning) {
+      try {
+        await this._stopBrowser()
+      } catch (e) {
+        console.warn('Warning during final cleanup:', e.message)
+      }
+    } else {
+      // Check if we still have a browser object despite isRunning being false
+      if (this.browser) {
+        try {
+          await this._stopBrowser()
+        } catch (e) {
+          console.warn('Warning during forced cleanup:', e.message)
+        }
+      }
+    }
   }
 
   _session() {
@@ -637,16 +794,20 @@ class Playwright extends Helper {
           page = await browser.firstWindow()
         } else {
           try {
-            browserContext = await this.browser.newContext(Object.assign(this.contextOptions, config))
-            page = await browserContext.newPage()
+            // Check if browser is still available before creating context
+            if (!this.browser) {
+              throw new Error('Browser is not available for session context creation')
+            }
+            browserContext = await Promise.race([this.browser.newContext(Object.assign(this.contextOptions, config)), new Promise((_, reject) => setTimeout(() => reject(new Error('New context timeout')), 10000))])
+            page = await Promise.race([browserContext.newPage(), new Promise((_, reject) => setTimeout(() => reject(new Error('New page timeout')), 5000))])
           } catch (e) {
+            console.warn('Warning during context creation:', e.message)
             if (this.playwrightOptions.userDataDir) {
-              browserContext = await playwright[this.options.browser].launchPersistentContext(
-                `${this.userDataDir}_${this.activeSessionName}`,
-                this.playwrightOptions,
-              )
+              browserContext = await playwright[this.options.browser].launchPersistentContext(`${this.userDataDir}_${this.activeSessionName}`, this.playwrightOptions)
               this.browser = browserContext
               page = await browserContext.pages()[0]
+            } else {
+              throw e
             }
           }
         }
@@ -660,7 +821,7 @@ class Playwright extends Helper {
       stop: async () => {
         // is closed by _after
       },
-      loadVars: async (context) => {
+      loadVars: async context => {
         if (context) {
           this.browserContext = context
           const existingPages = await context.pages()
@@ -668,7 +829,7 @@ class Playwright extends Helper {
           return this._setPage(this.sessionPages[this.activeSessionName])
         }
       },
-      restoreVars: async (session) => {
+      restoreVars: async session => {
         this.withinLocator = null
         this.browserContext = defaultContext
 
@@ -677,8 +838,28 @@ class Playwright extends Helper {
         } else {
           this.activeSessionName = session
         }
-        const existingPages = await this.browserContext.pages()
-        await this._setPage(existingPages[0])
+
+        // Safety check: ensure browserContext exists before calling pages()
+        if (!this.browserContext) {
+          this.debug('Cannot restore session vars: browserContext is undefined')
+          return
+        }
+
+        try {
+          const existingPages = await this.browserContext.pages()
+          if (existingPages && existingPages.length > 0) {
+            await this._setPage(existingPages[0])
+            // Reset context-related variables to ensure clean state after session
+            this.context = await this.page
+            this.contextLocator = null
+            this.frame = null
+          } else {
+            this.debug('Cannot restore session vars: no pages available')
+          }
+        } catch (err) {
+          this.debug(`Failed to restore session vars: ${err.message}`)
+          return
+        }
 
         return this._waitForAction()
       },
@@ -764,21 +945,43 @@ class Playwright extends Helper {
    * @param {object} page page to set
    */
   async _setPage(page) {
+    // Clean up previous page event listeners
+    if (this.page && this.page !== page) {
+      try {
+        this.page.removeAllListeners('crash')
+        this.page.removeAllListeners('dialog')
+      } catch (e) {
+        console.warn('Warning cleaning previous page listeners:', e.message)
+      }
+    }
+
     page = await page
     this._addPopupListener(page)
     this.page = page
     if (!page) return
-    this.browserContext.setDefaultTimeout(0)
-    page.setDefaultNavigationTimeout(this.options.getPageTimeout)
-    page.setDefaultTimeout(this.options.timeout)
 
-    page.on('crash', async () => {
-      console.log('ERROR: Page has crashed, closing page!')
-      await page.close()
-    })
-    this.context = await this.page
-    this.contextLocator = null
-    await page.bringToFront()
+    try {
+      this.browserContext.setDefaultTimeout(0)
+      page.setDefaultNavigationTimeout(this.options.getPageTimeout)
+      page.setDefaultTimeout(this.options.timeout)
+
+      page.on('crash', async () => {
+        console.log('ERROR: Page has crashed, closing page!')
+        try {
+          await page.close()
+        } catch (e) {
+          console.warn('Warning during crashed page cleanup:', e.message)
+        }
+      })
+
+      this.context = await this.page
+      this.contextLocator = null
+      await page.bringToFront()
+    } catch (e) {
+      console.warn('Warning during page setup:', e.message)
+      this.context = await this.page
+      this.contextLocator = null
+    }
   }
 
   /**
@@ -793,7 +996,7 @@ class Playwright extends Helper {
       return
     }
     page.removeAllListeners('dialog')
-    page.on('dialog', async (dialog) => {
+    page.on('dialog', async dialog => {
       popupStore.popup = dialog
       const action = popupStore.actionType || this.options.defaultPopupAction
       await this._waitForAction()
@@ -856,16 +1059,13 @@ class Playwright extends Helper {
         throw err
       }
     } else if (this.playwrightOptions.userDataDir) {
-      this.browser = await playwright[this.options.browser].launchPersistentContext(
-        this.userDataDir,
-        this.playwrightOptions,
-      )
+      this.browser = await playwright[this.options.browser].launchPersistentContext(this.userDataDir, this.playwrightOptions)
     } else {
       this.browser = await playwright[this.options.browser].launch(this.playwrightOptions)
     }
 
     // works only for Chromium
-    this.browser.on('targetchanged', (target) => {
+    this.browser.on('targetchanged', target => {
       this.debugSection('Url', target.url())
     })
 
@@ -879,6 +1079,9 @@ class Playwright extends Helper {
    * @param {object} [contextOptions] See https://playwright.dev/docs/api/class-browser#browser-new-context
    */
   async _createContextPage(contextOptions) {
+    if (!this.browser) {
+      throw new Error('Browser not started. Call _startBrowser() first or disable manualStart option.')
+    }
     this.browserContext = await this.browser.newContext(contextOptions)
     const page = await this.browserContext.newPage()
     targetCreatedHandler.call(this, page)
@@ -895,8 +1098,58 @@ class Playwright extends Helper {
     this.context = null
     this.frame = null
     popupStore.clear()
-    if (this.options.recordHar) await this.browserContext.close()
-    await this.browser.close()
+
+    // Clean up event listeners to prevent hanging
+    try {
+      if (this.browser) {
+        this.browser.removeAllListeners('targetchanged')
+        if (this.browserContext) {
+          // Clean up any page event listeners in the context
+          const pages = this.browserContext.pages()
+          for (const page of pages) {
+            try {
+              page.removeAllListeners('crash')
+              page.removeAllListeners('dialog')
+            } catch (e) {
+              console.warn('Warning cleaning page listeners:', e.message)
+            }
+          }
+        }
+      }
+    } catch (e) {
+      console.warn('Warning cleaning event listeners:', e.message)
+    }
+
+    try {
+      if (this.browserContext) {
+        await Promise.race([this.browserContext.close(), new Promise((_, reject) => setTimeout(() => reject(new Error('Context close timeout')), 3000))])
+      }
+    } catch (error) {
+      console.warn('Failed to close browser context:', error.message)
+    }
+
+    try {
+      if (this.browser) {
+        await Promise.race([this.browser.close(), new Promise((_, reject) => setTimeout(() => reject(new Error('Browser close timeout')), 3000))])
+      }
+    } catch (error) {
+      console.warn('Failed to close browser:', error.message)
+    }
+
+    // Always try to kill the browser process to ensure cleanup
+    try {
+      if (this.browser && this.browser.process && this.browser.process()) {
+        this.browser.process().kill('SIGKILL')
+      }
+    } catch (e) {
+      // Silently ignore process kill errors
+    }
+
+    // Ensure cleanup is complete
+    this.browser = null
+    this.browserContext = null
+    this.page = null
+    this.isRunning = false
   }
 
   async _evaluateHandeInContext(...args) {
@@ -913,8 +1166,21 @@ class Playwright extends Helper {
 
     if (frame) {
       if (Array.isArray(frame)) {
+        // For nested frames, build the complete frame path
         await this.switchTo(null)
-        return frame.reduce((p, frameLocator) => p.then(() => this.switchTo(frameLocator)), Promise.resolve())
+
+        // Build nested frame locator from page
+        let frameLocatorObj = this.page
+        for (const frameSelector of frame) {
+          const selector = buildLocatorString(new Locator(frameSelector, 'css'))
+          frameLocatorObj = frameLocatorObj.frameLocator(selector)
+        }
+
+        this.frame = frameLocatorObj
+        this.context = frameLocatorObj
+        this.contextLocator = null
+        this.withinLocator = new Locator(frame)
+        return
       }
       await this.switchTo(frame)
       this.withinLocator = new Locator(frame)
@@ -931,7 +1197,11 @@ class Playwright extends Helper {
 
   async _withinEnd() {
     this.withinLocator = null
-    this.context = await this.page
+    if (this.page) {
+      this.context = await this.page
+    } else {
+      this.context = null
+    }
     this.contextLocator = null
     this.frame = null
   }
@@ -940,7 +1210,7 @@ class Playwright extends Helper {
     const navigationStart = timing.navigationStart
 
     const extractedData = {}
-    dataNames.forEach((name) => {
+    dataNames.forEach(name => {
       extractedData[name] = timing[name] - navigationStart
     })
 
@@ -954,8 +1224,15 @@ class Playwright extends Helper {
     if (this.isElectron) {
       throw new Error('Cannot open pages inside an Electron container')
     }
+
+    // Prevent navigation attempts when browser is being torn down
+    if (!this.isRunning && (!this.browser || !this.browserContext || !this.page)) {
+      throw new Error('Cannot navigate: browser is not running or has been closed')
+    }
+
     if (!/^\w+\:(\/\/|.+)/.test(url)) {
-      url = this.options.url + (url.startsWith('/') ? url : `/${url}`)
+      url = this.options.url + (!this.options.url.endsWith('/') && url.startsWith('/') ? url : `/${url}`)
+      this.debug(`Changed URL to base url + relative path: ${url}`)
     }
 
     if (this.options.basicAuth && this.isAuthenticated !== true) {
@@ -965,17 +1242,81 @@ class Playwright extends Helper {
       }
     }
 
-    await this.page.goto(url, { waitUntil: this.options.waitForNavigation })
+    // Ensure browser is initialized before page operations
+    if (!this.page) {
+      this.debugSection('Auto-initializing', `Browser not started properly. page=${!!this.page}, isRunning=${this.isRunning}, browser=${!!this.browser}, browserContext=${!!this.browserContext}`)
+
+      if (!this.browser) {
+        await this._startBrowser()
+      }
+
+      // Create browser context and page (simplified version of _before logic)
+      if (!this.browserContext) {
+        if (!this.browser) {
+          throw new Error('Browser is not available for context creation. Browser may have been closed.')
+        }
+        const contextOptions = {
+          ignoreHTTPSErrors: this.options.ignoreHTTPSErrors,
+          acceptDownloads: true,
+          ...this.options.emulate,
+        }
+        this.browserContext = await this.browser.newContext(contextOptions)
+      }
+
+      let pages
+      let mainPage
+      try {
+        pages = await this.browserContext.pages()
+        mainPage = pages[0] || (await this.browserContext.newPage())
+      } catch (e) {
+        if (e.message.includes('Target page, context or browser has been closed') || e.message.includes('Browser has been closed')) {
+          throw new Error('Cannot create page: browser context has been closed')
+        }
+        throw e
+      }
+      await this._setPage(mainPage)
+
+      this.debugSection('Auto-initializing', `Completed. page=${!!this.page}, browserContext=${!!this.browserContext}`)
+    }
+
+    // Additional safety check
+    if (!this.page) {
+      throw new Error(`Page is not initialized after auto-initialization. this.page=${this.page}, this.isRunning=${this.isRunning}, this.browser=${!!this.browser}, this.browserContext=${!!this.browserContext}`)
+    }
+
+    try {
+      // Additional validation before navigation
+      if (this.page && this.page.isClosed && this.page.isClosed()) {
+        throw new Error('Cannot navigate: page has been closed')
+      }
+
+      if (this.browserContext) {
+        // Try to check if context is still valid
+        try {
+          await Promise.race([this.browserContext.pages(), new Promise((_, reject) => setTimeout(() => reject(new Error('Context check timeout')), 1000))])
+        } catch (contextError) {
+          throw new Error('Cannot navigate: browser context is invalid or closed')
+        }
+      }
+
+      await this.page.goto(url, { waitUntil: this.options.waitForNavigation })
+    } catch (err) {
+      // Handle terminal navigation errors that shouldn't be retried
+      if (
+        err.message &&
+        (err.message.includes('ERR_ABORTED') || err.message.includes('frame was detached') || err.message.includes('Target page, context or browser has been closed') || err.message.includes('Cannot navigate'))
+      ) {
+        // Mark this as a terminal error to prevent retries
+        const terminalError = new Error(err.message)
+        terminalError.isTerminal = true
+        throw terminalError
+      }
+      throw err
+    }
 
     const performanceTiming = JSON.parse(await this.page.evaluate(() => JSON.stringify(window.performance.timing)))
 
-    perfTiming = this._extractDataFromPerformanceTiming(
-      performanceTiming,
-      'responseEnd',
-      'domInteractive',
-      'domContentLoadedEventEnd',
-      'loadEventEnd',
-    )
+    perfTiming = this._extractDataFromPerformanceTiming(performanceTiming, 'responseEnd', 'domInteractive', 'domContentLoadedEventEnd', 'loadEventEnd')
 
     return this._waitForAction()
   }
@@ -1127,26 +1468,6 @@ class Playwright extends Helper {
     await this.page.mouse.up()
   }
 
-  /**
-   * Restart browser with a new context and a new page
-   *
-   * ```js
-   * // Restart browser and use a new timezone
-   * I.restartBrowser({ timezoneId: 'America/Phoenix' });
-   * // Open URL in a new page in changed timezone
-   * I.amOnPage('/');
-   * // Restart browser, allow reading/copying of text from/into clipboard in Chrome
-   * I.restartBrowser({ permissions: ['clipboard-read', 'clipboard-write'] });
-   * ```
-   *
-   * @param {object} [contextOptions] [Options for browser context](https://playwright.dev/docs/api/class-browser#browser-new-context) when starting new browser
-   */
-  async restartBrowser(contextOptions) {
-    await this._stopBrowser()
-    await this._startBrowser()
-    await this._createContextPage(contextOptions)
-  }
-
   /**
    * {{> refreshPage }}
    */
@@ -1197,10 +1518,7 @@ class Playwright extends Helper {
     return this.executeScript(() => {
       const body = document.body
       const html = document.documentElement
-      window.scrollTo(
-        0,
-        Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight),
-      )
+      window.scrollTo(0, Math.max(body.scrollHeight, body.offsetHeight, html.clientHeight, html.scrollHeight, html.offsetHeight))
     })
   }
 
@@ -1287,7 +1605,22 @@ class Playwright extends Helper {
 
     if (this.frame) return findElements(this.frame, locator)
 
-    return findElements(context, locator)
+    const els = await findElements(context, locator)
+
+    if (store.debugMode) {
+      const previewElements = els.slice(0, 3)
+      let htmls = await Promise.all(previewElements.map(el => elToString(el, previewElements.length)))
+      if (els.length > 3) htmls.push('...')
+      if (els.length > 1) {
+        this.debugSection(`Elements (${els.length})`, htmls.join('|').trim())
+      } else if (els.length === 1) {
+        this.debugSection('Element', htmls.join('|').trim())
+      } else {
+        this.debug(`No elements found by ${JSON.stringify(locator).slice(0, 50)}....`)
+      }
+    }
+
+    return els
   }
 
   /**
@@ -1437,10 +1770,10 @@ class Playwright extends Helper {
    */
   async closeOtherTabs() {
     const pages = await this.browserContext.pages()
-    const otherPages = pages.filter((page) => page !== this.page)
+    const otherPages = pages.filter(page => page !== this.page)
     if (otherPages.length) {
       this.debug(`Closing ${otherPages.length} tabs`)
-      return Promise.all(otherPages.map((p) => p.close()))
+      return Promise.all(otherPages.map(p => p.close()))
     }
     return Promise.resolve()
   }
@@ -1483,9 +1816,9 @@ class Playwright extends Helper {
    */
   async seeElement(locator) {
     let els = await this._locate(locator)
-    els = await Promise.all(els.map((el) => el.isVisible()))
+    els = await Promise.all(els.map(el => el.isVisible()))
     try {
-      return empty('visible elements').negate(els.filter((v) => v).fill('ELEMENT'))
+      return empty('visible elements').negate(els.filter(v => v).fill('ELEMENT'))
     } catch (e) {
       dontSeeElementError(locator)
     }
@@ -1497,9 +1830,9 @@ class Playwright extends Helper {
    */
   async dontSeeElement(locator) {
     let els = await this._locate(locator)
-    els = await Promise.all(els.map((el) => el.isVisible()))
+    els = await Promise.all(els.map(el => el.isVisible()))
     try {
-      return empty('visible elements').assert(els.filter((v) => v).fill('ELEMENT'))
+      return empty('visible elements').assert(els.filter(v => v).fill('ELEMENT'))
     } catch (e) {
       seeElementError(locator)
     }
@@ -1511,7 +1844,7 @@ class Playwright extends Helper {
   async seeElementInDOM(locator) {
     const els = await this._locate(locator)
     try {
-      return empty('elements on page').negate(els.filter((v) => v).fill('ELEMENT'))
+      return empty('elements on page').negate(els.filter(v => v).fill('ELEMENT'))
     } catch (e) {
       dontSeeElementInDOMError(locator)
     }
@@ -1523,7 +1856,7 @@ class Playwright extends Helper {
   async dontSeeElementInDOM(locator) {
     const els = await this._locate(locator)
     try {
-      return empty('elements on a page').assert(els.filter((v) => v).fill('ELEMENT'))
+      return empty('elements on a page').assert(els.filter(v => v).fill('ELEMENT'))
     } catch (e) {
       seeElementInDOMError(locator)
     }
@@ -1547,7 +1880,7 @@ class Playwright extends Helper {
    * @return {Promise<void>}
    */
   async handleDownloads(fileName) {
-    this.page.waitForEvent('download').then(async (download) => {
+    this.page.waitForEvent('download').then(async download => {
       const filePath = await download.path()
       fileName = fileName || `downloads/${path.basename(filePath)}`
 
@@ -1741,6 +2074,7 @@ class Playwright extends Helper {
     const el = els[0]
 
     await el.clear()
+    if (store.debugMode) this.debugSection('Focused', await elToString(el, 1))
 
     await highlightActiveElement.call(this, el)
 
@@ -1852,8 +2186,8 @@ class Playwright extends Helper {
    */
   async grabNumberOfVisibleElements(locator) {
     let els = await this._locate(locator)
-    els = await Promise.all(els.map((el) => el.isVisible()))
-    return els.filter((v) => v).length
+    els = await Promise.all(els.map(el => el.isVisible()))
+    return els.filter(v => v).length
   }
 
   /**
@@ -1963,9 +2297,7 @@ class Playwright extends Helper {
    */
   async seeNumberOfElements(locator, num) {
     const elements = await this._locate(locator)
-    return equals(
-      `expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`,
-    ).assert(elements.length, num)
+    return equals(`expected number of elements (${new Locator(locator)}) is ${num}, but found ${elements.length}`).assert(elements.length, num)
   }
 
   /**
@@ -1975,10 +2307,7 @@ class Playwright extends Helper {
    */
   async seeNumberOfVisibleElements(locator, num) {
     const res = await this.grabNumberOfVisibleElements(locator)
-    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(
-      res,
-      num,
-    )
+    return equals(`expected number of visible elements (${new Locator(locator)}) is ${num}, but found ${res}`).assert(res, num)
   }
 
   /**
@@ -1997,7 +2326,7 @@ class Playwright extends Helper {
    */
   async seeCookie(name) {
     const cookies = await this.browserContext.cookies()
-    empty(`cookie ${name} to be set`).negate(cookies.filter((c) => c.name === name))
+    empty(`cookie ${name} to be set`).negate(cookies.filter(c => c.name === name))
   }
 
   /**
@@ -2005,7 +2334,7 @@ class Playwright extends Helper {
    */
   async dontSeeCookie(name) {
     const cookies = await this.browserContext.cookies()
-    empty(`cookie ${name} not to be set`).assert(cookies.filter((c) => c.name === name))
+    empty(`cookie ${name} not to be set`).assert(cookies.filter(c => c.name === name))
   }
 
   /**
@@ -2014,19 +2343,31 @@ class Playwright extends Helper {
    * {{> grabCookie }}
    */
   async grabCookie(name) {
-    const cookies = await this.browserContext.cookies()
-    if (!name) return cookies
-    const cookie = cookies.filter((c) => c.name === name)
-    if (cookie[0]) return cookie[0]
+    if (!this.browserContext) {
+      throw new Error('Browser context is not available for grabCookie')
+    }
+
+    try {
+      const cookies = await this.browserContext.cookies()
+      if (!name) return cookies
+      const cookie = cookies.filter(c => c.name === name)
+      if (cookie[0]) return cookie[0]
+    } catch (err) {
+      if (err.message.includes('Target page, context or browser has been closed') || err.message.includes('Browser has been closed')) {
+        throw new Error('Cannot grab cookies: browser context has been closed')
+      }
+      throw err
+    }
   }
 
   /**
    * {{> clearCookie }}
    */
-  async clearCookie() {
-    // Playwright currently doesn't support to delete a certain cookie
-    // https://github.com/microsoft/playwright/blob/main/docs/src/api/class-browsercontext.md#async-method-browsercontextclearcookies
+  async clearCookie(cookieName) {
     if (!this.browserContext) return
+    if (cookieName) {
+      return this.browserContext.clearCookies({ name: cookieName })
+    }
     return this.browserContext.clearCookies()
   }
 
@@ -2083,9 +2424,28 @@ class Playwright extends Helper {
    *
    */
   async grabTextFrom(locator) {
-    locator = this._contextLocator(locator)
-    const text = await this.page.textContent(locator)
-    assertElementExists(text, locator)
+    const originalLocator = locator
+    const matchedLocator = new Locator(locator)
+
+    if (!matchedLocator.isFuzzy()) {
+      const els = await this._locate(matchedLocator)
+      assertElementExists(els, locator)
+      const text = await els[0].innerText()
+      this.debugSection('Text', text)
+      return text
+    }
+
+    const contextAwareLocator = this._contextLocator(matchedLocator.value)
+    let text
+    try {
+      text = await this.page.textContent(contextAwareLocator)
+    } catch (err) {
+      if (err.message.includes('Timeout') || err.message.includes('exceeded')) {
+        throw new Error(`Element ${new Locator(originalLocator).toString()} was not found by text|CSS|XPath`)
+      }
+      throw err
+    }
+    assertElementExists(text, contextAwareLocator)
     this.debugSection('Text', text)
     return text
   }
@@ -2098,7 +2458,7 @@ class Playwright extends Helper {
     const els = await this._locate(locator)
     const texts = []
     for (const el of els) {
-      texts.push(await await el.innerText())
+      texts.push(await el.innerText())
     }
     this.debug(`Matched ${els.length} elements`)
     return texts
@@ -2120,7 +2480,7 @@ class Playwright extends Helper {
   async grabValueFromAll(locator) {
     const els = await findFields.call(this, locator)
     this.debug(`Matched ${els.length} elements`)
-    return Promise.all(els.map((el) => el.inputValue()))
+    return Promise.all(els.map(el => el.inputValue()))
   }
 
   /**
@@ -2139,7 +2499,7 @@ class Playwright extends Helper {
   async grabHTMLFromAll(locator) {
     const els = await this._locate(locator)
     this.debug(`Matched ${els.length} elements`)
-    return Promise.all(els.map((el) => el.innerHTML()))
+    return Promise.all(els.map(el => el.innerHTML()))
   }
 
   /**
@@ -2160,11 +2520,7 @@ class Playwright extends Helper {
   async grabCssPropertyFromAll(locator, cssProperty) {
     const els = await this._locate(locator)
     this.debug(`Matched ${els.length} elements`)
-    const cssValues = await Promise.all(
-      els.map((el) =>
-        el.evaluate((el, cssProperty) => getComputedStyle(el).getPropertyValue(cssProperty), cssProperty),
-      ),
-    )
+    const cssValues = await Promise.all(els.map(el => el.evaluate((el, cssProperty) => getComputedStyle(el).getPropertyValue(cssProperty), cssProperty)))
 
     return cssValues
   }
@@ -2192,19 +2548,16 @@ class Playwright extends Helper {
       }
     }
 
-    const values = Object.keys(cssPropertiesCamelCase).map((key) => cssPropertiesCamelCase[key])
+    const values = Object.keys(cssPropertiesCamelCase).map(key => cssPropertiesCamelCase[key])
     if (!Array.isArray(props)) props = [props]
     let chunked = chunkArray(props, values.length)
-    chunked = chunked.filter((val) => {
+    chunked = chunked.filter(val => {
       for (let i = 0; i < val.length; ++i) {
-        // eslint-disable-next-line eqeqeq
         if (val[i] != values[i]) return false
       }
       return true
     })
-    return equals(
-      `all elements (${new Locator(locator)}) to have CSS property ${JSON.stringify(cssProperties)}`,
-    ).assert(chunked.length, elemAmount)
+    return equals(`all elements (${new Locator(locator)}) to have CSS property ${JSON.stringify(cssProperties)}`).assert(chunked.length, elemAmount)
   }
 
   /**
@@ -2217,16 +2570,16 @@ class Playwright extends Helper {
 
     const elemAmount = res.length
     const commands = []
-    res.forEach((el) => {
-      Object.keys(attributes).forEach((prop) => {
+    res.forEach(el => {
+      Object.keys(attributes).forEach(prop => {
         commands.push(el.evaluate((el, attr) => el[attr] || el.getAttribute(attr), prop))
       })
     })
     let attrs = await Promise.all(commands)
-    const values = Object.keys(attributes).map((key) => attributes[key])
+    const values = Object.keys(attributes).map(key => attributes[key])
     if (!Array.isArray(attrs)) attrs = [attrs]
     let chunked = chunkArray(attrs, values.length)
-    chunked = chunked.filter((val) => {
+    chunked = chunked.filter(val => {
       for (let i = 0; i < val.length; ++i) {
         // the attribute could be a boolean
         if (typeof val[i] === 'boolean') return val[i] === values[i]
@@ -2235,10 +2588,7 @@ class Playwright extends Helper {
       }
       return true
     })
-    return equals(`all elements (${new Locator(locator)}) to have attributes ${JSON.stringify(attributes)}`).assert(
-      chunked.length,
-      elemAmount,
-    )
+    return equals(`all elements (${new Locator(locator)}) to have attributes ${JSON.stringify(attributes)}`).assert(chunked.length, elemAmount)
   }
 
   /**
@@ -2297,11 +2647,16 @@ class Playwright extends Helper {
   async saveElementScreenshot(locator, fileName) {
     const outputFile = screenshotOutputFolder(fileName)
 
-    const res = await this._locateElement(locator)
-    assertElementExists(res, locator)
-    const elem = res
-    this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
-    return elem.screenshot({ path: outputFile, type: 'png' })
+    try {
+      const res = await this._locateElement(locator)
+      assertElementExists(res, locator)
+      const elem = res
+      this.debug(`Screenshot of ${new Locator(locator)} element has been saved to ${outputFile}`)
+      return elem.screenshot({ path: outputFile, type: 'png' })
+    } catch (err) {
+      this.debug(`Failed to take element screenshot: ${err.message}`)
+      throw err
+    }
   }
 
   /**
@@ -2311,27 +2666,72 @@ class Playwright extends Helper {
     const fullPageOption = fullPage || this.options.fullPageScreenshots
     let outputFile = screenshotOutputFolder(fileName)
 
-    this.debug(`Screenshot is saving to ${outputFile}`)
+    this.debugSection('Screenshot', relativeDir(outputFile))
 
-    await this.page.screenshot({
-      path: outputFile,
-      fullPage: fullPageOption,
-      type: 'png',
-    })
+    if (!this.page || !this.browser || !this.browserContext) {
+      this.debug(`Cannot take screenshot: page=${!!this.page}, browser=${!!this.browser}, browserContext=${!!this.browserContext}`)
+      return
+    }
+    if (this.page.isClosed && this.page.isClosed()) {
+      this.debug('Cannot take screenshot: page is closed')
+      return
+    }
+
+    try {
+      await Promise.race([
+        this.page.screenshot({
+          path: outputFile,
+          fullPage: fullPageOption,
+          type: 'png',
+        }),
+        new Promise((_, reject) => setTimeout(() => reject(new Error('Screenshot timeout')), 5000)),
+      ])
+    } catch (err) {
+      this.debug(`Failed to take screenshot: ${err.message}`)
+
+      this.hasCleanupError = true
+      this.testFailures.push(`Screenshot failed: ${err.message}`)
+
+      if (err.message.includes('closed') || err.message.includes('Protocol error') || err.message.includes('timeout')) {
+        this.debug('Screenshot failed due to browser/page closure or timeout, continuing...')
+        return
+      }
+      throw err
+    }
 
-    if (this.activeSessionName) {
+    // Handle session screenshots for ALL sessions, not just active one
+    if (this.sessionPages && Object.keys(this.sessionPages).length > 0) {
       for (const sessionName in this.sessionPages) {
-        const activeSessionPage = this.sessionPages[sessionName]
+        const sessionPage = this.sessionPages[sessionName]
         outputFile = screenshotOutputFolder(`${sessionName}_${fileName}`)
 
-        this.debug(`${sessionName} - Screenshot is saving to ${outputFile}`)
+        this.debugSection('Screenshot', `${sessionName} - ${relativeDir(outputFile)}`)
 
-        if (activeSessionPage) {
-          await activeSessionPage.screenshot({
-            path: outputFile,
-            fullPage: fullPageOption,
-            type: 'png',
-          })
+        try {
+          // Add timeout protection for session screenshots
+          await Promise.race([
+            (async () => {
+              if (sessionPage && !sessionPage.isClosed()) {
+                await sessionPage.screenshot({
+                  path: outputFile,
+                  fullPage: fullPageOption,
+                  type: 'png',
+                })
+              } else {
+                this.debug(`Cannot take session screenshot: session page for '${sessionName}' is closed or undefined`)
+              }
+            })(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Session screenshot timeout')), 3000)),
+          ])
+        } catch (err) {
+          this.debug(`Failed to take session screenshot for '${sessionName}': ${err.message}`)
+
+          // Track session screenshot failures
+          this.hasCleanupError = true
+          this.testFailures.push(`Session screenshot failed for '${sessionName}': ${err.message}`)
+
+          // Don't throw here - main screenshot was successful and we don't want to hang
+          // Just log and continue
         }
       }
     }
@@ -2358,9 +2758,7 @@ class Playwright extends Helper {
     method = method.toLowerCase()
     const allowedMethods = ['get', 'post', 'patch', 'head', 'fetch', 'delete']
     if (!allowedMethods.includes(method)) {
-      throw new Error(
-        `Method ${method} is not allowed, use the one from a list ${allowedMethods} or switch to using REST helper`,
-      )
+      throw new Error(`Method ${method} is not allowed, use the one from a list ${allowedMethods} or switch to using REST helper`)
     }
 
     if (url.startsWith('/')) {
@@ -2397,10 +2795,7 @@ class Playwright extends Helper {
     if (this.options.recordVideo && this.page && this.page.video()) {
       test.artifacts.video = saveVideoForPage(this.page, `${test.title}.failed`)
       for (const sessionName in this.sessionPages) {
-        test.artifacts[`video_${sessionName}`] = saveVideoForPage(
-          this.sessionPages[sessionName],
-          `${test.title}_${sessionName}.failed`,
-        )
+        test.artifacts[`video_${sessionName}`] = saveVideoForPage(this.sessionPages[sessionName], `${test.title}_${sessionName}.failed`)
       }
     }
 
@@ -2408,10 +2803,7 @@ class Playwright extends Helper {
       test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.failed`)
       for (const sessionName in this.sessionPages) {
         if (!this.sessionPages[sessionName].context) continue
-        test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(
-          this.sessionPages[sessionName].context,
-          `${test.title}_${sessionName}.failed`,
-        )
+        test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(this.sessionPages[sessionName].context, `${test.title}_${sessionName}.failed`)
       }
     }
 
@@ -2425,16 +2817,13 @@ class Playwright extends Helper {
       if (this.options.keepVideoForPassedTests) {
         test.artifacts.video = saveVideoForPage(this.page, `${test.title}.passed`)
         for (const sessionName of Object.keys(this.sessionPages)) {
-          test.artifacts[`video_${sessionName}`] = saveVideoForPage(
-            this.sessionPages[sessionName],
-            `${test.title}_${sessionName}.passed`,
-          )
+          test.artifacts[`video_${sessionName}`] = saveVideoForPage(this.sessionPages[sessionName], `${test.title}_${sessionName}.passed`)
         }
       } else {
         this.page
           .video()
           .delete()
-          .catch((e) => {})
+          .catch(e => {})
       }
     }
 
@@ -2444,10 +2833,7 @@ class Playwright extends Helper {
           test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.passed`)
           for (const sessionName in this.sessionPages) {
             if (!this.sessionPages[sessionName].context) continue
-            test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(
-              this.sessionPages[sessionName].context,
-              `${test.title}_${sessionName}.passed`,
-            )
+            test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(this.sessionPages[sessionName].context, `${test.title}_${sessionName}.passed`)
           }
         }
       } else {
@@ -2464,7 +2850,7 @@ class Playwright extends Helper {
    * {{> wait }}
    */
   async wait(sec) {
-    return new Promise((done) => {
+    return new Promise(done => {
       setTimeout(done, sec * 1000)
     })
   }
@@ -2480,20 +2866,18 @@ class Playwright extends Helper {
     const context = await this._getContext()
     if (!locator.isXPath()) {
       const valueFn = function ([locator]) {
-        return Array.from(document.querySelectorAll(locator)).filter((el) => !el.disabled).length > 0
+        return Array.from(document.querySelectorAll(locator)).filter(el => !el.disabled).length > 0
       }
       waiter = context.waitForFunction(valueFn, [locator.value], { timeout: waitTimeout })
     } else {
       const enabledFn = function ([locator, $XPath]) {
-        eval($XPath) // eslint-disable-line no-eval
-        return $XPath(null, locator).filter((el) => !el.disabled).length > 0
+        eval($XPath)
+        return $XPath(null, locator).filter(el => !el.disabled).length > 0
       }
       waiter = context.waitForFunction(enabledFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
     }
-    return waiter.catch((err) => {
-      throw new Error(
-        `element (${locator.toString()}) still not enabled after ${waitTimeout / 1000} sec\n${err.message}`,
-      )
+    return waiter.catch(err => {
+      throw new Error(`element (${locator.toString()}) still not enabled after ${waitTimeout / 1000} sec\n${err.message}`)
     })
   }
 
@@ -2508,20 +2892,18 @@ class Playwright extends Helper {
     const context = await this._getContext()
     if (!locator.isXPath()) {
       const valueFn = function ([locator]) {
-        return Array.from(document.querySelectorAll(locator)).filter((el) => el.disabled).length > 0
+        return Array.from(document.querySelectorAll(locator)).filter(el => el.disabled).length > 0
       }
       waiter = context.waitForFunction(valueFn, [locator.value], { timeout: waitTimeout })
     } else {
       const disabledFn = function ([locator, $XPath]) {
-        eval($XPath) // eslint-disable-line no-eval
-        return $XPath(null, locator).filter((el) => el.disabled).length > 0
+        eval($XPath)
+        return $XPath(null, locator).filter(el => el.disabled).length > 0
       }
       waiter = context.waitForFunction(disabledFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
     }
-    return waiter.catch((err) => {
-      throw new Error(
-        `element (${locator.toString()}) is still enabled after ${waitTimeout / 1000} sec\n${err.message}`,
-      )
+    return waiter.catch(err => {
+      throw new Error(`element (${locator.toString()}) is still enabled after ${waitTimeout / 1000} sec\n${err.message}`)
     })
   }
 
@@ -2536,26 +2918,21 @@ class Playwright extends Helper {
     const context = await this._getContext()
     if (!locator.isXPath()) {
       const valueFn = function ([locator, value]) {
-        return (
-          Array.from(document.querySelectorAll(locator)).filter((el) => (el.value || '').indexOf(value) !== -1).length >
-          0
-        )
+        return Array.from(document.querySelectorAll(locator)).filter(el => (el.value || '').indexOf(value) !== -1).length > 0
       }
       waiter = context.waitForFunction(valueFn, [locator.value, value], { timeout: waitTimeout })
     } else {
       const valueFn = function ([locator, $XPath, value]) {
-        eval($XPath) // eslint-disable-line no-eval
-        return $XPath(null, locator).filter((el) => (el.value || '').indexOf(value) !== -1).length > 0
+        eval($XPath)
+        return $XPath(null, locator).filter(el => (el.value || '').indexOf(value) !== -1).length > 0
       }
       waiter = context.waitForFunction(valueFn, [locator.value, $XPath.toString(), value], {
         timeout: waitTimeout,
       })
     }
-    return waiter.catch((err) => {
+    return waiter.catch(err => {
       const loc = locator.toString()
-      throw new Error(
-        `element (${loc}) is not in DOM or there is no element(${loc}) with value "${value}" after ${waitTimeout / 1000} sec\n${err.message}`,
-      )
+      throw new Error(`element (${loc}) is not in DOM or there is no element(${loc}) with value "${value}" after ${waitTimeout / 1000} sec\n${err.message}`)
     })
   }
 
@@ -2575,22 +2952,20 @@ class Playwright extends Helper {
         if (!els || els.length === 0) {
           return false
         }
-        return Array.prototype.filter.call(els, (el) => el.offsetParent !== null).length === num
+        return Array.prototype.filter.call(els, el => el.offsetParent !== null).length === num
       }
       waiter = context.waitForFunction(visibleFn, [locator.value, num], { timeout: waitTimeout })
     } else {
       const visibleFn = function ([locator, $XPath, num]) {
-        eval($XPath) // eslint-disable-line no-eval
-        return $XPath(null, locator).filter((el) => el.offsetParent !== null).length === num
+        eval($XPath)
+        return $XPath(null, locator).filter(el => el.offsetParent !== null).length === num
       }
       waiter = context.waitForFunction(visibleFn, [locator.value, $XPath.toString(), num], {
         timeout: waitTimeout,
       })
     }
-    return waiter.catch((err) => {
-      throw new Error(
-        `The number of elements (${locator.toString()}) is not ${num} after ${waitTimeout / 1000} sec\n${err.message}`,
-      )
+    return waiter.catch(err => {
+      throw new Error(`The number of elements (${locator.toString()}) is not ${num} after ${waitTimeout / 1000} sec\n${err.message}`)
     })
   }
 
@@ -2598,9 +2973,7 @@ class Playwright extends Helper {
    * {{> waitForClickable }}
    */
   async waitForClickable(locator, waitTimeout) {
-    console.log(
-      'I.waitForClickable is DEPRECATED: This is no longer needed, Playwright automatically waits for element to be clickable',
-    )
+    console.log('I.waitForClickable is DEPRECATED: This is no longer needed, Playwright automatically waits for element to be clickable')
     console.log('Remove usage of this function')
   }
 
@@ -2616,9 +2989,7 @@ class Playwright extends Helper {
     try {
       await context.locator(buildLocatorString(locator)).first().waitFor({ timeout: waitTimeout, state: 'attached' })
     } catch (e) {
-      throw new Error(
-        `element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${e.message}`,
-      )
+      throw new Error(`element (${locator.toString()}) still not present on page after ${waitTimeout / 1000} sec\n${e.message}`)
     }
   }
 
@@ -2710,10 +3081,8 @@ class Playwright extends Helper {
       .locator(buildLocatorString(locator))
       .first()
       .waitFor({ timeout: waitTimeout, state: 'hidden' })
-      .catch((err) => {
-        throw new Error(
-          `element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`,
-        )
+      .catch(err => {
+        throw new Error(`element (${locator.toString()}) still not hidden after ${waitTimeout / 1000} sec\n${err.message}`)
       })
   }
 
@@ -2739,6 +3108,9 @@ class Playwright extends Helper {
     if ((this.context && this.context.constructor.name === 'FrameLocator') || this.context) {
       return this.context
     }
+    if (this.frame) {
+      return this.frame
+    }
     return this.page
   }
 
@@ -2750,14 +3122,14 @@ class Playwright extends Helper {
 
     return this.page
       .waitForFunction(
-        (urlPart) => {
+        urlPart => {
           const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
           return currUrl.indexOf(urlPart) > -1
         },
         urlPart,
         { timeout: waitTimeout },
       )
-      .catch(async (e) => {
+      .catch(async e => {
         const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
         if (/Timeout/i.test(e.message)) {
           throw new Error(`expected url to include ${urlPart}, but found ${currUrl}`)
@@ -2780,14 +3152,14 @@ class Playwright extends Helper {
 
     return this.page
       .waitForFunction(
-        (urlPart) => {
+        urlPart => {
           const currUrl = decodeURIComponent(decodeURIComponent(decodeURIComponent(window.location.href)))
           return currUrl.indexOf(urlPart) > -1
         },
         urlPart,
         { timeout: waitTimeout },
       )
-      .catch(async (e) => {
+      .catch(async e => {
         const currUrl = await this._getPageUrl() // Required because the waitForFunction can't return data.
         if (/Timeout/i.test(e.message)) {
           throw new Error(`expected url to be ${urlPart}, but found ${currUrl}`)
@@ -2803,28 +3175,23 @@ class Playwright extends Helper {
   async waitForText(text, sec = null, context = null) {
     const waitTimeout = sec ? sec * 1000 : this.options.waitForTimeout
     const errorMessage = `Text "${text}" was not found on page after ${waitTimeout / 1000} sec.`
-    let waiter
 
     const contextObject = await this._getContext()
 
     if (context) {
       const locator = new Locator(context, 'css')
-      if (!locator.isXPath()) {
-        try {
-          await contextObject
+      try {
+        if (!locator.isXPath()) {
+          return contextObject
             .locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()} >> text=${text}`)
             .first()
             .waitFor({ timeout: waitTimeout, state: 'visible' })
-        } catch (e) {
-          throw new Error(`${errorMessage}\n${e.message}`)
         }
-      }
 
-      if (locator.isXPath()) {
-        try {
-          await contextObject.waitForFunction(
+        if (locator.isXPath()) {
+          return contextObject.waitForFunction(
             ([locator, text, $XPath]) => {
-              eval($XPath) // eslint-disable-line no-eval
+              eval($XPath)
               const el = $XPath(null, locator)
               if (!el.length) return false
               return el[0].innerText.indexOf(text) > -1
@@ -2832,27 +3199,34 @@ class Playwright extends Helper {
             [locator.value, text, $XPath.toString()],
             { timeout: waitTimeout },
           )
-        } catch (e) {
-          throw new Error(`${errorMessage}\n${e.message}`)
         }
+      } catch (e) {
+        throw new Error(`${errorMessage}\n${e.message}`)
       }
-    } else {
-      // we have this as https://github.com/microsoft/playwright/issues/26829 is not yet implemented
-
-      const _contextObject = this.frame ? this.frame : contextObject
-      let count = 0
-      do {
-        waiter = await _contextObject
-          .locator(`:has-text(${JSON.stringify(text)})`)
-          .first()
-          .isVisible()
-        if (waiter) break
-        await this.wait(1)
-        count += 1000
-      } while (count <= waitTimeout)
-
-      if (!waiter) throw new Error(`${errorMessage}`)
     }
+
+    const timeoutGap = waitTimeout + 1000
+
+    // We add basic timeout to make sure we don't wait forever
+    // We apply 2 strategies here: wait for text as innert text on page (wide strategy) - older
+    // or we use native Playwright matcher to wait for text in element (narrow strategy) - newer
+    // If a user waits for text on a page they are mostly expect it to be there, so wide strategy can be helpful even PW strategy is available
+    return Promise.race([
+      new Promise((_, reject) => {
+        setTimeout(() => reject(errorMessage), waitTimeout)
+      }),
+      this.page.waitForFunction(text => document.body && document.body.innerText.indexOf(text) > -1, text, { timeout: timeoutGap }),
+      promiseRetry(
+        async retry => {
+          const textPresent = await contextObject
+            .locator(`:has-text(${JSON.stringify(text)})`)
+            .first()
+            .isVisible()
+          if (!textPresent) retry(errorMessage)
+        },
+        { retries: 1000, minTimeout: 500, maxTimeout: 500, factor: 1 },
+      ),
+    ])
   }
 
   /**
@@ -2902,8 +3276,13 @@ class Playwright extends Helper {
       }
 
       if (locator >= 0 && locator < childFrames.length) {
-        this.context = await this.page.frameLocator('iframe').nth(locator)
-        this.contextLocator = locator
+        try {
+          this.context = await Promise.race([this.page.frameLocator('iframe').nth(locator), new Promise((_, reject) => setTimeout(() => reject(new Error('Frame locator timeout')), 5000))])
+          this.contextLocator = locator
+        } catch (e) {
+          console.warn('Warning during frame selection:', e.message)
+          throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath')
+        }
       } else {
         throw new Error('Element #invalidIframeSelector was not found by text|CSS|XPath')
       }
@@ -2919,16 +3298,25 @@ class Playwright extends Helper {
 
     // iframe by selector
     locator = buildLocatorString(new Locator(locator, 'css'))
-    const frame = await this._locateElement(locator)
+
+    let frame
+    try {
+      frame = await Promise.race([this._locateElement(locator), new Promise((_, reject) => setTimeout(() => reject(new Error('Locate frame timeout')), 5000))])
+    } catch (e) {
+      console.warn('Warning during frame location:', e.message)
+      frame = null
+    }
 
     if (!frame) {
       throw new Error(`Frame ${JSON.stringify(locator)} was not found by text|CSS|XPath`)
     }
 
-    if (this.frame) {
-      this.frame = await this.frame.frameLocator(locator)
-    } else {
-      this.frame = await this.page.frameLocator(locator)
+    try {
+      // Always create frame locator from page to avoid nested frame paths
+      this.frame = await Promise.race([this.page.frameLocator(locator), new Promise((_, reject) => setTimeout(() => reject(new Error('Frame locator timeout')), 5000))])
+    } catch (e) {
+      console.warn('Warning during frame locator creation:', e.message)
+      throw new Error(`Frame ${JSON.stringify(locator)} could not be accessed`)
     }
 
     const contentFrame = this.frame
@@ -2937,8 +3325,14 @@ class Playwright extends Helper {
       this.context = contentFrame
       this.contextLocator = null
     } else {
-      this.context = this.page.frame(this.page.frames()[1].name())
-      this.contextLocator = locator
+      try {
+        this.context = this.page.frame(this.page.frames()[1].name())
+        this.contextLocator = locator
+      } catch (e) {
+        console.warn('Warning during frame context setup:', e.message)
+        this.context = this.page
+        this.contextLocator = null
+      }
     }
   }
 
@@ -3021,11 +3415,11 @@ class Playwright extends Helper {
       }
     } else {
       const visibleFn = function ([locator, $XPath]) {
-        eval($XPath) // eslint-disable-line no-eval
+        eval($XPath)
         return $XPath(null, locator).length === 0
       }
       waiter = context.waitForFunction(visibleFn, [locator.value, $XPath.toString()], { timeout: waitTimeout })
-      return waiter.catch((err) => {
+      return waiter.catch(err => {
         throw new Error(`element (${locator.toString()}) still on page after ${waitTimeout / 1000} sec\n${err.message}`)
       })
     }
@@ -3047,9 +3441,9 @@ class Playwright extends Helper {
 
     return promiseRetry(
       async (retry, number) => {
-        const _grabCookie = async (name) => {
+        const _grabCookie = async name => {
           const cookies = await this.browserContext.cookies()
-          const cookie = cookies.filter((c) => c.name === name)
+          const cookie = cookies.filter(c => c.name === name)
           if (cookie.length === 0) throw Error(`Cookie ${name} is not found after ${retries}s`)
         }
 
@@ -3128,7 +3522,7 @@ class Playwright extends Helper {
     this.recording = true
     this.recordedAtLeastOnce = true
 
-    this.page.on('requestfinished', async (request) => {
+    this.page.on('requestfinished', async request => {
       const information = {
         url: request.url(),
         method: request.method(),
@@ -3167,20 +3561,20 @@ class Playwright extends Helper {
    */
   blockTraffic(urls) {
     if (Array.isArray(urls)) {
-      urls.forEach((url) => {
-        this.page.route(url, (route) => {
+      urls.forEach(url => {
+        this.page.route(url, route => {
           route
             .abort()
             // Sometimes it happens that browser has been closed in the meantime. It is ok to ignore error then.
-            .catch((e) => {})
+            .catch(e => {})
         })
       })
     } else {
-      this.page.route(urls, (route) => {
+      this.page.route(urls, route => {
         route
           .abort()
           // Sometimes it happens that browser has been closed in the meantime. It is ok to ignore error then.
-          .catch((e) => {})
+          .catch(e => {})
       })
     }
   }
@@ -3209,8 +3603,8 @@ class Playwright extends Helper {
       urls = [urls]
     }
 
-    urls.forEach((url) => {
-      this.page.route(url, (route) => {
+    urls.forEach(url => {
+      this.page.route(url, route => {
         if (this.page.isClosed()) {
           // Sometimes it happens that browser has been closed in the meantime.
           // In this case we just don't fulfill to prevent error in test scenario.
@@ -3256,13 +3650,10 @@ class Playwright extends Helper {
    */
   grabTrafficUrl(urlMatch) {
     if (!this.recordedAtLeastOnce) {
-      throw new Error(
-        'Failure in test automation. You use "I.grabTrafficUrl", but "I.startRecordingTraffic" was never called before.',
-      )
+      throw new Error('Failure in test automation. You use "I.grabTrafficUrl", but "I.startRecordingTraffic" was never called before.')
     }
 
     for (const i in this.requests) {
-      // eslint-disable-next-line no-prototype-builtins
       if (this.requests.hasOwnProperty(i)) {
         const request = this.requests[i]
 
@@ -3312,15 +3703,15 @@ class Playwright extends Helper {
     await this.cdpSession.send('Network.enable')
     await this.cdpSession.send('Page.enable')
 
-    this.cdpSession.on('Network.webSocketFrameReceived', (payload) => {
+    this.cdpSession.on('Network.webSocketFrameReceived', payload => {
       this._logWebsocketMessages(this._getWebSocketLog('RECEIVED', payload))
     })
 
-    this.cdpSession.on('Network.webSocketFrameSent', (payload) => {
+    this.cdpSession.on('Network.webSocketFrameSent', payload => {
       this._logWebsocketMessages(this._getWebSocketLog('SENT', payload))
     })
 
-    this.cdpSession.on('Network.webSocketFrameError', (payload) => {
+    this.cdpSession.on('Network.webSocketFrameError', payload => {
       this._logWebsocketMessages(this._getWebSocketLog('ERROR', payload))
     })
   }
@@ -3344,9 +3735,7 @@ class Playwright extends Helper {
   grabWebSocketMessages() {
     if (!this.recordingWebSocketMessages) {
       if (!this.recordedWebSocketMessagesAtLeastOnce) {
-        throw new Error(
-          'Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.',
-        )
+        throw new Error('Failure in test automation. You use "I.grabWebSocketMessages", but "I.startRecordingWebSocketMessages" was never called before.')
       }
     }
     return this.webSocketMessages
@@ -3441,48 +3830,7 @@ class Playwright extends Helper {
   }
 }
 
-module.exports = Playwright
-
-function buildLocatorString(locator) {
-  if (locator.isCustom()) {
-    return `${locator.type}=${locator.value}`
-  }
-  if (locator.isXPath()) {
-    return `xpath=${locator.value}`
-  }
-  return locator.simplify()
-}
-
-async function findElements(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator)
-  if (locator.vue) return findVue(matcher, locator)
-  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
-  locator = new Locator(locator, 'css')
-
-  return matcher.locator(buildLocatorString(locator)).all()
-}
-
-async function findElement(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator)
-  if (locator.vue) return findVue(matcher, locator)
-  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
-  locator = new Locator(locator, 'css')
-
-  return matcher.locator(buildLocatorString(locator)).first()
-}
-
-async function getVisibleElements(elements) {
-  const visibleElements = []
-  for (const element of elements) {
-    if (await element.isVisible()) {
-      visibleElements.push(element)
-    }
-  }
-  if (visibleElements.length === 0) {
-    return elements
-  }
-  return visibleElements
-}
+export default Playwright
 
 async function proceedClick(locator, context = null, options = {}) {
   let matcher = await this._getContext()
@@ -3493,17 +3841,13 @@ async function proceedClick(locator, context = null, options = {}) {
   }
   const els = await findClickable.call(this, matcher, locator)
   if (context) {
-    assertElementExists(
-      els,
-      locator,
-      'Clickable element',
-      `was not found inside element ${new Locator(context).toString()}`,
-    )
+    assertElementExists(els, locator, 'Clickable element', `was not found inside element ${new Locator(context).toString()}`)
   } else {
     assertElementExists(els, locator, 'Clickable element')
   }
 
   await highlightActiveElement.call(this, els[0])
+  if (store.debugMode) this.debugSection('Clicked', await elToString(els[0], 1))
 
   /*
     using the force true options itself but instead dispatching a click
@@ -3524,15 +3868,26 @@ async function proceedClick(locator, context = null, options = {}) {
 }
 
 async function findClickable(matcher, locator) {
-  if (locator.react) return findReact(matcher, locator)
-  if (locator.vue) return findVue(matcher, locator)
-  if (locator.pw) return findByPlaywrightLocator.call(this, matcher, locator)
+  const matchedLocator = new Locator(locator)
 
-  locator = new Locator(locator)
-  if (!locator.isFuzzy()) return findElements.call(this, matcher, locator)
+  if (!matchedLocator.isFuzzy()) return findElements.call(this, matcher, matchedLocator)
 
   let els
-  const literal = xpathLocator.literal(locator.value)
+  const literal = xpathLocator.literal(matchedLocator.value)
+
+  try {
+    els = await matcher.getByRole('button', { name: matchedLocator.value }).all()
+    if (els.length) return els
+  } catch (err) {
+    // getByRole not supported or failed
+  }
+
+  try {
+    els = await matcher.getByRole('link', { name: matchedLocator.value }).all()
+    if (els.length) return els
+  } catch (err) {
+    // getByRole not supported or failed
+  }
 
   els = await findElements.call(this, matcher, Locator.clickable.narrow(literal))
   if (els.length) return els
@@ -3547,7 +3902,7 @@ async function findClickable(matcher, locator) {
     // Do nothing
   }
 
-  return findElements.call(this, matcher, locator.value) // by css or xpath
+  return findElements.call(this, matcher, matchedLocator.value) // by css or xpath
 }
 
 async function proceedSee(assertType, text, context, strict = false) {
@@ -3565,16 +3920,18 @@ async function proceedSee(assertType, text, context, strict = false) {
     description = `element ${locator.toString()}`
     const els = await this._locate(locator)
     assertElementExists(els, locator.toString())
-    allText = await Promise.all(els.map((el) => el.innerText()))
+    allText = await Promise.all(els.map(el => el.innerText()))
+  }
+
+  if (store?.currentStep?.opts?.ignoreCase === true) {
+    text = text.toLowerCase()
+    allText = allText.map(elText => elText.toLowerCase())
   }
 
   if (strict) {
-    return allText.map((elText) => equals(description)[assertType](text, elText))
+    return allText.map(elText => equals(description)[assertType](text, elText))
   }
-  return stringIncludes(description)[assertType](
-    normalizeSpacesInString(text),
-    normalizeSpacesInString(allText.join(' | ')),
-  )
+  return stringIncludes(description)[assertType](normalizeSpacesInString(text), normalizeSpacesInString(allText.join(' | ')))
 }
 
 async function findCheckable(locator, context) {
@@ -3586,10 +3943,10 @@ async function findCheckable(locator, context) {
 
   const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
-    return findElements.call(this, contextEl, matchedLocator.simplify())
+    return findElements.call(this, contextEl, matchedLocator)
   }
 
-  const literal = xpathLocator.literal(locator)
+  const literal = xpathLocator.literal(matchedLocator.value)
   let els = await findElements.call(this, contextEl, Locator.checkable.byText(literal))
   if (els.length) {
     return els
@@ -3598,13 +3955,13 @@ async function findCheckable(locator, context) {
   if (els.length) {
     return els
   }
-  return findElements.call(this, contextEl, locator)
+  return findElements.call(this, contextEl, matchedLocator.value)
 }
 
 async function proceedIsChecked(assertType, option) {
   let els = await findCheckable.call(this, option)
   assertElementExists(els, option, 'Checkable')
-  els = await Promise.all(els.map((el) => el.isChecked()))
+  els = await Promise.all(els.map(el => el.isChecked()))
   const selected = els.reduce((prev, cur) => prev || cur)
   return truth(`checkable ${option}`, 'to be checked')[assertType](selected)
 }
@@ -3636,10 +3993,10 @@ async function proceedSeeInField(assertType, field, value) {
   const els = await findFields.call(this, field)
   assertElementExists(els, field, 'Field')
   const el = els[0]
-  const tag = await el.evaluate((e) => e.tagName)
+  const tag = await el.evaluate(e => e.tagName)
   const fieldType = await el.getAttribute('type')
 
-  const proceedMultiple = async (elements) => {
+  const proceedMultiple = async elements => {
     const fields = Array.isArray(elements) ? elements : [elements]
 
     const elementValues = []
@@ -3653,7 +4010,7 @@ async function proceedSeeInField(assertType, field, value) {
       if (assertType === 'assert') {
         equals(`select option by ${field}`)[assertType](true, elementValues.length > 0)
       }
-      elementValues.forEach((val) => stringIncludes(`fields by ${field}`)[assertType](value, val))
+      elementValues.forEach(val => stringIncludes(`fields by ${field}`)[assertType](value, val))
     }
   }
 
@@ -3740,6 +4097,8 @@ function isFrameLocator(locator) {
 }
 
 function assertElementExists(res, locator, prefix, suffix) {
+  // if element text is an empty string, just exit this check
+  if (typeof res === 'string' && res === '') return
   if (!res || res.length === 0) {
     throw new ElementNotFound(locator, prefix, suffix)
   }
@@ -3776,12 +4135,9 @@ async function targetCreatedHandler(page) {
         this.contextLocator = null
       })
   })
-  page.on('console', (msg) => {
+  page.on('console', msg => {
     if (!consoleLogStore.includes(msg) && this.options.ignoreLog && !this.options.ignoreLog.includes(msg.type())) {
-      this.debugSection(
-        `Browser:${ucfirst(msg.type())}`,
-        ((msg.text && msg.text()) || msg._text || '') + msg.args().join(' '),
-      )
+      this.debugSection(`Browser:${ucfirst(msg.type())}`, ((msg.text && msg.text()) || msg._text || '') + msg.args().join(' '))
     }
     consoleLogStore.add(msg)
   })
@@ -3884,36 +4240,67 @@ async function clickablePoint(el) {
 }
 
 async function refreshContextSession() {
-  // close other sessions
+  // close other sessions with timeout protection, but preserve active session contexts
   try {
-    const contexts = await this.browser.contexts()
-    contexts.shift()
+    const contexts = await Promise.race([this.browser.contexts(), new Promise((_, reject) => setTimeout(() => reject(new Error('Get contexts timeout')), 3000))])
+
+    // Keep the first context (default) and any contexts that belong to active sessions
+    const defaultContext = contexts.shift()
+    const activeSessionContexts = new Set()
+
+    // Identify contexts that are still in use by active sessions
+    if (this.sessionPages) {
+      for (const sessionName in this.sessionPages) {
+        const sessionPage = this.sessionPages[sessionName]
+        if (sessionPage && sessionPage.context) {
+          activeSessionContexts.add(sessionPage.context)
+        }
+      }
+    }
+
+    // Only close contexts that are not in use by active sessions
+    const contextsToClose = contexts.filter(context => !activeSessionContexts.has(context))
 
-    await Promise.all(contexts.map((c) => c.close()))
+    if (contextsToClose.length > 0) {
+      await Promise.race([Promise.all(contextsToClose.map(c => c.close())), new Promise((_, reject) => setTimeout(() => reject(new Error('Close contexts timeout')), 5000))])
+    }
   } catch (e) {
-    console.log(e)
+    console.warn('Warning during context cleanup:', e.message)
   }
 
   if (this.page) {
-    const existingPages = await this.browserContext.pages()
-    await this._setPage(existingPages[0])
+    try {
+      const existingPages = await this.browserContext.pages()
+      await this._setPage(existingPages[0])
+    } catch (e) {
+      console.warn('Warning during page setup:', e.message)
+    }
   }
 
   if (this.options.keepBrowserState) return
 
   if (!this.options.keepCookies) {
     this.debugSection('Session', 'cleaning cookies and localStorage')
-    await this.clearCookie()
+    try {
+      await this.clearCookie()
+    } catch (e) {
+      console.warn('Warning during cookie cleanup:', e.message)
+    }
   }
-  const currentUrl = await this.grabCurrentUrl()
 
-  if (currentUrl.startsWith('http')) {
-    await this.executeScript('localStorage.clear();').catch((err) => {
-      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
-    })
-    await this.executeScript('sessionStorage.clear();').catch((err) => {
-      if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
-    })
+  try {
+    const currentUrl = await this.grabCurrentUrl()
+
+    if (currentUrl.startsWith('http')) {
+      await this.executeScript('localStorage.clear();').catch(err => {
+        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+      })
+      await this.executeScript('sessionStorage.clear();').catch(err => {
+        if (!(err.message.indexOf("Storage is disabled inside 'data:' URLs.") > -1)) throw err
+      })
+    }
+  } catch (e) {
+    console.warn('Warning during storage cleanup:', e.message)
   }
 }
 
@@ -3941,11 +4328,22 @@ async function saveTraceForContext(context, name) {
 }
 
 async function highlightActiveElement(element) {
-  if (this.options.highlightElement && global.debugMode) {
-    await element.evaluate((el) => {
+  if ((this.options.highlightElement || store.onPause) && store.debugMode) {
+    await element.evaluate(el => {
       const prevStyle = el.style.boxShadow
-      el.style.boxShadow = '0px 0px 4px 3px rgba(255, 0, 0, 0.7)'
+      el.style.boxShadow = '0px 0px 4px 3px rgba(147, 51, 234, 0.8)' // Bright purple that works on both dark/light modes
       setTimeout(() => (el.style.boxShadow = prevStyle), 2000)
     })
   }
 }
+
+async function elToString(el, numberOfElements) {
+  const html = await el.evaluate(node => node.outerHTML)
+  return (
+    html
+      .replace(/\n/g, '')
+      .replace(/\s+/g, ' ')
+      .substring(0, 100 / numberOfElements)
+      .trim() + '...'
+  )
+}