@mui/internal-docs-infra 0.2.3-canary.8 → 0.3.1-canary.0

package/esm/pipeline/loadPrecomputedCodeHighlighter/loadPrecomputedCodeHighlighter.js

@@ -2,16 +2,22 @@ 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";
-import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
+// 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
 // import { TypescriptToJavascriptTransformer } from '../transformTypescriptToJavascript';
 
 import { parseCreateFactoryCall } from "./parseCreateFactoryCall.js";
-import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { resolveVariantPathsWithFs } from "../loadServerCodeMeta/resolveModulePathWithFs.js";
 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$loadVariant, 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) {
@@ -99,7 +147,7 @@ function _loadPrecomputedCodeHighlighter() {
                   case 2:
                     _context.p = 2;
                     _context.n = 3;
-                    return loadVariant(fileUrl,
+                    return loadCodeVariant(fileUrl,
                     // URL for the variant entry point (already includes file://)
                     variantName, variant, {
                       sourceParser: sourceParser,
@@ -113,9 +161,13 @@ function _loadPrecomputedCodeHighlighter() {
                       output: _this.getOptions().output || 'hastGzip'
                     });
                   case 3:
-                    _yield$loadVariant = _context.v;
-                    processedVariant = _yield$loadVariant.code;
-                    dependencies = _yield$loadVariant.dependencies;
+                    _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/pipeline/loadPrecomputedCodeHighlighterClient/loadPrecomputedCodeHighlighterClient.js

@@ -7,9 +7,9 @@ import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { readFile } from 'fs/promises';
 import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
 import { generateResolvedExternals } from "./generateResolvedExternals.js";
-import { loadVariant } from "../../CodeHighlighter/loadVariant.js";
+import { loadCodeVariant } from "../loadCodeVariant/loadCodeVariant.js";
 import { createLoadServerSource } from "../loadServerSource/index.js";
-import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { resolveVariantPathsWithFs } from "../loadServerCodeMeta/resolveModulePathWithFs.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
 import { mergeExternals } from "../loaderUtils/mergeExternals.js";
 import { filterRuntimeExternals } from "./filterRuntimeExternals.js";
@@ -116,7 +116,7 @@ function _loadPrecomputedCodeHighlighterClient() {
           variantPromises = Array.from(resolvedVariantMap.entries()).map(/*#__PURE__*/function () {
             var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
               var _indexDemoCall$namedE;
-              var _ref3, variantName, fileUrl, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadVariant, dependencies, externals, _t;
+              var _ref3, variantName, fileUrl, namedExport, variant, _getFileNameFromUrl, fileName, _yield$loadCodeVarian, dependencies, externals, _t;
               return _regenerator().w(function (_context) {
                 while (1) switch (_context.p = _context.n) {
                   case 0:
@@ -142,7 +142,7 @@ function _loadPrecomputedCodeHighlighterClient() {
                   case 2:
                     _context.p = 2;
                     _context.n = 3;
-                    return loadVariant(fileUrl,
+                    return loadCodeVariant(fileUrl,
                     // URL for the variant entry point (already includes file://)
                     variantName, variant, {
                       loadSource: loadSource,
@@ -152,9 +152,9 @@ function _loadPrecomputedCodeHighlighterClient() {
                       disableTransforms: true
                     });
                   case 3:
-                    _yield$loadVariant = _context.v;
-                    dependencies = _yield$loadVariant.dependencies;
-                    externals = _yield$loadVariant.externals;
+                    _yield$loadCodeVarian = _context.v;
+                    dependencies = _yield$loadCodeVarian.dependencies;
+                    externals = _yield$loadCodeVarian.externals;
                     return _context.a(2, {
                       variantName: variantName,
                       dependencies: dependencies,

package/esm/pipeline/loadPrecomputedSitemap/index.d.ts

@@ -0,0 +1,2 @@
+import { loadPrecomputedSitemap } from "./loadPrecomputedSitemap.js";
+export default loadPrecomputedSitemap;

package/esm/pipeline/loadPrecomputedSitemap/index.js

@@ -0,0 +1,4 @@
+// This is export format a Webpack / Turbopack loader expects
+
+import { loadPrecomputedSitemap } from "./loadPrecomputedSitemap.js";
+export default loadPrecomputedSitemap;

package/esm/pipeline/loadPrecomputedSitemap/loadPrecomputedSitemap.d.ts

@@ -0,0 +1,10 @@
+import type { LoaderContext } from 'webpack';
+export type LoaderOptions = {
+  performance?: {
+    logging?: boolean;
+    notableMs?: number;
+    showWrapperMeasures?: boolean;
+    significantDependencyCountThreshold?: number;
+  };
+};
+export declare function loadPrecomputedSitemap(this: LoaderContext<LoaderOptions>, source: string): Promise<void>;

package/esm/pipeline/loadPrecomputedSitemap/loadPrecomputedSitemap.js

@@ -0,0 +1,213 @@
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+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 { createPerformanceLogger, logPerformance, nameMark, performanceMeasure } from "../loadPrecomputedCodeHighlighter/performanceLogger.js";
+import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
+import { replacePrecomputeValue } from "../loadPrecomputedCodeHighlighter/replacePrecomputeValue.js";
+import { rewriteImportsToNull } from "../loaderUtils/rewriteImports.js";
+import { createLoadServerPageIndex } from "../loadServerPageIndex/loadServerPageIndex.js";
+import { createSitemapSchema } from "../loadServerSitemap/loadServerSitemap.js";
+var functionName = 'Load Precomputed Sitemap';
+export function loadPrecomputedSitemap(_x) {
+  return _loadPrecomputedSitemap.apply(this, arguments);
+}
+function _loadPrecomputedSitemap() {
+  _loadPrecomputedSitemap = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee2(source) {
+    var _options$performance$, _options$performance, _options$performance$2, _options$performance2, _options$performance3;
+    var callback, options, performanceNotableMs, performanceShowWrapperMeasures, relativePath, observer, currentMark, _observer, _observer2, sitemapCall, variants, sitemapData, rootContext, loadPageIndex, entries, results, _iterator, _step, result, precomputeData, modifiedSource, relative, importPathsToRewrite, importResult, _i, _Object$entries, _Object$entries$_i, importPath, importData, _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; // const resourceName = extractNameAndSlugFromUrl(
+          //   new URL('.', `file://${this.resourcePath}`).pathname,
+          // ).name;
+          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 = nameMark(functionName, 'Start Loading', [relativePath]);
+          performance.mark(currentMark);
+          _context2.p = 1;
+          _context2.n = 2;
+          return parseCreateFactoryCall(source, this.resourcePath);
+        case 2:
+          sitemapCall = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Parsed Factory',
+            measure: 'Factory Parsing'
+          }, [functionName, relativePath]);
+
+          // If no createSitemap call found, return the source unchanged
+          if (sitemapCall) {
+            _context2.n = 3;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 3:
+          if (!sitemapCall.options.skipPrecompute) {
+            _context2.n = 4;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 4:
+          // Extract the variants (imported markdown files)
+          variants = sitemapCall.variants;
+          if (!(!variants || Object.keys(variants).length === 0)) {
+            _context2.n = 5;
+            break;
+          }
+          callback(null, source);
+          return _context2.a(2);
+        case 5:
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Extracted Variants',
+            measure: 'Variant Extraction'
+          }, [functionName, relativePath]);
+
+          // Read and parse each markdown file
+          sitemapData = {}; // Create page index loader with root context
+          rootContext = this.rootContext || process.cwd();
+          loadPageIndex = createLoadServerPageIndex({
+            rootContext: rootContext
+          }); // Process all markdown files in parallel using shared logic
+          entries = Object.entries(variants);
+          _context2.n = 6;
+          return Promise.all(entries.map(/*#__PURE__*/function () {
+            var _ref2 = _asyncToGenerator(/*#__PURE__*/_regenerator().m(function _callee(_ref) {
+              var _ref3, key, importPath, absolutePath, metadata, _t;
+              return _regenerator().w(function (_context) {
+                while (1) switch (_context.p = _context.n) {
+                  case 0:
+                    _ref3 = _slicedToArray(_ref, 2), key = _ref3[0], importPath = _ref3[1];
+                    absolutePath = importPath.startsWith('file://') ? importPath.slice(7) : importPath;
+                    _context.p = 1;
+                    _context.n = 2;
+                    return loadPageIndex(importPath);
+                  case 2:
+                    metadata = _context.v;
+                    return _context.a(2, {
+                      key: key,
+                      absolutePath: absolutePath,
+                      metadata: metadata,
+                      error: null
+                    });
+                  case 3:
+                    _context.p = 3;
+                    _t = _context.v;
+                    return _context.a(2, {
+                      key: key,
+                      absolutePath: absolutePath,
+                      metadata: null,
+                      error: _t instanceof Error ? _t : new Error(String(_t))
+                    });
+                }
+              }, _callee, null, [[1, 3]]);
+            }));
+            return function (_x2) {
+              return _ref2.apply(this, arguments);
+            };
+          }()));
+        case 6:
+          results = _context2.v;
+          currentMark = performanceMeasure(currentMark, {
+            mark: 'Processed All Files',
+            measure: 'Process Markdown Files'
+          }, [functionName, relativePath]);
+
+          // Collect results and dependencies
+          _iterator = _createForOfIteratorHelper(results);
+          try {
+            for (_iterator.s(); !(_step = _iterator.n()).done;) {
+              result = _step.value;
+              if (result.error) {
+                // Log error but continue processing other files
+                console.error("Failed to process ".concat(result.key, " at ").concat(result.absolutePath, ":"), result.error);
+              } else if (result.metadata) {
+                sitemapData[result.key] = result.metadata;
+                // Add to dependencies for webpack watching
+                this.addDependency(result.absolutePath);
+              }
+            }
+
+            // Create sitemap with Orama schema for search indexing
+          } catch (err) {
+            _iterator.e(err);
+          } finally {
+            _iterator.f();
+          }
+          precomputeData = {
+            schema: createSitemapSchema(),
+            data: sitemapData
+          }; // Replace the factory function call with the precomputed sitemap data
+          modifiedSource = replacePrecomputeValue(source, precomputeData, sitemapCall);
+          performanceMeasure(currentMark, {
+            mark: 'replaced precompute',
+            measure: 'precompute replacement'
+          }, [functionName, relativePath]);
+
+          // Rewrite MDX imports to const declarations since we've precomputed the data
+          if (sitemapCall.importsAndComments) {
+            relative = sitemapCall.importsAndComments.relative; // Build a set of MDX imports to rewrite
+            importPathsToRewrite = new Set();
+            importResult = {};
+            for (_i = 0, _Object$entries = Object.entries(relative); _i < _Object$entries.length; _i++) {
+              _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), importPath = _Object$entries$_i[0], importData = _Object$entries$_i[1];
+              // Check if this is an MDX file
+              if (importPath.endsWith('.mdx')) {
+                // Add to the set of imports to rewrite
+                importPathsToRewrite.add(importPath);
+                importResult[importPath] = {
+                  positions: importData.positions,
+                  names: importData.names
+                };
+              }
+            }
+
+            // Rewrite the import statements to const declarations if there are any MDX imports
+            if (importPathsToRewrite.size > 0) {
+              modifiedSource = rewriteImportsToNull(modifiedSource, importPathsToRewrite, importResult);
+              currentMark = performanceMeasure(currentMark, {
+                mark: 'rewritten imports',
+                measure: 'import rewriting'
+              }, [functionName, relativePath]);
+            }
+          }
+
+          // 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);
+      }
+    }, _callee2, this, [[1, 7]]);
+  }));
+  return _loadPrecomputedSitemap.apply(this, arguments);
+}

package/esm/pipeline/loadServerCodeMeta/index.d.ts

@@ -1 +1,2 @@
-export * from "./loadServerCodeMeta.js";
+export * from "./loadServerCodeMeta.js";
+export * from "./resolveModulePathWithFs.js";

package/esm/pipeline/loadServerCodeMeta/index.js

@@ -1 +1,2 @@
-export * from "./loadServerCodeMeta.js";
+export * from "./loadServerCodeMeta.js";
+export * from "./resolveModulePathWithFs.js";

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.d.ts

@@ -16,7 +16,7 @@ export declare const loadServerCodeMeta: LoadCodeMeta;
  * 3. Returns a Code object mapping variant names to their resolved file URLs
  *
  * The actual loading, parsing, and transformation of the variants is handled
- * elsewhere by the CodeHighlighter component using loadVariant.
+ * elsewhere by the CodeHighlighter component using loadCodeVariant.
  *
  * @param options - Configuration options (currently unused)
  * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>

package/esm/pipeline/loadServerCodeMeta/loadServerCodeMeta.js

@@ -2,7 +2,7 @@ import _regenerator from "@babel/runtime/helpers/esm/regenerator";
 import _slicedToArray from "@babel/runtime/helpers/esm/slicedToArray";
 import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 import { readFile } from 'node:fs/promises';
-import { resolveVariantPathsWithFs } from "../loaderUtils/resolveModulePathWithFs.js";
+import { resolveVariantPathsWithFs } from "./resolveModulePathWithFs.js";
 import { parseCreateFactoryCall } from "../loadPrecomputedCodeHighlighter/parseCreateFactoryCall.js";
 import { getFileNameFromUrl } from "../loaderUtils/index.js";
 /**
@@ -22,7 +22,7 @@ export var loadServerCodeMeta = createLoadServerCodeMeta();
  * 3. Returns a Code object mapping variant names to their resolved file URLs
  *
  * The actual loading, parsing, and transformation of the variants is handled
- * elsewhere by the CodeHighlighter component using loadVariant.
+ * elsewhere by the CodeHighlighter component using loadCodeVariant.
  *
  * @param options - Configuration options (currently unused)
  * @returns LoadCodeMeta function that takes a URL and returns Promise<Code>

package/esm/pipeline/{loaderUtils → loadServerCodeMeta}/resolveModulePathWithFs.d.ts

@@ -1,4 +1,4 @@
-import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions, type TypeAwareResolveResult } from "./resolveModulePath.js";
+import { type DirectoryEntry, type DirectoryReader, type ResolveModulePathOptions, type TypeAwareResolveResult } from "../loaderUtils/resolveModulePath.js";
 /**
  * Resolves a module path using Node.js filesystem APIs.
  * This is a convenience wrapper around the generic resolveModulePath function.

package/esm/pipeline/{loaderUtils → loadServerCodeMeta}/resolveModulePathWithFs.js

@@ -3,7 +3,7 @@ import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
 // webpack does not like node: imports
 // eslint-disable-next-line n/prefer-node-protocol
 import { readdir } from 'fs/promises';
-import { resolveModulePath, resolveModulePaths, resolveImportResult, resolveVariantPaths } from "./resolveModulePath.js";
+import { resolveModulePath, resolveModulePaths, resolveImportResult, resolveVariantPaths } from "../loaderUtils/resolveModulePath.js";
 
 /**
  * Node.js filesystem-based directory reader that converts Dirent objects

package/esm/pipeline/loadServerPageIndex/index.d.ts

@@ -0,0 +1,2 @@
+export { loadServerPageIndex, createLoadServerPageIndex, extractPrefixAndTitle, pathSegmentToTitle, stripTitleMarkdown } from "./loadServerPageIndex.js";
+export type { CreateLoadServerPageIndexOptions, LoadServerPageIndex } from "./loadServerPageIndex.js";

package/esm/pipeline/loadServerPageIndex/index.js

@@ -0,0 +1 @@
+export { loadServerPageIndex, createLoadServerPageIndex, extractPrefixAndTitle, pathSegmentToTitle, stripTitleMarkdown } from "./loadServerPageIndex.js";