Fix window consistency, transport filter for polygons, add URL state + coverage area

Fixes:
- Longer windows now always include stations from shorter windows.
  getStationMessageCounts scans all windows up to the requested one,
  ensuring a station visible in 5m also appears in 1h/1mo.
- Polygon mode now respects the transport filter (All/Aircraft/Marine).
  Marine source types (aiscatcher, ais) are filtered out in Aircraft
  mode and vice versa.

New features:
- URL state sync: view state, mode, time window, and transport filter
  are encoded in the URL hash. Share links like /#mode=hexgrid&window=1h
  &lat=51.50&lon=-0.12&zoom=6.0
- Coverage area estimation: stats bar shows approximate total coverage
  area in km² (derived from H3 res-3 cell count × 12,400 km²/cell).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: kevinelliott

map/src/components/controls/StatsBar.tsx

@@ -64,7 +64,7 @@ export default function StatsBar() {
       {/* Main stats */}
       <div className="flex items-center justify-between">
         <Stat label="Stations" value={stations.length} />
-        <Stat label="H3 Cells" value={hexData.length} />
+        <Stat label="Coverage" value={formatArea(stats?.coverageAreaKm2 ?? 0)} />
         <Stat label="Messages" value={formatCount(totalMessages)} />
         <Stat label="msg/s" value={stats?.messagesPerSecond ?? 0} decimals={1} />
       </div>
@@ -146,3 +146,9 @@ function formatCount(n: number): string {
   if (n >= 1_000) return `${(n / 1_000).toFixed(1)}k`;
   return String(n);
 }
+
+function formatArea(km2: number): string {
+  if (km2 >= 1_000_000) return `${(km2 / 1_000_000).toFixed(1)}M km²`;
+  if (km2 >= 1_000) return `${(km2 / 1_000).toFixed(0)}k km²`;
+  return `${km2} km²`;
+}

map/src/components/map/CoverageMap.tsx

@@ -15,6 +15,7 @@ import ConnectionBanner from '@/components/controls/ConnectionBanner';
 import StationPopup from '@/components/station/StationPopup';
 import HexPopup from '@/components/map/HexPopup';
 import PolygonPopup from '@/components/map/PolygonPopup';
+import { useUrlState } from '@/lib/hooks/use-url-state';
 import type { CoverageHex, CoveragePolygon } from '@/lib/types/coverage';
 
 const POLL_INTERVAL = 10_000;
@@ -30,6 +31,8 @@ function DeckGLOverlay(props: any) {
 }
 
 export default function CoverageMap() {
+  useUrlState();
+
   const [viewState, setLocalViewState] = useState({
     longitude: MAP_CONFIG.initialViewState.longitude as number,
     latitude: MAP_CONFIG.initialViewState.latitude as number,
@@ -105,9 +108,16 @@ export default function CoverageMap() {
   }, [timeWindow, h3Resolution, transportFilter, setHexData, setRefreshing]);
 
   const fetchPolygons = useCallback(async () => {
-    const withPosition = stations.filter(
-      (s) => s.latitude !== 0 && s.longitude !== 0 && s.messagesWithPosition > 0
-    ).slice(0, 30);
+    const MARINE_TYPES = new Set(['aiscatcher', 'ais']);
+
+    const withPosition = stations.filter((s) => {
+      if (s.latitude === 0 && s.longitude === 0) return false;
+      if (s.messagesWithPosition <= 0) return false;
+      // Transport filter
+      if (transportFilter === 'aircraft' && MARINE_TYPES.has(s.sourceType)) return false;
+      if (transportFilter === 'marine' && !MARINE_TYPES.has(s.sourceType)) return false;
+      return true;
+    }).slice(0, 30);
 
     const polygons: CoveragePolygon[] = [];
 
@@ -135,7 +145,7 @@ export default function CoverageMap() {
     );
 
     setPolygonData(polygons);
-  }, [stations, timeWindow, setPolygonData]);
+  }, [stations, timeWindow, transportFilter, setPolygonData]);
 
   const fetchStations = useCallback(async () => {
     try {

map/src/lib/hooks/use-url-state.ts

@@ -0,0 +1,74 @@
+'use client';
+
+import { useEffect, useRef } from 'react';
+import { useUIStore } from '../stores/ui-store';
+import { TIME_WINDOWS, type TimeWindowKey } from '../constants/time-windows';
+
+/**
+ * Sync UI state to/from URL hash parameters.
+ * Enables sharing links like: /map#mode=hexgrid&window=1h&lat=51.5&lon=-0.1&zoom=8
+ */
+export function useUrlState() {
+  const mode = useUIStore((s) => s.mode);
+  const timeWindow = useUIStore((s) => s.timeWindow);
+  const transportFilter = useUIStore((s) => s.transportFilter);
+  const viewState = useUIStore((s) => s.viewState);
+  const setMode = useUIStore((s) => s.setMode);
+  const setTimeWindow = useUIStore((s) => s.setTimeWindow);
+  const setTransportFilter = useUIStore((s) => s.setTransportFilter);
+  const flyTo = useUIStore((s) => s.flyTo);
+
+  const initialized = useRef(false);
+
+  // On mount: read from URL hash
+  useEffect(() => {
+    if (initialized.current) return;
+    initialized.current = true;
+
+    const hash = window.location.hash.slice(1);
+    if (!hash) return;
+
+    const params = new URLSearchParams(hash);
+
+    const m = params.get('mode');
+    if (m === 'hexgrid' || m === 'polygon') setMode(m);
+
+    const w = params.get('window');
+    if (w && TIME_WINDOWS.some((tw) => tw.key === w)) setTimeWindow(w as TimeWindowKey);
+
+    const t = params.get('transport');
+    if (t === 'all' || t === 'aircraft' || t === 'marine') setTransportFilter(t);
+
+    const lat = params.get('lat');
+    const lon = params.get('lon');
+    const zoom = params.get('zoom');
+    if (lat && lon) {
+      flyTo({
+        latitude: parseFloat(lat),
+        longitude: parseFloat(lon),
+        zoom: zoom ? parseFloat(zoom) : 6,
+      });
+    }
+  }, [setMode, setTimeWindow, setTransportFilter, flyTo]);
+
+  // Debounced write to URL hash
+  const writeTimer = useRef<ReturnType<typeof setTimeout>>(undefined);
+
+  useEffect(() => {
+    clearTimeout(writeTimer.current);
+    writeTimer.current = setTimeout(() => {
+      const params = new URLSearchParams();
+      params.set('mode', mode);
+      params.set('window', timeWindow);
+      if (transportFilter !== 'all') params.set('transport', transportFilter);
+      params.set('lat', viewState.latitude.toFixed(2));
+      params.set('lon', viewState.longitude.toFixed(2));
+      params.set('zoom', viewState.zoom.toFixed(1));
+
+      const newHash = params.toString();
+      if (window.location.hash.slice(1) !== newHash) {
+        history.replaceState(null, '', `#${newHash}`);
+      }
+    }, 1000);
+  }, [mode, timeWindow, transportFilter, viewState]);
+}

map/src/lib/types/coverage.ts

@@ -47,6 +47,7 @@ export interface CoverageStats {
   messagesPerSecond: number;
   activeStations: number;
   totalCells: Record<string, number>;
+  coverageAreaKm2: number;
   natsConnected: boolean;
 }
 

service/src/aggregation/coverage-store.ts

@@ -280,18 +280,31 @@ export class CoverageStore {
    */
   getStationMessageCounts(windowName: string): Map<number, { messageCount: number; maxDistance: number }> {
     const stationCounts = new Map<number, { messageCount: number; maxDistance: number }>();
+    const wi = WINDOW_CONFIGS.findIndex(c => c.name === windowName);
+    if (wi === -1) return stationCounts;
 
-    // Primary source: H3 sliding windows (tracks station IDs per cell)
     const ri = H3_RESOLUTION_CONFIGS.findIndex(c => c.resolution === 3);
-    const wi = WINDOW_CONFIGS.findIndex(c => c.name === windowName);
-    if (ri !== -1 && wi !== -1) {
-      const window = this.windows[ri][wi];
+
+    // Scan the requested window AND all shorter windows.
+    // A station visible in a shorter window must appear in all longer windows.
+    // Use the requested window's counts as the primary, but ensure stations
+    // from shorter windows are included.
+    const windowsToCheck = ri !== -1
+      ? Array.from({ length: wi + 1 }, (_, i) => i)
+      : [];
+
+    for (const checkWi of windowsToCheck) {
+      if (ri === -1) continue;
+      const window = this.windows[ri][checkWi];
       const aggregated = window.getAggregated();
       for (const [, cell] of aggregated) {
         for (const stationId of cell.stationIds) {
           const existing = stationCounts.get(stationId);
           if (existing) {
-            existing.messageCount += cell.messageCount;
+            // Use the max values (longer window should have more data)
+            if (checkWi === wi) {
+              existing.messageCount += cell.messageCount;
+            }
             existing.maxDistance = Math.max(existing.maxDistance, cell.maxDistance);
           } else {
             stationCounts.set(stationId, {
@@ -303,12 +316,11 @@ export class CoverageStore {
       }
     }
 
-    // Fallback: station sliding windows (for data loaded from persistence
-    // where H3 cells may lack station IDs)
-    if (wi !== -1 && wi < this.stationWindows.length) {
-      const sw = this.stationWindows[wi];
+    // Also check station sliding windows (for persistence-loaded data)
+    for (let swi = 0; swi <= wi && swi < this.stationWindows.length; swi++) {
+      const sw = this.stationWindows[swi];
       for (const stationId of sw.activeStationIds()) {
-        if (stationCounts.has(stationId)) continue; // Already counted from H3
+        if (stationCounts.has(stationId)) continue;
         const cov = sw.getStationCoverage(stationId);
         if (cov && cov.totalMessages > 0) {
           stationCounts.set(stationId, {

service/src/api/routes/health.ts

@@ -43,10 +43,15 @@ healthRoutes.get('/stats', (c) => {
   const uptime = process.uptime();
   const mps = uptime > 0 ? Math.round(stats.eventsProcessed / uptime * 10) / 10 : 0;
 
+  // Estimate coverage area from H3 res-3 cells (each ~12,400 km²)
+  const res3Cells = stats.activeCells[3] ?? 0;
+  const coverageAreaKm2 = Math.round(res3Cells * 12400);
+
   return c.json({
     messagesPerSecond: mps,
     activeStations: stats.stationsTracked,
     totalCells: stats.activeCells,
+    coverageAreaKm2,
     natsConnected: nats.isConnected(),
   });
 });