codeceptjs 3.7.6-beta.4 → 4.0.0-beta.10.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,14 @@ 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 { findReact, findVue, findByPlaywrightLocator } from './extras/PlaywrightReactVueLocator.js'
+import WebElement from '../element/WebElement.js'
 
 let playwright
 let perfTiming
@@ -41,14 +39,19 @@ let defaultSelectorEnginesInitialized = false
 let registeredCustomLocatorStrategies = new Set()
 let globalCustomLocatorStrategies = new Map()
 
+// Use global object to track selector registration across workers
+if (typeof global.__playwrightSelectorsRegistered === 'undefined') {
+  global.__playwrightSelectorsRegistered = false
+}
+
 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, restartsBrowser } 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
 
@@ -64,7 +67,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.
@@ -330,7 +332,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
@@ -353,7 +355,20 @@ class Playwright extends Helper {
     this.recordingWebSocketMessages = false
     this.recordedWebSocketMessagesAtLeastOnce = false
     this.cdpSession = null
-    this.customLocatorStrategies = typeof config.customLocatorStrategies === 'object' && config.customLocatorStrategies !== null ? config.customLocatorStrategies : null
+    
+    // Filter out invalid customLocatorStrategies (empty arrays, objects without functions)
+    // This can happen in worker threads where config is serialized/deserialized
+    let validCustomLocators = null
+    if (typeof config.customLocatorStrategies === 'object' && config.customLocatorStrategies !== null) {
+      // Check if it's an empty array or object with no function properties
+      const entries = Object.entries(config.customLocatorStrategies)
+      const hasFunctions = entries.some(([_, value]) => typeof value === 'function')
+      if (hasFunctions) {
+        validCustomLocators = config.customLocatorStrategies
+      }
+    }
+    
+    this.customLocatorStrategies = validCustomLocators
     this._customLocatorsRegistered = false
 
     // Add custom locator strategies to global registry for early registration
@@ -363,6 +378,10 @@ class Playwright extends Helper {
       }
     }
 
+    // Add test failure tracking to prevent false positives
+    this.testFailures = []
+    this.hasCleanupError = false
+
     // override defaults with config
     this._setConfig(config)
 
@@ -479,20 +498,69 @@ 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.')
+        }
+      }
+    }
+
+    // Ensure custom locators from this instance are in the global registry
+    // This is critical for worker threads where globalCustomLocatorStrategies is a new Map
+    if (this.customLocatorStrategies) {
+      for (const [strategyName, strategyFunction] of Object.entries(this.customLocatorStrategies)) {
+        if (!globalCustomLocatorStrategies.has(strategyName)) {
+          globalCustomLocatorStrategies.set(strategyName, strategyFunction)
+        }
+      }
+    }
+
     // register an internal selector engine for reading value property of elements in a selector
     try {
-      if (!defaultSelectorEnginesInitialized) {
-        await playwright.selectors.register('__value', createValueEngine)
-        await playwright.selectors.register('__disabled', createDisabledEngine)
-        if (process.env.testIdAttribute) await playwright.selectors.setTestIdAttribute(process.env.testIdAttribute)
+      // Always wrap in try-catch since selectors might be registered globally across workers
+      // Check global flag to avoid re-registration in worker processes
+      if (!global.__playwrightSelectorsRegistered) {
+        try {
+          await playwright.selectors.register('__value', createValueEngine)
+          await playwright.selectors.register('__disabled', createDisabledEngine)
+          global.__playwrightSelectorsRegistered = true
+          defaultSelectorEnginesInitialized = true
+        } catch (e) {
+          if (!e.message.includes('already registered')) {
+            throw e
+          }
+          // Selector already registered globally by another worker
+          global.__playwrightSelectorsRegistered = true
+          defaultSelectorEnginesInitialized = true
+        }
+      } else {
+        // Selectors already registered in a worker, skip
         defaultSelectorEnginesInitialized = true
+        this.debugSection('Init', 'Default selector engines already registered globally, skipping')
+      }
+      if (process.env.testIdAttribute) {
+        try {
+          await playwright.selectors.setTestIdAttribute(process.env.testIdAttribute)
+        } catch (e) {
+          // Ignore if already set
+        }
       }
 
       // Register all custom locator strategies from the global registry
@@ -548,15 +616,41 @@ class Playwright extends Helper {
   }
 
   _beforeSuite() {
-    if ((restartsSession() || restartsContext()) && !this.options.manualStart && !this.isRunning) {
+    // Skip browser start in dry-run mode (used by check command)
+    if (store.dryRun) {
+      this.debugSection('Dry Run', 'Skipping browser start')
+      return
+    }
+
+    // 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()
     }
   }
 
   async _before(test) {
+    // Skip browser operations in dry-run mode (used by check command)
+    if (store.dryRun) {
+      this.currentRunningTest = test
+      return
+    }
+
     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 => {
@@ -568,8 +662,12 @@ class Playwright extends Helper {
       },
     })
 
-    if (restartsBrowser() && !this.options.manualStart) await this._startBrowser()
+    // Start browser if needed (initial start or browser restart strategy)
     if (!this.isRunning && !this.options.manualStart) await this._startBrowser()
+    else if (restartsBrowser() && !this.options.manualStart) {
+      // Browser restart strategy: start browser for each test
+      await this._startBrowser()
+    }
 
     this.isAuthenticated = false
     if (this.isElectron) {
@@ -606,8 +704,29 @@ 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
+        try {
+          this.browserContext = await this.browser.newContext(this.contextOptions) // Adding the HTTPSError ignore in the context so that we can ignore those errors
+        } catch (err) {
+          // In worker mode with Playwright 1.x, there's a known issue where newContext() fails
+          // with "selector engine already registered" when selectors are registered globally
+          // across worker threads. This is safe to retry without ANY custom options.
+          if (err.message && err.message.includes('already registered')) {
+            this.debugSection('Worker Mode', 'Selector conflict detected, retrying context creation with no options')
+            // Create context with NO options to avoid selector conflicts
+            this.browserContext = await this.browser.newContext()
+          } else {
+            throw err
+          }
+        }
       }
     }
 
@@ -652,8 +771,12 @@ class Playwright extends Helper {
     popupStore.clear()
 
     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
     }
 
@@ -662,33 +785,203 @@ class Playwright extends Helper {
     }
 
     if (restartsBrowser()) {
-      this.isRunning = false
-      return this._stopBrowser()
+      // Close browser completely for restart strategy
+      if (this.isRunning) {
+        try {
+          // Close all pages first to release resources
+          if (this.browserContext) {
+            const pages = await this.browserContext.pages()
+            await Promise.allSettled(pages.map(p => p.close().catch(() => {})))
+          }
+          // Use timeout to prevent hanging (10s should be enough for browser cleanup)
+          await Promise.race([
+            this._stopBrowser(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout')), 10000)),
+          ])
+        } catch (e) {
+          console.warn('Warning during browser restart in _after:', e.message)
+          // Force cleanup even on timeout
+          this.browser = null
+          this.browserContext = null
+          this.isRunning = false
+        }
+      }
+      return
     }
 
-    // close other sessions
+    // 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() {
+    // Stop browser after suite completes
+    // For restart strategies: stop after each suite
+    // For session mode (restart:false): stop after the last suite
+    if (this.isRunning) {
+      try {
+        // Add timeout protection to prevent hanging
+        await Promise.race([
+          this._stopBrowser(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in afterSuite')), 10000)),
+        ])
+      } 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}`)
+        // Force cleanup on timeout
+        this.browser = null
+        this.browserContext = null
+        this.isRunning = false
+      } 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}`)
+    }
+
+    // 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() || restartsBrowser()) && 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 {
+        // Add timeout protection to prevent hanging
+        await Promise.race([
+          this._stopBrowser(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in cleanup')), 10000)),
+        ])
+      } catch (e) {
+        console.warn('Warning during final cleanup:', e.message)
+        // Force cleanup on timeout
+        this.browser = null
+        this.browserContext = null
+        this.isRunning = false
+      }
+    } else {
+      // Check if we still have a browser object despite isRunning being false
+      if (this.browser) {
+        try {
+          // Add timeout protection to prevent hanging
+          await Promise.race([
+            this._stopBrowser(),
+            new Promise((_, reject) => setTimeout(() => reject(new Error('Browser stop timeout in forced cleanup')), 10000)),
+          ])
+        } catch (e) {
+          console.warn('Warning during forced cleanup:', e.message)
+          // Force cleanup on timeout
+          this.browser = null
+          this.browserContext = null
+        }
+      }
+    }
   }
 
   _session() {
@@ -707,13 +1000,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
             }
           }
         }
@@ -744,8 +1044,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()
       },
@@ -831,21 +1151,46 @@ 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')
+        this.page.removeAllListeners('load')
+        this.page.removeAllListeners('console')
+        this.page.removeAllListeners('requestfinished')
+      } 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
+    }
   }
 
   /**
@@ -903,7 +1248,10 @@ class Playwright extends Helper {
 
   async _startBrowser() {
     // Ensure custom locator strategies are registered before browser launch
-    await this._init()
+    // Only init once globally to avoid selector re-registration in workers
+    if (!defaultSelectorEnginesInitialized) {
+      await this._init()
+    }
 
     if (this.isElectron) {
       this.browser = await playwright._electron.launch(this.playwrightOptions)
@@ -970,6 +1318,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)
 
     // Register custom locator strategies for this context
@@ -1039,9 +1390,42 @@ class Playwright extends Helper {
     this.context = null
     this.frame = null
     popupStore.clear()
-    if (this.options.recordHar) await this.browserContext.close()
+    
+    // Remove all event listeners to prevent hanging
+    if (this.browser) {
+      try {
+        this.browser.removeAllListeners()
+      } catch (e) {
+        // Ignore errors if browser is already closed
+      }
+    }
+    
+    if (this.options.recordHar && this.browserContext) {
+      try {
+        await this.browserContext.close()
+      } catch (e) {
+        // Ignore errors if context is already closed
+      }
+    }
     this.browserContext = null
-    await this.browser.close()
+    
+    if (this.browser) {
+      try {
+        // Add timeout to prevent browser.close() from hanging indefinitely
+        await Promise.race([
+          this.browser.close(),
+          new Promise((_, reject) => 
+            setTimeout(() => reject(new Error('Browser close timeout')), 5000)
+          )
+        ])
+      } catch (e) {
+        // Ignore errors if browser is already closed or timeout
+        if (!e.message?.includes('Browser close timeout')) {
+          // Non-timeout error, can be ignored as well
+        }
+        // Force cleanup even on error
+      }
+    }
     this.browser = null
     this.isRunning = false
   }
@@ -1060,8 +1444,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)
@@ -1078,7 +1475,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
   }
@@ -1101,6 +1502,13 @@ class Playwright extends Helper {
     if (this.isElectron) {
       throw new Error('Cannot open pages inside an Electron container')
     }
+
+    // Prevent navigation attempts only when manual start is enabled and browser is not running
+    // Allow auto-initialization for normal operation (e.g., when using BROWSER_RESTART=browser)
+    if (!this.isRunning && this.options.manualStart && (!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}`)
@@ -1113,7 +1521,91 @@ 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,
+        }
+        
+        try {
+          this.browserContext = await this.browser.newContext(contextOptions)
+        } catch (err) {
+          // In worker mode with Playwright 1.x, there's a known issue where newContext() fails
+          // with "selector engine already registered" when selectors are registered globally
+          // across worker threads. This is safe to retry without ANY custom options.
+          if (err.message && err.message.includes('already registered')) {
+            this.debugSection('Worker Mode', 'Selector conflict in amOnPage, retrying with empty options')
+            // Create context with NO options to avoid selector conflicts
+            this.browserContext = await this.browser.newContext()
+          } else {
+            throw err
+          }
+        }
+      }
+
+      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)))
 
@@ -1251,44 +1743,25 @@ class Playwright extends Helper {
   async dragAndDrop(srcElement, destElement, options) {
     const src = new Locator(srcElement)
     const dst = new Locator(destElement)
+    const context = await this._getContext()
 
     if (options) {
-      return this.page.dragAndDrop(buildLocatorString(src), buildLocatorString(dst), options)
+      return context.dragAndDrop(buildLocatorString(src), buildLocatorString(dst), options)
     }
 
     const _smallWaitInMs = 600
-    await this.page.locator(buildLocatorString(src)).hover()
+    await context.locator(buildLocatorString(src)).hover()
     await this.page.mouse.down()
     await this.page.waitForTimeout(_smallWaitInMs)
 
-    const destElBox = await this.page.locator(buildLocatorString(dst)).boundingBox()
+    const destElBox = await context.locator(buildLocatorString(dst)).boundingBox()
 
     await this.page.mouse.move(destElBox.x + destElBox.width / 2, destElBox.y + destElBox.height / 2)
-    await this.page.locator(buildLocatorString(dst)).hover({ position: { x: 10, y: 10 } })
+    await context.locator(buildLocatorString(dst)).hover({ position: { x: 10, y: 10 } })
     await this.page.waitForTimeout(_smallWaitInMs)
     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 }}
    */
@@ -1734,7 +2207,7 @@ class Playwright extends Helper {
    * ```
    *
    */
-  async click(locator, context = null, options = {}) {
+  async click(locator = '//body', context = null, options = {}) {
     return proceedClick.call(this, locator, context, options)
   }
 
@@ -1768,6 +2241,49 @@ class Playwright extends Helper {
     return proceedClick.call(this, locator, context, { button: 'right' })
   }
 
+  /**
+   * Performs click at specific coordinates.
+   * If locator is provided, the coordinates are relative to the element.
+   * If locator is not provided, the coordinates are global page coordinates.
+   *
+   * ```js
+   * // Click at global coordinates (100, 200)
+   * I.clickXY(100, 200);
+   *
+   * // Click at coordinates (50, 30) relative to element
+   * I.clickXY('#someElement', 50, 30);
+   * ```
+   *
+   * @param {CodeceptJS.LocatorOrString|number} locator Element to click on or X coordinate if no element.
+   * @param {number} [x] X coordinate relative to element, or Y coordinate if locator is a number.
+   * @param {number} [y] Y coordinate relative to element.
+   * @returns {Promise<void>}
+   */
+  async clickXY(locator, x, y) {
+    // If locator is a number, treat it as global X coordinate
+    if (typeof locator === 'number') {
+      const globalX = locator
+      const globalY = x
+      await this.page.mouse.click(globalX, globalY)
+      return this._waitForAction()
+    }
+
+    // Locator is provided, click relative to element
+    const el = await this._locateElement(locator)
+    assertElementExists(el, locator, 'Element to click')
+
+    const box = await el.boundingBox()
+    if (!box) {
+      throw new Error(`Element ${locator} is not visible or has no bounding box`)
+    }
+
+    const absoluteX = box.x + x
+    const absoluteY = box.y + y
+
+    await this.page.mouse.click(absoluteX, absoluteY)
+    return this._waitForAction()
+  }
+
   /**
    *
    * [Additional options](https://playwright.dev/docs/api/class-elementhandle#element-handle-check) for check available as 3rd argument.
@@ -1876,11 +2392,15 @@ class Playwright extends Helper {
    * {{> type }}
    */
   async type(keys, delay = null) {
+    // Always use page.keyboard.type for any string (including single character and national characters).
     if (!Array.isArray(keys)) {
       keys = keys.toString()
-      keys = keys.split('')
+      const typeDelay = typeof delay === 'number' ? delay : this.options.pressKeyDelay
+      await this.page.keyboard.type(keys, { delay: typeDelay })
+      return
     }
 
+    // For array input, treat each as a key press to keep working combinations such as ['Control', 'A'] or ['T', 'e', 's', 't'].
     for (const key of keys) {
       await this.page.keyboard.press(key)
       if (delay) await this.wait(delay / 1000)
@@ -2166,10 +2686,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
+    }
   }
 
   /**
@@ -2274,6 +2805,17 @@ class Playwright extends Helper {
    *
    */
   async grabTextFrom(locator) {
+    // Handle role locators with text/exact options
+    if (isRoleLocatorObject(locator)) {
+      const elements = await handleRoleLocator(this.page, locator)
+      if (elements && elements.length > 0) {
+        const text = await elements[0].textContent()
+        assertElementExists(text, JSON.stringify(locator))
+        this.debugSection('Text', text)
+        return text
+      }
+    }
+
     const locatorObj = new Locator(locator, 'css')
 
     if (locatorObj.isCustom()) {
@@ -2288,10 +2830,18 @@ class Playwright extends Helper {
       return text
     } else {
       locator = this._contextLocator(locator)
-      const text = await this.page.textContent(locator)
-      assertElementExists(text, locator)
-      this.debugSection('Text', text)
-      return text
+      try {
+        const text = await this.page.textContent(locator)
+        assertElementExists(text, locator)
+        this.debugSection('Text', text)
+        return text
+      } catch (error) {
+        // Convert Playwright timeout errors to ElementNotFound for consistency
+        if (error.message && error.message.includes('Timeout')) {
+          throw new ElementNotFound(locator, 'text')
+        }
+        throw error
+      }
     }
   }
 
@@ -2480,6 +3030,33 @@ class Playwright extends Helper {
     return array
   }
 
+  /**
+   * Retrieves the ARIA snapshot for an element using Playwright's [`locator.ariaSnapshot`](https://playwright.dev/docs/api/class-locator#locator-aria-snapshot).
+   * This method returns a YAML representation of the accessibility tree that can be used for assertions.
+   * If no locator is provided, it captures the snapshot of the entire page body.
+   *
+   * ```js
+   * const snapshot = await I.grabAriaSnapshot();
+   * expect(snapshot).toContain('heading "Sign up"');
+   *
+   * const formSnapshot = await I.grabAriaSnapshot('#login-form');
+   * expect(formSnapshot).toContain('textbox "Email"');
+   * ```
+   *
+   * [Learn more about ARIA snapshots](https://playwright.dev/docs/aria-snapshots)
+   *
+   * @param {string|object} [locator='//body'] element located by CSS|XPath|strict locator. Defaults to body element.
+   * @return {Promise<string>} YAML representation of the accessibility tree
+   */
+  async grabAriaSnapshot(locator = '//body') {
+    const matchedLocator = new Locator(locator)
+    const els = await this._locate(matchedLocator)
+    assertElementExists(els, locator)
+    const snapshot = await els[0].ariaSnapshot()
+    this.debugSection('Aria Snapshot', snapshot)
+    return snapshot
+  }
+
   /**
    * {{> saveElementScreenshot }}
    *
@@ -2502,25 +3079,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
+    }
+
+    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.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
         }
       }
     }
@@ -3130,8 +3752,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')
       }
@@ -3147,16 +3774,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
@@ -3165,8 +3801,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
+      }
     }
   }
 
@@ -3664,7 +4306,7 @@ class Playwright extends Helper {
   }
 }
 
-module.exports = Playwright
+export default Playwright
 
 function buildCustomLocatorString(locator) {
   // Note: this.debug not available in standalone function, using console.log
@@ -3682,10 +4324,40 @@ function buildLocatorString(locator) {
   return locator.simplify()
 }
 
+/**
+ * Checks if a locator is a role locator object (e.g., {role: 'button', text: 'Submit', exact: true})
+ */
+function isRoleLocatorObject(locator) {
+  return locator && typeof locator === 'object' && locator.role && !locator.type
+}
+
+/**
+ * Handles role locator objects by converting them to Playwright's getByRole() API
+ * Returns elements array if role locator, null otherwise
+ */
+async function handleRoleLocator(context, locator) {
+  if (!isRoleLocatorObject(locator)) return null
+  
+  const options = {}
+  if (locator.text) options.name = locator.text
+  if (locator.exact !== undefined) options.exact = locator.exact
+  
+  return context.getByRole(locator.role, Object.keys(options).length > 0 ? options : undefined).all()
+}
+
 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)
+  // Check if locator is a Locator object with react/vue type, or a raw object with react/vue property
+  const isReactLocator = locator.type === 'react' || (locator.locator && locator.locator.react) || locator.react
+  const isVueLocator = locator.type === 'vue' || (locator.locator && locator.locator.vue) || locator.vue
+  const isPwLocator = locator.type === 'pw' || (locator.locator && locator.locator.pw) || locator.pw
+  
+  if (isReactLocator) return findReact(matcher, locator)
+  if (isVueLocator) return findVue(matcher, locator)
+  if (isPwLocator) return findByPlaywrightLocator.call(this, matcher, locator)
+
+  // Handle role locators with text/exact options (e.g., {role: 'button', text: 'Submit', exact: true})
+  const roleElements = await handleRoleLocator(matcher, locator)
+  if (roleElements) return roleElements
 
   locator = new Locator(locator, 'css')
 
@@ -3716,8 +4388,16 @@ async function findElements(matcher, locator) {
 }
 
 async function findCustomElements(matcher, locator) {
-  const customLocatorStrategies = this.customLocatorStrategies || globalCustomLocatorStrategies
-  const strategyFunction = customLocatorStrategies.get ? customLocatorStrategies.get(locator.type) : customLocatorStrategies[locator.type]
+  // Always prioritize this.customLocatorStrategies which is set in constructor from config
+  // and persists in every worker thread instance
+  let strategyFunction = null
+  
+  if (this.customLocatorStrategies && this.customLocatorStrategies[locator.type]) {
+    strategyFunction = this.customLocatorStrategies[locator.type]
+  } else if (globalCustomLocatorStrategies.has(locator.type)) {
+    // Fallback to global registry (populated in constructor and _init)
+    strategyFunction = globalCustomLocatorStrategies.get(locator.type)
+  }
 
   if (!strategyFunction) {
     throw new Error(`Custom locator strategy "${locator.type}" is not defined. Please define "customLocatorStrategies" in your configuration.`)
@@ -3853,15 +4533,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
@@ -3876,7 +4567,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) {
@@ -3915,12 +4606,16 @@ async function findCheckable(locator, context) {
     contextEl = contextEl[0]
   }
 
+  // Handle role locators with text/exact options
+  const roleElements = await handleRoleLocator(contextEl, locator)
+  if (roleElements) return roleElements
+
   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
@@ -3929,7 +4624,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) {
@@ -3941,6 +4636,13 @@ async function proceedIsChecked(assertType, option) {
 }
 
 async function findFields(locator) {
+  // Handle role locators with text/exact options
+  if (isRoleLocatorObject(locator)) {
+    const page = await this.page
+    const roleElements = await handleRoleLocator(page, locator)
+    if (roleElements) return roleElements
+  }
+
   const matchedLocator = new Locator(locator)
   if (!matchedLocator.isFuzzy()) {
     return this._locate(matchedLocator)
@@ -4212,36 +4914,72 @@ 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))])
 
-    await Promise.all(contexts.map(c => c.close()))
+    // 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))
+
+    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 {
+    if (!this.page || !this.browserContext) {
+      this.debugSection('Session', 'Skipping storage cleanup - no active page/context')
+      return
+    }
+    
+    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)
   }
 }