diff --git a/opennow-stable/src/main/gfn/signaling.ts b/opennow-stable/src/main/gfn/signaling.ts
index c15e2c4..dda3c3d 100644
--- a/opennow-stable/src/main/gfn/signaling.ts
+++ b/opennow-stable/src/main/gfn/signaling.ts
@@ -30,8 +30,14 @@ export class GfnSignalingClient {
   private peerId = 2;
   private peerName = `peer-${Math.floor(Math.random() * 10_000_000_000)}`;
   private ackCounter = 0;
+  private maxReceivedAckId = 0;
   private heartbeatTimer: NodeJS.Timeout | null = null;
+  private reconnectTimer: NodeJS.Timeout | null = null;
+  private reconnectAttempts = 0;
+  private manualDisconnect = false;
   private listeners = new Set<(event: MainToRendererSignalingEvent) => void>();
+  private static readonly MAX_RECONNECT_ATTEMPTS = 6;
+  private static readonly RECONNECT_BASE_DELAY_MS = 750;
 
   constructor(
     private readonly signalingServer: string,
@@ -39,7 +45,7 @@ export class GfnSignalingClient {
     private readonly signalingUrl?: string,
   ) {}
 
-  private buildSignInUrl(): string {
+  private buildSignInUrl(reconnect = false): string {
     // Match Rust behavior: extract host:port from signalingUrl if available,
     // since the signalingUrl contains the real server address (which may differ
     // from signalingServer when the resource path was an rtsps:// URL)
@@ -58,7 +64,7 @@ export class GfnSignalingClient {
         : `${this.signalingServer}:443`;
     }
 
-    const url = `wss://${serverWithPort}/nvst/sign_in?peer_id=${this.peerName}&version=2`;
+    const url = `wss://${serverWithPort}/nvst/sign_in?peer_id=${this.peerName}&version=2&peer_role=1${reconnect ? "&reconnect=1" : ""}`;
     console.log("[Signaling] URL:", url, "(server:", this.signalingServer, ", signalingUrl:", this.signalingUrl, ")");
     return url;
   }
@@ -88,9 +94,7 @@ export class GfnSignalingClient {
 
   private setupHeartbeat(): void {
     this.clearHeartbeat();
-    this.heartbeatTimer = setInterval(() => {
-      this.sendJson({ hb: 1 });
-    }, 5000);
+    // Official client does not proactively send signaling hb packets.
   }
 
   private clearHeartbeat(): void {
@@ -100,6 +104,47 @@ export class GfnSignalingClient {
     }
   }
 
+  private clearReconnectTimer(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+
+  private scheduleReconnect(closeReason: string): void {
+    if (this.manualDisconnect) {
+      return;
+    }
+    if (this.reconnectAttempts >= GfnSignalingClient.MAX_RECONNECT_ATTEMPTS) {
+      this.emit({ type: "disconnected", reason: `${closeReason} (reconnect exhausted)` });
+      return;
+    }
+    if (this.reconnectTimer) {
+      return;
+    }
+
+    this.reconnectAttempts += 1;
+    const attempt = this.reconnectAttempts;
+    const delayMs = Math.min(
+      5000,
+      GfnSignalingClient.RECONNECT_BASE_DELAY_MS * Math.pow(2, attempt - 1),
+    );
+    this.emit({
+      type: "log",
+      message: `Signaling reconnect attempt ${attempt}/${GfnSignalingClient.MAX_RECONNECT_ATTEMPTS} in ${delayMs}ms`,
+    });
+
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = null;
+      void this.connectSocket(true).catch((error) => {
+        const errorMsg = `Signaling reconnect failed: ${String(error)}`;
+        console.error("[Signaling]", errorMsg);
+        this.emit({ type: "error", message: errorMsg });
+        this.scheduleReconnect(errorMsg);
+      });
+    }, delayMs);
+  }
+
   private sendPeerInfo(): void {
     this.sendJson({
       ackid: this.nextAckId(),
@@ -117,20 +162,27 @@ export class GfnSignalingClient {
   }
 
   async connect(): Promise<void> {
-    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+    if (this.ws && (this.ws.readyState === WebSocket.OPEN || this.ws.readyState === WebSocket.CONNECTING)) {
       return;
     }
+    this.manualDisconnect = false;
+    this.clearReconnectTimer();
+    this.reconnectAttempts = 0;
+    this.maxReceivedAckId = 0;
+    await this.connectSocket(false);
+  }
 
-    const url = this.buildSignInUrl();
+  private async connectSocket(reconnect: boolean): Promise<void> {
+    const url = this.buildSignInUrl(reconnect);
     const protocol = `x-nv-sessionid.${this.sessionId}`;
 
-    console.log("[Signaling] Connecting to:", url);
+    console.log("[Signaling] Connecting to:", url, reconnect ? "(reconnect)" : "");
     console.log("[Signaling] Session ID:", this.sessionId);
     console.log("[Signaling] Protocol:", protocol);
 
     await new Promise<void>((resolve, reject) => {
-      // Extract host:port for the Host header (matching Rust behavior)
       const urlHost = url.replace(/^wss?:\/\//, "").split("/")[0];
+      let reconnectStabilized = !reconnect;
 
       const ws = new WebSocket(url, protocol, {
         rejectUnauthorized: false,
@@ -143,28 +195,66 @@ export class GfnSignalingClient {
       });
 
       this.ws = ws;
+      let opened = false;
 
       ws.once("error", (error) => {
-        this.emit({ type: "error", message: `Signaling connect failed: ${String(error)}` });
-        reject(error);
+        if (!opened) {
+          this.emit({ type: "error", message: `Signaling connect failed: ${String(error)}` });
+          reject(error);
+          return;
+        }
+        const errorMsg = String(error);
+        console.error("[Signaling] WebSocket error during session:", errorMsg);
+        this.emit({ type: "error", message: `Signaling session error: ${errorMsg}` });
       });
 
       ws.once("open", () => {
-        this.sendPeerInfo();
-        this.setupHeartbeat();
+        opened = true;
+        this.manualDisconnect = false;
+        this.clearReconnectTimer();
+        if (!reconnect) {
+          this.sendPeerInfo();
+          this.setupHeartbeat();
+        }
         this.emit({ type: "connected" });
         resolve();
       });
 
       ws.on("message", (raw) => {
+        if (!reconnectStabilized && this.reconnectAttempts > 0) {
+          reconnectStabilized = true;
+          this.reconnectAttempts = 0;
+          this.emit({ type: "log", message: "Signaling reconnect stabilized" });
+        }
         const text = typeof raw === "string" ? raw : raw.toString("utf8");
         this.handleMessage(text);
       });
 
-      ws.on("close", (_code, reason) => {
+      ws.on("close", (code, reason) => {
+        if (this.ws === ws) {
+          this.ws = null;
+        }
         this.clearHeartbeat();
         const reasonText = typeof reason === "string" ? reason : reason.toString("utf8");
-        this.emit({ type: "disconnected", reason: reasonText || "socket closed" });
+        const closeReason = reasonText || "socket closed";
+        console.log(`[Signaling] WebSocket closed - code: ${code}, reason: "${closeReason}"`);
+
+        if (!opened) {
+          reject(new Error(`Signaling socket closed before open: ${closeReason} (code: ${code})`));
+          return;
+        }
+
+        if (this.manualDisconnect) {
+          this.emit({ type: "disconnected", reason: `${closeReason} (code: ${code})` });
+          return;
+        }
+
+        if (code === 1006 || code === 1011 || code === 1001) {
+          this.scheduleReconnect(`${closeReason} (code: ${code})`);
+          return;
+        }
+
+        this.emit({ type: "disconnected", reason: `${closeReason} (code: ${code})` });
       });
     });
   }
@@ -178,15 +268,22 @@ export class GfnSignalingClient {
       return;
     }
 
+    if (parsed.hb) {
+      // Official client ignores signaling hb payloads.
+      return;
+    }
+
+    let shouldProcessPayload = true;
     if (typeof parsed.ackid === "number") {
-      const shouldAck = parsed.peer_info?.id !== this.peerId;
-      if (shouldAck) {
-        this.sendJson({ ack: parsed.ackid });
+      if (parsed.ackid <= this.maxReceivedAckId) {
+        shouldProcessPayload = false;
+      } else {
+        this.maxReceivedAckId = parsed.ackid;
       }
+      this.sendJson({ ack: this.maxReceivedAckId });
     }
 
-    if (parsed.hb) {
-      this.sendJson({ hb: 1 });
+    if (!shouldProcessPayload) {
       return;
     }
 
@@ -272,7 +369,10 @@ export class GfnSignalingClient {
   }
 
   disconnect(): void {
+    this.manualDisconnect = true;
     this.clearHeartbeat();
+    this.clearReconnectTimer();
+    this.reconnectAttempts = 0;
     if (this.ws) {
       this.ws.close();
       this.ws = null;
diff --git a/opennow-stable/src/main/index.ts b/opennow-stable/src/main/index.ts
index 8219783..f6ff175 100644
--- a/opennow-stable/src/main/index.ts
+++ b/opennow-stable/src/main/index.ts
@@ -183,6 +183,8 @@ async function createMainWindow(): Promise<void> {
       contextIsolation: true,
       nodeIntegration: false,
       sandbox: false,
+      backgroundThrottling: false,
+      v8CacheOptions: "code",
     },
   });
 
@@ -441,6 +443,17 @@ function registerIpcHandlers(): void {
     return signalingClient.sendIceCandidate(payload);
   });
 
+  // Power save blocker handlers - DISABLED to fix Windows stream start issues
+  ipcMain.handle(IPC_CHANNELS.POWER_SAVE_BLOCKER_START, async (): Promise<void> => {
+    // Disabled: power save blocker was causing stream start issues on Windows after sleep
+    console.log("[Main] Power save blocker start requested (disabled)");
+  });
+
+  ipcMain.handle(IPC_CHANNELS.POWER_SAVE_BLOCKER_STOP, async (): Promise<void> => {
+    // Disabled: power save blocker was causing stream start issues on Windows after sleep
+    console.log("[Main] Power save blocker stop requested (disabled)");
+  });
+
   // Toggle fullscreen via IPC (for completeness)
   ipcMain.handle(IPC_CHANNELS.TOGGLE_FULLSCREEN, async () => {
     if (mainWindow && !mainWindow.isDestroyed()) {
diff --git a/opennow-stable/src/preload/index.ts b/opennow-stable/src/preload/index.ts
index 638397e..0914fec 100644
--- a/opennow-stable/src/preload/index.ts
+++ b/opennow-stable/src/preload/index.ts
@@ -76,6 +76,8 @@ const api: PreloadApi = {
   resetSettings: () => ipcRenderer.invoke(IPC_CHANNELS.SETTINGS_RESET),
   exportLogs: (format?: "text" | "json") => ipcRenderer.invoke(IPC_CHANNELS.LOGS_EXPORT, format),
   pingRegions: (regions: StreamRegion[]) => ipcRenderer.invoke(IPC_CHANNELS.PING_REGIONS, regions),
+  startPowerSaveBlocker: () => ipcRenderer.invoke(IPC_CHANNELS.POWER_SAVE_BLOCKER_START),
+  stopPowerSaveBlocker: () => ipcRenderer.invoke(IPC_CHANNELS.POWER_SAVE_BLOCKER_STOP),
 };
 
 contextBridge.exposeInMainWorld("openNow", api);
diff --git a/opennow-stable/src/renderer/src/App.tsx b/opennow-stable/src/renderer/src/App.tsx
index c9388f1..d3adf10 100644
--- a/opennow-stable/src/renderer/src/App.tsx
+++ b/opennow-stable/src/renderer/src/App.tsx
@@ -154,6 +154,10 @@ function defaultDiagnostics(): StreamDiagnostics {
     serverRegion: "",
     micState: "uninitialized",
     micEnabled: false,
+    cursorVisible: false,
+    cursorX: 0,
+    cursorY: 0,
+    cursorType: 'arrow',
   };
 }
 
@@ -371,11 +375,13 @@ export function App(): JSX.Element {
   // Refs
   const videoRef = useRef<HTMLVideoElement | null>(null);
   const audioRef = useRef<HTMLAudioElement | null>(null);
+  const cursorRef = useRef<HTMLCanvasElement | null>(null);
   const clientRef = useRef<GfnWebRtcClient | null>(null);
   const sessionRef = useRef<SessionInfo | null>(null);
   const hasInitializedRef = useRef(false);
   const regionsRequestRef = useRef(0);
   const launchInFlightRef = useRef(false);
+  const streamStatusRef = useRef<StreamStatus>("idle");
   const exitPromptResolverRef = useRef<((confirmed: boolean) => void) | null>(null);
 
   const applyVariantSelections = useCallback((catalog: GameInfo[]): void => {
@@ -410,6 +416,10 @@ export function App(): JSX.Element {
     sessionRef.current = session;
   }, [session]);
 
+  useEffect(() => {
+    streamStatusRef.current = streamStatus;
+  }, [streamStatus]);
+
   useEffect(() => {
     document.body.classList.toggle("controller-mode", controllerConnected);
     return () => {
@@ -754,7 +764,17 @@ export function App(): JSX.Element {
   // Signaling events
   useEffect(() => {
     const unsubscribe = window.openNow.onSignalingEvent(async (event: MainToRendererSignalingEvent) => {
-      console.log(`[App] Signaling event: ${event.type}`, event.type === "offer" ? `(SDP ${event.sdp.length} chars)` : "", event.type === "remote-ice" ? event.candidate : "");
+      const eventDetail =
+        event.type === "offer"
+          ? `(SDP ${event.sdp.length} chars)`
+          : event.type === "remote-ice"
+            ? event.candidate
+            : event.type === "disconnected"
+              ? event.reason
+              : event.type === "error" || event.type === "log"
+                ? event.message
+                : "";
+      console.log(`[App] Signaling event: ${event.type}`, eventDetail);
       try {
         if (event.type === "offer") {
           const activeSession = sessionRef.current;
@@ -793,6 +813,22 @@ export function App(): JSX.Element {
               onMicStateChange: (state) => {
                 console.log(`[App] Mic state: ${state.state}${state.deviceLabel ? ` (${state.deviceLabel})` : ""}`);
               },
+              onStreamExit: (info) => {
+                console.warn("[App] Stream exit from control channel:", info);
+                void window.openNow.disconnectSignaling().catch(() => {});
+                clientRef.current?.dispose();
+                clientRef.current = null;
+                setLaunchError({
+                  stage: "connecting",
+                  title: "Stream Ended by Server",
+                  description: info.nvstResult
+                    ? `The server ended the stream (nvstResult ${info.nvstResult}).`
+                    : "The server ended the stream unexpectedly.",
+                  codeLabel: toCodeLabel(info.gfnErrorCode),
+                });
+                resetLaunchRuntime({ keepLaunchError: true, keepStreamingContext: true });
+                launchInFlightRef.current = false;
+              },
             });
             // Auto-start microphone if mode is enabled
             if (settings.microphoneMode !== "disabled") {
@@ -810,14 +846,45 @@ export function App(): JSX.Element {
             });
             setLaunchError(null);
             setStreamStatus("streaming");
+            // Power save blocker disabled - was causing stream start issues on Windows after sleep
           }
         } else if (event.type === "remote-ice") {
           await clientRef.current?.addRemoteCandidate(event.candidate);
         } else if (event.type === "disconnected") {
           console.warn("Signaling disconnected:", event.reason);
+          const currentStreamStatus = streamStatusRef.current;
+          const mediaObject = videoRef.current?.srcObject;
+          const hasLiveMediaTracks =
+            mediaObject instanceof MediaStream &&
+            mediaObject.getTracks().some((track) => track.readyState === "live");
+          console.warn(
+            "Signaling disconnected - streamStatus:",
+            currentStreamStatus,
+            "videoRef exists:",
+            !!videoRef.current,
+            "hasLiveMediaTracks:",
+            hasLiveMediaTracks,
+          );
+          const reconnectExhausted = event.reason.includes("reconnect exhausted");
+          if ((currentStreamStatus === "streaming" || currentStreamStatus === "connecting") && hasLiveMediaTracks && !reconnectExhausted) {
+            console.warn("[App] Ignoring signaling disconnect while WebRTC media is still live");
+            return;
+          }
+          if (videoRef.current) {
+            console.warn("Video element state before dispose:", {
+              isConnected: videoRef.current.isConnected,
+              parentElement: videoRef.current.parentElement?.tagName,
+              paused: videoRef.current.paused,
+              readyState: videoRef.current.readyState,
+              videoWidth: videoRef.current.videoWidth,
+              videoHeight: videoRef.current.videoHeight,
+              srcObject: videoRef.current.srcObject ? "set" : "null",
+            });
+          }
           clientRef.current?.dispose();
           clientRef.current = null;
           resetLaunchRuntime();
+          // Power save blocker disabled - was causing stream start issues on Windows after sleep
           launchInFlightRef.current = false;
         } else if (event.type === "error") {
           console.error("Signaling error:", event.message);
@@ -1258,9 +1325,11 @@ export function App(): JSX.Element {
       clientRef.current = null;
       setNavbarActiveSession(null);
       resetLaunchRuntime();
+      // Power save blocker disabled - was causing stream start issues on Windows after sleep
       void refreshNavbarActiveSession();
     } catch (error) {
       console.error("Stop failed:", error);
+      // Power save blocker disabled - was causing stream start issues on Windows after sleep
     }
   }, [authSession, refreshNavbarActiveSession, resetLaunchRuntime, resolveExitPrompt]);
 
@@ -1269,6 +1338,7 @@ export function App(): JSX.Element {
     clientRef.current?.dispose();
     clientRef.current = null;
     resetLaunchRuntime();
+    // Power save blocker disabled - was causing stream start issues on Windows after sleep
     void refreshNavbarActiveSession();
   }, [refreshNavbarActiveSession, resetLaunchRuntime]);
 
@@ -1503,6 +1573,7 @@ export function App(): JSX.Element {
           <StreamView
             videoRef={videoRef}
             audioRef={audioRef}
+            cursorRef={cursorRef}
             stats={diagnostics}
             showStats={showStatsOverlay}
             shortcuts={{
diff --git a/opennow-stable/src/renderer/src/components/StreamView.tsx b/opennow-stable/src/renderer/src/components/StreamView.tsx
index 9f2b810..ca59505 100644
--- a/opennow-stable/src/renderer/src/components/StreamView.tsx
+++ b/opennow-stable/src/renderer/src/components/StreamView.tsx
@@ -99,6 +99,7 @@ function formatWarningSeconds(value: number | undefined): string | null {
 export function StreamView({
   videoRef,
   audioRef,
+  cursorRef,
   stats,
   showStats,
   shortcuts,
@@ -226,6 +227,51 @@ export function StreamView({
     }
   }, [videoRef]);
 
+  // Calculate cursor position scaled to video element
+  const getCursorPosition = () => {
+    const videoEl = localVideoRef.current;
+    if (!videoEl) return { x: 0, y: 0 };
+    
+    const videoRect = videoEl.getBoundingClientRect();
+    const videoWidth = videoEl.videoWidth || videoRect.width || 1920;
+    const videoHeight = videoEl.videoHeight || videoRect.height || 1200;
+
+    // Match object-fit: contain placement so cursor stays aligned in fullscreen letterbox/pillarbox.
+    const streamAspect = videoWidth / videoHeight;
+    const boxAspect = videoRect.width / videoRect.height;
+
+    let renderWidth = videoRect.width;
+    let renderHeight = videoRect.height;
+    let offsetX = 0;
+    let offsetY = 0;
+
+    if (streamAspect > boxAspect) {
+      renderHeight = videoRect.width / streamAspect;
+      offsetY = (videoRect.height - renderHeight) / 2;
+    } else {
+      renderWidth = videoRect.height * streamAspect;
+      offsetX = (videoRect.width - renderWidth) / 2;
+    }
+
+    const scaleX = renderWidth / videoWidth;
+    const scaleY = renderHeight / videoHeight;
+    
+    return {
+      x: offsetX + stats.cursorX * scaleX - (stats.cursorHotspotX || 0) * scaleX,
+      y: offsetY + stats.cursorY * scaleY - (stats.cursorHotspotY || 0) * scaleY,
+    };
+  };
+  
+  const cursorPos = getCursorPosition();
+
+  useEffect(() => {
+    if (stats.cursorVisible && stats.cursorImageUrl) {
+      console.log(
+        `[StreamView] Custom cursor applied (hotspot=${stats.cursorHotspotX || 0},${stats.cursorHotspotY || 0})`,
+      );
+    }
+  }, [stats.cursorVisible, stats.cursorImageUrl, stats.cursorHotspotX, stats.cursorHotspotY]);
+
   // Focus video element when stream is ready (not connecting anymore)
   useEffect(() => {
     if (!isConnecting && localVideoRef.current && hasResolution) {
@@ -250,6 +296,7 @@ export function StreamView({
         muted 
         tabIndex={0} 
         className="sv-video"
+        style={{ cursor: stats.cursorVisible ? 'none' : 'default' }}
         onClick={() => {
           // Ensure video has focus when clicked for pointer lock to work
           if (localVideoRef.current && document.activeElement !== localVideoRef.current) {
@@ -257,6 +304,27 @@ export function StreamView({
           }
         }}
       />
+      {/* Cursor overlay - displays server-rendered cursor image */}
+      {stats.cursorVisible && stats.cursorImageUrl && (
+        <img
+          src={stats.cursorImageUrl}
+          alt=""
+          className="sv-cursor"
+          style={{
+            position: 'absolute',
+            left: cursorPos.x,
+            top: cursorPos.y,
+            width: 'auto',
+            height: 'auto',
+            pointerEvents: 'none',
+            zIndex: 10,
+            imageRendering: 'pixelated',
+          }}
+          onError={(e) => {
+            console.log('[StreamView] Cursor image failed to load:', e);
+          }}
+        />
+      )}
       <audio ref={audioRef} autoPlay playsInline />
 
       {/* Gradient background when no video */}
diff --git a/opennow-stable/src/renderer/src/gfn/webrtcClient.ts b/opennow-stable/src/renderer/src/gfn/webrtcClient.ts
index d822bc8..077da14 100644
--- a/opennow-stable/src/renderer/src/gfn/webrtcClient.ts
+++ b/opennow-stable/src/renderer/src/gfn/webrtcClient.ts
@@ -169,6 +169,15 @@ export interface StreamDiagnostics {
   // Microphone state
   micState: MicState;
   micEnabled: boolean;
+
+  // Cursor state
+  cursorVisible: boolean;
+  cursorX: number;
+  cursorY: number;
+  cursorType: 'arrow' | 'ibeam' | 'hand' | 'crosshair' | 'wait' | 'default';
+  cursorImageUrl: string | null;
+  cursorHotspotX: number;
+  cursorHotspotY: number;
 }
 
 export interface StreamTimeWarning {
@@ -176,6 +185,11 @@ export interface StreamTimeWarning {
   secondsLeft?: number;
 }
 
+export interface StreamExitInfo {
+  nvstResult?: number;
+  gfnErrorCode: number;
+}
+
 interface ClientOptions {
   videoElement: HTMLVideoElement;
   audioElement: HTMLAudioElement;
@@ -190,6 +204,7 @@ interface ClientOptions {
   onEscHoldProgress?: (visible: boolean, progress: number) => void;
   onTimeWarning?: (warning: StreamTimeWarning) => void;
   onMicStateChange?: (state: MicStateChange) => void;
+  onStreamExit?: (info: StreamExitInfo) => void;
 }
 
 function timestampUs(sourceTimestampMs?: number): bigint {
@@ -429,11 +444,22 @@ export class GfnWebRtcClient {
   private readonly inputEncoder = new InputEncoder();
 
   private pc: RTCPeerConnection | null = null;
+  private disposed = false;
   private reliableInputChannel: RTCDataChannel | null = null;
   private mouseInputChannel: RTCDataChannel | null = null;
+  private cursorChannel: RTCDataChannel | null = null;
+  private statsChannel: RTCDataChannel | null = null;
   private controlChannel: RTCDataChannel | null = null;
   private audioContext: AudioContext | null = null;
 
+  // Server timebase offset for timestamp synchronization (matches official client's time remapping)
+  private serverTimebaseOffsetMs = 0;
+  private serverTimebaseSynced = false;
+
+  // Mouse sub-pixel accumulation for fractional deltas (matches official client's Up/Hp fields)
+  private mouseSubPixelX = 0;
+  private mouseSubPixelY = 0;
+
   private inputReady = false;
   private inputProtocolVersion = 2;
   private heartbeatTimer: number | null = null;
@@ -445,6 +471,7 @@ export class GfnWebRtcClient {
   private pendingMouseDy = 0;
   private inputCleanup: Array<() => void> = [];
   private queuedCandidates: RTCIceCandidateInit[] = [];
+  private streamExitHandled = false;
 
   // Input mode: auto-switches between mouse+keyboard and gamepad
   // When gamepad has activity, mouse/keyboard are suppressed (and vice versa)
@@ -513,6 +540,11 @@ export class GfnWebRtcClient {
   private inputQueuePressureLoggedAtMs = 0;
   private inputQueueDropCount = 0;
 
+  // Mouse event queue for coalescing and rate limiting (matches official client's ql/qc)
+  private mouseEventQueue: Array<{ dx: number; dy: number; ts: bigint; dropped?: boolean }> = [];
+  private static readonly MOUSE_QUEUE_MAX_SIZE = 8; // Max pending mouse events before coalescing
+  private mouseQueueHighWatermark = 0;
+
   // Microphone
   private micManager: MicrophoneManager | null = null;
   private micState: MicState = "uninitialized";
@@ -554,9 +586,17 @@ export class GfnWebRtcClient {
     serverRegion: "",
     micState: "uninitialized",
     micEnabled: false,
+    cursorVisible: false,
+    cursorX: 0,
+    cursorY: 0,
+    cursorType: 'arrow',
+    cursorImageUrl: null,
+    cursorHotspotX: 0,
+    cursorHotspotY: 0,
   };
 
   constructor(private readonly options: ClientOptions) {
+    this.log(`WebRTCClient constructor - video element isConnected=${options.videoElement.isConnected}, parentElement=${options.videoElement.parentElement?.tagName || 'null'}`);
     options.videoElement.srcObject = this.videoStream;
     options.audioElement.srcObject = this.audioStream;
     options.audioElement.muted = true;
@@ -718,10 +758,17 @@ export class GfnWebRtcClient {
     }
     this.reliableInputChannel?.close();
     this.mouseInputChannel?.close();
+    this.cursorChannel?.close();
+    this.statsChannel?.close();
     this.controlChannel?.close();
     this.reliableInputChannel = null;
     this.mouseInputChannel = null;
+    this.cursorChannel = null;
+    this.statsChannel = null;
     this.controlChannel = null;
+    this.serverTimebaseSynced = false;
+    this.mouseSubPixelX = 0;
+    this.mouseSubPixelY = 0;
   }
 
   private clearTimers(): void {
@@ -992,6 +1039,9 @@ export class GfnWebRtcClient {
   }
 
   private cleanupPeerConnection(): void {
+    this.log("cleanupPeerConnection() called");
+    this.log(`cleanupPeerConnection() - video element: isConnected=${this.options.videoElement.isConnected}, parentElement=${this.options.videoElement.parentElement?.tagName || 'null'}`);
+    this.streamExitHandled = false;
     this.clearTimers();
     this.detachInputCapture();
     this.closeDataChannels();
@@ -1011,10 +1061,16 @@ export class GfnWebRtcClient {
     }
 
     // Remove old tracks so reconnects don't accumulate ended tracks in srcObject streams.
-    for (const track of this.videoStream.getTracks()) {
+    const videoTracksBefore = this.videoStream.getTracks();
+    this.log(`cleanupPeerConnection: removing ${videoTracksBefore.length} video tracks`);
+    for (const track of videoTracksBefore) {
+      this.log(`cleanupPeerConnection: removing video track - id=${track.id}, readyState=${track.readyState}, muted=${track.muted}, enabled=${track.enabled}`);
       this.videoStream.removeTrack(track);
     }
-    for (const track of this.audioStream.getTracks()) {
+    const audioTracksBefore = this.audioStream.getTracks();
+    this.log(`cleanupPeerConnection: removing ${audioTracksBefore.length} audio tracks`);
+    for (const track of audioTracksBefore) {
+      this.log(`cleanupPeerConnection: removing audio track - id=${track.id}, readyState=${track.readyState}, muted=${track.muted}, enabled=${track.enabled}`);
       this.audioStream.removeTrack(track);
     }
 
@@ -1031,6 +1087,10 @@ export class GfnWebRtcClient {
     this.pendingMouseDx = 0;
     this.pendingMouseDy = 0;
     this.pendingMouseTimestampUs = null;
+    this.mouseSubPixelX = 0;
+    this.mouseSubPixelY = 0;
+    this.mouseEventQueue = [];
+    this.mouseQueueHighWatermark = 0;
     this.mouseDeltaFilter.reset();
     this.mouseFlushLastTickMs = 0;
     this.inputQueuePeakBufferedBytesWindow = 0;
@@ -1047,6 +1107,10 @@ export class GfnWebRtcClient {
       // Set up render FPS tracking using video element
       const video = this.options.videoElement;
       const frameCallback = () => {
+        // Stop callback if disposed or video element removed
+        if (this.disposed || !video.isConnected) {
+          return;
+        }
         this.updateRenderFps();
         if (this.videoStream.active) {
           video.requestVideoFrameCallback(frameCallback);
@@ -1060,14 +1124,38 @@ export class GfnWebRtcClient {
 
       // Explicitly start video playback after track attachment.
       // Some Chromium/Electron builds keep the video element paused even with autoplay.
-      video
-        .play()
-        .then(() => {
-          this.log("Video element playback started");
-        })
-        .catch((playError) => {
-          this.log(`Video play() failed: ${String(playError)}`);
-        });
+      // Add error handler for video element
+      video.onerror = (e) => {
+        const videoEl = e.target as HTMLVideoElement;
+        const error = videoEl.error;
+        this.log(`Video element error: code=${error?.code}, message=${error?.message || 'unknown'}, networkState=${videoEl.networkState}`);
+      };
+
+      // Only play if video element is still in DOM
+      if (video.isConnected) {
+        video
+          .play()
+          .then(() => {
+            // Check if still connected before logging to avoid errors after unmount
+            if (video.isConnected) {
+              this.log("Video element playback started");
+            } else {
+              this.log("Video playback started but element was removed from DOM shortly after");
+            }
+          })
+          .catch((playError) => {
+            // Only log detailed errors if element is still in DOM - avoids false errors during cleanup
+            if (video.isConnected) {
+              this.log(`Video play() failed: ${String(playError)}`);
+              this.log(`Video play() failure context: isConnected=${video.isConnected}, parentElement=${video.parentElement?.tagName || 'null'}, srcObject=${video.srcObject ? 'set' : 'null'}`);
+              this.log(`Video play() failure - video state: paused=${video.paused}, readyState=${video.readyState}, networkState=${video.networkState}`);
+            } else {
+              this.log(`Video play() aborted - element was removed from DOM (expected during cleanup)`);
+            }
+          });
+      } else {
+        this.log("Skipping video play() - element not connected to DOM");
+      }
 
       window.setTimeout(() => {
         this.log(
@@ -1081,11 +1169,66 @@ export class GfnWebRtcClient {
       track.onmute = () => {
         this.log("Warning: video track muted by sender");
       };
+
+      this.log("Video track attached");
+      
+      // Monitor video element for DOM removal using MutationObserver
+      if (video.parentElement) {
+        const observer = new MutationObserver((mutations) => {
+          for (const mutation of mutations) {
+            if (mutation.type === 'childList') {
+              for (const node of mutation.removedNodes) {
+                if (node === video || (node instanceof Element && node.contains(video))) {
+                  this.log(`CRITICAL: Video element or parent removed from DOM! removedNode=${node.nodeName}`);
+                }
+              }
+            }
+          }
+          // Also check general state
+          if (!video.isConnected) {
+            this.log(`CRITICAL: Video element no longer connected to DOM! parentElement=${video.parentElement?.tagName || 'null'}`);
+          }
+        });
+        observer.observe(video.parentElement, { childList: true, subtree: true });
+        this.log(`MutationObserver attached to video parent: ${video.parentElement.tagName}`);
+      }
+      
+      // Periodic check as backup
+      const checkVideoInDom = () => {
+        if (!video.isConnected) {
+          this.log(`CRITICAL: Video element removed from DOM! parentElement=${video.parentElement?.tagName || 'null'}`);
+        }
+        if (video.srcObject !== this.videoStream) {
+          this.log(`CRITICAL: Video srcObject changed! current=${video.srcObject ? (video.srcObject === this.videoStream ? 'our stream' : 'different stream') : 'null'}`);
+        }
+      };
+      // Check immediately and periodically
+      checkVideoInDom();
+      const domCheckInterval = window.setInterval(checkVideoInDom, 2000);
+      
+      // Clean up interval when track ends
       track.onended = () => {
+        if (this.disposed) {
+          this.log("Video track ended but client already disposed - skipping cleanup (expected during dispose)");
+          window.clearInterval(domCheckInterval);
+          return;
+        }
+        
         this.log("Warning: video track ended");
+        
+        // Only log video element state if it's still in DOM to avoid misleading logs
+        if (video.isConnected) {
+          this.log(`Video track ended - state: readyState=${track.readyState}, muted=${track.muted}, enabled=${track.enabled}`);
+          this.log(`Video element state: parentElement=${video.parentElement?.tagName || 'null'}, isConnected=${video.isConnected}, srcObject=${video.srcObject ? 'set' : 'null'}`);
+          this.log(`Video stream state: active=${this.videoStream.active}, tracks=${this.videoStream.getTracks().length}`);
+        } else {
+          this.log(`Video track ended - element already removed from DOM (likely due to stream stopping)`);
+          this.log(`Video track ended - state: readyState=${track.readyState}, muted=${track.muted}, enabled=${track.enabled}`);
+          this.log(`Video stream state: active=${this.videoStream.active}, tracks=${this.videoStream.getTracks().length}`);
+        }
+        window.clearInterval(domCheckInterval);
       };
-
-      this.log("Video track attached");
+      
       return;
     }
 
@@ -1171,12 +1314,28 @@ export class GfnWebRtcClient {
       window.clearInterval(this.heartbeatTimer);
     }
 
+    let heartbeatCount = 0;
+    let lastLogTime = performance.now();
+
     this.heartbeatTimer = window.setInterval(() => {
       if (!this.inputReady) {
         return;
       }
       const bytes = this.inputEncoder.encodeHeartbeat();
-      this.sendReliable(bytes);
+      const sent = this.sendReliable(bytes);
+      heartbeatCount++;
+
+      // Log heartbeat stats every 10 seconds
+      const now = performance.now();
+      if (now - lastLogTime > 10000) {
+        this.log(`Heartbeat stats: sent=${heartbeatCount}, reliableChannel=${this.reliableInputChannel?.readyState || "null"}, inputReady=${this.inputReady}`);
+        lastLogTime = now;
+        heartbeatCount = 0;
+      }
+
+      if (!sent) {
+        this.log(`Heartbeat failed to send - reliableChannel=${this.reliableInputChannel?.readyState || "null"}, bufferedAmount=${this.reliableInputChannel?.bufferedAmount || 0}`);
+      }
     }, 2000);
   }
 
@@ -1388,11 +1547,21 @@ export class GfnWebRtcClient {
     this.reliableInputChannel = pc.createDataChannel("input_channel_v1", {
       ordered: true,
     });
+    this.reliableInputChannel.binaryType = "arraybuffer";
 
     this.reliableInputChannel.onopen = () => {
+      this.reliableDropLogged = false;
       this.log("Reliable input channel open");
     };
 
+    this.reliableInputChannel.onclose = () => {
+      this.log("Reliable input channel closed");
+    };
+
+    this.reliableInputChannel.onerror = (e) => {
+      this.log(`Reliable input channel error: ${e.type}`);
+    };
+
     this.reliableInputChannel.onmessage = async (event) => {
       const bytes = await toBytes(event.data as string | Blob | ArrayBuffer);
       this.onInputHandshakeMessage(bytes);
@@ -1402,10 +1571,80 @@ export class GfnWebRtcClient {
       ordered: false,
       maxPacketLifeTime: this.partialReliableThresholdMs,
     });
+    this.mouseInputChannel.binaryType = "arraybuffer";
 
     this.mouseInputChannel.onopen = () => {
       this.log(`Mouse channel open (partially reliable, maxPacketLifeTime=${this.partialReliableThresholdMs}ms)`);
     };
+
+    this.mouseInputChannel.onclose = () => {
+      this.log("Mouse input channel closed");
+    };
+
+    this.mouseInputChannel.onerror = (e) => {
+      this.log(`Mouse input channel error: ${e.type}`);
+    };
+
+    // Server-rendered cursor channel for precise cursor positioning
+    // CRITICAL: Must use reliable=true, ordered=true for accurate cursor positioning
+    this.cursorChannel = pc.createDataChannel("cursor_channel", {
+      ordered: true,
+      reliable: true,
+    });
+    this.cursorChannel.binaryType = "arraybuffer";
+
+    this.cursorChannel.onopen = () => {
+      this.log("Cursor channel open (server-rendered cursor, reliable=true)");
+    };
+
+    this.cursorChannel.onclose = () => {
+      this.log("Cursor channel closed");
+    };
+
+    this.cursorChannel.onerror = (e) => {
+      this.log(`Cursor channel error: ${e.type}`);
+    };
+
+    this.cursorChannel.onmessage = (event) => {
+      void toBytes(event.data as string | Blob | ArrayBuffer)
+        .then((bytes) => {
+          this.handleCursorMessage(bytes);
+        })
+        .catch((error) => {
+          this.log(`Cursor channel decode error: ${String(error)}`);
+        });
+    };
+
+    // Stats/telemetry channel for stream quality metrics
+    // Fire-and-forget: no ordering, no reliability, no retransmits (matches official)
+    this.statsChannel = pc.createDataChannel("stats_channel", {
+      ordered: false,
+      reliable: false,
+      maxRetransmits: 0,
+    });
+    this.statsChannel.binaryType = "arraybuffer";
+
+    this.statsChannel.onopen = () => {
+      this.log("Stats channel open (telemetry, fire-and-forget)");
+    };
+
+    this.statsChannel.onclose = () => {
+      this.log("Stats channel closed");
+    };
+
+    this.statsChannel.onerror = (e) => {
+      this.log(`Stats channel error: ${e.type}`);
+    };
+
+    this.statsChannel.onmessage = (event) => {
+      void toBytes(event.data as string | Blob | ArrayBuffer)
+        .then((bytes) => {
+          this.handleServerStatsMessage(bytes);
+        })
+        .catch((error) => {
+          this.log(`Stats channel decode error: ${String(error)}`);
+        });
+    };
   }
 
   private mapTimerNotificationCode(rawCode: number): StreamTimeWarning["code"] | null {
@@ -1422,6 +1661,274 @@ export class GfnWebRtcClient {
     return null;
   }
 
+  private mapNvstResultToGfnErrorCode(nvstResult: number | undefined): number {
+    switch (nvstResult) {
+      case 2147680271:
+        return 3237094147; // ServerDisconnectedFrameGrabFailed
+      case 2147680259:
+        return 3237094152; // ServerDisconnectedGameLaunchFailed
+      default:
+        return 15868672; // StreamDisconnectedFromServer
+    }
+  }
+
+  /**
+   * Handle cursor image data from cursor_channel.
+   * 
+   * Based on vendor_beautified.js Jf() function (line 14822):
+   * The cursor_channel sends binary messages with embedded cursor images.
+   * 
+   * Message format:
+   * - Byte 0: Message type (0=apply cursor+pos, 1=define cursor, 10=allowUnconfined flag)
+   * - Byte 1: Cursor ID (m)
+   * - Byte 2: Hotspot X (Sf)
+   * - Byte 3: Hotspot Y (wf)
+   * - Byte 4: MIME type length (L)
+   * - Bytes 5 to 5+L: MIME type (UTF-8, optional)
+   * - Next 2 bytes: Image data length (16-bit LE)
+   * - Next N bytes: Base64 cursor image data (bf)
+   * - Next 4 bytes (optional): Position X, Y (16-bit LE each)
+   * - Next 2 bytes (optional): Scale x100 (uint16 LE)
+   * 
+   * The server sends: type 1 to define cursor image, then type 0 to set position
+   */
+  private cursorImageCache: Map<number, { bf: string; Sf: number; wf: number; mimeType: string; scale: number }> = new Map();
+  private currentCursorId: number = 0;
+
+  private inferCursorMimeType(base64Image: string, hintedMimeType: string): string {
+    const normalizedHint = hintedMimeType.trim().toLowerCase();
+    if (normalizedHint.startsWith("image/")) {
+      return normalizedHint;
+    }
+    if (base64Image.startsWith("iVBOR")) {
+      return "image/png";
+    }
+    if (base64Image.startsWith("/9j/")) {
+      return "image/jpeg";
+    }
+    if (base64Image.startsWith("R0lGOD")) {
+      return "image/gif";
+    }
+    if (base64Image.startsWith("PHN2Z")) {
+      return "image/svg+xml";
+    }
+    return "image/x-icon";
+  }
+
+  private applyCursorFromCache(cursorId: number, posX?: number, posY?: number): void {
+    const cursorData = this.cursorImageCache.get(cursorId);
+    if (!cursorData) {
+      this.log(`Cursor not found: id=${cursorId}`);
+      return;
+    }
+
+    this.currentCursorId = cursorId;
+    this.diagnostics.cursorImageUrl = `data:${cursorData.mimeType};base64,${cursorData.bf}`;
+    this.diagnostics.cursorHotspotX = cursorData.Sf;
+    this.diagnostics.cursorHotspotY = cursorData.wf;
+    this.diagnostics.cursorType = "default";
+    this.diagnostics.cursorVisible = true;
+
+    if (posX !== undefined && posY !== undefined) {
+      this.diagnostics.cursorX = posX;
+      this.diagnostics.cursorY = posY;
+    }
+
+    this.emitStats();
+    this.log(
+      `Cursor applied: id=${cursorId}, pos=(${this.diagnostics.cursorX},${this.diagnostics.cursorY}), hotspot=(${cursorData.Sf},${cursorData.wf}), scale=${cursorData.scale.toFixed(2)}`,
+    );
+  }
+
+  private handleCursorMessage(u: Uint8Array): void {
+    try {
+      if (u.byteLength < 1) {
+        this.log("Cursor message too short: 0 bytes");
+        return;
+      }
+
+      const msgType = u[0];
+
+      // type 10 is an unconfined cursor flag in the official client, not visibility.
+      if (msgType === 10) {
+        const allowUnconfined = u.byteLength >= 2 && u[1] === 1;
+        this.log(`Cursor channel flag: allowUnconfined=${allowUnconfined}`);
+        return;
+      }
+
+      if (u.byteLength < 5) {
+        this.log(`Cursor message too short: ${u.byteLength} bytes`);
+        return;
+      }
+      if (msgType !== 0 && msgType !== 1) {
+        this.log(`Cursor message ignored: unsupported type=${msgType}`);
+        return;
+      }
+
+      const cursorId = u[1];
+      const hotspotX = u[2];
+      const hotspotY = u[3];
+      const mimeTypeLen = u[4];
+
+      let offset = 5;
+
+      // Read MIME type hint if present
+      let mimeTypeHint = "";
+      if (mimeTypeLen > 0) {
+        if (offset + mimeTypeLen > u.byteLength) {
+          this.log(`Cursor message truncated (mime type): id=${cursorId}, len=${u.byteLength}`);
+          return;
+        }
+        mimeTypeHint = new TextDecoder("utf-8").decode(u.subarray(offset, offset + mimeTypeLen));
+        offset += mimeTypeLen;
+      }
+
+      // Helper to read 16-bit LE
+      const readUint16 = (): number | undefined => {
+        if (offset + 2 > u.byteLength) return undefined;
+        const val = u[offset] | (u[offset + 1] << 8);
+        offset += 2;
+        return val;
+      };
+
+      // Read image data length and image data
+      const imageDataLen = readUint16();
+      if (imageDataLen === undefined) {
+        this.log(`Cursor message truncated (image length): id=${cursorId}, len=${u.byteLength}`);
+        return;
+      }
+      let base64Image = "";
+
+      if (imageDataLen > 0) {
+        if (offset + imageDataLen > u.byteLength) {
+          this.log(`Cursor message truncated (image payload): id=${cursorId}, len=${u.byteLength}`);
+          return;
+        }
+        base64Image = new TextDecoder("utf-8").decode(u.subarray(offset, offset + imageDataLen));
+        offset += imageDataLen;
+      }
+
+      // Read position if present (need 4 more bytes)
+      let posX: number | undefined;
+      let posY: number | undefined;
+
+      if (offset + 4 <= u.byteLength) {
+        posX = readUint16();
+        posY = readUint16();
+      }
+
+      // Optional scale (uint16 / 100)
+      let scale = 1;
+      if (offset + 2 <= u.byteLength) {
+        const parsedScale = readUint16();
+        if (parsedScale && parsedScale > 0) {
+          scale = parsedScale / 100;
+        }
+      }
+
+      // Cache cursor definition if message includes image payload
+      if (base64Image.length > 0) {
+        const cachedMimeType = this.cursorImageCache.get(cursorId)?.mimeType ?? "";
+        const mimeType = this.inferCursorMimeType(base64Image, mimeTypeHint || cachedMimeType);
+        this.cursorImageCache.set(cursorId, {
+          bf: base64Image,
+          Sf: hotspotX,
+          wf: hotspotY,
+          mimeType,
+          scale,
+        });
+        this.log(`Cursor cached: id=${cursorId}, len=${base64Image.length}, mime="${mimeType}", scale=${scale.toFixed(2)}`);
+      } else if (msgType === 1 && !this.cursorImageCache.has(cursorId)) {
+        this.log(`Cursor define missing image: id=${cursorId}`);
+        return;
+      }
+
+      // Official behavior: type 0 applies cached cursor+position, type 1 defines and can also apply.
+      this.applyCursorFromCache(cursorId, posX, posY);
+    } catch (e) {
+      this.log(`Cursor message parse error: ${String(e)}`);
+    }
+  }
+
+  /**
+   * Handle server stats/telemetry messages from stats_channel.
+   * The server sends performance metrics for adaptive streaming.
+   * 
+   * Message format (from vendor_beautified.js:18668-18682):
+   * - Byte 0: version/type
+   * - If version >= 4:
+   *   - Bytes 1-8: timestamp (float64 BE) / 1e6 = seconds
+   *   - Bytes 9-16: server timestamp (float64 BE)
+   *   - Bytes 17-24: unknown (float64 BE)
+   *   - Bytes 25-28: overall score (float32 BE)
+   *   - Bytes 29-32: gpuPerfScore (float32 BE)
+   *   - Bytes 33-36: serverPerfScore (float32 BE)
+   *   - etc.
+   */
+  private handleServerStatsMessage(data: Uint8Array): void {
+    try {
+      const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+      if (data.byteLength < 1) return;
+
+      const version = view.getUint8(0);
+
+      // Version 3: simple ACK message
+      if (version === 3) {
+        this.log("Server stats: ACK received");
+        return;
+      }
+
+      // Version >= 4: full performance metrics (matches vendor:18668-18682)
+      if (version >= 4 && data.byteLength >= 70) {
+        // Extract timestamps for timebase synchronization
+        const serverTimestampUs = view.getFloat64(1, true); // microseconds
+        const serverPerfTimestamp = view.getFloat64(9, true);
+
+        // Calculate server timebase offset for timestamp remapping
+        if (!this.serverTimebaseSynced) {
+          const localNowUs = performance.now() * 1000;
+          this.serverTimebaseOffsetMs = (serverTimestampUs - localNowUs) / 1000;
+          this.serverTimebaseSynced = true;
+          this.log(`Server timebase synced: offset=${this.serverTimebaseOffsetMs.toFixed(2)}ms`);
+        }
+
+        // Extract performance scores (all float32 BE)
+        const overall = view.getFloat32(25, true);
+        const gpuPerfScore = view.getFloat32(29, true);
+        const serverPerfScore = view.getFloat32(33, true);
+        const visualScore = view.getFloat32(37, true);
+        const decoderScore = view.getFloat32(41, true);
+        const downlinkLag = view.getFloat32(45, true);
+        const downlinkCongestion = view.getFloat32(49, true);
+        const uplink = view.getFloat32(53, true);
+
+        this.log(
+          `Server stats: overall=${overall.toFixed(2)}, ` +
+          `gpu=${gpuPerfScore.toFixed(2)}, server=${serverPerfScore.toFixed(2)}, ` +
+          `visual=${visualScore.toFixed(2)}, decoder=${decoderScore.toFixed(2)}, ` +
+          `lag=${downlinkLag.toFixed(2)}, congestion=${downlinkCongestion.toFixed(2)}, ` +
+          `uplink=${uplink.toFixed(2)}`
+        );
+
+        // Could use these metrics for adaptive bitrate or quality adjustments
+      }
+    } catch (e) {
+      this.log(`Server stats message parse error: ${String(e)}`);
+    }
+  }
+
+  /**
+   * Convert local timestamp to server timebase for input events.
+   * This ensures timestamps are synchronized with the server's clock.
+   */
+  private remapTimestampToServer(localTimestampMs: number): bigint {
+    if (!this.serverTimebaseSynced) {
+      return timestampUs(localTimestampMs);
+    }
+    const remappedMs = localTimestampMs + this.serverTimebaseOffsetMs;
+    return BigInt(Math.floor(remappedMs * 1000));
+  }
+
   private async onControlChannelMessage(data: string | Blob | ArrayBuffer): Promise<void> {
     let payloadText: string;
     if (typeof data === "string") {
@@ -1441,6 +1948,28 @@ export class GfnWebRtcClient {
       return;
     }
 
+    if (parsed && typeof parsed === "object") {
+      const control = parsed as Record<string, unknown>;
+      if ("exitMessage" in control) {
+        this.log(`Control exit message: ${JSON.stringify(control.exitMessage)}`);
+        if (!this.streamExitHandled && control.exitMessage && typeof control.exitMessage === "object") {
+          const exit = control.exitMessage as Record<string, unknown>;
+          const rawNvstResult = Number(exit.nvstResult);
+          const nvstResult = Number.isFinite(rawNvstResult) ? rawNvstResult : undefined;
+          const gfnErrorCode = this.mapNvstResultToGfnErrorCode(nvstResult);
+          this.streamExitHandled = true;
+          this.options.onStreamExit?.({
+            nvstResult,
+            gfnErrorCode,
+          });
+        }
+      } else if ("videoStreamProgressEvent" in control) {
+        this.log(`Control videoStreamProgressEvent: ${JSON.stringify(control.videoStreamProgressEvent)}`);
+      } else if ("customMessage" in control) {
+        this.log(`Control custom message: ${JSON.stringify(control.customMessage)}`);
+      }
+    }
+
     if (!parsed || typeof parsed !== "object" || !("timerNotification" in parsed)) {
       return;
     }
@@ -1484,14 +2013,16 @@ export class GfnWebRtcClient {
 
   private reliableDropLogged = false;
 
-  public sendReliable(payload: Uint8Array): void {
+  public sendReliable(payload: Uint8Array): boolean {
     if (this.reliableInputChannel?.readyState === "open") {
       const safePayload = Uint8Array.from(payload);
       this.reliableInputChannel.send(safePayload.buffer);
+      return true;
     } else if (!this.reliableDropLogged) {
       this.reliableDropLogged = true;
       this.log(`Reliable channel not open (state=${this.reliableInputChannel?.readyState ?? "null"}), dropping event (${payload.length} bytes)`);
     }
+    return false;
   }
 
   private async lockEscapeInFullscreen(): Promise<void> {
@@ -1813,13 +2344,13 @@ export class GfnWebRtcClient {
       }
 
       if (this.activeInputMode === "gamepad") {
-        this.pendingMouseDx = 0;
-        this.pendingMouseDy = 0;
-        this.pendingMouseTimestampUs = null;
+        this.mouseEventQueue = [];
+        this.mouseSubPixelX = 0;
+        this.mouseSubPixelY = 0;
         return;
       }
 
-      if (this.pendingMouseDx === 0 && this.pendingMouseDy === 0) {
+      if (this.mouseEventQueue.length === 0) {
         return;
       }
 
@@ -1840,15 +2371,39 @@ export class GfnWebRtcClient {
         return;
       }
 
+      // Process queued mouse events (matches official client's batching behavior)
+      // Sum all queued deltas and use the oldest timestamp for the batch
+      let totalDx = 0;
+      let totalDy = 0;
+      let batchTimestamp: bigint | null = null;
+      let coalescedCount = 0;
+
+      for (const event of this.mouseEventQueue) {
+        totalDx += event.dx;
+        totalDy += event.dy;
+        if (event.dropped) coalescedCount++;
+        if (batchTimestamp === null) {
+          batchTimestamp = event.ts;
+        }
+      }
+
+      // Add sub-pixel remainders
+      totalDx += Math.trunc(this.mouseSubPixelX);
+      totalDy += Math.trunc(this.mouseSubPixelY);
+
+      // Store fractional remainders for next frame
+      this.mouseSubPixelX = this.mouseSubPixelX - Math.trunc(this.mouseSubPixelX);
+      this.mouseSubPixelY = this.mouseSubPixelY - Math.trunc(this.mouseSubPixelY);
+
+      // Clear queue
+      this.mouseEventQueue = [];
+
       const payload = this.inputEncoder.encodeMouseMove({
-        dx: Math.max(-32768, Math.min(32767, this.pendingMouseDx)),
-        dy: Math.max(-32768, Math.min(32767, this.pendingMouseDy)),
-        timestampUs: this.pendingMouseTimestampUs ?? timestampUs(),
+        dx: Math.max(-32768, Math.min(32767, totalDx)),
+        dy: Math.max(-32768, Math.min(32767, totalDy)),
+        timestampUs: batchTimestamp ?? timestampUs(),
       });
 
-      this.pendingMouseDx = 0;
-      this.pendingMouseDy = 0;
-      this.pendingMouseTimestampUs = null;
       this.sendReliable(payload);
     };
 
@@ -1867,10 +2422,45 @@ export class GfnWebRtcClient {
         return;
       }
 
-      // Apply user-configured mouse sensitivity multiplier before queuing
-      this.pendingMouseDx += Math.round(this.mouseDeltaFilter.getX() * this.mouseSensitivity);
-      this.pendingMouseDy += Math.round(this.mouseDeltaFilter.getY() * this.mouseSensitivity);
-      this.pendingMouseTimestampUs = timestampUs(eventTimestampMs);
+      // Apply user-configured mouse sensitivity multiplier
+      const scaledX = this.mouseDeltaFilter.getX() * this.mouseSensitivity;
+      const scaledY = this.mouseDeltaFilter.getY() * this.mouseSensitivity;
+
+      // Accumulate fractional deltas in sub-pixel storage (matches official Up/Hp)
+      // This preserves sub-pixel precision across multiple events
+      const roundedX = Math.round(scaledX);
+      const roundedY = Math.round(scaledY);
+
+      // Store fractional remainder for next accumulation
+      this.mouseSubPixelX += scaledX - roundedX;
+      this.mouseSubPixelY += scaledY - roundedY;
+
+      // Remap timestamp to server timebase for synchronization
+      const timestampUs = this.remapTimestampToServer(eventTimestampMs);
+
+      // Queue depth-based rate limiting (matches official client's ql/qc behavior)
+      // When queue is full, coalesce with last event rather than dropping
+      if (this.mouseEventQueue.length >= GfnWebRtcClient.MOUSE_QUEUE_MAX_SIZE) {
+        // Queue full - coalesce with last pending event (sum deltas, use newer timestamp)
+        const lastEvent = this.mouseEventQueue[this.mouseEventQueue.length - 1];
+        lastEvent.dx += roundedX;
+        lastEvent.dy += roundedY;
+        lastEvent.ts = timestampUs;
+        lastEvent.dropped = true; // Mark as coalesced
+
+        // Track high watermark for diagnostics
+        if (this.mouseEventQueue.length > this.mouseQueueHighWatermark) {
+          this.mouseQueueHighWatermark = this.mouseEventQueue.length;
+        }
+        return;
+      }
+
+      // Add to queue
+      this.mouseEventQueue.push({
+        dx: roundedX,
+        dy: roundedY,
+        ts: timestampUs,
+      });
     };
 
     const onPointerMove = (event: PointerEvent) => {
@@ -2158,11 +2748,13 @@ export class GfnWebRtcClient {
         this.log("Window blur during mic permission - keeping keys pressed");
         return;
       }
+      this.log(`Window blur event - document.hidden=${document.hidden}, visibilityState=${document.visibilityState}, video.paused=${this.options.videoElement.paused}`);
       this.clearEscapeHoldTimer();
       this.releasePressedKeys("window blur");
     };
 
     const onVisibilityChange = () => {
+      this.log(`Visibility change event: ${document.visibilityState} - video.paused=${this.options.videoElement.paused}, document.hidden=${document.hidden}`);
       if (document.visibilityState !== "visible") {
         this.clearEscapeHoldTimer();
         this.releasePressedKeys(`visibility ${document.visibilityState}`);
@@ -2483,8 +3075,9 @@ export class GfnWebRtcClient {
 
     const rtcConfig: RTCConfiguration = {
       iceServers: toRtcIceServers(session.iceServers),
-      bundlePolicy: "max-bundle",
+      bundlePolicy: "balanced",
       rtcpMuxPolicy: "require",
+      iceCandidatePoolSize: 4,
     };
 
     const pc = new RTCPeerConnection(rtcConfig);
@@ -2509,6 +3102,10 @@ export class GfnWebRtcClient {
       if (!payload.candidate) {
         return;
       }
+      if (payload.candidate.includes(" tcp ")) {
+        this.log(`Skipping local ICE candidate (tcp): ${payload.candidate}`);
+        return;
+      }
       this.log(`Local ICE candidate: ${payload.candidate}`);
       const candidate: IceCandidatePayload = {
         candidate: payload.candidate,
@@ -2525,6 +3122,15 @@ export class GfnWebRtcClient {
       this.diagnostics.connectionState = pc.connectionState;
       this.emitStats();
       this.log(`Peer connection state: ${pc.connectionState}`);
+      
+      // Enhanced logging for debugging Windows crashes
+      if (pc.connectionState === "disconnected" || pc.connectionState === "failed" || pc.connectionState === "closed") {
+        this.log(`Connection state change to ${pc.connectionState} - video element isConnected=${this.options.videoElement.isConnected}, videoStream.active=${this.videoStream.active}`);
+        const videoTracks = this.videoStream.getTracks();
+        this.log(`Video stream tracks: ${videoTracks.length}, states: ${videoTracks.map(t => `${t.readyState}/${t.muted}`).join(", ") || "none"}`);
+        const audioTracks = this.audioStream.getTracks();
+        this.log(`Audio stream tracks: ${audioTracks.length}, states: ${audioTracks.map(t => `${t.readyState}/${t.muted}`).join(", ") || "none"}`);
+      }
     };
 
     pc.ondatachannel = (event) => {
@@ -2560,6 +3166,11 @@ export class GfnWebRtcClient {
 
     pc.oniceconnectionstatechange = () => {
       this.log(`ICE connection state: ${pc.iceConnectionState}`);
+      // Log ICE connection failures for debugging
+      if (pc.iceConnectionState === "disconnected" || pc.iceConnectionState === "failed" || pc.iceConnectionState === "closed") {
+        this.log(`ICE state ${pc.iceConnectionState} detected - checking data channels`);
+        this.log(`Reliable channel: ${this.reliableInputChannel?.readyState || "null"}, Mouse channel: ${this.mouseInputChannel?.readyState || "null"}`);
+      }
     };
 
     pc.onicegatheringstatechange = () => {
@@ -2644,7 +3255,14 @@ export class GfnWebRtcClient {
     }
 
     if (supported.length > 0 && !supported.includes(settings.codec)) {
-      this.log(`Warning: ${settings.codec} not reported in browser codec list; forcing requested codec anyway`);
+      const fallbackOrder: VideoCodec[] = ["H264", "H265", "AV1"];
+      const fallbackCodec = fallbackOrder.find((codecName) => supported.includes(codecName));
+      if (fallbackCodec) {
+        this.log(`Warning: ${settings.codec} not supported by browser; falling back to ${fallbackCodec}`);
+        effectiveCodec = fallbackCodec;
+      } else {
+        this.log(`Warning: ${settings.codec} not reported in browser codec list; forcing requested codec anyway`);
+      }
     }
     this.log(`Effective codec: ${effectiveCodec} (preferred HEVC profile-id=${preferredHevcProfileId})`);
     const filteredOffer = preferCodec(processedOffer, effectiveCodec, {
@@ -2715,7 +3333,7 @@ export class GfnWebRtcClient {
       }
 
       if (effectiveCodec === "H265" && !hasNegotiatedH265) {
-        throw new Error("H265 requested but not negotiated in local SDP (no H265 rtpmap in answer)");
+        this.log("Warning: H265 requested but not negotiated in local SDP; continuing with negotiated codec");
       }
     }
 
@@ -2820,6 +3438,14 @@ export class GfnWebRtcClient {
   }
 
   dispose(): void {
+    if (this.disposed) {
+      this.log("dispose() called but already disposed - ignoring");
+      return;
+    }
+    this.disposed = true;
+    
+    this.log(`dispose() called - stack trace: ${new Error().stack}`);
+    this.log(`dispose() state: pc=${this.pc ? 'exists' : 'null'}, videoStream.active=${this.videoStream.active}, audioStream.active=${this.audioStream.active}`);
     this.cleanupPeerConnection();
 
     // Cleanup microphone
@@ -2829,11 +3455,14 @@ export class GfnWebRtcClient {
     }
 
     for (const track of this.videoStream.getTracks()) {
+      this.log(`dispose(): removing video track - readyState=${track.readyState}, muted=${track.muted}`);
       this.videoStream.removeTrack(track);
     }
     for (const track of this.audioStream.getTracks()) {
+      this.log(`dispose(): removing audio track - readyState=${track.readyState}, muted=${track.muted}`);
       this.audioStream.removeTrack(track);
     }
+    this.log("dispose() complete");
   }
 
   /**
diff --git a/opennow-stable/src/renderer/src/styles.css b/opennow-stable/src/renderer/src/styles.css
index c291424..ed3703d 100644
--- a/opennow-stable/src/renderer/src/styles.css
+++ b/opennow-stable/src/renderer/src/styles.css
@@ -2210,7 +2210,11 @@ button.game-card-store-chip.active:hover {
   object-fit: contain; display: block;
   position: relative; z-index: 1;
   outline: none;
+  cursor: default;
 }
+
+.sv-video:active,
+.sv-video:focus:active,
 .sv-video:focus,
 .sv-video:focus-visible {
   outline: none;
diff --git a/opennow-stable/src/shared/gfn.ts b/opennow-stable/src/shared/gfn.ts
index 71eed96..c53644f 100644
--- a/opennow-stable/src/shared/gfn.ts
+++ b/opennow-stable/src/shared/gfn.ts
@@ -352,4 +352,8 @@ export interface OpenNowApi {
   exportLogs(format?: "text" | "json"): Promise<string>;
   /** Ping all regions and return latency results */
   pingRegions(regions: StreamRegion[]): Promise<PingResult[]>;
+  /** Start power save blocker to prevent display sleep during streaming */
+  startPowerSaveBlocker(): Promise<void>;
+  /** Stop power save blocker when streaming ends */
+  stopPowerSaveBlocker(): Promise<void>;
 }
diff --git a/opennow-stable/src/shared/ipc.ts b/opennow-stable/src/shared/ipc.ts
index dd79bc2..f89dfc8 100644
--- a/opennow-stable/src/shared/ipc.ts
+++ b/opennow-stable/src/shared/ipc.ts
@@ -28,6 +28,8 @@ export const IPC_CHANNELS = {
   SETTINGS_RESET: "settings:reset",
   LOGS_EXPORT: "logs:export",
   LOGS_GET_RENDERER: "logs:get-renderer",
+  POWER_SAVE_BLOCKER_START: "power-save-blocker:start",
+  POWER_SAVE_BLOCKER_STOP: "power-save-blocker:stop",
 } as const;
 
 export type IpcChannel = (typeof IPC_CHANNELS)[keyof typeof IPC_CHANNELS];