signalk-edge-link 2.5.0 → 2.6.0

package/lib/config-watcher.js

@@ -51,42 +51,37 @@ const crypto = __importStar(require("crypto"));
 const config_io_1 = require("./config-io");
 const constants_1 = require("./constants");
 const { readFile, writeFile, mkdir } = fs_1.promises;
-/**
- * Create a debounced config-change handler.
- */
 function createDebouncedConfigHandler(opts) {
     const { name, getFilePath, processConfig, state, instanceId, app, readFallback } = opts;
-    return function handleChange() {
+    async function runLoad() {
+        if (state.stopped)
+            return;
+        let content;
+        const filePath = getFilePath();
+        if (readFallback !== undefined) {
+            content = filePath ? await readFile(filePath, "utf-8").catch(() => null) : null;
+        }
+        else {
+            content = filePath ? await readFile(filePath, "utf-8") : null;
+        }
+        if (state.stopped)
+            return;
+        const hashSource = content || JSON.stringify(readFallback) || "";
+        const contentHash = crypto.createHash(constants_1.CONTENT_HASH_ALGORITHM).update(hashSource).digest("hex");
+        if (contentHash === state.configContentHashes[name]) {
+            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;
+        }
+    }
+    const handleChange = function () {
         clearTimeout(state.configDebounceTimers[name]);
         state.configDebounceTimers[name] = setTimeout(() => {
-            (async () => {
-                if (state.stopped)
-                    return;
-                let content;
-                const filePath = getFilePath();
-                if (readFallback !== undefined) {
-                    content = filePath ? await readFile(filePath, "utf-8").catch(() => null) : null;
-                }
-                else {
-                    content = filePath ? await readFile(filePath, "utf-8") : null;
-                }
-                if (state.stopped)
-                    return;
-                const hashSource = content || JSON.stringify(readFallback) || "";
-                const contentHash = crypto
-                    .createHash(constants_1.CONTENT_HASH_ALGORITHM)
-                    .update(hashSource)
-                    .digest("hex");
-                if (contentHash === state.configContentHashes[name]) {
-                    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;
-                }
-            })().catch((err) => {
+            runLoad().catch((err) => {
                 if (state.stopped)
                     return;
                 const msg = err instanceof Error ? err.message : String(err);
@@ -94,6 +89,19 @@ function createDebouncedConfigHandler(opts) {
             });
         }, constants_1.FILE_WATCH_DEBOUNCE_DELAY);
     };
+    handleChange.flush = async function flush() {
+        clearTimeout(state.configDebounceTimers[name]);
+        try {
+            await runLoad();
+        }
+        catch (err) {
+            if (state.stopped)
+                return;
+            const msg = err instanceof Error ? err.message : String(err);
+            app.error(`[${instanceId}] Error handling ${name} change: ${msg}`);
+        }
+    };
+    return handleChange;
 }
 /**
  * Create a file-system watcher with automatic recovery on error or rename.

package/lib/instance.js

@@ -34,6 +34,7 @@ const config_watcher_1 = require("./config-watcher");
 const metadata_1 = require("./metadata");
 const delta_sanitizer_1 = require("./delta-sanitizer");
 const source_snapshot_1 = require("./source-snapshot");
+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;
@@ -110,6 +111,7 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         metaDiffFlushTimer: null,
         metaSnapshotTimers: [],
         lastMetaRequestAt: 0,
+        lastFullStatusRequestAt: 0,
         sourceRegistry: (0, source_replication_1.createSourceRegistry)(app)
     };
     const metricsApi = (0, metrics_1.default)();
@@ -383,6 +385,22 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             app.debug(`[${instanceId}] META_REQUEST snapshot failed: ${msg}`);
         });
     }
+    /** 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;
+    /** 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. */
+    function handleFullStatusRequest() {
+        const now = Date.now();
+        if (now - state.lastFullStatusRequestAt < FULL_STATUS_REQUEST_RATE_LIMIT_MS) {
+            app.debug(`[${instanceId}] FULL_STATUS_REQUEST rate-limited, skipping`);
+            return;
+        }
+        state.lastFullStatusRequestAt = now;
+        app.debug(`[${instanceId}] FULL_STATUS_REQUEST received — replaying values snapshot`);
+        replayValuesSnapshot("full-status-request");
+    }
     async function sendSourceSnapshot() {
         if (state.stopped ||
             !state.readyToSend ||
@@ -404,6 +422,48 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             app.debug(`[${instanceId}] source snapshot send failed: ${msg}`);
         }
     }
+    /**
+     * Replay every value currently in the local Signal K tree by feeding
+     * synthetic deltas through `processDelta`. The subscription manager only
+     * delivers *future* deltas, so values published into the tree before
+     * `subscribe()` ran (one-shot startup deltas, or deltas published by a
+     * co-located edge-link server-mode instance via `app.handleMessage`) would
+     * otherwise never reach the receiver. Triggered on initial subscribe
+     * success, on subscribe-retry success, and on UDP socket recovery so the
+     * receiver gets re-primed if it restarted.
+     *
+     * Returns silently if the SignalK app object doesn't expose `signalk`
+     * (older signalk-server versions or test mocks), or while the instance is
+     * not yet ready to send.
+     */
+    function replayValuesSnapshot(reason) {
+        if (state.stopped || !state.readyToSend || !state.processDelta) {
+            return;
+        }
+        let snapshot;
+        try {
+            snapshot = (0, values_snapshot_1.collectValuesSnapshot)(appProxy);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            app.debug(`[${instanceId}] values snapshot collect failed (${reason}): ${msg}`);
+            return;
+        }
+        if (snapshot.length === 0) {
+            return;
+        }
+        app.debug(`[${instanceId}] Replaying ${snapshot.length} value-snapshot delta(s) (${reason})`);
+        for (const delta of snapshot) {
+            try {
+                state.processDelta(delta);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                app.debug(`[${instanceId}] values snapshot replay failed (${reason}): ${msg}`);
+                return;
+            }
+        }
+    }
     function restartSourceSnapshotTimer() {
         clearInterval(state.sourceSnapshotTimer ?? undefined);
         state.sourceSnapshotTimer = null;
@@ -598,6 +658,9 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 }
                 state.readyToSend = true;
                 _setStatus("Subscription restored", true);
+                // Replay current tree state so any value that arrived in the tree
+                // while we were retrying isn't permanently lost.
+                replayValuesSnapshot("subscription retry");
             }
             catch (retryError) {
                 const msg = retryError instanceof Error ? retryError.message : String(retryError);
@@ -649,6 +712,12 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 if (state.metaConfig?.enabled) {
                     scheduleMetadataSnapshot(2000);
                 }
+                // Replay every value already present in the tree. Without this,
+                // one-shot startup deltas published before subscribe() ran (e.g. by
+                // a co-located edge-link server-mode instance) never reach the
+                // receiver, since the subscription manager only delivers future
+                // events.
+                replayValuesSnapshot("initial subscribe");
             }
             catch (subscribeError) {
                 // Re-subscribe failed — restore old handlers so stop() can still
@@ -713,8 +782,16 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 }
             ];
             state.configWatcherObjects = watcherConfigs.map((cfg) => (0, config_watcher_1.createWatcherWithRecovery)({ ...cfg, instanceId, app, state }));
-            // Trigger initial subscription load
-            handleSubscriptionChange();
+            // Trigger initial subscription load immediately (no debounce). The
+            // debounce delay exists to coalesce file-system change events; for the
+            // one-shot startup load it just widens the window during which deltas
+            // 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}`);
+            });
             app.debug(`[${instanceId}] Configuration file watchers initialized`);
         }
         catch (err) {
@@ -1001,6 +1078,10 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                             if (state.metaConfig?.enabled) {
                                 scheduleMetadataSnapshot(1000);
                             }
+                            // Re-prime the receiver's value tree too — a restarted
+                            // receiver lost everything we sent before, and the
+                            // subscription manager won't replay past deltas.
+                            replayValuesSnapshot("socket recovery");
                         }
                         catch (recoveryErr) {
                             state.socketRecoveryInProgress = false;
@@ -1064,6 +1145,9 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 if (typeof v2Pipeline.setMetaRequestHandler === "function") {
                     v2Pipeline.setMetaRequestHandler(handleMetaRequest);
                 }
+                if (typeof v2Pipeline.setFullStatusRequestHandler === "function") {
+                    v2Pipeline.setFullStatusRequestHandler(handleFullStatusRequest);
+                }
                 v2Pipeline.startMetricsPublishing();
                 if (options.congestionControl && options.congestionControl.enabled) {
                     v2Pipeline.startCongestionControl();
@@ -1146,6 +1230,7 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         Object.keys(state.configContentHashes).forEach((k) => delete state.configContentHashes[k]);
         state.excludedSentences = ["GSV"];
         state.lastPacketTime = 0;
+        state.lastFullStatusRequestAt = 0;
         // Reset metrics
         resetMetrics();
         // Clear timers

package/lib/packet.js

@@ -55,7 +55,9 @@ const PacketType = Object.freeze({
     HEARTBEAT: 0x04,
     HELLO: 0x05,
     METADATA: 0x06,
-    META_REQUEST: 0x07
+    META_REQUEST: 0x07,
+    /** Server → client: request a full values snapshot replay. */
+    FULL_STATUS_REQUEST: 0x08
 });
 exports.PacketType = PacketType;
 /**
@@ -176,6 +178,14 @@ class PacketBuilder {
     buildMetaRequestPacket(options = {}) {
         return this._buildPacket(PacketType.META_REQUEST, Buffer.alloc(0), {}, options);
     }
+    /**
+     * Build a FULL_STATUS_REQUEST control packet (server → client).
+     * Payload is empty. Instructs the client to replay its full values snapshot
+     * so the server can rebuild state after a restart.
+     */
+    buildFullStatusRequestPacket(options = {}) {
+        return this._buildPacket(PacketType.FULL_STATUS_REQUEST, Buffer.alloc(0), {}, options);
+    }
     /**
      * Build an ACK packet
      * @param {number} ackedSequence - Sequence number being acknowledged
@@ -404,11 +414,13 @@ class PacketParser {
                 payload = payloadData;
             }
             else {
-                // HEARTBEAT and META_REQUEST packets carry a 0-byte payload with no CRC
-                // — accept as-is. ACK / NAK / HELLO must include a 2-byte CRC16 trailer;
-                // reject undersized payloads so forged control frames cannot slip
-                // through unverified.
-                if (type !== PacketType.HEARTBEAT && type !== PacketType.META_REQUEST) {
+                // HEARTBEAT, META_REQUEST, and FULL_STATUS_REQUEST carry a 0-byte
+                // payload with no CRC — accept as-is. ACK / NAK / HELLO must include
+                // a 2-byte CRC16 trailer; reject undersized payloads so forged control
+                // frames cannot slip through unverified.
+                if (type !== PacketType.HEARTBEAT &&
+                    type !== PacketType.META_REQUEST &&
+                    type !== PacketType.FULL_STATUS_REQUEST) {
                     if (payload.length < 2) {
                         throw new Error(`Control packet payload too short for CRC: ${payload.length} byte(s)`);
                     }
@@ -504,7 +516,8 @@ function getTypeName(type) {
         [PacketType.HEARTBEAT]: "HEARTBEAT",
         [PacketType.HELLO]: "HELLO",
         [PacketType.METADATA]: "METADATA",
-        [PacketType.META_REQUEST]: "META_REQUEST"
+        [PacketType.META_REQUEST]: "META_REQUEST",
+        [PacketType.FULL_STATUS_REQUEST]: "FULL_STATUS_REQUEST"
     };
     return names[type] || "UNKNOWN";
 }

package/lib/pipeline-v2-client.js

@@ -106,6 +106,9 @@ function createPipelineV2Client(app, state, metricsApi) {
     // (META_REQUEST control packet). Wired up by instance.ts, which is the only
     // layer that knows how to build a snapshot from `app.signalk.retrieve()`.
     let metaRequestHandler = null;
+    // Callback fired when the server sends FULL_STATUS_REQUEST, asking the client
+    // to replay its complete current values snapshot.
+    let fullStatusRequestHandler = null;
     let metaEnvelopeSeq = 0;
     let sourceEnvelopeSeq = 0;
     // Seed all four meta bandwidth counters so downstream consumers (metrics
@@ -632,6 +635,9 @@ function createPipelineV2Client(app, state, metricsApi) {
     function setMetaRequestHandler(handler) {
         metaRequestHandler = handler;
     }
+    function setFullStatusRequestHandler(handler) {
+        fullStatusRequestHandler = handler;
+    }
     /**
      * Handle incoming ACK packet from server.
      * Removes acknowledged packets from the retransmit queue.
@@ -772,6 +778,21 @@ function createPipelineV2Client(app, state, metricsApi) {
                     }
                 }
             }
+            else if (parsed.type === packet_1.PacketType.FULL_STATUS_REQUEST) {
+                // Server asks us to replay our full values snapshot (e.g. after a
+                // server restart). Rate-limited in instance.ts to prevent abuse.
+                if (fullStatusRequestHandler) {
+                    try {
+                        Promise.resolve(fullStatusRequestHandler()).catch((err) => {
+                            app.debug(`FULL_STATUS_REQUEST handler rejected: ${err instanceof Error ? err.message : String(err)}`);
+                        });
+                    }
+                    catch (err) {
+                        const errMsg = err instanceof Error ? err.message : String(err);
+                        app.debug(`FULL_STATUS_REQUEST handler error: ${errMsg}`);
+                    }
+                }
+            }
             // Ignore other packet types on client side
         }
         catch (err) {
@@ -1110,6 +1131,7 @@ function createPipelineV2Client(app, state, metricsApi) {
         sendMetadata,
         sendSourceSnapshot,
         setMetaRequestHandler,
+        setFullStatusRequestHandler,
         getPacketBuilder,
         getRetransmitQueue,
         getMetricsPublisher,

package/lib/pipeline-v2-server.js

@@ -178,6 +178,7 @@ function createPipelineV2Server(app, state, metricsApi) {
                 rateLimitCount: 0,
                 rateLimitWindowStart: Date.now(),
                 metaRequested: false,
+                statusRequested: false,
                 lastMetaEnvSeq: null,
                 seenMetaChunkIdx: new Set(),
                 lastSourceEnvSeq: null,
@@ -212,6 +213,8 @@ function createPipelineV2Server(app, state, metricsApi) {
             rateLimitWindowStart: Date.now(),
             // META_REQUEST bookkeeping
             metaRequested: false,
+            // FULL_STATUS_REQUEST bookkeeping
+            statusRequested: false,
             // Stale-envelope rejection for METADATA packets
             lastMetaEnvSeq: null,
             seenMetaChunkIdx: new Set(),
@@ -491,6 +494,7 @@ function createPipelineV2Server(app, state, metricsApi) {
             seenChunkIdx.clear();
             if (!isSource) {
                 session.metaRequested = false;
+                session.statusRequested = false;
             }
         }
         if (lastEnvSeq !== null) {
@@ -610,6 +614,7 @@ function createPipelineV2Server(app, state, metricsApi) {
                     session.lastMetaEnvSeq = null;
                     session.seenMetaChunkIdx.clear();
                     session.metaRequested = false;
+                    session.statusRequested = false;
                 }
                 if (session.lastMetaEnvSeq !== null) {
                     const distance = (envSeq - session.lastMetaEnvSeq) >>> 0;
@@ -697,6 +702,21 @@ function createPipelineV2Server(app, state, metricsApi) {
             recordError("general", `v2 META decode error: ${msg}`);
         }
     }
+    /**
+     * Build and send a FULL_STATUS_REQUEST (0x08) control packet to a client.
+     * Instructs the client to replay its complete current values snapshot so the
+     * server can rebuild state immediately after a restart.
+     */
+    async function _sendFullStatusRequest(session, secretKey) {
+        try {
+            const packet = packetBuilder.buildFullStatusRequestPacket({ secretKey });
+            await _sendUDP(packet, { address: session.address, port: session.port });
+            app.debug(`[v2-server] FULL_STATUS_REQUEST sent to ${session.key}`);
+        }
+        catch (err) {
+            throw 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
@@ -819,6 +839,15 @@ function createPipelineV2Server(app, state, metricsApi) {
                         app.debug(`[v2-server] META_REQUEST send failed: ${err instanceof Error ? err.message : String(err)}`);
                     });
                 }
+                // If the operator enabled full-status-on-restart, also request a values
+                // snapshot. Capped at one per session so rapid HELLOs (e.g. NAT churn)
+                // don't create repeated replay bursts.
+                if (session && !session.statusRequested && state.options?.requestFullStatusOnRestart) {
+                    session.statusRequested = true;
+                    _sendFullStatusRequest(session, secretKey).catch((err) => {
+                        app.debug(`[v2-server] FULL_STATUS_REQUEST send failed: ${err instanceof Error ? err.message : String(err)}`);
+                    });
+                }
                 return;
             }
             if (parsed.type === packet_1.PacketType.METADATA) {
@@ -892,6 +921,14 @@ function createPipelineV2Server(app, state, metricsApi) {
             if (session) {
                 session.hasReceivedData = true;
             }
+            // On first DATA from a new session, request full-status replay if enabled.
+            // This covers the case where the client sends data before its next HELLO.
+            if (session && !session.statusRequested && state.options?.requestFullStatusOnRestart) {
+                session.statusRequested = true;
+                _sendFullStatusRequest(session, secretKey).catch((err) => {
+                    app.debug(`[v2-server] FULL_STATUS_REQUEST (data trigger) send failed: ${err instanceof Error ? err.message : String(err)}`);
+                });
+            }
             const dataSeq = parsed.sequence >>> 0;
             if (session) {
                 if (seqResult.resynced || session.lossBaseSeq === null) {

package/lib/shared/connection-schema.js

@@ -15,7 +15,7 @@
  * results to `RJSFSchema` at call sites.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.alertThresholdsProperty = exports.skipOwnDataProperty = exports.enableNotificationsProperty = exports.bondingProperty = exports.congestionControlProperty = exports.serverReliabilityProperty = exports.clientReliabilityProperty = exports.clientTransportProperties = exports.v1ClientPingProperties = exports.commonConnectionProperties = void 0;
+exports.alertThresholdsProperty = exports.skipOwnDataProperty = exports.enableNotificationsProperty = exports.bondingProperty = exports.congestionControlProperty = exports.serverReliabilityProperty = exports.requestFullStatusOnRestartProperty = exports.clientReliabilityProperty = exports.clientTransportProperties = exports.v1ClientPingProperties = exports.commonConnectionProperties = void 0;
 exports.buildConnectionItemSchema = buildConnectionItemSchema;
 exports.buildWebappConnectionSchema = buildWebappConnectionSchema;
 const crypto_constants_1 = require("./crypto-constants");
@@ -246,6 +246,12 @@ exports.clientReliabilityProperty = {
     }
 };
 // ── v2/v3 reliability (server pipeline — ACK/NAK timing) ──────────────────────
+exports.requestFullStatusOnRestartProperty = {
+    type: "boolean",
+    title: "Request Full Status on Server Start (v2/v3 only)",
+    description: "When enabled, the server sends a request to each client on first contact asking it to replay its complete current values snapshot. This rebuilds the server's state immediately after a restart instead of waiting for incremental deltas to arrive.",
+    default: false
+};
 exports.serverReliabilityProperty = {
     type: "object",
     title: "Reliability Settings (v2/v3 only)",
@@ -511,6 +517,7 @@ function buildConnectionItemSchema() {
                     {
                         properties: {
                             serverType: { enum: ["server"] },
+                            requestFullStatusOnRestart: exports.requestFullStatusOnRestartProperty,
                             reliability: exports.serverReliabilityProperty
                         }
                     },
@@ -567,6 +574,7 @@ function buildWebappConnectionSchema(isClient, protocolVersion) {
         }
     }
     else if (isReliableProtocol) {
+        props.requestFullStatusOnRestart = exports.requestFullStatusOnRestartProperty;
         props.reliability = exports.serverReliabilityProperty;
     }
     return { type: "object", required, properties: props };

package/lib/values-snapshot.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectValuesSnapshot = collectValuesSnapshot;
+// Reserved leaf-level keys we must not descend into when walking the tree.
+const SK_LEAF_KEYS = new Set([
+    "value",
+    "values",
+    "timestamp",
+    "$source",
+    "meta",
+    "sentence",
+    "pgn"
+]);
+// Top-level tree keys that aren't context groups.
+const SK_NON_CONTEXT_KEYS = new Set(["self", "version", "sources"]);
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readLeafFromNode(obj) {
+    // A Signal K value leaf has either a `value` property with sibling
+    // `timestamp`, or a multi-source `values` map. Single-source leaves are the
+    // common case so we handle them first.
+    if ("value" in obj && typeof obj.timestamp === "string") {
+        return {
+            value: obj.value,
+            timestamp: obj.timestamp,
+            source: typeof obj.$source === "string" ? obj.$source : undefined
+        };
+    }
+    return null;
+}
+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.
+    if (isRecord(node.values)) {
+        for (const [sourceLabel, sourceData] of Object.entries(node.values)) {
+            if (isRecord(sourceData) &&
+                "value" in sourceData &&
+                typeof sourceData.timestamp === "string") {
+                onLeaf({
+                    path: pathParts.join("."),
+                    value: sourceData.value,
+                    timestamp: sourceData.timestamp,
+                    source: sourceLabel
+                });
+            }
+        }
+        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)) {
+            continue;
+        }
+        walkValues(node[key], pathParts.concat(key), onLeaf);
+    }
+}
+/**
+ * Build synthetic deltas for every value currently in the Signal K tree.
+ *
+ * Returns one delta per `(context, source)` pair, with all matching leaves
+ * grouped into a single `updates[].values[]` array. `DeltaUpdate.timestamp`
+ * is per-update (not per-leaf), so the latest timestamp across the group is
+ * used — receivers treat the delta as "current state" anyway.
+ *
+ * Returns [] when `app.signalk` isn't exposed (older signalk-server) or the
+ * tree is empty.
+ */
+function collectValuesSnapshot(app) {
+    if (!app.signalk || typeof app.signalk.retrieve !== "function") {
+        return [];
+    }
+    let tree;
+    try {
+        const retrieved = app.signalk.retrieve();
+        if (!isRecord(retrieved)) {
+            return [];
+        }
+        tree = retrieved;
+    }
+    catch {
+        return [];
+    }
+    // Group leaves by (context, source) so we emit one delta per group.
+    const grouped = new Map();
+    for (const contextGroup of Object.keys(tree)) {
+        if (SK_NON_CONTEXT_KEYS.has(contextGroup)) {
+            continue;
+        }
+        const group = tree[contextGroup];
+        if (!isRecord(group)) {
+            continue;
+        }
+        for (const contextId of Object.keys(group)) {
+            const contextNode = group[contextId];
+            if (!isRecord(contextNode)) {
+                continue;
+            }
+            const context = `${contextGroup}.${contextId}`;
+            walkValues(contextNode, [], (leaf) => {
+                const key = `${context}|${leaf.source ?? ""}`;
+                const existing = grouped.get(key);
+                if (existing) {
+                    existing.values.push({ path: leaf.path, value: leaf.value });
+                    if (leaf.timestamp > existing.timestamp) {
+                        existing.timestamp = leaf.timestamp;
+                    }
+                }
+                else {
+                    grouped.set(key, {
+                        context,
+                        source: leaf.source,
+                        timestamp: leaf.timestamp,
+                        values: [{ path: leaf.path, value: leaf.value }]
+                    });
+                }
+            });
+        }
+    }
+    const deltas = [];
+    for (const entry of grouped.values()) {
+        if (entry.values.length === 0) {
+            continue;
+        }
+        const update = {
+            timestamp: entry.timestamp,
+            values: entry.values
+        };
+        if (entry.source) {
+            update.$source = entry.source;
+        }
+        deltas.push({ context: entry.context, updates: [update] });
+    }
+    return deltas;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "signalk-edge-link",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "SignalK Edge Link. Secure UDP link for data exchange.",
   "main": "lib/index.js",
   "files": [