@signalk/tracks-plugin 3.0.0-beta.0 → 3.0.0-beta.2

package/dist/index.js

@@ -1,10 +1,10 @@
 import { Temporal } from "@js-temporal/polyfill";
 import { join } from "node:path";
-import { BehaviorSubject, ReplaySubject, Subject, combineLatest, connectable, firstValueFrom } from "rxjs";
-import { map, scan, startWith, throttleTime } from "rxjs/operators";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { DatabaseSync } from "node:sqlite";
+import { BehaviorSubject, ReplaySubject, Subject, combineLatest, connectable, firstValueFrom } from "rxjs";
+import { map, scan, startWith, throttleTime } from "rxjs/operators";
 //#region \0rolldown/runtime.js
 var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
 //#endregion
@@ -161,6 +161,42 @@ function thin(points, resolution) {
 	return result;
 }
 /**
+* Thin to at most `maxPoints`, widening the spacing until the budget fits.
+*
+* A budget, not a fidelity contract: the caller has said how many points it can
+* afford to transfer and draw, whatever shape the track is. Returns the
+* resolution actually applied so the response can report it — a client that is
+* given 29 points instead of the 546 it would otherwise have received should be
+* able to see the spacing that produced them.
+*
+* Widening by doubling from the span-derived estimate rather than binary
+* searching: `thin` keeps the first point and the last unconditionally, so the
+* count is not a clean function of the spacing and an exact solve would be
+* false precision. Two or three passes settle it in practice.
+*/
+function thinToBudget(points, maxPoints, resolution) {
+	const start = thin(points, resolution);
+	if (start.length <= maxPoints) return {
+		points: start,
+		resolution
+	};
+	if (maxPoints < 2) return {
+		points: start.slice(0, Math.max(0, maxPoints)),
+		resolution
+	};
+	const span = start[start.length - 1].timestamp - start[0].timestamp;
+	let spacing = Math.max(1, Math.ceil(span / (maxPoints - 1)), resolution ?? 0);
+	let result = thin(points, spacing);
+	while (result.length > maxPoints && spacing <= span) {
+		spacing *= 2;
+		result = thin(points, spacing);
+	}
+	return {
+		points: result,
+		resolution: spacing
+	};
+}
+/**
 * Split points into segments wherever recording stopped for longer than `gap`.
 *
 * A track is not one continuous line: a vessel that stops for the night, or
@@ -313,7 +349,7 @@ function resolveContext(vesselId, selfContext) {
 function createMatcher(params, selfPosition, debug) {
 	if (params.bbox) {
 		const inBounds = createInBounds(params.bbox);
-		return (track) => inBounds(lastPoint(track));
+		return params.intersects ? (track) => track.some(inBounds) : (track) => inBounds(lastPoint(track));
 	} else if (params.radius !== null) {
 		if (!selfPosition) throw new Error("No self position to calculate radius values");
 		const radius = params.radius;
@@ -322,142 +358,26 @@ function createMatcher(params, selfPosition, debug) {
 	}
 	return () => true;
 }
-//#endregion
-//#region src/tracks.ts
 /**
-* The in-memory store: a bounded sliding window of positions per context,
-* held in RxJS accumulators and lost on restart. `bootstrapSelfTrack()` in
-* index.ts is what re-hydrates it from a History provider at startup.
+* A history row is `[timestamp, position]`. Both encodings are legal: the
+* History API types a value as `unknown` and its own comment names "objects
+* (like navigation.position)" alongside primitives, so signalk-questdb returns
+* `{latitude, longitude}` and signalk-to-influxdb2 returns `[lon, lat]`.
+* Accept both — neither is an error, so rejecting one silently yields an empty
+* track rather than a failure anybody can see.
 */
-var Tracks = class {
-	tracks = {};
-	debug;
-	config;
-	constructor(config, debug) {
-		if (debug.enabled) debug(JSON.stringify(config));
-		this.config = config;
-		this.debug = debug;
-	}
-	newPosition(context, position, timestamp) {
-		this.getAccumulator(context)?.nextLatLngTuple(position, timestamp);
-	}
-	initialTrack(context, track, timestamps) {
-		this.getAccumulator(context)?.setInitialTrack(track, timestamps);
-	}
-	getAccumulator(context, createIfMissing = true) {
-		if (context.indexOf("vessels.") === -1 && context.indexOf("aircraft.") === -1) return;
-		let result = this.tracks[context];
-		if (!result && createIfMissing) {
-			const accParams = this.config.fetchInitialTrack ? {
-				...this.config,
-				fetchTrackFor: context
-			} : { ...this.config };
-			result = this.tracks[context] = new TrackAccumulator(accParams);
-		}
-		return result;
-	}
-	get(context, window) {
-		return this.getTimed(context, window).then((points) => points.map(({ position }) => position));
-	}
-	/**
-	* Track points with their timestamps, optionally narrowed to a time window.
-	*
-	* Rejects with EmptyError if the stream completes without emitting; the route
-	* handlers turn that into the same 404 as an unknown context.
-	*/
-	getTimed(context, window) {
-		const accumulator = this.getAccumulator(context, false);
-		if (!accumulator) return Promise.reject(/* @__PURE__ */ new Error(`No track accumulator for ${context}`));
-		return firstValueFrom(accumulator.timedTrack).then((points) => window ? points.filter(({ timestamp }) => timestamp >= window.from && (window.inclusiveEnd ? timestamp <= window.to : timestamp < window.to)) : points);
-	}
-	getAllTracks(query) {
-		return Promise.all(Object.keys(this.tracks).map((context) => this.getTimed(context, query?.window).then((points) => ({
-			context,
-			track: thin(points, query?.resolution).map(({ position }) => position)
-		}))));
-	}
-	async getFilteredTracks(params, selfPosition, debug, query) {
-		const timed = await this.getFilteredTimedTracks(params, selfPosition, debug, query);
-		return Object.fromEntries(Object.entries(timed).map(([context, points]) => [context, points.map(({ position }) => position)]));
-	}
-	/**
-	* The same filtering as `getFilteredTracks`, keeping each point's timestamp.
-	*
-	* The untimed form is derived from this one so the two cannot disagree about
-	* which tracks match — the filter runs once, here.
-	*/
-	async getFilteredTimedTracks(params, selfPosition, debug, query) {
-		this.debug(params);
-		this.debug("Self position", selfPosition);
-		const matcher = createMatcher(params, selfPosition, debug);
-		const contexts = Object.keys(this.tracks);
-		return (await Promise.all(contexts.map((context) => this.getTimed(context, query?.window).then((points) => ({
-			context,
-			points: thin(points, query?.resolution)
-		}))))).reduce((acc, { context, points }) => {
-			if (matcher(points.map(({ position }) => position))) acc[context] = points;
-			return acc;
-		}, {});
-	}
-	prune(maxAge) {
-		const cutoff = Date.now() - maxAge;
-		const deleted = [];
-		Object.entries(this.tracks).forEach(([key, value]) => {
-			if (value.latestLatLngTuple < cutoff) {
-				delete this.tracks[key];
-				deleted.push(key);
-			}
-		});
-		if (this.debug.enabled) this.debug(`deleted tracks for ${deleted.join(", ")}`);
-	}
-};
-var TrackAccumulator = class {
-	initialTrack = new BehaviorSubject([]);
-	input = new Subject();
-	latestLatLngTuple = 0;
-	accumulatedTrack;
-	/** Timestamped points, used to answer time-window queries. */
-	timedTrack;
-	/** Positions only — the long-standing public shape. */
-	track;
-	constructor({ resolution, pointsToKeep, fetchTrackFor }) {
-		this.accumulatedTrack = connectable(this.input.pipe(throttleTime(resolution), scan((acc, point) => {
-			acc.push(point);
-			return acc.slice(Math.max(0, acc.length - pointsToKeep));
-		}, []), startWith([])), {
-			connector: () => new ReplaySubject(1),
-			resetOnDisconnect: false
-		});
-		this.timedTrack = combineLatest([this.initialTrack, this.accumulatedTrack]).pipe(map(([initialTrack, accumulatedTrack]) => [...initialTrack, ...accumulatedTrack]));
-		this.track = this.timedTrack.pipe(map((points) => points.map(({ position }) => position)));
-		this.accumulatedTrack.connect();
-		if (fetchTrackFor) fetchTrack(fetchTrackFor).then((trackGEOJson) => {
-			const coordinates = trackGEOJson?.coordinates?.[0];
-			if (coordinates) this.initialTrack.next(coordinates.map((position) => ({
-				position,
-				timestamp: 0
-			})));
-		});
-	}
-	nextLatLngTuple(position, timestamp = Date.now()) {
-		this.input.next({
-			position,
-			timestamp
-		});
-		this.latestLatLngTuple = timestamp;
+var historyRowPosition = (row) => {
+	if (!Array.isArray(row) || row.length < 2) return;
+	const value = row[1];
+	if (Array.isArray(value) && value.length === 2 && Number.isFinite(value[0]) && Number.isFinite(value[1])) {
+		const [longitude, latitude] = value;
+		return [latitude, longitude];
 	}
-	setInitialTrack(track, timestamps) {
-		this.initialTrack.next(track.map((position, i) => ({
-			position,
-			timestamp: timestamps?.[i] ?? 0
-		})));
+	if (value && typeof value === "object" && "latitude" in value && "longitude" in value) {
+		const { latitude, longitude } = value;
+		if (Number.isFinite(latitude) && Number.isFinite(longitude)) return [latitude, longitude];
 	}
 };
-var fetchTrack = (context) => {
-	const contextParts = context.split(".");
-	if (contextParts[0] !== "vessels") return Promise.resolve({});
-	return fetch(`/signalk/v1/api/vessels/${contextParts[1]}/track`, { credentials: "include" }).then((r) => r.status === 200 ? r.json() : Promise.resolve({}));
-};
 //#endregion
 //#region src/trackProvider.ts
 /** v2 sends `[west, south, east, north]`; a bounds here is `[lat, lng]` corners. */
@@ -511,21 +431,33 @@ var totalMilliseconds = (duration) => duration.total({
 	unit: "milliseconds",
 	relativeTo: CALENDAR_REFERENCE
 });
+/**
+* Milliseconds back to a Duration, for reporting the spacing applied.
+*
+* Exact, not rounded to something tidier. A budget-derived spacing lands on
+* values like 24470ms, and `PT24.47S` does read as false precision — but the
+* field says what was applied, and a client re-querying with a rounded `PT24S`
+* gets 51 points where the budget it asked for was 50. Reproducibility beats
+* tidiness.
+*/
+var msToDuration = (ms) => Temporal.Duration.from({
+	milliseconds: Math.trunc(ms),
+	nanoseconds: Math.round((ms - Math.trunc(ms)) * 1e6)
+}).round({ largestUnit: "hour" });
 var toLngLat$1 = ([lat, lng]) => [lng, lat];
 /** Bounding box of the returned geometry, in GeoJSON order. */
 var boundsOf = (points) => {
 	if (points.length === 0) return;
-	let west = points[0].position[1];
-	let east = west;
 	let south = points[0].position[0];
 	let north = south;
+	const longitudes = [];
 	for (const { position } of points) {
 		const [lat, lng] = position;
-		if (lng < west) west = lng;
-		if (lng > east) east = lng;
 		if (lat < south) south = lat;
 		if (lat > north) north = lat;
+		longitudes.push(lng);
 	}
+	const [west, east] = longitudeSpan(longitudes);
 	return [
 		west,
 		south,
@@ -533,35 +465,78 @@ var boundsOf = (points) => {
 		north
 	];
 };
+/**
+* The narrower of the two longitude intervals covering these points.
+*
+* A plain min/max describes a track spanning the antimeridian as almost the
+* whole globe: two fixes at 179 and -179 are two degrees apart, but min/max
+* reports 358. RFC 7946 says a box crossing the antimeridian is written with
+* west greater than east, so the wrap-around interval is expressible — pick it
+* whenever it is the shorter of the two.
+*
+* The widest gap between adjacent longitudes is the part of the globe the track
+* does not cover, so the complement of that gap is the tightest interval that
+* does.
+*/
+var longitudeSpan = (longitudes) => {
+	const sorted = [...longitudes].sort((a, b) => a - b);
+	const min = sorted[0];
+	const max = sorted[sorted.length - 1];
+	let widestGap = 360 - (max - min);
+	let west = min;
+	let east = max;
+	for (let i = 1; i < sorted.length; i++) {
+		const gap = sorted[i] - sorted[i - 1];
+		if (gap > widestGap) {
+			widestGap = gap;
+			west = sorted[i];
+			east = sorted[i - 1];
+		}
+	}
+	return [west, east];
+};
 function createTrackProvider(deps) {
 	const matching = async (query) => {
 		const store = deps.store();
-		if (!store) return /* @__PURE__ */ new Map();
+		if (!store) return {
+			tracks: /* @__PURE__ */ new Map(),
+			resolution: void 0
+		};
 		const window = toTimeWindow(query);
 		const resolution = query.resolution ? totalMilliseconds(query.resolution) : void 0;
 		const wanted = query.contexts?.length ? new Set(query.contexts.map(resolveSelf(deps.selfContext()))) : void 0;
 		const collection = await store.getFilteredTimedTracks({
 			bbox: toGeoBounds(query.bbox),
-			radius: null
+			radius: null,
+			intersects: true
 		}, void 0, void 0, {
 			...window ? { window } : {},
 			...resolution === void 0 ? {} : { resolution }
 		});
 		const result = /* @__PURE__ */ new Map();
-		for (const [context, points] of Object.entries(collection)) {
-			if (wanted && !wanted.has(context)) continue;
+		const contexts = Object.entries(collection).filter(([context]) => !wanted || wanted.has(context));
+		const reconciled = await Promise.all(contexts.map(async ([context, stored]) => [context, await deps.reconcileWithHistory(context, stored, window, resolution)]));
+		for (const [context, points] of reconciled) {
 			if (points.length === 0) continue;
 			result.set(context, points);
 		}
-		return result;
+		return {
+			tracks: result,
+			resolution
+		};
 	};
 	return {
 		async getTracks(query) {
-			const matched = await matching(query);
+			const { tracks: matched, resolution: requested } = await matching(query);
 			const gap = deps.segmentGap();
 			const selfContext = deps.selfContext();
 			const features = [];
-			for (const [context, points] of matched) {
+			for (const [context, all] of matched) {
+				const { points, resolution: appliedMs } = query.maxPoints === void 0 ? {
+					points: all,
+					resolution: requested
+				} : thinToBudget(all, query.maxPoints, requested);
+				if (points.length === 0) continue;
 				const segments = segment(points, gap);
 				const bbox = boundsOf(points);
 				features.push({
@@ -577,7 +552,7 @@ function createTrackProvider(deps) {
 						to: new Date(points[points.length - 1].timestamp).toISOString(),
 						...bbox ? { bbox } : {},
 						pointCount: points.length,
-						...query.resolution ? { resolution: query.resolution.toString() } : {},
+						...appliedMs === void 0 ? {} : { resolution: msToDuration(appliedMs).toString() },
 						...query.times ? { coordTimes: segments.map(toIsoTimes) } : {}
 					}
 				});
@@ -588,7 +563,7 @@ function createTrackProvider(deps) {
 			};
 		},
 		async getTrackContexts(query) {
-			return [...(await matching(query)).keys()];
+			return [...(await matching(query)).tracks.keys()];
 		}
 	};
 }
@@ -11973,16 +11948,20 @@ var SqliteTrackStore = class {
 		}))));
 	}
 	/**
-	* Tracks whose last position matches the spatial predicate.
+	* Tracks matching the spatial predicate, which depends on who is asking.
+	*
+	* `intersects: false` — the v1 routes — matches a track's *last* position:
+	* "which vessels are near me now". `intersects: true` — the v2 Track API —
+	* matches a track that passed through the box at any point in the window,
+	* including one that has since left.
 	*
 	* Two filters run, and they are not redundant despite both testing bounds:
 	*
 	* - `contextsInBounds` asks the cell index which contexts have *any* position
 	*   near the box. It is a cheap prefilter that keeps the query off every row
 	*   in the table, and it decides nothing on its own.
-	* - `matcher` — the same predicate the in-memory store uses — then tests each
-	*   track's *last* position, which is what the endpoint actually means by
-	*   "in this box". That test is authoritative.
+	* - `matcher` — the same predicate the in-memory store uses — then applies
+	*   whichever rule the caller asked for. That test is authoritative.
 	*
 	* Because `matcher` has the final say, dropping the exact-bounds check inside
 	* `contextsInBounds` does not change any result; it only widens the candidate
@@ -12046,10 +12025,16 @@ var SqliteTrackStore = class {
 		if (current.length > 0) result.push(current);
 		return result;
 	}
-	prune(maxAge) {
+	prune(maxAge, keep) {
 		const cutoff = Date.now() - maxAge;
-		this.db.prepare("DELETE FROM positions WHERE context IN (SELECT context FROM positions GROUP BY context HAVING MAX(timestamp) < ?)").run(cutoff);
-		if (this.retention > 0) this.db.prepare("DELETE FROM positions WHERE timestamp < ?").run(Date.now() - this.retention);
+		const dropped = this.db.prepare("SELECT context FROM positions GROUP BY context HAVING MAX(timestamp) < ? AND context IS NOT ?").all(cutoff, keep ?? null);
+		this.db.prepare("DELETE FROM positions WHERE context IN (SELECT context FROM positions GROUP BY context HAVING MAX(timestamp) < ?) AND context IS NOT ?").run(cutoff, keep ?? null);
+		for (const { context } of dropped) this.lastStored.delete(context);
+		if (this.retention > 0) {
+			const oldest = Date.now() - this.retention;
+			if (keep === void 0) this.db.prepare("DELETE FROM positions WHERE timestamp < ?").run(oldest);
+			else this.db.prepare("DELETE FROM positions WHERE timestamp < ? AND context IS ?").run(oldest, keep);
+		}
 	}
 	close() {
 		this.db.close();
@@ -12283,11 +12268,11 @@ var SourceWatch = class {
 };
 //#endregion
 //#region src/stateGate.ts
-/**
-* Off unless a user opts in, per the request and because the states worth
-* pausing on depend on how a boat is used.
-*/
-var DEFAULT_PAUSE_STATES = [];
+var DEFAULT_PAUSE_STATES = [
+	"moored",
+	"not-under-way",
+	"aground"
+];
 /**
 * The states a boat is plausibly parked in, offered in the plugin UI.
 *
@@ -12352,25 +12337,150 @@ var StateGate = class {
 	}
 };
 //#endregion
-//#region src/index.ts
+//#region src/tracks.ts
 /**
-* Resolve the effective source, honouring the setting this replaced.
+* The in-memory store: a bounded sliding window of positions per context, held
+* in RxJS accumulators and lost on restart.
 *
-* `bootstrapFromHistory` shipped as a boolean defaulting to true, so an
-* installed plugin has it saved in its config either way. Reading `source`
-* first and only then falling back keeps those installs working: an explicit
-* `false` still means "do not touch the History API", and everything else
-* lands on the old default of `history`.
+* No longer used by the plugin, which always records to SQLite. It remains as
+* the client-side `TrackAccumulator` this package exports, where a browser
+* holding one vessel's recent track in memory is exactly the right shape.
 */
-var resolveSource = (config) => {
-	if (config.source) return config.source;
-	return config.bootstrapFromHistory === false ? "memory" : "history";
+var Tracks = class {
+	tracks = {};
+	debug;
+	config;
+	constructor(config, debug) {
+		if (debug.enabled) debug(JSON.stringify(config));
+		this.config = config;
+		this.debug = debug;
+	}
+	newPosition(context, position, timestamp) {
+		this.getAccumulator(context)?.nextLatLngTuple(position, timestamp);
+	}
+	initialTrack(context, track, timestamps) {
+		this.getAccumulator(context)?.setInitialTrack(track, timestamps);
+	}
+	getAccumulator(context, createIfMissing = true) {
+		if (context.indexOf("vessels.") === -1 && context.indexOf("aircraft.") === -1) return;
+		let result = this.tracks[context];
+		if (!result && createIfMissing) {
+			const accParams = this.config.fetchInitialTrack ? {
+				...this.config,
+				fetchTrackFor: context
+			} : { ...this.config };
+			result = this.tracks[context] = new TrackAccumulator(accParams);
+		}
+		return result;
+	}
+	get(context, window) {
+		return this.getTimed(context, window).then((points) => points.map(({ position }) => position));
+	}
+	/**
+	* Track points with their timestamps, optionally narrowed to a time window.
+	*
+	* Rejects with EmptyError if the stream completes without emitting; the route
+	* handlers turn that into the same 404 as an unknown context.
+	*/
+	getTimed(context, window) {
+		const accumulator = this.getAccumulator(context, false);
+		if (!accumulator) return Promise.reject(/* @__PURE__ */ new Error(`No track accumulator for ${context}`));
+		return firstValueFrom(accumulator.timedTrack).then((points) => window ? points.filter(({ timestamp }) => timestamp >= window.from && (window.inclusiveEnd ? timestamp <= window.to : timestamp < window.to)) : points);
+	}
+	getAllTracks(query) {
+		return Promise.all(Object.keys(this.tracks).map((context) => this.getTimed(context, query?.window).then((points) => ({
+			context,
+			track: thin(points, query?.resolution).map(({ position }) => position)
+		}))));
+	}
+	async getFilteredTracks(params, selfPosition, debug, query) {
+		const timed = await this.getFilteredTimedTracks(params, selfPosition, debug, query);
+		return Object.fromEntries(Object.entries(timed).map(([context, points]) => [context, points.map(({ position }) => position)]));
+	}
+	/**
+	* The same filtering as `getFilteredTracks`, keeping each point's timestamp.
+	*
+	* The untimed form is derived from this one so the two cannot disagree about
+	* which tracks match — the filter runs once, here.
+	*/
+	async getFilteredTimedTracks(params, selfPosition, debug, query) {
+		this.debug(params);
+		this.debug("Self position", selfPosition);
+		const matcher = createMatcher(params, selfPosition, debug);
+		const contexts = Object.keys(this.tracks);
+		return (await Promise.all(contexts.map((context) => this.getTimed(context, query?.window).then((points) => ({
+			context,
+			points: thin(points, query?.resolution)
+		}))))).reduce((acc, { context, points }) => {
+			if (matcher(points.map(({ position }) => position))) acc[context] = points;
+			return acc;
+		}, {});
+	}
+	prune(maxAge, keep) {
+		const cutoff = Date.now() - maxAge;
+		const deleted = [];
+		Object.entries(this.tracks).forEach(([key, value]) => {
+			if (key !== keep && value.latestLatLngTuple < cutoff) {
+				delete this.tracks[key];
+				deleted.push(key);
+			}
+		});
+		if (this.debug.enabled) this.debug(`deleted tracks for ${deleted.join(", ")}`);
+	}
 };
+var TrackAccumulator = class {
+	initialTrack = new BehaviorSubject([]);
+	input = new Subject();
+	latestLatLngTuple = 0;
+	accumulatedTrack;
+	/** Timestamped points, used to answer time-window queries. */
+	timedTrack;
+	/** Positions only — the long-standing public shape. */
+	track;
+	constructor({ resolution, pointsToKeep, fetchTrackFor }) {
+		this.accumulatedTrack = connectable(this.input.pipe(throttleTime(resolution), scan((acc, point) => {
+			acc.push(point);
+			return acc.slice(Math.max(0, acc.length - pointsToKeep));
+		}, []), startWith([])), {
+			connector: () => new ReplaySubject(1),
+			resetOnDisconnect: false
+		});
+		this.timedTrack = combineLatest([this.initialTrack, this.accumulatedTrack]).pipe(map(([initialTrack, accumulatedTrack]) => [...initialTrack, ...accumulatedTrack]));
+		this.track = this.timedTrack.pipe(map((points) => points.map(({ position }) => position)));
+		this.accumulatedTrack.connect();
+		if (fetchTrackFor) fetchTrack(fetchTrackFor).then((trackGEOJson) => {
+			const coordinates = trackGEOJson?.coordinates?.[0];
+			if (coordinates) this.initialTrack.next(coordinates.map((position) => ({
+				position,
+				timestamp: 0
+			})));
+		});
+	}
+	nextLatLngTuple(position, timestamp = Date.now()) {
+		this.input.next({
+			position,
+			timestamp
+		});
+		this.latestLatLngTuple = timestamp;
+	}
+	setInitialTrack(track, timestamps) {
+		this.initialTrack.next(track.map((position, i) => ({
+			position,
+			timestamp: timestamps?.[i] ?? 0
+		})));
+	}
+};
+var fetchTrack = (context) => {
+	const contextParts = context.split(".");
+	if (contextParts[0] !== "vessels") return Promise.resolve({});
+	return fetch(`/signalk/v1/api/vessels/${contextParts[1]}/track`, { credentials: "include" }).then((r) => r.status === 200 ? r.json() : Promise.resolve({}));
+};
+//#endregion
+//#region src/index.ts
 var toLngLat = ([lat, lng]) => [lng, lat];
 var DEFAULT_RESOLUTION = 6e4;
-var DEFAULT_POINTS_TO_KEEP = 120;
-var DEFAULT_MAX_AGE = 600;
-var DEFAULT_MAX_RADIUS = 5e4;
+var DEFAULT_AIS_RETENTION_DAYS = 30;
+var PRUNE_INTERVAL_MS = 36e5;
 var DEFAULT_SEGMENT_GAP_MINUTES = 0;
 var SOURCE_STATUS_INTERVAL_MS = 3e4;
 /**
@@ -12392,10 +12502,6 @@ var HISTORY_QUERY_TIMEOUT_MS = 5e3;
 * `duration` or `timespan` reaches further.
 */
 var WINDOWLESS_HISTORY_SPAN_MS = 864e5;
-var BOOTSTRAP_INITIAL_DELAY = 5e3;
-var BOOTSTRAP_RETRY_DELAY = 15e3;
-var BOOTSTRAP_MAX_ATTEMPTS = 18;
-var BOOTSTRAP_MAX_NO_PROVIDER = 3;
 /**
 * Config values arrive from the plugin UI as numbers, but a hand-edited
 * settings file can supply strings. Accept both, reject anything non-finite so
@@ -12412,27 +12518,7 @@ var notAvailable = (res) => {
 	res.status(404);
 	res.json({ message: "Tracks API not available because tracks plugin is not enabled" });
 };
-var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 var errorDetail = (err) => err instanceof Error && err.stack ? err.stack : String(err);
-var isNoProviderError = (err) => {
-	const text = String(err);
-	return text.includes("No history") && text.includes("provider");
-};
-/**
-* A history row is `[timestamp, position]`. Providers disagree on how the
-* position is encoded: signalk-questdb returns `{latitude, longitude}`, while
-* a `[lon, lat]` pair is the shape the History API's own docs describe. Accept
-* both — rejecting either silently bootstraps an empty track.
-*/
-var historyRowPosition = (row) => {
-	if (!Array.isArray(row) || row.length < 2) return;
-	const value = row[1];
-	if (Array.isArray(value) && value.length === 2 && typeof value[0] === "number" && typeof value[1] === "number") return [value[1], value[0]];
-	if (value && typeof value === "object" && "latitude" in value && "longitude" in value) {
-		const { latitude, longitude } = value;
-		if (typeof latitude === "number" && typeof longitude === "number") return [latitude, longitude];
-	}
-};
 /**
 * A window covering everything the store holds, up to now.
 *
@@ -12532,92 +12618,6 @@ var historyRowTimestamp = (row) => {
 	const parsed = Date.parse(raw);
 	return Number.isNaN(parsed) ? 0 : parsed;
 };
-async function bootstrapSelfTrack(app, tracks, config, glitchFilter) {
-	const { debug } = app;
-	const getHistoryApi = app.getHistoryApi;
-	if (!getHistoryApi) {
-		debug("getHistoryApi not available on server, skipping track bootstrap");
-		return;
-	}
-	if (!app.selfContext) {
-		debug("selfContext not available, skipping track bootstrap");
-		return;
-	}
-	const configuredProvider = app.config?.settings?.historyApi?.defaultProvider;
-	const resolution = toNumber(config.resolution) ?? DEFAULT_RESOLUTION;
-	const timespanMs = resolution * (toNumber(config.pointsToKeep) ?? DEFAULT_POINTS_TO_KEEP);
-	const resolutionSecs = Math.max(1, Math.round(resolution / 1e3));
-	const timespanMinutes = Math.round(timespanMs / 1e3 / 60);
-	debug(`Track bootstrap: requesting ${timespanMinutes} minutes of history at ${resolutionSecs}s resolution (max ${BOOTSTRAP_MAX_ATTEMPTS} attempts)`);
-	let noProviderCount = 0;
-	for (let attempt = 1; attempt <= BOOTSTRAP_MAX_ATTEMPTS; attempt++) {
-		const delay = attempt === 1 ? BOOTSTRAP_INITIAL_DELAY : BOOTSTRAP_RETRY_DELAY;
-		debug(`Track bootstrap attempt ${attempt}/${BOOTSTRAP_MAX_ATTEMPTS}, waiting ${delay / 1e3}s...`);
-		await sleep(delay);
-		try {
-			const historyApi = await getHistoryApi(configuredProvider);
-			noProviderCount = 0;
-			const to = /* @__PURE__ */ new Date();
-			const from = new Date(to.getTime() - timespanMs);
-			const response = await historyApi.getValues({
-				context: app.selfContext,
-				from: Temporal.Instant.from(from.toISOString()),
-				to: Temporal.Instant.from(to.toISOString()),
-				pathSpecs: [{
-					path: "navigation.position",
-					aggregate: "first"
-				}],
-				resolution: resolutionSecs
-			});
-			if (response?.data && response.data.length > 0) {
-				const positions = [];
-				const timestamps = [];
-				let dropped = 0;
-				for (const row of response.data) {
-					const position = historyRowPosition(row);
-					if (position) {
-						const timestamp = historyRowTimestamp(row);
-						if (timestamp === 0) {
-							dropped++;
-							continue;
-						}
-						if (!glitchFilter.accept(app.selfContext, position, timestamp)) {
-							dropped++;
-							continue;
-						}
-						positions.push(position);
-						timestamps.push(timestamp);
-					}
-				}
-				if (dropped > 0) debug(`Track bootstrap discarded ${dropped} position(s) as glitches`);
-				if (positions.length > 0) {
-					tracks.initialTrack(app.selfContext, positions, timestamps);
-					debug(`Track bootstrap complete: loaded ${positions.length} positions for self (${timespanMinutes} min window) on attempt ${attempt}`);
-					return;
-				}
-			}
-			debug(`History API returned no position data on attempt ${attempt}/${BOOTSTRAP_MAX_ATTEMPTS}; the configured provider may not have registered yet`);
-			if (attempt === BOOTSTRAP_MAX_ATTEMPTS) {
-				debug("History API returned no position data for bootstrap");
-				return;
-			}
-			continue;
-		} catch (err) {
-			if (isNoProviderError(err)) {
-				noProviderCount++;
-				debug(`Track bootstrap attempt ${attempt}/${BOOTSTRAP_MAX_ATTEMPTS}: no history provider registered yet (${noProviderCount}/${BOOTSTRAP_MAX_NO_PROVIDER})`);
-				if (noProviderCount >= BOOTSTRAP_MAX_NO_PROVIDER) {
-					debug(`No history provider registered after ${BOOTSTRAP_MAX_NO_PROVIDER} consecutive checks — no provider plugin appears to be installed. Giving up.`);
-					return;
-				}
-			} else {
-				noProviderCount = 0;
-				debug(`Track bootstrap attempt ${attempt}/${BOOTSTRAP_MAX_ATTEMPTS} failed: ${errorDetail(err)}`);
-			}
-			if (attempt === BOOTSTRAP_MAX_ATTEMPTS) app.error(`Track bootstrap from History API failed after ${BOOTSTRAP_MAX_ATTEMPTS} attempts. Tracks will start empty and accumulate from live data.`);
-		}
-	}
-}
 function ThePlugin(app) {
 	let onStop = [];
 	let tracks = void 0;
@@ -12630,7 +12630,6 @@ function ThePlugin(app) {
 	* own.
 	*/
 	let storeResolution = DEFAULT_RESOLUTION;
-	let defaultMaxRadius = void 0;
 	const sourceWatch = new SourceWatch();
 	let glitchFilter = new GlitchFilter({ maxSpeedKnots: 100 });
 	let stateGate = new StateGate(app.selfContext, DEFAULT_PAUSE_STATES);
@@ -12651,25 +12650,28 @@ function ThePlugin(app) {
 	}
 	return {
 		start: function(config) {
-			const { resolution, pointsToKeep, maxAge, maxRadius } = config;
-			defaultMaxRadius = toNumber(maxRadius);
-			const source = resolveSource(config);
+			const { resolution } = config;
 			storeResolution = toNumber(config.resolution) ?? DEFAULT_RESOLUTION;
 			const segmentGapMinutes = toNumber(config.segmentGapMinutes) ?? DEFAULT_SEGMENT_GAP_MINUTES;
 			segmentGap = segmentGapMinutes > 0 ? segmentGapMinutes * 60 * 1e3 : 0;
 			glitchFilter = new GlitchFilter({ maxSpeedKnots: toNumber(config.maxSpeedKnots) ?? 100 });
 			stateGate = new StateGate(app.selfContext, Array.isArray(config.pauseWhenState) ? config.pauseWhenState : DEFAULT_PAUSE_STATES);
-			const dataDir = source === "sqlite" ? app.getDataDirPath?.() : void 0;
-			if (source === "sqlite" && !dataDir) app.error("source is sqlite but this server provides no plugin data directory; using memory instead");
-			tracks = dataDir ? new SqliteTrackStore({
-				file: join(dataDir, "tracks.db"),
-				resolution: toNumber(resolution) ?? DEFAULT_RESOLUTION,
-				retention: (toNumber(config.retentionDays) ?? 0) * 24 * 60 * 60 * 1e3,
-				segmentGap
-			}, app.debug) : new Tracks({
-				resolution: toNumber(resolution) ?? DEFAULT_RESOLUTION,
-				pointsToKeep: toNumber(pointsToKeep) ?? DEFAULT_POINTS_TO_KEEP
-			}, app.debug);
+			const dataDir = app.getDataDirPath?.();
+			if (!dataDir) {
+				app.error("This server provides no plugin data directory, so tracks cannot be recorded.");
+				return;
+			}
+			try {
+				tracks = new SqliteTrackStore({
+					file: join(dataDir, "tracks.db"),
+					resolution: toNumber(resolution) ?? DEFAULT_RESOLUTION,
+					retention: (toNumber(config.retentionDays) ?? 0) * 24 * 60 * 60 * 1e3,
+					segmentGap
+				}, app.debug);
+			} catch (err) {
+				app.error(`Could not open the track database in ${dataDir}: ${errorDetail(err)}`);
+				return;
+			}
 			onStop.push(app.streambundle.getBus("navigation.position").onValue((update) => {
 				if (!update.value || update.value.latitude == null || update.value.longitude == null) return;
 				sourceWatch.add(update.context, update.$source);
@@ -12680,8 +12682,10 @@ function ThePlugin(app) {
 				if (!glitchFilter.accept(update.context, position, timestamp ?? Date.now())) return;
 				tracks?.newPosition(update.context, position, timestamp);
 			}));
-			const theMaxAge = toNumber(maxAge) ?? DEFAULT_MAX_AGE;
-			const pruneInterval = setInterval(() => tracks?.prune(theMaxAge * 1e3), theMaxAge * 1e3 / 2);
+			const aisRetentionMs = (toNumber(config.aisRetentionDays) ?? DEFAULT_AIS_RETENTION_DAYS) * 24 * 60 * 60 * 1e3;
+			const pruneInterval = setInterval(() => {
+				tracks?.prune(aisRetentionMs > 0 ? aisRetentionMs : Infinity, app.selfContext);
+			}, PRUNE_INTERVAL_MS);
 			onStop.push(() => {
 				clearInterval(pruneInterval);
 			});
@@ -12699,11 +12703,13 @@ function ThePlugin(app) {
 			app.registerTrackApiProvider?.(createTrackProvider({
 				store: () => tracks,
 				selfContext: () => app.selfContext,
-				segmentGap: () => segmentGap
+				segmentGap: () => segmentGap,
+				reconcileWithHistory: async (context, stored, window, resolutionMs) => {
+					const effective = resolutionMs ?? storeResolution;
+					const history = await historyPositions(app, context, window ?? windowSpanning(stored, WINDOWLESS_HISTORY_SPAN_MS), effective, app.debug);
+					return history.points.length ? reconcile(history.points, stored, history.resolutionMs).positions : stored;
+				}
 			}));
-			if (source === "history") bootstrapSelfTrack(app, tracks, config, glitchFilter).catch((err) => {
-				app.error(`Unexpected error in track bootstrap: ${errorDetail(err)}`);
-			});
 		},
 		stop: function() {
 			onStop.forEach((f) => {
@@ -12721,6 +12727,8 @@ function ThePlugin(app) {
 				tracks?.close?.();
 			} catch (err) {
 				app.error(err);
+			} finally {
+				tracks = void 0;
 			}
 		},
 		signalKApiRoutes: function(router) {
@@ -12784,7 +12792,7 @@ function ThePlugin(app) {
 					res.json({ message: err instanceof TimeWindowError ? err.message : "Invalid query parameters" });
 					return;
 				}
-				const params = validateParameters(req.query, defaultMaxRadius);
+				const params = validateParameters(req.query, void 0);
 				const selfPosition = getVesselPosition();
 				(query.times ? tracks.getFilteredTimedTracks(params, selfPosition, app.debug, query).then((tc) => Object.entries(tc).reduce((acc, [context, points]) => {
 					const segments = segment(points, segmentGap);
@@ -12816,55 +12824,31 @@ function ThePlugin(app) {
 		getTracks: () => tracks,
 		id: "tracks",
 		name: "Tracks",
-		description: "Accumulate tracks in memory for the track API implementation",
+		enabledByDefault: true,
+		description: "Record vessel tracks to SQLite and serve them through the track API",
 		schema: {
 			type: "object",
 			properties: {
 				resolution: {
 					type: "integer",
+					minimum: 0,
 					title: "Track resolution (milliseconds)",
 					default: DEFAULT_RESOLUTION
 				},
-				pointsToKeep: {
-					type: "integer",
-					title: "Points to keep",
-					description: "How many trackpoints to keep for each track",
-					default: DEFAULT_POINTS_TO_KEEP
-				},
-				maxAge: {
-					type: "integer",
-					title: "Maximum idle time (seconds)",
-					description: "Tracks with no updates longer than this are removed",
-					default: DEFAULT_MAX_AGE
-				},
-				maxRadius: {
-					type: "integer",
-					title: "Maximum Radius (meters) ",
-					description: "Include only vessels with position within this range. 0= all vessels",
-					default: DEFAULT_MAX_RADIUS
-				},
-				source: {
-					type: "string",
-					title: "Where tracks come from after a restart",
-					description: "In memory only: start empty and accumulate from live positions. History API: refill on startup from a history provider such as signalk-to-influxdb2 or signalk-questdb. SQLite: record positions to a database file so they survive a restart with no other plugin required.",
-					enum: [
-						"memory",
-						"history",
-						"sqlite"
-					],
-					enumNames: [
-						"In memory only",
-						"Load from the History API on startup",
-						"Record to a SQLite database"
-					],
-					default: "history"
-				},
 				retentionDays: {
 					type: "integer",
-					title: "Days of track history to keep (SQLite only)",
-					description: "Positions older than this are deleted. 0 keeps everything.",
+					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,
+					title: "Days to keep another vessel after its last fix",
+					description: "The own vessel is never removed. Other vessels are: a busy harbour puts hundreds of AIS targets past the receiver in a day, and keeping all of them forever is rarely what anyone wants. 0 keeps every vessel indefinitely.",
+					default: DEFAULT_AIS_RETENTION_DAYS
+				},
 				segmentGapMinutes: {
 					type: "integer",
 					title: "Split a track after this many minutes without a fix",
@@ -12893,6 +12877,6 @@ function ThePlugin(app) {
 	};
 }
 //#endregion
-export { TrackAccumulator, Tracks, ThePlugin as default, resolveSource };
+export { TrackAccumulator, Tracks, ThePlugin as default };
 
 //# sourceMappingURL=index.js.map