@aguacerowx/mapsgl 0.0.49 → 0.0.51

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(); }
@@ -892,14 +745,6 @@ export class WeatherLayerManager extends EventEmitter {
     async setNexradProduct(product) {
         return this.core.setNexradProduct(product);
     }
-    /** @param {'level2'|'level3'} dataSource @param {string} product */
-    async setNexradProductMode(dataSource, product) {
-        return this.core.setNexradProductMode(dataSource, product);
-    }
-    /** @param {'level2'|'level3'} source */
-    async setNexradDataSource(source) {
-        return this.core.setNexradDataSource(source);
-    }
     async setNexradTilt(tilt) {
         return this.core.setNexradTilt(tilt);
     }
@@ -983,17 +828,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 +842,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 +891,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 +927,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 +1007,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 +1023,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 +1274,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