model-unfolder 0.2.0__py3-none-any.whl

model_unfolder/renderers/html/block_views/attention.py

@@ -0,0 +1,91 @@
+"""Inspect-card content for attention blocks."""
+from __future__ import annotations
+
+from ....labels import describe_attention, kv_shared, mask_long
+from ..utils import _html
+
+
+def attention_card(ir: dict, info: dict, meta_for: callable) -> str:
+    """Inspect card for the attention block."""
+    attn_groups = [
+        g for g in info.get("groups", []) if g.get("spec", {}).get("attention")
+    ]
+    if len(attn_groups) <= 1:
+        title, desc = meta_for("attn")
+        return (
+            '<div class="uf-card-detail uf-card-attn">'
+            f'<div class="uf-card-title">{_html(title)}</div>'
+            f'<div class="uf-card-desc">{_html(desc)}</div>'
+            "</div>"
+        )
+
+    rows = "".join(_attention_row_for_group(group, ir) for group in attn_groups)
+    return (
+        '<div class="uf-card-detail uf-card-attn">'
+        '<div class="uf-card-title">Attention layers</div>'
+        '<div class="uf-card-desc">'
+        f"{len(attn_groups)} attention variants in this model — each row is one variant."
+        "</div>"
+        f'<div class="uf-attn-rows">{rows}</div>'
+        "</div>"
+    )
+
+
+def _attention_row_for_group(group: dict, ir: dict) -> str:
+    attn = group["spec"]["attention"]
+    indices = group["indices"]
+    n_layers = len(indices)
+    layers = ir.get("layers", [])
+    n_shared = sum(
+        1 for i in indices
+        if 0 <= i < len(layers) and kv_shared(layers[i].get("attention") or {})
+    )
+    return _attention_row(attn, n_layers, n_shared)
+
+
+def _attention_row(attn: dict, n_layers: int, n_shared: int) -> str:
+    title = f"{mask_long(attn)} · {describe_attention(attn)}"
+    bits: list[str] = []
+    if attn.get("window_size"):
+        bits.append(f"window {attn['window_size']}")
+    if n_shared:
+        bits.append(f"{n_shared} of {n_layers} reuse K/V from earlier layers")
+    else:
+        bits.append(f"{n_layers} layers")
+    detail = "  ·  ".join(bits)
+    return (
+        '<div class="uf-attn-row">'
+        f'<div class="uf-attn-row-title">{_html(title)}</div>'
+        f'<div class="uf-attn-row-detail">{_html(detail)}</div>'
+        "</div>"
+    )
+
+
+def attention_card_css(mount_id: str, theme: dict) -> str:
+    return f"""
+#{mount_id} .uf-attn-rows {{
+  margin-top:10px;
+  display:flex;
+  flex-direction:column;
+  gap:8px;
+}}
+#{mount_id} .uf-attn-row {{
+  padding:9px 12px;
+  background:{theme['bg_card']};
+  border:0.5px solid {theme['border']};
+  border-left:3px solid {theme['block']};
+  border-radius:8px;
+}}
+#{mount_id} .uf-attn-row-title {{
+  font-family:{theme['font_head']};
+  font-size:16px;
+  color:{theme['text']};
+  line-height:1.15;
+}}
+#{mount_id} .uf-attn-row-detail {{
+  margin-top:3px;
+  font-size:12px;
+  color:{theme['muted']};
+  font-family:{theme['font_mono']};
+}}
+"""

model_unfolder/renderers/html/block_views/feed_forward.py

@@ -0,0 +1,213 @@
+"""Detail SVGs for feed-forward blocks."""
+from __future__ import annotations
+
+from ....labels import activation_label
+from ..svg import (
+    _defs,
+    _elbow_hv,
+    _elbow_vh,
+    _ids,
+    _plus_block,
+    _rect_block,
+    _region_rect,
+    _svg,
+    _svg_tag,
+    _svg_text,
+    _v_line,
+    _v_seg,
+)
+from ..theme import C, FONT_BODY, FONT_HEAD, FONT_MONO, GAP
+from ..utils import _fmt_int
+
+
+def build_moe_view(ir: dict, info: dict, mount_id: str) -> str:
+    w, h = 720, 620
+    arrow_id, shadow_id = _ids(mount_id, "moe")
+    parts = [_defs(arrow_id, shadow_id)]
+    parts.append(_region_rect(40, 30, w - 80, h - 60, C["bg_outer"]))
+
+    ffn = info["dominant"]["spec"]["ffn"]
+    hidden = _fmt_int(ir.get("hidden_size"))
+    inter = _fmt_int(ffn.get("expert_intermediate_size") or ffn.get("intermediate_size"))
+    n_experts = _fmt_int(ffn.get("num_experts")) if ffn.get("num_experts") else "N"
+    cx = w / 2
+    router_w = 540
+    router = _rect_block(parts, info, shadow_id, "router", (w - router_w) / 2, h - 130, router_w, 50, "Router")
+    sum_node = _plus_block(parts, info, shadow_id, "add_moe", cx, 100)
+
+    expert_w, expert_h = 116, 54
+    expert_y = 235
+    n_total = ffn.get("num_experts")
+    last_label = str(n_total) if n_total else "N"
+    side_pad = 60
+    gap = (w - 2 * side_pad - 4 * expert_w) / 3
+    slots = [
+        (side_pad + 0 * (expert_w + gap), "Expert 1", "expert_1"),
+        (side_pad + 1 * (expert_w + gap), "Expert k", "expert_k"),
+        (side_pad + 2 * (expert_w + gap), "Expert k+1", "expert_kp1"),
+        (side_pad + 3 * (expert_w + gap), f"Expert {last_label}", "expert_n"),
+    ]
+    experts = [
+        _rect_block(parts, info, shadow_id, node_id, x, expert_y, expert_w, expert_h, label, font_size=15)
+        for x, label, node_id in slots
+    ]
+    _dim_label(parts, router["cx"], router["top"] - 14, f"router: {hidden} -> {n_experts}", anchor="middle")
+    _dim_label(parts, cx, expert_y - 18, f"each expert: {hidden} -> {inter} -> {hidden}", anchor="middle")
+
+    dots_x = (experts[1]["right"] + experts[2]["left"]) / 2
+    dots_y = expert_y + expert_h / 2
+    for i in range(-2, 3):
+        parts.append(_svg_tag("circle", {"cx": dots_x + i * 7, "cy": dots_y, "r": 2.5, "fill": C["muted"]}))
+
+    for expert in experts:
+        parts.append(_v_seg(expert["cx"], router["top"], expert["bottom"] + GAP, arrow_id))
+
+    for expert in experts:
+        target_x = sum_node["cx"] + (-sum_node["r"] - GAP if expert["cx"] < sum_node["cx"] else sum_node["r"] + GAP)
+        parts.append(_elbow_vh(expert["cx"], expert["top"], target_x, sum_node["cy"], arrow_id))
+
+    if ffn.get("num_experts") and ffn.get("num_experts_per_tok"):
+        sparsity = 100 * ffn["num_experts_per_tok"] / ffn["num_experts"]
+        cg_x, cg_y, cg_w, cg_h = w - 244, 58, 188, 58
+        parts.append(
+            _svg_tag(
+                "rect",
+                {
+                    "x": cg_x,
+                    "y": cg_y,
+                    "width": cg_w,
+                    "height": cg_h,
+                    "rx": 10,
+                    "ry": 10,
+                    "fill": C["bg_card"],
+                    "stroke": C["border"],
+                    "stroke-width": 0.5,
+                },
+            )
+        )
+        parts.append(
+            _svg_text(
+                cg_x + 12,
+                cg_y + 18,
+                "ACTIVE PER TOKEN",
+                {
+                    "fill": C["muted"],
+                    "font-family": FONT_BODY,
+                    "font-size": 10,
+                    "letter-spacing": "0.12em",
+                    "font-weight": 600,
+                },
+            )
+        )
+        parts.append(
+            _svg_text(
+                cg_x + 12,
+                cg_y + 44,
+                f"{ffn['num_experts_per_tok']} / {ffn['num_experts']}  -  {sparsity:.1f}%",
+                {"fill": C["text"], "font-family": FONT_HEAD, "font-size": 22},
+            )
+        )
+
+    parts.append(_svg_tag("line", {
+        "x1": sum_node["cx"], "y1": sum_node["top"],
+        "x2": sum_node["cx"], "y2": sum_node["top"] - 36,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+    parts.append(_svg_text(
+        sum_node["cx"], sum_node["top"] - 46,
+        f"out ({hidden})",
+        {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 11},
+    ))
+
+    parts.append(_svg_tag("line", {
+        "x1": cx, "y1": router["bottom"] + 36,
+        "x2": cx, "y2": router["bottom"] + GAP,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+    parts.append(_svg_text(
+        cx, router["bottom"] + 50,
+        f"in ({hidden})",
+        {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 11},
+    ))
+
+    return _svg(w, h, f"{ir.get('name', 'model')} mixture of experts", parts)
+
+
+def build_ffn_view(ir: dict, info: dict, mount_id: str) -> str:
+    w, h = 720, 660
+    arrow_id, shadow_id = _ids(mount_id, "ffn")
+    parts = [_defs(arrow_id, shadow_id)]
+    parts.append(_region_rect(40, 30, w - 80, h - 60, C["bg_outer"]))
+
+    ffn = info["dominant"]["spec"]["ffn"]
+    hidden = _fmt_int(ir.get("hidden_size"))
+    inter = _fmt_int(ffn.get("expert_intermediate_size") or ffn.get("intermediate_size"))
+    cx = w / 2
+    act_name = activation_label(ffn.get("activation") or "silu")
+
+    down_proj = _rect_block(parts, info, shadow_id, "down_proj", cx - 90, 110, 180, 50, "Linear (down)")
+    mul_node = _plus_block(parts, info, shadow_id, "mul", cx, 230, "×")
+    silu = _rect_block(parts, info, shadow_id, "silu", cx - 270, 330, 180, 50, act_name)
+    up_proj = _rect_block(parts, info, shadow_id, "up_proj", cx + 90, 330, 180, 50, "Linear (up)")
+    gate_proj = _rect_block(parts, info, shadow_id, "gate_proj", cx - 270, 460, 180, 50, "Linear (gate)")
+
+    branch_y = h - 110
+    parts.append(_svg_tag("circle", {"cx": cx, "cy": branch_y, "r": 4, "fill": C["arrow"]}))
+    parts.append(_elbow_hv(cx, branch_y, gate_proj["cx"], gate_proj["bottom"] + GAP, arrow_id))
+    parts.append(_elbow_hv(cx, branch_y, up_proj["cx"], up_proj["bottom"] + GAP, arrow_id))
+    parts.append(_v_line(gate_proj, silu, arrow_id))
+    parts.append(_elbow_vh(silu["cx"], silu["top"], mul_node["cx"] - mul_node["r"] - GAP, mul_node["cy"], arrow_id))
+    parts.append(_elbow_vh(up_proj["cx"], up_proj["top"], mul_node["cx"] + mul_node["r"] + GAP, mul_node["cy"], arrow_id))
+    parts.append(_v_line(mul_node, down_proj, arrow_id))
+    _dim_label(parts, down_proj["right"] + 14, down_proj["cy"], f"{inter} -> {hidden}")
+    _dim_label(parts, gate_proj["right"] + 14, gate_proj["cy"], f"{hidden} -> {inter}")
+    _dim_label(parts, up_proj["cx"], up_proj["bottom"] + 18, f"{hidden} -> {inter}", anchor="middle")
+    _dim_label(parts, mul_node["cx"], mul_node["cy"] + 36, f"{inter} x {inter}", anchor="middle")
+
+    parts.append(_svg_tag("line", {
+        "x1": cx, "y1": down_proj["top"],
+        "x2": cx, "y2": down_proj["top"] - 36,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+    parts.append(_svg_text(
+        cx, down_proj["top"] - 46,
+        f"out ({hidden})",
+        {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 11},
+    ))
+
+    parts.append(_svg_tag("line", {
+        "x1": cx, "y1": branch_y + 38,
+        "x2": cx, "y2": branch_y + 8,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+    parts.append(
+        _svg_text(
+            cx,
+            h - 48,
+            f"in ({hidden})",
+            {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 11},
+        )
+    )
+
+    return _svg(w, h, f"{ir.get('name', 'model')} feed-forward block", parts)
+
+
+def _dim_label(parts: list[str], x: float, y: float, text: str, *, anchor: str = "start") -> None:
+    parts.append(
+        _svg_text(
+            x,
+            y,
+            text,
+            {
+                "text-anchor": anchor,
+                "dominant-baseline": "central",
+                "fill": C["muted"],
+                "font-family": FONT_MONO,
+                "font-size": 10,
+            },
+        )
+    )

model_unfolder/renderers/html/block_views/per_layer_embedding.py

@@ -0,0 +1,199 @@
+"""Detail SVG for reusable Per-Layer Embedding blocks."""
+from __future__ import annotations
+
+from ..metadata import _block_label
+from ..svg import (
+    _defs,
+    _ids,
+    _plus_block,
+    _rect_block,
+    _region_rect,
+    _svg,
+    _svg_tag,
+    _svg_text,
+    _v_line,
+)
+from ..theme import C, FONT_MONO, GAP
+from ..utils import _fmt_int
+
+
+def build_per_layer_embedding_view(ir: dict, info: dict, mount_id: str, block: dict) -> str:
+    """Render the canonical PLE gate -> multiply -> projection detail view.
+
+    The adapter declares the child node ids and dimensions in ``block['detail']``.
+    Any model family with the same part emits the same block contract.
+    """
+    w, h = 720, 660
+    detail = block.get("detail") or {}
+    view_id = detail.get("view_id") or block.get("id") or "ple"
+    arrow_id, shadow_id = _ids(mount_id, view_id)
+    parts = [_defs(arrow_id, shadow_id)]
+    parts.append(_region_rect(40, 30, w - 80, h - 60, C["bg_outer"]))
+
+    ids = _node_ids(block)
+    hidden_size = detail.get("hidden_size") or ir.get("hidden_size")
+    embedding_dim = detail.get("embedding_dim") or (
+        ((ir.get("extras") or {}).get("per_layer_embeddings") or {}).get("hidden")
+    )
+    cx = 300
+    y_shift = -24
+
+    gate = _rect_block(
+        parts, info, shadow_id, ids["gate"],
+        cx - 110, h - 160 + y_shift, 220, 50,
+        _label(info, block, ids["gate"], "Linear (gate)"),
+    )
+    act = _rect_block(
+        parts, info, shadow_id, ids["activation"],
+        cx - 90, h - 250 + y_shift, 180, 44,
+        _label(info, block, ids["activation"], "Activation"),
+    )
+    mul = _plus_block(parts, info, shadow_id, ids["multiply"], cx, h - 320 + y_shift, "×")
+    proj = _rect_block(
+        parts, info, shadow_id, ids["projection"],
+        cx - 110, h - 410 + y_shift, 220, 50,
+        _label(info, block, ids["projection"], "Linear (up)"),
+    )
+    norm = _rect_block(
+        parts, info, shadow_id, ids["norm"],
+        cx - 90, h - 500 + y_shift, 180, 44,
+        _label(info, block, ids["norm"], "RMSNorm"),
+    )
+
+    for src, dst in ((gate, act), (act, mul), (mul, proj), (proj, norm)):
+        parts.append(_v_line(src, dst, arrow_id))
+
+    parts.append(_svg_tag("line", {
+        "x1": cx, "y1": norm["top"],
+        "x2": cx, "y2": norm["top"] - 36,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+    parts.append(_svg_text(
+        cx, norm["top"] - 46,
+        detail.get("output_label") or "out  -> add (residual)",
+        {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 11},
+    ))
+
+    parts.append(_svg_tag("line", {
+        "x1": cx, "y1": gate["bottom"] + 38,
+        "x2": cx, "y2": gate["bottom"] + 8,
+        "stroke": C["arrow"], "stroke-width": 1.6, "stroke-linecap": "round",
+        "marker-end": f"url(#{arrow_id})", "fill": "none",
+    }))
+    parts.append(_svg_text(
+        cx, gate["bottom"] + 56,
+        detail.get("input_label") or "in  (hidden)",
+        {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 11},
+    ))
+
+    external = _external_tensor_block(
+        parts,
+        shadow_id,
+        detail.get("pathway_id") or "per_layer_input",
+        382,
+        mul["cy"] - 21,
+        178,
+        42,
+        detail.get("external_label") or "per_layer_input[L]",
+    )
+    parts.append(_svg_tag("line", {
+        "x1": external["left"] - GAP, "y1": external["cy"],
+        "x2": mul["cx"] + mul["r"] + GAP, "y2": mul["cy"],
+        "stroke": "#1F9E78", "stroke-width": 1.6, "stroke-linecap": "round",
+        "stroke-dasharray": "5 4",
+        "marker-end": f"url(#{arrow_id})",
+    }))
+    parts.append(_svg_text(
+        external["cx"], external["bottom"] + 16,
+        "(outside stack)",
+        {"text-anchor": "middle", "fill": C["muted"], "font-family": FONT_MONO, "font-size": 9},
+    ))
+
+    parts.append(_svg_text(
+        gate["right"] + 14, gate["cy"],
+        f"{_fmt_int(hidden_size)}  ->  {_fmt_int(embedding_dim)}" if embedding_dim else "",
+        {"dominant-baseline": "central", "fill": C["muted"],
+         "font-family": FONT_MONO, "font-size": 10},
+    ))
+    parts.append(_svg_text(
+        proj["right"] + 14, proj["cy"],
+        f"{_fmt_int(embedding_dim)}  ->  {_fmt_int(hidden_size)}" if embedding_dim else "",
+        {"dominant-baseline": "central", "fill": C["muted"],
+         "font-family": FONT_MONO, "font-size": 10},
+    ))
+
+    return _svg(w, h, f"{ir.get('name', 'model')} per-layer embeddings block", parts)
+
+
+def _node_ids(block: dict) -> dict[str, str]:
+    ids = ((block.get("detail") or {}).get("nodes") or {}).copy()
+    block_id = block.get("id") or "ple"
+    ids.setdefault("gate", f"{block_id}_gate")
+    ids.setdefault("activation", f"{block_id}_act")
+    ids.setdefault("multiply", f"{block_id}_mul")
+    ids.setdefault("projection", f"{block_id}_proj")
+    ids.setdefault("norm", f"{block_id}_norm")
+    return ids
+
+
+def _external_tensor_block(
+    parts: list[str],
+    shadow_id: str,
+    node_id: str,
+    x: float,
+    y: float,
+    w: float,
+    h: float,
+    label: str,
+) -> dict:
+    children = [
+        _svg_tag("rect", {
+            "x": x,
+            "y": y,
+            "width": w,
+            "height": h,
+            "rx": 10,
+            "ry": 10,
+            "fill": C["badge_bg"],
+            "stroke": "#1F9E78",
+            "stroke-width": 1,
+            "stroke-dasharray": "4 3",
+            "filter": f"url(#{shadow_id})",
+        }),
+        _svg_text(
+            x + w / 2,
+            y + h / 2,
+            label,
+            {
+                "text-anchor": "middle",
+                "dominant-baseline": "central",
+                "fill": "#0F6E56",
+                "font-family": FONT_MONO,
+                "font-size": 12,
+                "font-weight": 700,
+                "pointer-events": "none",
+            },
+        ),
+    ]
+    parts.append(_svg_tag("g", {"class": "uf-node uf-external-tensor", "data-id": node_id}, "".join(children)))
+    return {
+        "left": x,
+        "right": x + w,
+        "top": y,
+        "bottom": y + h,
+        "cx": x + w / 2,
+        "cy": y + h / 2,
+        "w": w,
+        "h": h,
+    }
+
+
+def _label(info: dict, block: dict, node_id: str, default: str) -> str:
+    label = _block_label(info, node_id, None)
+    if label:
+        return label
+    for child in block.get("children") or []:
+        if child.get("id") == node_id:
+            return child.get("label") or default
+    return default

model_unfolder/renderers/html/cards.py

@@ -0,0 +1,130 @@
+"""Inspect-card HTML for architecture block clicks."""
+from __future__ import annotations
+
+from ...labels import activation_label
+from .block_views import attention_card, block_detail_svg
+from .utils import _attr, _fmt_int, _html
+
+
+def _build_inspect_cards(ir: dict, info: dict, mount_id: str) -> str:
+    """Cards-only HTML for the L2 inspect panel."""
+    panels: list[str] = [_hint_card("default", "Click a block above to inspect it")]
+
+    spec = info["dominant"]["spec"]
+    layer_blocks = spec.get("blocks") or []
+
+    for node_id in ("tok_text", "embed"):
+        panels.append(_simple_card(node_id, *_meta(info, node_id)))
+
+    for block in layer_blocks:
+        kind = block.get("kind")
+        node_id = block["id"]
+        if kind == "attention":
+            panels.append(attention_card(ir, info, lambda nid: _meta(info, nid)))
+            continue
+
+        svg = block_detail_svg(ir, info, mount_id, block)
+        if svg:
+            title, desc = _meta(info, node_id)
+            panels.append(_rich_card(node_id, title, desc, svg))
+        else:
+            panels.append(_simple_card(node_id, *_meta(info, node_id)))
+
+    for node_id in ("final_rms", "lm_head"):
+        panels.append(_simple_card(node_id, *_meta(info, node_id)))
+
+    return "".join(panels)
+
+
+def _build_sub_inspect_cards(ir: dict, info: dict, mount_id: str) -> str:
+    """Cards-only HTML for the L3 sub-inspect panel."""
+    panels: list[str] = [_l3_card("default", "", "")]
+    ffn = info["dominant"]["spec"]["ffn"]
+    children = _sub_inspect_children(info)
+
+    if children:
+        seen: set[str] = set()
+        for child in children:
+            child_id = child.get("id")
+            if not child_id or child_id in seen:
+                continue
+            seen.add(child_id)
+            panels.append(_l3_card(child_id, child.get("title", child_id), child.get("description", "")))
+    else:
+        panels.extend(_fallback_sub_inspect_cards(ir, ffn))
+
+    return "".join(panels)
+
+
+def _meta(info: dict, node_id: str) -> tuple[str, str]:
+    return info.get("meta", {}).get(node_id, (node_id, ""))
+
+
+def _simple_card(node_id: str, title: str, desc: str) -> str:
+    return (
+        f'<div class="uf-card-detail uf-card-{_attr(node_id)}">'
+        f'<div class="uf-card-title">{_html(title)}</div>'
+        f'<div class="uf-card-desc">{_html(desc)}</div>'
+        "</div>"
+    )
+
+
+def _hint_card(node_id: str, hint: str) -> str:
+    return (
+        f'<div class="uf-card-detail uf-card-hint uf-card-{_attr(node_id)}">'
+        f"{_html(hint)}"
+        "</div>"
+    )
+
+
+def _l3_card(node_id: str, title: str, desc: str) -> str:
+    return (
+        f'<div class="uf-card-detail uf-l3-{_attr(node_id)}">'
+        f'<div class="uf-card-title">{_html(title)}</div>'
+        f'<div class="uf-card-desc">{_html(desc)}</div>'
+        "</div>"
+    )
+
+
+def _rich_card(node_id: str, title: str, desc: str, svg: str) -> str:
+    return (
+        f'<div class="uf-card-detail uf-card-{_attr(node_id)}">'
+        f'<div class="uf-card-title">{_html(title)}</div>'
+        f'<div class="uf-card-desc">{_html(desc)}</div>'
+        f'<div class="uf-card-svg">{svg}</div>'
+        "</div>"
+    )
+
+
+def _sub_inspect_children(info: dict) -> list[dict]:
+    children: list[dict] = []
+    for block in (info["dominant"]["spec"].get("blocks") or []):
+        children.extend(block.get("children") or [])
+    return children
+
+
+def _fallback_sub_inspect_cards(ir: dict, ffn: dict) -> list[str]:
+    h = _fmt_int(ir.get("hidden_size"))
+    inter = _fmt_int(ffn.get("expert_intermediate_size") or ffn.get("intermediate_size"))
+    activation = activation_label(ffn.get("activation") or "silu")
+    panels = [
+        _l3_card("gate_proj", "Gate projection", f"Linear · {h} → {inter} (gated path through {activation})"),
+        _l3_card("up_proj", "Up projection", f"Linear · {h} → {inter}"),
+        _l3_card("silu", f"{activation} activation", "Element-wise non-linearity applied to the gate path"),
+        _l3_card("mul", "Element-wise multiply", f"{activation}(gate) × up — combines the gated and ungated paths"),
+        _l3_card("down_proj", "Down projection", f"Linear · {inter} → {h}"),
+    ]
+    if ffn.get("kind") == "moe":
+        n_experts = _fmt_int(ffn.get("num_experts")) if ffn.get("num_experts") else "N"
+        n_active = ffn.get("num_experts_per_tok") or "k"
+        n_shared = ffn.get("num_shared_experts") or 0
+        panels.append(_l3_card("router", "Router", f"Linear · {h} → {n_experts} (selects top-{n_active} experts per token)"))
+        expert_desc = (
+            f"Dense FFN with same shape as above · {h} → {inter} → {h} · "
+            f"only top-{n_active} of {n_experts} active per token"
+            + (f" · plus {n_shared} shared expert(s) always active" if n_shared else "")
+        )
+        for eid in ("expert_1", "expert_k", "expert_kp1", "expert_n"):
+            panels.append(_l3_card(eid, "Expert FFN", expert_desc))
+        panels.append(_l3_card("add_moe", "Weighted sum", f"Combines top-{n_active} expert outputs weighted by router probabilities"))
+    return panels