@aeroswarm/weather 0.0.0-stage → 0.1.2

package/README.md

@@ -1,3 +1,40 @@
-# Temporary Holding Version
+# @aeroswarm/weather
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Decode raw weather messages (AFTN-wrapped or plain METAR, SPECI, TAF) and turn them into animation
+parameters. No network, no API: it only takes text in and gives data out.
+
+```ts
+import { decodeWeatherMessage, animationSnapshot } from "@aeroswarm/weather";
+
+const reports = decodeWeatherMessage(rawAftnText, receivedAt);
+const metar = reports.find((r) => r.kind !== "TAF");
+const taf = reports.find((r) => r.kind === "TAF");
+
+const snapshot = animationSnapshot({ observation: metar, forecast: taf, at: new Date() });
+// snapshot.state.wind / clouds / visibility / precipitation / thunderstorm / obscuration
+```
+
+- `extractReports(text)` unwraps AFTN (`ZCZC` ... `NNNN`, address lines, bulletin headers) and splits
+  the reports on `=`.
+- `parseMetar`, `parseTaf` read one report. METAR/TAF carry only day and time, so pass the time the
+  message was received as `reference`.
+- `forecastAt(taf, at)` returns the conditions at a time: base, FM, BECMG (blended while it
+  changes), TEMPO, and PROB groups only when `includeProbable` is set.
+- `animationFromConditions` maps conditions to renderer-agnostic parameters. `animationSnapshot`
+  chooses the best source for a time: a fresh METAR/SPECI, else the TAF, else a stale observation.
+
+METAR/TAF describe one point (the aerodrome), not a weather field, so the animation is a
+representation around the airport, not the real position of clouds or rain.
+
+## Gridded fields
+
+`grid.ts` turns wind and scalar data into grids, whatever the source:
+
+- `windGridFromStations(stations, { bounds, nx, ny })` interpolates the wind of several stations (IDW);
+  `stationWindsFromMetars(reports, locate)` takes them from decoded METARs.
+- `parseGrib2Json(json)` reads `grib2json` output (convert GRIB binary first with `grib2json` or
+  `wgrib2`); `parseGridJson(json)` reads a plain `{ bounds, nx, ny, u, v }` or `{ ..., values }`.
+- `stationWindsFromModelPoints(response)` reads multi-location model responses (Open-Meteo style).
+- `sampleWind`, `sampleScalar` (bilinear) and `blendWindGrids` (between two forecast hours).
+
+Row 0 is north, wind is in m/s (`u` east, `v` north), cells without data are NaN.

package/dist/aftn.d.ts

@@ -0,0 +1,13 @@
+import type { ReportKind } from "./types.js";
+export interface RawReport {
+    kind: ReportKind;
+    /** Teks laporan dari kata kunci (METAR/SPECI/TAF) sampai sebelum `=`, spasi dirapikan. */
+    text: string;
+}
+/**
+ * Ambil laporan cuaca dari teks mentah: boleh berupa laporan polos, buletin dengan header
+ * (`SAID31 WARR 021030`), atau pesan AFTN lengkap (`ZCZC ... NNNN` dengan baris alamat). Satu pesan
+ * bisa memuat beberapa laporan yang masing-masing diakhiri `=`.
+ */
+export declare function extractReports(message: string): RawReport[];
+//# sourceMappingURL=aftn.d.ts.map

package/dist/aftn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aftn.d.ts","sourceRoot":"","sources":["../src/aftn.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,UAAU,CAAC;IACjB,0FAA0F;IAC1F,IAAI,EAAE,MAAM,CAAC;CACd;AAID;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,EAAE,CAe3D"}

package/dist/animation.d.ts

@@ -0,0 +1,86 @@
+import type { Conditions, Metar, Taf } from "./types.js";
+export type PrecipitationKind = "drizzle" | "rain" | "snow" | "hail" | "ice";
+export type ObscurationKind = "fog" | "mist" | "haze" | "smoke" | "dust" | "sand" | "ash";
+export interface CloudAnimation {
+    /** Seberapa tertutup lapisan ini, 0-1. */
+    coverage: number;
+    baseFt: number | null;
+    /** low < 2.500 ft, mid < 8.000 ft, selain itu high. */
+    band: "low" | "mid" | "high";
+    /** Awan konvektif (CB/TCU): digambar lebih gelap dan menjulang. */
+    convective: boolean;
+}
+/** Parameter animasi yang siap dipakai renderer apa pun (canvas, WebGL, layer peta). */
+export interface AnimationState {
+    wind: {
+        /** Arah ASAL angin (derajat); null bila berubah-ubah. */
+        fromDeg: number | null;
+        /** Arah ke mana partikel bergerak (derajat); null bila berubah-ubah. */
+        toDeg: number | null;
+        speedKt: number;
+        /** 0-1: seberapa kuat hembusan (gust) menambah kecepatan; untuk denyut animasi. */
+        gustiness: number;
+        /** Angin berubah-ubah arah (VRB atau rentang arah): partikel berputar acak. */
+        turbulent: boolean;
+    };
+    clouds: {
+        layers: CloudAnimation[];
+        /** Tutupan total gabungan semua lapisan, 0-1. */
+        total: number;
+    };
+    visibility: {
+        meters: number | null;
+        /** Opasitas kabut tipis akibat jarak pandang rendah, 0-1. */
+        haze: number;
+    };
+    obscuration: {
+        kind: ObscurationKind;
+        density: number;
+    } | null;
+    precipitation: {
+        kind: PrecipitationKind;
+        /** 0-1 (ringan 0,3 · sedang 0,6 · lebat 1). */
+        intensity: number;
+        /** Hujan lokal (SH atau TS): turun dan berhenti, bukan merata. */
+        showers: boolean;
+        freezing: boolean;
+    } | null;
+    thunderstorm: {
+        /** Badai di bandara itu sendiri. */
+        overhead: boolean;
+        /** Badai di sekitar bandara (VCTS). */
+        vicinity: boolean;
+        lightningPerMinute: number;
+    } | null;
+}
+/** Ubah kondisi cuaca (dari METAR, SPECI, atau TAF) menjadi parameter animasi. */
+export declare function animationFromConditions(conditions: Conditions): AnimationState;
+export type AnimationSource = "METAR" | "SPECI" | "TAF";
+export interface AnimationSnapshot {
+    state: AnimationState;
+    source: AnimationSource;
+    station: string;
+    /** Waktu yang diwakili data ini. */
+    validAt: Date;
+    /** Pengamatan lebih tua dari batas, dan tidak ada TAF yang berlaku sebagai gantinya. */
+    stale: boolean;
+    /** Dari TAF: kondisi sementara (TEMPO) sedang berlaku. */
+    temporary: boolean;
+    /** Dari TAF: 0-1 selama transisi BECMG berjalan. */
+    transition: number | null;
+}
+export interface SnapshotInput {
+    observation?: Metar | null;
+    forecast?: Taf | null;
+    /** Waktu yang ingin ditampilkan (bawaan: sekarang). Geser untuk memutar TAF ke depan. */
+    at?: Date;
+    /** Pengamatan lebih tua dari ini dianggap kedaluwarsa dan TAF dipakai bila ada. Bawaan 3 jam. */
+    maxObservationAgeMs?: number;
+    includeProbable?: boolean;
+}
+/**
+ * Pilih sumber terbaik untuk waktu `at`: pengamatan (METAR/SPECI) yang masih segar, lalu TAF yang
+ * berlaku, lalu pengamatan lama (ditandai stale). Null bila tidak ada data sama sekali.
+ */
+export declare function animationSnapshot(input: SnapshotInput): AnimationSnapshot | null;
+//# sourceMappingURL=animation.d.ts.map

package/dist/animation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../src/animation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAc,UAAU,EAAE,KAAK,EAAkB,GAAG,EAAE,MAAM,YAAY,CAAC;AAErF,MAAM,MAAM,iBAAiB,GAAG,SAAS,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAC7E,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,KAAK,CAAC;AAE1F,MAAM,WAAW,cAAc;IAC7B,0CAA0C;IAC1C,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,uDAAuD;IACvD,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC7B,mEAAmE;IACnE,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,wFAAwF;AACxF,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE;QACJ,yDAAyD;QACzD,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;QACvB,wEAAwE;QACxE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;QACrB,OAAO,EAAE,MAAM,CAAC;QAChB,mFAAmF;QACnF,SAAS,EAAE,MAAM,CAAC;QAClB,+EAA+E;QAC/E,SAAS,EAAE,OAAO,CAAC;KACpB,CAAC;IACF,MAAM,EAAE;QACN,MAAM,EAAE,cAAc,EAAE,CAAC;QACzB,iDAAiD;QACjD,KAAK,EAAE,MAAM,CAAC;KACf,CAAC;IACF,UAAU,EAAE;QACV,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;QACtB,6DAA6D;QAC7D,IAAI,EAAE,MAAM,CAAC;KACd,CAAC;IACF,WAAW,EAAE;QAAE,IAAI,EAAE,eAAe,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;IAC/D,aAAa,EAAE;QACb,IAAI,EAAE,iBAAiB,CAAC;QACxB,+CAA+C;QAC/C,SAAS,EAAE,MAAM,CAAC;QAClB,kEAAkE;QAClE,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,EAAE,OAAO,CAAC;KACnB,GAAG,IAAI,CAAC;IACT,YAAY,EAAE;QACZ,oCAAoC;QACpC,QAAQ,EAAE,OAAO,CAAC;QAClB,uCAAuC;QACvC,QAAQ,EAAE,OAAO,CAAC;QAClB,kBAAkB,EAAE,MAAM,CAAC;KAC5B,GAAG,IAAI,CAAC;CACV;AAuED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,UAAU,GAAG,cAAc,CA+D9E;AAED,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,CAAC;AAExD,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,cAAc,CAAC;IACtB,MAAM,EAAE,eAAe,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,OAAO,EAAE,IAAI,CAAC;IACd,wFAAwF;IACxF,KAAK,EAAE,OAAO,CAAC;IACf,0DAA0D;IAC1D,SAAS,EAAE,OAAO,CAAC;IACnB,oDAAoD;IACpD,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,aAAa;IAC5B,WAAW,CAAC,EAAE,KAAK,GAAG,IAAI,CAAC;IAC3B,QAAQ,CAAC,EAAE,GAAG,GAAG,IAAI,CAAC;IACtB,yFAAyF;IACzF,EAAE,CAAC,EAAE,IAAI,CAAC;IACV,iGAAiG;IACjG,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,aAAa,GAAG,iBAAiB,GAAG,IAAI,CA6ChF"}

package/dist/conditions.d.ts

@@ -0,0 +1,19 @@
+import type { CloudLayer, Conditions, PresentWeather, Wind } from "./types.js";
+export declare function emptyConditions(): Conditions;
+export interface ConditionTokens {
+    wind?: Wind;
+    visibilityM?: number;
+    cavok?: boolean;
+    clouds?: CloudLayer[];
+    weather?: PresentWeather[];
+    noSignificantWeather?: boolean;
+    /** Token yang tidak dikenali (diteruskan ke pemanggil, mis. suhu atau QNH). */
+    rest: string[];
+}
+/** Baca token kondisi (angin, jarak pandang, awan, cuaca) dan kembalikan sisanya. */
+export declare function parseConditionTokens(tokens: string[]): ConditionTokens;
+/** Gabungkan grup yang lebih baru di atas kondisi dasar; yang tidak disebut diwarisi. */
+export declare function mergeConditions(base: Conditions, next: Partial<Conditions> & {
+    noSignificantWeather?: boolean;
+}): Conditions;
+//# sourceMappingURL=conditions.d.ts.map

package/dist/conditions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditions.d.ts","sourceRoot":"","sources":["../src/conditions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,UAAU,EACV,UAAU,EACV,cAAc,EACd,IAAI,EAEL,MAAM,YAAY,CAAC;AAYpB,wBAAgB,eAAe,IAAI,UAAU,CAa5C;AAgCD,MAAM,WAAW,eAAe;IAC9B,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,MAAM,CAAC,EAAE,UAAU,EAAE,CAAC;IACtB,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;IAC3B,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB;AAED,qFAAqF;AACrF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,eAAe,CAkFtE;AAED,yFAAyF;AACzF,wBAAgB,eAAe,CAC7B,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,OAAO,CAAC,UAAU,CAAC,GAAG;IAAE,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAAE,GAC7D,UAAU,CAqBZ"}

package/dist/grid.d.ts

@@ -0,0 +1,116 @@
+import type { Metar } from "./types.js";
+/**
+ * Medan cuaca berbentuk grid (angin, awan, hujan, suhu) dari sumber mana pun: interpolasi banyak
+ * stasiun METAR, JSON grid dari layanan luar, atau hasil konversi GRIB. Semua murni, tanpa jaringan.
+ *
+ * Konvensi: baris 0 = utara, kolom 0 = barat. Angin dalam m/s: `u` ke timur, `v` ke utara.
+ * Sel tanpa data berisi NaN.
+ */
+export interface GridBounds {
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+}
+export interface ScalarGrid {
+    bounds: GridBounds;
+    nx: number;
+    ny: number;
+    values: Float32Array;
+}
+export interface WindGrid {
+    bounds: GridBounds;
+    nx: number;
+    ny: number;
+    u: Float32Array;
+    v: Float32Array;
+}
+export interface GeoPoint {
+    lat: number;
+    lon: number;
+}
+export interface StationWind extends GeoPoint {
+    speedKt: number;
+    /** Arah ASAL angin (derajat); null untuk VRB (dianggap tenang). */
+    directionDeg: number | null;
+}
+export interface StationValue extends GeoPoint {
+    value: number;
+}
+export interface InterpolationOptions {
+    bounds: GridBounds;
+    nx: number;
+    ny: number;
+    /** Pangkat bobot 1/d^p. Bawaan 2. */
+    power?: number;
+    /** Sel yang lebih jauh dari stasiun mana pun dari jarak ini (km) dibiarkan tanpa data. Bawaan 400. */
+    maxDistanceKm?: number;
+}
+export declare const speedOf: (u: number, v: number) => number;
+/** Arah ASAL angin (derajat, 0-360) dari komponen u/v. */
+export declare function directionFromUV(u: number, v: number): number;
+/** Komponen u/v (m/s) dari kecepatan dan arah ASAL angin. */
+export declare function uvFromSpeedDirection(speedMs: number, fromDeg: number): {
+    u: number;
+    v: number;
+};
+export declare function pointOf(bounds: GridBounds, nx: number, ny: number, col: number, row: number): GeoPoint;
+/**
+ * Interpolasi bobot-jarak-terbalik (IDW) nilai di banyak titik ke grid. Tepat di sebuah stasiun
+ * hasilnya persis nilai stasiun itu. Sel yang jauh dari semua stasiun diberi NaN.
+ */
+export declare function interpolateScalar(points: readonly StationValue[], options: InterpolationOptions): ScalarGrid;
+/** Grid angin dari angin di banyak stasiun (mis. METAR beberapa bandara). */
+export declare function windGridFromStations(stations: readonly StationWind[], options: InterpolationOptions): WindGrid;
+/** Nilai grid di (lon, lat) dengan interpolasi bilinear; null di luar grid atau tanpa data. */
+export declare function sampleScalar(grid: ScalarGrid, lon: number, lat: number): number | null;
+/** Angin (m/s) di (lon, lat); null di luar grid atau tanpa data. */
+export declare function sampleWind(grid: WindGrid, lon: number, lat: number): {
+    u: number;
+    v: number;
+} | null;
+/** Campur dua grid angin yang bentuknya sama (mis. dua jam prakiraan), `t` 0-1. */
+export declare function blendWindGrids(a: WindGrid, b: WindGrid, t: number): WindGrid;
+/**
+ * Baca JSON hasil `grib2json` (format yang juga dipakai leaflet-velocity): dua rekaman, komponen angin
+ * u (parameter 2) dan v (parameter 3). GRIB biner dikonversi dulu ke JSON ini (grib2json/wgrib2).
+ */
+export declare function parseGrib2Json(input: unknown): WindGrid;
+/**
+ * Angin stasiun dari beberapa METAR/SPECI. `locate` memberi koordinat dari kode ICAO (mis. dari
+ * tabel bandara milik aplikasi); stasiun tanpa koordinat dilewati.
+ */
+export declare function stationWindsFromMetars(reports: readonly Metar[], locate: (icao: string) => GeoPoint | undefined): StationWind[];
+/**
+ * Format JSON sederhana bawaan: `{ bounds: {west,south,east,north}, nx, ny, u, v }` untuk angin atau
+ * `{ bounds, nx, ny, values }` untuk skalar (awan, hujan, suhu). Larik boleh berisi null untuk "tanpa data".
+ */
+export declare function parseGridJson(input: unknown): WindGrid | ScalarGrid;
+declare const OPEN_METEO_SPEED_TO_MS: Record<string, number>;
+/**
+ * Angin dari respons banyak lokasi layanan model bergaya Open-Meteo: larik `{latitude, longitude,
+ * current|hourly: {wind_speed_10m, wind_direction_10m}}`. `hourIndex` memilih jam dari `hourly`.
+ * `speedUnit` = satuan kecepatan di respons (bawaan km/h, seperti Open-Meteo).
+ */
+export declare function stationWindsFromModelPoints(response: unknown, options?: {
+    hourIndex?: number;
+    speedUnit?: keyof typeof OPEN_METEO_SPEED_TO_MS;
+}): StationWind[];
+export type DecodedGrid = {
+    kind: "wind";
+    grid: WindGrid;
+} | {
+    kind: "scalar";
+    grid: ScalarGrid;
+};
+/**
+ * Kenali dan baca JSON medan cuaca dari sumber mana pun: `grib2json`, JSON grid bawaan (`u`/`v` atau
+ * `values`), atau respons banyak lokasi layanan model (diinterpolasi ke grid `fallback`, wajib
+ * diberikan untuk bentuk terakhir ini). Melempar galat yang menjelaskan bila bentuknya tidak dikenal.
+ */
+export declare function decodeGridJson(input: unknown, fallback?: InterpolationOptions & {
+    hourIndex?: number;
+    speedUnit?: keyof typeof OPEN_METEO_SPEED_TO_MS;
+}): DecodedGrid;
+export {};
+//# sourceMappingURL=grid.d.ts.map

package/dist/grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.d.ts","sourceRoot":"","sources":["../src/grid.ts"],"names":[],"mappings":"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"}

package/dist/grid.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grid.test.d.ts.map

package/dist/grid.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grid.test.d.ts","sourceRoot":"","sources":["../src/grid.test.ts"],"names":[],"mappings":""}

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+import type { Report } from "./types.js";
+export * from "./aftn.js";
+export * from "./animation.js";
+export * from "./conditions.js";
+export * from "./grid.js";
+export * from "./metar.js";
+export * from "./taf.js";
+export * from "./time.js";
+export * from "./types.js";
+/**
+ * Baca semua laporan cuaca (METAR, SPECI, TAF) dari satu pesan mentah, termasuk bungkus AFTN.
+ * Laporan yang tidak terbaca dilewati. `reference` = waktu pesan diterima (menentukan bulan/tahun).
+ */
+export declare function decodeWeatherMessage(message: string, reference?: Date): Report[];
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AAEzC,cAAc,WAAW,CAAC;AAC1B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAE3B;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,IAAiB,GAC3B,MAAM,EAAE,CAUV"}

package/dist/index.js

@@ -0,0 +1,805 @@
+// src/aftn.ts
+var KEYWORD = /\b(METAR|SPECI|TAF)\b/;
+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 });
+  }
+  return reports;
+}
+
+// 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_VARIABLE = /^(\d{3})V(\d{3})$/;
+var VISIBILITY = /^\d{4}$/;
+var CLOUD = /^(FEW|SCT|BKN|OVC)(\d{3}|\/\/\/)(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() {
+  return {
+    wind: {
+      directionDeg: null,
+      variable: false,
+      speedKt: 0,
+      gustKt: null
+    },
+    visibilityM: null,
+    cavok: false,
+    clouds: [],
+    weather: []
+  };
+}
+function toKnots(value, unit) {
+  return unit === "MPS" ? Math.round(value * KT_PER_MPS) : value;
+}
+function parseWeather(token) {
+  const match = token.match(WEATHER);
+  if (!match) return null;
+  const [, prefix, descriptor, phenomena] = match;
+  if (!descriptor && !phenomena) return null;
+  const intensity = prefix === "-" ? "light" : prefix === "+" ? "heavy" : prefix === "VC" ? "vicinity" : "moderate";
+  const codes = [];
+  for (let i = 0; i < (phenomena ?? "").length; i += 2) {
+    codes.push((phenomena ?? "").slice(i, i + 2));
+  }
+  return {
+    intensity,
+    descriptor: descriptor || void 0,
+    phenomena: codes,
+    code: token
+  };
+}
+function parseConditionTokens(tokens) {
+  const out = { rest: [] };
+  const clouds = [];
+  const weather = [];
+  let sawCloudGroup = false;
+  for (const token of tokens) {
+    const wind = token.match(WIND);
+    if (wind) {
+      const variable = wind[1] === "VRB";
+      out.wind = {
+        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
+      };
+      continue;
+    }
+    const range = token.match(WIND_VARIABLE);
+    if (range && out.wind) {
+      out.wind.variableFromDeg = Number(range[1]);
+      out.wind.variableToDeg = Number(range[2]);
+      continue;
+    }
+    if (token === "CAVOK") {
+      out.cavok = true;
+      out.visibilityM = 1e4;
+      continue;
+    }
+    if (VISIBILITY.test(token)) {
+      out.visibilityM = token === "9999" ? 1e4 : Number(token);
+      continue;
+    }
+    const cloud = token.match(CLOUD);
+    if (cloud) {
+      sawCloudGroup = true;
+      clouds.push({
+        cover: cloud[1],
+        baseFt: cloud[2] === "///" ? null : Number(cloud[2]) * 100,
+        type: cloud[3] === "CB" || cloud[3] === "TCU" ? cloud[3] : void 0
+      });
+      continue;
+    }
+    const vv = token.match(VERTICAL_VISIBILITY);
+    if (vv) {
+      sawCloudGroup = true;
+      clouds.push({
+        cover: "VV",
+        baseFt: vv[1] === "///" ? null : Number(vv[1]) * 100
+      });
+      continue;
+    }
+    if (token === "SKC" || token === "NSC" || token === "NCD") {
+      sawCloudGroup = true;
+      out.clouds = [];
+      continue;
+    }
+    if (token === "NSW") {
+      out.noSignificantWeather = true;
+      continue;
+    }
+    const present = parseWeather(token);
+    if (present) {
+      weather.push(present);
+      continue;
+    }
+    out.rest.push(token);
+  }
+  if (clouds.length > 0) out.clouds = clouds;
+  else if (sawCloudGroup) out.clouds = [];
+  if (weather.length > 0) out.weather = weather;
+  return out;
+}
+function mergeConditions(base, next) {
+  const merged = {
+    wind: next.wind ?? base.wind,
+    visibilityM: next.visibilityM ?? base.visibilityM,
+    cavok: next.cavok ?? base.cavok,
+    clouds: next.clouds ?? base.clouds,
+    weather: next.weather ?? base.weather
+  };
+  if (next.noSignificantWeather) merged.weather = [];
+  if (next.cavok) {
+    merged.clouds = [];
+    merged.weather = [];
+    merged.visibilityM = 1e4;
+  } else if (next.visibilityM !== void 0 || next.clouds !== void 0 || next.weather !== void 0) {
+    merged.cavok = false;
+  }
+  return merged;
+}
+
+// src/time.ts
+function resolveDayTime(reference, day, hour, minute = 0) {
+  let best = null;
+  for (const offset of [-1, 0, 1]) {
+    const year = reference.getUTCFullYear();
+    const month = reference.getUTCMonth() + offset;
+    if (new Date(Date.UTC(year, month, day)).getUTCDate() !== day) continue;
+    const candidate = new Date(Date.UTC(year, month, day, hour, minute));
+    if (best === null || Math.abs(candidate.getTime() - reference.getTime()) < Math.abs(best.getTime() - reference.getTime())) {
+      best = candidate;
+    }
+  }
+  return best ?? new Date(Number.NaN);
+}
+
+// src/metar.ts
+var TIME = /^(\d{2})(\d{2})(\d{2})Z$/;
+var TEMPERATURE = /^(M?\d{2})\/(M?\d{2}|\/\/)?$/;
+var QNH = /^Q(\d{4})$/;
+var ALTIMETER = /^A(\d{4})$/;
+var STOP = /* @__PURE__ */ new Set(["RMK"]);
+var signed = (value) => value.startsWith("M") ? -Number(value.slice(1)) : Number(value);
+function parseMetar(raw, reference = /* @__PURE__ */ new Date()) {
+  const tokens = raw.replace(/=$/, "").trim().split(/\s+/).filter(Boolean);
+  const kind = tokens[0];
+  if (kind !== "METAR" && kind !== "SPECI") return null;
+  let index = 1;
+  let corrected = false;
+  if (tokens[index] === "COR") {
+    corrected = true;
+    index += 1;
+  }
+  const station = tokens[index++];
+  const timeToken = tokens[index++]?.match(TIME);
+  if (!station || !/^[A-Z]{4}$/.test(station) || !timeToken) return null;
+  const observedAt = resolveDayTime(
+    reference,
+    Number(timeToken[1]),
+    Number(timeToken[2]),
+    Number(timeToken[3])
+  );
+  if (Number.isNaN(observedAt.getTime())) return null;
+  let auto = false;
+  let temperatureC = null;
+  let dewPointC = null;
+  let qnhHpa = null;
+  let trend = null;
+  const body = [];
+  for (const token of tokens.slice(index)) {
+    if (STOP.has(token)) break;
+    if (token === "NOSIG" || token === "BECMG" || token === "TEMPO") {
+      trend = token;
+      break;
+    }
+    if (token === "AUTO") {
+      auto = true;
+      continue;
+    }
+    const temp = token.match(TEMPERATURE);
+    if (temp?.[1]) {
+      temperatureC = signed(temp[1]);
+      dewPointC = temp[2] && temp[2] !== "//" ? signed(temp[2]) : null;
+      continue;
+    }
+    const qnh = token.match(QNH);
+    if (qnh?.[1]) {
+      qnhHpa = Number(qnh[1]);
+      continue;
+    }
+    const altimeter = token.match(ALTIMETER);
+    if (altimeter?.[1]) {
+      qnhHpa = Math.round(Number(altimeter[1]) / 100 * 33.8639);
+      continue;
+    }
+    body.push(token);
+  }
+  const parsed = parseConditionTokens(body);
+  return {
+    kind,
+    station,
+    observedAt,
+    auto,
+    corrected,
+    conditions: mergeConditions(emptyConditions(), parsed),
+    temperatureC,
+    dewPointC,
+    qnhHpa,
+    trend,
+    raw: tokens.join(" ")
+  };
+}
+
+// src/taf.ts
+var ISSUED = /^(\d{2})(\d{2})(\d{2})Z$/;
+var VALIDITY = /^(\d{2})(\d{2})\/(\d{2})(\d{2})$/;
+var FROM = /^FM(\d{2})(\d{2})(\d{2})$/;
+var PROB = /^PROB(30|40)$/;
+var TEMPERATURE_GROUP = /^T[XN]M?\d{2}\/\d{4}Z$/;
+function parseTaf(raw, reference = /* @__PURE__ */ new Date()) {
+  const tokens = raw.replace(/=$/, "").trim().split(/\s+/).filter(Boolean);
+  if (tokens[0] !== "TAF") return null;
+  let index = 1;
+  let amended = false;
+  let corrected = false;
+  while (tokens[index] === "AMD" || tokens[index] === "COR") {
+    if (tokens[index] === "AMD") amended = true;
+    else corrected = true;
+    index += 1;
+  }
+  const station = tokens[index++];
+  const issued = tokens[index++]?.match(ISSUED);
+  if (!station || !/^[A-Z]{4}$/.test(station) || !issued) return null;
+  const issuedAt = resolveDayTime(
+    reference,
+    Number(issued[1]),
+    Number(issued[2]),
+    Number(issued[3])
+  );
+  const validity = tokens[index]?.match(VALIDITY);
+  if (!validity || Number.isNaN(issuedAt.getTime())) return null;
+  index += 1;
+  const validFrom = resolveDayTime(issuedAt, Number(validity[1]), Number(validity[2]));
+  const validTo = resolveDayTime(issuedAt, Number(validity[3]), Number(validity[4]));
+  const base = {
+    station,
+    issuedAt,
+    validFrom,
+    validTo,
+    amended,
+    corrected,
+    raw: tokens.join(" ")
+  };
+  if (tokens[index] === "CNL") {
+    return { kind: "TAF", ...base, cancelled: true, periods: [] };
+  }
+  const groups = [
+    { change: "BASE", from: validFrom, to: validTo, tokens: [] }
+  ];
+  let current = groups[0];
+  let probability;
+  const startGroup = (change, from, to) => {
+    current = { change, probability, from, to, tokens: [] };
+    probability = void 0;
+    groups.push(current);
+  };
+  for (let i = index; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (TEMPERATURE_GROUP.test(token)) continue;
+    const prob = token.match(PROB);
+    if (prob) {
+      probability = Number(prob[1]);
+      if (tokens[i + 1] !== "TEMPO") {
+        const period = tokens[i + 1]?.match(VALIDITY);
+        if (period) {
+          startGroup(
+            "PROB",
+            resolveDayTime(issuedAt, Number(period[1]), Number(period[2])),
+            resolveDayTime(issuedAt, Number(period[3]), Number(period[4]))
+          );
+          i += 1;
+        }
+      }
+      continue;
+    }
+    const from = token.match(FROM);
+    if (from) {
+      startGroup(
+        "FM",
+        resolveDayTime(issuedAt, Number(from[1]), Number(from[2]), Number(from[3])),
+        validTo
+      );
+      continue;
+    }
+    if (token === "BECMG" || token === "TEMPO") {
+      const period = tokens[i + 1]?.match(VALIDITY);
+      if (!period) continue;
+      startGroup(
+        token,
+        resolveDayTime(issuedAt, Number(period[1]), Number(period[2])),
+        resolveDayTime(issuedAt, Number(period[3]), Number(period[4]))
+      );
+      i += 1;
+      continue;
+    }
+    current.tokens.push(token);
+  }
+  const periods = groups.map((group) => {
+    const { rest: _rest, ...conditions } = parseConditionTokens(group.tokens);
+    return {
+      change: group.change,
+      probability: group.probability,
+      from: group.from,
+      to: group.to,
+      conditions,
+      raw: group.tokens.join(" ")
+    };
+  });
+  return { kind: "TAF", ...base, cancelled: false, periods };
+}
+var lerp = (a, b, t) => a + (b - a) * t;
+function lerpAngle(a, b, t) {
+  const delta = (b - a + 540) % 360 - 180;
+  return (a + delta * t + 360) % 360;
+}
+function blendConditions(a, b, t) {
+  const direction = a.wind.directionDeg !== null && b.wind.directionDeg !== null ? lerpAngle(a.wind.directionDeg, b.wind.directionDeg, t) : t < 0.5 ? a.wind.directionDeg : b.wind.directionDeg;
+  const gust = a.wind.gustKt !== null && b.wind.gustKt !== null ? lerp(a.wind.gustKt, b.wind.gustKt, t) : t < 0.5 ? a.wind.gustKt : b.wind.gustKt;
+  const visibility = a.visibilityM !== null && b.visibilityM !== null ? lerp(a.visibilityM, b.visibilityM, t) : t < 0.5 ? a.visibilityM : b.visibilityM;
+  const later = t < 0.5 ? a : b;
+  return {
+    wind: {
+      directionDeg: direction,
+      variable: direction === null,
+      speedKt: lerp(a.wind.speedKt, b.wind.speedKt, t),
+      gustKt: gust
+    },
+    visibilityM: visibility,
+    cavok: later.cavok,
+    clouds: later.clouds,
+    weather: later.weather
+  };
+}
+function forecastAt(taf, at, options = {}) {
+  if (taf.cancelled) return null;
+  const time = at.getTime();
+  if (time < taf.validFrom.getTime() || time >= taf.validTo.getTime()) return null;
+  const ordered = [...taf.periods].sort((x, y) => x.from.getTime() - y.from.getTime());
+  let state = emptyConditions();
+  let transition = null;
+  let temporary = false;
+  for (const period of ordered) {
+    if (period.change === "BASE") {
+      state = mergeConditions(emptyConditions(), period.conditions);
+    } else if (period.change === "FM" && period.from.getTime() <= time) {
+      state = mergeConditions(emptyConditions(), period.conditions);
+      transition = null;
+    } else if (period.change === "BECMG" && period.from.getTime() <= time) {
+      const target = mergeConditions(state, period.conditions);
+      if (time >= period.to.getTime()) {
+        state = target;
+        transition = null;
+      } else {
+        const progress = (time - period.from.getTime()) / (period.to.getTime() - period.from.getTime());
+        state = blendConditions(state, target, progress);
+        transition = progress;
+      }
+    }
+  }
+  for (const period of ordered) {
+    const overlay = period.change === "TEMPO" || period.change === "PROB" && options.includeProbable === true;
+    if (!overlay) continue;
+    if (period.probability !== void 0 && !options.includeProbable) continue;
+    if (time >= period.from.getTime() && time < period.to.getTime()) {
+      state = mergeConditions(state, period.conditions);
+      temporary = true;
+    }
+  }
+  return { conditions: state, temporary, transition };
+}
+
+// src/animation.ts
+var COVERAGE = {
+  FEW: 0.19,
+  SCT: 0.44,
+  BKN: 0.81,
+  OVC: 1,
+  VV: 1
+};
+var INTENSITY = {
+  light: 0.3,
+  moderate: 0.6,
+  heavy: 1,
+  vicinity: 0.3
+};
+var PRECIPITATION = {
+  DZ: "drizzle",
+  RA: "rain",
+  SN: "snow",
+  SG: "snow",
+  GR: "hail",
+  GS: "hail",
+  IC: "ice",
+  PL: "ice"
+};
+var OBSCURATION = {
+  FG: "fog",
+  BR: "mist",
+  HZ: "haze",
+  FU: "smoke",
+  DU: "dust",
+  SA: "sand",
+  VA: "ash"
+};
+var OBSCURATION_DENSITY = {
+  fog: 1,
+  mist: 0.4,
+  haze: 0.35,
+  smoke: 0.5,
+  dust: 0.5,
+  sand: 0.6,
+  ash: 0.7
+};
+var clamp = (value, min = 0, max = 1) => Math.min(max, Math.max(min, value));
+var band = (baseFt) => baseFt === null || baseFt < 2500 ? "low" : baseFt < 8e3 ? "mid" : "high";
+function cloudAnimation(layer) {
+  const coverage = COVERAGE[layer.cover];
+  if (coverage === void 0) return null;
+  return {
+    coverage,
+    baseFt: layer.baseFt,
+    band: band(layer.baseFt),
+    convective: layer.type === "CB" || layer.type === "TCU"
+  };
+}
+function hazeFor(visibilityM) {
+  if (visibilityM === null) return 0;
+  return clamp((8e3 - visibilityM) / (8e3 - 500)) * 0.9;
+}
+function animationFromConditions(conditions) {
+  const { wind } = conditions;
+  const turbulent = wind.variable || wind.variableFromDeg !== void 0;
+  const gustiness = wind.gustKt === null ? 0 : clamp((wind.gustKt - wind.speedKt) / 20);
+  const layers = conditions.clouds.map(cloudAnimation).filter((layer) => layer !== null);
+  const total = clamp(1 - layers.reduce((open, l) => open * (1 - l.coverage), 1));
+  let precipitation = null;
+  let thunderstorm = null;
+  let obscuration = null;
+  for (const weather of conditions.weather) {
+    const intensity = INTENSITY[weather.intensity];
+    const vicinity = weather.intensity === "vicinity";
+    if (weather.descriptor === "TS") {
+      const rate = vicinity ? 2 : Math.round(3 + 9 * intensity);
+      if (!thunderstorm || rate > thunderstorm.lightningPerMinute) {
+        thunderstorm = { overhead: !vicinity, vicinity, lightningPerMinute: rate };
+      }
+    }
+    if (vicinity) continue;
+    for (const code of weather.phenomena) {
+      const kind = PRECIPITATION[code];
+      if (kind && (!precipitation || intensity > precipitation.intensity)) {
+        precipitation = {
+          kind,
+          intensity,
+          showers: weather.descriptor === "SH" || weather.descriptor === "TS",
+          freezing: weather.descriptor === "FZ"
+        };
+      }
+      const obscure = OBSCURATION[code];
+      if (obscure) {
+        const density = OBSCURATION_DENSITY[obscure];
+        if (!obscuration || density > obscuration.density) {
+          obscuration = { kind: obscure, density };
+        }
+      }
+    }
+  }
+  return {
+    wind: {
+      fromDeg: wind.directionDeg,
+      toDeg: wind.directionDeg === null ? null : (wind.directionDeg + 180) % 360,
+      speedKt: wind.speedKt,
+      gustiness,
+      turbulent
+    },
+    clouds: { layers, total },
+    visibility: { meters: conditions.visibilityM, haze: hazeFor(conditions.visibilityM) },
+    obscuration,
+    precipitation,
+    thunderstorm
+  };
+}
+function animationSnapshot(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),
+      source: observation.kind,
+      station: observation.station,
+      validAt: observation.observedAt,
+      stale: false,
+      temporary: false,
+      transition: null
+    };
+  }
+  const predicted = forecast ? forecastAt(forecast, at, { includeProbable: input.includeProbable }) : null;
+  if (forecast && predicted) {
+    return {
+      state: animationFromConditions(predicted.conditions),
+      source: "TAF",
+      station: forecast.station,
+      validAt: at,
+      stale: false,
+      temporary: predicted.temporary,
+      transition: predicted.transition
+    };
+  }
+  if (observation) {
+    return {
+      state: animationFromConditions(observation.conditions),
+      source: observation.kind,
+      station: observation.station,
+      validAt: observation.observedAt,
+      stale: true,
+      temporary: false,
+      transition: null
+    };
+  }
+  return null;
+}
+
+// src/grid.ts
+var KT_TO_MS = 0.514444;
+var KM_PER_DEG_LAT = 111.32;
+var speedOf = (u, v) => Math.hypot(u, v);
+function directionFromUV(u, v) {
+  return (Math.atan2(-u, -v) * 180 / Math.PI + 360) % 360;
+}
+function uvFromSpeedDirection(speedMs, fromDeg) {
+  const rad = fromDeg * Math.PI / 180;
+  return { u: -speedMs * Math.sin(rad), v: -speedMs * Math.cos(rad) };
+}
+function pointOf(bounds, nx, ny, col, row) {
+  return {
+    lon: bounds.west + (bounds.east - bounds.west) * col / Math.max(1, nx - 1),
+    lat: bounds.north - (bounds.north - bounds.south) * row / Math.max(1, ny - 1)
+  };
+}
+function distanceKm(a, b) {
+  const dLat = (a.lat - b.lat) * KM_PER_DEG_LAT;
+  const dLon = (a.lon - b.lon) * KM_PER_DEG_LAT * Math.cos((a.lat + b.lat) / 2 * (Math.PI / 180));
+  return Math.hypot(dLat, dLon);
+}
+function interpolateScalar(points, options) {
+  const { bounds, nx, ny } = options;
+  const power = options.power ?? 2;
+  const maxKm = options.maxDistanceKm ?? 400;
+  const values = new Float32Array(nx * ny).fill(Number.NaN);
+  for (let row = 0; row < ny; row++) {
+    for (let col = 0; col < nx; col++) {
+      const cell = pointOf(bounds, nx, ny, col, row);
+      let weightSum = 0;
+      let sum = 0;
+      let exact = null;
+      for (const p of points) {
+        const d = distanceKm(cell, p);
+        if (d > maxKm) continue;
+        if (d < 0.5) {
+          exact = p.value;
+          break;
+        }
+        const w = 1 / d ** power;
+        weightSum += w;
+        sum += w * p.value;
+      }
+      values[row * nx + col] = exact ?? (weightSum > 0 ? sum / weightSum : Number.NaN);
+    }
+  }
+  return { bounds, nx, ny, values };
+}
+function windGridFromStations(stations, options) {
+  const components = stations.map((s) => {
+    const speedMs = s.speedKt * KT_TO_MS;
+    const { u: u2, v: v2 } = s.directionDeg === null ? { u: 0, v: 0 } : uvFromSpeedDirection(speedMs, s.directionDeg);
+    return { lat: s.lat, lon: s.lon, u: u2, v: v2 };
+  });
+  const u = interpolateScalar(components.map((c) => ({ lat: c.lat, lon: c.lon, value: c.u })), options);
+  const v = interpolateScalar(components.map((c) => ({ lat: c.lat, lon: c.lon, value: c.v })), options);
+  return { bounds: options.bounds, nx: options.nx, ny: options.ny, u: u.values, v: v.values };
+}
+function bilinear(values, bounds, nx, ny, lon, lat) {
+  if (lon < bounds.west || lon > bounds.east || lat < bounds.south || lat > bounds.north) return null;
+  const fx = (lon - bounds.west) / (bounds.east - bounds.west || 1) * (nx - 1);
+  const fy = (bounds.north - lat) / (bounds.north - bounds.south || 1) * (ny - 1);
+  const x0 = Math.min(nx - 1, Math.floor(fx));
+  const y0 = Math.min(ny - 1, Math.floor(fy));
+  const x1 = Math.min(nx - 1, x0 + 1);
+  const y1 = Math.min(ny - 1, y0 + 1);
+  const tx = fx - x0;
+  const ty = fy - y0;
+  const a = values[y0 * nx + x0];
+  const b = values[y0 * nx + x1];
+  const c = values[y1 * nx + x0];
+  const d = values[y1 * nx + x1];
+  const result = (a * (1 - tx) + b * tx) * (1 - ty) + (c * (1 - tx) + d * tx) * ty;
+  return Number.isNaN(result) ? null : result;
+}
+function sampleScalar(grid, lon, lat) {
+  return bilinear(grid.values, grid.bounds, grid.nx, grid.ny, lon, lat);
+}
+function sampleWind(grid, lon, lat) {
+  const u = bilinear(grid.u, grid.bounds, grid.nx, grid.ny, lon, lat);
+  const v = bilinear(grid.v, grid.bounds, grid.nx, grid.ny, lon, lat);
+  return u === null || v === null ? null : { u, v };
+}
+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);
+  return { bounds: a.bounds, nx: a.nx, ny: a.ny, u: mix(a.u, b.u), v: mix(a.v, b.v) };
+}
+var isRecord = (value) => typeof value === "object" && value !== null;
+function isGrib2Json(input) {
+  return Array.isArray(input) && input.length >= 2 && input.every((r) => isRecord(r) && isRecord(r.header) && Array.isArray(r.data));
+}
+function parseGrib2Json(input) {
+  if (!isGrib2Json(input)) throw new Error("Bukan JSON grib2json: perlu larik rekaman {header, data}");
+  const uRecord = input.find((r) => r.header.parameterNumber === 2 && (r.header.parameterCategory ?? 2) === 2);
+  const vRecord = input.find((r) => r.header.parameterNumber === 3 && (r.header.parameterCategory ?? 2) === 2);
+  if (!uRecord || !vRecord) throw new Error("Komponen angin u (2) dan v (3) tidak ditemukan");
+  const { nx, ny, lo1, la1 } = uRecord.header;
+  if (uRecord.data.length !== nx * ny || vRecord.data.length !== nx * ny) {
+    throw new Error("Jumlah data tidak sama dengan nx * ny");
+  }
+  const dx = uRecord.header.dx ?? ((uRecord.header.lo2 ?? lo1) - lo1) / Math.max(1, nx - 1);
+  const dy = Math.abs(uRecord.header.dy ?? ((uRecord.header.la2 ?? la1) - la1) / Math.max(1, ny - 1));
+  const lo2 = uRecord.header.lo2 ?? lo1 + dx * (nx - 1);
+  const la2 = uRecord.header.la2 ?? la1 - dy * (ny - 1);
+  const norm = (lon) => lon > 180 ? lon - 360 : lon;
+  const north = Math.max(la1, la2);
+  const south = Math.min(la1, la2);
+  const flip = la1 < la2;
+  const orient = (data) => {
+    const out = new Float32Array(nx * ny);
+    for (let row = 0; row < ny; row++) {
+      const source = flip ? ny - 1 - row : row;
+      for (let col = 0; col < nx; col++) {
+        const value = data[source * nx + col];
+        out[row * nx + col] = typeof value === "number" ? value : Number.NaN;
+      }
+    }
+    return out;
+  };
+  return {
+    bounds: { west: norm(lo1), south, east: norm(lo2), north },
+    nx,
+    ny,
+    u: orient(uRecord.data),
+    v: orient(vRecord.data)
+  };
+}
+function stationWindsFromMetars(reports, locate) {
+  const out = [];
+  for (const report of reports) {
+    const place = locate(report.station);
+    if (!place) continue;
+    const { wind } = report.conditions;
+    out.push({
+      lat: place.lat,
+      lon: place.lon,
+      speedKt: wind.speedKt,
+      directionDeg: wind.variable ? null : wind.directionDeg
+    });
+  }
+  return out;
+}
+function parseGridJson(input) {
+  if (!isRecord(input) || !isRecord(input.bounds)) throw new Error("JSON grid tidak valid: bounds hilang");
+  const { west, south, east, north } = input.bounds;
+  const nx = Number(input.nx);
+  const ny = Number(input.ny);
+  if (![west, south, east, north].every((n) => typeof n === "number") || !(nx > 0) || !(ny > 0)) {
+    throw new Error("JSON grid tidak valid: bounds/nx/ny");
+  }
+  const bounds = { west, south, east, north };
+  const toArray = (value) => {
+    if (!Array.isArray(value) || value.length !== nx * ny) throw new Error("Ukuran larik tidak sama dengan nx * ny");
+    return Float32Array.from(value, (n) => typeof n === "number" ? n : Number.NaN);
+  };
+  if (input.u !== void 0 && input.v !== void 0) {
+    return { bounds, nx, ny, u: toArray(input.u), v: toArray(input.v) };
+  }
+  return { bounds, nx, ny, values: toArray(input.values) };
+}
+var OPEN_METEO_SPEED_TO_MS = {
+  "km/h": 1 / 3.6,
+  "m/s": 1,
+  kn: KT_TO_MS,
+  mph: 0.44704
+};
+function stationWindsFromModelPoints(response, options = {}) {
+  const list = Array.isArray(response) ? response : [response];
+  const toMs = OPEN_METEO_SPEED_TO_MS[options.speedUnit ?? "km/h"] ?? 1 / 3.6;
+  const out = [];
+  for (const item of list) {
+    if (!isRecord(item)) continue;
+    const lat = Number(item.latitude);
+    const lon = Number(item.longitude);
+    const source = isRecord(item.current) ? item.current : isRecord(item.hourly) ? item.hourly : null;
+    if (!source || Number.isNaN(lat) || Number.isNaN(lon)) continue;
+    const pick = (value) => Array.isArray(value) ? Number(value[options.hourIndex ?? 0]) : Number(value);
+    const speed = pick(source.wind_speed_10m);
+    const direction = pick(source.wind_direction_10m);
+    if (Number.isNaN(speed)) continue;
+    out.push({
+      lat,
+      lon,
+      speedKt: speed * toMs / KT_TO_MS,
+      directionDeg: Number.isNaN(direction) ? null : direction
+    });
+  }
+  return out;
+}
+function decodeGridJson(input, fallback) {
+  if (isGrib2Json(input)) return { kind: "wind", grid: parseGrib2Json(input) };
+  if (isRecord(input) && isRecord(input.bounds)) {
+    const grid = parseGridJson(input);
+    return "u" in grid ? { kind: "wind", grid } : { kind: "scalar", grid };
+  }
+  const items = Array.isArray(input) ? input : [input];
+  if (items.some((item) => isRecord(item) && item.latitude !== void 0 && item.longitude !== void 0)) {
+    if (!fallback) throw new Error("Respons banyak lokasi perlu bounds, nx, dan ny untuk dijadikan grid");
+    const stations = stationWindsFromModelPoints(input, fallback);
+    if (stations.length === 0) throw new Error("Tidak ada titik dengan wind_speed_10m pada respons");
+    return { kind: "wind", grid: windGridFromStations(stations, fallback) };
+  }
+  throw new Error("Format medan tidak dikenal: harus grib2json, JSON grid {bounds,nx,ny,u,v|values}, atau respons banyak lokasi");
+}
+
+// src/index.ts
+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);
+    if (report) reports.push(report);
+  }
+  return reports;
+}
+export {
+  animationFromConditions,
+  animationSnapshot,
+  blendConditions,
+  blendWindGrids,
+  decodeGridJson,
+  decodeWeatherMessage,
+  directionFromUV,
+  emptyConditions,
+  extractReports,
+  forecastAt,
+  interpolateScalar,
+  mergeConditions,
+  parseConditionTokens,
+  parseGrib2Json,
+  parseGridJson,
+  parseMetar,
+  parseTaf,
+  pointOf,
+  resolveDayTime,
+  sampleScalar,
+  sampleWind,
+  speedOf,
+  stationWindsFromMetars,
+  stationWindsFromModelPoints,
+  uvFromSpeedDirection,
+  windGridFromStations
+};

package/dist/metar.d.ts

@@ -0,0 +1,8 @@
+import type { Metar } from "./types.js";
+/**
+ * Baca satu laporan METAR/SPECI. `reference` menentukan bulan dan tahun (laporan hanya memuat
+ * tanggal); isi dengan waktu pesan diterima. Mengembalikan null bila bukan METAR/SPECI atau waktunya
+ * tidak terbaca.
+ */
+export declare function parseMetar(raw: string, reference?: Date): Metar | null;
+//# sourceMappingURL=metar.d.ts.map

package/dist/metar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metar.d.ts","sourceRoot":"","sources":["../src/metar.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAWxC;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,GAAE,IAAiB,GAAG,KAAK,GAAG,IAAI,CA0ElF"}

package/dist/taf.d.ts

@@ -0,0 +1,22 @@
+import type { Conditions, Taf } from "./types.js";
+/**
+ * Baca satu TAF (termasuk AMD/COR/CNL). `reference` menentukan bulan dan tahun; isi dengan waktu
+ * pesan diterima. Mengembalikan null bila bukan TAF yang bisa dibaca.
+ */
+export declare function parseTaf(raw: string, reference?: Date): Taf | null;
+export interface ForecastAt {
+    conditions: Conditions;
+    /** True bila kondisi ini hanya sementara (TEMPO atau PROB yang sedang berlaku). */
+    temporary: boolean;
+    /** 0-1 selama transisi BECMG yang sedang berjalan; null di luar transisi. */
+    transition: number | null;
+}
+export interface ForecastOptions {
+    /** Ikutkan grup PROB30/PROB40 (bawaan: tidak, karena belum tentu terjadi). */
+    includeProbable?: boolean;
+}
+/** Campur dua kondisi: angka dan arah berpindah halus; awan dan cuaca berganti di tengah transisi. */
+export declare function blendConditions(a: Conditions, b: Conditions, t: number): Conditions;
+/** Kondisi yang berlaku pada waktu `at` menurut TAF. Null bila di luar masa berlaku atau dibatalkan. */
+export declare function forecastAt(taf: Taf, at: Date, options?: ForecastOptions): ForecastAt | null;
+//# sourceMappingURL=taf.d.ts.map

package/dist/taf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taf.d.ts","sourceRoot":"","sources":["../src/taf.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,GAAG,EAAwB,MAAM,YAAY,CAAC;AAgBxE;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,GAAE,IAAiB,GAAG,GAAG,GAAG,IAAI,CAiH9E;AAED,MAAM,WAAW,UAAU;IACzB,UAAU,EAAE,UAAU,CAAC;IACvB,mFAAmF;IACnF,SAAS,EAAE,OAAO,CAAC;IACnB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,8EAA8E;IAC9E,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AASD,sGAAsG;AACtG,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAgCnF;AAED,wGAAwG;AACxG,wBAAgB,UAAU,CACxB,GAAG,EAAE,GAAG,EACR,EAAE,EAAE,IAAI,EACR,OAAO,GAAE,eAAoB,GAC5B,UAAU,GAAG,IAAI,CA2CnB"}

package/dist/time.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Tanggal lengkap dari hari-jam-menit (DDHHMM) tanpa bulan/tahun: ambil bulan (sebelumnya, ini,
+ * berikutnya) yang hasilnya paling dekat ke `reference`. Jam 24 berarti tengah malam hari berikutnya.
+ */
+export declare function resolveDayTime(reference: Date, day: number, hour: number, minute?: number): Date;
+//# sourceMappingURL=time.d.ts.map

package/dist/time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time.d.ts","sourceRoot":"","sources":["../src/time.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,IAAI,EACf,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,MAAM,EACZ,MAAM,SAAI,GACT,IAAI,CAiBN"}

package/dist/types.d.ts

@@ -0,0 +1,77 @@
+export type ReportKind = "METAR" | "SPECI" | "TAF";
+export type CloudCover = "FEW" | "SCT" | "BKN" | "OVC" | "VV" | "SKC" | "NSC" | "NCD";
+export interface CloudLayer {
+    cover: CloudCover;
+    /** Tinggi dasar awan (ft AGL); null bila tidak diketahui (`///`) atau tanpa awan. */
+    baseFt: number | null;
+    type?: "CB" | "TCU";
+}
+export interface Wind {
+    /** Arah ASAL angin (derajat, 0-360); null bila berubah-ubah (VRB). */
+    directionDeg: number | null;
+    variable: boolean;
+    /** Rentang arah berubah-ubah (mis. 180V240), bila dilaporkan. */
+    variableFromDeg?: number;
+    variableToDeg?: number;
+    speedKt: number;
+    gustKt: number | null;
+}
+export type WeatherIntensity = "light" | "moderate" | "heavy" | "vicinity";
+export interface PresentWeather {
+    intensity: WeatherIntensity;
+    /** Deskriptor (SH, TS, FZ, ...), bila ada. */
+    descriptor?: string;
+    /** Fenomena (RA, SN, FG, ...), kosong untuk deskriptor tunggal seperti TS. */
+    phenomena: string[];
+    /** Kode asli, mis. `+TSRA`. */
+    code: string;
+}
+/** Kondisi cuaca pada satu titik waktu. */
+export interface Conditions {
+    wind: Wind;
+    /** Jarak pandang (meter); 10000 untuk 9999 dan CAVOK. */
+    visibilityM: number | null;
+    cavok: boolean;
+    clouds: CloudLayer[];
+    weather: PresentWeather[];
+}
+export interface Metar {
+    kind: "METAR" | "SPECI";
+    station: string;
+    observedAt: Date;
+    auto: boolean;
+    corrected: boolean;
+    conditions: Conditions;
+    temperatureC: number | null;
+    dewPointC: number | null;
+    qnhHpa: number | null;
+    trend: "NOSIG" | "BECMG" | "TEMPO" | null;
+    raw: string;
+}
+export type TafChange = "BASE" | "FM" | "BECMG" | "TEMPO" | "PROB";
+export interface TafPeriod {
+    change: TafChange;
+    /** Peluang (30/40) untuk PROB, atau PROB TEMPO. */
+    probability?: number;
+    from: Date;
+    to: Date;
+    /** Hanya bagian yang disebut grup ini; sisanya diwarisi dari grup sebelumnya. */
+    conditions: Partial<Conditions> & {
+        noSignificantWeather?: boolean;
+    };
+    raw: string;
+}
+export interface Taf {
+    kind: "TAF";
+    station: string;
+    issuedAt: Date;
+    validFrom: Date;
+    validTo: Date;
+    amended: boolean;
+    corrected: boolean;
+    cancelled: boolean;
+    periods: TafPeriod[];
+    raw: string;
+}
+export type Report = Metar | Taf;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/dist/weather.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=weather.test.d.ts.map

package/dist/weather.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"weather.test.d.ts","sourceRoot":"","sources":["../src/weather.test.ts"],"names":[],"mappings":""}

package/package.json

@@ -1,6 +1,40 @@
 {
   "name": "@aeroswarm/weather",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.2",
+  "description": "Decode raw AFTN/METAR/SPECI/TAF messages and turn them into animation parameters.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "main": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --clean && tsc --emitDeclarationOnly",
+    "dev": "tsup src/index.ts --format esm --dts --watch",
+    "test": "vitest run --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "pnpm run typecheck && pnpm run test && pnpm run build",
+    "release": "release-it",
+    "release:dry": "release-it --dry-run",
+    "release:patch": "release-it patch --no-git.requireCleanWorkingDir",
+    "release:minor": "release-it minor --no-git.requireCleanWorkingDir",
+    "release:major": "release-it major --no-git.requireCleanWorkingDir"
+  },
+  "devDependencies": {
+    "release-it": "^18.1.2",
+    "tsup": "^8.5.1",
+    "vitest": "^4.1.6"
+  }
+}