codeceptjs 4.0.1-beta.1 → 4.0.1-beta.10

package/lib/actor.js

@@ -75,7 +75,8 @@ export default function (obj = {}, container) {
   if (!container) {
     container = Container
   }
-  
+
+  // Get existing actor or create a new one
   const actor = container.actor() || new Actor()
 
   // load all helpers once container initialized
@@ -111,14 +112,17 @@ export default function (obj = {}, container) {
       }
     })
 
-    container.append({
-      support: {
-        I: actor,
-      },
-    })
+    // Update container.support.I to ensure it has the latest actor reference
+    if (!container.actor() || container.actor() !== actor) {
+      container.append({
+        support: {
+          I: actor,
+        },
+      })
+    }
   })
-  // store.actor = actor;
-  // add custom steps from actor
+
+  // add custom steps from actor immediately
   Object.keys(obj).forEach(key => {
     const ms = new MetaStep('I', key)
     ms.setContext(actor)

package/lib/container.js

@@ -22,6 +22,7 @@ let container = {
   helpers: {},
   support: {},
   proxySupport: {},
+  proxySupportConfig: {}, // Track config used to create proxySupport
   plugins: {},
   actor: null,
   /**
@@ -67,14 +68,15 @@ class Container {
     container.support = {}
     container.helpers = await createHelpers(config.helpers || {})
     container.translation = await loadTranslation(config.translation || null, config.vocabularies || [])
-    container.proxySupport = createSupportObjects(config.include || {})
+    container.proxySupportConfig = config.include || {}
+    container.proxySupport = createSupportObjects(container.proxySupportConfig)
     container.plugins = await createPlugins(config.plugins || {}, opts)
     container.result = new Result()
 
     // Preload includes (so proxies can expose real objects synchronously)
     const includes = config.include || {}
 
-    // Ensure I is available for DI modules at import time
+    // Check if custom I is provided
     if (Object.prototype.hasOwnProperty.call(includes, 'I')) {
       try {
         const mod = includes.I
@@ -89,7 +91,7 @@ class Container {
         throw new Error(`Could not include object I: ${e.message}`)
       }
     } else {
-      // Create default actor if not provided via includes
+      // Create default actor - this sets up the callback in asyncHelperPromise
       createActor()
     }
 
@@ -110,6 +112,9 @@ class Container {
       }
     }
 
+    // Wait for all async helpers to finish loading and populate the actor
+    await asyncHelperPromise
+
     if (opts && opts.ai) ai.enable(config.ai) // enable AI Assistant
     if (config.gherkin) await loadGherkinStepsAsync(config.gherkin.steps || [])
     if (opts && typeof opts.timeouts === 'boolean') store.timeouts = opts.timeouts
@@ -202,19 +207,12 @@ class Container {
   static append(newContainer) {
     container = deepMerge(container, newContainer)
 
-    // If new helpers are added, set the helpers property on them
-    if (newContainer.helpers) {
-      for (const name in newContainer.helpers) {
-        if (container.helpers[name] && typeof container.helpers[name] === 'object') {
-          container.helpers[name].helpers = container.helpers
-        }
-      }
-    }
-
     // If new support objects are added, update the proxy support
     if (newContainer.support) {
-      const newProxySupport = createSupportObjects(newContainer.support)
-      container.proxySupport = { ...container.proxySupport, ...newProxySupport }
+      // Merge the new support config with existing config
+      container.proxySupportConfig = { ...container.proxySupportConfig, ...newContainer.support }
+      // Recreate the proxy with merged config
+      container.proxySupport = createSupportObjects(container.proxySupportConfig)
     }
 
     debug('appended', JSON.stringify(newContainer).slice(0, 300))
@@ -230,6 +228,7 @@ class Container {
   static async clear(newHelpers = {}, newSupport = {}, newPlugins = {}) {
     container.helpers = newHelpers
     container.translation = await loadTranslation()
+    container.proxySupportConfig = newSupport
     container.proxySupport = createSupportObjects(newSupport)
     container.plugins = newPlugins
     container.sharedKeys = new Set() // Clear shared keys
@@ -301,7 +300,7 @@ async function createHelpers(config) {
       if (!HelperClass) {
         const helperResult = requireHelperFromModule(helperName, config)
         if (helperResult instanceof Promise) {
-          // Handle async ESM loading
+          // Handle async ESM loading - create placeholder
           helpers[helperName] = {}
           asyncHelperPromise = asyncHelperPromise
             .then(() => helperResult)
@@ -320,8 +319,7 @@ async function createHelpers(config) {
 
               checkHelperRequirements(ResolvedHelperClass)
               helpers[helperName] = new ResolvedHelperClass(config[helperName])
-              if (helpers[helperName]._init) await helpers[helperName]._init()
-              debug(`helper ${helperName} async initialized`)
+              debug(`helper ${helperName} async loaded`)
             })
           continue
         } else {
@@ -341,9 +339,8 @@ async function createHelpers(config) {
               throw new Error(`Helper class from module '${helperName}' is not a class. Use CJS async module syntax.`)
             }
 
-            debug(`helper ${helperName} async initialized`)
-
             helpers[helperName] = new ResolvedHelperClass(config[helperName])
+            debug(`helper ${helperName} async CJS loaded`)
           })
 
         continue
@@ -358,19 +355,18 @@ async function createHelpers(config) {
     }
   }
 
-  // Set helpers property on each helper to allow access to other helpers
-  for (const name in helpers) {
-    if (helpers[name] && typeof helpers[name] === 'object') {
-      helpers[name].helpers = helpers
+  // Don't await here - let Container.create() handle the await
+  // This allows actor callbacks to be registered before resolution
+  asyncHelperPromise = asyncHelperPromise.then(async () => {
+    // Call _init on all helpers after they're all loaded
+    for (const name in helpers) {
+      if (helpers[name]._init) {
+        await helpers[name]._init()
+        debug(`helper ${name} _init() called`)
+      }
     }
-  }
+  })
 
-  // Wait for async helpers and call _init
-  await asyncHelperPromise
-
-  for (const name in helpers) {
-    if (helpers[name]._init) await helpers[name]._init()
-  }
   return helpers
 }
 
@@ -402,20 +398,52 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
       throw err
     }
   } else {
+    // Handle TypeScript files
+    let importPath = moduleName
+    let tempJsFile = null
+    const ext = path.extname(moduleName)
+
+    if (ext === '.ts') {
+      try {
+        // Use the TypeScript transpilation utility
+        const typescript = await import('typescript')
+        const { tempFile, allTempFiles } = await transpileTypeScript(importPath, typescript)
+
+        debug(`Transpiled TypeScript helper: ${importPath} -> ${tempFile}`)
+
+        importPath = tempFile
+        tempJsFile = allTempFiles
+      } catch (tsError) {
+        throw new Error(`Failed to load TypeScript helper ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
+      }
+    }
+
     // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
     try {
       // Try dynamic import for both CommonJS and ESM modules
-      const mod = await import(moduleName)
+      const mod = await import(importPath)
       if (!mod && !mod.default) {
         throw new Error(`Helper module '${moduleName}' was not found. Make sure you have installed the package correctly.`)
       }
       HelperClass = mod.default || mod
+
+      // Clean up temp files if created
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
     } catch (err) {
+      // Clean up temp files before rethrowing
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        cleanupTempFiles(filesToClean)
+      }
+
       if (err.code === 'ERR_REQUIRE_ESM' || (err.message && err.message.includes('ES module'))) {
         // This is an ESM module, use dynamic import
         try {
           const pathModule = await import('path')
-          const absolutePath = pathModule.default.resolve(moduleName)
+          const absolutePath = pathModule.default.resolve(importPath)
           const mod = await import(absolutePath)
           HelperClass = mod.default || mod
           debug(`helper ${helperName} loaded via ESM import`)
@@ -544,10 +572,17 @@ function createSupportObjects(config) {
         return [...new Set([...keys, ...container.sharedKeys])]
       },
       getOwnPropertyDescriptor(target, prop) {
+        // For destructuring to work, we need to return the actual value from the getter
+        let value
+        if (container.sharedKeys.has(prop) && prop in container.support) {
+          value = container.support[prop]
+        } else {
+          value = lazyLoad(prop)
+        }
         return {
           enumerable: true,
           configurable: true,
-          value: target[prop],
+          value: value,
         }
       },
       get(target, key) {

package/lib/helper/GraphQL.js

@@ -45,6 +45,8 @@ class GraphQL extends Helper {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
+      onRequest: null,
+      onResponse: null,
     }
     this.options = Object.assign(this.options, config)
     this.headers = { ...this.options.defaultHeaders }
@@ -87,8 +89,8 @@ class GraphQL extends Helper {
 
     request.headers = { ...this.headers, ...request.headers }
 
-    if (this.config.onRequest) {
-      await this.config.onRequest(request)
+    if (this.options.onRequest) {
+      await this.options.onRequest(request)
     }
 
     this.debugSection('Request', JSON.stringify(request))
@@ -102,8 +104,8 @@ class GraphQL extends Helper {
       response = err.response
     }
 
-    if (this.config.onResponse) {
-      await this.config.onResponse(response)
+    if (this.options.onResponse) {
+      await this.options.onResponse(response)
     }
 
     this.debugSection('Response', JSON.stringify(response.data))

package/lib/helper/JSONResponse.js

@@ -72,8 +72,8 @@ class JSONResponse extends Helper {
     if (!this.helpers[this.options.requestHelper]) {
       throw new Error(`Error setting JSONResponse, helper ${this.options.requestHelper} is not enabled in config, helpers: ${Object.keys(this.helpers)}`)
     }
-    const origOnResponse = this.helpers[this.options.requestHelper].config.onResponse
-    this.helpers[this.options.requestHelper].config.onResponse = response => {
+    const origOnResponse = this.helpers[this.options.requestHelper].options.onResponse
+    this.helpers[this.options.requestHelper].options.onResponse = response => {
       this.response = response
       if (typeof origOnResponse === 'function') origOnResponse(response)
     }
@@ -83,7 +83,6 @@ class JSONResponse extends Helper {
     this.response = null
   }
 
-  
   /**
    * Checks that response code is equal to the provided one
    *
@@ -372,4 +371,4 @@ class JSONResponse extends Helper {
   }
 }
 
-export { JSONResponse as default }
+export { JSONResponse, JSONResponse as default }

package/lib/helper/Playwright.js

@@ -355,7 +355,7 @@ class Playwright extends Helper {
     this.recordingWebSocketMessages = false
     this.recordedWebSocketMessagesAtLeastOnce = false
     this.cdpSession = null
-    
+
     // Filter out invalid customLocatorStrategies (empty arrays, objects without functions)
     // This can happen in worker threads where config is serialized/deserialized
     let validCustomLocators = null
@@ -367,7 +367,7 @@ class Playwright extends Helper {
         validCustomLocators = config.customLocatorStrategies
       }
     }
-    
+
     this.customLocatorStrategies = validCustomLocators
     this._customLocatorsRegistered = false
 
@@ -416,6 +416,7 @@ class Playwright extends Helper {
       ignoreHTTPSErrors: false, // Adding it here o that context can be set up to ignore the SSL errors,
       highlightElement: false,
       storageState: undefined,
+      onResponse: null,
     }
 
     process.env.testIdAttribute = 'data-testid'
@@ -794,10 +795,7 @@ class Playwright extends Helper {
             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)),
-          ])
+          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
@@ -840,10 +838,7 @@ class Playwright extends Helper {
     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)),
-        ])
+        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
@@ -954,10 +949,7 @@ class Playwright extends Helper {
     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)),
-        ])
+        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
@@ -970,10 +962,7 @@ class Playwright extends Helper {
       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)),
-          ])
+          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
@@ -1390,7 +1379,7 @@ class Playwright extends Helper {
     this.context = null
     this.frame = null
     popupStore.clear()
-    
+
     // Remove all event listeners to prevent hanging
     if (this.browser) {
       try {
@@ -1399,7 +1388,7 @@ class Playwright extends Helper {
         // Ignore errors if browser is already closed
       }
     }
-    
+
     if (this.options.recordHar && this.browserContext) {
       try {
         await this.browserContext.close()
@@ -1408,16 +1397,11 @@ class Playwright extends Helper {
       }
     }
     this.browserContext = null
-    
+
     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)
-          )
-        ])
+        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')) {
@@ -1539,7 +1523,7 @@ class Playwright extends Helper {
           acceptDownloads: true,
           ...this.options.emulate,
         }
-        
+
         try {
           this.browserContext = await this.browser.newContext(contextOptions)
         } catch (err) {
@@ -3183,14 +3167,14 @@ class Playwright extends Helper {
     this.debugSection('Response', await response.text())
 
     // hook to allow JSON response handle this
-    if (this.config.onResponse) {
+    if (this.options.onResponse) {
       const axiosResponse = {
         data: await response.json(),
         status: response.status(),
         statusText: response.statusText(),
         headers: response.headers(),
       }
-      this.config.onResponse(axiosResponse)
+      this.options.onResponse(axiosResponse)
     }
 
     return response
@@ -4337,11 +4321,11 @@ function isRoleLocatorObject(locator) {
  */
 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()
 }
 
@@ -4350,7 +4334,7 @@ async function findElements(matcher, locator) {
   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)
@@ -4391,7 +4375,7 @@ async function findCustomElements(matcher, locator) {
   // 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)) {
@@ -4967,7 +4951,7 @@ async function refreshContextSession() {
       this.debugSection('Session', 'Skipping storage cleanup - no active page/context')
       return
     }
-    
+
     const currentUrl = await this.grabCurrentUrl()
 
     if (currentUrl.startsWith('http')) {

package/lib/helper/REST.js

@@ -94,7 +94,9 @@ const config = {}
 class REST extends Helper {
   constructor(config) {
     super(config)
-    this.options = {
+
+    // Set defaults first
+    const defaults = {
       timeout: 10000,
       defaultHeaders: {},
       endpoint: '',
@@ -103,15 +105,16 @@ class REST extends Helper {
       onResponse: null,
     }
 
+    // Merge config with defaults
+    this._setConfig(config)
+    this.options = { ...defaults, ...this.options }
+
     if (this.options.maxContentLength) {
       const maxContentLength = this.options.maxUploadFileSize * 1024 * 1024
       this.options.maxContentLength = maxContentLength
       this.options.maxBodyLength = maxContentLength
     }
 
-    // override defaults with config
-    this._setConfig(config)
-
     this.headers = { ...this.options.defaultHeaders }
 
     // Create an agent with SSL certificate
@@ -215,8 +218,9 @@ class REST extends Helper {
       }
     }
 
-    if (this.config.onRequest) {
-      await this.config.onRequest(request)
+    const onRequest = this.options.onRequest || this.config.onRequest
+    if (onRequest) {
+      await onRequest(request)
     }
 
     try {
@@ -245,8 +249,9 @@ class REST extends Helper {
       }
       response = err.response
     }
-    if (this.config.onResponse) {
-      await this.config.onResponse(response)
+    const onResponse = this.options.onResponse || this.config.onResponse
+    if (onResponse) {
+      await onResponse(response)
     }
     try {
       this.options.prettyPrintJson ? this.debugSection('Response', beautify(JSON.stringify(response.data))) : this.debugSection('Response', JSON.stringify(response.data))
@@ -468,7 +473,8 @@ class REST extends Helper {
 export { REST as default }
 
 function curlize(request) {
-  if (request.data?.constructor.name.toLowerCase() === 'formdata') return 'cURL is not printed as the request body is not a JSON'
+  // Guard access to nested properties safely in case request.data is undefined
+  if ((request.data?.constructor?.name || '').toLowerCase() === 'formdata') return 'cURL is not printed as the request body is not a JSON'
   let curl = `curl --location --request ${request.method ? request.method.toUpperCase() : 'GET'} ${request.baseURL} `.replace("'", '')
 
   if (request.headers) {

package/lib/listener/config.js

@@ -12,15 +12,23 @@ export default function () {
     return
   }
   global.__codeceptConfigListenerInitialized = true
-  
-  const helpers = global.container.helpers()
 
   enableDynamicConfigFor('suite')
   enableDynamicConfigFor('test')
 
   function enableDynamicConfigFor(type) {
     event.dispatcher.on(event[type].before, (context = {}) => {
+      // Get helpers dynamically at runtime, not at initialization time
+      // This ensures we get the actual helper instances, not placeholders
+      const helpers = global.container.helpers()
+
       function updateHelperConfig(helper, config) {
+        // Guard against undefined or invalid helpers
+        if (!helper || !helper.constructor) {
+          output.debug(`[${ucfirst(type)} Config] Helper not found or not properly initialized`)
+          return
+        }
+
         const oldConfig = deepClone(helper.options)
         try {
           helper._setConfig(deepMerge(deepClone(oldConfig), config))
@@ -41,7 +49,7 @@ export default function () {
         for (let name in context.config) {
           const config = context.config[name]
           if (name === '0') {
-            // first helper
+            // first helper - get dynamically
             name = Object.keys(helpers)[0]
           }
           const helper = helpers[name]

package/lib/step/meta.js

@@ -58,17 +58,24 @@ class MetaStep extends Step {
     this.status = 'queued'
     this.setArguments(Array.from(arguments).slice(1))
     let result
+    let hasChildSteps = false
 
     const registerStep = step => {
       this.setMetaStep(null)
       step.setMetaStep(this)
+      hasChildSteps = true
     }
     event.dispatcher.prependListener(event.step.before, registerStep)
+
+    // Start timing
+    this.startTime = Date.now()
+
     // Handle async and sync methods.
     if (fn.constructor.name === 'AsyncFunction') {
       result = fn
         .apply(this.context, this.args)
         .then(result => {
+          this.setStatus('success')
           return result
         })
         .catch(error => {
@@ -78,17 +85,27 @@ class MetaStep extends Step {
         .finally(() => {
           this.endTime = Date.now()
           event.dispatcher.removeListener(event.step.before, registerStep)
+          // Only emit events if no child steps were registered
+          if (!hasChildSteps) {
+            event.emit(event.step.started, this)
+            event.emit(event.step.finished, this)
+          }
         })
     } else {
       try {
-        this.startTime = Date.now()
         result = fn.apply(this.context, this.args)
+        this.setStatus('success')
       } catch (error) {
         this.setStatus('failed')
         throw error
       } finally {
         this.endTime = Date.now()
         event.dispatcher.removeListener(event.step.before, registerStep)
+        // Only emit events if no child steps were registered
+        if (!hasChildSteps) {
+          event.emit(event.step.started, this)
+          event.emit(event.step.finished, this)
+        }
       }
     }
 

package/lib/workers.js

@@ -5,6 +5,7 @@ import { mkdirp } from 'mkdirp'
 import { Worker } from 'worker_threads'
 import { EventEmitter } from 'events'
 import ms from 'ms'
+import merge from 'lodash.merge'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -66,21 +67,21 @@ const createWorker = (workerObject, isPoolMode = false) => {
     stdout: true,
     stderr: true,
   })
-  
+
   // Pipe worker stdout/stderr to main process
   if (worker.stdout) {
     worker.stdout.setEncoding('utf8')
-    worker.stdout.on('data', (data) => {
+    worker.stdout.on('data', data => {
       process.stdout.write(data)
     })
   }
   if (worker.stderr) {
     worker.stderr.setEncoding('utf8')
-    worker.stderr.on('data', (data) => {
+    worker.stderr.on('data', data => {
       process.stderr.write(data)
     })
   }
-  
+
   worker.on('error', err => {
     console.error(`[Main] Worker Error:`, err)
     output.error(`Worker Error: ${err.stack}`)
@@ -221,13 +222,13 @@ class WorkerObject {
 
   addConfig(config) {
     const oldConfig = JSON.parse(this.options.override || '{}')
-    
+
     // Remove customLocatorStrategies from both old and new config before JSON serialization
     // since functions cannot be serialized and will be lost, causing workers to have empty strategies
     const configWithoutFunctions = { ...config }
-    
+
     // Clean both old and new config
-    const cleanConfig = (cfg) => {
+    const cleanConfig = cfg => {
       if (cfg.helpers) {
         cfg.helpers = { ...cfg.helpers }
         Object.keys(cfg.helpers).forEach(helperName => {
@@ -239,14 +240,12 @@ class WorkerObject {
       }
       return cfg
     }
-    
+
     const cleanedOldConfig = cleanConfig(oldConfig)
     const cleanedNewConfig = cleanConfig(configWithoutFunctions)
-    
-    const newConfig = {
-      ...cleanedOldConfig,
-      ...cleanedNewConfig,
-    }
+
+    // Deep merge configurations to preserve all helpers from base config
+    const newConfig = merge({}, cleanedOldConfig, cleanedNewConfig)
     this.options.override = JSON.stringify(newConfig)
   }
 
@@ -280,8 +279,8 @@ class Workers extends EventEmitter {
     this.setMaxListeners(50)
     this.codeceptPromise = initializeCodecept(config.testConfig, config.options)
     this.codecept = null
-    this.config = config  // Save config
-    this.numberOfWorkersRequested = numberOfWorkers  // Save requested worker count
+    this.config = config // Save config
+    this.numberOfWorkersRequested = numberOfWorkers // Save requested worker count
     this.options = config.options || {}
     this.errors = []
     this.numberOfWorkers = 0
@@ -304,11 +303,8 @@ class Workers extends EventEmitter {
       // Initialize workers in these cases:
       // 1. Positive number requested AND no manual workers pre-spawned
       // 2. Function-based grouping (indicated by negative number) AND no manual workers pre-spawned
-      const shouldAutoInit = this.workers.length === 0 && (
-        (Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) ||
-        (this.numberOfWorkersRequested < 0 && isFunction(this.config.by))
-      )
-      
+      const shouldAutoInit = this.workers.length === 0 && ((Number.isInteger(this.numberOfWorkersRequested) && this.numberOfWorkersRequested > 0) || (this.numberOfWorkersRequested < 0 && isFunction(this.config.by)))
+
       if (shouldAutoInit) {
         this._initWorkers(this.numberOfWorkersRequested, this.config)
       }
@@ -319,7 +315,7 @@ class Workers extends EventEmitter {
     this.splitTestsByGroups(numberOfWorkers, config)
     // For function-based grouping, use the actual number of test groups created
     const actualNumberOfWorkers = isFunction(config.by) ? this.testGroups.length : numberOfWorkers
-    this.workers = createWorkerObjects(this.testGroups, this.codecept.config, config.testConfig, config.options, config.selectedRuns)
+    this.workers = createWorkerObjects(this.testGroups, this.codecept.config, getTestRoot(config.testConfig), config.options, config.selectedRuns)
     this.numberOfWorkers = this.workers.length
   }
 
@@ -371,9 +367,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfTests(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(numberOfWorkers)
-  const files = this.codecept.testFiles
+    // If Codecept isn't initialized yet, return empty groups as a safe fallback
+    if (!this.codecept) return populateGroups(numberOfWorkers)
+    const files = this.codecept.testFiles
     const mocha = Container.mocha()
     mocha.files = files
     mocha.loadFiles()
@@ -430,7 +426,7 @@ class Workers extends EventEmitter {
     for (const file of files) {
       this.testPool.push(file)
     }
-    
+
     this.testPoolInitialized = true
   }
 
@@ -443,7 +439,7 @@ class Workers extends EventEmitter {
     if (!this.testPoolInitialized) {
       this._initializeTestPool()
     }
-    
+
     return this.testPool.shift()
   }
 
@@ -451,9 +447,9 @@ class Workers extends EventEmitter {
    * @param {Number} numberOfWorkers
    */
   createGroupsOfSuites(numberOfWorkers) {
-  // If Codecept isn't initialized yet, return empty groups as a safe fallback
-  if (!this.codecept) return populateGroups(numberOfWorkers)
-  const files = this.codecept.testFiles
+    // If Codecept isn't initialized yet, return empty groups as a safe fallback
+    if (!this.codecept) return populateGroups(numberOfWorkers)
+    const files = this.codecept.testFiles
     const groups = populateGroups(numberOfWorkers)
 
     const mocha = Container.mocha()
@@ -494,7 +490,7 @@ class Workers extends EventEmitter {
     recorder.startUnlessRunning()
     event.dispatcher.emit(event.workers.before)
     process.env.RUNS_WITH_WORKERS = 'true'
-    
+
     // Create workers and set up message handlers immediately (not in recorder queue)
     // This prevents a race condition where workers start sending messages before handlers are attached
     const workerThreads = []
@@ -503,11 +499,11 @@ class Workers extends EventEmitter {
       this._listenWorkerEvents(workerThread)
       workerThreads.push(workerThread)
     }
-    
+
     recorder.add('workers started', () => {
       // Workers are already running, this is just a placeholder step
     })
-    
+
     return new Promise(resolve => {
       this.on('end', resolve)
     })
@@ -591,7 +587,7 @@ class Workers extends EventEmitter {
           // Otherwise skip - we'll emit based on finished state
           break
         case event.test.passed:
-          // Skip individual passed events - we'll emit based on finished state  
+          // Skip individual passed events - we'll emit based on finished state
           break
         case event.test.skipped:
           this.emit(event.test.skipped, deserializeTest(message.data))
@@ -602,15 +598,15 @@ class Workers extends EventEmitter {
             const data = message.data
             const uid = data?.uid
             const isFailed = !!data?.err || data?.state === 'failed'
-            
+
             if (uid) {
               // Track states for each test UID
               if (!this._testStates) this._testStates = new Map()
-              
+
               if (!this._testStates.has(uid)) {
                 this._testStates.set(uid, { states: [], lastData: data })
               }
-              
+
               const testState = this._testStates.get(uid)
               testState.states.push({ isFailed, data })
               testState.lastData = data
@@ -622,7 +618,7 @@ class Workers extends EventEmitter {
                 this.emit(event.test.passed, deserializeTest(data))
               }
             }
-            
+
             this.emit(event.test.finished, deserializeTest(data))
           }
           break
@@ -682,11 +678,10 @@ class Workers extends EventEmitter {
         // For tests with retries configured, emit all failures + final success
         // For tests without retries, emit only final state
         const lastState = states[states.length - 1]
-        
+
         // Check if this test had retries by looking for failure followed by success
-        const hasRetryPattern = states.length > 1 && 
-          states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
-        
+        const hasRetryPattern = states.length > 1 && states.some((s, i) => s.isFailed && i < states.length - 1 && !states[i + 1].isFailed)
+
         if (hasRetryPattern) {
           // Emit all intermediate failures and final success for retries
           for (const state of states) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeceptjs",
-  "version": "4.0.1-beta.1",
+  "version": "4.0.1-beta.10",
   "type": "module",
   "description": "Supercharged End 2 End Testing Framework for NodeJS",
   "keywords": [