signalk-siparu 0.2.10 → 0.2.12

package/LICENSE

@@ -187,7 +187,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright [yyyy] [name of copyright owner]
+   Copyright 2026 Siparu Ltd
 
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.

package/README.md

@@ -138,9 +138,10 @@ code off the helm. A caller with no browser headers, curl or a script on her own
 is not affected. Neither is the reading surface above.
 
 The two voyage edits are reachable from the boat's own network only. What the
-shore can ask her is a closed set of five questions, all of them reads
-(`history`, `snapshots`, `voyages`, `track`, `phases`); nothing on that socket
-changes anything aboard, and the REST surface above is not proxied to it.
+shore can ask her is a closed set of ten questions, all of them reads
+(`history`, `snapshots`, `voyages`, `track`, `phases`, `rollups`, `stats`,
+`fuel`, `ais`, `health`); nothing on that socket changes anything aboard, and
+the REST surface above is not proxied to it.
 
 ### The uplink, when she is paired
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-siparu",
-  "version": "0.2.10",
+  "version": "0.2.12",
   "description": "Kept aboard, proven ashore. Position, wind, depth and voyage history, recorded on the boat and readable from anywhere: sealed to the devices you name, signed on the way out. A read-only Signal K plugin with a built-in dashboard.",
   "keywords": [
     "signalk-node-server-plugin",

package/plugin/dist/aggregate.d.ts

@@ -0,0 +1,27 @@
+import { MetricAgg, MetricField, RollupHour } from './contract';
+export declare const SPEED_GUARD_KN = 80;
+export interface NumAgg extends MetricAgg {
+    min: number;
+    max: number;
+    avg: number;
+    n: number;
+}
+export declare function haversineNm(lat1: number, lon1: number, lat2: number, lon2: number): number;
+export declare function mergeAggs(aggs: readonly MetricAgg[]): NumAgg | null;
+export interface WindowAgg {
+    count: number;
+    first_ts: number;
+    last_ts: number;
+    distance_nm: number;
+    pos_first: {
+        lat: number;
+        lon: number;
+    } | null;
+    pos_last: {
+        lat: number;
+        lon: number;
+    } | null;
+    metrics: Partial<Record<MetricField, MetricAgg>>;
+    path_metrics?: Record<string, MetricAgg>;
+}
+export declare function mergeHours(hours: readonly RollupHour[], guardKn?: number): WindowAgg;

package/plugin/dist/aggregate.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SPEED_GUARD_KN = void 0;
+exports.haversineNm = haversineNm;
+exports.mergeAggs = mergeAggs;
+exports.mergeHours = mergeHours;
+const contract_1 = require("./contract");
+const EARTH_RADIUS_NM = 3440.065;
+exports.SPEED_GUARD_KN = 80;
+const LINEAR_FIELDS = (0, contract_1.metricFields)('linear');
+const LAST_ONLY_FIELDS = (0, contract_1.metricFields)('angular', 'text');
+function haversineNm(lat1, lon1, lat2, lon2) {
+    const toRad = (d) => (d * Math.PI) / 180;
+    const dLat = toRad(lat2 - lat1);
+    const dLon = toRad(lon2 - lon1);
+    const a = Math.sin(dLat / 2) ** 2 + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLon / 2) ** 2;
+    return 2 * EARTH_RADIUS_NM * Math.asin(Math.min(1, Math.sqrt(a)));
+}
+function mergeAggs(aggs) {
+    let min = Infinity;
+    let max = -Infinity;
+    let sum = 0;
+    let n = 0;
+    let last = null;
+    for (const m of aggs) {
+        if (typeof m.min !== 'number' || typeof m.max !== 'number' || typeof m.avg !== 'number')
+            continue;
+        const mn = m.n ?? 1;
+        if (m.min < min)
+            min = m.min;
+        if (m.max > max)
+            max = m.max;
+        sum += m.avg * mn;
+        n += mn;
+        if (m.last !== null && m.last !== undefined)
+            last = m.last;
+    }
+    return n > 0 ? { min, max, avg: sum / n, n, last } : null;
+}
+function mergeHours(hours, guardKn = exports.SPEED_GUARD_KN) {
+    const sorted = [...hours].sort((a, b) => a.hour.localeCompare(b.hour));
+    const metrics = {};
+    for (const field of LINEAR_FIELDS) {
+        const agg = mergeAggs(sorted.map((h) => h.metrics[field]).filter((m) => m !== undefined));
+        if (agg)
+            metrics[field] = agg;
+    }
+    for (const field of LAST_ONLY_FIELDS) {
+        for (let i = sorted.length - 1; i >= 0; i--) {
+            const m = sorted[i]?.metrics[field];
+            if (m && m.last !== null && m.last !== undefined) {
+                metrics[field] = { last: m.last };
+                break;
+            }
+        }
+    }
+    const path_metrics = {};
+    const keys = new Set();
+    for (const h of sorted)
+        if (h.path_metrics)
+            for (const k of Object.keys(h.path_metrics))
+                keys.add(k);
+    for (const key of keys) {
+        const agg = mergeAggs(sorted.map((h) => h.path_metrics?.[key]).filter((m) => m !== undefined));
+        if (agg)
+            path_metrics[key] = agg;
+    }
+    let distance = sorted.reduce((acc, h) => acc + h.distance_nm, 0);
+    for (let i = 0; i < sorted.length - 1; i++) {
+        const a = sorted[i];
+        const b = sorted[i + 1];
+        if (!a?.pos_last || !b?.pos_first)
+            continue;
+        const dtH = (b.first_ts - a.last_ts) / 3_600_000;
+        if (dtH <= 0)
+            continue;
+        const segNm = haversineNm(a.pos_last.lat, a.pos_last.lon, b.pos_first.lat, b.pos_first.lon);
+        if (segNm / dtH <= guardKn)
+            distance += segNm;
+    }
+    return {
+        count: sorted.reduce((acc, h) => acc + h.count, 0),
+        first_ts: sorted[0]?.first_ts ?? 0,
+        last_ts: sorted[sorted.length - 1]?.last_ts ?? 0,
+        distance_nm: distance,
+        pos_first: sorted.map((h) => h.pos_first).find((p) => p !== null) ?? null,
+        pos_last: [...sorted]
+            .reverse()
+            .map((h) => h.pos_last)
+            .find((p) => p !== null) ?? null,
+        metrics,
+        ...(Object.keys(path_metrics).length > 0 ? { path_metrics } : {})
+    };
+}

package/plugin/dist/ais.d.ts

@@ -6,3 +6,4 @@ export interface AisQuery {
 }
 export declare function buildAisFeed(vessels: unknown, selfContext: string, now: number, q: AisQuery): AisFeed;
 export declare function clampAisQuery(maxNm?: number, maxAgeMin?: number, limit?: number): AisQuery;
+export declare function seesOtherVessels(vessels: unknown, selfContext: string): boolean;

package/plugin/dist/ais.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildAisFeed = buildAisFeed;
 exports.clampAisQuery = clampAisQuery;
+exports.seesOtherVessels = seesOtherVessels;
 const rollup_1 = require("./rollup");
 const MS_TO_KN = 1.9438;
 function nodeValue(node) {
@@ -111,3 +112,9 @@ function clampAisQuery(maxNm, maxAgeMin, limit) {
         limit: clamp(limit, 30, 1, 400)
     };
 }
+function seesOtherVessels(vessels, selfContext) {
+    if (!vessels || typeof vessels !== 'object')
+        return false;
+    const selfKey = selfContext.replace(/^vessels\./, '').trim();
+    return Object.keys(vessels).some((k) => k !== selfKey);
+}

package/plugin/dist/aisreceiver.d.ts

@@ -0,0 +1,17 @@
+export interface AisReceiverStatus {
+    receiver_seen: boolean;
+    first_seen_ts: number | null;
+}
+export declare class AisReceiverMemory {
+    private readonly file;
+    private seen;
+    private written;
+    private firstSeenTs;
+    private writeChain;
+    constructor(dataDir: string);
+    load(): void;
+    note(now: number): void;
+    status(): AisReceiverStatus;
+    flush(): Promise<void>;
+    private write;
+}

package/plugin/dist/aisreceiver.js

@@ -0,0 +1,95 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AisReceiverMemory = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const FILE_VERSION = 1;
+class AisReceiverMemory {
+    file;
+    seen = false;
+    written = false;
+    firstSeenTs = null;
+    writeChain = Promise.resolve();
+    constructor(dataDir) {
+        this.file = path.join(dataDir, 'ais.json');
+    }
+    load() {
+        let text;
+        try {
+            text = fs.readFileSync(this.file, 'utf8');
+        }
+        catch {
+            return;
+        }
+        this.seen = true;
+        this.written = true;
+        try {
+            const raw = JSON.parse(text);
+            if (raw.v === FILE_VERSION && typeof raw.first_seen_ts === 'number') {
+                this.firstSeenTs = raw.first_seen_ts;
+            }
+        }
+        catch {
+        }
+    }
+    note(now) {
+        if (this.written)
+            return;
+        this.written = true;
+        if (!this.seen) {
+            this.seen = true;
+            this.firstSeenTs = now;
+        }
+        const shape = { v: FILE_VERSION, first_seen_ts: this.firstSeenTs ?? now };
+        this.write(async () => {
+            const tmp = `${this.file}.tmp`;
+            await fs.promises.writeFile(tmp, JSON.stringify(shape, null, 2), 'utf8');
+            await fs.promises.rename(tmp, this.file);
+        });
+    }
+    status() {
+        return { receiver_seen: this.seen, first_seen_ts: this.firstSeenTs };
+    }
+    flush() {
+        return this.writeChain.catch(() => undefined);
+    }
+    write(run) {
+        this.writeChain = this.writeChain.then(run, run).catch(() => {
+            this.written = false;
+        });
+    }
+}
+exports.AisReceiverMemory = AisReceiverMemory;

package/plugin/dist/config.js

@@ -4,6 +4,7 @@ exports.CONFIG_SCHEMA = exports.RELAY_URL = exports.KN_TO_MS = exports.INTERNAL
 exports.isCalendarMonthDay = isCalendarMonthDay;
 exports.safeRelayUrl = safeRelayUrl;
 exports.resolveOptions = resolveOptions;
+const aggregate_1 = require("./aggregate");
 exports.DEFAULTS = {
     boatName: '',
     snapshotSeconds: 60,
@@ -29,7 +30,7 @@ exports.INTERNAL = {
     samplePeriodMs: 2000,
     staleMs: 30_000,
     fabricationHorizonMs: 120_000,
-    rollupSpeedGuardKn: 80,
+    rollupSpeedGuardKn: aggregate_1.SPEED_GUARD_KN,
     degradedAfterMs: 5 * 60_000
 };
 exports.KN_TO_MS = 0.514444;

package/plugin/dist/contract.d.ts

@@ -26,10 +26,37 @@ export interface Snapshot {
     path_values?: Record<string, number>;
 }
 export type MetricField = Exclude<keyof Snapshot, 'ts' | 'path_values'>;
+export type MetricKind = 'position' | 'linear' | 'angular' | 'text';
+export declare const METRIC_KIND: {
+    readonly lat: "position";
+    readonly lon: "position";
+    readonly sog: "linear";
+    readonly rate_of_turn: "linear";
+    readonly magnetic_variation: "linear";
+    readonly magnetic_deviation: "linear";
+    readonly wind_speed_apparent: "linear";
+    readonly wind_speed_true: "linear";
+    readonly wind_gust: "linear";
+    readonly air_temp_k: "linear";
+    readonly air_pressure_pa: "linear";
+    readonly depth: "linear";
+    readonly water_temp_k: "linear";
+    readonly gps_satellites: "linear";
+    readonly cog: "angular";
+    readonly heading_mag: "angular";
+    readonly heading_true: "angular";
+    readonly wind_angle_apparent: "angular";
+    readonly wind_direction_true: "angular";
+    readonly nav_state: "text";
+    readonly ais_class: "text";
+    readonly depth_datum: "text";
+};
+export declare function metricFields(...kinds: MetricKind[]): MetricField[];
 export interface MetricAgg {
     min?: number;
     max?: number;
     avg?: number;
+    n?: number;
     last: number | string | null;
 }
 export interface RollupHour {
@@ -77,6 +104,7 @@ export interface SnapshotsQuery {
 export interface SnapshotsResult {
     rows: Snapshot[];
     clamped: boolean;
+    minutesFrom?: number;
 }
 export interface PathSeriesPoint {
     ts: number;
@@ -89,6 +117,7 @@ export interface PathSeriesResult {
     path: string;
     points: PathSeriesPoint[];
     clamped: boolean;
+    minutesFrom?: number;
 }
 export interface HistoryRequest {
     type: 'history';
@@ -191,6 +220,8 @@ export interface InventoryResult {
 }
 export interface HealthResult {
     status: 'ok' | 'degraded';
+    security_off?: boolean;
+    pairing_locked?: boolean;
     now: number;
     started_at: number;
     version: string;
@@ -218,6 +249,10 @@ export interface HealthResult {
         last_hour: string | null;
         hours_pending: number;
     };
+    ais: {
+        receiver_seen: boolean;
+        first_seen_ts: number | null;
+    };
     sealing: {
         devices: number;
         mode: 'sealed' | 'blocked' | 'none';
@@ -347,3 +382,94 @@ export interface DevicePublicKey {
     pub: string;
     approvals?: DeviceApproval[];
 }
+export interface RollupsRequest {
+    type: 'rollups';
+    id: string;
+    from: number;
+    to: number;
+}
+export interface RollupsResult {
+    rows: RollupHour[];
+}
+export type RollupsResponse = {
+    type: 'rollups';
+    id: string;
+    result: RollupsResult;
+} | {
+    type: 'rollups';
+    id: string;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export interface StatsRequest {
+    type: 'stats';
+    id: string;
+}
+export type StatsResponse = {
+    type: 'stats';
+    id: string;
+    result: VoyageStatsResult;
+} | {
+    type: 'stats';
+    id: string;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export interface FuelPathsView {
+    available: string[];
+    selected: string[];
+}
+export interface FuelRequest {
+    type: 'fuel';
+    id: string;
+}
+export type FuelResponse = {
+    type: 'fuel';
+    id: string;
+    result: FuelPathsView;
+} | {
+    type: 'fuel';
+    id: string;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export interface AisRequest {
+    type: 'ais';
+    id: string;
+    maxNm?: number;
+    limit?: number;
+}
+export type AisResponse = {
+    type: 'ais';
+    id: string;
+    result: AisFeed;
+} | {
+    type: 'ais';
+    id: string;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+export interface HealthRequest {
+    type: 'health';
+    id: string;
+}
+export type HealthResponse = {
+    type: 'health';
+    id: string;
+    result: HealthResult;
+} | {
+    type: 'health';
+    id: string;
+    error: {
+        code: string;
+        message: string;
+    };
+};

package/plugin/dist/contract.js

@@ -1,2 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.METRIC_KIND = void 0;
+exports.metricFields = metricFields;
+exports.METRIC_KIND = {
+    lat: 'position',
+    lon: 'position',
+    sog: 'linear',
+    rate_of_turn: 'linear',
+    magnetic_variation: 'linear',
+    magnetic_deviation: 'linear',
+    wind_speed_apparent: 'linear',
+    wind_speed_true: 'linear',
+    wind_gust: 'linear',
+    air_temp_k: 'linear',
+    air_pressure_pa: 'linear',
+    depth: 'linear',
+    water_temp_k: 'linear',
+    gps_satellites: 'linear',
+    cog: 'angular',
+    heading_mag: 'angular',
+    heading_true: 'angular',
+    wind_angle_apparent: 'angular',
+    wind_direction_true: 'angular',
+    nav_state: 'text',
+    ais_class: 'text',
+    depth_datum: 'text'
+};
+function metricFields(...kinds) {
+    return Object.keys(exports.METRIC_KIND).filter((f) => kinds.includes(exports.METRIC_KIND[f]));
+}

package/plugin/dist/index.js

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const ais_1 = require("./ais");
+const aisreceiver_1 = require("./aisreceiver");
 const charts_1 = require("./charts");
 const config_1 = require("./config");
 const fingerprint_1 = require("./fingerprint");
@@ -84,6 +85,7 @@ module.exports = (app) => {
     let boatKeyStore = null;
     let sealingLatch = null;
     let anchorStore = null;
+    let aisMemory = null;
     let screensNow = null;
     let reloadAnchor = null;
     let timer = null;
@@ -183,6 +185,14 @@ module.exports = (app) => {
         }
         return s;
     }
+    function fuelPathsView() {
+        return {
+            available: state
+                ? Object.keys(state.dynamicPaths(Date.now())).filter((p) => p.startsWith('propulsion.') && p.endsWith('.fuel.rate'))
+                : [],
+            selected: opts?.fuelRatePaths ?? []
+        };
+    }
     async function health() {
         if (!state || !store || !rollups || !query)
             throw new Error('not started');
@@ -195,6 +205,8 @@ module.exports = (app) => {
             started_at: startedAt,
             version: packageVersion(),
             boat_name: opts.boatName || app.getSelfPath('name') || null,
+            security_off: (0, pairing_1.securityOff)(app, {}),
+            pairing_locked: (0, pairing_1.securityOff)(app, {}) && !(opts?.acceptOpenNetwork ?? false),
             last_delta_ts: state.lastDeltaTs,
             last_snapshot_ts: lastSnapshotTs,
             snapshots_today: snapshotsToday,
@@ -207,6 +219,7 @@ module.exports = (app) => {
                 oldest_raw: usage.oldest
             },
             rollup: await rollups.status(now),
+            ais: aisMemory?.status() ?? { receiver_seen: false, first_seen_ts: null },
             sealing: (() => {
                 const view = screensNow?.();
                 const held = sealingState();
@@ -320,8 +333,17 @@ module.exports = (app) => {
                         }
                     }
                 });
+                const ais = new aisreceiver_1.AisReceiverMemory(app.getDataDirPath());
+                aisMemory = ais;
+                ais.load();
+                const noteAisTraffic = () => {
+                    if ((0, ais_1.seesOtherVessels)(app.getPath('vessels'), app.selfContext))
+                        ais.note(Date.now());
+                };
+                noteAisTraffic();
                 timer = setInterval(() => {
                     void writeSnapshot();
+                    noteAisTraffic();
                 }, opts.snapshotSeconds * 1000);
                 (0, rest_1.setRestDeps)({
                     live,
@@ -391,6 +413,11 @@ module.exports = (app) => {
                     onPhasesQuery: async (limit) => ({
                         phases: pl.list(Math.min(Math.max(1, limit || 50), 500))
                     }),
+                    onRollupsQuery: async (from, to) => ({ rows: await ru.readHourly(from, to) }),
+                    onStatsQuery: () => vl.stats(ru, Date.now()),
+                    onFuelQuery: async () => fuelPathsView(),
+                    onAisQuery: async (maxNm, limit) => (0, ais_1.buildAisFeed)(app.getPath('vessels'), app.selfContext, Date.now(), (0, ais_1.clampAisQuery)(maxNm, undefined, limit)),
+                    onHealthQuery: () => health(),
                     seal: (frame) => seal.seal(frame),
                     onWatching: () => ks.prompt(),
                     openAsk: (envelope) => seal.open(envelope),
@@ -453,6 +480,8 @@ module.exports = (app) => {
                 await sealingLatch.flush();
             if (anchorStore)
                 await anchorStore.flush();
+            if (aisMemory)
+                await aisMemory.flush();
             state = null;
             store = null;
             rollups = null;
@@ -466,6 +495,7 @@ module.exports = (app) => {
             boatKeyStore = null;
             sealingLatch = null;
             anchorStore = null;
+            aisMemory = null;
             screensNow = null;
             reloadAnchor = null;
             app.setPluginStatus('Stopped');
@@ -498,12 +528,7 @@ module.exports = (app) => {
                 app,
                 acceptOpenNetwork: () => opts?.acceptOpenNetwork ?? false,
                 getConfig: () => currentConfig,
-                fuelPathsView: () => ({
-                    available: state
-                        ? Object.keys(state.dynamicPaths(Date.now())).filter((p) => p.startsWith('propulsion.') && p.endsWith('.fuel.rate'))
-                        : [],
-                    selected: opts?.fuelRatePaths ?? []
-                }),
+                fuelPathsView,
                 restart: (configuration) => pluginRestart?.(configuration)
             });
             (0, voyage_routes_1.registerVoyageEditRoutes)(router, {

package/plugin/dist/live.d.ts

@@ -1,5 +1,5 @@
 import type { RemoteLink } from './remotelink';
-import type { PathSeriesResult, SnapshotsQuery, SnapshotsResult, TrackResult, VoyageListResult, PhaseListResult } from './contract';
+import type { PathSeriesResult, SnapshotsQuery, SnapshotsResult, TrackResult, VoyageListResult, PhaseListResult, RollupsResult, VoyageStatsResult, FuelPathsView, AisFeed, HealthResult } from './contract';
 export declare const FRAME_EVERY_MS = 2000;
 export declare const STILL_FRAME_EVERY_MS = 60000;
 export declare const REPORTING_STALE_MS: number;
@@ -47,6 +47,11 @@ export interface LiveDeps {
     onVoyagesQuery?: (limit: number) => Promise<VoyageListResult>;
     onTrackQuery?: (voyageId: number) => Promise<TrackResult>;
     onPhasesQuery?: (limit: number) => Promise<PhaseListResult>;
+    onRollupsQuery?: (from: number, to: number) => Promise<RollupsResult>;
+    onStatsQuery?: () => Promise<VoyageStatsResult>;
+    onFuelQuery?: () => Promise<FuelPathsView>;
+    onAisQuery?: (maxNm?: number, limit?: number) => Promise<AisFeed>;
+    onHealthQuery?: () => Promise<HealthResult>;
     onWatching?: () => void;
     debug: (msg: string) => void;
     connect?: (url: string, token: string) => LiveSocket;
@@ -90,6 +95,8 @@ export declare class LiveUplink {
     private handleVoyages;
     private handleTrack;
     private handlePhases;
+    private handleMore;
+    private failedRead;
     private refuse;
     private reply;
     private keepalive;
@@ -99,8 +106,10 @@ export declare class LiveUplink {
     private redial;
     private clearTimers;
 }
+type MoreType = 'rollups' | 'stats' | 'fuel' | 'ais' | 'health';
 export declare function rpcEnvelope(data: string): {
-    type: 'history' | 'snapshots' | 'voyages' | 'track' | 'phases';
+    type: 'history' | 'snapshots' | 'voyages' | 'track' | 'phases' | MoreType;
     id: string;
 } | null;
 export declare function isWatchingNote(data: string): boolean;
+export {};