signalk-edge-link 2.3.0 → 2.4.1

package/lib/connection-config.js

@@ -18,6 +18,7 @@ exports.VALID_CONNECTION_KEYS = [
     "useMsgpack",
     "usePathDictionary",
     "enableNotifications",
+    "skipOwnData",
     "protocolVersion",
     "udpAddress",
     "helloMessageSender",
@@ -75,6 +76,9 @@ function validateConnectionConfig(connection, prefix = "") {
         if (conn.alertThresholds !== undefined) {
             return `${p}alertThresholds is not supported in server mode`;
         }
+        if (conn.skipOwnData !== undefined) {
+            return `${p}skipOwnData is not supported in server mode`;
+        }
     }
     if (!isValidPort(conn.udpPort, 1024)) {
         return `${p}udpPort must be an integer between 1024 and 65535`;
@@ -103,6 +107,9 @@ function validateConnectionConfig(connection, prefix = "") {
     if (conn.enableNotifications !== undefined && typeof conn.enableNotifications !== "boolean") {
         return `${p}enableNotifications must be a boolean`;
     }
+    if (conn.skipOwnData !== undefined && typeof conn.skipOwnData !== "boolean") {
+        return `${p}skipOwnData must be a boolean`;
+    }
     if (conn.name !== undefined &&
         (typeof conn.name !== "string" || conn.name.length > 40)) {
         return `${p}name must be a string of at most 40 characters`;
@@ -328,6 +335,7 @@ function sanitizeConnectionConfig(connection) {
         delete out.congestionControl;
         delete out.bonding;
         delete out.alertThresholds;
+        delete out.skipOwnData;
     }
     return out;
 }

package/lib/delta-sanitizer.js

@@ -1,7 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripOwnDataFromDelta = stripOwnDataFromDelta;
 exports.sanitizeDeltaForSignalK = sanitizeDeltaForSignalK;
 exports.sanitizeDeltaPayloadForSignalK = sanitizeDeltaPayloadForSignalK;
+/**
+ * Path prefixes for data this plugin publishes locally. When the
+ * `skipOwnData` option is set on a client connection, value entries with
+ * matching paths are stripped before the delta is forwarded over the link so
+ * the receiver's Signal K tree is not polluted with the sender's own
+ * edge-link metrics. The `networking.edgeLink.*` subtree is owned entirely
+ * by this plugin so the whole prefix is matched.
+ */
+const OWN_DATA_PATH_PREFIXES = ["networking.edgeLink."];
+/**
+ * RTT paths the plugin publishes — kept by `stripOwnDataFromDelta` even when
+ * `skipOwnData` is on, because operators rely on RTT for link-health
+ * visibility on both sides of the link. Covers v1 modem RTT
+ * (`networking.modem.rtt`, `networking.modem.<instanceId>.rtt`) and v2
+ * edge-link RTT (`networking.edgeLink.rtt`,
+ * `networking.edgeLink.<instanceId>.rtt`).
+ */
+const RTT_PATH_RE = /^networking\.(?:modem|edgeLink)(?:\.[^.]+)?\.rtt$/;
+function isOwnDataPath(path) {
+    if (typeof path !== "string") {
+        return false;
+    }
+    // RTT paths (modem + edgeLink, namespaced or not) are always forwarded so
+    // the receiver retains link-health visibility regardless of skipOwnData.
+    if (RTT_PATH_RE.test(path)) {
+        return false;
+    }
+    for (const prefix of OWN_DATA_PATH_PREFIXES) {
+        // prefix.slice(0, -1) drops the trailing ".", so a published path that
+        // matches the prefix root exactly (e.g. just "networking.edgeLink") still
+        // counts as own data; startsWith(prefix) covers everything underneath.
+        if (path === prefix.slice(0, -1) || path.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Drop value/meta entries whose paths are owned by this plugin. Returns null
+ * when nothing remains to forward. Updates that become empty are dropped; the
+ * delta is dropped entirely when no updates survive.
+ */
+function stripOwnDataFromDelta(delta) {
+    if (!delta || !Array.isArray(delta.updates)) {
+        return null;
+    }
+    let changed = false;
+    const surviving = [];
+    for (const update of delta.updates) {
+        const rawValues = Array.isArray(update.values) ? update.values : [];
+        const values = rawValues.filter((v) => !isOwnDataPath(v?.path));
+        const valuesChanged = values.length !== rawValues.length;
+        const rawMeta = Array.isArray(update.meta) ? update.meta : null;
+        const meta = rawMeta
+            ? rawMeta.filter((m) => !isOwnDataPath(m?.path))
+            : null;
+        const metaChanged = rawMeta !== null && meta !== null && meta.length !== rawMeta.length;
+        if (values.length === 0 && (!meta || meta.length === 0)) {
+            changed = true;
+            continue;
+        }
+        if (valuesChanged || metaChanged) {
+            changed = true;
+            const next = { ...update, values };
+            if (meta && meta.length > 0) {
+                next.meta = meta;
+            }
+            else if (rawMeta) {
+                delete next.meta;
+            }
+            surviving.push(next);
+        }
+        else {
+            surviving.push(update);
+        }
+    }
+    if (surviving.length === 0) {
+        return null;
+    }
+    if (!changed) {
+        return delta;
+    }
+    return { ...delta, updates: surviving };
+}
 function isObject(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value);
 }

package/lib/instance.js

@@ -22,6 +22,7 @@ const dgram_1 = __importDefault(require("dgram"));
 const crypto_1 = require("./crypto");
 const ping_monitor_1 = __importDefault(require("ping-monitor"));
 const metrics_1 = __importDefault(require("./metrics"));
+const source_replication_1 = require("./source-replication");
 const pipeline_1 = __importDefault(require("./pipeline"));
 const pipeline_v2_client_1 = require("./pipeline-v2-client");
 const pipeline_v2_server_1 = require("./pipeline-v2-server");
@@ -32,8 +33,10 @@ const config_io_1 = require("./config-io");
 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 DELTA_SEND_MAX_RETRIES = 1;
 const DELTA_SEND_RETRY_BACKOFF_MS = 100;
+const SOURCE_SNAPSHOT_INTERVAL_MS = 60000;
 // ── Helpers ──────────────────────────────────────────────────────────────────
 /**
  * Derive a URL-safe identifier from a human-readable name.
@@ -102,10 +105,12 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         processDelta: null,
         metaConfig: null,
         metaTimer: null,
+        sourceSnapshotTimer: null,
         metaDiffBuffer: [],
         metaDiffFlushTimer: null,
         metaSnapshotTimers: [],
-        lastMetaRequestAt: 0
+        lastMetaRequestAt: 0,
+        sourceRegistry: (0, source_replication_1.createSourceRegistry)(app)
     };
     const metricsApi = (0, metrics_1.default)();
     const { metrics, recordError, resetMetrics } = metricsApi;
@@ -205,10 +210,25 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
     });
     /**
      * Forward subscribed deltas as-is except for malformed value entries that
-     * Signal K would reject on the receiver side.
+     * Signal K would reject on the receiver side. When `skipOwnData` is set on
+     * a client connection, also drop value/meta entries this plugin publishes
+     * locally under the `networking.edgeLink.*` subtree, so the receiver's
+     * Signal K tree is not polluted with the sender's own edge-link metrics.
+     *
+     * Exception: RTT paths are always forwarded regardless of skipOwnData so
+     * the operator retains link-health visibility on both sides of the link.
+     * The carve-out covers both v2 edge-link RTT
+     * (`networking.edgeLink.rtt`, `networking.edgeLink.<instanceId>.rtt`) and
+     * the v1 modem RTT paths historically published by `publishRtt`
+     * (`networking.modem.rtt`, `networking.modem.<instanceId>.rtt`). See
+     * `stripOwnDataFromDelta` in `delta-sanitizer.ts` for the implementation.
      */
     function filterOutboundDelta(delta) {
-        return (0, delta_sanitizer_1.sanitizeDeltaForSignalK)(delta);
+        const sanitized = (0, delta_sanitizer_1.sanitizeDeltaForSignalK)(delta);
+        if (!sanitized || !options.skipOwnData) {
+            return sanitized;
+        }
+        return (0, delta_sanitizer_1.stripOwnDataFromDelta)(sanitized);
     }
     // ── Metadata streaming ────────────────────────────────────────────────────
     /** In-memory cache of last-sent meta (hashed) per context+path. Used to
@@ -363,6 +383,40 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             app.debug(`[${instanceId}] META_REQUEST snapshot failed: ${msg}`);
         });
     }
+    async function sendSourceSnapshot() {
+        if (state.stopped ||
+            !state.readyToSend ||
+            !state.pipeline ||
+            typeof state.pipeline.sendSourceSnapshot !== "function" ||
+            !options.secretKey ||
+            !options.udpAddress) {
+            return;
+        }
+        const sources = (0, source_snapshot_1.collectSourceSnapshot)(appProxy);
+        if (!sources || Object.keys(sources).length === 0) {
+            return;
+        }
+        try {
+            await state.pipeline.sendSourceSnapshot(sources, options.secretKey, options.udpAddress, options.udpPort);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            app.debug(`[${instanceId}] source snapshot send failed: ${msg}`);
+        }
+    }
+    function restartSourceSnapshotTimer() {
+        clearInterval(state.sourceSnapshotTimer ?? undefined);
+        state.sourceSnapshotTimer = null;
+        if ((options.protocolVersion ?? 0) < 2) {
+            return;
+        }
+        state.sourceSnapshotTimer = setInterval(() => {
+            sendSourceSnapshot().catch((err) => {
+                const msg = err instanceof Error ? err.message : String(err);
+                app.debug(`[${instanceId}] periodic source snapshot failed: ${msg}`);
+            });
+        }, SOURCE_SNAPSHOT_INTERVAL_MS);
+    }
     /** Thin wrapper around the parser in `metadata.ts` so the instance log
      *  line is tagged with this connection's instanceId. Errors from the
      *  shared parser already have the `[meta-config]` prefix. */
@@ -935,6 +989,10 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                             state.readyToSend = true;
                             _setStatus("UDP socket recovered", true);
                             app.debug(`[${instanceId}] UDP socket recovered`);
+                            sendSourceSnapshot().catch((err) => {
+                                const msg = err instanceof Error ? err.message : String(err);
+                                app.debug(`[${instanceId}] recovery source snapshot failed: ${msg}`);
+                            });
                             // A socket-level recovery is the strongest local signal that the
                             // remote receiver may have restarted. Re-prime its meta cache
                             // with a full snapshot so it doesn't have to wait a full
@@ -1012,6 +1070,11 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                 state.heartbeatHandle = v2Pipeline.startHeartbeat(options.udpAddress ?? "", options.udpPort, {
                     heartbeatInterval: options.heartbeatInterval
                 });
+                restartSourceSnapshotTimer();
+                sendSourceSnapshot().catch((err) => {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    app.debug(`[${instanceId}] initial source snapshot failed: ${msg}`);
+                });
                 state.socketUdp.on("message", (msg, rinfo) => {
                     v2Pipeline.handleControlPacket(msg, rinfo).catch((err) => {
                         const errMsg = err instanceof Error ? err.message : String(err);
@@ -1089,6 +1152,8 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         state.helloMessageSender = null;
         clearInterval(state.metaTimer ?? undefined);
         state.metaTimer = null;
+        clearInterval(state.sourceSnapshotTimer ?? undefined);
+        state.sourceSnapshotTimer = null;
         clearTimeout(state.metaDiffFlushTimer ?? undefined);
         state.metaDiffFlushTimer = null;
         for (const handle of state.metaSnapshotTimers) {

package/lib/metadata.js

@@ -49,6 +49,37 @@ function stableStringify(value) {
 function hashMeta(meta) {
     return (0, crypto_1.createHash)("sha1").update(stableStringify(meta)).digest("hex");
 }
+const STRIP_UNSET = Symbol("strip-unset");
+/**
+ * Deep-clone a metadata payload while removing unset placeholders.
+ *
+ * Explicit `null` values are preserved so metadata clear operations
+ * (`{ someField: null }`) can propagate to receivers.
+ *
+ * Returns a private sentinel when no useful data remains.
+ */
+function stripUnsetDeep(value) {
+    if (value === undefined) {
+        return STRIP_UNSET;
+    }
+    if (value === null || typeof value !== "object") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        const cleaned = value
+            .map((item) => stripUnsetDeep(item))
+            .filter((item) => item !== STRIP_UNSET);
+        return cleaned.length > 0 ? cleaned : STRIP_UNSET;
+    }
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+        const cleaned = stripUnsetDeep(v);
+        if (cleaned !== STRIP_UNSET) {
+            out[k] = cleaned;
+        }
+    }
+    return Object.keys(out).length > 0 ? out : STRIP_UNSET;
+}
 /**
  * Cache of the last-sent meta value (hash) per `context+path` pair.
  *
@@ -137,7 +168,13 @@ function walkMeta(node, pathParts, onMeta) {
     }
     const obj = node;
     if (obj.meta && typeof obj.meta === "object" && !Array.isArray(obj.meta)) {
-        onMeta(pathParts.join("."), obj.meta);
+        const cleanedMeta = stripUnsetDeep(obj.meta);
+        if (cleanedMeta !== STRIP_UNSET &&
+            cleanedMeta &&
+            typeof cleanedMeta === "object" &&
+            !Array.isArray(cleanedMeta)) {
+            onMeta(pathParts.join("."), cleanedMeta);
+        }
     }
     for (const key of Object.keys(obj)) {
         // Signal K "value", "timestamp", "$source" are leaves, not sub-paths.
@@ -377,10 +414,17 @@ function extractLiveMeta(delta, config, selfContext) {
             else {
                 context = rawContext;
             }
+            const cleanedMeta = stripUnsetDeep(m.value);
+            if (cleanedMeta === STRIP_UNSET ||
+                !cleanedMeta ||
+                typeof cleanedMeta !== "object" ||
+                Array.isArray(cleanedMeta)) {
+                continue;
+            }
             out.push({
                 context,
                 path: m.path,
-                meta: m.value
+                meta: cleanedMeta
             });
         }
     }

package/lib/pipeline-v2-client.js

@@ -107,6 +107,7 @@ function createPipelineV2Client(app, state, metricsApi) {
     // layer that knows how to build a snapshot from `app.signalk.retrieve()`.
     let metaRequestHandler = null;
     let metaEnvelopeSeq = 0;
+    let sourceEnvelopeSeq = 0;
     // Seed all four meta bandwidth counters so downstream consumers (metrics
     // publishers, prometheus exporter, tests) always see numeric zeros rather
     // than undefined on a fresh pipeline. Uses || 0 at write sites elsewhere as
@@ -398,6 +399,128 @@ function createPipelineV2Client(app, state, metricsApi) {
             throw error;
         }
     }
+    function isSourceRecord(value) {
+        return value !== null && typeof value === "object" && !Array.isArray(value);
+    }
+    function mergeSourcePatch(target, patch) {
+        for (const [key, value] of Object.entries(patch)) {
+            const current = target[key];
+            if (isSourceRecord(current) && isSourceRecord(value)) {
+                mergeSourcePatch(current, value);
+            }
+            else {
+                target[key] = value;
+            }
+        }
+    }
+    function buildSourcePatch(path, value) {
+        let patch = value;
+        for (let i = path.length - 1; i >= 0; i--) {
+            patch = { [path[i]]: patch };
+        }
+        return patch;
+    }
+    function flattenSourcePatches(value, path = []) {
+        if (!isSourceRecord(value)) {
+            return path.length > 0 ? [buildSourcePatch(path, value)] : [];
+        }
+        const entries = Object.entries(value);
+        if (path.length > 0 && entries.length === 0) {
+            return [buildSourcePatch(path, {})];
+        }
+        const patches = [];
+        for (const [key, entry] of entries) {
+            patches.push(...flattenSourcePatches(entry, path.concat(key)));
+        }
+        return patches;
+    }
+    function buildSourceChunk(patches) {
+        const out = {};
+        for (const patch of patches) {
+            mergeSourcePatch(out, patch);
+        }
+        return out;
+    }
+    async function buildSourceSnapshotPacket(sources, envelopeSeq, idx, total, useMsgpack, secretKey) {
+        const envelope = {
+            v: 1,
+            kind: "sources",
+            seq: envelopeSeq >>> 0,
+            idx,
+            total,
+            sources
+        };
+        const serialized = (0, pipeline_utils_1.deltaBuffer)(envelope, useMsgpack);
+        const compressed = await (0, pipeline_utils_1.compressPayload)(serialized, useMsgpack);
+        const encrypted = (0, crypto_1.encryptBinary)(compressed, secretKey, { stretchAsciiKey });
+        return packetBuilder.buildMetadataPacket(encrypted, {
+            compressed: true,
+            encrypted: true,
+            messagepack: useMsgpack,
+            pathDictionary: false
+        });
+    }
+    async function chunkSourceSnapshot(sources, envelopeSeq, useMsgpack, secretKey) {
+        const sourcePatches = flattenSourcePatches(sources);
+        const chunks = [];
+        let currentPatches = [];
+        for (const patch of sourcePatches) {
+            const candidatePatches = currentPatches.concat([patch]);
+            const candidate = buildSourceChunk(candidatePatches);
+            const candidatePacket = await buildSourceSnapshotPacket(candidate, envelopeSeq, sourcePatches.length, sourcePatches.length, useMsgpack, secretKey);
+            if (currentPatches.length > 0 && candidatePacket.length > constants_1.MAX_SAFE_UDP_PAYLOAD) {
+                chunks.push(currentPatches);
+                currentPatches = [patch];
+            }
+            else {
+                currentPatches = candidatePatches;
+            }
+        }
+        if (currentPatches.length > 0) {
+            chunks.push(currentPatches);
+        }
+        let finalChunks = chunks;
+        while (true) {
+            const packets = [];
+            let splitIndex = -1;
+            for (let i = 0; i < finalChunks.length; i++) {
+                const patchChunk = finalChunks[i];
+                const sourceChunk = buildSourceChunk(patchChunk);
+                const packet = await buildSourceSnapshotPacket(sourceChunk, envelopeSeq, i, finalChunks.length, useMsgpack, secretKey);
+                packets.push({ sources: sourceChunk, packet });
+                if (packet.length > constants_1.MAX_SAFE_UDP_PAYLOAD && patchChunk.length > 1) {
+                    splitIndex = i;
+                    break;
+                }
+            }
+            if (splitIndex === -1) {
+                return packets;
+            }
+            const patchesToSplit = finalChunks[splitIndex];
+            const midpoint = Math.ceil(patchesToSplit.length / 2);
+            finalChunks = [
+                ...finalChunks.slice(0, splitIndex),
+                patchesToSplit.slice(0, midpoint),
+                patchesToSplit.slice(midpoint),
+                ...finalChunks.slice(splitIndex + 1)
+            ];
+        }
+    }
+    function recordSentMetadataPacket(packet, udpAddress, udpPort) {
+        if (monitoringHooks) {
+            const rinfo = { address: udpAddress, port: udpPort };
+            if (monitoringHooks.packetCapture) {
+                monitoringHooks.packetCapture.capture(packet, "send", rinfo);
+            }
+            if (monitoringHooks.packetInspector) {
+                monitoringHooks.packetInspector.inspect(packet, "send", rinfo);
+            }
+        }
+        metrics.bandwidth.metaBytesOut = (metrics.bandwidth.metaBytesOut || 0) + packet.length;
+        metrics.bandwidth.metaPacketsOut = (metrics.bandwidth.metaPacketsOut || 0) + 1;
+        metrics.bandwidth.bytesOut += packet.length;
+        metrics.bandwidth.packetsOut++;
+    }
     /**
      * Send a batch of Signal K metadata entries to the receiver as one or more
      * METADATA (0x06) packets. Mirrors the compress → encrypt → packet-build
@@ -446,19 +569,7 @@ function createPipelineV2Client(app, state, metricsApi) {
                     metrics.smartBatching.oversizedPackets++;
                 }
                 await udpSendAsync(packet, udpAddress, udpPort);
-                if (monitoringHooks) {
-                    const rinfo = { address: udpAddress, port: udpPort };
-                    if (monitoringHooks.packetCapture) {
-                        monitoringHooks.packetCapture.capture(packet, "send", rinfo);
-                    }
-                    if (monitoringHooks.packetInspector) {
-                        monitoringHooks.packetInspector.inspect(packet, "send", rinfo);
-                    }
-                }
-                metrics.bandwidth.metaBytesOut = (metrics.bandwidth.metaBytesOut || 0) + packet.length;
-                metrics.bandwidth.metaPacketsOut = (metrics.bandwidth.metaPacketsOut || 0) + 1;
-                metrics.bandwidth.bytesOut += packet.length;
-                metrics.bandwidth.packetsOut++;
+                recordSentMetadataPacket(packet, udpAddress, udpPort);
             }
             // Count one envelope per call (a multi-chunk envelope is logically one
             // snapshot/diff, even though it shows up in metaPacketsOut as N).
@@ -481,6 +592,35 @@ function createPipelineV2Client(app, state, metricsApi) {
             throw error instanceof Error ? error : new Error(msg);
         }
     }
+    async function sendSourceSnapshot(sources, secretKey, udpAddress, udpPort) {
+        try {
+            if (!state.options) {
+                app.debug("sendSourceSnapshot called but plugin is stopped, ignoring");
+                return;
+            }
+            if (!sources || Object.keys(sources).length === 0) {
+                return;
+            }
+            const useMsgpack = !!state.options.useMsgpack;
+            const envelopeSeq = sourceEnvelopeSeq++ >>> 0;
+            const chunks = await chunkSourceSnapshot(sources, envelopeSeq, useMsgpack, secretKey);
+            for (const { packet } of chunks) {
+                if (packet.length > constants_1.MAX_SAFE_UDP_PAYLOAD) {
+                    app.debug(`Warning: v2 source snapshot packet size ${packet.length} bytes exceeds safe MTU (${constants_1.MAX_SAFE_UDP_PAYLOAD}), may fragment.`);
+                    metrics.smartBatching.oversizedPackets++;
+                }
+                await udpSendAsync(packet, udpAddress, udpPort);
+                recordSentMetadataPacket(packet, udpAddress, udpPort);
+            }
+            app.debug(`v2 source snapshot sent: sources=${Object.keys(sources).length}, chunks=${chunks.length}, envSeq=${envelopeSeq}`);
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            app.error(`v2 sendSourceSnapshot error: ${msg}`);
+            recordError("general", `v2 sendSourceSnapshot error: ${msg}`);
+            throw error;
+        }
+    }
     function setMetaRequestHandler(handler) {
         metaRequestHandler = handler;
     }
@@ -775,7 +915,8 @@ function createPipelineV2Client(app, state, metricsApi) {
                 });
             }
         }
-        // Send client-side telemetry to the server
+        // RTT is always published — operators rely on it for link-health visibility
+        // even when skipOwnData suppresses the rest of edge-link's own metrics.
         if (!telemetrySendInFlight &&
             state.readyToSend &&
             state.options &&
@@ -783,6 +924,23 @@ function createPipelineV2Client(app, state, metricsApi) {
             state.options.secretKey &&
             state.options.udpAddress &&
             state.options.udpPort) {
+            const rttValues = [{ path: "networking.edgeLink.rtt", value: metrics.rtt || 0 }];
+            const extraValues = state.options.skipOwnData
+                ? []
+                : [
+                    { path: "networking.edgeLink.jitter", value: metrics.jitter || 0 },
+                    { path: "networking.edgeLink.packetLoss", value: packetLoss },
+                    {
+                        path: "networking.edgeLink.retransmissions",
+                        value: metrics.retransmissions || 0
+                    },
+                    { path: "networking.edgeLink.queueDepth", value: retransmitQueue.getSize() },
+                    { path: "networking.edgeLink.retransmitRate", value: retransmitRate },
+                    {
+                        path: "networking.edgeLink.activeLink",
+                        value: bondingManager ? bondingManager.getActiveLinkName() : "primary"
+                    }
+                ];
             const telemetryDelta = {
                 context: "vessels.self",
                 updates: [
@@ -792,21 +950,7 @@ function createPipelineV2Client(app, state, metricsApi) {
                             type: "plugin"
                         },
                         timestamp: new Date().toISOString(),
-                        values: [
-                            { path: "networking.edgeLink.rtt", value: metrics.rtt || 0 },
-                            { path: "networking.edgeLink.jitter", value: metrics.jitter || 0 },
-                            { path: "networking.edgeLink.packetLoss", value: packetLoss },
-                            {
-                                path: "networking.edgeLink.retransmissions",
-                                value: metrics.retransmissions || 0
-                            },
-                            { path: "networking.edgeLink.queueDepth", value: retransmitQueue.getSize() },
-                            { path: "networking.edgeLink.retransmitRate", value: retransmitRate },
-                            {
-                                path: "networking.edgeLink.activeLink",
-                                value: bondingManager ? bondingManager.getActiveLinkName() : "primary"
-                            }
-                        ]
+                        values: [...rttValues, ...extraValues]
                     }
                 ]
             };
@@ -956,6 +1100,7 @@ function createPipelineV2Client(app, state, metricsApi) {
     return {
         sendDelta,
         sendMetadata,
+        sendSourceSnapshot,
         setMetaRequestHandler,
         getPacketBuilder,
         getRetransmitQueue,