livedesk 0.1.456 → 0.1.458

package/diagnostics/livedesk-mode3-capture-smoke.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import assert from 'node:assert/strict';
-import { spawn, spawnSync } from 'node:child_process';
+import { execFile, spawn, spawnSync } from 'node:child_process';
 import { createHash, randomBytes } from 'node:crypto';
 import { existsSync } from 'node:fs';
 import { chmod, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
@@ -13,13 +13,15 @@ import { fileURLToPath } from 'node:url';
 import { setTimeout as delay } from 'node:timers/promises';
 import WebSocket from 'ws';
 import {
+  buildMacDiagnosticResourceSample,
   buildMacModifierProbeSteps,
   buildMacModifierReleaseSteps,
   classifyMacPhysicalGate,
+  createAsyncSingleFlightSampler,
   noteMacModifierAfterAppliedAck,
   noteMacModifierBeforeSend,
-  parseMacHelperProcesses,
-  parseMacLiveDeskRuntimeProcesses
+  parseMacLiveDeskRuntimeProcesses,
+  summarizeMacDiagnosticResourceSamples
 } from './livedesk-mac-physical-gate-core.mjs';
 import {
   acquireMacDiagnosticLease,
@@ -38,6 +40,7 @@ const publicMacPhysicalDiagnostic = String(rawArguments[0] || '').toLowerCase()
 const macPhysicalGate = process.argv.includes('--mac-physical-gate') || publicMacPhysicalDiagnostic;
 const isWindows = process.platform === 'win32';
 const isMacPhysicalGate = process.platform === 'darwin' && macPhysicalGate;
+const MAC_PHYSICAL_RESOURCE_SAMPLE_INTERVAL_MS = 500;
 if (macPhysicalGate && !isMacPhysicalGate) {
   const message = 'Mac physical diagnostic requires macOS hardware; no LiveDesk process was started.';
   if (publicMacPhysicalDiagnostic) {
@@ -313,9 +316,28 @@ function readMacProcessSnapshot() {
   return String(result.stdout || '');
 }
 
-function readMacCaptureHelpers() {
-  if (!isMacPhysicalGate) return [];
-  return parseMacHelperProcesses(readMacProcessSnapshot());
+function readMacProcessResourceSnapshot() {
+  return new Promise((resolveSnapshot, rejectSnapshot) => {
+    execFile(
+      '/bin/ps',
+      ['-axo', 'pid=,ppid=,comm=,%cpu=,rss=,args='],
+      {
+        encoding: 'utf8',
+        timeout: 2_000,
+        windowsHide: true,
+        maxBuffer: 4 * 1024 * 1024
+      },
+      (error, stdout, stderr) => {
+        if (error) {
+          rejectSnapshot(new Error(
+            `resource ps failed: ${String(stderr || error.message || error)}`
+          ));
+          return;
+        }
+        resolveSnapshot(String(stdout || ''));
+      }
+    );
+  });
 }
 
 function readConflictingMacLiveDeskRuntimes() {
@@ -469,6 +491,10 @@ async function decodeKeyFrame(accessUnit, label) {
         windowsHide: true
       });
       ownedDecoders.set(decoder, { directory, label });
+      if (isMacPhysicalGate && Number(decoder?.pid || 0) > 1) {
+        macOwnedDecoderPids.add(Number(decoder.pid));
+        requestMacResourceSample('steadyCapture');
+      }
       let errors = '';
       let settled = false;
       let unsubscribeAbort = () => {};
@@ -566,12 +592,20 @@ let hub;
 let agent;
 let frameSocket;
 const ownedDecoders = new Map();
+const macOwnedDecoderPids = new Set();
 let hubLogs = [];
 let agentLogs = [];
 let helperSampleTimer;
 let helperMaxConcurrent = 0;
 const helperObservedPids = new Set();
 let helperFinalCount = 0;
+let macResourcePhase = '';
+const macResourceSamples = {
+  baseline: [],
+  steadyCapture: [],
+  afterCleanup: []
+};
+const macResourceSamplingErrors = new Set();
 let macModifierProbe = { expectedAcks: 8, appliedAcks: 0, applied: [], errors: [] };
 let macInitialPixelHash = '';
 let macNextPixelHash = '';
@@ -590,12 +624,62 @@ let macRunError = '';
 const macCleanupErrors = [];
 const macSignalHandlers = new Map();
 
-const sampleMacHelpers = () => {
+const collectMacResourceSample = async phase => {
+  if (!isMacPhysicalGate) {
+    return {
+      totalLiveDeskProcessCount: 0,
+      captureHelperCount: 0,
+      unownedLiveDeskPids: [],
+      processes: []
+    };
+  }
+  let sample;
+  try {
+    sample = buildMacDiagnosticResourceSample(
+      await readMacProcessResourceSnapshot(),
+      {
+        diagnosticPid: process.pid,
+        hubPid: hub?.pid,
+        agentPid: agent?.pid,
+        decoderPids: [...ownedDecoders.keys()]
+          .filter(decoder => decoder?.exitCode === null && decoder?.signalCode === null)
+          .map(decoder => decoder?.pid)
+      }
+    );
+  } catch {
+    const safePhase = String(phase || 'unassigned').replace(/[^a-z-]/gi, '') || 'unassigned';
+    macResourceSamplingErrors.add(`${safePhase}:unavailable`);
+    throw new Error(`Mac ${safePhase} process resource telemetry is unavailable.`);
+  }
+  helperMaxConcurrent = Math.max(helperMaxConcurrent, sample.captureHelperCount);
+  for (const helper of sample.processes.filter(record => record.role === 'capture-helper')) {
+    helperObservedPids.add(helper.pid);
+  }
+  if (Object.prototype.hasOwnProperty.call(macResourceSamples, phase)) {
+    const phaseSamples = macResourceSamples[phase];
+    phaseSamples.push(sample);
+    while (phaseSamples.length > 240) phaseSamples.shift();
+  }
+  return sample;
+};
+
+const macResourceSampler = createAsyncSingleFlightSampler(collectMacResourceSample);
+
+const sampleMacResources = phase => macResourceSampler.run(phase);
+
+const requestMacResourceSample = phase => {
+  const pending = macResourceSampler.request(phase);
+  pending?.catch(() => {
+    // A later required sample reports persistent process telemetry failure.
+  });
+};
+
+const sampleMacHelpers = async () => {
   if (!isMacPhysicalGate) return [];
-  const helpers = readMacCaptureHelpers();
-  helperMaxConcurrent = Math.max(helperMaxConcurrent, helpers.length);
-  for (const helper of helpers) helperObservedPids.add(helper.pid);
-  return helpers;
+  const sample = await sampleMacResources(macResourcePhase);
+  return sample.processes
+    .filter(record => record.role === 'capture-helper')
+    .map(record => ({ pid: record.pid }));
 };
 
 async function stopMacAgentAndSampleDrain() {
@@ -614,7 +698,7 @@ async function stopMacAgentAndSampleDrain() {
   } finally {
     const drainDeadline = Date.now() + 5_000;
     do {
-      const helpers = sampleMacHelpers();
+      const helpers = await sampleMacHelpers();
       helperFinalCount = helpers.length;
       if (helperFinalCount === 0) break;
       await delay(100);
@@ -641,8 +725,27 @@ async function writeMacPhysicalGateReport() {
   while (true) {
     const diagnostic = readDiagnosticState();
     const stateToken = diagnosticStateToken(diagnostic);
+    const expectedSteadyProcesses = [
+      { role: 'hub', pid: hub?.pid, ownedByDiagnostic: true },
+      { role: 'remote-fast', pid: agent?.pid, ownedByDiagnostic: true },
+      ...[...macOwnedDecoderPids].map(pid => ({
+        role: 'decoder',
+        pid,
+        ownedByDiagnostic: true
+      }))
+    ];
+    const resources = {
+      sampleIntervalMs: MAC_PHYSICAL_RESOURCE_SAMPLE_INTERVAL_MS,
+      samplingErrors: [...macResourceSamplingErrors],
+      baseline: summarizeMacDiagnosticResourceSamples(macResourceSamples.baseline),
+      steadyCapture: summarizeMacDiagnosticResourceSamples(
+        macResourceSamples.steadyCapture,
+        { expectedProcesses: expectedSteadyProcesses }
+      ),
+      afterCleanup: summarizeMacDiagnosticResourceSamples(macResourceSamples.afterCleanup)
+    };
     snapshot = {
-      schemaVersion: 1,
+      schemaVersion: 2,
       generatedAt,
       runtimeId: clientRuntimeId,
       requestedFps: 30,
@@ -665,6 +768,7 @@ async function writeMacPhysicalGateReport() {
       },
       modifier: macModifierProbe,
       transport: macTransport,
+      resources,
       diagnostic,
       error: diagnostic.runError
     };
@@ -688,6 +792,13 @@ async function writeMacPhysicalGateReport() {
     `Mac physical gate helper: max=${helperMaxConcurrent}, final=${helperFinalCount}, `
     + `pids=${[...helperObservedPids].join(',') || '-'}.`
   );
+  const resourceEvidence = snapshot.resources;
+  console.log(
+    `Mac physical gate resources: baseline=${resourceEvidence.baseline.totalLiveDeskProcessCount}, `
+    + `steady-peak=${resourceEvidence.steadyCapture.totalLiveDeskProcessCountPeak}, `
+    + `after-cleanup=${resourceEvidence.afterCleanup.totalLiveDeskProcessCount}, `
+    + `samples=${resourceEvidence.steadyCapture.sampleCount}.`
+  );
   console.log(
     `Mac physical gate monitor: count=${macMonitorCount}, generation=${macInitialGeneration}->${macNextGeneration}, `
     + `pixels=${macInitialPixelHash.slice(0, 12) || '-'}->${macNextPixelHash.slice(0, 12) || '-'}.`
@@ -766,6 +877,12 @@ async function cleanupOwnedDiagnosticResources() {
     }
   }
   if (!isMacPhysicalGate) return;
+  macResourcePhase = 'afterCleanup';
+  try {
+    await sampleMacResources(macResourcePhase);
+  } catch (error) {
+    recordMacCleanupError('resource-snapshot-after-cleanup', error);
+  }
   const teardownPlan = buildMacDiagnosticTeardownPlan({
     agentStopped,
     hubStopped,
@@ -843,14 +960,12 @@ try {
   macIsolation = await prepareMacDiagnosticIsolation();
   if (isMacPhysicalGate) {
     macDiagnosticAbort.throwIfRequested();
-    sampleMacHelpers();
+    macResourcePhase = 'baseline';
+    await sampleMacResources(macResourcePhase);
+    macResourcePhase = '';
     helperSampleTimer = setInterval(() => {
-      try {
-        sampleMacHelpers();
-      } catch {
-        // The final synchronous sample reports a persistent ps failure.
-      }
-    }, 100);
+      requestMacResourceSample(macResourcePhase);
+    }, MAC_PHYSICAL_RESOURCE_SAMPLE_INTERVAL_MS);
     helperSampleTimer.unref?.();
   }
   const isolatedHubEnvironment = isMacPhysicalGate
@@ -989,7 +1104,11 @@ try {
     frameSocket.on('message', handleMessage);
   });
 
-  frameSocket.send(JSON.stringify({
+  if (isMacPhysicalGate) {
+    macResourcePhase = 'steadyCapture';
+    await sampleMacResources(macResourcePhase);
+  }
+  frameSocket.send(JSON.stringify({
     type: 'subscribe',
     deviceIds: [connectedDeviceId],
     autoStartLive: true,

package/hub/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@livedesk/hub",
-  "version": "0.1.23",
+  "version": "0.1.25",
   "description": "LiveDesk local Hub API and browser frame bridge",
   "type": "module",
   "main": "src/server.js",

package/hub/src/live-stream-monitor-contract.js

@@ -0,0 +1,38 @@
+export const LIVE_STREAM_MONITOR_INDEX_MIN = 0;
+export const LIVE_STREAM_MONITOR_INDEX_MAX = 63;
+
+export function parseExactLiveStreamMonitorIndex(value) {
+    return typeof value === 'number'
+        && Number.isInteger(value)
+        && value >= LIVE_STREAM_MONITOR_INDEX_MIN
+        && value <= LIVE_STREAM_MONITOR_INDEX_MAX
+        ? value
+        : null;
+}
+
+export function isReusedLiveStreamFrameReady(result, activeStream, expectedBinding) {
+    const expectedMonitorIndex = parseExactLiveStreamMonitorIndex(expectedBinding?.monitorIndex);
+    const activeMonitorIndex = parseExactLiveStreamMonitorIndex(activeStream?.monitorIndex);
+    const latestFrame = activeStream?.latestFrame;
+    const frameMonitorIndex = parseExactLiveStreamMonitorIndex(latestFrame?.monitorIndex);
+    const expectedStreamId = String(expectedBinding?.streamId || '');
+    const expectedCommandId = String(expectedBinding?.commandId || '');
+    const expectedCaptureGeneration = Number(expectedBinding?.captureGeneration || 0);
+
+    return result?.reused === true
+        && result?.ready === true
+        && Number(activeStream?.framesReceived || 0) > 0
+        && !!expectedStreamId
+        && String(activeStream?.streamId || '') === expectedStreamId
+        && !!expectedCommandId
+        && String(activeStream?.commandId || '') === expectedCommandId
+        && Number.isInteger(expectedCaptureGeneration)
+        && expectedCaptureGeneration > 0
+        && Number(activeStream?.captureGeneration || 0) === expectedCaptureGeneration
+        && latestFrame?.currentGenerationVerified === true
+        && String(latestFrame?.commandId || '') === expectedCommandId
+        && Number(latestFrame?.captureGeneration || 0) === expectedCaptureGeneration
+        && expectedMonitorIndex !== null
+        && activeMonitorIndex === expectedMonitorIndex
+        && frameMonitorIndex === expectedMonitorIndex;
+}

package/hub/src/remote-hub.js

@@ -2,6 +2,7 @@ import net from 'net';
 import os from 'os';
 import crypto from 'crypto';
 import { createHubRelayControl } from './transport/relay-hub-control.js';
+import { parseExactLiveStreamMonitorIndex } from './live-stream-monitor-contract.js';
 
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_REMOTE_HUB_HOST = '0.0.0.0';
@@ -689,21 +690,39 @@ const SUPPORTED_AGENT_OPERATIONS = new Set([
     'logs.collect'
 ]);
 
-function normalizeAgentOperation(value) {
-    const operation = safeString(value, 80).toLowerCase();
-    return SUPPORTED_AGENT_OPERATIONS.has(operation) ? operation : '';
-}
-
-function normalizeRemoteInputEvent(value = {}) {
-    const input = value && typeof value === 'object' ? value : {};
-    const type = safeString(input.type || input.Type, 48);
+function normalizeAgentOperation(value) {
+    const operation = safeString(value, 80).toLowerCase();
+    return SUPPORTED_AGENT_OPERATIONS.has(operation) ? operation : '';
+}
+
+const REMOTE_INPUT_MONITOR_KEYS = Object.freeze([
+    'monitorIndex',
+    'MonitorIndex',
+    'screenIndex',
+    'ScreenIndex',
+    'displayIndex',
+    'DisplayIndex'
+]);
+
+function readRawRemoteInputMonitorIndex(input) {
+    for (const key of REMOTE_INPUT_MONITOR_KEYS) {
+        if (Object.prototype.hasOwnProperty.call(input, key)) {
+            return input[key];
+        }
+    }
+    return undefined;
+}
+
+function normalizeRemoteInputEvent(value = {}) {
+    const input = value && typeof value === 'object' ? value : {};
+    const type = safeString(input.type || input.Type, 48);
     const normalizedX = Number(input.normalizedX ?? input.NormalizedX);
     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 monitorIndex = parseExactLiveStreamMonitorIndex(readRawRemoteInputMonitorIndex(input));
     const inputSeq = Number(input.inputSeq ?? input.InputSeq);
     const issuedAtEpochMs = Number(input.issuedAtEpochMs ?? input.IssuedAtEpochMs);
     const hubReceivedAtEpochMs = Number(input.hubReceivedAtEpochMs ?? input.HubReceivedAtEpochMs);
@@ -719,7 +738,7 @@ function normalizeRemoteInputEvent(value = {}) {
         type,
         // A missing monitor is not equivalent to the primary display. Control
         // input must prove the exact monitor owned by its capture generation.
-        monitorIndex: Number.isFinite(monitorIndex) ? normalizeMonitorIndex(monitorIndex) : null,
+        monitorIndex,
         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),
@@ -3983,6 +4002,34 @@ export function createRemoteHub(options = {}) {
             });
             return null;
         }
+        const pendingMonitorIndex = parseExactLiveStreamMonitorIndex(pending.monitorIndex);
+        const messageMonitorIndex = parseExactLiveStreamMonitorIndex(message.monitorIndex);
+        if (pendingMonitorIndex === null || messageMonitorIndex === null) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'invalid-pending-monitor-metadata',
+                streamId: streamState.streamId,
+                commandId,
+                captureGeneration: messageCaptureGeneration,
+                pendingCaptureGeneration,
+                monitorIndex: messageMonitorIndex,
+                pendingMonitorIndex,
+                transport
+            });
+            return null;
+        }
+        if (messageMonitorIndex !== pendingMonitorIndex) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'stale-pending-monitor',
+                streamId: streamState.streamId,
+                commandId,
+                captureGeneration: messageCaptureGeneration,
+                pendingCaptureGeneration,
+                monitorIndex: messageMonitorIndex,
+                pendingMonitorIndex,
+                transport
+            });
+            return null;
+        }
 
         const previousCommandId = safeString(streamState.commandId, 128);
         const transfer = buildRemoteFrameTransferDescriptorFromMessage(
@@ -4011,9 +4058,7 @@ export function createRemoteHub(options = {}) {
             height: Number.isFinite(Number(message.height)) ? Number(message.height) : Number(pending.height || 0),
             sourceWidth: Number.isFinite(Number(message.sourceWidth)) ? Number(message.sourceWidth) : Number(pending.sourceWidth || 0),
             sourceHeight: Number.isFinite(Number(message.sourceHeight)) ? Number(message.sourceHeight) : Number(pending.sourceHeight || 0),
-            monitorIndex: Number.isFinite(Number(message.monitorIndex))
-                ? normalizeMonitorIndex(message.monitorIndex)
-                : Number(pending.monitorIndex || 0),
+            monitorIndex: pendingMonitorIndex,
             monitorCount: Number.isFinite(Number(message.monitorCount))
                 ? clampNumber(message.monitorCount, 1, 64, 1)
                 : Number(pending.monitorCount || 1),
@@ -4106,6 +4151,37 @@ export function createRemoteHub(options = {}) {
             return true;
         }
 
+        const activeMonitorIndex = parseExactLiveStreamMonitorIndex(streamState.monitorIndex);
+        const messageMonitorIndex = parseExactLiveStreamMonitorIndex(message.monitorIndex);
+        if (activeMonitorIndex === null || messageMonitorIndex === null) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'invalid-live-stream-monitor-metadata',
+                streamId,
+                commandId,
+                activeCommandId,
+                captureGeneration: Number(message.captureGeneration || 0),
+                activeCaptureGeneration: Number(streamState.captureGeneration || 0),
+                monitorIndex: messageMonitorIndex,
+                activeMonitorIndex,
+                transport
+            });
+            return false;
+        }
+        if (messageMonitorIndex !== activeMonitorIndex) {
+            emitRemoteEvent('RemoteLiveStreamOpenIgnored', device, {
+                reason: 'stale-live-stream-monitor',
+                streamId,
+                commandId,
+                activeCommandId,
+                captureGeneration: Number(message.captureGeneration || 0),
+                activeCaptureGeneration: Number(streamState.captureGeneration || 0),
+                monitorIndex: messageMonitorIndex,
+                activeMonitorIndex,
+                transport
+            });
+            return false;
+        }
+
         const transfer = buildRemoteFrameTransferDescriptorFromMessage(message, streamState.mode || DEFAULT_REMOTE_FRAME_MODE);
         const openedAt = safeString(message.openedAt, 80) || device.lastSeenAt || new Date().toISOString();
         const nextStreamState = {
@@ -4126,7 +4202,7 @@ export function createRemoteHub(options = {}) {
             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),
+            monitorIndex: activeMonitorIndex,
             monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
             streamPurpose: safeString(message.streamPurpose || streamState.streamPurpose, 24) || 'wall',
             captureGeneration: Number.isSafeInteger(Number(message.captureGeneration)) && Number(message.captureGeneration) > 0
@@ -4204,8 +4280,40 @@ export function createRemoteHub(options = {}) {
             });
             return false;
         }
-
-        const byteLength = normalizeFrameByteLength(framePayload, frameData);
+        const activeMonitorIndex = parseExactLiveStreamMonitorIndex(streamState.monitorIndex);
+        const frameMonitorIndex = parseExactLiveStreamMonitorIndex(message.monitorIndex);
+        if (activeMonitorIndex === null || frameMonitorIndex === null) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'invalid-live-stream-monitor-frame-metadata',
+                streamId,
+                commandId,
+                captureGeneration: frameCaptureGeneration,
+                activeCaptureGeneration,
+                monitorIndex: frameMonitorIndex,
+                activeMonitorIndex,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
+        if (frameMonitorIndex !== activeMonitorIndex) {
+            device.counters.liveFramesDropped += 1;
+            emitRemoteEvent('RemoteFrameDropped', device, {
+                reason: 'stale-live-stream-monitor-frame',
+                streamId,
+                commandId,
+                captureGeneration: frameCaptureGeneration,
+                activeCaptureGeneration,
+                monitorIndex: frameMonitorIndex,
+                activeMonitorIndex,
+                frameSeq: Number.isFinite(frameSeq) ? frameSeq : null,
+                transport
+            });
+            return false;
+        }
+
+        const byteLength = normalizeFrameByteLength(framePayload, frameData);
         if ((!Buffer.isBuffer(framePayload) && !frameData)
             || byteLength > MAX_STREAM_BINARY_BYTES
             || !Number.isFinite(frameSeq)) {
@@ -4242,7 +4350,8 @@ export function createRemoteHub(options = {}) {
         const currentGenerationVerified = (!activeCommandId || commandId === activeCommandId)
             && (activeCaptureGeneration <= 0
                 || (frameCaptureGeneration > 0
-                    && frameCaptureGeneration === activeCaptureGeneration));
+                    && frameCaptureGeneration === activeCaptureGeneration))
+            && frameMonitorIndex === activeMonitorIndex;
         const readyFrameReceivedBeforeFrame = streamState.readyFrameReceived === true;
         const captureTimingAvailable = hasFrameCaptureTiming(message);
         const videoTransport = transport === 'udp-p2p'
@@ -4323,7 +4432,7 @@ export function createRemoteHub(options = {}) {
             udpIncompleteFrames: Number.isFinite(Number(message.udpIncompleteFrames)) ? Number(message.udpIncompleteFrames) : 0,
             hardwareEncoder: safeString(message.hardwareEncoder, 80),
             platformProfile: safeString(message.platformProfile, 80),
-            monitorIndex: Number.isFinite(Number(message.monitorIndex)) ? normalizeMonitorIndex(message.monitorIndex) : Number(streamState.monitorIndex || 0),
+            monitorIndex: activeMonitorIndex,
             monitorCount: Number.isFinite(Number(message.monitorCount)) ? clampNumber(message.monitorCount, 1, 64, 1) : Number(streamState.monitorCount || 1),
             transferProtocol: transfer.transferProtocol,
             transferProtocolVersion: transfer.transferProtocolVersion,
@@ -4402,7 +4511,6 @@ export function createRemoteHub(options = {}) {
         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;
@@ -6457,8 +6565,12 @@ export function createRemoteHub(options = {}) {
         }
         const activeCaptureGeneration = Number(activeLiveStream.captureGeneration || 0);
         const frameCaptureGeneration = Number(latestFrame.captureGeneration || 0);
-        return activeCaptureGeneration <= 0
-            || (frameCaptureGeneration > 0 && frameCaptureGeneration === activeCaptureGeneration);
+        const activeMonitorIndex = parseExactLiveStreamMonitorIndex(activeLiveStream.monitorIndex);
+        const frameMonitorIndex = parseExactLiveStreamMonitorIndex(latestFrame.monitorIndex);
+        return activeMonitorIndex !== null
+            && frameMonitorIndex === activeMonitorIndex
+            && (activeCaptureGeneration <= 0
+                || (frameCaptureGeneration > 0 && frameCaptureGeneration === activeCaptureGeneration));
     }
 
     function getLiveStreamFreshWindowMs(activeLiveStream) {

package/hub/src/server.js

@@ -7,8 +7,9 @@ import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, wri
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import os from 'node:os';
-import { WebSocketServer } from 'ws';
+import { WebSocketServer } from 'ws';
 import { createRemoteHub } from './remote-hub.js';
+import { isReusedLiveStreamFrameReady } from './live-stream-monitor-contract.js';
 import { buildMode4AtlasSessionKey, Mode4AtlasPool, planMode4AtlasInputTransitions } from './mode4-atlas-pool.js';
 import { resolveMode4AtlasTileSize } from './mode4-atlas-sizing.js';
 import { createHubFilesystem } from './filesystem/hub-filesystem.js';
@@ -1976,12 +1977,7 @@ function startFrameSubscriptionLive(ws, reason = 'subscribe', onlyDeviceId = '',
         readySent: false
       };
       const activeStream = device?.activeLiveStream;
-      const reusedFrameReady = result.reused === true
-        && result.ready === true
-        && Number(result.framesReceived ?? activeStream?.framesReceived ?? 0) > 0
-        && String(activeStream?.streamId || expectedBinding.streamId) === expectedBinding.streamId
-        && String(activeStream?.commandId || expectedBinding.commandId) === expectedBinding.commandId
-        && Number(activeStream?.captureGeneration || expectedBinding.captureGeneration) === expectedBinding.captureGeneration;
+      const reusedFrameReady = isReusedLiveStreamFrameReady(result, activeStream, expectedBinding);
       expectedBinding.readySent = reusedFrameReady;
       ws.liveDeskStreamIdsByDeviceId.set(deviceId, result.streamId);
       ws.liveDeskExpectedStreamBindingsByDeviceId.set(deviceId, expectedBinding);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "livedesk",
-  "version": "0.1.456",
-  "livedeskClientVersion": "0.1.211",
+  "version": "0.1.458",
+  "livedeskClientVersion": "0.1.212",
   "buildFlavor": "production",
   "description": "LiveDesk Hub and client launcher",
   "type": "module",
@@ -50,10 +50,10 @@
     "ws": "^8.18.3"
   },
   "optionalDependencies": {
-    "@livedesk/fast-linux-x64": "0.1.415",
-    "@livedesk/fast-osx-arm64": "0.1.415",
-    "@livedesk/fast-osx-x64": "0.1.415",
-    "@livedesk/fast-win-x64": "0.1.415"
+    "@livedesk/fast-linux-x64": "0.1.416",
+    "@livedesk/fast-osx-arm64": "0.1.416",
+    "@livedesk/fast-osx-x64": "0.1.416",
+    "@livedesk/fast-win-x64": "0.1.416"
   },
   "publishConfig": {
     "access": "public"