@aguacerowx/mapsgl 0.0.51 → 0.0.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aguacerowx/mapsgl",
-  "version": "0.0.51",
+  "version": "0.0.53",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -9,7 +9,7 @@
   "type": "module",
   "scripts": {
     "prepublishOnly": "npm run bundle-nexrad",
-    "bundle-nexrad": "esbuild src/nexrad/radarDecode.worker.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarDecode.worker.bundled.js && esbuild src/nexrad/radarArchiveCore.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarArchiveCore.bundled.js --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/MapboxRadarLayer.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/MapboxRadarLayer.bundled.js --external:mapbox-gl --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/nexradCrossSectionSampleAtLatLon.ts --format=esm --platform=browser --outfile=src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.js && esbuild src/nexrad/radarFrameGpuMatch.ts --format=esm --platform=browser --outfile=src/nexrad/radarFrameGpuMatch.bundled.js",
+    "bundle-nexrad": "esbuild src/nexrad/radarDecode.worker.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarDecode.worker.bundled.js && esbuild src/nexrad/radarArchiveCore.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/radarArchiveCore.bundled.js --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/MapboxRadarLayer.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/MapboxRadarLayer.bundled.js --external:mapbox-gl --external:@aguacerowx/javascript-sdk && esbuild src/nexrad/nexradCrossSectionSampleAtLatLon.ts --format=esm --platform=browser --outfile=src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.js && esbuild src/nexrad/radarFrameGpuMatch.ts --format=esm --platform=browser --outfile=src/nexrad/radarFrameGpuMatch.bundled.js && esbuild src/nexrad/nexradMapboxFrameOpts.ts --bundle --format=esm --platform=browser --outfile=src/nexrad/nexradMapboxFrameOpts.bundled.js --external:@aguacerowx/javascript-sdk",
     "gen:nws-key": "esbuild ../../../aguacero-frontend/src/components/WarningsMenu/nwsWarningCustomizationKey.ts --bundle --format=esm --platform=neutral --outfile=src/nwsWarningCustomizationKey.gen.js"
   },
   "files": [
@@ -21,7 +21,7 @@
     "esbuild": "^0.21.5"
   },
   "dependencies": {
-    "@aguacerowx/javascript-sdk": "^0.0.22",
+    "@aguacerowx/javascript-sdk": "^0.0.23",
     "buffer": "^6.0.3",
     "fzstd": "^0.1.1",
     "mapbox-gl": "^3.4.0",

package/src/NexradWeatherController.js

@@ -8,7 +8,7 @@ import { MapboxRadarLayer } from './nexrad/MapboxRadarLayer.bundled.js';
 import { nexradBinGroupIdForKey, variableToNexradGroup } from '@aguacerowx/javascript-sdk';
 import { sampleNexradFrameAtLatLon } from './nexrad/nexradCrossSectionSampleAtLatLon.bundled.js';
 import { prepareRadarFrameForGpuReadout } from './nexrad/radarFrameGpuMatch.bundled.js';
-import { mapboxFrameUploadOptionsForNexradState } from './nexrad/nexradMapboxFrameOpts.js';
+import { mapboxFrameUploadOptionsForNexradState } from './nexrad/nexradMapboxFrameOpts.bundled.js';
 
 function pickNearestLevel3ObjectKey(unixTime, timeToKeyMap, maxDeltaSec = 600) {
     const direct = timeToKeyMap[String(unixTime)];

package/src/NwsWatchesWarningsOverlay.js

@@ -136,6 +136,8 @@ export class NwsWatchesWarningsOverlay {
         this._timelineUnix = undefined;
         /** Timeline unix list for the active layer (satellite / MRMS / NEXRAD) — used to match frontend “live edge” behavior. */
         this._timelineTimes = null;
+        /** Last finite scrub time while sat/MRMS/NEXRAD is active — keeps filters during brief `nexradTimestamp: null` gaps. */
+        this._stickyTimelineUnix = null;
     }
 
     getAlertsUrl() {
@@ -161,6 +163,9 @@ export class NwsWatchesWarningsOverlay {
     /** Merge top-level options (e.g. `deltaDebounceMs`, `alertsBaseUrl`) and/or nested `nwsAlertSettings`. */
     updateOptions(partial) {
         if (!partial || typeof partial !== 'object') return;
+        const prevScope = this._nwsAlertSettings.alertScope ?? 'all';
+        const prevIncludedKey = JSON.stringify(this._nwsAlertSettings.includedAlerts ?? []);
+        const prevActiveOnly = this._nwsAlertSettings.activeOnlyRealtime;
         for (const [k, v] of Object.entries(partial)) {
             if (v === undefined) continue;
             if (k === 'nwsAlertSettings' && v && typeof v === 'object') {
@@ -173,8 +178,16 @@ export class NwsWatchesWarningsOverlay {
             }
         }
         if (this.map?.getLayer?.(this._fillId)) {
+            const nextScope = this._nwsAlertSettings.alertScope ?? 'all';
+            const nextIncludedKey = JSON.stringify(this._nwsAlertSettings.includedAlerts ?? []);
+            const scopeFilterChanged = prevScope !== nextScope || prevIncludedKey !== nextIncludedKey;
+            const activeOnlyChanged = prevActiveOnly !== this._nwsAlertSettings.activeOnlyRealtime;
             this._refreshPaint();
-            this._resyncSourceDataFilters();
+            if (scopeFilterChanged) {
+                this._resyncSourceDataFilters();
+            } else if (activeOnlyChanged) {
+                this._applyTimeFilters();
+            }
             this._syncClickHandler();
             this._applyLayerOrder();
         }
@@ -280,6 +293,9 @@ export class NwsWatchesWarningsOverlay {
      */
     setTimelineUnix(unixSeconds) {
         this._timelineUnix = unixSeconds;
+        if (unixSeconds != null && Number.isFinite(Number(unixSeconds))) {
+            this._stickyTimelineUnix = Number(unixSeconds);
+        }
         this._applyTimeFilters();
     }
 
@@ -295,8 +311,39 @@ export class NwsWatchesWarningsOverlay {
         return this._nwsAlertSettings.flashStyles ?? {};
     }
 
+    _hasNonEmptyTimelineTimes() {
+        const times = this._timelineTimes;
+        return Array.isArray(times) && times.length > 0;
+    }
+
+    /**
+     * Scrub reference: live `timelineUnix`, else last good scrub while observation data is loading, else newest tick.
+     */
+    _effectiveScrubUnix() {
+        const raw = this._timelineUnix;
+        if (raw != null && Number.isFinite(Number(raw))) {
+            return Number(raw);
+        }
+        if (this._stickyTimelineUnix != null && Number.isFinite(this._stickyTimelineUnix)) {
+            return this._stickyTimelineUnix;
+        }
+        const times = this._timelineTimes;
+        if (Array.isArray(times) && times.length > 0) {
+            let latest = -Infinity;
+            for (const t of times) {
+                if (typeof t === 'number' && Number.isFinite(t) && t > latest) {
+                    latest = t;
+                }
+            }
+            if (Number.isFinite(latest)) {
+                return latest;
+            }
+        }
+        return null;
+    }
+
     _isFollowingLatestTimelineAnchor() {
-        const current = this._timelineUnix;
+        const current = this._effectiveScrubUnix();
         if (current == null || !Number.isFinite(current)) return false;
         const times = this._timelineTimes;
         if (!Array.isArray(times) || times.length === 0) return false;
@@ -316,11 +363,22 @@ export class NwsWatchesWarningsOverlay {
      */
     _resolveDisplayTimeMode() {
         const userPinnedRealtime = this._nwsAlertSettings.activeOnlyRealtime === true;
+        const effectiveUnix = this._effectiveScrubUnix();
         const followRealtimeAtLatestAnchor = !userPinnedRealtime && this._isFollowingLatestTimelineAnchor();
-        const useRealtime = userPinnedRealtime || followRealtimeAtLatestAnchor;
+        const noScrubObservationTimelineUseWallClock =
+            !userPinnedRealtime &&
+            effectiveUnix == null &&
+            !this._hasNonEmptyTimelineTimes();
+        let useRealtime =
+            userPinnedRealtime || followRealtimeAtLatestAnchor || noScrubObservationTimelineUseWallClock;
+        let timelineUnixOut = useRealtime ? undefined : effectiveUnix;
+        if (!useRealtime && (timelineUnixOut == null || !Number.isFinite(timelineUnixOut))) {
+            useRealtime = true;
+            timelineUnixOut = undefined;
+        }
         return {
             useRealtime,
-            timelineUnix: useRealtime ? undefined : this._timelineUnix,
+            timelineUnix: timelineUnixOut,
         };
     }
 
@@ -825,15 +883,20 @@ export class NwsWatchesWarningsOverlay {
      * @param {boolean} opts.enabled
      * @param {number | null | undefined} opts.timelineUnix - Active scrubber unix for satellite / MRMS / NEXRAD.
      * @param {number[] | null | undefined} [opts.timelineTimes] - Full timeline for the current layer (for “live edge” = wall clock).
+     * @param {boolean} [opts.hasObservationTimeline] - When false (model / base map only), scrub hold is cleared and wall clock is used until observation data returns.
      */
-    syncWithMode({ enabled, timelineUnix, timelineTimes }) {
+    syncWithMode({ enabled, timelineUnix, timelineTimes, hasObservationTimeline }) {
         if (this._destroyed) return;
         this.options.enabled = !!enabled;
+        if (hasObservationTimeline === false) {
+            this._stickyTimelineUnix = null;
+        }
         if (timelineTimes !== undefined) {
             this._timelineTimes = Array.isArray(timelineTimes) ? timelineTimes : null;
         }
         this.setTimelineUnix(timelineUnix);
         if (!this.options.enabled) {
+            this._stickyTimelineUnix = null;
             this._started = false;
             this._sseFirstOpen = true;
             this._tearDownStream();
@@ -843,14 +906,15 @@ export class NwsWatchesWarningsOverlay {
         if (!this._started) {
             this._started = true;
             void this._initialLoad();
-        } else {
-            this._applyTimeFilters();
         }
+        // When already running, time filtering is applied in setTimelineUnix (avoids double work
+        // per scrub tick, matching aguacero-frontend: no full setData on slider move).
     }
 
     destroy() {
         this._destroyed = true;
         this._started = false;
+        this._stickyTimelineUnix = null;
         this.map?.off?.('click', this._boundClick);
         this._tearDownStream();
         this._removeLayers();

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 });
     }
 
     /**
@@ -748,6 +768,9 @@ export class WeatherLayerManager extends EventEmitter {
     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.bundled.js

@@ -0,0 +1,244 @@
+// src/nexrad/nexradMapboxFrameOpts.ts
+import { clampNexradTiltForVariable as clampNexradTiltForVariable2, getDefaultRadarTilt as getDefaultRadarTilt2, getRadarTilts as getRadarTilts2 } from "@aguacerowx/javascript-sdk";
+
+// src/nexrad/nexradLevel3Products.ts
+import {
+  clampNexradTiltForVariable,
+  formatTiltForApi,
+  getDefaultRadarTilt,
+  getRadarTilts,
+  isTerminalRadar
+} from "@aguacerowx/javascript-sdk";
+var NEXRAD_LEVEL3_MENU = [
+  {
+    radarKey: "VEL",
+    product: "N0G",
+    menuLabel: "Storm Relative Velocity",
+    fldKey: "nexrad_vel",
+    cmapPropertyKey: "nexrad_vel",
+    decodeMode: "velocity",
+    stormRelativeVelocity: true
+  },
+  {
+    radarKey: "KDP",
+    product: "N0K",
+    menuLabel: "Specific Differential Phase",
+    fldKey: "nexrad_l3_n0k",
+    cmapPropertyKey: "nexrad_kdp",
+    defaultUnit: "deg/km",
+    decodeMode: "generic_physical"
+  },
+  {
+    radarKey: "N0H",
+    product: "N0H",
+    menuLabel: "Hydrometeor Classification",
+    fldKey: "nexrad_l3_n0h",
+    cmapPropertyKey: "nexrad_l3_n0h",
+    defaultUnit: "None",
+    decodeMode: "categorical"
+  },
+  {
+    radarKey: "HHC",
+    product: "HHC",
+    menuLabel: "Hybrid Hydrometeor Classification",
+    fldKey: "nexrad_l3_hhc",
+    cmapPropertyKey: "nexrad_l3_hhc",
+    defaultUnit: "None",
+    decodeMode: "categorical"
+  },
+  {
+    radarKey: "EET",
+    product: "EET",
+    menuLabel: "Enhanced Echo Tops",
+    fldKey: "nexrad_l3_eet",
+    cmapPropertyKey: "nexrad_l3_eet",
+    defaultUnit: "kft",
+    decodeMode: "tops_kft"
+  },
+  {
+    radarKey: "DVL",
+    product: "DVL",
+    menuLabel: "Vertically Integrated Liquid",
+    fldKey: "nexrad_l3_dvl",
+    cmapPropertyKey: "nexrad_l3_dvl",
+    defaultUnit: "kg/m\xB2",
+    decodeMode: "vil"
+  },
+  {
+    radarKey: "DAA",
+    product: "DAA",
+    menuLabel: "1-Hour Precipitation",
+    fldKey: "nexrad_l3_daa",
+    cmapPropertyKey: "tp_0_1",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  },
+  {
+    radarKey: "DU3",
+    product: "DU3",
+    menuLabel: "3-Hour Precipitation",
+    fldKey: "nexrad_l3_du3",
+    cmapPropertyKey: "tp_0_total",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  },
+  {
+    radarKey: "DTA",
+    product: "DTA",
+    menuLabel: "Storm Total Precipitation",
+    fldKey: "nexrad_l3_dta",
+    cmapPropertyKey: "tp_0_total",
+    defaultUnit: "in",
+    decodeMode: "precip"
+  }
+];
+var byRadarKey = /* @__PURE__ */ new Map();
+for (const e of NEXRAD_LEVEL3_MENU) {
+  byRadarKey.set(e.radarKey, e);
+  if (e.radarKey === "DVL") byRadarKey.set("NVL", e);
+}
+var NEXRAD_LEVEL3_KDP_PRODUCTS = [
+  "NXK",
+  "NYK",
+  "NZK",
+  "N0K",
+  "NAK",
+  "N1K",
+  "NBK",
+  "N2K",
+  "N3K"
+];
+var NEXRAD_LEVEL3_DHC_PRODUCTS = [
+  "NXH",
+  "NYH",
+  "NZH",
+  "N0H",
+  "NAH",
+  "N1H",
+  "NBH",
+  "N2H",
+  "N3H"
+];
+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 getNexradLevel3RadarTiltsForVelocity(siteId) {
+  return getRadarTilts(siteId, "VEL").slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT);
+}
+function nexradLevel3S3VelocityProductForSiteTilt(siteId, tilt) {
+  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];
+}
+
+// src/nexrad/nexradMapboxFrameOpts.ts
+var NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST2 = [
+  "N0K",
+  "NAK",
+  "N1K",
+  "NBK",
+  "N2K",
+  "N3K"
+];
+var NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST2 = [
+  "N0H",
+  "NAH",
+  "N1H",
+  "NBH",
+  "N2H",
+  "N3H"
+];
+var NEXRAD_LEVEL3_MANIFEST_TILT_COUNT2 = NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST2.length;
+function nearestTiltInSortedList(tilts, target) {
+  if (!tilts.length) return target;
+  let best = tilts[0];
+  let bestD = Math.abs(best - target);
+  for (let i = 1; i < tilts.length; i++) {
+    const t = tilts[i];
+    const d = Math.abs(t - target);
+    if (d < bestD || d === bestD && t < best) {
+      best = t;
+      bestD = d;
+    }
+  }
+  return best;
+}
+function getNexradLevel3RadarTilts(siteId, radarVariable) {
+  return getRadarTilts2(siteId, radarVariable).slice(0, NEXRAD_LEVEL3_MANIFEST_TILT_COUNT2);
+}
+function nexradLevel3UsesTiltIndexedS3Products(radarVariable) {
+  const v = radarVariable || "";
+  return v === "KDP" || v === "N0H";
+}
+function clampTiltForLevel3CompositeKey(siteId, radarVariable, tilt) {
+  if (!nexradLevel3UsesTiltIndexedS3Products(radarVariable)) {
+    return clampNexradTiltForVariable2(siteId, radarVariable, tilt);
+  }
+  const tilts = getNexradLevel3RadarTilts(siteId, radarVariable);
+  const c = clampNexradTiltForVariable2(siteId, radarVariable, tilt);
+  if (!tilts.length) return c;
+  return nearestTiltInSortedList(tilts, c);
+}
+function nexradLevel3S3ProductForSiteTilt(siteId, radarVariable, tilt) {
+  const products = radarVariable === "KDP" ? NEXRAD_LEVEL3_KDP_PRODUCTS_FOR_MANIFEST2 : NEXRAD_LEVEL3_DHC_PRODUCTS_FOR_MANIFEST2;
+  const tilts = getNexradLevel3RadarTilts(siteId, radarVariable);
+  if (!tilts.length) {
+    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,
+      0
+    );
+  }
+  idx = Math.min(idx, products.length - 1);
+  return products[idx];
+}
+function mapboxFrameUploadOptionsForNexradState(state) {
+  if (!state || state.nexradDataSource !== "level3") return void 0;
+  const site = state.nexradSite;
+  const radarVar = (state.nexradProduct || "REF").toUpperCase();
+  if (nexradLevel3UsesTiltIndexedS3Products(radarVar) && site) {
+    const tilt = Number.isFinite(state.nexradTilt) ? Number(state.nexradTilt) : getDefaultRadarTilt2(site);
+    const kind = radarVar === "KDP" ? "KDP" : "N0H";
+    const mnemonic = nexradLevel3S3ProductForSiteTilt(site, kind, tilt);
+    return { geometryLayoutKey: `${site}|${radarVar}|${mnemonic}` };
+  }
+  if (radarVar === "VEL" && site) {
+    const tilt = Number.isFinite(state.nexradTilt) ? Number(state.nexradTilt) : getDefaultRadarTilt2(site);
+    const mnemonic = nexradLevel3S3VelocityProductForSiteTilt(site, tilt);
+    return { geometryLayoutKey: `${site}|${radarVar}|${mnemonic}` };
+  }
+  return { geometryCacheKeysRayBoundaries: true };
+}
+export {
+  mapboxFrameUploadOptionsForNexradState,
+  nexradLevel3S3ProductForSiteTilt,
+  nexradLevel3UsesTiltIndexedS3Products
+};

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(

package/src/nexrad/radarArchiveCore.ts

@@ -1420,18 +1420,23 @@ function decodeLevel3RasterProduct(buffer: ArrayBuffer, objectKey: string, radar
     }
 }
 
-const GROUP2_VARS = ['VEL', 'SW'];
+const GROUP2_VARS = ['SW'];
+/** g2 split-cut in clear-air mode (VCP 35): REF + VEL + SW in one file (legacy archives only). */
+const GROUP2_COMBINED_3_VARS = ['REF', 'VEL', 'SW'];
 /** g1 dual-pol + REF; order must match writer. KDP is Level-III (N0K), not in g1 bins. */
 const GROUP1_VARS = ['REF', 'ZDR', 'RHO', 'PHI'] as const;
 /** g2 combined tilt with KDP (7 slots); order must match writer. */
 const GROUP2_COMBINED_7_VARS = ['REF', 'ZDR', 'RHO', 'PHI', 'KDP', 'VEL', 'SW'];
 const GROUP2_COMBINED_VARS = ['REF', 'ZDR', 'RHO', 'PHI', 'VEL', 'SW'];
 
-// Fixed sizes matching the Python writer
-const FILE_HDR_BYTES       = 64;
-const AZ_BLOCK_BYTES       = 720 * 4;   // 2880
-const SLOT_INDEX_ENTRY     = 18;
-const MAX_SLOTS = 6;
+// Fixed sizes matching the Python writer (`lambda_function.py` MAX_RAYS / AZ_BLOCK_BYTES).
+const FILE_HDR_BYTES = 64;
+const LEVEL2_AZ_BLOCK_RAYS = 720;
+const LEVEL2_AZ_BLOCK_BYTES = LEVEL2_AZ_BLOCK_RAYS * 4;
+/** Per-sweep Nyquist (m/s), big-endian float32 after azimuth block and before slot index (writer `nyquist_bytes`). */
+const LEVEL2_FILE_NYQUIST_BYTES = 4;
+const SLOT_INDEX_ENTRY = 18;
+const MAX_SLOTS = 7; // g2 combined tilt can write 7 fields (GROUP2_COMBINED_7_VARS)
 
 interface FileHeader {
     unixTime:   number;
@@ -1441,8 +1446,10 @@ interface FileHeader {
     firstGateKm: number;
     gateWidthKm: number;
     nSlots:     number;
-    azimuthsBuffer: ArrayBuffer;  // raw big-endian float32 bytes, 720*4
+    azimuthsBuffer: ArrayBuffer;  // raw big-endian float32 bytes (720*4)
     slots: Array<{ offset: number; compressedSize: number; uncompressedSize: number }>;
+    /** Nyquist velocity (m/s) from file header after azimuths; null if non-finite / out of band. */
+    embeddedNyquistMs: number | null;
 }
 
 function int16ToFloat16(val: number): number {
@@ -1455,7 +1462,30 @@ function int16ToFloat16(val: number): number {
     return Math.pow(-1, sign) * Math.pow(2, exponent - 16) * (1 + fraction / Math.pow(2, 10));
 }
 
-function parseFileHeader(buffer: ArrayBuffer): FileHeader {
+/**
+ * Total Level-II object size when known.
+ * For 206 partial responses, only `Content-Range: bytes a-b/total` gives `total` — `Content-Length` is the segment size.
+ */
+function nexradLevel2ResourceTotalBytes(resp: Response): number | null {
+    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: ArrayBuffer, azBlockBytes: number): FileHeader {
     const view = new DataView(buffer);
     const magic = view.getUint32(0, false);
     if (magic !== 0x4E584244) throw new Error(`Bad magic: 0x${magic.toString(16)}`);
@@ -1468,24 +1498,42 @@ function parseFileHeader(buffer: ArrayBuffer): FileHeader {
     const gateWidthKm = view.getFloat32(20, false);
     const nSlots      = view.getUint16(24, false);
 
-    // Azimuths: 720 big-endian float32s starting at byte 64
-    const azimuthsBuffer = buffer.slice(FILE_HDR_BYTES, 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;
 
-    // Slot index starts at byte 2944
-    const idxStart = FILE_HDR_BYTES + AZ_BLOCK_BYTES;
-    const slots = [];
+    const slots: Array<{ offset: number; compressedSize: number; uncompressedSize: number }> = [];
     for (let i = 0; i < nSlots; i++) {
         const base = idxStart + i * SLOT_INDEX_ENTRY;
-        const offsetHigh = view.getUint32(base,     false);
-        const offsetLow  = view.getUint32(base + 4, false);
+        const offsetHigh = view.getUint32(base, false);
+        const offsetLow = view.getUint32(base + 4, false);
         const offset = offsetHigh * 2 ** 32 + offsetLow;
-        const compressedSize   = view.getUint32(base + 8,  false);
+        const compressedSize = view.getUint32(base + 8, false);
         const uncompressedSize = view.getUint32(base + 12, false);
         slots.push({ offset, compressedSize, uncompressedSize });
     }
 
-    return { unixTime, nRays, nGates, elevAngle, firstGateKm, gateWidthKm,
-             nSlots, azimuthsBuffer, slots };
+    return {
+        unixTime,
+        nRays,
+        nGates,
+        elevAngle,
+        firstGateKm,
+        gateWidthKm,
+        nSlots,
+        azimuthsBuffer,
+        slots,
+        embeddedNyquistMs,
+    };
 }
 
 function decodeSweepInWorker(
@@ -1550,11 +1598,34 @@ function resolveLevel3SrvMotionObjectKey(
     return pickNearestLevel3ObjectKey(unixTime, motionMap);
 }
 
+/** Reuse parsed N0S motion across time steps (SRV: same motion key is common while scrubbing). */
+const N0S_MOTION_CACHE_MAX = 128;
+const n0sMotionVectorCache = new Map<string, { speedMs: number; directionDeg: number }>();
+
+function getCachedN0sMotion(motionObjectKey: string) {
+    return n0sMotionVectorCache.get(motionObjectKey);
+}
+function setCachedN0sMotion(
+    motionObjectKey: string,
+    motion: { speedMs: number; directionDeg: number },
+) {
+    n0sMotionVectorCache.set(motionObjectKey, motion);
+    while (n0sMotionVectorCache.size > N0S_MOTION_CACHE_MAX) {
+        const first = n0sMotionVectorCache.keys().next().value as string | undefined;
+        if (first === undefined) break;
+        n0sMotionVectorCache.delete(first);
+    }
+}
+
 async function applyStormMotionFromN0sObjectKey(
     frame: DecodedRadarFrame,
     motionObjectKey: string,
     logLabel: string,
 ): Promise<DecodedRadarFrame> {
+    const cached = getCachedN0sMotion(motionObjectKey);
+    if (cached) {
+        return applyLevel3StormRelativeToFrame(frame, cached.speedMs, cached.directionDeg);
+    }
     const motionUrl = objectKeyToUrl(motionObjectKey, 'level3');
     try {
         const motionResp = await fetch(motionUrl);
@@ -1562,6 +1633,7 @@ async function applyStormMotionFromN0sObjectKey(
             const motionBuf = await motionResp.arrayBuffer();
             const motion = parseLevel3StormMotionFromBuffer(motionBuf);
             if (motion) {
+                setCachedN0sMotion(motionObjectKey, motion);
                 return applyLevel3StormRelativeToFrame(frame, motion.speedMs, motion.directionDeg);
             }
         }
@@ -1648,7 +1720,9 @@ export async function fetchAndParseArchive(
 
 // ── Level-2 two-request range path ───────────────────────────────────────
             // Request 1: fetch just the header + slot index to find byte offsets
-            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,
@@ -1659,7 +1733,21 @@ export async function fetchAndParseArchive(
                 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;
+            }
 
             // ── Step 2: find slot for this variable ─────────────────────
             let varList: string[];
@@ -1667,6 +1755,8 @@ export async function fetchAndParseArchive(
                 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 {
@@ -1688,17 +1778,44 @@ export async function fetchAndParseArchive(
             }
 
             // ── Step 3: fetch exactly the slot bytes ────────────────────
-            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}`,
-                },
-            });
-            if (!slotResp.ok && slotResp.status !== 206) {
+            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: Record<string, string> = {
+                'x-api-key': NEXRAD_ARCHIVE_API_KEY,
+                'Range': `bytes=${slot.offset}-${slotRangeEnd}`,
+            };
+            let slotResp = await fetch(url, { headers: slotHeaders });
+            let slotBuffer: ArrayBuffer;
+            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}`);
+                }
+                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();
 
             // ── Step 4: decode in worker ────────────────────────────────
             const sites = await loadNexradSites();
@@ -1709,6 +1826,7 @@ export async function fetchAndParseArchive(
             );
 
             if (!decoded) { setArchiveCache(cacheKey, null); return null; }
+            decoded = { ...decoded, embeddedNyquistMs: header.embeddedNyquistMs };
             const l2MotionKey = options?.level3MotionObjectKey;
             if (l2MotionKey && radarVariable === 'VEL') {
                 decoded = await applyStormMotionFromN0sObjectKey(