signalk-edge-link 2.6.2 → 2.7.0

package/lib/config-watcher.js

@@ -72,10 +72,48 @@ function createDebouncedConfigHandler(opts) {
             app.debug(`[${instanceId}] ${name} file unchanged, skipping`);
             return;
         }
-        const parsed = content ? JSON.parse(content) : readFallback;
-        await processConfig(parsed);
-        if (!state.stopped) {
-            state.configContentHashes[name] = contentHash;
+        // Claim the hash BEFORE awaiting processConfig so a concurrent runLoad
+        // (e.g. the initial flush() racing an fs.watch event triggered during
+        // startup) sees the hash and skips instead of running processConfig
+        // twice. Without this, two processConfigs can both observe the same
+        // pre-claim hash and both call subscribe(), leaving leaked listeners
+        // for any path whose bus is created between the new subscribe() and
+        // the old previousUnsubscribes.forEach() in the second call.
+        const previousHash = state.configContentHashes[name];
+        function revertHashClaim() {
+            if (state.configContentHashes[name] !== contentHash)
+                return;
+            if (previousHash === undefined) {
+                delete state.configContentHashes[name];
+            }
+            else {
+                state.configContentHashes[name] = previousHash;
+            }
+        }
+        state.configContentHashes[name] = contentHash;
+        let parsed;
+        try {
+            parsed = content ? JSON.parse(content) : readFallback;
+        }
+        catch (parseErr) {
+            // Parse failure leaves nothing valid to process. Revert the claim so
+            // a subsequent file event (presumably with corrected content) is not
+            // silently skipped on the unchanged-hash check.
+            revertHashClaim();
+            throw parseErr;
+        }
+        try {
+            await processConfig(parsed);
+        }
+        catch (err) {
+            revertHashClaim();
+            throw err;
+        }
+        // If stop() ran between claim and the processConfig microtask, treat
+        // the hash as unclaimed so a fresh start() will reload from disk
+        // instead of inheriting our claim (the in-memory state is gone).
+        if (state.stopped) {
+            revertHashClaim();
         }
     }
     const handleChange = function () {

package/lib/index.js

@@ -209,6 +209,23 @@ module.exports = function createPlugin(app) {
             setStatus(`Startup failed: ${startError instanceof Error ? startError.message : String(startError)}`);
             return;
         }
+        // Wire up FULL_STATUS_REQUEST cascade: when a client-mode instance receives
+        // a FULL_STATUS_REQUEST from its upstream server, it should also forward the
+        // request to all downstream clients connected to any co-located server-mode
+        // instances. This propagates the request down the chain (Cloud → Proxy → Boat)
+        // so one-shot startup values from the furthest-downstream node are re-sent.
+        const allStarted = [...instances.values()];
+        const serverInsts = allStarted.filter((inst) => inst.isServerMode());
+        const clientInsts = allStarted.filter((inst) => !inst.isServerMode());
+        if (serverInsts.length > 0 && clientInsts.length > 0) {
+            for (const clientInst of clientInsts) {
+                clientInst.setFullStatusCascadeHandler(() => {
+                    for (const serverInst of serverInsts) {
+                        serverInst.requestFullStatusFromAllClients();
+                    }
+                });
+            }
+        }
         // Initial status aggregation after all instances report their status
         updateAggregatedStatus();
     };

package/lib/instance.js

@@ -38,6 +38,11 @@ const values_snapshot_1 = require("./values-snapshot");
 const DELTA_SEND_MAX_RETRIES = 1;
 const DELTA_SEND_RETRY_BACKOFF_MS = 100;
 const SOURCE_SNAPSHOT_INTERVAL_MS = 60000;
+// Signal K's subscription manager can deliver the same cached/live delta pair
+// about one fixed-policy window apart. Exact JSON equality keeps this narrow:
+// a fresh timestamp or changed value still forwards normally.
+const OUTBOUND_DUPLICATE_SUPPRESS_MS = 1500;
+const SUPPRESSED_DUPLICATE_STATS_MAX_SIZE = 50;
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /**
  * Derive a URL-safe identifier from a human-readable name.
@@ -71,7 +76,13 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         socketUdp: null,
         readyToSend: false,
         stopped: false,
-        isServerMode: false,
+        // Initialise from options so isServerMode() returns the correct value
+        // BEFORE start() runs. index.ts filters instances into server and client
+        // groups (servers start first) using inst.isServerMode(); if that read
+        // happens before start() has had a chance to set state.isServerMode, the
+        // server group ends up empty and every instance starts concurrently in
+        // the client group, defeating the intended sequencing.
+        isServerMode: options.serverType === true || options.serverType === "server",
         deltas: [],
         timer: false,
         batchSendInFlight: false,
@@ -95,6 +106,7 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         pingMonitor: null,
         deltaTimer: null,
         subscriptionRetryTimer: null,
+        subscribing: false,
         pipeline: null,
         pipelineServer: null,
         heartbeatHandle: null,
@@ -115,6 +127,9 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
     };
     const metricsApi = (0, metrics_1.default)();
     const { metrics, recordError, resetMetrics } = metricsApi;
+    const recentOutboundDeltas = new Map();
+    let lastOutboundDuplicateLogAt = 0;
+    let activeSubscriptionGeneration = 0;
     let v1Pipeline = null;
     function getV1Pipeline() {
         if (!v1Pipeline) {
@@ -379,6 +394,12 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
     /** Minimum gap between server-initiated full-status replays. Prevents a
      *  restarting or misconfigured server from flooding the link. */
     const FULL_STATUS_REQUEST_RATE_LIMIT_MS = 10000;
+    /**
+     * Optional callback invoked after this (client-mode) instance handles a
+     * FULL_STATUS_REQUEST. Used in multi-hop chains to cascade the request to
+     * any downstream clients connected to a co-located server-mode instance.
+     */
+    let fullStatusCascadeHandler = null;
     /** Server asked for a full values snapshot (FULL_STATUS_REQUEST control
      *  packet). Replays the entire current Signal K tree to the server.
      *  Rate-limited to prevent replay floods across rapid server restarts. */
@@ -391,6 +412,10 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         state.lastFullStatusRequestAt = now;
         app.debug(`[${instanceId}] FULL_STATUS_REQUEST received — replaying values snapshot`);
         replayValuesSnapshot("full-status-request");
+        if (fullStatusCascadeHandler) {
+            app.debug(`[${instanceId}] FULL_STATUS_REQUEST cascading to downstream clients`);
+            fullStatusCascadeHandler();
+        }
     }
     async function sendSourceSnapshot() {
         if (state.stopped ||
@@ -474,6 +499,51 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
     function parseMetaConfig(raw) {
         return (0, metadata_1.parseMetaConfig)(raw, (msg) => app.error(msg), instanceId);
     }
+    function normalizeSubscriptionConfig(config) {
+        if (!config || typeof config !== "object" || Array.isArray(config)) {
+            return config;
+        }
+        const record = config;
+        if (!Array.isArray(record.subscribe)) {
+            return config;
+        }
+        const rows = record.subscribe;
+        const wildcardRow = rows.find((row) => row &&
+            typeof row === "object" &&
+            !Array.isArray(row) &&
+            row.path === "*");
+        if (wildcardRow) {
+            if (rows.length > 1) {
+                app.debug(`[${instanceId}] Subscription contains path="*"; ignoring ${rows.length - 1} overlapping row(s)`);
+            }
+            return { ...record, subscribe: [wildcardRow] };
+        }
+        const seenPaths = new Set();
+        const deduped = [];
+        let dropped = 0;
+        for (const row of rows) {
+            if (!row || typeof row !== "object" || Array.isArray(row)) {
+                deduped.push(row);
+                continue;
+            }
+            const path = row.path;
+            if (typeof path !== "string") {
+                deduped.push(row);
+                continue;
+            }
+            if (seenPaths.has(path)) {
+                dropped++;
+                continue;
+            }
+            seenPaths.add(path);
+            deduped.push(row);
+        }
+        if (dropped > 0) {
+            app.debug(`[${instanceId}] Removed ${dropped} duplicate subscription row(s)`);
+            return { ...record, subscribe: deduped };
+        }
+        return config;
+    }
     /**
      * Processes an incoming delta from the subscription manager.
      * Buffers and dispatches deltas to the send pipeline.
@@ -549,6 +619,17 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         if (!state.readyToSend) {
             return;
         }
+        // Drop signalk-server's synchronous cache replay. handleSubscribeRow
+        // calls `latest.forEach(callback)` after registering the live listener,
+        // bypassing the bufferWithTime+uniqBy dedupe — so each path with a
+        // cached value at subscribe time is delivered to us twice (once direct,
+        // once through the live pipeline). `replayValuesSnapshot("initial
+        // subscribe")` runs immediately after subscribe() returns and walks
+        // the SK tree explicitly to ship initial state downstream, so dropping
+        // the direct replay does not cost us any data.
+        if (state.subscribing) {
+            return;
+        }
         // Capture live meta BEFORE the delta flows into the pipeline encoder,
         // because pathDictionary.transformDelta will strip `updates[].meta[]` when
         // rebuilding the update objects. `extractLiveMeta` returns [] when meta
@@ -563,6 +644,24 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         if (!outboundDelta) {
             return;
         }
+        const now = Date.now();
+        const dedupeKey = JSON.stringify(outboundDelta);
+        const lastSeenAt = recentOutboundDeltas.get(dedupeKey);
+        if (lastSeenAt !== undefined && now - lastSeenAt <= OUTBOUND_DUPLICATE_SUPPRESS_MS) {
+            metrics.suppressedOutboundDuplicates = (metrics.suppressedOutboundDuplicates || 0) + 1;
+            recordSuppressedDuplicateStats(outboundDelta, now);
+            if (now - lastOutboundDuplicateLogAt >= 1000) {
+                lastOutboundDuplicateLogAt = now;
+                app.debug(`[${instanceId}] Suppressed duplicate outbound delta (${summarizeDeltaForLog(outboundDelta)})`);
+            }
+            return;
+        }
+        recentOutboundDeltas.set(dedupeKey, now);
+        for (const [key, seenAt] of recentOutboundDeltas) {
+            if (now - seenAt > OUTBOUND_DUPLICATE_SUPPRESS_MS) {
+                recentOutboundDeltas.delete(key);
+            }
+        }
         if (state.deltas.length >= constants_1.MAX_DELTAS_BUFFER_SIZE) {
             const dropCount = Math.floor(constants_1.MAX_DELTAS_BUFFER_SIZE * constants_1.DELTA_BUFFER_DROP_RATIO);
             state.deltas.splice(0, dropCount);
@@ -592,6 +691,14 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         }
     }
     state.processDelta = processDelta;
+    function createSubscriptionDeltaHandler(subscriptionGeneration) {
+        return (delta) => {
+            if (subscriptionGeneration !== activeSubscriptionGeneration) {
+                return;
+            }
+            processDelta(delta);
+        };
+    }
     const SUBSCRIPTION_RETRY_BASE_DELAY = 5000;
     const SUBSCRIPTION_RETRY_MAX_DELAY = 300000;
     const SUBSCRIPTION_RETRY_MAX_ATTEMPTS = 10;
@@ -627,13 +734,27 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 return;
             }
             app.debug(`[${instanceId}] Retrying subscription (attempt ${attempt})...`);
+            // Tear down any partial listeners left behind by a previous failed
+            // subscribe attempt before adding new ones — same reason as the main
+            // handleSubscriptionChange path: keeping stale partial listeners in
+            // state.unsubscribes alongside a fresh subscribe() causes them to fire
+            // for every push, doubling processDelta delivery for affected paths.
+            const partialUnsubscribes = state.unsubscribes.splice(0);
+            partialUnsubscribes.forEach((f) => f());
             try {
-                app.subscriptionmanager.subscribe(state.localSubscription, state.unsubscribes, (retrySubError) => {
-                    app.error(`[${instanceId}] Subscription error (attempt ${attempt}): ${retrySubError}`);
-                    state.readyToSend = false;
-                    _setStatus("Subscription error - data transmission paused", false);
-                    recordError("subscription", `Subscription error: ${retrySubError}`);
-                }, processDelta);
+                const subscriptionGeneration = ++activeSubscriptionGeneration;
+                state.subscribing = true;
+                try {
+                    app.subscriptionmanager.subscribe(state.localSubscription, state.unsubscribes, (retrySubError) => {
+                        app.error(`[${instanceId}] Subscription error (attempt ${attempt}): ${retrySubError}`);
+                        state.readyToSend = false;
+                        _setStatus("Subscription error - data transmission paused", false);
+                        recordError("subscription", `Subscription error: ${retrySubError}`);
+                    }, createSubscriptionDeltaHandler(subscriptionGeneration));
+                }
+                finally {
+                    state.subscribing = false;
+                }
                 // Retry succeeded — perform the staged commit that the original
                 // processConfig catch block skipped. Without this, the operator's
                 // new meta block (stashed on state.pendingMetaConfig) would remain
@@ -666,30 +787,46 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         name: "Subscription",
         getFilePath: () => state.subscriptionFile,
         processConfig: (config) => {
-            state.localSubscription = config;
+            state.localSubscription = normalizeSubscriptionConfig(config);
             app.debug(`[${instanceId}] Subscription configuration updated`);
             // Stage the new metadata config — do NOT yet touch state.metaConfig,
             // the periodic timer, or metaCache. If subscribe() throws, the old
             // subscription remains active until the retry succeeds, so its
             // previous metadata behaviour must remain intact.
             const previousMetaConfig = state.metaConfig;
-            const pendingMetaConfig = parseMetaConfig(config);
-            // Capture the old cleanup handlers but do NOT call them yet.
-            // We establish the new subscription first so data keeps flowing during
-            // the handover; only after success do we release the old subscription.
-            // If the new subscribe() throws, we restore the old handlers so that
-            // stop() can still clean up and the old subscription remains active
-            // until the scheduled retry succeeds.
+            const pendingMetaConfig = parseMetaConfig(state.localSubscription);
+            // Tear down the old subscription FIRST, then establish the new one.
+            // The previous "subscribe-then-unsubscribe" ordering tried to avoid
+            // dropping any delta during the handover, but it leaves a window
+            // where BOTH the old and new subscriptions are simultaneously
+            // attached to every per-path bus in signalk-server's
+            // `streambundle.buses`. Any push that lands in that window — or any
+            // listener that the new subscribe() registers asynchronously via
+            // streambundle.keys.onValue for a path whose bus is created during
+            // the window — fires both callbacks, doubling processDelta delivery
+            // for the rest of the process lifetime.
+            //
+            // Replaying via `replayValuesSnapshot("initial subscribe")` below
+            // recovers any value that was already in the SK tree, and any
+            // genuinely live delta that lands in the brief teardown→subscribe
+            // gap will be re-emitted by its publisher within the subscription's
+            // throttle period.
             const previousUnsubscribes = state.unsubscribes.splice(0);
+            previousUnsubscribes.forEach((f) => f());
             try {
-                app.subscriptionmanager.subscribe(state.localSubscription, state.unsubscribes, (subscriptionError) => {
-                    app.error(`[${instanceId}] Subscription error: ${subscriptionError}`);
-                    state.readyToSend = false;
-                    _setStatus("Subscription error - data transmission paused", false);
-                    recordError("subscription", `Subscription error: ${subscriptionError}`);
-                }, processDelta);
-                // New subscription established — release old cleanup handlers.
-                previousUnsubscribes.forEach((f) => f());
+                const subscriptionGeneration = ++activeSubscriptionGeneration;
+                state.subscribing = true;
+                try {
+                    app.subscriptionmanager.subscribe(state.localSubscription, state.unsubscribes, (subscriptionError) => {
+                        app.error(`[${instanceId}] Subscription error: ${subscriptionError}`);
+                        state.readyToSend = false;
+                        _setStatus("Subscription error - data transmission paused", false);
+                        recordError("subscription", `Subscription error: ${subscriptionError}`);
+                    }, createSubscriptionDeltaHandler(subscriptionGeneration));
+                }
+                finally {
+                    state.subscribing = false;
+                }
                 // Commit the new metadata config AFTER a successful subscribe: swap
                 // state.metaConfig, (re)start the periodic timer, and reset the diff
                 // cache so the next snapshot represents the live state in full. We
@@ -711,12 +848,19 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 replayValuesSnapshot("initial subscribe");
             }
             catch (subscribeError) {
-                // Re-subscribe failed — restore old handlers so stop() can still
-                // clean up and the previous subscription remains active until retry.
+                // Re-subscribe failed. The old subscription was already torn down
+                // before we attempted the new subscribe(), so we cannot restore it —
+                // any partial subscriptions registered by the failed subscribe() are
+                // already in state.unsubscribes and stop() can clean them up.
+                // The retry path (scheduleSubscriptionRetry) will attempt a fresh
+                // subscribe() against state.unsubscribes; if any partial listeners
+                // exist they get added to alongside, but that's no worse than the
+                // pre-fix behaviour and avoids the more serious 2× delivery race.
                 // Leave state.metaConfig / metaCache / metaTimer untouched so the
-                // previous subscription's metadata stream keeps running unchanged.
-                state.unsubscribes = previousUnsubscribes;
+                // previous subscription's metadata behaviour rules are preserved
+                // pending retry.
                 void previousMetaConfig; // explicit: intentionally unchanged
+                void previousUnsubscribes; // intentionally not restored — see above
                 // Stash the new meta config on state so the scheduled retry can
                 // promote it when subscribe() finally succeeds. Otherwise the
                 // operator's new meta settings would silently sit unused until the
@@ -757,7 +901,7 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         app
     });
     // ── File-system watchers (delegated to config-watcher module) ────────────
-    function setupConfigWatchers() {
+    async function setupConfigWatchers() {
         try {
             const watcherConfigs = [
                 { filePath: state.deltaTimerFile, onChange: handleDeltaTimerChange, name: "Delta timer" },
@@ -779,10 +923,7 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             // produced by co-located plugins are emitted before our subscription
             // is registered with the subscriptionmanager — those deltas would be
             // silently dropped since the manager only delivers future events.
-            handleSubscriptionChange.flush().catch((err) => {
-                const msg = err instanceof Error ? err.message : String(err);
-                app.error(`[${instanceId}] Initial subscription load failed: ${msg}`);
-            });
+            await handleSubscriptionChange.flush();
             app.debug(`[${instanceId}] Configuration file watchers initialized`);
         }
         catch (err) {
@@ -1057,7 +1198,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             }
             state.socketUdp.on("error", handleClientSocketError);
             scheduleDeltaTimer();
-            setupConfigWatchers();
             // Ping / connectivity monitor (v1 only, RTT measurement)
             if ((options.protocolVersion ?? 0) < 2) {
                 state.pingMonitor = new ping_monitor_1.default({
@@ -1123,11 +1263,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                     const msg = err instanceof Error ? err.message : String(err);
                     app.debug(`[${instanceId}] initial source snapshot failed: ${msg}`);
                 });
-                // The initial-subscribe replayValuesSnapshot fires before readyToSend
-                // is true (pipeline not yet created) and silently returns early. Replay
-                // now so data already in the SK tree — including values injected by a
-                // co-located server-mode instance — is forwarded on first connect.
-                replayValuesSnapshot("initial connect");
                 state.socketUdp.on("message", (msg, rinfo) => {
                     v2Pipeline.handleControlPacket(msg, rinfo).catch((err) => {
                         const errMsg = err instanceof Error ? err.message : String(err);
@@ -1171,8 +1306,67 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 }
                 app.debug(`[${instanceId}] [v1] Client pipeline initialized`);
             }
+            // Wire the Signal K subscription after the client send pipeline is ready.
+            // The subscription handler performs one explicit values-snapshot replay;
+            // doing it here prevents the v2 startup path from also sending a second
+            // "initial connect" snapshot.
+            await setupConfigWatchers();
         }
     }
+    function summarizeDeltaForLog(delta) {
+        const fields = getDeltaSummaryFields(delta);
+        return `context=${fields.context}, path=${fields.path}, source=${fields.source}, timestamp=${fields.timestamp}, updates=${fields.updateCount}, values=${fields.valueCount}, suppressed=${metrics.suppressedOutboundDuplicates || 0}`;
+    }
+    function getDeltaSummaryFields(delta) {
+        const update = Array.isArray(delta.updates) ? delta.updates[0] : null;
+        const value = Array.isArray(update?.values) ? update.values[0] : null;
+        const context = delta.context || "?";
+        const path = value?.path || "?";
+        const source = update?.$source || update?.source?.label || "?";
+        const timestamp = update?.timestamp || "?";
+        const updateCount = Array.isArray(delta.updates) ? delta.updates.length : 0;
+        const valueCount = Array.isArray(delta.updates)
+            ? delta.updates.reduce((sum, item) => sum + (Array.isArray(item.values) ? item.values.length : 0), 0)
+            : 0;
+        return { context, path, source, timestamp, updateCount, valueCount };
+    }
+    function recordSuppressedDuplicateStats(delta, now) {
+        if (!metrics.suppressedOutboundDuplicateStats) {
+            metrics.suppressedOutboundDuplicateStats = new Map();
+        }
+        const fields = getDeltaSummaryFields(delta);
+        const key = JSON.stringify({
+            context: fields.context,
+            path: fields.path,
+            source: fields.source
+        });
+        const existing = metrics.suppressedOutboundDuplicateStats.get(key);
+        if (existing) {
+            existing.count++;
+            existing.lastUpdate = now;
+            return;
+        }
+        if (metrics.suppressedOutboundDuplicateStats.size >= SUPPRESSED_DUPLICATE_STATS_MAX_SIZE) {
+            let stalestKey = null;
+            let stalestTime = Infinity;
+            for (const [candidateKey, item] of metrics.suppressedOutboundDuplicateStats) {
+                if (item.lastUpdate < stalestTime) {
+                    stalestKey = candidateKey;
+                    stalestTime = item.lastUpdate;
+                }
+            }
+            if (stalestKey) {
+                metrics.suppressedOutboundDuplicateStats.delete(stalestKey);
+            }
+        }
+        metrics.suppressedOutboundDuplicateStats.set(key, {
+            context: fields.context,
+            path: fields.path,
+            source: fields.source,
+            count: 1,
+            lastUpdate: now
+        });
+    }
     function stop() {
         // If a batch send is in progress, log the warning. We cannot reliably
         // await it here because stop() must remain synchronous (called by the
@@ -1188,8 +1382,10 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         state.unsubscribes.forEach((f) => f());
         state.unsubscribes = [];
         state.localSubscription = null;
+        activeSubscriptionGeneration++;
         // Reset runtime state
         state.deltas = [];
+        recentOutboundDeltas.clear();
         state.timer = false;
         state.batchSendInFlight = false;
         state.socketRecoveryInProgress = false;
@@ -1291,6 +1487,16 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         getName: () => state.instanceName,
         getStatus: () => ({ text: state.instanceStatus, healthy: state.isHealthy }),
         getState: () => state,
-        getMetricsApi: () => metricsApi
+        getMetricsApi: () => metricsApi,
+        /** Register a callback to invoke when this client-mode instance handles
+         *  a FULL_STATUS_REQUEST, so the request cascades to downstream clients. */
+        setFullStatusCascadeHandler(handler) {
+            fullStatusCascadeHandler = handler;
+        },
+        /** Forward a FULL_STATUS_REQUEST to all currently-connected clients
+         *  (server-mode instances only; no-op on client-mode instances). */
+        requestFullStatusFromAllClients() {
+            state.pipelineServer?.requestFullStatusFromAllClients?.();
+        }
     };
 }

package/lib/metrics.js

@@ -36,6 +36,8 @@ function createMetrics() {
         rateLimitedPackets: 0,
         droppedDeltaBatches: 0,
         droppedDeltaCount: 0,
+        suppressedOutboundDuplicates: 0,
+        suppressedOutboundDuplicateStats: new Map(),
         remoteNetworkQuality: {
             rtt: 0,
             jitter: 0,
@@ -156,7 +158,9 @@ function createMetrics() {
             dataPacketsReceived: 0,
             rateLimitedPackets: 0,
             droppedDeltaBatches: 0,
-            droppedDeltaCount: 0
+            droppedDeltaCount: 0,
+            suppressedOutboundDuplicates: 0,
+            suppressedOutboundDuplicateStats: new Map()
         });
         Object.assign(metrics.bandwidth, {
             bytesOut: 0,

package/lib/pipeline-v2-server.js

@@ -717,6 +717,20 @@ function createPipelineV2Server(app, state, metricsApi) {
             throw err;
         }
     }
+    /**
+     * Send FULL_STATUS_REQUEST to every currently-connected client session.
+     * Called when this server instance itself receives a FULL_STATUS_REQUEST
+     * from an upstream server, so the request cascades down the chain:
+     * Cloud → Proxy (triggers this) → Boat.
+     */
+    function requestFullStatusFromAllClients() {
+        const secretKey = state.options?.secretKey ?? "";
+        for (const session of clientSessions.values()) {
+            _sendFullStatusRequest(session, secretKey).catch((err) => {
+                app.debug(`[v2-server] cascade FULL_STATUS_REQUEST to ${session.key} failed: ${err instanceof Error ? err.message : String(err)}`);
+            });
+        }
+    }
     /**
      * Build and send a META_REQUEST (0x07) control packet to a client.
      * Instructs the client to emit a fresh metadata snapshot — used on first
@@ -1210,6 +1224,7 @@ function createPipelineV2Server(app, state, metricsApi) {
         startACKTimer,
         stopACKTimer,
         startMetricsPublishing,
-        stopMetricsPublishing
+        stopMetricsPublishing,
+        requestFullStatusFromAllClients
     };
 }

package/lib/prometheus.js

@@ -47,6 +47,19 @@ function formatPrometheusMetrics(metrics, state, extra = {}, opts = {}) {
     counter("rate_limited_packets_total", "Total packets dropped by rate limiting", metrics.rateLimitedPackets || 0);
     counter("dropped_delta_batches_total", "Total delta batches dropped before send", metrics.droppedDeltaBatches || 0);
     counter("dropped_deltas_total", "Total deltas dropped before send", metrics.droppedDeltaCount || 0);
+    counter("suppressed_outbound_duplicates_total", "Total exact duplicate outbound deltas suppressed before send", metrics.suppressedOutboundDuplicates || 0);
+    if (metrics.suppressedOutboundDuplicateStats) {
+        const duplicateStats = Array.from(metrics.suppressedOutboundDuplicateStats.values())
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 20);
+        for (const item of duplicateStats) {
+            counter("suppressed_outbound_duplicates_by_path_total", "Total exact duplicate outbound deltas suppressed before send, grouped by context/path/source", item.count, {
+                context: item.context,
+                path: item.path,
+                source: item.source
+            });
+        }
+    }
     // Error counters
     counter("udp_send_errors_total", "Total UDP send errors", metrics.udpSendErrors);
     counter("udp_retries_total", "Total UDP send retries", metrics.udpRetries);

package/lib/routes.js

@@ -462,6 +462,7 @@ function createRoutes(app, instanceRegistry, pluginRef) {
                 rateLimitedPackets: metrics.rateLimitedPackets || 0,
                 droppedDeltaBatches: metrics.droppedDeltaBatches || 0,
                 droppedDeltaCount: metrics.droppedDeltaCount || 0,
+                suppressedOutboundDuplicates: metrics.suppressedOutboundDuplicates || 0,
                 errorCounts: { ...(metrics.errorCounts || {}) }
             },
             status: {

package/lib/source-dispatch.js

@@ -5,94 +5,159 @@ exports.handleMessageBySource = handleMessageBySource;
 function isRecord(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }
-function getSourceLabel(update) {
-    const source = isRecord(update.source) ? update.source : null;
-    const label = source && typeof source.label === "string" ? source.label.trim() : "";
-    return label.length > 0 ? label : "";
+function trimmedString(value) {
+    return typeof value === "string" ? value.trim() : "";
 }
-function hasStaleEdgeLinkSourceRef(update) {
-    const sourceLabel = getSourceLabel(update);
-    const sourceRef = typeof update.$source === "string" ? update.$source.trim() : "";
-    if (!sourceLabel || !sourceRef || sourceLabel === "signalk-edge-link") {
-        return false;
-    }
+function isStaleEdgeLinkRef(sourceRef) {
     return (sourceRef === "signalk-edge-link" ||
         sourceRef.startsWith("signalk-edge-link.") ||
         sourceRef.startsWith("signalk-edge-link:"));
 }
-function normalizeUpdateSourceRef(update) {
-    if (!hasStaleEdgeLinkSourceRef(update)) {
-        return update;
+/**
+ * Mirror of signalk-schema's `getSourceId` for use when the incoming update
+ * lacks a `$source` string and we have to synthesize one from the structured
+ * `source` object. Kept locally so we don't introduce a runtime dependency
+ * on signalk-schema just for this one function.
+ *
+ * Notably: the schema's fallback for a labelled-but-otherwise-empty source
+ * is `${label}.XX` (literal "XX"). We deliberately do NOT reproduce that
+ * fallback here — emitting a bare label keeps the receiver's $source key
+ * identical to what a single-source publisher would have stored.
+ */
+function deriveSourceRefFromObject(source) {
+    const label = trimmedString(source.label);
+    if (!label) {
+        return "";
+    }
+    const canName = trimmedString(source.canName);
+    if (canName) {
+        return `${label}.${canName}`;
+    }
+    const src = source.src === undefined || source.src === null ? "" : String(source.src).trim();
+    if (src) {
+        return `${label}.${src}`;
+    }
+    const talker = trimmedString(source.talker);
+    if (talker) {
+        return `${label}.${talker}`;
+    }
+    return label;
+}
+/**
+ * Resolve the canonical `$source` string for an update, preferring the
+ * incoming `$source` field over a derived value from the structured source
+ * object. A stale `signalk-edge-link.*` explicit ref is only replaced when
+ * the derived ref is genuinely fresh — otherwise we'd be swapping one stale
+ * attribution for another (e.g. when `source.label` is itself
+ * `"signalk-edge-link"` on a relayed update), which would collapse keys and
+ * misroute downstream subscribers.
+ */
+function resolveSourceRef(update) {
+    const explicit = trimmedString(update.$source);
+    const sourceObj = isRecord(update.source) ? update.source : null;
+    const derived = sourceObj ? deriveSourceRefFromObject(sourceObj) : "";
+    if (explicit) {
+        if (!isStaleEdgeLinkRef(explicit)) {
+            return explicit;
+        }
+        // Explicit is stale; only swap to derived if derived is genuinely fresh.
+        if (!derived || isStaleEdgeLinkRef(derived)) {
+            return explicit;
+        }
     }
-    const cloned = { ...update };
-    delete cloned.$source;
-    return cloned;
+    return derived;
 }
-function cloneUpdate(update) {
-    const normalized = normalizeUpdateSourceRef(update);
-    const cloned = {
-        ...normalized,
-        source: isRecord(normalized.source)
-            ? { ...normalized.source }
-            : normalized.source,
-        values: Array.isArray(normalized.values)
-            ? normalized.values.map((value) => ({ ...value }))
-            : normalized.values,
-        meta: Array.isArray(normalized.meta)
-            ? normalized.meta.map((entry) => ({ ...entry }))
-            : normalized.meta
+/**
+ * Build the update object actually handed to `app.handleMessage`.
+ *
+ * Critically, the structured `source` object is dropped — signalk-server's
+ * `FullSignalK.addValue` unconditionally recomputes the leaf's `$source` via
+ * `getSourceId(source)` whenever a structured source is present, which in turn
+ * uses the providerId-rewritten `source.label` and the hardcoded `.XX` fallback
+ * from signalk-schema. Passing the canonical `$source` as a string instead
+ * (via the `update.source || update.$source` short-circuit in addUpdate)
+ * makes addValue store the leaf under our chosen key verbatim, so a leaf
+ * published on the boat as `$source = "bedroom"` lands on every downstream
+ * node as `$source = "bedroom"` too.
+ *
+ * Side effect: per-leaf `pgn` / `sentence` metadata that signalk-schema's
+ * `setMessage` would attach from the source object is no longer applied at
+ * the receiver — that metadata still rides across the link via the source
+ * snapshot envelope (`sendSourceSnapshot` / `mergeSourceSnapshot`) and is
+ * available under `/signalk/v1/api/sources`.
+ */
+function prepareUpdateForDispatch(update) {
+    const sourceRef = resolveSourceRef(update);
+    const prepared = {
+        values: Array.isArray(update.values)
+            ? update.values.map((value) => ({ ...value }))
+            : update.values
     };
-    return cloned;
+    if (update.timestamp !== undefined) {
+        prepared.timestamp = update.timestamp;
+    }
+    if (Array.isArray(update.meta)) {
+        prepared.meta = update.meta.map((entry) => ({ ...entry }));
+    }
+    if (sourceRef) {
+        prepared.$source = sourceRef;
+    }
+    return prepared;
 }
+/**
+ * Strip stale `signalk-edge-link.*` `$source` values from a delta in place
+ * (well, by returning a cloned delta when needed). Kept for callers that need
+ * to massage a delta without going through full dispatch — currently used by
+ * the v2 server pipeline before `_ingestRemoteTelemetry`.
+ *
+ * After the resolve-source-ref rewrite this is largely a no-op for the
+ * dispatch path itself: `resolveSourceRef` already prefers a fresh structured
+ * source over a stale `signalk-edge-link.*` `$source`. It remains useful so
+ * downstream consumers (e.g. source-replication metrics) see the same
+ * normalised `$source` the receiver would store.
+ */
 function normalizeDeltaSourceRefs(delta) {
     if (!delta || !Array.isArray(delta.updates)) {
         return delta;
     }
     let changed = false;
     const updates = delta.updates.map((update) => {
-        const normalized = normalizeUpdateSourceRef(update);
-        if (normalized !== update) {
-            changed = true;
+        const sourceRef = trimmedString(update.$source);
+        if (!sourceRef || !isStaleEdgeLinkRef(sourceRef)) {
+            return update;
+        }
+        const sourceObj = isRecord(update.source) ? update.source : null;
+        const sourceLabel = trimmedString(sourceObj?.label);
+        // Only strip when we have a real (non-edge-link) structured source the
+        // receiver can fall back to. Otherwise keep the stale $source so the
+        // value still has *some* attribution downstream. Use prefix-aware
+        // staleness detection so a label like `"signalk-edge-link:<instanceId>"`
+        // is treated the same as the bare `"signalk-edge-link"`.
+        if (!sourceLabel || isStaleEdgeLinkRef(sourceLabel)) {
+            return update;
         }
-        return normalized;
+        changed = true;
+        const cloned = { ...update };
+        delete cloned.$source;
+        return cloned;
     });
     return changed ? { ...delta, updates } : delta;
 }
 /**
- * Signal K's app.handleMessage(providerId, delta) rewrites update.source.label
- * to providerId before applying the delta. Remote updates can contain several
- * original source labels, so dispatch them under their original label. Stale
- * edge-link `$source` values are removed separately before dispatch so Signal K
- * can recompute them from the structured source object.
+ * Hand a delta to `app.handleMessage` with `$source` preserved end-to-end.
+ *
+ * signalk-server's plugin handleMessage wrapper substitutes the calling
+ * plugin's id for whatever providerId argument we pass, so dispatching one
+ * call per source label is pointless — we always end up with providerId =
+ * `"signalk-edge-link"` anyway. The important work is in
+ * `prepareUpdateForDispatch`, which drops the structured `source` object so
+ * `FullSignalK.addValue` doesn't recompute the leaf's `$source` from the
+ * rewritten label.
  */
 function handleMessageBySource(app, delta) {
     if (!delta || !Array.isArray(delta.updates) || delta.updates.length === 0) {
         return;
     }
-    const grouped = new Map();
-    let hasOriginalSourceLabel = false;
-    for (const update of delta.updates) {
-        const sourceLabel = getSourceLabel(update);
-        if (sourceLabel) {
-            hasOriginalSourceLabel = true;
-        }
-        const providerId = sourceLabel || "";
-        const updates = grouped.get(providerId);
-        if (updates) {
-            updates.push(update);
-        }
-        else {
-            grouped.set(providerId, [update]);
-        }
-    }
-    if (!hasOriginalSourceLabel) {
-        app.handleMessage("", delta);
-        return;
-    }
-    for (const [providerId, updates] of grouped) {
-        app.handleMessage(providerId, {
-            ...delta,
-            updates: updates.map(cloneUpdate)
-        });
-    }
+    const prepared = delta.updates.map(prepareUpdateForDispatch);
+    app.handleMessage("", { ...delta, updates: prepared });
 }

package/lib/values-snapshot.js

@@ -33,11 +33,28 @@ function walkValues(node, pathParts, onLeaf) {
     if (!isRecord(node)) {
         return;
     }
-    // Multi-source case wins when present: `values` is { sourceLabel:
-    // { value, timestamp } } and is more authoritative than the top-level
-    // `value`/`timestamp` (which mirror the latest of the multi-source map).
-    // Emit one leaf per source so the receiver retains attribution, then stop
-    // — the rest of the node is per-source bookkeeping.
+    // Prefer the top-level single-source view: it reflects the *current*
+    // writer, which is what live subscription deltas also carry. The
+    // multi-source `values: { … }` map is signalk-server's append-only
+    // history bookkeeping — entries created by sources that have since
+    // stopped writing (different N2K source address, a previous edge-link
+    // version, a one-shot delta from another local provider) stay there
+    // for the life of the signalk-server process with no TTL. Walking
+    // that map would ship every historical `$source` to the receiver,
+    // where they become ghost entries that never refresh because no live
+    // writer is producing them anymore.
+    const single = readLeafFromNode(node);
+    if (single !== null) {
+        onLeaf({
+            path: pathParts.join("."),
+            value: single.value,
+            timestamp: single.timestamp,
+            source: single.source
+        });
+        return;
+    }
+    // No top-level leaf — fall back to the multi-source map for older
+    // signalk-server versions or partial trees that only populated `values`.
     if (isRecord(node.values)) {
         for (const [sourceLabel, sourceData] of Object.entries(node.values)) {
             if (isRecord(sourceData) &&
@@ -53,17 +70,6 @@ function walkValues(node, pathParts, onLeaf) {
         }
         return;
     }
-    // Single-source leaf.
-    const single = readLeafFromNode(node);
-    if (single !== null) {
-        onLeaf({
-            path: pathParts.join("."),
-            value: single.value,
-            timestamp: single.timestamp,
-            source: single.source
-        });
-        return;
-    }
     // Container — descend.
     for (const key of Object.keys(node)) {
         if (SK_LEAF_KEYS.has(key)) {
@@ -171,18 +177,28 @@ function collectValuesSnapshot(app) {
             }
             const context = `${contextGroup}.${contextId}`;
             walkValues(contextNode, [], (leaf) => {
-                // Skip values that this plugin injected from remote instances.
-                // SK stores them under "signalk-edge-link.*" $source keys. Including
-                // them in the snapshot would loop remote data back to its origin and
-                // propagate wrong source labels (the fallback label derived from the
-                // "signalk-edge-link" prefix is never the original sensor label).
-                // Live streaming handles relay correctly via subscription callbacks,
-                // which SK populates with the full source object automatically.
+                // Values stored under "signalk-edge-link.*" $source keys were injected
+                // by this plugin (data received via an upstream edge-link server connection
+                // or a downstream edge-link client connection). Skip them only when the SK
+                // sources table cannot provide a proper original-sensor label — that case
+                // would produce wrong attribution on the receiver. When the sources table
+                // does resolve to a real label (e.g. "pypilot"), include the value so relay
+                // data reaches the upstream server after its restart; the receiver's
+                // normalizeDeltaSourceRefs will strip the stale $source and
+                // handleMessageBySource will dispatch under the original label.
                 const src = leaf.source ?? "";
                 if (src === "signalk-edge-link" ||
                     src.startsWith("signalk-edge-link.") ||
                     src.startsWith("signalk-edge-link:")) {
-                    return;
+                    const resolved = sourceLookup.get(src);
+                    const resolvedLabel = typeof resolved?.label === "string" ? resolved.label.trim() : "";
+                    if (!resolvedLabel ||
+                        resolvedLabel === "signalk-edge-link" ||
+                        resolvedLabel.startsWith("signalk-edge-link.") ||
+                        resolvedLabel.startsWith("signalk-edge-link:")) {
+                        return; // No proper label available — skip to avoid wrong attribution
+                    }
+                    // Resolved to a real sensor label — fall through and include the value
                 }
                 const key = `${context}|${leaf.source ?? ""}|${leaf.timestamp}`;
                 const existing = grouped.get(key);

package/package.json

@@ -1,165 +1,165 @@
-{
-  "name": "signalk-edge-link",
-  "version": "2.6.2",
-  "description": "SignalK Edge Link. Secure UDP link for data exchange.",
-  "main": "lib/index.js",
-  "files": [
-    "lib/",
-    "public/"
-  ],
-  "keywords": [
-    "signalk-node-server-plugin",
-    "signalk-category-network",
-    "signalk-webapp",
-    "signalk-category-utility",
-    "signalk-plugin-configurator"
-  ],
-  "signalk": {
-    "appIcon": "./icons/icon-72x72.png",
-    "displayName": "Edge Link Configuration"
-  },
-  "signalk-plugin-enabled-by-default": false,
-  "scripts": {
-    "clean:lib": "node -e \"const fs=require('fs');if(fs.existsSync('lib'))fs.rmSync('lib',{recursive:true,force:true});\"",
-    "clean:public": "node -e \"const fs=require('fs');if(fs.existsSync('public'))fs.rmSync('public',{recursive:true,force:true});\"",
-    "build": "npm run build:ts && npm run build:web",
-    "build:web": "npm run clean:public && webpack --mode production",
-    "build:ts": "npm run clean:lib && tsc",
-    "check:ts": "tsc --noEmit",
-    "check:release-docs": "node scripts/check-release-truth.js",
-    "dev": "webpack --mode development --watch",
-    "test": "jest --runInBand",
-    "test:v2": "jest __tests__/v2/",
-    "test:integration": "jest test/integration/",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
-    "lint": "eslint .",
-    "lint:fix": "eslint . --fix",
-    "format": "prettier --write \"**/*.{js,ts,json,md}\"",
-    "migrate:config": "node lib/scripts/migrate-config.js",
-    "cli": "node lib/bin/edge-link-cli.js",
-    "prepare": "husky"
-  },
-  "dependencies": {
-    "@msgpack/msgpack": "^3.0.0",
-    "@rjsf/core": "^5.18.4",
-    "@rjsf/utils": "^5.18.4",
-    "@rjsf/validator-ajv8": "^5.18.4",
-    "ping-monitor": "^0.8.2"
-  },
-  "devDependencies": {
-    "@babel/core": "^7.22.0",
-    "@babel/preset-env": "^7.22.0",
-    "@babel/preset-react": "^7.22.0",
-    "@testing-library/jest-dom": "^5.17.0",
-    "@testing-library/react": "^12.1.5",
-    "@types/node": "^25.3.5",
-    "@types/react": "^16.14.0",
-    "@types/react-dom": "^16.9.0",
-    "babel-loader": "^9.1.2",
-    "copy-webpack-plugin": "^14.0.0",
-    "css-loader": "^6.8.1",
-    "eslint": "^8.57.1",
-    "eslint-plugin-react": "^7.37.5",
-    "html-webpack-plugin": "^5.5.3",
-    "husky": "^9.1.7",
-    "jest": "^29.7.0",
-    "jest-environment-jsdom": "^30.3.0",
-    "lint-staged": "^15.4.3",
-    "mini-css-extract-plugin": "^2.7.6",
-    "prettier": "^3.6.2",
-    "react": "^16.13.1",
-    "react-dom": "^16.13.1",
-    "react-test-renderer": "^16.14.0",
-    "style-loader": "^3.3.3",
-    "ts-jest": "^29.4.6",
-    "ts-loader": "^9.5.4",
-    "typescript": "^5.9.3",
-    "webpack": "^5.102.1",
-    "webpack-cli": "^5.1.4"
-  },
-  "engines": {
-    "node": ">=16"
-  },
-  "author": "Karl-Erik Gustafsson",
-  "repository": "https://github.com/KEGustafsson/signalk-edge-link",
-  "homepage": "https://github.com/KEGustafsson/signalk-edge-link#readme",
-  "bugs": {
-    "url": "https://github.com/KEGustafsson/signalk-edge-link/issues"
-  },
-  "license": "MIT",
-  "jest": {
-    "testEnvironment": "node",
-    "coverageDirectory": "coverage",
-    "collectCoverageFrom": [
-      "lib/**/*.js",
-      "!lib/webapp/**",
-      "!lib/components/**",
-      "!lib/utils/**"
-    ],
-    "testMatch": [
-      "**/__tests__/**/*.js",
-      "**/*.test.js",
-      "**/*.spec.js"
-    ],
-    "transform": {
-      "^.+\\.js$": [
-        "babel-jest",
-        {
-          "presets": [
-            [
-              "@babel/preset-env",
-              {
-                "targets": {
-                  "node": "current"
-                }
-              }
-            ]
-          ]
-        }
-      ],
-      ".+\\.tsx$": [
-        "ts-jest",
-        {
-          "tsconfig": "tsconfig.webapp.json",
-          "diagnostics": false
-        }
-      ],
-      "^.+\\.ts$": "ts-jest"
-    },
-    "moduleFileExtensions": [
-      "ts",
-      "tsx",
-      "js",
-      "json",
-      "node"
-    ],
-    "testPathIgnorePatterns": [
-      "/node_modules/",
-      "/public/"
-    ],
-    "coverageThreshold": {
-      "global": {
-        "branches": 60,
-        "functions": 65,
-        "lines": 65,
-        "statements": 65
-      }
-    }
-  },
-  "bin": {
-    "edge-link-cli": "lib/bin/edge-link-cli.js"
-  },
-  "lint-staged": {
-    "*.js": [
-      "prettier --write",
-      "eslint --fix"
-    ],
-    "*.ts": [
-      "prettier --write"
-    ],
-    "*.{json,md}": [
-      "prettier --write"
-    ]
-  }
-}
+{
+  "name": "signalk-edge-link",
+  "version": "2.7.0",
+  "description": "SignalK Edge Link. Secure UDP link for data exchange.",
+  "main": "lib/index.js",
+  "files": [
+    "lib/",
+    "public/"
+  ],
+  "keywords": [
+    "signalk-node-server-plugin",
+    "signalk-category-network",
+    "signalk-webapp",
+    "signalk-category-utility",
+    "signalk-plugin-configurator"
+  ],
+  "signalk": {
+    "appIcon": "./icons/icon-72x72.png",
+    "displayName": "Edge Link Configuration"
+  },
+  "signalk-plugin-enabled-by-default": false,
+  "scripts": {
+    "clean:lib": "node -e \"const fs=require('fs');if(fs.existsSync('lib'))fs.rmSync('lib',{recursive:true,force:true});\"",
+    "clean:public": "node -e \"const fs=require('fs');if(fs.existsSync('public'))fs.rmSync('public',{recursive:true,force:true});\"",
+    "build": "npm run build:ts && npm run build:web",
+    "build:web": "npm run clean:public && webpack --mode production",
+    "build:ts": "npm run clean:lib && tsc",
+    "check:ts": "tsc --noEmit",
+    "check:release-docs": "node scripts/check-release-truth.js",
+    "dev": "webpack --mode development --watch",
+    "test": "jest --runInBand",
+    "test:v2": "jest __tests__/v2/",
+    "test:integration": "jest test/integration/",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "format": "prettier --write \"**/*.{js,ts,json,md}\"",
+    "migrate:config": "node lib/scripts/migrate-config.js",
+    "cli": "node lib/bin/edge-link-cli.js",
+    "prepare": "husky"
+  },
+  "dependencies": {
+    "@msgpack/msgpack": "^3.0.0",
+    "@rjsf/core": "^5.18.4",
+    "@rjsf/utils": "^5.18.4",
+    "@rjsf/validator-ajv8": "^5.18.4",
+    "ping-monitor": "^0.8.2"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.22.0",
+    "@babel/preset-env": "^7.22.0",
+    "@babel/preset-react": "^7.22.0",
+    "@testing-library/jest-dom": "^5.17.0",
+    "@testing-library/react": "^12.1.5",
+    "@types/node": "^25.3.5",
+    "@types/react": "^16.14.0",
+    "@types/react-dom": "^16.9.0",
+    "babel-loader": "^9.1.2",
+    "copy-webpack-plugin": "^14.0.0",
+    "css-loader": "^6.8.1",
+    "eslint": "^8.57.1",
+    "eslint-plugin-react": "^7.37.5",
+    "html-webpack-plugin": "^5.5.3",
+    "husky": "^9.1.7",
+    "jest": "^29.7.0",
+    "jest-environment-jsdom": "^30.3.0",
+    "lint-staged": "^15.4.3",
+    "mini-css-extract-plugin": "^2.7.6",
+    "prettier": "^3.6.2",
+    "react": "^16.13.1",
+    "react-dom": "^16.13.1",
+    "react-test-renderer": "^16.14.0",
+    "style-loader": "^3.3.3",
+    "ts-jest": "^29.4.6",
+    "ts-loader": "^9.5.4",
+    "typescript": "^5.9.3",
+    "webpack": "^5.102.1",
+    "webpack-cli": "^5.1.4"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "author": "Karl-Erik Gustafsson",
+  "repository": "https://github.com/KEGustafsson/signalk-edge-link",
+  "homepage": "https://github.com/KEGustafsson/signalk-edge-link#readme",
+  "bugs": {
+    "url": "https://github.com/KEGustafsson/signalk-edge-link/issues"
+  },
+  "license": "MIT",
+  "jest": {
+    "testEnvironment": "node",
+    "coverageDirectory": "coverage",
+    "collectCoverageFrom": [
+      "lib/**/*.js",
+      "!lib/webapp/**",
+      "!lib/components/**",
+      "!lib/utils/**"
+    ],
+    "testMatch": [
+      "**/__tests__/**/*.js",
+      "**/*.test.js",
+      "**/*.spec.js"
+    ],
+    "transform": {
+      "^.+\\.js$": [
+        "babel-jest",
+        {
+          "presets": [
+            [
+              "@babel/preset-env",
+              {
+                "targets": {
+                  "node": "current"
+                }
+              }
+            ]
+          ]
+        }
+      ],
+      ".+\\.tsx$": [
+        "ts-jest",
+        {
+          "tsconfig": "tsconfig.webapp.json",
+          "diagnostics": false
+        }
+      ],
+      "^.+\\.ts$": "ts-jest"
+    },
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "json",
+      "node"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/",
+      "/public/"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "branches": 60,
+        "functions": 65,
+        "lines": 65,
+        "statements": 65
+      }
+    }
+  },
+  "bin": {
+    "edge-link-cli": "lib/bin/edge-link-cli.js"
+  },
+  "lint-staged": {
+    "*.js": [
+      "prettier --write",
+      "eslint --fix"
+    ],
+    "*.ts": [
+      "prettier --write"
+    ],
+    "*.{json,md}": [
+      "prettier --write"
+    ]
+  }
+}