@aguacerowx/javascript-sdk 0.0.18 → 0.0.20

package/src/AguaceroCore.js

@@ -7,7 +7,31 @@ import { getUnitConversionFunction } from './unitConversions.js';
 import { DICTIONARIES, MODEL_CONFIGS } from './dictionaries.js';
 import { DEFAULT_COLORMAPS } from './default-colormaps.js';
 import proj4 from 'proj4';
+import { processCompressedGrid } from './gridDecodePipeline.js';
 import { getBundleId } from './getBundleId';
+import {
+    SATELLITE_FRAMES_URL,
+    buildSatelliteTimelineForKey,
+    SATELLITE_DURATION_CONFIG,
+    TIMELINE_DURATION_HOUR_VALUES,
+    normalizeTimelineDurationValue,
+    parseTimelineDurationHours,
+} from './satellite_support.js';
+import {
+    fetchNexradTimesListing,
+    nexradColormapFldKey,
+    variableToNexradGroup,
+    getAvailableNexradTilts,
+} from './nexrad_support.js';
+import { NEXRAD_LEVEL3_ELEV, getNexradLevel3EntryByRadarKey } from './nexrad_level3_catalog.js';
+import {
+    setRadarTiltsManifest,
+    fetchRadarTiltsManifestFromNetwork,
+    getDefaultRadarTilt,
+    formatTiltForApi,
+    clampNexradTiltForVariable,
+    getRadarTilts,
+} from './nexradTilts.js';
 
 // --- Non-UI Helper Functions ---
 function hrdpsObliqueTransform(rotated_lon, rotated_lat) {
@@ -41,26 +65,67 @@ function findLatestModelRun(modelsData, modelName) {
     return null;
 }
 
+/**
+ * model-status JSON uses string keys for runs (often zero-padded: "00", "06").
+ * Direct lookup modelStatus[model][date][run] fails if state.run is "6" but the key is "06".
+ * Returns the hour list and the run key that matched.
+ */
+function resolveModelRunHours(modelStatus, model, date, run) {
+    const runs = modelStatus?.[model]?.[date];
+    if (!runs || run == null || run === '') {
+        return {
+            hours: [],
+            matchedRunKey: null,
+            availableRunKeys: runs ? Object.keys(runs) : [],
+        };
+    }
+    const runStr = String(run);
+    const candidates = new Set([runStr]);
+    const n = parseInt(runStr, 10);
+    if (!Number.isNaN(n)) {
+        candidates.add(String(n));
+        candidates.add(String(n).padStart(2, '0'));
+        candidates.add(String(n).padStart(3, '0'));
+    }
+    for (const key of candidates) {
+        const h = runs[key];
+        if (h && Array.isArray(h) && h.length > 0) {
+            return { hours: h, matchedRunKey: key, availableRunKeys: Object.keys(runs) };
+        }
+    }
+    if (!Number.isNaN(n)) {
+        for (const k of Object.keys(runs)) {
+            const kn = parseInt(k, 10);
+            if (!Number.isNaN(kn) && kn === n) {
+                const h = runs[k];
+                if (h && Array.isArray(h) && h.length > 0) {
+                    return { hours: h, matchedRunKey: k, availableRunKeys: Object.keys(runs) };
+                }
+            }
+        }
+    }
+    return { hours: [], matchedRunKey: null, availableRunKeys: Object.keys(runs) };
+}
+
 export class AguaceroCore extends EventEmitter {
     constructor(options = {}) {
         super();
         this.isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
         this.apiKey = options.apiKey;
+        /** Passed as CloudFront `userId` for satellite KTX2 URLs (production uses the authenticated account id). */
+        this.userId = options.userId ?? 'sdk-user';
         this.bundleId = getBundleId();
         this.baseGridUrl = 'https://d3dc62msmxkrd7.cloudfront.net';
-        if (!this.isReactNative) {
-            this.worker = this.createWorker();
-            this.workerRequestId = 0;
-            this.workerResolvers = new Map();
-            this.worker.addEventListener('message', this._handleWorkerMessage.bind(this));
-            this.resultQueue = [];
-            this.isProcessingQueue = false;
-        } else {
-            this.worker = null;
-        }
+        /** @type {Worker | null} */
+        this._gridDecodeWorker = null;
+        /** When true, skip Worker and use {@link processCompressedGrid} on the main thread. */
+        this._gridDecodeWorkerDisabled = false;
+        this._gridDecodeMsgId = 0;
         this.statusUrl = 'https://d3dc62msmxkrd7.cloudfront.net/model-status';
         this.modelStatus = null;
         this.mrmsStatus = null;
+        /** @type {{ objects?: Array<{ key: string }> } | null} */
+        this.satelliteListing = null;
         this.dataCache = new Map();
         this.abortControllers = new Map();
         this.isPlaying = false;
@@ -73,31 +138,213 @@ export class AguaceroCore extends EventEmitter {
         const initialMode = userLayerOptions.mode || 'model';
         const initialVariable = userLayerOptions.variable || null;
 
+        const initialSatellite = initialMode === 'satellite';
+        const initialNexrad = initialMode === 'nexrad';
+        const initialNexradDs = userLayerOptions.nexradDataSource || 'level2';
+        const initialNexradProd = userLayerOptions.nexradProduct || 'REF';
+        const initialNexradFld = initialNexrad
+            ? nexradColormapFldKey(initialNexradDs, initialNexradProd)
+            : initialVariable;
         this.state = {
             model: userLayerOptions.model || 'gfs',
             // EDIT: Set isMRMS based on the initial mode
-            isMRMS: initialMode === 'mrms',
+            isMRMS: initialMode === 'mrms' && !initialSatellite && !initialNexrad,
             mrmsTimestamp: null,
-            variable: initialVariable,
+            variable: initialNexrad ? initialNexradFld : initialVariable,
             date: null,
             run: null,
             forecastHour: 0,
             visible: true,
             opacity: userLayerOptions.opacity ?? 1,
             units: options.initialUnit || 'imperial',
-            shaderSmoothingEnabled: options.shaderSmoothingEnabled ?? true
+            shaderSmoothingEnabled: options.shaderSmoothingEnabled ?? true,
+            isSatellite: initialSatellite,
+            satelliteKey: userLayerOptions.satelliteKey || null,
+            satelliteTimestamp: userLayerOptions.satelliteTimestamp != null ? Number(userLayerOptions.satelliteTimestamp) : null,
+            satelliteTier: userLayerOptions.satelliteTier || 'basic',
+            satelliteDurationValue: (() => {
+                const n = normalizeTimelineDurationValue(
+                    userLayerOptions.satelliteDurationValue != null ? userLayerOptions.satelliteDurationValue : '1'
+                );
+                return TIMELINE_DURATION_HOUR_VALUES.includes(n) ? n : '1';
+            })(),
+            mrmsDurationValue: (() => {
+                const n = normalizeTimelineDurationValue(
+                    userLayerOptions.mrmsDurationValue != null ? userLayerOptions.mrmsDurationValue : '1'
+                );
+                return TIMELINE_DURATION_HOUR_VALUES.includes(n) ? n : '1';
+            })(),
+            isNexrad: initialNexrad,
+            nexradSite: userLayerOptions.nexradSite ?? null,
+            nexradDataSource: initialNexradDs,
+            nexradProduct: initialNexradProd,
+            nexradTilt:
+                userLayerOptions.nexradTilt != null
+                    ? Number(userLayerOptions.nexradTilt)
+                    : userLayerOptions.nexradSite
+                      ? getDefaultRadarTilt(userLayerOptions.nexradSite)
+                      : null,
+            nexradTimestamp: userLayerOptions.nexradTimestamp != null ? Number(userLayerOptions.nexradTimestamp) : null,
+            nexradStormRelative: userLayerOptions.nexradStormRelative === true,
+            /** When true, mapsgl shows clickable NEXRAD site markers (independent of selected site). */
+            nexradShowSitesPicker: userLayerOptions.nexradShowSitesPicker !== false,
         };
 
         this.autoRefreshEnabled = options.autoRefresh ?? false;
         this.autoRefreshIntervalSeconds = options.autoRefreshInterval ?? 60;
         this.autoRefreshIntervalId = null;
+
+        /** @type {Record<string, { unixTimes?: number[]; timeToKeyMap?: Record<string, string>; listWindowHours?: number }>} */
+        this.nexradTimesByStation = {};
     }
 
     async setState(newState) {
-        Object.assign(this.state, newState);
+        const patch = { ...newState };
+        if ('forecastHour' in patch && patch.forecastHour != null) {
+            patch.forecastHour = Number(patch.forecastHour);
+        }
+        if ('mrmsTimestamp' in patch && patch.mrmsTimestamp != null) {
+            patch.mrmsTimestamp = Number(patch.mrmsTimestamp);
+        }
+        if ('satelliteTimestamp' in patch && patch.satelliteTimestamp != null) {
+            patch.satelliteTimestamp = Number(patch.satelliteTimestamp);
+        }
+        if ('satelliteDurationValue' in patch && patch.satelliteDurationValue != null) {
+            const n = normalizeTimelineDurationValue(patch.satelliteDurationValue);
+            patch.satelliteDurationValue = TIMELINE_DURATION_HOUR_VALUES.includes(n) ? n : '1';
+        }
+        if ('mrmsDurationValue' in patch && patch.mrmsDurationValue != null) {
+            const n = normalizeTimelineDurationValue(patch.mrmsDurationValue);
+            patch.mrmsDurationValue = TIMELINE_DURATION_HOUR_VALUES.includes(n) ? n : '1';
+        }
+        if ('nexradTimestamp' in patch && patch.nexradTimestamp != null) {
+            patch.nexradTimestamp = Number(patch.nexradTimestamp);
+        }
+        if ('nexradTilt' in patch && patch.nexradTilt != null) {
+            patch.nexradTilt = Number(patch.nexradTilt);
+        }
+        Object.assign(this.state, patch);
         this._emitStateChange();
     }
 
+    /**
+     * Forecast hours for the current model/date/run (normalized numbers).
+     * Tolerates model-status run keys like "06" vs state.run "6" so preload and slider stay in sync.
+     */
+    getAvailableForecastHours() {
+        if (this.state.isMRMS || this.state.isSatellite || this.state.isNexrad) return [];
+        if (!this.state.model || this.state.date == null || this.state.run == null) return [];
+
+        const resolved = resolveModelRunHours(
+            this.modelStatus,
+            this.state.model,
+            this.state.date,
+            this.state.run
+        );
+        let hours = resolved.hours || [];
+
+        if (hours.length > 0) {
+            hours = hours.map(h => (typeof h === 'string' ? parseInt(h, 10) : Number(h))).filter(h => !Number.isNaN(h));
+        }
+        if (this.state.variable === 'ptypeRefl' && this.state.model === 'hrrr' && hours.length > 0) {
+            hours = hours.filter(hour => hour !== 0);
+        }
+        return hours;
+    }
+
+    _computeSatelliteTimeline() {
+        if (!this.state.satelliteKey || !this.satelliteListing?.objects) {
+            return { unixTimes: [], timeToFileMap: {} };
+        }
+        const allFiles = this.satelliteListing.objects.map((o) => o.key);
+        const sectorName = this.state.satelliteKey.split('.')[1] || 'GOES-EAST CONUS';
+        let sectorType = 'CONUS';
+        if (sectorName.includes('FULL DISK')) sectorType = 'FULL_DISK';
+        else if (sectorName.includes('MESOSCALE')) sectorType = 'MESOSCALE';
+        const tier = this.state.satelliteTier || 'basic';
+        const tierConfig =
+            SATELLITE_DURATION_CONFIG[sectorType]?.[tier] || SATELLITE_DURATION_CONFIG.CONUS.basic;
+        const durationKey = normalizeTimelineDurationValue(this.state.satelliteDurationValue);
+        const durationOpt =
+            tierConfig.find((o) => String(o.value) === String(durationKey)) ||
+            tierConfig.find((o) => o.value === '1') ||
+            tierConfig[0];
+        return buildSatelliteTimelineForKey(this.state.satelliteKey, allFiles, durationOpt);
+    }
+
+    /**
+     * MRMS timestamps for a variable, oldest first (matches satellite timelines and left→right time sliders).
+     * Limited to the last N hours relative to the newest frame (see mrmsDurationValue).
+     * @param {string} variable
+     * @returns {number[]}
+     */
+    _getFilteredMrmsTimestampsForVariable(variable) {
+        const raw = this.mrmsStatus?.[variable];
+        if (!raw || !raw.length) return [];
+        const hours = parseTimelineDurationHours(this.state.mrmsDurationValue);
+        let list = [...raw]
+            .map((t) => Number(t))
+            .filter((t) => !Number.isNaN(t))
+            .sort((a, b) => a - b);
+        if (hours > 0 && list.length > 0) {
+            const latest = list[list.length - 1];
+            const cutoff = latest - hours * 3600;
+            list = list.filter((t) => t >= cutoff);
+        }
+        return list;
+    }
+
+    _nexradListingWindowHours() {
+        return parseTimelineDurationHours(this.state.mrmsDurationValue);
+    }
+
+    _getFilteredNexradTimestampsForVariable(rawList) {
+        if (!rawList || !rawList.length) return [];
+        const hours = this._nexradListingWindowHours();
+        let list = [...rawList]
+            .map((t) => Number(t))
+            .filter((t) => !Number.isNaN(t))
+            .sort((a, b) => a - b);
+        if (hours > 0 && list.length > 0) {
+            const latest = list[list.length - 1];
+            const cutoff = latest - hours * 3600;
+            list = list.filter((t) => t >= cutoff);
+        }
+        return list;
+    }
+
+    /**
+     * Cache key for {@link this.nexradTimesByStation} — matches frontend composite keys (tilt + variable group/source).
+     */
+    _nexradTimesCacheKey() {
+        const s = this.state;
+        if (!s.isNexrad || !s.nexradSite) return null;
+        const site = s.nexradSite;
+        const variable = s.nexradProduct || 'REF';
+        const ds = s.nexradDataSource || 'level2';
+        const tiltNum = s.nexradTilt != null ? s.nexradTilt : getDefaultRadarTilt(site);
+        const elevNormUse =
+            ds === 'level3'
+                ? NEXRAD_LEVEL3_ELEV
+                : formatTiltForApi(clampNexradTiltForVariable(site, variable, tiltNum));
+        const group = ds === 'level3' ? 'l3' : variableToNexradGroup(variable);
+        const l3Product =
+            ds === 'level3'
+                ? getNexradLevel3EntryByRadarKey(variable)?.product ?? (variable === 'VEL' ? 'N0G' : variable)
+                : '';
+        if (ds === 'level3') {
+            return `${site}_l3_${l3Product}_${elevNormUse}`;
+        }
+        return `${site}_${group}_${elevNormUse}`;
+    }
+
+    /** Storm-relative Level-III velocity (N0G + N0S) — matches aguacero-frontend `level3StormRelative` for VEL. */
+    _nexradStormRelativeFor(nexradDataSource, nexradProduct) {
+        const ds = nexradDataSource === 'level3' ? 'level3' : 'level2';
+        const p = (nexradProduct || 'REF').toUpperCase();
+        return ds === 'level3' && p === 'VEL';
+    }
+
     _emitStateChange() {
         const { colormap, baseUnit } = this._getColormapForVariable(this.state.variable);
         const toUnit = this._getTargetUnit(baseUnit, this.state.units);
@@ -105,18 +352,40 @@ export class AguaceroCore extends EventEmitter {
 
         let availableTimestamps = [];
         if (this.state.isMRMS && this.state.variable && this.mrmsStatus) {
-            const timestamps = this.mrmsStatus[this.state.variable] || [];
-            availableTimestamps = [...timestamps].reverse();
+            availableTimestamps = this._getFilteredMrmsTimestampsForVariable(this.state.variable);
         }
 
-        let availableHours = this.state.isMRMS 
-            ? [] 
-            : (this.modelStatus?.[this.state.model]?.[this.state.date]?.[this.state.run] || []);
-        
-        if (!this.state.isMRMS && this.state.variable === 'ptypeRefl' && this.state.model === 'hrrr' && availableHours.length > 0) {
-            availableHours = availableHours.filter(hour => hour !== 0);
+        let availableSatelliteTimestamps = [];
+        let satelliteTimeToFileMap = {};
+        if (this.state.isSatellite && this.state.satelliteKey) {
+            const timeline = this._computeSatelliteTimeline();
+            satelliteTimeToFileMap = timeline.timeToFileMap || {};
+            availableSatelliteTimestamps = [...(timeline.unixTimes || [])]
+                .map((t) => Number(t))
+                .filter((t) => !Number.isNaN(t))
+                .sort((a, b) => a - b);
+        }
+
+        let availableNexradTimestamps = [];
+        let nexradTimeToKeyMap = {};
+        let nexradLevel3MotionTimeToKeyMap = {};
+        let availableNexradTilts = [];
+        if (this.state.isNexrad && this.state.nexradSite) {
+            const nk = this._nexradTimesCacheKey();
+            const ent = nk ? this.nexradTimesByStation[nk] : null;
+            const raw = ent?.unixTimes || [];
+            availableNexradTimestamps = this._getFilteredNexradTimestampsForVariable(raw);
+            nexradTimeToKeyMap = ent?.timeToKeyMap || {};
+            nexradLevel3MotionTimeToKeyMap = ent?.level3MotionTimeToKeyMap || {};
+            availableNexradTilts = getAvailableNexradTilts(
+                this.state.nexradSite,
+                this.state.nexradDataSource || 'level2',
+                this.state.nexradProduct || 'REF',
+            );
         }
 
+        const availableHours = this.getAvailableForecastHours();
+
         const eventPayload = {
             ...this.state,
             availableModels: this.modelStatus ? Object.keys(this.modelStatus).sort() : [],
@@ -126,6 +395,12 @@ export class AguaceroCore extends EventEmitter {
             // We need to confirm this line is working as expected.
             availableMRMSVariables: this.getAvailableVariables('mrms'),
             availableTimestamps: availableTimestamps,
+            availableSatelliteTimestamps,
+            satelliteTimeToFileMap,
+            availableNexradTimestamps,
+            nexradTimeToKeyMap,
+            nexradLevel3MotionTimeToKeyMap,
+            availableNexradTilts,
             isPlaying: this.isPlaying,
             colormap: displayColormap,
             colormapBaseUnit: toUnit,
@@ -137,27 +412,36 @@ export class AguaceroCore extends EventEmitter {
     async initialize(options = {}) {
         await this.fetchModelStatus(true);
         await this.fetchMRMSStatus(true);
-        
+        await this.fetchSatelliteListing(true);
+
         let initialState = { ...this.state };
 
+        if (initialState.isSatellite && initialState.satelliteKey) {
+            const timeline = this._computeSatelliteTimeline();
+            const tsList = [...(timeline.unixTimes || [])].sort((a, b) => a - b);
+            if (initialState.satelliteTimestamp == null && tsList.length > 0) {
+                initialState.satelliteTimestamp = tsList[tsList.length - 1];
+            }
+        }
+
         // ADD: Logic to handle an initial MRMS state
         if (initialState.isMRMS) {
             const variable = initialState.variable;
             if (variable && this.mrmsStatus && this.mrmsStatus[variable]) {
-                const sortedTimestamps = [...(this.mrmsStatus[variable] || [])].sort((a, b) => b - a);
-                initialState.mrmsTimestamp = sortedTimestamps.length > 0 ? sortedTimestamps[0] : null;
+                const sortedTimestamps = this._getFilteredMrmsTimestampsForVariable(variable);
+                initialState.mrmsTimestamp =
+                    sortedTimestamps.length > 0 ? sortedTimestamps[sortedTimestamps.length - 1] : null;
             } else {
-                // Fallback if the provided variable is not valid
-                console.warn(`Initial MRMS variable '${variable}' not found. Using default.`);
                 const availableMRMSVars = this.getAvailableVariables('mrms');
                 if (availableMRMSVars.length > 0) {
                     const firstVar = availableMRMSVars[0];
                     initialState.variable = firstVar;
-                    const sortedTimestamps = [...(this.mrmsStatus[firstVar] || [])].sort((a, b) => b - a);
-                    initialState.mrmsTimestamp = sortedTimestamps.length > 0 ? sortedTimestamps[0] : null;
+                    const sortedTimestamps = this._getFilteredMrmsTimestampsForVariable(firstVar);
+                    initialState.mrmsTimestamp =
+                        sortedTimestamps.length > 0 ? sortedTimestamps[sortedTimestamps.length - 1] : null;
                 }
             }
-        } else {
+        } else if (!initialState.isSatellite && !initialState.isNexrad) {
             // EDIT: This is the existing logic, now in an else block
             const latestRun = findLatestModelRun(this.modelStatus, initialState.model);
             if (latestRun) {
@@ -172,6 +456,14 @@ export class AguaceroCore extends EventEmitter {
         }
 
         await this.setState(initialState);
+
+        if (this.state.isNexrad) {
+            const manifest = await fetchRadarTiltsManifestFromNetwork();
+            if (manifest) setRadarTiltsManifest(manifest);
+            if (this.state.nexradSite) {
+                await this.refreshNexradTimes();
+            }
+        }
         if (options.autoRefresh ?? this.autoRefreshEnabled) {
             this.startAutoRefresh(options.refreshInterval ?? this.autoRefreshIntervalSeconds);
         }
@@ -181,11 +473,11 @@ export class AguaceroCore extends EventEmitter {
         this.pause();
         this.stopAutoRefresh();
         this.dataCache.clear();
-        if (this.worker) {
-            this.worker.terminate();
-        }
         this.callbacks = {};
-        console.log(`AguaceroCore has been destroyed.`);
+        if (this._gridDecodeWorker) {
+            this._gridDecodeWorker.terminate();
+            this._gridDecodeWorker = null;
+        }
     }
 
     // --- Public API Methods ---
@@ -213,24 +505,40 @@ export class AguaceroCore extends EventEmitter {
     }
 
     step(direction = 1) {
+        if (this.state.isSatellite) {
+            const timeline = this._computeSatelliteTimeline();
+            const availableTimestamps = [...(timeline.unixTimes || [])]
+                .sort((a, b) => a - b)
+                .map((t) => Number(t));
+            if (availableTimestamps.length === 0) return;
+
+            const ts = this.state.satelliteTimestamp == null ? null : Number(this.state.satelliteTimestamp);
+            const currentIndex = ts == null ? -1 : availableTimestamps.indexOf(ts);
+
+            let nextIndex = currentIndex === -1 ? availableTimestamps.length - 1 : currentIndex + direction;
+            const maxIndex = availableTimestamps.length - 1;
+            if (nextIndex > maxIndex) nextIndex = 0;
+            if (nextIndex < 0) nextIndex = maxIndex;
+
+            this.setState({ satelliteTimestamp: availableTimestamps[nextIndex] });
+            return;
+        }
         // --- THIS IS THE CORRECTED MRMS LOGIC ---
         if (this.state.isMRMS) {
             const { variable, mrmsTimestamp } = this.state;
             if (!this.mrmsStatus || !this.mrmsStatus[variable]) {
-                console.warn('[Core.step] MRMS status or variable not available.');
                 return;
             }
-            
-            // CRITICAL FIX: The UI and state emissions use a REVERSED array (newest first).
-            // The step logic MUST use the same reversed array for indexes to match.
-            const availableTimestamps = [...(this.mrmsStatus[variable] || [])].reverse();
+
+            const availableTimestamps = this._getFilteredMrmsTimestampsForVariable(variable);
             if (availableTimestamps.length === 0) return;
 
-            const currentIndex = availableTimestamps.indexOf(mrmsTimestamp);
+            const ts = mrmsTimestamp == null ? null : Number(mrmsTimestamp);
+            const currentIndex = ts == null ? -1 : availableTimestamps.indexOf(ts);
 
             if (currentIndex === -1) {
-                // If not found, reset to the first (newest) frame
-                this.setState({ mrmsTimestamp: availableTimestamps[0] });
+                // If not found, reset to the latest frame (end of ascending list)
+                this.setState({ mrmsTimestamp: availableTimestamps[availableTimestamps.length - 1] });
                 return;
             }
 
@@ -244,12 +552,28 @@ export class AguaceroCore extends EventEmitter {
             const newTimestamp = availableTimestamps[nextIndex];
             this.setState({ mrmsTimestamp: newTimestamp });
 
+        } else if (this.state.isNexrad) {
+            const nk = this._nexradTimesCacheKey();
+            const raw = nk ? this.nexradTimesByStation[nk]?.unixTimes : [];
+            const availableTimestamps = this._getFilteredNexradTimestampsForVariable(raw || []);
+            if (availableTimestamps.length === 0) return;
+
+            const ts = this.state.nexradTimestamp == null ? null : Number(this.state.nexradTimestamp);
+            const currentIndex = ts == null ? -1 : availableTimestamps.indexOf(ts);
+
+            let nextIndex = currentIndex === -1 ? availableTimestamps.length - 1 : currentIndex + direction;
+            const maxIndex = availableTimestamps.length - 1;
+            if (nextIndex > maxIndex) nextIndex = 0;
+            if (nextIndex < 0) nextIndex = maxIndex;
+
+            this.setState({ nexradTimestamp: availableTimestamps[nextIndex] });
         } else {
-            const { model, date, run, forecastHour } = this.state;
-            const forecastHours = this.modelStatus?.[model]?.[date]?.[run];
+            const { forecastHour } = this.state;
+            const forecastHours = this.getAvailableForecastHours();
             if (!forecastHours || forecastHours.length === 0) return;
 
-            const currentIndex = forecastHours.indexOf(forecastHour);
+            const fh = Number(forecastHour);
+            const currentIndex = forecastHours.indexOf(fh);
             if (currentIndex === -1) return;
 
             const maxIndex = forecastHours.length - 1;
@@ -283,7 +607,12 @@ export class AguaceroCore extends EventEmitter {
     async setVariable(variable) {
         // --- NEW CODE: Handle switching TO ptypeRefl on HRRR ---
         if (variable === 'ptypeRefl' && this.state.model === 'hrrr' && this.state.forecastHour === 0) {
-            const availableHours = this.modelStatus?.[this.state.model]?.[this.state.date]?.[this.state.run] || [];
+            const availableHours = resolveModelRunHours(
+                this.modelStatus,
+                this.state.model,
+                this.state.date,
+                this.state.run
+            ).hours || [];
             const firstValidHour = availableHours.find(hour => hour !== 0) || 0;
             await this.setState({ variable, forecastHour: firstValidHour });
             return;
@@ -295,6 +624,9 @@ export class AguaceroCore extends EventEmitter {
     
     async setModel(modelName) {
         if (modelName === this.state.model || !this.modelStatus?.[modelName]) return;
+        if (this.state.isSatellite) {
+            await this.setState({ isSatellite: false, satelliteKey: null, satelliteTimestamp: null });
+        }
         const latestRun = findLatestModelRun(this.modelStatus, modelName);
         if (latestRun) {
             // --- NEW CODE: Determine initial forecast hour ---
@@ -302,8 +634,12 @@ export class AguaceroCore extends EventEmitter {
             
             // If switching to HRRR with ptypeRefl, start at hour 1 instead of 0
             if (modelName === 'hrrr' && this.state.variable === 'ptypeRefl') {
-                const availableHours = this.modelStatus?.[modelName]?.[latestRun.date]?.[latestRun.run] || [];
-                // Find the first valid hour (should be 1)
+                const availableHours = resolveModelRunHours(
+                    this.modelStatus,
+                    modelName,
+                    latestRun.date,
+                    latestRun.run
+                ).hours || [];
                 initialHour = availableHours.find(hour => hour !== 0) || 0;
             }
             // --- END NEW CODE ---
@@ -330,12 +666,16 @@ export class AguaceroCore extends EventEmitter {
     }
     
     async setMRMSVariable(variable) {
-        const sortedTimestamps = [...(this.mrmsStatus[variable] || [])].sort((a, b) => b - a);
-        const initialTimestamp = sortedTimestamps.length > 0 ? sortedTimestamps[0] : null;
+        const sortedTimestamps = this._getFilteredMrmsTimestampsForVariable(variable);
+        const initialTimestamp =
+            sortedTimestamps.length > 0 ? sortedTimestamps[sortedTimestamps.length - 1] : null;
 
         await this.setState({
             variable,
             isMRMS: true,
+            isSatellite: false,
+            satelliteKey: null,
+            satelliteTimestamp: null,
             mrmsTimestamp: initialTimestamp,
         });
     }
@@ -345,33 +685,148 @@ export class AguaceroCore extends EventEmitter {
         await this.setState({ mrmsTimestamp: timestamp });
     }
 
+    async setSatelliteTimestamp(timestamp) {
+        if (!this.state.isSatellite) return;
+        await this.setState({ satelliteTimestamp: timestamp != null ? Number(timestamp) : null });
+    }
+
+    /**
+     * How many hours of satellite frames to include in the timeline (1, 4, 6, or 12).
+     * API default: `layerOptions.satelliteDurationValue` on construction.
+     */
+    async setSatelliteDurationValue(value) {
+        const v = normalizeTimelineDurationValue(value);
+        if (!TIMELINE_DURATION_HOUR_VALUES.includes(v)) return;
+        await this.setState({ satelliteDurationValue: v });
+        if (!this.state.isSatellite || !this.state.satelliteKey) return;
+        const timeline = this._computeSatelliteTimeline();
+        const tsList = [...(timeline.unixTimes || [])]
+            .map((t) => Number(t))
+            .filter((t) => !Number.isNaN(t))
+            .sort((a, b) => a - b);
+        if (tsList.length === 0) return;
+        const cur = this.state.satelliteTimestamp;
+        const curN = cur == null ? null : Number(cur);
+        if (curN == null || !tsList.includes(curN)) {
+            await this.setState({ satelliteTimestamp: tsList[tsList.length - 1] });
+        }
+    }
+
+    /**
+     * How many hours of MRMS frames to include in the timeline (1, 4, 6, or 12).
+     * API default: `layerOptions.mrmsDurationValue` on construction.
+     */
+    async setMRMSDurationValue(value) {
+        const v = normalizeTimelineDurationValue(value);
+        if (!TIMELINE_DURATION_HOUR_VALUES.includes(v)) return;
+        await this.setState({ mrmsDurationValue: v });
+        // NEXRAD listings are fetched with `hours` from this value (see _nexradListingWindowHours). Without a
+        // refresh, expanding 1h→4h only re-filters the old in-memory sweep list — new frames never appear until
+        // site/product changes trigger refreshNexradTimes.
+        if (this.state.isNexrad && this.state.nexradSite) {
+            await this.refreshNexradTimes();
+            const nk = this._nexradTimesCacheKey();
+            const filtered = this._getFilteredNexradTimestampsForVariable(
+                nk ? this.nexradTimesByStation[nk]?.unixTimes || [] : [],
+            );
+            if (filtered.length === 0) return;
+            const cur = this.state.nexradTimestamp;
+            const curN = cur == null ? null : Number(cur);
+            if (curN == null || !filtered.includes(curN)) {
+                await this.setState({ nexradTimestamp: filtered[filtered.length - 1] });
+            }
+            return;
+        }
+        if (!this.state.isMRMS || !this.state.variable) return;
+        const filtered = this._getFilteredMrmsTimestampsForVariable(this.state.variable);
+        if (filtered.length === 0) return;
+        const cur = this.state.mrmsTimestamp;
+        const curN = cur == null ? null : Number(cur);
+        if (curN == null || !filtered.includes(curN)) {
+            await this.setState({ mrmsTimestamp: filtered[filtered.length - 1] });
+        }
+    }
+
     async switchMode(options) {
-        const { mode, variable, model, forecastHour, mrmsTimestamp } = options;
-        if (!mode || !variable) {
-            console.error("switchMode requires 'mode' ('mrms' | 'model') and 'variable' properties.");
+        const { mode, variable, model, forecastHour, mrmsTimestamp, satelliteKey, satelliteTimestamp } = options;
+        if (!mode) {
             return;
         }
         if (mode === 'model' && !model) {
-            console.error("switchMode with mode 'model' requires a 'model' property.");
+            return;
+        }
+        if ((mode === 'mrms' || mode === 'model') && !variable) {
+            return;
+        }
+        if (mode === 'satellite' && !satelliteKey) {
             return;
         }
         let targetState = {};
-        if (mode === 'mrms') {
+        if (mode === 'satellite') {
+            const channelToken = satelliteKey.split('.').pop() || variable || 'C13';
+            // Emit satellite mode immediately so map layers (e.g. model grid) clear before listing fetch finishes.
+            await this.setState({
+                isSatellite: true,
+                isMRMS: false,
+                isNexrad: false,
+                satelliteKey,
+                variable: channelToken,
+                satelliteTimestamp: null,
+                mrmsTimestamp: null,
+                date: null,
+                run: null,
+                forecastHour: 0,
+            });
+
+            await this.fetchSatelliteListing(true);
+            const allFiles = this.satelliteListing?.objects?.map((o) => o.key) || [];
+            const sectorName = satelliteKey.split('.')[1] || 'GOES-EAST CONUS';
+            let sectorType = 'CONUS';
+            if (sectorName.includes('FULL DISK')) sectorType = 'FULL_DISK';
+            else if (sectorName.includes('MESOSCALE')) sectorType = 'MESOSCALE';
+            const tier = this.state.satelliteTier || 'basic';
+            const tierConfig =
+                SATELLITE_DURATION_CONFIG[sectorType]?.[tier] || SATELLITE_DURATION_CONFIG.CONUS.basic;
+            const durationKey = normalizeTimelineDurationValue(this.state.satelliteDurationValue);
+            const durationOpt =
+                tierConfig.find((o) => String(o.value) === String(durationKey)) ||
+                tierConfig.find((o) => o.value === '1') ||
+                tierConfig[0];
+            const timeline = buildSatelliteTimelineForKey(satelliteKey, allFiles, durationOpt);
+            const tsList = [...(timeline.unixTimes || [])].sort((a, b) => a - b);
+            let finalTs = satelliteTimestamp !== undefined ? satelliteTimestamp : null;
+            if (finalTs == null && tsList.length > 0) {
+                finalTs = tsList[tsList.length - 1];
+            }
+            await this.setState({
+                satelliteTimestamp: finalTs != null ? Number(finalTs) : null,
+            });
+            return;
+        } else if (mode === 'mrms') {
+            const sortedTimestamps = this._getFilteredMrmsTimestampsForVariable(variable);
             let finalTimestamp = mrmsTimestamp;
             if (finalTimestamp === undefined) {
-                const sortedTimestamps = [...(this.mrmsStatus[variable] || [])].sort((a, b) => b - a);
-                finalTimestamp = sortedTimestamps.length > 0 ? sortedTimestamps[0] : null;
+                finalTimestamp =
+                    sortedTimestamps.length > 0 ? sortedTimestamps[sortedTimestamps.length - 1] : null;
+            } else if (sortedTimestamps.length > 0) {
+                const n = Number(finalTimestamp);
+                if (!sortedTimestamps.includes(n)) {
+                    finalTimestamp = sortedTimestamps[sortedTimestamps.length - 1];
+                }
             }
             targetState = {
                 isMRMS: true,
+                isSatellite: false,
+                isNexrad: false,
                 variable: variable,
                 mrmsTimestamp: finalTimestamp,
                 model: this.state.model, date: null, run: null, forecastHour: 0,
+                satelliteKey: null,
+                satelliteTimestamp: null,
             };
         } else if (mode === 'model') {
             const latestRun = findLatestModelRun(this.modelStatus, model);
             if (!latestRun) {
-                console.error(`Could not find a valid run for model: ${model}`);
                 return;
             }
             
@@ -380,50 +835,316 @@ export class AguaceroCore extends EventEmitter {
             
             // If switching to HRRR with ptypeRefl and hour is 0, use hour 1
             if (model === 'hrrr' && variable === 'ptypeRefl' && initialHour === 0) {
-                const availableHours = this.modelStatus?.[model]?.[latestRun.date]?.[latestRun.run] || [];
+                const availableHours = resolveModelRunHours(
+                    this.modelStatus,
+                    model,
+                    latestRun.date,
+                    latestRun.run
+                ).hours || [];
                 initialHour = availableHours.find(hour => hour !== 0) || 0;
             }
             // --- END NEW CODE ---
             
             targetState = {
                 isMRMS: false,
+                isSatellite: false,
+                isNexrad: false,
                 model: model,
                 variable: variable,
                 date: latestRun.date,
                 run: latestRun.run,
                 forecastHour: initialHour,  // <-- Changed
                 mrmsTimestamp: null,
+                satelliteKey: null,
+                satelliteTimestamp: null,
             };
+        } else if (mode === 'nexrad') {
+            const nexradDataSource = options.nexradDataSource || 'level2';
+            const nexradProduct = options.nexradProduct || 'REF';
+            const fld = nexradColormapFldKey(nexradDataSource, nexradProduct);
+            const site = options.nexradSite ?? null;
+            let tilt =
+                options.nexradTilt != null
+                    ? Number(options.nexradTilt)
+                    : site != null
+                      ? getDefaultRadarTilt(site)
+                      : null;
+            await this.setState({
+                isNexrad: true,
+                isMRMS: false,
+                isSatellite: false,
+                variable: fld,
+                nexradSite: site,
+                nexradDataSource,
+                nexradProduct,
+                nexradTilt: tilt,
+                nexradTimestamp: options.nexradTimestamp != null ? Number(options.nexradTimestamp) : null,
+                nexradStormRelative: options.nexradStormRelative === true,
+                nexradShowSitesPicker: options.nexradShowSitesPicker !== false,
+                mrmsTimestamp: null,
+                satelliteKey: null,
+                satelliteTimestamp: null,
+                date: null,
+                run: null,
+                forecastHour: 0,
+            });
+            const manifest = await fetchRadarTiltsManifestFromNetwork();
+            if (manifest) setRadarTiltsManifest(manifest);
+            if (site) {
+                await this.refreshNexradTimes();
+                const filtered = this._getFilteredNexradTimestampsForVariable(
+                    this.nexradTimesByStation[this._nexradTimesCacheKey()]?.unixTimes || [],
+                );
+                let ts =
+                    options.nexradTimestamp != null
+                        ? Number(options.nexradTimestamp)
+                        : this.state.nexradTimestamp;
+                if (ts == null && filtered.length > 0) ts = filtered[filtered.length - 1];
+                else if (ts != null && filtered.length > 0 && !filtered.includes(ts)) {
+                    ts = filtered[filtered.length - 1];
+                }
+                await this.setState({ nexradTimestamp: ts });
+            }
+            return;
         } else {
-            console.error(`Invalid mode specified in switchMode: '${mode}'`);
             return;
         }
         await this.setState(targetState);
     }
 
-    // --- Data and Calculation Methods ---
+    /**
+     * Keep `nexradTilt` on an angle returned by {@link getAvailableNexradTilts} (matches aguacero-frontend elevation buttons).
+     */
+    async _snapNexradTiltToAvailableOptions() {
+        const s = this.state;
+        if (!s.isNexrad || !s.nexradSite) return;
+        const tilts = getAvailableNexradTilts(
+            s.nexradSite,
+            s.nexradDataSource || 'level2',
+            s.nexradProduct || 'REF',
+        );
+        if (!tilts.length) return;
+        const t = s.nexradTilt;
+        const match = (a, b) => Math.abs(Number(a) - Number(b)) < 1e-4;
+        if (t != null && tilts.some((x) => match(x, t))) return;
+        const target = t != null && Number.isFinite(Number(t)) ? Number(t) : getDefaultRadarTilt(s.nexradSite);
+        let best = tilts[0];
+        for (const x of tilts) {
+            if (Math.abs(x - target) < Math.abs(best - target)) best = x;
+        }
+        await this.setState({ nexradTilt: best });
+    }
 
-    _reconstructData(decompressedDeltas, encoding) {
-        const expectedLength = encoding.length;
-        const reconstructedData = new Int8Array(expectedLength);
+    async refreshNexradTimes() {
+        const s0 = this.state;
+        if (!s0.isNexrad || !s0.nexradSite) return;
+        await this._snapNexradTiltToAvailableOptions();
+        const s = this.state;
+        const listingHours = this._nexradListingWindowHours();
+        const out = await fetchNexradTimesListing({
+            stationId: s.nexradSite,
+            variable: s.nexradProduct || 'REF',
+            elev: s.nexradTilt,
+            source: s.nexradDataSource || 'level2',
+            level3StormRelative: s.nexradStormRelative,
+            level3Product: getNexradLevel3EntryByRadarKey(s.nexradProduct)?.product,
+            listingWindowHours: listingHours,
+        });
+        const nk = this._nexradTimesCacheKey();
+        if (!nk) return;
+        this.nexradTimesByStation[nk] = {
+            unixTimes: out.unixTimes,
+            timeToKeyMap: out.timeToKeyMap,
+            level3MotionTimeToKeyMap: out.level3MotionTimeToKeyMap,
+            listWindowHours: listingHours,
+        };
+        if (out.level3MotionKey && out.level3MotionUnixTimes?.length) {
+            this.nexradTimesByStation[out.level3MotionKey] = {
+                unixTimes: out.level3MotionUnixTimes,
+                timeToKeyMap: out.level3MotionTimeToKeyMap,
+                listWindowHours: listingHours,
+            };
+        }
+        if (out.l2StormMotionListKey && out.level3MotionUnixTimes?.length) {
+            this.nexradTimesByStation[out.l2StormMotionListKey] = {
+                unixTimes: out.level3MotionUnixTimes,
+                timeToKeyMap: out.level3MotionTimeToKeyMap,
+                listWindowHours: listingHours,
+            };
+        }
+        this._emitStateChange();
+    }
 
-        if (decompressedDeltas.length > 0 && expectedLength > 0) {
-            // First value is absolute
-            reconstructedData[0] = decompressedDeltas[0] > 127 ? decompressedDeltas[0] - 256 : decompressedDeltas[0];
+    async setNexradSite(siteId) {
+        if (!this.state.isNexrad) return;
+        const tilt = siteId ? getDefaultRadarTilt(siteId) : null;
+        await this.setState({
+            nexradSite: siteId || null,
+            nexradTilt: tilt,
+            nexradTimestamp: null,
+        });
+        await this.refreshNexradTimes();
+        const filtered = this._getFilteredNexradTimestampsForVariable(
+            this.nexradTimesByStation[this._nexradTimesCacheKey()]?.unixTimes || [],
+        );
+        if (filtered.length > 0) {
+            await this.setState({ nexradTimestamp: filtered[filtered.length - 1] });
+        }
+    }
 
-            // Subsequent values are deltas from the previous one
-            for (let i = 1; i < expectedLength; i++) {
-                const delta = decompressedDeltas[i] > 127 ? decompressedDeltas[i] - 256 : decompressedDeltas[i];
-                reconstructedData[i] = reconstructedData[i - 1] + delta;
-            }
+    async setNexradProduct(product) {
+        if (!this.state.isNexrad) return;
+        const p = (product || 'REF').toUpperCase();
+        const ds = this.state.nexradDataSource || 'level2';
+        const fld = nexradColormapFldKey(ds, p);
+        const nexradStormRelative = this._nexradStormRelativeFor(ds, p);
+        await this.setState({ nexradProduct: p, variable: fld, nexradStormRelative });
+        await this.refreshNexradTimes();
+        const filtered = this._getFilteredNexradTimestampsForVariable(
+            this.nexradTimesByStation[this._nexradTimesCacheKey()]?.unixTimes || [],
+        );
+        if (filtered.length > 0) {
+            await this.setState({ nexradTimestamp: filtered[filtered.length - 1] });
         }
-        // Return as a Uint8Array, which is what the rest of the code expects
-        return new Uint8Array(reconstructedData.buffer);
+    }
+
+    async setNexradDataSource(source) {
+        if (!this.state.isNexrad) return;
+        const ds = source === 'level3' ? 'level3' : 'level2';
+        const p = (this.state.nexradProduct || 'REF').toUpperCase();
+        const fld = nexradColormapFldKey(ds, p);
+        const nexradStormRelative = this._nexradStormRelativeFor(ds, p);
+        await this.setState({ nexradDataSource: ds, variable: fld, nexradStormRelative });
+        await this.refreshNexradTimes();
+        const filtered = this._getFilteredNexradTimestampsForVariable(
+            this.nexradTimesByStation[this._nexradTimesCacheKey()]?.unixTimes || [],
+        );
+        if (filtered.length > 0) {
+            await this.setState({ nexradTimestamp: filtered[filtered.length - 1] });
+        }
+    }
+
+    /**
+     * Sets NEXRAD product and archive source together (single refresh). Used when the UI exposes one
+     * combined menu instead of separate “Level II / Level III” controls.
+     * @param {'level2'|'level3'} dataSource
+     * @param {string} product - Level-II variable (REF, VEL, …) or Level-III radar key (N0H, HHC, …)
+     */
+    async setNexradProductMode(dataSource, product) {
+        if (!this.state.isNexrad) return;
+        const ds = dataSource === 'level3' ? 'level3' : 'level2';
+        const p = (product || 'REF').toUpperCase();
+        const fld = nexradColormapFldKey(ds, p);
+        const nexradStormRelative = this._nexradStormRelativeFor(ds, p);
+        await this.setState({ nexradDataSource: ds, nexradProduct: p, variable: fld, nexradStormRelative });
+        await this.refreshNexradTimes();
+        const filtered = this._getFilteredNexradTimestampsForVariable(
+            this.nexradTimesByStation[this._nexradTimesCacheKey()]?.unixTimes || [],
+        );
+        if (filtered.length > 0) {
+            await this.setState({ nexradTimestamp: filtered[filtered.length - 1] });
+        }
+    }
+
+    async setNexradTilt(tilt) {
+        if (!this.state.isNexrad || !this.state.nexradSite) return;
+        await this.setState({ nexradTilt: tilt != null ? Number(tilt) : null });
+        await this.refreshNexradTimes();
+    }
+
+    async setNexradTimestamp(ts) {
+        if (!this.state.isNexrad) return;
+        await this.setState({ nexradTimestamp: ts != null ? Number(ts) : null });
+    }
+
+    // --- Data and Calculation Methods ---
+
+    _ensureGridDecodeWorker() {
+        if (this._gridDecodeWorkerDisabled) {
+            return null;
+        }
+        if (this._gridDecodeWorker) {
+            return this._gridDecodeWorker;
+        }
+        if (typeof Worker === 'undefined') {
+            this._gridDecodeWorkerDisabled = true;
+            return null;
+        }
+        try {
+            this._gridDecodeWorker = new Worker(new URL('./gridDecodeWorker.js', import.meta.url), {
+                type: 'module',
+            });
+            this._gridDecodeWorker.addEventListener('error', () => {
+                this._gridDecodeWorkerDisabled = true;
+                if (this._gridDecodeWorker) {
+                    this._gridDecodeWorker.terminate();
+                    this._gridDecodeWorker = null;
+                }
+            });
+        } catch {
+            this._gridDecodeWorkerDisabled = true;
+            return null;
+        }
+        return this._gridDecodeWorker;
+    }
+
+    /**
+     * Offloads zstd + delta decode + transform to a Worker when available; falls back to main-thread
+     * {@link processCompressedGrid}. Uses a copy for postMessage transfer so the original `compressedData`
+     * stays valid if the Worker path fails.
+     */
+    _decodeGridPayload(compressedData, encoding) {
+        const worker = this._ensureGridDecodeWorker();
+        if (!worker) {
+            return Promise.resolve(processCompressedGrid(compressedData, encoding));
+        }
+        const payload = compressedData.slice();
+        return new Promise((resolve, reject) => {
+            const id = ++this._gridDecodeMsgId;
+            const onMsg = (e) => {
+                if (!e.data || e.data.id !== id) {
+                    return;
+                }
+                worker.removeEventListener('message', onMsg);
+                worker.removeEventListener('error', onErr);
+                if (e.data.error) {
+                    reject(new Error(e.data.error));
+                    return;
+                }
+                const data = new Uint8Array(e.data.dataBuffer, e.data.dataByteOffset, e.data.dataByteLength);
+                resolve({ data, encoding: e.data.encoding });
+            };
+            const onErr = (err) => {
+                worker.removeEventListener('message', onMsg);
+                worker.removeEventListener('error', onErr);
+                reject(err);
+            };
+            worker.addEventListener('message', onMsg);
+            worker.addEventListener('error', onErr);
+            try {
+                worker.postMessage(
+                    {
+                        id,
+                        encoding,
+                        compressedBuffer: payload.buffer,
+                        compressedByteOffset: payload.byteOffset,
+                        compressedByteLength: payload.byteLength,
+                    },
+                    [payload.buffer]
+                );
+            } catch (err) {
+                worker.removeEventListener('message', onMsg);
+                worker.removeEventListener('error', onErr);
+                reject(err);
+            }
+        });
     }
 
     async _loadGridData(state) {
         if (this.isReactNative) {
-            console.warn(`[AguaceroCore] _loadGridData was called in React Native. This is a bypass. Data loading is handled natively.`);
+            return null;
+        }
+        if (state.isNexrad) {
             return null;
         }
         const { model, date, run, forecastHour, variable, isMRMS, mrmsTimestamp } = state;
@@ -447,18 +1168,7 @@ export class AguaceroCore extends EventEmitter {
         if (this.dataCache.has(dataUrlIdentifier)) {
             return this.dataCache.get(dataUrlIdentifier);
         }
-        
-        // --- EDITED ---
-        // If we are in React Native, this function should NOT do any work.
-        // The native WeatherFrameProcessorModule is now responsible for all data loading.
-        // This function might still be called by a "cache miss" fallback, but it
-        // should not fetch data from JS anymore. We return null so the fallback knows
-        // that the native module is the only source of truth for new data.
-        if (this.isReactNative) {
-            console.warn(`_loadGridData was called in React Native for ${dataUrlIdentifier}. This should be handled by the native module. Returning null.`);
-            return null;
-        }
-                
+
         const abortController = new AbortController();
         this.abortControllers.set(dataUrlIdentifier, abortController);
                 
@@ -485,31 +1195,18 @@ export class AguaceroCore extends EventEmitter {
                 const { data: b64Data, encoding } = await response.json();
                 const compressedData = Uint8Array.from(atob(b64Data), c => c.charCodeAt(0));
 
-                // This path is now ONLY for the web worker
-                const requestId = this.workerRequestId++;
-                const workerPromise = new Promise((resolve, reject) => {
-                    this.workerResolvers.set(requestId, { resolve, reject });
-                });
-                this.worker.postMessage({ requestId, compressedData, encoding }, [compressedData.buffer]);
-                const result = await workerPromise;
-                const finalData = result.data;
-
-                const transformedData = new Uint8Array(finalData.length);
-                for (let i = 0; i < finalData.length; i++) {
-                    const signedValue = finalData[i] > 127 ? finalData[i] - 256 : finalData[i];
-                    transformedData[i] = signedValue + 128;
+                let gridPayload;
+                try {
+                    gridPayload = await this._decodeGridPayload(compressedData, encoding);
+                } catch {
+                    gridPayload = processCompressedGrid(compressedData, encoding);
                 }
                 
                 this.abortControllers.delete(dataUrlIdentifier);
                 
-                return { data: transformedData, encoding };
+                return { data: gridPayload.data, encoding: gridPayload.encoding };
 
             } catch (error) {
-                if (error.name === 'AbortError') {
-                    console.log(`Request cancelled for ${resourcePath}`);
-                } else {
-                    console.error(`Failed to load data for path ${resourcePath}:`, error);
-                }
                 this.dataCache.delete(dataUrlIdentifier);
                 this.abortControllers.delete(dataUrlIdentifier);
                 return null;
@@ -528,11 +1225,12 @@ export class AguaceroCore extends EventEmitter {
         // Clear both maps
         this.abortControllers.clear();
         this.dataCache.clear();
-        
-        console.log('All pending requests cancelled');
     }
     
     async getValueAtLngLat(lng, lat) {
+        if (this.state.isSatellite || this.state.isNexrad) {
+            return null;
+        }
         const { variable, isMRMS, mrmsTimestamp, model, date, run, forecastHour, units } = this.state;
         if (!variable) return null;
 
@@ -814,74 +1512,11 @@ export class AguaceroCore extends EventEmitter {
             const y = t_y * (ny - 1);
             return { x, y };
         } catch (error) {
-            console.warn(`[GridAccessor] RGEM polar stereographic conversion failed for ${lat}, ${lon}:`, error);
             return { x: -1, y: -1 };
         }
     }
     
-    // --- Worker and Status Methods ---
-
-    createWorker() {
-        if (this.isReactNative) return null;
-
-        const workerCode = `
-            import { decompress } from 'https://cdn.skypack.dev/fzstd@0.1.1';
-
-            function _reconstructData(decompressedDeltas, encoding) {
-                const expectedLength = encoding.length;
-                const reconstructedData = new Int8Array(expectedLength);
-                if (decompressedDeltas.length > 0 && expectedLength > 0) {
-                    reconstructedData[0] = decompressedDeltas[0] > 127 ? decompressedDeltas[0] - 256 : decompressedDeltas[0];
-                    for (let i = 1; i < expectedLength; i++) {
-                        const delta = decompressedDeltas[i] > 127 ? decompressedDeltas[i] - 256 : decompressedDeltas[i];
-                        reconstructedData[i] = reconstructedData[i - 1] + delta;
-                    }
-                }
-                return new Uint8Array(reconstructedData.buffer);
-            }
-
-            self.onmessage = async (e) => {
-                const { requestId, compressedData, encoding } = e.data;
-                try {
-                    const decompressedDeltas = await decompress(compressedData);
-                    const finalData = _reconstructData(decompressedDeltas, encoding);
-                    self.postMessage({ success: true, requestId: requestId, decompressedData: finalData, encoding: encoding }, [finalData.buffer]);
-                } catch (error) { 
-                    self.postMessage({ success: false, requestId: requestId, error: error.message }); 
-                }
-            };
-        `;
-        const blob = new Blob([workerCode], { type: 'application/javascript' });
-        return new Worker(URL.createObjectURL(blob), { type: 'module' });
-    }
-
-    _processResultQueue() {
-        while (this.resultQueue.length > 0) {
-            const { success, requestId, decompressedData, encoding, error } = this.resultQueue.shift();
-            if (this.workerResolvers.has(requestId)) {
-                const { resolve, reject } = this.workerResolvers.get(requestId);
-                if (success) {
-                    resolve({ data: decompressedData }); // Return as { data: ... }
-                } else {
-                    reject(new Error(error));
-                }
-                this.workerResolvers.delete(requestId);
-            }
-        }
-        this.isProcessingQueue = false;
-    }
-
-    _handleWorkerMessage(e) {
-        if (this.isReactNative) return;
-
-        const { success, requestId, decompressedData, encoding, error } = e.data;
-
-        this.resultQueue.push({ success, requestId, decompressedData, encoding, error });
-        if (!this.isProcessingQueue) {
-            this.isProcessingQueue = true;
-            requestAnimationFrame(() => this._processResultQueue());
-        }
-    }
+    // --- Status Methods ---
 
     async fetchModelStatus(force = false) {
         if (!this.modelStatus || force) {
@@ -906,6 +1541,19 @@ export class AguaceroCore extends EventEmitter {
         return this.mrmsStatus;
     }
 
+    async fetchSatelliteListing(force = false) {
+        if (!this.satelliteListing || force) {
+            try {
+                const response = await fetch(SATELLITE_FRAMES_URL);
+                if (!response.ok) throw new Error(`HTTP error! Status: ${response.status}`);
+                this.satelliteListing = await response.json();
+            } catch (error) {
+                this.satelliteListing = null;
+            }
+        }
+        return this.satelliteListing;
+    }
+
     startAutoRefresh(intervalSeconds) {
         this.stopAutoRefresh();
         this.autoRefreshIntervalId = setInterval(async () => {