@opengeni/react 1.4.2 → 1.4.5-canary.37458084490001

package/dist/{chunk-MDIXFKA3.js → chunk-6FOTSVWU.js}

@@ -10,7 +10,7 @@ import {
 } from "./chunk-BNKV5ZLF.js";
 import {
   copyTextToClipboard
-} from "./chunk-CVYCLFMH.js";
+} from "./chunk-PEHTX3V7.js";
 import {
   DesktopViewer
 } from "./chunk-IMSUVYQB.js";
@@ -408,27 +408,49 @@ function isPlacementGenerationLossError(cause) {
 
 // src/hooks/use-computer-session.ts
 import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+var actionResultFences = /* @__PURE__ */ new WeakMap();
+function isStaleComputerActionResult(value) {
+  return typeof value === "object" && value !== null && actionResultFences.get(value)?.() === false;
+}
+function computerActionReceiptError(receipt) {
+  const error = new Error(receipt.error?.message ?? "Desktop input did not complete.");
+  const fence = actionResultFences.get(receipt);
+  if (fence) actionResultFences.set(error, fence);
+  return error;
+}
 function useComputerSession(options) {
   const { client, workspaceId } = useEmbeddedComputerInteraction(options);
   const computerSessionId = options.computerSessionId;
   const enabled = (options.enabled ?? true) && computerSessionId !== null;
+  const sourceRef = useRef2({
+    client,
+    workspaceId,
+    computerSessionId,
+    enabled
+  });
+  if (sourceRef.current.client !== client || sourceRef.current.workspaceId !== workspaceId || sourceRef.current.computerSessionId !== computerSessionId || sourceRef.current.enabled !== enabled) {
+    sourceRef.current = { client, workspaceId, computerSessionId, enabled };
+  }
+  const source = sourceRef.current;
   const pageLive = usePageLiveActivity();
   const pollIntervalMs = Math.max(750, options.pollIntervalMs ?? 2e3);
-  const [state, setState] = useState2(
-    () => emptyState(computerSessionId, enabled)
-  );
-  const visible = state.computerSessionId === computerSessionId ? state : emptyState(computerSessionId, enabled);
+  const [state, setState] = useState2(() => emptyState(source, enabled));
+  const visible = state.source === source ? state : emptyState(source, enabled);
   const refreshBlocked = isNonRetryableInteractionError(visible.error);
   const selectedTargetIdRef = useRef2(visible.selectedTargetId);
   selectedTargetIdRef.current = visible.selectedTargetId;
+  const selectionRevisionRef = useRef2(0);
+  const actionResultOrderRef = useRef2({ next: 0, settled: 0 });
   const targetsRef = useRef2({
+    source,
     computerSessionId,
     targets: visible.targets
   });
-  const observationRef = useRef2({ computerSessionId, observation: visible.observation });
-  if (targetsRef.current.computerSessionId !== computerSessionId) {
-    targetsRef.current = { computerSessionId, targets: visible.targets };
+  const observationRef = useRef2({ source, computerSessionId, observation: visible.observation });
+  if (targetsRef.current.source !== source) {
+    targetsRef.current = { source, computerSessionId, targets: visible.targets };
     observationRef.current = {
+      source,
       computerSessionId,
       observation: visible.observation
     };
@@ -442,16 +464,21 @@ function useComputerSession(options) {
   });
   const mutationRef = useRef2({
     computerSessionId,
+    source,
     count: 0
   });
   const mountedRef = useRef2(true);
+  const isCurrentSource = useCallback2(
+    () => mountedRef.current && sourceRef.current === source,
+    [source]
+  );
   const invalidateRefresh = useCallback2(() => {
     const id = requestRef.current.id + 1;
     requestRef.current.controller?.abort();
     requestRef.current = { id, controller: null };
   }, []);
   const refresh = useCallback2(async () => {
-    if (!enabled || !computerSessionId) return;
+    if (!enabled || !computerSessionId || !isCurrentSource()) return;
     const id = requestRef.current.id + 1;
     requestRef.current.controller?.abort();
     const controller = new AbortController();
@@ -467,16 +494,16 @@ function useComputerSession(options) {
         })
       ]);
       discoveryCompleted = true;
-      if (!mountedRef.current || requestRef.current.id !== id) return;
+      if (!isCurrentSource() || requestRef.current.id !== id) return;
       const targets = sortComputerTargets(targetResponse.targets);
       const selected = chooseTarget(targets, selectedTargetIdRef.current);
-      const previous = observationRef.current.observation;
+      const previous = observationRef.current.source === source ? observationRef.current.observation : null;
       const retainedObservation = selected && previous?.target.id === selected.id && previous.target.controllerGeneration === selected.controllerGeneration && previous.target.targetGeneration === selected.targetGeneration ? previous : null;
       selectedTargetIdRef.current = selected?.id ?? null;
-      targetsRef.current = { computerSessionId, targets };
-      observationRef.current = { computerSessionId, observation: retainedObservation };
+      targetsRef.current = { source, computerSessionId, targets };
+      observationRef.current = { source, computerSessionId, observation: retainedObservation };
       setState(
-        (current) => current.computerSessionId === computerSessionId ? {
+        (current) => isCurrentSource() && current.source === source && current.computerSessionId === computerSessionId ? {
           ...current,
           session,
           targets,
@@ -490,12 +517,12 @@ function useComputerSession(options) {
       const observation = selected ? await client.observeComputerTarget(workspaceId, computerSessionId, selected.id, {
         signal: controller.signal
       }) : null;
-      if (!mountedRef.current || requestRef.current.id !== id) return;
+      if (!isCurrentSource() || requestRef.current.id !== id) return;
       selectedTargetIdRef.current = selected?.id ?? null;
-      targetsRef.current = { computerSessionId, targets };
-      observationRef.current = { computerSessionId, observation };
+      targetsRef.current = { source, computerSessionId, targets };
+      observationRef.current = { source, computerSessionId, observation };
       setState(
-        (current) => current.computerSessionId === computerSessionId ? {
+        (current) => isCurrentSource() && current.source === source && current.computerSessionId === computerSessionId ? {
           ...current,
           session,
           targets,
@@ -506,10 +533,10 @@ function useComputerSession(options) {
         } : current
       );
     } catch (cause) {
-      if (controller.signal.aborted || !mountedRef.current || requestRef.current.id !== id) return;
+      if (controller.signal.aborted || !isCurrentSource() || requestRef.current.id !== id) return;
       const error = cause instanceof Error ? cause : new Error(String(cause));
       setState(
-        (current) => current.computerSessionId === computerSessionId ? {
+        (current) => isCurrentSource() && current.source === source && current.computerSessionId === computerSessionId ? {
           ...current,
           loading: false,
           error,
@@ -522,23 +549,27 @@ function useComputerSession(options) {
     } finally {
       if (requestRef.current.id === id) requestRef.current = { id, controller: null };
     }
-  }, [client, computerSessionId, enabled, workspaceId]);
+  }, [client, computerSessionId, enabled, isCurrentSource, source, workspaceId]);
   useEffect2(() => {
     mountedRef.current = true;
     if (!enabled) {
       invalidateRefresh();
-      setState(emptyState(computerSessionId, false));
+      setState(emptyState(source, false));
       return;
     }
     setState(
-      (current) => current.computerSessionId === computerSessionId ? { ...current, loading: true } : emptyState(computerSessionId, true)
+      (current) => current.source === source ? {
+        ...current,
+        loading: true,
+        mutating: mutationRef.current.source === source && mutationRef.current.count > 0
+      } : emptyState(source, true)
     );
     void refresh();
     return () => {
       mountedRef.current = false;
       invalidateRefresh();
     };
-  }, [computerSessionId, enabled, invalidateRefresh, refresh]);
+  }, [computerSessionId, enabled, invalidateRefresh, refresh, source]);
   useEffect2(() => {
     if (!enabled || !pageLive || visible.mutating || refreshBlocked) return;
     const timer = setInterval(() => {
@@ -561,55 +592,48 @@ function useComputerSession(options) {
   }, [client, computerSessionId, enabled, pageLive, refresh, refreshBlocked, workspaceId]);
   const runMutation = useCallback2(
     async (scopeComputerSessionId, operation) => {
+      if (!isCurrentSource()) throw new Error("The desktop source is no longer selected.");
       invalidateRefresh();
-      if (mutationRef.current.computerSessionId !== scopeComputerSessionId) {
+      if (mutationRef.current.computerSessionId !== scopeComputerSessionId || mutationRef.current.source !== source) {
         mutationRef.current = {
           computerSessionId: scopeComputerSessionId,
+          source,
           count: 0
         };
       }
       mutationRef.current.count += 1;
       setState(
-        (current) => current.computerSessionId === scopeComputerSessionId ? { ...current, mutating: true, error: null } : current
+        (current) => isCurrentSource() && current.source === source && current.computerSessionId === scopeComputerSessionId ? { ...current, mutating: true, error: null } : current
       );
       try {
-        const result = await operation();
-        setState(
-          (current) => current.computerSessionId === scopeComputerSessionId ? { ...current, controlError: null } : current
-        );
-        return result;
-      } catch (cause) {
-        const error = cause instanceof Error ? cause : new Error(String(cause));
-        setState(
-          (current) => current.computerSessionId === scopeComputerSessionId ? {
-            ...current,
-            error,
-            controlError: isInteractionControlUnavailable(error) ? error : current.controlError
-          } : current
-        );
-        throw error;
+        return await operation();
       } finally {
-        if (mutationRef.current.computerSessionId === scopeComputerSessionId) {
+        if (mutationRef.current.computerSessionId === scopeComputerSessionId && mutationRef.current.source === source) {
           mutationRef.current.count = Math.max(0, mutationRef.current.count - 1);
           const mutating = mutationRef.current.count > 0;
           setState(
-            (current) => current.computerSessionId === scopeComputerSessionId ? { ...current, mutating } : current
+            (current) => isCurrentSource() && current.source === source && current.computerSessionId === scopeComputerSessionId ? { ...current, mutating } : current
           );
         }
       }
     },
-    [invalidateRefresh]
+    [invalidateRefresh, isCurrentSource, source]
   );
   const selectTarget = useCallback2(
     async (targetId) => {
       if (!computerSessionId) throw new Error("No desktop is selected.");
-      const target = targetsRef.current.targets.find((candidate) => candidate.id === targetId);
+      if (!isCurrentSource()) throw new Error("The desktop source is no longer selected.");
+      const target = targetsRef.current.source === source ? targetsRef.current.targets.find((candidate) => candidate.id === targetId) : null;
       if (!target) throw new Error("The selected desktop target is no longer available.");
       invalidateRefresh();
+      const readRequestId = requestRef.current.id;
+      const selectionRevision = ++selectionRevisionRef.current;
+      const isCurrentSelection = () => isCurrentSource() && selectionRevisionRef.current === selectionRevision;
+      const isCurrentSelectionRead = () => isCurrentSelection() && requestRef.current.id === readRequestId;
       selectedTargetIdRef.current = target.id;
-      observationRef.current = { computerSessionId, observation: null };
+      observationRef.current = { source, computerSessionId, observation: null };
       setState(
-        (current) => current.computerSessionId === computerSessionId ? {
+        (current) => isCurrentSelection() && current.source === source && current.computerSessionId === computerSessionId ? {
           ...current,
           selectedTargetId: target.id,
           observation: null,
@@ -623,37 +647,40 @@ function useComputerSession(options) {
           computerSessionId,
           target.id
         );
-        if (selectedTargetIdRef.current !== target.id) return target;
-        observationRef.current = { computerSessionId, observation };
+        if (!isCurrentSelectionRead() || selectedTargetIdRef.current !== target.id) return target;
+        observationRef.current = { source, computerSessionId, observation };
         setState(
-          (current) => current.computerSessionId === computerSessionId && current.selectedTargetId === target.id ? { ...current, observation, loading: false, error: null } : current
+          (current) => isCurrentSelection() && current.source === source && current.computerSessionId === computerSessionId && current.selectedTargetId === target.id ? { ...current, observation, loading: false, error: null } : current
         );
         return observation.target;
       } catch (cause) {
         const error = cause instanceof Error ? cause : new Error(String(cause));
-        setState(
-          (current) => current.computerSessionId === computerSessionId && current.selectedTargetId === target.id ? {
-            ...current,
-            loading: false,
-            error,
-            controlError: isInteractionControlUnavailable(error, "observation") ? error : current.controlError
-          } : current
-        );
+        if (isCurrentSelectionRead()) {
+          setState(
+            (current) => isCurrentSelection() && current.source === source && current.computerSessionId === computerSessionId && current.selectedTargetId === target.id ? {
+              ...current,
+              loading: false,
+              error,
+              controlError: isInteractionControlUnavailable(error, "observation") ? error : current.controlError
+            } : current
+          );
+        }
         throw error;
       }
     },
-    [client, computerSessionId, invalidateRefresh, workspaceId]
+    [client, computerSessionId, invalidateRefresh, isCurrentSource, source, workspaceId]
   );
   const dispatchAction = useCallback2(
     async (action, operationId, frame) => {
       if (!computerSessionId) throw new Error("No desktop is selected.");
+      if (!isCurrentSource()) throw new Error("The desktop source is no longer selected.");
       if (frame && frame.computerSessionId !== computerSessionId) {
         throw new Error("The displayed desktop frame belongs to another desktop session.");
       }
-      const currentObservation = observationRef.current.computerSessionId === computerSessionId ? observationRef.current.observation : null;
-      const focusTarget = action.type === "focus" ? targetsRef.current.targets.find((candidate) => candidate.id === action.targetId) ?? null : null;
-      const frameTarget = frame ? targetsRef.current.targets.find((candidate) => candidate.id === frame.targetId) ?? (currentObservation?.target.id === frame.targetId ? currentObservation.target : null) : null;
-      const inputTarget = (action.type === "keyboard" || action.type === "clipboard") && targetsRef.current.computerSessionId === computerSessionId ? targetsRef.current.targets.find(
+      const currentObservation = observationRef.current.source === source && observationRef.current.computerSessionId === computerSessionId ? observationRef.current.observation : null;
+      const focusTarget = action.type === "focus" && targetsRef.current.source === source ? targetsRef.current.targets.find((candidate) => candidate.id === action.targetId) ?? null : null;
+      const frameTarget = frame && targetsRef.current.source === source ? currentObservation?.target.id === frame.targetId ? currentObservation.target : targetsRef.current.targets.find((candidate) => candidate.id === frame.targetId) ?? null : null;
+      const inputTarget = (action.type === "keyboard" || action.type === "clipboard") && targetsRef.current.source === source && targetsRef.current.computerSessionId === computerSessionId ? targetsRef.current.targets.find(
         (candidate) => candidate.id === selectedTargetIdRef.current
       ) : null;
       const target = frameTarget ?? focusTarget ?? currentObservation?.target ?? inputTarget ?? null;
@@ -661,6 +688,9 @@ function useComputerSession(options) {
       if (frame && frame.targetId !== selectedTargetIdRef.current) {
         throw new Error("The displayed desktop frame is no longer selected.");
       }
+      if (frame && (frame.controllerGeneration !== target.controllerGeneration || frame.targetGeneration !== target.targetGeneration)) {
+        throw new Error("The displayed desktop frame belongs to an earlier target generation.");
+      }
       if (action.type === "pointer") {
         const expectedFrameId = frame?.frameId ?? currentObservation?.frameId ?? null;
         if (!expectedFrameId || action.frameId !== expectedFrameId) {
@@ -670,34 +700,114 @@ function useComputerSession(options) {
       if (action.type === "semantic" && !currentObservation) {
         throw new Error("The desktop accessibility tree is not ready for input.");
       }
+      const selectedTargetId = selectedTargetIdRef.current;
+      const selectedTarget = targetsRef.current.targets.find(
+        (candidate) => candidate.id === selectedTargetId
+      );
+      const selectedFence = selectedTarget && {
+        id: selectedTarget.id,
+        computerSessionId: selectedTarget.computerSessionId,
+        controllerGeneration: selectedTarget.controllerGeneration,
+        targetGeneration: selectedTarget.targetGeneration
+      };
+      const selectionRevision = selectionRevisionRef.current;
+      const isCurrentView = () => isCurrentSource() && selectionRevisionRef.current === selectionRevision && selectedTargetIdRef.current === selectedTargetId && targetsRef.current.source === source && targetsRef.current.computerSessionId === computerSessionId && sameTargetFence(
+        selectedFence,
+        targetsRef.current.targets.find((candidate) => candidate.id === selectedTargetId)
+      );
+      const resultOrder = ++actionResultOrderRef.current.next;
+      let admitted = false;
+      let resultTargetId = selectedTargetId;
+      let resultFence = selectedFence;
+      const isCurrentResultView = () => isCurrentSource() && selectionRevisionRef.current === selectionRevision && selectedTargetIdRef.current === resultTargetId && targetsRef.current.source === source && sameTargetFence(
+        resultFence,
+        targetsRef.current.targets.find((candidate) => candidate.id === resultTargetId)
+      );
+      const canProjectResult = () => {
+        if (!admitted) {
+          if (!isCurrentView() || resultOrder < actionResultOrderRef.current.settled) return false;
+          actionResultOrderRef.current.settled = resultOrder;
+          admitted = true;
+          invalidateRefresh();
+        }
+        return isCurrentResultView() && resultOrder === actionResultOrderRef.current.settled;
+      };
+      const projectState = (update) => {
+        setState(
+          (current) => admitted && isCurrentResultView() && current.source === source && current.computerSessionId === computerSessionId && current.actionResultOrder <= resultOrder ? { ...update(current), actionResultOrder: resultOrder } : current
+        );
+      };
       return await runMutation(computerSessionId, async () => {
-        const receipt = await client.actInComputer(workspaceId, computerSessionId, {
-          operationId,
-          targetId: target.id,
-          expectedTargetGeneration: frame?.targetGeneration ?? target.targetGeneration,
-          expectedObservationId: action.type === "pointer" ? null : currentObservation?.observationId ?? null,
-          expectedFrameId: action.type === "pointer" ? action.frameId : null,
-          action
-        });
-        if (receipt.observation) {
-          const observation = receipt.observation;
-          observationRef.current = { computerSessionId, observation };
-          selectedTargetIdRef.current = observation.target.id;
-          setState(
-            (current) => current.computerSessionId === computerSessionId ? {
+        try {
+          const receipt = await client.actInComputer(workspaceId, computerSessionId, {
+            operationId,
+            targetId: target.id,
+            expectedTargetGeneration: frame?.targetGeneration ?? target.targetGeneration,
+            expectedObservationId: action.type === "pointer" ? null : currentObservation?.observationId ?? null,
+            expectedFrameId: action.type === "pointer" ? action.frameId : null,
+            action
+          });
+          const receiptSettled = receipt.state === "completed" || receipt.state === "failed" || receipt.state === "outcome_unknown";
+          actionResultFences.set(
+            receipt,
+            () => admitted ? isCurrentResultView() && resultOrder === actionResultOrderRef.current.settled : isCurrentView() && resultOrder >= actionResultOrderRef.current.settled
+          );
+          if (!receiptSettled || !canProjectResult()) return receipt;
+          if (receipt.observation) {
+            const observation = receipt.observation;
+            observationRef.current = { source, computerSessionId, observation };
+            selectedTargetIdRef.current = observation.target.id;
+            targetsRef.current.targets = replaceTarget(
+              targetsRef.current.targets,
+              observation.target
+            );
+            resultTargetId = observation.target.id;
+            resultFence = {
+              id: observation.target.id,
+              computerSessionId: observation.target.computerSessionId,
+              controllerGeneration: observation.target.controllerGeneration,
+              targetGeneration: observation.target.targetGeneration
+            };
+            projectState((current) => ({
               ...current,
+              error: null,
+              controlError: null,
               observation,
               selectedTargetId: observation.target.id,
               targets: replaceTarget(current.targets, observation.target)
-            } : current
+            }));
+          } else {
+            projectState((current) => ({ ...current, error: null, controlError: null }));
+            void refresh();
+          }
+          return receipt;
+        } catch (cause) {
+          const error = cause instanceof Error ? cause : new Error(String(cause));
+          actionResultFences.set(
+            error,
+            () => admitted && isCurrentResultView() && resultOrder === actionResultOrderRef.current.settled
           );
-        } else {
-          void refresh();
+          if (canProjectResult()) {
+            projectState((current) => ({
+              ...current,
+              error,
+              controlError: isInteractionControlUnavailable(error) ? error : current.controlError
+            }));
+          }
+          throw error;
         }
-        return receipt;
       });
     },
-    [client, computerSessionId, refresh, runMutation, workspaceId]
+    [
+      client,
+      computerSessionId,
+      invalidateRefresh,
+      isCurrentSource,
+      refresh,
+      runMutation,
+      source,
+      workspaceId
+    ]
   );
   const act = useCallback2(
     async (action, operationId = crypto.randomUUID()) => await dispatchAction(action, operationId, null),
@@ -709,12 +819,31 @@ function useComputerSession(options) {
   );
   const readClipboard = useCallback2(async () => {
     if (!computerSessionId) throw new Error("No desktop is selected.");
+    const selectionRevision = selectionRevisionRef.current;
+    const settledOrder = actionResultOrderRef.current.settled;
+    const selectedTargetId = selectedTargetIdRef.current;
+    const selectedTarget = targetsRef.current.targets.find(
+      (candidate) => candidate.id === selectedTargetId
+    );
+    const selectedFence = selectedTarget && {
+      id: selectedTarget.id,
+      computerSessionId: selectedTarget.computerSessionId,
+      controllerGeneration: selectedTarget.controllerGeneration,
+      targetGeneration: selectedTarget.targetGeneration
+    };
+    const isCurrentRead = () => isCurrentSource() && selectionRevisionRef.current === selectionRevision && actionResultOrderRef.current.settled === settledOrder && selectedTargetIdRef.current === selectedTargetId && targetsRef.current.source === source && sameTargetFence(
+      selectedFence,
+      targetsRef.current.targets.find((candidate) => candidate.id === selectedTargetId)
+    );
     try {
-      return await client.readComputerClipboard(workspaceId, computerSessionId);
+      const clipboard = await client.readComputerClipboard(workspaceId, computerSessionId);
+      actionResultFences.set(clipboard, isCurrentRead);
+      return clipboard;
     } catch (cause) {
       const error = cause instanceof Error ? cause : new Error(String(cause));
+      actionResultFences.set(error, isCurrentRead);
       setState(
-        (current) => current.computerSessionId === computerSessionId ? {
+        (current) => isCurrentRead() && current.source === source && current.computerSessionId === computerSessionId ? {
           ...current,
           error,
           controlError: isInteractionControlUnavailable(error) ? error : current.controlError
@@ -722,7 +851,7 @@ function useComputerSession(options) {
       );
       throw error;
     }
-  }, [client, computerSessionId, workspaceId]);
+  }, [client, computerSessionId, isCurrentSource, source, workspaceId]);
   return {
     session: visible.session,
     targets: visible.targets,
@@ -739,9 +868,10 @@ function useComputerSession(options) {
     actFromFrame
   };
 }
-function emptyState(computerSessionId, loading) {
+function emptyState(source, loading) {
   return {
-    computerSessionId,
+    source,
+    computerSessionId: source.computerSessionId,
     session: null,
     targets: [],
     selectedTargetId: null,
@@ -749,7 +879,8 @@ function emptyState(computerSessionId, loading) {
     loading,
     mutating: false,
     error: null,
-    controlError: null
+    controlError: null,
+    actionResultOrder: 0
   };
 }
 function chooseTarget(targets, preferredId) {
@@ -769,6 +900,9 @@ function replaceTarget(targets, target) {
     target
   ]);
 }
+function sameTargetFence(left, right) {
+  return left?.id === right?.id && left?.computerSessionId === right?.computerSessionId && left?.controllerGeneration === right?.controllerGeneration && left?.targetGeneration === right?.targetGeneration;
+}
 
 // src/hooks/use-computer-input-posture.ts
 import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
@@ -1089,6 +1223,7 @@ function ComputerViewer({
   }, [enabled, endStaleComputer, registry.sessions]);
   const notifyError = useCallback5(
     (cause, fallback) => {
+      if (isStaleComputerActionResult(cause)) return;
       onNotify?.({
         kind: "error",
         message: cause instanceof Error ? cause.message : fallback
@@ -1323,19 +1458,20 @@ function ComputerViewer({
     suppressGenericCreate
   ]);
   const perform = useCallback5(
-    async (action, frame) => {
+    async (action, frame, operationId) => {
       if (computer.controlError) throw computer.controlError;
       if (inputDenied) throw new Error("Desktop is view only. Refresh to check desktop controls.");
       let receipt;
       if (action.type === "pointer") {
         if (!frame) throw new Error("Desktop view is not ready for pointer input.");
-        receipt = await actFromFrame(action, frame);
+        receipt = await actFromFrame(action, frame, operationId);
       } else {
-        receipt = await act(action);
+        receipt = await act(action, operationId);
       }
-      if (receipt.state !== "completed") {
-        throw new Error(receipt.error?.message ?? "Desktop input did not complete.");
+      if (!isStaleComputerActionResult(receipt) && receipt.state !== "completed") {
+        throw computerActionReceiptError(receipt);
       }
+      return receipt;
     },
     [act, actFromFrame, computer.controlError, inputDenied]
   );
@@ -1350,11 +1486,15 @@ function ComputerViewer({
         return;
       event.preventDefault();
       event.stopPropagation();
-      void perform({ type: "clipboard", operation: "copy" }, null).then(() => computer.readClipboard()).then(async (clipboard) => {
+      void (async () => {
+        const receipt = await perform({ type: "clipboard", operation: "copy" }, null);
+        if (isStaleComputerActionResult(receipt)) return;
+        const clipboard = await computer.readClipboard();
+        if (isStaleComputerActionResult(receipt) || isStaleComputerActionResult(clipboard)) return;
         if (clipboard.text && !await copyTextToClipboard(clipboard.text)) {
           throw new Error("Desktop text could not be copied to the local clipboard");
         }
-      }).catch((cause) => notifyError(cause, "Could not copy from the desktop."));
+      })().catch((cause) => notifyError(cause, "Could not copy from the desktop."));
     },
     [computer, notifyError, perform, rfbInputEnabled, rfbStream]
   );
@@ -1363,8 +1503,11 @@ function ComputerViewer({
       if (!rfbInputEnabled || !rfbStream || computer.session?.capabilities?.clipboard !== true)
         return false;
       void (async () => {
-        await perform({ type: "clipboard", operation: "write", text }, null);
-        assertExactComputerClipboard(await computer.readClipboard(), text);
+        const receipt = await perform({ type: "clipboard", operation: "write", text }, null);
+        if (isStaleComputerActionResult(receipt)) return;
+        const clipboard = await computer.readClipboard();
+        if (isStaleComputerActionResult(receipt) || isStaleComputerActionResult(clipboard)) return;
+        assertExactComputerClipboard(clipboard, text);
         await perform({ type: "clipboard", operation: "paste" }, null);
       })().catch((cause) => notifyError(cause, "Could not paste into the desktop."));
       return true;
@@ -1523,6 +1666,7 @@ function ComputerViewer({
                 backgroundInput: computer.session?.capabilities?.backgroundInput === true,
                 clipboardEnabled: attachmentInputAllowed && computer.session?.capabilities?.clipboard === true,
                 pointerInput: attachmentInputAllowed && computer.session?.capabilities?.pointerInput === true,
+                pointerClickContinuation: attachmentInputAllowed && computer.session?.capabilities?.pointerClickContinuation === true,
                 keyboardInput: attachmentInputAllowed && computer.session?.capabilities?.keyboardInput === true,
                 onAction: perform,
                 onReadClipboard: computer.readClipboard,
@@ -1997,21 +2141,38 @@ function ComputerViewport(props) {
     }
   }, [clearBufferedInput, props.keyboardInput, props.pointerInput, rawInputEnabled]);
   const enqueue = useCallback5(
-    (action, frame, after) => {
+    (action, frame, after, continuation) => {
       const epoch = actionQueueEpochRef.current;
       const dispatch = actionRef.current;
       const isCurrent = () => mountedRef.current && epoch === actionQueueEpochRef.current;
-      actionTailRef.current = actionTailRef.current.catch(() => void 0).then(async () => {
-        if (!isCurrent()) return;
-        await dispatch(action, frame);
-        if (!isCurrent()) return;
-        await after?.(isCurrent);
+      const operationId = crypto.randomUUID();
+      let markStarted;
+      const started = new Promise((resolve) => {
+        markStarted = resolve;
+      });
+      const previous = actionTailRef.current;
+      const ready = continuation && previous === continuation.completion ? continuation.started : previous.then(() => true);
+      const delivery = ready.then(async (firstStarted) => {
+        if (!firstStarted || !isCurrent()) {
+          markStarted(false);
+          return;
+        }
+        const pending = dispatch(action, frame, operationId);
+        markStarted(true);
+        const receipt = await pending;
+        const isCurrentResult = () => isCurrent() && !isStaleComputerActionResult(receipt);
+        if (!isCurrentResult()) return;
+        await after?.(isCurrentResult);
       }).catch((cause) => {
-        if (!isCurrent()) return;
+        markStarted(false);
+        if (!isCurrent() || isStaleComputerActionResult(cause)) return;
         actionQueueEpochRef.current += 1;
         clearBufferedInput();
         errorRef.current(cause);
       });
+      const completion = continuation ? Promise.all([previous, delivery]).then(() => void 0) : delivery;
+      actionTailRef.current = completion;
+      return { operationId, started, completion };
     },
     [clearBufferedInput]
   );
@@ -2032,6 +2193,7 @@ function ComputerViewport(props) {
     if (clickTimerRef.current) clearTimeout(clickTimerRef.current);
     clickTimerRef.current = null;
     lastClickRef.current = null;
+    if (!pending.pending) return;
     enqueue(
       {
         type: "pointer",
@@ -2063,7 +2225,8 @@ function ComputerViewport(props) {
   }, [enqueue]);
   const pointerDown = (event) => {
     const frame = paintedFrameRef.current;
-    if (!frame || props.mutating || !rawInputEnabled || event.button !== 0) return;
+    if (!frame || !props.pointerClickContinuation && props.mutating || !rawInputEnabled || event.button !== 0)
+      return;
     event.preventDefault();
     if (keyboardInputEnabled) inputRef.current?.focus({ preventScroll: true });
     if (!pointerInputEnabled) return;
@@ -2082,6 +2245,7 @@ function ComputerViewport(props) {
     const start = pointerStartRef.current;
     pointerStartRef.current = null;
     if (!start || start.pointerId !== event.pointerId) return;
+    const canvasRect = event.currentTarget.getBoundingClientRect();
     const from = point(start.frame, start.x, start.y);
     const to = point(start.frame, event.clientX, event.clientY);
     if (!from || !to) return;
@@ -2103,7 +2267,7 @@ function ComputerViewport(props) {
     }
     const now = Date.now();
     const previous = lastClickRef.current;
-    if (previous && now - previous.at < 280 && Math.hypot(previous.x - to.x, previous.y - to.y) < 6 && sameFrameFence(previous.frame, start.frame)) {
+    if (previous && now - previous.at < 280 && previous.pending === !props.pointerClickContinuation && (props.pointerClickContinuation ? Math.hypot(previous.clientX - event.clientX, previous.clientY - event.clientY) < 6 && previous.canvasRect.left === canvasRect.left && previous.canvasRect.top === canvasRect.top && previous.canvasRect.width === canvasRect.width && previous.canvasRect.height === canvasRect.height && sameComputerTarget(previous.frame, start.frame) && previous.frame.width === start.frame.width && previous.frame.height === start.frame.height : Math.hypot(previous.x - to.x, previous.y - to.y) < 6 && sameFrameFence(previous.frame, start.frame))) {
       if (clickTimerRef.current) clearTimeout(clickTimerRef.current);
       clickTimerRef.current = null;
       lastClickRef.current = null;
@@ -2111,15 +2275,45 @@ function ComputerViewport(props) {
         {
           type: "pointer",
           frameId: start.frame.frameId,
-          action: "double_click",
+          action: props.pointerClickContinuation ? "click" : "double_click",
+          ...props.pointerClickContinuation ? { clickCount: 2 } : {},
+          ...previous.delivery ? { continuationOfOperationId: previous.delivery.operationId } : {},
+          x: to.x,
+          y: to.y
+        },
+        start.frame,
+        void 0,
+        previous.delivery ?? void 0
+      );
+      return;
+    }
+    flushPendingClick();
+    lastClickRef.current = {
+      at: now,
+      x: to.x,
+      y: to.y,
+      frame: start.frame,
+      clientX: event.clientX,
+      clientY: event.clientY,
+      canvasRect,
+      pending: !props.pointerClickContinuation,
+      delivery: null
+    };
+    if (props.pointerClickContinuation) {
+      const delivery = enqueue(
+        {
+          type: "pointer",
+          frameId: start.frame.frameId,
+          action: "click",
+          clickCount: 1,
           x: to.x,
           y: to.y
         },
         start.frame
       );
+      if (lastClickRef.current) lastClickRef.current.delivery = delivery;
       return;
     }
-    lastClickRef.current = { at: now, x: to.x, y: to.y, frame: start.frame };
     clickTimerRef.current = setTimeout(() => {
       clickTimerRef.current = null;
       lastClickRef.current = null;
@@ -2731,4 +2925,4 @@ export {
   ComputerViewer,
   computerKey
 };
-//# sourceMappingURL=chunk-MDIXFKA3.js.map
+//# sourceMappingURL=chunk-6FOTSVWU.js.map