@dangahagan/weather-mcp 1.18.0 → 1.19.0

package/README.md

@@ -3,7 +3,7 @@
 [![npm version](https://badge.fury.io/js/@dangahagan%2Fweather-mcp.svg)](https://www.npmjs.com/package/@dangahagan/weather-mcp)
 [![MCP Registry](https://img.shields.io/badge/MCP-Registry-blue)](https://registry.modelcontextprotocol.io/v0/servers?search=io.github.dgahagan/weather-mcp)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
-[![Tests](https://img.shields.io/badge/tests-1%2C675%20passing-brightgreen)](./docs/testing/TEST_SUITE_README.md)
+[![Tests](https://img.shields.io/badge/tests-1%2C812%20passing-brightgreen)](./docs/testing/TEST_SUITE_README.md)
 [![Node](https://img.shields.io/badge/node-%3E%3D18-339933?logo=node.js&logoColor=white)](https://nodejs.org)
 
 **Give your AI assistant real weather data — 17 tools, zero API keys, zero signup, zero cost.**
@@ -35,8 +35,11 @@ Then just ask:
 > *"Are there wildfires within 50 miles of my cabin?"*
 > *"Will there be a full moon this weekend?"*
 > *"Is this a record high for today?"*
+> *"How bad is the pollen in Berlin today?"*
 > *"What was the weather in Paris on June 6, 1944?"*
 
+👉 **[See it in action](./examples/)** — real prompts like these with the answers they produced, and the raw server output behind them.
+
 📦 Listed in the [Official MCP Registry](https://registry.modelcontextprotocol.io/v0/servers?search=io.github.dgahagan/weather-mcp) as `io.github.dgahagan/weather-mcp`.
 
 ## Why this server?
@@ -47,7 +50,7 @@ Choose this one if you want:
 
 - **Genuinely free** — every data source is a free public API. No trial that expires, no credit card, no rate-limited "free tier" bait.
 - **No API keys** — install to first forecast in under a minute. Nothing to configure, nothing to leak into a repo.
-- **Fully open source** — MIT licensed, readable TypeScript, 1,675 tests. Audit it, fork it, fix it.
+- **Fully open source** — MIT licensed, readable TypeScript, 1,812 tests. Audit it, fork it, fix it.
 - **Privacy-respecting** — your queries go directly from your machine to public weather APIs. No middleman server, no telemetry.
 - **Breadth** — 17 tools covering weather, safety hazards (lightning, floods, wildfires), marine conditions, air quality, and historical data back to 1940. Most weather MCPs stop at forecasts.
 
@@ -60,17 +63,17 @@ All 17 tools, documented in detail in **[docs/TOOLS.md](./docs/TOOLS.md)**:
 | Tool | What it does | Coverage |
 |------|-------------|----------|
 | `get_forecast` | Daily/hourly forecasts up to 16 days by coordinates, saved location, or city name; sunrise/sunset, UV, precipitation probability, optional climate-normals comparison, optional moon phase & twilight almanac | 🌍 Global |
-| `get_current_conditions` | Current weather: temperature, wind, humidity, pressure; NOAA station observations in the US (plus heat index/wind chill, snow depth, optional fire-weather indices), Open-Meteo model data elsewhere, or real airport station observations worldwide with `source="metar"` | 🌍 Global |
-| `get_alerts` | Active watches, warnings, and advisories sorted by severity | 🇺🇸 US |
+| `get_current_conditions` | Current weather: temperature, wind, humidity, pressure; NOAA station observations in the US (plus heat index/wind chill, snow depth, optional fire-weather indices), Open-Meteo model data elsewhere, or real airport station observations worldwide with `source="metar"`. Always states the observation's age, and automatically falls back to a fresher nearby station when the nearest one has gone dark | 🌍 Global |
+| `get_alerts` | Active watches, warnings, and advisories sorted by severity; official national warnings for the US (NOAA), Canada (ECCC), and 38 European countries (MeteoAlarm) | 🇺🇸 🇨🇦 🇪🇺 |
 | `get_historical_weather` | Hourly/daily observations from 1940 to present | 🌍 Global |
 | `get_weather_summary` | One-call overview combining current conditions, forecast, and alerts (optionally air quality and lightning) | 🌍 Global |
 | `search_location` | Geocode place names to coordinates ("Paris" → 48.85, 2.35) | 🌍 Global |
 | `get_air_quality` | AQI (US/European scales), pollutants, UV index, health guidance; current pollen levels for European locations; optional day-grouped forecast up to 7 days with per-day peak AQI and UV | 🌍 Global |
 | `get_marine_conditions` | Wave height, swell, ocean currents, Douglas Sea Scale — includes Great Lakes and major US bays; forecast up to 16 days | 🌍 Global |
-| `get_weather_imagery` | Precipitation radar (static or 2-hour animated loops) + GOES satellite imagery | 🌍 Global |
+| `get_weather_imagery` | Precipitation radar (static or 2-hour animated loops) + GOES satellite imagery; `composite: true` returns a finished radar map over a base map as an image | 🌍 Global |
 | `get_lightning_activity` | Real-time strike detection with 4-level proximity safety assessment | 🌍 Global |
 | `get_river_conditions` | US: NWPS gauge levels, flood stages, streamflow, rise/fall trends, forecast series. Elsewhere: GloFAS modeled discharge snapped to the nearest river channel, with ensemble forecast | 🌍 Global |
-| `get_wildfire_info` | Active fires, containment, size, proximity-based safety guidance | 🇺🇸 US |
+| `get_wildfire_info` | Active fires, containment, size, safety guidance from the nearest *uncontained* fire (fully contained fires are listed but don't drive danger levels) | 🇺🇸 US |
 | `check_service_status` | Health checks for all upstream APIs plus cache statistics | — |
 | `save_location` | Save places as aliases ("home", "cabin") with optional activity tags | — |
 | `list_saved_locations` | List all saved locations | — |
@@ -86,6 +89,7 @@ All 17 tools, documented in detail in **[docs/TOOLS.md](./docs/TOOLS.md)**:
 ## Feature highlights
 
 - **Smart source selection** — US queries use NOAA (detailed, includes forecaster narratives); everywhere else uses Open-Meteo. You never pick; it just works.
+- **International weather alerts** — `get_alerts` routes by country: NOAA in the US, Environment and Climate Change Canada alerts in Canada, and the official national warnings of 38 European countries via EUMETNET MeteoAlarm — shown unmodified, with the issuing service credited. Border cities like Toronto get the right country's alerts, not the nearest bounding box's.
 - **Real observations worldwide** — ask for what a station is *actually reporting* and `get_current_conditions` will read the nearest airport's METAR (`source="metar"`): a genuine instrument reading anywhere on earth, with the station, its distance, and the observation age always stated. Outside the US this is the difference between a measurement and a model estimate.
 - **Saved locations** — save "home", "work", or "cabin" once, then ask *"what's the weather at home?"* Locations persist in `~/.weather-mcp/locations.json` and can be tagged with activities ("boating", "skiing") so the AI highlights what matters to you.
 - **Climate context** — optional 30-year climate normals show how today compares: *"10°F warmer than normal for this date."* For US locations the normals also carry the record high/low for the date and the year it was set: *"is this a record high?"*
@@ -107,13 +111,19 @@ All free, all public, no authentication required:
 | [Open-Meteo](https://open-meteo.com/) | Global forecasts, historical data (1940+), air quality, marine, geocoding, climate normals | Global |
 | [NOAA NWPS](https://water.noaa.gov/) | River levels, streamflow, flood stages | US |
 | [RCC ACIS](https://www.rcc-acis.org/) | Daily record high/low temperatures | US |
+| [EUMETNET MeteoAlarm](https://meteoalarm.org/) | Official national weather warnings (38 European countries) | Europe |
+| [MSC GeoMet](https://api.weather.gc.ca/) | Environment and Climate Change Canada weather alerts | Canada |
 | [NIFC WFIGS](https://data-nifc.opendata.arcgis.com/) | Active wildfire perimeters and incidents | US |
 | [RainViewer](https://www.rainviewer.com/api.html) | Precipitation radar imagery | Global |
-| [NASA GIBS](https://www.earthdata.nasa.gov/engage/open-data-services-software/earthdata-developer-portal/gibs-api) | GOES GeoColor satellite imagery | Western Hemisphere |
+| [NASA GIBS](https://www.earthdata.nasa.gov/engage/open-data-services-software/earthdata-developer-portal/gibs-api) | GOES GeoColor satellite imagery; base map for composited radar | Western Hemisphere (satellite), Global (base map) |
 | [Blitzortung.org](https://www.blitzortung.org/) | Community lightning detection network | Global |
 
 Open-Meteo allows 10,000 requests/day for non-commercial use; caching keeps typical AI usage far below that. Please respect the upstream providers' fair-use terms.
 
+Composited radar maps (`get_weather_imagery` with `composite: true`) carry the acknowledgment NASA requests for GIBS imagery, alongside the RainViewer radar credit:
+
+> Imagery provided by services from NASA's Global Imagery Browse Services (GIBS), part of NASA's Earth Science Data and Information System (ESDIS).
+
 ## Installation
 
 **Recommended — npx (always latest, nothing to manage):**
@@ -254,10 +264,11 @@ Being honest about what free public data can and can't do:
 | Historical weather (1940+) | ✅ (>7 days old) | Station-level detail for last 7 days |
 | Air quality, marine, radar, lightning | ✅ | — |
 | Current conditions | ✅ (model data, or real station observations via `source="metar"`) | Station observations via NOAA (richer detail) |
-| Weather alerts | ❌ | ✅ |
+| Weather alerts | ✅ US, Canada, and 38 European countries | NWS zone-level precision; Europe is matched at country level |
 | River conditions | ✅ (GloFAS modeled discharge) | Gauge observations + official flood stages via NWPS |
 | Wildfires | ❌ | ✅ |
 
+- European alerts are matched at **country level** — the keyless MeteoAlarm feeds carry no region polygons, so warnings for a large country may not affect the requested point; the output says so. Canadian alerts use a real bbox query with polygon-backed features.
 - International current conditions default to **model-interpolated** values at the exact coordinates. `source="metar"` returns a **real instrument reading** instead — but from the nearest airport, which may be tens of km away and up to an hour old. The output always names the station, its distance and bearing, and the observation age, so the tradeoff is visible rather than assumed. METAR coverage follows airports, so remote land and open ocean have real gaps.
 - Historical data older than 7 days comes from reanalysis models (9–25km grid), not direct station observations, and trails real time by ~5 days.
 - Non-US river discharge is **modeled**, not observed, and has no official flood-stage thresholds — levels are shown relative to recent history and the forecast ensemble. The ~5km model grid means the reported channel may be a few km from the requested point; the output says so when it is.
@@ -270,7 +281,7 @@ Being honest about what free public data can and can't do:
 ```bash
 npm run build          # Compile TypeScript
 npm run dev            # Run in development mode
-npm test               # Run all 1,675 tests
+npm test               # Run all 1,812 tests
 npm run test:coverage  # Coverage report
 npm run audit          # Dependency vulnerability scan
 ```
@@ -294,6 +305,7 @@ To report a vulnerability, see [SECURITY.md](./SECURITY.md).
 
 ## Documentation
 
+- **[Examples](./examples/)** — realistic sessions in cities around the world: prompt → assistant answer → verbatim server output
 - **[Tool Reference](./docs/TOOLS.md)** — all 17 tools: parameters, examples, sample output
 - **[Client Setup](./docs/CLIENT_SETUP.md)** — step-by-step for 8 MCP clients
 - **[Error Handling](./docs/ERROR_HANDLING.md)** — how failures are reported

package/dist/config/cache.d.ts

@@ -25,6 +25,9 @@ export declare const CacheConfig: {
         readonly records: number;
         readonly recordsStation: number;
         readonly metarObservations: number;
+        readonly basemapTiles: number;
+        readonly compositeImage: number;
+        readonly reverseCountry: number;
     };
 };
 /**

package/dist/config/cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/config/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkDH,eAAO,MAAM,WAAW;aAEtB,OAAO;aAIP,OAAO;aAIP,YAAY;aAGZ,GAAG;iBAGD,eAAe;iBAIf,SAAS;iBAIT,QAAQ;iBAIR,QAAQ;iBAIR,iBAAiB;iBAIjB,MAAM;iBAIN,gBAAgB;iBAIhB,cAAc;iBAId,aAAa;iBAMb,cAAc;iBAMd,OAAO;iBAIP,cAAc;iBAMd,iBAAiB;;CAEX,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAYrE"}
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/config/cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAkDH,eAAO,MAAM,WAAW;aAEtB,OAAO;aAIP,OAAO;aAIP,YAAY;aAGZ,GAAG;iBAGD,eAAe;iBAIf,SAAS;iBAIT,QAAQ;iBAIR,QAAQ;iBAIR,iBAAiB;iBAIjB,MAAM;iBAIN,gBAAgB;iBAIhB,cAAc;iBAId,aAAa;iBAMb,cAAc;iBAMd,OAAO;iBAIP,cAAc;iBAMd,iBAAiB;iBAQjB,YAAY;iBAQZ,cAAc;iBAKd,cAAc;;CAER,CAAC;AAEX;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,CAYrE"}

package/dist/config/cache.js

@@ -106,6 +106,24 @@ export const CacheConfig = {
         // burst of calls into one fetch without ever serving a response across a
         // reporting cycle.
         metarObservations: 10 * MINUTE,
+        // NASA GIBS basemap tiles (OSM_Land_Water_Map, Reference_Features_15m),
+        // cached individually by raw tile buffer. These are near-static
+        // reference layers — land/water boundaries and coastline/border outlines
+        // don't move on any timescale that matters to a weather query — so cache
+        // aggressively; 24h balances that staticness against not holding stale
+        // tiles indefinitely if a layer is ever revised upstream.
+        basemapTiles: 24 * HOUR,
+        // Composited radar-on-basemap output, keyed on frame path + tile +
+        // marker pixel. Radar frames are immutable once published under their
+        // timestamp, so this isn't about staleness — it's about not re-fetching
+        // and re-compositing on every call within a feed cycle; RainViewer's
+        // nowcast cadence is ~10 minutes, so a repeat call inside that window is
+        // still looking at the same latest frame.
+        compositeImage: 10 * MINUTE,
+        // Nominatim reverse geocoding — country resolution only (zoom=3). Keyed
+        // on coordinates rounded to ~1.1km; countries don't move, so once
+        // resolved (including a "no country" open-ocean result) it's permanent.
+        reverseCountry: Infinity,
     },
 };
 /**

package/dist/config/cache.js.map

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

package/dist/handlers/alertsHandler.d.ts

@@ -1,13 +1,32 @@
 /**
- * Handler for get_alerts tool
+ * Handler for get_alerts tool.
+ *
+ * Routed by country (see docs/plans/international-alerts-plan.md D1):
+ *   US → NOAA (the original path, byte-identical output),
+ *   Canada → MSC GeoMet (Environment and Climate Change Canada),
+ *   MeteoAlarm member countries → the country's MeteoAlarm feed,
+ *   elsewhere → a clean not-covered message.
+ *
+ * Country resolution order: a `country_code` already carried by the resolved
+ * location (saved location or geocoded city_name), else a cached
+ * country-level Nominatim reverse lookup, else the `isInUS` bounding-box
+ * fallback (which preserves NOAA marine alerts for US coastal waters, where
+ * reverse geocoding returns no country). The reverse answer wins over
+ * `isInUS` — the CONUS box deliberately overruns into Canada (Toronto,
+ * Vancouver), and alert authority is jurisdictional.
  */
 import { NOAAService } from '../services/noaa.js';
 import { LocationStore } from '../services/locationStore.js';
 import { GeocodingService } from '../services/geocoding.js';
-export declare function handleGetAlerts(args: unknown, noaaService: NOAAService, locationStore: LocationStore, geocodingService: GeocodingService): Promise<{
+import { MeteoAlarmService } from '../services/meteoalarm.js';
+import { GeoMetService } from '../services/geomet.js';
+import { NominatimService } from '../services/nominatim.js';
+type HandlerResult = {
     content: Array<{
         type: string;
         text: string;
     }>;
-}>;
+};
+export declare function handleGetAlerts(args: unknown, noaaService: NOAAService, locationStore: LocationStore, geocodingService: GeocodingService, meteoAlarmService?: MeteoAlarmService, geoMetService?: GeoMetService, nominatimService?: NominatimService): Promise<HandlerResult>;
+export {};
 //# sourceMappingURL=alertsHandler.d.ts.map

package/dist/handlers/alertsHandler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"alertsHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/alertsHandler.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAc5D,wBAAsB,eAAe,CACnC,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,gBAAgB,EAAE,gBAAgB,GACjC,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC,CA8H7D"}
+{"version":3,"file":"alertsHandler.d.ts","sourceRoot":"","sources":["../../src/handlers/alertsHandler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAC7D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EACL,iBAAiB,EAGlB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAuB5D,KAAK,aAAa,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAAE,CAAC;AAMxE,wBAAsB,eAAe,CACnC,IAAI,EAAE,OAAO,EACb,WAAW,EAAE,WAAW,EACxB,aAAa,EAAE,aAAa,EAC5B,gBAAgB,EAAE,gBAAgB,EAClC,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,aAAa,CAAC,EAAE,aAAa,EAC7B,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,aAAa,CAAC,CAsDxB"}

package/dist/handlers/alertsHandler.js

@@ -1,16 +1,81 @@
 /**
- * Handler for get_alerts tool
+ * Handler for get_alerts tool.
+ *
+ * Routed by country (see docs/plans/international-alerts-plan.md D1):
+ *   US → NOAA (the original path, byte-identical output),
+ *   Canada → MSC GeoMet (Environment and Climate Change Canada),
+ *   MeteoAlarm member countries → the country's MeteoAlarm feed,
+ *   elsewhere → a clean not-covered message.
+ *
+ * Country resolution order: a `country_code` already carried by the resolved
+ * location (saved location or geocoded city_name), else a cached
+ * country-level Nominatim reverse lookup, else the `isInUS` bounding-box
+ * fallback (which preserves NOAA marine alerts for US coastal waters, where
+ * reverse geocoding returns no country). The reverse answer wins over
+ * `isInUS` — the CONUS box deliberately overruns into Canada (Toronto,
+ * Vancouver), and alert authority is jurisdictional.
  */
+import { COUNTRY_FEEDS, isMeteoAlarmCountry } from '../services/meteoalarm.js';
 import { resolveLocationAsync, prependLocationLine } from '../utils/locationResolver.js';
 import { validateOptionalBoolean, validateDetail } from '../utils/validation.js';
 import { formatInTimezone, guessTimezoneFromCoords } from '../utils/timezone.js';
-export async function handleGetAlerts(args, noaaService, locationStore, geocodingService) {
+import { isInUS } from '../utils/geography.js';
+import { logger } from '../utils/logger.js';
+/** Display caps for the international renderers (country feeds routinely carry 50+ warnings). */
+const STANDARD_DISPLAY_CAP = 10;
+const FULL_DISPLAY_CAP = 25;
+export async function handleGetAlerts(args, noaaService, locationStore, geocodingService, meteoAlarmService, geoMetService, nominatimService) {
     // Resolve location from coordinates, a saved location name, or a geocoded city name
     const resolved = await resolveLocationAsync(args, locationStore, geocodingService);
     const { latitude, longitude } = resolved;
     const active_only = validateOptionalBoolean(args?.active_only, 'active_only', true);
     // Output verbosity: 'full' includes the complete NWS description text.
     const detail = validateDetail(args?.detail);
+    // --- Country routing (D1) ---
+    // 1. A country the resolution path already knows (saved location /
+    //    geocoded city). Sources vary in casing; normalize to lowercase once.
+    let countryCode = resolved.country_code
+        ? resolved.country_code.toLowerCase()
+        : null;
+    // 2. Coordinates only: cached country-level reverse lookup. A missing
+    //    service (test harnesses) skips this silently; only a *failed* lookup
+    //    earns the one-line fallback note.
+    let reverseLookupFailed = false;
+    if (!countryCode && nominatimService) {
+        try {
+            countryCode = await nominatimService.reverseCountry(latitude, longitude);
+        }
+        catch (error) {
+            reverseLookupFailed = true;
+            logger.warn('Reverse country lookup failed; falling back to coordinate routing', {
+                error: error instanceof Error ? error.message : 'unknown'
+            });
+        }
+    }
+    // 3. Route. The reverse answer wins over isInUS; "no country" (open
+    //    water, absent service, or a failed lookup) falls back to the
+    //    bounding boxes so US coastal waters keep their NOAA marine alerts.
+    if (countryCode === 'us') {
+        return handleNoaaAlerts(resolved, noaaService, active_only, detail);
+    }
+    if (countryCode === 'ca' && geoMetService) {
+        return handleGeoMetAlerts(resolved, geoMetService, active_only, detail);
+    }
+    if (countryCode && isMeteoAlarmCountry(countryCode) && meteoAlarmService) {
+        return handleMeteoAlarmAlerts(resolved, meteoAlarmService, countryCode, active_only, detail);
+    }
+    if (!countryCode && isInUS(latitude, longitude)) {
+        return handleNoaaAlerts(resolved, noaaService, active_only, detail);
+    }
+    return notCoveredResult(resolved, countryCode, reverseLookupFailed);
+}
+/**
+ * The original US path — prologue (station timezone side-call) and renderer
+ * preserved verbatim so US output stays byte-identical
+ * (locked by tests/unit/alerts-detail.test.ts passing unedited).
+ */
+async function handleNoaaAlerts(resolved, noaaService, active_only, detail) {
+    const { latitude, longitude } = resolved;
     // Get timezone for proper time formatting
     let timezone = guessTimezoneFromCoords(latitude, longitude); // fallback
     try {
@@ -107,4 +172,312 @@ export async function handleGetAlerts(args, noaaService, locationStore, geocodin
         ]
     }, resolved);
 }
+/**
+ * Render a source-published ISO 8601 timestamp in the offset it was
+ * published with (`2026-08-13T09:21:00+02:00` → `2026-08-13 09:21 (+02:00)`)
+ * — the licence terms favour times as issued, and it skips the NOAA
+ * station-timezone side-call entirely. Unparseable strings render raw.
+ */
+function formatPublishedTime(iso) {
+    if (!iso) {
+        return undefined;
+    }
+    const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}:\d{2})(?::\d{2}(?:\.\d+)?)?(Z|[+-]\d{2}:?\d{2})?$/.exec(iso);
+    if (!match) {
+        return iso;
+    }
+    const [, date, time, offset] = match;
+    const zone = !offset || offset === 'Z' ? 'UTC' : offset;
+    return `${date} ${time} (${zone})`;
+}
+/** Human-readable region name from an ISO code ("au" → "Australia"), falling back to the uppercased code. */
+function regionDisplayName(countryCode) {
+    try {
+        const name = new Intl.DisplayNames(['en'], { type: 'region' }).of(countryCode.toUpperCase());
+        return name ?? countryCode.toUpperCase();
+    }
+    catch {
+        return countryCode.toUpperCase();
+    }
+}
+/** Shared severity rank/emoji conventions (the NOAA ordering, reused where a source supplies CAP severity). */
+const CAP_SEVERITY_ORDER = {
+    'Extreme': 0,
+    'Severe': 1,
+    'Moderate': 2,
+    'Minor': 3,
+    'Unknown': 4
+};
+function capSeverityRank(severity) {
+    return CAP_SEVERITY_ORDER[severity ?? 'Unknown'] ?? 4;
+}
+function capSeverityEmoji(severity) {
+    return severity === 'Extreme' ? '🔴' :
+        severity === 'Severe' ? '🟠' :
+            severity === 'Moderate' ? '🟡' :
+                severity === 'Minor' ? '🔵' : '⚪';
+}
+function capitalize(value) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+/** "…and N more warnings, mostly Minor" remainder line for capped lists. */
+function remainderNote(remainder) {
+    const counts = new Map();
+    for (const warning of remainder) {
+        const severity = warning.severity ?? 'Unknown';
+        counts.set(severity, (counts.get(severity) ?? 0) + 1);
+    }
+    let top = 'Unknown';
+    let topCount = -1;
+    for (const [severity, count] of counts) {
+        if (count > topCount) {
+            top = severity;
+            topCount = count;
+        }
+    }
+    const plural = remainder.length > 1 ? 's' : '';
+    return `*…and ${remainder.length} more warning${plural}, mostly ${top}. Use detail="full" to see more.*\n\n`;
+}
+/**
+ * MeteoAlarm (Europe) renderer — CAP-shaped, so visually close to the NOAA
+ * blocks. Licence terms honoured here: CAP text verbatim, the issue time
+ * always shown, EUMETNET – MeteoAlarm + national service attribution.
+ */
+async function handleMeteoAlarmAlerts(resolved, meteoAlarmService, countryCode, active_only, detail) {
+    const feed = COUNTRY_FEEDS[countryCode];
+    const countryName = feed?.name ?? regionDisplayName(countryCode);
+    const warnings = await meteoAlarmService.getWarnings(countryCode);
+    let output = `# Weather Alerts — ${countryName}\n\n`;
+    output += `**Location:** ${resolved.latitude.toFixed(4)}, ${resolved.longitude.toFixed(4)}\n`;
+    output += `**Coverage note:** European alerts are matched at country level — regional filtering is not yet available. Warnings below may not affect ${resolved.location_name ?? 'your exact location'}.\n\n`;
+    if (!active_only) {
+        output += `*Note: historical alerts are not available for this region — showing current warnings only.*\n\n`;
+    }
+    if (warnings.length === 0) {
+        output += `✅ **No active weather alerts for ${countryName}.**\n\n`;
+    }
+    else {
+        output += `⚠️ **${warnings.length} active warning${warnings.length > 1 ? 's' : ''} for ${countryName}**\n\n`;
+        // Sort by CAP severity (the NOAA Extreme→Unknown order), then by expiry.
+        const sorted = [...warnings].sort((a, b) => {
+            const bySeverity = capSeverityRank(a.severity) - capSeverityRank(b.severity);
+            if (bySeverity !== 0) {
+                return bySeverity;
+            }
+            const aExpires = a.expires ? new Date(a.expires).getTime() : Infinity;
+            const bExpires = b.expires ? new Date(b.expires).getTime() : Infinity;
+            return aExpires - bExpires;
+        });
+        if (detail === 'summary') {
+            // Counts by severity and colour only.
+            const bySeverity = new Map();
+            const byColour = new Map();
+            for (const warning of sorted) {
+                const severity = warning.severity ?? 'Unknown';
+                bySeverity.set(severity, (bySeverity.get(severity) ?? 0) + 1);
+                if (warning.colour) {
+                    byColour.set(warning.colour, (byColour.get(warning.colour) ?? 0) + 1);
+                }
+            }
+            output += `**By severity:** ${[...bySeverity.entries()]
+                .map(([severity, count]) => `${severity}: ${count}`)
+                .join(' | ')}\n`;
+            if (byColour.size > 0) {
+                output += `**By colour:** ${[...byColour.entries()]
+                    .map(([colour, count]) => `${capitalize(colour)}: ${count}`)
+                    .join(' | ')}\n`;
+            }
+            output += `\n*Counts only at detail="summary". Use detail="standard" or detail="full" for the warnings themselves.*\n\n`;
+        }
+        else {
+            const cap = detail === 'full' ? FULL_DISPLAY_CAP : STANDARD_DISPLAY_CAP;
+            const shown = sorted.slice(0, cap);
+            const remainder = sorted.slice(cap);
+            for (const warning of shown) {
+                const colourSuffix = warning.colour
+                    ? ` — ${capitalize(warning.colour)}${warning.severity ? ` (${warning.severity})` : ''}`
+                    : '';
+                output += `${capSeverityEmoji(warning.severity)} **${warning.event ?? 'Weather warning'}**${colourSuffix}\n`;
+                output += `---\n`;
+                if (warning.headline) {
+                    output += `**Headline:** ${warning.headline}\n`;
+                }
+                output += `**Severity:** ${warning.severity ?? 'Unknown'} | **Urgency:** ${warning.urgency ?? 'Unknown'} | **Certainty:** ${warning.certainty ?? 'Unknown'}\n`;
+                if (warning.areaDesc.length > 0) {
+                    output += `**Area:** ${warning.areaDesc.join('; ')}\n`;
+                }
+                // The issue time is always shown — a MeteoAlarm licence term.
+                output += `**Issued:** ${formatPublishedTime(warning.sent) ?? 'not stated'}\n`;
+                if (warning.onset) {
+                    output += `**Onset:** ${formatPublishedTime(warning.onset)}\n`;
+                }
+                if (warning.expires) {
+                    output += `**Expires:** ${formatPublishedTime(warning.expires)}\n`;
+                }
+                // CAP text renders verbatim (licence term): description at full only,
+                // instruction at standard+full — the NOAA detail contract.
+                if (detail === 'full' && warning.description) {
+                    output += `\n**Description:**\n${warning.description}\n`;
+                }
+                if (warning.instruction) {
+                    output += `\n**Instructions:**\n${warning.instruction}\n`;
+                }
+                if (warning.senderName) {
+                    output += `\n**Sender:** ${warning.senderName}\n`;
+                }
+                output += `\n`;
+            }
+            if (remainder.length > 0) {
+                output += remainderNote(remainder);
+            }
+            if (detail !== 'full') {
+                output += `*Showing standard detail. Use detail="full" for complete warning descriptions.*\n\n`;
+            }
+        }
+    }
+    const serviceSuffix = feed?.service ? ` (national warnings: ${feed.service})` : '';
+    output += `---\n`;
+    output += `*Data source: EUMETNET – MeteoAlarm${serviceSuffix}. Alerts shown unmodified as issued; times as published.*\n`;
+    return prependLocationLine({
+        content: [{ type: 'text', text: output }]
+    }, resolved);
+}
+/** GeoMet alert_type display rank: warning > watch > advisory > statement. */
+const GEOMET_TYPE_ORDER = {
+    'warning': 0,
+    'watch': 1,
+    'advisory': 2,
+    'statement': 3
+};
+function geoMetTypeRank(alertType) {
+    return GEOMET_TYPE_ORDER[(alertType ?? '').toLowerCase()] ?? 4;
+}
+function geoMetTypeEmoji(alertType) {
+    switch ((alertType ?? '').toLowerCase()) {
+        case 'warning':
+            return '🔶';
+        case 'watch':
+            return '🟡';
+        case 'advisory':
+            return '🔵';
+        default:
+            return '⚪';
+    }
+}
+/**
+ * MSC GeoMet (Canada) renderer — not CAP-shaped; renders what ECCC provides
+ * and invents nothing (no severity/urgency/certainty lines). `alert_text_en`
+ * renders verbatim — an ECCC licence term.
+ */
+async function handleGeoMetAlerts(resolved, geoMetService, active_only, detail) {
+    const alerts = await geoMetService.getAlerts(resolved.latitude, resolved.longitude);
+    let output = `# Weather Alerts — Canada\n\n`;
+    output += `**Location:** ${resolved.latitude.toFixed(4)}, ${resolved.longitude.toFixed(4)}\n\n`;
+    if (!active_only) {
+        output += `*Note: historical alerts are not available for this region — showing current alerts only.*\n\n`;
+    }
+    if (alerts.length === 0) {
+        output += `✅ **No active weather alerts for this area.**\n\n`;
+    }
+    else {
+        output += `⚠️ **${alerts.length} active alert${alerts.length > 1 ? 's' : ''} found**\n\n`;
+        // Sort by alert_type rank (warning > watch > advisory > statement), then recency.
+        const sorted = [...alerts].sort((a, b) => {
+            const byType = geoMetTypeRank(a.properties.alert_type) - geoMetTypeRank(b.properties.alert_type);
+            if (byType !== 0) {
+                return byType;
+            }
+            const aPublished = a.properties.publication_datetime
+                ? new Date(a.properties.publication_datetime).getTime()
+                : 0;
+            const bPublished = b.properties.publication_datetime
+                ? new Date(b.properties.publication_datetime).getTime()
+                : 0;
+            return bPublished - aPublished;
+        });
+        if (detail === 'summary') {
+            const byType = new Map();
+            for (const alert of sorted) {
+                const alertType = (alert.properties.alert_type ?? 'other').toLowerCase();
+                byType.set(alertType, (byType.get(alertType) ?? 0) + 1);
+            }
+            output += `**By type:** ${[...byType.entries()]
+                .map(([alertType, count]) => `${capitalize(alertType)}: ${count}`)
+                .join(' | ')}\n`;
+            output += `\n*Counts only at detail="summary". Use detail="standard" or detail="full" for the alerts themselves.*\n\n`;
+        }
+        else {
+            const cap = detail === 'full' ? FULL_DISPLAY_CAP : STANDARD_DISPLAY_CAP;
+            const shown = sorted.slice(0, cap);
+            const remainder = sorted.length - shown.length;
+            for (const alert of shown) {
+                const props = alert.properties;
+                const name = props.alert_name_en ?? props.alert_short_name_en ?? 'Weather alert';
+                const typeSuffix = props.alert_type ? ` (${props.alert_type})` : '';
+                output += `${geoMetTypeEmoji(props.alert_type)} **${name}**${typeSuffix}\n`;
+                output += `---\n`;
+                if (props.feature_name_en) {
+                    output += `**Area:** ${props.feature_name_en}${props.province ? `, ${props.province}` : ''}\n`;
+                }
+                const riskParts = [];
+                if (props.risk_colour_en) {
+                    riskParts.push(`**Risk:** ${props.risk_colour_en}`);
+                }
+                if (props.confidence_en) {
+                    riskParts.push(`**Confidence:** ${props.confidence_en}`);
+                }
+                if (riskParts.length > 0) {
+                    output += `${riskParts.join(' | ')}\n`;
+                }
+                const timeParts = [];
+                const issued = formatPublishedTime(props.publication_datetime);
+                const ends = formatPublishedTime(props.event_end_datetime);
+                if (issued) {
+                    timeParts.push(`**Issued:** ${issued}`);
+                }
+                if (ends) {
+                    timeParts.push(`**Ends:** ${ends}`);
+                }
+                if (timeParts.length > 0) {
+                    output += `${timeParts.join(' | ')}\n`;
+                }
+                // The alert body renders verbatim at standard and full (ECCC terms:
+                // content unaltered).
+                if (props.alert_text_en) {
+                    output += `\n${props.alert_text_en}\n`;
+                }
+                output += `\n`;
+            }
+            if (remainder > 0) {
+                output += `*…and ${remainder} more alert${remainder > 1 ? 's' : ''}. Use detail="full" to see more.*\n\n`;
+            }
+        }
+    }
+    output += `---\n`;
+    output += `*Data source: Environment and Climate Change Canada (MSC GeoMet). Alert content shown unaltered.*\n`;
+    return prependLocationLine({
+        content: [{ type: 'text', text: output }]
+    }, resolved);
+}
+/**
+ * The clean not-covered message (D1): names the region, states the current
+ * coverage, and never surfaces a wrong-country upstream error. The one-line
+ * note appears only when a real reverse lookup *failed* — an absent lookup
+ * service falls back silently.
+ */
+function notCoveredResult(resolved, countryCode, reverseLookupFailed) {
+    const region = countryCode ? regionDisplayName(countryCode) : 'this location';
+    let output = `# Weather Alerts\n\n`;
+    output += `**Location:** ${resolved.latitude.toFixed(4)}, ${resolved.longitude.toFixed(4)}\n\n`;
+    output += `Weather alerts are not yet available for ${region}.\n\n`;
+    output += `Current alert coverage: the United States (NOAA National Weather Service), `;
+    output += `Canada (Environment and Climate Change Canada), and the European MeteoAlarm `;
+    output += `member countries (matched at country level).\n`;
+    if (reverseLookupFailed) {
+        output += `\n*Note: the country lookup service was unavailable, so routing fell back to coordinate checks.*\n`;
+    }
+    return prependLocationLine({
+        content: [{ type: 'text', text: output }]
+    }, resolved);
+}
 //# sourceMappingURL=alertsHandler.js.map