@aguacerowx/mapsgl 0.0.54 → 0.0.55

package/src/nexrad/radarArchiveCore.ts

@@ -19,19 +19,119 @@ import {
 import type { NexradSite } from './PreprocessedSweepParser.js';
 import { archiveCache, setArchiveCache, type DecodedRadarFrame } from './nexradArchiveCache.js';
 import { loadNexradSites } from './loadNexradSites.js';
+export { setNexradSitesJsonUrl, setNexradSitesFetchAuth } from './loadNexradSites.js';
 import { sampleNexradFrameAtLatLon } from './nexradCrossSectionSampleAtLatLon.js';
+import { decodeRadarSlotMessage, type DecodeSlotRequest } from './radarDecodeSlot.js';
+import { nexradArchiveDiag, redactApiKeyFromUrl } from './nexradArchiveDiag.js';
 
 // seek-bzip pulls in node-bzip paths that use `new Buffer()` as a global; browsers have no Buffer.
 if (typeof (globalThis as { Buffer?: typeof Buffer }).Buffer === 'undefined') {
     (globalThis as { Buffer: typeof Buffer }).Buffer = Buffer;
 }
 
+/** RN/Hermes has no global {@link DOMException}; keep AbortError semantics for fetch abort paths. */
+function createAbortError(message = 'Aborted'): Error {
+    const g = globalThis as typeof globalThis & { DOMException?: typeof DOMException };
+    if (typeof g.DOMException !== 'undefined') {
+        return new g.DOMException(message, 'AbortError');
+    }
+    const err = new Error(message);
+    err.name = 'AbortError';
+    return err;
+}
+
+function isAbortError(err: unknown): boolean {
+    if (err == null || typeof err !== 'object') return false;
+    return (err as Error).name === 'AbortError';
+}
+
 let NEXRAD_ARCHIVE_API_KEY = '';
+/** Same as {@link AguaceroCore} grid fetches: `x-app-identifier` on React Native when set. */
+let NEXRAD_ARCHIVE_BUNDLE_ID = '';
+
 export function setNexradArchiveApiKey(k: string) {
     NEXRAD_ARCHIVE_API_KEY = k || '';
 }
 
+export function setNexradArchiveBundleId(bundleId: string) {
+    NEXRAD_ARCHIVE_BUNDLE_ID = bundleId || '';
+}
+
+/** Match {@link AguaceroCore} `urlWithApiKeyParam` for the same CloudFront distribution. */
+function cloudFrontUrlWithApiKeyQuery(baseUrl: string): string {
+    if (!NEXRAD_ARCHIVE_API_KEY) return baseUrl;
+    const sep = baseUrl.includes('?') ? '&' : '?';
+    return `${baseUrl}${sep}apiKey=${NEXRAD_ARCHIVE_API_KEY}`;
+}
+
+/** Level-II: match AguaceroCore grid `fetch` headers (x-api-key, x-app-identifier on RN when bundleId set) plus Range. */
+function level2CloudFrontFetchHeaders(range: string | undefined): Record<string, string> {
+    const headers: Record<string, string> = {
+        'x-api-key': NEXRAD_ARCHIVE_API_KEY,
+    };
+    if (range !== undefined) {
+        headers['Range'] = range;
+    }
+    const g = globalThis as typeof globalThis & { navigator?: { product?: string } };
+    if (g.navigator?.product === 'ReactNative' && NEXRAD_ARCHIVE_BUNDLE_ID) {
+        headers['x-app-identifier'] = NEXRAD_ARCHIVE_BUNDLE_ID;
+    }
+    return headers;
+}
+
+type RadarDecodeWorkerResponse = {
+    type: 'DECODE_RESULT';
+    requestId: number;
+    gateData: Uint8Array | null;
+    nRays?: number;
+    nGates?: number;
+    stationLat?: number;
+    stationLon?: number;
+    firstGateKm?: number;
+    gateWidthKm?: number;
+    valueScale?: number;
+    valueOffset?: number;
+    rayBoundariesDeg?: Float32Array;
+    error?: string;
+};
+
+function shouldDecodeRadarOnMainThread(): boolean {
+    const g = globalThis as typeof globalThis & { navigator?: { product?: string } };
+    return typeof Worker === 'undefined' || g.navigator?.product === 'ReactNative';
+}
+
+/** Hermes/RN has no web Workers; mirror Worker.postMessage/onmessage on the JS thread. */
+class MainThreadRadarDecodeWorker implements Pick<Worker, 'postMessage' | 'onmessage' | 'onerror' | 'terminate'> {
+    onmessage: ((ev: MessageEvent<RadarDecodeWorkerResponse>) => void) | null = null;
+    onerror: ((ev: ErrorEvent) => void) | null = null;
+
+    postMessage(data: unknown): void {
+        const msg = data as DecodeSlotRequest;
+        if (!msg || msg.type !== 'DECODE_SLOT') return;
+        queueMicrotask(() => {
+            try {
+                const response = decodeRadarSlotMessage(msg);
+                this.onmessage?.({ data: response } as MessageEvent<RadarDecodeWorkerResponse>);
+            } catch (error) {
+                this.onmessage?.({
+                    data: {
+                        type: 'DECODE_RESULT',
+                        requestId: msg.requestId,
+                        gateData: null,
+                        error: error instanceof Error ? error.message : 'Main-thread radar decode failed',
+                    },
+                } as MessageEvent<RadarDecodeWorkerResponse>);
+            }
+        });
+    }
+
+    terminate(): void {}
+}
+
 function createRadarDecodeWorker(): Worker {
+    if (shouldDecodeRadarOnMainThread()) {
+        return new MainThreadRadarDecodeWorker() as unknown as Worker;
+    }
     return new Worker(new URL('./radarDecode.worker.bundled.js', import.meta.url), { type: 'module' });
 }
 
@@ -115,22 +215,6 @@ const inflightFetchMeta = new Map<
 >();
 let radarFetchRequestSeq = 0;
 
-type RadarDecodeWorkerResponse = {
-    type: 'DECODE_RESULT';
-    requestId: number;
-    gateData: Uint8Array | null;
-    nRays?: number;
-    nGates?: number;
-    stationLat?: number;
-    stationLon?: number;
-    firstGateKm?: number;
-    gateWidthKm?: number;
-    valueScale?: number;
-    valueOffset?: number;
-    rayBoundariesDeg?: Float32Array;
-    error?: string;
-};
-
 let radarDecodeWorkers: Worker[] = [];
 let radarDecodeRequestId = 0;
 const radarDecodePending = new Map<number, {
@@ -1544,7 +1628,7 @@ function decodeSweepInWorker(
     priority: 'display' | 'prefetch',
     signal?: AbortSignal,
 ): Promise<DecodedRadarFrame | null> {
-    if (signal?.aborted) return Promise.reject(new DOMException('Aborted', 'AbortError'));
+    if (signal?.aborted) return Promise.reject(createAbortError());
 
     const { worker } = getDecodeWorkerForPriority(priority);
     const requestId = ++radarDecodeRequestId;
@@ -1560,7 +1644,7 @@ function decodeSweepInWorker(
             radarDecodePending.delete(requestId);
             radarDecodeRequestMeta.delete(requestId);
             signal?.removeEventListener('abort', onAbort);
-            reject(new DOMException('Aborted', 'AbortError'));
+            reject(createAbortError());
         };
 
         radarDecodePending.set(requestId, {
@@ -1719,15 +1803,30 @@ export async function fetchAndParseArchive(
             }
 
 // ── Level-2 two-request range path ───────────────────────────────────────
+            const level2Url = cloudFrontUrlWithApiKeyQuery(url);
+            nexradArchiveDiag('level2.pipeline.start', {
+                objectKey,
+                radarVariable,
+                groupId,
+                apiKeyLen: NEXRAD_ARCHIVE_API_KEY.length,
+                bundleIdLen: NEXRAD_ARCHIVE_BUNDLE_ID.length,
+                urlNoSecret: redactApiKeyFromUrl(level2Url),
+            });
             // Request 1: fetch just the header + slot index to find byte offsets
             const azBlockBytes = LEVEL2_AZ_BLOCK_BYTES;
             const INDEX_FETCH_BYTES =
                 FILE_HDR_BYTES + azBlockBytes + LEVEL2_FILE_NYQUIST_BYTES + MAX_SLOTS * SLOT_INDEX_ENTRY;
-            const indexResp = await fetch(url, {
-                headers: {
-                    'x-api-key': NEXRAD_ARCHIVE_API_KEY,
-                    'Range': `bytes=0-${INDEX_FETCH_BYTES - 1}`,
-                },
+            nexradArchiveDiag('level2.index.fetch', {
+                objectKey,
+                byteRangeEnd: INDEX_FETCH_BYTES - 1,
+            });
+            const indexResp = await fetch(level2Url, {
+                headers: level2CloudFrontFetchHeaders(`bytes=0-${INDEX_FETCH_BYTES - 1}`),
+            });
+            nexradArchiveDiag('level2.index.response', {
+                objectKey,
+                status: indexResp.status,
+                ok: indexResp.ok,
             });
             if (!indexResp.ok && indexResp.status !== 206) {
                 throw new Error(`HTTP ${indexResp.status} fetching level2 index ${url}`);
@@ -1793,16 +1892,24 @@ export async function fetchAndParseArchive(
             }
 
             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 });
+            const slotHeaders = level2CloudFrontFetchHeaders(`bytes=${slot.offset}-${slotRangeEnd}`);
+            nexradArchiveDiag('level2.slot.fetch', {
+                objectKey,
+                slotIdx,
+                compressedSize: slot.compressedSize,
+                offset: slot.offset,
+            });
+            let slotResp = await fetch(level2Url, { headers: slotHeaders });
+            nexradArchiveDiag('level2.slot.response', {
+                objectKey,
+                status: slotResp.status,
+                ok: slotResp.ok,
+            });
             let slotBuffer: 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 } });
+                const fullResp = await fetch(level2Url, { headers: level2CloudFrontFetchHeaders(undefined) });
                 if (!fullResp.ok) {
                     throw new Error(`HTTP ${fullResp.status} full fetch after 416 for level2 ${url}`);
                 }
@@ -1818,6 +1925,7 @@ export async function fetchAndParseArchive(
             }
 
             // ── Step 4: decode in worker ────────────────────────────────
+            nexradArchiveDiag('level2.decode.start', { objectKey, radarVariable });
             const sites = await loadNexradSites();
             let decoded = await decodeSweepInWorker(
                 objectKey, slotBuffer, header, sites,
@@ -1836,11 +1944,22 @@ export async function fetchAndParseArchive(
                 );
             }
             setArchiveCache(cacheKey, decoded);
+            nexradArchiveDiag('level2.decode.done', {
+                objectKey,
+                radarVariable,
+                nRays: decoded.nRays ?? null,
+                nGates: decoded.nGates ?? null,
+            });
             return decoded;
         } catch (err) {
-            if (err instanceof DOMException && err.name === 'AbortError') {
+            if (isAbortError(err)) {
                 return null;
             }
+            nexradArchiveDiag('fetchAndParseArchive.failed', {
+                objectKey,
+                radarSource,
+                message: err instanceof Error ? err.message : String(err),
+            });
             console.error(`[RadarLayer] fetchAndParseArchive failed for ${objectKey}:`, err);
             return null;
         } finally {

package/src/nexrad/radarDecode.worker.bundled.js

@@ -619,7 +619,7 @@ function decompress(dat, buf) {
   return cct(bufs, ol);
 }
 
-// src/nexrad/radarDecode.worker.ts
+// src/nexrad/radarDecodeSlot.ts
 var SLOT_HDR_BYTES = 28;
 function isZstd(bytes) {
   return bytes.length >= 4 && bytes[0] === 40 && bytes[1] === 181 && bytes[2] === 47 && bytes[3] === 253;
@@ -657,9 +657,7 @@ function buildRayBoundariesDeg(azimuths) {
   boundaries[nRays] = azimuths[nRays - 1] + avgSpacing / 2;
   return boundaries;
 }
-self.onmessage = (event) => {
-  const data = event.data;
-  if (!data || data.type !== "DECODE_SLOT") return;
+function decodeRadarSlotMessage(data) {
   const {
     requestId,
     objectKey,
@@ -671,137 +669,143 @@ self.onmessage = (event) => {
     azimuthsBuffer,
     sites
   } = data;
-  try {
-    const compressed = new Uint8Array(slotBuffer);
-    if (!isZstd(compressed)) {
-      self.postMessage({
-        type: "DECODE_RESULT",
-        requestId,
-        gateData: null,
-        error: `Slot for ${objectKey} is not valid zstd`
-      });
-      return;
-    }
-    const decompressed = decompress(compressed);
-    const buffer = decompressed.buffer.slice(
-      decompressed.byteOffset,
-      decompressed.byteOffset + decompressed.byteLength
-    );
-    const view = new DataView(buffer);
-    const valueScale = view.getFloat32(0, false);
-    const valueOffset = view.getFloat32(4, false);
-    const present = view.getUint32(8, false);
-    if (present === 0) {
-      self.postMessage({
-        type: "DECODE_RESULT",
-        requestId,
-        gateData: null,
-        error: `Slot for ${objectKey} marked not present`
-      });
-      return;
-    }
-    const slotNRays = view.getUint16(12, false);
-    const slotNGates = view.getUint16(14, false);
-    const gateBytes = buffer.byteLength - SLOT_HDR_BYTES;
-    const expectedGates = slotNRays * slotNGates;
-    const bytesPerGate = gateBytes / expectedGates;
-    if (bytesPerGate !== 1 && bytesPerGate !== 2 && bytesPerGate !== 4) {
-      self.postMessage({
-        type: "DECODE_RESULT",
-        requestId,
-        gateData: null,
-        error: `Unexpected bytesPerGate=${bytesPerGate} for ${objectKey}`
-      });
-      return;
-    }
-    const keyParts = parseObjectKey(objectKey);
-    if (!keyParts) {
-      self.postMessage({
-        type: "DECODE_RESULT",
-        requestId,
-        gateData: null,
-        error: `Unable to parse station from key: ${objectKey}`
-      });
-      return;
-    }
-    const site = sites.find((s) => s.id === keyParts.stationId);
-    if (!site) {
-      self.postMessage({
-        type: "DECODE_RESULT",
-        requestId,
-        gateData: null,
-        error: `Station "${keyParts.stationId}" not found`
-      });
-      return;
+  const compressed = new Uint8Array(slotBuffer);
+  if (!isZstd(compressed)) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Slot for ${objectKey} is not valid zstd`
+    };
+  }
+  const decompressed = decompress(compressed);
+  const buffer = decompressed.buffer.slice(
+    decompressed.byteOffset,
+    decompressed.byteOffset + decompressed.byteLength
+  );
+  const view = new DataView(buffer);
+  const valueScale = view.getFloat32(0, false);
+  const valueOffset = view.getFloat32(4, false);
+  const present = view.getUint32(8, false);
+  if (present === 0) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Slot for ${objectKey} marked not present`
+    };
+  }
+  const slotNRays = view.getUint16(12, false);
+  const slotNGates = view.getUint16(14, false);
+  const gateBytes = buffer.byteLength - SLOT_HDR_BYTES;
+  const expectedGates = slotNRays * slotNGates;
+  const bytesPerGate = gateBytes / expectedGates;
+  if (bytesPerGate !== 1 && bytesPerGate !== 2 && bytesPerGate !== 4) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Unexpected bytesPerGate=${bytesPerGate} for ${objectKey}`
+    };
+  }
+  const keyParts = parseObjectKey(objectKey);
+  if (!keyParts) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Unable to parse station from key: ${objectKey}`
+    };
+  }
+  const site = sites.find((s) => s.id === keyParts.stationId);
+  if (!site) {
+    return {
+      type: "DECODE_RESULT",
+      requestId,
+      gateData: null,
+      error: `Station "${keyParts.stationId}" not found`
+    };
+  }
+  const azimuths = new Float32Array(slotNRays);
+  const azView = new DataView(azimuthsBuffer);
+  const headerNRays = azimuthsBuffer.byteLength / 4;
+  for (let i = 0; i < slotNRays; i++) {
+    if (i < headerNRays) {
+      azimuths[i] = azView.getFloat32(i * 4, false);
+    } else {
+      const prevAz = i > 0 ? azimuths[i - 1] : 0;
+      azimuths[i] = (prevAz + 360 / slotNRays) % 360;
     }
-    const azimuths = new Float32Array(slotNRays);
-    const azView = new DataView(azimuthsBuffer);
-    const headerNRays = azimuthsBuffer.byteLength / 4;
-    for (let i = 0; i < slotNRays; i++) {
-      if (i < headerNRays) {
-        azimuths[i] = azView.getFloat32(i * 4, false);
-      } else {
-        const prevAz = i > 0 ? azimuths[i - 1] : 0;
-        azimuths[i] = (prevAz + 360 / slotNRays) % 360;
+  }
+  const rayBoundariesDeg = buildRayBoundariesDeg(azimuths);
+  const gateCount = slotNRays * slotNGates;
+  const gateDataCopy = new Uint8Array(slotNRays * slotNGates * 2);
+  const outView = new DataView(gateDataCopy.buffer);
+  if (bytesPerGate === 1) {
+    const raw = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount);
+    for (let ray = 0; ray < slotNRays; ray++) {
+      let prev = 0;
+      for (let g = 0; g < slotNGates; g++) {
+        const idx = ray * slotNGates + g;
+        const delta = raw[idx];
+        const val = prev + delta & 255;
+        prev = val;
+        if (val === 0) {
+          outView.setInt16(idx * 2, -32768, false);
+        } else {
+          outView.setInt16(idx * 2, val, false);
+        }
       }
     }
-    const rayBoundariesDeg = buildRayBoundariesDeg(azimuths);
-    const gateCount = slotNRays * slotNGates;
-    const gateDataCopy = new Uint8Array(slotNRays * slotNGates * 2);
-    const outView = new DataView(gateDataCopy.buffer);
-    if (bytesPerGate === 1) {
-      const raw = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount);
-      for (let ray = 0; ray < slotNRays; ray++) {
-        let prev = 0;
-        for (let g = 0; g < slotNGates; g++) {
-          const idx = ray * slotNGates + g;
-          const delta = raw[idx];
-          const val = prev + delta & 255;
-          prev = val;
-          if (val === 0) {
-            outView.setInt16(idx * 2, -32768, false);
-          } else {
-            outView.setInt16(idx * 2, val, false);
-          }
-        }
+  } else {
+    const rawBytes = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount * 2);
+    for (let ray = 0; ray < slotNRays; ray++) {
+      let prev = 0;
+      for (let g = 0; g < slotNGates; g++) {
+        const idx = ray * slotNGates + g;
+        const hi = rawBytes[idx * 2];
+        const lo = rawBytes[idx * 2 + 1];
+        const delta = (hi << 8 | lo) << 16 >> 16;
+        const val = prev + delta | 0;
+        prev = val;
+        outView.setInt16(idx * 2, val, false);
       }
+    }
+  }
+  return {
+    type: "DECODE_RESULT",
+    requestId,
+    gateData: gateDataCopy,
+    stationLat: site.lat,
+    stationLon: site.lon,
+    firstGateKm,
+    gateWidthKm,
+    valueScale,
+    valueOffset,
+    rayBoundariesDeg,
+    nRays: slotNRays,
+    nGates: slotNGates
+  };
+}
+
+// src/nexrad/radarDecode.worker.ts
+self.onmessage = (event) => {
+  const data = event.data;
+  if (!data || data.type !== "DECODE_SLOT") return;
+  try {
+    const response = decodeRadarSlotMessage(data);
+    if (response.gateData && response.rayBoundariesDeg) {
+      self.postMessage(response, [
+        response.gateData.buffer,
+        response.rayBoundariesDeg.buffer
+      ]);
     } else {
-      const rawBytes = new Uint8Array(buffer, SLOT_HDR_BYTES, gateCount * 2);
-      for (let ray = 0; ray < slotNRays; ray++) {
-        let prev = 0;
-        for (let g = 0; g < slotNGates; g++) {
-          const idx = ray * slotNGates + g;
-          const hi = rawBytes[idx * 2];
-          const lo = rawBytes[idx * 2 + 1];
-          const delta = (hi << 8 | lo) << 16 >> 16;
-          const val = prev + delta | 0;
-          prev = val;
-          outView.setInt16(idx * 2, val, false);
-        }
-      }
+      self.postMessage(response);
     }
-    const response = {
-      type: "DECODE_RESULT",
-      requestId,
-      gateData: gateDataCopy,
-      stationLat: site.lat,
-      stationLon: site.lon,
-      firstGateKm,
-      gateWidthKm,
-      valueScale,
-      valueOffset,
-      rayBoundariesDeg,
-      nRays: slotNRays,
-      nGates: slotNGates
-    };
-    self.postMessage(response, [
-      gateDataCopy.buffer,
-      rayBoundariesDeg.buffer
-    ]);
   } catch (error) {
     self.postMessage({
       type: "DECODE_RESULT",
-      requestId,
+      requestId: data.requestId,
       gateData: null,
       error: error instanceof Error ? error.message : "Unknown worker error"
     });