@aguacerowx/mapsgl 0.0.50 → 0.0.52

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(

package/src/nwsAlertsSupport.js

@@ -1190,6 +1190,56 @@ export function cloneNwwsFeatureCollectionStrippingVolatile(data) {
     };
 }
 
+/**
+ * Parse `properties.parameters` (JSON string or object from NWWS / CAP-style extensions).
+ * @param {unknown} raw
+ * @returns {Record<string, unknown>|null}
+ */
+function parseNwsParametersJson(raw) {
+    if (raw == null) return null;
+    if (typeof raw === 'object' && !Array.isArray(raw)) return /** @type {Record<string, unknown>} */ (raw);
+    if (typeof raw === 'string') {
+        try {
+            const o = JSON.parse(raw);
+            return o && typeof o === 'object' && !Array.isArray(o) ? o : null;
+        } catch {
+            return null;
+        }
+    }
+    return null;
+}
+
+/**
+ * Human-oriented subset of `parameters` for severe wx / common warning types (hail, wind, radar source).
+ * @param {Record<string, unknown>|null} pObj
+ * @returns {Record<string, string> | null}
+ */
+function buildHazardDetailsFromParameters(pObj) {
+    if (!pObj || typeof pObj !== 'object') return null;
+    /** @type {Record<string, string>} */
+    const out = {};
+    const set = (key, from) => {
+        const v = pObj[from];
+        if (v != null && String(v).trim() !== '') out[key] = String(v);
+    };
+    set('source', 'source');
+    set('maxHailSize', 'max_hail_size');
+    set('maxWindGust', 'max_wind_gust');
+    set('damageThreat', 'damage_threat');
+    set('wmo', 'wmo');
+    if (pObj.tornado_detection != null && String(pObj.tornado_detection).trim() !== '')
+        out.tornadoDetection = String(pObj.tornado_detection);
+    if (pObj.flood_detection != null && String(pObj.flood_detection).trim() !== '')
+        out.floodDetection = String(pObj.flood_detection);
+    return Object.keys(out).length ? out : null;
+}
+
+/**
+ * Normalized payload for `nws:alert:click`. Top-level fields are derived from `feature.properties`
+ * so you rarely need the duplicate `properties` object (kept for advanced / forward-compatible use).
+ *
+ * @param {GeoJSON.Feature|{ properties?: Record<string, unknown> }} feature
+ */
 export function buildAlertClickPayload(feature) {
     const properties = feature?.properties ? { ...feature.properties } : {};
     const eventName = getNwsAlertEventLabelFromProperties(properties);
@@ -1204,9 +1254,10 @@ export function buildAlertClickPayload(feature) {
     if (!Array.isArray(tags)) {
         tags = tags != null ? [String(tags)] : [];
     }
-    const headline = properties.headline != null ? String(properties.headline) : '';
     const name =
-        headline ||
+        (properties.headline != null && String(properties.headline).trim() !== ''
+            ? String(properties.headline)
+            : '') ||
         eventName ||
         (properties.event != null ? String(properties.event) : '') ||
         (properties.event_name != null ? String(properties.event_name) : '');
@@ -1216,8 +1267,6 @@ export function buildAlertClickPayload(feature) {
             : properties.raw_text != null
               ? String(properties.raw_text)
               : '';
-    const summary = properties.summary != null ? String(properties.summary) : '';
-    const instruction = properties.instruction != null ? String(properties.instruction) : '';
 
     const startUnix =
         typeof properties.start_unix === 'number'
@@ -1232,17 +1281,29 @@ export function buildAlertClickPayload(feature) {
             ? properties.active_start_unix
             : getNwsActiveStartUnix(properties);
 
+    const parametersParsed = parseNwsParametersJson(properties.parameters);
+    const hazardDetails = buildHazardDetailsFromParameters(parametersParsed);
+
     return {
         name,
         eventName,
-        headline,
-        summary,
         description,
-        instruction,
         tags,
         startUnix,
         endUnix,
         activeStartUnix,
+        /** ISO-ish strings from the feed (see also unix fields above). */
+        issued: properties.issued != null ? String(properties.issued) : '',
+        updatedAt: properties.updated_at != null ? String(properties.updated_at) : '',
+        expiresAt: properties.expires != null ? String(properties.expires) : '',
+        alertId: properties.alert_id != null ? String(properties.alert_id) : '',
+        office: properties.office != null ? String(properties.office) : '',
+        nwsProductKey: properties.nws_product_key != null ? String(properties.nws_product_key) : '',
+        /** Parsed `properties.parameters` JSON when present (hail/wind/source keys vary by product). */
+        parametersParsed,
+        /** Short labels for SV / similar products: source, maxHailSize, maxWindGust, damageThreat, … */
+        hazardDetails,
+        /** Same as `feature.properties` — prefer top-level fields above when possible. */
         properties,
     };
 }