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

* 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>

---------

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

src/vegas_mode/stream_manager.py

@@ -717,6 +717,20 @@ class StreamManager:
             A STATIC plugin is also returned with an empty list, unfetched: it
             pauses the scroll instead of adding to it (see is_static_plugin).
         """
+        group: List[Tuple[str, Optional[List[Image.Image]]]] = []
+        for plugin_id in self.plan_next_group(count):
+            member = self.fetch_group_member(plugin_id, offscreen_only=offscreen_only)
+            if member is not None:
+                group.append(member)
+        return group
+
+    def plan_next_group(self, count: Optional[int] = None) -> List[str]:
+        """Which plugins the next group holds, advancing the rotation past them.
+
+        The first half of take_next_group(). The live-element worker fetches
+        a group one plugin at a time (fetch_group_member) so it can fit more
+        urgent redraws between them.
+        """
         if count is None:
             count = self.config.plugins_per_cycle
 
@@ -730,37 +744,38 @@ class StreamManager:
             for _ in range(min(max(1, count), total)):
                 ids.append(self._ordered_plugins[self._prefetch_index])
                 self._prefetch_index = (self._prefetch_index + 1) % total
+        return ids
 
-        plugins = getattr(self.plugin_manager, 'plugins', {})
-        group: List[Tuple[str, Optional[List[Image.Image]]]] = []
+    def fetch_group_member(
+        self, plugin_id: str, offscreen_only: bool = False
+    ) -> Optional[Tuple[str, Optional[List[Image.Image]]]]:
+        """One plugin's entry in a group, as take_next_group() describes it.
+
+        None when the plugin is gone or its fetch raised: it is left out of
+        the group.
+        """
+        plugin = getattr(self.plugin_manager, 'plugins', {}).get(plugin_id)
+        if not plugin:
+            return None
+        if self.is_static_plugin(plugin_id):
+            # A STATIC plugin pauses the scroll rather than scrolling by, so it
+            # contributes no columns. It keeps its place in the group (empty)
+            # so the pipeline can mark where its turn falls.
+            return (plugin_id, [])
+        try:
+            images = self.plugin_adapter.get_content(
+                plugin, plugin_id, offscreen_only=offscreen_only)
+        except Exception:
+            logger.exception("[%s] ERROR fetching content", plugin_id)
+            self.stats['fetch_errors'] += 1
+            return None
+        if images:
+            self.stats['segments_fetched'] += 1
+            return (plugin_id, images)
         # Only the old contract hands anything back to the render thread.
         defer_empty = offscreen_only and not getattr(
             self.config, 'offscreen_prefetch', True)
-
-        for plugin_id in ids:
-            plugin = plugins.get(plugin_id)
-            if not plugin:
-                continue
-            if self.is_static_plugin(plugin_id):
-                # A STATIC plugin pauses the scroll rather than scrolling by,
-                # so it contributes no columns. It keeps its place in the
-                # group (empty) so the pipeline can mark where its turn falls.
-                group.append((plugin_id, []))
-                continue
-            try:
-                images = self.plugin_adapter.get_content(
-                    plugin, plugin_id, offscreen_only=offscreen_only)
-            except Exception:
-                logger.exception("[%s] ERROR fetching content", plugin_id)
-                self.stats['fetch_errors'] += 1
-                continue
-            if images:
-                self.stats['segments_fetched'] += 1
-                group.append((plugin_id, images))
-            else:
-                group.append((plugin_id, None if defer_empty else []))
-
-        return group
+        return (plugin_id, None if defer_empty else [])
 
     def advance_cycle(self) -> None:
         """