@aeroswarm/weather 0.1.3 → 0.1.4

package/GRID_STANDARD.md

@@ -0,0 +1,68 @@
+# AeroSwarm Weather Grid (`aeroswarm.weather-grid`) v1
+
+One JSON format for gridded weather forecasts, whatever the source (a model API, a converted GRIB
+file, your own service). A source only has to produce this document; the renderer and the timeline
+never need to know where the data came from.
+
+- Read: `parseWeatherGridSeries(json)` (strict, throws a message naming the bad part).
+- Write: `serializeWeatherGridSeries(series)`.
+- Use: `seriesFieldsAt(series, time)` blends the two nearest frames; `null` outside the time range.
+- Open-Meteo: `latticePoints(lattice)` gives the points to request, `weatherGridFromOpenMeteo(response,
+  lattice)` turns the answer into this format. Nothing here calls the network.
+
+## Document
+
+```json
+{
+  "standard": "aeroswarm.weather-grid",
+  "version": 1,
+  "source": {
+    "name": "open-meteo",
+    "model": "icon_seamless",
+    "runAt": "2026-11-02T00:00:00Z",
+    "generatedAt": "2026-11-02T04:12:00Z"
+  },
+  "grid": { "west": 105, "south": -11, "east": 118, "north": -5, "nx": 14, "ny": 13 },
+  "times": ["2026-11-02T04:00:00Z", "2026-11-02T05:00:00Z"],
+  "fields": {
+    "windU":       [[/* nx*ny values for time 0 */], [/* time 1 */]],
+    "windV":       [[...], [...]],
+    "cloud":       [[...], [...]],
+    "rain":        [[...], [...]],
+    "temperature": [[...], [...]]
+  }
+}
+```
+
+## Rules
+
+| Part | Rule |
+|---|---|
+| `standard`, `version` | Exactly `"aeroswarm.weather-grid"` and `1`. |
+| `source.name` | Required. `model`, `runAt`, `generatedAt` are optional (ISO 8601). |
+| `grid` | `west < east`, `south < north`, `nx` and `ny` integers >= 2. Cells sit on the lattice points: column 0 is `west`, the last column is `east`; row 0 is `north`, the last row is `south`. |
+| `times` | At least one ISO 8601 time in UTC, strictly increasing. |
+| `fields` | At least one quantity. Each present quantity has exactly one array per time, and each array has exactly `nx * ny` values in row-major order (row 0 first). `null` means no data. |
+| `windU` / `windV` | Both or neither. m/s. `windU` blows towards the east, `windV` towards the north. |
+| `cloud` | Total cloud cover, percent 0-100. |
+| `rain` | Precipitation rate, mm per hour. |
+| `temperature` | Degrees Celsius. |
+
+Wind is stored as components, not speed and direction, so frames can be blended and interpolated
+without wrapping problems. To convert: `u = -speed * sin(from)`, `v = -speed * cos(from)`, where
+`from` is the direction the wind comes FROM (meteorological, degrees from north).
+
+## Versioning
+
+A change that breaks readers (a different layout, a changed unit) raises `version`. Adding an optional
+quantity or an optional `source` field does not. A reader must reject a `version` it does not know
+instead of guessing.
+
+## Producing it
+
+- **Open-Meteo (in an app, not in this package):** request the lattice points with
+  `hourly=wind_speed_10m,wind_direction_10m,cloud_cover,precipitation,temperature_2m`,
+  `wind_speed_unit=ms`, `timezone=GMT`, then call `weatherGridFromOpenMeteo`.
+- **GRIB:** convert to JSON on the server (`grib2json` or `wgrib2`), then build the document from the
+  two wind records and any scalar fields.
+- **Your own service:** return this document directly; the app loads it from a URL or a file.

package/README.md

@@ -38,3 +38,11 @@ representation around the airport, not the real position of clouds or rain.
 - `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.
+
+## Gridded forecast standard
+
+`GRID_STANDARD.md` defines `aeroswarm.weather-grid` v1: one JSON format (grid + times + wind/cloud/rain/
+temperature) for any model source. `parseWeatherGridSeries`, `serializeWeatherGridSeries`,
+`seriesFieldsAt`, and the Open-Meteo adapter (`latticePoints`, `weatherGridFromOpenMeteo`) are in the
+package; the network call stays in the app.
+

package/dist/gridSeries.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Standar data medan cuaca AeroSwarm (`aeroswarm.weather-grid` versi 1).
+ *
+ * Satu format untuk semua sumber model (Open-Meteo, hasil konversi GRIB, layanan sendiri): grid
+ * beraturan, beberapa waktu, dan beberapa besaran. Sumber apa pun cukup menghasilkan format ini; renderer
+ * dan timeline tidak perlu tahu asalnya. Lihat GRID_STANDARD.md untuk bentuk JSON-nya.
+ *
+ * Konvensi: baris 0 = utara, kolom 0 = barat. Angin m/s (`windU` ke timur, `windV` ke utara), awan %,
+ * hujan mm/jam, suhu °C. Nilai `null` = tanpa data. Waktu UTC.
+ */
+import { type GridBounds, type ScalarGrid, type WindGrid } from "./grid.js";
+export declare const WEATHER_GRID_STANDARD = "aeroswarm.weather-grid";
+export declare const WEATHER_GRID_VERSION = 1;
+export type GridQuantity = "windU" | "windV" | "cloud" | "rain" | "temperature";
+export interface WeatherGridSource {
+    /** Nama sumber, mis. `open-meteo`. */
+    name: string;
+    /** Nama model, mis. `icon_seamless`. */
+    model?: string;
+    /** Waktu model dijalankan (run), bila diketahui. */
+    runAt?: Date;
+    /** Waktu data diambil/dibuat. */
+    generatedAt?: Date;
+}
+export interface WeatherGridSeries {
+    source: WeatherGridSource;
+    bounds: GridBounds;
+    nx: number;
+    ny: number;
+    /** Waktu tiap bingkai, naik. */
+    times: Date[];
+    /** Per besaran: satu larik nx*ny per waktu. Besaran yang tidak ada dibiarkan kosong. */
+    fields: Partial<Record<GridQuantity, Float32Array[]>>;
+}
+export interface SeriesFields {
+    at: Date;
+    wind: WindGrid | null;
+    cloud: ScalarGrid | null;
+    rain: ScalarGrid | null;
+    temperature: ScalarGrid | null;
+}
+/**
+ * Baca dan periksa JSON berstandar `aeroswarm.weather-grid` v1. Melempar galat yang menyebut bagian
+ * mana yang salah. Nilai di luar angka (null) menjadi NaN (tanpa data).
+ */
+export declare function parseWeatherGridSeries(input: unknown): WeatherGridSeries;
+/** Bentuk JSON berstandar dari seri (kebalikan `parseWeatherGridSeries`); NaN menjadi null. */
+export declare function serializeWeatherGridSeries(series: WeatherGridSeries): Record<string, unknown>;
+/** Rentang waktu seri. */
+export declare function seriesRange(series: WeatherGridSeries): {
+    from: Date;
+    to: Date;
+};
+/**
+ * Medan pada waktu `at`, dicampur linear antar dua bingkai terdekat. Null di luar rentang waktu seri.
+ * Besaran yang tidak ada di seri dikembalikan null.
+ */
+export declare function seriesFieldsAt(series: WeatherGridSeries, at: Date): SeriesFields | null;
+//# sourceMappingURL=gridSeries.d.ts.map

package/dist/gridSeries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gridSeries.d.ts","sourceRoot":"","sources":["../src/gridSeries.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAEL,KAAK,UAAU,EACf,KAAK,UAAU,EACf,KAAK,QAAQ,EACd,MAAM,WAAW,CAAC;AAEnB,eAAO,MAAM,qBAAqB,2BAA2B,CAAC;AAC9D,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,GAAG,aAAa,CAAC;AAEhF,MAAM,WAAW,iBAAiB;IAChC,sCAAsC;IACtC,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,oDAAoD;IACpD,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,iCAAiC;IACjC,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,MAAM,EAAE,UAAU,CAAC;IACnB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,gCAAgC;IAChC,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,wFAAwF;IACxF,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,YAAY,EAAE,CAAC,CAAC,CAAC;CACvD;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,IAAI,CAAC;IACT,IAAI,EAAE,QAAQ,GAAG,IAAI,CAAC;IACtB,KAAK,EAAE,UAAU,GAAG,IAAI,CAAC;IACzB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACxB,WAAW,EAAE,UAAU,GAAG,IAAI,CAAC;CAChC;AAaD;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,iBAAiB,CAgExE;AAED,+FAA+F;AAC/F,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAsB7F;AAED,0BAA0B;AAC1B,wBAAgB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG;IAAE,IAAI,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,IAAI,CAAA;CAAE,CAK/E;AAqBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,iBAAiB,EAAE,EAAE,EAAE,IAAI,GAAG,YAAY,GAAG,IAAI,CAwBvF"}

package/dist/gridSeries.test.d.ts

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

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

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

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export * from "./aftn.js";
 export * from "./animation.js";
 export * from "./conditions.js";
 export * from "./grid.js";
+export * from "./gridSeries.js";
+export * from "./openMeteo.js";
 export * from "./metar.js";
 export * from "./taf.js";
 export * from "./store.js";

package/dist/index.d.ts.map

@@ -1 +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,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,YAAY,CAAC;AAE3B;;;GAGG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EACf,SAAS,GAAE,IAAiB,GAC3B,MAAM,EAAE,CAUV"}
+{"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,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,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

@@ -688,10 +688,10 @@ function parseGrib2Json(input) {
     v: orient(vRecord.data)
   };
 }
-function stationWindsFromMetars(reports, locate) {
+function stationWindsFromMetars(reports, locate2) {
   const out = [];
   for (const report of reports) {
-    const place = locate(report.station);
+    const place = locate2(report.station);
     if (!place) continue;
     const { wind } = report.conditions;
     out.push({
@@ -766,14 +766,222 @@ function decodeGridJson(input, fallback) {
   throw new Error("Format medan tidak dikenal: harus grib2json, JSON grid {bounds,nx,ny,u,v|values}, atau respons banyak lokasi");
 }
 
+// src/gridSeries.ts
+var WEATHER_GRID_STANDARD = "aeroswarm.weather-grid";
+var WEATHER_GRID_VERSION = 1;
+var QUANTITIES = ["windU", "windV", "cloud", "rain", "temperature"];
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+function parseDate(value, where) {
+  const date = typeof value === "string" ? new Date(value) : new Date(Number.NaN);
+  if (Number.isNaN(date.getTime())) throw new Error(`${where}: bukan tanggal ISO 8601 yang valid`);
+  return date;
+}
+function parseWeatherGridSeries(input) {
+  if (!isRecord2(input)) throw new Error("Bukan objek JSON");
+  if (input.standard !== WEATHER_GRID_STANDARD) {
+    throw new Error(`standard harus "${WEATHER_GRID_STANDARD}"`);
+  }
+  if (input.version !== WEATHER_GRID_VERSION) {
+    throw new Error(`version ${String(input.version)} tidak didukung (didukung: ${WEATHER_GRID_VERSION})`);
+  }
+  const src = isRecord2(input.source) ? input.source : null;
+  if (!src || typeof src.name !== "string" || src.name === "") throw new Error("source.name wajib diisi");
+  const source = {
+    name: src.name,
+    model: typeof src.model === "string" ? src.model : void 0,
+    runAt: src.runAt === void 0 ? void 0 : parseDate(src.runAt, "source.runAt"),
+    generatedAt: src.generatedAt === void 0 ? void 0 : parseDate(src.generatedAt, "source.generatedAt")
+  };
+  const grid = isRecord2(input.grid) ? input.grid : null;
+  if (!grid) throw new Error("grid wajib diisi");
+  const { west, south, east, north } = grid;
+  const nx = Number(grid.nx);
+  const ny = Number(grid.ny);
+  if (![west, south, east, north].every((n) => typeof n === "number" && Number.isFinite(n))) {
+    throw new Error("grid.west/south/east/north harus angka");
+  }
+  if (!Number.isInteger(nx) || !Number.isInteger(ny) || nx < 2 || ny < 2) {
+    throw new Error("grid.nx dan grid.ny harus bilangan bulat >= 2");
+  }
+  const bounds = { west, south, east, north };
+  if (bounds.west >= bounds.east || bounds.south >= bounds.north) {
+    throw new Error("grid: west < east dan south < north");
+  }
+  if (!Array.isArray(input.times) || input.times.length === 0) throw new Error("times wajib berisi minimal satu waktu");
+  const times = input.times.map((t, i) => parseDate(t, `times[${i}]`));
+  for (let i = 1; i < times.length; i++) {
+    if (times[i].getTime() <= times[i - 1].getTime()) {
+      throw new Error(`times[${i}] harus lebih baru dari times[${i - 1}]`);
+    }
+  }
+  const rawFields = isRecord2(input.fields) ? input.fields : null;
+  if (!rawFields) throw new Error("fields wajib diisi");
+  const fields = {};
+  for (const quantity of QUANTITIES) {
+    const frames = rawFields[quantity];
+    if (frames === void 0) continue;
+    if (!Array.isArray(frames) || frames.length !== times.length) {
+      throw new Error(`fields.${quantity} harus berisi ${times.length} bingkai (satu per waktu)`);
+    }
+    fields[quantity] = frames.map((frame, t) => {
+      if (!Array.isArray(frame) || frame.length !== nx * ny) {
+        throw new Error(`fields.${quantity}[${t}] harus berisi ${nx * ny} nilai (nx * ny)`);
+      }
+      return Float32Array.from(frame, (v) => typeof v === "number" && Number.isFinite(v) ? v : Number.NaN);
+    });
+  }
+  if (fields.windU === void 0 !== (fields.windV === void 0)) {
+    throw new Error("windU dan windV harus ada berdua");
+  }
+  if (Object.keys(fields).length === 0) throw new Error("fields tidak berisi satu besaran pun");
+  return { source, bounds, nx, ny, times, fields };
+}
+function serializeWeatherGridSeries(series) {
+  const fields = {};
+  for (const quantity of QUANTITIES) {
+    const frames = series.fields[quantity];
+    if (!frames) continue;
+    fields[quantity] = frames.map(
+      (frame) => Array.from(frame, (v) => Number.isNaN(v) ? null : Math.round(v * 1e3) / 1e3)
+    );
+  }
+  return {
+    standard: WEATHER_GRID_STANDARD,
+    version: WEATHER_GRID_VERSION,
+    source: {
+      name: series.source.name,
+      ...series.source.model ? { model: series.source.model } : {},
+      ...series.source.runAt ? { runAt: series.source.runAt.toISOString() } : {},
+      ...series.source.generatedAt ? { generatedAt: series.source.generatedAt.toISOString() } : {}
+    },
+    grid: { ...series.bounds, nx: series.nx, ny: series.ny },
+    times: series.times.map((t) => t.toISOString()),
+    fields
+  };
+}
+function seriesRange(series) {
+  return {
+    from: series.times[0],
+    to: series.times[series.times.length - 1]
+  };
+}
+function locate(times, at) {
+  const ms = at.getTime();
+  const first = times[0].getTime();
+  const last = times[times.length - 1].getTime();
+  if (ms < first || ms > last) return null;
+  for (let i = 1; i < times.length; i++) {
+    const hi = times[i].getTime();
+    if (ms <= hi) {
+      const lo = times[i - 1].getTime();
+      return { a: i - 1, b: i, t: (ms - lo) / (hi - lo || 1) };
+    }
+  }
+  return { a: times.length - 1, b: times.length - 1, t: 0 };
+}
+var mixFrames = (frames, a, b, t) => Float32Array.from(frames[a], (value, i) => value + (frames[b][i] - value) * t);
+function seriesFieldsAt(series, at) {
+  const where = locate(series.times, at);
+  if (!where) return null;
+  const { bounds, nx, ny } = series;
+  const scalar = (quantity) => {
+    const frames = series.fields[quantity];
+    return frames ? { bounds, nx, ny, values: mixFrames(frames, where.a, where.b, where.t) } : null;
+  };
+  const u = series.fields.windU;
+  const v = series.fields.windV;
+  let wind = null;
+  if (u && v) {
+    const from = { bounds, nx, ny, u: u[where.a], v: v[where.a] };
+    const to = { bounds, nx, ny, u: u[where.b], v: v[where.b] };
+    wind = where.a === where.b ? from : blendWindGrids(from, to, where.t);
+  }
+  return {
+    at,
+    wind,
+    cloud: scalar("cloud"),
+    rain: scalar("rain"),
+    temperature: scalar("temperature")
+  };
+}
+
+// src/openMeteo.ts
+function latticePoints(lattice) {
+  const latitude = [];
+  const longitude = [];
+  for (let row = 0; row < lattice.ny; row++) {
+    const lat = lattice.north - (lattice.north - lattice.south) * row / (lattice.ny - 1);
+    for (let col = 0; col < lattice.nx; col++) {
+      latitude.push(round(lat));
+      longitude.push(round(lattice.west + (lattice.east - lattice.west) * col / (lattice.nx - 1)));
+    }
+  }
+  return { latitude, longitude };
+}
+var round = (value) => Math.round(value * 1e4) / 1e4;
+var SPEED_TO_MS = { "m/s": 1, "km/h": 1 / 3.6, kn: 0.514444, mph: 0.44704 };
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var toUtc = (iso) => new Date(/[zZ]|[+-]\d\d:?\d\d$/.test(iso) ? iso : `${iso}Z`);
+function weatherGridFromOpenMeteo(response, lattice, options = {}) {
+  const items = Array.isArray(response) ? response : [response];
+  const expected = lattice.nx * lattice.ny;
+  if (items.length !== expected) {
+    throw new Error(`Respons berisi ${items.length} titik, kisi memerlukan ${expected} (${lattice.nx} x ${lattice.ny})`);
+  }
+  const hourly = items.map((item, i) => {
+    const h = isRecord3(item) && isRecord3(item.hourly) ? item.hourly : null;
+    if (!h || !Array.isArray(h.time)) throw new Error(`Titik ${i}: tidak ada data hourly.time`);
+    return h;
+  });
+  const timesIso = hourly[0].time;
+  if (timesIso.length === 0) throw new Error("hourly.time kosong");
+  for (const [i, h] of hourly.entries()) {
+    if (h.time.length !== timesIso.length) throw new Error(`Titik ${i}: jumlah waktu berbeda dari titik pertama`);
+  }
+  const times = timesIso.map(toUtc);
+  const toMs = SPEED_TO_MS[options.speedUnit ?? "m/s"] ?? 1;
+  const frame = (pick) => times.map((_, t) => Float32Array.from(hourly, (h) => pick(h, t)));
+  const num = (value) => typeof value === "number" && Number.isFinite(value) ? value : Number.NaN;
+  const fields = {};
+  const has = (key) => hourly.every((h) => Array.isArray(h[key]));
+  if (has("wind_speed_10m") && has("wind_direction_10m")) {
+    const uv = (h, t) => {
+      const speed = num(h.wind_speed_10m?.[t]) * toMs;
+      const dir = num(h.wind_direction_10m?.[t]);
+      return Number.isNaN(speed) || Number.isNaN(dir) ? { u: Number.NaN, v: Number.NaN } : uvFromSpeedDirection(speed, dir);
+    };
+    fields.windU = frame((h, t) => uv(h, t).u);
+    fields.windV = frame((h, t) => uv(h, t).v);
+  }
+  if (has("cloud_cover")) fields.cloud = frame((h, t) => num(h.cloud_cover?.[t]));
+  if (has("precipitation")) fields.rain = frame((h, t) => num(h.precipitation?.[t]));
+  if (has("temperature_2m")) fields.temperature = frame((h, t) => num(h.temperature_2m?.[t]));
+  if (Object.keys(fields).length === 0) {
+    throw new Error("Respons tidak memuat wind_speed_10m, wind_direction_10m, cloud_cover, precipitation, atau temperature_2m");
+  }
+  return {
+    source: {
+      name: "open-meteo",
+      model: options.model,
+      runAt: options.runAt,
+      generatedAt: options.generatedAt ?? /* @__PURE__ */ new Date()
+    },
+    bounds: { west: lattice.west, south: lattice.south, east: lattice.east, north: lattice.north },
+    nx: lattice.nx,
+    ny: lattice.ny,
+    times,
+    fields
+  };
+}
+
 // src/store.ts
 var MAX_OBSERVATIONS_PER_STATION = 48;
 var MAX_FORECASTS_PER_STATION = 8;
 var rainRate = (intensity) => intensity * intensity * 15;
 var hhmm = (d) => `${String(d.getUTCHours()).padStart(2, "0")}:${String(d.getUTCMinutes()).padStart(2, "0")}`;
 var WeatherStore = class {
-  constructor(locate) {
-    this.locate = locate;
+  constructor(locate2) {
+    this.locate = locate2;
   }
   locate;
   observations = /* @__PURE__ */ new Map();
@@ -990,6 +1198,8 @@ function decodeWeatherMessage(message, reference = /* @__PURE__ */ new Date()) {
   return reports;
 }
 export {
+  WEATHER_GRID_STANDARD,
+  WEATHER_GRID_VERSION,
   WeatherStore,
   animationFromConditions,
   animationSnapshot,
@@ -1002,19 +1212,25 @@ export {
   extractReports,
   forecastAt,
   interpolateScalar,
+  latticePoints,
   mergeConditions,
   parseConditionTokens,
   parseGrib2Json,
   parseGridJson,
   parseMetar,
   parseTaf,
+  parseWeatherGridSeries,
   pointOf,
   resolveDayTime,
   sampleScalar,
   sampleWind,
+  serializeWeatherGridSeries,
+  seriesFieldsAt,
+  seriesRange,
   speedOf,
   stationWindsFromMetars,
   stationWindsFromModelPoints,
   uvFromSpeedDirection,
+  weatherGridFromOpenMeteo,
   windGridFromStations
 };

package/dist/openMeteo.d.ts

@@ -0,0 +1,40 @@
+import { type WeatherGridSeries } from "./gridSeries.js";
+/**
+ * Adaptor respons layanan model bergaya Open-Meteo menjadi standar `aeroswarm.weather-grid`. Murni:
+ * tidak memanggil jaringan. Pemanggilnya (aplikasi) yang mengambil datanya.
+ *
+ * Titik diminta sebagai kisi beraturan (lihat `latticePoints`), jadi responsnya langsung menjadi
+ * grid tanpa interpolasi.
+ */
+export interface Lattice {
+    west: number;
+    south: number;
+    east: number;
+    north: number;
+    nx: number;
+    ny: number;
+}
+/**
+ * Titik-titik kisi, baris demi baris dari utara ke selatan, kolom dari barat ke timur. Urutan ini
+ * sama dengan urutan respons banyak lokasi, dan dengan urutan sel pada grid standar.
+ */
+export declare function latticePoints(lattice: Lattice): {
+    latitude: number[];
+    longitude: number[];
+};
+declare const SPEED_TO_MS: Record<string, number>;
+export interface OpenMeteoOptions {
+    /** Satuan kecepatan angin di respons. Bawaan `m/s` (minta dengan `wind_speed_unit=ms`). */
+    speedUnit?: keyof typeof SPEED_TO_MS;
+    model?: string;
+    runAt?: Date;
+    generatedAt?: Date;
+}
+/**
+ * Susun seri standar dari respons banyak lokasi (satu elemen per titik kisi, urutan `latticePoints`).
+ * Meminta `hourly=wind_speed_10m,wind_direction_10m,cloud_cover,precipitation,temperature_2m`,
+ * `timezone=GMT`, dan `wind_speed_unit=ms`.
+ */
+export declare function weatherGridFromOpenMeteo(response: unknown, lattice: Lattice, options?: OpenMeteoOptions): WeatherGridSeries;
+export {};
+//# sourceMappingURL=openMeteo.d.ts.map

package/dist/openMeteo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openMeteo.d.ts","sourceRoot":"","sources":["../src/openMeteo.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,iBAAiB,CAAC;AAEzB;;;;;;GAMG;AAEH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,OAAO,GAAG;IAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,EAAE,CAAA;CAAE,CAW3F;AAID,QAAA,MAAM,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAA6D,CAAC;AAEtG,MAAM,WAAW,gBAAgB;IAC/B,2FAA2F;IAC3F,SAAS,CAAC,EAAE,MAAM,OAAO,WAAW,CAAC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,IAAI,CAAC;IACb,WAAW,CAAC,EAAE,IAAI,CAAC;CACpB;AAiBD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,OAAO,EAChB,OAAO,GAAE,gBAAqB,GAC7B,iBAAiB,CAyDnB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aeroswarm/weather",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Decode raw AFTN/METAR/SPECI/TAF messages and turn them into animation parameters.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "GRID_STANDARD.md"
   ],
   "publishConfig": {
     "access": "public",