@livedesk/hub 0.1.66 → 0.1.68

package/src/remote-hub.js

@@ -17,14 +17,15 @@ import {
     BoundedSegmentedBuffer,
     createBoundedAgentBinaryIngressLane
 } from './transport/agent-binary-ingress.js';
-import {
-    REMOTE_CLIPBOARD_FILE_ACTIONS,
+import {
+    REMOTE_CLIPBOARD_FILE_ACTIONS,
     REMOTE_CLIPBOARD_LIMITS,
     REMOTE_CLIPBOARD_PROTOCOL,
     normalizeRemoteClipboardCommandResult,
     normalizeRemoteClipboardManifest,
     remoteClipboardContentNeedsFileTransfer
-} from './remote-clipboard-contract.mjs';
+} from './remote-clipboard-contract.mjs';
+import { liveProfileSatisfiesDemand } from './shared-wall-profile-contract.mjs';
 
 const DEFAULT_REMOTE_HUB_PORT = 5197;
 const DEFAULT_REMOTE_HUB_HOST = '0.0.0.0';
@@ -74,6 +75,8 @@ const LIVE_STREAM_MIN_FRESH_MS = 3000;
 const LIVE_STREAM_MAX_FRESH_MS = 12000;
 const TASK_BATCH_OWNER = Symbol('remote-hub-task-batch-owner');
 const DEFAULT_REMOTE_INPUT_ACK_TIMEOUT_MS = 5000;
+const REMOTE_INPUT_FAILURE_LOG_INTERVAL_MS = 5000;
+const REMOTE_INPUT_FAILURE_LOG_KEY_LIMIT = 32;
 // RemoteFast owns a shared 7s native stop deadline. Keep four seconds for a
 // priority command.result to cross either Direct or encrypted Relay transport.
 const DEFAULT_LIVE_CAPTURE_STOP_ACK_TIMEOUT_MS = 11000;
@@ -1530,7 +1533,7 @@ function readCapabilityFlag(capabilities, key) {
     return /^(1|true|yes|on)$/i.test(String(value || '').trim());
 }
 
-function createDeviceCounters(overrides = {}) {
+function createDeviceCounters(overrides = {}) {
     return {
         messagesReceived: 0,
         statusReceived: 0,
@@ -1546,8 +1549,10 @@ function createDeviceCounters(overrides = {}) {
         audioStreamsStopped: 0,
         audioFramesReceived: 0,
         audioFramesDropped: 0,
-        audioStatusReceived: 0,
-        tasksQueued: 0,
+        audioStatusReceived: 0,
+        remoteInputsApplied: 0,
+        remoteInputsRejected: 0,
+        tasksQueued: 0,
         taskResultsReceived: 0,
         taskResultsFailed: 0,
         taskResultsTimedOut: 0,
@@ -1815,6 +1820,38 @@ function serializeDeviceTask(task) {
     };
 }
 
+function createRemoteInputDiagnostics() {
+    return {
+        appliedCount: 0,
+        rejectedCount: 0,
+        lastOutcome: null,
+        lastApplied: null,
+        lastFailure: null
+    };
+}
+
+function serializeRemoteInputDiagnostics(diagnostics) {
+    const source = diagnostics && typeof diagnostics === 'object'
+        ? diagnostics
+        : createRemoteInputDiagnostics();
+    return {
+        appliedCount: Math.max(0, Number(source.appliedCount) || 0),
+        rejectedCount: Math.max(0, Number(source.rejectedCount) || 0),
+        lastOutcome: source.lastOutcome ? { ...source.lastOutcome } : null,
+        lastApplied: source.lastApplied ? { ...source.lastApplied } : null,
+        lastFailure: source.lastFailure ? { ...source.lastFailure } : null
+    };
+}
+
+function firstOptionalBoolean(...values) {
+    for (const value of values) {
+        if (typeof value === 'boolean') {
+            return value;
+        }
+    }
+    return null;
+}
+
 function serializeDevice(device, options = {}) {
     if (!device) {
         return null;
@@ -1895,8 +1932,9 @@ function serializeDevice(device, options = {}) {
         recentTasks: Array.isArray(device.recentTasks)
             ? device.recentTasks.map(serializeDeviceTask).filter(Boolean)
             : [],
-        status: { ...device.status },
-        counters: { ...device.counters }
+        status: { ...device.status },
+        remoteInputDiagnostics: serializeRemoteInputDiagnostics(device.remoteInputDiagnostics),
+        counters: { ...device.counters }
     };
 }
 
@@ -4942,9 +4980,11 @@ export function createRemoteHub(options = {}) {
                 latestAudioStatus: null,
                 latestTask,
                 recentTasks: latestTask ? [latestTask] : [],
-                pendingTaskCommands: new Map(),
-                pendingTaskTimers: new Map(),
-                counters: createDeviceCounters({
+                pendingTaskCommands: new Map(),
+                pendingTaskTimers: new Map(),
+                remoteInputDiagnostics: createRemoteInputDiagnostics(),
+                remoteInputFailureLogAt: new Map(),
+                counters: createDeviceCounters({
                     messagesReceived: 1,
                     statusReceived: 1,
                     tasksQueued: latestTask ? 1 : 0,
@@ -5239,9 +5279,11 @@ export function createRemoteHub(options = {}) {
             },
             latestTask: null,
             recentTasks: [],
-            pendingTaskCommands: new Map(),
-            pendingTaskTimers: new Map(),
-            synthetic: false,
+            pendingTaskCommands: new Map(),
+            pendingTaskTimers: new Map(),
+            remoteInputDiagnostics: createRemoteInputDiagnostics(),
+            remoteInputFailureLogAt: new Map(),
+            synthetic: false,
             counters: createDeviceCounters({ messagesReceived: 1 })
         };
 
@@ -5979,9 +6021,10 @@ export function createRemoteHub(options = {}) {
     function acknowledgePendingDedicatedInput(device, message = {}) {
         const state = device?.pendingDedicatedInputAckState;
         if (!state?.current) {
-            return false;
+            return null;
         }
         if (dedicatedInputAckMatches(state.current, message)) {
+            const acknowledged = state.current;
             if (state.timeoutTimer) {
                 clearTimeout(state.timeoutTimer);
                 state.timeoutTimer = null;
@@ -5989,15 +6032,16 @@ export function createRemoteHub(options = {}) {
             state.current = state.next;
             state.next = null;
             armPendingDedicatedInputAck(device);
-            return true;
+            return acknowledged;
         }
         if (dedicatedInputAckMatches(state.next, message)) {
             // A later ordered acknowledgement proves that the input reader is
             // still draining, even if an earlier diagnostic response vanished.
+            const acknowledged = state.next;
             clearPendingDedicatedInputAcks(device);
-            return true;
+            return acknowledged;
         }
-        return false;
+        return null;
     }
 
     function pruneCompletedInputFallbacks(device, now = Date.now()) {
@@ -6104,14 +6148,39 @@ export function createRemoteHub(options = {}) {
                 || pending?.inputEventId,
                 128),
             inputSeq,
-            inputType: safeString(
+            inputType: safeString(
                 message.inputType
                 || message.InputType
                 || result.inputType
                 || result.InputType
                 || pending?.inputType,
-                48),
-            monitorIndex: Number(
+                48),
+            controlSessionId: safeString(
+                message.controlSessionId
+                || message.ControlSessionId
+                || result.controlSessionId
+                || result.ControlSessionId
+                || pending?.controlSessionId
+                || device.sessionId,
+                160),
+            controlCommandId: safeString(
+                message.controlCommandId
+                || message.ControlCommandId
+                || result.controlCommandId
+                || result.ControlCommandId
+                || pending?.controlCommandId,
+                128),
+            captureGeneration: Math.max(0, Number(
+                message.captureGeneration
+                ?? message.CaptureGeneration
+                ?? result.captureGeneration
+                ?? result.CaptureGeneration
+                ?? pending?.captureGeneration
+                ?? 0) || 0),
+            inputSocketConnectionId: safeString(
+                pending?.inputSocketConnectionId,
+                128),
+            monitorIndex: Number(
                 message.monitorIndex
                 ?? message.MonitorIndex
                 ?? result.monitorIndex
@@ -6177,27 +6246,144 @@ export function createRemoteHub(options = {}) {
                 || message.FocusChanged === true
                 || result.focusChanged === true
                 || result.FocusChanged === true,
-            inputDiagnostic: message.inputDiagnostic === true
+            inputDiagnostic: message.inputDiagnostic === true
                 || message.InputDiagnostic === true
-                || result.inputDiagnostic === true
-                || result.InputDiagnostic === true,
-            fallback: pending?.fallback === true,
-            hubAcknowledgedAtEpochMs: Date.now()
-        };
-    }
-
-    function emitRemoteInputApplied(device, message = {}, pending = null) {
-        const outcome = buildRemoteInputOutcome(device, message, pending);
-        emitEvent('RemoteInputApplied', {
-            ...outcome,
-            agentApplyMs: Number(
-                message.agentApplyMs
-                ?? message.AgentApplyMs
-                ?? message.result?.agentApplyMs
-                ?? message.result?.AgentApplyMs
-                ?? 0) || 0
-        });
-    }
+                || result.inputDiagnostic === true
+                || result.InputDiagnostic === true,
+            failureStage: safeString(
+                message.failureStage
+                || message.FailureStage
+                || result.failureStage
+                || result.FailureStage,
+                40),
+            exceptionType: safeString(
+                message.exceptionType
+                || message.ExceptionType
+                || result.exceptionType
+                || result.ExceptionType,
+                80),
+            permissionSupported: firstOptionalBoolean(
+                message.permissionSupported,
+                message.PermissionSupported,
+                result.permissionSupported,
+                result.PermissionSupported),
+            permissionGranted: firstOptionalBoolean(
+                message.permissionGranted,
+                message.PermissionGranted,
+                result.permissionGranted,
+                result.PermissionGranted),
+            macAccessibilityTrusted: firstOptionalBoolean(
+                message.macAccessibilityTrusted,
+                message.MacAccessibilityTrusted,
+                result.macAccessibilityTrusted,
+                result.MacAccessibilityTrusted),
+            macPostEventAccess: firstOptionalBoolean(
+                message.macPostEventAccess,
+                message.MacPostEventAccess,
+                result.macPostEventAccess,
+                result.MacPostEventAccess),
+            fallback: pending?.fallback === true,
+            hubAcknowledgedAtEpochMs: Date.now()
+        };
+    }
+
+    function rememberRemoteInputOutcome(device, outcome, state) {
+        const diagnostics = device.remoteInputDiagnostics
+            || (device.remoteInputDiagnostics = createRemoteInputDiagnostics());
+        const record = {
+            state,
+            receivedAt: new Date(outcome.hubAcknowledgedAtEpochMs).toISOString(),
+            inputType: safeString(outcome.inputType, 48),
+            inputSeq: Math.max(0, Number(outcome.inputSeq) || 0),
+            monitorIndex: Math.max(0, Number(outcome.monitorIndex) || 0),
+            sessionId: safeString(outcome.controlSessionId || device.sessionId, 160),
+            controlCommandId: safeString(outcome.controlCommandId, 128),
+            captureGeneration: Math.max(0, Number(outcome.captureGeneration) || 0),
+            inputSocketConnectionId: safeString(outcome.inputSocketConnectionId, 128),
+            fallback: outcome.fallback === true
+        };
+        if (state === 'applied') {
+            diagnostics.appliedCount += 1;
+            device.counters.remoteInputsApplied += 1;
+            const applied = {
+                ...record,
+                duplicate: outcome.duplicate === true,
+                agentApplyMs: Math.max(0, Number(outcome.agentApplyMs) || 0),
+                nativeInputBackend: safeString(outcome.nativeInputBackend, 80)
+            };
+            diagnostics.lastApplied = applied;
+            diagnostics.lastOutcome = applied;
+            return applied;
+        }
+
+        diagnostics.rejectedCount += 1;
+        device.counters.remoteInputsRejected += 1;
+        const failed = {
+            ...record,
+            errorKind: outcome.errorKind === 'native-apply' ? 'native-apply' : 'route',
+            failureStage: safeString(outcome.failureStage, 40) || 'unknown',
+            exceptionType: safeString(outcome.exceptionType, 80),
+            permissionSupported: firstOptionalBoolean(outcome.permissionSupported),
+            permissionGranted: firstOptionalBoolean(outcome.permissionGranted),
+            macAccessibilityTrusted: firstOptionalBoolean(outcome.macAccessibilityTrusted),
+            macPostEventAccess: firstOptionalBoolean(outcome.macPostEventAccess),
+            error: safeDiagnosticText(outcome.error, 600) || 'remote-input-failed',
+            failedAtEpochMs: Math.max(0, Number(outcome.failedAtEpochMs) || 0)
+        };
+        diagnostics.lastFailure = failed;
+        diagnostics.lastOutcome = failed;
+        return failed;
+    }
+
+    function logRemoteInputFailure(device, failure) {
+        const rateLimits = device.remoteInputFailureLogAt
+            || (device.remoteInputFailureLogAt = new Map());
+        const key = `${failure.errorKind}:${failure.failureStage}:${failure.exceptionType}:${failure.error}`;
+        const now = Date.now();
+        const lastAt = Number(rateLimits.get(key) || 0);
+        if (lastAt > 0 && now - lastAt < REMOTE_INPUT_FAILURE_LOG_INTERVAL_MS) {
+            return;
+        }
+        rateLimits.delete(key);
+        rateLimits.set(key, now);
+        while (rateLimits.size > REMOTE_INPUT_FAILURE_LOG_KEY_LIMIT) {
+            const oldestKey = rateLimits.keys().next().value;
+            if (!oldestKey) break;
+            rateLimits.delete(oldestKey);
+        }
+        const shortId = value => safeString(value, 128).slice(0, 12) || 'unknown';
+        const optionalFlag = value => typeof value === 'boolean' ? String(value) : 'unknown';
+        logWarn(
+            'remote',
+            `input rejected device=${device.deviceName} (${device.deviceId})`
+                + ` session=${shortId(failure.sessionId)}`
+                + ` command=${shortId(failure.controlCommandId)}`
+                + ` generation=${failure.captureGeneration}`
+                + ` monitor=${failure.monitorIndex}`
+                + ` type=${failure.inputType || 'unknown'}`
+                + ` seq=${failure.inputSeq}`
+                + ` kind=${failure.errorKind}`
+                + ` stage=${failure.failureStage}`
+                + ` exception=${failure.exceptionType || 'unknown'}`
+                + ` permission=${optionalFlag(failure.permissionGranted)}`
+                + ` accessibility=${optionalFlag(failure.macAccessibilityTrusted)}`
+                + ` postEvent=${optionalFlag(failure.macPostEventAccess)}`
+                + ` error=${failure.error}`);
+    }
+
+    function emitRemoteInputApplied(device, message = {}, pending = null) {
+        const outcome = {
+            ...buildRemoteInputOutcome(device, message, pending),
+            agentApplyMs: Number(
+                message.agentApplyMs
+                ?? message.AgentApplyMs
+                ?? message.result?.agentApplyMs
+                ?? message.result?.AgentApplyMs
+                ?? 0) || 0
+        };
+        rememberRemoteInputOutcome(device, outcome, 'applied');
+        emitEvent('RemoteInputApplied', outcome);
+    }
 
     function emitRemoteInputError(
         device,
@@ -6206,29 +6392,37 @@ export function createRemoteHub(options = {}) {
         fallbackError = 'remote-input-failed',
         errorKind = 'route') {
         const outcome = buildRemoteInputOutcome(device, message, pending);
-        emitEvent('RemoteInputError', {
+        const failure = {
             ...outcome,
             errorKind: errorKind === 'native-apply' ? 'native-apply' : 'route',
-            error: safeString(
-                message.error
-                || message.Error
-                || message.result?.error
-                || message.result?.Error
-                || fallbackError,
+            error: safeDiagnosticText(
+                message.error
+                || message.Error
+                || message.result?.error
+                || message.result?.Error
+                || fallbackError,
                 600) || fallbackError,
             failedAtEpochMs: Number(
                 message.failedAtEpochMs
                 ?? message.FailedAtEpochMs
                 ?? message.result?.failedAtEpochMs
-                ?? message.result?.FailedAtEpochMs
-                ?? 0) || 0
-        });
-    }
-
-    function handleRemoteInputOutcome(device, message = {}, source = 'input') {
+                ?? message.result?.FailedAtEpochMs
+                ?? 0) || 0
+        };
+        const persistentFailure = rememberRemoteInputOutcome(device, failure, 'rejected');
+        logRemoteInputFailure(device, persistentFailure);
+        emitEvent('RemoteInputError', failure);
+    }
+
+    function handleRemoteInputOutcome(
+        device,
+        message = {},
+        source = 'input',
+        acknowledgedPending = null) {
         const commandId = safeString(message.commandId || message.CommandId, 128);
         const inputSeq = Number(message.inputSeq ?? message.InputSeq ?? 0) || 0;
-        const pending = takePendingInputFallback(device, commandId, inputSeq);
+        const pending = acknowledgedPending
+            || takePendingInputFallback(device, commandId, inputSeq);
         if (!pending
             && source === 'main'
             && wasInputFallbackCompleted(device, commandId, inputSeq)) {
@@ -8571,12 +8765,12 @@ export function createRemoteHub(options = {}) {
         if (state.inputOnly) {
             device.inputLastSeenAt = new Date().toISOString();
             if (message.type === 'input.applied' || message.type === 'input.error') {
-                acknowledgePendingDedicatedInput(device, message);
+                const acknowledgedPending = acknowledgePendingDedicatedInput(device, message);
                 handleRemoteInputOutcome(device, {
-                    ...message,
-                    agentApplyMs: Number(message.agentApplyMs || 0) || 0
-                }, 'input');
-            }
+                    ...message,
+                    agentApplyMs: Number(message.agentApplyMs || 0) || 0
+                }, 'input', acknowledgedPending);
+            }
             return;
         }
         if (state.frameOnly) {
@@ -10923,23 +11117,29 @@ export function createRemoteHub(options = {}) {
         ensureLiveStreamReplacementTimers(device).set(stream.streamId, timer);
     }
 
-    function failPendingLiveStream(device, commandId, error = 'stream-start-failed') {
+    function failPendingLiveStream(device, commandId, error = 'stream-start-failed') {
         const key = safeString(commandId, 128);
         if (!device || !key) {
             return false;
         }
         const streams = ensureDeviceLiveStreams(device);
         for (const stream of streams.values()) {
-            const pending = getPendingLiveStreamDescriptor(stream);
-            if (safeString(pending?.commandId, 128) !== key) {
-                continue;
-            }
-            clearPendingLiveStreamDescriptor(device, stream);
-            emitRemoteEvent('RemoteLiveStreamRestartFailed', device, {
-                streamId: stream.streamId,
-                commandId: key,
-                error: safeString(error, 500) || 'stream-start-failed'
-            });
+            const pending = getPendingLiveStreamDescriptor(stream);
+            if (safeString(pending?.commandId, 128) !== key) {
+                continue;
+            }
+            const failedOwner = { ...pending };
+            clearPendingLiveStreamDescriptor(device, stream);
+            emitRemoteEvent('RemoteLiveStreamRestartFailed', device, {
+                streamId: stream.streamId,
+                commandId: key,
+                streamPurpose: safeString(failedOwner.streamPurpose, 24) || 'wall',
+                captureGeneration: Number(failedOwner.captureGeneration || 0),
+                monitorIndex: Number(failedOwner.monitorIndex || 0),
+                retainedCommandId: safeString(stream.commandId, 128),
+                retainedCaptureGeneration: Number(stream.captureGeneration || 0),
+                error: safeString(error, 500) || 'stream-start-failed'
+            });
             return true;
         }
         for (const stream of streams.values()) {
@@ -11276,9 +11476,23 @@ export function createRemoteHub(options = {}) {
                 === normalized.streamPurpose;
     }
 
-    function sharedLiveProfileResult(device, activeLiveStream, normalized, extra = {}) {
-        return {
-            ok: true,
+    function sharedLiveProfileResult(
+        device,
+        activeLiveStream,
+        normalized,
+        extra = {},
+        subscriberRequestedProfile = null
+    ) {
+        const requested = subscriberRequestedProfile && typeof subscriberRequestedProfile === 'object'
+            ? {
+                fps: clampNumber(subscriberRequestedProfile.fps, 1, normalized.streamPurpose === 'control' ? 60 : 30, normalized.fps),
+                maxWidth: clampNumber(subscriberRequestedProfile.maxWidth, 320, 3840, normalized.maxWidth),
+                maxHeight: clampNumber(subscriberRequestedProfile.maxHeight, 180, 2160, normalized.maxHeight),
+                quality: clampNumber(subscriberRequestedProfile.quality, 20, 95, normalized.quality)
+            }
+            : normalized;
+        return {
+            ok: true,
             commandId: activeLiveStream.commandId,
             sessionId: device.sessionId,
             streamId: activeLiveStream.streamId,
@@ -11290,12 +11504,12 @@ export function createRemoteHub(options = {}) {
             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
+            sharedProfileReused: true,
+            requestedProfile: {
+                fps: requested.fps,
+                maxWidth: requested.maxWidth,
+                maxHeight: requested.maxHeight,
+                quality: requested.quality
             },
             effectiveProfile: {
                 fps: Number(activeLiveStream.fps || normalized.fps),
@@ -11506,10 +11720,11 @@ export function createRemoteHub(options = {}) {
         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);
+            const pendingMatchesSharedOwner = options.forceRestart !== true
+                && options.reuseExisting === true
+                && options.reuseSharedExisting === true
+                && liveStreamMatchesOwnerIdentity(pendingDescriptor, normalized)
+                && liveProfileSatisfiesDemand(pendingDescriptor, normalized);
             if ((pendingMatchesRequest || pendingMatchesSharedOwner)
                 && liveStreamReplacementStillPending(activeLiveStream)) {
                 emitRemoteEvent('RemoteLiveStreamRestartPending', device, {
@@ -11519,10 +11734,10 @@ export function createRemoteHub(options = {}) {
                     reason: safeString(options.restartReason || 'duplicate-restart', 128)
                 });
                 if (pendingMatchesSharedOwner && !pendingMatchesRequest) {
-                    return sharedLiveProfileResult(device, pendingDescriptor, normalized, {
-                        ready: false,
-                        pending: true
-                    });
+                    return sharedLiveProfileResult(device, pendingDescriptor, normalized, {
+                        ready: false,
+                        pending: true
+                    }, options.subscriberRequestedProfile);
                 }
                 return {
                     ok: true,
@@ -11599,10 +11814,11 @@ export function createRemoteHub(options = {}) {
         }
         if (activeLiveStream
             && options.forceRestart !== true
-            && options.reuseExisting === true
-            && options.reuseSharedExisting === true
-            && liveStreamMatchesOwnerIdentity(activeLiveStream, normalized)
-            && liveStreamIsReusable(activeLiveStream)) {
+            && options.reuseExisting === true
+            && options.reuseSharedExisting === true
+            && liveStreamMatchesOwnerIdentity(activeLiveStream, normalized)
+            && liveStreamIsReusable(activeLiveStream)
+            && liveProfileSatisfiesDemand(activeLiveStream, normalized)) {
             emitRemoteEvent('RemoteLiveStreamSharedProfileReused', device, {
                 streamId,
                 commandId: activeLiveStream.commandId,
@@ -11614,7 +11830,13 @@ export function createRemoteHub(options = {}) {
                 effectiveMaxWidth: Number(activeLiveStream.maxWidth || normalized.maxWidth),
                 effectiveMaxHeight: Number(activeLiveStream.maxHeight || normalized.maxHeight)
             });
-            return sharedLiveProfileResult(device, activeLiveStream, normalized);
+            return sharedLiveProfileResult(
+                device,
+                activeLiveStream,
+                normalized,
+                {},
+                options.subscriberRequestedProfile
+            );
         }
         if (activeLiveStream
             && options.forceRestart !== true
@@ -11779,10 +12001,11 @@ export function createRemoteHub(options = {}) {
             fps,
             mode: transfer.mode,
             frameMode: transfer.frameMode,
-            monitorIndex,
-            captureGeneration,
-            ready: false
-        };
+            monitorIndex,
+            captureGeneration,
+            ready: false,
+            pending: replacingActiveStream
+        };
     }
 
     function stopLiveStream(deviceId, options = {}) {