slab-cli 0.1.0__py3-none-any.whl

slab_cli/display.py

@@ -0,0 +1,1187 @@
+"""Rich display helpers for CLI output."""
+
+from __future__ import annotations
+
+from rich.console import Group
+from rich.text import Text
+
+from slab_schemas.cards import CardOut, CardSearchResult, SetOut, SetSearchResult
+from slab_schemas.collection import BreakSearchResult, CollectionResult, LotSearchResult
+from slab_schemas.community import (
+    CollectedCard,
+    CollectedPlayer,
+    CommunityBoard,
+    CommunityCard,
+    HotPlayer,
+    RarestOwnedCard,
+    TickerItem,
+    ValuableCard,
+)
+from slab_schemas.custom_sets import CustomSetDetail, CustomSetOut, CustomSetSearchResult
+from slab_schemas.dashboard import CatalogStats, DashboardStats, HighlightCard, LabeledCount
+from slab_schemas.enums import Grade
+from slab_schemas.pricing import CardComps, CardMarket, PortfolioSummary, SetTopCards
+from slab_schemas.sealed import SealedPriceHistory, SealedProductOut
+from slab_schemas.timeseries import CardPriceHistory
+
+from .theme import (
+    bar,
+    console,
+    heading,
+    kv_grid,
+    money,
+    pct_coverage,
+    section,
+    signed_money,
+    slab_panel,
+    slab_table,
+    sparkline,
+    titled,
+)
+
+
+def format_grade_delta(delta: float | None) -> str | None:
+    """Human phrasing for a self-vs-pro grade gap (e.g. '+1 (optimistic)'). None if not comparable."""
+    if delta is None:
+        return None
+    if delta == 0:
+        return "spot on"
+    n = int(delta) if float(delta).is_integer() else delta
+    if delta < 0:
+        return f"{n} (optimistic)"
+    return f"+{n} (pessimistic)"
+
+
+def _grade_name(g) -> str:
+    """Human label for a Grade rung — 'excellent', 'near mint mint' — from the enum or its wire value."""
+    name = getattr(g, "name", None)
+    if name is None:
+        try:
+            name = Grade(g).name
+        except ValueError:
+            return str(g)
+    return name.replace("_", " ")
+
+
+def _format_collection_grade(cp) -> str:
+    """Compose the Grade column: pro grade and/or self-grade, with a compact delta when both exist."""
+    pro = f"{cp.grading_company} {cp.grade}".strip() if cp.grading_company else None
+    sg = f"{_grade_name(cp.self_grade)} (self)" if cp.self_grade else None
+    if pro and sg:
+        suffix = ""
+        if cp.grade_delta is not None:
+            n = int(cp.grade_delta) if float(cp.grade_delta).is_integer() else cp.grade_delta
+            sign = f"+{n}" if cp.grade_delta > 0 else str(n)
+            suffix = f" (Δ{sign})"
+        return f"{pro} · {sg}{suffix}"
+    return pro or sg or "Raw"
+
+
+def format_card_summary(card: CardOut) -> str:
+    """One-line summary of a card for inline display. Shows the subset (the line) and the parallel
+    finish only when there is one — so a no-finish INSERT reads as its insert name, not 'Base'."""
+    subjects = ", ".join(s.name for s in card.subjects) or "—"
+    slot = (card.subset or "?") + (f" · {card.finish}" if card.finish else "")
+    pr = f" /{card.print_run}" if card.print_run else ""
+    attrs = f" [{', '.join(a.name for a in card.attributes)}]" if card.attributes else ""
+    return f"{card.card_number}  {subjects} — {card.brand or ''} {card.set_name or ''} — {slot}{pr}{attrs}"
+
+
+def _more(shown: int, total: int, hint: str) -> None:
+    """Standard 'N of M shown' footer — one place so every list truncates the same way."""
+    if total > shown:
+        console.print(f"  [slab.dim]{shown} of {total} shown — {hint}[/]")
+
+
+def print_cards(result: CardSearchResult) -> None:
+    if not result.items:
+        console.print("[slab.dim]No cards found.[/]")
+        return
+
+    table = slab_table([
+        ("Number", {"style": "slab.value"}),
+        ("Subject(s)", {}),
+        ("Set", {}),
+        ("Subset", {}),
+        ("Finish", {"style": "slab.accent"}),
+        ("Attrs", {"style": "slab.dim"}),
+        ("Run", {"justify": "right", "style": "slab.dim"}),
+        ("UUID", {"style": "slab.muted"}),
+    ])
+
+    for c in result.items:
+        subjects = ", ".join(s.name for s in c.subjects)
+        attrs = ", ".join(a.name for a in c.attributes)
+        finish = c.finish or "[slab.dim]Base[/]"
+        pr = f"/{c.print_run}" if c.print_run else ""
+        table.add_row(
+            c.card_number, subjects, c.set_name or "", c.subset or "",
+            finish, attrs, pr, c.uuid[:8],
+        )
+
+    console.print(heading("Cards", f"{result.total} total"))
+    console.print(table)
+    _more(len(result.items), result.total, "narrow your search, or `--limit N` to see more.")
+
+
+def print_sets(result: SetSearchResult) -> None:
+    if not result.items:
+        console.print("[slab.dim]No sets found.[/]")
+        return
+
+    table = slab_table([
+        ("Name", {"style": "slab.value"}),
+        ("Brand", {}),
+        ("Cards", {"justify": "right", "style": "slab.dim"}),
+        ("Priced", {"justify": "right"}),
+        ("Sales/90d", {"justify": "right", "style": "slab.dim"}),
+        ("Box FMV", {"justify": "right"}),
+    ])
+
+    for s in result.items:
+        # Priced = printings with a sale in the past 90 days; the % against the full card
+        # count says how much of the set the market actually prices (color = health band).
+        priced = "[slab.dim]—[/]"
+        if s.priced_count:
+            pct = f" ({pct_coverage(100 * s.priced_count / s.card_count)})" if s.card_count else ""
+            priced = f"{s.priced_count:,}{pct}"
+        box = f"[slab.foil]{money(s.box_price)}[/]" if s.box_price is not None else "[slab.dim]—[/]"
+        table.add_row(
+            s.name or "", s.brand or "",
+            f"{s.card_count or 0:,}",
+            priced,
+            f"{s.sales_90d:,}" if s.sales_90d else "[slab.dim]—[/]",
+            box,
+        )
+
+    console.print(heading("Sets", f"{result.total} total"))
+    console.print(table)
+    _more(len(result.items), result.total, "narrow with a query (e.g. `slab set search platinum`).")
+
+
+def print_collection(result: CollectionResult) -> None:
+    if not result.items:
+        console.print("[dim]No cards in your collection matching that search.[/dim]")
+        if result.total == 0:
+            console.print("  [dim]Use `slab collection add` to start cataloging cards.[/dim]")
+        return
+
+    table = slab_table([
+        ("Card #", {"style": "slab.value"}),
+        ("Subject(s)", {}),
+        ("Set", {}),
+        ("Finish", {"style": "slab.accent"}),
+        ("Grade", {"style": "slab.dim"}),
+        ("Cost Basis", {"justify": "right"}),
+        ("FMV", {"justify": "right"}),
+        ("Gain/Loss", {"justify": "right"}),
+    ])
+
+    for cp in result.items:
+        card = cp.card
+        subjects = ", ".join(s.name for s in card.subjects) if card and card.subjects else "—"
+        set_name = (card.set_name or "") if card else ""
+        finish = ((card.finish if card else None) or "[slab.dim]Base[/]")
+        card_num = card.card_number if card else "—"
+        grade = _format_collection_grade(cp)
+        basis = money(cp.cost_basis) if cp.cost_basis is not None else "[slab.dim]—[/]"
+        fmv = "[slab.dim]—[/]"
+        gain = "[slab.dim]—[/]"
+        if cp.market and cp.market.fair_market_value is not None:
+            fmv = f"[slab.foil]{money(cp.market.fair_market_value)}[/]"
+            gain = signed_money(cp.market.unrealized_gain_loss)
+        table.add_row(card_num, subjects, set_name, finish, grade, basis, fmv, gain)
+
+    matches = f"{result.total} match{'' if result.total == 1 else 'es'}"
+    console.print(heading("Collection", matches))
+    console.print(table)
+
+    if result.summary:
+        s = result.summary
+        parts = []
+        if s.total_acquisition_cost is not None:
+            parts.append(f"[slab.label]Acquisition[/] {money(s.total_acquisition_cost)}")
+        if s.total_additional_costs is not None:
+            parts.append(f"[slab.label]Additional[/] {money(s.total_additional_costs)}")
+        if s.total_cost_basis is not None:
+            parts.append(f"[slab.label]Cost Basis[/] {money(s.total_cost_basis)}")
+        if isinstance(s, PortfolioSummary) and s.portfolio_value is not None:
+            parts.append(f"[slab.label]FMV[/] [slab.foil]{money(s.portfolio_value)}[/]")
+            if s.total_unrealized_gain_loss is not None:
+                parts.append(f"[slab.label]Unrealized[/] {signed_money(s.total_unrealized_gain_loss)}")
+        if parts:
+            console.print("  " + "     ".join(parts))
+
+    _more(len(result.items), result.total, "narrow your search, or `slab export` for the full list.")
+
+
+def print_breaks(result: BreakSearchResult) -> None:
+    if not result.items:
+        console.print("[slab.dim]No breaks found.[/]")
+        console.print("  [slab.dim]Use `slab break new` to record opening a pack, box, or case.[/]")
+        return
+
+    table = slab_table([
+        ("Set", {"style": "slab.value"}),
+        ("Type", {"style": "slab.dim"}),
+        ("Cost", {"justify": "right"}),
+        ("Cards", {"justify": "right", "style": "slab.dim"}),
+        ("$/Card", {"justify": "right", "style": "slab.dim"}),
+        ("Date", {"style": "slab.dim"}),
+        ("Source", {"style": "slab.dim"}),
+        ("UUID", {"style": "slab.muted"}),
+    ])
+
+    for b in result.items:
+        cpc = money(b.cost_per_card) if b.cost_per_card is not None else "—"
+        table.add_row(
+            b.set_name or "", b.break_type, money(b.total_cost),
+            str(b.copy_count), cpc, str(b.break_date or "—"),
+            b.source or "—", b.uuid[:8],
+        )
+
+    console.print(heading("Breaks", f"{result.total} total"))
+    console.print(table)
+    _more(len(result.items), result.total, "refine with filters.")
+
+
+def _pull_row(cp) -> tuple[str, str, str, str, str]:
+    """One pull as (card #, subjects, finish, run/serial, FMV) — shared by both pull tables."""
+    card = cp.card
+    subjects = ", ".join(s.name for s in card.subjects) if card and card.subjects else "—"
+    finish = ((card.finish if card else None) or "[slab.dim]Base[/]")
+    run = ""
+    if card and card.print_run:
+        run = f"{cp.serial_number}/{card.print_run}" if cp.serial_number else f"/{card.print_run}"
+    fmv = "[slab.dim]—[/]"
+    if cp.market and cp.market.fair_market_value is not None:
+        fmv = f"[slab.foil]{money(cp.market.fair_market_value)}[/]"
+    return (card.card_number if card else "—", subjects, finish, run, fmv)
+
+
+def _pull_table(pulls) -> object:
+    table = slab_table([
+        ("Card #", {"style": "slab.value"}),
+        ("Subject(s)", {}),
+        ("Finish", {"style": "slab.accent"}),
+        ("Run", {"justify": "right", "style": "slab.dim"}),
+        ("FMV", {"justify": "right"}),
+    ])
+    for cp in pulls:
+        table.add_row(*_pull_row(cp))
+    return table
+
+
+def render_break_pulls(brk, result: CollectionResult) -> None:
+    """A break's report card: what you paid vs what the pulls are worth today, then the most
+    valuable pulls and the rarest (lowest print run). Every number in plain words — this view
+    answers "did the box pay for itself?" at a glance."""
+    console.print()
+    t = Text()
+    t.append(brk.set_name or "Break", style="slab.value")
+    t.append(f"  —  {brk.break_type} · {brk.break_date or '—'}"
+             + (f" · {brk.source}" if brk.source else ""), style="slab.dim")
+    console.print(t)
+
+    if not result.items:
+        console.print("\n  [slab.dim]No pulls cataloged for this break yet — "
+                      "`slab break fill` walks the checklist.[/]\n")
+        return
+
+    def _fmv(cp):
+        return cp.market.fair_market_value if (cp.market and cp.market.fair_market_value is not None) else None
+
+    priced = [cp for cp in result.items if _fmv(cp) is not None]
+    total_fmv = sum(_fmv(cp) * (cp.quantity or 1) for cp in priced)
+    unpriced = len(result.items) - len(priced)
+
+    # The money shot, in plain words: cost in, value out, and what that means.
+    net = total_fmv - brk.total_cost
+    verdict = "the box has paid for itself" if net >= 0 else "the box hasn't paid for itself (yet)"
+    console.print(
+        f"\n  You paid [slab.value]{money(brk.total_cost)}[/] · your {len(result.items)} pulls are "
+        f"worth [slab.foil]{money(total_fmv)}[/] today → {signed_money(net)} — {verdict}."
+    )
+    if unpriced:
+        console.print(f"  [slab.dim]{unpriced} pull(s) have no market price yet and count as $0 here — "
+                      f"the real total can only be higher.[/]")
+
+    top = sorted(priced, key=_fmv, reverse=True)[:10]
+    if top:
+        console.print(heading("Most Valuable Pulls", f"top {len(top)} of {len(priced)} priced"))
+        console.print(_pull_table(top))
+
+    rare = sorted(
+        (cp for cp in result.items if cp.card and cp.card.print_run),
+        key=lambda cp: cp.card.print_run,
+    )[:5]
+    if rare:
+        console.print(heading("Rarest Pulls", "lowest print run — fewest copies exist"))
+        console.print(_pull_table(rare))
+    console.print()
+
+
+def print_lots(result: LotSearchResult) -> None:
+    if not result.items:
+        console.print("[slab.dim]No purchases found.[/]")
+        console.print("  [slab.dim]Use `slab lot new` to record a multi-card buy (an eBay bundle, a show pickup).[/]")
+        return
+
+    table = slab_table([
+        ("Date", {"style": "slab.dim"}),
+        ("Cost", {"justify": "right"}),
+        ("Cards", {"justify": "right", "style": "slab.dim"}),
+        ("$/Card", {"justify": "right", "style": "slab.dim"}),
+        ("Source", {"style": "slab.dim"}),
+        ("UUID", {"style": "slab.muted"}),
+    ])
+
+    for lot in result.items:
+        cpc = money(lot.cost_per_card) if lot.cost_per_card is not None else "—"
+        table.add_row(
+            str(lot.lot_date or "—"), money(lot.total_cost),
+            str(lot.copy_count), cpc, lot.source or "—", lot.uuid[:8],
+        )
+
+    console.print(heading("Purchases", f"{result.total} total"))
+    console.print(table)
+    _more(len(result.items), result.total, "refine with filters.")
+
+
+def render_lot_contents(lot, result: CollectionResult) -> None:
+    """A purchase's report card: what you paid vs what the cards are worth today, then the most
+    valuable and rarest cards in it. Answers "did that bundle come out ahead?" at a glance — the
+    lot counterpart of `render_break_pulls`."""
+    console.print()
+    t = Text()
+    t.append(f"Purchase {lot.uuid[:8]}", style="slab.value")
+    t.append(f"  —  {lot.lot_date or '—'}" + (f" · {lot.source}" if lot.source else ""), style="slab.dim")
+    console.print(t)
+
+    if not result.items:
+        console.print("\n  [slab.dim]No cards attached to this purchase yet — "
+                      "`slab lot fill` adds them one by one.[/]\n")
+        return
+
+    def _fmv(cp):
+        return cp.market.fair_market_value if (cp.market and cp.market.fair_market_value is not None) else None
+
+    priced = [cp for cp in result.items if _fmv(cp) is not None]
+    total_fmv = sum(_fmv(cp) * (cp.quantity or 1) for cp in priced)
+    unpriced = len(result.items) - len(priced)
+
+    net = total_fmv - lot.total_cost
+    verdict = "the purchase is above water" if net >= 0 else "the purchase is underwater (for now)"
+    console.print(
+        f"\n  You paid [slab.value]{money(lot.total_cost)}[/] · its {len(result.items)} cards are "
+        f"worth [slab.foil]{money(total_fmv)}[/] today → {signed_money(net)} — {verdict}."
+    )
+    if unpriced:
+        console.print(f"  [slab.dim]{unpriced} card(s) have no market price yet and count as $0 here — "
+                      f"the real total can only be higher.[/]")
+
+    top = sorted(priced, key=_fmv, reverse=True)[:10]
+    if top:
+        console.print(heading("Most Valuable", f"top {len(top)} of {len(priced)} priced"))
+        console.print(_pull_table(top))
+
+    rare = sorted(
+        (cp for cp in result.items if cp.card and cp.card.print_run),
+        key=lambda cp: cp.card.print_run,
+    )[:5]
+    if rare:
+        console.print(heading("Rarest", "lowest print run — fewest copies exist"))
+        console.print(_pull_table(rare))
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# Dashboards (collection + slab-wide) — shared visual helpers
+# ---------------------------------------------------------------------------
+
+def _dist_panel(title: str, items: list[LabeledCount]) -> Group | None:
+    """A ranked distribution as bars — heading + slate card. None when empty."""
+    if not items:
+        return None
+    maxv = max(i.count for i in items)
+    # Cap labels generously — set names like "2025-26 Upper Deck Series One" run past 24 chars and
+    # were being clipped; 40 fits typical set names while keeping the bar/count columns aligned.
+    lines = "\n".join(
+        f"{bar(i.count, maxv)} [slab.value]{i.count:>6,}[/]  {i.label[:40]}" for i in items
+    )
+    return section(title, Text.from_markup(lines))
+
+
+def _highlight_panel(title: str, cards: list[HighlightCard], show_cost: bool = False) -> Group | None:
+    """A short list of standout cards — heading + slate card. None when empty."""
+    if not cards:
+        return None
+    rows = []
+    for h in cards:
+        subj = ", ".join(h.subjects) or "—"
+        slot = (h.subset or "?") + (f" · {h.finish}" if h.finish else "")
+        run = f" /{h.print_run}" if h.print_run else ""
+        cost = f"   [slab.gain]{money(h.cost_basis)}[/]" if (show_cost and h.cost_basis is not None) else ""
+        rows.append(f"[slab.value]#{h.card_number}[/] {subj}  [slab.dim]{slot}{run}[/]{cost}")
+    return section(title, Text.from_markup("\n".join(rows)))
+
+
+def _n(count: int, sing: str, plur: str | None = None) -> str:
+    """Count + correctly-pluralized noun: '1 break' / '2 breaks'."""
+    return f"{count:,} {sing if count == 1 else (plur or sing + 's')}"
+
+
+def _breakdown_panel(title: str, total: int, parts: list[tuple[str, int, str]]) -> Group:
+    """A 'sum' card: an explicit `a + b = total` line over a single stacked bar, so the parts
+    visibly add up to the whole. `parts` is [(label, count, style), ...]."""
+    width = 46
+    segs, terms, used = [], [], 0
+    for i, (label, count, style) in enumerate(parts):
+        w = (width - used) if i == len(parts) - 1 else (round(count / total * width) if total else 0)
+        used += w
+        segs.append(f"[{style}]{'█' * w}[/]")
+        pct = f"{count / total:.0%}" if total else "0%"
+        terms.append(f"[{style}]{count:,} {label}[/] [slab.dim]({pct})[/]")
+    body = " [slab.dim]+[/] ".join(terms) + f"  [slab.dim]=[/]  [slab.value]{total:,} total[/]\n" + "".join(segs)
+    return section(title, Text.from_markup(body))
+
+
+def _composition_panel(*, rookies, autos, relics, numbered, one_of_ones, footer=None) -> Group:
+    """The rookie/auto/relic/numbered/1-of-1 attribute strip — attributes in accent, the 1/1 in
+    foil (the rarest = the hero highlight). Shared by the collection + catalog dashboards."""
+    line = (
+        f"[slab.accent]🌟 {_n(rookies, 'rookie')}[/]    [slab.accent]✍️  {_n(autos, 'auto')}[/]    "
+        f"[slab.accent]🧵 {_n(relics, 'relic')}[/]    [slab.value]#️⃣  {numbered:,} numbered[/]    "
+        f"[slab.foil]💎 {_n(one_of_ones, '1/1')}[/]"
+    )
+    if footer:
+        line += f"\n[slab.dim]{footer}[/]"
+    return section("Composition", Text.from_markup(line))
+
+
+def render_dashboard(d: DashboardStats) -> None:
+    console.print(slab_panel(Text.from_markup(
+        f"[slab.foil]🃏  {d.collector}'s Collection[/]\n"
+        f"[slab.dim]{_n(d.total_cards, 'card')} · {_n(d.players, 'player')} · "
+        f"{_n(d.teams, 'team')} · {_n(d.breaks, 'break')} · {_n(d.lots, 'purchase')}[/]"
+    ), foil=True))
+    # Build each section, then arrange into horizontal rows (they stack automatically on a terminal
+    # too narrow to fit them side by side — see theme.row).
+    cards = _breakdown_panel("Cards", d.total_cards, [
+        ("base", d.base_count, "slab.accent"),
+        ("parallels", d.parallel_count, "slab.foil"),
+    ])
+
+    rows: list[tuple[str, str]] = [(
+        "Cost Basis",
+        f"{money(d.total_cost_basis)}   [slab.dim]avg {money(d.avg_cost_per_card)} / card[/]",
+    )]
+    if d.portfolio_value is not None:
+        mv = f"[slab.foil]{money(d.portfolio_value)}[/]"
+        if d.portfolio_change_7d is not None:
+            mv += f"   {signed_money(d.portfolio_change_7d)} [slab.dim]appraisal 7d[/]"
+        rows.append(("Market Value", mv))
+        if d.total_unrealized_gain_loss is not None:
+            roi_str = ""
+            if d.portfolio_roi is not None:
+                sign = "+" if d.total_unrealized_gain_loss >= 0 else ""
+                roi_str = f"  [slab.dim]({sign}{float(d.portfolio_roi) * 100:.1f}% ROI)[/]"
+            rows.append(("Unrealized", f"{signed_money(d.total_unrealized_gain_loss)}{roi_str}"))
+        if d.priced_coverage is not None:
+            rows.append(("Coverage", f"{pct_coverage(float(d.priced_coverage) * 100)} [slab.dim]priced[/]"))
+        # Portfolio value over time — the CLI stand-in for the portal's chart, from the same payload.
+        if len(d.portfolio_series) >= 2:
+            vals = [p.portfolio_value for p in d.portfolio_series]
+            net = float(vals[-1]) - float(vals[0])
+            rows.append(("Trend 90d", f"{sparkline(vals)}   {signed_money(net)}"))
+    value = section("Value", kv_grid(rows), foil=True)
+
+    comp = _composition_panel(
+        rookies=d.rookies, autos=d.autos, relics=d.relics, numbered=d.numbered,
+        one_of_ones=d.one_of_ones, footer=f"{d.graded_count} graded · {d.raw_count} raw",
+    )
+    # How many cards you own from each set — the collection's "Biggest Sets".
+    your_sets = _dist_panel("Your Sets", d.top_sets)
+    rarest = _highlight_panel("💎 Rarest", d.rarest)
+
+    breaks = None
+    if d.break_stats:
+        table = slab_table([
+            ("Date", {"style": "slab.dim"}),
+            ("Product", {"style": "slab.value"}),
+            ("Type", {"style": "slab.dim"}),
+            ("Cost", {"justify": "right"}),
+            ("Cards", {"justify": "right", "style": "slab.dim"}),
+            ("$/card", {"justify": "right", "style": "slab.dim"}),
+        ])
+        for b in d.break_stats:
+            table.add_row(str(b.break_date or "—"), b.set_name or "—", b.break_type or "—",
+                          money(b.total_cost), str(b.cards), money(b.cost_per_card))
+        breaks = titled("Breaks", table)
+
+    lots = None
+    if d.lot_stats:
+        table = slab_table([
+            ("Date", {"style": "slab.dim"}),
+            ("Source", {"style": "slab.value"}),
+            ("Cost", {"justify": "right"}),
+            ("Cards", {"justify": "right", "style": "slab.dim"}),
+            ("$/card", {"justify": "right", "style": "slab.dim"}),
+        ])
+        for lot in d.lot_stats:
+            table.add_row(str(lot.lot_date or "—"), lot.source or "—",
+                          money(lot.total_cost), str(lot.cards), money(lot.cost_per_card))
+        lots = titled("Purchases", table)
+
+    console.print(cards)
+    console.print(value)
+    console.print(comp)
+    if your_sets:
+        console.print(your_sets)
+    if breaks:
+        console.print(breaks)
+    if lots:
+        console.print(lots)
+    if rarest:
+        console.print(rarest)
+
+
+def _catalog_stat_panels(c: CatalogStats, *, title: str = "📚  slab catalog") -> list:
+    """The catalog-overview renderables (header + card breakdown + composition + biggest sets),
+    the top of the `slab community` board."""
+    panels: list = [slab_panel(Text.from_markup(
+        f"[slab.foil]{title}[/]\n"
+        f"[slab.dim]{_n(c.sets, 'set')} · {_n(c.players, 'player')} · {_n(c.teams, 'team')}[/]"
+    ), foil=True)]
+    # Cards = base + parallels, shown so the parts visibly add up.
+    panels.append(_breakdown_panel("Cards", c.total_cards, [
+        ("base", c.base_cards, "slab.accent"),
+        ("parallels", c.parallels, "slab.foil"),
+    ]))
+    panels.append(_composition_panel(
+        rookies=c.rookies, autos=c.autos, relics=c.relics,
+        numbered=c.numbered, one_of_ones=c.one_of_ones,
+    ))
+    p = _dist_panel("Biggest Sets", c.biggest_sets)
+    if p:
+        panels.append(p)
+    return panels
+
+
+# ---------------------------------------------------------------------------
+# Community board (mirrors the portal's community page)
+# ---------------------------------------------------------------------------
+
+def _ccard_label(card: CommunityCard) -> str:
+    """One-line markup for a community-leaderboard card: `#num Player — Set · Subset · Finish /run`."""
+    subj = ", ".join(card.subjects) or "—"
+    ctx = " · ".join(filter(None, [card.set_name, card.subset, card.finish]))
+    run = f" [slab.foil]/{card.print_run}[/]" if card.print_run else ""
+    tail = f"  [slab.dim]{ctx}[/]" if ctx else ""
+    return f"[slab.value]#{card.card_number}[/] {subj}{tail}{run}"
+
+
+def _valuable_table(title: str, entries: list[ValuableCard]) -> Group | None:
+    if not entries:
+        return None
+    table = slab_table([
+        ("Card", {}),
+        ("Grade", {"style": "slab.dim"}),
+        ("FMV", {"justify": "right", "style": "slab.foil"}),
+        ("Comps", {"justify": "right", "style": "slab.muted"}),
+    ])
+    for e in entries:
+        table.add_row(Text.from_markup(_ccard_label(e.card)), e.market.grade_key,
+                      money(e.market.fair_market_value), str(e.market.sample_size))
+    return titled(title, table)
+
+
+def _collected_cards_table(entries: list[CollectedCard]) -> Group | None:
+    if not entries:
+        return None
+    table = slab_table([
+        ("Card", {}),
+        ("Collectors", {"justify": "right", "style": "slab.value"}),
+        ("Copies", {"justify": "right", "style": "slab.dim"}),
+    ])
+    for e in entries:
+        table.add_row(Text.from_markup(_ccard_label(e.card)), str(e.collector_count), str(e.copy_count))
+    return titled("Most Collected", table)
+
+
+def _collected_players_table(entries: list[CollectedPlayer]) -> Group | None:
+    if not entries:
+        return None
+    table = slab_table([
+        ("Player", {"style": "slab.value"}),
+        ("Collectors", {"justify": "right", "style": "slab.value"}),
+        ("Copies", {"justify": "right", "style": "slab.dim"}),
+    ])
+    for e in entries:
+        table.add_row(e.name, str(e.collector_count), str(e.copy_count))
+    return titled("Most Collected Players", table)
+
+
+def _hot_momentum(cur: int, prev: int) -> str:
+    """The window-over-window badge in plain terms: 'new' (was silent), ×N up, ×N down, or steady."""
+    if prev == 0:
+        return "[slab.accent]new[/]"
+    ratio = cur / prev
+    if ratio >= 1.5:
+        return f"[slab.accent]↑{ratio:.1f}×[/]"
+    if ratio <= 0.67:
+        return f"[slab.dim]↓{prev / cur:.1f}×[/]" if cur else "[slab.dim]↓[/]"
+    return "[slab.dim]steady[/]"
+
+
+def _hot_trend(pct: float | None) -> str:
+    """Price direction arrow — how to tell a breakout (selling up) from a sell-off (selling down)."""
+    if pct is None:
+        return "[slab.dim]—[/]"
+    if pct > 2:
+        return f"[slab.gain]↗ +{pct:.0f}%[/]"
+    if pct < -2:
+        return f"[slab.loss]↘ {pct:.0f}%[/]"
+    return f"[slab.dim]→ {pct:+.0f}%[/]"
+
+
+def _hottest_players_table(entries: list[HotPlayer]) -> Group | None:
+    if not entries:
+        return None
+    table = slab_table([
+        ("Player", {"style": "slab.value"}),
+        ("Sales (30d)", {"justify": "right", "style": "slab.value"}),
+        ("vs Prior 30d", {"justify": "right"}),
+        ("$ Volume", {"justify": "right"}),
+        ("Cards", {"justify": "right", "style": "slab.dim"}),
+        ("Prices", {"justify": "right"}),
+    ])
+    for e in entries:
+        table.add_row(
+            e.name,
+            str(e.sales_30d),
+            _hot_momentum(e.sales_30d, e.sales_prev_30d),
+            money(e.dollar_volume_30d),
+            str(e.distinct_cards_30d),
+            _hot_trend(e.price_trend_pct),
+        )
+    return titled("🔥 Hottest Players", table)
+
+
+def _rarest_owned_table(entries: list[RarestOwnedCard]) -> Group | None:
+    if not entries:
+        return None
+    table = slab_table([
+        ("Card", {}),
+        ("Collectors", {"justify": "right", "style": "slab.value"}),
+    ])
+    for e in entries:
+        table.add_row(Text.from_markup(_ccard_label(e.card)), str(e.collector_count))
+    return titled("💎 Rarest Owned", table)
+
+
+def _ticker_panel(items: list[TickerItem]) -> Group | None:
+    if not items:
+        return None
+    lines = "\n".join(f"{i.icon}  {i.text}" for i in items)
+    return section("What's Happening", Text.from_markup(lines))
+
+
+def render_community_board(b: CommunityBoard) -> None:
+    """The whole community picture — catalog overview + activity ticker + leaderboards + popular
+    chase sets — mirroring the portal's community page from the single GET /community payload."""
+    for panel in _catalog_stat_panels(b.stats, title="🌐  community board"):
+        console.print(panel)
+
+    for block in (
+        _ticker_panel(b.ticker),
+        _valuable_table("Most Valuable — Raw", b.most_valuable_raw),
+        _valuable_table("Most Valuable — Graded", b.most_valuable_graded),
+        _collected_cards_table(b.most_collected),
+        _collected_players_table(b.most_collected_players),
+        _hottest_players_table(b.hottest_players),
+        _rarest_owned_table(b.rarest_owned),
+    ):
+        if block:
+            console.print(block)
+
+    if b.popular_sets:
+        table = slab_table([
+            ("Name", {"style": "slab.value"}),
+            ("Type", {"style": "slab.dim"}),
+            ("Cards", {"justify": "right", "style": "slab.dim"}),
+            ("Subs", {"justify": "right", "style": "slab.value"}),
+            ("Creator", {"style": "slab.dim"}),
+        ])
+        for s in b.popular_sets:
+            table.add_row(s.name, s.set_type, str(s.card_count),
+                          str(s.subscriber_count), s.creator_name or "—")
+        console.print(titled("Popular Chase Sets", table))
+
+
+# ---------------------------------------------------------------------------
+# Custom sets
+# ---------------------------------------------------------------------------
+
+def print_custom_sets(result: CustomSetSearchResult | list[CustomSetOut]) -> None:
+    items = result.items if isinstance(result, CustomSetSearchResult) else result
+    if not items:
+        console.print("[dim]No custom sets found.[/dim]")
+        console.print("  [dim]Use `slab chase create` to make one.[/dim]")
+        return
+
+    total = result.total if isinstance(result, CustomSetSearchResult) else len(items)
+    table = slab_table([
+        ("Name", {"style": "slab.value"}),
+        ("Type", {"style": "slab.dim"}),
+        ("Vis", {"justify": "center"}),
+        ("Cards", {"justify": "right", "style": "slab.dim"}),
+        ("Subs", {"justify": "right", "style": "slab.dim"}),
+        ("Creator", {}),
+        ("UUID", {"style": "slab.muted"}),
+    ])
+
+    for s in items:
+        vis = "🔒" if s.visibility == "private" else "🌐"
+        sub_marker = " [slab.gain]✓[/]" if s.is_subscribed else ""
+        table.add_row(
+            s.name, s.set_type, vis, str(s.card_count),
+            f"{s.subscriber_count}{sub_marker}", s.creator_name or "—", s.uuid[:8],
+        )
+
+    console.print(heading("Custom Sets", f"{total} total"))
+    console.print(table)
+
+
+def print_custom_set_detail(detail: CustomSetDetail) -> None:
+    vis = "Public" if detail.visibility == "public" else "Private"
+    sub = "subscribed" if detail.is_subscribed else "not subscribed"
+
+    head = [f"[slab.dim]{detail.set_type} · {vis} · {sub}[/]"]
+    if detail.description:
+        head.append(detail.description)
+    head.append(f"[slab.label]Creator[/] {detail.creator_name or '—'}   "
+                f"[slab.label]Subscribers[/] {detail.subscriber_count}")
+    head.append(f"[slab.muted]{detail.uuid}[/]")
+    if detail.completion:
+        c = detail.completion
+        style = "slab.gain" if c.completion_pct == 100 else ("slab.foil" if c.completion_pct >= 50 else "slab.loss")
+        head.append(
+            f"{bar(c.completion_pct, 100, 20, style=style)}  "
+            f"[slab.value]{c.owned_cards}/{c.total_cards}[/] [slab.dim]({c.completion_pct}%)[/]"
+        )
+
+    console.print(heading(detail.name))
+    console.print(slab_panel(Text.from_markup("\n".join(head)), foil=False))
+
+    if detail.cards:
+        table = slab_table([
+            ("#", {"style": "slab.dim", "justify": "right"}),
+            ("Card", {}),
+            ("Match", {"style": "slab.dim"}),
+            ("Owned", {"justify": "center"}),
+        ])
+
+        for entry in detail.cards:
+            card = entry.card
+            subjects = ", ".join(s.name for s in card.subjects) if card else "—"
+            slot = (card.subset or "?") + (f" · {card.finish}" if card and card.finish else "")
+            pr = f" /{card.print_run}" if card and card.print_run else ""
+            label = f"{card.card_number}  {subjects} [slab.dim]— {slot}{pr}[/]" if card else "—"
+
+            match = entry.match_mode
+            if entry.match_mode == "exact_serial" and entry.serial_number is not None:
+                match = f"serial #{entry.serial_number}"
+
+            if entry.owned:
+                owned = f"[slab.gain]✓[/] [slab.dim]{entry.owned_printing or ''}[/]"
+            else:
+                owned = "[slab.loss]✗[/]"
+            table.add_row(str(entry.position), label, match, owned)
+
+        console.print(table)
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# Market pricing
+# ---------------------------------------------------------------------------
+
+def _card_headline(card_number, subjects: str, set_name: str | None, slot: str) -> Text:
+    """The `#num  Player — Set — Subset · Finish` context line above a market/comps/history card."""
+    t = Text()
+    t.append(f"#{card_number}  ", style="slab.value")
+    t.append(subjects)
+    t.append(f"  —  {set_name or '—'}  —  {slot}", style="slab.dim")
+    return t
+
+
+def render_card_market(m: CardMarket) -> None:
+    """Display the market pricing for a catalog card — all grade buckets."""
+    subjects = ", ".join(m.subjects) or "—"
+    slot = (m.subset or "?") + (f" · {m.finish}" if m.finish else "")
+    console.print()
+    console.print(_card_headline(m.card_number, subjects, m.set_name, slot))
+
+    if not m.price_points:
+        console.print("\n  [slab.dim]No market data available for this card.[/]\n")
+        return
+
+    # The Δ columns are FMV (appraisal) drift, not the window's sales — FMV smooths 90 days of
+    # comps, so these lag the live market (two-lane rule, CLAUDE.md). Headers say FMV so a
+    # "+$5" cell reads as the appraisal moving, not as last week's market.
+    table = slab_table([
+        ("Grade", {"style": "slab.value"}),
+        ("FMV", {"justify": "right"}),
+        ("Range", {"justify": "right", "style": "slab.dim"}),
+        ("FMV Δ7d", {"justify": "right"}),
+        ("FMV Δ30d", {"justify": "right"}),
+        ("Comps", {"justify": "right", "style": "slab.dim"}),
+    ])
+
+    for pp in sorted(m.price_points, key=lambda p: (p.finish or "", p.grade_key)):
+        label = pp.grade_key
+        if pp.finish:
+            label = f"{pp.finish} · {pp.grade_key}"
+        fmv = f"[slab.foil]{money(pp.price_median)}[/]"
+        rng = "—"
+        if pp.price_low is not None and pp.price_high is not None:
+            rng = f"${pp.price_low:,.0f} – ${pp.price_high:,.0f}"
+        table.add_row(label, fmv, rng, signed_money(pp.price_change_7d),
+                      signed_money(pp.price_change_30d), str(pp.sample_size))
+
+    window = m.price_points[0].window_days
+    console.print(heading("Market Price", f"{window}-day window, as of {m.as_of_date}"))
+    console.print(table)
+    console.print()
+
+
+def _format_label(fmt: str) -> str:
+    """SealedFormat value -> display label: hobby_box -> Hobby Box."""
+    return fmt.replace("_", " ").title()
+
+
+def _sealed_config(p: SealedProductOut) -> str:
+    """A compact config string for a sealed SKU: '12 packs × 8 cards' / '8 boxes'."""
+    parts = []
+    if p.boxes_per_case:
+        parts.append(f"{p.boxes_per_case} boxes")
+    if p.packs_per_box:
+        parts.append(f"{p.packs_per_box} packs")
+    if p.cards_per_pack:
+        parts.append(f"{p.cards_per_pack} cards")
+    return " × ".join(parts) if parts else "—"
+
+
+def render_set_market(s: SetOut, sealed: list[SealedProductOut], top: SetTopCards) -> None:
+    """The set market view: every sealed SKU with its FMV, then the priciest cards inside —
+    what the wax costs next to what you're chasing in it."""
+    console.print()
+    t = Text()
+    t.append(s.name or s.slug, style="slab.value")
+    t.append(f"  —  {s.brand or '—'}  —  {s.season or '—'}", style="slab.dim")
+    console.print(t)
+
+    # --- sealed SKUs ---
+    priced = [p for p in sealed if p.price_median is not None]
+    if not sealed:
+        console.print("\n  [slab.dim]No sealed products catalogued for this set.[/]")
+    else:
+        table = slab_table([
+            ("Format", {"style": "slab.value"}),
+            ("Config", {"style": "slab.dim"}),
+            ("FMV", {"justify": "right"}),
+            ("MSRP", {"justify": "right", "style": "slab.dim"}),
+            ("Comps", {"justify": "right", "style": "slab.dim"}),
+            ("As of", {"style": "slab.dim"}),
+        ])
+        # Priced first (dearest on top), unpriced after so the whole SKU list is still visible.
+        # No low-confidence marker here — the Comps column IS the confidence signal (a 1 or 2
+        # says "thin" on its own), and a suffix on FMV breaks the right-aligned money column.
+        for p in sorted(sealed, key=lambda p: (p.price_median is None, -float(p.price_median or 0))):
+            fmv = f"[slab.foil]{money(p.price_median)}[/]" if p.price_median is not None else "[slab.dim]—[/]"
+            table.add_row(
+                _format_label(p.format.value),
+                _sealed_config(p),
+                fmv,
+                money(p.msrp) if p.msrp is not None else "—",
+                str(p.sample_size) if p.sample_size is not None else "—",
+                str(p.as_of_date or "—"),
+            )
+        console.print(heading("Sealed", f"{len(priced)}/{len(sealed)} SKUs priced"))
+        console.print(table)
+
+    # --- top cards ---
+    if not top.cards:
+        console.print("\n  [slab.dim]No card pricing in this set yet.[/]\n")
+        return
+
+    table = slab_table([
+        ("#", {"justify": "right", "style": "slab.dim"}),
+        ("Card", {"style": "slab.value"}),
+        ("Subject", {}),
+        ("Slot", {"style": "slab.dim"}),
+        ("Grade", {"style": "slab.dim"}),
+        ("FMV", {"justify": "right"}),
+        ("Comps", {"justify": "right", "style": "slab.dim"}),
+    ])
+    for i, entry in enumerate(top.cards, 1):
+        slot = (entry.subset or "?") + (f" · {entry.finish}" if entry.finish else "")
+        if entry.print_run:
+            slot += f" /{entry.print_run}"
+        fmv = f"[slab.foil]{money(entry.market.fair_market_value)}[/]"
+        table.add_row(
+            str(i),
+            f"#{entry.card_number}",
+            ", ".join(entry.subjects) or "—",
+            slot,
+            entry.market.grade_key,
+            fmv,
+            str(entry.market.sample_size),
+        )
+    console.print(heading("Top Cards", f"of {top.total_priced} priced printings"))
+    console.print(table)
+    console.print("  [slab.dim]Drill in with `slab card price` / `slab card comps`.[/]\n")
+
+
+def render_comps(c: CardComps) -> None:
+    """Display recent comps (raw sales) for a catalog card — the evidence behind its FMV."""
+    subjects = ", ".join(c.subjects) or "—"
+    slot = (c.subset or "?") + (f" · {c.finish}" if c.finish else "")
+    console.print()
+    console.print(_card_headline(c.card_number, subjects, c.set_name, slot))
+
+    if not c.comps:
+        console.print("\n  [slab.dim]No comps found for this card yet.[/]\n")
+        return
+
+    table = slab_table([
+        ("Date", {"style": "slab.dim"}),
+        ("Price", {"justify": "right", "style": "slab.foil"}),
+        ("Grade", {}),
+        ("Market", {"style": "slab.dim"}),
+        ("Type", {"style": "slab.dim"}),
+        ("Title", {}),
+    ])
+
+    for comp in c.comps:
+        when = comp.sold_date.isoformat() if comp.sold_date else "—"
+        price = money(comp.sale_price) if comp.sale_price is not None else "—"
+        grade = comp.grade_key or "—"
+        market = comp.marketplace or "—"
+        sale_type = comp.sale_type or "—"
+        title = comp.title if len(comp.title) <= 50 else comp.title[:49] + "…"
+        table.add_row(when, price, grade, market, sale_type, title)
+
+    console.print(heading("Recent Comps", f"showing {len(c.comps)} of {c.total}"))
+    console.print(table)
+    console.print()
+
+
+def _render_portfolio_by_set(by_set: list | None) -> None:
+    """Per-set breakdown, most valuable first. Highlights the top set and shows comp coverage."""
+    if not by_set:
+        return
+
+    table = slab_table([
+        ("Set", {"style": "slab.value", "no_wrap": False}),
+        ("Cards", {"justify": "right", "style": "slab.dim"}),
+        ("Cost Basis", {"justify": "right"}),
+        ("FMV", {"justify": "right"}),
+        ("Gain/Loss", {"justify": "right"}),
+        ("Comps", {"justify": "right"}),
+    ])
+
+    for i, st in enumerate(by_set):
+        # crown the single most valuable set
+        name = f"[slab.foil]★[/] {st['name']}" if i == 0 and st["has_fmv"] else st["name"]
+        cards = f"{st['total_qty']:,}"
+        basis = money(st["cost_basis"])
+        fmv = f"[slab.foil]{money(st['fmv'])}[/]" if st["has_fmv"] else "[slab.dim]—[/]"
+        gain = signed_money(st["unrealized"])
+        comps = pct_coverage(st["comp_pct"])
+
+        table.add_row(name, cards, basis, fmv, gain, comps)
+
+    console.print(heading("By Set", "most valuable first"))
+    console.print(table)
+
+
+def _render_most_valuable_break(mvb: dict | None) -> None:
+    """Highlight the single break whose pulled cards carry the most market value — did it pay off?"""
+    if not mvb:
+        return
+
+    date_str = f"  ·  {mvb['break_date']}" if mvb.get("break_date") else ""
+    title = Text()
+    title.append(mvb["set_name"], style="slab.value")
+    title.append(f"   {mvb['break_type']}{date_str}", style="slab.dim")
+
+    g = mvb["gain"]
+    verdict = "paid off" if g >= 0 else "underwater"
+    roi = f"  [slab.dim]({'+' if g >= 0 else '-'}{abs(g) / mvb['cost'] * 100:.0f}%)[/]" if mvb["cost"] else ""
+
+    body = kv_grid([
+        ("Cost", f"{money(mvb['cost'])}  [slab.dim]({_n(mvb['copy_count'], 'card')})[/]"),
+        ("Market Value", f"[slab.foil]{money(mvb['fmv'])}[/]  [slab.dim]({mvb['priced']} priced)[/]"),
+        ("Net vs Cost", f"{signed_money(g)}{roi}  [slab.dim]· {verdict}[/]"),
+    ])
+
+    console.print(heading("Most Valuable Break"))
+    console.print(slab_panel(Group(title, Text(""), body), foil=True))
+
+
+def render_portfolio(
+    total: int, totals: dict, movers: list | None = None, by_set: list | None = None,
+    most_valuable_break: dict | None = None,
+) -> None:
+    """Display portfolio-level financial summary, per-set breakdown, and optional top movers.
+
+    `totals` is the grand-total dict (cost_basis, fmv, unrealized, roi, priced_qty, total_qty)
+    built from the server's PortfolioSummary — see `_portfolio_totals`."""
+    rows: list[tuple[str, str]] = [("Cost Basis", money(totals["cost_basis"]))]
+
+    if totals["fmv"] is not None:
+        rows.append(("Fair Market Value", f"[slab.foil]{money(totals['fmv'])}[/]"))
+
+        g = totals["unrealized"]
+        if g is not None:
+            roi_str = ""
+            if totals["roi"] is not None:
+                sign = "+" if g >= 0 else ""
+                roi_str = f"  [slab.dim]({sign}{float(totals['roi']) * 100:.1f}% ROI)[/]"
+            rows.append(("Unrealized Gain/Loss", f"{signed_money(g)}{roi_str}"))
+
+        priced, denom = totals["priced_qty"], totals["total_qty"]
+        pct = (priced / denom * 100) if denom > 0 else 0
+        rows.append((
+            "Comps Coverage",
+            f"{pct_coverage(pct)} [slab.dim]have comps · {priced} of {denom} copies priced[/]",
+        ))
+    else:
+        rows.append(("Market", "[slab.dim]no market data available yet[/]"))
+
+    console.print(heading("Portfolio Valuation", _n(total, "card")))
+    console.print(slab_panel(kv_grid(rows), foil=True))
+
+    _render_portfolio_by_set(by_set)
+    _render_most_valuable_break(most_valuable_break)
+
+    # Top movers
+    if movers:
+        table = slab_table([
+            ("Card #", {"style": "slab.value"}),
+            ("Subject(s)", {}),
+            ("Finish", {"style": "slab.accent"}),
+            ("Grade", {"style": "slab.dim"}),
+            ("Cost Basis", {"justify": "right"}),
+            ("FMV", {"justify": "right"}),
+            ("Gain/Loss", {"justify": "right"}),
+        ])
+
+        for cp in movers:
+            card = cp.card
+            subjects = ", ".join(s.name for s in card.subjects) if card and card.subjects else "—"
+            card_num = card.card_number if card else "—"
+            finish = (card.finish if card else None) or "[slab.dim]Base[/]"
+            grade = _format_collection_grade(cp)
+            basis = money(cp.cost_basis) if cp.cost_basis is not None else "[slab.dim]—[/]"
+            fmv = "[slab.dim]—[/]"
+            gain = "[slab.dim]—[/]"
+            if cp.market and cp.market.fair_market_value is not None:
+                fmv = f"[slab.foil]{money(cp.market.fair_market_value)}[/]"
+                gain = signed_money(cp.market.unrealized_gain_loss)
+            table.add_row(card_num, subjects, finish, grade, basis, fmv, gain)
+
+        console.print(heading("Top Movers"))
+        console.print(table)
+
+    console.print()
+
+
+# ---------------------------------------------------------------------------
+# Price history (cards + sealed share one table shape)
+# ---------------------------------------------------------------------------
+
+# Plain-language note behind the ⚠ marker — a thin-sample FMV renders differently on purpose so a
+# 2-comp number can't masquerade as a solid one (a single cross-license sale once moved a box's
+# headline by $30).
+_THIN_NOTE = "⚠ thin market — fewer than 3 sales in the window; treat the value as indicative"
+
+
+def _history_table(points) -> tuple:
+    """(table, any_thin) for a list of CardPricePoint — the shared body of both history views."""
+    table = slab_table([
+        ("Date", {"style": "slab.dim"}),
+        ("FMV", {"justify": "right", "style": "slab.foil"}),
+        ("Range", {"justify": "right", "style": "slab.dim"}),
+        ("Change", {"justify": "right"}),
+        ("Comps", {"justify": "right", "style": "slab.dim"}),
+    ])
+    prev_median = None
+    any_thin = False
+    for p in points:
+        rng = "—"
+        if p.price_low is not None and p.price_high is not None:
+            rng = f"${p.price_low:,.0f} – ${p.price_high:,.0f}"
+        change = "[slab.dim]—[/]"
+        if prev_median is not None:
+            change = signed_money(p.price_median - prev_median)
+        comps = str(p.sample_size)
+        if p.low_confidence:
+            comps += " ⚠"
+            any_thin = True
+        table.add_row(str(p.date), money(p.price_median), rng, change, comps)
+        prev_median = p.price_median
+    return table, any_thin
+
+
+def _history_summary(points) -> None:
+    """First-vs-last net change line under a history table."""
+    first, last = points[0], points[-1]
+    total_change = last.price_median - first.price_median
+    pct = (total_change / first.price_median * 100) if first.price_median else 0
+    sign = "+" if total_change >= 0 else ""
+    console.print(
+        f"  {signed_money(total_change)} [slab.dim]({sign}{pct:.1f}% over {len(points)} data points)[/]"
+    )
+
+
+def render_price_history(h: CardPriceHistory) -> None:
+    """Display a card's price history as a table with trend indicators."""
+    subjects = ", ".join(h.subjects) or "—"
+    console.print()
+    console.print(_card_headline(h.card_number, subjects, h.set_name, h.grade_key))
+
+    if not h.points:
+        console.print("\n  [slab.dim]No price history available for this card/grade.[/]\n")
+        return
+
+    table, any_thin = _history_table(h.points)
+    console.print(heading("Price History", f"{h.grade_key} · {h.start_date} to {h.end_date}"))
+    console.print(table)
+    _history_summary(h.points)
+    if any_thin:
+        console.print(f"  [slab.dim]{_THIN_NOTE}[/]")
+    console.print()
+
+
+def render_sealed_price_history(h: SealedPriceHistory) -> None:
+    """Display a sealed product's price history — same table as a card's, keyed by SKU."""
+    console.print()
+    t = Text()
+    t.append(h.set_name or "—", style="slab.value")
+    t.append(f"  —  {_format_label(h.format.value)}", style="slab.dim")
+    console.print(t)
+
+    if not h.points:
+        console.print("\n  [slab.dim]No price history for this sealed product yet.[/]\n")
+        return
+
+    table, any_thin = _history_table(h.points)
+    console.print(heading("Price History", f"{h.start_date} to {h.end_date}"))
+    console.print(table)
+    _history_summary(h.points)
+    if any_thin:
+        console.print(f"  [slab.dim]{_THIN_NOTE}[/]")
+    console.print()