feat(weather): add globe wind, observed weather and cyclone context (#617)

Wind (NOAA GFS and ECMWF IFS: animated particles, colour field, a reading at map centre), observed weather (NOAA MRMS radar, GOES and NESDIS infrared clouds, lightning density) on one shared history timeline, NHC and CPHC cyclone advisories with tracks and cones, and a WEATHER panel in the right rail. On 3D Tiles the observed products render as raised shells with a sharper window around the view.

Co-authored-by: Gustavo Beneduzi <[email protected]>
Co-authored-by: Daniel Slay <[email protected]>
Co-authored-by: Rehaan Delmotra <[email protected]>
Co-authored-by: Cursor Agent <[email protected]>

server/providers/wind/catalog.js

@@ -0,0 +1,34 @@
+export const GFS_BUCKET = 'noaa-gfs-bdp-pds';
+
+/** Build the public GFS object key. */
+export function gfsObjectKey({ date, hour, forecastHour = 0 }) {
+  const hh = String(hour).padStart(2, '0');
+  return `gfs.${date}/${hh}/atmos/gfs.t${hh}z.pgrb2.0p25.f${String(forecastHour).padStart(3, '0')}`;
+}
+
+/** Select the latest GFS cycle that should be available. */
+export function selectLatestGfsCycle(
+  nowMs,
+  { availabilityLagMs = 5 * 3600_000 } = {},
+) {
+  const d = new Date(nowMs - availabilityLagMs);
+  const date = new Date(
+    Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()),
+  );
+  const hour = Math.floor(d.getUTCHours() / 6) * 6;
+  date.setUTCHours(hour);
+  return { date: date.toISOString().slice(0, 10).replaceAll('-', ''), hour };
+}
+
+/**
+ * Round a time offset to the nearest published GFS forecast step so the field
+ * shown is the one valid closest to now, not always the analysis (f000).
+ * GFS 0.25° is hourly through f120, then every 3 h through f384.
+ * @param {number} hours - Hours elapsed since the cycle run time.
+ * @returns {number} A valid forecast step.
+ */
+export function nearestGfsStep(hours) {
+  const value = Math.max(0, Number.isFinite(hours) ? hours : 0);
+  const step = value <= 120 ? Math.round(value) : Math.round(value / 3) * 3;
+  return Math.max(0, Math.min(384, step));
+}

server/providers/wind/decode.js

@@ -0,0 +1,51 @@
+/** Lazy shared ecCodes WASM instance, created only for an active wind request. */
+let eccodesPromise = null;
+function loadEccodes() {
+  eccodesPromise ??= import('@meri-imperiumi/eccodes-wasm')
+    .then((module) => module.createEccodes())
+    .catch((error) => {
+      eccodesPromise = null;
+      throw error;
+    });
+  return eccodesPromise;
+}
+
+/** Decode one bounded message in WASM memory without mounting the host filesystem. */
+export async function decodeWindGribMessage(buffer, { eccodesModule } = {}) {
+  if (buffer.byteLength > 8 * 1024 * 1024)
+    throw new Error('Wind GRIB exceeds byte budget');
+  const eccodes = eccodesModule ?? (await loadEccodes());
+  // Everything after this await is synchronous. A shared virtual file is safe
+  // across U/V and model requests and its storage is released after each decode.
+  const file = '/gev-wind.grib2';
+  let handle = null;
+  try {
+    eccodes.writeFile(file, buffer);
+    handle = eccodes.openGrib(file);
+    const ni = handle.getLong('Ni');
+    const nj = handle.getLong('Nj');
+    if (
+      !Number.isInteger(ni) ||
+      !Number.isInteger(nj) ||
+      ni < 1 ||
+      nj < 1 ||
+      ni * nj > 2_000_000
+    )
+      throw new Error('Invalid wind GRIB geometry');
+    return {
+      ni,
+      nj,
+      lo1: handle.getDouble('longitudeOfFirstGridPointInDegrees'),
+      la1: handle.getDouble('latitudeOfFirstGridPointInDegrees'),
+      di: handle.getDouble('iDirectionIncrementInDegrees'),
+      dj: handle.getDouble('jDirectionIncrementInDegrees'),
+      values: handle.getDoubleArray('values'),
+      shortName: handle.getString('shortName'),
+      level: handle.getLong('level'),
+      units: handle.getString('units'),
+    };
+  } finally {
+    handle?.delete();
+    eccodes.writeFile(file, new Uint8Array(0));
+  }
+}

server/providers/wind/gfs.js

@@ -0,0 +1,221 @@
+import { readWindBody } from '../../../src/sources/windBody.js';
+/**
+ * Parse a GFS `.idx` inventory into ordered message records.
+ *
+ * Each line is `msgNumber:byteOffset:d=YYYYMMDDHH:VAR:LEVEL:...:`. Malformed
+ * lines are skipped; a payload with no valid lines is rejected so callers never
+ * treat an HTML error page as an empty inventory.
+ *
+ * @param {string} text - Raw `.idx` body.
+ * @returns {{ messages: Array<{index: number, offset: number, variable: string, level: string}> }}
+ */
+export function parseGfsIdx(text) {
+  const messages = [];
+  for (const line of String(text).split(/\r?\n/)) {
+    if (!line) continue;
+    const parts = line.split(':');
+    if (
+      parts.length < 6 ||
+      !/^\d+$/.test(parts[0]) ||
+      !/^\d+$/.test(parts[1]) ||
+      !parts[3] ||
+      !parts[4]
+    )
+      continue;
+    messages.push({
+      index: Number(parts[0]),
+      offset: Number(parts[1]),
+      variable: parts[3],
+      level: parts[4],
+    });
+  }
+  if (!messages.length) throw new Error('malformed GFS index');
+  return { messages };
+}
+
+/**
+ * Byte ranges for the two 10 m wind components. A message runs from its own
+ * offset to one byte before the next message in file order.
+ *
+ * @param {{messages: Array<object>}} parsed - {@link parseGfsIdx} result.
+ * @param {{level?: string}} [options]
+ * @returns {{u: {start: number, end: number}, v: {start: number, end: number}}}
+ */
+export function windMessageRanges(
+  parsed,
+  { level = '10 m above ground', overlay = 'none' } = {},
+) {
+  weatherScalarMetadata(overlay);
+  const range = (variable, fieldLevel = level) => {
+    const index = parsed.messages.findIndex(
+      (message) =>
+        message.variable === variable && message.level === fieldLevel,
+    );
+    const message = parsed.messages[index];
+    const next = parsed.messages[index + 1];
+    if (!message || !next)
+      throw new Error(`missing ${variable} at ${fieldLevel}`);
+    return { start: message.offset, end: next.offset - 1 };
+  };
+  return {
+    u: range('UGRD'),
+    v: range('VGRD'),
+    ...(overlay === 'temperature'
+      ? { scalar: range('TMP', '2 m above ground') }
+      : {}),
+    ...(overlay === 'pressure'
+      ? { scalar: range('PRMSL', 'mean sea level') }
+      : {}),
+  };
+}
+
+/** Fetch a bounded text response as a Buffer. */
+export async function fetchText({ url, fetchImpl = fetch, signal }) {
+  const response = await fetchImpl(url, { signal, redirect: 'error' });
+  if (!response.ok) {
+    await response.body?.cancel();
+    throw new Error('Wind upstream unavailable');
+  }
+  return Buffer.from(await readWindBody(response, 2 * 1024 * 1024, signal));
+}
+
+/**
+ * Fetch one bounded byte range. Rejects oversized ranges, non-206 responses
+ * (except a whole-object 200 starting at zero), and short bodies.
+ */
+export async function fetchRange({
+  url,
+  start,
+  end,
+  fetchImpl = fetch,
+  signal,
+  maxBytes = 8 * 1024 * 1024,
+}) {
+  if (
+    !Number.isSafeInteger(start) ||
+    !Number.isSafeInteger(end) ||
+    start < 0 ||
+    end < start ||
+    end - start + 1 > maxBytes
+  )
+    throw new Error('range too large');
+  const response = await fetchImpl(url, {
+    signal,
+    redirect: 'error',
+    headers: { Range: `bytes=${start}-${end}` },
+  });
+  const validStatus =
+    response.status === 206 || (response.status === 200 && start === 0);
+  if (!validStatus || !response.ok) {
+    await response.body?.cancel();
+    throw new Error('Wind upstream unavailable');
+  }
+  const buffer = Buffer.from(
+    await readWindBody(response, end - start + 1, signal),
+  );
+  if (buffer.length !== end - start + 1)
+    throw new Error('invalid range length');
+  return buffer;
+}
+
+/** A bounded optional request may fail without cancelling valid wind siblings. */
+export async function loadOptionalScalar({
+  range,
+  url,
+  fetchImpl,
+  decodeImpl,
+  signal,
+  timeoutMs = 12_000,
+}) {
+  if (!range) return undefined;
+  const controller = new AbortController();
+  const abort = () => controller.abort(signal.reason);
+  signal?.addEventListener('abort', abort, { once: true });
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    signal?.throwIfAborted();
+    const bytes = await fetchRange({
+      url,
+      ...range,
+      fetchImpl,
+      signal: controller.signal,
+    });
+    const value = await decodeImpl(bytes);
+    controller.signal.throwIfAborted();
+    return value;
+  } catch {
+    return undefined;
+  } finally {
+    clearTimeout(timer);
+    controller.abort();
+    signal?.removeEventListener('abort', abort);
+  }
+}
+
+import {
+  GFS_BUCKET,
+  gfsObjectKey,
+  selectLatestGfsCycle,
+  nearestGfsStep,
+} from './catalog.js';
+import { decodeWindGribMessage } from './decode.js';
+import { resampleWeatherSnapshot, weatherScalarMetadata } from './grid.js';
+
+/** Fetch and decode the GFS 10 m wind field valid closest to now. */
+export async function fetchGfsWind({
+  fetchImpl = fetch,
+  now = () => Date.now(),
+  targetDx = 1,
+  decodeImpl = decodeWindGribMessage,
+  signal,
+  overlay = 'none',
+} = {}) {
+  weatherScalarMetadata(overlay);
+  const nowMs = now();
+  const cycle = selectLatestGfsCycle(nowMs);
+  const runMs = Date.UTC(
+    Number(cycle.date.slice(0, 4)),
+    Number(cycle.date.slice(4, 6)) - 1,
+    Number(cycle.date.slice(6, 8)),
+    cycle.hour,
+  );
+  // Pick the forecast step whose valid time is closest to now, so the layer
+  // shows the freshest field the cycle offers instead of the analysis.
+  const forecastHour = nearestGfsStep((nowMs - runMs) / 3600_000);
+  const base = `https://${GFS_BUCKET}.s3.amazonaws.com/${gfsObjectKey({ ...cycle, forecastHour })}`;
+  const index = await fetchText({ url: `${base}.idx`, fetchImpl, signal });
+  const inventory = parseGfsIdx(index.toString());
+  const ranges = windMessageRanges(inventory);
+  let scalarRange;
+  if (overlay !== 'none') {
+    try {
+      scalarRange = windMessageRanges(inventory, { overlay }).scalar;
+    } catch {
+      /* A missing optional field does not discard valid wind. */
+    }
+  }
+  // All selected messages come from this one issue/valid-time object.
+  const load = async (range) =>
+    decodeImpl(await fetchRange({ url: base, ...range, fetchImpl, signal }));
+  const [u, v, scalar] = await Promise.all([
+    load(ranges.u),
+    load(ranges.v),
+    loadOptionalScalar({
+      range: scalarRange,
+      url: base,
+      fetchImpl,
+      decodeImpl,
+      signal,
+    }),
+  ]);
+  signal?.throwIfAborted();
+  const fields = resampleWeatherSnapshot({ u, v, scalar, overlay, targetDx });
+  const runIso = new Date(runMs).toISOString();
+  const validIso = new Date(runMs + forecastHour * 3600_000).toISOString();
+  return {
+    cycle: { ...cycle, forecastHour, runIso, validIso },
+    level: '10 m above ground',
+    units: 'm/s',
+    ...fields,
+  };
+}

server/providers/wind/grid.js

@@ -0,0 +1,172 @@
+/**
+ * Resample a GRIB wind grid into a compact equirectangular grid.
+ *
+ * Source grids are north-to-south (`la1` at the top, `dj` increasing toward the
+ * south) and start at `lo1`. Longitude wraps across the seam; latitude clamps.
+ *
+ * @param {{u: ArrayLike<number>, v: ArrayLike<number>, ni: number, nj: number,
+ *   lo1: number, la1: number, di: number, dj: number, dx?: number, dy?: number}} input
+ * @returns {{nx: number, ny: number, lo1: number, la1: number, dx: number,
+ *   dy: number, u: Float32Array, v: Float32Array}}
+ */
+export function resampleWindGrid({
+  u,
+  v,
+  scalar,
+  scalarScale = 1,
+  scalarOffset = 0,
+  ni,
+  nj,
+  lo1,
+  la1,
+  di,
+  dj,
+  dx = 1,
+  dy = 1,
+}) {
+  if (
+    !Number.isInteger(ni) ||
+    !Number.isInteger(nj) ||
+    ni < 1 ||
+    nj < 1 ||
+    ni * nj > 2_000_000 ||
+    u?.length !== ni * nj ||
+    v?.length !== ni * nj ||
+    (scalar !== undefined && scalar?.length !== ni * nj) ||
+    ![lo1, la1, di, dj, dx, dy, scalarScale, scalarOffset].every(
+      Number.isFinite,
+    ) ||
+    di <= 0 ||
+    dj <= 0 ||
+    dx < 0.25 ||
+    dy < 0.25 ||
+    dx > 180 ||
+    dy > 180
+  )
+    throw new Error('Invalid wind grid geometry');
+  for (const values of [u, v, ...(scalar === undefined ? [] : [scalar])]) {
+    if (!Array.prototype.every.call(values, Number.isFinite))
+      throw new Error('Invalid wind grid values');
+  }
+  const nx = Math.round(360 / dx);
+  const ny = Math.round(180 / dy) + 1;
+  if (nx * ny > 1_000_000)
+    throw new Error('Resampled wind grid exceeds point budget');
+  const outU = new Float32Array(nx * ny);
+  const outV = new Float32Array(nx * ny);
+  const outScalar = scalar === undefined ? null : new Float32Array(nx * ny);
+  const sample = (source, lon, lat) => {
+    const x = ((lon - lo1) / di + ni) % ni;
+    const y = Math.max(0, Math.min(nj - 1, (la1 - lat) / dj));
+    const x0 = Math.floor(x);
+    const x1 = (x0 + 1) % ni;
+    const y0 = Math.floor(y);
+    const y1 = Math.min(nj - 1, y0 + 1);
+    const fx = x - x0;
+    const fy = y - y0;
+    const top = source[y0 * ni + x0] * (1 - fx) + source[y0 * ni + x1] * fx;
+    const bottom = source[y1 * ni + x0] * (1 - fx) + source[y1 * ni + x1] * fx;
+    return top * (1 - fy) + bottom * fy;
+  };
+  for (let y = 0; y < ny; y += 1) {
+    for (let x = 0; x < nx; x += 1) {
+      const index = y * nx + x;
+      const lon = x * dx;
+      const lat = 90 - y * dy;
+      outU[index] = sample(u, lon, lat);
+      outV[index] = sample(v, lon, lat);
+      if (outScalar)
+        outScalar[index] =
+          sample(scalar, lon, lat) * scalarScale + scalarOffset;
+    }
+  }
+  for (const values of [outU, outV, ...(outScalar ? [outScalar] : [])]) {
+    if (!values.every(Number.isFinite))
+      throw new Error('Invalid resampled wind values');
+  }
+  return {
+    nx,
+    ny,
+    lo1: 0,
+    la1: 90,
+    dx,
+    dy,
+    u: outU,
+    v: outV,
+    ...(outScalar ? { scalar: outScalar } : {}),
+  };
+}
+
+/** Metadata for the two optional same-cycle weather fields. */
+export function weatherScalarMetadata(overlay = 'none') {
+  if (overlay === 'none') return null;
+  if (overlay === 'temperature')
+    return { kind: overlay, units: '°C', level: '2 m above ground' };
+  if (overlay === 'pressure')
+    return { kind: overlay, units: 'hPa', level: 'mean sea level' };
+  throw new Error('Unknown weather overlay');
+}
+
+/** Reject shifted/mismatched components before sharing U's grid geometry. */
+export function resampleWeatherFields({
+  u,
+  v,
+  scalar,
+  overlay = 'none',
+  targetDx = 1,
+}) {
+  const metadata = weatherScalarMetadata(overlay);
+  const fields = [u, v, ...(metadata ? [scalar] : [])];
+  if (
+    !u ||
+    fields.some(
+      (field) =>
+        !field ||
+        ['ni', 'nj', 'lo1', 'la1', 'di', 'dj'].some(
+          (key) => field[key] !== u[key],
+        ),
+    )
+  )
+    throw new Error('Mismatched weather grid geometry');
+  if (metadata && scalar.units !== (overlay === 'temperature' ? 'K' : 'Pa'))
+    throw new Error('Unexpected weather scalar units');
+  const grid = resampleWindGrid({
+    u: u.values,
+    v: v.values,
+    ni: u.ni,
+    nj: u.nj,
+    lo1: u.lo1,
+    la1: u.la1,
+    di: u.di,
+    dj: u.dj,
+    dx: targetDx,
+    dy: targetDx,
+    ...(metadata
+      ? {
+          scalar: scalar.values,
+          scalarScale: overlay === 'pressure' ? 0.01 : 1,
+          scalarOffset: overlay === 'temperature' ? -273.15 : 0,
+        }
+      : {}),
+  });
+  return { grid, ...(metadata ? { scalar: metadata } : {}) };
+}
+
+/** Preserve usable same-cycle wind when only its optional companion fails. */
+export function resampleWeatherSnapshot(options) {
+  try {
+    return resampleWeatherFields(options);
+  } catch (error) {
+    if ((options.overlay ?? 'none') === 'none') throw error;
+    // Revalidate wind alone: a wind defect must never become a partial success.
+    const wind = resampleWeatherFields({ ...options, overlay: 'none' });
+    return { ...wind, scalarError: weatherScalarError(options.overlay) };
+  }
+}
+
+export function weatherScalarError(overlay) {
+  weatherScalarMetadata(overlay);
+  return overlay === 'temperature'
+    ? 'Temperature field unavailable'
+    : 'Mean sea level pressure field unavailable';
+}

server/providers/wind/ifs.js

@@ -0,0 +1,166 @@
+import { fetchText, fetchRange, loadOptionalScalar } from './gfs.js';
+import { decodeWindGribMessage } from './decode.js';
+import { resampleWeatherSnapshot, weatherScalarMetadata } from './grid.js';
+
+/** Keyless ECMWF Open Data root for real-time IFS forecasts. */
+export const IFS_BASE = 'https://data.ecmwf.int/forecasts';
+
+/**
+ * Select the latest IFS cycle that should be available.
+ * @param {number} nowMs - Reference epoch milliseconds.
+ * @param {{availabilityLagMs?: number}} [options]
+ * @returns {{date: string, hour: number}}
+ */
+export function selectLatestIfsCycle(
+  nowMs,
+  { availabilityLagMs = 6 * 3600_000 } = {},
+) {
+  const shifted = new Date(nowMs - availabilityLagMs);
+  return {
+    date: shifted.toISOString().slice(0, 10).replaceAll('-', ''),
+    hour: Math.floor(shifted.getUTCHours() / 6) * 6,
+  };
+}
+
+/**
+ * Build the IFS GRIB2 and `.index` URLs for one cycle and step.
+ * @param {{date: string, hour: number, step?: number}} cycle
+ * @returns {{grib: string, index: string}}
+ */
+export function ifsObjectUrls({ date, hour, step = 0 }) {
+  const hh = String(hour).padStart(2, '0');
+  const stem = `${IFS_BASE}/${date}/${hh}z/ifs/0p25/oper/${date}${hh}0000-${step}h-oper-fc`;
+  // The inventory sits beside the GRIB2 as `<stem>.index`, NOT `<grib2>.index`.
+  return { grib: `${stem}.grib2`, index: `${stem}.index` };
+}
+
+/**
+ * Parse the IFS JSON Lines inventory into `{param, offset, length}` records.
+ * Malformed lines are skipped; a payload with no valid lines is rejected.
+ * @param {string} text - Raw `.index` body.
+ * @returns {Array<{param: string, offset: number, length: number}>}
+ */
+export function parseIfsIndex(text) {
+  const entries = [];
+  for (const line of String(text).split(/\r?\n/)) {
+    if (!line) continue;
+    let value;
+    try {
+      value = JSON.parse(line);
+    } catch {
+      continue; // non-JSON line in the index
+    }
+    if (
+      value?.param &&
+      Number.isFinite(value._offset) &&
+      Number.isFinite(value._length)
+    )
+      entries.push({
+        param: value.param,
+        offset: value._offset,
+        length: value._length,
+      });
+  }
+  if (!entries.length) throw new Error('malformed IFS index');
+  return entries;
+}
+
+/**
+ * Byte ranges for the IFS 10 m wind components.
+ * @param {Array<{param: string, offset: number, length: number}>} entries
+ * @returns {{u: {start: number, end: number}, v: {start: number, end: number}}}
+ */
+export function ifsWindRanges(entries, { overlay = 'none' } = {}) {
+  weatherScalarMetadata(overlay);
+  const range = (param) => {
+    const item = entries.find((entry) => entry.param === param);
+    if (!item) throw new Error(`missing ${param}`);
+    return { start: item.offset, end: item.offset + item.length - 1 };
+  };
+  return {
+    u: range('10u'),
+    v: range('10v'),
+    ...(overlay === 'temperature' ? { scalar: range('2t') } : {}),
+    ...(overlay === 'pressure' ? { scalar: range('msl') } : {}),
+  };
+}
+
+/**
+ * Round a time offset to the nearest published IFS forecast step. IFS 0.25°
+ * oper is 3-hourly through f144, then 6-hourly to f360 for 00/12z.
+ * @param {number} hours - Hours elapsed since the cycle run time.
+ * @param {number} cycleHour - The cycle hour (0, 6, 12 or 18).
+ * @returns {number} A valid forecast step.
+ */
+export function nearestIfsStep(hours, cycleHour) {
+  const max = cycleHour === 6 || cycleHour === 18 ? 144 : 360;
+  const value = Math.max(0, Number.isFinite(hours) ? hours : 0);
+  const step =
+    value <= 144 ? Math.round(value / 3) * 3 : Math.round(value / 6) * 6;
+  return Math.max(0, Math.min(max, step));
+}
+
+/**
+ * Fetch and decode the IFS 10 m wind field valid closest to now.
+ * @param {{fetchImpl?: Function, now?: Function, targetDx?: number,
+ *   decodeImpl?: Function}} [options]
+ * @returns {Promise<{cycle: object, level: string, units: string, grid: object}>}
+ */
+export async function fetchIfsWind({
+  fetchImpl = fetch,
+  now = () => Date.now(),
+  targetDx = 1,
+  decodeImpl = decodeWindGribMessage,
+  signal,
+  overlay = 'none',
+} = {}) {
+  weatherScalarMetadata(overlay);
+  const nowMs = now();
+  const cycle = selectLatestIfsCycle(nowMs);
+  const runMs = Date.UTC(
+    Number(cycle.date.slice(0, 4)),
+    Number(cycle.date.slice(4, 6)) - 1,
+    Number(cycle.date.slice(6, 8)),
+    cycle.hour,
+  );
+  // Show the field valid closest to now rather than always the analysis.
+  const forecastHour = nearestIfsStep((nowMs - runMs) / 3600_000, cycle.hour);
+  const urls = ifsObjectUrls({ ...cycle, step: forecastHour });
+  const index = await fetchText({ url: urls.index, fetchImpl, signal });
+  const inventory = parseIfsIndex(index.toString());
+  const ranges = ifsWindRanges(inventory);
+  let scalarRange;
+  if (overlay !== 'none') {
+    try {
+      scalarRange = ifsWindRanges(inventory, { overlay }).scalar;
+    } catch {
+      /* A missing optional field does not discard valid wind. */
+    }
+  }
+  // All selected messages come from this one issue/valid-time object.
+  const load = async (range) =>
+    decodeImpl(
+      await fetchRange({ url: urls.grib, ...range, fetchImpl, signal }),
+    );
+  const [u, v, scalar] = await Promise.all([
+    load(ranges.u),
+    load(ranges.v),
+    loadOptionalScalar({
+      range: scalarRange,
+      url: urls.grib,
+      fetchImpl,
+      decodeImpl,
+      signal,
+    }),
+  ]);
+  signal?.throwIfAborted();
+  const fields = resampleWeatherSnapshot({ u, v, scalar, overlay, targetDx });
+  const runIso = new Date(runMs).toISOString();
+  const validIso = new Date(runMs + forecastHour * 3600_000).toISOString();
+  return {
+    cycle: { ...cycle, forecastHour, runIso, validIso },
+    level: '10 m above ground',
+    units: 'm/s',
+    ...fields,
+  };
+}