@aguacerowx/react-native 0.0.53 → 0.0.54

package/lib/module/nexrad/nexradAndroidController.js

@@ -1,1024 +1,1013 @@
-/**
- * AguaceroCore NEXRAD → Android native custom layer (parity with mapsgl {@link NexradWeatherController}).
- */
-import { getUnitConversionFunction, getDefaultRadarTilt, nexradBinGroupIdForKey, variableToNexradGroup } from '@aguacerowx/javascript-sdk';
-import { fromByteArray } from 'base64-js';
-import { fetchAndParseArchive, objectKeyToUrl, setNexradArchiveApiKey, setNexradArchiveBundleId, setNexradArchiveSiteOrigin, setNexradSitesJsonUrl, setNexradSitesFetchAuth } from './radarArchiveCore.bundled.js';
-import { prepareRadarFrameForGpuReadout } from './radarFrameGpuMatch.bundled.js';
-import { mapboxFrameUploadOptionsForNexradState } from './nexradMapboxFrameOpts.bundled.js';
-import { sampleNexradFrameAtLatLon } from './nexradCrossSectionSampleAtLatLon.bundled.js';
-import { buildNexradLutRgba } from './nexradLutBuild.js';
-import { Platform } from 'react-native';
-import { nexradDiagBootSnapshot, nexradDiagGateTextureSummary, nexradPerfSpan } from './nexradDiag.js';
-import { aguaceroDebug, getAguaceroAuthDiagnosticSnapshot, isAguaceroRnDebugEnabled } from '../aguaceroRnDebug';
-nexradDiagBootSnapshot({
+import { getUnitConversionFunction as O, getDefaultRadarTilt as Q, nexradBinGroupIdForKey as X, variableToNexradGroup as ee } from "./nexradSdkImports.js";
+import { fetchAndApplyLevel2ListingToCore as te, isValidLevel2SweepObjectKey as j, level2ListingCacheNeedsRefresh as D, level2ListingEmptyHint as ae, listingContextParams as E, rebuildLevel2TimeToKeyMap as re, resolveLevel2ObjectKeyForFetch as ie } from "./nexradLevel2Keys.js";
+import { fromByteArray as J } from "base64-js";
+import { fetchAndParseArchive as k, getNexradArchiveAuthSnapshot as ne, objectKeyToUrl as G, setNexradArchiveApiKey as L, setNexradArchiveBundleId as R, setNexradArchiveSiteOrigin as w, setNexradArchiveUserId as $, setNexradSitesJsonUrl as se, setNexradSitesFetchAuth as B } from "./radarArchiveCore.bundled.js";
+import { RN_DEFAULT_GRID_REQUEST_SITE_ORIGIN as I } from "../gridCdnAuth";
+import { prepareRadarFrameForGpuReadout as oe } from "./radarFrameGpuMatch.bundled.js";
+import { mapboxFrameUploadOptionsForNexradState as V } from "./nexradMapboxFrameOpts.bundled.js";
+import { sampleNexradFrameAtLatLon as le } from "./nexradCrossSectionSampleAtLatLon.bundled.js";
+import { buildNexradLutRgba as de } from "./nexradLutBuild.js";
+import { Platform as ce } from "react-native";
+import { nexradDiagBootSnapshot as ue, nexradDiagGateTextureSummary as he, nexradPerfSpan as h, nexradPipelineLog as y } from "./nexradDiag.js";
+import { aguaceroDebug as z, getAguaceroAuthDiagnosticSnapshot as H, isAguaceroRnDebugEnabled as W } from "../aguaceroRnDebug";
+ue({
   archiveExports: {
-    setNexradArchiveApiKey: typeof setNexradArchiveApiKey,
-    setNexradArchiveBundleId: typeof setNexradArchiveBundleId,
-    objectKeyToUrl: typeof objectKeyToUrl,
-    fetchAndParseArchive: typeof fetchAndParseArchive
+    setNexradArchiveApiKey: typeof L,
+    setNexradArchiveBundleId: typeof R,
+    objectKeyToUrl: typeof G,
+    fetchAndParseArchive: typeof k
   }
 });
-
-/** @returns {boolean} */
-function ensureRadarArchiveBindings(label) {
-  const ok = typeof setNexradArchiveApiKey === 'function' && typeof setNexradArchiveBundleId === 'function' && typeof objectKeyToUrl === 'function' && typeof fetchAndParseArchive === 'function';
-  return ok;
+function q(c) {
+  return typeof L == "function" && typeof R == "function" && typeof G == "function" && typeof k == "function";
 }
-function pickNearestLevel3ObjectKey(unixTime, timeToKeyMap, maxDeltaSec = 600) {
-  const direct = timeToKeyMap[String(unixTime)];
-  if (direct) return direct;
-  const entries = Object.entries(timeToKeyMap || {});
-  if (entries.length === 0) return null;
-  let bestKey = null;
-  let bestDelta = Infinity;
-  for (const [tStr, key] of entries) {
-    const t = Number(tStr);
-    if (!Number.isFinite(t)) continue;
-    const d = Math.abs(t - unixTime);
-    if (d < bestDelta) {
-      bestDelta = d;
-      bestKey = key;
-    }
-  }
-  if (bestKey == null) return null;
-  if (bestDelta > maxDeltaSec && Number.isFinite(maxDeltaSec)) return null;
-  return bestKey;
+function me(c, e, t = 600) {
+  const a = e[String(c)];
+  if (a) return a;
+  const n = Object.entries(e || {});
+  if (n.length === 0) return null;
+  let i = null,
+    r = 1 / 0;
+  for (const [s, l] of n) {
+    const o = Number(s);
+    if (!Number.isFinite(o)) continue;
+    const m = Math.abs(o - c);
+    m < r && (r = m, i = l);
+  }
+  return i == null || r > t && Number.isFinite(t) ? null : i;
 }
-function isVelocityStyleRadarVar(radarVariable) {
-  return radarVariable === 'VEL' || radarVariable === 'SW' || radarVariable === 'N0G' || radarVariable === 'N0W';
+function U(c) {
+  return c === "VEL" || c === "SW" || c === "N0G" || c === "N0W";
 }
-function velocityRangeToMs(rangeMin, rangeMax, displayUnit) {
-  if (rangeMin == null || rangeMax == null || !displayUnit || displayUnit.toLowerCase() === 'm/s' || displayUnit.toLowerCase() === 'ms') {
-    return [rangeMin, rangeMax];
-  }
-  const toMs = getUnitConversionFunction(displayUnit, 'm/s', 'nexrad_vel');
-  if (!toMs) return [rangeMin, rangeMax];
-  return [toMs(rangeMin), toMs(rangeMax)];
+function pe(c, e, t) {
+  if (c == null || e == null || !t || t.toLowerCase() === "m/s" || t.toLowerCase() === "ms") return [c, e];
+  const a = O(t, "m/s", "nexrad_vel");
+  return a ? [a(c), a(e)] : [c, e];
 }
-function colormapToMs(colormap, radarVariable, displayUnit) {
-  if (!colormap || !Array.isArray(colormap) || colormap.length < 2) return colormap;
-  if (!isVelocityStyleRadarVar(radarVariable)) return colormap;
-  if (!displayUnit || displayUnit.toLowerCase() === 'm/s' || displayUnit.toLowerCase() === 'ms') return colormap;
-  const toMs = getUnitConversionFunction(displayUnit, 'm/s', radarVariable === 'SW' || radarVariable === 'N0W' ? 'nexrad_sw' : 'nexrad_vel');
-  if (!toMs) return colormap;
-  const out = [...colormap];
-  for (let i = 0; i < out.length; i += 2) {
-    const v = out[i];
-    if (typeof v === 'number' && Number.isFinite(v)) out[i] = toMs(v);
-  }
-  return out;
+function ye(c, e, t) {
+  if (!c || !Array.isArray(c) || c.length < 2 || !U(e) || !t || t.toLowerCase() === "m/s" || t.toLowerCase() === "ms") return c;
+  const a = O(t, "m/s", e === "SW" || e === "N0W" ? "nexrad_sw" : "nexrad_vel");
+  if (!a) return c;
+  const n = [...c];
+  for (let i = 0; i < n.length; i += 2) {
+    const r = n[i];
+    typeof r == "number" && Number.isFinite(r) && (n[i] = a(r));
+  }
+  return n;
 }
-function radarShaderValueRange(rangeMin, rangeMax, radarVariable, units, nexradDataSource) {
-  const v = (radarVariable || '').toUpperCase();
-  if (isVelocityStyleRadarVar(v)) {
-    const [vmin, vmax] = velocityRangeToMs(rangeMin, rangeMax, units);
-    return [vmin ?? 0, vmax ?? 80];
-  }
-  if (nexradDataSource === 'level3' && (v === 'N0H' || v === 'HHC')) {
-    const lo = rangeMin ?? 0;
-    let hi = rangeMax ?? 11;
-    if (hi > 11) hi = 11;
-    if (hi < lo) hi = lo;
-    return [lo, hi];
-  }
-  if (v === 'KDP') {
-    const lo = rangeMin ?? -2;
-    let hi = rangeMax ?? 8;
-    if (hi < lo) hi = lo;
-    return [lo, hi];
-  }
-  return [rangeMin ?? 0, rangeMax ?? 80];
+function ge(c, e, t, a, n) {
+  const i = (t || "").toUpperCase();
+  if (U(i)) {
+    const [r, s] = pe(c, e, a);
+    return [r ?? 0, s ?? 80];
+  }
+  if (n === "level3" && (i === "N0H" || i === "HHC")) {
+    const r = c ?? 0;
+    let s = e ?? 11;
+    return s > 11 && (s = 11), s < r && (s = r), [r, s];
+  }
+  if (i === "KDP") {
+    const r = c ?? -2;
+    let s = e ?? 8;
+    return s < r && (s = r), [r, s];
+  }
+  return [c ?? 0, e ?? 80];
 }
-function nexradLevel3IsHydrometeorClassification(radarVariable) {
-  const v = (radarVariable || '').toUpperCase();
-  return v === 'N0H' || v === 'HHC';
+function fe(c) {
+  const e = (c || "").toUpperCase();
+  return e === "N0H" || e === "HHC";
 }
-const NEXRAD_HYDROMETEOR_CLASS_LABELS = ['Biological', 'Ground clutter', 'Ice crystals', 'Dry snow', 'Wet snow', 'Light rain', 'Heavy rain', 'Big drops', 'Graupel', 'Hail/rain', 'Large hail', 'Giant hail'];
-function nexradHydrometeorLabelForClassIndex(value) {
-  const idx = Math.round(Number(value));
-  if (idx >= 12) return null;
-  if (idx >= 0 && idx < NEXRAD_HYDROMETEOR_CLASS_LABELS.length) {
-    return NEXRAD_HYDROMETEOR_CLASS_LABELS[idx];
-  }
-  return `Class ${idx}`;
+const Y = ["Biological", "Ground clutter", "Ice crystals", "Dry snow", "Wet snow", "Light rain", "Heavy rain", "Big drops", "Graupel", "Hail/rain", "Large hail", "Giant hail"];
+function xe(c) {
+  const e = Math.round(Number(c));
+  return e >= 12 ? null : e >= 0 && e < Y.length ? Y[e] : `Class ${e}`;
 }
-function velocityMsToDisplay(valueMs, displayUnit) {
-  if (!displayUnit || displayUnit.toLowerCase() === 'm/s' || displayUnit.toLowerCase() === 'ms') {
-    return valueMs;
-  }
-  const fromMs = getUnitConversionFunction('m/s', displayUnit, 'nexrad_vel');
-  return fromMs ? fromMs(valueMs) : valueMs;
+function ve(c, e) {
+  if (!e || e.toLowerCase() === "m/s" || e.toLowerCase() === "ms") return c;
+  const t = O("m/s", e, "nexrad_vel");
+  return t ? t(c) : c;
 }
-function beamHeightKm(slantRangeKm, elevDeg) {
-  const el = elevDeg * Math.PI / 180;
-  const ReKm = 6371000 * 4 / (3 * 1000);
-  const cosEl = Math.max(Math.cos(el), 0.05);
-  const s = slantRangeKm / cosEl;
-  return Math.sqrt(s * s + ReKm * ReKm + 2 * s * ReKm * Math.sin(el)) - ReKm;
+function _e(c, e) {
+  const t = e * Math.PI / 180,
+    a = 6371e3 * 4 / (3 * 1e3),
+    n = Math.max(Math.cos(t), .05),
+    i = c / n;
+  return Math.sqrt(i * i + a * a + 2 * i * a * Math.sin(t)) - a;
 }
-function formatNexradInspectNumeric(raw, radarVariable) {
-  const vu = (radarVariable || '').toUpperCase();
-  const vl = radarVariable || '';
-  if (vu.includes('RATE') || vl.toLowerCase().includes('rate')) {
-    return Number(raw.toFixed(3).replace(/\.?0+$/, ''));
-  }
-  if (vu === 'RHO' || vu === 'ZDR' || vl.includes('RhoHV') || vl.includes('Zdr')) {
-    return Number(raw.toFixed(2));
-  }
-  if (Math.abs(raw) < 10) return Number(raw.toFixed(1));
-  return Math.round(raw);
+function Se(c, e) {
+  const t = (e || "").toUpperCase(),
+    a = e || "";
+  return t.includes("RATE") || a.toLowerCase().includes("rate") ? Number(c.toFixed(3).replace(/\.?0+$/, "")) : t === "RHO" || t === "ZDR" || a.includes("RhoHV") || a.includes("Zdr") ? Number(c.toFixed(2)) : Math.abs(c) < 10 ? Number(c.toFixed(1)) : Math.round(c);
 }
-
-/** Keep low so Level-2 decode stays off the critical path for touches/animations (was 4). */
-/** iOS Metal uploads benefit from overlapping fetches; keep Android at 1 for steadier radio/CPU. */
-const PRELOAD_CONCURRENCY = Platform.OS === 'ios' ? 2 : 1;
-function yieldToJsEventLoop() {
-  return new Promise(resolve => setTimeout(resolve, 0));
+const be = ce.OS === "ios" ? 2 : 1;
+function M() {
+  return new Promise(c => setTimeout(c, 0));
 }
-
-/** Match mapsgl {@link MapboxRadarLayer} geometry LRU — reuse serialized native payloads when scrubbing. */
-const NATIVE_UPLOAD_JSON_LRU_MAX = 12;
-function rleCompressGateData(gateData) {
-  const len = gateData.length;
-  const out = new Uint8Array(len * 2);
-  let outIdx = 0;
-  let i = 0;
-  while (i < len) {
-    let val0 = gateData[i];
-    let val1 = gateData[i + 1];
-    let count = 1;
-    let maxCount = len - i >> 1;
-    if (maxCount > 65535) maxCount = 65535;
-    let j = i + 2;
-    while (count < maxCount && gateData[j] === val0 && gateData[j + 1] === val1) {
-      count++;
-      j += 2;
-    }
-    out[outIdx++] = count & 0xFF;
-    out[outIdx++] = count >> 8 & 0xFF;
-    out[outIdx++] = val0;
-    out[outIdx++] = val1;
-    i = j;
-  }
-  return out.subarray(0, outIdx);
+const Ne = 12;
+function Te(c) {
+  const e = c.length,
+    t = new Uint8Array(e * 2);
+  let a = 0,
+    n = 0;
+  for (; n < e;) {
+    let i = c[n],
+      r = c[n + 1],
+      s = 1,
+      l = e - n >> 1;
+    l > 65535 && (l = 65535);
+    let o = n + 2;
+    for (; s < l && c[o] === i && c[o + 1] === r;) s++, o += 2;
+    t[a++] = s & 255, t[a++] = s >> 8 & 255, t[a++] = i, t[a++] = r, n = o;
+  }
+  return t.subarray(0, a);
 }
 export class NexradAndroidController {
-  /**
-   * @param {*} core - AguaceroCore instance
-   * @param {React.MutableRefObject<{ uploadNexradFrame?: (s: string) => void; uploadNexradStyleOnly?: (s: string) => void; clearNexrad?: () => void; activateNexradCachedFrame?: (k: string) => void } | null>} layerRef
-       * @param {object} [options]
-       */
-  constructor(core, layerRef, options = {}) {
-    this.core = core;
-    this._layerRef = layerRef;
-    this._lastSyncKey = null;
-    this._abort = null;
-    this._interpolateColormap = options.interpolateNexradColormap !== false;
-    this._gateSmoothing = options.nexradGateSmoothing === true;
-    this._frameCache = new Map();
-    /** WeakMap: decoded frame → Map(uploadOptsKey → prepared frame). Avoids O(n²) canonical re-bin every map move. */
-    this._gpuReadoutPrep = new WeakMap();
-    this._preloadAbort = null;
-    this._preloadTimelineSig = null;
-    this._nativeFrameUploaded = false;
-    /** @type {{ valueScale: number; valueOffset: number } | null} */
-    this._lastUploadMeta = null;
-    /** @type {Map<string, { json: string; valueScale: number; valueOffset: number }>} */
-    this._nativeUploadJsonLru = new Map();
-    /** @type {Set<string>} Sync keys with gate texture registered in Android GL cache (AguaceroNexradGpuFrameReady). */
-    this._nativeGpuReadyKeys = new Set();
-    /** @type {Map<string, { valueScale: number; valueOffset: number }>} */
-    this._uploadMetaBySyncKey = new Map();
-    /** @type {{ remove: () => void } | null} */
-    this._gpuReadyEventSub = null;
+  constructor(e, t, a = {}) {
+    this.core = e, this._layerRef = t, this._lastSyncKey = null, this._abort = null, this._interpolateColormap = a.interpolateNexradColormap !== !1, this._gateSmoothing = a.nexradGateSmoothing === !0, this._frameCache = new Map(), this._gpuReadoutPrep = new WeakMap(), this._preloadAbort = null, this._preloadTimelineSig = null, this._listingRefreshPromise = null, this._nativeFrameUploaded = !1, this._lastUploadMeta = null, this._nativeUploadJsonLru = new Map(), this._nativeGpuReadyKeys = new Set(), this._uploadMetaBySyncKey = new Map(), this._gpuReadyEventSub = null;
     try {
       const {
-        DeviceEventEmitter
-      } = require('react-native');
-      if (DeviceEventEmitter && typeof DeviceEventEmitter.addListener === 'function') {
-        this._gpuReadyEventSub = DeviceEventEmitter.addListener('AguaceroNexradGpuFrameReady', e => {
-          const k = e && e.nativeGpuCacheKey;
-          if (typeof k === 'string' && k.length > 0) {
-            this._nativeGpuReadyKeys.add(k);
-            this._trimNativeGpuReadyKeys(96);
-          }
-        });
-      }
-    } catch (err) {
-      /* ignore */
-    }
-    const base = typeof core?.baseGridUrl === 'string' ? core.baseGridUrl.replace(/\/$/, '') : '';
-    if (base && typeof navigator !== 'undefined' && navigator.product === 'ReactNative') {
-      setNexradSitesJsonUrl(`${base}/data/nexrad.json`);
-      setNexradSitesFetchAuth(core.apiKey || '', core.bundleId || '');
-    }
-    setNexradArchiveSiteOrigin(core.gridRequestSiteOrigin || 'https://localhost');
-    if (isAguaceroRnDebugEnabled()) {
-      aguaceroDebug('nexrad.authConfigured', getAguaceroAuthDiagnosticSnapshot(core, {
-        phase: 'NexradAndroidController.constructor'
+        DeviceEventEmitter: i
+      } = require("react-native");
+      i && typeof i.addListener == "function" && (this._gpuReadyEventSub = i.addListener("AguaceroNexradGpuFrameReady", r => {
+        const s = r && r.nativeGpuCacheKey;
+        typeof s == "string" && s.length > 0 && (this._nativeGpuReadyKeys.add(s), this._trimNativeGpuReadyKeys(96));
       }));
-    }
+    } catch {}
+    const n = typeof e?.baseGridUrl == "string" ? e.baseGridUrl.replace(/\/$/, "") : "";
+    n && typeof navigator < "u" && navigator.product === "ReactNative" && (se(`${n}/data/nexrad.json`), B(e.apiKey || "", e.bundleId || "")), L(e.apiKey || ""), R(e.bundleId || ""), w(e.gridRequestSiteOrigin || I), $(e.nexradUserId || "sdk-user"), W() && z("nexrad.authConfigured", {
+      ...ne({
+        phase: "NexradAndroidController.constructor"
+      }),
+      ...H(e, {
+        phase: "NexradAndroidController.constructor"
+      })
+    });
   }
-  _trimNativeGpuReadyKeys(max) {
-    while (this._nativeGpuReadyKeys.size > max) {
-      const first = this._nativeGpuReadyKeys.values().next().value;
-      if (first === undefined) break;
-      this._nativeGpuReadyKeys.delete(first);
+  _trimNativeGpuReadyKeys(e) {
+    for (; this._nativeGpuReadyKeys.size > e;) {
+      const t = this._nativeGpuReadyKeys.values().next().value;
+      if (t === void 0) break;
+      this._nativeGpuReadyKeys.delete(t);
     }
   }
-  _rememberUploadMetaForSyncKey(syncKey, valueScale, valueOffset) {
-    this._uploadMetaBySyncKey.set(syncKey, {
-      valueScale,
-      valueOffset
-    });
-    while (this._uploadMetaBySyncKey.size > 40) {
-      const k = this._uploadMetaBySyncKey.keys().next().value;
-      if (k === undefined) break;
-      this._uploadMetaBySyncKey.delete(k);
+  _rememberUploadMetaForSyncKey(e, t, a) {
+    for (this._uploadMetaBySyncKey.set(e, {
+      valueScale: t,
+      valueOffset: a
+    }); this._uploadMetaBySyncKey.size > 40;) {
+      const n = this._uploadMetaBySyncKey.keys().next().value;
+      if (n === void 0) break;
+      this._uploadMetaBySyncKey.delete(n);
     }
   }
-  updateStyleOptions(options) {
-    if (options.interpolateNexradColormap != null) {
-      this._interpolateColormap = options.interpolateNexradColormap !== false;
-    }
-    if (options.nexradGateSmoothing != null) {
-      this._gateSmoothing = options.nexradGateSmoothing === true;
-    }
+  updateStyleOptions(e) {
+    e.interpolateNexradColormap != null && (this._interpolateColormap = e.interpolateNexradColormap !== !1), e.nexradGateSmoothing != null && (this._gateSmoothing = e.nexradGateSmoothing === !0);
   }
   destroy() {
     try {
       this._gpuReadyEventSub?.remove();
-    } catch (_) {
-      /* ignore */
-    }
-    this._gpuReadyEventSub = null;
-    this._nativeGpuReadyKeys.clear();
-    this._uploadMetaBySyncKey.clear();
-    this._abort?.abort();
-    this._abort = null;
-    this._preloadAbort?.abort();
-    this._preloadAbort = null;
-    this._frameCache.clear();
-    this._gpuReadoutPrep = new WeakMap();
-    this._preloadTimelineSig = null;
-    this._lastSyncKey = null;
-    this._nativeFrameUploaded = false;
-    this._lastUploadMeta = null;
-    this._nativeUploadJsonLru.clear();
-    this._layerRef?.current?.clearNexrad?.();
+    } catch {}
+    this._gpuReadyEventSub = null, this._nativeGpuReadyKeys.clear(), this._uploadMetaBySyncKey.clear(), this._abort?.abort(), this._abort = null, this._preloadAbort?.abort(), this._preloadAbort = null, this._frameCache.clear(), this._gpuReadoutPrep = new WeakMap(), this._preloadTimelineSig = null, this._lastSyncKey = null, this._nativeFrameUploaded = !1, this._lastUploadMeta = null, this._nativeUploadJsonLru.clear(), this._layerRef?.current?.clearNexrad?.();
   }
-  _getPreparedReadoutFrame(frame, uploadOpts) {
-    let byOpts = this._gpuReadoutPrep.get(frame);
-    if (!byOpts) {
-      byOpts = new Map();
-      this._gpuReadoutPrep.set(frame, byOpts);
-    }
-    const optKey = uploadOpts && typeof uploadOpts === 'object' ? JSON.stringify(uploadOpts) : String(uploadOpts);
-    let prepared = byOpts.get(optKey);
-    if (!prepared) {
-      prepared = prepareRadarFrameForGpuReadout(frame, uploadOpts);
-      byOpts.set(optKey, prepared);
-    }
-    return prepared;
+  _getPreparedReadoutFrame(e, t) {
+    let a = this._gpuReadoutPrep.get(e);
+    a || (a = new Map(), this._gpuReadoutPrep.set(e, a));
+    const n = t && typeof t == "object" ? JSON.stringify(t) : String(t);
+    let i = a.get(n);
+    return i || (i = oe(e, t), a.set(n, i)), i;
   }
   _native() {
     return this._layerRef?.current;
   }
-  _lutPack(state) {
-    const radarVar = (state.nexradProduct || 'REF').toUpperCase();
-    const colormapFlat = state.colormap;
-    const colormapForShader = colormapToMs(colormapFlat, radarVar, state.units);
-    const [shaderMin, shaderMax] = radarShaderValueRange(colormapFlat?.[0], colormapFlat?.[colormapFlat.length - 2], radarVar, state.units, state.nexradDataSource);
-    const {
-      bytes,
-      discreteIntegerLut
-    } = buildNexradLutRgba(colormapForShader, shaderMin, shaderMax, this._interpolateColormap);
+  _lutPack(e) {
+    const t = (e.nexradProduct || "REF").toUpperCase(),
+      a = e.colormap,
+      n = ye(a, t, e.units),
+      [i, r] = ge(a?.[0], a?.[a.length - 2], t, e.units, e.nexradDataSource),
+      {
+        bytes: s,
+        discreteIntegerLut: l
+      } = de(n, i, r, this._interpolateColormap);
     return {
-      lutB64: fromByteArray(bytes),
-      lutMin: shaderMin,
-      lutMax: shaderMax,
-      discreteIntegerLut
+      lutB64: J(s),
+      lutMin: i,
+      lutMax: r,
+      discreteIntegerLut: l
     };
   }
-
-  /**
-   * LRU for full native JSON payloads (parity with mapsgl gate-texture reuse — avoids base64 + stringify on repeat scrubs).
-   * @param {string} syncKey
-   * @returns {{ json: string; valueScale: number; valueOffset: number } | null}
-   */
-  _nativeUploadJsonLruTouch(syncKey) {
-    const ent = this._nativeUploadJsonLru.get(syncKey);
-    if (!ent) return null;
-    this._nativeUploadJsonLru.delete(syncKey);
-    this._nativeUploadJsonLru.set(syncKey, ent);
-    return ent;
-  }
-
-  /** @param {string} syncKey @param {{ json: string; valueScale: number; valueOffset: number }} entry */
-  _nativeUploadJsonLruPut(syncKey, entry) {
-    if (this._nativeUploadJsonLru.has(syncKey)) this._nativeUploadJsonLru.delete(syncKey);
-    this._nativeUploadJsonLru.set(syncKey, entry);
-    while (this._nativeUploadJsonLru.size > NATIVE_UPLOAD_JSON_LRU_MAX) {
-      const oldest = this._nativeUploadJsonLru.keys().next().value;
-      if (oldest === undefined) break;
-      this._nativeUploadJsonLru.delete(oldest);
-    }
-  }
-
-  /**
-   * Full-frame JSON includes LUT + opacity + shader toggles; keep LRU key aligned so scrubbing
-   * cannot resurrect an outdated style after the user changes only presentation options.
-   */
-  _nativeUploadLruKey(state, syncKey) {
-    return `${syncKey}|o:${state.opacity ?? 1}|g:${this._gateSmoothing ? 1 : 0}|i:${this._interpolateColormap ? 1 : 0}`;
-  }
-
-  /**
-   * After JS decoded a frame into `_frameCache`, optionally push it through the native bridge.
-   * During timeline preload we **only** upload the **currently displayed** unix to Metal; other
-   * volumes stay in the JS cache until {@link sync} needs them (avoids 40+ full decodes on load).
-   */
-  _primeNativeGpuUploadIfNeeded(snapshot, unix, p, frame, abortSignal) {
-    if (!frame || !p || abortSignal && abortSignal.aborted) return;
-    try {
-      const displayUx = snapshot.nexradTimestamp != null && Number.isFinite(Number(snapshot.nexradTimestamp)) ? Number(snapshot.nexradTimestamp) : NaN;
-      if (Number.isFinite(displayUx) && Number(unix) !== displayUx) {
-        return;
-      }
-      const syncKey = this._syncIdentity(snapshot, p, unix);
-      if (this._nativeGpuReadyKeys.has(syncKey)) {
-        return;
-      }
-      if (!this._native()?.uploadNexradFrame) {
-        return;
-      }
-      this._uploadFrameToNative(snapshot, frame, p, unix);
-    } catch (err) {
-      /* ignore */
-    }
-  }
-
-  /**
-   * @param {*} state
-   * @param {*} frame - decoded archive frame
-   * @param {{ fetchKey: string }} p - from {@link _buildFetchParamsForUnix}
-   * @param {number} unix
-   */
-  _uploadFrameToNative(state, frame, p, unix) {
-    const uploadTotal = nexradPerfSpan(`uploadFrame.total site=${state.nexradSite} unix=${unix} var=${p?.radarVar ?? state.nexradProduct}`);
-    const n = this._native();
-    if (!n?.uploadNexradFrame) {
-      uploadTotal.end({
-        outcome: 'skippedNoNative'
+  _nativeUploadJsonLruTouch(e) {
+    const t = this._nativeUploadJsonLru.get(e);
+    return t ? (this._nativeUploadJsonLru.delete(e), this._nativeUploadJsonLru.set(e, t), t) : null;
+  }
+  _nativeUploadJsonLruPut(e, t) {
+    for (this._nativeUploadJsonLru.has(e) && this._nativeUploadJsonLru.delete(e), this._nativeUploadJsonLru.set(e, t); this._nativeUploadJsonLru.size > Ne;) {
+      const a = this._nativeUploadJsonLru.keys().next().value;
+      if (a === void 0) break;
+      this._nativeUploadJsonLru.delete(a);
+    }
+  }
+  _nativeUploadLruKey(e, t) {
+    return `${t}|o:${e.opacity ?? 1}|g:${this._gateSmoothing ? 1 : 0}|i:${this._interpolateColormap ? 1 : 0}`;
+  }
+  _primeNativeGpuUploadIfNeeded(e, t, a, n, i) {
+    if (!(!n || !a || i && i.aborted)) try {
+      const r = e.nexradTimestamp != null && Number.isFinite(Number(e.nexradTimestamp)) ? Number(e.nexradTimestamp) : NaN;
+      if (Number.isFinite(r) && Number(t) !== r) return;
+      const s = this._syncIdentity(e, a, t);
+      if (this._nativeGpuReadyKeys.has(s) || !this._native()?.uploadNexradFrame) return;
+      this._uploadFrameToNative(e, n, a, t);
+    } catch {}
+  }
+  _uploadFrameToNative(e, t, a, n) {
+    const i = h(`uploadFrame.total site=${e.nexradSite} unix=${n} var=${a?.radarVar ?? e.nexradProduct}`),
+      r = this._native();
+    if (!r?.uploadNexradFrame) {
+      y("upload.skip", {
+        reason: "noNativeUploadMethod",
+        site: e.nexradSite,
+        unix: n,
+        layerRefSet: !!this._layerRef?.current
+      }), i.end({
+        outcome: "skippedNoNative"
       });
       return;
     }
-    const syncKey = this._syncIdentity(state, p, unix);
-    const lruKey = this._nativeUploadLruKey(state, syncKey);
-    const lruHit = this._nativeUploadJsonLruTouch(lruKey);
-    if (lruHit) {
-      this._lastUploadMeta = {
-        valueScale: lruHit.valueScale,
-        valueOffset: lruHit.valueOffset
-      };
-      this._rememberUploadMetaForSyncKey(syncKey, lruHit.valueScale, lruHit.valueOffset);
-      if (n.activateNexradCachedFrame && this._nativeGpuReadyKeys.has(syncKey)) {
-        const tAct = nexradPerfSpan('uploadFrame.nativeGpuActivateOnly');
-        n.activateNexradCachedFrame(syncKey);
-        tAct.end({
-          keyLen: syncKey.length
+    const s = this._syncIdentity(e, a, n),
+      l = this._nativeUploadLruKey(e, s),
+      o = this._nativeUploadJsonLruTouch(l);
+    if (o) {
+      if (this._lastUploadMeta = {
+        valueScale: o.valueScale,
+        valueOffset: o.valueOffset
+      }, this._rememberUploadMetaForSyncKey(s, o.valueScale, o.valueOffset), r.activateNexradCachedFrame && this._nativeGpuReadyKeys.has(s)) {
+        const K = h("uploadFrame.nativeGpuActivateOnly");
+        r.activateNexradCachedFrame(s), K.end({
+          keyLen: s.length
         });
-        const tStyle = nexradPerfSpan('uploadFrame.styleAfterGpuActivate');
-        this.applyStyleFromState(state);
-        tStyle.end({});
-        this._nativeFrameUploaded = true;
-        uploadTotal.end({
-          outcome: 'gpuActivateOnly',
-          jsonCharsSkipped: lruHit.json.length
+        const Z = h("uploadFrame.styleAfterGpuActivate");
+        this.applyStyleFromState(e), Z.end({}), this._nativeFrameUploaded = !0, i.end({
+          outcome: "gpuActivateOnly",
+          jsonCharsSkipped: o.json.length
         });
         return;
       }
-      const bridge = nexradPerfSpan('uploadFrame.nativeJsonLru.bridgeDispatch');
-      n.uploadNexradFrame(lruHit.json);
-      bridge.end({
-        jsonChars: lruHit.json.length,
-        path: 'jsonLruHit'
-      });
-      this._nativeFrameUploaded = true;
-      uploadTotal.end({
-        outcome: 'jsonLruHit',
-        jsonChars: lruHit.json.length
+      const A = h("uploadFrame.nativeJsonLru.bridgeDispatch");
+      r.uploadNexradFrame(o.json), A.end({
+        jsonChars: o.json.length,
+        path: "jsonLruHit"
+      }), this._nativeFrameUploaded = !0, i.end({
+        outcome: "jsonLruHit",
+        jsonChars: o.json.length
       });
       return;
     }
-    const tOpts = nexradPerfSpan('uploadFrame.mapboxFrameUploadOptions');
-    const uploadOpts = mapboxFrameUploadOptionsForNexradState(state);
-    tOpts.end({});
-
-    // Skip JS sorting for Android native upload
-    // We pass the raw frame and let Android do the sorting/canonicalization
-    const rawFrame = frame;
+    const m = h("uploadFrame.mapboxFrameUploadOptions"),
+      u = V(e);
+    m.end({});
+    const d = t;
     this._lastUploadMeta = {
-      valueScale: rawFrame.valueScale,
-      valueOffset: rawFrame.valueOffset
+      valueScale: d.valueScale,
+      valueOffset: d.valueOffset
     };
-    const tLut = nexradPerfSpan('uploadFrame.lutPack_buildNexradLutRgba');
-    const style = this._lutPack(state);
-    tLut.end({
-      lutB64Chars: style.lutB64?.length ?? 0,
-      discreteIntegerLut: style.discreteIntegerLut,
-      lutMin: style.lutMin,
-      lutMax: style.lutMax
+    const N = h("uploadFrame.lutPack_buildNexradLutRgba"),
+      p = this._lutPack(e);
+    N.end({
+      lutB64Chars: p.lutB64?.length ?? 0,
+      discreteIntegerLut: p.discreteIntegerLut,
+      lutMin: p.lutMin,
+      lutMax: p.lutMax
     });
-    const tRay = nexradPerfSpan('uploadFrame.rayBoundariesToJsArray');
-    const rayBoundaries = rawFrame.rayBoundariesDeg?.slice ? Array.from(rawFrame.rayBoundariesDeg) : [...(rawFrame.rayBoundariesDeg || [])];
-    tRay.end({
-      len: rayBoundaries.length
+    const F = h("uploadFrame.rayBoundariesToJsArray"),
+      g = d.rayBoundariesDeg?.slice ? Array.from(d.rayBoundariesDeg) : [...(d.rayBoundariesDeg || [])];
+    F.end({
+      len: g.length
     });
-    const tB64 = nexradPerfSpan('uploadFrame.gateData_toBase64');
-    const rleGateData = rleCompressGateData(rawFrame.gateData);
-    const gateB64 = fromByteArray(rleGateData);
-    tB64.end({
-      gateB64Chars: gateB64.length,
-      rleBytes: rleGateData.length,
-      rawBytes: rawFrame.gateData.length
+    const f = h("uploadFrame.gateData_toBase64"),
+      _ = Te(d.gateData),
+      C = J(_);
+    f.end({
+      gateB64Chars: C.length,
+      rleBytes: _.length,
+      rawBytes: d.gateData.length
     });
-    const payload = {
-      gateB64,
-      gateIsRle: true,
-      nGates: rawFrame.nGates,
-      nRays: rawFrame.nRays,
-      stationLat: rawFrame.stationLat,
-      stationLon: rawFrame.stationLon,
-      firstGateKm: rawFrame.firstGateKm,
-      gateWidthKm: rawFrame.gateWidthKm,
-      rayBoundaries,
-      lutB64: style.lutB64,
-      valueScale: rawFrame.valueScale,
-      valueOffset: rawFrame.valueOffset,
-      lutMin: style.lutMin,
-      lutMax: style.lutMax,
-      discreteIntegerLut: style.discreteIntegerLut,
-      opacity: state.opacity ?? 1,
-      gateSmoothPolar: this._gateSmoothing ? 1 : 0,
-      interpolateLut: this._interpolateColormap ? 1 : 0,
-      nativeGpuCacheKey: syncKey,
-      uploadOpts: uploadOpts
-    };
-    const tJson = nexradPerfSpan('uploadFrame.JSON_stringify_payload');
-    const json = JSON.stringify(payload);
-    tJson.end({
-      jsonChars: json.length,
-      rayBoundaryLen: rayBoundaries.length
-    });
-    const tLruPut = nexradPerfSpan('uploadFrame.nativeUploadJsonLruPut');
-    this._nativeUploadJsonLruPut(lruKey, {
-      json,
-      valueScale: rawFrame.valueScale,
-      valueOffset: rawFrame.valueOffset
+    const x = {
+        gateB64: C,
+        gateIsRle: !0,
+        nGates: d.nGates,
+        nRays: d.nRays,
+        stationLat: d.stationLat,
+        stationLon: d.stationLon,
+        firstGateKm: d.firstGateKm,
+        gateWidthKm: d.gateWidthKm,
+        rayBoundaries: g,
+        lutB64: p.lutB64,
+        valueScale: d.valueScale,
+        valueOffset: d.valueOffset,
+        lutMin: p.lutMin,
+        lutMax: p.lutMax,
+        discreteIntegerLut: p.discreteIntegerLut ? 1 : 0,
+        opacity: e.opacity ?? 1,
+        gateSmoothPolar: this._gateSmoothing ? 1 : 0,
+        interpolateLut: this._interpolateColormap ? 1 : 0,
+        nativeGpuCacheKey: s,
+        uploadOpts: u
+      },
+      S = h("uploadFrame.JSON_stringify_payload"),
+      v = JSON.stringify(x);
+    S.end({
+      jsonChars: v.length,
+      rayBoundaryLen: g.length
     });
-    tLruPut.end({
-      lruKeyTail: lruKey.slice(-96),
+    const b = h("uploadFrame.nativeUploadJsonLruPut");
+    this._nativeUploadJsonLruPut(l, {
+      json: v,
+      valueScale: d.valueScale,
+      valueOffset: d.valueOffset
+    }), b.end({
+      lruKeyTail: l.slice(-96),
       lruSize: this._nativeUploadJsonLru.size
     });
-    const gateSummary = nexradDiagGateTextureSummary(rawFrame.gateData, rawFrame.nGates, rawFrame.nRays, rawFrame.valueScale, rawFrame.valueOffset, style.lutMin, style.lutMax);
-    const tBridge = nexradPerfSpan('uploadFrame.nativeBridge_uploadNexradFrame');
-    n.uploadNexradFrame(json);
-    tBridge.end({
-      jsonChars: json.length,
-      path: 'fullRebuild'
-    });
-    this._rememberUploadMetaForSyncKey(syncKey, rawFrame.valueScale, rawFrame.valueOffset);
-    this._nativeFrameUploaded = true;
-    uploadTotal.end({
-      outcome: 'fullPipeline',
-      jsonChars: json.length,
-      nGates: rawFrame.nGates,
-      nRays: rawFrame.nRays
+    const T = he(d.gateData, d.nGates, d.nRays, d.valueScale, d.valueOffset, p.lutMin, p.lutMax),
+      P = h("uploadFrame.nativeBridge_uploadNexradFrame");
+    r.uploadNexradFrame(v), P.end({
+      jsonChars: v.length,
+      path: "fullRebuild"
+    }), this._rememberUploadMetaForSyncKey(s, d.valueScale, d.valueOffset), this._nativeFrameUploaded = !0, i.end({
+      outcome: "fullPipeline",
+      jsonChars: v.length,
+      nGates: d.nGates,
+      nRays: d.nRays
     });
   }
-  applyStyleFromState(state) {
-    const perf = nexradPerfSpan(`applyStyleFromState site=${state.nexradSite} product=${state.nexradProduct} tilt=${state.nexradTilt}`);
-    const n = this._native();
-    if (!this._nativeFrameUploaded || !this._lastUploadMeta || !n?.uploadNexradStyleOnly) {
-      perf.end({
-        outcome: 'skipped',
+  applyStyleFromState(e) {
+    const t = h(`applyStyleFromState site=${e.nexradSite} product=${e.nexradProduct} tilt=${e.nexradTilt}`),
+      a = this._native();
+    if (!this._nativeFrameUploaded || !this._lastUploadMeta || !a?.uploadNexradStyleOnly) {
+      t.end({
+        outcome: "skipped",
         nativeFrameUploaded: this._nativeFrameUploaded,
         hasUploadMeta: !!this._lastUploadMeta,
-        hasStyleMethod: !!n?.uploadNexradStyleOnly
+        hasStyleMethod: !!a?.uploadNexradStyleOnly
       });
       return;
     }
-    const tLut = nexradPerfSpan('applyStyleFromState.lutPack');
-    const style = this._lutPack(state);
-    tLut.end({
-      lutB64Chars: style.lutB64?.length ?? 0
-    });
-    const payload = {
-      lutB64: style.lutB64,
-      valueScale: this._lastUploadMeta.valueScale,
-      valueOffset: this._lastUploadMeta.valueOffset,
-      lutMin: style.lutMin,
-      lutMax: style.lutMax,
-      discreteIntegerLut: style.discreteIntegerLut,
-      opacity: state.opacity ?? 1,
-      gateSmoothPolar: this._gateSmoothing ? 1 : 0,
-      interpolateLut: this._interpolateColormap ? 1 : 0
-    };
-    const tJson = nexradPerfSpan('applyStyleFromState.JSON_stringify');
-    const json = JSON.stringify(payload);
-    tJson.end({
-      jsonChars: json.length
+    const n = h("applyStyleFromState.lutPack"),
+      i = this._lutPack(e);
+    n.end({
+      lutB64Chars: i.lutB64?.length ?? 0
     });
-    const tBridge = nexradPerfSpan('applyStyleFromState.nativeBridge');
-    n.uploadNexradStyleOnly(json);
-    tBridge.end({
-      jsonChars: json.length
+    const r = {
+        lutB64: i.lutB64,
+        valueScale: this._lastUploadMeta.valueScale,
+        valueOffset: this._lastUploadMeta.valueOffset,
+        lutMin: i.lutMin,
+        lutMax: i.lutMax,
+        discreteIntegerLut: i.discreteIntegerLut ? 1 : 0,
+        opacity: e.opacity ?? 1,
+        gateSmoothPolar: this._gateSmoothing ? 1 : 0,
+        interpolateLut: this._interpolateColormap ? 1 : 0
+      },
+      s = h("applyStyleFromState.JSON_stringify"),
+      l = JSON.stringify(r);
+    s.end({
+      jsonChars: l.length
     });
-    perf.end({
-      outcome: 'dispatched'
+    const o = h("applyStyleFromState.nativeBridge");
+    a.uploadNexradStyleOnly(l), o.end({
+      jsonChars: l.length
+    }), t.end({
+      outcome: "dispatched"
     });
   }
-  _resolveListingContext(state) {
-    const nk = this.core._nexradTimesCacheKey?.();
-    const ent = nk ? this.core.nexradTimesByStation?.[nk] : null;
-    // Merge so we still resolve object keys if the last state event omitted maps but the core cache is populated.
-    const timeToKeyMap = {
-      ...(ent?.timeToKeyMap || {}),
-      ...(state.nexradTimeToKeyMap || {})
-    };
-    const motionMap = {
-      ...(ent?.level3MotionTimeToKeyMap || {}),
-      ...(state.nexradLevel3MotionTimeToKeyMap || {})
+  _resolveListingContext(e) {
+    const {
+        site: t,
+        elevNorm: a,
+        group: n
+      } = E(e),
+      i = (e?.nexradDataSource || "level2") !== "level3" && t ? `${t}_${n}_${a}` : this.core._nexradTimesCacheKey?.(),
+      r = i ? this.core.nexradTimesByStation?.[i] : null,
+      s = e?.nexradTimeToKeyMap && typeof e.nexradTimeToKeyMap == "object" ? e.nexradTimeToKeyMap : {};
+    let l = r?.timeToKeyMap && typeof r.timeToKeyMap == "object" ? {
+      ...s,
+      ...r.timeToKeyMap
+    } : {
+      ...s
     };
+    const o = r?.level2Clens,
+      m = Array.isArray(r?.unixTimes) && r.unixTimes.length > 0 ? r.unixTimes : Array.isArray(e?.availableNexradTimestamps) && e.availableNexradTimestamps.length > 0 ? e.availableNexradTimestamps : void 0;
+    if (this._nexradRadarSource(e) === "level2" && o && typeof o == "object" && Object.keys(o).length > 0) {
+      const d = re({
+        stationId: t,
+        elevNorm: a,
+        group: n,
+        timeToKeyMap: l,
+        level2Clens: o,
+        unixTimes: m
+      });
+      Object.keys(d).length > 0 ? l = d : Object.keys(l).length > 0 && (l = Object.fromEntries(Object.entries(l).filter(([, N]) => j(N))));
+    } else this._nexradRadarSource(e) === "level2" && (l = Object.fromEntries(Object.entries(l).filter(([, d]) => j(d))));
+    const u = r?.level3MotionTimeToKeyMap || {};
     return {
-      nk,
-      ent,
-      timeToKeyMap,
-      motionMap
+      nk: i,
+      ent: r,
+      timeToKeyMap: l,
+      motionMap: u
     };
   }
-  _buildFetchParamsForUnix(state, unix) {
-    const radarVar = (state.nexradProduct || 'REF').toUpperCase();
-    const radarSource = state.nexradDataSource === 'level3' ? 'level3' : 'level2';
-    const groupId = nexradBinGroupIdForKey(variableToNexradGroup(radarVar));
+  _nexradStateWithCoreListing(e) {
     const {
-      timeToKeyMap,
-      motionMap
-    } = this._resolveListingContext(state);
-    const objectKey = timeToKeyMap[String(unix)];
-    if (!objectKey) {
-      return null;
-    }
-    let motionObjectKey = null;
-    if (radarVar === 'VEL' && state.nexradStormRelative) {
-      motionObjectKey = pickNearestLevel3ObjectKey(unix, motionMap);
+        site: t,
+        elevNorm: a,
+        group: n
+      } = E(e),
+      i = (e?.nexradDataSource || "level2") !== "level3" && t ? `${t}_${n}_${a}` : this.core._nexradTimesCacheKey?.(),
+      r = i ? this.core.nexradTimesByStation?.[i] : null;
+    if (!r) return e;
+    const s = Array.isArray(r.unixTimes) ? r.unixTimes : [],
+      {
+        timeToKeyMap: l
+      } = this._resolveListingContext(e),
+      o = this.core._getFilteredNexradTimestampsForVariable(s),
+      m = this._nexradRadarSource(e) === "level2" ? o.filter(d => j(l[String(d)])) : o.filter(d => typeof l[String(d)] == "string" && l[String(d)].length > 0);
+    let u = e.nexradTimestamp != null ? e.nexradTimestamp : this.core.state.nexradTimestamp != null ? this.core.state.nexradTimestamp : null;
+    return u == null && m.length > 0 && (u = m[m.length - 1]), {
+      ...e,
+      availableNexradTimestamps: m,
+      nexradTimeToKeyMap: l,
+      nexradLevel3MotionTimeToKeyMap: r.level3MotionTimeToKeyMap || {},
+      nexradTimestamp: u
+    };
+  }
+  async _ensureLevel2ListingReady(e) {
+    if (this._nexradRadarSource(e) !== "level2") return;
+    if (this._listingRefreshPromise) {
+      await this._listingRefreshPromise;
+      return;
     }
-    const url = objectKeyToUrl(objectKey, radarSource);
-    const fetchKey = `${url}|${radarVar}|${radarSource}|${motionObjectKey || ''}`;
+    const t = () => this.core._nexradTimesCacheKey?.(),
+      a = () => t() ? this.core.nexradTimesByStation?.[t()] : null;
+    D(a()) && (this._listingRefreshPromise = (async () => {
+      try {
+        await this.core.refreshNexradTimes();
+        let n = a();
+        if (D(n)) {
+          const s = await te(this.core, this.core.state, {
+            siteOrigin: this.core.gridRequestSiteOrigin || ""
+          });
+          if (n = a(), !s) {
+            y("listing.patchFailed", {
+              site: e.nexradSite,
+              cacheKey: t()
+            });
+            return;
+          }
+          if (n?.level2ListingEmpty) {
+            y("listing.empty", {
+              site: e.nexradSite,
+              cacheKey: t(),
+              hint: ae(e.nexradSite)
+            });
+            return;
+          }
+        }
+        const i = n?.timeToKeyMap || {},
+          r = Object.values(i).find(s => typeof s == "string" && s.length > 0);
+        y("listing.refreshed", {
+          site: e.nexradSite,
+          product: e.nexradProduct,
+          tilt: e.nexradTilt,
+          cacheKey: t(),
+          clensEntries: Object.keys(n?.level2Clens || {}).length,
+          mappedTimes: Object.keys(i).length,
+          sampleKeyTail: typeof r == "string" ? r.slice(-72) : r
+        });
+      } catch (n) {
+        y("listing.refreshFailed", {
+          site: e.nexradSite,
+          message: n?.message || String(n)
+        });
+      } finally {
+        this._listingRefreshPromise = null;
+      }
+    })(), await this._listingRefreshPromise);
+  }
+  _logListingDiag(e, t, a, n = {}) {
+    const {
+        nk: i,
+        ent: r,
+        timeToKeyMap: s,
+        motionMap: l
+      } = this._resolveListingContext(t),
+      o = Object.keys(s || {}),
+      m = a != null ? s[String(a)] : void 0;
+    y(e, {
+      site: t.nexradSite,
+      product: t.nexradProduct,
+      tilt: t.nexradTilt,
+      radarSource: this._nexradRadarSource(t),
+      unix: a,
+      listingCacheKey: i,
+      coreListingPresent: !!r,
+      stateMapEntries: Object.keys(t.nexradTimeToKeyMap || {}).length,
+      mergedMapEntries: o.length,
+      motionMapEntries: Object.keys(l || {}).length,
+      availableUnixCount: Array.isArray(t.availableNexradTimestamps) ? t.availableNexradTimestamps.length : 0,
+      hasObjectKeyForUnix: a != null && Object.prototype.hasOwnProperty.call(s, String(a)),
+      objectKeyTail: typeof m == "string" ? m.slice(-72) : m,
+      sampleMapEntries: o.slice(0, 4).map(u => ({
+        unix: u,
+        keyTail: String(s[u] || "").slice(-56)
+      })),
+      nativeLayerReady: !!this._native()?.uploadNexradFrame,
+      ...n
+    });
+  }
+  _nexradRadarSource(e) {
+    return e.nexradDataSource === "level3" ? "level3" : "level2";
+  }
+  _buildFetchParamsForUnix(e, t, a = {}) {
+    const n = a.logDiag !== !1,
+      i = (e.nexradProduct || "REF").toUpperCase(),
+      r = this._nexradRadarSource(e),
+      s = X(ee(i)),
+      {
+        ent: l,
+        timeToKeyMap: o,
+        motionMap: m
+      } = this._resolveListingContext(e),
+      u = o[String(t)];
+    if (!u) return n && this._logListingDiag("fetchParams.missingObjectKey", e, t, {
+      radarVar: i
+    }), null;
+    const d = r === "level2" ? ie({
+      state: e,
+      listingEntry: l,
+      unix: t,
+      radarVar: i,
+      rawKey: u
+    }) : u;
+    if (!d) return n && y("fetchParams.invalidLevel2ObjectKey", {
+      site: e.nexradSite,
+      unix: t,
+      rawKeyTail: String(u).slice(-72),
+      hasLevel2Clens: !!(l?.level2Clens && Object.keys(l.level2Clens).length)
+    }), null;
+    let N = null;
+    i === "VEL" && e.nexradStormRelative && (N = me(t, m));
+    const p = G(d, r),
+      F = `${p}|${i}|${r}|${N || ""}`;
     return {
-      objectKey,
-      url,
-      fetchKey,
-      motionObjectKey,
-      radarVar,
-      radarSource,
-      groupId
+      objectKey: d,
+      url: p,
+      fetchKey: F,
+      motionObjectKey: N,
+      radarVar: i,
+      radarSource: r,
+      groupId: s
     };
   }
-  async _fetchFrame(state, unix, {
-    signal,
-    priority
+  async _fetchFrame(e, t, {
+    signal: a,
+    priority: n
   }) {
-    const fetchPerf = nexradPerfSpan(`fetchAndParseArchive priority=${priority} site=${state.nexradSite} unix=${unix} product=${state.nexradProduct}`);
-    const p = this._buildFetchParamsForUnix(state, unix);
-    if (!p) {
-      fetchPerf.end({
-        ok: false,
-        reason: 'noFetchParams'
-      });
-      return null;
-    }
+    const i = h(`fetchAndParseArchive priority=${n} site=${e.nexradSite} unix=${t} product=${e.nexradProduct}`),
+      r = this._buildFetchParamsForUnix(e, t);
+    if (!r) return i.end({
+      ok: !1,
+      reason: "noFetchParams"
+    }), null;
+    y("fetch.start", {
+      priority: n,
+      site: e.nexradSite,
+      unix: t,
+      radarVar: r.radarVar,
+      radarSource: r.radarSource,
+      url: r.url?.replace(/([?&])apiKey=[^&]*/gi, "$1apiKey=(redacted)"),
+      objectKeyTail: (r.objectKey || "").slice(-72),
+      motionKeyTail: (r.motionObjectKey || "").slice(-48)
+    });
     try {
-      const frame = await fetchAndParseArchive(p.url, p.objectKey, p.radarVar, p.groupId, p.radarSource, {
-        signal,
-        priority,
-        level3MotionObjectKey: p.motionObjectKey
-      });
-      fetchPerf.end({
-        ok: !!frame,
-        radarVar: p.radarVar,
-        radarSource: p.radarSource,
-        objectKeyTail: (p.objectKey || '').slice(-48),
-        motionKeyTail: (p.motionObjectKey || '').slice(-48)
-      });
-      return frame;
-    } catch (err) {
-      fetchPerf.end({
-        ok: false,
-        error: err?.message || String(err),
-        radarVar: p.radarVar,
-        radarSource: p.radarSource
-      });
-      throw err;
+      const s = await k(r.url, r.objectKey, r.radarVar, r.groupId, r.radarSource, {
+          signal: a,
+          priority: n,
+          level3MotionObjectKey: r.motionObjectKey
+        }),
+        l = {
+          ok: !!s,
+          radarVar: r.radarVar,
+          radarSource: r.radarSource,
+          objectKeyTail: (r.objectKey || "").slice(-48),
+          motionKeyTail: (r.motionObjectKey || "").slice(-48)
+        };
+      return s && (l.nGates = s.nGates, l.nRays = s.nRays, l.gateBytes = s.gateData?.length ?? 0), i.end(l), y(s ? "fetch.ok" : "fetch.emptyFrame", l), s;
+    } catch (s) {
+      const l = {
+        ok: !1,
+        error: s?.message || String(s),
+        radarVar: r.radarVar,
+        radarSource: r.radarSource,
+        objectKeyTail: (r.objectKey || "").slice(-48)
+      };
+      throw i.end(l), y("fetch.error", l), s;
     }
   }
-  _preloadTimelineSignature(state) {
-    const nk = this.core._nexradTimesCacheKey?.() || '';
-    const ts = [...(state.availableNexradTimestamps || [])].map(Number).filter(t => Number.isFinite(t)).sort((a, b) => a - b).join(',');
-    const tilt = state.nexradTilt != null && Number.isFinite(Number(state.nexradTilt)) ? Number(state.nexradTilt).toFixed(3) : '';
-    return `${nk}|${ts}|sr:${state.nexradStormRelative ? 1 : 0}|tilt:${tilt}`;
+  _preloadTimelineSignature(e) {
+    const t = this.core._nexradTimesCacheKey?.() || "",
+      a = [...(e.availableNexradTimestamps || [])].map(Number).filter(i => Number.isFinite(i)).sort((i, r) => i - r).join(","),
+      n = e.nexradTilt != null && Number.isFinite(Number(e.nexradTilt)) ? Number(e.nexradTilt).toFixed(3) : "";
+    return `${t}|${a}|sr:${e.nexradStormRelative ? 1 : 0}|tilt:${n}`;
   }
-  _syncIdentity(state, p, unix) {
-    const tilt = state.nexradTilt != null && Number.isFinite(Number(state.nexradTilt)) ? Number(state.nexradTilt).toFixed(3) : '';
-    return `${p.fetchKey}|tilt:${tilt}|u:${unix}`;
+  _syncIdentity(e, t, a) {
+    const n = e.nexradTilt != null && Number.isFinite(Number(e.nexradTilt)) ? Number(e.nexradTilt).toFixed(3) : "";
+    return `${t.fetchKey}|tilt:${n}|u:${a}`;
   }
-  preloadAllAvailable(state) {
-    if (!state.isNexrad || !state.nexradSite) return;
-    if (!ensureRadarArchiveBindings('preloadAllAvailable')) return;
-    const times = [...(state.availableNexradTimestamps || [])].map(Number).filter(t => Number.isFinite(t));
-    if (!times.length) {
-      // Important: do not touch `_preloadTimelineSig` or the frame cache here — callers
-      // sometimes pass `core.state` before `availableNexradTimestamps` is committed; an
-      // empty list must not poison the signature or wipe the LRU (see WeatherLayerManager
-      // preload kick merging subscription snapshot).
+  async preloadAllAvailable(e) {
+    if (!e.isNexrad || !e.nexradSite) {
+      y("preload.skip", {
+        reason: "notNexradOrNoSite",
+        isNexrad: e.isNexrad,
+        site: e.nexradSite
+      });
       return;
     }
-    const sig = this._preloadTimelineSignature(state);
-    if (sig === this._preloadTimelineSig) {
+    if (!q("preloadAllAvailable")) {
+      y("preload.skip", {
+        reason: "missingArchiveBindings",
+        site: e.nexradSite
+      });
       return;
     }
-    this._preloadTimelineSig = sig;
-    this._preloadAbort?.abort();
-    this._preloadAbort = new AbortController();
-    const signal = this._preloadAbort.signal;
-
-    // Keep the volume currently on screen in the JS cache so getInspectPayload (mapsgl parity readouts)
-    // still works while we clear and rebuild the prefetch LRU — otherwise readouts stay null until
-    // this unix is fetched again (often last in the timeline).
-    const curUnix = state.nexradTimestamp != null && Number.isFinite(Number(state.nexradTimestamp)) ? Number(state.nexradTimestamp) : NaN;
-
-    // Keep frames that are still in the new timeline (or the currently displayed one)
-    // to avoid re-fetching them when expanding the duration window.
-    const validFetchKeys = new Set();
-    for (const unix of times) {
-      const p = this._buildFetchParamsForUnix(state, unix);
-      if (p) validFetchKeys.add(p.fetchKey);
+    let t = e;
+    if ([...(t.availableNexradTimestamps || [])].length || (await this._ensureLevel2ListingReady(t), t = this._nexradStateWithCoreListing(t)), ![...(t.availableNexradTimestamps || [])].length) {
+      y("preload.skip", {
+        reason: "noAvailableTimestamps",
+        site: t.nexradSite,
+        product: t.nexradProduct,
+        hint: "Listing empty after refreshNexradTimes"
+      });
+      return;
     }
-    const curP = Number.isFinite(curUnix) ? this._buildFetchParamsForUnix(state, curUnix) : null;
-    if (curP) validFetchKeys.add(curP.fetchKey);
-    for (const key of this._frameCache.keys()) {
-      if (!validFetchKeys.has(key)) {
-        this._frameCache.delete(key);
-      }
+    await this._ensureLevel2ListingReady(t), t = this._nexradStateWithCoreListing(t);
+    const a = [...(t.availableNexradTimestamps || [])].map(Number).filter(g => Number.isFinite(g));
+    if (!a.length) {
+      y("preload.skip", {
+        reason: "noValidListingAfterRefresh",
+        site: e.nexradSite,
+        product: e.nexradProduct
+      });
+      return;
     }
-    // Do NOT clear `_nativeGpuReadyKeys` / JSON LRU / upload meta here: that forced a full
-    // ~1MB JSON parse + native decode on every timeline scrub after prefetch. GPU cache keys
-    // stay valid while Metal still holds the slot; `sync` falls back to full upload if needed.
-    // (Controller `destroy()` still clears everything on site/mode teardown.)
-
-    setNexradArchiveApiKey(this.core.apiKey || '');
-    setNexradArchiveBundleId(this.core.bundleId || '');
-    setNexradArchiveSiteOrigin(this.core.gridRequestSiteOrigin || 'https://localhost');
-    setNexradSitesFetchAuth(this.core.apiKey || '', this.core.bundleId || '');
-    if (isAguaceroRnDebugEnabled()) {
-      aguaceroDebug('nexrad.authConfigured', getAguaceroAuthDiagnosticSnapshot(this.core, {
-        phase: 'NexradAndroidController.preload',
-        site: state.nexradSite,
-        product: state.nexradProduct
-      }));
+    const n = this._preloadTimelineSignature(t);
+    if (n === this._preloadTimelineSig) {
+      y("preload.skip", {
+        reason: "sameTimelineSig",
+        site: e.nexradSite,
+        times: a.length
+      });
+      return;
     }
-    const snapshot = {
-      ...state
-    };
-    const preloadBatch = nexradPerfSpan(`preload.batch site=${state.nexradSite} times=${times.length}`);
-    let preloadCompleted = 0;
-    let preloadFailed = 0;
-    let preloadSkippedCached = 0;
-    const run = async () => {
-      // Prime the visible unix first so the active frame hits GPU before background slots.
-      const curUx = snapshot.nexradTimestamp != null && Number.isFinite(Number(snapshot.nexradTimestamp)) ? Number(snapshot.nexradTimestamp) : NaN;
-      if (Number.isFinite(curUx)) {
-        const p0 = this._buildFetchParamsForUnix(snapshot, curUx);
-        if (p0) {
-          const fr0 = this._frameCache.get(p0.fetchKey);
-          if (fr0) {
-            this._primeNativeGpuUploadIfNeeded(snapshot, curUx, p0, fr0, signal);
-            await yieldToJsEventLoop();
-          }
+    this._preloadTimelineSig = n, this._preloadAbort?.abort(), this._preloadAbort = new AbortController();
+    const i = this._preloadAbort.signal;
+    let r = 0,
+      s = 0;
+    for (const g of a) this._buildFetchParamsForUnix(t, g, {
+      logDiag: !1
+    }) ? r++ : s++;
+    if (y("preload.start", {
+      site: t.nexradSite,
+      product: t.nexradProduct,
+      dataSource: t.nexradDataSource,
+      tilt: t.nexradTilt,
+      times: a.length,
+      validFetchParams: r,
+      invalidFetchParams: s,
+      displayUnix: t.nexradTimestamp,
+      timelineSigTail: n.slice(-80)
+    }), r === 0) {
+      this._logListingDiag("preload.allFetchParamsInvalid", t, t.nexradTimestamp, {
+        times: a.length
+      });
+      return;
+    }
+    const l = t.nexradTimestamp != null && Number.isFinite(Number(t.nexradTimestamp)) ? Number(t.nexradTimestamp) : NaN,
+      o = new Set();
+    for (const g of a) {
+      const f = this._buildFetchParamsForUnix(t, g);
+      f && o.add(f.fetchKey);
+    }
+    const m = Number.isFinite(l) ? this._buildFetchParamsForUnix(t, l) : null;
+    m && o.add(m.fetchKey);
+    for (const g of this._frameCache.keys()) o.has(g) || this._frameCache.delete(g);
+    L(this.core.apiKey || ""), R(this.core.bundleId || ""), w(this.core.gridRequestSiteOrigin || I), $(this.core.nexradUserId || "sdk-user"), B(this.core.apiKey || "", this.core.bundleId || ""), W() && z("nexrad.authConfigured", H(this.core, {
+      phase: "NexradAndroidController.preload",
+      site: t.nexradSite,
+      product: t.nexradProduct
+    }));
+    const u = {
+        ...t
+      },
+      d = h(`preload.batch site=${t.nexradSite} times=${a.length}`);
+    let N = 0,
+      p = 0,
+      F = 0;
+    await (async () => {
+      const g = u.nexradTimestamp != null && Number.isFinite(Number(u.nexradTimestamp)) ? Number(u.nexradTimestamp) : NaN;
+      if (Number.isFinite(g)) {
+        const x = this._buildFetchParamsForUnix(u, g);
+        if (x) {
+          const S = this._frameCache.get(x.fetchKey);
+          S && (this._primeNativeGpuUploadIfNeeded(u, g, x, S, i), await M());
         }
       }
-      let cursor = 0;
-      const work = async () => {
-        while (cursor < times.length && !signal.aborted) {
-          const i = cursor++;
-          const unix = times[i];
-          const slot = nexradPerfSpan(`preload.slot idx=${i + 1}/${times.length} unix=${unix}`);
-          const p = this._buildFetchParamsForUnix(snapshot, unix);
-          if (!p || signal.aborted) {
-            slot.end({
-              outcome: 'noParamsOrAborted'
+      let f = 0;
+      const _ = async () => {
+        for (; f < a.length && !i.aborted;) {
+          const x = f++,
+            S = a[x],
+            v = h(`preload.slot idx=${x + 1}/${a.length} unix=${S}`),
+            b = this._buildFetchParamsForUnix(u, S);
+          if (!b || i.aborted) v.end({
+            outcome: "noParamsOrAborted"
+          });else if (this._frameCache.has(b.fetchKey)) {
+            F++;
+            const T = this._frameCache.get(b.fetchKey);
+            this._primeNativeGpuUploadIfNeeded(u, S, b, T, i), await M(), v.end({
+              outcome: "alreadyCached",
+              fetchKeyTail: b.fetchKey.slice(-64)
+            });
+          } else try {
+            const T = await this._fetchFrame(u, S, {
+              signal: i,
+              priority: "prefetch"
             });
-          } else if (this._frameCache.has(p.fetchKey)) {
-            preloadSkippedCached++;
-            const cachedFrame = this._frameCache.get(p.fetchKey);
-            this._primeNativeGpuUploadIfNeeded(snapshot, unix, p, cachedFrame, signal);
-            await yieldToJsEventLoop();
-            slot.end({
-              outcome: 'alreadyCached',
-              fetchKeyTail: p.fetchKey.slice(-64)
+            T && !i.aborted ? (this._frameCache.set(b.fetchKey, T), N++, this._primeNativeGpuUploadIfNeeded(u, S, b, T, i), await M(), v.end({
+              outcome: "cachedFrame",
+              fetchKeyTail: b.fetchKey.slice(-64),
+              cacheSizeAfter: this._frameCache.size
+            })) : v.end({
+              outcome: "noFrame",
+              aborted: i.aborted
+            });
+          } catch (T) {
+            p++, v.end({
+              outcome: "error",
+              message: T?.message || String(T)
             });
-          } else {
-            try {
-              const frame = await this._fetchFrame(snapshot, unix, {
-                signal,
-                priority: 'prefetch'
-              });
-              if (frame && !signal.aborted) {
-                this._frameCache.set(p.fetchKey, frame);
-                preloadCompleted++;
-                this._primeNativeGpuUploadIfNeeded(snapshot, unix, p, frame, signal);
-                await yieldToJsEventLoop();
-                slot.end({
-                  outcome: 'cachedFrame',
-                  fetchKeyTail: p.fetchKey.slice(-64),
-                  cacheSizeAfter: this._frameCache.size
-                });
-              } else {
-                slot.end({
-                  outcome: 'noFrame',
-                  aborted: signal.aborted
-                });
-              }
-            } catch (err) {
-              preloadFailed++;
-              slot.end({
-                outcome: 'error',
-                message: err?.message || String(err)
-              });
-            }
           }
-          await yieldToJsEventLoop();
+          await M();
         }
       };
-      await Promise.all(Array.from({
-        length: PRELOAD_CONCURRENCY
-      }, () => work()));
-
-      // Catch-up: any unix still missing a GPU slot (e.g. layer mounted mid-preload) gets one upload pass.
-      if (!signal.aborted) {
-        for (let i = 0; i < times.length && !signal.aborted; i++) {
-          const unix = times[i];
-          const p = this._buildFetchParamsForUnix(snapshot, unix);
-          if (!p) continue;
-          const frame = this._frameCache.get(p.fetchKey);
-          if (!frame) continue;
-          const syncKey = this._syncIdentity(snapshot, p, unix);
-          if (this._nativeGpuReadyKeys.has(syncKey)) continue;
-          this._primeNativeGpuUploadIfNeeded(snapshot, unix, p, frame, signal);
-          await yieldToJsEventLoop();
-        }
+      if (await Promise.all(Array.from({
+        length: be
+      }, () => _())), !i.aborted) for (let x = 0; x < a.length && !i.aborted; x++) {
+        const S = a[x],
+          v = this._buildFetchParamsForUnix(u, S);
+        if (!v) continue;
+        const b = this._frameCache.get(v.fetchKey);
+        if (!b) continue;
+        const T = this._syncIdentity(u, v, S);
+        this._nativeGpuReadyKeys.has(T) || (this._primeNativeGpuUploadIfNeeded(u, S, v, b, i), await M());
       }
-      preloadBatch.end({
-        outcome: signal.aborted ? 'aborted' : 'complete',
-        completed: preloadCompleted,
-        failed: preloadFailed,
-        skippedCached: preloadSkippedCached,
+      const C = {
+        outcome: i.aborted ? "aborted" : "complete",
+        completed: N,
+        failed: p,
+        skippedCached: F,
         finalCacheSize: this._frameCache.size,
         gpuReadyCount: this._nativeGpuReadyKeys.size
+      };
+      d.end(C), y("preload.done", C);
+    })();
+  }
+  async sync(e) {
+    const t = e.nexradTimestamp != null ? Number(e.nexradTimestamp) : NaN,
+      a = h(`sync.total site=${e.nexradSite} unix=${t} product=${e.nexradProduct} source=${e.nexradDataSource} tilt=${e.nexradTilt}`);
+    if (!e.isNexrad || !e.nexradSite) {
+      y("sync.skip", {
+        reason: "notNexradOrNoSite",
+        isNexrad: e.isNexrad,
+        site: e.nexradSite
+      }), this.destroy(), a.end({
+        outcome: "skippedNotNexradOrNoSite"
       });
-    };
-    void run();
-  }
-  async sync(state) {
-    const unixEarly = state.nexradTimestamp != null ? Number(state.nexradTimestamp) : NaN;
-    const syncTotal = nexradPerfSpan(`sync.total site=${state.nexradSite} unix=${unixEarly} product=${state.nexradProduct} source=${state.nexradDataSource} tilt=${state.nexradTilt}`);
-    if (!state.isNexrad || !state.nexradSite || state.nexradTimestamp == null) {
-      this.destroy();
-      syncTotal.end({
-        outcome: 'skippedNotNexradOrMissing'
+      return;
+    }
+    if (!q("sync")) {
+      y("sync.skip", {
+        reason: "missingArchiveBindings",
+        site: e.nexradSite
+      }), a.end({
+        outcome: "skippedMissingArchiveBindings"
       });
       return;
     }
-    if (!ensureRadarArchiveBindings('sync')) {
-      syncTotal.end({
-        outcome: 'skippedMissingArchiveBindings'
+    await this._ensureLevel2ListingReady(e), e = this._nexradStateWithCoreListing(e);
+    let n = e.nexradTimestamp != null ? Number(e.nexradTimestamp) : NaN;
+    if (!Number.isFinite(n) && this.core.state.nexradTimestamp != null && (n = Number(this.core.state.nexradTimestamp), e = {
+      ...e,
+      nexradTimestamp: n
+    }), !Number.isFinite(n) && Array.isArray(e.availableNexradTimestamps) && e.availableNexradTimestamps.length > 0 && (n = Number(e.availableNexradTimestamps[e.availableNexradTimestamps.length - 1]), e = {
+      ...e,
+      nexradTimestamp: n
+    }, this.core.state.nexradTimestamp == null && (this.core.state.nexradTimestamp = n, typeof this.core._emitStateChange == "function" && this.core._emitStateChange())), !Number.isFinite(n)) {
+      y("sync.skip", {
+        reason: "noTimestampYet",
+        site: e.nexradSite,
+        availableUnixCount: Array.isArray(e.availableNexradTimestamps) ? e.availableNexradTimestamps.length : 0
+      }), a.end({
+        outcome: "skippedNoTimestampYet"
       });
       return;
     }
-    const tAuth = nexradPerfSpan('sync.setArchiveAuth');
-    setNexradArchiveApiKey(this.core.apiKey || '');
-    setNexradArchiveBundleId(this.core.bundleId || '');
-    setNexradArchiveSiteOrigin(this.core.gridRequestSiteOrigin || 'https://localhost');
-    setNexradSitesFetchAuth(this.core.apiKey || '', this.core.bundleId || '');
-    tAuth.end({});
-    const unix = Number(state.nexradTimestamp);
-    const tParams = nexradPerfSpan('sync.buildFetchParams');
-    const p = this._buildFetchParamsForUnix(state, unix);
-    tParams.end({
-      ok: !!p
+    y("sync.start", {
+      site: e.nexradSite,
+      product: e.nexradProduct,
+      dataSource: e.nexradDataSource,
+      tilt: e.nexradTilt,
+      unix: e.nexradTimestamp,
+      nativeLayerReady: !!this._native()?.uploadNexradFrame
     });
-    if (!p) {
-      const ctx = this._resolveListingContext(state);
-      syncTotal.end({
-        outcome: 'noFetchParams'
+    const i = h("sync.setArchiveAuth");
+    L(this.core.apiKey || ""), R(this.core.bundleId || ""), w(this.core.gridRequestSiteOrigin || I), $(this.core.nexradUserId || "sdk-user"), B(this.core.apiKey || "", this.core.bundleId || ""), i.end({});
+    const r = h("sync.buildFetchParams"),
+      s = this._buildFetchParamsForUnix(e, n);
+    if (r.end({
+      ok: !!s
+    }), !s) {
+      this._logListingDiag("sync.noFetchParams", e, n), a.end({
+        outcome: "noFetchParams"
+      }), y("sync.done", {
+        outcome: "noFetchParams",
+        site: e.nexradSite,
+        unix: n
       });
       return;
     }
-    const tIdentity = nexradPerfSpan('sync.syncIdentity');
-    const syncKey = this._syncIdentity(state, p, unix);
-    tIdentity.end({
-      syncKeyTail: syncKey.slice(-96),
-      lastSyncKeyMatch: syncKey === this._lastSyncKey
+    const l = h("sync.syncIdentity"),
+      o = this._syncIdentity(e, s, n);
+    l.end({
+      syncKeyTail: o.slice(-96),
+      lastSyncKeyMatch: o === this._lastSyncKey
     });
-    const jsCachedForShortCircuit = this._frameCache.get(p.fetchKey);
-    if (syncKey === this._lastSyncKey && this._nativeFrameUploaded && jsCachedForShortCircuit) {
-      const tStyle = nexradPerfSpan('sync.shortCircuit_styleOnly');
-      this.applyStyleFromState(state);
-      tStyle.end({});
-      syncTotal.end({
-        outcome: 'styleOnlyShortCircuit'
+    const m = this._frameCache.get(s.fetchKey);
+    if (o === this._lastSyncKey && this._nativeFrameUploaded && m) {
+      const f = h("sync.shortCircuit_styleOnly");
+      this.applyStyleFromState(e), f.end({}), a.end({
+        outcome: "styleOnlyShortCircuit"
       });
       return;
     }
-    const tCacheLookup = nexradPerfSpan('sync.memoryCacheLookup');
-    const cached = this._frameCache.get(p.fetchKey);
-    tCacheLookup.end({
-      hit: !!cached,
+    const u = h("sync.memoryCacheLookup"),
+      d = this._frameCache.get(s.fetchKey);
+    u.end({
+      hit: !!d,
       cacheSize: this._frameCache.size,
-      fetchKeyTail: p.fetchKey.slice(-80)
+      fetchKeyTail: s.fetchKey.slice(-80)
     });
-    const tGpuTry = nexradPerfSpan('sync.tryGpuCacheActivate');
-    if (cached && this._nativeGpuReadyKeys.has(syncKey)) {
-      const n = this._native();
-      if (n?.activateNexradCachedFrame) {
-        const tAct = nexradPerfSpan('sync.dispatchActivateCachedFrame');
-        n.activateNexradCachedFrame(syncKey);
-        tAct.end({
-          keyLen: syncKey.length
+    const N = h("sync.tryGpuCacheActivate");
+    if (d && this._nativeGpuReadyKeys.has(o)) {
+      const f = this._native();
+      if (f?.activateNexradCachedFrame) {
+        const _ = h("sync.dispatchActivateCachedFrame");
+        f.activateNexradCachedFrame(o), _.end({
+          keyLen: o.length
         });
-        const tStyle = nexradPerfSpan('sync.applyStyleAfterGpuActivate');
-        this.applyStyleFromState(state);
-        tStyle.end({});
-        const meta = this._uploadMetaBySyncKey.get(syncKey);
-        if (meta) {
-          this._lastUploadMeta = {
-            valueScale: meta.valueScale,
-            valueOffset: meta.valueOffset
-          };
-        }
-        this._lastSyncKey = syncKey;
-        this._nativeFrameUploaded = true;
-        tGpuTry.end({
-          outcome: 'gpuCacheActivate',
+        const C = h("sync.applyStyleAfterGpuActivate");
+        this.applyStyleFromState(e), C.end({});
+        const x = this._uploadMetaBySyncKey.get(o);
+        x && (this._lastUploadMeta = {
+          valueScale: x.valueScale,
+          valueOffset: x.valueOffset
+        }), this._lastSyncKey = o, this._nativeFrameUploaded = !0, N.end({
+          outcome: "gpuCacheActivate",
           gpuReadySetSize: this._nativeGpuReadyKeys.size
-        });
-        syncTotal.end({
-          outcome: 'gpuCacheActivate'
+        }), a.end({
+          outcome: "gpuCacheActivate"
         });
         return;
       }
     }
-    tGpuTry.end({
-      outcome: 'noGpuActivate',
-      hasJsCachedFrame: !!cached,
-      gpuReadyForSyncKey: this._nativeGpuReadyKeys.has(syncKey),
+    if (N.end({
+      outcome: "noGpuActivate",
+      hasJsCachedFrame: !!d,
+      gpuReadyForSyncKey: this._nativeGpuReadyKeys.has(o),
       hasActivateMethod: !!this._native()?.activateNexradCachedFrame
-    });
-    if (cached) {
-      const tUpload = nexradPerfSpan('sync.uploadFromMemoryCache_toNative');
-      this._uploadFrameToNative(state, cached, p, unix);
-      tUpload.end({});
-      this._lastSyncKey = syncKey;
-      syncTotal.end({
-        outcome: 'memoryCacheHit'
+    }), d) {
+      const f = h("sync.uploadFromMemoryCache_toNative");
+      this._uploadFrameToNative(e, d, s, n), f.end({}), this._lastSyncKey = o, a.end({
+        outcome: "memoryCacheHit"
       });
       return;
     }
-    this._abort?.abort();
-    this._abort = new AbortController();
-    let frame;
+    this._abort?.abort(), this._abort = new AbortController();
+    let p;
     try {
-      frame = await this._fetchFrame(state, unix, {
+      p = await this._fetchFrame(e, n, {
         signal: this._abort.signal,
-        priority: 'display'
+        priority: "display"
       });
-    } catch (err) {
-      syncTotal.end({
-        outcome: 'fetchThrew',
-        message: err?.message || String(err)
+    } catch (f) {
+      const _ = f?.message || String(f);
+      a.end({
+        outcome: "fetchThrew",
+        message: _
+      }), y("sync.done", {
+        outcome: "fetchThrew",
+        site: e.nexradSite,
+        unix: n,
+        message: _
       });
       return;
     }
-    if (!frame || this._abort.signal.aborted) {
-      syncTotal.end({
-        outcome: 'fetchNoFrame',
+    if (!p || this._abort.signal.aborted) {
+      const f = {
+        outcome: "fetchNoFrame",
         aborted: this._abort.signal.aborted,
-        hadFrame: !!frame
+        hadFrame: !!p
+      };
+      a.end(f), y("sync.done", {
+        ...f,
+        site: e.nexradSite,
+        unix: n
       });
       return;
     }
-    const tPut = nexradPerfSpan('sync.frameCacheSet');
-    this._frameCache.set(p.fetchKey, frame);
-    tPut.end({
+    const F = h("sync.frameCacheSet");
+    this._frameCache.set(s.fetchKey, p), F.end({
       cacheSizeAfter: this._frameCache.size
     });
-    const tUploadFetched = nexradPerfSpan('sync.uploadFetchedFrame_toNative');
-    this._uploadFrameToNative(state, frame, p, unix);
-    tUploadFetched.end({});
-    this._lastSyncKey = syncKey;
-    syncTotal.end({
-      outcome: 'fetchedAndUploaded'
+    const g = h("sync.uploadFetchedFrame_toNative");
+    this._uploadFrameToNative(e, p, s, n), g.end({}), this._lastSyncKey = o, a.end({
+      outcome: "fetchedAndUploaded"
+    }), y("sync.done", {
+      outcome: "fetchedAndUploaded",
+      site: e.nexradSite,
+      unix: n,
+      nGates: p.nGates,
+      nRays: p.nRays,
+      nativeFrameUploaded: this._nativeFrameUploaded
     });
   }
-  getInspectPayload(lng, lat, state) {
-    if (!state?.isNexrad || !state.nexradSite || state.nexradTimestamp == null) {
-      return null;
-    }
-    if (state.visible === false || (state.opacity ?? 1) <= 0) {
-      return null;
-    }
-    const unix = Number(state.nexradTimestamp);
-    const p = this._buildFetchParamsForUnix(state, unix);
-    if (!p) {
-      return null;
-    }
-    const frame = this._frameCache.get(p.fetchKey);
-    if (!frame) {
-      return null;
-    }
-    const colormapFlat = state.colormap;
-    if (!colormapFlat || colormapFlat.length < 2) {
-      return null;
-    }
-    const rangeMin = colormapFlat[0];
-    const rangeMax = colormapFlat[colormapFlat.length - 2];
-    const radarVariable = (state.nexradProduct || 'REF').toUpperCase();
-    const radarSource = state.nexradDataSource === 'level3' ? 'level3' : 'level2';
-    const displayUnits = state.units && String(state.units).toLowerCase() !== 'none' ? state.units : isVelocityStyleRadarVar(radarVariable) ? 'm/s' : '';
-    const uploadOptsForReadout = mapboxFrameUploadOptionsForNexradState(state);
-    const gpuFrame = this._getPreparedReadoutFrame(frame, uploadOptsForReadout);
-    const sample = sampleNexradFrameAtLatLon(gpuFrame, lat, lng, {
-      smoothPolar: this._gateSmoothing
-    });
-    if (!sample) {
-      return null;
-    }
-    const valueMs = sample.value;
-    const isHydro = radarSource === 'level3' && nexradLevel3IsHydrometeorClassification(radarVariable);
-    let valueOut;
-    let unitOut = displayUnits || '';
-    if (isVelocityStyleRadarVar(radarVariable)) {
-      valueOut = velocityMsToDisplay(valueMs, displayUnits);
-    } else if (isHydro) {
-      const label = nexradHydrometeorLabelForClassIndex(valueMs);
-      if (label == null) {
-        return null;
-      }
-      valueOut = label;
-      unitOut = '';
-    } else {
-      valueOut = formatNexradInspectNumeric(valueMs, radarVariable);
-      const bu = state.colormapBaseUnit;
-      if (bu != null && String(bu).length > 0 && String(bu).toLowerCase() !== 'none') {
-        unitOut = bu;
-      }
-    }
-    let inRange;
-    if (isHydro) {
-      const idx = Math.round(Number(valueMs));
-      inRange = (rangeMin == null || idx >= rangeMin) && (rangeMax == null || idx <= rangeMax);
-    } else if (isVelocityStyleRadarVar(radarVariable)) {
-      inRange = (rangeMin == null || valueOut >= rangeMin) && (rangeMax == null || valueOut <= rangeMax);
+  getInspectPayload(e, t, a) {
+    if (!a?.isNexrad || !a.nexradSite || a.nexradTimestamp == null || a.visible === !1 || (a.opacity ?? 1) <= 0) return null;
+    const n = Number(a.nexradTimestamp),
+      i = this._buildFetchParamsForUnix(a, n);
+    if (!i) return null;
+    const r = this._frameCache.get(i.fetchKey);
+    if (!r) return null;
+    const s = a.colormap;
+    if (!s || s.length < 2) return null;
+    const l = s[0],
+      o = s[s.length - 2],
+      m = (a.nexradProduct || "REF").toUpperCase(),
+      u = this._nexradRadarSource(a) || "level3",
+      d = a.units && String(a.units).toLowerCase() !== "none" ? a.units : U(m) ? "m/s" : "",
+      N = V(a),
+      p = this._getPreparedReadoutFrame(r, N),
+      F = le(p, t, e, {
+        smoothPolar: this._gateSmoothing
+      });
+    if (!F) return null;
+    const g = F.value,
+      f = u === "level3" && fe(m);
+    let _,
+      C = d || "";
+    if (U(m)) _ = ve(g, d);else if (f) {
+      const K = xe(g);
+      if (K == null) return null;
+      _ = K, C = "";
     } else {
-      // Do not apply the colormap *lower* stop as a hard readout floor: weak echoes below the first
-      // legend tick can still be drawn (LUT / GL), and users expect a number there.
-      inRange = rangeMax == null || valueOut <= rangeMax;
-    }
-    if (!inRange) {
-      return null;
-    }
-    const tiltDeg = Number.isFinite(state.nexradTilt) ? state.nexradTilt : getDefaultRadarTilt(state.nexradSite);
-    const bhKm = beamHeightKm(sample.groundRangeKm, tiltDeg);
-    const metric = state.units === 'metric';
-    const beamHeightDisplay = metric ? bhKm : bhKm * 3.280839895013123;
-    const beamUnit = metric ? 'km' : 'kft';
-    const fldKey = state.variable;
+      _ = Se(g, m);
+      const K = a.colormapBaseUnit;
+      K != null && String(K).length > 0 && String(K).toLowerCase() !== "none" && (C = K);
+    }
+    let x;
+    if (f) {
+      const K = Math.round(Number(g));
+      x = (l == null || K >= l) && (o == null || K <= o);
+    } else U(m) ? x = (l == null || _ >= l) && (o == null || _ <= o) : x = o == null || _ <= o;
+    if (!x) return null;
+    const S = Number.isFinite(a.nexradTilt) ? a.nexradTilt : Q(a.nexradSite),
+      v = _e(F.groundRangeKm, S),
+      b = a.units === "metric",
+      T = b ? v : v * 3.280839895013123,
+      P = b ? "km" : "kft",
+      A = a.variable;
     return {
       lngLat: {
-        lng,
-        lat
+        lng: e,
+        lat: t
       },
       variable: {
-        code: fldKey,
-        name: this.core.getVariableDisplayName(fldKey)
+        code: A,
+        name: this.core.getVariableDisplayName(A)
       },
-      value: valueOut,
-      unit: unitOut,
-      beamHeight: Number.isFinite(beamHeightDisplay) && Number.isFinite(bhKm) ? {
-        value: beamHeightDisplay,
-        unit: beamUnit
+      value: _,
+      unit: C,
+      beamHeight: Number.isFinite(T) && Number.isFinite(v) ? {
+        value: T,
+        unit: P
       } : null
     };
   }