@mui/internal-docs-infra 0.11.1-canary.0 → 0.11.1-canary.2

package/CodeHighlighter/CodeHighlighter.mjs

@@ -1,10 +1,11 @@
 import * as React from 'react';
-import { loadCodeVariant } from "../pipeline/loadCodeVariant/loadCodeVariant.mjs";
-import { loadCodeFallback } from "../pipeline/loadCodeVariant/loadCodeFallback.mjs";
+import { loadIsomorphicCodeVariant } from "../pipeline/loadIsomorphicCodeVariant/loadIsomorphicCodeVariant.mjs";
+import { loadCodeFallback } from "../pipeline/loadIsomorphicCodeVariant/loadCodeFallback.mjs";
 import { CodeHighlighterClient } from "./CodeHighlighterClient.mjs";
-import { maybeCodeInitialData } from "../pipeline/loadCodeVariant/maybeCodeInitialData.mjs";
-import { hasAllVariants } from "../pipeline/loadCodeVariant/hasAllCodeVariants.mjs";
+import { maybeCodeInitialData } from "../pipeline/loadIsomorphicCodeVariant/maybeCodeInitialData.mjs";
+import { hasAllVariants } from "../pipeline/loadIsomorphicCodeVariant/hasAllCodeVariants.mjs";
 import { getFileNameFromUrl, getLanguageFromExtension } from "../pipeline/loaderUtils/index.mjs";
+import { replaceUrlPrefix } from "../pipeline/loaderUtils/applyUrlPrefix.mjs";
 import { codeToFallbackProps } from "./codeToFallbackProps.mjs";
 import * as Errors from "./errors.mjs";
 import { jsx as _jsx } from "react/jsx-runtime";
@@ -13,17 +14,25 @@ const DEBUG = false; // Set to true for debugging purposes
 function createClientProps(props) {
   const highlightAfter = props.highlightAfter === 'stream' ? 'init' : props.highlightAfter;
   const enhanceAfter = props.enhanceAfter === 'stream' ? 'init' : props.enhanceAfter;
+
+  // Rewrite the top-level URL before it leaves the server. The client never
+  // receives `urlPrefix` (and shouldn't deal with `file://` URLs), so any
+  // local URL must be translated to its hosted form here. Variant-level URLs
+  // inside `code`/`precompute` are already rewritten upstream (by
+  // `loadIsomorphicCodeVariant` on the server, or by the demo factory for precomputed
+  // input).
+  const url = props.urlPrefix && props.url ? replaceUrlPrefix(props.url, props.urlPrefix) : props.url;
   const contentProps = {
     code: props.code || props.precompute,
     components: props.components,
     name: props.name,
     slug: props.slug,
-    url: props.url,
+    url,
     variantType: props.variantType,
     ...props.contentProps
   };
   return {
-    url: props.url,
+    url,
     code: props.code,
     precompute: props.precompute,
     components: props.components,
@@ -115,14 +124,15 @@ async function CodeSourceLoader(props) {
     } else if (props.deferParsing === 'none') {
       output = 'hast';
     }
-    return loadCodeVariant(variantUrl, variantName, variantCode, {
+    return loadIsomorphicCodeVariant(variantUrl, variantName, variantCode, {
       sourceParser: props.sourceParser,
       loadSource: props.loadSource,
       loadVariantMeta: props.loadVariantMeta,
       sourceTransformers: props.sourceTransformers,
       sourceEnhancers: props.sourceEnhancers,
       globalsCode: resolvedGlobalsCode,
-      output
+      output,
+      urlPrefix: props.urlPrefix
     }).then(variant => ({
       name: variantName,
       variant
@@ -182,7 +192,6 @@ async function CodeHighlighterSuspense(props) {
 function renderWithInitialSource(props) {
   const ContentLoading = props.ContentLoading;
   const {
-    url,
     slug,
     name,
     initialVariant,
@@ -191,6 +200,11 @@ function renderWithInitialSource(props) {
     fallbackUsesExtraFiles,
     fallbackUsesAllVariants
   } = props;
+
+  // Rewrite the top-level URL before it reaches the loading fallback so the
+  // browser never sees `file://` URLs. See `createClientProps` for the same
+  // rewrite on the regular client path.
+  const url = props.urlPrefix && props.url ? replaceUrlPrefix(props.url, props.urlPrefix) : props.url;
   const fallbackProps = codeToFallbackProps(initialVariant, code, initialFilename, fallbackUsesExtraFiles, fallbackUsesAllVariants);
 
   // Get the component for the selected variant
@@ -272,7 +286,8 @@ async function CodeInitialSourceLoader(props) {
     initialFilename: fileName,
     variants,
     globalsCode,
-    output
+    output,
+    urlPrefix: props.urlPrefix
   });
   return renderWithInitialSource({
     ...props,

package/CodeHighlighter/CodeHighlighterClient.mjs

@@ -3,12 +3,12 @@
 import * as React from 'react';
 import { useCodeContext } from "../CodeProvider/CodeContext.mjs";
 import { CodeHighlighterContext } from "./CodeHighlighterContext.mjs";
-import { maybeCodeInitialData } from "../pipeline/loadCodeVariant/maybeCodeInitialData.mjs";
-import { hasAllVariants } from "../pipeline/loadCodeVariant/hasAllCodeVariants.mjs";
+import { maybeCodeInitialData } from "../pipeline/loadIsomorphicCodeVariant/maybeCodeInitialData.mjs";
+import { hasAllVariants } from "../pipeline/loadIsomorphicCodeVariant/hasAllCodeVariants.mjs";
 import { CodeHighlighterFallbackContext } from "./CodeHighlighterFallbackContext.mjs";
 import { useControlledCode } from "../CodeControllerContext/index.mjs";
 import { codeToFallbackProps } from "./codeToFallbackProps.mjs";
-import { mergeCodeMetadata } from "../pipeline/loadCodeVariant/mergeCodeMetadata.mjs";
+import { mergeCodeMetadata } from "../pipeline/loadIsomorphicCodeVariant/mergeCodeMetadata.mjs";
 import * as Errors from "./errors.mjs";
 import { jsx as _jsx } from "react/jsx-runtime";
 const DEBUG = false; // Set to true for debugging purposes
@@ -50,6 +50,11 @@ function useInitialData({
     }
   }
 
+  // Signal to downstream loaders that a fallback fetch is pending. Used to gate
+  // `useAllVariants` so it can reuse the data populated by the fallback rather
+  // than racing it and re-fetching the same variant.
+  const fallbackPending = Boolean(needsFallback && url && loadCodeFallback);
+
   // TODO: fallbackInitialRenderOnly option? this would mean we can't fetch fallback data on the client side
   // Load initial data if not provided
   React.useEffect(() => {
@@ -90,6 +95,9 @@ function useInitialData({
       }
     })();
   }, [initialData, reason, needsFallback, variantName, code, setCode, highlightAfter, url, sourceParser, loadSource, loadVariantMeta, loadCodeMeta, sourceEnhancers, fallbackUsesExtraFiles, fallbackUsesAllVariants, fileName, variants, globalsCode, setProcessedGlobalsCode, loadCodeFallback]);
+  return {
+    fallbackPending
+  };
 }
 function useAllVariants({
   readyForContent,
@@ -100,16 +108,17 @@ function useAllVariants({
   setCode,
   processedGlobalsCode,
   globalsCode,
-  setProcessedGlobalsCode
+  setProcessedGlobalsCode,
+  fallbackPending
 }) {
   const {
     loadCodeMeta,
     loadVariantMeta,
     loadSource,
-    loadCodeVariant,
+    loadIsomorphicCodeVariant,
     sourceEnhancers
   } = useCodeContext();
-  const needsData = !readyForContent && !isControlled;
+  const needsData = !readyForContent && !isControlled && !fallbackPending;
 
   // validation
   React.useMemo(() => {
@@ -117,7 +126,7 @@ function useAllVariants({
       if (!url) {
         throw new Errors.ErrorCodeHighlighterClientMissingUrlForVariants();
       }
-      if (!loadCodeVariant) {
+      if (!loadIsomorphicCodeVariant) {
         throw new Errors.ErrorCodeHighlighterClientMissingLoadVariant(url);
       }
       if (!code && !loadCodeMeta) {
@@ -143,9 +152,9 @@ function useAllVariants({
         throw new Errors.ErrorCodeHighlighterClientMissingLoadSourceForUnloadedUrls();
       }
     }
-  }, [code, globalsCode, loadCodeMeta, loadCodeVariant, loadSource, needsData, url]);
+  }, [code, globalsCode, loadCodeMeta, loadIsomorphicCodeVariant, loadSource, needsData, url]);
   React.useEffect(() => {
-    if (!needsData || !url || !loadCodeVariant) {
+    if (!needsData || !url || !loadIsomorphicCodeVariant) {
       return;
     }
 
@@ -190,7 +199,7 @@ function useAllVariants({
             // Only include if this variant exists in the globalsCode
             return codeObj[name];
           }).filter(item => Boolean(item));
-          return loadCodeVariant(url, name, loadedCode[name], {
+          return loadIsomorphicCodeVariant(url, name, loadedCode[name], {
             disableParsing: true,
             disableTransforms: true,
             loadSource,
@@ -222,7 +231,7 @@ function useAllVariants({
         console.error(new Errors.ErrorCodeHighlighterClientLoadAllVariantsFailure(url, error));
       }
     })();
-  }, [needsData, variants, url, code, setCode, loadSource, loadVariantMeta, loadCodeMeta, sourceEnhancers, processedGlobalsCode, globalsCode, setProcessedGlobalsCode, loadCodeVariant]);
+  }, [needsData, variants, url, code, setCode, loadSource, loadVariantMeta, loadCodeMeta, sourceEnhancers, processedGlobalsCode, globalsCode, setProcessedGlobalsCode, loadIsomorphicCodeVariant]);
   return {
     readyForContent
   };
@@ -246,6 +255,7 @@ function useCodeParsing({
   url
 }) {
   const {
+    sourceParser,
     parseSource,
     parseCode
   } = useCodeContext();
@@ -285,6 +295,12 @@ function useCodeParsing({
       return undefined;
     }
     if (!parseSource) {
+      // A CodeProvider is present and its async `sourceParser` promise hasn't
+      // resolved yet — wait for it instead of erroring. The memo will re-run
+      // once `parseSource` is populated.
+      if (sourceParser) {
+        return undefined;
+      }
       if (forceClient) {
         console.error(new Errors.ErrorCodeHighlighterClientMissingParseSource(url, true));
       } else {
@@ -301,7 +317,7 @@ function useCodeParsing({
       return undefined;
     }
     return parseCode(code, parseSource);
-  }, [code, shouldHighlight, parseSource, parseCode, forceClient, url]);
+  }, [code, shouldHighlight, sourceParser, parseSource, parseCode, forceClient, url]);
   const deferHighlight = !shouldHighlight;
   return {
     parsedCode,
@@ -404,7 +420,7 @@ function useGlobalsCodeMerging({
     loadCodeMeta,
     loadSource,
     loadVariantMeta,
-    loadCodeVariant
+    loadIsomorphicCodeVariant
   } = useCodeContext();
 
   // Set processedGlobalsCode if we have ready Code objects but haven't stored them yet
@@ -424,7 +440,7 @@ function useGlobalsCodeMerging({
       }
       // If not all ready, fall through to loading logic below
     }
-    if (!loadCodeVariant) {
+    if (!loadIsomorphicCodeVariant) {
       console.error(new Errors.ErrorCodeHighlighterClientMissingLoadVariantForGlobals());
       return;
     }
@@ -470,7 +486,7 @@ function useGlobalsCodeMerging({
 
             // Need to load this variant
             try {
-              const result = await loadCodeVariant(originalUrl || '',
+              const result = await loadIsomorphicCodeVariant(originalUrl || '',
               // Use the original URL if available
               variantName, codeObj[variantName],
               // May be undefined or string
@@ -493,7 +509,7 @@ function useGlobalsCodeMerging({
         console.error(new Errors.ErrorCodeHighlighterClientLoadGlobalsCodeFailure(url || 'No URL', error));
       }
     })();
-  }, [url, globalsCode, processedGlobalsCode, setProcessedGlobalsCode, loadCodeMeta, loadSource, loadVariantMeta, variants, loadCodeVariant]);
+  }, [url, globalsCode, processedGlobalsCode, setProcessedGlobalsCode, loadCodeMeta, loadSource, loadVariantMeta, variants, loadIsomorphicCodeVariant]);
 
   // Determine globalsCodeObjects to use (prefer processed, fallback to direct if ready)
   const globalsCodeObjects = React.useMemo(() => {
@@ -675,7 +691,9 @@ export function CodeHighlighterClient(props) {
     fallbackUsesExtraFiles,
     fallbackUsesAllVariants
   } = props;
-  useInitialData({
+  const {
+    fallbackPending
+  } = useInitialData({
     variants,
     variantName,
     code,
@@ -748,7 +766,8 @@ export function CodeHighlighterClient(props) {
     setCode,
     processedGlobalsCode,
     globalsCode: props.globalsCode,
-    setProcessedGlobalsCode
+    setProcessedGlobalsCode,
+    fallbackPending
   });
 
   // Merge globalsCode with internal state code (fetched data) - this should be stable once ready

package/CodeHighlighter/errors.mjs

@@ -156,7 +156,7 @@ export class ErrorCodeHighlighterClientMissingLoadFallbackCode extends ErrorCode
 }
 export class ErrorCodeHighlighterClientMissingLoadVariant extends ErrorCodeHighlighterClientProvider {
   constructor(url) {
-    super(`Missing loadCodeVariant function - loadCodeVariant function is required when no initial code is provided (${url || 'No URL'})`);
+    super(`Missing loadIsomorphicCodeVariant function - loadIsomorphicCodeVariant function is required when no initial code is provided (${url || 'No URL'})`);
   }
 }
 export class ErrorCodeHighlighterClientMissingLoadCodeMeta extends ErrorCodeHighlighterClientProvider {
@@ -273,7 +273,7 @@ export class ErrorCodeHighlighterClientTransformProcessingFailure extends ErrorC
 }
 export class ErrorCodeHighlighterClientMissingLoadVariantForGlobals extends ErrorCodeHighlighterClientProvider {
   constructor() {
-    super(`loadCodeVariant function is required for loading missing variants in globalsCode`);
+    super(`loadIsomorphicCodeVariant function is required for loading missing variants in globalsCode`);
   }
 }
 export class ErrorCodeHighlighterClientLoadVariantFailureForGlobals extends ErrorCodeHighlighterClientLoader {

package/CodeHighlighter/types.d.mts

@@ -52,6 +52,17 @@ export type VariantExtraFiles = {
     metadata?: boolean;
     /** File system path for this file */
     path?: string;
+    /**
+     * Path of this file relative to the variant's `url`. Set when the
+     * `extraFiles` key was rewritten (e.g., flattened) and no longer
+     * resolves to the file's URL on its own. Consumers derive the file
+     * URL via `new URL(relativeUrl, variant.url)`. When omitted, the
+     * `extraFiles` key itself resolves to the file URL against
+     * `variant.url`.
+     *
+     * Always normalized to start with `./` or `../`.
+     */
+    relativeUrl?: string;
     /** Comments extracted from source, stored when parsing is disabled for later use */
     comments?: SourceComments;
   };
@@ -212,9 +223,20 @@ export interface LoadFileOptions {
    * @default 'hast'
    */
   output?: 'hast' | 'hastJson' | 'hastCompressed';
+  /**
+   * Optional URL-prefix rewrite applied to the loaded variant's `url` and any
+   * string-form `extraFiles` entries. Useful for translating local `file://`
+   * URLs (e.g. those returned by `loadServerCodeSource`) into hosted URLs (e.g.
+   * `https://github.com/owner/repo/tree/<branch>/`) before they reach the
+   * client.
+   */
+  urlPrefix?: {
+    from: string;
+    to: string;
+  };
 }
 /**
- * Options for the loadCodeVariant function, extending LoadFileOptions with required function dependencies
+ * Options for the loadIsomorphicCodeVariant function, extending LoadFileOptions with required function dependencies
  */
 export interface LoadVariantOptions extends LoadFileOptions, Pick<CodeFunctionProps, 'sourceParser' | 'loadSource' | 'loadVariantMeta' | 'sourceTransformers' | 'sourceEnhancers'> {}
 /**
@@ -312,6 +334,15 @@ export interface CodeFunctionProps {
   sourceParser?: Promise<ParseSource>;
   /** Array of source enhancers that run after parsing to enhance the HAST tree */
   sourceEnhancers?: SourceEnhancers;
+  /**
+   * Optional URL-prefix rewrite forwarded to {@link LoadFileOptions.urlPrefix}.
+   * Lets the demo factory translate local `file://` URLs returned by
+   * `loadSource` into hosted URLs before they reach the client.
+   */
+  urlPrefix?: {
+    from: string;
+    to: string;
+  };
 }
 /**
  * Component and rendering props

package/CodeProvider/CodeContext.d.mts

@@ -43,7 +43,7 @@ export interface CodeContext {
   /** Heavy function: Loads fallback code with all variants and files */
   loadCodeFallback?: LoadFallbackCodeFn;
   /** Heavy function: Loads a specific code variant with its dependencies */
-  loadCodeVariant?: LoadVariantFn;
+  loadIsomorphicCodeVariant?: LoadVariantFn;
   /** Heavy function: Parses code strings into HAST nodes */
   parseCode?: ParseCodeFn;
   /** Heavy function: Parses controlled code for editable demos */

package/CodeProvider/CodeProvider.mjs

@@ -5,11 +5,11 @@ import { CodeContext } from "./CodeContext.mjs";
 import { enhanceCodeEmphasis } from "../pipeline/enhanceCodeEmphasis/index.mjs";
 import { createParseSource } from "../pipeline/parseSource/parseSource.mjs";
 // Import the heavy functions
-import { loadCodeFallback } from "../pipeline/loadCodeVariant/loadCodeFallback.mjs";
-import { loadCodeVariant } from "../pipeline/loadCodeVariant/loadCodeVariant.mjs";
-import { parseCode } from "../pipeline/loadCodeVariant/parseCode.mjs";
+import { loadCodeFallback } from "../pipeline/loadIsomorphicCodeVariant/loadCodeFallback.mjs";
+import { loadIsomorphicCodeVariant } from "../pipeline/loadIsomorphicCodeVariant/loadIsomorphicCodeVariant.mjs";
+import { parseCode } from "../pipeline/loadIsomorphicCodeVariant/parseCode.mjs";
 import { parseControlledCode } from "../CodeHighlighter/parseControlledCode.mjs";
-import { computeHastDeltas, getAvailableTransforms } from "../pipeline/loadCodeVariant/computeHastDeltas.mjs";
+import { computeHastDeltas, getAvailableTransforms } from "../pipeline/loadIsomorphicCodeVariant/computeHastDeltas.mjs";
 import { jsx as _jsx } from "react/jsx-runtime";
 const DEFAULT_SOURCE_ENHANCERS = [enhanceCodeEmphasis];
 
@@ -116,7 +116,7 @@ export function CodeProvider({
     sourceEnhancers,
     // Provide the heavy functions
     loadCodeFallback,
-    loadCodeVariant,
+    loadIsomorphicCodeVariant,
     parseCode,
     parseControlledCode,
     computeHastDeltas,

package/abstractCreateDemo/abstractCreateDemo.d.mts

@@ -33,6 +33,24 @@ type AbstractCreateDemoOptions<T extends {}> = {
   loadSource?: LoadSource;
   sourceParser?: Promise<ParseSource>;
   sourceEnhancers?: SourceEnhancers;
+  /**
+   * Absolute filesystem path of the project root used to resolve `url`s
+   * gathered from `import.meta.url`. Combined with `projectUrl` to rewrite
+   * local `file://` URLs into hosted Git URLs (e.g.
+   * `https://github.com/owner/repo/tree/<branch>/`) before they reach the
+   * `CodeHighlighter`.
+   *
+   * Typically read from an environment variable populated by the build
+   * pipeline (e.g. Netlify's `REPOSITORY_URL`/`BRANCH` plus
+   * `git rev-parse --show-toplevel`). When either `projectPath` or
+   * `projectUrl` is missing, URLs are left untouched.
+   */
+  projectPath?: string;
+  /**
+   * Public URL prefix that maps to `projectPath`. See `projectPath` for
+   * details.
+   */
+  projectUrl?: string;
 };
 export declare function abstractCreateDemo<T extends {}>(options: AbstractCreateDemoOptions<T>, url: string, variants: {
   [key: string]: React.ComponentType;

package/abstractCreateDemo/abstractCreateDemo.mjs

@@ -1,5 +1,7 @@
 import * as React from 'react';
+import { pathToFileURL } from 'node:url';
 import { CodeHighlighter } from "../CodeHighlighter/index.mjs";
+import { applyUrlPrefixToCode, applyUrlPrefixToGlobalsCode, replaceUrlPrefix } from "../pipeline/loaderUtils/applyUrlPrefix.mjs";
 import { createDemoDataWithVariants } from "../createDemoData/index.mjs";
 import { jsx as _jsx } from "react/jsx-runtime";
 export function abstractCreateDemo(options, url, variants, meta) {
@@ -11,18 +13,35 @@ export function abstractCreateDemo(options, url, variants, meta) {
       globalCode.push(data.precompute || data.url);
     });
   }
+
+  // Apply urlPrefix once at factory build time so the rewritten values are
+  // captured by the closures below (and shared across renders) instead of
+  // being recomputed on every render inside `DemoComponent`.
+  //
+  // The top-level `url` is only rewritten when the variant is fully loaded
+  // (i.e. a `precompute` is present). Without a precompute, this `url` is
+  // forwarded to `loadSource` at runtime, which expects the original
+  // `file://` URL it can read from disk — rewriting here would turn it into
+  // a hosted `https://` URL and cause `loadSource` to fail. In that case
+  // the `urlPrefix` prop on `<CodeHighlighter>` (forwarded into
+  // `loadIsomorphicCodeVariant`) takes care of rewriting the loaded variant after the
+  // file is read.
+  const urlPrefix = resolveUrlPrefix(options.projectPath, options.projectUrl);
+  const resolvedUrl = urlPrefix && demoData.precompute ? replaceUrlPrefix(demoData.url, urlPrefix) ?? demoData.url : demoData.url;
+  const resolvedPrecompute = urlPrefix && demoData.precompute ? applyUrlPrefixToCode(demoData.precompute, urlPrefix) : demoData.precompute;
+  const resolvedGlobalCode = urlPrefix && globalCode.length > 0 ? applyUrlPrefixToGlobalsCode(globalCode, urlPrefix) : globalCode;
   function DemoComponent(props) {
     const renderedComponents = Object.entries(demoData.components).reduce((acc, [key, Component]) => {
       acc[key] = /*#__PURE__*/React.createElement(Component);
       return acc;
     }, {});
     const highlighter = /*#__PURE__*/_jsx(CodeHighlighter, {
-      url: demoData.url,
+      url: resolvedUrl,
       name: demoData.name,
       slug: demoData.slug,
       variantType: meta?.variantType || variantType,
-      precompute: demoData.precompute,
-      globalsCode: globalCode,
+      precompute: resolvedPrecompute,
+      globalsCode: resolvedGlobalCode,
       components: renderedComponents,
       contentProps: props,
       Content: options.DemoContent,
@@ -32,6 +51,7 @@ export function abstractCreateDemo(options, url, variants, meta) {
       loadSource: options.loadSource,
       sourceParser: options.sourceParser,
       sourceEnhancers: options.sourceEnhancers,
+      urlPrefix: urlPrefix,
       highlightAfter: meta?.highlightAfter || options.highlightAfter,
       enhanceAfter: meta?.enhanceAfter || options.enhanceAfter,
       controlled: options.controlled,
@@ -67,6 +87,17 @@ export function abstractCreateDemo(options, url, variants, meta) {
   }
   return DemoComponent;
 }
+function resolveUrlPrefix(projectPath, projectUrl) {
+  if (!projectPath || !projectUrl) {
+    return undefined;
+  }
+  const from = `${pathToFileURL(projectPath).href}/`;
+  const to = projectUrl.endsWith('/') ? projectUrl : `${projectUrl}/`;
+  return {
+    from,
+    to
+  };
+}
 export function createDemoFactory(options) {
   /**
    * Creates a demo component for displaying code examples with syntax highlighting.

package/cli/ensureDemoClients.mjs

@@ -1,7 +1,7 @@
 import { readFile, writeFile, readdir, access } from 'node:fs/promises';
 import path from 'node:path';
-import { parseCreateFactoryCall } from "../pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.mjs";
-import { serializeFunctionArguments } from "../pipeline/loadPrecomputedCodeHighlighter/serializeFunctionArguments.mjs";
+import { parseCreateFactoryCall } from "../pipeline/parseCreateFactoryCall/parseCreateFactoryCall.mjs";
+import { serializeFunctionArguments } from "../pipeline/parseCreateFactoryCall/serializeFunctionArguments.mjs";
 const CLIENT_FILE_NAME = 'client.ts';
 const INDEX_FILE_NAME = 'index.ts';
 const CLIENT_PROVIDER_IDENTIFIER = 'ClientProvider';

package/cli/validateWorker.mjs

@@ -6,7 +6,7 @@ import { unified } from 'unified';
 import remarkParse from 'remark-parse';
 import remarkMdx from 'remark-mdx';
 import { transformMarkdownMetadata } from "../pipeline/transformMarkdownMetadata/transformMarkdownMetadata.mjs";
-import { parseCreateFactoryCall } from "../pipeline/loadPrecomputedCodeHighlighter/parseCreateFactoryCall.mjs";
+import { parseCreateFactoryCall } from "../pipeline/parseCreateFactoryCall/parseCreateFactoryCall.mjs";
 import { syncTypes } from "../pipeline/syncTypes/syncTypes.mjs";
 function collectPerfEntries() {
   const entries = performance.getEntriesByType('measure').map(entry => ({