trcc-linux 9.7.7__tar.gz → 9.7.8__tar.gz

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trcc-linux
-Version: 9.7.7
+Version: 9.7.8
 Summary: Linux implementation of Thermalright LCD Control Center
 Project-URL: Homepage, https://github.com/Lexonight1/thermalright-trcc-linux
 Project-URL: Documentation, https://github.com/Lexonight1/thermalright-trcc-linux#readme

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "trcc-linux"
-version = "9.7.7"
+version = "9.7.8"
 description = "Linux implementation of Thermalright LCD Control Center"
 readme = "README.md"
 license = "GPL-3.0-or-later"

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/__version__.py

@@ -1,4 +1,4 @@
 """TRCC Linux version information. History in doc/CHANGELOG.md."""
 
-__version__ = "9.7.7"
+__version__ = "9.7.8"
 __version_info__ = tuple(int(x) for x in __version__.split("."))

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/adapters/diagnostics/debug_report.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import json
 import logging
+import os
 import platform as py_platform
 import sys
 from dataclasses import dataclass, field
@@ -43,6 +44,7 @@ class DebugReport:
     devices_error: str = ""
     sensors: list[dict[str, str]] = field(default_factory=list)
     sensors_error: str = ""
+    powercap: list[dict[str, str]] = field(default_factory=list)
     settings_json: str = ""
     settings_error: str = ""
     health: HealthReport = field(default_factory=HealthReport)
@@ -57,6 +59,7 @@ class DebugReport:
         sections.append(_render_kv("Paths", self.paths))
         sections.append(_render_devices(self.devices, self.devices_error))
         sections.append(_render_sensors(self.sensors, self.sensors_error))
+        sections.append(_render_powercap(self.powercap))
         sections.append(_render_settings(self.settings_json, self.settings_error))
         sections.append(_render_health(self.health))
         sections.append(_render_log_tail(self.log_tail))
@@ -83,6 +86,7 @@ def build_debug_report(
     path_table = _collect_paths(platform)
     devices, devices_err = _collect_devices(platform)
     sensors, sensors_err = _collect_sensors(platform)
+    powercap = _collect_powercap()
     settings_text, settings_err = _read_settings_file(
         settings_path or platform.paths().config_dir() / "config.json",
     )
@@ -98,6 +102,7 @@ def build_debug_report(
         devices_error=devices_err,
         sensors=sensors,
         sensors_error=sensors_err,
+        powercap=powercap,
         settings_json=settings_text,
         settings_error=settings_err,
         health=health,
@@ -188,6 +193,45 @@ def _collect_sensors(
     return rows, ""
 
 
+def _collect_powercap() -> list[dict[str, str]]:
+    """Probe the powercap RAPL nodes that CPU package power comes from (#194).
+
+    Answers the two questions a bare ``cpu:power = —`` can't: does the
+    ``intel-rapl:*`` node exist at all (``intel_rapl_msr`` loaded?), and is
+    its ``energy_uj`` counter readable by us (root-only since CVE-2020-8694?).
+    Linux-only; other OSes get no rows (the section renders as N/A).
+    """
+    log.debug("_collect_powercap: called")
+    if sys.platform != "linux":
+        return []
+    root = Path("/sys/class/powercap")
+    rows: list[dict[str, str]] = []
+    try:
+        domains = sorted(root.glob("intel-rapl:*"))
+    except OSError as e:
+        log.debug("_collect_powercap: glob failed: %s", e)
+        return []
+    for domain in domains:
+        # Top-level package domains only (intel-rapl:N), not subdomains.
+        if ":" in domain.name.split("intel-rapl:")[1]:
+            continue
+        try:
+            name = (domain / "name").read_text(encoding="utf-8").strip() \
+                if (domain / "name").is_file() else "?"
+            energy = domain / "energy_uj"
+            if not energy.exists():
+                readable = "no energy_uj"
+            else:
+                mode = energy.stat().st_mode & 0o777
+                ok = os.access(energy, os.R_OK)
+                readable = f"{'readable' if ok else 'ROOT-ONLY'} ({mode:#o})"
+        except OSError as e:
+            # A diagnostic must never abort the report — note the probe error.
+            name, readable = "?", f"probe error: {type(e).__name__}"
+        rows.append({"domain": domain.name, "name": name, "energy_uj": readable})
+    return rows
+
+
 def _read_settings_file(path: Path) -> tuple[str, str]:
     log.debug("_read_settings_file: path=%s", path)
     if not path.is_file():
@@ -251,6 +295,18 @@ def _render_sensors(rows: list[dict[str, str]], error: str) -> str:
     return f"## Sensors ({len(rows)})\n{body}"
 
 
+def _render_powercap(rows: list[dict[str, str]]) -> str:
+    if not rows:
+        return ("## CPU power (RAPL)\n  No intel-rapl powercap domains — "
+                "intel_rapl_msr not loaded (or N/A on this OS).\n"
+                "  Run `trcc setup` to load it + grant read access (#194).")
+    body = "\n".join(
+        f"  {r['domain']:16}  {r['name']:12}  energy_uj: {r['energy_uj']}"
+        for r in rows
+    )
+    return f"## CPU power (RAPL, {len(rows)} package domain(s))\n{body}"
+
+
 def _render_settings(text: str, error: str) -> str:
     if error and not text:
         return f"## Settings\n  {error}"

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/adapters/sensors/hwmon.py

@@ -34,6 +34,11 @@ _HWMON_ROOT = Path("/sys/class/hwmon")
 _DRM_ROOT = Path("/sys/class/drm")
 _POWERCAP_ROOT = Path("/sys/class/powercap")
 
+# When RAPL discovery comes up empty (driver not loaded, or energy_uj still
+# root-only), re-scan at most this often so CPU power appears without an app
+# restart once the user runs `trcc setup` to load the module / grant read.
+_RAPL_REDISCOVER_INTERVAL_S = 30.0
+
 _CPU_DRIVERS = ("coretemp", "k10temp", "zenpower")
 _AMD_DRIVER = "amdgpu"
 _INTEL_DRIVERS = ("i915", "xe")
@@ -129,12 +134,13 @@ class _RaplCpuPower:
     ``prev`` and report garbage watts.
     """
 
-    __slots__ = ("_last", "_lock", "_paths")
+    __slots__ = ("_last", "_lock", "_next_rediscover", "_paths")
 
     def __init__(self) -> None:
         self._paths = self._discover()
         self._last: tuple[float, float] | None = None   # (sum_uj, monotonic)
         self._lock = threading.Lock()
+        self._next_rediscover = 0.0
 
     @staticmethod
     def _discover() -> list[Path]:
@@ -163,15 +169,29 @@ class _RaplCpuPower:
         log.info("RAPL CPU power: %d readable package domain(s)", len(paths))
         return paths
 
+    def _maybe_rediscover(self) -> None:
+        """Re-scan for RAPL paths when we have none — covers a driver load or
+        permission grant that happened after construction (the user just ran
+        ``trcc setup``), so CPU power appears without restarting the app
+        (#194).  Throttled so the empty case stays cheap.  Caller holds
+        ``_lock``."""
+        now = time.monotonic()
+        if now < self._next_rediscover:
+            return
+        self._next_rediscover = now + _RAPL_REDISCOVER_INTERVAL_S
+        self._paths = self._discover()
+
     def read(self) -> float | None:
         """Watts since the last read, or None (first read / wrap / locked).
 
         Thread-safe: the read-delta-update runs under ``_lock`` so
         concurrent callers can't interleave their energy/time samples.
         """
-        if not self._paths:
-            return None
         with self._lock:
+            if not self._paths:
+                self._maybe_rediscover()
+                if not self._paths:
+                    return None
             total = 0.0
             for path in self._paths:
                 val = _read_float(path)

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/adapters/system/_autostart.py

@@ -142,10 +142,15 @@ class XdgDesktopAutostart(AutostartManager):
 
         The second form is robust across pipx / venv / system-python
         installs because ``sys.executable`` is always the right interpreter.
+
+        ``--resume`` makes the autostarted instance start hidden in the
+        system tray (restoring the last-used theme) instead of popping a
+        window on every login — the long-standing autostart behaviour that
+        regressed when the flag was dropped (#201).
         """
         if (resolved := shutil.which("trcc")):
-            return f"{resolved} gui"
-        return f"{sys.executable} -m trcc gui"
+            return f"{resolved} gui --resume"
+        return f"{sys.executable} -m trcc gui --resume"
 
 
 # =========================================================================

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/adapters/system/_udev.py

@@ -42,6 +42,23 @@ log = logging.getLogger(__name__)
 _RULES_PATH = Path("/etc/udev/rules.d/99-trcc-lcd.rules")
 _MODPROBE_PATH = Path("/etc/modprobe.d/trcc-lcd.conf")
 _MODULES_LOAD_PATH = Path("/etc/modules-load.d/trcc-sg.conf")
+_MODULES_LOAD_RAPL_PATH = Path("/etc/modules-load.d/trcc-rapl.conf")
+
+# `intel_rapl_msr` exposes the powercap RAPL energy counter on BOTH Intel and
+# AMD (Zen) — the vendor-agnostic `/sys/class/powercap/intel-rapl:*` node trcc
+# reads CPU package watts from (#194).
+_RAPL_MODULE = "intel_rapl_msr"
+
+# CPU package power read-grant.  `energy_uj` is root-only since CVE-2020-8694
+# (PLATYPUS), so without this trcc can't report CPU watts on most distros.
+# Scoped to ONLY the energy counter; reverted by deleting the rules file.
+_POWERCAP_RULES = (
+    "# CPU package power (RAPL) — make energy_uj readable without root so\n"
+    "# trcc can report CPU watts (root-only since CVE-2020-8694).  Scoped to\n"
+    "# the energy counter only; delete this file to revert.\n"
+    'SUBSYSTEM=="powercap", KERNEL=="intel-rapl:*", '
+    'RUN+="/bin/chmod 0444 /sys$devpath/energy_uj"\n'
+)
 
 
 # Wire → which kernel subsystems grant access for that protocol.
@@ -86,7 +103,8 @@ def build_udev_rules() -> str:
             f'ATTR{{power/autosuspend_delay_ms}}="10000"'
         )
         lines.append("")
-    return "\n".join(lines).rstrip() + "\n"
+    body = "\n".join(lines).rstrip() + "\n"
+    return f"{body}\n{_POWERCAP_RULES}"
 
 
 def build_modprobe_conf() -> str:
@@ -128,6 +146,9 @@ def install(dry_run: bool = False) -> int:
             print(modprobe, end="")
         print(f"\n--- would write {_MODULES_LOAD_PATH} ---")
         print("sg\n")
+        print(f"--- would write {_MODULES_LOAD_RAPL_PATH} ---")
+        print(f"{_RAPL_MODULE}\n")
+        print(f"--- would modprobe {_RAPL_MODULE} (CPU power, now) ---")
         return 0
 
     if os.geteuid() != 0:
@@ -143,10 +164,22 @@ def install(dry_run: bool = False) -> int:
             log.info("Wrote %s", _MODPROBE_PATH)
         _write_atomic(_MODULES_LOAD_PATH, "sg\n")
         log.info("Wrote %s (auto-load sg kernel module)", _MODULES_LOAD_PATH)
+        _write_atomic(_MODULES_LOAD_RAPL_PATH, f"{_RAPL_MODULE}\n")
+        log.info("Wrote %s (auto-load %s for CPU power)",
+                 _MODULES_LOAD_RAPL_PATH, _RAPL_MODULE)
     except OSError:
         log.exception("Could not write udev/modprobe config")
         return 1
 
+    # Load the RAPL module now so CPU power works without a reboot — the
+    # modules-load.d entry above only takes effect on next boot.  Best-effort:
+    # a kernel without the module (or a VM) just leaves CPU power unavailable.
+    try:
+        subprocess.run(["modprobe", _RAPL_MODULE], check=False)
+    except (OSError, subprocess.SubprocessError):
+        log.warning("modprobe %s failed — CPU power may need a reboot",
+                    _RAPL_MODULE)
+
     return _reload_udev()
 
 
@@ -166,7 +199,10 @@ def _reload_udev() -> int:
     for cmd in (["udevadm", "control", "--reload-rules"],
                 ["udevadm", "trigger", "--subsystem-match=usb"],
                 ["udevadm", "trigger", "--subsystem-match=scsi_generic"],
-                ["udevadm", "trigger", "--subsystem-match=hidraw"]):
+                ["udevadm", "trigger", "--subsystem-match=hidraw"],
+                # Re-fire the RAPL read-grant on the already-present
+                # powercap nodes so CPU power works without a reboot (#194).
+                ["udevadm", "trigger", "--subsystem-match=powercap"]):
         try:
             result = subprocess.run(cmd, check=False)
         except (OSError, subprocess.SubprocessError):

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/app.py

@@ -698,10 +698,20 @@ class _DeviceRenderObserver:
             # display IS the live metric, no theme involved).  LED was
             # dropped from this list at the cutover, which is why LED panels
             # stopped updating on sensor ticks.
+            #
+            # BUT skip any LED device the animation loop is already ticking:
+            # it re-renders that device every 150 ms off the same cached
+            # sample, so an extra render here just advances the effect timer
+            # one more step right as the metric updates — a brief hiccup the
+            # user sees as the numbers "glitching while updating" (#202).  The
+            # loop owns the cadence for animating devices; static LED devices
+            # (not ticked by the loop) still need this sensor-driven refresh.
+            animating = set(self._app.led_animation_loop.animating_keys())
             keys = [
                 k for k, d in self._app.devices.items()
                 if d.is_connected
                 and (d.is_led or k in self._app.active_themes)
+                and k not in animating
             ]
         for key in keys:
             device = self._app.devices.get(key)

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/core/commands/led.py

@@ -339,11 +339,22 @@ class RenderLed(Command[LedColorsResult]):
                     zone_map=zone_map,
                     metric_sources=display.zone_metric_sources,
                     led_count=segment_count,
+                    zone_color_groups=display.zone_color_groups,
                 )
             else:
                 colors = app.led_effects.tick(
                     effective_settings, runtime, current,
                     led_count=segment_count,
+                    color_groups=display.color_groups,
+                )
+
+            # Styles with a decoration strip (LF10/LF12) keep the strip's
+            # spatial rainbow but collapse each metric digit to one color so the
+            # number reads cohesively (#193) — a post-effect pass that leaves
+            # every non-digit LED on its per-LED spread.
+            if display.digit_groups is not None:
+                colors = app.led_effects.cohere_digit_groups(
+                    colors, display.digit_groups,
                 )
 
         # One writer: bake global brightness into the rendered signal so the

{trcc_linux-9.7.7 → trcc_linux-9.7.8}/src/trcc/services/led_effects.py

@@ -38,11 +38,11 @@ log = logging.getLogger(__name__)
 def apply_brightness(
     colors: list[tuple[int, int, int]], percent: int,
 ) -> list[tuple[int, int, int]]:
-    """Scale a logical colour array by a 0–100 % brightness.
+    """Scale a logical color array by a 0–100 % brightness.
 
     The single conversion point for global LED brightness: ``RenderLed``
     and ``SetLedColors`` bake it into the rendered signal so the device
-    wire and the GUI preview observe one identical colour list.  100 % is
+    wire and the GUI preview observe one identical color list.  100 % is
     the identity, so callers may always route through this.
     """
     scale = max(0, min(100, percent)) / 100.0
@@ -149,6 +149,16 @@ _COLORFUL_PERIOD = 168            # six 28-tick phases
 _COLORFUL_PHASE_LEN = 28
 _RAINBOW_STEP = 4                 # rainbow advance per tick
 
+# Hue step between adjacent COLOUR GROUPS (one group = one digit).  A strip
+# wraps the whole spectrum around its LEDs (``table_len // led_count``); a
+# segment number instead wants each digit a single color with only a GENTLE
+# gradient between digits — the look the Windows app produces.  These fixed
+# steps give that subtle spread regardless of how many digits a zone has
+# (≈ one-sixth of the wheel across ten groups), so the rainbow never smears
+# across a single digit's seven segments (#193).
+_RAINBOW_GROUP_STEP = 768 // 10 // 6        # ≈ 12 / 768  ≈ 1.6 % of the wheel
+_COLORFUL_GROUP_STEP = _COLORFUL_PERIOD // 10 // 6   # ≈ 2 / 168
+
 
 class LEDEffectEngine:
     """Compute one tick's worth of per-segment colors for an LED device.
@@ -167,17 +177,29 @@ class LEDEffectEngine:
         sensors: dict[str, float],
         *,
         led_count: int,
+        color_groups: tuple[tuple[int, ...], ...] | None = None,
     ) -> list[tuple[int, int, int]]:
         """Run one tick and return ``led_count`` RGB tuples.
 
         Test mode short-circuits everything — diagnostic color cycle.
-        Otherwise dispatch by ``settings.mode``.
+        ``color_groups`` (segment-number displays) colors each digit as one
+        cohesive unit; without it the spatial effects render per raw LED,
+        which is right for RGB strips but smears a rainbow across a digit's
+        segments (#193).  Otherwise dispatch by ``settings.mode``.
         """
-        log.debug("tick: mode=%s test=%s led_count=%d",
-                  settings.mode, settings.test_mode, led_count)
+        log.debug("tick: mode=%s test=%s led_count=%d groups=%s",
+                  settings.mode, settings.test_mode, led_count,
+                  len(color_groups) if color_groups else 0)
         if settings.test_mode:
             return self._tick_test(runtime, led_count)
 
+        if color_groups is not None:
+            return self._color_groups(
+                settings.mode, settings.color, runtime, sensors,
+                color_groups, led_count,
+                settings.temp_source, settings.load_source,
+            )
+
         return self._tick_mode(
             settings.mode, settings.color, runtime, sensors,
             led_count, settings.temp_source, settings.load_source,
@@ -194,6 +216,7 @@ class LEDEffectEngine:
         zone_map: tuple[tuple[int, ...], ...],
         metric_sources: tuple[tuple[str, str], ...] | None,
         led_count: int,
+        zone_color_groups: tuple[tuple[tuple[int, ...], ...], ...] | None = None,
     ) -> list[tuple[int, int, int]]:
         """Per-zone colors placed at each zone's physical LED indices.
 
@@ -201,7 +224,9 @@ class LEDEffectEngine:
         its own mode + color + brightness over its mapped LED indices
         (``SegmentDisplay.zone_led_map``).  ``metric_sources`` maps zone
         index → (device, kind) so a sensor-linked zone reads its own
-        source.
+        source.  ``zone_color_groups[zi]`` (when present) groups a zone's
+        LEDs by digit so each digit is one cohesive color — otherwise the
+        spatial effects smear a rainbow across a digit's segments (#193).
 
         Note the shared ``rgb_timer``: each animated zone's per-mode tick
         advances it, so N animated zones step it N× per frame and each
@@ -211,8 +236,8 @@ class LEDEffectEngine:
         """
         colors: list[tuple[int, int, int]] = [(0, 0, 0)] * led_count
         zones = settings.zones
-        log.debug("tick_multi_zone: %d zones, led_count=%d",
-                  len(zone_map), led_count)
+        log.debug("tick_multi_zone: %d zones, led_count=%d grouped=%s",
+                  len(zone_map), led_count, zone_color_groups is not None)
         for zi, led_indices in enumerate(zone_map):
             if zi >= len(zones):
                 break
@@ -228,16 +253,32 @@ class LEDEffectEngine:
             # Zone's device ("cpu"/"gpu") drives both temp + load sources;
             # the zone's mode decides which one applies.  Empty → "cpu".
             zone_source = src[0] if src and src[0] else "cpu"
-            zone_colors = self._tick_mode(
-                zone.mode, zone.color, runtime, sensors,
-                len(led_indices), zone_source, zone_source,
+            groups = (
+                zone_color_groups[zi]
+                if zone_color_groups is not None and zi < len(zone_color_groups)
+                else None
+            )
+            if groups is not None:
+                # One color per digit-group, gentle gradient between digits.
+                group_colors = self._scale_brightness(
+                    self._tick_mode(
+                        zone.mode, zone.color, runtime, sensors,
+                        len(groups), zone_source, zone_source, cohesive=True,
+                    ),
+                    zone.brightness,
+                )
+                for gi, group_leds in enumerate(groups):
+                    for idx in group_leds:
+                        if idx < led_count:
+                            colors[idx] = group_colors[gi]
+                continue
+            zone_colors = self._scale_brightness(
+                self._tick_mode(
+                    zone.mode, zone.color, runtime, sensors,
+                    len(led_indices), zone_source, zone_source,
+                ),
+                zone.brightness,
             )
-            if zone.brightness < 100:
-                scale = zone.brightness / 100.0
-                zone_colors = [
-                    (int(r * scale), int(g * scale), int(b * scale))
-                    for r, g, b in zone_colors
-                ]
             for i, idx in enumerate(led_indices):
                 if idx < led_count:
                     colors[idx] = zone_colors[i]
@@ -270,16 +311,29 @@ class LEDEffectEngine:
         led_count: int,
         temp_source: str,
         load_source: str,
+        *,
+        cohesive: bool = False,
     ) -> list[tuple[int, int, int]]:
+        """Compute ``led_count`` colors for one logical strip.
+
+        ``cohesive`` is set when ``led_count`` counts COLOUR GROUPS (digits),
+        not raw LEDs: the spatial effects then use a gentle fixed hue step so
+        each digit reads as one color, instead of wrapping a full rainbow
+        across the group (#193).  Non-spatial modes ignore it.
+        """
         match mode:
             case LEDMode.STATIC:
                 return [color] * led_count
             case LEDMode.BREATHING:
                 return self._tick_breathing(color, runtime, led_count)
             case LEDMode.COLORFUL:
-                return self._tick_colorful(runtime, led_count)
+                return self._tick_colorful(
+                    runtime, led_count,
+                    _COLORFUL_GROUP_STEP if cohesive else None)
             case LEDMode.RAINBOW:
-                return self._tick_rainbow(runtime, led_count)
+                return self._tick_rainbow(
+                    runtime, led_count,
+                    _RAINBOW_GROUP_STEP if cohesive else None)
             case LEDMode.TEMP_LINKED:
                 return self._tick_temp_linked(runtime, sensors, led_count,
                                               temp_source)
@@ -288,6 +342,73 @@ class LEDEffectEngine:
                                               load_source)
         return [(0, 0, 0)] * led_count
 
+    @staticmethod
+    def cohere_digit_groups(
+        colors: list[tuple[int, int, int]],
+        groups: tuple[tuple[int, ...], ...],
+    ) -> list[tuple[int, int, int]]:
+        """Collapse each digit group to one color (its first LED's), in place
+        on a copy.
+
+        For styles that pair segment digits with a decoration STRIP (LF10/
+        LF12): the strip must keep the spatial rainbow the effect already gave
+        it, so we don't group it — we only flatten the digits here, after the
+        effect, leaving every other LED on its per-LED spread (#193).
+        """
+        out = list(colors)
+        for group in groups:
+            if not group:
+                continue
+            head = group[0]
+            if head >= len(out):
+                continue
+            color = out[head]
+            for led in group:
+                if led < len(out):
+                    out[led] = color
+        return out
+
+    @staticmethod
+    def _scale_brightness(
+        colors: list[tuple[int, int, int]], brightness: int,
+    ) -> list[tuple[int, int, int]]:
+        """Scale a color list by a 0–100 % zone brightness (no-op at 100)."""
+        if brightness >= 100:
+            return colors
+        scale = brightness / 100.0
+        return [(int(r * scale), int(g * scale), int(b * scale))
+                for r, g, b in colors]
+
+    def _color_groups(
+        self,
+        mode: LEDMode,
+        color: tuple[int, int, int],
+        runtime: LedRuntimeState,
+        sensors: dict[str, float],
+        groups: tuple[tuple[int, ...], ...],
+        led_count: int,
+        temp_source: str,
+        load_source: str,
+    ) -> list[tuple[int, int, int]]:
+        """One color per group, written to every LED the group covers.
+
+        Each group is a digit (its seven segments), so the whole digit reads
+        as a single color and only a gentle gradient separates digits — the
+        Windows look, without the C#'s hand-mapped ``ledVal`` slots (#193).
+        Out-of-range indices are skipped defensively.
+        """
+        group_colors = self._tick_mode(
+            mode, color, runtime, sensors, len(groups),
+            temp_source, load_source, cohesive=True,
+        )
+        out: list[tuple[int, int, int]] = [(0, 0, 0)] * led_count
+        for gi, leds in enumerate(groups):
+            gc = group_colors[gi]
+            for led in leds:
+                if 0 <= led < led_count:
+                    out[led] = gc
+        return out
+
     def _tick_test(
         self,
         runtime: LedRuntimeState,
@@ -326,10 +447,12 @@ class LEDEffectEngine:
     def _tick_colorful(
         runtime: LedRuntimeState,
         led_count: int,
+        step: int | None = None,
     ) -> list[tuple[int, int, int]]:
-        """6-phase gradient cycle with per-segment offset."""
+        """6-phase gradient cycle.  ``step`` overrides the per-element hue
+        offset (groups pass a small fixed step; a strip wraps the spectrum)."""
         timer = runtime.rgb_timer
-        seg_offset = _COLORFUL_PERIOD // max(led_count, 1)
+        seg_offset = step if step is not None else _COLORFUL_PERIOD // max(led_count, 1)
         colors: list[tuple[int, int, int]] = []
         for i in range(led_count):
             t_i = (timer + i * seg_offset) % _COLORFUL_PERIOD
@@ -356,12 +479,14 @@ class LEDEffectEngine:
     def _tick_rainbow(
         runtime: LedRuntimeState,
         led_count: int,
+        step: int | None = None,
     ) -> list[tuple[int, int, int]]:
-        """768-entry table shift with per-segment offset."""
+        """768-entry table shift.  ``step`` overrides the per-element table
+        offset (groups pass a small fixed step; a strip wraps the spectrum)."""
         table = ColorEngine.get_table()
         table_len = len(table)
         timer = runtime.rgb_timer
-        stride = table_len // max(led_count, 1)
+        stride = step if step is not None else table_len // max(led_count, 1)
         colors = [table[(timer + i * stride) % table_len]
                   for i in range(led_count)]
         runtime.rgb_timer = (timer + _RAINBOW_STEP) % table_len