@aeroswarm/weather 0.1.4 → 0.2.0

package/dist/index.js

@@ -1,24 +1,47 @@
 // src/aftn.ts
-var KEYWORD = /\b(METAR|SPECI|TAF)\b/;
+var START = /(?:^|\s)(?:\(?(?<simple>METAR|SPECI|TAF|SNOWTAM)(?=[\s)])|(?:(?<fir>[A-Z]{4})\s+)?(?<hazard>SIGMET|AIRMET)\s+[A-Z]?\d{1,3}\s+VALID\b|(?<vaa>VA ADVISORY)(?=\s))/g;
 function extractReports(message) {
   const text = message.replace(/\r/g, "\n").replace(/\bZCZC\b[^\n]*/g, " ").replace(/\bNNNN\b/g, " ");
   const reports = [];
   for (const segment of text.split("=")) {
     const flat = segment.replace(/\s+/g, " ").trim();
-    const match = KEYWORD.exec(flat);
-    if (!match) continue;
-    const body = flat.slice(match.index);
-    reports.push({ kind: match[1], text: body });
+    const starts = [...flat.matchAll(START)].map((match) => {
+      const lead = match[0].length - match[0].trimStart().length;
+      const groups = match.groups ?? {};
+      const kind = groups.simple ?? groups.hazard ?? "VAA";
+      const offset = (match.index ?? 0) + lead + (match[0].trimStart().startsWith("(") ? 1 : 0);
+      return { kind, offset };
+    });
+    starts.forEach((start, i) => {
+      let body = flat.slice(start.offset, starts[i + 1]?.offset ?? flat.length).trim();
+      if (start.kind === "SNOWTAM") body = trimToClosingParenthesis(body);
+      reports.push({ kind: start.kind, text: body });
+    });
   }
   return reports;
 }
+function trimToClosingParenthesis(body) {
+  const close = body.lastIndexOf(")");
+  return close >= 0 ? body.slice(0, close).trim() : body;
+}
 
 // src/conditions.ts
 var KT_PER_MPS = 1.943844;
-var WIND = /^(\d{3}|VRB)(\d{2,3})(?:G(\d{2,3}))?(KT|MPS)$/;
+var WIND = /^(\d{3}|VRB)(\d{2,3})(?:G(\d{2,3}))?(KT|MPS)(?:(\d{3})V(\d{3}))?$/;
 var WIND_VARIABLE = /^(\d{3})V(\d{3})$/;
 var VISIBILITY = /^\d{4}$/;
-var CLOUD = /^(FEW|SCT|BKN|OVC)(\d{3}|\/\/\/)(CB|TCU|\/\/\/)?$/;
+var VISIBILITY_SM = /^([PM])?(\d+)(?:\/(\d+))?SM$/;
+var WHOLE_MILES = /^\d{1,2}$/;
+var METERS_PER_MILE = 1609.344;
+var RVR = /^R(\d{2}[LRC]?)\/([PM])?(\d{4})(?:V([PM])?(\d{4}))?(FT)?([UDN])?$/;
+var FEET_TO_M = 0.3048;
+var RUNWAY_STATE = /^R\d{2}[LRC]?\/(?:CLRD\d{2}|CLRD\/\/|[\d/]{6}|\/{4})$/;
+var WIND_SHEAR_RUNWAY = /^R\d{2}[LRC]?$/;
+var RECENT_WEATHER = /^RE(?:[-+]|VC)?(?:(?:MI|BC|PR|DR|BL|SH|TS|FZ)(?:DZ|RA|SN|SG|IC|PL|GR|GS|UP|BR|FG|FU|VA|DU|SA|HZ|PO|SQ|FC|SS|DS)*|(?:DZ|RA|SN|SG|IC|PL|GR|GS|UP|BR|FG|FU|VA|DU|SA|HZ|PO|SQ|FC|SS|DS)+)$/;
+var DIRECTIONAL_VISIBILITY = /^\d{4}(?:N|NE|E|SE|S|SW|W|NW)$/;
+var WIND_SHEAR = /^WS\d{3}\/\d{3}\d{2,3}KT$/;
+var MISSING = /^\/{2,}$/;
+var CLOUD = /^(FEW|SCT|BKN|OVC)(\d{3}|\/\/\/)(CB|TCU|\/\/\/)?(?:\/(CB|TCU))?$/;
 var VERTICAL_VISIBILITY = /^VV(\d{3}|\/\/\/)$/;
 var WEATHER = /^([-+]|VC)?(MI|BC|PR|DR|BL|SH|TS|FZ)?((?:DZ|RA|SN|SG|IC|PL|GR|GS|UP|BR|FG|FU|VA|DU|SA|HZ|PO|SQ|FC|SS|DS)*)$/;
 function emptyConditions() {
@@ -59,8 +82,51 @@ function parseConditionTokens(tokens) {
   const out = { rest: [] };
   const clouds = [];
   const weather = [];
+  const rvr = [];
   let sawCloudGroup = false;
-  for (const token of tokens) {
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens[index];
+    if (WHOLE_MILES.test(token)) {
+      const fraction = (tokens[index + 1] ?? "").match(VISIBILITY_SM);
+      if (fraction?.[3]) {
+        out.visibilityM = Math.round(
+          Math.min(1e4, (Number(token) + Number(fraction[2]) / Number(fraction[3])) * METERS_PER_MILE)
+        );
+        index++;
+        continue;
+      }
+    }
+    const miles = token.match(VISIBILITY_SM);
+    if (miles) {
+      const value = miles[3] ? Number(miles[2]) / Number(miles[3]) : Number(miles[2]);
+      out.visibilityM = miles[1] === "P" ? 1e4 : Math.round(Math.min(1e4, value * METERS_PER_MILE));
+      continue;
+    }
+    const runwayVisual = token.match(RVR);
+    if (runwayVisual) {
+      const unit = runwayVisual[6] === "FT" ? FEET_TO_M : 1;
+      const value = Number(runwayVisual[3]) * unit;
+      const entry = { runway: runwayVisual[1], meters: Math.round(value) };
+      if (runwayVisual[2]) entry.modifier = runwayVisual[2] === "P" ? "above" : "below";
+      if (runwayVisual[5]) {
+        entry.variableMinM = Math.round(value);
+        entry.variableMaxM = Math.round(Number(runwayVisual[5]) * unit);
+      }
+      if (runwayVisual[7]) {
+        entry.trend = runwayVisual[7] === "U" ? "up" : runwayVisual[7] === "D" ? "down" : "none";
+      }
+      rvr.push(entry);
+      continue;
+    }
+    if (token === "WS") {
+      const next = tokens[index + 1] ?? "";
+      if (WIND_SHEAR_RUNWAY.test(next)) index++;
+      else if (next === "ALL" && tokens[index + 2] === "RWY") index += 2;
+      continue;
+    }
+    if (RUNWAY_STATE.test(token) || RECENT_WEATHER.test(token) || DIRECTIONAL_VISIBILITY.test(token) || WIND_SHEAR.test(token) || MISSING.test(token)) {
+      continue;
+    }
     const wind = token.match(WIND);
     if (wind) {
       const variable = wind[1] === "VRB";
@@ -68,7 +134,8 @@ function parseConditionTokens(tokens) {
         directionDeg: variable ? null : Number(wind[1]),
         variable,
         speedKt: toKnots(Number(wind[2]), wind[4] ?? "KT"),
-        gustKt: wind[3] ? toKnots(Number(wind[3]), wind[4] ?? "KT") : null
+        gustKt: wind[3] ? toKnots(Number(wind[3]), wind[4] ?? "KT") : null,
+        ...wind[5] && wind[6] ? { variableFromDeg: Number(wind[5]), variableToDeg: Number(wind[6]) } : {}
       };
       continue;
     }
@@ -93,7 +160,8 @@ function parseConditionTokens(tokens) {
       clouds.push({
         cover: cloud[1],
         baseFt: cloud[2] === "///" ? null : Number(cloud[2]) * 100,
-        type: cloud[3] === "CB" || cloud[3] === "TCU" ? cloud[3] : void 0
+        // `FEW025TCU/CB` (dua kemungkinan): dicatat CB, yang lebih berbahaya.
+        type: cloud[3] === "CB" || cloud[4] === "CB" ? "CB" : cloud[3] === "TCU" || cloud[4] === "TCU" ? "TCU" : void 0
       });
       continue;
     }
@@ -106,7 +174,7 @@ function parseConditionTokens(tokens) {
       });
       continue;
     }
-    if (token === "SKC" || token === "NSC" || token === "NCD") {
+    if (token === "SKC" || token === "CLR" || token === "NSC" || token === "NCD") {
       sawCloudGroup = true;
       out.clouds = [];
       continue;
@@ -120,11 +188,19 @@ function parseConditionTokens(tokens) {
       weather.push(present);
       continue;
     }
+    if (token.includes("/")) {
+      const alternatives = token.split("/").map((part) => parseWeather(part));
+      if (alternatives.every((a) => a !== null)) {
+        weather.push(...alternatives);
+        continue;
+      }
+    }
     out.rest.push(token);
   }
   if (clouds.length > 0) out.clouds = clouds;
   else if (sawCloudGroup) out.clouds = [];
   if (weather.length > 0) out.weather = weather;
+  if (rvr.length > 0) out.rvr = rvr;
   return out;
 }
 function mergeConditions(base, next) {
@@ -133,7 +209,8 @@ function mergeConditions(base, next) {
     visibilityM: next.visibilityM ?? base.visibilityM,
     cavok: next.cavok ?? base.cavok,
     clouds: next.clouds ?? base.clouds,
-    weather: next.weather ?? base.weather
+    weather: next.weather ?? base.weather,
+    rvr: next.rvr ?? base.rvr
   };
   if (next.noSignificantWeather) merged.weather = [];
   if (next.cavok) {
@@ -204,6 +281,10 @@ function parseMetar(raw, reference = /* @__PURE__ */ new Date()) {
       auto = true;
       continue;
     }
+    if (token === "COR") {
+      corrected = true;
+      continue;
+    }
     const temp = token.match(TEMPERATURE);
     if (temp?.[1]) {
       temperatureC = signed(temp[1]);
@@ -234,10 +315,520 @@ function parseMetar(raw, reference = /* @__PURE__ */ new Date()) {
     dewPointC,
     qnhHpa,
     trend,
+    unparsed: parsed.rest,
     raw: tokens.join(" ")
   };
 }
 
+// src/nil.ts
+var NIL = /^(METAR|SPECI|TAF)(?: (?:COR|AMD|CCA|CCB))* ([A-Z]{4})(?: (\d{2})(\d{2})(\d{2})Z)? NIL$/;
+function parseNil(rawText, reference = /* @__PURE__ */ new Date()) {
+  const text = rawText.replace(/\s+/g, " ").trim().replace(/=$/, "").trim();
+  const match = text.match(NIL);
+  if (!match) return null;
+  const at = match[3] ? resolveDayTime(reference, Number(match[3]), Number(match[4]), Number(match[5])) : reference;
+  if (Number.isNaN(at.getTime())) return null;
+  return { kind: "NIL", of: match[1], station: match[2], at, raw: text };
+}
+
+// src/geo.ts
+var COMPASS_DEGREES = {
+  N: 0,
+  NNE: 22.5,
+  NE: 45,
+  ENE: 67.5,
+  E: 90,
+  ESE: 112.5,
+  SE: 135,
+  SSE: 157.5,
+  S: 180,
+  SSW: 202.5,
+  SW: 225,
+  WSW: 247.5,
+  W: 270,
+  WNW: 292.5,
+  NW: 315,
+  NNW: 337.5
+};
+var isCompass = (value) => value in COMPASS_DEGREES;
+var compassDegrees = (direction) => COMPASS_DEGREES[direction];
+var POINT = String.raw`[NS]\d{2,6}\s?[EW]\d{3,7}`;
+var POINT_PARTS = /^([NS])(\d{2,6})\s?([EW])(\d{3,7})$/;
+function degreesMinutes(digits, degreeDigits) {
+  const degrees = Number(digits.slice(0, degreeDigits));
+  const rest = digits.slice(degreeDigits);
+  const minutes = rest === "" ? 0 : Number(rest.padEnd(2, "0").slice(0, 2));
+  const seconds = rest.length > 2 ? Number(rest.slice(2).padEnd(2, "0").slice(0, 2)) : 0;
+  return degrees + minutes / 60 + seconds / 3600;
+}
+function parsePosition(text) {
+  const match = text.trim().match(POINT_PARTS);
+  if (!match) return null;
+  const [, ns, latDigits, ew, lonDigits] = match;
+  const lat = degreesMinutes(latDigits, 2) * (ns === "S" ? -1 : 1);
+  const lonDegreeDigits = lonDigits.length === 4 ? 2 : 3;
+  const lon = degreesMinutes(lonDigits, lonDegreeDigits) * (ew === "W" ? -1 : 1);
+  if (Math.abs(lat) > 90 || Math.abs(lon) > 180) return null;
+  return { lat: Math.round(lat * 1e4) / 1e4, lon: Math.round(lon * 1e4) / 1e4 };
+}
+function parsePositions(text) {
+  const points = [];
+  for (const match of text.matchAll(new RegExp(POINT, "g"))) {
+    const point = parsePosition(match[0]);
+    if (point) points.push(point);
+  }
+  return points;
+}
+var LEVEL = String.raw`(?:SFC|FL\d{3}|\d{3,5}FT|\d{3,5}M)`;
+var levelFeet = (token) => {
+  if (token === "SFC") return 0;
+  let m = token.match(/^FL(\d{3})$/);
+  if (m) return Number(m[1]) * 100;
+  m = token.match(/^(\d{3,5})FT$/);
+  if (m) return Number(m[1]);
+  m = token.match(/^(\d{3,5})M$/);
+  if (m) return Math.round(Number(m[1]) * 3.28084);
+  return null;
+};
+var ALTITUDE_PATTERNS = {
+  /** `TOP FL490`, `TOP ABV FL450`, `TOP FL250/390`. */
+  top: new RegExp(String.raw`\b(?:CB\s+)?TOPS?\s+(?:TO\s+)?(ABV\s+)?(FL\d{3})(?:\/(\d{3}))?`),
+  /** `FL240/300`, `SFC/FL100`, `SFC/6000FT`, `2000/4000FT`. */
+  range: new RegExp(String.raw`\b(?:FL(\d{3})\/(\d{3})\b|(${LEVEL}|\d{3,5})\/(${LEVEL}))`),
+  /** `ABV FL250` sendirian. */
+  above: new RegExp(String.raw`\bABV\s+(FL\d{3})`)
+};
+function findAltitude(text) {
+  const top = text.match(ALTITUDE_PATTERNS.top);
+  if (top) {
+    const first = levelFeet(top[2]);
+    const second = top[3] ? Number(top[3]) * 100 : null;
+    return {
+      matched: top[0],
+      range: second ? { baseFt: first, topFt: second } : { baseFt: null, topFt: first, ...top[1] ? { topAbove: true } : {} }
+    };
+  }
+  const range = text.match(ALTITUDE_PATTERNS.range);
+  if (range) {
+    if (range[1] && range[2]) {
+      return { matched: range[0], range: { baseFt: Number(range[1]) * 100, topFt: Number(range[2]) * 100 } };
+    }
+    const baseToken = /^\d{3,5}$/.test(range[3]) ? `${range[3]}${range[4].replace(/^.*?(FT|M)$/, "$1")}` : range[3];
+    return {
+      matched: range[0],
+      range: { baseFt: levelFeet(baseToken), topFt: levelFeet(range[4]) }
+    };
+  }
+  const above = text.match(ALTITUDE_PATTERNS.above);
+  if (above) {
+    return { matched: above[0], range: { baseFt: levelFeet(above[1]), topFt: null } };
+  }
+  const single = text.match(/\bFL(\d{3})\b/);
+  if (single) {
+    const level = Number(single[1]) * 100;
+    return { matched: single[0], range: { baseFt: level, topFt: level } };
+  }
+  return null;
+}
+var KMH_TO_KT = 0.539957;
+function findMovement(text) {
+  const stationary = text.match(/\bSTNR\b/);
+  const moving = text.match(/\bMOV(?:ING)?\s+(?:FROM\s+)?([NSEW]{1,3})(?:\s+(\d{1,3})(?:-(\d{1,3}))?\s*(KT|KMH))?/);
+  if (moving && isCompass(moving[1])) {
+    const toKt = (value) => moving[4] === "KMH" ? Math.round(Number(value) * KMH_TO_KT) : Number(value);
+    const speed = moving[2] === void 0 ? void 0 : toKt(moving[3] ?? moving[2]);
+    const min = moving[3] !== void 0 && moving[2] !== void 0 ? toKt(moving[2]) : void 0;
+    return {
+      matched: moving[0],
+      movement: {
+        stationary: false,
+        direction: moving[1],
+        ...speed !== void 0 ? { speedKt: speed } : {},
+        ...min !== void 0 ? { speedMinKt: min } : {}
+      }
+    };
+  }
+  if (stationary) return { matched: stationary[0], movement: { stationary: true } };
+  return null;
+}
+
+// src/sigmet.ts
+var HEADER = /^(?:([A-Z]{4}) )?(SIGMET|AIRMET) ([A-Z]?\d{1,3}) VALID (\d{6})\/(\d{6})(?: ([A-Z]{4})-?)?/;
+var FIR_NAME = /^([A-Z0-9'.-]+(?: [A-Z0-9'.-]+){0,5}? (?:FIR\/UIR|FIR|UIR|CTA))(?= |$)/;
+var CANCEL = /^CNL (SIGMET|AIRMET) ([A-Z]?\d{1,3}) (\d{6})\/(\d{6})(?: (.*))?$/;
+var POINTS = String.raw`${POINT}(?:\s*-\s*${POINT})*`;
+var SIDE = "(N|NNE|NE|ENE|E|ESE|SE|SSE|S|SSW|SW|WSW|W|WNW|NW|NNW)";
+var KM_TO_NM = 0.539957;
+var dayTime = (reference, token) => resolveDayTime(reference, Number(token.slice(0, 2)), Number(token.slice(2, 4)), Number(token.slice(4, 6)));
+function timeNear(validFrom, hhmm2) {
+  let best = null;
+  for (const offset of [-1, 0, 1]) {
+    const candidate = new Date(
+      Date.UTC(
+        validFrom.getUTCFullYear(),
+        validFrom.getUTCMonth(),
+        validFrom.getUTCDate() + offset,
+        Number(hhmm2.slice(0, 2)),
+        Number(hhmm2.slice(2, 4))
+      )
+    );
+    if (best === null || Math.abs(candidate.getTime() - validFrom.getTime()) < Math.abs(best.getTime() - validFrom.getTime())) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+var blank = (text, matched) => text.replace(matched, " ".repeat(matched.length));
+var FILLER = /* @__PURE__ */ new Set(["-", "AND", "VA", "CLD", "AT", "OF", "WI", "CB", "TC", "CENTRE", "PSN", "OBS", "FCST"]);
+function leftovers(rest) {
+  const words = rest.split(/\s+/).filter((w) => w !== "" && !FILLER.has(w));
+  return words.length > 0 ? [words.join(" ")] : [];
+}
+function findArea(text) {
+  const entire = text.match(/\b(?:ENTIRE|WHOLE) FIR\b/);
+  if (entire) return { area: { kind: "entire-fir" }, matched: entire[0] };
+  const circle = text.match(new RegExp(String.raw`\bWI (\d+)\s*(NM|KM) OF (TC CENTRE|CENTRE|VA CENTRE|(${POINT}))`));
+  if (circle) {
+    const radius = Number(circle[1]) * (circle[2] === "KM" ? KM_TO_NM : 1);
+    const centre = circle[4] ? parsePosition(circle[4]) : null;
+    return {
+      area: {
+        kind: "circle",
+        radiusNm: Math.round(radius * 10) / 10,
+        center: centre ?? (circle[3]?.startsWith("VA") ? "VA_CENTRE" : circle[3] ? "TC_CENTRE" : null)
+      },
+      matched: circle[0]
+    };
+  }
+  const corridor = text.match(new RegExp(String.raw`\bWI (\d+)\s*NM WID LINE BTN (${POINTS})`));
+  if (corridor) {
+    return {
+      area: { kind: "corridor", widthNm: Number(corridor[1]), points: parsePositions(corridor[2]) },
+      matched: corridor[0]
+    };
+  }
+  const sideLine = text.match(new RegExp(String.raw`\b${SIDE} OF LINE (${POINTS})`));
+  if (sideLine) {
+    return {
+      area: { kind: "line", side: sideLine[1], points: parsePositions(sideLine[2]) },
+      matched: sideLine[0]
+    };
+  }
+  const line = text.match(new RegExp(String.raw`\bLINE (${POINTS})`));
+  if (line) {
+    return { area: { kind: "line", side: null, points: parsePositions(line[1]) }, matched: line[0] };
+  }
+  const latitude = text.match(/\b(N|S|NE|SE|NW|SW) OF ([NS])(\d{2,4})\b/);
+  if (latitude) {
+    const sign = latitude[2] === "S" ? -1 : 1;
+    const digits = latitude[3];
+    const lat = sign * (Number(digits.slice(0, 2)) + (digits.length > 2 ? Number(digits.slice(2).padEnd(2, "0")) / 60 : 0));
+    return { area: { kind: "latitude-line", side: latitude[1], lat: Math.round(lat * 1e4) / 1e4 }, matched: latitude[0] };
+  }
+  const longitude = text.match(/\b(E|W|NE|SE|NW|SW) OF ([EW])(\d{3,5})\b/);
+  if (longitude) {
+    const sign = longitude[2] === "W" ? -1 : 1;
+    const digits = longitude[3];
+    const lon = sign * (Number(digits.slice(0, 3)) + (digits.length > 3 ? Number(digits.slice(3).padEnd(2, "0")) / 60 : 0));
+    return { area: { kind: "longitude-line", side: longitude[1], lon: Math.round(lon * 1e4) / 1e4 }, matched: longitude[0] };
+  }
+  const polygon = text.match(new RegExp(String.raw`\bWI (${POINTS})`));
+  if (polygon) {
+    return { area: { kind: "polygon", points: parsePositions(polygon[1]) }, matched: polygon[0] };
+  }
+  const bare = text.match(new RegExp(String.raw`(?:^|\s)(${POINTS})`));
+  if (bare) {
+    const points = parsePositions(bare[1]);
+    if (points.length >= 3) return { area: { kind: "polygon", points }, matched: bare[1] };
+  }
+  return null;
+}
+function readPhenomenon(body) {
+  let m = body.match(/^(OBSC|EMBD|FRQ|SQL|ISOL|OCNL) (TSGR|TS)\b/);
+  if (m) return { hazard: "THUNDERSTORM", phrase: m[0], length: m[0].length };
+  m = body.match(/^(ISOL|OCNL|FRQ) (CB|TCU)\b/);
+  if (m) return { hazard: "THUNDERSTORM", phrase: m[0], length: m[0].length };
+  m = body.match(new RegExp(String.raw`^TC ([A-Z0-9-]+)(?: PSN (${POINT}))?( CB)?`));
+  if (m) {
+    const position = m[2] ? parsePosition(m[2]) : null;
+    return {
+      hazard: "TROPICAL_CYCLONE",
+      phrase: m[0],
+      length: m[0].length,
+      cyclone: {
+        name: m[1],
+        ...position ? { position } : {},
+        ...m[3] ? { cumulonimbus: true } : {}
+      }
+    };
+  }
+  m = body.match(/^(SEV|MOD) TURB\b/);
+  if (m) return { hazard: "TURBULENCE", phrase: m[0], length: m[0].length };
+  m = body.match(/^(SEV|MOD) ICE(?: ?\(FZRA\))?/);
+  if (m) return { hazard: "ICING", phrase: m[0], length: m[0].length };
+  m = body.match(/^(SEV|MOD) MTW\b/);
+  if (m) return { hazard: "MOUNTAIN_WAVE", phrase: m[0], length: m[0].length };
+  m = body.match(/^HVY (DS|SS)\b/);
+  if (m) return { hazard: m[1] === "DS" ? "DUST_STORM" : "SAND_STORM", phrase: m[0], length: m[0].length };
+  m = body.match(/^RDOACT CLD\b/);
+  if (m) return { hazard: "RADIOACTIVE_CLOUD", phrase: m[0], length: m[0].length };
+  m = body.match(new RegExp(String.raw`^VA(?: ERUPTION)?(?: MT ([A-Z0-9][A-Z0-9 .'()-]*?))?(?: PSN (${POINT}))?(?: POSS)?(?= VA CLD| OBS| FCST| WI|$)`));
+  if (m) {
+    const position = m[2] ? parsePosition(m[2]) : null;
+    return {
+      hazard: "VOLCANIC_ASH",
+      phrase: m[0],
+      length: m[0].length,
+      volcano: { name: m[1]?.trim() ?? null, ...position ? { position } : {} }
+    };
+  }
+  m = body.match(new RegExp(String.raw`^VA ([A-Z][A-Z0-9 .'()-]*?) PSN (${POINT})`));
+  if (m) {
+    const position = parsePosition(m[2]);
+    return {
+      hazard: "VOLCANIC_ASH",
+      phrase: m[0],
+      length: m[0].length,
+      volcano: { name: m[1].trim(), ...position ? { position } : {} }
+    };
+  }
+  m = body.match(/^VA CLD\b/);
+  if (m) return { hazard: "VOLCANIC_ASH", phrase: m[0], length: m[0].length, volcano: { name: null } };
+  m = body.match(/^SFC WSPD (\d{2,3}) ?(KT|MPS)/);
+  if (m) {
+    const speed = Number(m[1]);
+    return {
+      hazard: "SURFACE_WIND",
+      phrase: m[0],
+      length: m[0].length,
+      surfaceWindKt: m[2] === "MPS" ? Math.round(speed * 1.943844) : speed
+    };
+  }
+  m = body.match(/^SFC VIS (\d{2,5}) ?M(?: ?\(([A-Z ]+)\))?/);
+  if (m) {
+    return { hazard: "SURFACE_VISIBILITY", phrase: m[0], length: m[0].length, surfaceVisibilityM: Number(m[1]) };
+  }
+  m = body.match(/^(BKN|OVC) CLD (\d{2,5})\/(\d{3,5}) ?(FT|M)/);
+  if (m) return { hazard: "CLOUD", phrase: m[0], length: m[0].length };
+  m = body.match(/^(MT OBSC|ISOL TCU)\b/);
+  if (m) return { hazard: "OTHER", phrase: m[0], length: m[0].length };
+  return null;
+}
+function parseSigmet(rawText, reference = /* @__PURE__ */ new Date()) {
+  const text = rawText.replace(/\s+/g, " ").trim().replace(/=$/, "").trim();
+  const header = text.match(HEADER);
+  if (!header || !header[1]) return null;
+  const validFrom = dayTime(reference, header[4]);
+  const validTo = dayTime(validFrom, header[5]);
+  if (Number.isNaN(validFrom.getTime()) || Number.isNaN(validTo.getTime())) return null;
+  let rest = text.slice(header[0].length).replace(/^[^A-Z0-9]+/, "").trim();
+  if (rest.startsWith(`${header[1]} `)) rest = rest.slice(5);
+  const sigmet = {
+    kind: header[2],
+    fir: header[1],
+    issuer: header[6] ?? null,
+    series: header[3],
+    validFrom,
+    validTo,
+    hazard: "OTHER",
+    phenomenon: "",
+    area: null,
+    unparsed: [],
+    raw: text
+  };
+  const firName = rest.match(FIR_NAME);
+  if (firName) {
+    sigmet.firName = firName[1];
+    rest = rest.slice(firName[0].length).trim();
+  }
+  const cancel = rest.match(CANCEL);
+  if (cancel) {
+    sigmet.hazard = "CANCEL";
+    sigmet.phenomenon = `CNL ${cancel[1]} ${cancel[2]}`;
+    sigmet.cancel = {
+      series: cancel[2],
+      validFrom: dayTime(validFrom, cancel[3]),
+      validTo: dayTime(validFrom, cancel[4])
+    };
+    if (cancel[5]) sigmet.note = cancel[5];
+    return sigmet;
+  }
+  const phenomenon = readPhenomenon(rest);
+  let body = rest;
+  if (phenomenon) {
+    sigmet.hazard = phenomenon.hazard;
+    sigmet.phenomenon = phenomenon.phrase;
+    if (phenomenon.volcano) sigmet.volcano = phenomenon.volcano;
+    if (phenomenon.cyclone) sigmet.cyclone = phenomenon.cyclone;
+    if (phenomenon.surfaceWindKt !== void 0) sigmet.surfaceWindKt = phenomenon.surfaceWindKt;
+    if (phenomenon.surfaceVisibilityM !== void 0) sigmet.surfaceVisibilityM = phenomenon.surfaceVisibilityM;
+    body = " ".repeat(phenomenon.length) + rest.slice(phenomenon.length);
+  }
+  let main = body;
+  let forecastPart = null;
+  const split = body.search(/ FCST (?:AT )?\d{4}Z/);
+  if (split >= 0 && /\bOBS\b/.test(body.slice(0, split))) {
+    main = body.slice(0, split);
+    forecastPart = body.slice(split);
+  }
+  const consumed = { rest: main };
+  const status = consumed.rest.match(/\b(?:AT (\d{4})Z )?(OBS\/FCST|OBS|FCST)(?: AT (\d{4})Z)?/);
+  if (status) {
+    sigmet.status = status[2];
+    const at = status[1] ?? status[3];
+    if (at) sigmet.statusAt = timeNear(validFrom, at);
+    consumed.rest = blank(consumed.rest, status[0]);
+  }
+  const areas = [];
+  for (let guard = 0; guard < 6; guard++) {
+    const found = findArea(consumed.rest);
+    if (!found) break;
+    areas.push(found.area);
+    consumed.rest = blank(consumed.rest, found.matched);
+  }
+  if (areas[0]) sigmet.area = areas[0];
+  if (areas.length > 1) sigmet.areas = areas;
+  const altitude = findAltitude(consumed.rest);
+  if (altitude) {
+    sigmet.altitude = altitude.range;
+    consumed.rest = blank(consumed.rest, altitude.matched);
+  }
+  const movement = findMovement(consumed.rest);
+  if (movement) {
+    sigmet.movement = movement.movement;
+    consumed.rest = blank(consumed.rest, movement.matched);
+  }
+  const trends = [...consumed.rest.matchAll(/\b(NC|INTSF|WKN)\b/g)];
+  if (trends.length > 0) {
+    const names = trends.map((t) => t[1]);
+    sigmet.trend = names.find((n) => n !== "NC") ?? "NC";
+    for (const t of trends) consumed.rest = blank(consumed.rest, t[0]);
+  }
+  sigmet.unparsed.push(...leftovers(consumed.rest));
+  if (forecastPart) {
+    const at = forecastPart.match(/ FCST (?:AT )?(\d{4})Z/);
+    let part = forecastPart.replace(/ FCST (?:AT )?\d{4}Z/, " ");
+    const forecast = { at: at ? timeNear(validFrom, at[1]) : null, area: null };
+    const noVa = part.match(/\bNO VA EXP\b/);
+    if (noVa) {
+      forecast.noVaExpected = true;
+      part = blank(part, noVa[0]);
+    }
+    const centre = part.match(new RegExp(String.raw`\bTC CENTRE PSN (${POINT})`));
+    if (centre) {
+      const point = parsePosition(centre[1]);
+      if (point) forecast.centre = point;
+      part = blank(part, centre[0]);
+    }
+    const forecastArea = findArea(part);
+    if (forecastArea) {
+      forecast.area = forecastArea.area;
+      part = blank(part, forecastArea.matched);
+    }
+    const forecastAltitude = findAltitude(part);
+    if (forecastAltitude) part = blank(part, forecastAltitude.matched);
+    sigmet.forecast = forecast;
+    sigmet.unparsed.push(...leftovers(part));
+  }
+  return sigmet;
+}
+
+// src/snowtam.ts
+function monthDayTime(reference, digits) {
+  const m = digits.match(/^(\d{2})(\d{2})(\d{2})(\d{2})$/);
+  if (!m) return null;
+  const month = Number(m[1]) - 1;
+  const day = Number(m[2]);
+  if (month < 0 || month > 11 || day < 1 || day > 31) return null;
+  let best = null;
+  for (const year of [reference.getUTCFullYear() - 1, reference.getUTCFullYear(), reference.getUTCFullYear() + 1]) {
+    const candidate = new Date(Date.UTC(year, month, day, Number(m[3]), Number(m[4])));
+    if (candidate.getUTCDate() !== day) continue;
+    if (!best || Math.abs(candidate.getTime() - reference.getTime()) < Math.abs(best.getTime() - reference.getTime())) {
+      best = candidate;
+    }
+  }
+  return best;
+}
+var perThird = (value) => value.split("/").map((part) => /^\d+$/.test(part) ? Number(part) : null);
+var ITEM = /(?:^|\s)([A-T])\)\s*/g;
+function parseSnowtam(rawText, reference = /* @__PURE__ */ new Date()) {
+  const text = rawText.replace(/\s+/g, " ").trim().replace(/^\(/, "").replace(/\)$/, "").trim();
+  const head = text.match(/^SNOWTAM(?: ([A-Z]{0,4}\d{2,4}))?\s*(.*)$/);
+  if (!head) return null;
+  const snowtam = {
+    kind: "SNOWTAM",
+    format: "lettered",
+    number: head[1] ?? null,
+    aerodrome: null,
+    assessedAt: null,
+    runways: [],
+    items: {},
+    unparsed: [],
+    raw: text
+  };
+  const body = head[2];
+  const marks = [...body.matchAll(ITEM)];
+  if (marks.length === 0 || marks[0][1] !== "A") {
+    snowtam.format = "grf";
+    const tokens = body.split(" ").filter(Boolean);
+    if (/^[A-Z]{4}$/.test(tokens[0] ?? "")) snowtam.aerodrome = tokens.shift();
+    if (/^\d{8}$/.test(tokens[0] ?? "")) snowtam.assessedAt = monthDayTime(reference, tokens.shift());
+    if (tokens.length > 0) snowtam.unparsed.push(tokens.join(" "));
+    return snowtam.aerodrome ? snowtam : null;
+  }
+  let runway = null;
+  marks.forEach((mark, i) => {
+    const letter = mark[1];
+    const value = body.slice((mark.index ?? 0) + mark[0].length, marks[i + 1]?.index ?? body.length).trim();
+    switch (letter) {
+      case "A":
+        snowtam.aerodrome = value || null;
+        break;
+      case "B":
+        snowtam.assessedAt = monthDayTime(reference, value);
+        if (!snowtam.assessedAt) snowtam.unparsed.push(`B) ${value}`);
+        break;
+      case "C":
+        runway = { designator: value };
+        snowtam.runways.push(runway);
+        break;
+      case "D": {
+        if (runway && /^\d+$/.test(value)) runway.clearedLengthM = Number(value);
+        else if (runway) snowtam.unparsed.push(`D) ${value}`);
+        break;
+      }
+      case "E": {
+        const width = value.match(/^(\d+)\s*([LR])?$/);
+        if (runway && width) {
+          runway.clearedWidthM = { value: Number(width[1]), ...width[2] ? { side: width[2] } : {} };
+        } else if (runway) snowtam.unparsed.push(`E) ${value}`);
+        break;
+      }
+      case "F":
+        if (runway) runway.deposits = perThird(value);
+        break;
+      case "G":
+        if (runway) runway.meanDepthMm = perThird(value);
+        break;
+      case "H":
+        if (runway) runway.friction = value.split("/");
+        break;
+      case "S":
+        snowtam.items.S = value;
+        snowtam.nextObservationAt = monthDayTime(reference, value);
+        break;
+      case "T":
+        snowtam.items.T = value;
+        snowtam.remarks = value;
+        break;
+      default:
+        snowtam.items[letter] = value;
+    }
+  });
+  return snowtam.aerodrome ? snowtam : null;
+}
+
 // src/taf.ts
 var ISSUED = /^(\d{2})(\d{2})(\d{2})Z$/;
 var VALIDITY = /^(\d{2})(\d{2})\/(\d{2})(\d{2})$/;
@@ -269,6 +860,7 @@ function parseTaf(raw, reference = /* @__PURE__ */ new Date()) {
   index += 1;
   const validFrom = resolveDayTime(issuedAt, Number(validity[1]), Number(validity[2]));
   const validTo = resolveDayTime(issuedAt, Number(validity[3]), Number(validity[4]));
+  if (Number.isNaN(validFrom.getTime()) || Number.isNaN(validTo.getTime())) return null;
   const base = {
     station,
     issuedAt,
@@ -279,14 +871,22 @@ function parseTaf(raw, reference = /* @__PURE__ */ new Date()) {
     raw: tokens.join(" ")
   };
   if (tokens[index] === "CNL") {
-    return { kind: "TAF", ...base, cancelled: true, periods: [] };
+    return { kind: "TAF", ...base, cancelled: true, periods: [], unparsed: [] };
   }
   const groups = [
     { change: "BASE", from: validFrom, to: validTo, tokens: [] }
   ];
   let current = groups[0];
   let probability;
+  let remark = false;
+  let malformed = false;
+  const dropped = [];
+  let dropping = false;
+  let amendmentsNotScheduled = false;
   const startGroup = (change, from, to) => {
+    if (Number.isNaN(from.getTime()) || Number.isNaN(to.getTime())) malformed = true;
+    remark = false;
+    dropping = false;
     current = { change, probability, from, to, tokens: [] };
     probability = void 0;
     groups.push(current);
@@ -306,6 +906,9 @@ function parseTaf(raw, reference = /* @__PURE__ */ new Date()) {
             resolveDayTime(issuedAt, Number(period[3]), Number(period[4]))
           );
           i += 1;
+        } else {
+          dropping = true;
+          dropped.push(token);
         }
       }
       continue;
@@ -321,7 +924,11 @@ function parseTaf(raw, reference = /* @__PURE__ */ new Date()) {
     }
     if (token === "BECMG" || token === "TEMPO") {
       const period = tokens[i + 1]?.match(VALIDITY);
-      if (!period) continue;
+      if (!period) {
+        dropping = true;
+        dropped.push(token);
+        continue;
+      }
       startGroup(
         token,
         resolveDayTime(issuedAt, Number(period[1]), Number(period[2])),
@@ -330,20 +937,41 @@ function parseTaf(raw, reference = /* @__PURE__ */ new Date()) {
       i += 1;
       continue;
     }
-    current.tokens.push(token);
+    if (token === "RMK") {
+      remark = true;
+      continue;
+    }
+    if (token === "AMD" && tokens[i + 1] === "NOT" && /^(SKED|SCHEDULED)$/.test(tokens[i + 2] ?? "")) {
+      amendmentsNotScheduled = true;
+      i += 2;
+      continue;
+    }
+    if (remark) continue;
+    if (VALIDITY.test(token)) dropping = true;
+    if (dropping) dropped.push(token);
+    else current.tokens.push(token);
   }
+  if (malformed) return null;
   const periods = groups.map((group) => {
-    const { rest: _rest, ...conditions } = parseConditionTokens(group.tokens);
+    const { rest, ...conditions } = parseConditionTokens(group.tokens);
     return {
       change: group.change,
       probability: group.probability,
       from: group.from,
       to: group.to,
       conditions,
+      unparsed: rest,
       raw: group.tokens.join(" ")
     };
   });
-  return { kind: "TAF", ...base, cancelled: false, periods };
+  return {
+    kind: "TAF",
+    ...base,
+    cancelled: false,
+    ...amendmentsNotScheduled ? { amendmentsNotScheduled } : {},
+    periods,
+    unparsed: dropped
+  };
 }
 var lerp = (a, b, t) => a + (b - a) * t;
 function lerpAngle(a, b, t) {
@@ -406,6 +1034,163 @@ function forecastAt(taf, at, options = {}) {
   return { conditions: state, temporary, transition };
 }
 
+// src/vaa.ts
+var LABELS = [
+  "DTG",
+  "VAAC",
+  "VOLCANO",
+  "PSN",
+  "AREA",
+  "SUMMIT ELEV",
+  "SOURCE ELEV",
+  "ADVISORY NR",
+  "INFO SOURCE",
+  "AVIATION COLOUR CODE",
+  "ERUPTION DETAILS",
+  "OBS VA DTG",
+  "OBS VA CLD",
+  "EST VA DTG",
+  "EST VA CLD",
+  "FCST VA CLD \\+ ?\\d+ ?HR",
+  "RMK",
+  "NXT ADVISORY",
+  "NEXT ADVISORY"
+];
+var LABEL = new RegExp(`(?:^|\\s)(${LABELS.join("|")}):`, "g");
+var FLIGHT_LEVEL = String.raw`(?:SFC|FL\d{3})`;
+var LAYER_LEVELS = new RegExp(String.raw`(${FLIGHT_LEVEL})\/(${FLIGHT_LEVEL})`, "g");
+var levelFeet2 = (token) => token === "SFC" ? 0 : Number(token.slice(2)) * 100;
+function fullDate(text) {
+  const m = text.match(/(\d{4})(\d{2})(\d{2})\/(\d{2})(\d{2})Z/);
+  return m ? new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]), Number(m[4]), Number(m[5]))) : null;
+}
+function dayHour(reference, text) {
+  const m = text.match(/(\d{2})\/(\d{2})(\d{2})Z/);
+  return m ? resolveDayTime(reference, Number(m[1]), Number(m[2]), Number(m[3])) : null;
+}
+function parseVaCloud(text, reference) {
+  const flat = text.replace(/\s+/g, " ").trim();
+  if (/^(?:NOT AVBL|NOT AVAILABLE|NIL)\b/.test(flat)) return { status: "not-available", layers: [], text: flat };
+  if (/^NO VA EXP/.test(flat)) return { status: "none-expected", layers: [], text: flat };
+  if (/^(?:VA )?NOT IDENTIFIABLE/.test(flat)) {
+    const cloud = { status: "not-identifiable", layers: [], text: flat };
+    const wind = flat.match(/WIND (FL\d{3}) (\d{3})\/(\d{2,3})KT/);
+    if (wind) {
+      cloud.wind = { levelFt: levelFeet2(wind[1]), directionDeg: Number(wind[2]), speedKt: Number(wind[3]) };
+    }
+    return cloud;
+  }
+  const layers = [];
+  const found = [...flat.matchAll(LAYER_LEVELS)];
+  found.forEach((match, i) => {
+    const start = match.index ?? 0;
+    const end = found[i + 1]?.index ?? flat.length;
+    const part = flat.slice(start, end);
+    const layer = {
+      baseFt: levelFeet2(match[1]),
+      topFt: levelFeet2(match[2]),
+      area: parsePositions(part)
+    };
+    const move = findMovement(part);
+    if (move) layer.movement = move.movement;
+    if (i === 0) {
+      const at = dayHour(reference, flat.slice(0, start));
+      if (at) layer.at = at;
+    }
+    layers.push(layer);
+  });
+  return { status: "identified", layers, text: flat };
+}
+function parseVaa(rawText, _reference = /* @__PURE__ */ new Date()) {
+  const text = rawText.replace(/\s+/g, " ").trim().replace(/=$/, "").trim();
+  const marks = [...text.matchAll(LABEL)];
+  if (marks.length === 0) return null;
+  const values = /* @__PURE__ */ new Map();
+  const order = [];
+  marks.forEach((mark, i) => {
+    const labelEnd = (mark.index ?? 0) + mark[0].length;
+    const value = text.slice(labelEnd, marks[i + 1]?.index ?? text.length).trim();
+    const name = mark[1].replace(/\s*\+\s*/, " +").replace(/ ?HR$/, " HR");
+    if (!values.has(name)) order.push(name);
+    values.set(name, value);
+  });
+  const issuedAt = fullDate(values.get("DTG") ?? "");
+  const vaac = values.get("VAAC");
+  const volcanoText = values.get("VOLCANO");
+  const advisoryNumber = values.get("ADVISORY NR");
+  if (!issuedAt || !vaac || !volcanoText || !advisoryNumber) return null;
+  const number = volcanoText.match(/^(.*?)\s+(\d{6})$/);
+  const advisory = {
+    kind: "VAA",
+    vaac,
+    issuedAt,
+    volcano: { name: (number?.[1] ?? volcanoText) || null, ...number ? { number: number[2] } : {} },
+    advisoryNumber,
+    forecasts: [],
+    unparsed: [],
+    raw: text
+  };
+  if (/^(UNNAMED|UNKNOWN|NIL)$/i.test(advisory.volcano.name ?? "")) advisory.volcano.name = null;
+  const psn = values.get("PSN");
+  if (psn) {
+    const position = parsePosition(psn.match(new RegExp(POINT))?.[0] ?? "");
+    if (position) advisory.position = position;
+    else advisory.unparsed.push(`PSN: ${psn}`);
+  }
+  const area = values.get("AREA");
+  if (area) advisory.area = area;
+  const elevation = (values.get("SUMMIT ELEV") ?? values.get("SOURCE ELEV"))?.match(/(\d+)\s*M/);
+  if (elevation) advisory.summitElevationM = Number(elevation[1]);
+  const source = values.get("INFO SOURCE");
+  if (source) advisory.infoSource = source;
+  const colour = values.get("AVIATION COLOUR CODE");
+  if (colour) advisory.colourCode = colour;
+  const eruption = values.get("ERUPTION DETAILS");
+  if (eruption) {
+    const at = fullDate(eruption);
+    const top = eruption.match(/\bFL(\d{3})\b/);
+    advisory.eruption = {
+      text: eruption,
+      ...at ? { at } : {},
+      ...top ? { topFt: Number(top[1]) * 100 } : {}
+    };
+  }
+  const observedAt = dayHour(issuedAt, values.get("OBS VA DTG") ?? "");
+  const observed = values.get("OBS VA CLD");
+  if (observed !== void 0) advisory.observed = { at: observedAt, cloud: parseVaCloud(observed, issuedAt) };
+  const estimated = values.get("EST VA CLD");
+  if (estimated !== void 0) {
+    advisory.estimated = { at: dayHour(issuedAt, values.get("EST VA DTG") ?? ""), cloud: parseVaCloud(estimated, issuedAt) };
+  }
+  for (const name of order) {
+    const forecast = name.match(/^FCST VA CLD \+(\d+) HR$/);
+    if (!forecast) continue;
+    const hours = Number(forecast[1]);
+    const base = observedAt ?? issuedAt;
+    const cloud = parseVaCloud(values.get(name), issuedAt);
+    advisory.forecasts.push({
+      hoursAhead: hours,
+      at: cloud.layers[0]?.at ?? new Date(base.getTime() + hours * 36e5),
+      cloud
+    });
+  }
+  const remarks = values.get("RMK");
+  if (remarks) advisory.remarks = remarks;
+  const next = values.get("NXT ADVISORY") ?? values.get("NEXT ADVISORY");
+  if (next !== void 0) {
+    const by = fullDate(next);
+    advisory.next = { text: next, noFurther: /NO FURTHER ADVISOR/.test(next), ...by ? { by } : {} };
+  }
+  for (const layer of [
+    ...advisory.observed?.cloud.layers ?? [],
+    ...advisory.estimated?.cloud.layers ?? [],
+    ...advisory.forecasts.flatMap((f) => f.cloud.layers)
+  ]) {
+    if (layer.area.length === 0) advisory.unparsed.push(`awan abu tanpa titik batas: FL ${layer.baseFt}-${layer.topFt}`);
+  }
+  return advisory;
+}
+
 // src/animation.ts
 var COVERAGE = {
   FEW: 0.19,
@@ -643,6 +1428,52 @@ function sampleWind(grid, lon, lat) {
   const v = bilinear(grid.v, grid.bounds, grid.nx, grid.ny, lon, lat);
   return u === null || v === null ? null : { u, v };
 }
+var influence = (distance, radius) => distance >= radius ? 0 : (radius * radius - distance * distance) / (radius * radius + distance * distance);
+function nudgeValues(values, bounds, nx, ny, deltas, radius) {
+  const out = Float32Array.from(values);
+  if (deltas.length === 0) return out;
+  for (let row = 0; row < ny; row++) {
+    for (let col = 0; col < nx; col++) {
+      const index = row * nx + col;
+      if (Number.isNaN(out[index])) continue;
+      const cell = pointOf(bounds, nx, ny, col, row);
+      let weights = 0;
+      let weighted = 0;
+      for (const d of deltas) {
+        const w = influence(distanceKm(cell, d), radius);
+        weights += w;
+        weighted += w * d.delta;
+      }
+      if (weights > 0) out[index] = out[index] + weighted / weights * Math.min(1, weights);
+    }
+  }
+  return out;
+}
+function nudgeScalar(grid, points, options = {}) {
+  const deltas = [];
+  for (const p of points) {
+    const model = sampleScalar(grid, p.lon, p.lat);
+    if (model !== null) deltas.push({ lat: p.lat, lon: p.lon, delta: p.value - model });
+  }
+  return { ...grid, values: nudgeValues(grid.values, grid.bounds, grid.nx, grid.ny, deltas, options.radiusKm ?? 80) };
+}
+function nudgeWind(grid, stations, options = {}) {
+  const du = [];
+  const dv = [];
+  for (const s of stations) {
+    const model = sampleWind(grid, s.lon, s.lat);
+    if (!model) continue;
+    const obs = s.directionDeg === null ? { u: 0, v: 0 } : uvFromSpeedDirection(s.speedKt * KT_TO_MS, s.directionDeg);
+    du.push({ lat: s.lat, lon: s.lon, delta: obs.u - model.u });
+    dv.push({ lat: s.lat, lon: s.lon, delta: obs.v - model.v });
+  }
+  const radius = options.radiusKm ?? 80;
+  return {
+    ...grid,
+    u: nudgeValues(grid.u, grid.bounds, grid.nx, grid.ny, du, radius),
+    v: nudgeValues(grid.v, grid.bounds, grid.nx, grid.ny, dv, radius)
+  };
+}
 function blendWindGrids(a, b, t) {
   if (a.nx !== b.nx || a.ny !== b.ny) throw new Error("Grid angin harus berukuran sama");
   const mix = (x, y) => Float32Array.from(x, (value, i) => value + (y[i] - value) * t);
@@ -993,9 +1824,17 @@ var WeatherStore = class {
   ingest(message, options = {}) {
     const receivedAt = options.receivedAt ?? /* @__PURE__ */ new Date();
     const manual = options.manual === true;
-    const result = { metars: 0, tafs: 0, skipped: 0, stations: [] };
+    const result = { metars: 0, tafs: 0, nil: 0, other: 0, skipped: 0, stations: [] };
     const touched = /* @__PURE__ */ new Set();
     for (const raw of extractReports(message)) {
+      if (raw.kind !== "METAR" && raw.kind !== "SPECI" && raw.kind !== "TAF") {
+        result.other++;
+        continue;
+      }
+      if (parseNil(raw.text, receivedAt)) {
+        result.nil++;
+        continue;
+      }
       if (raw.kind === "TAF") {
         const taf = parseTaf(raw.text, receivedAt);
         if (!taf) {
@@ -1099,24 +1938,48 @@ var WeatherStore = class {
    * koordinat, diinterpolasi ke grid. Mengembalikan null bila tidak ada stasiun yang bisa dipakai.
    */
   fieldsAt(at, grid, options = {}) {
+    const points = this.pointsAt(at, options);
+    if (points.stations.length === 0) return null;
+    return {
+      at,
+      stations: points.stations,
+      wind: windGridFromStations(points.winds, grid),
+      cloud: interpolateScalar(points.clouds, grid),
+      rain: interpolateScalar(points.rains, grid),
+      temperature: points.temperatures.length > 0 ? interpolateScalar(points.temperatures, grid) : null
+    };
+  }
+  /**
+   * Gabungkan medan model dengan laporan: grid model disesuaikan ke pengamatan (METAR/SPECI) atau
+   * prakiraan (TAF) di stasiun yang punya koordinat, dalam jarak `radiusKm` dari tiap stasiun. Tanpa
+   * stasiun yang bisa dipakai, medan model dikembalikan apa adanya.
+   */
+  blendInto(model, modelName, at, options = {}) {
+    const points = this.pointsAt(at, options);
+    return {
+      at,
+      stations: [modelName, ...points.stations],
+      wind: model.wind ? nudgeWind(model.wind, points.winds, options) : null,
+      cloud: model.cloud ? nudgeScalar(model.cloud, points.clouds, options) : null,
+      rain: model.rain ? nudgeScalar(model.rain, points.rains, options) : null,
+      temperature: model.temperature ? nudgeScalar(model.temperature, points.temperatures, options) : null
+    };
+  }
+  /** Nilai tiap stasiun yang punya koordinat dan data pada waktu `at`. */
+  pointsAt(at, options) {
     const winds = [];
     const clouds = [];
     const rains = [];
     const temperatures = [];
-    const used = [];
+    const stations = [];
     for (const station of this.stations()) {
       const place = this.locate(station);
       if (!place) continue;
       const snapshot = this.snapshotAt(station, at, options);
       if (!snapshot) continue;
-      used.push(station);
+      stations.push(station);
       const { state } = snapshot;
-      winds.push({
-        lat: place.lat,
-        lon: place.lon,
-        speedKt: state.wind.speedKt,
-        directionDeg: state.wind.fromDeg
-      });
+      winds.push({ lat: place.lat, lon: place.lon, speedKt: state.wind.speedKt, directionDeg: state.wind.fromDeg });
       clouds.push({ lat: place.lat, lon: place.lon, value: state.clouds.total * 100 });
       rains.push({
         lat: place.lat,
@@ -1128,15 +1991,7 @@ var WeatherStore = class {
         temperatures.push({ lat: place.lat, lon: place.lon, value: observed.temperatureC });
       }
     }
-    if (used.length === 0) return null;
-    return {
-      at,
-      stations: used,
-      wind: windGridFromStations(winds, grid),
-      cloud: interpolateScalar(clouds, grid),
-      rain: interpolateScalar(rains, grid),
-      temperature: temperatures.length > 0 ? interpolateScalar(temperatures, grid) : null
-    };
+    return { stations, winds, clouds, rains, temperatures };
   }
   // ---- internal -------------------------------------------------------------
   changed() {
@@ -1192,12 +2047,33 @@ var WeatherStore = class {
 function decodeWeatherMessage(message, reference = /* @__PURE__ */ new Date()) {
   const reports = [];
   for (const raw of extractReports(message)) {
-    const report = raw.kind === "TAF" ? parseTaf(raw.text, reference) : parseMetar(raw.text, reference);
+    let report;
+    switch (raw.kind) {
+      case "TAF":
+        report = parseNil(raw.text, reference) ?? parseTaf(raw.text, reference);
+        break;
+      case "METAR":
+      case "SPECI":
+        report = parseNil(raw.text, reference) ?? parseMetar(raw.text, reference);
+        break;
+      case "SIGMET":
+      case "AIRMET":
+        report = parseSigmet(raw.text, reference);
+        break;
+      case "VAA":
+        report = parseVaa(raw.text, reference);
+        break;
+      case "SNOWTAM":
+        report = parseSnowtam(raw.text, reference);
+        break;
+    }
     if (report) reports.push(report);
   }
   return reports;
 }
 export {
+  ALTITUDE_PATTERNS,
+  POINT,
   WEATHER_GRID_STANDARD,
   WEATHER_GRID_VERSION,
   WeatherStore,
@@ -1205,20 +2081,33 @@ export {
   animationSnapshot,
   blendConditions,
   blendWindGrids,
+  compassDegrees,
   decodeGridJson,
   decodeWeatherMessage,
   directionFromUV,
   emptyConditions,
   extractReports,
+  findAltitude,
+  findMovement,
   forecastAt,
   interpolateScalar,
+  isCompass,
   latticePoints,
   mergeConditions,
+  nudgeScalar,
+  nudgeWind,
   parseConditionTokens,
   parseGrib2Json,
   parseGridJson,
   parseMetar,
+  parseNil,
+  parsePosition,
+  parsePositions,
+  parseSigmet,
+  parseSnowtam,
   parseTaf,
+  parseVaCloud,
+  parseVaa,
   parseWeatherGridSeries,
   pointOf,
   resolveDayTime,