signalk-edge-link 2.1.0 → 2.2.0

package/lib/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const createRoutes = require("./routes");
 const instance_1 = require("./instance");
 const connection_config_1 = require("./connection-config");
+const connection_schema_1 = require("./shared/connection-schema");
 const pkg = require("../package.json");
 module.exports = function createPlugin(app) {
     const plugin = {};
@@ -200,460 +201,11 @@ module.exports = function createPlugin(app) {
     // ── Schema (array-based) ─────────────────────────────────────────────────
     //
     // Each item in the `connections` array is a full connection configuration.
-    // The schema retains complete backward-compat: Signal K's RJSF renderer
-    // renders arrays as an add/remove list automatically.
-    //
-    // Client-only fields are shown via `dependencies` on `serverType`, matching
-    // the original single-connection schema pattern.
-    const connectionItemSchema = {
-        type: "object",
-        title: "Connection",
-        required: ["serverType", "udpPort", "secretKey"],
-        properties: {
-            name: {
-                type: "string",
-                title: "Connection Name",
-                description: "Human-readable label for this connection (e.g. 'Shore Server', 'Sat Client'). Used to namespace config files and Signal K metrics paths.",
-                default: "connection",
-                maxLength: 40
-            },
-            serverType: {
-                type: "string",
-                title: "Operation Mode",
-                description: "Select Server to receive data, or Client to send data",
-                default: "client",
-                oneOf: [
-                    { const: "server", title: "Server Mode – Receive Data" },
-                    { const: "client", title: "Client Mode – Send Data" }
-                ]
-            },
-            udpPort: {
-                type: "number",
-                title: "UDP Port",
-                description: "UDP port for data transmission (must match on both ends)",
-                default: 4446,
-                minimum: 1024,
-                maximum: 65535
-            },
-            secretKey: {
-                type: "string",
-                title: "Encryption Key",
-                description: "32-byte secret key: 32-character ASCII, 64-character hex, or 44-character base64",
-                minLength: 32,
-                maxLength: 64,
-                pattern: "^(?:.{32}|[0-9a-fA-F]{64}|[A-Za-z0-9+/]{43}=?)$"
-            },
-            useMsgpack: {
-                type: "boolean",
-                title: "Use MessagePack",
-                description: "Binary serialization for smaller payloads (must match on both ends)",
-                default: false
-            },
-            usePathDictionary: {
-                type: "boolean",
-                title: "Use Path Dictionary",
-                description: "Encode paths as numeric IDs for bandwidth savings (must match on both ends)",
-                default: false
-            },
-            protocolVersion: {
-                type: "number",
-                title: "Protocol Version",
-                description: "v1: encrypted UDP. v2 adds reliable delivery and metrics. v3 keeps the v2 data path and authenticates control packets (ACK/NAK/HEARTBEAT/HELLO). Must match on both ends.",
-                default: 1,
-                oneOf: [
-                    { const: 1, title: "v1 – Standard encrypted UDP" },
-                    { const: 2, title: "v2 – Reliability, congestion control, bonding, metrics" },
-                    { const: 3, title: "v3 - v2 features with authenticated control packets" }
-                ]
-            }
-        },
-        dependencies: {
-            serverType: {
-                oneOf: [
-                    {
-                        properties: {
-                            serverType: { enum: ["server"] },
-                            reliability: {
-                                type: "object",
-                                title: "Reliability Settings (v2/v3 only)",
-                                description: "Requires Protocol v2 or v3. Controls ACK/NAK timing for reliable delivery",
-                                properties: {
-                                    ackInterval: {
-                                        type: "number",
-                                        title: "ACK Interval (ms)",
-                                        description: "How often server sends cumulative ACK updates",
-                                        default: 100,
-                                        minimum: 20,
-                                        maximum: 5000
-                                    },
-                                    ackResendInterval: {
-                                        type: "number",
-                                        title: "ACK Resend Interval (ms)",
-                                        description: "Re-send duplicate ACK periodically to recover from lost ACK packets",
-                                        default: 1000,
-                                        minimum: 100,
-                                        maximum: 10000
-                                    },
-                                    nakTimeout: {
-                                        type: "number",
-                                        title: "NAK Timeout (ms)",
-                                        description: "Delay before requesting retransmission for missing sequence numbers",
-                                        default: 100,
-                                        minimum: 20,
-                                        maximum: 5000
-                                    }
-                                }
-                            }
-                        }
-                    },
-                    {
-                        properties: {
-                            serverType: { enum: ["client"] },
-                            udpAddress: {
-                                type: "string",
-                                title: "Server Address",
-                                description: "IP address or hostname of the SignalK server",
-                                default: "127.0.0.1"
-                            },
-                            helloMessageSender: {
-                                type: "integer",
-                                title: "Heartbeat Interval (seconds)",
-                                description: "How often to send heartbeat messages",
-                                default: 60,
-                                minimum: 10,
-                                maximum: 3600
-                            },
-                            testAddress: {
-                                type: "string",
-                                title: "Connectivity Test Address",
-                                description: "Address to ping for network testing (e.g., 8.8.8.8)",
-                                default: "127.0.0.1"
-                            },
-                            testPort: {
-                                type: "number",
-                                title: "Connectivity Test Port",
-                                description: "Port for connectivity test (80, 443, 53)",
-                                default: 80,
-                                minimum: 1,
-                                maximum: 65535
-                            },
-                            pingIntervalTime: {
-                                type: "number",
-                                title: "Check Interval (minutes)",
-                                description: "How often to test network connectivity",
-                                default: 1,
-                                minimum: 0.1,
-                                maximum: 60
-                            },
-                            heartbeatInterval: {
-                                type: "number",
-                                title: "NAT Keepalive Heartbeat Interval (ms)",
-                                description: "v2/v3 only. How often to send UDP heartbeat packets for NAT traversal. Typical NAT timeouts range from 30s to 120s.",
-                                default: 25000,
-                                minimum: 5000,
-                                maximum: 120000
-                            },
-                            reliability: {
-                                type: "object",
-                                title: "Reliability Settings (v2/v3 only)",
-                                description: "Requires Protocol v2 or v3. Controls retransmit queue behavior and packet retry limits",
-                                properties: {
-                                    retransmitQueueSize: {
-                                        type: "number",
-                                        title: "Retransmit Queue Size",
-                                        description: "Maximum number of sent packets stored for potential retransmission",
-                                        default: 5000,
-                                        minimum: 100,
-                                        maximum: 50000
-                                    },
-                                    maxRetransmits: {
-                                        type: "number",
-                                        title: "Max Retransmit Attempts",
-                                        description: "Maximum resend attempts before a packet is dropped from the retransmit queue",
-                                        default: 3,
-                                        minimum: 1,
-                                        maximum: 20
-                                    },
-                                    retransmitMaxAge: {
-                                        type: "number",
-                                        title: "Retransmit Max Age (ms)",
-                                        description: "Expire stale unacknowledged packets older than this age",
-                                        default: 120000,
-                                        minimum: 1000,
-                                        maximum: 300000
-                                    },
-                                    retransmitMinAge: {
-                                        type: "number",
-                                        title: "Retransmit Min Age (ms)",
-                                        description: "Minimum packet age before expiration is allowed",
-                                        default: 10000,
-                                        minimum: 200,
-                                        maximum: 30000
-                                    },
-                                    retransmitRttMultiplier: {
-                                        type: "number",
-                                        title: "RTT Expiry Multiplier",
-                                        description: "Dynamic expiry age is adjusted to RTT x this multiplier",
-                                        default: 12,
-                                        minimum: 2,
-                                        maximum: 20
-                                    },
-                                    ackIdleDrainAge: {
-                                        type: "number",
-                                        title: "ACK Idle Drain Age (ms)",
-                                        description: "If ACKs are idle longer than this, expiry becomes more aggressive",
-                                        default: 20000,
-                                        minimum: 500,
-                                        maximum: 30000
-                                    },
-                                    forceDrainAfterAckIdle: {
-                                        type: "boolean",
-                                        title: "Force Drain After ACK Idle",
-                                        description: "When enabled, clear retransmit queue if no ACKs arrive for too long",
-                                        default: false
-                                    },
-                                    forceDrainAfterMs: {
-                                        type: "number",
-                                        title: "Force Drain Timeout (ms)",
-                                        description: "ACK idle duration before force-draining retransmit queue to zero",
-                                        default: 45000,
-                                        minimum: 2000,
-                                        maximum: 120000
-                                    },
-                                    recoveryBurstEnabled: {
-                                        type: "boolean",
-                                        title: "Recovery Burst Enabled",
-                                        description: "When ACKs return after outage, rapidly retransmit queued packets to catch up",
-                                        default: true
-                                    },
-                                    recoveryBurstSize: {
-                                        type: "number",
-                                        title: "Recovery Burst Size",
-                                        description: "Max queued packets to retransmit per recovery burst cycle",
-                                        default: 100,
-                                        minimum: 10,
-                                        maximum: 1000
-                                    },
-                                    recoveryBurstIntervalMs: {
-                                        type: "number",
-                                        title: "Recovery Burst Interval (ms)",
-                                        description: "Interval between recovery burst cycles while backlog exists",
-                                        default: 200,
-                                        minimum: 50,
-                                        maximum: 5000
-                                    },
-                                    recoveryAckGapMs: {
-                                        type: "number",
-                                        title: "Recovery ACK Gap (ms)",
-                                        description: "Minimum ACK silence before triggering fast recovery bursts",
-                                        default: 4000,
-                                        minimum: 500,
-                                        maximum: 120000
-                                    }
-                                }
-                            },
-                            congestionControl: {
-                                type: "object",
-                                title: "Dynamic Congestion Control (v2/v3 only)",
-                                description: "Requires Protocol v2 or v3. AIMD algorithm to dynamically adjust send rate based on network conditions",
-                                properties: {
-                                    enabled: {
-                                        type: "boolean",
-                                        title: "Enable Congestion Control",
-                                        description: "Automatically adjust delta timer based on RTT and packet loss",
-                                        default: false
-                                    },
-                                    targetRTT: {
-                                        type: "number",
-                                        title: "Target RTT (ms)",
-                                        description: "RTT threshold above which send rate is reduced",
-                                        default: 200,
-                                        minimum: 50,
-                                        maximum: 2000
-                                    },
-                                    nominalDeltaTimer: {
-                                        type: "number",
-                                        title: "Nominal Delta Timer (ms)",
-                                        description: "Preferred steady-state send interval",
-                                        default: 1000,
-                                        minimum: 100,
-                                        maximum: 10000
-                                    },
-                                    minDeltaTimer: {
-                                        type: "number",
-                                        title: "Minimum Delta Timer (ms)",
-                                        description: "Fastest allowed send interval",
-                                        default: 100,
-                                        minimum: 50,
-                                        maximum: 1000
-                                    },
-                                    maxDeltaTimer: {
-                                        type: "number",
-                                        title: "Maximum Delta Timer (ms)",
-                                        description: "Slowest allowed send interval",
-                                        default: 5000,
-                                        minimum: 1000,
-                                        maximum: 30000
-                                    }
-                                }
-                            },
-                            bonding: {
-                                type: "object",
-                                title: "Connection Bonding (v2/v3 only)",
-                                description: "Requires Protocol v2 or v3. Dual-link bonding with automatic failover between primary and backup connections",
-                                properties: {
-                                    enabled: {
-                                        type: "boolean",
-                                        title: "Enable Connection Bonding",
-                                        description: "Enable dual-link bonding with automatic failover",
-                                        default: false
-                                    },
-                                    mode: {
-                                        type: "string",
-                                        title: "Bonding Mode",
-                                        description: "Bonding operating mode",
-                                        default: "main-backup",
-                                        oneOf: [
-                                            {
-                                                const: "main-backup",
-                                                title: "Main/Backup – Failover to backup when primary degrades"
-                                            }
-                                        ]
-                                    },
-                                    primary: {
-                                        type: "object",
-                                        title: "Primary Link",
-                                        description: "Primary connection (e.g., LTE modem)",
-                                        properties: {
-                                            address: { type: "string", title: "Server Address", default: "127.0.0.1" },
-                                            port: {
-                                                type: "number",
-                                                title: "UDP Port",
-                                                default: 4446,
-                                                minimum: 1024,
-                                                maximum: 65535
-                                            },
-                                            interface: { type: "string", title: "Bind Interface (optional)" }
-                                        }
-                                    },
-                                    backup: {
-                                        type: "object",
-                                        title: "Backup Link",
-                                        description: "Backup connection (e.g., Starlink, satellite)",
-                                        properties: {
-                                            address: { type: "string", title: "Server Address", default: "127.0.0.1" },
-                                            port: {
-                                                type: "number",
-                                                title: "UDP Port",
-                                                default: 4447,
-                                                minimum: 1024,
-                                                maximum: 65535
-                                            },
-                                            interface: { type: "string", title: "Bind Interface (optional)" }
-                                        }
-                                    },
-                                    failover: {
-                                        type: "object",
-                                        title: "Failover Thresholds",
-                                        description: "Configure when failover is triggered",
-                                        properties: {
-                                            rttThreshold: {
-                                                type: "number",
-                                                title: "RTT Threshold (ms)",
-                                                default: 500,
-                                                minimum: 100,
-                                                maximum: 5000
-                                            },
-                                            lossThreshold: {
-                                                type: "number",
-                                                title: "Packet Loss Threshold",
-                                                default: 0.1,
-                                                minimum: 0.01,
-                                                maximum: 0.5
-                                            },
-                                            healthCheckInterval: {
-                                                type: "number",
-                                                title: "Health Check Interval (ms)",
-                                                default: 1000,
-                                                minimum: 500,
-                                                maximum: 10000
-                                            },
-                                            failbackDelay: {
-                                                type: "number",
-                                                title: "Failback Delay (ms)",
-                                                default: 30000,
-                                                minimum: 5000,
-                                                maximum: 300000
-                                            },
-                                            heartbeatTimeout: {
-                                                type: "number",
-                                                title: "Heartbeat Timeout (ms)",
-                                                default: 5000,
-                                                minimum: 1000,
-                                                maximum: 30000
-                                            }
-                                        }
-                                    }
-                                }
-                            },
-                            alertThresholds: {
-                                type: "object",
-                                title: "Monitoring Alert Thresholds (v2/v3 only)",
-                                description: "Customize warning/critical thresholds for network monitoring alerts",
-                                properties: {
-                                    rtt: {
-                                        type: "object",
-                                        title: "RTT Thresholds",
-                                        properties: {
-                                            warning: { type: "number", title: "Warning RTT (ms)", default: 300 },
-                                            critical: { type: "number", title: "Critical RTT (ms)", default: 800 }
-                                        }
-                                    },
-                                    packetLoss: {
-                                        type: "object",
-                                        title: "Packet Loss Thresholds",
-                                        properties: {
-                                            warning: { type: "number", title: "Warning Loss Ratio", default: 0.03 },
-                                            critical: { type: "number", title: "Critical Loss Ratio", default: 0.1 }
-                                        }
-                                    },
-                                    retransmitRate: {
-                                        type: "object",
-                                        title: "Retransmit Rate Thresholds",
-                                        properties: {
-                                            warning: { type: "number", title: "Warning Retransmit Ratio", default: 0.05 },
-                                            critical: {
-                                                type: "number",
-                                                title: "Critical Retransmit Ratio",
-                                                default: 0.15
-                                            }
-                                        }
-                                    },
-                                    jitter: {
-                                        type: "object",
-                                        title: "Jitter Thresholds",
-                                        properties: {
-                                            warning: { type: "number", title: "Warning Jitter (ms)", default: 100 },
-                                            critical: { type: "number", title: "Critical Jitter (ms)", default: 300 }
-                                        }
-                                    },
-                                    queueDepth: {
-                                        type: "object",
-                                        title: "Queue Depth Thresholds",
-                                        properties: {
-                                            warning: { type: "number", title: "Warning Queue Depth", default: 100 },
-                                            critical: { type: "number", title: "Critical Queue Depth", default: 500 }
-                                        }
-                                    }
-                                }
-                            }
-                        },
-                        required: ["udpAddress", "testAddress", "testPort"]
-                    }
-                ]
-            }
-        }
-    };
+    // The field definitions live in `src/shared/connection-schema.ts` and are
+    // consumed unchanged here and by the webapp RJSF form in
+    // `src/webapp/components/PluginConfigurationPanel.tsx` — there is a single
+    // schema source.
+    const connectionItemSchema = (0, connection_schema_1.buildConnectionItemSchema)();
     plugin.schema = {
         type: "object",
         title: "SignalK Edge Link",

package/lib/instance.js

@@ -93,7 +93,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         pipelineServer: null,
         heartbeatHandle: null,
         monitoring: null,
-        networkSimulator: null,
         configDebounceTimers: {},
         configContentHashes: {},
         configWatcherObjects: [],
@@ -269,7 +268,7 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
         }
         finally {
             state.batchSendInFlight = false;
-            if (state.deltas.length > 0 && !state.pendingRetry) {
+            if (state.deltas.length > 0 && !state.pendingRetry && !state.stopped) {
                 setImmediate(() => {
                     flushDeltaBatch();
                 });
@@ -780,7 +779,8 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
                         failover: options.bonding.failover || {},
                         instanceId: state.instanceId,
                         notificationsEnabled: options.enableNotifications === true,
-                        secretKey: options.secretKey
+                        secretKey: options.secretKey,
+                        stretchAsciiKey: !!options.stretchAsciiKey
                     };
                     try {
                         await v2Pipeline.initBonding(bondingConfig);
@@ -884,7 +884,6 @@ function createInstance(app, options, instanceId, pluginId, onStatusChange) {
             }
             state.monitoring = null;
         }
-        state.networkSimulator = null;
         // Stop ping monitor
         if (state.pingMonitor) {
             state.pingMonitor.stop();

package/lib/packet.js

@@ -120,11 +120,14 @@ class PacketBuilder {
     /**
      * @param {Object} [config]
      * @param {number} [config.initialSequence=0] - Starting sequence number
+     * @param {boolean} [config.stretchAsciiKey=false] - When true, 32-char
+     *   ASCII keys are stretched via PBKDF2 before use. Both ends must agree.
      */
     constructor(config = {}) {
         this._sequence = config.initialSequence ?? 0;
         this._protocolVersion = normalizeProtocolVersion(config.protocolVersion);
         this._secretKey = config.secretKey || null;
+        this._stretchAsciiKey = !!config.stretchAsciiKey;
     }
     /**
      * Build a DATA packet
@@ -258,7 +261,7 @@ class PacketBuilder {
                     throw new Error("Protocol v3 control packets require a secretKey");
                 }
                 header.writeUInt32BE(payloadBuffer.length + crypto_1.CONTROL_AUTH_TAG_LENGTH, 9);
-                const authTag = (0, crypto_1.createControlPacketAuthTag)(header.subarray(0, 13), payloadBuffer, secretKey);
+                const authTag = (0, crypto_1.createControlPacketAuthTag)(header.subarray(0, 13), payloadBuffer, secretKey, { stretchAsciiKey: this._stretchAsciiKey });
                 finalPayload = Buffer.concat([payloadBuffer, authTag]);
             }
             else if (payloadBuffer.length > 0) {
@@ -290,13 +293,15 @@ exports.PacketBuilder = PacketBuilder;
 class PacketParser {
     constructor(config = {}) {
         this._secretKey = config.secretKey || null;
+        this._stretchAsciiKey = !!config.stretchAsciiKey;
     }
     /**
      * Parse a packet header
      * @param {Buffer} packet - Raw packet data
      * @param {Object} [options]
      * @param {string} [options.secretKey] - Required for v3 control packets
-     * @param {boolean} [options.allowUnauthenticatedControl=false] - Skip v3 control auth verification
+     * @param {boolean} [options.stretchAsciiKey] - Override the parser's
+     *   constructor-time setting; both ends must agree
      * @returns {Object} Parsed packet information
      * @throws {Error} If packet is invalid
      */
@@ -353,13 +358,14 @@ class PacketParser {
                 }
                 const payloadData = payload.subarray(0, payload.length - crypto_1.CONTROL_AUTH_TAG_LENGTH);
                 const authTag = payload.subarray(payload.length - crypto_1.CONTROL_AUTH_TAG_LENGTH);
-                if (!options.allowUnauthenticatedControl) {
-                    const secretKey = options.secretKey || this._secretKey;
-                    if (!secretKey) {
-                        throw new Error("Control packet authentication requires secretKey");
-                    }
-                    (0, crypto_1.verifyControlPacketAuthTag)(packet.subarray(0, 13), payloadData, authTag, secretKey);
+                const secretKey = options.secretKey || this._secretKey;
+                if (!secretKey) {
+                    throw new Error("Control packet authentication requires secretKey");
                 }
+                const stretchAsciiKey = options.stretchAsciiKey ?? this._stretchAsciiKey;
+                (0, crypto_1.verifyControlPacketAuthTag)(packet.subarray(0, 13), payloadData, authTag, secretKey, {
+                    stretchAsciiKey
+                });
                 payload = payloadData;
             }
             else {

package/lib/pipeline-v2-client.js

@@ -37,12 +37,15 @@ function createPipelineV2Client(app, state, metricsApi) {
     const { metrics, recordError, trackPathStats, updateBandwidthRates } = metricsApi;
     const setStatus = app.setPluginStatus || app.setProviderStatus || (() => { });
     const protocolVersion = state.options && state.options.protocolVersion === 3 ? 3 : 2;
+    const stretchAsciiKey = !!state.options?.stretchAsciiKey;
     const packetBuilder = new packet_1.PacketBuilder({
         protocolVersion,
-        secretKey: state.options?.secretKey ?? undefined
+        secretKey: state.options?.secretKey ?? undefined,
+        stretchAsciiKey
     });
     const packetParser = new packet_1.PacketParser({
-        secretKey: state.options?.secretKey ?? undefined
+        secretKey: state.options?.secretKey ?? undefined,
+        stretchAsciiKey
     });
     const clientTelemetrySource = "signalk-edge-link-client-telemetry";
     // Reliability: extract config once to avoid repetitive deep-access chains
@@ -140,8 +143,11 @@ function createPipelineV2Client(app, state, metricsApi) {
     }
     function _effectiveRetransmitAge() {
         let maxAge = retransmitMaxAge;
-        if ((metrics.rtt ?? 0) > 0) {
-            const rttBasedAge = Math.round((metrics.rtt ?? 0) * retransmitRttMultiplier);
+        // Use the congestion controller's smoothed RTT (EMA) instead of the raw
+        // latest sample to avoid volatile timeout swings from single RTT spikes.
+        const smoothedRtt = congestionControl.getAvgRTT();
+        if (smoothedRtt > 0) {
+            const rttBasedAge = Math.round(smoothedRtt * retransmitRttMultiplier);
             maxAge = Math.min(maxAge, Math.max(retransmitMinAge, rttBasedAge));
         }
         const ackIdleMs = Date.now() - lastAckAt;
@@ -266,7 +272,9 @@ function createPipelineV2Client(app, state, metricsApi) {
             // Compress
             const compressed = await (0, pipeline_utils_1.compressPayload)(serialized, state.options?.useMsgpack ?? false);
             // Encrypt
-            const encrypted = (0, crypto_1.encryptBinary)(compressed, secretKey);
+            const encrypted = (0, crypto_1.encryptBinary)(compressed, secretKey, {
+                stretchAsciiKey
+            });
             // Capture sequence before building (buildDataPacket advances it)
             const seq = packetBuilder.getCurrentSequence();
             // Build v2 packet with header
@@ -349,10 +357,12 @@ function createPipelineV2Client(app, state, metricsApi) {
             const ackedSeq = packetParser.parseACKPayload(parsed.payload);
             const now = Date.now();
             let rttSample = null;
-            // Estimate RTT from original send timestamp (not retransmit timestamp).
+            // Only sample RTT from packets that were NOT retransmitted (Karn's algorithm).
+            // When a retransmitted packet is ACKed, the measurement is ambiguous — the ACK
+            // could be for the original or the retransmit — so we skip it entirely.
             const entry = retransmitQueue.get(ackedSeq);
-            if (entry && (entry.originalTimestamp || entry.timestamp)) {
-                rttSample = Math.max(0, now - (entry.originalTimestamp || entry.timestamp));
+            if (entry && entry.attempts === 0) {
+                rttSample = Math.max(0, now - entry.originalTimestamp);
             }
             if (rttSample !== null) {
                 metrics.rtt = rttSample;
@@ -376,10 +386,13 @@ function createPipelineV2Client(app, state, metricsApi) {
             lastAckAt = now;
             lastAckRinfo = rinfo ? { address: rinfo.address, port: rinfo.port } : lastAckRinfo;
             // Update congestion control with latest network metrics.
+            // Only feed RTT when we have a fresh sample; passing -1 causes the
+            // congestion controller's >= 0 guard to skip the RTT EMA update,
+            // preventing stale values from being repeatedly folded into the average.
             // Clamp packetLoss to [0, 1] as a defensive measure against any future
             // changes to _calculatePacketLoss that could produce out-of-range values.
             congestionControl.updateMetrics({
-                rtt: metrics.rtt ?? 0,
+                rtt: rttSample ?? -1,
                 packetLoss: Math.min(1, Math.max(0, _calculatePacketLoss()))
             });
             app.debug(`ACK received: seq=${ackedSeq}, removed=${removed}, queueDepth=${retransmitQueue.getSize()}, rtt=${metrics.rtt}ms`);