@aguacerowx/javascript-sdk 0.0.24 → 0.0.26

package/dist/satellite_support.js

@@ -0,0 +1,395 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TIMELINE_DURATION_MAX_HOURS = exports.TIMELINE_DURATION_HOUR_VALUES = exports.SECTOR_CODE_MAP = exports.SATELLITE_FRAMES_URL = exports.SATELLITE_DURATION_CONFIG = exports.GOES_SATELLITE_CHANNEL_LABELS = exports.GOES_SATELLITE_CHANNELS = exports.GOES_EAST_SATELLITE_SECTORS = void 0;
+exports.buildSatelliteTimelineForSelection = buildSatelliteTimelineForSelection;
+exports.calculateUnixTimeFromSatelliteKey = calculateUnixTimeFromSatelliteKey;
+exports.formatTimelineDurationValue = formatTimelineDurationValue;
+exports.getAllGoesEastSatelliteSelections = getAllGoesEastSatelliteSelections;
+exports.getDefaultSatelliteDurationOption = getDefaultSatelliteDurationOption;
+exports.normalizeTimelineDurationValue = normalizeTimelineDurationValue;
+exports.parseTimelineDurationHours = parseTimelineDurationHours;
+exports.resolveSatelliteDurationOption = resolveSatelliteDurationOption;
+exports.resolveSatelliteS3FileName = resolveSatelliteS3FileName;
+exports.resolveSatelliteSectorLabel = resolveSatelliteSectorLabel;
+/**
+ * Satellite listing / timeline helpers aligned with aguacero-frontend (ActiveTimeContext + satelliteAvailability).
+ * Used by AguaceroCore for GOES-East WebGL satellite mode.
+ */
+
+const SATELLITE_FRAMES_URL = exports.SATELLITE_FRAMES_URL = 'https://rhnq3edhcry5n6nljn6my4o3h40zwxze.lambda-url.us-east-2.on.aws/';
+
+/** Same sector labels as production bundle / ActiveTimeContext SECTOR_CODE_MAP (inverse). */
+const GOES_EAST_SATELLITE_SECTORS = exports.GOES_EAST_SATELLITE_SECTORS = ['GOES-EAST CONUS', 'GOES-EAST FULL DISK', 'GOES-EAST MESOSCALE 1', 'GOES-EAST MESOSCALE 2'];
+const SECTOR_SYNONYM_TO_LABEL = {
+  conus: 'GOES-EAST CONUS',
+  full_disk: 'GOES-EAST FULL DISK',
+  fulldisk: 'GOES-EAST FULL DISK',
+  mesoscale_1: 'GOES-EAST MESOSCALE 1',
+  mesoscale1: 'GOES-EAST MESOSCALE 1',
+  m1: 'GOES-EAST MESOSCALE 1',
+  mesoscale_2: 'GOES-EAST MESOSCALE 2',
+  mesoscale2: 'GOES-EAST MESOSCALE 2',
+  m2: 'GOES-EAST MESOSCALE 2'
+};
+
+/**
+ * Normalizes a sector argument to the listing sector label (middle segment; must match archive paths).
+ * Accepts short tokens (<code>conus</code>, <code>full_disk</code>, …), synonyms (<code>m1</code>, <code>fulldisk</code>, …), or full labels (passthrough for West / custom feeds).
+ * @param {string} [sector]
+ * @returns {string}
+ */
+function resolveSatelliteSectorLabel(sector) {
+  if (sector == null || sector === '') return 'GOES-EAST CONUS';
+  const raw = String(sector).trim();
+  const norm = raw.toLowerCase().replace(/[\s-]+/g, '_');
+  if (SECTOR_SYNONYM_TO_LABEL[norm]) return SECTOR_SYNONYM_TO_LABEL[norm];
+  if (GOES_EAST_SATELLITE_SECTORS.includes(raw)) return raw;
+  return raw;
+}
+
+/** Flat channel ids matching CHANNEL_CATEGORIES in frontend dictionaries. */
+const GOES_SATELLITE_CHANNELS = exports.GOES_SATELLITE_CHANNELS = [...['true_color', 'geocolor', 'ntmicro', 'day_cloud_phase', 'day_land_cloud_fire', 'air_mass', 'sandwich', 'simple_water_vapor', 'dust', 'fire_temperature'], 'C01', 'C02', 'C03', 'C04', 'C05', 'C06', 'C07', 'C08', 'C09', 'C10', 'C11', 'C12', 'C13', 'C14', 'C15', 'C16'];
+
+/**
+ * Human-readable labels for {@link GOES_SATELLITE_CHANNELS}, aligned with aguacero-frontend `CHANNEL_LABELS`.
+ */
+const GOES_SATELLITE_CHANNEL_LABELS = exports.GOES_SATELLITE_CHANNEL_LABELS = {
+  true_color: 'True Color',
+  ntmicro: 'Night Microphysics',
+  day_cloud_phase: 'Day Cloud Phase',
+  day_land_cloud_fire: 'Natural Color Fire',
+  air_mass: 'Air Mass',
+  sandwich: 'Sandwich',
+  simple_water_vapor: 'Simple Water Vapor',
+  dust: 'Dust',
+  geocolor: 'Geocolor',
+  fire_temperature: 'Fire Temperature',
+  C01: 'Blue - Visible',
+  C02: 'Red - Visible',
+  C03: 'Veggie - Near IR',
+  C04: 'Cirrus - Near IR',
+  C05: 'Snow/Ice - Near IR',
+  C06: 'Cloud Particle - Near IR',
+  C07: 'Shortwave Window - IR',
+  C08: 'Upper-Level Water Vapor - IR',
+  C09: 'Mid-Level Water Vapor - IR',
+  C10: 'Lower-Level Water Vapor - IR',
+  C11: 'Cloud Top - IR',
+  C12: 'Ozone - IR',
+  C13: 'Clean Longwave Window - IR',
+  C14: 'Longwave Window - IR',
+  C15: 'Dirty Longwave Window - IR',
+  C16: 'CO2 Longwave - IR'
+};
+const SECTOR_CODE_MAP = exports.SECTOR_CODE_MAP = {
+  'GOES-EAST CONUS': 'C',
+  'GOES-EAST FULL DISK': 'F',
+  'GOES-EAST MESOSCALE 1': 'M1',
+  'GOES-EAST MESOSCALE 2': 'M2'
+};
+const LUMPED_MULTIBAND_SATELLITE_SECTORS = new Set(['GOES-EAST CONUS', 'GOES-EAST FULL DISK']);
+
+/** Uppercase RGB channel tokens as in production (CHANNEL_CATEGORIES.RGB). */
+const SATELLITE_RGB_PRODUCT_UPPER = new Set(['TRUE_COLOR', 'GEOCOLOR', 'NTMICRO', 'DAY_CLOUD_PHASE', 'DAY_LAND_CLOUD_FIRE', 'AIR_MASS', 'SANDWICH', 'SIMPLE_WATER_VAPOR', 'DUST', 'FIRE_TEMPERATURE']);
+
+/**
+ * Maximum timeline window length in hours for satellite, MRMS, and NEXRAD. Values are clamped to (0, this].
+ */
+const TIMELINE_DURATION_MAX_HOURS = exports.TIMELINE_DURATION_MAX_HOURS = 12;
+
+/**
+ * Preset hour buttons (UI). Any positive duration ≤ {@link TIMELINE_DURATION_MAX_HOURS} is valid via {@link formatTimelineDurationValue}.
+ */
+const TIMELINE_DURATION_HOUR_VALUES = exports.TIMELINE_DURATION_HOUR_VALUES = ['1', '4', '6', '12'];
+const LEGACY_SATELLITE_DURATION_ALIASES = {
+  '0.5': '1'
+};
+
+/** Tier keys used in SATELLITE_DURATION_CONFIG (frontend dictionaries). */
+const SATELLITE_DURATION_CONFIG = exports.SATELLITE_DURATION_CONFIG = {
+  CONUS: {
+    basic: [{
+      label: '1 Hr',
+      value: '1',
+      interval: 300
+    }, {
+      label: '4 Hr',
+      value: '4',
+      interval: 300
+    }, {
+      label: '6 Hr',
+      value: '6',
+      interval: 300
+    }, {
+      label: '12 Hr',
+      value: '12',
+      interval: 300
+    }]
+  },
+  FULL_DISK: {
+    basic: [{
+      label: '1 Hr',
+      value: '1',
+      interval: 600
+    }, {
+      label: '4 Hr',
+      value: '4',
+      interval: 600
+    }, {
+      label: '6 Hr',
+      value: '6',
+      interval: 600
+    }, {
+      label: '12 Hr',
+      value: '12',
+      interval: 600
+    }]
+  },
+  MESOSCALE: {
+    basic: [{
+      label: '1 Hr',
+      value: '1',
+      interval: 120
+    }, {
+      label: '4 Hr',
+      value: '4',
+      interval: 120
+    }, {
+      label: '6 Hr',
+      value: '6',
+      interval: 120
+    }, {
+      label: '12 Hr',
+      value: '12',
+      interval: 120
+    }]
+  }
+};
+
+/**
+ * Parses a user duration to hours, then clamps to a positive value not exceeding {@link TIMELINE_DURATION_MAX_HOURS}.
+ * @param {string|number} value
+ * @returns {number}
+ */
+function parseTimelineDurationHours(value) {
+  let s = value == null ? '1' : String(value).trim();
+  s = LEGACY_SATELLITE_DURATION_ALIASES[s] || s;
+  const n = Number(s);
+  if (!Number.isFinite(n) || n <= 0) return 1;
+  if (n > TIMELINE_DURATION_MAX_HOURS) return TIMELINE_DURATION_MAX_HOURS;
+  return n;
+}
+
+/**
+ * Canonical string for AguaceroCore state (stable for equality checks). Supports fractional hours (e.g. <code>'2.5'</code>).
+ * @param {string|number} value
+ * @returns {string}
+ */
+function formatTimelineDurationValue(value) {
+  const n = parseTimelineDurationHours(value);
+  if (Math.abs(n - Math.round(n)) < 1e-6) return String(Math.round(n));
+  return String(Math.round(n * 10000) / 10000);
+}
+
+/** @returns {string} Same as {@link formatTimelineDurationValue} (backward-compatible name). */
+function normalizeTimelineDurationValue(value) {
+  return formatTimelineDurationValue(value);
+}
+
+/**
+ * Picks a preset GOES duration option when one matches; otherwise builds a custom option using the same cadence as the 1&nbsp;hr preset for that sector/tier.
+ * @param {string} sectorName - e.g. <code>GOES-EAST CONUS</code>
+ * @param {string} [tier='basic']
+ * @param {string|number} durationValue
+ * @returns {{ label: string, value: string, interval: number }}
+ */
+function resolveSatelliteDurationOption(sectorName, tier, durationValue) {
+  var _SATELLITE_DURATION_C, _tierConfig$find;
+  let sectorType = 'CONUS';
+  if (sectorName.includes('FULL DISK')) sectorType = 'FULL_DISK';else if (sectorName.includes('MESOSCALE')) sectorType = 'MESOSCALE';
+  const t = tier || 'basic';
+  const tierConfig = ((_SATELLITE_DURATION_C = SATELLITE_DURATION_CONFIG[sectorType]) === null || _SATELLITE_DURATION_C === void 0 ? void 0 : _SATELLITE_DURATION_C[t]) || SATELLITE_DURATION_CONFIG.CONUS.basic;
+  const key = formatTimelineDurationValue(durationValue);
+  const preset = tierConfig.find(o => String(o.value) === String(key));
+  if (preset) return preset;
+  const interval = ((_tierConfig$find = tierConfig.find(o => o.value === '1')) === null || _tierConfig$find === void 0 ? void 0 : _tierConfig$find.interval) || 300;
+  return {
+    label: `${key} Hr`,
+    value: key,
+    interval
+  };
+}
+function getDefaultSatelliteDurationOption(sectorName, tier = 'basic') {
+  var _SATELLITE_DURATION_C2;
+  let sectorType = 'CONUS';
+  if (sectorName.includes('FULL DISK')) sectorType = 'FULL_DISK';else if (sectorName.includes('MESOSCALE')) sectorType = 'MESOSCALE';
+  const tierConfig = ((_SATELLITE_DURATION_C2 = SATELLITE_DURATION_CONFIG[sectorType]) === null || _SATELLITE_DURATION_C2 === void 0 ? void 0 : _SATELLITE_DURATION_C2[tier]) || SATELLITE_DURATION_CONFIG.CONUS.basic;
+  return tierConfig.find(o => o.value === '1') || tierConfig[0];
+}
+function calculateUnixTimeFromSatelliteKey(fileKey) {
+  try {
+    const match = fileKey.match(/_(\d{10})(?:\.ktx2)?$/);
+    if (match) return parseInt(match[1], 10);
+    const oldMatch = fileKey.match(/_s(\d{4})(\d{3})(\d{2})(\d{2})(\d{2})/);
+    if (oldMatch) {
+      const [, year, dayOfYear, hour, minute, second] = oldMatch.map(Number);
+      const date = new Date(Date.UTC(year, 0, 1));
+      date.setUTCDate(dayOfYear);
+      date.setUTCHours(hour, minute, second, 0);
+      return date.getTime() / 1000;
+    }
+    return 0;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * @param {{ satelliteInstrumentId: string, satelliteSectorLabel: string, satelliteChannel: string }} selection
+ * @param {string[]} allFiles S3 keys from satellite listing API
+ * @param {{ value: string, interval: number }} durationOption
+ */
+function buildSatelliteTimelineForSelection(selection, allFiles, durationOption) {
+  const satelliteName = selection === null || selection === void 0 ? void 0 : selection.satelliteInstrumentId;
+  const categoryName = selection === null || selection === void 0 ? void 0 : selection.satelliteSectorLabel;
+  const channelName = selection === null || selection === void 0 ? void 0 : selection.satelliteChannel;
+  if (!satelliteName || !categoryName || !channelName) {
+    return {
+      unixTimes: [],
+      fileList: [],
+      timeToFileMap: {}
+    };
+  }
+  const SECTOR_CODE_MAP_LOCAL = {
+    'GOES-EAST CONUS': 'C',
+    'GOES-EAST FULL DISK': 'F',
+    'GOES-EAST MESOSCALE 1': 'M1',
+    'GOES-EAST MESOSCALE 2': 'M2'
+  };
+  const satelliteNum = satelliteName.replace('GOES', '').replace('-EAST', '').replace('-WEST', '');
+  const satId = `G${satelliteNum}`;
+  const sectorCode = SECTOR_CODE_MAP_LOCAL[categoryName] || 'C';
+  let sectorType = 'CONUS';
+  if (categoryName.includes('FULL DISK')) sectorType = 'FULL_DISK';else if (categoryName.includes('MESOSCALE')) sectorType = 'MESOSCALE';
+  const intervalSeconds = (durationOption === null || durationOption === void 0 ? void 0 : durationOption.interval) || 300;
+  const durationHours = durationOption !== null && durationOption !== void 0 && durationOption.value ? parseFloat(durationOption.value) : 1;
+  const filePrefix = `${sectorCode}_${satId}_`;
+  let searchProduct = channelName.toUpperCase();
+  if (!/^C\d{2}$/.test(searchProduct)) {
+    if (SATELLITE_RGB_PRODUCT_UPPER.has(searchProduct)) {
+      searchProduct = LUMPED_MULTIBAND_SATELLITE_SECTORS.has(categoryName) ? 'MULTI' : searchProduct;
+    } else {
+      searchProduct = 'MULTI';
+    }
+  }
+  const matchString = `${filePrefix}${searchProduct}`;
+  let relevantFiles = allFiles.filter(file => file.startsWith(matchString));
+  if (relevantFiles.length === 0) {
+    return {
+      unixTimes: [],
+      fileList: [],
+      timeToFileMap: {}
+    };
+  }
+  relevantFiles.sort((a, b) => {
+    const timeA = calculateUnixTimeFromSatelliteKey(a);
+    const timeB = calculateUnixTimeFromSatelliteKey(b);
+    return timeA - timeB;
+  });
+  let cutoffTime = 0;
+  if (durationHours > 0) {
+    const latestTime = calculateUnixTimeFromSatelliteKey(relevantFiles[relevantFiles.length - 1]);
+    cutoffTime = latestTime - durationHours * 3600;
+  }
+  let processedFiles = relevantFiles.filter(f => calculateUnixTimeFromSatelliteKey(f) >= cutoffTime);
+  if (intervalSeconds > 0 && processedFiles.length > 0) {
+    const intervalMinutes = intervalSeconds / 60;
+    if (sectorType === 'MESOSCALE') {
+      processedFiles = processedFiles.filter(file => {
+        if (intervalMinutes <= 1.1) return true;
+        const t = calculateUnixTimeFromSatelliteKey(file);
+        const date = new Date(t * 1000);
+        const minutes = date.getUTCMinutes();
+        return minutes % intervalMinutes === 0;
+      });
+    } else {
+      if (intervalSeconds >= 300) {
+        processedFiles = processedFiles.filter(file => {
+          if (Math.abs(intervalMinutes - 5) < 0.1) return true;
+          const t = calculateUnixTimeFromSatelliteKey(file);
+          const minutes = new Date(t * 1000).getUTCMinutes();
+          const remainder = minutes % intervalMinutes;
+          const distToInterval = Math.min(remainder, intervalMinutes - remainder);
+          return distToInterval < 2.5;
+        });
+      } else {
+        processedFiles = processedFiles.filter(file => {
+          const t = calculateUnixTimeFromSatelliteKey(file);
+          const minutes = new Date(t * 1000).getUTCMinutes();
+          return minutes % intervalMinutes === 0;
+        });
+      }
+    }
+    if (processedFiles.length === 0 && relevantFiles.length > 0) {
+      processedFiles = relevantFiles.slice(-1);
+    }
+  }
+  const unixTimes = [];
+  const timeToFileMap = {};
+  processedFiles.forEach(file => {
+    const unixTime = calculateUnixTimeFromSatelliteKey(file);
+    if (unixTime > 0) {
+      unixTimes.push(unixTime);
+      timeToFileMap[unixTime] = file;
+    }
+  });
+
+  // Chronological (oldest → newest): matches standard time sliders (earlier left, later right).
+  unixTimes.sort((a, b) => a - b);
+  return {
+    unixTimes,
+    fileList: processedFiles,
+    timeToFileMap
+  };
+}
+
+/**
+ * All GOES-East spacecraft / sector / channel combinations the SDK knows (same naming as production).
+ * @param {string} [satelliteInstrumentId='GOES19-EAST']
+ * @returns {Array<{ satelliteInstrumentId: string, satelliteSectorLabel: string, satelliteChannel: string }>}
+ */
+function getAllGoesEastSatelliteSelections(satelliteInstrumentId = 'GOES19-EAST') {
+  const out = [];
+  for (const sector of GOES_EAST_SATELLITE_SECTORS) {
+    for (const ch of GOES_SATELLITE_CHANNELS) {
+      out.push({
+        satelliteInstrumentId,
+        satelliteSectorLabel: sector,
+        satelliteChannel: ch
+      });
+    }
+  }
+  return out;
+}
+
+/**
+ * @param {string} satelliteChannel — band or RGB id (third segment of the archive descriptor)
+ */
+function resolveSatelliteS3FileName(satelliteChannel, timeToFileMap, satelliteTimestamp) {
+  const fileFromMap = timeToFileMap === null || timeToFileMap === void 0 ? void 0 : timeToFileMap[satelliteTimestamp];
+  if (fileFromMap) return fileFromMap;
+  const channelName = satelliteChannel;
+  const channelNameUpper = String(channelName).toUpperCase();
+  let name = fileFromMap || '';
+  if (!name && satelliteTimestamp != null) {
+    const suffix = `_${String(Math.floor(Number(satelliteTimestamp)))}`;
+    const multiName = Object.values(timeToFileMap || {}).find(f => f.includes('MULTI') && f.includes(suffix));
+    if (multiName) {
+      name = multiName.replace('MULTI', channelNameUpper);
+    }
+  }
+  return name;
+}

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@aguacerowx/javascript-sdk",
-  "version": "0.0.24",
+  "version": "0.0.26",
+  "type": "module",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -30,6 +31,36 @@
       "import": "./src/nexradTiltCoalesce.js",
       "require": "./src/nexradTiltCoalesce.js",
       "default": "./src/nexradTiltCoalesce.js"
+    },
+    "./satellite_support.js": {
+      "import": "./src/satellite_support.js",
+      "require": "./src/satellite_support.js",
+      "react-native": "./src/satellite_support.js",
+      "default": "./src/satellite_support.js"
+    },
+    "./nws/NwsWatchesWarningsOverlay.js": {
+      "import": "./src/nws/NwsWatchesWarningsOverlay.js",
+      "require": "./src/nws/NwsWatchesWarningsOverlay.js",
+      "react-native": "./src/nws/NwsWatchesWarningsOverlay.js",
+      "default": "./src/nws/NwsWatchesWarningsOverlay.js"
+    },
+    "./nws/nwsSdkConstants.js": {
+      "import": "./src/nws/nwsSdkConstants.js",
+      "require": "./src/nws/nwsSdkConstants.js",
+      "react-native": "./src/nws/nwsSdkConstants.js",
+      "default": "./src/nws/nwsSdkConstants.js"
+    },
+    "./nws/nwsAlertsSupport.js": {
+      "import": "./src/nws/nwsAlertsSupport.js",
+      "require": "./src/nws/nwsAlertsSupport.js",
+      "react-native": "./src/nws/nwsAlertsSupport.js",
+      "default": "./src/nws/nwsAlertsSupport.js"
+    },
+    "./nws/nwsAlertsFetchSpec.js": {
+      "import": "./src/nws/nwsAlertsFetchSpec.js",
+      "require": "./src/nws/nwsAlertsFetchSpec.js",
+      "react-native": "./src/nws/nwsAlertsFetchSpec.js",
+      "default": "./src/nws/nwsAlertsFetchSpec.js"
     }
   },
   "files": [
@@ -37,10 +68,14 @@
     "src"
   ],
   "scripts": {
-    "build": "babel src -d dist"
+    "build": "babel src -d dist",
+    "gen:nws-key": "esbuild ../../../aguacero-frontend/src/components/WarningsMenu/nwsWarningCustomizationKey.ts --bundle --format=esm --platform=neutral --outfile=src/nws/nwsWarningCustomizationKey.gen.js"
   },
   "author": "Your Name",
   "license": "MIT",
+  "devDependencies": {
+    "esbuild": "^0.21.5"
+  },
   "dependencies": {
     "proj4": "^2.11.0",
     "fzstd": "^0.1.1"

package/src/AguaceroCore.js

@@ -8,7 +8,7 @@ import { DICTIONARIES, MODEL_CONFIGS } from './dictionaries.js';
 import { DEFAULT_COLORMAPS } from './default-colormaps.js';
 import proj4 from 'proj4';
 import { processCompressedGrid } from './gridDecodePipeline.js';
-import { getBundleId } from './getBundleId';
+import { getBundleId } from './getBundleId.js';
 import {
     SATELLITE_FRAMES_URL,
     buildSatelliteTimelineForSelection,
@@ -115,8 +115,10 @@ export class AguaceroCore extends EventEmitter {
         super();
         this.isReactNative = typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
         this.apiKey = options.apiKey;
-        /** Passed as CloudFront `userId` for satellite KTX2 URLs (production uses the authenticated account id). */
-        this.userId = options.userId ?? 'sdk-user';
+        /** Base origin for grid HTTP requests (no trailing slash). Node/SSR: sets Origin + Referer so CloudFront can derive a source; browsers usually omit. */
+        const siteOriginRaw =
+            typeof options.gridRequestSiteOrigin === 'string' ? options.gridRequestSiteOrigin.trim() : '';
+        this.gridRequestSiteOrigin = siteOriginRaw ? siteOriginRaw.replace(/\/+$/, '') : null;
         this.bundleId = getBundleId();
         this.baseGridUrl = 'https://d3dc62msmxkrd7.cloudfront.net';
         /** @type {Worker | null} */
@@ -1231,12 +1233,16 @@ export class AguaceroCore extends EventEmitter {
             }
             try {
                 const baseUrl = `${this.baseGridUrl}${resourcePath}`;
-                const urlWithApiKeyParam = `${baseUrl}?apiKey=${this.apiKey}`;
+                const urlWithApiKeyParam = `${baseUrl}?apiKey=${encodeURIComponent(this.apiKey)}`;
                 const headers = { 'x-api-key': this.apiKey };
                 if (this.bundleId && this.isReactNative) {
                     headers['x-app-identifier'] = this.bundleId;
                 }
-                
+                if (this.gridRequestSiteOrigin) {
+                    headers['Origin'] = this.gridRequestSiteOrigin;
+                    headers['Referer'] = `${this.gridRequestSiteOrigin}/`;
+                }
+
                 const response = await fetch(urlWithApiKeyParam, { 
                     headers: headers,
                     signal: abortController.signal
@@ -1302,7 +1308,10 @@ export class AguaceroCore extends EventEmitter {
             ? `mrms-${mrmsTimestamp}-${variable}-${effectiveSmoothing}`
             : `${model}-${date}-${run}-${forecastHour}-${variable}-${effectiveSmoothing}`;
 
-        const gridDataPromise = this.dataCache.get(dataUrlIdentifier);
+        let gridDataPromise = this.dataCache.get(dataUrlIdentifier);
+        if (!gridDataPromise) {
+            gridDataPromise = await this._loadGridData(this.state);
+        }
         if (!gridDataPromise) return null;
 
         try {

package/src/index.js

@@ -40,4 +40,10 @@ export {
 /** NEXRAD tilt + listing helpers (also importable via subpaths; root re-export fixes Vite/esbuild subpath resolution). */
 export * from './nexradTilts.js';
 export * from './nexradTiltCoalesce.js';
-export * from './nexrad_support.js';
+export * from './nexrad_support.js';
+
+/** NWS watches/warnings (NWWS HTTP + SSE, Mapbox-style paint helpers) — shared by mapsgl and React Native. */
+export { NwsWatchesWarningsOverlay, NWS_DEFAULT_LINE_BEFORE_LAYER_ID } from './nws/NwsWatchesWarningsOverlay.js';
+export * from './nws/nwsSdkConstants.js';
+export * from './nws/nwsAlertsSupport.js';
+export * from './nws/nwsAlertsFetchSpec.js';