@aeroswarm/weather 0.1.5 → 0.3.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,
@@ -517,14 +1302,14 @@ function animationFromConditions(conditions) {
     thunderstorm
   };
 }
-function animationSnapshot(input) {
+function selectConditions(input) {
   const at = input.at ?? /* @__PURE__ */ new Date();
   const maxAge = input.maxObservationAgeMs ?? 3 * 36e5;
   const { observation, forecast } = input;
   const age = observation ? at.getTime() - observation.observedAt.getTime() : null;
   if (observation && age !== null && age >= 0 && age <= maxAge) {
     return {
-      state: animationFromConditions(observation.conditions),
+      conditions: observation.conditions,
       source: observation.kind,
       station: observation.station,
       validAt: observation.observedAt,
@@ -536,7 +1321,7 @@ function animationSnapshot(input) {
   const predicted = forecast ? forecastAt(forecast, at, { includeProbable: input.includeProbable }) : null;
   if (forecast && predicted) {
     return {
-      state: animationFromConditions(predicted.conditions),
+      conditions: predicted.conditions,
       source: "TAF",
       station: forecast.station,
       validAt: at,
@@ -547,7 +1332,7 @@ function animationSnapshot(input) {
   }
   if (observation) {
     return {
-      state: animationFromConditions(observation.conditions),
+      conditions: observation.conditions,
       source: observation.kind,
       station: observation.station,
       validAt: observation.observedAt,
@@ -558,6 +1343,12 @@ function animationSnapshot(input) {
   }
   return null;
 }
+function animationSnapshot(input) {
+  const selected = selectConditions(input);
+  if (!selected) return null;
+  const { conditions, ...meta } = selected;
+  return { state: animationFromConditions(conditions), ...meta };
+}
 
 // src/grid.ts
 var KT_TO_MS = 0.514444;
@@ -1020,6 +1811,323 @@ function weatherGridFromOpenMeteo(response, lattice, options = {}) {
   };
 }
 
+// src/ops.ts
+var METERS_PER_MILE2 = 1609.344;
+var FAA_CATEGORY_THRESHOLDS = {
+  lifrCeilingFt: 500,
+  ifrCeilingFt: 1e3,
+  mvfrCeilingFt: 3e3,
+  lifrVisibilityM: 1 * METERS_PER_MILE2,
+  ifrVisibilityM: 3 * METERS_PER_MILE2,
+  mvfrVisibilityM: 5 * METERS_PER_MILE2
+};
+var RANK = { LIFR: 0, IFR: 1, MVFR: 2, VFR: 3 };
+var BY_RANK = ["LIFR", "IFR", "MVFR", "VFR"];
+function ceilingOf(clouds) {
+  let lowest = null;
+  let unknown = false;
+  for (const layer of clouds) {
+    if (layer.cover !== "BKN" && layer.cover !== "OVC" && layer.cover !== "VV") continue;
+    if (layer.baseFt === null) {
+      unknown = true;
+      continue;
+    }
+    lowest = lowest === null ? layer.baseFt : Math.min(lowest, layer.baseFt);
+  }
+  return { ceilingFt: lowest, unknown };
+}
+var rankByCeiling = (ceilingFt, t) => {
+  if (ceilingFt === null) return RANK.VFR;
+  if (ceilingFt < t.lifrCeilingFt) return RANK.LIFR;
+  if (ceilingFt < t.ifrCeilingFt) return RANK.IFR;
+  if (ceilingFt <= t.mvfrCeilingFt) return RANK.MVFR;
+  return RANK.VFR;
+};
+var rankByVisibility = (visibilityM, t) => {
+  if (visibilityM < t.lifrVisibilityM) return RANK.LIFR;
+  if (visibilityM < t.ifrVisibilityM) return RANK.IFR;
+  if (visibilityM <= t.mvfrVisibilityM) return RANK.MVFR;
+  return RANK.VFR;
+};
+function flightCategory(conditions, thresholds = FAA_CATEGORY_THRESHOLDS) {
+  if (conditions.cavok) {
+    return { category: "VFR", ceilingFt: null, ceilingUnknown: false, visibilityM: 1e4, limitedBy: null };
+  }
+  const { ceilingFt, unknown } = ceilingOf(conditions.clouds);
+  const visibilityM = conditions.visibilityM;
+  const ceilingRank = unknown && ceilingFt === null ? null : rankByCeiling(ceilingFt, thresholds);
+  const visibilityRank = visibilityM === null ? null : rankByVisibility(visibilityM, thresholds);
+  if (ceilingRank === null && visibilityRank === null) {
+    return { category: null, ceilingFt, ceilingUnknown: unknown, visibilityM, limitedBy: null };
+  }
+  const rank = Math.min(ceilingRank ?? Number.POSITIVE_INFINITY, visibilityRank ?? Number.POSITIVE_INFINITY);
+  const limitedBy = ceilingRank !== null && visibilityRank !== null ? ceilingRank === visibilityRank ? "both" : ceilingRank < visibilityRank ? "ceiling" : "visibility" : ceilingRank !== null ? "ceiling" : "visibility";
+  return {
+    category: BY_RANK[rank] ?? null,
+    ceilingFt,
+    ceilingUnknown: unknown,
+    visibilityM,
+    limitedBy
+  };
+}
+var round1 = (value) => Math.round(value * 10) / 10;
+function windComponents(wind, runwayHeadingTrueDeg) {
+  if (wind.directionDeg === null) {
+    return { headwindKt: null, tailwindKt: null, crosswindKt: round1(wind.speedKt), crosswindFrom: null, variable: true };
+  }
+  const angle = (wind.directionDeg - runwayHeadingTrueDeg) * Math.PI / 180;
+  const head = wind.speedKt * Math.cos(angle);
+  const cross = wind.speedKt * Math.sin(angle);
+  return {
+    headwindKt: round1(Math.max(0, head)),
+    tailwindKt: round1(Math.max(0, -head)),
+    crosswindKt: round1(Math.abs(cross)),
+    crosswindFrom: Math.abs(cross) < 0.05 ? null : cross > 0 ? "right" : "left",
+    variable: false
+  };
+}
+function runwayAdvice(wind, runways, limits = {}) {
+  const advise = (direction) => {
+    const steady = windComponents(wind, direction.headingTrueDeg);
+    const gust = wind.gustKt !== null && wind.gustKt !== void 0 ? windComponents({ directionDeg: wind.directionDeg, speedKt: wind.gustKt }, direction.headingTrueDeg) : void 0;
+    const worst = gust ?? steady;
+    return {
+      direction,
+      steady,
+      ...gust ? { gust } : {},
+      exceeds: {
+        crosswind: limits.crosswindKt === void 0 ? null : worst.crosswindKt > limits.crosswindKt,
+        tailwind: limits.tailwindKt === void 0 ? null : worst.tailwindKt === null ? null : worst.tailwindKt > limits.tailwindKt
+      }
+    };
+  };
+  return runways.map((runway) => {
+    const first = advise(runway.directions[0]);
+    const second = advise(runway.directions[1]);
+    const headA = first.steady.headwindKt ?? Number.NEGATIVE_INFINITY;
+    const headB = second.steady.headwindKt ?? Number.NEGATIVE_INFINITY;
+    const preferred = headA === headB ? first.steady.crosswindKt <= second.steady.crosswindKt ? first : second : headA > headB ? first : second;
+    return { runway, directions: [first, second], preferred };
+  });
+}
+function rvrAgainst(rvr, minimum) {
+  const value = rvr.variableMinM ?? rvr.meters;
+  if (rvr.modifier === "above") return value >= minimum ? "above" : "unknown";
+  if (rvr.modifier === "below") return value <= minimum ? "below" : "unknown";
+  return value < minimum ? "below" : "above";
+}
+function evaluateMinima(conditions, minima) {
+  const reasons = [];
+  const unknown = [];
+  if (minima.visibilityM !== void 0) {
+    const visibility = conditions.cavok ? 1e4 : conditions.visibilityM;
+    if (visibility === null) unknown.push("visibility");
+    else if (visibility < minima.visibilityM) {
+      reasons.push({ kind: "visibility", value: visibility, minimum: minima.visibilityM });
+    }
+  }
+  if (minima.ceilingFt !== void 0 && !conditions.cavok) {
+    const { ceilingFt, unknown: ceilingUnknown } = ceilingOf(conditions.clouds);
+    if (ceilingFt !== null && ceilingFt < minima.ceilingFt) {
+      reasons.push({ kind: "ceiling", value: ceilingFt, minimum: minima.ceilingFt });
+    } else if (ceilingUnknown && ceilingFt === null) unknown.push("ceiling");
+  }
+  if (minima.rvrM !== void 0) {
+    const wanted = minima.rvrRunways;
+    const reports = (conditions.rvr ?? []).filter((r) => !wanted || wanted.includes(r.runway));
+    if (reports.length === 0) unknown.push("rvr");
+    for (const rvr of reports) {
+      const verdict = rvrAgainst(rvr, minima.rvrM);
+      if (verdict === "below") {
+        reasons.push({ kind: "rvr", value: rvr.variableMinM ?? rvr.meters, minimum: minima.rvrM, runway: rvr.runway });
+      } else if (verdict === "unknown" && !unknown.includes("rvr")) unknown.push("rvr");
+    }
+  }
+  return { below: reasons.length > 0, reasons, unknown };
+}
+var PRECIPITATION2 = /* @__PURE__ */ new Set(["DZ", "RA", "SN", "SG", "IC", "PL", "GR", "GS", "UP"]);
+var hasThunderstorm = (c) => c.weather.some((w) => w.descriptor === "TS" && w.intensity !== "vicinity") || c.clouds.some((layer) => layer.type === "CB");
+var hasHeavyPrecipitation = (weather) => weather.some((w) => w.intensity === "heavy" && w.phenomena.some((p) => PRECIPITATION2.has(p)));
+function sourceAt(taf, time, includeProbable) {
+  const covers = (p) => time >= p.from.getTime() && time < p.to.getTime();
+  if (taf.periods.some((p) => p.change === "TEMPO" && covers(p) && (p.probability === void 0 || includeProbable))) {
+    return "TEMPO";
+  }
+  if (includeProbable && taf.periods.some((p) => p.change === "PROB" && covers(p))) return "PROB";
+  let latest = null;
+  for (const p of taf.periods) {
+    if ((p.change === "FM" || p.change === "BECMG") && p.from.getTime() <= time) {
+      if (!latest || p.from.getTime() >= latest.from.getTime()) latest = p;
+    }
+  }
+  return latest ? latest.change : "BASE";
+}
+function upcomingChanges(taf, from, hours, options = {}) {
+  if (taf.cancelled) return [];
+  const thresholds = options.thresholds ?? FAA_CATEGORY_THRESHOLDS;
+  const includeProbable = options.includeProbable === true;
+  const step = (options.stepMinutes ?? 30) * 6e4;
+  const start = Math.max(from.getTime(), taf.validFrom.getTime());
+  const end = Math.min(from.getTime() + hours * 36e5, taf.validTo.getTime());
+  if (start >= end) return [];
+  const times = /* @__PURE__ */ new Set();
+  for (let t = start; t <= end; t += step) times.add(t);
+  for (const p of taf.periods) {
+    for (const edge of [p.from.getTime(), p.to.getTime()]) if (edge > start && edge < end) times.add(edge);
+  }
+  const events = [];
+  let previous = null;
+  let windBaseline = null;
+  for (const time of [...times].sort((a, b) => a - b)) {
+    const at = forecastAt(taf, new Date(time), { includeProbable });
+    if (!at) continue;
+    const c = at.conditions;
+    const category = flightCategory(c, thresholds).category;
+    const thunder = hasThunderstorm(c);
+    const heavy = hasHeavyPrecipitation(c.weather);
+    const lowVis = options.lowVisibilityM !== void 0 && c.visibilityM !== null && c.visibilityM < options.lowVisibilityM;
+    const source = sourceAt(taf, time, includeProbable);
+    const when = new Date(time);
+    if (!previous) {
+      if (thunder) {
+        events.push({ kind: "THUNDERSTORM_START", at: when, source, ongoing: true, detail: "Badai petir/CB sudah berlangsung" });
+      }
+      windBaseline = c.wind.speedKt;
+    } else {
+      if (category !== previous.category && category !== null) {
+        events.push({
+          kind: "CATEGORY_CHANGE",
+          at: when,
+          source,
+          from: previous.category,
+          to: category,
+          detail: `Kategori ${previous.category ?? "?"} menjadi ${category}`
+        });
+      }
+      if (thunder && !previous.thunder) events.push({ kind: "THUNDERSTORM_START", at: when, source, detail: "Badai petir/CB mulai" });
+      if (!thunder && previous.thunder) events.push({ kind: "THUNDERSTORM_END", at: when, source, detail: "Badai petir/CB berakhir" });
+      if (heavy && !previous.heavy) events.push({ kind: "HEAVY_PRECIPITATION_START", at: when, source, detail: "Hujan atau presipitasi lebat" });
+      if (lowVis && !previous.lowVis) {
+        events.push({ kind: "LOW_VISIBILITY_START", at: when, source, detail: `Jarak pandang di bawah ${options.lowVisibilityM} m` });
+      }
+      if (options.windChangeKt !== void 0 && windBaseline !== null && Math.abs(c.wind.speedKt - windBaseline) >= options.windChangeKt) {
+        events.push({
+          kind: "WIND_CHANGE",
+          at: when,
+          source,
+          detail: `Angin ${windBaseline} menjadi ${c.wind.speedKt} kt`
+        });
+        windBaseline = c.wind.speedKt;
+      }
+    }
+    previous = { category, thunder, heavy, lowVis };
+  }
+  return events;
+}
+function qnhTrend(previous, current, options = {}) {
+  if (previous.qnhHpa === null || current.qnhHpa === null) return null;
+  const hours = (current.observedAt.getTime() - previous.observedAt.getTime()) / 36e5;
+  if (hours <= 0) return null;
+  const delta = current.qnhHpa - previous.qnhHpa;
+  const steady = Math.abs(delta) < (options.steadyHpa ?? 0.5);
+  const perHour = delta / hours;
+  return {
+    deltaHpa: delta,
+    hours,
+    hpaPerHour: Math.round(perHour * 100) / 100,
+    direction: steady ? "steady" : delta > 0 ? "rising" : "falling",
+    rapid: options.rapidHpaPerHour === void 0 ? null : Math.abs(perHour) >= options.rapidHpaPerHour
+  };
+}
+
+// src/operations.ts
+function stationOperations(store, station, at, config = {}) {
+  const selected = store.conditionsAt(station, at, { maxObservationAgeMs: config.maxObservationAgeMs });
+  if (!selected) return null;
+  const { conditions } = selected;
+  const taf = store.forecastFor(station, at);
+  const upcoming = taf ? upcomingChanges(taf, at, config.horizonHours ?? 6, { ...config.upcoming, thresholds: config.thresholds }) : [];
+  const [latest, previous] = store.observationsUntil(station, at, 2);
+  return {
+    station,
+    at,
+    basis: {
+      source: selected.source,
+      validAt: selected.validAt,
+      stale: selected.stale,
+      temporary: selected.temporary,
+      transition: selected.transition
+    },
+    category: flightCategory(conditions, config.thresholds),
+    ...config.runways ? { runways: runwayAdvice(conditions.wind, config.runways, config.limits) } : {},
+    ...config.minima ? { minima: evaluateMinima(conditions, config.minima) } : {},
+    upcoming,
+    qnh: latest && previous ? qnhTrend(previous, latest, config.qnh) : null
+  };
+}
+
+// src/runway.ts
+var normalize = (degrees) => (degrees % 360 + 360) % 360;
+function magneticToTrue(magneticDeg, variationEastDeg) {
+  return normalize(magneticDeg + variationEastDeg);
+}
+var reciprocal = (headingDeg) => normalize(headingDeg + 180);
+function reciprocalDesignator(designator) {
+  const match = designator.trim().toUpperCase().match(/^(\d{2})([LRC])?$/);
+  if (!match) return null;
+  const number = Number(match[1]);
+  if (number < 1 || number > 36) return null;
+  const opposite = (number + 18 - 1) % 36 + 1;
+  const side = match[2] === "L" ? "R" : match[2] === "R" ? "L" : match[2] ?? "";
+  return `${String(opposite).padStart(2, "0")}${side}`;
+}
+function designatorHeadingDeg(designator) {
+  const match = designator.trim().match(/^(\d{2})[LRC]?$/);
+  return match ? Number(match[1]) * 10 : null;
+}
+function runwayFromHeading(designator, magneticHeadingDeg, variationEastDeg = 0) {
+  const opposite = reciprocalDesignator(designator);
+  const magnetic = magneticHeadingDeg ?? designatorHeadingDeg(designator);
+  if (!opposite || magnetic === null) return null;
+  const heading = magneticToTrue(magnetic, variationEastDeg);
+  const [low, high] = [designator.toUpperCase(), opposite].sort();
+  const first = { designator: designator.toUpperCase(), headingTrueDeg: heading };
+  const second = { designator: opposite, headingTrueDeg: reciprocal(heading) };
+  return {
+    name: `${low}/${high}`,
+    directions: [first, second]
+  };
+}
+function headingFromPolygon(points) {
+  if (points.length < 2) return null;
+  const meanLat = points.reduce((sum, p) => sum + p.lat, 0) / points.length;
+  const meanLon = points.reduce((sum, p) => sum + p.lon, 0) / points.length;
+  const kx = Math.cos(meanLat * Math.PI / 180);
+  let sxx = 0;
+  let syy = 0;
+  let sxy = 0;
+  for (const p of points) {
+    const x = (p.lon - meanLon) * kx;
+    const y = p.lat - meanLat;
+    sxx += x * x;
+    syy += y * y;
+    sxy += x * y;
+  }
+  if (sxx + syy === 0) return null;
+  const theta = 0.5 * Math.atan2(2 * sxy, sxx - syy);
+  const heading = Math.atan2(Math.cos(theta), Math.sin(theta)) * 180 / Math.PI;
+  return normalize(heading) % 180;
+}
+function runwayFromPolygon(points, variationEastDeg = 0) {
+  const trueHeading = headingFromPolygon(points);
+  if (trueHeading === null) return null;
+  const magnetic = normalize(trueHeading - variationEastDeg);
+  const number = Math.round(magnetic / 10) % 36 || 36;
+  const designator = String(number).padStart(2, "0");
+  const spec = runwayFromHeading(designator, magnetic, variationEastDeg);
+  return spec;
+}
+
 // src/store.ts
 var MAX_OBSERVATIONS_PER_STATION = 48;
 var MAX_FORECASTS_PER_STATION = 8;
@@ -1039,9 +2147,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) {
@@ -1110,6 +2226,25 @@ var WeatherStore = class {
       includeProbable: options.includeProbable
     });
   }
+  /** Kondisi (belum diubah menjadi parameter animasi) di satu stasiun pada waktu `at`. */
+  conditionsAt(station, at, options = {}) {
+    return selectConditions({
+      observation: this.pickObservation(station, at, options.maxObservationAgeMs),
+      forecast: this.pickForecast(station, at),
+      at,
+      maxObservationAgeMs: options.maxObservationAgeMs,
+      includeProbable: options.includeProbable
+    });
+  }
+  /** TAF yang berlaku di satu stasiun pada waktu `at` (manual didahulukan), atau null. */
+  forecastFor(station, at) {
+    return this.pickForecast(station, at);
+  }
+  /** Pengamatan terakhir (paling baru dulu) di satu stasiun sampai waktu `at`, paling banyak `count`. */
+  observationsUntil(station, at, count) {
+    const list = this.observations.get(station) ?? [];
+    return list.map((s) => s.report).filter((m) => m.observedAt.getTime() <= at.getTime()).sort((x, y) => y.observedAt.getTime() - x.observedAt.getTime()).slice(0, count);
+  }
   /** Rentang waktu dan pembagian periode (BASE/BECMG/TEMPO/FM) dari TAF, untuk timeline. */
   timeline() {
     const segments = [];
@@ -1254,12 +2389,34 @@ 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,
+  FAA_CATEGORY_THRESHOLDS,
+  POINT,
   WEATHER_GRID_STANDARD,
   WEATHER_GRID_VERSION,
   WeatherStore,
@@ -1267,14 +2424,24 @@ export {
   animationSnapshot,
   blendConditions,
   blendWindGrids,
+  ceilingOf,
+  compassDegrees,
   decodeGridJson,
   decodeWeatherMessage,
+  designatorHeadingDeg,
   directionFromUV,
   emptyConditions,
+  evaluateMinima,
   extractReports,
+  findAltitude,
+  findMovement,
+  flightCategory,
   forecastAt,
+  headingFromPolygon,
   interpolateScalar,
+  isCompass,
   latticePoints,
+  magneticToTrue,
   mergeConditions,
   nudgeScalar,
   nudgeWind,
@@ -1282,19 +2449,36 @@ export {
   parseGrib2Json,
   parseGridJson,
   parseMetar,
+  parseNil,
+  parsePosition,
+  parsePositions,
+  parseSigmet,
+  parseSnowtam,
   parseTaf,
+  parseVaCloud,
+  parseVaa,
   parseWeatherGridSeries,
   pointOf,
+  qnhTrend,
+  reciprocal,
+  reciprocalDesignator,
   resolveDayTime,
+  runwayAdvice,
+  runwayFromHeading,
+  runwayFromPolygon,
   sampleScalar,
   sampleWind,
+  selectConditions,
   serializeWeatherGridSeries,
   seriesFieldsAt,
   seriesRange,
   speedOf,
+  stationOperations,
   stationWindsFromMetars,
   stationWindsFromModelPoints,
+  upcomingChanges,
   uvFromSpeedDirection,
   weatherGridFromOpenMeteo,
+  windComponents,
   windGridFromStations
 };