codeceptjs 4.0.0-beta.9.esm-aria → 4.0.0-rc.10

package/docs/webapi/dontSeeInField.mustache

@@ -1,11 +1,16 @@
 Checks that value of input field or textarea doesn't equal to given value
 Opposite to `seeInField`.
 
+The third parameter is an optional context (CSS or XPath locator) to narrow the search.
+
 ```js
 I.dontSeeInField('email', 'user@user.com'); // field by name
 I.dontSeeInField({ css: 'form input.email' }, 'user@user.com'); // field by CSS
+// within a context
+I.dontSeeInField('Name', 'old_value', '.form-container');
 ```
 
 @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
 @param {CodeceptJS.StringOrSecret} value value to check.
+@param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
 @returns {void} automatically synchronized promise through #recorder

package/docs/webapi/fillField.mustache

@@ -1,6 +1,8 @@
 Fills a text field or textarea, after clearing its value, with the given string.
 Field is located by name, label, CSS, or XPath.
 
+The third parameter is an optional context (CSS or XPath locator) to narrow the search.
+
 ```js
 // by label
 I.fillField('Email', 'hello@world.com');
@@ -10,7 +12,10 @@ I.fillField('password', secret('123456'));
 I.fillField('form#login input[name=username]', 'John');
 // or by strict locator
 I.fillField({css: 'form#login input[name=username]'}, 'John');
+// within a context
+I.fillField('Name', 'John', '#section2');
 ```
 @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
 @param {CodeceptJS.StringOrSecret} value text value to fill.
+@param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
 @returns {void} automatically synchronized promise through #recorder

package/docs/webapi/moveCursorTo.mustache

@@ -1,12 +1,16 @@
 Moves cursor to element matched by locator.
 Extra shift can be set with offsetX and offsetY options.
 
+An optional `context` (as a second parameter) can be specified to narrow the search to an element within a parent.
+When the second argument is a non-number (string or locator object), it is treated as context.
+
 ```js
 I.moveCursorTo('.tooltip');
 I.moveCursorTo('#submit', 5,5);
+I.moveCursorTo('#submit', '.container');
 ```
 
 @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
-@param {number} [offsetX=0] (optional, `0` by default) X-axis offset.
+@param {number|CodeceptJS.LocatorOrString} [offsetX=0] (optional, `0` by default) X-axis offset or context locator.
 @param {number} [offsetY=0] (optional, `0` by default) Y-axis offset.
 @returns {void} automatically synchronized promise through #recorder

package/docs/webapi/seeCurrentPathEquals.mustache

@@ -0,0 +1,10 @@
+Checks that current URL path matches the expected path.
+Query strings and URL fragments are ignored.
+
+```js
+I.seeCurrentPathEquals('/info'); // passes for '/info', '/info?user=1', '/info#section'
+I.seeCurrentPathEquals('/'); // passes for '/', '/?user=ok', '/#top'
+```
+
+@param {string} path value to check.
+@returns {void} automatically synchronized promise through #recorder

package/docs/webapi/seeElement.mustache

@@ -1,8 +1,12 @@
 Checks that a given Element is visible
 Element is located by CSS or XPath.
 
+The second parameter is a context (CSS or XPath locator) to narrow the search.
+
 ```js
 I.seeElement('#modal');
+I.seeElement('#modal', '#container');
 ```
 @param {CodeceptJS.LocatorOrString} locator located by CSS|XPath|strict locator.
+@param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
 @returns {void} automatically synchronized promise through #recorder

package/docs/webapi/seeInField.mustache

@@ -1,12 +1,17 @@
 Checks that the given input field or textarea equals to given value.
 For fuzzy locators, fields are matched by label text, the "name" attribute, CSS, and XPath.
 
+The third parameter is an optional context (CSS or XPath locator) to narrow the search.
+
 ```js
 I.seeInField('Username', 'davert');
 I.seeInField({css: 'form textarea'},'Type your comment here');
 I.seeInField('form input[type=hidden]','hidden_value');
 I.seeInField('#searchform input','Search');
+// within a context
+I.seeInField('Name', 'John', '.form-container');
 ```
 @param {CodeceptJS.LocatorOrString} field located by label|name|CSS|XPath|strict locator.
 @param {CodeceptJS.StringOrSecret} value value to check.
+@param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
 @returns {void} automatically synchronized promise through #recorder

package/docs/webapi/selectOption.mustache

@@ -2,6 +2,8 @@ Selects an option in a drop-down select.
 Field is searched by label | name | CSS | XPath.
 Option is selected by visible text or by value.
 
+The third parameter is an optional context (CSS or XPath locator) to narrow the search.
+
 ```js
 I.selectOption('Choose Plan', 'Monthly'); // select by label
 I.selectOption('subscription', 'Monthly'); // match option by text
@@ -9,6 +11,8 @@ I.selectOption('subscription', '0'); // or by value
 I.selectOption('//form/select[@name=account]','Premium');
 I.selectOption('form select[name=account]', 'Premium');
 I.selectOption({css: 'form select[name=account]'}, 'Premium');
+// within a context
+I.selectOption('age', '21-60', '#section2');
 ```
 
 Provide an array for the second argument to select multiple options.
@@ -18,4 +22,5 @@ I.selectOption('Which OS do you use?', ['Android', 'iOS']);
 ```
 @param {LocatorOrString} select field located by label|name|CSS|XPath|strict locator.
 @param {string|Array<*>} option visible text or value of option.
+@param {?CodeceptJS.LocatorOrString} [context=null] (optional, `null` by default) element located by CSS | XPath | strict locator.
 @returns {void} automatically synchronized promise through #recorder

package/docs/webapi/uncheckOption.mustache

@@ -1,7 +1,7 @@
 Unselects a checkbox or radio button.
 Element is located by label or name or CSS or XPath.
 
-The second parameter is a context (CSS or XPath locator) to narrow the search.
+The second parameter is an optional context (CSS or XPath locator) to narrow the search.
 
 ```js
 I.uncheckOption('#agree');

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/codecept.js

@@ -3,8 +3,9 @@ import { globSync } from 'glob'
 import shuffle from 'lodash.shuffle'
 import fsPath from 'path'
 import { resolve } from 'path'
-import { fileURLToPath } from 'url'
+import { fileURLToPath, pathToFileURL } from 'url'
 import { dirname } from 'path'
+import { createRequire } from 'module'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = dirname(__filename)
@@ -18,6 +19,7 @@ import ActorFactory from './actor.js'
 import output from './output.js'
 import { emptyFolder } from './utils.js'
 import { initCodeceptGlobals } from './globals.js'
+import { validateTypeScriptSetup, getTSNodeESMWarning } from './utils/loaderCheck.js'
 import recorder from './recorder.js'
 
 import storeListener from './listener/store.js'
@@ -66,6 +68,21 @@ class Codecept {
               modulePath = `${modulePath}.js`
             }
           }
+        } else {
+          // For npm packages, resolve from the user's directory
+          // This ensures packages like tsx are found in user's node_modules
+          const userDir = global.codecept_dir || process.cwd()
+          
+          try {
+            // Use createRequire to resolve from user's directory
+            const userRequire = createRequire(pathToFileURL(resolve(userDir, 'package.json')).href)
+            const resolvedPath = userRequire.resolve(requiredModule)
+            modulePath = pathToFileURL(resolvedPath).href
+          } catch (resolveError) {
+            // If resolution fails, try direct import (will check from CodeceptJS node_modules)
+            // This is the fallback for globally installed packages
+            modulePath = requiredModule
+          }
         }
         // Use dynamic import for ESM
         await import(modulePath)
@@ -103,23 +120,26 @@ class Codecept {
    * Executes hooks.
    */
   async runHooks() {
-    // default hooks - dynamic imports for ESM
-    const listenerModules = [
-      './listener/store.js',
-      './listener/steps.js',
-      './listener/config.js',
-      './listener/result.js',
-      './listener/helpers.js',
-      './listener/globalTimeout.js',
-      './listener/globalRetry.js',
-      './listener/retryEnhancer.js',
-      './listener/exit.js',
-      './listener/emptyRun.js',
-    ]
-
-    for (const modulePath of listenerModules) {
-      const module = await import(modulePath)
-      runHook(module.default || module)
+    // For workers parent process we only need plugins/hooks.
+    // Core listeners are executed inside worker threads.
+    if (!this.opts?.skipDefaultListeners) {
+      const listenerModules = [
+        './listener/store.js',
+        './listener/steps.js',
+        './listener/config.js',
+        './listener/result.js',
+        './listener/helpers.js',
+        './listener/globalTimeout.js',
+        './listener/globalRetry.js',
+        './listener/retryEnhancer.js',
+        './listener/exit.js',
+        './listener/emptyRun.js',
+      ]
+
+      for (const modulePath of listenerModules) {
+        const module = await import(modulePath)
+        runHook(module.default || module)
+      }
     }
 
     // custom hooks (previous iteration of plugins)
@@ -246,6 +266,19 @@ class Codecept {
   async run(test) {
     await container.started()
 
+    // Check TypeScript loader configuration before running tests
+    const tsValidation = validateTypeScriptSetup(this.testFiles, this.requiringModules || [])
+    if (tsValidation.hasError) {
+      output.error(tsValidation.message)
+      process.exit(1)
+    }
+
+    // Show warning if ts-node/esm is being used
+    const tsWarning = getTSNodeESMWarning(this.requiringModules || [])
+    if (tsWarning) {
+      output.print(output.colors.yellow(tsWarning))
+    }
+
     // Ensure translations are loaded for Gherkin features
     try {
       const { loadTranslations } = await import('./mocha/gherkin.js')

package/lib/command/definitions.js

@@ -41,7 +41,7 @@ const getDefinitionsFileContent = ({ hasCustomHelper, hasCustomStepsFile, helper
 
   const importPathsFragment = importPaths.join('\n')
   const supportObjectsTypeFragment = convertMapToType(supportObject)
-  const methodsTypeFragment = helperNames.length > 0 ? `interface Methods extends ${helperNames.join(', ')} {}` : ''
+  const methodsTypeFragment = helperNames.length > 0 ? `interface Methods extends ${helperNames.join(', ')} {}` : 'interface Methods {}'
   const translatedActionsFragment = JSON.stringify(translations.vocabulary.actions, null, 2)
 
   return generateDefinitionsContent({
@@ -229,18 +229,25 @@ function getImportString(testsPath, targetFolderPath, pathsToType, pathsToValue)
   const importStrings = []
 
   for (const name in pathsToType) {
-    const relativePath = getPath(pathsToType[name], targetFolderPath, testsPath)
-    // For ESM modules with default exports, we need to access the default export type
-    if (relativePath.endsWith('.js')) {
-      importStrings.push(`type ${name} = typeof import('${relativePath}')['default'];`)
+    const originalPath = pathsToType[name]
+    const relativePath = getPath(originalPath, targetFolderPath, testsPath)
+    // For .js files with plain object exports, access .default to allow TypeScript to extract properties
+    // For .ts files, the default export is handled differently by TypeScript
+    if (originalPath.endsWith('.js')) {
+      importStrings.push(`type ${name} = typeof import('${relativePath}').default;`)
     } else {
       importStrings.push(`type ${name} = typeof import('${relativePath}');`)
     }
   }
 
   for (const name in pathsToValue) {
-    const relativePath = getPath(pathsToValue[name], targetFolderPath, testsPath)
-    importStrings.push(`type ${name} = import('${relativePath}');`)
+    const originalPath = pathsToValue[name]
+    const relativePath = getPath(originalPath, targetFolderPath, testsPath)
+    if (originalPath.endsWith('.js') || originalPath.endsWith('.ts')) {
+      importStrings.push(`type ${name} = InstanceType<typeof import('${relativePath}').default>;`)
+    } else {
+      importStrings.push(`type ${name} = import('${relativePath}');`)
+    }
   }
 
   return importStrings

package/lib/command/init.js

@@ -20,9 +20,6 @@ const defaultConfig = {
   helpers: {},
   include: {},
   plugins: {
-    htmlReporter: {
-      enabled: true,
-    },
   },
 }
 
@@ -161,7 +158,7 @@ export default async function (initPath) {
         isTypeScript = true
         extension = isTypeScript === true ? 'ts' : 'js'
         packages.push('typescript')
-        packages.push('ts-node')
+        packages.push('tsx')  // Add tsx for TypeScript support
         packages.push('@types/node')
       }
 
@@ -172,6 +169,7 @@ export default async function (initPath) {
       config.tests = result.tests
       if (isTypeScript) {
         config.tests = `${config.tests.replace(/\.js$/, `.${extension}`)}`
+        config.require = ['tsx/cjs']  // Add tsx/cjs loader for TypeScript tests
       }
 
       // create a directory tests if it is included in tests path

package/lib/command/run-workers.js

@@ -40,11 +40,23 @@ export default async function (workerCount, selectedRuns, options) {
 
   output.print(`CodeceptJS v${Codecept.version()} ${output.standWithUkraine()}`)
   output.print(`Running tests in ${output.styles.bold(numberOfWorkers)} workers...`)
-  output.print()
   store.hasWorkers = true
+  process.env.RUNS_WITH_WORKERS = 'true'
 
   const workers = new Workers(numberOfWorkers, config)
   workers.overrideConfig(overrideConfigs)
+  
+  // Show test distribution after workers are initialized
+  await workers.bootstrapAll()
+  
+  const workerObjects = workers.getWorkers()
+  output.print()
+  output.print('Test distribution:')
+  workerObjects.forEach((worker, index) => {
+    const testCount = worker.tests.length
+    output.print(`  Worker ${index + 1}: ${testCount} test${testCount !== 1 ? 's' : ''}`)
+  })
+  output.print()
 
   workers.on(event.test.failed, test => {
     output.test.failed(test)
@@ -68,7 +80,6 @@ export default async function (workerCount, selectedRuns, options) {
     if (options.verbose) {
       await getMachineInfo()
     }
-    await workers.bootstrapAll()
     await workers.run()
   } catch (err) {
     output.error(err)

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 = ''
 
@@ -19,6 +19,48 @@ const stderr = ''
 
 const { options, tests, testRoot, workerIndex, poolMode } = workerData
 
+// Global error handlers to catch critical errors but not test failures
+process.on('uncaughtException', (err) => {
+  if (global.container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = global.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')) {
+    return
+  }
+  process.exit(1)
+})
+
+process.on('unhandledRejection', (reason, promise) => {
+  if (reason && typeof reason === 'object' && reason.stack && global.container?.tsFileMapping && fixErrorStack) {
+    const fileMapping = global.container.tsFileMapping()
+    if (fileMapping) {
+      fixErrorStack(reason, fileMapping)
+    }
+  }
+
+  // Log to stderr to bypass stdout suppression
+  const msg = reason?.message || String(reason)
+  process.stderr.write(`[Worker ${workerIndex}] UNHANDLED REJECTION: ${msg}\n`)
+  if (reason?.stack) {
+    process.stderr.write(`${reason.stack}\n`)
+  }
+
+  // Don't exit on test-related rejections
+  if (msg.includes('expected') || msg.includes('AssertionError')) {
+    return
+  }
+  process.exit(1)
+})
+
 // hide worker output
 // In pool mode, only suppress output if debug is NOT enabled
 // In regular mode, hide result output but allow step output in verbose/debug
@@ -26,6 +68,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('✔') ||
@@ -45,7 +91,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
   }
@@ -82,30 +133,69 @@ 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 (global.container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = global.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)
     
-    codecept = new Codecept(config, options)
-    await codecept.init(testRoot)
+    // Pass workerIndex as child option for output.process() to display worker prefix
+    const optsWithChild = { ...options, child: workerIndex }
+    codecept = new Codecept(config, optsWithChild)
+    
+    try {
+      await codecept.init(testRoot)
+    } catch (initErr) {
+      if (global.container?.tsFileMapping && fixErrorStack) {
+        const fileMapping = global.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()
 
@@ -124,10 +214,18 @@ initPromise = (async function () {
       await runTests()
     } else {
       // No tests to run, close the worker
+      console.error(`[Worker ${workerIndex}] ERROR: No tests found after filtering! Assigned ${tests.length} UIDs but none matched.`)
       parentPort?.close()
     }
   } catch (err) {
-    console.error('Error in worker initialization:', err)
+    if (global.container?.tsFileMapping && fixErrorStack) {
+      const fileMapping = global.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)
   }
 })()
@@ -145,8 +243,14 @@ async function runTests() {
   disablePause()
   try {
     await codecept.run()
+  } catch (err) {
+    throw err
   } finally {
-    await codecept.teardown()
+    try {
+      await codecept.teardown()
+    } catch (err) {
+      // Ignore teardown errors
+    }
   }
 }
 
@@ -334,8 +438,16 @@ function filterTests() {
   mocha.files = files
   mocha.loadFiles()
 
-  for (const suite of mocha.suite.suites) {
+  // Recursively filter tests in all suites (including nested ones)
+  const filterSuiteTests = (suite) => {
     suite.tests = suite.tests.filter(test => tests.indexOf(test.uid) >= 0)
+    for (const childSuite of suite.suites) {
+      filterSuiteTests(childSuite)
+    }
+  }
+
+  for (const suite of mocha.suite.suites) {
+    filterSuiteTests(suite)
   }
 }
 

package/lib/config.js

@@ -2,6 +2,7 @@ import fs from 'fs'
 import path from 'path'
 import { createRequire } from 'module'
 import { fileExists, isFile, deepMerge, deepClone } from './utils.js'
+import { transpileTypeScript, cleanupTempFiles, fixErrorStack } from './utils/typescript.js'
 
 const defaultConfig = {
   output: './_output',
@@ -155,42 +156,32 @@ async function loadConfigFile(configFile) {
     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 {
-          // Try to load ts-node and compile the file
-          const { transpile } = require('typescript')
-          const tsContent = fs.readFileSync(configFile, 'utf8')
-
-          // Transpile TypeScript to JavaScript with ES module output
-          const jsContent = transpile(tsContent, {
-            module: 99, // ModuleKind.ESNext
-            target: 99, // ScriptTarget.ESNext
-            esModuleInterop: true,
-            allowSyntheticDefaultImports: true,
-          })
-
-          // Create a temporary JS file with .mjs extension to force ES module treatment
-          const tempJsFile = configFile.replace('.ts', '.temp.mjs')
-          fs.writeFileSync(tempJsFile, jsContent)
-
-          try {
-            configModule = await import(tempJsFile)
-            // Clean up temp file
-            fs.unlinkSync(tempJsFile)
-          } catch (err) {
-            // Clean up temp file even on error
-            if (fs.existsSync(tempJsFile)) {
-              fs.unlinkSync(tempJsFile)
-            }
-            throw err
+          // Use the TypeScript transpilation utility
+          const typescript = require('typescript')
+          const result = await transpileTypeScript(configFile, typescript)
+          tempFile = result.tempFile
+          allTempFiles = result.allTempFiles
+          fileMapping = result.fileMapping
+
+          configModule = await import(tempFile)
+          cleanupTempFiles(allTempFiles)
+        } catch (err) {
+          transpileError = err
+          if (fileMapping) {
+            fixErrorStack(err, fileMapping)
           }
-        } 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