signalk-edge-link 2.5.1 → 2.6.1

package/README.md

@@ -22,6 +22,9 @@ It is designed for links where latency, packet loss, and bandwidth usage matter
   - congestion control
   - optional primary/backup bonding
   - monitoring and alerting endpoints
+  - values snapshot replay on subscribe, retry, and socket recovery
+  - optional server-triggered full-state request on restart (`requestFullStatusOnRestart`)
+  - Signal K path metadata transport (units, descriptions, zones)
 - **Multi-connection support** on one Signal K instance
 
 ## How data flows
@@ -110,11 +113,11 @@ Check that:
 
 ## Protocol version guidance
 
-| Version | Use when                                                  | Notes                                                                       |
-| ------- | --------------------------------------------------------- | --------------------------------------------------------------------------- |
-| v1      | stable local links, simplest setup                        | lower overhead, no ACK/NAK reliability layer                                |
-| v2      | packet loss, variable latency, WAN links                  | adds retransmission, congestion control, bonding, richer monitoring         |
-| v3      | same use cases as v2 when both peers can upgrade together | keeps v2 features and authenticates ACK/NAK/HEARTBEAT/HELLO control packets |
+| Version | Use when                                                  | Notes                                                                         |
+| ------- | --------------------------------------------------------- | ----------------------------------------------------------------------------- |
+| v1      | stable local links, simplest setup                        | lower overhead, no ACK/NAK reliability, no metadata transport                 |
+| v2      | packet loss, variable latency, WAN links                  | adds retransmission, congestion control, bonding, metadata, richer monitoring |
+| v3      | same use cases as v2 when both peers can upgrade together | keeps v2 features and authenticates ACK/NAK/HEARTBEAT/HELLO control packets   |
 
 For unstable links, start with **v3** when both peers support it; fall back to **v2** only when you need compatibility with an already deployed v2 peer.
 
@@ -137,7 +140,7 @@ Most used endpoints:
 - `GET /bonding`
 - `POST /bonding`
 
-For full endpoint details, use `docs/api-reference.md
+For full endpoint details, use `docs/api-reference.md`
 
 ## Configuration model (summary)
 
@@ -151,7 +154,8 @@ Configuration is an array of independent connections:
       "serverType": "server",
       "udpPort": 4446,
       "secretKey": "<32-byte key>",
-      "protocolVersion": 3
+      "protocolVersion": 3,
+      "requestFullStatusOnRestart": false
     },
     {
       "name": "sat-client",
@@ -168,6 +172,7 @@ Configuration is an array of independent connections:
 - Each connection runs independently.
 - Legacy single-object config is auto-normalized to one connection.
 - Client runtime JSON files (`delta_timer.json`, `subscription.json`, `sentence_filter.json`) are stored per connection and can be edited via API.
+- `requestFullStatusOnRestart` (server mode, v2/v3, default `false`): when enabled, the server sends a `FULL_STATUS_REQUEST` to each client on first contact after a (re)start; the client immediately replays its complete values snapshot so the server rebuilds state without waiting for incremental deltas. Client-side rate-limited to 10 s to prevent replay floods across rapid restarts.
 
 For complete setting definitions and ranges, use `docs/configuration-reference.md`.
 
@@ -199,6 +204,24 @@ Common checks:
 - Confirm server UDP port is reachable and not already in use.
 - If link quality is poor, switch to `protocolVersion: 3` when both peers can upgrade together, or `2` if you must stay compatible with an existing v2 peer.
 
+**`testAddress is only supported on v1 clients` after upgrading to v2/v3**
+
+The fields `testAddress`, `testPort`, and `pingIntervalTime` belong to the v1 ping monitor and are not used by v2/v3 clients (which derive RTT from HEARTBEAT exchanges instead). If these fields are present in a connection with `protocolVersion: 2` or `3` the validator will reject the config.
+
+Remove them from the affected connection:
+
+```json
+{
+  "name": "my-client",
+  "serverType": "client",
+  "protocolVersion": 3,
+  "udpAddress": "...",
+  "heartbeatInterval": 25000
+}
+```
+
+The plugin strips these fields automatically on startup, but if you see the error when saving via the SignalK admin UI you need to remove them from the stored config JSON manually once.
+
 For issue-oriented diagnostics, use `docs/troubleshooting.md`.
 
 ## Developer commands
@@ -264,7 +287,7 @@ window.__EDGE_LINK_AUTH__ = {
 - `docs/README.md` (documentation index)
 - `docs/architecture-overview.md` (system architecture and lifecycle)
 - `docs/configuration-reference.md` (settings and defaults)
-- `docs/api-reference.md
+- `docs/api-reference.md`
 - `docs/protocol-v2.md` (reliable protocol operational overview)
 - `docs/protocol-v3-spec.md` (authenticated control-plane details)
 - `docs/bonding.md` (bonding concepts and API usage)

package/lib/connection-config.js

@@ -14,7 +14,6 @@ exports.VALID_CONNECTION_KEYS = [
     "name",
     "serverType",
     "udpPort",
-    "udpMetaPort",
     "secretKey",
     "stretchAsciiKey",
     "useMsgpack",
@@ -28,6 +27,7 @@ exports.VALID_CONNECTION_KEYS = [
     "testAddress",
     "testPort",
     "pingIntervalTime",
+    "requestFullStatusOnRestart",
     "reliability",
     "congestionControl",
     "bonding",
@@ -85,9 +85,6 @@ function validateConnectionConfig(connection, prefix = "") {
     if (!isValidPort(conn.udpPort, 1024)) {
         return `${p}udpPort must be an integer between 1024 and 65535`;
     }
-    if (conn.udpMetaPort !== undefined && !isValidPort(conn.udpMetaPort, 1024)) {
-        return `${p}udpMetaPort must be an integer between 1024 and 65535`;
-    }
     try {
         (0, crypto_1.validateSecretKey)(conn.secretKey);
     }

package/lib/instance.js

@@ -69,7 +69,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         isHealthy: false,
         options,
         socketUdp: null,
-        metaSocketUdp: null,
         readyToSend: false,
         stopped: false,
         isServerMode: false,
@@ -111,6 +110,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)();
@@ -251,16 +251,8 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         if (entries.length === 0) {
             return false;
         }
-        const protoVer = options.protocolVersion ?? 2;
         try {
-            if (protoVer === 1) {
-                if (!options.udpMetaPort || options.udpMetaPort <= 0) {
-                    app.debug(`[${instanceId}] Meta skipped: v1 pipeline requires 'udpMetaPort' in connection config`);
-                    return false;
-                }
-                await getV1Pipeline().packCryptMeta(entries, kind, options.secretKey, options.udpAddress, options.udpMetaPort);
-            }
-            else if (state.pipeline && typeof state.pipeline.sendMetadata === "function") {
+            if (state.pipeline && typeof state.pipeline.sendMetadata === "function") {
                 await state.pipeline.sendMetadata(entries, kind, options.secretKey, options.udpAddress, options.udpPort);
             }
             else {
@@ -384,6 +376,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 ||
@@ -857,34 +865,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                     getV1Pipeline().unpackDecrypt(delta, options.secretKey);
                 });
                 app.debug(`[${instanceId}] [v1] Server pipeline initialized`);
-                // v1 has no packet-type byte, so meta is streamed on a separate UDP
-                // port by the client. Bind that port here when the operator has opted
-                // in. If `udpMetaPort` is unset we simply don't listen — keeping the
-                // receive side idle is the correct default for existing v1 peers that
-                // don't know about meta.
-                if (typeof options.udpMetaPort === "number" && options.udpMetaPort > 0) {
-                    if (options.udpMetaPort === options.udpPort) {
-                        app.error(`[${instanceId}] [v1] udpMetaPort (${options.udpMetaPort}) must differ from udpPort; meta disabled`);
-                    }
-                    else {
-                        const metaSocket = dgram_1.default.createSocket({ type: "udp4", reuseAddr: true });
-                        state.metaSocketUdp = metaSocket;
-                        metaSocket.on("message", (msg) => {
-                            getV1Pipeline()
-                                .unpackDecryptMeta(msg, options.secretKey)
-                                .catch((err) => {
-                                const m = err instanceof Error ? err.message : String(err);
-                                app.debug(`[${instanceId}] [v1] meta decrypt failed: ${m}`);
-                            });
-                        });
-                        metaSocket.on("error", (err) => {
-                            app.error(`[${instanceId}] [v1] meta socket error: ${err.message} (${err.code})`);
-                            recordError("udpSend", `v1 meta socket error: ${err.message} (${err.code})`);
-                        });
-                        metaSocket.bind(options.udpMetaPort);
-                        app.debug(`[${instanceId}] [v1] Meta listener bound to UDP :${options.udpMetaPort}`);
-                    }
-                }
             }
             const startupSocket = state.socketUdp;
             await new Promise((resolve, reject) => {
@@ -1128,6 +1108,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();
@@ -1210,6 +1193,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
@@ -1291,16 +1275,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             state.socketUdp = null;
             app.debug(`[${instanceId}] Stopped`);
         }
-        if (state.metaSocketUdp) {
-            try {
-                state.metaSocketUdp.close();
-            }
-            catch (err) {
-                const msg = err instanceof Error ? err.message : String(err);
-                app.debug(`[${instanceId}] Meta socket close failed: ${msg}`);
-            }
-            state.metaSocketUdp = null;
-        }
         _setStatus("Stopped", false);
     }
     // ── Public API ────────────────────────────────────────────────────────────

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/pipeline.js

@@ -39,15 +39,6 @@ const delta_sanitizer_1 = require("./delta-sanitizer");
 const source_dispatch_1 = require("./source-dispatch");
 const pipeline_utils_1 = require("./pipeline-utils");
 const constants_1 = require("./constants");
-const metadata_1 = require("./metadata");
-/** Leading magic that distinguishes v1 meta payloads from v1 deltas, placed
- *  inside the encrypted plaintext so existing v1 receivers (which do not
- *  recognise it) simply reject the packet rather than misinterpreting it. */
-const V1_META_MAGIC = Buffer.from("SKM1", "ascii");
-/** Threshold for v1 sender-restart detection — see the v2 server's
- *  META_RESTART_THRESHOLD comment. envSeq=0 is treated as a restart only when
- *  the last accepted seq has moved beyond this small reorder window. */
-const META_RESTART_THRESHOLD_V1 = 8;
 /**
  * Creates the data processing pipeline (compress, encrypt, send / receive, decrypt, decompress).
  * @param app - SignalK app object (for logging)
@@ -58,12 +49,6 @@ const META_RESTART_THRESHOLD_V1 = 8;
 function createPipeline(app, state, metricsApi) {
     const { metrics, recordError, trackPathStats } = metricsApi;
     const setStatus = app.setPluginStatus || app.setProviderStatus || (() => { });
-    let metaEnvelopeSeqV1 = 0;
-    // Last accepted inner-envelope seq on the receive side. v1 has no
-    // per-session concept (one socket per pipeline instance), so a single
-    // closure variable is sufficient. Used to drop stale/duplicate envelopes
-    // that UDP reorders or replays.
-    let lastIngestedMetaEnvSeqV1 = null;
     /**
      * Compresses, encrypts, and sends delta data via UDP.
      * Pipeline: Serialize -> Compress -> Encrypt (AES-256-GCM) -> Send
@@ -148,73 +133,6 @@ function createPipeline(app, state, metricsApi) {
             }
         }
     }
-    /**
-     * Sends Signal K path metadata to the receiver using the v1 wire format on a
-     * separate UDP port.
-     *
-     * v1 has no packet-type byte so we cannot multiplex meta with deltas on the
-     * existing port without breaking every deployed v1 receiver. To keep the
-     * change backward-compatible, meta is sent on `udpMetaPort` with a 4-byte
-     * `SKM1` magic prefix inside the encrypted plaintext — a v1 receiver that
-     * has not been upgraded will fail to JSON-parse the payload and simply drop
-     * it without side effects.
-     */
-    async function packCryptMeta(entries, kind, secretKey, udpAddress, udpMetaPort) {
-        try {
-            if (!state.options) {
-                app.debug("packCryptMeta called but plugin is stopped, ignoring");
-                return;
-            }
-            if (!udpMetaPort || udpMetaPort <= 0) {
-                app.debug("packCryptMeta: no udpMetaPort configured, meta disabled on v1");
-                return;
-            }
-            if (entries.length === 0) {
-                return;
-            }
-            const usePathDict = !!state.options.usePathDictionary;
-            const useMsgpack = !!state.options.useMsgpack;
-            const maxPerPacket = state.metaConfig?.maxPathsPerPacket ?? 500;
-            const chunks = (0, metadata_1.splitIntoPackets)(entries, maxPerPacket);
-            const envelopeSeq = metaEnvelopeSeqV1++ >>> 0;
-            for (let i = 0; i < chunks.length; i++) {
-                const chunk = chunks[i];
-                const processed = usePathDict ? chunk.map(pathDictionary_1.encodeMetaEntry) : chunk;
-                const envelope = (0, metadata_1.buildMetaEnvelope)(processed, kind, envelopeSeq, i, chunks.length);
-                const serialized = (0, pipeline_utils_1.deltaBuffer)(envelope, useMsgpack);
-                const withMagic = Buffer.concat([V1_META_MAGIC, serialized]);
-                const compressed = await (0, pipeline_utils_1.compressPayload)(withMagic, useMsgpack);
-                const packet = (0, crypto_1.encryptBinary)(compressed, secretKey, {
-                    stretchAsciiKey: !!state.options.stretchAsciiKey
-                });
-                if (packet.length > constants_1.MAX_SAFE_UDP_PAYLOAD) {
-                    app.debug(`Warning: v1 meta packet size ${packet.length} bytes exceeds safe MTU (${constants_1.MAX_SAFE_UDP_PAYLOAD})`);
-                }
-                await udpSendAsync(packet, udpAddress, udpMetaPort);
-                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++;
-            }
-            if (kind === "snapshot") {
-                metrics.bandwidth.metaSnapshotsSent = (metrics.bandwidth.metaSnapshotsSent || 0) + 1;
-            }
-            else {
-                metrics.bandwidth.metaDiffsSent = (metrics.bandwidth.metaDiffsSent || 0) + 1;
-            }
-            app.debug(`v1 meta sent: kind=${kind}, entries=${entries.length}, chunks=${chunks.length}, envSeq=${envelopeSeq}`);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            app.error(`packCryptMeta error: ${msg}`);
-            recordError("general", `packCryptMeta error: ${msg}`);
-            // Re-throw so the caller (sendMetaEntries) can tell the send failed
-            // and refrain from committing the MetaCache. Without this, a broken
-            // socket/encryption/compression would silently suppress every future
-            // diff for the affected paths.
-            throw error instanceof Error ? error : new Error(msg);
-        }
-    }
     /**
      * Decompresses, decrypts, and processes received UDP data.
      * Pipeline: Receive -> Decrypt (AES-256-GCM) -> Decompress -> Parse -> Process
@@ -357,138 +275,6 @@ function createPipeline(app, state, metricsApi) {
             }
         });
     }
-    /**
-     * Receive-side counterpart to `packCryptMeta` for v1. Decrypts a packet
-     * arrived on `udpMetaPort`, verifies the 4-byte `SKM1` magic inside the
-     * plaintext (packets without the magic are dropped — v1 has no packet-type
-     * byte, so the magic is the only signal that this is a meta payload and not
-     * a corrupted delta), and dispatches each entry as a minimal Signal K delta
-     * with `updates[].meta[]` via `app.handleMessage`.
-     */
-    async function unpackDecryptMeta(packet, secretKey) {
-        try {
-            if (!state.options) {
-                app.debug("unpackDecryptMeta called but plugin is stopped, ignoring");
-                return;
-            }
-            // Bump bytesIn/packetsIn AND the meta-scoped counters at the same
-            // gate — any packet that reached this code is a meta packet (the
-            // separate udpMetaPort ensures that), so bytesIn should always equal
-            // metaBytesIn for this pipeline path. Keeping them in lockstep lets
-            // consumers cross-check: bytesIn === dataBytesIn + metaBytesIn.
-            metrics.bandwidth.bytesIn += packet.length;
-            metrics.bandwidth.packetsIn++;
-            metrics.bandwidth.metaBytesIn = (metrics.bandwidth.metaBytesIn || 0) + packet.length;
-            metrics.bandwidth.metaPacketsIn = (metrics.bandwidth.metaPacketsIn || 0) + 1;
-            const decrypted = (0, crypto_1.decryptBinary)(packet, secretKey, {
-                stretchAsciiKey: !!state.options.stretchAsciiKey
-            });
-            const decompressed = (await (0, pipeline_utils_1.brotliDecompressAsync)(decrypted, {
-                maxOutputLength: constants_1.MAX_DECOMPRESSED_SIZE
-            }));
-            if (decompressed.length < V1_META_MAGIC.length) {
-                app.debug("v1 meta: decompressed payload too short, ignoring");
-                return;
-            }
-            // Reject anything that isn't prefixed with the SKM1 magic so a stray
-            // non-meta packet on the meta port (misconfiguration, replay, attacker)
-            // cannot be misinterpreted. The magic lives INSIDE the encrypted
-            // plaintext, so this check is authenticated.
-            if (decompressed.subarray(0, V1_META_MAGIC.length).compare(V1_META_MAGIC) !== 0) {
-                app.debug("v1 meta: missing SKM1 magic, dropping");
-                return;
-            }
-            const body = decompressed.subarray(V1_META_MAGIC.length);
-            if (body.length > constants_1.MAX_PARSE_PAYLOAD_SIZE) {
-                app.error(`v1 meta: payload too large to parse: ${body.length} bytes`);
-                return;
-            }
-            let content;
-            if (state.options.useMsgpack) {
-                try {
-                    content = msgpack.decode(body);
-                }
-                catch {
-                    content = JSON.parse(body.toString());
-                }
-            }
-            else {
-                content = JSON.parse(body.toString());
-            }
-            if (!content || typeof content !== "object" || Array.isArray(content)) {
-                app.debug("v1 meta: envelope was not an object, dropping");
-                return;
-            }
-            const env = content;
-            if (!Array.isArray(env.entries) || env.entries.length === 0) {
-                return;
-            }
-            // Drop stale/duplicate envelopes. The inner envelope `seq` is shared
-            // across all chunks of the same batch, so equal-seq chunks are still
-            // accepted; only earlier batches are rejected. Uint32-wrap aware so a
-            // long-running sender's wrap doesn't trigger mass-rejection.
-            //
-            // Sender-restart detection: the v1 client's meta envelope counter
-            // initialises to 0 at process start. Treat envSeq=0 as a peer restart
-            // only once lastIngestedMetaEnvSeqV1 has advanced beyond a small
-            // reorder window — below the threshold, envSeq=0 is ambiguous with
-            // first-packet replay and falls through to normal dedup.
-            if (typeof env.seq === "number" && Number.isFinite(env.seq)) {
-                const envSeq = env.seq >>> 0;
-                if (lastIngestedMetaEnvSeqV1 !== null &&
-                    envSeq === 0 &&
-                    lastIngestedMetaEnvSeqV1 >= META_RESTART_THRESHOLD_V1) {
-                    app.debug(`v1 meta: sender restart detected (last seq was ${lastIngestedMetaEnvSeqV1}); resetting`);
-                    lastIngestedMetaEnvSeqV1 = null;
-                }
-                if (lastIngestedMetaEnvSeqV1 !== null) {
-                    const distance = (envSeq - lastIngestedMetaEnvSeqV1) >>> 0;
-                    if (distance !== 0 && distance >= 0x80000000) {
-                        app.debug(`v1 meta: stale envelope seq=${envSeq} (last=${lastIngestedMetaEnvSeqV1}), dropping`);
-                        return;
-                    }
-                    if (distance !== 0) {
-                        lastIngestedMetaEnvSeqV1 = envSeq;
-                    }
-                }
-                else {
-                    lastIngestedMetaEnvSeqV1 = envSeq;
-                }
-            }
-            const nowIso = new Date().toISOString();
-            const usePathDict = !!state.options.usePathDictionary;
-            for (const rawEntry of env.entries) {
-                if (!rawEntry || typeof rawEntry.meta !== "object" || !rawEntry.meta) {
-                    continue;
-                }
-                const entry = usePathDict
-                    ? (0, pathDictionary_1.decodeMetaEntry)(rawEntry)
-                    : rawEntry;
-                const path = typeof entry.path === "string" ? entry.path : String(entry.path ?? "");
-                if (!path) {
-                    continue;
-                }
-                const context = typeof rawEntry.context === "string" ? rawEntry.context : "vessels.self";
-                const delta = {
-                    context,
-                    updates: [
-                        {
-                            timestamp: nowIso,
-                            values: [],
-                            meta: [{ path, value: entry.meta }]
-                        }
-                    ]
-                };
-                app.handleMessage("", delta);
-            }
-            app.debug(`v1 meta received: kind=${env.kind ?? "?"}, entries=${env.entries.length}`);
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            app.error(`unpackDecryptMeta error: ${msg}`);
-            recordError("general", `unpackDecryptMeta error: ${msg}`);
-        }
-    }
-    return { packCrypt, packCryptMeta, unpackDecrypt, unpackDecryptMeta };
+    return { packCrypt, unpackDecrypt };
 }
 module.exports = createPipeline;