@aguacerowx/javascript-sdk 0.0.24 → 0.0.25

package/dist/default-colormaps.js

@@ -70,6 +70,38 @@ const DEFAULT_COLORMAPS = exports.DEFAULT_COLORMAPS = {
       }
     }
   },
+  "nexrad_kdp": {
+    units: {
+      'deg/km': {
+        colormap: [-2, "#8e8e8e", -0.5, "#4c0001", 0.25, "#a3072f", 1, "#ea73b4", 1.5, "#997eb9", 2, "#68f4f4", 2.5, "#1aba34", 3, "#11f910", 4, "#f7fc00", 5, "#ff7c10", 7, "#ffc47c", 10, "#790279"],
+        breakpoints: [-2, -0.5, 0.25, 1, 1.5, 2, 2.5, 3, 4, 5, 7, 10]
+      }
+    }
+  },
+  "nexrad_l3_n0h": {
+    units: {
+      None: {
+        colormap: [0, "#d0d0d0", 1, "#696969", 2, "#ffccd5", 3, "#a8d8f0", 4, "#2566d8", 5, "#b8f5b8", 6, "#1a8f1a", 7, "#f5e6b8", 8, "#ff8787", 9, "#e02020", 10, "#5c0000", 11, "#ffd700"],
+        breakpoints: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+      }
+    }
+  },
+  "nexrad_l3_hhc": {
+    units: {
+      None: {
+        colormap: [0, "#d0d0d0", 1, "#696969", 2, "#ffccd5", 3, "#a8d8f0", 4, "#2566d8", 5, "#b8f5b8", 6, "#1a8f1a", 7, "#f5e6b8", 8, "#ff8787", 9, "#e02020", 10, "#5c0000", 11, "#ffd700"],
+        breakpoints: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
+      }
+    }
+  },
+  "nexrad_l3_eet": {
+    units: {
+      kft: {
+        colormap: [5, "#737373", 10, "#818181", 15, "#919191", 20, "#a5a5a5", 25, "#49af45", 30, "#19770b", 35, "#fedd00", 40, "#fc6901", 45, "#bf0005", 50, "#800001", 55, "#cf2ad3", 60, "#b117b5", 65, "#00b6c5", 70, "#009ca9"],
+        breakpoints: [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]
+      }
+    }
+  },
   "rotation": {
     units: {
       's⁻¹': {

package/dist/dictionaries.js

@@ -2915,6 +2915,69 @@ const DICTIONARIES = exports.DICTIONARIES = {
       defaultUnit: 'm/s',
       description: 'Spread of velocities within a radar sample volume. High values indicate turbulence or wind shear.'
     },
+    "nexrad_kdp": {
+      category: "NEXRAD",
+      variable: "Specific Differential Phase",
+      shortname: "KDP",
+      defaultUnit: 'deg/km',
+      description: 'Rate of change of differential phase along the radar beam; used to estimate rain rate.'
+    },
+    "nexrad_l3_n0k": {
+      category: "NEXRAD",
+      variable: "Specific Differential Phase (Level III)",
+      shortname: "N0K",
+      defaultUnit: 'deg/km',
+      description: 'Level-III KDP (digital) by tilt slot.'
+    },
+    "nexrad_l3_dvl": {
+      category: "NEXRAD",
+      variable: "Vertically Integrated Liquid",
+      shortname: "DVL",
+      defaultUnit: 'kg/m²',
+      description: 'Integrated liquid water content in the column above each gate.'
+    },
+    "nexrad_l3_eet": {
+      category: "NEXRAD",
+      variable: "Enhanced Echo Tops",
+      shortname: "EET",
+      defaultUnit: 'kft',
+      description: 'Height of echo tops in hundreds of feet MSL (product-dependent scaling).'
+    },
+    "nexrad_l3_n0h": {
+      category: "NEXRAD",
+      variable: "Hydrometeor Classification",
+      shortname: "N0H",
+      defaultUnit: 'None',
+      description: 'Digital hydrometeor classification by class index.'
+    },
+    "nexrad_l3_hhc": {
+      category: "NEXRAD",
+      variable: "Hybrid Hydrometeor Classification",
+      shortname: "HHC",
+      defaultUnit: 'None',
+      description: 'Hybrid hydrometeor classification product.'
+    },
+    "nexrad_l3_daa": {
+      category: "NEXRAD",
+      variable: "1-Hour Accumulation",
+      shortname: "DAA",
+      defaultUnit: 'in',
+      description: 'One-hour precipitation accumulation.'
+    },
+    "nexrad_l3_du3": {
+      category: "NEXRAD",
+      variable: "3-Hour Accumulation",
+      shortname: "DU3",
+      defaultUnit: 'in',
+      description: 'Three-hour precipitation accumulation.'
+    },
+    "nexrad_l3_dta": {
+      category: "NEXRAD",
+      variable: "Storm Total Precipitation",
+      shortname: "DTA",
+      defaultUnit: 'in',
+      description: 'Storm-total precipitation accumulation.'
+    },
     "MergedAzShear_0-2kmAGL_00.50": {
       category: "Rotation",
       variable: "Rotation Track (Instant)",
@@ -3298,6 +3361,16 @@ const DICTIONARIES = exports.DICTIONARIES = {
     'nexrad_rho': 'MergedRhoHV_04.00',
     'nexrad_vel': 'nexrad_vel',
     'nexrad_sw': 'nexrad_sw',
+    'nexrad_kdp': 'nexrad_kdp',
+    'nexrad_l3_n0k': 'nexrad_kdp',
+    'nexrad_l3_n0h': 'nexrad_l3_n0h',
+    'nexrad_l3_hhc': 'nexrad_l3_hhc',
+    'nexrad_l3_eet': 'nexrad_l3_eet',
+    'nexrad_l3_dvl': 'vil',
+    'nexrad_l3_nvl': 'vil',
+    'nexrad_l3_daa': 'tp_0_1',
+    'nexrad_l3_du3': 'tp_0_total',
+    'nexrad_l3_dta': 'tp_0_total',
     //mrms
     'MergedReflectivityQCComposite_00.50': 'refc_0',
     'CREF_1HR_MAX_00.50': 'refc_0',

package/dist/getBundleId.js

@@ -4,23 +4,12 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getBundleId = void 0;
-// This module acts as a platform-agnostic proxy.
-
-let getBundleIdImpl;
-try {
-  // This line will ONLY succeed in a React Native environment where the
-  // 'react-native-device-info' module is installed.
-  const DeviceInfo = require('react-native-device-info');
-
-  // If the above line doesn't throw an error, we set the implementation
-  // to the native version.
-  getBundleIdImpl = () => DeviceInfo.getBundleId();
-} catch (e) {
-  // If require() fails, we know we are in a non-React Native environment
-  // (like the web). We set the implementation to a "dummy" function
-  // that does nothing and returns null.
-  getBundleIdImpl = () => null;
-}
-
-// Export the chosen implementation.
-const getBundleId = exports.getBundleId = getBundleIdImpl;
+/**
+ * Default implementation for web and Node bundlers (Vite, webpack).
+ * Do not import react-native-device-info here: static analysis would pull in
+ * `react-native` (Flow sources) and break esbuild.
+ *
+ * Metro resolves `getBundleId.native.js` on iOS/Android instead of this file.
+ */
+const getBundleId = () => null;
+exports.getBundleId = getBundleId;

package/dist/getBundleId.native.js

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getBundleId = void 0;
+/**
+ * React Native (Metro picks this file over getBundleId.js on native platforms).
+ */
+
+let getBundleIdImpl;
+try {
+  const DeviceInfo = require('react-native-device-info');
+  getBundleIdImpl = () => DeviceInfo.getBundleId();
+} catch {
+  getBundleIdImpl = () => null;
+}
+const getBundleId = exports.getBundleId = getBundleIdImpl;

package/dist/gridDecodePipeline.js

@@ -0,0 +1,37 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.processCompressedGrid = processCompressedGrid;
+var _fzstd = require("fzstd");
+function reconstructData(decompressedDeltas, encoding) {
+  const expectedLength = encoding.length;
+  const reconstructedData = new Int8Array(expectedLength);
+  if (decompressedDeltas.length > 0 && expectedLength > 0) {
+    reconstructedData[0] = decompressedDeltas[0] > 127 ? decompressedDeltas[0] - 256 : decompressedDeltas[0];
+    for (let i = 1; i < expectedLength; i++) {
+      const delta = decompressedDeltas[i] > 127 ? decompressedDeltas[i] - 256 : decompressedDeltas[i];
+      reconstructedData[i] = reconstructedData[i - 1] + delta;
+    }
+  }
+  return new Uint8Array(reconstructedData.buffer);
+}
+
+/**
+ * zstd decompress → delta reconstruction → unsigned byte offset for GPU lookup.
+ * Used on the main thread as a fallback and inside {@link ./gridDecodeWorker.js}.
+ */
+function processCompressedGrid(compressedData, encoding) {
+  const decompressedDeltas = (0, _fzstd.decompress)(compressedData);
+  const finalData = reconstructData(decompressedDeltas, encoding);
+  const transformedData = new Uint8Array(finalData.length);
+  for (let i = 0; i < finalData.length; i++) {
+    const signedValue = finalData[i] > 127 ? finalData[i] - 256 : finalData[i];
+    transformedData[i] = signedValue + 128;
+  }
+  return {
+    data: transformedData,
+    encoding
+  };
+}

package/dist/gridDecodeWorker.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _gridDecodePipeline = require("./gridDecodePipeline.js");
+self.onmessage = e => {
+  const {
+    id,
+    encoding,
+    compressedBuffer,
+    compressedByteOffset,
+    compressedByteLength
+  } = e.data;
+  try {
+    const compressedData = new Uint8Array(compressedBuffer, compressedByteOffset, compressedByteLength);
+    const {
+      data,
+      encoding: enc
+    } = (0, _gridDecodePipeline.processCompressedGrid)(compressedData, encoding);
+    self.postMessage({
+      id,
+      encoding: enc,
+      dataBuffer: data.buffer,
+      dataByteOffset: data.byteOffset,
+      dataByteLength: data.byteLength
+    }, [data.buffer]);
+  } catch (err) {
+    self.postMessage({
+      id,
+      error: (err === null || err === void 0 ? void 0 : err.message) || String(err)
+    });
+  }
+};

package/dist/index.js

@@ -3,12 +3,43 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  AguaceroCore: true,
+  EventEmitter: true,
+  THEME_CONFIGS: true,
+  DICTIONARIES: true,
+  DEFAULT_COLORMAPS: true,
+  getUnitConversionFunction: true,
+  SATELLITE_FRAMES_URL: true,
+  GOES_EAST_SATELLITE_SECTORS: true,
+  GOES_SATELLITE_CHANNELS: true,
+  GOES_SATELLITE_CHANNEL_LABELS: true,
+  SATELLITE_DURATION_CONFIG: true,
+  TIMELINE_DURATION_MAX_HOURS: true,
+  TIMELINE_DURATION_HOUR_VALUES: true,
+  formatTimelineDurationValue: true,
+  normalizeTimelineDurationValue: true,
+  parseTimelineDurationHours: true,
+  resolveSatelliteDurationOption: true,
+  getDefaultSatelliteDurationOption: true,
+  buildSatelliteTimelineForSelection: true,
+  getAllGoesEastSatelliteSelections: true,
+  calculateUnixTimeFromSatelliteKey: true,
+  resolveSatelliteS3FileName: true,
+  resolveSatelliteSectorLabel: true
+};
 Object.defineProperty(exports, "AguaceroCore", {
   enumerable: true,
   get: function () {
     return _AguaceroCore.AguaceroCore;
   }
 });
+Object.defineProperty(exports, "DEFAULT_COLORMAPS", {
+  enumerable: true,
+  get: function () {
+    return _defaultColormaps.DEFAULT_COLORMAPS;
+  }
+});
 Object.defineProperty(exports, "DICTIONARIES", {
   enumerable: true,
   get: function () {
@@ -21,20 +52,160 @@ Object.defineProperty(exports, "EventEmitter", {
     return _events.EventEmitter;
   }
 });
+Object.defineProperty(exports, "GOES_EAST_SATELLITE_SECTORS", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.GOES_EAST_SATELLITE_SECTORS;
+  }
+});
+Object.defineProperty(exports, "GOES_SATELLITE_CHANNELS", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.GOES_SATELLITE_CHANNELS;
+  }
+});
+Object.defineProperty(exports, "GOES_SATELLITE_CHANNEL_LABELS", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.GOES_SATELLITE_CHANNEL_LABELS;
+  }
+});
+Object.defineProperty(exports, "SATELLITE_DURATION_CONFIG", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.SATELLITE_DURATION_CONFIG;
+  }
+});
+Object.defineProperty(exports, "SATELLITE_FRAMES_URL", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.SATELLITE_FRAMES_URL;
+  }
+});
 Object.defineProperty(exports, "THEME_CONFIGS", {
   enumerable: true,
   get: function () {
     return _mapStyles.THEME_CONFIGS;
   }
 });
+Object.defineProperty(exports, "TIMELINE_DURATION_HOUR_VALUES", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.TIMELINE_DURATION_HOUR_VALUES;
+  }
+});
+Object.defineProperty(exports, "TIMELINE_DURATION_MAX_HOURS", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.TIMELINE_DURATION_MAX_HOURS;
+  }
+});
+Object.defineProperty(exports, "buildSatelliteTimelineForSelection", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.buildSatelliteTimelineForSelection;
+  }
+});
+Object.defineProperty(exports, "calculateUnixTimeFromSatelliteKey", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.calculateUnixTimeFromSatelliteKey;
+  }
+});
+Object.defineProperty(exports, "formatTimelineDurationValue", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.formatTimelineDurationValue;
+  }
+});
+Object.defineProperty(exports, "getAllGoesEastSatelliteSelections", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.getAllGoesEastSatelliteSelections;
+  }
+});
+Object.defineProperty(exports, "getDefaultSatelliteDurationOption", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.getDefaultSatelliteDurationOption;
+  }
+});
 Object.defineProperty(exports, "getUnitConversionFunction", {
   enumerable: true,
   get: function () {
     return _unitConversions.getUnitConversionFunction;
   }
 });
+Object.defineProperty(exports, "normalizeTimelineDurationValue", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.normalizeTimelineDurationValue;
+  }
+});
+Object.defineProperty(exports, "parseTimelineDurationHours", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.parseTimelineDurationHours;
+  }
+});
+Object.defineProperty(exports, "resolveSatelliteDurationOption", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.resolveSatelliteDurationOption;
+  }
+});
+Object.defineProperty(exports, "resolveSatelliteS3FileName", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.resolveSatelliteS3FileName;
+  }
+});
+Object.defineProperty(exports, "resolveSatelliteSectorLabel", {
+  enumerable: true,
+  get: function () {
+    return _satellite_support.resolveSatelliteSectorLabel;
+  }
+});
 var _AguaceroCore = require("./AguaceroCore.js");
 var _events = require("./events.js");
 var _mapStyles = require("./map-styles.js");
 var _dictionaries = require("./dictionaries.js");
-var _unitConversions = require("./unitConversions.js");
+var _defaultColormaps = require("./default-colormaps.js");
+var _unitConversions = require("./unitConversions.js");
+var _satellite_support = require("./satellite_support.js");
+var _nexradTilts = require("./nexradTilts.js");
+Object.keys(_nexradTilts).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _nexradTilts[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nexradTilts[key];
+    }
+  });
+});
+var _nexradTiltCoalesce = require("./nexradTiltCoalesce.js");
+Object.keys(_nexradTiltCoalesce).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _nexradTiltCoalesce[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nexradTiltCoalesce[key];
+    }
+  });
+});
+var _nexrad_support = require("./nexrad_support.js");
+Object.keys(_nexrad_support).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _nexrad_support[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _nexrad_support[key];
+    }
+  });
+});

package/dist/nexradTiltCoalesce.js

@@ -0,0 +1,95 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NEXRAD_TILT_COALESCE_MAX_GAP = void 0;
+exports.chainCoalesceToCanonical = chainCoalesceToCanonical;
+exports.coalesceNexradTiltOptionsForDisplay = coalesceNexradTiltOptionsForDisplay;
+exports.nexradLayerTiltToDisplayOption = nexradLayerTiltToDisplayOption;
+/**
+ * NEXRAD tilt coalescing (matches aguacero-frontend `nexradTiltCoalesce.ts`).
+ * Adjacent manifest tilts within {@link NEXRAD_TILT_COALESCE_MAX_GAP}° are merged for UI/listings:
+ * pairs → higher tilt; runs of three or more consecutive steps merge the first two into the lower tilt.
+ */
+
+/** Adjacent tilts (sorted) within this gap share one listing / control. */
+const NEXRAD_TILT_COALESCE_MAX_GAP = exports.NEXRAD_TILT_COALESCE_MAX_GAP = 0.1;
+
+/**
+ * @param {number[]} segment
+ * @param {Map<number, number>} map
+ */
+function mergeCoalesceSegment(segment, map) {
+  if (segment.length === 0) return;
+  if (segment.length === 1) {
+    map.set(segment[0], segment[0]);
+    return;
+  }
+  if (segment.length === 2) {
+    const canonical = Math.max(segment[0], segment[1]);
+    map.set(segment[0], canonical);
+    map.set(segment[1], canonical);
+    return;
+  }
+  const low = segment[0];
+  map.set(segment[0], low);
+  map.set(segment[1], low);
+  mergeCoalesceSegment(segment.slice(2), map);
+}
+
+/**
+ * @param {number[]} sortedUnique
+ * @returns {Map<number, number>}
+ */
+function chainCoalesceToCanonical(sortedUnique) {
+  const map = new Map();
+  let i = 0;
+  while (i < sortedUnique.length) {
+    let j = i + 1;
+    while (j < sortedUnique.length && sortedUnique[j] - sortedUnique[j - 1] <= NEXRAD_TILT_COALESCE_MAX_GAP + 1e-9) {
+      j++;
+    }
+    const segment = sortedUnique.slice(i, j);
+    mergeCoalesceSegment(segment, map);
+    i = j;
+  }
+  return map;
+}
+
+/**
+ * Manifest tilt list with adjacent options merged (pairs → higher; triple+ splits per merge rules).
+ * @param {number[]} tilts
+ * @returns {number[]}
+ */
+function coalesceNexradTiltOptionsForDisplay(tilts) {
+  const sorted = [...new Set(tilts)].filter(t => Number.isFinite(t)).sort((a, b) => a - b);
+  if (sorted.length <= 1) return sorted;
+  const tiltToCanonical = chainCoalesceToCanonical(sorted);
+  const reps = [];
+  let prevRep;
+  for (const t of sorted) {
+    const c = tiltToCanonical.get(t);
+    if (c === undefined) continue;
+    if (c !== prevRep) {
+      reps.push(c);
+      prevRep = c;
+    }
+  }
+  return reps;
+}
+
+/**
+ * Map stored/clamped tilt to the coalesced elevation value (same rules as {@link coalesceNexradTiltOptionsForDisplay}).
+ * @param {number} layerTilt
+ * @param {number[]} manifestTilts raw manifest tilts (before coalescing)
+ * @returns {number}
+ */
+function nexradLayerTiltToDisplayOption(layerTilt, manifestTilts) {
+  const sorted = [...new Set(manifestTilts)].filter(t => Number.isFinite(t)).sort((a, b) => a - b);
+  if (sorted.length === 0) return layerTilt;
+  const tiltToCanonical = chainCoalesceToCanonical(sorted);
+  if (tiltToCanonical.has(layerTilt)) return tiltToCanonical.get(layerTilt);
+  const nearest = sorted.reduce((best, x) => Math.abs(x - layerTilt) < Math.abs(best - layerTilt) ? x : best, sorted[0]);
+  return tiltToCanonical.get(nearest) ?? layerTilt;
+}

package/dist/nexradTilts.js

@@ -0,0 +1,129 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RADAR_TILTS_MANIFEST_URL = void 0;
+exports.clampNexradTiltForVariable = clampNexradTiltForVariable;
+exports.fetchRadarTiltsManifestFromNetwork = fetchRadarTiltsManifestFromNetwork;
+exports.formatTiltForApi = formatTiltForApi;
+exports.getDefaultRadarTilt = getDefaultRadarTilt;
+exports.getRadarTilts = getRadarTilts;
+exports.getRadarTiltsManifest = getRadarTiltsManifest;
+exports.isNexradTdwrSiteId = isNexradTdwrSiteId;
+exports.isTerminalRadar = isTerminalRadar;
+exports.setRadarTiltsManifest = setRadarTiltsManifest;
+/**
+ * NEXRAD tilt helpers (mirrors aguacero-frontend dictionaries + radar tilts manifest behavior).
+ * When {@link setRadarTiltsManifest} has been called with a non-empty map, per-site tilts follow it.
+ */
+
+const WSR88D_TILTS = [0.5, 0.9, 1.3, 1.8, 2.4, 3.1, 4.0, 5.1, 6.4];
+const TDWR_TILTS = [0.3, 1.0, 2, 6.5, 8.8, 16.0, 21.3];
+const WSR88D_SITE_IDS_WITH_T_PREFIX = new Set(['TJUA']);
+
+/** @type {Record<string, { g1_tilts: number[]; g2_tilts: number[]; last_seen?: number }>} */
+let manifestBySite = {};
+function setRadarTiltsManifest(map) {
+  manifestBySite = map && typeof map === 'object' ? map : {};
+}
+function getRadarTiltsManifest() {
+  return manifestBySite;
+}
+function isNexradTdwrSiteId(siteId) {
+  const id = String(siteId ?? '').trim().toUpperCase();
+  if (!id) return false;
+  if (WSR88D_SITE_IDS_WITH_T_PREFIX.has(id)) return false;
+  return id.startsWith('T');
+}
+function isTerminalRadar(siteId) {
+  return isNexradTdwrSiteId(siteId);
+}
+const NEXRAD_G2_VARIABLES = new Set(['VEL', 'SW']);
+const TDWR_DUAL_POL_CAPPED = new Set(['ZDR', 'PHI', 'RHO', 'KDP']);
+const TDWR_DUAL_POL_MAX_TILT = 0.3;
+function uniqSorted(nums) {
+  const arr = nums.filter(n => typeof n === 'number' && Number.isFinite(n));
+  const rounded = arr.map(n => Math.round(n * 1000) / 1000);
+  return [...new Set(rounded)].sort((a, b) => a - b);
+}
+function computeRadarTiltsFromManifestEntry(entry, siteId, radarVariable) {
+  const v = (radarVariable || 'REF').toUpperCase();
+  let base;
+  if (NEXRAD_G2_VARIABLES.has(v)) {
+    base = uniqSorted(entry.g2_tilts || []);
+  } else {
+    base = uniqSorted([...(entry.g1_tilts || []), ...(entry.g2_tilts || [])]);
+  }
+  if (isNexradTdwrSiteId(siteId) && TDWR_DUAL_POL_CAPPED.has(v)) {
+    return base.filter(t => t <= TDWR_DUAL_POL_MAX_TILT);
+  }
+  return base;
+}
+function getDefaultTiltFromManifestEntry(entry) {
+  const g1 = entry.g1_tilts;
+  if (!Array.isArray(g1) || g1.length === 0) return null;
+  const sorted = uniqSorted(g1);
+  return sorted[0] ?? null;
+}
+function getDefaultRadarTilt(siteId) {
+  const id = siteId === null || siteId === void 0 ? void 0 : siteId.toUpperCase();
+  const entry = id ? manifestBySite[id] : undefined;
+  if (entry) {
+    const t = getDefaultTiltFromManifestEntry(entry);
+    if (t != null) return t;
+  }
+  return isTerminalRadar(siteId) ? 0.3 : 0.5;
+}
+function getRadarTilts(siteId, radarVariable) {
+  const id = siteId === null || siteId === void 0 ? void 0 : siteId.toUpperCase();
+  const entry = id ? manifestBySite[id] : undefined;
+  if (entry) {
+    const fromManifest = computeRadarTiltsFromManifestEntry(entry, siteId, radarVariable);
+    if (fromManifest.length) return fromManifest;
+  }
+  const base = isTerminalRadar(siteId) ? TDWR_TILTS : WSR88D_TILTS;
+  if (!radarVariable || !isTerminalRadar(siteId)) return [...base];
+  const v = radarVariable.toUpperCase();
+  if (['ZDR', 'PHI', 'RHO'].includes(v)) {
+    return base.filter(t => t <= TDWR_DUAL_POL_MAX_TILT);
+  }
+  return [...base];
+}
+function clampNexradTiltForVariable(siteId, variable, tilt) {
+  if (!isTerminalRadar(siteId)) return tilt;
+  const v = (variable || 'REF').toUpperCase();
+  if (['ZDR', 'PHI', 'RHO'].includes(v)) {
+    return Math.min(tilt, TDWR_DUAL_POL_MAX_TILT);
+  }
+  return tilt;
+}
+function formatTiltForApi(tilt) {
+  return tilt.toFixed(2);
+}
+const RADAR_TILTS_MANIFEST_URL = exports.RADAR_TILTS_MANIFEST_URL = 'https://radar-tilts.s3.us-east-2.amazonaws.com/manifest.json';
+async function fetchRadarTiltsManifestFromNetwork() {
+  try {
+    const res = await fetch(RADAR_TILTS_MANIFEST_URL, {
+      cache: 'no-store'
+    });
+    if (!res.ok) return null;
+    const raw = await res.json();
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return null;
+    const out = {};
+    for (const [key, val] of Object.entries(raw)) {
+      if (!val || typeof val !== 'object' || Array.isArray(val)) continue;
+      const g1 = val.g1_tilts;
+      const g2 = val.g2_tilts;
+      if (!Array.isArray(g1) || !Array.isArray(g2)) continue;
+      out[key.toUpperCase()] = {
+        g1_tilts: g1.filter(n => typeof n === 'number' && Number.isFinite(n)),
+        g2_tilts: g2.filter(n => typeof n === 'number' && Number.isFinite(n)),
+        last_seen: typeof val.last_seen === 'number' ? val.last_seen : undefined
+      };
+    }
+    return Object.keys(out).length ? out : null;
+  } catch {
+    return null;
+  }
+}