diff --git a/app/ui.js b/app/ui.js
index 1ba0b19f1..aae107c67 100644
--- a/app/ui.js
+++ b/app/ui.js
@@ -327,6 +327,7 @@ const UI = {
         UI.initSetting('virtual_keyboard_visible', false);
         UI.initSetting('enable_ime', false);
         UI.initSetting('enable_webrtc', false);
+        UI.initSetting('webrtc_congestion_control', false);
         UI.initSetting('enable_hidpi', false);
         UI.initSetting('fallback_image_mode', false);
 
@@ -695,6 +696,8 @@ const UI = {
         UI.addSettingChangeHandler('enable_ime', UI.toggleIMEMode);
         UI.addSettingChangeHandler('enable_webrtc');
         UI.addSettingChangeHandler('enable_webrtc', UI.toggleWebRTC);
+        UI.addSettingChangeHandler('webrtc_congestion_control');
+        UI.addSettingChangeHandler('webrtc_congestion_control', UI.updateWebRTCCongestionControl);
         UI.addSettingChangeHandler('enable_hidpi');
         UI.addSettingChangeHandler('enable_hidpi', UI.enableHiDpi);
         UI.addSettingChangeHandler('enable_threading');
@@ -1905,6 +1908,10 @@ const UI = {
         UI.rfb.keyboard.enableIME = UI.getSetting('enable_ime');
         UI.rfb.clipboardBinary = supportsBinaryClipboard() && UI.rfb.clipboardSeamless;
         UI.rfb.enableWebRTC = UI.getSetting('enable_webrtc');
+        // WebRTC congestion control is still in development and hidden from the
+        // UI; force it off so a stale localStorage value can never activate it.
+        UI.rfb.webRTCCongestionControl = false;
+        UI.updateWebRTCCongestionControlAvailability();
         UI.rfb.mouseButtonMapper = UI.initMouseButtonMapper();
         // UI.rfb.qualityPreset = UI.getSetting(UI_SETTINGS.PRESET);
         if (UI.rfb.videoQuality === 5) {
@@ -3144,10 +3151,32 @@ const UI = {
             } else {
                 UI.rfb.enableWebRTC = false;
             }
+            UI.updateWebRTCCongestionControlAvailability();
             UI.updateQuality();
         }
     },
 
+    // The congestion-control toggle only does anything while WebRTC media is
+    // active, so grey it out (disable the checkbox) whenever WebRTC is off.
+    // The stored preference is preserved across the disable so re-enabling
+    // WebRTC restores the user's choice.
+    updateWebRTCCongestionControlAvailability() {
+        // Feature still in development: keep the toggle permanently disabled
+        // (it is also hidden in index.html) so it cannot be activated.
+        const el = document.getElementById('noVNC_setting_webrtc_congestion_control');
+        if (el) {
+            el.disabled = true;
+            el.checked = false;
+        }
+    },
+
+    updateWebRTCCongestionControl() {
+        // Force off while the feature is hidden; ignore any stored preference.
+        if (UI.rfb) {
+            UI.rfb.webRTCCongestionControl = false;
+        }
+    },
+
     enableHiDpi() {
         if (UI.rfb) {
             if (UI.getSetting('enable_hidpi')) {
diff --git a/core/decoders/kasmvideo.js b/core/decoders/kasmvideo.js
index b00a0d015..98458ded4 100644
--- a/core/decoders/kasmvideo.js
+++ b/core/decoders/kasmvideo.js
@@ -99,7 +99,33 @@ export default class KasmVideoDecoder {
     }
 
     _skipRect(x, y, width, height, _sock, display, _depth, frameId) {
-        display.clearRect(x, y, width, height, 0, frameId, false);
+        // Under WebRTC media the server emits skip-rects in place of
+        // encoded video (the payload rides the RTCPeerConnection).
+        // Clearing the canvas here would paint the visible area black
+        // during the ~1-2s ICE/SDP handshake before the first WebRTC
+        // frame arrives. Leave the canvas alone in that mode so the
+        // user sees the last image-mode frame until the <video> takes
+        // over on its 'playing' event.
+        // Per-screen WebRTC (one PeerConnection per screen): a skip-rect
+        // is only emitted by the server for a screen it is streaming over
+        // WebRTC, so if any screen transport is still up (negotiating or
+        // connected) we leave the canvas alone and let the <video> overlay
+        // show through. A screen that has fallen back to WebSocket video
+        // emits real encoded rects, not skip-rects, so it isn't affected.
+        let webrtcActive = false;
+        const screens = this._rfb && this._rfb._webrtcScreens;
+        if (screens) {
+            for (const slot of screens.values()) {
+                const t = slot.live || slot.pending;
+                if (t && t.state !== 'closed' && t.state !== 'fallback') {
+                    webrtcActive = true;
+                    break;
+                }
+            }
+        }
+        if (!webrtcActive) {
+            display.clearRect(x, y, width, height, 0, frameId, false);
+        }
         return true;
     }
 
diff --git a/core/decoders/udp.js b/core/decoders/udp.js
deleted file mode 100644
index f40e1c402..000000000
--- a/core/decoders/udp.js
+++ /dev/null
@@ -1,283 +0,0 @@
-/*
- * KasmVNC: HTML5 VNC client
- * Copyright (C) 2020 Kasm Technologies
- * Licensed under MPL 2.0 (see LICENSE.txt)
- *
- * See README.md for usage and integration instructions.
- *
- */
-
-import * as Log from '../util/logging.js';
-import Inflator from "../inflator.js";
-
-export default class UDPDecoder {
-    constructor() {
-        this._filter = null;
-        this._palette = new Uint8Array(1024);  // 256 * 4 (max palette size * max bytes-per-pixel)
-        this._directDraw = false; //Draw directly to the canvas without ordering
-
-        this._zlibs = [];
-        for (let i = 0; i < 4; i++) {
-            this._zlibs[i] = new Inflator();
-        }
-    }
-
-    decodeRect(x, y, width, height, data, display, depth, frame_id) {
-        let ctl = data[12];
-        ctl = ctl >> 4;
-
-        let ret;
-
-        if (ctl === 0x08) {
-            ret = this._fillRect(x, y, width, height, data, display, depth, frame_id);
-        } else if (ctl === 0x09) {
-            ret = this._jpegRect(x, y, width, height, data, display, depth, frame_id);
-        } else if (ctl === 0x0A) {
-            ret = this._pngRect(x, y, width, height, data, display, depth, frame_id);
-        } else if ((ctl & 0x08) == 0) {
-            ret = this._basicRect(ctl, x, y, width, height, data, display, depth, frame_id);
-        } else if (ctl === 0x0B) {
-            ret = this._webpRect(x, y, width, height, data, display, depth, frame_id);
-        } else {
-            throw new Error("Illegal udp compression received (ctl: " +
-                ctl + ")");
-        }
-
-        return ret;
-    }
-
-    _fillRect(x, y, width, height, data, display, depth, frame_id) {
-
-        display.fillRect(x, y, width, height,
-            [data[13], data[14], data[15]], frame_id, this._directDraw);
-
-        return true;
-    }
-
-    _jpegRect(x, y, width, height, data, display, depth, frame_id) {
-        let img = this._readData(data);
-        if (img === null) {
-            return false;
-        }
-
-        display.imageRect(x, y, width, height, "image/jpeg", img, frame_id, this._directDraw);
-
-        return true;
-    }
-
-    _webpRect(x, y, width, height, data, display, depth, frame_id) {
-        let img = this._readData(data);
-        if (img === null) {
-            return false;
-        }
-
-        display.imageRect(x, y, width, height, "image/webp", img, frame_id, this._directDraw);
-
-        return true;
-    }
-
-    _pngRect(x, y, width, height, data, display, depth, frame_id) {
-        //throw new Error("PNG received in UDP rect");
-        Log.Error("PNG received in UDP rect");
-    }
-
-    _basicRect(ctl, x, y, width, height, data, display, depth, frame_id) {
-        let zlibs_flags = data[12];
-        // Reset streams if the server requests it
-        for (let i = 0; i < 4; i++) {
-            if ((zlibs_flags >> i) & 1) {
-                this._zlibs[i].reset();
-                //Log.Debug("Reset zlib stream " + i);
-            }
-        }
-
-        let filter = data[13];
-        let data_index = 14;
-        let streamId = ctl & 0x3;
-        if (!(ctl & 0x4)) {
-            // Implicit CopyFilter
-            filter = 0;
-            data_index = 13;
-        }
-
-        let ret;
-
-        switch (filter) {
-            case 0: // CopyFilter
-                ret = this._copyFilter(streamId, x, y, width, height,
-                    data, display, depth, frame_id, data_index);
-                break;
-            case 1: // PaletteFilter
-                ret = this._paletteFilter(streamId, x, y, width, height,
-                    data, display, depth, frame_id);
-                break;
-            case 2: // GradientFilter
-                ret = this._gradientFilter(streamId, x, y, width, height,
-                    data, display, depth, frame_id);
-                break;
-            default:
-                throw new Error("Illegal tight filter received (ctl: " +
-                    this._filter + ")");
-        }
-
-        return ret;
-    }
-
-    _copyFilter(streamId, x, y, width, height, data, display, depth, frame_id, data_index=14) {
-        const uncompressedSize = width * height * 3;
-
-        if (uncompressedSize === 0) {
-            return true;
-        }
-
-        if (uncompressedSize < 12) {
-            data = data.slice(data_index, data_index + uncompressedSize);
-        } else {
-            data = this._readData(data, data_index);
-            if (data === null) {
-                return false;
-            }
-
-            this._zlibs[streamId].setInput(data);
-            data = this._zlibs[streamId].inflate(uncompressedSize);
-            this._zlibs[streamId].setInput(null);
-        }
-
-        let rgbx = new Uint8Array(width * height * 4);
-        for (let i = 0, j = 0; i < width * height * 4; i += 4, j += 3) {
-            rgbx[i] = data[j];
-            rgbx[i + 1] = data[j + 1];
-            rgbx[i + 2] = data[j + 2];
-            rgbx[i + 3] = 255;  // Alpha
-        }
-
-        display.blitImage(x, y, width, height, rgbx, 0, frame_id, this._directDraw);
-
-        return true;
-    }
-
-    _paletteFilter(streamId, x, y, width, height, data, display, depth, frame_id) {
-        const numColors = data[14] + 1;
-        const paletteSize = numColors * 3;
-        let palette = data.slice(15, 15 + paletteSize);
-
-        const bpp = (numColors <= 2) ? 1 : 8;
-        const rowSize = Math.floor((width * bpp + 7) / 8);
-        const uncompressedSize = rowSize * height;
-        let data_i = 15 + paletteSize;
-
-        if (uncompressedSize === 0) {
-            return true;
-        }
-
-        if (uncompressedSize < 12) {
-            data = data.slice(data_i, data_i + uncompressedSize);
-        } else {
-            data = this._readData(data, data_i);
-            if (data === null) {
-                return false;
-            }
-
-            this._zlibs[streamId].setInput(data);
-            data = this._zlibs[streamId].inflate(uncompressedSize);
-            this._zlibs[streamId].setInput(null);
-        }
-
-        // Convert indexed (palette based) image data to RGB
-        if (numColors == 2) {
-            this._monoRect(x, y, width, height, data, palette, display, frame_id);
-        } else {
-            this._paletteRect(x, y, width, height, data, palette, display, frame_id);
-        }
-
-        return true;
-    }
-
-    _monoRect(x, y, width, height, data, palette, display, frame_id) {
-        // Convert indexed (palette based) image data to RGB
-        // TODO: reduce number of calculations inside loop
-        const dest = this._getScratchBuffer(width * height * 4);
-        const w = Math.floor((width + 7) / 8);
-        const w1 = Math.floor(width / 8);
-
-        for (let y = 0; y < height; y++) {
-            let dp, sp, x;
-            for (x = 0; x < w1; x++) {
-                for (let b = 7; b >= 0; b--) {
-                    dp = (y * width + x * 8 + 7 - b) * 4;
-                    sp = (data[y * w + x] >> b & 1) * 3;
-                    dest[dp] = palette[sp];
-                    dest[dp + 1] = palette[sp + 1];
-                    dest[dp + 2] = palette[sp + 2];
-                    dest[dp + 3] = 255;
-                }
-            }
-
-            for (let b = 7; b >= 8 - width % 8; b--) {
-                dp = (y * width + x * 8 + 7 - b) * 4;
-                sp = (data[y * w + x] >> b & 1) * 3;
-                dest[dp] = palette[sp];
-                dest[dp + 1] = palette[sp + 1];
-                dest[dp + 2] = palette[sp + 2];
-                dest[dp + 3] = 255;
-            }
-        }
-
-        display.blitImage(x, y, width, height, dest, 0, frame_id, this._directDraw);
-    }
-
-    _paletteRect(x, y, width, height, data, palette, display, frame_id) {
-        // Convert indexed (palette based) image data to RGB
-        const dest = this._getScratchBuffer(width * height * 4);
-        const total = width * height * 4;
-        for (let i = 0, j = 0; i < total; i += 4, j++) {
-            const sp = data[j] * 3;
-            dest[i] = palette[sp];
-            dest[i + 1] = palette[sp + 1];
-            dest[i + 2] = palette[sp + 2];
-            dest[i + 3] = 255;
-        }
-
-        display.blitImage(x, y, width, height, dest, 0, frame_id, this._directDraw);
-    }
-
-    _gradientFilter(streamId, x, y, width, height, data, display, depth, frame_id) {
-        throw new Error("Gradient filter not implemented");
-    }
-
-    _readData(data, len_index = 13) {
-        if (data.length < len_index + 2) {
-            Log.Error("UDP Decoder, readData, invalid data len")
-            return null;
-        }
-
-
-        let i = len_index;
-        let byte = data[i++];
-        let len = byte & 0x7f;
-        // lenth field is variably sized 1 to 3 bytes long
-        if (byte & 0x80) {
-            byte = data[i++]
-            len |= (byte & 0x7f) << 7;
-            if (byte & 0x80) {
-                byte = data[i++];
-                len |= byte << 14;
-            }
-        }
-
-        //TODO: get rid of me
-        if (data.length !== len + i) {
-            console.log('Rect of size ' + len + ' with data size ' + data.length + ' index of ' + i);
-        }
-        
-
-        return data.slice(i);
-    }
-
-    _getScratchBuffer(size) {
-        if (!this._scratchBuffer || (this._scratchBuffer.length < size)) {
-            this._scratchBuffer = new Uint8Array(size);
-        }
-        return this._scratchBuffer;
-    }
-}
diff --git a/core/display.js b/core/display.js
index 93fef11be..f7c676104 100644
--- a/core/display.js
+++ b/core/display.js
@@ -166,11 +166,15 @@ export default class Display {
         this._primaryChannel = null;
         this._portRelayWorker = null;      // SharedWorker instance (primary only)
         this._encodedFramePort = null;     // MessagePort from primary (secondary only)
+        // Per-screenIndex queue of WebRTC signals to relay to a secondary
+        // window whose encodedFramePort isn't established yet (primary only).
+        this._webrtcRelayQueue = new Map();
         this._localDecoder = null;         // VideoDecoder on secondary
         this._localDecoderCodec = null;
         this._localDecoderW = 0;
         this._localDecoderH = 0;
         this._localDecoderStreamMode = null;
+        this._localDecoderNeedKey = false; // wait for a key frame after (re)configure
         this._localDecoderMeta = new Map(); // timestamp → {x, y, width, height, frameId}
         this._localDecoderTs = 0;
         this._rfb = rfb;
@@ -482,10 +486,29 @@ export default class Display {
                 this._portRelayWorker.port.start();
                 this._portRelayWorker.port.onmessage = (e) => {
                     if (e.data.type === 'port') {
-                        const screen = this._screens[e.data.screenIndex];
+                        const idx = e.data.screenIndex;
+                        const screen = this._screens[idx];
                         if (screen) {
                             screen.encodedFramePort = e.data.port;
-                            Log.Info(`[PRIMARY] encodedFramePort established for screen ${e.data.screenIndex}`);
+                            // Listen for the secondary window's relayed WebRTC
+                            // signals (its SDP answer / ICE) coming back so we
+                            // can forward them up the server WebSocket. Encoded
+                            // frames only flow primary->secondary, so this
+                            // receive path is WebRTC-signal-only.
+                            screen.encodedFramePort.onmessage = (ev) => {
+                                const w = ev.data && ev.data.webrtc;
+                                if (w && this._rfb &&
+                                    typeof this._rfb._forwardRelayedWebRTCToServer === 'function') {
+                                    this._rfb._forwardRelayedWebRTCToServer(w.kind, w.screenId, w.payload);
+                                }
+                            };
+                            screen.encodedFramePort.start();
+                            Log.Info(`[PRIMARY] encodedFramePort established for screen ${idx}`);
+                            // Flush any WebRTC signals queued for this screen
+                            // before its relay port existed (offer can arrive
+                            // from the server before the SharedWorker handshake
+                            // completes — see doc/MULTI_MONITOR_WEBRTC_PLAN.md §10).
+                            this._flushWebRTCRelayQueue(idx);
                         }
                     }
                 };
@@ -806,6 +829,26 @@ export default class Display {
         }
     }
 
+    // Push a no-op placeholder rect that occupies one slot in a frame's
+    // expected rect count but renders nothing. Used by callers that
+    // skipped or dropped a real rect (e.g. UDP video reorder dropping a
+    // delta while waiting for an IDR) and still need the LastRect flip
+    // to fire. Safe on both primary and secondary screens: 'dummy' type
+    // falls through the default branch in _pushAsyncFrame on primary,
+    // and is explicitly no-op on secondary.
+    enqueueDummyRect(screenId, frameId, x, y, width, height) {
+        const rect = {
+            type: 'dummy',
+            screenId,
+            x, y, width, height,
+            frame_id: frameId,
+        };
+        if (screenId < this._screens.length) {
+            this._processRectScreens(rect);
+            this._asyncRenderQPush(rect);
+        }
+    }
+
     videoFrameRect(screenId, frame, frame_id, x, y, width, height) {
         const startTime = perfLogger.start('videoFrameRender');
 
@@ -1040,7 +1083,20 @@ export default class Display {
             case 'registered':
                 if (!this._isPrimaryDisplay) {
                     const screenIndex = event.data.screenIndex;
+                    const prevScreenIndex = this._screens[0].screenIndex;
                     this._screens[0].screenIndex = screenIndex;
+                    // A *change* of index (vs. the initial registration) means a
+                    // non-last monitor closed and the windows re-densified. Any
+                    // WebRTC transport this window still holds was built for its
+                    // old screenId; drop it now so its stale full-window <video>
+                    // overlay doesn't sit frozen over the new screen's WebSocket
+                    // video until the old PC's ICE grace expires.
+                    if (typeof prevScreenIndex === 'number' &&
+                        prevScreenIndex !== screenIndex &&
+                        this._rfb &&
+                        typeof this._rfb._teardownStaleSecondaryWebRTC === 'function') {
+                        this._rfb._teardownStaleSecondaryWebRTC(screenIndex);
+                    }
                     Log.Info(`Screen with index (${screenIndex}) successfully registered with the primary display.`);
                     if (this._screens.length > 0) {
                         this.resize(this._screens[0].serverWidth, this._screens[0].serverHeight);
@@ -1055,6 +1111,13 @@ export default class Display {
                             this._encodedFramePort.start();
                             this._encodedFramePort.onmessage = this._handleEncodedFrame.bind(this);
                             Log.Info(`[SECONDARY] encodedFramePort established`);
+                            // Now that the relay port for this (possibly new)
+                            // screen is up, fire any deferred re-offer request
+                            // queued by a reindex so the survivor recovers RTP.
+                            if (this._rfb &&
+                                typeof this._rfb._maybeRequestPendingWebRTCOffer === 'function') {
+                                this._rfb._maybeRequestPendingWebRTCOffer();
+                            }
                         }
                     };
                     relayWorker.port.postMessage({type: 'secondary_ready', screenIndex});
@@ -1574,7 +1637,64 @@ export default class Display {
         });
     }
 
+    // Primary -> secondary: relay one WebRTC signal to the secondary
+    // window that renders screen `screenIndex`, over its dedicated
+    // encodedFramePort. Queues until that port is established (the server
+    // can offer a screen before the SharedWorker port handshake finishes).
+    relayWebRTCSignal(screenIndex, kind, screenId, payload) {
+        const screen = this._screens[screenIndex];
+        const msg = { webrtc: { kind, screenId, payload } };
+        if (screen && screen.encodedFramePort) {
+            try { screen.encodedFramePort.postMessage(msg); } catch (e) {
+                Log.Warn('relayWebRTCSignal post failed: ' + e);
+            }
+            return;
+        }
+        let q = this._webrtcRelayQueue.get(screenIndex);
+        if (!q) { q = []; this._webrtcRelayQueue.set(screenIndex, q); }
+        q.push(msg);
+    }
+
+    _flushWebRTCRelayQueue(screenIndex) {
+        const q = this._webrtcRelayQueue.get(screenIndex);
+        const screen = this._screens[screenIndex];
+        if (!q || !screen || !screen.encodedFramePort) return;
+        for (const msg of q) {
+            try { screen.encodedFramePort.postMessage(msg); } catch (e) {
+                Log.Warn('relayWebRTCSignal flush failed: ' + e);
+            }
+        }
+        this._webrtcRelayQueue.delete(screenIndex);
+    }
+
+    // Secondary -> primary: send this window's WebRTC signal (SDP answer /
+    // ICE / fallback) up to the primary, which forwards it to the server.
+    relayWebRTCSignalUp(kind, screenId, payload) {
+        if (!this._encodedFramePort) {
+            Log.Warn('relayWebRTCSignalUp: no encodedFramePort yet (screen ' +
+                screenId + ')');
+            return;
+        }
+        try {
+            this._encodedFramePort.postMessage({ webrtc: { kind, screenId, payload } });
+        } catch (e) {
+            Log.Warn('relayWebRTCSignalUp post failed: ' + e);
+        }
+    }
+
     _handleEncodedFrame(e) {
+        // The encodedFramePort is shared by the encoded-frame fast path and
+        // the per-screen WebRTC signaling relay. WebRTC signals are tagged
+        // with a `webrtc` envelope; hand them to rfb (the secondary builds
+        // its own RTCPeerConnection from relayed offers).
+        if (e.data && e.data.webrtc) {
+            const w = e.data.webrtc;
+            if (this._rfb &&
+                typeof this._rfb._onRelayedWebRTCSignal === 'function') {
+                this._rfb._onRelayedWebRTCSignal(w.kind, w.screenId, w.payload);
+            }
+            return;
+        }
         const { codec, keyFrame, streamMode, data, x, y, width, height, frameId } = e.data;
 
         // Reconfigure decoder on first use or when codec/dimensions/streaming mode change
@@ -1614,6 +1734,16 @@ export default class Display {
             this._localDecoderH = height;
             this._localDecoderStreamMode = streamMode;
             this._configureLocalDecoder(codec, width, height, streamMode);
+            // A freshly (re)configured VideoDecoder must be fed a key frame
+            // first; a delta throws and tears the decoder down. After a
+            // transport switch (WebRTC -> WebSocket) the first relayed frame
+            // is usually mid-GOP, so wait for the next key frame.
+            this._localDecoderNeedKey = true;
+        }
+
+        if (this._localDecoderNeedKey) {
+            if (!keyFrame) return;   // drop deltas until the GOP boundary
+            this._localDecoderNeedKey = false;
         }
 
         const ts = ++this._localDecoderTs;
diff --git a/core/encodings.js b/core/encodings.js
index 4e6c97914..626446257 100644
--- a/core/encodings.js
+++ b/core/encodings.js
@@ -78,6 +78,7 @@ export const encodings = {
     pseudoEncodingTreatLosslessLevel0: -1003,
     pseudoEncodingTreatLosslessLevel10: -993,
     pseudoEncodingPreferBandwidth: -992,
+    pseudoEncodingWebRTCCongestionControl: -990,
     pseudoEncodingDynamicQualityMinLevel0: -991,
     pseudoEncodingDynamicQualityMinLevel9: -982,
     pseudoEncodingDynamicQualityMaxLevel0: -981,
diff --git a/core/rfb.js b/core/rfb.js
index de4ee6c17..954383b8e 100644
--- a/core/rfb.js
+++ b/core/rfb.js
@@ -37,9 +37,10 @@ import CopyRectDecoder from "./decoders/copyrect.js";
 import RREDecoder from "./decoders/rre.js";
 import HextileDecoder from "./decoders/hextile.js";
 import KasmVideoDecoder from "./decoders/kasmvideo.js";
+import WebRTCVideoTransport from "./transport/webrtc_video.js";
+import WebRTCSignaling, { WEBRTC_MSG_TYPE, WEBRTC_SESSION_SCREEN, WebRTCSignalKind, writeWebRTCFrame } from "./transport/webrtc_signaling.js";
 import TightDecoder from "./decoders/tight.js";
 import TightPNGDecoder from "./decoders/tightpng.js";
-import UDPDecoder from './decoders/udp.js';
 import {FPS, UI_SETTING_PROFILE_OPTIONS} from '../app/constants.js';
 
 // How many seconds to wait for a disconnect to finish
@@ -152,21 +153,25 @@ export default class RFB extends EventTargetMixin {
         this._clipboardBinary = true;
         this._resendClipboardNextUserDrivenEvent = true;
         this._useUdp = true;
+        this._webrtcScreens = new Map();
+        // Secondary-only: screenId this window must request a fresh offer for
+        // after a reindex, deferred until its relay port is up. null = none.
+        this._pendingWebRTCOfferRequest = null;
+        // Session-level negotiation state (the codec is session-wide).
+        this._webrtcSessionActive = false;  // capability advertised to server
+        this._webrtcSessionCodec = null;    // codecKey currently advertised
+        this._webrtcIceServers = [];        // [{urls}] from the kind=4 signal
+        this._webrtcIceServersRaw = '';     // raw newline list, for relaying
+
         this._hiDpi = 'hiDpi' in options ? !!options.hiDpi : false;
         this._enableQOI = false;
         this._videoQuality = 2;
+        // Opt-in: drive WebRTC media bitrate via the server's congestion
+        // controller. Off by default — full-quality CQP until the user enables
+        // it. Only has effect while WebRTC is active. Sent to the server as the
+        // pseudoEncodingWebRTCCongestionControl pseudo-encoding.
+        this._webRTCCongestionControl = false;
         this._enableWebP = false;
-        this.TransitConnectionStates = {
-            Tcp: Symbol("tcp"),
-            Udp: Symbol("udp"),
-            Upgrading: Symbol("upgrading"),
-            Downgrading: Symbol("downgrading"),
-            Failure: Symbol("failure")
-        }
-        this._transitConnectionState = this.TransitConnectionStates.Tcp;
-        this._lastTransition = null;
-        this._udpConnectFailures = 0; //Failures in upgrading connection to udp
-        this._udpTransitFailures = 0; //Failures in transit after successful upgrade
 
         this._trackFrameStats = false;
 
@@ -307,7 +312,6 @@ export default class RFB extends EventTargetMixin {
         this._decoders[encodings.encodingKasmVideo] = new KasmVideoDecoder(this, this._display);
         this._decoders[encodings.encodingTight] = new TightDecoder(this._display);
         this._decoders[encodings.encodingTightPNG] = new TightPNGDecoder();
-        this._decoders[encodings.encodingUDP] = new UDPDecoder();
 
         this._keyboard = new Keyboard(this._canvas, touchInput, navigator.keyboard);
         this._keyboard.onkeyevent = this._handleKeyEvent.bind(this);
@@ -407,6 +411,16 @@ export default class RFB extends EventTargetMixin {
         this._pendingApplyEncodingChanges = true;
     }
 
+    get webRTCCongestionControl() { return this._webRTCCongestionControl; }
+    set webRTCCongestionControl(val) {
+        val = !!val;
+        if (this._webRTCCongestionControl === val) {
+            return;
+        }
+        this._webRTCCongestionControl = val;
+        this._pendingApplyEncodingChanges = true;
+    }
+
     get viewOnly() { return this._viewOnly; }
     set viewOnly(viewOnly) {
         Log.Debug("Setting viewOnly to " + viewOnly);
@@ -740,15 +754,11 @@ export default class RFB extends EventTargetMixin {
     get enableWebRTC() { return this._useUdp; }
     set enableWebRTC(value) {
         this._useUdp = value;
-        if (!value) {
-            if (this.isConnected && (this._transitConnectionState !== this.TransitConnectionStates.Tcp)) {
-                this._sendUdpDowngrade();
-            }
-        } else {
-            if (this.isConnected && (this._transitConnectionState !== this.TransitConnectionStates.Udp)) {
-                this._sendUdpUpgrade();
-            }
-        }
+        // Drives the WebRTC media path. If the server didn't build with
+        // ENABLE_WEBRTC_MEDIA, the kind=6 capability message gets bounced
+        // with a fallback signal and _webrtc tears itself down — no harm
+        // done.
+        this._applyWebRTCMediaState('toggle');
     }
 
     get enableHiDpi() { return this._hiDpi; }
@@ -812,9 +822,174 @@ export default class RFB extends EventTargetMixin {
             if (this._display) {
                 this._display.preferSoftwareDecode = value === encodings.pseudoEncodingStreamingModeAVCNVENC;
             }
+            this._applyWebRTCMediaState('streamMode');
+        }
+    }
+
+    _streamModeToWebRTCCodecs(mode) {
+        const E = encodings;
+        switch (mode) {
+            case E.pseudoEncodingStreamingModeAVC:
+            case E.pseudoEncodingStreamingModeAVCSW:
+            case E.pseudoEncodingStreamingModeAVCVAAPI:
+            case E.pseudoEncodingStreamingModeAVCNVENC:
+            case E.pseudoEncodingStreamingModeAVCQSV:
+                return ['H264'];
+            case E.pseudoEncodingStreamingModeHEVC:
+            case E.pseudoEncodingStreamingModeHEVCSW:
+            case E.pseudoEncodingStreamingModeHEVCVAAPI:
+            case E.pseudoEncodingStreamingModeHEVCNVENC:
+            case E.pseudoEncodingStreamingModeHEVCQSV:
+                return ['H265', 'H264'];   // fall back to H264 if browser refuses H265
+            case E.pseudoEncodingStreamingModeAV1:
+            case E.pseudoEncodingStreamingModeAV1SW:
+            case E.pseudoEncodingStreamingModeAV1VAAPI:
+            case E.pseudoEncodingStreamingModeAV1NVENC:
+            case E.pseudoEncodingStreamingModeAV1QSV:
+                return ['AV1', 'H264'];
+            default:
+                return null;   // image mode
+        }
+    }
+
+    _applyWebRTCMediaState(reason) {
+        // Only the primary window advertises session capability; the
+        // server then sends one offer per screen. Screens that this
+        // window doesn't render are relayed to their secondary window
+        // (see _dispatchWebRTCSignal). Secondary windows never call this —
+        // they are purely reactive to relayed offers.
+        if (!this._isPrimaryDisplay) return;
+        if (typeof RTCPeerConnection === 'undefined') return;
+
+        const wantCodecs = this._useUdp
+            ? this._streamModeToWebRTCCodecs(this._streamMode)
+            : null;
+        const wantOn  = !!wantCodecs;
+        const codecKey = wantCodecs ? wantCodecs.join(',') : '';
+
+        if (wantOn && this.isConnected) {
+            // Advertise (or re-advertise on a codec change). The server
+            // replies with the ICE-servers list + one offer per active
+            // screen; a re-advertisement while screens are live triggers a
+            // server-side smooth codec switch (pending transports).
+            if (!this._webrtcSessionActive || this._webrtcSessionCodec !== codecKey) {
+                Log.Info('Advertising WebRTC capability (codecs=' + codecKey +
+                    ', reason=' + reason + ')');
+                this._webRTCMediaCodecs = wantCodecs;
+                this._webrtcSessionActive = true;
+                this._webrtcSessionCodec = codecKey;
+                try {
+                    this._sendWebRTCFrame(WebRTCSignalKind.ClientCapabilities,
+                        WEBRTC_SESSION_SCREEN, codecKey);
+                } catch (e) {
+                    Log.Error('WebRTC capability advertisement failed: ' + e);
+                }
+            }
+            return;
+        }
+
+        // Image-mode requested while WebRTC is active: freeze-frame the
+        // canvas, tell the server to drop the whole session, and tear
+        // down every screen's transport. Image mode shows through.
+        if (!wantOn && this._webrtcSessionActive) {
+            Log.Info('Disabling WebRTC media (reason=' + reason + ')');
+            this._freezeFrameWebRTC();
+            try {
+                this._sendWebRTCFrame(WebRTCSignalKind.Fallback,
+                    WEBRTC_SESSION_SCREEN, 'unsubscribe');
+            } catch (e) {}
+            this._teardownAllWebRTCScreens();
+            this._webrtcSessionActive = false;
+            this._webrtcSessionCodec = null;
+        }
+    }
+
+    // Write one WebRTC signal frame to the server's WebSocket. The sink
+    // every local per-screen WebRTCSignaling uses.
+    _sendWebRTCFrame(kind, screenId, payload) {
+        writeWebRTCFrame(this._sock, kind, screenId, payload);
+    }
+
+    _makeLocalSignaling(screenId) {
+        return new WebRTCSignaling(screenId,
+            (k, sid, p) => this._sendWebRTCFrame(k, sid, p));
+    }
+
+    _teardownAllWebRTCScreens() {
+        for (const slot of this._webrtcScreens.values()) {
+            if (slot.pending) { try { slot.pending.stop(); } catch (e) {} }
+            if (slot.live)    { try { slot.live.stop(); }    catch (e) {} }
+        }
+        this._webrtcScreens.clear();
+    }
+
+    _teardownStaleSecondaryWebRTC(keepScreenId) {
+        let toreDown = false;
+        for (const [sid, slot] of Array.from(this._webrtcScreens)) {
+            if (sid === keepScreenId) continue;
+            Log.Info('[WEBRTC-DIAG] secondary dropping stale transport screen ' +
+                sid + ' after reindex to ' + keepScreenId);
+            if (slot.pending) { try { slot.pending.stop(); } catch (e) {} }
+            if (slot.live)    { try { slot.live.stop(); }    catch (e) {} }
+            this._webrtcScreens.delete(sid);
+            toreDown = true;
+        }
+        // If this window was streaming over WebRTC for its previous screenId,
+        // it now needs a fresh offer for the screen it took over. The server
+        // can't detect the window swap (the slot's RandR id is unchanged), so
+        // request it explicitly — deferred until our relay port for the new
+        // screen is established (_maybeRequestPendingWebRTCOffer).
+        if (toreDown && !this._webrtcScreens.has(keepScreenId)) {
+            this._pendingWebRTCOfferRequest = keepScreenId;
+        }
+    }
+
+    // SECONDARY: our relay port for the new screen is up; if a reindex left
+    // us without a transport for it, ask the server to (re)offer it so the
+    // monitor recovers RTP instead of staying on WebSocket video.
+    _maybeRequestPendingWebRTCOffer() {
+        const sid = this._pendingWebRTCOfferRequest;
+        if (sid == null) return;
+        this._pendingWebRTCOfferRequest = null;
+        if (this._webrtcScreens.has(sid)) return;   // already (re)building
+        Log.Info('[WEBRTC-DIAG] secondary requesting fresh offer for screen ' + sid);
+        if (this._display && typeof this._display.relayWebRTCSignalUp === 'function') {
+            this._display.relayWebRTCSignalUp(WebRTCSignalKind.RequestOffer, sid, '');
+        }
+    }
+
+    // Capture the last decoded frame from any live WebRTC <video> onto
+    // the canvas so the user sees a still image during the gap before the
+    // next mode's first paint, instead of an empty/black region.
+    _freezeFrameWebRTC() {
+        try {
+            let video = null;
+            for (const slot of this._webrtcScreens.values()) {
+                if (slot.live && slot.live.video && slot.live.video.videoWidth) {
+                    video = slot.live.video; break;
+                }
+            }
+            if (!video || !video.videoHeight) return;
+            const canvas = this._display && this._display._target;
+            if (!canvas || !canvas.getContext) return;
+            const ctx = canvas.getContext('2d');
+            if (!ctx) return;
+            ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
+        } catch (e) {
+            Log.Warn('Freeze-frame capture failed: ' + e);
         }
     }
 
+    // Pending (codec-switch) transport for one screen failed before it
+    // could promote — drop just it, keep the live transport streaming.
+    _abandonPendingWebRTCScreen(screenId, reason) {
+        const slot = this._webrtcScreens.get(screenId);
+        if (!slot || !slot.pending) return;
+        Log.Info('Abandoning pending WebRTC (screen ' + screenId + '): ' + reason);
+        try { slot.pending.stop(); } catch (e) {}
+        slot.pending = null;
+    }
+
     // ===== PUBLIC METHODS =====
 
     refreshSecondaryDisplays() {
@@ -1226,11 +1401,6 @@ export default class RFB extends EventTargetMixin {
         this.lastActiveAt = Date.now();
     }
 
-    _changeTransitConnectionState(value) {
-        Log.Info("Transit state change from " + this._transitConnectionState.toString() + ' to ' + value.toString());
-        this._transitConnectionState = value;
-    }
-
     _setupWebSocket() {
         this._sock = new Websock();
         this._sock.on('message', () => {
@@ -1393,115 +1563,12 @@ export default class RFB extends EventTargetMixin {
 
         this._resendClipboardNextUserDrivenEvent = true;
 
-        // WebRTC UDP datachannel inits
-        if (typeof RTCPeerConnection !== 'undefined' && this._isPrimaryDisplay) {
-            this._udpBuffer = new Map();
-
-            this._udpPeer = new RTCPeerConnection({
-                iceServers: [{
-                    urls: ["stun:stun.l.google.com:19302"]
-                }]
-            });
-            let peer = this._udpPeer;
-
-            peer.onicecandidate = function(e) {
-                if (e.candidate)
-                    Log.Debug("received ice candidate", e.candidate);
-                else
-                    Log.Debug("all candidates received");
-            }
-
-            peer.ondatachannel = function(e) {
-                Log.Debug("peer connection on data channel", e);
-            }
-
-            this._udpChannel = peer.createDataChannel("webudp", {
-                ordered: false,
-                maxRetransmits: 0
-            });
-            this._udpChannel.binaryType = "arraybuffer";
-
-            this._udpChannel.onerror = function(e) {
-                Log.Error("data channel error " + e.message);
-                this._udpTransitFailures+=1;
-                this._sendUdpDowngrade();
-            }
-
-            let sock = this._sock;
-            let udpBuffer = this._udpBuffer;
-            let me = this;
-            this._udpChannel.onmessage = function(e) {
-                //Log.Info("got udp msg", e.data);
-                const u8 = new Uint8Array(e.data);
-                // Got an UDP packet. Do we need reassembly?
-                const id = parseInt(u8[0] +
-                                    (u8[1] << 8) +
-                                    (u8[2] << 16) +
-                                    (u8[3] << 24), 10);
-                const i = parseInt(u8[4] +
-                                   (u8[5] << 8) +
-                                   (u8[6] << 16) +
-                                   (u8[7] << 24), 10);
-                const pieces = parseInt(u8[8] +
-                                        (u8[9] << 8) +
-                                        (u8[10] << 16) +
-                                        (u8[11] << 24), 10);
-                const hash = parseInt(u8[12] +
-                                        (u8[13] << 8) +
-                                        (u8[14] << 16) +
-                                        (u8[15] << 24), 10);
-                // TODO: check the hash. It's the low 32 bits of XXH64, seed 0
-                const frame_id = parseInt(u8[16] +
-                                        (u8[17] << 8) +
-                                        (u8[18] << 16) +
-                                        (u8[19] << 24), 10);
-
-                if (me._transitConnectionState !== me.TransitConnectionStates.Udp) {
-                    me._display.clear();
-                    me._changeTransitConnectionState(me.TransitConnectionStates.Udp);
-                }
-
-                if (pieces == 1) { // Handle it immediately
-                    me._handleUdpRect(u8.slice(20), frame_id);
-                } else { // Use buffer
-                    const now = Date.now();
-
-                    if (udpBuffer.has(id)) {
-                        let item = udpBuffer.get(id);
-                        item.recieved_pieces += 1;
-                        item.data[i] = u8.slice(20);
-                        item.total_bytes += item.data[i].length;
-
-                        if (item.total_pieces == item.recieved_pieces) {
-                            // Message is complete, combile data into a single array
-                            var finaldata = new Uint8Array(item.total_bytes);
-                            let z = 0;
-                            for (let x = 0; x < item.data.length; x++) {
-                                finaldata.set(item.data[x], z);
-                                z += item.data[x].length;
-                            }
-                            udpBuffer.delete(id);
-                            me._handleUdpRect(finaldata, frame_id);
-                        }
-                    } else {
-                        let item = {
-                            total_pieces: pieces,   // number of pieces expected
-                                arrival: now,       //time first piece was recieved
-                            recieved_pieces: 1,     // current number of pieces in data
-                            total_bytes: 0,         // total size of all data pieces combined
-                            data: new Array(pieces)
-                        }
-                        item.data[i] = u8.slice(20);
-                        item.total_bytes = item.data[i].length;
-                        udpBuffer.set(id, item);
-                    }
-                }
-            }
-        }
-
-	    if (this._useUdp && typeof RTCPeerConnection !== 'undefined' && this._isPrimaryDisplay) {
-            setTimeout(function() { this._sendUdpUpgrade() }.bind(this), 3000);
-        }
+        // WebRTC media (libdatachannel) kickoff. The reconciler reads
+        // _useUdp and _streamMode and starts the transport iff both are
+        // in a WebRTC-eligible state (toggle on, codec is not image-mode).
+        // Server-side: enableWebRTCMedia off -> kind=6 gets bounced
+        // and _webrtc tears itself down.
+        setTimeout(function() { this._applyWebRTCMediaState('connect') }.bind(this), 3000);
 
         Log.Debug("<< RFB.connect");
     }
@@ -3332,6 +3399,10 @@ export default class RFB extends EventTargetMixin {
         // encs.push(encodings.pseudoEncodingHardwareProfile0 + this.hwEncoderProfile);
         encs.push(encodings.pseudoEncodingGOP1 + this.gop);
         encs.push(encodings.pseudoEncodingStreamingVideoQualityLevel0 + this.videoStreamQuality);
+
+        if (this._webRTCCongestionControl)
+            encs.push(encodings.pseudoEncodingWebRTCCongestionControl);
+
         encs.push(this.streamMode);
 
 	// preferBandwidth choses preset settings. Since we expose all the settings, let's not pass this
@@ -3836,14 +3907,14 @@ export default class RFB extends EventTargetMixin {
             case 180: // KASM binary clipboard
                 return this._handleBinaryClipboard();
 
-            case 181: // KASM UDP upgrade
-                return this._handleUdpUpgrade();
-
             case 182: // KASM unix relay subscription
                 return this._handleSubscribeUnixRelay();
 
             case 183: // KASM unix relay data
                 return this._handleUnixRelay();
+
+            case WEBRTC_MSG_TYPE: // 190 — KASM WebRTC media signaling
+                return this._handleWebRTCSignal();
             case messages.msgTypeServerDisconnect: // KASM disconnect notice
                 return this._handleDisconnectNotify();
 
@@ -3880,111 +3951,267 @@ export default class RFB extends EventTargetMixin {
         }
     }
 
-    _handleUdpRect(data, frame_id) {
-        let frame = {
-            x: (data[0] << 8) + data[1],
-            y: (data[2] << 8) + data[3],
-            width: (data[4] << 8) + data[5],
-            height: (data[6] << 8) + data[7],
-            encoding: parseInt((data[8] << 24) + (data[9] << 16) +
-                                            (data[10] << 8) + data[11], 10)
-        };
+    // -------- WebRTC media (libdatachannel migration, Phase 1+) --------
 
-        switch (frame.encoding) {
-            case encodings.pseudoEncodingLastRect:
-                this._display.flip(frame_id, frame.x + 1); //Last Rect message, first 16 bytes contain rect count
-                if (this._display.pending())
-                    this._display.flush(false);
-                break;
-            case encodings.encodingTight:
-                let decoder = this._decoders[encodings.encodingUDP];
-                try {
-                    decoder.decodeRect(frame.x, frame.y,
-                        frame.width, frame.height,
-                        data, this._display,
-                        this._fbDepth, frame_id);
-                } catch (err) {
-                    this._fail("Error decoding rect: " + err);
-                    return false;
-                }
-                break;
-            default:
-                Log.Error("Invalid rect encoding via UDP: " + frame.encoding);
-                return false;
-        }
+    _handleWebRTCSignal() {
+        // Body: [u8 kind][u8 screenId][u16 len][bytes payload]
+        if (this._sock.rQwait('WebRTC sig header', 4, 1)) { return false; }
+        const kind     = this._sock.rQshift8();
+        const screenId = this._sock.rQshift8();
+        const len      = this._sock.rQshift16();
+        if (this._sock.rQwait('WebRTC sig payload', len, 5)) { return false; }
+        const payload = len ? this._sock.rQshiftStr(len) : '';
 
+        this._dispatchWebRTCSignal(kind, screenId, payload);
         return true;
     }
 
-    _sendUdpUpgrade() {
-        if (this._transitConnectionState == this.TransitConnectionStates.Upgrading) {
+    _dispatchWebRTCSignal(kind, screenId, payload) {
+        // Session-level ICE servers: stash (parsed for our own PCs, raw
+        // for relaying to secondary windows before their offers).
+        if (kind === WebRTCSignalKind.IceServers) {
+            this._storeWebRTCIceServers(payload);
             return;
         }
-        this._changeTransitConnectionState(this.TransitConnectionStates.Upgrading);
-
-        let peer = this._udpPeer;
-        let sock = this._sock;
-
-        peer.createOffer().then(function(offer) {
-            return peer.setLocalDescription(offer);
-        }).then(function() {
-            const buff = sock._sQ;
-            const offset = sock._sQlen;
-            const str = Uint8Array.from(Array.from(peer.localDescription.sdp).map(letter => letter.charCodeAt(0)));
-
-            buff[offset] = 181; // msg-type
-            buff[offset + 1] = str.length >> 8; // u16 len
-            buff[offset + 2] = str.length;
-
-            buff.set(str, offset + 3);
+        // Session-level fallback: tear everything down, image mode wins.
+        if (kind === WebRTCSignalKind.Fallback && screenId === WEBRTC_SESSION_SCREEN) {
+            this._onWebRTCSessionFallback(payload);
+            return;
+        }
+        // Per-screen signal. Handle locally if this (the primary) window
+        // renders the screen; otherwise relay it to the secondary window
+        // that does.
+        if (this._webrtcScreenIsLocal(screenId)) {
+            this._routeWebRTCSignal(kind, screenId, payload,
+                (sid) => this._makeLocalSignaling(sid));
+        } else {
+            this._relayWebRTCSignalToScreen(screenId, kind, payload);
+        }
+    }
 
-            sock._sQlen += 3 + str.length;
-            sock.flush();
-        }).catch(function(reason) {
-            Log.Error("Failed to create offer " + reason);
-            this._changeTransitConnectionState(this.TransitConnectionStates.Tcp);
-            this._udpConnectFailures++;
-        });
+    _storeWebRTCIceServers(payload) {
+        this._webrtcIceServersRaw = payload || '';
+        this._webrtcIceServers = this._webrtcIceServersRaw.split('\n')
+            .map(s => s.trim()).filter(Boolean)
+            .map(raw => RFB._parseIceServer(raw));
+        Log.Debug('WebRTC ICE servers: ' + JSON.stringify(this._webrtcIceServers));
     }
 
-    _sendUdpDowngrade() {
-        this._changeTransitConnectionState(this.TransitConnectionStates.Downgrading);
-        const buff = this._sock._sQ;
-        const offset = this._sock._sQlen;
+    // Parse one server-sent ICE server URL into an RTCIceServer dict. STUN
+    // URLs pass through unchanged. TURN URLs carry credentials in the URL
+    // userinfo (turn:user:pass@host:port?...) — the W3C RTCIceServer API
+    // rejects userinfo in `urls`, so split it back out into the separate
+    // username/credential fields (percent-decoding, mirroring the
+    // urlEncodeCredential() done server-side in VNCSConnectionST).
+    static _parseIceServer(raw) {
+        const m = /^(turns?):(?:([^@/:]+):([^@/]*)@)(.+)$/i.exec(raw);
+        if (!m) {
+            return { urls: raw };
+        }
+        return {
+            urls: m[1] + ':' + m[4],
+            username: decodeURIComponent(m[2]),
+            credential: decodeURIComponent(m[3]),
+        };
+    }
 
-        buff[offset] = 181; // msg-type
-        buff[offset + 1] = 0; // u16 len
-        buff[offset + 2] = 0;
+    // The screenId this window renders over WebRTC. The primary renders
+    // screen 0; a secondary window renders its own screenIndex. (Server
+    // screenId === display screenIndex — see setDesktopSize, which sends
+    // the screen's position index as its RFB id.)
+    _localWebRTCScreenId() {
+        if (this._isPrimaryDisplay) return 0;
+        return (this._display && this._display.screenIndex) || 0;
+    }
 
-        this._sock._sQlen += 3;
-        this._sock.flush();
+    _webrtcScreenIsLocal(screenId) {
+        return screenId === this._localWebRTCScreenId();
     }
 
-    _handleUdpUpgrade() {
-        if (this._sock.rQwait("UdpUgrade header", 2, 1)) { return false; }
-        let len = this._sock.rQshift16();
-        if (this._sock.rQwait("UdpUpgrade payload", len, 3)) { return false; }
+    // Route a per-screen offer/ICE/Close/Fallback to this window's
+    // transport for that screen, creating one reactively on a fresh
+    // offer. A second offer for a live screen builds a `pending` transport
+    // that promotes on its first decoded frame (smooth codec switch).
+    // `makeSignaling(screenId)` produces the outbound channel — socket on
+    // the primary's own screen, relay port on a secondary window.
+    _routeWebRTCSignal(kind, screenId, payload, makeSignaling) {
+        if (typeof RTCPeerConnection === 'undefined') {
+            if (kind === WebRTCSignalKind.SdpOffer) {
+                Log.Warn('RTCPeerConnection unsupported; declining screen ' + screenId);
+                const sig = makeSignaling(screenId);
+                try { sig.send(WebRTCSignalKind.Fallback, 'no-rtcpeerconnection'); } catch (e) {}
+            }
+            return;
+        }
+        let slot = this._webrtcScreens.get(screenId);
+        if (kind === WebRTCSignalKind.SdpOffer) {
+            if (!slot) { slot = { live: null, pending: null }; this._webrtcScreens.set(screenId, slot); }
+            const pending = !!slot.live;
+            Log.Info('[WEBRTC-DIAG] building transport screen ' + screenId +
+                ' pending=' + pending + ' (window ' +
+                (this._isPrimaryDisplay ? 'primary' : 'secondary') + ')');
+            const sig = makeSignaling(screenId);
+            const transport = new WebRTCVideoTransport(this, screenId, sig,
+                { pending, iceServers: this._webrtcIceServers });
+            if (pending) {
+                if (slot.pending) { try { slot.pending.stop(); } catch (e) {} }
+                slot.pending = transport;
+            } else {
+                slot.live = transport;
+            }
+            sig.deliver(kind, payload);   // drive _handleOffer
+            return;
+        }
+        // ICE / Close / Fallback for an existing transport. During a codec
+        // switch route to pending (its offer is the one in flight).
+        if (!slot) return;
+        const target = slot.pending || slot.live;
+        if (target) target.signaling.deliver(kind, payload);
+    }
+
+    // PRIMARY: relay a per-screen signal to the secondary window that
+    // renders this screen, over its encodedFramePort. The secondary builds
+    // its own RTCPeerConnection and answers back through the same port
+    // (see _forwardRelayedWebRTCToServer). On a fresh offer, relay the
+    // session ICE-servers first so the secondary can configure its PC.
+    _relayWebRTCSignalToScreen(screenId, kind, payload) {
+        Log.Info('[WEBRTC-DIAG] primary relaying kind=' + kind +
+            ' to secondary screen ' + screenId);
+        if (!this._display || typeof this._display.relayWebRTCSignal !== 'function') return;
+        if (kind === WebRTCSignalKind.SdpOffer) {
+            this._display.relayWebRTCSignal(screenId, WebRTCSignalKind.IceServers,
+                WEBRTC_SESSION_SCREEN,
+                this._webrtcIceServersRaw || '');
+        }
+        this._display.relayWebRTCSignal(screenId, kind, screenId, payload);
+    }
+
+    // PRIMARY: a secondary window relayed one of its WebRTC signals (SDP
+    // answer / ICE / fallback) back up; forward it to the server.
+    _forwardRelayedWebRTCToServer(kind, screenId, payload) {
+        try { this._sendWebRTCFrame(kind, screenId, payload); } catch (e) {
+            Log.Warn('Forwarding relayed WebRTC signal to server failed: ' + e);
+        }
+    }
+
+    // SECONDARY: a WebRTC signal for this window's screen arrived from the
+    // primary over the encodedFramePort. Build/route this window's own
+    // RTCPeerConnection; outbound answers/ICE go back over the relay port.
+    _onRelayedWebRTCSignal(kind, screenId, payload) {
+        Log.Info('[WEBRTC-DIAG] secondary received relayed kind=' + kind +
+            ' screen=' + screenId);
+        if (kind === WebRTCSignalKind.IceServers) {
+            this._storeWebRTCIceServers(payload);
+            return;
+        }
+        this._routeWebRTCSignal(kind, screenId, payload,
+            (sid) => this._makeRelaySignaling(sid));
+    }
 
-        const payload = this._sock.rQshiftStr(len);
+    // Outbound signaling sink for a secondary window: post the answer/ICE
+    // to the primary over the encodedFramePort; the primary forwards it to
+    // the server's WebSocket.
+    _makeRelaySignaling(screenId) {
+        return new WebRTCSignaling(screenId,
+            (k, sid, p) => {
+                if (this._display && typeof this._display.relayWebRTCSignalUp === 'function')
+                    this._display.relayWebRTCSignalUp(k, sid, p);
+            });
+    }
 
-        let peer = this._udpPeer;
-
-        var response = JSON.parse(payload);
-        Log.Debug("UDP Upgrade recieved from server: " + payload);
-        peer.setRemoteDescription(new RTCSessionDescription(response.answer)).then(function() {
-            var candidate = new RTCIceCandidate(response.candidate);
-            peer.addIceCandidate(candidate).then(function() {
-                Log.Debug("success in addicecandidate");
-            }.bind(this)).catch(function(err) {
-                Log.Error("Failure in addIceCandidate", err);
-                this._changeTransitConnectionState(this.TransitConnectionStates.Failure)
-                this._udpConnectFailures++;
-            }.bind(this));
-        }.bind(this)).catch(function(e) {
-            Log.Error("Failure in setRemoteDescription", e);
-            this._changeTransitConnectionState(this.TransitConnectionStates.Failure)
-            this._udpConnectFailures++;
-        }.bind(this));
+    _onWebRTCVideoReady(video, transport) {
+        // Overlay the <video> full-window on top of the canvas. Each
+        // window renders exactly one screen and that screen's PC streams
+        // exactly that screen's content, so the overlay is 100%x100% (no
+        // sub-rect positioning — that was only needed by the rejected
+        // spanning approach). The canvas stays in the DOM so the
+        // WebSocket/image-mode path can take over instantly on failure.
+        // A *pending* (codec-switch) transport sits above the live one
+        // and promotes on `playing`.
+        const screenId = transport.screenId;
+        const slot = this._webrtcScreens.get(screenId);
+        const pending = !!(slot && transport === slot.pending);
+        try {
+            video.style.position = 'absolute';
+            video.style.left   = '0';
+            video.style.top    = '0';
+            video.style.width  = '100%';
+            video.style.height = '100%';
+            // Pending overlay must sit above the live overlay (z=1) so
+            // it visually wins on opacity:1. Both stay click-through.
+            video.style.zIndex = pending ? '2' : '1';
+            // CRITICAL: the overlay must be click-through. Without this,
+            // the <video> intercepts all mouse/touch events and the
+            // canvas underneath (where rfb's input handlers live)
+            // never receives them — the user can see the stream but
+            // can't interact with the remote desktop.
+            video.style.pointerEvents = 'none';
+            // Hide until the first frame is decoded and ready to paint.
+            // Otherwise the user sees a black <video> rectangle covering
+            // whatever the canvas had during ICE/SDP negotiation.
+            video.style.opacity = '0';
+            Log.Info('[WEBRTC-DIAG] mounting <video> screen ' + screenId +
+                ' (window ' + (this._isPrimaryDisplay ? 'primary' : 'secondary') +
+                ', pending=' + pending + ')');
+            video.addEventListener('playing', () => {
+                Log.Info('[WEBRTC-DIAG] <video> PLAYING screen ' + screenId +
+                    ' (' + video.videoWidth + 'x' + video.videoHeight + ')');
+                video.style.opacity = '1';
+                if (pending) this._promotePendingWebRTCScreen(screenId, transport);
+            }, { once: true });
+            // Find the canvas's parent. _screen is the standard mount
+            // point; if a project embeds rfb differently, the hook can
+            // be overridden by subclassing.
+            const host = this._screen || this._target;
+            if (host && host.appendChild) host.appendChild(video);
+        } catch (e) {
+            Log.Warn('Failed to mount WebRTC <video> (screen ' + screenId + '): ' + e);
+        }
+    }
+
+    // First decoded frame from a screen's pending transport has painted —
+    // promote it: drop that screen's old live transport + <video>, make
+    // the pending one live.
+    _promotePendingWebRTCScreen(screenId, transport) {
+        const slot = this._webrtcScreens.get(screenId);
+        if (!slot || transport !== slot.pending) return;  // superseded
+        Log.Info('Pending WebRTC media (screen ' + screenId + ') is playing — promoting');
+        const oldLive  = slot.live;
+        const oldVideo = oldLive && oldLive.video;
+        if (oldLive) { try { oldLive.stop(); } catch (e) {} }
+        if (oldVideo && oldVideo.parentNode) {
+            oldVideo.parentNode.removeChild(oldVideo);
+        }
+        slot.live = slot.pending;
+        slot.pending = null;
+        // Drop the now-live overlay back to z=1.
+        try { if (slot.live.video) slot.live.video.style.zIndex = '1'; } catch (e) {}
+    }
+
+    // One screen's live transport failed (ICE / codec) — drop just that
+    // screen; the server streams it over the WebSocket and the canvas /
+    // KasmVideo path renders it. Other screens keep streaming. The
+    // transport already sent a per-screen Fallback to the server.
+    _onWebRTCScreenFallback(screenId, reason) {
+        Log.Warn('WebRTC screen ' + screenId + ' fallback (' + reason +
+            ') — this screen now streams over the WebSocket');
+        const slot = this._webrtcScreens.get(screenId);
+        if (!slot) return;
+        this._freezeFrameWebRTC();
+        if (slot.pending) { try { slot.pending.stop(); } catch (e) {} }
+        if (slot.live)    { try { slot.live.stop(); }    catch (e) {} }
+        this._webrtcScreens.delete(screenId);
+    }
+
+    // The server tore down the whole WebRTC session (ICE timeout, no
+    // server codec, etc.). Drop every screen; image mode / WebSocket
+    // video takes over for all of them.
+    _onWebRTCSessionFallback(reason) {
+        Log.Warn('WebRTC session fallback (' + reason + ') — image mode taking over');
+        this._freezeFrameWebRTC();
+        this._teardownAllWebRTCScreens();
+        this._webrtcSessionActive = false;
+        this._webrtcSessionCodec = null;
     }
 
     _handleSubscribeUnixRelay() {
@@ -4490,27 +4717,6 @@ export default class RFB extends EventTargetMixin {
         }
 
         try {
-            if (this._transitConnectionState == this.TransitConnectionStates.Udp || this._transitConnectionState == this.TransitConnectionStates.Failure) {
-                if (this._transitConnectionState == this.TransitConnectionStates.Udp) {
-                    Log.Warn("Implicit UDP Transit Failure, TCP rects recieved while in UDP mode.")
-                    this._udpTransitFailures++;
-                }
-                this._changeTransitConnectionState(this.TransitConnectionStates.Tcp);
-                this._display.clear();
-                if (this._useUdp) {
-                    if (this._udpConnectFailures < 3 && this._udpTransitFailures < 3) {
-                        setTimeout(function() {
-                            Log.Warn("Attempting to connect via UDP again after failure.")
-                            this.enableWebRTC = true;
-                        }.bind(this), 3000);
-                    } else {
-                        Log.Warn("UDP connection failures exceeded limit, remaining on TCP transit.")
-                    }
-                }
-            } else if (this._transitConnectionState == this.TransitConnectionStates.Downgrading) {
-                this._display.clear();
-                this._changeTransitConnectionState(this.TransitConnectionStates.Tcp);
-            }
             return decoder.decodeRect(this._FBU.x, this._FBU.y,
                                       this._FBU.width, this._FBU.height,
                                       this._sock, this._display,
diff --git a/core/transport/webrtc_signaling.js b/core/transport/webrtc_signaling.js
new file mode 100644
index 000000000..ceaeb6d4b
--- /dev/null
+++ b/core/transport/webrtc_signaling.js
@@ -0,0 +1,123 @@
+/*
+ * KasmVNC WebRTC signaling — wraps msgTypeWebRTCSignal (190) frames
+ * over the existing WebSocket. Body schema (multi-screen):
+ *     [u8 kind][u8 screenId][u16 len][bytes payload]
+ *
+ * Multi-monitor sessions run one RTCPeerConnection per X screen (see
+ * doc/MULTI_MONITOR_WEBRTC_PLAN.md); screenId selects which one a signal
+ * applies to. WEBRTC_SESSION_SCREEN (0xFF) marks a session-level signal
+ * (capabilities, ICE-servers list, whole-session fallback).
+ *
+ * Kind values mirror common/rfb/msgTypes.h:
+ *   1: SDP offer        (server -> client, per screen)
+ *   2: SDP answer       (client -> server, per screen)
+ *   3: ICE candidate    (bidirectional; payload "<candidate>|<sdpMid>")
+ *   4: ICE servers list (server -> client; session-level; newline URLs)
+ *   5: Fallback signal  (bidirectional; per screen or session-level)
+ *   6: Client capability advertisement (client -> server; session-level)
+ *   7: Screen close     (server -> client; per screen — monitor removed)
+ *
+ * Each instance is bound to one screenId so a per-screen transport's
+ * outbound signals carry the right id without the transport having to
+ * know the wire format. The `send` primitive is pluggable so the same
+ * class works on the primary (writes to the WebSocket) and on a
+ * secondary window (posts to its relay MessagePort).
+ *
+ * Licensed under MPL 2.0, same as the rest of kasmweb.
+ */
+
+import * as Log from '../util/logging.js';
+
+// 187/188 are reserved by the direct-drive-mouse/game-mode work
+// (msgTypeForceGameMode / msgTypeDirectMouseEvent) and 189 is a buffer,
+// so WebRTC signaling lives at 190. Keep in sync with msgTypeWebRTCSignal
+// in common/rfb/msgTypes.h.
+export const WEBRTC_MSG_TYPE = 190;
+export const WEBRTC_SESSION_SCREEN = 0xFF;
+
+export const WebRTCSignalKind = Object.freeze({
+    SdpOffer:      1,
+    SdpAnswer:     2,
+    IceCandidate:  3,
+    IceServers:    4,
+    Fallback:      5,
+    ClientCapabilities: 6,
+    Close:         7,
+    RequestOffer:  8,
+});
+
+// Write a single msgTypeWebRTCSignal frame to the WebSocket. Standalone
+// (not a method) so the primary window can use it both for its own
+// transports and to forward a secondary window's relayed answer/ICE up
+// to the server. Body: [u8 190][u8 kind][u8 screenId][u16 len][payload].
+export function writeWebRTCFrame(sock, kind, screenId, payload) {
+    const utf8 = (typeof payload === 'string')
+        ? new TextEncoder().encode(payload)
+        : (payload || new Uint8Array(0));
+    if (utf8.length > 0xffff) {
+        Log.Error('WebRTC signal payload too large (' + utf8.length + 'B); dropped');
+        return;
+    }
+    const header = new Uint8Array(5);
+    header[0] = WEBRTC_MSG_TYPE;
+    header[1] = kind & 0xff;
+    header[2] = screenId & 0xff;
+    header[3] = (utf8.length >> 8) & 0xff;
+    header[4] =  utf8.length       & 0xff;
+
+    // Drain anything another writer left in the send queue so our header
+    // lands at a known offset and we have the full _sQbufferSize to chunk
+    // the body against.
+    sock.flush();
+    sock.send(header);
+
+    // Body. Websock._sQ is a fixed-size buffer (defaults to 10 KiB); SDP
+    // offers can exceed it, so chunk and let send()'s flush() drain each.
+    const sQSize = sock._sQbufferSize;
+    for (let off = 0; off < utf8.length; off += sQSize) {
+        const end = Math.min(off + sQSize, utf8.length);
+        sock.send(utf8.subarray(off, end));
+    }
+}
+
+// Per-screen signaling channel. Bound to one screenId and one outbound
+// sink. The sink is `(kind, screenId, payloadStr) => void`:
+//   - primary, screen it owns: sink writes to the WebSocket
+//     (writeWebRTCFrame(sock, ...)).
+//   - secondary window: sink posts {webrtcSignal:{kind,screenId,payload}}
+//     to its relay MessagePort; the primary forwards it to the socket.
+// Inbound signals are pushed in via deliver(kind, payload) by whoever
+// receives them (rfb.js socket reader on the primary, or the relay-port
+// onmessage handler on a secondary window).
+export default class WebRTCSignaling {
+    constructor(screenId, sendFn) {
+        this._screenId = screenId;
+        this._sendFn = sendFn;       // (kind, screenId, payloadStr) => void
+        this._onMessage = null;      // (kind, payload:string) -> void
+    }
+
+    get screenId() { return this._screenId; }
+
+    onMessage(cb) { this._onMessage = cb; }
+
+    // Inbound: dispatch a kind/payload pair to the bound transport.
+    deliver(kind, payload) {
+        if (this._onMessage) this._onMessage(kind, payload);
+    }
+
+    // Outbound: send through the configured sink, tagging our screenId.
+    send(kind, payload) {
+        this._sendFn(kind, this._screenId, payload);
+    }
+
+    sendAnswer(sdp) {
+        this.send(WebRTCSignalKind.SdpAnswer, sdp);
+    }
+    sendIceCandidate(candidate, sdpMid) {
+        this.send(WebRTCSignalKind.IceCandidate,
+                  (candidate || '') + '|' + (sdpMid || ''));
+    }
+    sendFallback(reason) {
+        this.send(WebRTCSignalKind.Fallback, reason || 'unknown');
+    }
+}
diff --git a/core/transport/webrtc_video.js b/core/transport/webrtc_video.js
new file mode 100644
index 000000000..b0de9b3e3
--- /dev/null
+++ b/core/transport/webrtc_video.js
@@ -0,0 +1,301 @@
+/*
+ * KasmVNC WebRTC video transport — browser side, one per X screen.
+ *
+ * Multi-monitor sessions run one RTCPeerConnection per screen (see
+ * doc/MULTI_MONITOR_WEBRTC_PLAN.md). Each instance owns exactly one
+ * screen's PC + <video>, and is RECV-ONLY (the server initiates the SDP
+ * offer per screen). Instances are created *reactively* by rfb.js when a
+ * per-screen SdpOffer arrives — the client does not send capabilities or
+ * offers from here; rfb.js advertises capability once for the session and
+ * the server replies with one offer per screen.
+ *
+ * Signaling is decoupled from the WebSocket: the WebRTCSignaling passed
+ * in carries a sink that routes outbound answers/ICE either straight to
+ * the socket (when this transport runs in the window that owns the
+ * server's WebSocket — the primary) or over the SharedWorker relay port
+ * (when this transport runs in a secondary window that displays the
+ * screen). Either way the transport code is identical.
+ *
+ * Failure modes that drop *this screen* to image/WebSocket-video:
+ *   - iceConnectionState === 'failed' || 'disconnected' for >5 s
+ *   - SDP answer has no overlapping codec (m=video missing / a=inactive)
+ *   - Browser refuses RTCPeerConnection construction
+ *
+ * Licensed under MPL 2.0.
+ */
+
+import * as Log from '../util/logging.js';
+import { WebRTCSignalKind } from './webrtc_signaling.js';
+
+const FALLBACK_GRACE_MS = 5000;
+
+export default class WebRTCVideoTransport {
+    // signaling: a WebRTCSignaling already bound to `screenId` and an
+    //            outbound sink (socket or relay port).
+    // opts.iceServers: [{urls}] list from the session-level kind=4 signal.
+    // opts.pending:    true when this is a smooth codec-switch transport
+    //                  that replaces an existing live one on `playing`.
+    constructor(rfb, screenId, signaling, opts) {
+        this._rfb = rfb;
+        this._screenId = screenId;
+        this._signaling = signaling;
+        this._signaling.onMessage((kind, payload) => this._onSignal(kind, payload));
+
+        this._opts = Object.assign({ pending: false, iceServers: [] }, opts || {});
+
+        this._pc = null;
+        this._video = null;
+        this._failureTimer = null;
+        this._negotiated = false;
+        this._iceServers = this._opts.iceServers || [];
+
+        // Remote ICE candidates can arrive (trickled by the server) before this
+        // side has finished setRemoteDescription — addIceCandidate() throws in
+        // that window and the candidate is lost, slowing or stalling ICE. Buffer
+        // them here and flush once the remote description is applied. See
+        // remediation plan P4.2.
+        this._remoteDescriptionSet = false;
+        this._pendingRemoteCandidates = [];
+
+        // Mirrors rfb.js's transit-state semantics so failure counters /
+        // UX don't need to learn a second model.
+        this._state = 'idle';
+    }
+
+    get screenId() { return this._screenId; }
+    get signaling() { return this._signaling; }
+    get video()     { return this._video; }
+    get state()     { return this._state; }
+    get pending()   { return !!this._opts.pending; }
+
+    stop() {
+        if (this._failureTimer) {
+            clearTimeout(this._failureTimer);
+            this._failureTimer = null;
+        }
+        if (this._pc) {
+            try { this._pc.close(); } catch (e) {}
+            this._pc = null;
+        }
+        if (this._video) {
+            this._video.srcObject = null;
+            if (this._video.parentNode) {
+                this._video.parentNode.removeChild(this._video);
+            }
+        }
+        this._state = 'closed';
+    }
+
+    _onSignal(kind, payload) {
+        switch (kind) {
+            case WebRTCSignalKind.SdpOffer:
+                this._handleOffer(payload);
+                break;
+            case WebRTCSignalKind.IceCandidate:
+                this._handleRemoteIce(payload);
+                break;
+            case WebRTCSignalKind.Close:
+                Log.Info('Server closed WebRTC screen ' + this._screenId +
+                         ': ' + payload);
+                // The screen left the layout (or its negotiation was
+                // rejected). Drop the PC; the owning window falls back to
+                // its WebSocket/encoded-frame decode path for this screen.
+                this._fallback('server-close:' + payload, /*silent=*/true);
+                break;
+            case WebRTCSignalKind.Fallback:
+                Log.Warn('Server signalled WebRTC fallback (screen ' +
+                         this._screenId + '): ' + payload);
+                this._fallback('server-' + payload, /*silent=*/true);
+                break;
+            default:
+                Log.Warn('Unknown WebRTC signal kind for screen ' +
+                         this._screenId + ': ' + kind);
+        }
+    }
+
+    _createPeerConnection() {
+        if (typeof RTCPeerConnection === 'undefined') {
+            this._fallback('no-rtcpeerconnection');
+            return;
+        }
+        try {
+            this._pc = new RTCPeerConnection({
+                iceServers: this._iceServers,
+                bundlePolicy: 'max-bundle',
+            });
+        } catch (e) {
+            Log.Error('RTCPeerConnection construction failed (screen ' +
+                      this._screenId + '): ' + e);
+            this._fallback('pc-construct-failed');
+            return;
+        }
+
+        // Recv-only transceiver so the answer aligns with the server's
+        // send-only track.
+        try {
+            this._pc.addTransceiver('video', { direction: 'recvonly' });
+        } catch (e) {
+            Log.Warn('addTransceiver(video, recvonly) failed: ' + e +
+                     ' — relying on browser default');
+        }
+
+        this._video = document.createElement('video');
+        this._video.autoplay    = true;
+        this._video.muted       = true;
+        this._video.playsInline = true;
+
+        const logVideoEvent = (name) => {
+            const err = this._video.error ? this._video.error.code : 0;
+            // Debug, not Info: these <video> media events (resize/waiting/
+            // stalled/suspend/...) fire repeatedly, especially on a stalling or
+            // low-motion stream, and spam the console at Info in production. The
+            // one-shot milestones (PLAYING / ontrack) stay at Info. See P4.1.
+            Log.Debug('[WEBRTC-DIAG] <video> ' + name + ' screen ' +
+                     this._screenId + ' (readyState=' + this._video.readyState +
+                     ', networkState=' + this._video.networkState +
+                     ', currentTime=' + this._video.currentTime.toFixed(3) +
+                     ', size=' + this._video.videoWidth + 'x' +
+                     this._video.videoHeight + ', paused=' + this._video.paused +
+                     ', error=' + err + ')');
+        };
+        ['loadedmetadata', 'canplay', 'playing', 'waiting', 'stalled',
+         'suspend', 'pause', 'error', 'resize'].forEach((name) => {
+            this._video.addEventListener(name, () => logVideoEvent(name));
+        });
+
+        this._pc.ontrack = (e) => {
+            Log.Info('[WEBRTC-DIAG] ontrack screen ' + this._screenId +
+                     ' (streams=' + (e.streams ? e.streams.length : 0) + ')');
+            this._video.srcObject = e.streams && e.streams[0]
+                ? e.streams[0]
+                : new MediaStream([e.track]);
+            this._state = 'connected';
+            if (this._rfb._onWebRTCVideoReady) {
+                this._rfb._onWebRTCVideoReady(this._video, this);
+            }
+        };
+
+        this._pc.onicecandidate = (e) => {
+            if (e.candidate) {
+                this._signaling.sendIceCandidate(e.candidate.candidate,
+                                                 e.candidate.sdpMid);
+            }
+        };
+
+        this._pc.oniceconnectionstatechange = () => {
+            const s = this._pc.iceConnectionState;
+            Log.Info('[WEBRTC-DIAG] screen ' + this._screenId +
+                     ' iceConnectionState=' + s);
+            if (s === 'failed' || s === 'disconnected') {
+                if (!this._failureTimer) {
+                    this._failureTimer = setTimeout(() => {
+                        this._failureTimer = null;
+                        // stop() can null _pc between schedule and fire.
+                        if (!this._pc) return;
+                        this._fallback('ice-' + this._pc.iceConnectionState);
+                    }, FALLBACK_GRACE_MS);
+                }
+            } else if (s === 'connected' || s === 'completed') {
+                if (this._failureTimer) {
+                    clearTimeout(this._failureTimer);
+                    this._failureTimer = null;
+                }
+            }
+        };
+    }
+
+    async _handleOffer(sdp) {
+        Log.Info('[WEBRTC-DIAG] offer received screen ' + this._screenId +
+                 ' (' + (sdp ? sdp.length : 0) + ' bytes)');
+        if (!this._pc) {
+            this._createPeerConnection();
+            if (!this._pc) return;
+        }
+        try {
+            await this._pc.setRemoteDescription({ type: 'offer', sdp });
+            // Remote description is applied — any candidates that arrived during
+            // the await are now safe to add. Flush the buffer (P4.2).
+            this._remoteDescriptionSet = true;
+            const buffered = this._pendingRemoteCandidates;
+            this._pendingRemoteCandidates = [];
+            for (const c of buffered) this._addRemoteCandidate(c.candidate, c.sdpMid);
+
+            const answer = await this._pc.createAnswer();
+            await this._pc.setLocalDescription(answer);
+
+            // Codec-mismatch guard: no usable video m-line means the
+            // browser refused every offered codec (e.g. HEVC-only server
+            // vs Firefox). Drop this screen loudly before a black frame.
+            const sdpText = answer.sdp || '';
+            if (!/^m=video /m.test(sdpText) || /^a=inactive/m.test(sdpText)) {
+                Log.Error('SDP answer for screen ' + this._screenId +
+                          ' has no usable video m-line; falling back');
+                this._fallback('codec-mismatch');
+                return;
+            }
+            this._negotiated = true;
+            Log.Info('[WEBRTC-DIAG] answer sent screen ' + this._screenId);
+            this._signaling.sendAnswer(sdpText);
+        } catch (e) {
+            Log.Error('SDP offer handling failed (screen ' +
+                      this._screenId + '): ' + e);
+            this._fallback('sdp-failed');
+        }
+    }
+
+    _handleRemoteIce(payload) {
+        const pipe = payload.indexOf('|');
+        if (pipe < 0) {
+            Log.Warn('Malformed ICE candidate from server: ' + payload);
+            return;
+        }
+        const candidate = payload.substring(0, pipe);
+        const sdpMid    = payload.substring(pipe + 1);
+        // If the offer hasn't been applied yet (no PC, or setRemoteDescription
+        // still in flight), buffer the candidate instead of dropping it —
+        // addIceCandidate() before the remote description throws and the
+        // candidate is lost, which slows or stalls ICE. _handleOffer flushes
+        // the buffer once setRemoteDescription resolves. See plan P4.2.
+        if (!this._pc || !this._remoteDescriptionSet) {
+            this._pendingRemoteCandidates.push({ candidate, sdpMid });
+            return;
+        }
+        this._addRemoteCandidate(candidate, sdpMid);
+    }
+
+    async _addRemoteCandidate(candidate, sdpMid) {
+        if (!this._pc) return;
+        try {
+            await this._pc.addIceCandidate({ candidate, sdpMid });
+        } catch (e) {
+            Log.Warn('addIceCandidate failed (screen ' +
+                     this._screenId + '): ' + e);
+        }
+    }
+
+    // Drop this screen's PC. `silent` suppresses the outbound fallback
+    // signal (used when the server already told us to close, so we don't
+    // echo it back). The owning window resumes its WebSocket/encoded-frame
+    // decode path for this screen; rfb.js handles the bookkeeping.
+    _fallback(reason, silent) {
+        this._state = 'fallback';
+        if (this._opts.pending) {
+            // A pending (codec-switch) transport failing must not drag the
+            // live one down. Abandon just the pending half.
+            if (!silent) { try { this._signaling.sendFallback('renegotiate'); } catch (e) {} }
+            if (this._rfb &&
+                typeof this._rfb._abandonPendingWebRTCScreen === 'function') {
+                this._rfb._abandonPendingWebRTCScreen(this._screenId,
+                                                      'pending-failed:' + reason);
+            }
+            this.stop();
+            return;
+        }
+        if (!silent) { try { this._signaling.sendFallback(reason); } catch (e) {} }
+        if (this._rfb &&
+            typeof this._rfb._onWebRTCScreenFallback === 'function') {
+            this._rfb._onWebRTCScreenFallback(this._screenId, reason);
+        }
+        this.stop();
+    }
+}
diff --git a/index.html b/index.html
index 53398e8a0..4f4b6aaa7 100644
--- a/index.html
+++ b/index.html
@@ -367,7 +367,18 @@ <h1 class="noVNC_logo">
                                                 </select>
                                             <li>
                                         </ul>
-                                        <hr />
+                                        <!-- WebRTC Congestion Control: hidden while the feature is still in
+                                             development. Remove the display:none (and the force-off in app/ui.js)
+                                             to re-expose it. -->
+                                        <hr style="display: none;" />
+                                        <ul style="display: none;">
+                                            <li>
+                                                <label class="switch"><input id="noVNC_setting_webrtc_congestion_control" type="checkbox" disabled />
+                                                    <span class="slider round"></span>
+                                                    <span class="slider-label">WebRTC Congestion Control</span>
+                                                </label>
+                                            </li>
+                                        </ul>
                                         <ul id="noVNC_setting_render_mode_image_quality_group">
                                             <li>
                                                 <label for="noVNC_setting_video_quality">Preset Modes:</label>