@panaversity/ksor 0.0.38 → 0.0.40

package/templates/scaffold/system/site/components/embed.tsx

@@ -0,0 +1,276 @@
+"use client";
+
+import { ExternalLink, Play } from "lucide-react";
+import { useCallback, useEffect, useRef, useState, type ReactElement } from "react";
+
+import { Button } from "@/components/ui/button";
+
+/**
+ * An interactive page the document points at.
+ *
+ * Authored as an ordinary link (see lib/embed-rule.ts); rendered here as a
+ * frame the reader loads by asking. The click is not politeness — the
+ * scaffold's browser test asserts ZERO external requests on a built page, and
+ * that guarantee is what makes this record work offline, behind a firewall,
+ * and without telling a third party which document someone is reading. An
+ * always-on frame would break it on every page carrying one.
+ *
+ * Two things the panel says out loud, because they are the reason for the
+ * click. It NAMES the host, so a reader consents to a party rather than to a
+ * button. And it says the page is not part of the record: an embed carries no
+ * provenance claim, cannot be cited, and can change under the document without
+ * anyone reviewing it. The link out is always there and costs nothing, because
+ * a plain `<a>` is not a request.
+ */
+
+/**
+ * A framed page may not scroll the document that hosts it.
+ *
+ * `scrollIntoView` scrolls EVERY ancestor scrolling box, and a frame's
+ * ancestors include the host page — so a page that auto-scrolls its own log
+ * throws the reader somewhere else entirely. Six of the seven sims this was
+ * built for do exactly that, and clicking one moved the page 5,807px (found
+ * live).
+ *
+ * The call still does its real job inside the frame; only the part that moved
+ * the host is undone, in the same task, so nothing is painted in between.
+ *
+ * Same-origin only, which is all it can be: a cross-origin frame's prototypes
+ * are not reachable, and it cannot scroll us either.
+ */
+function containScrolling(doc: Document | null): void {
+  const view = doc?.defaultView;
+  if (!view) return;
+  const proto = view.Element.prototype as Element & {
+    scrollIntoView: (...args: unknown[]) => void;
+    __ksorContained?: boolean;
+  };
+  if (proto.__ksorContained) return;
+  const native = proto.scrollIntoView;
+  proto.scrollIntoView = function contained(this: Element, ...args: unknown[]): void {
+    const { scrollX, scrollY } = window;
+    native.apply(this, args);
+    if (window.scrollX !== scrollX || window.scrollY !== scrollY) {
+      window.scrollTo(scrollX, scrollY);
+    }
+  };
+  proto.__ksorContained = true;
+}
+
+/**
+ * Close the gutter a framed page leaves around itself.
+ *
+ * A page that does not reset `body { margin }` keeps the user agent's 8px, and
+ * that band shows whatever is behind the frame — so a sim painted near-black
+ * sat inside a ring of near-white. Matching the colour instead was tried and
+ * does not work: these pages paint below the body, so `html`, `body` and even
+ * the wrapper all compute to transparent (measured on the one that has the
+ * gutter), and chasing the colour down the tree would be guesswork.
+ *
+ * Zeroing it is the honest fix, and it is what six of the seven sims already
+ * do in their own stylesheet — this only makes the seventh agree. Presentation
+ * of the frame is the host's to decide; the page's content is untouched.
+ */
+function closeGutter(doc: Document | null): void {
+  const body = doc?.body;
+  if (!body) return;
+  body.style.margin = "0";
+}
+
+export function Embed({
+  url,
+  host,
+  label,
+  owned,
+}: {
+  readonly url: string;
+  readonly host: string;
+  readonly label: string;
+  /** "true" when the page is carried IN the record and served from here. */
+  readonly owned?: string;
+}): ReactElement {
+  const [loaded, setLoaded] = useState(false);
+  const [height, setHeight] = useState<number | null>(null);
+  const frame = useRef<HTMLIFrameElement>(null);
+  const isOwned = owned === "true";
+
+  /**
+   * Fit the frame to the page it holds, so nothing scrolls in a box and no
+   * band of dead space sits under it.
+   *
+   * Measure the body's CHILDREN, never `documentElement.scrollHeight`. These
+   * pages set `min-height: 100vh`, and inside a frame the viewport IS the
+   * frame — so the document's scroll height is just the frame's own height
+   * echoed back, and a frame sized from it grows without bound. Watched that
+   * run away before the CSS explained it (2026-08-24). The children do not
+   * depend on the frame: measured across all seven sims of the record this was
+   * built for, each returned the same height at a 300px frame and a 1400px
+   * one.
+   *
+   * Possible at all only because a carried page is SAME-ORIGIN. A cross-origin
+   * frame refuses `contentDocument`, so it keeps the ratio box and this
+   * returns without touching anything.
+   */
+  const fit = useCallback((): void => {
+    let doc: Document | null = null;
+    try {
+      doc = frame.current?.contentDocument ?? null;
+    } catch {
+      return; // cross-origin: not ours to measure
+    }
+    const body = doc?.body;
+    if (!body) return;
+    // NOT `instanceof HTMLElement`. The elements inside a frame belong to the
+    // frame's realm, so they are instances of ITS HTMLElement and never of this
+    // one — the filter matched nothing, and the frame kept the ratio box while
+    // looking as though measuring had simply not helped (found live).
+    const blocks = [...body.children].filter(
+      (el): el is HTMLElement => typeof (el as HTMLElement).offsetHeight === "number",
+    );
+    if (blocks.length === 0) return;
+    const bottom = Math.max(...blocks.map((el) => el.offsetTop + el.offsetHeight));
+    // The body's own bottom edge, padding AND margin. A page that does not
+    // reset `body { margin }` keeps the user agent's 8px, and leaving the
+    // margin out left exactly that much overflowing — one scrollbar, on the
+    // one sim of seven whose stylesheet omits the reset (found live).
+    // `offsetTop` already carries the top margin.
+    const style = getComputedStyle(body);
+    const edge =
+      (Number.parseFloat(style.paddingBottom) || 0) + (Number.parseFloat(style.marginBottom) || 0);
+    const measured = Math.ceil(bottom + edge);
+    // GROW-ONLY. A running page changes height every beat — measured
+    // oscillating 504 to 562 on one sim — and following it exactly would
+    // shift everything below the frame while someone is reading. The high
+    // water mark costs a little slack after a shrink and never a scrollbar.
+    if (measured > 0)
+      setHeight((current) => (current === null ? measured : Math.max(current, measured)));
+  }, []);
+
+  const watcher = useRef<ResizeObserver | null>(null);
+
+  /**
+   * Measure on load, then keep watching — these pages animate, and some add a
+   * row per beat.
+   *
+   * Set up HERE rather than in an effect on `loaded`: that effect runs the
+   * moment the click flips the state, which is before the frame's document
+   * exists, so it observed an empty `about:blank` and never fired again (found
+   * live — the frame fitted once and then ignored everything).
+   *
+   * Watch the CHILDREN, not the body. The body's own box is pinned by the
+   * page's `min-height: 100vh` to exactly the frame, so it never reports a
+   * change.
+   */
+  const handleLoad = useCallback((): void => {
+    fit();
+    let doc: Document | null = null;
+    try {
+      doc = frame.current?.contentDocument ?? null;
+    } catch {
+      return;
+    }
+    containScrolling(doc);
+    closeGutter(doc);
+    const body = doc?.body;
+    if (!body || typeof ResizeObserver === "undefined") return;
+    watcher.current?.disconnect();
+    const observer = new ResizeObserver(fit);
+    for (const child of body.children) observer.observe(child);
+    watcher.current = observer;
+  }, [fit]);
+
+  useEffect(() => () => watcher.current?.disconnect(), []);
+
+  return (
+    <figure
+      // The measure, like every other figure in the document. Wider was tried
+      // twice — 64rem, then 56rem — and both read as a block that had stopped
+      // belonging to the text around it (owner, seen live). These pages are
+      // responsive and lay themselves out at whatever width they are given, so
+      // the measure costs them nothing.
+      className="not-prose my-8 w-full"
+    >
+      <div
+        // A ratio rather than a fixed height, so the frame scales with the
+        // measure. The floor is there because these pages are usually taller
+        // than they are wide, and a narrow window would otherwise letterbox
+        // an interactive thing down to a strip.
+        className={
+          // Before the click this is a card, and it should read as one. After
+          // it, the page inside brings its own surface — and the box's does
+          // not match it: a sim painted near-black arrived ringed in
+          // near-white, on every side the page did not fill.
+          //
+          // Fitting the WIDTH to the page was tried and cannot work: these
+          // pages are responsive, so narrowing the frame made them reflow
+          // narrower still, which left a fresh gap and, on one, a scrollbar
+          // (measured). A page that does not fill the width now simply sits on
+          // the page, which is the honest arrangement — it is the record's own
+          // figure, not a screenshot in a mount.
+          loaded
+            ? "relative w-full overflow-hidden rounded-lg"
+            : "relative w-full overflow-hidden rounded-lg border border-fd-border bg-fd-muted"
+        }
+        // The invitation is a card. Once the page is measured the height goes
+        // on the FRAME instead and this box wraps it: put on the box, the
+        // border is inside that height, so the frame came out two pixels short
+        // and every single embed carried a scrollbar (found live — content 862
+        // in a frame of 860). Until it is measured, and always for a frame we
+        // may not measure, a ratio with a floor.
+        style={
+          !loaded
+            ? { height: "14rem" }
+            : height === null
+              ? { aspectRatio: "16 / 10", minHeight: "26rem" }
+              : undefined
+        }
+      >
+        {loaded ? (
+          <iframe
+            ref={frame}
+            onLoad={handleLoad}
+            src={url}
+            title={label}
+            allowFullScreen
+            // The host learns that its page was opened, not which document of
+            // this record opened it.
+            referrerPolicy="no-referrer"
+            // Scripts, because the point of the page is that it runs. Not
+            // top-navigation, and not forms: a framed page may not steer the
+            // reader out of the record or collect anything from inside it.
+            sandbox="allow-scripts allow-same-origin allow-popups"
+            loading="lazy"
+            // Absolute only while the box owns the height, which is the ratio
+            // case. With a measured height the frame owns it and lays out in
+            // flow, so the box is exactly as tall as the page plus its border.
+            className={height === null ? "absolute inset-0 size-full" : "block w-full"}
+            style={height === null ? undefined : { height }}
+          />
+        ) : (
+          <div className="absolute inset-0 flex flex-col items-center justify-center gap-4 px-6 text-center">
+            <Play aria-hidden className="size-8 text-fd-muted-foreground" />
+            <Button onClick={() => setLoaded(true)}>{label}</Button>
+            <p className="max-w-sm text-xs text-fd-muted-foreground">
+              {isOwned
+                ? "Part of this record, served from this site. Nothing leaves your browser."
+                : `Runs on ${host}, and is not part of this record. Nothing is requested from there until you load it.`}
+            </p>
+          </div>
+        )}
+      </div>
+
+      <figcaption className="mt-2 flex items-center justify-between gap-3 text-xs text-fd-muted-foreground">
+        <span>{label}</span>
+        <a
+          href={url}
+          target="_blank"
+          rel="noreferrer"
+          className="inline-flex items-center gap-1 hover:text-fd-foreground"
+        >
+          {isOwned ? "Open on its own" : `Open on ${host}`}
+          <ExternalLink aria-hidden className="size-3" />
+        </a>
+      </figcaption>
+    </figure>
+  );
+}

package/templates/scaffold/system/site/components/governance.tsx

@@ -1,6 +1,7 @@
 import Link from "next/link";
 
 import { DocumentActions } from "@/components/document-actions";
+import { Clock } from "lucide-react";
 import type { ReactElement } from "react";
 
 import {
@@ -113,17 +114,24 @@ export function GovernanceMeta({
   governance,
   replaces = [],
   markdownUrl,
+  minutes,
 }: {
   governance: DocumentGovernance;
   /** Documents this one replaced — derived from the record, never declared. */
   replaces?: readonly Successor[];
   /** The document's markdown twin, offered beside its governance. */
   markdownUrl?: string;
+  /**
+   * How long the document takes to read, when this row is the only place for
+   * it — a document with a summary shows it on that view's own strip instead,
+   * because there the number belongs to the view you picked.
+   */
+  minutes?: number;
 }): ReactElement | null {
   const { owner, effective } = governance;
   const status = caveatStatus(governance.status);
   const bare = status === null && owner === null && effective === null && replaces.length === 0;
-  if (bare && markdownUrl === undefined) return null;
+  if (bare && markdownUrl === undefined && minutes === undefined) return null;
 
   return (
     <dl className="mb-7 flex flex-wrap items-baseline gap-x-8 gap-y-2.5 border-b border-fd-border pb-4">
@@ -199,6 +207,12 @@ export function GovernanceMeta({
           <DocumentActions href={markdownUrl} />
         </span>
       )}
+      {minutes === undefined ? null : (
+        <div className="ms-auto flex items-center gap-2 text-sm text-fd-muted-foreground">
+          <Clock aria-hidden className="size-3.5 shrink-0" />
+          <span>{minutes} min read</span>
+        </div>
+      )}
     </dl>
   );
 }

package/templates/scaffold/system/site/components/mdx.tsx

@@ -1,4 +1,7 @@
 import defaultMdxComponents from "fumadocs-ui/mdx";
+
+import { WrappableCodeBlock } from "@/components/code-block";
+import { Embed } from "@/components/embed";
 import { CodeBlockTabsTrigger } from "fumadocs-ui/components/codeblock";
 import { Tab, Tabs } from "fumadocs-ui/components/tabs";
 import type { MDXComponents } from "mdx/types";
@@ -32,9 +35,14 @@ export function getMDXComponents(components?: MDXComponents) {
     // here or a document whose page forgot to pass one serves a 500 rather
     // than a page without an aid.
     TeachingAid: () => null,
+    // A long line is the reader's to unwrap, per block — see
+    // components/code-block.tsx. Replaces fumadocs' own `pre`.
+    pre: WrappableCodeBlock,
+    // `rehypeEmbeds` (source.config.ts) rewrites a link titled `embed` into
+    // this; an unknown component fails the build, so it has to be in the map.
+    Embed,
     // `remarkCodeTab` (source.config.ts) rewrites consecutive fenced blocks
-    // that declare `tab="…"` into these, so they have to be in the map or the
-    // build fails on an unknown component rather than at authoring time.
+    // that declare `tab="…"` into these, for the same reason.
     Tabs,
     Tab,
     CodeBlockTabsTrigger: BrandedTabsTrigger,

package/templates/scaffold/system/site/components/record-views.tsx

@@ -146,23 +146,12 @@ export function RecordViews({
     [select, views],
   );
 
-  // No summary, so no tabs — but the strip row still carries the reading time.
-  // It sits here rather than up with the title because this row is about the
-  // reading you are ABOUT to do, and a lone line above the facts row read as
-  // floating between two things it belonged to neither of.
-  if (only) {
-    return (
-      <div className="ksor-views">
-        {documentMinutes === undefined ? null : (
-          <p className="mb-6 flex items-center justify-end gap-2 border-b border-fd-border pb-2.5 text-sm text-fd-muted-foreground">
-            <Clock aria-hidden className="size-3.5 shrink-0" />
-            <span>{documentMinutes} min read</span>
-          </p>
-        )}
-        {children}
-      </div>
-    );
-  }
+  // No summary, so no tabs — and so no strip. It used to keep the row anyway,
+  // for the reading time alone: a full-width rule under an empty band with one
+  // number at its far end, which is what most documents got, because most have
+  // no summary. The number moved to the governance row, where it sits with the
+  // document's other facts and needs no furniture of its own.
+  if (only) return <div className="ksor-views">{children}</div>;
 
   return (
     <div className="ksor-views">

package/templates/scaffold/system/site/lib/alert-rule.ts

@@ -0,0 +1,214 @@
+/**
+ * What makes a blockquote a CALLOUT: GitHub's alert syntax, unchanged.
+ *
+ *     > [!WARNING]
+ *     > A withdrawn document is still cited by answers that were given while
+ *     > it was published.
+ *
+ * The reason this syntax and not `:::warning`: a blockquote is CommonMark. The
+ * record is CommonMark by rule (critical rule 3 keeps `knowledge/` free of any
+ * grammar a plain markdown reader has to learn), and this one is already read
+ * by the two places a record is looked at OUTSIDE this site — GitHub renders it
+ * as a styled alert, and every other viewer renders an ordinary blockquote
+ * carrying a visible `[!WARNING]` label. Nobody is misled and nothing is lost.
+ * A `:::` directive is a grammar: it renders as the literal characters, and it
+ * would reach `/md/`, `llms.txt` and `llms-full.txt`, where an agent would have
+ * to know our dialect to read the record.
+ *
+ * The set is GitHub's five, exactly. Adding a sixth would mean a record that
+ * renders here and not there, which is the whole thing this choice buys.
+ *
+ * A LEAF: no imports, so the remark plugin and the tests share one rule.
+ */
+
+/**
+ * GitHub's marker -> the fumadocs Callout it becomes.
+ *
+ * `type` is one of fumadocs' `CalloutType` (`info` | `warn` | `error` |
+ * `success` | `warning` | `idea`); anything else renders as plain `info` with
+ * nothing going red, so these are checked against the shipped page.
+ *
+ * NOTE and IMPORTANT share `info` because fumadocs has no fifth colour, and
+ * inventing one would drift from GitHub. The `title` is what tells them apart,
+ * which is also how GitHub distinguishes them.
+ */
+export const ALERT_KINDS = [
+  { marker: "NOTE", type: "info", title: "Note" },
+  { marker: "TIP", type: "idea", title: "Tip" },
+  { marker: "IMPORTANT", type: "info", title: "Important" },
+  { marker: "WARNING", type: "warn", title: "Warning" },
+  { marker: "CAUTION", type: "error", title: "Caution" },
+] as const;
+
+export type AlertKind = (typeof ALERT_KINDS)[number];
+
+export interface AlertMatch {
+  readonly kind: AlertKind;
+  /** What is left of the leading text once the marker's own line is removed. */
+  readonly rest: string;
+}
+
+/**
+ * The alert this blockquote opens with, or null when it is an ordinary quote.
+ *
+ * `leadingText` is the value of the first text node of the blockquote's first
+ * paragraph — the marker has to be the very start of the quote, and has to be
+ * the WHOLE of its first line. Both are GitHub's rules, and following them is
+ * the point: a quote that renders as a callout here and as a quote there would
+ * make the site and the record disagree about the same bytes.
+ *
+ * Case-insensitive, because GitHub accepts `[!note]` and rendering it plain
+ * here would be exactly that disagreement.
+ */
+export function matchAlert(leadingText: string): AlertMatch | null {
+  if (!leadingText.startsWith("[!")) return null;
+
+  const close = leadingText.indexOf("]");
+  if (close === -1) return null;
+
+  const marker = leadingText.slice(2, close).toUpperCase();
+  const kind = ALERT_KINDS.find((entry) => entry.marker === marker);
+  if (!kind) return null;
+
+  const after = leadingText.slice(close + 1);
+  const newline = after.indexOf("\n");
+  const restOfLine = newline === -1 ? after : after.slice(0, newline);
+  // Anything else on the marker's line means the author wrote a quote that
+  // happens to start with a bracket, not an alert.
+  if (restOfLine.trim() !== "") return null;
+
+  return { kind, rest: newline === -1 ? "" : after.slice(newline + 1) };
+}
+
+/**
+ * The cases the rule is held to.
+ *
+ * A table rather than prose assertions, because the interesting half is what
+ * this must REFUSE: every refusal here is a blockquote an author wrote meaning
+ * a blockquote, and turning one into a coloured panel is a change to the
+ * record's meaning that nothing else would catch.
+ */
+export const ALERT_CASES = [
+  // The five, as GitHub documents them.
+  { text: "[!NOTE]\nThe record is the source of truth.", type: "info", title: "Note" },
+  { text: "[!TIP]\nStart at level 0.", type: "idea", title: "Tip" },
+  { text: "[!IMPORTANT]\nCitations pin a generation.", type: "info", title: "Important" },
+  { text: "[!WARNING]\nThis document is superseded.", type: "warn", title: "Warning" },
+  { text: "[!CAUTION]\nA takedown does not unsay an answer.", type: "error", title: "Caution" },
+  // Lowercase renders as an alert on GitHub, so it renders as one here.
+  { text: "[!note]\nStill an alert.", type: "info", title: "Note" },
+  { text: "[!Warning]\nStill an alert.", type: "warn", title: "Warning" },
+  // The marker alone, with the body in later nodes or later blocks.
+  { text: "[!NOTE]", type: "info", title: "Note" },
+  { text: "[!NOTE]\n", type: "info", title: "Note" },
+  // Trailing spaces on the marker's line are invisible; they may not decide.
+  { text: "[!NOTE]   \nBody.", type: "info", title: "Note" },
+  // Ordinary blockquotes, which must stay blockquotes.
+  { text: "A quote about something.", type: null, title: null },
+  { text: "[!NOTES]\nNot a marker.", type: null, title: null },
+  { text: "[!]\nEmpty marker.", type: null, title: null },
+  { text: "[NOTE]\nNo bang.", type: null, title: null },
+  { text: " [!NOTE]\nLeading space.", type: null, title: null },
+  { text: "[!NOTE\nUnclosed.", type: null, title: null },
+  // The marker has to own its line. Text beside it means the author quoted it.
+  { text: "[!NOTE] see below", type: null, title: null },
+  { text: "[!NOTE] see below\nBody.", type: null, title: null },
+] as const;
+
+/**
+ * The slice of hast this touches, written structurally rather than imported.
+ *
+ * `@types/hast` would be a dependency for five field names, and this only ever
+ * reads `type`/`tagName`, walks `children`, and edits the `value` of a text
+ * node. Typing what is used keeps this file a leaf.
+ */
+interface AlertNode {
+  type: string;
+  tagName?: string;
+  children?: AlertNode[];
+  value?: string;
+  name?: string;
+  attributes?: { type: "mdxJsxAttribute"; name: string; value: string }[];
+}
+
+/**
+ * The `<Callout>` this blockquote becomes, or null when it stays a blockquote.
+ *
+ * Mutates the quote's own first paragraph to drop the marker line — the marker
+ * is syntax, and leaving it in the rendered panel would show the reader the
+ * plumbing.
+ */
+function calloutFor(node: AlertNode): AlertNode | null {
+  if (node.type !== "element" || node.tagName !== "blockquote") return null;
+
+  // hast keeps the source's whitespace between block children, so the first
+  // paragraph is the first ELEMENT rather than the first child.
+  const paragraph = node.children?.find((child) => child.type === "element");
+  if (!paragraph || paragraph.tagName !== "p") return null;
+
+  const lead = paragraph.children?.[0];
+  if (!lead || lead.type !== "text" || typeof lead.value !== "string") return null;
+
+  const match = matchAlert(lead.value);
+  if (!match) return null;
+
+  if (match.rest === "") {
+    // The marker was the whole text node. Drop it, and drop the paragraph too
+    // when the marker was all it held — `> [!NOTE]` on a line of its own.
+    paragraph.children?.shift();
+    if (paragraph.children?.length === 0) {
+      node.children = node.children?.filter((child) => child !== paragraph);
+    }
+  } else {
+    lead.value = match.rest;
+  }
+
+  return {
+    type: "mdxJsxFlowElement",
+    name: "Callout",
+    attributes: [
+      { type: "mdxJsxAttribute", name: "type", value: match.kind.type },
+      { type: "mdxJsxAttribute", name: "title", value: match.kind.title },
+    ],
+    children: node.children ?? [],
+  };
+}
+
+/** Depth-first, so an alert nested inside a list or another quote converts. */
+function convertAlerts(node: AlertNode): void {
+  const children = node.children;
+  if (!children) return;
+
+  for (let i = 0; i < children.length; i++) {
+    const child = children[i];
+    if (!child) continue;
+    convertAlerts(child);
+    const callout = calloutFor(child);
+    if (callout) children[i] = callout;
+  }
+}
+
+/**
+ * REHYPE, deliberately — and this is the load-bearing half of the design.
+ *
+ * As a remark plugin this works and is wrong: fumadocs serializes the record's
+ * markdown from the mdast (`includeProcessedMarkdown` -> `remarkLLMs`), so a
+ * blockquote rewritten there reaches `/md/` and `llms-full.txt` as
+ * `<Callout type="warn" title="Warning">` — the agent surface served this
+ * site's React component in place of the author's blockquote. Measured, not
+ * assumed: that is exactly what the first build of this emitted.
+ *
+ * By the rehype phase the markdown is already captured, so the page gets the
+ * callout and every agent-facing surface keeps the record's own shape. This is
+ * product principle 2 — one source, two surfaces — and the reason the syntax
+ * is GitHub's rather than a directive in the first place.
+ *
+ * The cost, recorded because it is real: `remarkStructure` also runs in the
+ * remark phase, so the search index contains the literal `[!NOTE]` alongside
+ * the passage. Noise in one index is the cheaper half of this trade.
+ */
+export function rehypeGithubAlerts(): (tree: AlertNode) => void {
+  return (tree: AlertNode): void => {
+    convertAlerts(tree);
+  };
+}