@aguacerowx/react-native 0.0.53 → 0.0.54

package/lib/module/WeatherLayerManager.js

@@ -1,1835 +1,1184 @@
-// packages/react-native/src/WeatherLayerManager.js
-
-import { AguaceroCore, DICTIONARIES, formatTimelineDurationValue, getUnitConversionFunction, parseTimelineDurationHours } from '@aguacerowx/javascript-sdk';
-import { fromByteArray } from 'base64-js';
-import React, { forwardRef, useCallback, useContext, useEffect, useImperativeHandle, useMemo, useRef, useState } from 'react';
-import { NativeModules, Platform, UIManager } from 'react-native';
-import { AguaceroContext } from './AguaceroContext';
-import { GridRenderLayer } from './GridRenderLayer';
-import NexradRadarLayer from './NexradRadarLayer';
-import SatelliteLayer from './SatelliteLayer';
-import { NexradSitesMapLayer } from './NexradSitesMapLayer';
-import { NexradAndroidController } from './nexrad/nexradAndroidController';
-import { SatelliteAndroidController } from './satellite/satelliteAndroidController';
-import NwsAlertsOverlay from './nws/NwsAlertsOverlay';
-import { mapRegistry } from './MapRegistry';
-import { satBridgeWarn } from './satelliteBridgeDiag';
-import { augmentProcessFrameOptionsForDebug, aguaceroDebugWarn, configureAguaceroRnDebug, getAguaceroAuthDiagnosticSnapshot, isAguaceroRnDebugEnabled } from './aguaceroRnDebug';
-import { installAguaceroCoreDebugHooks, logProcessFrameAuthMismatch } from './aguaceroCoreDebugHooks';
-import { resolveGridRequestSiteOrigin } from './gridCdnAuth';
-import { auditSatelliteIntegration, installSatelliteDiagnosticListener } from './satelliteRnDebug';
-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.'
+import { AguaceroCore as je, DICTIONARIES as Be, formatTimelineDurationValue as ct, getUnitConversionFunction as ve, parseTimelineDurationHours as xt } from "@aguacerowx/javascript-sdk";
+import { fromByteArray as ze } from "base64-js";
+import be, { forwardRef as Tt, useCallback as we, useContext as Ct, useEffect as j, useImperativeHandle as Mt, useMemo as ut, useRef as V, useState as Je } from "react";
+import { NativeModules as vt, Platform as se, UIManager as mt } from "react-native";
+import { AguaceroContext as $t } from "./AguaceroContext";
+import { GridRenderLayer as _t } from "./GridRenderLayer";
+import Nt from "./NexradRadarLayer";
+import Dt from "./SatelliteLayer";
+import { NexradSitesMapLayer as It } from "./NexradSitesMapLayer";
+import { SatelliteAndroidController as Rt } from "./satellite/satelliteAndroidController";
+import { NexradAndroidController as Ft } from "./nexrad/nexradAndroidController";
+import { createNexradCloudFrontFetch as At } from "./cdnAuthenticatedFetch";
+import { setNexradLevel2CloudFrontFetch as dt } from "./nexrad/radarArchiveCore.bundled.js";
+import Pt from "./nws/NwsAlertsOverlay";
+import { mapRegistry as Ue } from "./MapRegistry";
+import { satBridgeWarn as Ee } from "./satelliteBridgeDiag";
+import { augmentProcessFrameOptionsForDebug as Xe, aguaceroDebugWarn as Ye, configureAguaceroRnDebug as Lt, getAguaceroAuthDiagnosticSnapshot as ft, isAguaceroRnDebugEnabled as Ke } from "./aguaceroRnDebug";
+import { installAguaceroCoreDebugHooks as Vt, logProcessFrameAuthMismatch as Qe } from "./aguaceroCoreDebugHooks";
+import { buildNativeCloudFrontFetchOptions as Ot, resolveGridRequestSiteOrigin as wt } from "./gridCdnAuth";
+import { auditSatelliteIntegration as Ut, installSatelliteDiagnosticListener as Et } from "./satelliteRnDebug";
+const Q = se.OS === "android" || se.OS === "ios",
+  ie = se.OS === "android" || se.OS === "ios";
+Ee("SDK fingerprint", {
+  platform: se.OS,
+  SATELLITE_NATIVE: ie,
+  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
- * where that helper (or {@code setMRMSDurationValue}) is missing from the prototype chain.
- */
-function getFilteredMrmsTimestampsCompat(core, variable) {
-  const raw = core.mrmsStatus?.[variable];
-  if (!raw || !raw.length) return [];
-  const hours = parseTimelineDurationHours(core.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);
+function Kt(m, x) {
+  const g = m.mrmsStatus?.[x];
+  if (!g || !g.length) return [];
+  const I = xt(m.state.mrmsDurationValue);
+  let v = [...g].map(O => Number(O)).filter(O => !Number.isNaN(O)).sort((O, _) => O - _);
+  if (I > 0 && v.length > 0) {
+    const O = v[v.length - 1] - I * 3600;
+    v = v.filter(_ => _ >= O);
   }
-  return list;
+  return v;
 }
-
-/**
- * Older npm installs may resolve an {@link AguaceroCore} without {@code setMRMSDurationValue} /
- * {@code setNexradDurationValue}; mirror those methods here using the same logic as the SDK.
- */
-async function applyMrmsDurationValue(core, value) {
-  if (typeof core.setMRMSDurationValue === 'function') {
-    await core.setMRMSDurationValue(value);
+async function qt(m, x) {
+  if (typeof m.setMRMSDurationValue == "function") {
+    await m.setMRMSDurationValue(x);
     return;
   }
-  const v = formatTimelineDurationValue(value);
-  await core.setState({
-    mrmsDurationValue: v
-  });
-  if (!core.state.isMRMS || !core.state.variable) return;
-  const filtered = typeof core._getFilteredMrmsTimestampsForVariable === 'function' ? core._getFilteredMrmsTimestampsForVariable(core.state.variable) : getFilteredMrmsTimestampsCompat(core, core.state.variable);
-  if (!filtered || filtered.length === 0) return;
-  const curN = core.state.mrmsTimestamp == null ? null : Number(core.state.mrmsTimestamp);
-  if (curN == null || !filtered.includes(curN)) {
-    await core.setState({
-      mrmsTimestamp: filtered[filtered.length - 1]
-    });
-  }
-}
-async function applyNexradDurationValue(core, value) {
-  if (typeof core.setNexradDurationValue === 'function') {
-    await core.setNexradDurationValue(value);
-    return;
-  }
-  const v = formatTimelineDurationValue(value);
-  await core.setState({
-    nexradDurationValue: v
-  });
-  if (!core.state.isNexrad || !core.state.nexradSite) return;
-  if (typeof core.refreshNexradTimes === 'function') {
-    await core.refreshNexradTimes();
-  }
-  const nk = typeof core._nexradTimesCacheKey === 'function' ? core._nexradTimesCacheKey() : null;
-  const raw = nk ? core.nexradTimesByStation?.[nk]?.unixTimes || [] : [];
-  const filtered = typeof core._getFilteredNexradTimestampsForVariable === 'function' ? core._getFilteredNexradTimestampsForVariable(raw) : [...raw].map(t => Number(t)).filter(t => !Number.isNaN(t)).sort((a, b) => a - b);
-  if (!filtered || filtered.length === 0) return;
-  const curN = core.state.nexradTimestamp == null ? null : Number(core.state.nexradTimestamp);
-  if (curN == null || !filtered.includes(curN)) {
-    await core.setState({
-      nexradTimestamp: filtered[filtered.length - 1]
-    });
-  }
+  const g = ct(x);
+  if (await m.setState({
+    mrmsDurationValue: g
+  }), !m.state.isMRMS || !m.state.variable) return;
+  const I = typeof m._getFilteredMrmsTimestampsForVariable == "function" ? m._getFilteredMrmsTimestampsForVariable(m.state.variable) : Kt(m, m.state.variable);
+  if (!I || I.length === 0) return;
+  const v = m.state.mrmsTimestamp == null ? null : Number(m.state.mrmsTimestamp);
+  (v == null || !I.includes(v)) && (await m.setState({
+    mrmsTimestamp: I[I.length - 1]
+  }));
 }
-function findLatestModelRun(modelsData, modelName) {
-  const model = modelsData?.[modelName];
-  if (!model) return null;
-  const availableDates = Object.keys(model).sort((a, b) => b.localeCompare(a));
-  for (const date of availableDates) {
-    const runs = model[date];
-    if (!runs) continue;
-    const availableRuns = Object.keys(runs).sort((a, b) => b.localeCompare(a));
-    if (availableRuns.length > 0) return {
-      date: date,
-      run: availableRuns[0]
+function Gt(m, x) {
+  const g = m?.[x];
+  if (!g) return null;
+  const I = Object.keys(g).sort((v, O) => O.localeCompare(v));
+  for (const v of I) {
+    const O = g[v];
+    if (!O) continue;
+    const _ = Object.keys(O).sort((ee, B) => B.localeCompare(ee));
+    if (_.length > 0) return {
+      date: v,
+      run: _[0]
     };
   }
   return null;
 }
 const {
-  WeatherFrameProcessorModule,
-  InspectorModule
-} = NativeModules;
-
-/**
- * `state:change` payloads can briefly have {@code isNexrad} before {@code nexradSite} / {@code nexradTimestamp}
- * are populated; {@code core.state} is updated first. Merge so readouts match the active radar.
- *
- * @param {object | null} emitted
- * @param {object | null} coreState
- */
-function mergeNexradEmittedWithCore(emitted, coreState) {
-  if (!emitted || !coreState) return null;
-  return {
-    ...emitted,
-    nexradSite: coreState.nexradSite ?? emitted.nexradSite,
-    nexradTimestamp: coreState.nexradTimestamp ?? emitted.nexradTimestamp,
-    nexradProduct: coreState.nexradProduct ?? emitted.nexradProduct,
-    nexradTilt: coreState.nexradTilt ?? emitted.nexradTilt,
-    nexradDataSource: coreState.nexradDataSource ?? emitted.nexradDataSource,
-    nexradStormRelative: coreState.nexradStormRelative ?? emitted.nexradStormRelative
-  };
+  WeatherFrameProcessorModule: qe,
+  InspectorModule: kt
+} = vt;
+function ue(m) {
+  const x = Object.keys(m?.satelliteTimeToFileMap || {}).map(Number).filter(g => Number.isFinite(g)).sort((g, I) => g - I);
+  return x.length ? `${x.length}:${x[0]}:${x[x.length - 1]}` : "0";
 }
-
-/**
- * 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 when {@link WeatherLayerManager} `debug` / {@link configureAguaceroRnDebug}, or legacy `__AGUACERO_WX_GRID_DEBUG__`. */
-function wxGridDebugEnabled() {
-  if (isAguaceroRnDebugEnabled()) return true;
+function pt() {
+  if (Ke()) return !0;
   try {
-    if (typeof __DEV__ !== 'undefined' && __DEV__) return true;
-    return Boolean(typeof globalThis !== 'undefined' && globalThis.__AGUACERO_WX_GRID_DEBUG__);
+    return typeof __DEV__ < "u" && __DEV__ ? !0 : !!(typeof globalThis < "u" && globalThis.__AGUACERO_WX_GRID_DEBUG__);
   } catch {
-    return false;
+    return !1;
   }
 }
-function wxGridVerbose(tag, detail) {
-  if (!wxGridDebugEnabled()) return;
-  if (detail !== undefined) {
-    console.log(`[AguaceroWX][grid][${tag}]`, detail);
-  } else {
-    console.log(`[AguaceroWX][grid][${tag}]`);
-  }
+function z(m, x) {
+  pt() && (x !== void 0 ? console.log(`[AguaceroWX][grid][${m}]`, x) : console.log(`[AguaceroWX][grid][${m}]`));
 }
-
-/** 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}]`);
-  }
+function Z(m, x) {
+  x !== void 0 ? console.warn(`[AguaceroWX][grid][${m}]`, x) : console.warn(`[AguaceroWX][grid][${m}]`);
 }
-
-/**
- * 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 - prop or core origin (see {@link resolveGridRequestSiteOrigin})
- * @param {import('@aguacerowx/javascript-sdk').AguaceroCore | null | undefined} core
- */
-function buildGridFrameProcessOptions(baseGridUrl, resourcePath, apiKey, bundleId, gridRequestSiteOrigin, core) {
-  const trimmedKey = typeof apiKey === 'string' ? apiKey.trim() : apiKey;
-  const url = `${baseGridUrl}${resourcePath}?apiKey=${encodeURIComponent(trimmedKey || '')}`;
-  const options = {
-    url,
-    apiKey: trimmedKey,
-    bundleId
-  };
-  const origin = resolveGridRequestSiteOrigin(gridRequestSiteOrigin, core);
-  if (origin) {
-    options.gridRequestSiteOrigin = origin;
-  }
-  return options;
+function Ze(m, x, g, I, v, O) {
+  const _ = `${m}${x}`;
+  return Ot({
+    url: _,
+    apiKey: g,
+    bundleId: I,
+    gridRequestSiteOrigin: v,
+    core: O
+  });
 }
-
-/**
- * A helper function to generate the raw RGBA byte buffer for the colormap texture.
- */
-const _generateColormapBytes = colormap => {
-  const width = 256;
-  const data = new Uint8Array(width * 4);
-  const stops = colormap.reduce((acc, _, i) => i % 2 === 0 ? [...acc, {
-    value: colormap[i],
-    color: colormap[i + 1]
-  }] : acc, []);
-  if (stops.length === 0) return data;
-  const minVal = stops[0].value;
-  const maxVal = stops[stops.length - 1].value;
-  const hexToRgb = hex => {
-    const r = parseInt(hex.slice(1, 3), 16);
-    const g = parseInt(hex.slice(3, 5), 16);
-    const b = parseInt(hex.slice(5, 7), 16);
-    return [r, g, b];
-  };
-  for (let i = 0; i < width; i++) {
-    const val = minVal + i / (width - 1) * (maxVal - minVal);
-    let lower = stops[0];
-    let upper = stops[stops.length - 1];
-    for (let j = 0; j < stops.length - 1; j++) {
-      if (val >= stops[j].value && val <= stops[j + 1].value) {
-        lower = stops[j];
-        upper = stops[j + 1];
-        break;
-      }
+const et = m => {
+  const x = new Uint8Array(1024),
+    g = m.reduce((_, ee, B) => B % 2 === 0 ? [..._, {
+      value: m[B],
+      color: m[B + 1]
+    }] : _, []);
+  if (g.length === 0) return x;
+  const I = g[0].value,
+    v = g[g.length - 1].value,
+    O = _ => {
+      const ee = parseInt(_.slice(1, 3), 16),
+        B = parseInt(_.slice(3, 5), 16),
+        fe = parseInt(_.slice(5, 7), 16);
+      return [ee, B, fe];
+    };
+  for (let _ = 0; _ < 256; _++) {
+    const ee = I + _ / 255 * (v - I);
+    let B = g[0],
+      fe = g[g.length - 1];
+    for (let J = 0; J < g.length - 1; J++) if (ee >= g[J].value && ee <= g[J + 1].value) {
+      B = g[J], fe = g[J + 1];
+      break;
     }
-    const t = (val - lower.value) / (upper.value - lower.value || 1);
-    const lowerRgb = hexToRgb(lower.color);
-    const upperRgb = hexToRgb(upper.color);
-    const rgb = lowerRgb.map((c, idx) => c * (1 - t) + upperRgb[idx] * t);
-    const offset = i * 4;
-    data[offset + 0] = Math.round(rgb[0]);
-    data[offset + 1] = Math.round(rgb[1]);
-    data[offset + 2] = Math.round(rgb[2]);
-    data[offset + 3] = 255;
+    const Ae = (ee - B.value) / (fe.value - B.value || 1),
+      Pe = O(B.color),
+      xe = O(fe.color),
+      $e = Pe.map((J, Ge) => J * (1 - Ae) + xe[Ge] * Ae),
+      Te = _ * 4;
+    x[Te + 0] = Math.round($e[0]), x[Te + 1] = Math.round($e[1]), x[Te + 2] = Math.round($e[2]), x[Te + 3] = 255;
   }
-  return data;
+  return x;
 };
-AguaceroCore.prototype.setMapCenter = function (center) {
-  this.emit('map:move', center);
+je.prototype.setMapCenter = function (m) {
+  this.emit("map:move", m);
 };
-export const WeatherLayerManager = /*#__PURE__*/forwardRef((props, ref) => {
+export const WeatherLayerManager = /*#__PURE__*/Tt((m, x) => {
   const {
-    inspectorEnabled,
-    onInspect,
-    apiKey,
-    customColormaps,
-    initialMode,
-    initialVariable,
-    /** GOES instrument when {@link initialMode} is `"satellite"` (default `GOES19-EAST`). */
-    initialSatelliteId,
-    /** Sector token or label when {@link initialMode} is `"satellite"` (default `conus` → GOES-EAST CONUS). */
-    initialSatelliteSector,
-    /** Product/band when {@link initialMode} is `"satellite"` (e.g. `geocolor`, `C13`). Falls back to {@link initialVariable}. */
-    initialSatelliteProduct,
-    autoRefresh,
-    autoRefreshInterval,
-    initialModel,
-    belowID: belowIDFromProps,
-    interpolateNexradColormap = true,
-    nexradGateSmoothing = false,
-    watchesWarnings: watchesWarningsProp,
-    onNwsAlertClick,
-    /** Same semantics as mapsgl / AguaceroCore: Origin + Referer for grid CDN (required by many CloudFront rules). */
-    gridRequestSiteOrigin,
-    /** When true, logs auth/HTTP diagnostics under `[AguaceroRN][debug]` (Metro / Logcat / Xcode). */
-    debug = false,
-    ...restProps
-  } = props;
-  useEffect(() => {
-    configureAguaceroRnDebug({
-      enabled: Boolean(debug)
+    inspectorEnabled: g,
+    onInspect: I,
+    apiKey: v,
+    customColormaps: O,
+    initialMode: _,
+    initialVariable: ee,
+    initialSatelliteId: B,
+    initialSatelliteSector: fe,
+    initialSatelliteProduct: Ae,
+    autoRefresh: Pe,
+    autoRefreshInterval: xe,
+    initialModel: $e,
+    belowID: Te,
+    watchesWarnings: J,
+    onNwsAlertClick: Ge,
+    gridRequestSiteOrigin: te,
+    debug: Ce = !1,
+    ...Ht
+  } = m;
+  j(() => {
+    Lt({
+      enabled: !!Ce
     });
-  }, [debug]);
-  useEffect(() => {
-    if (!debug) return undefined;
-    auditSatelliteIntegration({
-      core,
-      satelliteLayerRef
-    });
-    return installSatelliteDiagnosticListener();
-  }, [debug, core]);
-  const context = useContext(AguaceroContext);
-
-  // Create the core here instead of getting it from context
-  const core = useMemo(() => new AguaceroCore({
-    apiKey: apiKey,
-    customColormaps: customColormaps,
-    gridRequestSiteOrigin: gridRequestSiteOrigin,
-    layerOptions: {
-      mode: initialMode,
-      variable: initialVariable,
-      model: initialModel,
-      ...(initialMode === 'satellite' ? {
-        satelliteId: initialSatelliteId,
-        sector: initialSatelliteSector,
-        satelliteProduct: initialSatelliteProduct ?? initialVariable
-      } : {})
-    },
-    autoRefresh: false // <-- add this
-  }), [apiKey, gridRequestSiteOrigin]);
-  useEffect(() => {
-    if (!core) return;
-    installAguaceroCoreDebugHooks(core, {
-      gridRequestSiteOriginProp: gridRequestSiteOrigin ?? null,
-      debugProp: Boolean(debug)
-    });
-    if (isAguaceroRnDebugEnabled() && !apiKey) {
-      aguaceroDebugWarn('WeatherLayerManager.missingApiKey', {
-        hint: 'apiKey prop is empty — all CDN requests will fail or return 403'
-      });
-    }
-    if (isAguaceroRnDebugEnabled() && apiKey && !gridRequestSiteOrigin) {
-      aguaceroDebugWarn('WeatherLayerManager.missingGridOrigin', {
-        hint: 'gridRequestSiteOrigin is not set — CloudFront often returns 403 without Origin/Referer on React Native',
-        snapshot: getAguaceroAuthDiagnosticSnapshot(core)
-      });
-    }
-  }, [core, debug, gridRequestSiteOrigin, apiKey]);
-  const [watchesWarningsOptions, setWatchesWarningsOptions] = useState(() => ({
-    alertInteractionEnabled: true,
-    ...(watchesWarningsProp ?? {})
+  }, [Ce]), j(() => {
+    if (Ce) return Ut({
+      core: t,
+      satelliteLayerRef: Ne
+    }), Et();
+  }, [Ce, t]);
+  const _e = Ct($t),
+    t = ut(() => new je({
+      apiKey: v,
+      customColormaps: O,
+      gridRequestSiteOrigin: te,
+      layerOptions: {
+        mode: _,
+        variable: ee,
+        model: $e,
+        ...(_ === "satellite" ? {
+          satelliteId: B,
+          sector: fe,
+          satelliteProduct: Ae ?? ee
+        } : {})
+      },
+      autoRefresh: !1
+    }), [v, te]);
+  j(() => {
+    t && (Vt(t, {
+      gridRequestSiteOriginProp: te ?? null,
+      debugProp: !!Ce
+    }), Ke() && !v && Ye("WeatherLayerManager.missingApiKey", {
+      hint: "apiKey prop is empty \u2014 all CDN requests will fail or return 403"
+    }), Ke() && v && !te && Ye("WeatherLayerManager.missingGridOrigin", {
+      hint: "gridRequestSiteOrigin is not set \u2014 CloudFront often returns 403 without Origin/Referer on React Native",
+      snapshot: ft(t)
+    }));
+  }, [t, Ce, te, v]);
+  const [gt, tt] = Je(() => ({
+    alertInteractionEnabled: !0,
+    ...(J ?? {})
   }));
-  useEffect(() => {
-    setWatchesWarningsOptions(prev => ({
-      ...prev,
-      ...(watchesWarningsProp ?? {})
+  j(() => {
+    tt(r => ({
+      ...r,
+      ...(J ?? {})
     }));
-  }, [watchesWarningsProp]);
-  useEffect(() => {
-    setNexradSitesMapVisible(Boolean(core.state.isNexrad && core.state.nexradShowSitesPicker !== false));
-  }, [core]);
-  const gridLayerRef = useRef(null);
-  const nexradLayerRef = useRef(null);
-  const nexradControllerRef = useRef(null);
-  /** Latest {@code state:change} payload (includes {@code colormap}, NEXRAD maps) — required for readouts; {@code core.state} omits those. */
-  const lastEmittedStateForInspectRef = useRef(null);
-  const satelliteLayerRef = useRef(null);
-  const satelliteControllerRef = useRef(null);
-  /** @type {React.MutableRefObject<{ cancel?: () => void } | null>} */
-  const nexradPreloadInteractionRef = useRef(null);
-  const currentGridDataRef = useRef(null);
-  const autoRefreshIntervalId = useRef(null);
-  const ensureNexradController = useCallback(() => {
-    if (!NEXRAD_NATIVE) return null;
-    if (!nexradControllerRef.current) {
-      nexradControllerRef.current = new NexradAndroidController(core, nexradLayerRef, {
-        interpolateNexradColormap,
-        nexradGateSmoothing
-      });
-    }
-    return nexradControllerRef.current;
-  }, [core, interpolateNexradColormap, nexradGateSmoothing]);
-
-  /** Synchronous NEXRAD readout (mapsgl-style); no await — avoids jank on map move. */
-  const getNexradInspectPayloadAt = useCallback((lng, lat) => {
-    if (!NEXRAD_NATIVE || !core?.state?.isNexrad) return null;
-    const ctl = ensureNexradController();
-    if (!ctl) {
-      return null;
-    }
-    const emitted = lastEmittedStateForInspectRef.current;
-    if (!emitted) {
-      return null;
-    }
-    const st = mergeNexradEmittedWithCore(emitted, core.state);
-    if (!st?.nexradSite || st.nexradTimestamp == null) {
-      return null;
-    }
-    return ctl.getInspectPayload(lng, lat, st) ?? null;
-  }, [core, ensureNexradController]);
-  const ensureSatelliteController = useCallback(() => {
-    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 = [];
+  }, [J]), j(() => {
+    st(!!(t.state.isNexrad && t.state.nexradShowSitesPicker !== !1));
+  }, [t]);
+  const p = V(null),
+    rt = V(null),
+    X = V(null),
+    Ne = V(null),
+    re = V(null),
+    De = V(null),
+    me = V(null),
+    at = we(() => ie ? (re.current || (re.current = new Rt(t, Ne)), re.current) : null, [t]),
+    nt = we(() => !Q || !t ? null : (X.current || (X.current = new Ft(t, rt, {
+      interpolateNexradColormap: t.state?.shaderSmoothingEnabled !== !1
+    })), X.current), [t]),
+    ht = we(r => {
+      const {
+          colormap: a,
+          baseUnit: e
+        } = t._getColormapForVariable(r.variable),
+        o = t._getTargetUnit(e, r.units);
+      return {
+        ...r,
+        colormap: t._convertColormapUnits(a, e, o),
+        colormapBaseUnit: o
+      };
+    }, [t]),
+    Ie = we(r => {
+      if (!Q || !r?.isNexrad) return;
+      const a = nt();
+      a && (ae.current = !0, a.preloadAllAvailable(r), a.sync(r));
+    }, [nt]);
+  j(() => {
+    if (!Q || !t) return;
+    const r = wt(te, t),
+      a = At(() => ({
+        apiKey: t.apiKey,
+        bundleId: t.bundleId,
+        gridRequestSiteOrigin: r
+      }));
+    return dt(a), () => dt(null);
+  }, [t, te]), j(() => {
+    if (!ie) return;
+    let r = [],
+      a = [];
     try {
-      gridCmdKeys = Object.keys(UIManager.getViewManagerConfig?.('GridRenderLayer')?.Commands ?? {});
+      r = Object.keys(mt.getViewManagerConfig?.("GridRenderLayer")?.Commands ?? {});
     } catch {
-      gridCmdKeys = ['error'];
+      r = ["error"];
     }
     try {
-      satCmdKeys = Object.keys(UIManager.getViewManagerConfig?.('SatelliteLayer')?.Commands ?? {});
+      a = Object.keys(mt.getViewManagerConfig?.("SatelliteLayer")?.Commands ?? {});
     } catch {
-      satCmdKeys = ['error'];
+      a = ["error"];
     }
-    satBridgeWarn('mount UIManager command registration', {
-      GridRenderLayerCommands: gridCmdKeys,
-      SatelliteLayerCommands: satCmdKeys,
-      satelliteMissing: satCmdKeys.length === 0
+    Ee("mount UIManager command registration", {
+      GridRenderLayerCommands: r,
+      SatelliteLayerCommands: a,
+      satelliteMissing: a.length === 0
     });
   }, []);
-  useEffect(() => {
-    const ctl = nexradControllerRef.current;
-    if (NEXRAD_NATIVE && ctl) {
-      ctl.updateStyleOptions({
-        interpolateNexradColormap,
-        nexradGateSmoothing
-      });
-      if (core?.state?.isNexrad) {
-        ctl.applyStyleFromState(core.state);
+  const W = V(new Map()),
+    pe = V(null),
+    ge = V(null),
+    ke = V([0, 1]),
+    ae = V(!1),
+    ne = V(!1),
+    Le = V(0),
+    He = V(null),
+    l = V(null),
+    [Ve, Me] = Je({
+      opacity: 1,
+      dataRange: [0, 1]
+    }),
+    [St, st] = Je(!1);
+  Mt(x, () => ({
+    play: () => {
+      t.play();
+    },
+    pause: () => {
+      t.pause();
+    },
+    togglePlay: () => {
+      t.togglePlay();
+    },
+    step: r => {
+      t.step(r);
+    },
+    setPlaybackSpeed: r => {
+      r > 0 && (t.playbackSpeed = r, t.isPlaying && (t.pause(), t.play()));
+    },
+    setOpacity: r => t.setOpacity(r),
+    setUnits: r => t.setUnits(r),
+    switchMode: r => t.switchMode(r),
+    getAvailableVariables: r => t.getAvailableVariables(r),
+    getVariableDisplayName: r => t.getVariableDisplayName(r),
+    setRun: r => t.setState({
+      run: r.split(":")[1]
+    }),
+    setState: r => t.setState(r),
+    setMRMSTimestamp: r => t.setMRMSTimestamp(r),
+    setMRMSDurationValue: r => qt(t, r),
+    setNexradSite: r => t.setNexradSite(r),
+    setNexradProduct: r => t.setNexradProduct(r),
+    setNexradTilt: r => t.setNexradTilt(r),
+    setNexradStormRelative: r => t.setNexradStormRelative(r),
+    setNexradTimestamp: r => t.setNexradTimestamp(r),
+    setNexradDurationValue: r => typeof t.setNexradDurationValue == "function" ? t.setNexradDurationValue(r) : t.setState({
+      nexradDurationValue: ct(r)
+    }),
+    setSatelliteTimestamp: r => t.setSatelliteTimestamp(r),
+    setSatelliteDurationValue: r => t.setSatelliteDurationValue(r),
+    setSatelliteSelection: r => t.setSatelliteSelection(r),
+    setShaderSmoothing: async r => {
+      await t.setShaderSmoothing(r), p.current && p.current.setSmoothing(r);
+    },
+    setSmoothing: r => {
+      p.current && p.current.setSmoothing(r);
+    },
+    setAutoRefresh: (r, a) => {
+      if (me.current && (clearInterval(me.current), me.current = null), r) {
+        const e = (a || xe || 30) * 1e3;
+        Se(), me.current = setInterval(Se, e);
       }
+    },
+    refreshData: () => {
+      Se();
+    },
+    configureWatchesWarnings: r => {
+      tt(a => ({
+        ...a,
+        ...r
+      }));
     }
-  }, [interpolateNexradColormap, nexradGateSmoothing, core]);
-
-  // Cache for preloaded grid data - stores the processed data ready for GPU upload
-  const preloadedDataCache = useRef(new Map());
-
-  // Store geometry and colormap that don't change with forecast hour
-  const cachedGeometry = useRef(null);
-  const cachedColormap = useRef(null);
-  const cachedDataRange = useRef([0, 1]);
-
-  // Track if we've done the initial load
-  const hasInitialLoad = useRef(false);
-  const hasPreloadedRef = useRef(false);
-  /** Bumped on {@code cancelAllFrames} / full reload so stale {@code processFrame} results are ignored. */
-  const preloadGenerationRef = useRef(0);
-
-  // Track the last state we processed to avoid redundant updates
-  const lastProcessedState = useRef(null);
-  const previousStateRef = useRef(null);
-  const [renderProps, setRenderProps] = useState({
-    opacity: 1,
-    dataRange: [0, 1]
-  });
-  /** Drives {@link NexradSitesMapLayer}; must re-render when core NEXRAD / picker flags change. */
-  const [nexradSitesMapVisible, setNexradSitesMapVisible] = useState(false);
-  useImperativeHandle(ref, () => {
-    const setAutoRefresh = (enabled, intervalSeconds) => {
-      if (autoRefreshIntervalId.current) {
-        clearInterval(autoRefreshIntervalId.current);
-        autoRefreshIntervalId.current = null;
-      }
-      if (enabled) {
-        const effectiveInterval = (intervalSeconds || autoRefreshInterval || 30) * 1000;
-        // Run once immediately, then start the interval
-        _checkForUpdates();
-        autoRefreshIntervalId.current = setInterval(_checkForUpdates, effectiveInterval);
-      }
-    };
-    return {
-      play: () => {
-        core.play();
-      },
-      pause: () => {
-        core.pause();
-      },
-      togglePlay: () => {
-        core.togglePlay();
-      },
-      step: direction => {
-        core.step(direction);
-      },
-      setPlaybackSpeed: speed => {
-        if (speed > 0) {
-          core.playbackSpeed = speed;
-          if (core.isPlaying) {
-            core.pause();
-            core.play();
-          }
-        }
-      },
-      setOpacity: opacity => core.setOpacity(opacity),
-      setUnits: units => core.setUnits(units),
-      switchMode: options => core.switchMode(options),
-      getAvailableVariables: model => core.getAvailableVariables(model),
-      getVariableDisplayName: code => core.getVariableDisplayName(code),
-      setRun: runString => core.setState({
-        run: runString.split(':')[1]
-      }),
-      setState: newState => core.setState(newState),
-      setMRMSTimestamp: timestamp => core.setMRMSTimestamp(timestamp),
-      setMRMSDurationValue: value => applyMrmsDurationValue(core, value),
-      setNexradSite: siteId => core.setNexradSite(siteId),
-      setNexradProduct: product => core.setNexradProduct(product),
-      setNexradTilt: tilt => core.setNexradTilt(tilt),
-      setNexradStormRelative: enabled => core.setNexradStormRelative(enabled),
-      setNexradTimestamp: ts => core.setNexradTimestamp(ts),
-      setNexradDurationValue: value => applyNexradDurationValue(core, value),
-      setSatelliteTimestamp: timestamp => core.setSatelliteTimestamp(timestamp),
-      setSatelliteDurationValue: value => core.setSatelliteDurationValue(value),
-      setSatelliteSelection: opts => core.setSatelliteSelection(opts),
-      setShaderSmoothing: async enabled => {
-        await core.setShaderSmoothing(enabled);
-        if (gridLayerRef.current) {
-          gridLayerRef.current.setSmoothing(enabled);
-        }
-      },
-      setSmoothing: enabled => {
-        if (gridLayerRef.current) {
-          gridLayerRef.current.setSmoothing(enabled);
-        }
-      },
-      setAutoRefresh,
-      refreshData: () => {
-        _checkForUpdates();
-      },
-      /**
-       * NWS watches/warnings (native map, iOS + Android): same options as mapsgl {@link WeatherLayerManager#configureWatchesWarnings}.
-       * @param {object} partial
-       */
-      configureWatchesWarnings: partial => {
-        setWatchesWarningsOptions(prev => ({
-          ...prev,
-          ...partial
-        }));
-      }
-    };
-  }, [core, autoRefreshInterval, _checkForUpdates]);
-  const preloadAllFramesToDisk = async state => {
-    if (state.isNexrad || state.isSatellite) {
-      hasPreloadedRef.current = false;
-      wxGridVerbose('preloadSkip', {
-        reason: 'nexrad_or_satellite'
+  }), [t, xe, Se]);
+  const it = async r => {
+    if (r.isNexrad || r.isSatellite) {
+      ne.current = !1, z("preloadSkip", {
+        reason: "nexrad_or_satellite"
       });
       return;
     }
-    if (hasPreloadedRef.current) {
-      wxGridVerbose('preloadSkip', {
-        reason: 'hasPreloadedRef_gate',
-        isMRMS: state.isMRMS,
-        variable: state.variable
+    if (ne.current) {
+      z("preloadSkip", {
+        reason: "hasPreloadedRef_gate",
+        isMRMS: r.isMRMS,
+        variable: r.variable
       });
       return;
     }
     const {
-      isMRMS,
-      model,
-      date,
-      run,
-      variable,
-      units,
-      availableHours,
-      availableTimestamps,
-      forecastHour,
-      mrmsTimestamp
-    } = state;
-
-    // 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
+      isMRMS: a,
+      model: e,
+      date: o,
+      run: F,
+      variable: s,
+      units: w,
+      availableHours: N,
+      availableTimestamps: c,
+      forecastHour: i,
+      mrmsTimestamp: u
+    } = r;
+    if (a && (u == null || !c || c.length === 0)) {
+      ne.current = !1, Z("preloadAbort", {
+        reason: "mrms_missing_frame_or_timestamps",
+        mrmsTimestamp: u,
+        timestampCount: c?.length ?? 0,
+        variable: s
       });
       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
+    if (!a && (i == null || !N || N.length === 0)) {
+      ne.current = !1, Z("preloadAbort", {
+        reason: "model_missing_hour_or_hours",
+        forecastHour: i,
+        hourCount: N?.length ?? 0,
+        model: e,
+        variable: s
       });
       return;
     }
-
-    // Only mark as "has preloaded" after validation passes
-    hasPreloadedRef.current = true;
-    const generation = preloadGenerationRef.current;
-    const isStaleGeneration = () => generation !== preloadGenerationRef.current;
-    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
+    ne.current = !0;
+    const A = Le.current,
+      y = () => A !== Le.current;
+    z("preloadStart", {
+      isMRMS: a,
+      model: e,
+      date: o,
+      run: F,
+      variable: s,
+      mrmsTimestamp: a ? u : void 0,
+      forecastHour: a ? void 0 : i,
+      baseGridUrl: t?.baseGridUrl,
+      hasApiKey: !!t?.apiKey,
+      bundleId: t?.bundleId ?? null,
+      gridRequestSiteOrigin: te || 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) {
-      const validHours = availableHours.filter(hour => hour !== 0);
-      effectiveForecastHour = validHours.length > 0 ? validHours[0] : 0;
+    let M = i;
+    if (!a && s === "ptypeRefl" && e === "hrrr" && i === 0) {
+      const d = N.filter(G => G !== 0);
+      M = d.length > 0 ? d[0] : 0;
     }
-    if (!cachedGeometry.current || !cachedColormap.current) {
-      const gridModel = isMRMS ? 'mrms' : model;
-      const {
-        corners,
-        gridDef
-      } = core._getGridCornersAndDef(gridModel);
-      gridLayerRef.current.updateGeometry(corners, gridDef);
-      cachedGeometry.current = {
-        model: gridModel,
-        variable
-      };
-      wxGridVerbose('geometryColormapInit', {
-        gridModel,
-        variable,
-        nx: gridDef?.grid_params?.nx,
-        ny: gridDef?.grid_params?.ny
+    if (!pe.current || !ge.current) {
+      const d = a ? "mrms" : e,
+        {
+          corners: G,
+          gridDef: n
+        } = t._getGridCornersAndDef(d);
+      p.current.updateGeometry(G, n), pe.current = {
+        model: d,
+        variable: s
+      }, z("geometryColormapInit", {
+        gridModel: d,
+        variable: s,
+        nx: n?.grid_params?.nx,
+        ny: n?.grid_params?.ny
       });
       const {
-        colormap,
-        baseUnit
-      } = core._getColormapForVariable(variable);
-      const toUnit = core._getTargetUnit(baseUnit, units);
-      const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-      let dataRange;
-      if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
-        dataRange = isMRMS ? [5, 380] : [5, 380];
-      } else {
-        dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
-      }
-      const colormapBytes = _generateColormapBytes(finalColormap);
-      const colormapAsBase64 = fromByteArray(colormapBytes);
-      gridLayerRef.current.updateColormapTexture(colormapAsBase64);
-      cachedColormap.current = {
-        key: `${variable}-${units}`
-      };
-      cachedDataRange.current = dataRange;
-      setRenderProps({
-        opacity: state.opacity,
-        dataRange: dataRange
-      });
-      hasInitialLoad.current = true;
+          colormap: R,
+          baseUnit: h
+        } = t._getColormapForVariable(s),
+        k = t._getTargetUnit(h, w),
+        P = t._convertColormapUnits(R, h, k);
+      let f;
+      s === "ptypeRefl" || s === "ptypeRate" ? f = a ? [5, 380] : [5, 380] : f = [P[0], P[P.length - 2]];
+      const C = et(P),
+        b = ze(C);
+      p.current.updateColormapTexture(b), ge.current = {
+        key: `${s}-${w}`
+      }, ke.current = f, Me({
+        opacity: r.opacity,
+        dataRange: f
+      }), ae.current = !0;
     }
-
-    // Apply the same filtering logic as in AguaceroCore._emitStateChange
-    let filteredHours = availableHours;
-    if (!isMRMS && variable === 'ptypeRefl' && model === 'hrrr' && availableHours && availableHours.length > 0) {
-      filteredHours = availableHours.filter(hour => hour !== 0);
-    }
-    const allFrames = isMRMS ? availableTimestamps : filteredHours;
-    if (!allFrames || allFrames.length === 0) {
-      hasPreloadedRef.current = false;
-      wxGridWarn('preloadAbort', {
-        reason: 'no_frames_after_filter',
-        isMRMS,
-        variable
+    let U = N;
+    !a && s === "ptypeRefl" && e === "hrrr" && N && N.length > 0 && (U = N.filter(d => d !== 0));
+    const E = a ? c : U;
+    if (!E || E.length === 0) {
+      ne.current = !1, Z("preloadAbort", {
+        reason: "no_frames_after_filter",
+        isMRMS: a,
+        variable: s
       });
       return;
     }
-    const currentFrame = isMRMS ? mrmsTimestamp : effectiveForecastHour;
-
-    // Double-check currentFrame is valid
-    if (currentFrame == null) {
-      hasPreloadedRef.current = false;
-      wxGridWarn('preloadAbort', {
-        reason: 'currentFrame_null',
-        isMRMS,
-        variable
+    const K = a ? u : M;
+    if (K == null) {
+      ne.current = !1, Z("preloadAbort", {
+        reason: "currentFrame_null",
+        isMRMS: a,
+        variable: s
       });
       return;
     }
-
-    // Reverse the frame order to load from last to first
-    const reversedFrames = [...allFrames].reverse();
-    const framesToPreload = reversedFrames.filter(frame => frame !== currentFrame);
-    const {
-      corners,
-      gridDef
-    } = core._getGridCornersAndDef(isMRMS ? 'mrms' : model);
-    const {
-      nx,
-      ny
-    } = gridDef.grid_params;
-
-    // Load the current frame FIRST and WAIT for it before continuing
-    const currentCacheKey = isMRMS ? `mrms-${currentFrame}-${variable}` : `${model}-${date}-${run}-${currentFrame}-${variable}`;
-    if (!preloadedDataCache.current.has(currentCacheKey)) {
-      let resourcePath;
-      if (isMRMS) {
-        const frameDate = new Date(currentFrame * 1000);
-        const y = frameDate.getUTCFullYear();
-        const m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0');
-        const d = frameDate.getUTCDate().toString().padStart(2, '0');
-        resourcePath = `/grids/mrms/${y}${m}${d}/${currentFrame}/0/${variable}/0`;
-      } else {
-        resourcePath = `/grids/${model}/${date}/${run}/${currentFrame}/${variable}/0`;
-      }
-      const options = augmentProcessFrameOptionsForDebug(buildGridFrameProcessOptions(core.baseGridUrl, resourcePath, core.apiKey, core.bundleId, gridRequestSiteOrigin, core), core);
-      logProcessFrameAuthMismatch(core, options, {
-        phase: 'preloadCurrent',
-        currentCacheKey
+    const Y = [...E].reverse().filter(d => d !== K),
+      {
+        corners: D,
+        gridDef: q
+      } = t._getGridCornersAndDef(a ? "mrms" : e),
+      {
+        nx: de,
+        ny: ye
+      } = q.grid_params,
+      $ = a ? `mrms-${K}-${s}` : `${e}-${o}-${F}-${K}-${s}`;
+    if (!W.current.has($)) {
+      let d;
+      if (a) {
+        const n = new Date(K * 1e3),
+          R = n.getUTCFullYear(),
+          h = (n.getUTCMonth() + 1).toString().padStart(2, "0"),
+          k = n.getUTCDate().toString().padStart(2, "0");
+        d = `/grids/mrms/${R}${h}${k}/${K}/0/${s}/0`;
+      } else d = `/grids/${e}/${o}/${F}/${K}/${s}/0`;
+      const G = Xe(Ze(t.baseGridUrl, d, t.apiKey, t.bundleId, te, t), t);
+      Qe(t, G, {
+        phase: "preloadCurrent",
+        currentCacheKey: $
       });
       try {
-        wxGridVerbose('processFrameRequest', {
-          currentCacheKey,
-          resourcePath,
-          frame: currentFrame
+        z("processFrameRequest", {
+          currentCacheKey: $,
+          resourcePath: d,
+          frame: K
         });
-        const result = await WeatherFrameProcessorModule.processFrame(options);
-        if (isStaleGeneration()) {
-          wxGridVerbose('preloadCurrentFrameStale', {
-            currentCacheKey,
-            generation
+        const n = await qe.processFrame(G);
+        if (y()) {
+          z("preloadCurrentFrameStale", {
+            currentCacheKey: $,
+            generation: A
           });
           return;
         }
-        if (!result || !result.filePath) {
-          hasPreloadedRef.current = false;
-          wxGridWarn('preloadAbort', {
-            reason: 'processFrame_empty_result',
-            currentCacheKey,
-            resultKeys: result ? Object.keys(result) : []
+        if (!n || !n.filePath) {
+          ne.current = !1, Z("preloadAbort", {
+            reason: "processFrame_empty_result",
+            currentCacheKey: $,
+            resultKeys: n ? Object.keys(n) : []
           });
           return;
         }
         const {
-          baseUnit
-        } = core._getColormapForVariable(variable);
-        const toUnit = core._getTargetUnit(baseUnit, units);
-        const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
-        const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
-        let dataScale = result.scale;
-        let dataOffset = result.offset;
-        let convertedScale = dataScale;
-        let convertedOffset = dataOffset;
-        if (serverDataUnit !== baseUnit) {
-          const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
-          if (conversionFunc) {
-            if (result.scaleType === 'sqrt') {
-              const physicalAtOffset = dataOffset * dataOffset;
-              const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-              const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
-              const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-              convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
-              const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-              convertedScale = newOffsetPlusScale - convertedOffset;
-            } else {
-              convertedOffset = conversionFunc(dataOffset);
-              const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-              convertedScale = convertedOffsetPlusScale - convertedOffset;
-            }
-            dataScale = convertedScale;
-            dataOffset = convertedOffset;
+            baseUnit: R
+          } = t._getColormapForVariable(s),
+          h = t._getTargetUnit(R, w),
+          k = (Be?.fld?.[s] || {}).defaultUnit || R;
+        let P = n.scale,
+          f = n.offset,
+          C = P,
+          b = f;
+        if (k !== R) {
+          const T = ve(k, R);
+          if (T) {
+            if (n.scaleType === "sqrt") {
+              const L = f * f,
+                H = (f + P) * (f + P),
+                oe = T(L),
+                ce = T(H);
+              b = Math.sqrt(Math.abs(oe)) * Math.sign(oe), C = Math.sqrt(Math.abs(ce)) * Math.sign(ce) - b;
+            } else b = T(f), C = T(f + P) - b;
+            P = C, f = b;
           }
         }
-        if (baseUnit !== toUnit) {
-          const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
-          if (conversionFunc) {
-            if (result.scaleType === 'sqrt') {
-              const physicalAtOffset = dataOffset * dataOffset;
-              const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-              const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
-              const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-              convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
-              const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-              convertedScale = newOffsetPlusScale - convertedOffset;
-            } else {
-              convertedOffset = conversionFunc(dataOffset);
-              const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-              convertedScale = convertedOffsetPlusScale - convertedOffset;
-            }
-          }
+        if (R !== h) {
+          const T = ve(R, h);
+          if (T) if (n.scaleType === "sqrt") {
+            const L = f * f,
+              H = (f + P) * (f + P),
+              oe = T(L),
+              ce = T(H);
+            b = Math.sqrt(Math.abs(oe)) * Math.sign(oe), C = Math.sqrt(Math.abs(ce)) * Math.sign(ce) - b;
+          } else b = T(f), C = T(f + P) - b;
         }
-        const frameData = {
-          filePath: result.filePath,
-          nx,
-          ny,
-          scale: convertedScale,
-          offset: convertedOffset,
-          missing: result.missing,
-          corners,
-          gridDef,
-          scaleType: result.scaleType,
-          originalScale: result.scale,
-          originalOffset: result.offset
-        };
-        preloadedDataCache.current.set(currentCacheKey, frameData);
-
-        // Update the GPU with the current frame
-        gridLayerRef.current.updateDataTextureFromFile(frameData.filePath, frameData.nx, frameData.ny, frameData.scale, frameData.offset, frameData.missing, frameData.scaleType);
-        currentGridDataRef.current = {
-          nx: frameData.nx,
-          ny: frameData.ny,
-          scale: frameData.scale,
-          offset: frameData.offset,
-          missing: frameData.missing,
-          gridDef: frameData.gridDef,
-          variable: variable,
-          units: units,
-          scaleType: frameData.scaleType
+        const S = {
+          filePath: n.filePath,
+          nx: de,
+          ny: ye,
+          scale: C,
+          offset: b,
+          missing: n.missing,
+          corners: D,
+          gridDef: q,
+          scaleType: n.scaleType,
+          originalScale: n.scale,
+          originalOffset: n.offset
         };
-        wxGridVerbose('preloadCurrentFrameOk', {
-          currentCacheKey,
-          nx: frameData.nx,
-          ny: frameData.ny,
-          scale: frameData.scale,
-          offset: frameData.offset,
-          filePathSuffix: String(frameData.filePath).split('/').pop()
+        W.current.set($, S), p.current.updateDataTextureFromFile(S.filePath, S.nx, S.ny, S.scale, S.offset, S.missing, S.scaleType), De.current = {
+          nx: S.nx,
+          ny: S.ny,
+          scale: S.scale,
+          offset: S.offset,
+          missing: S.missing,
+          gridDef: S.gridDef,
+          variable: s,
+          units: w,
+          scaleType: S.scaleType
+        }, z("preloadCurrentFrameOk", {
+          currentCacheKey: $,
+          nx: S.nx,
+          ny: S.ny,
+          scale: S.scale,
+          offset: S.offset,
+          filePathSuffix: String(S.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;
-          const errDetail = {
-            currentCacheKey,
-            code: e?.code,
-            message: e?.message,
-            userInfo: e?.userInfo
+      } catch (n) {
+        if (n && (n.code === "E_CANCELLED" || n?.userInfo?.code === "E_CANCELLED" || typeof n?.message == "string" && n.message.includes("superseded"))) z("preloadProcessFrameCancelled", {
+          currentCacheKey: $
+        });else {
+          ne.current = !1;
+          const R = {
+            currentCacheKey: $,
+            code: n?.code,
+            message: n?.message,
+            userInfo: n?.userInfo
           };
-          wxGridWarn('preloadProcessFrameError', errDetail);
-          if (isAguaceroRnDebugEnabled()) {
-            aguaceroDebugWarn('preloadProcessFrameError', {
-              ...errDetail,
-              auth: getAguaceroAuthDiagnosticSnapshot(core),
-              is403: e?.code === 'HTTP_ERROR' && typeof e?.message === 'string' && e.message.includes('403')
-            });
-          }
-        } else {
-          wxGridVerbose('preloadProcessFrameCancelled', {
-            currentCacheKey
+          Z("preloadProcessFrameError", R), Ke() && Ye("preloadProcessFrameError", {
+            ...R,
+            auth: ft(t),
+            is403: n?.code === "HTTP_ERROR" && typeof n?.message == "string" && n.message.includes("403")
           });
         }
       }
     }
-
-    // NOW preload the rest of the frames asynchronously
-    framesToPreload.forEach(frame => {
-      const cacheKey = isMRMS ? `mrms-${frame}-${variable}` : `${model}-${date}-${run}-${frame}-${variable}`;
-      if (preloadedDataCache.current.has(cacheKey)) {
-        return;
-      }
-      let resourcePath;
-      if (isMRMS) {
-        const frameDate = new Date(frame * 1000);
-        const y = frameDate.getUTCFullYear();
-        const m = (frameDate.getUTCMonth() + 1).toString().padStart(2, '0');
-        const d = frameDate.getUTCDate().toString().padStart(2, '0');
-        resourcePath = `/grids/mrms/${y}${m}${d}/${frame}/0/${variable}/0`;
-      } else {
-        resourcePath = `/grids/${model}/${date}/${run}/${frame}/${variable}/0`;
-      }
-      const options = augmentProcessFrameOptionsForDebug(buildGridFrameProcessOptions(core.baseGridUrl, resourcePath, core.apiKey, core.bundleId, gridRequestSiteOrigin, core), core);
-      logProcessFrameAuthMismatch(core, options, {
-        phase: 'preloadBackground',
-        cacheKey
-      });
-      WeatherFrameProcessorModule.processFrame(options).then(result => {
-        if (isStaleGeneration()) {
-          return;
-        }
-        if (!result || !result.filePath) {
-          return;
-        }
-
-        // ADD: Same two-step conversion as the current frame
+    Y.forEach(d => {
+      const G = a ? `mrms-${d}-${s}` : `${e}-${o}-${F}-${d}-${s}`;
+      if (W.current.has(G)) return;
+      let n;
+      if (a) {
+        const h = new Date(d * 1e3),
+          k = h.getUTCFullYear(),
+          P = (h.getUTCMonth() + 1).toString().padStart(2, "0"),
+          f = h.getUTCDate().toString().padStart(2, "0");
+        n = `/grids/mrms/${k}${P}${f}/${d}/0/${s}/0`;
+      } else n = `/grids/${e}/${o}/${F}/${d}/${s}/0`;
+      const R = Xe(Ze(t.baseGridUrl, n, t.apiKey, t.bundleId, te, t), t);
+      Qe(t, R, {
+        phase: "preloadBackground",
+        cacheKey: G
+      }), qe.processFrame(R).then(h => {
+        if (y() || !h || !h.filePath) return;
         const {
-          baseUnit
-        } = core._getColormapForVariable(variable);
-        const toUnit = core._getTargetUnit(baseUnit, units);
-        const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
-        const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
-        let dataScale = result.scale;
-        let dataOffset = result.offset;
-        let convertedScale = dataScale;
-        let convertedOffset = dataOffset;
-
-        // Step 1: Convert from server unit to colormap base unit
-        if (serverDataUnit !== baseUnit) {
-          const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
-          if (conversionFunc) {
-            if (result.scaleType === 'sqrt') {
-              const physicalAtOffset = dataOffset * dataOffset;
-              const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-              const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
-              const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-              convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
-              const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-              convertedScale = newOffsetPlusScale - convertedOffset;
-            } else {
-              convertedOffset = conversionFunc(dataOffset);
-              const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-              convertedScale = convertedOffsetPlusScale - convertedOffset;
-            }
-            dataScale = convertedScale;
-            dataOffset = convertedOffset;
+            baseUnit: k
+          } = t._getColormapForVariable(s),
+          P = t._getTargetUnit(k, w),
+          f = (Be?.fld?.[s] || {}).defaultUnit || k;
+        let C = h.scale,
+          b = h.offset,
+          S = C,
+          T = b;
+        if (f !== k) {
+          const H = ve(f, k);
+          if (H) {
+            if (h.scaleType === "sqrt") {
+              const oe = b * b,
+                ce = (b + C) * (b + C),
+                Re = H(oe),
+                Fe = H(ce);
+              T = Math.sqrt(Math.abs(Re)) * Math.sign(Re), S = Math.sqrt(Math.abs(Fe)) * Math.sign(Fe) - T;
+            } else T = H(b), S = H(b + C) - T;
+            C = S, b = T;
           }
         }
-
-        // Step 2: Convert from colormap base unit to target display unit
-        if (baseUnit !== toUnit) {
-          const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
-          if (conversionFunc) {
-            if (result.scaleType === 'sqrt') {
-              const physicalAtOffset = dataOffset * dataOffset;
-              const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-              const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
-              const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-              convertedOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
-              const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-              convertedScale = newOffsetPlusScale - convertedOffset;
-            } else {
-              convertedOffset = conversionFunc(dataOffset);
-              const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-              convertedScale = convertedOffsetPlusScale - convertedOffset;
-            }
-          }
+        if (k !== P) {
+          const H = ve(k, P);
+          if (H) if (h.scaleType === "sqrt") {
+            const oe = b * b,
+              ce = (b + C) * (b + C),
+              Re = H(oe),
+              Fe = H(ce);
+            T = Math.sqrt(Math.abs(Re)) * Math.sign(Re), S = Math.sqrt(Math.abs(Fe)) * Math.sign(Fe) - T;
+          } else T = H(b), S = H(b + C) - T;
         }
-        const frameData = {
-          filePath: result.filePath,
-          nx,
-          ny,
-          scale: convertedScale,
-          offset: convertedOffset,
-          missing: result.missing,
-          corners,
-          gridDef,
-          scaleType: result.scaleType,
-          originalScale: result.scale,
-          originalOffset: result.offset
+        const L = {
+          filePath: h.filePath,
+          nx: de,
+          ny: ye,
+          scale: S,
+          offset: T,
+          missing: h.missing,
+          corners: D,
+          gridDef: q,
+          scaleType: h.scaleType,
+          originalScale: h.scale,
+          originalOffset: h.offset
         };
-        preloadedDataCache.current.set(cacheKey, frameData);
-        if (Platform.OS === 'ios' && gridLayerRef.current.primeGpuCache) {
-          const frameInfoForGpu = {
-            [cacheKey]: {
-              filePath: frameData.filePath,
-              nx: frameData.nx,
-              ny: frameData.ny,
-              scale: frameData.scale,
-              offset: frameData.offset,
-              missing: frameData.missing,
-              scaleType: frameData.scaleType || 'linear',
-              originalScale: frameData.originalScale,
-              originalOffset: frameData.originalOffset
+        if (W.current.set(G, L), se.OS === "ios" && p.current.primeGpuCache) {
+          const H = {
+            [G]: {
+              filePath: L.filePath,
+              nx: L.nx,
+              ny: L.ny,
+              scale: L.scale,
+              offset: L.offset,
+              missing: L.missing,
+              scaleType: L.scaleType || "linear",
+              originalScale: L.originalScale,
+              originalOffset: L.originalOffset
             }
           };
-          gridLayerRef.current.primeGpuCache(frameInfoForGpu);
-        }
-      }).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
-          });
+          p.current.primeGpuCache(H);
         }
+      }).catch(h => {
+        h && (h.code === "E_CANCELLED" || h?.userInfo?.code === "E_CANCELLED" || typeof h?.message == "string" && h.message.includes("superseded")) || Z("backgroundFrameError", {
+          cacheKey: G,
+          code: h?.code,
+          message: h?.message
+        });
       });
     });
   };
-  useEffect(() => {
-    // This effect manages the auto-refresh based on props
-    if (autoRefresh) {
-      const interval = (autoRefreshInterval || 30) * 1000;
-      _checkForUpdates(); // Run immediately on enable
-      autoRefreshIntervalId.current = setInterval(_checkForUpdates, interval);
+  j(() => {
+    if (Pe) {
+      const r = (xe || 30) * 1e3;
+      Se(), me.current = setInterval(Se, r);
     }
-
-    // Cleanup function: this runs when the component unmounts or props change
     return () => {
-      if (autoRefreshIntervalId.current) {
-        clearInterval(autoRefreshIntervalId.current);
-        autoRefreshIntervalId.current = null;
-      }
+      me.current && (clearInterval(me.current), me.current = null);
     };
-  }, [autoRefresh, autoRefreshInterval, _checkForUpdates]);
-  const updateGPUWithCachedData = state => {
-    const {
-      model,
-      date,
-      run,
-      forecastHour,
-      variable,
-      units,
-      isMRMS,
-      mrmsTimestamp
-    } = state;
-    const cacheKey = isMRMS ? `mrms-${mrmsTimestamp}-${variable}` : `${model}-${date}-${run}-${forecastHour}-${variable}`;
-    if (Platform.OS === 'ios' && gridLayerRef.current.setActiveFrame) {
-      // Get the cached data BEFORE calling setActiveFrame
-      const cachedData = preloadedDataCache.current.get(cacheKey);
-      if (cachedData) {
-        currentGridDataRef.current = {
-          nx: cachedData.nx,
-          ny: cachedData.ny,
-          scale: cachedData.scale,
-          offset: cachedData.offset,
-          missing: cachedData.missing,
-          gridDef: cachedData.gridDef,
-          variable: variable,
-          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;
-    }
-    if (!cachedGeometry.current || cachedGeometry.current.model !== (isMRMS ? 'mrms' : model) || cachedGeometry.current.variable !== variable) {
-      gridLayerRef.current.updateGeometry(cachedData.corners, cachedData.gridDef);
-      cachedGeometry.current = {
-        model: isMRMS ? 'mrms' : model,
-        variable
-      };
-    }
-    const colormapKey = `${variable}-${units}`;
-    if (!cachedColormap.current || cachedColormap.current.key !== colormapKey) {
+  }, [Pe, xe, Se]);
+  const yt = r => {
       const {
-        colormap,
-        baseUnit
-      } = core._getColormapForVariable(variable);
-      const toUnit = core._getTargetUnit(baseUnit, units);
-      const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-      let dataRange;
-      if (variable === 'ptypeRefl' || variable === 'ptypeRate') {
-        if (isMRMS) {
-          dataRange = [5, 380];
-        } else {
-          dataRange = [5, 380];
-        }
-      } else {
-        dataRange = [finalColormap[0], finalColormap[finalColormap.length - 2]];
+          model: a,
+          date: e,
+          run: o,
+          forecastHour: F,
+          variable: s,
+          units: w,
+          isMRMS: N,
+          mrmsTimestamp: c
+        } = r,
+        i = N ? `mrms-${c}-${s}` : `${a}-${e}-${o}-${F}-${s}`;
+      if (se.OS === "ios" && p.current.setActiveFrame) {
+        const y = W.current.get(i);
+        return y ? De.current = {
+          nx: y.nx,
+          ny: y.ny,
+          scale: y.scale,
+          offset: y.offset,
+          missing: y.missing,
+          gridDef: y.gridDef,
+          variable: s,
+          units: w,
+          scaleType: y.scaleType
+        } : z("gpuIOS_setActiveFrame_no_row", {
+          cacheKey: i,
+          cacheSize: W.current.size
+        }), p.current.setActiveFrame(i), z("gpuIOS_setActiveFrame", {
+          cacheKey: i,
+          hadCachedRow: !!y
+        }), !0;
       }
-      const colormapBytes = _generateColormapBytes(finalColormap);
-      const colormapAsBase64 = fromByteArray(colormapBytes);
-      gridLayerRef.current.updateColormapTexture(colormapAsBase64);
-      cachedColormap.current = {
-        key: colormapKey
-      };
-      cachedDataRange.current = dataRange;
-      setRenderProps(prev => ({
-        ...prev,
-        dataRange
-      }));
-    }
-    if (cachedData.filePath) {
-      gridLayerRef.current.updateDataTextureFromFile(cachedData.filePath, cachedData.nx, cachedData.ny, cachedData.scale, cachedData.offset, cachedData.missing, cachedData.scaleType);
-      currentGridDataRef.current = {
-        nx: cachedData.nx,
-        ny: cachedData.ny,
-        scale: cachedData.scale,
-        offset: cachedData.offset,
-        missing: cachedData.missing,
-        gridDef: cachedData.gridDef,
-        variable: variable,
-        units: units,
-        scaleType: cachedData.scaleType
-      };
-      wxGridVerbose('gpuUploadFromFile', {
-        cacheKey,
-        nx: cachedData.nx,
-        ny: cachedData.ny,
-        filePathSuffix: String(cachedData.filePath).split('/').pop()
+      const u = W.current.get(i);
+      if (!u) return Z("updateGPUNoCache", {
+        cacheKey: i,
+        cacheSize: W.current.size,
+        sampleKeys: Array.from(W.current.keys()).slice(0, 5)
+      }), !1;
+      if (!p.current) return Z("updateGPUNoGridLayerRef", {
+        cacheKey: i
+      }), !1;
+      (!pe.current || pe.current.model !== (N ? "mrms" : a) || pe.current.variable !== s) && (p.current.updateGeometry(u.corners, u.gridDef), pe.current = {
+        model: N ? "mrms" : a,
+        variable: s
       });
-    } else {
-      wxGridWarn('updateGPUNoFilePath', {
-        cacheKey
-      });
-      return false;
-    }
-
-    // Update inspector parameters for file-based data too
-    if (gridLayerRef.current && gridLayerRef.current.updateDataParameters) {
-      gridLayerRef.current.updateDataParameters(cachedData.scale, cachedData.offset, cachedData.missing);
-    }
-    return true;
-  };
-  const handleStateChangeRef = useRef(null);
-  const debounceTimeoutRef = useRef(null);
-  useEffect(() => {
-    if (core && props.customColormaps) {
-      core.customColormaps = props.customColormaps;
-      // Trigger a re-render if we already have data loaded
-      if (hasInitialLoad.current) {
-        core._emitStateChange();
-      }
-    }
-  }, [core, props.customColormaps]);
-  const getValueAtPoint = async (lng, lat) => {
-    if (!core) {
-      return null;
-    }
-    if (NEXRAD_NATIVE && core.state?.isNexrad) {
-      return getNexradInspectPayloadAt(lng, lat);
-    }
-
-    // ADD THIS: Check if we have valid data before attempting inspection
-    if (!currentGridDataRef.current) {
-      return null;
-    }
-    try {
-      const gridIndices = core._getGridIndexFromLngLat(lng, lat);
-      if (!gridIndices) return null;
-      const {
-        i,
-        j
-      } = gridIndices;
-      const value = await InspectorModule.getValueAtGridIndex(i, j);
-      if (value === null) {
-        return null;
-      }
-      const {
-        colormap,
-        baseUnit
-      } = core._getColormapForVariable(core.state.variable);
-      const displayUnit = core._getTargetUnit(baseUnit, core.state.units);
-      const finalColormap = core._convertColormapUnits(colormap, baseUnit, displayUnit);
-      const minThreshold = finalColormap[0];
-      if (value < minThreshold) {
-        return null;
+      const A = `${s}-${w}`;
+      if (!ge.current || ge.current.key !== A) {
+        const {
+            colormap: y,
+            baseUnit: M
+          } = t._getColormapForVariable(s),
+          U = t._getTargetUnit(M, w),
+          E = t._convertColormapUnits(y, M, U);
+        let K;
+        s === "ptypeRefl" || s === "ptypeRate" ? N ? K = [5, 380] : K = [5, 380] : K = [E[0], E[E.length - 2]];
+        const Y = et(E),
+          D = ze(Y);
+        p.current.updateColormapTexture(D), ge.current = {
+          key: A
+        }, ke.current = K, Me(q => ({
+          ...q,
+          dataRange: K
+        }));
       }
-
-      // Filter out values below the minimum threshold (matching shader behavior)
-      if (value < minThreshold) {
-        return null;
+      if (u.filePath) p.current.updateDataTextureFromFile(u.filePath, u.nx, u.ny, u.scale, u.offset, u.missing, u.scaleType), De.current = {
+        nx: u.nx,
+        ny: u.ny,
+        scale: u.scale,
+        offset: u.offset,
+        missing: u.missing,
+        gridDef: u.gridDef,
+        variable: s,
+        units: w,
+        scaleType: u.scaleType
+      }, z("gpuUploadFromFile", {
+        cacheKey: i,
+        nx: u.nx,
+        ny: u.ny,
+        filePathSuffix: String(u.filePath).split("/").pop()
+      });else return Z("updateGPUNoFilePath", {
+        cacheKey: i
+      }), !1;
+      return p.current && p.current.updateDataParameters && p.current.updateDataParameters(u.scale, u.offset, u.missing), !0;
+    },
+    he = V(null),
+    le = V(null);
+  j(() => {
+    t && m.customColormaps && (t.customColormaps = m.customColormaps, ae.current && t._emitStateChange());
+  }, [t, m.customColormaps]);
+  const lt = async (r, a) => {
+      if (!t) return null;
+      if (t.state?.isNexrad) {
+        const e = X.current;
+        return e ? e.getInspectPayload(r, a, ht(t.state)) : null;
       }
-
-      // Also check if value is NaN or effectively missing
-      if (!isFinite(value)) {
+      if (!De.current) return null;
+      try {
+        const e = t._getGridIndexFromLngLat(r, a);
+        if (!e) return null;
+        const {
+            i: o,
+            j: F
+          } = e,
+          s = await kt.getValueAtGridIndex(o, F);
+        if (s === null) return null;
+        const {
+            colormap: w,
+            baseUnit: N
+          } = t._getColormapForVariable(t.state.variable),
+          c = t._getTargetUnit(N, t.state.units),
+          i = t._convertColormapUnits(w, N, c)[0];
+        return s < i || s < i || !isFinite(s) ? null : {
+          value: s,
+          unit: c,
+          variable: {
+            code: t.state.variable,
+            name: t.getVariableDisplayName(t.state.variable)
+          },
+          lngLat: {
+            lng: r,
+            lat: a
+          }
+        };
+      } catch {
         return null;
       }
-      return {
-        value: value,
-        unit: displayUnit,
-        variable: {
-          code: core.state.variable,
-          name: core.getVariableDisplayName(core.state.variable)
-        },
-        lngLat: {
-          lng,
-          lat
-        }
-      };
-    } catch {
-      return null;
-    }
-  };
-  const getValueAtPointRef = useRef(getValueAtPoint);
-  getValueAtPointRef.current = getValueAtPoint;
-  const getNexradInspectPayloadAtRef = useRef(getNexradInspectPayloadAt);
-  getNexradInspectPayloadAtRef.current = getNexradInspectPayloadAt;
-  const _checkForUpdates = useMemo(() => async () => {
-    if (!core) return;
-    const s = core.state;
-    const {
-      isMRMS,
-      isSatellite,
-      isNexrad,
-      model: currentModel,
-      variable: currentVariable,
-      date,
-      run
-    } = s;
-    if (isSatellite) {
-      const prevTimeline = core._computeSatelliteTimeline();
-      const prevTimes = [...(prevTimeline.unixTimes || [])].map(t => Number(t)).filter(t => !Number.isNaN(t)).sort((a, b) => a - b);
-      const prevMax = prevTimes.length ? prevTimes[prevTimes.length - 1] : null;
-      const curSat = s.satelliteTimestamp == null ? null : Number(s.satelliteTimestamp);
-      await core.fetchSatelliteListing(true);
-      core._emitStateChange();
-      const nextTimeline = core._computeSatelliteTimeline();
-      const nextTimes = [...(nextTimeline.unixTimes || [])].map(t => Number(t)).filter(t => !Number.isNaN(t)).sort((a, b) => a - b);
-      const newMax = nextTimes.length ? nextTimes[nextTimes.length - 1] : null;
-      if (prevMax != null && curSat != null && curSat === prevMax && newMax != null && newMax > prevMax) {
-        await core.setSatelliteTimestamp(newMax);
-      } else if (curSat != null && newMax != null && nextTimes.length && !nextTimes.includes(curSat)) {
-        await core.setSatelliteTimestamp(newMax);
-      }
+    },
+    We = V(lt);
+  We.current = lt;
+  const Se = ut(() => async () => {
+    if (!t) return;
+    const r = t.state,
+      {
+        isMRMS: a,
+        isSatellite: e,
+        isNexrad: o,
+        model: F,
+        variable: s,
+        date: w,
+        run: N
+      } = r;
+    if (e) {
+      const c = [...(t._computeSatelliteTimeline().unixTimes || [])].map(M => Number(M)).filter(M => !Number.isNaN(M)).sort((M, U) => M - U),
+        i = c.length ? c[c.length - 1] : null,
+        u = r.satelliteTimestamp == null ? null : Number(r.satelliteTimestamp);
+      await t.fetchSatelliteListing(!0), t._emitStateChange();
+      const A = [...(t._computeSatelliteTimeline().unixTimes || [])].map(M => Number(M)).filter(M => !Number.isNaN(M)).sort((M, U) => M - U),
+        y = A.length ? A[A.length - 1] : null;
+      i != null && u != null && u === i && y != null && y > i ? await t.setSatelliteTimestamp(y) : u != null && y != null && A.length && !A.includes(u) && (await t.setSatelliteTimestamp(y));
       return;
     }
-    if (isNexrad && s.nexradSite) {
-      const nk = core._nexradTimesCacheKey();
-      const rawBefore = nk ? core.nexradTimesByStation[nk]?.unixTimes : [];
-      const filteredBefore = core._getFilteredNexradTimestampsForVariable(rawBefore || []);
-      const prevMax = filteredBefore.length ? filteredBefore[filteredBefore.length - 1] : null;
-      const curNx = s.nexradTimestamp == null ? null : Number(s.nexradTimestamp);
-      await core.refreshNexradTimes();
-      const rawAfter = nk ? core.nexradTimesByStation[nk]?.unixTimes : [];
-      const filteredAfter = core._getFilteredNexradTimestampsForVariable(rawAfter || []);
-      const newMax = filteredAfter.length ? filteredAfter[filteredAfter.length - 1] : null;
-      if (prevMax != null && curNx != null && curNx === prevMax && newMax != null && newMax > prevMax) {
-        await core.setNexradTimestamp(newMax);
-      } else if (curNx != null && newMax != null && filteredAfter.length && !filteredAfter.includes(curNx)) {
-        await core.setNexradTimestamp(newMax);
-      }
+    if (o && r.nexradSite) {
+      const c = t._nexradTimesCacheKey(),
+        i = c ? t.nexradTimesByStation[c]?.unixTimes : [],
+        u = t._getFilteredNexradTimestampsForVariable(i || []),
+        A = u.length ? u[u.length - 1] : null,
+        y = r.nexradTimestamp == null ? null : Number(r.nexradTimestamp);
+      await t.refreshNexradTimes(), t._emitStateChange();
+      const M = c ? t.nexradTimesByStation[c]?.unixTimes : [],
+        U = t._getFilteredNexradTimestampsForVariable(M || []),
+        E = U.length ? U[U.length - 1] : null;
+      A != null && y != null && y === A && E != null && E > A ? await t.setNexradTimestamp(E) : y != null && E != null && U.length && !U.includes(y) && (await t.setNexradTimestamp(E));
       return;
     }
-    if (isMRMS) {
-      // --- MRMS LOGIC (Keep existing logic) ---
-      const oldTimestamps = new Set(core.mrmsStatus?.[currentVariable] || []);
-      const mrmsStatus = await core.fetchMRMSStatus(true);
-      const newTimestamps = mrmsStatus?.[currentVariable] || [];
-      if (newTimestamps.length === 0) return;
-      const newTimestampsToPreload = newTimestamps.filter(ts => !oldTimestamps.has(ts));
-      if (newTimestampsToPreload.length > 0) {
-        core.mrmsStatus = mrmsStatus;
-        core._emitStateChange(); // Update UI slider without changing selection
-
-        // ... (Keep your existing preloading logic here) ...
-        const {
-          corners,
-          gridDef
-        } = core._getGridCornersAndDef('mrms');
+    if (a) {
+      const c = new Set(t.mrmsStatus?.[s] || []),
+        i = await t.fetchMRMSStatus(!0),
+        u = i?.[s] || [];
+      if (u.length === 0) return;
+      const A = u.filter(y => !c.has(y));
+      if (A.length > 0) {
+        t.mrmsStatus = i, t._emitStateChange();
         const {
-          nx,
-          ny
-        } = gridDef.grid_params;
-        newTimestampsToPreload.forEach(frame => {
-          const cacheKey = `mrms-${frame}-${currentVariable}`;
-          if (preloadedDataCache.current.has(cacheKey)) return;
-          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 options = augmentProcessFrameOptionsForDebug(buildGridFrameProcessOptions(core.baseGridUrl, resourcePath, core.apiKey, core.bundleId, gridRequestSiteOrigin, core), core);
-          logProcessFrameAuthMismatch(core, options, {
-            phase: 'mrmsRefresh',
-            cacheKey
-          });
-          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
+            corners: y,
+            gridDef: M
+          } = t._getGridCornersAndDef("mrms"),
+          {
+            nx: U,
+            ny: E
+          } = M.grid_params;
+        A.forEach(Y => {
+          const D = `mrms-${Y}-${s}`;
+          if (W.current.has(D)) return;
+          const q = new Date(Y * 1e3),
+            de = q.getUTCFullYear(),
+            ye = (q.getUTCMonth() + 1).toString().padStart(2, "0"),
+            $ = q.getUTCDate().toString().padStart(2, "0"),
+            d = `/grids/mrms/${de}${ye}${$}/${Y}/0/${s}/0`,
+            G = Xe(Ze(t.baseGridUrl, d, t.apiKey, t.bundleId, te, t), t);
+          Qe(t, G, {
+            phase: "mrmsRefresh",
+            cacheKey: D
+          }), qe.processFrame(G).then(n => {
+            if (!n || !n.filePath) return;
+            const R = {
+              filePath: n.filePath,
+              nx: U,
+              ny: E,
+              scale: n.scale,
+              offset: n.offset,
+              missing: n.missing,
+              corners: y,
+              gridDef: M,
+              scaleType: n.scaleType,
+              originalScale: n.scale,
+              originalOffset: n.offset
             };
-            preloadedDataCache.current.set(cacheKey, frameData);
-            if (Platform.OS === 'ios' && gridLayerRef.current?.primeGpuCache) {
-              gridLayerRef.current.primeGpuCache({
-                [cacheKey]: frameData
-              });
-            }
-          }).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
-              });
-            }
+            W.current.set(D, R), se.OS === "ios" && p.current?.primeGpuCache && p.current.primeGpuCache({
+              [D]: R
+            });
+          }).catch(n => {
+            n && (n.code === "E_CANCELLED" || n?.userInfo?.code === "E_CANCELLED" || typeof n?.message == "string" && n.message.includes("superseded")) || Z("mrmsRefreshFrameError", {
+              cacheKey: D,
+              code: n?.code,
+              message: n?.message
+            });
           });
         });
-        const newTimestampsSet = new Set(newTimestamps);
-        oldTimestamps.forEach(oldTs => {
-          if (!newTimestampsSet.has(oldTs)) {
-            const cacheKey = `mrms-${oldTs}-${currentVariable}`;
-            preloadedDataCache.current.delete(cacheKey);
+        const K = new Set(u);
+        c.forEach(Y => {
+          if (!K.has(Y)) {
+            const D = `mrms-${Y}-${s}`;
+            W.current.delete(D);
           }
         });
       }
     } else {
-      const previousStatus = core.modelStatus;
-      const modelStatus = await core.fetchModelStatus(true);
-      const statusChanged = JSON.stringify(previousStatus) !== JSON.stringify(modelStatus);
-      if (statusChanged) {
-        core._emitStateChange();
-      }
-      const latestRun = findLatestModelRun(modelStatus, currentModel);
-      if (!latestRun) return;
-    }
-  }, [core]);
-  useEffect(() => {
-    if (!core) {
-      return;
+      const c = t.modelStatus,
+        i = await t.fetchModelStatus(!0);
+      if (JSON.stringify(c) !== JSON.stringify(i) && t._emitStateChange(), !Gt(i, F)) return;
     }
-    const handleStateChange = newState => {
-      if (!previousStateRef.current) {
-        previousStateRef.current = core.state;
-      }
-      const variableChanged = !previousStateRef.current || newState.variable !== previousStateRef.current.variable;
-      if (variableChanged && gridLayerRef.current?.setVariable) {
-        gridLayerRef.current.setVariable(newState.variable);
-      }
-      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}-dur:${newState.nexradDurationValue ?? ''}-tl:${nexradObsTimelineSig(newState)}` : newState.isSatellite ? `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) && 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.satelliteDurationValue === previousStateRef.current?.satelliteDurationValue && satelliteObsTimelineSig(newState) === satelliteObsTimelineSig(previousStateRef.current) : newState.forecastHour === previousStateRef.current?.forecastHour && newState.mrmsTimestamp === previousStateRef.current?.mrmsTimestamp;
-      const sameModeAnchor = newState.isSatellite ? newState.satelliteInstrumentId === previousStateRef.current?.satelliteInstrumentId && newState.satelliteSectorLabel === previousStateRef.current?.satelliteSectorLabel && newState.satelliteChannel === previousStateRef.current?.satelliteChannel : newState.model === previousStateRef.current?.model && newState.isMRMS === previousStateRef.current?.isMRMS;
-      const isOpacityOnlyChange = hasInitialLoad.current && newState.opacity !== renderProps.opacity && newState.variable === previousStateRef.current?.variable && sameTimeline && sameModeAnchor && newState.units === previousStateRef.current?.units;
-      const isPlayStateOnlyChange = hasInitialLoad.current && newState.isPlaying !== previousStateRef.current?.isPlaying && newState.variable === previousStateRef.current?.variable && sameTimeline && sameModeAnchor && newState.units === previousStateRef.current?.units && newState.opacity === previousStateRef.current?.opacity;
-      if (!isOpacityOnlyChange && !isPlayStateOnlyChange && lastProcessedState.current === stateKey) {
-        previousStateRef.current = newState;
+  }, [t]);
+  j(() => {
+    if (!t) return;
+    const r = e => {
+      l.current || (l.current = t.state), (!l.current || e.variable !== l.current.variable) && p.current?.setVariable && p.current.setVariable(e.variable);
+      const o = e.isNexrad ? `nx-${e.nexradSite}-${e.nexradProduct}-${e.nexradDataSource}-${e.nexradTimestamp}-${e.nexradTilt}-${e.opacity}` : e.isSatellite ? `sat-${e.satelliteInstrumentId}-${e.satelliteSectorLabel}-${e.satelliteChannel}-${e.satelliteTimestamp}-${e.variable}-${e.units}-${e.opacity}-dur:${e.satelliteDurationValue ?? ""}-tl:${ue(e)}` : `${e.model}-${e.variable}-${e.date}-${e.run}-${e.forecastHour}-${e.units}-${e.mrmsTimestamp}`,
+        F = e.isNexrad ? e.nexradTimestamp === l.current?.nexradTimestamp && e.nexradSite === l.current?.nexradSite && e.nexradProduct === l.current?.nexradProduct && Number(e.nexradTilt) === Number(l.current?.nexradTilt) : e.isSatellite ? e.satelliteTimestamp === l.current?.satelliteTimestamp && e.satelliteInstrumentId === l.current?.satelliteInstrumentId && e.satelliteSectorLabel === l.current?.satelliteSectorLabel && e.satelliteChannel === l.current?.satelliteChannel && e.satelliteDurationValue === l.current?.satelliteDurationValue && ue(e) === ue(l.current) : e.forecastHour === l.current?.forecastHour && e.mrmsTimestamp === l.current?.mrmsTimestamp,
+        s = e.isSatellite ? e.satelliteInstrumentId === l.current?.satelliteInstrumentId && e.satelliteSectorLabel === l.current?.satelliteSectorLabel && e.satelliteChannel === l.current?.satelliteChannel : e.model === l.current?.model && e.isMRMS === l.current?.isMRMS,
+        w = ae.current && e.opacity !== Ve.opacity && e.variable === l.current?.variable && F && s && e.units === l.current?.units,
+        N = ae.current && e.isPlaying !== l.current?.isPlaying && e.variable === l.current?.variable && F && s && e.units === l.current?.units && e.opacity === l.current?.opacity;
+      if (!w && !N && He.current === o) {
+        l.current = e;
         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 (pt() && se.OS === "ios" && e.isSatellite && l.current?.isSatellite) {
+        const i = l.current;
+        e.isSatellite && i?.isSatellite && (e.satelliteDurationValue !== i.satelliteDurationValue || ue(e) !== ue(i)) && z("iosSatelliteTimelineWindowChanged", {
+          duration: {
+            from: i.satelliteDurationValue,
+            to: e.satelliteDurationValue
+          },
+          timelineSig: {
+            from: ue(i),
+            to: ue(e)
+          },
+          willSyncNative: !0
+        });
       }
-      if (isOpacityOnlyChange) {
-        setRenderProps(prev => ({
-          ...prev,
-          opacity: newState.opacity
-        }));
-        if (NEXRAD_NATIVE && newState.isNexrad) {
-          nexradControllerRef.current?.applyStyleFromState?.(newState);
-        }
-        if (SATELLITE_NATIVE && newState.isSatellite) {
-          satelliteLayerRef.current?.updateSatelliteStyle?.(JSON.stringify({
-            visible: newState.visible !== false,
-            opacity: newState.opacity ?? 1,
-            fillSmoothing: 0
-          }));
-        }
-        previousStateRef.current = newState;
+      if (!w && !N && (He.current = o), w) {
+        Me(i => ({
+          ...i,
+          opacity: e.opacity
+        })), ie && e.isSatellite && Ne.current?.updateSatelliteStyle?.(JSON.stringify({
+          visible: e.visible !== !1,
+          opacity: e.opacity ?? 1,
+          fillSmoothing: 0
+        })), Q && e.isNexrad && Ie(e), l.current = e;
         return;
       }
-      if (isPlayStateOnlyChange) {
-        previousStateRef.current = newState;
+      if (N) {
+        l.current = e;
         return;
       }
-      const isUnitsOnlyChange = hasInitialLoad.current && newState.model === previousStateRef.current.model && newState.isMRMS === previousStateRef.current.isMRMS && newState.variable === previousStateRef.current.variable && newState.date === previousStateRef.current.date && newState.run === previousStateRef.current.run && (newState.isNexrad ? newState.nexradTimestamp === previousStateRef.current.nexradTimestamp && newState.nexradSite === previousStateRef.current.nexradSite && newState.nexradProduct === previousStateRef.current.nexradProduct : newState.forecastHour === previousStateRef.current.forecastHour && newState.mrmsTimestamp === previousStateRef.current.mrmsTimestamp) && newState.units !== previousStateRef.current.units;
-      if (isUnitsOnlyChange) {
-        if (NEXRAD_NATIVE && newState.isNexrad) {
-          setRenderProps(prev => ({
-            ...prev,
-            opacity: newState.opacity
-          }));
-          nexradControllerRef.current?.applyStyleFromState?.(newState);
-          previousStateRef.current = newState;
+      if (ae.current && e.model === l.current.model && e.isMRMS === l.current.isMRMS && e.variable === l.current.variable && e.date === l.current.date && e.run === l.current.run && (e.isNexrad ? e.nexradTimestamp === l.current.nexradTimestamp && e.nexradSite === l.current.nexradSite && e.nexradProduct === l.current.nexradProduct : e.forecastHour === l.current.forecastHour && e.mrmsTimestamp === l.current.mrmsTimestamp) && e.units !== l.current.units) {
+        if (Q && e.isNexrad) {
+          Me(q => ({
+            ...q,
+            opacity: e.opacity
+          })), Ie(e), l.current = e;
           return;
         }
         const {
-          variable,
-          units,
-          isMRMS,
-          mrmsTimestamp,
-          model,
-          date,
-          run,
-          forecastHour
-        } = newState;
-        const oldCacheKey = isMRMS ? `mrms-${mrmsTimestamp}-${variable}` : `${model}-${date}-${run}-${forecastHour}-${variable}`;
-        const cachedData = preloadedDataCache.current.get(oldCacheKey);
-        if (cachedData && cachedData.originalScale !== undefined && cachedData.originalOffset !== undefined) {
+            variable: i,
+            units: u,
+            isMRMS: A,
+            mrmsTimestamp: y,
+            model: M,
+            date: U,
+            run: E,
+            forecastHour: K
+          } = e,
+          Y = A ? `mrms-${y}-${i}` : `${M}-${U}-${E}-${K}-${i}`,
+          D = W.current.get(Y);
+        if (D && D.originalScale !== void 0 && D.originalOffset !== void 0) {
           const {
-            baseUnit
-          } = core._getColormapForVariable(variable);
-          const toUnit = core._getTargetUnit(baseUnit, units);
-          const fieldInfo = DICTIONARIES?.fld?.[variable] || {};
-          const serverDataUnit = fieldInfo.defaultUnit || baseUnit;
-          let dataScale = cachedData.originalScale;
-          let dataOffset = cachedData.originalOffset;
-          if (serverDataUnit !== baseUnit) {
-            const conversionFunc = getUnitConversionFunction(serverDataUnit, baseUnit);
-            if (conversionFunc) {
-              if (cachedData.scaleType === 'sqrt') {
-                const physicalAtOffset = dataOffset * dataOffset;
-                const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-                const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
-                const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-                const newOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
-                const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-                dataScale = newOffsetPlusScale - newOffset;
-                dataOffset = newOffset;
-              } else {
-                const convertedOffset = conversionFunc(dataOffset);
-                const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-                dataScale = convertedOffsetPlusScale - convertedOffset;
-                dataOffset = convertedOffset;
-              }
+              baseUnit: q
+            } = t._getColormapForVariable(i),
+            de = t._getTargetUnit(q, u),
+            ye = (Be?.fld?.[i] || {}).defaultUnit || q;
+          let $ = D.originalScale,
+            d = D.originalOffset;
+          if (ye !== q) {
+            const f = ve(ye, q);
+            if (f) if (D.scaleType === "sqrt") {
+              const C = d * d,
+                b = (d + $) * (d + $),
+                S = f(C),
+                T = f(b),
+                L = Math.sqrt(Math.abs(S)) * Math.sign(S);
+              $ = Math.sqrt(Math.abs(T)) * Math.sign(T) - L, d = L;
+            } else {
+              const C = f(d);
+              $ = f(d + $) - C, d = C;
             }
           }
-          if (baseUnit !== toUnit) {
-            const conversionFunc = getUnitConversionFunction(baseUnit, toUnit);
-            if (conversionFunc) {
-              if (cachedData.scaleType === 'sqrt') {
-                const physicalAtOffset = dataOffset * dataOffset;
-                const physicalAtOffsetPlusScale = (dataOffset + dataScale) * (dataOffset + dataScale);
-                const convertedPhysicalAtOffset = conversionFunc(physicalAtOffset);
-                const convertedPhysicalAtOffsetPlusScale = conversionFunc(physicalAtOffsetPlusScale);
-                const newOffset = Math.sqrt(Math.abs(convertedPhysicalAtOffset)) * Math.sign(convertedPhysicalAtOffset);
-                const newOffsetPlusScale = Math.sqrt(Math.abs(convertedPhysicalAtOffsetPlusScale)) * Math.sign(convertedPhysicalAtOffsetPlusScale);
-                dataScale = newOffsetPlusScale - newOffset;
-                dataOffset = newOffset;
-              } else {
-                const convertedOffset = conversionFunc(dataOffset);
-                const convertedOffsetPlusScale = conversionFunc(dataOffset + dataScale);
-                dataScale = convertedOffsetPlusScale - convertedOffset;
-                dataOffset = convertedOffset;
-              }
+          if (q !== de) {
+            const f = ve(q, de);
+            if (f) if (D.scaleType === "sqrt") {
+              const C = d * d,
+                b = (d + $) * (d + $),
+                S = f(C),
+                T = f(b),
+                L = Math.sqrt(Math.abs(S)) * Math.sign(S);
+              $ = Math.sqrt(Math.abs(T)) * Math.sign(T) - L, d = L;
+            } else {
+              const C = f(d);
+              $ = f(d + $) - C, d = C;
             }
           }
           const {
-            colormap
-          } = core._getColormapForVariable(variable);
-          const finalColormap = core._convertColormapUnits(colormap, baseUnit, toUnit);
-          let dataRange = variable === 'ptypeRefl' || variable === 'ptypeRate' ? [5, 380] : [finalColormap[0], finalColormap[finalColormap.length - 2]];
-          const colormapBytes = _generateColormapBytes(finalColormap);
-          const colormapAsBase64 = fromByteArray(colormapBytes);
-          gridLayerRef.current.updateColormapTexture(colormapAsBase64);
-          cachedColormap.current = {
-            key: `${variable}-${units}`
-          };
-          cachedDataRange.current = dataRange;
-          setRenderProps(prev => ({
-            ...prev,
-            dataRange,
-            opacity: newState.opacity
-          }));
-          if (gridLayerRef.current && gridLayerRef.current.updateDataParameters) {
-            const scaleTypeValue = cachedData.scaleType === 'sqrt' ? 1 : 0;
-            gridLayerRef.current.updateDataParameters(dataScale, dataOffset, cachedData.missing, scaleTypeValue);
+              colormap: G
+            } = t._getColormapForVariable(i),
+            n = t._convertColormapUnits(G, q, de);
+          let R = i === "ptypeRefl" || i === "ptypeRate" ? [5, 380] : [n[0], n[n.length - 2]];
+          const h = et(n),
+            k = ze(h);
+          if (p.current.updateColormapTexture(k), ge.current = {
+            key: `${i}-${u}`
+          }, ke.current = R, Me(f => ({
+            ...f,
+            dataRange: R,
+            opacity: e.opacity
+          })), p.current && p.current.updateDataParameters) {
+            const f = D.scaleType === "sqrt" ? 1 : 0;
+            p.current.updateDataParameters($, d, D.missing, f);
           }
-          const newCacheKey = isMRMS ? `mrms-${mrmsTimestamp}-${variable}` : `${model}-${date}-${run}-${forecastHour}-${variable}`;
-          preloadedDataCache.current.set(newCacheKey, {
-            ...cachedData,
-            scale: dataScale,
-            offset: dataOffset
+          const P = A ? `mrms-${y}-${i}` : `${M}-${U}-${E}-${K}-${i}`;
+          W.current.set(P, {
+            ...D,
+            scale: $,
+            offset: d
           });
         }
-        previousStateRef.current = newState;
+        l.current = e;
         return;
       }
-      const prev = previousStateRef.current;
-      const needsFullLoad = !hasInitialLoad.current || newState.isNexrad !== prev?.isNexrad || newState.isSatellite !== prev?.isSatellite || newState.isNexrad && prev?.isNexrad && (newState.nexradSite !== prev.nexradSite || newState.nexradDataSource !== prev.nexradDataSource || newState.nexradProduct !== prev.nexradProduct) || newState.isSatellite && prev?.isSatellite && (newState.satelliteInstrumentId !== prev.satelliteInstrumentId || newState.satelliteSectorLabel !== prev.satelliteSectorLabel || newState.satelliteChannel !== prev.satelliteChannel) || !newState.isNexrad && !newState.isSatellite && (newState.model !== prev?.model || newState.isMRMS !== prev?.isMRMS || newState.variable !== prev?.variable || newState.date !== prev?.date || 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 = NEXRAD_NATIVE && (newState.isNexrad !== prev?.isNexrad || newState.isNexrad && prev?.isNexrad && (newState.nexradSite !== prev.nexradSite || newState.nexradDataSource !== prev.nexradDataSource || newState.nexradProduct !== prev.nexradProduct));
-        const satelliteIdentityChange = SATELLITE_NATIVE && (newState.isSatellite !== prev?.isSatellite || newState.isSatellite && prev?.isSatellite && (newState.satelliteInstrumentId !== prev.satelliteInstrumentId || newState.satelliteSectorLabel !== prev.satelliteSectorLabel || newState.satelliteChannel !== prev.satelliteChannel));
-        if (nexradIdentityChange) {
-          nexradPreloadInteractionRef.current?.cancel?.();
-          nexradPreloadInteractionRef.current = null;
-          nexradControllerRef.current?.destroy();
-          nexradControllerRef.current = null;
-        }
-        if (satelliteIdentityChange) {
-          satelliteControllerRef.current?.destroy();
-          satelliteControllerRef.current = null;
-        }
-        if (gridLayerRef.current) {
-          gridLayerRef.current.setVariable(newState.variable);
-          gridLayerRef.current.clear();
-          if (Platform.OS === 'ios' && gridLayerRef.current.clearGpuCache) {
-            gridLayerRef.current.clearGpuCache();
-          }
-        }
-        hasPreloadedRef.current = false;
-        preloadGenerationRef.current += 1;
-        preloadedDataCache.current.clear();
-        cachedGeometry.current = null;
-        cachedColormap.current = null;
-        currentGridDataRef.current = null;
-        WeatherFrameProcessorModule.cancelAllFrames();
-        wxGridVerbose('cancelAllFrames', {
-          reason: 'needsFullLoad',
-          variable: newState.variable,
-          generation: preloadGenerationRef.current
+      const c = l.current;
+      if (!ae.current || e.isNexrad !== c?.isNexrad || e.isSatellite !== c?.isSatellite || e.isNexrad && c?.isNexrad && (e.nexradSite !== c.nexradSite || e.nexradDataSource !== c.nexradDataSource || e.nexradProduct !== c.nexradProduct) || e.isSatellite && c?.isSatellite && (e.satelliteInstrumentId !== c.satelliteInstrumentId || e.satelliteSectorLabel !== c.satelliteSectorLabel || e.satelliteChannel !== c.satelliteChannel) || !e.isNexrad && !e.isSatellite && (e.model !== c?.model || e.isMRMS !== c?.isMRMS || e.variable !== c?.variable || e.date !== c?.date || e.run !== c?.run)) {
+        z("needsFullLoad", {
+          variable: e.variable,
+          isMRMS: e.isMRMS,
+          model: e.model,
+          isInitial: !ae.current,
+          prevVariable: c?.variable,
+          prevModel: c?.model
         });
-        if (!newState.variable) {
-          previousStateRef.current = newState;
+        const i = Q && (e.isNexrad !== c?.isNexrad || e.isNexrad && c?.isNexrad && (e.nexradSite !== c.nexradSite || e.nexradDataSource !== c.nexradDataSource || e.nexradProduct !== c.nexradProduct)),
+          u = ie && (e.isSatellite !== c?.isSatellite || e.isSatellite && c?.isSatellite && (e.satelliteInstrumentId !== c.satelliteInstrumentId || e.satelliteSectorLabel !== c.satelliteSectorLabel || e.satelliteChannel !== c.satelliteChannel));
+        if (i && (X.current?.destroy(), X.current = null), u && (re.current?.destroy(), re.current = null), p.current && (p.current.setVariable(e.variable), p.current.clear(), se.OS === "ios" && p.current.clearGpuCache && p.current.clearGpuCache()), ne.current = !1, Le.current += 1, W.current.clear(), pe.current = null, ge.current = null, De.current = null, qe.cancelAllFrames(), z("cancelAllFrames", {
+          reason: "needsFullLoad",
+          variable: e.variable,
+          generation: Le.current
+        }), !e.variable) {
+          l.current = e;
           return;
         }
-        if (!newState.isNexrad && !newState.isSatellite) {
-          preloadAllFramesToDisk(newState);
-        } else if (NEXRAD_NATIVE && newState.isNexrad) {
-          hasInitialLoad.current = true;
-        } else if (SATELLITE_NATIVE && newState.isSatellite) {
-          hasInitialLoad.current = true;
-        }
-      } else if (!newState.isNexrad && (newState.forecastHour !== previousStateRef.current.forecastHour || 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
-          });
-          hasPreloadedRef.current = false;
-          void preloadAllFramesToDisk(newState);
-        }
-        if (success && newState.opacity !== renderProps.opacity) {
-          setRenderProps(prev => ({
-            ...prev,
-            opacity: newState.opacity
-          }));
-        }
-      }
-      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?.();
-          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;
-            }
-            const s = core.state;
-            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 (NEXRAD_NATIVE && (!newState.isNexrad || !newState.nexradSite)) {
-        nexradPreloadInteractionRef.current?.cancel?.();
-        nexradPreloadInteractionRef.current = null;
-        nexradControllerRef.current?.destroy();
-        nexradControllerRef.current = null;
+        !e.isNexrad && !e.isSatellite ? it(e) : Q && e.isNexrad ? Ie(e) : ie && e.isSatellite && (ae.current = !0);
+      } else if (!e.isNexrad && (e.forecastHour !== l.current.forecastHour || e.isMRMS && e.mrmsTimestamp !== l.current.mrmsTimestamp)) {
+        const i = yt(e);
+        i || (Z("timelineGpuUpdateMiss", {
+          isMRMS: e.isMRMS,
+          variable: e.variable,
+          mrmsTimestamp: e.mrmsTimestamp,
+          forecastHour: e.forecastHour
+        }), ne.current = !1, it(e)), i && e.opacity !== Ve.opacity && Me(u => ({
+          ...u,
+          opacity: e.opacity
+        }));
       }
-      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)
+      if (Q && e.isNexrad ? Ie(e) : Q && !e.isNexrad && (X.current?.destroy(), X.current = null), ie && e.isSatellite) {
+        Ee("handleStateChange \u2192 satellite", {
+          satelliteInstrumentId: e.satelliteInstrumentId ?? null,
+          satelliteSectorLabel: e.satelliteSectorLabel ?? null,
+          satelliteChannel: e.satelliteChannel ?? null,
+          timelineKeys: Object.keys(e.satelliteTimeToFileMap || {}).length,
+          refHasSync: !!Ne.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 (SATELLITE_NATIVE && !newState.isSatellite) {
-        satelliteControllerRef.current?.destroy();
-        satelliteControllerRef.current = null;
-      }
-      previousStateRef.current = newState;
+        const i = at();
+        i ? (ae.current = !0, i.sync(e)) : Ee("handleStateChange satellite: ensureSatelliteController returned null", {}), !e.satelliteInstrumentId && typeof __DEV__ < "u" && __DEV__ && console.warn("[AguaceroWX][satellite] isSatellite is true but satelliteInstrumentId is missing \u2014 native sync still runs; timeline may be empty until core sets instrument.");
+      } else ie && !e.isSatellite && (re.current?.destroy(), re.current = null);
+      l.current = e;
     };
-    handleStateChangeRef.current = handleStateChange;
-    const stableHandler = newState => {
-      lastEmittedStateForInspectRef.current = newState;
-      setNexradSitesMapVisible(Boolean(newState.isNexrad && newState.nexradShowSitesPicker !== false));
-      // OPTIMIZATION: If playing (high speed), prioritize MAP update and skip debounce
-      if (newState.isPlaying) {
-        // 1. Update Map FIRST (Native Enqueue)
-        if (handleStateChangeRef.current) {
-          handleStateChangeRef.current(newState);
-        }
-
-        // 2. Update UI Slider SECOND
-        // This ensures the heavy map frame is processing while React reconciles the slider
-        props.onStateChange?.(newState);
-        if (debounceTimeoutRef.current) {
-          clearTimeout(debounceTimeoutRef.current);
-          debounceTimeoutRef.current = null;
-        }
+    he.current = r;
+    const a = e => {
+      if (st(!!(e.isNexrad && e.nexradShowSitesPicker !== !1)), e.isPlaying) {
+        he.current && he.current(e), m.onStateChange?.(e), le.current && (clearTimeout(le.current), le.current = null);
         return;
       }
-
-      // --- Existing Logic for scrubbing/paused ---
-
-      // 1. Immediate Slider Update for responsiveness
-      props.onStateChange?.(newState);
-      if (debounceTimeoutRef.current) {
-        clearTimeout(debounceTimeoutRef.current);
-      }
-      const prevStable = previousStateRef.current;
-      const sameTimelineStable = prevStable && (prevStable.isNexrad ? newState.nexradTimestamp === prevStable.nexradTimestamp && newState.nexradSite === prevStable.nexradSite && newState.nexradProduct === prevStable.nexradProduct && 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.satelliteDurationValue === prevStable.satelliteDurationValue && satelliteObsTimelineSig(newState) === satelliteObsTimelineSig(prevStable) : newState.forecastHour === prevStable.forecastHour && newState.mrmsTimestamp === prevStable.mrmsTimestamp);
-      const sameModeStable = prevStable && (newState.isSatellite ? newState.satelliteInstrumentId === prevStable.satelliteInstrumentId && newState.satelliteSectorLabel === prevStable.satelliteSectorLabel && newState.satelliteChannel === prevStable.satelliteChannel : newState.model === prevStable.model && newState.isMRMS === prevStable.isMRMS);
-
-      // Opacity and Play state changes should be immediate for the native layer too
-      const isOpacityOnlyChange = prevStable && sameTimelineStable && sameModeStable && newState.opacity !== prevStable.opacity && newState.variable === prevStable.variable && newState.units === prevStable.units;
-      const isPlayStateOnlyChange = prevStable && sameTimelineStable && sameModeStable && newState.isPlaying !== prevStable.isPlaying && newState.variable === prevStable.variable && newState.units === prevStable.units && newState.opacity === prevStable.opacity;
-      if (isOpacityOnlyChange || isPlayStateOnlyChange || !previousStateRef.current) {
-        if (handleStateChangeRef.current) {
-          handleStateChangeRef.current(newState);
-        }
+      m.onStateChange?.(e), le.current && clearTimeout(le.current);
+      const o = l.current,
+        F = o && (o.isNexrad ? e.nexradTimestamp === o.nexradTimestamp && e.nexradSite === o.nexradSite && e.nexradProduct === o.nexradProduct && Number(e.nexradTilt) === Number(o.nexradTilt) : o.isSatellite ? e.satelliteTimestamp === o.satelliteTimestamp && e.satelliteInstrumentId === o.satelliteInstrumentId && e.satelliteSectorLabel === o.satelliteSectorLabel && e.satelliteChannel === o.satelliteChannel && e.satelliteDurationValue === o.satelliteDurationValue && ue(e) === ue(o) : e.forecastHour === o.forecastHour && e.mrmsTimestamp === o.mrmsTimestamp),
+        s = o && (e.isSatellite ? e.satelliteInstrumentId === o.satelliteInstrumentId && e.satelliteSectorLabel === o.satelliteSectorLabel && e.satelliteChannel === o.satelliteChannel : e.model === o.model && e.isMRMS === o.isMRMS),
+        w = o && F && s && e.opacity !== o.opacity && e.variable === o.variable && e.units === o.units,
+        N = o && F && s && e.isPlaying !== o.isPlaying && e.variable === o.variable && e.units === o.units && e.opacity === o.opacity;
+      if (w || N || !l.current) {
+        he.current && he.current(e);
         return;
       }
-      debounceTimeoutRef.current = setTimeout(() => {
-        if (handleStateChangeRef.current) {
-          handleStateChangeRef.current(newState);
-        }
-        debounceTimeoutRef.current = null;
-      }, 16); // ~60fps map updates
+      le.current = setTimeout(() => {
+        he.current && he.current(e), le.current = null;
+      }, 16);
     };
-    core.on('state:change', stableHandler);
-    return () => {
-      core.off('state:change', stableHandler);
-      if (debounceTimeoutRef.current) {
-        clearTimeout(debounceTimeoutRef.current);
-      }
-      if (NEXRAD_NATIVE) {
-        nexradPreloadInteractionRef.current?.cancel?.();
-        nexradPreloadInteractionRef.current = null;
-        nexradControllerRef.current?.destroy();
-        nexradControllerRef.current = null;
-      }
-      if (SATELLITE_NATIVE) {
-        satelliteControllerRef.current?.destroy();
-        satelliteControllerRef.current = null;
-      }
-    };
-  }, [core, ensureNexradController, ensureSatelliteController]);
-  useEffect(() => {
-    return () => {
-      preloadedDataCache.current.clear(); // This drops JS references
-      hasInitialLoad.current = false;
-      lastProcessedState.current = null;
-      // Native cleanup
-      if (gridLayerRef.current && Platform.OS === 'ios') {
-        gridLayerRef.current.clearGpuCache();
-      }
-      if (NEXRAD_NATIVE) {
-        nexradPreloadInteractionRef.current?.cancel?.();
-        nexradPreloadInteractionRef.current = null;
-        nexradControllerRef.current?.destroy();
-        nexradControllerRef.current = null;
-      }
-      if (SATELLITE_NATIVE) {
-        satelliteControllerRef.current?.destroy();
-        satelliteControllerRef.current = null;
-      }
+    return t.on("state:change", a), () => {
+      t.off("state:change", a), le.current && clearTimeout(le.current), Q && (X.current?.destroy(), X.current = null), ie && (re.current?.destroy(), re.current = null);
     };
+  }, [t, at, Ie]), j(() => () => {
+    W.current.clear(), ae.current = !1, He.current = null, p.current && se.OS === "ios" && p.current.clearGpuCache(), Q && (X.current?.destroy(), X.current = null), ie && (re.current?.destroy(), re.current = null);
   }, []);
-  const lastInspectorUpdateRef = useRef(0);
-  const INSPECTOR_THROTTLE_MS = 50;
-  useEffect(() => {
-    if (!core || !inspectorEnabled) {
-      return;
-    }
-    const handleMapMove = center => {
-      if (!center || !Array.isArray(center) || center.length !== 2) {
-        return;
-      }
-
-      // Throttle updates
-      const now = Date.now();
-      if (now - lastInspectorUpdateRef.current < INSPECTOR_THROTTLE_MS) {
-        return;
-      }
-      lastInspectorUpdateRef.current = now;
-      const [longitude, latitude] = center;
-      if (NEXRAD_NATIVE && core.state?.isNexrad) {
-        onInspect?.(getNexradInspectPayloadAtRef.current(longitude, latitude));
-        return;
-      }
-      void getValueAtPointRef.current(longitude, latitude).then(payload => {
-        onInspect?.(payload);
+  const ot = V(0),
+    bt = 50;
+  j(() => {
+    if (!t || !g) return;
+    const r = a => {
+      if (!a || !Array.isArray(a) || a.length !== 2) return;
+      const e = Date.now();
+      if (e - ot.current < bt) return;
+      ot.current = e;
+      const [o, F] = a;
+      We.current(o, F).then(s => {
+        I?.(s);
       });
     };
-    core.on('map:move', handleMapMove);
-    if (context && context.getCenter) {
-      const center = context.getCenter();
-      if (center) {
-        handleMapMove(center);
-      }
+    if (t.on("map:move", r), _e && _e.getCenter) {
+      const a = _e.getCenter();
+      a && r(a);
     }
     return () => {
-      core.off('map:move', handleMapMove);
-    };
-  }, [inspectorEnabled, onInspect, core, context]);
-  useEffect(() => {
-    if (!core || !inspectorEnabled) {
-      return;
-    }
-    const triggerReinspection = () => {
-      const mapRef = mapRegistry.getMap();
-      const center = mapRef?._currentCenter;
-      if (center && Array.isArray(center) && center.length === 2) {
-        const [longitude, latitude] = center;
-        if (NEXRAD_NATIVE && core?.state?.isNexrad) {
-          onInspect?.(getNexradInspectPayloadAtRef.current(longitude, latitude));
-        } else {
-          getValueAtPointRef.current(longitude, latitude).then(payload => {
-            onInspect?.(payload);
-          });
-        }
-      }
+      t.off("map:move", r);
     };
-
-    // Small delay to ensure data is loaded before re-inspecting
-    const timer = setTimeout(triggerReinspection, 100);
-    return () => clearTimeout(timer);
-  }, [core?.state?.nexradTimestamp, core?.state?.isNexrad, core?.state?.nexradSite, core?.state?.nexradProduct, core?.state?.nexradTilt, core?.state?.nexradDataSource, core?.state?.nexradStormRelative, core?.state?.variable, core?.state?.model, core?.state?.forecastHour, core?.state?.mrmsTimestamp, core?.state?.units, core?.state?.opacity, inspectorEnabled, onInspect]);
-  useEffect(() => {
-    if (!core) {
-      return;
-    }
-    const handleCameraChange = center => {
-      if (core && center) {
-        core.setMapCenter(center);
+  }, [g, I, t, _e]), j(() => {
+    if (!t || !g) return;
+    const r = setTimeout(() => {
+      const a = Ue.getMap()?._currentCenter;
+      if (a && Array.isArray(a) && a.length === 2) {
+        const [e, o] = a;
+        We.current(e, o).then(F => {
+          I?.(F);
+        });
       }
+    }, 100);
+    return () => clearTimeout(r);
+  }, [t?.state?.nexradTimestamp, t?.state?.isNexrad, t?.state?.nexradSite, t?.state?.nexradProduct, t?.state?.nexradTilt, t?.state?.nexradDataSource, t?.state?.nexradStormRelative, t?.state?.variable, t?.state?.model, t?.state?.forecastHour, t?.state?.mrmsTimestamp, t?.state?.units, t?.state?.opacity, g, I]), j(() => {
+    if (!t) return;
+    const r = e => {
+      t && e && t.setMapCenter(e);
     };
-
-    // Register with the global registry
-    mapRegistry.addCameraListener(handleCameraChange);
-
-    // Try to get initial center
-    const mapRef = mapRegistry.getMap();
-    if (mapRef?._currentCenter) {
-      handleCameraChange(mapRef._currentCenter);
-    }
-    return () => {
-      mapRegistry.removeCameraListener(handleCameraChange);
-    };
-  }, [core]);
-  useEffect(() => {
-    core.initialize({
-      autoRefresh: false
-    }); // <-- add the argument
-    return () => {
-      core.destroy();
+    Ue.addCameraListener(r);
+    const a = Ue.getMap();
+    return a?._currentCenter && r(a._currentCenter), () => {
+      Ue.removeCameraListener(r);
     };
-  }, [core]);
-  const gridBelowId = belowIDFromProps ?? context?.weatherBeforeLayerId ?? 'AML_-_terrain';
-  return /*#__PURE__*/React.createElement(React.Fragment, null, /*#__PURE__*/React.createElement(GridRenderLayer, {
-    ref: gridLayerRef,
-    opacity: renderProps.opacity,
-    dataRange: renderProps.dataRange,
-    belowID: gridBelowId
-  }), NEXRAD_NATIVE ? /*#__PURE__*/React.createElement(NexradRadarLayer, {
-    ref: nexradLayerRef,
-    belowID: gridBelowId
-  }) : null, SATELLITE_NATIVE ? /*#__PURE__*/React.createElement(SatelliteLayer, {
-    ref: satelliteLayerRef,
-    belowID: gridBelowId
-  }) : null, /*#__PURE__*/React.createElement(NwsAlertsOverlay, {
-    core: core,
-    watchesWarnings: watchesWarningsOptions,
-    onNwsAlertClick: onNwsAlertClick
-  }), nexradSitesMapVisible ? /*#__PURE__*/React.createElement(NexradSitesMapLayer, {
-    visible: true,
-    belowLayerID: gridBelowId,
-    onSelectSite: siteId => void core.setNexradSite(siteId)
+  }, [t]), j(() => (t.initialize({
+    autoRefresh: !1
+  }), () => {
+    t.destroy();
+  }), [t]);
+  const Oe = Te ?? _e?.weatherBeforeLayerId ?? "AML_-_terrain";
+  return /*#__PURE__*/be.createElement(be.Fragment, null, /*#__PURE__*/be.createElement(_t, {
+    ref: p,
+    opacity: Ve.opacity,
+    dataRange: Ve.dataRange,
+    belowID: Oe
+  }), Q ? /*#__PURE__*/be.createElement(Nt, {
+    ref: rt,
+    belowID: Oe
+  }) : null, ie ? /*#__PURE__*/be.createElement(Dt, {
+    ref: Ne,
+    belowID: Oe
+  }) : null, /*#__PURE__*/be.createElement(Pt, {
+    core: t,
+    watchesWarnings: gt,
+    onNwsAlertClick: Ge
+  }), St ? /*#__PURE__*/be.createElement(It, {
+    visible: !0,
+    belowLayerID: Oe,
+    onSelectSite: r => void t.setNexradSite(r)
   }) : null);
 });
-WeatherLayerManager.getAvailableVariables = options => {
-  if (!options || !options.apiKey) {
-    return [];
-  }
-  const core = new AguaceroCore({
-    apiKey: options.apiKey
-  });
-  return core.getAvailableVariables('mrms');
-};
+WeatherLayerManager.getAvailableVariables = m => !m || !m.apiKey ? [] : new je({
+  apiKey: m.apiKey
+}).getAvailableVariables("mrms");
 //# sourceMappingURL=WeatherLayerManager.js.map