@mui/internal-docs-infra 0.3.1-canary.3 → 0.3.1-canary.4

package/esm/pipeline/loadCodeVariant/loadCodeFallback.js

@@ -1,762 +1,547 @@
-import _toConsumableArray from "@babel/runtime/helpers/esm/toConsumableArray";
-import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import _extends from "@babel/runtime/helpers/esm/extends";
-import _regenerator from "@babel/runtime/helpers/esm/regenerator";
-import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { loadCodeVariant } from "./loadCodeVariant.js";
 import { getFileNameFromUrl, getLanguageFromExtension } from "../loaderUtils/index.js";
 import { performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.js";
 
 // Helper function to get the source for a specific filename from a variant
-function getFileSource(_x, _x2, _x3) {
-  return _getFileSource.apply(this, arguments);
+async function getFileSource(variant, requestedFilename, loadSource) {
+  const filename = requestedFilename || variant.fileName;
+  if (!filename) {
+    // If no filename is available, return the main variant source
+    if (variant.source !== undefined) {
+      return {
+        source: variant.source,
+        filename: undefined
+      };
+    }
+    throw new Error('No filename available and no source in variant');
+  }
+
+  // If requesting the main file and we have its source
+  if (filename === variant.fileName && variant.source !== undefined) {
+    return {
+      source: variant.source,
+      filename
+    };
+  }
+
+  // If requesting an extra file and we have its source
+  if (filename !== variant.fileName && variant.extraFiles) {
+    const extraFile = variant.extraFiles[filename];
+    if (extraFile && typeof extraFile !== 'string' && extraFile.source !== undefined) {
+      return {
+        source: extraFile.source,
+        filename
+      };
+    }
+
+    // If we have the URL but not the source, we need to load it
+    if (typeof extraFile === 'string' && loadSource) {
+      const loadResult = await loadSource(extraFile);
+      return {
+        source: loadResult.source,
+        filename
+      };
+    }
+    if (extraFile && typeof extraFile !== 'string' && !extraFile.source && loadSource) {
+      // This case shouldn't normally happen, but handle it anyway
+      throw new Error(`Extra file ${filename} has no source or URL to load from`);
+    }
+  }
+  throw new Error(`File ${filename} not found in variant or cannot be loaded`);
 }
-function _getFileSource() {
-  _getFileSource = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(variant, requestedFilename, loadSource) {
-    var filename, extraFile, loadResult;
-    return _regenerator().w(function (_context) {
-      while (1) switch (_context.n) {
-        case 0:
-          filename = requestedFilename || variant.fileName;
-          if (filename) {
-            _context.n = 2;
-            break;
-          }
-          if (!(variant.source !== undefined)) {
-            _context.n = 1;
-            break;
-          }
-          return _context.a(2, {
-            source: variant.source,
-            filename: undefined
-          });
-        case 1:
-          throw new Error('No filename available and no source in variant');
-        case 2:
-          if (!(filename === variant.fileName && variant.source !== undefined)) {
-            _context.n = 3;
-            break;
-          }
-          return _context.a(2, {
-            source: variant.source,
-            filename: filename
-          });
-        case 3:
-          if (!(filename !== variant.fileName && variant.extraFiles)) {
-            _context.n = 7;
-            break;
-          }
-          extraFile = variant.extraFiles[filename];
-          if (!(extraFile && typeof extraFile !== 'string' && extraFile.source !== undefined)) {
-            _context.n = 4;
-            break;
-          }
-          return _context.a(2, {
-            source: extraFile.source,
-            filename: filename
-          });
-        case 4:
-          if (!(typeof extraFile === 'string' && loadSource)) {
-            _context.n = 6;
-            break;
-          }
-          _context.n = 5;
-          return loadSource(extraFile);
-        case 5:
-          loadResult = _context.v;
-          return _context.a(2, {
-            source: loadResult.source,
-            filename: filename
-          });
-        case 6:
-          if (!(extraFile && typeof extraFile !== 'string' && !extraFile.source && loadSource)) {
-            _context.n = 7;
-            break;
-          }
-          throw new Error("Extra file ".concat(filename, " has no source or URL to load from"));
-        case 7:
-          throw new Error("File ".concat(filename, " not found in variant or cannot be loaded"));
-        case 8:
-          return _context.a(2);
+export async function loadCodeFallback(url, initialVariant, loaded, options = {}) {
+  const {
+    shouldHighlight,
+    fallbackUsesExtraFiles,
+    fallbackUsesAllVariants,
+    sourceParser,
+    loadSource,
+    loadVariantMeta,
+    loadCodeMeta,
+    initialFilename,
+    variants,
+    globalsCode,
+    output
+  } = options;
+  loaded = {
+    ...loaded
+  };
+  const functionName = 'Load Fallback Code';
+  let currentMark = performanceMeasure(undefined, {
+    mark: 'Start',
+    measure: 'Start'
+  }, [functionName, url], true);
+
+  // Step 1: Ensure we have the initial variant loaded
+  let initial = loaded[initialVariant];
+  if (!initial) {
+    if (!loadCodeMeta) {
+      throw new Error('"loadCodeMeta" function is required when initial variant is not provided');
+    }
+    try {
+      loaded = await loadCodeMeta(url);
+    } catch (error) {
+      throw new Error(`Failed to load code from URL: ${url}. Error: ${JSON.stringify(error)}`);
+    }
+    initial = loaded[initialVariant];
+    if (!initial) {
+      throw new Error(`Initial variant "${initialVariant}" not found in loaded code.`);
+    }
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Loaded Code Meta',
+      measure: 'Code Meta Loading'
+    }, [functionName, url]);
+  }
+
+  // Check if we can return early after loadCodeMeta
+  if (typeof initial !== 'string' && initial.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants) {
+    // Collect all file names from the loaded code
+    const allFileNames = new Set();
+    if (initial.fileName) {
+      allFileNames.add(initial.fileName);
+    }
+    if (initial.extraFiles) {
+      Object.keys(initial.extraFiles).forEach(fileName => allFileNames.add(fileName));
+    }
+
+    // Get the source for the requested filename (or main file if not specified)
+    let fileSource;
+    let actualFilename;
+    try {
+      const result = await getFileSource(initial, initialFilename, loadSource);
+      fileSource = result.source;
+      actualFilename = result.filename;
+    } catch (error) {
+      throw new Error(`Failed to get source for file ${initialFilename || initial.fileName} in variant ${initialVariant}: ${error}`);
+    }
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Loaded Main File',
+      measure: 'Main File Loading'
+    }, [functionName, url]);
+
+    // If we need highlighting and have a string source, parse it
+    if (shouldHighlight && typeof fileSource === 'string' && sourceParser && actualFilename) {
+      try {
+        const parseSource = await sourceParser;
+        fileSource = parseSource(fileSource, actualFilename);
+      } catch (error) {
+        throw new Error(`Failed to parse source for highlighting (variant: ${initialVariant}, file: ${actualFilename}): ${JSON.stringify(error)}`);
       }
-    }, _callee);
-  }));
-  return _getFileSource.apply(this, arguments);
-}
-export function loadCodeFallback(_x4, _x5, _x6) {
-  return _loadCodeFallback.apply(this, arguments);
-}
-function _loadCodeFallback() {
-  _loadCodeFallback = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee4(url, initialVariant, loaded) {
-    var options,
-      shouldHighlight,
-      fallbackUsesExtraFiles,
-      fallbackUsesAllVariants,
-      sourceParser,
-      loadSource,
-      loadVariantMeta,
-      loadCodeMeta,
-      initialFilename,
-      variants,
-      globalsCode,
-      output,
-      functionName,
-      currentMark,
-      initial,
-      _allFileNames,
-      fileSource,
-      actualFilename,
-      result,
-      parseSource,
-      quickVariant,
-      derivedFileName,
-      extension,
-      beforeInitialVariantMark,
-      _allFileNames2,
-      _fileSource,
-      _actualFilename,
-      _result,
-      _parseSource,
-      beforeGlobalsMark,
-      globalsCodeObjects,
-      hasStringUrls,
-      globalsPromises,
-      resolvedGlobalsCode,
-      _iterator,
-      _step,
-      codeObj,
-      targetVariant,
-      _yield$loadCodeVarian,
-      loadedVariant,
-      allFileNames,
-      beforeAllVariantMark,
-      allVariants,
-      variantPromises,
-      variantResults,
-      finalInitial,
-      finalFileSource,
-      finalFilename,
-      _result2,
-      _args4 = arguments,
-      _t4,
-      _t5,
-      _t6,
-      _t7,
-      _t8,
-      _t9,
-      _t0,
-      _t1;
-    return _regenerator().w(function (_context4) {
-      while (1) switch (_context4.p = _context4.n) {
-        case 0:
-          options = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : {};
-          shouldHighlight = options.shouldHighlight, fallbackUsesExtraFiles = options.fallbackUsesExtraFiles, fallbackUsesAllVariants = options.fallbackUsesAllVariants, sourceParser = options.sourceParser, loadSource = options.loadSource, loadVariantMeta = options.loadVariantMeta, loadCodeMeta = options.loadCodeMeta, initialFilename = options.initialFilename, variants = options.variants, globalsCode = options.globalsCode, output = options.output;
-          loaded = _extends({}, loaded);
-          functionName = 'Load Fallback Code';
-          currentMark = performanceMeasure(undefined, {
-            mark: 'Start',
-            measure: 'Start'
-          }, [functionName, url], true); // Step 1: Ensure we have the initial variant loaded
-          initial = loaded[initialVariant];
-          if (initial) {
-            _context4.n = 6;
-            break;
-          }
-          if (loadCodeMeta) {
-            _context4.n = 1;
-            break;
-          }
-          throw new Error('"loadCodeMeta" function is required when initial variant is not provided');
-        case 1:
-          _context4.p = 1;
-          _context4.n = 2;
-          return loadCodeMeta(url);
-        case 2:
-          loaded = _context4.v;
-          _context4.n = 4;
-          break;
-        case 3:
-          _context4.p = 3;
-          _t4 = _context4.v;
-          throw new Error("Failed to load code from URL: ".concat(url, ". Error: ").concat(JSON.stringify(_t4)));
-        case 4:
-          initial = loaded[initialVariant];
-          if (initial) {
-            _context4.n = 5;
-            break;
-          }
-          throw new Error("Initial variant \"".concat(initialVariant, "\" not found in loaded code."));
-        case 5:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded Code Meta',
-            measure: 'Code Meta Loading'
-          }, [functionName, url]);
-        case 6:
-          if (!(typeof initial !== 'string' && initial.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
-            _context4.n = 17;
-            break;
-          }
-          // Collect all file names from the loaded code
-          _allFileNames = new Set();
-          if (initial.fileName) {
-            _allFileNames.add(initial.fileName);
-          }
-          if (initial.extraFiles) {
-            Object.keys(initial.extraFiles).forEach(function (fileName) {
-              return _allFileNames.add(fileName);
-            });
-          }
+      currentMark = performanceMeasure(currentMark, {
+        mark: 'Parsed Main File',
+        measure: 'Main File Parsing'
+      }, [functionName, url]);
+    } else if (shouldHighlight && typeof fileSource === 'string' && !actualFilename) {
+      // Create basic HAST node when we can't parse due to missing filename
+      // This marks that the source has passed through the parsing pipeline
+      fileSource = {
+        type: 'root',
+        children: [{
+          type: 'text',
+          value: fileSource
+        }]
+      };
+    }
 
-          // Get the source for the requested filename (or main file if not specified)
-          _context4.p = 7;
-          _context4.n = 8;
-          return getFileSource(initial, initialFilename, loadSource);
-        case 8:
-          result = _context4.v;
-          fileSource = result.source;
-          actualFilename = result.filename;
-          _context4.n = 10;
-          break;
-        case 9:
-          _context4.p = 9;
-          _t5 = _context4.v;
-          throw new Error("Failed to get source for file ".concat(initialFilename || initial.fileName, " in variant ").concat(initialVariant, ": ").concat(_t5));
-        case 10:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded Main File',
-            measure: 'Main File Loading'
-          }, [functionName, url]);
+    // Update the loaded code with any changes we made
+    if (actualFilename && actualFilename === initial.fileName) {
+      initial = {
+        ...initial,
+        source: fileSource
+      };
+      loaded = {
+        ...loaded,
+        [initialVariant]: initial
+      };
+    } else if (!actualFilename && !initial.fileName) {
+      // If both are undefined, we're dealing with the main source
+      initial = {
+        ...initial,
+        source: fileSource
+      };
+      loaded = {
+        ...loaded,
+        [initialVariant]: initial
+      };
+    }
 
-          // If we need highlighting and have a string source, parse it
-          if (!(shouldHighlight && typeof fileSource === 'string' && sourceParser && actualFilename)) {
-            _context4.n = 15;
-            break;
-          }
-          _context4.p = 11;
-          _context4.n = 12;
-          return sourceParser;
-        case 12:
-          parseSource = _context4.v;
-          fileSource = parseSource(fileSource, actualFilename);
-          _context4.n = 14;
-          break;
-        case 13:
-          _context4.p = 13;
-          _t6 = _context4.v;
-          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(actualFilename, "): ").concat(JSON.stringify(_t6)));
-        case 14:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Parsed Main File',
-            measure: 'Main File Parsing'
-          }, [functionName, url]);
-          _context4.n = 16;
-          break;
-        case 15:
-          if (shouldHighlight && typeof fileSource === 'string' && !actualFilename) {
-            // Create basic HAST node when we can't parse due to missing filename
-            // This marks that the source has passed through the parsing pipeline
-            fileSource = {
-              type: 'root',
-              children: [{
-                type: 'text',
-                value: fileSource
-              }]
-            };
-          }
-        case 16:
-          // Update the loaded code with any changes we made
-          if (actualFilename && actualFilename === initial.fileName) {
-            initial = _extends(_extends({}, initial), {}, {
-              source: fileSource
-            });
-            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
-          } else if (!actualFilename && !initial.fileName) {
-            // If both are undefined, we're dealing with the main source
-            initial = _extends(_extends({}, initial), {}, {
-              source: fileSource
-            });
-            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
-          }
+    // Early return - we have all the info we need
+    return {
+      code: loaded,
+      initialFilename: actualFilename,
+      initialSource: fileSource,
+      initialExtraFiles: initial.extraFiles || {},
+      allFileNames: Array.from(allFileNames)
+    };
+  }
 
-          // Early return - we have all the info we need
-          return _context4.a(2, {
-            code: loaded,
-            initialFilename: actualFilename,
-            initialSource: fileSource,
-            initialExtraFiles: initial.extraFiles || {},
-            allFileNames: Array.from(_allFileNames)
-          });
-        case 17:
-          if (!(typeof initial === 'string')) {
-            _context4.n = 34;
-            break;
-          }
-          _context4.p = 18;
-          if (!loadVariantMeta) {
-            _context4.n = 20;
-            break;
-          }
-          _context4.n = 19;
-          return loadVariantMeta(initialVariant, initial);
-        case 19:
-          quickVariant = _context4.v;
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded Initial Variant Meta',
-            measure: 'Initial Variant Meta Loading'
-          }, [functionName, url]);
-          _context4.n = 21;
-          break;
-        case 20:
-          // Create a basic variant using fallback logic
-          derivedFileName = getFileNameFromUrl(initial).fileName;
-          extension = derivedFileName.slice(derivedFileName.lastIndexOf('.'));
-          quickVariant = {
-            url: initial,
-            fileName: derivedFileName,
-            language: getLanguageFromExtension(extension)
-          };
-        case 21:
-          beforeInitialVariantMark = currentMark;
-          loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, quickVariant));
-          initial = quickVariant;
+  // Step 2: Try to get variant metadata quickly first
+  if (typeof initial === 'string') {
+    try {
+      let quickVariant;
+      if (loadVariantMeta) {
+        // Use provided loadVariantMeta function
+        quickVariant = await loadVariantMeta(initialVariant, initial);
+        currentMark = performanceMeasure(currentMark, {
+          mark: 'Loaded Initial Variant Meta',
+          measure: 'Initial Variant Meta Loading'
+        }, [functionName, url]);
+      } else {
+        // Create a basic variant using fallback logic
+        const derivedFileName = getFileNameFromUrl(initial).fileName;
+        const extension = derivedFileName.slice(derivedFileName.lastIndexOf('.'));
+        quickVariant = {
+          url: initial,
+          fileName: derivedFileName,
+          language: getLanguageFromExtension(extension)
+        };
+      }
+      const beforeInitialVariantMark = currentMark;
+      loaded = {
+        ...loaded,
+        [initialVariant]: quickVariant
+      };
+      initial = quickVariant;
 
-          // If we have all files listed and don't need extra file processing, we can optimize
-          if (!(quickVariant.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants)) {
-            _context4.n = 32;
-            break;
-          }
-          // Collect all file names from the quick load
-          _allFileNames2 = new Set();
-          if (quickVariant.fileName) {
-            _allFileNames2.add(quickVariant.fileName);
-          }
-          if (quickVariant.extraFiles) {
-            Object.keys(quickVariant.extraFiles).forEach(function (fileName) {
-              return _allFileNames2.add(fileName);
-            });
-          }
+      // If we have all files listed and don't need extra file processing, we can optimize
+      if (quickVariant.allFilesListed && !fallbackUsesExtraFiles && !fallbackUsesAllVariants) {
+        // Collect all file names from the quick load
+        const allFileNames = new Set();
+        if (quickVariant.fileName) {
+          allFileNames.add(quickVariant.fileName);
+        }
+        if (quickVariant.extraFiles) {
+          Object.keys(quickVariant.extraFiles).forEach(fileName => allFileNames.add(fileName));
+        }
 
-          // Get the source for the requested filename (or main file if not specified)
-          _context4.p = 22;
-          _context4.n = 23;
-          return getFileSource(quickVariant, initialFilename, loadSource);
-        case 23:
-          _result = _context4.v;
-          _fileSource = _result.source;
-          _actualFilename = _result.filename;
+        // Get the source for the requested filename (or main file if not specified)
+        let fileSource;
+        let actualFilename;
+        try {
+          const result = await getFileSource(quickVariant, initialFilename, loadSource);
+          fileSource = result.source;
+          actualFilename = result.filename;
           currentMark = performanceMeasure(currentMark, {
             mark: 'Loaded Initial File',
             measure: 'Initial File Loading'
           }, [functionName, initialFilename || 'unknown', url]);
-          _context4.n = 25;
-          break;
-        case 24:
-          _context4.p = 24;
-          _t7 = _context4.v;
-          throw new Error("Failed to get source for file ".concat(initialFilename || quickVariant.fileName, " in variant ").concat(initialVariant, ": ").concat(_t7));
-        case 25:
-          if (!(shouldHighlight && typeof _fileSource === 'string' && sourceParser && _actualFilename)) {
-            _context4.n = 30;
-            break;
-          }
-          _context4.p = 26;
-          _context4.n = 27;
-          return sourceParser;
-        case 27:
-          _parseSource = _context4.v;
-          _fileSource = _parseSource(_fileSource, _actualFilename);
+        } catch (error) {
+          throw new Error(`Failed to get source for file ${initialFilename || quickVariant.fileName} in variant ${initialVariant}: ${error}`);
+        }
+
+        // If we need highlighting and have a string source, parse it
+        if (shouldHighlight && typeof fileSource === 'string' && sourceParser && actualFilename) {
+          try {
+            const parseSource = await sourceParser;
+            fileSource = parseSource(fileSource, actualFilename);
+            currentMark = performanceMeasure(currentMark, {
+              mark: 'Parsed Initial File',
+              measure: 'Initial File Parsing'
+            }, [functionName, initialFilename || 'unknown', url]);
+          } catch (error) {
+            throw new Error(`Failed to parse source for highlighting (variant: ${initialVariant}, file: ${actualFilename}): ${JSON.stringify(error)}`);
+          }
+        } else if (shouldHighlight && typeof fileSource === 'string' && !actualFilename) {
+          // Create basic HAST node when we can't parse due to missing filename
+          // This marks that the source has passed through the parsing pipeline
+          fileSource = {
+            type: 'root',
+            children: [{
+              type: 'text',
+              value: fileSource
+            }]
+          };
+        }
+
+        // Update the loaded code with any changes we made
+        if (actualFilename && actualFilename === quickVariant.fileName) {
+          initial = {
+            ...quickVariant,
+            source: fileSource
+          };
+          loaded = {
+            ...loaded,
+            [initialVariant]: initial
+          };
+        } else if (!actualFilename && !quickVariant.fileName) {
+          // If both are undefined, we're dealing with the main source
+          initial = {
+            ...quickVariant,
+            source: fileSource
+          };
+          loaded = {
+            ...loaded,
+            [initialVariant]: initial
+          };
+        }
+        currentMark = performanceMeasure(beforeInitialVariantMark, {
+          mark: 'Loaded Initial Files',
+          measure: 'Initial Files Loading'
+        }, [functionName, url], true);
+
+        // Early return - we have all the info we need
+        return {
+          code: loaded,
+          initialFilename: actualFilename,
+          initialSource: fileSource,
+          initialExtraFiles: quickVariant.extraFiles || {},
+          allFileNames: Array.from(allFileNames)
+        };
+      }
+    } catch (error) {
+      throw new Error(`Failed to load initial variant code (variant: ${initialVariant}, url: ${initial}): ${JSON.stringify(error)}`);
+    }
+  }
+  const beforeGlobalsMark = currentMark;
+
+  // Step 2b: Fall back to full loadCodeVariant processing
+  // Load globalsCode - convert string URLs to Code objects, keep Code objects as-is
+  let globalsCodeObjects;
+  if (globalsCode && globalsCode.length > 0) {
+    const hasStringUrls = globalsCode.some(item => typeof item === 'string');
+    if (hasStringUrls && !loadCodeMeta) {
+      throw new Error('loadCodeMeta function is required when globalsCode contains string URLs');
+    }
+
+    // Load all string URLs in parallel, keep Code objects as-is
+    const globalsPromises = globalsCode.map(async globalItem => {
+      if (typeof globalItem === 'string') {
+        // String URL - load Code object via loadCodeMeta
+        try {
+          const codeMeta = await loadCodeMeta(globalItem);
           currentMark = performanceMeasure(currentMark, {
-            mark: 'Parsed Initial File',
-            measure: 'Initial File Parsing'
-          }, [functionName, initialFilename || 'unknown', url]);
-          _context4.n = 29;
-          break;
-        case 28:
-          _context4.p = 28;
-          _t8 = _context4.v;
-          throw new Error("Failed to parse source for highlighting (variant: ".concat(initialVariant, ", file: ").concat(_actualFilename, "): ").concat(JSON.stringify(_t8)));
-        case 29:
-          _context4.n = 31;
-          break;
-        case 30:
-          if (shouldHighlight && typeof _fileSource === 'string' && !_actualFilename) {
-            // Create basic HAST node when we can't parse due to missing filename
-            // This marks that the source has passed through the parsing pipeline
-            _fileSource = {
-              type: 'root',
-              children: [{
-                type: 'text',
-                value: _fileSource
-              }]
-            };
-          }
-        case 31:
-          // Update the loaded code with any changes we made
-          if (_actualFilename && _actualFilename === quickVariant.fileName) {
-            initial = _extends(_extends({}, quickVariant), {}, {
-              source: _fileSource
-            });
-            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
-          } else if (!_actualFilename && !quickVariant.fileName) {
-            // If both are undefined, we're dealing with the main source
-            initial = _extends(_extends({}, quickVariant), {}, {
-              source: _fileSource
-            });
-            loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, initial));
-          }
-          currentMark = performanceMeasure(beforeInitialVariantMark, {
-            mark: 'Loaded Initial Files',
-            measure: 'Initial Files Loading'
-          }, [functionName, url], true);
+            mark: 'Loaded Global Code Meta',
+            measure: 'Global Code Meta Loading'
+          }, [functionName, globalItem, url]);
+          return codeMeta;
+        } catch (error) {
+          throw new Error(`Failed to load globalsCode from URL: ${globalItem}. Error: ${JSON.stringify(error)}`);
+        }
+      } else {
+        // Code object - return as-is
+        return globalItem;
+      }
+    });
+    globalsCodeObjects = await Promise.all(globalsPromises);
+    currentMark = performanceMeasure(beforeGlobalsMark, {
+      mark: 'Loaded Globals Meta',
+      measure: 'Globals Meta Loading'
+    }, [functionName, url], true);
+  }
 
-          // Early return - we have all the info we need
-          return _context4.a(2, {
-            code: loaded,
-            initialFilename: _actualFilename,
-            initialSource: _fileSource,
-            initialExtraFiles: quickVariant.extraFiles || {},
-            allFileNames: Array.from(_allFileNames2)
-          });
-        case 32:
-          _context4.n = 34;
-          break;
-        case 33:
-          _context4.p = 33;
-          _t9 = _context4.v;
-          throw new Error("Failed to load initial variant code (variant: ".concat(initialVariant, ", url: ").concat(initial, "): ").concat(JSON.stringify(_t9)));
-        case 34:
-          beforeGlobalsMark = currentMark; // Step 2b: Fall back to full loadCodeVariant processing
-          // Load globalsCode - convert string URLs to Code objects, keep Code objects as-is
-          if (!(globalsCode && globalsCode.length > 0)) {
-            _context4.n = 37;
-            break;
-          }
-          hasStringUrls = globalsCode.some(function (item) {
-            return typeof item === 'string';
-          });
-          if (!(hasStringUrls && !loadCodeMeta)) {
-            _context4.n = 35;
-            break;
-          }
-          throw new Error('loadCodeMeta function is required when globalsCode contains string URLs');
-        case 35:
-          // Load all string URLs in parallel, keep Code objects as-is
-          globalsPromises = globalsCode.map(/*#__PURE__*/function () {
-            var _ref = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(globalItem) {
-              var codeMeta, _t;
-              return _regenerator().w(function (_context2) {
-                while (1) switch (_context2.p = _context2.n) {
-                  case 0:
-                    if (!(typeof globalItem === 'string')) {
-                      _context2.n = 4;
-                      break;
-                    }
-                    _context2.p = 1;
-                    _context2.n = 2;
-                    return loadCodeMeta(globalItem);
-                  case 2:
-                    codeMeta = _context2.v;
-                    currentMark = performanceMeasure(currentMark, {
-                      mark: 'Loaded Global Code Meta',
-                      measure: 'Global Code Meta Loading'
-                    }, [functionName, globalItem, url]);
-                    return _context2.a(2, codeMeta);
-                  case 3:
-                    _context2.p = 3;
-                    _t = _context2.v;
-                    throw new Error("Failed to load globalsCode from URL: ".concat(globalItem, ". Error: ").concat(JSON.stringify(_t)));
-                  case 4:
-                    return _context2.a(2, globalItem);
-                  case 5:
-                    return _context2.a(2);
-                }
-              }, _callee2, null, [[1, 3]]);
-            }));
-            return function (_x7) {
-              return _ref.apply(this, arguments);
+  // Convert globalsCodeObjects to VariantCode | string for this specific variant
+  let resolvedGlobalsCode;
+  if (globalsCodeObjects && globalsCodeObjects.length > 0) {
+    resolvedGlobalsCode = [];
+    for (const codeObj of globalsCodeObjects) {
+      // Only use the variant that matches the current initialVariant
+      const targetVariant = codeObj[initialVariant];
+      if (targetVariant) {
+        resolvedGlobalsCode.push(targetVariant);
+      }
+    }
+  }
+  try {
+    const {
+      code: loadedVariant
+    } = await loadCodeVariant(url, initialVariant, initial, {
+      sourceParser,
+      loadSource,
+      loadVariantMeta,
+      sourceTransformers: undefined,
+      // sourceTransformers - skip transforms for fallback
+      disableTransforms: true,
+      // Don't apply transforms for fallback
+      disableParsing: !shouldHighlight,
+      // Only parse if highlighting is needed
+      globalsCode: resolvedGlobalsCode,
+      // Pass resolved globalsCode
+      output
+    });
+    currentMark = performanceMeasure(currentMark, {
+      mark: 'Loaded Initial Variant',
+      measure: 'Initial Variant Loading'
+    }, [functionName, url], true);
+
+    // Update the loaded code with the processed variant
+    loaded = {
+      ...loaded,
+      [initialVariant]: loadedVariant
+    };
+    initial = loadedVariant;
+  } catch (error) {
+    throw new Error(`Failed to load initial variant using loadCodeVariant (variant: ${initialVariant}, url: ${url}): ${JSON.stringify(error)}`);
+  }
+
+  // Step 3: Collect all file names
+  const allFileNames = new Set();
+  if (initial.fileName) {
+    allFileNames.add(initial.fileName);
+  }
+
+  // Add extra files from the initial variant
+  if (initial.extraFiles) {
+    Object.keys(initial.extraFiles).forEach(fileName => allFileNames.add(fileName));
+  }
+
+  // Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
+  if (fallbackUsesAllVariants) {
+    const beforeAllVariantMark = currentMark;
+
+    // Determine all variants to process - use provided variants or infer from loaded code
+    const allVariants = variants || Object.keys(loaded || {});
+    if (allVariants.length === 0) {
+      console.warn('No variants found for fallbackUsesAllVariants processing');
+    } else {
+      // Process all required variants, not just the ones already loaded
+      const variantPromises = allVariants.map(async variantName => {
+        if (variantName === initialVariant) {
+          // Skip initial variant as it's already processed
+          return {
+            variantName,
+            loadedVariant: null,
+            fileNames: []
+          };
+        }
+        let variant = loaded?.[variantName];
+
+        // If variant is not loaded yet, load it first using loadCodeMeta
+        if (!variant && loadCodeMeta) {
+          try {
+            const allCode = await loadCodeMeta(url);
+            variant = allCode[variantName];
+            // Update loaded with all variants from loadCodeMeta
+            loaded = {
+              ...loaded,
+              ...allCode
+            };
+            currentMark = performanceMeasure(currentMark, {
+              mark: 'Loaded Initial Code Meta',
+              measure: 'Initial Code Meta Loading'
+            }, [functionName, url]);
+          } catch (error) {
+            console.warn(`Failed to load code meta for variant ${variantName}: ${error}`);
+            return {
+              variantName,
+              loadedVariant: null,
+              fileNames: []
             };
-          }());
-          _context4.n = 36;
-          return Promise.all(globalsPromises);
-        case 36:
-          globalsCodeObjects = _context4.v;
-          currentMark = performanceMeasure(beforeGlobalsMark, {
-            mark: 'Loaded Globals Meta',
-            measure: 'Globals Meta Loading'
-          }, [functionName, url], true);
-        case 37:
-          if (globalsCodeObjects && globalsCodeObjects.length > 0) {
-            resolvedGlobalsCode = [];
-            _iterator = _createForOfIteratorHelper(globalsCodeObjects);
-            try {
-              for (_iterator.s(); !(_step = _iterator.n()).done;) {
-                codeObj = _step.value;
-                // Only use the variant that matches the current initialVariant
-                targetVariant = codeObj[initialVariant];
-                if (targetVariant) {
-                  resolvedGlobalsCode.push(targetVariant);
-                }
-              }
-            } catch (err) {
-              _iterator.e(err);
-            } finally {
-              _iterator.f();
-            }
           }
-          _context4.p = 38;
-          _context4.n = 39;
-          return loadCodeVariant(url, initialVariant, initial, {
-            sourceParser: sourceParser,
-            loadSource: loadSource,
-            loadVariantMeta: loadVariantMeta,
+        }
+        if (!variant) {
+          console.warn(`Variant ${variantName} not found after loading code meta`);
+          return {
+            variantName,
+            loadedVariant: null,
+            fileNames: []
+          };
+        }
+        try {
+          const {
+            code: loadedVariant
+          } = await loadCodeVariant(url, variantName, variant, {
+            sourceParser,
+            loadSource,
+            loadVariantMeta,
             sourceTransformers: undefined,
-            // sourceTransformers - skip transforms for fallback
+            // sourceTransformers
             disableTransforms: true,
-            // Don't apply transforms for fallback
             disableParsing: !shouldHighlight,
-            // Only parse if highlighting is needed
-            globalsCode: resolvedGlobalsCode,
-            // Pass resolved globalsCode
-            output: output
+            output,
+            globalsCode: globalsCodeObjects && globalsCodeObjects.length > 0 ? (() => {
+              // Convert globalsCodeObjects to VariantCode | string for this specific variant
+              const variantGlobalsCode = [];
+              for (const codeObj of globalsCodeObjects) {
+                // Only use the variant that matches the current variantName
+                const targetVariant = codeObj[variantName];
+                if (targetVariant) {
+                  variantGlobalsCode.push(targetVariant);
+                }
+              }
+              return variantGlobalsCode;
+            })() : undefined
           });
-        case 39:
-          _yield$loadCodeVarian = _context4.v;
-          loadedVariant = _yield$loadCodeVarian.code;
+
+          // Collect file names from this variant
+          const fileNames = loadedVariant.fileName ? [loadedVariant.fileName] : [];
+          if (loadedVariant.extraFiles) {
+            fileNames.push(...Object.keys(loadedVariant.extraFiles));
+          }
           currentMark = performanceMeasure(currentMark, {
             mark: 'Loaded Initial Variant',
             measure: 'Initial Variant Loading'
-          }, [functionName, url], true);
+          }, [functionName, variantName, url], true);
+          return {
+            variantName,
+            loadedVariant,
+            fileNames
+          };
+        } catch (error) {
+          // Log but don't fail - we want to get as many file names as possible
+          console.warn(`Failed to load variant ${variantName} for file listing: ${error}`);
+          return {
+            variantName,
+            loadedVariant: null,
+            fileNames: []
+          };
+        }
+      });
+      const variantResults = await Promise.all(variantPromises);
 
-          // Update the loaded code with the processed variant
-          loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, loadedVariant));
-          initial = loadedVariant;
-          _context4.n = 41;
-          break;
-        case 40:
-          _context4.p = 40;
-          _t0 = _context4.v;
-          throw new Error("Failed to load initial variant using loadCodeVariant (variant: ".concat(initialVariant, ", url: ").concat(url, "): ").concat(JSON.stringify(_t0)));
-        case 41:
-          // Step 3: Collect all file names
-          allFileNames = new Set();
-          if (initial.fileName) {
-            allFileNames.add(initial.fileName);
-          }
+      // Update loaded code and collect file names
+      variantResults.forEach(({
+        variantName,
+        loadedVariant,
+        fileNames
+      }) => {
+        if (loadedVariant) {
+          loaded = {
+            ...loaded,
+            [variantName]: loadedVariant
+          };
+        }
+        fileNames.forEach(fileName => allFileNames.add(fileName));
+      });
+    }
+    currentMark = performanceMeasure(beforeAllVariantMark, {
+      mark: 'Loaded Initial Variants',
+      measure: 'Initial Variants Loading'
+    }, [functionName, url], true);
+  }
 
-          // Add extra files from the initial variant
-          if (initial.extraFiles) {
-            Object.keys(initial.extraFiles).forEach(function (fileName) {
-              return allFileNames.add(fileName);
-            });
-          }
+  // Ensure we have the latest initial variant data
+  const finalInitial = loaded[initialVariant];
+  if (!finalInitial || typeof finalInitial === 'string') {
+    throw new Error(`Failed to process initial variant: ${initialVariant}`);
+  }
 
-          // Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
-          if (!fallbackUsesAllVariants) {
-            _context4.n = 45;
-            break;
-          }
-          beforeAllVariantMark = currentMark; // Determine all variants to process - use provided variants or infer from loaded code
-          allVariants = variants || Object.keys(loaded || {});
-          if (!(allVariants.length === 0)) {
-            _context4.n = 42;
-            break;
-          }
-          console.warn('No variants found for fallbackUsesAllVariants processing');
-          _context4.n = 44;
-          break;
-        case 42:
-          // Process all required variants, not just the ones already loaded
-          variantPromises = allVariants.map(/*#__PURE__*/function () {
-            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee3(variantName) {
-              var _loaded;
-              var variant, allCode, _yield$loadCodeVarian2, _loadedVariant, fileNames, _t2, _t3;
-              return _regenerator().w(function (_context3) {
-                while (1) switch (_context3.p = _context3.n) {
-                  case 0:
-                    if (!(variantName === initialVariant)) {
-                      _context3.n = 1;
-                      break;
-                    }
-                    return _context3.a(2, {
-                      variantName: variantName,
-                      loadedVariant: null,
-                      fileNames: []
-                    });
-                  case 1:
-                    variant = (_loaded = loaded) == null ? void 0 : _loaded[variantName]; // If variant is not loaded yet, load it first using loadCodeMeta
-                    if (!(!variant && loadCodeMeta)) {
-                      _context3.n = 5;
-                      break;
-                    }
-                    _context3.p = 2;
-                    _context3.n = 3;
-                    return loadCodeMeta(url);
-                  case 3:
-                    allCode = _context3.v;
-                    variant = allCode[variantName];
-                    // Update loaded with all variants from loadCodeMeta
-                    loaded = _extends(_extends({}, loaded), allCode);
-                    currentMark = performanceMeasure(currentMark, {
-                      mark: 'Loaded Initial Code Meta',
-                      measure: 'Initial Code Meta Loading'
-                    }, [functionName, url]);
-                    _context3.n = 5;
-                    break;
-                  case 4:
-                    _context3.p = 4;
-                    _t2 = _context3.v;
-                    console.warn("Failed to load code meta for variant ".concat(variantName, ": ").concat(_t2));
-                    return _context3.a(2, {
-                      variantName: variantName,
-                      loadedVariant: null,
-                      fileNames: []
-                    });
-                  case 5:
-                    if (variant) {
-                      _context3.n = 6;
-                      break;
-                    }
-                    console.warn("Variant ".concat(variantName, " not found after loading code meta"));
-                    return _context3.a(2, {
-                      variantName: variantName,
-                      loadedVariant: null,
-                      fileNames: []
-                    });
-                  case 6:
-                    _context3.p = 6;
-                    _context3.n = 7;
-                    return loadCodeVariant(url, variantName, variant, {
-                      sourceParser: sourceParser,
-                      loadSource: loadSource,
-                      loadVariantMeta: loadVariantMeta,
-                      sourceTransformers: undefined,
-                      // sourceTransformers
-                      disableTransforms: true,
-                      disableParsing: !shouldHighlight,
-                      output: output,
-                      globalsCode: globalsCodeObjects && globalsCodeObjects.length > 0 ? function () {
-                        // Convert globalsCodeObjects to VariantCode | string for this specific variant
-                        var variantGlobalsCode = [];
-                        var _iterator2 = _createForOfIteratorHelper(globalsCodeObjects),
-                          _step2;
-                        try {
-                          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
-                            var _codeObj = _step2.value;
-                            // Only use the variant that matches the current variantName
-                            var _targetVariant = _codeObj[variantName];
-                            if (_targetVariant) {
-                              variantGlobalsCode.push(_targetVariant);
-                            }
-                          }
-                        } catch (err) {
-                          _iterator2.e(err);
-                        } finally {
-                          _iterator2.f();
-                        }
-                        return variantGlobalsCode;
-                      }() : undefined
-                    });
-                  case 7:
-                    _yield$loadCodeVarian2 = _context3.v;
-                    _loadedVariant = _yield$loadCodeVarian2.code;
-                    // Collect file names from this variant
-                    fileNames = _loadedVariant.fileName ? [_loadedVariant.fileName] : [];
-                    if (_loadedVariant.extraFiles) {
-                      fileNames.push.apply(fileNames, _toConsumableArray(Object.keys(_loadedVariant.extraFiles)));
-                    }
-                    currentMark = performanceMeasure(currentMark, {
-                      mark: 'Loaded Initial Variant',
-                      measure: 'Initial Variant Loading'
-                    }, [functionName, variantName, url], true);
-                    return _context3.a(2, {
-                      variantName: variantName,
-                      loadedVariant: _loadedVariant,
-                      fileNames: fileNames
-                    });
-                  case 8:
-                    _context3.p = 8;
-                    _t3 = _context3.v;
-                    // Log but don't fail - we want to get as many file names as possible
-                    console.warn("Failed to load variant ".concat(variantName, " for file listing: ").concat(_t3));
-                    return _context3.a(2, {
-                      variantName: variantName,
-                      loadedVariant: null,
-                      fileNames: []
-                    });
-                }
-              }, _callee3, null, [[6, 8], [2, 4]]);
-            }));
-            return function (_x8) {
-              return _ref2.apply(this, arguments);
-            };
-          }());
-          _context4.n = 43;
-          return Promise.all(variantPromises);
-        case 43:
-          variantResults = _context4.v;
-          // Update loaded code and collect file names
-          variantResults.forEach(function (_ref3) {
-            var variantName = _ref3.variantName,
-              loadedVariant = _ref3.loadedVariant,
-              fileNames = _ref3.fileNames;
-            if (loadedVariant) {
-              loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, variantName, loadedVariant));
-            }
-            fileNames.forEach(function (fileName) {
-              return allFileNames.add(fileName);
-            });
-          });
-        case 44:
-          currentMark = performanceMeasure(beforeAllVariantMark, {
-            mark: 'Loaded Initial Variants',
-            measure: 'Initial Variants Loading'
-          }, [functionName, url], true);
-        case 45:
-          // Ensure we have the latest initial variant data
-          finalInitial = loaded[initialVariant];
-          if (!(!finalInitial || typeof finalInitial === 'string')) {
-            _context4.n = 46;
-            break;
-          }
-          throw new Error("Failed to process initial variant: ".concat(initialVariant));
-        case 46:
-          _context4.p = 46;
-          _context4.n = 47;
-          return getFileSource(finalInitial, initialFilename, loadSource);
-        case 47:
-          _result2 = _context4.v;
-          finalFileSource = _result2.source;
-          finalFilename = _result2.filename;
-          _context4.n = 50;
-          break;
-        case 48:
-          _context4.p = 48;
-          _t1 = _context4.v;
-          if (!(!finalInitial.fileName && !finalInitial.source)) {
-            _context4.n = 49;
-            break;
-          }
-          throw new Error("Cannot determine filename for initial variant \"".concat(initialVariant, "\". ") + "No fileName available in variant definition, no initialFilename provided, and no source available.");
-        case 49:
-          // Fall back to the main file with proper validation
-          finalFileSource = finalInitial.source || '';
-          finalFilename = finalInitial.fileName;
-        case 50:
-          currentMark = performanceMeasure(currentMark, {
-            mark: 'Loaded Initial File',
-            measure: 'Initial File Loading'
-          }, [functionName, url]);
-          return _context4.a(2, {
-            code: loaded,
-            initialFilename: finalFilename,
-            initialSource: finalFileSource,
-            initialExtraFiles: finalInitial.extraFiles || {},
-            allFileNames: Array.from(allFileNames),
-            processedGlobalsCode: globalsCodeObjects
-          });
-      }
-    }, _callee4, null, [[46, 48], [38, 40], [26, 28], [22, 24], [18, 33], [11, 13], [7, 9], [1, 3]]);
-  }));
-  return _loadCodeFallback.apply(this, arguments);
+  // Get the source for the requested filename (or main file if not specified) for the final return
+  let finalFileSource;
+  let finalFilename;
+  try {
+    const result = await getFileSource(finalInitial, initialFilename, loadSource);
+    finalFileSource = result.source;
+    finalFilename = result.filename;
+  } catch (error) {
+    // If we can't get the specific file, fall back to main file
+    if (!finalInitial.fileName && !finalInitial.source) {
+      throw new Error(`Cannot determine filename for initial variant "${initialVariant}". ` + `No fileName available in variant definition, no initialFilename provided, and no source available.`);
+    }
+
+    // Fall back to the main file with proper validation
+    finalFileSource = finalInitial.source || '';
+    finalFilename = finalInitial.fileName;
+  }
+  currentMark = performanceMeasure(currentMark, {
+    mark: 'Loaded Initial File',
+    measure: 'Initial File Loading'
+  }, [functionName, url]);
+  return {
+    code: loaded,
+    initialFilename: finalFilename,
+    initialSource: finalFileSource,
+    initialExtraFiles: finalInitial.extraFiles || {},
+    allFileNames: Array.from(allFileNames),
+    processedGlobalsCode: globalsCodeObjects
+  };
 }