test(web): assert 400 exactly, and prove valid input is accepted

Both review points were right, and the first is the failure mode this file
exists to catch.

Accepting any 4xx meant a 404 would have passed. Renaming one of these routes
would have left the test green while it tested nothing -- the same "looks like
coverage, points somewhere safe" shape that hid the composer injections. Now
asserts exactly 400.

Both infinity signs are exercised for every route. int() raises OverflowError
either way, but only +Infinity was in the original report, and a guard that
special-cased the sign would have passed a one-sided test.

The valid-input test previously asserted "not a 400", which did not show what
it claimed: the mocked save path fails for any input, so that assertion held
whether or not validation had accepted the value. It now gives load_config a
real dict and stubs _save_config_atomic, so the endpoint reaches its success
response and the test can assert 200 -- which only happens if the value passed
validation.

8 of the 11 checks fail with OverflowError removed from the except tuples.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01STMbQE4YctTacQXfbYqKuW

src/display_controller.py

@@ -181,16 +181,6 @@ class DisplayController:
         self.plugin_modes = {}  # mode -> plugin_instance mapping for plugin-first dispatch
         self.mode_to_plugin_id: Dict[str, str] = {}
         self.plugin_display_modes: Dict[str, List[str]] = {}
-        # plugin_display_modes is mutated only by _register_loaded_plugin /
-        # _unregister_plugin on the render thread, but the config-watcher
-        # thread reads it in _enabled_plugin_not_running. Both mutation sites
-        # run during reconcile (rare), so this lock never touches the per-frame
-        # path -- the hot-path reads are same-thread as the writes.
-        self._plugin_modes_lock = threading.Lock()
-        # Guards the consume-and-clear of _pending_plugin_reconcile. Only taken
-        # when a reconcile is actually pending or a config change arrives, both
-        # rare -- the per-frame path just reads the bool.
-        self._reconcile_flag_lock = threading.Lock()
         # Per-plugin config-change callbacks, kept so we can unsubscribe a
         # plugin when it is disabled live.
         self._plugin_config_callbacks: Dict[str, Callable] = {}
@@ -473,10 +463,8 @@ class DisplayController:
             self._refresh_config_cache(new_config)
             # If a plugin was enabled/disabled, flag a reconcile for the main
             # loop to apply (loading/unloading off the watcher thread is unsafe).
-            if (self._enabled_set_changed(old_config, new_config)
-                    or self._enabled_plugin_not_running(new_config)):
-                with self._reconcile_flag_lock:
-                    self._pending_plugin_reconcile = True
+            if self._enabled_set_changed(old_config, new_config):
+                self._pending_plugin_reconcile = True
 
         self.config_service.subscribe(_controller_config_change)
 
@@ -1761,12 +1749,11 @@ class DisplayController:
                 # rebuilding available_modes happens here on the render thread so
                 # it can't race with rendering. Deferred while on-demand is active
                 # (the flag stays set) so we don't fight its temporary-enable.
-                # The lock-free read is a fast path only; it can be a false
-                # negative (the watcher setting the flag just after it is read
-                # is seen next iteration), never a false positive that loses a
-                # request.
                 if self._pending_plugin_reconcile and not self.on_demand_active:
-                    self._service_pending_reconcile()
+                    # Only clear the flag on success -- a retryable failure
+                    # (e.g. discovery) leaves it set so the request isn't lost.
+                    if self._reconcile_enabled_plugins():
+                        self._pending_plugin_reconcile = False
 
                 if not self.available_modes:
                     # Nothing to render yet. Re-check _pending_plugin_reconcile
@@ -2826,8 +2813,7 @@ class DisplayController:
             logger.debug("Using manifest display_modes for %s: %s", plugin_id, display_modes)
         if not (isinstance(display_modes, list) and display_modes):
             display_modes = [plugin_id]
-        with self._plugin_modes_lock:
-            self.plugin_display_modes[plugin_id] = list(display_modes)
+        self.plugin_display_modes[plugin_id] = list(display_modes)
 
         # Subscribe to config changes for per-plugin hot-reload. Bind plugin_id
         # and instance as defaults so each plugin's callback targets its own
@@ -2861,8 +2847,7 @@ class DisplayController:
     def _unregister_plugin(self, plugin_id: str) -> None:
         """Remove a plugin's modes, config subscription and instance, then
         unload it. Used by live disable hot-reload."""
-        with self._plugin_modes_lock:
-            modes = self.plugin_display_modes.pop(plugin_id, [])
+        modes = self.plugin_display_modes.pop(plugin_id, [])
         for mode in modes:
             if mode in self.available_modes:
                 self.available_modes.remove(mode)
@@ -2907,67 +2892,6 @@ class DisplayController:
             }
         return enabled_map(old_config) != enabled_map(new_config)
 
-    def _service_pending_reconcile(self) -> None:
-        """Consume a pending reconcile request and run it.
-
-        The request is consumed BEFORE reconciling, not cleared after. Clearing
-        after would drop any config change that lands while reconcile is
-        running: reconcile has already read its config by then, so the clear
-        erases a request it never served and the newest config never
-        reconciles -- the same "your save did nothing" failure this whole path
-        exists to prevent. Consuming first means such a request stays set and
-        is picked up on the next pass.
-
-        A retryable failure (e.g. discovery) re-arms the flag.
-        """
-        with self._reconcile_flag_lock:
-            pending = self._pending_plugin_reconcile
-            self._pending_plugin_reconcile = False
-        if pending and not self._reconcile_enabled_plugins():
-            with self._reconcile_flag_lock:
-                self._pending_plugin_reconcile = True
-
-    def _enabled_plugin_not_running(self, new_config: Dict[str, Any]) -> bool:
-        """True when a discovered plugin is enabled in config but not running.
-
-        ``_enabled_set_changed`` compares only top-level ``enabled`` flags, which
-        misses the case that strands a plugin: one whose ``validate_config()``
-        returned False is absent from the running set, and the edit that fixes it
-        (enabling a league, filling in an API key) lives *nested* inside that
-        plugin's own section. No top-level flag changes, so no reconcile is
-        queued, and the save that should have fixed it appears to do nothing --
-        only toggling some unrelated plugin recovers it. hockey-scoreboard sat
-        enabled-but-absent on a live rig for four days this way.
-
-        Deliberately narrow: it fires only for ids the plugin manager has
-        actually discovered, so non-plugin sections that carry their own
-        ``enabled`` flag (``schedule``, ``display``, ...) don't queue a reconcile
-        on every save. In the steady state -- everything enabled is loaded --
-        this is False and costs nothing. That matters because reconcile runs
-        ``discover_plugins()`` on the render thread, where a needless
-        filesystem scan per config save would show up as a frame hitch.
-
-        Runs on the config-watcher thread, so both mappings it reads are
-        snapshotted under the lock that guards their writes.
-        """
-        if self.plugin_manager is None:
-            return False
-        # Two snapshots, each taken under its own lock and never nested, so a
-        # half-written mapping is never observed and this can't deadlock
-        # against discovery (which holds the discovery lock while rebuilding).
-        try:
-            known = self.plugin_manager.discovered_plugin_ids()
-        except AttributeError:
-            # Older manager without the accessor: fall back to a plain read.
-            known = set(getattr(self.plugin_manager, 'plugin_manifests', ()) or ())
-        with self._plugin_modes_lock:
-            running = set(self.plugin_display_modes)
-        for key, value in new_config.items():
-            if (key in known and isinstance(value, dict)
-                    and value.get('enabled', False) and key not in running):
-                return True
-        return False
-
     def _reconcile_enabled_plugins(self) -> bool:
         """Load/unload plugins so the running set matches the enabled set in
         config. Runs on the main display thread (never the config-watcher

src/plugin_system/plugin_manager.py

@@ -631,17 +631,6 @@ class PluginManager:
         
         return self.load_plugin(plugin_id)
     
-    def discovered_plugin_ids(self) -> set:
-        """Snapshot of the discovered plugin ids, taken under the discovery lock.
-
-        Callers on other threads (the config watcher) must not iterate
-        ``plugin_manifests`` directly: discovery rebuilds it entry by entry, so
-        an unsynchronised reader can see a half-populated mapping or raise
-        "dictionary changed size during iteration".
-        """
-        with self._discovery_lock:
-            return set(self.plugin_manifests)
-
     def get_plugin(self, plugin_id: str) -> Optional[Any]:
         """
         Get a loaded plugin instance by ID.

test/test_api_v3_non_finite_numbers.py

@@ -0,0 +1,85 @@
+"""Non-finite JSON numbers must be rejected, not raise.
+
+json.loads accepts Infinity/-Infinity/NaN by default (they are not valid JSON,
+but Python's parser emits them) and Flask's get_json passes them straight
+through. int(float('inf')) raises OverflowError, which is neither ValueError
+nor TypeError -- so validation blocks that carefully caught those let it
+through and Flask turned it into a 500.
+
+The damage was not the status code. /config/dim-schedule answered with
+CONFIG_SAVE_FAILED and suggested "Check file permissions on config directory"
+and "Check available disk space" for what was actually an invalid number.
+
+NaN already returned 400 (int(nan) raises ValueError), which is why this only
+showed up for the infinities.
+"""
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from test._api_v3_test_helpers import api_v3_client, api_v3_module  # noqa: F401,E402
+
+
+#: (route, field) that returned 500 before OverflowError was caught. Both
+#: infinity signs are exercised: int() raises OverflowError for either, but
+#: only one of them was in the original report, and a guard that special-cased
+#: the sign would pass a one-sided test.
+NON_FINITE_ROUTES = [
+    ('/api/v3/config/dim-schedule', 'dim_brightness'),
+    ('/api/v3/errors/clear', 'max_age_hours'),
+    ('/api/v3/config/main', 'multiplexing'),
+    ('/api/v3/config/main', 'row_address_type'),
+]
+NON_FINITE_CASES = [
+    (route, '{"%s": %s}' % (field, literal))
+    for route, field in NON_FINITE_ROUTES
+    for literal in ('Infinity', '-Infinity')
+]
+
+
+@pytest.mark.parametrize("route,body", NON_FINITE_CASES)
+def test_infinity_is_a_client_error_not_a_server_error(api_v3_client, route, body):
+    """Exactly 400, not merely "some 4xx".
+
+    Accepting any 4xx would let a 404 pass, so renaming one of these routes
+    would leave the test green while testing nothing -- the failure mode this
+    whole file exists to catch.
+    """
+    response = api_v3_client.post(route, data=body, content_type='application/json')
+    assert response.status_code == 400, (
+        f"{route} with {body} answered {response.status_code}; expected 400"
+    )
+
+
+@pytest.mark.parametrize("route,body", [
+    ('/api/v3/config/dim-schedule', '{"dim_brightness": NaN}'),
+    ('/api/v3/errors/clear', '{"max_age_hours": NaN}'),
+])
+def test_nan_is_also_a_client_error(api_v3_client, route, body):
+    """int(nan) raises ValueError so this path already worked -- pinned so a
+    refactor that narrows the except tuple cannot quietly break it."""
+    response = api_v3_client.post(route, data=body, content_type='application/json')
+    assert response.status_code == 400
+
+
+def test_a_valid_number_is_accepted(api_v3_client, api_v3_module, monkeypatch):
+    """Prove the widened except did not start swallowing ordinary input.
+
+    Asserting "not a 400" would not show that: the mocked save path fails for
+    any input, so the assertion would hold even if validation had rejected the
+    value. Give load_config a real dict and stub the atomic save, and the
+    endpoint reaches its success response -- which only happens if 30 passed
+    validation.
+    """
+    api_v3_module.api_v3.config_manager.load_config.return_value = {}
+    monkeypatch.setattr(api_v3_module, '_save_config_atomic',
+                        lambda *a, **k: (True, ''))
+    response = api_v3_client.post(
+        '/api/v3/config/dim-schedule',
+        data='{"dim_brightness": 30}',
+        content_type='application/json',
+    )
+    assert response.status_code == 200, response.get_data(as_text=True)[:200]

test/test_display_controller_plugin_toggle.py

@@ -6,7 +6,6 @@ These tests cover the reconcile path that loads/unloads plugins and rebuilds
 the dispatch maps on the main thread when the enabled set changes.
 """
 
-import copy
 from unittest.mock import MagicMock
 
 
@@ -254,182 +253,3 @@ class TestEnabledSetChanged:
             {"a": {"enabled": True, "duration": 30}},
             {"a": {"enabled": True, "duration": 45}},
         ) is False
-
-
-class TestEnabledPluginNotRunning:
-    """A plugin that fails validate_config() is enabled but absent, and the
-    config edit that fixes it is nested inside the plugin's own section -- so
-    the top-level ``enabled`` comparison never sees it. These cover the second
-    gate that queues a reconcile in that case.
-    """
-
-    def test_nested_edit_is_invisible_to_the_enabled_set_check(self, test_display_controller):
-        """The original gate: proves why a second one is needed."""
-        controller = test_display_controller
-        old = {"hockey-scoreboard": {"enabled": True, "nhl": {"enabled": False}}}
-        new = {"hockey-scoreboard": {"enabled": True, "nhl": {"enabled": True}}}
-        # Enabling a league changes no top-level flag.
-        assert controller._enabled_set_changed(old, new) is False
-
-    def test_queues_reconcile_when_enabled_plugin_is_absent(self, test_display_controller):
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {}  # failed to load
-        cfg = {"hockey-scoreboard": {"enabled": True, "nhl": {"enabled": True}}}
-        assert controller._enabled_plugin_not_running(cfg) is True
-
-    def test_quiet_when_every_enabled_plugin_is_running(self, test_display_controller):
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {"hockey-scoreboard": ["nhl"]}
-        cfg = {"hockey-scoreboard": {"enabled": True}}
-        assert controller._enabled_plugin_not_running(cfg) is False
-
-    def test_disabled_plugin_does_not_queue(self, test_display_controller):
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {}
-        cfg = {"hockey-scoreboard": {"enabled": False}}
-        assert controller._enabled_plugin_not_running(cfg) is False
-
-    def test_non_plugin_sections_do_not_queue(self, test_display_controller):
-        """``schedule``/``display`` carry their own ``enabled`` and are never
-        in plugin_display_modes -- without the manifest check they would queue
-        a reconcile, and therefore a filesystem scan, on every config save."""
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {"hockey-scoreboard": ["nhl"]}
-        cfg = {
-            "hockey-scoreboard": {"enabled": True},
-            "schedule": {"enabled": True},
-            "display": {"enabled": True},
-        }
-        assert controller._enabled_plugin_not_running(cfg) is False
-
-    def test_non_dict_section_is_ignored(self, test_display_controller):
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {}
-        assert controller._enabled_plugin_not_running({"hockey-scoreboard": "nonsense"}) is False
-
-    def test_no_plugin_manager_is_quiet(self, test_display_controller):
-        controller = test_display_controller
-        controller.plugin_manager = None
-        assert controller._enabled_plugin_not_running({"x": {"enabled": True}}) is False
-
-
-class TestReconcileQueuedThroughSubscriber:
-    """End-to-end through the real config-change subscriber, not the helper.
-
-    Without the second gate this is the four-day-outage path: the plugin is
-    enabled, absent, and the save that enables its league sets no flag.
-    """
-
-    @staticmethod
-    def _subscriber(controller):
-        subs = controller.config_service._subscribers['*']
-        for cb in subs:
-            if getattr(cb, '__name__', '') == '_controller_config_change':
-                return cb
-        raise AssertionError(f"controller subscriber not found among {subs}")
-
-    @staticmethod
-    def _configs(controller, plugin_section_old, plugin_section_new):
-        """Build two full configs differing only inside the plugin section --
-        the subscriber refreshes its cache from these, so they must be real."""
-        base = copy.deepcopy(controller.config)
-        old = copy.deepcopy(base)
-        new = copy.deepcopy(base)
-        old["hockey-scoreboard"] = plugin_section_old
-        new["hockey-scoreboard"] = plugin_section_new
-        return old, new
-
-    def test_nested_edit_queues_reconcile_for_absent_plugin(self, test_display_controller):
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {}          # validate_config() said False
-        controller._pending_plugin_reconcile = False
-
-        old, new = self._configs(
-            controller,
-            {"enabled": True, "nhl": {"enabled": False}},
-            {"enabled": True, "nhl": {"enabled": True}},
-        )
-        # The original gate is blind to this edit ...
-        assert controller._enabled_set_changed(old, new) is False
-        self._subscriber(controller)(old, new)
-        # ... but the reconcile is queued anyway.
-        assert controller._pending_plugin_reconcile is True
-
-    def test_steady_state_does_not_queue_reconcile(self, test_display_controller):
-        """Everything enabled is running: an unrelated edit must not queue a
-        reconcile, or every config save drags a filesystem scan onto the
-        render thread."""
-        controller = test_display_controller
-        controller.plugin_manager.plugin_manifests = {"hockey-scoreboard": {}}
-        controller.plugin_manager.discovered_plugin_ids.return_value = {"hockey-scoreboard"}
-        controller.plugin_display_modes = {"hockey-scoreboard": ["nhl"]}
-        controller._pending_plugin_reconcile = False
-
-        old, new = self._configs(
-            controller,
-            {"enabled": True, "scroll_speed": 1},
-            {"enabled": True, "scroll_speed": 2},
-        )
-        self._subscriber(controller)(old, new)
-
-        assert controller._pending_plugin_reconcile is False
-
-
-class TestPendingReconcileNotLost:
-    """A config change arriving *during* reconcile must not be discarded.
-
-    The flag used to be cleared after a successful reconcile. Reconcile has
-    already read its config by then, so that clear erased a request it never
-    served and the newest config never reconciled -- the same "my save did
-    nothing" symptom this path exists to prevent.
-    """
-
-    def test_request_arriving_during_reconcile_survives(self, test_display_controller):
-        controller = test_display_controller
-        controller._pending_plugin_reconcile = True
-
-        def reconcile_and_race():
-            # The watcher thread queues another change while we are mid-flight.
-            with controller._reconcile_flag_lock:
-                controller._pending_plugin_reconcile = True
-            return True
-
-        controller._reconcile_enabled_plugins = reconcile_and_race
-        controller._service_pending_reconcile()
-
-        assert controller._pending_plugin_reconcile is True, \
-            "a config change landing during reconcile was discarded"
-
-    def test_flag_cleared_on_a_quiet_success(self, test_display_controller):
-        controller = test_display_controller
-        controller._pending_plugin_reconcile = True
-        controller._reconcile_enabled_plugins = lambda: True
-        controller._service_pending_reconcile()
-        assert controller._pending_plugin_reconcile is False
-
-    def test_retryable_failure_rearms(self, test_display_controller):
-        controller = test_display_controller
-        controller._pending_plugin_reconcile = True
-        controller._reconcile_enabled_plugins = lambda: False
-        controller._service_pending_reconcile()
-        assert controller._pending_plugin_reconcile is True
-
-    def test_no_reconcile_when_nothing_pending(self, test_display_controller):
-        controller = test_display_controller
-        controller._pending_plugin_reconcile = False
-        calls = []
-        controller._reconcile_enabled_plugins = lambda: calls.append(1) or True
-        controller._service_pending_reconcile()
-        assert calls == []

test/test_plugin_manager_discovered_ids.py

@@ -1,63 +0,0 @@
-"""Tests for PluginManager.discovered_plugin_ids().
-
-The config-watcher thread needs the set of discovered plugin ids while the
-render thread may be rebuilding plugin_manifests. Iterating that dict directly
-can observe a half-populated mapping or raise "dictionary changed size during
-iteration", so the accessor snapshots it under the discovery lock.
-"""
-
-import tempfile
-import threading
-from pathlib import Path
-
-import pytest
-
-from src.plugin_system.plugin_manager import PluginManager
-
-
-@pytest.fixture
-def pm():
-    with tempfile.TemporaryDirectory() as tmp:
-        yield PluginManager(plugins_dir=str(Path(tmp) / "plugins"))
-
-
-def test_returns_the_discovered_ids(pm):
-    pm.plugin_manifests = {"clock-simple": {}, "hockey-scoreboard": {}}
-    assert pm.discovered_plugin_ids() == {"clock-simple", "hockey-scoreboard"}
-
-
-def test_empty_when_nothing_discovered(pm):
-    pm.plugin_manifests = {}
-    assert pm.discovered_plugin_ids() == set()
-
-
-def test_is_a_snapshot_not_a_live_view(pm):
-    """The caller iterates the result on another thread; it must not alias
-    the mapping discovery is still writing to."""
-    pm.plugin_manifests = {"clock-simple": {}}
-    snapshot = pm.discovered_plugin_ids()
-    pm.plugin_manifests["hockey-scoreboard"] = {}
-    assert snapshot == {"clock-simple"}
-
-
-def test_takes_the_discovery_lock(pm):
-    """Guards against the lock being dropped in a later refactor: with the
-    lock held by another thread the call must block rather than read."""
-    pm.plugin_manifests = {"clock-simple": {}}
-    finished = threading.Event()
-
-    def call():
-        pm.discovered_plugin_ids()
-        finished.set()
-
-    pm._discovery_lock.acquire()
-    try:
-        # RLock is reentrant per-thread, so use a *different* thread to prove
-        # the accessor actually waits on it.
-        t = threading.Thread(target=call, daemon=True)
-        t.start()
-        assert not finished.wait(timeout=0.3), "accessor did not take the discovery lock"
-    finally:
-        pm._discovery_lock.release()
-    t.join(timeout=2)
-    assert finished.is_set()

web_interface/blueprints/api_v3.py

@@ -597,7 +597,7 @@ def save_dim_schedule_config():
                 dim_brightness = 30
             else:
                 dim_brightness = int(dim_brightness_raw)
-        except (ValueError, TypeError):
+        except (ValueError, TypeError, OverflowError):
             return error_response(
                 ErrorCode.VALIDATION_ERROR,
                 "dim_brightness must be an integer between 0 and 100",
@@ -797,7 +797,7 @@ def save_main_config():
                 }), 400
             try:
                 target_fps = int(raw_target_fps)
-            except (ValueError, TypeError):
+            except (ValueError, TypeError, OverflowError):
                 return jsonify({
                     'status': 'error',
                     'message': "Invalid value for target_fps: must be an integer"
@@ -867,7 +867,7 @@ def save_main_config():
                     mux_val = int(data['multiplexing'])
                     if mux_val < 0 or mux_val > 22:
                         return jsonify({'status': 'error', 'message': f"Invalid multiplexing value '{data['multiplexing']}'. Must be an integer from 0 to 22."}), 400
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({'status': 'error', 'message': f"Invalid multiplexing value '{data['multiplexing']}'. Must be an integer from 0 to 22."}), 400
 
             # Validate pixel_mapper_config (free-form mapper string, e.g. "U-mapper;Rotate:90")
@@ -885,7 +885,7 @@ def save_main_config():
                     rat_val = int(data['row_address_type'])
                     if rat_val < 0 or rat_val > 4:
                         return jsonify({'status': 'error', 'message': f"Invalid row_address_type '{data['row_address_type']}'. Must be an integer from 0 to 4."}), 400
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({'status': 'error', 'message': f"Invalid row_address_type '{data['row_address_type']}'. Must be an integer from 0 to 4."}), 400
 
             # Handle hardware settings
@@ -910,7 +910,7 @@ def save_main_config():
                     if rp1_val not in (0, 1):
                         return jsonify({'status': 'error', 'message': "rp1_rio must be 0 (PIO) or 1 (RIO)"}), 400
                     current_config['display']['runtime']['rp1_rio'] = rp1_val
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({'status': 'error', 'message': "rp1_rio must be 0 or 1"}), 400
 
             # Handle checkboxes - coerce to bool to ensure proper JSON types
@@ -963,7 +963,7 @@ def save_main_config():
                 copies = None
                 try:
                     copies = int(data['double_sided_copies'])
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     if enabled:
                         return jsonify({'status': 'error', 'message': "Double-sided copies must be an integer"}), 400
                 if copies is not None and not (2 <= copies <= 8):
@@ -1036,7 +1036,7 @@ def save_main_config():
             if data.get('vegas_extend_threshold_screens') not in ('', None):
                 try:
                     screens = float(data['vegas_extend_threshold_screens'])
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({
                         'status': 'error',
                         'message': "Invalid value for vegas_extend_threshold_screens: "
@@ -1053,7 +1053,7 @@ def save_main_config():
             if data.get('vegas_max_plugin_width_ratio') not in ('', None):
                 try:
                     ratio = float(data['vegas_max_plugin_width_ratio'])
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({
                         'status': 'error',
                         'message': "Invalid value for vegas_max_plugin_width_ratio: "
@@ -1101,7 +1101,7 @@ def save_main_config():
                         continue
                     try:
                         int_value = int(raw_value)
-                    except (ValueError, TypeError):
+                    except (ValueError, TypeError, OverflowError):
                         return jsonify({
                             'status': 'error',
                             'message': f"Invalid value for {field_name}: must be an integer"
@@ -1153,7 +1153,7 @@ def save_main_config():
                     if not (1024 <= port_val <= 65535):
                         return jsonify({'status': 'error', 'message': "sync_port must be between 1024 and 65535"}), 400
                     current_config['sync']['port'] = port_val
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({'status': 'error', 'message': "sync_port must be an integer"}), 400
 
             if "sync_follower_position" in data:
@@ -1197,7 +1197,7 @@ def save_main_config():
                 raw_value = data.pop(field)
                 try:
                     int_value = int(raw_value)
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     return jsonify({'status': 'error',
                                     'message': f"Invalid duration for {field}: must be an integer"}), 400
                 current_config['display']['display_durations'][field] = int_value
@@ -1220,7 +1220,7 @@ def save_main_config():
                     continue
                 try:
                     int_value = int(raw_value)
-                except (ValueError, TypeError):
+                except (ValueError, TypeError, OverflowError):
                     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
@@ -5118,7 +5118,7 @@ def save_plugin_config():
                                                                 converted_array.append(int(v))
                                                             else:
                                                                 converted_array.append(float(v))
-                                                        except (ValueError, TypeError):
+                                                        except (ValueError, TypeError, OverflowError):
                                                             converted_array.append(v)
                                                     else:
                                                         converted_array.append(v)
@@ -5143,7 +5143,7 @@ def save_plugin_config():
                                                         converted_array.append(int(v))
                                                     else:
                                                         converted_array.append(float(v))
-                                                except (ValueError, TypeError):
+                                                except (ValueError, TypeError, OverflowError):
                                                     converted_array.append(v)
                                             else:
                                                 converted_array.append(v)
@@ -5180,7 +5180,7 @@ def save_plugin_config():
                                                                 converted_array.append(int(v))
                                                             else:
                                                                 converted_array.append(float(v))
-                                                        except (ValueError, TypeError):
+                                                        except (ValueError, TypeError, OverflowError):
                                                             converted_array.append(v)
                                                     else:
                                                         converted_array.append(v)
@@ -5204,7 +5204,7 @@ def save_plugin_config():
                                                         converted_array.append(int(v))
                                                     else:
                                                         converted_array.append(float(v))
-                                                except (ValueError, TypeError):
+                                                except (ValueError, TypeError, OverflowError):
                                                     converted_array.append(v)
                                             else:
                                                 converted_array.append(v)
@@ -5371,7 +5371,7 @@ def save_plugin_config():
                                         if isinstance(v, str):
                                             try:
                                                 converted.append(int(v) if item_type == 'integer' else float(v))
-                                            except (ValueError, TypeError):
+                                            except (ValueError, TypeError, OverflowError):
                                                 converted.append(v)
                                         else:
                                             converted.append(v)
@@ -5496,7 +5496,7 @@ def save_plugin_config():
                             try:
                                 normalized[key] = int(value_stripped)
                                 continue
-                            except (ValueError, TypeError):
+                            except (ValueError, TypeError, OverflowError):
                                 pass
                         elif isinstance(value, (int, float)):
                             normalized[key] = int(value)
@@ -5514,7 +5514,7 @@ def save_plugin_config():
                             try:
                                 normalized[key] = float(value_stripped)
                                 continue
-                            except (ValueError, TypeError):
+                            except (ValueError, TypeError, OverflowError):
                                 pass
                         elif isinstance(value, (int, float)):
                             normalized[key] = float(value)
@@ -5569,7 +5569,7 @@ def save_plugin_config():
                                     try:
                                         normalized_array.append(int(v))
                                         continue
-                                    except (ValueError, TypeError):
+                                    except (ValueError, TypeError, OverflowError):
                                         pass
                                 elif isinstance(v, (int, float)):
                                     normalized_array.append(int(v))
@@ -5579,7 +5579,7 @@ def save_plugin_config():
                                     try:
                                         normalized_array.append(float(v))
                                         continue
-                                    except (ValueError, TypeError):
+                                    except (ValueError, TypeError, OverflowError):
                                         pass
                                 elif isinstance(v, (int, float)):
                                     normalized_array.append(float(v))
@@ -5595,7 +5595,7 @@ def save_plugin_config():
                             if isinstance(v, str):
                                 try:
                                     normalized_array.append(int(v))
-                                except (ValueError, TypeError):
+                                except (ValueError, TypeError, OverflowError):
                                     normalized_array.append(v)
                             elif isinstance(v, (int, float)):
                                 normalized_array.append(int(v))
@@ -5609,7 +5609,7 @@ def save_plugin_config():
                             if isinstance(v, str):
                                 try:
                                     normalized_array.append(float(v))
-                                except (ValueError, TypeError):
+                                except (ValueError, TypeError, OverflowError):
                                     normalized_array.append(v)
                             else:
                                 normalized_array.append(v)
@@ -5632,7 +5632,7 @@ def save_plugin_config():
                     if isinstance(value, str):
                         try:
                             normalized[key] = int(value)
-                        except (ValueError, TypeError):
+                        except (ValueError, TypeError, OverflowError):
                             normalized[key] = value
                     else:
                         normalized[key] = value
@@ -5641,7 +5641,7 @@ def save_plugin_config():
                     if isinstance(value, str):
                         try:
                             normalized[key] = float(value)
-                        except (ValueError, TypeError):
+                        except (ValueError, TypeError, OverflowError):
                             normalized[key] = value
                     else:
                         normalized[key] = value
@@ -6779,7 +6779,7 @@ def get_font_preview() -> tuple[Response, int] | Response:
         # Safe integer parsing for size
         try:
             size = int(request.args.get('size', 12))
-        except (ValueError, TypeError):
+        except (ValueError, TypeError, OverflowError):
             return jsonify({'status': 'error', 'message': 'Invalid font size'}), 400
 
         if not font_filename:
@@ -8360,7 +8360,7 @@ def clear_old_errors():
                     context={'provided_value': raw_max_age},
                     status_code=400
                 )
-        except (ValueError, TypeError):
+        except (ValueError, TypeError, OverflowError):
             return error_response(
                 error_code=ErrorCode.INVALID_INPUT,
                 message="max_age_hours must be a valid integer",