livedesk 0.1.154 → 0.1.155

package/hub/src/remote-hub.js

@@ -1849,17 +1849,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 +1872,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 +2647,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 +3125,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 +3136,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 +3148,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 +3164,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 +3192,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 +3203,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 +3235,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 +3285,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 +3304,7 @@ export function createRemoteHub(options = {}) {
             payload,
             accessToken: createFrameAccessToken()
         };
+        streamState.latestFrame = device.latestLiveFrame;
         rememberRecentFramePayload(device, 'live', device.latestLiveFrame);
         emitFrame({
             kind: 'live',
@@ -3312,24 +3314,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;
     }
@@ -4105,11 +4108,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;
@@ -4432,20 +4431,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 +4554,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 +4575,7 @@ export function createRemoteHub(options = {}) {
                 };
             }
             device.counters.commandsSent += 1;
-            device.activeLiveStream = {
+            setDeviceLiveStream(device, {
                 streamId,
                 commandId,
                 active: true,
@@ -4553,8 +4602,9 @@ export function createRemoteHub(options = {}) {
                 stopReason: '',
                 lastFrameAt: '',
                 lastFrameSeq: 0,
-                framesReceived: 0
-            };
+                framesReceived: 0,
+                streamPurpose
+            });
             device.counters.liveStreamsStarted += 1;
             applySyntheticLiveFrame(device, streamId, {
                 commandId,
@@ -4581,30 +4631,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 +4667,7 @@ export function createRemoteHub(options = {}) {
             }
             return {
                 ok: true,
-                commandId: device.activeLiveStream.commandId,
+                commandId: activeLiveStream.commandId,
                 streamId,
                 fps,
                 mode: transfer.mode,
@@ -4625,7 +4676,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 +4686,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 +4720,7 @@ export function createRemoteHub(options = {}) {
                 maxHeight,
                 quality,
                 monitorIndex,
+                streamPurpose,
                 requestedAt: now
             }
         });
@@ -4688,7 +4729,7 @@ export function createRemoteHub(options = {}) {
             return result;
         }
 
-        device.activeLiveStream = {
+        setDeviceLiveStream(device, {
             streamId,
             commandId,
             active: true,
@@ -4715,8 +4756,9 @@ export function createRemoteHub(options = {}) {
             stopReason: '',
             lastFrameAt: '',
             lastFrameSeq: 0,
-            framesReceived: 0
-        };
+            framesReceived: 0,
+            streamPurpose
+        });
         device.counters.liveStreamsStarted += 1;
         emitRemoteEvent('RemoteLiveStreamStarted', device, {
             streamId,
@@ -4736,10 +4778,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 +4812,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, {

package/hub/src/server.js

@@ -398,7 +398,7 @@ function normalizeTransferChunk(body = {}) {
 
 function normalizeLiveOptions(payload = {}) {
   const mode = String(payload.frameMode || payload.mode || 'mode3-h264-hw').trim() || 'mode3-h264-hw';
-  const maxFps = mode === 'mode3-h264-hw' ? 20 : 30;
+  const maxFps = 30;
   return {
     fps: clampNumber(payload.fps, 1, maxFps, 2),
     maxWidth: clampNumber(payload.maxWidth, 320, 3840, 640),
@@ -408,6 +408,7 @@ function normalizeLiveOptions(payload = {}) {
     monitorSelections: normalizeMonitorSelections(payload.monitorSelections),
     forceRestart: /^(1|true|yes|on)$/i.test(String(payload.forceRestart ?? '')),
     reuseExisting: /^(1|true|yes|on)$/i.test(String(payload.reuseExisting ?? '')),
+    streamPurpose: String(payload.streamPurpose || payload.purpose || 'wall').trim().slice(0, 24) || 'wall',
     mode,
     frameMode: mode
   };
@@ -607,6 +608,14 @@ function updateFrameSubscription(ws, payload = {}) {
   registerFrameClient(ws);
   ws.liveDeskAutoStart = /^(1|true|yes|on|live)$/i.test(String(payload.autoStartLive ?? payload.startLive ?? ''));
   ws.liveDeskLiveOptions = normalizeLiveOptions(payload);
+  if (!(ws.liveDeskStreamIdsByDeviceId instanceof Map)) {
+    ws.liveDeskStreamIdsByDeviceId = new Map();
+  }
+  for (const subscribedDeviceId of ws.liveDeskStreamIdsByDeviceId.keys()) {
+    if (!ws.liveDeskDeviceIds.has(subscribedDeviceId)) {
+      ws.liveDeskStreamIdsByDeviceId.delete(subscribedDeviceId);
+    }
+  }
   sendJson(ws, {
     type: 'RemoteFrameSubscription',
     timestamp: new Date().toISOString(),
@@ -666,8 +675,10 @@ function startFrameSubscriptionLive(ws, reason = 'subscribe', onlyDeviceId = '',
       silentReuse: reason === 'watchdog' && liveOptions.forceRestart !== true
     });
     if (result?.ok) {
+      ws.liveDeskStreamIdsByDeviceId.set(deviceId, result.streamId);
       started.push({ deviceId, streamId: result.streamId, fps: result.fps, reused: result.reused === true });
     } else {
+      ws.liveDeskStreamIdsByDeviceId.delete(deviceId);
       skipped.push({ deviceId, reason: result?.error || 'start-failed' });
     }
   }
@@ -836,6 +847,12 @@ function broadcastRemoteBinaryFrame(frameEvent) {
     if (client.readyState !== client.OPEN) {
       continue;
     }
+    const expectedStreamId = client.liveDeskStreamIdsByDeviceId instanceof Map
+      ? client.liveDeskStreamIdsByDeviceId.get(deviceId)
+      : '';
+    if (expectedStreamId && String(frame.streamId || '') !== expectedStreamId) {
+      continue;
+    }
     const lane = ensureFrameClientSendLane(client);
     if (client.liveDeskFrameBackpressured && isH264 && !isKeyFrame) {
       lane.dropped += 1;
@@ -964,6 +981,7 @@ function configureMode4Atlas(ws, payload = {}) {
       quality: 60,
       mode: 'mode2-lzo',
       frameMode: 'mode2-lzo',
+      streamPurpose: 'atlas',
       monitorIndex: Number(monitorSelections[deviceId] || 0),
       reuseExisting: false,
       silentReuse: true

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.154",
+  "version": "0.1.155",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
   "bin": {
@@ -31,7 +31,7 @@
   },
   "dependencies": {
     "@ffmpeg-installer/ffmpeg": "^1.1.0",
-    "@livedesk/client": "0.1.103",
+    "@livedesk/client": "0.1.104",
     "cors": "^2.8.5",
     "express": "^4.21.2",
     "ffmpeg-static": "^5.3.0",