@signalk/tracks-plugin 3.1.0 → 3.2.0

package/README.md

@@ -34,6 +34,69 @@ The own vessel is kept indefinitely by default. Other vessels are kept for 30 da
 fix — a harbour puts hundreds of AIS targets past a receiver in a day, and keeping every one of them
 forever is rarely what anybody wants. Both are settings.
 
+## Imported tracks
+
+A client can store a track of its own, a GPX from a friend or a passage logged by another
+device, with `POST /signalk/v2/api/tracks` (Signal K server with
+[#3038](https://github.com/SignalK/signalk-server/pull/3038)). The body is a GeoJSON
+Feature, the shape a v2 query returns; the plugin answers with an id such as
+`tracks:imported:0f0f2a1e-…`, and `GET` or `DELETE /signalk/v2/api/tracks/<id>` fetch or
+delete it. Storing needs write access; deleting needs administrator rights, or write
+access on a server with security turned off.
+
+An imported track is kept apart from the recording. It is listed by v2 queries like any
+other track, filtered by vessel, time window and area, but as a feature of its own even when
+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.
+
+A track needs times (`coordTimes`) or a vessel (`context`). One with neither is refused:
+it would match no time window, and a query across every vessel needs one, so it could
+only be found again by its id.
+
+### Importing a GPX file
+
+The Tracks webapp imports a GPX file from the **Import** form, and a client can do the same
+with `POST /plugins/tracks/imports`, the file as the request body with `Content-Type:
+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; otherwise a track names a vessel only if the file says which, as
+the plugin's own GPX export does.
+
+A file with a track that cannot be kept is refused whole: if any track in it has neither times
+nor a vessel, nothing is stored and the reason is shown. In a timed track, points without a time are
+skipped, and the answer says how many. 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.
+
+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
+its `tracks:` prefix: under the track's own name, and without times if it had none.
+
+## Deleting tracks
+
+`DELETE /signalk/v2/api/tracks/<id>` deletes a track, and with `from`, `to` or both only the
+part recorded between them (on a Signal K server that accepts them; an older one refuses the
+request rather than deleting the whole track). Deleting needs administrator rights, or write
+access on a server with security turned off. The Tracks webapp offers both from each row.
+
+A recorded track has the id `tracks:recorded:<vessel context>`. Deleting it whole removes
+what was recorded up to now; the recording goes on, and what it records next is kept. With a
+history provider installed the deleted span is hidden in what the provider returns too, since
+the History API has no way to delete or hide data and the next query would otherwise fill it
+back in.
+
+Nothing deleted is gone at once. It goes to a recycle bin, listed in the Tracks webapp, where it
+can be restored or deleted for good, until it is purged after the number of days set in the
+plugin settings (180 by default). The retention settings above do not reach into the bin, but
+they apply again to what is restored: an AIS vessel restored after its last fix has aged past
+the retention is dropped at the next prune. Once a recorded span is purged its points are gone,
+but the span stays hidden in the provider's data for good.
+
 ## Glitch filtering
 
 A receiver occasionally reports a position far from the vessel — a bad almanac, a multipath

package/dist/asyncTrackStore.d.ts

@@ -1,6 +1,6 @@
 import { TrackStore } from './store.js';
 import { SqliteStoreConfig } from './sqliteStore.js';
-import { Debug, Context, LatLngTuple, TimeWindow, TrackParams } from './types.js';
+import { Debug, Context, ImportedTrack, ImportFilter, LatLngTuple, TimeWindow, TrackParams } from './types.js';
 import { TrackQuery } from './timeWindow.js';
 interface Limits {
     maxItems?: number;
@@ -41,6 +41,14 @@ export declare class AsyncTrackStore implements TrackStore {
     private resumeIfDrained;
     private fail;
     private enqueue;
+    /**
+     * A write whose caller waits for the commit: an imported track, or its
+     * deletion. Admitted outside the recording budget, which is sized for
+     * positions; an import of a few megabytes would otherwise pause recording,
+     * and then be dropped like a position. Refused once writes have failed,
+     * since that state lasts until a restart.
+     */
+    private acknowledged;
     private schedule;
     private pump;
     private receive;
@@ -57,6 +65,21 @@ export declare class AsyncTrackStore implements TrackStore {
     }[]>;
     getFilteredTracks(params: TrackParams, selfPosition?: LatLngTuple, _debug?: Debug, query?: TrackQuery): Promise<import('./types.js').TrackCollection>;
     getFilteredTimedTracks(params: TrackParams, selfPosition?: LatLngTuple, _debug?: Debug, query?: TrackQuery): Promise<import('./types.js').TimedTrackCollection>;
+    storeImport(track: ImportedTrack): Promise<void>;
+    binRecorded(context: Context, from: number | undefined, to: number, deletedAt: number, keepEmpty: boolean): Promise<{
+        id?: number;
+        known: boolean;
+    }>;
+    binImport(importId: string, span: {
+        from?: number;
+        to?: number;
+    } | undefined, deletedAt: number): Promise<number | undefined>;
+    restoreFromBin(id: number): Promise<import('./types.js').RestoreResult>;
+    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[]>;
     close(): Promise<void>;
 }
 export {};

package/dist/bin.js

@@ -0,0 +1,285 @@
+/**
+ * Deleting tracks, and the recycle bin they go to.
+ *
+ * Deletes go through the v2 Track API, like every other client's; the bin is
+ * this plugin's own, under its router at /plugins/tracks, since the Track API
+ * has no restore. Both need an administrator, which the server enforces.
+ *
+ * Everything that touches the page runs from `start()`, so the pure helpers
+ * can be imported and tested without a document.
+ */
+
+/** Relative, because the server mounts this page under /@signalk/tracks-plugin. */
+const TRACKS_URL = '../../signalk/v2/api/tracks'
+const BIN_URL = '../../plugins/tracks/recycle-bin'
+
+/** The label for a track, matching `trackLabel()` on the server and `label()` in tracks.js. */
+export function label({ context, contextName, isSelf }) {
+  if (isSelf) {
+    return 'Own Ship'
+  }
+  if (contextName) {
+    return `AIS ${contextName}`
+  }
+  const mmsi = /urn:mrn:imo:mmsi:(\d+)$/.exec(context ?? '')
+  return mmsi ? `AIS ${mmsi[1]}` : (context ?? 'No vessel')
+}
+
+/** What a bin entry deleted, in the viewer's locale and zone. */
+export function deletedPart({ whole, from, to }) {
+  if (whole) {
+    return 'The whole track'
+  }
+  if (from === undefined) {
+    return `Everything up to ${when(to)}`
+  }
+  if (to === undefined) {
+    return `Everything from ${when(from)}`
+  }
+  return `${when(from)} to ${when(to)}`
+}
+
+/**
+ * The query string for a delete of part of a track, from two `datetime-local`
+ * values; undefined when neither is set.
+ *
+ * The inputs show whole seconds, so `to` reaches the end of its second: a
+ * track ending at 12:00:00.5 shows as ending at 12:00:00, and a span "to
+ * 12:00:00" taken literally would keep the last point the user meant to
+ * delete.
+ */
+export function spanQuery(from, to) {
+  const params = new URLSearchParams()
+  if (from) params.set('from', new Date(from).toISOString())
+  if (to) params.set('to', new Date(new Date(to).getTime() + 999).toISOString())
+  const query = params.toString()
+  return query ? `?${query}` : undefined
+}
+
+/** An ISO time as a `datetime-local` value, in the viewer's zone. */
+export function localInput(iso) {
+  const at = new Date(iso)
+  if (Number.isNaN(at.getTime())) {
+    return ''
+  }
+  const pad = (n) => String(n).padStart(2, '0')
+  return (
+    `${at.getFullYear()}-${pad(at.getMonth() + 1)}-${pad(at.getDate())}` +
+    `T${pad(at.getHours())}:${pad(at.getMinutes())}:${pad(at.getSeconds())}`
+  )
+}
+
+/** Why a request was refused, in words a user can act on. */
+export function refusal(status) {
+  if (status === 401 || status === 403) {
+    return 'This needs an administrator login.'
+  }
+  if (status === 404) {
+    return 'It is no longer there.'
+  }
+  if (status === 501) {
+    return 'The track provider cannot do this.'
+  }
+  return `The server answered ${status}.`
+}
+
+function when(iso) {
+  const at = new Date(iso)
+  return Number.isNaN(at.getTime()) ? '—' : at.toLocaleString()
+}
+
+async function messageOf(response) {
+  try {
+    const body = await response.json()
+    return body?.error ?? body?.message
+  } catch {
+    return undefined
+  }
+}
+
+function start() {
+  const dialog = document.getElementById('delete-dialog')
+  const form = dialog.querySelector('form')
+  const error = document.getElementById('delete-error')
+  const binStatus = document.getElementById('bin-status')
+  const binTable = document.getElementById('bin-table')
+  const binBody = binTable.querySelector('tbody')
+  let target
+
+  document.addEventListener('tracks:delete', (event) => {
+    target = event.detail
+    document.getElementById('delete-title').textContent = `Delete ${target.label}${
+      target.name ? ` (imported: ${target.name})` : ''
+    }`
+    // A recording goes on after it is deleted: what is recorded next is a new
+    // track, so "whole" means up to now, and saying so avoids a surprise.
+    document.getElementById('delete-whole').textContent = target.id.startsWith(`${target.providerId}:recorded:`)
+      ? 'The whole track, up to now'
+      : 'The whole track'
+    form.elements.scope.value = 'whole'
+    form.elements.from.value = localInput(target.from)
+    form.elements.to.value = localInput(target.to)
+    // A track without times has no part to address by time.
+    for (const input of form.querySelectorAll('[value="span"], .span input')) {
+      input.disabled = target.from === undefined
+    }
+    error.hidden = true
+    dialog.showModal()
+  })
+
+  form.addEventListener('submit', async (event) => {
+    if (event.submitter?.value !== 'delete') {
+      return
+    }
+    event.preventDefault()
+    const { scope, from, to } = form.elements
+    let query = ''
+    if (scope.value === 'span') {
+      // Without a bound the request would delete the whole track, which is
+      // not what choosing a part asked for.
+      const span = spanQuery(from.value, to.value)
+      if (span === undefined) {
+        error.textContent = 'Give the time the part starts, ends, or both.'
+        error.hidden = false
+        return
+      }
+      query = span
+    }
+    // The server hands out ids already qualified by their provider.
+    const id = encodeURIComponent(target.id)
+    const url = `${TRACKS_URL}/${id}${query}`
+    let response
+    try {
+      response = await fetch(url, { method: 'DELETE', credentials: 'include' })
+    } catch {
+      error.textContent = 'Could not reach the server.'
+      error.hidden = false
+      return
+    }
+    if (!response.ok) {
+      error.textContent = (await messageOf(response)) ?? refusal(response.status)
+      error.hidden = false
+      return
+    }
+    dialog.close()
+    location.reload()
+  })
+
+  async function act(url, method) {
+    let response
+    try {
+      response = await fetch(url, { method, credentials: 'include' })
+    } catch {
+      showBin('Could not reach the server.', 'error')
+      return
+    }
+    if (!response.ok) {
+      showBin((await messageOf(response)) ?? refusal(response.status), 'error')
+      return
+    }
+    location.reload()
+  }
+
+  function showBin(message, state) {
+    binStatus.textContent = message
+    if (state) {
+      binStatus.dataset.state = state
+    } else {
+      delete binStatus.dataset.state
+    }
+  }
+
+  function cell(text, className) {
+    const td = document.createElement('td')
+    td.textContent = String(text)
+    if (className) td.className = className
+    return td
+  }
+
+  function button(text, onClick, className) {
+    const b = document.createElement('button')
+    b.type = 'button'
+    b.textContent = text
+    if (className) b.className = className
+    b.addEventListener('click', onClick)
+    return b
+  }
+
+  function binRow(entry) {
+    const tr = document.createElement('tr')
+    const name = cell(label(entry))
+    if (entry.name) {
+      const imported = document.createElement('span')
+      imported.className = 'imported'
+      imported.textContent = ` (imported: ${entry.name})`
+      name.append(imported)
+    }
+    const actions = document.createElement('td')
+    const buttons = document.createElement('div')
+    buttons.className = 'actions'
+    actions.append(buttons)
+    buttons.append(
+      button('Restore', () => act(`${BIN_URL}/${entry.id}/restore`, 'POST')),
+      button(
+        'Delete now',
+        () => {
+          if (confirm('Delete this for good? It cannot be restored afterwards.')) {
+            void act(`${BIN_URL}/${entry.id}`, 'DELETE')
+          }
+        },
+        'danger',
+      ),
+    )
+    tr.append(
+      name,
+      cell(deletedPart(entry)),
+      cell(when(entry.deletedAt)),
+      cell(when(entry.purgeAt)),
+      cell(entry.pointCount, 'num'),
+      actions,
+    )
+    return tr
+  }
+
+  async function loadBin() {
+    let response
+    try {
+      response = await fetch(BIN_URL, { credentials: 'include', signal: AbortSignal.timeout(30_000) })
+    } catch {
+      showBin('Could not reach the server.', 'error')
+      return
+    }
+    if (!response.ok) {
+      showBin(
+        response.status === 401 || response.status === 403
+          ? 'Sign in as an administrator to see the recycle bin.'
+          : refusal(response.status),
+        'error',
+      )
+      return
+    }
+    let entries
+    try {
+      entries = await response.json()
+    } catch {
+      entries = undefined
+    }
+    if (!Array.isArray(entries)) {
+      showBin('The server sent a response this page could not read.', 'error')
+      return
+    }
+    if (entries.length === 0) {
+      showBin('The recycle bin is empty.')
+      return
+    }
+    binBody.replaceChildren(...entries.map(binRow))
+    binTable.hidden = false
+    showBin(`${entries.length} deleted track${entries.length === 1 ? '' : 's'} or parts, newest first.`)
+  }
+
+  void loadBin()
+}
+
+if (typeof document !== 'undefined') {
+  start()
+}

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

@@ -1,5 +1,11 @@
 /** QuestDB endpoint used by the history-provider tier. */
 export declare const QUESTDB_URL: string;
+export interface RequestOptions {
+    method?: string;
+    /** Sent as JSON, unless `contentType` says it is already text of that type. */
+    body?: unknown;
+    contentType?: string;
+}
 export interface E2EServer {
     url: string;
     configDir: string;
@@ -12,14 +18,22 @@ export interface E2EServer {
      *
      * The status is what distinguishes "no provider registered" (501) from an
      * answered query, which is the thing a provider registration test is about.
+     * `init` sends another method, with `body` as JSON. A body that is not JSON,
+     * as an older server's 404 page is, comes back as its text.
      */
-    apiV2: (path: string) => Promise<{
+    apiV2: (path: string, init?: RequestOptions) => Promise<{
+        status: number;
+        body: unknown;
+    }>;
+    /** As `apiV2`, for a path under this plugin's own router at /plugins/tracks. */
+    plugin: (path: string, init?: RequestOptions) => Promise<{
         status: number;
         body: unknown;
     }>;
     /** The server's own vessel context, as it resolved it. */
     selfContext: string;
-    stop: () => void;
+    /** Stop the server, resolving once it has exited and its config dir is gone. */
+    stop: () => Promise<void>;
 }
 export interface E2EOptions {
     /** Plugin configuration written to plugin-config-data/tracks.json. */

package/dist/gpx.d.ts

@@ -1,4 +1,4 @@
-import { TimedPosition } from './types.js';
+import { LatLngTuple, TimedPosition } from './types.js';
 /** Identity of the vessel a track belongs to, as far as it is known. */
 export interface GpxTrackIdentity {
     /** Display label, e.g. `Own Ship` or `AIS Ariadne`. Becomes `<name>`. */
@@ -10,6 +10,15 @@ export interface GpxTrack extends GpxTrackIdentity {
     /** Segments as `segment()` produces them: a recording gap starts a new one. */
     segments: TimedPosition[][];
 }
+/** A point to write; one without a time is written without `<time>`. */
+export interface GpxPoint {
+    position: LatLngTuple;
+    timestamp?: number;
+}
+/** A track to write: a recorded one, or an import that may carry no times. */
+export interface GpxExportTrack extends GpxTrackIdentity {
+    segments: GpxPoint[][];
+}
 /**
  * Serialise tracks as a GPX 1.1 document.
  *
@@ -23,7 +32,7 @@ export interface GpxTrack extends GpxTrackIdentity {
  * identity; carrying the context means ours can, while staying readable by
  * anything else, since `<extensions>` is ignorable by specification.
  */
-export declare function toGpx(tracks: GpxTrack[], now?: Date): string;
+export declare function toGpx(tracks: GpxExportTrack[], now?: Date): string;
 /**
  * Parse a GPX document into tracks.
  *

package/dist/gpxExport.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/gpxImport.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -117,6 +117,8 @@ export interface HarnessOptions {
          * only the earliest of `rows` in each bucket of the asked resolution.
          */
         aggregatesFirst?: boolean;
+        /** Called with every `getValues` query, so a test can see what was asked. */
+        onValues?: (query: HistoryValuesQuery) => void;
         /**
          * Reject `getHistoryApi` itself, as the server does when no provider is
          * registered — the default install, and not an outage.
@@ -136,4 +138,13 @@ export declare function deferred(): {
     release: () => void;
     wait: Promise<void>;
 };
+export interface HistoryValuesQuery {
+    from: {
+        toString: () => string;
+    };
+    to: {
+        toString: () => string;
+    };
+    resolution?: number;
+}
 export declare function createHarness(options?: HarnessOptions): TestHarness;

package/dist/import.js

@@ -0,0 +1,98 @@
+/**
+ * Importing GPX files as tracks.
+ *
+ * The file goes to this plugin's own route, which reads it with the same GPX
+ * parser the export uses: the page ships with no bundler and cannot reach it.
+ * Storing needs write access, which the server enforces.
+ */
+import { refusal } from './bin.js'
+
+/** Relative, because the server mounts this page under /@signalk/tracks-plugin. */
+const IMPORT_URL = '../../plugins/tracks/imports'
+
+/** 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
+}
+
+async function messageOf(response) {
+  try {
+    const body = await response.json()
+    return body?.message ?? body?.error
+  } catch {
+    return undefined
+  }
+}
+
+export function start() {
+  const form = document.getElementById('import-form')
+  const status = document.getElementById('import-status')
+  const button = form.querySelector('button[type="submit"]')
+
+  function show(message, state) {
+    // A failed upload can be tried again; a successful one reloads the page.
+    if (state === 'error') {
+      button.disabled = false
+    }
+    status.textContent = message
+    status.hidden = false
+    if (state) {
+      status.dataset.state = state
+    } else {
+      delete status.dataset.state
+    }
+  }
+
+  form.addEventListener('submit', async (event) => {
+    event.preventDefault()
+    // Each request stores the file anew, so a second click while one is in
+    // flight would import every track in it twice.
+    if (button.disabled) {
+      return
+    }
+    const file = form.elements.file.files[0]
+    if (!file) {
+      show('Choose a GPX file first.', 'error')
+      return
+    }
+    const query = form.elements.self.checked ? '?self=true' : ''
+    button.disabled = true
+    show('Importing…')
+    let response
+    try {
+      response = await fetch(`${IMPORT_URL}${query}`, {
+        method: 'POST',
+        credentials: 'include',
+        headers: { 'Content-Type': 'application/gpx+xml' },
+        body: file,
+      })
+    } catch {
+      show('Could not reach the server.', 'error')
+      return
+    }
+    if (!response.ok) {
+      show((await messageOf(response)) ?? refusal(response.status), 'error')
+      return
+    }
+    let body
+    try {
+      body = await response.json()
+    } catch {
+      body = undefined
+    }
+    if (!Array.isArray(body?.ids)) {
+      show('The server sent a response this page could not read.', 'error')
+      return
+    }
+    show(imported(body))
+    // Reloaded so the list, which shows every import, includes this one.
+    setTimeout(() => location.reload(), 1500)
+  })
+}
+
+if (typeof document !== 'undefined') {
+  start()
+}

package/dist/importedTracks.d.ts

@@ -0,0 +1,54 @@
+import { GpxTrack } from './gpx.js';
+import { TrackImport } from './trackApi.js';
+import { GeoBounds, ImportedTrack, TimedPosition, TimeWindow } from './types.js';
+/**
+ * Prefix of every imported track's id. It keeps imported and recorded tracks
+ * in separate id spaces, so no import can ever address a recorded track.
+ */
+export declare const IMPORTED_PREFIX = "imported:";
+export declare const isImportedId: (id: string) => boolean;
+/**
+ * The track the server handed over, as this plugin stores it.
+ *
+ * Times are sorted within each segment, the way `fromGpx` reads a file: the
+ * thinning and window code assume time order, and a segment boundary is a gap
+ * in recording, so segments are never merged or reordered.
+ *
+ * Refuses a track with neither times nor a vessel. Such a track answers no
+ * time window, and the server refuses a query across all vessels without one,
+ * so it could only ever be found again by an id the client would have to keep.
+ */
+export declare function toImportedTrack(track: TrackImport, id?: string): ImportedTrack;
+/**
+ * A track read from a GPX file, as this plugin stores it, with the number of
+ * points left out.
+ *
+ * `fromGpx` dates a point with no `<time>` to 0. A file with no times at all
+ * becomes an untimed import; a file with some keeps only its timed points,
+ * because an import is timed throughout or not at all, and its times are what
+ * let a query find it. `context` names the vessel in place of the file's own.
+ * Refused, like any import, when it ends up with neither times nor a vessel.
+ */
+export declare function fromGpxTrack(gpx: GpxTrack, context?: string | undefined, id?: string): {
+    track: ImportedTrack;
+    skippedPoints: number;
+};
+/** Whether the track's points carry times; an import is timed throughout or not at all. */
+export declare const isTimed: (track: ImportedTrack) => boolean;
+/**
+ * The track as one list of points for the shared pipeline, each posted segment
+ * after the first starting a new line.
+ *
+ * Narrowed to the window and clipped per segment, so a line never joins two
+ * segments: not where the window empties the start of one, nor through the
+ * point just outside the box that a clipped stretch keeps, which must come
+ * from its own segment. An untimed point gets timestamp 0, which only the
+ * time-free paths of the pipeline ever see.
+ */
+export declare function positionsOf(track: ImportedTrack, clipTo: GeoBounds | null, window?: TimeWindow): TimedPosition[];
+/**
+ * At most `maxPoints` evenly chosen points of a track without times, keeping
+ * the first and the last. A point that starts a new line passes that on to
+ * the next point kept, so dropping it does not join two segments.
+ */
+export declare function decimate(points: TimedPosition[], maxPoints: number): TimedPosition[];

package/dist/importedTracks.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -99,6 +99,7 @@ interface Plugin {
     enabledByDefault: boolean;
     stop: () => Promise<void>;
     signalKApiRoutes: (r: Router) => Router;
+    registerWithRouter: (r: Router) => Router;
     id: string;
     name: string;
     description: string;
@@ -116,6 +117,8 @@ interface TracksPluginConfig {
     resolution?: number;
     /** Days another vessel is kept after its last fix. 0 keeps every vessel. */
     aisRetentionDays?: number;
+    /** Days a deleted track waits in the recycle bin before it is purged. */
+    recycleBinDays?: number;
     /** Minutes without a fix that start a new track segment. 0 disables. */
     segmentGapMinutes?: number;
     /** Speed above which a position is treated as a glitch. 0 disables. */
@@ -125,7 +128,7 @@ interface TracksPluginConfig {
 }
 export default function ThePlugin(app: App): Plugin;
 export { fromGpx, toGpx } from './gpx.js';
-export type { GpxTrack, GpxTrackIdentity } from './gpx.js';
+export type { GpxExportTrack, GpxPoint, GpxTrack, GpxTrackIdentity } from './gpx.js';
 export { Tracks, TrackAccumulator } from './tracks.js';
 export type { TracksConfig } from './tracks.js';
 export type { TrackStore } from './store.js';