blume 1.7.2 → 2.0.0

package/src/core/sources/github-releases.ts

@@ -1,3 +1,4 @@
+import type { Heading, Nodes } from "mdast";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { gfmFromMarkdown } from "mdast-util-gfm";
 import { toString as mdastToString } from "mdast-util-to-string";
@@ -6,6 +7,7 @@ import stringWidth from "string-width";
 
 import matter from "../frontmatter.ts";
 import { PUBLIC_API_URL } from "../github.ts";
+import { neutralizeUnsafeLinks } from "../safe-links.ts";
 import { columnsPrefix } from "../text-width.ts";
 import {
   hashText,
@@ -121,6 +123,47 @@ const releaseDescription = (body: string): string | undefined => {
   return `${head}…`;
 };
 
+/** Every heading in a tree, in document order (lists and quotes included). */
+const headingsIn = (node: Nodes): Heading[] => {
+  if (node.type === "heading") {
+    return [node];
+  }
+  const found: Heading[] = [];
+  if ("children" in node) {
+    for (const child of node.children) {
+      found.push(...headingsIn(child));
+    }
+  }
+  return found;
+};
+
+/**
+ * Lift the notes' headings so the shallowest is an h2. The release page's
+ * title is its h1, and changesets opens every section at `### Patch Changes`,
+ * which would skip a level on every page. Only ATX headings can sit deeper
+ * than h2, so each lift drops leading `#`s; headings are read from the parsed
+ * tree, so a `#` inside a code fence is never touched.
+ */
+const liftHeadings = (body: string): string => {
+  const headings = headingsIn(
+    fromMarkdown(body, {
+      extensions: [gfm()],
+      mdastExtensions: [gfmFromMarkdown()],
+    })
+  );
+  const lift = Math.min(...headings.map((heading) => heading.depth)) - 2;
+  if (headings.length === 0 || lift <= 0) {
+    return body;
+  }
+  let lifted = body;
+  // Back to front, so each cut leaves the earlier offsets valid.
+  for (const heading of headings.toReversed()) {
+    const marker = lifted.indexOf("#", heading.position?.start.offset);
+    lifted = lifted.slice(0, marker) + lifted.slice(marker + lift);
+  }
+  return lifted;
+};
+
 /** Slugify a tag into a stable, URL-safe source ref (`v1.2.0` -> `v1-2-0`). */
 const slugifyTag = (tag: string): string =>
   tag.toLowerCase().replaceAll(NON_SLUG, "-").replaceAll(EDGE_DASHES, "");
@@ -159,7 +202,12 @@ const releaseToEntry = (release: GithubRelease): SourceEntry => {
   const title = release.name?.trim() || release.tag_name;
   const date = release.published_at ?? release.created_at;
   const category = release.prerelease ? "Prerelease" : "Release";
-  const body = (release.body ?? "").replaceAll("\r\n", "\n").trim();
+  // Release notes are the repository's content, not the site author's, so a
+  // link whose destination isn't a web, mail, or relative address
+  // (`javascript:`, `data:`) keeps only its label (see `safe-links.ts`).
+  const body = liftHeadings(
+    neutralizeUnsafeLinks((release.body ?? "").replaceAll("\r\n", "\n")).trim()
+  );
   // A summary in `seo.description` gives each release page a unique meta
   // description (instead of the site-wide fallback) without also rendering the
   // visible lede paragraph a top-level `description` would add.
@@ -286,6 +334,8 @@ export const githubReleasesSource = (
 
   return {
     load,
+    // Releases are written once, in one language: no locale can translate them.
+    monolingual: true,
     name: options.name,
     prefix: options.prefix,
     read,

package/src/core/sources/json.ts

@@ -0,0 +1,71 @@
+/**
+ * The JSON a CMS API returns: arbitrary values a query or REST endpoint
+ * hands back, typed as a closed union so a source narrows with predicates
+ * instead of casting.
+ */
+export type JsonValue =
+  | string
+  | number
+  | boolean
+  | null
+  | JsonValue[]
+  | { [key: string]: JsonValue };
+
+/** A JSON object: a document, a node in a rich-text tree, an API envelope. */
+export interface JsonObject {
+  [key: string]: JsonValue;
+}
+
+/**
+ * A node a dot path can descend into. Arrays pass too (matching their runtime
+ * string-key indexing, e.g. `items.0`), so the predicate types them as the
+ * keyed form both traverse through.
+ */
+export const isJsonObject = (
+  value: JsonValue | undefined
+): value is JsonObject => typeof value === "object" && value !== null;
+
+/** Resolve a dot path (`slug.current`) against a document. */
+export const getPath = (
+  doc: JsonObject,
+  path: string
+): JsonValue | undefined => {
+  let current: JsonValue | undefined = doc;
+  for (const key of path.split(".")) {
+    if (isJsonObject(current)) {
+      current = current[key];
+    } else {
+      return;
+    }
+  }
+  return current;
+};
+
+export const isStringValue = (value: JsonValue | undefined): value is string =>
+  typeof value === "string";
+
+export const asString = (value: JsonValue | undefined): string | undefined =>
+  isStringValue(value) ? value : undefined;
+
+/** The elements of an array value, or none when the value is not an array. */
+export const asArray = (value: JsonValue | undefined): JsonValue[] =>
+  Array.isArray(value) ? value : [];
+
+/** The object form of a value, or none when it is a scalar, array, or absent. */
+export const asObject = (
+  value: JsonValue | undefined
+): JsonObject | undefined =>
+  isJsonObject(value) && !Array.isArray(value) ? value : undefined;
+
+export const isNumberValue = (value: JsonValue | undefined): value is number =>
+  typeof value === "number";
+
+export const asNumber = (value: JsonValue | undefined): number | undefined =>
+  isNumberValue(value) ? value : undefined;
+
+/** The object elements of an array value; scalars and nested arrays are dropped. */
+export const objectsIn = (value: JsonValue | undefined): JsonObject[] =>
+  asArray(value).flatMap((item) => {
+    const object = asObject(item);
+    return object ? [object] : [];
+  });

package/src/core/sources/lexical.ts

@@ -0,0 +1,195 @@
+/**
+ * Lexical (Payload's rich text editor) → Markdown. Covers the nodes Payload's
+ * default features emit — paragraphs, headings, lists (bullet, numbered,
+ * check), quotes, links, uploads, horizontal rules — and hands `block` /
+ * `inlineBlock` nodes to a serializer keyed by their `blockType`, or notes
+ * them in a comment.
+ */
+import type { JsonObject } from "./json.ts";
+import { asNumber, asObject, asString, getPath, objectsIn } from "./json.ts";
+import type { InlineMarks } from "./lower.ts";
+import {
+  absoluteUrl,
+  blockquote,
+  headingPrefix,
+  image,
+  indent,
+  listItem,
+  markdownDocument,
+  renderInline,
+  renderLink,
+  unsupported,
+  writesMdx,
+} from "./lower.ts";
+
+export interface LexicalOptions {
+  /** The CMS origin a relative upload URL (`/media/x.png`) resolves against. */
+  baseUrl?: string;
+  /** Serializers for `block`/`inlineBlock` nodes, keyed by `fields.blockType`. */
+  serializers?: Record<string, (fields: JsonObject) => string>;
+}
+
+// Lexical's text `format` bitmask.
+const IS_BOLD = 1;
+const IS_ITALIC = 2;
+const IS_STRIKETHROUGH = 4;
+const IS_CODE = 16;
+
+/** Whether a power-of-two flag is set in the format bitmask. */
+const hasFlag = (format: number, flag: number): boolean =>
+  Math.floor(format / flag) % 2 === 1;
+
+const marksOf = (node: JsonObject): InlineMarks => {
+  const format = asNumber(node.format) ?? 0;
+  return {
+    bold: hasFlag(format, IS_BOLD),
+    code: hasFlag(format, IS_CODE),
+    italic: hasFlag(format, IS_ITALIC),
+    strike: hasFlag(format, IS_STRIKETHROUGH),
+  };
+};
+
+const children = (node: JsonObject): JsonObject[] => objectsIn(node.children);
+
+const typeOf = (node: JsonObject): string => asString(node.type) ?? "";
+
+const customBlock = (node: JsonObject, options: LexicalOptions): string => {
+  const fields = asObject(node.fields);
+  const blockType = fields ? asString(fields.blockType) : undefined;
+  const serializer = blockType ? options.serializers?.[blockType] : undefined;
+  if (fields && serializer) {
+    return serializer(fields);
+  }
+  return unsupported(
+    `Lexical block${blockType ? `: ${blockType}` : ""}`,
+    writesMdx(options.serializers)
+  );
+};
+
+const renderInlines = (nodes: JsonObject[], options: LexicalOptions): string =>
+  nodes
+    // oxlint-disable-next-line no-use-before-define -- mutual recursion: a link's label is itself inline content
+    .map((node) => renderInlineNode(node, options))
+    .join("");
+
+const renderInlineNode = (
+  node: JsonObject,
+  options: LexicalOptions
+): string => {
+  switch (typeOf(node)) {
+    case "text": {
+      return renderInline(asString(node.text) ?? "", marksOf(node));
+    }
+    case "linebreak": {
+      return "\n";
+    }
+    case "tab": {
+      return "\t";
+    }
+    case "link":
+    case "autolink": {
+      // `fields.url` on Payload 3; `url` on older Lexical payloads. An
+      // internal link (`linkType: "internal"`) carries a document, not a
+      // URL, so its label stays.
+      return renderLink(
+        renderInlines(children(node), options),
+        asString(getPath(node, "fields.url")) ?? asString(node.url)
+      );
+    }
+    case "inlineBlock": {
+      return customBlock(node, options);
+    }
+    default: {
+      return renderInlines(children(node), options);
+    }
+  }
+};
+
+const renderUpload = (node: JsonObject, options: LexicalOptions): string => {
+  const value = asObject(node.value);
+  const url = value ? asString(value.url) : undefined;
+  if (!(value && url)) {
+    return unsupported(
+      "Lexical upload (fetch with depth 1 to populate it)",
+      writesMdx(options.serializers)
+    );
+  }
+  const alt = asString(value.alt) ?? asString(value.filename) ?? "";
+  return image(alt, absoluteUrl(url, options.baseUrl));
+};
+
+const renderList = (node: JsonObject, options: LexicalOptions): string => {
+  const listType = asString(node.listType) ?? "bullet";
+  const start = asNumber(node.start) ?? 1;
+  const items: string[] = [];
+  let lastMarker = "-";
+  let index = 0;
+  for (const item of children(node)) {
+    const kids = children(item);
+    const nested = kids.filter((kid) => typeOf(kid) === "list");
+    const inline = kids.filter((kid) => typeOf(kid) !== "list");
+    const sub = nested.map((list) => renderList(list, options)).join("\n");
+    if (inline.length === 0 && nested.length > 0) {
+      // Lexical nests a sub-list as its own item holding only the list; it
+      // hangs under the item before it, or stands alone when there is none.
+      items.push(items.length > 0 ? indent(sub, lastMarker.length + 1) : sub);
+      continue;
+    }
+    lastMarker = listType === "number" ? `${start + index}.` : "-";
+    let check = "";
+    if (listType === "check") {
+      check = item.checked === true ? "[x] " : "[ ] ";
+    }
+    const line = `${check}${renderInlines(inline, options)}`;
+    items.push(listItem(lastMarker, sub ? `${line}\n${sub}` : line));
+    index += 1;
+  }
+  return items.join("\n");
+};
+
+const renderBlock = (node: JsonObject, options: LexicalOptions): string => {
+  switch (typeOf(node)) {
+    case "paragraph": {
+      return renderInlines(children(node), options);
+    }
+    case "heading": {
+      const level = Number((asString(node.tag) ?? "h1").slice(1));
+      return `${headingPrefix(level)}${renderInlines(children(node), options)}`;
+    }
+    case "quote": {
+      return blockquote(renderInlines(children(node), options));
+    }
+    case "list": {
+      return renderList(node, options);
+    }
+    case "horizontalrule": {
+      return "---";
+    }
+    case "upload": {
+      return renderUpload(node, options);
+    }
+    case "block": {
+      return customBlock(node, options);
+    }
+    default: {
+      return unsupported(
+        `Lexical node: ${typeOf(node)}`,
+        writesMdx(options.serializers)
+      );
+    }
+  }
+};
+
+/**
+ * Serialize a Lexical editor state (`{ root: { children } }`, or the root
+ * node itself) to Markdown.
+ */
+export const lexicalToMarkdown = (
+  state: JsonObject,
+  options: LexicalOptions = {}
+): string => {
+  const root = asObject(state.root) ?? state;
+  return markdownDocument(
+    children(root).map((node) => renderBlock(node, options))
+  );
+};

package/src/core/sources/lower.ts

@@ -0,0 +1,226 @@
+/**
+ * Shared primitives for lowering a CMS's rich-text tree to Markdown text.
+ * Every rich-text lowerer (Portable Text, Contentful, Lexical, Strapi
+ * blocks) renders inline runs, wraps them in block syntax, and joins blocks
+ * with blank lines; these helpers keep that Markdown identical across them.
+ */
+
+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
+// backslash-escapes every ASCII punctuation character, so `\*` is always the
+// literal asterisk, in `.md` and `.mdx` alike.
+const MARKDOWN_SPECIALS = /[\\`*_{}[\]~<]/gu;
+
+// 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.
+const BLOCK_START =
+  /^(?<marker>[#+-]|\d+[.)])(?=[ \t]|$)|^(?<quote>>)|^(?<rule>=+|-{2,})(?=[ \t]*$)/gmu;
+
+// 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;
+
+const escapeBlockStart = (text: string): string =>
+  text.replaceAll(BLOCK_START, (marker: string) => {
+    // A numbered marker escapes its punctuation (`1\.`), the rest themselves.
+    const index = marker.search(/[.)]/u);
+    return index === -1
+      ? `\\${marker}`
+      : `${marker.slice(0, index)}\\${marker.slice(index)}`;
+  });
+
+const escapeEsmStart = (text: string): string =>
+  text.replaceAll(
+    ESM_START,
+    (keyword: string) => `&#${keyword.codePointAt(0)};${keyword.slice(1)}`
+  );
+
+export const escapeMarkdownText = (text: string): string =>
+  escapeEsmStart(
+    escapeBlockStart(
+      text
+        .replaceAll(MARKDOWN_SPECIALS, String.raw`\$&`)
+        .replaceAll(CHARACTER_REFERENCE, String.raw`\&`)
+    )
+  );
+
+/** The marks a lowerer can put on an inline run. */
+export interface InlineMarks {
+  bold?: boolean;
+  code?: boolean;
+  italic?: boolean;
+  strike?: boolean;
+}
+
+const BACKTICK_RUN = /`+/gu;
+
+/** The longest run of backticks in `text`, 0 when there is none. */
+const longestBacktickRun = (text: string): number => {
+  let longest = 0;
+  for (const run of text.match(BACKTICK_RUN) ?? []) {
+    longest = Math.max(longest, run.length);
+  }
+  return longest;
+};
+
+/**
+ * A code span whose delimiter outruns any backtick run inside it, padded with
+ * a space on each side when the code starts or ends with a backtick (the
+ * CommonMark rule that keeps the padding out of the rendered code).
+ */
+export const codeSpan = (code: string): string => {
+  const fence = "`".repeat(longestBacktickRun(code) + 1);
+  const pad = code.startsWith("`") || code.endsWith("`") ? " " : "";
+  return `${fence}${pad}${code}${pad}${fence}`;
+};
+
+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.
+ */
+export const renderInline = (text: string, marks: InlineMarks): 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}*`;
+  }
+  if (marks.strike) {
+    out = `~~${out}~~`;
+  }
+  return `${lead}${out}${trail}`;
+};
+
+// A destination with whitespace or parentheses ends early in `[label](…)`;
+// CommonMark's pointy-bracket form carries it intact.
+const UNSAFE_DESTINATION = /[\s()]/u;
+
+/** A link or image destination as Markdown can carry it verbatim. */
+export const destination = (url: string): string =>
+  UNSAFE_DESTINATION.test(url) ? `<${url}>` : url;
+
+/**
+ * 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`).
+ */
+export const renderLink = (label: string, href?: string): string =>
+  href && isSafeHref(href) ? `[${label}](${destination(href)})` : label;
+
+/** The ATX prefix for a heading level, clamped to Markdown's six. */
+export const headingPrefix = (level: number): string =>
+  `${"#".repeat(Math.min(Math.max(Math.trunc(level), 1), 6))} `;
+
+/** Quote every line of a block. */
+export const blockquote = (text: string): string =>
+  text
+    .split("\n")
+    .map((line) => (line === "" ? ">" : `> ${line}`))
+    .join("\n");
+
+/**
+ * A list item: the marker on the first line, and every continuation line
+ * indented to the marker's width so nested blocks stay inside the item.
+ */
+export const listItem = (marker: string, body: string): string => {
+  const [first = "", ...rest] = body.split("\n");
+  const pad = " ".repeat(marker.length + 1);
+  return [
+    `${marker} ${first}`,
+    ...rest.map((line) => (line === "" ? "" : `${pad}${line}`)),
+  ].join("\n");
+};
+
+/** Indent every non-empty line, for a nested list hanging off an item. */
+export const indent = (text: string, width: number): string => {
+  const pad = " ".repeat(width);
+  return text
+    .split("\n")
+    .map((line) => (line === "" ? "" : `${pad}${line}`))
+    .join("\n");
+};
+
+/** A fenced code block whose fence outruns any backtick run in the code. */
+export const codeFence = (code: string, language = ""): string => {
+  const fence = "`".repeat(Math.max(3, longestBacktickRun(code) + 1));
+  return `${fence}${language}\n${code}\n${fence}`;
+};
+
+/** A Markdown image; the alt is escaped so a `]` in a caption can't close it. */
+export const image = (alt: string, url: string): string =>
+  `![${escapeMarkdownText(alt)}](${destination(url)})`;
+
+/**
+ * Whether a lowerer's output is written as MDX. Serializers are how a CMS
+ * block becomes a Blume component, and components (like directives) only
+ * render in MDX, so configuring any serializer switches the source's
+ * rich-text bodies to `.mdx`. The escaping above keeps the rest of the
+ * lowered text valid there.
+ */
+export const writesMdx = <Node>(
+  serializers?: Record<string, (node: Node) => string>
+): boolean => serializers !== undefined && Object.keys(serializers).length > 0;
+
+/**
+ * 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} -->`;
+
+/** Blocks separated by blank lines; empty blocks are dropped. */
+export const joinBlocks = (blocks: string[]): string =>
+  blocks.filter((block) => block !== "").join("\n\n");
+
+/** A whole document: its blocks plus the trailing newline a file ends with. */
+export const markdownDocument = (blocks: string[]): string =>
+  `${joinBlocks(blocks)}\n`;
+
+const ABSOLUTE = /^[a-z][a-z0-9+.-]*:/iu;
+
+/**
+ * A media URL as a static site can reference it. A protocol-relative
+ * Contentful asset (`//images.ctfassets.net/…`) gets `https:`; a path a
+ * self-hosted CMS serves (`/uploads/x.png`) resolves against the CMS origin.
+ */
+export const absoluteUrl = (url: string, base?: string): string => {
+  if (url.startsWith("//")) {
+    return `https:${url}`;
+  }
+  if (ABSOLUTE.test(url) || base === undefined) {
+    return url;
+  }
+  return new URL(url, base).href;
+};

package/src/core/sources/normalize.ts

@@ -675,17 +675,66 @@ const scanLinkLine = (
   return next;
 };
 
+/**
+ * A component's string `href` (`<Card href="./install" />`): the attribute
+ * may sit on a later line than the tag name, where a formatter wraps a long
+ * element, so the gap between them spans lines. An expression-valued
+ * `href={…}` isn't a literal target, and a lowercase tag is raw HTML in a
+ * `.md` page, so neither is matched.
+ */
+const COMPONENT_HREF =
+  /<[A-Z][\w.]*(?=[\s/>])[^<>]*?\shref=(?:"(?<double>[^"]*)"|'(?<single>[^']*)')/gu;
+
+/** The body with fenced blocks and inline code blanked, shape preserved. */
+const maskCode = (lines: readonly string[]): string => {
+  let fence: FenceState = null;
+  const masked = lines.map((line) => {
+    const next = nextFenceState(line, fence);
+    const inFence = fence !== null || next !== null;
+    fence = next;
+    return inFence
+      ? " ".repeat(line.length)
+      : line.replaceAll(INLINE_CODE, (span) => " ".repeat(span.length));
+  });
+  return masked.join("\n");
+};
+
+/** Every component `href` target in `body`, with its 1-based position. */
+const componentHrefs = (
+  lines: readonly string[],
+  lineOffset: number
+): PageLink[] => {
+  const links: PageLink[] = [];
+  const text = maskCode(lines);
+  for (const match of text.matchAll(COMPONENT_HREF)) {
+    const target = match.groups?.double ?? match.groups?.single ?? "";
+    // The value ends one character (its closing quote) before the match does.
+    const at = match.index + match[0].length - target.length - 1;
+    const before = text.slice(0, at);
+    const lineStart = before.lastIndexOf("\n") + 1;
+    links.push({
+      column: at - lineStart + 1,
+      line: lineOffset + before.split("\n").length,
+      target,
+    });
+  }
+  return links;
+};
+
 export const extractLinks = (body: string, lineOffset = 0): PageLink[] => {
   const links: PageLink[] = [];
   let fence: FenceState = null;
   let lineNumber = lineOffset;
 
-  for (const line of body.split("\n")) {
+  const lines = body.split("\n");
+  for (const line of lines) {
     lineNumber += 1;
     fence = scanLinkLine(line, lineNumber, fence, links);
   }
 
-  return links;
+  return body.includes("href=")
+    ? [...links, ...componentHrefs(lines, lineOffset)]
+    : links;
 };
 
 // Double-quoted strings hold JSX attribute values and JSON in `{...}` props; a
@@ -1172,6 +1221,7 @@ export const normalizeEntry = (
     lastModified: meta.lastModified ?? entry.lastModified,
     links: entryLinks(entry),
     meta,
+    monolingual: ctx.source.monolingual,
     navPath,
     segments,
     source: { name: ctx.source.name, ref: entry.ref },