Function importModule

src/esm.ts:219–324

(modulePath: string, functionName?: string)

 * Uses Node.js native ESM import with proper URL resolution
 */
export async function importModule(modulePath: string, functionName?: string) {
  logger.debug(
    `Attempting to import module: ${JSON.stringify({ resolvedPath: safeResolve(modulePath), moduleId: modulePath })}`,
  );

  try {
    await ensureTypescriptLoader(modulePath);

    const resolvedPath = pathToFileURL(safeResolve(modulePath));
    const resolvedPathStr = resolvedPath.toString();
    logger.debug(`Attempting ESM import from: ${resolvedPathStr}`);

    // Native dynamic import - no eval() needed in ESM-only environment
    const importedModule = await import(resolvedPathStr);

    const mod = importedModule?.default?.default || importedModule?.default || importedModule;
    logger.debug(
      `Successfully imported module: ${JSON.stringify({ resolvedPath, moduleId: modulePath })}`,
    );

    if (functionName) {
      logger.debug(`Returning named export: ${functionName}`);
      return mod[functionName];
    }
    return mod;
  } catch (err) {
    const errorMessage = err instanceof Error ? err.message : String(err);

    // Fall back to vm-based CJS execution for .js files that use CJS syntax
    // Note: createRequire() doesn't work for .js files in "type": "module" packages
    // because Node.js still treats them as ESM based on package.json.
    // We use Node's vm module to execute the code with proper CJS globals.
    if (modulePath.endsWith('.js') && isCjsInEsmError(errorMessage)) {
      logger.debug(
        `ESM import failed for ${modulePath}, attempting vm-based CJS fallback: ${errorMessage}`,
      );

      try {
        const resolvedPath = safeResolve(modulePath);
        const mod = loadCjsModule(resolvedPath);
        logger.debug(
          `Successfully loaded module via CJS fallback: ${JSON.stringify({ resolvedPath, moduleId: modulePath })}`,
        );

        if (functionName) {
          logger.debug(`Returning named export: ${functionName}`);
          return mod[functionName];
        }
        return mod;
      } catch (cjsErr) {
        // If CJS fallback also fails, throw a combined error with both details
        const cjsErrorMessage = cjsErr instanceof Error ? cjsErr.message : String(cjsErr);
        logger.error(`ESM import failed for ${modulePath}: ${errorMessage}`);
        logger.error(`CJS fallback also failed: ${cjsErrorMessage}`);

        // Create a combined error that includes both failure reasons
        const combinedError = new Error(
          `Failed to load module ${modulePath}:\n` +