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

package/dist/plugin.e2e.test.d.ts

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

package/dist/provider.e2e.test.d.ts

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

package/dist/readme.test.d.ts

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

package/dist/reconcile.d.ts

@@ -0,0 +1,16 @@
+import { TimedPosition } from './types.js';
+export interface ReconcileResult {
+    positions: TimedPosition[];
+    /** Buckets served from the history provider. */
+    fromHistory: number;
+    /** Buckets served from the plugin's own store. */
+    fromStore: number;
+}
+/**
+ * Merge history and store positions into one track.
+ *
+ * `resolution` is the bucket width in milliseconds; it should be the
+ * resolution the history provider was asked for, so its rows land one per
+ * bucket.
+ */
+export declare function reconcile(history: TimedPosition[], stored: TimedPosition[], resolution: number): ReconcileResult;

package/dist/reconcile.test.d.ts

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

package/dist/routes.test.d.ts

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

package/dist/selfTrack.test.d.ts

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

package/dist/source.test.d.ts

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

package/dist/sourceWatch.d.ts

@@ -0,0 +1,44 @@
+import { Context } from './types.js';
+/**
+ * Watches which `$source` each context's positions arrive from.
+ *
+ * `navigation.position` is a rapid update — a GPS may report at 10Hz — and a
+ * typical boat has several receivers: an internal GPS, an AIS transponder, a
+ * chart plotter echoing its own fix.
+ *
+ * Signal K resolves which one wins through source priority, and the bus this
+ * plugin listens on is the filtered one: the server applies `toPreferredDelta`
+ * before emitting `delta`, which is what feeds `getBus()`. So with a priority
+ * rule in place, only the winner arrives and there is nothing to warn about.
+ *
+ * The gap is when no rule *matches* the path. Then the engine passes every
+ * source through, the fixes from receivers metres apart interleave, and the
+ * track zigzags between them rather than following the boat. The fix is to
+ * configure source priority for `navigation.position`; this watcher exists to
+ * say so, because the symptom (a track that looks noisy) does not obviously
+ * point at the cause.
+ *
+ * Detection is therefore empirical rather than reading the priority config:
+ * seeing several sources here *is* the evidence that no rule is matching,
+ * which a config that merely exists would not tell us.
+ */
+export declare class SourceWatch {
+    private readonly seen;
+    /** Record that `context` produced a position from `$source`. */
+    add(context: Context, source: string | undefined): void;
+    /** Sources seen for a context, in the order they first appeared. */
+    sourcesFor(context: Context): string[];
+    /** Contexts receiving positions from more than one source. */
+    conflicted(): Context[];
+    /**
+     * A status line naming the problem, or undefined when nothing is wrong.
+     *
+     * `selfContext` is called out by name because the own vessel's track is the
+     * one a user looks at, and it is the one whose priority they can fix. Other
+     * vessels are usually AIS, where multiple receivers are expected and less
+     * worth nagging about — they are counted, not named.
+     */
+    warning(selfContext?: Context): string | undefined;
+    /** Forget everything seen; used when the plugin restarts. */
+    clear(): void;
+}

package/dist/sourceWatch.test.d.ts

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

package/dist/sqlitePlugin.test.d.ts

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

package/dist/sqliteStore.d.ts

@@ -0,0 +1,95 @@
+import { TrackQuery } from './timeWindow.js';
+import { TrackStore } from './store.js';
+import { Context, Debug, LatLngTuple, TimedPosition, TimedTrackCollection, TimeWindow, TrackCollection, TrackParams } from './types.js';
+export interface SqliteStoreConfig {
+    /** Absolute path to the database file, or ':memory:'. */
+    file: string;
+    /**
+     * Minimum spacing between stored positions, in ms. 0 stores every one.
+     *
+     * The same `resolution` the in-memory accumulator applies with
+     * `throttleTime`, enforced here on write instead. Without it a boat emitting
+     * position at 8 Hz writes ~700k rows a day rather than the ~1.4k a 60s
+     * resolution implies — a difference that lands on an SD card.
+     */
+    resolution?: number;
+    /** Drop positions older than this many ms. 0 keeps everything. */
+    retention?: number;
+    /** Cells per bounding box covering. */
+    maxCells?: number;
+    /** A gap longer than this ms starts a new track segment. */
+    segmentGap?: number;
+}
+/**
+ * A position store backed by SQLite, so tracks survive a restart.
+ *
+ * Uses node:sqlite rather than better-sqlite3: it is built into Node >= 22, so
+ * installing the plugin on a Raspberry Pi needs no native compilation.
+ *
+ * The spatial index is Teppo Kurki's design from SignalK/tracks#11 — an S2 cell
+ * id per position, queried as id ranges — as is segmenting a track on a time
+ * gap. Both are reimplemented here rather than rebased; see that PR for the
+ * original.
+ */
+export declare class SqliteTrackStore implements TrackStore {
+    private readonly db;
+    private readonly insert;
+    private readonly maxCells;
+    private readonly segmentGap;
+    private readonly retention;
+    private readonly resolution;
+    private readonly debug;
+    /** Timestamp of the last position stored per context, for throttling. */
+    private readonly lastStored;
+    constructor(config: SqliteStoreConfig, debug: Debug);
+    newPosition(context: Context, position: LatLngTuple, timestamp?: number): void;
+    private store;
+    initialTrack(context: Context, track: LatLngTuple[], timestamps?: number[]): void;
+    private rowsFor;
+    private knows;
+    get(context: Context, window?: TimeWindow): Promise<LatLngTuple[]>;
+    getTimed(context: Context, window?: TimeWindow): Promise<TimedPosition[]>;
+    private contexts;
+    getAllTracks(query?: TrackQuery): Promise<{
+        context: string;
+        track: LatLngTuple[];
+    }[]>;
+    /**
+     * Tracks whose last position matches the spatial predicate.
+     *
+     * 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.
+     *
+     * Because `matcher` has the final say, dropping the exact-bounds check inside
+     * `contextsInBounds` does not change any result; it only widens the candidate
+     * set. It is kept because a prefilter that returns half the table is not
+     * worth running, not because correctness depends on it.
+     */
+    getFilteredTracks(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug, query?: TrackQuery): Promise<TrackCollection>;
+    /**
+     * 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 — both the cell prefilter and the authoritative
+     * last-position test run once, here.
+     */
+    getFilteredTimedTracks(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug, query?: TrackQuery): Promise<TimedTrackCollection>;
+    /** Contexts with at least one position inside `bounds`, via the cell index. */
+    private contextsInBounds;
+    /**
+     * Split a context's positions into segments, breaking where the recording
+     * stopped for longer than `segmentGap` — an overnight stop should not draw a
+     * straight line across the anchorage.
+     */
+    segments(context: Context, window?: TimeWindow): LatLngTuple[][];
+    prune(maxAge: number): void;
+    close(): void;
+    /** Unsigned round-trip check, used by the tests. */
+    cellIdsFor(context: Context): bigint[];
+}

package/dist/sqliteStore.test.d.ts

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

package/dist/stateGate.d.ts

@@ -0,0 +1,40 @@
+import { Context } from './types.js';
+/**
+ * Off unless a user opts in, per the request and because the states worth
+ * pausing on depend on how a boat is used.
+ */
+export declare const DEFAULT_PAUSE_STATES: string[];
+/**
+ * The states a boat is plausibly parked in, offered in the plugin UI.
+ *
+ * A subset of the `navigation.state` enum in `@signalk/signalk-schema` rather
+ * than the whole of it: most of that list is AIS navigational status, and
+ * offering `trawling-hauling` as a reason to stop recording would be noise.
+ */
+export declare const PAUSABLE_STATES: readonly ["moored", "not-under-way", "anchored", "aground"];
+export declare class StateGate {
+    private readonly pauseStates;
+    private readonly selfContext;
+    /** Last state seen, for the plugin status line. */
+    private lastState;
+    private pausedCount;
+    constructor(selfContext: string, pauseStates: readonly string[]);
+    /** Whether the gate can ever pause anything. */
+    get enabled(): boolean;
+    /**
+     * Whether to record this position.
+     *
+     * `state` is whatever `navigation.state` currently reads, or undefined when
+     * the vessel does not report it. Undefined records: a boat with no state at
+     * all must not silently stop being tracked.
+     */
+    accept(context: Context, state: string | undefined): boolean;
+    /** The state last seen for the own vessel, or undefined if none yet. */
+    get state(): string | undefined;
+    /** How many positions have been skipped. */
+    get skipped(): number;
+    /** A status line while paused, or undefined when recording. */
+    status(): string | undefined;
+    /** Forget what was seen; used when the plugin restarts. */
+    clear(): void;
+}

package/dist/stateGate.test.d.ts

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

package/dist/store.d.ts

@@ -0,0 +1,63 @@
+import { Context, Debug, LatLngTuple, TimedPosition, TimedTrackCollection, TimeWindow, TrackCollection, TrackParams } from './types.js';
+import { TrackQuery } from './timeWindow.js';
+/**
+ * A track store: somewhere positions are accumulated and queried back.
+ *
+ * The in-memory `Tracks` accumulator is one implementation; a persistent store
+ * is another. The interface is deliberately the surface the plugin already
+ * calls in `index.ts` and nothing more, so that adding an implementation cannot
+ * quietly widen what a store is expected to do.
+ *
+ * Note what is *not* here. `getAllTracks` and `getFilteredTracks` are derived
+ * operations — filtering is a predicate over whole tracks, which the in-memory
+ * implementation applies in JS and a database implementation will want to push
+ * into the query. Both stay on the interface for that reason: a store that can
+ * filter in SQL must be allowed to, rather than being forced to materialise
+ * every track so a caller can filter it afterwards.
+ */
+export interface TrackStore {
+    /** Record a position for a context. `timestamp` defaults to now. */
+    newPosition(context: Context, position: LatLngTuple, timestamp?: number): void;
+    /**
+     * Seed a context's track, replacing whatever it held.
+     *
+     * Used by the History API bootstrap at startup. `timestamps` is positional
+     * against `track`; points without one are dated to the start of time so a
+     * time-window query treats them as older than anything live.
+     */
+    initialTrack(context: Context, track: LatLngTuple[], timestamps?: number[]): void;
+    /**
+     * Positions for a context, oldest first, optionally narrowed to a window.
+     *
+     * Rejects when the context is unknown; the route handlers turn that into a
+     * 404. Resolving with `[]` would be indistinguishable from a vessel that is
+     * known but has not moved.
+     */
+    get(context: Context, window?: TimeWindow): Promise<LatLngTuple[]>;
+    /** As `get`, but keeping the timestamp of each point. */
+    getTimed(context: Context, window?: TimeWindow): Promise<TimedPosition[]>;
+    /** Every known context and its track, thinned to `query.resolution`. */
+    getAllTracks(query?: TrackQuery): Promise<{
+        context: string;
+        track: LatLngTuple[];
+    }[]>;
+    /** As `getFilteredTracks`, but keeping the timestamp of each point. */
+    getFilteredTimedTracks(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug, query?: TrackQuery): Promise<TimedTrackCollection>;
+    /**
+     * Tracks whose *last* position matches a spatial predicate.
+     *
+     * Matching on the last position rather than any position is what makes this
+     * "vessels currently near here" rather than "vessels that ever passed here".
+     */
+    getFilteredTracks(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug, query?: TrackQuery): Promise<TrackCollection>;
+    /** Drop contexts whose newest position is older than `maxAge` ms. */
+    prune(maxAge: number): void;
+    /**
+     * Release any resources held by the store.
+     *
+     * A no-op for the in-memory implementation, which is why it is optional; a
+     * store holding file handles must implement it and the plugin calls it from
+     * `stop()`.
+     */
+    close?(): void;
+}

package/dist/store.test.d.ts

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

package/dist/timeWindow.d.ts

@@ -0,0 +1,50 @@
+import { TimedPosition, TimeWindow } from './types.js';
+export declare class TimeWindowError extends Error {
+}
+export declare function parseDuration(value: string): number;
+export interface TrackQuery {
+    window?: TimeWindow;
+    /** Minimum spacing between returned points, in milliseconds. */
+    resolution?: number;
+    /**
+     * Serve the recording time of every point alongside the geometry.
+     *
+     * Opt-in rather than always-on: the response grows by roughly a third, and
+     * the clients reading these routes today (Freeboard-SK) draw the geometry
+     * and have no use for the times. Consumers that need per-point time — an
+     * IMO-style AIS display drawing dots equally spaced by time, per
+     * SignalK/signalk-server#2504 — ask for it.
+     */
+    times?: boolean;
+}
+/**
+ * Resolve the time-window parameters into an absolute `[from, to)` window.
+ *
+ * Precedence: explicit `from`/`to` win; then `duration`; then the Freeboard
+ * `timespan`/`timespanOffset` pair. Absent all of them, no window is applied
+ * and the whole retained track is returned, as before.
+ */
+export declare function parseTrackQuery(query: Record<string, unknown>, now?: number): TrackQuery;
+/**
+ * Drop points closer together than `resolution` milliseconds, always keeping
+ * the first and last so the track keeps its extent.
+ */
+export declare function thin(points: TimedPosition[], resolution: number | undefined): TimedPosition[];
+/**
+ * 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
+ * sails out of AIS range and back, leaves a hole. Joining across it draws a
+ * straight line through places the vessel never went — across a headland, or
+ * over an anchorage it actually sat still in.
+ *
+ * Operates on timestamped points rather than inside a store, so both the
+ * in-memory and sqlite stores segment identically, and so it composes with
+ * `thin()` — thinning first, then segmenting, keeps a thinned-away gap from
+ * being invented as a join.
+ *
+ * `gap` of 0 or undefined returns a single segment, preserving the old shape.
+ * An empty input returns no segments rather than one empty one, so a caller can
+ * distinguish "no track" from "a track with no points".
+ */
+export declare function segment(points: TimedPosition[], gap: number | undefined): TimedPosition[][];

package/dist/timeWindow.test.d.ts

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

package/dist/trackApi.d.ts

@@ -0,0 +1,77 @@
+import { Temporal } from '@js-temporal/polyfill';
+/**
+ * The v2 Track API contract, declared locally.
+ *
+ * These mirror `@signalk/server-api/tracks`, and are copied here for the same
+ * reason the History API types are: depending on the package would pin this
+ * plugin to a server version, and the subpath is not published yet. Swap the
+ * imports when it is.
+ *
+ * Specified in https://github.com/SignalK/signalk-server/issues/2504 and
+ * implemented in https://github.com/SignalK/signalk-server/pull/2995.
+ */
+/** `[west, south, east, north]` — GeoJSON coordinate order. */
+export type TrackBoundingBox = [number, number, number, number];
+/**
+ * A request as the server hands it to a provider.
+ *
+ * Not every field is honoured here. `maxPoints`, `simplify`, `epsilon` and
+ * `properties` are accepted by the API and ignored by this provider: it serves
+ * positions, and has no co-recorded values to attach or geometry simplifier to
+ * run. A caller gets the full, unsimplified track for the window it asked for,
+ * which is a superset of what it requested rather than a wrong answer. The
+ * response echoes `resolution` when one was requested, so a client can tell a
+ * thinned track from a full one.
+ *
+ * Simplification and co-recorded properties are tracked separately; see
+ * SignalK/tracks.
+ */
+export interface TracksRequest {
+    contexts?: string[];
+    from?: Temporal.Instant;
+    to?: Temporal.Instant;
+    duration?: Temporal.Duration;
+    bbox?: TrackBoundingBox;
+    resolution?: Temporal.Duration;
+    maxPoints?: number;
+    simplify?: boolean;
+    epsilon?: number;
+    times?: boolean;
+    properties?: string[];
+    geometry?: boolean;
+}
+export interface TrackProperties {
+    context: string;
+    isSelf: boolean;
+    contextName?: string;
+    from: string;
+    to: string;
+    bbox?: TrackBoundingBox;
+    pointCount: number;
+    resolution?: string;
+    epsilon?: number;
+    coordTimes?: string[][];
+    appliedProperties?: string[];
+    values?: Record<string, (number | string | null)[][]>;
+}
+export interface TrackFeature {
+    type: 'Feature';
+    geometry: {
+        type: 'MultiLineString';
+        /** `[longitude, latitude]` positions, per segment. */
+        coordinates: [number, number][][];
+    } | null;
+    properties: TrackProperties;
+}
+export interface TracksResponse {
+    type: 'FeatureCollection';
+    features: TrackFeature[];
+}
+export interface TrackApi {
+    getTracks(query: TracksRequest): Promise<TracksResponse>;
+    getTrackContexts(query: TracksRequest): Promise<string[]>;
+}
+/** Present on servers that carry the Track API; absent on older ones. */
+export interface WithTrackApi {
+    registerTrackApiProvider?: (provider: TrackApi) => void;
+}

package/dist/trackApi.e2e.test.d.ts

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

package/dist/trackProvider.d.ts

@@ -0,0 +1,21 @@
+import { TrackStore } from './store.js';
+import { TrackApi } from './trackApi.js';
+/**
+ * Serves the v2 Track API from this plugin's store.
+ *
+ * The store answers the hard parts — spatial filtering, time windows, thinning
+ * — so what is left here is mostly translation: v2's GeoJSON coordinate order
+ * and Temporal values in, GeoJSON Features out. Segmentation is done here,
+ * by `segment()`, because it is what turns a thinned track into the
+ * MultiLineString the wire format wants.
+ *
+ * Registered alongside the v1 routes rather than replacing them, so
+ * Freeboard-SK keeps working until it moves.
+ */
+export interface TrackProviderDeps {
+    store: () => TrackStore | undefined;
+    selfContext: () => string;
+    /** Gap in ms that starts a new segment; 0 leaves the track as one line. */
+    segmentGap: () => number;
+}
+export declare function createTrackProvider(deps: TrackProviderDeps): TrackApi;

package/dist/trackProvider.test.d.ts

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

package/dist/tracks.d.ts

@@ -0,0 +1,67 @@
+import { Subject, Connectable, Observable } from 'rxjs';
+import { TrackQuery } from './timeWindow.js';
+import { TrackStore } from './store.js';
+import { Context, Debug, LatLngTuple, TimedPosition, TimedTrackCollection, TimeWindow, TrackCollection, TrackParams } from './types.js';
+interface TracksMap {
+    [context: string]: TrackAccumulator;
+}
+interface VesselTrack {
+    context: string;
+    track: LatLngTuple[];
+}
+export interface TracksConfig {
+    resolution: number;
+    pointsToKeep: number;
+    fetchInitialTrack?: boolean;
+}
+/**
+ * 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.
+ */
+export declare class Tracks implements TrackStore {
+    tracks: TracksMap;
+    debug: Debug;
+    config: TracksConfig;
+    constructor(config: TracksConfig, debug: Debug);
+    newPosition(context: Context, position: LatLngTuple, timestamp?: number): void;
+    initialTrack(context: Context, track: LatLngTuple[], timestamps?: number[]): void;
+    getAccumulator(context: Context, createIfMissing?: boolean): TrackAccumulator | undefined;
+    get(context: Context, window?: TimeWindow): Promise<LatLngTuple[]>;
+    /**
+     * 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: Context, window?: TimeWindow): Promise<TimedPosition[]>;
+    getAllTracks(query?: TrackQuery): Promise<VesselTrack[]>;
+    getFilteredTracks(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug, query?: TrackQuery): Promise<TrackCollection>;
+    /**
+     * 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.
+     */
+    getFilteredTimedTracks(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug, query?: TrackQuery): Promise<TimedTrackCollection>;
+    prune(maxAge: number): void;
+}
+interface AccumulatorParams {
+    resolution: number;
+    pointsToKeep: number;
+    fetchTrackFor?: string;
+}
+export declare class TrackAccumulator {
+    initialTrack: Subject<TimedPosition[]>;
+    input: Subject<TimedPosition>;
+    latestLatLngTuple: number;
+    accumulatedTrack: Connectable<TimedPosition[]>;
+    /** Timestamped points, used to answer time-window queries. */
+    timedTrack: Observable<TimedPosition[]>;
+    /** Positions only — the long-standing public shape. */
+    track: Observable<LatLngTuple[]>;
+    constructor({ resolution, pointsToKeep, fetchTrackFor }: AccumulatorParams);
+    nextLatLngTuple(position: LatLngTuple, timestamp?: number): void;
+    setInitialTrack(track: LatLngTuple[], timestamps?: number[]): void;
+}
+export {};

package/dist/tracks.test.d.ts

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

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+export type Context = string;
+export type LatLngTuple = [number, number];
+export type LngLatTuple = [number, number];
+/**
+ * A track point with the time it was recorded, in epoch milliseconds.
+ *
+ * Positions are stored as bare `LatLngTuple`s on the wire and in the public
+ * `track` observable; timestamps are kept alongside so time-window queries
+ * (`from`/`to`/`duration`) can slice a track without changing that shape.
+ */
+export interface TimedPosition {
+    position: LatLngTuple;
+    timestamp: number;
+}
+/**
+ * A time window in epoch milliseconds, half-open as `[from, to)`.
+ *
+ * Half-open so the bands a client requests to cover a long trail tile exactly:
+ * `[now-24h, now-1h)` and `[now-1h, now]` share the boundary point without
+ * returning it twice. `inclusiveEnd` closes the final band so the newest fix is
+ * not dropped from a "last hour" query.
+ */
+export interface TimeWindow {
+    from: number;
+    to: number;
+    inclusiveEnd?: boolean;
+}
+export interface Position {
+    latitude: number;
+    longitude: number;
+}
+export interface TrackCollection {
+    [key: string]: LatLngTuple[];
+}
+/** As `TrackCollection`, but each point keeps the time it was recorded. */
+export interface TimedTrackCollection {
+    [key: string]: TimedPosition[];
+}
+export interface GeoBounds {
+    ne: LatLngTuple;
+    sw: LatLngTuple;
+}
+/**
+ * Express `req.query` shape: a value may be absent, a single string, or repeated
+ * into an array when the same key appears more than once in the query string.
+ */
+export type QueryParameters = Record<string, unknown>;
+export interface TrackParams {
+    bbox: GeoBounds | null;
+    radius: number | null;
+}
+export interface Debug {
+    (...args: unknown[]): void;
+    enabled: boolean;
+}

package/dist/utils.d.ts

@@ -0,0 +1,31 @@
+import { LatLngTuple, GeoBounds, QueryParameters, TimedPosition, TrackParams, Debug } from './types.js';
+/**
+ * The recording times of a segment, as ISO-8601 UTC, positionally aligned with
+ * the segment's coordinates.
+ *
+ * UTC because a track outlives the timezone it was recorded in: a passage that
+ * crosses a zone boundary, or a database restored on a boat that has since
+ * moved, must not shift. ISO-8601 rather than the epoch milliseconds held
+ * internally because that is what the rest of Signal K puts on the wire.
+ */
+export declare function toIsoTimes(segment: TimedPosition[]): string[];
+export declare function createInBounds(bounds: GeoBounds): (position: LatLngTuple | null) => boolean;
+/**
+ * Split a bounds that crosses the antimeridian into two that do not.
+ *
+ * A bounds wraps when its west edge is numerically greater than its east edge
+ * (sw lng 179, ne lng -179): the box runs 179 -> 180 -> -179, the short way
+ * across the Pacific. `createInBounds` handles that directly with its +360
+ * arithmetic, but anything that has to describe the box *geometrically* cannot
+ * — a GeoJSON polygon with those corners is read as a band going the long way
+ * round, and an S2 covering of it comes back empty, which turns "vessels near
+ * Fiji" into a silent no results rather than an error.
+ *
+ * Returns one bounds unchanged when there is no wrap, so callers can always
+ * iterate the result.
+ */
+export declare function splitAtAntimeridian(bounds: GeoBounds): GeoBounds[];
+export declare function validateParameters(params: QueryParameters, defaultMaxRadius: number | undefined): TrackParams;
+export declare function createDistanceTo([lat1d, lon1d]: LatLngTuple, debug?: Debug): (d: LatLngTuple | null) => number;
+export declare function resolveContext(vesselId: string, selfContext?: string): string;
+export declare function createMatcher(params: TrackParams, selfPosition?: LatLngTuple, debug?: Debug): (track: LatLngTuple[]) => boolean;

package/dist/utils.test.d.ts

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