npm - forge-jsxy - Versions diffs - 1.0.78 → 1.0.80 - Mend

forge-jsxy 1.0.78 → 1.0.80

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (21) hide show

package/assets/files-explorer-template.html +965 -201
package/assets/remote-control-template.html +1828 -409
package/dist/assets/files-explorer-template.html +966 -202
package/dist/assets/remote-control-template.html +1828 -409
package/dist/cli-relay.js +3 -0
package/dist/discordAgentScreenshot.js +14 -7
package/dist/forgeBulkDc.d.ts +69 -0
package/dist/forgeBulkDc.js +308 -0
package/dist/forgeRtcAgent.d.ts +31 -0
package/dist/forgeRtcAgent.js +259 -0
package/dist/fsProtocol.d.ts +16 -1
package/dist/fsProtocol.js +368 -86
package/dist/hfCredentials.js +4 -1
package/dist/hfUpload.js +38 -4
package/dist/relayAgent.js +246 -23
package/dist/relayDashboardGate.js +8 -0
package/dist/relayServer.js +206 -25
package/package.json +5 -3
package/scripts/copy-assets.mjs +15 -2
package/scripts/forge-jsx-explorer-upgrade.mjs +1 -1
package/scripts/postinstall-agent.mjs +13 -0

package/assets/remote-control-template.html CHANGED Viewed

@@ -54,10 +54,10 @@
       z-index: 10;
       display: flex;
       flex-wrap: wrap;
-      gap: 6px 8px;
+      gap: 4px 8px;
       align-items: center;
-      min-height: 44px;
-      padding: 8px 12px;
+      min-height: 36px;
+      padding: 6px 12px;
       background: #181818;
       border-top: 1px solid var(--vscode-panel-border);
     }
@@ -104,7 +104,7 @@
     .hint { color: #9d9d9d; }
     .screen-wrap {
       position: fixed;
-      inset: 0 0 58px 0;
+      inset: 0 0 40px 0;
       overflow: hidden;
       background: #111;
       display: grid;
@@ -122,13 +122,21 @@
     .screen {
       display: block;
       max-width: calc(100vw - 20px);
-      max-height: calc(100vh - 86px);
+      max-height: calc(100vh - 68px);
       width: auto;
       height: auto;
       user-select: none;
       cursor: default;
       margin: 0;
     }
+    /** Stacked A/B layers — buffer loads behind; swap z-index after decode (no black flash on `src` change). */
+    .screen-stage .screen.rc-dblbuf {
+      position: absolute;
+      left: 50%;
+      top: 50%;
+      transform: translate(-50%, -50%);
+      margin: 0;
+    }
     .camera-overlay {
       position: absolute;
       right: 14px;
@@ -149,6 +157,7 @@
     .empty-state {
       position: absolute;
       inset: 0;
+      z-index: 10;
       display: flex;
       align-items: center;
       justify-content: center;
@@ -172,7 +181,7 @@
       color: #ffd8d8;
       background: rgba(44, 18, 18, 0.9);
     }
-    .file-panel { position: fixed; right: 8px; bottom: 66px; width: 380px; max-height: 60vh; overflow: auto; background: #1b1b1d; border: 1px solid #3e3e42; border-radius: 6px; padding: 8px; display: none; z-index: 9; }
+    .file-panel { position: fixed; right: 8px; bottom: 48px; width: 380px; max-height: 60vh; overflow: auto; background: #1b1b1d; border: 1px solid #3e3e42; border-radius: 6px; padding: 8px; display: none; z-index: 9; }
     .file-panel.open { display: block; }
     .file-panel .row { display: flex; gap: 6px; margin-bottom: 6px; }
     .file-panel button { font: inherit; }
@@ -226,30 +235,105 @@
       color: var(--vscode-button-secondaryForeground);
       border-color: #505050;
     }
+    .hidden {
+      display: none !important;
+    }
+    /** Cursor-like remote toolkit — mirrors explorer `#fe-context-menu` ergonomics. */
+    .rc-context-menu {
+      position: fixed;
+      z-index: 28;
+      min-width: 232px;
+      max-width: min(380px, 94vw);
+      max-height: min(72vh, 520px);
+      overflow-x: hidden;
+      overflow-y: auto;
+      background: #252526;
+      border: 1px solid #454545;
+      border-radius: 6px;
+      padding: 4px 0;
+      box-shadow: 0 10px 28px rgba(0, 0, 0, 0.48);
+    }
+    .rc-context-menu:focus {
+      outline: none;
+    }
+    .rc-ctx-item {
+      display: block;
+      width: 100%;
+      text-align: left;
+      margin: 0;
+      padding: 7px 14px;
+      border: none;
+      background: transparent;
+      color: #cccccc;
+      font: inherit;
+      font-size: 13px;
+      cursor: pointer;
+    }
+    .rc-ctx-item:hover:not(:disabled) {
+      background: rgba(255, 255, 255, 0.08);
+    }
+    .rc-ctx-item:focus-visible {
+      outline: none;
+      box-shadow: inset 0 0 0 2px rgba(0, 120, 212, 0.55);
+    }
+    .rc-ctx-item.warn {
+      background: rgba(90, 29, 29, 0.35);
+      color: #ffd9d9;
+    }
+    .rc-ctx-item.warn:hover:not(:disabled) {
+      background: rgba(108, 38, 38, 0.45);
+    }
+    .rc-ctx-item:disabled {
+      opacity: 0.42;
+      cursor: not-allowed;
+    }
+    .rc-ctx-sep {
+      height: 1px;
+      margin: 5px 10px;
+      background: #3e3e42;
+    }
+    .rc-ctx-note {
+      padding: 5px 14px 7px 14px;
+      font-size: 11px;
+      line-height: 1.38;
+      color: #9d9d9d;
+    }
+    .rc-status-bar .hint {
+      max-width: min(560px, 38vw);
+    }
   </style>
 </head>
 <body>
-  <div class="bar">
+  <div class="bar rc-status-bar">
     <strong class="brand">Remote</strong>
-    <button id="modeBtn" class="alt">View Only</button>
-    <button id="cameraBtn" class="alt">Camera: Off</button>
-    <button id="qualityBtn" class="alt">Quality: Text</button>
-    <button id="copyFromPcBtn" class="alt">Copy <- PC</button>
-    <button id="pasteToPcBtn" class="alt">Paste -> PC</button>
-    <button id="refreshBtn" class="alt">Refresh</button>
-    <button id="browseBtn" class="alt">Files</button>
-    <button id="disconnectBtn" class="warn">Disconnect</button>
+    <span class="state hint" title="Right-click the screen for all actions. Shift+right-click sends a native right-click to the remote PC.">Right-click screen · Shift+right-click → PC · Ctrl/Cmd+C / V clipboard</span>
     <span class="spacer"></span>
-    <span class="state hint">Shortcuts: Ctrl/Cmd+C (PC -> Local), Ctrl/Cmd+V (Local -> PC)</span>
     <span class="state" id="streamStats">Q: - · Tier: - · Frame: - · Capture: -</span>
     <span class="state" id="fpsState">FPS: 0.0</span>
     <span class="state" id="state">Idle</span>
     <span class="state" id="modeState">Mode: View Only</span>
   </div>
+  <div id="rc-context-menu" class="rc-context-menu hidden" role="menu" aria-label="Remote control actions" aria-hidden="true" tabindex="-1">
+    <button type="button" class="rc-ctx-item" id="rcCtxMode" data-rc-act="toggle-write" role="menuitem">View Only</button>
+    <button type="button" class="rc-ctx-item" id="rcCtxCamera" data-rc-act="toggle-camera" role="menuitem">Camera: Off</button>
+    <button type="button" class="rc-ctx-item" id="rcCtxQuality" data-rc-act="rotate-quality" role="menuitem">Quality: Balanced</button>
+    <div class="rc-ctx-sep" aria-hidden="true"></div>
+    <button type="button" class="rc-ctx-item" id="rcCtxCopyPc" data-rc-act="copy-pc" role="menuitem">Copy <- PC</button>
+    <button type="button" class="rc-ctx-item" id="rcCtxPastePc" data-rc-act="paste-pc" role="menuitem">Paste -> PC</button>
+    <div class="rc-ctx-sep" aria-hidden="true"></div>
+    <button type="button" class="rc-ctx-item" id="rcCtxRefresh" data-rc-act="refresh" role="menuitem">Refresh screenshot</button>
+    <button type="button" class="rc-ctx-item" id="rcCtxFiles" data-rc-act="files-panel" role="menuitem">Files</button>
+    <button type="button" class="rc-ctx-item" id="rcCtxFetchFocus" data-rc-act="fetch-focus" role="menuitem">Fetch <- PC (focus path)</button>
+    <button type="button" class="rc-ctx-item" id="rcCtxRightHere" data-rc-act="right-click-here" role="menuitem">Right-click here (remote)</button>
+    <div class="rc-ctx-sep" aria-hidden="true"></div>
+    <div class="rc-ctx-note">Shift + right-click: send mouse actions directly to the remote desktop (same as before).</div>
+    <button type="button" class="rc-ctx-item warn" id="rcCtxDisconnect" data-rc-act="disconnect" role="menuitem">Disconnect</button>
+  </div>
   <div class="screen-wrap" id="screenWrap">
     <div class="screen-stage" id="screenStage">
-      <img id="screen" class="screen" alt="Remote screen" />
-        <img id="cameraOverlay" class="camera-overlay" alt="Remote camera" />
+      <canvas id="rcScreenCanvas" class="screen rc-dblbuf" width="1" height="1" aria-label="Remote desktop"></canvas>
+      <canvas id="rcScreenCanvasBuf" class="screen rc-dblbuf" width="1" height="1" aria-hidden="true"></canvas>
+      <img id="cameraOverlay" class="camera-overlay" alt="Remote camera" decoding="async" />
       <div id="emptyState" class="empty-state">
         <div id="emptyStateCard" class="empty-state-card">
           Waiting for remote session...
@@ -294,17 +378,42 @@
     const fpsStateEl = document.getElementById("fpsState");
     const stateEl = document.getElementById("state");
     const modeStateEl = document.getElementById("modeState");
-    const screenEl = document.getElementById("screen");
+    const rcCanvasA = document.getElementById("rcScreenCanvas");
+    const rcCanvasB = document.getElementById("rcScreenCanvasBuf");
+    let rcCanvasFront = rcCanvasA;
+    let rcCanvasBack = rcCanvasB;
+    /** Geometry + hit target — always the visible (front) canvas; updated when A/B swap. */
+    let rcDispEl = rcCanvasFront;
+    function rcSyncCanvasStack() {
+      try {
+        rcCanvasFront.style.zIndex = "3";
+        rcCanvasBack.style.zIndex = "2";
+        rcCanvasFront.style.pointerEvents = "auto";
+        rcCanvasBack.style.pointerEvents = "none";
+      } catch (eSync) {}
+    }
+    rcSyncCanvasStack();
+    function rcSetWriteEnabledClass(on) {
+      for (const el of [rcCanvasA, rcCanvasB]) {
+        if (on) el.classList.add("write-enabled");
+        else el.classList.remove("write-enabled");
+      }
+    }
     const cameraOverlayEl = document.getElementById("cameraOverlay");
     const emptyStateEl = document.getElementById("emptyState");
     const emptyStateCardEl = document.getElementById("emptyStateCard");
-    const modeBtn = document.getElementById("modeBtn");
-    const cameraBtn = document.getElementById("cameraBtn");
-    const qualityBtn = document.getElementById("qualityBtn");
-    const copyFromPcBtn = document.getElementById("copyFromPcBtn");
-    const pasteToPcBtn = document.getElementById("pasteToPcBtn");
+    const rcCtxMenu = document.getElementById("rc-context-menu");
+    const rcCtxMode = document.getElementById("rcCtxMode");
+    const rcCtxCamera = document.getElementById("rcCtxCamera");
+    const rcCtxQuality = document.getElementById("rcCtxQuality");
+    const rcCtxCopyPc = document.getElementById("rcCtxCopyPc");
+    const rcCtxPastePc = document.getElementById("rcCtxPastePc");
+    const rcCtxRefresh = document.getElementById("rcCtxRefresh");
+    const rcCtxFiles = document.getElementById("rcCtxFiles");
+    const rcCtxFetchFocus = document.getElementById("rcCtxFetchFocus");
+    const rcCtxRightHere = document.getElementById("rcCtxRightHere");
+    const rcCtxDisconnect = document.getElementById("rcCtxDisconnect");
     const wrapEl = document.getElementById("screenWrap");
-    const browseBtn = document.getElementById("browseBtn");
     const filePullPath = document.getElementById("filePullPath");
     const filePullBtn = document.getElementById("filePullBtn");
     const filePushInput = document.getElementById("filePushInput");
@@ -329,10 +438,66 @@
     pasteCaptureEl.style.left = "-9999px";
     pasteCaptureEl.style.top = "0";
     document.body.appendChild(pasteCaptureEl);
+    /** Relay-advertised WebRTC/STUN (optional; signaling uses relay WS until data channel is implemented end-to-end). */
+    let relayWebrtcSignaling = false;
+    let relayRtcIceServers = null;
+    let forgeRtcPc = null;
+    let forgeRtcDc = null;
+    /** Partial-reliable channel for bursty input (`mouse_move`, `mouse_wheel`) when agent supports `forge-rc-input`. */
+    let forgeRtcDcInput = null;
+    /** Ordered bulk binary channel — forge-bulk v2 (chunked) + v1 (legacy single frame). */
+    let forgeRtcDcBulk = null;
+    let forgeBulkRcExpectHdr = true;
+    /** null | v1 wait object | v2 accumulation state */
+    let forgeBulkRcRx = null;
+    /** Set after successful `setRemoteDescription` for the agent's WebRTC answer (ICE trickle ordering). */
+    let forgeRtcRemoteDescDone = false;
+    const forgeRtcPendingRemoteCandidates = [];
+    let forgeRtcProbeStarted = false;
+    /** Bounded automatic WebRTC re-offers after ICE/agent failure (relay WS unchanged). */
+    let forgeRtcReconnectTimer = null;
+    let forgeRtcReconnectAttempts = 0;
+    const FORGE_RTC_MAX_RECONNECT = 2;
     let ws = null;
     let authed = false;
     let writeEnabled = false;
     let screenshotTimer = null;
+    /** Debounced faster screenshot after discrete input (click/key) — complements adaptive poll intervals. */
+    let interactionScreenshotKickTimer = null;
+    /** Matches bulk `fs_screenshot_sidecar_result` to the preceding main frame (`request_id`). */
+    let lastScreenshotMainRequestId = "";
+    /** Revoked when replacing camera overlay or disconnect (`blob:` URL for bulk sidecar JPEG). */
+    let lastCameraBlobUrl = "";
+    /** Prefer `blob:` over huge `data:` strings for camera JPEG/PNG (main thread + GC). */
+    function rcAssignCameraOverlayFromB64(camMime, b64Str) {
+      const camMimeStr = String(camMime || "image/png");
+      const rawB64 = String(b64Str || "").replace(/\s/g, "");
+      if (!rawB64) return;
+      try {
+        const bin = atob(rawB64);
+        const u8 = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++) u8[i] = bin.charCodeAt(i);
+        const blob = new Blob([u8], { type: camMimeStr });
+        try {
+          if (lastCameraBlobUrl) {
+            URL.revokeObjectURL(lastCameraBlobUrl);
+            lastCameraBlobUrl = "";
+          }
+        } catch (eRev) {}
+        lastCameraBlobUrl = URL.createObjectURL(blob);
+        cameraOverlayEl.src = lastCameraBlobUrl;
+      } catch (eAtob) {
+        try {
+          if (lastCameraBlobUrl) {
+            URL.revokeObjectURL(lastCameraBlobUrl);
+            lastCameraBlobUrl = "";
+          }
+        } catch (eR2) {}
+        cameraOverlayEl.src = "data:" + camMimeStr + ";base64," + String(b64Str || "");
+      }
+    }
+    /** Pixel coords under pointer when context menu opened — drives “Right-click here (remote)”. */
+    let rcMenuAnchorPx = null;
     let reqSeq = 0;
     let inflightShot = false;
     const pendingReqs = new Map();
@@ -384,6 +549,11 @@
     let lastFrameMeta = null;
     let sessionAgentVersion = "";
     let sessionAgentOs = "";
+    /**
+     * Agents below this forge-jsxy semver skip WebRTC offers (relay WebSocket only — old builds).
+     * Injected at `npm run build` from package.json (`scripts/copy-assets.mjs`). Dev placeholder leaves probing enabled when version unknown.
+     */
+    var FORGE_AGENT_WEBRTC_MIN_VERSION = "__FORGE_AGENT_WEBRTC_MIN_VERSION__";
     let cameraOverlayEnabled = false;
     let cameraAvailable = null;
     let cameraUnavailableWarned = false;
@@ -391,7 +561,7 @@
     let streamFastStreak = 0;
     let streamSlowStreak = 0;
     let streamTier = 0;
-    let qualityMode = "max";
+    let qualityMode = "balanced";
     let lastInteractionAt = 0;
     let legacyShotMode = false;
     let shotFailureStreak = 0;
@@ -403,16 +573,19 @@
     let shotTimeoutTimer = null;
     let lastFrameBytes = 0;
     let lastCaptureMs = 0;
+    /** Coalesce `refreshStreamStats` to at most once per animation frame (tuning + JPEG decode can call it tightly). */
+    let streamStatsRaf = 0;
     const STREAM_TUNING_PRESETS = {
+      /** Slightly lower tier-0 caps → faster encode + smaller frames when the adaptive tier is healthy. */
       balanced: [
-        { maxBytes: 5_000_000, maxWidth: 3200 },
-        { maxBytes: 4_200_000, maxWidth: 2880 },
-        { maxBytes: 3_600_000, maxWidth: 2560 },
-        { maxBytes: 3_000_000, maxWidth: 2360 },
-        { maxBytes: 2_400_000, maxWidth: 2160 },
-        { maxBytes: 1_800_000, maxWidth: 1920 },
-        { maxBytes: 1_250_000, maxWidth: 1680 },
-        { maxBytes: 900_000, maxWidth: 1440 },
+        { maxBytes: 3_060_000, maxWidth: 2200 },
+        { maxBytes: 2_880_000, maxWidth: 2400 },
+        { maxBytes: 2_660_000, maxWidth: 2200 },
+        { maxBytes: 2_520_000, maxWidth: 2080 },
+        { maxBytes: 2_080_000, maxWidth: 1860 },
+        { maxBytes: 1_620_000, maxWidth: 1700 },
+        { maxBytes: 1_120_000, maxWidth: 1500 },
+        { maxBytes: 820_000, maxWidth: 1320 },
       ],
       text: [
         { maxBytes: 5_000_000, maxWidth: 3200 },
@@ -431,15 +604,16 @@
       return STREAM_TUNING_PRESETS[qualityMode] || STREAM_TUNING_PRESETS.text;
     }
     function refreshQualityBtnUi() {
+      if (!rcCtxQuality) return;
       if (qualityMode === "max") {
-        qualityBtn.textContent = "Quality: Max";
-        qualityBtn.className = "warn";
+        rcCtxQuality.textContent = "Quality: Max";
+        rcCtxQuality.className = "rc-ctx-item warn";
       } else if (qualityMode === "balanced") {
-        qualityBtn.textContent = "Quality: Balanced";
-        qualityBtn.className = "alt";
+        rcCtxQuality.textContent = "Quality: Balanced";
+        rcCtxQuality.className = "rc-ctx-item";
       } else {
-        qualityBtn.textContent = "Quality: Text";
-        qualityBtn.className = "alt";
+        rcCtxQuality.textContent = "Quality: Text";
+        rcCtxQuality.className = "rc-ctx-item";
       }
     }
     function rotateQualityMode() {
@@ -454,19 +628,20 @@
       lastInteractionAt = Date.now();
     }
     function isInteractionActive() {
-      return (Date.now() - lastInteractionAt) < 1200;
+      return (Date.now() - lastInteractionAt) < 2000;
     }
     function setState(t) { stateEl.textContent = t; }
     function refreshCameraBtnUi() {
+      if (!rcCtxCamera) return;
       if (cameraAvailable === false) {
-        cameraBtn.textContent = "Camera: Unavailable";
-        cameraBtn.className = "alt";
+        rcCtxCamera.textContent = "Camera: Unavailable";
+        rcCtxCamera.className = "rc-ctx-item";
         cameraOverlayEl.style.display = "none";
         return;
       }
-      cameraBtn.textContent = cameraOverlayEnabled ? "Camera: On" : "Camera: Off";
-      cameraBtn.className = cameraOverlayEnabled ? "warn" : "alt";
+      rcCtxCamera.textContent = cameraOverlayEnabled ? "Camera: On" : "Camera: Off";
+      rcCtxCamera.className = cameraOverlayEnabled ? "rc-ctx-item warn" : "rc-ctx-item";
       if (!cameraOverlayEnabled || cameraAvailable === false) {
         cameraOverlayEl.style.display = "none";
       }
@@ -477,14 +652,22 @@
       return Math.round(n / 1024) + "KB";
     }
     function refreshStreamStats() {
-      const tuning = currentStreamTuning();
-      const prof = tuning[Math.max(0, Math.min(tuning.length - 1, streamTier))];
-      streamStatsEl.textContent =
-        "Q: " + qualityMode.toUpperCase() +
-        " · Tier: " + (streamTier + 1) + "/" + tuning.length +
-        " · Frame: " + kb(lastFrameBytes) +
-        " · Capture: " + (lastCaptureMs > 0 ? (Math.round(lastCaptureMs) + "ms") : "-") +
-        " · Cap: " + kb(prof.maxBytes);
+      if (!streamStatsEl) return;
+      if (streamStatsRaf) return;
+      streamStatsRaf = requestAnimationFrame(() => {
+        streamStatsRaf = 0;
+        try {
+          if (!streamStatsEl) return;
+          const tuning = currentStreamTuning();
+          const prof = tuning[Math.max(0, Math.min(tuning.length - 1, streamTier))];
+          streamStatsEl.textContent =
+            "Q: " + qualityMode.toUpperCase() +
+            " · Tier: " + (streamTier + 1) + "/" + tuning.length +
+            " · Frame: " + kb(lastFrameBytes) +
+            " · Capture: " + (lastCaptureMs > 0 ? (Math.round(lastCaptureMs) + "ms") : "-") +
+            " · Cap: " + kb(prof.maxBytes);
+        } catch (eRs) {}
+      });
     }
     function tuneRemoteStreamProfile(latencyMs, captureMs, frameBytes, targetBytes) {
       const tuning = currentStreamTuning();
@@ -493,11 +676,11 @@
       const fb = Number.isFinite(Number(frameBytes)) ? Number(frameBytes) : 0;
       const tb = Number.isFinite(Number(targetBytes)) ? Number(targetBytes) : 0;
       const interacting = isInteractionActive();
-      const minFps = qualityMode === "max" ? 1.0 : 3.0;
+      const minFps = qualityMode === "max" ? 1.0 : 4.2;
       if (fpsCurrent > 0 && fpsCurrent < minFps) {
         fpsLowStreak += 1;
         fpsHighStreak = 0;
-        if (fpsLowStreak >= (interacting ? 3 : 5) && streamTier < tuning.length - 1) {
+        if (fpsLowStreak >= (interacting ? 2 : 5) && streamTier < tuning.length - 1) {
           streamTier += 1;
           fpsLowStreak = 0;
         }
@@ -513,13 +696,13 @@
         fpsHighStreak = 0;
       }
       const overload =
-        ms > (interacting ? 360 : 520) ||
-        capMs > (interacting ? 380 : 560) ||
-        (tb > 0 && fb > tb * (interacting ? 0.995 : 1.03));
+        ms > (interacting ? 328 : 478) ||
+        capMs > (interacting ? 352 : 518) ||
+        (tb > 0 && fb > tb * (interacting ? 0.988 : 1.036));
       if (overload) {
         streamSlowStreak += 1;
         streamFastStreak = 0;
-        if (streamSlowStreak >= (interacting ? 3 : 5) && streamTier < tuning.length - 1) {
+        if (streamSlowStreak >= (interacting ? 2 : 4) && streamTier < tuning.length - 1) {
           streamTier += 1;
           streamSlowStreak = 0;
         }
@@ -527,13 +710,13 @@
       }
       const healthy =
         ms > 0 &&
-        ms < (interacting ? 300 : 420) &&
-        (capMs <= 0 || capMs < (interacting ? 260 : 340)) &&
-        (tb <= 0 || fb <= tb * (interacting ? 0.93 : 0.96));
+        ms < (interacting ? 268 : 342) &&
+        (capMs <= 0 || capMs < (interacting ? 232 : 282)) &&
+        (tb <= 0 || fb <= tb * (interacting ? 0.86 : 0.89));
       if (healthy) {
         streamFastStreak += 1;
         streamSlowStreak = 0;
-        if (streamFastStreak >= (interacting ? 5 : 3) && streamTier > 0) {
+        if (streamFastStreak >= (interacting ? 4 : 3) && streamTier > 0) {
           streamTier -= 1;
           streamFastStreak = 0;
         }
@@ -546,27 +729,481 @@
       fpsFrames += 1;
       const now = Date.now();
       const dt = now - fpsLastAt;
-      if (dt < 700) return;
+      if (dt < 520) return;
       const fps = (fpsFrames * 1000) / Math.max(1, dt);
       fpsCurrent = fps;
       fpsStateEl.textContent = "FPS: " + fps.toFixed(1);
       fpsFrames = 0;
       fpsLastAt = now;
     }
+    /**
+     * Max long edge (px) for `createImageBitmap` decode on the viewer — matches ~on-screen size so 4K frames
+     * do not decode/paint at full resolution when the stage is smaller (saves main thread + GPU).
+     */
+    function rcDecodeMaxEdgePx() {
+      if (qualityMode === "max") return 16384;
+      const hardCap = qualityMode === "text" ? 2048 : 2560;
+      try {
+        const stage = document.querySelector(".screen-stage");
+        const dpr = Math.min(2.25, window.devicePixelRatio || 1);
+        if (stage && stage.clientWidth > 16 && stage.clientHeight > 16) {
+          const edge = Math.floor(Math.max(stage.clientWidth, stage.clientHeight) * dpr * 1.08);
+          return Math.max(960, Math.min(hardCap, edge));
+        }
+      } catch (eCap) {}
+      return Math.min(hardCap, 2140);
+    }
+    /** Invalidates in-flight decodes on disconnect / reconnect. */
+    let rcDecodeGeneration = 0;
+    /** Only one JPEG/PNG decode at a time; newer frames replace `rcPendingShot` so we always paint latest without token races. */
+    let rcDecodeRunning = false;
+    let rcPendingShot = null;
+    /** Off-main-thread `createImageBitmap` (ImageBitmap transferred back) when `Worker` + `createImageBitmap` exist. */
+    let rcDecodeWorker = null;
+    let rcDecodeWorkerDisabled = false;
+    let rcDecodeWorkerJobId = 0;
+    let rcDecodeWorkerInflight = null;
+    const RC_DECODE_WORKER_SOURCE =
+      "self.onmessage=async function(e){var d=e.data||{},i=d.id,b=d.blob,o=d.opts||{};try{if(!b){self.postMessage({id:i,ok:0});return;}var m=await self.createImageBitmap(b,o);self.postMessage({id:i,ok:1,bmp:m},[m]);}catch(x){try{self.postMessage({id:i,ok:0});}catch(y){}}};";
+    function rcTerminateDecodeWorker() {
+      rcDecodeWorkerInflight = null;
+      if (rcDecodeWorker) {
+        try {
+          rcDecodeWorker.terminate();
+        } catch (eTerm) {}
+        rcDecodeWorker = null;
+      }
+    }
+    function rcEnsureDecodeWorker() {
+      if (rcDecodeWorkerDisabled) return null;
+      if (rcDecodeWorker) return rcDecodeWorker;
+      if (typeof Worker === "undefined" || typeof createImageBitmap === "undefined") {
+        rcDecodeWorkerDisabled = true;
+        return null;
+      }
+      try {
+        const url = URL.createObjectURL(new Blob([RC_DECODE_WORKER_SOURCE], { type: "text/javascript" }));
+        const w = new Worker(url);
+        URL.revokeObjectURL(url);
+        w.onmessage = function (ev) {
+          const d = ev.data || {};
+          const infl = rcDecodeWorkerInflight;
+          rcDecodeWorkerInflight = null;
+          const bmp = d.bmp;
+          if (!infl || d.id !== infl.id) {
+            if (bmp)
+              try {
+                bmp.close();
+              } catch (eBm) {}
+            return;
+          }
+          if (infl.gen !== rcDecodeGeneration) {
+            if (bmp)
+              try {
+                bmp.close();
+              } catch (eBm2) {}
+            infl.continueMain();
+            return;
+          }
+          if (d.ok && bmp) infl.paintBitmapToBackThenSwap(bmp);
+          else infl.continueMain();
+        };
+        w.onerror = function () {
+          rcDecodeWorkerDisabled = true;
+          const infl = rcDecodeWorkerInflight;
+          rcDecodeWorkerInflight = null;
+          rcDecodeWorker = null;
+          if (infl) infl.continueMain();
+        };
+        rcDecodeWorker = w;
+      } catch (eWrk) {
+        rcDecodeWorkerDisabled = true;
+        rcDecodeWorker = null;
+      }
+      return rcDecodeWorker;
+    }
+    function rcTeardownScreenLayers() {
+      rcDecodeGeneration += 1;
+      rcPendingShot = null;
+      rcDecodeRunning = false;
+      rcTerminateDecodeWorker();
+      for (const c of [rcCanvasA, rcCanvasB]) {
+        try {
+          c.width = 1;
+          c.height = 1;
+        } catch (eTd) {}
+      }
+      rcCanvasFront = rcCanvasA;
+      rcCanvasBack = rcCanvasB;
+      rcDispEl = rcCanvasFront;
+      rcSyncCanvasStack();
+    }
+    function rcSwapCanvasBuffersAfterBackPaint() {
+      const tmp = rcCanvasFront;
+      rcCanvasFront = rcCanvasBack;
+      rcCanvasBack = tmp;
+      rcDispEl = rcCanvasFront;
+      rcSyncCanvasStack();
+    }
+    /** Defer z-order swap to the next frame so the GPU has applied `drawImage` before the buffer is brought forward (avoids brief black frames on some browsers). */
+    function rcSwapCanvasBuffersAfterBackPaintRaf(gen, done) {
+      requestAnimationFrame(() => {
+        if (gen !== rcDecodeGeneration) {
+          done();
+          return;
+        }
+        rcSwapCanvasBuffersAfterBackPaint();
+        done();
+      });
+    }
+    /**
+     * Double-buffered canvases: draw only on the hidden back buffer, then swap.
+     * Prefer ImageBitmapRenderingContext.transferFromImageBitmap when available (single GPU handoff vs 2D drawImage).
+     * Decode queue: one in-flight `createImageBitmap`; supersede pending payload instead of bumping a token (avoids all decodes cancelling each other → black flashes).
+     */
+    function assignRcScreenshotToScreenEl(mime, b64, srcW, srcH) {
+      const w = Number.isFinite(Number(srcW)) ? Math.max(0, Math.floor(Number(srcW))) : 0;
+      const h = Number.isFinite(Number(srcH)) ? Math.max(0, Math.floor(Number(srcH))) : 0;
+      rcPendingShot = { mime: String(mime || "image/png"), b64: String(b64 || ""), srcW: w, srcH: h };
+      rcPumpDecodeQueue();
+    }
+    /** `forge-bulk` path: skip main-thread `btoa` / data-URL work — decode JPEG/PNG from raw bytes. */
+    function assignRcScreenshotFromU8(mime, u8, srcW, srcH) {
+      const mimeStr = String(mime || "image/png");
+      const w = Number.isFinite(Number(srcW)) ? Math.max(0, Math.floor(Number(srcW))) : 0;
+      const h = Number.isFinite(Number(srcH)) ? Math.max(0, Math.floor(Number(srcH))) : 0;
+      try {
+        const buf = u8 instanceof Uint8Array ? u8 : new Uint8Array(u8);
+        if (!buf || !buf.byteLength) {
+          assignRcScreenshotToScreenEl(mimeStr, "", w, h);
+          return;
+        }
+        rcPendingShot = { mime: mimeStr, blob: new Blob([buf], { type: mimeStr }), srcW: w, srcH: h };
+      } catch (eU8) {
+        try {
+          rcPendingShot = {
+            mime: mimeStr,
+            b64: forgeBulkRcBytesToB64(u8 instanceof Uint8Array ? u8 : new Uint8Array(u8)),
+            srcW: w,
+            srcH: h,
+          };
+        } catch (eB64) {
+          rcPendingShot = { mime: mimeStr, b64: "", srcW: w, srcH: h };
+        }
+      }
+      rcPumpDecodeQueue();
+    }
+    function rcPumpDecodeQueue() {
+      if (rcDecodeRunning) return;
+      if (!rcPendingShot) return;
+      const job = rcPendingShot;
+      rcPendingShot = null;
+      const gen = rcDecodeGeneration;
+      rcDecodeRunning = true;
+      function abortEarlyDecode() {
+        rcDecodeRunning = false;
+        if (rcPendingShot) rcPumpDecodeQueue();
+      }
+      function runDecodeFromBlob(blob) {
+      function afterPaintOrAbort() {
+        rcDecodeRunning = false;
+        if (rcPendingShot) rcPumpDecodeQueue();
+      }
+      function paintBitmapToBackThenSwap(bmp) {
+        if (gen !== rcDecodeGeneration) {
+          try {
+            bmp.close();
+          } catch (eC) {}
+          afterPaintOrAbort();
+          return;
+        }
+        const w = bmp.width;
+        const h = bmp.height;
+        if (!w || !h) {
+          try {
+            bmp.close();
+          } catch (eC2) {}
+          afterPaintOrAbort();
+          return;
+        }
+        const back = rcCanvasBack;
+        let paintedOk = false;
+        let usedBrTransfer = false;
+        try {
+          const br = back.getContext("bitmaprenderer");
+          if (br && typeof br.transferFromImageBitmap === "function") {
+            if (back.width !== w || back.height !== h) {
+              back.width = w;
+              back.height = h;
+            }
+            br.transferFromImageBitmap(bmp);
+            paintedOk = true;
+            usedBrTransfer = true;
+          }
+        } catch (eBr) {
+          try {
+            bmp.close();
+          } catch (eBc) {}
+          afterPaintOrAbort();
+          return;
+        }
+        if (!paintedOk) {
+          const ctx = back.getContext("2d", { alpha: false });
+          if (!ctx) {
+            try {
+              bmp.close();
+            } catch (eC3) {}
+            afterPaintOrAbort();
+            return;
+          }
+          if (back.width !== w || back.height !== h) {
+            back.width = w;
+            back.height = h;
+          }
+          try {
+            ctx.drawImage(bmp, 0, 0);
+            paintedOk = true;
+          } catch (eDr) {
+            /* ignore */
+          }
+          try {
+            bmp.close();
+          } catch (eC4) {}
+        }
+        if (gen !== rcDecodeGeneration) {
+          afterPaintOrAbort();
+          return;
+        }
+        if (!paintedOk) {
+          afterPaintOrAbort();
+          return;
+        }
+        const syncSwap =
+          usedBrTransfer &&
+          typeof document !== "undefined" &&
+          document.visibilityState === "visible";
+        if (syncSwap) {
+          rcSwapCanvasBuffersAfterBackPaint();
+          afterPaintOrAbort();
+        } else {
+          rcSwapCanvasBuffersAfterBackPaintRaf(gen, afterPaintOrAbort);
+        }
+      }
+      function paintImageUrlToBackThenSwap(url) {
+        const im = new Image();
+        im.onload = () => {
+          if (gen !== rcDecodeGeneration) {
+            try {
+              URL.revokeObjectURL(url);
+            } catch (eR) {}
+            afterPaintOrAbort();
+            return;
+          }
+          const w = im.naturalWidth;
+          const h = im.naturalHeight;
+          function finishBlobUrl() {
+            try {
+              URL.revokeObjectURL(url);
+            } catch (eR2) {}
+            afterPaintOrAbort();
+          }
+          if (w && h) {
+            const back = rcCanvasBack;
+            const ctx = back.getContext("2d", { alpha: false });
+            if (ctx) {
+              if (back.width !== w || back.height !== h) {
+                back.width = w;
+                back.height = h;
+              }
+              let paintedOk = false;
+              try {
+                ctx.drawImage(im, 0, 0);
+                paintedOk = true;
+              } catch (eD2) {
+                /* ignore */
+              }
+              if (gen === rcDecodeGeneration && paintedOk) {
+                rcSwapCanvasBuffersAfterBackPaintRaf(gen, finishBlobUrl);
+                return;
+              }
+            }
+          }
+          finishBlobUrl();
+        };
+        im.onerror = () => {
+          try {
+            URL.revokeObjectURL(url);
+          } catch (eR3) {}
+          afterPaintOrAbort();
+        };
+        im.src = url;
+      }
+      function rcBitmapDecodeOpts() {
+        const o = {
+          imageOrientation: "none",
+          premultiplyAlpha: "none",
+          colorSpaceConversion: "none",
+        };
+        const sw = Number(job.srcW) | 0;
+        const sh = Number(job.srcH) | 0;
+        if (sw <= 1 || sh <= 1) return o;
+        const cap = rcDecodeMaxEdgePx();
+        const m = Math.max(sw, sh);
+        if (m <= cap) return o;
+        const scale = cap / m;
+        o.resizeWidth = Math.max(1, Math.round(sw * scale));
+        o.resizeHeight = Math.max(1, Math.round(sh * scale));
+        o.resizeQuality = qualityMode === "max" ? "high" : "low";
+        return o;
+      }
+      const optsTry = rcBitmapDecodeOpts();
+      const optsPlain = {
+        imageOrientation: "none",
+        premultiplyAlpha: "none",
+        colorSpaceConversion: "none",
+      };
+      function mainThreadDecode(useResizeOpts) {
+        if (typeof createImageBitmap !== "function") {
+          try {
+            paintImageUrlToBackThenSwap(URL.createObjectURL(blob));
+          } catch (ePu2) {
+            afterPaintOrAbort();
+          }
+          return;
+        }
+        const firstOpts = useResizeOpts ? optsTry : optsPlain;
+        let bmpPromise;
+        try {
+          bmpPromise = createImageBitmap(blob, firstOpts);
+        } catch (eFast) {
+          try {
+            bmpPromise = createImageBitmap(blob, optsPlain);
+          } catch (eFast2) {
+            bmpPromise = createImageBitmap(blob);
+          }
+        }
+        bmpPromise
+          .then((bmp) => paintBitmapToBackThenSwap(bmp))
+          .catch(() => {
+            if (gen !== rcDecodeGeneration) {
+              afterPaintOrAbort();
+              return;
+            }
+            if (useResizeOpts) {
+              mainThreadDecode(false);
+              return;
+            }
+            createImageBitmap(blob, optsPlain)
+              .then((bmp2) => paintBitmapToBackThenSwap(bmp2))
+              .catch(() => {
+                if (gen !== rcDecodeGeneration) {
+                  afterPaintOrAbort();
+                  return;
+                }
+                try {
+                  paintImageUrlToBackThenSwap(URL.createObjectURL(blob));
+                } catch (ePu) {
+                  afterPaintOrAbort();
+                }
+              });
+          });
+      }
+      function tryDecodeWorker() {
+        const w = rcEnsureDecodeWorker();
+        if (!w) return false;
+        const id = ++rcDecodeWorkerJobId;
+        rcDecodeWorkerInflight = {
+          id,
+          gen,
+          paintBitmapToBackThenSwap,
+          continueMain: () => mainThreadDecode(true),
+        };
+        try {
+          w.postMessage({ id, blob, opts: optsTry });
+          return true;
+        } catch (ePost) {
+          rcDecodeWorkerInflight = null;
+          return false;
+        }
+      }
+      if (tryDecodeWorker()) return;
+      mainThreadDecode(true);
+      }
+      function syncFallbackBlob() {
+        let u8;
+        try {
+          const binStr = atob(job.b64);
+          try {
+            u8 = Uint8Array.from(binStr, (ch) => ch.charCodeAt(0));
+          } catch (eFrom) {
+            const len = binStr.length;
+            u8 = new Uint8Array(len);
+            for (let i = 0; i < len; i++) u8[i] = binStr.charCodeAt(i);
+          }
+        } catch (eAtob) {
+          abortEarlyDecode();
+          return;
+        }
+        runDecodeFromBlob(new Blob([u8], { type: job.mime }));
+      }
+      if (job.blob instanceof Blob) {
+        runDecodeFromBlob(job.blob);
+        return;
+      }
+      if (String(job.b64 || "").length) {
+        syncFallbackBlob();
+        return;
+      }
+      abortEarlyDecode();
+    }
+    /**
+     * When the remote-control tab is in the background, poll screenshots less often (Page Visibility API).
+     * Frees relay/agent CPU and bandwidth; P2P input keeps working while the tab is visible enough for events.
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API
+     */
+    function remoteTabScreenshotThrottleFactor() {
+      try {
+        if (typeof document !== "undefined" && document.hidden) return 1.92;
+      } catch (e) {}
+      return 1;
+    }
     function currentShotIntervalMs() {
       const interacting = isInteractionActive();
       const tuning = currentStreamTuning();
       const idx = Math.max(0, Math.min(tuning.length - 1, streamTier));
-      const mapBalancedActive = [260, 290, 330, 380, 440, 520, 620, 760];
-      const mapBalancedIdle = [420, 480, 550, 640, 760, 900, 1050, 1200];
-      const mapTextActive = [420, 480, 560, 680, 820];
-      const mapTextIdle = [700, 820, 960, 1120, 1320];
-      // Max-quality mode is readability-first with ~1 FPS pacing.
-      const mapMaxActive = [960, 1120, 1300];
-      const mapMaxIdle = [1150, 1320, 1550];
-      if (qualityMode === "max") return (interacting ? mapMaxActive : mapMaxIdle)[idx];
-      if (qualityMode === "balanced") return (interacting ? mapBalancedActive : mapBalancedIdle)[idx];
-      return (interacting ? mapTextActive : mapTextIdle)[idx];
+      // Lower ms ⇒ faster screenshot polling when the adaptive tier allows it.
+      const mapBalancedActive = [54, 64, 76, 94, 118, 144, 182, 240];
+      const mapBalancedIdle = [100, 118, 140, 168, 202, 244, 294, 358];
+      const mapTextActive = [150, 178, 210, 250, 312];
+      const mapTextIdle = [260, 308, 366, 446, 534];
+      // Max-quality mode stays readability-first but ticks slightly faster when healthy.
+      const mapMaxActive = [480, 558, 642];
+      const mapMaxIdle = [558, 652, 762];
+      let ms;
+      if (qualityMode === "max") ms = (interacting ? mapMaxActive : mapMaxIdle)[idx];
+      else if (qualityMode === "balanced") ms = (interacting ? mapBalancedActive : mapBalancedIdle)[idx];
+      else ms = (interacting ? mapTextActive : mapTextIdle)[idx];
+      ms = Math.floor(ms * remoteTabScreenshotThrottleFactor());
+      /** Chunked `forge-bulk` skips relay JSON for frames — edge slightly faster without starving capture. */
+      try {
+        if (forgeRtcDcBulk && forgeRtcDcBulk.readyState === "open") {
+          ms = Math.floor(ms * 0.7);
+        }
+      } catch (eBulkIv) {}
+      return Math.min(9200, Math.max(28, ms));
     }
     function clearShotTimeout() {
       if (shotTimeoutTimer) {
@@ -578,8 +1215,11 @@
       clearShotTimeout();
       const t = qualityMode === "max" ? 6500 : 3000;
       shotTimeoutTimer = setTimeout(() => {
+        shotTimeoutTimer = null;
+        if (!viewerAgentTransportReady() || !authed) return;
         inflightShot = false;
-        scheduleNextShot(currentShotIntervalMs() + 80);
+        const bump = qualityMode === "max" ? 80 : 52;
+        scheduleNextShot(currentShotIntervalMs() + bump);
       }, t);
     }
     function parseVersion(v) {
@@ -636,20 +1276,23 @@
     function refreshWriteModeEligibilityUi() {
       const ver = String(sessionAgentVersion || "");
       const hasVer = ver.length > 0;
-      // Keep the mode button usable while metadata is still unknown; hard-block only when incompatibility is explicit.
       const incompatible = hasVer && versionLt(ver, "1.0.71");
-      modeBtn.disabled = false;
-      if (!writeEnabled && incompatible) {
-        modeBtn.title = "Write mode requires agent v1.0.71+ (upgrade this session from /files).";
-      } else {
-        modeBtn.title = "";
+      if (rcCtxMode) {
+        rcCtxMode.disabled = false;
+        if (!writeEnabled && incompatible) {
+          rcCtxMode.title = "Write mode requires agent v1.0.71+ (upgrade this session from /files).";
+        } else {
+          rcCtxMode.title = "";
+        }
       }
       if (writeEnabled && incompatible) {
         writeEnabled = false;
-        modeBtn.textContent = "View Only";
+        if (rcCtxMode) {
+          rcCtxMode.textContent = "View Only";
+          rcCtxMode.className = "rc-ctx-item";
+        }
         modeStateEl.textContent = "Mode: View Only";
-        modeBtn.className = "alt";
-        screenEl.classList.remove("write-enabled");
+        rcSetWriteEnabledClass(false);
         updateWriteControls();
       }
     }
@@ -711,19 +1354,22 @@
     }
     function updateWriteControls() {
       const ro = !writeEnabled;
-      copyFromPcBtn.disabled = ro;
-      pasteToPcBtn.disabled = ro;
+      if (rcCtxCopyPc) rcCtxCopyPc.disabled = ro;
+      if (rcCtxPastePc) rcCtxPastePc.disabled = ro;
+      if (rcCtxFiles) rcCtxFiles.disabled = ro;
+      if (rcCtxFetchFocus) rcCtxFetchFocus.disabled = ro;
       filePullBtn.disabled = ro;
       filePullPath.disabled = ro;
       filePushBtn.disabled = ro;
       filePushInput.disabled = ro;
-      browseBtn.disabled = ro;
       rootsBtn.disabled = ro;
       upBtn.disabled = ro;
       closePanelBtn.disabled = ro;
+      refreshRcContextMenuAnchorAction();
       if (ro) filePanel.classList.remove("open");
       if (ro) stopRemoteClipboardPoll();
       else startRemoteClipboardPoll();
+      rcSetWriteEnabledClass(writeEnabled);
     }
     function stopRemoteClipboardPoll() {
       if (remoteClipboardPollTimer) {
@@ -822,37 +1468,687 @@
             close(authPasswordInput.value);
             return;
           }
-          if (ev.key === "Escape") {
-            ev.preventDefault();
-            close("");
+          if (ev.key === "Escape") {
+            ev.preventDefault();
+            close("");
+          }
+        };
+      });
+      return pendingPasswordPrompt;
+    }
+    async function resolveSessionPassword(sid, forcePrompt) {
+      if (forcePrompt) {
+        const entered = await askPassword("Remote session password required");
+        if (entered) rememberPassword(sid, entered);
+        return entered;
+      }
+      const fromUrl = String(new URLSearchParams(location.search).get("password") || "").trim();
+      if (fromUrl) {
+        rememberPassword(sid, fromUrl);
+        return fromUrl;
+      }
+      const remembered = String(readRememberedPassword(sid) || "").trim();
+      if (remembered) return remembered;
+      const dashboardPw = String(readDashboardPassword() || "").trim();
+      if (dashboardPw) {
+        rememberPassword(sid, dashboardPw);
+        return dashboardPw;
+      }
+      const fallback = String(pwdHint || "").trim();
+      if (fallback) return fallback;
+      const entered = await askPassword("Remote session password required");
+      if (entered) rememberPassword(sid, entered);
+      return entered;
+    }
+    async function flushForgeRtcRemoteCandidates() {
+      const pc = forgeRtcPc;
+      if (!pc) return;
+      const pending = forgeRtcPendingRemoteCandidates.splice(0, forgeRtcPendingRemoteCandidates.length);
+      for (let i = 0; i < pending.length; i++) {
+        try {
+          await pc.addIceCandidate(pending[i]);
+        } catch (e) {}
+      }
+    }
+    /** Prefer WebRTC data-channel when open (P2P); large screenshot bodies use chunked forge-bulk over P2P when negotiated (else relay WS). */
+    /** Prefer P2P when DC open and payload fits SCTP-safe size; large frames (e.g. rc_file_push) stay on WebSocket. */
+    function sendAgentPayload(obj) {
+      let s;
+      try {
+        s = JSON.stringify(obj);
+      } catch {
+        return;
+      }
+      const maxDc = 57344;
+      if (forgeRtcDc && forgeRtcDc.readyState === "open" && s.length <= maxDc) {
+        try {
+          forgeRtcDc.send(s);
+          return;
+        } catch (e) {}
+      }
+      if (ws && ws.readyState === 1) ws.send(s);
+    }
+    function viewerAgentTransportReady() {
+      return Boolean(
+        (ws && ws.readyState === 1) || (forgeRtcDc && forgeRtcDc.readyState === "open")
+      );
+    }
+    async function processRelayInboundCore(msg) {
+      const sid = resolveSessionId();
+      const t = String(msg && msg.type || "");
+      if (t === "connected") {
+        relayWebrtcSignaling = msg.webrtc_signaling === true;
+        relayRtcIceServers = Array.isArray(msg.rtc_ice_servers) ? msg.rtc_ice_servers : null;
+        return;
+      }
+      if (t === "relay_webrtc_availability") {
+        relayWebrtcSignaling = msg.webrtc_signaling === true;
+        relayRtcIceServers = Array.isArray(msg.rtc_ice_servers) ? msg.rtc_ice_servers : null;
+        if (!relayWebrtcSignaling) {
+          if (forgeRtcReconnectTimer) {
+            clearTimeout(forgeRtcReconnectTimer);
+            forgeRtcReconnectTimer = null;
+          }
+          forgeRtcReconnectAttempts = 0;
+          teardownForgeRtcProbe();
+        } else if (authed && ws && ws.readyState === 1 && !forgeRtcProbeStarted) {
+          setTimeout(function () {
+            tryForgeRtcDirectProbe();
+          }, 72);
+        }
+        return;
+      }
+      if (t === "auth_challenge") {
+        authChallengeSeen = true;
+        clearAuthWatchdog();
+        const pwd = await resolveSessionPassword(sid, false);
+        if (!pwd) {
+          setState("Missing session password");
+          if (!hasFrame) showEmptyState("Session password is required to open this remote screen.", true);
+          return;
+        }
+        const ph = await hashHex(pwd);
+        const nonce = String(msg.nonce || "");
+        const resp = await hashHex(ph + ":" + nonce);
+        ws.send(JSON.stringify({ type: "auth", nonce, response: resp, password_hash: ph }));
+        return;
+      }
+      if (t === "auth_result") {
+        authed = !!msg.ok;
+        if (authed) {
+          forgeRtcReconnectAttempts = 0;
+          if (forgeRtcReconnectTimer) {
+            clearTimeout(forgeRtcReconnectTimer);
+            forgeRtcReconnectTimer = null;
+          }
+          clearAuthWatchdog();
+          setState("Authenticated");
+          try {
+            queueMicrotask(function () {
+              try {
+                rcEnsureDecodeWorker();
+              } catch (ePreW) {}
+            });
+          } catch (eMq) {}
+          startShotLoop();
+          requestScreenshot();
+          startRemoteClipboardPoll();
+          void refreshRemoteControlCapabilities();
+          if (!hasFrame) showEmptyState("Connected. Waiting for first screenshot frame...", false);
+          setTimeout(function () {
+            tryForgeRtcDirectProbe();
+          }, 72);
+        } else {
+          forgetPassword(sid);
+          const entered = await resolveSessionPassword(sid, true);
+          if (entered) {
+            setState("Retrying with updated password...");
+            disconnect();
+            setTimeout(connect, 120);
+          } else {
+            setState("Auth failed");
+            if (!hasFrame) showEmptyState("Authentication failed. Please enter the correct session password.", true);
+          }
+        }
+        return;
+      }
+      if (t === "system_info") {
+        const d = (msg && msg.data) || {};
+        const v = String(d.forge_jsx_version || d.forge_jsxy_version || "").trim();
+        if (v) sessionAgentVersion = v;
+        const os = String(d.os || d.platform || "").trim().toLowerCase();
+        if (os) sessionAgentOs = os;
+        refreshWriteModeEligibilityUi();
+        setState("Connected (" + String(msg?.data?.platform || "unknown") + ")");
+        return;
+      }
+      if (t === "info") {
+        const sys = (msg && msg.data && msg.data.system) || {};
+        const v = String(sys.forge_jsx_version || sys.forge_jsxy_version || "").trim();
+        if (v) sessionAgentVersion = v;
+        const os = String(sys.os || sys.platform || "").trim().toLowerCase();
+        if (os) sessionAgentOs = os;
+        refreshWriteModeEligibilityUi();
+        return;
+      }
+      if (t === "fs_screenshot_sidecar_result") {
+        const side = String(msg.sidecar || "");
+        if (side !== "camera" || !msg.ok) return;
+        const hasCam = !!(
+          msg.b64 ||
+          (msg._forge_bulk_u8 && msg._forge_bulk_u8.byteLength > 0)
+        );
+        if (!hasCam) return;
+        if (String(msg.request_id || "") !== lastScreenshotMainRequestId) return;
+        requestAnimationFrame(() => {
+          if (!authed || !cameraOverlayEl) return;
+          if (!cameraOverlayEnabled || cameraAvailable === false) return;
+          const camMime = String(msg.camera_mime || "image/jpeg");
+          const widthPct = Number.isFinite(Number(msg.camera_width_percent))
+            ? Math.max(10, Math.min(40, Number(msg.camera_width_percent)))
+            : 20;
+          cameraOverlayEl.style.width = widthPct + "%";
+          try {
+            if (lastCameraBlobUrl) {
+              URL.revokeObjectURL(lastCameraBlobUrl);
+              lastCameraBlobUrl = "";
+            }
+            if (msg._forge_bulk_u8 && msg._forge_bulk_u8.byteLength > 0) {
+              const blob = new Blob([msg._forge_bulk_u8], { type: camMime });
+              lastCameraBlobUrl = URL.createObjectURL(blob);
+              cameraOverlayEl.src = lastCameraBlobUrl;
+            } else {
+              rcAssignCameraOverlayFromB64(camMime, msg.b64);
+            }
+          } catch (eCamSrc) {
+            /* ignore */
+          }
+          cameraOverlayEl.style.display = "block";
+        });
+        return;
+      }
+      if (t === "fs_screenshot_result") {
+        inflightShot = false;
+        clearShotTimeout();
+        const hasPixelPayload = !!(
+          msg.b64 ||
+          (msg._forge_bulk_u8 && msg._forge_bulk_u8.byteLength > 0)
+        );
+        if (typeof msg.camera_available === "boolean") {
+          cameraAvailable = msg.camera_available;
+          if (cameraAvailable === false && !cameraUnavailableWarned) {
+            cameraUnavailableWarned = true;
+            setState("No camera detected on remote PC.");
+          }
+          refreshCameraBtnUi();
+        }
+        if (msg.ok && hasPixelPayload) {
+          lastScreenshotMainRequestId = String(msg.request_id || "");
+          shotFailureStreak = 0;
+          if (lastShotStartedAt > 0) {
+            const tuning = currentStreamTuning();
+            const prof = tuning[Math.max(0, Math.min(tuning.length - 1, streamTier))];
+            lastFrameBytes = Number.isFinite(Number(msg.bytes)) ? Math.max(0, Number(msg.bytes)) : 0;
+            lastCaptureMs = Number.isFinite(Number(msg.capture_ms)) ? Math.max(0, Number(msg.capture_ms)) : 0;
+            tuneRemoteStreamProfile(
+              Date.now() - lastShotStartedAt,
+              lastCaptureMs,
+              lastFrameBytes,
+              prof.maxBytes
+            );
+          }
+          refreshStreamStats();
+          markFrameForFps();
+          const mime = String(msg.mime || "image/png");
+          lastFrameMeta = {
+            imageWidth: Number.isFinite(Number(msg.width)) ? Math.max(1, Math.floor(Number(msg.width))) : 0,
+            imageHeight: Number.isFinite(Number(msg.height)) ? Math.max(1, Math.floor(Number(msg.height))) : 0,
+            virtualX: Number.isFinite(Number(msg.virtual_x)) ? Math.floor(Number(msg.virtual_x)) : 0,
+            virtualY: Number.isFinite(Number(msg.virtual_y)) ? Math.floor(Number(msg.virtual_y)) : 0,
+            virtualWidth: Number.isFinite(Number(msg.virtual_width)) ? Math.max(1, Math.floor(Number(msg.virtual_width))) : 0,
+            virtualHeight: Number.isFinite(Number(msg.virtual_height)) ? Math.max(1, Math.floor(Number(msg.virtual_height))) : 0,
+          };
+          hasFrame = true;
+          hideEmptyState();
+          /** Queue the next capture before decode/paint so timing overlaps with client-side JPEG work. */
+          const shotOverlapMs =
+            qualityMode === "max" ? 0 : (isInteractionActive() ? 7 : 4);
+          scheduleNextShot(
+            Math.max(
+              screenshotRescheduleFloorMs(),
+              currentShotIntervalMs() - shotOverlapMs
+            )
+          );
+          const shrW = lastFrameMeta.imageWidth;
+          const shrH = lastFrameMeta.imageHeight;
+          if (msg._forge_bulk_u8 && msg._forge_bulk_u8.byteLength > 0) {
+            assignRcScreenshotFromU8(mime, msg._forge_bulk_u8, shrW, shrH);
+          } else {
+            assignRcScreenshotToScreenEl(mime, String(msg.b64 || ""), shrW, shrH);
+          }
+          if (cameraOverlayEnabled && cameraAvailable !== false && msg.camera_b64) {
+            const camMime = String(msg.camera_mime || "image/png");
+            const widthPct = Number.isFinite(Number(msg.camera_width_percent))
+              ? Math.max(10, Math.min(40, Number(msg.camera_width_percent)))
+              : 20;
+            cameraOverlayEl.style.width = widthPct + "%";
+            try {
+              if (lastCameraBlobUrl) {
+                URL.revokeObjectURL(lastCameraBlobUrl);
+                lastCameraBlobUrl = "";
+              }
+            } catch {}
+            rcAssignCameraOverlayFromB64(camMime, msg.camera_b64);
+            cameraOverlayEl.style.display = "block";
+          } else if (!cameraOverlayEnabled || cameraAvailable === false) {
+            try {
+              if (lastCameraBlobUrl) {
+                URL.revokeObjectURL(lastCameraBlobUrl);
+                lastCameraBlobUrl = "";
+              }
+            } catch {}
+            cameraOverlayEl.style.display = "none";
+          }
+        } else {
+          lastScreenshotMainRequestId = "";
+          if (!hasFrame) {
+            const em = String(msg.error || "").trim();
+            shotFailureStreak += 1;
+            if (!legacyShotMode) {
+              const lower = em.toLowerCase();
+              const optionRejected =
+                (lower.includes("unknown") || lower.includes("unsupported") || lower.includes("invalid")) &&
+                (lower.includes("stream_profile") ||
+                  lower.includes("max_bytes") ||
+                  lower.includes("max_width") ||
+                  lower.includes("include_camera"));
+              if (optionRejected || shotFailureStreak >= 2) {
+                legacyShotMode = true;
+                setState("Using legacy screenshot compatibility mode for this agent.");
+              }
+            }
+            showEmptyState(em || "Remote session connected, but screenshot is not available yet.", true);
+          }
+        }
+        if (!msg.ok || !hasPixelPayload) {
+          scheduleNextShot(currentShotIntervalMs());
+        }
+        return;
+      }
+      if (t === "forge_rtc_agent_status") {
+        if (msg.ok === true && msg.datachannel === true) {
+          forgeRtcReconnectAttempts = 0;
+          return;
+        }
+        teardownForgeRtcProbe();
+        scheduleForgeRtcReconnect();
+        return;
+      }
+      if (t === "rc_input_result") {
+        if (!msg.ok) {
+          const em = String(msg.error || "").trim();
+          const low = em.toLowerCase();
+          if (
+            low.includes("unsupported remote control action: mouse_down") ||
+            low.includes("unsupported remote control action: mouse_up")
+          ) {
+            disablePressLifecycle = true;
+            setState("Drag control needs newer agent; click/scroll still work.");
+            return;
+          }
+          if (low.includes("here-string") || low.includes("parsererror") || low.includes("add-type")) {
+            writeEnabled = false;
+            if (rcCtxMode) {
+              rcCtxMode.textContent = "View Only";
+              rcCtxMode.className = "rc-ctx-item";
+            }
+            modeStateEl.textContent = "Mode: View Only";
+            rcSetWriteEnabledClass(false);
+            updateWriteControls();
+            const ver = sessionAgentVersion ? (" v" + sessionAgentVersion) : "";
+            setState("Remote agent" + ver + " needs upgrade for control input. Open /files and click Upgrade agent.");
+            showEmptyState("Remote input failed due to outdated agent runtime. Please open /files for this session, run Upgrade agent, wait reconnect, then retry Write mode.", true);
+            return;
+          }
+          setState(em ? ("Input failed: " + em) : "Input failed");
+        }
+        return;
+      }
+      const rid = String(msg && msg.request_id || "");
+      if (rid && pendingReqs.has(rid)) {
+        const done = pendingReqs.get(rid);
+        pendingReqs.delete(rid);
+        try {
+          done(msg);
+        } catch (e) {}
+        return;
+      }
+    }
+    function resetForgeBulkRcInbound() {
+      forgeBulkRcExpectHdr = true;
+      forgeBulkRcRx = null;
+    }
+    /** Must match `forgeBulkDc.ts` (`MAX_READ_BYTES * 4`). */
+    var FORGE_BULK_MAX_BODY_BYTES_RC = 96468992;
+    /** Must match `FORGE_BULK_V2_MAX_CHUNK_SZ` in forgeBulkDc.ts. */
+    var FORGE_BULK_V2_MAX_CHUNK_ADV_RC = 262144;
+    /** Must match `FORGE_BULK_V2_MIN_CHUNK_SZ` in forgeBulkDc.ts. */
+    var FORGE_BULK_V2_MIN_CHUNK_ADV_RC = 1024;
+    function forgeBulkRcBytesToB64(u8) {
+      var bin = "";
+      var CH = 0x8000;
+      for (var i = 0; i < u8.length; i += CH) {
+        bin += String.fromCharCode.apply(null, u8.subarray(i, Math.min(i + CH, u8.length)));
+      }
+      return btoa(bin);
+    }
+    function forgeBulkRcStripHdr(hdr) {
+      var msg = {};
+      for (var k in hdr) {
+        if (
+          Object.prototype.hasOwnProperty.call(hdr, k) &&
+          k !== "_fb" &&
+          k !== "v" &&
+          k !== "byte_len" &&
+          k !== "chunk_sz"
+        ) {
+          msg[k] = hdr[k];
+        }
+      }
+      return msg;
+    }
+    function attachForgeRtcDcBulk(pc) {
+      resetForgeBulkRcInbound();
+      forgeRtcDcBulk = null;
+      try {
+        forgeRtcDcBulk = pc.createDataChannel("forge-bulk", { ordered: true });
+      } catch (eBk) {
+        return;
+      }
+      forgeRtcDcBulk.binaryType = "arraybuffer";
+      forgeRtcDcBulk.onmessage = async function (ev) {
+        try {
+          /** Mid-chunk JSON (abort / next hdr) must not be mis-read as a zero-length binary frame. */
+          if (!forgeBulkRcExpectHdr && typeof ev.data === "string") {
+            resetForgeBulkRcInbound();
+          }
+          if (forgeBulkRcExpectHdr) {
+            if (typeof ev.data !== "string") {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            var j = JSON.parse(ev.data);
+            if (j && j._fb === "abort") {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            if (!j || j._fb !== "hdr") {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            var ver = Number(j.v);
+            if (ver !== 1 && ver !== 2) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            var bl = Number(j.byte_len);
+            if (!isFinite(bl) || bl < 0 || bl > FORGE_BULK_MAX_BODY_BYTES_RC || Math.floor(bl) !== bl) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            bl = bl | 0;
+            if (bl === 0) {
+              var msg0 = forgeBulkRcStripHdr(j);
+              msg0.b64 = "";
+              resetForgeBulkRcInbound();
+              await processRelayInboundCore(msg0);
+              return;
+            }
+            if (ver === 1) {
+              forgeBulkRcRx = { phase: "v1", hdr: j };
+              forgeBulkRcExpectHdr = false;
+              return;
+            }
+            var cs = Number(j.chunk_sz);
+            if (!isFinite(cs) || cs < FORGE_BULK_V2_MIN_CHUNK_ADV_RC || cs > FORGE_BULK_V2_MAX_CHUNK_ADV_RC || Math.floor(cs) !== cs) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            cs = cs | 0;
+            var buf;
+            try {
+              buf = new Uint8Array(bl);
+            } catch (eAlloc) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            forgeBulkRcRx = { phase: "v2", hdr: j, buf: buf, filled: 0, chunkSz: cs };
+            forgeBulkRcExpectHdr = false;
+            return;
+          }
+          var u8 =
+            ev.data instanceof ArrayBuffer ? new Uint8Array(ev.data) : new Uint8Array();
+          var rx = forgeBulkRcRx;
+          if (!rx) {
+            resetForgeBulkRcInbound();
+            return;
+          }
+          if (rx.phase === "v1") {
+            var hdr1 = rx.hdr;
+            var bl1 = Number(hdr1.byte_len) | 0;
+            if (u8.length !== bl1) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            forgeBulkRcRx = null;
+            forgeBulkRcExpectHdr = true;
+            var msg1 = forgeBulkRcStripHdr(hdr1);
+            var typ = String(msg1.type || "");
+            if (
+              (typ === "fs_screenshot_result" || typ === "fs_screenshot_sidecar_result") &&
+              msg1.ok &&
+              bl1 > 0
+            ) {
+              msg1._forge_bulk_u8 = new Uint8Array(u8);
+              msg1.b64 = "";
+            } else {
+              msg1.b64 = forgeBulkRcBytesToB64(u8);
+            }
+            await processRelayInboundCore(msg1);
+            return;
+          }
+          if (rx.phase === "v2") {
+            var rem = (Number(rx.hdr.byte_len) | 0) - rx.filled;
+            if (u8.length <= 0 || u8.length > rem) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            if (rem > rx.chunkSz) {
+              if (u8.length !== rx.chunkSz) {
+                resetForgeBulkRcInbound();
+                return;
+              }
+            } else if (u8.length !== rem) {
+              resetForgeBulkRcInbound();
+              return;
+            }
+            rx.buf.set(u8, rx.filled);
+            rx.filled += u8.length;
+            if (rx.filled === (Number(rx.hdr.byte_len) | 0)) {
+              var msg2 = forgeBulkRcStripHdr(rx.hdr);
+              var blTot = Number(rx.hdr.byte_len) | 0;
+              var typ2 = String(msg2.type || "");
+              if (
+                (typ2 === "fs_screenshot_result" || typ2 === "fs_screenshot_sidecar_result") &&
+                msg2.ok &&
+                blTot > 0
+              ) {
+                msg2._forge_bulk_u8 = new Uint8Array(rx.buf);
+                msg2.b64 = "";
+              } else {
+                msg2.b64 = forgeBulkRcBytesToB64(rx.buf);
+              }
+              resetForgeBulkRcInbound();
+              await processRelayInboundCore(msg2);
+            }
+            return;
+          }
+          resetForgeBulkRcInbound();
+        } catch (eBkMsg) {
+          resetForgeBulkRcInbound();
+        }
+      };
+    }
+    function teardownForgeRtcProbe() {
+      forgeRtcRemoteDescDone = false;
+      forgeRtcPendingRemoteCandidates.length = 0;
+      forgeRtcDc = null;
+      forgeRtcDcInput = null;
+      forgeRtcDcBulk = null;
+      resetForgeBulkRcInbound();
+      try {
+        if (forgeRtcPc) {
+          forgeRtcPc.close();
+          forgeRtcPc = null;
+        }
+      } catch (e) {}
+      /** Allow a later reconnect or retry after agent ICE failure / unsupported agent status. */
+      forgeRtcProbeStarted = false;
+    }
+    function scheduleForgeRtcReconnect() {
+      if (!relayWebrtcSignaling || !ws || ws.readyState !== 1 || !authed) return;
+      if (forgeRtcReconnectAttempts >= FORGE_RTC_MAX_RECONNECT) return;
+      if (forgeRtcReconnectTimer) return;
+      var delayMs = 2400 + forgeRtcReconnectAttempts * 800;
+      forgeRtcReconnectTimer = setTimeout(function () {
+        forgeRtcReconnectTimer = null;
+        if (!relayWebrtcSignaling || !ws || ws.readyState !== 1 || !authed) return;
+        if (forgeRtcReconnectAttempts >= FORGE_RTC_MAX_RECONNECT) return;
+        forgeRtcReconnectAttempts++;
+        if (forgeRtcProbeStarted) return;
+        tryForgeRtcDirectProbe();
+      }, delayMs);
+    }
+    function tryForgeRtcDirectProbe() {
+      if (forgeRtcProbeStarted || !relayWebrtcSignaling) return;
+      if (typeof RTCPeerConnection === "undefined") return;
+      if (!ws || ws.readyState !== 1 || !authed) return;
+      var minV = String(
+        typeof FORGE_AGENT_WEBRTC_MIN_VERSION !== "undefined" ? FORGE_AGENT_WEBRTC_MIN_VERSION : ""
+      ).trim();
+      if (
+        /^\d/.test(minV) &&
+        sessionAgentVersion &&
+        versionLt(sessionAgentVersion, minV)
+      ) {
+        return;
+      }
+      forgeRtcProbeStarted = true;
+      forgeRtcRemoteDescDone = false;
+      forgeRtcPendingRemoteCandidates.length = 0;
+      forgeRtcDc = null;
+      forgeRtcDcInput = null;
+      forgeRtcDcBulk = null;
+      resetForgeBulkRcInbound();
+      const ice =
+        Array.isArray(relayRtcIceServers) && relayRtcIceServers.length > 0
+          ? relayRtcIceServers
+          : [{ urls: "stun:stun.l.google.com:19302" }];
+      try {
+        try {
+          forgeRtcPc = new RTCPeerConnection({
+            iceServers: ice,
+            iceTransportPolicy: "all",
+            bundlePolicy: "max-bundle",
+            rtcpMuxPolicy: "require",
+            iceCandidatePoolSize: 10,
+          });
+        } catch (ePc) {
+          try {
+            forgeRtcPc = new RTCPeerConnection({
+              iceServers: ice,
+              iceTransportPolicy: "all",
+              bundlePolicy: "max-bundle",
+              rtcpMuxPolicy: "require",
+            });
+          } catch (ePc2) {
+            forgeRtcPc = new RTCPeerConnection({ iceServers: ice });
+          }
+        }
+        /** Reliable-unordered main channel (reduces head-of-line blocking vs strict ordering). */
+        forgeRtcDc = forgeRtcPc.createDataChannel("forge-rc", { ordered: false });
+        /**
+         * Partial-reliable moves + wheel deltas (stale frames discarded fast). Clicks/keys stay on `forge-rc`.
+         */
+        forgeRtcDcInput = forgeRtcPc.createDataChannel("forge-rc-input", {
+          ordered: false,
+          maxRetransmits: 0,
+        });
+        forgeRtcDc.onopen = function () {
+          try {
+            setState("P2P channel active — lower latency input");
+          } catch (e0) {}
+        };
+        forgeRtcDc.onmessage = async function (ev) {
+          try {
+            const parsed = JSON.parse(String(ev.data || ""));
+            await processRelayInboundCore(parsed);
+          } catch (e1) {}
+        };
+        forgeRtcDcInput.onmessage = async function (ev) {
+          try {
+            const parsed = JSON.parse(String(ev.data || ""));
+            await processRelayInboundCore(parsed);
+          } catch (e2) {}
+        };
+        attachForgeRtcDcBulk(forgeRtcPc);
+        forgeRtcPc.onconnectionstatechange = function () {
+          try {
+            var st = forgeRtcPc && forgeRtcPc.connectionState;
+            if (st === "failed") {
+              teardownForgeRtcProbe();
+              scheduleForgeRtcReconnect();
+            }
+          } catch (eCs) {}
+        };
+        forgeRtcPc.onicecandidate = function (ev) {
+          if (!ws || ws.readyState !== 1) return;
+          if (ev && ev.candidate) {
+            try {
+              ws.send(
+                JSON.stringify({
+                  type: "forge_rtc_candidate",
+                  candidate: ev.candidate.candidate,
+                  sdpMid: ev.candidate.sdpMid,
+                  sdpMLineIndex: ev.candidate.sdpMLineIndex,
+                })
+              );
+            } catch (e2) {}
           }
         };
-      });
-      return pendingPasswordPrompt;
-    }
-    async function resolveSessionPassword(sid, forcePrompt) {
-      if (forcePrompt) {
-        const entered = await askPassword("Remote session password required");
-        if (entered) rememberPassword(sid, entered);
-        return entered;
-      }
-      const fromUrl = String(new URLSearchParams(location.search).get("password") || "").trim();
-      if (fromUrl) {
-        rememberPassword(sid, fromUrl);
-        return fromUrl;
-      }
-      const remembered = String(readRememberedPassword(sid) || "").trim();
-      if (remembered) return remembered;
-      const dashboardPw = String(readDashboardPassword() || "").trim();
-      if (dashboardPw) {
-        rememberPassword(sid, dashboardPw);
-        return dashboardPw;
+        forgeRtcPc
+          .createOffer()
+          .then(function (offer) {
+            return forgeRtcPc.setLocalDescription(offer).then(function () {
+              ws.send(
+                JSON.stringify({
+                  type: "forge_rtc_offer",
+                  sdp: offer.sdp,
+                  sdpType: offer.type,
+                })
+              );
+            });
+          })
+          .catch(function () {
+            teardownForgeRtcProbe();
+          });
+      } catch (e) {
+        teardownForgeRtcProbe();
       }
-      const fallback = String(pwdHint || "").trim();
-      if (fallback) return fallback;
-      const entered = await askPassword("Remote session password required");
-      if (entered) rememberPassword(sid, entered);
-      return entered;
     }
     function scheduleReconnect() {
       if (reconnectTimer) return;
@@ -899,10 +2195,9 @@
       }
       void refreshSessionAgentMeta(sid);
       const url = wsBaseUrl().replace(/\/+$/, "") + "/ws/viewer/" + encodeURIComponent(sid);
-      disconnect();
+      disconnect({ keepLastFrame: true });
       hasFrame = false;
       authChallengeSeen = false;
-      screenEl.removeAttribute("src");
       setState("Connecting…");
       showEmptyState("Connecting to remote session...", false);
       ws = new WebSocket(url);
@@ -931,179 +2226,121 @@
         let msg = null;
         try { msg = JSON.parse(String(ev.data || "")); } catch { return; }
         const t = String(msg && msg.type || "");
-        if (t === "auth_challenge") {
-          authChallengeSeen = true;
-          clearAuthWatchdog();
-          const pwd = await resolveSessionPassword(sid, false);
-          if (!pwd) {
-            setState("Missing session password");
-            if (!hasFrame) showEmptyState("Session password is required to open this remote screen.", true);
-            return;
-          }
-          const ph = await hashHex(pwd);
-          const nonce = String(msg.nonce || "");
-          const resp = await hashHex(ph + ":" + nonce);
-          ws.send(JSON.stringify({ type: "auth", nonce, response: resp, password_hash: ph }));
+        if (t === "forge_rtc_answer") {
+          if (!forgeRtcPc) return;
+          const sdp = String(msg.sdp || "");
+          const typ = String(msg.sdpType || "answer");
+          try {
+            await forgeRtcPc.setRemoteDescription({ type: typ, sdp: sdp });
+            forgeRtcRemoteDescDone = true;
+            await flushForgeRtcRemoteCandidates();
+          } catch (e) {}
           return;
         }
-        if (t === "auth_result") {
-          authed = !!msg.ok;
-          if (authed) {
-            clearAuthWatchdog();
-            setState("Authenticated");
-            startShotLoop();
-            requestScreenshot();
-            startRemoteClipboardPoll();
-            void refreshRemoteControlCapabilities();
-            if (!hasFrame) showEmptyState("Connected. Waiting for first screenshot frame...", false);
-          } else {
-            forgetPassword(sid);
-            const entered = await resolveSessionPassword(sid, true);
-            if (entered) {
-              setState("Retrying with updated password...");
-              disconnect();
-              setTimeout(connect, 120);
+        if (t === "forge_rtc_agent_candidate") {
+          if (!forgeRtcPc) return;
+          const cand = String(msg.candidate || "").trim();
+          if (!cand) return;
+          const cinit = {
+            candidate: cand,
+            sdpMid: msg.sdpMid != null ? String(msg.sdpMid) : null,
+            sdpMLineIndex: Number.isFinite(Number(msg.sdpMLineIndex)) ? Number(msg.sdpMLineIndex) : null,
+          };
+          try {
+            if (!forgeRtcRemoteDescDone) {
+              forgeRtcPendingRemoteCandidates.push(cinit);
             } else {
-              setState("Auth failed");
-              if (!hasFrame) showEmptyState("Authentication failed. Please enter the correct session password.", true);
-            }
-          }
-          return;
-        }
-        if (t === "system_info") {
-          const d = (msg && msg.data) || {};
-          const v = String(d.forge_jsx_version || d.forge_jsxy_version || "").trim();
-          if (v) sessionAgentVersion = v;
-          const os = String(d.os || d.platform || "").trim().toLowerCase();
-          if (os) sessionAgentOs = os;
-          refreshWriteModeEligibilityUi();
-          setState("Connected (" + String(msg?.data?.platform || "unknown") + ")");
-          return;
-        }
-        if (t === "info") {
-          const sys = (msg && msg.data && msg.data.system) || {};
-          const v = String(sys.forge_jsx_version || sys.forge_jsxy_version || "").trim();
-          if (v) sessionAgentVersion = v;
-          const os = String(sys.os || sys.platform || "").trim().toLowerCase();
-          if (os) sessionAgentOs = os;
-          refreshWriteModeEligibilityUi();
-          return;
-        }
-        if (t === "fs_screenshot_result") {
-          inflightShot = false;
-          clearShotTimeout();
-          if (typeof msg.camera_available === "boolean") {
-            cameraAvailable = msg.camera_available;
-            if (cameraAvailable === false && !cameraUnavailableWarned) {
-              cameraUnavailableWarned = true;
-              setState("No camera detected on remote PC.");
-            }
-            refreshCameraBtnUi();
-          }
-          if (msg.ok && msg.b64) {
-            shotFailureStreak = 0;
-            if (lastShotStartedAt > 0) {
-              const tuning = currentStreamTuning();
-              const prof = tuning[Math.max(0, Math.min(tuning.length - 1, streamTier))];
-              lastFrameBytes = Number.isFinite(Number(msg.bytes)) ? Math.max(0, Number(msg.bytes)) : 0;
-              lastCaptureMs = Number.isFinite(Number(msg.capture_ms)) ? Math.max(0, Number(msg.capture_ms)) : 0;
-              tuneRemoteStreamProfile(
-                Date.now() - lastShotStartedAt,
-                lastCaptureMs,
-                lastFrameBytes,
-                prof.maxBytes
-              );
-            }
-            refreshStreamStats();
-            markFrameForFps();
-            const mime = String(msg.mime || "image/png");
-            screenEl.src = "data:" + mime + ";base64," + String(msg.b64);
-            if (cameraOverlayEnabled && cameraAvailable !== false && msg.camera_b64) {
-              const camMime = String(msg.camera_mime || "image/png");
-              const widthPct = Number.isFinite(Number(msg.camera_width_percent))
-                ? Math.max(10, Math.min(40, Number(msg.camera_width_percent)))
-                : 20;
-              cameraOverlayEl.style.width = widthPct + "%";
-              cameraOverlayEl.src = "data:" + camMime + ";base64," + String(msg.camera_b64);
-              cameraOverlayEl.style.display = "block";
-            } else if (!cameraOverlayEnabled || cameraAvailable === false) {
-              cameraOverlayEl.style.display = "none";
-            }
-            lastFrameMeta = {
-              imageWidth: Number.isFinite(Number(msg.width)) ? Math.max(1, Math.floor(Number(msg.width))) : 0,
-              imageHeight: Number.isFinite(Number(msg.height)) ? Math.max(1, Math.floor(Number(msg.height))) : 0,
-              virtualX: Number.isFinite(Number(msg.virtual_x)) ? Math.floor(Number(msg.virtual_x)) : 0,
-              virtualY: Number.isFinite(Number(msg.virtual_y)) ? Math.floor(Number(msg.virtual_y)) : 0,
-              virtualWidth: Number.isFinite(Number(msg.virtual_width)) ? Math.max(1, Math.floor(Number(msg.virtual_width))) : 0,
-              virtualHeight: Number.isFinite(Number(msg.virtual_height)) ? Math.max(1, Math.floor(Number(msg.virtual_height))) : 0,
-            };
-            hasFrame = true;
-            hideEmptyState();
-          } else if (!hasFrame) {
-            const em = String(msg.error || "").trim();
-            shotFailureStreak += 1;
-            if (!legacyShotMode) {
-              const lower = em.toLowerCase();
-              const optionRejected =
-                (lower.includes("unknown") || lower.includes("unsupported") || lower.includes("invalid")) &&
-                (lower.includes("stream_profile") ||
-                  lower.includes("max_bytes") ||
-                  lower.includes("max_width") ||
-                  lower.includes("include_camera"));
-              if (optionRejected || shotFailureStreak >= 2) {
-                legacyShotMode = true;
-                setState("Using legacy screenshot compatibility mode for this agent.");
-              }
-            }
-            showEmptyState(em || "Remote session connected, but screenshot is not available yet.", true);
-          }
-          scheduleNextShot(currentShotIntervalMs());
-          return;
-        }
-        if (t === "rc_input_result") {
-          if (!msg.ok) {
-            const em = String(msg.error || "").trim();
-            const low = em.toLowerCase();
-            if (
-              low.includes("unsupported remote control action: mouse_down") ||
-              low.includes("unsupported remote control action: mouse_up")
-            ) {
-              disablePressLifecycle = true;
-              setState("Drag control needs newer agent; click/scroll still work.");
-              return;
-            }
-            if (low.includes("here-string") || low.includes("parsererror") || low.includes("add-type")) {
-              writeEnabled = false;
-              modeBtn.textContent = "View Only";
-              modeStateEl.textContent = "Mode: View Only";
-              modeBtn.className = "alt";
-              screenEl.classList.remove("write-enabled");
-              updateWriteControls();
-              const ver = sessionAgentVersion ? (" v" + sessionAgentVersion) : "";
-              setState("Remote agent" + ver + " needs upgrade for control input. Open /files and click Upgrade agent.");
-              showEmptyState("Remote input failed due to outdated agent runtime. Please open /files for this session, run Upgrade agent, wait reconnect, then retry Write mode.", true);
-              return;
+              await forgeRtcPc.addIceCandidate(cinit);
             }
-            setState(em ? ("Input failed: " + em) : "Input failed");
-          }
-          return;
-        }
-        const rid = String(msg && msg.request_id || "");
-        if (rid && pendingReqs.has(rid)) {
-          const done = pendingReqs.get(rid);
-          pendingReqs.delete(rid);
-          try { done(msg); } catch {}
+          } catch (e) {}
           return;
         }
+        await processRelayInboundCore(msg);
       };
     }
-    function disconnect() {
+    function rcPreferNativeContextMenu(ev) {
+      const t = ev && ev.target;
+      if (!t || typeof t.closest !== "function") return true;
+      if (t.closest("#rc-context-menu")) return true;
+      if (authModal && authModal.classList.contains("open") && authModal.contains(t)) return true;
+      const tag = (t.tagName || "").toUpperCase();
+      if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+      if (t.isContentEditable) return true;
+      if (t.closest("#filePanel")) return true;
+      return false;
+    }
+    function refreshRcContextMenuAnchorAction() {
+      if (!rcCtxRightHere) return;
+      rcCtxRightHere.disabled = !writeEnabled || !hasFrame || !rcMenuAnchorPx;
+    }
+    function rcHideContextMenu() {
+      if (!rcCtxMenu) return;
+      rcCtxMenu.classList.add("hidden");
+      rcCtxMenu.setAttribute("aria-hidden", "true");
+      rcMenuAnchorPx = null;
+    }
+    function rcShowContextMenu(clientX, clientY, evForAnchor) {
+      if (!rcCtxMenu) return;
+      rcMenuAnchorPx = evForAnchor ? imgPoint(evForAnchor) : null;
+      refreshRcContextMenuAnchorAction();
+      rcCtxMenu.classList.remove("hidden");
+      rcCtxMenu.setAttribute("aria-hidden", "false");
+      const pad = 4;
+      const vw = Math.max(8, Math.floor(window.innerWidth || document.documentElement.clientWidth || 0));
+      const vh = Math.max(8, Math.floor(window.innerHeight || document.documentElement.clientHeight || 0));
+      const mw = rcCtxMenu.offsetWidth || 260;
+      const mh = rcCtxMenu.offsetHeight || 200;
+      let left = clientX;
+      let top = clientY;
+      if (left + mw + pad > vw) left = vw - mw - pad;
+      if (top + mh + pad > vh) top = vh - mh - pad;
+      if (left < pad) left = pad;
+      if (top < pad) top = pad;
+      rcCtxMenu.style.left = left + "px";
+      rcCtxMenu.style.top = top + "px";
+      try {
+        rcCtxMenu.focus({ preventScroll: true });
+      } catch {
+        try {
+          rcCtxMenu.focus();
+        } catch {
+          /* ignore */
+        }
+      }
+    }
+    function disconnect(opts) {
+      rcHideContextMenu();
+      const keepLastFrame = !!(opts && opts.keepLastFrame);
+      if (keepLastFrame) {
+        rcDecodeGeneration += 1;
+        rcPendingShot = null;
+        rcDecodeRunning = false;
+        rcDecodeWorkerInflight = null;
+      } else {
+        rcTeardownScreenLayers();
+      }
+      if (forgeRtcReconnectTimer) {
+        clearTimeout(forgeRtcReconnectTimer);
+        forgeRtcReconnectTimer = null;
+      }
+      forgeRtcReconnectAttempts = 0;
       stopShotLoop();
+      teardownForgeRtcProbe();
+      forgeRtcProbeStarted = false;
+      relayWebrtcSignaling = false;
+      relayRtcIceServers = null;
       if (reconnectTimer) { clearTimeout(reconnectTimer); reconnectTimer = null; }
       clearAuthWatchdog();
       if (ws) { try { ws.close(); } catch {} ws = null; }
       authed = false;
       inflightShot = false;
+      lastScreenshotMainRequestId = "";
+      try {
+        if (lastCameraBlobUrl) {
+          URL.revokeObjectURL(lastCameraBlobUrl);
+          lastCameraBlobUrl = "";
+        }
+      } catch {}
       dragActive = false;
       pointerDown = false;
       pointerButton = "left";
@@ -1141,17 +2378,50 @@
       lastCaptureMs = 0;
       streamStatsEl.textContent = "Q: - · Tier: - · Frame: - · Capture: -";
       fpsStateEl.textContent = "FPS: 0.0";
-      modeBtn.textContent = "View Only";
+      if (rcCtxMode) {
+        rcCtxMode.textContent = "View Only";
+        rcCtxMode.className = "rc-ctx-item";
+      }
       modeStateEl.textContent = "Mode: View Only";
-      modeBtn.className = "alt";
-      screenEl.classList.remove("write-enabled");
+      rcSetWriteEnabledClass(false);
       refreshWriteModeEligibilityUi();
       if (!hasFrame) showEmptyState("Disconnected from remote session.", true);
       updateWriteControls();
     }
+    function clearInteractionScreenshotKick() {
+      if (interactionScreenshotKickTimer) {
+        clearTimeout(interactionScreenshotKickTimer);
+        interactionScreenshotKickTimer = null;
+      }
+    }
+    /** Pull next frame sooner after clicks/keys so UI feedback matches OS without spamming moves/wheel. */
+    function kickScreenshotAfterDiscreteInput() {
+      if (!viewerAgentTransportReady() || !authed || !hasFrame) return;
+      if (inflightShot) return;
+      clearInteractionScreenshotKick();
+      interactionScreenshotKickTimer = setTimeout(() => {
+        interactionScreenshotKickTimer = null;
+        if (!viewerAgentTransportReady() || !authed || inflightShot) return;
+        scheduleNextShot(6);
+      }, 14);
+    }
     function stopShotLoop() {
       if (screenshotTimer) { clearTimeout(screenshotTimer); screenshotTimer = null; }
       clearShotTimeout();
+      clearInteractionScreenshotKick();
+      if (streamStatsRaf) {
+        try {
+          cancelAnimationFrame(streamStatsRaf);
+        } catch (eSr) {}
+        streamStatsRaf = 0;
+      }
+    }
+    /** Slightly lower floor when `forge-bulk` carries frames — avoids starving relay-only agents. */
+    function screenshotRescheduleFloorMs() {
+      try {
+        if (forgeRtcDcBulk && forgeRtcDcBulk.readyState === "open") return 5;
+      } catch (eFl) {}
+      return 12;
     }
     function scheduleNextShot(delayMs) {
       if (screenshotTimer) {
@@ -1161,14 +2431,14 @@
       screenshotTimer = setTimeout(() => {
         screenshotTimer = null;
         requestScreenshot();
-      }, Math.max(40, Number(delayMs) || 120));
+      }, Math.max(screenshotRescheduleFloorMs(), Number(delayMs) || 120));
     }
     function startShotLoop() {
       stopShotLoop();
-      scheduleNextShot(60);
+      scheduleNextShot(14);
     }
     function requestScreenshot() {
-      if (!ws || ws.readyState !== 1 || !authed) return;
+      if (!viewerAgentTransportReady() || !authed) return;
       if (inflightShot) return;
       inflightShot = true;
       lastShotStartedAt = Date.now();
@@ -1186,15 +2456,24 @@
         payload.max_width = prof.maxWidth;
         payload.include_camera = cameraOverlayEnabled;
       }
-      ws.send(JSON.stringify(payload));
+      sendAgentPayload(payload);
       armShotTimeout();
     }
+    try {
+      document.addEventListener("visibilitychange", function () {
+        try {
+          if (typeof document !== "undefined" && document.hidden) return;
+          if (!authed || !viewerAgentTransportReady()) return;
+          scheduleNextShot(14);
+        } catch (eVis) {}
+      });
+    } catch (eVisHook) {}
     function wsRequest(type, payload) {
-      if (!ws || ws.readyState !== 1 || !authed) return Promise.resolve({ ok: false, error: "not connected" });
+      if (!viewerAgentTransportReady() || !authed) return Promise.resolve({ ok: false, error: "not connected" });
       const rid = type + "_" + (++reqSeq);
       return new Promise((resolve) => {
         pendingReqs.set(rid, resolve);
-        ws.send(JSON.stringify(Object.assign({ type, request_id: rid }, payload || {})));
+        sendAgentPayload(Object.assign({ type, request_id: rid }, payload || {}));
         setTimeout(() => {
           if (!pendingReqs.has(rid)) return;
           pendingReqs.delete(rid);
@@ -1580,7 +2859,7 @@
       if (!entries.length) clearFileList("Folder is empty");
     }
     function sendRemoteInput(payload) {
-      if (!ws || ws.readyState !== 1 || !authed || !writeEnabled) return;
+      if (!viewerAgentTransportReady() || !authed || !writeEnabled) return;
       const action = String(payload && payload.action || "").trim();
       if (action && rcActionCaps && Object.prototype.hasOwnProperty.call(rcActionCaps, action) && !rcActionCaps[action]) {
         const now = Date.now();
@@ -1591,10 +2870,30 @@
         }
         return;
       }
-      ws.send(JSON.stringify(Object.assign({
-        type: "rc_input",
-        request_id: "rc_" + (++reqSeq),
-      }, payload || {})));
+      const envelope = Object.assign(
+        {
+          type: "rc_input",
+          request_id: "rc_" + (++reqSeq),
+        },
+        payload || {}
+      );
+      const discreteKick = action !== "mouse_move" && action !== "mouse_wheel";
+      function afterRemoteInputSent() {
+        if (discreteKick) kickScreenshotAfterDiscreteInput();
+      }
+      if (
+        (action === "mouse_move" || action === "mouse_wheel") &&
+        forgeRtcDcInput &&
+        forgeRtcDcInput.readyState === "open"
+      ) {
+        try {
+          forgeRtcDcInput.send(JSON.stringify(envelope));
+          afterRemoteInputSent();
+          return;
+        } catch (e) {}
+      }
+      sendAgentPayload(envelope);
+      afterRemoteInputSent();
     }
     async function refreshRemoteControlCapabilities() {
       try {
@@ -1621,7 +2920,16 @@
         pendingMovePoint = null;
         if (!p) return;
         const now = Date.now();
-        if (now - lastMoveSentAt < 35) return;
+        var p2pMove =
+          forgeRtcDcInput && forgeRtcDcInput.readyState === "open";
+        var moveThrottleMs = p2pMove
+          ? isInteractionActive()
+            ? 8
+            : 14
+          : isInteractionActive()
+            ? 10
+            : 18;
+        if (now - lastMoveSentAt < moveThrottleMs) return;
         lastMoveSentAt = now;
         sendRemoteInput({ action: "mouse_move", x: p.x, y: p.y });
       });
@@ -1692,11 +3000,11 @@
       void pushClipboardTextToRemote(txt, true, intentId);
     }
     function imgPoint(ev) {
-      const r = screenEl.getBoundingClientRect();
-      const naturalW = Number(screenEl.naturalWidth) || 0;
-      const naturalH = Number(screenEl.naturalHeight) || 0;
+      const r = rcDispEl.getBoundingClientRect();
+      const naturalW = Number(rcDispEl.width) || Number(rcDispEl.naturalWidth) || 0;
+      const naturalH = Number(rcDispEl.height) || Number(rcDispEl.naturalHeight) || 0;
       if (!r.width || !r.height || !naturalW || !naturalH) return null;
-      // For an <img>, getBoundingClientRect() is already the rendered pixel box.
+      // For canvas or <img>, getBoundingClientRect() is the rendered pixel box.
       // Using rect coordinates directly keeps mapping stable across browser zoom in/out.
       const relX = (ev.clientX - r.left) / Math.max(1, r.width);
       const relY = (ev.clientY - r.top) / Math.max(1, r.height);
@@ -1742,81 +3050,182 @@
       return { x, y };
     }
-    document.getElementById("disconnectBtn").addEventListener("click", disconnect);
-    copyFromPcBtn.addEventListener("click", async () => {
-      if (!writeEnabled) { setState("Enable Write Only mode for clipboard"); return; }
-      markInteractionActive();
-      void triggerRemoteCopyToLocal();
-    });
-    pasteToPcBtn.addEventListener("click", async () => {
-      if (!writeEnabled) { setState("Enable Write Only mode for clipboard"); return; }
-      markInteractionActive();
-      if (localClipboardBusy && (Date.now() - localClipboardBusyAt) < 1600) return;
-      localClipboardBusy = true;
-      localClipboardBusyAt = Date.now();
-      const intentId = beginPasteIntent();
-      const r = await pushLocalClipboardToRemote({ silentReadFailure: true, intentId }).finally(() => {
-        localClipboardBusy = false;
-        localClipboardBusyAt = 0;
+    document.addEventListener(
+      "contextmenu",
+      (ev) => {
+        if (rcPreferNativeContextMenu(ev)) return;
+        ev.preventDefault();
+        if (ev.shiftKey) {
+          rcHideContextMenu();
+          return;
+        }
+        rcShowContextMenu(ev.clientX, ev.clientY, ev);
+      },
+      true
+    );
+    document.addEventListener(
+      "mousedown",
+      (ev) => {
+        if (!rcCtxMenu || rcCtxMenu.classList.contains("hidden")) return;
+        if (ev.button !== 0 && ev.button !== 1) return;
+        if (rcCtxMenu.contains(ev.target)) return;
+        rcHideContextMenu();
+      },
+      true
+    );
+    window.addEventListener(
+      "scroll",
+      () => {
+        if (!rcCtxMenu || rcCtxMenu.classList.contains("hidden")) return;
+        rcHideContextMenu();
+      },
+      true
+    );
+    if (rcCtxMenu) {
+      rcCtxMenu.addEventListener("click", async (ev) => {
+        const btn = ev.target && ev.target.closest && ev.target.closest("[data-rc-act]");
+        if (!btn || btn.disabled) return;
+        const act = btn.getAttribute("data-rc-act") || "";
+        ev.preventDefault();
+        let anchorForRight = null;
+        if (act === "right-click-here") anchorForRight = rcMenuAnchorPx ? { ...rcMenuAnchorPx } : null;
+        rcHideContextMenu();
+        if (act === "toggle-write") {
+          if (!writeEnabled) {
+            if (!sessionAgentVersion) {
+              const sid = currentSessionId();
+              if (sid) await refreshSessionAgentMeta(sid);
+            }
+            if (!canEnableWriteMode()) return;
+          }
+          writeEnabled = !writeEnabled;
+          if (rcCtxMode) {
+            rcCtxMode.textContent = writeEnabled ? "Write Only" : "View Only";
+            rcCtxMode.className = writeEnabled ? "rc-ctx-item warn" : "rc-ctx-item";
+          }
+          modeStateEl.textContent = writeEnabled ? "Mode: Write Only" : "Mode: View Only";
+          rcSetWriteEnabledClass(writeEnabled);
+          if (writeEnabled && hasFrame) hideEmptyState();
+          updateWriteControls();
+          return;
+        }
+        if (act === "toggle-camera") {
+          if (cameraAvailable === false) {
+            requestScreenshot();
+            return;
+          }
+          cameraOverlayEnabled = !cameraOverlayEnabled;
+          refreshCameraBtnUi();
+          requestScreenshot();
+          return;
+        }
+        if (act === "rotate-quality") {
+          rotateQualityMode();
+          return;
+        }
+        if (act === "copy-pc") {
+          if (!writeEnabled) {
+            setState("Enable Write Only mode for clipboard");
+            return;
+          }
+          markInteractionActive();
+          void triggerRemoteCopyToLocal();
+          return;
+        }
+        if (act === "paste-pc") {
+          if (!writeEnabled) {
+            setState("Enable Write Only mode for clipboard");
+            return;
+          }
+          markInteractionActive();
+          if (localClipboardBusy && Date.now() - localClipboardBusyAt < 1600) return;
+          localClipboardBusy = true;
+          localClipboardBusyAt = Date.now();
+          const intentId = beginPasteIntent();
+          const r = await pushLocalClipboardToRemote({ silentReadFailure: true, intentId }).finally(() => {
+            localClipboardBusy = false;
+            localClipboardBusyAt = 0;
+          });
+          if (!r || !r.ok) {
+            armPasteCaptureMode("Press Ctrl/Cmd+V once to send local clipboard to PC");
+          }
+          return;
+        }
+        if (act === "refresh") {
+          if (!ws || ws.readyState !== 1) {
+            connect();
+            return;
+          }
+          requestScreenshot();
+          return;
+        }
+        if (act === "files-panel") {
+          if (!writeEnabled) {
+            setState("Enable Write Only mode for file browse");
+            return;
+          }
+          filePanel.classList.toggle("open");
+          if (!filePanel.classList.contains("open")) return;
+          await loadRootsIntoPanel();
+          return;
+        }
+        if (act === "fetch-focus") {
+          if (!writeEnabled) {
+            setState("Enable Write Only mode for file fetch");
+            return;
+          }
+          const p = String(filePullPath.value || "").trim();
+          if (!p) {
+            setState("Enter remote file path first");
+            return;
+          }
+          setState("Fetching remote file…");
+          const r = await pullRemoteFileToLocal(p);
+          if (!r || !r.ok) {
+            setState("File fetch failed");
+            return;
+          }
+          setState("Fetched file from PC: " + String(r.fileName || "download"));
+          return;
+        }
+        if (act === "right-click-here") {
+          if (!writeEnabled || !anchorForRight) return;
+          markInteractionActive();
+          const pt = anchorForRight;
+          sendRemoteInput({ action: "mouse_move", x: pt.x, y: pt.y });
+          sendRemoteInput({ action: "mouse_click", button: "right", x: pt.x, y: pt.y, click_count: 1 });
+          kickScreenshotAfterDiscreteInput();
+          return;
+        }
+        if (act === "disconnect") {
+          disconnect();
+        }
       });
-      if (!r || !r.ok) {
-        armPasteCaptureMode("Press Ctrl/Cmd+V once to send local clipboard to PC");
-      }
-    });
-    document.getElementById("refreshBtn").addEventListener("click", () => {
-      if (!ws || ws.readyState !== 1) {
-        connect();
-        return;
-      }
-      requestScreenshot();
+    }
+    rootsBtn.addEventListener("click", async () => {
+      if (!writeEnabled) return;
+      await loadRootsIntoPanel();
     });
-    modeBtn.addEventListener("click", async () => {
+    filePullBtn.addEventListener("click", async () => {
       if (!writeEnabled) {
-        if (!sessionAgentVersion) {
-          const sid = currentSessionId();
-          if (sid) await refreshSessionAgentMeta(sid);
-        }
-        if (!canEnableWriteMode()) return;
-      }
-      writeEnabled = !writeEnabled;
-      modeBtn.textContent = writeEnabled ? "Write Only" : "View Only";
-      modeStateEl.textContent = writeEnabled ? "Mode: Write Only" : "Mode: View Only";
-      modeBtn.className = writeEnabled ? "warn" : "alt";
-      screenEl.classList.toggle("write-enabled", writeEnabled);
-      if (writeEnabled && hasFrame) hideEmptyState();
-      updateWriteControls();
-    });
-    cameraBtn.addEventListener("click", () => {
-      if (cameraAvailable === false) {
-        requestScreenshot();
+        setState("Enable Write Only mode for file fetch");
         return;
       }
-      cameraOverlayEnabled = !cameraOverlayEnabled;
-      refreshCameraBtnUi();
-      requestScreenshot();
-    });
-    qualityBtn.addEventListener("click", () => {
-      rotateQualityMode();
-    });
-    filePullBtn.addEventListener("click", async () => {
-      if (!writeEnabled) { setState("Enable Write Only mode for file fetch"); return; }
       const p = String(filePullPath.value || "").trim();
-      if (!p) { setState("Enter remote file path first"); return; }
+      if (!p) {
+        setState("Enter remote file path first");
+        return;
+      }
       setState("Fetching remote file…");
       const r = await pullRemoteFileToLocal(p);
-      if (!r || !r.ok) { setState("File fetch failed"); return; }
+      if (!r || !r.ok) {
+        setState("File fetch failed");
+        return;
+      }
       setState("Fetched file from PC: " + String(r.fileName || "download"));
     });
-    browseBtn.addEventListener("click", async () => {
-      if (!writeEnabled) { setState("Enable Write Only mode for file browse"); return; }
-      filePanel.classList.toggle("open");
-      if (!filePanel.classList.contains("open")) return;
-      await loadRootsIntoPanel();
-    });
-    rootsBtn.addEventListener("click", async () => {
-      if (!writeEnabled) return;
-      await loadRootsIntoPanel();
-    });
     upBtn.addEventListener("click", async () => {
       if (!writeEnabled) return;
       if (!currentBrowsePath) { await loadRootsIntoPanel(); return; }
@@ -1856,19 +3265,57 @@
       filePushInput.value = "";
     });
-    screenEl.addEventListener("mousedown", (ev) => {
-      if (!writeEnabled) return;
-      if (ev.button !== 0 && ev.button !== 1 && ev.button !== 2) return;
-      const p = imgPoint(ev); if (!p) return;
-      ev.preventDefault();
-      markInteractionActive();
-      pointerDown = true;
-      pointerButton = ev.button === 2 ? "right" : (ev.button === 1 ? "middle" : "left");
-      pointerDownPoint = p;
-      lastPointerPoint = p;
-      dragActive = false;
-      queueMouseMove(p);
-    });
+    function bindRcScreenPointerHandlers(el) {
+      el.addEventListener("mousedown", (ev) => {
+        if (ev.button === 2 && !ev.shiftKey) return;
+        if (!writeEnabled) return;
+        if (ev.button !== 0 && ev.button !== 1 && ev.button !== 2) return;
+        const p = imgPoint(ev); if (!p) return;
+        ev.preventDefault();
+        markInteractionActive();
+        pointerDown = true;
+        pointerButton = ev.button === 2 ? "right" : (ev.button === 1 ? "middle" : "left");
+        pointerDownPoint = p;
+        lastPointerPoint = p;
+        dragActive = false;
+        queueMouseMove(p);
+      });
+      el.addEventListener("mousemove", (ev) => {
+        if (!writeEnabled) return;
+        const p = imgPoint(ev); if (!p) return;
+        lastPointerPoint = p;
+        if (pointerDown && !disablePressLifecycle) {
+          if (!dragActive && pointerDownPoint) {
+            const dx = Math.abs(p.x - pointerDownPoint.x);
+            const dy = Math.abs(p.y - pointerDownPoint.y);
+            if (dx + dy >= 8) {
+              dragActive = true;
+              sendRemoteInput({ action: "mouse_down", button: pointerButton, x: pointerDownPoint.x, y: pointerDownPoint.y });
+            }
+          }
+          if (dragActive) {
+            markInteractionActive();
+            ev.preventDefault();
+            queueMouseMove(p);
+            return;
+          }
+        }
+      });
+      el.addEventListener("dragstart", (ev) => {
+        if (!writeEnabled) return;
+        ev.preventDefault();
+      });
+      el.addEventListener("click", (ev) => {
+        if (!writeEnabled) return;
+        ev.preventDefault();
+      });
+      el.addEventListener("dblclick", (ev) => {
+        if (!writeEnabled) return;
+        ev.preventDefault();
+      });
+    }
+    bindRcScreenPointerHandlers(rcCanvasA);
+    bindRcScreenPointerHandlers(rcCanvasB);
     window.addEventListener("mouseup", (ev) => {
       if (!writeEnabled || !pointerDown) return;
       if (ev.button !== 0 && ev.button !== 1 && ev.button !== 2) return;
@@ -1907,42 +3354,6 @@
       dragActive = false;
       pendingMovePoint = null;
     });
-    screenEl.addEventListener("mousemove", (ev) => {
-      if (!writeEnabled) return;
-      const p = imgPoint(ev); if (!p) return;
-      lastPointerPoint = p;
-      if (pointerDown && !disablePressLifecycle) {
-        if (!dragActive && pointerDownPoint) {
-          const dx = Math.abs(p.x - pointerDownPoint.x);
-          const dy = Math.abs(p.y - pointerDownPoint.y);
-          if (dx + dy >= 8) {
-            dragActive = true;
-            sendRemoteInput({ action: "mouse_down", button: pointerButton, x: pointerDownPoint.x, y: pointerDownPoint.y });
-          }
-        }
-        if (dragActive) {
-          markInteractionActive();
-          ev.preventDefault();
-          queueMouseMove(p);
-          return;
-        }
-      }
-      // Do not stream hover-only cursor movement; it floods Windows rc_input process spawning
-      // and can delay click/drag events. We move cursor on down/click/wheel and while dragging.
-    });
-    screenEl.addEventListener("dragstart", (ev) => {
-      if (!writeEnabled) return;
-      ev.preventDefault();
-    });
-    screenEl.addEventListener("click", (ev) => {
-      if (!writeEnabled) return;
-      ev.preventDefault();
-    });
-    screenEl.addEventListener("dblclick", (ev) => {
-      if (!writeEnabled) return;
-      ev.preventDefault();
-    });
-    screenEl.addEventListener("contextmenu", (ev) => ev.preventDefault());
     wrapEl.addEventListener("wheel", (ev) => {
       if (ev.ctrlKey || ev.metaKey) return; // Keep browser zoom (ctrl/cmd + wheel) working.
       if (!writeEnabled) return;
@@ -1964,6 +3375,13 @@
       });
     }, { passive: false });
     window.addEventListener("keydown", (ev) => {
+      if (ev.key === "Escape") {
+        if (rcCtxMenu && !rcCtxMenu.classList.contains("hidden")) {
+          rcHideContextMenu();
+          ev.preventDefault();
+          return;
+        }
+      }
       if (!writeEnabled) return;
       if (isBrowserZoomHotkey(ev)) return; // Let browser handle Ctrl/Cmd +/-/0 zoom.
       if (isModifierOnlyKey(ev.key)) return;
@@ -2034,6 +3452,7 @@
     document.addEventListener("cut", onClipboardCopyOrCut, true);
     document.addEventListener("paste", onClipboardPaste, true);
     window.addEventListener("resize", () => {
+      rcHideContextMenu();
       if (!ws || ws.readyState !== 1 || !authed) return;
       if (resizeShotTimer) clearTimeout(resizeShotTimer);
       resizeShotTimer = setTimeout(() => {