@aguacerowx/mapsgl 0.0.50 → 0.0.52

package/src/WeatherLayerManager.js

@@ -103,6 +103,8 @@ export class WeatherLayerManager extends EventEmitter {
             ...(options.watchesWarnings ?? {}),
         };
         this._nwsOverlay = null;
+        /** Dedupes {@link NwsWatchesWarningsOverlay#updateOptions} when only the observation timeline (slider) changes. */
+        this._nwsOptsKey = null;
 
         /**
          * Style layer id to insert custom weather layers below when using a non-Aguacero Mapbox style
@@ -288,8 +290,9 @@ export class WeatherLayerManager extends EventEmitter {
     }
 
     /**
-     * NWS watches/warnings: same NWWS feed as aguacero-frontend, overlaid on satellite / MRMS / NEXRAD only
-     * (hidden on model grids). By default `nwsAlertSettings.alertScope` is `'all'`. Use `'user'` with
+     * NWS watches/warnings: same NWWS feed as aguacero-frontend. Shown whenever `enabled` is true (including
+     * model-only maps — time filter uses wall clock until a satellite / MRMS / NEXRAD scrub timeline exists).
+     * By default `nwsAlertSettings.alertScope` is `'all'`. Use `'user'` with
      * `includedAlerts` (exact NWS `event_name` strings) to show only selected products.
      *
      * @param {object} partial
@@ -320,8 +323,9 @@ export class WeatherLayerManager extends EventEmitter {
     _syncNwsOverlay(state) {
         const wopt = this._watchesWarningsOptions ?? {};
         const masterEnabled = wopt.enabled === true;
-        const isModelMode = !state.isSatellite && !state.isNexrad && !state.isMRMS;
-        const enabled = masterEnabled && !isModelMode;
+        const hasObservationTimeline = state.isSatellite || state.isNexrad || state.isMRMS;
+        /** Watches/warnings may run on model-only maps: use wall-clock “active now” when no sat/MRMS/NEXRAD timeline. */
+        const enabled = masterEnabled;
 
         let timelineUnix = null;
         /** Same list the core uses for the time slider — enables NWS “live edge” (wall clock at latest step) like aguacero-frontend. */
@@ -349,22 +353,38 @@ export class WeatherLayerManager extends EventEmitter {
             ? wopt.fillBeforeLayerId ?? null
             : null;
 
-        this._nwsOverlay.updateOptions({
+        const nwsAlertSettingsForOpts = {
+            ...(wopt.nwsAlertSettings ?? {}),
+            ...(wopt.activeOnlyRealtime !== undefined ? { activeOnlyRealtime: wopt.activeOnlyRealtime } : {}),
+        };
+        const nwsOptsKey = JSON.stringify({
+            weatherLayerId,
+            fillBeforeLayerId,
+            lineBeforeLayerId: wopt.lineBeforeLayerId,
             alertsBaseUrl: wopt.alertsBaseUrl,
             alertInteractionEnabled: wopt.alertInteractionEnabled,
             deltaDebounceMs: wopt.deltaDebounceMs,
             fillOpacity: wopt.fillOpacity,
             lineOpacity: wopt.lineOpacity,
             lineWidth: wopt.lineWidth,
-            weatherLayerId,
-            fillBeforeLayerId,
-            lineBeforeLayerId: wopt.lineBeforeLayerId,
-            nwsAlertSettings: {
-                ...(wopt.nwsAlertSettings ?? {}),
-                ...(wopt.activeOnlyRealtime !== undefined ? { activeOnlyRealtime: wopt.activeOnlyRealtime } : {}),
-            },
+            nwsAlertSettings: nwsAlertSettingsForOpts,
         });
-        this._nwsOverlay.syncWithMode({ enabled, timelineUnix, timelineTimes });
+        if (this._nwsOptsKey !== nwsOptsKey) {
+            this._nwsOptsKey = nwsOptsKey;
+            this._nwsOverlay.updateOptions({
+                alertsBaseUrl: wopt.alertsBaseUrl,
+                alertInteractionEnabled: wopt.alertInteractionEnabled,
+                deltaDebounceMs: wopt.deltaDebounceMs,
+                fillOpacity: wopt.fillOpacity,
+                lineOpacity: wopt.lineOpacity,
+                lineWidth: wopt.lineWidth,
+                weatherLayerId,
+                fillBeforeLayerId,
+                lineBeforeLayerId: wopt.lineBeforeLayerId,
+                nwsAlertSettings: nwsAlertSettingsForOpts,
+            });
+        }
+        this._nwsOverlay.syncWithMode({ enabled, timelineUnix, timelineTimes, hasObservationTimeline });
     }
 
     /**
@@ -745,17 +765,12 @@ export class WeatherLayerManager extends EventEmitter {
     async setNexradProduct(product) {
         return this.core.setNexradProduct(product);
     }
-    /** @param {'level2'|'level3'} dataSource @param {string} product */
-    async setNexradProductMode(dataSource, product) {
-        return this.core.setNexradProductMode(dataSource, product);
-    }
-    /** @param {'level2'|'level3'} source */
-    async setNexradDataSource(source) {
-        return this.core.setNexradDataSource(source);
-    }
     async setNexradTilt(tilt) {
         return this.core.setNexradTilt(tilt);
     }
+    async setNexradStormRelative(enabled) {
+        return this.core.setNexradStormRelative(enabled);
+    }
     async setNexradTimestamp(timestamp) {
         return this.core.setNexradTimestamp(timestamp);
     }

package/src/nexrad/nexradArchiveCache.ts

@@ -19,6 +19,8 @@ export type DecodedRadarFrame = {
     valueScale: number;
     valueOffset: number;
     rayBoundariesDeg: Float32Array;
+    /** Nyquist velocity (m/s) from Level-II archive header; used for VEL readout (aguacero-frontend parity). */
+    embeddedNyquistMs?: number | null;
 };
 
 // ─── Cache storage ────────────────────────────────────────────────────────────

package/src/nexrad/nexradLevel3Products.ts

@@ -195,6 +195,12 @@ export const NEXRAD_LEVEL3_DHC_PRODUCTS: readonly string[] = [
 const NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST: readonly string[] = NEXRAD_LEVEL3_KDP_PRODUCTS.slice(3);
 const NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST: readonly string[] = NEXRAD_LEVEL3_DHC_PRODUCTS.slice(3);
 
+/** Super-res base radial velocity (154): S3 mnemonic per elevation (ICD order, low → high). */
+export const NEXRAD_LEVEL3_VELOCITY_PRODUCTS: readonly string[] = [
+    'NXG', 'NYG', 'NZG', 'N0G', 'NAG', 'N1G', 'NBG', 'N2G', 'N3G',
+];
+const NEXRAD_LEVEL3_VELOCITY_PRODUCTS_FOR_MANIFEST: readonly string[] = NEXRAD_LEVEL3_VELOCITY_PRODUCTS.slice(3);
+
 /**
  * Level-III KDP / digital HC (N0H): one S3 mnemonic per manifest slot in
  * {@link NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST} / {@link NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST}.
@@ -207,6 +213,32 @@ export function getNexradLevel3RadarTilts(siteId: string, radarVariable: string)
     return getRadarTilts(siteId, radarVariable).slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT);
 }
 
+/** Tilts for super-res L3 velocity (N*G), same manifest cap as KDP/N0H. */
+export function getNexradLevel3RadarTiltsForVelocity(siteId: string): number[] {
+    return getRadarTilts(siteId, 'VEL').slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT);
+}
+
+/**
+ * Map site tilt to L3 super-res base velocity mnemonic (N0G, NAG, …) for Unidata S3 keys / stable GPU layout — aguacero-frontend parity.
+ */
+export function nexradLevel3S3VelocityProductForSiteTilt(siteId: string, tilt: number): string {
+    const products = NEXRAD_LEVEL3_VELOCITY_PRODUCTS_FOR_MANIFEST;
+    const tilts = getNexradLevel3RadarTiltsForVelocity(siteId);
+    if (!tilts.length) {
+        return products[0]!;
+    }
+    const clamped = clampNexradTiltForVariable(siteId, 'VEL', tilt);
+    let idx = tilts.indexOf(clamped);
+    if (idx === -1) {
+        idx = tilts.reduce(
+            (bestI, t, i) => (Math.abs(t - clamped) < Math.abs(tilts[bestI]! - clamped) ? i : bestI),
+            0,
+        );
+    }
+    idx = Math.min(idx, products.length - 1);
+    return products[idx]!;
+}
+
 export function nexradLevel3IsTiltIndexedKdpProduct(product: string): boolean {
     return NEXRAD_LEVEL3_KDP_PRODUCTS.includes(product);
 }

package/src/nexrad/{nexradMapboxFrameOpts.js → nexradMapboxFrameOpts.ts}

@@ -1,11 +1,15 @@
 /**
  * MapboxRadarLayer upload options for NEXRAD — matches aguacero-frontend `RadarLayer` / MapboxRadarLayer docs:
- * Level-III KDP/N0H need {@link geometryLayoutKey} so frames use canonical azimuth bins (stable mesh).
- * Other Level-III radials need ray-boundary-keyed geometry so time scrubbing cannot reuse a mismatched mesh.
+ * Level-III KDP/N0H/VEL use {@link geometryLayoutKey} so frames use canonical azimuth bins (stable mesh; fast scrub).
+ * Other Level-III radials use ray-boundary-keyed geometry when layout cannot be fixed to a manifest product.
  */
 import { clampNexradTiltForVariable, getDefaultRadarTilt, getRadarTilts } from '@aguacerowx/javascript-sdk';
+import { nexradLevel3S3VelocityProductForSiteTilt } from './nexradLevel3Products.js';
 
-/** @typedef {{ geometryLayoutKey?: string; geometryCacheKeysRayBoundaries?: boolean }} MapboxRadarFrameUploadOptions */
+export type MapboxRadarFrameUploadOptions = {
+    geometryLayoutKey?: string;
+    geometryCacheKeysRayBoundaries?: boolean;
+};
 
 const NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST = [
     'N0K',
@@ -27,12 +31,12 @@ const NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST = [
 
 const NEXRAD_LEVEL3_MANIFEST_TILT_COUNT = NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST.length;
 
-function nearestTiltInSortedList(tilts, target) {
+function nearestTiltInSortedList(tilts: number[], target: number): number {
     if (!tilts.length) return target;
-    let best = tilts[0];
+    let best = tilts[0]!;
     let bestD = Math.abs(best - target);
     for (let i = 1; i < tilts.length; i++) {
-        const t = tilts[i];
+        const t = tilts[i]!;
         const d = Math.abs(t - target);
         if (d < bestD || (d === bestD && t < best)) {
             best = t;
@@ -42,16 +46,16 @@ function nearestTiltInSortedList(tilts, target) {
     return best;
 }
 
-function getNexradLevel3RadarTilts(siteId, radarVariable) {
+function getNexradLevel3RadarTilts(siteId: string, radarVariable: string): number[] {
     return getRadarTilts(siteId, radarVariable).slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT);
 }
 
-export function nexradLevel3UsesTiltIndexedS3Products(radarVariable) {
+export function nexradLevel3UsesTiltIndexedS3Products(radarVariable: string | undefined): boolean {
     const v = radarVariable || '';
     return v === 'KDP' || v === 'N0H';
 }
 
-function clampTiltForLevel3CompositeKey(siteId, radarVariable, tilt) {
+function clampTiltForLevel3CompositeKey(siteId: string, radarVariable: string, tilt: number): number {
     if (!nexradLevel3UsesTiltIndexedS3Products(radarVariable)) {
         return clampNexradTiltForVariable(siteId, radarVariable, tilt);
     }
@@ -63,34 +67,43 @@ function clampTiltForLevel3CompositeKey(siteId, radarVariable, tilt) {
 
 /**
  * Map site tilt to Level-III S3 product mnemonic (N0K, NAK, … / N0H, …) — aguacero-frontend parity.
- * @param {string} siteId
- * @param {'KDP' | 'N0H'} radarVariable
- * @param {number} tilt
  */
-export function nexradLevel3S3ProductForSiteTilt(siteId, radarVariable, tilt) {
+export function nexradLevel3S3ProductForSiteTilt(
+    siteId: string,
+    radarVariable: 'KDP' | 'N0H',
+    tilt: number,
+): string {
     const products =
         radarVariable === 'KDP' ? NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST : NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST;
     const tilts = getNexradLevel3RadarTilts(siteId, radarVariable);
     if (!tilts.length) {
-        return products[0];
+        return products[0]!;
     }
     const clamped = clampTiltForLevel3CompositeKey(siteId, radarVariable, tilt);
     let idx = tilts.indexOf(clamped);
     if (idx === -1) {
         idx = tilts.reduce(
-            (bestI, t, i) => (Math.abs(t - clamped) < Math.abs(tilts[bestI] - clamped) ? i : bestI),
+            (bestI, t, i) => (Math.abs(t - clamped) < Math.abs(tilts[bestI]! - clamped) ? i : bestI),
             0,
         );
     }
     idx = Math.min(idx, products.length - 1);
-    return products[idx];
+    return products[idx]!;
 }
 
+type NexradStateForMapbox = {
+    nexradDataSource?: string;
+    nexradSite?: string | null;
+    nexradProduct?: string | null;
+    nexradTilt?: number | null;
+};
+
 /**
- * @param {object} state - AguaceroCore state (or state:change payload) with NEXRAD fields
- * @returns {MapboxRadarFrameUploadOptions | undefined}
+ * @param state - AguaceroCore state (or state:change payload) with NEXRAD fields
  */
-export function mapboxFrameUploadOptionsForNexradState(state) {
+export function mapboxFrameUploadOptionsForNexradState(
+    state: NexradStateForMapbox | null | undefined,
+): MapboxRadarFrameUploadOptions | undefined {
     if (!state || state.nexradDataSource !== 'level3') return undefined;
     const site = state.nexradSite;
     const radarVar = (state.nexradProduct || 'REF').toUpperCase();
@@ -102,5 +115,11 @@ export function mapboxFrameUploadOptionsForNexradState(state) {
         return { geometryLayoutKey: `${site}|${radarVar}|${mnemonic}` };
     }
 
+    if (radarVar === 'VEL' && site) {
+        const tilt = Number.isFinite(state.nexradTilt) ? Number(state.nexradTilt) : getDefaultRadarTilt(site);
+        const mnemonic = nexradLevel3S3VelocityProductForSiteTilt(site, tilt);
+        return { geometryLayoutKey: `${site}|${radarVar}|${mnemonic}` };
+    }
+
     return { geometryCacheKeysRayBoundaries: true };
 }

package/src/nexrad/radarArchiveCore.bundled.js

@@ -2779,6 +2779,18 @@ var NEXRAD_LEVEL3_DHC_PRODUCTS = [
 ];
 var NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_KDP_PRODUCTS.slice(3);
 var NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_DHC_PRODUCTS.slice(3);
+var NEXRAD_LEVEL3_VELOCITY_PRODUCTS = [
+  "NXG",
+  "NYG",
+  "NZG",
+  "N0G",
+  "NAG",
+  "N1G",
+  "NBG",
+  "N2G",
+  "N3G"
+];
+var NEXRAD_LEVEL3_VELOCITY_PRODUCTS_FOR_MANIFEST = NEXRAD_LEVEL3_VELOCITY_PRODUCTS.slice(3);
 var NEXRAD_LEVEL3_MANIFEST_TILT_COUNT = NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST.length;
 function level3EetHeightKmFromLevel(level, dataMaskRaw, scaleRaw, offsetRaw) {
   if (level < 2) return null;
@@ -3932,14 +3944,17 @@ function decodeLevel3RasterProduct(buffer, objectKey, radarVariable) {
     return null;
   }
 }
-var GROUP2_VARS = ["VEL", "SW"];
+var GROUP2_VARS = ["SW"];
+var GROUP2_COMBINED_3_VARS = ["REF", "VEL", "SW"];
 var GROUP1_VARS = ["REF", "ZDR", "RHO", "PHI"];
 var GROUP2_COMBINED_7_VARS = ["REF", "ZDR", "RHO", "PHI", "KDP", "VEL", "SW"];
 var GROUP2_COMBINED_VARS = ["REF", "ZDR", "RHO", "PHI", "VEL", "SW"];
 var FILE_HDR_BYTES = 64;
-var AZ_BLOCK_BYTES = 720 * 4;
+var LEVEL2_AZ_BLOCK_RAYS = 720;
+var LEVEL2_AZ_BLOCK_BYTES = LEVEL2_AZ_BLOCK_RAYS * 4;
+var LEVEL2_FILE_NYQUIST_BYTES = 4;
 var SLOT_INDEX_ENTRY = 18;
-var MAX_SLOTS = 6;
+var MAX_SLOTS = 7;
 function int16ToFloat16(val) {
   const sign = (val & 32768) / 32768;
   const exponent = (val & 31744) / 1024;
@@ -3949,7 +3964,25 @@ function int16ToFloat16(val) {
   }
   return Math.pow(-1, sign) * Math.pow(2, exponent - 16) * (1 + fraction / Math.pow(2, 10));
 }
-function parseFileHeader(buffer) {
+function nexradLevel2ResourceTotalBytes(resp) {
+  const cr = resp.headers.get("Content-Range");
+  if (cr) {
+    const m = cr.trim().match(/\/(\d+)\s*$/);
+    if (m) {
+      const n = Number(m[1]);
+      return Number.isFinite(n) && n > 0 ? n : null;
+    }
+  }
+  if (resp.status === 200) {
+    const cl = resp.headers.get("Content-Length");
+    if (cl) {
+      const n = Number(cl);
+      return Number.isFinite(n) && n > 0 ? n : null;
+    }
+  }
+  return null;
+}
+function parseFileHeader(buffer, azBlockBytes) {
   const view = new DataView(buffer);
   const magic = view.getUint32(0, false);
   if (magic !== 1314406980) throw new Error(`Bad magic: 0x${magic.toString(16)}`);
@@ -3960,8 +3993,15 @@ function parseFileHeader(buffer) {
   const firstGateKm = view.getFloat32(16, false);
   const gateWidthKm = view.getFloat32(20, false);
   const nSlots = view.getUint16(24, false);
-  const azimuthsBuffer = buffer.slice(FILE_HDR_BYTES, FILE_HDR_BYTES + AZ_BLOCK_BYTES);
-  const idxStart = FILE_HDR_BYTES + AZ_BLOCK_BYTES;
+  const azimuthsBuffer = buffer.slice(FILE_HDR_BYTES, FILE_HDR_BYTES + azBlockBytes);
+  const azEnd = FILE_HDR_BYTES + azBlockBytes;
+  const idxStart = azEnd + LEVEL2_FILE_NYQUIST_BYTES;
+  const needBytes = idxStart + nSlots * SLOT_INDEX_ENTRY;
+  if (buffer.byteLength < needBytes) {
+    throw new Error(`level2 header buffer too small: ${buffer.byteLength} < ${needBytes}`);
+  }
+  const nyqCandidate = view.getFloat32(azEnd, false);
+  const embeddedNyquistMs = Number.isFinite(nyqCandidate) && nyqCandidate > 0.5 && nyqCandidate < 128 ? nyqCandidate : null;
   const slots = [];
   for (let i = 0; i < nSlots; i++) {
     const base = idxStart + i * SLOT_INDEX_ENTRY;
@@ -3981,7 +4021,8 @@ function parseFileHeader(buffer) {
     gateWidthKm,
     nSlots,
     azimuthsBuffer,
-    slots
+    slots,
+    embeddedNyquistMs
   };
 }
 function decodeSweepInWorker(objectKey, slotBuffer, header, sites, priority, signal) {
@@ -4030,7 +4071,24 @@ function decodeSweepInWorker(objectKey, slotBuffer, header, sites, priority, sig
     }, [slotBuffer, azCopy]);
   });
 }
+var N0S_MOTION_CACHE_MAX = 128;
+var n0sMotionVectorCache = /* @__PURE__ */ new Map();
+function getCachedN0sMotion(motionObjectKey) {
+  return n0sMotionVectorCache.get(motionObjectKey);
+}
+function setCachedN0sMotion(motionObjectKey, motion) {
+  n0sMotionVectorCache.set(motionObjectKey, motion);
+  while (n0sMotionVectorCache.size > N0S_MOTION_CACHE_MAX) {
+    const first = n0sMotionVectorCache.keys().next().value;
+    if (first === void 0) break;
+    n0sMotionVectorCache.delete(first);
+  }
+}
 async function applyStormMotionFromN0sObjectKey(frame, motionObjectKey, logLabel) {
+  const cached = getCachedN0sMotion(motionObjectKey);
+  if (cached) {
+    return applyLevel3StormRelativeToFrame(frame, cached.speedMs, cached.directionDeg);
+  }
   const motionUrl = objectKeyToUrl(motionObjectKey, "level3");
   try {
     const motionResp = await fetch(motionUrl);
@@ -4038,6 +4096,7 @@ async function applyStormMotionFromN0sObjectKey(frame, motionObjectKey, logLabel
       const motionBuf = await motionResp.arrayBuffer();
       const motion = parseLevel3StormMotionFromBuffer(motionBuf);
       if (motion) {
+        setCachedN0sMotion(motionObjectKey, motion);
         return applyLevel3StormRelativeToFrame(frame, motion.speedMs, motion.directionDeg);
       }
     }
@@ -4104,7 +4163,8 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         }
         return decoded2;
       }
-      const INDEX_FETCH_BYTES = FILE_HDR_BYTES + AZ_BLOCK_BYTES + MAX_SLOTS * SLOT_INDEX_ENTRY;
+      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,
@@ -4115,12 +4175,26 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         throw new Error(`HTTP ${indexResp.status} fetching level2 index ${url}`);
       }
       const indexBuffer = await indexResp.arrayBuffer();
-      const header = parseFileHeader(indexBuffer);
+      const indexResourceTotal = nexradLevel2ResourceTotalBytes(indexResp);
+      const header = parseFileHeader(indexBuffer, azBlockBytes);
+      const slotIndexBytes = FILE_HDR_BYTES + azBlockBytes + LEVEL2_FILE_NYQUIST_BYTES + header.nSlots * SLOT_INDEX_ENTRY;
+      if (indexBuffer.byteLength < slotIndexBytes) {
+        console.warn("[RadarLayer] level2 index response shorter than slot table", {
+          objectKey,
+          byteLength: indexBuffer.byteLength,
+          need: slotIndexBytes,
+          nSlots: header.nSlots
+        });
+        setArchiveCache(cacheKey, null);
+        return null;
+      }
       let varList;
       if (groupId === 2 && header.nSlots === 7) {
         varList = GROUP2_COMBINED_7_VARS;
       } else if (groupId === 2 && header.nSlots === 6) {
         varList = GROUP2_COMBINED_VARS;
+      } else if (groupId === 2 && header.nSlots === 3) {
+        varList = GROUP2_COMBINED_3_VARS;
       } else if (groupId === 2) {
         varList = GROUP2_VARS;
       } else {
@@ -4138,17 +4212,43 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         setArchiveCache(cacheKey, null);
         return null;
       }
-      const slotRangeEnd = slot.offset + slot.compressedSize - 1;
-      const slotResp = await fetch(url, {
-        headers: {
-          "x-api-key": NEXRAD_ARCHIVE_API_KEY,
-          "Range": `bytes=${slot.offset}-${slotRangeEnd}`
+      const slotEndExclusive = slot.offset + slot.compressedSize;
+      if (indexResourceTotal != null && slotEndExclusive > indexResourceTotal) {
+        console.warn("[RadarLayer] level2 slot extends past object size (bad index or stale CDN)", {
+          objectKey,
+          radarVariable,
+          slotIdx,
+          offset: slot.offset,
+          compressedSize: slot.compressedSize,
+          indexResourceTotal
+        });
+        setArchiveCache(cacheKey, null);
+        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 });
+      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 } });
+        if (!fullResp.ok) {
+          throw new Error(`HTTP ${fullResp.status} full fetch after 416 for level2 ${url}`);
         }
-      });
-      if (!slotResp.ok && slotResp.status !== 206) {
+        const fullBuf = await fullResp.arrayBuffer();
+        if (slot.offset >= fullBuf.byteLength || slotEndExclusive > fullBuf.byteLength) {
+          throw new Error(
+            `level2 slot out of bounds after 416 fallback (offset=${slot.offset}, end=${slotEndExclusive}, file=${fullBuf.byteLength}) for ${url}`
+          );
+        }
+        slotBuffer = fullBuf.slice(slot.offset, slotEndExclusive);
+      } else {
         throw new Error(`HTTP ${slotResp.status} fetching level2 slot ${url}`);
       }
-      const slotBuffer = await slotResp.arrayBuffer();
       const sites = await loadNexradSites();
       let decoded = await decodeSweepInWorker(
         objectKey,
@@ -4162,6 +4262,7 @@ async function fetchAndParseArchive(url, objectKey, radarVariable, groupId, rada
         setArchiveCache(cacheKey, null);
         return null;
       }
+      decoded = { ...decoded, embeddedNyquistMs: header.embeddedNyquistMs };
       const l2MotionKey = options?.level3MotionObjectKey;
       if (l2MotionKey && radarVariable === "VEL") {
         decoded = await applyStormMotionFromN0sObjectKey(