codeceptjs 4.0.0-beta.1 → 4.0.0-beta.11.esm-aria

package/lib/container.js

@@ -1,34 +1,50 @@
-import glob from 'glob';
-import path, { dirname } from 'path';
-import importSync from 'import-sync';
-import { fileURLToPath } from 'url';
-import { MetaStep } from './step.js';
-import {
-  fileExists, isFunction, isAsyncFunction, deepMerge,
-} from './utils.js';
-import Translation from './translation.js';
-import { MochaFactory } from './mochaFactory.js';
-// eslint-disable-next-line import/no-named-as-default
-import recorder from './recorder.js';
-import * as event from './event.js';
-import * as WorkerStorage from './workerStorage.js';
-import { store } from './store.js';
-import { actor } from './actor.js';
-
-import ai from './ai.js';
+import { globSync } from 'glob'
+import path from 'path'
+import fs from 'fs'
+import debugModule from 'debug'
+const debug = debugModule('codeceptjs:container')
+import { MetaStep } from './step.js'
+import { methodsOfObject, fileExists, isFunction, isAsyncFunction, installedLocally, deepMerge } from './utils.js'
+import Translation from './translation.js'
+import MochaFactory from './mocha/factory.js'
+import recorder from './recorder.js'
+import event from './event.js'
+import WorkerStorage from './workerStorage.js'
+import store from './store.js'
+import Result from './result.js'
+import ai from './ai.js'
+import actorFactory from './actor.js'
+
+let asyncHelperPromise
 
 let container = {
   helpers: {},
   support: {},
+  proxySupport: {},
   plugins: {},
+  actor: null,
+  /**
+   * @type {Mocha | {}}
+   * @ignore
+   */
   mocha: {},
   translation: {},
-};
+  /** @type {Result | null} */
+  result: null,
+  sharedKeys: new Set() // Track keys shared via share() function
+}
 
 /**
  * Dependency Injection Container
  */
-export default class Container {
+class Container {
+  /**
+   * Get the standard acting helpers of CodeceptJS Container
+   *
+   */
+  static get STANDARD_ACTING_HELPERS() {
+    return ['Playwright', 'WebDriver', 'Puppeteer', 'Appium']
+  }
   /**
    * Create container with all required helpers and support objects
    *
@@ -36,22 +52,70 @@ export default class Container {
    * @param {*} config
    * @param {*} opts
    */
-  static create(config, opts) {
-    const mochaConfig = config.mocha || {};
-    if (config.grep && !opts.grep) {
-      mochaConfig.grep = config.grep;
+  static async create(config, opts) {
+    debug('creating container')
+    asyncHelperPromise = Promise.resolve()
+
+    // dynamically create mocha instance
+    const mochaConfig = config.mocha || {}
+    if (config.grep && !opts.grep) mochaConfig.grep = config.grep
+    this.createMocha = () => (container.mocha = MochaFactory.create(mochaConfig, opts || {}))
+    this.createMocha()
+
+    // create support objects
+    container.support = {}
+    container.helpers = await createHelpers(config.helpers || {})
+    container.translation = await loadTranslation(config.translation || null, config.vocabularies || [])
+    container.proxySupport = createSupportObjects(config.include || {})
+    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
+    if (Object.prototype.hasOwnProperty.call(includes, 'I')) {
+      try {
+        const mod = includes.I
+        if (typeof mod === 'string') {
+          container.support.I = await loadSupportObject(mod, 'I')
+        } else if (typeof mod === 'function') {
+          container.support.I = await loadSupportObject(mod, 'I')
+        } else if (mod && typeof mod === 'object') {
+          container.support.I = mod
+        }
+      } catch (e) {
+        throw new Error(`Could not include object I: ${e.message}`)
+      }
+    } else {
+      // Create default actor if not provided via includes
+      createActor()
+    }
+
+    // Load remaining includes except I
+    for (const [name, mod] of Object.entries(includes)) {
+      if (name === 'I') continue
+      try {
+        if (typeof mod === 'string') {
+          container.support[name] = await loadSupportObject(mod, name)
+        } else if (typeof mod === 'function') {
+          // function or class
+          container.support[name] = await loadSupportObject(mod, name)
+        } else if (mod && typeof mod === 'object') {
+          container.support[name] = mod
+        }
+      } catch (e) {
+        throw new Error(`Could not include object ${name}: ${e.message}`)
+      }
     }
-    this.createMocha = () => {
-      container.mocha = MochaFactory.create(mochaConfig, opts || {});
-    };
-    this.createMocha();
-    container.helpers = createHelpers(config.helpers || {});
-    container.translation = loadTranslation(config.translation || null, config.vocabularies || []);
-    container.support = createSupportObjects(config.include || {});
-    container.plugins = createPlugins(config.plugins || {}, opts);
-    if (opts && opts.ai) ai.enable(config.ai); // enable AI Assistant
-    if (config.gherkin) loadGherkinSteps(config.gherkin.steps || []);
-    if (opts && typeof opts.timeouts === 'boolean') store.timeouts = opts.timeouts;
+
+    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
+  }
+
+  static actor() {
+    return container.support.I
   }
 
   /**
@@ -62,7 +126,10 @@ export default class Container {
    * @returns { * }
    */
   static plugins(name) {
-    return name ? container.plugins[name] : container.plugins;
+    if (!name) {
+      return container.plugins
+    }
+    return container.plugins[name]
   }
 
   /**
@@ -74,9 +141,10 @@ export default class Container {
    */
   static support(name) {
     if (!name) {
-      return container.support;
+      return container.proxySupport
     }
-    return container.support[name];
+    // Always return the proxy to ensure MetaStep creation works
+    return container.proxySupport[name]
   }
 
   /**
@@ -88,9 +156,9 @@ export default class Container {
    */
   static helpers(name) {
     if (!name) {
-      return container.helpers;
+      return container.helpers
     }
-    return container.helpers[name];
+    return container.helpers[name]
   }
 
   /**
@@ -99,7 +167,7 @@ export default class Container {
    * @api
    */
   static translation() {
-    return container.translation;
+    return container.translation
   }
 
   /**
@@ -109,7 +177,19 @@ export default class Container {
    * @returns { * }
    */
   static mocha() {
-    return container.mocha;
+    return container.mocha
+  }
+
+  /**
+   * Get result
+   *
+   * @returns {Result}
+   */
+  static result() {
+    if (!container.result) {
+      container.result = new Result()
+    }
+    return container.result
   }
 
   /**
@@ -119,7 +199,15 @@ export default class Container {
    * @param {Object<string, *>} newContainer
    */
   static append(newContainer) {
-    container = deepMerge(container, newContainer);
+    container = deepMerge(container, newContainer)
+
+    // If new support objects are added, update the proxy support
+    if (newContainer.support) {
+      const newProxySupport = createSupportObjects(newContainer.support)
+      container.proxySupport = { ...container.proxySupport, ...newProxySupport }
+    }
+
+    debug('appended', JSON.stringify(newContainer).slice(0, 300))
   }
 
   /**
@@ -129,11 +217,26 @@ export default class Container {
    * @param {Object<string, *>} newSupport
    * @param {Object<string, *>} newPlugins
    */
-  static clear(newHelpers, newSupport, newPlugins) {
-    container.helpers = newHelpers || {};
-    container.support = newSupport || {};
-    container.plugins = newPlugins || {};
-    container.translation = loadTranslation();
+  static async clear(newHelpers = {}, newSupport = {}, newPlugins = {}) {
+    container.helpers = newHelpers
+    container.translation = await loadTranslation()
+    container.proxySupport = createSupportObjects(newSupport)
+    container.plugins = newPlugins
+    container.sharedKeys = new Set() // Clear shared keys
+    asyncHelperPromise = Promise.resolve()
+    store.actor = null
+    debug('container cleared')
+  }
+
+  /**
+   * @param {Function|null} fn
+   * @returns {Promise<void>}
+   */
+  static async started(fn = null) {
+    if (fn) {
+      asyncHelperPromise = asyncHelperPromise.then(fn)
+    }
+    return asyncHelperPromise
   }
 
   /**
@@ -143,308 +246,710 @@ export default class Container {
    * @param {Object} options - set {local: true} to not share among workers
    */
   static share(data, options = {}) {
-    Container.append({ support: data });
+    // Instead of using append which replaces the entire container,
+    // directly update the support object to maintain proxy references
+    Object.assign(container.support, data)
+    
+    // Track which keys were explicitly shared
+    Object.keys(data).forEach(key => container.sharedKeys.add(key))
+    
     if (!options.local) {
-      WorkerStorage.share(data);
+      WorkerStorage.share(data)
+    }
+  }
+
+  static createMocha(config = {}, opts = {}) {
+    const mochaConfig = config?.mocha || {}
+    if (config?.grep && !opts?.grep) {
+      mochaConfig.grep = config.grep
     }
+    container.mocha = MochaFactory.create(mochaConfig, opts || {})
   }
 }
 
-function createHelpers(config) {
-  const helpers = {};
-  let moduleName;
-  for (const helperName in config) {
+export default Container
+
+async function createHelpers(config) {
+  const helpers = {}
+  for (let helperName in config) {
     try {
-      if (config[helperName].require) {
-        if (config[helperName].require.startsWith('.')) {
-          // @ts-ignore
-          moduleName = path.resolve(global.codecept_dir, config[helperName].require); // custom helper
-        } else {
-          moduleName = config[helperName].require; // plugin helper
-        }
-      } else {
-        moduleName = `./helper/${helperName}.js`; // built-in helper
+      let HelperClass
+
+      // Check if helper class was stored in config during ESM import processing
+      if (config[helperName]._helperClass) {
+        HelperClass = config[helperName]._helperClass
+        debug(`helper ${helperName} loaded from ESM import`)
       }
 
-      // @ts-ignore
-      let HelperClass;
-      // check if the helper is the built-in, use the require() syntax.
-      if (moduleName.startsWith('./helper/')) {
-        const __dirname = dirname(fileURLToPath(import.meta.url));
-        HelperClass = importSync(path.resolve(__dirname, moduleName)).default;
-      } else {
-        // check if the new syntax export default HelperName is used and loads the Helper, otherwise loads the module that used old syntax export = HelperName.
-        HelperClass = importSync(path.resolve(moduleName)).default;
+      // ESM import (legacy check)
+      if (!HelperClass && typeof helperName === 'function' && helperName.prototype) {
+        HelperClass = helperName
+        helperName = HelperClass.constructor.name
       }
 
-      if (HelperClass && HelperClass._checkRequirements) {
-        const requirements = HelperClass._checkRequirements();
-        if (requirements) {
-          let install;
-          if (importSync('./utils.js').installedLocally()) {
-            install = `npm install --save-dev ${requirements.join(' ')}`;
-          } else {
-            console.log('WARNING: CodeceptJS is not installed locally. It is recommended to switch to local installation');
-            install = `[sudo] npm install -g ${requirements.join(' ')}`;
-          }
-          throw new Error(`Required modules are not installed.\n\nRUN: ${install}`);
+      // classical require - may be async for ESM modules
+      if (!HelperClass) {
+        const helperResult = requireHelperFromModule(helperName, config)
+        if (helperResult instanceof Promise) {
+          // Handle async ESM loading
+          helpers[helperName] = {}
+          asyncHelperPromise = asyncHelperPromise
+            .then(() => helperResult)
+            .then(async ResolvedHelperClass => {
+              debug(`helper ${helperName} resolved type: ${typeof ResolvedHelperClass}`, ResolvedHelperClass)
+
+              // Extract default export from ESM module wrapper if needed
+              if (ResolvedHelperClass && ResolvedHelperClass.__esModule && ResolvedHelperClass.default) {
+                ResolvedHelperClass = ResolvedHelperClass.default
+                debug(`extracted default export for ${helperName}, new type: ${typeof ResolvedHelperClass}`)
+              }
+
+              if (typeof ResolvedHelperClass !== 'function') {
+                throw new Error(`Helper '${helperName}' is not a class. Got: ${typeof ResolvedHelperClass}`)
+              }
+
+              checkHelperRequirements(ResolvedHelperClass)
+              helpers[helperName] = new ResolvedHelperClass(config[helperName])
+              if (helpers[helperName]._init) await helpers[helperName]._init()
+              debug(`helper ${helperName} async initialized`)
+            })
+          continue
+        } else {
+          HelperClass = helperResult
         }
       }
-      helpers[helperName] = new HelperClass(config[helperName]);
+
+      // handle async CJS modules that use dynamic import
+      if (isAsyncFunction(HelperClass)) {
+        helpers[helperName] = {}
+
+        asyncHelperPromise = asyncHelperPromise
+          .then(() => HelperClass())
+          .then(ResolvedHelperClass => {
+            // Check if ResolvedHelperClass is a constructor function
+            if (typeof ResolvedHelperClass?.constructor !== 'function') {
+              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])
+          })
+
+        continue
+      }
+
+      checkHelperRequirements(HelperClass)
+
+      helpers[helperName] = new HelperClass(config[helperName])
+      debug(`helper ${helperName} initialized`)
     } catch (err) {
-      throw new Error(`Could not load helper ${helperName} from module '${moduleName}':\n${err.message}\n${err.stack}`);
+      throw new Error(`Could not load helper ${helperName} (${err.message})`)
     }
   }
 
   for (const name in helpers) {
-    if (helpers[name]._init) helpers[name]._init();
+    if (helpers[name]._init) await helpers[name]._init()
   }
-  return helpers;
+  return helpers
 }
 
-export function createSupportObjects(config) {
-  const objects = {};
-
-  for (const name in config) {
-    objects[name] = {}; // placeholders
-  }
-
-  if (!config.I) {
-    objects.I = actor();
-
-    if (container.translation.I !== 'I') {
-      objects[container.translation.I] = objects.I;
+function checkHelperRequirements(HelperClass) {
+  if (HelperClass._checkRequirements) {
+    const requirements = HelperClass._checkRequirements()
+    if (requirements) {
+      let install
+      if (installedLocally()) {
+        install = `npm install --save-dev ${requirements.join(' ')}`
+      } else {
+        console.log('WARNING: CodeceptJS is not installed locally. It is recommended to switch to local installation')
+        install = `[sudo] npm install -g ${requirements.join(' ')}`
+      }
+      throw new Error(`Required modules are not installed.\n\nRUN: ${install}`)
     }
   }
+}
 
-  container.support = objects;
-
-  function lazyLoad(name) {
-    let newObj = getSupportObject(config, name);
+async function requireHelperFromModule(helperName, config, HelperClass) {
+  const moduleName = getHelperModuleName(helperName, config)
+  if (moduleName.startsWith('./helper/')) {
     try {
-      if (typeof newObj === 'function') {
-        newObj = newObj();
-      } else if (newObj._init) {
-        newObj._init();
+      // For built-in helpers, use direct relative import with .js extension
+      const helperPath = `${moduleName}.js`
+      const mod = await import(helperPath)
+      HelperClass = mod.default || mod
+    } catch (err) {
+      throw err
+    }
+  } else {
+    // 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)
+      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
     } catch (err) {
-      throw new Error(`Initialization failed for ${name}: ${newObj}\n${err.message}\n${err.stack}`);
+      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 mod = await import(absolutePath)
+          HelperClass = mod.default || mod
+          debug(`helper ${helperName} loaded via ESM import`)
+        } catch (importErr) {
+          throw new Error(`Helper module '${moduleName}' could not be imported as ESM: ${importErr.message}`)
+        }
+      } else if (err.code === 'MODULE_NOT_FOUND') {
+        throw new Error(`Helper module '${moduleName}' was not found. Make sure you have installed the package correctly.`)
+      } else {
+        throw err
+      }
     }
-    return newObj;
   }
+  return HelperClass
+}
 
+function createSupportObjects(config) {
   const asyncWrapper = function (f) {
     return function () {
-      return f.apply(this, arguments).catch((e) => {
-        recorder.saveFirstAsyncError(e);
-        throw e;
-      });
-    };
-  };
-
-  Object.keys(objects).forEach((object) => {
-    const currentObject = objects[object];
-    Object.keys(currentObject).forEach((method) => {
-      const currentMethod = currentObject[method];
-      if (currentMethod && currentMethod[Symbol.toStringTag] === 'AsyncFunction') {
-        objects[object][method] = asyncWrapper(currentMethod);
-      }
-    });
-  });
+      return f.apply(this, arguments).catch(e => {
+        recorder.saveFirstAsyncError(e)
+        throw e
+      })
+    }
+  }
 
-  return new Proxy({}, {
-    has(target, key) {
-      return key in config;
-    },
-    ownKeys() {
-      return Reflect.ownKeys(config);
-    },
-    get(target, key) {
-      // configured but not in support object, yet: load the module
-      if (key in objects && !(key in target)) {
-        // load default I
-        if (key in objects && !(key in config)) {
-          return target[key] = objects[key];
-        }
+  function lazyLoad(name) {
+    return new Proxy(
+      {},
+      {
+        get(target, prop) {
+          // behavr like array or
+          if (prop === 'length') return Object.keys(config).length
+          if (prop === Symbol.iterator) {
+            return function* () {
+              for (let i = 0; i < Object.keys(config).length; i++) {
+                yield target[i]
+              }
+            }
+          }
+
+          // load actual name from vocabulary
+          if (container.translation && container.translation.I && name === 'I') {
+            // Use translated name for I
+            const actualName = container.translation.I
+            if (actualName !== 'I') {
+              name = actualName
+            }
+          }
+
+          if (name === 'I') {
+            if (!container.support.I) {
+              // Actor will be created during container.create()
+              return undefined
+            }
+            methodsOfObject(container.support.I)
+            return container.support.I[prop]
+          }
+
+          if (!container.support[name] && typeof config[name] === 'object') {
+            container.support[name] = config[name]
+          }
+
+          if (!container.support[name]) {
+            // Cannot load object synchronously in proxy getter
+            // Return undefined and log warning - object should be pre-loaded during container creation
+            debug(`Support object ${name} not pre-loaded, returning undefined`)
+            return undefined
+          }
+
+          const currentObject = container.support[name]
+          let currentValue = currentObject[prop]
+
+          if (isFunction(currentValue) || isAsyncFunction(currentValue)) {
+            const ms = new MetaStep(name, prop)
+            ms.setContext(currentObject)
+            if (isAsyncFunction(currentValue)) currentValue = asyncWrapper(currentValue)
+            debug(`metastep is created for ${name}.${prop.toString()}()`)
+            return ms.run.bind(ms, currentValue)
+          }
+
+          return currentValue
+        },
+        has(target, prop) {
+          if (!container.support[name]) {
+            // Note: This is sync, so we can't use async loadSupportObject here
+            // The object will be loaded lazily on first property access
+            return false
+          }
+          return prop in container.support[name]
+        },
+        getOwnPropertyDescriptor(target, prop) {
+          if (!container.support[name]) {
+            // Object will be loaded on property access
+            return {
+              enumerable: true,
+              configurable: true,
+              value: undefined,
+            }
+          }
+          return {
+            enumerable: true,
+            configurable: true,
+            value: container.support[name][prop],
+          }
+        },
+        ownKeys() {
+          if (!container.support[name]) {
+            return []
+          }
+          return Reflect.ownKeys(container.support[name])
+        },
+      },
+    )
+  }
 
-        // load new object
-        const object = lazyLoad(key);
-        // check that object is a real object and not an array
-        if (Object.prototype.toString.call(object) === '[object Object]') {
-          return target[key] = Object.assign(objects[key], object);
+  const keys = Reflect.ownKeys(config)
+  return new Proxy(
+    {},
+    {
+      has(target, key) {
+        return keys.includes(key) || container.sharedKeys.has(key)
+      },
+      ownKeys() {
+        // Return both original config keys and explicitly shared keys
+        return [...new Set([...keys, ...container.sharedKeys])]
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        return {
+          enumerable: true,
+          configurable: true,
+          value: target[prop],
         }
-        target[key] = object;
-      }
-      return target[key];
+      },
+      get(target, key) {
+        // First check if this is an explicitly shared property
+        if (container.sharedKeys.has(key) && key in container.support) {
+          return container.support[key]
+        }
+        return lazyLoad(key)
+      },
     },
-  });
+  )
+}
+
+function createActor(actorPath) {
+  if (container.support.I) return container.support.I
+
+  // Default actor
+  container.support.I = actorFactory({}, Container)
+
+  return container.support.I
 }
 
-function createPlugins(config, options = {}) {
-  const plugins = {};
+async function loadPluginAsync(modulePath, config) {
+  let pluginMod
+  try {
+    // Try dynamic import first (works for both ESM and CJS)
+    pluginMod = await import(modulePath)
+  } catch (err) {
+    throw new Error(`Could not load plugin from '${modulePath}': ${err.message}`)
+  }
+
+  const pluginFactory = pluginMod.default || pluginMod
+  if (typeof pluginFactory !== 'function') {
+    throw new Error(`Plugin '${modulePath}' is not a function. Expected a plugin factory function.`)
+  }
+
+  return pluginFactory(config)
+}
+
+async function loadPluginFallback(modulePath, config) {
+  // This function is kept for backwards compatibility but now uses dynamic import
+  return await loadPluginAsync(modulePath, config)
+}
+
+async function createPlugins(config, options = {}) {
+  const plugins = {}
 
-  const enabledPluginsByOptions = (options.plugins || '').split(',');
+  const enabledPluginsByOptions = (options.plugins || '').split(',')
   for (const pluginName in config) {
-    if (!config[pluginName]) config[pluginName] = {};
-    if (!config[pluginName].enabled && (enabledPluginsByOptions.indexOf(pluginName) < 0)) {
-      continue; // plugin is disabled
+    if (!config[pluginName]) config[pluginName] = {}
+    if (!config[pluginName].enabled && enabledPluginsByOptions.indexOf(pluginName) < 0) {
+      continue // plugin is disabled
     }
-    let module;
+    let module
     try {
       if (config[pluginName].require) {
-        module = config[pluginName].require;
-        if (module.startsWith('.')) { // local
-          // @ts-ignore
-          module = path.resolve(global.codecept_dir, module); // custom plugin
+        module = config[pluginName].require
+        if (module.startsWith('.')) {
+          // local
+          module = path.resolve(global.codecept_dir, module) // custom plugin
         }
       } else {
-        module = `./plugin/${pluginName}.js`;
+        module = `./plugin/${pluginName}.js`
       }
-      plugins[pluginName] = importSync(module).default(config[pluginName]);
+
+      // Use async loading for all plugins (ESM and CJS)
+      plugins[pluginName] = await loadPluginAsync(module, config[pluginName])
+      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}`);
+      throw new Error(`Could not load plugin ${pluginName} from module '${module}':\n${err.message}\n${err.stack}`)
     }
   }
-  return plugins;
+  return plugins
 }
 
-function getSupportObject(config, name) {
-  const module = config[name];
-  if (typeof module === 'string') {
-    return loadSupportObject(module, name);
-  }
-  return module;
-}
+async function loadGherkinStepsAsync(paths) {
+  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)
 
-export function loadGherkinSteps(paths) {
-  // @ts-ignore
-  global.Before = fn => event.dispatcher.on(event.test.started, fn);
-  // @ts-ignore
-  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')
 
   // 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
   // This is done so that we need not enter all Step Definition files under config.gherkin.steps
   if (Array.isArray(paths)) {
     for (const path of paths) {
-      loadSupportObject(path, `Step Definition from ${path}`);
+      // Set context for step definition file location tracking
+      bddModule.setCurrentStepFile(path)
+      await loadSupportObject(path, `Step Definition from ${path}`)
+      bddModule.clearCurrentStepFile()
     }
   } else {
-    // @ts-ignore
-    const folderPath = paths.startsWith('.') ? path.join(global.codecept_dir, paths) : '';
+    const folderPath = paths.startsWith('.') ? normalizeAndJoin(global.codecept_dir, paths) : ''
     if (folderPath !== '') {
-      glob.sync(folderPath).forEach((file) => {
-        loadSupportObject(file, `Step Definition from ${file}`);
-      });
+      const files = globSync(folderPath)
+      for (const file of files) {
+        // Set context for step definition file location tracking
+        bddModule.setCurrentStepFile(file)
+        await loadSupportObject(file, `Step Definition from ${file}`)
+        bddModule.clearCurrentStepFile()
+      }
     }
   }
 
-  // @ts-ignore
-  delete global.Before;
-  // @ts-ignore
-  delete global.After;
-  delete global.Fail;
+  delete global.Before
+  delete global.After
+  delete global.Fail
 }
 
-function loadSupportObject(modulePath, supportObjectName) {
-  if (modulePath.charAt(0) === '.') {
-    // @ts-ignore
-    modulePath = path.join(global.codecept_dir, modulePath);
-  }
-  try {
-    const obj = importSync(modulePath).default || importSync(modulePath);
+function loadGherkinSteps(paths) {
+  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)
 
-    if (typeof obj === 'function') {
-      const fobj = obj();
+  // Gherkin step loading must be handled asynchronously
+  throw new Error('Gherkin step loading must be converted to async. Use loadGherkinStepsAsync() instead.')
 
-      if (fobj.constructor.name === 'Actor') {
-        const methods = getObjectMethods(fobj);
-        Object.keys(methods)
-          .forEach(key => {
-            fobj[key] = methods[key];
-          });
+  delete global.Before
+  delete global.After
+  delete global.Fail
+}
 
-        return methods;
+async function loadSupportObject(modulePath, supportObjectName) {
+  if (!modulePath) {
+    throw new Error(`Support object "${supportObjectName}" is not defined`)
+  }
+  // If function/class provided directly
+  if (typeof modulePath === 'function') {
+    try {
+      // class constructor
+      if (modulePath.prototype && modulePath.prototype.constructor === modulePath) {
+        return new modulePath()
       }
+      // plain function factory
+      return modulePath()
+    } catch (err) {
+      throw new Error(`Could not include object ${supportObjectName} from function: ${err.message}`)
     }
-    if (typeof obj !== 'function'
-      && Object.getPrototypeOf(obj) !== Object.prototype
-      && !Array.isArray(obj)
-    ) {
-      const methods = getObjectMethods(obj);
-      Object.keys(methods)
-        .filter(key => !key.startsWith('_'))
-        .forEach(key => {
-          const currentMethod = methods[key];
-          if (isFunction(currentMethod) || isAsyncFunction(currentMethod)) {
-            const ms = new MetaStep(supportObjectName, key);
-            ms.setContext(methods);
-            methods[key] = ms.run.bind(ms, currentMethod);
+  }
+  if (typeof modulePath === 'string' && modulePath.charAt(0) === '.') {
+    modulePath = path.join(global.codecept_dir, modulePath)
+  }
+  try {
+    // Use dynamic import for both ESM and CJS modules
+    let importPath = modulePath
+    let tempJsFile = null
+    
+    if (typeof importPath === 'string') {
+      const ext = path.extname(importPath)
+      
+      // Handle TypeScript files
+      if (ext === '.ts') {
+        try {
+          const { transpile } = await import('typescript')
+          
+          // Recursively transpile the file and its dependencies
+          const transpileTS = (filePath) => {
+            const tsContent = fs.readFileSync(filePath, 'utf8')
+            
+            // Transpile TypeScript to JavaScript with ES module output
+            let jsContent = transpile(tsContent, {
+              module: 99, // ModuleKind.ESNext
+              target: 99, // ScriptTarget.ESNext
+              esModuleInterop: true,
+              allowSyntheticDefaultImports: true,
+            })
+            
+            // Check if the code uses __dirname or __filename (CommonJS globals)
+            const usesCommonJSGlobals = /__dirname|__filename/.test(jsContent)
+            
+            if (usesCommonJSGlobals) {
+              // Inject ESM equivalents at the top of the file
+              const esmGlobals = `import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __dirname_fn } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __dirname_fn(__filename);
+
+`
+              jsContent = esmGlobals + jsContent
+            }
+            
+            return jsContent
+          }
+          
+          // Create a map to track transpiled files
+          const transpiledFiles = new Map()
+          const baseDir = path.dirname(importPath)
+          
+          // Transpile main file
+          let jsContent = transpileTS(importPath)
+          
+          // Find and transpile all relative TypeScript imports
+          // Match: import ... from './file' or '../file' or './file.ts'
+          const importRegex = /from\s+['"](\..+?)(?:\.ts)?['"]/g
+          let match
+          const imports = []
+          
+          while ((match = importRegex.exec(jsContent)) !== null) {
+            imports.push(match[1])
+          }
+          
+          // Transpile each imported TypeScript file
+          for (const relativeImport of imports) {
+            let importedPath = path.resolve(baseDir, relativeImport)
+            
+            // Handle .js extensions that might actually be .ts files
+            if (importedPath.endsWith('.js')) {
+              const tsVersion = importedPath.replace(/\.js$/, '.ts')
+              if (fs.existsSync(tsVersion)) {
+                importedPath = tsVersion
+              }
+            }
+            
+            // Try adding .ts extension if file doesn't exist and no extension provided
+            if (!path.extname(importedPath)) {
+              if (fs.existsSync(importedPath + '.ts')) {
+                importedPath = importedPath + '.ts'
+              }
+            }
+            
+            // If it's a TypeScript file, transpile it
+            if (importedPath.endsWith('.ts') && fs.existsSync(importedPath)) {
+              const transpiledImportContent = transpileTS(importedPath)
+              const tempImportFile = importedPath.replace(/\.ts$/, '.temp.mjs')
+              fs.writeFileSync(tempImportFile, transpiledImportContent)
+              transpiledFiles.set(importedPath, tempImportFile)
+              debug(`Transpiled dependency: ${importedPath} -> ${tempImportFile}`)
+            }
           }
-        });
-      return methods;
+          
+          // Replace imports in the main file to point to temp .mjs files
+          jsContent = jsContent.replace(
+            /from\s+['"](\..+?)(?:\.ts)?['"]/g,
+            (match, importPath) => {
+              let resolvedPath = path.resolve(baseDir, importPath)
+              
+              // Handle .js extension that might be .ts
+              if (resolvedPath.endsWith('.js')) {
+                const tsVersion = resolvedPath.replace(/\.js$/, '.ts')
+                if (transpiledFiles.has(tsVersion)) {
+                  const tempFile = transpiledFiles.get(tsVersion)
+                  const relPath = path.relative(baseDir, tempFile).replace(/\\/g, '/')
+                  return `from './${relPath}'`
+                }
+              }
+              
+              // Try with .ts extension
+              const tsPath = resolvedPath.endsWith('.ts') ? resolvedPath : resolvedPath + '.ts'
+              
+              // If we transpiled this file, use the temp file
+              if (transpiledFiles.has(tsPath)) {
+                const tempFile = transpiledFiles.get(tsPath)
+                // Get relative path from main temp file to this temp file
+                const relPath = path.relative(baseDir, tempFile).replace(/\\/g, '/')
+                return `from './${relPath}'`
+              }
+              
+              // Otherwise, keep the import as-is
+              return match
+            }
+          )
+
+          // Create a temporary JS file with .mjs extension for the main file
+          tempJsFile = importPath.replace(/\.ts$/, '.temp.mjs')
+          fs.writeFileSync(tempJsFile, jsContent)
+          
+          // Store all temp files for cleanup
+          const allTempFiles = [tempJsFile, ...Array.from(transpiledFiles.values())]
+          
+          // Attach cleanup handler
+          importPath = tempJsFile
+          // Store temp files list in a way that cleanup can access them
+          tempJsFile = allTempFiles
+          
+        } catch (tsError) {
+          throw new Error(`Failed to load TypeScript file ${importPath}: ${tsError.message}. Make sure 'typescript' package is installed.`)
+        }
+      } else if (!ext) {
+        // Append .js if no extension provided (ESM resolution requires it)
+        importPath = `${importPath}.js`
+      }
     }
-    if (!Array.isArray(obj)) {
-      Object.keys(obj)
-        .filter(key => !key.startsWith('_'))
-        .forEach(key => {
-          const currentMethod = obj[key];
-          if (isFunction(currentMethod) || isAsyncFunction(currentMethod)) {
-            const ms = new MetaStep(supportObjectName, key);
-            ms.setContext(obj);
-            obj[key] = ms.run.bind(ms, currentMethod);
+    
+    let obj
+    try {
+      obj = await import(importPath)
+    } catch (importError) {
+      // Clean up temp files if created before rethrowing
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        for (const file of filesToClean) {
+          try {
+            if (fs.existsSync(file)) {
+              fs.unlinkSync(file)
+            }
+          } catch (cleanupError) {
+            // Ignore cleanup errors
+          }
+        }
+      }
+      throw importError
+    } finally {
+      // Clean up temp files if created
+      if (tempJsFile) {
+        const filesToClean = Array.isArray(tempJsFile) ? tempJsFile : [tempJsFile]
+        for (const file of filesToClean) {
+          try {
+            if (fs.existsSync(file)) {
+              fs.unlinkSync(file)
+            }
+          } catch (cleanupError) {
+            // Ignore cleanup errors
           }
-        });
+        }
+      }
+    }
+
+    // Handle ESM module wrapper
+    let actualObj = obj
+    if (obj && obj.__esModule && obj.default) {
+      actualObj = obj.default
+    } else if (obj.default) {
+      actualObj = obj.default
+    }
+
+    // Handle different types of imports
+    if (typeof actualObj === 'function') {
+      // If it's a class (constructor function)
+      if (actualObj.prototype && actualObj.prototype.constructor === actualObj) {
+        const ClassName = actualObj
+        return new ClassName()
+      }
+      // If it's a regular function
+      return actualObj()
+    }
+
+    if (actualObj && Array.isArray(actualObj)) {
+      return actualObj
     }
 
-    return obj;
+    // If it's a plain object
+    if (actualObj && typeof actualObj === 'object') {
+      // Call _init if it exists (for page objects)
+      if (actualObj._init && typeof actualObj._init === 'function') {
+        actualObj._init()
+      }
+      return actualObj
+    }
+
+    throw new Error(`Support object "${supportObjectName}" should be an object, class, or function, but got ${typeof actualObj}`)
   } catch (err) {
-    throw new Error(`Could not include object ${supportObjectName} from module '${modulePath}'\n${err.message}\n${err.stack}`);
+    throw new Error(`Could not include object ${supportObjectName} from module '${modulePath}'\n${err.message}\n${err.stack}`)
   }
 }
 
+// Backwards compatibility function that throws an error for sync usage
+function loadSupportObjectSync(modulePath, supportObjectName) {
+  throw new Error(`loadSupportObjectSync is deprecated. Support object "${supportObjectName || 'undefined'}" from '${modulePath}' must be loaded asynchronously. Use loadSupportObject() instead.`)
+}
+
 /**
  * Method collect own property and prototype
  */
-function getObjectMethods(obj) {
-  const methodsSet = new Set();
-  let protoObj = Reflect.getPrototypeOf(obj);
-  do {
-    if (protoObj?.constructor.prototype !== Object.prototype) {
-      const keys = Reflect.ownKeys(protoObj);
-      keys.forEach(k => methodsSet.add(k));
-    }
-  } while (protoObj = Reflect.getPrototypeOf(protoObj));
-  Reflect.ownKeys(obj).forEach(k => methodsSet.add(k));
-  const methods = {};
-  for (const key of methodsSet.keys()) {
-    if (key !== 'constructor') methods[key] = obj[key];
-  }
-  return methods;
-}
 
-function loadTranslation(locale, vocabularies) {
+async function loadTranslation(locale, vocabularies) {
   if (!locale) {
-    return Translation.createEmpty();
+    return Translation.createEmpty()
   }
 
-  let translation;
-  locale = locale.replace('-', '_');
+  let translation
 
   // check if it is a known translation
-  if (Translation.langs[locale]) {
-    translation = new Translation(Translation.langs[locale]);
-  } else { // @ts-ignore
-    translation = Translation.createDefault();
-    // @ts-ignore
-    if (fileExists(path.join(global.codecept_dir, locale))) {
-      // get from a provided file instead
-      translation.loadVocabulary(locale);
+  const langs = await Translation.getLangs()
+  if (langs[locale]) {
+    translation = new Translation(langs[locale])
+  } else if (fileExists(path.join(global.codecept_dir, locale))) {
+    // get from a provided file instead
+    translation = Translation.createDefault()
+    translation.loadVocabulary(locale)
+  } else {
+    translation = Translation.createDefault()
+  }
+
+  vocabularies.forEach(v => translation.loadVocabulary(v))
+
+  return translation
+}
+
+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)
+      // Add .js extension if not present for ESM compatibility
+      if (!path.extname(helperPath)) {
+        helperPath += '.js'
+      }
+      return helperPath // custom helper
     }
+    return config[helperName].require // plugin helper
   }
 
-  vocabularies.forEach(v => translation.loadVocabulary(v));
+  // built-in helpers
+  if (helperName.startsWith('@codeceptjs/')) {
+    return helperName
+  }
+
+  // built-in helpers
+  return `./helper/${helperName}`
+}
+function normalizeAndJoin(basePath, subPath) {
+  // Normalize and convert slashes to forward slashes in one step
+  const normalizedBase = path.posix.normalize(basePath.replace(/\\/g, '/'))
+  const normalizedSub = path.posix.normalize(subPath.replace(/\\/g, '/'))
+
+  // If subPath is absolute (starts with "/"), return it as the final path
+  if (normalizedSub.startsWith('/')) {
+    return normalizedSub
+  }
 
-  return translation;
+  // Join the paths using POSIX-style
+  return path.posix.join(normalizedBase, normalizedSub)
 }