@signalk/tracks-plugin 3.3.0 → 3.4.0

package/README.md

@@ -49,17 +49,22 @@ other track, filtered by vessel, time window and area, but as a feature of its o
 it names a vessel the plugin also records. It is never merged with a history provider's data,
 never removed by the retention settings, and never returned by the v1 routes, which answer
 where vessels are now. Its own name and any other properties it was posted with come back as
-posted. It carries `imported: true`, which a recorded track does not, so a client drawing a
-vessel's recording can leave the import out of it.
+posted. It carries `imported`, the time it was stored, which a recorded track does not, so a
+client drawing a vessel's recording can leave the import out of it. Imports stored by a version
+before that time was kept are dated to the first start of a version that keeps it.
 
 A timed track of the own vessel is the exception: it is the boat's own passage, logged before
 the plugin was installed or by another plotter, so it is written into the own vessel's
 recording instead of being kept as an import, and the answer is the recording's id,
-`tracks:recorded:<context>`. It replaces what was recorded over the same time: the positions
-this plugin stored there go to the recycle bin first, one entry per segment, and a history
-provider's data over that time is hidden while the entry is there. Restoring the entry brings
-both back. An untimed track of the own vessel stays an import, since it cannot be placed in
-time.
+`tracks:recorded:<context>`. By default it only fills what the recording is missing: its
+points are used where the vessel has no position, from this plugin or a history provider, for
+at least five minutes, and left out elsewhere, so nothing recorded is overwritten and two
+sources are never interleaved minute by minute; while a history provider cannot be read, such an
+import is refused with a 503 rather than drawn over what it holds. Asked to replace instead, it takes the place of
+what was recorded over the same time: the positions this plugin stored there go to the recycle
+bin first, one entry per segment, and a history provider's data over that time is hidden while
+the entry is there. Restoring the entry brings both back. An untimed track of the own vessel
+stays an import, since it cannot be placed in time.
 
 A track with neither times (`coordTimes`) nor a vessel (`context`) is kept too. No time
 window or vessel query matches it, but `GET /plugins/tracks/imports` lists it with every other
@@ -72,15 +77,23 @@ with `POST /plugins/tracks/imports`, the file as the request body with `Content-
 application/gpx+xml`. Each track in the file becomes an imported track as above. Ticking
 **Tracks of my own vessel** (`?self=true`) files them under the own vessel, which writes a
 timed one into the recording; otherwise a track names a vessel only if the file says which, as
-the plugin's own GPX export does.
-
-In a timed track, points without a time are skipped, and the answer says how many. The route
+the plugin's own GPX export does. Ticking **Replace what my vessel recorded over the same time**
+as well (`onOverlap=replace`; the default is `keep`) replaces the recording rather than filling
+it.
+
+In a timed track, points without a time are skipped, and the answer says how many
+(`skippedPoints`), as it does for the points left out where the recording already has positions
+(`overlappingPoints`). A track posted through the Track API's `POST /signalk/v2/api/tracks` is
+always kept beside the recording this way, since that API has no such choice yet. The route
 needs write access on a Signal K server that lets a plugin say so, and administrator rights on
 an older one.
 
 The webapp lists every imported track, however old and whether or not it has times, next to
 the last 30 days of recorded ones, so a passage imported from years ago can be found there. It
-can be deleted there on a Signal K server that deletes tracks by id. `GET /plugins/tracks/imports` returns every imported track, and no recorded ones.
+can be deleted there on a Signal K server that deletes tracks by id.
+
+`GET /plugins/tracks/imports` returns every imported track, and no recorded ones, each with
+`imported`, the time it was stored.
 
 The Tracks webapp exports an imported track as GPX from its row, as it was imported. A client
 can download the same file from `GET /plugins/tracks/imports/<id>/track.gpx`, with the id less

package/dist/asyncTrackStore.d.ts

@@ -79,8 +79,8 @@ export declare class AsyncTrackStore implements TrackStore {
     purgeFromBin(id: number): Promise<boolean>;
     binEntries(): Promise<import('./types.js').BinEntry[]>;
     deletedSpans(): Promise<import('./types.js').RecordedSpan[]>;
-    getImport(id: string): Promise<ImportedTrack | undefined>;
-    findImports(filter?: ImportFilter): Promise<ImportedTrack[]>;
+    getImport(id: string): Promise<import('./types.js').StoredImport | undefined>;
+    findImports(filter?: ImportFilter): Promise<import('./types.js').StoredImport[]>;
     close(): Promise<void>;
 }
 export {};

package/dist/import.js

@@ -10,12 +10,26 @@ import { refusal } from './bin.js'
 /** Relative, because the server mounts this page under /@signalk/tracks-plugin. */
 const IMPORT_URL = '../../plugins/tracks/imports'
 
+const points = (count) => `${count} point${count === 1 ? '' : 's'}`
+
 /** What an import came to, in words. */
-export function imported({ ids, skippedPoints }) {
-  const count = `Imported ${ids.length} track${ids.length === 1 ? '' : 's'}.`
-  return skippedPoints > 0
-    ? `${count} ${skippedPoints} point${skippedPoints === 1 ? '' : 's'} without a time left out.`
-    : count
+export function imported({ ids, skippedPoints, overlappingPoints = 0 }) {
+  return [
+    `Imported ${ids.length} track${ids.length === 1 ? '' : 's'}.`,
+    ...(skippedPoints > 0 ? [`${points(skippedPoints)} without a time left out.`] : []),
+    ...(overlappingPoints > 0 ? [`${points(overlappingPoints)} left out where your vessel already has a track.`] : []),
+  ].join(' ')
+}
+
+/**
+ * The upload's query. Only the own vessel's tracks go into a recording, so
+ * replacing is offered for those alone; the route keeps by default.
+ */
+export function importQuery({ self, replace }) {
+  if (!self) {
+    return ''
+  }
+  return replace ? '?self=true&onOverlap=replace' : '?self=true'
 }
 
 async function messageOf(response) {
@@ -31,6 +45,13 @@ export function start() {
   const form = document.getElementById('import-form')
   const status = document.getElementById('import-status')
   const button = form.querySelector('button[type="submit"]')
+  const { self, replace } = form.elements
+  // Only the own vessel has a recording to replace.
+  const allowReplace = () => {
+    replace.disabled = !self.checked
+  }
+  allowReplace()
+  self.addEventListener('change', allowReplace)
 
   function show(message, state) {
     // A failed upload can be tried again; a successful one reloads the page.
@@ -58,7 +79,7 @@ export function start() {
       show('Choose a GPX file first.', 'error')
       return
     }
-    const query = form.elements.self.checked ? '?self=true' : ''
+    const query = importQuery({ self: self.checked, replace: replace.checked })
     button.disabled = true
     show('Importing…')
     let response

package/dist/index.html

@@ -31,6 +31,10 @@
         <form id="import-form">
           <label>GPX file <input type="file" name="file" accept=".gpx,application/gpx+xml" required /></label>
           <label><input type="checkbox" name="self" /> Tracks of my own vessel</label>
+          <label
+            ><input type="checkbox" name="replace" /> Replace what my vessel recorded over the same time (it goes to the
+            recycle bin)</label
+          >
           <button type="submit">Import</button>
         </form>
         <p id="import-status" role="status" hidden></p>

package/dist/index.js

@@ -445,14 +445,14 @@ function createTrackProvider(deps) {
 	};
 	/**
 	* What names an imported track: its id, name and vessel, over what it was posted with.
-	* `imported` tells it apart from the recording of the same vessel, which it is listed beside.
+	* `imported`, when it was kept, tells it apart from the recording of the same vessel, which it is listed beside.
 	*/
 	const importIdentity = (track) => {
 		const contextName = track.context === void 0 ? void 0 : deps.contextName(track.context);
 		return {
 			...track.metadata,
 			id: track.id,
-			imported: true,
+			imported: new Date(track.importedAt).toISOString(),
 			...track.name === void 0 ? {} : { name: track.name },
 			...track.context === void 0 ? {} : {
 				context: track.context,
@@ -467,6 +467,16 @@ function createTrackProvider(deps) {
 		if (!store?.storeImport || !store.recordTrack || !store.getImport || !store.binImport || !store.binRecorded) throw new Error("Track storage is not available");
 		return store;
 	};
+	const importTrack = (track, onOverlap) => keepTrack(track, {
+		store: writableStore(),
+		selfContext: deps.selfContext(),
+		historyKnows: deps.historyKnows,
+		recorded: (context, from, to) => deps.recordedOver(context, {
+			from,
+			to
+		}),
+		deleted: deps.deleted
+	}, onOverlap);
 	/** The recorded feature's identity, which `getTracks` and `getTrack` share. */
 	const recordedIdentity = (context) => {
 		const name = deps.contextName(context);
@@ -537,13 +547,9 @@ function createTrackProvider(deps) {
 			return shapeFeature(positionsOf(track, null), 0, { times: timed }, void 0, importIdentity(track), timed);
 		},
 		async storeTrack(track) {
-			return keepTrack(toImportedTrack(track), {
-				store: writableStore(),
-				selfContext: deps.selfContext(),
-				historyKnows: deps.historyKnows,
-				deleted: deps.deleted
-			});
+			return (await importTrack(toImportedTrack(track), "keep")).id;
 		},
+		importTrack,
 		async deleteTrack(id) {
 			const recorded = recordedContext(id);
 			if (recorded !== void 0) return deleteRecorded(resolveSelf(deps.selfContext())(recorded), void 0, void 0);
@@ -673,28 +679,127 @@ function extentEpsilon([west, south, east, north]) {
 	return Math.max(Math.hypot(width, height) / AUTO_EPSILON_DIVISOR, MIN_AUTO_EPSILON);
 }
 /**
+* The shortest stretch without positions that an import kept beside a
+* recording may fill. Filling every pause between recorded points would
+* interleave two sources minute by minute, and any offset between them would
+* draw as a sawtooth; whole stretches keep each part of the line from one.
+*/
+var MIN_FILLED_GAP_MS = 3e5;
+/**
 * Keep a client's track, resolving to the id that addresses it.
 *
 * A timed track of the own vessel is the vessel's own passage, from before
 * the plugin recorded it or from another plotter, so it is written into the
-* recording in place of what was recorded over the same time and answers
-* as `recorded:<context>`. Everything else is kept as an import: another
-* vessel's track is not this boat's recording, and an untimed one cannot be
-* placed in it.
+* recording and answers as `recorded:<context>`: with `keep`, only where the
+* recording has nothing (see {@link fillGaps}); with `replace`, in place of
+* what was recorded over the same time. Everything else is kept as an import:
+* another vessel's track is not this boat's recording, and an untimed one
+* cannot be placed in it.
 */
-async function keepTrack(track, deps) {
+async function keepTrack(track, deps, onOverlap) {
 	const context = track.context === void 0 ? void 0 : resolveSelf(deps.selfContext)(track.context);
 	if (context === deps.selfContext && isTimed(track)) {
 		const segments = track.segments.map((points) => points.map(({ position, timestamp }) => ({
 			position,
 			timestamp
 		})));
+		if (onOverlap === "keep") {
+			const runs = [];
+			const filled = [];
+			let overlapping = 0;
+			for (const points of segments) {
+				if (points.length === 0) continue;
+				let from = Infinity;
+				let to = -Infinity;
+				for (const { timestamp } of points) {
+					from = Math.min(from, timestamp);
+					to = Math.max(to, timestamp);
+				}
+				from -= MIN_FILLED_GAP_MS;
+				to += MIN_FILLED_GAP_MS;
+				const recorded = await deps.recorded(context, from, to);
+				for (const point of filled) if (point.timestamp >= from && point.timestamp <= to) recorded.push(point);
+				const kept = fillGaps([points], recorded, MIN_FILLED_GAP_MS);
+				runs.push(...kept.runs);
+				filled.push(...kept.runs.flat());
+				overlapping += kept.overlapping;
+			}
+			await deps.store.recordTrack(context, runs, Date.now(), false);
+			return {
+				id: recordedId(context),
+				overlapping
+			};
+		}
 		await deps.store.recordTrack(context, segments, Date.now(), await deps.historyKnows(context));
 		deps.deleted();
-		return recordedId(context);
+		return {
+			id: recordedId(context),
+			overlapping: 0
+		};
 	}
 	await deps.store.storeImport(track);
-	return track.id;
+	return {
+		id: track.id,
+		overlapping: 0
+	};
+}
+/**
+* The parts of an import that fall where a recording has nothing for at least
+* `minGap`, as runs to record, and how many points were left out.
+*
+* Each recorded point covers its own instant, or a history bucket's whole
+* span, so a coarse provider read still counts as covering the time between
+* its buckets. A run never crosses a recorded stretch or a segment boundary.
+*/
+function fillGaps(segments, recorded, minGap) {
+	const covered = [];
+	for (const { timestamp, span } of [...recorded].sort((a, b) => a.timestamp - b.timestamp)) {
+		const end = timestamp + (span ?? 0);
+		const last = covered.at(-1);
+		if (last && timestamp <= last[1]) last[1] = Math.max(last[1], end);
+		else covered.push([timestamp, end]);
+	}
+	/** Index of the first covered stretch ending at or after `time`. */
+	const nextStretch = (time) => {
+		let low = 0;
+		let high = covered.length;
+		while (low < high) {
+			const mid = low + high >> 1;
+			if (covered[mid][1] < time) low = mid + 1;
+			else high = mid;
+		}
+		return low;
+	};
+	const runs = [];
+	let overlapping = 0;
+	for (const points of segments) {
+		let run = [];
+		let runGap = -1;
+		for (const point of points) {
+			const next = nextStretch(point.timestamp);
+			const after = covered[next];
+			const before = covered[next - 1];
+			const inside = after !== void 0 && after[0] <= point.timestamp;
+			const free = (after?.[0] ?? Infinity) - (before?.[1] ?? -Infinity);
+			if (inside || free < minGap) {
+				overlapping += 1;
+				if (run.length > 0) runs.push(run);
+				run = [];
+				continue;
+			}
+			if (run.length > 0 && next !== runGap) {
+				runs.push(run);
+				run = [];
+			}
+			run.push(point);
+			runGap = next;
+		}
+		if (run.length > 0) runs.push(run);
+	}
+	return {
+		runs,
+		overlapping
+	};
 }
 /** v2 accepts the `self` alias; the store keys on the qualified context. */
 var resolveSelf = (selfContext) => (context) => context === "self" || context === "vessels.self" ? selfContext : context;
@@ -2073,6 +2178,14 @@ var KNOWN_CONTEXTS_TTL_MS = 3e4;
 */
 var KNOWN_CONTEXTS_FAILURE_TTL_MS = 1e3;
 /**
+* How long a context query may stay unanswered before another is started
+* beside it. Waiting for the provider to settle is what keeps a slow one from
+* running a new epoch-wide scan every few seconds; the bound only covers a
+* provider whose promise never settles at all, which would otherwise leave
+* the list unknown until a restart.
+*/
+var KNOWN_CONTEXTS_PENDING_MAX_MS = 3e5;
+/**
 * 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
 * a bad value falls back to the default instead of poisoning arithmetic with NaN.
@@ -2161,35 +2274,50 @@ var toContextSet = (listed, selfContext) => new Set((listed ?? []).filter((c) =>
 * request open.
 */
 async function historyKnowsContext(app, context, debug, cache) {
-	const getHistoryApi = app.getHistoryApi;
-	if (!getHistoryApi) return false;
 	try {
-		const now = Date.now();
-		const cached = cache.current;
-		if (cached === void 0 || now - cached.at >= KNOWN_CONTEXTS_TTL_MS) {
-			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) => toContextSet(listed, app.selfContext)), HISTORY_QUERY_TIMEOUT_MS);
-			const entry = {
-				at: now,
-				contexts
-			};
-			contexts.catch(() => {
-				if (cache.current === entry) cache.current = {
-					at: now - KNOWN_CONTEXTS_TTL_MS + KNOWN_CONTEXTS_FAILURE_TTL_MS,
-					contexts
-				};
-			});
-			cache.current = entry;
-		}
-		return (await cache.current.contexts).has(context);
+		return (await knownHistoryContexts(app, cache)).has(context);
 	} catch (err) {
 		debug(`History contexts unavailable for ${context}: ${errorDetail(err)}`);
 		return false;
 	}
 }
 /**
+* Every context a history provider holds anything for, from the cache.
+*
+* Reused while fresh, and shared while in flight: a burst of misses is one
+* question to the provider, not one each. The promise is cached rather than
+* its result so concurrent callers join the same query instead of starting
+* their own, and a query is shared until the provider answers it, not only
+* until the caller's timeout: the provider keeps running a query nobody waits
+* for, so asking again on every timeout stacks scans of the whole database.
+*/
+function knownHistoryContexts(app, cache) {
+	const getHistoryApi = app.getHistoryApi;
+	if (!getHistoryApi) return Promise.resolve(/* @__PURE__ */ new Set());
+	const now = Date.now();
+	const cached = cache.current;
+	if (cached === void 0 || (cached.pending ? now - cached.at >= KNOWN_CONTEXTS_PENDING_MAX_MS : now - cached.at >= KNOWN_CONTEXTS_TTL_MS)) {
+		const contexts = 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) => toContextSet(listed, app.selfContext));
+		const entry = {
+			at: now,
+			contexts,
+			pending: true
+		};
+		contexts.then(() => {
+			entry.pending = false;
+			entry.at = Date.now();
+		}, () => {
+			entry.pending = false;
+			entry.at = Date.now() - KNOWN_CONTEXTS_TTL_MS + KNOWN_CONTEXTS_FAILURE_TTL_MS;
+		});
+		cache.current = entry;
+	}
+	return withTimeout(cache.current.contexts, HISTORY_QUERY_TIMEOUT_MS);
+}
+/**
 * 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
@@ -2206,16 +2334,30 @@ 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();
+		if (!window) return await knownHistoryContexts(app, cache);
+		const running = cache.windowQueries ??= /* @__PURE__ */ new Set();
+		const now = Date.now();
+		let slow = false;
+		for (const entry of running) {
+			const age = now - entry.startedAt;
+			if (age >= KNOWN_CONTEXTS_PENDING_MAX_MS) running.delete(entry);
+			else if (age >= HISTORY_QUERY_TIMEOUT_MS) slow = true;
+		}
+		if (slow) {
+			if (debug.enabled) debug("History contexts skipped: an earlier windowed query is still running");
+			return /* @__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({
+		const query = 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);
+		});
+		const entry = { startedAt: Date.now() };
+		running.add(entry);
+		const settled = () => running.delete(entry);
+		query.then(settled, settled);
+		return toContextSet(await withTimeout(query, HISTORY_QUERY_TIMEOUT_MS), app.selfContext);
 	} catch (err) {
 		if (debug.enabled) debug(`History contexts unavailable: ${errorDetail(err)}`);
 		return /* @__PURE__ */ new Set();
@@ -2328,6 +2470,8 @@ function ThePlugin(app) {
 	};
 	let onStop = [];
 	let tracks = void 0;
+	/** Also what the plugin's own import route keeps tracks through. */
+	let trackProvider = void 0;
 	let segmentGap = 0;
 	/**
 	* How often the store keeps a position, in ms.
@@ -2472,7 +2616,7 @@ function ThePlugin(app) {
 			onStop.push(() => {
 				clearInterval(statusInterval);
 			});
-			app.registerTrackApiProvider?.(createTrackProvider({
+			trackProvider = createTrackProvider({
 				store: () => tracks,
 				selfContext: () => app.selfContext,
 				segmentGap: () => segmentGap,
@@ -2485,8 +2629,20 @@ function ThePlugin(app) {
 				reconcileWithHistory: async (context, stored, window, resolutionMs) => {
 					const effective = resolutionMs ?? storeResolution;
 					return withHistory(await visibleHistory(context, window ?? windowSpanning(stored, WINDOWLESS_HISTORY_SPAN_MS), effective), stored);
+				},
+				recordedOver: async (context, window) => {
+					const stored = (await tracks?.getFilteredTimedTracks({
+						bbox: null,
+						radius: null,
+						intersects: true,
+						contexts: [context]
+					}, void 0, void 0, { window }))?.[context] ?? [];
+					const history = await visibleHistory(context, window, storeResolution);
+					if (history.failed) throw new HistoryUnavailableError(`History provider could not be read for ${context}`);
+					return [...stored, ...history.points];
 				}
-			}));
+			});
+			app.registerTrackApiProvider?.(trackProvider);
 			return starting.ready.catch(async () => {
 				await starting.close().catch(() => {});
 				if (tracks === starting) tracks = void 0;
@@ -2505,6 +2661,7 @@ function ThePlugin(app) {
 			glitchFilter.clear();
 			stateGate.clear();
 			knownContexts.current = void 0;
+			delete knownContexts.windowQueries;
 			const closing = tracks;
 			tracks = void 0;
 			try {
@@ -2720,6 +2877,7 @@ function ThePlugin(app) {
 						from: new Date(from).toISOString(),
 						to: new Date(to).toISOString()
 					},
+					imported: new Date(track.importedAt).toISOString(),
 					pointCount
 				};
 			};
@@ -2778,16 +2936,17 @@ function ThePlugin(app) {
 				});
 			});
 			(router.access?.("readwrite") ?? router).post("/imports", (req, res) => {
-				const store = tracks;
-				if (!store?.storeImport || !store.recordTrack) {
+				const provider = trackProvider;
+				if (!provider || !tracks?.storeImport || !tracks.recordTrack) {
 					notAvailable(res);
 					return;
 				}
-				const writableStore = {
-					storeImport: store.storeImport.bind(store),
-					recordTrack: store.recordTrack.bind(store)
-				};
 				const context = req.query.self === "true" ? app.selfContext : void 0;
+				const onOverlap = req.query.onOverlap ?? "keep";
+				if (onOverlap !== "keep" && onOverlap !== "replace") {
+					res.status(400).json({ message: "onOverlap must be 'keep' or 'replace'" });
+					return;
+				}
 				(async () => {
 					let text;
 					try {
@@ -2804,24 +2963,22 @@ function ThePlugin(app) {
 						return;
 					}
 					const converted = read.map((gpx) => fromGpxTrack(gpx, context ?? gpx.context));
-					const ids = [];
+					const kept = [];
 					try {
-						for (const { track } of converted) ids.push(await keepTrack(track, {
-							store: writableStore,
-							selfContext: app.selfContext,
-							historyKnows: (vessel) => historyKnowsContext(app, vessel, app.debug, knownContexts),
-							deleted: () => {
-								deletedSpans = void 0;
-							}
-						}));
+						for (const { track } of converted) kept.push(await provider.importTrack(track, onOverlap));
 					} catch (err) {
+						if (err instanceof HistoryUnavailableError) {
+							res.status(503).json({ message: "The history provider could not be read, so the gaps to fill are unknown; try again later" });
+							return;
+						}
 						app.error(`GPX import: ${errorDetail(err)}`);
 						res.status(500).json({ message: "Track storage failed" });
 						return;
 					}
 					res.status(201).json({
-						ids: ids.map((id) => `${PLUGIN_ID}:${id}`),
-						skippedPoints: converted.reduce((sum, { skippedPoints }) => sum + skippedPoints, 0)
+						ids: kept.map(({ id }) => `${PLUGIN_ID}:${id}`),
+						skippedPoints: converted.reduce((sum, { skippedPoints }) => sum + skippedPoints, 0),
+						overlappingPoints: kept.reduce((sum, { overlapping }) => sum + overlapping, 0)
 					});
 				})();
 			});