@livedesk/hub 0.1.0 → 0.1.1

package/src/remote-hub.js

@@ -8,7 +8,7 @@ const DEFAULT_HEARTBEAT_MS = 5000;
 const DEFAULT_AGENT_TASK_TIMEOUT_MS = 120000;
 const MAX_LINE_CHARS = 4 * 1024 * 1024;
 const MAX_THUMBNAIL_BASE64_CHARS = 3 * 1024 * 1024;
-const MAX_STREAM_BASE64_CHARS = 3 * 1024 * 1024;
+const MAX_STREAM_BASE64_CHARS = Math.ceil(8 * 1024 * 1024 * 4 / 3);
 const MAX_THUMBNAIL_BINARY_BYTES = Math.floor(MAX_THUMBNAIL_BASE64_CHARS * 3 / 4);
 const MAX_STREAM_BINARY_BYTES = Math.floor(MAX_STREAM_BASE64_CHARS * 3 / 4);
 const MAX_AUDIO_BASE64_CHARS = 1024 * 1024;
@@ -17,17 +17,22 @@ const MAX_AGENT_TASK_CHARS = 4000;
 const MAX_AGENT_TASK_RESULT_CHARS = 3000;
 const RECENT_TASK_LIMIT = 12;
 const RECENT_TASK_BATCH_LIMIT = 16;
-const RECENT_FRAME_CACHE_TTL_MS = 12000;
-const RECENT_THUMBNAIL_FRAME_CACHE_LIMIT = 4;
-const RECENT_LIVE_FRAME_CACHE_LIMIT = 80;
-const RECENT_THUMBNAIL_FRAME_CACHE_MAX_BYTES = 3 * 1024 * 1024;
-const RECENT_LIVE_FRAME_CACHE_MAX_BYTES = 24 * 1024 * 1024;
+const RECENT_FRAME_CACHE_TTL_MS = 4000;
+const RECENT_THUMBNAIL_FRAME_CACHE_LIMIT = 2;
+const RECENT_LIVE_FRAME_CACHE_LIMIT = 1;
+const RECENT_THUMBNAIL_FRAME_CACHE_MAX_BYTES = 2 * 1024 * 1024;
+const RECENT_LIVE_FRAME_CACHE_MAX_BYTES = 8 * 1024 * 1024;
+const LIVE_STREAM_PENDING_REUSE_MS = 5000;
+const LIVE_STREAM_MIN_FRESH_MS = 3000;
+const LIVE_STREAM_MAX_FRESH_MS = 12000;
 const REMOTE_PROTOCOL_VERSION = 2;
 const REMOTE_AGENT_PROTOCOL = 'mindexec.remote.agent';
 const REMOTE_FRAME_PROTOCOL = 'mindexec.remote.frame.v2';
 const REMOTE_FRAME_PROTOCOL_VERSION = 2;
 const REMOTE_FRAME_HANDSHAKE = 'smartview-request-open-frame';
-const DEFAULT_REMOTE_FRAME_MODE = 'remote-fast';
+const DEFAULT_REMOTE_FRAME_MODE = 'mode1-jpeg';
+const TCP_BINARY_FRAME_MAGIC = Buffer.from('LDFB', 'ascii');
+const TCP_BINARY_FRAME_HEADER_BYTES = 12;
 const REMOTE_FRAME_MODE_PROFILES = Object.freeze({
     thumbnail: Object.freeze({
         mode: 'thumbnail',
@@ -40,54 +45,102 @@ const REMOTE_FRAME_MODE_PROFILES = Object.freeze({
         modeVersion: 1,
         implemented: true
     }),
-    'remote-fast': Object.freeze({
-        mode: 'remote-fast',
-        label: 'RemoteFast JPEG Binary',
+    'mode1-jpeg': Object.freeze({
+        mode: 'mode1-jpeg',
+        label: 'Mode 1 - Test JPEG Binary',
         transport: 'ws-binary',
         encoding: 'image',
         codec: 'jpeg',
         compression: 'image/jpeg',
-        profile: 'jpeg-binary-v1',
+        profile: 'mode1-jpeg-binary-v1',
         modeVersion: 1,
         implemented: true
     }),
-    'remote-quality': Object.freeze({
-        mode: 'remote-quality',
-        label: 'RemoteQuality JPEG Binary',
+    'mode2-lzo': Object.freeze({
+        mode: 'mode2-lzo',
+        label: 'Mode 2 - RGB565 LZO Wall',
         transport: 'ws-binary',
-        encoding: 'image',
-        codec: 'jpeg',
-        compression: 'image/jpeg',
-        profile: 'jpeg-quality-binary-v1',
-        modeVersion: 1,
+        encoding: 'image-raw',
+        codec: 'rgb565',
+        compression: 'lzo1x',
+        profile: 'mode2-lzo-rgb565-v1',
+        modeVersion: 2,
         implemented: true
     }),
-    'video-codec': Object.freeze({
-        mode: 'video-codec',
-        label: 'Video Codec Stream',
+    'mode3-h264-hw': Object.freeze({
+        mode: 'mode3-h264-hw',
+        label: 'Mode 3 - Hardware H.264',
         transport: 'ws-binary',
         encoding: 'video',
-        codec: 'video',
-        compression: 'video/*',
-        profile: 'future-video-codec',
-        modeVersion: 0,
-        implemented: false
+        codec: 'h264',
+        compression: 'video/h264',
+        profile: 'mode3-h264-hardware-v1',
+        modeVersion: 3,
+        implemented: true
+    }),
+    'mode5-lzo-delta': Object.freeze({
+        mode: 'mode5-lzo-delta',
+        label: 'Mode 5 - RGB565 Tile Delta LZO',
+        transport: 'ws-binary',
+        encoding: 'image-delta',
+        codec: 'rgb565-delta',
+        compression: 'lzo1x',
+        profile: 'mode5-lzo-rgb565-delta-v1',
+        modeVersion: 5,
+        implemented: true
     })
 });
 const REMOTE_FRAME_MODE_ALIASES = new Map([
-    ['fast', 'remote-fast'],
-    ['remotefast', 'remote-fast'],
-    ['remote_fast', 'remote-fast'],
-    ['remote-fast', 'remote-fast'],
-    ['quality', 'remote-quality'],
-    ['remotequality', 'remote-quality'],
-    ['remote_quality', 'remote-quality'],
-    ['remote-quality', 'remote-quality'],
+    ['1', 'mode1-jpeg'],
+    ['mode1', 'mode1-jpeg'],
+    ['mode-1', 'mode1-jpeg'],
+    ['mode1-jpeg', 'mode1-jpeg'],
+    ['jpeg', 'mode1-jpeg'],
+    ['jpg', 'mode1-jpeg'],
+    ['test', 'mode1-jpeg'],
+    ['fast', 'mode1-jpeg'],
+    ['remotefast', 'mode1-jpeg'],
+    ['remote_fast', 'mode1-jpeg'],
+    ['remote-fast', 'mode1-jpeg'],
+    ['quality', 'mode1-jpeg'],
+    ['remotequality', 'mode1-jpeg'],
+    ['remote_quality', 'mode1-jpeg'],
+    ['remote-quality', 'mode1-jpeg'],
+    ['2', 'mode2-lzo'],
+    ['mode2', 'mode2-lzo'],
+    ['mode-2', 'mode2-lzo'],
+    ['mode2-lzo', 'mode2-lzo'],
+    ['lzo', 'mode2-lzo'],
+    ['lzo1x', 'mode2-lzo'],
+    ['rgb565', 'mode2-lzo'],
+    ['tile-lzo', 'mode2-lzo'],
+    ['tiles-lzo', 'mode2-lzo'],
+    ['mode2-lz4', 'mode2-lzo'],
+    ['lz4', 'mode2-lzo'],
+    ['tile-lz4', 'mode2-lzo'],
+    ['tiles-lz4', 'mode2-lzo'],
+    ['3', 'mode3-h264-hw'],
+    ['mode3', 'mode3-h264-hw'],
+    ['mode-3', 'mode3-h264-hw'],
+    ['mode3-h264', 'mode3-h264-hw'],
+    ['mode3-h264-hw', 'mode3-h264-hw'],
+    ['h264', 'mode3-h264-hw'],
+    ['h264-hw', 'mode3-h264-hw'],
+    ['hardware', 'mode3-h264-hw'],
+    ['hardware-h264', 'mode3-h264-hw'],
+    ['5', 'mode5-lzo-delta'],
+    ['mode5', 'mode5-lzo-delta'],
+    ['mode-5', 'mode5-lzo-delta'],
+    ['mode5-lzo', 'mode5-lzo-delta'],
+    ['mode5-lzo-delta', 'mode5-lzo-delta'],
+    ['lzo-delta', 'mode5-lzo-delta'],
+    ['tile-delta', 'mode5-lzo-delta'],
+    ['control-lzo', 'mode5-lzo-delta'],
     ['thumb', 'thumbnail'],
     ['thumbnail', 'thumbnail'],
-    ['video', 'video-codec'],
-    ['codec', 'video-codec'],
-    ['video-codec', 'video-codec']
+    ['video', 'mode3-h264-hw'],
+    ['codec', 'mode3-h264-hw'],
+    ['video-codec', 'mode3-h264-hw']
 ]);
 const MAX_SYNTHETIC_DEVICES = 1000;
 const DEFAULT_HOST_TARGET_LEASE_MS = 30000;
@@ -96,6 +149,9 @@ const DEFAULT_PUBLIC_IP_TIMEOUT_MS = 1800;
 const DUPLICATE_DEVICE_ACTIVE_REJECT_MS = 15000;
 const DUPLICATE_DEVICE_LOG_THROTTLE_MS = 60000;
 const DUPLICATE_DEVICE_RETRY_AFTER_MS = 30000;
+const AGENT_BINARY_INGRESS_QUEUE_PACKETS = 256;
+const MODE5_AGENT_BINARY_INGRESS_QUEUE_PACKETS = 2;
+const AGENT_BINARY_INGRESS_DRAIN_BUDGET_PACKETS = 64;
 const SYNTHETIC_FRAME_DATA_URL = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAIAAAABCAYAAAD0In+KAAAADElEQVR42mP8z8AAAAMBAQDJ/pLvAAAAAElFTkSuQmCC';
 const SYNTHETIC_FRAME_PAYLOAD = Buffer.from(SYNTHETIC_FRAME_DATA_URL.split(',')[1], 'base64');
 const SYNTHETIC_FRAME_HASH = crypto.createHash('sha256').update(SYNTHETIC_FRAME_PAYLOAD).digest('hex').slice(0, 16);
@@ -134,7 +190,11 @@ function safeString(value, maxLength = 200) {
     return String(value ?? '').replace(/[\r\n\t]/g, ' ').trim().slice(0, maxLength);
 }
 
-function normalizeRemoteFrameMode(value, fallback = DEFAULT_REMOTE_FRAME_MODE) {
+function generatePairingPin() {
+    return crypto.randomInt(0, 1000000).toString().padStart(6, '0');
+}
+
+function normalizeRemoteFrameMode(value, fallback = DEFAULT_REMOTE_FRAME_MODE, { allowUnimplemented = false } = {}) {
     const requested = safeString(value, 80).toLowerCase();
     const fallbackMode = REMOTE_FRAME_MODE_PROFILES[fallback] ? fallback : DEFAULT_REMOTE_FRAME_MODE;
     if (!requested) {
@@ -143,7 +203,7 @@ function normalizeRemoteFrameMode(value, fallback = DEFAULT_REMOTE_FRAME_MODE) {
 
     const normalized = REMOTE_FRAME_MODE_ALIASES.get(requested) || requested;
     const profile = REMOTE_FRAME_MODE_PROFILES[normalized];
-    if (!profile || profile.implemented !== true) {
+    if (!profile || (!allowUnimplemented && profile.implemented !== true)) {
         return fallbackMode;
     }
 
@@ -164,14 +224,13 @@ function serializeRemoteFrameModeProfile(profile) {
     };
 }
 
-function getRemoteFrameModeProfile(value, fallback = DEFAULT_REMOTE_FRAME_MODE) {
-    const mode = normalizeRemoteFrameMode(value, fallback);
+function getRemoteFrameModeProfile(value, fallback = DEFAULT_REMOTE_FRAME_MODE, options = {}) {
+    const mode = normalizeRemoteFrameMode(value, fallback, options);
     return serializeRemoteFrameModeProfile(REMOTE_FRAME_MODE_PROFILES[mode]);
 }
 
 function getSupportedRemoteFrameModeProfiles() {
     return Object.values(REMOTE_FRAME_MODE_PROFILES)
-        .filter(profile => profile.implemented === true)
         .map(serializeRemoteFrameModeProfile);
 }
 
@@ -222,14 +281,14 @@ function normalizeIncomingFrameModeProfile(value) {
     }
 
     if (typeof value === 'string') {
-        return getRemoteFrameModeProfile(value);
+        return getRemoteFrameModeProfile(value, DEFAULT_REMOTE_FRAME_MODE, { allowUnimplemented: true });
     }
 
     if (typeof value !== 'object') {
         return null;
     }
 
-    const profile = buildRemoteFrameTransferDescriptor(value.mode || value.frameMode || value.profile);
+    const profile = getRemoteFrameModeProfile(value.mode || value.frameMode || value.profile, DEFAULT_REMOTE_FRAME_MODE, { allowUnimplemented: true });
     return {
         mode: profile.mode,
         label: safeString(value.label, 80) || profile.mode,
@@ -452,6 +511,10 @@ function normalizeSlotNumber(value) {
     return Number.isInteger(number) && number >= 1 && number <= 999 ? number : 0;
 }
 
+function normalizeMonitorIndex(value) {
+    return clampNumber(value, 0, 63, 0);
+}
+
 function parseManagerEndpoint(value) {
     const endpoint = safeString(value, 256);
     const match = endpoint.match(/^(\[[^\]]+\]|[^:\s]+):(\d{1,5})$/);
@@ -505,8 +568,15 @@ function normalizeRemoteInputEvent(value = {}) {
     const normalizedY = Number(input.normalizedY ?? input.NormalizedY);
     const deltaX = Number(input.deltaX ?? input.DeltaX);
     const deltaY = Number(input.deltaY ?? input.DeltaY);
+    const keyCode = Number(input.keyCode ?? input.KeyCode);
+    const location = Number(input.location ?? input.Location);
+    const monitorIndex = Number(input.monitorIndex ?? input.MonitorIndex ?? input.screenIndex ?? input.ScreenIndex ?? input.displayIndex ?? input.DisplayIndex);
+    const inputSeq = Number(input.inputSeq ?? input.InputSeq);
+    const issuedAtEpochMs = Number(input.issuedAtEpochMs ?? input.IssuedAtEpochMs);
+    const hubReceivedAtEpochMs = Number(input.hubReceivedAtEpochMs ?? input.HubReceivedAtEpochMs);
     return {
         type,
+        monitorIndex: Number.isFinite(monitorIndex) ? normalizeMonitorIndex(monitorIndex) : 0,
         normalizedX: Number.isFinite(normalizedX) ? Math.max(0, Math.min(1, normalizedX)) : undefined,
         normalizedY: Number.isFinite(normalizedY) ? Math.max(0, Math.min(1, normalizedY)) : undefined,
         button: safeString(input.button || input.Button, 24),
@@ -514,9 +584,19 @@ function normalizeRemoteInputEvent(value = {}) {
         deltaY: Number.isFinite(deltaY) ? Math.max(-4096, Math.min(4096, deltaY)) : 0,
         key: safeString(input.key || input.Key, 80),
         code: safeString(input.code || input.Code, 80),
+        keyCode: Number.isFinite(keyCode) ? Math.max(0, Math.min(65535, Math.trunc(keyCode))) : 0,
+        location: Number.isFinite(location) ? Math.max(0, Math.min(255, Math.trunc(location))) : 0,
         text: safeText(input.text || input.Text, 256),
         repeat: input.repeat === true || input.Repeat === true,
+        shiftKey: input.shiftKey === true || input.ShiftKey === true,
+        ctrlKey: input.ctrlKey === true || input.ControlKey === true || input.CtrlKey === true,
+        altKey: input.altKey === true || input.AltKey === true,
+        metaKey: input.metaKey === true || input.MetaKey === true || input.commandKey === true || input.CommandKey === true,
         controlLeaseId: safeString(input.controlLeaseId || input.ControlLeaseId, 128),
+        inputSeq: Number.isSafeInteger(inputSeq) && inputSeq > 0 ? inputSeq : 0,
+        requestAck: input.requestAck !== false && input.RequestAck !== false,
+        issuedAtEpochMs: Number.isFinite(issuedAtEpochMs) ? issuedAtEpochMs : 0,
+        hubReceivedAtEpochMs: Number.isFinite(hubReceivedAtEpochMs) ? hubReceivedAtEpochMs : 0,
         issuedAt: safeString(input.issuedAt || input.IssuedAt, 80)
     };
 }
@@ -811,6 +891,13 @@ function serializeDevice(device, options = {}) {
         lastDisconnectReason: device.lastDisconnectReason,
         remoteAddress: device.remoteAddress,
         remotePort: device.remotePort,
+        channels: {
+            control: !!device.socket && !device.socket.destroyed,
+            input: !!device.inputSocket && !device.inputSocket.destroyed,
+            frame: !!device.frameSocket && !device.frameSocket.destroyed,
+            audio: !!device.audioSocket && !device.audioSocket.destroyed,
+            file: !!device.fileSocket && !device.fileSocket.destroyed
+        },
         latestThumbnail: serializeRemoteFrame(device.latestThumbnail, device.deviceId, 'thumbnail', options),
         latestLiveFrame: serializeRemoteFrame(device.latestLiveFrame, device.deviceId, 'live', options),
         activeLiveStream: device.activeLiveStream ? { ...device.activeLiveStream } : null,
@@ -958,6 +1045,112 @@ function parseRemoteHubWebSocketBinaryFrame(buffer) {
     return { header, payload };
 }
 
+function hasTcpBinaryFrameMagicPrefix(buffer) {
+    if (!Buffer.isBuffer(buffer) || buffer.length <= 0 || buffer.length > TCP_BINARY_FRAME_MAGIC.length) {
+        return false;
+    }
+
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (buffer[index] !== TCP_BINARY_FRAME_MAGIC[index]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+function startsWithTcpBinaryFrameMagic(buffer) {
+    return Buffer.isBuffer(buffer)
+        && buffer.length >= TCP_BINARY_FRAME_MAGIC.length
+        && buffer.subarray(0, TCP_BINARY_FRAME_MAGIC.length).equals(TCP_BINARY_FRAME_MAGIC);
+}
+
+function isJsonObjectStartByte(value) {
+    return value === 0x7b;
+}
+
+function isWhitespaceByte(value) {
+    return value === 0x20 || value === 0x09 || value === 0x0d || value === 0x0a;
+}
+
+function findFirstNonWhitespaceByte(buffer) {
+    if (!Buffer.isBuffer(buffer)) {
+        return -1;
+    }
+
+    for (let index = 0; index < buffer.length; index += 1) {
+        if (!isWhitespaceByte(buffer[index])) {
+            return index;
+        }
+    }
+    return -1;
+}
+
+function findTcpFrameOnlySyncIndex(buffer, startIndex = 0) {
+    if (!Buffer.isBuffer(buffer) || buffer.length <= 0) {
+        return -1;
+    }
+
+    const safeStart = Math.max(0, Math.min(buffer.length, Math.floor(Number(startIndex) || 0)));
+    const magicIndex = buffer.indexOf(TCP_BINARY_FRAME_MAGIC, safeStart);
+    const jsonIndex = buffer.indexOf(0x7b, safeStart);
+    if (magicIndex < 0) {
+        return jsonIndex;
+    }
+    if (jsonIndex < 0) {
+        return magicIndex;
+    }
+    return Math.min(magicIndex, jsonIndex);
+}
+
+function keepTcpFrameOnlySyncTail(buffer) {
+    if (!Buffer.isBuffer(buffer) || buffer.length <= 0) {
+        return Buffer.alloc(0);
+    }
+
+    const maxTailLength = Math.min(buffer.length, TCP_BINARY_FRAME_MAGIC.length - 1);
+    for (let tailLength = maxTailLength; tailLength > 0; tailLength -= 1) {
+        const tail = buffer.subarray(buffer.length - tailLength);
+        if (hasTcpBinaryFrameMagicPrefix(tail)) {
+            return tail;
+        }
+    }
+    return Buffer.alloc(0);
+}
+
+function parseTcpBinaryFramePacket(buffer) {
+    if (!Buffer.isBuffer(buffer) || buffer.length < TCP_BINARY_FRAME_HEADER_BYTES) {
+        return { incomplete: true };
+    }
+    if (!startsWithTcpBinaryFrameMagic(buffer)) {
+        return null;
+    }
+
+    const metaLength = buffer.readUInt32BE(4);
+    const payloadLength = buffer.readUInt32BE(8);
+    const maxPayloadBytes = Math.max(MAX_THUMBNAIL_BINARY_BYTES, MAX_STREAM_BINARY_BYTES, MAX_AUDIO_BINARY_BYTES);
+    if (!Number.isFinite(metaLength)
+        || !Number.isFinite(payloadLength)
+        || metaLength <= 0
+        || metaLength > 64 * 1024
+        || payloadLength <= 0
+        || payloadLength > maxPayloadBytes) {
+        return { invalid: true, reason: 'invalid-tcp-binary-frame-size' };
+    }
+
+    const packetLength = TCP_BINARY_FRAME_HEADER_BYTES + metaLength + payloadLength;
+    if (buffer.length < packetLength) {
+        return { incomplete: true };
+    }
+
+    try {
+        const header = JSON.parse(buffer.subarray(TCP_BINARY_FRAME_HEADER_BYTES, TCP_BINARY_FRAME_HEADER_BYTES + metaLength).toString('utf8'));
+        const payload = buffer.subarray(TCP_BINARY_FRAME_HEADER_BYTES + metaLength, packetLength);
+        return { header, payload, packetLength };
+    } catch (err) {
+        return { invalid: true, reason: err?.message || 'invalid-tcp-binary-frame-header' };
+    }
+}
+
 class RemoteHubWebSocketAgentSocket {
     constructor(socket) {
         this.__remoteHubWebSocket = true;
@@ -973,9 +1166,21 @@ class RemoteHubWebSocketAgentSocket {
         this.onCloseMessage = () => {};
     }
 
-    setNoDelay() {}
+    setNoDelay(value = true) {
+        try {
+            this.socket?.setNoDelay?.(value);
+        } catch {
+            // Best-effort latency hint.
+        }
+    }
 
-    setKeepAlive() {}
+    setKeepAlive(value = true, initialDelay = 0) {
+        try {
+            this.socket?.setKeepAlive?.(value, initialDelay);
+        } catch {
+            // Best-effort connection liveness hint.
+        }
+    }
 
     sendJson(payload) {
         return this.sendText(JSON.stringify(payload));
@@ -1153,6 +1358,10 @@ export function createRemoteHub(options = {}) {
     const pairToken = safeString(
         options.pairToken || env.REMOTE_HUB_PAIR_TOKEN || env.LIVEDESK_CLIENT_PAIR_TOKEN || env.MINDEXEC_REMOTE_PAIR_TOKEN || crypto.randomBytes(6).toString('hex'),
         256);
+    let pairingPin = /^\d{6}$/.test(String(options.pairingPin || env.LIVEDESK_PAIRING_PIN || '').trim())
+        ? String(options.pairingPin || env.LIVEDESK_PAIRING_PIN).trim()
+        : generatePairingPin();
+    let pairingPinUpdatedAt = new Date().toISOString();
     const duplicateDeviceLogThrottleMs = clampNumber(
         env.MINDEXEC_REMOTE_DUPLICATE_DEVICE_LOG_MS || env.REMOTE_HUB_DUPLICATE_DEVICE_LOG_MS,
         5000,
@@ -1167,6 +1376,10 @@ export function createRemoteHub(options = {}) {
     const devices = new Map();
     const taskBatches = new Map();
     const sockets = new Map();
+    const inputSockets = new Map();
+    const frameSockets = new Map();
+    const audioSockets = new Map();
+    const fileSockets = new Map();
     const allSockets = new Set();
     const duplicateDeviceLogAt = new Map();
     let server = null;
@@ -1485,6 +1698,8 @@ export function createRemoteHub(options = {}) {
             agentEndpointCandidateDetails: routeInfo.candidateDetails,
             pairToken: includeSecrets ? pairToken : undefined,
             pairTokenPreview: maskToken(pairToken),
+            pairingPin: includeSecrets ? pairingPin : '',
+            pairingPinUpdatedAt,
             deviceCount: devices.size,
             connectedDeviceCount: connectedDevices,
             canvasDeviceListMode: 'all-devices',
@@ -1506,6 +1721,19 @@ export function createRemoteHub(options = {}) {
         };
     }
 
+    function rotatePairingPin() {
+        pairingPin = generatePairingPin();
+        pairingPinUpdatedAt = new Date().toISOString();
+        emitRemoteEvent('RemotePairingPinRotated', null, {
+            pairingPinUpdatedAt
+        });
+        return {
+            ok: true,
+            pairingPin,
+            pairingPinUpdatedAt
+        };
+    }
+
     function listDevices(options = {}) {
         const serializeOptions = {
             includeDataUrl: options.includeDataUrl === true
@@ -1593,8 +1821,8 @@ export function createRemoteHub(options = {}) {
             streamId: safeString(streamId, 128) || `${mode}-${Date.now()}`,
             frameSeq,
             commandId: safeString(options.commandId, 128),
-            width: clampNumber(options.width, 2, 2560, mode === 'remote-fast' ? 960 : 360),
-            height: clampNumber(options.height, 1, 1440, mode === 'remote-fast' ? 540 : 220),
+            width: clampNumber(options.width, 2, 3840, mode === 'thumbnail' ? 360 : 640),
+            height: clampNumber(options.height, 1, 2160, mode === 'thumbnail' ? 220 : 360),
             mimeType: 'image/png',
             format: 'image/png',
             mode,
@@ -1606,7 +1834,7 @@ export function createRemoteHub(options = {}) {
             transferProtocol: descriptor.transferProtocol,
             transferProtocolVersion: descriptor.transferProtocolVersion,
             handshake: descriptor.handshake,
-            fps: clampNumber(options.fps, 1, 24, mode === 'remote-fast' ? 20 : 1),
+            fps: clampNumber(options.fps, 1, 20, mode === 'thumbnail' ? 1 : 2),
             capturedAt: now,
             receivedAt: now,
             byteLength: 68,
@@ -1614,6 +1842,8 @@ export function createRemoteHub(options = {}) {
             contentHash: SYNTHETIC_FRAME_HASH,
             captureMs: 0,
             sameContentStreak: 0,
+            monitorIndex: normalizeMonitorIndex(options.monitorIndex ?? 0),
+            monitorCount: clampNumber(options.monitorCount, 1, 64, 1),
             dataUrl: SYNTHETIC_FRAME_DATA_URL,
             payload: SYNTHETIC_FRAME_PAYLOAD,
             accessToken: createFrameAccessToken()
@@ -1646,15 +1876,18 @@ export function createRemoteHub(options = {}) {
     }
 
     function applySyntheticLiveFrame(device, streamId, options = {}) {
-        if (!device?.activeLiveStream?.active) {
+        const streamState = getDeviceLiveStream(device, streamId);
+        if (!streamState?.active) {
             return null;
         }
 
-        const frame = makeSyntheticFrame(device, streamId || device.activeLiveStream.streamId, device.activeLiveStream.mode || DEFAULT_REMOTE_FRAME_MODE, {
-            commandId: options.commandId || device.activeLiveStream.commandId,
+        const frame = makeSyntheticFrame(device, streamId || streamState.streamId, streamState.mode || DEFAULT_REMOTE_FRAME_MODE, {
+            commandId: options.commandId || streamState.commandId,
             width: options.maxWidth || 960,
             height: options.maxHeight || 540,
-            fps: options.fps || device.activeLiveStream.fps
+            monitorIndex: options.monitorIndex ?? streamState.monitorIndex ?? 0,
+            monitorCount: options.monitorCount ?? streamState.monitorCount ?? 1,
+            fps: options.fps || streamState.fps
         });
         device.latestLiveFrame = frame;
         rememberRecentFramePayload(device, 'live', frame);
@@ -1666,9 +1899,10 @@ export function createRemoteHub(options = {}) {
             mimeType: frame.mimeType,
             byteLength: frame.byteLength
         });
-        device.activeLiveStream.lastFrameAt = frame.receivedAt;
-        device.activeLiveStream.lastFrameSeq = frame.frameSeq;
-        device.activeLiveStream.framesReceived = (device.activeLiveStream.framesReceived || 0) + 1;
+        streamState.latestFrame = frame;
+        streamState.lastFrameAt = frame.receivedAt;
+        streamState.lastFrameSeq = frame.frameSeq;
+        streamState.framesReceived = (streamState.framesReceived || 0) + 1;
         device.lastSeenAt = frame.receivedAt;
         device.counters.liveFramesReceived += 1;
         emitRemoteEvent('RemoteFrameReceived', device, {
@@ -1681,6 +1915,10 @@ export function createRemoteHub(options = {}) {
 
     function closeExistingDeviceSocket(deviceId, nextSessionId) {
         const existing = devices.get(deviceId);
+        closeInputSocket(existing, 'replaced-by-new-session');
+        closeFrameSocket(existing, 'replaced-by-new-session');
+        closeAudioSocket(existing, 'replaced-by-new-session');
+        closeFileSocket(existing, 'replaced-by-new-session');
         if (!existing?.socket || existing.socket.destroyed) {
             return;
         }
@@ -1695,6 +1933,154 @@ export function createRemoteHub(options = {}) {
         existing.socket.destroy();
     }
 
+    function closeFrameSocket(device, reason = 'frame-socket-closed') {
+        const socket = device?.frameSocket;
+        if (!socket) {
+            return;
+        }
+
+        device.frameSocket = null;
+        frameSockets.delete(socket);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', channel: 'frame', reason });
+        } catch {
+            // Best-effort notice before closing the side channel.
+        }
+        try {
+            socket.destroy?.();
+        } catch {
+            // Ignore close failures.
+        }
+    }
+
+    function closeAudioSocket(device, reason = 'audio-socket-closed') {
+        const socket = device?.audioSocket;
+        if (!socket) {
+            return;
+        }
+
+        device.audioSocket = null;
+        audioSockets.delete(socket);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', channel: 'audio', reason });
+        } catch {
+            // Best-effort notice before closing the side channel.
+        }
+        try {
+            socket.destroy?.();
+        } catch {
+            // Ignore close failures.
+        }
+    }
+
+    function closeFileSocket(device, reason = 'file-socket-closed') {
+        const socket = device?.fileSocket;
+        if (!socket) {
+            return;
+        }
+
+        device.fileSocket = null;
+        fileSockets.delete(socket);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', channel: 'file', reason });
+        } catch {
+            // Best-effort notice before closing the side channel.
+        }
+        try {
+            socket.destroy?.();
+        } catch {
+            // Ignore close failures.
+        }
+    }
+
+    function closeInputSocket(device, reason = 'input-socket-closed') {
+        const socket = device?.inputSocket;
+        if (!socket) {
+            return;
+        }
+
+        device.inputSocket = null;
+        inputSockets.delete(socket);
+        try {
+            writeJsonLine(socket, { type: 'disconnect', reason });
+        } catch {
+            // Best-effort notice before closing the side channel.
+        }
+        try {
+            socket.destroy?.();
+        } catch {
+            // Ignore close failures.
+        }
+    }
+
+    function detachInputSocket(socket, reason = 'input-socket-closed') {
+        const deviceId = inputSockets.get(socket);
+        inputSockets.delete(socket);
+        if (!deviceId) {
+            return;
+        }
+
+        const device = devices.get(deviceId);
+        if (!device || device.inputSocket !== socket) {
+            return;
+        }
+
+        device.inputSocket = null;
+        device.inputLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteInputSocketDisconnected', device, { reason });
+    }
+
+    function detachFrameSocket(socket, reason = 'frame-socket-closed') {
+        const deviceId = frameSockets.get(socket);
+        frameSockets.delete(socket);
+        if (!deviceId) {
+            return;
+        }
+
+        const device = devices.get(deviceId);
+        if (!device || device.frameSocket !== socket) {
+            return;
+        }
+
+        device.frameSocket = null;
+        device.frameLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteFrameSocketDisconnected', device, { reason });
+    }
+
+    function detachAudioSocket(socket, reason = 'audio-socket-closed') {
+        const deviceId = audioSockets.get(socket);
+        audioSockets.delete(socket);
+        if (!deviceId) {
+            return;
+        }
+
+        const device = devices.get(deviceId);
+        if (!device || device.audioSocket !== socket) {
+            return;
+        }
+
+        device.audioSocket = null;
+        device.audioLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteAudioSocketDisconnected', device, { reason });
+    }
+
+    function detachFileSocket(socket, reason = 'file-socket-closed') {
+        const deviceId = fileSockets.get(socket);
+        fileSockets.delete(socket);
+        if (!deviceId) {
+            return;
+        }
+
+        const device = devices.get(deviceId);
+        if (!device || device.fileSocket !== socket) {
+            return;
+        }
+
+        device.fileSocket = null;
+        device.fileLastSeenAt = new Date().toISOString();
+        emitRemoteEvent('RemoteFileSocketDisconnected', device, { reason });
+    }
+
     function getDeviceActivityMs(device) {
         return Math.max(
             Date.parse(device?.lastSeenAt || '') || 0,
@@ -2003,7 +2389,7 @@ export function createRemoteHub(options = {}) {
                     transferProtocol: transfer.transferProtocol,
                     transferProtocolVersion: transfer.transferProtocolVersion,
                     handshake: transfer.handshake,
-                    fps: 20,
+                    fps: 2,
                     startedAt: seenAt,
                     stoppedAt: '',
                     stopReason: '',
@@ -2013,7 +2399,7 @@ export function createRemoteHub(options = {}) {
                 };
                 applySyntheticLiveFrame(device, device.activeLiveStream.streamId, {
                     commandId: device.activeLiveStream.commandId,
-                    fps: 20
+                    fps: 2
                 });
                 live += 1;
             }
@@ -2079,6 +2465,10 @@ export function createRemoteHub(options = {}) {
 
         const device = {
             socket,
+            inputSocket: null,
+            frameSocket: null,
+            audioSocket: null,
+            fileSocket: null,
             deviceId,
             sessionId,
             deviceName: safeString(hello.deviceName || hello.hostname || deviceId, 120),
@@ -2095,6 +2485,14 @@ export function createRemoteHub(options = {}) {
             capabilities,
             connected: true,
             connectedAt: now,
+            inputConnectedAt: '',
+            inputLastSeenAt: '',
+            frameConnectedAt: '',
+            frameLastSeenAt: '',
+            audioConnectedAt: '',
+            audioLastSeenAt: '',
+            fileConnectedAt: '',
+            fileLastSeenAt: '',
             disconnectedAt: '',
             lastSeenAt: now,
             lastStatusAt: '',
@@ -2138,6 +2536,126 @@ export function createRemoteHub(options = {}) {
         return device;
     }
 
+    function attachInputSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
+            socket.destroy();
+            return null;
+        }
+
+        closeInputSocket(device, 'replaced-by-new-input-socket');
+
+        const now = new Date().toISOString();
+        device.inputSocket = socket;
+        device.inputConnectedAt = now;
+        device.inputLastSeenAt = now;
+        inputSockets.set(socket, deviceId);
+
+        writeJsonLine(socket, {
+            type: 'welcome',
+            channel: 'input',
+            protocol: REMOTE_AGENT_PROTOCOL,
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: device.sessionId,
+            deviceId,
+            serverTime: now
+        });
+
+        emitRemoteEvent('RemoteInputSocketConnected', device);
+        return device;
+    }
+
+    function attachFrameSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
+            socket.destroy();
+            return null;
+        }
+
+        closeFrameSocket(device, 'replaced-by-new-frame-socket');
+
+        const now = new Date().toISOString();
+        device.frameSocket = socket;
+        device.frameConnectedAt = now;
+        device.frameLastSeenAt = now;
+        frameSockets.set(socket, deviceId);
+
+        writeJsonLine(socket, {
+            type: 'welcome',
+            channel: 'frame',
+            protocol: REMOTE_AGENT_PROTOCOL,
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: device.sessionId,
+            deviceId,
+            frameProtocol: buildRemoteFrameProtocolDescriptor(),
+            frameModes: getSupportedRemoteFrameModeProfiles(),
+            serverTime: now
+        });
+
+        emitRemoteEvent('RemoteFrameSocketConnected', device);
+        return device;
+    }
+
+    function attachAudioSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
+            socket.destroy();
+            return null;
+        }
+
+        closeAudioSocket(device, 'replaced-by-new-audio-socket');
+        const now = new Date().toISOString();
+        device.audioSocket = socket;
+        device.audioConnectedAt = now;
+        device.audioLastSeenAt = now;
+        audioSockets.set(socket, deviceId);
+        writeJsonLine(socket, {
+            type: 'welcome',
+            channel: 'audio',
+            protocol: REMOTE_AGENT_PROTOCOL,
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: device.sessionId,
+            deviceId,
+            serverTime: now
+        });
+        emitRemoteEvent('RemoteAudioSocketConnected', device);
+        return device;
+    }
+
+    function attachFileSocket(socket, hello) {
+        const deviceId = normalizeDeviceId(hello.deviceId);
+        const device = devices.get(deviceId);
+        if (!device || !device.connected || !device.socket || device.socket.destroyed) {
+            writeJsonLine(socket, { type: 'error', error: 'device-not-connected' });
+            socket.destroy();
+            return null;
+        }
+
+        closeFileSocket(device, 'replaced-by-new-file-socket');
+        const now = new Date().toISOString();
+        device.fileSocket = socket;
+        device.fileConnectedAt = now;
+        device.fileLastSeenAt = now;
+        fileSockets.set(socket, deviceId);
+        writeJsonLine(socket, {
+            type: 'welcome',
+            channel: 'file',
+            protocol: REMOTE_AGENT_PROTOCOL,
+            protocolVersion: REMOTE_PROTOCOL_VERSION,
+            sessionId: device.sessionId,
+            deviceId,
+            serverTime: now
+        });
+        emitRemoteEvent('RemoteFileSocketConnected', device);
+        return device;
+    }
+
     function detachSocket(socket, reason = 'socket-closed') {
         const deviceId = sockets.get(socket);
         sockets.delete(socket);
@@ -2152,13 +2670,11 @@ export function createRemoteHub(options = {}) {
 
         device.connected = false;
         device.socket = null;
+        closeInputSocket(device, reason);
+        closeFrameSocket(device, reason);
         device.disconnectedAt = new Date().toISOString();
         device.lastDisconnectReason = reason;
-        if (device.activeLiveStream) {
-            device.activeLiveStream.active = false;
-            device.activeLiveStream.stoppedAt = device.disconnectedAt;
-            device.activeLiveStream.stopReason = reason;
-        }
+        deactivateDeviceLiveStreams(device, reason, device.disconnectedAt);
         failAllPendingTasks(device, 'device-disconnected');
         logWarn('remote', `device disconnected ${device.deviceName} (${deviceId}): ${reason}`);
         emitRemoteEvent('RemoteDeviceDisconnected', device, { reason });
@@ -2500,7 +3016,7 @@ export function createRemoteHub(options = {}) {
 
     function buildFramePayloadBuffer(framePayload, frameData) {
         if (Buffer.isBuffer(framePayload)) {
-            return Buffer.from(framePayload);
+            return framePayload;
         }
 
         const raw = String(frameData || '');
@@ -2534,6 +3050,13 @@ export function createRemoteHub(options = {}) {
             : 0;
     }
 
+    function readFrameStageMs(message, property) {
+        const value = Number(message?.[property]);
+        return Number.isFinite(value) && value >= 0
+            ? Math.round(value)
+            : 0;
+    }
+
     function computeSameContentStreak(previousFrame, contentHash) {
         if (!contentHash || !previousFrame?.contentHash || previousFrame.contentHash !== contentHash) {
             return 0;
@@ -2572,6 +3095,8 @@ export function createRemoteHub(options = {}) {
             commandId: safeString(message.commandId, 128),
             width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
             height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
+            sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(message.width || 0),
+            sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(message.height || 0),
             mimeType,
             format: mimeType,
             frameMode: transfer.frameMode,
@@ -2579,6 +3104,24 @@ export function createRemoteHub(options = {}) {
             encoding: transfer.encoding,
             codec: transfer.codec,
             compression: transfer.compression || mimeType,
+            pixelFormat: safeString(message.pixelFormat, 40),
+            bytesPerPixel: Number.isFinite(Number(message.bytesPerPixel)) ? Number(message.bytesPerPixel) : 0,
+            uncompressedByteLength: Number.isFinite(Number(message.uncompressedByteLength)) ? Number(message.uncompressedByteLength) : 0,
+            h264Format: safeString(message.h264Format, 40),
+            isKeyFrame: message.isKeyFrame === true || safeString(message.chunkType, 20).toLowerCase() === 'key',
+            chunkType: safeString(message.chunkType, 20),
+            timestampUs: Number.isFinite(Number(message.timestampUs)) ? Number(message.timestampUs) : 0,
+            durationUs: Number.isFinite(Number(message.durationUs)) ? Number(message.durationUs) : 0,
+            sourceGapMs: Number.isFinite(Number(message.sourceGapMs)) ? Number(message.sourceGapMs) : 0,
+            agentSendGapMs: Number.isFinite(Number(message.agentSendGapMs)) ? Number(message.agentSendGapMs) : 0,
+            agentSendDurationMs: Number.isFinite(Number(message.agentSendDurationMs)) ? Number(message.agentSendDurationMs) : 0,
+            agentSendDurationFrameSeq: Number.isFinite(Number(message.agentSendDurationFrameSeq)) ? Number(message.agentSendDurationFrameSeq) : 0,
+            agentPaceMs: Number.isFinite(Number(message.agentPaceMs)) ? Number(message.agentPaceMs) : 0,
+            agentQueueBeforePaceMs: Number.isFinite(Number(message.agentQueueBeforePaceMs)) ? Number(message.agentQueueBeforePaceMs) : 0,
+            agentFrameAgeMs: Number.isFinite(Number(message.agentFrameAgeMs)) ? Number(message.agentFrameAgeMs) : 0,
+            droppedByAgent: Number.isFinite(Number(message.droppedByAgent)) ? Number(message.droppedByAgent) : 0,
+            hardwareEncoder: safeString(message.hardwareEncoder, 80),
+            platformProfile: safeString(message.platformProfile, 80),
             transferProtocol: transfer.transferProtocol,
             transferProtocolVersion: transfer.transferProtocolVersion,
             handshake: transfer.handshake,
@@ -2588,6 +3131,16 @@ export function createRemoteHub(options = {}) {
             transport,
             contentHash,
             captureMs: readFrameCaptureMs(message),
+            captureStageMs: readFrameStageMs(message, 'captureStageMs'),
+            convertMs: readFrameStageMs(message, 'convertMs'),
+            compressMs: readFrameStageMs(message, 'compressMs'),
+            captureSourceSerial: Number.isFinite(Number(message.captureSourceSerial)) ? Number(message.captureSourceSerial) : 0,
+            captureSourceSkipped: Number.isFinite(Number(message.captureSourceSkipped)) ? Number(message.captureSourceSkipped) : 0,
+            deltaTileSize: Number.isFinite(Number(message.deltaTileSize)) ? Number(message.deltaTileSize) : 0,
+            deltaTileCount: Number.isFinite(Number(message.deltaTileCount)) ? Number(message.deltaTileCount) : 0,
+            deltaVisualTileCount: Number.isFinite(Number(message.deltaVisualTileCount)) ? Number(message.deltaVisualTileCount) : 0,
+            deltaRefreshTileCount: Number.isFinite(Number(message.deltaRefreshTileCount)) ? Number(message.deltaRefreshTileCount) : 0,
+            deltaTotalTiles: Number.isFinite(Number(message.deltaTotalTiles)) ? Number(message.deltaTotalTiles) : 0,
             sameContentStreak,
             payload,
             accessToken: createFrameAccessToken()
@@ -2608,7 +3161,8 @@ export function createRemoteHub(options = {}) {
 
     function applyLiveStreamOpen(device, message, transport = 'json') {
         const streamId = safeString(message.streamId, 128) || 'live';
-        if (!device.activeLiveStream?.active || device.activeLiveStream.streamId !== streamId) {
+        const streamState = getDeviceLiveStream(device, streamId);
+        if (!streamState?.active) {
             emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
                 reason: 'stale-live-stream-open',
                 streamId,
@@ -2617,10 +3171,23 @@ export function createRemoteHub(options = {}) {
             return false;
         }
 
-        const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, device.activeLiveStream.mode || DEFAULT_REMOTE_FRAME_MODE);
+        const commandId = safeString(message.commandId, 128);
+        const activeCommandId = safeString(streamState.commandId, 128);
+        if (commandId && activeCommandId && commandId !== activeCommandId) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'stale-live-stream-generation',
+                streamId,
+                commandId,
+                activeCommandId,
+                transport
+            });
+            return false;
+        }
+
+        const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, streamState.mode || DEFAULT_REMOTE_FRAME_MODE);
         const openedAt = safeString(message.openedAt, 80) || device.lastSeenAt || new Date().toISOString();
-        device.activeLiveStream = {
-            ...device.activeLiveStream,
+        const nextStreamState = {
+            ...streamState,
             open: true,
             openedAt,
             openTransport: transport,
@@ -2633,10 +3200,15 @@ export function createRemoteHub(options = {}) {
             transferProtocol: transfer.transferProtocol,
             transferProtocolVersion: transfer.transferProtocolVersion,
             handshake: transfer.handshake,
-            width: Number.isFinite(Number(message.width)) ? Number(message.width) : Number(device.activeLiveStream.width || 0),
-            height: Number.isFinite(Number(message.height)) ? Number(message.height) : Number(device.activeLiveStream.height || 0),
-            openedFrameSeq: Number.isFinite(Number(message.frameSeq)) ? Number(message.frameSeq) : Number(device.activeLiveStream.openedFrameSeq || 0)
+            width: Number.isFinite(Number(message.width)) ? Number(message.width) : Number(streamState.width || 0),
+            height: Number.isFinite(Number(message.height)) ? Number(message.height) : Number(streamState.height || 0),
+            sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(streamState.sourceWidth || 0),
+            sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(streamState.sourceHeight || 0),
+            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(streamState.monitorIndex || 0),
+            monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
+            openedFrameSeq: Number.isFinite(Number(message.frameSeq)) ? Number(message.frameSeq) : Number(streamState.openedFrameSeq || 0)
         };
+        setDeviceLiveStream(device, nextStreamState);
         emitRemoteEvent('RemoteLiveStreamOpened', device, {
             streamId,
             mode: transfer.mode,
@@ -2655,7 +3227,9 @@ export function createRemoteHub(options = {}) {
             : safeString(framePayload, MAX_STREAM_BASE64_CHARS + 1);
         const frameSeq = Number(message.frameSeq);
         const streamId = safeString(message.streamId, 128) || 'live';
-        if (!device.activeLiveStream?.active || device.activeLiveStream.streamId !== streamId) {
+        const commandId = safeString(message.commandId, 128);
+        const streamState = getDeviceLiveStream(device, streamId);
+        if (!streamState?.active) {
             device.counters.liveFramesDropped += 1;
             emitRemoteEvent('RemoteFrameDropped', device, {
                 reason: 'stale-live-stream-frame',
@@ -2665,6 +3239,19 @@ export function createRemoteHub(options = {}) {
             });
             return false;
         }
+        const activeCommandId = safeString(streamState.commandId, 128);
+        if (commandId && activeCommandId && commandId !== activeCommandId) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'stale-live-stream-generation-frame',
+                streamId,
+                commandId,
+                activeCommandId,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
 
         const byteLength = normalizeFrameByteLength(framePayload, frameData);
         if ((!Buffer.isBuffer(framePayload) && !frameData)
@@ -2684,28 +3271,31 @@ export function createRemoteHub(options = {}) {
         const capturedAt = safeString(message.capturedAt, 80) || device.lastSeenAt;
         const payload = buildFramePayloadBuffer(framePayload, frameData);
         const contentHash = buildFrameContentHash(message, payload);
-        const sameContentStreak = computeSameContentStreak(device.latestLiveFrame, contentHash);
-        const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, device.activeLiveStream.mode || DEFAULT_REMOTE_FRAME_MODE);
-        if (device.activeLiveStream.open !== true) {
-            device.activeLiveStream.open = true;
-            device.activeLiveStream.openedAt = device.lastSeenAt;
-            device.activeLiveStream.openTransport = `${transport}-implicit`;
-            device.activeLiveStream.mode = transfer.mode;
-            device.activeLiveStream.frameMode = transfer.frameMode;
-            device.activeLiveStream.frameProfile = transfer.frameProfile;
-            device.activeLiveStream.encoding = transfer.encoding;
-            device.activeLiveStream.codec = transfer.codec;
-            device.activeLiveStream.compression = transfer.compression;
-            device.activeLiveStream.transferProtocol = transfer.transferProtocol;
-            device.activeLiveStream.transferProtocolVersion = transfer.transferProtocolVersion;
-            device.activeLiveStream.handshake = transfer.handshake;
+        const sameContentStreak = computeSameContentStreak(streamState.latestFrame, contentHash);
+        const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, streamState.mode || DEFAULT_REMOTE_FRAME_MODE);
+        if (streamState.open !== true) {
+            streamState.open = true;
+            streamState.openedAt = device.lastSeenAt;
+            streamState.openTransport = `${transport}-implicit`;
+            streamState.mode = transfer.mode;
+            streamState.frameMode = transfer.frameMode;
+            streamState.frameProfile = transfer.frameProfile;
+            streamState.encoding = transfer.encoding;
+            streamState.codec = transfer.codec;
+            streamState.compression = transfer.compression;
+            streamState.transferProtocol = transfer.transferProtocol;
+            streamState.transferProtocolVersion = transfer.transferProtocolVersion;
+            streamState.handshake = transfer.handshake;
         }
         device.latestLiveFrame = {
             streamId,
             frameSeq,
-            commandId: safeString(message.commandId, 128),
+            streamFrameSeq: Number.isFinite(Number(message.streamFrameSeq)) ? Number(message.streamFrameSeq) : frameSeq,
+            commandId,
             width: Number.isFinite(Number(message.width)) ? Number(message.width) : 0,
             height: Number.isFinite(Number(message.height)) ? Number(message.height) : 0,
+            sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(message.width || 0),
+            sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(message.height || 0),
             mimeType,
             format: mimeType,
             mode: transfer.mode,
@@ -2714,20 +3304,52 @@ export function createRemoteHub(options = {}) {
             encoding: transfer.encoding,
             codec: transfer.codec,
             compression: transfer.compression || mimeType,
+            pixelFormat: safeString(message.pixelFormat, 40),
+            bytesPerPixel: Number.isFinite(Number(message.bytesPerPixel)) ? Number(message.bytesPerPixel) : 0,
+            uncompressedByteLength: Number.isFinite(Number(message.uncompressedByteLength)) ? Number(message.uncompressedByteLength) : 0,
+            h264Format: safeString(message.h264Format, 40),
+            isKeyFrame: message.isKeyFrame === true || safeString(message.chunkType, 20).toLowerCase() === 'key',
+            chunkType: safeString(message.chunkType, 20),
+            timestampUs: Number.isFinite(Number(message.timestampUs)) ? Number(message.timestampUs) : 0,
+            durationUs: Number.isFinite(Number(message.durationUs)) ? Number(message.durationUs) : 0,
+            sourceGapMs: Number.isFinite(Number(message.sourceGapMs)) ? Number(message.sourceGapMs) : 0,
+            agentSendGapMs: Number.isFinite(Number(message.agentSendGapMs)) ? Number(message.agentSendGapMs) : 0,
+            agentSendDurationMs: Number.isFinite(Number(message.agentSendDurationMs)) ? Number(message.agentSendDurationMs) : 0,
+            agentSendDurationFrameSeq: Number.isFinite(Number(message.agentSendDurationFrameSeq)) ? Number(message.agentSendDurationFrameSeq) : 0,
+            agentPaceMs: Number.isFinite(Number(message.agentPaceMs)) ? Number(message.agentPaceMs) : 0,
+            agentQueueBeforePaceMs: Number.isFinite(Number(message.agentQueueBeforePaceMs)) ? Number(message.agentQueueBeforePaceMs) : 0,
+            agentFrameAgeMs: Number.isFinite(Number(message.agentFrameAgeMs)) ? Number(message.agentFrameAgeMs) : 0,
+            droppedByAgent: Number.isFinite(Number(message.droppedByAgent)) ? Number(message.droppedByAgent) : 0,
+            hubIngressDropped: Number.isFinite(Number(message.hubIngressDropped)) ? Number(message.hubIngressDropped) : 0,
+            hardwareEncoder: safeString(message.hardwareEncoder, 80),
+            platformProfile: safeString(message.platformProfile, 80),
+            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(streamState.monitorIndex || 0),
+            monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
             transferProtocol: transfer.transferProtocol,
             transferProtocolVersion: transfer.transferProtocolVersion,
             handshake: transfer.handshake,
-            fps: Number.isFinite(Number(message.fps)) ? Number(message.fps) : device.activeLiveStream.fps,
+            fps: Number.isFinite(Number(message.fps)) ? Number(message.fps) : streamState.fps,
             capturedAt,
             receivedAt: device.lastSeenAt,
             byteLength,
             transport,
             contentHash,
             captureMs: readFrameCaptureMs(message),
+            captureStageMs: readFrameStageMs(message, 'captureStageMs'),
+            convertMs: readFrameStageMs(message, 'convertMs'),
+            compressMs: readFrameStageMs(message, 'compressMs'),
+            captureSourceSerial: Number.isFinite(Number(message.captureSourceSerial)) ? Number(message.captureSourceSerial) : 0,
+            captureSourceSkipped: Number.isFinite(Number(message.captureSourceSkipped)) ? Number(message.captureSourceSkipped) : 0,
+            deltaTileSize: Number.isFinite(Number(message.deltaTileSize)) ? Number(message.deltaTileSize) : 0,
+            deltaTileCount: Number.isFinite(Number(message.deltaTileCount)) ? Number(message.deltaTileCount) : 0,
+            deltaVisualTileCount: Number.isFinite(Number(message.deltaVisualTileCount)) ? Number(message.deltaVisualTileCount) : 0,
+            deltaRefreshTileCount: Number.isFinite(Number(message.deltaRefreshTileCount)) ? Number(message.deltaRefreshTileCount) : 0,
+            deltaTotalTiles: Number.isFinite(Number(message.deltaTotalTiles)) ? Number(message.deltaTotalTiles) : 0,
             sameContentStreak,
             payload,
             accessToken: createFrameAccessToken()
         };
+        streamState.latestFrame = device.latestLiveFrame;
         rememberRecentFramePayload(device, 'live', device.latestLiveFrame);
         emitFrame({
             kind: 'live',
@@ -2737,29 +3359,26 @@ export function createRemoteHub(options = {}) {
             mimeType: device.latestLiveFrame.mimeType,
             byteLength: device.latestLiveFrame.byteLength
         });
-        device.activeLiveStream.lastFrameAt = device.lastSeenAt;
-        device.activeLiveStream.lastFrameSeq = frameSeq;
-        device.activeLiveStream.framesReceived = (device.activeLiveStream.framesReceived || 0) + 1;
-        device.activeLiveStream.mode = transfer.mode;
-        device.activeLiveStream.frameMode = transfer.frameMode;
-        device.activeLiveStream.frameProfile = transfer.frameProfile;
-        device.activeLiveStream.encoding = transfer.encoding;
-        device.activeLiveStream.codec = transfer.codec;
-        device.activeLiveStream.compression = transfer.compression;
-        device.activeLiveStream.transferProtocol = transfer.transferProtocol;
-        device.activeLiveStream.transferProtocolVersion = transfer.transferProtocolVersion;
-        device.activeLiveStream.handshake = transfer.handshake;
+        streamState.lastFrameAt = device.lastSeenAt;
+        streamState.lastFrameSeq = frameSeq;
+        streamState.framesReceived = (streamState.framesReceived || 0) + 1;
+        streamState.mode = transfer.mode;
+        streamState.frameMode = transfer.frameMode;
+        streamState.frameProfile = transfer.frameProfile;
+        streamState.encoding = transfer.encoding;
+        streamState.codec = transfer.codec;
+        streamState.compression = transfer.compression;
+        streamState.transferProtocol = transfer.transferProtocol;
+        streamState.transferProtocolVersion = transfer.transferProtocolVersion;
+        streamState.handshake = transfer.handshake;
+        streamState.width = device.latestLiveFrame.width;
+        streamState.height = device.latestLiveFrame.height;
+        streamState.sourceWidth = device.latestLiveFrame.sourceWidth;
+        streamState.sourceHeight = device.latestLiveFrame.sourceHeight;
+        streamState.monitorIndex = device.latestLiveFrame.monitorIndex;
+        streamState.monitorCount = device.latestLiveFrame.monitorCount;
+        ensureDeviceLiveStreams(device).set(streamId, streamState);
         device.counters.liveFramesReceived += 1;
-        emitRemoteEvent('RemoteFrameReceived', device, {
-            streamId,
-            frameSeq,
-            width: device.latestLiveFrame.width,
-            height: device.latestLiveFrame.height,
-            mode: device.latestLiveFrame.mode,
-            transport,
-            contentHash,
-            sameContentStreak
-        });
         return true;
     }
 
@@ -2827,13 +3446,6 @@ export function createRemoteHub(options = {}) {
             mimeType,
             byteLength
         });
-        emitRemoteEvent('RemoteAudioFrameReceived', device, {
-            streamId,
-            frameSeq,
-            mimeType,
-            byteLength,
-            transport
-        });
         return true;
     }
 
@@ -2845,8 +3457,20 @@ export function createRemoteHub(options = {}) {
         }
 
         const device = state.device;
+        if (state.inputOnly || state.fileOnly) {
+            writeJsonLine(socket, { type: 'error', error: 'input-channel-binary-not-supported' });
+            socket.destroy();
+            return;
+        }
+
         device.counters.messagesReceived += 1;
         device.lastSeenAt = new Date().toISOString();
+        if (state.frameOnly) {
+            device.frameLastSeenAt = device.lastSeenAt;
+        }
+        if (state.audioOnly) {
+            device.audioLastSeenAt = device.lastSeenAt;
+        }
 
         const frameKind = safeString(header.frameKind || header.kind || header.frameType || '', 40).toLowerCase();
         if (frameKind === 'thumbnail' || header.type === 'thumbnail.binary') {
@@ -2855,7 +3479,10 @@ export function createRemoteHub(options = {}) {
         }
 
         if (frameKind === 'stream' || frameKind === 'live' || header.type === 'stream.binary') {
-            applyLiveFrame(device, header, framePayload, 'binary');
+            applyLiveFrame(device, {
+                ...header,
+                hubIngressDropped: Number(state.binaryQueueDrops || 0)
+            }, framePayload, 'binary');
             return;
         }
 
@@ -2870,6 +3497,103 @@ export function createRemoteHub(options = {}) {
         });
     }
 
+    function dropQueuedAgentBinaryFrame(state) {
+        if (!Array.isArray(state.binaryQueue) || state.binaryQueue.length === 0) {
+            return;
+        }
+        const deltaIndex = state.binaryQueue.findIndex(item => {
+            const header = item?.header || {};
+            const frameKind = safeString(header.frameKind || header.kind || header.frameType || '', 40).toLowerCase();
+            const chunkType = safeString(header.chunkType, 20).toLowerCase();
+            return (frameKind === 'stream' || frameKind === 'live' || header.type === 'stream.binary')
+                && header.isKeyFrame !== true
+                && chunkType !== 'key';
+        });
+        const index = deltaIndex >= 0 ? deltaIndex : 0;
+        state.binaryQueue.splice(index, 1);
+        state.binaryQueueDrops = Number(state.binaryQueueDrops || 0) + 1;
+    }
+
+    function isMode5BinaryHeader(header) {
+        const mode = safeString(header?.frameMode || header?.mode, 40).toLowerCase();
+        return mode === 'mode5-lzo-delta';
+    }
+
+    function dropQueuedMode5AgentBinaryFrame(state, header) {
+        const streamId = safeString(header?.streamId, 160);
+        const dropIndex = state.binaryQueue.findIndex(item => isMode5BinaryHeader(item?.header)
+            && (!streamId || safeString(item?.header?.streamId, 160) === streamId));
+        if (dropIndex < 0) {
+            return false;
+        }
+        state.binaryQueue.splice(dropIndex, 1);
+        state.binaryQueueDrops = Number(state.binaryQueueDrops || 0) + 1;
+        return true;
+    }
+
+    function scheduleAgentBinaryIngress(socket, state) {
+        if (!state || state.closed || !socket || socket.destroyed) {
+            return;
+        }
+
+        state.binaryQueueSocket = socket;
+        if (state.binaryQueueScheduled === true) {
+            return;
+        }
+        state.binaryQueueScheduled = true;
+        setImmediate(() => drainAgentBinaryIngressLane(state));
+    }
+
+    function drainAgentBinaryIngressLane(state) {
+        state.binaryQueueScheduled = false;
+        const socket = state.binaryQueueSocket;
+        if (state.closed || !socket || socket.destroyed) {
+            if (Array.isArray(state.binaryQueue)) {
+                state.binaryQueue.length = 0;
+            }
+            return;
+        }
+
+        let processed = 0;
+        while (state.binaryQueue.length > 0 && processed < AGENT_BINARY_INGRESS_DRAIN_BUDGET_PACKETS) {
+            const item = state.binaryQueue.shift();
+            if (!item) {
+                continue;
+            }
+            handleAgentBinaryFrame(socket, state, item.header, item.payload);
+            processed += 1;
+        }
+
+        if (state.binaryQueue.length > 0 && !state.closed && !socket.destroyed) {
+            scheduleAgentBinaryIngress(socket, state);
+        }
+    }
+
+    function enqueueAgentBinaryFrame(socket, state, header, payload) {
+        if (state.closed || socket.destroyed) {
+            return;
+        }
+        if (!Array.isArray(state.binaryQueue)) {
+            state.binaryQueue = [];
+        }
+        if (isMode5BinaryHeader(header)) {
+            const streamId = safeString(header?.streamId, 160);
+            let queuedMode5Packets = state.binaryQueue.filter(item => isMode5BinaryHeader(item?.header)
+                && (!streamId || safeString(item?.header?.streamId, 160) === streamId)).length;
+            while (queuedMode5Packets >= MODE5_AGENT_BINARY_INGRESS_QUEUE_PACKETS) {
+                if (!dropQueuedMode5AgentBinaryFrame(state, header)) {
+                    break;
+                }
+                queuedMode5Packets -= 1;
+            }
+        }
+        while (state.binaryQueue.length >= AGENT_BINARY_INGRESS_QUEUE_PACKETS) {
+            dropQueuedAgentBinaryFrame(state);
+        }
+        state.binaryQueue.push({ header, payload });
+        scheduleAgentBinaryIngress(socket, state);
+    }
+
     function handleAgentMessage(socket, state, message) {
         if (!message || typeof message !== 'object') {
             return;
@@ -2888,6 +3612,52 @@ export function createRemoteHub(options = {}) {
                 return;
             }
 
+            const channel = safeString(message.channel || message.Channel, 40).toLowerCase();
+            if (channel === 'input') {
+                const device = attachInputSocket(socket, message);
+                if (!device) {
+                    return;
+                }
+
+                state.authenticated = true;
+                state.device = device;
+                state.inputOnly = true;
+                return;
+            }
+            if (channel === 'frame') {
+                const device = attachFrameSocket(socket, message);
+                if (!device) {
+                    return;
+                }
+
+                state.authenticated = true;
+                state.device = device;
+                state.frameOnly = true;
+                return;
+            }
+            if (channel === 'audio') {
+                const device = attachAudioSocket(socket, message);
+                if (!device) {
+                    return;
+                }
+
+                state.authenticated = true;
+                state.device = device;
+                state.audioOnly = true;
+                return;
+            }
+            if (channel === 'file') {
+                const device = attachFileSocket(socket, message);
+                if (!device) {
+                    return;
+                }
+
+                state.authenticated = true;
+                state.device = device;
+                state.fileOnly = true;
+                return;
+            }
+
             const device = attachDevice(socket, message);
             if (!device) {
                 return;
@@ -2904,6 +3674,34 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
+        if (state.inputOnly) {
+            device.inputLastSeenAt = new Date().toISOString();
+            if (message.type === 'input.applied') {
+                emitEvent('RemoteInputApplied', {
+                    deviceId: device.deviceId,
+                    inputSeq: Number(message.inputSeq || 0) || 0,
+                    inputType: safeString(message.inputType, 48),
+                    issuedAtEpochMs: Number(message.issuedAtEpochMs || 0) || 0,
+                    hubReceivedAtEpochMs: Number(message.hubReceivedAtEpochMs || 0) || 0,
+                    hubForwardedAtEpochMs: Number(message.hubForwardedAtEpochMs || 0) || 0,
+                    agentApplyMs: Number(message.agentApplyMs || 0) || 0,
+                    hubAcknowledgedAtEpochMs: Date.now()
+                });
+            }
+            return;
+        }
+        if (state.frameOnly) {
+            device.frameLastSeenAt = new Date().toISOString();
+            return;
+        }
+        if (state.audioOnly) {
+            device.audioLastSeenAt = new Date().toISOString();
+            return;
+        }
+        if (state.fileOnly) {
+            device.fileLastSeenAt = new Date().toISOString();
+        }
+
         device.counters.messagesReceived += 1;
         device.lastSeenAt = new Date().toISOString();
 
@@ -2975,7 +3773,17 @@ export function createRemoteHub(options = {}) {
 
         const state = {
             authenticated: false,
-            device: null
+            device: null,
+            inputOnly: false,
+            frameOnly: false,
+            audioOnly: false,
+            fileOnly: false,
+            binaryQueue: [],
+            binaryQueueDraining: false,
+            binaryQueueScheduled: false,
+            binaryQueueSocket: null,
+            binaryQueueDrops: 0,
+            closed: false
         };
 
         const helloTimer = setTimeout(() => {
@@ -3016,7 +3824,7 @@ export function createRemoteHub(options = {}) {
                     return;
                 }
 
-                handleAgentBinaryFrame(socket, state, packet.header, packet.payload);
+                enqueueAgentBinaryFrame(socket, state, packet.header, packet.payload);
             } catch (err) {
                 writeJsonLine(socket, { type: 'error', error: 'invalid-websocket-binary-frame' });
                 logWarn('remote', `invalid websocket binary frame: ${err?.message || err}`);
@@ -3024,8 +3832,16 @@ export function createRemoteHub(options = {}) {
         };
 
         const detach = reason => {
+            state.closed = true;
+            state.binaryQueue.length = 0;
+            state.binaryQueueScheduled = false;
+            state.binaryQueueSocket = null;
             allSockets.delete(socket);
             clearTimeout(helloTimer);
+            detachInputSocket(socket, reason);
+            detachFrameSocket(socket, reason);
+            detachAudioSocket(socket, reason);
+            detachFileSocket(socket, reason);
             detachSocket(socket, reason);
         };
 
@@ -3115,8 +3931,18 @@ export function createRemoteHub(options = {}) {
         const state = {
             authenticated: false,
             device: null,
+            inputOnly: false,
+            frameOnly: false,
+            audioOnly: false,
+            fileOnly: false,
             buffer: Buffer.alloc(0),
-            pendingBinaryFrame: null
+            pendingBinaryFrame: null,
+            binaryQueue: [],
+            binaryQueueDraining: false,
+            binaryQueueScheduled: false,
+            binaryQueueSocket: null,
+            binaryQueueDrops: 0,
+            closed: false
         };
 
         const helloTimer = setTimeout(() => {
@@ -3142,10 +3968,57 @@ export function createRemoteHub(options = {}) {
                     const framePayload = state.buffer.subarray(0, byteLength);
                     state.buffer = state.buffer.subarray(byteLength);
                     state.pendingBinaryFrame = null;
-                    handleAgentBinaryFrame(socket, state, header, framePayload);
+                    enqueueAgentBinaryFrame(socket, state, header, framePayload);
                     continue;
                 }
 
+                if (state.authenticated && (state.frameOnly || state.audioOnly) && state.buffer.length > 0) {
+                    const firstNonWhitespaceIndex = findFirstNonWhitespaceByte(state.buffer);
+                    if (firstNonWhitespaceIndex < 0) {
+                        state.buffer = Buffer.alloc(0);
+                        return;
+                    }
+                    if (firstNonWhitespaceIndex > 0) {
+                        state.buffer = state.buffer.subarray(firstNonWhitespaceIndex);
+                    }
+
+                    if (state.buffer.length < TCP_BINARY_FRAME_MAGIC.length && hasTcpBinaryFrameMagicPrefix(state.buffer)) {
+                        return;
+                    }
+
+                    if (startsWithTcpBinaryFrameMagic(state.buffer)) {
+                        const packet = parseTcpBinaryFramePacket(state.buffer);
+                        if (packet?.incomplete) {
+                            return;
+                        }
+                        if (!packet || packet.invalid) {
+                            const syncIndex = findTcpFrameOnlySyncIndex(state.buffer, 1);
+                            if (syncIndex > 0) {
+                                state.buffer = state.buffer.subarray(syncIndex);
+                                continue;
+                            }
+
+                            state.buffer = keepTcpFrameOnlySyncTail(state.buffer);
+                            return;
+                        }
+
+                        state.buffer = state.buffer.subarray(packet.packetLength);
+                        enqueueAgentBinaryFrame(socket, state, packet.header, packet.payload);
+                        continue;
+                    }
+
+                    if (!isJsonObjectStartByte(state.buffer[0])) {
+                        const syncIndex = findTcpFrameOnlySyncIndex(state.buffer, 1);
+                        if (syncIndex > 0) {
+                            state.buffer = state.buffer.subarray(syncIndex);
+                            continue;
+                        }
+
+                        state.buffer = keepTcpFrameOnlySyncTail(state.buffer);
+                        return;
+                    }
+                }
+
                 const newlineIndex = state.buffer.indexOf(0x0a);
                 if (newlineIndex < 0) {
                     if (state.buffer.length > MAX_LINE_CHARS) {
@@ -3181,6 +4054,9 @@ export function createRemoteHub(options = {}) {
 
                     handleAgentMessage(socket, state, message);
                 } catch (err) {
+                    if (state.authenticated && (state.frameOnly || state.audioOnly)) {
+                        continue;
+                    }
                     writeJsonLine(socket, { type: 'error', error: 'invalid-json' });
                     logWarn('remote', `invalid agent message: ${err?.message || err}`);
                 }
@@ -3193,13 +4069,29 @@ export function createRemoteHub(options = {}) {
         }
 
         socket.on('close', () => {
+            state.closed = true;
+            state.binaryQueue.length = 0;
+            state.binaryQueueScheduled = false;
+            state.binaryQueueSocket = null;
             allSockets.delete(socket);
             clearTimeout(helloTimer);
+            detachInputSocket(socket);
+            detachFrameSocket(socket);
+            detachAudioSocket(socket);
+            detachFileSocket(socket);
             detachSocket(socket);
         });
         socket.on('error', err => {
+            state.closed = true;
+            state.binaryQueue.length = 0;
+            state.binaryQueueScheduled = false;
+            state.binaryQueueSocket = null;
             allSockets.delete(socket);
             clearTimeout(helloTimer);
+            detachInputSocket(socket, err?.message || 'socket-error');
+            detachFrameSocket(socket, err?.message || 'socket-error');
+            detachAudioSocket(socket, err?.message || 'socket-error');
+            detachFileSocket(socket, err?.message || 'socket-error');
             detachSocket(socket, err?.message || 'socket-error');
         });
     }
@@ -3236,9 +4128,9 @@ export function createRemoteHub(options = {}) {
                 started = true;
                 boundPort = server.address()?.port || requestedPort;
                 lastError = '';
-                logEvent('remote', `RemoteHub listening on tcp://${host}:${boundPort}`, 'success');
+                logEvent('remote', `LiveDesk Hub client endpoint listening on tcp://${host}:${boundPort}`, 'success');
                 if (host === '0.0.0.0' || host === '::') {
-                    logWarn('remote', 'RemoteHub is externally reachable. Use a strong pairing token and trusted network.');
+                    logWarn('remote', 'LiveDesk Hub client endpoint is externally reachable. Use a strong pairing token and trusted network.');
                 }
                 emitRemoteEvent('RemoteHubStarted', null);
                 resolve();
@@ -3301,11 +4193,7 @@ export function createRemoteHub(options = {}) {
             device.connected = false;
             device.disconnectedAt = new Date().toISOString();
             device.lastDisconnectReason = reason;
-            if (device.activeLiveStream) {
-                device.activeLiveStream.active = false;
-                device.activeLiveStream.stoppedAt = device.disconnectedAt;
-                device.activeLiveStream.stopReason = reason;
-            }
+            deactivateDeviceLiveStreams(device, reason, device.disconnectedAt);
             failAllPendingTasks(device, 'device-disconnected');
             emitRemoteEvent('RemoteDeviceDisconnected', device, { reason, synthetic: true });
             return true;
@@ -3350,19 +4238,26 @@ export function createRemoteHub(options = {}) {
         }
 
         const commandId = safeString(command?.commandId, 128) || crypto.randomUUID();
+        const commandName = safeString(command?.command || 'ping', 80);
         const payload = {
             type: 'command',
             commandId,
-            command: safeString(command?.command || 'ping', 80),
+            command: commandName,
             payload: command?.payload ?? null,
             issuedAt: new Date().toISOString()
         };
 
-        writeJsonLine(device.socket, payload);
+        const dedicatedFileSocket = commandName.startsWith('file.transfer')
+            && device.fileSocket
+            && !device.fileSocket.destroyed
+            ? device.fileSocket
+            : null;
+        writeJsonLine(dedicatedFileSocket || device.socket, payload);
         device.counters.commandsSent += 1;
         emitRemoteEvent('RemoteCommandQueued', device, {
             commandId,
-            command: payload.command
+            command: payload.command,
+            channel: dedicatedFileSocket ? 'file' : 'control'
         });
         return { ok: true, commandId };
     }
@@ -3386,10 +4281,30 @@ export function createRemoteHub(options = {}) {
             return { ok: false, error: 'missing-input-type' };
         }
 
+        const inputSocket = device.inputSocket;
+        if (inputSocket && !inputSocket.destroyed) {
+            const sent = writeJsonLine(inputSocket, {
+                type: 'input.control',
+                payload: {
+                    ...normalized,
+                    hubForwardedAtEpochMs: Date.now(),
+                    issuedAt: normalized.issuedAt || new Date().toISOString()
+                }
+            });
+            if (sent) {
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                return { ok: true, inputSocket: true };
+            }
+
+            detachInputSocket(inputSocket, 'input-socket-write-failed');
+        }
+
         return sendCommand(deviceId, {
             command: 'input.control',
             payload: {
                 ...normalized,
+                hubForwardedAtEpochMs: Date.now(),
                 issuedAt: normalized.issuedAt || new Date().toISOString()
             }
         });
@@ -3603,6 +4518,121 @@ export function createRemoteHub(options = {}) {
         });
     }
 
+    function ensureDeviceLiveStreams(device) {
+        if (!(device?.activeLiveStreams instanceof Map)) {
+            Object.defineProperty(device, 'activeLiveStreams', {
+                value: new Map(),
+                enumerable: false,
+                configurable: true,
+                writable: true
+            });
+            if (device?.activeLiveStream?.streamId) {
+                device.activeLiveStreams.set(device.activeLiveStream.streamId, device.activeLiveStream);
+            }
+        }
+        return device.activeLiveStreams;
+    }
+
+    function getDeviceLiveStream(device, streamId) {
+        const id = safeString(streamId, 128);
+        if (!id) {
+            return device?.activeLiveStream || null;
+        }
+        return ensureDeviceLiveStreams(device).get(id)
+            || (device?.activeLiveStream?.streamId === id ? device.activeLiveStream : null);
+    }
+
+    function setDeviceLiveStream(device, stream) {
+        if (!device || !stream?.streamId) {
+            return stream;
+        }
+        ensureDeviceLiveStreams(device).set(stream.streamId, stream);
+        device.activeLiveStream = stream;
+        return stream;
+    }
+
+    function deactivateDeviceLiveStreams(device, reason, stoppedAt = new Date().toISOString()) {
+        const streams = ensureDeviceLiveStreams(device);
+        for (const stream of streams.values()) {
+            stream.active = false;
+            stream.stoppedAt = stoppedAt;
+            stream.stopReason = reason;
+        }
+        if (device?.activeLiveStream) {
+            device.activeLiveStream.active = false;
+            device.activeLiveStream.stoppedAt = stoppedAt;
+            device.activeLiveStream.stopReason = reason;
+        }
+    }
+
+    function makeStableLiveStreamId(deviceId, purpose = 'wall') {
+        const hash = crypto.createHash('sha1').update(String(deviceId || 'device')).digest('hex').slice(0, 16);
+        const role = safeString(purpose, 24).toLowerCase().replace(/[^a-z0-9_-]+/g, '-') || 'wall';
+        return `${role}-${hash}`;
+    }
+
+    function normalizeLiveStreamStartOptions(options = {}) {
+        const transfer = buildRemoteFrameTransferDescriptor(options.mode || options.frameMode || DEFAULT_REMOTE_FRAME_MODE);
+        const streamPurpose = safeString(options.streamPurpose || options.purpose || 'wall', 24) || 'wall';
+        const maxFps = streamPurpose === 'control' ? 60 : 30;
+        const fps = clampNumber(options.fps, 1, maxFps, 8);
+        const maxWidth = clampNumber(options.maxWidth, 320, 3840, 640);
+        const maxHeight = clampNumber(options.maxHeight, 180, 2160, 360);
+        const quality = clampNumber(options.quality, 20, 95, 45);
+        const monitorIndex = normalizeMonitorIndex(options.monitorIndex ?? options.screenIndex ?? options.displayIndex);
+        return { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose };
+    }
+
+    function liveStreamStartStillPending(activeLiveStream) {
+        if (!activeLiveStream?.active || activeLiveStream.open === true) {
+            return false;
+        }
+        const startedAt = Date.parse(activeLiveStream.startedAt || '');
+        return Number.isFinite(startedAt) && Date.now() - startedAt < LIVE_STREAM_PENDING_REUSE_MS;
+    }
+
+    function getLiveStreamFreshWindowMs(activeLiveStream) {
+        const fps = Number(activeLiveStream?.fps || 0);
+        const frameMs = Number.isFinite(fps) && fps > 0 ? 1000 / fps : 500;
+        return Math.max(
+            LIVE_STREAM_MIN_FRESH_MS,
+            Math.min(LIVE_STREAM_MAX_FRESH_MS, Math.round(frameMs * 20))
+        );
+    }
+
+    function getLiveStreamIdleMs(activeLiveStream) {
+        const lastFrameAt = Date.parse(activeLiveStream?.lastFrameAt || activeLiveStream?.openedAt || activeLiveStream?.startedAt || '');
+        if (!Number.isFinite(lastFrameAt)) {
+            return Infinity;
+        }
+        return Math.max(0, Date.now() - lastFrameAt);
+    }
+
+    function liveStreamIsReusable(activeLiveStream) {
+        if (!activeLiveStream?.active) {
+            return false;
+        }
+        if (liveStreamStartStillPending(activeLiveStream)) {
+            return true;
+        }
+        if (activeLiveStream.open !== true) {
+            return false;
+        }
+        return getLiveStreamIdleMs(activeLiveStream) <= getLiveStreamFreshWindowMs(activeLiveStream);
+    }
+
+    function liveStreamMatchesOptions(activeLiveStream, normalized) {
+        if (!activeLiveStream?.active) {
+            return false;
+        }
+        return activeLiveStream.frameMode === normalized.transfer.frameMode
+            && Number(activeLiveStream.fps || 0) === normalized.fps
+            && Number(activeLiveStream.maxWidth || 0) === normalized.maxWidth
+            && Number(activeLiveStream.maxHeight || 0) === normalized.maxHeight
+            && Number(activeLiveStream.quality || 0) === normalized.quality
+            && Number(activeLiveStream.monitorIndex || 0) === normalized.monitorIndex;
+    }
+
     function startLiveStream(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
         if (device?.synthetic === true && device.connected) {
@@ -3611,12 +4641,28 @@ export function createRemoteHub(options = {}) {
             }
 
             const now = new Date().toISOString();
-            const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
-            const fps = clampNumber(options.fps, 1, 24, 20);
+            const normalized = normalizeLiveStreamStartOptions({ fps: 2, ...options });
+            const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
+            const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
+            const activeLiveStream = getDeviceLiveStream(device, streamId);
             const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
-            const transfer = buildRemoteFrameTransferDescriptor(options.mode || DEFAULT_REMOTE_FRAME_MODE);
+            if (activeLiveStream
+                && liveStreamMatchesOptions(activeLiveStream, normalized)
+                && (activeLiveStream.open === true || liveStreamStartStillPending(activeLiveStream))) {
+                return {
+                    ok: true,
+                    commandId: activeLiveStream.commandId,
+                    streamId,
+                    fps,
+                    mode: transfer.mode,
+                    frameMode: transfer.frameMode,
+                    monitorIndex,
+                    synthetic: true,
+                    reused: true
+                };
+            }
             device.counters.commandsSent += 1;
-            device.activeLiveStream = {
+            setDeviceLiveStream(device, {
                 streamId,
                 commandId,
                 active: true,
@@ -3633,18 +4679,25 @@ export function createRemoteHub(options = {}) {
                 transferProtocolVersion: transfer.transferProtocolVersion,
                 handshake: transfer.handshake,
                 fps,
+                maxWidth,
+                maxHeight,
+                quality,
+                monitorIndex,
+                monitorCount: 1,
                 startedAt: now,
                 stoppedAt: '',
                 stopReason: '',
                 lastFrameAt: '',
                 lastFrameSeq: 0,
-                framesReceived: 0
-            };
+                framesReceived: 0,
+                streamPurpose
+            });
             device.counters.liveStreamsStarted += 1;
             applySyntheticLiveFrame(device, streamId, {
                 commandId,
-                maxWidth: options.maxWidth,
-                maxHeight: options.maxHeight,
+                maxWidth,
+                maxHeight,
+                monitorIndex,
                 fps
             });
             emitRemoteEvent('RemoteLiveStreamStarted', device, {
@@ -3654,7 +4707,7 @@ export function createRemoteHub(options = {}) {
                 mode: transfer.mode,
                 synthetic: true
             });
-            return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, synthetic: true };
+            return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, monitorIndex, synthetic: true };
         }
 
         if (!device?.socket || device.socket.destroyed || !device.connected) {
@@ -3665,10 +4718,76 @@ export function createRemoteHub(options = {}) {
         }
 
         const now = new Date().toISOString();
-        const streamId = safeString(options.streamId, 128) || `live-${Date.now()}`;
-        const fps = clampNumber(options.fps, 1, 24, 12);
+        const normalized = normalizeLiveStreamStartOptions(options);
+        const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose } = normalized;
+        const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId, streamPurpose);
+        const activeLiveStream = getDeviceLiveStream(device, streamId);
         const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
-        const transfer = buildRemoteFrameTransferDescriptor(options.mode || DEFAULT_REMOTE_FRAME_MODE);
+        if (activeLiveStream
+            && options.forceRestart !== true
+            && options.reuseExisting === true
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
+            return {
+                ok: true,
+                commandId: activeLiveStream.commandId,
+                streamId,
+                fps: Number(activeLiveStream.fps || fps),
+                mode: activeLiveStream.mode || transfer.mode,
+                frameMode: activeLiveStream.frameMode || transfer.frameMode,
+                monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
+                reused: true
+            };
+        }
+        if (activeLiveStream
+            && options.forceRestart !== true
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
+            if (options.silentReuse !== true) {
+                emitRemoteEvent('RemoteLiveStreamStartReused', device, {
+                    streamId,
+                    fps,
+                    mode: transfer.mode,
+                    frameMode: transfer.frameMode,
+                    monitorIndex
+                });
+            }
+            return {
+                ok: true,
+                commandId: activeLiveStream.commandId,
+                streamId,
+                fps,
+                mode: transfer.mode,
+                frameMode: transfer.frameMode,
+                monitorIndex,
+                reused: true
+            };
+        }
+        if (options.forceRestart === true && activeLiveStream) {
+            emitRemoteEvent('RemoteLiveStreamForcedRestart', device, {
+                streamId,
+                fps,
+                mode: transfer.mode,
+                frameMode: transfer.frameMode,
+                monitorIndex,
+                reason: safeString(options.restartReason || 'browser-stale', 128)
+            });
+        }
+        if (activeLiveStream
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && activeLiveStream.open === true
+            && !liveStreamIsReusable(activeLiveStream)) {
+            emitRemoteEvent('RemoteLiveStreamStaleRestart', device, {
+                streamId,
+                fps,
+                mode: transfer.mode,
+                frameMode: transfer.frameMode,
+                monitorIndex,
+                idleMs: getLiveStreamIdleMs(activeLiveStream),
+                staleAfterMs: getLiveStreamFreshWindowMs(activeLiveStream),
+                lastFrameAt: activeLiveStream.lastFrameAt || ''
+            });
+        }
         const result = sendCommand(deviceId, {
             command: 'stream.start',
             commandId,
@@ -3684,9 +4803,11 @@ export function createRemoteHub(options = {}) {
                 transferProtocolVersion: transfer.transferProtocolVersion,
                 handshake: transfer.handshake,
                 fps,
-                maxWidth: clampNumber(options.maxWidth, 320, 2560, 960),
-                maxHeight: clampNumber(options.maxHeight, 180, 1440, 540),
-                quality: clampNumber(options.quality, 20, 95, 60),
+                maxWidth,
+                maxHeight,
+                quality,
+                monitorIndex,
+                streamPurpose,
                 requestedAt: now
             }
         });
@@ -3695,7 +4816,7 @@ export function createRemoteHub(options = {}) {
             return result;
         }
 
-        device.activeLiveStream = {
+        setDeviceLiveStream(device, {
             streamId,
             commandId,
             active: true,
@@ -3712,23 +4833,30 @@ export function createRemoteHub(options = {}) {
             transferProtocolVersion: transfer.transferProtocolVersion,
             handshake: transfer.handshake,
             fps,
+            maxWidth,
+            maxHeight,
+            quality,
+            monitorIndex,
+            monitorCount: 1,
             startedAt: now,
             stoppedAt: '',
             stopReason: '',
             lastFrameAt: '',
             lastFrameSeq: 0,
-            framesReceived: 0
-        };
+            framesReceived: 0,
+            streamPurpose
+        });
         device.counters.liveStreamsStarted += 1;
         emitRemoteEvent('RemoteLiveStreamStarted', device, {
             streamId,
             commandId,
             fps,
             mode: transfer.mode,
-            frameMode: transfer.frameMode
+            frameMode: transfer.frameMode,
+            monitorIndex
         });
 
-        return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode };
+        return { ok: true, commandId, streamId, fps, mode: transfer.mode, frameMode: transfer.frameMode, monitorIndex };
     }
 
     function stopLiveStream(deviceId, options = {}) {
@@ -3737,10 +4865,11 @@ export function createRemoteHub(options = {}) {
             const streamId = safeString(options.streamId, 128) || device.activeLiveStream?.streamId || '';
             const commandId = safeString(options.commandId, 128) || crypto.randomUUID();
             device.counters.commandsSent += 1;
-            if (device.activeLiveStream && (!streamId || device.activeLiveStream.streamId === streamId)) {
-                device.activeLiveStream.active = false;
-                device.activeLiveStream.stoppedAt = new Date().toISOString();
-                device.activeLiveStream.stopReason = 'manager-request';
+            const streamState = getDeviceLiveStream(device, streamId);
+            if (streamState) {
+                streamState.active = false;
+                streamState.stoppedAt = new Date().toISOString();
+                streamState.stopReason = 'manager-request';
             }
             device.counters.liveStreamsStopped += 1;
             emitRemoteEvent('RemoteLiveStreamStopped', device, {
@@ -3770,10 +4899,11 @@ export function createRemoteHub(options = {}) {
             return result;
         }
 
-        if (device.activeLiveStream && (!streamId || device.activeLiveStream.streamId === streamId)) {
-            device.activeLiveStream.active = false;
-            device.activeLiveStream.stoppedAt = new Date().toISOString();
-            device.activeLiveStream.stopReason = 'manager-request';
+        const streamState = getDeviceLiveStream(device, streamId);
+        if (streamState) {
+            streamState.active = false;
+            streamState.stoppedAt = new Date().toISOString();
+            streamState.stopReason = 'manager-request';
         }
         device.counters.liveStreamsStopped += 1;
         emitRemoteEvent('RemoteLiveStreamStopped', device, {
@@ -3925,6 +5055,7 @@ export function createRemoteHub(options = {}) {
         requestAgentTask,
         requestAgentTaskBatch,
         setHostTarget,
+        rotatePairingPin,
         requestThumbnail,
         startLiveStream,
         stopLiveStream,
@@ -3935,7 +5066,8 @@ export function createRemoteHub(options = {}) {
         getFramePayload,
         seedSyntheticFleet,
         clearSyntheticFleet,
-        getPairToken: () => pairToken
+        getPairToken: () => pairToken,
+        getPairingPin: () => pairingPin
     };
 }