@aguacerowx/mapsgl 0.0.49 → 0.0.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/mapsgl",
-  "version": "0.0.49",
+  "version": "0.0.50",
   "private": false,
   "publishConfig": {
     "access": "public"

package/src/NwsWatchesWarningsOverlay.js

@@ -19,9 +19,12 @@ import {
     enrichWarningsWithColors,
     filterNwwsTerminalStatusFeatures,
     filterNwsAlertsByScope,
+    getNwwsProductKeyFromFeature,
     normalizeFeatureCollectionForMapboxGl,
     normalizeNwwsHttpAlertFeature,
+    nwsRevisionVisibilityActive,
     parseNwwsWsDelta,
+    pickBestNwsRevisionAmongConflictingFeatures,
     unwrapNwwsFeatureCollectionRoot,
 } from './nwsAlertsSupport.js';
 
@@ -131,6 +134,8 @@ export class NwsWatchesWarningsOverlay {
 
         /** @type {number | null | undefined} */
         this._timelineUnix = undefined;
+        /** Timeline unix list for the active layer (satellite / MRMS / NEXRAD) — used to match frontend “live edge” behavior. */
+        this._timelineTimes = null;
     }
 
     getAlertsUrl() {
@@ -290,9 +295,29 @@ export class NwsWatchesWarningsOverlay {
         return this._nwsAlertSettings.flashStyles ?? {};
     }
 
+    _isFollowingLatestTimelineAnchor() {
+        const current = this._timelineUnix;
+        if (current == null || !Number.isFinite(current)) return false;
+        const times = this._timelineTimes;
+        if (!Array.isArray(times) || times.length === 0) return false;
+        let latest = -Infinity;
+        for (const t of times) {
+            if (typeof t === 'number' && Number.isFinite(t) && t > latest) {
+                latest = t;
+            }
+        }
+        if (!Number.isFinite(latest)) return false;
+        return Math.abs(current - latest) <= 1;
+    }
+
+    /**
+     * Matches aguacero-frontend {@link WatchesWarningsLayer.resolveNwsDisplayTimeMode}: at the last slider
+     * step, use wall clock so SSE/stream updates appear even when the timeline tick lags.
+     */
     _resolveDisplayTimeMode() {
         const userPinnedRealtime = this._nwsAlertSettings.activeOnlyRealtime === true;
-        const useRealtime = userPinnedRealtime;
+        const followRealtimeAtLatestAnchor = !userPinnedRealtime && this._isFollowingLatestTimelineAnchor();
+        const useRealtime = userPinnedRealtime || followRealtimeAtLatestAnchor;
         return {
             useRealtime,
             timelineUnix: useRealtime ? undefined : this._timelineUnix,
@@ -309,35 +334,66 @@ export class NwsWatchesWarningsOverlay {
             : timeMode.timelineUnix;
         const useOnsetWindow = this._nwsAlertSettings.activeOnlyRealtime === true;
 
-        /**
-         * Weather-timeline alignment (MRMS / satellite / NEXRAD scrubber): without a valid reference
-         * time we must not show every alert at full opacity — previously `isActive` defaulted to
-         * true for all features when `referenceUnix` was still null (race before first timestamp).
-         */
-        if (!timeMode.useRealtime && (referenceUnix == null || !Number.isFinite(referenceUnix))) {
-            for (const f of this._workingFc.features ?? []) {
-                if (f.id == null) continue;
-                try {
-                    m.setFeatureState({ source: this._sourceId, id: f.id }, { active: false });
-                } catch {
-                    /* ignore */
-                }
-            }
-            return;
-        }
+        /** @type {Map<number, boolean>} */
+        const tentativeActive = new Map();
 
         for (const f of this._workingFc.features ?? []) {
             if (f.id == null) continue;
+            const fid = typeof f.id === 'number' ? f.id : Number(f.id);
+            if (!Number.isFinite(fid)) continue;
+
             let isActive = true;
             if (referenceUnix != null && Number.isFinite(referenceUnix)) {
                 const p = f.properties ?? {};
-                const startWindow = useOnsetWindow ? (p.active_start_unix ?? p.start_unix) : p.start_unix;
-                if (startWindow != null && referenceUnix < startWindow) {
-                    isActive = false;
-                } else if (p.end_unix != null && referenceUnix > p.end_unix) {
+                const rev = nwsRevisionVisibilityActive(p, referenceUnix);
+                if (rev === false) {
                     isActive = false;
+                } else {
+                    const startWindow = useOnsetWindow ? (p.active_start_unix ?? p.start_unix) : p.start_unix;
+                    if (startWindow != null && referenceUnix < startWindow) {
+                        isActive = false;
+                    } else if (p.end_unix != null && referenceUnix > p.end_unix) {
+                        isActive = false;
+                    }
+                }
+            }
+
+            tentativeActive.set(fid, isActive);
+        }
+
+        if (referenceUnix != null && Number.isFinite(referenceUnix)) {
+            const keyToFeatures = new globalThis.Map();
+            for (const f of this._workingFc.features ?? []) {
+                if (f.id == null) continue;
+                const fid = typeof f.id === 'number' ? f.id : Number(f.id);
+                if (!Number.isFinite(fid) || !tentativeActive.get(fid)) continue;
+                const pk = getNwwsProductKeyFromFeature(f);
+                if (!pk) continue;
+                let bucket = keyToFeatures.get(pk);
+                if (!bucket) {
+                    bucket = [];
+                    keyToFeatures.set(pk, bucket);
                 }
+                bucket.push(f);
             }
+            for (const [, group] of keyToFeatures) {
+                if (group.length <= 1) continue;
+                const winner = pickBestNwsRevisionAmongConflictingFeatures(group, referenceUnix);
+                const winId = typeof winner?.id === 'number' ? winner.id : Number(winner?.id);
+                for (const f of group) {
+                    const gfid = typeof f.id === 'number' ? f.id : Number(f.id);
+                    if (Number.isFinite(gfid) && Number.isFinite(winId) && gfid !== winId) {
+                        tentativeActive.set(gfid, false);
+                    }
+                }
+            }
+        }
+
+        for (const f of this._workingFc.features ?? []) {
+            if (f.id == null) continue;
+            const fid = typeof f.id === 'number' ? f.id : Number(f.id);
+            if (!Number.isFinite(fid)) continue;
+            const isActive = tentativeActive.get(fid) ?? true;
             try {
                 m.setFeatureState({ source: this._sourceId, id: f.id }, { active: isActive });
             } catch {
@@ -759,10 +815,17 @@ export class NwsWatchesWarningsOverlay {
 
     /**
      * Called by WeatherLayerManager when radar/satellite/MRMS mode is active.
+     * @param {object} opts
+     * @param {boolean} opts.enabled
+     * @param {number | null | undefined} opts.timelineUnix - Active scrubber unix for satellite / MRMS / NEXRAD.
+     * @param {number[] | null | undefined} [opts.timelineTimes] - Full timeline for the current layer (for “live edge” = wall clock).
      */
-    syncWithMode({ enabled, timelineUnix }) {
+    syncWithMode({ enabled, timelineUnix, timelineTimes }) {
         if (this._destroyed) return;
         this.options.enabled = !!enabled;
+        if (timelineTimes !== undefined) {
+            this._timelineTimes = Array.isArray(timelineTimes) ? timelineTimes : null;
+        }
         this.setTimelineUnix(timelineUnix);
         if (!this.options.enabled) {
             this._started = false;

package/src/WeatherLayerManager.js

@@ -10,48 +10,6 @@ import WorkerPool from './WorkerPool.js';
 
 import { DEFAULT_BASIS_BASE_URL } from './defaultBasisBaseUrl.js';
 
-const DEBUG_NS = '[WeatherLayerManager:debug]';
-
-/**
- * Redact secrets for console output.
- * @param {object} options
- */
-function _debugSanitizeOptions(options) {
-    if (!options || typeof options !== 'object') return options;
-    const o = { ...options };
-    if (typeof o.apiKey === 'string' && o.apiKey.length > 0) {
-        o.apiKey = `${o.apiKey.slice(0, 4)}…(${o.apiKey.length} chars)`;
-    }
-    return o;
-}
-
-/**
- * Compact summary of timestamp / hour arrays (MRMS timeline debugging).
- * @param {unknown[]} arr
- */
-function _debugSummarizeNumericSeries(arr) {
-    if (!Array.isArray(arr) || arr.length === 0) {
-        return { length: 0, min: null, max: null, spanSec: null, head: [], tail: undefined };
-    }
-    const nums = arr.map((x) => Number(x)).filter((n) => !Number.isNaN(n));
-    if (nums.length === 0) {
-        return { length: 0, min: null, max: null, spanSec: null, head: [], tail: undefined };
-    }
-    const sorted = [...nums].sort((a, b) => a - b);
-    const min = sorted[0];
-    const max = sorted[sorted.length - 1];
-    const head = sorted.slice(0, Math.min(8, sorted.length));
-    const tail = sorted.length > 16 ? sorted.slice(-8) : [];
-    return {
-        length: sorted.length,
-        min,
-        max,
-        spanSec: max != null && min != null ? max - min : null,
-        head,
-        tail: tail.length ? tail : undefined,
-    };
-}
-
 function findLatestModelRun(modelsData, modelName) {
     const model = modelsData?.[modelName];
     if (!model) return null;
@@ -77,7 +35,7 @@ function findLatestModelRun(modelsData, modelName) {
  * @param {string} [options.belowID] - Style layer id to insert Aguacero weather layers **below** (default `AML_-_terrain` when present). Alias of `weatherBeforeLayerId`.
  * @param {string} [options.weatherBeforeLayerId] - Same as `belowID`.
  * @param {string} [options.nexradLayerId] - Override Mapbox id for the NEXRAD custom layer (default: derived from `layerId`).
- * @param {boolean} [options.debug] - When `true`, logs detailed diagnostics to the console (prefix `[WeatherLayerManager:debug]`). Off by default.
+ * @param {boolean} [options.mrmsTimelineLog] - When `true`, logs MRMS duration / raw vs filtered timeline counts (prefix `[WeatherLayerManager MRMS]`). Off by default.
  * @param {string} [options.basisBaseUrl] - URL prefix for satellite KTX2 Basis transcoder assets (`basis_transcoder.js`, `basis_transcoder.wasm`). Defaults to jsDelivr for the published package version; override (e.g. `/basis/`) for strict CSP or offline.
  */
 export class WeatherLayerManager extends EventEmitter {
@@ -85,10 +43,10 @@ export class WeatherLayerManager extends EventEmitter {
         super();
         if (!map) throw new Error('A Mapbox GL map instance is required.');
         this.map = map;
-        /** @private When true, emit verbose `[WeatherLayerManager:debug]` logs. */
-        this._debug = options.debug === true;
-        /** @private Monotonic counter for correlating state:change logs. */
-        this._debugStateSeq = 0;
+        /** @private MRMS-only timeline diagnostics (duration, raw vs filtered counts). */
+        this._mrmsTimelineLog = options.mrmsTimelineLog === true;
+        /** @private Dedupes repeated MRMS timeline log lines. */
+        this._mrmsLogKey = '';
         this.layerId =
             options.layerId ||
             options.id ||
@@ -159,30 +117,6 @@ export class WeatherLayerManager extends EventEmitter {
         // 1. CREATE an instance of the core engine
         this.core = new AguaceroCore(options);
 
-        if (this._debug) {
-            const layerOpts = options.layerOptions || {};
-            console.log(DEBUG_NS, 'constructor', {
-                layerId: this.layerId,
-                nexradLayerId: this._nexradLayerId,
-                mapLoaded: typeof this.map?.loaded === 'function' ? this.map.loaded() : undefined,
-                styleLoaded: this.map?.isStyleLoaded?.() ?? undefined,
-                weatherBeforeLayerId: this._weatherBeforeLayerId,
-                options: _debugSanitizeOptions(options),
-                layerOptions: layerOpts,
-                coreStateSnapshot: {
-                    isMRMS: this.core.state?.isMRMS,
-                    isSatellite: this.core.state?.isSatellite,
-                    isNexrad: this.core.state?.isNexrad,
-                    model: this.core.state?.model,
-                    variable: this.core.state?.variable,
-                    mrmsDurationValue: this.core.state?.mrmsDurationValue,
-                    mrmsTimestamp: this.core.state?.mrmsTimestamp,
-                    nexradDurationValue: this.core.state?.nexradDurationValue,
-                    satelliteDurationValue: this.core.state?.satelliteDurationValue,
-                },
-            });
-        }
-
         // 2. LISTEN for events from the core engine
         this.core.on('state:change', (newState) => {
             this._lastEmittedState = newState;
@@ -203,17 +137,44 @@ export class WeatherLayerManager extends EventEmitter {
     }
 
     /**
-     * Structured debug log (no-op unless `options.debug === true` on construction).
-     * @param {string} scope
-     * @param {object} [data]
+     * Logs MRMS timeline facts when `options.mrmsTimelineLog` is enabled (once per distinct snapshot).
+     * @param {object} state
      */
-    _debugLog(scope, data) {
-        if (!this._debug) return;
-        if (data !== undefined) {
-            console.log(DEBUG_NS, scope, data);
-        } else {
-            console.log(DEBUG_NS, scope);
-        }
+    _logMrmsTimelineIfEnabled(state) {
+        if (!this._mrmsTimelineLog || !state.isMRMS || !state.variable) return;
+        const raw = this.core.mrmsStatus?.[state.variable];
+        const rawLen = Array.isArray(raw) ? raw.length : 0;
+        const avail = state.availableTimestamps || [];
+        const filteredLen = avail.length;
+        let spanH = null;
+        let minT = null;
+        let maxT = null;
+        if (filteredLen) {
+            const nums = avail.map(Number).filter(Number.isFinite).sort((a, b) => a - b);
+            minT = nums[0];
+            maxT = nums[nums.length - 1];
+            spanH = (maxT - minT) / 3600;
+        }
+        const key = `${state.variable}|${state.mrmsDurationValue}|${state.mrmsTimestamp}|${rawLen}|${filteredLen}|${minT}|${maxT}`;
+        if (key === this._mrmsLogKey) return;
+        this._mrmsLogKey = key;
+        const rawSpanH =
+            rawLen > 1 && Array.isArray(raw)
+                ? (Math.max(...raw.map(Number)) - Math.min(...raw.map(Number))) / 3600
+                : null;
+        console.log('[WeatherLayerManager MRMS]', {
+            variable: state.variable,
+            durationSettingHours: state.mrmsDurationValue,
+            selectedUnix: state.mrmsTimestamp,
+            rawStatusScanCount: rawLen,
+            rawWallClockSpanHoursApprox: rawSpanH != null ? Number(rawSpanH.toFixed(2)) : null,
+            filteredTimelineCount: filteredLen,
+            filteredSpanHoursApprox: spanH != null ? Number(spanH.toFixed(2)) : null,
+            filteredWindow:
+                minT != null && maxT != null ? { minUnix: minT, maxUnix: maxT } : null,
+            note:
+                'Timeline cannot extend beyond scans returned by the MRMS status feed; widening "hours" only includes more of that list when older scans exist.',
+        });
     }
 
     /**
@@ -262,38 +223,11 @@ export class WeatherLayerManager extends EventEmitter {
      * @private
      */
     _handleStateChange(state) {
-        const seq = this._debug ? ++this._debugStateSeq : 0;
         /** NEXRAD setup is async (`sites.show`, frame fetch). `finally` would run before the radar layer exists, so NWS fill stacks above terrain instead of under the custom layer — defer sync until the handler settles. */
         let deferNwsSyncUntilNexradReady = false;
         try {
-            if (this._debug) {
-                const tsSummary = state.isMRMS
-                    ? _debugSummarizeNumericSeries(state.availableTimestamps || [])
-                    : null;
-                this._debugLog('state:change', {
-                    seq,
-                    mode: state.isSatellite
-                        ? 'satellite'
-                        : state.isNexrad
-                          ? 'nexrad'
-                          : state.isMRMS
-                            ? 'mrms'
-                            : 'model',
-                    model: state.model,
-                    variable: state.variable,
-                    runKey: `${state.model}-${state.date}-${state.run}-${state.variable}`,
-                    timeKey: state.isMRMS
-                        ? (state.mrmsTimestamp == null ? null : Number(state.mrmsTimestamp))
-                        : Number(state.forecastHour),
-                    mrmsTimestamp: state.mrmsTimestamp,
-                    mrmsDurationValue: state.mrmsDurationValue,
-                    availableTimestampsSummary: tsSummary,
-                    availableHoursLen: Array.isArray(state.availableHours) ? state.availableHours.length : 0,
-                    shaderLayerRunKey: this.shaderLayer?.runKey ?? null,
-                    currentLoadedTimeKey: this.currentLoadedTimeKey,
-                    rebuildId: this.currentRebuildId,
-                    initialGridLoadPending: this._initialGridLoadPending,
-                });
+            if (state.isMRMS) {
+                this._logMrmsTimelineIfEnabled(state);
             }
 
             if (state.isSatellite) {
@@ -325,21 +259,6 @@ export class WeatherLayerManager extends EventEmitter {
                 : Number(state.forecastHour);
             const runKey = `${state.model}-${state.date}-${state.run}-${state.variable}`;
 
-            if (this._debug && state.isMRMS) {
-                this._debugLog('grid path (mrms/model)', {
-                    seq,
-                    prevMrmsDurationValue: prevMrmsDur,
-                    mrmsDurationChanged,
-                    willRebuild: !this.shaderLayer || this.shaderLayer.runKey !== runKey,
-                    willUpdateData:
-                        this.shaderLayer &&
-                        this.shaderLayer.runKey === runKey &&
-                        this.currentLoadedTimeKey !== timeKey,
-                    shaderRunKey: this.shaderLayer?.runKey,
-                    targetRunKey: runKey,
-                });
-            }
-
             if (!this.shaderLayer || this.shaderLayer.runKey !== runKey) {
                 this._rebuildLayerAndPreload(state);
             } else if (this.currentLoadedTimeKey !== timeKey) {
@@ -349,12 +268,6 @@ export class WeatherLayerManager extends EventEmitter {
                     timeKey === this._rebuildTargetTimeKey;
                 if (!duplicateBeforeFirstPaint) {
                     this._updateLayerData(state);
-                } else if (this._debug) {
-                    this._debugLog('skip _updateLayerData (duplicate before first paint)', {
-                        seq,
-                        timeKey,
-                        _rebuildTargetTimeKey: this._rebuildTargetTimeKey,
-                    });
                 }
             }
 
@@ -365,13 +278,6 @@ export class WeatherLayerManager extends EventEmitter {
             }
 
             if (state.isMRMS && this.shaderLayer && mrmsDurationChanged) {
-                if (this._debug) {
-                    this._debugLog('_preloadAllTimeSteps (mrms duration changed)', {
-                        seq,
-                        from: prevMrmsDur,
-                        to: state.mrmsDurationValue,
-                    });
-                }
                 this._preloadAllTimeSteps(state);
             }
         } finally {
@@ -418,12 +324,17 @@ export class WeatherLayerManager extends EventEmitter {
         const enabled = masterEnabled && !isModelMode;
 
         let timelineUnix = null;
+        /** Same list the core uses for the time slider — enables NWS “live edge” (wall clock at latest step) like aguacero-frontend. */
+        let timelineTimes = null;
         if (state.isSatellite) {
             timelineUnix = state.satelliteTimestamp == null ? null : Number(state.satelliteTimestamp);
+            timelineTimes = state.availableSatelliteTimestamps;
         } else if (state.isNexrad) {
             timelineUnix = state.nexradTimestamp == null ? null : Number(state.nexradTimestamp);
+            timelineTimes = state.availableNexradTimestamps;
         } else if (state.isMRMS) {
             timelineUnix = state.mrmsTimestamp == null ? null : Number(state.mrmsTimestamp);
+            timelineTimes = state.availableTimestamps;
         }
 
         if (!this._nwsOverlay) {
@@ -453,7 +364,7 @@ export class WeatherLayerManager extends EventEmitter {
                 ...(wopt.activeOnlyRealtime !== undefined ? { activeOnlyRealtime: wopt.activeOnlyRealtime } : {}),
             },
         });
-        this._nwsOverlay.syncWithMode({ enabled, timelineUnix });
+        this._nwsOverlay.syncWithMode({ enabled, timelineUnix, timelineTimes });
     }
 
     /**
@@ -784,68 +695,10 @@ export class WeatherLayerManager extends EventEmitter {
     // to the core engine. This keeps the API consistent for your users.
 
     async initialize(options) {
-        const t0 =
-            typeof performance !== 'undefined' && typeof performance.now === 'function'
-                ? performance.now()
-                : Date.now();
-        this._debugLog('initialize:start', {
-            autoRefreshEnabled: this.autoRefreshEnabled,
-            autoRefreshIntervalSeconds: this.autoRefreshIntervalSeconds,
-            passedOptions: options && typeof options === 'object' ? { ...options } : options,
-            coreStateBefore: {
-                isMRMS: this.core.state?.isMRMS,
-                variable: this.core.state?.variable,
-                mrmsTimestamp: this.core.state?.mrmsTimestamp,
-                mrmsDurationValue: this.core.state?.mrmsDurationValue,
-            },
-            mrmsStatusVariableLen: this.core.state?.variable
-                ? (this.core.mrmsStatus?.[this.core.state.variable]?.length ?? 'n/a')
-                : 'n/a',
-        });
         if (this.autoRefreshEnabled) {
             this.setAutoRefresh(true, this.autoRefreshIntervalSeconds);
         }
-        try {
-            const result = await this.core.initialize({ ...options, autoRefresh: false });
-            const t1 =
-                typeof performance !== 'undefined' && typeof performance.now === 'function'
-                    ? performance.now()
-                    : Date.now();
-            this._debugLog('initialize:done', {
-                elapsedMs: Math.round(t1 - t0),
-                coreStateAfter: {
-                    isMRMS: this.core.state?.isMRMS,
-                    variable: this.core.state?.variable,
-                    model: this.core.state?.model,
-                    date: this.core.state?.date,
-                    run: this.core.state?.run,
-                    forecastHour: this.core.state?.forecastHour,
-                    mrmsTimestamp: this.core.state?.mrmsTimestamp,
-                    mrmsDurationValue: this.core.state?.mrmsDurationValue,
-                },
-                availableTimestampsSummary: _debugSummarizeNumericSeries(
-                    this._lastEmittedState?.availableTimestamps || [],
-                ),
-                availableHoursLen: Array.isArray(this._lastEmittedState?.availableHours)
-                    ? this._lastEmittedState.availableHours.length
-                    : 0,
-                modelStatusLoaded: this.core.modelStatus != null,
-                mrmsStatusKeys:
-                    this.core.mrmsStatus && typeof this.core.mrmsStatus === 'object'
-                        ? Object.keys(this.core.mrmsStatus).length
-                        : 0,
-                mrmsStatusVariableLen: this.core.state?.variable
-                    ? (this.core.mrmsStatus?.[this.core.state.variable]?.length ?? 0)
-                    : 0,
-            });
-            return result;
-        } catch (err) {
-            this._debugLog('initialize:error', {
-                message: err?.message || String(err),
-                stack: err?.stack,
-            });
-            throw err;
-        }
+        return this.core.initialize({ ...options, autoRefresh: false });
     }
     async setState(newState) { return this.core.setState(newState); }
     play() { this.core.play(); }
@@ -983,17 +836,6 @@ export class WeatherLayerManager extends EventEmitter {
         const out = (timeSteps || [])
             .map(t => Number(t))
             .filter(t => !Number.isNaN(t));
-        if (this._debug && state.isMRMS) {
-            this._debugLog('_collectNormalizedTimelineSteps', {
-                variable: state.variable,
-                mrmsDurationValue: state.mrmsDurationValue,
-                fromStateLen: fromState.length,
-                fromCoreLen: fromCore.length,
-                chosenSource: mrmsTimelineSource || (state.isMRMS ? 'n/a' : 'model'),
-                normalizedLen: out.length,
-                summary: _debugSummarizeNumericSeries(out),
-            });
-        }
         return out;
     }
 
@@ -1008,50 +850,27 @@ export class WeatherLayerManager extends EventEmitter {
             if (mode === 'rebuild') {
                 this._initialGridLoadPending = false;
             }
-            this._debugLog('_runParallelGridFrameLoads:skip', {
-                reason: !times.length ? 'no times' : 'no shaderLayer',
-                mode,
-                rebuildId,
-                timesLen: times.length,
-            });
             return;
         }
 
-        // Number(null) === 0, which is falsy and causes _loadGridData to return null immediately
-        // (the core guards with `if (!mrmsTimestamp) return null`). Treat null as NaN so that
-        // primaryTimeForRebuild falls through to times[0] — the first real MRMS timestamp.
+        // Number(null) === 0 — treat null as NaN. For MRMS, when the active timestep is unset,
+        // prefer the **newest** scan in the timeline (matches AguaceroCore default); model grids
+        // keep using the first forecast hour in the list.
         const _rawFrameTime = state.isMRMS ? state.mrmsTimestamp : state.forecastHour;
         const currentFrameTime = _rawFrameTime == null ? NaN : Number(_rawFrameTime);
-        /** When the active timestep is unset/NaN, paint the first timeline step (legacy single-fetch behavior). */
         let primaryTimeForRebuild = Number.NaN;
         if (mode === 'rebuild') {
-            primaryTimeForRebuild = Number.isFinite(currentFrameTime)
-                ? currentFrameTime
-                : times[0];
+            if (Number.isFinite(currentFrameTime)) {
+                primaryTimeForRebuild = currentFrameTime;
+            } else if (times.length > 0) {
+                const finite = times.map(Number).filter(Number.isFinite);
+                primaryTimeForRebuild = state.isMRMS ? Math.max(...finite) : Number(times[0]);
+            }
         }
         const tsKey = state.isMRMS ? 'mrmsTimestamp' : 'forecastHour';
         const gridModel = state.isMRMS ? 'mrms' : state.model;
         const { gridDef } = this.core._getGridCornersAndDef(gridModel);
 
-        this._debugLog('_runParallelGridFrameLoads', {
-            mode,
-            rebuildId,
-            gridModel,
-            timesLen: times.length,
-            timesSummary: _debugSummarizeNumericSeries(times),
-            currentFrameTime,
-            primaryTimeForRebuild:
-                mode === 'rebuild'
-                    ? Number.isFinite(currentFrameTime)
-                        ? currentFrameTime
-                        : times[0]
-                    : undefined,
-            tsKey,
-            gridNxNy: gridDef?.grid_params
-                ? { nx: gridDef.grid_params.nx, ny: gridDef.grid_params.ny }
-                : null,
-        });
-
         times.forEach((time) => {
             const stateForTime = { ...state, [tsKey]: time };
             this.core._loadGridData(stateForTime)
@@ -1080,21 +899,10 @@ export class WeatherLayerManager extends EventEmitter {
                                     : Number(this.core.state.mrmsTimestamp))
                                 : Number(this.core.state.forecastHour);
                             if (coreTimeKey !== this._rebuildTargetTimeKey) {
-                                this._debugLog('_loadGridData:skip primary (core time drifted vs rebuild target)', {
-                                    time,
-                                    coreTimeKey,
-                                    _rebuildTargetTimeKey: this._rebuildTargetTimeKey,
-                                    rebuildId,
-                                });
                                 return;
                             }
                         }
                         if (!grid?.data) {
-                            this._debugLog('_loadGridData:primary frame missing grid.data', {
-                                time,
-                                rebuildId,
-                                mode,
-                            });
                             this._initialGridLoadPending = false;
                             return;
                         }
@@ -1127,17 +935,9 @@ export class WeatherLayerManager extends EventEmitter {
                             this.currentLoadedTimeKey = time;
                             this.map.triggerRepaint();
                         }
-                    } else if (this._debug && mode === 'append') {
-                        this._debugLog('_loadGridData:empty grid (append)', { time, mode, rebuildId });
                     }
                 })
-                .catch((err) => {
-                    this._debugLog('_loadGridData:error', {
-                        time,
-                        mode,
-                        rebuildId,
-                        message: err?.message || String(err),
-                    });
+                .catch(() => {
                     if (
                         mode === 'rebuild' &&
                         Number.isFinite(primaryTimeForRebuild) &&
@@ -1215,26 +1015,8 @@ export class WeatherLayerManager extends EventEmitter {
         if (timesToLoad.length === 0 && !Number.isNaN(currentFrameTime)) {
             timesToLoad = [currentFrameTime];
         }
-        this._debugLog('_rebuildLayerAndPreload:timeline', {
-            rebuildId,
-            isMRMS: state.isMRMS,
-            variable: state.variable,
-            normalizedLen: normalized.length,
-            normalizedSummary: _debugSummarizeNumericSeries(normalized),
-            currentFrameTime,
-            timesToLoadLen: timesToLoad.length,
-            timesToLoadSummary: _debugSummarizeNumericSeries(timesToLoad),
-            insertBeforeId: beforeId ?? '(stack top)',
-        });
         if (timesToLoad.length === 0) {
             this._initialGridLoadPending = false;
-            this._debugLog('_rebuildLayerAndPreload:no times to load — check availableTimestamps / duration window', {
-                rebuildId,
-                availableTimestampsLen: Array.isArray(state.availableTimestamps)
-                    ? state.availableTimestamps.length
-                    : 0,
-                mrmsDurationValue: state.mrmsDurationValue,
-            });
             return;
         }
 
@@ -1249,21 +1031,11 @@ export class WeatherLayerManager extends EventEmitter {
         const currentFrameTime = _rawPft == null ? NaN : Number(_rawPft);
         const stepsToPreload = normalized.filter(t => t !== currentFrameTime);
 
-        this._debugLog('_preloadAllTimeSteps', {
-            normalizedLen: normalized.length,
-            currentFrameTime,
-            stepsToPreloadLen: stepsToPreload.length,
-            stepsSummary: _debugSummarizeNumericSeries(stepsToPreload),
-        });
-
         if (normalized.length === 0) {
             return;
         }
 
         if (stepsToPreload.length === 0) {
-            this._debugLog('_preloadAllTimeSteps:skip (nothing to preload besides current)', {
-                currentFrameTime,
-            });
             return;
         }
 
@@ -1510,7 +1282,6 @@ export class WeatherLayerManager extends EventEmitter {
      * Cleans up all resources.
      */
     destroy() {
-        this._debugLog('destroy');
         this.setAutoRefresh(false);
         
         // 1. Unbind the map's mousemove event listener

package/src/nwsAlertsSupport.js

@@ -442,6 +442,98 @@ export function getNwsAlertInstanceIdFromFeature(feature) {
     );
 }
 
+/**
+ * SVR revision visibility: superseded geometry only before cutover unix; updated geometry only at/after cutover.
+ * Returns null when this feature does not use revision split (fall back to start_unix / end_unix).
+ * Matches aguacero-frontend {@link nwsRevisionVisibilityActive}.
+ */
+export function nwsRevisionVisibilityActive(properties, referenceUnix) {
+    if (!properties) return null;
+    const role = properties._nws_revision_role;
+    const cut = properties._nws_revision_cutover_unix;
+    if (cut == null || typeof cut !== 'number' || !role) return null;
+    if (role === 'superseded') {
+        return referenceUnix < cut;
+    }
+    if (role === 'update') {
+        return referenceUnix >= cut;
+    }
+    if (role === 'current') {
+        return null;
+    }
+    return null;
+}
+
+/** nwws-server stores ids as `${vtecBaseId}.${issuedTs}`; strip the issued suffix for revision grouping. */
+function stripNwwsIssuedMillisSuffixFromId(id) {
+    const m = String(id).match(/^(.+)\.(\d{10,})$/);
+    return m ? m[1] : id;
+}
+
+/**
+ * One key per logical warning product (VTEC sequence / base id). Matches aguacero-frontend
+ * {@link getNwwsLogicalProductKey} for deduping superseded vs update rows on the time slider.
+ */
+export function getNwwsLogicalProductKey(feature) {
+    const p = feature?.properties ?? {};
+    const params = p.parameters;
+    const vtecRaw = params != null && typeof params === 'object' && !Array.isArray(params) ? params.VTEC : undefined;
+    const vtec = Array.isArray(vtecRaw)
+        ? vtecRaw[0]
+        : p.vtec ?? (p.details && typeof p.details === 'object' ? p.details.pvtec : undefined);
+    if (typeof vtec === 'string' && vtec.trim()) {
+        const parts = vtec.split('.');
+        if (parts.length >= 6) {
+            return `${parts[2]}.${parts[3]}.${parts[4]}.${parts[5]}`;
+        }
+    }
+    const base = getNwsBaseAlertIdFromFeature(feature);
+    if (base) return stripNwwsIssuedMillisSuffixFromId(base);
+    if (feature?.id != null && feature.id !== '') return stripNwwsIssuedMillisSuffixFromId(String(feature.id));
+    return null;
+}
+
+export function getNwwsProductKeyFromFeature(feature) {
+    const pk = feature?.properties?.nws_product_key;
+    if (typeof pk === 'string' && pk.trim() !== '') return pk.trim();
+    return getNwwsLogicalProductKey(feature);
+}
+
+/**
+ * When superseded + update rows both pass time checks, pick one per reference instant (same product key).
+ * Matches aguacero-frontend {@link pickBestNwsRevisionAmongConflictingFeatures}.
+ */
+export function pickBestNwsRevisionAmongConflictingFeatures(features, referenceUnix) {
+    if (!Array.isArray(features) || features.length === 0) return null;
+    if (features.length === 1) return features[0];
+    const scored = features.map((f) => {
+        const p = f?.properties ?? {};
+        const role = String(p._nws_revision_role ?? '');
+        const cut =
+            typeof p._nws_revision_cutover_unix === 'number' && Number.isFinite(p._nws_revision_cutover_unix)
+                ? p._nws_revision_cutover_unix
+                : null;
+        let slotScore = 0;
+        if (role === 'superseded' && cut != null) {
+            slotScore = referenceUnix < cut ? 2 : 0;
+        } else if (role === 'update' && cut != null) {
+            slotScore = referenceUnix >= cut ? 2 : 0;
+        } else if (role === 'current') {
+            slotScore = 1;
+        } else {
+            slotScore = 1;
+        }
+        const t =
+            parseNwsTimeToUnix(getNwsTimeProp(p, ['sent', 'updated_at', 'issued_at', 'issued'])) ?? 0;
+        return { f, slotScore, t };
+    });
+    scored.sort((a, b) => {
+        if (b.slotScore !== a.slotScore) return b.slotScore - a.slotScore;
+        return b.t - a.t;
+    });
+    return scored[0].f;
+}
+
 export function isUsableNwwsAlertGeometry(geometry) {
     if (geometry == null || typeof geometry !== 'object') return false;
     const g = geometry;