livedesk 0.1.567 → 0.1.568

package/hub/src/remote-hub.js

@@ -9533,7 +9533,7 @@ export function createRemoteHub(options = {}) {
         return getLiveStreamIdleMs(activeLiveStream) <= getLiveStreamFreshWindowMs(activeLiveStream);
     }
 
-    function liveStreamMatchesOptions(activeLiveStream, normalized) {
+    function liveStreamMatchesOptions(activeLiveStream, normalized) {
         if (!activeLiveStream?.active) {
             return false;
         }
@@ -9544,8 +9544,49 @@ export function createRemoteHub(options = {}) {
             && Number(activeLiveStream.quality || 0) === normalized.quality
             && Number(activeLiveStream.monitorIndex || 0) === normalized.monitorIndex
             && (safeString(activeLiveStream.streamPurpose, 24).toLowerCase() || 'wall')
-                === normalized.streamPurpose;
-    }
+                === normalized.streamPurpose;
+    }
+
+    function liveStreamMatchesOwnerIdentity(activeLiveStream, normalized) {
+        if (!activeLiveStream) {
+            return false;
+        }
+        return activeLiveStream.frameMode === normalized.transfer.frameMode
+            && Number(activeLiveStream.monitorIndex || 0) === normalized.monitorIndex
+            && (safeString(activeLiveStream.streamPurpose, 24).toLowerCase() || 'wall')
+                === normalized.streamPurpose;
+    }
+
+    function sharedLiveProfileResult(device, activeLiveStream, normalized, extra = {}) {
+        return {
+            ok: true,
+            commandId: activeLiveStream.commandId,
+            sessionId: device.sessionId,
+            streamId: activeLiveStream.streamId,
+            streamPurpose: safeString(activeLiveStream.streamPurpose, 24) || normalized.streamPurpose,
+            fps: Number(activeLiveStream.fps || normalized.fps),
+            mode: activeLiveStream.mode || normalized.transfer.mode,
+            frameMode: activeLiveStream.frameMode || normalized.transfer.frameMode,
+            monitorIndex: Number(activeLiveStream.monitorIndex ?? normalized.monitorIndex),
+            captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+            ready: liveStreamHasCurrentFrame(activeLiveStream),
+            reused: true,
+            sharedProfileReused: true,
+            requestedProfile: {
+                fps: normalized.fps,
+                maxWidth: normalized.maxWidth,
+                maxHeight: normalized.maxHeight,
+                quality: normalized.quality
+            },
+            effectiveProfile: {
+                fps: Number(activeLiveStream.fps || normalized.fps),
+                maxWidth: Number(activeLiveStream.maxWidth || normalized.maxWidth),
+                maxHeight: Number(activeLiveStream.maxHeight || normalized.maxHeight),
+                quality: Number(activeLiveStream.quality || normalized.quality)
+            },
+            ...extra
+        };
+    }
 
     function startLiveStream(deviceId, options = {}) {
         const device = devices.get(String(deviceId || ''));
@@ -9701,17 +9742,28 @@ export function createRemoteHub(options = {}) {
         const captureClaim = claimSingleLiveCapture(deviceId, device, streamId, streamPurpose);
         if (!captureClaim.ok) return captureClaim;
         const activeLiveStream = getDeviceLiveStream(device, streamId);
-        const pendingDescriptor = getPendingLiveStreamDescriptor(activeLiveStream);
-        if (pendingDescriptor?.commandId) {
-            const pendingMatchesRequest = liveStreamMatchesOptions(pendingDescriptor, normalized);
-            if (pendingMatchesRequest && liveStreamReplacementStillPending(activeLiveStream)) {
-                emitRemoteEvent('RemoteLiveStreamRestartPending', device, {
+        const pendingDescriptor = getPendingLiveStreamDescriptor(activeLiveStream);
+        if (pendingDescriptor?.commandId) {
+            const pendingMatchesRequest = liveStreamMatchesOptions(pendingDescriptor, normalized);
+            const pendingMatchesSharedOwner = options.forceRestart !== true
+                && options.reuseExisting === true
+                && options.reuseSharedExisting === true
+                && liveStreamMatchesOwnerIdentity(pendingDescriptor, normalized);
+            if ((pendingMatchesRequest || pendingMatchesSharedOwner)
+                && liveStreamReplacementStillPending(activeLiveStream)) {
+                emitRemoteEvent('RemoteLiveStreamRestartPending', device, {
                     streamId,
                     commandId: pendingDescriptor.commandId,
                     activeCommandId: activeLiveStream.commandId,
                     reason: safeString(options.restartReason || 'duplicate-restart', 128)
                 });
-                return {
+                if (pendingMatchesSharedOwner && !pendingMatchesRequest) {
+                    return sharedLiveProfileResult(device, pendingDescriptor, normalized, {
+                        ready: false,
+                        pending: true
+                    });
+                }
+                return {
                     ok: true,
                     commandId: pendingDescriptor.commandId,
                     sessionId: device.sessionId,
@@ -9764,9 +9816,9 @@ export function createRemoteHub(options = {}) {
                 reused: true
             };
         }
-        if (activeLiveStream
-            && options.forceRestart !== true
-            && options.reuseExisting === true
+        if (activeLiveStream
+            && options.forceRestart !== true
+            && options.reuseExisting === true
             && liveStreamMatchesOptions(activeLiveStream, normalized)
             && liveStreamIsReusable(activeLiveStream)) {
             return {
@@ -9781,9 +9833,28 @@ export function createRemoteHub(options = {}) {
                 monitorIndex: Number(activeLiveStream.monitorIndex || monitorIndex),
                 captureGeneration: Number(activeLiveStream.captureGeneration || 0),
                 ready: liveStreamHasCurrentFrame(activeLiveStream),
-                reused: true
-            };
-        }
+                reused: true
+            };
+        }
+        if (activeLiveStream
+            && options.forceRestart !== true
+            && options.reuseExisting === true
+            && options.reuseSharedExisting === true
+            && liveStreamMatchesOwnerIdentity(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)) {
+            emitRemoteEvent('RemoteLiveStreamSharedProfileReused', device, {
+                streamId,
+                commandId: activeLiveStream.commandId,
+                captureGeneration: Number(activeLiveStream.captureGeneration || 0),
+                requestedFps: normalized.fps,
+                effectiveFps: Number(activeLiveStream.fps || normalized.fps),
+                requestedMaxWidth: normalized.maxWidth,
+                requestedMaxHeight: normalized.maxHeight,
+                effectiveMaxWidth: Number(activeLiveStream.maxWidth || normalized.maxWidth),
+                effectiveMaxHeight: Number(activeLiveStream.maxHeight || normalized.maxHeight)
+            });
+            return sharedLiveProfileResult(device, activeLiveStream, normalized);
+        }
         if (activeLiveStream
             && options.forceRestart !== true
             && liveStreamMatchesOptions(activeLiveStream, normalized)

package/hub/src/server.js

@@ -1821,7 +1821,7 @@ function unregisterFrameClient(ws) {
   retireFrameClientSendLane(ws);
 }
 
-function hasOtherFrameStreamOwner(ws, deviceId, streamId, streamPurpose = '') {
+function hasOtherFrameStreamOwner(ws, deviceId, streamId, streamPurpose = '') {
   if (!streamId) {
     return false;
   }
@@ -1844,7 +1844,27 @@ function hasOtherFrameStreamOwner(ws, deviceId, streamId, streamPurpose = '') {
     }
   }
   return false;
-}
+}
+
+function hasOtherFrameStreamDemand(ws, deviceId, streamPurpose = '') {
+  const normalizedPurpose = String(streamPurpose || '').trim().toLowerCase();
+  if (!deviceId || !normalizedPurpose) {
+    return false;
+  }
+  for (const candidate of frameClients) {
+    if (candidate === ws || candidate.readyState !== candidate.OPEN) {
+      continue;
+    }
+    if (candidate.liveDeskAutoStart === true
+      && candidate.liveDeskDeviceIds instanceof Set
+      && candidate.liveDeskDeviceIds.has(deviceId)
+      && String(candidate.liveDeskLiveOptions?.streamPurpose || '').trim().toLowerCase()
+        === normalizedPurpose) {
+      return true;
+    }
+  }
+  return false;
+}
 
 function frameStreamStopKey(deviceId, streamId, streamPurpose) {
   return `${deviceId}\u0000${streamId}\u0000${streamPurpose}`;
@@ -2138,15 +2158,24 @@ function snapshotFrameLaneResourceHealth() {
       const bindings = ws.liveDeskExpectedStreamBindingsByDeviceId instanceof Map
         ? [...ws.liveDeskExpectedStreamBindingsByDeviceId.values()]
         : [];
-      return {
+      return {
         deviceIds: bindings
           .map(binding => String(binding?.deviceId || '').trim())
           .filter(Boolean)
           .slice(0, 16),
-        streamPurposes: [...new Set(bindings
+        streamPurposes: [...new Set(bindings
           .map(binding => String(binding?.streamPurpose || '').trim().toLowerCase())
-          .filter(Boolean))]
-          .slice(0, 4),
+          .filter(Boolean))]
+          .slice(0, 4),
+        requestedProfile: ws.liveDeskLiveOptions ? {
+          frameMode: String(ws.liveDeskLiveOptions.frameMode || ws.liveDeskLiveOptions.mode || ''),
+          streamPurpose: String(ws.liveDeskLiveOptions.streamPurpose || ''),
+          fps: Math.max(0, Number(ws.liveDeskLiveOptions.fps || 0)),
+          maxWidth: Math.max(0, Number(ws.liveDeskLiveOptions.maxWidth || 0)),
+          maxHeight: Math.max(0, Number(ws.liveDeskLiveOptions.maxHeight || 0)),
+          quality: Math.max(0, Number(ws.liveDeskLiveOptions.quality || 0))
+        } : null,
+        sharedProfileReuseCount: Math.max(0, Number(ws.liveDeskSharedProfileReuseCount || 0)),
         queueDepth: Math.max(0, Number(lane?.queue?.length || 0)),
         queueLimit: frameClientQueueLimit(ws),
         queueHighWaterPackets: Math.max(0, Number(lane?.queuedPacketsHighWater || 0)),
@@ -2934,14 +2963,28 @@ function startFrameSubscriptionLive(
     const monitorIndex = Object.prototype.hasOwnProperty.call(liveOptions.monitorSelections || {}, deviceId)
       ? liveOptions.monitorSelections[deviceId]
       : liveOptions.monitorIndex;
-    const result = remoteHub.startLiveStream(deviceId, {
-      ...liveOptions,
-      monitorIndex,
-      reuseExisting: liveOptions.forceRestart !== true
-        && (liveOptions.reuseExisting === true || reason === 'subscribe' || reason === 'watchdog'),
-      silentReuse: reason === 'watchdog' && liveOptions.forceRestart !== true
-    });
-    if (result?.ok) {
+    const result = remoteHub.startLiveStream(deviceId, {
+      ...liveOptions,
+      monitorIndex,
+      reuseExisting: liveOptions.forceRestart !== true
+        && (liveOptions.reuseExisting === true || reason === 'subscribe' || reason === 'watchdog'),
+      // Wall capture is one shared native encoder per device. Two open browser
+      // views may ask for different soft profiles (for example mobile 5 fps at
+      // 1080p and desktop 20 fps at 540p). Once a healthy shared owner exists,
+      // those preferences must bind to that owner instead of replacing it back
+      // and forth every time either view refreshes its subscription.
+      reuseSharedExisting: liveOptions.forceRestart !== true
+        && String(liveOptions.streamPurpose || '').trim().toLowerCase() === 'wall'
+        && hasOtherFrameStreamDemand(ws, deviceId, 'wall'),
+      silentReuse: reason === 'watchdog' && liveOptions.forceRestart !== true
+    });
+    if (result?.ok) {
+      if (result.sharedProfileReused === true) {
+        ws.liveDeskSharedProfileReuseCount = Math.max(
+          0,
+          Number(ws.liveDeskSharedProfileReuseCount || 0)
+        ) + 1;
+      }
       frameCaptureTransitionRetries.complete(ws, deviceId, intentGeneration, 'capture-started');
       const expectedBinding = {
         deviceId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "livedesk",
-  "version": "0.1.567",
+  "version": "0.1.568",
   "livedeskClientVersion": "0.1.249",
   "buildFlavor": "production",
   "description": "LiveDesk Hub and client launcher",

package/web/dist/livedesk-build-evidence.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 2,
   "kind": "livedesk-production-web-source-evidence",
-  "generatedAt": "2026-08-15T10:22:01.470Z",
-  "pwaRelease": "0.1.567",
-  "sourceHash": "d76472291fca94621046b84b576aee288905017153a70cc0244e7a8cea31ee1b",
+  "generatedAt": "2026-08-15T11:55:50.032Z",
+  "pwaRelease": "0.1.568",
+  "sourceHash": "b6ddf954042b6c26a3965235894648d5171bdc3e327c5c689e0d91989fd4f019",
   "sourceFileCount": 142,
-  "sourceBytes": 2244963,
+  "sourceBytes": 2245018,
   "viteEnvironmentHash": "4f53cda18c2baa0c0354bb5f9a3ecbe5ed12ab4d8e11ba873c2f11161202b945",
-  "outputHash": "cf0ba18f6abfb4a5d973030410dde8b6ebe7d968fe3b43bccdd22d4b8eaff25e",
+  "outputHash": "74cc3037596534ef697f26c4313052a213c1f54ad82a3be6b2de74af7633acf1",
   "outputFileCount": 18,
   "outputBytes": 1629754,
   "outputManifest": [
@@ -99,7 +99,7 @@
     {
       "path": "sw.js",
       "bytes": 1309,
-      "sha256": "51df49a75ed4edbd16f5f09cca6b2cdb4a6e616517fe8b4d9e7f4bca0c8886ee"
+      "sha256": "c12eb04df48d694da8a380a588343ee2ef242888c4285149b6a4839bff33c2ec"
     }
   ]
 }

package/web/dist/sw.js

@@ -1,4 +1,4 @@
-const PWA_RELEASE = '0.1.567';
+const PWA_RELEASE = '0.1.568';
 const OFFLINE_CACHE = `livedesk-pwa-offline-${PWA_RELEASE}`;
 const OFFLINE_URL = '/offline.html';