@signalk/tracks-plugin 3.0.2 → 3.1.0

package/dist/harness.test-utils.d.ts

@@ -112,6 +112,11 @@ export interface HarnessOptions {
         };
         /** Fail the windowed read, leaving the provider unable to answer at all. */
         getValuesRejects?: boolean;
+        /**
+         * Answer `getValues` as a real provider does with `aggregate: 'first'`:
+         * only the earliest of `rows` in each bucket of the asked resolution.
+         */
+        aggregatesFirst?: boolean;
         /**
          * Reject `getHistoryApi` itself, as the server does when no provider is
          * registered — the default install, and not an outage.

package/dist/index.js

@@ -1,4 +1,4 @@
-import { _ as TimeWindowError, a as createDistanceTo, b as thin, c as gpxFilename, d as rfc8187, g as validateParameters, h as unwrapString, i as contextName, l as historyRowPosition, m as trackLabel, n as SelfPositionUnavailableError, p as toIsoTimes, r as asciiFilename, s as createMatcher, t as QueryParameterError, u as resolveContext, v as parseTrackQuery, x as thinToBudget, y as segment } from "./utils-OGjP1B0D.js";
+import { C as uncoveredBetween, S as thinToBudget, _ as validateParameters, a as contextName, b as segment, c as createMatcher, d as resolveContext, f as rfc8187, g as unwrapString, h as trackLabel, i as clipToBounds, l as gpxFilename, m as toIsoTimes, n as SelfPositionUnavailableError, o as createDistanceTo, r as asciiFilename, s as createInBounds, t as QueryParameterError, u as historyRowPosition, v as TimeWindowError, x as thin, y as parseTrackQuery } from "./utils-CGIGp4Xf.js";
 import { Temporal } from "@js-temporal/polyfill";
 import { join } from "node:path";
 import { Worker } from "node:worker_threads";
@@ -241,19 +241,31 @@ function createTrackProvider(deps) {
 		};
 		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 wanted = query.contexts?.length ? [...new Set(query.contexts.map(resolveSelf(deps.selfContext())))] : void 0;
+		const bounds = toGeoBounds(query.bbox);
+		const clipTo = query.clip === true ? bounds : null;
 		const collection = await store.getFilteredTimedTracks({
-			bbox: toGeoBounds(query.bbox),
+			bbox: bounds,
 			radius: null,
-			intersects: true
+			intersects: true,
+			...wanted ? { contexts: wanted } : {},
+			...clipTo ? { clip: true } : {}
 		}, void 0, void 0, {
 			...window ? { window } : {},
-			...resolution === void 0 ? {} : { resolution }
+			...resolution === void 0 || bounds ? {} : { resolution }
 		});
+		const fromHistory = [...await deps.historyContexts(window)].filter((context) => !(context in collection) && (!wanted || wanted.includes(context)));
+		const inBounds = bounds ? createInBounds(bounds) : void 0;
+		const storedFor = async (context) => {
+			const points = await store.getTimed(context, window).catch(() => []);
+			return bounds ? points : thin(points, resolution);
+		};
+		const historyResolution = bounds ? void 0 : resolution;
 		const result = /* @__PURE__ */ new Map();
-		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) {
+		const reconciled = await Promise.all([...Object.entries(collection).map(async ([context, stored]) => [context, await deps.reconcileWithHistory(context, stored, window, historyResolution)]), ...fromHistory.map(async (context) => [context, await deps.reconcileWithHistory(context, await storedFor(context), window, historyResolution)])]);
+		for (const [context, reconciledPoints] of reconciled) {
+			if (inBounds && !reconciledPoints.some(({ position }) => inBounds(position))) continue;
+			const points = clipTo ? thin(clipToBounds(reconciledPoints, clipTo), resolution) : bounds ? thin(reconciledPoints, resolution) : reconciledPoints;
 			if (points.length === 0) continue;
 			result.set(context, points);
 		}
@@ -792,12 +804,29 @@ function reconcile(history, stored, resolution) {
 	for (const point of stored) if (!covered.has(bucketOf(point.timestamp, resolution))) positions.push(point);
 	positions.sort((a, b) => a.timestamp - b.timestamp);
 	return {
-		positions,
+		positions: measuredFromHistory(positions, history),
 		fromHistory,
 		fromStore: positions.length - fromHistory
 	};
 }
 /**
+* A stored point's `pauseBefore` was measured over the stored points thinning
+* dropped before it. Where a history point now comes right before it, history
+* covered part of that time, so the pause is at most the time since that
+* bucket, and at most the longest step the store recorded, whichever is less.
+*/
+function measuredFromHistory(positions, history) {
+	const fromHistory = new Set(history);
+	return positions.map((point, i) => {
+		const before = positions[i - 1];
+		if (point.pauseBefore === void 0 || before === void 0 || !fromHistory.has(before)) return point;
+		return {
+			...point,
+			pauseBefore: Math.min(point.pauseBefore, uncoveredBetween(before, point))
+		};
+	});
+}
+/**
 * Fallback when no bucket width is known: history covers its own time span,
 * and the store supplies whatever falls outside it.
 *
@@ -818,7 +847,7 @@ function reconcileByExtent(history, stored) {
 	}
 	const outside = stored.filter((p) => p.timestamp < first || p.timestamp > last);
 	return {
-		positions: [...history, ...outside].sort((a, b) => a.timestamp - b.timestamp),
+		positions: measuredFromHistory([...history, ...outside].sort((a, b) => a.timestamp - b.timestamp), history),
 		fromHistory: history.length,
 		fromStore: outside.length
 	};
@@ -1398,7 +1427,8 @@ var Tracks = class {
 		this.debug(params);
 		this.debug("Self position", selfPosition);
 		const matcher = createMatcher(params, selfPosition, debug);
-		const contexts = Object.keys(this.tracks);
+		const requested = params.contexts ? new Set(params.contexts) : void 0;
+		const contexts = Object.keys(this.tracks).filter((context) => !requested || requested.has(context));
 		return (await Promise.all(contexts.map((context) => this.getTimed(context, query?.window).then((points) => ({
 			context,
 			points: thin(points, query?.resolution)
@@ -1627,6 +1657,8 @@ function withTimeout(promise, ms) {
 		});
 	});
 }
+/** A provider's context list as a set, with the `vessels.self` spelling resolved. */
+var toContextSet = (listed, selfContext) => new Set((listed ?? []).filter((c) => typeof c === "string").map((c) => c === "vessels.self" ? selfContext : c));
 /**
 * Whether a history provider holds anything at all for a context.
 *
@@ -1650,7 +1682,7 @@ async function historyKnowsContext(app, context, debug, cache) {
 			const contexts = withTimeout(getHistoryApi(app.config?.settings?.historyApi?.defaultProvider).then((historyApi) => historyApi.getContexts ? historyApi.getContexts({
 				from: Temporal.Instant.from((/* @__PURE__ */ new Date(EXISTENCE_PROBE_FROM_MS)).toISOString()),
 				to: Temporal.Instant.from(new Date(now).toISOString())
-			}) : []).then((listed) => new Set((listed ?? []).filter((c) => typeof c === "string").map((c) => c === "vessels.self" ? app.selfContext : c))), HISTORY_QUERY_TIMEOUT_MS);
+			}) : []).then((listed) => toContextSet(listed, app.selfContext)), HISTORY_QUERY_TIMEOUT_MS);
 			const entry = {
 				at: now,
 				contexts
@@ -1670,6 +1702,38 @@ async function historyKnowsContext(app, context, debug, cache) {
 	}
 }
 /**
+* Contexts a history provider holds data for within a window, or none.
+*
+* What lets the v2 provider return a vessel the store has never seen, or match
+* a box on positions only history recorded: the store is often far younger
+* than the provider. Best-effort like every other provider call: no provider,
+* a provider without `getContexts`, an error or a hang all answer with no
+* contexts, and the store answers alone.
+*
+* A window with no start is asked from the epoch, for the same reason the
+* existence probe is; without any window the probe's cached all-time list is
+* reused rather than asking again per query.
+*/
+async function historyContextsIn(app, window, debug, cache) {
+	const getHistoryApi = app.getHistoryApi;
+	if (!getHistoryApi) return /* @__PURE__ */ new Set();
+	try {
+		if (!window) {
+			await historyKnowsContext(app, app.selfContext, debug, cache);
+			return await cache.current?.contexts ?? /* @__PURE__ */ new Set();
+		}
+		const historyApi = await withTimeout(getHistoryApi(app.config?.settings?.historyApi?.defaultProvider), HISTORY_QUERY_TIMEOUT_MS);
+		if (!historyApi.getContexts) return /* @__PURE__ */ new Set();
+		return toContextSet(await withTimeout(historyApi.getContexts({
+			from: Temporal.Instant.from(new Date(Math.max(window.from, EXISTENCE_PROBE_FROM_MS)).toISOString()),
+			to: Temporal.Instant.from(new Date(window.to).toISOString())
+		}), HISTORY_QUERY_TIMEOUT_MS), app.selfContext);
+	} catch (err) {
+		if (debug.enabled) debug(`History contexts unavailable: ${errorDetail(err)}`);
+		return /* @__PURE__ */ new Set();
+	}
+}
+/**
 * Positions a history provider holds for a window, or none.
 *
 * Best-effort by design: a provider that is absent, slow, or failing must not
@@ -1700,7 +1764,7 @@ async function historyPositions(app, context, window, resolutionMs, debug) {
 	try {
 		const response = await withTimeout(historyApi.getValues({
 			context,
-			from: Temporal.Instant.from(new Date(window.from).toISOString()),
+			from: Temporal.Instant.from(new Date(Math.max(window.from, EXISTENCE_PROBE_FROM_MS)).toISOString()),
 			to: Temporal.Instant.from(new Date(window.to).toISOString()),
 			pathSpecs: [{
 				path: "navigation.position",
@@ -1716,7 +1780,8 @@ async function historyPositions(app, context, window, resolutionMs, debug) {
 				const withinEnd = window.inclusiveEnd ? timestamp <= window.to : timestamp < window.to;
 				if (timestamp >= window.from && withinEnd) points.push({
 					position,
-					timestamp
+					timestamp,
+					span: applied
 				});
 			}
 		}
@@ -1867,6 +1932,7 @@ function ThePlugin(app) {
 				selfContext: () => app.selfContext,
 				segmentGap: () => segmentGap,
 				contextName: (context) => contextName(context, remembering(() => tracks)),
+				historyContexts: (window) => historyContextsIn(app, window, app.debug, knownContexts),
 				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);