Transport filter for polygons, stations, stats, and bearing sectors

Full transport filter support across the entire stack:
- Backend: station sliding windows now key data by stationId+transportType.
  getStationCoverage and getAllStationCoverage accept transportFilter
  to return only bearing sectors from matching transport types.
- Backend: /stations endpoint filters by transport type based on
  station source type (aiscatcher/ais → marine, rest → aircraft).
- Backend: /coverage/stations/:id accepts transport query param to
  filter polygon bearing sector data by transport type.
- Frontend: stations API call passes transport filter, so station
  list, stats, and coverage area all update with the filter.
- Frontend: polygon fetch passes transport filter to both station
  list filtering and polygon detail API calls.

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

Author: kevinelliott

map/src/components/map/CoverageMap.tsx

@@ -124,8 +124,10 @@ export default function CoverageMap() {
     await Promise.allSettled(
       withPosition.map(async (station) => {
         try {
+          const p = new URLSearchParams({ window: timeWindow });
+          if (transportFilter !== 'all') p.set('transport', transportFilter);
           const res = await fetch(
-            `${API_URL}/api/v1/coverage/stations/${station.id}?window=${timeWindow}`
+            `${API_URL}/api/v1/coverage/stations/${station.id}?${p}`
           );
           if (res.ok) {
             const data = await res.json();
@@ -149,13 +151,15 @@ export default function CoverageMap() {
 
   const fetchStations = useCallback(async () => {
     try {
-      const res = await fetch(`${API_URL}/api/v1/stations?window=${timeWindow}`);
+      const params = new URLSearchParams({ window: timeWindow });
+      if (transportFilter !== 'all') params.set('transport', transportFilter);
+      const res = await fetch(`${API_URL}/api/v1/stations?${params}`);
       if (res.ok) {
         const data = await res.json();
         setStations(data.stations ?? []);
       }
     } catch { /* retry next interval */ }
-  }, [timeWindow, setStations]);
+  }, [timeWindow, transportFilter, setStations]);
 
   const fetchStats = useCallback(async () => {
     try {

service/src/aggregation/coverage-store.ts

@@ -198,6 +198,7 @@ export class CoverageStore {
         event.signalLevel,
         hasValidTarget,
         hasError,
+        event.transportType,
       );
     }
   }
@@ -254,20 +255,20 @@ export class CoverageStore {
   }
 
   /** Get station coverage data for a specific station and window (sliding window scoped) */
-  getStationCoverage(stationId: number, windowName: string): StationCoverage | null {
+  getStationCoverage(stationId: number, windowName: string, transportFilter?: TransportType): StationCoverage | null {
     const wi = WINDOW_CONFIGS.findIndex(c => c.name === windowName);
     if (wi === -1) return null;
-    return this.stationWindows[wi].getStationCoverage(stationId);
+    return this.stationWindows[wi].getStationCoverage(stationId, transportFilter);
   }
 
   /** Get all stations with coverage data for a given window */
-  getAllStationCoverage(windowName: string): StationCoverage[] {
+  getAllStationCoverage(windowName: string, transportFilter?: TransportType): StationCoverage[] {
     const wi = WINDOW_CONFIGS.findIndex(c => c.name === windowName);
     if (wi === -1) return [];
     const sw = this.stationWindows[wi];
     const results: StationCoverage[] = [];
-    for (const id of sw.activeStationIds()) {
-      const cov = sw.getStationCoverage(id);
+    for (const id of sw.activeStationIds(transportFilter)) {
+      const cov = sw.getStationCoverage(id, transportFilter);
       if (cov && cov.totalMessages > 0) results.push(cov);
     }
     return results;
@@ -398,20 +399,24 @@ export class CoverageStore {
     const sw = this.stationWindows[wi];
     for (const s of stationData) {
       if (!s.stationId || !s.bearingSectors) continue;
+      // Determine transport type from station metadata
+      const meta = this.stationMap.get(s.stationId);
+      const tt: TransportType = (meta?.sourceType === 'aiscatcher' || meta?.sourceType === 'ais')
+        ? 'marine' : 'aircraft';
       // Record each sector's data into the current slice
       for (let i = 0; i < 36; i++) {
         const dist = s.bearingSectors[i] ?? 0;
         const count = s.sectorMessageCounts?.[i] ?? 0;
         if (dist > 0 || count > 0) {
           for (let j = 0; j < count; j++) {
-            sw.record(s.stationId, i, dist, s.sectorAvgLevels?.[i] ?? null, true, false);
+            sw.record(s.stationId, i, dist, s.sectorAvgLevels?.[i] ?? null, true, false, tt);
           }
         }
       }
       // Record messages without position
       const noPos = (s.totalMessages ?? 0) - (s.messagesWithPosition ?? 0);
       for (let j = 0; j < noPos; j++) {
-        sw.record(s.stationId, -1, 0, s.avgLevel ?? null, false, false);
+        sw.record(s.stationId, -1, 0, s.avgLevel ?? null, false, false, tt);
       }
     }
   }

service/src/aggregation/station-window.ts

@@ -1,26 +1,20 @@
 import type { WindowConfig, StationCoverage } from '../types/coverage.js';
+import type { TransportType } from '../types/events.js';
 
-/** Per-station sector data stored in one time slice */
+/** Per-station+transport sector data stored in one time slice */
 interface StationSliceData {
-  /** Max distance per 10-degree sector (36 sectors) */
   sectorMaxDist: Float64Array;
-  /** Message count per sector */
   sectorMsgCount: Uint32Array;
-  /** Sum of signal levels per sector (for averaging) */
   sectorLevelSum: Float64Array;
-  /** Total messages (with and without position) */
   totalMessages: number;
-  /** Messages that had target position */
   messagesWithPosition: number;
-  /** Sum of signal levels for overall average */
   totalLevelSum: number;
-  /** Count of messages with signal level data */
   levelCount: number;
-  /** Count of messages with errors */
   errorCount: number;
+  transportType: TransportType;
 }
 
-function createEmptySliceData(): StationSliceData {
+function createEmptySliceData(transportType: TransportType): StationSliceData {
   return {
     sectorMaxDist: new Float64Array(36),
     sectorMsgCount: new Uint32Array(36),
@@ -30,15 +24,21 @@ function createEmptySliceData(): StationSliceData {
     totalLevelSum: 0,
     levelCount: 0,
     errorCount: 0,
+    transportType,
   };
 }
 
-type Slice = Map<number, StationSliceData>; // stationId -> data
+/** Composite key: stationId + transportType */
+function sliceKey(stationId: number, transportType: TransportType): string {
+  return `${stationId}:${transportType}`;
+}
+
+type Slice = Map<string, StationSliceData>;
 
 /**
  * Sliding window for per-station bearing sector data.
- * Each slice stores sector data for all stations active in that period.
- * Aggregation across slices computes the window-scoped StationCoverage.
+ * Data is keyed by stationId+transportType so coverage can be
+ * filtered by transport type at query time.
  */
 export class StationSlidingWindow {
   readonly config: WindowConfig;
@@ -61,20 +61,22 @@ export class StationSlidingWindow {
     this.slices[this.currentIndex].clear();
   }
 
-  /** Record a reception event for a station in the current slice */
+  /** Record a reception event */
   record(
     stationId: number,
     sector: number,
     distance: number,
     signalLevel: number | null,
     hasPosition: boolean,
     hasError: boolean,
+    transportType: TransportType = 'aircraft',
   ): void {
+    const key = sliceKey(stationId, transportType);
     const slice = this.slices[this.currentIndex];
-    let data = slice.get(stationId);
+    let data = slice.get(key);
     if (!data) {
-      data = createEmptySliceData();
-      slice.set(stationId, data);
+      data = createEmptySliceData(transportType);
+      slice.set(key, data);
     }
 
     data.totalMessages++;
@@ -100,8 +102,11 @@ export class StationSlidingWindow {
     }
   }
 
-  /** Aggregate all slices into per-station coverage for the full window */
-  getStationCoverage(stationId: number): StationCoverage | null {
+  /**
+   * Aggregate all slices into per-station coverage.
+   * @param transportFilter - if set, only include data from matching transport types
+   */
+  getStationCoverage(stationId: number, transportFilter?: TransportType): StationCoverage | null {
     const result: StationCoverage = {
       stationId,
       bearingSectors: new Float64Array(36),
@@ -122,32 +127,32 @@ export class StationSlidingWindow {
     const sectorLevelSums = new Float64Array(36);
 
     for (const slice of this.slices) {
-      const data = slice.get(stationId);
-      if (!data) continue;
-
-      result.totalMessages += data.totalMessages;
-      result.messagesWithPosition += data.messagesWithPosition;
-      totalLevelSum += data.totalLevelSum;
-      levelCount += data.levelCount;
-      errorCount += data.errorCount;
-
-      for (let i = 0; i < 36; i++) {
-        // Max distance across all slices per sector
-        if (data.sectorMaxDist[i] > result.bearingSectors[i]) {
-          result.bearingSectors[i] = data.sectorMaxDist[i];
-        }
-        result.sectorMessageCounts[i] += data.sectorMsgCount[i];
-        sectorLevelSums[i] += data.sectorLevelSum[i];
-
-        if (data.sectorMaxDist[i] > result.maxDistance) {
-          result.maxDistance = data.sectorMaxDist[i];
+      // Check all matching keys for this station
+      for (const [key, data] of slice) {
+        if (!key.startsWith(`${stationId}:`)) continue;
+        if (transportFilter && data.transportType !== transportFilter) continue;
+
+        result.totalMessages += data.totalMessages;
+        result.messagesWithPosition += data.messagesWithPosition;
+        totalLevelSum += data.totalLevelSum;
+        levelCount += data.levelCount;
+        errorCount += data.errorCount;
+
+        for (let i = 0; i < 36; i++) {
+          if (data.sectorMaxDist[i] > result.bearingSectors[i]) {
+            result.bearingSectors[i] = data.sectorMaxDist[i];
+          }
+          result.sectorMessageCounts[i] += data.sectorMsgCount[i];
+          sectorLevelSums[i] += data.sectorLevelSum[i];
+          if (data.sectorMaxDist[i] > result.maxDistance) {
+            result.maxDistance = data.sectorMaxDist[i];
+          }
         }
       }
     }
 
     if (result.totalMessages === 0) return null;
 
-    // Compute averages
     result.avgLevel = levelCount > 0 ? totalLevelSum / levelCount : 0;
     result.errorRate = result.totalMessages > 0 ? errorCount / result.totalMessages : 0;
 
@@ -161,12 +166,14 @@ export class StationSlidingWindow {
     return result;
   }
 
-  /** Get all station IDs that have data in this window */
-  activeStationIds(): Set<number> {
+  /** Get all unique station IDs, optionally filtered by transport type */
+  activeStationIds(transportFilter?: TransportType): Set<number> {
     const ids = new Set<number>();
     for (const slice of this.slices) {
-      for (const id of slice.keys()) {
-        ids.add(id);
+      for (const [key, data] of slice) {
+        if (transportFilter && data.transportType !== transportFilter) continue;
+        const stationId = parseInt(key.split(':')[0], 10);
+        ids.add(stationId);
       }
     }
     return ids;

service/src/api/routes/coverage.ts

@@ -45,6 +45,11 @@ coverageRoutes.get('/stations/:id', (c) => {
   const store = c.get('store');
   const stationId = parseInt(c.req.param('id'), 10);
   const windowName = c.req.query('window') ?? '1h';
+  const transportRaw = c.req.query('transport');
+  const validTransports = ['aircraft', 'marine', 'sonde', 'space'];
+  const transportFilter = transportRaw && validTransports.includes(transportRaw)
+    ? transportRaw as TransportType
+    : undefined;
 
   if (!Number.isInteger(stationId) || stationId < 1) {
     return c.json({ error: 'Invalid station ID' }, 400);
@@ -55,16 +60,16 @@ coverageRoutes.get('/stations/:id', (c) => {
     return c.json({ error: 'Station not found' }, 404);
   }
 
-  // Window-scoped message counts from H3 sliding windows (properly expires)
+  // Window-scoped message counts from H3 sliding windows
   const windowCounts = store.getStationMessageCounts(windowName);
   const windowData = windowCounts.get(stationId);
 
   if (!windowData || windowData.messageCount === 0) {
     return c.json({ error: 'No coverage data for this station in this window' }, 404);
   }
 
-  // Bearing sector data (cumulative best-observed range per direction)
-  const coverage = store.getStationCoverage(stationId, windowName);
+  // Bearing sector data filtered by transport type
+  const coverage = store.getStationCoverage(stationId, windowName, transportFilter);
 
   const polygon = coverage
     ? buildCoveragePolygon(station.latitude, station.longitude, coverage)

service/src/api/routes/stations.ts

@@ -1,19 +1,24 @@
 import { Hono } from 'hono';
 import type { AppContext } from '../server.js';
+import type { TransportType } from '../../types/events.js';
 
 export const stationRoutes = new Hono<AppContext>();
 
+const MARINE_SOURCE_TYPES = new Set(['aiscatcher', 'ais']);
+
 /** GET /api/v1/stations — All stations with window-scoped coverage summaries */
 stationRoutes.get('/', (c) => {
   const store = c.get('store');
   const windowName = c.req.query('window') ?? '1h';
   const activeOnly = c.req.query('active') !== 'false';
+  const transportRaw = c.req.query('transport');
+  const validTransports = ['aircraft', 'marine', 'sonde', 'space'];
+  const transportFilter = transportRaw && validTransports.includes(transportRaw)
+    ? transportRaw as TransportType
+    : undefined;
 
-  // Get window-scoped message counts from H3 sliding windows (properly expires old data)
   const windowCounts = store.getStationMessageCounts(windowName);
-
-  // Get full coverage data (for bearing sectors, signal levels, etc.)
-  const allCoverage = store.getAllStationCoverage(windowName);
+  const allCoverage = store.getAllStationCoverage(windowName, transportFilter);
   const coverageByStation = new Map(allCoverage.map((cov) => [cov.stationId, cov]));
 
   const stations = [];
@@ -24,6 +29,10 @@ stationRoutes.get('/', (c) => {
     const meta = store.stationMap.get(stationId);
     if (!meta) continue;
 
+    // Filter stations by transport type based on their source type
+    if (transportFilter === 'aircraft' && MARINE_SOURCE_TYPES.has(meta.sourceType)) continue;
+    if (transportFilter === 'marine' && !MARINE_SOURCE_TYPES.has(meta.sourceType)) continue;
+
     const cov = coverageByStation.get(stationId);
 
     stations.push({