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

package/lib/helper/Playwright.js

@@ -1,19 +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 store = require('../store')
-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,
@@ -26,14 +24,13 @@ const {
   requireWithFallback,
   normalizeSpacesInString,
   relativeDir,
-} = 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')
-const WebElement = require('../element/WebElement')
+} 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
@@ -43,10 +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
 
@@ -62,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.
@@ -321,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
@@ -345,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)
   }
@@ -455,13 +455,30 @@ class Playwright extends Helper {
 
   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
@@ -475,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()
     }
@@ -484,6 +503,18 @@ 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: test?.opts?.conditionalRetries || 3,
       when: err => {
@@ -495,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
@@ -534,6 +564,14 @@ class Playwright extends Helper {
       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
       }
@@ -577,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
     }
 
@@ -586,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
+      }
     }
 
-    // close other sessions
+    // Force cleanup of any remaining browser processes
     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.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}`)
+    }
+
+    // Clean up session pages explicitly to prevent hanging references
+    try {
+      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() {
@@ -632,13 +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)
               this.browser = browserContext
               page = await browserContext.pages()[0]
+            } else {
+              throw e
             }
           }
         }
@@ -669,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()
       },
@@ -756,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
+    }
   }
 
   /**
@@ -868,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)
@@ -884,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) {
@@ -902,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)
@@ -920,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
   }
@@ -943,6 +1224,12 @@ 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 + (!this.options.url.endsWith('/') && url.startsWith('/') ? url : `/${url}`)
       this.debug(`Changed URL to base url + relative path: ${url}`)
@@ -955,7 +1242,77 @@ 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)))
 
@@ -1111,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 }}
    */
@@ -1342,8 +1679,7 @@ class Playwright extends Helper {
    *
    */
   async grabWebElements(locator) {
-    const elements = await this._locate(locator)
-    return elements.map(element => new WebElement(element, this))
+    return this._locate(locator)
   }
 
   /**
@@ -1351,8 +1687,7 @@ class Playwright extends Helper {
    *
    */
   async grabWebElement(locator) {
-    const element = await this._locateElement(locator)
-    return new WebElement(element, this)
+    return this._locateElement(locator)
   }
 
   /**
@@ -2008,10 +2343,21 @@ 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
+    }
   }
 
   /**
@@ -2078,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
   }
@@ -2282,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
+    }
   }
 
   /**
@@ -2298,25 +2668,70 @@ class Playwright extends Helper {
 
     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
+    }
 
-    if (this.activeSessionName) {
+    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
+    }
+
+    // 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.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
         }
       }
     }
@@ -2380,19 +2795,15 @@ 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) {
-        if (sessionName === '') continue
-        test.artifacts[`video_${sessionName}`] = saveVideoForPage(this.sessionPages[sessionName], `${sessionName}_${test.title}.failed`)
+        test.artifacts[`video_${sessionName}`] = saveVideoForPage(this.sessionPages[sessionName], `${test.title}_${sessionName}.failed`)
       }
     }
 
     if (this.options.trace) {
       test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.failed`)
       for (const sessionName in this.sessionPages) {
-        if (sessionName === '') continue
-        const sessionPage = this.sessionPages[sessionName]
-        const sessionContext = sessionPage.context()
-        if (!sessionContext || !sessionContext.tracing) continue
-        test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(sessionContext, `${sessionName}_${test.title}.failed`)
+        if (!this.sessionPages[sessionName].context) continue
+        test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(this.sessionPages[sessionName].context, `${test.title}_${sessionName}.failed`)
       }
     }
 
@@ -2406,8 +2817,7 @@ 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)) {
-          if (sessionName === '') continue
-          test.artifacts[`video_${sessionName}`] = saveVideoForPage(this.sessionPages[sessionName], `${sessionName}_${test.title}.passed`)
+          test.artifacts[`video_${sessionName}`] = saveVideoForPage(this.sessionPages[sessionName], `${test.title}_${sessionName}.passed`)
         }
       } else {
         this.page
@@ -2422,11 +2832,8 @@ class Playwright extends Helper {
         if (this.options.trace) {
           test.artifacts.trace = await saveTraceForContext(this.browserContext, `${test.title}.passed`)
           for (const sessionName in this.sessionPages) {
-            if (sessionName === '') continue
-            const sessionPage = this.sessionPages[sessionName]
-            const sessionContext = sessionPage.context()
-            if (!sessionContext || !sessionContext.tracing) continue
-            test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(sessionContext, `${sessionName}_${test.title}.passed`)
+            if (!this.sessionPages[sessionName].context) continue
+            test.artifacts[`trace_${sessionName}`] = await saveTraceForContext(this.sessionPages[sessionName].context, `${test.title}_${sessionName}.passed`)
           }
         }
       } else {
@@ -2779,63 +3186,47 @@ class Playwright extends Helper {
             .locator(`${locator.isCustom() ? `${locator.type}=${locator.value}` : locator.simplify()} >> text=${text}`)
             .first()
             .waitFor({ timeout: waitTimeout, state: 'visible' })
-            .catch(e => {
-              throw new Error(errorMessage)
-            })
         }
 
         if (locator.isXPath()) {
-          return contextObject
-            .waitForFunction(
-              ([locator, text, $XPath]) => {
-                eval($XPath)
-                const el = $XPath(null, locator)
-                if (!el.length) return false
-                return el[0].innerText.indexOf(text) > -1
-              },
-              [locator.value, text, $XPath.toString()],
-              { timeout: waitTimeout },
-            )
-            .catch(e => {
-              throw new Error(errorMessage)
-            })
+          return contextObject.waitForFunction(
+            ([locator, text, $XPath]) => {
+              eval($XPath)
+              const el = $XPath(null, locator)
+              if (!el.length) return false
+              return el[0].innerText.indexOf(text) > -1
+            },
+            [locator.value, text, $XPath.toString()],
+            { timeout: waitTimeout },
+          )
         }
       } catch (e) {
         throw new Error(`${errorMessage}\n${e.message}`)
       }
     }
 
-    // Based on original implementation but fixed to check title text and remove problematic promiseRetry
-    // Original used timeoutGap for waitForFunction to give it slightly more time than the locator
     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([
-      // Strategy 1: waitForFunction that checks both body AND title text
-      // Use this.page instead of contextObject because FrameLocator doesn't have waitForFunction
-      // Original only checked document.body.innerText, missing title text like "TestEd"
-      this.page.waitForFunction(
-        function (text) {
-          // Check body text (original behavior)
-          if (document.body && document.body.innerText && document.body.innerText.indexOf(text) > -1) {
-            return true
-          }
-          // Check document title (fixes the TestEd in title issue)
-          if (document.title && document.title.indexOf(text) > -1) {
-            return true
-          }
-          return false
+      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)
         },
-        text,
-        { timeout: timeoutGap },
+        { retries: 1000, minTimeout: 500, maxTimeout: 500, factor: 1 },
       ),
-      // Strategy 2: Native Playwright text locator (replaces problematic promiseRetry)
-      contextObject
-        .locator(`:has-text(${JSON.stringify(text)})`)
-        .first()
-        .waitFor({ timeout: waitTimeout }),
-    ]).catch(err => {
-      throw new Error(errorMessage)
-    })
+    ])
   }
 
   /**
@@ -2885,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')
       }
@@ -2902,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
@@ -2920,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
+      }
     }
   }
 
@@ -3419,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()
@@ -3498,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
@@ -3521,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) {
@@ -3562,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
@@ -3574,7 +3955,7 @@ 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) {
@@ -3859,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)
   }
 }
 
@@ -3910,18 +4322,9 @@ function saveVideoForPage(page, name) {
 async function saveTraceForContext(context, name) {
   if (!context) return
   if (!context.tracing) return
-  try {
-    const fileName = `${`${global.output_dir}${pathSeparator}trace${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.zip`
-    await context.tracing.stop({ path: fileName })
-    return fileName
-  } catch (err) {
-    // Handle the case where tracing was not started or context is invalid
-    if (err.message && err.message.includes('Must start tracing before stopping')) {
-      // Tracing was never started on this context, silently skip
-      return null
-    }
-    throw err
-  }
+  const fileName = `${`${global.output_dir}${pathSeparator}trace${pathSeparator}${uuidv4()}_${clearString(name)}`.slice(0, 245)}.zip`
+  await context.tracing.stop({ path: fileName })
+  return fileName
 }
 
 async function highlightActiveElement(element) {