mostlyright-data 0.9.0__py3-none-any.whl

mostlyright/data_harness/nbrender/markdown_body.py

@@ -0,0 +1,477 @@
+"""Group C · markdown (C13) and the inline entity-chip hook (F29).
+
+Dispatched from ``document``.  A hand-written, escaping-safe mini-markdown engine renders
+prose — no markdown pip dependency — and every text run is escaped before any inline markup is
+re-introduced, so a ``<script>`` in the source can never survive.  Inline ``$…$`` hands off to
+``code_body.render_math``; ``[[type:id]]`` refs are split by :func:`parse.split_entity_refs` and
+each rendered through :func:`render_entity_chip`.
+
+Engine shape.  ``render_markdown`` splits the source into blocks (heading / hr / fenced code /
+blockquote / table / list / paragraph) on a line-oriented pass, then renders each block's text
+through :func:`_render_inline`.  The inline pass is escape-first: it isolates the constructs whose
+interior must NOT be re-interpreted (code spans, math, links, images), and every remaining plain
+run is escaped via :func:`parse.esc` before emphasis markers and entity chips are re-introduced.
+Raw HTML in the source is therefore never passed through — it is escaped and shown verbatim.
+"""
+
+from __future__ import annotations
+
+import html
+import re
+
+from mostlyright.data_harness.nbrender import code_body
+from mostlyright.data_harness.nbrender.parse import (
+    Cell,
+    EntityRef,
+    RenderContext,
+    esc,
+    heading_text,
+    slugify,
+    split_entity_refs,
+)
+from mostlyright.data_harness.nbrender.status import is_status_column, render_status
+
+# F29 · the four entity types that earn a colored-dot chip; any other type renders as plain text.
+_KNOWN_ENTITY_TYPES = ("station", "dataset", "run", "source")
+
+# --- block classifiers ------------------------------------------------------------------------
+# atx heading; deeper levels are capped at h4 because the type scale only defines h1-h4.
+_HEADING_RE = re.compile(r"^(#{1,6})\s+(.*?)\s*#*\s*$")
+# thematic break: three or more of the same -, * or _, spaces allowed between.
+_HR_RE = re.compile(r"^ {0,3}([-*_])(?: *\1){2,} *$")
+# fenced code opener: three or more backticks or tildes, optional info string.
+_FENCE_RE = re.compile(r"^ {0,3}(`{3,}|~{3,})\s*([^`]*)$")
+# list item: optional indent, a bullet or ordered marker, then content.
+_LIST_RE = re.compile(r"^(\s*)([-*+]|\d{1,9}[.)])\s+(.*)$")
+# blockquote line: one > and an optional single space.
+_QUOTE_RE = re.compile(r"^ {0,3}>\s?(.*)$")
+# blockquote attribution -> <footer>: an em dash (U+2014) or a double hyphen, then text.
+_FOOTER_RE = re.compile("^(?:\\u2014|--)\\s+(.*)$")
+# a table body cell counts as numeric (right-aligned) when it matches this.
+_NUMERIC_RE = re.compile(r"^[-+]?\$?\d[\d,]*(?:\.\d+)?%?$")
+
+# --- inline scanner ---------------------------------------------------------------------------
+# One alternative per construct, each a single named group with no capturing subgroups, so
+# ``match.lastgroup`` names the construct.  The URL alternative permits one level of balanced
+# parens so ``(javascript:alert(1))`` is consumed whole and never leaks a trailing ``)``.
+# Interiors are re-parsed by ``_PARTS`` below.
+_URL = r"\((?:[^()]|\([^()]*\))*\)"
+_INLINE_RE = re.compile(
+    r"(?P<disp>\$\$.+?\$\$)"
+    r"|(?P<imath>\$(?!\s)[^$\n]+?(?<!\s)\$)"
+    r"|(?P<code>`[^`\n]+`)"
+    r"|(?P<image>!\[[^\]]*\]" + _URL + r")"
+    r"|(?P<link>\[[^\]]*\]" + _URL + r")",
+    re.DOTALL,
+)
+# alt/text in group 1, the raw parenthesized target in group 2 (first token is the URL).
+_PARTS = re.compile(r"^!?\[([^\]]*)\]\((.*)\)$", re.DOTALL)
+
+# standalone-block forms of image and display math (a paragraph that is nothing else).
+_STANDALONE_IMG_RE = re.compile(r"^!\[([^\]]*)\]" + _URL + r"$")
+_STANDALONE_MATH_RE = re.compile(r"^\$\$(.+?)\$\$$", re.DOTALL)
+
+# schemes an image src may carry; anything else falls back to the alt caption (no external fetch).
+_SCHEME_RE = re.compile(r"^[a-z][a-z0-9+.\-]*:")
+
+
+def render_markdown(cell: Cell, ctx: RenderContext) -> str:
+    """C13 · markdown — headings, lists, tables, blockquotes, inline code, links, images, math."""
+    return f'<div class="nb-md">{_render_blocks(cell.source, ctx)}</div>'
+
+
+def render_entity_chip(ref: EntityRef, ctx: RenderContext) -> str:
+    """F29 · entity chip — inline mono chip with type-colored dot. Static: no popover.
+
+    The dot conveys the entity type; the chip text is the id.  A type outside the four known
+    kinds carries no styling class, so it renders as plain escaped text rather than an unstyled
+    chip.
+    """
+    label = esc(ref.id)
+    if ref.type not in _KNOWN_ENTITY_TYPES:
+        return label
+    return (
+        f'<span class="nb-chip nb-chip--{ref.type}"><span class="nb-chip-dot"></span>{label}</span>'
+    )
+
+
+# --- block layer ------------------------------------------------------------------------------
+
+
+def _render_blocks(source: str, ctx: RenderContext) -> str:
+    lines = source.replace("\r\n", "\n").replace("\r", "\n").split("\n")
+    parts: list[str] = []
+    i = 0
+    n = len(lines)
+    while i < n:
+        line = lines[i]
+        if line.strip() == "":
+            i += 1
+            continue
+
+        fence = _FENCE_RE.match(line)
+        if fence:
+            i, block = _consume_fence(lines, i, fence.group(1)[0])
+            parts.append(block)
+            continue
+
+        heading = _HEADING_RE.match(line)
+        if heading:
+            level = min(len(heading.group(1)), 4)
+            # Emit a stable id so the A04 outline's ``#slug`` anchors resolve — the slug is derived
+            # from the SAME shared helpers chrome.py uses, so the two always agree.
+            slug = esc(slugify(heading_text(heading.group(2))))
+            parts.append(
+                f'<h{level} id="{slug}">{_render_inline(heading.group(2), ctx)}</h{level}>'
+            )
+            i += 1
+            continue
+
+        if _HR_RE.match(line):
+            parts.append("<hr>")
+            i += 1
+            continue
+
+        if _QUOTE_RE.match(line):
+            buf = []
+            while i < n and _QUOTE_RE.match(lines[i]):
+                buf.append(_QUOTE_RE.match(lines[i]).group(1))
+                i += 1
+            parts.append(_render_blockquote(buf, ctx))
+            continue
+
+        if _is_table_header(lines, i):
+            header, sep = lines[i], lines[i + 1]
+            i += 2
+            body = []
+            while (
+                i < n and lines[i].strip() != "" and "|" in lines[i] and not _starts_block(lines, i)
+            ):
+                body.append(lines[i])
+                i += 1
+            parts.append(_render_table(header, sep, body, ctx))
+            continue
+
+        if _LIST_RE.match(line):
+            buf = []
+            while i < n and lines[i].strip() != "":
+                if _LIST_RE.match(lines[i]) or lines[i].startswith((" ", "\t")):
+                    buf.append(lines[i])
+                    i += 1
+                else:
+                    break
+            parts.append(_render_list(buf, ctx))
+            continue
+
+        buf = []
+        while i < n and lines[i].strip() != "" and not _starts_block(lines, i):
+            buf.append(lines[i])
+            i += 1
+        parts.append(_render_paragraph(buf, ctx))
+    return "".join(parts)
+
+
+def _starts_block(lines: list[str], i: int) -> bool:
+    """True when line ``i`` opens a non-paragraph block, so paragraph/table collection stops."""
+    if i >= len(lines):
+        return False
+    line = lines[i]
+    if line.strip() == "":
+        return True
+    if (
+        _HEADING_RE.match(line)
+        or _HR_RE.match(line)
+        or _FENCE_RE.match(line)
+        or _QUOTE_RE.match(line)
+        or _LIST_RE.match(line)
+    ):
+        return True
+    return _is_table_header(lines, i)
+
+
+def _consume_fence(lines: list[str], i: int, fence_char: str) -> tuple[int, str]:
+    close = re.compile(r"^ {0,3}" + re.escape(fence_char) + r"{3,}\s*$")
+    i += 1
+    buf: list[str] = []
+    while i < len(lines):
+        if close.match(lines[i]):
+            i += 1
+            break
+        buf.append(lines[i])
+        i += 1
+    # Fenced code is a paper-ground panel; its interior is escaped verbatim, never re-parsed.
+    return i, f'<pre class="nb-md-fence">{esc(chr(10).join(buf))}</pre>'
+
+
+def _render_paragraph(lines: list[str], ctx: RenderContext) -> str:
+    raw = " ".join(part.strip() for part in lines).strip()
+    if not raw:
+        return ""
+    math = _STANDALONE_MATH_RE.match(raw)
+    if math:
+        return _call_math(math.group(1).strip(), raw, ctx, display=True)
+    image = _STANDALONE_IMG_RE.match(raw)
+    if image:
+        parts = _PARTS.match(raw)
+        return _render_image(parts.group(1), _first_url(parts.group(2)), block=True)
+    # A paragraph may contain a block-level inline result (a math well, since C14 renders even
+    # inline math as a display well).  Emit those blocks between <p> runs so no block nests in a
+    # <p>; consecutive inline fragments group into one paragraph.
+    out: list[str] = []
+    buffer: list[str] = []
+
+    def flush() -> None:
+        text = "".join(buffer).strip()
+        buffer.clear()
+        if text:
+            out.append(f"<p>{text}</p>")
+
+    for is_block, fragment in _inline_segments(raw, ctx):
+        if is_block:
+            flush()
+            out.append(fragment)
+        else:
+            buffer.append(fragment)
+    flush()
+    return "".join(out)
+
+
+def _render_blockquote(lines: list[str], ctx: RenderContext) -> str:
+    body: list[str] = []
+    footer: str | None = None
+    for line in lines:
+        match = _FOOTER_RE.match(line.strip())
+        if match is not None:
+            footer = match.group(1)
+        else:
+            body.append(line)
+    text = " ".join(part.strip() for part in body).strip()
+    html_out = f"<blockquote>{_render_inline(text, ctx)}"
+    if footer is not None:
+        html_out += f"<footer>{_render_inline(footer, ctx)}</footer>"
+    return html_out + "</blockquote>"
+
+
+def _render_list(lines: list[str], ctx: RenderContext) -> str:
+    items: list[dict] = []
+    for line in lines:
+        match = _LIST_RE.match(line)
+        if match is None:
+            if items:
+                items[-1]["content"] += " " + line.strip()
+            continue
+        indent = len(match.group(1).expandtabs(4))
+        ordered = match.group(2)[0].isdigit()
+        content = match.group(3)
+        if indent >= 2 and items:
+            items[-1]["subs"].append({"ordered": ordered, "content": content})
+        else:
+            items.append({"ordered": ordered, "content": content, "subs": []})
+    if not items:
+        return ""
+    tag = "ol" if items[0]["ordered"] else "ul"
+    out = [f"<{tag}>"]
+    for item in items:
+        out.append(f"<li>{_render_inline(item['content'], ctx)}")
+        subs = item["subs"]
+        if subs:
+            subtag = "ol" if subs[0]["ordered"] else "ul"
+            out.append(f"<{subtag}>")
+            for sub in subs:
+                out.append(f"<li>{_render_inline(sub['content'], ctx)}</li>")
+            out.append(f"</{subtag}>")
+        out.append("</li>")
+    out.append(f"</{tag}>")
+    return "".join(out)
+
+
+def _render_table(header: str, sep: str, body: list[str], ctx: RenderContext) -> str:
+    headers = _split_row(header)
+    ncol = len(headers)
+    rows = [_split_row(line) for line in body]
+    numeric = []
+    for col in range(ncol):
+        vals = [row[col] for row in rows if col < len(row) and row[col] != ""]
+        numeric.append(bool(vals) and all(_NUMERIC_RE.match(value) for value in vals))
+    head_cells = "".join(f"<th>{_render_inline(cell, ctx)}</th>" for cell in headers)
+    body_rows = []
+    for row in rows:
+        cells = []
+        for col in range(ncol):
+            value = row[col] if col < len(row) else ""
+            klass = ' class="nb-num"' if numeric[col] else ""
+            status = render_status(value) if is_status_column(headers[col]) else None
+            cells.append(f"<td{klass}>{status or _render_inline(value, ctx)}</td>")
+        body_rows.append(f"<tr>{''.join(cells)}</tr>")
+    return (
+        '<table class="nb-md-table">'
+        f"<thead><tr>{head_cells}</tr></thead>"
+        f"<tbody>{''.join(body_rows)}</tbody></table>"
+    )
+
+
+def _is_table_header(lines: list[str], i: int) -> bool:
+    """A table is a ``|`` header row followed by a ``|`` delimiter row of dashes."""
+    if i + 1 >= len(lines):
+        return False
+    if "|" not in lines[i] or "|" not in lines[i + 1]:
+        return False
+    return _is_table_sep(lines[i + 1])
+
+
+def _is_table_sep(line: str) -> bool:
+    cells = _split_row(line)
+    return bool(cells) and all(re.fullmatch(r":?-{1,}:?", cell) for cell in cells)
+
+
+def _split_row(line: str) -> list[str]:
+    text = line.strip()
+    if text.startswith("|"):
+        text = text[1:]
+    if text.endswith("|"):
+        text = text[:-1]
+    cells: list[str] = []
+    current: list[str] = []
+    index = 0
+    while index < len(text):
+        character = text[index]
+        if character == "\\" and index + 1 < len(text) and text[index + 1] in {"\\", "|"}:
+            current.append(text[index + 1])
+            index += 2
+            continue
+        if character == "|":
+            cells.append("".join(current).strip())
+            current = []
+        else:
+            current.append(character)
+        index += 1
+    cells.append("".join(current).strip())
+    return cells
+
+
+# --- inline layer -----------------------------------------------------------------------------
+
+
+def _render_inline(text: str, ctx: RenderContext) -> str:
+    """Inline HTML for a flow context (heading/list/table/blockquote) — segments joined flat."""
+    return "".join(fragment for _, fragment in _inline_segments(text, ctx))
+
+
+def _inline_segments(text: str, ctx: RenderContext) -> list[tuple[bool, str]]:
+    """Scan ``text`` into (is_block, html) fragments.
+
+    Only math can be a block: C14 renders it as a display well.  ``is_block`` is decided from the
+    returned markup, so if C14 ever yields a truly inline span the fragment stays inline.
+    """
+    out: list[tuple[bool, str]] = []
+    pos = 0
+    for match in _INLINE_RE.finditer(text):
+        if match.start() > pos:
+            out.append((False, _render_text_run(text[pos : match.start()], ctx)))
+        kind = match.lastgroup
+        token = match.group()
+        if kind == "disp":
+            fragment = _call_math(token[2:-2].strip(), token, ctx, display=True)
+            out.append((_is_block_markup(fragment), fragment))
+        elif kind == "imath":
+            fragment = _call_math(token[1:-1].strip(), token, ctx, display=False)
+            out.append((_is_block_markup(fragment), fragment))
+        elif kind == "code":
+            out.append((False, f"<code>{esc(token[1:-1])}</code>"))
+        elif kind == "image":
+            parts = _PARTS.match(token)
+            image = _render_image(parts.group(1), _first_url(parts.group(2)), block=False)
+            out.append((False, image))
+        elif kind == "link":
+            parts = _PARTS.match(token)
+            out.append((False, _render_link(parts.group(1), _first_url(parts.group(2)), ctx)))
+        pos = match.end()
+    if pos < len(text):
+        out.append((False, _render_text_run(text[pos:], ctx)))
+    return out
+
+
+_BLOCK_TAGS = ("<div", "<p", "<pre", "<table", "<blockquote", "<ul", "<ol")
+
+
+def _is_block_markup(fragment: str) -> bool:
+    return fragment.lstrip().startswith(_BLOCK_TAGS)
+
+
+def _first_url(target: str) -> str:
+    """The URL from a link/image target, dropping any optional ``"title"`` after whitespace."""
+    target = target.strip()
+    return target.split(None, 1)[0] if target else ""
+
+
+def _render_text_run(text: str, ctx: RenderContext) -> str:
+    """A plain run: split out entity chips, escape the rest, then re-introduce emphasis."""
+    out: list[str] = []
+    for segment in split_entity_refs(text):
+        if isinstance(segment, EntityRef):
+            out.append(render_entity_chip(segment, ctx))
+        else:
+            out.append(_emphasize(esc(segment)))
+    return "".join(out)
+
+
+def _emphasize(escaped: str) -> str:
+    """Apply bold/italic to already-escaped text (markers survive escaping; content stays safe)."""
+    escaped = re.sub(r"\*\*(\S.*?\S|\S)\*\*", r"<strong>\1</strong>", escaped)
+    escaped = re.sub(r"(?<![\w*])__(\S.*?\S|\S)__(?![\w*])", r"<strong>\1</strong>", escaped)
+    escaped = re.sub(r"(?<!\*)\*(?!\s)([^*]+?)(?<!\s)\*(?!\*)", r"<em>\1</em>", escaped)
+    escaped = re.sub(r"(?<![\w_])_(?!\s)([^_]+?)(?<!\s)_(?![\w_])", r"<em>\1</em>", escaped)
+    return escaped
+
+
+def _render_link(text: str, url: str, ctx: RenderContext) -> str:
+    inner = _render_text_run(text, ctx)
+    if _href_dangerous(url):
+        # Neutralized: drop the anchor, keep the visible (escaped) text.
+        return inner
+    return f'<a href="{esc(url.strip())}">{inner}</a>'
+
+
+def _href_dangerous(url: str) -> bool:
+    """True for script-bearing hrefs, after unwrapping entity obfuscation and whitespace.
+
+    Order matters: decode HTML entities first so ``java&#09;script:`` becomes ``java<tab>script:``,
+    then remove the whitespace/control the browser itself strips, leaving a bare ``javascript:``.
+    """
+    decoded = html.unescape(url)
+    collapsed = re.sub(r"[\x00-\x20]+", "", decoded).lower()
+    return (
+        collapsed.startswith("javascript:")
+        or collapsed.startswith("vbscript:")
+        or collapsed.startswith("data:text/html")
+    )
+
+
+def _render_image(alt: str, src: str, *, block: bool) -> str:
+    if _img_src_allowed(src):
+        return f'<img src="{esc(src.strip())}" alt="{esc(alt)}">'
+    # Blocked src (external fetch) or missing src: the alt text becomes the caption.
+    caption = esc(alt) if alt.strip() else "image unavailable"
+    tag = "div" if block else "span"
+    return f'<{tag} class="nb-md-caption">{caption}</{tag}>'
+
+
+def _img_src_allowed(src: str) -> bool:
+    """Only inline ``data:image/`` blobs and relative paths render; external URLs do not."""
+    text = src.strip()
+    if not text:
+        return False
+    lowered = text.lower()
+    if lowered.startswith("data:image/"):
+        return True
+    if _SCHEME_RE.match(lowered) or text.startswith("//"):
+        return False
+    return True
+
+
+def _call_math(tex: str, raw: str, ctx: RenderContext, *, display: bool) -> str:
+    """Hand off to C14, falling back to the escaped TeX source if it is unimplemented."""
+    try:
+        return code_body.render_math(tex, ctx, display=display)
+    except NotImplementedError:
+        return f"<p>{esc(raw)}</p>" if display else esc(raw)

mostlyright/data_harness/nbrender/mr_components.py

@@ -0,0 +1,134 @@
+"""Group F · Mostly Right components (F27, F28): provenance callout and leakage warning.
+
+Dispatched from ``document.render_notebook`` (the F29 entity chip is an inline markdown hook in
+``markdown_body``).  Both render only when their metadata block is present: F27 from
+``notebook.metadata.mostlyright.provenance``, F28 from ``notebook.metadata.mostlyright.leakage[]``.
+A leakage entry is placed by ``document`` after the cell it references.  Escape every key and value
+from the metadata JSON; the leakage body permits only inline ``code`` spans, nothing else.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+from mostlyright.data_harness.nbrender.parse import Notebook, RenderContext, esc
+
+# Sanctioned middot separator (U+00B7), used to detect a secondary tail in a provenance value.
+_MIDDOT = "·"
+
+# Provenance fields: metadata key -> displayed label.  Rendered in this order; a field
+# whose value is absent or empty is skipped so the grid never shows a labelled blank.
+_PROV_FIELDS: tuple[tuple[str, str], ...] = (
+    ("source", "Source identity"),
+    ("join", "Join"),
+    ("revision", "Revision"),
+    ("cache", "Cache"),
+)
+
+# A trailing parenthetical (the short sha) is the secondary part of a value; ``re.DOTALL`` off so a
+# newline never leaks into the match.
+_PAREN_TAIL_RE = re.compile(r"^(.*\S)\s+(\([^()]*\))\s*$")
+
+# Inline code spans in a leakage message.  Everything outside a span is escaped plain text; the span
+# contents are escaped too, so the only markup this body ever introduces is ``<code>``.
+_INLINE_CODE_RE = re.compile(r"`([^`]*)`")
+
+
+def _prov_mark(size: int = 15) -> str:
+    """The 15px brand mark with every facet the yellow token (F27 header)."""
+    return (
+        f'<svg width="{size}" height="{size}" viewBox="0 0 26 26" '
+        'aria-hidden="true" focusable="false">'
+        '<rect x="0" y="0" width="11" height="11" rx="2" fill="var(--nb-yellow)"></rect>'
+        '<rect x="15" y="0" width="11" height="11" rx="2" fill="var(--nb-yellow)"></rect>'
+        '<rect x="0" y="15" width="11" height="11" rx="2" fill="var(--nb-yellow)"></rect>'
+        '<rect x="15" y="15" width="11" height="11" rx="2" fill="var(--nb-yellow)"></rect>'
+        "</svg>"
+    )
+
+
+def _split_secondary(value: str) -> tuple[str, str]:
+    """Split a value into its primary text and a dimmed secondary tail (short sha or middot suffix).
+
+    ``r7 (a1b2c3d)`` -> ``("r7", "(a1b2c3d)")``; ``warm · 4m ago`` -> ``("warm", "· 4m ago")``; a
+    value with neither shape stays whole.
+    """
+    match = _PAREN_TAIL_RE.match(value)
+    if match:
+        return match.group(1), match.group(2)
+    sep = f" {_MIDDOT} "
+    if sep in value:
+        head, _, tail = value.partition(sep)
+        return head, f"{_MIDDOT} {tail}"
+    return value, ""
+
+
+def _prov_field(label: str, value: Any) -> str:
+    """One grid cell: mono key over mono value, with any secondary tail dimmed.  Classless wrapper
+    so key and value stack inside a single ``nb-prov-grid`` cell."""
+    primary, secondary = _split_secondary(str(value))
+    val = '<div class="nb-prov-val">' + esc(primary)
+    if secondary:
+        val += ' <span class="nb-prov-sub">' + esc(secondary) + "</span>"
+    val += "</div>"
+    return "<div>" + '<div class="nb-prov-key">' + esc(label) + "</div>" + val + "</div>"
+
+
+def render_provenance(nb: Notebook, ctx: RenderContext) -> str:
+    """F27 · provenance callout — dark card, brand mark, source/join/revision/cache field grid.
+
+    Renders only when ``notebook.metadata.mostlyright.provenance`` is present; absent -> empty
+    string (no card).  Fields render in ``_PROV_FIELDS`` order; each value's short-sha / timestamp
+    tail is dimmed via ``nb-prov-sub``.  Every value is escaped at interpolation.
+    """
+    provenance = nb.provenance
+    if not provenance:
+        return ""
+    fields = [
+        _prov_field(label, provenance[key])
+        for key, label in _PROV_FIELDS
+        if provenance.get(key) not in (None, "")
+    ]
+    head = (
+        '<div class="nb-prov-head">'
+        + _prov_mark(15)
+        + '<span class="nb-prov-title">Provenance</span>'
+        "</div>"
+    )
+    grid = '<div class="nb-prov-grid">' + "".join(fields) + "</div>"
+    return '<div class="nb-prov">' + head + grid + "</div>"
+
+
+def _leak_body(message: str) -> str:
+    """Escape a leakage message, promoting only backtick spans to ``<code>`` (no other markup)."""
+    parts: list[str] = []
+    cursor = 0
+    for match in _INLINE_CODE_RE.finditer(message):
+        if match.start() > cursor:
+            parts.append(esc(message[cursor : match.start()]))
+        parts.append("<code>" + esc(match.group(1)) + "</code>")
+        cursor = match.end()
+    if cursor < len(message):
+        parts.append(esc(message[cursor:]))
+    return "".join(parts)
+
+
+def render_leakage(entry: dict[str, Any], ctx: RenderContext) -> str:
+    """F28 · leakage warning — warn-tinted callout, badge, body with inline code spans only.
+
+    ``document`` places this after the cell the entry's integer ``cell`` index names.  The body is
+    the entry's ``message``, escaped, with backtick spans rendered as inline ``code`` and nothing
+    else — no headings, links, or raw HTML survive.
+    """
+    message = entry.get("message")
+    body = _leak_body(str(message)) if message else ""
+    head = (
+        '<div class="nb-leak-head">'
+        '<span class="nb-leak-badge">!</span>'
+        '<span class="nb-leak-title">Leakage guard</span>'
+        "</div>"
+    )
+    return (
+        '<div class="nb-leak">' + head + '<div class="nb-leak-body">' + body + "</div>" + "</div>"
+    )