explico 0.12.0 → 0.13.0

package/src/compiler/exports/markdown/serialize.ts

@@ -0,0 +1,632 @@
+import type {
+  BlockContent,
+  DefinitionContent,
+  List,
+  ListItem,
+  Paragraph,
+  PhrasingContent,
+  Root,
+  RootContent,
+  Table,
+  TableCell as MdTableCell,
+  TableRow,
+} from 'mdast';
+import { gfmTableToMarkdown } from 'mdast-util-gfm-table';
+import { mathToMarkdown } from 'mdast-util-math';
+import { toMarkdown } from 'mdast-util-to-markdown';
+
+import { captionTitle } from '../../../components/float-name';
+import { stripNotationMarkers } from '../../../reference/math-glyphs.mjs';
+import type { ContentSegment } from '../../../reference/mixed-content';
+import type { CheckItem } from '../latex/serialize';
+import type {
+  Block,
+  CourseTarget,
+  DiagramGeometry,
+  Inline,
+  NotationEntry,
+  StaticPage,
+  TableCell,
+} from '../static-tree';
+
+/**
+ * Serialize explico's static reading tree to Markdown: GitHub's flavour, with
+ * `$…$` and `$$…$$` math for remark-math, KaTeX or MathJax (decisions D2, D3).
+ * It builds an mdast tree and lets `mdast-util-to-markdown` write it, so every
+ * character that means something to Markdown is escaped where it must be.
+ *
+ * What a reader of the file needs from the website comes along as text: each
+ * heading and float keeps its number, a display equation its `\tag{…}`, and
+ * every anchor an `<a id>` the links in the file land on. A reference into a
+ * page of the same download is a link into its file; any other goes to the
+ * website. The author's `\explain{key}{…}` markers are stripped from the
+ * math. Memos, notes, examples and checks are titled quotes, always open;
+ * Starlight's asides are GitHub alerts; each chapter ends with its
+ * references, its notation and the answers to its checks.
+ */
+
+export interface MarkdownChapterContext {
+  readonly page: StaticPage;
+  /** Every page of this download by route, with its file relative to this one (`''` for this file). */
+  readonly documentFiles: ReadonlyMap<string, string>;
+  /** Published course root, for links that leave the download. */
+  readonly canonicalBaseUrl?: string;
+  /** Picture files written for this page, by float anchor or image `src`, relative to this file. */
+  readonly pictures: ReadonlyMap<string, string>;
+  /** Answers of this page's checks, by assessment id, in authored order. */
+  readonly checkItems: ReadonlyMap<string, readonly CheckItem[]>;
+  /** Course title, version and the page's live URL, for the line under its title. */
+  readonly source?: { readonly course: string; readonly version?: string; readonly url?: string };
+}
+
+type Phrasing = PhrasingContent;
+
+const text = (value: string): Phrasing => ({ type: 'text', value });
+const html = (value: string): Phrasing => ({ type: 'html', value });
+const strong = (children: Phrasing[]): Phrasing => ({ type: 'strong', children });
+const emphasis = (children: Phrasing[]): Phrasing => ({ type: 'emphasis', children });
+const paragraph = (children: Phrasing[]): Paragraph => ({ type: 'paragraph', children });
+const link = (url: string, children: Phrasing[]): Phrasing => ({ type: 'link', url, children });
+const anchor = (id: string): Phrasing => html(`<a id="${id.replace(/"/gu, '&quot;')}"></a>`);
+
+/** Math for a Markdown renderer: plain TeX, the author's markers stripped. */
+function plainTex(tex: string): string {
+  return stripNotationMarkers(tex).trim();
+}
+
+/**
+ * A pipe ends a table cell even inside `$…$` (GitHub and remark-gfm split
+ * the row first), so math in a cell spells its bars as commands.
+ */
+function cellTex(tex: string): string {
+  return tex.replace(/\\\|/gu, '\\Vert ').replace(/\|/gu, '\\vert ');
+}
+
+/** The GitHub alert a Starlight aside becomes. */
+const ALERTS: Readonly<Record<string, string>> = {
+  note: 'NOTE',
+  tip: 'TIP',
+  caution: 'WARNING',
+  danger: 'CAUTION',
+};
+
+/** What a phrase says, without markup: a link's text, a caption's words. */
+function plainText(inlines: readonly Inline[]): string {
+  return inlines
+    .map((inline) => {
+      switch (inline.kind) {
+        case 'text':
+        case 'code':
+          return inline.value;
+        case 'math':
+          return plainTex(inline.tex);
+        case 'break':
+          return ' ';
+        case 'cite':
+          return `[${inline.number}]`;
+        case 'memoMark':
+          return inline.label;
+        default:
+          return 'children' in inline ? plainText(inline.children) : '';
+      }
+    })
+    .join('');
+}
+
+/** Each edge of a diagram as the boxes it joins: the nearest box to each end. */
+export function diagramEdges(geometry: DiagramGeometry): [number, number][] {
+  const nearest = ([x, y]: readonly [number, number]) => {
+    let best = -1;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    geometry.nodes.forEach((node, index) => {
+      const dx = Math.max(node.x - x, 0, x - (node.x + node.width));
+      const dy = Math.max(node.y - y, 0, y - (node.y + node.height));
+      const distance = Math.hypot(dx, dy);
+      if (distance < bestDistance) [best, bestDistance] = [index, distance];
+    });
+    return best;
+  };
+  return geometry.edges.flatMap((edge) => {
+    const start = edge[0];
+    const end = edge.at(-1);
+    if (!start || !end) return [];
+    const from = nearest(start);
+    const to = nearest(end);
+    return from === -1 || to === -1 || from === to ? [] : [[from, to] as [number, number]];
+  });
+}
+
+class MarkdownWriter {
+  private readonly route: string;
+  private readonly notationAnchors: Map<string, string>;
+
+  constructor(private readonly context: MarkdownChapterContext) {
+    this.route = context.page.route;
+    this.notationAnchors = new Map(context.page.notation.map((entry) => [entry.key, entry.anchor]));
+  }
+
+  /** The link to an anchor on a page: into its file when the download has it, else the website. */
+  private targetUrl(target: CourseTarget): string | undefined {
+    const file = this.context.documentFiles.get(target.route);
+    if (file !== undefined) {
+      if (!target.anchor) return file || '#';
+      return `${file}#${target.anchor}`;
+    }
+    const base = this.context.canonicalBaseUrl;
+    if (!base) return undefined;
+    return `${base}${target.route ? `${target.route}/` : ''}${target.anchor ? `#${target.anchor}` : ''}`;
+  }
+
+  inline(inline: Inline, inTable = false): Phrasing[] {
+    switch (inline.kind) {
+      case 'text':
+        return [text(inline.value)];
+      case 'emphasis':
+        return [emphasis(this.inlines(inline.children, inTable))];
+      case 'strong':
+        return [strong(this.inlines(inline.children, inTable))];
+      case 'superscript':
+        return [html('<sup>'), ...this.inlines(inline.children, inTable), html('</sup>')];
+      case 'subscript':
+        return [html('<sub>'), ...this.inlines(inline.children, inTable), html('</sub>')];
+      case 'code':
+        return [{ type: 'inlineCode', value: inline.value }];
+      case 'math': {
+        const tex = plainTex(inline.tex);
+        return tex ? [{ type: 'inlineMath', value: inTable ? cellTex(tex) : tex }] : [];
+      }
+      case 'break':
+        return inTable ? [html('<br>')] : [{ type: 'break' }];
+      case 'link':
+        return [link(inline.href, this.inlines(inline.children, inTable))];
+      case 'ref': {
+        const url = this.targetUrl(inline.target);
+        const children = this.inlines(inline.children, inTable);
+        return url ? [link(url, children)] : children;
+      }
+      case 'term': {
+        const target = this.notationAnchors.get(inline.key);
+        const children = this.inlines(inline.children, inTable);
+        return target ? [link(`#${target}`, children)] : children;
+      }
+      case 'cite':
+        return [link(`#${inline.anchor}`, [text(`[${inline.number}]`)])];
+      case 'memoMark':
+        return [html('<sup>'), link(`#${inline.anchor}`, [text(inline.label)]), html('</sup>')];
+      case 'noteMark':
+        return [link(`#${inline.anchor}`, this.inlines(inline.children, inTable))];
+    }
+  }
+
+  inlines(inlines: readonly Inline[], inTable = false): Phrasing[] {
+    return inlines.flatMap((inline) => this.inline(inline, inTable));
+  }
+
+  /** A choice's label, its math as math like the prompt's. */
+  private optionLabel(option: NonNullable<CheckItem['options']>[number]): Phrasing[] {
+    return option.labelSegments ? this.segments(option.labelSegments) : [text(option.label)];
+  }
+
+  private segments(segments: readonly ContentSegment[]): Phrasing[] {
+    return segments.flatMap((segment): Phrasing[] =>
+      segment.type === 'math' ? [{ type: 'inlineMath', value: plainTex(segment.latex) }] : [text(segment.value)],
+    );
+  }
+
+  /** A float's caption line: its number and short caption in bold, then the long one. */
+  private captionLine(label: string, block: { short?: string; caption: readonly Inline[] }, extra: readonly Inline[] = []): Phrasing[] {
+    const short = block.short?.trim();
+    const head = short ? `${label}. ${captionTitle(short)}` : `${label}.`;
+    const long = [...this.inlines(block.caption), ...(extra.length > 0 ? [text(' '), ...this.inlines(extra)] : [])];
+    return [strong([text(head)]), ...(long.length > 0 ? [text(' '), ...long] : [])];
+  }
+
+  private picture(key: string, alt: string): Phrasing | undefined {
+    const file = this.context.pictures.get(key);
+    return file ? { type: 'image', url: file, alt } : undefined;
+  }
+
+  private table(block: Extract<Block, { kind: 'table' }>): RootContent[] {
+    const rows = [...block.head, ...block.body];
+    const spans = rows.some((row) => row.some((cell) => cell.colspan > 1 || cell.rowspan > 1));
+    const caption = block.number
+      ? [paragraph([anchor(block.anchor), ...this.captionLine(`Table ${block.number}`, block)])]
+      : [];
+    if (spans) return [...caption, ...this.htmlTable(block)];
+    const columns = Math.max(0, ...rows.map((row) => row.length));
+    if (columns === 0) return caption;
+    const cell = (source: TableCell | undefined): MdTableCell => ({
+      type: 'tableCell',
+      children: source ? this.inlines(source.children, true) : [],
+    });
+    const row = (cells: readonly TableCell[]): TableRow => ({
+      type: 'tableRow',
+      children: Array.from({ length: columns }, (_, index) => cell(cells[index])),
+    });
+    const head = block.head[0] ?? [];
+    const firstBody = block.body[0] ?? head;
+    const table: Table = {
+      type: 'table',
+      align: Array.from({ length: columns }, (_, index) => (firstBody[index] ?? head[index])?.align ?? null),
+      children: [row(head), ...block.head.slice(1).map(row), ...block.body.map(row)],
+    };
+    return [...caption, table];
+  }
+
+  /**
+   * A table with spanning cells as HTML, which pipe tables cannot hold. Each
+   * cell's content stands on lines of its own, so Markdown (and its math)
+   * still reads it.
+   */
+  private htmlTable(block: Extract<Block, { kind: 'table' }>): RootContent[] {
+    const cellHtml = (cell: TableCell) => {
+      const tag = cell.header ? 'th' : 'td';
+      const attributes = [
+        ...(cell.colspan > 1 ? [`colspan="${cell.colspan}"`] : []),
+        ...(cell.rowspan > 1 ? [`rowspan="${cell.rowspan}"`] : []),
+        ...(cell.align ? [`align="${cell.align}"`] : []),
+      ];
+      const content = serializeNodes([paragraph(this.inlines(cell.children))]).trim();
+      return [`<${tag}${attributes.length > 0 ? ` ${attributes.join(' ')}` : ''}>`, '', content, '', `</${tag}>`];
+    };
+    const lines = [
+      '<table>',
+      ...block.head.flatMap((row) => ['<tr>', ...row.flatMap(cellHtml), '</tr>']),
+      ...block.body.flatMap((row) => ['<tr>', ...row.flatMap(cellHtml), '</tr>']),
+      '</table>',
+    ];
+    return [{ type: 'html', value: lines.join('\n') }];
+  }
+
+  /** A diagram's boxes and arrows as a list: what the picture shows, as text. */
+  private diagramText(geometry: DiagramGeometry): RootContent[] {
+    const label = (index: number): Phrasing[] => {
+      const node = geometry.nodes[index]!;
+      return [
+        ...(node.text ? [text(node.text)] : []),
+        ...(node.text && node.tex ? [text(' ')] : []),
+        ...(node.tex ? [{ type: 'inlineMath', value: plainTex(node.tex) } as Phrasing] : []),
+      ];
+    };
+    const edges = diagramEdges(geometry);
+    const joined = new Set(edges.flat());
+    const items: ListItem[] = [
+      ...edges.map(([from, to]): ListItem => ({
+        type: 'listItem',
+        spread: false,
+        children: [paragraph([...label(from), text(' → '), ...label(to)])],
+      })),
+      ...geometry.nodes
+        .map((_, index) => index)
+        .filter((index) => !joined.has(index))
+        .map((index): ListItem => ({ type: 'listItem', spread: false, children: [paragraph(label(index))] })),
+    ];
+    if (items.length === 0) return [];
+    return [
+      paragraph([emphasis([text('The diagram as text:')])]),
+      { type: 'list', ordered: false, spread: false, children: items },
+    ];
+  }
+
+  /** A titled quote: a memo, a short note, an example set, a check. */
+  private quote(title: Phrasing[], children: RootContent[], id?: string): RootContent {
+    return {
+      type: 'blockquote',
+      children: [paragraph([...(id ? [anchor(id)] : []), strong(title)]), ...(children as BlockContent[])],
+    };
+  }
+
+  private check(block: Extract<Block, { kind: 'check' }>): RootContent {
+    const items = this.context.checkItems.get(block.assessmentId) ?? [];
+    const questions: List = {
+      type: 'list',
+      ordered: true,
+      spread: false,
+      children: items.map((item): ListItem => ({
+        type: 'listItem',
+        spread: false,
+        children: [
+          paragraph(this.segments(item.promptSegments)),
+          ...(item.type === 'single-choice' && item.options && item.options.length > 0
+            ? [
+                {
+                  type: 'list',
+                  ordered: false,
+                  spread: false,
+                  children: item.options.map(
+                    (option, index): ListItem => ({
+                      type: 'listItem',
+                      spread: false,
+                      children: [
+                        paragraph([text(`(${String.fromCharCode(97 + index)}) `), ...this.optionLabel(option)]),
+                      ],
+                    }),
+                  ),
+                } satisfies List,
+              ]
+            : []),
+        ],
+      })),
+    };
+    return this.quote(
+      [text(`Knowledge check ${block.number}: `), ...this.inlines(block.title)],
+      [
+        ...(items.length > 0 ? [questions] : []),
+        paragraph([emphasis([text('Answers: '), link('#answers', [text('end of the chapter')]), text('.')])]),
+      ],
+      block.anchor,
+    );
+  }
+
+  block(block: Block, inBox = false): RootContent[] {
+    switch (block.kind) {
+      case 'heading': {
+        const content = [
+          ...(block.anchor ? [anchor(block.anchor)] : []),
+          ...(block.number ? [text(`${block.number} `)] : []),
+          ...this.inlines(block.children),
+        ];
+        if (inBox) return [paragraph([strong(content)])];
+        const depth = Math.min(Math.max(block.level, 2), 6) as 2 | 3 | 4 | 5 | 6;
+        return [{ type: 'heading', depth, children: content }];
+      }
+      case 'paragraph': {
+        const children = this.inlines(block.children);
+        return children.length > 0 ? [paragraph(children)] : [];
+      }
+      case 'list':
+        return [
+          {
+            type: 'list',
+            ordered: block.ordered,
+            ...(block.ordered && block.start ? { start: block.start } : {}),
+            spread: false,
+            children: block.items.map((item): ListItem => ({
+              type: 'listItem',
+              spread: false,
+              children: this.blocks(item, inBox) as (BlockContent | DefinitionContent)[],
+            })),
+          },
+        ];
+      case 'equation':
+        return [
+          paragraph([anchor(block.anchor)]),
+          { type: 'math', value: `${plainTex(block.tex)}\n\\tag{${block.number}}` },
+        ];
+      case 'displayMath':
+        return [{ type: 'math', value: plainTex(block.tex) }];
+      case 'figure': {
+        const alt =
+          block.alt ?? [block.short && captionTitle(block.short), plainText(block.caption)].filter(Boolean).join(' ');
+        const image = this.picture(block.anchor, alt || 'Figure');
+        const missing: Phrasing[] = [
+          emphasis([
+            text('Interactive figure'),
+            ...(this.context.canonicalBaseUrl
+              ? [text(': '), link(`${this.context.canonicalBaseUrl}${this.route}/#${block.anchor}`, [text('see it on the course website')])]
+              : []),
+            text('.'),
+          ]),
+        ];
+        return [
+          paragraph([anchor(block.anchor), ...(image ? [image] : missing)]),
+          paragraph(this.captionLine(`Figure ${block.number}`, block, block.live)),
+        ];
+      }
+      case 'diagram': {
+        const image = this.picture(block.anchor, block.short ?? plainText(block.caption) ?? 'Diagram');
+        return [
+          paragraph([anchor(block.anchor), ...(image ? [image] : [])]),
+          paragraph(this.captionLine(`Diagram ${block.number}`, block)),
+          ...this.diagramText(block.geometry),
+        ];
+      }
+      case 'table':
+        return this.table(block);
+      case 'memo':
+        return [
+          this.quote(
+            [text(`Memo ${block.label}: `), ...this.inlines(block.title)],
+            this.blocks(block.children, true),
+            block.anchor,
+          ),
+        ];
+      case 'note':
+        return [this.quote([text(block.title)], this.blocks(block.children, true), block.anchor)];
+      case 'aside': {
+        const title = this.inlines(block.title);
+        return [
+          {
+            type: 'blockquote',
+            children: [
+              paragraph([
+                html(`[!${ALERTS[block.variant] ?? 'NOTE'}]`),
+                ...(title.length > 0 ? [text('\n'), strong(title)] : []),
+              ]),
+              ...(this.blocks(block.children, true) as BlockContent[]),
+            ],
+          },
+        ];
+      }
+      case 'fold':
+        return [
+          ...(block.title && block.title.length > 0 ? [paragraph([strong(this.inlines(block.title))])] : []),
+          ...this.blocks(block.children, inBox),
+        ];
+      case 'examples':
+        return [
+          this.quote(
+            [text(`Example ${block.number}: `), ...this.inlines(block.title)],
+            block.items.flatMap((item) => [paragraph([strong(this.inlines(item.title))]), ...this.blocks(item.children, true)]),
+            block.anchor,
+          ),
+        ];
+      case 'check':
+        return [this.check(block)];
+      case 'quote':
+        return [{ type: 'blockquote', children: this.blocks(block.children, inBox) as BlockContent[] }];
+      case 'image': {
+        const image = this.picture(block.src, block.alt);
+        return image ? [paragraph([image])] : [];
+      }
+      case 'code':
+        return [{ type: 'code', value: block.value }];
+      case 'rule':
+        return [{ type: 'thematicBreak' }];
+      case 'references':
+        return [
+          { type: 'heading', depth: 2, children: [text('References')] },
+          {
+            type: 'list',
+            ordered: true,
+            start: Number.parseInt(block.items[0]?.number ?? '1', 10) || 1,
+            spread: false,
+            children: block.items.map((item): ListItem => ({
+              type: 'listItem',
+              spread: false,
+              children: [paragraph([anchor(item.anchor), ...this.inlines(item.children)])],
+            })),
+          },
+        ];
+    }
+  }
+
+  blocks(blocks: readonly Block[], inBox = false): RootContent[] {
+    return blocks.flatMap((block) => this.block(block, inBox));
+  }
+
+  notation(entries: readonly NotationEntry[], remarks: readonly (readonly Inline[])[]): RootContent[] {
+    if (entries.length === 0) return [];
+    return [
+      { type: 'heading', depth: 2, children: [text('Notation')] },
+      ...remarks.map((remark) => paragraph([emphasis(this.inlines(remark))])),
+      {
+        type: 'list',
+        ordered: false,
+        spread: false,
+        children: entries.map((entry): ListItem => {
+          const symbol = entry.symbolTex ? plainTex(entry.symbolTex) : '';
+          const line: Phrasing[] = [
+            anchor(entry.anchor),
+            ...(symbol ? [{ type: 'inlineMath', value: symbol } as Phrasing, text(' ')] : []),
+            strong([...this.inlines(entry.label), text('.')]),
+            ...(entry.summary.length > 0 ? [text(' '), ...this.inlines(entry.summary)] : []),
+            ...(entry.units ? [text(' '), emphasis([text('Units:')]), text(' '), ...this.inlines(entry.units), text('.')] : []),
+          ];
+          return {
+            type: 'listItem',
+            spread: false,
+            children: [
+              paragraph(line),
+              ...(entry.formulaTex ? [{ type: 'math', value: plainTex(entry.formulaTex) } as BlockContent] : []),
+            ],
+          };
+        }),
+      },
+    ];
+  }
+
+  answers(checks: readonly Extract<Block, { kind: 'check' }>[]): RootContent[] {
+    if (checks.length === 0) return [];
+    return [
+      { type: 'heading', depth: 2, children: [anchor('answers'), text('Answers to the knowledge checks')] },
+      ...checks.flatMap((check): RootContent[] => {
+        const items = this.context.checkItems.get(check.assessmentId) ?? [];
+        return [
+          paragraph([
+            strong([link(`#${check.anchor}`, [text(`Knowledge check ${check.number}`)]), text(': '), ...this.inlines(check.title)]),
+          ]),
+          {
+            type: 'list',
+            ordered: true,
+            spread: false,
+            children: items.map((item): ListItem => {
+              const answer: Phrasing[] = [];
+              if (item.type === 'single-choice' && item.options) {
+                const index = item.options.findIndex((option) => option.id === item.correctOptionId);
+                if (index !== -1) {
+                  answer.push(
+                    strong([text(`(${String.fromCharCode(97 + index)}) `), ...this.optionLabel(item.options[index]!), text('.')]),
+                    text(' '),
+                  );
+                }
+              } else if (item.type === 'numeric' && item.answer) {
+                answer.push(
+                  strong([text(String(item.answer.value))]),
+                  text(` (accepted within ±${item.answer.tolerance}). `),
+                );
+              }
+              return { type: 'listItem', spread: false, children: [paragraph([...answer, ...this.segments(item.explanationSegments)])] };
+            }),
+          },
+        ];
+      }),
+    ];
+  }
+}
+
+function serializeNodes(children: RootContent[]): string {
+  const root: Root = { type: 'root', children };
+  return toMarkdown(root, {
+    bullet: '-',
+    emphasis: '*',
+    strong: '*',
+    fence: '`',
+    fences: true,
+    rule: '-',
+    listItemIndent: 'one',
+    incrementListMarker: true,
+    extensions: [gfmTableToMarkdown(), mathToMarkdown()],
+  });
+}
+
+/** Every check of a page, in reading order. */
+function checksOf(blocks: readonly Block[]): Extract<Block, { kind: 'check' }>[] {
+  const checks: Extract<Block, { kind: 'check' }>[] = [];
+  const visit = (list: readonly Block[]) => {
+    for (const block of list) {
+      if (block.kind === 'check') checks.push(block);
+      if (block.kind === 'list') block.items.forEach(visit);
+      if (block.kind === 'examples') block.items.forEach((item) => visit(item.children));
+      if ('children' in block && Array.isArray(block.children) && block.kind !== 'paragraph' && block.kind !== 'heading') {
+        visit(block.children as readonly Block[]);
+      }
+    }
+  };
+  visit(blocks);
+  return checks;
+}
+
+/** The Markdown of one page: its title, its body, references, notation and answers. */
+export function serializeMarkdownPage(
+  context: MarkdownChapterContext,
+  options: { readonly number?: string } = {},
+): string {
+  const writer = new MarkdownWriter(context);
+  const { page, source } = context;
+  const sourceLine: Phrasing[] = source
+    ? [
+        text('From '),
+        emphasis([text(source.course)]),
+        ...(source.version ? [text(`, version ${source.version}`)] : []),
+        text('.'),
+        ...(source.url ? [text(' Interactive version: '), link(source.url, [text(source.url)]), text('.')] : []),
+      ]
+    : [];
+  return serializeNodes([
+    {
+      type: 'heading',
+      depth: 1,
+      children: [anchor('_top'), ...(options.number ? [text(`${options.number} `)] : []), text(page.title)],
+    },
+    ...(sourceLine.length > 0 ? [paragraph(sourceLine)] : []),
+    ...writer.blocks(page.blocks),
+    ...writer.notation(page.notation, page.notationRemarks),
+    ...writer.answers(checksOf(page.blocks)),
+  ]);
+}
+
+/** Markdown of a few blocks of mdast, written the same way (for a download's `index.md`). */
+export function serializeMarkdownNodes(children: RootContent[]): string {
+  return serializeNodes(children);
+}