mostlyright-data 0.9.0__py3-none-any.whl

mostlyright/data_harness/nbrender/frame.py

@@ -0,0 +1,275 @@
+"""Group B · cell frame (B06-B11): gutter prompt, states, hover toolbar, collapse, tags, meta.
+
+These are the chrome that wraps a cell body; the body itself is rendered by
+``code_body``/``markdown_body`` and the outputs by the ``outputs_*`` modules, then ``document``
+slots them into the 62px grid this group decorates.  State is expressed as box-shadow classes
+(B07), never borders, so a selection can never shift layout.  ``document`` calls
+:func:`render_prompt` for every cell and output row, :func:`cell_state_classes` and
+:func:`render_hover_toolbar` on code cells, :func:`render_exec_meta` when a cell has an execution
+count, and :func:`render_tags` on tagged markdown cells; :func:`render_collapse_bar` (B09) is a
+public helper with no call site in ``document``.
+
+Every class emitted here resolves against a rule in :func:`tokens.build_css`, including
+``.nb-panel-head-left`` (the language/tags group) and ``.nb-panel-head--static`` (the
+always-visible static toolbar).  No literal color, size, or font is written here — the
+design-system values live only in ``tokens``.  Every value interpolated from notebook JSON passes
+through :func:`parse.esc` at the point of interpolation.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mostlyright.data_harness.nbrender.parse import Cell, RenderContext, esc
+
+# --- B06 · gutter prompt ----------------------------------------------------------------------
+# The gutter prompt variants.  Key == the ``nb-prompt--<key>`` CSS modifier;
+# value is the literal glyph, with ``{n}`` the sole interpolation slot (the execution count).
+_PROMPT_LABEL: dict[str, str] = {
+    "in": "In [{n}]",  # executed code cell · cobalt
+    "running": "In [*]",  # running · orange + pulse
+    "idle": "In [ ]",  # never run · faint
+    "out": "Out [{n}]",  # execute_result / display_data · orange
+    "stream": "Out [*]",  # streaming · faint
+    "err": "Err",  # error output · rust
+    "wgt": "Wgt",  # widget output · faint
+    "md": "md",  # markdown cell · hairline
+    "raw": "raw",  # raw cell · hairline
+}
+
+
+def _derive_prompt(cell: Cell) -> tuple[str | None, int | None]:
+    """Pick the gutter variant for a cell from its type and execution state.
+
+    Output prompts (out/stream/err/wgt) and the live ``running`` state are not derivable from a
+    frozen cell — callers request them explicitly through ``variant``.
+    """
+    if cell.cell_type == "code":
+        if cell.execution_count is not None:
+            return "in", cell.execution_count
+        return "idle", None
+    if cell.cell_type == "markdown":
+        return "md", None
+    if cell.cell_type == "raw":
+        return "raw", None
+    return None, None
+
+
+def render_prompt(
+    cell: Cell,
+    ctx: RenderContext,
+    *,
+    variant: str | None = None,
+    count: int | None = None,
+) -> str:
+    """B06 · gutter prompt — one of the eight variants for the 62px column, excluded from copy.
+
+    With no ``variant`` the cell decides: executed code -> ``In [n]``, unrun code -> ``In [ ]``,
+    markdown -> ``md``, raw -> ``raw``.  Output prompts (``out``/``stream``/``err``/``wgt``) and the
+    live ``running`` state are requested explicitly by ``document`` when it re-enters an output into
+    the gutter column.  The span is ``aria-hidden`` so it stays out of the accessibility tree even
+    when placed outside the (already aria-hidden) gutter; copy-exclusion comes from the gutter's
+    ``user-select: none``.  An unknown cell type yields no prompt.
+    """
+    if variant is None:
+        variant, count = _derive_prompt(cell)
+    template = _PROMPT_LABEL.get(variant) if variant is not None else None
+    if template is None:
+        return ""
+    if "{n}" in template:
+        label = template.replace("{n}", esc(count) if count is not None else " ")
+    else:
+        label = template
+    return f'<span class="nb-prompt nb-prompt--{variant}" aria-hidden="true">{label}</span>'
+
+
+# --- B07 · cell states ------------------------------------------------------------------------
+# Live UI states (selected/editing/running) map to a box-shadow class on the code panel.  Only the
+# error state is derivable from frozen data — a cell carrying an error output always gets it.
+_STATE_CLASS: dict[str, str] = {
+    "selected": "is-selected",
+    "editing": "is-selected",  # panel reads selected; the gutter bar is a cell-level concern
+    "running": "is-running",
+}
+
+
+def cell_state_classes(cell: Cell, ctx: RenderContext, *, state: str | None = None) -> str:
+    """B07 · cell states — space-joined panel classes; ``''`` when resting.
+
+    Never emits a ``border`` class: state is box-shadow only so a selection cannot shift layout.
+    ``state`` names a live UI state (selected/editing/running) for connected mode; the error ring
+    is data-driven and combines with any live state.  Every returned token resolves against a
+    ``.nb-panel.is-*`` rule, so the fragment is safe to concatenate onto the panel's class list.
+    """
+    classes: list[str] = []
+    live = _STATE_CLASS.get(state) if state is not None else None
+    if live is not None:
+        classes.append(live)
+    if any(out.kind == "error" for out in cell.outputs):
+        classes.append("is-error")
+    return " ".join(classes)
+
+
+# --- B08 · hover toolbar ----------------------------------------------------------------------
+_COPY_BTN = '<button class="nb-panel-btn" type="button">copy</button>'
+_RUN_BTN = '<button class="nb-panel-btn" type="button">run</button>'
+_FOLD_BTN = '<button class="nb-panel-btn" type="button">fold</button>'
+_INTERRUPT_BTN = (
+    '<button class="nb-panel-btn nb-panel-btn--interrupt" type="button">interrupt</button>'
+)
+
+
+def render_hover_toolbar(
+    cell: Cell,
+    ctx: RenderContext,
+    *,
+    running: bool = False,
+    language: str = "python",
+) -> str:
+    """B08 · hover toolbar — panel header with the language label, cell tags, and ghost actions.
+
+    Left group is the language label plus the B10 tag chips.  Right group is the action set:
+    connected mode shows ``copy`` / ``run`` / ``fold`` (``run`` becomes ``interrupt`` while the
+    cell runs); static and embed modes show ``copy`` only and stay visible without a hover via the
+    ``--static`` modifier.  Opacity/hover behaviour lives entirely in the stylesheet.
+    """
+    left = (
+        '<div class="nb-panel-head-left">'
+        f'<span class="nb-panel-lang">{esc(language)}</span>'
+        f"{render_tags(cell, ctx)}"
+        "</div>"
+    )
+    if ctx.mode == "connected":
+        run = _INTERRUPT_BTN if running else _RUN_BTN
+        actions = _COPY_BTN + run + _FOLD_BTN
+        head_class = "nb-panel-head"
+    else:
+        actions = _COPY_BTN
+        head_class = "nb-panel-head nb-panel-head--static"
+    right = f'<div class="nb-panel-actions">{actions}</div>'
+    return f'<div class="{head_class}">{left}{right}</div>'
+
+
+# --- B09 · collapse affordances ---------------------------------------------------------------
+def _int_or_zero(value: Any) -> int:
+    """Coerce a hidden-line count to a non-negative int; anything malformed reads as zero."""
+    if isinstance(value, bool) or not isinstance(value, int):
+        return 0
+    return max(0, value)
+
+
+def render_collapse_bar(cell: Cell, ctx: RenderContext, *, hidden_lines: int, kind: str) -> str:
+    """B09 · collapse affordance — dashed bar for a folded input or output.
+
+    ``kind`` is ``input`` (``metadata.jupyter.source_hidden``) or ``output``
+    (``metadata.jupyter.outputs_hidden``); ``hidden_lines`` is the caller's line count.  A folded
+    input reading ``hide-input`` also surfaces that tag chip.  The bar is a full-width button; in
+    static mode it is an inert affordance.
+    """
+    count = _int_or_zero(hidden_lines)
+    if kind == "output":
+        text = f"output hidden · {count} lines"
+        chip = ""
+    else:
+        text = f"{count} lines hidden"
+        chip = (
+            '<span class="nb-tag nb-tag--hide-input">hide-input</span>'
+            if "hide-input" in cell.tags
+            else ""
+        )
+    return (
+        '<button class="nb-collapse" type="button">'
+        '<span class="nb-collapse-caret">▸</span>'
+        f"<span>{esc(text)}</span>"
+        f"{chip}"
+        '<span class="nb-collapse-spacer"></span>'
+        '<span class="nb-collapse-show">show</span>'
+        "</button>"
+    )
+
+
+# --- B10 · cell tags --------------------------------------------------------------------------
+def render_tags(cell: Cell, ctx: RenderContext) -> str:
+    """B10 · cell tags — the four known chips from ``cell.tags`` in display order; ``''`` when none.
+
+    ``cell.tags`` has already narrowed to the known set (``cached``/``slow``/``skip``/
+    ``hide-input``), so each name is a safe class modifier; the chips are returned bare for the
+    caller to place (the B08 left group, or before a markdown body).
+    """
+    tags = cell.tags
+    if not tags:
+        return ""
+    return "".join(f'<span class="nb-tag nb-tag--{tag}">{esc(tag)}</span>' for tag in tags)
+
+
+def render_research_activity(cell: Cell, ctx: RenderContext) -> str:
+    """Render only the exact persisted activity declaration carried by a research cell."""
+
+    state = cell.research_activity
+    if state is None:
+        return ""
+    label = "Writing" if state == "writing" else "Executing"
+    caret = (
+        '<span class="nb-activity-caret" aria-hidden="true"></span>' if state == "writing" else ""
+    )
+    return (
+        f'<span class="nb-activity nb-activity--{state}" data-cell-activity>'
+        f"{esc(label)}{caret}</span>"
+    )
+
+
+# --- B11 · execution meta ---------------------------------------------------------------------
+def _fmt_number(value: int | float) -> str:
+    """Compact numeric string: integers and whole floats drop the decimal point."""
+    if isinstance(value, int):
+        return str(value)
+    number = float(value)
+    return str(int(number)) if number.is_integer() else f"{number:g}"
+
+
+def _exec_meta_facts(cell: Cell) -> list[str]:
+    """Duration / finish-time / peak-memory facts from ``metadata.mostlyright.execution``.
+
+    Keys are ``duration_s`` (seconds), ``finished_at`` (a clock string), and ``peak_mb`` (MB).
+    Only well-typed fields render; the free-text ``finished_at`` is escaped.
+    """
+    block = cell.metadata.get("mostlyright")
+    execution = block.get("execution") if isinstance(block, dict) else None
+    if not isinstance(execution, dict):
+        return []
+    facts: list[str] = []
+    duration = execution.get("duration_s")
+    if isinstance(duration, (int, float)) and not isinstance(duration, bool):
+        facts.append(f"{float(duration):.2f} s")
+    finished = execution.get("finished_at")
+    if isinstance(finished, str) and finished.strip():
+        facts.append(esc(finished))
+    peak = execution.get("peak_mb")
+    if isinstance(peak, (int, float)) and not isinstance(peak, bool):
+        facts.append(f"peak {_fmt_number(peak)} MB")
+    return facts
+
+
+def _is_int(value: Any) -> bool:
+    return isinstance(value, int) and not isinstance(value, bool)
+
+
+def render_exec_meta(cell: Cell, ctx: RenderContext) -> str:
+    """B11 · execution meta — duration/finish/peak row plus the out-of-order chip.
+
+    Facts come from cell metadata when present.  When ``execution_count`` is below the previous
+    code cell's (``ctx.prev_execution_count``), an orange ``ran out of order`` chip is appended.
+    The row is omitted entirely when there is nothing to say.
+    """
+    facts = _exec_meta_facts(cell)
+    out_of_order = ""
+    if (
+        _is_int(cell.execution_count)
+        and _is_int(ctx.prev_execution_count)
+        and cell.execution_count < ctx.prev_execution_count  # type: ignore[operator]
+    ):
+        out_of_order = '<span class="nb-exec-ooo">↯ ran out of order</span>'
+    if not facts and not out_of_order:
+        return ""
+    separator = '<span class="nb-exec-mid">·</span>'
+    return f'<div class="nb-exec-meta">{separator.join(facts)}{out_of_order}</div>'

mostlyright/data_harness/nbrender/interactive.py

@@ -0,0 +1,337 @@
+"""Group E · interactive (E25, E26): ipywidgets frozen render and the stale-output banner.
+
+Routed to from ``document._render_output``.  There is no kernel in ``static``/``embed``: E25 renders
+a frozen control state from ``application/vnd.jupyter.widget-view+json`` plus widget-state metadata
+when present, otherwise it dims a placeholder and pairs it with the E26 banner.  When the banner is
+shown the controls take ``opacity: 0.62; pointer-events: none``.  Escape every label and value from
+the widget JSON.
+
+Frozen state is resolved from what a single :class:`~parse.Output` can reach — the fixed
+``render_widget(out, ctx)`` signature does not expose notebook-level ``metadata.widgets`` — so this
+module reads either an embedded ``state`` object on the widget-view bundle (a Mostly Right export
+convenience) or the widget's ``text/plain`` repr (``IntSlider(value=5)``).  Neither present, or an
+unrecognized model, degrades to the dimmed placeholder.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any, NamedTuple
+
+from mostlyright.data_harness.nbrender.parse import Output, RenderContext, esc
+
+_WIDGET_MIME = "application/vnd.jupyter.widget-view+json"
+
+# The E26 banner's cobalt affordance is the same element that becomes a re-run button in connected
+# mode; in a no-kernel export it renders inert (a span, no action) so the banner height is stable.
+_STALE_ACTION = "re-run to refresh"
+
+# A slider with no declared bounds falls back to the ipywidgets integer defaults.
+_DEFAULT_MIN = 0.0
+_DEFAULT_MAX = 100.0
+
+# A checkmark glyph is not sanctioned iconography, so the checked tick is an inline SVG stroke.  The
+# stroke references the paper token (near-white); the ``.nb-checkbox.is-checked svg`` rule in
+# ``tokens`` wins over this presentation attribute and upgrades it to pure white.
+_CHECK_TICK = (
+    '<svg viewBox="0 0 12 12" width="12" height="12" aria-hidden="true" focusable="false">'
+    '<path d="M2.5 6.2 L5 8.7 L9.5 3.3" fill="none" stroke="var(--nb-paper)" '
+    'stroke-width="1.6" stroke-linecap="round" stroke-linejoin="round"></path>'
+    "</svg>"
+)
+
+_REPR_RE = re.compile(r"^\s*([A-Za-z_]\w*)\s*\((.*)\)\s*$", re.DOTALL)
+
+
+class _WidgetState(NamedTuple):
+    """Normalized frozen widget state, source-agnostic (embedded object or text/plain repr)."""
+
+    kind: str | None  # slider | toggle | button | checkbox | output | None (unrecognized)
+    label: str  # model/class name, used only for the placeholder label
+    description: str
+    value: Any
+    vmin: float | None
+    vmax: float | None
+    options: list[str]
+
+
+def _classify(name: str) -> str | None:
+    """Map an ipywidgets model/class name to one of the five controls drawn here, else None."""
+    lowered = (name or "").lower()
+    if "slider" in lowered:
+        return "slider"
+    if "togglebuttons" in lowered:  # plural group; must precede the bare "button" test below
+        return "toggle"
+    if "checkbox" in lowered:
+        return "checkbox"
+    if "button" in lowered:
+        return "button"
+    if "output" in lowered:
+        return "output"
+    return None
+
+
+def _as_num(value: Any) -> float | None:
+    """Coerce a numeric bound to float; reject bools and non-numerics (``None`` -> use defaults)."""
+    if isinstance(value, bool):
+        return None
+    if isinstance(value, (int, float)):
+        return float(value)
+    return None
+
+
+def _fmt_value(value: Any) -> str:
+    """Human value readout: bools verbatim, floats without trailing-zero noise, else ``str``."""
+    if isinstance(value, bool):
+        return "True" if value else "False"
+    if isinstance(value, float):
+        return f"{value:g}"
+    if value is None:
+        return ""
+    return str(value)
+
+
+def _fraction(value: Any, vmin: float | None, vmax: float | None) -> float:
+    """Slider fill fraction in [0, 1] from value and bounds: bounds default, range clamps."""
+    numeric = _as_num(value)
+    if numeric is None:
+        return 0.0
+    lo = vmin if vmin is not None else _DEFAULT_MIN
+    hi = vmax if vmax is not None else _DEFAULT_MAX
+    if hi == lo:
+        return 0.0
+    return max(0.0, min(1.0, (numeric - lo) / (hi - lo)))
+
+
+# --- state resolution -------------------------------------------------------------------------
+
+
+def _split_top_level(source: str) -> list[str]:
+    """Split a repr arg string on top-level commas, honoring quotes and bracket nesting."""
+    parts: list[str] = []
+    buf: list[str] = []
+    depth = 0
+    quote: str | None = None
+    escaped = False
+    for ch in source:
+        if escaped:
+            buf.append(ch)
+            escaped = False
+            continue
+        if quote is not None:
+            buf.append(ch)
+            if ch == "\\":
+                escaped = True
+            elif ch == quote:
+                quote = None
+            continue
+        if ch in "\"'":
+            quote = ch
+            buf.append(ch)
+        elif ch in "([{":
+            depth += 1
+            buf.append(ch)
+        elif ch in ")]}":
+            depth = max(0, depth - 1)
+            buf.append(ch)
+        elif ch == "," and depth == 0:
+            parts.append("".join(buf))
+            buf = []
+        else:
+            buf.append(ch)
+    if buf:
+        parts.append("".join(buf))
+    return [part.strip() for part in parts if part.strip()]
+
+
+def _parse_val(token: str) -> Any:
+    """Parse one repr scalar/sequence: quoted string, bool, None, number, or a tuple/list."""
+    text = token.strip()
+    if len(text) >= 2 and text[0] in "\"'" and text[-1] == text[0]:
+        return text[1:-1]
+    if text == "True":
+        return True
+    if text == "False":
+        return False
+    if text == "None":
+        return None
+    if len(text) >= 2 and text[0] in "([" and text[-1] in ")]":
+        return [_parse_val(item) for item in _split_top_level(text[1:-1])]
+    if re.fullmatch(r"[+-]?\d+", text):
+        return int(text)
+    try:
+        return float(text)
+    except ValueError:
+        return text
+
+
+def _options_of(raw: Any) -> list[str]:
+    """Coerce an options sequence to a list of strings; anything else yields no options."""
+    if isinstance(raw, list):
+        return [str(item) for item in raw]
+    return []
+
+
+def _from_embedded(state: dict[str, Any]) -> _WidgetState:
+    """Normalize an embedded widget-state object (``_model_name`` + fields)."""
+    model = str(state.get("_model_name", ""))
+    options = _options_of(state.get("_options_labels"))
+    if not options:
+        options = _options_of(state.get("options"))
+    value = state.get("value")
+    # ToggleButtons serializes the selection as an index into the labels, not a value.
+    index = state.get("index")
+    if value is None and isinstance(index, int) and not isinstance(index, bool) and options:
+        if 0 <= index < len(options):
+            value = options[index]
+    label = re.sub(r"Model$", "", model) or "widget"
+    return _WidgetState(
+        kind=_classify(model),
+        label=label,
+        description=str(state.get("description", "") or ""),
+        value=value,
+        vmin=_as_num(state.get("min")),
+        vmax=_as_num(state.get("max")),
+        options=options,
+    )
+
+
+def _from_repr(text: str) -> _WidgetState | None:
+    """Normalize a widget ``text/plain`` repr, e.g. ``ToggleButtons(options=('a','b'))``."""
+    match = _REPR_RE.match(text.strip())
+    if match is None:
+        return None
+    class_name = match.group(1)
+    kwargs: dict[str, Any] = {}
+    for part in _split_top_level(match.group(2)):
+        if "=" in part:
+            key, _, raw = part.partition("=")
+            kwargs[key.strip()] = _parse_val(raw)
+    return _WidgetState(
+        kind=_classify(class_name),
+        label=class_name,
+        description=str(kwargs.get("description", "") or ""),
+        value=kwargs.get("value"),
+        vmin=_as_num(kwargs.get("min")),
+        vmax=_as_num(kwargs.get("max")),
+        options=_options_of(kwargs.get("options")),
+    )
+
+
+def _resolve_state(out: Output) -> _WidgetState | None:
+    """Frozen state from an embedded view ``state`` object, else the text/plain repr, else None."""
+    view = out.data.get(_WIDGET_MIME)
+    if isinstance(view, dict):
+        embedded = view.get("state")
+        if isinstance(embedded, dict):
+            return _from_embedded(embedded)
+    repr_text = out.text_of("text/plain")
+    if repr_text.strip():
+        return _from_repr(repr_text)
+    return None
+
+
+# --- control rows -----------------------------------------------------------------------------
+
+
+def _row(label_html: str, control_html: str) -> str:
+    return (
+        '<div class="nb-widget-row">'
+        '<span class="nb-widget-label">' + label_html + "</span>" + control_html + "</div>"
+    )
+
+
+def _slider_row(state: _WidgetState) -> str:
+    pct = f"{_fraction(state.value, state.vmin, state.vmax) * 100:g}"
+    control = (
+        '<div class="nb-slider-track" style="position: relative">'
+        '<div class="nb-slider-fill" style="width: ' + pct + '%"></div>'
+        '<div class="nb-slider-thumb" style="position: absolute; top: 50%; left: ' + pct + "%; "
+        'transform: translate(-50%, -50%)"></div>'
+        "</div>"
+        '<span class="nb-widget-value">' + esc(_fmt_value(state.value)) + "</span>"
+    )
+    return _row(esc(state.description), control)
+
+
+def _toggle_row(state: _WidgetState) -> str:
+    selected = _fmt_value(state.value)
+    options = state.options if state.options else ([selected] if selected else [])
+    segments: list[str] = []
+    for option in options:
+        cls = "nb-toggle-seg is-active" if _fmt_value(option) == selected else "nb-toggle-seg"
+        segments.append('<span class="' + cls + '">' + esc(str(option)) + "</span>")
+    control = '<div class="nb-toggle">' + "".join(segments) + "</div>"
+    return _row(esc(state.description), control)
+
+
+def _button_row(state: _WidgetState) -> str:
+    # A Button carries its own label; the left description column stays empty for column alignment.
+    text = state.description or "run"
+    control = '<button type="button" class="nb-widget-btn">' + esc(text) + "</button>"
+    return _row("", control)
+
+
+def _checkbox_row(state: _WidgetState) -> str:
+    checked = bool(state.value)
+    cls = "nb-checkbox is-checked" if checked else "nb-checkbox"
+    control = '<span class="' + cls + '">' + (_CHECK_TICK if checked else "") + "</span>"
+    return _row(esc(state.description), control)
+
+
+def _placeholder_row(state: _WidgetState | None) -> str:
+    """Dimmed stand-in for an absent or unrecognized widget: a labeled, empty control bar."""
+    label = state.label if state is not None and state.label else "widget"
+    control = (
+        '<div class="nb-slider-track" style="position: relative">'
+        '<div class="nb-slider-fill" style="width: 0%"></div>'
+        "</div>"
+    )
+    return _row(esc(label), control)
+
+
+def render_widget(out: Output, ctx: RenderContext) -> str:
+    """E25 · ipywidgets — frozen slider/toggle/button/checkbox state, or a dimmed placeholder.
+
+    State is recovered from the output alone (embedded view ``state`` object or the text/plain
+    repr); an unrecognized model degrades to the placeholder.  ``static``/``embed`` add
+    ``is-frozen`` so the shared rule dims the controls and blocks pointer events — no kernel to
+    drive them; ``connected`` leaves them live.
+    """
+    state = _resolve_state(out)
+    if state is None:
+        row = _placeholder_row(None)
+    elif state.kind == "slider":
+        row = _slider_row(state)
+    elif state.kind == "toggle":
+        row = _toggle_row(state)
+    elif state.kind == "button":
+        row = _button_row(state)
+    elif state.kind == "checkbox":
+        row = _checkbox_row(state)
+    else:  # recognized-but-undrawn (output) or unrecognized model
+        row = _placeholder_row(state)
+
+    frozen = " is-frozen" if ctx.mode in ("static", "embed") else ""
+    return (
+        '<div class="nb-widget' + frozen + '">'
+        '<div class="nb-widget-controls">' + row + "</div>"
+        "</div>"
+    )
+
+
+def render_stale_banner(ctx: RenderContext, *, message: str) -> str:
+    """E26 · stale-output banner — dot, frozen-state message, cobalt text (no action in static).
+
+    ``document`` shows this only in ``static``/``embed`` (the paths with no kernel), so the cobalt
+    affordance renders inert: a ``span``, never a link or button.  ``message`` is caller-supplied
+    and escaped at interpolation.
+    """
+    return (
+        '<div class="nb-stale">'
+        '<span class="nb-stale-dot"></span>'
+        '<span class="nb-stale-msg">' + esc(message) + "</span>"
+        '<span class="nb-stale-spacer"></span>'
+        '<span class="nb-stale-action">' + esc(_STALE_ACTION) + "</span>"
+        "</div>"
+    )