fix(store): serialize concurrent updates per plugin, check cleanup results

CodeRabbit review on #405 flagged two things in
_reinstall_with_rollback, both verified against current code:

- Real race: the web UI runs Flask with threaded=True and there's a
  single update route, so two overlapping requests for the same
  plugin_id (double-click, two tabs) can interleave. The loser could
  rename the winner's in-progress install aside mid-download, deleting
  its own rollback safety net — worse than the bug this function
  exists to fix. Added a lazy per-plugin_id lock dict (mirrors the
  plugin_manager per-plugin lock pattern) held for the whole function.
- _safe_remove_directory's return value was ignored at both call
  sites. Stale-aside cleanup failure now aborts cleanly instead of
  falling through to a rename that would fail anyway with a less
  useful error; post-success backup-removal failure now logs instead
  of failing silently (still returns True — the update itself
  succeeded, and the next update self-heals the leftover aside).

Left the third nitpick (test_stale_aside_from_previous_crash_is_cleared)
addressed by asserting the stale dir is actually gone and that
install_plugin was reached, rather than just the end-to-end result.

Added a concurrency regression test asserting install_plugin never
runs for the same plugin_id while another call is in flight.

bandit.yaml

@@ -1,29 +0,0 @@
-# bandit.yaml — LEDMatrix bandit configuration
-# https://bandit.readthedocs.io/en/latest/config.html
-#
-# Skips are justified by the specific codebase context documented below.
-# Do not remove skips without updating the justification comment.
-
-skips:
-  # B104: Binding to all interfaces (0.0.0.0)
-  # Intentional — the Flask server binds 0.0.0.0 for LAN access on a Raspberry Pi.
-  # This is not internet-facing and is documented in web_interface/app.py.
-  - B104
-
-  # B603: subprocess call without shell=True
-  # All subprocess.run() calls in this codebase use list arguments (confirmed by
-  # grep — zero uses of shell=True in src/ or web_interface/). List args prevent
-  # shell injection. See src/common/permission_utils.py for the primary usage.
-  - B603
-
-  # B607: Starting a process with a partial executable path
-  # The subprocess calls invoke system utilities (systemctl, sudo, git) by name.
-  # These are fixed-list invocations, not user-controlled, and rely on PATH.
-  - B607
-
-exclude_dirs:
-  - tests
-  - test
-  - venv
-  - .venv
-  - rpi-rgb-led-matrix-master

config/config.template.json

@@ -121,7 +121,6 @@
             "axis": "horizontal"
         },
         "display_durations": {},
-        "plugin_rotation_order": [],
         "use_short_date_format": true,
         "vegas_scroll": {
             "enabled": false,

docs/ADAPTIVE_LAYOUT.md

@@ -1,234 +0,0 @@
-# Adaptive Layout & Font Scaling
-
-`src/adaptive_layout.py` lets a plugin render legibly on **any** panel size
-(64x32, 128x32, 96x48, 128x64, 256x64, ...) without hand-tuned per-display
-layouts. It is **opt-in**: nothing changes for plugins that don't use it.
-
-It generalizes three patterns proven in the plugin ecosystem:
-
-| Pattern | Origin | Core API |
-|---|---|---|
-| Geometry scale factor vs. a design size | f1-scoreboard | `ctx.px(base)` / `ctx.scale` |
-| Breakpoint tiers | masters-tournament | `ctx.tier` / `ctx.by_tier({...})` |
-| "Largest crisp font that fits" ladder | baseball-scoreboard | `ctx.fit_text(...)` and friends |
-
-## Quick start
-
-Every `BasePlugin` has a lazy `self.layout` (a `LayoutContext` for the
-current logical display size, rebuilt automatically if the size changes)
-and a one-liner `self.draw_fit(...)`:
-
-```python
-def display(self, force_clear=False):
-    from src.adaptive_layout import LADDER_ARCADE
-
-    b = self.layout.bounds.inset(1)          # Region(0,0,W,H) minus 1px margin
-    rows = b.split_v(3, 1, 1, gap=1)          # 3/5 for time, 1/5 each for the rest
-
-    self.draw_fit(self.time_str, rows[0], ladder=LADDER_ARCADE)
-    self.draw_fit(self.weekday, rows[1])      # default LADDER_GRID
-    self.draw_fit(self.date_str, rows[2])
-    self.display_manager.update_display()
-```
-
-On 128x64 the time renders at press_start 24px; on 64x32 it steps down to
-8px. The rows partition the height, so bands can never overlap — no more
-`y = height - 7` magic numbers.
-
-## Region — rect algebra
-
-`Region(x, y, w, h)` is a frozen dataclass. All carving clamps to
-non-negative dimensions, so degenerate panels behave.
-
-- Carving: `inset(dx, dy)`, `top_band(h)`, `bottom_band(h)`,
-  `middle(top_h, bottom_h)`, `left_col(w)`, `right_col(w)`,
-  `split_h(*weights, gap=0)`, `split_v(*weights, gap=0)`
-- Placement: `align_xy(w, h, align, valign)`, `center_xy(w, h)`,
-  `contains(w, h)`, `.center`, `.right`, `.bottom`
-
-Scoreboard-style layout:
-
-```python
-b = self.layout.bounds
-status = b.top_band(self.layout.px(7))
-detail = b.bottom_band(self.layout.px(7))
-score_area = b.middle(status.h, detail.h)
-away_slot, home_slot = b.left_col(b.h), b.right_col(b.h)
-```
-
-## Font ladders — discrete, never fractional
-
-Pixel fonts (BDF, PressStart2P) only look right at native/integer sizes, so
-fonts are never scaled continuously. A `FontLadder` is an ordered tuple of
-`FontStep(family, size_px)` rungs, largest first; fitting walks down until
-the measured text fits.
-
-- `LADDER_GRID` (default): X11 BDFs at native sizes — 10x20 → 9x18 → 9x15 →
-  8x13 → 7x13 → 6x13 → 6x12 → 6x10 → 6x9 → 5x8 → 5x7 → 4x6 → tom-thumb.
-  Body text, labels, multi-row content.
-- `LADDER_ARCADE`: PressStart2P at 32/24/16/8 (integer multiples of its 8px
-  grid). Headline text: clocks, scores.
-
-Custom ladders are just tuples — e.g. to add your plugin's registered font
-on top: `(FontStep("myplugin::digits", 16),) + LADDER_GRID`.
-
-## LayoutContext
-
-Built per (width, height); exposes facts and fit queries:
-
-- `bounds`, `width`, `height`, `aspect`
-- `tier` by height (`xs`≤16, `sm`≤32, `md`≤48, `lg`≤64, `xl`) and
-  `width_tier` (`narrow`≤64, `normal`≤128, `wide`≤256, `ultrawide`)
-- `is_wide_short` — aspect ≥ 2.5 and height ≤ 32 (the classic 128x32 shape)
-- `scale` — `min(w/design_w, h/design_h)` vs. your manifest's
-  `display.design_size` (default 128x32). **Geometry only** — gaps, icon
-  and logo sizes via `px(base, minimum, maximum)`; fonts use ladders.
-- `by_tier({"sm": 10, "lg": 18})` — value for the nearest defined tier
-  at-or-below the panel's tier.
-- `fit_text(text, box, ladder, ellipsis=True)` → `FitResult` — largest rung
-  that fits; ellipsizes as a last resort. Cached per (text, box, ladder).
-- `fit_text_proportional(text, box, base_size_px, ladder, ellipsis=True, scale=None)` —
-  rung closest to (not exceeding) `base_size_px * scale`, still capped to
-  what fits the box. Use this instead of `fit_text` when several
-  independently-fitted elements need to stay visually harmonious as the
-  panel grows — `fit_text` maximizes *each one* within its own region,
-  which can make one element (e.g. a score with a generous box) balloon
-  out of proportion to a neighbor that scales by geometry (e.g. logos
-  sized via `px()`), even though each individual pick is "correct" in
-  isolation. `base_size_px` is normally the element's existing classic/
-  fixed font size. `scale` defaults to `self.scale` (the conservative
-  min-of-both-axes factor `px()` uses); pass an axis-specific value when
-  the surrounding composition already scales that way — e.g. a scoreboard
-  whose logo slots track height alone (`min(height, width // 2)`) should
-  size its text by `height / design_height` too, or the text reads as
-  under-scaled next to bigger logos on a panel that only grew taller.
-- `fit_lines(lines, box, ladder, spacing)` — every line fits the width and
-  the stack fits the height (measures the actual strings).
-- `font_for_rows(rows, box_h, ladder)` — largest rung whose line height
-  fits `rows` rows.
-
-`FitResult` carries the ready-to-use `font` (drops straight into
-`display_manager.draw_text(font=...)`), the possibly-ellipsized `text`,
-ink `width`/`height`, `baseline`, `y_offset`, `line_height`, and `fits`.
-
-## Adaptive images
-
-`src/adaptive_images.py` is the image counterpart to `fit_text`, exposed as
-`self.layout.fit_image(...)` (cached per panel size) and the one-liner
-`self.draw_image(...)`:
-
-```python
-# Team logo: trim its transparent padding, fill the slot height (the
-# football/hockey pattern), cached across frames by a stable key
-self.draw_image(logo, regs.away_slot, mode="fill_height",
-                crop_to_ink=True, cache_key=f"logo:{abbr}")
-
-# Album art: cover-crop a square, faces kept by the top anchor
-self.draw_image(art, row.art, mode="cover", anchor="top")
-
-# Pixel flags / sprite icons: NEAREST keeps hard edges
-from src.adaptive_images import RESAMPLE_NEAREST
-self.draw_image(flag, box, resample=RESAMPLE_NEAREST)
-```
-
-Modes: `contain` (letterbox, default), `cover` (crop-to-fill),
-`fill_height` (logo-style), `stretch`. Unlike PIL's `thumbnail()`
-(downscale-only — why imagery stays tiny on big panels) fitting **upscales
-by default**; pass `upscale=False` for the legacy behavior. Results are
-cached per (image, box size, options) with a bounded LRU — always pass a
-stable `cache_key` (e.g. `"logo:KC"`) for images you reload. The module
-also exports the Pillow-compat `RESAMPLE_LANCZOS`/`RESAMPLE_NEAREST`
-constants so plugins can drop their local shims.
-
-## Composite layouts
-
-Pre-carved Region arrangements for the layouts plugins keep rebuilding:
-
-```python
-from src.adaptive_layout import scoreboard_regions, media_row
-
-regs = scoreboard_regions(self.layout.bounds, ctx=self.layout)
-# regs.away_slot / home_slot   — logo slots (logo_slot = min(H, W // 2),
-#                                 capped so a center reserve always exists —
-#                                 see below)
-# regs.status_band             — top band (replaces the magic y = 1)
-# regs.score_area              — center gap, plus a controlled bleed into
-#                                 each logo slot (replaces y = H//2 - 3)
-# regs.detail_band             — bottom band (replaces y = H - 7)
-# regs.bottom_left / bottom_right — record/timeout corners
-
-row = media_row(self.layout.bounds, ctx=self.layout)   # art left, text right
-```
-
-Both work on the full panel or on a scroll-mode card Region. They return
-Regions and never draw — compose them with `draw_fit`/`draw_image`.
-
-**`scoreboard_regions`'s center reserve.** The raw `logo_slot = min(H, W//2)`
-formula has a blind spot: at exactly 2:1 aspect ratio (width = 2×height —
-two, four, or more square modules stacked into a taller panel, e.g.
-96x48, 128x64, 256x128) the two logo slots mathematically claim the
-*entire* width, leaving zero pixels for a center column no matter how
-big the panel gets. Wide panels (the 128x32 design baseline, 192x48,
-256x32) never hit this, since height is already the tighter constraint
-there. Two parameters fix it without any plugin-side code:
-`min_center_fraction`/`min_center_design_px` guarantee a real minimum
-center reserve at any aspect ratio, and `score_bleed_fraction` lets the
-score's *fit box* extend a controlled amount into each logo slot — the
-same way a real broadcast scoreboard's numbers cross slightly into the
-team marks flanking them — so a short score string never has to truncate
-even on the tightest aspect ratios. All three have sane defaults; override
-them per call if a plugin's card proportions genuinely differ.
-
-## Preserving user customization
-
-Adaptive layout supplies *defaults*; explicit user configuration wins:
-
-- **User-set fonts win.** If the plugin's config has an explicit
-  `font`/`font_size` for an element, load it as before and skip the ladder —
-  fit only when the user hasn't overridden (see the football-scoreboard
-  `_resolve_element_fit` pattern).
-- **Offsets apply on top.** `customization.layout.<element>.{x_offset,y_offset}`
-  style knobs translate the *computed* region as a final step:
-  `region.offset(user_dx, user_dy)`. `draw_image(..., offset=(dx, dy))`
-  does the same for images.
-- **Colors pass through.** `draw_fit`/`draw_fitted_text` take explicit
-  `color=` params; adaptive mode never repaints semantic or user-chosen
-  colors.
-
-## Manifest declaration
-
-Declare the size your layout was authored against so `ctx.scale` means
-something:
-
-```json
-"display": { "design_size": { "width": 128, "height": 32 } }
-```
-
-Also available under `requires.display_size`: `min_width`, `min_height`,
-`max_width`, `max_height`.
-
-## Performance notes (Pi)
-
-Fit queries are cached, so cost is O(unique strings). For per-second text
-(clocks, live scores), fit on a **shape placeholder** and reuse the font:
-
-```python
-fit = self.layout.fit_text("00:00", box, ladder=LADDER_ARCADE)  # cached once
-self.display_manager.draw_text(current_time, font=fit.font, ...)
-```
-
-## Testing across sizes
-
-The harness already renders every plugin at a spread of sizes (now
-including 96x48):
-
-```bash
-python scripts/check_plugin.py <plugin-dir> --sizes 64x32,128x32,96x48,128x64,256x64
-python scripts/render_plugin.py <plugin-dir> --width 96 --height 48
-```
-
-`BoundsCheckingDisplayManager` flags right/bottom overflow and now records
-mediated draw calls with negative coordinates in
-`negative_coordinate_calls` (raw-PIL draws remain uncovered).
-
-Reference migration: the **text-display** plugin's `font_mode: "auto"`.

docs/ADVANCED_PLUGIN_DEVELOPMENT.md

@@ -2,12 +2,6 @@
 
 Advanced patterns, examples, and best practices for developing LEDMatrix plugins.
 
-> **Adaptive layout:** for plugins that should render legibly on any panel
-> size (fonts that grow on big panels, layouts that degrade gracefully on
-> small ones), use the adaptive layout system — `self.layout`, `draw_fit`,
-> `draw_image`, `scoreboard_regions` — documented in
-> [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md).
-
 ## Table of Contents
 
 - [Using Weather Icons](#using-weather-icons)

docs/DEVELOPER_QUICK_REFERENCE.md

@@ -48,12 +48,6 @@ display_manager.draw_text("Centered", centered=True)  # Auto-center
 width = display_manager.get_text_width("Text", font)
 height = display_manager.get_font_height(font)
 
-# Adaptive layout (recommended for multi-size support — text and images
-# that scale to any panel; see docs/ADAPTIVE_LAYOUT.md)
-rows = self.layout.bounds.inset(1).split_v(3, 1, gap=1)
-self.draw_fit("12:34", rows[0])                 # largest crisp font that fits
-self.draw_image(logo, rows[1], mode="fill_height", crop_to_ink=True)
-
 # Weather icons
 display_manager.draw_weather_icon("rain", x=10, y=10, size=16)
 

docs/DEV_PREVIEW.md

@@ -6,12 +6,6 @@ Tools for rapid plugin development without deploying to the RPi.
 
 Interactive web UI for tweaking plugin configs and seeing the rendered display in real time.
 
-The size inputs have a preset dropdown with the harness's standard panel
-sizes, and the **All Sizes** button renders the current config at every
-harness size in a side-by-side gallery (`POST /api/render-matrix`) — the
-quickest way to eyeball adaptive-layout behavior across panels
-(see [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md)).
-
 ### Quick Start
 
 ```bash

docs/FONT_MANAGER.md

@@ -1,12 +1,5 @@
 # FontManager Usage Guide
 
-> **Picking a size automatically:** if you want the *largest font that fits
-> a given area* rather than a fixed size, use the adaptive layout system's
-> font ladders, which resolve through this FontManager. `BasePlugin`
-> subclasses get this as `self.layout.fit_text(...)`; other code can build
-> a `LayoutContext(width, height, font_manager)` directly — see
-> [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md).
-
 ## Overview
 
 The enhanced FontManager provides comprehensive font management for the LEDMatrix application with support for:

docs/HOW_TO_RUN_TESTS.md

@@ -248,6 +248,7 @@ test/
 ├── test_config_service.py               # Config service tests
 ├── test_config_validation_edge_cases.py # Config edge cases
 ├── test_font_manager.py                 # Font manager tests
+├── test_layout_manager.py               # Layout manager tests
 ├── test_text_helper.py                  # Text helper tests
 ├── test_error_handling.py               # Error handling tests
 ├── test_error_aggregator.py             # Error aggregation tests

docs/PLUGIN_API_REFERENCE.md

@@ -2,11 +2,6 @@
 
 Complete API reference for plugin developers. This document describes all methods and properties available to plugins through the Display Manager, Cache Manager, and Plugin Manager.
 
-> **Adaptive layout:** every `BasePlugin` also exposes `self.layout`,
-> `self.draw_fit(text, region)` and `self.draw_image(img, region, ...)` —
-> the recommended way to render text and images that scale to any panel
-> size. See [ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md).
-
 ## Table of Contents
 
 - [BasePlugin](#baseplugin)

docs/PLUGIN_DEVELOPMENT_GUIDE.md

@@ -2,14 +2,6 @@
 
 This guide explains how to set up a development workflow for plugins that are maintained in separate Git repositories while still being able to test them within the LEDMatrix project.
 
-> **Rendering guidance:** plugins should read the display size dynamically
-> (`self.display_manager.matrix.width/height`) rather than hardcoding one
-> panel. For plugins that want to *scale* their layout to any panel, the
-> opt-in adaptive layout system ([ADAPTIVE_LAYOUT.md](ADAPTIVE_LAYOUT.md))
-> provides the shared helpers — fonts, images, and composite layouts that
-> scale. Existing plugins keep their classic rendering unless they adopt
-> those APIs; nothing migrates automatically.
-
 ## Overview
 
 When developing plugins in separate repositories, you need a way to:

docs/widget-guide.md

@@ -206,40 +206,6 @@ To use an existing widget in your plugin's `config_schema.json`, simply add the
 
 The widget will be automatically rendered when the plugin configuration form is loaded.
 
-## Marking Fields as Advanced (`x-advanced`)
-
-Add `"x-advanced": true` to any top-level, non-object property to move it out
-of the main form and into a single collapsed **Advanced Settings** section at
-the bottom of the plugin's configuration page:
-
-```json
-{
-  "properties": {
-    "city": {
-      "type": "string",
-      "title": "City"
-    },
-    "request_timeout": {
-      "type": "integer",
-      "default": 10,
-      "description": "HTTP timeout in seconds",
-      "x-advanced": true
-    }
-  }
-}
-```
-
-Guidelines:
-
-- Use it for fine-tuning knobs most users never touch (timeouts, retry
-  behavior, cache TTLs, styling overrides). Anything a first-time user must
-  set to get the plugin working should stay basic.
-- Nothing is hidden permanently — the section expands on click, and the
-  settings search finds and auto-expands advanced fields like any others.
-- The flag is ignored on `object`-type properties (they already render as
-  their own collapsible sections) and is safely ignored by older cores, so
-  adding it never breaks compatibility.
-
 ## Creating Custom Widgets
 
 ### Step 1: Create Widget File

requirements.txt

@@ -8,11 +8,16 @@ numpy>=1.24.0  # For fast array operations in ScrollHelper (compatible with 2.x)
 
 # Timezone handling
 pytz>=2024.2,<2025.0  # Updated for latest timezone data
+timezonefinder>=6.5.0,<7.0.0  # Updated for better performance and accuracy
+geopy>=2.4.1,<3.0.0
 
 # HTTP requests
 requests>=2.33.0,<3.0.0
 
 # Google API integration
+google-auth-oauthlib>=1.2.0,<2.0.0
+google-auth-httplib2>=0.2.0,<1.0.0
+google-api-python-client>=2.147.0,<3.0.0
 
 # Font rendering
 freetype-py>=2.5.1,<3.0.0
@@ -24,8 +29,10 @@ spotipy>=2.25.2,<3.0.0
 Flask>=3.1.3,<4.0.0
 
 # Text processing
+unidecode>=1.3.8,<2.0.0
 
 # Calendar integration
+icalevents>=0.1.27,<1.0.0
 
 # WebSocket support
 python-socketio>=5.14.0,<6.0.0

schema/manifest_schema.json

@@ -90,40 +90,11 @@
             "min_height": {
               "type": "integer",
               "minimum": 1
-            },
-            "max_width": {
-              "type": "integer",
-              "minimum": 1
-            },
-            "max_height": {
-              "type": "integer",
-              "minimum": 1
             }
           }
         }
       }
     },
-    "display": {
-      "type": "object",
-      "properties": {
-        "design_size": {
-          "type": "object",
-          "properties": {
-            "width": {
-              "type": "integer",
-              "minimum": 8
-            },
-            "height": {
-              "type": "integer",
-              "minimum": 8
-            }
-          },
-          "required": ["width", "height"],
-          "description": "Panel size the plugin's layout was authored against; core derives the adaptive-layout scale factor from it. Defaults to 128x32 when omitted."
-        }
-      },
-      "description": "Display/layout hints for the adaptive layout system"
-    },
     "config_schema": {
       "type": "string",
       "description": "Path to configuration schema file"

scripts/audit_plugins.py

@@ -1,344 +0,0 @@
-#!/usr/bin/env python3
-"""
-LEDMatrix Plugin Security Auditor
-
-Performs AST-based security analysis of all Python files in plugin directories.
-Designed to run in CI — exits non-zero on CRITICAL findings only.
-
-Usage:
-    python scripts/audit_plugins.py
-    python scripts/audit_plugins.py --verbose
-    python scripts/audit_plugins.py --plugin hello-world
-    python scripts/audit_plugins.py --output results.json
-"""
-
-import ast
-import argparse
-import json
-import sys
-from dataclasses import dataclass, asdict
-from pathlib import Path
-from datetime import datetime, timezone
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-
-PLUGIN_BASE_DIRS = [
-    PROJECT_ROOT / "plugins",
-    PROJECT_ROOT / "plugin-repos",
-]
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Finding dataclass
-# ─────────────────────────────────────────────────────────────────────────────
-
-@dataclass
-class Finding:
-    plugin_id: str
-    file: str
-    line: int
-    severity: str   # CRITICAL | WARNING | INFO
-    rule: str
-    message: str
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# AST visitor
-# ─────────────────────────────────────────────────────────────────────────────
-
-class _PluginVisitor(ast.NodeVisitor):
-    """Collect security findings from a single plugin Python file."""
-
-    def __init__(self, filepath: Path, plugin_id: str):
-        self.filepath = filepath
-        self.plugin_id = plugin_id
-        self.findings: list[Finding] = []
-        # Local name -> real dotted path, so aliased imports and from-imports
-        # of dangerous APIs (import subprocess as sp; from builtins import
-        # eval as e) are still recognized in visit_Call below.
-        self._aliases: dict[str, str] = {}
-
-    def _add(self, node: ast.AST, severity: str, rule: str, message: str) -> None:
-        self.findings.append(Finding(
-            plugin_id=self.plugin_id,
-            file=str(self.filepath.relative_to(PROJECT_ROOT)),
-            line=getattr(node, "lineno", 0),
-            severity=severity,
-            rule=rule,
-            message=message,
-        ))
-
-    def _resolve(self, local_name: str) -> str:
-        """Resolve a local name through recorded import aliases to its real
-        dotted path (e.g. "sp" -> "subprocess"); unresolved names pass through
-        unchanged."""
-        return self._aliases.get(local_name, local_name)
-
-    def _resolve_call_target(self, func: ast.expr) -> str | None:
-        """Resolve a Call's func node to a fully-qualified dotted target,
-        covering a direct name (bare builtin, aliased import, or
-        from-import: from builtins import eval as e; from subprocess
-        import run; from os import system as s) and module-attribute
-        access (subprocess.run, sp.run, os.system, o.system) uniformly.
-        Returns None for call shapes this doesn't attempt to resolve."""
-        if isinstance(func, ast.Name):
-            return self._resolve(func.id)
-        if isinstance(func, ast.Attribute) and isinstance(func.value, ast.Name):
-            base = self._resolve(func.value.id)
-            return f"{base}.{func.attr}"
-        return None
-
-    def visit_Call(self, node: ast.Call) -> None:
-        target = self._resolve_call_target(node.func)
-        if target is None:
-            self.generic_visit(node)
-            return
-
-        leaf = target.rsplit(".", 1)[-1]
-
-        # eval() / exec() / compile() — arbitrary code execution, whether a
-        # bare call, an aliased import, or a from-import
-        # (from builtins import eval as e; e(...))
-        if leaf == "eval":
-            self._add(node, "CRITICAL", "PLUGIN-001",
-                      "eval() call — arbitrary code execution risk")
-        elif leaf == "exec":
-            self._add(node, "CRITICAL", "PLUGIN-002",
-                      "exec() call — arbitrary code execution risk")
-        elif leaf == "compile":
-            self._add(node, "WARNING", "PLUGIN-003",
-                      "compile() call — dynamic code compilation")
-
-        # subprocess.*(shell=True), whether subprocess.run(...), sp.run(...),
-        # or a from-import (from subprocess import run; run(..., shell=True))
-        if target in {
-            "subprocess.run", "subprocess.call", "subprocess.Popen",
-            "subprocess.check_call", "subprocess.check_output",
-        }:
-            for kw in node.keywords:
-                if (kw.arg == "shell" and
-                        isinstance(kw.value, ast.Constant) and
-                        kw.value.value is True):
-                    self._add(node, "WARNING", "PLUGIN-004",
-                              f"subprocess.{leaf}(shell=True) — "
-                              f"shell injection risk if args include user input")
-
-        # os.system(), whether os.system(...), o.system(...), or a
-        # from-import (from os import system as s; s(...))
-        if target == "os.system":
-            self._add(node, "WARNING", "PLUGIN-005",
-                      "os.system() call — prefer subprocess with list args")
-
-        self.generic_visit(node)
-
-    def visit_Import(self, node: ast.Import) -> None:
-        for alias in node.names:
-            if alias.asname:
-                local, real = alias.asname, alias.name
-            else:
-                # `import os.path` binds the top-level name `os`, not `os.path`
-                local = real = alias.name.split(".")[0]
-            self._aliases[local] = real
-            self._check_import(node, alias.name)
-        self.generic_visit(node)
-
-    def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
-        if node.module:
-            for alias in node.names:
-                local = alias.asname or alias.name
-                self._aliases[local] = f"{node.module}.{alias.name}"
-            self._check_import(node, node.module)
-        self.generic_visit(node)
-
-    def _check_import(self, node: ast.AST, module_name: str) -> None:
-        dangerous = {
-            "ctypes": ("WARNING", "PLUGIN-010", "ctypes import — native code execution"),
-            "cffi": ("WARNING", "PLUGIN-011", "cffi import — native code execution"),
-            "pickle": ("WARNING", "PLUGIN-012",
-                       "pickle import — deserialization can execute arbitrary code"),
-            "marshal": ("WARNING", "PLUGIN-013",
-                        "marshal import — deserialization risk"),
-        }
-        for mod, (severity, rule, msg) in dangerous.items():
-            if module_name == mod or module_name.startswith(mod + "."):
-                self._add(node, severity, rule, msg)
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Per-plugin audit
-# ─────────────────────────────────────────────────────────────────────────────
-
-def audit_plugin(plugin_dir: Path) -> list[Finding]:
-    """Audit a single plugin directory. Returns all findings."""
-    findings: list[Finding] = []
-    plugin_id = plugin_dir.name
-
-    # Check for required files
-    for required_file, rule, msg in [
-        ("manifest.json", "PLUGIN-020",
-         "manifest.json missing — plugin may be incomplete"),
-        ("config_schema.json", "PLUGIN-021",
-         "config_schema.json missing — no input validation schema declared"),
-    ]:
-        if not (plugin_dir / required_file).exists():
-            findings.append(Finding(
-                plugin_id=plugin_id,
-                file=str((plugin_dir / required_file).relative_to(PROJECT_ROOT)),
-                line=0,
-                severity="WARNING",
-                rule=rule,
-                message=msg,
-            ))
-
-    # AST analysis of all Python files
-    for py_file in sorted(plugin_dir.rglob("*.py")):
-        try:
-            source = py_file.read_text(encoding="utf-8")
-            tree = ast.parse(source, filename=str(py_file))
-            visitor = _PluginVisitor(py_file, plugin_id)
-            visitor.visit(tree)
-            findings.extend(visitor.findings)
-        except SyntaxError as exc:
-            # A file the visitor can't even parse is a file we can't verify
-            # is safe -- this must block the audit, not just warn.
-            findings.append(Finding(
-                plugin_id=plugin_id,
-                file=str(py_file.relative_to(PROJECT_ROOT)),
-                line=getattr(exc, "lineno", 0) or 0,
-                severity="CRITICAL",
-                rule="PLUGIN-030",
-                message=f"Python syntax error — cannot be parsed: {exc}",
-            ))
-        except OSError as exc:
-            # Same reasoning as SyntaxError: an unreadable file was never
-            # actually scanned, so it must block rather than pass silently.
-            findings.append(Finding(
-                plugin_id=plugin_id,
-                file=str(py_file.relative_to(PROJECT_ROOT)),
-                line=0,
-                severity="CRITICAL",
-                rule="PLUGIN-031",
-                message=f"Could not read file: {exc}",
-            ))
-
-    return findings
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Main
-# ─────────────────────────────────────────────────────────────────────────────
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="LEDMatrix plugin security auditor",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--plugin", "-p", default=None,
-                        help="Audit a specific plugin ID only")
-    parser.add_argument("--output", "-o", default=None,
-                        help="Write JSON results to this file")
-    parser.add_argument("--verbose", "-v", action="store_true",
-                        help="Show all findings, not just summary")
-    args = parser.parse_args()
-
-    print("=" * 60)
-    print("LEDMatrix Plugin Security Audit")
-    print(f"Project root: {PROJECT_ROOT}")
-    print("=" * 60)
-
-    all_findings: list[Finding] = []
-    plugins_scanned = 0
-    plugin_found = args.plugin is None
-
-    for base_dir in PLUGIN_BASE_DIRS:
-        if not base_dir.exists():
-            if args.verbose:
-                print(f"  ⏭️  Skipping {base_dir.name}/ (directory not found)")
-            continue
-
-        base_label = base_dir.relative_to(PROJECT_ROOT)
-        print(f"\n  Scanning {base_label}/")
-
-        for plugin_dir in sorted(base_dir.iterdir()):
-            if not plugin_dir.is_dir():
-                continue
-            if plugin_dir.name.startswith((".", "_")):
-                continue
-            if args.plugin and plugin_dir.name != args.plugin:
-                continue
-            if args.plugin:
-                plugin_found = True
-
-            findings = audit_plugin(plugin_dir)
-            all_findings.extend(findings)
-            plugins_scanned += 1
-
-            critical = [f for f in findings if f.severity == "CRITICAL"]
-            warnings = [f for f in findings if f.severity == "WARNING"]
-
-            if critical:
-                icon, label = "🚨", "CRITICAL"
-            elif warnings:
-                icon, label = "⚠️ ", "WARN   "
-            else:
-                icon, label = "✅", "PASS   "
-
-            print(f"    {icon} [{label}] {plugin_dir.name}"
-                  f" — {len(critical)} critical, {len(warnings)} warnings")
-
-            if args.verbose:
-                for f in findings:
-                    severity_icon = {"CRITICAL": "🚨", "WARNING": "⚠️ ", "INFO": "ℹ️ "}.get(
-                        f.severity, "  "
-                    )
-                    print(f"           {severity_icon} {f.rule} {f.file}:{f.line} — {f.message}")
-
-    if args.plugin and not plugin_found:
-        print(f"\n  🚨 Plugin '{args.plugin}' not found in any of "
-              f"{[str(d.relative_to(PROJECT_ROOT)) for d in PLUGIN_BASE_DIRS]} — "
-              f"nothing was audited")
-        return 1
-
-    # Summary
-    critical_findings = [f for f in all_findings if f.severity == "CRITICAL"]
-    warning_findings = [f for f in all_findings if f.severity == "WARNING"]
-
-    print(f"\n{'=' * 60}")
-    print(f"  Plugins scanned : {plugins_scanned}")
-    print(f"  CRITICAL        : {len(critical_findings)}")
-    print(f"  WARNING         : {len(warning_findings)}")
-
-    if critical_findings:
-        print("\n  🚨 CRITICAL findings:")
-        for f in critical_findings:
-            print(f"    {f.plugin_id} | {Path(f.file).name}:{f.line} | {f.message}")
-
-    # Write JSON output
-    if args.output:
-        output_data = {
-            "timestamp": datetime.now(timezone.utc).isoformat(),
-            "plugins_scanned": plugins_scanned,
-            "summary": {
-                "critical": len(critical_findings),
-                "warnings": len(warning_findings),
-            },
-            "findings": [f.to_dict() for f in all_findings],
-        }
-        Path(args.output).write_text(
-            json.dumps(output_data, indent=2), encoding="utf-8"
-        )
-        print(f"\n  Results written to: {args.output}")
-
-    if critical_findings:
-        print("\n  🚨 Blocking — CRITICAL issues must be resolved")
-        return 1
-
-    print("\n  ✅ No critical issues found")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/check_plugin.py

@@ -37,11 +37,10 @@ os.environ['EMULATOR'] = 'true'
 
 from src.logging_config import get_logger  # noqa: E402
 from src.plugin_system.testing.loading import (  # noqa: E402
-    build_full_config, find_plugin_dir, load_harness_spec, load_manifest,
+    find_plugin_dir, load_config_defaults, load_harness_spec,
 )
 from src.plugin_system.testing.harness import (  # noqa: E402
     RenderResult, render_plugin_matrix, compare_to_goldens, write_goldens,
-    check_scale_up,
 )
 from src.plugin_system.testing.sizes import (  # noqa: E402
     parse_size_token, resolve_test_sizes, safe_mode_filename, size_label,
@@ -97,11 +96,12 @@ def check_one(plugin_id: str, search_dirs: List[str], sizes, mock_data: Dict,
     # matrix path does; explicit CLI flags still override the file.
     spec = load_harness_spec(plugin_dir)
 
-    # config_schema defaults (real-install behavior, with enabled forced True
-    # so a plugin's own enabled:false default can't accidentally disable
-    # testing), then harness.json config, then CLI --config — most specific
-    # wins.
-    full_config = build_full_config(plugin_dir, spec, config)
+    # config_schema defaults (real-install behavior), then harness.json config,
+    # then CLI --config — most specific wins.
+    full_config = {"enabled": True}
+    full_config.update(load_config_defaults(plugin_dir))
+    full_config.update(spec.get("config", {}))
+    full_config.update(config)
 
     # Precedence: CLI flag > LEDMATRIX_TEST_SIZES env > harness.json > default.
     effective_sizes = sizes if sizes else resolve_test_sizes(spec.get("sizes"))
@@ -110,55 +110,28 @@ def check_one(plugin_id: str, search_dirs: List[str], sizes, mock_data: Dict,
     effective_freeze = freeze_time or spec.get("freeze_time")
     effective_run_update = run_update and not spec.get("skip_update", False)
 
-    # The plugin's declared design size drives the scale-up fill check
-    # (panels >= 2x the design size must not be left mostly empty).
-    declared = load_manifest(plugin_dir).get("display", {}).get("design_size", {})
-    design_size = (int(declared.get("width", 128)), int(declared.get("height", 32)))
-    fill_strict = spec.get("fill_check") == "strict"
+    results = render_plugin_matrix(
+        plugin_id=plugin_id, plugin_dir=plugin_dir, config=full_config,
+        mock_data=effective_mock_data, sizes=effective_sizes,
+        run_update=effective_run_update, freeze_time=effective_freeze,
+    )
 
-    # Every run: the base config, plus one per harness.json "variant" —
-    # a config overlay with its own golden dir (e.g. adaptive layout mode
-    # tested alongside the classic default).
-    runs = [(None, {}, golden_dir_override or (plugin_dir / 'test' / 'golden'))]
-    for variant in spec.get("variants", []):
-        name = variant.get("name") or "variant"
-        vdir = plugin_dir / variant.get("golden_dir", f"test/golden-{name}")
-        runs.append((name, variant.get("config", {}), vdir))
+    golden_dir = golden_dir_override or (plugin_dir / 'test' / 'golden')
+    if update_golden:
+        written = write_goldens(results, golden_dir)
+        logger.info("Wrote %d golden image(s) for %s to %s", written, plugin_id, golden_dir)
+    else:
+        compare_to_goldens(results, golden_dir)
 
-    all_run_results: List[RenderResult] = []
-    for variant_name, overlay, golden_dir in runs:
-        run_config = {**full_config, **overlay}
-        results = render_plugin_matrix(
-            plugin_id=plugin_id, plugin_dir=plugin_dir, config=run_config,
-            mock_data=effective_mock_data, sizes=effective_sizes,
-            run_update=effective_run_update, freeze_time=effective_freeze,
-        )
+    if out_dir:
+        for r in results:
+            if r.image is None:
+                continue
+            dest = out_dir / plugin_id / size_label(r.width, r.height)
+            dest.mkdir(parents=True, exist_ok=True)
+            r.image.save(dest / f"{safe_mode_filename(r.mode)}.png", format="PNG")
 
-        if update_golden:
-            written = write_goldens(results, golden_dir)
-            logger.info("Wrote %d golden image(s) for %s%s to %s", written, plugin_id,
-                        f" [{variant_name}]" if variant_name else "", golden_dir)
-        else:
-            compare_to_goldens(results, golden_dir)
-
-        check_scale_up(results, design_size=design_size, strict=fill_strict)
-
-        # Tag variant runs so the report and PNG dumps stay distinguishable.
-        if variant_name:
-            for r in results:
-                r.mode = f"{r.mode}@{variant_name}"
-
-        if out_dir:
-            for r in results:
-                if r.image is None:
-                    continue
-                dest = out_dir / plugin_id / size_label(r.width, r.height)
-                dest.mkdir(parents=True, exist_ok=True)
-                r.image.save(dest / f"{safe_mode_filename(r.mode)}.png", format="PNG")
-
-        all_run_results.extend(results)
-
-    return all_run_results
+    return results
 
 
 def print_report(all_results: Dict[str, List[RenderResult]]) -> bool:
@@ -174,10 +147,6 @@ def print_report(all_results: Dict[str, List[RenderResult]]) -> bool:
                     detail = " (golden ✓)"
                 if r.update_error is not None:
                     detail += f" (update warn: {r.update_error})"
-                if r.fill_checked and r.fill_ok is None and r.fill_extent:
-                    # warn-only underfill: big panel left mostly empty
-                    ex, ey = r.fill_extent
-                    detail += f" (fill warn: extent {ex:.0%}x{ey:.0%})"
             else:
                 everything_ok = False
                 if r.error is not None:
@@ -187,10 +156,6 @@ def print_report(all_results: Dict[str, List[RenderResult]]) -> bool:
                 elif r.golden_ok is False:
                     status = "FAIL"
                     detail = f" golden drift: {r.golden_diff_pixels}px (max Δ={r.golden_max_delta})"
-                elif r.fill_ok is False:
-                    ex, ey = r.fill_extent or (0.0, 0.0)
-                    status = "FAIL"
-                    detail = f" fill: extent {ex:.0%}x{ey:.0%} below required coverage"
                 else:
                     status, detail = "FAIL", ""
             print(f"  [{status}] {r.size_label:>7}  {r.mode}{detail}")

scripts/dev/test_pillow_compat.py

@@ -55,7 +55,7 @@ def main():
     failures += not check("draw.textbbox",
         lambda: draw.textbbox((0, 0), "Test", font=font))
 
-    print("\nResampling (used in logo_helper, sports base):")
+    print("\nResampling (used in logo_helper, image_utils, sports base):")
     logo = Image.new('RGBA', (200, 200), (255, 128, 0, 200))
     failures += not check("Image.Resampling.LANCZOS exists",
         lambda: str(Image.Resampling.LANCZOS))

scripts/dev_server.py

@@ -16,7 +16,6 @@ Opens at http://localhost:5001
 import sys
 import os
 import json
-import re
 import time
 import argparse
 import logging
@@ -45,10 +44,6 @@ MAX_HEIGHT = 512
 MIN_WIDTH = 1
 MIN_HEIGHT = 1
 
-# plugin_id arrives in request input and is used to build filesystem paths —
-# allowlist it (same pattern the web UI's pages_v3 uses)
-_SAFE_PLUGIN_ID_RE = re.compile(r'^[a-zA-Z0-9_-]{1,64}$')
-
 
 # --------------------------------------------------------------------------
 # Plugin discovery
@@ -111,30 +106,15 @@ def discover_plugins() -> List[Dict[str, Any]]:
 
 
 def find_plugin_dir(plugin_id: str) -> Optional[Path]:
-    """Find a plugin directory by ID.
-
-    plugin_id comes from request input: it must pass an allowlist match,
-    and the resulting directory is normalized and required to live inside
-    one of the plugin search dirs, so a crafted id can never name a path
-    outside them.
-    """
-    if not isinstance(plugin_id, str) or not _SAFE_PLUGIN_ID_RE.match(plugin_id):
-        return None
+    """Find a plugin directory by ID."""
     from src.plugin_system.plugin_loader import PluginLoader
     loader = PluginLoader()
     for search_dir in get_search_dirs():
         if not search_dir.exists():
             continue
         result = loader.find_plugin_directory(plugin_id, search_dir)
-        if not result:
-            continue
-        # Normalize WITHOUT following symlinks (dev plugins are often
-        # symlinked into plugins/) and require lexical containment in the
-        # search dir, so no id can ever name a path outside it.
-        result_abs = os.path.abspath(str(result))
-        root_abs = os.path.abspath(str(search_dir))
-        if os.path.commonpath([result_abs, root_abs]) == root_abs:
-            return Path(result_abs)
+        if result:
+            return Path(result)
     return None
 
 
@@ -196,118 +176,6 @@ def api_plugin_defaults(plugin_id):
     return jsonify({'defaults': defaults})
 
 
-def _render_once(plugin_id, plugin_dir, manifest, config, mock_data, width, height,
-                 skip_update):
-    """Render one plugin at one size. Returns the /api/render response dict.
-
-    A fresh plugin instance per call, mirroring the safety harness, so sizes
-    never share state.
-    """
-    from src.plugin_system.testing import VisualTestDisplayManager, MockCacheManager, MockPluginManager
-    from src.plugin_system.plugin_loader import PluginLoader
-
-    display_manager = VisualTestDisplayManager(width=width, height=height)
-    cache_manager = MockCacheManager()
-    plugin_manager = MockPluginManager()
-
-    # Pre-populate cache with mock data
-    for key, value in mock_data.items():
-        cache_manager.set(key, value)
-
-    loader = PluginLoader()
-    errors = []
-    warnings = []
-
-    plugin_instance, _module = loader.load_plugin(
-        plugin_id=plugin_id,
-        manifest=manifest,
-        plugin_dir=plugin_dir,
-        config=config,
-        display_manager=display_manager,
-        cache_manager=cache_manager,
-        plugin_manager=plugin_manager,
-        install_deps=False,
-    )
-
-    start_time = time.time()
-
-    # Run update()
-    if not skip_update:
-        try:
-            plugin_instance.update()
-        except Exception as e:
-            logger.warning("update() raised for plugin %s", plugin_id, exc_info=True)
-            warnings.append(f"update() raised: {type(e).__name__} — see server log")
-
-    # Run display()
-    try:
-        plugin_instance.display(force_clear=True)
-    except Exception as e:
-        logger.warning("display() raised for plugin %s", plugin_id, exc_info=True)
-        errors.append(f"display() raised: {type(e).__name__} — see server log")
-
-    render_time_ms = round((time.time() - start_time) * 1000, 1)
-
-    return {
-        'image': f'data:image/png;base64,{display_manager.get_image_base64()}',
-        'width': width,
-        'height': height,
-        'render_time_ms': render_time_ms,
-        'errors': errors,
-        'warnings': warnings,
-    }
-
-
-def _trusted_plugin_dir(plugin_dir: Path) -> Optional[Path]:
-    """Re-derive a plugin directory from the search dirs' own listings.
-
-    Path-injection barrier: unlike ``Path.iterdir()`` (which CodeQL doesn't
-    recognize as a taint-clearing enumeration), ``os.scandir()`` is. The
-    returned Path is built from a trusted root plus a name the filesystem
-    itself produced under that root via scandir — request-derived strings
-    never enter its construction — so a crafted plugin id can never make
-    downstream file access leave the plugin search dirs. Comparison is by
-    name, deliberately without symlink resolution (dev plugins are
-    commonly symlinked into plugins/).
-    """
-    wanted_name = Path(os.path.normpath(str(plugin_dir))).name
-    for search_dir in get_search_dirs():
-        search_dir_str = str(search_dir)
-        try:
-            with os.scandir(search_dir_str) as entries:
-                for entry in entries:
-                    if entry.name == wanted_name and entry.is_dir():
-                        return Path(search_dir_str) / entry.name
-        except OSError:
-            continue
-    return None
-
-
-def _parse_render_request(data):
-    """Shared /api/render* request prep. Returns (plugin_dir, manifest, config,
-    mock_data, skip_update) or raises ValueError with a client message."""
-    plugin_id = data['plugin_id']
-    candidate_dir = find_plugin_dir(plugin_id)
-    # Never reuse `candidate_dir` past this point: it's built from
-    # request-derived input, and a variable reassigned only on some paths
-    # isn't a barrier CodeQL's flow analysis honors. `trusted_dir` is the
-    # sole name used below, always the scandir-sourced result.
-    trusted_dir = _trusted_plugin_dir(candidate_dir) if candidate_dir else None
-    if not trusted_dir:
-        raise LookupError(f'Plugin not found: {plugin_id}')
-
-    manifest_path = trusted_dir / 'manifest.json'
-    with open(manifest_path, 'r') as f:
-        manifest = json.load(f)
-
-    # Build config: schema defaults + user overrides
-    config = {'enabled': True}
-    config.update(load_config_defaults(trusted_dir))
-    config.update(data.get('config', {}))
-
-    return trusted_dir, manifest, config, data.get('mock_data', {}), data.get('skip_update', False)
-
-
 @app.route('/api/render', methods=['POST'])
 def api_render():
     """Render a plugin and return the display as base64 PNG."""
@@ -315,6 +183,11 @@ def api_render():
     if not data or 'plugin_id' not in data:
         return jsonify({'error': 'plugin_id is required'}), 400
 
+    plugin_id = data['plugin_id']
+    user_config = data.get('config', {})
+    mock_data = data.get('mock_data', {})
+    skip_update = data.get('skip_update', False)
+
     try:
         width = int(data.get('width', 128))
         height = int(data.get('height', 32))
@@ -326,77 +199,78 @@ def api_render():
     if not (MIN_HEIGHT <= height <= MAX_HEIGHT):
         return jsonify({'error': f'height must be between {MIN_HEIGHT} and {MAX_HEIGHT}'}), 400
 
-    try:
-        plugin_dir, manifest, config, mock_data, skip_update = _parse_render_request(data)
-    except LookupError:
-        return jsonify({'error': f"Plugin not found: {data['plugin_id']}"}), 404
-    except Exception:
-        # Bad manifest.json / schema / fixture — details go to the dev's
-        # console, not the HTTP response
-        app.logger.exception('render request preparation failed')
-        return jsonify({'error': 'Could not prepare render request; see server log'}), 400
+    # Find plugin
+    plugin_dir = find_plugin_dir(plugin_id)
+    if not plugin_dir:
+        return jsonify({'error': f'Plugin not found: {plugin_id}'}), 404
+
+    # Load manifest
+    manifest_path = plugin_dir / 'manifest.json'
+    with open(manifest_path, 'r') as f:
+        manifest = json.load(f)
+
+    # Build config: schema defaults + user overrides
+    config_defaults = load_config_defaults(plugin_dir)
+    config = {'enabled': True}
+    config.update(config_defaults)
+    config.update(user_config)
+
+    # Create display manager and mocks
+    from src.plugin_system.testing import VisualTestDisplayManager, MockCacheManager, MockPluginManager
+    from src.plugin_system.plugin_loader import PluginLoader
+
+    display_manager = VisualTestDisplayManager(width=width, height=height)
+    cache_manager = MockCacheManager()
+    plugin_manager = MockPluginManager()
+
+    # Pre-populate cache with mock data
+    for key, value in mock_data.items():
+        cache_manager.set(key, value)
+
+    # Load plugin
+    loader = PluginLoader()
+    errors = []
+    warnings = []
 
     try:
-        result = _render_once(data['plugin_id'], plugin_dir, manifest, config,
-                              mock_data, width, height, skip_update)
-    except Exception:
-        app.logger.exception('plugin load failed during render')
-        return jsonify({'error': 'Failed to load plugin; see server log'}), 500
-    return jsonify(result)
+        plugin_instance, module = loader.load_plugin(
+            plugin_id=plugin_id,
+            manifest=manifest,
+            plugin_dir=plugin_dir,
+            config=config,
+            display_manager=display_manager,
+            cache_manager=cache_manager,
+            plugin_manager=plugin_manager,
+            install_deps=False,
+        )
+    except Exception as e:
+        return jsonify({'error': f'Failed to load plugin: {e}'}), 500
 
+    start_time = time.time()
 
-@app.route('/api/sizes')
-def api_sizes():
-    """The representative panel-size sample the safety harness renders at."""
-    from src.plugin_system.testing.sizes import DEFAULT_TEST_SIZES
-    return jsonify({'sizes': [list(s) for s in DEFAULT_TEST_SIZES]})
-
-
-MAX_MATRIX_SIZES = 12
-
-
-@app.route('/api/render-matrix', methods=['POST'])
-def api_render_matrix():
-    """Render a plugin at a list of sizes (default: the harness sample) so the
-    UI can show a side-by-side multi-resolution gallery."""
-    data = request.get_json()
-    if not data or 'plugin_id' not in data:
-        return jsonify({'error': 'plugin_id is required'}), 400
-
-    from src.plugin_system.testing.sizes import DEFAULT_TEST_SIZES
-    sizes = data.get('sizes') or [list(s) for s in DEFAULT_TEST_SIZES]
-    if len(sizes) > MAX_MATRIX_SIZES:
-        return jsonify({'error': f'at most {MAX_MATRIX_SIZES} sizes per request'}), 400
-    parsed_sizes = []
-    for pair in sizes:
+    # Run update()
+    if not skip_update:
         try:
-            w, h = int(pair[0]), int(pair[1])
-        except (TypeError, ValueError, IndexError):
-            return jsonify({'error': f'invalid size entry {pair!r} (expected [w, h])'}), 400
-        if not (MIN_WIDTH <= w <= MAX_WIDTH and MIN_HEIGHT <= h <= MAX_HEIGHT):
-            return jsonify({'error': f'size {w}x{h} out of bounds'}), 400
-        parsed_sizes.append((w, h))
+            plugin_instance.update()
+        except Exception as e:
+            warnings.append(f"update() raised: {e}")
 
+    # Run display()
     try:
-        plugin_dir, manifest, config, mock_data, skip_update = _parse_render_request(data)
-    except LookupError:
-        return jsonify({'error': f"Plugin not found: {data['plugin_id']}"}), 404
-    except Exception:
-        app.logger.exception('render request preparation failed')
-        return jsonify({'error': 'Could not prepare render request; see server log'}), 400
+        plugin_instance.display(force_clear=True)
+    except Exception as e:
+        errors.append(f"display() raised: {e}")
 
-    results = []
-    for w, h in parsed_sizes:
-        try:
-            results.append(_render_once(data['plugin_id'], plugin_dir, manifest,
-                                        config, mock_data, w, h, skip_update))
-        except Exception:
-            app.logger.exception('plugin load failed during %dx%d render', w, h)
-            results.append({'image': None, 'width': w, 'height': h,
-                            'render_time_ms': 0,
-                            'errors': ['Failed to load plugin; see server log'],
-                            'warnings': []})
-    return jsonify({'results': results})
+    render_time_ms = round((time.time() - start_time) * 1000, 1)
+
+    return jsonify({
+        'image': f'data:image/png;base64,{display_manager.get_image_base64()}',
+        'width': width,
+        'height': height,
+        'render_time_ms': render_time_ms,
+        'errors': errors,
+        'warnings': warnings,
+    })
 
 
 # --------------------------------------------------------------------------

scripts/generate_report.py

@@ -1,356 +0,0 @@
-#!/usr/bin/env python3
-"""
-Security Report Generator
-
-Aggregates JSON output from all CI security audit jobs into a single
-Markdown report suitable for PR comments and artifact storage.
-
-Expected artifact layout (from actions/download-artifact@v4):
-    <artifact-dir>/
-        sast-results/
-            bandit-results.json
-            semgrep-results.json
-        dependency-audit-results/
-            pip-audit-results.json
-            safety-results.json
-        secrets-scan-results/
-            gitleaks-results.json
-        security-proofs-results/
-            security-proofs-results.json
-        plugin-audit-results/
-            plugin-audit-results.json
-
-Usage:
-    python scripts/generate_report.py --artifact-dir audit-artifacts/ --output report.md
-    python scripts/generate_report.py --artifact-dir audit-artifacts/ --output report.md --verbose
-"""
-
-import argparse
-import json
-import sys
-from pathlib import Path
-from datetime import datetime, timezone
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-
-# Gitleaks matches exactly equal to one of these (not a substring match -- a
-# real secret that merely contains one of these words as part of its actual
-# value must still be reported) are known template placeholders.
-_GITLEAKS_SUPPRESS_EXACT_VALUES = {
-    "YOUR_YOUTUBE_API_KEY",
-    "YOUR_YOUTUBE_CHANNEL_ID",
-    "YOUR_GITHUB_PERSONAL_ACCESS_TOKEN",
-}
-
-# Findings in these files are suppressed regardless of value -- they are
-# template/example files that are expected to only ever contain placeholders.
-_GITLEAKS_SUPPRESS_PATHS = [
-    "config_secrets.template.json",
-    "config.template.json",
-]
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Helpers
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _load(path: Path) -> tuple[dict | list | None, str | None]:
-    """Load a JSON artifact file.
-
-    Returns (data, error): error is None on success (data is whatever was
-    parsed, which may legitimately be an empty list/dict for a clean scan);
-    otherwise error is a human-readable reason the artifact is unavailable,
-    distinguishing "missing/malformed artifact" from "valid empty result" so
-    callers don't silently treat a broken CI job as a clean pass.
-    """
-    if not path.exists():
-        return None, f"artifact not found: {path}"
-    try:
-        return json.loads(path.read_text(encoding="utf-8")), None
-    except (json.JSONDecodeError, OSError) as exc:
-        return None, f"could not read/parse {path}: {exc}"
-
-
-def _md_sanitize_cell(value: object) -> str:
-    """Escape/normalize a value so scanner-controlled content (a matched
-    secret, a bandit issue_text, a file path) can't alter the Markdown
-    table's structure: pipes would add bogus columns, newlines would break
-    out of the row (or forge a fake header/separator line)."""
-    text = str(value)
-    text = text.replace("\\", "\\\\").replace("|", "\\|")
-    text = text.replace("\r\n", " ").replace("\n", " ").replace("\r", " ")
-    return text
-
-
-def _md_table_row(*cells: str) -> str:
-    return "| " + " | ".join(_md_sanitize_cell(c) for c in cells) + " |"
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Per-tool summarizers
-# Returns: (markdown_lines: list[str], critical_count: int, available: bool)
-# `available=False` means the artifact was missing or malformed -- distinct
-# from a valid scan that simply found nothing -- so the caller can report
-# INCOMPLETE instead of silently counting it as a clean pass.
-# ─────────────────────────────────────────────────────────────────────────────
-
-def _summarize_bandit(artifact_dir: Path) -> tuple[list[str], int, bool]:
-    data, error = _load(artifact_dir / "sast-results" / "bandit-results.json")
-    if error:
-        return [f"_bandit results unavailable: {error}_"], 0, False
-
-    results = data.get("results", [])
-    high = [r for r in results if r.get("issue_severity") == "HIGH"]
-    medium = [r for r in results if r.get("issue_severity") == "MEDIUM"]
-    low = [r for r in results if r.get("issue_severity") == "LOW"]
-
-    lines = [
-        f"**Bandit**: {len(high)} HIGH · {len(medium)} MEDIUM · {len(low)} LOW"
-    ]
-
-    if high:
-        lines += [
-            "",
-            "| Severity | File | Line | Issue |",
-            "| --- | --- | --- | --- |",
-        ]
-        for r in high[:10]:
-            fname = Path(r.get("filename", "")).name
-            lines.append(_md_table_row(
-                "HIGH", f"`{fname}`",
-                str(r.get("line_number", "?")),
-                r.get("issue_text", "")
-            ))
-        if len(high) > 10:
-            lines.append(f"_… and {len(high) - 10} more HIGH findings_")
-
-    return lines, len(high), True
-
-
-def _summarize_pip_audit(artifact_dir: Path) -> tuple[list[str], int, bool]:
-    data, error = _load(artifact_dir / "dependency-audit-results" / "pip-audit-results.json")
-    if error:
-        return [f"_pip-audit results unavailable: {error}_"], 0, False
-
-    # pip-audit JSON format: {"dependencies": [{"name": ..., "vulns": [...]}]}
-    vulns: list[dict] = []
-    for dep in data.get("dependencies", []):
-        for v in dep.get("vulns", []):
-            vulns.append({"package": dep.get("name", "?"), **v})
-
-    lines = [f"**pip-audit**: {len(vulns)} vulnerabilities found"]
-
-    if vulns:
-        lines += ["", "| Package | ID | Fix |", "| --- | --- | --- |"]
-        for v in vulns[:10]:
-            fix = v.get("fix_versions", ["none"])
-            fix_str = ", ".join(fix) if fix else "none"
-            lines.append(_md_table_row(
-                v.get("package", "?"),
-                v.get("id", "?"),
-                fix_str,
-            ))
-
-    # Treat known vulnerabilities as warnings, not critical (they may be unavoidable)
-    return lines, 0, True
-
-
-def _summarize_gitleaks(artifact_dir: Path) -> tuple[list[str], int, bool]:
-    data, error = _load(artifact_dir / "secrets-scan-results" / "gitleaks-results.json")
-    if error:
-        return [f"_gitleaks results unavailable: {error}_"], 0, False
-
-    if not isinstance(data, list):
-        data = []
-
-    real_findings = []
-    suppressed = 0
-    for finding in data:
-        secret_val = str(finding.get("Secret", "") or finding.get("Match", ""))
-        file_name = Path(finding.get("File", "")).name
-        if (secret_val in _GITLEAKS_SUPPRESS_EXACT_VALUES
-                or file_name in _GITLEAKS_SUPPRESS_PATHS):
-            suppressed += 1
-        else:
-            real_findings.append(finding)
-
-    lines = [
-        f"**Gitleaks**: {len(real_findings)} finding(s) "
-        f"({suppressed} suppressed as template placeholders)"
-    ]
-
-    if real_findings:
-        lines += ["", "| Rule | File | Line | Description |", "| --- | --- | --- | --- |"]
-        for f in real_findings[:10]:
-            fname = Path(f.get("File", "")).name
-            lines.append(_md_table_row(
-                f.get("RuleID", "?"),
-                f"`{fname}`",
-                str(f.get("StartLine", "?")),
-                f.get("Description", ""),
-            ))
-
-    critical = len(real_findings)  # any real secret is critical
-    return lines, critical, True
-
-
-def _summarize_security_proofs(artifact_dir: Path) -> tuple[list[str], int, bool]:
-    data, error = _load(artifact_dir / "security-proofs-results" / "security-proofs-results.json")
-    if error:
-        return [f"_security proofs results unavailable: {error}_"], 0, False
-
-    if not isinstance(data, list):
-        data = []
-
-    critical = [r for r in data if r.get("severity") == "CRITICAL"]
-    warnings = [r for r in data if r.get("severity") == "WARNING"]
-    passed = [r for r in data if r.get("severity") == "PASS"]
-    skipped = [r for r in data if r.get("severity") == "SKIP"]
-
-    lines = [
-        f"**Security Proofs**: "
-        f"{len(passed)} PASS · {len(warnings)} WARN · "
-        f"{len(critical)} CRITICAL · {len(skipped)} SKIP",
-        "",
-    ]
-
-    _icon = {"PASS": "✅", "INFO": "ℹ️", "WARNING": "⚠️",  # nosec B105 - severity labels, not credentials
-             "CRITICAL": "🚨", "SKIP": "⏭️"}
-    for r in data:
-        icon = _icon.get(r.get("severity", ""), "❓")
-        lines.append(
-            f"- {icon} **{r.get('test_id', '?')}**: {r.get('message', '')}"
-        )
-        if r.get("details") and r.get("severity") in ("CRITICAL", "WARNING"):
-            lines.append(f"  - _{r['details']}_")
-
-    return lines, len(critical), True
-
-
-def _summarize_plugin_audit(artifact_dir: Path) -> tuple[list[str], int, bool]:
-    data, error = _load(artifact_dir / "plugin-audit-results" / "plugin-audit-results.json")
-    if error:
-        return [f"_plugin audit results unavailable: {error}_"], 0, False
-
-    summary = data.get("summary", {})
-    findings = data.get("findings", [])
-    critical_findings = [f for f in findings if f.get("severity") == "CRITICAL"]
-    warning_findings = [f for f in findings if f.get("severity") == "WARNING"]
-
-    lines = [
-        f"**Plugin Audit**: {data.get('plugins_scanned', '?')} plugins scanned — "
-        f"{summary.get('critical', 0)} CRITICAL · {summary.get('warnings', 0)} WARNINGS"
-    ]
-
-    if critical_findings:
-        lines += ["", "| Plugin | File | Line | Rule | Message |",
-                  "| --- | --- | --- | --- | --- |"]
-        for f in critical_findings[:10]:
-            fname = Path(f.get("file", "")).name
-            lines.append(_md_table_row(
-                f.get("plugin_id", "?"),
-                f"`{fname}`",
-                str(f.get("line", "?")),
-                f.get("rule", "?"),
-                f.get("message", ""),
-            ))
-
-    if warning_findings and not critical_findings:
-        lines.append(f"\n_{len(warning_findings)} warning(s) found — see artifact for details_")
-
-    return lines, summary.get("critical", 0), True
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Main
-# ─────────────────────────────────────────────────────────────────────────────
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="Generate consolidated security audit report",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--artifact-dir", required=True,
-                        help="Directory containing downloaded CI artifacts")
-    parser.add_argument("--output", "-o", required=True,
-                        help="Output Markdown file path")
-    parser.add_argument("--verbose", "-v", action="store_true")
-    args = parser.parse_args()
-
-    artifact_dir = Path(args.artifact_dir)
-    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M UTC")
-
-    bandit_lines, bandit_crit, bandit_ok = _summarize_bandit(artifact_dir)
-    pip_audit_lines, pip_audit_crit, pip_audit_ok = _summarize_pip_audit(artifact_dir)
-    gitleaks_lines, gitleaks_crit, gitleaks_ok = _summarize_gitleaks(artifact_dir)
-    proofs_lines, proofs_crit, proofs_ok = _summarize_security_proofs(artifact_dir)
-    plugins_lines, plugins_crit, plugins_ok = _summarize_plugin_audit(artifact_dir)
-
-    unavailable_tools = [
-        name for name, ok in [
-            ("bandit", bandit_ok), ("pip-audit", pip_audit_ok),
-            ("gitleaks", gitleaks_ok), ("security-proofs", proofs_ok),
-            ("plugin-audit", plugins_ok),
-        ] if not ok
-    ]
-
-    total_critical = bandit_crit + pip_audit_crit + gitleaks_crit + proofs_crit + plugins_crit
-    if unavailable_tools:
-        # A missing/malformed artifact means that tool's checks never
-        # actually ran -- this must not be reported as a clean PASS just
-        # because the *artifacts that did load* found nothing.
-        overall = "INCOMPLETE ⚠️"
-    elif total_critical > 0:
-        overall = "ACTION REQUIRED 🚨"
-    else:
-        overall = "PASSED ✅"
-
-    def section(title: str, lines: list[str]) -> str:
-        return f"### {title}\n\n" + "\n".join(lines) + "\n"
-
-    incomplete_note = (
-        f"\n_⚠️ Incomplete: results unavailable for {', '.join(unavailable_tools)} "
-        f"— see the corresponding section(s) below for details_\n"
-        if unavailable_tools else ""
-    )
-
-    report = f"""## 🔒 Security Audit — {overall}
-
-_Generated: {timestamp}_
-{incomplete_note}
-| Critical | High/Warn | Overall |
-| :---: | :---: | :---: |
-| {'🚨 ' + str(total_critical) if total_critical else '✅ 0'} | ⚠️ see below | {overall} |
-
----
-
-{section('SAST — Bandit', bandit_lines)}
-{section('Dependencies — pip-audit', pip_audit_lines)}
-{section('Secrets — Gitleaks', gitleaks_lines)}
-{section('LEDMatrix Security Proofs', proofs_lines)}
-{section('Plugin Security Audit', plugins_lines)}
----
-
-_Total critical findings: **{total_critical}**_
-"""
-
-    output_path = Path(args.output)
-    output_path.write_text(report, encoding="utf-8")
-
-    if args.verbose:
-        print(f"  Report written to: {output_path}")
-        print(f"  Status: {overall}")
-        print(f"  Critical findings: {total_critical}")
-        print(f"    bandit={bandit_crit}  pip-audit={pip_audit_crit}  "
-              f"gitleaks={gitleaks_crit}  proofs={proofs_crit}  plugins={plugins_crit}")
-        if unavailable_tools:
-            print(f"  Unavailable: {', '.join(unavailable_tools)}")
-
-    if unavailable_tools:
-        return 1
-
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/prove_security.py

@@ -1,593 +0,0 @@
-#!/usr/bin/env python3
-"""
-LEDMatrix Security Proof Tests
-
-Automated proofs that run in CI to verify security properties hold on every
-commit. Inspired by the Huntarr security review approach of using standard
-tooling to confirm specific vulnerability classes are absent.
-
-Usage:
-    python scripts/prove_security.py
-    python scripts/prove_security.py --verbose
-    python scripts/prove_security.py --output results.json
-
-Exit code: 1 only if CRITICAL findings are detected. Warnings are reported
-but do not block CI.
-"""
-
-import ast
-import argparse
-import hashlib
-import json
-import re
-import sys
-from dataclasses import dataclass, asdict
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).resolve().parent.parent
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Result dataclass
-# ─────────────────────────────────────────────────────────────────────────────
-
-@dataclass
-class TestResult:
-    test_id: str
-    severity: str   # PASS | INFO | WARNING | CRITICAL | SKIP
-    message: str
-    details: str = ""
-
-    def to_dict(self) -> dict:
-        return asdict(self)
-
-    @property
-    def icon(self) -> str:
-        return {
-            "PASS": "✅",  # nosec B105 - severity label, not a credential
-            "INFO": "ℹ️ ",
-            "WARNING": "⚠️ ",
-            "CRITICAL": "🚨",
-            "SKIP": "⏭️ ",
-        }.get(self.severity, "❓")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T1: Plugin Loading / Zip Slip
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t1a_zip_slip_protection() -> TestResult:
-    """
-    Verify that zip-slip protection actually guards zip extraction in
-    store_manager.py.
-
-    A whole-file substring check for "is_relative_to"/"Zip-slip detected"
-    would pass even if the guard existed somewhere unrelated, or covered
-    only one of several extract()/extractall() call sites. Instead, this
-    walks the AST: for every extract()/extractall() call, it confirms an
-    is_relative_to() check (and the "Zip-slip detected" log) appears
-    earlier in that same enclosing function -- validate-then-bulk-extract
-    (validate every member, then call extractall() only after all passed)
-    counts as protecting the call, since it covers the same member list.
-    """
-    store_manager = PROJECT_ROOT / "src" / "plugin_system" / "store_manager.py"
-    if not store_manager.exists():
-        return TestResult("T1a", "CRITICAL",
-                          "store_manager.py not found",
-                          f"Expected at {store_manager}")
-
-    content = store_manager.read_text(encoding="utf-8")
-    try:
-        tree = ast.parse(content, filename=str(store_manager))
-    except SyntaxError as exc:
-        return TestResult("T1a", "CRITICAL",
-                          "store_manager.py could not be parsed",
-                          str(exc))
-
-    extraction_sites = 0
-    unprotected: list[str] = []
-
-    for func in ast.walk(tree):
-        if not isinstance(func, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            continue
-
-        extract_calls = [
-            node for node in ast.walk(func)
-            if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)
-            and node.func.attr in ("extract", "extractall")
-        ]
-        if not extract_calls:
-            continue
-        extraction_sites += len(extract_calls)
-
-        guard_lines = [
-            n.lineno for n in ast.walk(func)
-            if isinstance(n, ast.Attribute) and n.attr == "is_relative_to"
-        ]
-        has_zip_slip_log = any(
-            isinstance(n, ast.Constant) and isinstance(n.value, str)
-            and "Zip-slip detected" in n.value
-            for n in ast.walk(func)
-        )
-
-        for call in extract_calls:
-            guarded = has_zip_slip_log and any(g < call.lineno for g in guard_lines)
-            if not guarded:
-                unprotected.append(
-                    f"{func.name}() line {call.lineno}: {call.func.attr}() call not "
-                    f"clearly preceded by an is_relative_to() guard + Zip-slip log "
-                    f"in the same function"
-                )
-
-    if extraction_sites == 0:
-        return TestResult("T1a", "WARNING",
-                          "No zipfile extract()/extractall() calls found in store_manager.py",
-                          "Verify plugin installation no longer extracts zip archives, "
-                          "or that this check still targets the right file")
-
-    if unprotected:
-        return TestResult("T1a", "CRITICAL",
-                          f"{len(unprotected)} of {extraction_sites} zip extraction "
-                          f"call(s) not clearly guarded",
-                          "; ".join(unprotected))
-
-    return TestResult("T1a", "PASS",
-                      "Zip-slip protection verified",
-                      f"All {extraction_sites} extract()/extractall() call(s) in "
-                      f"store_manager.py are preceded by an is_relative_to() guard "
-                      f"with a Zip-slip log in the same function")
-
-
-def test_t1b_dangerous_plugin_calls() -> list[TestResult]:
-    """
-    Scan plugin directories for dangerous function calls (eval, exec).
-    These represent arbitrary code execution risks in plugin code.
-    """
-    results = []
-    plugin_dirs = [
-        PROJECT_ROOT / "plugins",
-        PROJECT_ROOT / "plugin-repos",
-    ]
-
-    violations: list[str] = []
-    files_scanned = 0
-
-    scan_errors: list[str] = []
-
-    for base in plugin_dirs:
-        if not base.exists():
-            continue
-        for plugin_dir in sorted(base.iterdir()):
-            if not plugin_dir.is_dir() or plugin_dir.name.startswith(('.', '_')):
-                continue
-            for py_file in plugin_dir.rglob("*.py"):
-                files_scanned += 1
-                try:
-                    source = py_file.read_text(encoding="utf-8")
-                    tree = ast.parse(source, filename=str(py_file))
-                    for node in ast.walk(tree):
-                        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
-                            if node.func.id in ("eval", "exec"):
-                                rel = py_file.relative_to(PROJECT_ROOT)
-                                violations.append(
-                                    f"{rel}:{node.lineno} — {node.func.id}() call")
-                except (SyntaxError, OSError) as exc:
-                    # A file we couldn't parse/read was never actually
-                    # scanned for eval()/exec() -- that must block this
-                    # test, not silently pass as if it were clean.
-                    rel = py_file.relative_to(PROJECT_ROOT)
-                    scan_errors.append(f"{rel} — {type(exc).__name__}: {exc}")
-
-    if scan_errors:
-        results.append(TestResult(
-            "T1b", "CRITICAL",
-            f"{len(scan_errors)} plugin file(s) could not be scanned for eval()/exec()",
-            "; ".join(scan_errors[:10])
-        ))
-
-    if violations:
-        results.append(TestResult(
-            "T1b", "CRITICAL",
-            f"Dangerous function calls found in plugins ({len(violations)} instance(s))",
-            "; ".join(violations[:10])
-        ))
-    elif not scan_errors:
-        results.append(TestResult(
-            "T1b", "PASS",
-            "No eval()/exec() calls found in plugins",
-            f"{files_scanned} plugin Python files scanned"
-        ))
-
-    return results
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T2: API Surface Inventory
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t2a_api_surface_inventory() -> TestResult:
-    """
-    Document the API surface area.
-
-    This app intentionally has no authentication (local-only Raspberry Pi
-    design, documented in web_interface/app.py). This test produces an
-    inventory for audit purposes and warns only if the design-intent comment
-    is removed from app.py (which would indicate someone deleted the rationale
-    without adding auth, rather than a deliberate undocumented change).
-    """
-    api_file = PROJECT_ROOT / "web_interface" / "blueprints" / "api_v3.py"
-    app_file = PROJECT_ROOT / "web_interface" / "app.py"
-
-    if not api_file.exists():
-        return TestResult("T2a", "WARNING", "api_v3.py not found", str(api_file))
-
-    api_content = api_file.read_text(encoding="utf-8")
-    routes = re.findall(r"@api_v3\.route\('([^']+)'", api_content)
-
-    csrf_documented = False
-    if app_file.exists():
-        app_content = app_file.read_text(encoding="utf-8")
-        csrf_documented = "CSRF protection disabled for local-only" in app_content
-
-    summary = (
-        f"{len(routes)} API routes in api_v3.py. "
-        f"No auth decorators (intentional local-only design). "
-        f"CSRF disabled: {'YES — design intent documented in app.py' if csrf_documented else 'YES — but design intent comment NOT found in app.py'}. "
-        f"Rate limiting: 1000/min."
-    )
-
-    if not csrf_documented:
-        return TestResult(
-            "T2a", "WARNING",
-            "CSRF is disabled but the design-intent comment is missing from app.py",
-            "Add the rationale comment back, or add proper CSRF protection if "
-            "the app is now internet-facing"
-        )
-
-    # There is currently no config mechanism that actually enforces the
-    # local-only boundary the design-intent comment describes -- app.py
-    # hardcodes host='0.0.0.0' unconditionally, so nothing here can confirm
-    # this deployment is in fact LAN-only. Reporting this as mere INFO
-    # understates that: an unauthenticated, CSRF-disabled API surface is a
-    # real risk the moment this ever runs somewhere other than a home LAN,
-    # documented rationale or not.
-    return TestResult(
-        "T2a", "WARNING",
-        "API surface has no auth and CSRF disabled; enforcement of the "
-        "documented local-only boundary cannot be confirmed",
-        summary
-    )
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T3: Secrets & Credential Handling
-# ─────────────────────────────────────────────────────────────────────────────
-
-# Patterns that suggest real credentials (must be >8 chars, not placeholders)
-_SECRET_PATTERNS = [
-    (r'(?i)password\s*=\s*["\'](?!none|empty|placeholder|example|test|default|""|'')[^"\']{8,}["\']', "WARNING", "password"),
-    (r'(?i)api[_-]?key\s*=\s*["\'](?!none|empty|placeholder|YOUR_|example|test)[^"\']{16,}["\']', "WARNING", "api_key"),
-    (r'(?i)secret\s*=\s*["\'](?!none|empty|placeholder|YOUR_|example|test)[^"\']{16,}["\']', "WARNING", "secret"),
-    # Real GitHub token pattern
-    (r'ghp_[a-zA-Z0-9]{36}', "CRITICAL", "github_token"),
-    # Generic long bearer tokens
-    (r'Bearer\s+[a-zA-Z0-9\-_\.]{32,}', "WARNING", "bearer_token"),
-]
-
-_TEMPLATE_SKIP_STRINGS = [
-    "YOUR_", "PLACEHOLDER", "_HERE", "example.com", "config_secrets.template",
-    "prove_security",  # this file itself
-]
-
-_SCAN_DIRS = ["src", "web_interface", "scripts"]
-
-
-def test_t3a_hardcoded_secrets() -> TestResult:
-    """Scan source code for hardcoded credentials."""
-    violations: list[str] = []
-
-    for dir_name in _SCAN_DIRS:
-        scan_dir = PROJECT_ROOT / dir_name
-        if not scan_dir.exists():
-            continue
-        for py_file in scan_dir.rglob("*.py"):
-            # Skip test files and this script
-            if "test" in str(py_file).lower() or "prove_security" in str(py_file):
-                continue
-            try:
-                content = py_file.read_text(encoding="utf-8")
-            except OSError:
-                continue
-
-            for pattern, severity, pattern_type in _SECRET_PATTERNS:
-                for match in re.finditer(pattern, content):
-                    line_content = match.group(0)
-                    # Skip lines containing template placeholder strings.
-                    # line_content is only used for this in-memory check --
-                    # it must never be stored or included in output below.
-                    if any(skip in line_content for skip in _TEMPLATE_SKIP_STRINGS):
-                        continue
-                    rel = py_file.relative_to(PROJECT_ROOT)
-                    line_no = content[: match.start()].count("\n") + 1
-                    # Redacted fingerprint lets the same finding be recognized
-                    # across scans without ever reporting the matched
-                    # credential itself (which would otherwise get published
-                    # into CI logs, JSON artifacts, and PR comments -- wider
-                    # exposure than the original leak).
-                    fingerprint = hashlib.sha256(line_content.encode()).hexdigest()[:12]
-                    violations.append(
-                        f"[{severity}] {rel}:{line_no} — {pattern_type} "
-                        f"(fingerprint {fingerprint})"
-                    )
-
-    critical_violations = [v for v in violations if "[CRITICAL]" in v]
-    if critical_violations:
-        return TestResult(
-            "T3a", "CRITICAL",
-            f"Hardcoded secrets found ({len(critical_violations)} critical)",
-            "; ".join(critical_violations[:5])
-        )
-    if violations:
-        return TestResult(
-            "T3a", "WARNING",
-            f"Potential hardcoded secrets found ({len(violations)} instance(s))",
-            "; ".join(violations[:5])
-        )
-
-    return TestResult("T3a", "PASS", "No hardcoded secrets detected",
-                      f"Scanned {', '.join(_SCAN_DIRS)}")
-
-
-def test_t3b_plaintext_password_storage() -> TestResult:
-    """
-    Check for user account password storage without hashing.
-
-    The LEDMatrix app has no user account system, so this should produce INFO.
-    It would only CRITICAL if someone added user auth and stored passwords without hashing.
-
-    We require all three of: a password *variable assignment or DB operation*,
-    a clear storage call (INSERT / db commit / ORM save), and no hashing lib present
-    — to avoid false positives from files that contain 'password' for WiFi handling
-    and '.save()' for image/file saving in unrelated functions.
-    """
-    hashing_libs = ["bcrypt", "argon2", "pbkdf2", "scrypt",
-                    "generate_password_hash", "hashpw", "make_password"]
-    # Patterns that indicate password being stored in a database / ORM context.
-    # Must be specific enough to avoid matching set.add(), file.save(), etc.
-    db_storage_patterns = ["INSERT INTO", "db.session", "session.add(", "session.commit(", "orm.save"]
-
-    password_storage_found = False
-
-    for dir_name in _SCAN_DIRS:
-        scan_dir = PROJECT_ROOT / dir_name
-        if not scan_dir.exists():
-            continue
-        for py_file in scan_dir.rglob("*.py"):
-            try:
-                content = py_file.read_text(encoding="utf-8")
-            except OSError:
-                continue
-            # Require DB/ORM context specifically — not just any .save() call
-            if ("password" in content.lower() and
-                    any(store in content for store in db_storage_patterns) and
-                    not any(h in content for h in hashing_libs)):
-                password_storage_found = True
-
-    if password_storage_found:
-        return TestResult(
-            "T3b", "CRITICAL",
-            "Potential plaintext password storage in database/ORM detected",
-            "Found password + database storage operations without a recognized hashing library"
-        )
-
-    return TestResult("T3b", "INFO",
-                      "No plaintext password storage detected",
-                      "App has no user account system — expected result")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T4: Path Traversal
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t4a_path_traversal() -> TestResult:
-    """
-    Verify static file serving uses send_from_directory (safe) rather than
-    open() with user-supplied paths. Also checks for extractall() calls that
-    lack the is_relative_to() guard.
-    """
-    issues: list[str] = []
-
-    app_file = PROJECT_ROOT / "web_interface" / "app.py"
-    if app_file.exists():
-        content = app_file.read_text(encoding="utf-8")
-        # The file-serve route should use send_from_directory or commonpath
-        if "send_from_directory" not in content and "commonpath" not in content:
-            issues.append("app.py: file-serve routes may not use send_from_directory/commonpath")
-
-    # Check all extractall() calls have a preceding is_relative_to guard
-    for py_file in (PROJECT_ROOT / "src").rglob("*.py"):
-        try:
-            content = py_file.read_text(encoding="utf-8")
-        except OSError:
-            continue
-        if "extractall(" in content and "is_relative_to" not in content:
-            rel = py_file.relative_to(PROJECT_ROOT)
-            issues.append(f"{rel}: extractall() without is_relative_to() guard")
-
-    if issues:
-        return TestResult(
-            "T4a", "WARNING",
-            f"Potential path traversal patterns found ({len(issues)})",
-            "; ".join(issues)
-        )
-
-    return TestResult("T4a", "PASS",
-                      "Path traversal mitigations verified",
-                      "send_from_directory/commonpath used for file serving; "
-                      "extractall() calls have is_relative_to() guards")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T5: Auth Bypass Patterns
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t5a_auth_bypass_patterns() -> TestResult:
-    """
-    Look for broken auth bypass patterns — not the intentional no-auth design
-    (T2a covers that), but patterns that suggest auth was INTENDED to exist
-    but has an exploitable bypass: broad substring matching, debug-mode skips,
-    or if-True conditions.
-    """
-    bypass_signals = [
-        (r'if\s+True\s*:', "if True: bypass"),
-        (r'if\s+debug\s*:', "debug-mode auth skip"),
-        (r'request\.path\s+in\s+', "substring path matching in auth (Huntarr pattern)"),
-        (r'EXEMPT_ROUTES\s*=', "exempt routes list"),
-    ]
-
-    findings: list[str] = []
-
-    for dir_name in ["src", "web_interface"]:
-        scan_dir = PROJECT_ROOT / dir_name
-        if not scan_dir.exists():
-            continue
-        for py_file in scan_dir.rglob("*.py"):
-            try:
-                content = py_file.read_text(encoding="utf-8")
-            except OSError:
-                continue
-            for pattern, label in bypass_signals:
-                if re.search(pattern, content):
-                    # Only flag if the file also contains auth-related terms
-                    if any(auth in content.lower() for auth in
-                           ["auth", "login", "authenticate", "token", "permission"]):
-                        rel = py_file.relative_to(PROJECT_ROOT)
-                        findings.append(f"{rel}: {label}")
-
-    if findings:
-        return TestResult(
-            "T5a", "WARNING",
-            f"Potential auth bypass patterns found ({len(findings)})",
-            "; ".join(findings[:5])
-        )
-
-    return TestResult("T5a", "PASS",
-                      "No auth bypass patterns detected",
-                      "Checked src/ and web_interface/ for bypass signals")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# T6: Docker / Container Hardening
-# ─────────────────────────────────────────────────────────────────────────────
-
-def test_t6_docker_hardening() -> TestResult:
-    """Container security — skipped if no Dockerfile exists."""
-    dockerfile = PROJECT_ROOT / "Dockerfile"
-    if not dockerfile.exists():
-        return TestResult("T6", "SKIP",
-                          "No Dockerfile found — container security scan not applicable",
-                          "If Docker support is added in future, enable hadolint/trivy scanning "
-                          "in .github/workflows/security-audit.yml")
-
-    content = dockerfile.read_text(encoding="utf-8")
-    issues: list[str] = []
-
-    # Check for non-root USER directive
-    user_lines = [l for l in content.splitlines() if l.strip().startswith("USER")]
-    if not user_lines or user_lines[-1].strip() == "USER root":
-        issues.append("Container runs as root — use USER directive to drop privileges")
-
-    # Check for pinned base image tags. A tag (even a specific version, not
-    # just :latest) is mutable -- the same tag can point to a different
-    # image later. Only a @sha256 digest is truly immutable/reproducible.
-    from_lines = [line for line in content.splitlines() if line.strip().startswith("FROM")]
-    for from_line in from_lines:
-        parts = from_line.split()
-        # FROM [--platform=<platform>] <image> [AS <name>] -- skip an
-        # optional --platform= flag so it's never mistaken for the image
-        # token itself (which would falsely report it as unpinned).
-        image_parts = [p for p in parts[1:] if not p.startswith("--platform=")]
-        if image_parts:
-            image = image_parts[0]
-            if "@sha256:" not in image:
-                issues.append(f"Base image not pinned to a digest: {image}")
-
-    if issues:
-        return TestResult("T6", "WARNING",
-                          f"Dockerfile hardening issues ({len(issues)})",
-                          "; ".join(issues))
-
-    return TestResult("T6", "PASS", "Dockerfile hardening checks passed", "")
-
-
-# ─────────────────────────────────────────────────────────────────────────────
-# Runner
-# ─────────────────────────────────────────────────────────────────────────────
-
-def main() -> int:
-    parser = argparse.ArgumentParser(
-        description="LEDMatrix security proof tests",
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--output", "-o", default=None,
-                        help="Write JSON results to this file")
-    parser.add_argument("--verbose", "-v", action="store_true",
-                        help="Show details for each check")
-    args = parser.parse_args()
-
-    print("=" * 60)
-    print("LEDMatrix Security Proof Tests")
-    print(f"Project root: {PROJECT_ROOT}")
-    print("=" * 60)
-
-    all_results: list[TestResult] = []
-
-    # Run all test groups
-    all_results.append(test_t1a_zip_slip_protection())
-    all_results.extend(test_t1b_dangerous_plugin_calls())
-    all_results.append(test_t2a_api_surface_inventory())
-    all_results.append(test_t3a_hardcoded_secrets())
-    all_results.append(test_t3b_plaintext_password_storage())
-    all_results.append(test_t4a_path_traversal())
-    all_results.append(test_t5a_auth_bypass_patterns())
-    all_results.append(test_t6_docker_hardening())
-
-    # Print results
-    print()
-    for r in all_results:
-        line = f"  {r.icon} [{r.severity:<8}] {r.test_id}: {r.message}"
-        print(line)
-        if args.verbose and r.details:
-            print(f"             {r.details}")
-
-    # Tally
-    critical = [r for r in all_results if r.severity == "CRITICAL"]
-    warnings = [r for r in all_results if r.severity == "WARNING"]
-    passed = [r for r in all_results if r.severity == "PASS"]
-    skipped = [r for r in all_results if r.severity == "SKIP"]
-
-    print()
-    print(f"  Results: {len(passed)} PASS  {len(warnings)} WARN  "
-          f"{len(critical)} CRITICAL  {len(skipped)} SKIP")
-
-    # Write JSON output
-    if args.output:
-        output_data = [r.to_dict() for r in all_results]
-        Path(args.output).write_text(
-            json.dumps(output_data, indent=2), encoding="utf-8"
-        )
-        print(f"  Results written to: {args.output}")
-
-    if critical:
-        print(f"\n  🚨 {len(critical)} CRITICAL issue(s) found — blocking")
-        return 1
-
-    if warnings:
-        print(f"\n  ⚠️  {len(warnings)} warning(s) found — non-blocking")
-
-    print("\n  ✅ All checks passed (warnings are non-blocking)")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

scripts/render_plugin.py

@@ -28,7 +28,7 @@ os.environ['EMULATOR'] = 'true'
 # Import logger after path setup so src.logging_config is importable
 from src.logging_config import get_logger  # noqa: E402
 from src.plugin_system.testing.loading import (  # noqa: E402
-    build_full_config, find_plugin_dir, load_manifest,
+    find_plugin_dir, load_manifest, load_config_defaults,
 )
 logger = get_logger("[Render Plugin]")
 
@@ -83,13 +83,16 @@ def main() -> int:
     manifest = load_manifest(Path(plugin_dir))
 
     # Parse config: start with schema defaults, then apply overrides
+    config_defaults = load_config_defaults(Path(plugin_dir))
     try:
         user_config = json.loads(args.config)
     except json.JSONDecodeError as e:
         logger.error("Invalid JSON config: %s", e)
         return 1
 
-    config = build_full_config(Path(plugin_dir), cli_config=user_config)
+    config = {'enabled': True}
+    config.update(config_defaults)
+    config.update(user_config)
 
     # Load mock data if provided
     mock_data = {}

scripts/templates/dev_preview.html

@@ -209,11 +209,6 @@
                            onchange="onConfigChange()">
                     <span class="text-xs ml-2" style="color: var(--text-secondary);">px</span>
                 </div>
-                <select id="sizePreset" onchange="applySizePreset()"
-                        class="w-full mt-2 px-2 py-1.5 rounded text-xs"
-                        style="background: var(--bg-primary); color: var(--text-secondary); border: 1px solid var(--border-color);">
-                    <option value="">Preset sizes…</option>
-                </select>
             </div>
 
             <!-- Config form -->
@@ -247,18 +242,13 @@
                 </div>
             </details>
 
-            <!-- Render buttons -->
+            <!-- Render button -->
             <div class="flex gap-2">
                 <button onclick="renderPlugin()" id="renderBtn"
                         class="flex-1 px-4 py-2.5 rounded-lg text-sm font-medium text-white"
                         style="background: var(--accent);">
                     Render
                 </button>
-                <button onclick="renderAllSizes()" id="renderAllBtn" title="Render at every harness test size"
-                        class="px-4 py-2.5 rounded-lg text-sm font-medium"
-                        style="background: var(--bg-tertiary); color: var(--text-primary); border: 1px solid var(--border-color);">
-                    All Sizes
-                </button>
             </div>
         </div>
 
@@ -321,15 +311,6 @@
             <div id="messagesPanel" class="panel p-3 hidden">
                 <div id="messagesList" class="text-xs font-mono space-y-1"></div>
             </div>
-
-            <!-- Multi-size gallery -->
-            <div id="galleryPanel" class="panel p-4 hidden">
-                <div class="flex items-center justify-between mb-3">
-                    <span class="text-xs font-medium" style="color: var(--text-secondary);">All Sizes</span>
-                    <span class="text-xs" style="color: var(--text-secondary);" id="galleryStatus"></span>
-                </div>
-                <div id="galleryGrid" class="flex flex-wrap gap-4 items-start"></div>
-            </div>
         </div>
     </div>
 
@@ -359,30 +340,8 @@
                 opt.textContent = `${p.name} (${p.id})`;
                 select.appendChild(opt);
             });
-
-            // Load harness size presets
-            try {
-                const sizesRes = await fetch('/api/sizes');
-                const sizesData = await sizesRes.json();
-                const preset = document.getElementById('sizePreset');
-                (sizesData.sizes || []).forEach(([w, h]) => {
-                    const opt = document.createElement('option');
-                    opt.value = `${w}x${h}`;
-                    opt.textContent = `${w} x ${h}`;
-                    preset.appendChild(opt);
-                });
-            } catch (e) { /* presets are a convenience; ignore */ }
         });
 
-        function applySizePreset() {
-            const value = document.getElementById('sizePreset').value;
-            if (!value) return;
-            const [w, h] = value.split('x');
-            document.getElementById('displayWidth').value = w;
-            document.getElementById('displayHeight').value = h;
-            onConfigChange();
-        }
-
         // ---------- Plugin selection ----------
         async function onPluginChange() {
             const pluginId = document.getElementById('pluginSelect').value;
@@ -526,89 +485,6 @@
             }
         }
 
-        // ---------- Multi-size gallery ----------
-        async function renderAllSizes() {
-            if (!currentPluginId) return;
-
-            const btn = document.getElementById('renderAllBtn');
-            const panel = document.getElementById('galleryPanel');
-            const grid = document.getElementById('galleryGrid');
-            const status = document.getElementById('galleryStatus');
-            btn.disabled = true;
-            btn.textContent = 'Rendering…';
-            panel.classList.remove('hidden');
-            grid.innerHTML = '';
-            status.textContent = 'Rendering at all harness sizes…';
-
-            const config = jsonEditor ? jsonEditor.getValue() : {};
-            config.enabled = true;
-            let mockData = {};
-            const mockInput = document.getElementById('mockDataInput').value.trim();
-            if (mockInput) {
-                try { mockData = JSON.parse(mockInput); }
-                catch (e) { showMessages([], [`Mock data JSON error: ${e.message}`]); }
-            }
-
-            try {
-                const res = await fetch('/api/render-matrix', {
-                    method: 'POST',
-                    headers: { 'Content-Type': 'application/json' },
-                    body: JSON.stringify({
-                        plugin_id: currentPluginId,
-                        config: config,
-                        mock_data: mockData,
-                    }),
-                });
-                const data = await res.json();
-                if (data.error) {
-                    status.textContent = data.error;
-                    return;
-                }
-
-                let failures = 0;
-                (data.results || []).forEach(r => {
-                    const cell = document.createElement('div');
-                    cell.style.cssText = 'display:flex;flex-direction:column;gap:4px;';
-                    const failed = (r.errors || []).length > 0 || !r.image;
-                    if (failed) failures++;
-
-                    const label = document.createElement('span');
-                    label.className = 'text-xs font-mono';
-                    label.style.color = failed ? '#f87171' : 'var(--text-secondary)';
-                    label.textContent = `${r.width}x${r.height} · ${r.render_time_ms}ms`;
-                    cell.appendChild(label);
-
-                    if (r.image) {
-                        const img = document.createElement('img');
-                        img.src = r.image;
-                        // Small panels get 2x zoom so they stay legible in the grid
-                        const zoom = r.height >= 128 ? 1 : 2;
-                        img.style.cssText =
-                            `image-rendering: pixelated; width:${r.width * zoom}px; ` +
-                            `height:${r.height * zoom}px; ` +
-                            `border:1px solid ${failed ? '#f87171' : 'var(--border-color)'};`;
-                        cell.appendChild(img);
-                    }
-                    if (failed) {
-                        const err = document.createElement('span');
-                        err.className = 'text-xs font-mono';
-                        err.style.color = '#f87171';
-                        err.textContent = (r.errors || ['render failed']).join('; ');
-                        cell.appendChild(err);
-                    }
-                    grid.appendChild(cell);
-                });
-                status.textContent = failures
-                    ? `${failures} size(s) failed`
-                    : `${(data.results || []).length} sizes rendered`;
-            } catch (e) {
-                status.textContent = `Network error: ${e.message}`;
-            } finally {
-                btn.disabled = false;
-                btn.textContent = 'All Sizes';
-            }
-        }
-
         // ---------- Zoom ----------
         function updateZoom() {
             const zoom = parseInt(document.getElementById('zoomSlider').value);

scripts/utils/wifi_monitor_daemon.py

@@ -78,17 +78,21 @@ class WiFiMonitorDaemon:
         
         while self.running:
             try:
-                # One combined check that also returns the state it observed —
-                # the previous flow fetched status before AND after the check
-                # on top of the check's own internal fetch, each one several
-                # nmcli subprocess forks, every 30s, forever.
-                (state_changed, updated_status, updated_ethernet,
-                 ap_active) = self.wifi_manager.check_and_manage_ap_mode_with_state()
-
+                # Get current status before checking
+                status = self.wifi_manager.get_wifi_status()
+                ethernet_connected = self.wifi_manager._is_ethernet_connected()
+                
+                # Check WiFi status and manage AP mode
+                state_changed = self.wifi_manager.check_and_manage_ap_mode()
+                
+                # Get updated status after check
+                updated_status = self.wifi_manager.get_wifi_status()
+                updated_ethernet = self.wifi_manager._is_ethernet_connected()
+                
                 current_state = {
                     'connected': updated_status.connected,
                     'ethernet_connected': updated_ethernet,
-                    'ap_active': ap_active,
+                    'ap_active': updated_status.ap_mode_active,
                     'ssid': updated_status.ssid
                 }
                 
@@ -105,7 +109,7 @@ class WiFiMonitorDaemon:
                     else:
                         logger.debug("Ethernet not connected")
                     
-                    if ap_active:
+                    if updated_status.ap_mode_active:
                         logger.info(f"AP mode ACTIVE - SSID: {ap_ssid} (IP: 192.168.4.1)")
                     else:
                         logger.debug("AP mode inactive")
@@ -119,16 +123,16 @@ class WiFiMonitorDaemon:
                     # Log periodic status (less verbose)
                     if updated_status.connected:
                         logger.debug(f"Status check: WiFi={updated_status.ssid} ({updated_status.signal}%), "
-                                   f"Ethernet={updated_ethernet}, AP={ap_active}")
+                                   f"Ethernet={updated_ethernet}, AP={updated_status.ap_mode_active}")
                     else:
-                        logger.debug(f"Status check: WiFi=disconnected, Ethernet={updated_ethernet}, AP={ap_active}")
+                        logger.debug(f"Status check: WiFi=disconnected, Ethernet={updated_ethernet}, AP={updated_status.ap_mode_active}")
                 
                 # Escalating recovery: if nmcli reports connected but actual internet
                 # is unreachable for several consecutive checks, restart NetworkManager.
                 # This is done HERE (not inside check_and_manage_ap_mode) to keep the
                 # AP-enable trigger clean and avoid false-positive AP enables from
                 # transient packet loss on otherwise working WiFi.
-                if updated_status.connected and not ap_active:
+                if updated_status.connected and not updated_status.ap_mode_active:
                     if not self.wifi_manager.check_internet_connectivity():
                         self._consecutive_internet_failures += 1
                         logger.warning(

src/__init__.py

@@ -4,5 +4,5 @@ LEDMatrix Display System
 Core source package for the LED Matrix Display project.
 """
 
-__version__ = "3.1.0"
+__version__ = "1.0.0"
 

src/adaptive_images.py

@@ -1,174 +0,0 @@
-"""
-Adaptive image fitting for plugins — the image counterpart to
-src/adaptive_layout.py's text fitting.
-
-Promotes the proven in-field image patterns into one shared helper so
-plugins stop hand-copying resize/cache code:
-
-- "crop transparent padding, then fill the row height" (football/hockey
-  logo pattern) -> ``crop_to_ink=True, mode="fill_height"``
-- "crop-to-fill with a top anchor for faces" (masters-tournament headshot
-  pattern) -> ``mode="cover", anchor="top"``
-- "letterbox to fit, centered on a background" (static-image pattern)
-  -> ``mode="contain"``
-- NEAREST for pixel art/flags vs LANCZOS for photos (masters flag pattern)
-  -> ``resample=RESAMPLE_NEAREST``
-
-Unlike PIL's ``thumbnail()`` (downscale-only — the reason plugin imagery
-stays tiny on big panels), ``fit_image`` upscales by default so content
-genuinely adapts to larger displays; pass ``upscale=False`` for the old
-behavior.
-
-Use via ``LayoutContext.fit_image(...)`` (cached per panel size) or
-``BasePlugin.draw_image(...)``; the module-level functions are the
-uncached primitives.
-"""
-
-from dataclasses import dataclass
-from typing import Any, Optional, Tuple
-
-from PIL import Image
-
-# The one Pillow >= 9.1 compat shim (replaces the per-plugin copies).
-try:
-    RESAMPLE_LANCZOS = Image.Resampling.LANCZOS
-    RESAMPLE_NEAREST = Image.Resampling.NEAREST
-except AttributeError:  # Pillow < 9.1
-    RESAMPLE_LANCZOS = Image.LANCZOS
-    RESAMPLE_NEAREST = Image.NEAREST
-
-FIT_MODES = ("contain", "cover", "fill_height", "stretch")
-
-
-@dataclass(frozen=True)
-class ImageFitResult:
-    """A processed RGBA copy of a source image, sized for a target box."""
-    image: Image.Image
-    width: int
-    height: int
-    scale: float          # scale applied vs the (possibly ink-cropped) source
-    mode: str
-    source_size: Tuple[int, int]
-
-    @property
-    def is_empty(self) -> bool:
-        return self.width <= 0 or self.height <= 0
-
-
-_EMPTY_IMAGE = Image.new("RGBA", (1, 1), (0, 0, 0, 0))
-
-
-def _empty_result(mode: str, source_size: Tuple[int, int]) -> ImageFitResult:
-    return ImageFitResult(_EMPTY_IMAGE, 0, 0, 0.0, mode, source_size)
-
-
-def _box_dims(box: Any) -> Tuple[int, int]:
-    """Accept a Region (duck-typed .w/.h) or a (w, h) tuple."""
-    if hasattr(box, "w") and hasattr(box, "h"):
-        return (int(box.w), int(box.h))
-    w, h = box
-    return (int(w), int(h))
-
-
-def fit_image(img: Image.Image, box: Any, *, mode: str = "contain",
-              crop_to_ink: bool = False, anchor: str = "center",
-              resample: Any = None, upscale: bool = True) -> ImageFitResult:
-    """Fit an image into a box, preserving crispness policy per content type.
-
-    Args:
-        img: Source PIL image (any mode; output is always RGBA).
-        box: Region or (w, h) target box.
-        mode: "contain" (letterbox), "cover" (crop-to-fill),
-              "fill_height" (height == box height, contain-capped by width),
-              "stretch" (exact resize).
-        crop_to_ink: Trim fully-transparent padding (getbbox) before fitting —
-              logos shipped with generous padding otherwise render small.
-        anchor: For "cover" crops: "center" or "top" (keeps faces/tops).
-        resample: PIL resampling filter; defaults to RESAMPLE_LANCZOS.
-              Use RESAMPLE_NEAREST for pixel art, flags, and sprite icons.
-        upscale: Allow scaling above source size (default True — the adaptive
-              point). False mimics the legacy thumbnail() behavior.
-    """
-    if mode not in FIT_MODES:
-        raise ValueError(f"Unknown fit mode '{mode}' (expected one of {FIT_MODES})")
-    box_w, box_h = _box_dims(box)
-    if box_w <= 0 or box_h <= 0 or img.width <= 0 or img.height <= 0:
-        return _empty_result(mode, img.size)
-
-    resample = RESAMPLE_LANCZOS if resample is None else resample
-
-    work = img if img.mode == "RGBA" else img.convert("RGBA")
-    if crop_to_ink:
-        bbox = work.getbbox()
-        if bbox is None:  # fully transparent
-            return _empty_result(mode, img.size)
-        work = work.crop(bbox)
-
-    src_w, src_h = work.size
-
-    if mode == "stretch":
-        out = work.resize((box_w, box_h), resample)
-        return ImageFitResult(out, box_w, box_h, box_w / src_w, mode, (src_w, src_h))
-
-    if mode == "cover":
-        scale = max(box_w / src_w, box_h / src_h)
-        if not upscale:
-            scale = min(scale, 1.0)
-        scaled_w = max(1, round(src_w * scale))
-        scaled_h = max(1, round(src_h * scale))
-        out = work.resize((scaled_w, scaled_h), resample)
-        # Crop the overhang down to the box (only when the scaled image is
-        # larger; with upscale=False it may be smaller and is left as-is).
-        crop_w, crop_h = min(box_w, scaled_w), min(box_h, scaled_h)
-        left = (scaled_w - crop_w) // 2
-        top = 0 if anchor == "top" else (scaled_h - crop_h) // 2
-        out = out.crop((left, top, left + crop_w, top + crop_h))
-        return ImageFitResult(out, out.width, out.height, scale, mode, (src_w, src_h))
-
-    # contain / fill_height share the "preserve aspect, no crop" path
-    if mode == "fill_height":
-        scale = box_h / src_h
-        # contain-cap: never exceed the box width (football's logo_slot rule)
-        scale = min(scale, box_w / src_w)
-    else:  # contain
-        scale = min(box_w / src_w, box_h / src_h)
-    if not upscale:
-        scale = min(scale, 1.0)
-    out_w = max(1, round(src_w * scale))
-    out_h = max(1, round(src_h * scale))
-    if (out_w, out_h) == (src_w, src_h):
-        # No resize needed — but `work` may still BE the caller's original
-        # image (RGBA source, no ink crop). The result must always be an
-        # independent copy: LayoutContext caches ImageFitResults, and an
-        # aliased image would let later mutations of the source corrupt
-        # cached fits (or vice versa).
-        out = work.copy() if work is img else work
-    else:
-        out = work.resize((out_w, out_h), resample)
-    return ImageFitResult(out, out_w, out_h, scale, mode, (src_w, src_h))
-
-
-def draw_fitted_image(display_manager: Any, ifit: ImageFitResult, box: Any, *,
-                      align: str = "center", valign: str = "center",
-                      offset: Tuple[int, int] = (0, 0)) -> Optional[Tuple[int, int]]:
-    """Paste a fitted image aligned within a Region onto the display canvas.
-
-    Pastes with the image's own alpha mask. Returns the (x, y) actually used
-    so callers can position adjacent decorations, or None when nothing was
-    drawn (empty fit / no canvas).
-    """
-    if ifit is None or ifit.is_empty:
-        return None
-    image = getattr(display_manager, "image", None)
-    if image is None:
-        return None
-    if hasattr(box, "align_xy"):
-        x, y = box.align_xy(ifit.width, ifit.height, align, valign)
-    else:
-        box_w, box_h = _box_dims(box)
-        x = (box_w - ifit.width) // 2
-        y = (box_h - ifit.height) // 2
-    x += int(offset[0])
-    y += int(offset[1])
-    image.paste(ifit.image, (x, y), ifit.image)
-    return (x, y)

src/adaptive_layout.py

@@ -1,746 +0,0 @@
-"""
-Adaptive layout and font scaling helpers for plugins.
-
-Generalizes the three size-adaptation patterns proven in the plugin
-ecosystem into small composable core helpers, so plugins render legibly on
-any panel size (64x32, 128x32, 96x48, 128x64, 256x64, ...) without
-hand-tuned per-display layouts:
-
-- Region: integer rect algebra (bands, columns, weighted splits, centering).
-  Regions partition space, so text bands can't overlap by construction —
-  replacing the magic ``y = 1`` / ``y = height - 7`` offsets tuned for 128x32.
-- Font ladders: ordered (family, size) steps known to render crisply.
-  Pixel fonts (BDF, PressStart2P) only look right at native/integer sizes,
-  so fonts are never scaled continuously — fitting walks a ladder from the
-  largest rung down until the measured text fits the target box. This is
-  baseball-scoreboard's fallback-ladder pattern promoted to core.
-- LayoutContext: per-(width, height) facts — breakpoint tiers
-  (masters-tournament's pattern), a geometry scale factor vs. a declared
-  design size (f1-scoreboard's pattern), and cached fit-text queries.
-
-Everything is opt-in: plugins get a context via ``self.layout`` on
-BasePlugin (or construct one directly) and existing plugins are unaffected.
-
-Fonts are resolved through FontManager's catalog (family names are
-lowercased file stems from assets/fonts, e.g. "9x15", "tom-thumb", plus
-aliases like "press_start"). FitResult.font is a plain PIL font or
-freetype.Face, so it drops straight into DisplayManager.draw_text().
-"""
-
-import logging
-from collections import OrderedDict
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Union
-
-import freetype
-
-logger = logging.getLogger(__name__)
-
-# Height-based breakpoint tiers, smallest to largest. A 32px-tall panel is
-# the ecosystem baseline ("sm"); 96x48 lands in "md"; 128x64 in "lg".
-_HEIGHT_TIERS: Tuple[Tuple[str, int], ...] = (
-    ("xs", 16), ("sm", 32), ("md", 48), ("lg", 64), ("xl", 10 ** 9),
-)
-TIER_ORDER: Tuple[str, ...] = tuple(name for name, _ in _HEIGHT_TIERS)
-
-_WIDTH_TIERS: Tuple[Tuple[str, int], ...] = (
-    ("narrow", 64), ("normal", 128), ("wide", 256), ("ultrawide", 10 ** 9),
-)
-WIDTH_TIER_ORDER: Tuple[str, ...] = tuple(name for name, _ in _WIDTH_TIERS)
-
-# The panel size most existing plugins were authored against.
-DEFAULT_DESIGN_SIZE: Tuple[int, int] = (128, 32)
-
-
-@dataclass(frozen=True)
-class Region:
-    """An integer rectangle. Carving methods return sub-Regions clamped to
-    non-negative dimensions, so degenerate panels never produce negative
-    boxes — a band request larger than the region simply consumes it all."""
-
-    x: int
-    y: int
-    w: int
-    h: int
-
-    def __post_init__(self):
-        object.__setattr__(self, "w", max(0, int(self.w)))
-        object.__setattr__(self, "h", max(0, int(self.h)))
-        object.__setattr__(self, "x", int(self.x))
-        object.__setattr__(self, "y", int(self.y))
-
-    @property
-    def right(self) -> int:
-        return self.x + self.w
-
-    @property
-    def bottom(self) -> int:
-        return self.y + self.h
-
-    @property
-    def center(self) -> Tuple[int, int]:
-        return (self.x + self.w // 2, self.y + self.h // 2)
-
-    # ---- carving -----------------------------------------------------
-
-    def inset(self, dx: int, dy: Optional[int] = None) -> "Region":
-        """Shrink by dx horizontally and dy (default dx) vertically, each side."""
-        if dy is None:
-            dy = dx
-        return Region(self.x + dx, self.y + dy, self.w - 2 * dx, self.h - 2 * dy)
-
-    def offset(self, dx: int, dy: int) -> "Region":
-        """Translate without resizing — the hook for user x/y-offset
-        customization: compute regions first, then apply the user's
-        configured offsets as a final translation."""
-        return Region(self.x + dx, self.y + dy, self.w, self.h)
-
-    def top_band(self, h: int) -> "Region":
-        return Region(self.x, self.y, self.w, min(h, self.h))
-
-    def bottom_band(self, h: int) -> "Region":
-        h = min(h, self.h)
-        return Region(self.x, self.bottom - h, self.w, h)
-
-    def middle(self, top_h: int = 0, bottom_h: int = 0) -> "Region":
-        """What remains between a top band and a bottom band."""
-        return Region(self.x, self.y + top_h, self.w, self.h - top_h - bottom_h)
-
-    def left_col(self, w: int) -> "Region":
-        return Region(self.x, self.y, min(w, self.w), self.h)
-
-    def right_col(self, w: int) -> "Region":
-        w = min(w, self.w)
-        return Region(self.right - w, self.y, w, self.h)
-
-    def split_h(self, *weights: float, gap: int = 0) -> List["Region"]:
-        """Side-by-side columns sized by weight; gaps between them."""
-        sizes = _weighted_sizes(self.w, weights, gap)
-        cols, cursor = [], self.x
-        for size in sizes:
-            cols.append(Region(cursor, self.y, size, self.h))
-            cursor += size + gap
-        return cols
-
-    def split_v(self, *weights: float, gap: int = 0) -> List["Region"]:
-        """Stacked rows sized by weight; gaps between them."""
-        sizes = _weighted_sizes(self.h, weights, gap)
-        rows, cursor = [], self.y
-        for size in sizes:
-            rows.append(Region(self.x, cursor, self.w, size))
-            cursor += size + gap
-        return rows
-
-    # ---- placement ---------------------------------------------------
-
-    def align_xy(self, w: int, h: int, align: str = "center",
-                 valign: str = "center") -> Tuple[int, int]:
-        """Top-left position for a w x h box aligned within this region.
-        align: left|center|right; valign: top|center|bottom."""
-        if align == "left":
-            x = self.x
-        elif align == "right":
-            x = self.right - w
-        else:
-            x = self.x + (self.w - w) // 2
-        if valign == "top":
-            y = self.y
-        elif valign == "bottom":
-            y = self.bottom - h
-        else:
-            y = self.y + (self.h - h) // 2
-        return (x, y)
-
-    def center_xy(self, w: int, h: int) -> Tuple[int, int]:
-        return self.align_xy(w, h)
-
-    def contains(self, w: int, h: int) -> bool:
-        return w <= self.w and h <= self.h
-
-
-def _weighted_sizes(total: int, weights: Sequence[float], gap: int) -> List[int]:
-    """Integer sizes proportional to weights, remainder spread left-to-right."""
-    if not weights:
-        return []
-    usable = max(0, total - gap * (len(weights) - 1))
-    weight_sum = sum(weights) or 1
-    sizes = [int(usable * w / weight_sum) for w in weights]
-    remainder = usable - sum(sizes)
-    for i in range(remainder):
-        sizes[i % len(sizes)] += 1
-    return sizes
-
-
-# ---------------------------------------------------------------------------
-# Font ladders
-# ---------------------------------------------------------------------------
-
-@dataclass(frozen=True)
-class FontStep:
-    """One rung: a FontManager catalog family at a size it renders crisply."""
-    family: str
-    size_px: int
-
-
-FontLadder = Tuple[FontStep, ...]
-
-# X11 BDF bitmap fonts at their native pixel sizes, largest to smallest —
-# baseball-scoreboard's fallback ladder extended upward. Same-height rungs
-# are ordered widest first so width-constrained text steps to a narrower
-# face before dropping a size.
-LADDER_GRID: FontLadder = (
-    FontStep("10x20", 20),
-    FontStep("9x18", 18),
-    FontStep("9x15", 15),
-    FontStep("8x13", 13),
-    FontStep("7x13", 13),
-    FontStep("6x13", 13),
-    FontStep("6x12", 12),
-    FontStep("6x10", 10),
-    FontStep("6x9", 9),
-    FontStep("5x8", 8),
-    FontStep("5x7", 7),
-    FontStep("4x6", 6),
-    FontStep("tom-thumb", 6),
-)
-
-# PressStart2P at integer multiples of its 8px pixel grid only — fractional
-# sizes blur a pixel font. For headline text (clocks, scores).
-LADDER_ARCADE: FontLadder = (
-    FontStep("press_start", 32),
-    FontStep("press_start", 24),
-    FontStep("press_start", 16),
-    FontStep("press_start", 8),
-)
-
-LADDER_DEFAULT: FontLadder = LADDER_GRID
-
-ELLIPSIS = "…"
-
-
-@dataclass(frozen=True)
-class FitResult:
-    """A fitted font plus the ink metrics of the (possibly ellipsized) text.
-
-    ``y_offset`` is the gap between the y passed to draw_text() and where
-    ink actually starts; subtract it from the desired ink-top position when
-    drawing (draw_fitted_text does this for you).
-    """
-    font: Any
-    family: str
-    size_px: int
-    text: str
-    width: int
-    height: int
-    baseline: int
-    y_offset: int
-    fits: bool
-    line_height: int = 0
-
-
-def measure_ink(text: str, font: Any) -> Tuple[int, int, int, int]:
-    """Measure the ink box of text: (width, height, baseline, y_offset).
-
-    y_offset is the distance from the y coordinate DisplayManager.draw_text()
-    is given to the top of the actual ink — PIL draws TTF from the em-box
-    top and _draw_bdf_text derives the baseline from y + ascender, so both
-    leave a font-dependent gap that matters when centering in short bands.
-    """
-    if isinstance(font, freetype.Face):
-        width = 0
-        ascender = font.size.ascender >> 6
-        ink_top, ink_bottom = None, None
-        for char in text:
-            font.load_char(char)
-            width += font.glyph.advance.x >> 6
-            rows = font.glyph.bitmap.rows
-            if rows:
-                top = ascender - font.glyph.bitmap_top
-                ink_top = top if ink_top is None else min(ink_top, top)
-                ink_bottom = top + rows if ink_bottom is None else max(ink_bottom, top + rows)
-        if ink_top is None:
-            ink_top, ink_bottom = 0, 0
-        return (width, ink_bottom - ink_top, ascender, ink_top)
-    bbox = font.getbbox(text)
-    return (bbox[2] - bbox[0], bbox[3] - bbox[1], -bbox[1], bbox[1])
-
-
-def font_line_height(font: Any) -> int:
-    """Recommended line spacing for a font (matches DisplayManager.get_font_height)."""
-    if isinstance(font, freetype.Face):
-        return font.size.height >> 6
-    ascent, descent = font.getmetrics()
-    return ascent + descent
-
-
-def measure_font_crispness(font: Any, sample_text: str = "Ay0",
-                           canvas_size: Tuple[int, int] = (250, 60)) -> float:
-    """Fraction of the rendered sample's ink-bbox pixels that are neither
-    pure black nor pure white — i.e. antialiased.
-
-    BDF (freetype.Face) glyphs are true bitmaps and always render at 0.0.
-    "Pixel-style" TTFs (PressStart2P, and similar fonts bundled for
-    plugins that draw through ImageDraw.text() and so can't take a BDF
-    face) are NOT automatically crisp at arbitrary sizes — PIL antialiases
-    TTF outlines by default, and a pixel-grid font only lands on whole
-    pixels at specific sizes (for PressStart2P: exact multiples of 8).
-    Requesting an unverified size silently produces soft/blurry glyphs on
-    an LED panel, which reads as fuzzy compared to a true BDF rung.
-
-    Use this to vet any custom FontLadder rung that mixes TTF fonts before
-    shipping it — see test_adaptive_layout.py::test_ladder_is_crisp for the
-    pattern. A rung should score 0.0 (or very close, to allow for the odd
-    diagonal stroke) before it belongs in a "crisp" ladder.
-    """
-    if isinstance(font, freetype.Face):
-        return 0.0
-    from PIL import Image, ImageDraw
-    img = Image.new("L", canvas_size, 0)
-    ImageDraw.Draw(img).text((2, 2), sample_text, font=font, fill=255)
-    bbox = img.getbbox()
-    if bbox is None:
-        return 0.0
-    pixels = img.crop(bbox).tobytes()
-    pure = sum(1 for p in pixels if p == 0 or p == 255)
-    return (len(pixels) - pure) / len(pixels)
-
-
-class LayoutContext:
-    """Per-render-size layout facts and fit-text queries for one panel size.
-
-    Construct once per (width, height); BasePlugin.layout does this and
-    rebuilds automatically when the logical display size changes.
-    """
-
-    def __init__(self, width: int, height: int, font_manager: Any,
-                 design_size: Tuple[int, int] = DEFAULT_DESIGN_SIZE):
-        self.width = int(width)
-        self.height = int(height)
-        self.font_manager = font_manager
-        self.design_size = design_size
-        self.bounds = Region(0, 0, self.width, self.height)
-        self.aspect = self.width / max(1, self.height)
-        self.tier = _pick_tier(_HEIGHT_TIERS, self.height)
-        self.width_tier = _pick_tier(_WIDTH_TIERS, self.width)
-        self.is_wide_short = self.aspect >= 2.5 and self.height <= 32
-        design_w, design_h = design_size
-        # Geometry scale only (gaps, icon/logo sizes) — never applied to
-        # fonts, which step between crisp ladder rungs instead.
-        self.scale = min(self.width / max(1, design_w),
-                         self.height / max(1, design_h))
-        # LRU-bounded: entries are small, but keys embed the fitted TEXT —
-        # a plugin fitting changing text (a live game clock, a ticker) on a
-        # 24/7 service would otherwise grow this without bound.
-        self._fit_cache: "OrderedDict[Any, FitResult]" = OrderedDict()
-        # LRU-bounded (images are big). Entries hold a strong reference to
-        # the source image when keyed by id() so the id can't be recycled
-        # out from under the cache.
-        self._image_cache: "OrderedDict[Any, Tuple[Any, Any]]" = OrderedDict()
-
-    _IMAGE_CACHE_MAX = 64
-    _FIT_CACHE_MAX = 512
-
-    def _fit_cache_get(self, key: Any) -> Optional["FitResult"]:
-        cached = self._fit_cache.get(key)
-        if cached is not None:
-            self._fit_cache.move_to_end(key)
-        return cached
-
-    def _fit_cache_put(self, key: Any, result: "FitResult") -> None:
-        self._fit_cache[key] = result
-        while len(self._fit_cache) > self._FIT_CACHE_MAX:
-            self._fit_cache.popitem(last=False)
-
-    # ---- the three adaptation patterns --------------------------------
-
-    def px(self, base: int, minimum: int = 1, maximum: Optional[int] = None) -> int:
-        """Scale a design-size pixel measurement (f1's pattern): gaps,
-        icon sizes, logo slots. Clamped to [minimum, maximum]."""
-        value = max(minimum, round(base * self.scale))
-        if maximum is not None:
-            value = min(value, maximum)
-        return value
-
-    def by_tier(self, mapping: Dict[str, Any], default: Any = None) -> Any:
-        """Pick the value for the nearest defined tier at-or-below the
-        panel's height tier (masters' pattern). Falls forward to the
-        smallest defined tier above, then to default.
-
-        by_tier({"sm": 10, "lg": 18}) -> 10 on 128x32, 18 on 128x64.
-        Keys may also use width tiers ("narrow", "wide", ...)."""
-        order = TIER_ORDER if any(k in TIER_ORDER for k in mapping) else WIDTH_TIER_ORDER
-        current = self.tier if order is TIER_ORDER else self.width_tier
-        idx = order.index(current)
-        for name in reversed(order[: idx + 1]):
-            if name in mapping:
-                return mapping[name]
-        for name in order[idx + 1:]:
-            if name in mapping:
-                return mapping[name]
-        return default
-
-    def fit_text(self, text: str, box: Union[Region, Tuple[int, int]],
-                 ladder: FontLadder = LADDER_DEFAULT,
-                 ellipsis: bool = True) -> FitResult:
-        """Largest ladder rung whose rendered text fits the box (baseball's
-        pattern). If even the smallest rung is too wide, the text is
-        ellipsized to fit (unless ellipsis=False); fits=False only when no
-        acceptable rendering exists."""
-        box_w, box_h = _box_dims(box)
-        key = ("text", text, box_w, box_h, ladder, ellipsis)
-        cached = self._fit_cache_get(key)
-        if cached is not None:
-            return cached
-        result = self._walk_ladder(text, ladder, box_w, box_h, ellipsis)
-        self._fit_cache_put(key, result)
-        return result
-
-    def fit_text_proportional(self, text: str, box: Union[Region, Tuple[int, int]],
-                              base_size_px: int, ladder: FontLadder = LADDER_DEFAULT,
-                              ellipsis: bool = True,
-                              scale: Optional[float] = None) -> FitResult:
-        """Ladder rung closest to (but not exceeding) ``base_size_px * scale``
-        that still fits the box — proportional sizing instead of ``fit_text``'s
-        "always maximize" behavior.
-
-        Use this when several independently-fitted elements need to stay
-        visually harmonious as the panel grows (e.g. a scoreboard's score,
-        status, and detail text) — ``fit_text`` maximizes each one within
-        its own region, which can make one element balloon out of
-        proportion to its neighbors (a huge score overlapping logos it fit
-        fine at the design size) even though every individual pick is
-        independently "correct". ``base_size_px`` is the size that element
-        renders at on the design size (``design_size``, typically 128x32)
-        — commonly a plugin's existing classic/fixed font size for that
-        element.
-
-        ``scale`` defaults to ``self.scale`` (the same conservative
-        min(width_ratio, height_ratio) factor ``px()`` uses — safe for
-        content whose aspect ratio matters). Pass an explicit axis-specific
-        value when the surrounding composition already scales that way —
-        e.g. a scoreboard whose logos scale with height alone
-        (``logo_slot = min(height, width // 2)``) should size its score
-        text by ``height / design_height`` too, or its text will look
-        under-scaled next to bigger logos on a panel that only grew taller.
-
-        Falls back to the smallest rung when even that exceeds the target
-        (a tiny scale factor), and to fit_text's ordinary smaller-rung
-        fallback when the closest-to-target rung doesn't actually fit the
-        box.
-        """
-        box_w, box_h = _box_dims(box)
-        effective_scale = self.scale if scale is None else scale
-        key = ("text_prop", text, box_w, box_h, ladder, base_size_px, ellipsis, effective_scale)
-        cached = self._fit_cache_get(key)
-        if cached is not None:
-            return cached
-        target = base_size_px * effective_scale
-        eligible = [step for step in ladder if step.size_px <= target]
-        candidates = eligible if eligible else (min(ladder, key=lambda s: s.size_px),)
-        result = self._walk_ladder(text, candidates, box_w, box_h, ellipsis)
-        self._fit_cache_put(key, result)
-        return result
-
-    def _walk_ladder(self, text: str, ladder: Sequence[FontStep],
-                     box_w: int, box_h: int, ellipsis: bool) -> FitResult:
-        """Shared by fit_text/fit_text_proportional: first ladder entry (in
-        the order given) whose rendered text fits, ellipsizing the last one
-        tried if none do."""
-        result = None
-        for step in ladder:
-            font = self.font_manager.get_font(step.family, step.size_px)
-            width, height, baseline, y_offset = measure_ink(text, font)
-            result = FitResult(font, step.family, step.size_px, text,
-                               width, height, baseline, y_offset,
-                               fits=(width <= box_w and height <= box_h),
-                               line_height=font_line_height(font))
-            if result.fits:
-                break
-
-        if result is not None and not result.fits and ellipsis:
-            short = self.ellipsize(text, result.font, box_w)
-            width, height, baseline, y_offset = measure_ink(short, result.font)
-            result = FitResult(result.font, result.family, result.size_px,
-                               short, width, height, baseline, y_offset,
-                               fits=(width <= box_w and height <= box_h),
-                               line_height=result.line_height)
-        return result
-
-    def fit_lines(self, lines: Sequence[str], box: Union[Region, Tuple[int, int]],
-                  ladder: FontLadder = LADDER_DEFAULT,
-                  spacing: int = 1) -> FitResult:
-        """Largest rung where every line fits the box width and the stacked
-        lines (line_height + spacing apart) fit the box height. Measures the
-        actual strings, so a long line pushes the ladder down a rung a short
-        one wouldn't (baseball's multiline pattern). Text is the widest line."""
-        box_w, box_h = _box_dims(box)
-        key = ("lines", tuple(lines), box_w, box_h, ladder, spacing)
-        cached = self._fit_cache_get(key)
-        if cached is not None:
-            return cached
-
-        rows = max(1, len(lines))
-        result = None
-        for step in ladder:
-            font = self.font_manager.get_font(step.family, step.size_px)
-            line_h = font_line_height(font)
-            widest, metrics = "", (0, 0, 0, 0)
-            for line in lines:
-                m = measure_ink(line, font)
-                if m[0] >= metrics[0]:
-                    widest, metrics = line, m
-            total_h = rows * line_h + (rows - 1) * spacing
-            result = FitResult(font, step.family, step.size_px, widest,
-                               metrics[0], metrics[1], metrics[2], metrics[3],
-                               fits=(metrics[0] <= box_w and total_h <= box_h),
-                               line_height=line_h)
-            if result.fits:
-                break
-
-        self._fit_cache_put(key, result)
-        return result
-
-    def font_for_rows(self, rows: int, box_h: int,
-                      ladder: FontLadder = LADDER_GRID) -> FitResult:
-        """Largest rung whose line height lets `rows` rows fit in box_h
-        (baseball's traditional-scoreboard pattern). Measures a digit/cap
-        sample rather than specific strings."""
-        key = ("rows", rows, box_h, ladder)
-        cached = self._fit_cache_get(key)
-        if cached is not None:
-            return cached
-
-        sample = "0Ay"
-        result = None
-        for step in ladder:
-            font = self.font_manager.get_font(step.family, step.size_px)
-            line_h = font_line_height(font)
-            width, height, baseline, y_offset = measure_ink(sample, font)
-            result = FitResult(font, step.family, step.size_px, sample,
-                               width, height, baseline, y_offset,
-                               fits=(max(1, rows) * line_h <= box_h),
-                               line_height=line_h)
-            if result.fits:
-                break
-
-        self._fit_cache_put(key, result)
-        return result
-
-    # ---- images ---------------------------------------------------------
-
-    def fit_image(self, img: Any, box: Union[Region, Tuple[int, int]], *,
-                  mode: str = "contain", crop_to_ink: bool = False,
-                  anchor: str = "center", resample: Any = None,
-                  upscale: bool = True, cache_key: Any = None) -> Any:
-        """Fit an image into a box (see src/adaptive_images.py for modes),
-        cached per (image, box size, options) for this panel size.
-
-        Prefer a stable ``cache_key`` (e.g. "logo:KC") for images that get
-        reloaded — the default id()-based key is safe (the entry pins the
-        source image) but misses across reloads of the same content.
-        """
-        from src.adaptive_images import fit_image as _fit_image
-
-        box_w, box_h = _box_dims(box)
-        resample_name = getattr(resample, "name", repr(resample)) if resample is not None else "default"
-        identity = cache_key if cache_key is not None else ("id", id(img))
-        key = ("image", identity, img.size, box_w, box_h, mode,
-               crop_to_ink, anchor, resample_name, upscale)
-
-        cached = self._image_cache.get(key)
-        if cached is not None:
-            self._image_cache.move_to_end(key)
-            return cached[0]
-
-        result = _fit_image(img, (box_w, box_h), mode=mode,
-                            crop_to_ink=crop_to_ink, anchor=anchor,
-                            resample=resample, upscale=upscale)
-        # Pin the source only for id()-keyed entries (see docstring).
-        self._image_cache[key] = (result, img if cache_key is None else None)
-        while len(self._image_cache) > self._IMAGE_CACHE_MAX:
-            self._image_cache.popitem(last=False)
-        return result
-
-    # ---- text utilities ------------------------------------------------
-
-    def ellipsize(self, text: str, font: Any, max_w: int) -> str:
-        """Trim text to fit max_w, appending an ellipsis. Returns '' when
-        not even the ellipsis fits."""
-        if measure_ink(text, font)[0] <= max_w:
-            return text
-        for end in range(len(text) - 1, 0, -1):
-            candidate = text[:end].rstrip() + ELLIPSIS
-            if measure_ink(candidate, font)[0] <= max_w:
-                return candidate
-        return ELLIPSIS if measure_ink(ELLIPSIS, font)[0] <= max_w else ""
-
-    def measure(self, text: str, font: Any) -> Tuple[int, int, int]:
-        """Ink (width, height, baseline) of text — see measure_ink."""
-        width, height, baseline, _ = measure_ink(text, font)
-        return (width, height, baseline)
-
-    def clear_cache(self) -> None:
-        """Drop cached fit results (call after fonts are reloaded)."""
-        self._fit_cache.clear()
-        self._image_cache.clear()
-
-
-def _pick_tier(tiers: Tuple[Tuple[str, int], ...], value: int) -> str:
-    for name, limit in tiers:
-        if value <= limit:
-            return name
-    return tiers[-1][0]
-
-
-def _box_dims(box: Union[Region, Tuple[int, int]]) -> Tuple[int, int]:
-    if isinstance(box, Region):
-        return (box.w, box.h)
-    w, h = box
-    return (int(w), int(h))
-
-
-def draw_fitted_text(display_manager: Any, fit: FitResult,
-                     box: Union[Region, Tuple[int, int]],
-                     color: Tuple[int, int, int] = (255, 255, 255),
-                     align: str = "center", valign: str = "center") -> None:
-    """Draw a FitResult's text aligned within a Region via
-    DisplayManager.draw_text(), compensating for the font's ink offset so
-    the ink (not the em box) is what gets aligned."""
-    region = box if isinstance(box, Region) else Region(0, 0, box[0], box[1])
-    x, y = region.align_xy(fit.width, fit.height, align, valign)
-    display_manager.draw_text(fit.text, x=x, y=y - fit.y_offset,
-                              color=color, font=fit.font)
-
-
-# ---------------------------------------------------------------------------
-# Composite layouts — the region arrangements repeated across plugins,
-# expressed as Region math so migrated plugins stop hand-copying coordinate
-# formulas. Deliberately tiny: these return Regions, they don't draw.
-# ---------------------------------------------------------------------------
-
-@dataclass(frozen=True)
-class ScoreboardRegions:
-    """The two-logos-plus-center-score card shared by the sports plugins."""
-    bounds: Region
-    logo_slot: int        # width of each logo slot: min(H, W // 2), center-reserved
-    away_slot: Region     # left logo slot
-    home_slot: Region     # right logo slot
-    center_col: Region    # column between the slots (>= min_center_fraction of width)
-    status_band: Region   # top band (replaces the magic y = 1)
-    score_area: Region    # center_col's true width, between the bands (replaces y = H//2 - 3)
-    detail_band: Region   # bottom band (replaces the magic y = H - 7)
-    bottom_left: Region   # bottom corner: away records / timeouts
-    bottom_right: Region  # bottom corner: home records / timeouts
-
-
-def scoreboard_regions(bounds: Region, *, ctx: Optional["LayoutContext"] = None,
-                       status_h: Optional[int] = None,
-                       detail_h: Optional[int] = None,
-                       min_center_fraction: float = 0.15,
-                       min_center_design_px: int = 40,
-                       score_bleed_fraction: float = 0.5) -> ScoreboardRegions:
-    """Carve a game-card Region into the standard scoreboard arrangement.
-
-    Encodes the invariant duplicated across the sports plugins:
-    ``logo_slot = min(height, width // 2)`` (capped at half the card so the
-    home slot never collapses), away logo centered in the left slot, home in
-    the right.
-
-    That formula alone has a blind spot: at exactly 2:1 aspect ratio
-    (width == 2 * height — a very common shape, e.g. two, four, or more
-    square modules stacked into a taller panel) ``width // 2`` and
-    ``height`` are equal, so the two logo slots claim the *entire* width
-    and leave zero pixels for a center column, no matter how large the
-    panel gets. It isn't a "small panel" problem: 96x48, 128x64, and
-    256x128 (all exactly 2:1) hit it identically, while wide panels like
-    the 128x32 design baseline or a 192x48/256x32 panel never do, because
-    height is already the tighter constraint there.
-
-    Two knobs fix it, both defaulted to values verified against the full
-    harness size spread (see test_adaptive_layout.py::TestScoreboardRegions):
-
-    - ``min_center_fraction`` / ``min_center_design_px`` reserve at least
-      ``max(width * min_center_fraction, min_center_design_px * ctx.scale)``
-      for the center column, capping ``logo_slot`` further when needed. The
-      design-px term (scaled by the context's geometry factor, so it grows
-      on bigger panels like everything else in ``px()``) matters most on
-      small panels where a flat fraction alone reserves too little absolute
-      space for even a short score string. On wide panels the height
-      constraint already leaves more room than either reserves, so both are
-      a no-op there — 128x32/192x48-style layouts are unaffected.
-    - ``score_bleed_fraction`` extends the score's own *fit box* (not the
-      logo slots themselves) an extra ``logo_slot * score_bleed_fraction``
-      into each side — controlled, intentional overlap with the logo art,
-      the same way real broadcast scoreboards let a big score number's
-      edges cross into the team marks flanking it. Without this, on a
-      square-ish panel the center reserve alone can be too narrow for even
-      a modest score to render without truncating (`"17-21"` -> `"17-2…"`),
-      which is worse than a little overlap.
-
-    status_band and detail_band span the FULL card width and overlay the
-    logo slots — matching the classic layouts, where short outlined status/
-    date text is drawn over the logos without issue; only score_area (the
-    one element whose size actively grows with the panel) uses the
-    narrower, bleed-adjusted box. Band heights default to the classic
-    128x32 values, scaled by the context's geometry factor when one is
-    provided. Works on a full panel or on a scroll-mode card Region.
-    """
-    if status_h is None:
-        status_h = ctx.px(9, minimum=7) if ctx else 9
-    if detail_h is None:
-        detail_h = ctx.px(8, minimum=7) if ctx else 8
-
-    logo_slot = min(bounds.h, bounds.w // 2)
-    design_reserve = int(min_center_design_px * (ctx.scale if ctx else 1.0))
-    min_center_w = max(1, int(bounds.w * min_center_fraction), design_reserve)
-    max_logo_slot_by_center = max(1, (bounds.w - min_center_w) // 2)
-    logo_slot = min(logo_slot, max_logo_slot_by_center)
-    away_slot = bounds.left_col(logo_slot)
-    home_slot = bounds.right_col(logo_slot)
-    center_col = Region(bounds.x + logo_slot, bounds.y,
-                        bounds.w - 2 * logo_slot, bounds.h)
-    status_band = bounds.top_band(status_h)
-    detail_band = bounds.bottom_band(detail_h)
-    middle = bounds.middle(status_band.h, detail_band.h)
-    # score_area is the true center gap's width plus a controlled bleed
-    # into each logo slot (see score_bleed_fraction above) -- narrower than
-    # the full card width status/detail get, since it's the one element
-    # whose size actively grows with the panel and needs its *fit box* to
-    # reflect real available space, but generous enough that a short score
-    # string never has to truncate on a square-ish panel.
-    bleed = int(logo_slot * score_bleed_fraction)
-    score_area = Region(center_col.x - bleed, middle.y,
-                        center_col.w + 2 * bleed, middle.h)
-    bottom = bounds.bottom_band(detail_h)
-    return ScoreboardRegions(
-        bounds=bounds, logo_slot=logo_slot,
-        away_slot=away_slot, home_slot=home_slot, center_col=center_col,
-        status_band=status_band, score_area=score_area, detail_band=detail_band,
-        bottom_left=bottom.left_col(logo_slot),
-        bottom_right=bottom.right_col(logo_slot),
-    )
-
-
-@dataclass(frozen=True)
-class MediaRow:
-    """Art/icon on the left, text column on the right (music's idiom)."""
-    art: Region
-    body: Region
-
-
-def media_row(bounds: Region, *, ctx: Optional["LayoutContext"] = None,
-              square: bool = True, gap: Optional[int] = None) -> MediaRow:
-    """Split a Region into an art slot and a body column.
-
-    With ``square=True`` the art slot is bounds.h wide (album-art style);
-    otherwise it takes the left half. The gap defaults to 2px scaled by the
-    context's geometry factor.
-    """
-    if gap is None:
-        gap = ctx.px(2, minimum=1) if ctx else 2
-    art_w = bounds.h if square else bounds.w // 2
-    art_w = min(art_w, bounds.w)
-    art = bounds.left_col(art_w)
-    body = Region(bounds.x + art_w + gap, bounds.y,
-                  bounds.w - art_w - gap, bounds.h)
-    return MediaRow(art=art, body=body)

src/background_cache_mixin.py

@@ -0,0 +1,134 @@
+"""
+Background Cache Mixin for Sports Managers
+
+This mixin provides common caching functionality to eliminate code duplication
+across all sports managers. It implements the background service cache pattern
+where Recent/Upcoming managers consume data from the background service cache.
+"""
+
+import time
+from typing import Dict, Optional, Any, Callable
+
+
+class BackgroundCacheMixin:
+    """
+    Mixin class that provides background service cache functionality to sports managers.
+    
+    This mixin eliminates code duplication by providing a common implementation
+    for the background service cache pattern used across all sports managers.
+    
+    Note: For non-sports managers (weather, stocks, news, etc.), use
+    GenericCacheMixin instead. See src/generic_cache_mixin.py for details.
+    """
+    
+    def _fetch_data_with_background_cache(self, 
+                                        sport_key: str, 
+                                        api_fetch_method: Callable,
+                                        live_manager_class: type = None) -> Optional[Dict]:
+        """
+        Common logic for fetching data with background service cache support.
+        
+        This method implements the background service cache pattern:
+        1. Live managers always fetch fresh data
+        2. Recent/Upcoming managers try background cache first
+        3. Fallback to direct API call if background data unavailable
+        
+        Args:
+            sport_key: Sport identifier (e.g., 'nba', 'nfl', 'ncaa_fb')
+            api_fetch_method: Method to call for direct API fetch
+            live_manager_class: Class to check if this is a live manager
+            
+        Returns:
+            Cached or fresh data from API
+        """
+        start_time = time.time()
+        cache_hit = False
+        cache_source = None
+        
+        try:
+            # For Live managers, always fetch fresh data
+            if live_manager_class and isinstance(self, live_manager_class):
+                self.logger.info(f"[{sport_key.upper()}] Live manager - fetching fresh data")
+                result = api_fetch_method(use_cache=False)
+                cache_source = "live_fresh"
+            else:
+                # For Recent/Upcoming managers, try background service cache first
+                cache_key = self.cache_manager.generate_sport_cache_key(sport_key)
+                
+                # Check if background service has fresh data
+                if self.cache_manager.is_background_data_available(cache_key, sport_key):
+                    cached_data = self.cache_manager.get_background_cached_data(cache_key, sport_key)
+                    if cached_data:
+                        self.logger.info(f"[{sport_key.upper()}] Using background service cache for {cache_key}")
+                        result = cached_data
+                        cache_hit = True
+                        cache_source = "background_cache"
+                    else:
+                        self.logger.warning(f"[{sport_key.upper()}] Background cache check passed but no data returned for {cache_key}")
+                        result = None
+                        cache_source = "background_miss"
+                else:
+                    self.logger.info(f"[{sport_key.upper()}] Background data not available for {cache_key}")
+                    result = None
+                    cache_source = "background_unavailable"
+                
+                # Fallback to direct API call if background data not available
+                if result is None:
+                    self.logger.info(f"[{sport_key.upper()}] Fetching directly from API for {cache_key}")
+                    result = api_fetch_method(use_cache=True)
+                    cache_source = "api_fallback"
+            
+            # Record performance metrics
+            duration = time.time() - start_time
+            self.cache_manager.record_fetch_time(duration)
+            
+            # Log performance metrics
+            self._log_fetch_performance(sport_key, duration, cache_hit, cache_source)
+            
+            return result
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            self.logger.error(f"[{sport_key.upper()}] Error in background cache fetch after {duration:.2f}s: {e}")
+            self.cache_manager.record_fetch_time(duration)
+            raise
+    
+    def _log_fetch_performance(self, sport_key: str, duration: float, cache_hit: bool, cache_source: str):
+        """
+        Log detailed performance metrics for fetch operations.
+        
+        Args:
+            sport_key: Sport identifier
+            duration: Fetch operation duration in seconds
+            cache_hit: Whether this was a cache hit
+            cache_source: Source of the data (background_cache, api_fallback, etc.)
+        """
+        # Log basic performance info
+        self.logger.info(f"[{sport_key.upper()}] Fetch completed in {duration:.2f}s "
+                        f"(cache_hit={cache_hit}, source={cache_source})")
+        
+        # Log detailed metrics every 10 operations
+        if hasattr(self, '_fetch_count'):
+            self._fetch_count += 1
+        else:
+            self._fetch_count = 1
+            
+        if self._fetch_count % 10 == 0:
+            metrics = self.cache_manager.get_cache_metrics()
+            self.logger.info(f"[{sport_key.upper()}] Cache Performance Summary - "
+                           f"Hit Rate: {metrics['cache_hit_rate']:.2%}, "
+                           f"Background Hit Rate: {metrics['background_hit_rate']:.2%}, "
+                           f"API Calls Saved: {metrics['api_calls_saved']}")
+    
+    def get_cache_performance_summary(self) -> Dict[str, Any]:
+        """
+        Get cache performance summary for this manager.
+        
+        Returns:
+            Dictionary containing cache performance metrics
+        """
+        return self.cache_manager.get_cache_metrics()
+    
+    def log_cache_performance(self):
+        """Log current cache performance metrics."""
+        self.cache_manager.log_cache_metrics()

src/cache/disk_cache.py

@@ -10,7 +10,6 @@ import time
 import tempfile
 import logging
 import threading
-import zlib
 from typing import Dict, Any, Optional, Protocol
 from datetime import datetime
 
@@ -54,11 +53,6 @@ class DiskCache:
         self.cache_dir = cache_dir
         self.logger = logger or logging.getLogger(__name__)
         self._lock = threading.Lock()
-        # key -> adler32 of the last payload successfully written to the
-        # primary cache path; lets set() skip rewriting identical data
-        # (per-process only — worst case another process rewrites, never
-        # a missed write). Guarded by _lock.
-        self._write_digests: Dict[str, int] = {}
     
     def get_cache_path(self, key: str) -> Optional[str]:
         """
@@ -161,35 +155,10 @@ class DiskCache:
         cache_path = self.get_cache_path(key)
         if not cache_path:
             return
-
-        # Serialize once, compact (no indent): the payload is reused by every
-        # write path below, and cache files are machine-read only — indenting
-        # them just multiplied the bytes written to the SD card.
-        try:
-            payload = json.dumps(data, cls=DateTimeEncoder)
-        except (TypeError, ValueError) as e:
-            self.logger.warning("Cache data for key '%s' not serializable: %s", key, e)
-            return
-
-        digest = zlib.adler32(payload.encode('utf-8'))
-
+        
         try:
             # Atomic write to avoid partial/corrupt files
             with self._lock:
-                # Skip the disk entirely when this exact payload was already
-                # written for this key (plugins re-save unchanged API data
-                # every update cycle — each write is real SD-card wear).
-                # Refresh the file mtime so records that rely on it for TTL
-                # (no embedded 'timestamp') don't expire early; a metadata
-                # touch is journal-cheap compared to rewriting the data.
-                if self._write_digests.get(key) == digest:
-                    try:
-                        os.utime(cache_path, None)
-                        return
-                    except OSError:
-                        # File vanished or perms changed — fall through and write
-                        self._write_digests.pop(key, None)
-
                 tmp_dir = os.path.dirname(cache_path)
                 # Try to create temp file in cache directory first
                 # If that fails due to permissions, fall back to direct write
@@ -212,17 +181,13 @@ class DiskCache:
                         fd = None
                     
                     if tmp_path and fd is not None:
-                        # Atomic write with temp file. No fsync: os.replace
-                        # already guarantees readers never see a torn file,
-                        # and cache data is re-fetchable — forcing a disk
-                        # flush per write was the single biggest SD-card
-                        # wear source (dozens of fsyncs/min on API-heavy
-                        # installs) for data that can be re-downloaded.
+                        # Use atomic write with temp file
                         try:
                             with os.fdopen(fd, 'w', encoding='utf-8') as tmp_file:
-                                tmp_file.write(payload)
+                                json.dump(data, tmp_file, indent=4, cls=DateTimeEncoder)
+                                tmp_file.flush()
+                                os.fsync(tmp_file.fileno())
                             os.replace(tmp_path, cache_path)
-                            self._write_digests[key] = digest
                             # Set proper permissions: 660 (rw-rw----) for group-readable cache files
                             try:
                                 os.chmod(cache_path, 0o660)  # nosec B103 - intentional; web UI and service share a group
@@ -238,8 +203,9 @@ class DiskCache:
                         # Fallback: direct write (not atomic, but better than failing)
                         try:
                             with open(cache_path, 'w', encoding='utf-8') as cache_file:
-                                cache_file.write(payload)
-                            self._write_digests[key] = digest
+                                json.dump(data, cache_file, indent=4, cls=DateTimeEncoder)
+                                cache_file.flush()
+                                os.fsync(cache_file.fileno())
                             # Set proper permissions: 660 (rw-rw----) for group-readable cache files
                             try:
                                 os.chmod(cache_path, 0o660)  # nosec B103 - intentional; web UI and service share a group
@@ -263,12 +229,9 @@ class DiskCache:
                             pass
                         
                         if os.path.isdir(fallback_dir) and os.access(fallback_dir, os.W_OK):
-                            # NOTE: no digest record here — the fallback file
-                            # is a different path, so future sets must keep
-                            # retrying the primary location.
                             fallback_path = os.path.join(fallback_dir, os.path.basename(cache_path))
                             with open(fallback_path, 'w', encoding='utf-8') as tmp_file:
-                                tmp_file.write(payload)
+                                json.dump(data, tmp_file, indent=4, cls=DateTimeEncoder)
                             # Set proper permissions: 660 (rw-rw----) for group-readable cache files
                             try:
                                 os.chmod(fallback_path, 0o660)  # nosec B103 - intentional; web UI and service share a group
@@ -309,7 +272,6 @@ class DiskCache:
         
         with self._lock:
             if key:
-                self._write_digests.pop(key, None)
                 cache_path = self.get_cache_path(key)
                 if cache_path and os.path.exists(cache_path):
                     try:
@@ -318,7 +280,6 @@ class DiskCache:
                         self.logger.warning("Could not remove cache file %s: %s", cache_path, e)
             else:
                 # Clear all cache files
-                self._write_digests.clear()
                 if os.path.exists(self.cache_dir):
                     for filename in os.listdir(self.cache_dir):
                         if filename.endswith('.json'):

src/common/README.md

@@ -2,28 +2,6 @@
 
 This directory contains reusable utilities and helpers for LEDMatrix plugins and core modules.
 
-## Adaptive Layout & Images (`src/adaptive_layout.py`, `src/adaptive_images.py`)
-
-The recommended way to lay out plugins that render legibly on **any** panel
-size (64x32 through 256x128+) without hand-tuned coordinates. Re-exported
-from `src.common` for convenience; canonical import paths are
-`src.adaptive_layout` / `src.adaptive_images`.
-
-```python
-# Every BasePlugin already has self.layout and the draw helpers:
-regs = scoreboard_regions(self.layout.bounds, ctx=self.layout)
-self.draw_image(away_logo, regs.away_slot, mode="fill_height",
-                crop_to_ink=True, cache_key=f"logo:{abbr}")
-self.draw_fit(score_text, regs.score_area)     # largest crisp font that fits
-self.draw_fit(status, regs.status_band)
-```
-
-Key pieces: `Region` (rect algebra: bands/columns/splits/offset),
-font ladders (`LADDER_GRID`, `LADDER_ARCADE` — discrete crisp sizes, never
-fractional scaling), `LayoutContext` (`fit_text`, `fit_image`, `by_tier`,
-`px`), and composite carvers `scoreboard_regions()` / `media_row()`.
-Full guide: [docs/ADAPTIVE_LAYOUT.md](../../docs/ADAPTIVE_LAYOUT.md).
-
 ## Error Handling (`error_handler.py`)
 
 Common error handling patterns and utilities:

src/common/__init__.py

@@ -26,31 +26,6 @@ from src.common.scroll_helper import ScrollHelper
 from src.common.logo_helper import LogoHelper
 from src.common.text_helper import TextHelper
 
-# Adaptive layout & images (canonical homes: src.adaptive_layout /
-# src.adaptive_images — re-exported here so plugin authors find them in the
-# blessed-helpers package). See docs/ADAPTIVE_LAYOUT.md.
-from src.adaptive_layout import (
-    Region,
-    LayoutContext,
-    FontStep,
-    FontLadder,
-    LADDER_GRID,
-    LADDER_ARCADE,
-    FitResult,
-    draw_fitted_text,
-    ScoreboardRegions,
-    scoreboard_regions,
-    MediaRow,
-    media_row,
-)
-from src.adaptive_images import (
-    ImageFitResult,
-    fit_image,
-    draw_fitted_image,
-    RESAMPLE_LANCZOS,
-    RESAMPLE_NEAREST,
-)
-
 __all__ = [
     'handle_file_operation',
     'handle_json_operation',
@@ -62,22 +37,4 @@ __all__ = [
     'ScrollHelper',
     'LogoHelper',
     'TextHelper',
-    # adaptive layout & images
-    'Region',
-    'LayoutContext',
-    'FontStep',
-    'FontLadder',
-    'LADDER_GRID',
-    'LADDER_ARCADE',
-    'FitResult',
-    'draw_fitted_text',
-    'ScoreboardRegions',
-    'scoreboard_regions',
-    'MediaRow',
-    'media_row',
-    'ImageFitResult',
-    'fit_image',
-    'draw_fitted_image',
-    'RESAMPLE_LANCZOS',
-    'RESAMPLE_NEAREST',
 ]

src/common/basketball_plugin_example.py

@@ -0,0 +1,328 @@
+"""
+Example: Basketball Plugin using LEDMatrix Common Helpers
+
+This example shows how to refactor the basketball plugin to use the
+ledmatrix-common package for cleaner, more maintainable code.
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+
+# Import common helpers
+from src.common import (
+    LogoHelper, TextHelper, APIHelper, DisplayHelper, 
+    GameHelper, ConfigHelper
+)
+from src.plugin_system.base_plugin import BasePlugin
+
+
+class BasketballPluginManager(BasePlugin):
+    """
+    Basketball scoreboard plugin using LEDMatrix Common helpers.
+    
+    This version is much cleaner and more maintainable than the original
+    because it delegates common functionality to the shared helpers.
+    """
+    
+    def __init__(
+        self,
+        plugin_id: str,
+        config: Dict[str, Any],
+        display_manager,
+        cache_manager,
+        plugin_manager
+    ):
+        """Initialize the basketball plugin with common helpers."""
+        super().__init__(plugin_id, config, display_manager, cache_manager, plugin_manager)
+        
+        # Get display dimensions
+        self.display_width = display_manager.matrix.width
+        self.display_height = display_manager.matrix.height
+        
+        # Initialize common helpers
+        self._init_helpers()
+        
+        # Load configuration
+        self._load_config()
+        
+        # State tracking
+        self.current_games = []
+        self.current_game = None
+        
+        # Log initialization
+        enabled_leagues = [k for k, v in self.league_configs.items() if v['enabled']]
+        self.logger.info(f"Basketball plugin initialized with leagues: {enabled_leagues}")
+    
+    def _init_helpers(self):
+        """Initialize all common helpers."""
+        # Logo helper for team logos
+        self.logo_helper = LogoHelper(
+            display_width=self.display_width,
+            display_height=self.display_height,
+            logger=self.logger
+        )
+        
+        # Text helper for rendering
+        self.text_helper = TextHelper(logger=self.logger)
+        self.fonts = self.text_helper.load_fonts()
+        
+        # API helper for ESPN data
+        self.api_helper = APIHelper(
+            cache_manager=self.cache_manager,
+            logger=self.logger
+        )
+        
+        # Display helper for layouts
+        self.display_helper = DisplayHelper(
+            display_width=self.display_width,
+            display_height=self.display_height,
+            logger=self.logger
+        )
+        
+        # Game helper for data processing
+        self.game_helper = GameHelper(
+            timezone_str=self.config.get('timezone', 'UTC'),
+            logger=self.logger
+        )
+        
+        # Config helper for configuration management
+        self.config_helper = ConfigHelper(logger=self.logger)
+    
+    def _load_config(self):
+        """Load and validate configuration."""
+        # Get basketball-specific config
+        basketball_config = self.config_helper.get_sports_config(self.config, 'basketball')
+        
+        # Build league configurations
+        self.league_configs = {
+            'nba': {
+                'enabled': basketball_config.get('nba_enabled', True),
+                'url': 'https://site.api.espn.com/apis/site/v2/sports/basketball/nba/scoreboard',
+                'logo_dir': Path('assets/sports/nba_logos'),
+                'favorite_teams': basketball_config.get('nba_favorite_teams', []),
+                'display_modes': {
+                    'nba_live': basketball_config.get('nba_display_modes_live', True),
+                    'nba_recent': basketball_config.get('nba_display_modes_recent', True),
+                    'nba_upcoming': basketball_config.get('nba_display_modes_upcoming', True),
+                },
+            },
+            'wnba': {
+                'enabled': basketball_config.get('wnba_enabled', False),
+                'url': 'https://site.api.espn.com/apis/site/v2/sports/basketball/wnba/scoreboard',
+                'logo_dir': Path('assets/sports/wnba_logos'),
+                'favorite_teams': basketball_config.get('wnba_favorite_teams', []),
+                'display_modes': {
+                    'wnba_live': basketball_config.get('wnba_display_modes_live', True),
+                    'wnba_recent': basketball_config.get('wnba_display_modes_recent', True),
+                    'wnba_upcoming': basketball_config.get('wnba_display_modes_upcoming', True),
+                },
+            },
+            'ncaam': {
+                'enabled': basketball_config.get('ncaam_basketball_enabled', False),
+                'url': 'https://site.api.espn.com/apis/site/v2/sports/basketball/mens-college-basketball/scoreboard',
+                'logo_dir': Path('assets/sports/ncaa_logos'),
+                'favorite_teams': basketball_config.get('ncaam_basketball_favorite_teams', []),
+                'display_modes': {
+                    'ncaam_basketball_live': basketball_config.get('ncaam_basketball_display_modes_live', True),
+                    'ncaam_basketball_recent': basketball_config.get('ncaam_basketball_display_modes_recent', True),
+                    'ncaam_basketball_upcoming': basketball_config.get('ncaam_basketball_display_modes_upcoming', True),
+                },
+            },
+            'ncaaw': {
+                'enabled': basketball_config.get('ncaaw_basketball_enabled', False),
+                'url': 'https://site.api.espn.com/apis/site/v2/sports/basketball/womens-college-basketball/scoreboard',
+                'logo_dir': Path('assets/sports/ncaa_logos'),
+                'favorite_teams': basketball_config.get('ncaaw_basketball_favorite_teams', []),
+                'display_modes': {
+                    'ncaaw_basketball_live': basketball_config.get('ncaaw_basketball_display_modes_live', True),
+                    'ncaaw_basketball_recent': basketball_config.get('ncaaw_basketball_display_modes_recent', True),
+                    'ncaaw_basketball_upcoming': basketball_config.get('ncaaw_basketball_display_modes_upcoming', True),
+                },
+            },
+        }
+    
+    def update(self) -> None:
+        """Update game data for all enabled leagues."""
+        try:
+            all_games = []
+            
+            for league_key, league_config in self.league_configs.items():
+                if not league_config['enabled']:
+                    continue
+                
+                games = self._fetch_league_games(league_key, league_config)
+                for game in games:
+                    game['league_key'] = league_key
+                    game['league_config'] = league_config
+                all_games.extend(games)
+            
+            self.current_games = all_games
+            self.logger.debug(f"Updated basketball data: {len(all_games)} total games")
+            
+        except Exception as e:
+            self.logger.error(f"Error updating basketball data: {e}", exc_info=True)
+    
+    def _fetch_league_games(self, league_key: str, league_config: Dict) -> List[Dict]:
+        """Fetch games for a specific league using API helper."""
+        try:
+            # Use API helper to fetch ESPN data with caching
+            data = self.api_helper.fetch_espn_scoreboard(
+                sport='basketball',
+                league=league_key,
+                cache_key=f"basketball_{league_key}",
+                cache_ttl=300  # 5 minutes cache
+            )
+            
+            if not data:
+                return []
+            
+            # Use game helper to process events
+            events = data.get('events', [])
+            games = self.game_helper.process_games(events, sport='basketball')
+            
+            # Add logo paths to games
+            for game in games:
+                logo_dir = league_config['logo_dir']
+                game['home_logo_path'] = logo_dir / f"{game['home_abbr']}.png"
+                game['away_logo_path'] = logo_dir / f"{game['away_abbr']}.png"
+            
+            return games
+            
+        except Exception as e:
+            self.logger.error(f"Error fetching {league_key} games: {e}", exc_info=True)
+            return []
+    
+    def display(self, force_clear: bool = False, display_mode: str = None) -> None:
+        """Display basketball games using display helper."""
+        try:
+            mode = display_mode or self._determine_display_mode()
+            
+            if not mode:
+                self._display_no_games()
+                return
+            
+            # Filter games for mode
+            filtered_games = self._filter_games_for_mode(mode)
+            
+            if not filtered_games:
+                self._display_no_games()
+                return
+            
+            # Display first game
+            self.current_game = filtered_games[0]
+            self._draw_scorebug_layout(self.current_game, force_clear)
+            
+        except Exception as e:
+            self.logger.error(f"Error displaying game: {e}", exc_info=True)
+    
+    def _determine_display_mode(self) -> Optional[str]:
+        """Determine display mode based on available games."""
+        # Priority: live > recent > upcoming
+        for game in self.current_games:
+            if game.get('is_live'):
+                return f"{game['league_key']}_live"
+        for game in self.current_games:
+            if game.get('is_final'):
+                return f"{game['league_key']}_recent"
+        for game in self.current_games:
+            if game.get('is_upcoming'):
+                return f"{game['league_key']}_upcoming"
+        return None
+    
+    def _filter_games_for_mode(self, mode: str) -> List[Dict]:
+        """Filter games based on display mode."""
+        filtered = []
+        
+        for game in self.current_games:
+            league_config = game.get('league_config', {})
+            display_modes = league_config.get('display_modes', {})
+            
+            if mode in display_modes and display_modes[mode]:
+                if 'live' in mode and game.get('is_live'):
+                    filtered.append(game)
+                elif 'recent' in mode and game.get('is_final'):
+                    filtered.append(game)
+                elif 'upcoming' in mode and game.get('is_upcoming'):
+                    filtered.append(game)
+        
+        return filtered[:5]
+    
+    def _draw_scorebug_layout(self, game: Dict, force_clear: bool = False) -> None:
+        """Draw the basketball scorebug layout using display helper."""
+        try:
+            # Load logos using logo helper
+            home_logo = self.logo_helper.load_logo(
+                game['home_abbr'], 
+                game['home_logo_path']
+            )
+            away_logo = self.logo_helper.load_logo(
+                game['away_abbr'], 
+                game['away_logo_path']
+            )
+            
+            if not home_logo or not away_logo:
+                self.logger.error("Failed to load logos")
+                self._display_error("Logo Error")
+                return
+            
+            # Use display helper to create scorebug layout
+            final_img = self.display_helper.draw_scorebug_layout(
+                game_data=game,
+                fonts=self.fonts,
+                home_logo=home_logo,
+                away_logo=away_logo
+            )
+            
+            # Display the image
+            self.display_manager.image.paste(final_img, (0, 0))
+            self.display_manager.update_display()
+            
+        except Exception as e:
+            self.logger.error(f"Error drawing scorebug: {e}", exc_info=True)
+    
+    def _display_no_games(self) -> None:
+        """Display 'no games' message using display helper."""
+        try:
+            img = self.display_helper.draw_no_data_message("No Games")
+            self.display_manager.image = img.copy()
+            self.display_manager.update_display()
+        except Exception as e:
+            self.logger.error(f"Error displaying no games: {e}", exc_info=True)
+    
+    def _display_error(self, message: str) -> None:
+        """Display error message using display helper."""
+        try:
+            img = self.display_helper.draw_error_message(message)
+            self.display_manager.image = img.copy()
+            self.display_manager.update_display()
+        except Exception as e:
+            self.logger.error(f"Error displaying error message: {e}", exc_info=True)
+    
+    def get_display_duration(self) -> float:
+        """Get display duration."""
+        return self.config.get('display_duration', 15)
+    
+    def cleanup(self) -> None:
+        """Cleanup resources."""
+        self.current_games = []
+        self.logger.info("Basketball plugin cleaned up")
+
+
+# Example usage and benefits:
+"""
+Benefits of using LEDMatrix Common helpers:
+
+1. **Cleaner Code**: The plugin is much shorter and more readable
+2. **Reusable Components**: Common functionality is shared across plugins
+3. **Better Testing**: Each helper can be tested independently
+4. **Easier Maintenance**: Bug fixes in helpers benefit all plugins
+5. **Consistent Behavior**: All plugins use the same underlying logic
+6. **Reduced Dependencies**: Plugins don't need to import LEDMatrix core
+7. **Better Error Handling**: Centralized error handling in helpers
+8. **Configuration Management**: Consistent config handling across plugins
+
+The original basketball plugin was 326 lines. This version is much cleaner
+and delegates most functionality to the common helpers, making it easier to
+maintain and extend.
+"""

src/common/logo_helper.py

@@ -72,20 +72,9 @@ class LogoHelper:
             
         Returns:
             PIL Image object or None if loading fails
-
-        Note: for new adaptive-layout code prefer ``BasePlugin.draw_image``
-        / ``LayoutContext.fit_image`` (src/adaptive_images.py) for the
-        fitting step — LogoHelper remains useful for its download and
-        placeholder logic.
         """
-        # Resolve the effective target size BEFORE the cache lookup so the
-        # key is size-qualified — a panel-size change must not return a
-        # logo resized for the old dimensions.
-        if max_width is None:
-            max_width = int(self.display_width * 1.5)
-        if max_height is None:
-            max_height = int(self.display_height * 1.5)
-        cache_key = f"{team_abbr}_{logo_path}_{max_width}x{max_height}"
+        # Check cache first
+        cache_key = f"{team_abbr}_{logo_path}"
         if cache_key in self._logo_cache:
             self.logger.debug(f"Using cached logo for {team_abbr}")
             # Update LRU order (move to end)

src/common/permission_utils.py

@@ -146,60 +146,6 @@ def ensure_file_permissions(path: Path, mode: int = 0o644) -> None:
         raise
 
 
-_shared_group_gid_cache: Optional[int] = None
-
-
-def get_shared_group_gid() -> Optional[int]:
-    """
-    Return the gid that should own config/secrets files shared between the
-    root-run ``ledmatrix.service`` (main display) and the non-root user that
-    ``ledmatrix-web.service`` runs as (see install_web_service.sh, which sets
-    ``User=$SUDO_USER``).
-
-    Resolved once from the project root directory's current group (normally
-    the login user's group from the initial ``git clone``), since that user
-    is stable across reinstalls unlike any single file's ownership.
-
-    Returns:
-        The gid, or None if it cannot be determined.
-    """
-    global _shared_group_gid_cache
-    if _shared_group_gid_cache is not None:
-        return _shared_group_gid_cache
-    try:
-        project_root = Path(__file__).resolve().parent.parent.parent
-        _shared_group_gid_cache = project_root.stat().st_gid
-        return _shared_group_gid_cache
-    except OSError:
-        return None
-
-
-def ensure_shared_group_ownership(path: Path) -> None:
-    """
-    Best-effort chgrp of ``path`` to the shared group (see
-    :func:`get_shared_group_gid`) when running as root.
-
-    Only root can change a file's group to one the calling process isn't a
-    member of, which is exactly the case that causes the web interface
-    (running as a non-root user) to get ``PermissionError`` reading files
-    the root-run display service just wrote with a 0o640/2775 mode: the mode
-    is group-readable, but without this the group is root's, not the web
-    user's. Silently does nothing if not running as root or on any error —
-    this is a hardening step, not a required one.
-    """
-    if os.geteuid() != 0:
-        return
-    gid = get_shared_group_gid()
-    if gid is None:
-        return
-    try:
-        if path.exists() and path.stat().st_gid != gid:
-            os.chown(path, -1, gid)
-            logger.debug(f"Set shared group ownership (gid {gid}) on {path}")
-    except OSError as e:
-        logger.debug(f"Could not set shared group ownership on {path}: {e}")
-
-
 def get_config_file_mode(file_path: Path) -> int:
     """
     Return appropriate permission mode for config files.

src/common/snapshot_policy.py

@@ -1,68 +0,0 @@
-"""Snapshot write policy for the display preview mirror.
-
-The display service mirrors frames to /tmp/led_matrix_preview.png, which
-serves two consumers with different needs:
-
-- The web UI's live preview (SSE reader in web_interface/app.py) wants
-  fresh frames — but only while a browser is actually watching.
-- The health check (web_interface/blueprints/api_v3.py, hardware status)
-  uses the file's AGE as a liveness proxy: age >= 60s reads as degraded.
-
-PNG-encoding every frame at 5 fps forever — identical frames, no viewers —
-was one of the biggest fixed CPU costs on the Pi. This module is the pure
-decision logic (extracted so it's unit-testable off-Pi; display_manager
-imports rgbmatrix unconditionally and can't be):
-
-    WRITE  — encode + atomically replace the snapshot file
-    TOUCH  — os.utime only: keeps the health-check mtime fresh and lets
-             the SSE reader (mtime-gated) resend at a low rate, without
-             paying for a PNG encode of an unchanged frame
-    SKIP   — do nothing
-
-Policy:
-- With a fresh viewer marker: changed frames write at up to 1/VIEWER_INTERVAL.
-- Without viewers: changed frames still write at 1/IDLE_INTERVAL so the
-  preview page shows something recent on open.
-- Unchanged frames are never re-encoded; the mtime is touched every
-  TOUCH_INTERVAL so the health check (60s threshold) never degrades.
-
-If any constant here changes, re-check the health threshold in
-api_v3.py (get_hardware_status) — TOUCH_INTERVAL must stay well under it.
-"""
-
-from enum import Enum
-
-# Snapshot cadence with a browser preview open (seconds).
-VIEWER_INTERVAL = 0.2
-# Snapshot cadence with no viewers — cheap freshness for page-open (seconds).
-IDLE_INTERVAL = 30.0
-# Max age of the last write/touch before bumping mtime for the health
-# check. MUST stay well under api_v3's 60s degraded threshold.
-TOUCH_INTERVAL = 20.0
-# A viewer marker older than this no longer counts as a live viewer.
-VIEWER_MARKER_FRESH_SEC = 5.0
-
-
-class SnapshotAction(Enum):
-    WRITE = "write"
-    TOUCH = "touch"
-    SKIP = "skip"
-
-
-def decide(now: float, last_write_ts: float, last_touch_ts: float,
-           viewer_fresh: bool, frame_changed: bool) -> SnapshotAction:
-    """Decide what to do with the current frame.
-
-    Args:
-        now: current monotonic-ish timestamp (same clock as the ts args)
-        last_write_ts: when a frame was last actually encoded+written
-        last_touch_ts: when the file mtime was last bumped (write or touch)
-        viewer_fresh: a browser preview is currently watching
-        frame_changed: the frame differs from the last WRITTEN frame
-    """
-    interval = VIEWER_INTERVAL if viewer_fresh else IDLE_INTERVAL
-    if frame_changed and (now - last_write_ts) >= interval:
-        return SnapshotAction.WRITE
-    if (now - max(last_write_ts, last_touch_ts)) >= TOUCH_INTERVAL:
-        return SnapshotAction.TOUCH
-    return SnapshotAction.SKIP

src/common/text_helper.py

@@ -11,9 +11,6 @@ from typing import Dict, List, Optional, Tuple, Union
 
 from PIL import Image, ImageDraw, ImageFont
 
-# Shared throwaway draw surface for measuring text without a target canvas.
-_measure_draw = ImageDraw.Draw(Image.new("RGB", (1, 1)))
-
 
 class TextHelper:
     """
@@ -115,10 +112,10 @@ class TextHelper:
             Width in pixels
         """
         try:
-            return int(_measure_draw.textlength(text, font=font))
+            return draw.textlength(text, font=font)
         except AttributeError:
             # Fallback for older PIL versions
-            bbox = _measure_draw.textbbox((0, 0), text, font=font)
+            bbox = draw.textbbox((0, 0), text, font=font)
             return bbox[2] - bbox[0]
     
     def get_text_height(self, text: str, font: ImageFont.ImageFont) -> int:
@@ -132,8 +129,13 @@ class TextHelper:
         Returns:
             Height in pixels
         """
-        bbox = _measure_draw.textbbox((0, 0), text, font=font)
-        return bbox[3] - bbox[1]
+        try:
+            bbox = draw.textbbox((0, 0), text, font=font)
+            return bbox[3] - bbox[1]
+        except AttributeError:
+            # Fallback for older PIL versions
+            bbox = draw.textbbox((0, 0), text, font=font)
+            return bbox[3] - bbox[1]
     
     def get_text_dimensions(self, text: str, font: ImageFont.ImageFont) -> Tuple[int, int]:
         """

src/config_manager.py

@@ -38,7 +38,6 @@ from src.config_manager_atomic import (
 from src.common.permission_utils import (
     ensure_directory_permissions,
     ensure_file_permissions,
-    ensure_shared_group_ownership,
     get_config_file_mode,
     get_config_dir_mode
 )
@@ -57,13 +56,6 @@ class ConfigManager:
         self.secrets_path: str = secrets_path or "config/config_secrets.json"
         self.template_path: str = "config/config.template.json"
         self.config: Dict[str, Any] = {}
-        # (mtime_ns, size) signature of (config, secrets, template) at the
-        # last successful load. load_config() skips the full re-read (3 file
-        # parses + recursive template migration) when nothing changed —
-        # ~30 web request handlers call it, some 2-3x per request. Cross-
-        # process freshness is preserved: another process's save bumps the
-        # mtime, so the next load here re-reads.
-        self._loaded_sig: Optional[tuple] = None
         self.logger: logging.Logger = get_logger(__name__)
         
         # Initialize atomic config manager
@@ -130,14 +122,6 @@ class ConfigManager:
         # Update in-memory config if save was successful
         if result.status == SaveResultStatus.SUCCESS:
             self.config = new_config_data
-            # In-memory config now matches what was just written; refresh
-            # the load signature so the fast path stays valid. NOTE: the
-            # in-memory copy includes merged secrets; the on-disk file has
-            # them stripped — the fast path returning self.config preserves
-            # exactly the pre-cache behavior (load-after-save also returned
-            # the secret-merged self.config only after re-reading secrets;
-            # here secrets file is unchanged, so contents are equivalent).
-            self._loaded_sig = self._files_signature()
             self.logger.info(f"Configuration successfully saved atomically to {os.path.abspath(self.config_path)}")
         elif result.status == SaveResultStatus.ROLLED_BACK:
             # Reload config from file after rollback
@@ -195,36 +179,13 @@ class ConfigManager:
         atomic_mgr = self._get_atomic_manager()
         return atomic_mgr.validate_config_file(config_path)
 
-    def _files_signature(self) -> tuple:
-        """(mtime_ns, size) of config/secrets/template, None for missing —
-        cheap staleness probe (3 stats) for the load_config fast path."""
-        sig = []
-        for path in (self.config_path, self.secrets_path, self.template_path):
-            try:
-                st = os.stat(path)
-                sig.append((st.st_mtime_ns, st.st_size))
-            except OSError:
-                sig.append(None)
-        return tuple(sig)
-
     def load_config(self) -> Dict[str, Any]:
-        """Load configuration from JSON files.
-
-        Fast path: when config.json, config_secrets.json and the template
-        are all unchanged since the last successful load (mtime_ns + size),
-        the already-parsed self.config is returned without touching the
-        files — same aliasing semantics as the full path, which also
-        returns self.config.
-        """
+        """Load configuration from JSON files."""
         try:
-            current_sig = self._files_signature()
-            if self.config and self._loaded_sig == current_sig:
-                return self.config
-
             # Check if config file exists, if not create from template
             if not os.path.exists(self.config_path):
                 self._create_config_from_template()
-
+            
             # Load main config
             self.logger.info(f"Attempting to load config from: {os.path.abspath(self.config_path)}")
             with open(self.config_path, 'r') as f:
@@ -235,11 +196,6 @@ class ConfigManager:
 
             # Load and merge secrets if they exist (be permissive on errors)
             if os.path.exists(self.secrets_path):
-                # Self-heal stale group ownership (e.g. the root-run display
-                # service wrote this file before the web user was granted
-                # group access) before every load attempt; no-op unless
-                # running as root and the group is already wrong.
-                ensure_shared_group_ownership(Path(self.secrets_path))
                 try:
                     with open(self.secrets_path, 'r') as f:
                         secrets = json.load(f)
@@ -249,10 +205,7 @@ class ConfigManager:
                     self.logger.warning(f"Secrets file not readable ({self.secrets_path}): {e}. Continuing without secrets.")
                 except (json.JSONDecodeError, OSError) as e:
                     self.logger.warning(f"Error reading secrets file ({self.secrets_path}): {e}. Continuing without secrets.")
-
-            # Signature taken AFTER load + migration (migration may write the
-            # config back), so it reflects exactly what was read/written.
-            self._loaded_sig = self._files_signature()
+            
             return self.config
             
         except FileNotFoundError as e:
@@ -311,8 +264,7 @@ class ConfigManager:
                 json.dump(config_to_write, f, indent=4)
             
             # Update the in-memory config to the new state (which includes secrets for runtime)
-            self.config = new_config_data
-            self._loaded_sig = self._files_signature()
+            self.config = new_config_data 
             self.logger.info(f"Configuration successfully saved to {os.path.abspath(self.config_path)}")
             if secrets_content:
                  self.logger.info("Secret values were preserved in memory and not written to the main config file.")
@@ -369,7 +321,6 @@ class ConfigManager:
         # Set proper file permissions after creation
         config_path_obj = Path(self.config_path)
         ensure_file_permissions(config_path_obj, get_config_file_mode(config_path_obj))
-        ensure_shared_group_ownership(config_path_obj)
         
         self.logger.info(f"Created config.json from template at {os.path.abspath(self.config_path)}")
 
@@ -482,11 +433,6 @@ class ConfigManager:
             self.logger.error(error_msg)
             raise ConfigError(error_msg, config_path=path_to_load)
 
-        if file_type == "secrets":
-            # Best-effort self-heal: no-op unless running as root and the
-            # group is stale (see load_config for why this can happen).
-            ensure_shared_group_ownership(Path(path_to_load))
-
         try:
             with open(path_to_load, 'r') as f:
                 return json.load(f)
@@ -494,18 +440,7 @@ class ConfigManager:
             error_msg = f"Error parsing {file_type} configuration file: {path_to_load}"
             self.logger.error(error_msg, exc_info=True)
             raise ConfigError(error_msg, config_path=path_to_load) from e
-        except PermissionError as e:
-            if file_type == "secrets":
-                # Match load_config()'s tolerance: a secrets file the web
-                # process can't read (e.g. written 0640 by the root-run
-                # display service before the group was fixed up) shouldn't
-                # 500 the settings page — degrade to "no secrets" instead.
-                self.logger.warning(f"Secrets file not readable ({path_to_load}): {e}. Returning empty secrets.")
-                return {}
-            error_msg = f"Error loading {file_type} configuration file {path_to_load}: {str(e)}"
-            self.logger.error(error_msg, exc_info=True)
-            raise ConfigError(error_msg, config_path=path_to_load) from e
-        except (IOError, OSError) as e:
+        except (IOError, OSError, PermissionError) as e:
             error_msg = f"Error loading {file_type} configuration file {path_to_load}: {str(e)}"
             self.logger.error(error_msg, exc_info=True)
             raise ConfigError(error_msg, config_path=path_to_load) from e
@@ -562,7 +497,6 @@ class ConfigManager:
                 # Ensure final file has correct permissions
                 try:
                     ensure_file_permissions(path_obj, file_mode)
-                    ensure_shared_group_ownership(path_obj)
                 except OSError as perm_error:
                     # If we can't set permissions but file was written, log warning but don't fail
                     self.logger.warning(

src/config_manager_atomic.py

@@ -17,7 +17,6 @@ from enum import Enum
 
 from src.exceptions import ConfigError
 from src.logging_config import get_logger
-from src.common.permission_utils import ensure_shared_group_ownership
 
 
 class SaveResultStatus(Enum):
@@ -411,13 +410,6 @@ class AtomicConfigManager:
             # This is important because temp files may have different permissions
             # and we need root service to be able to read config.json
             os.chmod(destination, target_mode)
-
-            # Also fix group ownership when this save is running as root
-            # (the display service): 0o640 alone only helps the non-root web
-            # user read a root-written secrets file if its group already
-            # matches the web user's group, which isn't guaranteed. See
-            # permission_utils.ensure_shared_group_ownership for why.
-            ensure_shared_group_ownership(destination)
             
         except Exception as e:
             raise ConfigError(f"Error during atomic move: {e}") from e

src/display_controller.py

@@ -23,9 +23,6 @@ Entry point: :func:`main` — instantiates :class:`DisplayController` and calls
 import time
 import os
 import json
-import threading
-import types
-from contextlib import contextmanager
 from pathlib import Path
 from typing import Dict, Any, List, Optional, Callable
 from datetime import datetime
@@ -202,10 +199,6 @@ class DisplayController:
         self.wifi_status_file = WIFI_STATUS_FILE
         self.wifi_status_active = False
         self.wifi_status_expires_at: Optional[float] = None
-        # _check_wifi_status_message throttle state (checked at frame rate,
-        # stat'd at most once per second)
-        self._wifi_status_check_ts = 0.0
-        self._wifi_status_last_result: Optional[Dict[str, Any]] = None
 
         # Plugin display() signature cache — must be initialised before the plugin
         # loading loop below so the .pop() invalidation at load time is always safe.
@@ -381,10 +374,6 @@ class DisplayController:
                 logger.debug("%d plugin(s) disabled in config", disabled_count)
 
             logger.info("Plugin system initialized in %.3f seconds", time.time() - plugin_time)
-            # Parallel loading appends modes in load-completion order, which
-            # varies between restarts; apply the user's configured rotation
-            # order (no-op when not configured).
-            self._apply_plugin_rotation_order()
             logger.info("Total available modes: %d", len(self.available_modes))
             logger.info("Available modes: %s", self.available_modes)
             
@@ -513,10 +502,7 @@ class DisplayController:
 
             # Run plugin updates inside the Vegas loop so the inter-iteration
             # gap is <1 ms (nothing left for _tick_plugin_updates() to do).
-            # Use the Vegas-aware variant so plugins that got fresh data are
-            # hot-swapped into the scroll promptly instead of waiting for the
-            # next full cycle.
-            self.vegas_coordinator.set_update_callback(self._tick_plugin_updates_for_vegas)
+            self.vegas_coordinator.set_update_callback(self._tick_plugin_updates)
 
             # Wire multi-display sync into Vegas render pipeline
             follower_pos = self.config.get("sync", {}).get("follower_position", "left")
@@ -635,28 +621,18 @@ class DisplayController:
 
         current_day = current_time.strftime('%A').lower()  # e.g. 'monday'
         current_time_only = current_time.time()
-
+        
         # Check if per-day schedule is configured
         days_config = schedule_config.get('days')
-
-        # Determine which schedule to use. Respect an explicit 'mode' field
-        # (like the dim schedule does) so a stray/legacy 'days' dict left over
-        # from config migration or a prior per-day setup can't silently
-        # override a user's Global schedule selection.
-        mode = schedule_config.get('mode')
-        mode_normalized = mode.replace('_', '-') if mode else None
-
+        
+        # Determine which schedule to use
         use_per_day = False
-        if mode_normalized == 'global':
-            use_per_day = False
-        elif mode_normalized == 'per-day':
-            use_per_day = bool(days_config and current_day in days_config)
-        elif days_config:
-            # No explicit mode recorded (legacy config) - fall back to
-            # inferring from presence of a 'days' dict for the current day.
-            if current_day in days_config:
+        if days_config:
+            # Check if days dict is not empty and contains current day
+            if days_config and current_day in days_config:
                 use_per_day = True
-            else:
+            elif days_config:
+                # Days dict exists but doesn't have current day - fall back to global
                 logger.debug("Per-day schedule exists but %s not configured, using global schedule", current_day)
         
         if use_per_day:
@@ -852,42 +828,6 @@ class DisplayController:
                     if hasattr(self.plugin_manager, 'health_tracker') and self.plugin_manager.health_tracker:
                         self.plugin_manager.health_tracker.record_failure(plugin_id, exc)
 
-    def _tick_plugin_updates_for_vegas(self) -> None:
-        """Run scheduled plugin updates and tell Vegas mode which plugins
-        actually got fresh data, so it can hot-swap them into the scroll
-        without waiting for a full cycle to complete.
-
-        Used as the Vegas coordinator's update callback instead of the plain
-        _tick_plugin_updates() so that a live score change is reflected in
-        the ticker within a few seconds rather than at the next cycle
-        boundary (which, depending on min/max_cycle_duration, can be
-        minutes away). Restores wiring that PR #299 added and PR #330's
-        sync-mode refactor inadvertently dropped: coordinator.mark_plugin_updated()
-        has been unreachable dead code since.
-
-        Delegates the before/after plugin_last_update snapshot to
-        PluginManager.run_scheduled_updates_with_changes() so the snapshot,
-        update pass, and diff are lock-protected against this callback's own
-        background update-tick thread racing the main render loop.
-        """
-        if not self.plugin_manager or not hasattr(self.plugin_manager, "run_scheduled_updates_with_changes"):
-            self._tick_plugin_updates()
-            return
-
-        updated = self.plugin_manager.run_scheduled_updates_with_changes()
-
-        vc = getattr(self, "vegas_coordinator", None)
-        if vc is None:
-            return
-
-        if updated:
-            logger.info("Vegas update tick: %d plugin(s) updated: %s", len(updated), updated)
-            for plugin_id in updated:
-                try:
-                    vc.mark_plugin_updated(plugin_id)
-                except Exception:  # pylint: disable=broad-except
-                    logger.exception("Error marking plugin %s updated for Vegas", plugin_id)
-
     def _tick_plugin_updates(self):
         """Run scheduled plugin updates if the plugin manager supports them."""
         if not self.plugin_manager:
@@ -899,30 +839,6 @@ class DisplayController:
             except Exception:  # pylint: disable=broad-except
                 logger.exception("Error running scheduled plugin updates")
 
-    @contextmanager
-    def _display_lock_or_skip(self, plugin_id):
-        """Try-lock guard keeping a plugin's display() off its in-flight update().
-
-        Yields True when display may run (lock held, released on exit) or
-        when no lock support exists (older plugin manager). Yields False when
-        the plugin's update() is currently executing on the background
-        worker — the caller should treat the frame as displayed (the panel
-        holds the last pushed frame) rather than as a plugin failure, so a
-        mid-update skip never advances the rotation.
-        """
-        pm = self.plugin_manager
-        if not pm or not hasattr(pm, 'get_plugin_lock') or not plugin_id:
-            yield True
-            return
-        lock = pm.get_plugin_lock(plugin_id)
-        if not lock.acquire(blocking=False):
-            yield False
-            return
-        try:
-            yield True
-        finally:
-            lock.release()
-
     _FOLLOWER_SEND_INTERVAL = 1.0 / 90  # raw bytes are cheap; 90fps > follower render rate
 
     def _follower_rebuild_scroll_image(self) -> None:
@@ -1719,7 +1635,7 @@ class DisplayController:
                     self._sleep_with_plugin_updates(60)
                     continue
                 
-                logger.debug("Display active, processing mode: %s", self.current_display_mode)
+                logger.info(f"Display active, processing mode: {self.current_display_mode}")
                 
                 # Plugins update on their own schedules - no forced sync updates needed
                 # Each plugin has its own update_interval and background services
@@ -1887,7 +1803,7 @@ class DisplayController:
                         if self.plugin_manager and hasattr(self.plugin_manager, 'health_tracker') and self.plugin_manager.health_tracker:
                             should_skip = self.plugin_manager.health_tracker.should_skip_plugin(plugin_id)
                             if should_skip:
-                                logger.info("Skipping plugin %s due to circuit breaker (mode: %s)", plugin_id, active_mode)
+                                logger.info(f"Skipping plugin {plugin_id} due to circuit breaker (mode: {active_mode})")
                                 display_result = False
                                 # Skip to next mode - let existing logic handle it
                                 manager_to_display = None
@@ -1910,7 +1826,6 @@ class DisplayController:
                     plugin_id = getattr(manager_to_display, 'plugin_id', active_mode)
                     try:
                         logger.debug(f"Calling display() for {active_mode} with force_clear={self.force_change}")
-                        can_display = False
                         if hasattr(manager_to_display, 'display'):
                             # Opt #1: look up (or compute once) whether display() accepts display_mode
                             _cache_key = plugin_id
@@ -1921,64 +1836,14 @@ class DisplayController:
                                 )
                             _accepts_display_mode = self._plugin_accepts_display_mode[_cache_key]
 
-                            pm = self.plugin_manager
-                            display_lock = None
-                            can_display = True
-                            if pm and hasattr(pm, 'get_plugin_lock'):
-                                display_lock = pm.get_plugin_lock(plugin_id)
-                                can_display = display_lock.acquire(blocking=False)
-
-                            if not can_display:
-                                # update() in flight on the worker — hold
-                                # the last frame; not a plugin failure
-                                result = True
-                            elif pm and hasattr(pm, 'plugin_executor'):
-                                # PluginExecutor's own thread.join(timeout) can
-                                # return before the real display() call
-                                # finishes (a lingering daemon thread keeps
-                                # running it) -- so the lock is released from
-                                # inside the wrapped call itself, whichever
-                                # thread actually finishes it, rather than
-                                # here when this dispatch merely returns.
-                                release_guard = threading.Lock()
-                                released = {'done': False}
-
-                                def _release_display_lock():
-                                    with release_guard:
-                                        if released['done']:
-                                            return
-                                        released['done'] = True
-                                    if display_lock is not None:
-                                        display_lock.release()
-
-                                if _accepts_display_mode:
-                                    def _display_target(display_mode=None, force_clear=False):
-                                        try:
-                                            return manager_to_display.display(
-                                                display_mode=display_mode, force_clear=force_clear)
-                                        finally:
-                                            _release_display_lock()
-                                else:
-                                    def _display_target(force_clear=False):
-                                        try:
-                                            return manager_to_display.display(force_clear=force_clear)
-                                        finally:
-                                            _release_display_lock()
-
-                                try:
-                                    result = self.plugin_manager.plugin_executor.execute_display(
-                                        types.SimpleNamespace(display=_display_target),
-                                        plugin_id,
-                                        force_clear=self.force_change,
-                                        display_mode=active_mode if _accepts_display_mode else None
-                                    )
-                                except Exception:  # pragma: no cover - defensive;
-                                    # execute_display catches everything
-                                    # internally, but guarantee the lock is
-                                    # never leaked if something unexpected
-                                    # slips through.
-                                    _release_display_lock()
-                                    raise
+                            # Use PluginExecutor for safe execution with timeout
+                            if self.plugin_manager and hasattr(self.plugin_manager, 'plugin_executor'):
+                                result = self.plugin_manager.plugin_executor.execute_display(
+                                    manager_to_display,
+                                    plugin_id,
+                                    force_clear=self.force_change,
+                                    display_mode=active_mode if _accepts_display_mode else None
+                                )
                                 # execute_display returns bool, convert to expected format
                                 if result:
                                     result = True  # Success
@@ -1986,31 +1851,23 @@ class DisplayController:
                                     result = False  # Failed
                             else:
                                 # Fallback to direct call if executor not available
-                                try:
-                                    if _accepts_display_mode:
-                                        result = manager_to_display.display(display_mode=active_mode, force_clear=self.force_change)
-                                    else:
-                                        result = manager_to_display.display(force_clear=self.force_change)
-                                finally:
-                                    if display_lock is not None:
-                                        display_lock.release()
+                                if _accepts_display_mode:
+                                    result = manager_to_display.display(display_mode=active_mode, force_clear=self.force_change)
+                                else:
+                                    result = manager_to_display.display(force_clear=self.force_change)
                             
                             logger.debug(f"display() returned: {result} (type: {type(result)})")
                             # Check if display() returned a boolean (new behavior)
                             if isinstance(result, bool):
                                 display_result = result
                                 if not display_result:
-                                    logger.info("Plugin %s display() returned False for mode %s", plugin_id, active_mode)
+                                    logger.info(f"Plugin {plugin_id} display() returned False for mode {active_mode}")
                         
-                        # Record success only when display() actually ran this
-                        # frame -- a skipped frame (lock busy) held the last
-                        # frame, not a real success, and must not clear
-                        # force_change or the pending mode-switch clear will
-                        # be lost when display() finally does run.
-                        if can_display:
-                            if self.plugin_manager and hasattr(self.plugin_manager, 'health_tracker') and self.plugin_manager.health_tracker:
-                                self.plugin_manager.health_tracker.record_success(plugin_id)
-                            self.force_change = False
+                        # Record success if display completed without exception
+                        if self.plugin_manager and hasattr(self.plugin_manager, 'health_tracker') and self.plugin_manager.health_tracker:
+                            self.plugin_manager.health_tracker.record_success(plugin_id)
+                        
+                        self.force_change = False
                     except Exception as exc:  # pylint: disable=broad-except
                         logger.exception("Error displaying %s", self.current_display_mode)
                         # Record failure
@@ -2215,23 +2072,10 @@ class DisplayController:
 
                     # For plugins, call display multiple times to allow game rotation
                     if manager_to_display and hasattr(manager_to_display, 'display'):
-                        # High-FPS decision, in precedence order:
-                        # 1. A plugin that declares needs_high_fps knows best
-                        #    (e.g. static-image sets it False for still PNGs,
-                        #    True for animated GIFs).
-                        # 2. Back-compat: older static-image versions without
-                        #    the attribute keep the historical forced high-FPS
-                        #    (GIF support).
-                        # 3. Otherwise scrolling plugins get high FPS.
+                        # Check if plugin needs high FPS (like stock ticker)
+                        # Always enable high-FPS for static-image plugin (for GIF animation support)
                         plugin_id = getattr(manager_to_display, 'plugin_id', None)
-                        declared = getattr(manager_to_display, 'needs_high_fps', None)
-                        if declared is not None:
-                            needs_high_fps = bool(declared)
-                            logger.debug(
-                                "[DisplayController] FPS check for %s (plugin=%s) - "
-                                "plugin declares needs_high_fps=%s",
-                                active_mode, plugin_id, needs_high_fps)
-                        elif plugin_id == 'static-image':
+                        if plugin_id == 'static-image':
                             needs_high_fps = True
                             logger.debug("FPS check - static-image plugin: forcing high-FPS mode for GIF support")
                         else:
@@ -2295,16 +2139,11 @@ class DisplayController:
 
                             while True:
                                 try:
-                                    with self._display_lock_or_skip(plugin_id) as can_display:
-                                        if can_display:
-                                            # Pass display_mode to maintain sticky manager state
-                                            if _accepts_display_mode:
-                                                result = manager_to_display.display(display_mode=active_mode, force_clear=False)
-                                            else:
-                                                result = manager_to_display.display(force_clear=False)
-                                        else:
-                                            # update() in flight — hold the last frame
-                                            result = True
+                                    # Pass display_mode to maintain sticky manager state
+                                    if _accepts_display_mode:
+                                        result = manager_to_display.display(display_mode=active_mode, force_clear=False)
+                                    else:
+                                        result = manager_to_display.display(force_clear=False)
                                     if isinstance(result, bool) and not result:
                                         logger.debug("Display returned False, breaking early")
                                         break
@@ -2364,16 +2203,11 @@ class DisplayController:
                                     break
 
                                 try:
-                                    with self._display_lock_or_skip(plugin_id) as can_display:
-                                        if can_display:
-                                            # Pass display_mode to maintain sticky manager state
-                                            if _accepts_display_mode:
-                                                result = manager_to_display.display(display_mode=active_mode, force_clear=False)
-                                            else:
-                                                result = manager_to_display.display(force_clear=False)
-                                        else:
-                                            # update() in flight — hold the last frame
-                                            result = True
+                                    # Pass display_mode to maintain sticky manager state
+                                    if _accepts_display_mode:
+                                        result = manager_to_display.display(display_mode=active_mode, force_clear=False)
+                                    else:
+                                        result = manager_to_display.display(force_clear=False)
                                     if isinstance(result, bool) and not result:
                                         # For dynamic duration plugins, don't exit on False - keep looping
                                         # until cycle is complete or max duration is reached
@@ -2520,16 +2354,6 @@ class DisplayController:
             Returns None on any error or if message is expired/invalid.
         """
         try:
-            # Throttle the existence stat to ~1 Hz: this runs on every render
-            # iteration (60+ fps), and the file usually doesn't exist — the
-            # status message's lifetime is measured in seconds anyway.
-            # Both attributes are initialised in __init__.
-            now = time.time()
-            if (now - self._wifi_status_check_ts) < 1.0:
-                return self._wifi_status_last_result
-            self._wifi_status_check_ts = now
-            self._wifi_status_last_result = None
-
             # Check if file exists
             if not self.wifi_status_file or not self.wifi_status_file.exists():
                 return None
@@ -2580,14 +2404,13 @@ class DisplayController:
                     pass
                 return None
             
-            # Message is valid and not expired — cache for the throttle window
-            self._wifi_status_last_result = {
+            # Message is valid and not expired
+            return {
                 'message': message,
                 'timestamp': timestamp,
                 'duration': duration,
                 'expires_at': expires_at
             }
-            return self._wifi_status_last_result
             
         except Exception as e:
             # Catch-all for any unexpected errors - log but don't break the display
@@ -2847,52 +2670,11 @@ class DisplayController:
             except Exception as e:
                 logger.error("Plugin reconcile: error enabling %s: %s", plugin_id, e, exc_info=True)
 
-        # Newly enabled plugins were appended at the end; put them in the
-        # configured rotation slot before resyncing the index.
-        self._apply_plugin_rotation_order()
         self._resync_mode_index_after_change(previous_mode)
-        logger.info("[DisplayController] Plugin reconcile complete: +%s -%s (%d modes)",
+        logger.info("Plugin reconcile complete: +%s -%s (%d modes)",
                     sorted(to_add), sorted(to_remove), len(self.available_modes))
         return True
 
-    def _apply_plugin_rotation_order(self) -> None:
-        """Reorder available_modes to follow display.plugin_rotation_order.
-
-        The configured value is a list of plugin ids; their modes rotate in
-        that order (each plugin's own modes keep their declared order), with
-        any enabled-but-unlisted plugins appended afterwards in their current
-        relative order. An empty/missing list leaves available_modes exactly
-        as built (today's behavior). Mirrors vegas_mode/config.py's
-        get_ordered_plugins() semantics for the primary rotation.
-        """
-        configured = (self.config.get("display", {}) or {}).get("plugin_rotation_order", []) or []
-        # Defensive: hand-edited or migrated configs may hold a non-list or
-        # non-string entries; keep the existing rotation rather than applying
-        # a garbage order.
-        if not isinstance(configured, list):
-            logger.warning("[DisplayController] Ignoring invalid plugin_rotation_order (not a list): %r",
-                           type(configured).__name__)
-            return
-        configured = [p for p in configured if isinstance(p, str)]
-        if not configured or not self.available_modes:
-            return
-
-        ordered_ids = [p for p in configured if p in self.plugin_display_modes]
-        new_modes: List[str] = []
-        for plugin_id in ordered_ids:
-            for mode in self.plugin_display_modes[plugin_id]:
-                if mode in self.available_modes and mode not in new_modes:
-                    new_modes.append(mode)
-        # Unlisted plugins' modes (and any mode not attributable to a plugin)
-        # follow in their existing relative order.
-        for mode in self.available_modes:
-            if mode not in new_modes:
-                new_modes.append(mode)
-        if new_modes != self.available_modes:
-            self.available_modes = new_modes
-            logger.info("[DisplayController] Applied plugin rotation order %s -> modes: %s",
-                        configured, self.available_modes)
-
     def _resync_mode_index_after_change(self, previous_mode: Optional[str]) -> None:
         """Clamp rotation state after available_modes changed. Stays on the
         previous mode if it survived, otherwise restarts cleanly within range."""
@@ -2932,14 +2714,6 @@ class DisplayController:
 
     def cleanup(self):
         """Clean up resources."""
-        # Stop the async update worker first so no in-flight update() call
-        # is still touching display/cache-backed resources while they're
-        # torn down below.
-        if self.plugin_manager and hasattr(self.plugin_manager, 'stop_update_worker'):
-            try:
-                self.plugin_manager.stop_update_worker()
-            except Exception as e:
-                logger.warning("Error stopping plugin update worker: %s", e)
         # Shutdown config service if it exists
         if hasattr(self, 'config_service'):
             try:

src/display_manager.py

@@ -31,25 +31,13 @@ if os.getenv("EMULATOR", "false") == "true":
 else:
     from rgbmatrix import RGBMatrix, RGBMatrixOptions
 from contextlib import contextmanager
-from pathlib import Path
 from PIL import Image, ImageDraw, ImageFont
-import threading
 import time
-from collections import OrderedDict
-from typing import Dict, Any, List, Optional, Tuple
+from typing import Dict, Any, List, Optional
 import logging
 import math
-import zlib
 import freetype
 
-from src.common import snapshot_policy
-from src.common.permission_utils import (
-    ensure_directory_permissions,
-    ensure_file_permissions,
-    get_assets_dir_mode,
-    get_assets_file_mode,
-)
-
 # Get logger without configuring
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)  # Set to INFO level
@@ -192,45 +180,14 @@ class DisplayManager:
         # the logical image is blitted to the matrix unchanged.
         self._double_sided = None  # dict {copies, axis, logical_width, logical_height} or None
         self._physical_image = None  # full-chain buffer reused each frame when tiling
-        # Text-width measurement cache: (text, id(font)) -> (width, font_ref)
+        # Text-width measurement cache: (text, id(font)) -> pixel_width
         # Avoids re-measuring the same string+font on every display() call.
-        # LRU-bounded: keys embed the TEXT, so changing strings (a clock, a
-        # live score) would otherwise grow it forever on a 24/7 service.
-        # Entries hold a strong reference to the font so its id() can't be
-        # recycled by a different font object — an id-keyed cache without
-        # the reference can return the WRONG width after garbage collection.
         # Cleared on _load_fonts() so stale entries don't survive a font reload.
-        self._text_width_cache: "OrderedDict[tuple, Tuple[int, Any]]" = OrderedDict()
-        self._TEXT_WIDTH_CACHE_MAX = 1024
-        # Snapshot mirror for web preview + health check (service writes, web
-        # reads). Cadence/skip decisions live in src/common/snapshot_policy.py:
-        # full rate only while the web SSE broadcaster keeps the viewer marker
-        # fresh; unchanged frames are never re-encoded, only mtime-touched.
+        self._text_width_cache: Dict[tuple, int] = {}
+        # Snapshot settings for web preview integration (service writes, web reads)
         self._snapshot_path = "/tmp/led_matrix_preview.png"  # nosec B108 - fixed path intentional; web UI reads same path
-        self._viewer_marker_path = "/tmp/led_matrix_preview_viewer"  # nosec B108 - touched by web SSE broadcaster
+        self._snapshot_min_interval_sec = 0.2  # max ~5 fps
         self._last_snapshot_ts = 0.0
-        self._last_snapshot_touch_ts = 0.0
-        self._last_snapshot_digest: Optional[int] = None
-        self._snapshot_dir_prepared = False
-        self._viewer_check_ts = 0.0
-        self._viewer_fresh = False
-        self._viewer_was_fresh = False
-        # Snapshot failures are logged as warnings, rate-limited so a
-        # persistent failure (e.g. an unwritable file) can't spam the log —
-        # but is never silent: the snapshot's mtime doubles as the web UI's
-        # hardware-liveness signal, so a quiet failure makes health checks lie.
-        self._snapshot_fail_log_ts = 0.0
-        # Dirty tracking: (image digest, brightness) of the last frame pushed
-        # to the panel; update_display() skips identical pushes. Kill switch:
-        # display.dirty_tracking: false.
-        self._dirty_tracking_enabled = bool(
-            self.config.get('display', {}).get('dirty_tracking', True))
-        self._last_pushed_digest = None
-        # Serializes update_display(): plugins can call it directly from
-        # background threads (see docstring on update_display), not just the
-        # render loop. RLock in case a caller within the critical section
-        # ever re-enters (e.g. via a nested draw callback).
-        self._update_lock = threading.RLock()
         
         # Scrolling state tracking for graceful updates
         self._scrolling_state = {
@@ -461,10 +418,6 @@ class DisplayManager:
         try:
             # RGBMatrix accepts brightness as a property
             self.matrix.brightness = brightness
-            # Brightness applies on the next swap — force a re-push even if
-            # the image itself is unchanged (belt-and-braces: brightness is
-            # also part of the dirty-tracking digest when readable).
-            self._last_pushed_digest = None
             logger.info(f"[BRIGHTNESS] Display brightness set to {brightness}%")
             return True
         except AttributeError as e:
@@ -556,70 +509,33 @@ class DisplayManager:
         return phys
 
     def update_display(self):
-        """Update the display using double buffering with proper sync.
-
-        Skips the panel push entirely when the frame is byte-identical to
-        the last pushed one (same image digest AND same brightness) — static
-        content re-rendered every second, and 125 fps loops between actual
-        scroll steps, otherwise re-walk the full framebuffer for nothing.
-        The panel keeps refreshing the current frame from its own thread,
-        so skipping a swap never blanks or freezes the hardware.
-
-        Correctness hinges on invalidation: clear() resets the digest (it
-        writes to the matrix directly), and brightness is PART of the digest
-        so a dim-schedule change is never skipped. Disable via config
-        ``display.dirty_tracking: false`` if a redraw issue is ever suspected.
-
-        Serialized via ``_update_lock``: plugins can call this directly from
-        background threads (e.g. sports base classes push an immediate
-        "live" refresh from inside update()), so without a lock two callers
-        could both pass the digest check before either writes it back,
-        double-pushing a frame, or interleave the offscreen/current canvas
-        swap below. The lock is scoped to this method, so callers never
-        need to know about it.
-        """
+        """Update the display using double buffering with proper sync."""
         try:
-            with self._update_lock:
-                if self.matrix is None:
-                    # Fallback mode - no actual hardware to update
-                    logger.debug("Update display called in fallback mode (no hardware)")
-                    # Still write a snapshot so the web UI can preview
-                    self._write_snapshot_if_due()
-                    return
-
-                if self._capture_mode_active:
-                    return  # Skip hardware write — content is being captured off-screen
-
-                digest = None
-                if self._dirty_tracking_enabled:
-                    try:
-                        brightness = getattr(self.matrix, 'brightness', None)
-                    except AttributeError:
-                        brightness = None
-                    digest = (zlib.adler32(self.image.tobytes()), brightness)
-                    if digest == self._last_pushed_digest:
-                        # Nothing changed since the last push — the panel is
-                        # already showing exactly this frame.
-                        self._write_snapshot_if_due()
-                        return
-
-                # Copy the current image to the offscreen canvas. In double-sided
-                # mode the logical screen is first tiled across the full chain.
-                if self._double_sided is not None:
-                    self.offscreen_canvas.SetImage(self._composite_double_sided())
-                else:
-                    self.offscreen_canvas.SetImage(self.image)
-
-                # Swap buffers immediately
-                self.matrix.SwapOnVSync(self.offscreen_canvas)
-
-                # Swap our canvas references
-                self.offscreen_canvas, self.current_canvas = self.current_canvas, self.offscreen_canvas
-
-                self._last_pushed_digest = digest
-
-                # Write a snapshot for the web preview (throttled)
+            if self.matrix is None:
+                # Fallback mode - no actual hardware to update
+                logger.debug("Update display called in fallback mode (no hardware)")
+                # Still write a snapshot so the web UI can preview
                 self._write_snapshot_if_due()
+                return
+
+            if self._capture_mode_active:
+                return  # Skip hardware write — content is being captured off-screen
+
+            # Copy the current image to the offscreen canvas. In double-sided
+            # mode the logical screen is first tiled across the full chain.
+            if self._double_sided is not None:
+                self.offscreen_canvas.SetImage(self._composite_double_sided())
+            else:
+                self.offscreen_canvas.SetImage(self.image)
+
+            # Swap buffers immediately
+            self.matrix.SwapOnVSync(self.offscreen_canvas)
+            
+            # Swap our canvas references
+            self.offscreen_canvas, self.current_canvas = self.current_canvas, self.offscreen_canvas
+
+            # Write a snapshot for the web preview (throttled)
+            self._write_snapshot_if_due()
         except Exception as e:
             logger.error(f"Error updating display: {e}")
 
@@ -653,9 +569,6 @@ class DisplayManager:
                 # Clear both canvases and the underlying matrix to ensure no artifacts.
                 # Failures are non-fatal — the image buffer is already black above, so
                 # the next update_display() call will push clean content regardless.
-                # The matrix content no longer matches the last pushed digest,
-                # so dirty tracking must not skip the next push.
-                self._last_pushed_digest = None
                 try:
                     self.offscreen_canvas.Clear()
                 except (RuntimeError, OSError) as e:
@@ -786,15 +699,12 @@ class DisplayManager:
 
         Results are cached by (text, font identity) so plugins that measure
         the same string every frame (e.g. to centre a score) pay only one
-        measurement per unique (text, font) pair. The entry keeps the font
-        alive so its id() can't be recycled, and the cache is LRU-bounded so
-        ever-changing text (clocks, tickers) can't grow it without limit.
+        measurement per unique (text, font) pair.
         """
         cache_key = (text, id(font))
         cached = self._text_width_cache.get(cache_key)
         if cached is not None:
-            self._text_width_cache.move_to_end(cache_key)
-            return cached[0]
+            return cached
 
         try:
             if isinstance(font, freetype.Face):
@@ -809,9 +719,7 @@ class DisplayManager:
             logger.error("Error getting text width: %s", e)
             return 0
 
-        self._text_width_cache[cache_key] = (width, font)
-        while len(self._text_width_cache) > self._TEXT_WIDTH_CACHE_MAX:
-            self._text_width_cache.popitem(last=False)
+        self._text_width_cache[cache_key] = width
         return width
 
     def get_font_height(self, font):
@@ -1220,56 +1128,27 @@ class DisplayManager:
             'deferred_update_ttl': self._scrolling_state['deferred_update_ttl']
         }
 
-    def _viewer_is_fresh(self, now: float) -> bool:
-        """True when a browser preview is watching (marker file touched by
-        the web SSE broadcaster). The marker is stat'd at most once per
-        second — at 125 fps loops a per-call stat would be pure overhead."""
-        if (now - self._viewer_check_ts) >= 1.0:
-            self._viewer_check_ts = now
-            try:
-                marker_age = now - os.stat(self._viewer_marker_path).st_mtime
-                self._viewer_fresh = marker_age < snapshot_policy.VIEWER_MARKER_FRESH_SEC
-            except OSError:
-                self._viewer_fresh = False
-        return self._viewer_fresh
-
     def _write_snapshot_if_due(self) -> None:
-        """Mirror the current frame to the preview snapshot when the policy
-        says it's worth it — see src/common/snapshot_policy.py. Unchanged
-        frames are never re-encoded; without viewers the cadence drops to
-        the idle keepalive."""
+        """Write the current image to a PNG snapshot file at a limited frequency."""
         try:
             now = time.time()
-            viewer_fresh = self._viewer_is_fresh(now)
-            if viewer_fresh and not self._viewer_was_fresh:
-                # A preview just opened: let the next changed frame through
-                # immediately instead of waiting out the idle interval.
-                self._last_snapshot_ts = 0.0
-            self._viewer_was_fresh = viewer_fresh
-
-            digest = zlib.adler32(self.image.tobytes())
-            action = snapshot_policy.decide(
-                now, self._last_snapshot_ts, self._last_snapshot_touch_ts,
-                viewer_fresh, digest != self._last_snapshot_digest)
-            if action is snapshot_policy.SnapshotAction.SKIP:
+            if (now - self._last_snapshot_ts) < self._snapshot_min_interval_sec:
                 return
-            if action is snapshot_policy.SnapshotAction.TOUCH:
-                # mtime bump only: keeps the health check (snapshot age)
-                # green without paying for a PNG encode of an unchanged frame
-                os.utime(self._snapshot_path, None)
-                self._last_snapshot_touch_ts = now
-                return
-
-            # WRITE: ensure directory permissions once, not per frame
+            # Ensure directory exists with proper permissions
+            from pathlib import Path
+            from src.common.permission_utils import (
+                ensure_directory_permissions,
+                ensure_file_permissions,
+                get_assets_dir_mode,
+                get_assets_file_mode
+            )
             snapshot_path_obj = Path(self._snapshot_path)
-            if not self._snapshot_dir_prepared:
-                # Never modify /tmp permissions - it has special system
-                # permissions (1777) that must not be changed or it breaks
-                # apt and other system tools
-                parent_dir = snapshot_path_obj.parent
-                if parent_dir and str(parent_dir) != '/tmp':  # nosec B108 - guard to skip /tmp for permission ops
-                    ensure_directory_permissions(parent_dir, get_assets_dir_mode())
-                self._snapshot_dir_prepared = True
+            # Only ensure permissions on non-system directories
+            # Never modify /tmp permissions - it has special system permissions (1777)
+            # that must not be changed or it breaks apt and other system tools
+            parent_dir = snapshot_path_obj.parent
+            if parent_dir and str(parent_dir) != '/tmp':  # nosec B108 - guard to skip /tmp for permission ops
+                ensure_directory_permissions(parent_dir, get_assets_dir_mode())
             # Write atomically: temp then replace
             tmp_path = f"{self._snapshot_path}.tmp"
             self.image.save(tmp_path, format='PNG')
@@ -1284,18 +1163,6 @@ class DisplayManager:
             except Exception:
                 pass
             self._last_snapshot_ts = now
-            self._last_snapshot_touch_ts = now
-            self._last_snapshot_digest = digest
         except Exception as e:
-            # Snapshot failures must never break display — but they must not
-            # be silent either: the snapshot's mtime is the web UI's display
-            # mirror AND its hardware-liveness proxy, so a quietly failing
-            # write freezes the mirror and makes health checks lie (seen in
-            # the field: a stale root-owned /tmp file froze it for a day).
-            # Warn at most once per 5 minutes to avoid log spam.
-            if (now - self._snapshot_fail_log_ts) > 300:
-                self._snapshot_fail_log_ts = now
-                logger.warning("Snapshot write failing (web preview/health "
-                               "mirror is stale): %s", e)
-            else:
-                logger.debug(f"Snapshot write skipped: {e}")
+            # Snapshot failures should never break display; log at debug to avoid noise
+            logger.debug(f"Snapshot write skipped: {e}")

src/font_manager.py

@@ -35,7 +35,6 @@ import urllib.request
 import zipfile
 import tempfile
 import time
-from collections import OrderedDict
 from pathlib import Path
 from PIL import ImageFont
 from typing import Dict, Tuple, Optional, Union, Any, List
@@ -59,13 +58,7 @@ class FontManager:
         # Font discovery and catalog
         self.font_catalog: Dict[str, str] = {}  # family_name -> file_path
         self.font_cache: Dict[str, Union[ImageFont.FreeTypeFont, freetype.Face]] = {}  # (family, size) -> font
-        # (text, id(font)) -> ((width, height, baseline), font_ref).
-        # LRU-bounded — keys embed the measured TEXT, so changing strings
-        # (clocks, live scores) would otherwise grow it forever. Entries
-        # keep the font alive so its id() can't be recycled by a different
-        # font object (which would silently return wrong metrics).
-        self.metrics_cache: "OrderedDict[Any, Tuple[Tuple[int, int, int], Any]]" = OrderedDict()
-        self._METRICS_CACHE_MAX = 1024
+        self.metrics_cache: Dict[str, Tuple[int, int, int]] = {}  # (text, font_id) -> (width, height, baseline)
 
         # Plugin font management
         self.plugin_fonts: Dict[str, Dict[str, Any]] = {}  # plugin_id -> font_manifest
@@ -110,10 +103,6 @@ class FontManager:
         # Font overrides storage (for manual overrides)
         self.font_overrides_file = "config/font_overrides.json"
         self.font_overrides: Dict[str, Dict[str, Any]] = {}
-
-        # Bumped whenever cached font objects are invalidated, so holders of
-        # derived caches (e.g. adaptive-layout fit results) know to rebuild.
-        self.cache_generation = 0
         
         self._initialize_fonts()
     
@@ -123,7 +112,6 @@ class FontManager:
         self.fonts_config = new_config.get("fonts", {})
         self.font_cache.clear()  # Clear cache to force reload
         self.metrics_cache.clear()  # Clear metrics cache
-        self.cache_generation += 1
         self._initialize_fonts()
         logger.info("FontManager configuration reloaded successfully")
 
@@ -494,14 +482,6 @@ class FontManager:
     def _load_bdf_font(self, font_path: str, size_px: int) -> freetype.Face:
         """Load a BDF font using FreeType."""
         try:
-            native_size = self._read_bdf_native_size(font_path)
-            if native_size is not None and native_size != size_px:
-                # BDF is a fixed-strike bitmap format: FreeType renders the
-                # native size no matter what set_char_size asks for.
-                logger.debug(
-                    "BDF font %s requested at %spx but renders at its native "
-                    "%spx", font_path, size_px, native_size
-                )
             face = freetype.Face(font_path)
             # Set character size (width, height) in 1/64th of points
             face.set_char_size(size_px * 64, size_px * 64, 72, 72)
@@ -510,41 +490,6 @@ class FontManager:
             logger.error(f"Error loading BDF font {font_path}: {e}")
             raise
 
-    def get_native_bdf_size(self, family: str) -> Optional[int]:
-        """The one true pixel size of a BDF family in the catalog, or None
-        for scalable (TTF) families / unknown families."""
-        font_path = self.font_catalog.get(family)
-        if not font_path or not font_path.endswith('.bdf'):
-            return None
-        return self._read_bdf_native_size(font_path)
-
-    @staticmethod
-    def _read_bdf_native_size(bdf_path: str) -> Optional[int]:
-        """Read a BDF file's own header to find its one true pixel size.
-        Prefers the PIXEL_SIZE property, which states the real pixel height
-        directly; falls back to the SIZE line's point-size only if PIXEL_SIZE
-        is absent, since point-size only equals pixel height at exactly
-        100dpi — several bundled fonts (e.g. 6x13.bdf, 5x8.bdf) are defined
-        at 75dpi, where the two values genuinely differ."""
-        size_line_value = None
-        try:
-            with open(bdf_path, "r", encoding="ascii", errors="ignore") as f:
-                for line in f:
-                    if line.startswith("PIXEL_SIZE"):
-                        parts = line.split()
-                        if len(parts) >= 2:
-                            return int(float(parts[1]))
-                    elif line.startswith("SIZE") and size_line_value is None:
-                        # Format: "SIZE <point_size> <xres> <yres>"
-                        parts = line.split()
-                        if len(parts) >= 2:
-                            size_line_value = int(float(parts[1]))
-                    elif line.startswith("STARTCHAR"):
-                        break
-        except (OSError, ValueError):
-            return None
-        return size_line_value
-
     def _get_fallback_font(self) -> ImageFont.ImageFont:
         """Get a fallback font when loading fails."""
         return ImageFont.load_default()
@@ -562,14 +507,10 @@ class FontManager:
         Returns:
             Tuple of (width, height, baseline_offset)
         """
-        # Key on the text itself (hash(text) could collide) + font identity;
-        # the entry below keeps the font referenced so the id stays valid.
-        cache_key = (text, id(font))
+        cache_key = f"{hash(text)}_{id(font)}"
 
-        cached = self.metrics_cache.get(cache_key)
-        if cached is not None:
-            self.metrics_cache.move_to_end(cache_key)
-            return cached[0]
+        if cache_key in self.metrics_cache:
+            return self.metrics_cache[cache_key]
 
         try:
             if isinstance(font, freetype.Face):
@@ -606,9 +547,7 @@ class FontManager:
             baseline = 10
 
         result = (width, height, baseline)
-        self.metrics_cache[cache_key] = (result, font)
-        while len(self.metrics_cache) > self._METRICS_CACHE_MAX:
-            self.metrics_cache.popitem(last=False)
+        self.metrics_cache[cache_key] = result
         return result
 
     def get_font_height(self, font: Union[ImageFont.FreeTypeFont, freetype.Face]) -> int:

src/font_test_manager.py

@@ -0,0 +1,135 @@
+import os
+import freetype
+from PIL import ImageDraw, ImageFont
+import logging
+from typing import Dict, Any
+from src.display_manager import DisplayManager
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class FontTestManager:
+    """Manager for testing fonts with easy BDF/TTF switching."""
+    
+    def __init__(self, config: Dict[str, Any], display_manager: DisplayManager):
+        self.display_manager = display_manager
+        self.config = config
+        self.logger = logging.getLogger('FontTest')
+        
+        # FONT CONFIGURATION - EASY SWITCHING
+        # Set to 'bdf' or 'ttf' to switch font types
+        self.font_type = 'bdf'  # Change this to 'ttf' to use TTF font
+        
+        # Font configurations
+        self.font_configs = {
+            'bdf': {
+                'path': "assets/fonts/cozette.bdf",
+                'display_name': "Cozette BTF",
+                'description': "BTF font Test"
+            },
+            'ttf': {
+                'path': "assets/fonts/5by7.regular.ttf",
+                'display_name': "5by7 TTF",
+                'description': "TTF font test"
+            }
+        }
+        
+        # Get current font configuration
+        self.current_config = self.font_configs[self.font_type]
+        self.font_path = self.current_config['path']
+        
+        # Verify font exists
+        if not os.path.exists(self.font_path):
+            self.logger.error(f"Font file not found: {self.font_path}")
+            raise FileNotFoundError(f"Font file not found: {self.font_path}")
+        
+        # Load the font based on type
+        if self.font_type == 'bdf':
+            self._load_bdf_font()
+        else:
+            self._load_ttf_font()
+        
+        self.logger.info(f"Initialized FontTestManager with {self.current_config['description']}")
+    
+    def _load_bdf_font(self):
+        """Load BDF font using freetype."""
+        try:
+            self.face = freetype.Face(self.font_path)
+            self.logger.info(f"Successfully loaded BDF font from {self.font_path}")
+        except Exception as e:
+            self.logger.error(f"Failed to load BDF font: {e}")
+            raise
+    
+    def _load_ttf_font(self):
+        """Load TTF font using PIL."""
+        try:
+            self.font = ImageFont.truetype(self.font_path, 8)  # Size 8 for 5x7 font
+            self.logger.info(f"Successfully loaded TTF font from {self.font_path}")
+        except Exception as e:
+            self.logger.error(f"Failed to load TTF font: {e}")
+            raise
+    
+    def update(self):
+        """No update needed for static display."""
+    
+    def display(self, force_clear: bool = False):
+        """Display the font with sample text."""
+        try:
+            # Clear the display
+            self.display_manager.clear()
+            
+            # Draw font name at the top
+            self.display_manager.draw_text(self.current_config['display_name'], y=2, color=(255, 255, 255))
+            
+            # Draw sample text
+            draw = ImageDraw.Draw(self.display_manager.image)
+            sample_text = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            
+            # Calculate starting position
+            x = 10  # Start 10 pixels from the left
+            y = 10  # Start 10 pixels from the top
+            
+            # Draw text based on font type
+            if self.font_type == 'bdf':
+                self._draw_bdf_text(draw, sample_text, x, y)
+            else:
+                self._draw_ttf_text(draw, sample_text, x, y)
+            
+            # Update the display once
+            self.display_manager.update_display()
+            
+            # Log that display is complete
+            self.logger.info("Font test display complete.")
+            
+        except Exception as e:
+            self.logger.error(f"Error displaying font test: {e}", exc_info=True)
+    
+    def _draw_bdf_text(self, draw, text, x, y):
+        """Draw text using BDF font."""
+        for char in text:
+            # Load the glyph
+            self.face.load_char(char)
+            bitmap = self.face.glyph.bitmap
+            
+            # Draw the glyph
+            for i in range(bitmap.rows):
+                for j in range(bitmap.width):
+                    try:
+                        # Get the byte containing the pixel
+                        byte_index = i * bitmap.pitch + (j // 8)
+                        if byte_index < len(bitmap.buffer):
+                            byte = bitmap.buffer[byte_index]
+                            # Check if the specific bit is set
+                            if byte & (1 << (7 - (j % 8))):
+                                draw.point((x + j, y + i), fill=(255, 255, 255))
+                    except IndexError:
+                        self.logger.warning(f"Index out of range for char '{char}' at position ({i}, {j})")
+                        continue
+            
+            # Move to next character position
+            x += self.face.glyph.advance.x >> 6
+    
+    def _draw_ttf_text(self, draw, text, x, y):
+        """Draw text using TTF font."""
+        draw.text((x, y), text, font=self.font, fill=(255, 255, 255)) 

src/generic_cache_mixin.py

@@ -0,0 +1,150 @@
+"""
+Generic Cache Mixin for Any Manager
+
+This mixin provides caching functionality that can be used by any manager
+that needs to cache data, not just sports managers. It's a more general
+version of BackgroundCacheMixin that works for weather, stocks, news, etc.
+"""
+
+import time
+from typing import Dict, Optional, Any, Callable
+
+
+class GenericCacheMixin:
+    """
+    Generic mixin class that provides caching functionality to any manager.
+    
+    This mixin can be used by weather, stock, news, or any other manager
+    that needs to cache data with performance monitoring.
+    
+    Note: For sports managers that need background service cache integration,
+    use BackgroundCacheMixin instead. See src/background_cache_mixin.py for details.
+    """
+    
+    def _fetch_data_with_cache(self, 
+                             cache_key: str,
+                             api_fetch_method: Callable,
+                             cache_ttl: int = 300,
+                             force_refresh: bool = False) -> Optional[Dict]:
+        """
+        Generic caching pattern for any manager.
+        
+        Args:
+            cache_key: Unique cache key for this data
+            api_fetch_method: Method to call for fresh data
+            cache_ttl: Time-to-live in seconds (default: 5 minutes)
+            force_refresh: Skip cache and fetch fresh data
+            
+        Returns:
+            Cached or fresh data from API
+        """
+        start_time = time.time()
+        cache_hit = False
+        cache_source = None
+        
+        try:
+            # Check cache first (unless forcing refresh)
+            if not force_refresh:
+                cached_data = self.cache_manager.get_cached_data(cache_key, cache_ttl)
+                if cached_data:
+                    self.logger.info(f"Using cached data for {cache_key}")
+                    cache_hit = True
+                    cache_source = "cache"
+                    self.cache_manager.record_cache_hit('regular')
+                    
+                    # Record performance metrics
+                    duration = time.time() - start_time
+                    self.cache_manager.record_fetch_time(duration)
+                    self._log_fetch_performance(cache_key, duration, cache_hit, cache_source)
+                    
+                    return cached_data
+            
+            # Fetch fresh data
+            self.logger.info(f"Fetching fresh data for {cache_key}")
+            result = api_fetch_method()
+            cache_source = "api_fresh"
+            
+            # Store in cache if we got data
+            if result:
+                self.cache_manager.save_cache(cache_key, result)
+                self.cache_manager.record_cache_miss('regular')
+            else:
+                self.logger.warning(f"No data returned for {cache_key}")
+            
+            # Record performance metrics
+            duration = time.time() - start_time
+            self.cache_manager.record_fetch_time(duration)
+            
+            # Log performance
+            self._log_fetch_performance(cache_key, duration, cache_hit, cache_source)
+            
+            return result
+            
+        except Exception as e:
+            duration = time.time() - start_time
+            self.logger.error(f"Error fetching data for {cache_key} after {duration:.2f}s: {e}")
+            self.cache_manager.record_fetch_time(duration)
+            raise
+    
+    def _log_fetch_performance(self, cache_key: str, duration: float, cache_hit: bool, cache_source: str):
+        """
+        Log detailed performance metrics for fetch operations.
+        
+        Args:
+            cache_key: Cache key that was accessed
+            duration: Fetch operation duration in seconds
+            cache_hit: Whether this was a cache hit
+            cache_source: Source of the data (cache, api_fresh, etc.)
+        """
+        # Log basic performance info
+        self.logger.info(f"Fetch completed for {cache_key} in {duration:.2f}s "
+                        f"(cache_hit={cache_hit}, source={cache_source})")
+        
+        # Log detailed metrics every 10 operations
+        if hasattr(self, '_fetch_count'):
+            self._fetch_count += 1
+        else:
+            self._fetch_count = 1
+            
+        if self._fetch_count % 10 == 0:
+            metrics = self.cache_manager.get_cache_metrics()
+            self.logger.info(f"Cache Performance Summary - "
+                           f"Hit Rate: {metrics['cache_hit_rate']:.2%}, "
+                           f"API Calls Saved: {metrics['api_calls_saved']}, "
+                           f"Avg Fetch Time: {metrics['average_fetch_time']:.2f}s")
+    
+    def get_cache_performance_summary(self) -> Dict[str, Any]:
+        """
+        Get cache performance summary for this manager.
+        
+        Returns:
+            Dictionary containing cache performance metrics
+        """
+        return self.cache_manager.get_cache_metrics()
+    
+    def log_cache_performance(self):
+        """Log current cache performance metrics."""
+        self.cache_manager.log_cache_metrics()
+    
+    def clear_cache_for_key(self, cache_key: str):
+        """Clear cache for a specific key."""
+        self.cache_manager.clear_cache(cache_key)
+        self.logger.info(f"Cleared cache for {cache_key}")
+    
+    def get_cache_info(self, cache_key: str) -> Dict[str, Any]:
+        """
+        Get information about a cached item.
+        
+        Args:
+            cache_key: Cache key to check
+            
+        Returns:
+            Dictionary with cache information
+        """
+        # This would need to be implemented in CacheManager
+        # For now, just return basic info
+        return {
+            'key': cache_key,
+            'exists': self.cache_manager.get_cached_data(cache_key, 0) is not None,
+            'ttl': 'unknown'  # Would need to be implemented
+        }

src/image_utils.py

@@ -0,0 +1,16 @@
+import logging
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+def scale_to_max_dimensions(img, max_width, max_height):
+    h_to_w_ratio = img.height / img.width
+    w_to_h_ratio = img.width / img.height
+
+    if img.height > max_height:
+        img = img.resize((int(max_height * w_to_h_ratio), max_height), Image.Resampling.LANCZOS)
+    
+    if img.width > max_width:
+        img = img.resize((max_width, int(max_width * h_to_w_ratio)), Image.Resampling.LANCZOS)
+    
+    return img

src/layout_manager.py

@@ -0,0 +1,409 @@
+"""
+Layout Manager for LED Matrix Display
+Handles custom layouts, element positioning, and display composition.
+"""
+
+import json
+import os
+import logging
+from typing import Dict, List, Any
+from datetime import datetime
+
+logger = logging.getLogger(__name__)
+
+class LayoutManager:
+    def __init__(self, display_manager=None, config_path="config/custom_layouts.json"):
+        self.display_manager = display_manager
+        self.config_path = config_path
+        self.layouts = self.load_layouts()
+        self.current_layout = None
+        
+    def load_layouts(self) -> Dict[str, Any]:
+        """Load saved layouts from file."""
+        try:
+            if os.path.exists(self.config_path):
+                with open(self.config_path, 'r') as f:
+                    return json.load(f)
+            return {}
+        except Exception as e:
+            logger.error(f"Error loading layouts: {e}")
+            return {}
+    
+    def save_layouts(self) -> bool:
+        """Save layouts to file."""
+        try:
+            from pathlib import Path
+            from src.common.permission_utils import (
+                ensure_directory_permissions,
+                get_config_dir_mode
+            )
+            config_path_obj = Path(self.config_path)
+            ensure_directory_permissions(config_path_obj.parent, get_config_dir_mode())
+            with open(self.config_path, 'w') as f:
+                json.dump(self.layouts, f, indent=2)
+            return True
+        except Exception as e:
+            logger.error(f"Error saving layouts: {e}")
+            return False
+    
+    def create_layout(self, name: str, elements: List[Dict], description: str = "") -> bool:
+        """Create a new layout."""
+        try:
+            self.layouts[name] = {
+                'elements': elements,
+                'description': description,
+                'created': datetime.now().isoformat(),
+                'modified': datetime.now().isoformat()
+            }
+            return self.save_layouts()
+        except Exception as e:
+            logger.error(f"Error creating layout '{name}': {e}")
+            return False
+    
+    def update_layout(self, name: str, elements: List[Dict], description: str = None) -> bool:
+        """Update an existing layout."""
+        try:
+            if name not in self.layouts:
+                return False
+            
+            self.layouts[name]['elements'] = elements
+            self.layouts[name]['modified'] = datetime.now().isoformat()
+            
+            if description is not None:
+                self.layouts[name]['description'] = description
+                
+            return self.save_layouts()
+        except Exception as e:
+            logger.error(f"Error updating layout '{name}': {e}")
+            return False
+    
+    def delete_layout(self, name: str) -> bool:
+        """Delete a layout."""
+        try:
+            if name in self.layouts:
+                del self.layouts[name]
+                return self.save_layouts()
+            return False
+        except Exception as e:
+            logger.error(f"Error deleting layout '{name}': {e}")
+            return False
+    
+    def get_layout(self, name: str) -> Dict[str, Any]:
+        """Get a specific layout."""
+        return self.layouts.get(name, {})
+    
+    def list_layouts(self) -> List[str]:
+        """Get list of all layout names."""
+        return list(self.layouts.keys())
+    
+    def set_current_layout(self, name: str) -> bool:
+        """Set the current active layout."""
+        if name in self.layouts:
+            self.current_layout = name
+            return True
+        return False
+    
+    def render_layout(self, layout_name: str = None, data_context: Dict = None) -> bool:
+        """Render a layout to the display."""
+        if not self.display_manager:
+            logger.error("No display manager available")
+            return False
+        
+        layout_name = layout_name or self.current_layout
+        if not layout_name or layout_name not in self.layouts:
+            logger.error(f"Layout '{layout_name}' not found")
+            return False
+        
+        try:
+            # Clear the display
+            self.display_manager.clear()
+            
+            # Get layout elements
+            elements = self.layouts[layout_name]['elements']
+            
+            # Render each element
+            for element in elements:
+                self.render_element(element, data_context or {})
+            
+            # Update the display
+            self.display_manager.update_display()
+            return True
+            
+        except Exception as e:
+            logger.error(f"Error rendering layout '{layout_name}': {e}")
+            return False
+    
+    def render_element(self, element: Dict, data_context: Dict) -> None:
+        """Render a single element."""
+        element_type = element.get('type')
+        x = element.get('x', 0)
+        y = element.get('y', 0)
+        properties = element.get('properties', {})
+        
+        try:
+            if element_type == 'text':
+                self._render_text_element(x, y, properties, data_context)
+            elif element_type == 'weather_icon':
+                self._render_weather_icon_element(x, y, properties, data_context)
+            elif element_type == 'rectangle':
+                self._render_rectangle_element(x, y, properties)
+            elif element_type == 'line':
+                self._render_line_element(x, y, properties)
+            elif element_type == 'clock':
+                self._render_clock_element(x, y, properties)
+            elif element_type == 'data_text':
+                self._render_data_text_element(x, y, properties, data_context)
+            else:
+                logger.warning(f"Unknown element type: {element_type}")
+                
+        except Exception as e:
+            logger.error(f"Error rendering element {element_type}: {e}")
+    
+    def _render_text_element(self, x: int, y: int, properties: Dict, data_context: Dict) -> None:
+        """Render a text element."""
+        text = properties.get('text', 'Sample Text')
+        color = tuple(properties.get('color', [255, 255, 255]))
+        font_size = properties.get('font_size', 'normal')
+        
+        # Support template variables in text
+        text = self._process_template_text(text, data_context)
+        
+        # Select font
+        if font_size == 'small':
+            font = self.display_manager.small_font
+        elif font_size == 'large':
+            font = self.display_manager.regular_font
+        else:
+            font = self.display_manager.regular_font
+        
+        self.display_manager.draw_text(text, x, y, color, font=font)
+    
+    def _render_weather_icon_element(self, x: int, y: int, properties: Dict, data_context: Dict) -> None:
+        """Render a weather icon element."""
+        condition = properties.get('condition', 'sunny')
+        size = properties.get('size', 16)
+        
+        # Use weather data from context if available
+        if 'weather' in data_context and 'condition' in data_context['weather']:
+            condition = data_context['weather']['condition'].lower()
+        
+        self.display_manager.draw_weather_icon(condition, x, y, size)
+    
+    def _render_rectangle_element(self, x: int, y: int, properties: Dict) -> None:
+        """Render a rectangle element."""
+        width = properties.get('width', 10)
+        height = properties.get('height', 10)
+        color = tuple(properties.get('color', [255, 255, 255]))
+        filled = properties.get('filled', False)
+        
+        if filled:
+            self.display_manager.draw.rectangle(
+                [x, y, x + width, y + height], 
+                fill=color
+            )
+        else:
+            self.display_manager.draw.rectangle(
+                [x, y, x + width, y + height], 
+                outline=color
+            )
+    
+    def _render_line_element(self, x: int, y: int, properties: Dict) -> None:
+        """Render a line element."""
+        x2 = properties.get('x2', x + 10)
+        y2 = properties.get('y2', y)
+        color = tuple(properties.get('color', [255, 255, 255]))
+        width = properties.get('width', 1)
+        
+        self.display_manager.draw.line([x, y, x2, y2], fill=color, width=width)
+    
+    def _render_clock_element(self, x: int, y: int, properties: Dict) -> None:
+        """Render a clock element."""
+        format_str = properties.get('format', '%H:%M')
+        color = tuple(properties.get('color', [255, 255, 255]))
+        
+        current_time = datetime.now().strftime(format_str)
+        self.display_manager.draw_text(current_time, x, y, color)
+    
+    def _render_data_text_element(self, x: int, y: int, properties: Dict, data_context: Dict) -> None:
+        """Render a data-driven text element."""
+        data_key = properties.get('data_key', '')
+        format_str = properties.get('format', '{value}')
+        color = tuple(properties.get('color', [255, 255, 255]))
+        default_value = properties.get('default', 'N/A')
+        
+        # Extract data from context
+        value = self._get_nested_value(data_context, data_key, default_value)
+        
+        # Format the text
+        try:
+            text = format_str.format(value=value)
+        except (ValueError, TypeError, KeyError, IndexError):
+            text = str(value)
+        
+        self.display_manager.draw_text(text, x, y, color)
+    
+    def _process_template_text(self, text: str, data_context: Dict) -> str:
+        """Process template variables in text."""
+        try:
+            # Simple template processing - replace {key} with values from context
+            for key, value in data_context.items():
+                placeholder = f"{{{key}}}"
+                if placeholder in text:
+                    text = text.replace(placeholder, str(value))
+            return text
+        except Exception as e:
+            logger.error(f"Error processing template text: {e}")
+            return text
+    
+    def _get_nested_value(self, data: Dict, key: str, default=None):
+        """Get a nested value from a dictionary using dot notation."""
+        try:
+            keys = key.split('.')
+            value = data
+            for k in keys:
+                value = value[k]
+            return value
+        except (KeyError, TypeError):
+            return default
+    
+    def create_preset_layouts(self) -> None:
+        """Create some preset layouts for common use cases."""
+        # Basic clock layout
+        clock_layout = [
+            {
+                'type': 'clock',
+                'x': 10,
+                'y': 10,
+                'properties': {
+                    'format': '%H:%M',
+                    'color': [255, 255, 255]
+                }
+            },
+            {
+                'type': 'clock',
+                'x': 10,
+                'y': 20,
+                'properties': {
+                    'format': '%m/%d',
+                    'color': [100, 100, 255]
+                }
+            }
+        ]
+        self.create_layout('basic_clock', clock_layout, 'Simple clock with date')
+        
+        # Weather layout
+        weather_layout = [
+            {
+                'type': 'weather_icon',
+                'x': 5,
+                'y': 5,
+                'properties': {
+                    'condition': 'sunny',
+                    'size': 20
+                }
+            },
+            {
+                'type': 'data_text',
+                'x': 30,
+                'y': 8,
+                'properties': {
+                    'data_key': 'weather.temperature',
+                    'format': '{value}°',
+                    'color': [255, 200, 0],
+                    'default': '--°'
+                }
+            },
+            {
+                'type': 'data_text',
+                'x': 30,
+                'y': 18,
+                'properties': {
+                    'data_key': 'weather.condition',
+                    'format': '{value}',
+                    'color': [200, 200, 200],
+                    'default': 'Unknown'
+                }
+            }
+        ]
+        self.create_layout('weather_display', weather_layout, 'Weather icon with temperature and condition')
+        
+        # Mixed dashboard layout
+        dashboard_layout = [
+            {
+                'type': 'clock',
+                'x': 2,
+                'y': 2,
+                'properties': {
+                    'format': '%H:%M',
+                    'color': [255, 255, 255]
+                }
+            },
+            {
+                'type': 'weather_icon',
+                'x': 50,
+                'y': 2,
+                'properties': {
+                    'size': 16
+                }
+            },
+            {
+                'type': 'data_text',
+                'x': 70,
+                'y': 5,
+                'properties': {
+                    'data_key': 'weather.temperature',
+                    'format': '{value}°',
+                    'color': [255, 200, 0],
+                    'default': '--°'
+                }
+            },
+            {
+                'type': 'line',
+                'x': 0,
+                'y': 15,
+                'properties': {
+                    'x2': 128,
+                    'y2': 15,
+                    'color': [100, 100, 100]
+                }
+            },
+            {
+                'type': 'data_text',
+                'x': 2,
+                'y': 18,
+                'properties': {
+                    'data_key': 'stocks.AAPL.price',
+                    'format': 'AAPL: ${value}',
+                    'color': [0, 255, 0],
+                    'default': 'AAPL: N/A'
+                }
+            }
+        ]
+        self.create_layout('dashboard', dashboard_layout, 'Mixed dashboard with clock, weather, and stocks')
+        
+        logger.info("Created preset layouts")
+
+    def get_layout_preview(self, layout_name: str) -> Dict[str, Any]:
+        """Get a preview representation of a layout."""
+        if layout_name not in self.layouts:
+            return {}
+        
+        layout = self.layouts[layout_name]
+        elements = layout['elements']
+        
+        # Create a simple preview representation
+        preview = {
+            'name': layout_name,
+            'description': layout.get('description', ''),
+            'element_count': len(elements),
+            'elements': []
+        }
+        
+        for element in elements:
+            preview['elements'].append({
+                'type': element.get('type'),
+                'position': f"({element.get('x', 0)}, {element.get('y', 0)})",
+                'properties': list(element.get('properties', {}).keys())
+            })
+        
+        return preview

src/plugin_system/base_plugin.py

@@ -15,19 +15,6 @@ import logging
 from src.logging_config import get_logger
 
 
-_shared_fallback_font_manager: Optional[Any] = None
-
-
-def _fallback_font_manager() -> Any:
-    """Shared FontManager for environments (unit tests, mocks) where the
-    plugin manager doesn't carry one. Scans assets/fonts like the real one."""
-    global _shared_fallback_font_manager
-    if _shared_fallback_font_manager is None:
-        from src.font_manager import FontManager
-        _shared_fallback_font_manager = FontManager({})
-    return _shared_fallback_font_manager
-
-
 class VegasDisplayMode(Enum):
     """
     Display mode for Vegas scroll integration.
@@ -143,133 +130,6 @@ class BasePlugin(ABC):
         """
         raise NotImplementedError("Plugins must implement display()")
 
-    # -------------------------------------------------------------------------
-    # Adaptive layout support (opt-in)
-    # -------------------------------------------------------------------------
-    @property
-    def layout(self) -> Any:
-        """
-        LayoutContext for the current logical display size.
-
-        Lazily built and rebuilt automatically when the display size changes
-        (e.g. Vegas segment widths, double-sided logical screens). Provides
-        Region carving (self.layout.bounds), breakpoint tiers, a geometry
-        scale factor vs. the manifest's display.design_size, and fit-text
-        queries against font ladders. See src/adaptive_layout.py.
-
-        Example:
-            rows = self.layout.bounds.inset(1).split_v(3, 1, gap=1)
-            self.draw_fit(big_text, rows[0], ladder=LADDER_ARCADE)
-            self.draw_fit(small_text, rows[1])
-        """
-        from src.adaptive_layout import LayoutContext
-
-        width = getattr(self.display_manager, "width", None)
-        height = getattr(self.display_manager, "height", None)
-        if not width or not height:
-            matrix = getattr(self.display_manager, "matrix", None)
-            width = getattr(matrix, "width", 128)
-            height = getattr(matrix, "height", 32)
-
-        font_manager = self._get_font_manager()
-        generation = getattr(font_manager, "cache_generation", 0)
-        cached = getattr(self, "_layout_context", None)
-        if (cached is not None
-                and (cached.width, cached.height) == (width, height)
-                and getattr(self, "_layout_font_generation", None) == generation):
-            return cached
-
-        context = LayoutContext(
-            width, height, font_manager,
-            design_size=self._get_design_size(),
-        )
-        self._layout_context = context
-        self._layout_font_generation = generation
-        return context
-
-    def draw_fit(self, text: str, box: Any,
-                 color: tuple = (255, 255, 255),
-                 ladder: Optional[Any] = None,
-                 align: str = "center", valign: str = "center") -> Any:
-        """
-        Fit text to a Region with the largest crisp font that fits, then draw
-        it aligned within that region via the display manager.
-
-        Args:
-            text: Text to display (ellipsized if even the smallest rung is too wide)
-            box: Region (or (w, h) tuple anchored at 0,0) to fit and align within
-            color: RGB color tuple
-            ladder: FontLadder to walk (default LADDER_GRID; use LADDER_ARCADE
-                    for headline text like clocks and scores)
-            align/valign: alignment of the text ink within the box
-
-        Returns:
-            FitResult (font, family, size_px, text, ink metrics, fits flag)
-        """
-        from src.adaptive_layout import LADDER_DEFAULT, draw_fitted_text
-
-        fit = self.layout.fit_text(text, box, ladder=ladder or LADDER_DEFAULT)
-        draw_fitted_text(self.display_manager, fit, box,
-                         color=color, align=align, valign=valign)
-        return fit
-
-    def draw_image(self, img: Any, box: Any, *,
-                   mode: str = "contain", align: str = "center",
-                   valign: str = "center", crop_to_ink: bool = False,
-                   anchor: str = "center", resample: Optional[Any] = None,
-                   cache_key: Optional[Any] = None,
-                   offset: tuple = (0, 0)) -> Any:
-        """
-        Fit an image into a Region and paste it aligned within that region
-        onto the display canvas — the image counterpart to draw_fit().
-
-        Args:
-            img: Source PIL image (logos, art, icons)
-            box: Region (or (w, h) tuple) to fit and align within
-            mode: "contain" (letterbox), "cover" (crop-to-fill),
-                  "fill_height" (logo-style), "stretch"
-            crop_to_ink: Trim transparent padding before fitting
-            anchor: "center" or "top" for cover crops
-            resample: PIL filter; default LANCZOS. Use RESAMPLE_NEAREST
-                  (from src.adaptive_images) for pixel art/flags
-            cache_key: Stable identity (e.g. "logo:KC") for cross-reload
-                  caching; defaults to the image object's identity
-            offset: Final (dx, dy) translation — the hook for user
-                  x/y-offset customization
-
-        Returns:
-            ImageFitResult (processed image + dimensions + scale)
-        """
-        from src.adaptive_images import draw_fitted_image
-
-        ifit = self.layout.fit_image(img, box, mode=mode,
-                                     crop_to_ink=crop_to_ink, anchor=anchor,
-                                     resample=resample, cache_key=cache_key)
-        draw_fitted_image(self.display_manager, ifit, box,
-                          align=align, valign=valign, offset=offset)
-        return ifit
-
-    def _get_font_manager(self) -> Any:
-        """The shared FontManager, or a module-level fallback when running
-        under mocks/harnesses that don't provide one."""
-        font_manager = getattr(self.plugin_manager, "font_manager", None)
-        if font_manager is not None and hasattr(font_manager, "get_font"):
-            return font_manager
-        return _fallback_font_manager()
-
-    def _get_design_size(self) -> tuple:
-        """Panel size this plugin's layout was authored against, from the
-        manifest's optional display.design_size (defaults to 128x32)."""
-        from src.adaptive_layout import DEFAULT_DESIGN_SIZE
-
-        if self.plugin_manager and hasattr(self.plugin_manager, "plugin_manifests"):
-            manifest = self.plugin_manager.plugin_manifests.get(self.plugin_id, {})
-            declared = manifest.get("display", {}).get("design_size", {})
-            width, height = declared.get("width"), declared.get("height")
-            if width and height:
-                return (int(width), int(height))
-        return DEFAULT_DESIGN_SIZE
-
     def get_display_duration(self) -> float:
         """
         Get the display duration for this plugin instance.

src/plugin_system/plugin_loader.py

@@ -437,7 +437,8 @@ class PluginLoader:
                 if not Path(existing_file).resolve().is_relative_to(resolved_dir):
                     evicted[mod_name] = sys.modules.pop(mod_name)
                     self.logger.debug(
-                        "Evicted stale bare-name module '%s' before loading plugin", mod_name,
+                        "Evicted stale module '%s' (from %s) before loading plugin in %s",
+                        mod_name, existing_file, plugin_dir,
                     )
             except (ValueError, TypeError):
                 continue
@@ -550,7 +551,7 @@ class PluginLoader:
             plugin_dir_str = str(plugin_dir)
             if plugin_dir_str not in sys.path:
                 sys.path.insert(0, plugin_dir_str)
-                self.logger.debug("Added plugin %s's directory to sys.path", plugin_id)
+                self.logger.debug("Added plugin directory to sys.path: %s", plugin_dir_str)
 
             # Import the plugin module
             module_name = f"plugin_{plugin_id.replace('-', '_')}"
@@ -562,8 +563,8 @@ class PluginLoader:
 
             spec = importlib.util.spec_from_file_location(module_name, entry_file)
             if spec is None or spec.loader is None:
-                self.logger.error("Could not create module spec for plugin %s", plugin_id)
                 error_msg = f"Could not create module spec for {entry_file}"
+                self.logger.error(error_msg)
                 raise PluginError(error_msg, plugin_id=plugin_id, context={'entry_file': str(entry_file)})
 
             module = importlib.util.module_from_spec(spec)
@@ -682,55 +683,6 @@ class PluginLoader:
             self.logger.error(error_msg, exc_info=True)
             raise PluginError(error_msg, plugin_id=plugin_id) from e
     
-    @staticmethod
-    def _parse_semver(value: Any) -> Optional[Tuple[int, int, int]]:
-        """Parse 'X.Y.Z' (extra parts/suffixes ignored) into a comparable
-        3-tuple, or None when unparseable."""
-        if not isinstance(value, str):
-            return None
-        parts = value.strip().lstrip('v').split('.')
-        try:
-            nums = [int(''.join(ch for ch in p if ch.isdigit()) or 0) for p in parts[:3]]
-        except ValueError:
-            return None
-        while len(nums) < 3:
-            nums.append(0)
-        return tuple(nums)  # type: ignore[return-value]
-
-    def _warn_if_incompatible(self, plugin_id: str, manifest: Dict[str, Any]) -> None:
-        """Log one warning when a plugin declares a minimum LEDMatrix version
-        newer than the running core. Advisory only — never raises — so a
-        plugin that guards optional features with try/except keeps working.
-        """
-        declared = (
-            manifest.get('min_ledmatrix_version')
-            or manifest.get('requires', {}).get('min_ledmatrix_version')
-        )
-        if not declared:
-            versions = manifest.get('versions') or []
-            if versions and isinstance(versions[0], dict):
-                declared = (versions[0].get('ledmatrix_min_version')
-                            or versions[0].get('ledmatrix_min'))
-        needed = self._parse_semver(declared)
-        if needed is None:
-            return
-
-        from src import __version__ as core_version
-        current = self._parse_semver(core_version)
-        # Anti-spam guard: if the core's own version number is stale (below
-        # the ecosystem floor every shipped plugin declares), comparing would
-        # warn on nearly everything — skip with a debug note instead.
-        if current is None or current < (2, 0, 0):
-            self.logger.debug(
-                "Skipping version compatibility check for %s: core __version__ "
-                "(%s) is below the ecosystem floor", plugin_id, core_version)
-            return
-        if needed > current:
-            self.logger.warning(
-                "Plugin %s declares min LEDMatrix version %s but this core is %s — "
-                "features it relies on may be missing; update the core or expect "
-                "degraded fallbacks", plugin_id, declared, core_version)
-
     def load_plugin(
         self,
         plugin_id: str,
@@ -763,8 +715,6 @@ class PluginLoader:
         Raises:
             PluginError: If loading fails
         """
-        self._warn_if_incompatible(plugin_id, manifest)
-
         # Install dependencies if needed
         if install_deps:
             if plugins_dir is None:

src/plugin_system/plugin_manager.py

@@ -8,13 +8,12 @@ API Version: 1.0.0
 """
 
 import json
-import queue
 import sys
 import time
 import threading
 import types
 from pathlib import Path
-from typing import Dict, List, Optional, Any, Tuple
+from typing import Dict, List, Optional, Any
 import logging
 from src.exceptions import PluginError, ConfigError
 from src.logging_config import get_logger
@@ -77,12 +76,6 @@ class PluginManager:
         # concurrent mutation (background reconciliation) and reads (requests).
         self._discovery_lock = threading.RLock()
 
-        # Lock protecting plugin_last_update from concurrent mutation/iteration.
-        # It's written from run_scheduled_updates()/update_all_plugins() (main
-        # loop) and read/diffed by run_scheduled_updates_with_changes(), which
-        # Vegas mode calls from its own background update-tick thread.
-        self._plugin_last_update_lock = threading.RLock()
-
         # Active plugins
         self.plugins: Dict[str, Any] = {}
         self.plugin_manifests: Dict[str, Dict[str, Any]] = {}
@@ -98,50 +91,6 @@ class PluginManager:
         # Health tracking (optional, set by display_controller if available)
         self.health_tracker = None
         self.resource_monitor = None
-
-        # --- Asynchronous plugin updates -------------------------------
-        # update() used to run inline in the render loop (execute_update's
-        # internal thread.join(timeout=30) blocked it), so one slow plugin
-        # HTTP fetch froze scrolling for the whole fetch. Scheduling still
-        # happens on the render thread (run_scheduled_updates), but
-        # execution moves to this single background worker. Per-plugin
-        # locks keep a plugin's update() and display() mutually exclusive —
-        # today's implicit guarantee, now explicit (and, unlike today,
-        # also held across the post-timeout window).
-        # Kill switch: plugin_system.synchronous_updates: true restores the
-        # inline path.
-        self._update_queue: "queue.Queue[Optional[Tuple[str, float]]]" = queue.Queue()
-        self._pending_updates: set = set()
-        self._pending_lock = threading.Lock()
-        self._plugin_locks: Dict[str, threading.Lock] = {}
-        self._plugin_locks_guard = threading.Lock()
-        self._update_worker: Optional[threading.Thread] = None
-        self._synchronous_updates = False
-        if self.config_manager is not None:
-            try:
-                cfg = self.config_manager.get_config() or {}
-            except (OSError, ValueError) as exc:
-                self.logger.warning(
-                    "Could not load config to check plugin_system.synchronous_updates "
-                    "(%s: %s); defaulting to synchronous updates", type(exc).__name__, exc)
-                self._synchronous_updates = True
-            else:
-                plugin_system_cfg = cfg.get('plugin_system', {})
-                if not isinstance(plugin_system_cfg, dict):
-                    self.logger.warning(
-                        "config plugin_system must be a mapping, got %s; "
-                        "defaulting to synchronous updates",
-                        type(plugin_system_cfg).__name__)
-                    self._synchronous_updates = True
-                else:
-                    sync_value = plugin_system_cfg.get('synchronous_updates', False)
-                    if not isinstance(sync_value, bool):
-                        self.logger.warning(
-                            "config plugin_system.synchronous_updates must be a boolean, "
-                            "got %r; defaulting to synchronous updates", sync_value)
-                        self._synchronous_updates = True
-                    else:
-                        self._synchronous_updates = sync_value
         
         # Ensure plugins directory exists with proper permissions
         try:
@@ -368,8 +317,7 @@ class PluginManager:
 
             # Store plugin instance
             self.plugins[plugin_id] = plugin_instance
-            with self._plugin_last_update_lock:
-                self.plugin_last_update[plugin_id] = 0.0
+            self.plugin_last_update[plugin_id] = 0.0
             # Invalidate cached interval so next tick re-derives it for this plugin
             self._update_interval_cache.pop(plugin_id, None)
             
@@ -481,8 +429,7 @@ class PluginManager:
             
             # Remove from active plugins
             del self.plugins[plugin_id]
-            with self._plugin_last_update_lock:
-                self.plugin_last_update.pop(plugin_id, None)
+            self.plugin_last_update.pop(plugin_id, None)
             self._update_interval_cache.pop(plugin_id, None)
             
             # Remove main module from sys.modules if present
@@ -751,8 +698,7 @@ class PluginManager:
             'recoverable': True,
         }
         self.logger.warning("Plugin %s update() failed; will retry after interval", plugin_id)
-        with self._plugin_last_update_lock:
-            self.plugin_last_update[plugin_id] = failure_time
+        self.plugin_last_update[plugin_id] = failure_time
         self.state_manager.set_state_with_error(plugin_id, PluginState.ENABLED, error_info, error=err)
         if self.health_tracker:
             self.health_tracker.record_failure(plugin_id, err)
@@ -785,218 +731,49 @@ class PluginManager:
             if interval is None:
                 continue
 
-            with self._plugin_last_update_lock:
-                last_update = self.plugin_last_update.get(plugin_id, 0.0)
+            last_update = self.plugin_last_update.get(plugin_id, 0.0)
 
             if last_update == 0.0 or (current_time - last_update) >= interval:
-                if self._synchronous_updates:
-                    # Kill-switch path: the original inline execution
-                    # (blocks the caller until update() completes/times out)
-                    self.state_manager.set_state(plugin_id, PluginState.RUNNING)
-                    self._execute_update_now(plugin_id, plugin_instance, current_time)
-                else:
-                    self._enqueue_update(plugin_id, current_time)
-
-    def get_plugin_lock(self, plugin_id: str) -> threading.Lock:
-        """Per-plugin lock keeping update() and display() mutually exclusive.
-
-        The update worker holds it for the duration of a plugin's update();
-        the display side acquires it non-blocking and skips that frame's
-        display() call when the plugin is mid-update.
-        """
-        with self._plugin_locks_guard:
-            lock = self._plugin_locks.get(plugin_id)
-            if lock is None:
-                lock = threading.Lock()
-                self._plugin_locks[plugin_id] = lock
-            return lock
-
-    def _enqueue_update(self, plugin_id: str, scheduled_time: float) -> None:
-        """Queue a due update for the background worker (dedup while pending)."""
-        with self._pending_lock:
-            if plugin_id in self._pending_updates:
-                return
-            self._pending_updates.add(plugin_id)
-        # RUNNING is set at enqueue time so can_execute() blocks re-entry and
-        # the web UI shows the truthful state while the item waits its turn.
-        self.state_manager.set_state(plugin_id, PluginState.RUNNING)
-        self._ensure_update_worker()
-        self._update_queue.put((plugin_id, scheduled_time))
-
-    def _ensure_update_worker(self) -> None:
-        if self._update_worker is not None and self._update_worker.is_alive():
-            return
-        self._update_worker = threading.Thread(
-            target=self._update_worker_loop, name='plugin-update-worker',
-            daemon=True)
-        self._update_worker.start()
-
-    def _update_worker_loop(self) -> None:
-        """Single worker: dispatches queued updates off the render thread
-        (matching the old inline behavior — no thundering herd of
-        concurrent fetches).
-
-        The plugin's lock is acquired here, before its instance is looked
-        up, and the instance is re-fetched under the lock — a concurrent
-        unload_plugin() can't leave this loop about to run update() on an
-        instance that's already been torn down. The lock — and RUNNING/
-        pending lifecycle state — is released by the update itself once the
-        real update() call genuinely finishes (see _execute_update_now),
-        which can be after this dispatch returns if PluginExecutor's own
-        timeout elapses first.
-        """
-        while True:
-            item = self._update_queue.get()
-            if item is None:  # shutdown sentinel
-                return
-            plugin_id, scheduled_time = item
-            lock = self.get_plugin_lock(plugin_id)
-            lock.acquire()
-            plugin_instance = self.plugins.get(plugin_id)
-            if plugin_instance is None:  # unloaded while queued; its
-                # lifecycle state was already cleared by unload_plugin —
-                # leave it alone rather than resurrecting it to ENABLED
-                lock.release()
-                with self._pending_lock:
-                    self._pending_updates.discard(plugin_id)
-                continue
-            try:
-                self._execute_update_now(plugin_id, plugin_instance,
-                                         scheduled_time, lock=lock)
-            except Exception:  # pylint: disable=broad-except
-                # _execute_update_now guarantees the lock/pending bookkeeping
-                # is released via its own _finish() before returning or
-                # raising; this is a last-resort log only.
-                self.logger.exception("update worker: unexpected error for %s",
-                                      plugin_id)
-
-    def stop_update_worker(self, timeout: float = 5.0) -> None:
-        """Signal the worker to exit (used by cleanup; thread is a daemon)."""
-        if self._update_worker is not None and self._update_worker.is_alive():
-            self._update_queue.put(None)
-            self._update_worker.join(timeout=timeout)
-            if self._update_worker.is_alive():
-                self.logger.warning(
-                    "Update worker did not stop within %.1fs; it is a daemon "
-                    "thread and will be abandoned on shutdown", timeout)
-
-    def _execute_update_now(self, plugin_id: str, plugin_instance: Any,
-                            scheduled_time: float,
-                            lock: Optional[threading.Lock] = None) -> None:
-        """Execute a plugin's update() via PluginExecutor, then bookkeep.
-
-        Caller is responsible for having set RUNNING state.
-
-        On the synchronous path (``lock=None``) this is the original,
-        unchanged inline behavior. On the async worker path, PluginExecutor's
-        internal thread.join(timeout) blocks only the calling thread -- on
-        timeout the lingering daemon update-thread keeps running the real
-        plugin.update() call unkillable in the background. So that the
-        plugin's lock (and its RUNNING/pending lifecycle state) stays held
-        for that real duration rather than just this bounded wait, ownership
-        of both is carried by the wrapped update callable itself, released
-        from whichever thread actually finishes it -- see _finish() below.
-        """
-        finish_guard = threading.Lock()
-        finished = {'done': False}
-
-        def _finish(success: bool, exc: Optional[Exception] = None) -> None:
-            with finish_guard:
-                if finished['done']:
-                    return
-                finished['done'] = True
-            try:
-                if success:
-                    with self._plugin_last_update_lock:
-                        self.plugin_last_update[plugin_id] = scheduled_time
-                    self.state_manager.record_update(plugin_id)
-                    self.state_manager.set_state(plugin_id, PluginState.ENABLED)
-                    if self.health_tracker:
-                        self.health_tracker.record_success(plugin_id)
-                else:
+                # Update state to RUNNING
+                self.state_manager.set_state(plugin_id, PluginState.RUNNING)
+                
+                try:
+                    # Use PluginExecutor for safe execution
+                    success = False
+                    if self.resource_monitor:
+                        # If resource monitor exists, wrap the call
+                        def monitored_update():
+                            self.resource_monitor.monitor_call(plugin_id, plugin_instance.update)
+                        # SimpleNamespace stores `update` as an *instance*
+                        # attribute, so attribute lookup returns the plain
+                        # function object as-is. A dynamically-built class
+                        # (`type(..., {'update': monitored_update})`) instead
+                        # stores it as a *class* attribute, which the
+                        # descriptor protocol turns into a bound method on
+                        # access -- silently prepending the instance as an
+                        # implicit first argument to a function that takes
+                        # none, raising "monitored_update() takes 0
+                        # positional arguments but 1 was given" on every call.
+                        success = self.plugin_executor.execute_update(
+                            types.SimpleNamespace(update=monitored_update),
+                            plugin_id
+                        )
+                    else:
+                        success = self.plugin_executor.execute_update(plugin_instance, plugin_id)
+                    
+                    if success:
+                        self.plugin_last_update[plugin_id] = current_time
+                        self.state_manager.record_update(plugin_id)
+                        # Update state back to ENABLED
+                        self.state_manager.set_state(plugin_id, PluginState.ENABLED)
+                        # Record success
+                        if self.health_tracker:
+                            self.health_tracker.record_success(plugin_id)
+                    else:
+                        self._record_update_failure(plugin_id)
+                except Exception as exc:  # pylint: disable=broad-except
+                    self.logger.exception("Error updating plugin %s: %s", plugin_id, exc)
                     self._record_update_failure(plugin_id, exc=exc)
-            finally:
-                if lock is not None:
-                    lock.release()
-                    with self._pending_lock:
-                        self._pending_updates.discard(plugin_id)
-
-        if lock is None:
-            # Synchronous / no-lock path: unchanged behavior.
-            try:
-                if self.resource_monitor:
-                    def monitored_update():
-                        self.resource_monitor.monitor_call(plugin_id, plugin_instance.update)
-                    # SimpleNamespace stores `update` as an *instance*
-                    # attribute, so attribute lookup returns the plain
-                    # function object as-is. A dynamically-built class
-                    # (`type(..., {'update': monitored_update})`) instead
-                    # stores it as a *class* attribute, which the
-                    # descriptor protocol turns into a bound method on
-                    # access -- silently prepending the instance as an
-                    # implicit first argument to a function that takes
-                    # none, raising "monitored_update() takes 0
-                    # positional arguments but 1 was given" on every call.
-                    success = self.plugin_executor.execute_update(
-                        types.SimpleNamespace(update=monitored_update),
-                        plugin_id
-                    )
-                else:
-                    success = self.plugin_executor.execute_update(plugin_instance, plugin_id)
-                _finish(success)
-            except Exception as exc:  # pylint: disable=broad-except
-                self.logger.exception("Error updating plugin %s: %s", plugin_id, exc)
-                _finish(False, exc=exc)
-            return
-
-        # Async worker path: the real update() call -- through the resource
-        # monitor, if configured -- owns finishing the lock/lifecycle
-        # bookkeeping, from whichever thread actually runs it to completion.
-        def _target_update() -> None:
-            try:
-                if self.resource_monitor:
-                    self.resource_monitor.monitor_call(plugin_id, plugin_instance.update)
-                else:
-                    plugin_instance.update()
-            except Exception as exc:
-                _finish(False, exc=exc)
-                raise
-            else:
-                _finish(True)
-
-        try:
-            self.plugin_executor.execute_update(
-                types.SimpleNamespace(update=_target_update), plugin_id)
-        except Exception as exc:  # pragma: no cover - defensive; execute_update
-            # catches everything internally, but guarantee _finish still
-            # runs (releasing the lock) if something unexpected slips through.
-            self.logger.exception("Unexpected error dispatching update for %s: %s", plugin_id, exc)
-            _finish(False, exc=exc)
-
-    def run_scheduled_updates_with_changes(self, current_time: Optional[float] = None) -> List[str]:
-        """
-        Like run_scheduled_updates(), but also returns the plugin_ids whose
-        plugin_last_update timestamp actually advanced during this call.
-
-        The before/after snapshots and the update pass itself are each
-        individually lock-protected against concurrent plugin_last_update
-        mutation (Vegas mode calls this from its own background
-        update-tick thread, racing the main render loop's plugin updates),
-        so callers get an atomic "who got fresh data" answer without
-        reaching into plugin_last_update themselves. The lock is not held
-        across the update pass so slow/blocking plugin update() calls don't
-        serialize against other plugin_last_update readers.
-        """
-        with self._plugin_last_update_lock:
-            old_times = dict(self.plugin_last_update)
-
-        self.run_scheduled_updates(current_time)
-
-        with self._plugin_last_update_lock:
-            return [
-                plugin_id for plugin_id, new_time in self.plugin_last_update.items()
-                if new_time > old_times.get(plugin_id, 0.0)
-            ]
 
     def update_all_plugins(self) -> None:
         """
@@ -1020,8 +797,7 @@ class PluginManager:
             try:
                 success = self.plugin_executor.execute_update(plugin_instance, plugin_id)
                 if success:
-                    with self._plugin_last_update_lock:
-                        self.plugin_last_update[plugin_id] = time.time()
+                    self.plugin_last_update[plugin_id] = time.time()
                     self.state_manager.record_update(plugin_id)
                     self.state_manager.set_state(plugin_id, PluginState.ENABLED)
                 else:

src/plugin_system/testing/bounds_display_manager.py

@@ -10,11 +10,8 @@ that don't scale down to a smaller panel.
 
 Limitations (documented on purpose):
 - Overflow past the LEFT or TOP edge (negative coordinates) is still clipped by
-  PIL and not detected pixel-wise here. The dominant real-world breakage is
-  content that is too wide/tall for a smaller panel, which this catches.
-  As a partial net, draw_text/draw_image calls made with negative coordinates
-  through this manager are recorded in `negative_coordinate_calls` — but draws
-  made directly on the raw PIL canvas remain uncovered.
+  PIL and not detected here. The dominant real-world breakage is content that is
+  too wide/tall for a smaller panel, which this catches.
 - BDF text is clipped to the declared bounds by the parent's bitmap drawer, so
   BDF overflow is not flagged. Golden-image regression covers those plugins.
 - If a plugin replaces the canvas with its own image (display_manager.image = ...),
@@ -59,21 +56,6 @@ class BoundsCheckingDisplayManager(VisualTestDisplayManager):
         super().__init__(self._canvas_width, self._canvas_height)
         # Plugins must see the DECLARED size, not the padded canvas size.
         self.matrix = _MatrixProxy(self._declared_width, self._declared_height)
-        # (text-or-'image', x, y) for every mediated draw call given a
-        # negative coordinate — PIL clips these silently, so record them.
-        self.negative_coordinate_calls: list = []
-
-    # -- negative-coordinate (left/top overflow) recording --
-
-    def draw_text(self, text, x=None, y=None, *args, **kwargs):
-        if (x is not None and x < 0) or (y is not None and y < 0):
-            self.negative_coordinate_calls.append((text, x, y))
-        return super().draw_text(text, x, y, *args, **kwargs)
-
-    def draw_image(self, image, x, y, *args, **kwargs):
-        if x < 0 or y < 0:
-            self.negative_coordinate_calls.append(('image', x, y))
-        return super().draw_image(image, x, y, *args, **kwargs)
 
     # -- declared dimensions (override parent's image-derived properties) --
 

src/plugin_system/testing/harness.py

@@ -73,10 +73,6 @@ class RenderResult:
     golden_ok: Optional[bool] = None
     golden_diff_pixels: int = 0
     golden_max_delta: int = 0
-    # fill / scale-up check (populated only for sizes >= 2x the design size)
-    fill_checked: bool = False
-    fill_ok: Optional[bool] = None       # False only in strict mode
-    fill_extent: Optional[Tuple[float, float]] = None  # (extent_x, extent_y)
 
     @property
     def size_label(self) -> str:
@@ -90,8 +86,6 @@ class RenderResult:
             return False
         if self.golden_checked and self.golden_ok is False:
             return False
-        if self.fill_ok is False:
-            return False
         return True
 
 
@@ -307,74 +301,6 @@ def compare_to_goldens(results: List[RenderResult], golden_dir: Path,
     return results
 
 
-# ---------------------------------------------------------------------------
-# Fill / scale-up check
-# ---------------------------------------------------------------------------
-#
-# Overflow catches content that is too BIG for a panel; nothing catches
-# content that stays tiny on a panel much larger than the plugin's design
-# size (e.g. 128x32 content in the corner of a 256x128 renders "green").
-# These helpers measure how much of the panel the lit content spans so the
-# harness can flag plugins that don't scale up.
-
-# A pixel counts as "lit" above this luminance — low enough to catch dim
-# content, high enough to ignore near-black noise.
-_LIT_THRESHOLD = 16
-# Content must span at least this fraction of an axis that is >= 2x the
-# design size. Lenient on purpose: margins are fine, a tiny corner is not.
-_MIN_FILL_EXTENT = 0.5
-
-
-def fill_metrics(image: Image.Image) -> Tuple[float, float, float]:
-    """Measure lit-content coverage: (extent_x, extent_y, ink_ratio).
-
-    extent_* are the lit bounding box's spans as fractions of the panel;
-    ink_ratio is the fraction of pixels lit (reporting only — sparse pixel
-    fonts legitimately have low ink ratios)."""
-    lit = image.convert("L").point(lambda p: 255 if p > _LIT_THRESHOLD else 0)
-    bbox = lit.getbbox()
-    if bbox is None:
-        return (0.0, 0.0, 0.0)
-    extent_x = (bbox[2] - bbox[0]) / image.width
-    extent_y = (bbox[3] - bbox[1]) / image.height
-    ink = sum(1 for p in lit.getdata() if p) / (image.width * image.height)
-    return (extent_x, extent_y, ink)
-
-
-def check_scale_up(results: List[RenderResult],
-                   design_size: Tuple[int, int] = (128, 32),
-                   min_extent: float = _MIN_FILL_EXTENT,
-                   strict: bool = False) -> List[RenderResult]:
-    """Flag renders that leave a big panel mostly empty.
-
-    For each result whose panel is at least 2x the design size on an axis,
-    require the lit content to span >= min_extent of that axis. Mutates the
-    results' fill_* fields. In the default warn-only mode fill_ok is left
-    None (reported, never failing); strict=True sets fill_ok=False, which
-    fails RenderResult.ok — opt in per plugin via harness.json
-    {"fill_check": "strict"} once its adaptive layout is in place.
-    """
-    design_w, design_h = design_size
-    for r in results:
-        if r.image is None or r.error is not None:
-            continue
-        check_x = r.width >= 2 * design_w
-        check_y = r.height >= 2 * design_h
-        if not (check_x or check_y):
-            continue
-        extent_x, extent_y, _ink = fill_metrics(r.image)
-        r.fill_checked = True
-        r.fill_extent = (round(extent_x, 3), round(extent_y, 3))
-        underfilled = ((check_x and extent_x < min_extent)
-                       or (check_y and extent_y < min_extent))
-        if underfilled and strict:
-            r.fill_ok = False
-        elif not underfilled:
-            r.fill_ok = True
-        # warn-only underfill: fill_ok stays None; fill_extent tells the story
-    return results
-
-
 def write_goldens(results: List[RenderResult], golden_dir: Path) -> int:
     """Write each successfully-rendered result to its golden path. Returns count."""
     written = 0

src/plugin_system/testing/loading.py

@@ -56,15 +56,7 @@ def load_harness_spec(plugin_dir: Union[str, Path]) -> Dict[str, Any]:
           "config":     {...},            # config overrides
           "mock_data":  "fixtures/mock.json",  # path (relative to plugin dir) to cache fixtures
           "freeze_time": "2025-08-01 15:25:00",
-          "skip_update": false,
-          "fill_check": "warn",           # or "strict": underfilled big panels FAIL
-          "variants": [                   # extra runs with config overlays and
-            {                             # their own golden dirs — e.g. an
-              "name": "adaptive",         # opt-in adaptive mode tested beside
-              "config": {"layout_mode": "adaptive"},   # the classic default
-              "golden_dir": "test/golden-adaptive"
-            }
-          ]
+          "skip_update": false
         }
     Returns {} when no harness.json exists.
     """
@@ -88,27 +80,3 @@ def load_harness_spec(plugin_dir: Union[str, Path]) -> Dict[str, Any]:
         with open(mock_path, 'r') as mf:
             spec['mock_data_contents'] = json.load(mf)
     return spec
-
-
-def build_full_config(
-    plugin_dir: Union[str, Path],
-    spec: Optional[Dict[str, Any]] = None,
-    cli_config: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
-    """Build the config a plugin sees under test.
-
-    Merge order: config_schema.json defaults, then a forced ``enabled: True``,
-    then harness.json's config overlay, then the caller's explicit config --
-    most specific wins. `enabled` is re-asserted *after* the schema defaults
-    so a plugin that reasonably ships `enabled: false` (e.g. a seasonal or
-    opt-in plugin) can't silently make every harness run test "disabled, do
-    nothing" by accident -- callers that genuinely want to test the disabled
-    path can still do so via `cli_config={"enabled": False}`.
-    """
-    spec = spec or {}
-    config: Dict[str, Any] = {}
-    config.update(load_config_defaults(plugin_dir))
-    config["enabled"] = True
-    config.update(spec.get("config", {}))
-    config.update(cli_config or {})
-    return config

src/plugin_system/testing/mocks.py

@@ -71,7 +71,6 @@ class MockCacheManager:
         self.get_calls = []
         self.set_calls = []
         self.delete_calls = []
-        self.get_cached_data_with_strategy_calls = []
         # Real temp dir for plugins that write/read files under cache_dir.
         # Registered for cleanup so each mock instance doesn't leak a tmp dir.
         self.cache_dir = tempfile.mkdtemp(prefix="ledmatrix-mock-cache-")
@@ -109,24 +108,6 @@ class MockCacheManager:
         self.delete_calls.append(key)
         if key in self._cache:
             del self._cache[key]
-
-    def get_cached_data_with_strategy(self, key: str, data_type: str = 'default') -> Optional[Any]:
-        """Mock of CacheManager.get_cached_data_with_strategy (src/cache_manager.py).
-
-        The real method picks a max_age/memory_ttl strategy per data_type
-        (and extends it during market-closed hours for market data) before
-        delegating to get_cached_data(). None of that timing nuance matters
-        for a mock -- plugins under test just need the method to exist and
-        return whatever was cached, so this delegates straight to get().
-        """
-        self.get_cached_data_with_strategy_calls.append({'key': key, 'data_type': data_type})
-        return self.get(key)
-
-    def save_cache(self, key: str, data: Any) -> None:
-        """Mock of CacheManager.save_cache (src/cache_manager.py) -- the
-        write-side counterpart to get_cached_data_with_strategy, used by the
-        same real-CacheManager-oriented plugins. Delegates to set()."""
-        self.set(key, data)
         if key in self._cache_timestamps:
             del self._cache_timestamps[key]
     
@@ -137,7 +118,6 @@ class MockCacheManager:
         self.get_calls = []
         self.set_calls = []
         self.delete_calls = []
-        self.get_cached_data_with_strategy_calls = []
 
 
 class MockConfigManager:
@@ -181,13 +161,6 @@ class MockPluginManager:
         self.plugin_manifests: Dict[str, Dict] = {}
         self.get_plugin_calls = []
         self.get_all_plugins_calls = []
-        # Real FontManager so BasePlugin.layout / draw_fit behave identically
-        # under the harness (it only needs assets/fonts on disk).
-        try:
-            from src.font_manager import FontManager
-            self.font_manager: Optional[Any] = FontManager({})
-        except Exception:
-            self.font_manager = None
     
     def get_plugin(self, plugin_id: str) -> Optional[Any]:
         """Get a plugin instance."""

src/plugin_system/testing/sizes.py

@@ -28,7 +28,6 @@ DEFAULT_TEST_SIZES: List[Tuple[int, int]] = [
     (64, 32),    # 1x1 — single panel, the tightest common rectangle
     (128, 32),   # 2x1 — the baseline most plugins are tuned for
     (64, 64),    # 1x2 — stacked, exercises tall-narrow centering
-    (96, 48),    # non-64x32-module panel (e.g. Waveshare), off-grid dims
     (128, 64),   # 2x2 — block, icon scaling / vertical centering
     (256, 32),   # 4x1 — long strip, wide horizontal layout
     (128, 96),   # 2x3 — tall, exercises vertical overflow

src/vegas_mode/render_pipeline.py

@@ -66,10 +66,6 @@ class RenderPipeline:
             else display_manager.height
         )
 
-        # Reusable blank frame for cycle-end pushes (allocated lazily,
-        # re-blacked before each reuse)
-        self._blank_frame = None
-
         # ScrollHelper for optimized scrolling
         self.scroll_helper = ScrollHelper(
             self.display_width,
@@ -238,19 +234,11 @@ class RenderPipeline:
                     )
                     # Push blank immediately so the hardware never shows any
                     # post-wrap content while the coordinator recomposes the
-                    # next cycle (~100 ms). The blank is allocated once and
-                    # reused across cycle wraps (fresh paste each time in case
-                    # a consumer drew on the previous one).
+                    # next cycle (~100 ms).
                     try:
-                        if self._blank_frame is None or self._blank_frame.size != (
-                                self.display_width, self.display_height):
-                            self._blank_frame = Image.new(
-                                'RGB', (self.display_width, self.display_height))
-                        else:
-                            self._blank_frame.paste(
-                                (0, 0, 0),
-                                (0, 0, self.display_width, self.display_height))
-                        self.display_manager.image = self._blank_frame
+                        from PIL import Image as _Image
+                        blank = _Image.new('RGB', (self.display_width, self.display_height))
+                        self.display_manager.image = blank
                         self.display_manager.update_display()
                     except Exception:
                         logger.exception("Failed to write blank frame to display at cycle end")
@@ -309,8 +297,6 @@ class RenderPipeline:
         Returns True when:
         - Cycle is complete and we should start fresh
         - Staging buffer has new content
-        - A plugin currently visible in the scroll has pending updated data
-          (e.g. a live score changed) — standalone (non-sync) mode only
         """
         if self._cycle_complete:
             return True
@@ -328,12 +314,6 @@ class RenderPipeline:
         if buffer_status['staging_count'] > 0:
             return True
 
-        # Trigger recompose when pending updates affect visible segments, so
-        # live score/status changes reach the display within a few seconds
-        # instead of waiting for the next full cycle.
-        if self.stream_manager.has_pending_updates_for_visible_segments():
-            return True
-
         return False
 
     def hot_swap_content(self) -> bool:

src/wifi_manager.py

@@ -2564,35 +2564,11 @@ address=/detectportal.firefox.com/192.168.4.1
         Returns:
             True if AP mode state changed, False otherwise
         """
-        changed, _status, _ethernet, _ap = self.check_and_manage_ap_mode_with_state()
-        return changed
-
-    def check_and_manage_ap_mode_with_state(self) -> Tuple[bool, WiFiStatus, bool, bool]:
-        """Like check_and_manage_ap_mode, but also returns the state it
-        observed, so callers (the wifi monitor daemon) don't have to re-run
-        the same nmcli subprocess battery before AND after the check —
-        each status fetch is several process forks.
-
-        Returns:
-            (state_changed, WiFiStatus, ethernet_connected, ap_active_after)
-        """
         try:
             # Get status with retry for more reliable detection
             status = self._get_wifi_status_with_retry()
             ethernet_connected = self._is_ethernet_connected()
             ap_active = self._is_ap_mode_active()
-            changed = self._manage_ap_mode(status, ethernet_connected, ap_active)
-            # State only ever changes via one enable or one disable, so the
-            # post-state is the inverse of the pre-state when changed.
-            ap_after = (not ap_active) if changed else ap_active
-            return changed, status, ethernet_connected, ap_after
-        except Exception as e:
-            logger.error(f"Error checking AP mode: {e}", exc_info=True)
-            return False, WiFiStatus(connected=False), False, False
-
-    def _manage_ap_mode(self, status: WiFiStatus, ethernet_connected: bool, ap_active: bool) -> bool:
-        """AP-mode decision logic against an already-fetched state snapshot."""
-        try:
             auto_enable = self.config.get("auto_enable_ap_mode", True)  # Default: True (safe due to grace period)
             
             # Log current state for debugging

test/conftest.py

@@ -38,11 +38,7 @@ def mock_cache_manager():
     mock._memory_cache_timestamps = {}
     mock.cache_dir = "/tmp/test_cache"
     
-    def mock_get(key: str, max_age: Optional[int] = 300,
-                 memory_ttl: Optional[int] = None) -> Optional[Dict]:
-        # Signature mirrors CacheManager.get — keep in sync or callers
-        # passing keyword args (health tracker, resource monitor) break
-        # only in tests, hiding real-API compatibility.
+    def mock_get(key: str, max_age: int = 300) -> Optional[Dict]:
         return mock._memory_cache.get(key)
     
     def mock_set(key: str, data: Dict, ttl: Optional[int] = None) -> None:

test/plugins/test_harness.py

@@ -253,61 +253,3 @@ class TestCheckPluginHonorsHarnessJson:
         )
         assert captured["freeze_time"] == "2030-01-01 00:00:00"
         assert captured["config"]["timezone"] == "America/New_York"
-
-
-class TestBuildFullConfigForcesEnabled:
-    """Regression: a plugin's own config_schema.json may reasonably default
-    enabled to False (e.g. a seasonal or opt-in plugin) -- march-madness and
-    14 other real plugins do. The harness must still test it as enabled
-    unless a caller explicitly asks otherwise, or every render silently
-    becomes a same-shaped "disabled, do nothing" no-op."""
-
-    def _make_plugin_with_disabled_default(self, tmp_path):
-        pdir = tmp_path / "plugins" / "demo-seasonal"
-        pdir.mkdir(parents=True)
-        (pdir / "manifest.json").write_text(json.dumps({
-            "id": "demo-seasonal", "name": "Demo Seasonal", "version": "1.0.0",
-            "author": "test", "entry_point": "manager.py",
-            "class_name": "DemoSeasonal", "display_modes": ["demo-seasonal"],
-            "compatible_versions": ["*"],
-        }))
-        (pdir / "config_schema.json").write_text(json.dumps({
-            "type": "object",
-            "properties": {"enabled": {"type": "boolean", "default": False}},
-        }))
-        return pdir
-
-    def test_schema_disabled_default_does_not_win(self, tmp_path):
-        from src.plugin_system.testing.loading import build_full_config
-        plugin_dir = self._make_plugin_with_disabled_default(tmp_path)
-        config = build_full_config(plugin_dir)
-        assert config["enabled"] is True
-
-    def test_harness_json_config_can_still_disable(self, tmp_path):
-        from src.plugin_system.testing.loading import build_full_config
-        plugin_dir = self._make_plugin_with_disabled_default(tmp_path)
-        config = build_full_config(plugin_dir, spec={"config": {"enabled": False}})
-        assert config["enabled"] is False
-
-    def test_explicit_cli_config_can_still_disable(self, tmp_path):
-        from src.plugin_system.testing.loading import build_full_config
-        plugin_dir = self._make_plugin_with_disabled_default(tmp_path)
-        config = build_full_config(plugin_dir, cli_config={"enabled": False})
-        assert config["enabled"] is False
-
-    def test_check_one_renders_a_schema_disabled_plugin_as_enabled(self, tmp_path, monkeypatch):
-        """End-to-end: check_plugin.py's check_one() must not blank-render a
-        plugin just because its own schema defaults enabled to False."""
-        mod = _load_check_plugin_cli()
-        plugin_dir = self._make_plugin_with_disabled_default(tmp_path)
-        captured = {}
-        monkeypatch.setattr(mod, "render_plugin_matrix",
-                            lambda **kw: captured.update(kw) or [])
-        monkeypatch.setattr(mod, "compare_to_goldens", lambda *a, **k: [])
-        mod.check_one(
-            plugin_id="demo-seasonal", search_dirs=[str(tmp_path / "plugins")],
-            sizes=None, mock_data={}, config={}, run_update=True,
-            out_dir=None, update_golden=False, golden_dir_override=None,
-            freeze_time=None,
-        )
-        assert captured["config"]["enabled"] is True

test/plugins/test_plugin_matrix.py

@@ -22,7 +22,7 @@ import pytest
 from src.plugin_system.testing.harness import (
     render_plugin_matrix, compare_to_goldens,
 )
-from src.plugin_system.testing.loading import build_full_config, load_harness_spec
+from src.plugin_system.testing.loading import load_config_defaults, load_harness_spec
 from src.plugin_system.testing.sizes import resolve_test_sizes
 
 PROJECT_ROOT = Path(__file__).resolve().parents[2]
@@ -81,7 +81,9 @@ def test_plugin_renders_across_sizes_and_screens(plugin_id: str) -> None:
     plugin_dir = _PLUGINS[plugin_id]
     spec = load_harness_spec(plugin_dir)
 
-    config = build_full_config(plugin_dir, spec)
+    config = {"enabled": True}
+    config.update(load_config_defaults(plugin_dir))
+    config.update(spec.get("config", {}))
 
     # Sizes: LEDMATRIX_TEST_SIZES env (test on real hardware) wins, then the
     # plugin's own harness.json "sizes", else the default representative sample.

test/test_adaptive_images.py

@@ -1,208 +0,0 @@
-"""Tests for adaptive image fitting (src/adaptive_images.py) and the
-LayoutContext image cache."""
-
-import pytest
-from PIL import Image
-
-from src.adaptive_images import (
-    RESAMPLE_LANCZOS,
-    RESAMPLE_NEAREST,
-    ImageFitResult,
-    draw_fitted_image,
-    fit_image,
-)
-from src.adaptive_layout import LayoutContext, Region
-from src.font_manager import FontManager
-
-
-@pytest.fixture(scope="module")
-def font_manager():
-    return FontManager({})
-
-
-@pytest.fixture
-def ctx(font_manager):
-    return LayoutContext(128, 32, font_manager)
-
-
-def _solid(w, h, color=(255, 0, 0, 255)):
-    return Image.new("RGBA", (w, h), color)
-
-
-def _padded_logo(ink_w=10, ink_h=10, pad=10):
-    """Transparent canvas with a solid ink block in the middle — models a
-    logo shipped with generous transparent padding."""
-    img = Image.new("RGBA", (ink_w + 2 * pad, ink_h + 2 * pad), (0, 0, 0, 0))
-    img.paste(_solid(ink_w, ink_h), (pad, pad))
-    return img
-
-
-class TestFitModes:
-    def test_contain_letterboxes_and_upscales(self):
-        fit = fit_image(_solid(10, 5), (40, 40))
-        assert (fit.width, fit.height) == (40, 20)  # aspect preserved
-        assert fit.scale == 4.0
-
-    def test_contain_no_upscale(self):
-        fit = fit_image(_solid(10, 5), (40, 40), upscale=False)
-        assert (fit.width, fit.height) == (10, 5)
-        assert fit.scale == 1.0
-
-    def test_cover_fills_and_crops(self):
-        fit = fit_image(_solid(10, 20), (40, 40), mode="cover")
-        assert (fit.width, fit.height) == (40, 40)
-
-    def test_cover_top_anchor(self):
-        # top half red, bottom half blue; cover-crop a wide box with top anchor
-        img = Image.new("RGBA", (20, 40), (0, 0, 255, 255))
-        img.paste(_solid(20, 20, (255, 0, 0, 255)), (0, 0))
-        fit = fit_image(img, (20, 20), mode="cover", anchor="top")
-        assert fit.image.getpixel((10, 5))[:3] == (255, 0, 0)  # kept the top
-
-    def test_fill_height_matches_box_height(self):
-        fit = fit_image(_solid(10, 10), (64, 32), mode="fill_height")
-        assert fit.height == 32 and fit.width == 32
-
-    def test_fill_height_capped_by_width(self):
-        # very wide source: height-fill would overflow the box width
-        fit = fit_image(_solid(100, 10), (40, 32), mode="fill_height")
-        assert fit.width <= 40
-
-    def test_stretch_exact(self):
-        fit = fit_image(_solid(3, 7), (25, 13), mode="stretch")
-        assert (fit.width, fit.height) == (25, 13)
-
-    def test_crop_to_ink(self):
-        fit = fit_image(_padded_logo(), (30, 30), crop_to_ink=True)
-        # 10x10 ink upscaled to fill 30x30 (padding would have kept it small)
-        assert (fit.width, fit.height) == (30, 30)
-        no_crop = fit_image(_padded_logo(), (30, 30), crop_to_ink=False)
-        assert no_crop.width == 30  # whole padded canvas scaled instead
-
-    def test_fully_transparent_source(self):
-        img = Image.new("RGBA", (10, 10), (0, 0, 0, 0))
-        fit = fit_image(img, (20, 20), crop_to_ink=True)
-        assert fit.is_empty
-
-    def test_degenerate_box(self):
-        assert fit_image(_solid(10, 10), (0, 20)).is_empty
-        assert fit_image(_solid(10, 10), Region(0, 0, 20, 0)).is_empty
-
-    def test_output_always_rgba(self):
-        rgb = Image.new("RGB", (10, 10), (1, 2, 3))
-        assert fit_image(rgb, (20, 20)).image.mode == "RGBA"
-
-    def test_nearest_keeps_hard_edges(self):
-        # 2x2 checker scaled 8x: NEAREST keeps pure colors, LANCZOS blends
-        img = Image.new("RGBA", (2, 2), (0, 0, 0, 255))
-        img.putpixel((0, 0), (255, 255, 255, 255))
-        near = fit_image(img, (16, 16), mode="stretch", resample=RESAMPLE_NEAREST)
-        colors = {near.image.getpixel((x, y))[:3] for x in range(16) for y in range(16)}
-        assert colors == {(255, 255, 255), (0, 0, 0)}
-
-    def test_unknown_mode_raises(self):
-        with pytest.raises(ValueError):
-            fit_image(_solid(4, 4), (8, 8), mode="tile")
-
-
-class TestDrawFittedImage:
-    class _DM:
-        def __init__(self, w=64, h=32):
-            self.image = Image.new("RGB", (w, h), (0, 0, 0))
-
-    def test_pastes_aligned_in_region(self):
-        dm = self._DM()
-        box = Region(10, 4, 20, 20)
-        fit = fit_image(_solid(10, 10), box)
-        xy = draw_fitted_image(dm, fit, box)
-        assert xy == box.align_xy(fit.width, fit.height)
-        assert dm.image.getpixel((xy[0] + 1, xy[1] + 1)) == (255, 0, 0)
-
-    def test_offset_translates(self):
-        dm = self._DM()
-        box = Region(0, 0, 20, 20)
-        fit = fit_image(_solid(10, 10), box)
-        x, y = draw_fitted_image(dm, fit, box, align="left", valign="top",
-                                 offset=(3, 5))
-        assert (x, y) == (3, 5)
-
-    def test_empty_fit_noops(self):
-        dm = self._DM()
-        fit = fit_image(_solid(10, 10), (0, 0))
-        assert draw_fitted_image(dm, fit, Region(0, 0, 10, 10)) is None
-
-
-class TestContextImageCache:
-    def test_size_keyed_hit_and_miss(self, ctx):
-        img = _solid(10, 10)
-        a = ctx.fit_image(img, (20, 20), cache_key="logo:A")
-        assert ctx.fit_image(img, (20, 20), cache_key="logo:A") is a
-        b = ctx.fit_image(img, (30, 30), cache_key="logo:A")
-        assert b is not a and b.width == 30  # different box size = new entry
-
-    def test_id_keyed_default(self, ctx):
-        img = _solid(10, 10)
-        a = ctx.fit_image(img, (20, 20))
-        assert ctx.fit_image(img, (20, 20)) is a
-
-    def test_id_safety_pins_source(self, ctx):
-        # id()-keyed entries must pin the source image so a recycled id
-        # can't alias a dead image's cache entry.
-        img = _solid(10, 10)
-        ctx.fit_image(img, (20, 20))
-        pinned = [entry[1] for entry in ctx._image_cache.values()]
-        assert img in pinned
-
-    def test_cache_key_entries_do_not_pin(self, ctx):
-        img = _solid(10, 10)
-        ctx.fit_image(img, (20, 20), cache_key="logo:X")
-        key = next(k for k in ctx._image_cache if k[1] == "logo:X")
-        assert ctx._image_cache[key][1] is None
-
-    def test_lru_eviction(self, ctx):
-        for i in range(ctx._IMAGE_CACHE_MAX + 5):
-            ctx.fit_image(_solid(4, 4), (8, 8), cache_key=f"k{i}")
-        assert len(ctx._image_cache) == ctx._IMAGE_CACHE_MAX
-        assert not any(k[1] == "k0" for k in ctx._image_cache)  # oldest evicted
-
-    def test_clear_cache_clears_images(self, ctx):
-        ctx.fit_image(_solid(4, 4), (8, 8), cache_key="k")
-        ctx.clear_cache()
-        assert len(ctx._image_cache) == 0
-
-
-class TestBasePluginDrawImage:
-    def test_draw_image_end_to_end(self):
-        from src.plugin_system.base_plugin import BasePlugin
-        from src.plugin_system.testing.mocks import (
-            MockCacheManager, MockDisplayManager, MockPluginManager,
-        )
-
-        class _P(BasePlugin):
-            def update(self):
-                pass
-
-            def display(self, force_clear=False):
-                pass
-
-        plugin = _P("t", {}, MockDisplayManager(64, 32),
-                    MockCacheManager(), MockPluginManager())
-        logo = _padded_logo()
-        box = plugin.layout.bounds.left_col(32)
-        ifit = plugin.draw_image(logo, box, mode="fill_height",
-                                 crop_to_ink=True, cache_key="logo:T")
-        assert ifit.height == 32
-        # pasted onto the mock's canvas
-        assert plugin.display_manager.image.getpixel((16, 16)) != (0, 0, 0)
-
-
-class TestResultIndependence:
-    def test_same_size_fit_never_aliases_the_source(self):
-        """LayoutContext caches ImageFitResults — an aliased image would let
-        later mutations of the source corrupt cached fits (or vice versa)."""
-        from PIL import ImageDraw
-        src = Image.new("RGBA", (20, 20), (255, 0, 0, 255))
-        fit = fit_image(src, (20, 20))
-        assert fit.image is not src
-        ImageDraw.Draw(src).rectangle([0, 0, 19, 19], fill=(0, 255, 0, 255))
-        assert fit.image.getpixel((5, 5)) == (255, 0, 0, 255)

test/test_adaptive_layout.py

@@ -1,454 +0,0 @@
-"""Tests for the adaptive layout system (src/adaptive_layout.py)."""
-
-import pytest
-
-from src.adaptive_layout import (
-    DEFAULT_DESIGN_SIZE,
-    LADDER_ARCADE,
-    LADDER_GRID,
-    LayoutContext,
-    Region,
-    draw_fitted_text,
-    measure_font_crispness,
-    measure_ink,
-    media_row,
-    scoreboard_regions,
-)
-from src.plugin_system.testing.sizes import DEFAULT_TEST_SIZES
-from src.font_manager import FontManager
-
-
-@pytest.fixture(scope="module")
-def font_manager():
-    """Real FontManager over assets/fonts — the ladders depend on it."""
-    return FontManager({})
-
-
-@pytest.fixture
-def ctx(font_manager):
-    return LayoutContext(128, 32, font_manager)
-
-
-class TestRegion:
-    """Pure integer rect algebra."""
-
-    def test_bands_partition_without_overlap(self):
-        r = Region(0, 0, 128, 32)
-        top = r.top_band(7)
-        bottom = r.bottom_band(7)
-        middle = r.middle(7, 7)
-        assert top.bottom == middle.y
-        assert middle.bottom == bottom.y
-        assert top.h + middle.h + bottom.h == r.h
-
-    def test_bands_clamp_on_short_panel(self):
-        # The classic failure: y=1 top band and y=height-7 bottom band
-        # overlapping on a short panel. Bands can't exceed the region.
-        r = Region(0, 0, 32, 8)
-        assert r.top_band(16).h == 8
-        assert r.bottom_band(16).h == 8
-        assert r.middle(8, 8).h == 0  # degenerate, never negative
-
-    def test_split_v_weights_sum_to_height(self):
-        r = Region(0, 0, 64, 33)
-        rows = r.split_v(3, 1, 1, gap=1)
-        assert len(rows) == 3
-        assert sum(row.h for row in rows) == 33 - 2  # two 1px gaps
-        assert rows[0].h > rows[1].h
-        assert rows[-1].bottom == r.bottom
-
-    def test_split_h_columns_advance(self):
-        r = Region(0, 0, 100, 32)
-        cols = r.split_h(1, 1, gap=2)
-        assert cols[0].right + 2 == cols[1].x
-        assert cols[1].right == r.right
-
-    def test_degenerate_sizes_never_negative(self):
-        for w, h in [(8, 8), (32, 16), (1, 1)]:
-            r = Region(0, 0, w, h).inset(4)
-            assert r.w >= 0 and r.h >= 0
-            for sub in r.split_v(1, 1) + r.split_h(1, 1, gap=3):
-                assert sub.w >= 0 and sub.h >= 0
-
-    def test_align_xy(self):
-        r = Region(10, 10, 100, 20)
-        assert r.align_xy(20, 10, "left", "top") == (10, 10)
-        assert r.align_xy(20, 10, "right", "bottom") == (90, 20)
-        assert r.align_xy(20, 10) == (50, 15)
-
-    def test_left_right_cols(self):
-        r = Region(0, 0, 128, 32)
-        assert r.left_col(32) == Region(0, 0, 32, 32)
-        assert r.right_col(32) == Region(96, 0, 32, 32)
-
-    def test_offset_translates_without_resizing(self):
-        r = Region(5, 5, 20, 10).offset(3, -2)
-        assert r == Region(8, 3, 20, 10)
-
-
-class TestScoreboardRegions:
-    @pytest.mark.parametrize("w,h", DEFAULT_TEST_SIZES + [(8, 8)])
-    def test_invariants_at_all_sizes(self, w, h):
-        regs = scoreboard_regions(Region(0, 0, w, h))
-        assert regs.logo_slot <= min(h, w // 2)
-        # slots hug the edges and never overlap the center column
-        assert regs.away_slot.x == 0 and regs.home_slot.right == w
-        assert regs.away_slot.right <= regs.center_col.x or regs.center_col.w == 0
-        assert regs.center_col.right <= regs.home_slot.x or regs.center_col.w == 0
-        # bands stack inside the center column without overlap
-        assert regs.status_band.bottom <= regs.score_area.y or regs.score_area.h == 0
-        assert regs.score_area.bottom <= regs.detail_band.y or regs.score_area.h == 0
-        # everything within bounds, nothing negative
-        for reg in (regs.away_slot, regs.home_slot, regs.center_col,
-                    regs.status_band, regs.score_area, regs.detail_band,
-                    regs.bottom_left, regs.bottom_right):
-            assert reg.w >= 0 and reg.h >= 0
-            assert reg.x >= 0 and reg.y >= 0
-            assert reg.right <= w and reg.bottom <= h
-
-    @pytest.mark.parametrize("w,h", [(96, 48), (128, 64), (256, 128), (64, 32), (128, 96)])
-    def test_2to1_aspect_gets_a_center_reserve(self, w, h):
-        """These sizes are all <= 2:1 aspect, where the raw min(h, w//2)
-        formula claims the entire width for logos and leaves zero pixels
-        for a center column — the bug this reserve exists to fix."""
-        regs = scoreboard_regions(Region(0, 0, w, h))
-        assert regs.center_col.w >= int(w * 0.15) - 1  # -1 for int() rounding
-
-    @pytest.mark.parametrize("w,h", [(128, 32), (192, 48), (256, 32)])
-    def test_wide_panels_unaffected_by_center_reserve(self, w, h):
-        """Wide (>= ~4:1) panels already have height as the tighter
-        constraint, so the center reserve must be a no-op there — the
-        design-size baseline's proportions shouldn't shift."""
-        regs = scoreboard_regions(Region(0, 0, w, h))
-        assert regs.logo_slot == min(h, w // 2)
-
-    def test_center_reserve_fraction_is_configurable(self):
-        # min_center_design_px=0 isolates the fraction term (otherwise the
-        # scaled absolute floor can dominate and mask a fraction change).
-        regs_default = scoreboard_regions(Region(0, 0, 128, 64), min_center_design_px=0)
-        regs_wider = scoreboard_regions(Region(0, 0, 128, 64), min_center_fraction=0.5,
-                                        min_center_design_px=0)
-        assert regs_wider.center_col.w > regs_default.center_col.w
-        assert regs_wider.logo_slot < regs_default.logo_slot
-
-    def test_score_bleed_extends_past_center_col(self):
-        regs = scoreboard_regions(Region(0, 0, 128, 64), score_bleed_fraction=0.5)
-        assert regs.score_area.w > regs.center_col.w
-        assert regs.score_area.x < regs.center_col.x
-        assert regs.score_area.right > regs.center_col.right
-
-    def test_score_bleed_zero_matches_center_col(self):
-        regs = scoreboard_regions(Region(0, 0, 128, 64), score_bleed_fraction=0.0)
-        assert regs.score_area.w == regs.center_col.w
-        assert regs.score_area.x == regs.center_col.x
-
-    @pytest.mark.parametrize("w,h", [(64, 32), (96, 48), (128, 64), (256, 128), (128, 96)])
-    def test_score_never_needs_ellipsis_for_a_short_score(self, w, h, font_manager):
-        """The concrete regression this whole reserve/bleed system exists to
-        prevent: a real game score like '17-21' must always render in full,
-        never truncated, at every 2:1-or-tighter aspect ratio in the sample."""
-        ctx = LayoutContext(w, h, font_manager)
-        regs = scoreboard_regions(Region(0, 0, w, h), ctx=ctx)
-        height_scale = h / 32.0
-        fit = ctx.fit_text_proportional("17-21", regs.score_area, base_size_px=10,
-                                        ladder=LADDER_ARCADE, scale=height_scale)
-        assert fit.text == "17-21"
-        assert fit.fits
-
-    def test_ctx_scales_band_heights(self, font_manager):
-        small = scoreboard_regions(Region(0, 0, 128, 32),
-                                   ctx=LayoutContext(128, 32, font_manager))
-        big = scoreboard_regions(Region(0, 0, 256, 64),
-                                 ctx=LayoutContext(256, 64, font_manager))
-        assert big.status_band.h > small.status_band.h
-
-    def test_works_on_offset_card_region(self):
-        card = Region(10, 4, 100, 24)
-        regs = scoreboard_regions(card)
-        assert regs.away_slot.x == 10
-        assert regs.home_slot.right == card.right
-
-
-class TestMediaRow:
-    def test_square_art_plus_body(self):
-        row = media_row(Region(0, 0, 128, 32))
-        assert row.art == Region(0, 0, 32, 32)
-        assert row.body.x == 32 + 2 and row.body.right == 128
-
-    def test_non_square(self):
-        row = media_row(Region(0, 0, 100, 20), square=False, gap=4)
-        assert row.art.w == 50
-        assert row.body.x == 54
-
-    def test_narrow_panel_clamps(self):
-        row = media_row(Region(0, 0, 16, 32))
-        assert row.art.w == 16 and row.body.w == 0
-
-
-class TestLayoutContext:
-    def test_tiers(self, font_manager):
-        assert LayoutContext(128, 32, font_manager).tier == "sm"
-        assert LayoutContext(96, 48, font_manager).tier == "md"
-        assert LayoutContext(128, 64, font_manager).tier == "lg"
-        assert LayoutContext(64, 16, font_manager).tier == "xs"
-        assert LayoutContext(256, 128, font_manager).tier == "xl"
-
-    def test_wide_short_flag(self, font_manager):
-        assert LayoutContext(128, 32, font_manager).is_wide_short
-        assert not LayoutContext(128, 64, font_manager).is_wide_short
-
-    def test_scale_against_design_size(self, font_manager):
-        assert LayoutContext(128, 32, font_manager).scale == 1.0
-        assert LayoutContext(256, 64, font_manager).scale == 2.0
-        # min() of the two axes: don't overscale the constrained one
-        assert LayoutContext(256, 32, font_manager).scale == 1.0
-        assert DEFAULT_DESIGN_SIZE == (128, 32)
-
-    def test_px_scales_and_clamps(self, font_manager):
-        big = LayoutContext(256, 64, font_manager)
-        assert big.px(4) == 8
-        assert big.px(4, maximum=6) == 6
-        tiny = LayoutContext(32, 16, font_manager)
-        assert tiny.px(4, minimum=2) == 2
-
-    def test_by_tier_nearest_at_or_below(self, font_manager):
-        mapping = {"sm": 10, "lg": 18}
-        assert LayoutContext(128, 32, font_manager).by_tier(mapping) == 10
-        assert LayoutContext(96, 48, font_manager).by_tier(mapping) == 10  # md -> sm
-        assert LayoutContext(128, 64, font_manager).by_tier(mapping) == 18
-        assert LayoutContext(256, 128, font_manager).by_tier(mapping) == 18  # xl -> lg
-        # nothing at-or-below: fall forward to smallest defined above
-        assert LayoutContext(64, 16, font_manager).by_tier(mapping) == 10
-
-
-class TestFontFitting:
-    def test_ladder_monotonic(self, font_manager):
-        """Each ladder rung must render no taller than the one before it."""
-        for ladder in (LADDER_GRID, LADDER_ARCADE):
-            heights = []
-            for step in ladder:
-                font = font_manager.get_font(step.family, step.size_px)
-                heights.append(measure_ink("Ay0", font)[1])
-            assert heights == sorted(heights, reverse=True), (
-                f"ladder not monotonically shrinking: {heights}")
-
-    def test_ladder_grid_is_crisp(self, font_manager):
-        """LADDER_GRID's BDF fonts are real bitmaps — always 0% antialiased."""
-        for step in LADDER_GRID:
-            font = font_manager.get_font(step.family, step.size_px)
-            assert measure_font_crispness(font, "Ay0") == 0.0
-
-    def test_ladder_arcade_is_crisp(self, font_manager):
-        """PressStart2P only rasterizes without antialiasing at exact
-        multiples of its 8px design grid — every LADDER_ARCADE rung must
-        land on one."""
-        for step in LADDER_ARCADE:
-            assert step.size_px % 8 == 0, f"{step} is not a multiple of 8"
-            font = font_manager.get_font(step.family, step.size_px)
-            assert measure_font_crispness(font, "17-21") == 0.0
-
-    def test_crispness_catches_a_bad_size(self, font_manager):
-        """Sanity check the measurement itself: a known-bad size for a
-        pixel-grid font must NOT read as crisp."""
-        font = font_manager.get_font("press_start", 10)  # not a multiple of 8
-        assert measure_font_crispness(font, "17-21") > 0.1
-
-    def test_fit_text_grows_on_taller_panel(self, font_manager):
-        small = LayoutContext(64, 32, font_manager)
-        large = LayoutContext(128, 64, font_manager)
-        text = "12:34"
-        fit_small = small.fit_text(text, small.bounds, ladder=LADDER_ARCADE)
-        fit_large = large.fit_text(text, large.bounds, ladder=LADDER_ARCADE)
-        assert fit_small.fits and fit_large.fits
-        assert fit_large.size_px > fit_small.size_px
-
-    def test_fit_text_fits_the_box(self, ctx):
-        box = ctx.bounds.inset(1)
-        fit = ctx.fit_text("HELLO WORLD", box)
-        assert fit.fits
-        assert fit.width <= box.w and fit.height <= box.h
-
-    def test_fit_text_ellipsizes_overlong_text(self, font_manager):
-        tiny = LayoutContext(32, 16, font_manager)
-        fit = tiny.fit_text("SUPERCALIFRAGILISTIC", tiny.bounds)
-        assert fit.text != "SUPERCALIFRAGILISTIC"
-        assert fit.text.endswith("…")
-        assert fit.width <= tiny.bounds.w
-
-    def test_fit_text_cached(self, ctx):
-        first = ctx.fit_text("CACHED", ctx.bounds)
-        second = ctx.fit_text("CACHED", ctx.bounds)
-        assert first is second
-        ctx.clear_cache()
-        assert ctx.fit_text("CACHED", ctx.bounds) is not first
-
-    def test_fit_text_proportional_tracks_design_scale(self, font_manager):
-        # design size 128x32, base_size_px=10 (a typical classic score size):
-        # at 2x scale the target is 20px -> nearest LADDER_ARCADE rung <= 20
-        # is 16px, not the largest that merely fits the box (32).
-        ctx = LayoutContext(256, 64, font_manager)  # scale = min(2,2) = 2
-        fit = ctx.fit_text_proportional("17-21", ctx.bounds, base_size_px=10,
-                                        ladder=LADDER_ARCADE)
-        assert fit.size_px == 16
-
-    def test_fit_text_proportional_does_not_exceed_max_fit(self, ctx):
-        # at scale=1 (128x32, the design size itself) the target equals
-        # base_size_px, so proportional should never pick something LARGER
-        # than plain fit_text would for the same box.
-        prop = ctx.fit_text_proportional("17-21", ctx.bounds, base_size_px=10,
-                                         ladder=LADDER_ARCADE)
-        maxed = ctx.fit_text("17-21", ctx.bounds, ladder=LADDER_ARCADE)
-        assert prop.size_px <= maxed.size_px
-
-    def test_fit_text_proportional_floors_at_smallest_rung(self, font_manager):
-        # scale so small the target is below every rung -> use the smallest
-        # rung as a floor rather than refusing to render anything.
-        ctx = LayoutContext(32, 8, font_manager)  # scale = min(32/128, 8/32) = 0.25
-        fit = ctx.fit_text_proportional("HI", ctx.bounds, base_size_px=10,
-                                        ladder=LADDER_ARCADE)
-        assert fit.size_px == min(s.size_px for s in LADDER_ARCADE)
-
-    def test_fit_text_proportional_falls_through_when_target_rung_overflows(self, font_manager):
-        # a long string at the target rung might not fit a narrow box even
-        # though the target size is "correct" -- must fall through to a
-        # smaller rung exactly like fit_text does, not just refuse to fit.
-        ctx = LayoutContext(256, 64, font_manager)
-        narrow_box = Region(0, 0, 40, 64)
-        fit = ctx.fit_text_proportional("A REALLY LONG STRING HERE", narrow_box,
-                                        base_size_px=10, ladder=LADDER_ARCADE)
-        assert fit.fits or fit.text.endswith("…")
-
-    def test_fit_text_proportional_cached(self, ctx):
-        first = ctx.fit_text_proportional("X", ctx.bounds, base_size_px=10)
-        second = ctx.fit_text_proportional("X", ctx.bounds, base_size_px=10)
-        assert first is second
-
-    def test_fit_text_proportional_scale_override(self, font_manager):
-        # 128x64 vs design 128x32: self.scale (min of both axes) is 1.0
-        # since width didn't grow, but a caller whose composition scales by
-        # HEIGHT alone (e.g. logo_slot = min(h, w//2)) should be able to
-        # override the reference scale so text grows with it too.
-        ctx = LayoutContext(128, 64, font_manager)
-        assert ctx.scale == 1.0
-        default_fit = ctx.fit_text_proportional("17-21", ctx.bounds, base_size_px=10,
-                                                 ladder=LADDER_ARCADE)
-        height_scale = 64 / 32  # matches design height
-        scaled_fit = ctx.fit_text_proportional("17-21", ctx.bounds, base_size_px=10,
-                                                ladder=LADDER_ARCADE, scale=height_scale)
-        assert scaled_fit.size_px > default_fit.size_px
-
-    def test_fit_lines_stacks_within_height(self, ctx):
-        box = ctx.bounds
-        lines = ["LINE ONE", "LINE TWO", "LINE THREE"]
-        fit = ctx.fit_lines(lines, box, spacing=1)
-        assert fit.fits
-        assert 3 * fit.line_height + 2 <= box.h
-
-    def test_font_for_rows(self, ctx):
-        fit = ctx.font_for_rows(4, 32)
-        assert fit.fits
-        assert 4 * fit.line_height <= 32
-
-    def test_ellipsize_returns_original_when_it_fits(self, ctx):
-        font = ctx.font_manager.get_font("4x6", 6)
-        assert ctx.ellipsize("HI", font, 1000) == "HI"
-
-
-class TestDrawFittedText:
-    def test_draws_within_region(self, ctx):
-        calls = []
-
-        class _DM:
-            def draw_text(self, text, x=None, y=None, color=None, font=None):
-                calls.append((text, x, y))
-
-        box = Region(10, 4, 100, 24)
-        fit = ctx.fit_text("SCORE", box)
-        draw_fitted_text(_DM(), fit, box)
-        text, x, y = calls[0]
-        assert text == "SCORE"
-        assert box.x <= x <= box.right - fit.width
-        # the ink (y + y_offset .. + height) must land inside the box
-        assert box.y <= y + fit.y_offset
-        assert y + fit.y_offset + fit.height <= box.bottom
-
-
-class TestBasePluginIntegration:
-    def test_layout_property_and_draw_fit(self):
-        from src.plugin_system.base_plugin import BasePlugin
-        from src.plugin_system.testing.mocks import (
-            MockCacheManager, MockDisplayManager, MockPluginManager,
-        )
-
-        class _Plugin(BasePlugin):
-            def update(self):
-                pass
-
-            def display(self, force_clear=False):
-                pass
-
-        plugin = _Plugin("test-plugin", {}, MockDisplayManager(96, 48),
-                         MockCacheManager(), MockPluginManager())
-        assert (plugin.layout.width, plugin.layout.height) == (96, 48)
-        assert plugin.layout is plugin.layout  # cached
-        fit = plugin.draw_fit("HELLO", plugin.layout.bounds.inset(1))
-        assert fit.fits
-        assert plugin.display_manager.draw_calls  # actually drew
-
-    def test_layout_rebuilds_on_size_change(self):
-        from src.plugin_system.base_plugin import BasePlugin
-        from src.plugin_system.testing.mocks import (
-            MockCacheManager, MockDisplayManager, MockPluginManager,
-        )
-
-        class _Plugin(BasePlugin):
-            def update(self):
-                pass
-
-            def display(self, force_clear=False):
-                pass
-
-        dm = MockDisplayManager(128, 32)
-        plugin = _Plugin("test-plugin", {}, dm,
-                         MockCacheManager(), MockPluginManager())
-        assert plugin.layout.tier == "sm"
-        dm.width, dm.height = 128, 64
-        assert plugin.layout.tier == "lg"
-
-    def test_design_size_from_manifest(self):
-        from src.plugin_system.base_plugin import BasePlugin
-        from src.plugin_system.testing.mocks import (
-            MockCacheManager, MockDisplayManager, MockPluginManager,
-        )
-
-        class _Plugin(BasePlugin):
-            def update(self):
-                pass
-
-            def display(self, force_clear=False):
-                pass
-
-        pm = MockPluginManager()
-        pm.plugin_manifests["test-plugin"] = {
-            "display": {"design_size": {"width": 64, "height": 32}}
-        }
-        plugin = _Plugin("test-plugin", {}, MockDisplayManager(128, 64),
-                         MockCacheManager(), pm)
-        assert plugin.layout.design_size == (64, 32)
-        assert plugin.layout.scale == 2.0
-
-
-class TestFitCacheBound:
-    def test_fit_cache_is_lru_bounded(self, ctx):
-        """A plugin fitting changing text (live game clock, ticker) on a
-        24/7 service must not grow the fit cache without bound."""
-        for i in range(ctx._FIT_CACHE_MAX + 100):
-            ctx.fit_text(f"tick {i}", Region(0, 0, 100, 20))
-        assert len(ctx._fit_cache) <= ctx._FIT_CACHE_MAX
-
-    def test_lru_keeps_recent_entries_hot(self, ctx):
-        hot = ctx.fit_text("stay hot", Region(0, 0, 100, 20))
-        for i in range(ctx._FIT_CACHE_MAX - 1):
-            ctx.fit_text(f"cold {i}", Region(0, 0, 100, 20))
-            ctx.fit_text("stay hot", Region(0, 0, 100, 20))  # keep touching it
-        assert ctx.fit_text("stay hot", Region(0, 0, 100, 20)) is hot

test/test_async_plugin_updates.py

@@ -1,270 +0,0 @@
-"""Tests for asynchronous plugin updates (plugin_manager background worker).
-
-The invariants that keep this change safe:
-1. run_scheduled_updates returns immediately — a slow update() can never
-   again freeze the render loop (the original defect: 30s scroll freezes).
-2. A plugin's update() and display() are NEVER concurrent — the per-plugin
-   lock makes the old implicit no-overlap guarantee explicit, and it stays
-   held through PluginExecutor's own timeout: a lingering, still-running
-   update() keeps the lock even after PluginExecutor gives up waiting on it.
-3. Failure/timeout bookkeeping is unchanged (same executor, same
-   _record_update_failure path, same last-update stamping).
-4. The kill switch (plugin_system.synchronous_updates) restores the
-   inline path exactly.
-"""
-
-import os
-import sys
-import threading
-import time
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from src.plugin_system.plugin_manager import PluginManager  # noqa: E402
-from src.plugin_system.plugin_state import PluginState  # noqa: E402
-
-
-class SlowPlugin:
-    """Fake plugin whose update() sleeps and records overlap violations."""
-
-    def __init__(self, update_seconds=0.5):
-        self.enabled = True
-        self.update_seconds = update_seconds
-        self.update_calls = 0
-        self.display_calls = 0
-        self.in_update = False
-        self.overlap_detected = False
-
-    def update(self):
-        self.in_update = True
-        self.update_calls += 1
-        time.sleep(self.update_seconds)
-        self.in_update = False
-        return True
-
-    def display(self, force_clear=False):
-        if self.in_update:
-            self.overlap_detected = True
-        self.display_calls += 1
-        return True
-
-
-@pytest.fixture
-def pm(tmp_path):
-    manager = PluginManager(plugins_dir=str(tmp_path), config_manager=None,
-                            display_manager=None, cache_manager=None)
-    yield manager
-    manager.stop_update_worker()
-
-
-def _install(pm, plugin, plugin_id="slow-plugin"):
-    pm.plugins[plugin_id] = plugin
-    pm._update_interval_cache[plugin_id] = 0.01  # always due
-    # load_plugin normally registers state; can_execute() gates on it
-    pm.state_manager.set_state(plugin_id, PluginState.ENABLED)
-    return plugin_id
-
-
-class TestSchedulerNonBlocking:
-    def test_run_scheduled_updates_returns_immediately(self, pm):
-        plugin_id = _install(pm, SlowPlugin(update_seconds=2.0))
-        start = time.monotonic()
-        pm.run_scheduled_updates()
-        elapsed = time.monotonic() - start
-        assert elapsed < 0.1, f"scheduler blocked for {elapsed:.2f}s"
-        # the update actually runs in the background
-        deadline = time.monotonic() + 5
-        while pm.plugins[plugin_id].update_calls == 0 and time.monotonic() < deadline:
-            time.sleep(0.05)
-        assert pm.plugins[plugin_id].update_calls == 1
-
-    def test_no_double_enqueue_while_pending(self, pm):
-        plugin_id = _install(pm, SlowPlugin(update_seconds=0.8))
-        for _ in range(20):
-            pm.run_scheduled_updates()
-            time.sleep(0.01)
-        time.sleep(1.5)  # let the single queued update finish
-        assert pm.plugins[plugin_id].update_calls == 1
-
-
-class TestUpdateDisplayExclusion:
-    def test_display_lock_held_during_update(self, pm):
-        plugin_id = _install(pm, SlowPlugin(update_seconds=0.6))
-        pm.run_scheduled_updates()
-        # give the worker a moment to take the lock and enter update()
-        deadline = time.monotonic() + 2
-        while not pm.plugins[plugin_id].in_update and time.monotonic() < deadline:
-            time.sleep(0.01)
-        lock = pm.get_plugin_lock(plugin_id)
-        assert lock.acquire(blocking=False) is False, \
-            "lock must be held while update() runs"
-        # and released afterwards
-        deadline = time.monotonic() + 3
-        while pm.plugins[plugin_id].in_update and time.monotonic() < deadline:
-            time.sleep(0.05)
-        time.sleep(0.1)
-        assert lock.acquire(blocking=False) is True
-        lock.release()
-
-    def test_no_overlap_under_hammering_display_loop(self, pm):
-        """Simulate the render loop's try-lock display pattern at high rate
-        while updates fire — the plugin itself asserts no overlap."""
-        plugin = SlowPlugin(update_seconds=0.15)
-        plugin_id = _install(pm, plugin)
-        stop = threading.Event()
-
-        def render_loop():
-            while not stop.is_set():
-                lock = pm.get_plugin_lock(plugin_id)
-                if lock.acquire(blocking=False):
-                    try:
-                        plugin.display()
-                    finally:
-                        lock.release()
-                time.sleep(0.002)
-
-        renderer = threading.Thread(target=render_loop, daemon=True)
-        renderer.start()
-        try:
-            for _ in range(6):
-                pm.plugin_last_update.pop(plugin_id, None)  # force due
-                pm.run_scheduled_updates()
-                time.sleep(0.3)
-        finally:
-            stop.set()
-            renderer.join(timeout=2)
-        assert plugin.update_calls >= 3
-        assert plugin.display_calls > 10
-        assert plugin.overlap_detected is False
-
-    def test_lock_held_through_timeout_until_real_update_finishes(self, pm):
-        """PluginExecutor's join(timeout) can return before the real
-        update() call does -- the lingering daemon thread keeps running it.
-        The plugin's lock must stay held for that whole real duration, not
-        just PluginExecutor's bounded wait, or display() could run
-        concurrently with a still-executing update()."""
-        plugin = SlowPlugin(update_seconds=0.3)
-        plugin_id = _install(pm, plugin)
-        pm.plugin_executor.default_timeout = 0.05  # times out well before
-                                                    # update_seconds elapses
-
-        pm.run_scheduled_updates()
-
-        deadline = time.monotonic() + 2
-        while not plugin.in_update and time.monotonic() < deadline:
-            time.sleep(0.01)
-        assert plugin.in_update is True
-
-        # PluginExecutor's own timeout has now elapsed, but the real
-        # update() (0.3s) is still running in its lingering daemon thread.
-        time.sleep(0.15)
-        assert plugin.in_update is True, "test setup: update should still be running"
-        lock = pm.get_plugin_lock(plugin_id)
-        assert lock.acquire(blocking=False) is False, \
-            "lock must stay held through PluginExecutor's timeout while the real update() runs"
-
-        # Once the real update() genuinely finishes, the lock is released.
-        deadline = time.monotonic() + 2
-        while plugin.in_update and time.monotonic() < deadline:
-            time.sleep(0.02)
-        time.sleep(0.1)
-        assert lock.acquire(blocking=False) is True
-        lock.release()
-
-    def test_state_returns_to_enabled_after_update(self, pm):
-        """RUNNING is set at enqueue (blocks re-entry via can_execute) and
-        must return to an executable state once the update finishes."""
-        plugin_id = _install(pm, SlowPlugin(update_seconds=0.1))
-        pm.run_scheduled_updates()
-        # while queued/running, re-entry is blocked
-        assert pm.state_manager.can_execute(plugin_id) is False
-        deadline = time.monotonic() + 3
-        while time.monotonic() < deadline:
-            if (pm.plugins[plugin_id].update_calls
-                    and pm.state_manager.can_execute(plugin_id)):
-                break
-            time.sleep(0.05)
-        assert pm.plugins[plugin_id].update_calls == 1
-        assert pm.state_manager.can_execute(plugin_id) is True
-
-
-class TestFailurePaths:
-    def test_update_failure_routes_through_failure_bookkeeping(self, pm):
-        class FailingPlugin(SlowPlugin):
-            def update(self):
-                self.update_calls += 1
-                raise RuntimeError("boom")
-
-        plugin_id = _install(pm, FailingPlugin())
-        pm.run_scheduled_updates()
-        deadline = time.monotonic() + 3
-        while pm.plugins[plugin_id].update_calls == 0 and time.monotonic() < deadline:
-            time.sleep(0.05)
-        time.sleep(0.2)
-        # failure stamped so the interval gate holds (no hot retry loop)
-        assert pm.plugin_last_update.get(plugin_id, 0) > 0
-        # lock released after failure
-        assert pm.get_plugin_lock(plugin_id).acquire(blocking=False) is True
-        pm.get_plugin_lock(plugin_id).release()
-
-    def test_unloaded_while_queued_is_harmless(self, pm):
-        """Exercise the public unload_plugin() lifecycle rather than
-        deleting pm.plugins directly: queue the target's update behind a
-        deterministic blocker (occupying the single worker), unload the
-        target while its item still sits queued, then release the blocker
-        and confirm the target's update never ran and its state stayed
-        unloaded rather than being resurrected to ENABLED."""
-        blocker_event = threading.Event()
-
-        class BlockerPlugin(SlowPlugin):
-            def update(self):
-                self.update_calls += 1
-                blocker_event.wait(timeout=5)
-                return True
-
-        blocker_id = _install(pm, BlockerPlugin(), plugin_id="blocker-plugin")
-        target = SlowPlugin(update_seconds=0.05)
-        target_id = _install(pm, target, plugin_id="slow-plugin")
-
-        # Dispatch the blocker first so it occupies the single worker
-        # thread, then enqueue the target behind it -- deterministically
-        # queued, not yet started.
-        pm._enqueue_update(blocker_id, time.time())
-        deadline = time.monotonic() + 2
-        while pm.plugins[blocker_id].update_calls == 0 and time.monotonic() < deadline:
-            time.sleep(0.01)
-        assert pm.plugins[blocker_id].update_calls == 1
-
-        pm._enqueue_update(target_id, time.time())
-        assert target_id in pm._pending_updates
-
-        assert pm.unload_plugin(target_id) is True
-        assert target_id not in pm.plugins
-
-        blocker_event.set()  # let the blocker finish; worker moves on to
-                              # the target's queued item
-
-        deadline = time.monotonic() + 3
-        while target_id in pm._pending_updates and time.monotonic() < deadline:
-            time.sleep(0.02)
-
-        assert target.update_calls == 0, "update() must not run for an unloaded plugin"
-        assert target_id not in pm._pending_updates
-        assert pm.state_manager.get_state(target_id) == PluginState.UNLOADED
-
-
-class TestKillSwitch:
-    def test_synchronous_mode_blocks_like_before(self, pm):
-        pm._synchronous_updates = True
-        plugin_id = _install(pm, SlowPlugin(update_seconds=0.4))
-        start = time.monotonic()
-        pm.run_scheduled_updates()
-        elapsed = time.monotonic() - start
-        assert elapsed >= 0.4, "synchronous mode must run inline"
-        assert pm.plugins[plugin_id].update_calls == 1
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-v"]))

test/test_cache_manager.py

@@ -400,61 +400,3 @@ class TestDiskCache:
         assert stats['fetch_count'] == 3
         assert stats['total_fetch_time'] == 1.8
         assert stats['average_fetch_time'] == pytest.approx(0.6, abs=0.01)
-
-
-class TestDiskCacheWriteEconomy:
-    """SD-card wear guards: identical payloads skip the disk, files are
-    compact, and TTL semantics survive the skip (see PR: fix/diskcache-sd-wear)."""
-
-    def test_identical_set_skips_rewrite(self, tmp_path):
-        import os
-        cache = DiskCache(cache_dir=str(tmp_path))
-        cache.set("k", {"data": "v"})
-        path = cache.get_cache_path("k")
-        first = os.stat(path)
-        os.utime(path, (first.st_atime - 100, first.st_mtime - 100))  # age it
-        aged_mtime = os.stat(path).st_mtime
-        ino_before = os.stat(path).st_ino
-        cache.set("k", {"data": "v"})  # identical payload
-        after = os.stat(path)
-        # mtime refreshed (TTL for mtime-based records preserved)...
-        assert after.st_mtime > aged_mtime
-        # ...but the file was NOT rewritten (same inode: no replace happened)
-        assert after.st_ino == ino_before
-
-    def test_changed_data_rewrites(self, tmp_path):
-        import os
-        cache = DiskCache(cache_dir=str(tmp_path))
-        cache.set("k", {"data": "v1"})
-        cache.set("k", {"data": "v2"})
-        assert cache.get("k") == {"data": "v2"}
-
-    def test_clear_resets_digest(self, tmp_path):
-        import os
-        cache = DiskCache(cache_dir=str(tmp_path))
-        cache.set("k", {"data": "v"})
-        cache.clear("k")
-        assert cache.get("k") is None
-        cache.set("k", {"data": "v"})  # same payload after clear must WRITE
-        assert cache.get("k") == {"data": "v"}
-
-    def test_skip_self_heals_when_file_deleted_externally(self, tmp_path):
-        import os
-        cache = DiskCache(cache_dir=str(tmp_path))
-        cache.set("k", {"data": "v"})
-        os.remove(cache.get_cache_path("k"))  # e.g. expiry cleanup
-        cache.set("k", {"data": "v"})  # digest matches but file is gone
-        assert cache.get("k") == {"data": "v"}
-
-    def test_files_are_compact_json(self, tmp_path):
-        cache = DiskCache(cache_dir=str(tmp_path))
-        cache.set("k", {"a": 1, "b": [1, 2, 3]})
-        raw = open(cache.get_cache_path("k")).read()
-        assert "\n" not in raw.strip()  # no indent
-        assert cache.get("k") == {"a": 1, "b": [1, 2, 3]}
-
-    def test_datetime_round_trip_still_works(self, tmp_path):
-        from datetime import datetime
-        cache = DiskCache(cache_dir=str(tmp_path))
-        cache.set("k", {"when": datetime(2026, 7, 12, 10, 30)})
-        assert cache.get("k") == {"when": "2026-07-12T10:30:00"}

test/test_config_load_cache.py

@@ -1,129 +0,0 @@
-"""Tests for load_config's mtime fast path (src/config_manager.py).
-
-load_config used to re-read + re-parse config.json, the template (with a
-recursive migration diff) and secrets on EVERY call — ~30 web request
-handlers call it, some 2-3x per request. The fast path skips all of it
-when the three files' (mtime_ns, size) signatures are unchanged.
-
-The invariant that matters most: cross-process freshness — a save from
-the web process must be picked up by the display process's next load.
-That's guaranteed because the signature is re-stat'd on every call.
-"""
-
-import json
-import os
-import sys
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from src.config_manager import ConfigManager  # noqa: E402
-
-
-@pytest.fixture
-def mgr(tmp_path):
-    config = tmp_path / "config.json"
-    secrets = tmp_path / "secrets.json"
-    template = tmp_path / "template.json"
-    config.write_text(json.dumps({"display": {"brightness": 90}, "timezone": "UTC"}))
-    secrets.write_text(json.dumps({"weather": {"api_key": "sek"}}))
-    template.write_text(json.dumps({"display": {"brightness": 90}, "timezone": "UTC"}))
-    m = ConfigManager(config_path=str(config), secrets_path=str(secrets))
-    m.template_path = str(template)
-    return m, config, secrets, template
-
-
-def _count_opens(monkeypatch, mgr_paths):
-    """Count open() calls hitting the config files."""
-    counts = {"n": 0}
-    real_open = open
-
-    def counting_open(file, *args, **kwargs):
-        if str(file) in mgr_paths:
-            counts["n"] += 1
-        return real_open(file, *args, **kwargs)
-
-    import builtins
-    monkeypatch.setattr(builtins, "open", counting_open)
-    return counts
-
-
-class TestFastPath:
-    def test_unchanged_files_are_not_reread(self, mgr, monkeypatch):
-        m, config, secrets, template = mgr
-        first = m.load_config()
-        assert first["weather"]["api_key"] == "sek"  # secrets merged
-        counts = _count_opens(monkeypatch, {str(config), str(secrets), str(template)})
-        for _ in range(10):
-            again = m.load_config()
-        assert counts["n"] == 0, "fast path must not re-open any config file"
-        assert again is first  # same aliasing semantics as the full path
-
-    def test_config_change_triggers_reload(self, mgr):
-        m, config, secrets, template = mgr
-        m.load_config()
-        data = json.loads(config.read_text())
-        data["display"]["brightness"] = 55
-        config.write_text(json.dumps(data))
-        os.utime(config, (os.stat(config).st_atime, os.stat(config).st_mtime + 2))
-        assert m.load_config()["display"]["brightness"] == 55
-
-    def test_secrets_change_triggers_reload(self, mgr):
-        m, config, secrets, template = mgr
-        m.load_config()
-        secrets.write_text(json.dumps({"weather": {"api_key": "NEW"}}))
-        os.utime(secrets, (os.stat(secrets).st_atime, os.stat(secrets).st_mtime + 2))
-        assert m.load_config()["weather"]["api_key"] == "NEW"
-
-    def test_template_change_triggers_reload_and_migration(self, mgr):
-        m, config, secrets, template = mgr
-        m.load_config()
-        template.write_text(json.dumps({
-            "display": {"brightness": 90}, "timezone": "UTC",
-            "brand_new_key": {"added": True}}))
-        os.utime(template, (os.stat(template).st_atime, os.stat(template).st_mtime + 2))
-        reloaded = m.load_config()
-        assert reloaded.get("brand_new_key") == {"added": True}
-
-    def test_same_second_edit_detected_via_mtime_ns_or_size(self, mgr):
-        """Coarse-mtime same-second edits: size difference still busts it."""
-        m, config, secrets, template = mgr
-        m.load_config()
-        st = os.stat(config)
-        data = json.loads(config.read_text())
-        data["timezone"] = "America/New_York"  # different byte length
-        config.write_text(json.dumps(data))
-        os.utime(config, (st.st_atime, st.st_mtime))  # force same mtime
-        assert m.load_config()["timezone"] == "America/New_York"
-
-
-class TestSaveCoherence:
-    def test_save_config_then_load_returns_saved_data(self, mgr, monkeypatch):
-        m, config, secrets, template = mgr
-        m.load_config()
-        new = {"display": {"brightness": 42}, "timezone": "UTC",
-               "weather": {"api_key": "sek"}}
-        m.save_config(new)
-        counts = _count_opens(monkeypatch, {str(config), str(secrets), str(template)})
-        loaded = m.load_config()
-        assert loaded["display"]["brightness"] == 42
-        assert loaded["weather"]["api_key"] == "sek"  # secrets survive in memory
-        assert counts["n"] == 0  # signature refreshed by save; no re-read
-
-    def test_cross_process_save_is_picked_up(self, mgr):
-        """Another process writing config.json (different mtime) must bust
-        this process's fast path — the core cross-process guarantee."""
-        m, config, secrets, template = mgr
-        m.load_config()
-        other = ConfigManager(config_path=str(config), secrets_path=str(secrets))
-        other.template_path = str(template)
-        other.load_config()
-        other.save_config({"display": {"brightness": 11}, "timezone": "UTC",
-                           "weather": {"api_key": "sek"}})
-        os.utime(config, (os.stat(config).st_atime, os.stat(config).st_mtime + 2))
-        assert m.load_config()["display"]["brightness"] == 11
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-v"]))

test/test_display_controller_vegas_tick.py

@@ -1,88 +0,0 @@
-"""
-Regression tests for DisplayController._tick_plugin_updates_for_vegas().
-
-PR #299 added logic to detect which plugins actually got fresh data on a
-scheduled-update tick and notify Vegas mode via
-vegas_coordinator.mark_plugin_updated(), so a live score change reaches the
-scroll within seconds instead of waiting for a full cycle. PR #330's
-multi-display sync refactor deleted this method (folding the callback back
-to the plain _tick_plugin_updates(), which reports nothing), silently
-orphaning VegasModeCoordinator.mark_plugin_updated() -- it has had zero
-callers since.
-"""
-
-from typing import Dict, List, Optional
-from unittest.mock import MagicMock
-
-from src.display_controller import DisplayController
-
-
-def _make_controller(updated: Optional[List[str]] = None, vegas_coordinator: Optional[MagicMock] = None) -> DisplayController:
-    dc = object.__new__(DisplayController)
-    dc.plugin_manager = MagicMock()
-    dc.plugin_manager.run_scheduled_updates_with_changes.return_value = list(updated or [])
-    dc.vegas_coordinator = vegas_coordinator
-    return dc
-
-
-class TestTickPluginUpdatesForVegas:
-    def test_marks_only_plugins_whose_timestamp_advanced(self):
-        vc = MagicMock()
-        dc = _make_controller(updated=["stock-news"], vegas_coordinator=vc)
-
-        dc._tick_plugin_updates_for_vegas()
-
-        vc.mark_plugin_updated.assert_called_once_with("stock-news")
-
-    def test_no_advance_marks_nothing(self):
-        vc = MagicMock()
-        dc = _make_controller(updated=[], vegas_coordinator=vc)
-
-        dc._tick_plugin_updates_for_vegas()
-
-        vc.mark_plugin_updated.assert_not_called()
-
-    def test_no_vegas_coordinator_does_not_raise(self):
-        dc = _make_controller(updated=["stock-news"], vegas_coordinator=None)
-
-        dc._tick_plugin_updates_for_vegas()  # must not raise
-
-    def test_mark_plugin_updated_exception_does_not_propagate(self):
-        """One plugin's mark_plugin_updated failing must not stop the tick
-        or crash the update loop it runs in."""
-        vc = MagicMock()
-        vc.mark_plugin_updated.side_effect = [RuntimeError("boom"), None]
-        dc = _make_controller(updated=["a", "b"], vegas_coordinator=vc)
-
-        dc._tick_plugin_updates_for_vegas()  # must not raise
-
-        assert vc.mark_plugin_updated.call_count == 2
-
-
-class TestVegasCoordinatorCallbackWiring:
-    def test_initialize_wires_vegas_aware_tick_as_update_callback(self):
-        """The Vegas coordinator must be given the Vegas-aware
-        _tick_plugin_updates_for_vegas as its update callback, not the plain
-        _tick_plugin_updates() -- that's the exact wiring PR #330 dropped."""
-        dc = object.__new__(DisplayController)
-        dc.config = {"display": {"vegas_scroll": {"enabled": True}}, "sync": {}}
-        dc.display_manager = MagicMock()
-        dc.plugin_manager = MagicMock()
-        dc.sync_manager = MagicMock()
-        dc._check_live_priority = MagicMock()
-        dc._check_vegas_interrupt = MagicMock(return_value=False)
-
-        fake_coordinator = MagicMock()
-
-        import src.display_controller as dc_module
-        original_imported = dc_module._vegas_mode_imported
-        original_class = dc_module.VegasModeCoordinator
-        try:
-            dc_module._vegas_mode_imported = True
-            dc_module.VegasModeCoordinator = MagicMock(return_value=fake_coordinator)
-            dc._initialize_vegas_mode()
-        finally:
-            dc_module._vegas_mode_imported = original_imported
-            dc_module.VegasModeCoordinator = original_class
-
-        fake_coordinator.set_update_callback.assert_called_once_with(dc._tick_plugin_updates_for_vegas)

test/test_display_dirty_tracking.py

@@ -1,162 +0,0 @@
-"""Tests for update_display dirty tracking (src/display_manager.py).
-
-Runs against RGBMatrixEmulator (EMULATOR=true), exercising the REAL
-DisplayManager — not a mock — so the skip logic, its invalidation hooks,
-and the kill switch are verified off-Pi.
-
-The invariants:
-- identical frames are pushed exactly once (SwapOnVSync not re-called)
-- ANY pixel change pushes
-- clear() and set_brightness() invalidate (the two paths that alter panel
-  state outside the digest's view)
-- the kill switch (display.dirty_tracking: false) restores always-push
-"""
-
-import os
-import sys
-import time
-
-os.environ["EMULATOR"] = "true"
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-
-@pytest.fixture(scope="module")
-def dm():
-    """One real DisplayManager on the emulator (it's a process singleton)."""
-    from src.display_manager import DisplayManager
-    DisplayManager._instance = None
-    DisplayManager._initialized = False
-    manager = DisplayManager({
-        "display": {
-            "hardware": {"rows": 32, "cols": 64, "chain_length": 2,
-                         "parallel": 1, "brightness": 90},
-            "runtime": {"gpio_slowdown": 0},
-        },
-    }, suppress_test_pattern=True)
-    yield manager
-    DisplayManager._instance = None
-    DisplayManager._initialized = False
-
-
-class _SwapSpy:
-    """Counts SwapOnVSync calls through the real matrix object."""
-
-    def __init__(self, matrix):
-        self.matrix = matrix
-        self.count = 0
-        self._orig = matrix.SwapOnVSync
-
-    def __enter__(self):
-        def counting(canvas):
-            self.count += 1
-            return self._orig(canvas)
-        self.matrix.SwapOnVSync = counting
-        return self
-
-    def __exit__(self, *exc):
-        self.matrix.SwapOnVSync = self._orig
-
-
-class TestDirtyTracking:
-    def test_identical_frames_push_once(self, dm):
-        dm.draw.rectangle([0, 0, 10, 10], fill=(255, 0, 0))
-        with _SwapSpy(dm.matrix) as spy:
-            dm.update_display()
-            dm.update_display()
-            dm.update_display()
-        assert spy.count == 1
-
-    def test_pixel_change_pushes(self, dm):
-        dm.update_display()
-        with _SwapSpy(dm.matrix) as spy:
-            dm.draw.point((5, 5), fill=(0, 255, 0))
-            dm.update_display()
-            dm.update_display()  # unchanged again
-        assert spy.count == 1
-
-    def test_clear_invalidates(self, dm):
-        dm.draw.rectangle([0, 0, 20, 20], fill=(0, 0, 255))
-        dm.update_display()
-        dm.clear()  # writes to the matrix directly; digest must reset
-        with _SwapSpy(dm.matrix) as spy:
-            dm.update_display()  # black frame after clear must still push
-        assert spy.count == 1
-
-    def test_brightness_change_forces_push(self, dm):
-        dm.draw.rectangle([0, 0, 20, 20], fill=(200, 200, 200))
-        dm.update_display()
-        with _SwapSpy(dm.matrix) as spy:
-            dm.update_display()          # identical -> skipped
-            assert spy.count == 0
-            dm.set_brightness(40)        # dim schedule scenario
-            dm.update_display()          # same image, new brightness -> push
-        assert spy.count == 1
-        dm.set_brightness(90)
-
-    def test_snapshot_still_written_on_skip(self, dm, tmp_path):
-        """The web preview mirror must keep working through skipped panel
-        pushes: _write_snapshot_if_due() still runs on the dirty-tracking
-        skip path and applies its own write/touch policy rather than being
-        bypassed entirely (see src/common/snapshot_policy.py — an unchanged
-        frame is touched, not re-encoded, once TOUCH_INTERVAL elapses)."""
-        dm._snapshot_path = str(tmp_path / "snap.png")
-        dm._last_snapshot_ts = 0.0
-        dm._last_snapshot_touch_ts = 0.0
-        dm._last_snapshot_digest = None
-        dm.draw.rectangle([0, 0, 30, 8], fill=(255, 255, 0))
-        dm.update_display()   # push + snapshot write (first frame)
-        assert os.path.exists(dm._snapshot_path)
-        first_mtime = os.path.getmtime(dm._snapshot_path)
-
-        # Age the write/touch bookkeeping past TOUCH_INTERVAL so the next
-        # identical frame is due for a touch, then push it again: dirty
-        # tracking must skip the panel write, but the snapshot mirror must
-        # still get its mtime bumped so the health check doesn't go stale.
-        from src.common import snapshot_policy
-        stale_ts = time.time() - snapshot_policy.TOUCH_INTERVAL - 1.0
-        dm._last_snapshot_ts = stale_ts
-        dm._last_snapshot_touch_ts = stale_ts
-        with _SwapSpy(dm.matrix) as spy:
-            dm.update_display()  # identical frame -> panel push skipped
-        assert spy.count == 0
-        assert os.path.getmtime(dm._snapshot_path) > first_mtime
-
-
-class TestKillSwitch:
-    def test_dirty_tracking_can_be_disabled(self, dm):
-        dm._dirty_tracking_enabled = False
-        try:
-            dm.draw.rectangle([0, 0, 10, 10], fill=(1, 2, 3))
-            with _SwapSpy(dm.matrix) as spy:
-                dm.update_display()
-                dm.update_display()
-                dm.update_display()
-            assert spy.count == 3  # always-push, exactly the old behavior
-        finally:
-            dm._dirty_tracking_enabled = True
-            dm._last_pushed_digest = None
-
-    def test_config_flag_wires_through(self):
-        from src.display_manager import DisplayManager
-        DisplayManager._instance = None
-        DisplayManager._initialized = False
-        try:
-            manager = DisplayManager({
-                "display": {
-                    "hardware": {"rows": 32, "cols": 64, "chain_length": 1,
-                                 "parallel": 1},
-                    "runtime": {"gpio_slowdown": 0},
-                    "dirty_tracking": False,
-                },
-            }, suppress_test_pattern=True)
-            assert manager._dirty_tracking_enabled is False
-        finally:
-            DisplayManager._instance = None
-            DisplayManager._initialized = False
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-v"]))

test/test_harness_fill.py

@@ -1,98 +0,0 @@
-"""Tests for the harness fill / scale-up check (src/plugin_system/testing/harness.py)."""
-
-from PIL import Image
-
-from src.plugin_system.testing.harness import (
-    RenderResult,
-    check_scale_up,
-    fill_metrics,
-)
-
-
-def _canvas(w, h):
-    return Image.new("RGB", (w, h), (0, 0, 0))
-
-
-def _with_block(w, h, bx, by, bw, bh, color=(255, 255, 255)):
-    img = _canvas(w, h)
-    img.paste(Image.new("RGB", (bw, bh), color), (bx, by))
-    return img
-
-
-def _result(w, h, image):
-    return RenderResult("p", w, h, "mode", image=image)
-
-
-class TestFillMetrics:
-    def test_full_white(self):
-        ex, ey, ink = fill_metrics(Image.new("RGB", (64, 32), (255, 255, 255)))
-        assert (ex, ey, ink) == (1.0, 1.0, 1.0)
-
-    def test_black_is_empty(self):
-        assert fill_metrics(_canvas(64, 32)) == (0.0, 0.0, 0.0)
-
-    def test_corner_dot(self):
-        ex, ey, ink = fill_metrics(_with_block(100, 100, 0, 0, 10, 10))
-        assert ex == 0.1 and ey == 0.1
-        assert ink == 0.01
-
-    def test_centered_half(self):
-        ex, ey, _ = fill_metrics(_with_block(100, 100, 25, 25, 50, 50))
-        assert ex == 0.5 and ey == 0.5
-
-    def test_dim_pixels_ignored(self):
-        img = _canvas(10, 10)
-        img.putpixel((5, 5), (10, 10, 10))  # below the lit threshold
-        assert fill_metrics(img) == (0.0, 0.0, 0.0)
-
-
-class TestCheckScaleUp:
-    def test_not_checked_below_2x(self):
-        # 128x64 vs design 128x32: only height is 2x -> checked on y only;
-        # 128x32 itself: not checked at all
-        r = _result(128, 32, _with_block(128, 32, 0, 0, 10, 10))
-        check_scale_up([r], design_size=(128, 32))
-        assert not r.fill_checked
-
-    def test_warn_mode_records_but_passes(self):
-        # tiny corner content on a 256x128 (2x both axes)
-        r = _result(256, 128, _with_block(256, 128, 0, 0, 20, 20))
-        check_scale_up([r], design_size=(128, 32), strict=False)
-        assert r.fill_checked
-        assert r.fill_ok is None       # warn-only: not a failure
-        assert r.ok                    # still passes
-        assert r.fill_extent[0] < 0.5
-
-    def test_strict_mode_fails_underfill(self):
-        r = _result(256, 128, _with_block(256, 128, 0, 0, 20, 20))
-        check_scale_up([r], design_size=(128, 32), strict=True)
-        assert r.fill_ok is False
-        assert not r.ok
-
-    def test_well_filled_passes_strict(self):
-        r = _result(256, 128, _with_block(256, 128, 10, 10, 200, 100))
-        check_scale_up([r], design_size=(128, 32), strict=True)
-        assert r.fill_ok is True and r.ok
-
-    def test_axis_selection_wide_only(self):
-        # 256x32 vs design 128x32: width is 2x, height is not -> only the
-        # x-extent matters; content spanning full width but few rows passes
-        r = _result(256, 32, _with_block(256, 32, 0, 12, 250, 8))
-        check_scale_up([r], design_size=(128, 32), strict=True)
-        assert r.fill_ok is True
-
-    def test_axis_selection_wide_only_underfill(self):
-        r = _result(256, 32, _with_block(256, 32, 0, 12, 60, 8))
-        check_scale_up([r], design_size=(128, 32), strict=True)
-        assert r.fill_ok is False
-
-    def test_errored_render_skipped(self):
-        r = RenderResult("p", 256, 128, "m", error="boom")
-        check_scale_up([r], design_size=(128, 32), strict=True)
-        assert not r.fill_checked
-
-    def test_custom_design_size(self):
-        # 128x64 with design 64x32 IS 2x both axes
-        r = _result(128, 64, _with_block(128, 64, 0, 0, 10, 10))
-        check_scale_up([r], design_size=(64, 32), strict=False)
-        assert r.fill_checked

test/test_layout_manager.py

@@ -0,0 +1,392 @@
+"""
+Tests for LayoutManager.
+
+Tests layout creation, management, rendering, and element positioning.
+"""
+
+import pytest
+import json
+from unittest.mock import MagicMock
+from src.layout_manager import LayoutManager
+
+
+class TestLayoutManager:
+    """Test LayoutManager functionality."""
+    
+    @pytest.fixture
+    def tmp_layout_file(self, tmp_path):
+        """Create a temporary layout file."""
+        layout_file = tmp_path / "custom_layouts.json"
+        return str(layout_file)
+    
+    @pytest.fixture
+    def mock_display_manager(self):
+        """Create a mock display manager."""
+        dm = MagicMock()
+        dm.clear = MagicMock()
+        dm.update_display = MagicMock()
+        dm.draw_text = MagicMock()
+        dm.draw_weather_icon = MagicMock()
+        dm.small_font = MagicMock()
+        dm.regular_font = MagicMock()
+        return dm
+    
+    @pytest.fixture
+    def layout_manager(self, tmp_layout_file, mock_display_manager):
+        """Create a LayoutManager instance."""
+        return LayoutManager(
+            display_manager=mock_display_manager,
+            config_path=tmp_layout_file
+        )
+    
+    def test_init(self, tmp_layout_file, mock_display_manager):
+        """Test LayoutManager initialization."""
+        lm = LayoutManager(
+            display_manager=mock_display_manager,
+            config_path=tmp_layout_file
+        )
+        
+        assert lm.display_manager == mock_display_manager
+        assert lm.config_path == tmp_layout_file
+        assert lm.layouts == {}
+        assert lm.current_layout is None
+    
+    def test_load_layouts_file_exists(self, tmp_path, mock_display_manager):
+        """Test loading layouts from existing file."""
+        layout_file = tmp_path / "custom_layouts.json"
+        layout_data = {
+            "test_layout": {
+                "elements": [{"type": "text", "x": 0, "y": 0}],
+                "description": "Test layout"
+            }
+        }
+        with open(layout_file, 'w') as f:
+            json.dump(layout_data, f)
+        
+        lm = LayoutManager(
+            display_manager=mock_display_manager,
+            config_path=str(layout_file)
+        )
+        
+        assert "test_layout" in lm.layouts
+        assert lm.layouts["test_layout"]["description"] == "Test layout"
+    
+    def test_load_layouts_file_not_exists(self, tmp_layout_file, mock_display_manager):
+        """Test loading layouts when file doesn't exist."""
+        lm = LayoutManager(
+            display_manager=mock_display_manager,
+            config_path=tmp_layout_file
+        )
+        
+        assert lm.layouts == {}
+    
+    def test_create_layout(self, layout_manager):
+        """Test creating a new layout."""
+        elements = [{"type": "text", "x": 10, "y": 20, "properties": {"text": "Hello"}}]
+        
+        result = layout_manager.create_layout("test_layout", elements, "Test description")
+        
+        assert result is True
+        assert "test_layout" in layout_manager.layouts
+        assert layout_manager.layouts["test_layout"]["elements"] == elements
+        assert layout_manager.layouts["test_layout"]["description"] == "Test description"
+        assert "created" in layout_manager.layouts["test_layout"]
+        assert "modified" in layout_manager.layouts["test_layout"]
+    
+    def test_update_layout(self, layout_manager):
+        """Test updating an existing layout."""
+        # Create a layout first
+        elements1 = [{"type": "text", "x": 0, "y": 0}]
+        layout_manager.create_layout("test_layout", elements1, "Original")
+        
+        # Update it
+        elements2 = [{"type": "text", "x": 10, "y": 20}]
+        result = layout_manager.update_layout("test_layout", elements2, "Updated")
+        
+        assert result is True
+        assert layout_manager.layouts["test_layout"]["elements"] == elements2
+        assert layout_manager.layouts["test_layout"]["description"] == "Updated"
+        assert "modified" in layout_manager.layouts["test_layout"]
+    
+    def test_update_layout_not_exists(self, layout_manager):
+        """Test updating a non-existent layout."""
+        elements = [{"type": "text", "x": 0, "y": 0}]
+        result = layout_manager.update_layout("nonexistent", elements)
+        
+        assert result is False
+    
+    def test_delete_layout(self, layout_manager):
+        """Test deleting a layout."""
+        elements = [{"type": "text", "x": 0, "y": 0}]
+        layout_manager.create_layout("test_layout", elements)
+        
+        result = layout_manager.delete_layout("test_layout")
+        
+        assert result is True
+        assert "test_layout" not in layout_manager.layouts
+    
+    def test_delete_layout_not_exists(self, layout_manager):
+        """Test deleting a non-existent layout."""
+        result = layout_manager.delete_layout("nonexistent")
+        
+        assert result is False
+    
+    def test_get_layout(self, layout_manager):
+        """Test getting a specific layout."""
+        elements = [{"type": "text", "x": 0, "y": 0}]
+        layout_manager.create_layout("test_layout", elements)
+        
+        layout = layout_manager.get_layout("test_layout")
+        
+        assert layout is not None
+        assert layout["elements"] == elements
+    
+    def test_get_layout_not_exists(self, layout_manager):
+        """Test getting a non-existent layout."""
+        layout = layout_manager.get_layout("nonexistent")
+        
+        assert layout == {}
+    
+    def test_list_layouts(self, layout_manager):
+        """Test listing all layouts."""
+        layout_manager.create_layout("layout1", [])
+        layout_manager.create_layout("layout2", [])
+        layout_manager.create_layout("layout3", [])
+        
+        layouts = layout_manager.list_layouts()
+        
+        assert len(layouts) == 3
+        assert "layout1" in layouts
+        assert "layout2" in layouts
+        assert "layout3" in layouts
+    
+    def test_set_current_layout(self, layout_manager):
+        """Test setting the current layout."""
+        layout_manager.create_layout("test_layout", [])
+        
+        result = layout_manager.set_current_layout("test_layout")
+        
+        assert result is True
+        assert layout_manager.current_layout == "test_layout"
+    
+    def test_set_current_layout_not_exists(self, layout_manager):
+        """Test setting a non-existent layout as current."""
+        result = layout_manager.set_current_layout("nonexistent")
+        
+        assert result is False
+        assert layout_manager.current_layout is None
+    
+    def test_render_layout(self, layout_manager, mock_display_manager):
+        """Test rendering a layout."""
+        elements = [
+            {"type": "text", "x": 0, "y": 0, "properties": {"text": "Hello"}},
+            {"type": "text", "x": 10, "y": 10, "properties": {"text": "World"}}
+        ]
+        layout_manager.create_layout("test_layout", elements)
+        
+        result = layout_manager.render_layout("test_layout")
+        
+        assert result is True
+        mock_display_manager.clear.assert_called_once()
+        mock_display_manager.update_display.assert_called_once()
+        assert mock_display_manager.draw_text.call_count == 2
+    
+    def test_render_layout_no_display_manager(self, tmp_layout_file):
+        """Test rendering without display manager."""
+        lm = LayoutManager(display_manager=None, config_path=tmp_layout_file)
+        lm.create_layout("test_layout", [])
+        
+        result = lm.render_layout("test_layout")
+        
+        assert result is False
+    
+    def test_render_layout_not_exists(self, layout_manager):
+        """Test rendering a non-existent layout."""
+        result = layout_manager.render_layout("nonexistent")
+        
+        assert result is False
+    
+    def test_render_element_text(self, layout_manager, mock_display_manager):
+        """Test rendering a text element."""
+        element = {
+            "type": "text",
+            "x": 10,
+            "y": 20,
+            "properties": {
+                "text": "Hello",
+                "color": [255, 0, 0],
+                "font_size": "small"
+            }
+        }
+        
+        layout_manager.render_element(element, {})
+        
+        mock_display_manager.draw_text.assert_called_once()
+        call_args = mock_display_manager.draw_text.call_args
+        assert call_args[0][0] == "Hello"  # text
+        assert call_args[0][1] == 10  # x
+        assert call_args[0][2] == 20  # y
+    
+    def test_render_element_weather_icon(self, layout_manager, mock_display_manager):
+        """Test rendering a weather icon element."""
+        element = {
+            "type": "weather_icon",
+            "x": 10,
+            "y": 20,
+            "properties": {
+                "condition": "sunny",
+                "size": 16
+            }
+        }
+        
+        layout_manager.render_element(element, {})
+        
+        mock_display_manager.draw_weather_icon.assert_called_once_with("sunny", 10, 20, 16)
+    
+    def test_render_element_weather_icon_from_context(self, layout_manager, mock_display_manager):
+        """Test rendering weather icon with data from context."""
+        element = {
+            "type": "weather_icon",
+            "x": 10,
+            "y": 20,
+            "properties": {"size": 16}
+        }
+        data_context = {
+            "weather": {
+                "condition": "cloudy"
+            }
+        }
+        
+        layout_manager.render_element(element, data_context)
+        
+        mock_display_manager.draw_weather_icon.assert_called_once_with("cloudy", 10, 20, 16)
+    
+    def test_render_element_rectangle(self, layout_manager, mock_display_manager):
+        """Test rendering a rectangle element."""
+        element = {
+            "type": "rectangle",
+            "x": 10,
+            "y": 20,
+            "properties": {
+                "width": 50,
+                "height": 30,
+                "color": [255, 0, 0],
+                "filled": True
+            }
+        }
+        
+        # Mock the draw object and rectangle method
+        mock_draw = MagicMock()
+        mock_display_manager.draw = mock_draw
+        
+        layout_manager.render_element(element, {})
+        
+        # Verify rectangle was drawn
+        mock_draw.rectangle.assert_called_once()
+    
+    def test_render_element_unknown_type(self, layout_manager):
+        """Test rendering an unknown element type."""
+        element = {
+            "type": "unknown_type",
+            "x": 0,
+            "y": 0,
+            "properties": {}
+        }
+        
+        # Should not raise an exception
+        layout_manager.render_element(element, {})
+    
+    def test_process_template_text(self, layout_manager):
+        """Test template text processing."""
+        text = "Hello {name}, temperature is {temp}°F"
+        data_context = {
+            "name": "World",
+            "temp": 72
+        }
+        
+        result = layout_manager._process_template_text(text, data_context)
+        
+        assert result == "Hello World, temperature is 72°F"
+    
+    def test_process_template_text_no_context(self, layout_manager):
+        """Test template text with missing context."""
+        text = "Hello {name}"
+        data_context = {}
+        
+        result = layout_manager._process_template_text(text, data_context)
+        
+        # Should leave template as-is or handle gracefully
+        assert "{name}" in result or result == "Hello "
+    
+    def test_save_layouts_error_handling(self, layout_manager):
+        """Test error handling when saving layouts."""
+        # Create a layout
+        layout_manager.create_layout("test", [])
+        
+        # Make save fail by using invalid path
+        layout_manager.config_path = "/nonexistent/directory/layouts.json"
+        
+        result = layout_manager.save_layouts()
+        
+        # Should handle error gracefully
+        assert result is False
+    
+    def test_render_element_line(self, layout_manager, mock_display_manager):
+        """Test rendering a line element."""
+        element = {
+            "type": "line",
+            "x": 10,
+            "y": 20,
+            "properties": {
+                "x2": 50,
+                "y2": 30,
+                "color": [255, 0, 0],
+                "width": 2
+            }
+        }
+        
+        mock_draw = MagicMock()
+        mock_display_manager.draw = mock_draw
+        
+        layout_manager.render_element(element, {})
+        
+        mock_draw.line.assert_called_once()
+    
+    def test_render_element_clock(self, layout_manager, mock_display_manager):
+        """Test rendering a clock element."""
+        element = {
+            "type": "clock",
+            "x": 10,
+            "y": 20,
+            "properties": {
+                "format": "%H:%M",
+                "color": [255, 255, 255]
+            }
+        }
+        
+        layout_manager.render_element(element, {})
+        
+        mock_display_manager.draw_text.assert_called_once()
+    
+    def test_render_element_data_text(self, layout_manager, mock_display_manager):
+        """Test rendering a data text element."""
+        element = {
+            "type": "data_text",
+            "x": 10,
+            "y": 20,
+            "properties": {
+                "data_key": "weather.temperature",
+                "format": "Temp: {value}°F",
+                "color": [255, 255, 255],
+                "default": "N/A"
+            }
+        }
+        data_context = {
+            "weather": {
+                "temperature": 72
+            }
+        }
+        
+        layout_manager.render_element(element, data_context)
+        
+        mock_display_manager.draw_text.assert_called_once()

test/test_loader_compat_warning.py

@@ -1,70 +0,0 @@
-"""Tests for the plugin loader's advisory version-compatibility warning."""
-
-import logging
-
-import pytest
-
-from src.plugin_system.plugin_loader import PluginLoader
-
-
-@pytest.fixture
-def loader():
-    return PluginLoader(logger=logging.getLogger("test-loader"))
-
-
-def _warnings(caplog):
-    return [r for r in caplog.records if r.levelno == logging.WARNING]
-
-
-class TestParseSemver:
-    def test_basic(self, loader):
-        assert loader._parse_semver("3.1.0") == (3, 1, 0)
-        assert loader._parse_semver("v2.0") == (2, 0, 0)
-        assert loader._parse_semver("2.0.0-beta.1") == (2, 0, 0)
-
-    def test_unparseable(self, loader):
-        assert loader._parse_semver(None) is None
-        assert loader._parse_semver(123) is None
-
-
-class TestWarnIfIncompatible:
-    def test_warns_when_plugin_needs_newer_core(self, loader, caplog, monkeypatch):
-        import src
-        monkeypatch.setattr(src, "__version__", "3.1.0")
-        with caplog.at_level(logging.WARNING, logger="test-loader"):
-            loader._warn_if_incompatible("p", {"min_ledmatrix_version": "9.0.0"})
-        assert len(_warnings(caplog)) == 1
-        assert "9.0.0" in _warnings(caplog)[0].message
-
-    def test_silent_when_compatible(self, loader, caplog, monkeypatch):
-        import src
-        monkeypatch.setattr(src, "__version__", "3.1.0")
-        with caplog.at_level(logging.WARNING, logger="test-loader"):
-            loader._warn_if_incompatible("p", {"min_ledmatrix_version": "2.0.0"})
-        assert not _warnings(caplog)
-
-    def test_silent_when_field_absent(self, loader, caplog):
-        with caplog.at_level(logging.WARNING, logger="test-loader"):
-            loader._warn_if_incompatible("p", {"name": "no version fields"})
-        assert not _warnings(caplog)
-
-    def test_reads_requires_and_versions_spellings(self, loader, caplog, monkeypatch):
-        import src
-        monkeypatch.setattr(src, "__version__", "3.1.0")
-        with caplog.at_level(logging.WARNING, logger="test-loader"):
-            loader._warn_if_incompatible(
-                "a", {"requires": {"min_ledmatrix_version": "9.0.0"}})
-            loader._warn_if_incompatible(
-                "b", {"versions": [{"ledmatrix_min_version": "9.0.0"}]})
-            loader._warn_if_incompatible(
-                "c", {"versions": [{"ledmatrix_min": "9.0.0"}]})
-        assert len(_warnings(caplog)) == 3
-
-    def test_stale_core_version_skips_comparison(self, loader, caplog, monkeypatch):
-        # Anti-spam guard: a core whose __version__ is below the ecosystem
-        # floor must not warn about every plugin.
-        import src
-        monkeypatch.setattr(src, "__version__", "1.0.0")
-        with caplog.at_level(logging.WARNING, logger="test-loader"):
-            loader._warn_if_incompatible("p", {"min_ledmatrix_version": "2.0.0"})
-        assert not _warnings(caplog)

test/test_plugin_system.py

@@ -123,14 +123,6 @@ class TestPluginManager:
 
             pm.run_scheduled_updates(current_time=time.time())
 
-            # Updates now execute on the background worker (the scheduler
-            # returns immediately) — wait for completion before asserting.
-            deadline = time.time() + 5
-            while (plugin_instance.update.call_count == 0
-                   and time.time() < deadline):
-                time.sleep(0.02)
-            pm.stop_update_worker()
-
             plugin_instance.update.assert_called_once()
             assert "test_plugin" in pm.plugin_last_update
             assert pm.state_manager.get_state("test_plugin") == PluginState.ENABLED

test/test_snapshot_policy.py

@@ -1,93 +0,0 @@
-"""Tests for the snapshot write policy (src/common/snapshot_policy.py).
-
-The invariants that matter:
-- unchanged frames are NEVER re-encoded (the old code PNG-encoded identical
-  frames at 5 fps, 24/7)
-- the file mtime never goes stale enough to trip the health check's 60s
-  degraded threshold (api_v3 get_hardware_status)
-- a viewer gets full cadence; no viewer drops to the idle keepalive
-"""
-
-import os
-import sys
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from src.common.snapshot_policy import (  # noqa: E402
-    IDLE_INTERVAL,
-    TOUCH_INTERVAL,
-    VIEWER_INTERVAL,
-    SnapshotAction,
-    decide,
-)
-
-
-class TestViewerCadence:
-    def test_changed_frame_with_viewer_writes_at_full_rate(self):
-        assert decide(now=100.0, last_write_ts=100.0 - VIEWER_INTERVAL,
-                      last_touch_ts=0, viewer_fresh=True,
-                      frame_changed=True) is SnapshotAction.WRITE
-
-    def test_changed_frame_with_viewer_respects_min_interval(self):
-        assert decide(now=100.0, last_write_ts=100.0 - VIEWER_INTERVAL / 2,
-                      last_touch_ts=100.0, viewer_fresh=True,
-                      frame_changed=True) is SnapshotAction.SKIP
-
-    def test_unchanged_frame_with_viewer_never_writes(self):
-        """A static screen with a viewer must not burn PNG encodes."""
-        assert decide(now=100.0, last_write_ts=90.0, last_touch_ts=90.0,
-                      viewer_fresh=True,
-                      frame_changed=False) is SnapshotAction.SKIP
-
-
-class TestIdleCadence:
-    def test_changed_frame_without_viewer_waits_for_idle_interval(self):
-        assert decide(now=100.0, last_write_ts=100.0 - IDLE_INTERVAL / 2,
-                      last_touch_ts=100.0, viewer_fresh=False,
-                      frame_changed=True) is SnapshotAction.SKIP
-
-    def test_changed_frame_without_viewer_writes_at_idle_rate(self):
-        assert decide(now=100.0, last_write_ts=100.0 - IDLE_INTERVAL,
-                      last_touch_ts=0, viewer_fresh=False,
-                      frame_changed=True) is SnapshotAction.WRITE
-
-
-class TestHealthKeepalive:
-    def test_stale_mtime_gets_touched(self):
-        """Whatever else happens, mtime must be bumped within TOUCH_INTERVAL
-        so the health check (60s threshold) never reads the display as dead."""
-        assert decide(now=100.0, last_write_ts=100.0 - TOUCH_INTERVAL,
-                      last_touch_ts=100.0 - TOUCH_INTERVAL, viewer_fresh=False,
-                      frame_changed=False) is SnapshotAction.TOUCH
-
-    def test_touch_applies_with_viewer_too(self):
-        """Viewer watching a static screen: no writes, but health stays green."""
-        assert decide(now=100.0, last_write_ts=100.0 - TOUCH_INTERVAL - 1,
-                      last_touch_ts=100.0 - TOUCH_INTERVAL - 1, viewer_fresh=True,
-                      frame_changed=False) is SnapshotAction.TOUCH
-
-    def test_recent_touch_suppresses_another(self):
-        assert decide(now=100.0, last_write_ts=0.0,
-                      last_touch_ts=100.0 - TOUCH_INTERVAL / 2, viewer_fresh=False,
-                      frame_changed=False) is SnapshotAction.SKIP
-
-    def test_touch_interval_stays_under_health_threshold(self):
-        """api_v3's hardware status treats snapshot age >= 60s as degraded.
-        Keep a 2x margin so scheduling jitter can't trip it."""
-        assert TOUCH_INTERVAL <= 30
-
-    def test_worst_case_mtime_age_is_bounded(self):
-        """Simulate any interleaving: from any state, within one policy call
-        after TOUCH_INTERVAL elapses, mtime gets refreshed (WRITE or TOUCH)."""
-        for viewer in (True, False):
-            for changed in (True, False):
-                action = decide(now=1000.0, last_write_ts=900.0,
-                                last_touch_ts=900.0, viewer_fresh=viewer,
-                                frame_changed=changed)
-                assert action in (SnapshotAction.WRITE, SnapshotAction.TOUCH)
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-v"]))

test/test_testing_mocks.py

@@ -1,45 +0,0 @@
-"""
-Unit tests for src/plugin_system/testing/mocks.py.
-
-MockCacheManager/MockPluginManager stand in for the real production
-managers under the plugin safety harness -- a missing method here isn't a
-harness bug in the abstract, it's a plugin silently failing to render
-under test (confirmed on ledmatrix-leaderboard, which calls
-get_cached_data_with_strategy() and previously hit an AttributeError that
-its own broad except swallowed, producing an empty-but-green render).
-"""
-
-from src.plugin_system.testing.mocks import MockCacheManager
-
-
-class TestMockCacheManagerStrategyMethod:
-    def test_get_cached_data_with_strategy_returns_cached_value(self):
-        cm = MockCacheManager()
-        cm.set("standings_nfl", {"teams": ["KC", "BUF"]})
-        result = cm.get_cached_data_with_strategy("standings_nfl", "sports_live")
-        assert result == {"teams": ["KC", "BUF"]}
-
-    def test_get_cached_data_with_strategy_returns_none_when_missing(self):
-        cm = MockCacheManager()
-        assert cm.get_cached_data_with_strategy("missing_key") is None
-
-    def test_get_cached_data_with_strategy_defaults_data_type(self):
-        cm = MockCacheManager()
-        cm.set("k", "v")
-        assert cm.get_cached_data_with_strategy("k") == "v"
-
-    def test_calls_are_tracked(self):
-        cm = MockCacheManager()
-        cm.get_cached_data_with_strategy("k", "sports_live")
-        assert cm.get_cached_data_with_strategy_calls == [{"key": "k", "data_type": "sports_live"}]
-
-    def test_save_cache_is_readable_via_strategy_lookup(self):
-        cm = MockCacheManager()
-        cm.save_cache("standings_nfl", {"teams": ["KC", "BUF"]})
-        assert cm.get_cached_data_with_strategy("standings_nfl") == {"teams": ["KC", "BUF"]}
-
-    def test_reset_clears_strategy_call_tracking(self):
-        cm = MockCacheManager()
-        cm.get_cached_data_with_strategy("k", "sports_live")
-        cm.reset()
-        assert cm.get_cached_data_with_strategy_calls == []

test/test_vegas_render_pipeline_recompose.py

@@ -1,72 +0,0 @@
-"""
-Regression tests for RenderPipeline.should_recompose()'s pending-updates check.
-
-PR #299 added a check so a plugin's live score/status change (a "pending
-update" in StreamManager) triggers a hot-swap within a few seconds instead
-of waiting for a full scroll cycle to complete. PR #330 (multi-display sync)
-refactored should_recompose() and dropped that check entirely -- not just
-gated behind the new sync-mode deferral it added, but removed outright, so
-even standalone (non-sync) installations silently lost live-refresh and fell
-back to waiting for full cycle boundaries (which, depending on
-min/max_cycle_duration, can be minutes).
-"""
-
-from unittest.mock import MagicMock
-
-from src.vegas_mode.config import VegasModeConfig
-from src.vegas_mode.render_pipeline import RenderPipeline
-
-
-class FakeDisplayManager:
-    width = 64
-    height = 32
-
-
-def _make_pipeline(sync_manager=None):
-    stream_manager = MagicMock()
-    stream_manager.get_buffer_status.return_value = {'staging_count': 0}
-    pipeline = RenderPipeline(VegasModeConfig(), FakeDisplayManager(), stream_manager)
-    pipeline.sync_manager = sync_manager
-    return pipeline, stream_manager
-
-
-class TestShouldRecompose:
-    def test_cycle_complete_always_recomposes(self):
-        pipeline, stream_manager = _make_pipeline()
-        pipeline._cycle_complete = True
-        stream_manager.has_pending_updates_for_visible_segments.return_value = False
-        assert pipeline.should_recompose() is True
-
-    def test_no_pending_updates_no_staging_does_not_recompose(self):
-        pipeline, stream_manager = _make_pipeline()
-        stream_manager.has_pending_updates_for_visible_segments.return_value = False
-        assert pipeline.should_recompose() is False
-
-    def test_pending_updates_on_visible_segment_triggers_recompose(self):
-        """The actual regression: a live-updated plugin currently in view
-        must trigger a recompose instead of waiting for cycle end."""
-        pipeline, stream_manager = _make_pipeline()
-        stream_manager.has_pending_updates_for_visible_segments.return_value = True
-        assert pipeline.should_recompose() is True
-
-    def test_staging_buffer_content_triggers_recompose(self):
-        pipeline, stream_manager = _make_pipeline()
-        stream_manager.get_buffer_status.return_value = {'staging_count': 1}
-        stream_manager.has_pending_updates_for_visible_segments.return_value = False
-        assert pipeline.should_recompose() is True
-
-    def test_sync_active_defers_pending_updates_to_cycle_boundary(self):
-        """Sync-mode deferral (PR #330's actual intent) must still hold:
-        pending updates alone must NOT trigger a mid-cycle hot-swap when a
-        follower display is attached, since that causes a visible
-        freeze+jump on the follower. This must keep working after
-        restoring the non-sync pending-updates check above."""
-        pipeline, stream_manager = _make_pipeline(sync_manager=MagicMock())
-        stream_manager.has_pending_updates_for_visible_segments.return_value = True
-        assert pipeline.should_recompose() is False
-
-    def test_sync_active_still_recomposes_on_cycle_complete(self):
-        pipeline, stream_manager = _make_pipeline(sync_manager=MagicMock())
-        pipeline._cycle_complete = True
-        stream_manager.has_pending_updates_for_visible_segments.return_value = True
-        assert pipeline.should_recompose() is True

test/test_web_smoke.py

@@ -1,184 +0,0 @@
-"""
-Web-UI smoke tests: every page, partial, and critical static asset must render.
-
-These boot the pages blueprint with the same dual registration app.py uses
-(un-prefixed primary + /v3 legacy alias) and assert each surface returns 200
-with its load-bearing markers present. They exist to catch, in CI, the class
-of regression that only shows up when a real request renders a real template:
-a broken partial, a missing tab wiring, a renamed element id that JS depends
-on, or a static asset that stopped being served.
-"""
-
-import sys
-from pathlib import Path
-from unittest.mock import MagicMock
-
-import pytest
-from flask import Flask
-
-PROJECT_ROOT = Path(__file__).parent.parent
-sys.path.insert(0, str(PROJECT_ROOT))
-
-
-SMOKE_CONFIG = {
-    "web_display_autostart": True,
-    "timezone": "America/Chicago",
-    "location": {"city": "Dallas", "state": "Texas", "country": "US"},
-    "plugin_system": {
-        "auto_discover": True,
-        "auto_load_enabled": True,
-        "development_mode": False,
-        "plugins_directory": "plugin-repos",
-    },
-    "schedule": {},
-    "dim_schedule": {"dim_brightness": 30},
-    "sync": {"role": "standalone", "port": 5765, "follower_position": "left"},
-    "clock": {"enabled": True},
-    "ledmatrix-weather": {"enabled": True},
-    "display": {
-        "hardware": {
-            "rows": 32, "cols": 64, "chain_length": 2, "parallel": 1,
-            "brightness": 95, "hardware_mapping": "adafruit-hat-pwm",
-            "led_rgb_sequence": "RGB", "multiplexing": 0, "panel_type": "",
-            "row_address_type": 0, "scan_mode": 0, "pwm_bits": 9,
-            "pwm_dither_bits": 1, "pwm_lsb_nanoseconds": 130,
-            "limit_refresh_rate_hz": 120, "disable_hardware_pulsing": False,
-            "inverse_colors": False, "show_refresh_rate": False,
-        },
-        "runtime": {"gpio_slowdown": 3, "rp1_rio": 0},
-        "double_sided": {"enabled": False, "copies": 2, "axis": "horizontal"},
-        "use_short_date_format": False,
-        "dynamic_duration": {"max_duration_seconds": 180},
-        "vegas_scroll": {
-            "enabled": False, "scroll_speed": 50, "separator_width": 32,
-            "target_fps": 125, "buffer_ahead": 2,
-            "plugin_order": [], "excluded_plugins": [],
-        },
-        "display_durations": {"stale_saved_mode": 45},
-        "plugin_rotation_order": ["ledmatrix-weather", "clock"],
-    },
-}
-
-PLUGIN_MODES = {
-    "clock": ["clock"],
-    "ledmatrix-weather": ["weather_current", "weather_daily"],
-}
-
-
-@pytest.fixture
-def client():
-    base = PROJECT_ROOT / "web_interface"
-    app = Flask(
-        __name__,
-        template_folder=str(base / "templates"),
-        static_folder=str(base / "static"),
-    )
-    app.config["TESTING"] = True
-
-    from web_interface.blueprints import pages_v3 as pv
-
-    # pages_v3 is a module-level Blueprint singleton shared by the whole test
-    # process (test_web_settings_ui.py mutates the same attributes) - save
-    # the originals and restore them on teardown so this fixture can't leak
-    # its mocks into tests that run afterward.
-    original_config_manager = getattr(pv.pages_v3, "config_manager", None)
-    original_plugin_manager = getattr(pv.pages_v3, "plugin_manager", None)
-
-    mock_cm = MagicMock()
-    mock_cm.load_config.return_value = SMOKE_CONFIG
-    mock_cm.get_raw_file_content.return_value = SMOKE_CONFIG
-    mock_cm.get_config_path.return_value = "config/config.json"
-    mock_cm.get_secrets_path.return_value = "config/config_secrets.json"
-    pv.pages_v3.config_manager = mock_cm
-
-    mock_pm = MagicMock()
-    mock_pm.plugins = {}
-    mock_pm.get_all_plugin_info.return_value = [
-        {"id": "clock", "name": "Clock"},
-        {"id": "ledmatrix-weather", "name": "Weather"},
-    ]
-    mock_pm.get_plugin_display_modes.side_effect = (
-        lambda pid: PLUGIN_MODES.get(pid, [])
-    )
-    pv.pages_v3.plugin_manager = mock_pm
-
-    # Same dual registration as web_interface/app.py: un-prefixed primary,
-    # /v3 kept as a working legacy alias.
-    app.register_blueprint(pv.pages_v3, url_prefix="")
-    app.register_blueprint(pv.pages_v3, url_prefix="/v3", name="pages_v3_legacy")
-    try:
-        yield app.test_client()
-    finally:
-        pv.pages_v3.config_manager = original_config_manager
-        pv.pages_v3.plugin_manager = original_plugin_manager
-
-
-# (path, [markers that must appear in the body])
-PAGES = [
-    ("/", ["site-nav", "mobileNavOpen", 'rel="manifest"',
-           "restart-pending-banner", "activeTab = 'durations'"]),
-    ("/partials/overview", ["getting-started-card", "displayImage"]),
-    ("/partials/general", ["timezone"]),
-    ("/partials/display", ["display-section-advanced-hardware",
-                           "display-resolution-value", "vegas_scroll_label"]),
-    ("/partials/durations", ["rotation_plugin_order", "duration__clock",
-                             "duration__weather_current",
-                             "duration__stale_saved_mode"]),
-    ("/partials/schedule", ["schedule"]),
-]
-
-
-@pytest.mark.parametrize("path,markers", PAGES, ids=[p for p, _ in PAGES])
-def test_page_renders_with_markers(client, path, markers):
-    resp = client.get(path)
-    assert resp.status_code == 200, f"{path} -> {resp.status_code}"
-    body = resp.get_data(as_text=True)
-    for marker in markers:
-        assert marker in body, f"{path}: missing marker {marker!r}"
-
-
-@pytest.mark.parametrize("path", [p for p, _ in PAGES if p != "/"])
-def test_legacy_v3_alias_serves_the_same_partials(client, path):
-    assert client.get("/v3" + path).status_code == 200
-
-
-STATIC_ASSETS = [
-    "/static/v3/app.css",
-    "/static/v3/app.js",
-    "/static/v3/manifest.json",
-    "/static/v3/icons/icon-192.png",
-    "/static/v3/js/app-shell.js",
-    "/static/v3/js/app-early.js",
-    "/static/v3/js/htmx-config.js",
-    "/static/v3/js/widgets/plugin-order-list.js",
-    "/static/v3/js/widgets/notification.js",
-    "/static/v3/vendor/fontawesome/css/all.min.css",
-    "/static/v3/vendor/codemirror/codemirror.min.js",
-]
-
-
-@pytest.mark.parametrize("asset", STATIC_ASSETS)
-def test_static_asset_served(client, asset):
-    resp = client.get(asset)
-    assert resp.status_code == 200, f"{asset} -> {resp.status_code}"
-    assert len(resp.data) > 0
-
-
-def test_durations_page_groups_by_plugin(client):
-    """One duration input per display mode of each enabled plugin, plus the
-    leftover group for saved keys no enabled plugin owns."""
-    body = client.get("/partials/durations").get_data(as_text=True)
-    assert body.count("duration__") >= 2 * len(
-        [m for modes in PLUGIN_MODES.values() for m in modes]
-    )  # each mode: id= and name=
-    assert "Other saved entries" in body
-
-
-def test_display_advanced_section_contains_tuning_fields(client):
-    body = client.get("/partials/display").get_data(as_text=True)
-    adv = body.find('id="display-section-advanced-hardware"')
-    adv_close = body.find("/#display-section-advanced-hardware")
-    assert 0 < adv < adv_close
-    for field in ["multiplexing", "pwm_bits", "inverse_colors"]:
-        pos = body.find(f'name="{field}"')
-        assert adv < pos < adv_close, f"{field} not inside the advanced section"

test/test_web_static_audit.py

@@ -1,85 +0,0 @@
-"""
-Static-analysis audits for the web UI, as tests so CI enforces them.
-
-1. Breakpoint utility audit: app.css hand-maintains a Tailwind-style utility
-   subset, so a template can reference a responsive class (e.g. sm:block)
-   that no CSS rule defines — it silently no-ops. This once left the header
-   search box and system stats invisible at every screen width. The audit
-   diffs classes used in templates against classes defined in app.css.
-
-2. Asset reference audit: every url_for('static', filename=...) in the
-   templates must point to a file that exists, so a renamed/moved asset
-   can't ship as a broken <script>/<link>/<img>.
-
-3. debugLog globals audit: any static JS file calling debugLog() (a global
-   defined in base.html) must declare it in a /* global */ header so linting
-   stays clean and the dependency is explicit.
-"""
-
-import re
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).parent.parent
-WEB = PROJECT_ROOT / "web_interface"
-TEMPLATES = WEB / "templates"
-STATIC = WEB / "static"
-APP_CSS = STATIC / "v3" / "app.css"
-
-BP_PREFIXES = ("sm", "md", "lg", "xl", "2xl")
-
-
-def _template_files():
-    return sorted(TEMPLATES.rglob("*.html"))
-
-
-def test_every_used_breakpoint_class_is_defined():
-    used = set()
-    class_attr = re.compile(r'class="([^"]*)"')
-    bp_class = re.compile(r"\b(%s):[A-Za-z0-9_.-]+" % "|".join(BP_PREFIXES))
-    for path in _template_files():
-        for attr in class_attr.findall(path.read_text()):
-            for m in bp_class.finditer(attr):
-                used.add(m.group(0))
-
-    css = APP_CSS.read_text()
-    defined = {
-        m.group(0).lstrip(".").replace("\\:", ":")
-        for m in re.finditer(
-            r"\.(%s)\\:[A-Za-z0-9_-]+" % "|".join(BP_PREFIXES), css
-        )
-    }
-
-    missing = sorted(used - defined)
-    assert not missing, (
-        "Responsive utility classes referenced in templates but never defined "
-        f"in app.css (they silently no-op): {missing}"
-    )
-
-
-def test_every_static_url_for_points_to_a_real_file():
-    ref = re.compile(
-        r"url_for\(\s*['\"]static['\"]\s*,\s*filename\s*=\s*['\"]([^'\"]+)['\"]"
-    )
-    missing = []
-    for path in _template_files():
-        for filename in ref.findall(path.read_text()):
-            if not (STATIC / filename).is_file():
-                missing.append(f"{path.relative_to(PROJECT_ROOT)}: {filename}")
-    assert not missing, f"Templates reference missing static assets: {missing}"
-
-
-def test_js_files_calling_debuglog_declare_the_global():
-    undeclared = []
-    for path in sorted((STATIC / "v3").rglob("*.js")):
-        if "vendor" in path.parts:
-            continue
-        text = path.read_text()
-        # Calls debugLog( but neither defines it nor declares the global
-        calls = re.search(r"(?<![.\w])debugLog\(", text)
-        defines = "window.debugLog" in text
-        declares = re.search(r"/\*\s*global[^*]*\bdebugLog\b", text)
-        if calls and not defines and not declares:
-            undeclared.append(str(path.relative_to(PROJECT_ROOT)))
-    assert not undeclared, (
-        f"JS files call debugLog() without a /* global debugLog */ header: {undeclared}"
-    )

test/test_wifi_check_state.py

@@ -1,92 +0,0 @@
-"""Tests for check_and_manage_ap_mode_with_state (src/wifi_manager.py).
-
-The wifi monitor daemon used to fetch WiFi status before AND after each
-check on top of the check's own internal fetch — every fetch is several
-nmcli subprocess forks, every 30s, forever. The new API returns the state
-the check observed, so the daemon runs exactly one fetch battery per tick.
-"""
-
-import os
-import sys
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))
-
-from src.wifi_manager import WiFiManager, WiFiStatus  # noqa: E402
-
-
-@pytest.fixture
-def wm(tmp_path):
-    with patch.object(WiFiManager, "_load_config", return_value={}, create=True):
-        manager = WiFiManager.__new__(WiFiManager)
-        # minimal attribute setup without running the real __init__
-        manager.config = {"auto_enable_ap_mode": True}
-        manager._disconnected_checks = 0
-        manager._disconnected_checks_required = 3
-        manager._ap_enabled_at = None
-        return manager
-
-
-def _wire(wm, connected, ethernet, ap_active):
-    wm._get_wifi_status_with_retry = MagicMock(
-        return_value=WiFiStatus(connected=connected, ssid="net" if connected else None))
-    wm._is_ethernet_connected = MagicMock(return_value=ethernet)
-    wm._is_ap_mode_active = MagicMock(return_value=ap_active)
-    wm.enable_ap_mode = MagicMock(return_value=(True, "ok"))
-    wm.disable_ap_mode = MagicMock(return_value=(True, "ok"))
-    wm.scan_networks = MagicMock(return_value=([], False))
-    wm._save_cached_scan = MagicMock()
-    wm._FORCE_AP_FLAG_PATH = MagicMock()
-    wm._FORCE_AP_FLAG_PATH.exists.return_value = False
-
-
-class TestWithState:
-    def test_single_fetch_per_call(self, wm):
-        _wire(wm, connected=True, ethernet=False, ap_active=False)
-        wm.check_and_manage_ap_mode_with_state()
-        assert wm._get_wifi_status_with_retry.call_count == 1
-        assert wm._is_ethernet_connected.call_count == 1
-        assert wm._is_ap_mode_active.call_count == 1
-
-    def test_returns_observed_state(self, wm):
-        _wire(wm, connected=True, ethernet=True, ap_active=False)
-        changed, status, ethernet, ap_after = wm.check_and_manage_ap_mode_with_state()
-        assert changed is False
-        assert status.connected is True
-        assert ethernet is True
-        assert ap_after is False
-
-    def test_ap_after_inverts_on_disable(self, wm):
-        """WiFi reconnects while AP is up -> auto-disable -> ap_after False."""
-        _wire(wm, connected=True, ethernet=False, ap_active=True)
-        changed, _status, _ethernet, ap_after = wm.check_and_manage_ap_mode_with_state()
-        assert changed is True
-        assert ap_after is False
-        wm.disable_ap_mode.assert_called_once()
-
-    def test_ap_after_inverts_on_enable(self, wm):
-        """Grace period exhausted with nothing connected -> enable -> True."""
-        _wire(wm, connected=False, ethernet=False, ap_active=False)
-        wm._disconnected_checks = 2  # this call is the 3rd
-        changed, _status, _ethernet, ap_after = wm.check_and_manage_ap_mode_with_state()
-        assert changed is True
-        assert ap_after is True
-        wm.enable_ap_mode.assert_called_once()
-
-    def test_bool_wrapper_is_back_compatible(self, wm):
-        _wire(wm, connected=True, ethernet=False, ap_active=False)
-        assert wm.check_and_manage_ap_mode() is False
-        _wire(wm, connected=True, ethernet=False, ap_active=True)
-        assert wm.check_and_manage_ap_mode() is True
-
-    def test_exception_path_never_raises(self, wm):
-        wm._get_wifi_status_with_retry = MagicMock(side_effect=RuntimeError("nmcli gone"))
-        changed, status, _ethernet, _ap_after = wm.check_and_manage_ap_mode_with_state()
-        assert changed is False
-        assert status.connected is False
-
-
-if __name__ == "__main__":
-    sys.exit(pytest.main([__file__, "-v"]))

web_interface/app.py

@@ -59,20 +59,6 @@ except ImportError:
     # flask-limiter not installed, rate limiting disabled
     limiter = None
 
-# Enable gzip/brotli response compression (Flask-Compress skips streaming
-# responses, so the SSE endpoints are unaffected). Optional, like limiter:
-# missing package just means uncompressed responses.
-try:
-    from flask_compress import Compress
-
-    Compress(app)
-except ImportError:
-    logging.getLogger(__name__).warning(
-        "flask-compress not installed - responses will be served uncompressed. "
-        "Install it with the Tools tab's 'Install Base Requirements' button or "
-        "'pip install flask-compress'."
-    )
-
 # Import cache functions from separate module to avoid circular imports
 
 # Initialize plugin managers - read plugins directory from config
@@ -190,12 +176,7 @@ except Exception as _hm_err:  # pragma: no cover - defensive startup guard
         "Could not enable plugin health/metrics for web UI: %s", _hm_err
     )
 
-# Pages are served un-prefixed (the interface lives at /); the /v3 mount is a
-# legacy alias kept so existing bookmarks and the hardcoded /v3/partials/...
-# fetches in templates/JS keep working unchanged. url_for('pages_v3.*')
-# resolves against the primary (un-prefixed) registration.
-app.register_blueprint(pages_v3, url_prefix='')
-app.register_blueprint(pages_v3, url_prefix='/v3', name='pages_v3_legacy')
+app.register_blueprint(pages_v3, url_prefix='/v3')
 app.register_blueprint(api_v3, url_prefix='/api/v3')
 
 # Route to serve plugin asset files (registered on main app, not blueprint, for /assets/... path)
@@ -426,11 +407,7 @@ def captive_portal_redirect():
     
     # List of paths that should NOT be redirected (allow normal operation)
     allowed_paths = [
-        '/v3',  # Legacy-prefixed interface and all sub-paths
-        '/setup',  # Captive setup page itself (un-prefixed mount)
-        '/partials/',  # HTMX partials (un-prefixed mount)
-        '/settings/',  # Settings search index (un-prefixed mount)
-        '/plugin-ui/',  # Plugin-provided web UI assets (un-prefixed mount)
+        '/v3',  # Main interface and all sub-paths (includes /v3/setup)
         '/api/v3/',  # All API endpoints
         '/static/',  # Static files (CSS, JS, images)
         '/hotspot-detect.html',  # iOS/macOS detection
@@ -629,23 +606,11 @@ def system_status_generator():
 def display_preview_generator():
     """Generate display preview updates from snapshot file"""
     import base64
-
+    from PIL import Image
+    import io
+    
     snapshot_path = "/tmp/led_matrix_preview.png"  # nosec B108 - fixed path matches display_manager; only read here
-    # Viewer marker: this generator only runs while the broadcaster has
-    # subscribers (it exits with no clients), so touching the marker each
-    # loop tells the DISPLAY service a browser is actually watching — it
-    # only pays for full-rate PNG snapshot encodes while this stays fresh
-    # (see src/common/snapshot_policy.py).
-    viewer_marker_path = "/tmp/led_matrix_preview_viewer"  # nosec B108 - fixed path matches display_manager
     last_modified = None
-
-    def _touch_viewer_marker():
-        try:
-            with open(viewer_marker_path, 'a'):
-                pass
-            os.utime(viewer_marker_path, None)
-        except OSError:
-            pass  # display side treats a missing marker as "no viewer"
     
     # Get display dimensions from config
     try:
@@ -662,7 +627,6 @@ def display_preview_generator():
     
     while True:
         try:
-            _touch_viewer_marker()
             # Check if snapshot file exists and has been modified
             if os.path.exists(snapshot_path):
                 current_modified = os.path.getmtime(snapshot_path)
@@ -670,26 +634,24 @@ def display_preview_generator():
                 # Only read if file is new or has been updated
                 if last_modified is None or current_modified > last_modified:
                     try:
-                        # The snapshot is already a PNG, written atomically by
-                        # the display service (tmp + os.replace in
-                        # display_manager), so pass the raw bytes straight
-                        # through instead of PIL-decoding and re-encoding —
-                        # identical payload, much less CPU on the Pi.
-                        with open(snapshot_path, 'rb') as f:
-                            img_str = base64.b64encode(f.read()).decode('utf-8')
-
-                        preview_data = {
-                            'timestamp': time.time(),
-                            'width': width,
-                            'height': height,
-                            'image': img_str
-                        }
-                        last_modified = current_modified
-                        yield preview_data
-                    except OSError:
-                        # Transient filesystem race (file rotated/replaced
-                        # between mtime check and read); skip this update.
-                        app.logger.debug("Preview snapshot read failed; skipping frame", exc_info=True)
+                        # Read and encode the image
+                        with Image.open(snapshot_path) as img:
+                            # Convert to PNG and encode as base64
+                            buffer = io.BytesIO()
+                            img.save(buffer, format='PNG')
+                            img_str = base64.b64encode(buffer.getvalue()).decode('utf-8')
+                            
+                            preview_data = {
+                                'timestamp': time.time(),
+                                'width': width,
+                                'height': height,
+                                'image': img_str
+                            }
+                            last_modified = current_modified
+                            yield preview_data
+                    except Exception:  # nosec B110 - SSE preview file may be mid-write; transient error, skip this update
+                        # File might be being written, skip this update
+                        pass
             else:
                 # No snapshot available
                 yield {
@@ -822,8 +784,11 @@ if limiter:
     limiter.limit("200 per minute")(stream_display)
     limiter.limit("200 per minute")(stream_logs)
 
-# The pages blueprint's index now serves '/' directly (see the un-prefixed
-# blueprint registration above), so no redirect route is needed here.
+# Main route - redirect to v3 interface as default
+@app.route('/')
+def index():
+    """Redirect to v3 interface"""
+    return redirect(url_for('pages_v3.index'))
 
 @app.route('/favicon.ico')
 def favicon():

web_interface/blueprints/api_v3.py

@@ -329,7 +329,6 @@ def save_schedule_config():
         }
 
         mode = data.get('mode', 'global')
-        schedule_config['mode'] = mode
 
         if mode == 'global':
             # Simple global schedule
@@ -961,31 +960,8 @@ def save_main_config():
                     return jsonify({"status": "error", "message": "sync_follower_position must be left or right"}), 400
                 current_config["sync"]["follower_position"] = pos_val
 
-        # Handle primary rotation order: must be a JSON array of plugin-id
-        # strings. Reject anything else with a 400 rather than silently
-        # coercing, so a buggy client can't clear or corrupt the saved order.
-        if 'plugin_rotation_order' in data:
-            raw_order = data.pop('plugin_rotation_order')
-            try:
-                parsed = json.loads(raw_order) if isinstance(raw_order, str) else raw_order
-            except (json.JSONDecodeError, TypeError, ValueError):
-                return jsonify({'status': 'error',
-                                'message': 'plugin_rotation_order must be valid JSON'}), 400
-            if not isinstance(parsed, list) or not all(isinstance(p, str) for p in parsed):
-                return jsonify({'status': 'error',
-                                'message': 'plugin_rotation_order must be a list of plugin-id strings'}), 400
-            if 'display' not in current_config:
-                current_config['display'] = {}
-            current_config['display']['plugin_rotation_order'] = parsed
-
-        # Handle display durations. Popped from `data` (not just read) so
-        # they can never also fall through to the generic "remaining keys"
-        # merge near the end of this function, which would otherwise write
-        # them AGAIN as bogus top-level config keys (e.g. "clock_duration": 30
-        # sitting at config root alongside the correct
-        # display.display_durations.clock_duration).
-        duration_fields = [k for k in list(data.keys())
-                           if k.endswith('_duration') or k in ('default_duration', 'transition_duration')]
+        # Handle display durations
+        duration_fields = [k for k in data.keys() if k.endswith('_duration') or k in ['default_duration', 'transition_duration']]
         if duration_fields:
             if 'display' not in current_config:
                 current_config['display'] = {}
@@ -993,36 +969,8 @@ def save_main_config():
                 current_config['display']['display_durations'] = {}
 
             for field in duration_fields:
-                raw_value = data.pop(field)
-                try:
-                    int_value = int(raw_value)
-                except (ValueError, TypeError):
-                    return jsonify({'status': 'error',
-                                    'message': f"Invalid duration for {field}: must be an integer"}), 400
-                current_config['display']['display_durations'][field] = int_value
-
-        # Per-mode durations from the Rotation & Durations page, posted as
-        # duration__<mode_key> (mode keys are arbitrary plugin mode names, so
-        # they can't use the suffix convention above). Same pop-and-validate
-        # treatment, for the same reason.
-        mode_duration_fields = [k for k in list(data.keys()) if k.startswith('duration__')]
-        if mode_duration_fields:
-            if 'display' not in current_config:
-                current_config['display'] = {}
-            if 'display_durations' not in current_config['display']:
-                current_config['display']['display_durations'] = {}
-
-            for field in mode_duration_fields:
-                raw_value = data.pop(field)
-                mode_key = field[len('duration__'):]
-                if not mode_key:
-                    continue
-                try:
-                    int_value = int(raw_value)
-                except (ValueError, TypeError):
-                    return jsonify({'status': 'error',
-                                    'message': f"Invalid duration for mode '{mode_key}': must be an integer"}), 400
-                current_config['display']['display_durations'][mode_key] = int_value
+                if field in data:
+                    current_config['display']['display_durations'][field] = int(data[field])
 
         # Handle plugin configurations dynamically
         # Any key that matches a plugin ID should be saved as plugin config
@@ -1690,16 +1638,6 @@ def execute_system_action():
                 except subprocess.TimeoutExpired:
                     logger.warning("git stash timed out, proceeding with pull")
 
-            # Record HEAD before the pull so dependency changes can be detected
-            old_head = None
-            try:
-                _pre = subprocess.run(['git', 'rev-parse', 'HEAD'],
-                                      capture_output=True, text=True, timeout=10, cwd=project_dir)
-                if _pre.returncode == 0:
-                    old_head = _pre.stdout.strip()
-            except subprocess.TimeoutExpired:
-                logger.warning("git rev-parse timed out before pull")
-
             # Perform the git pull
             result = subprocess.run(
                 ['git', 'pull', '--rebase'],
@@ -1716,54 +1654,6 @@ def execute_system_action():
                     pull_message = f"Code updated successfully. Local changes were automatically stashed.{stash_info}"
                 if result.stdout and "Already up to date" not in result.stdout:
                     pull_message = f"Code updated successfully.{stash_info}"
-
-                # Keep Python dependencies in sync automatically: if the pull
-                # changed a requirements file, install it now — users updating
-                # from the web UI (most of them) never SSH in to pip install.
-                # Installs go through the same root-visible path as the
-                # Tools-tab buttons (_pip_install_requirements).
-                dep_notes = []
-                try:
-                    _post = subprocess.run(['git', 'rev-parse', 'HEAD'],
-                                           capture_output=True, text=True, timeout=10, cwd=project_dir)
-                    new_head = _post.stdout.strip() if _post.returncode == 0 else None
-                    if old_head and new_head and old_head != new_head:
-                        diff = subprocess.run(
-                            ['git', 'diff', '--name-only', f'{old_head}..{new_head}'],
-                            capture_output=True, text=True, timeout=15, cwd=project_dir)
-                        changed = set(diff.stdout.split()) if diff.returncode == 0 else set()
-                        for rel in ('requirements.txt', 'web_interface/requirements.txt'):
-                            req_path = PROJECT_ROOT / rel
-                            if rel not in changed or not req_path.exists():
-                                continue
-                            # Each file's install is isolated: a timeout or
-                            # OSError (e.g. the sudo wrapper/interpreter
-                            # missing) on one file must not abort the other.
-                            try:
-                                r = _pip_install_requirements(req_path, timeout=180)
-                                if r.returncode == 0:
-                                    dep_notes.append(f"Dependencies from {rel} updated.")
-                                else:
-                                    dep_notes.append(
-                                        f"Dependency install from {rel} failed — "
-                                        "run Install Base Requirements from the Tools tab.")
-                                    logger.warning("post-update pip install failed for %s: %s",
-                                                   rel, _truncate_output(r.stdout, r.stderr))
-                            except subprocess.TimeoutExpired:
-                                dep_notes.append(
-                                    f"Dependency install from {rel} timed out — "
-                                    "run Install Base Requirements from the Tools tab.")
-                                logger.warning("post-update pip install timed out for %s", rel)
-                            except OSError as install_err:
-                                dep_notes.append(
-                                    f"Dependency install from {rel} failed — "
-                                    "run Install Base Requirements from the Tools tab.")
-                                logger.warning("post-update pip install errored for %s: %s",
-                                               rel, install_err)
-                except subprocess.TimeoutExpired:
-                    logger.warning("post-update dependency sync timed out")
-                if dep_notes:
-                    pull_message += " " + " ".join(dep_notes)
                 # A `git pull` restores built-in plugins (committed under
                 # plugin-repos/) even if the user uninstalled them. Re-remove
                 # any the user previously uninstalled so the update doesn't
@@ -1794,36 +1684,14 @@ def execute_system_action():
             result = subprocess.run(['sudo', 'systemctl', 'restart', 'ledmatrix-web.service'],
                                  capture_output=True, text=True, timeout=10)
         elif action == 'install_base_requirements':
-            # Base + web interface requirements: flask-compress and friends
-            # live in web_interface/requirements.txt, not the root file.
-            req_files = [f for f in (PROJECT_ROOT / 'requirements.txt',
-                                     PROJECT_ROOT / 'web_interface' / 'requirements.txt')
-                         if f.exists()]
-            if not req_files:
+            req_file = PROJECT_ROOT / 'requirements.txt'
+            if not req_file.exists():
                 return jsonify({'status': 'error', 'message': 'No requirements.txt found at project root'})
-            outputs = []
-            all_ok = True
-            for req_file in req_files:
-                label = req_file.relative_to(PROJECT_ROOT)
-                # Isolate each file's install: a timeout or OSError on one
-                # (e.g. requirements.txt) must not abort the rest of the
-                # loop (e.g. web_interface/requirements.txt never attempted).
-                try:
-                    result = _pip_install_requirements(req_file, timeout=120)
-                    all_ok = all_ok and result.returncode == 0
-                    outputs.append(f"== {label} ==\n" + _truncate_output(result.stdout, result.stderr))
-                except subprocess.TimeoutExpired:
-                    all_ok = False
-                    outputs.append(f"== {label} ==\nTimed out after 120s")
-                    logger.warning("install_base_requirements timed out for %s", label)
-                except OSError as install_err:
-                    all_ok = False
-                    outputs.append(f"== {label} ==\nFailed: {install_err}")
-                    logger.warning("install_base_requirements errored for %s: %s", label, install_err)
+            result = _pip_install_requirements(req_file, timeout=120)
             return jsonify({
-                'status': 'success' if all_ok else 'error',
-                'message': 'Base requirements installed successfully' if all_ok else 'pip install failed',
-                'output': "\n".join(outputs)
+                'status': 'success' if result.returncode == 0 else 'error',
+                'message': 'Base requirements installed successfully' if result.returncode == 0 else 'pip install failed',
+                'output': _truncate_output(result.stdout, result.stderr)
             })
         elif action == 'install_plugin_requirements':
             active_pm = getattr(api_v3, 'plugin_manager', None)

web_interface/blueprints/pages_v3.py

@@ -397,51 +397,12 @@ def _load_display_partial():
         return "Error loading partial", 500
 
 def _load_durations_partial():
-    """Load rotation & durations partial.
-
-    Builds one duration entry per display mode of every enabled plugin
-    (falling back to the display controller's 30s default), overlaid with any
-    values saved in display.display_durations. Historically the template only
-    looped over saved keys, and nothing ever populated them, so the page
-    rendered empty.
-    """
+    """Load display durations partial"""
     try:
         if pages_v3.config_manager:
             main_config = pages_v3.config_manager.load_config()
-            duration_groups = []
-            covered_keys = set()
-            if pages_v3.plugin_manager:
-                try:
-                    pages_v3.plugin_manager.discover_plugins()
-                    saved = (main_config.get('display', {}) or {}).get('display_durations', {}) or {}
-                    infos = sorted(pages_v3.plugin_manager.get_all_plugin_info(),
-                                   key=lambda i: (i.get('name') or i.get('id') or '').lower())
-                    for info in infos:
-                        pid = info.get('id')
-                        if not pid or not (main_config.get(pid, {}) or {}).get('enabled', False):
-                            continue
-                        modes = pages_v3.plugin_manager.get_plugin_display_modes(pid) or [pid]
-                        covered_keys.update(modes)
-                        duration_groups.append({
-                            'plugin_id': pid,
-                            'plugin_name': info.get('name') or pid,
-                            'modes': [{'key': m, 'value': saved.get(m, 30)} for m in modes],
-                        })
-                    # Saved keys not owned by any enabled plugin (disabled or
-                    # uninstalled plugins) stay visible rather than vanishing.
-                    leftovers = [{'key': k, 'value': v} for k, v in saved.items()
-                                 if k not in covered_keys]
-                    if leftovers:
-                        duration_groups.append({
-                            'plugin_id': '',
-                            'plugin_name': 'Other saved entries',
-                            'modes': leftovers,
-                        })
-                except Exception:
-                    logger.warning("durations: could not enumerate plugin modes", exc_info=True)
             return render_template('v3/partials/durations.html',
-                                 main_config=main_config,
-                                 duration_groups=duration_groups)
+                                 main_config=main_config)
     except Exception as e:
         logger.error("Error loading partial", exc_info=True)
         return "Error loading partial", 500

web_interface/requirements.txt

@@ -7,7 +7,6 @@ flask>=3.1.3,<4.0.0
 werkzeug>=3.1.6,<4.0.0
 flask-wtf>=1.2.0  # CSRF protection (optional for local-only, but recommended)
 flask-limiter>=3.5.0  # Rate limiting (prevent accidental abuse)
-flask-compress>=1.14  # gzip/brotli response compression (big win for the large JS/HTML over WiFi)
 
 # WebSocket support for plugins
 # Note: Web interface uses Server-Sent Events (SSE) for real-time updates, not WebSockets

web_interface/static/v3/app.css

@@ -413,9 +413,6 @@ a, button, input, select, textarea {
 /* Responsive breakpoints */
 @media (min-width: 640px) {
     .sm\:px-6 { padding-left: 1.5rem; padding-right: 1.5rem; }
-    .sm\:block { display: block; }
-    .sm\:grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-    .sm\:text-sm { font-size: 0.875rem; line-height: 1.25rem; }
 }
 
 @media (min-width: 768px) {
@@ -424,8 +421,6 @@ a, button, input, select, textarea {
     .md\:grid-cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
     .md\:flex { display: flex; }
     .md\:hidden { display: none; }
-    .md\:block { display: block; }
-    .md\:w-auto { width: auto; }
 }
 
 @media (min-width: 1024px) {
@@ -436,14 +431,9 @@ a, button, input, select, textarea {
     .lg\:px-8 { padding-left: 2rem; padding-right: 2rem; }
     .lg\:gap-x-3 { column-gap: 0.75rem; }
     .lg\:gap-x-6 { column-gap: 1.5rem; }
-    .lg\:block { display: block; }
-    .lg\:flex { display: flex; }
-    .lg\:w-64 { width: 16rem; }
 }
 
 @media (min-width: 1280px) {
-    .xl\:grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-    .xl\:grid-cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
     .xl\:grid-cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
     .xl\:grid-cols-5 { grid-template-columns: repeat(5, minmax(0, 1fr)); }
     .xl\:grid-cols-6 { grid-template-columns: repeat(6, minmax(0, 1fr)); }
@@ -456,9 +446,6 @@ a, button, input, select, textarea {
 }
 
 @media (min-width: 1536px) {
-    .2xl\:grid-cols-2 { grid-template-columns: repeat(2, minmax(0, 1fr)); }
-    .2xl\:grid-cols-3 { grid-template-columns: repeat(3, minmax(0, 1fr)); }
-    .2xl\:grid-cols-4 { grid-template-columns: repeat(4, minmax(0, 1fr)); }
     .2xl\:grid-cols-5 { grid-template-columns: repeat(5, minmax(0, 1fr)); }
     .2xl\:grid-cols-6 { grid-template-columns: repeat(6, minmax(0, 1fr)); }
     .2xl\:grid-cols-7 { grid-template-columns: repeat(7, minmax(0, 1fr)); }
@@ -469,129 +456,6 @@ a, button, input, select, textarea {
     .2xl\:space-x-8 > * + * { margin-left: 2rem; }
 }
 
-/* ===== Mobile navigation drawer =====
-   Below md the #site-nav wrapper becomes an off-canvas drawer; at md and up
-   none of these rules apply and the nav renders exactly as before. */
-@media (max-width: 767.98px) {
-    .site-nav {
-        position: fixed;
-        top: 0;
-        left: 0;
-        bottom: 0;
-        z-index: 60;
-        width: min(85vw, 320px);
-        background-color: var(--color-surface);
-        border-right: 1px solid var(--color-border);
-        transform: translateX(-100%);
-        transition: transform 0.25s ease;
-        overflow-y: auto;
-        padding: 1rem;
-        -webkit-overflow-scrolling: touch;
-    }
-    .site-nav.open {
-        transform: translateX(0);
-        box-shadow: 0 0 24px rgba(0, 0, 0, 0.25);
-    }
-    /* Tabs become full-width rows with >=44px touch targets */
-    .site-nav .nav-tab {
-        display: flex;
-        width: 100%;
-        align-items: center;
-        gap: 0.5rem;
-        text-align: left;
-        padding: 0.75rem 1rem;
-        min-height: 44px;
-    }
-    .site-nav nav.-mb-px {
-        display: block;
-    }
-    .nav-backdrop {
-        position: fixed;
-        inset: 0;
-        z-index: 55;
-        background-color: rgba(0, 0, 0, 0.4);
-    }
-    /* Header widgets relocated into the drawer (see placeHeaderWidgets in
-       app.js). The originals carry `hidden`/breakpoint classes tuned for the
-       header, so re-enable them explicitly in the drawer context. */
-    #drawer-widgets #settings-search-wrap {
-        display: block !important;
-        margin-bottom: 1rem;
-    }
-    #drawer-widgets #settings-search-wrap input {
-        width: 100%;
-    }
-    #drawer-widgets #settings-search-results {
-        position: static;
-        width: 100%;
-        max-height: 50vh;
-        margin-top: 0.25rem;
-    }
-    #drawer-widgets #system-stats {
-        display: flex !important;
-        justify-content: space-between;
-        margin-bottom: 1rem;
-    }
-    /* Larger touch targets inside horizontally scrolling tables */
-    .overflow-x-auto table button {
-        min-width: 44px;
-        min-height: 44px;
-    }
-    .overflow-x-auto table input:not([type="checkbox"]),
-    .overflow-x-auto table select {
-        min-height: 40px;
-    }
-    .overflow-x-auto table input[type="checkbox"] {
-        width: 1.25rem;
-        height: 1.25rem;
-    }
-}
-
-@media (min-width: 768px) {
-    /* Hard guards: even if mobileNavOpen was left true when the viewport
-       crossed the breakpoint, the drawer/backdrop must render as plain
-       in-flow nav on desktop. */
-    .site-nav {
-        position: static;
-        transform: none;
-        width: auto;
-        padding: 0;
-        border-right: none;
-        box-shadow: none;
-        background-color: transparent;
-        overflow-y: visible;
-    }
-    .nav-backdrop {
-        display: none !important;
-    }
-    #drawer-widgets {
-        display: none;
-    }
-}
-
-/* Mobile modal sizing: every .modal-content dialog fits the viewport with
-   internal scrolling instead of overflowing it. */
-@media (max-width: 640px) {
-    .modal-content {
-        width: 95vw !important;
-        max-width: 95vw !important;
-        max-height: 90vh;
-        overflow-y: auto;
-    }
-}
-
-/* Edge-fade hint that a container scrolls horizontally (pure CSS,
-   Lea Verou scrolling-shadows technique — backgrounds sit behind content). */
-.overflow-x-auto {
-    background:
-        linear-gradient(90deg, var(--color-surface) 30%, rgba(255, 255, 255, 0)) left / 24px 100%,
-        linear-gradient(270deg, var(--color-surface) 30%, rgba(255, 255, 255, 0)) right / 24px 100%,
-        radial-gradient(farthest-side at 0 50%, rgba(0, 0, 0, 0.18), rgba(0, 0, 0, 0)) left / 12px 100%,
-        radial-gradient(farthest-side at 100% 50%, rgba(0, 0, 0, 0.18), rgba(0, 0, 0, 0)) right / 12px 100%;
-    background-repeat: no-repeat;
-    background-attachment: local, local, scroll, scroll;
-}
-
 /* HTMX loading states */
 .htmx-request .loading {
     display: inline-block;
@@ -1356,44 +1220,3 @@ button.bg-white {
 [data-theme="dark"] .power-warning-banner-dismiss {
     color: #fca5a5;
 }
-
-/* ===== Floating live preview (all tabs except Overview) ===== */
-.floating-preview {
-    position: fixed;
-    right: 1rem;
-    bottom: 1rem;
-    z-index: 70;
-    background-color: #111827;
-    border: 1px solid #374151;
-    border-radius: 0.5rem;
-    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.4);
-    overflow: hidden;
-    /* Desktop: draggable resize handle (bottom-left visually, since the
-       panel is anchored to the right). Touch devices use the size button. */
-    resize: both;
-    min-width: 160px;
-    max-width: 90vw;
-}
-.floating-preview img {
-    background-color: #000;
-}
-.floating-preview-toggle {
-    position: fixed;
-    right: 1rem;
-    bottom: 1rem;
-    z-index: 70;
-    width: 44px;
-    height: 44px;
-    border-radius: 9999px;
-    background-color: var(--color-primary);
-    color: #ffffff;
-    box-shadow: 0 4px 12px rgba(0, 0, 0, 0.35);
-    align-items: center;
-    justify-content: center;
-}
-@media (max-width: 640px) {
-    /* Whatever size is chosen, never wider than the phone viewport */
-    .floating-preview {
-        max-width: calc(100vw - 2rem);
-    }
-}

web_interface/static/v3/app.js

@@ -1,4 +1,4 @@
-/* global showNotification, updateSystemStats, updateDisplayPreview, htmx, debugLog */
+/* global showNotification, updateSystemStats, updateDisplayPreview, htmx */
 // LED Matrix v3 JavaScript
 // Additional helpers for HTMX and Alpine.js integration
 
@@ -12,8 +12,8 @@ window.showNotification = function(message, type = 'info') {
         });
         document.dispatchEvent(event);
     } else {
-        // Fallback notification — user-facing last resort, so never gated
-        console.info(`${type}: ${message}`);
+        // Fallback notification
+        console.log(`${type}: ${message}`);
     }
 };
 
@@ -49,111 +49,6 @@ document.body.addEventListener('htmx:afterRequest', function(event) {
             // Not JSON, ignore
         }
     }
-
-    // Main-config saves (display hardware, rotation/durations, general) only
-    // take effect after a display-service restart — surface the reminder
-    // banner. Plugin config saves apply live and are deliberately excluded.
-    try {
-        const cfg = event.detail.requestConfig;
-        if (cfg && cfg.verb === 'post' &&
-            (cfg.path || '').includes('/api/v3/config/main') &&
-            response && response.status >= 200 && response.status < 300) {
-            window.showRestartPending();
-        }
-    } catch { /* banner is best-effort */ }
-});
-
-// ===== Unsaved-changes guard =====
-// Plugin config panels are Alpine x-if templates: navigating away DESTROYS
-// the panel and revisiting re-fetches it, silently discarding any edits.
-// (System tabs use x-show + data-loaded and persist, so they're exempt.)
-// Track dirty forms and confirm before a lossy navigation.
-(function() {
-    function markDirty(e) {
-        const form = e.target && e.target.closest ? e.target.closest('form') : null;
-        if (form) form.setAttribute('data-dirty', '');
-    }
-    document.body.addEventListener('input', markDirty);
-    document.body.addEventListener('change', markDirty);
-
-    // A successful submit makes the form clean again
-    document.body.addEventListener('htmx:afterRequest', function(event) {
-        const xhr = event.detail.xhr;
-        const form = event.detail.elt && event.detail.elt.closest ? event.detail.elt.closest('form') : null;
-        if (form && xhr && xhr.status >= 200 && xhr.status < 300) {
-            form.removeAttribute('data-dirty');
-        }
-    });
-
-    // Capture phase so this runs before Alpine's bubbling @click switches tabs
-    document.addEventListener('click', function(e) {
-        const tabBtn = e.target && e.target.closest ? e.target.closest('.nav-tab') : null;
-        if (!tabBtn) return;
-        const lossy = Array.prototype.filter.call(
-            document.querySelectorAll('.plugin-config-tab form[data-dirty]'),
-            function(f) { return f.offsetParent !== null; }
-        );
-        if (lossy.length === 0) return;
-        if (!window.confirm('You have unsaved plugin settings — leaving this page will discard them. Leave anyway?')) {
-            e.stopPropagation();
-            e.preventDefault();
-        }
-    }, true);
-
-    // Full page unload loses every panel's edits
-    window.addEventListener('beforeunload', function(e) {
-        const dirty = Array.prototype.some.call(
-            document.querySelectorAll('form[data-dirty]'),
-            function(f) { return f.offsetParent !== null; }
-        );
-        if (dirty) {
-            e.preventDefault();
-            e.returnValue = '';
-        }
-    });
-})();
-
-// ===== Restart-pending banner =====
-// Shown after restart-requiring saves; persists across tab switches (and
-// reloads, via sessionStorage) until the display restarts or it's dismissed.
-window.showRestartPending = function() {
-    try { sessionStorage.setItem('ledmatrix-restart-pending', '1'); } catch { /* private browsing */ }
-    const banner = document.getElementById('restart-pending-banner');
-    if (banner) banner.style.display = 'block';
-};
-
-window.dismissRestartPending = function() {
-    try { sessionStorage.removeItem('ledmatrix-restart-pending'); } catch { /* no-op */ }
-    const banner = document.getElementById('restart-pending-banner');
-    if (banner) banner.style.display = 'none';
-};
-
-window.restartPendingNow = function() {
-    const btn = document.getElementById('restart-pending-btn');
-    if (btn) btn.disabled = true;
-    fetch('/api/v3/system/action', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ action: 'restart_display_service' })
-    })
-    .then(r => r.json())
-    .then(data => {
-        showNotification(data.message || 'Display restarting…', data.status || 'success');
-        window.dismissRestartPending();
-    })
-    .catch(err => {
-        showNotification('Error restarting display: ' + err.message, 'error');
-    })
-    .finally(() => { if (btn) btn.disabled = false; });
-};
-
-document.addEventListener('DOMContentLoaded', function() {
-    try {
-        if (sessionStorage.getItem('ledmatrix-restart-pending') === '1') {
-            const banner = document.getElementById('restart-pending-banner');
-            if (banner) banner.style.display = 'block';
-        }
-    } catch { /* no-op */ }
 });
 
 // SSE reconnection helper — closes and reopens both SSE streams,
@@ -351,13 +246,13 @@ window.performanceMonitor = {
     logMetrics: function() {
         const metrics = this.getMetrics();
         console.group('Performance Metrics');
-        debugLog('DOM Content Loaded:', metrics.domContentLoaded?.toFixed(2) || 'N/A', 'ms');
-        debugLog('Load Complete:', metrics.loadComplete?.toFixed(2) || 'N/A', 'ms');
-        debugLog('First Paint:', metrics.firstPaint?.toFixed(2) || 'N/A', 'ms');
-        debugLog('First Contentful Paint:', metrics.firstContentfulPaint?.toFixed(2) || 'N/A', 'ms');
-        debugLog('Resources:', metrics.resourceCount || 0, 'files,', (metrics.totalResourceSize / 1024).toFixed(2) || '0', 'KB');
+        console.log('DOM Content Loaded:', metrics.domContentLoaded?.toFixed(2) || 'N/A', 'ms');
+        console.log('Load Complete:', metrics.loadComplete?.toFixed(2) || 'N/A', 'ms');
+        console.log('First Paint:', metrics.firstPaint?.toFixed(2) || 'N/A', 'ms');
+        console.log('First Contentful Paint:', metrics.firstContentfulPaint?.toFixed(2) || 'N/A', 'ms');
+        console.log('Resources:', metrics.resourceCount || 0, 'files,', (metrics.totalResourceSize / 1024).toFixed(2) || '0', 'KB');
         if (Object.keys(metrics.measures || {}).length > 0) {
-            debugLog('Custom Measures:', metrics.measures);
+            console.log('Custom Measures:', metrics.measures);
         }
         console.groupEnd();
     }
@@ -378,170 +273,3 @@ document.addEventListener('DOMContentLoaded', function() {
         }, 100);
     });
 });
-
-// ===== Floating live preview =====
-// A mini preview of the display, available on every tab except Overview
-// (which has the full-size one). Open/closed state persists per browser;
-// frames arrive via the existing SSE stream (updateDisplayPreview in
-// app-shell.js feeds #floating-preview-img).
-window.toggleFloatingPreview = function(open) {
-    try { localStorage.setItem('ledmatrix-floating-preview', open ? '1' : '0'); } catch { /* no-op */ }
-    window.updateFloatingPreviewVisibility();
-};
-
-// Preset widths the size button cycles through (px). Desktop users can also
-// drag the panel's native resize handle (CSS resize: both).
-const FLOATING_PREVIEW_SIZES = [192, 256, 384, 512];
-
-window.applyFloatingPreviewSize = function() {
-    const panel = document.getElementById('floating-preview');
-    if (!panel) return;
-    let size = 256;
-    try { size = parseInt(localStorage.getItem('ledmatrix-floating-preview-size'), 10) || 256; } catch { /* no-op */ }
-    panel.style.width = size + 'px';
-    // Clear any manual drag-resize height so the image's aspect ratio rules
-    panel.style.height = '';
-};
-
-window.cycleFloatingPreviewSize = function() {
-    let size = 256;
-    try { size = parseInt(localStorage.getItem('ledmatrix-floating-preview-size'), 10) || 256; } catch { /* no-op */ }
-    const idx = FLOATING_PREVIEW_SIZES.indexOf(size);
-    const next = FLOATING_PREVIEW_SIZES[(idx + 1) % FLOATING_PREVIEW_SIZES.length];
-    try { localStorage.setItem('ledmatrix-floating-preview-size', String(next)); } catch { /* no-op */ }
-    window.applyFloatingPreviewSize();
-};
-
-window.updateFloatingPreviewVisibility = function(tab) {
-    const panel = document.getElementById('floating-preview');
-    const toggle = document.getElementById('floating-preview-toggle');
-    if (!panel || !toggle) return;
-    let active = tab;
-    if (!active) {
-        const el = document.querySelector('[x-data="app()"]') || document.querySelector('[x-data]');
-        const data = el && el._x_dataStack && el._x_dataStack[0];
-        active = data && data.activeTab;
-    }
-    const onOverview = active === 'overview';
-    let open = false;
-    try { open = localStorage.getItem('ledmatrix-floating-preview') === '1'; } catch { /* no-op */ }
-    const showPanel = !onOverview && open;
-    panel.style.display = showPanel ? 'block' : 'none';
-    toggle.style.display = (!onOverview && !open) ? 'flex' : 'none';
-    if (showPanel) {
-        window.applyFloatingPreviewSize();
-        // Show the last cached frame immediately — SSE only pushes on
-        // display changes, so a freshly opened panel would otherwise stay
-        // empty until the next change.
-        const img = document.getElementById('floating-preview-img');
-        if (img && !img.src && window._lastPreviewFrame) {
-            img.src = 'data:image/png;base64,' + window._lastPreviewFrame;
-        }
-    }
-};
-
-document.addEventListener('DOMContentLoaded', function() {
-    window.updateFloatingPreviewVisibility();
-});
-
-// Run a plugin on the real display for 60s via the existing on-demand API
-// and open the floating preview so the effect is visible while configuring.
-window.previewPluginNow = function(pluginId) {
-    fetch('/api/v3/display/on-demand/start', {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ plugin_id: pluginId, duration: 60 })
-    })
-    .then(r => r.json())
-    .then(data => {
-        showNotification(data.message || ('Previewing ' + pluginId + ' for 60 seconds'),
-                         data.status || 'success');
-        if (data.status === 'success') window.toggleFloatingPreview(true);
-    })
-    .catch(err => {
-        showNotification('Preview failed: ' + err.message, 'error');
-    });
-};
-
-// ===== Nav accessibility =====
-// aria-current tracks the active tab. Buttons are matched by their Alpine
-// @click expression ("activeTab = '<tab>'"), which works for both the static
-// system tabs and the dynamically injected plugin tabs.
-window.updateNavAriaCurrent = function(tab) {
-    document.querySelectorAll('.nav-tab').forEach(function(btn) {
-        const expr = btn.getAttribute('@click') || btn.getAttribute('x-on:click') || '';
-        const isCurrent = expr.indexOf("activeTab = '" + tab + "'") !== -1;
-        if (isCurrent) {
-            btn.setAttribute('aria-current', 'page');
-        } else {
-            btn.removeAttribute('aria-current');
-        }
-    });
-};
-
-// Escape closes the mobile nav drawer and returns focus to the hamburger;
-// opening the drawer moves focus to its first tab.
-(function() {
-    function appData() {
-        const el = document.querySelector('[x-data="app()"]') || document.querySelector('[x-data]');
-        return el && el._x_dataStack && el._x_dataStack[0];
-    }
-    document.addEventListener('keydown', function(e) {
-        if (e.key !== 'Escape') return;
-        const data = appData();
-        if (data && data.mobileNavOpen) {
-            data.mobileNavOpen = false;
-            const burger = document.querySelector('[aria-controls="site-nav"]');
-            if (burger) burger.focus();
-        }
-    });
-    document.addEventListener('click', function(e) {
-        const burger = e.target && e.target.closest
-            ? e.target.closest('[aria-controls="site-nav"]') : null;
-        if (!burger) return;
-        // The click handler toggles mobileNavOpen; focus the first tab once
-        // the drawer has slid in (matches the CSS transition timing).
-        setTimeout(function() {
-            const data = appData();
-            if (data && data.mobileNavOpen) {
-                const first = document.querySelector('#site-nav .nav-tab');
-                if (first) first.focus();
-            }
-        }, 120);
-    });
-})();
-
-// ===== Mobile nav: header-widget relocation =====
-// Below the md breakpoint the settings-search box and system-stats block are
-// MOVED (same DOM nodes, listeners intact) from the header into the nav
-// drawer's #drawer-widgets slot; at md and up they move back. Single-instance
-// constraint: settings-search.js and the SSE stats updater both look these
-// elements up by id, so they must never be duplicated.
-window.placeHeaderWidgets = function() {
-    const drawer = document.getElementById('drawer-widgets');
-    const header = document.getElementById('header-widgets');
-    const search = document.getElementById('settings-search-wrap');
-    const stats = document.getElementById('system-stats');
-    if (!drawer || !header) return;
-
-    const desktop = window.matchMedia('(min-width: 768px)').matches;
-    if (desktop) {
-        // Restore original header order: search before the theme toggle,
-        // stats as the last item.
-        const themeToggle = document.getElementById('theme-toggle');
-        if (search && search.parentElement !== header) {
-            header.insertBefore(search, themeToggle || null);
-        }
-        if (stats && stats.parentElement !== header) {
-            header.appendChild(stats);
-        }
-    } else {
-        if (search && search.parentElement !== drawer) drawer.appendChild(search);
-        if (stats && stats.parentElement !== drawer) drawer.appendChild(stats);
-    }
-};
-
-document.addEventListener('DOMContentLoaded', function() {
-    window.placeHeaderWidgets();
-    window.matchMedia('(min-width: 768px)').addEventListener('change', window.placeHeaderWidgets);
-});

web_interface/static/v3/js/app-early.js

@@ -1,356 +0,0 @@
-/* global debugLog */
-// Early helpers and the app() stub (must run before Alpine init)
-// Extracted from templates/v3/base.html so browsers cache it as a static asset.
-        // Helper function to get installed plugins with fallback
-        // Must be defined before app() function that uses it
-        async function getInstalledPluginsSafe() {
-            if (window.PluginAPI && window.PluginAPI.getInstalledPlugins) {
-                try {
-                    const plugins = await window.PluginAPI.getInstalledPlugins();
-                    // Ensure plugins is always an array
-                    const pluginsArray = Array.isArray(plugins) ? plugins : [];
-                    return { status: 'success', data: { plugins: pluginsArray } };
-                } catch (error) {
-                    console.error('Error using PluginAPI.getInstalledPlugins, falling back to direct fetch:', error);
-                    // Fall through to direct fetch
-                }
-            }
-            // Fallback to direct fetch if PluginAPI not loaded
-            const response = await fetch('/api/v3/plugins/installed');
-            return await response.json();
-        }
-
-        // Global event listener for pluginsUpdated - works even if Alpine isn't ready yet
-        // This ensures tabs update when plugins_manager.js loads plugins
-        document.addEventListener('pluginsUpdated', function(event) {
-            debugLog('[GLOBAL] Received pluginsUpdated event:', event.detail?.plugins?.length || 0, 'plugins');
-            const plugins = event.detail?.plugins || [];
-            
-            // Update window.installedPlugins
-            window.installedPlugins = plugins;
-            
-            // Try to update Alpine component if it exists (only if using full implementation)
-            if (window.Alpine) {
-                const appElement = document.querySelector('[x-data="app()"]');
-                if (appElement && appElement._x_dataStack && appElement._x_dataStack[0]) {
-                    const appComponent = appElement._x_dataStack[0];
-                    appComponent.installedPlugins = plugins;
-                    // Only call updatePluginTabs if it's the full implementation (has _doUpdatePluginTabs)
-                    if (typeof appComponent.updatePluginTabs === 'function' && 
-                        appComponent.updatePluginTabs.toString().includes('_doUpdatePluginTabs')) {
-                        debugLog('[GLOBAL] Updating plugin tabs via Alpine component (full implementation)');
-                        appComponent.updatePluginTabs();
-                        return; // Full implementation handles it, don't do direct update
-                    }
-                }
-            }
-            
-            // Only do direct DOM update if full implementation isn't available yet
-            const pluginTabsRow = document.getElementById('plugin-tabs-row');
-            const pluginTabsNav = pluginTabsRow?.querySelector('nav');
-            if (pluginTabsRow && pluginTabsNav && plugins.length > 0) {
-                // Clear existing plugin tabs (except Plugin Manager)
-                const existingTabs = pluginTabsNav.querySelectorAll('.plugin-tab');
-                existingTabs.forEach(tab => { tab.remove(); });
-                
-                // Add tabs for each installed plugin
-                plugins.forEach(plugin => {
-                    const tabButton = document.createElement('button');
-                    tabButton.type = 'button';
-                    tabButton.setAttribute('data-plugin-id', plugin.id);
-                    tabButton.className = `plugin-tab nav-tab`;
-                    tabButton.onclick = function() {
-                        // Try to set activeTab via Alpine if available
-                        if (window.Alpine) {
-                            const appElement = document.querySelector('[x-data="app()"]');
-                            if (appElement && appElement._x_dataStack && appElement._x_dataStack[0]) {
-                                appElement._x_dataStack[0].activeTab = plugin.id;
-                                // Only call updatePluginTabStates if it exists
-                                if (typeof appElement._x_dataStack[0].updatePluginTabStates === 'function') {
-                                    appElement._x_dataStack[0].updatePluginTabStates();
-                                }
-                            }
-                        }
-                    };
-                    // Built with DOM APIs (no innerHTML): the icon class and
-                    // name come from plugin manifests, which are only
-                    // semi-trusted input.
-                    const tabIcon = document.createElement('i');
-                    tabIcon.className = plugin.icon || 'fas fa-puzzle-piece';
-                    tabButton.textContent = '';
-                    tabButton.appendChild(tabIcon);
-                    tabButton.appendChild(document.createTextNode(plugin.name || plugin.id));
-                    pluginTabsNav.appendChild(tabButton);
-                });
-                debugLog('[GLOBAL] Updated plugin tabs directly:', plugins.length, 'tabs added');
-            }
-        });
-
-        // Guard flag to prevent duplicate stub-to-full enhancement
-        window._appEnhanced = false;
-
-        // Define app() function early so Alpine can find it when it initializes
-        // This is a complete implementation that will work immediately
-        (function() {
-            const isAPMode = window.location.hostname === '192.168.4.1' || 
-                           window.location.hostname.startsWith('192.168.4.');
-            
-            // Create the app function - will be enhanced by full implementation later
-            window.app = function() {
-                return {
-                    activeTab: isAPMode ? 'wifi' : 'overview',
-                    mobileNavOpen: false,
-                    installedPlugins: [],
-                    
-                    init() {
-                        // Try to enhance immediately with full implementation
-                        const tryEnhance = () => {
-                            if (window._appEnhanced) return true;
-                            if (typeof window.app === 'function') {
-                                const fullApp = window.app();
-                                // Check if this is the full implementation (has updatePluginTabs with proper implementation)
-                                if (fullApp && typeof fullApp.updatePluginTabs === 'function' && fullApp.updatePluginTabs.toString().includes('_doUpdatePluginTabs')) {
-                                    window._appEnhanced = true;
-                                    // Preserve runtime state that should not be reset
-                                    const preservedPlugins = this.installedPlugins;
-                                    const preservedTab = this.activeTab;
-                                    const defaultTab = isAPMode ? 'wifi' : 'overview';
-                                    const wasInitialized = this._initialized;
-                                    Object.assign(this, fullApp);
-                                    // Restore runtime state if non-default
-                                    if (preservedPlugins && preservedPlugins.length > 0) {
-                                        this.installedPlugins = preservedPlugins;
-                                    }
-                                    if (preservedTab && preservedTab !== defaultTab) {
-                                        this.activeTab = preservedTab;
-                                    }
-                                    if (wasInitialized) {
-                                        this._initialized = wasInitialized;
-                                    }
-                                    // Only call init if not already initialized
-                                    if (typeof this.init === 'function' && !this._initialized) {
-                                        this.init();
-                                    }
-                                    return true;
-                                }
-                            }
-                            return false;
-                        };
-                        
-                        // Set up event listener for pluginsUpdated in stub (only if not already enhanced)
-                        // The full implementation will have its own listener, so we only need this for the stub
-                        if (!this._pluginsUpdatedListenerSet) {
-                            const handlePluginsUpdated = (event) => {
-                                debugLog('[STUB] Received pluginsUpdated event:', event.detail?.plugins?.length || 0, 'plugins');
-                                const plugins = event.detail?.plugins || [];
-                                // Only update if we're still in stub mode (not enhanced yet)
-                                if (typeof this.updatePluginTabs === 'function' && !this.updatePluginTabs.toString().includes('_doUpdatePluginTabs')) {
-                                    this.installedPlugins = plugins;
-                                    if (this.$nextTick && typeof this.$nextTick === 'function') {
-                                        this.$nextTick(() => {
-                                            this.updatePluginTabs();
-                                        });
-                                    } else {
-                                        setTimeout(() => {
-                                            this.updatePluginTabs();
-                                        }, 100);
-                                    }
-                                }
-                            };
-                            document.addEventListener('pluginsUpdated', handlePluginsUpdated);
-                            this._pluginsUpdatedListenerSet = true;
-                            debugLog('[STUB] init: Set up pluginsUpdated event listener');
-                        }
-                        
-                        // Try immediately - if full implementation is already loaded, use it right away
-                        if (!tryEnhance()) {
-                            // Full implementation not ready yet, load plugins directly while waiting
-                            this.loadInstalledPluginsDirectly();
-                            // Try again very soon to enhance with full implementation
-                            setTimeout(tryEnhance, 10);
-                            
-                            // Also set up a periodic check to update tabs if plugins get loaded by plugins_manager.js
-                            let retryCount = 0;
-                            const maxRetries = 20; // Check for 2 seconds (20 * 100ms)
-                            const checkAndUpdateTabs = () => {
-                                if (retryCount >= maxRetries) {
-                                    // Fallback: if plugins_manager.js hasn't loaded after 2 seconds, fetch directly
-                                    if (!window.installedPlugins || window.installedPlugins.length === 0) {
-                                        debugLog('[STUB] checkAndUpdateTabs: Fallback - fetching plugins directly after timeout');
-                                        this.loadInstalledPluginsDirectly();
-                                    }
-                                    return;
-                                }
-                                
-                                // Check if plugins are available (either from window or component)
-                                const plugins = window.installedPlugins || this.installedPlugins || [];
-                                if (plugins.length > 0) {
-                                    debugLog('[STUB] checkAndUpdateTabs: Found', plugins.length, 'plugins, updating tabs');
-                                    this.installedPlugins = plugins;
-                                    if (typeof this.updatePluginTabs === 'function') {
-                                        this.updatePluginTabs();
-                                    }
-                                } else {
-                                    retryCount++;
-                                    setTimeout(checkAndUpdateTabs, 100);
-                                }
-                            };
-                            // Start checking after a short delay
-                            setTimeout(checkAndUpdateTabs, 200);
-                        } else {
-                            // Full implementation loaded, but still set up fallback timer
-                            setTimeout(() => {
-                                if (!window.installedPlugins || window.installedPlugins.length === 0) {
-                                    debugLog('[STUB] init: Fallback timer - fetching plugins directly');
-                                    this.loadInstalledPluginsDirectly();
-                                }
-                            }, 2000);
-                        }
-                    },
-                    
-                    // Direct plugin loading for stub (before full implementation loads)
-                    async loadInstalledPluginsDirectly() {
-                        try {
-                            debugLog('[STUB] loadInstalledPluginsDirectly: Starting...');
-                            // Ensure DOM is ready
-                            const ensureDOMReady = () => {
-                                return new Promise((resolve) => {
-                                    if (document.readyState === 'complete' || document.readyState === 'interactive') {
-                                        // Use requestAnimationFrame to ensure DOM is painted
-                                        requestAnimationFrame(() => {
-                                            setTimeout(resolve, 50); // Small delay to ensure rendering
-                                        });
-                                    } else {
-                                        document.addEventListener('DOMContentLoaded', () => {
-                                            requestAnimationFrame(() => {
-                                                setTimeout(resolve, 50);
-                                            });
-                                        });
-                                    }
-                                });
-                            };
-                            
-                            await ensureDOMReady();
-                            
-                            const data = await getInstalledPluginsSafe();
-                            if (data.status === 'success') {
-                                const plugins = data.data.plugins || [];
-                                debugLog('[STUB] loadInstalledPluginsDirectly: Loaded', plugins.length, 'plugins');
-                                
-                                // Update both component and window
-                                this.installedPlugins = plugins;
-                                window.installedPlugins = plugins;
-                                
-                                // Dispatch event so global listener can update tabs
-                                document.dispatchEvent(new CustomEvent('pluginsUpdated', {
-                                    detail: { plugins: plugins }
-                                }));
-                                debugLog('[STUB] loadInstalledPluginsDirectly: Dispatched pluginsUpdated event');
-                                
-                                // Update tabs if we have the method - use $nextTick if available
-                                if (typeof this.updatePluginTabs === 'function') {
-                                    if (this.$nextTick && typeof this.$nextTick === 'function') {
-                                        this.$nextTick(() => {
-                                            this.updatePluginTabs();
-                                        });
-                                    } else {
-                                        // Fallback: wait a bit for DOM
-                                        setTimeout(() => {
-                                            this.updatePluginTabs();
-                                        }, 100);
-                                    }
-                                }
-                            } else {
-                                console.warn('[STUB] loadInstalledPluginsDirectly: Failed to load plugins:', data.message);
-                            }
-                        } catch (error) {
-                            console.error('[STUB] loadInstalledPluginsDirectly: Error loading plugins:', error);
-                        }
-                    },
-                    
-                    // Stub methods that will be replaced by full implementation
-                    loadTabContent: function(tab) {},
-                    loadInstalledPlugins: async function() {
-                        // Try to use global function if available, otherwise use direct loading
-                        if (typeof window.loadInstalledPlugins === 'function') {
-                            await window.loadInstalledPlugins();
-                            // Update tabs after loading (window.installedPlugins should be set by the global function)
-                            if (window.installedPlugins && Array.isArray(window.installedPlugins)) {
-                                this.installedPlugins = window.installedPlugins;
-                                this.updatePluginTabs();
-                            }
-                        } else if (typeof window.pluginManager?.loadInstalledPlugins === 'function') {
-                            await window.pluginManager.loadInstalledPlugins();
-                            // Update tabs after loading
-                            if (window.installedPlugins && Array.isArray(window.installedPlugins)) {
-                                this.installedPlugins = window.installedPlugins;
-                                this.updatePluginTabs();
-                            }
-                        } else {
-                            // Fallback to direct loading (which already calls updatePluginTabs)
-                            await this.loadInstalledPluginsDirectly();
-                        }
-                    },
-                    updatePluginTabs: function() {
-                        // Basic implementation for stub - will be replaced by full implementation
-                        // Debounce to prevent multiple rapid calls
-                        if (this._updatePluginTabsTimeout) {
-                            clearTimeout(this._updatePluginTabsTimeout);
-                        }
-                        
-                        this._updatePluginTabsTimeout = setTimeout(() => {
-                            debugLog('[STUB] updatePluginTabs: Executing with', this.installedPlugins?.length || 0, 'plugins');
-                            const pluginTabsRow = document.getElementById('plugin-tabs-row');
-                            const pluginTabsNav = pluginTabsRow?.querySelector('nav');
-                            if (!pluginTabsRow || !pluginTabsNav) {
-                                console.warn('[STUB] updatePluginTabs: Plugin tabs container not found');
-                                return;
-                            }
-                            if (!this.installedPlugins || this.installedPlugins.length === 0) {
-                                debugLog('[STUB] updatePluginTabs: No plugins to display');
-                                return;
-                            }
-                            
-                            // Check if tabs are already correct by comparing plugin IDs
-                            const existingTabs = pluginTabsNav.querySelectorAll('.plugin-tab');
-                            const existingIds = Array.from(existingTabs).map(tab => tab.getAttribute('data-plugin-id')).sort().join(',');
-                            const currentIds = this.installedPlugins.map(p => p.id).sort().join(',');
-                            
-                            if (existingIds === currentIds && existingTabs.length === this.installedPlugins.length) {
-                                debugLog('[STUB] updatePluginTabs: Tabs already match, skipping update');
-                                return;
-                            }
-                            
-                            // Clear existing plugin tabs (except Plugin Manager)
-                            existingTabs.forEach(tab => { tab.remove(); });
-                            debugLog('[STUB] updatePluginTabs: Cleared', existingTabs.length, 'existing tabs');
-                            
-                            // Add tabs for each installed plugin
-                            this.installedPlugins.forEach(plugin => {
-                                const tabButton = document.createElement('button');
-                                tabButton.type = 'button';
-                                tabButton.setAttribute('data-plugin-id', plugin.id);
-                                tabButton.className = `plugin-tab nav-tab ${this.activeTab === plugin.id ? 'nav-tab-active' : ''}`;
-                                tabButton.onclick = () => {
-                                    this.activeTab = plugin.id;
-                                    if (typeof this.updatePluginTabStates === 'function') {
-                                        this.updatePluginTabStates();
-                                    }
-                                };
-                                // DOM APIs instead of innerHTML: manifest
-                                // icon/name are semi-trusted input.
-                                const tabIcon = document.createElement('i');
-                                tabIcon.className = plugin.icon || 'fas fa-puzzle-piece';
-                                tabButton.textContent = '';
-                                tabButton.appendChild(tabIcon);
-                                tabButton.appendChild(document.createTextNode(plugin.name || plugin.id));
-                                pluginTabsNav.appendChild(tabButton);
-                            });
-                            debugLog('[STUB] updatePluginTabs: Added', this.installedPlugins.length, 'plugin tabs');
-                        }, 100);
-                    },
-                    showNotification: function(message, type) {},
-                    escapeHtml: function(text) { return String(text || '').replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;'); }
-                };
-            };
-        })();

web_interface/static/v3/js/htmx-config.js

@@ -1,256 +0,0 @@
-/* global debugLog */
-// HTMX swap/script-execution configuration and section toggle helpers
-// Extracted from templates/v3/base.html so browsers cache it as a static asset.
-        // Configure HTMX to evaluate scripts in swapped content and fix insertBefore errors
-        (function() {
-            function setupScriptExecution() {
-                if (document.body) {
-                    // Fix HTMX insertBefore errors by validating targets before swap
-                    document.body.addEventListener('htmx:beforeSwap', function(event) {
-                        try {
-                            const target = event.detail.target;
-                            if (!target) {
-                                console.warn('[HTMX] Target is null, skipping swap');
-                                event.detail.shouldSwap = false;
-                                return false;
-                            }
-                            
-                            // Check if target is a valid DOM element
-                            if (!(target instanceof Element)) {
-                                console.warn('[HTMX] Target is not a valid Element, skipping swap');
-                                event.detail.shouldSwap = false;
-                                return false;
-                            }
-                            
-                            // Check if target has a parent node (required for insertBefore)
-                            if (!target.parentNode) {
-                                console.warn('[HTMX] Target has no parent node, skipping swap');
-                                event.detail.shouldSwap = false;
-                                return false;
-                            }
-                            
-                            // Ensure target is in the DOM
-                            if (!document.body.contains(target) && !document.head.contains(target)) {
-                                console.warn('[HTMX] Target is not in DOM, skipping swap');
-                                event.detail.shouldSwap = false;
-                                return false;
-                            }
-                            
-                            // Additional check: ensure parent is also in DOM
-                            if (target.parentNode && !document.body.contains(target.parentNode) && !document.head.contains(target.parentNode)) {
-                                console.warn('[HTMX] Target parent is not in DOM, skipping swap');
-                                event.detail.shouldSwap = false;
-                                return false;
-                            }
-                            
-                            // All checks passed, allow swap
-                            return true;
-                        } catch (e) {
-                            // If validation fails, cancel swap
-                            console.warn('[HTMX] Error validating target:', e);
-                            event.detail.shouldSwap = false;
-                            return false;
-                        }
-                    });
-                    
-                    // Suppress HTMX insertBefore errors and other noisy errors - they're harmless but noisy
-                    const originalError = console.error;
-                    const originalWarn = console.warn;
-                    
-                    console.error = function(...args) {
-                        const errorStr = args.join(' ');
-                        const errorStack = args.find(arg => arg && typeof arg === 'string' && arg.includes('htmx')) || '';
-                        
-                        // Suppress HTMX insertBefore errors (comprehensive check)
-                        // These occur when HTMX tries to swap content but the target element is null
-                        // Usually happens due to timing/race conditions and is harmless
-                        if (errorStr.includes("insertBefore") || 
-                            errorStr.includes("Cannot read properties of null") ||
-                            errorStr.includes("reading 'insertBefore'")) {
-                            // Check if it's from HTMX by looking at stack trace or error string
-                            // Also check the call stack if available
-                            const isHtmxError = errorStr.includes('htmx') ||
-                                               errorStack.includes('htmx') ||
-                                               args.some(arg => {
-                                                   if (typeof arg === 'string') {
-                                                       return arg.includes('htmx');
-                                                   }
-                                                   // Check error objects for stack traces
-                                                   if (arg && typeof arg === 'object' && arg.stack) {
-                                                       return arg.stack.includes('htmx');
-                                                   }
-                                                   return false;
-                                               });
-                            
-                            if (isHtmxError) {
-                                return; // Suppress - this is a harmless HTMX timing/race condition issue
-                            }
-                        }
-                        
-                        // Suppress script execution errors from malformed HTML
-                        if (errorStr.includes("Failed to execute 'appendChild' on 'Node'") ||
-                            errorStr.includes("Failed to execute 'insertBefore' on 'Node'")) {
-                            if (errorStr.includes('Unexpected token')) {
-                                return; // Suppress malformed HTML errors
-                            }
-                        }
-                        originalError.apply(console, args);
-                    };
-                    
-                    console.warn = function(...args) {
-                        const warnStr = args.join(' ');
-                        // Suppress Permissions-Policy warnings (harmless browser warnings)
-                        if (warnStr.includes('Permissions-Policy header') ||
-                            warnStr.includes('Unrecognized feature') ||
-                            warnStr.includes('Origin trial controlled feature') ||
-                            warnStr.includes('browsing-topics') ||
-                            warnStr.includes('run-ad-auction') ||
-                            warnStr.includes('join-ad-interest-group') ||
-                            warnStr.includes('private-state-token') ||
-                            warnStr.includes('private-aggregation') ||
-                            warnStr.includes('attribution-reporting')) {
-                            return; // Suppress - these are harmless browser feature warnings
-                        }
-                        originalWarn.apply(console, args);
-                    };
-                    
-                    // Handle HTMX errors gracefully with detailed logging
-                    document.body.addEventListener('htmx:responseError', function(event) {
-                        const detail = event.detail;
-                        const xhr = detail.xhr;
-                        const target = detail.target;
-                        
-                        // Enhanced error logging
-                        console.error('HTMX response error:', {
-                            status: xhr?.status,
-                            statusText: xhr?.statusText,
-                            url: xhr?.responseURL,
-                            target: target?.id || target?.tagName,
-                            responseText: xhr?.responseText
-                        });
-                        
-                        // For form submissions, log field names only — values
-                        // may contain API keys, passwords, or other secrets
-                        // that must never reach the console.
-                        if (target && target.tagName === 'FORM') {
-                            const formData = new FormData(target);
-                            const fieldNames = [];
-                            for (const [key] of formData.entries()) {
-                                fieldNames.push(key);
-                            }
-                            console.error('Form fields (values redacted):', fieldNames);
-                            
-                            // Try to parse error response for validation details
-                            if (xhr?.responseText) {
-                                try {
-                                    const errorData = JSON.parse(xhr.responseText);
-                                    console.error('Error details:', {
-                                        message: errorData.message,
-                                        details: errorData.details,
-                                        validation_errors: errorData.validation_errors,
-                                        context: errorData.context
-                                    });
-                                } catch {
-                                    console.error('Error response (non-JSON):', xhr.responseText.substring(0, 500));
-                                }
-                            }
-                        }
-                    });
-                    
-                    document.body.addEventListener('htmx:swapError', function(event) {
-                        // Log but don't break the app
-                        console.warn('HTMX swap error:', event.detail);
-                    });
-
-                    // Execute <script> tags in swapped content ourselves, on
-                    // htmx:afterSwap (synchronous, right after the swap) rather
-                    // than relying on htmx's own script handling, which runs
-                    // during its later "settle" phase (~20ms after swap, per
-                    // htmx's defaultSettleDelay). Alpine's MutationObserver
-                    // processes newly-inserted x-data elements synchronously
-                    // as soon as the swap lands, which is BEFORE htmx's settle
-                    // phase - so any partial whose x-data component function
-                    // (e.g. wifiSetup()) is defined by an inline <script> in
-                    // that same partial would have that script still un-run
-                    // when Alpine evaluates x-data, permanently failing with
-                    // "wifiSetup is not defined" (Alpine does not retry).
-                    // Disable htmx's own native script re-execution so the
-                    // same script doesn't also run a second time via settle.
-                    if (typeof htmx !== 'undefined' && htmx.config) {
-                        htmx.config.allowScriptTags = false;
-                    }
-                    document.body.addEventListener('htmx:afterSwap', function(event) {
-                        const target = event.detail && event.detail.target;
-                        if (!target || !(target instanceof Element)) return;
-                        target.querySelectorAll('script').forEach(function(oldScript) {
-                            const newScript = document.createElement('script');
-                            for (const attr of oldScript.attributes) {
-                                newScript.setAttribute(attr.name, attr.value);
-                            }
-                            newScript.textContent = oldScript.textContent;
-                            oldScript.replaceWith(newScript);
-                        });
-                    });
-
-                    // Mark tab containers as loaded once their content settles, so switching
-                    // away and back doesn't re-fetch. Scoped to the "loadtab" trigger (tab
-                    // containers only) so modals and plugin config panels can still reload.
-                    document.body.addEventListener('htmx:afterSettle', function(event) {
-                        if (event.detail && event.detail.target) {
-                            const target = event.detail.target;
-                            const trigger = target.getAttribute('hx-trigger') || '';
-                            if (trigger.includes('loadtab')) {
-                                target.setAttribute('data-loaded', 'true');
-                            }
-                        }
-                    });
-                } else {
-                    if (document.readyState === 'loading') {
-                        document.addEventListener('DOMContentLoaded', setupScriptExecution);
-                    } else {
-                        setTimeout(setupScriptExecution, 100);
-                    }
-                }
-            }
-            setupScriptExecution();
-            
-            // Section toggle function - define early so it's available for HTMX-loaded content
-            window.toggleSection = function(sectionId) {
-                const section = document.getElementById(sectionId);
-                const icon = document.getElementById(sectionId + '-icon');
-                if (!section) {
-                    console.warn('toggleSection: Could not find section for', sectionId);
-                    return;
-                }
-                if (!icon) {
-                    console.warn('toggleSection: Could not find icon for', sectionId);
-                    return;
-                }
-                
-                // Check if currently hidden by checking both class and computed display
-                const hasHiddenClass = section.classList.contains('hidden');
-                const computedDisplay = window.getComputedStyle(section).display;
-                const isHidden = hasHiddenClass || computedDisplay === 'none';
-                
-                if (isHidden) {
-                    // Show the section - remove hidden class and explicitly set display to block
-                    section.classList.remove('hidden');
-                    section.style.display = 'block';
-                    icon.classList.remove('fa-chevron-right');
-                    icon.classList.add('fa-chevron-down');
-                } else {
-                    // Hide the section - add hidden class and set display to none
-                    section.classList.add('hidden');
-                    section.style.display = 'none';
-                    icon.classList.remove('fa-chevron-down');
-                    icon.classList.add('fa-chevron-right');
-                }
-
-                // Keep assistive tech in sync: any toggle button that declares
-                // aria-controls for this section mirrors the expanded state.
-                const controlBtn = document.querySelector(`[aria-controls="${sectionId}"]`);
-                if (controlBtn) {
-                    controlBtn.setAttribute('aria-expanded', String(isHidden));
-                }
-            };
-        })();

web_interface/static/v3/js/settings-search.js

@@ -173,14 +173,7 @@
 
     function setActiveTab(tab) {
         var data = getAppData();
-        if (data) {
-            data.activeTab = tab;
-            // Navigating from a search result should also dismiss the mobile
-            // nav drawer (harmless no-op on desktop, where the drawer CSS
-            // doesn't apply).
-            if ('mobileNavOpen' in data) data.mobileNavOpen = false;
-            return true;
-        }
+        if (data) { data.activeTab = tab; return true; }
         return false;
     }
 

web_interface/static/v3/js/widgets/custom-feeds.js

@@ -209,7 +209,6 @@
                 const removeButton = document.createElement('button');
                 removeButton.type = 'button';
                 removeButton.className = 'text-red-600 hover:text-red-800 px-2 py-1';
-                removeButton.setAttribute('aria-label', 'Remove feed');
                 removeButton.addEventListener('click', function() {
                     window.removeCustomFeedRow(this);
                 });
@@ -334,7 +333,6 @@
         const removeButton = document.createElement('button');
         removeButton.type = 'button';
         removeButton.className = 'text-red-600 hover:text-red-800 px-2 py-1';
-        removeButton.setAttribute('aria-label', 'Remove feed');
         removeButton.addEventListener('click', function() {
             window.removeCustomFeedRow(this);
         });
@@ -406,18 +404,9 @@
         if (!file) return;
         
         const formData = new FormData();
-        // Backend contract (see api_v3.upload_plugin_asset): the request
-        // field must be named "files" (it does request.files.getlist('files')
-        // and 400s with "No files provided" otherwise), and the response
-        // carries the result in a top-level "uploaded_files" key, not nested
-        // under "data". file-upload-single.js's working upload flow uses this
-        // same contract.
-        // Backend contract (api_v3.upload_plugin_asset): field must be named
-        // "files" (request.files.getlist('files')), and the response carries
-        // results in a top-level "uploaded_files" key, not nested under "data".
-        formData.append('files', file);
+        formData.append('file', file);
         formData.append('plugin_id', pluginId);
-
+        
         fetch('/api/v3/plugins/assets/upload', {
             method: 'POST',
             body: formData
@@ -432,8 +421,8 @@
             return response.json();
         })
         .then(data => {
-            if (data.status === 'success' && data.uploaded_files && data.uploaded_files.length > 0) {
-                const uploadedFile = data.uploaded_files[0];
+            if (data.status === 'success' && data.data && data.data.files && data.data.files.length > 0) {
+                const uploadedFile = data.data.files[0];
                 const row = document.querySelector(`#${fieldId}_tbody tr[data-index="${index}"]`);
                 if (row) {
                     const logoCell = row.querySelector('td:nth-child(3)');
@@ -506,6 +495,8 @@
                     // Append container to logoCell
                     logoCell.appendChild(container);
                 }
+                // Allow re-uploading the same file
+                event.target.value = '';
             } else {
                 const notifyFn = window.showNotification || alert;
                 notifyFn('Upload failed: ' + (data.message || 'Unknown error'), 'error');
@@ -515,12 +506,6 @@
             console.error('Upload error:', error);
             const notifyFn = window.showNotification || alert;
             notifyFn('Upload failed: ' + error.message, 'error');
-        })
-        .finally(() => {
-            // Reset regardless of outcome, so the same file can be re-selected
-            // to retry after a failure (browsers won't fire "change" again
-            // for an input that still holds that exact file).
-            event.target.value = '';
         });
     };
 

web_interface/static/v3/js/widgets/notification.js

@@ -58,10 +58,6 @@
 
     // Track active notifications
     let activeNotifications = [];
-    // onAction callbacks for notifications with an inline action button,
-    // keyed by notification id (cleaned up on dismiss). A Map rather than a
-    // plain object so ids can never collide with prototype properties.
-    const actionCallbacks = new Map();
     let notificationCounter = 0;
 
     /**
@@ -117,7 +113,6 @@
 
         // Remove from tracking array
         activeNotifications = activeNotifications.filter(id => id !== notificationId);
-        actionCallbacks.delete(notificationId);
     }
 
     /**
@@ -163,20 +158,6 @@
 
         html += `<span class="flex-1 text-sm">${escapeHtml(message)}</span>`;
 
-        // Optional inline action button (e.g. "Restart Now" on a restart nudge).
-        // The callback is stored by id and invoked via triggerAction, which
-        // also dismisses the notification.
-        if (options.actionLabel && typeof options.onAction === 'function') {
-            actionCallbacks.set(notificationId, options.onAction);
-            html += `
-                <button type="button"
-                        onclick="window.LEDMatrixWidgets.get('notification').triggerAction('${notificationId}')"
-                        class="flex-shrink-0 ml-2 px-3 py-1 text-xs font-semibold rounded-md bg-white bg-opacity-20 hover:bg-opacity-30 transition-colors duration-150">
-                    ${escapeHtml(options.actionLabel)}
-                </button>
-            `;
-        }
-
         if (dismissible) {
             html += `
                 <button type="button"
@@ -246,17 +227,6 @@
             removeNotification(notificationId);
         },
 
-        /**
-         * Invoke a notification's onAction callback (see options.actionLabel /
-         * options.onAction on show) and dismiss it.
-         * @param {string} notificationId - Notification ID whose action to run
-         */
-        triggerAction: function(notificationId) {
-            const cb = actionCallbacks.get(notificationId);
-            removeNotification(notificationId);
-            if (typeof cb === 'function') cb();
-        },
-
         /**
          * Clear all notifications
          */
@@ -292,11 +262,9 @@
         }
     });
 
-    // Global shorthand function (backwards compatible with existing code).
-    // Accepts either the legacy type string or a full options object
-    // ({ type, duration, actionLabel, onAction, ... }).
+    // Global shorthand function (backwards compatible with existing code)
     window.showNotification = function(message, type = 'info') {
-        return showNotification(message, typeof type === 'string' ? { type: type } : (type || {}));
+        return showNotification(message, { type: type });
     };
 
     // Initialize container on load

web_interface/static/v3/js/widgets/plugin-order-list.js

@@ -1,225 +0,0 @@
-/**
- * Plugin Order List — shared drag-and-drop reorder list of enabled plugins.
- *
- * Factored out of the Vegas Scroll section of display.html so both Vegas mode
- * and the primary rotation (Durations tab) use one implementation. Renders
- * one draggable row per enabled plugin into a container and keeps a hidden
- * input's value in sync as a JSON array of plugin ids in display order.
- *
- * Usage:
- *   PluginOrderList.init({
- *       containerId: 'vegas_plugin_order',        // rows render here
- *       orderInputId: 'vegas_plugin_order_value', // hidden input, JSON array of ids
- *       excludedInputId: 'vegas_excluded_plugins_value', // optional: adds an
- *           // include-checkbox per row; unchecked ids collect here (JSON array)
- *       showVegasModeBadge: true                  // optional: Scroll/Fixed/Static badge
- *   });
- *
- * The container re-renders from /api/v3/plugins/installed each init; the
- * hidden input(s) must already hold the saved order/exclusions (JSON).
- */
-(function() {
-    'use strict';
-
-    const MODE_LABELS = new Map([
-        ['scroll', { label: 'Scroll', icon: 'fa-scroll', color: 'text-blue-600' }],
-        ['fixed',  { label: 'Fixed',  icon: 'fa-square', color: 'text-green-600' }],
-        ['static', { label: 'Static', icon: 'fa-pause',  color: 'text-orange-600' }]
-    ]);
-
-    function init(options) {
-        const container = document.getElementById(options.containerId);
-        const orderInput = document.getElementById(options.orderInputId);
-        const excludedInput = options.excludedInputId ? document.getElementById(options.excludedInputId) : null;
-        if (!container || !orderInput) return;
-
-        function syncInputs() {
-            const order = [];
-            const excluded = [];
-            container.querySelectorAll('.plugin-order-item').forEach(item => {
-                const pluginId = item.dataset.pluginId;
-                order.push(pluginId);
-                const checkbox = item.querySelector('.plugin-order-include');
-                if (checkbox && !checkbox.checked) excluded.push(pluginId);
-            });
-            orderInput.value = JSON.stringify(order);
-            if (excludedInput) excludedInput.value = JSON.stringify(excluded);
-        }
-
-        function setupDragAndDrop() {
-            let draggedItem = null;
-            container.querySelectorAll('.plugin-order-item').forEach(item => {
-                item.addEventListener('dragstart', function(e) {
-                    draggedItem = this;
-                    this.style.opacity = '0.5';
-                    e.dataTransfer.effectAllowed = 'move';
-                });
-                item.addEventListener('dragend', function() {
-                    this.style.opacity = '1';
-                    draggedItem = null;
-                    syncInputs();
-                });
-                item.addEventListener('dragover', function(e) {
-                    e.preventDefault();
-                    e.dataTransfer.dropEffect = 'move';
-                    const rect = this.getBoundingClientRect();
-                    const midY = rect.top + rect.height / 2;
-                    if (e.clientY < midY) {
-                        this.style.borderTop = '2px solid #3b82f6';
-                        this.style.borderBottom = '';
-                    } else {
-                        this.style.borderBottom = '2px solid #3b82f6';
-                        this.style.borderTop = '';
-                    }
-                });
-                item.addEventListener('dragleave', function() {
-                    this.style.borderTop = '';
-                    this.style.borderBottom = '';
-                });
-                item.addEventListener('drop', function(e) {
-                    e.preventDefault();
-                    this.style.borderTop = '';
-                    this.style.borderBottom = '';
-                    if (draggedItem && draggedItem !== this) {
-                        const rect = this.getBoundingClientRect();
-                        const midY = rect.top + rect.height / 2;
-                        if (e.clientY < midY) {
-                            container.insertBefore(draggedItem, this);
-                        } else {
-                            container.insertBefore(draggedItem, this.nextSibling);
-                        }
-                    }
-                });
-            });
-        }
-
-        fetch('/api/v3/plugins/installed')
-            .then(response => response.json())
-            .then(data => {
-                const allPlugins = (data.data && data.data.plugins) || data.plugins || [];
-                const plugins = allPlugins.filter(p => p.enabled);
-                if (plugins.length === 0) {
-                    const empty = document.createElement('p');
-                    empty.className = 'text-sm text-gray-500 italic';
-                    empty.textContent = 'No enabled plugins';
-                    container.textContent = '';
-                    container.appendChild(empty);
-                    return;
-                }
-
-                let currentOrder = [];
-                let excluded = [];
-                try {
-                    currentOrder = JSON.parse(orderInput.value || '[]');
-                    if (excludedInput) excluded = JSON.parse(excludedInput.value || '[]');
-                } catch (e) {
-                    console.error('Error parsing saved plugin order:', e);
-                }
-                // JSON.parse can succeed and still return null/objects
-                // (e.g. a saved value of "null"); normalize to arrays.
-                if (!Array.isArray(currentOrder)) currentOrder = [];
-                if (!Array.isArray(excluded)) excluded = [];
-
-                // Saved order first, then any newly enabled plugins.
-                const orderedPlugins = [];
-                currentOrder.forEach(id => {
-                    const plugin = plugins.find(p => p.id === id);
-                    if (plugin) orderedPlugins.push(plugin);
-                });
-                plugins.forEach(plugin => {
-                    if (!orderedPlugins.find(p => p.id === plugin.id)) orderedPlugins.push(plugin);
-                });
-
-                // Rows are built with DOM APIs rather than innerHTML — plugin
-                // ids/names come from installed manifests (semi-trusted).
-                container.textContent = '';
-                orderedPlugins.forEach(plugin => {
-                    const row = document.createElement('div');
-                    row.className = 'flex items-center p-2 bg-gray-50 rounded border border-gray-200 cursor-move plugin-order-item';
-                    row.dataset.pluginId = plugin.id;
-                    row.draggable = true;
-
-                    const grip = document.createElement('i');
-                    grip.className = 'fas fa-grip-vertical text-gray-400 mr-3';
-                    row.appendChild(grip);
-
-                    if (excludedInput) {
-                        const isExcluded = excluded.includes(plugin.id);
-                        const label = document.createElement('label');
-                        label.className = 'flex items-center flex-1';
-                        const checkbox = document.createElement('input');
-                        checkbox.type = 'checkbox';
-                        checkbox.className = 'plugin-order-include h-4 w-4 text-blue-600 focus:ring-blue-500 border-gray-300 rounded mr-2';
-                        checkbox.checked = !isExcluded;
-                        const name = document.createElement('span');
-                        name.className = 'text-sm font-medium text-gray-700';
-                        name.textContent = plugin.name || plugin.id;
-                        label.appendChild(checkbox);
-                        label.appendChild(name);
-                        row.appendChild(label);
-                    } else {
-                        const name = document.createElement('span');
-                        name.className = 'text-sm font-medium text-gray-700 flex-1';
-                        name.textContent = plugin.name || plugin.id;
-                        row.appendChild(name);
-                    }
-
-                    if (options.showVegasModeBadge) {
-                        const vegasMode = plugin.vegas_mode || plugin.vegas_content_type || 'fixed';
-                        const modeInfo = MODE_LABELS.get(vegasMode) || MODE_LABELS.get('fixed');
-                        const badge = document.createElement('span');
-                        badge.className = `text-xs ${modeInfo.color} ml-2`;
-                        badge.title = `Vegas display mode: ${modeInfo.label}`;
-                        const badgeIcon = document.createElement('i');
-                        badgeIcon.className = `fas ${modeInfo.icon} mr-1`;
-                        badge.appendChild(badgeIcon);
-                        badge.appendChild(document.createTextNode(modeInfo.label));
-                        row.appendChild(badge);
-                    }
-
-                    // Up/down buttons: touch- and keyboard-accessible
-                    // reordering alongside native drag-and-drop (HTML5 drag
-                    // events don't fire on most mobile browsers).
-                    const pluginLabel = plugin.name || plugin.id;
-                    [['up', 'fa-chevron-up', `Move ${pluginLabel} up`],
-                     ['down', 'fa-chevron-down', `Move ${pluginLabel} down`]].forEach(([dir, iconCls, ariaLabel]) => {
-                        const moveBtn = document.createElement('button');
-                        moveBtn.type = 'button';
-                        moveBtn.className = 'plugin-order-move text-gray-400 hover:text-gray-700 px-2 py-1';
-                        moveBtn.setAttribute('aria-label', ariaLabel);
-                        const moveIcon = document.createElement('i');
-                        moveIcon.className = `fas ${iconCls} text-xs`;
-                        moveBtn.appendChild(moveIcon);
-                        moveBtn.addEventListener('click', function() {
-                            if (dir === 'up' && row.previousElementSibling) {
-                                container.insertBefore(row, row.previousElementSibling);
-                            } else if (dir === 'down' && row.nextElementSibling) {
-                                container.insertBefore(row.nextElementSibling, row);
-                            }
-                            syncInputs();
-                            moveBtn.focus();
-                        });
-                        row.appendChild(moveBtn);
-                    });
-
-                    container.appendChild(row);
-                });
-
-                setupDragAndDrop();
-                container.querySelectorAll('.plugin-order-include').forEach(checkbox => {
-                    checkbox.addEventListener('change', syncInputs);
-                });
-                syncInputs();
-            })
-            .catch(error => {
-                console.error('Error fetching plugins:', error);
-                const err = document.createElement('p');
-                err.className = 'text-sm text-red-500';
-                err.textContent = 'Error loading plugins';
-                container.textContent = '';
-                container.appendChild(err);
-            });
-    }
-
-    window.PluginOrderList = { init: init };
-})();

web_interface/static/v3/manifest.json

@@ -1,24 +0,0 @@
-{
-    "name": "LED Matrix Control",
-    "short_name": "LEDMatrix",
-    "description": "Control panel for the LEDMatrix display",
-    "start_url": "/",
-    "scope": "/",
-    "display": "standalone",
-    "background_color": "#111827",
-    "theme_color": "#111827",
-    "icons": [
-        {
-            "src": "/static/v3/icons/icon-192.png",
-            "sizes": "192x192",
-            "type": "image/png",
-            "purpose": "any maskable"
-        },
-        {
-            "src": "/static/v3/icons/icon-512.png",
-            "sizes": "512x512",
-            "type": "image/png",
-            "purpose": "any maskable"
-        }
-    ]
-}

web_interface/static/v3/vendor/codemirror/addon/edit/closebrackets.min.js

@@ -1 +0,0 @@
-!function(e){"object"==typeof exports&&"object"==typeof module?e(require("../../lib/codemirror")):"function"==typeof define&&define.amd?define(["../../lib/codemirror"],e):e(CodeMirror)}(function(P){var t={pairs:"()[]{}''\"\"",closeBefore:")]}'\":;>",triples:"",explode:"[]{}"},S=P.Pos;function k(e,n){return"pairs"==n&&"string"==typeof e?e:("object"==typeof e&&null!=e[n]?e:t)[n]}P.defineOption("autoCloseBrackets",!1,function(e,n,t){t&&t!=P.Init&&(e.removeKeyMap(i),e.state.closeBrackets=null),n&&(r(k(n,"pairs")),e.state.closeBrackets=n,e.addKeyMap(i))});var i={Backspace:function(e){var n=y(e);if(!n||e.getOption("disableInput"))return P.Pass;for(var t=k(n,"pairs"),r=e.listSelections(),i=0;i<r.length;i++){if(!r[i].empty())return P.Pass;var a=s(e,r[i].head);if(!a||t.indexOf(a)%2!=0)return P.Pass}for(i=r.length-1;0<=i;i--){var o=r[i].head;e.replaceRange("",S(o.line,o.ch-1),S(o.line,o.ch+1),"+delete")}},Enter:function(r){var e=y(r),n=e&&k(e,"explode");if(!n||r.getOption("disableInput"))return P.Pass;for(var i=r.listSelections(),t=0;t<i.length;t++){if(!i[t].empty())return P.Pass;var a=s(r,i[t].head);if(!a||n.indexOf(a)%2!=0)return P.Pass}r.operation(function(){var e=r.lineSeparator()||"\n";r.replaceSelection(e+e,null),O(r,-1),i=r.listSelections();for(var n=0;n<i.length;n++){var t=i[n].head.line;r.indentLine(t,null,!0),r.indentLine(t+1,null,!0)}})}};function r(e){for(var n=0;n<e.length;n++){var t=e.charAt(n),r="'"+t+"'";i[r]||(i[r]=function(n){return function(e){return function(i,e){var n=y(i);if(!n||i.getOption("disableInput"))return P.Pass;var t=k(n,"pairs"),r=t.indexOf(e);if(-1==r)return P.Pass;for(var a,o=k(n,"closeBefore"),s=k(n,"triples"),l=t.charAt(r+1)==e,c=i.listSelections(),f=r%2==0,h=0;h<c.length;h++){var u,d=c[h],p=d.head,g=i.getRange(p,S(p.line,p.ch+1));if(f&&!d.empty())u="surround";else if(!l&&f||g!=e)if(l&&1<p.ch&&0<=s.indexOf(e)&&i.getRange(S(p.line,p.ch-2),p)==e+e){if(2<p.ch&&/\bstring/.test(i.getTokenTypeAt(S(p.line,p.ch-2))))return P.Pass;u="addFour"}else if(l){d=0==p.ch?" ":i.getRange(S(p.line,p.ch-1),p);if(P.isWordChar(g)||d==e||P.isWordChar(d))return P.Pass;u="both"}else{if(!f||!(0===g.length||/\s/.test(g)||-1<o.indexOf(g)))return P.Pass;u="both"}else u=l&&function(e,n){var t=e.getTokenAt(S(n.line,n.ch+1));return/\bstring/.test(t.type)&&t.start==n.ch&&(0==n.ch||!/\bstring/.test(e.getTokenTypeAt(n)))}(i,p)?"both":0<=s.indexOf(e)&&i.getRange(p,S(p.line,p.ch+3))==e+e+e?"skipThree":"skip";if(a){if(a!=u)return P.Pass}else a=u}var v=r%2?t.charAt(r-1):e,b=r%2?e:t.charAt(r+1);i.operation(function(){if("skip"==a)O(i,1);else if("skipThree"==a)O(i,3);else if("surround"==a){for(var e=i.getSelections(),n=0;n<e.length;n++)e[n]=v+e[n]+b;i.replaceSelections(e,"around");for(e=i.listSelections().slice(),n=0;n<e.length;n++)e[n]=(t=e[n],r=void 0,r=0<P.cmpPos(t.anchor,t.head),{anchor:new S(t.anchor.line,t.anchor.ch+(r?-1:1)),head:new S(t.head.line,t.head.ch+(r?1:-1))});i.setSelections(e)}else"both"==a?(i.replaceSelection(v+b,null),i.triggerElectric(v+b),O(i,-1)):"addFour"==a&&(i.replaceSelection(v+v+v+v,"before"),O(i,1));var t,r})}(e,n)}}(t))}}function y(e){var n=e.state.closeBrackets;return n&&!n.override&&e.getModeAt(e.getCursor()).closeBrackets||n}function O(e,n){for(var t=[],r=e.listSelections(),i=0,a=0;a<r.length;a++){var o=r[a];o.head==e.getCursor()&&(i=a);o=o.head.ch||0<n?{line:o.head.line,ch:o.head.ch+n}:{line:o.head.line-1};t.push({anchor:o,head:o})}e.setSelections(t,i)}function s(e,n){n=e.getRange(S(n.line,n.ch-1),S(n.line,n.ch+1));return 2==n.length?n:null}r(t.pairs+"`")});

web_interface/static/v3/vendor/codemirror/addon/edit/matchbrackets.min.js

@@ -1 +0,0 @@
-!function(t){"object"==typeof exports&&"object"==typeof module?t(require("../../lib/codemirror")):"function"==typeof define&&define.amd?define(["../../lib/codemirror"],t):t(CodeMirror)}(function(r){var u=/MSIE \d/.test(navigator.userAgent)&&(null==document.documentMode||document.documentMode<8),k=r.Pos,p={"(":")>",")":"(<","[":"]>","]":"[<","{":"}>","}":"{<","<":">>",">":"<<"};function y(t){return t&&t.bracketRegex||/[(){}[\]]/}function f(t,e,n){var r=t.getLineHandle(e.line),i=e.ch-1,c=n&&n.afterCursor;null==c&&(c=/(^| )cm-fat-cursor($| )/.test(t.getWrapperElement().className));var a=y(n),c=!c&&0<=i&&a.test(r.text.charAt(i))&&p[r.text.charAt(i)]||a.test(r.text.charAt(i+1))&&p[r.text.charAt(++i)];if(!c)return null;a=">"==c.charAt(1)?1:-1;if(n&&n.strict&&0<a!=(i==e.ch))return null;r=t.getTokenTypeAt(k(e.line,i+1)),n=o(t,k(e.line,i+(0<a?1:0)),a,r,n);return null==n?null:{from:k(e.line,i),to:n&&n.pos,match:n&&n.ch==c.charAt(0),forward:0<a}}function o(t,e,n,r,i){for(var c=i&&i.maxScanLineLength||1e4,a=i&&i.maxScanLines||1e3,o=[],h=y(i),l=0<n?Math.min(e.line+a,t.lastLine()+1):Math.max(t.firstLine()-1,e.line-a),s=e.line;s!=l;s+=n){var u=t.getLine(s);if(u){var f=0<n?0:u.length-1,m=0<n?u.length:-1;if(!(u.length>c))for(s==e.line&&(f=e.ch-(n<0?1:0));f!=m;f+=n){var g=u.charAt(f);if(h.test(g)&&(void 0===r||(t.getTokenTypeAt(k(s,f+1))||"")==(r||""))){var d=p[g];if(d&&">"==d.charAt(1)==0<n)o.push(g);else{if(!o.length)return{pos:k(s,f),ch:g};o.pop()}}}}}return s-n!=(0<n?t.lastLine():t.firstLine())&&null}function e(t,e,n){for(var r=t.state.matchBrackets.maxHighlightLineLength||1e3,i=n&&n.highlightNonMatching,c=[],a=t.listSelections(),o=0;o<a.length;o++){var h,l=a[o].empty()&&f(t,a[o].head,n);l&&(l.match||!1!==i)&&t.getLine(l.from.line).length<=r&&(h=l.match?"CodeMirror-matchingbracket":"CodeMirror-nonmatchingbracket",c.push(t.markText(l.from,k(l.from.line,l.from.ch+1),{className:h})),l.to&&t.getLine(l.to.line).length<=r&&c.push(t.markText(l.to,k(l.to.line,l.to.ch+1),{className:h})))}if(c.length){u&&t.state.focused&&t.focus();function s(){t.operation(function(){for(var t=0;t<c.length;t++)c[t].clear()})}if(!e)return s;setTimeout(s,800)}}function i(t){t.operation(function(){t.state.matchBrackets.currentlyHighlighted&&(t.state.matchBrackets.currentlyHighlighted(),t.state.matchBrackets.currentlyHighlighted=null),t.state.matchBrackets.currentlyHighlighted=e(t,!1,t.state.matchBrackets)})}function c(t){t.state.matchBrackets&&t.state.matchBrackets.currentlyHighlighted&&(t.state.matchBrackets.currentlyHighlighted(),t.state.matchBrackets.currentlyHighlighted=null)}r.defineOption("matchBrackets",!1,function(t,e,n){n&&n!=r.Init&&(t.off("cursorActivity",i),t.off("focus",i),t.off("blur",c),c(t)),e&&(t.state.matchBrackets="object"==typeof e?e:{},t.on("cursorActivity",i),t.on("focus",i),t.on("blur",c))}),r.defineExtension("matchBrackets",function(){e(this,!0)}),r.defineExtension("findMatchingBracket",function(t,e,n){return f(this,t,e=n||"boolean"==typeof e?n?(n.strict=e,n):e?{strict:!0}:null:e)}),r.defineExtension("scanForBracket",function(t,e,n,r){return o(this,t,e,n,r)})});