@mui/internal-docs-infra 0.2.3-canary.13 → 0.2.3-canary.14

package/esm/pipeline/loadCodeVariant/loadCodeFallback.js

@@ -6,6 +6,7 @@ import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { loadCodeVariant } from "./loadCodeVariant.js";
 import { getFileNameFromUrl } 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) {
@@ -100,6 +101,8 @@ function _loadCodeFallback() {
       variants,
       globalsCode,
       output,
+      functionName,
+      currentMark,
       initial,
       _allFileNames,
       fileSource,
@@ -107,11 +110,13 @@ function _loadCodeFallback() {
       result,
       parseSource,
       quickVariant,
+      beforeInitialVariantMark,
       _allFileNames2,
       _fileSource,
       _actualFilename,
       _result,
       _parseSource,
+      beforeGlobalsMark,
       globalsCodeObjects,
       hasStringUrls,
       globalsPromises,
@@ -123,6 +128,7 @@ function _loadCodeFallback() {
       _yield$loadCodeVarian,
       loadedVariant,
       allFileNames,
+      beforeAllVariantMark,
       allVariants,
       variantPromises,
       variantResults,
@@ -145,11 +151,14 @@ function _loadCodeFallback() {
           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);
-
-          // Step 1: Ensure we have the initial variant 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 = 5;
+            _context4.n = 6;
             break;
           }
           if (loadCodeMeta) {
@@ -177,8 +186,13 @@ function _loadCodeFallback() {
           }
           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 = 16;
+            _context4.n = 17;
             break;
           }
           // Collect all file names from the loaded code
@@ -193,40 +207,50 @@ function _loadCodeFallback() {
           }
 
           // Get the source for the requested filename (or main file if not specified)
-          _context4.p = 6;
-          _context4.n = 7;
+          _context4.p = 7;
+          _context4.n = 8;
           return getFileSource(initial, initialFilename, loadSource);
-        case 7:
+        case 8:
           result = _context4.v;
           fileSource = result.source;
           actualFilename = result.filename;
-          _context4.n = 9;
+          _context4.n = 10;
           break;
-        case 8:
-          _context4.p = 8;
+        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 9:
+        case 10:
+          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)) {
-            _context4.n = 14;
+            _context4.n = 15;
             break;
           }
-          _context4.p = 10;
-          _context4.n = 11;
+          _context4.p = 11;
+          _context4.n = 12;
           return sourceParser;
-        case 11:
+        case 12:
           parseSource = _context4.v;
           fileSource = parseSource(fileSource, actualFilename);
-          _context4.n = 13;
+          _context4.n = 14;
           break;
-        case 12:
-          _context4.p = 12;
+        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 13:
-          _context4.n = 15;
-          break;
         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
@@ -238,7 +262,7 @@ function _loadCodeFallback() {
               }]
             };
           }
-        case 15:
+        case 16:
           // Update the loaded code with any changes we made
           if (actualFilename && actualFilename === initial.fileName) {
             initial = _extends(_extends({}, initial), {}, {
@@ -261,35 +285,40 @@ function _loadCodeFallback() {
             initialExtraFiles: initial.extraFiles || {},
             allFileNames: Array.from(_allFileNames)
           });
-        case 16:
+        case 17:
           if (!(typeof initial === 'string')) {
-            _context4.n = 33;
+            _context4.n = 34;
             break;
           }
-          _context4.p = 17;
+          _context4.p = 18;
           if (!loadVariantMeta) {
-            _context4.n = 19;
+            _context4.n = 20;
             break;
           }
-          _context4.n = 18;
+          _context4.n = 19;
           return loadVariantMeta(initialVariant, initial);
-        case 18:
+        case 19:
           quickVariant = _context4.v;
-          _context4.n = 20;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Initial Variant Meta',
+            measure: 'Initial Variant Meta Loading'
+          }, [functionName, url]);
+          _context4.n = 21;
           break;
-        case 19:
+        case 20:
           // Create a basic variant using fallback logic
           quickVariant = {
             url: initial,
             fileName: getFileNameFromUrl(initial).fileName
           };
-        case 20:
+        case 21:
+          beforeInitialVariantMark = currentMark;
           loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, 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 = 31;
+            _context4.n = 32;
             break;
           }
           // Collect all file names from the quick load
@@ -304,40 +333,48 @@ function _loadCodeFallback() {
           }
 
           // Get the source for the requested filename (or main file if not specified)
-          _context4.p = 21;
-          _context4.n = 22;
+          _context4.p = 22;
+          _context4.n = 23;
           return getFileSource(quickVariant, initialFilename, loadSource);
-        case 22:
+        case 23:
           _result = _context4.v;
           _fileSource = _result.source;
           _actualFilename = _result.filename;
-          _context4.n = 24;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Initial File',
+            measure: 'Initial File Loading'
+          }, [functionName, initialFilename || 'unknown', url]);
+          _context4.n = 25;
           break;
-        case 23:
-          _context4.p = 23;
+        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 24:
+        case 25:
           if (!(shouldHighlight && typeof _fileSource === 'string' && sourceParser && _actualFilename)) {
-            _context4.n = 29;
+            _context4.n = 30;
             break;
           }
-          _context4.p = 25;
-          _context4.n = 26;
+          _context4.p = 26;
+          _context4.n = 27;
           return sourceParser;
-        case 26:
+        case 27:
           _parseSource = _context4.v;
           _fileSource = _parseSource(_fileSource, _actualFilename);
-          _context4.n = 28;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed Initial File',
+            measure: 'Initial File Parsing'
+          }, [functionName, initialFilename || 'unknown', url]);
+          _context4.n = 29;
           break;
-        case 27:
-          _context4.p = 27;
+        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 28:
-          _context4.n = 30;
-          break;
         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
@@ -349,7 +386,7 @@ function _loadCodeFallback() {
               }]
             };
           }
-        case 30:
+        case 31:
           // Update the loaded code with any changes we made
           if (_actualFilename && _actualFilename === quickVariant.fileName) {
             initial = _extends(_extends({}, quickVariant), {}, {
@@ -363,6 +400,10 @@ function _loadCodeFallback() {
             });
             loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, 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 _context4.a(2, {
@@ -372,31 +413,33 @@ function _loadCodeFallback() {
             initialExtraFiles: quickVariant.extraFiles || {},
             allFileNames: Array.from(_allFileNames2)
           });
-        case 31:
-          _context4.n = 33;
-          break;
         case 32:
-          _context4.p = 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 33:
+        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 = 36;
+            _context4.n = 37;
             break;
           }
           hasStringUrls = globalsCode.some(function (item) {
             return typeof item === 'string';
           });
           if (!(hasStringUrls && !loadCodeMeta)) {
-            _context4.n = 34;
+            _context4.n = 35;
             break;
           }
           throw new Error('loadCodeMeta function is required when globalsCode contains string URLs');
-        case 34:
+        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 _t;
+              var codeMeta, _t;
               return _regenerator().w(function (_context2) {
                 while (1) switch (_context2.p = _context2.n) {
                   case 0:
@@ -408,7 +451,12 @@ function _loadCodeFallback() {
                     _context2.n = 2;
                     return loadCodeMeta(globalItem);
                   case 2:
-                    return _context2.a(2, _context2.v);
+                    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;
@@ -424,11 +472,15 @@ function _loadCodeFallback() {
               return _ref.apply(this, arguments);
             };
           }());
-          _context4.n = 35;
+          _context4.n = 36;
           return Promise.all(globalsPromises);
-        case 35:
-          globalsCodeObjects = _context4.v;
         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);
@@ -447,8 +499,8 @@ function _loadCodeFallback() {
               _iterator.f();
             }
           }
-          _context4.p = 37;
-          _context4.n = 38;
+          _context4.p = 38;
+          _context4.n = 39;
           return loadCodeVariant(url, initialVariant, initial, {
             sourceParser: sourceParser,
             loadSource: loadSource,
@@ -463,19 +515,24 @@ function _loadCodeFallback() {
             // Pass resolved globalsCode
             output: output
           });
-        case 38:
+        case 39:
           _yield$loadCodeVarian = _context4.v;
           loadedVariant = _yield$loadCodeVarian.code;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Initial Variant',
+            measure: 'Initial Variant Loading'
+          }, [functionName, url], true);
+
           // Update the loaded code with the processed variant
           loaded = _extends(_extends({}, loaded), {}, _defineProperty({}, initialVariant, loadedVariant));
           initial = loadedVariant;
-          _context4.n = 40;
+          _context4.n = 41;
           break;
-        case 39:
-          _context4.p = 39;
+        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 40:
+        case 41:
           // Step 3: Collect all file names
           allFileNames = new Set();
           if (initial.fileName) {
@@ -491,19 +548,19 @@ function _loadCodeFallback() {
 
           // Step 4: Handle fallbackUsesAllVariants - load all variants to get all possible files
           if (!fallbackUsesAllVariants) {
-            _context4.n = 43;
+            _context4.n = 45;
             break;
           }
-          // Determine all variants to process - use provided variants or infer from loaded code
+          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 = 41;
+            _context4.n = 42;
             break;
           }
           console.warn('No variants found for fallbackUsesAllVariants processing');
-          _context4.n = 43;
+          _context4.n = 44;
           break;
-        case 41:
+        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) {
@@ -535,6 +592,10 @@ function _loadCodeFallback() {
                     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:
@@ -599,6 +660,10 @@ function _loadCodeFallback() {
                     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,
@@ -621,9 +686,9 @@ function _loadCodeFallback() {
               return _ref2.apply(this, arguments);
             };
           }());
-          _context4.n = 42;
+          _context4.n = 43;
           return Promise.all(variantPromises);
-        case 42:
+        case 43:
           variantResults = _context4.v;
           // Update loaded code and collect file names
           variantResults.forEach(function (_ref3) {
@@ -637,37 +702,46 @@ function _loadCodeFallback() {
               return allFileNames.add(fileName);
             });
           });
-        case 43:
+        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 = 44;
+            _context4.n = 46;
             break;
           }
           throw new Error("Failed to process initial variant: ".concat(initialVariant));
-        case 44:
-          _context4.p = 44;
-          _context4.n = 45;
+        case 46:
+          _context4.p = 46;
+          _context4.n = 47;
           return getFileSource(finalInitial, initialFilename, loadSource);
-        case 45:
+        case 47:
           _result2 = _context4.v;
           finalFileSource = _result2.source;
           finalFilename = _result2.filename;
-          _context4.n = 48;
+          _context4.n = 50;
           break;
-        case 46:
-          _context4.p = 46;
+        case 48:
+          _context4.p = 48;
           _t1 = _context4.v;
           if (!(!finalInitial.fileName && !finalInitial.source)) {
-            _context4.n = 47;
+            _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 47:
+        case 49:
           // Fall back to the main file with proper validation
           finalFileSource = finalInitial.source || '';
           finalFilename = finalInitial.fileName;
-        case 48:
+        case 50:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Initial File',
+            measure: 'Initial File Loading'
+          }, [functionName, url]);
           return _context4.a(2, {
             code: loaded,
             initialFilename: finalFilename,
@@ -677,7 +751,7 @@ function _loadCodeFallback() {
             processedGlobalsCode: globalsCodeObjects
           });
       }
-    }, _callee4, null, [[44, 46], [37, 39], [25, 27], [21, 23], [17, 32], [10, 12], [6, 8], [1, 3]]);
+    }, _callee4, null, [[46, 48], [38, 40], [26, 28], [22, 24], [18, 33], [11, 13], [7, 9], [1, 3]]);
   }));
   return _loadCodeFallback.apply(this, arguments);
 }

package/esm/pipeline/loadCodeVariant/loadCodeVariant.js

@@ -12,6 +12,7 @@ import { transformSource } from "./transformSource.js";
 import { diffHast } from "./diffHast.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
 import { mergeExternals } from "../loaderUtils/mergeExternals.js";
+import { performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.js";
 function compressAsync(input) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   return new Promise(function (resolve, reject) {
@@ -138,6 +139,8 @@ function _loadSingleFile() {
       extraFilesFromSource,
       extraDependenciesFromSource,
       externalsFromSource,
+      functionName,
+      currentMark,
       loadPromise,
       loadResult,
       _i,
@@ -170,6 +173,11 @@ function _loadSingleFile() {
           knownExtraFiles = _args.length > 11 && _args[11] !== undefined ? _args[11] : new Set();
           _options$disableTrans = options.disableTransforms, disableTransforms = _options$disableTrans === void 0 ? false : _options$disableTrans, _options$disableParsi = options.disableParsing, disableParsing = _options$disableParsi === void 0 ? false : _options$disableParsi;
           finalSource = source;
+          functionName = 'Load Variant File';
+          currentMark = performanceMeasure(undefined, {
+            mark: 'Start',
+            measure: 'Start'
+          }, [functionName, url || fileName], true); // Load source if not provided
           if (finalSource) {
             _context.n = 20;
             break;
@@ -201,6 +209,10 @@ function _loadSingleFile() {
           extraFilesFromSource = loadResult.extraFiles;
           extraDependenciesFromSource = loadResult.extraDependencies;
           externalsFromSource = loadResult.externals;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded File',
+            measure: 'File Loading'
+          }, [functionName, url]);
 
           // Validate that extraFiles from loadSource contain only absolute URLs as values
           if (!extraFilesFromSource) {
@@ -321,6 +333,10 @@ function _loadSingleFile() {
           return transformSource(finalSource, normalizePathKey(fileName), sourceTransformers);
         case 21:
           finalTransforms = _context.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Transformed File',
+            measure: 'File Transforming'
+          }, [functionName, url || fileName]);
         case 22:
           if (!(typeof finalSource === 'string' && !disableParsing)) {
             _context.n = 31;
@@ -339,6 +355,10 @@ function _loadSingleFile() {
         case 24:
           parseSource = _context.v;
           finalSource = parseSource(finalSource, fileName);
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed File',
+            measure: 'File Parsing'
+          }, [functionName, url || fileName]);
           if (!(finalTransforms && !disableTransforms)) {
             _context.n = 26;
             break;
@@ -347,6 +367,10 @@ function _loadSingleFile() {
           return diffHast(sourceString, finalSource, normalizePathKey(fileName), finalTransforms, parseSource);
         case 25:
           finalTransforms = _context.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Transform Parsed File',
+            measure: 'Parsed File Transforming'
+          }, [functionName, url || fileName]);
         case 26:
           if (!(options.output === 'hastGzip' && process.env.NODE_ENV === 'production')) {
             _context.n = 28;
@@ -363,6 +387,10 @@ function _loadSingleFile() {
           finalSource = {
             hastGzip: hastGzip
           };
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Compressed File',
+            measure: 'File Compression'
+          }, [functionName, url || fileName]);
           _context.n = 29;
           break;
         case 28:
@@ -371,6 +399,10 @@ function _loadSingleFile() {
             finalSource = {
               hastJson: JSON.stringify(finalSource)
             };
+            performanceMeasure(currentMark, {
+              mark: 'JSON Stringified File',
+              measure: 'File Stringification'
+            }, [functionName, url || fileName]);
           }
         case 29:
           _context.n = 31;
@@ -668,6 +700,8 @@ function _loadCodeVariant() {
       sourceTransformers,
       globalsCode,
       loadSourceCache,
+      functionName,
+      currentMark,
       _getFileNameFromUrl,
       _fileName,
       loadedFiles,
@@ -680,11 +714,11 @@ function _loadCodeVariant() {
       fileName,
       _finalVariant,
       mainFileResult,
-      allExtraFiles,
       _i5,
       _Object$keys3,
       _extraFileName,
       extraFilesToLoad,
+      externalsMergedMark,
       globalsFileKeys,
       existingFiles,
       _i6,
@@ -701,6 +735,7 @@ function _loadCodeVariant() {
       _key,
       value,
       conflictFreeKey,
+      allExtraFiles,
       loadableFiles,
       _i8,
       _Object$entries4,
@@ -736,8 +771,13 @@ function _loadCodeVariant() {
         case 1:
           sourceParser = options.sourceParser, loadSource = options.loadSource, loadVariantMeta = options.loadVariantMeta, sourceTransformers = options.sourceTransformers, globalsCode = options.globalsCode; // Create a cache for loadSource calls scoped to this loadCodeVariant call
           loadSourceCache = new Map();
+          functionName = 'Load Variant';
+          currentMark = performanceMeasure(undefined, {
+            mark: 'Start',
+            measure: 'Start'
+          }, [functionName, url || variantName], true);
           if (!(typeof variant === 'string')) {
-            _context6.n = 6;
+            _context6.n = 7;
             break;
           }
           if (loadVariantMeta) {
@@ -756,7 +796,7 @@ function _loadCodeVariant() {
             url: variant,
             fileName: _fileName
           };
-          _context6.n = 6;
+          _context6.n = 7;
           break;
         case 3:
           _context6.p = 3;
@@ -771,6 +811,11 @@ function _loadCodeVariant() {
           _t9 = _context6.v;
           throw new Error("Failed to load variant code (variant: ".concat(variantName, ", url: ").concat(variant, "): ").concat(JSON.stringify(_t9)));
         case 6:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Variant Meta',
+            measure: 'Variant Meta Loading'
+          }, [functionName, url || variantName]);
+        case 7:
           loadedFiles = new Set();
           if (url) {
             loadedFiles.add(url);
@@ -789,7 +834,7 @@ function _loadCodeVariant() {
           // Load main file
           fileName = variant.fileName || (url ? getFileNameFromUrl(url).fileName : undefined); // If we don't have a fileName and no URL, we can't parse or transform but can still return the code
           if (!(!fileName && !url)) {
-            _context6.n = 7;
+            _context6.n = 8;
             break;
           }
           // Return the variant as-is without parsing or transforms
@@ -808,56 +853,66 @@ function _loadCodeVariant() {
             // No dependencies without URL
             externals: {} // No externals without URL
           });
-        case 7:
+        case 8:
           if (fileName) {
-            _context6.n = 8;
+            _context6.n = 9;
             break;
           }
           throw new Error("No fileName available for variant \"".concat(variantName, "\". ") + "Please provide a fileName in the variant definition or ensure the URL has a valid file extension.");
-        case 8:
-          _context6.n = 9;
+        case 9:
+          _context6.n = 10;
           return loadSingleFile(variantName, fileName, variant.source, url, loadSource, sourceParser, sourceTransformers, loadSourceCache, variant.transforms, _extends(_extends({}, options), {}, {
             loadedFiles: loadedFiles
           }), variant.allFilesListed || false, knownExtraFiles);
-        case 9:
+        case 10:
           mainFileResult = _context6.v;
           // Add files used from main file loading
           if (mainFileResult.extraDependencies) {
             allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(mainFileResult.extraDependencies));
           }
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Loaded Main File',
+            measure: 'Main File Loading'
+          }, [functionName, url || fileName], true);
 
-          // Add externals from main file loading
-          if (mainFileResult.externals) {
-            allExternals = mergeExternals([allExternals, mainFileResult.externals]);
-          }
-          allExtraFiles = {}; // Validate extraFiles keys from variant definition
+          // Validate extraFiles keys from variant definition
           if (!variant.extraFiles) {
-            _context6.n = 12;
+            _context6.n = 13;
             break;
           }
           _i5 = 0, _Object$keys3 = Object.keys(variant.extraFiles);
-        case 10:
+        case 11:
           if (!(_i5 < _Object$keys3.length)) {
-            _context6.n = 12;
+            _context6.n = 13;
             break;
           }
           _extraFileName = _Object$keys3[_i5];
           if (!isAbsolutePath(_extraFileName)) {
-            _context6.n = 11;
+            _context6.n = 12;
             break;
           }
           throw new Error("Invalid extraFiles key in variant: \"".concat(_extraFileName, "\" appears to be an absolute path. ") + "extraFiles keys in variant definition should be relative paths from the main file.");
-        case 11:
+        case 12:
           _i5++;
-          _context6.n = 10;
+          _context6.n = 11;
           break;
-        case 12:
+        case 13:
           // Collect extra files from variant definition and from loaded source
-          extraFilesToLoad = _extends(_extends({}, variant.extraFiles || {}), mainFileResult.extraFiles || {}); // Track which files come from globals for metadata marking
+          extraFilesToLoad = _extends(_extends({}, variant.extraFiles || {}), mainFileResult.extraFiles || {}); // Add externals from main file loading
+          if (mainFileResult.externals) {
+            allExternals = mergeExternals([allExternals, mainFileResult.externals]);
+          }
+          externalsMergedMark = performanceMeasure(currentMark, {
+            mark: 'Externals Merged',
+            measure: 'Merging Externals'
+          }, [functionName, url || fileName]);
+          currentMark = externalsMergedMark;
+
+          // Track which files come from globals for metadata marking
           globalsFileKeys = new Set(); // Track globals file keys for loadExtraFiles
           // Process globalsCode array and add to extraFiles if provided
           if (!(globalsCode && globalsCode.length > 0)) {
-            _context6.n = 14;
+            _context6.n = 15;
             break;
           }
           // Collect existing filenames to avoid conflicts
@@ -907,6 +962,10 @@ function _loadCodeVariant() {
                     return loadVariantMeta(variantName, globalsItem);
                   case 3:
                     globalsVariant = _context5.v;
+                    currentMark = performanceMeasure(currentMark, {
+                      mark: 'Globals Variant Meta Loaded',
+                      measure: 'Globals Variant Meta Loading'
+                    }, [functionName, globalsItem, url || fileName]);
                     _context5.n = 5;
                     break;
                   case 4:
@@ -927,6 +986,10 @@ function _loadCodeVariant() {
                     );
                   case 8:
                     globalsResult = _context5.v;
+                    currentMark = performanceMeasure(currentMark, {
+                      mark: 'Globals Variant Loaded',
+                      measure: 'Globals Variant Loading'
+                    }, [functionName, globalsVariant.url || variantName, url || fileName]);
                     return _context5.a(2, globalsResult);
                   case 9:
                     _context5.p = 9;
@@ -941,9 +1004,9 @@ function _loadCodeVariant() {
               return _ref4.apply(this, arguments);
             };
           }()); // Wait for all globals to load
-          _context6.n = 13;
+          _context6.n = 14;
           return Promise.all(globalsPromises);
-        case 13:
+        case 14:
           globalsResults = _context6.v;
           // Merge results from all globals
           _iterator4 = _createForOfIteratorHelper(globalsResults);
@@ -981,13 +1044,18 @@ function _loadCodeVariant() {
           } finally {
             _iterator4.f();
           }
-        case 14:
+        case 15:
+          currentMark = performanceMeasure(externalsMergedMark, {
+            mark: 'Globals Loaded',
+            measure: 'Globals Loading'
+          }, [functionName, url || fileName], true);
+          allExtraFiles = {}; // Load all extra files if any exist and we have a URL
           if (!(Object.keys(extraFilesToLoad).length > 0)) {
-            _context6.n = 19;
+            _context6.n = 21;
             break;
           }
           if (url) {
-            _context6.n = 17;
+            _context6.n = 18;
             break;
           }
           // If there's no URL, we can only load extra files that have inline source or absolute URLs
@@ -1005,7 +1073,7 @@ function _loadCodeVariant() {
             }
           }
           if (!(Object.keys(loadableFiles).length > 0)) {
-            _context6.n = 16;
+            _context6.n = 17;
             break;
           }
           // Process loadable files: inline sources without URL-based loading, absolute URLs with loading
@@ -1032,10 +1100,10 @@ function _loadCodeVariant() {
             }
           }
           if (!(Object.keys(urlFilesToLoad).length > 0)) {
-            _context6.n = 16;
+            _context6.n = 17;
             break;
           }
-          _context6.n = 15;
+          _context6.n = 16;
           return loadExtraFiles(variantName, urlFilesToLoad, '',
           // No base URL needed for absolute URLs
           '',
@@ -1044,28 +1112,33 @@ function _loadCodeVariant() {
             loadedFiles: loadedFiles
           }), variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
           );
-        case 15:
+        case 16:
           extraFilesResult = _context6.v;
           allExtraFiles = _extends(_extends({}, allExtraFiles), extraFilesResult.extraFiles);
           allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(extraFilesResult.allFilesUsed));
           allExternals = mergeExternals([allExternals, extraFilesResult.allExternals]);
-        case 16:
-          _context6.n = 19;
-          break;
         case 17:
-          _context6.n = 18;
+          _context6.n = 20;
+          break;
+        case 18:
+          _context6.n = 19;
           return loadExtraFiles(variantName, extraFilesToLoad, url, url,
           // Entry URL is the same as the main file URL
           loadSource, sourceParser, sourceTransformers, loadSourceCache, _extends(_extends({}, options), {}, {
             loadedFiles: loadedFiles
           }), variant.allFilesListed || false, knownExtraFiles, globalsFileKeys // Pass globals file tracking
           );
-        case 18:
+        case 19:
           _extraFilesResult = _context6.v;
           allExtraFiles = _extraFilesResult.extraFiles;
           allFilesUsed.push.apply(allFilesUsed, _toConsumableArray(_extraFilesResult.allFilesUsed));
           allExternals = mergeExternals([allExternals, _extraFilesResult.allExternals]);
-        case 19:
+        case 20:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Extra Files Loaded',
+            measure: 'Extra Files Loading'
+          }, [functionName, url || fileName], true);
+        case 21:
           // Note: metadata marking is now handled during loadExtraFiles processing
           finalVariant = _extends(_extends({}, variant), {}, {
             source: mainFileResult.source,

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.d.ts

@@ -1,5 +1,10 @@
 import type { LoaderContext } from 'webpack';
 export type LoaderOptions = {
+  performance?: {
+    logging?: boolean;
+    notableMs?: number;
+    showWrapperMeasures?: boolean;
+  };
   output?: 'hast' | 'hastJson' | 'hastGzip';
 };
 /**

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -2,6 +2,9 @@ import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIt
 import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+// webpack does not like node: imports
+// eslint-disable-next-line n/prefer-node-protocol
+import path from 'path';
 import { loadCodeVariant } from "../loadCodeVariant/loadCodeVariant.js";
 import { createParseSource } from "../parseSource/index.js";
 // TODO: re-enable following benchmarking
@@ -12,6 +15,9 @@ import { resolveVariantPathsWithFs } from "../loadServerCodeMeta/resolveModulePa
 import { replacePrecomputeValue } from "./replacePrecomputeValue.js";
 import { createLoadServerSource } from "../loadServerSource/index.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
+import { createPerformanceLogger, logPerformance, performanceMeasure } from "./performanceLogger.js";
+var functionName = 'Load Precomputed Code Highlighter';
+
 /**
  * Webpack loader that processes demo files and precomputes variant data.
  *
@@ -28,18 +34,44 @@ export function loadPrecomputedCodeHighlighter(_x) {
 }
 function _loadPrecomputedCodeHighlighter() {
   _loadPrecomputedCodeHighlighter = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
-    var _this = this;
-    var callback, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, variantPromises, variantResults, _iterator, _step, result, modifiedSource, _t2;
+    var _options$performance$,
+      _options$performance,
+      _options$performance$2,
+      _options$performance2,
+      _options$performance3,
+      _this = this;
+    var callback, options, performanceNotableMs, performanceShowWrapperMeasures, relativePath, observer, currentMark, _observer, _observer2, demoCall, variantData, allDependencies, resolvedVariantMap, loadSource, sourceTransformers, sourceParser, functionsInitMark, variantPromises, variantResults, _iterator, _step, result, modifiedSource, _observer3, _observer4, _t2;
     return _regenerator().w(function (_context2) {
       while (1) switch (_context2.p = _context2.n) {
         case 0:
           callback = this.async();
           this.cacheable();
+          options = this.getOptions();
+          performanceNotableMs = (_options$performance$ = (_options$performance = options.performance) == null ? void 0 : _options$performance.notableMs) != null ? _options$performance$ : 100;
+          performanceShowWrapperMeasures = (_options$performance$2 = (_options$performance2 = options.performance) == null ? void 0 : _options$performance2.showWrapperMeasures) != null ? _options$performance$2 : false;
+          relativePath = path.relative(this.rootContext || process.cwd(), this.resourcePath);
+          observer = undefined;
+          if ((_options$performance3 = options.performance) != null && _options$performance3.logging) {
+            observer = new PerformanceObserver(createPerformanceLogger(performanceNotableMs, performanceShowWrapperMeasures, relativePath));
+            observer.observe({
+              entryTypes: ['measure']
+            });
+          }
+          currentMark = performanceMeasure(undefined, {
+            mark: 'Start',
+            measure: 'Start'
+          }, [functionName, relativePath], true);
           _context2.p = 1;
           _context2.n = 2;
           return parseCreateFactoryCall(source, this.resourcePath);
         case 2:
           demoCall = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed Factory',
+            measure: 'Factory Parsing'
+          }, [functionName, relativePath]);
+
+          // If no createDemo call found, return the source unchanged
           if (demoCall) {
             _context2.n = 3;
             break;
@@ -61,6 +93,11 @@ function _loadPrecomputedCodeHighlighter() {
           return resolveVariantPathsWithFs(demoCall.variants || {});
         case 5:
           resolvedVariantMap = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Paths Resolved',
+            measure: 'Path Resolution'
+          }, [functionName, relativePath]);
+
           // Create loader functions
           loadSource = createLoadServerSource({
             includeDependencies: true,
@@ -69,15 +106,26 @@ function _loadPrecomputedCodeHighlighter() {
           // const sourceTransformers: SourceTransformers = [TypescriptToJavascriptTransformer];
           // TODO: maybe we should have `loadPrecomputedCodeHighlighterWithJsToTs`
           sourceTransformers = []; // Create sourceParser promise for syntax highlighting
-          sourceParser = createParseSource(); // Process variants in parallel
+          sourceParser = createParseSource();
+          functionsInitMark = performanceMeasure(currentMark, {
+            mark: 'Functions Init',
+            measure: 'Functions Init'
+          }, [functionName, relativePath]);
+          currentMark = functionsInitMark;
+
+          // Process variants in parallel
           variantPromises = Array.from(resolvedVariantMap.entries()).map(/*#__PURE__*/function () {
             var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
               var _demoCall$namedExport;
-              var _ref3, variantName, fileUrl, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, processedVariant, dependencies, _t;
+              var _ref3, variantName, fileUrl, variantMark, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, processedVariant, dependencies, _t;
               return _regenerator().w(function (_context) {
                 while (1) switch (_context.p = _context.n) {
                   case 0:
                     _ref3 = _slicedToArray(_ref, 2), variantName = _ref3[0], fileUrl = _ref3[1];
+                    variantMark = performanceMeasure(functionsInitMark, {
+                      mark: 'Variant Started',
+                      measure: 'Variant Start'
+                    }, [functionName, variantName, relativePath], true);
                     namedExport = (_demoCall$namedExport = demoCall.namedExports) == null ? void 0 : _demoCall$namedExport[variantName];
                     variant = fileUrl;
                     if (!namedExport) {
@@ -116,6 +164,10 @@ function _loadPrecomputedCodeHighlighter() {
                     _yield$loadCodeVarian = _context.v;
                     processedVariant = _yield$loadCodeVarian.code;
                     dependencies = _yield$loadCodeVarian.dependencies;
+                    performanceMeasure(variantMark, {
+                      mark: 'Variant Loaded',
+                      measure: 'Variant Loading'
+                    }, [functionName, variantName, relativePath], true);
                     return _context.a(2, {
                       variantName: variantName,
                       variantData: processedVariant,
@@ -151,24 +203,45 @@ function _loadPrecomputedCodeHighlighter() {
                 });
               }
             }
-
-            // Replace the factory function call with the actual precomputed data
           } catch (err) {
             _iterator.e(err);
           } finally {
             _iterator.f();
           }
-          modifiedSource = replacePrecomputeValue(source, variantData, demoCall); // Add all dependencies to webpack's watch list
+          currentMark = performanceMeasure(functionsInitMark, {
+            mark: 'All Variants Loaded',
+            measure: 'Complete Variants Loading'
+          }, [functionName, relativePath], true);
+
+          // Replace the factory function call with the actual precomputed data
+          modifiedSource = replacePrecomputeValue(source, variantData, demoCall);
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Replaced Precompute',
+            measure: 'Precompute Replacement'
+          }, [functionName, relativePath]);
+
+          // Add all dependencies to webpack's watch list
           allDependencies.forEach(function (dep) {
             // Strip 'file://' prefix if present before adding to webpack's dependency tracking
             _this.addDependency(dep.startsWith('file://') ? dep.slice(7) : dep);
           });
+
+          // log any pending performance entries before completing
+          (_observer = observer) == null || (_observer = _observer.takeRecords()) == null || _observer.forEach(function (entry) {
+            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
+          });
+          (_observer2 = observer) == null || _observer2.disconnect();
           callback(null, modifiedSource);
           _context2.n = 8;
           break;
         case 7:
           _context2.p = 7;
           _t2 = _context2.v;
+          // log any pending performance entries before completing
+          (_observer3 = observer) == null || (_observer3 = _observer3.takeRecords()) == null || _observer3.forEach(function (entry) {
+            return logPerformance(entry, performanceNotableMs, performanceShowWrapperMeasures, relativePath);
+          });
+          (_observer4 = observer) == null || _observer4.disconnect();
           callback(_t2 instanceof Error ? _t2 : new Error(String(_t2)));
         case 8:
           return _context2.a(2);

package/esm/pipeline/loadPrecomputedCodeHighlighter/performanceLogger.d.ts

@@ -0,0 +1,30 @@
+export declare function logPerformance(entry: PerformanceEntry, notableMs: number, showWrapperMeasures: boolean, filterContext?: string): void;
+export declare function createPerformanceLogger(notableMs: number, showWrapperMeasures: boolean, filterContext?: string): PerformanceObserverCallback;
+export declare function nameMark(functionName: string, event: string, context: string[], wrapper?: boolean): string;
+/**
+ * Helper to create a performance mark and measure in one call.
+ *
+ * @param startMark - Optional start mark name for the measure (typically currentMark)
+ * @param names - Object with mark and measure names
+ * @param context - Array of context strings [functionName, ...context]
+ * @param wrapper - Whether this is a wrapper measure (uses pipe delimiter)
+ * @returns The mark name that was created
+ *
+ * @example
+ * ```ts
+ * currentMark = performanceMeasure(
+ *   currentMark,
+ *   { mark: 'processed', measure: 'processing' },
+ *   [functionName, relativePath],
+ *   true,
+ * );
+ * ```
+ */
+export declare function performanceMeasure(startMark: string | undefined, names: {
+  mark: string;
+  measure: string;
+} | {
+  prefix?: string;
+  mark: string;
+  measure: string;
+}, context: string[], wrapper?: boolean): string;

package/esm/pipeline/loadPrecomputedCodeHighlighter/performanceLogger.js

@@ -0,0 +1,77 @@
+import _arrayLikeToArray from "@babel/runtime/helpers/esm/arrayLikeToArray";
+import _toArray from "@babel/runtime/helpers/esm/toArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+export function logPerformance(entry, notableMs, showWrapperMeasures, filterContext) {
+  if (entry.duration < notableMs) {
+    return;
+  }
+
+  // If filterContext is provided, only log entries that include it
+  if (filterContext && !entry.name.includes(filterContext)) {
+    return;
+  }
+  var delim = '-';
+  var message = entry.name;
+  if (message.startsWith('| ')) {
+    if (!showWrapperMeasures) {
+      return;
+    }
+    delim = '|';
+    message = message.slice(2);
+  }
+  var duration = Math.round(entry.duration).toString().padStart(4, ' ');
+  console.warn("".concat(duration, "ms ").concat(delim, " ").concat(message));
+}
+export function createPerformanceLogger(notableMs, showWrapperMeasures, filterContext) {
+  var performanceLogger = function performanceLogger(list) {
+    var _iterator = _createForOfIteratorHelper(list.getEntries()),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var entry = _step.value;
+        logPerformance(entry, notableMs, showWrapperMeasures, filterContext);
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  };
+  return performanceLogger;
+}
+export function nameMark(functionName, event, context) {
+  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  return "".concat(wrapper ? '| ' : '').concat(functionName, " ").concat(wrapper ? '|' : '-', " ").concat(event, " - ").concat(context.join(' - '));
+}
+
+/**
+ * Helper to create a performance mark and measure in one call.
+ *
+ * @param startMark - Optional start mark name for the measure (typically currentMark)
+ * @param names - Object with mark and measure names
+ * @param context - Array of context strings [functionName, ...context]
+ * @param wrapper - Whether this is a wrapper measure (uses pipe delimiter)
+ * @returns The mark name that was created
+ *
+ * @example
+ * ```ts
+ * currentMark = performanceMeasure(
+ *   currentMark,
+ *   { mark: 'processed', measure: 'processing' },
+ *   [functionName, relativePath],
+ *   true,
+ * );
+ * ```
+ */
+export function performanceMeasure(startMark, names, context) {
+  var wrapper = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  var _context = _toArray(context),
+    functionName = _context[0],
+    restContext = _arrayLikeToArray(_context).slice(1);
+  var prefix = 'prefix' in names && names.prefix ? "".concat(names.prefix, " ") : '';
+  var markName = nameMark(functionName, "".concat(prefix).concat(names.mark), restContext, wrapper);
+  var measureName = nameMark(functionName, "".concat(prefix).concat(names.measure), restContext, wrapper);
+  performance.mark(markName);
+  performance.measure(measureName, startMark, markName);
+  return markName;
+}

package/esm/withDocsInfra/withDocsInfra.d.ts

@@ -47,6 +47,14 @@ export interface WithDocsInfraOptions {
   additionalTurbopackRules?: Record<string, {
     loaders: string[];
   }>;
+  /**
+   * Performance logging options
+   */
+  performance?: {
+    logging: boolean;
+    notableMs?: number;
+    showWrapperMeasures?: boolean;
+  };
   /**
    * Defer AST parsing option for code highlighter output.
    * 'gzip' - Default, outputs gzipped HAST for best performance.

package/esm/withDocsInfra/withDocsInfra.js

@@ -40,6 +40,8 @@ export function withDocsInfra() {
     additionalDemoPatterns = _options$additionalDe === void 0 ? {} : _options$additionalDe,
     _options$additionalTu = options.additionalTurbopackRules,
     additionalTurbopackRules = _options$additionalTu === void 0 ? {} : _options$additionalTu,
+    _options$performance = options.performance,
+    performance = _options$performance === void 0 ? {} : _options$performance,
     _options$deferCodePar = options.deferCodeParsing,
     deferCodeParsing = _options$deferCodePar === void 0 ? 'gzip' : _options$deferCodePar;
   var output = 'hastGzip';
@@ -59,11 +61,17 @@ export function withDocsInfra() {
       loaders: [{
         loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighter',
         options: {
+          performance: performance,
           output: output
         }
       }]
     }), clientDemoPathPattern, {
-      loaders: ['@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient']
+      loaders: [{
+        loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient',
+        options: {
+          performance: performance
+        }
+      }]
     });
 
     // Add additional demo patterns to Turbopack rules
@@ -73,6 +81,7 @@ export function withDocsInfra() {
           loaders: [{
             loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighter',
             options: {
+              performance: performance,
               output: output
             }
           }]
@@ -82,7 +91,12 @@ export function withDocsInfra() {
     if (additionalDemoPatterns.client) {
       additionalDemoPatterns.client.forEach(function (pattern) {
         turbopackRules[pattern] = {
-          loaders: ['@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient']
+          loaders: [{
+            loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient',
+            options: {
+              performance: performance
+            }
+          }]
         };
       });
     }
@@ -118,6 +132,7 @@ export function withDocsInfra() {
           use: [defaultLoaders.babel, {
             loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighter',
             options: {
+              performance: performance,
               output: output
             }
           }]
@@ -126,7 +141,12 @@ export function withDocsInfra() {
         // Client files for live demos - processes externals
         webpackConfig.module.rules.push({
           test: new RegExp('/demos/[^/]+/client\\.ts$'),
-          use: [defaultLoaders.babel, '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient']
+          use: [defaultLoaders.babel, {
+            loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient',
+            options: {
+              performance: performance
+            }
+          }]
         });
 
         // Add webpack rules for additional demo patterns
@@ -144,6 +164,7 @@ export function withDocsInfra() {
               use: [defaultLoaders.babel, {
                 loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighter',
                 options: {
+                  performance: performance,
                   output: output
                 }
               }]
@@ -161,7 +182,12 @@ export function withDocsInfra() {
 
             webpackConfig.module.rules.push({
               test: new RegExp("".concat(regexPattern, "$")),
-              use: [defaultLoaders.babel, '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient']
+              use: [defaultLoaders.babel, {
+                loader: '@mui/internal-docs-infra/pipeline/loadPrecomputedCodeHighlighterClient',
+                options: {
+                  performance: performance
+                }
+              }]
             });
           });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mui/internal-docs-infra",
-  "version": "0.2.3-canary.13",
+  "version": "0.2.3-canary.14",
   "author": "MUI Team",
   "description": "MUI Infra - internal documentation creation tools.",
   "keywords": [
@@ -235,5 +235,5 @@
     },
     "./esm": null
   },
-  "gitSha": "8b1850f1e23152917fcc1e97d123805cd99d6a31"
+  "gitSha": "8e64ec558ea98ce0a577b4b11cd8ffd78de4f0a3"
 }