@aguacerowx/javascript-sdk 0.0.28 → 0.0.29

package/dist/AguaceroCore.js

@@ -10,7 +10,13 @@ var _unitConversions = require("./unitConversions.js");
 var _dictionaries = require("./dictionaries.js");
 var _defaultColormaps = require("./default-colormaps.js");
 var _proj = _interopRequireDefault(require("proj4"));
+var _gridDecodePipeline = require("./gridDecodePipeline.js");
 var _getBundleId = require("./getBundleId");
+var _satellite_support = require("./satellite_support.js");
+var _nexrad_support = require("./nexrad_support.js");
+var _nexradTiltCoalesce = require("./nexradTiltCoalesce.js");
+var _nexrad_level3_catalog = require("./nexrad_level3_catalog.js");
+var _nexradTilts = require("./nexradTilts.js");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 // AguaceroCore.js - The Headless "Engine"
 
@@ -54,26 +60,80 @@ 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) {
+  var _modelStatus$model;
+  const runs = modelStatus === null || modelStatus === void 0 || (_modelStatus$model = modelStatus[model]) === null || _modelStatus$model === void 0 ? void 0 : _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)
+  };
+}
 class AguaceroCore extends _events.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 = (0, _getBundleId.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;
@@ -84,30 +144,207 @@ class AguaceroCore extends _events.EventEmitter {
     // EDIT: Determine initial mode from options
     const initialMode = userLayerOptions.mode || 'model';
     const initialVariable = userLayerOptions.variable || null;
+    const initialSatellite = initialMode === 'satellite';
+    const initialNexrad = initialMode === 'nexrad';
+    const initialNexradProd = userLayerOptions.nexradProduct || 'REF';
+    const initialNexradDs = (0, _nexrad_support.inferNexradDataSourceForProduct)(initialNexradProd);
+    const initialNexradFld = initialNexrad ? (0, _nexrad_support.nexradColormapFldKey)(initialNexradDs, initialNexradProd) : initialVariable;
+    let initialSatelliteInstrumentId = null;
+    let initialSatelliteSectorLabel = null;
+    let initialSatelliteChannel = null;
+    if (initialSatellite) {
+      initialSatelliteInstrumentId = userLayerOptions.satelliteId ?? 'GOES19-EAST';
+      initialSatelliteSectorLabel = (0, _satellite_support.resolveSatelliteSectorLabel)(userLayerOptions.satelliteSector ?? userLayerOptions.sector ?? 'conus');
+      initialSatelliteChannel = userLayerOptions.satelliteProduct ?? userLayerOptions.satelliteChannel ?? initialVariable ?? 'C13';
+    }
     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 : initialSatellite && initialSatelliteInstrumentId ? initialSatelliteChannel : 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,
+      satelliteInstrumentId: initialSatelliteInstrumentId,
+      satelliteSectorLabel: initialSatelliteSectorLabel,
+      satelliteChannel: initialSatelliteChannel,
+      satelliteTimestamp: userLayerOptions.satelliteTimestamp != null ? Number(userLayerOptions.satelliteTimestamp) : null,
+      satelliteTier: userLayerOptions.satelliteTier || 'basic',
+      satelliteDurationValue: (0, _satellite_support.formatTimelineDurationValue)(userLayerOptions.satelliteDurationValue != null ? userLayerOptions.satelliteDurationValue : '1'),
+      mrmsDurationValue: (0, _satellite_support.formatTimelineDurationValue)(userLayerOptions.mrmsDurationValue != null ? userLayerOptions.mrmsDurationValue : '1'),
+      nexradDurationValue: (0, _satellite_support.formatTimelineDurationValue)(userLayerOptions.nexradDurationValue != null ? userLayerOptions.nexradDurationValue : '1'),
+      isNexrad: initialNexrad,
+      nexradSite: userLayerOptions.nexradSite ?? null,
+      nexradDataSource: initialNexradDs,
+      nexradProduct: initialNexradProd,
+      nexradTilt: userLayerOptions.nexradTilt != null ? Number(userLayerOptions.nexradTilt) : userLayerOptions.nexradSite ? (0, _nexradTilts.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 ('satelliteKey' in patch) delete patch.satelliteKey;
+    if ('nexradDataSource' in patch && !('nexradProduct' in patch)) {
+      delete patch.nexradDataSource;
+    }
+    const willBeNexrad = patch.isNexrad !== undefined ? Boolean(patch.isNexrad) : this.state.isNexrad;
+    if (willBeNexrad && 'nexradProduct' in patch && patch.nexradProduct != null) {
+      const p = (patch.nexradProduct || 'REF').toUpperCase();
+      const prevP = (this.state.nexradProduct || 'REF').toUpperCase();
+      const ds = (0, _nexrad_support.inferNexradDataSourceForProduct)(p);
+      patch.nexradProduct = p;
+      patch.nexradDataSource = ds;
+      patch.variable = (0, _nexrad_support.nexradColormapFldKey)(ds, p);
+      if (!('nexradStormRelative' in newState)) {
+        // Default: base radial velocity (L3 N0G only) — one fetch per time; fast scrub.
+        // SRV (N0G + N0S) is opt-in: setNexradStormRelative(true) or pass nexradStormRelative in setState.
+        // Re-selecting the same product (e.g. VEL → VEL) leaves the current SRV flag alone.
+        if (p !== 'VEL' || prevP !== 'VEL') {
+          patch.nexradStormRelative = false;
+        }
+      }
+    }
+    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) {
+      patch.satelliteDurationValue = (0, _satellite_support.formatTimelineDurationValue)(patch.satelliteDurationValue);
+    }
+    if ('mrmsDurationValue' in patch && patch.mrmsDurationValue != null) {
+      patch.mrmsDurationValue = (0, _satellite_support.formatTimelineDurationValue)(patch.mrmsDurationValue);
+    }
+    if ('nexradDurationValue' in patch && patch.nexradDurationValue != null) {
+      patch.nexradDurationValue = (0, _satellite_support.formatTimelineDurationValue)(patch.nexradDurationValue);
+    }
+    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() {
+    var _this$satelliteListin;
+    const {
+      satelliteInstrumentId,
+      satelliteSectorLabel,
+      satelliteChannel
+    } = this.state;
+    if (!satelliteInstrumentId || !satelliteSectorLabel || !satelliteChannel || !((_this$satelliteListin = this.satelliteListing) !== null && _this$satelliteListin !== void 0 && _this$satelliteListin.objects)) {
+      return {
+        unixTimes: [],
+        timeToFileMap: {}
+      };
+    }
+    const allFiles = this.satelliteListing.objects.map(o => o.key);
+    const sectorName = satelliteSectorLabel;
+    const tier = this.state.satelliteTier || 'basic';
+    const durationOpt = (0, _satellite_support.resolveSatelliteDurationOption)(sectorName, tier, this.state.satelliteDurationValue);
+    return (0, _satellite_support.buildSatelliteTimelineForSelection)({
+      satelliteInstrumentId,
+      satelliteSectorLabel,
+      satelliteChannel
+    }, 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) {
+    var _this$mrmsStatus;
+    const raw = (_this$mrmsStatus = this.mrmsStatus) === null || _this$mrmsStatus === void 0 ? void 0 : _this$mrmsStatus[variable];
+    if (!raw || !raw.length) return [];
+    const hours = (0, _satellite_support.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 (0, _satellite_support.parseTimelineDurationHours)(this.state.nexradDurationValue);
+  }
+  _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() {
+    var _getNexradLevel3Entry;
+    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 : (0, _nexradTilts.getDefaultRadarTilt)(site);
+    const elevNormUse = ds === 'level3' ? _nexrad_level3_catalog.NEXRAD_LEVEL3_ELEV : (0, _nexradTilts.formatTiltForApi)((0, _nexradTilts.clampNexradTiltForVariable)(site, variable, tiltNum));
+    const group = ds === 'level3' ? 'l3' : (0, _nexrad_support.variableToNexradGroup)(variable);
+    const l3Product = ds === 'level3' ? ((_getNexradLevel3Entry = (0, _nexrad_level3_catalog.getNexradLevel3EntryByRadarKey)(variable)) === null || _getNexradLevel3Entry === void 0 ? void 0 : _getNexradLevel3Entry.product) ?? (variable === 'VEL' ? 'N0G' : variable) : '';
+    if (ds === 'level3') {
+      return `${site}_l3_${l3Product}_${elevNormUse}`;
+    }
+    return `${site}_${group}_${elevNormUse}`;
+  }
   _emitStateChange() {
-    var _this$modelStatus, _this$modelStatus2;
+    var _this$modelStatus;
     const {
       colormap,
       baseUnit
@@ -116,23 +353,45 @@ class AguaceroCore extends _events.EventEmitter {
     const displayColormap = this._convertColormapUnits(colormap, baseUnit, toUnit);
     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.modelStatus) === null || _this$modelStatus === void 0 || (_this$modelStatus = _this$modelStatus[this.state.model]) === null || _this$modelStatus === void 0 || (_this$modelStatus = _this$modelStatus[this.state.date]) === null || _this$modelStatus === void 0 ? void 0 : _this$modelStatus[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.satelliteInstrumentId) {
+      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 === null || ent === void 0 ? void 0 : ent.unixTimes) || [];
+      availableNexradTimestamps = this._getFilteredNexradTimestampsForVariable(raw);
+      nexradTimeToKeyMap = (ent === null || ent === void 0 ? void 0 : ent.timeToKeyMap) || {};
+      nexradLevel3MotionTimeToKeyMap = (ent === null || ent === void 0 ? void 0 : ent.level3MotionTimeToKeyMap) || {};
+      availableNexradTilts = (0, _nexrad_support.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() : [],
-      availableRuns: ((_this$modelStatus2 = this.modelStatus) === null || _this$modelStatus2 === void 0 ? void 0 : _this$modelStatus2[this.state.model]) || {},
+      availableRuns: ((_this$modelStatus = this.modelStatus) === null || _this$modelStatus === void 0 ? void 0 : _this$modelStatus[this.state.model]) || {},
       availableHours: availableHours,
       // <-- Changed from inline calculation
       availableVariables: this.getAvailableVariables(this.state.isMRMS ? 'mrms' : this.state.model),
       // 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
@@ -142,28 +401,34 @@ class AguaceroCore extends _events.EventEmitter {
   async initialize(options = {}) {
     await this.fetchModelStatus(true);
     await this.fetchMRMSStatus(true);
+    await this.fetchSatelliteListing(true);
     let initialState = {
       ...this.state
     };
+    if (initialState.isSatellite && initialState.satelliteInstrumentId) {
+      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) {
@@ -181,6 +446,13 @@ class AguaceroCore extends _events.EventEmitter {
       }
     }
     await this.setState(initialState);
+    if (this.state.isNexrad) {
+      const manifest = await (0, _nexradTilts.fetchRadarTiltsManifestFromNetwork)();
+      if (manifest) (0, _nexradTilts.setRadarTiltsManifest)(manifest);
+      if (this.state.nexradSite) {
+        await this.refreshNexradTimes();
+      }
+    }
     if (options.autoRefresh ?? this.autoRefreshEnabled) {
       this.startAutoRefresh(options.refreshInterval ?? this.autoRefreshIntervalSeconds);
     }
@@ -189,11 +461,11 @@ class AguaceroCore extends _events.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 ---
@@ -222,6 +494,21 @@ class AguaceroCore extends _events.EventEmitter {
     this.isPlaying ? this.pause() : this.play();
   }
   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 {
@@ -229,19 +516,16 @@ class AguaceroCore extends _events.EventEmitter {
         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
+        // If not found, reset to the latest frame (end of ascending list)
         this.setState({
-          mrmsTimestamp: availableTimestamps[0]
+          mrmsTimestamp: availableTimestamps[availableTimestamps.length - 1]
         });
         return;
       }
@@ -255,17 +539,29 @@ class AguaceroCore extends _events.EventEmitter {
       this.setState({
         mrmsTimestamp: newTimestamp
       });
+    } else if (this.state.isNexrad) {
+      var _this$nexradTimesBySt;
+      const nk = this._nexradTimesCacheKey();
+      const raw = nk ? (_this$nexradTimesBySt = this.nexradTimesByStation[nk]) === null || _this$nexradTimesBySt === void 0 ? void 0 : _this$nexradTimesBySt.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 {
-      var _this$modelStatus3;
       const {
-        model,
-        date,
-        run,
         forecastHour
       } = this.state;
-      const forecastHours = (_this$modelStatus3 = this.modelStatus) === null || _this$modelStatus3 === void 0 || (_this$modelStatus3 = _this$modelStatus3[model]) === null || _this$modelStatus3 === void 0 || (_this$modelStatus3 = _this$modelStatus3[date]) === null || _this$modelStatus3 === void 0 ? void 0 : _this$modelStatus3[run];
+      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;
       let nextIndex = currentIndex + direction;
@@ -299,8 +595,7 @@ class AguaceroCore extends _events.EventEmitter {
   async setVariable(variable) {
     // --- NEW CODE: Handle switching TO ptypeRefl on HRRR ---
     if (variable === 'ptypeRefl' && this.state.model === 'hrrr' && this.state.forecastHour === 0) {
-      var _this$modelStatus4;
-      const availableHours = ((_this$modelStatus4 = this.modelStatus) === null || _this$modelStatus4 === void 0 || (_this$modelStatus4 = _this$modelStatus4[this.state.model]) === null || _this$modelStatus4 === void 0 || (_this$modelStatus4 = _this$modelStatus4[this.state.date]) === null || _this$modelStatus4 === void 0 ? void 0 : _this$modelStatus4[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,
@@ -315,8 +610,17 @@ class AguaceroCore extends _events.EventEmitter {
     });
   }
   async setModel(modelName) {
-    var _this$modelStatus5;
-    if (modelName === this.state.model || !((_this$modelStatus5 = this.modelStatus) !== null && _this$modelStatus5 !== void 0 && _this$modelStatus5[modelName])) return;
+    var _this$modelStatus2;
+    if (modelName === this.state.model || !((_this$modelStatus2 = this.modelStatus) !== null && _this$modelStatus2 !== void 0 && _this$modelStatus2[modelName])) return;
+    if (this.state.isSatellite) {
+      await this.setState({
+        isSatellite: false,
+        satelliteInstrumentId: null,
+        satelliteSectorLabel: null,
+        satelliteChannel: null,
+        satelliteTimestamp: null
+      });
+    }
     const latestRun = findLatestModelRun(this.modelStatus, modelName);
     if (latestRun) {
       // --- NEW CODE: Determine initial forecast hour ---
@@ -324,9 +628,7 @@ class AguaceroCore extends _events.EventEmitter {
 
       // If switching to HRRR with ptypeRefl, start at hour 1 instead of 0
       if (modelName === 'hrrr' && this.state.variable === 'ptypeRefl') {
-        var _this$modelStatus6;
-        const availableHours = ((_this$modelStatus6 = this.modelStatus) === null || _this$modelStatus6 === void 0 || (_this$modelStatus6 = _this$modelStatus6[modelName]) === null || _this$modelStatus6 === void 0 || (_this$modelStatus6 = _this$modelStatus6[latestRun.date]) === null || _this$modelStatus6 === void 0 ? void 0 : _this$modelStatus6[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 ---
@@ -356,11 +658,16 @@ class AguaceroCore extends _events.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,
+      satelliteInstrumentId: null,
+      satelliteSectorLabel: null,
+      satelliteChannel: null,
+      satelliteTimestamp: null,
       mrmsTimestamp: initialTimestamp
     });
   }
@@ -370,42 +677,184 @@ class AguaceroCore extends _events.EventEmitter {
       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 (positive, at most 12 hours).
+   * API default: `layerOptions.satelliteDurationValue` on construction.
+   */
+  async setSatelliteDurationValue(value) {
+    const v = (0, _satellite_support.formatTimelineDurationValue)(value);
+    await this.setState({
+      satelliteDurationValue: v
+    });
+    if (!this.state.isSatellite || !this.state.satelliteInstrumentId) 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]
+      });
+    }
+  }
+
+  /**
+   * Set satellite view using spacecraft id, sector, and channel/product.
+   * Omitted fields keep the current selection; when not in satellite mode, missing fields use GOES-19 East CONUS / C13 defaults.
+   * @param {{ satelliteId?: string, sector?: string, satelliteSector?: string, satelliteProduct?: string, satelliteChannel?: string, satelliteTimestamp?: number|null }} opts
+   */
+  async setSatelliteSelection(opts = {}) {
+    const cur = this.state.isSatellite ? this.state : null;
+    const tsArg = opts.satelliteTimestamp !== undefined ? opts.satelliteTimestamp : this.state.isSatellite && this.state.satelliteTimestamp != null ? Number(this.state.satelliteTimestamp) : undefined;
+    return this.switchMode({
+      mode: 'satellite',
+      satelliteId: opts.satelliteId ?? (cur === null || cur === void 0 ? void 0 : cur.satelliteInstrumentId) ?? 'GOES19-EAST',
+      satelliteSector: opts.satelliteSector ?? opts.sector ?? (cur === null || cur === void 0 ? void 0 : cur.satelliteSectorLabel) ?? 'conus',
+      satelliteProduct: opts.satelliteProduct ?? opts.satelliteChannel ?? (cur === null || cur === void 0 ? void 0 : cur.satelliteChannel) ?? 'C13',
+      satelliteTimestamp: tsArg
+    });
+  }
+
+  /**
+   * How many hours of MRMS frames to include in the timeline (positive, at most 12 hours).
+   * API default: `layerOptions.mrmsDurationValue` on construction.
+   */
+  async setMRMSDurationValue(value) {
+    const v = (0, _satellite_support.formatTimelineDurationValue)(value);
+    await this.setState({
+      mrmsDurationValue: v
+    });
+    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]
+      });
+    }
+  }
+
+  /**
+   * NEXRAD sweep listing / scrub window in hours (independent of MRMS duration).
+   * API default: `layerOptions.nexradDurationValue` on construction.
+   */
+  async setNexradDurationValue(value) {
+    var _this$nexradTimesBySt2;
+    const v = (0, _satellite_support.formatTimelineDurationValue)(value);
+    await this.setState({
+      nexradDurationValue: v
+    });
+    if (!this.state.isNexrad || !this.state.nexradSite) return;
+    await this.refreshNexradTimes();
+    const nk = this._nexradTimesCacheKey();
+    const filtered = this._getFilteredNexradTimestampsForVariable(nk ? ((_this$nexradTimesBySt2 = this.nexradTimesByStation[nk]) === null || _this$nexradTimesBySt2 === void 0 ? void 0 : _this$nexradTimesBySt2.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]
+      });
+    }
+  }
   async switchMode(options) {
-    const {
+    let {
       mode,
       variable,
       model,
       forecastHour,
-      mrmsTimestamp
+      mrmsTimestamp,
+      satelliteTimestamp
     } = options;
-    if (!mode || !variable) {
-      console.error("switchMode requires 'mode' ('mrms' | 'model') and 'variable' properties.");
+    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;
     }
     let targetState = {};
-    if (mode === 'mrms') {
+    if (mode === 'satellite') {
+      var _this$satelliteListin2;
+      const satelliteInstrumentId = options.satelliteId ?? 'GOES19-EAST';
+      const satelliteSectorLabel = (0, _satellite_support.resolveSatelliteSectorLabel)(options.satelliteSector ?? options.sector ?? 'conus');
+      const satelliteChannel = options.satelliteProduct ?? options.satelliteChannel ?? variable ?? 'C13';
+      const channelToken = satelliteChannel;
+      // 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,
+        satelliteInstrumentId,
+        satelliteSectorLabel,
+        satelliteChannel,
+        variable: channelToken,
+        satelliteTimestamp: null,
+        mrmsTimestamp: null,
+        date: null,
+        run: null,
+        forecastHour: 0
+      });
+      await this.fetchSatelliteListing(true);
+      const allFiles = ((_this$satelliteListin2 = this.satelliteListing) === null || _this$satelliteListin2 === void 0 || (_this$satelliteListin2 = _this$satelliteListin2.objects) === null || _this$satelliteListin2 === void 0 ? void 0 : _this$satelliteListin2.map(o => o.key)) || [];
+      const sectorName = satelliteSectorLabel;
+      const tier = this.state.satelliteTier || 'basic';
+      const durationOpt = (0, _satellite_support.resolveSatelliteDurationOption)(sectorName, tier, this.state.satelliteDurationValue);
+      const timeline = (0, _satellite_support.buildSatelliteTimelineForSelection)({
+        satelliteInstrumentId,
+        satelliteSectorLabel,
+        satelliteChannel
+      }, 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
+        forecastHour: 0,
+        satelliteInstrumentId: null,
+        satelliteSectorLabel: null,
+        satelliteChannel: 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;
       }
 
@@ -414,50 +863,289 @@ class AguaceroCore extends _events.EventEmitter {
 
       // If switching to HRRR with ptypeRefl and hour is 0, use hour 1
       if (model === 'hrrr' && variable === 'ptypeRefl' && initialHour === 0) {
-        var _this$modelStatus7;
-        const availableHours = ((_this$modelStatus7 = this.modelStatus) === null || _this$modelStatus7 === void 0 || (_this$modelStatus7 = _this$modelStatus7[model]) === null || _this$modelStatus7 === void 0 || (_this$modelStatus7 = _this$modelStatus7[latestRun.date]) === null || _this$modelStatus7 === void 0 ? void 0 : _this$modelStatus7[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
+        mrmsTimestamp: null,
+        satelliteInstrumentId: null,
+        satelliteSectorLabel: null,
+        satelliteChannel: null,
+        satelliteTimestamp: null
       };
+    } else if (mode === 'nexrad') {
+      const nexradProduct = options.nexradProduct || 'REF';
+      const p = nexradProduct.toUpperCase();
+      const site = options.nexradSite ?? null;
+      let tilt = options.nexradTilt != null ? Number(options.nexradTilt) : site != null ? (0, _nexradTilts.getDefaultRadarTilt)(site) : null;
+      await this.setState({
+        isNexrad: true,
+        isMRMS: false,
+        isSatellite: false,
+        nexradSite: site,
+        nexradProduct: p,
+        nexradTilt: tilt,
+        nexradTimestamp: options.nexradTimestamp != null ? Number(options.nexradTimestamp) : null,
+        nexradStormRelative: options.nexradStormRelative === true,
+        nexradShowSitesPicker: options.nexradShowSitesPicker !== false,
+        ...(options.nexradDurationValue != null ? {
+          nexradDurationValue: (0, _satellite_support.formatTimelineDurationValue)(options.nexradDurationValue)
+        } : {}),
+        mrmsTimestamp: null,
+        satelliteInstrumentId: null,
+        satelliteSectorLabel: null,
+        satelliteChannel: null,
+        satelliteTimestamp: null,
+        date: null,
+        run: null,
+        forecastHour: 0
+      });
+      const manifest = await (0, _nexradTilts.fetchRadarTiltsManifestFromNetwork)();
+      if (manifest) (0, _nexradTilts.setRadarTiltsManifest)(manifest);
+      if (site) {
+        var _this$nexradTimesBySt3;
+        await this.refreshNexradTimes();
+        const filtered = this._getFilteredNexradTimestampsForVariable(((_this$nexradTimesBySt3 = this.nexradTimesByStation[this._nexradTimesCacheKey()]) === null || _this$nexradTimesBySt3 === void 0 ? void 0 : _this$nexradTimesBySt3.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);
   }
 
+  /**
+   * Keep `nexradTilt` on a coalesced elevation (same rules as aguacero-frontend tilt controls).
+   */
+  async _snapNexradTiltToAvailableOptions() {
+    const s = this.state;
+    if (!s.isNexrad || !s.nexradSite) return;
+    const raw = (0, _nexrad_support.getRawNexradTiltsForCoalesce)(s.nexradSite, s.nexradDataSource || 'level2', s.nexradProduct || 'REF');
+    if (!raw.length) return;
+    const t = s.nexradTilt;
+    const target = t != null && Number.isFinite(Number(t)) ? Number(t) : (0, _nexradTilts.getDefaultRadarTilt)(s.nexradSite);
+    const canonical = (0, _nexradTiltCoalesce.nexradLayerTiltToDisplayOption)(target, raw);
+    const match = (a, b) => Math.abs(Number(a) - Number(b)) < 1e-4;
+    if (match(s.nexradTilt, canonical)) return;
+    await this.setState({
+      nexradTilt: canonical
+    });
+  }
+  async refreshNexradTimes() {
+    var _getNexradLevel3Entry2, _out$level3MotionUnix, _out$level3MotionUnix2;
+    const s0 = this.state;
+    if (!s0.isNexrad || !s0.nexradSite) return;
+    await this._snapNexradTiltToAvailableOptions();
+    const s = this.state;
+    const listingHours = this._nexradListingWindowHours();
+    const out = await (0, _nexrad_support.fetchNexradTimesListing)({
+      stationId: s.nexradSite,
+      variable: s.nexradProduct || 'REF',
+      elev: s.nexradTilt,
+      source: s.nexradDataSource || 'level2',
+      level3StormRelative: s.nexradStormRelative,
+      level3Product: (_getNexradLevel3Entry2 = (0, _nexrad_level3_catalog.getNexradLevel3EntryByRadarKey)(s.nexradProduct)) === null || _getNexradLevel3Entry2 === void 0 ? void 0 : _getNexradLevel3Entry2.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$level3MotionUnix = out.level3MotionUnixTimes) !== null && _out$level3MotionUnix !== void 0 && _out$level3MotionUnix.length) {
+      this.nexradTimesByStation[out.level3MotionKey] = {
+        unixTimes: out.level3MotionUnixTimes,
+        timeToKeyMap: out.level3MotionTimeToKeyMap,
+        listWindowHours: listingHours
+      };
+    }
+    if (out.l2StormMotionListKey && (_out$level3MotionUnix2 = out.level3MotionUnixTimes) !== null && _out$level3MotionUnix2 !== void 0 && _out$level3MotionUnix2.length) {
+      this.nexradTimesByStation[out.l2StormMotionListKey] = {
+        unixTimes: out.level3MotionUnixTimes,
+        timeToKeyMap: out.level3MotionTimeToKeyMap,
+        listWindowHours: listingHours
+      };
+    }
+    const filtered = this._getFilteredNexradTimestampsForVariable(out.unixTimes || []);
+    const map = out.timeToKeyMap || {};
+    if (filtered.length > 0) {
+      const cur = this.state.nexradTimestamp != null ? Number(this.state.nexradTimestamp) : null;
+      const hasKey = cur != null && Object.prototype.hasOwnProperty.call(map, String(cur));
+      const inWindow = cur != null && filtered.includes(cur);
+      if (cur == null || !inWindow || !hasKey) {
+        this.state.nexradTimestamp = filtered[filtered.length - 1];
+      }
+    } else if (this.state.nexradTimestamp != null) {
+      this.state.nexradTimestamp = null;
+    }
+    this._emitStateChange();
+  }
+  async setNexradSite(siteId) {
+    var _this$nexradTimesBySt4;
+    if (!this.state.isNexrad) return;
+    const tilt = siteId ? (0, _nexradTilts.getDefaultRadarTilt)(siteId) : null;
+    await this.setState({
+      nexradSite: siteId || null,
+      nexradTilt: tilt,
+      nexradTimestamp: null
+    });
+    await this.refreshNexradTimes();
+    const filtered = this._getFilteredNexradTimestampsForVariable(((_this$nexradTimesBySt4 = this.nexradTimesByStation[this._nexradTimesCacheKey()]) === null || _this$nexradTimesBySt4 === void 0 ? void 0 : _this$nexradTimesBySt4.unixTimes) || []);
+    if (filtered.length > 0) {
+      await this.setState({
+        nexradTimestamp: filtered[filtered.length - 1]
+      });
+    }
+  }
+  async setNexradProduct(product) {
+    var _this$nexradTimesBySt5;
+    if (!this.state.isNexrad) return;
+    const p = (product || 'REF').toUpperCase();
+    await this.setState({
+      nexradProduct: p
+    });
+    await this.refreshNexradTimes();
+    const filtered = this._getFilteredNexradTimestampsForVariable(((_this$nexradTimesBySt5 = this.nexradTimesByStation[this._nexradTimesCacheKey()]) === null || _this$nexradTimesBySt5 === void 0 ? void 0 : _this$nexradTimesBySt5.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();
+  }
+
+  /**
+   * Opt-in storm-relative velocity (L3: N0G + N0S). When off (default), only base radial velocity is used (faster).
+   * @param {boolean} enabled
+   */
+  async setNexradStormRelative(enabled) {
+    if (!this.state.isNexrad) return;
+    await this.setState({
+      nexradStormRelative: Boolean(enabled)
+    });
+    await this.refreshNexradTimes();
+  }
+  async setNexradTimestamp(ts) {
+    if (!this.state.isNexrad) return;
+    await this.setState({
+      nexradTimestamp: ts != null ? Number(ts) : null
+    });
+  }
+
   // --- Data and Calculation Methods ---
 
-  _reconstructData(decompressedDeltas, encoding) {
-    const expectedLength = encoding.length;
-    const reconstructedData = new Int8Array(expectedLength);
-    if (decompressedDeltas.length > 0 && expectedLength > 0) {
-      // First value is absolute
-      reconstructedData[0] = decompressedDeltas[0] > 127 ? decompressedDeltas[0] - 256 : decompressedDeltas[0];
+  _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;
+  }
 
-      // 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;
-      }
+  /**
+   * 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((0, _gridDecodePipeline.processCompressedGrid)(compressedData, encoding));
     }
-    // Return as a Uint8Array, which is what the rest of the code expects
-    return new Uint8Array(reconstructedData.buffer);
+    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 {
@@ -491,17 +1179,6 @@ class AguaceroCore extends _events.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);
     const loadPromise = (async () => {
@@ -529,38 +1206,18 @@ class AguaceroCore extends _events.EventEmitter {
           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 = (0, _gridDecodePipeline.processCompressedGrid)(compressedData, encoding);
         }
         this.abortControllers.delete(dataUrlIdentifier);
         return {
-          data: transformedData,
-          encoding
+          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;
@@ -578,9 +1235,11 @@ class AguaceroCore extends _events.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,
@@ -968,7 +1627,6 @@ class AguaceroCore extends _events.EventEmitter {
         y
       };
     } catch (error) {
-      console.warn(`[GridAccessor] RGEM polar stereographic conversion failed for ${lat}, ${lon}:`, error);
       return {
         x: -1,
         y: -1
@@ -976,91 +1634,8 @@ class AguaceroCore extends _events.EventEmitter {
     }
   }
 
-  // --- Worker and Status Methods ---
-
-  createWorker() {
-    if (this.isReactNative) return null;
-    const workerCode = `
-            import { decompress } from 'https://cdn.skypack.dev/fzstd@0.1.1';
+  // --- Status Methods ---
 
-            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());
-    }
-  }
   async fetchModelStatus(force = false) {
     if (!this.modelStatus || force) {
       try {
@@ -1086,6 +1661,18 @@ class AguaceroCore extends _events.EventEmitter {
     }
     return this.mrmsStatus;
   }
+  async fetchSatelliteListing(force = false) {
+    if (!this.satelliteListing || force) {
+      try {
+        const response = await fetch(_satellite_support.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 () => {