blume 2.0.1 → 2.0.3

package/src/core/sources/lower.ts

@@ -9,42 +9,66 @@ import { isSafeHref } from "../safe-href.ts";
 
 // Markdown/raw-HTML structure characters. Rich-text leaves are *plain text* —
 // formatting arrives as marks, never as syntax in the text — so a literal
-// `*`, `_`, `[`, backtick, `~`, or `<` typed in the CMS must render as
-// itself. Unescaped, it opened emphasis or a code span mid-paragraph, and `<`
-// let CMS prose inject raw HTML into the rendered page. `{` and `}` open an
-// expression once an entry is written as MDX (see {@link writesMdx}). CommonMark
+// `*`, `_`, `[`, backtick, `~`, `^`, or `<` typed in the CMS must render as
+// itself. Unescaped, it opened emphasis, a code span, or a superscript
+// (`2^10 and 2^20`) mid-paragraph, and `<` let CMS prose inject raw HTML into
+// the rendered page. `{` and `}` open an expression once an entry is written
+// as MDX (see {@link writesMdx}), and `$$` opens math there. CommonMark
 // backslash-escapes every ASCII punctuation character, so `\*` is always the
 // literal asterisk, in `.md` and `.mdx` alike.
-const MARKDOWN_SPECIALS = /[\\`*_{}[\]~<]/gu;
+const MARKDOWN_SPECIALS = /[\\`*_{}[\]~<$^]/gu;
+
+// MDX reads a colon ahead of a letter or digit as a text directive (`10:30`,
+// `og:image`, `pets:read`), so that colon is escaped too. One inside a bare
+// URL (`http://localhost:3000`) stays as written: an escape there would end
+// the autolink early.
+const DIRECTIVE_COLON = /(?<!(?:[a-z][\w+.-]*:\/\/|www\.)\S*):(?=[a-z\d])/giu;
+
+// GFM autolinks a bare `http://`, `https://`, or `www.` URL in prose, taking
+// its characters verbatim up to the next space or `<`: an escape inside one
+// reaches the href as a backslash (`a\_b`), so prose leaves a bare URL's
+// characters as written. That includes a trailing `*`, `_`, or `~`, which
+// GFM leaves out of the link: escaped, its backslash would still land inside.
+// A link label is the exception — GFM links nothing inside one, so there
+// every special is escaped (see `linkParts`).
+const BARE_URL = /\b(?:https?:\/\/|www\.)[\w-][^\s<]*/giu;
 
 // An entity or numeric character reference (`&copy;`, `&#38;`) is decoded
 // even in plain text, so one typed in the CMS would render as the character
 // it names rather than as written. A bare `&` is left alone.
 const CHARACTER_REFERENCE = /&(?=#?[a-z0-9]+;)/giu;
 
-// Block syntax is only syntax at the start of a line: `# `, `- `, `+ ` and
-// `1. `/`1) ` need the space (or line end) to become a heading or list item,
-// while `>` opens a quote on its own, and a line of only `=` or `-` turns the
-// line above it into a heading (or, alone, into a rule). A CMS paragraph that
-// begins with one of these — a soft break inside it counts as a line start
-// too — must stay prose.
+// Block syntax is only syntax at the start of a line: `# ` (through
+// `###### `), `- `, `+ ` and `1. `/`1) ` need the space (or line end) to
+// become a heading or list item, while `>` opens a quote on its own, and a
+// line of only `=` or `-` turns the line above it into a heading (or, alone,
+// into a rule). Indentation of up to three spaces still counts. A CMS
+// paragraph that begins with one of these — a soft break inside it counts as
+// a line start too — must stay prose.
 const BLOCK_START =
-  /^(?<marker>[#+-]|\d+[.)])(?=[ \t]|$)|^(?<quote>>)|^(?<rule>=+|-{2,})(?=[ \t]*$)/gmu;
+  /^(?<indent>[ \t]*)(?:(?<marker>#+|[+-]|\d+[.)])(?=[ \t]|$)|(?<quote>>)|(?<rule>=+|-{2,})(?=[ \t]*$))/gmu;
+
+// MDX reads a top-level line that opens with `import` or `export` followed by
+// a space, a tab, `{`, or `*` as an ESM statement, and prose like "import the
+// CSV first" then fails the whole page. The keyword's first letter as a
+// character reference renders the same in `.md` and `.mdx`, and MDX no longer
+// sees the keyword. The keyword is escaped wherever a word ends on it, which
+// covers every character that opens a statement. Only a block's first line
+// counts; a blank line inside the text starts a new block.
+const ESM_START = /(?<=^|\n[ \t]*\n)(?<keyword>import|export)(?![\w$])/gu;
 
-// MDX reads a top-level paragraph that opens with `import ` or `export ` as an
-// ESM statement, and prose like "import the CSV first" then fails the whole
-// page. The keyword's first letter as a character reference renders the same
-// in `.md` and `.mdx`, and MDX no longer sees the keyword. Only a paragraph's
-// first line counts; a blank line inside a run starts a new paragraph.
-const ESM_START = /(?<=^|\n[ \t]*\n)(?<keyword>import|export)(?= )/gu;
+// Whitespace opening a block: four columns of it (or a tab) make an indented
+// code block, and a paragraph drops it when it renders anyway.
+const BLOCK_INDENT = /(?<=^|\n[ \t]*\n)[ \t]+/gu;
 
 const escapeBlockStart = (text: string): string =>
-  text.replaceAll(BLOCK_START, (marker: string) => {
+  text.replaceAll(BLOCK_START, (match: string, indent: string) => {
     // A numbered marker escapes its punctuation (`1\.`), the rest themselves.
+    const marker = match.slice(indent.length);
     const index = marker.search(/[.)]/u);
     return index === -1
-      ? `\\${marker}`
-      : `${marker.slice(0, index)}\\${marker.slice(index)}`;
+      ? `${indent}\\${marker}`
+      : `${indent}${marker.slice(0, index)}\\${marker.slice(index)}`;
   });
 
 const escapeEsmStart = (text: string): string =>
@@ -53,15 +77,37 @@ const escapeEsmStart = (text: string): string =>
     (keyword: string) => `&#${keyword.codePointAt(0)};${keyword.slice(1)}`
   );
 
-export const escapeMarkdownText = (text: string): string =>
+const escapeSpecials = (text: string): string =>
+  text.replaceAll(MARKDOWN_SPECIALS, String.raw`\$&`);
+
+/** The escapes that apply everywhere, once the specials are escaped. */
+const escapeRest = (text: string): string =>
   escapeEsmStart(
     escapeBlockStart(
       text
-        .replaceAll(MARKDOWN_SPECIALS, String.raw`\$&`)
+        .replaceAll(DIRECTIVE_COLON, String.raw`\:`)
         .replaceAll(CHARACTER_REFERENCE, String.raw`\&`)
     )
   );
 
+/**
+ * CMS text as Markdown that renders as written, wherever it lands — a link
+ * label included, where GFM autolinks nothing, so every special is escaped.
+ */
+export const escapeMarkdownText = (text: string): string =>
+  escapeRest(escapeSpecials(text));
+
+/** CMS prose as {@link escapeMarkdownText}, except inside a bare URL. */
+const escapeProse = (text: string): string => {
+  let out = "";
+  let last = 0;
+  for (const match of text.matchAll(BARE_URL)) {
+    out += escapeSpecials(text.slice(last, match.index)) + match[0];
+    last = match.index + match[0].length;
+  }
+  return escapeRest(out + escapeSpecials(text.slice(last)));
+};
+
 /** The marks a lowerer can put on an inline run. */
 export interface InlineMarks {
   bold?: boolean;
@@ -70,6 +116,20 @@ export interface InlineMarks {
   strike?: boolean;
 }
 
+/** A run of CMS text and the marks on it. */
+export interface InlineRun {
+  marks: InlineMarks;
+  text: string;
+}
+
+/** Inline Markdown a lowerer rendered itself: a link, an embed, a break. */
+export interface InlineMarkdown {
+  markdown: string;
+}
+
+/** One piece of a block's inline content, in order. */
+export type InlinePart = InlineMarkdown | InlineRun;
+
 const BACKTICK_RUN = /`+/gu;
 
 /** The longest run of backticks in `text`, 0 when there is none. */
@@ -92,52 +152,195 @@ export const codeSpan = (code: string): string => {
   return `${fence}${pad}${code}${pad}${fence}`;
 };
 
+// Two struck runs side by side meet as `~~~~`: a closer and an opener that
+// GFM reads as one four-tilde run, so both print as literal tildes. A literal
+// `~` is escaped outside a bare URL, so an unescaped `~~~~` outside a code
+// span, a link destination, or a bare URL is exactly that seam, and dropping
+// it merges the runs into one strikethrough. The other alternatives only step
+// over escapes, code spans, destinations, and bare URLs so the seam is never
+// matched inside them.
+const SEAM_STEPS =
+  /\\[\s\S]|(?<ticks>`+)[\s\S]*?(?<!`)\k<ticks>(?!`)|\]\((?:<(?:\\.|[^\\<>\n])*>|(?:\\.|[^\\\s)])+)\)/u;
+const STRIKE_SEAM = new RegExp(
+  `${SEAM_STEPS.source}|${BARE_URL.source}|~~~~`,
+  "giu"
+);
+
+// A heading that ends in a space and a run of `#` reads that run as the
+// optional closing sequence and drops it (`## Issue #` renders "Issue").
+const CLOSING_HASHES = /(?<=[ \t])#+(?=[ \t]*$)/u;
+
+/**
+ * A block's inline text, guarded where only the whole block can tell. Runs
+ * are escaped one at a time, but "import" ending one run and a space or code
+ * span opening the next form an MDX `import` statement only once they are
+ * joined, whitespace the first runs put in front of a block turns it into
+ * an indented code block, two struck runs fuse into literal tildes, and a
+ * trailing ` #` is a heading's closing sequence. Apply it to the joined text
+ * of a paragraph, heading, quote, or list item — never to code.
+ */
+export const guardBlockStart = (text: string): string =>
+  escapeEsmStart(
+    text
+      .replaceAll(BLOCK_INDENT, "")
+      .replaceAll(STRIKE_SEAM, (match: string) =>
+        match === "~~~~" ? "" : match
+      )
+      .replace(CLOSING_HASHES, String.raw`\$&`)
+  );
+
 const EDGE_SPACE = /^(?<lead>\s*)(?<body>[\s\S]*?)(?<trail>\s*)$/u;
 
 /**
- * Wrap a text run in the Markdown for its marks. Code stays verbatim inside
- * the backticks (an escape would render as a backslash); everything else is
- * escaped first. Whitespace at either edge moves outside the delimiters,
- * since `** bold **` is not strong emphasis but `**bold**` is — editors
- * routinely bold a word together with the space after it.
+ * `text` with `render` applied between its edge whitespace, or as it is when
+ * it is only whitespace.
  */
-export const renderInline = (text: string, marks: InlineMarks): string => {
+const betweenEdges = (
+  text: string,
+  render: (body: string) => string
+): string => {
   const match = EDGE_SPACE.exec(text);
-  const lead = match?.groups?.lead ?? "";
   const body = match?.groups?.body ?? "";
-  const trail = match?.groups?.trail ?? "";
   if (body === "") {
     return text;
   }
-  let out = marks.code ? codeSpan(body) : escapeMarkdownText(body);
-  if (marks.bold) {
-    out = `**${out}**`;
-  }
-  if (marks.italic) {
-    out = `*${out}*`;
+  return `${match?.groups?.lead ?? ""}${render(body)}${match?.groups?.trail ?? ""}`;
+};
+
+const MARK_NAMES = ["bold", "code", "italic", "strike"] as const;
+
+const sameMarks = (
+  a: InlineMarks,
+  b: InlineMarks,
+  names: readonly (keyof InlineMarks)[] = MARK_NAMES
+): boolean => names.every((mark) => Boolean(a[mark]) === Boolean(b[mark]));
+
+/** A stretch of neighboring runs that share marks, and those marks. */
+interface RunGroup {
+  marks: InlineMarks;
+  runs: InlineRun[];
+}
+
+/** Runs split into stretches of neighbors that share the `names` marks. */
+const groupRuns = (
+  runs: InlineRun[],
+  names: readonly (keyof InlineMarks)[] = MARK_NAMES
+): RunGroup[] => {
+  const groups: RunGroup[] = [];
+  for (const run of runs) {
+    const group = groups.at(-1);
+    if (group && sameMarks(group.marks, run.marks, names)) {
+      group.runs.push(run);
+    } else {
+      groups.push({ marks: run.marks, runs: [run] });
+    }
   }
-  if (marks.strike) {
-    out = `~~${out}~~`;
+  return groups;
+};
+
+/**
+ * Consecutive text runs as Markdown. Neighbors with the same bold, italic,
+ * and strikethrough share one set of delimiters — rendered one run at a
+ * time, two bold runs met as `****` and two italic ones as `**`, which print
+ * as literal asterisks. Code stays verbatim inside the backticks (an escape
+ * would render as a backslash), and neighboring code joins into one span;
+ * everything else is escaped. Whitespace at either edge moves outside the
+ * delimiters, since `** bold **` is not strong emphasis but `**bold**` is —
+ * editors routinely bold a word together with the space after it.
+ */
+const renderRuns = (
+  runs: InlineRun[],
+  escape: (text: string) => string
+): string =>
+  groupRuns(runs, ["bold", "italic", "strike"])
+    .map(({ marks, runs: shared }) => {
+      const inner = groupRuns(shared)
+        .map((same) =>
+          betweenEdges(same.runs.map((run) => run.text).join(""), (body) =>
+            same.marks.code ? codeSpan(body) : escape(body)
+          )
+        )
+        .join("");
+      return betweenEdges(inner, (body) => {
+        let out = body;
+        if (marks.bold) {
+          out = `**${out}**`;
+        }
+        if (marks.italic) {
+          out = `*${out}*`;
+        }
+        if (marks.strike) {
+          out = `~~${out}~~`;
+        }
+        return out;
+      });
+    })
+    .join("");
+
+/** Inline parts as Markdown, each stretch of runs through {@link renderRuns}. */
+const renderParts = (
+  parts: InlinePart[],
+  escape: (text: string) => string
+): string => {
+  let out = "";
+  let runs: InlineRun[] = [];
+  for (const part of parts) {
+    if ("markdown" in part) {
+      out += renderRuns(runs, escape) + part.markdown;
+      runs = [];
+    } else {
+      runs.push(part);
+    }
   }
-  return `${lead}${out}${trail}`;
+  return out + renderRuns(runs, escape);
 };
 
-// A destination with whitespace or parentheses ends early in `[label](…)`;
-// CommonMark's pointy-bracket form carries it intact.
-const UNSAFE_DESTINATION = /[\s()]/u;
+/** A block's inline content as Markdown. */
+export const renderInline = (parts: InlinePart[]): string =>
+  renderParts(parts, escapeProse);
+
+// A destination with whitespace, a control character, or parentheses ends
+// early in `[label](…)`; CommonMark's pointy-bracket form carries it intact.
+// oxlint-disable-next-line no-control-regex -- control characters are exactly what the bare form refuses.
+const UNSAFE_DESTINATION = /[\s()\u0000-\u001F\u007F]/u;
 
-/** A link or image destination as Markdown can carry it verbatim. */
-export const destination = (url: string): string =>
-  UNSAFE_DESTINATION.test(url) ? `<${url}>` : url;
+// Markdown decodes a destination before the browser sees it: a backslash
+// escape or a character reference becomes its character, so
+// `java&#115;cript:` would reach the `href` as `javascript:` after the safety
+// check passed it. Escaping both — and `<`/`>`, which would close the
+// pointy form early and let the rest of the URL open a second link — keeps
+// the `href` exactly the URL the CMS holds.
+const DESTINATION_SPECIALS = /[\\<>]|&(?=#?[a-z0-9]+;)/giu;
+
+// A destination can't hold a line break, and the URL parser drops tabs and
+// line breaks anyway, so removing them leaves the same URL.
+const DESTINATION_IGNORED = /[\t\n\r]/gu;
+
+/** A link or image destination as Markdown carries it verbatim. */
+export const destination = (url: string): string => {
+  const escaped = url
+    .replaceAll(DESTINATION_IGNORED, "")
+    .replaceAll(DESTINATION_SPECIALS, String.raw`\$&`);
+  return UNSAFE_DESTINATION.test(escaped) ? `<${escaped}>` : escaped;
+};
 
 /**
- * A Markdown link, or the label alone when the target is missing — or unsafe:
- * CMS content is the editor's, not the site author's, so a destination that
- * isn't a web, mail, or relative address (`javascript:`, `data:`) never
- * becomes a clickable link on the docs site (see `safe-links.ts`).
+ * A Markdown link over inline parts, or the parts alone when the target is
+ * missing — or unsafe: CMS content is the editor's, not the site author's, so
+ * a destination that isn't a web, mail, or relative address (`javascript:`,
+ * `data:`) never becomes a clickable link on the docs site (see
+ * `safe-links.ts`). The parts stay parts then, so their runs merge with their
+ * neighbors'. A label escapes a bare URL too: GFM autolinks nothing inside a
+ * link, so its specials would read as syntax.
  */
-export const renderLink = (label: string, href?: string): string =>
-  href && isSafeHref(href) ? `[${label}](${destination(href)})` : label;
+export const linkParts = (parts: InlinePart[], href?: string): InlinePart[] =>
+  href && isSafeHref(href)
+    ? [
+        {
+          markdown: `[${renderParts(parts, escapeMarkdownText)}](${destination(href)})`,
+        },
+      ]
+    : parts;
 
 /** The ATX prefix for a heading level, clamped to Markdown's six. */
 export const headingPrefix = (level: number): string =>
@@ -172,10 +375,20 @@ export const indent = (text: string, width: number): string => {
     .join("\n");
 };
 
-/** A fenced code block whose fence outruns any backtick run in the code. */
+// A fence's language is one word of its info string. A backtick in it keeps
+// the fence from opening at all, so the code renders as Markdown and HTML,
+// and whitespace would start the meta Blume reads code titles from; a
+// language that isn't a single such word is dropped.
+const FENCE_LANGUAGE = /^[^\s`]+$/u;
+
+/**
+ * A fenced code block whose fence outruns any backtick run in the code,
+ * labeled with its language when that is one word a fence can carry.
+ */
 export const codeFence = (code: string, language = ""): string => {
   const fence = "`".repeat(Math.max(3, longestBacktickRun(code) + 1));
-  return `${fence}${language}\n${code}\n${fence}`;
+  const label = FENCE_LANGUAGE.test(language) ? language : "";
+  return `${fence}${label}\n${code}\n${fence}`;
 };
 
 /** A Markdown image; the alt is escaped so a `]` in a caption can't close it. */
@@ -193,12 +406,19 @@ export const writesMdx = <Node>(
   serializers?: Record<string, (node: Node) => string>
 ): boolean => serializers !== undefined && Object.keys(serializers).length > 0;
 
+// A node's type is the CMS's data too: a `*/` (or `--`) in it would close the
+// comment early and let the rest run as MDX (or render as HTML). A space
+// between the two characters keeps it inside.
+const COMMENT_END = /\*\/|--/gu;
+
 /**
  * A comment marking a node the lowerer has no Markdown for — an MDX comment
  * when the output is MDX, which rejects `<!-- -->`.
  */
-export const unsupported = (what: string, mdx = false): string =>
-  mdx ? `{/* unsupported ${what} */}` : `<!-- unsupported ${what} -->`;
+export const unsupported = (what: string, mdx = false): string => {
+  const label = what.replaceAll(COMMENT_END, (end) => [...end].join(" "));
+  return mdx ? `{/* unsupported ${label} */}` : `<!-- unsupported ${label} -->`;
+};
 
 /** Blocks separated by blank lines; empty blocks are dropped. */
 export const joinBlocks = (blocks: string[]): string =>

package/src/core/sources/mdx-remote.ts

@@ -9,6 +9,7 @@ import {
   pollingWatch,
   snapshotCache,
 } from "./cache.ts";
+import { REMOTE_TIMEOUT_MS } from "./remote.ts";
 import type {
   ContentSource,
   SourceContext,
@@ -64,6 +65,38 @@ const githubHeaders = (url: string): Record<string, string> => {
   return GITHUB_HOSTS.has(host) ? { authorization: `Bearer ${token}` } : {};
 };
 
+/**
+ * GET `url`'s body, giving up after {@link REMOTE_TIMEOUT_MS}: a server that
+ * accepts the connection and never finishes answering would otherwise hold the
+ * scan, and so the build or every dev rescan, indefinitely. A timeout rejects
+ * with an error naming the URL and the limit, so the skip or offline
+ * diagnostic says what stalled instead of only that an operation was aborted.
+ */
+const fetchText = async (
+  url: string,
+  doFetch: typeof fetch
+): Promise<string> => {
+  try {
+    // The signal bounds the body read too, not only the response headers.
+    const res = await doFetch(url, {
+      headers: githubHeaders(url),
+      signal: AbortSignal.timeout(REMOTE_TIMEOUT_MS),
+    });
+    if (!res.ok) {
+      throw new Error(`${url} -> ${res.status}`);
+    }
+    return await res.text();
+  } catch (error) {
+    if (error instanceof DOMException && error.name === "TimeoutError") {
+      throw new Error(
+        `${url} did not respond within ${REMOTE_TIMEOUT_MS / 1000}s`,
+        { cause: error }
+      );
+    }
+    throw error;
+  }
+};
+
 interface GithubTreeEntry {
   path: string;
   type: string;
@@ -78,13 +111,10 @@ const enumerateGithub = async (
   const { owner, repo, ref } = github;
   const base = github.path.replaceAll(/^\/|\/$/gu, "");
   const treeUrl = `https://api.github.com/repos/${owner}/${repo}/git/trees/${ref}?recursive=1`;
-  const res = await doFetch(treeUrl, { headers: githubHeaders(treeUrl) });
-  if (!res.ok) {
-    throw new Error(`${treeUrl} -> ${res.status}`);
-  }
+  const text = await fetchText(treeUrl, doFetch);
   // SAFETY: GitHub's git/trees endpoint returns this envelope; a missing or
   // differently-typed field falls through the `?? []` and blob filters below.
-  const body = (await res.json()) as {
+  const body = JSON.parse(text) as {
     tree?: GithubTreeEntry[];
     truncated?: boolean;
   };
@@ -157,13 +187,7 @@ export const mdxRemoteSource = (
   };
 
   const fetchEntry = async (item: RemoteRef): Promise<SourceEntry> => {
-    const res = await doFetch(item.fetchUrl, {
-      headers: githubHeaders(item.fetchUrl),
-    });
-    if (!res.ok) {
-      throw new Error(`${item.fetchUrl} -> ${res.status}`);
-    }
-    const text = await res.text();
+    const text = await fetchText(item.fetchUrl, doFetch);
     const parsed = matter(text);
     const format = item.ref.toLowerCase().endsWith(".mdx") ? "mdx" : "md";
     return {
@@ -193,16 +217,19 @@ export const mdxRemoteSource = (
             severity: "warning",
           });
         }
+        const reasons: string[] = [];
         const settled = await Promise.all(
           refs.map(async (ref) => {
             try {
               return await fetchEntry(ref);
             } catch (error) {
+              // SAFETY: fetch and decode failures throw Error instances;
+              // only the message is read for the skip diagnostic.
+              const reason = (error as Error).message;
+              reasons.push(reason);
               skipped.push({
                 code: "BLUME_SOURCE_FETCH_FAILED",
-                // SAFETY: fetch and decode failures throw Error instances;
-                // only the message is read for the skip diagnostic.
-                message: `Source "${options.name}" skipped "${ref.ref}" (${(error as Error).message}); the rest were imported.`,
+                message: `Source "${options.name}" skipped "${ref.ref}" (${reason}); the rest were imported.`,
                 severity: "warning",
               });
               return null;
@@ -215,9 +242,13 @@ export const mdxRemoteSource = (
         // Only a total wipeout is a hard failure — let loadWithCache fall back
         // to cache or fail loudly rather than silently importing nothing. A
         // partial failure keeps the healthy pages and warns about the rest.
+        // The first failure's reason rides along, so a server that timed out
+        // on every file says so.
         if (refs.length > 0 && entries.length === 0) {
           skipped.length = 0;
-          throw new Error(`all ${refs.length} remote file(s) failed to fetch`);
+          throw new Error(
+            `all ${refs.length} remote file(s) failed to fetch (${reasons[0]})`
+          );
         }
         return entries;
       },
@@ -243,6 +274,10 @@ export const mdxRemoteSource = (
   return {
     load,
     name: options.name,
+    // Refs are the remote tree's file and folder names, so an ordering prefix
+    // (`01-getting-started/02-install.mdx`) sorts the sidebar and drops from
+    // the route, the way it does in a local content folder.
+    orderedNames: true,
     prefix: options.prefix,
     read,
     staged: true,
@@ -253,5 +288,6 @@ export const mdxRemoteSource = (
           () => load()
         )
       : undefined,
+    withContext: (next) => mdxRemoteSource(options, next),
   };
 };