livedesk 0.1.154 → 0.1.156

package/hub/src/remote-hub.js

@@ -551,6 +551,9 @@ function normalizeRemoteInputEvent(value = {}) {
     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,
@@ -570,6 +573,9 @@ function normalizeRemoteInputEvent(value = {}) {
         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,
+        issuedAtEpochMs: Number.isFinite(issuedAtEpochMs) ? issuedAtEpochMs : 0,
+        hubReceivedAtEpochMs: Number.isFinite(hubReceivedAtEpochMs) ? hubReceivedAtEpochMs : 0,
         issuedAt: safeString(input.issuedAt || input.IssuedAt, 80)
     };
 }
@@ -1849,17 +1855,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,
-            monitorIndex: options.monitorIndex ?? device.activeLiveStream.monitorIndex ?? 0,
-            monitorCount: options.monitorCount ?? device.activeLiveStream.monitorCount ?? 1,
-            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);
@@ -1871,9 +1878,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, {
@@ -2645,11 +2653,7 @@ export function createRemoteHub(options = {}) {
         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 });
@@ -3127,7 +3131,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,
@@ -3137,7 +3142,7 @@ export function createRemoteHub(options = {}) {
         }
 
         const commandId = safeString(message.commandId, 128);
-        const activeCommandId = safeString(device.activeLiveStream.commandId, 128);
+        const activeCommandId = safeString(streamState.commandId, 128);
         if (commandId && activeCommandId && commandId !== activeCommandId) {
             emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
                 reason: 'stale-live-stream-generation',
@@ -3149,10 +3154,10 @@ export function createRemoteHub(options = {}) {
             return false;
         }
 
-        const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, device.activeLiveStream.mode || DEFAULT_REMOTE_FRAME_MODE);
+        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,
@@ -3165,14 +3170,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),
-            sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(device.activeLiveStream.sourceWidth || 0),
-            sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(device.activeLiveStream.sourceHeight || 0),
-            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(device.activeLiveStream.monitorIndex || 0),
-            monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(device.activeLiveStream.monitorCount || 1),
-            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,
@@ -3192,7 +3198,8 @@ export function createRemoteHub(options = {}) {
         const frameSeq = Number(message.frameSeq);
         const streamId = safeString(message.streamId, 128) || 'live';
         const commandId = safeString(message.commandId, 128);
-        if (!device.activeLiveStream?.active || device.activeLiveStream.streamId !== streamId) {
+        const streamState = getDeviceLiveStream(device, streamId);
+        if (!streamState?.active) {
             device.counters.liveFramesDropped += 1;
             emitRemoteEvent('RemoteFrameDropped', device, {
                 reason: 'stale-live-stream-frame',
@@ -3202,7 +3209,7 @@ export function createRemoteHub(options = {}) {
             });
             return false;
         }
-        const activeCommandId = safeString(device.activeLiveStream.commandId, 128);
+        const activeCommandId = safeString(streamState.commandId, 128);
         if (commandId && activeCommandId && commandId !== activeCommandId) {
             device.counters.liveFramesDropped += 1;
             emitRemoteEvent('RemoteFrameDropped', device, {
@@ -3234,21 +3241,21 @@ 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,
@@ -3284,12 +3291,12 @@ export function createRemoteHub(options = {}) {
             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(device.activeLiveStream.monitorIndex || 0),
-            monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(device.activeLiveStream.monitorCount || 1),
+            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,
@@ -3303,6 +3310,7 @@ export function createRemoteHub(options = {}) {
             payload,
             accessToken: createFrameAccessToken()
         };
+        streamState.latestFrame = device.latestLiveFrame;
         rememberRecentFramePayload(device, 'live', device.latestLiveFrame);
         emitFrame({
             kind: 'live',
@@ -3312,24 +3320,25 @@ 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;
-        device.activeLiveStream.width = device.latestLiveFrame.width;
-        device.activeLiveStream.height = device.latestLiveFrame.height;
-        device.activeLiveStream.sourceWidth = device.latestLiveFrame.sourceWidth;
-        device.activeLiveStream.sourceHeight = device.latestLiveFrame.sourceHeight;
-        device.activeLiveStream.monitorIndex = device.latestLiveFrame.monitorIndex;
-        device.activeLiveStream.monitorCount = device.latestLiveFrame.monitorCount;
+        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;
         return true;
     }
@@ -3600,6 +3609,18 @@ export function createRemoteHub(options = {}) {
 
         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) {
@@ -4105,11 +4126,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;
@@ -4203,6 +4220,7 @@ export function createRemoteHub(options = {}) {
                 type: 'input.control',
                 payload: {
                     ...normalized,
+                    hubForwardedAtEpochMs: Date.now(),
                     issuedAt: normalized.issuedAt || new Date().toISOString()
                 }
             });
@@ -4219,6 +4237,7 @@ export function createRemoteHub(options = {}) {
             command: 'input.control',
             payload: {
                 ...normalized,
+                hubForwardedAtEpochMs: Date.now(),
                 issuedAt: normalized.issuedAt || new Date().toISOString()
             }
         });
@@ -4432,20 +4451,69 @@ export function createRemoteHub(options = {}) {
         });
     }
 
-    function makeStableLiveStreamId(deviceId) {
+    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);
-        return `live-${hash}`;
+        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 maxFps = transfer.frameMode === 'mode3-h264-hw' ? 20 : 30;
+        const maxFps = 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 };
+        const streamPurpose = safeString(options.streamPurpose || options.purpose || 'wall', 24) || 'wall';
+        return { fps, maxWidth, maxHeight, quality, monitorIndex, transfer, streamPurpose };
     }
 
     function liveStreamStartStillPending(activeLiveStream) {
@@ -4506,16 +4574,17 @@ export function createRemoteHub(options = {}) {
             }
 
             const now = new Date().toISOString();
-            const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId);
             const normalized = normalizeLiveStreamStartOptions({ fps: 2, ...options });
-            const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer } = normalized;
+            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();
-            if (device.activeLiveStream?.streamId === streamId
-                && liveStreamMatchesOptions(device.activeLiveStream, normalized)
-                && (device.activeLiveStream.open === true || liveStreamStartStillPending(device.activeLiveStream))) {
+            if (activeLiveStream
+                && liveStreamMatchesOptions(activeLiveStream, normalized)
+                && (activeLiveStream.open === true || liveStreamStartStillPending(activeLiveStream))) {
                 return {
                     ok: true,
-                    commandId: device.activeLiveStream.commandId,
+                    commandId: activeLiveStream.commandId,
                     streamId,
                     fps,
                     mode: transfer.mode,
@@ -4526,7 +4595,7 @@ export function createRemoteHub(options = {}) {
                 };
             }
             device.counters.commandsSent += 1;
-            device.activeLiveStream = {
+            setDeviceLiveStream(device, {
                 streamId,
                 commandId,
                 active: true,
@@ -4553,8 +4622,9 @@ export function createRemoteHub(options = {}) {
                 stopReason: '',
                 lastFrameAt: '',
                 lastFrameSeq: 0,
-                framesReceived: 0
-            };
+                framesReceived: 0,
+                streamPurpose
+            });
             device.counters.liveStreamsStarted += 1;
             applySyntheticLiveFrame(device, streamId, {
                 commandId,
@@ -4581,30 +4651,31 @@ export function createRemoteHub(options = {}) {
         }
 
         const now = new Date().toISOString();
-        const streamId = safeString(options.streamId, 128) || makeStableLiveStreamId(deviceId);
         const normalized = normalizeLiveStreamStartOptions(options);
-        const { fps, maxWidth, maxHeight, quality, monitorIndex, transfer } = normalized;
+        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();
-        if (device.activeLiveStream?.streamId === streamId
+        if (activeLiveStream
             && options.forceRestart !== true
             && options.reuseExisting === true
-            && liveStreamMatchesOptions(device.activeLiveStream, normalized)
-            && liveStreamIsReusable(device.activeLiveStream)) {
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
             return {
                 ok: true,
-                commandId: device.activeLiveStream.commandId,
+                commandId: activeLiveStream.commandId,
                 streamId,
-                fps: Number(device.activeLiveStream.fps || fps),
-                mode: device.activeLiveStream.mode || transfer.mode,
-                frameMode: device.activeLiveStream.frameMode || transfer.frameMode,
-                monitorIndex: Number(device.activeLiveStream.monitorIndex || monitorIndex),
+                fps: Number(activeLiveStream.fps || fps),
+                mode: activeLiveStream.mode || transfer.mode,
+                frameMode: activeLiveStream.frameMode || transfer.frameMode,
+                monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
                 reused: true
             };
         }
-        if (device.activeLiveStream?.streamId === streamId
+        if (activeLiveStream
             && options.forceRestart !== true
-            && liveStreamMatchesOptions(device.activeLiveStream, normalized)
-            && liveStreamIsReusable(device.activeLiveStream)) {
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
             if (options.silentReuse !== true) {
                 emitRemoteEvent('RemoteLiveStreamStartReused', device, {
                     streamId,
@@ -4616,7 +4687,7 @@ export function createRemoteHub(options = {}) {
             }
             return {
                 ok: true,
-                commandId: device.activeLiveStream.commandId,
+                commandId: activeLiveStream.commandId,
                 streamId,
                 fps,
                 mode: transfer.mode,
@@ -4625,7 +4696,7 @@ export function createRemoteHub(options = {}) {
                 reused: true
             };
         }
-        if (options.forceRestart === true && device.activeLiveStream?.streamId === streamId) {
+        if (options.forceRestart === true && activeLiveStream) {
             emitRemoteEvent('RemoteLiveStreamForcedRestart', device, {
                 streamId,
                 fps,
@@ -4635,30 +4706,19 @@ export function createRemoteHub(options = {}) {
                 reason: safeString(options.restartReason || 'browser-stale', 128)
             });
         }
-        if (device.activeLiveStream?.streamId === streamId
-            && liveStreamMatchesOptions(device.activeLiveStream, normalized)
-            && device.activeLiveStream.open === true
-            && !liveStreamIsReusable(device.activeLiveStream)) {
+        if (activeLiveStream
+            && liveStreamMatchesOptions(activeLiveStream, normalized)
+            && activeLiveStream.open === true
+            && !liveStreamIsReusable(activeLiveStream)) {
             emitRemoteEvent('RemoteLiveStreamStaleRestart', device, {
                 streamId,
                 fps,
                 mode: transfer.mode,
                 frameMode: transfer.frameMode,
                 monitorIndex,
-                idleMs: getLiveStreamIdleMs(device.activeLiveStream),
-                staleAfterMs: getLiveStreamFreshWindowMs(device.activeLiveStream),
-                lastFrameAt: device.activeLiveStream.lastFrameAt || ''
-            });
-        }
-        if (device.activeLiveStream?.active && device.activeLiveStream.streamId && device.activeLiveStream.streamId !== streamId) {
-            sendCommand(deviceId, {
-                command: 'stream.stop',
-                commandId: crypto.randomUUID(),
-                payload: {
-                    streamId: device.activeLiveStream.streamId,
-                    reason: 'live-stream-replaced',
-                    requestedAt: now
-                }
+                idleMs: getLiveStreamIdleMs(activeLiveStream),
+                staleAfterMs: getLiveStreamFreshWindowMs(activeLiveStream),
+                lastFrameAt: activeLiveStream.lastFrameAt || ''
             });
         }
         const result = sendCommand(deviceId, {
@@ -4680,6 +4740,7 @@ export function createRemoteHub(options = {}) {
                 maxHeight,
                 quality,
                 monitorIndex,
+                streamPurpose,
                 requestedAt: now
             }
         });
@@ -4688,7 +4749,7 @@ export function createRemoteHub(options = {}) {
             return result;
         }
 
-        device.activeLiveStream = {
+        setDeviceLiveStream(device, {
             streamId,
             commandId,
             active: true,
@@ -4715,8 +4776,9 @@ export function createRemoteHub(options = {}) {
             stopReason: '',
             lastFrameAt: '',
             lastFrameSeq: 0,
-            framesReceived: 0
-        };
+            framesReceived: 0,
+            streamPurpose
+        });
         device.counters.liveStreamsStarted += 1;
         emitRemoteEvent('RemoteLiveStreamStarted', device, {
             streamId,
@@ -4736,10 +4798,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, {
@@ -4769,10 +4832,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, {