@aguacerowx/react-native 0.0.42 → 0.0.44

package/src/nexrad/nexradCrossSectionSampleAtLatLon.bundled.js

@@ -0,0 +1,91 @@
+function wrapAzimuthDeltaDeg(azDeg, azimuthBaseDeg) {
+  let da = azDeg - azimuthBaseDeg;
+  da -= Math.floor(da / 360) * 360;
+  if (da < 0) da += 360;
+  return da;
+}
+function snapGateCoord(t, nCells) {
+  if (nCells <= 1) return 0;
+  const idx = Math.floor(t * (nCells - 1) + 0.5);
+  return idx / (nCells - 1);
+}
+function readGateRawSigned(frame, rayIdx, gateIdx) {
+  if (rayIdx < 0 || gateIdx < 0 || rayIdx >= frame.nRays || gateIdx >= frame.nGates) return null;
+  const byteOffset = (rayIdx * frame.nGates + gateIdx) * 2;
+  const hi = frame.gateData[byteOffset];
+  const lo = frame.gateData[byteOffset + 1];
+  const raw = lo + hi * 256;
+  const rawSigned = raw >= 32768 ? raw - 65536 : raw;
+  if (rawSigned <= -32768) return null;
+  return rawSigned;
+}
+function sampleGateRawBilinearDecoded(frame, gateX, gateY) {
+  const w = frame.nGates;
+  const h = frame.nRays;
+  if (w < 1 || h < 1) return null;
+  const gx = Math.min(1, Math.max(0, gateX));
+  const gy = Math.min(1, Math.max(0, gateY));
+  const sx = gx * Math.max(w - 1, 1);
+  const sy = gy * Math.max(h - 1, 1);
+  const i0 = Math.floor(sx);
+  const j0 = Math.floor(sy);
+  const i1 = Math.min(i0 + 1, w - 1);
+  const j1 = Math.min(j0 + 1, h - 1);
+  const fx = sx - i0;
+  const fy = sy - j0;
+  const w00 = (1 - fx) * (1 - fy);
+  const w10 = fx * (1 - fy);
+  const w01 = (1 - fx) * fy;
+  const w11 = fx * fy;
+  let acc = 0;
+  let wsum = 0;
+  const add = (r, wt) => {
+    if (r !== null) {
+      acc += r * wt;
+      wsum += wt;
+    }
+  };
+  add(readGateRawSigned(frame, j0, i0), w00);
+  add(readGateRawSigned(frame, j0, i1), w10);
+  add(readGateRawSigned(frame, j1, i0), w01);
+  add(readGateRawSigned(frame, j1, i1), w11);
+  if (wsum < 1e-6) return null;
+  return acc / wsum;
+}
+function sampleNexradFrameAtLatLon(frame, lat, lon, options) {
+  const DEG_TO_RAD = Math.PI / 180;
+  const EARTH_RADIUS_M = 6378137;
+  const dLatDeg = lat - frame.stationLat;
+  const dLonDeg = lon - frame.stationLon;
+  const cosLat = Math.max(Math.cos(lat * DEG_TO_RAD), 1e-6);
+  const xM = dLonDeg * DEG_TO_RAD * EARTH_RADIUS_M * cosLat;
+  const yM = dLatDeg * DEG_TO_RAD * EARTH_RADIUS_M;
+  const rangeM = Math.hypot(xM, yM);
+  const rangeKm = rangeM / 1e3;
+  if (rangeKm < frame.firstGateKm) return null;
+  const spanKm = frame.nGates * frame.gateWidthKm;
+  if (!(spanKm > 0)) return null;
+  const maxRangeKm = frame.firstGateKm + spanKm;
+  if (rangeKm >= maxRangeKm) return null;
+  let azDeg = Math.atan2(xM, yM) * (180 / Math.PI);
+  if (azDeg < 0) azDeg += 360;
+  const boundaries = frame.rayBoundariesDeg;
+  const azimuthBaseDeg = boundaries.length > 0 ? Number(boundaries[0]) : 0;
+  const da = wrapAzimuthDeltaDeg(azDeg, azimuthBaseDeg);
+  let gateY = da / 360;
+  gateY = Math.min(1, Math.max(0, gateY));
+  let gateX = (rangeKm - frame.firstGateKm) / spanKm;
+  gateX = Math.min(1, Math.max(0, gateX));
+  const smoothPolar = options?.smoothPolar === true;
+  if (!smoothPolar) {
+    gateX = snapGateCoord(gateX, frame.nGates);
+    gateY = snapGateCoord(gateY, frame.nRays);
+  }
+  const rawSigned = sampleGateRawBilinearDecoded(frame, gateX, gateY);
+  if (rawSigned === null) return null;
+  const physical = rawSigned * frame.valueScale + frame.valueOffset;
+  return { value: physical, groundRangeKm: rangeKm };
+}
+export {
+  sampleNexradFrameAtLatLon
+};

package/src/nexrad/nexradDiag.js

@@ -0,0 +1,120 @@
+/**
+ * NEXRAD pipeline diagnostics (Android / Metro).
+ *
+ * All output is off unless you set {@code global.__AGUACERO_NEXRAD_DEBUG = true}
+ * (then filter {@code [Aguacero][NEXRAD]} and {@code [Aguacero][NEXRAD][PERF]}).
+ */
+
+export function nexradDiagEnabled() {
+    return typeof globalThis !== 'undefined' && globalThis.__AGUACERO_NEXRAD_DEBUG === true;
+}
+
+export function nexradDiag(phase, detail) {
+    if (!nexradDiagEnabled()) return;
+    if (detail !== undefined) {
+        console.warn(`[Aguacero][NEXRAD] ${phase}`, detail);
+    } else {
+        console.warn(`[Aguacero][NEXRAD] ${phase}`);
+    }
+}
+
+/**
+ * @param {string} label
+ * @returns {{ elapsedMs: () => number, end: (detail?: Record<string, unknown>) => number }}
+ */
+export function nexradPerfSpan(label) {
+    const hasPerf = typeof performance !== 'undefined' && typeof performance.now === 'function';
+    const t0 = hasPerf ? performance.now() : Date.now();
+    return {
+        elapsedMs() {
+            const t1 = hasPerf ? performance.now() : Date.now();
+            return t1 - t0;
+        },
+        end(detail) {
+            const msActual = hasPerf ? performance.now() - t0 : Date.now() - t0;
+            if (!nexradDiagEnabled()) {
+                return msActual;
+            }
+            const payload =
+                detail !== undefined && detail !== null && typeof detail === 'object'
+                    ? { ms: msActual, ...detail }
+                    : { ms: msActual };
+            console.warn(`[Aguacero][NEXRAD][PERF] ${label}`, payload);
+            return msActual;
+        },
+    };
+}
+
+/**
+ * @param {Record<string, unknown>} [extra]
+ */
+export function nexradDiagBootSnapshot(extra = {}) {
+    if (!nexradDiagEnabled()) return;
+    const g = typeof globalThis !== 'undefined' ? globalThis : {};
+    nexradDiag('boot.snapshot', {
+        ...extra,
+        workerType: typeof Worker,
+        navigatorProduct: typeof navigator !== 'undefined' ? navigator.product : undefined,
+        hermesInternal: typeof g.HermesInternal !== 'undefined',
+    });
+}
+
+/**
+ * @param {Uint8Array} gateData
+ * @param {number} nGates
+ * @param {number} nRays
+ * @param {number} valueScale
+ * @param {number} valueOffset
+ * @param {number} lutMin
+ * @param {number} lutMax
+ */
+export function nexradDiagGateTextureSummary(gateData, nGates, nRays, valueScale, valueOffset, lutMin, lutMax) {
+    if (!nexradDiagEnabled()) {
+        return { skipped: true };
+    }
+    if (!gateData?.length) return { error: 'empty' };
+    const pairCount = nGates * nRays;
+    const expected = pairCount * 2;
+    if (gateData.length < expected) {
+        return { error: 'shortBuffer', len: gateData.length, expected };
+    }
+    let sampleN = 0;
+    let nodataN = 0;
+    let inLutN = 0;
+    let minRaw = 32767;
+    let maxRaw = -32768;
+    let minPhys = Infinity;
+    let maxPhys = -Infinity;
+    const stride = Math.max(1, Math.floor(pairCount / 25000));
+    for (let p = 0; p < pairCount; p += stride) {
+        const o = p * 2;
+        const lo = gateData[o];
+        const hi = gateData[o + 1];
+        let raw = lo + hi * 256;
+        if (raw >= 32768) raw -= 65536;
+        sampleN++;
+        if (raw <= -32768) {
+            nodataN++;
+            continue;
+        }
+        if (raw < minRaw) minRaw = raw;
+        if (raw > maxRaw) maxRaw = raw;
+        const phys = raw * valueScale + valueOffset;
+        if (phys < minPhys) minPhys = phys;
+        if (phys > maxPhys) maxPhys = phys;
+        if (phys >= lutMin && phys <= lutMax) inLutN++;
+    }
+    return {
+        samples: sampleN,
+        nodataSamples: nodataN,
+        inLutSamples: inLutN,
+        minRaw: minRaw <= maxRaw ? minRaw : null,
+        maxRaw: minRaw <= maxRaw ? maxRaw : null,
+        minPhys: Number.isFinite(minPhys) ? minPhys : null,
+        maxPhys: Number.isFinite(maxPhys) ? maxPhys : null,
+        lutMin,
+        lutMax,
+        valueScale,
+        valueOffset,
+    };
+}

package/src/nexrad/nexradLutBuild.js

@@ -0,0 +1,126 @@
+/**
+ * NEXRAD 256×1 RGBA LUT — same rules as mapsgl {@code MapboxRadarLayer.buildLutTextureData}.
+ */
+import { DEFAULT_COLORMAPS } from '@aguacerowx/javascript-sdk';
+
+const LUT_SIZE = 256;
+
+function getRefc0DefaultColormap() {
+    const cm = DEFAULT_COLORMAPS?.refc_0?.units?.dBZ?.colormap;
+    return Array.isArray(cm) && cm.length >= 2 ? cm : null;
+}
+
+function parseHex(hex) {
+    const m = String(hex ?? '').match(/^#?([a-fA-F0-9]{8}|[a-fA-F0-9]{6}|[a-fA-F0-9]{3})$/);
+    if (!m) return [0, 0, 0, 255];
+    const s = m[1];
+    let r = 0;
+    let g = 0;
+    let b = 0;
+    let a = 255;
+    if (s.length === 8) {
+        r = parseInt(s.slice(0, 2), 16);
+        g = parseInt(s.slice(2, 4), 16);
+        b = parseInt(s.slice(4, 6), 16);
+        a = parseInt(s.slice(6, 8), 16);
+    } else if (s.length === 6) {
+        r = parseInt(s.slice(0, 2), 16);
+        g = parseInt(s.slice(2, 4), 16);
+        b = parseInt(s.slice(4, 6), 16);
+    } else {
+        r = parseInt(s[0] + s[0], 16);
+        g = parseInt(s[1] + s[1], 16);
+        b = parseInt(s[2] + s[2], 16);
+    }
+    return [r, g, b, a];
+}
+
+function shouldUseDiscreteIntegerLut(stops, lutValueMin, lutValueMax, interpolateColormap) {
+    if (interpolateColormap || stops.length < 2) return false;
+    const lo = lutValueMin;
+    const hi = lutValueMax;
+    if (!Number.isFinite(lo) || !Number.isFinite(hi)) return false;
+    const nExp = Math.round(hi - lo + 1);
+    if (stops.length !== nExp) return false;
+    if (Math.abs(Math.round(lo) - lo) > 1e-3 || Math.abs(Math.round(hi) - hi) > 1e-3) return false;
+    for (let i = 0; i < stops.length; i++) {
+        if (Math.abs(stops[i].value - (lo + i)) > 1e-3) return false;
+    }
+    return true;
+}
+
+function sampleStops(stops, value, interpolate) {
+    if (value <= stops[0].value) return stops[0].color;
+    if (value >= stops[stops.length - 1].value) return stops[stops.length - 1].color;
+    for (let i = 1; i < stops.length; i++) {
+        if (interpolate) {
+            if (value <= stops[i].value) {
+                const low = stops[i - 1];
+                const high = stops[i];
+                const t = (value - low.value) / Math.max(high.value - low.value, 1e-5);
+                return [
+                    Math.round(low.color[0] + (high.color[0] - low.color[0]) * t),
+                    Math.round(low.color[1] + (high.color[1] - low.color[1]) * t),
+                    Math.round(low.color[2] + (high.color[2] - low.color[2]) * t),
+                    Math.round(low.color[3] + (high.color[3] - low.color[3]) * t),
+                ];
+            }
+        } else if (value < stops[i].value) {
+            return stops[i - 1].color;
+        }
+    }
+    return stops[stops.length - 1].color;
+}
+
+/**
+ * @param {number[]|null|undefined} colormapFlat - [v0,c0,v1,c1,...]
+ * @param {number} lutValueMin
+ * @param {number} lutValueMax
+ * @param {boolean} interpolateColormap
+ * @returns {{ bytes: Uint8Array, discreteIntegerLut: number }}
+ */
+export function buildNexradLutRgba(colormapFlat, lutValueMin, lutValueMax, interpolateColormap) {
+    const cm = Array.isArray(colormapFlat) && colormapFlat.length >= 2 ? colormapFlat : getRefc0DefaultColormap();
+    const stops = [];
+    if (cm && cm.length >= 2) {
+        for (let i = 0; i < cm.length; i += 2) {
+            const value = Number(cm[i]);
+            const hex = String(cm[i + 1] ?? '');
+            const [r, g, b, a] = parseHex(hex);
+            stops.push({ value, color: [r, g, b, a] });
+        }
+    }
+
+    const out = new Uint8Array(LUT_SIZE * 4);
+    if (stops.length === 0) {
+        return { bytes: out, discreteIntegerLut: 0 };
+    }
+
+    const discrete = shouldUseDiscreteIntegerLut(stops, lutValueMin, lutValueMax, interpolateColormap) ? 1 : 0;
+
+    if (discrete) {
+        const n = stops.length;
+        for (let i = 0; i < LUT_SIZE; i++) {
+            const u = (i + 0.5) / LUT_SIZE;
+            const bin = Math.min(Math.floor(u * n), n - 1);
+            const c = stops[bin].color;
+            const idx = i * 4;
+            out[idx] = c[0];
+            out[idx + 1] = c[1];
+            out[idx + 2] = c[2];
+            out[idx + 3] = c[3];
+        }
+        return { bytes: out, discreteIntegerLut: 1 };
+    }
+
+    for (let i = 0; i < LUT_SIZE; i++) {
+        const value = lutValueMin + (i / (LUT_SIZE - 1)) * (lutValueMax - lutValueMin);
+        const color = sampleStops(stops, value, interpolateColormap);
+        const idx = i * 4;
+        out[idx] = color[0];
+        out[idx + 1] = color[1];
+        out[idx + 2] = color[2];
+        out[idx + 3] = color[3];
+    }
+    return { bytes: out, discreteIntegerLut: 0 };
+}

package/src/nexrad/nexradMapboxFrameOpts.bundled.js

@@ -0,0 +1,245 @@
+// 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) return { geometryLayoutKey: "canonical" };
+  if (state.nexradDataSource !== "level3") return { geometryLayoutKey: "canonical" };
+  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 { geometryLayoutKey: "canonical" };
+}
+export {
+  mapboxFrameUploadOptionsForNexradState,
+  nexradLevel3S3ProductForSiteTilt,
+  nexradLevel3UsesTiltIndexedS3Products
+};