signalk-edge-link 2.6.0 → 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,
@@ -252,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 {
@@ -874,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) => {
@@ -1312,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/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;

package/lib/routes/config.js

@@ -187,6 +187,7 @@ function register(router, ctx) {
                     error: error instanceof Error ? error.message : String(error)
                 });
             }
+            connectionList = connectionList.map((connection) => (0, connection_config_1.sanitizeConnectionConfig)(connection));
             for (let index = 0; index < connectionList.length; index++) {
                 const prefix = connectionList.length > 1 ? `connections[${index}].` : "";
                 const validationError = (0, connection_config_1.validateConnectionConfig)(connectionList[index], prefix);
@@ -213,7 +214,7 @@ function register(router, ctx) {
                 }
             }
             const finalConfig = {
-                connections: connectionList.map((connection) => (0, connection_config_1.sanitizeConnectionConfig)(connection))
+                connections: connectionList
             };
             if (resolvedManagementToken !== undefined) {
                 finalConfig.managementApiToken = resolvedManagementToken;

package/lib/routes/connections.js

@@ -191,12 +191,13 @@ function register(router, ctx) {
             if (!body.name) {
                 return res.status(400).json({ error: "Missing required field 'name'" });
             }
-            const validationError = (0, connection_config_1.validateConnectionConfig)(body);
+            const sanitized = (0, connection_config_1.sanitizeConnectionConfig)(body);
+            const validationError = (0, connection_config_1.validateConnectionConfig)(sanitized);
             if (validationError) {
                 return res.status(400).json({ error: validationError });
             }
             const connections = getCurrentConnectionsConfig();
-            connections.push((0, connection_config_1.sanitizeConnectionConfig)(body));
+            connections.push(sanitized);
             const portError = (0, connection_config_1.validateUniqueServerPorts)(connections);
             if (portError) {
                 return res.status(400).json({ error: portError });
@@ -237,15 +238,11 @@ function register(router, ctx) {
             const mutableAllowed = new Set([
                 "name",
                 "protocolVersion",
-                "udpMetaPort",
                 "useMsgpack",
                 "usePathDictionary",
                 "enableNotifications",
                 "udpAddress",
                 "helloMessageSender",
-                "testAddress",
-                "testPort",
-                "pingIntervalTime",
                 "reliability",
                 "congestionControl",
                 "bonding",
@@ -264,11 +261,12 @@ function register(router, ctx) {
                 }
             }
             const mergedConnection = { ...connections[idx], ...patch };
-            const validationError = (0, connection_config_1.validateConnectionConfig)(mergedConnection);
+            const sanitizedConnection = (0, connection_config_1.sanitizeConnectionConfig)(mergedConnection);
+            const validationError = (0, connection_config_1.validateConnectionConfig)(sanitizedConnection);
             if (validationError) {
                 return res.status(400).json({ error: validationError });
             }
-            connections[idx] = (0, connection_config_1.sanitizeConnectionConfig)(mergedConnection);
+            connections[idx] = sanitizedConnection;
             const portError = (0, connection_config_1.validateUniqueServerPorts)(connections);
             if (portError) {
                 return res.status(400).json({ error: portError });

package/lib/shared/connection-schema.js

@@ -46,13 +46,6 @@ exports.commonConnectionProperties = {
         minimum: 1024,
         maximum: 65535
     },
-    udpMetaPort: {
-        type: "integer",
-        title: "v1 Metadata UDP Port",
-        description: "Optional separate UDP port for v1 metadata packets; ignored by v2/v3.",
-        minimum: 1024,
-        maximum: 65535
-    },
     secretKey: {
         type: "string",
         title: "Encryption Key",