Align Vegas API bounds with validate(), fix audit config plumbing

Both from review feedback on #423.

The web API's accepted ranges disagreed with VegasModeConfig.validate(),
which is what actually gates Vegas starting:

  scroll_speed      1-100  -> 1-200   (a slider value of 150 returned 400)
  separator_width   0-500  -> 0-128
  target_fps        1-200  -> 30-200
  buffer_ahead      1-20   -> 1-5

The three loose ones were the dangerous direction: the value saved with a
200, then VegasModeCoordinator.start() failed validation with only a log
line, so the ticker silently never ran. The UI already matched validate() in
all four cases, so the API was the odd one out.

test_vegas_api_bounds_match_validate parses the numeric_fields map out of
api_v3 and asserts every bound against validate(), plus that validate()
accepts both endpoints and rejects just outside them, so these cannot drift
apart again. That test immediately caught a missing upper bound on
min_plugin_width, now added — unbounded it would drop every segment and
leave a blank ticker.

Separately, vegas_audit.py constructed PluginAdapter without the config, so
it fell back to VegasModeConfig() defaults and would report trimming and
width-budget behaviour that differed from the user's config.json. It now
passes the loaded config exactly as the coordinator does. This is the same
class of drift the explicit lead_gap and grouping arguments already guard
against. Output is unchanged on a rig whose config matches the defaults.

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

config/config.template.json

@@ -132,12 +132,6 @@
             "target_fps": 125,
             "buffer_ahead": 2,
             "intra_plugin_gap": 8,
-            "render_width_pct": 100,
-            "min_content_separation": 24,
-            "min_cut_gap": 6,
-            "continuous_scroll": true,
-            "smooth_scroll": true,
-            "extend_threshold_screens": 2.0,
             "auto_trim": true,
             "trim_threshold": 10,
             "content_padding": 8,
@@ -145,7 +139,6 @@
             "lead_in_width": 0,
             "plugins_per_cycle": 6,
             "max_plugin_width_ratio": 3.0,
-            "overflow_mode": "rotate",
             "dynamic_duration_enabled": true,
             "min_cycle_duration": 60,
             "max_cycle_duration": 240

src/common/scroll_helper.py

@@ -348,72 +348,13 @@ class ScrollHelper:
         """
         if not self.cached_image or self.cached_array is None:
             return None
-
+        
+        # Use integer pixel positioning for high FPS scrolling (like stock ticker)
         start_x_int = int(self.scroll_position)
         end_x_int = start_x_int + self.display_width
-
-        # Integer positioning quantises motion to whole pixels, so the number of
-        # distinct frames per second equals the scroll speed in px/s, no matter
-        # how fast the loop renders. At 50px/s and 78fps that made 36% of frames
-        # identical: the extra frames cost work and bought nothing. Blending
-        # between the two neighbouring positions gives motion at the frame rate
-        # instead of the step rate.
-        if self.sub_pixel_scrolling:
-            fractional = self.scroll_position - start_x_int
-            if fractional > 0.0:
-                return self._blend_visible_portion(start_x_int, fractional)
-
+        
+        # Fast integer pixel path (no interpolation - high frame rate provides smoothness)
         return self._get_visible_portion_integer(start_x_int, end_x_int)
-
-    def _blend_visible_portion(self, start_x: int, fractional: float) -> Image.Image:
-        """
-        Linear blend between the frames at ``start_x`` and ``start_x + 1``.
-
-        Implemented with numpy rather than scipy.ndimage.shift: scipy is not
-        installed on the target devices (HAS_SCIPY is False there), which is why
-        the pre-existing sub-pixel path was dead code — get_visible_portion never
-        consulted the flag, and the scipy fallback would not have interpolated
-        anyway.
-
-        Args:
-            start_x: Left column of the earlier of the two frames
-            fractional: How far between the two, in [0, 1)
-
-        Returns:
-            The blended frame
-        """
-        width = self.display_width
-        strip_width = self.cached_array.shape[1]
-
-        if start_x + width + 1 <= strip_width:
-            # Slice the backing array directly. Going via
-            # _get_visible_portion_integer would build two PIL images only for
-            # them to be converted straight back to arrays, which measured 15x
-            # the cost of the integer path.
-            near = self.cached_array[:, start_x:start_x + width]
-            far = self.cached_array[:, start_x + 1:start_x + 1 + width]
-        else:
-            # Close enough to the end that one of the slices wraps; let the
-            # integer path handle that and pay the conversion. Continuous mode
-            # extends the strip before reaching here, so this is the rare case.
-            near = np.asarray(
-                self._get_visible_portion_integer(start_x, start_x + width))
-            far = np.asarray(
-                self._get_visible_portion_integer(start_x + 1, start_x + 1 + width))
-
-        # Fixed-point rather than float32: integer multiply-add on uint16 is
-        # markedly faster than float maths on the Pi's ARM cores, and 8 bits of
-        # weight is finer than the panel can show.
-        weight = int(fractional * 256.0)
-        blended = (
-            (near.astype(np.uint16) * (256 - weight)
-             + far.astype(np.uint16) * weight) >> 8
-        ).astype(np.uint8)
-
-        return Image.frombytes(
-            'RGB', (width, self.display_height),
-            np.ascontiguousarray(blended).tobytes()
-        )
     
     def _get_visible_portion_integer(self, start_x: int, end_x: int) -> Image.Image:
         """Fast integer pixel extraction (no interpolation).
@@ -707,128 +648,6 @@ class ScrollHelper:
         """
         return self.scroll_complete
     
-    def append_content(self, content_items: list,
-                       item_gap: int = 32,
-                       element_gap: int = 0) -> bool:
-        """
-        Append items to the right of the existing strip, preserving scroll state.
-
-        Lets a caller keep one continuous strip instead of replacing it. Vegas
-        mode uses this so the next group of plugins scrolls in from the right
-        rather than the strip being swapped out underneath the viewer — a swap
-        shows as a flash and a hard cut to already-full-screen content.
-
-        ``scroll_position`` and ``total_distance_scrolled`` are untouched, so
-        motion continues uninterrupted; only the strip gets longer. Because
-        completion is measured against ``total_scroll_width``, extending the
-        strip also defers completion, which is the intent.
-
-        Args:
-            content_items: Images to append, in order
-            item_gap: Gap between appended items, and between the existing
-                content and the first appended item
-            element_gap: Extra gap after each item, mirroring
-                create_scrolling_image
-
-        Returns:
-            True if content was appended
-        """
-        if not content_items:
-            return False
-
-        if self.cached_image is None or self.cached_array is None:
-            # Nothing to extend yet — this is just the first build.
-            self.create_scrolling_image(
-                content_items, item_gap=item_gap, element_gap=element_gap, lead_gap=0)
-            return True
-
-        gap = max(0, item_gap)
-        addition_width = (
-            sum(img.width for img in content_items)
-            + gap * len(content_items)          # one leading gap per item
-            + element_gap * len(content_items)
-        )
-
-        addition = Image.new('RGB', (addition_width, self.display_height), (0, 0, 0))
-        x = 0
-        for img in content_items:
-            x += gap                            # separate from whatever precedes
-            addition.paste(img, (x, 0))
-            x += img.width + element_gap
-
-        # numpy concatenate then one conversion back, rather than allocating a
-        # full-width PIL image and pasting twice: the strip can be tens of
-        # thousands of columns wide and this runs on the render path.
-        self.cached_array = np.concatenate(
-            (self.cached_array, np.array(addition)), axis=1)
-        self.cached_image = Image.fromarray(self.cached_array)
-        self.total_scroll_width = self.cached_image.width
-        self.scroll_complete = False
-
-        self.logger.info(
-            "Appended %d item(s) (%dpx) to scroll strip: now %dpx, position %.0f",
-            len(content_items), addition_width, self.total_scroll_width,
-            self.scroll_position
-        )
-        return True
-
-    def drop_scrolled_prefix(self, keep_before: int = 0) -> int:
-        """
-        Discard columns that have already scrolled past, to bound memory.
-
-        A continuously extended strip would otherwise grow without limit. All
-        the positional state is shifted by the amount removed so the visible
-        frame and the completion arithmetic are unchanged:
-        ``total_distance_scrolled`` and ``total_scroll_width`` both shrink by the
-        same amount, preserving their difference.
-
-        Args:
-            keep_before: Columns to retain behind the current position, as a
-                safety margin against a caller reading slightly behind it
-
-        Returns:
-            Number of columns actually removed
-        """
-        if self.cached_image is None or self.cached_array is None:
-            return 0
-
-        # While the viewport wraps, get_visible_portion fills its right-hand side
-        # from the *head* of the strip, so trimming the head would change what
-        # is on screen. Continuous mode extends before ever reaching that state;
-        # refusing here keeps "trimming is invisible" true unconditionally.
-        if self.scroll_position + self.display_width > self.cached_image.width:
-            return 0
-
-        cut = int(self.scroll_position) - max(0, keep_before)
-        if cut <= 0:
-            return 0
-        # Never trim so far that the remaining strip is narrower than the
-        # viewport, or get_visible_portion has nothing to slice.
-        cut = min(cut, max(0, self.cached_image.width - self.display_width))
-        if cut <= 0:
-            return 0
-
-        # .copy() so the original buffer is released rather than kept alive by
-        # a numpy view.
-        self.cached_array = self.cached_array[:, cut:].copy()
-        self.cached_image = Image.fromarray(self.cached_array)
-        self.total_scroll_width = self.cached_image.width
-        self.scroll_position -= cut
-        self.total_distance_scrolled = max(0.0, self.total_distance_scrolled - cut)
-
-        self.logger.debug(
-            "Dropped %dpx of scrolled strip: now %dpx, position %.0f",
-            cut, self.total_scroll_width, self.scroll_position
-        )
-        return cut
-
-    def remaining_unscrolled(self) -> int:
-        """Columns of strip still to the right of the viewport."""
-        if self.cached_image is None:
-            return 0
-        return max(0, self.total_scroll_width - int(self.scroll_position)
-                   - self.display_width)
-
     def reset_scroll(self) -> None:
         """
         Reset scroll position to beginning.

src/display_manager.py

@@ -186,14 +186,8 @@ class DisplayManager:
         self.config = config or {}
         self._force_fallback = force_fallback
         self._suppress_test_pattern = suppress_test_pattern
-        # Per-thread capture state. update_display() and clear() skip hardware
-        # writes while the *calling* thread is capturing content off-screen.
-        #
-        # Thread-local rather than a plain flag because Vegas mode prepares
-        # upcoming content on a background thread: a shared flag set there would
-        # suppress the render loop's own frame pushes for the duration, freezing
-        # the panel exactly when the point was to avoid a freeze.
-        self._capture_state = threading.local()
+        # When True, update_display() and clear() skip hardware writes (used during off-screen content capture)
+        self._capture_mode_active = False
         # Double-sided mode state (resolved in _setup_matrix). When disabled,
         # the logical image is blitted to the matrix unchanged.
         self._double_sided = None  # dict {copies, axis, logical_width, logical_height} or None
@@ -526,15 +520,6 @@ class DisplayManager:
         except Exception as e:
             logger.error(f"Error drawing test pattern: {e}", exc_info=True)
 
-    @property
-    def _capture_mode_active(self) -> bool:
-        """True while the calling thread is capturing content off-screen."""
-        return getattr(self._capture_state, 'active', False)
-
-    @_capture_mode_active.setter
-    def _capture_mode_active(self, value: bool) -> None:
-        self._capture_state.active = bool(value)
-
     @contextmanager
     def capture_mode(self):
         """Suppress hardware output during off-screen content capture.
@@ -551,59 +536,6 @@ class DisplayManager:
         finally:
             self._capture_mode_active = False
 
-    @contextmanager
-    def render_size(self, width: int, height: Optional[int] = None):
-        """Temporarily present a smaller logical canvas to plugins.
-
-        Plugins lay out against ``display_manager.matrix.width`` (and the
-        ``width``/``height`` properties, which defer to it), so the only way to
-        get a *narrower layout* rather than a cropped one is to tell the plugin
-        the screen is narrower while it renders. Trimming after the fact cannot
-        fix a forecast spread across five columns or a progress bar drawn at
-        100% width — those need the plugin to make different layout decisions.
-
-        Vegas mode uses this so a plugin can occupy a fraction of a wide panel
-        and still look deliberately composed. Reuses the same _LogicalMatrix
-        indirection that double-sided mode relies on, so plugins see a
-        consistent size from every accessor.
-
-        Only meaningful inside :meth:`capture_mode` — this swaps the shared
-        image buffer, so the render loop must not be writing to it concurrently.
-
-        Args:
-            width: Logical width to report, clamped to at least 1 and to the
-                real panel width (a larger canvas would overflow the hardware).
-            height: Logical height, defaulting to the current height.
-        """
-        real_matrix = self.matrix
-        prev_image = getattr(self, 'image', None)
-        prev_draw = getattr(self, 'draw', None)
-
-        current_w = self.width
-        current_h = self.height
-        target_w = max(1, min(int(width), current_w))
-        target_h = max(1, min(int(height) if height else current_h, current_h))
-
-        if target_w == current_w and target_h == current_h:
-            # Nothing to do; avoid pointless wrapping and buffer churn.
-            yield
-            return
-
-        try:
-            if real_matrix is not None:
-                self.matrix = _LogicalMatrix(real_matrix, target_w, target_h)
-            # With no hardware, the width/height properties fall through to
-            # self.image, so swapping the buffer below is enough on its own.
-            self.image = Image.new('RGB', (target_w, target_h))
-            self.draw = ImageDraw.Draw(self.image)
-            yield
-        finally:
-            self.matrix = real_matrix
-            if prev_image is not None:
-                self.image = prev_image
-            if prev_draw is not None:
-                self.draw = prev_draw
-
     def _composite_double_sided(self):
         """Tile the logical screen across the full physical chain.
 

src/plugin_system/base_plugin.py

@@ -505,40 +505,6 @@ class BasePlugin(ABC):
     # -------------------------------------------------------------------------
     # Vegas scroll mode support
     # -------------------------------------------------------------------------
-    def get_vegas_render_width(self) -> int:
-        """
-        Width the Vegas ticker wants this plugin's content to occupy.
-
-        On a wide panel a layout built to fill the screen reads as sparse in a
-        ticker — a forecast spread over five columns, a progress bar drawn at
-        100% width, a stat block with the panel's whole width between its
-        elements. Vegas asks for a narrower render so the plugin can choose a
-        tighter arrangement instead of being cropped afterwards.
-
-        Vegas also narrows ``display_manager`` for the duration of the call, so
-        a plugin that already sizes itself from ``matrix.width`` needs no
-        changes. Read this only when you size content some other way.
-
-        Controlled by the plugin's own ``vegas_width_pct`` config value, else
-        the global ``display.vegas_scroll.render_width_pct``.
-
-        Returns:
-            Target width in pixels. Outside a Vegas content request, the full
-            display width.
-        """
-        requested = getattr(self, '_vegas_render_width', None)
-        if isinstance(requested, int) and requested > 0:
-            return requested
-
-        display_manager = getattr(self, 'display_manager', None)
-        matrix = getattr(display_manager, 'matrix', None)
-        if matrix is not None and getattr(matrix, 'width', None):
-            return int(matrix.width)
-        width = getattr(display_manager, 'width', None)
-        if callable(width):
-            width = width()
-        return int(width) if width else 128
-
     def get_vegas_content(self) -> Optional[Any]:
         """
         Get content for Vegas-style continuous scroll mode.

src/plugin_system/testing/visual_display_manager.py

@@ -178,35 +178,6 @@ class VisualTestDisplayManager:
         """No-op for hardware; marks that display was updated."""
         self.update_called = True
 
-    @contextmanager
-    def render_size(self, width: int, height: Optional[int] = None):
-        """
-        Interface parity with DisplayManager.render_size().
-
-        Vegas mode narrows the canvas so plugins lay out compactly instead of
-        being cropped. The harness must offer the same context or that path
-        cannot be exercised offline — and because the adapter catches broadly,
-        a missing method shows up as "no content" rather than an error.
-        """
-        prev_image = self.image
-        prev_draw = self.draw
-        prev_w, prev_h = self._width, self._height
-
-        target_w = max(1, min(int(width), prev_w))
-        target_h = max(1, min(int(height) if height else prev_h, prev_h))
-
-        try:
-            self._width, self._height = target_w, target_h
-            self.matrix = _MatrixProxy(target_w, target_h)
-            self.image = Image.new('RGB', (target_w, target_h), (0, 0, 0))
-            self.draw = ImageDraw.Draw(self.image)
-            yield
-        finally:
-            self._width, self._height = prev_w, prev_h
-            self.matrix = _MatrixProxy(prev_w, prev_h)
-            self.image = prev_image
-            self.draw = prev_draw
-
     @contextmanager
     def capture_mode(self):
         """

src/vegas_mode/config.py

@@ -21,20 +21,6 @@ class VegasModeConfig:
     scroll_speed: float = 50.0  # Pixels per second
     separator_width: int = 32  # Gap between plugins (pixels)
 
-    # Fraction of the panel width a plugin is told it has while rendering for
-    # the ticker, as a percentage. Trimming can only remove blank margins; it
-    # cannot compact a layout that genuinely spans the display — a five-column
-    # forecast, a full-width progress bar, a centred stat block with the panel's
-    # whole width between its elements. Rendering at a narrower size makes the
-    # plugin choose a tighter layout instead. 100 disables it.
-    render_width_pct: int = 100
-
-    # Minimum blank columns guaranteed between adjacent content, measured from
-    # actual ink rather than added blindly. A flat additive gap leaves
-    # card-style content nearly touching when the cards are drawn flush to their
-    # own edges, while padding out content that already has wide margins.
-    min_content_separation: int = 24
-
     # Gap between rows contributed by the *same* plugin. separator_width marks
     # the handoff from one plugin to the next; applying it between every image
     # forced a 32px chasm between each row of a per-row ticker (the F1
@@ -58,51 +44,12 @@ class VegasModeConfig:
     # switched off at the start of every cycle.
     lead_in_width: int = 0
 
-    # Blend between neighbouring pixel positions so motion happens at the frame
-    # rate rather than the scroll speed. With integer positioning the number of
-    # distinct frames per second equals scroll_speed, so at 50px/s the motion is
-    # 50 discrete 1px steps however fast the loop runs. The trade is a slight
-    # horizontal softening of text, since each frame is a blend of two positions.
-    smooth_scroll: bool = True
-
-    # Keep one continuous strip, extending it with the next group of plugins as
-    # the scroll approaches the end, instead of composing a fresh strip and
-    # swapping it in. A swap stops the motion, substitutes every pixel at once
-    # and restarts with the viewport already full — read as a freeze, a flash
-    # and a jump. Extending means the next group simply scrolls in from the
-    # right. Set false to restore the swap behaviour.
-    continuous_scroll: bool = True
-
-    # Extend once the unscrolled remainder falls below this many screen widths.
-    # Needs to be more than one so the join is prepared before it is on screen.
-    extend_threshold_screens: float = 2.0
-
     # How many plugins are composed into one scroll cycle. Kept separate from
     # buffer_ahead (which is only a prefetch low-water mark) because the two
     # were previously the same number: a buffer_ahead of 2 meant just 3 plugins
     # per cycle, so a 20-plugin install took seven cycles to come around.
     plugins_per_cycle: int = 6
 
-    # Minimum run of blank columns that counts as a boundary between items when
-    # an oversized segment has to be narrowed. Measured on rendered text, the
-    # gaps between characters are a single column while gaps between items are
-    # 8px and up, so anything above 1 stops a cut landing inside a word. Cutting
-    # mid-word orphaned the tail into the next cycle, which showed up as a lone
-    # letter floating between two unrelated plugins.
-    min_cut_gap: int = 6
-
-    # What to do when a plugin's content exceeds its width budget.
-    #
-    #   "rotate"   — advance a window each cycle so everything is seen eventually.
-    #                Right for interchangeable items: news headlines, odds, stocks.
-    #   "truncate" — always show the start. Right for ordered content, where a
-    #                window into the middle is meaningless: a league table that
-    #                shows ranks 1-6 then resumes at 7 two rotations later reads
-    #                as out of order and out of context.
-    #
-    # Override per plugin with vegas_overflow.
-    overflow_mode: str = "rotate"
-
     # Cap on one plugin's share of a cycle, as a multiple of display width.
     # A single ticker returning 7,000px would otherwise hold the panel for over
     # two minutes. Overflow is deferred to later cycles rather than discarded.
@@ -144,14 +91,6 @@ class VegasModeConfig:
             scroll_speed=float(vegas_config.get('scroll_speed', 50.0)),
             separator_width=int(vegas_config.get('separator_width', 32)),
             intra_plugin_gap=int(vegas_config.get('intra_plugin_gap', 8)),
-            render_width_pct=int(vegas_config.get('render_width_pct', 100)),
-            min_content_separation=int(
-                vegas_config.get('min_content_separation', 24)),
-            min_cut_gap=int(vegas_config.get('min_cut_gap', 6)),
-            smooth_scroll=vegas_config.get('smooth_scroll', True),
-            continuous_scroll=vegas_config.get('continuous_scroll', True),
-            extend_threshold_screens=float(
-                vegas_config.get('extend_threshold_screens', 2.0)),
             auto_trim=vegas_config.get('auto_trim', True),
             trim_threshold=int(vegas_config.get('trim_threshold', 10)),
             content_padding=int(vegas_config.get('content_padding', 8)),
@@ -160,7 +99,6 @@ class VegasModeConfig:
             plugins_per_cycle=int(vegas_config.get('plugins_per_cycle', 6)),
             max_plugin_width_ratio=float(
                 vegas_config.get('max_plugin_width_ratio', 3.0)),
-            overflow_mode=str(vegas_config.get('overflow_mode', 'rotate')),
             plugin_order=list(vegas_config.get('plugin_order', [])),
             excluded_plugins=set(vegas_config.get('excluded_plugins', [])),
             target_fps=int(vegas_config.get('target_fps', 125)),
@@ -179,12 +117,6 @@ class VegasModeConfig:
             'scroll_speed': self.scroll_speed,
             'separator_width': self.separator_width,
             'intra_plugin_gap': self.intra_plugin_gap,
-            'render_width_pct': self.render_width_pct,
-            'min_content_separation': self.min_content_separation,
-            'min_cut_gap': self.min_cut_gap,
-            'smooth_scroll': self.smooth_scroll,
-            'continuous_scroll': self.continuous_scroll,
-            'extend_threshold_screens': self.extend_threshold_screens,
             'auto_trim': self.auto_trim,
             'trim_threshold': self.trim_threshold,
             'content_padding': self.content_padding,
@@ -192,7 +124,6 @@ class VegasModeConfig:
             'lead_in_width': self.lead_in_width,
             'plugins_per_cycle': self.plugins_per_cycle,
             'max_plugin_width_ratio': self.max_plugin_width_ratio,
-            'overflow_mode': self.overflow_mode,
             'plugin_order': self.plugin_order,
             'excluded_plugins': list(self.excluded_plugins),
             'target_fps': self.target_fps,
@@ -278,26 +209,6 @@ class VegasModeConfig:
         if self.buffer_ahead > 5:
             errors.append(f"buffer_ahead must be <= 5, got {self.buffer_ahead}")
 
-        if not 10 <= self.render_width_pct <= 100:
-            errors.append(
-                "render_width_pct must be between 10 and 100, "
-                f"got {self.render_width_pct}")
-
-        if not 0 <= self.min_content_separation <= 256:
-            errors.append(
-                "min_content_separation must be between 0 and 256, "
-                f"got {self.min_content_separation}")
-
-        if not 1.0 <= self.extend_threshold_screens <= 10.0:
-            errors.append(
-                "extend_threshold_screens must be between 1.0 and 10.0, "
-                f"got {self.extend_threshold_screens}")
-
-        if not 1 <= self.min_cut_gap <= 128:
-            errors.append(
-                "min_cut_gap must be between 1 and 128, "
-                f"got {self.min_cut_gap}")
-
         if self.intra_plugin_gap < 0:
             errors.append(
                 f"intra_plugin_gap must be >= 0, got {self.intra_plugin_gap}")
@@ -336,11 +247,6 @@ class VegasModeConfig:
             errors.append(
                 f"plugins_per_cycle must be <= 50, got {self.plugins_per_cycle}")
 
-        if self.overflow_mode not in ('rotate', 'truncate'):
-            errors.append(
-                "overflow_mode must be 'rotate' or 'truncate', "
-                f"got {self.overflow_mode!r}")
-
         if self.max_plugin_width_ratio < 0:
             errors.append(
                 "max_plugin_width_ratio must be >= 0 "
@@ -365,20 +271,6 @@ class VegasModeConfig:
             self.separator_width = int(vegas_config['separator_width'])
         if 'intra_plugin_gap' in vegas_config:
             self.intra_plugin_gap = int(vegas_config['intra_plugin_gap'])
-        if 'render_width_pct' in vegas_config:
-            self.render_width_pct = int(vegas_config['render_width_pct'])
-        if 'min_content_separation' in vegas_config:
-            self.min_content_separation = int(
-                vegas_config['min_content_separation'])
-        if 'min_cut_gap' in vegas_config:
-            self.min_cut_gap = int(vegas_config['min_cut_gap'])
-        if 'smooth_scroll' in vegas_config:
-            self.smooth_scroll = vegas_config['smooth_scroll']
-        if 'continuous_scroll' in vegas_config:
-            self.continuous_scroll = vegas_config['continuous_scroll']
-        if 'extend_threshold_screens' in vegas_config:
-            self.extend_threshold_screens = float(
-                vegas_config['extend_threshold_screens'])
         if 'auto_trim' in vegas_config:
             self.auto_trim = vegas_config['auto_trim']
         if 'trim_threshold' in vegas_config:
@@ -394,8 +286,6 @@ class VegasModeConfig:
         if 'max_plugin_width_ratio' in vegas_config:
             self.max_plugin_width_ratio = float(
                 vegas_config['max_plugin_width_ratio'])
-        if 'overflow_mode' in vegas_config:
-            self.overflow_mode = str(vegas_config['overflow_mode'])
         if 'plugin_order' in vegas_config:
             self.plugin_order = list(vegas_config['plugin_order'])
         if 'excluded_plugins' in vegas_config:

src/vegas_mode/coordinator.py

@@ -233,11 +233,6 @@ class VegasModeCoordinator:
             self._should_stop = False
             self._start_time = time.time()
 
-        # Line up the next group immediately, so the first extension is already
-        # warm rather than stalling the scroll to fetch it.
-        if self.vegas_config.continuous_scroll:
-            self.render_pipeline.start_prefetch()
-
         logger.info("Vegas mode started")
         return True
 
@@ -306,43 +301,16 @@ class VegasModeCoordinator:
         if has_pending_update:
             self._apply_pending_config()
 
-        if self.vegas_config.continuous_scroll:
-            # Drop cached content for plugins whose data just changed, so the
-            # next time each comes round it is composed from current data. The
-            # swap path's hot_swap_content() does this via process_updates(),
-            # but it also rebuilds and repositions the whole strip, which is
-            # the freeze-and-jump this mode exists to avoid. Without this the
-            # pending-update flags are never consumed and a segment keeps
-            # rendering whatever it was first built from — last night's live
-            # game still shown as live the next morning.
-            self.render_pipeline.refresh_updated_plugins()
+        # Check if we need to start a new cycle
+        if self.render_pipeline.is_cycle_complete():
+            if not self.render_pipeline.start_new_cycle():
+                logger.warning("Failed to start new Vegas cycle")
+                return False
+            self.stats['cycles_completed'] += 1
 
-            # Extend the strip before the scroll can reach its end, so the next
-            # group arrives from the right and motion never stops. No cycle
-            # boundary, so no freeze, no substitution and no restart with the
-            # viewport already full.
-            # Trickle in the plugins that can only be fetched here, one per
-            # frame, before considering a further extension.
-            if self.render_pipeline.has_deferred():
-                self.render_pipeline.drain_deferred()
-            elif self.render_pipeline.needs_extension():
-                if self.render_pipeline.extend_scroll_content():
-                    self.stats['cycles_completed'] += 1
-                elif self.render_pipeline.is_cycle_complete():
-                    # Extension failed and the strip has run out: fall back to
-                    # the swap rather than sitting on a dead frame.
-                    self.render_pipeline.start_new_cycle()
-        else:
-            # Check if we need to start a new cycle
-            if self.render_pipeline.is_cycle_complete():
-                if not self.render_pipeline.start_new_cycle():
-                    logger.warning("Failed to start new Vegas cycle")
-                    return False
-                self.stats['cycles_completed'] += 1
-
-            # Check for hot-swap opportunities
-            if self.render_pipeline.should_recompose():
-                self.render_pipeline.hot_swap_content()
+        # Check for hot-swap opportunities
+        if self.render_pipeline.should_recompose():
+            self.render_pipeline.hot_swap_content()
 
         # Render frame
         return self.render_pipeline.render_frame()
@@ -369,14 +337,7 @@ class VegasModeCoordinator:
         self._update_static_mode_plugins()
 
         frame_interval = self.vegas_config.get_frame_interval()
-        if self.vegas_config.continuous_scroll:
-            # The strip is continuously extended and trimmed, so its width says
-            # nothing about how long to run. This is only how often control
-            # returns to the display controller; interrupts are still checked
-            # every few frames, so it costs nothing to make it a fixed period.
-            duration = float(self.vegas_config.max_cycle_duration)
-        else:
-            duration = self.render_pipeline.get_dynamic_duration()
+        duration = self.render_pipeline.get_dynamic_duration()
         start_time = time.time()
         frame_count = 0
         fps_log_interval = 5.0  # Log FPS every 5 seconds
@@ -386,8 +347,6 @@ class VegasModeCoordinator:
         logger.info("Starting Vegas iteration for %.1fs", duration)
 
         while True:
-            frame_started = time.time()
-
             # Check for STATIC mode plugin that should pause scroll
             static_plugin = self._check_static_plugin_trigger()
             if static_plugin:
@@ -408,14 +367,8 @@ class VegasModeCoordinator:
                         # Paused for live priority - let caller handle
                         return False
 
-            # Sleep only the remainder of the frame budget. This used to sleep
-            # the whole interval on top of however long the frame took, so at a
-            # measured 31.6ms per frame a fixed 8ms of that was pure idle — a
-            # quarter of the budget spent not rendering. Subtracting the work
-            # already done keeps the pacing target while reclaiming that time,
-            # and yields the GIL either way so other threads still run.
-            frame_elapsed = time.time() - frame_started
-            time.sleep(max(0.0, frame_interval - frame_elapsed))
+            # Sleep for frame interval
+            time.sleep(frame_interval)
 
             # Increment frame count and check for interrupt periodically
             frame_count += 1

src/vegas_mode/geometry.py

@@ -16,7 +16,7 @@ All column scans go through numpy: a Python-level per-column loop over a
 path.
 """
 
-from typing import List, NamedTuple, Optional, Tuple
+from typing import NamedTuple, Optional, Tuple
 
 import numpy as np
 from PIL import Image
@@ -139,136 +139,6 @@ def trim_to_content(
     return TrimResult(cropped, img.width, left, img.width - right)
 
 
-def edge_blank(
-    img: Image.Image, threshold: int = DEFAULT_INK_THRESHOLD
-) -> Tuple[int, int]:
-    """
-    Blank column counts at the left and right edges of an image.
-
-    Used to space items by *measured* separation rather than a flat added gap.
-    A fixed gap gets this wrong in both directions at once: card-style content
-    drawn flush to its own edges ends up nearly touching its neighbour, while
-    content that already carries wide margins gets pushed even further apart.
-
-    Args:
-        img: Image to measure
-        threshold: Ink threshold
-
-    Returns:
-        (left_blank, right_blank). For an entirely blank image both are the
-        full width, since there is no ink to be close to.
-    """
-    bounds = content_bounds(img, threshold)
-    if bounds is None:
-        return img.width, img.width
-    first, last = bounds
-    return first, img.width - 1 - last
-
-
-def separation_gap(
-    left_img: Image.Image,
-    right_img: Image.Image,
-    target: int,
-    minimum: int = 0,
-    threshold: int = DEFAULT_INK_THRESHOLD,
-) -> int:
-    """
-    Columns to insert between two images so their ink is ``target`` apart.
-
-    Only the shortfall is added: if the two images already carry enough blank
-    at the facing edges, nothing (beyond ``minimum``) is inserted.
-
-    Args:
-        left_img: Image on the left
-        right_img: Image on the right
-        target: Desired blank columns between the two pieces of ink
-        minimum: Floor applied regardless of what the images already have
-        threshold: Ink threshold
-
-    Returns:
-        Number of columns to insert, never negative
-    """
-    existing = edge_blank(left_img, threshold)[1] + edge_blank(right_img, threshold)[0]
-    return max(minimum, target - existing, 0)
-
-
-def blank_runs(
-    img: Image.Image,
-    min_run: int,
-    threshold: int = DEFAULT_INK_THRESHOLD,
-) -> List[Tuple[int, int]]:
-    """
-    Find maximal runs of blank columns at least ``min_run`` wide.
-
-    Distinguishes item boundaries from letter spacing. Measured on real
-    rendered text, the gaps *between characters* are a single column, while the
-    gaps a plugin puts *between items* are 8px and up (the stocks ticker uses
-    32px, baseball 48px). Treating any blank column as a cut point therefore
-    slices words in half; requiring a run excludes letter spacing.
-
-    Args:
-        img: Image to scan
-        min_run: Minimum consecutive blank columns to qualify
-        threshold: Ink threshold
-
-    Returns:
-        List of (start, end) half-open column ranges, in left-to-right order
-    """
-    blank = ~column_has_ink(img, threshold)
-    if not blank.any():
-        return []
-
-    # Vectorised run detection: pad with False so runs touching either edge get
-    # a boundary, then read starts and ends off the first difference. A Python
-    # loop here would be far too slow on a 17,000px ticker strip.
-    padded = np.concatenate(([False], blank, [False]))
-    diff = np.diff(padded.astype(np.int8))
-    starts = np.flatnonzero(diff == 1)
-    ends = np.flatnonzero(diff == -1)
-
-    long_enough = (ends - starts) >= max(1, min_run)
-    return list(zip(starts[long_enough].tolist(), ends[long_enough].tolist()))
-
-
-def find_item_boundary(
-    img: Image.Image,
-    target: int,
-    min_run: int,
-    threshold: int = DEFAULT_INK_THRESHOLD,
-) -> Optional[int]:
-    """
-    Find the column nearest ``target`` that sits inside a gap between items.
-
-    Used to narrow an oversized segment without cutting through a word. Only
-    runs of at least ``min_run`` blank columns are considered, so the
-    single-column gaps between characters are never chosen — cutting there
-    orphaned the tail of a word into the following cycle, which is how a lone
-    "y" from "Wednesday" ended up floating between two unrelated plugins.
-
-    Args:
-        img: Image to cut
-        target: Preferred cut column
-        min_run: Minimum blank-run width that counts as an item boundary
-        threshold: Ink threshold
-
-    Returns:
-        A column inside a qualifying gap, or None when the image has no such
-        gap at all — in which case the caller must not cut it.
-    """
-    runs = blank_runs(img, min_run, threshold)
-    if not runs:
-        return None
-
-    # Nearest point of the nearest run. For a run left of target that is its
-    # end (content resumes just after), for a run right of target its start
-    # (content stopped just before) — the right choice in both directions.
-    def clamp_to_run(run: Tuple[int, int]) -> int:
-        start, end = run
-        return max(start, min(target, end - 1))
-
-    return min((clamp_to_run(r) for r in runs), key=lambda c: abs(c - target))
-
-
 def find_blank_cut(
     img: Image.Image,
     target: int,
@@ -299,19 +169,16 @@ def find_blank_cut(
         return target
 
     ink = column_has_ink(img, threshold)
-
-    # target may legitimately equal width (a cut after the last column), but
-    # there is no column to inspect there, so both bounds stop at width - 1.
-    lo = max(0, min(target - search_radius, width - 1))
-    hi = max(0, min(target + search_radius, width - 1))
+    lo = max(0, target - search_radius)
+    hi = min(width - 1, target + search_radius)
 
     # Walk outwards from target so the nearest gap wins.
     for offset in range(0, search_radius + 1):
         right = target + offset
-        if lo <= right <= hi and not ink[right]:
+        if right <= hi and not ink[right]:
             return right
         left = target - offset
-        if lo <= left <= hi and not ink[left]:
+        if left >= lo and not ink[left]:
             return left
 
     return target

src/vegas_mode/plugin_adapter.py

@@ -8,15 +8,10 @@ implement get_vegas_content() and fallback capture of display() output.
 import logging
 import threading
 import time
-from contextlib import nullcontext
 from typing import Optional, List, Any, Tuple, Union, TYPE_CHECKING
 from PIL import Image
 
-from src.vegas_mode.geometry import (
-    blank_runs,
-    separation_gap,
-    trim_to_content,
-)
+from src.vegas_mode.geometry import find_blank_cut, trim_to_content
 
 if TYPE_CHECKING:
     from src.plugin_system.base_plugin import BasePlugin
@@ -73,8 +68,7 @@ class PluginAdapter:
             self.display_width, self.display_height
         )
 
-    def get_content(self, plugin: 'BasePlugin', plugin_id: str,
-                    offscreen_only: bool = False) -> Optional[List[Image.Image]]:
+    def get_content(self, plugin: 'BasePlugin', plugin_id: str) -> Optional[List[Image.Image]]:
         """
         Get scrollable content from a plugin.
 
@@ -83,13 +77,6 @@ class PluginAdapter:
         Args:
             plugin: Plugin instance to get content from
             plugin_id: Plugin identifier for logging
-            offscreen_only: Skip every path that touches the shared display
-                canvas, for callers running off the render thread. The canvas
-                and the matrix proxy are process-wide mutable state, so
-                narrowing or capturing through them from another thread would
-                corrupt the frame the render loop is pushing. Returns None when
-                the plugin can only be served that way, leaving the caller to
-                fetch it on the render thread.
 
         Returns:
             List of PIL Images representing plugin content, or None if no content
@@ -113,38 +100,30 @@ class PluginAdapter:
         has_native = hasattr(plugin, 'get_vegas_content')
         logger.info("[%s] Has get_vegas_content: %s", plugin_id, has_native)
         if has_native:
-            content = self._get_native_content(plugin, plugin_id, offscreen_only)
+            content = self._get_native_content(plugin, plugin_id)
             if content:
                 total_width = sum(img.width for img in content)
                 logger.info(
                     "[%s] Native content SUCCESS: %d images, %dpx total",
                     plugin_id, len(content), total_width
                 )
-                return self._finalize(content, plugin_id, 'native', plugin)
+                return self._finalize(content, plugin_id, 'native')
             logger.info("[%s] Native content returned None", plugin_id)
 
         # Try to get scroll_helper's cached image (for scrolling plugins like stocks/odds)
         has_scroll_helper = hasattr(plugin, 'scroll_helper')
         logger.info("[%s] Has scroll_helper: %s", plugin_id, has_scroll_helper)
-        content = self._get_scroll_helper_content(plugin, plugin_id, offscreen_only)
+        content = self._get_scroll_helper_content(plugin, plugin_id)
         if content:
             total_width = sum(img.width for img in content)
             logger.info(
                 "[%s] ScrollHelper content SUCCESS: %d images, %dpx total",
                 plugin_id, len(content), total_width
             )
-            return self._finalize(content, plugin_id, 'scroll_helper', plugin)
+            return self._finalize(content, plugin_id, 'scroll_helper')
         if has_scroll_helper:
             logger.info("[%s] ScrollHelper content returned None", plugin_id)
 
-        if offscreen_only:
-            # Display capture needs the shared canvas; leave it to the caller.
-            logger.info(
-                "[%s] Needs display capture, deferring to the render thread",
-                plugin_id
-            )
-            return None
-
         # Fall back to display capture
         logger.info("[%s] Trying fallback display capture...", plugin_id)
         content = self._capture_display_content(plugin, plugin_id)
@@ -154,7 +133,7 @@ class PluginAdapter:
                 "[%s] Fallback capture SUCCESS: %d images, %dpx total",
                 plugin_id, len(content), total_width
             )
-            return self._finalize(content, plugin_id, 'fallback', plugin)
+            return self._finalize(content, plugin_id, 'fallback')
 
         logger.warning(
             "[%s] NO CONTENT from any method (native=%s, scroll_helper=%s, fallback=tried)",
@@ -163,8 +142,7 @@ class PluginAdapter:
         return None
 
     def _finalize(
-        self, images: List[Image.Image], plugin_id: str, source: str,
-        plugin: Optional['BasePlugin'] = None
+        self, images: List[Image.Image], plugin_id: str, source: str
     ) -> Optional[List[Image.Image]]:
         """
         Trim dead space off a segment, then cache it.
@@ -187,13 +165,8 @@ class PluginAdapter:
             Trimmed image list, or None if nothing worth showing remains
         """
         if not self.config.auto_trim:
-            # 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, plugin)
-            self._cache_content(plugin_id, kept)
-            return kept
+            self._cache_content(plugin_id, images)
+            return images
 
         original_width = sum(img.width for img in images)
         kept: List[Image.Image] = []
@@ -236,171 +209,20 @@ class PluginAdapter:
                 len(kept), dropped_blank
             )
 
-        kept = self._apply_width_budget(kept, plugin_id, plugin)
+        kept = self._apply_width_budget(kept, plugin_id)
 
         self._cache_content(plugin_id, kept)
         return kept
 
-    def _capture(self):
-        """
-        Context manager suppressing hardware writes while plugin render code runs.
-
-        Degrades to a no-op when the display manager predates capture_mode. As
-        with _render_at, losing the suppression risks a visible flash, whereas
-        raising would be swallowed by the broad handlers upstream and drop the
-        plugin's content entirely — much worse.
-        """
-        capture_mode = getattr(self.display_manager, 'capture_mode', None)
-        if capture_mode is None:
-            logger.debug(
-                "display_manager has no capture_mode(); plugin writes during "
-                "content capture may reach the panel"
-            )
-            return nullcontext()
-        return capture_mode()
-
-    def _render_at(self, width: int):
-        """
-        Context manager narrowing the plugin-facing canvas to ``width``.
-
-        Degrades to a no-op when the display manager predates render_size (a
-        third-party or older test harness). Losing the narrowing is a cosmetic
-        regression; raising here would be caught by the broad handlers upstream
-        and silently drop the plugin's content entirely.
-        """
-        render_size = getattr(self.display_manager, 'render_size', None)
-        if render_size is None:
-            logger.debug(
-                "display_manager has no render_size(); Vegas width requests "
-                "will be ignored"
-            )
-            return nullcontext()
-        return render_size(width)
-
-    def resolve_render_width(self, plugin: 'BasePlugin', plugin_id: str) -> int:
-        """
-        Width to tell a plugin it has while it renders for the ticker.
-
-        Resolution order, most specific first:
-          1. the plugin's own ``vegas_width_pct`` config value
-          2. the global ``vegas_scroll.render_width_pct``
-          3. the full panel width
-
-        A percentage rather than an absolute width so one setting travels
-        across panel sizes.
-
-        Args:
-            plugin: Plugin instance, consulted for a per-plugin override
-            plugin_id: Plugin identifier for logging
-
-        Returns:
-            Target width in pixels, never wider than the panel
-        """
-        pct = self.config.render_width_pct
-
-        plugin_cfg = getattr(plugin, 'config', None)
-        if isinstance(plugin_cfg, dict):
-            raw = plugin_cfg.get('vegas_width_pct')
-            if raw not in (None, ''):
-                try:
-                    candidate = int(raw)
-                except (TypeError, ValueError):
-                    logger.warning(
-                        "[%s] Invalid vegas_width_pct %r, ignoring", plugin_id, raw)
-                else:
-                    if 10 <= candidate <= 100:
-                        pct = candidate
-                    else:
-                        logger.warning(
-                            "[%s] vegas_width_pct %d out of range 10-100, ignoring",
-                            plugin_id, candidate)
-
-        if pct >= 100:
-            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 _plugin_setting(self, plugin: 'BasePlugin', key: str):
-        """Read a per-plugin config override, or None if absent."""
-        plugin_cfg = getattr(plugin, 'config', None)
-        if not isinstance(plugin_cfg, dict):
-            return None
-        value = plugin_cfg.get(key)
-        return None if value in (None, '') else value
-
-    def resolve_overflow_mode(self, plugin: 'BasePlugin', plugin_id: str) -> str:
-        """
-        How to handle content that exceeds this plugin's width budget.
-
-        'rotate' advances a window each cycle so everything is seen eventually,
-        which suits interchangeable items. 'truncate' always shows the start,
-        which suits ordered content — a league table that shows ranks 1-6 and
-        then resumes at 7 two rotations later reads as out of order, and nobody
-        needs rank 23 in a ticker anyway.
-
-        Per-plugin ``vegas_overflow`` wins over the global ``overflow_mode``.
-        """
-        raw = self._plugin_setting(plugin, 'vegas_overflow')
-        if raw is not None:
-            candidate = str(raw).strip().lower()
-            if candidate in ('rotate', 'truncate'):
-                return candidate
-            logger.warning(
-                "[%s] Invalid vegas_overflow %r, expected 'rotate' or 'truncate'",
-                plugin_id, raw
-            )
-        return self.config.overflow_mode
-
-    def _width_budget(self, plugin: Optional['BasePlugin'] = None,
-                      plugin_id: str = '') -> int:
-        """
-        Maximum columns one plugin may occupy in a cycle. 0 means unlimited.
-
-        A per-plugin ``vegas_max_width_screens`` overrides the global ratio, so
-        content that has to stay whole can be given room (or uncapped with 0)
-        without lifting the cap on every ticker.
-        """
+    def _width_budget(self) -> int:
+        """Maximum columns one plugin may occupy in a cycle. 0 means unlimited."""
         ratio = self.config.max_plugin_width_ratio
-
-        if plugin is not None:
-            raw = self._plugin_setting(plugin, 'vegas_max_width_screens')
-            if raw is not None:
-                try:
-                    candidate = float(raw)
-                except (TypeError, ValueError):
-                    logger.warning(
-                        "[%s] Invalid vegas_max_width_screens %r, ignoring",
-                        plugin_id, raw
-                    )
-                else:
-                    if candidate >= 0:
-                        ratio = candidate
-                    else:
-                        logger.warning(
-                            "[%s] vegas_max_width_screens must be >= 0, got %s",
-                            plugin_id, candidate
-                        )
-
         if ratio <= 0:
             return 0
         return int(self.display_width * ratio)
 
     def _apply_width_budget(
-        self, images: List[Image.Image], plugin_id: str,
-        plugin: Optional['BasePlugin'] = None
+        self, images: List[Image.Image], plugin_id: str
     ) -> List[Image.Image]:
         """
         Hold one plugin to its share of a cycle.
@@ -419,19 +241,13 @@ class PluginAdapter:
             Images that fit the budget, starting from the plugin's current
             rotation offset.
         """
-        budget = self._width_budget(plugin, plugin_id)
-        mode = (self.resolve_overflow_mode(plugin, plugin_id)
-                if plugin is not None else self.config.overflow_mode)
+        budget = self._width_budget()
 
-        # 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)
-        )
+        # 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)
 
         if not budget or total <= budget:
             # Fits, so reset rotation — the whole segment is being shown.
@@ -439,15 +255,9 @@ class PluginAdapter:
             return images
 
         if len(images) == 1:
-            return [self._crop_to_budget(images[0], budget, plugin_id, mode)]
+            return [self._crop_to_budget(images[0], budget, plugin_id)]
 
-        if mode == 'truncate':
-            # Ordered content: always show from the top. Deliberately does not
-            # advance the offset, so the same opening items appear every time
-            # rather than the viewer being shown the middle of a ranked list.
-            start = 0
-        else:
-            start = self._item_offsets.get(plugin_id, 0) % len(images)
+        start = self._item_offsets.get(plugin_id, 0) % len(images)
         selected: List[Image.Image] = []
         used = 0
         consumed = 0
@@ -456,33 +266,24 @@ 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
-            if selected:
-                cost += self._row_gap(selected[-1], img)
+            cost = img.width + (gap if selected else 0)
             if selected and used + cost > budget:
                 break
             selected.append(img)
             used += cost
             consumed += 1
 
-        if mode == 'truncate':
-            logger.info(
-                "[%s] Width budget %dpx: showing the first %d of %d row(s) "
-                "(%dpx incl. gaps); the rest are not shown (overflow=truncate)",
-                plugin_id, budget, len(selected), len(images), used
-            )
-        else:
-            self._item_offsets[plugin_id] = (start + consumed) % len(images)
-            logger.info(
-                "[%s] Width budget %dpx: showing %d of %d row(s) (%dpx incl. gaps) "
-                "from offset %d; remainder deferred to a later cycle",
-                plugin_id, budget, len(selected), len(images), used, start
-            )
+        self._item_offsets[plugin_id] = (start + consumed) % len(images)
+
+        logger.info(
+            "[%s] Width budget %dpx: showing %d of %d row(s) (%dpx incl. gaps) "
+            "from offset %d; remainder deferred to a later cycle",
+            plugin_id, budget, len(selected), len(images), used, start
+        )
         return selected
 
     def _crop_to_budget(
-        self, img: Image.Image, budget: int, plugin_id: str,
-        mode: str = 'rotate'
+        self, img: Image.Image, budget: int, plugin_id: str
     ) -> Image.Image:
         """
         Narrow a single oversized image to the budget, advancing a window
@@ -491,68 +292,32 @@ class PluginAdapter:
         The cut is snapped to the nearest blank column so it does not slice
         through a glyph or logo and leave half a character at the panel edge.
         """
-        if mode == 'truncate':
-            # Always the start of the strip, so a ranked table is never entered
-            # from the middle.
+        offset = self._item_offsets.get(plugin_id, 0)
+        if offset >= img.width:
             offset = 0
-        else:
-            offset = self._item_offsets.get(plugin_id, 0)
-            if offset >= img.width:
-                offset = 0
 
-        # Cut only where the plugin left a real gap between items. Snapping to
-        # any blank column used to pick the single-column gaps between
-        # characters, splitting a word and orphaning its tail into the next
-        # cycle — a lone "y" from "Wednesday" floating between two unrelated
-        # plugins. Overshooting the budget is the lesser evil.
-        min_run = max(2, self.config.min_cut_gap)
-        gaps = blank_runs(img, min_run, self.config.trim_threshold)
+        # Snap both edges to blank columns. The search radius is generous
+        # enough to clear a wide glyph but small enough not to distort the
+        # requested budget much.
+        snap = max(8, self.display_width // 16)
+        start = find_blank_cut(img, offset, snap, self.config.trim_threshold)
+        end = find_blank_cut(
+            img, min(start + budget, img.width), snap, self.config.trim_threshold)
+        if end <= start:
+            end = min(start + budget, img.width)
 
-        if not gaps:
-            # No internal gaps means continuous content — a map, a chart, a
-            # photo — where any column is as good as any other, so cut to the
-            # budget exactly. The gap rule exists to protect discrete items
-            # (words, ticker entries); it would be wrong to let a solid image
-            # escape the cap in its name.
-            end = min(offset + budget, img.width)
-            if mode != 'truncate':
-                self._item_offsets[plugin_id] = 0 if end >= img.width else end
-            logger.info(
-                "[%s] Width budget %dpx: cropped continuous %dpx image to "
-                "[%d:%d] (no item gaps of %dpx+ to align to)%s",
-                plugin_id, budget, img.width, offset, end, min_run,
-                "" if mode != 'truncate' else "; showing the start only"
-            )
-            return img.crop((offset, 0, end, img.height))
-
-        # Cut mid-gap so the content either side keeps some breathing room.
-        cuts = sorted({0, img.width} | {(a + b) // 2 for a, b in gaps})
-
-        start = max((c for c in cuts if c <= offset), default=0)
-        later = [c for c in cuts if c > start]
-        if not later:
-            end = img.width
-        else:
-            within = [c for c in later if c <= start + budget]
-            # No boundary inside the budget: take the next one and overrun,
-            # because the alternative is cutting through an item.
-            end = max(within) if within else min(later)
-
-        if mode != 'truncate':
-            # Next cycle resumes where this one stopped; wrap when the strip ends.
-            self._item_offsets[plugin_id] = 0 if end >= img.width else end
+        # Next cycle resumes where this one stopped; wrap when the strip ends.
+        self._item_offsets[plugin_id] = 0 if end >= img.width else end
 
         logger.info(
             "[%s] Width budget %dpx: cropped single %dpx image to [%d:%d] "
-            "(%dpx) at item boundaries, %s",
-            plugin_id, budget, img.width, start, end, end - start,
-            "showing the start only (overflow=truncate)"
-            if mode == 'truncate' else "window advances next cycle"
+            "(%dpx), window advances next cycle",
+            plugin_id, budget, img.width, start, end, end - start
         )
         return img.crop((start, 0, end, img.height))
 
     def _get_native_content(
-        self, plugin: 'BasePlugin', plugin_id: str, offscreen_only: bool = False
+        self, plugin: 'BasePlugin', plugin_id: str
     ) -> Optional[List[Image.Image]]:
         """
         Get content via plugin's native get_vegas_content() method.
@@ -566,40 +331,7 @@ class PluginAdapter:
         """
         try:
             logger.info("[%s] Native: calling get_vegas_content()", plugin_id)
-
-            # Tell the plugin how much width the ticker wants it to use, and
-            # narrow the canvas for the duration of the call. A plugin that
-            # sizes its own images from display_manager.matrix.width picks up
-            # the narrower value with no changes of its own; one that wants to
-            # be explicit can read get_vegas_render_width().
-            render_width = self.resolve_render_width(plugin, plugin_id)
-            if render_width != self.display_width:
-                logger.info(
-                    "[%s] Native: requesting %dpx instead of %dpx",
-                    plugin_id, render_width, self.display_width
-                )
-
-            plugin._vegas_render_width = render_width
-            try:
-                # capture_mode unconditionally, even at full width. Building
-                # Vegas content is an off-screen operation, but a plugin is free
-                # to call update_display() while doing it — and outside
-                # capture_mode that write lands on the hardware, flashing the
-                # panel mid-scroll. The narrowing context is separate because it
-                # is a no-op at full width.
-                if offscreen_only:
-                    # _render_at swaps the shared canvas, so it is unsafe here.
-                    # _vegas_render_width is set regardless: a plugin reading
-                    # get_vegas_render_width() still gets its narrow size, and
-                    # one that only reads matrix.width renders full width and is
-                    # trimmed instead.
-                    with self._capture():
-                        result = plugin.get_vegas_content()
-                else:
-                    with self._capture(), self._render_at(render_width):
-                        result = plugin.get_vegas_content()
-            finally:
-                plugin._vegas_render_width = None
+            result = plugin.get_vegas_content()
 
             if result is None:
                 logger.info("[%s] Native: get_vegas_content() returned None", plugin_id)
@@ -677,7 +409,7 @@ class PluginAdapter:
             return None
 
     def _get_scroll_helper_content(
-        self, plugin: 'BasePlugin', plugin_id: str, offscreen_only: bool = False
+        self, plugin: 'BasePlugin', plugin_id: str
     ) -> Optional[List[Image.Image]]:
         """
         Get content from plugin's scroll_helper if available.
@@ -711,13 +443,6 @@ class PluginAdapter:
                     "[%s] scroll_helper.cached_image is None, triggering content generation",
                     plugin_id
                 )
-                if offscreen_only:
-                    # Generating it calls display(), which needs the canvas.
-                    logger.info(
-                        "[%s] scroll_helper cache empty; deferring generation "
-                        "to the render thread", plugin_id
-                    )
-                    return None
                 # Try to trigger scroll content generation
                 cached_image = self._trigger_scroll_content_generation(
                     plugin, plugin_id, scroll_helper
@@ -866,7 +591,7 @@ class PluginAdapter:
             # Save display state to restore after
             original_image = self.display_manager.image.copy()
 
-            with self._capture():
+            with self.display_manager.capture_mode():
                 # Method 1: Try _create_scrolling_display (stocks pattern)
                 if hasattr(plugin, '_create_scrolling_display'):
                     logger.info(
@@ -958,18 +683,7 @@ class PluginAdapter:
 
             # Clear and call plugin display — use capture_mode to suppress hardware writes
             # that plugins may trigger internally via update_display().
-            #
-            # render_size narrows the canvas the plugin lays out against, so a
-            # plugin that spreads across the whole panel produces a compact
-            # arrangement rather than one that has to be cropped afterwards.
-            render_width = self.resolve_render_width(plugin, plugin_id)
-            if render_width != self.display_width:
-                logger.info(
-                    "[%s] Fallback: rendering at %dpx instead of %dpx",
-                    plugin_id, render_width, self.display_width
-                )
-
-            with self._capture(), self._render_at(render_width):
+            with self.display_manager.capture_mode():
                 self.display_manager.clear()
                 logger.info("[%s] Fallback: display cleared, calling display()", plugin_id)
 
@@ -1003,7 +717,7 @@ class PluginAdapter:
                     plugin_id
                 )
                 # Try once more with force_clear=True
-                with self._capture(), self._render_at(render_width):
+                with self.display_manager.capture_mode():
                     self.display_manager.clear()
                     plugin.display(force_clear=True)
                     captured = self.display_manager.image.copy()
@@ -1135,53 +849,6 @@ class PluginAdapter:
             else:
                 self._content_cache.clear()
 
-    def invalidate_plugin_scroll_cache(
-        self, plugin: 'BasePlugin', plugin_id: str
-    ) -> bool:
-        """
-        Drop a plugin's own cached scroll image so its visual is rebuilt.
-
-        Invalidating only this adapter's cache is not enough. A plugin that
-        composes a scroll strip hands back the *same* image every time until its
-        own cache is cleared — the sports plugins' ``get_vegas_content()``
-        regenerates only "if the cache is empty" — so without this a segment
-        keeps rendering whatever data it was first built from. That is how a
-        game that was live last night can still be displayed as live the next
-        morning.
-
-        Two layouts to cover: a helper directly on the plugin (stocks, news,
-        odds-ticker) and one owned by a scroll-display manager (the sports
-        scoreboards). ``cached_image`` and ``cached_array`` must be cleared
-        together, since the array is the image's numpy mirror and code paths
-        read whichever is convenient.
-
-        Returns:
-            True if a cache was found and cleared.
-        """
-        cleared = False
-        for owner in (plugin, getattr(plugin, '_scroll_manager', None),
-                      getattr(plugin, 'scroll_manager', None)):
-            if owner is None:
-                continue
-            helper = getattr(owner, 'scroll_helper', None)
-            if helper is None:
-                continue
-            try:
-                if getattr(helper, 'cached_image', None) is not None:
-                    helper.cached_image = None
-                    cleared = True
-                if getattr(helper, 'cached_array', None) is not None:
-                    helper.cached_array = None
-                    cleared = True
-            except Exception:  # pylint: disable=broad-except
-                logger.exception(
-                    "[%s] Could not clear scroll cache on %s",
-                    plugin_id, type(owner).__name__
-                )
-        if cleared:
-            logger.debug("[%s] Cleared plugin scroll cache", plugin_id)
-        return cleared
-
     def get_content_type(self, plugin: 'BasePlugin', plugin_id: str) -> str:
         """
         Get the type of content a plugin provides.

src/vegas_mode/render_pipeline.py

@@ -6,7 +6,6 @@ Uses the existing ScrollHelper for numpy-optimized scroll operations.
 """
 
 import logging
-import os
 import time
 import threading
 from collections import deque
@@ -15,7 +14,6 @@ from PIL import Image
 
 from src.common.scroll_helper import ScrollHelper
 from src.vegas_mode.config import VegasModeConfig
-from src.vegas_mode.geometry import separation_gap
 from src.vegas_mode.stream_manager import StreamManager
 
 if TYPE_CHECKING:
@@ -36,10 +34,6 @@ class RenderPipeline:
     - Track scroll cycle completion
     """
 
-    # Minimum gap between fetches of canvas-bound plugins, so their individual
-    # stalls land in separate moments rather than one run of hitches.
-    DEFERRED_DRAIN_INTERVAL = 2.0
-
     def __init__(
         self,
         config: VegasModeConfig,
@@ -87,14 +81,6 @@ class RenderPipeline:
         self._staging_scroll_image: Optional[Image.Image] = None
         self._buffer_lock = threading.Lock()
 
-        # Group prepared off the render thread, waiting to be appended.
-        self._prepared_group = None
-        # Plugins that need the shared canvas, appended one at a time.
-        self._deferred_queue: List[str] = []
-        self._last_drain_time = 0.0
-        self._prefetch_thread: Optional[threading.Thread] = None
-        self._prefetch_lock = threading.Lock()
-
         # Render state
         self._is_rendering = False
         self._cycle_complete = False
@@ -124,7 +110,6 @@ class RenderPipeline:
         """Configure ScrollHelper with current settings."""
         self.scroll_helper.set_frame_based_scrolling(self.config.frame_based_scrolling)
         self.scroll_helper.set_scroll_delay(self.config.scroll_delay)
-        self.scroll_helper.set_sub_pixel_scrolling(self.config.smooth_scroll)
 
         # Config scroll_speed is always pixels per second, but ScrollHelper
         # interprets it differently based on frame_based_scrolling mode:
@@ -203,14 +188,12 @@ class RenderPipeline:
 
             logger.info(
                 "Composed scroll image: %dx%d, %d plugin block(s), %d rows, "
-                "separator=%dpx between plugins, rows spaced to %dpx of ink "
-                "(min added %dpx)",
+                "separator=%dpx between plugins / %dpx within",
                 self.scroll_helper.cached_image.width if self.scroll_helper.cached_image else 0,
                 self.display_height,
                 len(blocks),
                 total_rows,
                 self.config.separator_width,
-                self.config.min_content_separation,
                 self.config.intra_plugin_gap,
             )
 
@@ -221,226 +204,6 @@ class RenderPipeline:
             logger.exception("Error composing scroll content")
             return False
 
-    def needs_extension(self) -> bool:
-        """
-        Whether the strip should be extended with the next group of plugins.
-
-        Cheap enough to call every frame: it is arithmetic over cached state.
-        """
-        if not self.config.continuous_scroll or not self.scroll_helper.cached_image:
-            return False
-        threshold = int(self.display_width * self.config.extend_threshold_screens)
-        return self.scroll_helper.remaining_unscrolled() <= threshold
-
-    def start_prefetch(self) -> None:
-        """
-        Begin preparing the next group in the background, if not already doing so.
-
-        This is what makes the join seamless rather than merely continuous:
-        fetching a group costs 0.5-4.8s (rendering leaderboard and baseball cards
-        dominates), and doing it on the render thread stalls the scroll for that
-        long. Off the render thread there is a whole group's scroll time to work
-        in, so by the time the strip needs extending the content is already sat
-        waiting.
-
-        Only paths that avoid the shared display canvas run here; anything
-        needing it is marked and picked up on the render thread, where it is
-        safe. Those are the cheap ones — display capture measured 12-14ms
-        against seconds for the native renders.
-        """
-        if not self.config.continuous_scroll:
-            return
-
-        with self._prefetch_lock:
-            if self._prefetch_thread is not None and self._prefetch_thread.is_alive():
-                return
-            if self._prepared_group is not None:
-                return  # already have one waiting
-
-            def _work():
-                # Deprioritise against the render loop. Linux applies nice
-                # per-thread, and the heavy lifting here is PIL and numpy work
-                # that releases the GIL, so the scheduler can actually act on
-                # it — without this the prefetch competes for the same cores and
-                # costs frames.
-                try:
-                    os.nice(10)
-                except (OSError, AttributeError):
-                    pass
-                try:
-                    group = self.stream_manager.take_next_group(offscreen_only=True)
-                except Exception:
-                    logger.exception("Background prefetch failed")
-                    group = []
-                with self._prefetch_lock:
-                    self._prepared_group = group
-
-            self._prefetch_thread = threading.Thread(
-                target=_work, daemon=True, name="vegas-strip-prefetch")
-            self._prefetch_thread.start()
-
-    def drain_deferred(self) -> bool:
-        """
-        Fetch one queued canvas-bound plugin and append it to the strip.
-
-        Called once per frame. These plugins cannot be prepared off the render
-        thread — display capture and scroll-content generation both need the
-        shared canvas — so each costs roughly 290ms here. Doing one at a time
-        spreads that out instead of stalling for the whole group at once, and the
-        strip's lookahead means nothing runs dry while they arrive.
-
-        The cost is that a deferred plugin appears slightly after the group it
-        came with, which is a fair trade for a smooth scroll.
-
-        Returns:
-            True if a plugin was appended
-        """
-        if not self._deferred_queue:
-            return False
-
-        # Space the drains out. Each costs 40-600ms, and taking them back to
-        # back turns one long stall into a train of short ones — barely better.
-        # With a healthy lookahead there is no hurry, so wait a beat between
-        # them; when the strip is actually running short, fetch immediately.
-        threshold = int(self.display_width * self.config.extend_threshold_screens)
-        urgent = self.scroll_helper.remaining_unscrolled() <= threshold
-        if not urgent:
-            now = time.time()
-            if now - self._last_drain_time < self.DEFERRED_DRAIN_INTERVAL:
-                return False
-            self._last_drain_time = now
-        else:
-            self._last_drain_time = time.time()
-
-        plugin_id = self._deferred_queue.pop(0)
-        plugins = getattr(self.stream_manager.plugin_manager, 'plugins', {})
-        plugin = plugins.get(plugin_id)
-        if plugin is None:
-            return False
-
-        try:
-            images = self.stream_manager.plugin_adapter.get_content(plugin, plugin_id)
-        except Exception:
-            logger.exception("[%s] Error fetching deferred content", plugin_id)
-            return False
-
-        if not images:
-            return False
-
-        appended = self.scroll_helper.append_content(
-            content_items=[self._join_plugin_rows(images)],
-            item_gap=self.config.separator_width,
-            element_gap=0,
-        )
-        if appended:
-            with self._buffer_lock:
-                self._active_scroll_image = self.scroll_helper.cached_image
-            logger.info(
-                "[%s] Appended deferred content: strip now %dpx, %dpx ahead",
-                plugin_id, self.scroll_helper.total_scroll_width,
-                self.scroll_helper.remaining_unscrolled()
-            )
-        return appended
-
-    def has_deferred(self) -> bool:
-        """Whether any canvas-bound plugins are still queued."""
-        return bool(self._deferred_queue)
-
-    def _claim_prepared_group(self):
-        """Take the prefetched group, if one is ready."""
-        with self._prefetch_lock:
-            group = self._prepared_group
-            self._prepared_group = None
-        return group
-
-    def extend_scroll_content(self) -> bool:
-        """
-        Append the next group of plugins to the strip, without interrupting motion.
-
-        This is what replaces the swap. Scroll position is untouched, so the new
-        content simply arrives from the right; there is no substitution to see
-        and no restart with the viewport already full.
-
-        Consumed columns behind the viewport are then released, keeping the strip
-        bounded however long Vegas runs.
-
-        Returns:
-            True if the strip was extended
-        """
-        try:
-            grouped = self._claim_prepared_group()
-            if grouped is None:
-                # Nothing prepared (first extension, or prefetch still running).
-                # Fetch inline; the scroll hitches, but content keeps flowing.
-                logger.info("No prepared group ready; fetching inline")
-                grouped = self.stream_manager.take_next_group()
-
-            if not grouped:
-                logger.warning("No content available to extend the scroll strip")
-                return False
-
-            # Plugins the background thread had to defer need the shared canvas,
-            # so they can only be fetched here. Queue them rather than doing all
-            # of them now: measured, six in one go held the render thread for
-            # 1.75s. They are trickled in one per frame by drain_deferred(),
-            # which the strip's lookahead comfortably absorbs.
-            deferred = [pid for pid, images in grouped if images is None]
-            if deferred:
-                self._deferred_queue.extend(deferred)
-                logger.info(
-                    "Queued %d plugin(s) needing the render thread: %s",
-                    len(deferred), ', '.join(deferred)
-                )
-
-            grouped = [(pid, imgs) for pid, imgs in grouped if imgs]
-
-            if not grouped:
-                # Everything in this group is queued; the queue will extend the
-                # strip as it drains, so this is not a failure.
-                logger.info("Whole group deferred; strip will extend as it drains")
-                self.start_prefetch()
-                return bool(deferred)
-
-            blocks = []
-            total_rows = 0
-            for _plugin_id, images in grouped:
-                total_rows += len(images)
-                blocks.append(self._join_plugin_rows(images))
-
-            appended = self.scroll_helper.append_content(
-                content_items=blocks,
-                item_gap=self.config.separator_width,
-                element_gap=0,
-            )
-            if not appended:
-                return False
-
-            # Keep a screen's worth behind the viewport as a safety margin.
-            self.scroll_helper.drop_scrolled_prefix(keep_before=self.display_width)
-
-            with self._buffer_lock:
-                self._active_scroll_image = self.scroll_helper.cached_image
-
-            self._segments_in_scroll = [pid for pid, _ in grouped]
-            self.stats['composition_count'] += 1
-            self.stats['extensions'] = self.stats.get('extensions', 0) + 1
-
-            logger.info(
-                "Extended scroll strip with %d plugin block(s), %d rows: "
-                "strip now %dpx, %dpx still ahead of the viewport",
-                len(blocks), total_rows, self.scroll_helper.total_scroll_width,
-                self.scroll_helper.remaining_unscrolled()
-            )
-
-            # Line up the group after this one straight away, so it is ready
-            # well before the strip runs short again.
-            self.start_prefetch()
-            return True
-
-        except (ValueError, TypeError, OSError, RuntimeError):
-            logger.exception("Error extending scroll content")
-            return False
-
     def _join_plugin_rows(self, images: List[Image.Image]) -> Image.Image:
         """
         Concatenate one plugin's images into a single block.
@@ -456,27 +219,15 @@ class RenderPipeline:
         if len(images) == 1:
             return images[0]
 
-        floor = max(0, self.config.intra_plugin_gap)
-        target = max(0, self.config.min_content_separation)
-        threshold = self.config.trim_threshold
-
-        # Space by measured separation, not a flat gap. Rows drawn flush to
-        # their own edges (sports score cards) would otherwise end up nearly
-        # touching, while rows that already carry wide margins would be pushed
-        # needlessly further apart.
-        gaps = [
-            separation_gap(images[i], images[i + 1], target, floor, threshold)
-            for i in range(len(images) - 1)
-        ]
-
-        width = sum(img.width for img in images) + sum(gaps)
+        gap = max(0, self.config.intra_plugin_gap)
+        width = sum(img.width for img in images) + gap * (len(images) - 1)
         height = max(img.height for img in images)
 
         block = Image.new('RGB', (width, height), (0, 0, 0))
         x = 0
-        for i, img in enumerate(images):
+        for img in images:
             block.paste(img, (x, 0))
-            x += img.width + (gaps[i] if i < len(gaps) else 0)
+            x += img.width + gap
         return block
 
     def render_frame(self) -> bool:
@@ -499,33 +250,21 @@ class RenderPipeline:
 
             # Determine if the cycle is done.
             #
-            # get_visible_portion wraps: once scroll_position + display_width
-            # passes the end of the strip it fills the right-hand side of the
-            # frame from the *head* of the same strip. So the last
-            # display_width of travel shows the cycle's first plugin re-entering
-            # on the right while its last plugin exits on the left, and the
-            # recompose that follows then replaces both at once. That reads as
-            # the ticker "switching mid-scroll".
+            # scroll_helper considers a cycle complete only after
+            # total_distance_scrolled >= total_scroll_width + display_width.
+            # That extra display_width of travel causes a "wrap-around" phase
+            # where scroll_position resets to ~0 and the first plugin's content
+            # re-enters from the right — the user sees this 2-3 s of re-entry
+            # as "a plugin partially displaying before the next one starts."
             #
-            # This used to be hidden because the strip began with a full
-            # display_width of blank, so the wrapped-in region was black.
-            # lead_in_width now defaults to 0 (that blank was 10s of dead panel
-            # at 50px/s), which exposed the wrap — so the cycle has to end
-            # before it, one display width earlier.
-            #
-            # A strip no wider than the display never wraps, and subtracting
-            # would make the cycle complete instantly, so clamp in that case.
-            # In continuous mode there is no cycle to complete: the strip is
-            # extended before the scroll can reach its end, so the wrap is never
-            # entered and motion never stops. The completion path below stays for
-            # the swap behaviour and as a backstop if an extension fails.
-            wrap_point = self.scroll_helper.total_scroll_width
-            if wrap_point > self.display_width:
-                wrap_point -= self.display_width
-
+            # We end the cycle as soon as total_distance_scrolled reaches
+            # total_scroll_width (the wrap-around point), before any second-pass
+            # content becomes visible.  The scroll_helper's own is_scroll_complete()
+            # check is kept as a fallback for any edge-cases where that threshold
+            # is never hit.
             at_wrap_point = (
                 not self._cycle_complete and
-                self.scroll_helper.total_distance_scrolled >= wrap_point
+                self.scroll_helper.total_distance_scrolled >= self.scroll_helper.total_scroll_width
             )
 
             if at_wrap_point or self.scroll_helper.is_scroll_complete():
@@ -629,25 +368,6 @@ class RenderPipeline:
 
         return False
 
-    def refresh_updated_plugins(self) -> bool:
-        """
-        Let changed plugin data reach the strip without interrupting motion.
-
-        Used instead of :meth:`hot_swap_content` when scrolling continuously.
-        The swap rebuilds the whole image and repositions the scroll, which is
-        visible as a freeze and a jump; the strip is extended here rather than
-        replaced, so it is enough to drop the stale caches and let the plugin
-        recompose when it next comes round.
-
-        Returns:
-            True if any plugin's cached content was dropped.
-        """
-        try:
-            return bool(self.stream_manager.invalidate_pending_updates())
-        except Exception:  # pylint: disable=broad-except
-            logger.exception("Failed to refresh updated plugins")
-            return False
-
     def hot_swap_content(self) -> bool:
         """
         Hot-swap to new composed content.

src/vegas_mode/stream_manager.py

@@ -201,47 +201,6 @@ class StreamManager:
 
         logger.debug("Plugin %s marked for update", plugin_id)
 
-    def invalidate_pending_updates(self) -> List[str]:
-        """
-        Drop cached content for plugins whose data changed, without refetching.
-
-        The continuous-scroll counterpart to :meth:`process_updates`. That method
-        belongs to the swap path: it refetches immediately and merges into the
-        active buffer, which continuous mode bypasses entirely, and doing that
-        work on the render thread would hitch the scroll.
-
-        Here it is enough to clear the caches and let the plugin come round in
-        the rotation, which recomposes it from current data a moment later. Left
-        uncalled, ``_pending_updates`` simply accumulates and no visual ever
-        refreshes — a game that was live last night keeps being drawn as live.
-
-        Returns:
-            The plugin ids whose caches were dropped.
-        """
-        with self._buffer_lock:
-            if not self._pending_updates:
-                return []
-            updated = list(self._pending_updates.keys())
-            self._pending_updates.clear()
-
-        plugins = getattr(self.plugin_manager, 'plugins', {})
-        for plugin_id in updated:
-            try:
-                self.plugin_adapter.invalidate_cache(plugin_id)
-                plugin = plugins.get(plugin_id)
-                if plugin is not None:
-                    self.plugin_adapter.invalidate_plugin_scroll_cache(
-                        plugin, plugin_id)
-            except Exception:  # pylint: disable=broad-except
-                logger.exception(
-                    "[%s] Could not invalidate cached content", plugin_id)
-
-        logger.info(
-            "Vegas: dropped cached content for %d updated plugin(s): %s",
-            len(updated), ', '.join(updated)
-        )
-        return updated
-
     def has_pending_updates(self) -> bool:
         """Check if any plugins have pending updates awaiting processing."""
         with self._buffer_lock:
@@ -621,62 +580,6 @@ class StreamManager:
                 grouped.append((segment.plugin_id, list(segment.images)))
         return grouped
 
-    def take_next_group(
-        self, count: Optional[int] = None, offscreen_only: bool = False
-    ) -> List[Tuple[str, Optional[List[Image.Image]]]]:
-        """
-        Fetch and hand over the next slice of the rotation.
-
-        For continuous scrolling, where the strip is extended rather than
-        replaced. Advances the rotation index so plugins come round in order
-        across an unbroken strip, and bypasses the active buffer entirely — that
-        buffer exists to stage a *replacement* cycle, which continuous mode has
-        no use for.
-
-        Args:
-            count: Number of plugins to gather, defaulting to plugins_per_cycle
-            offscreen_only: Only use content paths that avoid the shared display
-                canvas, for use off the render thread
-
-        Returns:
-            Ordered list of (plugin_id, images). ``images`` is None when the
-            plugin could not be served under ``offscreen_only``, so the caller
-            can fetch just those on the render thread while keeping the order.
-        """
-        if count is None:
-            count = self.config.plugins_per_cycle
-
-        self.refresh()
-
-        with self._buffer_lock:
-            if not self._ordered_plugins:
-                return []
-            total = len(self._ordered_plugins)
-            ids = []
-            for _ in range(min(max(1, count), total)):
-                ids.append(self._ordered_plugins[self._prefetch_index])
-                self._prefetch_index = (self._prefetch_index + 1) % total
-
-        plugins = getattr(self.plugin_manager, 'plugins', {})
-        group: List[Tuple[str, Optional[List[Image.Image]]]] = []
-
-        for plugin_id in ids:
-            plugin = plugins.get(plugin_id)
-            if not plugin:
-                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 if images else None))
-
-        return group
-
     def advance_cycle(self) -> None:
         """
         Advance to next cycle by clearing the active buffer.

test/test_scroll_helper_continuous.py

@@ -1,336 +0,0 @@
-"""
-Tests for ScrollHelper's continuous-strip primitives.
-
-append_content extends the strip to the right without disturbing motion, and
-drop_scrolled_prefix reclaims what has already gone past. Together they let a
-caller keep one endless strip instead of swapping a new one in, which is what
-shows as a flash and a hard cut to already-full-screen content.
-"""
-
-import numpy as np
-import pytest
-from PIL import Image
-
-from src.common.scroll_helper import ScrollHelper
-from src.vegas_mode.geometry import column_has_ink
-
-W, H = 128, 32
-
-
-def helper():
-    return ScrollHelper(W, H)
-
-
-def block(width, colour=(255, 255, 255), height=H):
-    return Image.new('RGB', (width, height), colour)
-
-
-class TestAppendContent:
-    def test_first_append_builds_the_strip(self):
-        sh = helper()
-        assert sh.append_content([block(100)], item_gap=0)
-        assert sh.cached_image is not None
-        assert sh.total_scroll_width == sh.cached_image.width
-
-    def test_strip_grows_by_content_plus_gaps(self):
-        sh = helper()
-        sh.create_scrolling_image([block(100)], item_gap=0, element_gap=0, lead_gap=0)
-        assert sh.cached_image.width == 100
-
-        sh.append_content([block(50)], item_gap=10, element_gap=0)
-        # one leading gap of 10 then the 50px block
-        assert sh.cached_image.width == 160
-        assert sh.total_scroll_width == 160
-
-    def test_scroll_position_is_preserved(self):
-        sh = helper()
-        sh.create_scrolling_image([block(400)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 137.0
-        sh.total_distance_scrolled = 137.0
-
-        sh.append_content([block(200)], item_gap=16)
-        assert sh.scroll_position == 137.0
-        assert sh.total_distance_scrolled == 137.0
-
-    def test_appending_defers_completion(self):
-        sh = helper()
-        sh.create_scrolling_image([block(200)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_complete = True
-
-        sh.append_content([block(200)], item_gap=0)
-        assert not sh.scroll_complete
-        assert sh.total_distance_scrolled < sh.total_scroll_width
-
-    def test_existing_pixels_are_untouched(self):
-        sh = helper()
-        original = block(80, (10, 200, 10))
-        sh.create_scrolling_image([original], item_gap=0, element_gap=0, lead_gap=0)
-        before = sh.cached_image.crop((0, 0, 80, H)).tobytes()
-
-        sh.append_content([block(40, (200, 10, 10))], item_gap=8)
-        assert sh.cached_image.crop((0, 0, 80, H)).tobytes() == before
-
-    def test_appended_content_sits_after_the_gap(self):
-        sh = helper()
-        sh.create_scrolling_image([block(50)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.append_content([block(30)], item_gap=12)
-
-        ink = column_has_ink(sh.cached_image)
-        assert ink[:50].all()
-        assert not ink[50:62].any()      # the 12px gap
-        assert ink[62:92].all()
-
-    def test_array_and_image_stay_consistent(self):
-        # get_visible_portion slices cached_array but bounds-checks against
-        # cached_image.width, so a mismatch corrupts frames.
-        sh = helper()
-        sh.create_scrolling_image([block(200)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.append_content([block(100)], item_gap=8)
-        assert sh.cached_array.shape[1] == sh.cached_image.width
-        assert sh.cached_array.shape[0] == sh.cached_image.height
-
-    def test_visible_portion_still_renders_after_append(self):
-        sh = helper()
-        sh.create_scrolling_image([block(300)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.append_content([block(300)], item_gap=8)
-        sh.scroll_position = 250.0
-        frame = sh.get_visible_portion()
-        assert frame is not None and frame.size == (W, H)
-
-    def test_empty_append_is_a_no_op(self):
-        sh = helper()
-        sh.create_scrolling_image([block(100)], item_gap=0, element_gap=0, lead_gap=0)
-        assert sh.append_content([]) is False
-        assert sh.cached_image.width == 100
-
-    def test_repeated_appends_accumulate(self):
-        sh = helper()
-        sh.append_content([block(100)], item_gap=0)
-        for _ in range(5):
-            sh.append_content([block(100)], item_gap=0)
-        assert sh.cached_image.width == 600
-
-
-class TestDropScrolledPrefix:
-    def test_removes_consumed_columns(self):
-        sh = helper()
-        sh.create_scrolling_image([block(1000)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 500.0
-        sh.total_distance_scrolled = 500.0
-
-        removed = sh.drop_scrolled_prefix(keep_before=0)
-        assert removed == 500
-        assert sh.cached_image.width == 500
-        assert sh.scroll_position == 0.0
-
-    def test_keeps_the_requested_margin(self):
-        sh = helper()
-        sh.create_scrolling_image([block(1000)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 500.0
-        sh.drop_scrolled_prefix(keep_before=100)
-        assert sh.scroll_position == 100.0
-        assert sh.cached_image.width == 600
-
-    def test_completion_difference_is_preserved(self):
-        # total_distance_scrolled and total_scroll_width must shift together, or
-        # trimming would spuriously complete or un-complete the cycle.
-        sh = helper()
-        sh.create_scrolling_image([block(1000)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 600.0
-        sh.total_distance_scrolled = 600.0
-        before = sh.total_scroll_width - sh.total_distance_scrolled
-
-        sh.drop_scrolled_prefix(keep_before=0)
-        assert sh.total_scroll_width - sh.total_distance_scrolled == before
-
-    def test_never_trims_below_the_viewport(self):
-        sh = helper()
-        sh.create_scrolling_image([block(200)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 190.0
-        sh.drop_scrolled_prefix(keep_before=0)
-        assert sh.cached_image.width >= W
-
-    def test_no_op_before_anything_has_scrolled(self):
-        sh = helper()
-        sh.create_scrolling_image([block(500)], item_gap=0, element_gap=0, lead_gap=0)
-        assert sh.drop_scrolled_prefix(keep_before=0) == 0
-        assert sh.cached_image.width == 500
-
-    def test_no_op_with_no_strip(self):
-        assert helper().drop_scrolled_prefix() == 0
-
-    def test_visible_frame_is_unchanged_by_trimming(self):
-        # The whole point: trimming is invisible. Same pixels on screen before
-        # and after. Position chosen so the viewport is well clear of the end,
-        # i.e. not wrapping.
-        sh = helper()
-        items = [block(200, (255, 0, 0)), block(200, (0, 255, 0)),
-                 block(200, (0, 0, 255))]
-        sh.create_scrolling_image(items, item_gap=20, element_gap=0, lead_gap=0)
-        sh.scroll_position = 300.0
-        before = sh.get_visible_portion().tobytes()
-
-        assert sh.drop_scrolled_prefix(keep_before=0) > 0, "trim should have run"
-        after = sh.get_visible_portion().tobytes()
-        assert after == before
-
-    def test_refuses_to_trim_while_the_viewport_wraps(self):
-        # Wrapping reads the head of the strip into the right of the frame, so
-        # trimming the head there would visibly change the picture.
-        sh = helper()
-        sh.create_scrolling_image([block(200)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 150.0          # 150 + 128 > 200, so wrapping
-        before = sh.get_visible_portion().tobytes()
-        assert sh.drop_scrolled_prefix(keep_before=0) == 0
-        assert sh.get_visible_portion().tobytes() == before
-
-    def test_array_and_image_stay_consistent_after_trim(self):
-        sh = helper()
-        sh.create_scrolling_image([block(900)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 400.0
-        sh.drop_scrolled_prefix(keep_before=0)
-        assert sh.cached_array.shape[1] == sh.cached_image.width
-
-
-class TestRemainingUnscrolled:
-    def test_counts_content_right_of_the_viewport(self):
-        sh = helper()
-        sh.create_scrolling_image([block(500)], item_gap=0, element_gap=0, lead_gap=0)
-        assert sh.remaining_unscrolled() == 500 - W
-
-    def test_shrinks_as_the_strip_scrolls(self):
-        sh = helper()
-        sh.create_scrolling_image([block(500)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 200.0
-        assert sh.remaining_unscrolled() == 500 - 200 - W
-
-    def test_never_negative(self):
-        sh = helper()
-        sh.create_scrolling_image([block(200)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 500.0
-        assert sh.remaining_unscrolled() == 0
-
-    def test_zero_with_no_strip(self):
-        assert helper().remaining_unscrolled() == 0
-
-    def test_grows_when_content_is_appended(self):
-        sh = helper()
-        sh.create_scrolling_image([block(600)], item_gap=0, element_gap=0, lead_gap=0)
-        sh.scroll_position = 100.0
-        before = sh.remaining_unscrolled()
-        assert before > 0, "fixture should leave content ahead of the viewport"
-        sh.append_content([block(400)], item_gap=0)
-        assert sh.remaining_unscrolled() == before + 400
-
-
-class TestContinuousScrollingEndToEnd:
-    def test_strip_can_be_extended_indefinitely_at_bounded_size(self):
-        """The invariant that makes this viable: extend + trim keeps the strip
-        bounded while motion never stops."""
-        sh = helper()
-        sh.create_scrolling_image([block(600)], item_gap=0, element_gap=0, lead_gap=0)
-
-        widths = []
-        for _ in range(20):
-            sh.scroll_position += 200
-            sh.total_distance_scrolled += 200
-            if sh.remaining_unscrolled() < 2 * W:
-                sh.append_content([block(600)], item_gap=16)
-            sh.drop_scrolled_prefix(keep_before=W)
-            widths.append(sh.cached_image.width)
-            # A frame must always be renderable.
-            assert sh.get_visible_portion() is not None
-
-        assert max(widths) < 3000, f"strip grew unbounded: max {max(widths)}"
-        assert not sh.scroll_complete, "continuous strip should never complete"
-
-
-class TestSubPixelBlending:
-    """
-    Integer positioning quantises motion to whole pixels, so distinct frames per
-    second equals scroll speed regardless of frame rate — at 50px/s and 78fps,
-    36% of frames were identical. Blending between neighbouring positions gives
-    motion at the frame rate instead.
-    """
-
-    def _strip(self, width=2000):
-        rng = np.random.default_rng(0)
-        arr = (rng.random((H, width, 3)) * 255).astype(np.uint8)
-        sh = helper()
-        sh.create_scrolling_image([Image.fromarray(arr)],
-                                  item_gap=0, element_gap=0, lead_gap=0)
-        return sh
-
-    def _frame(self, sh, pos, subpixel):
-        sh.sub_pixel_scrolling = subpixel
-        sh.scroll_position = pos
-        return np.asarray(sh.get_visible_portion()).astype(int)
-
-    def test_integer_mode_ignores_the_fraction(self):
-        sh = self._strip()
-        a = self._frame(sh, 500.0, False)
-        b = self._frame(sh, 500.9, False)
-        assert np.array_equal(a, b), "integer positioning should not move sub-pixel"
-
-    def test_blending_moves_within_a_pixel(self):
-        sh = self._strip()
-        a = self._frame(sh, 500.0, True)
-        b = self._frame(sh, 500.5, True)
-        assert not np.array_equal(a, b)
-
-    def test_zero_fraction_matches_the_integer_frame(self):
-        # No interpolation to do, so it must be pixel-identical and take the
-        # cheap path.
-        sh = self._strip()
-        assert np.array_equal(self._frame(sh, 700.0, True),
-                              self._frame(sh, 700.0, False))
-
-    def test_blend_is_monotonic_between_neighbours(self):
-        # Marching the fraction from 0 to 1 should approach the next integer
-        # frame, not wander.
-        sh = self._strip()
-        target = self._frame(sh, 501.0, False)
-        dists = []
-        for frac in (0.0, 0.25, 0.5, 0.75):
-            f = self._frame(sh, 500.0 + frac, True)
-            dists.append(np.abs(f - target).mean())
-        assert dists == sorted(dists, reverse=True), f"not converging: {dists}"
-
-    def test_blend_endpoints_bracket_the_two_frames(self):
-        sh = self._strip()
-        near = self._frame(sh, 500.0, False)
-        far = self._frame(sh, 501.0, False)
-        mid = self._frame(sh, 500.5, True)
-        # Every blended pixel must lie between its two sources.
-        lo = np.minimum(near, far)
-        hi = np.maximum(near, far)
-        assert (mid >= lo - 1).all() and (mid <= hi + 1).all()
-
-    def test_output_size_and_mode_are_unchanged(self):
-        sh = self._strip()
-        sh.sub_pixel_scrolling = True
-        sh.scroll_position = 300.4
-        frame = sh.get_visible_portion()
-        assert frame.size == (W, H)
-        assert frame.mode == 'RGB'
-
-    def test_works_near_the_end_of_the_strip(self):
-        # One of the two slices wraps here; must not raise or missize.
-        sh = self._strip(width=600)
-        sh.sub_pixel_scrolling = True
-        sh.scroll_position = float(600 - W // 2) + 0.5
-        frame = sh.get_visible_portion()
-        assert frame is not None and frame.size == (W, H)
-
-    def test_works_at_the_very_last_column(self):
-        sh = self._strip(width=600)
-        sh.sub_pixel_scrolling = True
-        sh.scroll_position = 599.5
-        assert sh.get_visible_portion().size == (W, H)
-
-    @pytest.mark.parametrize("frac", [0.01, 0.1, 0.33, 0.5, 0.67, 0.9, 0.99])
-    def test_never_raises_across_the_fraction_range(self, frac):
-        sh = self._strip()
-        sh.sub_pixel_scrolling = True
-        sh.scroll_position = 400.0 + frac
-        assert sh.get_visible_portion().size == (W, H)

test/test_vegas_continuous_refresh.py

@@ -1,227 +0,0 @@
-"""
-Regression tests: changed plugin data must reach the strip in continuous mode.
-
-Two faults combined to freeze Vegas content indefinitely.
-
-PR #291 added a call to ``plugin_adapter.invalidate_plugin_scroll_cache()`` so a
-plugin's *own* cached scroll image would be rebuilt from fresh data. The method
-was never implemented, and ``hot_swap_content()`` wraps the call in a broad
-except, so every hot swap raised AttributeError and was silently swallowed.
-
-Continuous scrolling then removed the only path that reached it at all:
-``should_recompose()``/``hot_swap_content()`` are called from the non-continuous
-branch, while ``continuous_scroll`` defaults to True.
-
-Together, a plugin composed its scroll image once and handed back the same
-picture forever, because the sports plugins' ``get_vegas_content()`` regenerates
-only when its cache is empty. Symptom: a game that was live last night is still
-drawn as live the following morning.
-"""
-
-from types import SimpleNamespace
-from unittest.mock import MagicMock
-
-import numpy as np
-from PIL import Image
-
-from src.vegas_mode.config import VegasModeConfig
-from src.vegas_mode.plugin_adapter import PluginAdapter
-from src.vegas_mode.render_pipeline import RenderPipeline
-from src.vegas_mode.stream_manager import StreamManager
-
-
-class FakeDisplayManager:
-    width = 64
-    height = 32
-
-
-def _helper():
-    """A stand-in ScrollHelper holding both halves of its cache."""
-    image = Image.new('RGB', (128, 32), (10, 20, 30))
-    return SimpleNamespace(cached_image=image, cached_array=np.array(image))
-
-
-class TestInvalidatePluginScrollCache:
-    """The method PR #291 called but never defined."""
-
-    def test_method_exists(self):
-        # It was called for months without existing; the broad except in
-        # hot_swap_content() meant nothing ever surfaced.
-        assert hasattr(PluginAdapter, 'invalidate_plugin_scroll_cache')
-
-    def test_clears_helper_attached_to_the_plugin(self):
-        adapter = PluginAdapter(FakeDisplayManager(), VegasModeConfig())
-        helper = _helper()
-        plugin = SimpleNamespace(scroll_helper=helper)
-
-        assert adapter.invalidate_plugin_scroll_cache(plugin, 'stocks') is True
-        assert helper.cached_image is None
-        assert helper.cached_array is None
-
-    def test_clears_helper_owned_by_a_scroll_manager(self):
-        # The sports scoreboards keep theirs on _scroll_manager, which is the
-        # layout that produced the reported stale-scores bug.
-        adapter = PluginAdapter(FakeDisplayManager(), VegasModeConfig())
-        helper = _helper()
-        plugin = SimpleNamespace(_scroll_manager=SimpleNamespace(scroll_helper=helper))
-
-        assert adapter.invalidate_plugin_scroll_cache(plugin, 'baseball') is True
-        assert helper.cached_image is None
-        assert helper.cached_array is None
-
-    def test_clears_both_halves_together(self):
-        # cached_array is the image's numpy mirror; leaving one behind lets a
-        # reader pick up content the other no longer has.
-        adapter = PluginAdapter(FakeDisplayManager(), VegasModeConfig())
-        helper = _helper()
-        adapter.invalidate_plugin_scroll_cache(
-            SimpleNamespace(scroll_helper=helper), 'news')
-        assert (helper.cached_image, helper.cached_array) == (None, None)
-
-    def test_plugin_without_a_helper_is_not_an_error(self):
-        adapter = PluginAdapter(FakeDisplayManager(), VegasModeConfig())
-        assert adapter.invalidate_plugin_scroll_cache(SimpleNamespace(), 'clock') is False
-
-
-class TestInvalidatePendingUpdates:
-    def _manager(self, plugins):
-        stream = StreamManager(
-            VegasModeConfig(),
-            SimpleNamespace(plugins=plugins),
-            MagicMock(),
-        )
-        stream.plugin_adapter = MagicMock()
-        return stream
-
-    def test_drops_caches_for_updated_plugins(self):
-        helper = _helper()
-        plugin = SimpleNamespace(scroll_helper=helper)
-        stream = self._manager({'baseball': plugin})
-        stream.mark_plugin_updated('baseball')
-
-        assert stream.invalidate_pending_updates() == ['baseball']
-        stream.plugin_adapter.invalidate_cache.assert_called_once_with('baseball')
-        stream.plugin_adapter.invalidate_plugin_scroll_cache.assert_called_once_with(
-            plugin, 'baseball')
-
-    def test_pending_flags_are_consumed(self):
-        # Left unconsumed they accumulate forever and nothing ever refreshes.
-        stream = self._manager({'baseball': SimpleNamespace()})
-        stream.mark_plugin_updated('baseball')
-        assert stream.has_pending_updates() is True
-
-        stream.invalidate_pending_updates()
-        assert stream.has_pending_updates() is False
-        assert stream.invalidate_pending_updates() == []
-
-    def test_no_pending_updates_does_no_work(self):
-        stream = self._manager({})
-        assert stream.invalidate_pending_updates() == []
-        stream.plugin_adapter.invalidate_cache.assert_not_called()
-
-    def test_a_failing_plugin_does_not_stop_the_others(self):
-        stream = self._manager({'a': SimpleNamespace(), 'b': SimpleNamespace()})
-        stream.mark_plugin_updated('a')
-        stream.mark_plugin_updated('b')
-        stream.plugin_adapter.invalidate_cache.side_effect = [
-            RuntimeError('boom'), None]
-
-        assert sorted(stream.invalidate_pending_updates()) == ['a', 'b']
-        assert stream.plugin_adapter.invalidate_cache.call_count == 2
-
-
-class TestContinuousModeReachesTheRefresh:
-    def _pipeline(self):
-        stream = MagicMock()
-        stream.get_buffer_status.return_value = {'staging_count': 0}
-        return RenderPipeline(VegasModeConfig(), FakeDisplayManager(), stream), stream
-
-    def test_refresh_delegates_to_the_stream_manager(self):
-        pipeline, stream = self._pipeline()
-        stream.invalidate_pending_updates.return_value = ['baseball']
-        assert pipeline.refresh_updated_plugins() is True
-
-    def test_refresh_reports_false_when_nothing_changed(self):
-        pipeline, stream = self._pipeline()
-        stream.invalidate_pending_updates.return_value = []
-        assert pipeline.refresh_updated_plugins() is False
-
-    def test_refresh_never_raises_into_the_render_loop(self):
-        pipeline, stream = self._pipeline()
-        stream.invalidate_pending_updates.side_effect = RuntimeError('boom')
-        assert pipeline.refresh_updated_plugins() is False
-
-    def test_refresh_does_not_reposition_the_scroll(self):
-        # The whole point of preferring this over hot_swap_content(): that path
-        # rebuilds and repositions, which reads as a freeze then a jump.
-        pipeline, stream = self._pipeline()
-        stream.invalidate_pending_updates.return_value = ['baseball']
-        pipeline.scroll_helper.scroll_position = 1234
-
-        pipeline.refresh_updated_plugins()
-
-        assert pipeline.scroll_helper.scroll_position == 1234
-        stream.swap_buffers.assert_not_called()
-        stream.process_updates.assert_not_called()
-
-
-class TestCoordinatorWiring:
-    """
-    The regression itself: continuous mode has to *call* the refresh.
-
-    should_recompose()/hot_swap_content() sit in the non-continuous branch, and
-    continuous_scroll defaults to True, so before this fix the refresh was
-    simply never reached on a default install.
-    """
-
-    def _coordinator(self, continuous):
-        import threading
-
-        from src.vegas_mode.coordinator import VegasModeCoordinator
-
-        config = VegasModeConfig()
-        config.continuous_scroll = continuous
-        # Built without __init__ so the test exercises run_frame's branching
-        # without standing up a display, stream and render stack.
-        coordinator = VegasModeCoordinator.__new__(VegasModeCoordinator)
-        coordinator.vegas_config = config
-        coordinator.render_pipeline = MagicMock()
-        coordinator.render_pipeline.has_deferred.return_value = False
-        coordinator.render_pipeline.needs_extension.return_value = False
-        coordinator.render_pipeline.is_cycle_complete.return_value = False
-        coordinator.render_pipeline.should_recompose.return_value = False
-        coordinator.stream_manager = MagicMock()
-        coordinator.stats = {'cycles_completed': 0}
-        coordinator._state_lock = threading.Lock()
-        coordinator._is_active = True
-        coordinator._is_paused = False
-        coordinator._should_stop = False
-        coordinator._pending_config_update = False
-        coordinator._live_priority_check = None
-        coordinator._interrupt_check = None
-        coordinator.sync_manager = None
-        return coordinator
-
-    def test_continuous_mode_refreshes_updated_plugins_every_frame(self):
-        coordinator = self._coordinator(continuous=True)
-        coordinator.run_frame()
-        coordinator.render_pipeline.refresh_updated_plugins.assert_called_once()
-
-    def test_continuous_mode_does_not_use_the_disruptive_swap(self):
-        coordinator = self._coordinator(continuous=True)
-        coordinator.run_frame()
-        coordinator.render_pipeline.hot_swap_content.assert_not_called()
-
-    def test_swap_mode_still_uses_hot_swap(self):
-        # The non-continuous path must keep its original behaviour.
-        coordinator = self._coordinator(continuous=False)
-        coordinator.render_pipeline.should_recompose.return_value = True
-        coordinator.run_frame()
-        coordinator.render_pipeline.hot_swap_content.assert_called_once()
-        coordinator.render_pipeline.refresh_updated_plugins.assert_not_called()
-
-    def test_a_frame_is_still_rendered_either_way(self):
-        for continuous in (True, False):
-            coordinator = self._coordinator(continuous=continuous)
-            coordinator.run_frame()
-            coordinator.render_pipeline.render_frame.assert_called_once()

test/test_vegas_geometry.py

@@ -9,9 +9,6 @@ from src.vegas_mode.geometry import (
     column_has_ink,
     content_bounds,
     dead_window_stats,
-    edge_blank,
-    find_blank_cut,
-    separation_gap,
     trim_to_content,
     window_coverage_stats,
 )
@@ -274,97 +271,3 @@ class TestLongestRunHelper:
     def test_run_lengths(self, flags, expected):
         from src.vegas_mode.geometry import _longest_true_run
         assert _longest_true_run(np.array(flags, dtype=bool)) == expected
-
-
-class TestEdgeBlank:
-    def test_measures_both_edges(self):
-        assert edge_blank(paint(make_img(100), 20, 60)) == (20, 40)
-
-    def test_flush_content_has_no_blank(self):
-        assert edge_blank(paint(make_img(50), 0, 50)) == (0, 0)
-
-    def test_blank_image_reports_full_width_both_sides(self):
-        # No ink means nothing to be close to.
-        assert edge_blank(make_img(64)) == (64, 64)
-
-
-class TestSeparationGap:
-    def test_flush_edges_get_the_full_target(self):
-        a = paint(make_img(50), 0, 50)
-        b = paint(make_img(50), 0, 50)
-        assert separation_gap(a, b, target=24) == 24
-
-    def test_existing_margins_reduce_the_added_gap(self):
-        # 8px blank on each facing edge already covers 16 of the 24 target.
-        a = paint(make_img(50), 0, 42)
-        b = paint(make_img(50), 8, 50)
-        assert separation_gap(a, b, target=24) == 8
-
-    def test_ample_existing_margin_adds_nothing(self):
-        a = paint(make_img(100), 0, 60)
-        b = paint(make_img(100), 40, 100)
-        assert separation_gap(a, b, target=24) == 0
-
-    def test_minimum_is_a_floor(self):
-        a = paint(make_img(100), 0, 60)
-        b = paint(make_img(100), 40, 100)
-        assert separation_gap(a, b, target=24, minimum=4) == 4
-
-    def test_never_negative(self):
-        a = paint(make_img(200), 0, 10)
-        b = paint(make_img(200), 190, 200)
-        assert separation_gap(a, b, target=8) == 0
-
-    def test_sports_card_case_gets_real_separation(self):
-        # The reported problem: cards drawn edge to edge sat 8px apart under a
-        # flat gap; measured separation lifts them to the 24px target.
-        card = paint(make_img(150), 0, 150)
-        assert separation_gap(card, card, target=24, minimum=8) == 24
-
-
-class TestFindBlankCut:
-    def test_snaps_to_the_nearest_gap(self):
-        img = paint(make_img(200), 0, 90)
-        paint(img, 110, 200)
-        # 100 is inside the 90..110 gap already.
-        assert find_blank_cut(img, 100, 20) == 100
-
-    def test_walks_outwards_to_find_a_gap(self):
-        img = paint(make_img(200), 0, 95)
-        paint(img, 105, 200)
-        cut = find_blank_cut(img, 90, 20)
-        assert 95 <= cut < 105
-
-    def test_solid_ink_returns_the_target(self):
-        assert find_blank_cut(paint(make_img(200), 0, 200), 100, 20) == 100
-
-    def test_target_at_image_width_does_not_index_past_the_end(self):
-        # A cut after the last column is legal. Indexing ink[width] raised
-        # IndexError in the field, losing that plugin's content for the cycle.
-        # Reached once the rotation offset advances so start + budget lands
-        # exactly on the image width.
-        img = paint(make_img(1840), 0, 1840)
-        assert find_blank_cut(img, 1840, 32) == 1840
-
-    def test_target_past_image_width_is_clamped(self):
-        img = paint(make_img(100), 0, 100)
-        assert find_blank_cut(img, 500, 32) == 100
-
-    def test_target_at_width_with_a_trailing_gap_snaps_back(self):
-        # Content 0..179, blank 180..199. The nearest blank column to 200 is
-        # 199, not the start of the gap — nearest is what keeps the cut as
-        # close as possible to the requested budget.
-        img = paint(make_img(200), 0, 180)
-        assert find_blank_cut(img, 200, 32) == 199
-
-    def test_zero_radius_returns_the_target(self):
-        assert find_blank_cut(paint(make_img(100), 0, 100), 50, 0) == 50
-
-    def test_negative_target_is_clamped_to_zero(self):
-        assert find_blank_cut(paint(make_img(100), 0, 100), -20, 8) == 0
-
-    @pytest.mark.parametrize("target", [0, 1, 50, 99, 100])
-    def test_never_raises_across_the_range(self, target):
-        img = paint(make_img(100), 0, 100)
-        cut = find_blank_cut(img, target, 16)
-        assert 0 <= cut <= 100

web_interface/blueprints/api_v3.py

@@ -923,10 +923,7 @@ def save_main_config():
                        'vegas_min_plugin_width', 'vegas_lead_in_width', 'vegas_plugins_per_cycle',
                        'vegas_max_plugin_width_ratio', 'vegas_dynamic_duration_enabled',
                        'vegas_min_cycle_duration', 'vegas_max_cycle_duration',
-                       'vegas_intra_plugin_gap', 'vegas_render_width_pct',
-                       'vegas_min_content_separation', 'vegas_min_cut_gap',
-                       'vegas_continuous_scroll', 'vegas_extend_threshold_screens',
-                       'vegas_smooth_scroll', 'vegas_overflow_mode']
+                       'vegas_intra_plugin_gap']
 
         if any(k in data for k in vegas_fields):
             if 'display' not in current_config:
@@ -944,40 +941,9 @@ def save_main_config():
             vegas_config['auto_trim'] = _coerce_to_bool(data.get('vegas_auto_trim'))
             vegas_config['dynamic_duration_enabled'] = _coerce_to_bool(
                 data.get('vegas_dynamic_duration_enabled'))
-            vegas_config['continuous_scroll'] = _coerce_to_bool(
-                data.get('vegas_continuous_scroll'))
-            vegas_config['smooth_scroll'] = _coerce_to_bool(
-                data.get('vegas_smooth_scroll'))
 
             # max_plugin_width_ratio is the one fractional setting, so it is
             # handled outside the integer loop below.
-            if data.get('vegas_overflow_mode') not in ('', None):
-                mode = str(data['vegas_overflow_mode']).strip().lower()
-                if mode not in ('rotate', 'truncate'):
-                    return jsonify({
-                        'status': 'error',
-                        'message': "Invalid value for vegas_overflow_mode: "
-                                   "must be 'rotate' or 'truncate'"
-                    }), 400
-                vegas_config['overflow_mode'] = mode
-
-            if data.get('vegas_extend_threshold_screens') not in ('', None):
-                try:
-                    screens = float(data['vegas_extend_threshold_screens'])
-                except (ValueError, TypeError):
-                    return jsonify({
-                        'status': 'error',
-                        'message': "Invalid value for vegas_extend_threshold_screens: "
-                                   "must be a number"
-                    }), 400
-                if not (1.0 <= screens <= 10.0):
-                    return jsonify({
-                        'status': 'error',
-                        'message': "Invalid value for vegas_extend_threshold_screens: "
-                                   "must be between 1.0 and 10.0"
-                    }), 400
-                vegas_config['extend_threshold_screens'] = screens
-
             if data.get('vegas_max_plugin_width_ratio') not in ('', None):
                 try:
                     ratio = float(data['vegas_max_plugin_width_ratio'])
@@ -1008,9 +974,6 @@ def save_main_config():
                 'vegas_scroll_speed': ('scroll_speed', 1, 200),
                 'vegas_separator_width': ('separator_width', 0, 128),
                 'vegas_intra_plugin_gap': ('intra_plugin_gap', 0, 128),
-                'vegas_render_width_pct': ('render_width_pct', 10, 100),
-                'vegas_min_content_separation': ('min_content_separation', 0, 256),
-                'vegas_min_cut_gap': ('min_cut_gap', 1, 128),
                 'vegas_target_fps': ('target_fps', 30, 200),
                 'vegas_buffer_ahead': ('buffer_ahead', 1, 5),
                 'vegas_trim_threshold': ('trim_threshold', 0, 254),

web_interface/templates/v3/partials/display.html

@@ -438,7 +438,7 @@
 
                 <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
                     <div class="form-group" id="setting-display-vegas_intra_plugin_gap" data-setting-key="display.vegas_scroll.intra_plugin_gap">
-                        <label for="vegas_intra_plugin_gap" class="block text-sm font-medium text-gray-700">Row Gap (pixels){{ ui.help_tip('Extra gap always added between rows contributed by the same plugin (0–128 px).\nDefault: 8. This is a floor on top of Row Separation below, which does most of the work. Set both to 0 to butt rows directly together.', 'Row Gap') }}</label>
+                        <label for="vegas_intra_plugin_gap" class="block text-sm font-medium text-gray-700">Row Gap (pixels){{ ui.help_tip('Gap between rows contributed by the same plugin (0–128 px).\nDefault: 8. Multi-row plugins such as sports scoreboards, news feeds and the F1 standings return one image per row; this keeps those rows close together while Separator Width still marks the jump to the next plugin. Set 0 to butt rows directly together.', 'Row Gap') }}</label>
                         <input type="number"
                                id="vegas_intra_plugin_gap"
                                name="vegas_intra_plugin_gap"
@@ -447,31 +447,6 @@
                                max="128"
                                class="form-control">
                     </div>
-
-                    <div class="form-group" id="setting-display-vegas_min_content_separation" data-setting-key="display.vegas_scroll.min_content_separation">
-                        <label for="vegas_min_content_separation" class="block text-sm font-medium text-gray-700">Row Separation (pixels){{ ui.help_tip('Blank space guaranteed between rows of the same plugin, measured from the actual content rather than added blindly (0–256 px).\nDefault: 24. Rows already carrying wide margins get nothing added; rows drawn right up to their own edges — sports score cards, for instance — get the full amount, so they no longer look like they are touching. Raise it if items still feel cramped.', 'Row Separation') }}</label>
-                        <input type="number"
-                               id="vegas_min_content_separation"
-                               name="vegas_min_content_separation"
-                               value="{{ main_config.display.get('vegas_scroll', {}).get('min_content_separation', 24) }}"
-                               min="0"
-                               max="256"
-                               class="form-control">
-                    </div>
-                </div>
-
-                <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
-                    <div class="form-group" id="setting-display-vegas_render_width_pct" data-setting-key="display.vegas_scroll.render_width_pct">
-                        <label for="vegas_render_width_pct" class="block text-sm font-medium text-gray-700">Plugin Render Width (%){{ ui.help_tip('How much of the screen width each plugin is told it has while drawing for the ticker (10–100%).\nDefault: 100 (unchanged). Lowering it makes plugins choose a tighter layout rather than being cropped — a weather forecast becomes narrow cards instead of five columns spread across the panel. Useful on wide displays. Override per plugin with the vegas_width_pct setting in that plugin\'s own configuration.', 'Plugin Render Width') }}</label>
-                        <input type="number"
-                               id="vegas_render_width_pct"
-                               name="vegas_render_width_pct"
-                               value="{{ main_config.display.get('vegas_scroll', {}).get('render_width_pct', 100) }}"
-                               min="10"
-                               max="100"
-                               step="5"
-                               class="form-control">
-                    </div>
                 </div>
 
                 <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
@@ -499,42 +474,6 @@
                     <h4 class="text-sm font-medium text-gray-900 mb-3">Cycle Pacing</h4>
                     <p class="text-sm text-gray-600 mb-3">How long one pass through the ticker lasts, and how many plugins it covers.</p>
 
-                    <div class="form-group mb-4" id="setting-display-vegas_continuous_scroll" data-setting-key="display.vegas_scroll.continuous_scroll">
-                        <label class="flex items-center">
-                            <input type="checkbox"
-                                   id="vegas_continuous_scroll"
-                                   name="vegas_continuous_scroll"
-                                   {% if main_config.display.get('vegas_scroll', {}).get('continuous_scroll', True) %}checked{% endif %}
-                                   class="form-checkbox">
-                            <span class="ml-2 text-sm text-gray-700">Scroll continuously between groups{{ ui.help_tip('Keep one endless strip, extending it with the next group of plugins as the scroll approaches the end, so they simply arrive from the right. Default: on.\nWith this off the ticker builds a fresh strip and swaps it in, which stops the motion, replaces everything at once and restarts with the screen already full — a freeze, a flash and a jump.', 'Continuous Scroll') }}</span>
-                        </label>
-                    </div>
-
-                    <div class="form-group mb-4" id="setting-display-vegas_smooth_scroll" data-setting-key="display.vegas_scroll.smooth_scroll">
-                        <label class="flex items-center">
-                            <input type="checkbox"
-                                   id="vegas_smooth_scroll"
-                                   name="vegas_smooth_scroll"
-                                   {% if main_config.display.get('vegas_scroll', {}).get('smooth_scroll', True) %}checked{% endif %}
-                                   class="form-checkbox">
-                            <span class="ml-2 text-sm text-gray-700">Smooth sub-pixel motion{{ ui.help_tip('Blend between neighbouring pixel positions so the ticker moves once per rendered frame instead of once per pixel. Default: on.\nWithout it, motion happens only as often as the scroll speed in pixels per second — at 50 px/s that is 50 steps a second however fast the display renders, which reads as a slight judder. The trade is that text softens very slightly horizontally, since each frame blends two positions. Turn it off if you prefer maximum crispness.', 'Smooth Scrolling') }}</span>
-                        </label>
-                    </div>
-
-                    <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mb-4">
-                        <div class="form-group" id="setting-display-vegas_extend_threshold_screens" data-setting-key="display.vegas_scroll.extend_threshold_screens">
-                            <label for="vegas_extend_threshold_screens" class="block text-sm font-medium text-gray-700">Extend When (screens left){{ ui.help_tip('How much unscrolled content triggers loading the next group, measured in screen widths (1.0–10.0).\nDefault: 2. Higher loads earlier and leaves more slack, at the cost of holding more content in memory. Only applies when Continuous Scroll is on.', 'Extend Threshold') }}</label>
-                            <input type="number"
-                                   id="vegas_extend_threshold_screens"
-                                   name="vegas_extend_threshold_screens"
-                                   value="{{ main_config.display.get('vegas_scroll', {}).get('extend_threshold_screens', 2.0) }}"
-                                   min="1"
-                                   max="10"
-                                   step="0.5"
-                                   class="form-control">
-                        </div>
-                    </div>
-
                     <div class="grid grid-cols-1 md:grid-cols-2 gap-4">
                         <div class="form-group" id="setting-display-vegas_plugins_per_cycle" data-setting-key="display.vegas_scroll.plugins_per_cycle">
                             <label for="vegas_plugins_per_cycle" class="block text-sm font-medium text-gray-700">Plugins Per Cycle{{ ui.help_tip('How many plugins are composed into one pass of the ticker (1–50).\nDefault: 6. Higher means more variety before the ticker restarts, and fewer recompose pauses. Lower means each plugin comes around sooner.', 'Plugins Per Cycle') }}</label>
@@ -547,14 +486,6 @@
                                    class="form-control">
                         </div>
 
-                        <div class="form-group" id="setting-display-vegas_overflow_mode" data-setting-key="display.vegas_scroll.overflow_mode">
-                            <label for="vegas_overflow_mode" class="block text-sm font-medium text-gray-700">When A Plugin Is Too Wide{{ ui.help_tip('What to do when a plugin has more content than its width allowance.\nRotate through it: show a different slice each time round, so everything is seen eventually. Right for interchangeable items like news headlines, odds or stock prices.\nShow the start only: always display from the beginning and drop the rest. Right for ordered content — a league table that shows ranks 1-6 and then resumes at 7 two rotations later reads as out of order.\nDefault: rotate. Override for one plugin with vegas_overflow in its own settings.', 'Overflow Handling') }}</label>
-                            <select id="vegas_overflow_mode" name="vegas_overflow_mode" class="form-control">
-                                <option value="rotate" {% if main_config.display.get('vegas_scroll', {}).get('overflow_mode', 'rotate') == 'rotate' %}selected{% endif %}>Rotate through it (default)</option>
-                                <option value="truncate" {% if main_config.display.get('vegas_scroll', {}).get('overflow_mode', 'rotate') == 'truncate' %}selected{% endif %}>Show the start only</option>
-                            </select>
-                        </div>
-
                         <div class="form-group" id="setting-display-vegas_max_plugin_width_ratio" data-setting-key="display.vegas_scroll.max_plugin_width_ratio">
                             <label for="vegas_max_plugin_width_ratio" class="block text-sm font-medium text-gray-700">Max Plugin Width (screens){{ ui.help_tip('Caps how much of one cycle a single plugin may occupy, measured in screen widths (0–20).\nDefault: 3. A long ticker such as a news feed or leaderboard is trimmed to this and the remainder shown on later cycles, so one plugin cannot hold the display for minutes. Set 0 for no limit.', 'Max Plugin Width') }}</label>
                             <input type="number"
@@ -667,19 +598,6 @@
                                    class="form-control">
                         </div>
                     </div>
-
-                    <div class="grid grid-cols-1 md:grid-cols-2 gap-4 mt-4">
-                        <div class="form-group" id="setting-display-vegas_min_cut_gap" data-setting-key="display.vegas_scroll.min_cut_gap">
-                            <label for="vegas_min_cut_gap" class="block text-sm font-medium text-gray-700">Min Cut Gap (pixels){{ ui.help_tip('When a plugin is too wide for its share of a cycle and has to be narrowed, the cut is only made where there is at least this much blank space (1–128 px).\nDefault: 6. The gaps between letters are about 1px wide, so a smaller value lets a cut land inside a word and orphan its last letter into the next cycle. Raise it if cuts still land awkwardly. Continuous images such as maps have no gaps and are cut to fit regardless.', 'Min Cut Gap') }}</label>
-                            <input type="number"
-                                   id="vegas_min_cut_gap"
-                                   name="vegas_min_cut_gap"
-                                   value="{{ main_config.display.get('vegas_scroll', {}).get('min_cut_gap', 6) }}"
-                                   min="1"
-                                   max="128"
-                                   class="form-control">
-                        </div>
-                    </div>
                 </div>
 
                 <!-- Plugin Order Section -->