Vegas mode: end cycles before the wrap, keep the width budget honest

Three fixes, the first a regression from lead_in_width defaulting to 0.

get_visible_portion wraps: once scroll_position + display_width passes the end
of the strip it fills the right of the frame from the *head* of the same strip.
So the final display_width of travel showed the cycle's first plugin re-entering
on the right while its last plugin exited on the left, and the recompose that
followed replaced both at once. On a 512px panel at 50px/s that was 10.2s of
two plugins on screen at once, ending in a hard cut — reported as the ticker
"switching mid-scroll" from F1 to news.

That used to be invisible because the strip began with a full display_width of
blank, so the wrapped-in region was black. Removing that blank (it was 10s of
dead panel per cycle) exposed the wrap. Cycles now end one display width
earlier, before any wrapped content appears, clamped for strips no wider than
the display so they don't complete instantly and spin the recompose loop.

Verified on hardware: a 3936px strip now completes at 68.5s, exactly
(3936 - 512) / 50.

Second, auto_trim=False also skipped the width budget, which is an unrelated
concern — turning off margin cropping should not let one plugin hold the panel
for minutes. Seen in the field: the F1 scoreboard contributed 116 images and
14,848px untouched, giving a 33,821px cycle (11 minutes of content). The budget
now applies regardless of trimming; with it restored that cycle is 6,362px.

Third, the budget accounted for row gaps using the flat intra_plugin_gap while
the compositor had moved to measured separation, so it under-counted by up to
(min_content_separation - intra_plugin_gap) per row and a many-row plugin
overran its cap. Both now use the same separation_gap() rule, and a test
asserts the composed block fits the budget end to end rather than trusting the
two paths to agree.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01KEZK1P1Q1fu5pcuVrkrCFZ

src/vegas_mode/plugin_adapter.py

@@ -12,7 +12,11 @@ from contextlib import nullcontext
 from typing import Optional, List, Any, Tuple, Union, TYPE_CHECKING
 from PIL import Image
 
-from src.vegas_mode.geometry import find_blank_cut, trim_to_content
+from src.vegas_mode.geometry import (
+    find_blank_cut,
+    separation_gap,
+    trim_to_content,
+)
 
 if TYPE_CHECKING:
     from src.plugin_system.base_plugin import BasePlugin
@@ -166,8 +170,13 @@ class PluginAdapter:
             Trimmed image list, or None if nothing worth showing remains
         """
         if not self.config.auto_trim:
-            self._cache_content(plugin_id, images)
-            return images
+            # Trimming is off, but the width budget is a separate concern —
+            # turning off margin cropping should not let one plugin hold the
+            # panel for minutes. Skipping it here previously let a 14,848px
+            # segment through untouched.
+            kept = self._apply_width_budget(list(images), plugin_id)
+            self._cache_content(plugin_id, kept)
+            return kept
 
         original_width = sum(img.width for img in images)
         kept: List[Image.Image] = []
@@ -275,6 +284,20 @@ class PluginAdapter:
             return self.display_width
         return max(1, int(self.display_width * pct / 100))
 
+    def _row_gap(self, left: Image.Image, right: Image.Image) -> int:
+        """
+        Gap the compositor will insert between two of a plugin's rows.
+
+        Mirrors RenderPipeline._join_plugin_rows so the width budget measures
+        what will actually be rendered.
+        """
+        return separation_gap(
+            left, right,
+            target=max(0, self.config.min_content_separation),
+            minimum=max(0, self.config.intra_plugin_gap),
+            threshold=self.config.trim_threshold,
+        )
+
     def _width_budget(self) -> int:
         """Maximum columns one plugin may occupy in a cycle. 0 means unlimited."""
         ratio = self.config.max_plugin_width_ratio
@@ -304,11 +327,15 @@ class PluginAdapter:
         """
         budget = self._width_budget()
 
-        # Count the gaps the compositor will insert between these rows, not
-        # just the pixels of the rows themselves — otherwise a plugin with many
-        # rows quietly occupies far more of the panel than its budget allows.
-        gap = max(0, self.config.intra_plugin_gap)
-        total = sum(img.width for img in images) + gap * (len(images) - 1)
+        # Count the gaps the compositor will actually insert, not just the
+        # pixels of the rows — otherwise a plugin with many rows quietly
+        # occupies far more of the panel than its budget allows. These must use
+        # the same measured rule as RenderPipeline._join_plugin_rows; assuming
+        # the flat intra_plugin_gap here under-counted by up to
+        # (min_content_separation - intra_plugin_gap) per row.
+        total = sum(img.width for img in images) + sum(
+            self._row_gap(images[i], images[i + 1]) for i in range(len(images) - 1)
+        )
 
         if not budget or total <= budget:
             # Fits, so reset rotation — the whole segment is being shown.
@@ -327,7 +354,9 @@ class PluginAdapter:
         # cut never lands in the middle of one.
         for step in range(len(images)):
             img = images[(start + step) % len(images)]
-            cost = img.width + (gap if selected else 0)
+            cost = img.width
+            if selected:
+                cost += self._row_gap(selected[-1], img)
             if selected and used + cost > budget:
                 break
             selected.append(img)