@aguacerowx/mapsgl 0.0.53 → 0.0.55

package/src/nexrad/radarArchiveCore.bundled.js

@@ -321,18 +321,18 @@ var require_buffer = __commonJS({
         throw new RangeError('The value "' + size + '" is invalid for option "size"');
       }
     }
-    function alloc(size, fill, encoding) {
+    function alloc(size, fill2, encoding) {
       assertSize(size);
       if (size <= 0) {
         return createBuffer(size);
       }
-      if (fill !== void 0) {
-        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+      if (fill2 !== void 0) {
+        return typeof encoding === "string" ? createBuffer(size).fill(fill2, encoding) : createBuffer(size).fill(fill2);
       }
       return createBuffer(size);
     }
-    Buffer3.alloc = function(size, fill, encoding) {
-      return alloc(size, fill, encoding);
+    Buffer3.alloc = function(size, fill2, encoding) {
+      return alloc(size, fill2, encoding);
     };
     function allocUnsafe(size) {
       assertSize(size);
@@ -1503,7 +1503,7 @@ var require_buffer = __commonJS({
       }
       return len;
     };
-    Buffer3.prototype.fill = function fill(val, start, end, encoding) {
+    Buffer3.prototype.fill = function fill2(val, start, end, encoding) {
       if (typeof val === "string") {
         if (typeof start === "string") {
           encoding = start;
@@ -1784,9 +1784,9 @@ var require_buffer = __commonJS({
       const alphabet = "0123456789abcdef";
       const table = new Array(256);
       for (let i = 0; i < 16; ++i) {
-        const i16 = i * 16;
+        const i162 = i * 16;
         for (let j = 0; j < 16; ++j) {
-          table[i16 + j] = alphabet[i] + alphabet[j];
+          table[i162 + j] = alphabet[i] + alphabet[j];
         }
       }
       return table;
@@ -2895,33 +2895,1903 @@ function applyLevel3StormRelativeToFrame(frame, stormSpeedMs, stormDirectionDeg)
 }
 
 // src/nexrad/nexradArchiveCache.ts
-var MAX_ARCHIVE_CACHE_ENTRIES = 5e3;
+var NEXRAD_ARCHIVE_LEVEL2_BASE_URL = "https://d3dc62msmxkrd7.cloudfront.net/level-2";
+var NEXRAD_ARCHIVE_LEVEL3_BASE_URL = "https://unidata-nexrad-level3.s3.amazonaws.com";
+var MAX_ARCHIVE_CACHE_ENTRIES = 400;
+var MAX_ARCHIVE_CACHE_BYTES = 180 * 1024 * 1024;
 var archiveCache = /* @__PURE__ */ new Map();
-function setArchiveCache(url, archive) {
-  archiveCache.delete(url);
-  archiveCache.set(url, archive);
-  while (archiveCache.size > MAX_ARCHIVE_CACHE_ENTRIES) {
+var pruneAllowlistObjectKeys = null;
+var pruneSupplementalObjectKeys = /* @__PURE__ */ new Set();
+function canInsertCacheKey(cacheKey, frame) {
+  if (frame == null) return true;
+  if (pruneAllowlistObjectKeys == null) return true;
+  const o = extractObjectKeyFromCacheKey(cacheKey);
+  if (o == null) return true;
+  if (pruneAllowlistObjectKeys.has(o)) return true;
+  if (pruneSupplementalObjectKeys.has(o)) return true;
+  return false;
+}
+function estimateFrameBytes(value) {
+  if (value == null) return 0;
+  const g = value.gateData;
+  const r = value.rayBoundariesDeg;
+  const a = value.azimuthsDeg;
+  return (g?.byteLength ?? 0) + (r?.byteLength ?? 0) + (a?.byteLength ?? 0);
+}
+var cacheBytesTotal = 0;
+var onArchiveCacheKeysRemoved = null;
+function emitArchiveCacheKeysRemoved(keys) {
+  if (keys.length === 0) return;
+  onArchiveCacheKeysRemoved?.(keys);
+}
+function recomputeCacheBytes() {
+  let n = 0;
+  for (const v of archiveCache.values()) {
+    n += estimateFrameBytes(v);
+  }
+  cacheBytesTotal = n;
+}
+function evictOldestWhileOverCap() {
+  const removed = [];
+  while (archiveCache.size > MAX_ARCHIVE_CACHE_ENTRIES || cacheBytesTotal > MAX_ARCHIVE_CACHE_BYTES) {
     const oldestKey = archiveCache.keys().next().value;
     if (!oldestKey) break;
+    const v = archiveCache.get(oldestKey);
     archiveCache.delete(oldestKey);
+    removed.push(oldestKey);
+    cacheBytesTotal -= estimateFrameBytes(v);
+    if (cacheBytesTotal < 0) recomputeCacheBytes();
+  }
+  emitArchiveCacheKeysRemoved(removed);
+}
+function setArchiveCache(cacheKey, archive) {
+  if (archive && !canInsertCacheKey(cacheKey, archive)) {
+    return;
+  }
+  const prev = archiveCache.get(cacheKey);
+  if (prev !== void 0) {
+    cacheBytesTotal -= estimateFrameBytes(prev);
+  }
+  archiveCache.delete(cacheKey);
+  archiveCache.set(cacheKey, archive);
+  if (archive) {
+    cacheBytesTotal += estimateFrameBytes(archive);
+  }
+  evictOldestWhileOverCap();
+}
+function extractObjectKeyFromCacheKey(cacheKey) {
+  const m = cacheKey.match(/:([A-Za-z0-9_]+):((?:level2|level3))(?:\|.*)?$/i);
+  if (!m || m.index == null || m.index < 1) return null;
+  const urlPart = cacheKey.slice(0, m.index);
+  return objectKeyFromArchiveUrlString(urlPart);
+}
+function objectKeyFromArchiveUrlString(url) {
+  for (const base of [NEXRAD_ARCHIVE_LEVEL2_BASE_URL, NEXRAD_ARCHIVE_LEVEL3_BASE_URL]) {
+    const prefix = base.endsWith("/") ? base : `${base}/`;
+    if (url.startsWith(prefix)) {
+      return url.slice(prefix.length);
+    }
+  }
+  if (url.startsWith("http")) {
+    try {
+      const u = new URL(url);
+      const p = u.pathname.replace(/^\/+/, "");
+      if (p.startsWith("level-2/")) return p.slice("level-2/".length);
+      return p || null;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// src/nexrad/nexradSitesDefault.json
+var nexradSitesDefault_default = {
+  description: "NEXRAD WSR-88D Level II sites and TDWR Terminal Doppler Weather Radar sites",
+  source: "NOAA Radar Operations Center / NWS",
+  generated: "2026-04-03",
+  counts: {
+    "WSR-88D": 204,
+    TDWR: 0,
+    total: 204
+  },
+  sites: [
+    {
+      id: "KABR",
+      name: "Aberdeen",
+      state: "SD",
+      lat: 45.4558,
+      lon: -98.4134,
+      type: "WSR-88D"
+    },
+    {
+      id: "KABX",
+      name: "Albuquerque",
+      state: "NM",
+      lat: 35.1498,
+      lon: -106.824,
+      type: "WSR-88D"
+    },
+    {
+      id: "KAKQ",
+      name: "Norfolk Rich",
+      state: "VA",
+      lat: 36.9841,
+      lon: -77.0074,
+      type: "WSR-88D"
+    },
+    {
+      id: "KAMA",
+      name: "Amarillo",
+      state: "TX",
+      lat: 35.2335,
+      lon: -101.7093,
+      type: "WSR-88D"
+    },
+    {
+      id: "KAMX",
+      name: "Miami",
+      state: "FL",
+      lat: 25.6111,
+      lon: -80.4127,
+      type: "WSR-88D"
+    },
+    {
+      id: "KAPX",
+      name: "Gaylord",
+      state: "MI",
+      lat: 44.9071,
+      lon: -84.7198,
+      type: "WSR-88D"
+    },
+    {
+      id: "KARX",
+      name: "La Crosse",
+      state: "WI",
+      lat: 43.8228,
+      lon: -91.1913,
+      type: "WSR-88D"
+    },
+    {
+      id: "KATX",
+      name: "Seattle",
+      state: "WA",
+      lat: 48.1945,
+      lon: -122.4958,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBBX",
+      name: "Beale Afb",
+      state: "CA",
+      lat: 39.4957,
+      lon: -121.6316,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBGM",
+      name: "Binghamton",
+      state: "NY",
+      lat: 42.1996,
+      lon: -75.9847,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBHX",
+      name: "Eureka",
+      state: "CA",
+      lat: 40.4986,
+      lon: -124.2921,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBIS",
+      name: "Bismarck",
+      state: "ND",
+      lat: 46.7709,
+      lon: -100.7606,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBLX",
+      name: "Billings",
+      state: "MT",
+      lat: 45.8538,
+      lon: -108.6068,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBMX",
+      name: "Birmingham",
+      state: "AL",
+      lat: 33.1722,
+      lon: -86.7698,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBOX",
+      name: "Boston",
+      state: "MA",
+      lat: 41.9559,
+      lon: -71.137,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBRO",
+      name: "Brownsville",
+      state: "TX",
+      lat: 25.916,
+      lon: -97.4189,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBUF",
+      name: "Buffalo",
+      state: "NY",
+      lat: 42.9488,
+      lon: -78.7368,
+      type: "WSR-88D"
+    },
+    {
+      id: "KBYX",
+      name: "Key W",
+      state: "FL",
+      lat: 24.5975,
+      lon: -81.7032,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCAE",
+      name: "Columbia",
+      state: "SC",
+      lat: 33.9488,
+      lon: -81.1183,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCBW",
+      name: "Houlton",
+      state: "ME",
+      lat: 46.0393,
+      lon: -67.8065,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCBX",
+      name: "Boise",
+      state: "ID",
+      lat: 43.4903,
+      lon: -116.236,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCCX",
+      name: "State College",
+      state: "PA",
+      lat: 40.9232,
+      lon: -78.0037,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCLE",
+      name: "Cleveland",
+      state: "OH",
+      lat: 41.4132,
+      lon: -81.8597,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCLX",
+      name: "Charleston",
+      state: "SC",
+      lat: 32.6555,
+      lon: -81.0423,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCRP",
+      name: "Corpus Christi",
+      state: "TX",
+      lat: 27.784,
+      lon: -97.5113,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCXX",
+      name: "Burlington",
+      state: "VT",
+      lat: 44.511,
+      lon: -73.1664,
+      type: "WSR-88D"
+    },
+    {
+      id: "KCYS",
+      name: "Cheyenne",
+      state: "WY",
+      lat: 41.1519,
+      lon: -104.8061,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDAX",
+      name: "Sacramento",
+      state: "CA",
+      lat: 38.5012,
+      lon: -121.6779,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDDC",
+      name: "Dodge City",
+      state: "KS",
+      lat: 37.7608,
+      lon: -99.9689,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDFX",
+      name: "Laughlin Afb",
+      state: "TX",
+      lat: 29.2731,
+      lon: -100.2803,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDGX",
+      name: "Jackson Brandon",
+      state: "MS",
+      lat: 32.2798,
+      lon: -89.9845,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDIX",
+      name: "Phila",
+      state: "NJ",
+      lat: 39.9471,
+      lon: -74.4108,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDLH",
+      name: "Duluth",
+      state: "MN",
+      lat: 46.8369,
+      lon: -92.2098,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDMX",
+      name: "Des Moines",
+      state: "IA",
+      lat: 41.7312,
+      lon: -93.7229,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDOX",
+      name: "Dover Afb",
+      state: "DE",
+      lat: 38.8258,
+      lon: -75.4401,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDTX",
+      name: "Detroit",
+      state: "MI",
+      lat: 42.7,
+      lon: -83.4718,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDVN",
+      name: "Davenport",
+      state: "IA",
+      lat: 41.6116,
+      lon: -90.5808,
+      type: "WSR-88D"
+    },
+    {
+      id: "KDYX",
+      name: "Dyess Afb",
+      state: "TX",
+      lat: 32.5385,
+      lon: -99.2543,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEAX",
+      name: "Kansas City",
+      state: "MO",
+      lat: 38.8102,
+      lon: -94.2644,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEMX",
+      name: "Tucson",
+      state: "AZ",
+      lat: 31.8936,
+      lon: -110.6303,
+      type: "WSR-88D"
+    },
+    {
+      id: "KENX",
+      name: "Albany",
+      state: "NY",
+      lat: 42.5865,
+      lon: -74.0639,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEOX",
+      name: "Ft Rucker",
+      state: "AL",
+      lat: 31.4606,
+      lon: -85.4594,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEPZ",
+      name: "El Paso",
+      state: "NM",
+      lat: 31.8731,
+      lon: -106.698,
+      type: "WSR-88D"
+    },
+    {
+      id: "KESX",
+      name: "Las Vegas",
+      state: "NV",
+      lat: 35.7013,
+      lon: -114.8915,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEVX",
+      name: "Eglin Afb",
+      state: "FL",
+      lat: 30.565,
+      lon: -85.9216,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEWX",
+      name: "Austin San Antonio",
+      state: "TX",
+      lat: 29.7041,
+      lon: -98.0285,
+      type: "WSR-88D"
+    },
+    {
+      id: "KEYX",
+      name: "Edwards",
+      state: "CA",
+      lat: 35.0977,
+      lon: -117.561,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFCX",
+      name: "Roanoke",
+      state: "VA",
+      lat: 37.0244,
+      lon: -80.274,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFDR",
+      name: "Altus Afb",
+      state: "OK",
+      lat: 34.3622,
+      lon: -98.9767,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFDX",
+      name: "Cannon Afb",
+      state: "NM",
+      lat: 34.6341,
+      lon: -103.6189,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFFC",
+      name: "Atlanta",
+      state: "GA",
+      lat: 33.3635,
+      lon: -84.5659,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFSD",
+      name: "Sioux Falls",
+      state: "SD",
+      lat: 43.5877,
+      lon: -96.7294,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFSX",
+      name: "Flagstaff",
+      state: "AZ",
+      lat: 34.5743,
+      lon: -111.1984,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFTG",
+      name: "Denver Front Range Ap",
+      state: "CO",
+      lat: 39.7866,
+      lon: -104.5459,
+      type: "WSR-88D"
+    },
+    {
+      id: "KFWS",
+      name: "Dallas",
+      state: "TX",
+      lat: 32.573,
+      lon: -97.3032,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGGW",
+      name: "Glasgow",
+      state: "MT",
+      lat: 48.2065,
+      lon: -106.6249,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGJX",
+      name: "Grand Junction",
+      state: "CO",
+      lat: 39.0622,
+      lon: -108.2138,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGLD",
+      name: "Goodland",
+      state: "KS",
+      lat: 39.3669,
+      lon: -101.7004,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGRB",
+      name: "Green Bay",
+      state: "WI",
+      lat: 44.4986,
+      lon: -88.1113,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGRK",
+      name: "Ft Hood",
+      state: "TX",
+      lat: 30.7218,
+      lon: -97.383,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGRR",
+      name: "Grand Rapids",
+      state: "MI",
+      lat: 42.8939,
+      lon: -85.5449,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGSP",
+      name: "Greer",
+      state: "SC",
+      lat: 34.8833,
+      lon: -82.22,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGWX",
+      name: "Columbus Afb",
+      state: "MS",
+      lat: 33.8969,
+      lon: -88.3293,
+      type: "WSR-88D"
+    },
+    {
+      id: "KGYX",
+      name: "Portland",
+      state: "ME",
+      lat: 43.8913,
+      lon: -70.2566,
+      type: "WSR-88D"
+    },
+    {
+      id: "KHDC",
+      name: "Hammond Muni Ap",
+      state: "LA",
+      lat: 30.5193,
+      lon: -90.4074,
+      type: "WSR-88D"
+    },
+    {
+      id: "KHDX",
+      name: "Holloman Afb",
+      state: "NM",
+      lat: 33.0769,
+      lon: -106.1201,
+      type: "WSR-88D"
+    },
+    {
+      id: "KHGX",
+      name: "Houston",
+      state: "TX",
+      lat: 29.472,
+      lon: -95.0788,
+      type: "WSR-88D"
+    },
+    {
+      id: "KHNX",
+      name: "San Joaquin Valley",
+      state: "CA",
+      lat: 36.3142,
+      lon: -119.6322,
+      type: "WSR-88D"
+    },
+    {
+      id: "KHPX",
+      name: "Ft Campbell",
+      state: "KY",
+      lat: 36.737,
+      lon: -87.2856,
+      type: "WSR-88D"
+    },
+    {
+      id: "KHTX",
+      name: "Huntsville",
+      state: "AL",
+      lat: 34.9306,
+      lon: -86.0835,
+      type: "WSR-88D"
+    },
+    {
+      id: "KICT",
+      name: "Wichita",
+      state: "KS",
+      lat: 37.6546,
+      lon: -97.4431,
+      type: "WSR-88D"
+    },
+    {
+      id: "KICX",
+      name: "Cedar City",
+      state: "UT",
+      lat: 37.591,
+      lon: -112.8623,
+      type: "WSR-88D"
+    },
+    {
+      id: "KILN",
+      name: "Cincinnati",
+      state: "OH",
+      lat: 39.4202,
+      lon: -83.8216,
+      type: "WSR-88D"
+    },
+    {
+      id: "KILX",
+      name: "Lincoln",
+      state: "IL",
+      lat: 40.1505,
+      lon: -89.3368,
+      type: "WSR-88D"
+    },
+    {
+      id: "KIND",
+      name: "Indianapolis",
+      state: "IN",
+      lat: 39.7075,
+      lon: -86.2804,
+      type: "WSR-88D"
+    },
+    {
+      id: "KINX",
+      name: "Tulsa",
+      state: "OK",
+      lat: 36.1751,
+      lon: -95.5642,
+      type: "WSR-88D"
+    },
+    {
+      id: "KIWA",
+      name: "Phoenix",
+      state: "AZ",
+      lat: 33.2893,
+      lon: -111.6699,
+      type: "WSR-88D"
+    },
+    {
+      id: "KIWX",
+      name: "Ft Wayne",
+      state: "IN",
+      lat: 41.3586,
+      lon: -85.7,
+      type: "WSR-88D"
+    },
+    {
+      id: "KJAX",
+      name: "Jacksonville",
+      state: "FL",
+      lat: 30.4846,
+      lon: -81.7019,
+      type: "WSR-88D"
+    },
+    {
+      id: "KJGX",
+      name: "Robins Afb",
+      state: "GA",
+      lat: 32.6756,
+      lon: -83.3509,
+      type: "WSR-88D"
+    },
+    {
+      id: "KJKL",
+      name: "Jackson",
+      state: "KY",
+      lat: 37.5908,
+      lon: -83.3131,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLBB",
+      name: "Lubbock",
+      state: "TX",
+      lat: 33.6541,
+      lon: -101.8141,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLCH",
+      name: "Lake Charles",
+      state: "LA",
+      lat: 30.1253,
+      lon: -93.2158,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLGX",
+      name: "Langley Hill Nw Washin",
+      state: "WA",
+      lat: 47.1169,
+      lon: -124.1066,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLNX",
+      name: "N Platte",
+      state: "NE",
+      lat: 41.9579,
+      lon: -100.5763,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLOT",
+      name: "Chicago",
+      state: "IL",
+      lat: 41.6044,
+      lon: -88.0845,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLRX",
+      name: "Elko",
+      state: "NV",
+      lat: 40.7397,
+      lon: -116.8027,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLSX",
+      name: "St Louis",
+      state: "MO",
+      lat: 38.6987,
+      lon: -90.6829,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLTX",
+      name: "Wilmington",
+      state: "NC",
+      lat: 33.9892,
+      lon: -78.4291,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLVX",
+      name: "Louisville",
+      state: "KY",
+      lat: 37.9753,
+      lon: -85.9438,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLWX",
+      name: "Sterling",
+      state: "VA",
+      lat: 38.9763,
+      lon: -77.4876,
+      type: "WSR-88D"
+    },
+    {
+      id: "KLZK",
+      name: "Little Rock",
+      state: "AR",
+      lat: 34.8365,
+      lon: -92.2622,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMAF",
+      name: "Midland Odessa",
+      state: "TX",
+      lat: 31.9434,
+      lon: -102.1892,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMAX",
+      name: "Medford",
+      state: "OR",
+      lat: 42.0811,
+      lon: -122.7174,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMBX",
+      name: "Minot Afb",
+      state: "ND",
+      lat: 48.393,
+      lon: -100.8645,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMHX",
+      name: "Morehead City",
+      state: "NC",
+      lat: 34.7759,
+      lon: -76.8762,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMKX",
+      name: "Milwaukee",
+      state: "WI",
+      lat: 42.9678,
+      lon: -88.5506,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMLB",
+      name: "Melbourne",
+      state: "FL",
+      lat: 28.1132,
+      lon: -80.6542,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMOB",
+      name: "Mobile",
+      state: "AL",
+      lat: 30.6795,
+      lon: -88.2399,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMPX",
+      name: "Minneapolis",
+      state: "MN",
+      lat: 44.8488,
+      lon: -93.5655,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMQT",
+      name: "Marquette",
+      state: "MI",
+      lat: 46.5311,
+      lon: -87.5485,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMRX",
+      name: "Knoxville",
+      state: "TN",
+      lat: 36.1685,
+      lon: -83.4018,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMSX",
+      name: "Missoula",
+      state: "MT",
+      lat: 47.041,
+      lon: -113.9862,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMTX",
+      name: "Salt Lake City",
+      state: "UT",
+      lat: 41.2627,
+      lon: -112.4477,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMUX",
+      name: "San Francisco",
+      state: "CA",
+      lat: 37.1551,
+      lon: -121.8985,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMVX",
+      name: "Grand Forks",
+      state: "ND",
+      lat: 47.5279,
+      lon: -97.3255,
+      type: "WSR-88D"
+    },
+    {
+      id: "KMXX",
+      name: "Maxwell Afb",
+      state: "AL",
+      lat: 32.5366,
+      lon: -85.7897,
+      type: "WSR-88D"
+    },
+    {
+      id: "KNKX",
+      name: "San Diego",
+      state: "CA",
+      lat: 32.919,
+      lon: -117.0419,
+      type: "WSR-88D"
+    },
+    {
+      id: "KNQA",
+      name: "Memphis",
+      state: "TN",
+      lat: 35.3448,
+      lon: -89.8734,
+      type: "WSR-88D"
+    },
+    {
+      id: "KOAX",
+      name: "Omaha",
+      state: "NE",
+      lat: 41.3202,
+      lon: -96.3668,
+      type: "WSR-88D"
+    },
+    {
+      id: "KOHX",
+      name: "Nashville",
+      state: "TN",
+      lat: 36.2472,
+      lon: -86.5625,
+      type: "WSR-88D"
+    },
+    {
+      id: "KOKX",
+      name: "Nyc",
+      state: "NY",
+      lat: 40.8656,
+      lon: -72.8639,
+      type: "WSR-88D"
+    },
+    {
+      id: "KOTX",
+      name: "Spokane",
+      state: "WA",
+      lat: 47.6804,
+      lon: -117.6268,
+      type: "WSR-88D"
+    },
+    {
+      id: "KPAH",
+      name: "Paducah",
+      state: "KY",
+      lat: 37.0684,
+      lon: -88.7721,
+      type: "WSR-88D"
+    },
+    {
+      id: "KPBZ",
+      name: "Pittsburgh",
+      state: "PA",
+      lat: 40.5316,
+      lon: -80.218,
+      type: "WSR-88D"
+    },
+    {
+      id: "KPDT",
+      name: "Pendleton",
+      state: "OR",
+      lat: 45.6906,
+      lon: -118.8529,
+      type: "WSR-88D"
+    },
+    {
+      id: "KPOE",
+      name: "Ft Polk",
+      state: "LA",
+      lat: 31.1557,
+      lon: -92.9761,
+      type: "WSR-88D"
+    },
+    {
+      id: "KPUX",
+      name: "Pueblo",
+      state: "CO",
+      lat: 38.4596,
+      lon: -104.1813,
+      type: "WSR-88D"
+    },
+    {
+      id: "KRAX",
+      name: "Raleigh Durham",
+      state: "NC",
+      lat: 35.6655,
+      lon: -78.4898,
+      type: "WSR-88D"
+    },
+    {
+      id: "KRGX",
+      name: "Reno",
+      state: "NV",
+      lat: 39.7541,
+      lon: -119.462,
+      type: "WSR-88D"
+    },
+    {
+      id: "KRIW",
+      name: "Riverton",
+      state: "WY",
+      lat: 43.0661,
+      lon: -108.4773,
+      type: "WSR-88D"
+    },
+    {
+      id: "KRLX",
+      name: "Charleston",
+      state: "WV",
+      lat: 38.3111,
+      lon: -81.7229,
+      type: "WSR-88D"
+    },
+    {
+      id: "KRTX",
+      name: "Portland",
+      state: "OR",
+      lat: 45.715,
+      lon: -122.9649,
+      type: "WSR-88D"
+    },
+    {
+      id: "KSFX",
+      name: "Pocatello",
+      state: "ID",
+      lat: 43.1056,
+      lon: -112.6861,
+      type: "WSR-88D"
+    },
+    {
+      id: "KSGF",
+      name: "Springfield",
+      state: "MO",
+      lat: 37.2352,
+      lon: -93.4004,
+      type: "WSR-88D"
+    },
+    {
+      id: "KSHV",
+      name: "Shreveport",
+      state: "LA",
+      lat: 32.4508,
+      lon: -93.8413,
+      type: "WSR-88D"
+    },
+    {
+      id: "KSJT",
+      name: "San Angelo",
+      state: "TX",
+      lat: 31.3713,
+      lon: -100.4925,
+      type: "WSR-88D"
+    },
+    {
+      id: "KSOX",
+      name: "Santa Ana Mountains",
+      state: "CA",
+      lat: 33.8177,
+      lon: -117.636,
+      type: "WSR-88D"
+    },
+    {
+      id: "KSRX",
+      name: "Ft Smith",
+      state: "AR",
+      lat: 35.2904,
+      lon: -94.362,
+      type: "WSR-88D"
+    },
+    {
+      id: "KTBW",
+      name: "Tampa",
+      state: "FL",
+      lat: 27.7055,
+      lon: -82.4018,
+      type: "WSR-88D"
+    },
+    {
+      id: "KTFX",
+      name: "Great Falls",
+      state: "MT",
+      lat: 47.4597,
+      lon: -111.3854,
+      type: "WSR-88D"
+    },
+    {
+      id: "KTLH",
+      name: "Tallahassee",
+      state: "FL",
+      lat: 30.3976,
+      lon: -84.3289,
+      type: "WSR-88D"
+    },
+    {
+      id: "KTLX",
+      name: "Oklahoma City",
+      state: "OK",
+      lat: 35.3334,
+      lon: -97.2778,
+      type: "WSR-88D"
+    },
+    {
+      id: "KTWX",
+      name: "Topeka",
+      state: "KS",
+      lat: 38.997,
+      lon: -96.2326,
+      type: "WSR-88D"
+    },
+    {
+      id: "KTYX",
+      name: "Ft Drum",
+      state: "NY",
+      lat: 43.7557,
+      lon: -75.6798,
+      type: "WSR-88D"
+    },
+    {
+      id: "KUDX",
+      name: "Rapid City",
+      state: "SD",
+      lat: 44.1249,
+      lon: -102.8299,
+      type: "WSR-88D"
+    },
+    {
+      id: "KUEX",
+      name: "Hastings",
+      state: "NE",
+      lat: 40.3209,
+      lon: -98.442,
+      type: "WSR-88D"
+    },
+    {
+      id: "KVAX",
+      name: "Moody Afb",
+      state: "GA",
+      lat: 30.8903,
+      lon: -83.0017,
+      type: "WSR-88D"
+    },
+    {
+      id: "KVBX",
+      name: "Vandenberg Afb",
+      state: "CA",
+      lat: 34.8383,
+      lon: -120.3979,
+      type: "WSR-88D"
+    },
+    {
+      id: "KVNX",
+      name: "Vance Afb",
+      state: "OK",
+      lat: 36.7406,
+      lon: -98.1277,
+      type: "WSR-88D"
+    },
+    {
+      id: "KVTX",
+      name: "Los Angeles",
+      state: "CA",
+      lat: 34.4117,
+      lon: -119.1796,
+      type: "WSR-88D"
+    },
+    {
+      id: "KVWX",
+      name: "Evansville",
+      state: "IN",
+      lat: 38.2604,
+      lon: -87.7247,
+      type: "WSR-88D"
+    },
+    {
+      id: "KYUX",
+      name: "Yuma",
+      state: "AZ",
+      lat: 32.4953,
+      lon: -114.6567,
+      type: "WSR-88D"
+    },
+    {
+      id: "PABC",
+      name: "Bethel Faa",
+      state: "AK",
+      lat: 60.7919,
+      lon: -161.8764,
+      type: "TDWR"
+    },
+    {
+      id: "PACG",
+      name: "Sitka",
+      state: "AK",
+      lat: 56.8526,
+      lon: -135.5292,
+      type: "TDWR"
+    },
+    {
+      id: "PAEC",
+      name: "Nome",
+      state: "AK",
+      lat: 64.5115,
+      lon: -165.2954,
+      type: "TDWR"
+    },
+    {
+      id: "PAHG",
+      name: "Anchorage",
+      state: "AK",
+      lat: 60.7258,
+      lon: -151.3515,
+      type: "TDWR"
+    },
+    {
+      id: "PAKC",
+      name: "King Salmon",
+      state: "AK",
+      lat: 58.6794,
+      lon: -156.6298,
+      type: "TDWR"
+    },
+    {
+      id: "PAPD",
+      name: "Fairbanks",
+      state: "AK",
+      lat: 65.0351,
+      lon: -147.5017,
+      type: "TDWR"
+    },
+    {
+      id: "PGUA",
+      name: "Andersen Afb Agana",
+      state: "GU",
+      lat: 13.4559,
+      lon: 144.8111,
+      type: "TDWR"
+    },
+    {
+      id: "PHKI",
+      name: "S Kauai",
+      state: "HI",
+      lat: 21.894,
+      lon: -159.5525,
+      type: "TDWR"
+    },
+    {
+      id: "PHKM",
+      name: "Kamuela",
+      state: "HI",
+      lat: 20.1253,
+      lon: -155.7777,
+      type: "TDWR"
+    },
+    {
+      id: "PHMO",
+      name: "Molokai",
+      state: "HI",
+      lat: 21.1328,
+      lon: -157.1802,
+      type: "TDWR"
+    },
+    {
+      id: "PHWA",
+      name: "S Shore",
+      state: "HI",
+      lat: 19.095,
+      lon: -155.569,
+      type: "TDWR"
+    },
+    {
+      id: "RKJK",
+      name: "Kunsan",
+      state: "",
+      lat: 35.9242,
+      lon: 126.6221,
+      type: "TDWR"
+    },
+    {
+      id: "RKSG",
+      name: "Camp Humphreys",
+      state: "",
+      lat: 37.2076,
+      lon: 127.2859,
+      type: "TDWR"
+    },
+    {
+      id: "RODN",
+      name: "Kadena",
+      state: "",
+      lat: 26.3077,
+      lon: 127.9035,
+      type: "TDWR"
+    },
+    {
+      id: "TADW",
+      name: "Andrews Afb",
+      state: "MD",
+      lat: 38.6954,
+      lon: -76.845,
+      type: "TDWR"
+    },
+    {
+      id: "TATL",
+      name: "Atlanta",
+      state: "GA",
+      lat: 33.6466,
+      lon: -84.2621,
+      type: "TDWR"
+    },
+    {
+      id: "TBNA",
+      name: "Nashville",
+      state: "TN",
+      lat: 35.9796,
+      lon: -86.6617,
+      type: "TDWR"
+    },
+    {
+      id: "TBOS",
+      name: "Boston",
+      state: "MA",
+      lat: 42.1583,
+      lon: -70.9334,
+      type: "TDWR"
+    },
+    {
+      id: "TBWI",
+      name: "Baltimore Washington",
+      state: "MD",
+      lat: 39.0896,
+      lon: -76.6302,
+      type: "TDWR"
+    },
+    {
+      id: "TCLT",
+      name: "Charlotte",
+      state: "NC",
+      lat: 35.3373,
+      lon: -80.885,
+      type: "TDWR"
+    },
+    {
+      id: "TCMH",
+      name: "Columbus",
+      state: "OH",
+      lat: 40.0056,
+      lon: -82.7151,
+      type: "TDWR"
+    },
+    {
+      id: "TCVG",
+      name: "Covington",
+      state: "KY",
+      lat: 38.8981,
+      lon: -84.5799,
+      type: "TDWR"
+    },
+    {
+      id: "TDAL",
+      name: "Dallas Love Fld",
+      state: "TX",
+      lat: 32.9258,
+      lon: -96.9683,
+      type: "TDWR"
+    },
+    {
+      id: "TDAY",
+      name: "Dayton",
+      state: "OH",
+      lat: 40.0221,
+      lon: -84.1231,
+      type: "TDWR"
+    },
+    {
+      id: "TDCA",
+      name: "Washington Natl",
+      state: "MD",
+      lat: 38.759,
+      lon: -76.9617,
+      type: "TDWR"
+    },
+    {
+      id: "TDEN",
+      name: "Denver",
+      state: "CO",
+      lat: 39.7275,
+      lon: -104.5265,
+      type: "TDWR"
+    },
+    {
+      id: "TDFW",
+      name: "Dallas Ft Worth",
+      state: "TX",
+      lat: 33.0648,
+      lon: -96.9181,
+      type: "TDWR"
+    },
+    {
+      id: "TDTW",
+      name: "Detroit",
+      state: "MI",
+      lat: 42.1113,
+      lon: -83.515,
+      type: "TDWR"
+    },
+    {
+      id: "TEWR",
+      name: "Newark",
+      state: "NJ",
+      lat: 40.5936,
+      lon: -74.2703,
+      type: "TDWR"
+    },
+    {
+      id: "TFLL",
+      name: "Ft Lauderdale",
+      state: "FL",
+      lat: 26.1432,
+      lon: -80.344,
+      type: "TDWR"
+    },
+    {
+      id: "THOU",
+      name: "Houston Hobby",
+      state: "TX",
+      lat: 29.5163,
+      lon: -95.2416,
+      type: "TDWR"
+    },
+    {
+      id: "TIAD",
+      name: "Washington Dulles",
+      state: "VA",
+      lat: 39.0838,
+      lon: -77.5294,
+      type: "TDWR"
+    },
+    {
+      id: "TIAH",
+      name: "Houston Intl",
+      state: "TX",
+      lat: 30.0649,
+      lon: -95.5671,
+      type: "TDWR"
+    },
+    {
+      id: "TICH",
+      name: "Wichita",
+      state: "KS",
+      lat: 37.5071,
+      lon: -97.437,
+      type: "TDWR"
+    },
+    {
+      id: "TIDS",
+      name: "Indianapolis",
+      state: "IN",
+      lat: 39.6372,
+      lon: -86.4355,
+      type: "TDWR"
+    },
+    {
+      id: "TJFK",
+      name: "Nyc Jfk",
+      state: "NY",
+      lat: 40.5889,
+      lon: -73.8803,
+      type: "TDWR"
+    },
+    {
+      id: "TJUA",
+      name: "San Juan",
+      state: "PR",
+      lat: 18.1156,
+      lon: -66.0782,
+      type: "TDWR"
+    },
+    {
+      id: "TLAS",
+      name: "Las Vegas",
+      state: "NV",
+      lat: 36.1436,
+      lon: -115.0072,
+      type: "TDWR"
+    },
+    {
+      id: "TLVE",
+      name: "Cleveland",
+      state: "OH",
+      lat: 41.2898,
+      lon: -82.0076,
+      type: "TDWR"
+    },
+    {
+      id: "TMCI",
+      name: "Kansas City",
+      state: "MO",
+      lat: 39.4985,
+      lon: -94.742,
+      type: "TDWR"
+    },
+    {
+      id: "TMCO",
+      name: "Orlando Intl",
+      state: "FL",
+      lat: 28.3437,
+      lon: -81.3258,
+      type: "TDWR"
+    },
+    {
+      id: "TMDW",
+      name: "Chicago Midway",
+      state: "IL",
+      lat: 41.6514,
+      lon: -87.7296,
+      type: "TDWR"
+    },
+    {
+      id: "TMEM",
+      name: "Memphis",
+      state: "MS",
+      lat: 34.8958,
+      lon: -89.9927,
+      type: "TDWR"
+    },
+    {
+      id: "TMIA",
+      name: "Miami",
+      state: "FL",
+      lat: 25.7575,
+      lon: -80.4912,
+      type: "TDWR"
+    },
+    {
+      id: "TMKE",
+      name: "Milwaukee",
+      state: "WI",
+      lat: 42.8196,
+      lon: -88.0464,
+      type: "TDWR"
+    },
+    {
+      id: "TMSP",
+      name: "Minneapolis",
+      state: "MN",
+      lat: 44.8714,
+      lon: -92.9328,
+      type: "TDWR"
+    },
+    {
+      id: "TMSY",
+      name: "New Orleans",
+      state: "LA",
+      lat: 30.0216,
+      lon: -90.4032,
+      type: "TDWR"
+    },
+    {
+      id: "TOKC",
+      name: "Norman Wfo",
+      state: "OK",
+      lat: 35.2761,
+      lon: -97.5099,
+      type: "TDWR"
+    },
+    {
+      id: "TORD",
+      name: "Chicago Ohare",
+      state: "IL",
+      lat: 41.7971,
+      lon: -87.8583,
+      type: "TDWR"
+    },
+    {
+      id: "TPBI",
+      name: "W Palm Beach",
+      state: "FL",
+      lat: 26.6879,
+      lon: -80.2732,
+      type: "TDWR"
+    },
+    {
+      id: "TPHL",
+      name: "Phila",
+      state: "NJ",
+      lat: 39.9492,
+      lon: -75.07,
+      type: "TDWR"
+    },
+    {
+      id: "TPHX",
+      name: "Phoenix",
+      state: "AZ",
+      lat: 33.4205,
+      lon: -112.1629,
+      type: "TDWR"
+    },
+    {
+      id: "TPIT",
+      name: "Pittsburgh",
+      state: "PA",
+      lat: 40.5013,
+      lon: -80.4861,
+      type: "TDWR"
+    },
+    {
+      id: "TRDU",
+      name: "Raleigh",
+      state: "NC",
+      lat: 36.0021,
+      lon: -78.6973,
+      type: "TDWR"
+    },
+    {
+      id: "TSDF",
+      name: "Louisville",
+      state: "KY",
+      lat: 38.0459,
+      lon: -85.6105,
+      type: "TDWR"
+    },
+    {
+      id: "TSJU",
+      name: "San Juan",
+      state: "PR",
+      lat: 18.474,
+      lon: -66.1795,
+      type: "TDWR"
+    },
+    {
+      id: "TSLC",
+      name: "Salt Lake City",
+      state: "UT",
+      lat: 40.9673,
+      lon: -111.9298,
+      type: "TDWR"
+    },
+    {
+      id: "TSTL",
+      name: "St Louis",
+      state: "MO",
+      lat: 38.8054,
+      lon: -90.489,
+      type: "TDWR"
+    },
+    {
+      id: "TTPA",
+      name: "Tampa",
+      state: "FL",
+      lat: 27.8595,
+      lon: -82.5178,
+      type: "TDWR"
+    },
+    {
+      id: "TTUL",
+      name: "Tulsa",
+      state: "OK",
+      lat: 36.0706,
+      lon: -95.8263,
+      type: "TDWR"
+    },
+    {
+      id: "KCRI",
+      name: "Norman Testbed",
+      state: "OK",
+      lat: 35.238,
+      lon: -97.46,
+      type: "TDWR"
+    },
+    {
+      id: "FWLX",
+      name: "WLX X-Band",
+      state: "TN",
+      lat: 35.254,
+      lon: -87.325,
+      type: "TDWR"
+    },
+    {
+      id: "FUSA",
+      name: "FUSA/Denton",
+      state: "MD",
+      lat: 38.86949,
+      lon: -75.81616,
+      type: "TDWR"
+    },
+    {
+      id: "GAWX",
+      name: "GAWX/Lawrenceville",
+      state: "GA",
+      lat: 33.98047,
+      lon: -84.00345,
+      type: "TDWR"
+    },
+    {
+      id: "WILU",
+      name: "Western Illinois University (WIU)",
+      state: "IL",
+      lat: 40.465,
+      lon: -90.685,
+      type: "TDWR"
+    },
+    {
+      id: "KULM",
+      name: "Monroe/ULM",
+      state: "LA",
+      lat: 32.529,
+      lon: -92.012,
+      type: "TDWR"
+    },
+    {
+      id: "MZZU",
+      name: "Columbia/Mizzou",
+      state: "MO",
+      lat: 38.906,
+      lon: -92.269,
+      type: "TDWR"
+    },
+    {
+      id: "OP5R",
+      name: "Fort Greely",
+      state: "AK",
+      lat: 63.922,
+      lon: -145.833,
+      type: "TDWR"
+    }
+  ]
+};
+
+// src/nexrad/nexradArchiveDiag.ts
+function redactApiKeyFromUrl(u) {
+  return u.replace(/([?&])apiKey=[^&]*/gi, "$1apiKey=(redacted)");
+}
+function isReactNative() {
+  const nav = globalThis.navigator;
+  return nav?.product === "ReactNative";
+}
+function nexradArchiveDiag(phase, detail) {
+  if (!isReactNative()) return;
+  if (detail !== void 0) {
+    console.warn(`[Aguacero][NEXRAD][archive] ${phase}`, detail);
+  } else {
+    console.warn(`[Aguacero][NEXRAD][archive] ${phase}`);
   }
 }
 
 // src/nexrad/loadNexradSites.ts
 var sitesUrl = "/data/nexrad.json";
+function setNexradSitesJsonUrl(url) {
+  sitesUrl = url || sitesUrl;
+}
+var SITES_FETCH_API_KEY = "";
+var SITES_FETCH_BUNDLE_ID = "";
+function setNexradSitesFetchAuth(apiKey, bundleId) {
+  SITES_FETCH_API_KEY = apiKey || "";
+  if (bundleId !== void 0) {
+    SITES_FETCH_BUNDLE_ID = bundleId || "";
+  }
+}
 var nexradSitesPayloadPromise = null;
+function sitesFetchUrl() {
+  if (!sitesUrl.startsWith("http") || !SITES_FETCH_API_KEY) {
+    return sitesUrl;
+  }
+  const sep = sitesUrl.includes("?") ? "&" : "?";
+  return `${sitesUrl}${sep}apiKey=${SITES_FETCH_API_KEY}`;
+}
+function sitesFetchHeaders() {
+  if (!SITES_FETCH_API_KEY) {
+    return void 0;
+  }
+  const headers = {
+    "x-api-key": SITES_FETCH_API_KEY
+  };
+  const nav = globalThis.navigator;
+  if (nav?.product === "ReactNative" && SITES_FETCH_BUNDLE_ID) {
+    headers["x-app-identifier"] = SITES_FETCH_BUNDLE_ID;
+  }
+  return headers;
+}
+function embeddedSitesPayload() {
+  return nexradSitesDefault_default;
+}
 function loadNexradSitesPayload() {
   if (nexradSitesPayloadPromise) {
     return nexradSitesPayloadPromise;
   }
-  nexradSitesPayloadPromise = fetch(sitesUrl).then((response) => {
-    if (!response.ok) throw new Error(`nexrad.json fetch failed: HTTP ${response.status}`);
-    return response.json();
-  }).catch((error) => {
-    console.error("[mapsgl] Could not load nexrad.json:", error);
-    nexradSitesPayloadPromise = null;
-    throw error;
-  });
+  nexradSitesPayloadPromise = (async () => {
+    const url = sitesFetchUrl();
+    const headers = sitesFetchHeaders();
+    const headerKeys = headers ? Object.keys(headers).join(",") : "";
+    nexradArchiveDiag("sites.fetch.start", {
+      canonicalUrl: sitesUrl,
+      fetchUrl: redactApiKeyFromUrl(url),
+      hasApiKeyQuery: url.includes("apiKey="),
+      headerKeys: headerKeys || "(none)",
+      apiKeyLen: SITES_FETCH_API_KEY.length,
+      bundleIdLen: SITES_FETCH_BUNDLE_ID.length
+    });
+    try {
+      const response = await fetch(url, headers ? { headers } : void 0);
+      if (response.ok) {
+        nexradArchiveDiag("sites.fetch.ok", {
+          status: response.status,
+          canonicalUrl: sitesUrl
+        });
+        return await response.json();
+      }
+      if (sitesUrl.startsWith("https://")) {
+        console.warn(
+          `[mapsgl] nexrad.json HTTP ${response.status} for ${sitesUrl} \u2014 using embedded site list`
+        );
+        nexradArchiveDiag("sites.fetch.fallbackEmbedded", {
+          httpStatus: response.status,
+          reason: "HTTPS non-OK \u2014 CloudFront may not host /data/nexrad.json; embedded list used",
+          canonicalUrl: sitesUrl
+        });
+        return embeddedSitesPayload();
+      }
+      throw new Error(`nexrad.json fetch failed: HTTP ${response.status}`);
+    } catch (error) {
+      if (sitesUrl.startsWith("https://")) {
+        console.warn("[mapsgl] nexrad.json load failed \u2014 using embedded site list:", error);
+        nexradArchiveDiag("sites.fetch.catchFallbackEmbedded", {
+          message: error instanceof Error ? error.message : String(error),
+          canonicalUrl: sitesUrl
+        });
+        return embeddedSitesPayload();
+      }
+      console.error("[mapsgl] Could not load nexrad.json:", error);
+      nexradSitesPayloadPromise = null;
+      throw error;
+    }
+  })();
   return nexradSitesPayloadPromise;
 }
 async function loadNexradSites() {
@@ -2932,15 +4802,872 @@ async function loadNexradSites() {
   return [];
 }
 
+// ../../node_modules/fzstd/esm/index.mjs
+var ab = ArrayBuffer;
+var u8 = Uint8Array;
+var u16 = Uint16Array;
+var i16 = Int16Array;
+var i32 = Int32Array;
+var slc = function(v, s, e) {
+  if (u8.prototype.slice)
+    return u8.prototype.slice.call(v, s, e);
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  var n = new u8(e - s);
+  n.set(v.subarray(s, e));
+  return n;
+};
+var fill = function(v, n, s, e) {
+  if (u8.prototype.fill)
+    return u8.prototype.fill.call(v, n, s, e);
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  for (; s < e; ++s)
+    v[s] = n;
+  return v;
+};
+var cpw = function(v, t, s, e) {
+  if (u8.prototype.copyWithin)
+    return u8.prototype.copyWithin.call(v, t, s, e);
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  while (s < e) {
+    v[t++] = v[s++];
+  }
+};
+var ec = [
+  "invalid zstd data",
+  "window size too large (>2046MB)",
+  "invalid block type",
+  "FSE accuracy too high",
+  "match distance too far back",
+  "unexpected EOF"
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var rb = function(d, b, n) {
+  var i = 0, o = 0;
+  for (; i < n; ++i)
+    o |= d[b++] << (i << 3);
+  return o;
+};
+var b4 = function(d, b) {
+  return (d[b] | d[b + 1] << 8 | d[b + 2] << 16 | d[b + 3] << 24) >>> 0;
+};
+var rzfh = function(dat, w) {
+  var n3 = dat[0] | dat[1] << 8 | dat[2] << 16;
+  if (n3 == 3126568 && dat[3] == 253) {
+    var flg = dat[4];
+    var ss = flg >> 5 & 1, cc = flg >> 2 & 1, df = flg & 3, fcf = flg >> 6;
+    if (flg & 8)
+      err(0);
+    var bt = 6 - ss;
+    var db = df == 3 ? 4 : df;
+    var di = rb(dat, bt, db);
+    bt += db;
+    var fsb = fcf ? 1 << fcf : ss;
+    var fss = rb(dat, bt, fsb) + (fcf == 1 && 256);
+    var ws = fss;
+    if (!ss) {
+      var wb = 1 << 10 + (dat[5] >> 3);
+      ws = wb + (wb >> 3) * (dat[5] & 7);
+    }
+    if (ws > 2145386496)
+      err(1);
+    var buf = new u8((w == 1 ? fss || ws : w ? 0 : ws) + 12);
+    buf[0] = 1, buf[4] = 4, buf[8] = 8;
+    return {
+      b: bt + fsb,
+      y: 0,
+      l: 0,
+      d: di,
+      w: w && w != 1 ? w : buf.subarray(12),
+      e: ws,
+      o: new i32(buf.buffer, 0, 3),
+      u: fss,
+      c: cc,
+      m: Math.min(131072, ws)
+    };
+  } else if ((n3 >> 4 | dat[3] << 20) == 25481893) {
+    return b4(dat, 4) + 8;
+  }
+  err(0);
+};
+var msb = function(val) {
+  var bits = 0;
+  for (; 1 << bits <= val; ++bits)
+    ;
+  return bits - 1;
+};
+var rfse = function(dat, bt, mal) {
+  var tpos = (bt << 3) + 4;
+  var al = (dat[bt] & 15) + 5;
+  if (al > mal)
+    err(3);
+  var sz = 1 << al;
+  var probs = sz, sym = -1, re = -1, i = -1, ht = sz;
+  var buf = new ab(512 + (sz << 2));
+  var freq = new i16(buf, 0, 256);
+  var dstate = new u16(buf, 0, 256);
+  var nstate = new u16(buf, 512, sz);
+  var bb1 = 512 + (sz << 1);
+  var syms = new u8(buf, bb1, sz);
+  var nbits = new u8(buf, bb1 + sz);
+  while (sym < 255 && probs > 0) {
+    var bits = msb(probs + 1);
+    var cbt = tpos >> 3;
+    var msk = (1 << bits + 1) - 1;
+    var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (tpos & 7) & msk;
+    var msk1fb = (1 << bits) - 1;
+    var msv = msk - probs - 1;
+    var sval = val & msk1fb;
+    if (sval < msv)
+      tpos += bits, val = sval;
+    else {
+      tpos += bits + 1;
+      if (val > msk1fb)
+        val -= msv;
+    }
+    freq[++sym] = --val;
+    if (val == -1) {
+      probs += val;
+      syms[--ht] = sym;
+    } else
+      probs -= val;
+    if (!val) {
+      do {
+        var rbt = tpos >> 3;
+        re = (dat[rbt] | dat[rbt + 1] << 8) >> (tpos & 7) & 3;
+        tpos += 2;
+        sym += re;
+      } while (re == 3);
+    }
+  }
+  if (sym > 255 || probs)
+    err(0);
+  var sympos = 0;
+  var sstep = (sz >> 1) + (sz >> 3) + 3;
+  var smask = sz - 1;
+  for (var s = 0; s <= sym; ++s) {
+    var sf = freq[s];
+    if (sf < 1) {
+      dstate[s] = -sf;
+      continue;
+    }
+    for (i = 0; i < sf; ++i) {
+      syms[sympos] = s;
+      do {
+        sympos = sympos + sstep & smask;
+      } while (sympos >= ht);
+    }
+  }
+  if (sympos)
+    err(0);
+  for (i = 0; i < sz; ++i) {
+    var ns = dstate[syms[i]]++;
+    var nb = nbits[i] = al - msb(ns);
+    nstate[i] = (ns << nb) - sz;
+  }
+  return [tpos + 7 >> 3, {
+    b: al,
+    s: syms,
+    n: nbits,
+    t: nstate
+  }];
+};
+var rhu = function(dat, bt) {
+  var i = 0, wc = -1;
+  var buf = new u8(292), hb = dat[bt];
+  var hw = buf.subarray(0, 256);
+  var rc = buf.subarray(256, 268);
+  var ri = new u16(buf.buffer, 268);
+  if (hb < 128) {
+    var _a = rfse(dat, bt + 1, 6), ebt = _a[0], fdt = _a[1];
+    bt += hb;
+    var epos = ebt << 3;
+    var lb = dat[bt];
+    if (!lb)
+      err(0);
+    var st1 = 0, st2 = 0, btr1 = fdt.b, btr2 = btr1;
+    var fpos = (++bt << 3) - 8 + msb(lb);
+    for (; ; ) {
+      fpos -= btr1;
+      if (fpos < epos)
+        break;
+      var cbt = fpos >> 3;
+      st1 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr1) - 1;
+      hw[++wc] = fdt.s[st1];
+      fpos -= btr2;
+      if (fpos < epos)
+        break;
+      cbt = fpos >> 3;
+      st2 += (dat[cbt] | dat[cbt + 1] << 8) >> (fpos & 7) & (1 << btr2) - 1;
+      hw[++wc] = fdt.s[st2];
+      btr1 = fdt.n[st1];
+      st1 = fdt.t[st1];
+      btr2 = fdt.n[st2];
+      st2 = fdt.t[st2];
+    }
+    if (++wc > 255)
+      err(0);
+  } else {
+    wc = hb - 127;
+    for (; i < wc; i += 2) {
+      var byte = dat[++bt];
+      hw[i] = byte >> 4;
+      hw[i + 1] = byte & 15;
+    }
+    ++bt;
+  }
+  var wes = 0;
+  for (i = 0; i < wc; ++i) {
+    var wt = hw[i];
+    if (wt > 11)
+      err(0);
+    wes += wt && 1 << wt - 1;
+  }
+  var mb = msb(wes) + 1;
+  var ts = 1 << mb;
+  var rem = ts - wes;
+  if (rem & rem - 1)
+    err(0);
+  hw[wc++] = msb(rem) + 1;
+  for (i = 0; i < wc; ++i) {
+    var wt = hw[i];
+    ++rc[hw[i] = wt && mb + 1 - wt];
+  }
+  var hbuf = new u8(ts << 1);
+  var syms = hbuf.subarray(0, ts), nb = hbuf.subarray(ts);
+  ri[mb] = 0;
+  for (i = mb; i > 0; --i) {
+    var pv = ri[i];
+    fill(nb, i, pv, ri[i - 1] = pv + rc[i] * (1 << mb - i));
+  }
+  if (ri[0] != ts)
+    err(0);
+  for (i = 0; i < wc; ++i) {
+    var bits = hw[i];
+    if (bits) {
+      var code = ri[bits];
+      fill(syms, i, code, ri[bits] = code + (1 << mb - bits));
+    }
+  }
+  return [bt, {
+    n: nb,
+    b: mb,
+    s: syms
+  }];
+};
+var dllt = rfse(/* @__PURE__ */ new u8([
+  81,
+  16,
+  99,
+  140,
+  49,
+  198,
+  24,
+  99,
+  12,
+  33,
+  196,
+  24,
+  99,
+  102,
+  102,
+  134,
+  70,
+  146,
+  4
+]), 0, 6)[1];
+var dmlt = rfse(/* @__PURE__ */ new u8([
+  33,
+  20,
+  196,
+  24,
+  99,
+  140,
+  33,
+  132,
+  16,
+  66,
+  8,
+  33,
+  132,
+  16,
+  66,
+  8,
+  33,
+  68,
+  68,
+  68,
+  68,
+  68,
+  68,
+  68,
+  68,
+  36,
+  9
+]), 0, 6)[1];
+var doct = rfse(/* @__PURE__ */ new u8([
+  32,
+  132,
+  16,
+  66,
+  102,
+  70,
+  68,
+  68,
+  68,
+  68,
+  36,
+  73,
+  2
+]), 0, 5)[1];
+var b2bl = function(b, s) {
+  var len = b.length, bl = new i32(len);
+  for (var i = 0; i < len; ++i) {
+    bl[i] = s;
+    s += 1 << b[i];
+  }
+  return bl;
+};
+var llb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+  0,
+  0,
+  0,
+  0,
+  16843009,
+  50528770,
+  134678020,
+  202050057,
+  269422093
+])).buffer, 0, 36);
+var llbl = /* @__PURE__ */ b2bl(llb, 0);
+var mlb = /* @__PURE__ */ new u8((/* @__PURE__ */ new i32([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  16843009,
+  50528770,
+  117769220,
+  185207048,
+  252579084,
+  16
+])).buffer, 0, 53);
+var mlbl = /* @__PURE__ */ b2bl(mlb, 3);
+var dhu = function(dat, out, hu) {
+  var len = dat.length, ss = out.length, lb = dat[len - 1], msk = (1 << hu.b) - 1, eb = -hu.b;
+  if (!lb)
+    err(0);
+  var st = 0, btr = hu.b, pos = (len << 3) - 8 + msb(lb) - btr, i = -1;
+  for (; pos > eb && i < ss; ) {
+    var cbt = pos >> 3;
+    var val = (dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (pos & 7);
+    st = (st << btr | val) & msk;
+    out[++i] = hu.s[st];
+    pos -= btr = hu.n[st];
+  }
+  if (pos != eb || i + 1 != ss)
+    err(0);
+};
+var dhu4 = function(dat, out, hu) {
+  var bt = 6;
+  var ss = out.length, sz1 = ss + 3 >> 2, sz2 = sz1 << 1, sz3 = sz1 + sz2;
+  dhu(dat.subarray(bt, bt += dat[0] | dat[1] << 8), out.subarray(0, sz1), hu);
+  dhu(dat.subarray(bt, bt += dat[2] | dat[3] << 8), out.subarray(sz1, sz2), hu);
+  dhu(dat.subarray(bt, bt += dat[4] | dat[5] << 8), out.subarray(sz2, sz3), hu);
+  dhu(dat.subarray(bt), out.subarray(sz3), hu);
+};
+var rzb = function(dat, st, out) {
+  var _a;
+  var bt = st.b;
+  var b0 = dat[bt], btype = b0 >> 1 & 3;
+  st.l = b0 & 1;
+  var sz = b0 >> 3 | dat[bt + 1] << 5 | dat[bt + 2] << 13;
+  var ebt = (bt += 3) + sz;
+  if (btype == 1) {
+    if (bt >= dat.length)
+      return;
+    st.b = bt + 1;
+    if (out) {
+      fill(out, dat[bt], st.y, st.y += sz);
+      return out;
+    }
+    return fill(new u8(sz), dat[bt]);
+  }
+  if (ebt > dat.length)
+    return;
+  if (btype == 0) {
+    st.b = ebt;
+    if (out) {
+      out.set(dat.subarray(bt, ebt), st.y);
+      st.y += sz;
+      return out;
+    }
+    return slc(dat, bt, ebt);
+  }
+  if (btype == 2) {
+    var b3 = dat[bt], lbt = b3 & 3, sf = b3 >> 2 & 3;
+    var lss = b3 >> 4, lcs = 0, s4 = 0;
+    if (lbt < 2) {
+      if (sf & 1)
+        lss |= dat[++bt] << 4 | (sf & 2 && dat[++bt] << 12);
+      else
+        lss = b3 >> 3;
+    } else {
+      s4 = sf;
+      if (sf < 2)
+        lss |= (dat[++bt] & 63) << 4, lcs = dat[bt] >> 6 | dat[++bt] << 2;
+      else if (sf == 2)
+        lss |= dat[++bt] << 4 | (dat[++bt] & 3) << 12, lcs = dat[bt] >> 2 | dat[++bt] << 6;
+      else
+        lss |= dat[++bt] << 4 | (dat[++bt] & 63) << 12, lcs = dat[bt] >> 6 | dat[++bt] << 2 | dat[++bt] << 10;
+    }
+    ++bt;
+    var buf = out ? out.subarray(st.y, st.y + st.m) : new u8(st.m);
+    var spl = buf.length - lss;
+    if (lbt == 0)
+      buf.set(dat.subarray(bt, bt += lss), spl);
+    else if (lbt == 1)
+      fill(buf, dat[bt++], spl);
+    else {
+      var hu = st.h;
+      if (lbt == 2) {
+        var hud = rhu(dat, bt);
+        lcs += bt - (bt = hud[0]);
+        st.h = hu = hud[1];
+      } else if (!hu)
+        err(0);
+      (s4 ? dhu4 : dhu)(dat.subarray(bt, bt += lcs), buf.subarray(spl), hu);
+    }
+    var ns = dat[bt++];
+    if (ns) {
+      if (ns == 255)
+        ns = (dat[bt++] | dat[bt++] << 8) + 32512;
+      else if (ns > 127)
+        ns = ns - 128 << 8 | dat[bt++];
+      var scm = dat[bt++];
+      if (scm & 3)
+        err(0);
+      var dts = [dmlt, doct, dllt];
+      for (var i = 2; i > -1; --i) {
+        var md = scm >> (i << 1) + 2 & 3;
+        if (md == 1) {
+          var rbuf = new u8([0, 0, dat[bt++]]);
+          dts[i] = {
+            s: rbuf.subarray(2, 3),
+            n: rbuf.subarray(0, 1),
+            t: new u16(rbuf.buffer, 0, 1),
+            b: 0
+          };
+        } else if (md == 2) {
+          _a = rfse(dat, bt, 9 - (i & 1)), bt = _a[0], dts[i] = _a[1];
+        } else if (md == 3) {
+          if (!st.t)
+            err(0);
+          dts[i] = st.t[i];
+        }
+      }
+      var _b = st.t = dts, mlt = _b[0], oct = _b[1], llt = _b[2];
+      var lb = dat[ebt - 1];
+      if (!lb)
+        err(0);
+      var spos = (ebt << 3) - 8 + msb(lb) - llt.b, cbt = spos >> 3, oubt = 0;
+      var lst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << llt.b) - 1;
+      cbt = (spos -= oct.b) >> 3;
+      var ost = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << oct.b) - 1;
+      cbt = (spos -= mlt.b) >> 3;
+      var mst = (dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mlt.b) - 1;
+      for (++ns; --ns; ) {
+        var llc = llt.s[lst];
+        var lbtr = llt.n[lst];
+        var mlc = mlt.s[mst];
+        var mbtr = mlt.n[mst];
+        var ofc = oct.s[ost];
+        var obtr = oct.n[ost];
+        cbt = (spos -= ofc) >> 3;
+        var ofp = 1 << ofc;
+        var off = ofp + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16 | dat[cbt + 3] << 24) >>> (spos & 7) & ofp - 1);
+        cbt = (spos -= mlb[mlc]) >> 3;
+        var ml = mlbl[mlc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << mlb[mlc]) - 1);
+        cbt = (spos -= llb[llc]) >> 3;
+        var ll = llbl[llc] + ((dat[cbt] | dat[cbt + 1] << 8 | dat[cbt + 2] << 16) >> (spos & 7) & (1 << llb[llc]) - 1);
+        cbt = (spos -= lbtr) >> 3;
+        lst = llt.t[lst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << lbtr) - 1);
+        cbt = (spos -= mbtr) >> 3;
+        mst = mlt.t[mst] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << mbtr) - 1);
+        cbt = (spos -= obtr) >> 3;
+        ost = oct.t[ost] + ((dat[cbt] | dat[cbt + 1] << 8) >> (spos & 7) & (1 << obtr) - 1);
+        if (off > 3) {
+          st.o[2] = st.o[1];
+          st.o[1] = st.o[0];
+          st.o[0] = off -= 3;
+        } else {
+          var idx = off - (ll != 0);
+          if (idx) {
+            off = idx == 3 ? st.o[0] - 1 : st.o[idx];
+            if (idx > 1)
+              st.o[2] = st.o[1];
+            st.o[1] = st.o[0];
+            st.o[0] = off;
+          } else
+            off = st.o[0];
+        }
+        for (var i = 0; i < ll; ++i) {
+          buf[oubt + i] = buf[spl + i];
+        }
+        oubt += ll, spl += ll;
+        var stin = oubt - off;
+        if (stin < 0) {
+          var len = -stin;
+          var bs = st.e + stin;
+          if (len > ml)
+            len = ml;
+          for (var i = 0; i < len; ++i) {
+            buf[oubt + i] = st.w[bs + i];
+          }
+          oubt += len, ml -= len, stin = 0;
+        }
+        for (var i = 0; i < ml; ++i) {
+          buf[oubt + i] = buf[stin + i];
+        }
+        oubt += ml;
+      }
+      if (oubt != spl) {
+        while (spl < buf.length) {
+          buf[oubt++] = buf[spl++];
+        }
+      } else
+        oubt = buf.length;
+      if (out)
+        st.y += oubt;
+      else
+        buf = slc(buf, 0, oubt);
+    } else if (out) {
+      st.y += lss;
+      if (spl) {
+        for (var i = 0; i < lss; ++i) {
+          buf[i] = buf[spl + i];
+        }
+      }
+    } else if (spl)
+      buf = slc(buf, spl);
+    st.b = ebt;
+    return buf;
+  }
+  err(2);
+};
+var cct = function(bufs, ol) {
+  if (bufs.length == 1)
+    return bufs[0];
+  var buf = new u8(ol);
+  for (var i = 0, b = 0; i < bufs.length; ++i) {
+    var chk = bufs[i];
+    buf.set(chk, b);
+    b += chk.length;
+  }
+  return buf;
+};
+function decompress(dat, buf) {
+  var bufs = [], nb = +!buf;
+  var bt = 0, ol = 0;
+  for (; dat.length; ) {
+    var st = rzfh(dat, nb || buf);
+    if (typeof st == "object") {
+      if (nb) {
+        buf = null;
+        if (st.w.length == st.u) {
+          bufs.push(buf = st.w);
+          ol += st.u;
+        }
+      } else {
+        bufs.push(buf);
+        st.e = 0;
+      }
+      for (; !st.l; ) {
+        var blk = rzb(dat, st, buf);
+        if (!blk)
+          err(5);
+        if (buf)
+          st.e = st.y;
+        else {
+          bufs.push(blk);
+          ol += blk.length;
+          cpw(st.w, 0, blk.length);
+          st.w.set(blk, st.w.length - blk.length);
+        }
+      }
+      bt = st.b + st.c * 4;
+    } else
+      bt = st;
+    dat = dat.subarray(bt);
+  }
+  return cct(bufs, ol);
+}
+
+// src/nexrad/radarDecodeSlot.ts
+var SLOT_HDR_BYTES = 28;
+function isZstd(bytes) {
+  return bytes.length >= 4 && bytes[0] === 40 && bytes[1] === 181 && bytes[2] === 47 && bytes[3] === 253;
+}
+function parseObjectKey(objectKey) {
+  const parts = objectKey.split("_");
+  if (parts.length < 2) return null;
+  return { stationId: parts[0] };
+}
+function buildRayBoundariesDeg(azimuths) {
+  const nRays = azimuths.length;
+  const boundaries = new Float32Array(nRays + 1);
+  if (nRays === 0) return boundaries;
+  let totalSpacing = 0;
+  let validCount = 0;
+  for (let i = 1; i < nRays; i++) {
+    let diff = azimuths[i] - azimuths[i - 1];
+    while (diff < -180) diff += 360;
+    while (diff > 180) diff -= 360;
+    const absDiff = Math.abs(diff);
+    if (absDiff > 0 && absDiff < 10) {
+      totalSpacing += absDiff;
+      validCount++;
+    }
+  }
+  let avgSpacing = validCount > 0 ? totalSpacing / validCount : 360 / nRays;
+  if (avgSpacing <= 0 || isNaN(avgSpacing)) avgSpacing = 1;
+  boundaries[0] = azimuths[0] - avgSpacing / 2;
+  for (let i = 1; i < nRays; i++) {
+    let diff = azimuths[i] - azimuths[i - 1];
+    while (diff < -180) diff += 360;
+    while (diff > 180) diff -= 360;
+    boundaries[i] = azimuths[i - 1] + diff / 2;
+  }
+  boundaries[nRays] = azimuths[nRays - 1] + avgSpacing / 2;
+  return boundaries;
+}
+function decodeRadarSlotMessage(data) {
+  const {
+    requestId,
+    objectKey,
+    slotBuffer,
+    nRays,
+    nGates,
+    firstGateKm,
+    gateWidthKm,
+    azimuthsBuffer,
+    sites
+  } = data;
+  const compressed = new Uint8Array(slotBuffer);
+  if (!isZstd(compressed)) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Slot for ${objectKey} is not valid zstd`
+    };
+  }
+  const decompressed = decompress(compressed);
+  const buffer = decompressed.buffer.slice(
+    decompressed.byteOffset,
+    decompressed.byteOffset + decompressed.byteLength
+  );
+  const view = new DataView(buffer);
+  const valueScale = view.getFloat32(0, false);
+  const valueOffset = view.getFloat32(4, false);
+  const present = view.getUint32(8, false);
+  if (present === 0) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Slot for ${objectKey} marked not present`
+    };
+  }
+  const slotNRays = view.getUint16(12, false);
+  const slotNGates = view.getUint16(14, false);
+  const gateBytes = buffer.byteLength - SLOT_HDR_BYTES;
+  const expectedGates = slotNRays * slotNGates;
+  const bytesPerGate = gateBytes / expectedGates;
+  if (bytesPerGate !== 1 && bytesPerGate !== 2 && bytesPerGate !== 4) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Unexpected bytesPerGate=${bytesPerGate} for ${objectKey}`
+    };
+  }
+  const keyParts = parseObjectKey(objectKey);
+  if (!keyParts) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Unable to parse station from key: ${objectKey}`
+    };
+  }
+  const site = sites.find((s) => s.id === keyParts.stationId);
+  if (!site) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Station "${keyParts.stationId}" not found`
+    };
+  }
+  const azimuths = new Float32Array(slotNRays);
+  const azView = new DataView(azimuthsBuffer);
+  const headerNRays = azimuthsBuffer.byteLength / 4;
+  for (let i = 0; i < slotNRays; i++) {
+    if (i < headerNRays) {
+      azimuths[i] = azView.getFloat32(i * 4, false);
+    } else {
+      const prevAz = i > 0 ? azimuths[i - 1] : 0;
+      azimuths[i] = (prevAz + 360 / slotNRays) % 360;
+    }
+  }
+  const rayBoundariesDeg = buildRayBoundariesDeg(azimuths);
+  const gateCount = slotNRays * slotNGates;
+  const gateDataCopy = new Uint8Array(slotNRays * slotNGates * 2);
+  const outView = new DataView(gateDataCopy.buffer);
+  if (bytesPerGate === 1) {
+    const raw = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount);
+    for (let ray = 0; ray < slotNRays; ray++) {
+      let prev = 0;
+      for (let g = 0; g < slotNGates; g++) {
+        const idx = ray * slotNGates + g;
+        const delta = raw[idx];
+        const val = prev + delta & 255;
+        prev = val;
+        if (val === 0) {
+          outView.setInt16(idx * 2, -32768, false);
+        } else {
+          outView.setInt16(idx * 2, val, false);
+        }
+      }
+    }
+  } else {
+    const rawBytes = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount * 2);
+    for (let ray = 0; ray < slotNRays; ray++) {
+      let prev = 0;
+      for (let g = 0; g < slotNGates; g++) {
+        const idx = ray * slotNGates + g;
+        const hi = rawBytes[idx * 2];
+        const lo = rawBytes[idx * 2 + 1];
+        const delta = (hi << 8 | lo) << 16 >> 16;
+        const val = prev + delta | 0;
+        prev = val;
+        outView.setInt16(idx * 2, val, false);
+      }
+    }
+  }
+  return {
+    type: "DECODE_RESULT",
+    requestId,
+    gateData: gateDataCopy,
+    stationLat: site.lat,
+    stationLon: site.lon,
+    firstGateKm,
+    gateWidthKm,
+    valueScale,
+    valueOffset,
+    rayBoundariesDeg,
+    nRays: slotNRays,
+    nGates: slotNGates
+  };
+}
+
 // src/nexrad/radarArchiveCore.ts
 if (typeof globalThis.Buffer === "undefined") {
   globalThis.Buffer = import_buffer.Buffer;
 }
+function createAbortError(message = "Aborted") {
+  const g = globalThis;
+  if (typeof g.DOMException !== "undefined") {
+    return new g.DOMException(message, "AbortError");
+  }
+  const err2 = new Error(message);
+  err2.name = "AbortError";
+  return err2;
+}
+function isAbortError(err2) {
+  if (err2 == null || typeof err2 !== "object") return false;
+  return err2.name === "AbortError";
+}
 var NEXRAD_ARCHIVE_API_KEY = "";
+var NEXRAD_ARCHIVE_BUNDLE_ID = "";
 function setNexradArchiveApiKey(k) {
   NEXRAD_ARCHIVE_API_KEY = k || "";
 }
+function setNexradArchiveBundleId(bundleId) {
+  NEXRAD_ARCHIVE_BUNDLE_ID = bundleId || "";
+}
+function cloudFrontUrlWithApiKeyQuery(baseUrl) {
+  if (!NEXRAD_ARCHIVE_API_KEY) return baseUrl;
+  const sep = baseUrl.includes("?") ? "&" : "?";
+  return `${baseUrl}${sep}apiKey=${NEXRAD_ARCHIVE_API_KEY}`;
+}
+function level2CloudFrontFetchHeaders(range) {
+  const headers = {
+    "x-api-key": NEXRAD_ARCHIVE_API_KEY
+  };
+  if (range !== void 0) {
+    headers["Range"] = range;
+  }
+  const g = globalThis;
+  if (g.navigator?.product === "ReactNative" && NEXRAD_ARCHIVE_BUNDLE_ID) {
+    headers["x-app-identifier"] = NEXRAD_ARCHIVE_BUNDLE_ID;
+  }
+  return headers;
+}
+function shouldDecodeRadarOnMainThread() {
+  const g = globalThis;
+  return typeof Worker === "undefined" || g.navigator?.product === "ReactNative";
+}
+var MainThreadRadarDecodeWorker = class {
+  onmessage = null;
+  onerror = null;
+  postMessage(data) {
+    const msg = data;
+    if (!msg || msg.type !== "DECODE_SLOT") return;
+    queueMicrotask(() => {
+      try {
+        const response = decodeRadarSlotMessage(msg);
+        this.onmessage?.({ data: response });
+      } catch (error) {
+        this.onmessage?.({
+          data: {
+            type: "DECODE_RESULT",
+            requestId: msg.requestId,
+            gateData: null,
+            error: error instanceof Error ? error.message : "Main-thread radar decode failed"
+          }
+        });
+      }
+    });
+  }
+  terminate() {
+  }
+};
 function createRadarDecodeWorker() {
+  if (shouldDecodeRadarOnMainThread()) {
+    return new MainThreadRadarDecodeWorker();
+  }
   return new Worker(new URL("./radarDecode.worker.bundled.js", import.meta.url), { type: "module" });
 }
 var LEVEL2_BASE_URL = "https://d3dc62msmxkrd7.cloudfront.net/level-2";
@@ -3939,8 +6666,8 @@ function decodeLevel3RasterProduct(buffer, objectKey, radarVariable) {
       });
     }
     return null;
-  } catch (err) {
-    console.warn("[aguacero][nexrad-l3][decode-throw]", { objectKey, radarVariable, err });
+  } catch (err2) {
+    console.warn("[aguacero][nexrad-l3][decode-throw]", { objectKey, radarVariable, err: err2 });
     return null;
   }
 }
@@ -4026,7 +6753,7 @@ function parseFileHeader(buffer, azBlockBytes) {
   };
 }
 function decodeSweepInWorker(objectKey, slotBuffer, header, sites, priority, signal) {
-  if (signal?.aborted) return Promise.reject(new DOMException("Aborted", "AbortError"));
+  if (signal?.aborted) return Promise.reject(createAbortError());
   const { worker } = getDecodeWorkerForPriority(priority);
   const requestId = ++radarDecodeRequestId;
   const azCopy = header.azimuthsBuffer.slice(0);
@@ -4038,7 +6765,7 @@ function decodeSweepInWorker(objectKey, slotBuffer, header, sites, priority, sig
       radarDecodePending.delete(requestId);
       radarDecodeRequestMeta.delete(requestId);
       signal?.removeEventListener("abort", onAbort);
-      reject(new DOMException("Aborted", "AbortError"));
+      reject(createAbortError());
     };
     radarDecodePending.set(requestId, {
       resolve: (frame) => {
@@ -4048,11 +6775,11 @@ function decodeSweepInWorker(objectKey, slotBuffer, header, sites, priority, sig
           resolve(frame);
         }
       },
-      reject: (err) => {
+      reject: (err2) => {
         if (!isSettled) {
           isSettled = true;
           signal?.removeEventListener("abort", onAbort);
-          reject(err);
+          reject(err2);
         }
       }
     });
@@ -4163,13 +6890,28 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         }
         return decoded2;
       }
+      const level2Url = cloudFrontUrlWithApiKeyQuery(url);
+      nexradArchiveDiag("level2.pipeline.start", {
+        objectKey,
+        radarVariable,
+        groupId,
+        apiKeyLen: NEXRAD_ARCHIVE_API_KEY.length,
+        bundleIdLen: NEXRAD_ARCHIVE_BUNDLE_ID.length,
+        urlNoSecret: redactApiKeyFromUrl(level2Url)
+      });
       const azBlockBytes = LEVEL2_AZ_BLOCK_BYTES;
       const INDEX_FETCH_BYTES = FILE_HDR_BYTES + azBlockBytes + LEVEL2_FILE_NYQUIST_BYTES + MAX_SLOTS * SLOT_INDEX_ENTRY;
-      const indexResp = await fetch(url, {
-        headers: {
-          "x-api-key": NEXRAD_ARCHIVE_API_KEY,
-          "Range": `bytes=0-${INDEX_FETCH_BYTES - 1}`
-        }
+      nexradArchiveDiag("level2.index.fetch", {
+        objectKey,
+        byteRangeEnd: INDEX_FETCH_BYTES - 1
+      });
+      const indexResp = await fetch(level2Url, {
+        headers: level2CloudFrontFetchHeaders(`bytes=0-${INDEX_FETCH_BYTES - 1}`)
+      });
+      nexradArchiveDiag("level2.index.response", {
+        objectKey,
+        status: indexResp.status,
+        ok: indexResp.ok
       });
       if (!indexResp.ok && indexResp.status !== 206) {
         throw new Error(`HTTP ${indexResp.status} fetching level2 index ${url}`);
@@ -4226,16 +6968,24 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         return null;
       }
       const slotRangeEnd = slotEndExclusive - 1;
-      const slotHeaders = {
-        "x-api-key": NEXRAD_ARCHIVE_API_KEY,
-        "Range": `bytes=${slot.offset}-${slotRangeEnd}`
-      };
-      let slotResp = await fetch(url, { headers: slotHeaders });
+      const slotHeaders = level2CloudFrontFetchHeaders(`bytes=${slot.offset}-${slotRangeEnd}`);
+      nexradArchiveDiag("level2.slot.fetch", {
+        objectKey,
+        slotIdx,
+        compressedSize: slot.compressedSize,
+        offset: slot.offset
+      });
+      let slotResp = await fetch(level2Url, { headers: slotHeaders });
+      nexradArchiveDiag("level2.slot.response", {
+        objectKey,
+        status: slotResp.status,
+        ok: slotResp.ok
+      });
       let slotBuffer;
       if (slotResp.ok || slotResp.status === 206) {
         slotBuffer = await slotResp.arrayBuffer();
       } else if (slotResp.status === 416) {
-        const fullResp = await fetch(url, { headers: { "x-api-key": NEXRAD_ARCHIVE_API_KEY } });
+        const fullResp = await fetch(level2Url, { headers: level2CloudFrontFetchHeaders(void 0) });
         if (!fullResp.ok) {
           throw new Error(`HTTP ${fullResp.status} full fetch after 416 for level2 ${url}`);
         }
@@ -4249,6 +6999,7 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
       } else {
         throw new Error(`HTTP ${slotResp.status} fetching level2 slot ${url}`);
       }
+      nexradArchiveDiag("level2.decode.start", { objectKey, radarVariable });
       const sites = await loadNexradSites();
       let decoded = await decodeSweepInWorker(
         objectKey,
@@ -4272,12 +7023,23 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         );
       }
       setArchiveCache(cacheKey, decoded);
+      nexradArchiveDiag("level2.decode.done", {
+        objectKey,
+        radarVariable,
+        nRays: decoded.nRays ?? null,
+        nGates: decoded.nGates ?? null
+      });
       return decoded;
-    } catch (err) {
-      if (err instanceof DOMException && err.name === "AbortError") {
+    } catch (err2) {
+      if (isAbortError(err2)) {
         return null;
       }
-      console.error(`[RadarLayer] fetchAndParseArchive failed for ${objectKey}:`, err);
+      nexradArchiveDiag("fetchAndParseArchive.failed", {
+        objectKey,
+        radarSource,
+        message: err2 instanceof Error ? err2.message : String(err2)
+      });
+      console.error(`[RadarLayer] fetchAndParseArchive failed for ${objectKey}:`, err2);
       return null;
     } finally {
       inflightFetches.delete(cacheKey);
@@ -4290,7 +7052,10 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
 export {
   fetchAndParseArchive,
   objectKeyToUrl,
-  setNexradArchiveApiKey
+  setNexradArchiveApiKey,
+  setNexradArchiveBundleId,
+  setNexradSitesFetchAuth,
+  setNexradSitesJsonUrl
 };
 /*! Bundled license information: