@livedesk/hub 0.1.51 → 0.1.52

package/package.json

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

package/src/remote-hub.js

@@ -4288,13 +4288,14 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function closeInputSocket(device, reason = 'input-socket-closed') {
+    function closeInputSocket(device, reason = 'input-socket-closed') {
         const socket = device?.inputSocket;
         if (!socket) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
+        const writeOwner = device.inputWriteOwner;
+        clearPendingDedicatedInputAcks(device);
         clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
@@ -4317,7 +4318,7 @@ export function createRemoteHub(options = {}) {
         }
     }
 
-    function detachInputSocket(socket, reason = 'input-socket-closed') {
+    function detachInputSocket(socket, reason = 'input-socket-closed') {
         const deviceId = inputSockets.get(socket);
         inputSockets.delete(socket);
         if (!deviceId) {
@@ -4329,7 +4330,8 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
-        const writeOwner = device.inputWriteOwner;
+        const writeOwner = device.inputWriteOwner;
+        clearPendingDedicatedInputAcks(device);
         clearClipboardOperationsForDevice(device, reason);
         device.inputSocket = null;
         device.inputWriteOwner = null;
@@ -4948,7 +4950,8 @@ export function createRemoteHub(options = {}) {
             return null;
         }
 
-        closeInputSocket(device, 'replaced-by-new-input-socket');
+        closeInputSocket(device, 'replaced-by-new-input-socket');
+        clearPendingDedicatedInputAcks(device);
 
         const now = new Date().toISOString();
         const inputSocketConnectionId = crypto.randomUUID();
@@ -5392,7 +5395,7 @@ export function createRemoteHub(options = {}) {
         return failed;
     }
 
-    function ensurePendingInputFallbacks(device) {
+    function ensurePendingInputFallbacks(device) {
         if (!(device?.pendingInputFallbacks instanceof Map)) {
             Object.defineProperty(device, 'pendingInputFallbacks', {
                 value: new Map(),
@@ -5409,8 +5412,151 @@ export function createRemoteHub(options = {}) {
                 writable: true
             });
         }
-        return device.pendingInputFallbacks;
-    }
+        return device.pendingInputFallbacks;
+    }
+
+    function ensurePendingDedicatedInputAckState(device) {
+        if (!device?.pendingDedicatedInputAckState) {
+            Object.defineProperty(device, 'pendingDedicatedInputAckState', {
+                value: { current: null, next: null, timeoutTimer: null },
+                enumerable: false,
+                configurable: true,
+                writable: true
+            });
+        }
+        return device.pendingDedicatedInputAckState;
+    }
+
+    function clearPendingDedicatedInputAcks(device) {
+        if (!device?.pendingDedicatedInputAckState) {
+            return;
+        }
+        const state = device.pendingDedicatedInputAckState;
+        if (state.timeoutTimer) {
+            clearTimeout(state.timeoutTimer);
+        }
+        state.timeoutTimer = null;
+        state.current = null;
+        state.next = null;
+    }
+
+    function dedicatedInputAckMatches(pending, message = {}) {
+        if (!pending) {
+            return false;
+        }
+        const result = message?.result && typeof message.result === 'object'
+            ? message.result
+            : {};
+        const inputEventId = safeString(
+            message.inputEventId
+            || message.InputEventId
+            || result.inputEventId
+            || result.InputEventId,
+            128);
+        const hubConnectionId = safeString(
+            message.hubConnectionId
+            || message.HubConnectionId
+            || result.hubConnectionId
+            || result.HubConnectionId,
+            128);
+        const inputSeq = Number(
+            message.inputSeq
+            ?? message.InputSeq
+            ?? result.inputSeq
+            ?? result.InputSeq
+            ?? 0) || 0;
+        if (pending.inputEventId && inputEventId) {
+            return pending.inputEventId === inputEventId
+                && pending.hubConnectionId === hubConnectionId;
+        }
+        return pending.inputSeq > 0
+            && pending.inputSeq === inputSeq
+            && pending.hubConnectionId === hubConnectionId;
+    }
+
+    function armPendingDedicatedInputAck(device) {
+        const state = ensurePendingDedicatedInputAckState(device);
+        if (state.timeoutTimer) {
+            clearTimeout(state.timeoutTimer);
+            state.timeoutTimer = null;
+        }
+        const pending = state.current;
+        if (!pending) {
+            return;
+        }
+        const remainingMs = Math.max(0, pending.deadlineAtEpochMs - Date.now());
+        state.timeoutTimer = setTimeout(() => {
+            state.timeoutTimer = null;
+            if (state.current !== pending) {
+                return;
+            }
+            state.current = null;
+            state.next = null;
+            if (device.inputSocketConnectionId !== pending.inputSocketConnectionId) {
+                return;
+            }
+            emitRemoteInputError(
+                device,
+                { error: 'remote-input-timeout' },
+                pending,
+                'remote-input-timeout');
+            closeInputSocket(device, 'input-ack-timeout');
+        }, remainingMs);
+        state.timeoutTimer.unref?.();
+    }
+
+    function schedulePendingDedicatedInputAck(device, pending) {
+        if (pending?.requestAck !== true
+            || !Number.isSafeInteger(pending.inputSeq)
+            || pending.inputSeq <= 0) {
+            return;
+        }
+        const state = ensurePendingDedicatedInputAckState(device);
+        const record = {
+            ...pending,
+            deadlineAtEpochMs: Date.now() + inputAckTimeoutMs
+        };
+        if (!state.current) {
+            state.current = record;
+            state.next = null;
+            armPendingDedicatedInputAck(device);
+            return;
+        }
+        if (state.current.inputSocketConnectionId !== record.inputSocketConnectionId
+            || state.current.bindingKey !== record.bindingKey) {
+            clearPendingDedicatedInputAcks(device);
+            state.current = record;
+            armPendingDedicatedInputAck(device);
+            return;
+        }
+        // Keep only one later checkpoint. If the current acknowledgement
+        // arrives, this latest sampled input becomes the next exact deadline.
+        state.next = record;
+    }
+
+    function acknowledgePendingDedicatedInput(device, message = {}) {
+        const state = device?.pendingDedicatedInputAckState;
+        if (!state?.current) {
+            return false;
+        }
+        if (dedicatedInputAckMatches(state.current, message)) {
+            if (state.timeoutTimer) {
+                clearTimeout(state.timeoutTimer);
+                state.timeoutTimer = null;
+            }
+            state.current = state.next;
+            state.next = null;
+            armPendingDedicatedInputAck(device);
+            return true;
+        }
+        if (dedicatedInputAckMatches(state.next, message)) {
+            // A later ordered acknowledgement proves that the input reader is
+            // still draining, even if an earlier diagnostic response vanished.
+            clearPendingDedicatedInputAcks(device);
+            return true;
+        }
+        return false;
+    }
 
     function pruneCompletedInputFallbacks(device, now = Date.now()) {
         ensurePendingInputFallbacks(device);
@@ -7866,10 +8012,14 @@ export function createRemoteHub(options = {}) {
             return;
         }
 
-        if (state.inputOnly) {
-            device.inputLastSeenAt = new Date().toISOString();
-            if (message.type === 'input.applied' || message.type === 'input.error') {
-                handleRemoteInputOutcome(device, {
+        if (state.inputOnly) {
+            if (device.inputSocket !== socket) {
+                return;
+            }
+            device.inputLastSeenAt = new Date().toISOString();
+            if (message.type === 'input.applied' || message.type === 'input.error') {
+                acknowledgePendingDedicatedInput(device, message);
+                handleRemoteInputOutcome(device, {
                     ...message,
                     agentApplyMs: Number(message.agentApplyMs || 0) || 0
                 }, 'input');
@@ -9265,9 +9415,10 @@ export function createRemoteHub(options = {}) {
                 && normalized.hubConnectionId !== previousOwnerConnectionId;
             const bindingChanged = previousInputBindingKey
                 && previousInputBindingKey !== activeInputBindingKey;
-            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
-            if (ownerChanged || bindingChanged || writeBindingChanged) {
-                if (ownerChanged) {
+            const writeBindingChanged = inputWriteOwner.getBindingKey() !== activeInputBindingKey;
+            if (ownerChanged || bindingChanged || writeBindingChanged) {
+                clearPendingDedicatedInputAcks(device);
+                if (ownerChanged) {
                     clearClipboardOperationsForDevice(
                         device,
                         'browser-input-owner-changed',
@@ -9292,11 +9443,12 @@ export function createRemoteHub(options = {}) {
                     return { ok: false, error: 'INPUT_CHANNEL_RECONNECTING' };
                 }
             }
-            const sent = inputWriteOwner.enqueue({
-                type: 'input.control',
-                payload: {
-                    ...normalized,
-                    hubForwardedAtEpochMs: Date.now(),
+            const hubForwardedAtEpochMs = Date.now();
+            const sent = inputWriteOwner.enqueue({
+                type: 'input.control',
+                payload: {
+                    ...normalized,
+                    hubForwardedAtEpochMs,
                     issuedAt: normalized.issuedAt || new Date().toISOString()
                 }
             }, activeInputBindingKey);
@@ -9304,9 +9456,15 @@ export function createRemoteHub(options = {}) {
                 if (normalized.hubConnectionId) {
                     device.inputOwnerConnectionId = normalized.hubConnectionId;
                 }
-                device.inputOwnerBindingKey = activeInputBindingKey;
-                device.counters.commandsSent += 1;
-                device.inputLastSeenAt = new Date().toISOString();
+                device.inputOwnerBindingKey = activeInputBindingKey;
+                device.counters.commandsSent += 1;
+                device.inputLastSeenAt = new Date().toISOString();
+                schedulePendingDedicatedInputAck(device, {
+                    ...normalized,
+                    inputSocketConnectionId: device.inputSocketConnectionId,
+                    bindingKey: activeInputBindingKey,
+                    hubForwardedAtEpochMs
+                });
                 if (clipboardOperationKey) {
                     const operation = clipboardOperations.get(clipboardOperationKey);
                     if (operation) {
@@ -9397,7 +9555,8 @@ export function createRemoteHub(options = {}) {
             return { ok: false, error: 'input-owner-not-current' };
         }
 
-        clearClipboardOperationsForDevice(device, reason, owner);
+        clearClipboardOperationsForDevice(device, reason, owner);
+        clearPendingDedicatedInputAcks(device);
         device.inputOwnerConnectionId = '';
         device.inputOwnerBindingKey = '';
         const inputSocket = device.inputSocket;