kahu-signalk 0.0.13 → 0.0.16

package/.cursor/plans/3-branch_implementation_split_b745065d.plan.md

@@ -0,0 +1,150 @@
+---
+name: 3-branch implementation split
+overview: Split the Mayara + own-ship + data classification work into three sequential branches with explicit interfaces and no unknown cross-repo dependencies.
+todos:
+  - id: branch1-classification
+    content: Finalize Branch 1 scope and acceptance criteria for classification foundation
+    status: completed
+  - id: branch2-ownship
+    content: Finalize Branch 2 scope and acceptance criteria for own-ship route tracking
+    status: completed
+  - id: branch3-mayara
+    content: Finalize Branch 3 scope and acceptance criteria for Mayara ingestion
+    status: completed
+isProject: false
+---
+
+# 3-Branch Implementation Plan
+
+## Strategy
+
+Implement in dependency order so each branch is mergeable by itself:
+1. **Branch 1 = storage and metadata foundation**
+2. **Branch 2 = own-ship route tracking**
+3. **Branch 3 = Mayara ingestion**
+
+No branch requires protocol repo (`radarhub-protocol`) or server changes to land. Avro schema changes remain a separate follow-up.
+
+## Branch 1 — Data Classification Foundation
+
+### Goal
+Add stable data classification (`data_kind`, `source_type`) and RATTM Signal K metadata without changing ingestion behavior.
+
+### Scope
+- Update DB migration to add `data_kind` + `source_type`
+- Update `Routecache.insert()` to store those columns with defaults
+- Tag RATTM inserts as `arpaTarget` / `RATTM`
+- Extend RATTM Signal K delta with `kahu.dataKind`, `kahu.source`, `kahu.target.id`, `kahu.target.status`
+- README: add a short section on data classification semantics
+
+### Files
+- [plugin/routecache.js](/home/bs01743/Projects/KAHU/radarhub-signalk/plugin/routecache.js)
+- [plugin/index.js](/home/bs01743/Projects/KAHU/radarhub-signalk/plugin/index.js)
+- [data/protocol/migrations/0003-add-datakind.sql](/home/bs01743/Projects/KAHU/radarhub-signalk/data/protocol/migrations/0003-add-datakind.sql)
+- [README.md](/home/bs01743/Projects/KAHU/radarhub-signalk/README.md)
+
+### Branch Output Contract
+- Existing RATTM flow unchanged functionally
+- Every cached RATTM point has explicit classification fields
+- Live Signal K consumers can distinguish radar contacts via `kahu.dataKind`
+
+### Dependency Notes
+- No dependency on Mayara
+- No dependency on own-ship tracking
+- No dependency on protocol/server migration
+
+---
+
+## Branch 2 — Own-Ship Route Tracking
+
+### Goal
+Track and upload vessel route explicitly from Signal K self position stream.
+
+### Scope
+- Add plugin config section `own_ship_tracking` with:
+  - `enabled` (default `true`)
+  - `sample_interval_s` (default `10`)
+- Subscribe to `navigation.position` stream for self-context, non-TTM updates
+- Sample/throttle inserts by config interval
+- Insert own-ship points using:
+  - `data_kind = vesselRoute`
+  - `source_type = gps`
+- Ensure lifecycle cleanup (`unsubscribe` on stop)
+- README: document own-ship behavior and dashboard meaning (blue route)
+
+### Files
+- [plugin/index.js](/home/bs01743/Projects/KAHU/radarhub-signalk/plugin/index.js)
+- [README.md](/home/bs01743/Projects/KAHU/radarhub-signalk/README.md)
+
+### Branch Output Contract
+- Vessel route is recorded even when no ARPA targets exist
+- Data classified distinctly from ARPA targets
+- Connector upload path works unchanged (same route point shape)
+
+### Dependency Notes
+- Depends on Branch 1 classification columns/defaults
+- Does not depend on Mayara branch
+- Still no protocol/server schema dependency
+
+---
+
+## Branch 3 — Mayara Optional Ingestion
+
+### Goal
+Add optional Mayara target ingestion (WS primary, HTTP fallback) into existing cache/upload pipeline.
+
+### Scope
+- Add dependency `ws` to package.json
+- Add plugin config section `mayara`:
+  - `enabled` (default `false`)
+  - `base_url` (default `http://localhost:6502`)
+  - `poll_interval_ms` (default `2000`)
+- Create `MayaraIngestor` module
+  - Radar discovery from REST API
+  - WS subscribe to `radars.*.targets.*`
+  - Parse/normalize fields and units
+  - Filter status to `tracking`
+  - Stable UUID mapping per radar+target
+  - HTTP polling fallback with reconnect strategy
+- Cache inserts as:
+  - `data_kind = arpaTarget`
+  - `source_type = mayara`
+- Lifecycle wiring in plugin start/stop
+- README: operational setup and troubleshooting for Mayara
+
+### Files
+- [package.json](/home/bs01743/Projects/KAHU/radarhub-signalk/package.json)
+- [plugin/mayara.js](/home/bs01743/Projects/KAHU/radarhub-signalk/plugin/mayara.js)
+- [plugin/index.js](/home/bs01743/Projects/KAHU/radarhub-signalk/plugin/index.js)
+- [README.md](/home/bs01743/Projects/KAHU/radarhub-signalk/README.md)
+
+### Branch Output Contract
+- Mayara can be enabled without affecting RATTM or own-ship flows
+- If Mayara is unavailable, plugin degrades gracefully and existing flows continue
+- All Mayara target points are explicitly classified
+
+### Dependency Notes
+- Depends on Branch 1 classification fields
+- Independent from Branch 2 runtime behavior
+- No protocol/server migration dependency
+
+---
+
+## Cross-Branch Guardrails
+
+- Keep Avro schema unchanged in all 3 branches
+- Keep server-side kind/source ingestion as separate follow-up project
+- Preserve backward compatibility with existing local DB rows (defaults)
+- Keep each PR testable with local SQLite checks + plugin logs
+
+## Suggested Branch Names
+
+- `feature/classification-foundation`
+- `feature/own-ship-route-tracking`
+- `feature/mayara-ingestion`
+
+## Merge Order
+
+1. Branch 1
+2. Branch 2 (rebased on Branch 1)
+3. Branch 3 (rebased on Branch 1 or Branch 2; preferred on Branch 2 so README and config context are unified)

package/.gitmodules

@@ -1,3 +1,4 @@
 [submodule "data/protocol"]
 	path = data/protocol
 	url = https://github.com/KAHU-radar/radarhub-protocol.git
+	branch = master

package/README.md

@@ -96,6 +96,23 @@ A `$RATTM` sentence contains:
 
 ---
 
+## Data Classification
+
+The plugin stores classification metadata for each cached point so downstream
+consumers can reliably distinguish track types.
+
+| Field | Meaning | Current values |
+|-------|---------|----------------|
+| `data_kind` | Semantic category of the data point | `arpaTarget`, `vesselRoute` |
+| `source_type` | Origin of the point | `RATTM`, `mayara`, `gps` |
+
+For RATTM-derived targets, Signal K deltas also include:
+- `kahu.dataKind = arpaTarget`
+- `kahu.source = RATTM`
+- `kahu.target.id` and `kahu.target.status`
+
+---
+
 ## Installation
 
 ```bash
@@ -129,6 +146,11 @@ Enable the plugin in the Signal K admin UI under **Server > Plugin Config > KAHU
 | `api_key` | *(none)* | Your API key for authentication |
 | `min_reconnect_time` | `100` | Minimum delay (ms) before reconnecting after a drop |
 | `max_reconnect_time` | `600` | Maximum delay (ms) between reconnection attempts |
+| `own_ship_tracking.enabled` | `true` | Enable own-ship GPS route tracking |
+| `own_ship_tracking.sample_interval_s` | `10` | Minimum seconds between own-ship route points |
+| `mayara.enabled` | `false` | Enable Mayara target ingestion |
+| `mayara.base_url` | `http://localhost:6502` | Base URL for Mayara server |
+| `mayara.poll_interval_ms` | `2000` | HTTP fallback polling interval when WS is unavailable |
 
 ### Prerequisites
 
@@ -138,9 +160,43 @@ Enable the plugin in the Signal K admin UI under **Server > Plugin Config > KAHU
 
 ---
 
+## Mayara Integration (Optional)
+
+If you run [mayara-server](https://github.com/MarineYachtRadar/mayara-server),
+this plugin can ingest ARPA targets from Mayara in addition to `$RATTM`.
+
+How it works:
+1. Discover radars from `GET /signalk/v2/api/vessels/self/radars`
+2. Connect to `/signalk/v1/stream` and subscribe to `radars.*.targets.*`
+3. Ingest only `tracking` targets
+4. Write to cache as `data_kind=arpaTarget`, `source_type=mayara`
+5. If WebSocket is unstable, fall back to periodic HTTP polling at
+   `/signalk/v2/api/vessels/self/radars/{id}/targets`
+
+This path is optional and does not affect own-ship tracking or existing RATTM
+parsing when disabled.
+
+---
+
+## Own-Ship Route Tracking
+
+The plugin now tracks your vessel route explicitly from Signal K
+`navigation.position` updates (self-context, non-TTM source). These points are
+stored with:
+
+- `data_kind = vesselRoute`
+- `source_type = gps`
+
+This route stream is independent from ARPA targets, so route points continue to
+be recorded even when there are no tracked radar contacts. In dashboards, this
+is intended to be rendered as the vessel route (typically blue), while ARPA
+targets remain separate (typically red).
+
+---
+
 ## Current Limitations
 
-- Only supports `$RATTM` sentences (not `$RATTL` -- target list sentences)
+- `$RATTL` target list sentences are not parsed
 - Does not collect AIS data, only radar ARPA targets
 - The protocol is **NOT encrypted** (data is sent in plain text)
 - The protocol is **NOT cryptographically signed** (no tamper protection)
@@ -161,12 +217,14 @@ radarhub-signalk/
 │   ├── tcpclient.js          # TCP socket client with auto-reconnect
 │   ├── avroclient.js         # Avro serialization/deserialization over TCP
 │   ├── routecache.js         # SQLite local cache for track points
+│   ├── mayara.js             # Optional Mayara target ingestion
 │   └── utils.js              # Utility helpers
 └── data/protocol/            # Git submodule (radarhub-protocol)
     ├── proto_avro.json       # Avro schema defining the wire protocol
     └── migrations/           # SQLite database migrations
         ├── 0001-create-targets.sql
-        └── 0002-target-indices.sql
+        ├── 0002-target-indices.sql
+        └── 0003-add-datakind.sql
 ```
 
 ---
@@ -186,7 +244,7 @@ wanting to build a more elaborate server-side setup.
 
 - **Signal K Server:** v2.22.1+ (latest stable)
 - **Node.js:** **22.5.0+** (built-in `node:sqlite`; no native `sqlite3` bindings).
-- **Dependencies:** avro-js, promise-socket, uuid
+- **Dependencies:** avro-js, promise-socket, uuid, ws
 
 ---
 

package/data/protocol/migrations/0003-add-datakind.sql

@@ -0,0 +1,2 @@
+ALTER TABLE target_position ADD COLUMN data_kind TEXT DEFAULT 'arpaTarget';
+ALTER TABLE target_position ADD COLUMN source_type TEXT DEFAULT 'RATTM';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kahu-signalk",
-  "version": "0.0.13",
+  "version": "0.0.16",
   "description": "Contribute AIS and ARPA targets from your vessel to crowdsourcing for marine safety!",
   "keywords": [
     "signalk-node-server-plugin",
@@ -30,6 +30,7 @@
   "dependencies": {
     "avro-js": "^1.12.0",
     "promise-socket": "^8.0.0",
-    "uuid": "^8.1.0"
+    "uuid": "^8.1.0",
+    "ws": "^8.18.0"
   }
 }

package/plugin/connector.js

@@ -119,7 +119,23 @@ class Connector {
   async sendTracks() {
     const submit = await this.routecache.retrieve();
     if (submit === null) return;
-    console.error("Connector sending tracks");
+
+    const pointCount = Array.isArray(submit.route) ? submit.route.length : 0;
+    const firstPoint = pointCount > 0 ? submit.route[0] : null;
+    const lastPoint = pointCount > 0 ? submit.route[pointCount - 1] : null;
+    console.error(
+      "Connector submitting route:",
+      JSON.stringify({
+        uuid: submit?.uuid?.string,
+        data_kind: submit?.data_kind,
+        source_type: submit?.source_type,
+        start_epoch_ms: submit?.start,
+        point_count: pointCount,
+        first_point: firstPoint,
+        last_point: lastPoint,
+      }),
+    );
+
     await this.client.send({
       Message: {
         "kahu.Call": {

package/plugin/index.js

@@ -1,6 +1,7 @@
 const { v4: uuidv4 } = require("uuid");
 const { Routecache } = require("./routecache");
 const { Connector } = require("./connector");
+const { MayaraIngestor } = require("./mayara");
 const path = require("path");
 const fs = require("fs");
 
@@ -76,6 +77,8 @@ const polar2Pos = (ownPos, bearing, distance) => {
 
 const buildRattmDelta = ({
   route_id,
+  target_id,
+  target_status,
   target_distance,
   target_bearing,
   target_bearing_unit,
@@ -103,6 +106,10 @@ const buildRattmDelta = ({
           { path: "navigation.speedOverGround", value: target_speed },
           { path: "navigation.courseOverGroundTrue", value: target_course },
           { path: "navigation.position", value: { ...targetPos, relative } },
+          { path: "kahu.dataKind", value: "arpaTarget" },
+          { path: "kahu.source", value: "RATTM" },
+          { path: "kahu.target.id", value: target_id },
+          { path: "kahu.target.status", value: target_status || null },
         ],
       },
     ],
@@ -118,6 +125,9 @@ module.exports = (app) => {
 
       plugin.pending_rattm = [];
       plugin.last_no_ownpos_warning_at = 0;
+      plugin.lastOwnShipInsertAt = 0;
+      plugin.ownShipRouteId = uuidv4();
+      plugin.settings = settings || {};
 
       plugin.cache = new Routecache(
         path.join(packageDir, "data", "protocol", "migrations"),
@@ -132,6 +142,17 @@ module.exports = (app) => {
         status_function: app.setPluginStatus.bind(app),
       });
 
+      if (plugin.settings.mayara?.enabled) {
+        plugin.mayaraIngestor = new MayaraIngestor({
+          baseUrl: plugin.settings.mayara.base_url || "http://localhost:6502",
+          routecache: plugin.cache,
+          getOwnPosition: () => app.getSelfPath("navigation.position")?.value,
+          statusFn: (msg) => app.setPluginStatus(`Mayara: ${msg}`),
+          pollIntervalMs: plugin.settings.mayara.poll_interval_ms || 2000,
+        });
+        plugin.mayaraIngestor.start();
+      }
+
       const now = new Date(1970, 1, 1);
       plugin.route_updates = Array.from(Array(100)).map(() => now);
       plugin.route_ids = Array.from(Array(100));
@@ -211,6 +232,8 @@ module.exports = (app) => {
                     plugin.id,
                     buildRattmDelta({
                       route_id: plugin.route_ids[b.target_id],
+                      target_id: b.target_id,
+                      target_status: b.target_status,
                       target_distance: b.target_distance,
                       target_bearing: b.target_bearing,
                       target_bearing_unit: b.target_bearing_unit,
@@ -245,6 +268,8 @@ module.exports = (app) => {
 
             return buildRattmDelta({
               route_id: plugin.route_ids[target_id],
+              target_id,
+              target_status,
               target_distance,
               target_bearing,
               target_bearing_unit,
@@ -259,11 +284,20 @@ module.exports = (app) => {
         },
       });
 
-      app.streambundle
+      plugin.targetPositionSubscription = app.streambundle
         .getBus("navigation.position")
         .forEach(plugin.updatePosition);
+
+      if (plugin.settings.own_ship_tracking?.enabled !== false) {
+        plugin.ownShipPositionSubscription = app.streambundle
+          .getBus("navigation.position")
+          .forEach(plugin.updateOwnShipPosition);
+      }
     },
     stop: async () => {
+      plugin.targetPositionSubscription?.unsubscribe?.();
+      plugin.ownShipPositionSubscription?.unsubscribe?.();
+      await plugin.mayaraIngestor?.destroy?.();
       await plugin.connector?.destroy?.();
       await plugin.cache?.destroy?.();
       console.log("Stopped KAHU radar Hub");
@@ -276,6 +310,43 @@ module.exports = (app) => {
           api_key: { type: "string" },
           min_reconnect_time: { type: "number", default: 100.0 },
           max_reconnect_time: { type: "number", default: 600.0 },
+          own_ship_tracking: {
+            type: "object",
+            title: "Own-Ship Position Tracking",
+            properties: {
+              enabled: {
+                type: "boolean",
+                default: true,
+                title: "Track own vessel route from GPS",
+              },
+              sample_interval_s: {
+                type: "number",
+                default: 10,
+                title: "Own-ship sample interval in seconds",
+              },
+            },
+          },
+          mayara: {
+            type: "object",
+            title: "Mayara Radar Server",
+            properties: {
+              enabled: {
+                type: "boolean",
+                default: false,
+                title: "Enable Mayara target ingestion",
+              },
+              base_url: {
+                type: "string",
+                default: "http://localhost:6502",
+                title: "Mayara server base URL",
+              },
+              poll_interval_ms: {
+                type: "number",
+                default: 2000,
+                title: "Mayara HTTP fallback poll interval (ms)",
+              },
+            },
+          },
         },
       };
     },
@@ -288,12 +359,48 @@ module.exports = (app) => {
 
       plugin.cache.insert({
         target_id: target_id,
+        data_kind: "arpaTarget",
+        source_type: "RATTM",
         position: pos.value,
         speedOverGround: rest?.navigation?.speedOverGround?.value,
         courseOverGroundTrue: rest?.navigation?.courseOverGroundTrue?.value,
         name: rest?.name?.value,
       });
     },
+    updateOwnShipPosition: (pos) => {
+      if (!pos?.value?.latitude || !pos?.value?.longitude) return;
+      if (pos?.source?.sentence === "TTM") return;
+
+      const selfContext =
+        typeof app.selfId === "string" ? `vessels.${app.selfId}` : null;
+      if (
+        pos.context &&
+        pos.context !== "vessels.self" &&
+        (!selfContext || pos.context !== selfContext)
+      ) {
+        return;
+      }
+
+      const sampleIntervalMs =
+        (plugin.settings?.own_ship_tracking?.sample_interval_s || 10) * 1000;
+      const nowMs = Date.now();
+      if (nowMs - plugin.lastOwnShipInsertAt < sampleIntervalMs) return;
+      plugin.lastOwnShipInsertAt = nowMs;
+
+      plugin.cache.insert({
+        target_id: plugin.ownShipRouteId,
+        data_kind: "vesselRoute",
+        source_type: "gps",
+        position: {
+          latitude: pos.value.latitude,
+          longitude: pos.value.longitude,
+        },
+        speedOverGround: app.getSelfPath("navigation.speedOverGround")?.value,
+        courseOverGroundTrue: app.getSelfPath("navigation.courseOverGroundTrue")
+          ?.value,
+        name: app.getSelfPath("name")?.value || "Own Vessel",
+      });
+    },
   };
 
   return plugin;

package/plugin/mayara.js

@@ -0,0 +1,205 @@
+const { v4: uuidv4 } = require("uuid");
+const WebSocket = require("ws");
+
+const rad2deg = (rad) => (Number.isFinite(rad) ? (rad * 180) / Math.PI : null);
+
+class MayaraIngestor {
+  constructor({ baseUrl, routecache, getOwnPosition, statusFn, pollIntervalMs }) {
+    this.baseUrl = (baseUrl || "http://localhost:6502").replace(/\/+$/, "");
+    this.routecache = routecache;
+    this.getOwnPosition = getOwnPosition || (() => null);
+    this.statusFn = statusFn || (() => {});
+    this.pollIntervalMs = pollIntervalMs || 2000;
+
+    this.ws = null;
+    this.pollTimer = null;
+    this.reconnectTimer = null;
+    this.reconnectMs = 1000;
+    this.wsFailCount = 0;
+    this.destroyed = false;
+
+    this.radarIds = [];
+    this.targetUuids = new Map();
+  }
+
+  async start() {
+    await this._discoverRadars();
+    this._connectWebSocket();
+  }
+
+  async destroy() {
+    this.destroyed = true;
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    if (this.pollTimer) clearInterval(this.pollTimer);
+    this.reconnectTimer = null;
+    this.pollTimer = null;
+
+    if (this.ws) {
+      try {
+        this.ws.close();
+      } catch (err) {
+        this.statusFn(`Mayara WS close error: ${err.message}`);
+      }
+    }
+    this.ws = null;
+  }
+
+  async _discoverRadars() {
+    try {
+      const res = await fetch(
+        `${this.baseUrl}/signalk/v2/api/vessels/self/radars`,
+      );
+      if (!res.ok) {
+        this.statusFn(`Mayara radar discovery failed: HTTP ${res.status}`);
+        return;
+      }
+      const payload = await res.json();
+
+      if (Array.isArray(payload)) {
+        this.radarIds = payload
+          .map((item) => item?.id || item?.radarId)
+          .filter(Boolean);
+      } else if (payload && typeof payload === "object") {
+        this.radarIds = Object.keys(payload);
+      } else {
+        this.radarIds = [];
+      }
+
+      this.statusFn(`Mayara discovered ${this.radarIds.length} radar(s)`);
+    } catch (err) {
+      this.statusFn(`Mayara radar discovery error: ${err.message}`);
+    }
+  }
+
+  _buildWsUrl() {
+    const url = new URL(this.baseUrl);
+    url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+    url.pathname = "/signalk/v1/stream";
+    url.search = "subscribe=none";
+    return url.toString();
+  }
+
+  _connectWebSocket() {
+    if (this.destroyed) return;
+    const wsUrl = this._buildWsUrl();
+
+    this.ws = new WebSocket(wsUrl);
+
+    this.ws.on("open", () => {
+      this.wsFailCount = 0;
+      this.reconnectMs = 1000;
+      if (this.pollTimer) {
+        clearInterval(this.pollTimer);
+        this.pollTimer = null;
+      }
+      this.statusFn("Mayara WS connected");
+      this.ws.send(
+        JSON.stringify({
+          context: "vessels.self",
+          subscribe: [{ path: "radars.*.targets.*", policy: "instant" }],
+        }),
+      );
+    });
+
+    this.ws.on("message", (raw) => this._handleDelta(raw));
+    this.ws.on("error", (err) => this.statusFn(`Mayara WS error: ${err.message}`));
+    this.ws.on("close", () => this._scheduleReconnect());
+  }
+
+  _scheduleReconnect() {
+    if (this.destroyed) return;
+    this.wsFailCount += 1;
+
+    if (this.wsFailCount >= 3) this._startHttpFallback();
+
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.reconnectTimer = setTimeout(() => {
+      this._connectWebSocket();
+    }, this.reconnectMs);
+    this.reconnectMs = Math.min(this.reconnectMs * 2, 15000);
+  }
+
+  _getTargetUuid(radarId, targetId) {
+    const key = `${radarId}:${targetId}`;
+    if (!this.targetUuids.has(key)) this.targetUuids.set(key, uuidv4());
+    return this.targetUuids.get(key);
+  }
+
+  _insertTarget(radarId, targetId, target) {
+    if (!target || target.status !== "tracking") return;
+    const lat = target.position?.latitude;
+    const lon = target.position?.longitude;
+    if (!Number.isFinite(lat) || !Number.isFinite(lon)) return;
+
+    const ownPos = this.getOwnPosition?.();
+    if (!ownPos?.latitude || !ownPos?.longitude) return;
+
+    this.routecache.insert({
+      target_id: this._getTargetUuid(radarId, targetId),
+      data_kind: "arpaTarget",
+      source_type: "mayara",
+      target_status: target.status,
+      position: {
+        latitude: lat,
+        longitude: lon,
+        relative: {
+          position: ownPos,
+          distance: target.position?.distance,
+          bearing: rad2deg(target.position?.bearing),
+          bearing_unit: "T",
+          distance_unit: "M",
+        },
+      },
+      speedOverGround: target.motion?.speed ?? null,
+      courseOverGroundTrue: rad2deg(target.motion?.course),
+      name: `ARPA-${targetId}`,
+    });
+  }
+
+  _handleDelta(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw.toString());
+    } catch (err) {
+      return;
+    }
+
+    for (const update of msg?.updates || []) {
+      for (const value of update?.values || []) {
+        const path = value?.path || "";
+        const match = path.match(/^radars\.([^.]+)\.targets\.([^.]+)$/);
+        if (!match) continue;
+        if (!value.value) continue;
+        const radarId = match[1];
+        const targetId = match[2];
+        this._insertTarget(radarId, targetId, value.value);
+      }
+    }
+  }
+
+  _startHttpFallback() {
+    if (this.pollTimer || this.destroyed) return;
+    this.statusFn("Mayara WS unstable, enabling HTTP fallback polling");
+    this.pollTimer = setInterval(async () => {
+      if (this.destroyed) return;
+      if (!this.radarIds.length) await this._discoverRadars();
+      for (const radarId of this.radarIds) {
+        try {
+          const res = await fetch(
+            `${this.baseUrl}/signalk/v2/api/vessels/self/radars/${radarId}/targets`,
+          );
+          if (!res.ok) continue;
+          const targets = await res.json();
+          if (!Array.isArray(targets)) continue;
+          for (const target of targets) {
+            this._insertTarget(radarId, target?.id, target);
+          }
+        } catch (err) {
+          this.statusFn(`Mayara HTTP poll error: ${err.message}`);
+        }
+      }
+    }, this.pollIntervalMs);
+  }
+}
+
+module.exports = { MayaraIngestor };

package/plugin/routecache.js

@@ -193,9 +193,11 @@ class Routecache {
         latitude,
         longitude,
         target_latitude,
-        target_longitude
+        target_longitude,
+        data_kind,
+        source_type
       ) values (
-        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+        ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
    `,
       [
         target[0].target_id,
@@ -207,11 +209,13 @@ class Routecache {
         'T',
         props.position?.relative?.distance_unit,
         props.name,
-        'T',
+        props.target_status || 'T',
         props.position?.relative?.position?.latitude,
         props.position?.relative?.position?.longitude,
         props.position?.latitude,
         props.position?.longitude,
+        props.data_kind || 'arpaTarget',
+        props.source_type || 'RATTM',
       ]
     );
   }
@@ -251,7 +255,9 @@ class Routecache {
         (strftime('%s', timestamp) +  strftime('%f', timestamp) - strftime('%S', timestamp)) * 1000
           as timestamp_epoch,
         target_position.target_latitude,
-        target_position.target_longitude
+        target_position.target_longitude,
+        target_position.data_kind,
+        target_position.source_type
       from
         target_position,
         target
@@ -289,6 +295,8 @@ class Routecache {
       route: [],
       nmea: null,
       start: Number(query[0].timestamp_epoch),
+      data_kind: query[0].data_kind || "arpaTarget",
+      source_type: query[0].source_type || "RATTM",
     };
 
     for (const row of query) {