feat(sports): live Vegas cards for the scoreboards (shared layer) (#698)

* perf(timing): say which render-thread work a late frame followed

The soak already says how often a moving frame reached the panel late, but
not what the render thread was doing just before it. Vegas does two kinds of
work there between frames -- building its strip (compose, extend) and, with
live elements, patching changed pixels into it -- and deciding whether either
is affordable needs their own numbers.

- FrameTimingRecorder.note_op(kind, nbytes) tags the next presented frame.
  Totals gain op_frames, late_op_frames, op_freezes and op_bytes per kind;
  aggregate() still takes frames without ops. The file schema is unchanged.
- Vegas tags compose and every strip extension (with the bytes it copied).
- frame_soak prints an "after work" table: frames, late %, freezes and MB
  moved per kind, only when something tagged its work.
- render_bench gains --strip-screens (Vegas-sized strips), --patch-bytes /
  --patch-every / --patch-where (in-place column writes, as a live element
  update does) and --extend-every-screens / --extend-width (append + trim on
  a fixed cadence that holds the strip's width).

No runtime behaviour changes: this is the measurement gate for live Vegas
elements.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* docs(changelog): note the frame-op attribution and bench modes

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* perf(scroll): build the strip's PIL image only when something reads it

Every Vegas strip extension rebuilt ScrollHelper.cached_image from
cached_array in full, twice (append, then trim), on the render thread:
Image.fromarray is 1.7ms for an 8,000px strip and 3.8ms for 20,000px on a
Pi 4 (measured on ledpi), about two thirds of an extension's render-thread
cost. Nothing on the frame path reads the image's pixels; every frame is cut
from the array.

cached_image is now a property. append_content and drop_scrolled_prefix
defer it; the first read builds it from the array it started with and keeps
it only if the strip has not changed meanwhile, so a sync push racing an
extension cannot leave a stale image cached. Assigning cached_image stores
exactly what was assigned, as before. has_strip() says whether there is a
strip without building its image; the helper's frame path, Vegas and the
adapter's scroll-cache invalidation use it. The strip is also no longer held
in memory twice.

In Vegas the image is now built only by a multi-display sync push.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(vegas): live elements -- a plugin API for content that changes while it scrolls

Vegas bakes each plugin's pictures into one strip, so a card already on its
way across the panel keeps what it showed when it was drawn. This adds the
API and bookkeeping for content that can be updated in place; the worker
that redraws and swaps it follows separately. No shipped plugin implements
the hook yet, so nothing changes for users.

Plugin API (core 3.8.0), all no-ops by default:
- BasePlugin.get_vegas_elements() -> [VegasElement(key, image, version,
  live, refresh_hz)]: named, fixed-width pieces of Vegas content.
- BasePlugin.redraw_vegas_element(key, width, height, at): a lock-free
  redraw for content that changes with time.
- BasePlugin.notify_vegas_data_changed(): data that lands outside update().
- src/plugin_system/vegas_elements.py (VegasElement, re-exported from
  base_plugin).

Core:
- PluginAdapter asks a plugin that implements the hook for elements on the
  background fetch only (under its lock, on its own canvas); every other
  path keeps get_vegas_content(). Live elements are pinned (padded with
  content_padding, never trimmed), tagged with their key, digest and data
  epoch in Image.info so the existing cache and group plumbing carry them
  unchanged, and untagged if a width budget crops them.
- RenderPipeline records where each live element lands (ElementRecord), in
  absolute strip columns a trim does not move; the block-start arithmetic
  is shared with the STATIC markers.
- PluginManager update listeners (add/remove_update_listener,
  notify_data_changed): told the moment update() completes, not at the
  next ~4s Vegas poll. The coordinator uses one to move each plugin's data
  epoch on.
- vegas_scroll.live_refresh (kill switch), live_max_hz, live_min_interval,
  live_lead_screens; per-plugin core-owned vegas_live. Live elements are
  off under multi-display sync, in swap mode and with offscreen_prefetch off.
- scripts/check_plugin.py checks the element contract
  (src/plugin_system/testing/vegas.py); test/fixtures/plugins/vegas-live-stub
  is a working example.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(vegas): live elements update in place while they scroll

One background worker (src/vegas_mode/live_worker.py) redraws a plugin's
live elements when its data epoch moves on (update listener) or on their
refresh_hz, nearest the screen first, and hands changed pixels lock-free to
the render thread, which copies them into the strip between frames
(RenderPipeline.apply_live_patches, ScrollHelper.patch_columns): at most
four patches or two screens of bytes a frame, no drawing or locks there.
The worker takes over group prefetch once a live element is placed, runs
inside the render gate, and is supervised. Update tick 1s while live
elements exist. Web UI switch for live_refresh. OFFSCREEN_RENDERING.md
describes what was built and why SegmentStrip was not needed.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* feat(sports): live Vegas cards for the scoreboards (shared layer)

One live element per game, drawn only when what the card shows changes, so
a score changes on a card already crossing the panel. The shared part, so
each scoreboard adopts it in a few lines:

- src/common/sports_vegas.py: game_key, game_fingerprint (the whole game
  dict, frozen: no drawn field can be missed), dedupe_games, VegasCardCache,
  StickyOdds (odds a live poll left out stay drawn), finished_games /
  with_finished_games (a game that just went final keeps its card, after its
  league's live games; one a heuristic only judged over keeps its live
  state, so a tied end of regulation never shows FINAL early).
- SportsScrollDisplay.make_vegas_renderer() is the override point;
  build_vegas_elements() and SportsScrollDisplayManager
  .get_vegas_elements_for() do the rest. A card's version includes its
  teams' ranks, which the renderer draws from the rankings cache.
- SportsLiveSharedMixin._record_finished_game() / finished_games_snapshot():
  held for FINISHED_GAME_TTL after it leaves the live list.

A sport that does not implement make_vegas_renderer keeps its ordinary Vegas
content, so no scoreboard changes until it opts in.

scripts/render_plugin.py --vegas renders a plugin's Vegas block as the
ticker lays it out, and --timeline stacks it at successive moments as
the ticker would update it in place; the join is now
render_pipeline.join_plugin_rows().

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* refactor(sports): a default _determine_game_type on SportsScrollDisplay

render_vegas_card looked the method up with getattr and a None default, which
static analysis (Codacy) reports as calling something that may not be
callable. The base class now has the default -- the card type from the game's
state -- and the plugins that define their own override it as before.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* fix: review follow-ups on the shared live-card layer

- The reused Vegas renderer always gets the current rankings, empty
  included, so ranks cleared since are not kept drawn.
- render_plugin.py: --timeline refuses --no-live (a timeline shows live
  elements changing), --timeline/--no-live need --vegas, and the Vegas
  paths create the output's directory like the display path does.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

src/plugin_system/testing/vegas.py

@@ -266,6 +266,91 @@ def _base_redraw():
     return BasePlugin.redraw_vegas_element
 
 
+def render_vegas_strip(plugin: Any, plugin_id: str, display_manager: Any,
+                       live: bool = True) -> Any:
+    """The plugin's block of the Vegas strip, laid out exactly as the ticker would.
+
+    Fetched through the ticker's own adapter (trimming, pinning, width
+    budget) and joined with its own spacing, so what this draws is what
+    scrolls. ``live=False`` shows the ordinary get_vegas_content() instead.
+
+    Returns ``(block, layout)`` -- layout a list of ``(x, key, width)`` for the
+    live elements in the block -- or ``(None, [])`` when there is nothing.
+    """
+    _adapter, block, layout = _vegas_block(plugin, plugin_id, display_manager, live)
+    return block, [(x, meta.key, width) for x, meta, width in layout]
+
+
+def _vegas_block(plugin: Any, plugin_id: str, display_manager: Any, live: bool) -> Any:
+    """(adapter, block, layout) for a plugin's Vegas block, through the ticker's own code."""
+    from src.vegas_mode.config import VegasModeConfig
+    from src.vegas_mode.elements import LiveEpochs
+    from src.vegas_mode.plugin_adapter import PluginAdapter
+    from src.vegas_mode.render_pipeline import join_plugin_rows
+
+    config = VegasModeConfig()
+    adapter = PluginAdapter(display_manager, config)
+    adapter.live_elements_enabled = live
+    adapter.live_epochs = LiveEpochs()
+    images = adapter.get_content(plugin, plugin_id, offscreen_only=True)
+    if not images:
+        return adapter, None, []
+    block, layout = join_plugin_rows(images, config)
+    return adapter, block, layout
+
+
+def render_vegas_timeline(plugin: Any, plugin_id: str, display_manager: Any,
+                          steps: int = 8, step_seconds: float = 0.25,
+                          run_update: bool = False) -> Any:
+    """The plugin's Vegas block at successive moments, one row per step.
+
+    Row 0 is the block as placed (render_vegas_strip). Each later row is the
+    same block ``step_seconds`` later, changed the way the ticker would change
+    it in place: every live element with ``refresh_hz`` redrawn for that
+    moment through redraw_vegas_element(), and -- with ``run_update`` -- the
+    plugin's update() run first and every live element redrawn from the new
+    data. A redraw of another width is left out, as the ticker refuses it.
+    Rows are separated by a grey line.
+
+    Returns ``(image, rows)``, or ``(None, 0)`` when there is nothing.
+    """
+    import time
+
+    import numpy as np
+
+    adapter, block, layout = _vegas_block(plugin, plugin_id, display_manager, True)
+    if block is None:
+        return None, 0
+    base = np.array(block.convert('RGB'))
+    rows = [base.copy()]
+    height = base.shape[0]
+    start = time.monotonic()
+    for step in range(1, max(1, int(steps))):
+        frame = rows[-1].copy()
+        if run_update:
+            plugin.update()
+            adapter.live_epochs.bump(plugin_id)
+            batch = adapter.render_live_elements(plugin, plugin_id, lock_timeout=5.0)
+            rendered = batch[1] if batch is not None else {}
+            for x, meta, width in layout:
+                element = rendered.get(meta.key)
+                if element is not None and element.width == width:
+                    frame[:, x:x + width] = element.pixels
+        at = start + step * float(step_seconds)
+        for x, meta, width in layout:
+            if meta.refresh_hz > 0:
+                element = adapter.redraw_live_element(plugin, plugin_id, meta.key,
+                                                      width, height, at)
+                if element is not None and element.width == width:
+                    frame[:, x:x + width] = element.pixels
+        rows.append(frame)
+    divider = np.full((1, base.shape[1], 3), 60, dtype=np.uint8)
+    stacked = [rows[0]]
+    for row in rows[1:]:
+        stacked.extend([divider, row])
+    return Image.fromarray(np.concatenate(stacked, axis=0)), len(rows)
+
+
 def check_plugin_vegas_elements(plugin_id: str, plugin_dir: Any, config: dict,
                                 mock_data: dict, width: int, height: int,
                                 run_update: bool = True) -> VegasElementReport: