@signalk/tracks-plugin 3.0.0-beta.3 → 3.0.0-beta.5

package/dist/index.d.ts

@@ -114,8 +114,6 @@ interface Plugin {
 }
 interface TracksPluginConfig {
     resolution?: number;
-    /** Days of the own vessel's track to keep. 0 keeps everything. */
-    retentionDays?: number;
     /** Days another vessel is kept after its last fix. 0 keeps every vessel. */
     aisRetentionDays?: number;
     /** Minutes without a fix that start a new track segment. 0 disables. */

package/dist/index.html

@@ -4,6 +4,7 @@
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <title>Tracks</title>
+    <link rel="icon" href="./app-icon.svg" type="image/svg+xml" />
     <link rel="stylesheet" href="./style.css" />
   </head>
   <body>

package/dist/index.js

@@ -12483,26 +12483,108 @@ function reconcileByExtent(history, stored) {
 * Detection is therefore empirical rather than reading the priority config:
 * seeing several sources here *is* the evidence that no rule is matching,
 * which a config that merely exists would not tell us.
+*
+* With one qualification. A priority rule has a failover window — when the
+* top-ranked source goes quiet the engine promotes the next one — so over a
+* long run several sources legitimately reach this bus even with a rule in
+* place, one at a time. Counting every source ever seen would therefore
+* report a conflict on a correctly configured boat whose GPS drops out
+* occasionally. What distinguishes competition is *alternation*: unfiltered
+* sources hand back and forth repeatedly within seconds, while a failover
+* switches once and stays.
+*/
+/**
+* How quickly the source must change again for it to count as alternation.
+*
+* Shorter than the server's 15s default failover, so a promotion — one
+* switch after a silence — never chains into a sequence. Positions are a
+* rapid update, often 10Hz, so genuinely competing sources alternate far
+* faster than this.
+*/
+var ALTERNATION_WINDOW_MS = 1e4;
+/**
+* How long a conflict is remembered after it was last observed.
+*
+* Longer than the 30s status tick, so a conflict seen just after one tick is
+* still reported at the next and does not flicker. Finite, so fixing the
+* priorities clears the warning on its own rather than needing a restart —
+* which is the whole complaint about a watcher that only ever accumulates.
+*/
+var CONFLICT_RETENTION_MS = 9e4;
+/**
+* How many source changes in a row before it counts as competition.
+*
+* One change is a failover, two is a failback — the preferred source
+* returning and winning immediately, which the server does on purpose. Three
+* means the sources are trading the path back and forth, which no priority
+* rule does.
 */
+var CHANGES_BEFORE_WARNING = 3;
 var SourceWatch = class {
+	/** Last time each source produced a position, per context. */
 	seen = /* @__PURE__ */ new Map();
+	/** Sources found competing, per context, with when each was last seen so. */
+	competing = /* @__PURE__ */ new Map();
+	/** The current alternation per context: who is in it, and how long it is. */
+	lastSeen = /* @__PURE__ */ new Map();
 	/** Record that `context` produced a position from `$source`. */
-	add(context, source) {
+	add(context, source, now = Date.now()) {
 		if (!source) return;
 		let sources = this.seen.get(context);
 		if (!sources) {
-			sources = /* @__PURE__ */ new Set();
+			sources = /* @__PURE__ */ new Map();
 			this.seen.set(context, sources);
 		}
-		sources.add(source);
+		const previous = this.lastSeen.get(context);
+		sources.set(source, now);
+		const stale = !previous || now - previous.changedAt > ALTERNATION_WINDOW_MS;
+		if (stale || previous.source === source) this.lastSeen.set(context, {
+			source,
+			at: now,
+			changedAt: stale ? now : previous.changedAt,
+			changes: stale ? 0 : previous.changes,
+			participants: stale ? /* @__PURE__ */ new Set([source]) : previous.participants
+		});
+		else {
+			const changes = previous.changes + 1;
+			const participants = previous.participants.add(source);
+			this.lastSeen.set(context, {
+				source,
+				at: now,
+				changedAt: now,
+				changes,
+				participants
+			});
+			if (changes >= CHANGES_BEFORE_WARNING) {
+				const found = this.competing.get(context) ?? /* @__PURE__ */ new Map();
+				for (const participant of participants) found.set(participant, sources.get(participant) ?? now);
+				this.competing.set(context, found);
+			}
+		}
 	}
-	/** Sources seen for a context, in the order they first appeared. */
+	/** Every source seen for a context, in the order they first appeared. */
 	sourcesFor(context) {
-		return [...this.seen.get(context) ?? []];
+		return [...(this.seen.get(context) ?? /* @__PURE__ */ new Map()).keys()];
+	}
+	/**
+	* The sources found live at the same time, which is what a warning names.
+	*
+	* Expired entries are dropped rather than merely hidden, so a conflict that
+	* has stopped recurring leaves nothing behind.
+	*/
+	competingFor(context, now = Date.now()) {
+		const found = this.competing.get(context);
+		if (!found) return [];
+		for (const [source, at] of found) if (now - at > CONFLICT_RETENTION_MS) found.delete(source);
+		if (found.size < 2) {
+			this.competing.delete(context);
+			return [];
+		}
+		return [...found.keys()];
 	}
-	/** Contexts receiving positions from more than one source. */
-	conflicted() {
-		return [...this.seen.entries()].filter(([, sources]) => sources.size > 1).map(([context]) => context);
+	/** Contexts that have received positions from two sources at once. */
+	conflicted(now = Date.now()) {
+		return [...this.competing.keys()].filter((context) => this.competingFor(context, now).length > 1);
 	}
 	/**
 	* A status line naming the problem, or undefined when nothing is wrong.
@@ -12512,21 +12594,24 @@ var SourceWatch = class {
 	* vessels are usually AIS, where multiple receivers are expected and less
 	* worth nagging about — they are counted, not named.
 	*/
-	warning(selfContext) {
-		const conflicted = this.conflicted();
+	warning(selfContext, now = Date.now()) {
+		const conflicted = this.conflicted(now);
 		if (conflicted.length === 0) return;
 		const selfConflicted = selfContext !== void 0 && conflicted.includes(selfContext);
 		const others = conflicted.length - (selfConflicted ? 1 : 0);
 		if (selfConflicted) {
-			const sources = this.sourcesFor(selfContext).join(", ");
+			const recent = this.competingFor(selfContext, now);
+			const sources = recent.join(", ");
 			const tail = others > 0 ? ` (and ${others} other ${others === 1 ? "vessel" : "vessels"})` : "";
-			return `navigation.position for the own vessel is arriving from ${this.sourcesFor(selfContext).length} sources (${sources})${tail}. Set source priority for navigation.position, or the track will zigzag between them.`;
+			return `navigation.position for the own vessel is arriving from ${recent.length} sources (${sources})${tail}. Set source priority for navigation.position, or the track will zigzag between them.`;
 		}
 		return `navigation.position is arriving from multiple sources for ${others} ${others === 1 ? "vessel" : "vessels"}.`;
 	}
 	/** Forget everything seen; used when the plugin restarts. */
 	clear() {
 		this.seen.clear();
+		this.competing.clear();
+		this.lastSeen.clear();
 	}
 };
 //#endregion
@@ -13325,7 +13410,7 @@ function ThePlugin(app) {
 				tracks = new SqliteTrackStore({
 					file: join(dataDir, "tracks.db"),
 					resolution: toNumber(resolution) ?? DEFAULT_RESOLUTION,
-					retention: (toNumber(config.retentionDays) ?? 0) * 24 * 60 * 60 * 1e3,
+					retention: 0,
 					segmentGap
 				}, app.debug);
 			} catch (err) {
@@ -13579,13 +13664,6 @@ function ThePlugin(app) {
 					title: "Track resolution (milliseconds)",
 					default: DEFAULT_RESOLUTION
 				},
-				retentionDays: {
-					type: "integer",
-					minimum: 0,
-					title: "Days of the own vessel's track to keep",
-					description: "Positions older than this are deleted. 0, the default, keeps everything — a track is worth more the longer it goes back, and a year of one vessel at the default resolution is a few megabytes.",
-					default: 0
-				},
 				aisRetentionDays: {
 					type: "integer",
 					minimum: 0,