Getting started

provider files ──→ meteo forecast build ──→ static profile JSON
   (@azohra/meteo.forecast)                     │
   └ decoded by @azohra/meteo.grib + @azohra/meteo.j2k  │
                                            ▼
                                 npm package `@azohra/meteo.briefing`
                          validate → derive → scene → SVG
                                   └ analyze → compare

documentation + logbook ← scenario profiles

Publisher

Install the forecast engine with Node 22 or later:
Terminal
```
pnpm add @azohra/meteo.forecast
```
Create a versioned launch catalogue.
Choose a catalogued model whose declared domain, cadence, levels, and capabilities fit the publication.

Preflight one model without network access or writes:

pnpm exec meteo forecast build --model hrrr-conus --sites ./sites.json --output ./public/data --max-steps 2 --dry-run

Remove --dry-run and the temporary --max-steps cap only when ready for the provider’s full data volume. Then publish the static output on infrastructure you control.

TypeScript integrator

Install the ESM package and begin at its contract boundary:

pnpm add @azohra/meteo.briefing

Render a first Meteogram covers the complete contract → scene → SVG path. The package is headless: the same scene and SVG code works in Node, workers, and browsers. Use @azohra/meteo.briefing/transport when loading a manifest/profile pair from independently cached static storage.

Analyze a profile produces compact, auditable statements instead of chart geometry. The single-document API keeps the thresholds and source evidence behind each finding.

Compare model profiles reports agreement and divergence across those findings while preserving each model’s run, cadence, elevation, and availability.

History and run convergence reads the published month archives and compares successive runs of one model — the forecast capability’s one server-side subpath (Node, Bun, Deno; not browsers).

The platform’s sibling package @azohra/meteo.station covers the station capability: live weather-station reading, derivation, and display, with client, server, React, and custom-element bindings — its own getting started begins there.

Decoder user

The decoders beneath the engine install on their own — no forecast documents or engine required:

pnpm add @azohra/meteo.grib

@azohra/meteo.grib decodes GRIB2 in pure TypeScript — rotated and Lambert grids, complex packing, multi-field messages, NOMADS .idx byte-range helpers — gated bit-for-bit against ecCodes. Its documentation opens with this example, run from the repository’s grib/ directory against an HRDPS fixture; a package consumer imports the same surface as @azohra/meteo.grib and @azohra/meteo.grib/j2k-node:

// decode-fixture.mjs — run inside grib/ after `pnpm build`
import { readFileSync } from "node:fs";
import {
  decodeFieldValues,
  nearestGridpoint,
  parseFields,
  parseGrid,
  splitMessages,
} from "./dist/index.js";
import { createNodeJ2kDecoder } from "./dist/j2k-node.js";

const bytes = readFileSync("test/fixtures/hrdps-continental-tmp-2m.grib2");
const [field] = parseFields(splitMessages(bytes)[0]);
const grid = parseGrid(field.section3); // rotated lat-lon (GDT 3.1)
const decodeJ2k = await createNodeJ2kDecoder(); // every ECCC field is JPEG 2000
const { values } = decodeFieldValues(field, { decodeJ2k });
const site = nearestGridpoint(grid, 49.3634, -117.2361); // a launch near Nelson, BC
console.log(`${grid.kind} ${grid.ni}x${grid.nj} = ${values.length} points`);
console.log(site);
console.log(`2 m temperature: ${(values[site.index] - 273.15).toFixed(2)} C`);

The JPEG 2000 inside ECCC messages is decoded by @azohra/meteo.j2k, the production codec behind the j2k-node seam; it also installs on its own.

Forecast engine contributor

Read Forecast architecture before an internal module. Provider facts are verified and recorded in the living feed reference before a builder consumes them.

Technical learner

Start with Reading a Meteogram. The figures render from the repository’s synthetic scenario corpus, whose own document explains how each recipe isolates one relationship. The logbook records how derivations and visual conventions were established.