codeceptjs 4.0.2-beta.9 → 4.0.2

package/lib/command/workers/runTests.js

@@ -11,7 +11,7 @@ import { parentPort, workerData } from 'worker_threads'
 
 // Delay imports to avoid ES Module loader race conditions in Node 22.x worker threads
 // These will be imported dynamically when needed
-let event, container, Codecept, getConfig, tryOrDefault, deepMerge
+let event, container, Codecept, getConfig, tryOrDefault, deepMerge, fixErrorStack
 
 let stdout = ''
 
@@ -21,25 +21,40 @@ const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
 // Global error handlers to catch critical errors but not test failures
 process.on('uncaughtException', (err) => {
+  if (container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = container.tsFileMapping()
+    if (fileMapping) {
+      fixErrorStack(err, fileMapping)
+    }
+  }
+
+  // Log to stderr to bypass stdout suppression
+  process.stderr.write(`[Worker ${workerIndex}] UNCAUGHT EXCEPTION: ${err.message}\n`)
+  process.stderr.write(`${err.stack}\n`)
+
   // Don't exit on test assertion errors - those are handled by mocha
   if (err.name === 'AssertionError' || err.message?.includes('expected')) {
-    console.error(`[Worker ${workerIndex}] Test assertion error (handled by mocha):`, err.message)
     return
   }
-  console.error(`[Worker ${workerIndex}] Uncaught exception:`, err.message)
-  console.error(err.stack)
   process.exit(1)
 })
 
 process.on('unhandledRejection', (reason, promise) => {
-  // Don't exit on test-related rejections
+  if (reason && typeof reason === 'object' && reason.stack && container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = container.tsFileMapping()
+    if (fileMapping) {
+      fixErrorStack(reason, fileMapping)
+    }
+  }
+
+  // Log to stderr to bypass stdout suppression
   const msg = reason?.message || String(reason)
-  if (msg.includes('expected') || msg.includes('AssertionError')) {
-    console.error(`[Worker ${workerIndex}] Test rejection (handled by mocha):`, msg)
-    return
+  process.stderr.write(`[Worker ${workerIndex}] UNHANDLED REJECTION: ${msg}\n`)
+  if (reason?.stack) {
+    process.stderr.write(`${reason.stack}\n`)
   }
-  console.error(`[Worker ${workerIndex}] Unhandled rejection:`, reason)
-  process.exit(1)
+
+  // Do not exit — killing the worker silently drops every remaining test from the report.
 })
 
 // hide worker output
@@ -49,6 +64,10 @@ if (poolMode && !options.debug) {
   // In pool mode without debug, allow test names and important output but suppress verbose details
   const originalWrite = process.stdout.write
   process.stdout.write = string => {
+    // Always allow Worker logs
+    if (string.includes('[Worker')) {
+      return originalWrite.call(process.stdout, string)
+    }
     // Allow test names (✔ or ✖), Scenario Steps, failures, and important markers
     if (
       string.includes('✔') ||
@@ -68,7 +87,12 @@ if (poolMode && !options.debug) {
     return originalWrite.call(process.stdout, string)
   }
 } else if (!poolMode && !options.debug && !options.verbose) {
+  const originalWrite = process.stdout.write
   process.stdout.write = string => {
+    // Always allow Worker logs
+    if (string.includes('[Worker')) {
+      return originalWrite.call(process.stdout, string)
+    }
     stdout += string
     return true
   }
@@ -105,24 +129,47 @@ let config
 // Load test and run
 initPromise = (async function () {
   try {
+    // Add staggered delay at the very start to prevent resource conflicts
+    // Longer delay for browser initialization conflicts
+    const delay = (workerIndex - 1) * 2000 // 0ms, 2s, 4s, etc.
+    if (delay > 0) {
+      await new Promise(resolve => setTimeout(resolve, delay))
+    }
+    
     // Import modules dynamically to avoid ES Module loader race conditions in Node 22.x
     const eventModule = await import('../../event.js')
     const containerModule = await import('../../container.js')
     const utilsModule = await import('../utils.js')
     const coreUtilsModule = await import('../../utils.js')
     const CodeceptModule = await import('../../codecept.js')
-    
+    const typescriptModule = await import('../../utils/typescript.js')
+
     event = eventModule.default
     container = containerModule.default
     getConfig = utilsModule.getConfig
     tryOrDefault = coreUtilsModule.tryOrDefault
     deepMerge = coreUtilsModule.deepMerge
     Codecept = CodeceptModule.default
+    fixErrorStack = typescriptModule.fixErrorStack
     
     const overrideConfigs = tryOrDefault(() => JSON.parse(options.override), {})
     
-    // IMPORTANT: await is required here since getConfig is async
-    const baseConfig = await getConfig(options.config || testRoot)
+    let baseConfig
+    try {
+      // IMPORTANT: await is required here since getConfig is async
+      baseConfig = await getConfig(options.config || testRoot)
+    } catch (configErr) {
+      if (container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = container.tsFileMapping()
+        if (fileMapping) {
+          fixErrorStack(configErr, fileMapping)
+        }
+      }
+      process.stderr.write(`[Worker ${workerIndex}] FAILED loading config: ${configErr.message}\n`)
+      process.stderr.write(`${configErr.stack}\n`)
+      await new Promise(resolve => setTimeout(resolve, 100))
+      process.exit(1)
+    }
     
     // important deep merge so dynamic things e.g. functions on config are not overridden
     config = deepMerge(baseConfig, overrideConfigs)
@@ -130,7 +177,21 @@ initPromise = (async function () {
     // Pass workerIndex as child option for output.process() to display worker prefix
     const optsWithChild = { ...options, child: workerIndex }
     codecept = new Codecept(config, optsWithChild)
-    await codecept.init(testRoot)
+    
+    try {
+      await codecept.init(testRoot)
+    } catch (initErr) {
+      if (container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = container.tsFileMapping()
+        if (fileMapping) {
+          fixErrorStack(initErr, fileMapping)
+        }
+      }
+      process.stderr.write(`[Worker ${workerIndex}] FAILED during codecept.init(): ${initErr.message}\n`)
+      process.stderr.write(`${initErr.stack}\n`)
+      process.exit(1)
+    }
+    
     codecept.loadTests()
     mocha = container.mocha()
 
@@ -139,10 +200,7 @@ initPromise = (async function () {
       // We'll reload test files fresh for each test request
     } else {
       // Legacy mode - filter tests upfront
-      console.log(`[Worker ${workerIndex}] Starting test filtering. Assigned ${tests.length} test UIDs`)
       filterTests()
-      const finalCount = mocha.suite.total()
-      console.log(`[Worker ${workerIndex}] After filtering: ${finalCount} tests to run`)
     }
 
     // run tests
@@ -156,7 +214,14 @@ initPromise = (async function () {
       parentPort?.close()
     }
   } catch (err) {
-    console.error('Error in worker initialization:', err)
+    if (container?.tsFileMapping && fixErrorStack) {
+      const fileMapping = container.tsFileMapping()
+      if (fileMapping) {
+        fixErrorStack(err, fileMapping)
+      }
+    }
+    process.stderr.write(`[Worker ${workerIndex}] FATAL ERROR: ${err.message}\n`)
+    process.stderr.write(`${err.stack}\n`)
     process.exit(1)
   }
 })()
@@ -167,7 +232,6 @@ async function runTests() {
   try {
     await codecept.bootstrap()
   } catch (err) {
-    console.error(`[Worker ${workerIndex}] Bootstrap error:`, err.message)
     throw new Error(`Error while running bootstrap file :${err}`)
   }
   listenToParentThread()
@@ -176,13 +240,12 @@ async function runTests() {
   try {
     await codecept.run()
   } catch (err) {
-    console.error(`[Worker ${workerIndex}] Runtime error:`, err.message)
     throw err
   } finally {
     try {
       await codecept.teardown()
     } catch (err) {
-      console.error(`[Worker ${workerIndex}] Teardown error:`, err.message)
+      // Ignore teardown errors
     }
   }
 }
@@ -371,26 +434,6 @@ function filterTests() {
   mocha.files = files
   mocha.loadFiles()
 
-  // Collect all loaded tests for debugging
-  const allLoadedTests = [];
-  mocha.suite.eachTest(test => {
-    if (test) {
-      allLoadedTests.push({ uid: test.uid, title: test.fullTitle() });
-    }
-  });
-  
-  console.log(`[Worker ${workerIndex}] Loaded ${allLoadedTests.length} tests from ${files.length} files`);
-  console.log(`[Worker ${workerIndex}] Expecting ${tests.length} test UIDs`);
-  
-  const loadedUids = new Set(allLoadedTests.map(t => t.uid));
-  const missingTests = tests.filter(uid => !loadedUids.has(uid));
-  
-  if (missingTests.length > 0) {
-    console.error(`[Worker ${workerIndex}] ERROR: ${missingTests.length} assigned tests NOT FOUND in loaded files!`);
-    console.error(`[Worker ${workerIndex}] Missing UIDs:`, missingTests);
-    console.error(`[Worker ${workerIndex}] Available UIDs:`, Array.from(loadedUids).slice(0, 5), '...');
-  }
-
   // Recursively filter tests in all suites (including nested ones)
   const filterSuiteTests = (suite) => {
     suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)

package/lib/config.js

@@ -15,8 +15,9 @@ const defaultConfig = {
   hooks: [],
   gherkin: {},
   plugins: {
-    screenshotOnFail: {
-      enabled: true, // will be disabled by default in 2.0
+    screenshot: {
+      enabled: true,
+      on: 'fail',
     },
   },
   stepTimeout: 0,
@@ -32,9 +33,27 @@ const defaultConfig = {
   ],
 }
 
+// Array<{ fn: (cfg) => void, ran: boolean, error?: Error }>
 let hooks = []
 let config = {}
 
+// Apply a single hook against `cfg`, swallowing errors so one broken hook
+// can't take down the whole run. The failure is logged through the
+// framework's own output module (when available) so it shows up in test
+// reports; the hook is still marked ran so it doesn't get retried.
+function applyHook(hook, cfg) {
+  try {
+    hook.fn(cfg)
+  } catch (err) {
+    hook.error = err
+    const out = globalThis.codeceptjs?.output
+    if (out && typeof out.error === 'function') out.error(`config hook failed: ${err.message}`)
+    else console.error('config hook failed:', err)
+  } finally {
+    hook.ran = true
+  }
+}
+
 const configFileNames = ['codecept.config.js', 'codecept.conf.js', 'codecept.js', 'codecept.config.cjs', 'codecept.conf.cjs', 'codecept.config.ts', 'codecept.conf.ts']
 
 /**
@@ -49,7 +68,11 @@ class Config {
    */
   static create(newConfig) {
     config = deepMerge(deepClone(defaultConfig), newConfig)
-    hooks.forEach(f => f(config))
+    // Re-apply every hook against the freshly built config; hooks added later
+    // (e.g. from plugin boot) stay pending until runPendingHooks. Array
+    // iterators re-check length on each step, so hooks pushed during a hook
+    // execution are visited in this same pass.
+    for (const hook of hooks) applyHook(hook, config)
     return config
   }
 
@@ -121,7 +144,48 @@ class Config {
   }
 
   static addHook(fn) {
-    hooks.push(fn)
+    hooks.push({ fn, ran: false })
+  }
+
+  /**
+   * Run every hook that hasn't been applied to the current config yet.
+   * Hooks added after `Config.create()` (e.g. from plugin boot code) stay
+   * pending until this is called; once it runs, they're marked applied so
+   * subsequent calls are no-ops. Hooks added while pending hooks are running
+   * are picked up in the same pass (the array iterator re-checks length).
+   *
+   * Failures are logged through `output.error` and don't abort the loop —
+   * a broken hook can't poison the run, but its error is visible.
+   *
+   * @param {Object<string, *>} [cfg] target config (defaults to the live singleton)
+   * @return {boolean} true if any hook ran
+   */
+  static runPendingHooks(cfg = config) {
+    let ran = false
+    for (const hook of hooks) {
+      if (hook.ran) continue
+      applyHook(hook, cfg)
+      ran = true
+    }
+    return ran
+  }
+
+  /**
+   * Number of registered config hooks. Useful for snapshotting before a phase
+   * (e.g. plugin loading) and re-running only the hooks added during it.
+   * @return {number}
+   */
+  static hooksCount() {
+    return hooks.length
+  }
+
+  /**
+   * Run hooks in `[fromIndex, end)` against the given config object, mutating it.
+   * @param {number} fromIndex
+   * @param {Object<string, *>} cfg
+   */
+  static runHooksFrom(fromIndex, cfg) {
+    for (let i = fromIndex; i < hooks.length; i++) hooks[i](cfg)
   }
 
   /**
@@ -150,33 +214,47 @@ async function loadConfigFile(configFile) {
   const require = createRequire(import.meta.url)
   const extensionName = path.extname(configFile)
 
+  // Populate the in-process registry that packages like @codeceptjs/configure
+  // look up at config-import time (their proxies throw if `globalThis.codeceptjs`
+  // is missing). initCodeceptGlobals sets this too, but only later during
+  // bootstrap — config files are imported here first.
+  if (!globalThis.codeceptjs) {
+    const indexModule = await import('./index.js')
+    globalThis.codeceptjs = indexModule.default || indexModule
+  }
+
   // .conf.js config file
   if (extensionName === '.js' || extensionName === '.ts' || extensionName === '.cjs') {
     let configModule
     try {
       // For .ts files, try to compile and load as JavaScript
       if (extensionName === '.ts') {
+        let transpileError = null
+        let tempFile = null
+        let allTempFiles = null
+        let fileMapping = null
+
         try {
           // Use the TypeScript transpilation utility
           const typescript = require('typescript')
-          const { tempFile, allTempFiles, fileMapping } = await transpileTypeScript(configFile, typescript)
+          const result = await transpileTypeScript(configFile, typescript)
+          tempFile = result.tempFile
+          allTempFiles = result.allTempFiles
+          fileMapping = result.fileMapping
 
-          try {
-            configModule = await import(tempFile)
-            cleanupTempFiles(allTempFiles)
-          } catch (err) {
+          configModule = await import(tempFile)
+          cleanupTempFiles(allTempFiles)
+        } catch (err) {
+          transpileError = err
+          if (fileMapping) {
             fixErrorStack(err, fileMapping)
-            cleanupTempFiles(allTempFiles)
-            throw err
           }
-        } catch (tsError) {
-          // If TypeScript compilation fails, fallback to ts-node
-          try {
-            require('ts-node/register')
-            configModule = require(configFile)
-          } catch (tsNodeError) {
-            throw new Error(`Failed to load TypeScript config: ${tsError.message}`)
+          if (allTempFiles) {
+            cleanupTempFiles(allTempFiles)
           }
+          // Throw immediately with the actual error - don't fall back to ts-node
+          // as it will mask the real error with "Unexpected token 'export'"
+          throw err
         }
       } else {
         // Try ESM import first for JS files

package/lib/container.js

@@ -1,6 +1,7 @@
 import { globSync } from 'glob'
 import path from 'path'
 import fs from 'fs'
+import { isMainThread } from 'worker_threads'
 import debugModule from 'debug'
 const debug = debugModule('codeceptjs:container')
 import { MetaStep } from './step.js'
@@ -15,9 +16,15 @@ import store from './store.js'
 import Result from './result.js'
 import ai from './ai.js'
 import actorFactory from './actor.js'
+import Config from './config.js'
 
 let asyncHelperPromise
 
+let beforeCalledSet = new Set()
+
+export function getBeforeCalledSet() { return beforeCalledSet }
+export function resetBeforeCalledSet() { beforeCalledSet = new Set() }
+
 let container = {
   helpers: {},
   support: {},
@@ -116,6 +123,18 @@ class Container {
     // Wait for all async helpers to finish loading and populate the actor
     await asyncHelperPromise
 
+    // Plugins may have registered Config hooks during their boot. Run anything
+    // that hasn't been applied yet and re-feed the mutated helper config to the
+    // already-instantiated helpers.
+    if (Config.runPendingHooks(config)) {
+      for (const name of Object.keys(container.helpers)) {
+        const helper = container.helpers[name]
+        if (helper && typeof helper._setConfig === 'function' && config.helpers && config.helpers[name]) {
+          helper._setConfig(config.helpers[name])
+        }
+      }
+    }
+
     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
@@ -150,10 +169,23 @@ class Container {
     if (!name) {
       return container.proxySupport
     }
-    // Always return the proxy to ensure MetaStep creation works
+    if (typeof container.support[name] === 'function') {
+      return container.support[name]
+    }
     return container.proxySupport[name]
   }
 
+  /**
+   * Get raw (non-proxied) support objects for direct access.
+   * Used by listeners to call lifecycle hooks without MetaStep wrapping.
+   *
+   * @api
+   * @returns {object}
+   */
+  static supportObjects() {
+    return container.support
+  }
+
   /**
    * Get all helpers or get a helper by name
    *
@@ -183,7 +215,7 @@ class Container {
    * @api
    */
   static tsFileMapping() {
-    return container.tsFileMapping
+    return store.tsFileMapping
   }
 
   /**
@@ -426,11 +458,11 @@ async function requireHelperFromModule(helperName, config, HelperClass) {
         tempJsFile = allTempFiles
         fileMapping = mapping
         // Store file mapping in container for runtime error fixing (merge with existing)
-        if (!container.tsFileMapping) {
-          container.tsFileMapping = new Map()
+        if (!store.tsFileMapping) {
+          store.tsFileMapping = new Map()
         }
         for (const [key, value] of mapping.entries()) {
-          container.tsFileMapping.set(key, value)
+          store.tsFileMapping.set(key, value)
         }
       } catch (tsError) {
         throw new Error(`Failed to load TypeScript helper ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
@@ -542,6 +574,19 @@ function createSupportObjects(config) {
           let currentValue = currentObject[prop]
 
           if (isFunction(currentValue) || isAsyncFunction(currentValue)) {
+            if (prop.toString().charAt(0) !== '_' && currentObject._before && !beforeCalledSet.has(name)) {
+              beforeCalledSet.add(name)
+              const originalValue = currentValue
+              const wrappedValue = async function (...args) {
+                await currentObject._before()
+                return originalValue.apply(currentObject, args)
+              }
+              const ms = new MetaStep(name, prop)
+              ms.setContext(currentObject)
+              debug(`metastep is created for ${name}.${prop.toString()}() (with _before)`)
+              return ms.run.bind(ms, asyncWrapper(wrappedValue))
+            }
+
             const ms = new MetaStep(name, prop)
             ms.setContext(currentObject)
             if (isAsyncFunction(currentValue)) currentValue = asyncWrapper(currentValue)
@@ -600,6 +645,8 @@ function createSupportObjects(config) {
         let value
         if (container.sharedKeys.has(prop) && prop in container.support) {
           value = container.support[prop]
+        } else if (prop in container.support && typeof container.support[prop] === 'function') {
+          value = container.support[prop]
         } else {
           value = lazyLoad(prop)
         }
@@ -614,6 +661,9 @@ function createSupportObjects(config) {
         if (container.sharedKeys.has(key) && key in container.support) {
           return container.support[key]
         }
+        if (key in container.support && typeof container.support[key] === 'function') {
+          return container.support[key]
+        }
         return lazyLoad(key)
       },
     },
@@ -654,26 +704,55 @@ async function loadPluginFallback(modulePath, config) {
 async function createPlugins(config, options = {}) {
   const plugins = {}
 
-  const enabledPluginsByOptions = (options.plugins || '').split(',')
+  const pluginOptionMap = new Map()
+  for (const token of (options.plugins || '').split(',').filter(Boolean)) {
+    const parts = token.split(':')
+    pluginOptionMap.set(parts[0], parts.slice(1))
+  }
+
+  for (const [name] of pluginOptionMap) {
+    if (!config[name]) config[name] = {}
+  }
+
   for (const pluginName in config) {
     if (!config[pluginName]) config[pluginName] = {}
-    if (!config[pluginName].enabled && enabledPluginsByOptions.indexOf(pluginName) < 0) {
+    const pluginConfig = config[pluginName]
+    const enabledByCli = pluginOptionMap.has(pluginName)
+    if (!pluginConfig.enabled && !enabledByCli) {
       continue // plugin is disabled
     }
+
+    if (enabledByCli && pluginOptionMap.get(pluginName).length > 0) {
+      pluginConfig._args = pluginOptionMap.get(pluginName)
+    }
+
+    // Generic workers gate:
+    // - runInWorker / runInWorkers controls plugin execution inside worker threads.
+    // - runInParent / runInMain can disable plugin in workers parent process.
+    const runInWorker = pluginConfig.runInWorker ?? pluginConfig.runInWorkers ?? (pluginName === 'testomatio' ? false : true)
+    const runInParent = pluginConfig.runInParent ?? pluginConfig.runInMain ?? true
+
+    if (!isMainThread && !runInWorker) {
+      continue
+    }
+
+    if (isMainThread && store.workerMode && !runInParent) {
+      continue
+    }
     let module
     try {
-      if (config[pluginName].require) {
-        module = config[pluginName].require
+      if (pluginConfig.require) {
+        module = pluginConfig.require
         if (module.startsWith('.')) {
           // local
-          module = path.resolve(global.codecept_dir, module) // custom plugin
+          module = path.resolve(store.codeceptDir, module) // custom plugin
         }
       } else {
         module = `./plugin/${pluginName}.js`
       }
 
       // Use async loading for all plugins (ESM and CJS)
-      plugins[pluginName] = await loadPluginAsync(module, config[pluginName])
+      plugins[pluginName] = await loadPluginAsync(module, pluginConfig)
       debug(`plugin ${pluginName} loaded via async import`)
     } catch (err) {
       throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}\n${err.stack}`)
@@ -683,12 +762,24 @@ async function createPlugins(config, options = {}) {
 }
 
 async function loadGherkinStepsAsync(paths) {
+  // Import BDD module to access step file tracking functions and step DSL
+  const bddModule = await import('./mocha/bdd.js')
+
   global.Before = fn => event.dispatcher.on(event.test.started, fn)
   global.After = fn => event.dispatcher.on(event.test.finished, fn)
   global.Fail = fn => event.dispatcher.on(event.test.failed, fn)
 
-  // Import BDD module to access step file tracking functions
-  const bddModule = await import('./mocha/bdd.js')
+  // Scope-inject Given/When/Then/And while loading step files so they work
+  // with noGlobals: true. When noGlobals: false, globals.js has already set
+  // them as permanent globals — skip to avoid deleting them at the end.
+  const injectStepDsl = !!store.noGlobals
+  if (injectStepDsl) {
+    global.Given = bddModule.Given
+    global.When = bddModule.When
+    global.Then = bddModule.Then
+    global.And = bddModule.And
+    global.DefineParameterType = bddModule.defineParameterType
+  }
 
   // If gherkin.steps is string, then this will iterate through that folder and send all step def js files to loadSupportObject
   // If gherkin.steps is Array, it will go the old way
@@ -701,7 +792,7 @@ async function loadGherkinStepsAsync(paths) {
       bddModule.clearCurrentStepFile()
     }
   } else {
-    const folderPath = paths.startsWith('.') ? normalizeAndJoin(global.codecept_dir, paths) : ''
+    const folderPath = paths.startsWith('.') ? normalizeAndJoin(store.codeceptDir, paths) : ''
     if (folderPath !== '') {
       const files = globSync(folderPath)
       for (const file of files) {
@@ -716,6 +807,13 @@ async function loadGherkinStepsAsync(paths) {
   delete global.Before
   delete global.After
   delete global.Fail
+  if (injectStepDsl) {
+    delete global.Given
+    delete global.When
+    delete global.Then
+    delete global.And
+    delete global.DefineParameterType
+  }
 }
 
 function loadGherkinSteps(paths) {
@@ -749,7 +847,7 @@ async function loadSupportObject(modulePath, supportObjectName) {
     }
   }
   if (typeof modulePath === 'string' && modulePath.charAt(0) === '.') {
-    modulePath = path.join(global.codecept_dir, modulePath)
+    modulePath = path.join(store.codeceptDir, modulePath)
   }
   try {
     // Use dynamic import for both ESM and CJS modules
@@ -873,7 +971,7 @@ async function loadTranslation(locale, vocabularies) {
   const langs = await Translation.getLangs()
   if (langs[locale]) {
     translation = new Translation(langs[locale])
-  } else if (fileExists(path.join(global.codecept_dir, locale))) {
+  } else if (fileExists(path.join(store.codeceptDir, locale))) {
     // get from a provided file instead
     translation = Translation.createDefault()
     translation.loadVocabulary(locale)
@@ -890,7 +988,7 @@ function getHelperModuleName(helperName, config) {
   // classical require
   if (config[helperName].require) {
     if (config[helperName].require.startsWith('.')) {
-      let helperPath = path.resolve(global.codecept_dir, config[helperName].require)
+      let helperPath = path.resolve(store.codeceptDir, config[helperName].require)
       // Add .js extension if not present for ESM compatibility
       if (!path.extname(helperPath)) {
         helperPath += '.js'