@aguacerowx/react-native 0.0.46 → 0.0.49

package/src/WeatherLayerManager.js

@@ -9,7 +9,7 @@ import {
 } from '@aguacerowx/javascript-sdk';
 import { fromByteArray } from 'base64-js';
 import React, { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
-import { InteractionManager, NativeModules, Platform } from 'react-native';
+import { NativeModules, Platform, UIManager } from 'react-native';
 import { AguaceroContext } from './AguaceroContext';
 import { GridRenderLayer } from './GridRenderLayer';
 import NexradRadarLayer from './NexradRadarLayer';
@@ -19,6 +19,16 @@ import { NexradAndroidController } from './nexrad/nexradAndroidController';
 import { SatelliteAndroidController } from './satellite/satelliteAndroidController';
 import NwsAlertsOverlay from './nws/NwsAlertsOverlay';
 import { mapRegistry } from './MapRegistry';
+import { satBridgeWarn } from './satelliteBridgeDiag';
+
+const NEXRAD_NATIVE = Platform.OS === 'android' || Platform.OS === 'ios';
+const SATELLITE_NATIVE = Platform.OS === 'android' || Platform.OS === 'ios';
+
+satBridgeWarn('SDK fingerprint', {
+    platform: Platform.OS,
+    SATELLITE_NATIVE,
+    note: 'If you never see sat-bridge logs, the app bundle is not loading this WeatherLayerManager build.',
+});
 
 /**
  * Same filtering as {@link AguaceroCore#_getFilteredMrmsTimestampsForVariable} for older cores
@@ -121,6 +131,82 @@ function mergeNexradEmittedWithCore(emitted, coreState) {
     };
 }
 
+/**
+ * Compact timeline identity for deduping {@code state:change}: extending the NEXRAD/satellite window
+ * often keeps the same selected unix — without this, {@link WeatherLayerManager} short-circuits and
+ * never calls native {@code sync} / preload with the expanded frame list.
+ */
+function nexradObsTimelineSig(state) {
+    const arr = [...(state?.availableNexradTimestamps || [])]
+        .map(Number)
+        .filter((t) => Number.isFinite(t))
+        .sort((a, b) => a - b);
+    if (!arr.length) return '0';
+    return `${arr.length}:${arr[0]}:${arr[arr.length - 1]}`;
+}
+
+function satelliteObsTimelineSig(state) {
+    const keys = Object.keys(state?.satelliteTimeToFileMap || {})
+        .map(Number)
+        .filter((t) => Number.isFinite(t))
+        .sort((a, b) => a - b);
+    if (!keys.length) return '0';
+    return `${keys.length}:${keys[0]}:${keys[keys.length - 1]}`;
+}
+
+/** True in __DEV__, or set `globalThis.__AGUACERO_WX_GRID_DEBUG__ = true` in the app entry for release builds. */
+function wxGridDebugEnabled() {
+    try {
+        if (typeof __DEV__ !== 'undefined' && __DEV__) return true;
+        return Boolean(typeof globalThis !== 'undefined' && globalThis.__AGUACERO_WX_GRID_DEBUG__);
+    } catch {
+        return false;
+    }
+}
+
+function wxGridVerbose(tag, detail) {
+    if (!wxGridDebugEnabled()) return;
+    if (detail !== undefined) {
+        console.log(`[AguaceroWX][grid][${tag}]`, detail);
+    } else {
+        console.log(`[AguaceroWX][grid][${tag}]`);
+    }
+}
+
+/** Always logs (Metro / device logs) — use for failures and unusual early exits. */
+function wxGridWarn(tag, detail) {
+    if (detail !== undefined) {
+        console.warn(`[AguaceroWX][grid][${tag}]`, detail);
+    } else {
+        console.warn(`[AguaceroWX][grid][${tag}]`);
+    }
+}
+
+/**
+ * Native {@code processFrame} must mirror browser/AguaceroCore grid auth: encoded {@code apiKey}
+ * in the query string and optional {@code Origin} / {@code Referer} (many CloudFront setups require them).
+ *
+ * @param {string} baseGridUrl
+ * @param {string} resourcePath
+ * @param {string} apiKey
+ * @param {string | null | undefined} bundleId
+ * @param {string | undefined} gridRequestSiteOrigin - e.g. production web origin your edge allowlists (no trailing slash)
+ */
+function buildGridFrameProcessOptions(baseGridUrl, resourcePath, apiKey, bundleId, gridRequestSiteOrigin) {
+    const url = `${baseGridUrl}${resourcePath}?apiKey=${encodeURIComponent(apiKey)}`;
+    const options = { url, apiKey, bundleId };
+    if (typeof gridRequestSiteOrigin === 'string') {
+        let origin = gridRequestSiteOrigin.trim();
+        while (origin.endsWith('/')) {
+            origin = origin.slice(0, -1);
+        }
+        if (origin.length > 0) {
+            options.gridRequestSiteOrigin = origin;
+        }
+    }
+    return options;
+}
+
 /**
  * A helper function to generate the raw RGBA byte buffer for the colormap texture.
  */
@@ -186,21 +272,28 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         nexradGateSmoothing = false,
         watchesWarnings: watchesWarningsProp,
         onNwsAlertClick,
+        /** Same semantics as mapsgl / AguaceroCore: Origin + Referer for grid CDN (required by many CloudFront rules). */
+        gridRequestSiteOrigin,
         ...restProps
     } = props;
     const context = useContext(AguaceroContext);
 
     // Create the core here instead of getting it from context
-    const core = useMemo(() => new AguaceroCore({
-        apiKey: apiKey,
-        customColormaps: customColormaps,
-        layerOptions: {
-            mode: initialMode,
-            variable: initialVariable,
-            model: initialModel
-        },
-        autoRefresh: false, // <-- add this
-    }), [apiKey]);
+    const core = useMemo(
+        () =>
+            new AguaceroCore({
+                apiKey: apiKey,
+                customColormaps: customColormaps,
+                gridRequestSiteOrigin: gridRequestSiteOrigin,
+                layerOptions: {
+                    mode: initialMode,
+                    variable: initialVariable,
+                    model: initialModel,
+                },
+                autoRefresh: false, // <-- add this
+            }),
+        [apiKey, gridRequestSiteOrigin],
+    );
 
     const [watchesWarningsOptions, setWatchesWarningsOptions] = useState(() => ({
         alertInteractionEnabled: true,
@@ -231,7 +324,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
     const autoRefreshIntervalId = useRef(null);
 
     const ensureNexradController = useCallback(() => {
-        if (Platform.OS !== 'android') return null;
+        if (!NEXRAD_NATIVE) return null;
         if (!nexradControllerRef.current) {
             nexradControllerRef.current = new NexradAndroidController(core, nexradLayerRef, {
                 interpolateNexradColormap,
@@ -244,7 +337,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
     /** Synchronous NEXRAD readout (mapsgl-style); no await — avoids jank on map move. */
     const getNexradInspectPayloadAt = useCallback(
         (lng, lat) => {
-            if (Platform.OS !== 'android' || !core?.state?.isNexrad) return null;
+            if (!NEXRAD_NATIVE || !core?.state?.isNexrad) return null;
             const ctl = ensureNexradController();
             if (!ctl) {
                 return null;
@@ -263,16 +356,37 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
     );
 
     const ensureSatelliteController = useCallback(() => {
-        if (Platform.OS !== 'android') return null;
+        if (!SATELLITE_NATIVE) return null;
         if (!satelliteControllerRef.current) {
             satelliteControllerRef.current = new SatelliteAndroidController(core, satelliteLayerRef);
         }
         return satelliteControllerRef.current;
     }, [core]);
 
+    useEffect(() => {
+        if (!SATELLITE_NATIVE) return;
+        let gridCmdKeys = [];
+        let satCmdKeys = [];
+        try {
+            gridCmdKeys = Object.keys(UIManager.getViewManagerConfig?.('GridRenderLayer')?.Commands ?? {});
+        } catch {
+            gridCmdKeys = ['error'];
+        }
+        try {
+            satCmdKeys = Object.keys(UIManager.getViewManagerConfig?.('SatelliteLayer')?.Commands ?? {});
+        } catch {
+            satCmdKeys = ['error'];
+        }
+        satBridgeWarn('mount UIManager command registration', {
+            GridRenderLayerCommands: gridCmdKeys,
+            SatelliteLayerCommands: satCmdKeys,
+            satelliteMissing: satCmdKeys.length === 0,
+        });
+    }, []);
+
     useEffect(() => {
         const ctl = nexradControllerRef.current;
-        if (Platform.OS === 'android' && ctl) {
+        if (NEXRAD_NATIVE && ctl) {
             ctl.updateStyleOptions({
                 interpolateNexradColormap,
                 nexradGateSmoothing,
@@ -375,7 +489,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 _checkForUpdates();
             },
             /**
-             * NWS watches/warnings (Android native map): same options as mapsgl {@link WeatherLayerManager#configureWatchesWarnings}.
+             * NWS watches/warnings (native map, iOS + Android): same options as mapsgl {@link WeatherLayerManager#configureWatchesWarnings}.
              * @param {object} partial
              */
             configureWatchesWarnings: (partial) => {
@@ -387,10 +501,12 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
     const preloadAllFramesToDisk = async (state) => {
         if (state.isNexrad || state.isSatellite) {
             hasPreloadedRef.current = false;
+            wxGridVerbose('preloadSkip', { reason: 'nexrad_or_satellite' });
             return;
         }
 
         if (hasPreloadedRef.current) {
+            wxGridVerbose('preloadSkip', { reason: 'hasPreloadedRef_gate', isMRMS: state.isMRMS, variable: state.variable });
             return;
         }
 
@@ -399,17 +515,44 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         // CRITICAL: Don't start preloading if we don't have a valid current frame
         if (isMRMS && (mrmsTimestamp == null || !availableTimestamps || availableTimestamps.length === 0)) {
             hasPreloadedRef.current = false;
+            wxGridWarn('preloadAbort', {
+                reason: 'mrms_missing_frame_or_timestamps',
+                mrmsTimestamp,
+                timestampCount: availableTimestamps?.length ?? 0,
+                variable,
+            });
             return;
         }
 
         if (!isMRMS && (forecastHour == null || !availableHours || availableHours.length === 0)) {
             hasPreloadedRef.current = false;
+            wxGridWarn('preloadAbort', {
+                reason: 'model_missing_hour_or_hours',
+                forecastHour,
+                hourCount: availableHours?.length ?? 0,
+                model,
+                variable,
+            });
             return;
         }
 
         // Only mark as "has preloaded" after validation passes
         hasPreloadedRef.current = true;
 
+        wxGridVerbose('preloadStart', {
+            isMRMS,
+            model,
+            date,
+            run,
+            variable,
+            mrmsTimestamp: isMRMS ? mrmsTimestamp : undefined,
+            forecastHour: !isMRMS ? forecastHour : undefined,
+            baseGridUrl: core?.baseGridUrl,
+            hasApiKey: Boolean(core?.apiKey),
+            bundleId: core?.bundleId ?? null,
+            gridRequestSiteOrigin: gridRequestSiteOrigin || null,
+        });
+
         // Fix the current forecast hour if it's invalid for this variable/model combo
         let effectiveForecastHour = forecastHour;
         if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && forecastHour === 0) {
@@ -423,6 +566,13 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             gridLayerRef.current.updateGeometry(corners, gridDef);
             cachedGeometry.current = { model: gridModel, variable };
 
+            wxGridVerbose('geometryColormapInit', {
+                gridModel,
+                variable,
+                nx: gridDef?.grid_params?.nx,
+                ny: gridDef?.grid_params?.ny,
+            });
+
             const { colormap, baseUnit } = core._getColormapForVariable(variable);
             const toUnit = core._getTargetUnit(baseUnit, units);
             const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
@@ -451,6 +601,8 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
         const allFrames = isMRMS ? availableTimestamps : filteredHours;
         if (!allFrames || allFrames.length === 0) {
+            hasPreloadedRef.current = false;
+            wxGridWarn('preloadAbort', { reason: 'no_frames_after_filter', isMRMS, variable });
             return;
         }
 
@@ -459,6 +611,8 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         // Double-check currentFrame is valid
         if (currentFrame == null) {
             hasPreloadedRef.current = false;
+            wxGridWarn('preloadAbort', { reason: 'currentFrame_null', isMRMS, variable });
+            return;
         }
 
         // Reverse the frame order to load from last to first
@@ -483,13 +637,25 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 resourcePath = `/grids/${model}/${date}/${run}/${currentFrame}/${variable}/0`;
             }
 
-            const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
-            const options = { url, apiKey: core.apiKey, bundleId: core.bundleId };
+            const options = buildGridFrameProcessOptions(
+                core.baseGridUrl,
+                resourcePath,
+                core.apiKey,
+                core.bundleId,
+                gridRequestSiteOrigin,
+            );
 
             try {
+                wxGridVerbose('processFrameRequest', { currentCacheKey, resourcePath, frame: currentFrame });
                 const result = await WeatherFrameProcessorModule.processFrame(options);
 
                 if (!result || !result.filePath) {
+                    hasPreloadedRef.current = false;
+                    wxGridWarn('preloadAbort', {
+                        reason: 'processFrame_empty_result',
+                        currentCacheKey,
+                        resultKeys: result ? Object.keys(result) : [],
+                    });
                     return;
                 }
 
@@ -580,8 +746,32 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     units: units,
                     scaleType: frameData.scaleType
                 };
-            } catch {
-                hasPreloadedRef.current = false;
+
+                wxGridVerbose('preloadCurrentFrameOk', {
+                    currentCacheKey,
+                    nx: frameData.nx,
+                    ny: frameData.ny,
+                    scale: frameData.scale,
+                    offset: frameData.offset,
+                    filePathSuffix: String(frameData.filePath).split('/').pop(),
+                });
+            } catch (e) {
+                const cancelled =
+                    e &&
+                    (e.code === 'E_CANCELLED' ||
+                        e?.userInfo?.code === 'E_CANCELLED' ||
+                        (typeof e?.message === 'string' && e.message.includes('superseded')));
+                if (!cancelled) {
+                    hasPreloadedRef.current = false;
+                    wxGridWarn('preloadProcessFrameError', {
+                        currentCacheKey,
+                        code: e?.code,
+                        message: e?.message,
+                        userInfo: e?.userInfo,
+                    });
+                } else {
+                    wxGridVerbose('preloadProcessFrameCancelled', { currentCacheKey });
+                }
             }
         }
 
@@ -603,8 +793,13 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 resourcePath = `/grids/${model}/${date}/${run}/${frame}/${variable}/0`;
             }
 
-            const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
-            const options = { url, apiKey: core.apiKey, bundleId: core.bundleId };
+            const options = buildGridFrameProcessOptions(
+                core.baseGridUrl,
+                resourcePath,
+                core.apiKey,
+                core.bundleId,
+                gridRequestSiteOrigin,
+            );
 
             WeatherFrameProcessorModule.processFrame(options)
                 .then(result => {
@@ -698,7 +893,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                         gridLayerRef.current.primeGpuCache(frameInfoForGpu);
                     }
                 })
-                .catch(() => {});
+                .catch((e) => {
+                    const cancelled =
+                        e &&
+                        (e.code === 'E_CANCELLED' ||
+                            e?.userInfo?.code === 'E_CANCELLED' ||
+                            (typeof e?.message === 'string' && e.message.includes('superseded')));
+                    if (!cancelled) {
+                        wxGridWarn('backgroundFrameError', { cacheKey, code: e?.code, message: e?.message });
+                    }
+                });
         });
     };
 
@@ -742,19 +946,31 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     units: units,
                     scaleType: cachedData.scaleType
                 };
+            } else {
+                wxGridVerbose('gpuIOS_setActiveFrame_no_row', {
+                    cacheKey,
+                    cacheSize: preloadedDataCache.current.size,
+                });
             }
 
             gridLayerRef.current.setActiveFrame(cacheKey);
+            wxGridVerbose('gpuIOS_setActiveFrame', { cacheKey, hadCachedRow: Boolean(cachedData) });
             return true;
         }
 
         const cachedData = preloadedDataCache.current.get(cacheKey);
 
         if (!cachedData) {
+            wxGridWarn('updateGPUNoCache', {
+                cacheKey,
+                cacheSize: preloadedDataCache.current.size,
+                sampleKeys: Array.from(preloadedDataCache.current.keys()).slice(0, 5),
+            });
             return false;
         }
 
         if (!gridLayerRef.current) {
+            wxGridWarn('updateGPUNoGridLayerRef', { cacheKey });
             return false;
         }
 
@@ -806,7 +1022,14 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 units: units,
                 scaleType: cachedData.scaleType
             };
+            wxGridVerbose('gpuUploadFromFile', {
+                cacheKey,
+                nx: cachedData.nx,
+                ny: cachedData.ny,
+                filePathSuffix: String(cachedData.filePath).split('/').pop(),
+            });
         } else {
+            wxGridWarn('updateGPUNoFilePath', { cacheKey });
             return false;
         }
 
@@ -835,7 +1058,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             return null;
         }
 
-        if (Platform.OS === 'android' && core.state?.isNexrad) {
+        if (NEXRAD_NATIVE && core.state?.isNexrad) {
             return getNexradInspectPayloadAt(lng, lat);
         }
 
@@ -899,7 +1122,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
         const s = core.state;
         const { isMRMS, isSatellite, isNexrad, model: currentModel, variable: currentVariable, date, run } = s;
 
-        if (isSatellite && s.satelliteInstrumentId) {
+        if (isSatellite) {
             const prevTimeline = core._computeSatelliteTimeline();
             const prevTimes = [...(prevTimeline.unixTimes || [])]
                 .map((t) => Number(t))
@@ -971,9 +1194,15 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     const frameDate = new Date(frame * 1000);
                     const y = frameDate.getUTCFullYear(), m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0'), d = frameDate.getUTCDate().toString().padStart(2, '0');
                     const resourcePath = `/grids/mrms/${y}${m}${d}/${frame}/0/${currentVariable}/0`;
-                    const url = `${core.baseGridUrl}${resourcePath}?apiKey=${core.apiKey}`;
+                    const options = buildGridFrameProcessOptions(
+                        core.baseGridUrl,
+                        resourcePath,
+                        core.apiKey,
+                        core.bundleId,
+                        gridRequestSiteOrigin,
+                    );
 
-                    WeatherFrameProcessorModule.processFrame({ url, apiKey: core.apiKey, bundleId: core.bundleId })
+                    WeatherFrameProcessorModule.processFrame(options)
                         .then(result => {
                             if (!result || !result.filePath) return;
                             const frameData = { filePath: result.filePath, nx, ny, scale: result.scale, offset: result.offset, missing: result.missing, corners, gridDef, scaleType: result.scaleType, originalScale: result.scale, originalOffset: result.offset };
@@ -981,7 +1210,17 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                             if (Platform.OS === 'ios' && gridLayerRef.current?.primeGpuCache) {
                                 gridLayerRef.current.primeGpuCache({ [cacheKey]: frameData });
                             }
-                        }).catch(() => {});
+                        })
+                        .catch((e) => {
+                            const cancelled =
+                                e &&
+                                (e.code === 'E_CANCELLED' ||
+                                    e?.userInfo?.code === 'E_CANCELLED' ||
+                                    (typeof e?.message === 'string' && e.message.includes('superseded')));
+                            if (!cancelled) {
+                                wxGridWarn('mrmsRefreshFrameError', { cacheKey, code: e?.code, message: e?.message });
+                            }
+                        });
                 });
 
                 const newTimestampsSet = new Set(newTimestamps);
@@ -1022,21 +1261,25 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             }
 
             const stateKey = newState.isNexrad
-                ? `nx-${newState.nexradSite}-${newState.nexradProduct}-${newState.nexradDataSource}-${newState.nexradTimestamp}-${newState.nexradTilt}-${newState.units}-${newState.model}-${newState.variable}-${newState.mrmsTimestamp}-${newState.forecastHour}`
+                ? `nx-${newState.nexradSite}-${newState.nexradProduct}-${newState.nexradDataSource}-${newState.nexradTimestamp}-${newState.nexradTilt}-${newState.units}-${newState.model}-${newState.variable}-${newState.mrmsTimestamp}-${newState.forecastHour}-dur:${newState.nexradDurationValue ?? ''}-tl:${nexradObsTimelineSig(newState)}`
                 : newState.isSatellite
-                  ? `sat-${newState.satelliteInstrumentId}-${newState.satelliteSectorLabel}-${newState.satelliteChannel}-${newState.satelliteTimestamp}-${newState.variable}-${newState.units}-${newState.opacity}`
+                  ? `sat-${newState.satelliteInstrumentId}-${newState.satelliteSectorLabel}-${newState.satelliteChannel}-${newState.satelliteTimestamp}-${newState.variable}-${newState.units}-${newState.opacity}-dur:${newState.satelliteDurationValue ?? ''}-tl:${satelliteObsTimelineSig(newState)}`
                   : `${newState.model}-${newState.variable}-${newState.date}-${newState.run}-${newState.forecastHour}-${newState.units}-${newState.mrmsTimestamp}`;
 
             const sameTimeline = newState.isNexrad
                 ? newState.nexradTimestamp === previousStateRef.current?.nexradTimestamp &&
                   newState.nexradSite === previousStateRef.current?.nexradSite &&
                   newState.nexradProduct === previousStateRef.current?.nexradProduct &&
-                  Number(newState.nexradTilt) === Number(previousStateRef.current?.nexradTilt)
+                  Number(newState.nexradTilt) === Number(previousStateRef.current?.nexradTilt) &&
+                  newState.nexradDurationValue === previousStateRef.current?.nexradDurationValue &&
+                  nexradObsTimelineSig(newState) === nexradObsTimelineSig(previousStateRef.current)
                 : newState.isSatellite
                   ? newState.satelliteTimestamp === previousStateRef.current?.satelliteTimestamp &&
                     newState.satelliteInstrumentId === previousStateRef.current?.satelliteInstrumentId &&
                     newState.satelliteSectorLabel === previousStateRef.current?.satelliteSectorLabel &&
-                    newState.satelliteChannel === previousStateRef.current?.satelliteChannel
+                    newState.satelliteChannel === previousStateRef.current?.satelliteChannel &&
+                    newState.satelliteDurationValue === previousStateRef.current?.satelliteDurationValue &&
+                    satelliteObsTimelineSig(newState) === satelliteObsTimelineSig(previousStateRef.current)
                   : newState.forecastHour === previousStateRef.current?.forecastHour &&
                     newState.mrmsTimestamp === previousStateRef.current?.mrmsTimestamp;
 
@@ -1070,16 +1313,49 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 return;
             }
 
+            if (
+                wxGridDebugEnabled() &&
+                Platform.OS === 'ios' &&
+                ((newState.isNexrad && previousStateRef.current?.isNexrad) ||
+                    (newState.isSatellite && previousStateRef.current?.isSatellite))
+            ) {
+                const prev = previousStateRef.current;
+                if (newState.isNexrad && prev?.isNexrad) {
+                    if (
+                        newState.nexradDurationValue !== prev.nexradDurationValue ||
+                        nexradObsTimelineSig(newState) !== nexradObsTimelineSig(prev)
+                    ) {
+                        wxGridVerbose('iosNexradTimelineWindowChanged', {
+                            duration: { from: prev.nexradDurationValue, to: newState.nexradDurationValue },
+                            timelineSig: { from: nexradObsTimelineSig(prev), to: nexradObsTimelineSig(newState) },
+                            willSyncNative: true,
+                        });
+                    }
+                }
+                if (newState.isSatellite && prev?.isSatellite) {
+                    if (
+                        newState.satelliteDurationValue !== prev.satelliteDurationValue ||
+                        satelliteObsTimelineSig(newState) !== satelliteObsTimelineSig(prev)
+                    ) {
+                        wxGridVerbose('iosSatelliteTimelineWindowChanged', {
+                            duration: { from: prev.satelliteDurationValue, to: newState.satelliteDurationValue },
+                            timelineSig: { from: satelliteObsTimelineSig(prev), to: satelliteObsTimelineSig(newState) },
+                            willSyncNative: true,
+                        });
+                    }
+                }
+            }
+
             if (!isOpacityOnlyChange && !isPlayStateOnlyChange) {
                 lastProcessedState.current = stateKey;
             }
 
             if (isOpacityOnlyChange) {
                 setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
-                if (Platform.OS === 'android' && newState.isNexrad) {
+                if (NEXRAD_NATIVE && newState.isNexrad) {
                     nexradControllerRef.current?.applyStyleFromState?.(newState);
                 }
-                if (Platform.OS === 'android' && newState.isSatellite) {
+                if (SATELLITE_NATIVE && newState.isSatellite) {
                     satelliteLayerRef.current?.updateSatelliteStyle?.(
                         JSON.stringify({
                             visible: newState.visible !== false,
@@ -1113,7 +1389,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 newState.units !== previousStateRef.current.units;
 
             if (isUnitsOnlyChange) {
-                if (Platform.OS === 'android' && newState.isNexrad) {
+                if (NEXRAD_NATIVE && newState.isNexrad) {
                     setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
                     nexradControllerRef.current?.applyStyleFromState?.(newState);
                     previousStateRef.current = newState;
@@ -1225,8 +1501,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                         newState.run !== prev?.run));
 
             if (needsFullLoad) {
+                wxGridVerbose('needsFullLoad', {
+                    variable: newState.variable,
+                    isMRMS: newState.isMRMS,
+                    model: newState.model,
+                    isInitial: !hasInitialLoad.current,
+                    prevVariable: prev?.variable,
+                    prevModel: prev?.model,
+                });
                 const nexradIdentityChange =
-                    Platform.OS === 'android' &&
+                    NEXRAD_NATIVE &&
                     (newState.isNexrad !== prev?.isNexrad ||
                         (newState.isNexrad &&
                             prev?.isNexrad &&
@@ -1234,7 +1518,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                                 newState.nexradDataSource !== prev.nexradDataSource ||
                                 newState.nexradProduct !== prev.nexradProduct)));
                 const satelliteIdentityChange =
-                    Platform.OS === 'android' &&
+                    SATELLITE_NATIVE &&
                     (newState.isSatellite !== prev?.isSatellite ||
                         (newState.isSatellite &&
                             prev?.isSatellite &&
@@ -1264,6 +1548,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 cachedColormap.current = null;
                 currentGridDataRef.current = null;
                 WeatherFrameProcessorModule.cancelAllFrames();
+                wxGridVerbose('cancelAllFrames', { reason: 'needsFullLoad', variable: newState.variable });
 
                 if (!newState.variable) {
                     previousStateRef.current = newState;
@@ -1271,9 +1556,9 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 }
                 if (!newState.isNexrad && !newState.isSatellite) {
                     preloadAllFramesToDisk(newState);
-                } else if (Platform.OS === 'android' && newState.isNexrad) {
+                } else if (NEXRAD_NATIVE && newState.isNexrad) {
                     hasInitialLoad.current = true;
-                } else if (Platform.OS === 'android' && newState.isSatellite) {
+                } else if (SATELLITE_NATIVE && newState.isSatellite) {
                     hasInitialLoad.current = true;
                 }
             } else if (
@@ -1282,40 +1567,87 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     (newState.isMRMS && newState.mrmsTimestamp !== previousStateRef.current.mrmsTimestamp))
             ) {
                 const success = updateGPUWithCachedData(newState);
+                if (!success) {
+                    wxGridWarn('timelineGpuUpdateMiss', {
+                        isMRMS: newState.isMRMS,
+                        variable: newState.variable,
+                        mrmsTimestamp: newState.mrmsTimestamp,
+                        forecastHour: newState.forecastHour,
+                    });
+                }
                 if (success && newState.opacity !== renderProps.opacity) {
                     setRenderProps(prev => ({ ...prev, opacity: newState.opacity }));
                 }
             }
 
-            if (Platform.OS === 'android' && newState.isNexrad && newState.nexradSite && newState.nexradTimestamp != null) {
+            if (NEXRAD_NATIVE && newState.isNexrad && newState.nexradSite && newState.nexradTimestamp != null) {
                 const ctl = ensureNexradController();
                 if (ctl) {
                     hasInitialLoad.current = true;
                     void ctl.sync(newState);
                     nexradPreloadInteractionRef.current?.cancel?.();
-                    nexradPreloadInteractionRef.current = InteractionManager.runAfterInteractions(() => {
+                    const preloadCancelled = { v: false };
+                    nexradPreloadInteractionRef.current = {
+                        cancel: () => {
+                            preloadCancelled.v = true;
+                        },
+                    };
+                    const nexradTimelineSnapshot = Array.isArray(newState.availableNexradTimestamps)
+                        ? newState.availableNexradTimestamps
+                        : [];
+                    const kickPreload = () => {
                         nexradPreloadInteractionRef.current = null;
+                        if (preloadCancelled.v) {
+                            return;
+                        }
                         const cur = nexradControllerRef.current;
-                        if (!cur) return;
+                        if (!cur) {
+                            return;
+                        }
                         const s = core.state;
-                        if (!s.isNexrad || !s.nexradSite || s.nexradTimestamp == null) return;
-                        cur.preloadAllAvailable(s);
-                    });
+                        if (!s.isNexrad || !s.nexradSite || s.nexradTimestamp == null) {
+                            return;
+                        }
+                        const coreTs = Array.isArray(s.availableNexradTimestamps) ? s.availableNexradTimestamps : [];
+                        const mergedTimestamps =
+                            coreTs.length > 0 ? coreTs : nexradTimelineSnapshot.length > 0 ? nexradTimelineSnapshot : [];
+                        const preloadState = { ...s, availableNexradTimestamps: mergedTimestamps };
+                        cur.preloadAllAvailable(preloadState);
+                    };
+                    if (typeof queueMicrotask === 'function') {
+                        queueMicrotask(kickPreload);
+                    } else {
+                        setTimeout(kickPreload, 0);
+                    }
                 }
-            } else if (Platform.OS === 'android' && (!newState.isNexrad || !newState.nexradSite)) {
+            } else if (NEXRAD_NATIVE && (!newState.isNexrad || !newState.nexradSite)) {
                 nexradPreloadInteractionRef.current?.cancel?.();
                 nexradPreloadInteractionRef.current = null;
                 nexradControllerRef.current?.destroy();
                 nexradControllerRef.current = null;
             }
 
-            if (Platform.OS === 'android' && newState.isSatellite && newState.satelliteInstrumentId) {
+            if (SATELLITE_NATIVE && newState.isSatellite) {
+                satBridgeWarn('handleStateChange → satellite', {
+                    satelliteInstrumentId: newState.satelliteInstrumentId ?? null,
+                    satelliteSectorLabel: newState.satelliteSectorLabel ?? null,
+                    satelliteChannel: newState.satelliteChannel ?? null,
+                    timelineKeys: Object.keys(newState.satelliteTimeToFileMap || {}).length,
+                    refHasSync: Boolean(satelliteLayerRef.current?.syncSatellite),
+                });
                 const satCtl = ensureSatelliteController();
                 if (satCtl) {
                     hasInitialLoad.current = true;
                     void satCtl.sync(newState);
+                } else {
+                    satBridgeWarn('handleStateChange satellite: ensureSatelliteController returned null', {});
+                }
+                if (!newState.satelliteInstrumentId && typeof __DEV__ !== 'undefined' && __DEV__) {
+                    console.warn(
+                        '[AguaceroWX][satellite] isSatellite is true but satelliteInstrumentId is missing — native sync still runs; timeline may be empty until core sets instrument.',
+                    );
                 }
-            } else if (Platform.OS === 'android' && !newState.isSatellite) {
+            } else if (SATELLITE_NATIVE && !newState.isSatellite) {
                 satelliteControllerRef.current?.destroy();
                 satelliteControllerRef.current = null;
             }
@@ -1362,12 +1694,16 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                     ? newState.nexradTimestamp === prevStable.nexradTimestamp &&
                       newState.nexradSite === prevStable.nexradSite &&
                       newState.nexradProduct === prevStable.nexradProduct &&
-                      Number(newState.nexradTilt) === Number(prevStable.nexradTilt)
+                      Number(newState.nexradTilt) === Number(prevStable.nexradTilt) &&
+                      newState.nexradDurationValue === prevStable.nexradDurationValue &&
+                      nexradObsTimelineSig(newState) === nexradObsTimelineSig(prevStable)
                     : prevStable.isSatellite
                       ? newState.satelliteTimestamp === prevStable.satelliteTimestamp &&
                         newState.satelliteInstrumentId === prevStable.satelliteInstrumentId &&
                         newState.satelliteSectorLabel === prevStable.satelliteSectorLabel &&
-                        newState.satelliteChannel === prevStable.satelliteChannel
+                        newState.satelliteChannel === prevStable.satelliteChannel &&
+                        newState.satelliteDurationValue === prevStable.satelliteDurationValue &&
+                        satelliteObsTimelineSig(newState) === satelliteObsTimelineSig(prevStable)
                       : newState.forecastHour === prevStable.forecastHour &&
                         newState.mrmsTimestamp === prevStable.mrmsTimestamp);
 
@@ -1419,11 +1755,13 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             if (debounceTimeoutRef.current) {
                 clearTimeout(debounceTimeoutRef.current);
             }
-            if (Platform.OS === 'android') {
+            if (NEXRAD_NATIVE) {
                 nexradPreloadInteractionRef.current?.cancel?.();
                 nexradPreloadInteractionRef.current = null;
                 nexradControllerRef.current?.destroy();
                 nexradControllerRef.current = null;
+            }
+            if (SATELLITE_NATIVE) {
                 satelliteControllerRef.current?.destroy();
                 satelliteControllerRef.current = null;
             }
@@ -1439,11 +1777,13 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             if (gridLayerRef.current && Platform.OS === 'ios') {
                 gridLayerRef.current.clearGpuCache();
             }
-            if (Platform.OS === 'android') {
+            if (NEXRAD_NATIVE) {
                 nexradPreloadInteractionRef.current?.cancel?.();
                 nexradPreloadInteractionRef.current = null;
                 nexradControllerRef.current?.destroy();
                 nexradControllerRef.current = null;
+            }
+            if (SATELLITE_NATIVE) {
                 satelliteControllerRef.current?.destroy();
                 satelliteControllerRef.current = null;
             }
@@ -1472,7 +1812,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
 
             const [longitude, latitude] = center;
 
-            if (Platform.OS === 'android' && core.state?.isNexrad) {
+            if (NEXRAD_NATIVE && core.state?.isNexrad) {
                 onInspect?.(getNexradInspectPayloadAtRef.current(longitude, latitude));
                 return;
             }
@@ -1508,7 +1848,7 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
             if (center && Array.isArray(center) && center.length === 2) {
                 const [longitude, latitude] = center;
 
-                if (Platform.OS === 'android' && core?.state?.isNexrad) {
+                if (NEXRAD_NATIVE && core?.state?.isNexrad) {
                     onInspect?.(getNexradInspectPayloadAtRef.current(longitude, latitude));
                 } else {
                     getValueAtPointRef.current(longitude, latitude).then((payload) => {
@@ -1585,12 +1925,13 @@ export const WeatherLayerManager = forwardRef((props, ref) => {
                 dataRange={renderProps.dataRange}
                 belowID={gridBelowId}
             />
-            {Platform.OS === 'android' ? <NexradRadarLayer ref={nexradLayerRef} belowID={gridBelowId} /> : null}
-            {Platform.OS === 'android' ? <SatelliteLayer ref={satelliteLayerRef} belowID={gridBelowId} /> : null}
+            {NEXRAD_NATIVE ? <NexradRadarLayer ref={nexradLayerRef} belowID={gridBelowId} /> : null}
+            {SATELLITE_NATIVE ? <SatelliteLayer ref={satelliteLayerRef} belowID={gridBelowId} /> : null}
             <NwsAlertsOverlay core={core} watchesWarnings={watchesWarningsOptions} onNwsAlertClick={onNwsAlertClick} />
-            {Platform.OS === 'android' && nexradSitesMapVisible ? (
+            {nexradSitesMapVisible ? (
                 <NexradSitesMapLayer
                     visible
+                    belowLayerID={gridBelowId}
                     onSelectSite={(siteId) => void core.setNexradSite(siteId)}
                 />
             ) : null}