Fix production curve overshoot on coarse meters and flicker on low-end GPUs

Past-production curve: the recorder energy of each report is now spread across
the real interval since the previous report, capped, so a meter that reports its
energy less often (or unevenly) than the graph bucket can no longer land a whole
interval's energy in one short slice and plot an average power above what the
array can produce. Energy-conserving, so totals still match the Energy dashboard.
Reported in discussion #371.

Rendering: detect a GPU whose max texture size is smaller than the ground canvas
edge and switch that device to the projected compat ground path (a card-sized
canvas, no oversized CSS 3D layer), the same remedy as the old half-3D iPad fix,
keeping the 2.5D look. This clears the whole-view flicker and black kiosk
screenshots on entry-level tablets, automatically and per-device (no shared card
option). Also drop mix-blend-mode from the storm flash. Fixes #370.

Author: ReikanYsora

CHANGELOG.md

@@ -11,7 +11,7 @@ and the project follows a date-based versioning scheme (`YEAR.MONTH.PATCH`).
 
 The weather release, "Your real sky": the scene now reflects the weather over
 your home, and the outdoor temperature and humidity join the card. Currently in
-beta (`2026.9.0-b0`).
+beta (`2026.9.0-b1`).
 
 ### Added: the terrain horizon
 
@@ -122,6 +122,27 @@ anchored to a fixed reference regardless of where you view the card from, so the
 curve always aligns with the moment it belongs to. Thanks to @m1chaelmichael for
 the precise report (#366).
 
+### Fixed: the production curve could read above your real power
+
+On installations whose production meter reports its energy less often than the
+graph's detail (or at an uneven pace), the past-production curve could briefly
+climb **above the real power your panels can produce** — a 2.5 kW-capped array
+plotting more than 2.5 kW for a moment. The curve is reconstructed from the
+Energy dashboard's energy, and a long report landing in a short slice made the
+computed average too high. Helios now spreads each reading across the interval it
+actually covers, so the curve never resolves finer than your meter reports and
+can no longer overshoot — while the totals still match the Energy dashboard
+exactly. Thanks to @ritonbrunis-lab for the clear screenshots (#371).
+
+### Fixed: flicker and black screen on some entry-level tablets
+
+On a few low-end wall tablets the whole view could shimmer or recompose between
+frames, and a kiosk screenshot came back black. The cause was the same one behind
+the old half-3D iPad issue: the device's graphics chip could not hold the scene's
+ground as a single layer. Helios now detects that limit and switches those devices
+to a lighter drawing path automatically — no setting to touch, and the 2.5D look
+is kept. Thanks to @Richaaldo and @charleslales for the detailed reports (#370).
+
 ---
 
 ## 2026.8.3

dist/helios.js

@@ -1,6 +1,6 @@
 {
   "name": "helios",
-  "version": "2026.9.0-b0",
+  "version": "2026.9.0-b1",
   "description": "HELIOS - real-time solar exposure, cloud cover and PV production card for Home Assistant",
   "license": "GPL-3.0-or-later",
   "type": "module",

package.json

@@ -101,11 +101,10 @@ export const OTHER_ERROR_BACKOFF_MS: readonly number[] = [1 * 60_000, 5 * 60_000
 export const CHANGE_REFRESH_MS = 60_000;
 export const COARSE_PROBE_MS   = 15 * 60_000;
 export const DENSE_FRACTION    = 0.6;
-//Store-curve coarse-meter smoothing: the largest report cadence (in store buckets) still spread back into a
-//smooth curve, and the fraction of gaps that must sit at that cadence to treat a meter as regularly coarse
-//(below it, the non-zero buckets read as genuine intermittent flow and are left untouched).
+//Store-curve coarse-meter smoothing: the largest report interval (in store buckets) a single report is spread back
+//across. Past it, the buckets before a report keep their zero, so a long genuine gap (an overnight lull before the
+//first daytime reading) is never smeared into the reading that follows it.
 export const COARSE_MAX_SPREAD_BUCKETS = 6;
-export const COARSE_REGULARITY         = 0.6;
 
 
 //=== Grid mis-scope guard ===

src/core/config/constants.ts

@@ -958,12 +958,14 @@ export const heliosCardStyles = css`
     }
     .helios-corner-chip.is-curve-on ha-icon { color: var(--ha-card-background, var(--card-background-color, #fff)); }
 
-    /*  THUNDERSTORM lightning: a top-weighted blue-white flash pushed by the storm controller via --wx-flash.  */
+    /*  THUNDERSTORM lightning: a top-weighted blue-white flash pushed by the storm controller via --wx-flash.
+        Plain opacity compositing (no mix-blend-mode): screen-blend forces a stacking-context blend group that some
+        Android WebViews flicker/recompose the whole view under, and the near-white flash reads almost the same
+        through straight opacity. */
     .helios-wx-flash
     {
         z-index: 7;
         opacity: var(--wx-flash, 0);
-        mix-blend-mode: screen;
         background:
             radial-gradient(120% 80% at 50% -10%, rgba(226, 236, 255, 0.9), rgba(200, 216, 255, 0.35) 40%, transparent 75%);
     }

src/css/helios-card-scene-css.ts

@@ -7,7 +7,7 @@
 //unit conversion (`units: { energy: 'kWh' }` normalises Wh/kWh/MWh server-side). The only math here is
 //kWh-per-bucket / bucket-duration = average watts, so where HA has a number the card shows the same number.
 
-import { CHANGE_REFRESH_MS, COARSE_PROBE_MS, DENSE_FRACTION, COARSE_MAX_SPREAD_BUCKETS, COARSE_REGULARITY, HOUR_MS, DAY_MS } from '../../core/config/constants';
+import { CHANGE_REFRESH_MS, COARSE_PROBE_MS, DENSE_FRACTION, COARSE_MAX_SPREAD_BUCKETS, HOUR_MS, DAY_MS } from '../../core/config/constants';
 import { callWS } from '../ha-gateway';
 import { RequestCache } from '../request-cache';
 import { loadDurable, saveDurable } from '../durable-cache';
@@ -187,36 +187,33 @@ export function outlierCapKwh(buckets: ChangeBucket[] | null): number
     return mags[idx] * OUTLIER_CAP_FACTOR;
 }
 
-//Coarse-meter smoothing on the binned per-bucket energy (sums/hit). A meter that reports its cumulative energy
-//less often than a store bucket lands each delta in one bucket and leaves 0 in the buckets between reports, which
-//draws a sawtooth (production looks spiky while a dense grid meter stays smooth). When the non-zero buckets are
-//REGULARLY spaced (a real report cadence, not intermittent flow), spread each delta back over its report interval,
-//capped so a night-long gap before the first daytime reading is never smeared. Energy-conserving: the sum over each
-//interval is unchanged, so totals still match the Energy dashboard. No-op for dense meters (cadence 1) and for
-//irregular series (export that only flows sometimes).
+//Floor the reconstructed power to the meter's real report cadence, on the binned per-bucket energy (sums/hit). A
+//meter that reports its cumulative energy less often than a store bucket lands each delta in one bucket and leaves 0
+//in the buckets between reports; dividing that lump by the (shorter) bucket then reads an average power ABOVE what
+//the site actually produced (a 2.5 kW-capped array can plot >2.5 kW), and draws a sawtooth. So spread each report
+//back over the interval since the previous report, its true accumulation window: no bucket can then hold more than
+//one interval's energy, so no bucket over-reads. Capped so a long genuine gap (overnight before the first daytime
+//reading) is never smeared. Energy-conserving (each report's total is unchanged, so totals still match the Energy
+//dashboard) and inert for dense meters (consecutive reports are one bucket apart, so span 1 leaves the value as-is).
 function smoothCoarseReports(sums: number[], hit: boolean[]): void
 {
     const reports: number[] = [];
     for (let i = 0; i < sums.length; i++)
     {
         if (hit[i] && sums[i] !== 0) { reports.push(i); }
     }
-    if (reports.length < 3) { return; }
-    const gaps: number[] = [];
-    for (let k = 1; k < reports.length; k++) { gaps.push(reports[k] - reports[k - 1]); }
-    const cadence = [...gaps].sort((a, b) => a - b)[Math.floor(gaps.length / 2)];   //median gap
-    if (cadence <= 1 || cadence > COARSE_MAX_SPREAD_BUCKETS) { return; }
-    const regular = gaps.filter(g => Math.abs(g - cadence) <= 1).length / gaps.length;
-    if (regular < COARSE_REGULARITY) { return; }
-    //Spread each report back over its own interval (capped at the cadence), evenly. Left to right; a report's range
-    //never reaches the previous report (span <= cadence <= gap), so the in-place writes never collide, and the
-    //genuine-gap buckets before a capped range keep their zero.
-    let prev = -1;
-    for (const i of reports)
+    //Need two reports to know an interval; a lone spike (fully intermittent flow) is left untouched.
+    if (reports.length < 2) { return; }
+    //The first report keeps its own bucket (its accumulation start is unknown, so it is never spread backward);
+    //every later report spreads over the capped gap to its predecessor. span <= gap means a report's range never
+    //reaches the previous report, so the in-place writes never collide and genuine-gap buckets keep their zero.
+    let prev = reports[0];
+    for (let r = 1; r < reports.length; r++)
     {
-        const span  = prev < 0 ? cadence : Math.min(i - prev, cadence);
-        const start = Math.max(0, i - span + 1);
-        const share = sums[i] / (i - start + 1);
+        const i     = reports[r];
+        const span  = Math.min(i - prev, COARSE_MAX_SPREAD_BUCKETS);
+        const start = i - span + 1;
+        const share = sums[i] / span;
         for (let j = start; j <= i; j++)
         {
             sums[j] = share;

src/data/sources/energy-stats.ts

@@ -16,8 +16,33 @@ import {
     GROWTH_RISE_MS,
     HOME_SQUASH_MS,
     HOME_GROW_MS,
+    GROUND_RADIUS,
+    TILE_PX,
 } from '../core/config/constants';
 
+//Edge of the square basemap canvas (px): (2*radius+1) tiles across. On the normal path this canvas is CSS
+//3D-transformed, so the compositor backs it as one layer of this size.
+const GROUND_CANVAS_EDGE_PX = (2 * GROUND_RADIUS + 1) * TILE_PX;
+
+//The GPU's max texture edge (px), or 0 when it can't be read. A throwaway WebGL context, released at once.
+function gpuMaxTextureSize(): number
+{
+    if (typeof document === 'undefined') { return 0; }
+    try
+    {
+        const canvas = document.createElement('canvas');
+        const gl = (canvas.getContext('webgl') ?? canvas.getContext('experimental-webgl')) as WebGLRenderingContext | null;
+        if (!gl) { return 0; }
+        const max = gl.getParameter(gl.MAX_TEXTURE_SIZE) as unknown;
+        gl.getExtension('WEBGL_lose_context')?.loseContext();
+        return typeof max === 'number' && Number.isFinite(max) ? max : 0;
+    }
+    catch
+    {
+        return 0;
+    }
+}
+
 //Old iOS/iPadOS WebKit half-composites a flat layer over a CSS 3D-transformed one, clipping the whole scene to
 //its top half. Those devices render the ground on the projected compat path instead of a 3D
 //transform. It cannot be feature-detected (no API reads composited pixels), so we sniff: an Apple touch device
@@ -26,6 +51,14 @@ import {
 //positive only swaps in the near-equivalent compat render, so erring is cheap.
 function needsProjectedGround(): boolean
 {
+    //Platform-agnostic capability gate, checked first: the normal path composites the whole basemap canvas as one
+    //CSS 3D-transformed layer. A GPU whose max texture edge is smaller than that canvas cannot back the layer and
+    //drops it to black / flickers the whole view (the entry-level Android wall tablets that flicker under a
+    //2048-cap GPU with a 2816 px canvas). The projected compat path paints a card-sized canvas instead, so it clears the
+    //cap while keeping the 2.5D look. A GPU that can't be read (maxTex 0) falls through to the Apple sniff below.
+    const maxTex = gpuMaxTextureSize();
+    if (maxTex > 0 && maxTex < GROUND_CANVAS_EDGE_PX) { return true; }
+
     if (typeof navigator === 'undefined') { return false; }
     const ua = navigator.userAgent || '';
     const appleTouch = /iPad|iPhone|iPod/.test(ua)