@opengeni/react 0.57.0 → 1.0.2-canary.37191796234001

package/src/hooks/use-computer-frame-stream.ts

@@ -57,7 +57,12 @@ export type UseComputerFrameStreamResult = {
   frame: ComputerFrame | null;
   attachment: Pick<
     ComputerSessionAttachment,
-    "computerSessionId" | "controllerGeneration" | "targetId" | "stream" | "expiresAt"
+    | "computerSessionId"
+    | "controllerGeneration"
+    | "targetId"
+    | "inputAllowed"
+    | "stream"
+    | "expiresAt"
   > | null;
   error: Error | null;
   reconnect: () => void;
@@ -159,9 +164,19 @@ export function useComputerFrameStream(
       pendingFrame = null;
     };
 
+    const clearRecoveryTimers = () => {
+      if (reconnectTimer) clearTimeout(reconnectTimer);
+      if (expiryTimer) clearTimeout(expiryTimer);
+      reconnectTimer = null;
+      expiryTimer = null;
+    };
+
     const scheduleReconnect = () => {
       if (disposed || reconnectTimer) return;
-      if (failures >= MAX_AUTOMATIC_RECONNECTS_WITHOUT_A_FRAME) return;
+      if (failures >= MAX_AUTOMATIC_RECONNECTS_WITHOUT_A_FRAME) {
+        clearRecoveryTimers();
+        return;
+      }
       const delay = Math.min(5_000, 250 * 2 ** Math.min(failures, 5));
       failures += 1;
       setResult((current) => ({ ...current, state: "reconnecting" }));
@@ -177,6 +192,7 @@ export function useComputerFrameStream(
       setResult((current) => ({ ...current, state: "error", error }));
       clearSocket();
       if (reconnectAutomatically) scheduleReconnect();
+      else clearRecoveryTimers();
     };
 
     const onOpen = (source: ComputerFrameWebSocket) => {
@@ -211,10 +227,10 @@ export function useComputerFrameStream(
           const frame = await decodeComputerFrameMessage(bytes);
           if (disposed || source !== socket) continue;
           if (frame.computerSessionId !== computerSessionId || frame.targetId !== targetId) {
-            throw new Error("computer frame belongs to another resource");
+            throw new Error("desktop frame belongs to another resource");
           }
           if (!controllerGeneration || frame.controllerGeneration !== controllerGeneration) {
-            throw new Error("computer frame belongs to a stale controller");
+            throw new Error("desktop frame belongs to a stale controller");
           }
           const key = `${computerSessionId}:${targetId}:${frame.controllerGeneration}:${frame.targetGeneration}`;
           if (latestRef.current.key === key && frame.sequence <= latestRef.current.sequence)
@@ -246,7 +262,7 @@ export function useComputerFrameStream(
           if (disposed || source !== socket) return;
           let frameBytes = bytes;
           if (activeStream?.kind === "relay") {
-            if (bytes.length < 1) throw new Error("computer relay returned an empty message");
+            if (bytes.length < 1) throw new Error("desktop relay returned an empty message");
             const tag = bytes[0];
             const body = bytes.subarray(1);
             if (tag === RELAY_TAG_OPEN_ACK) {
@@ -255,7 +271,7 @@ export function useComputerFrameStream(
                 activeAttachment = null;
                 activeStream = null;
                 attachmentExpiresAt = 0;
-                throw new Error(ack.error?.message ?? "computer stream was rejected by the relay");
+                throw new Error(ack.error?.message ?? "desktop stream was rejected by the relay");
               }
               relayAccepted = true;
               return;
@@ -269,7 +285,7 @@ export function useComputerFrameStream(
               attachmentExpiresAt = 0;
               lastRelaySequence = null;
               relayAccepted = false;
-              fail(new Error("Computer frame source ended."), false);
+              fail(new Error("Desktop frame source ended."), false);
               return;
             }
             if (tag !== RELAY_TAG_FRAME || !relayAccepted) return;
@@ -290,13 +306,12 @@ export function useComputerFrameStream(
 
     const onError = (source: ComputerFrameWebSocket) => {
       if (source !== socket) return;
-      fail(new Error("Computer view lost connection."));
+      fail(new Error("Desktop view lost connection."));
     };
 
     const onClose = (source: ComputerFrameWebSocket) => {
       if (disposed || source !== socket) return;
-      clearSocket();
-      scheduleReconnect();
+      fail(new Error("Desktop view lost connection."));
     };
 
     const connectSocket = () => {
@@ -356,16 +371,19 @@ export function useComputerFrameStream(
             expiresInSeconds: 120,
             ...(streamRef.current ? { stream: streamRef.current } : {}),
           },
-          { signal: attachmentAbort.signal },
+          { signal: attachmentAbort.signal, timeoutMs: 15_000 },
         );
         if (disposed) return;
         if (
           attachment.computerSessionId !== computerSessionId ||
           attachment.targetId !== targetId
         ) {
-          throw new Error("computer attachment does not match the requested resource");
+          throw new Error("desktop attachment does not match the requested resource");
         }
         controllerGeneration = attachment.controllerGeneration;
+        // A fresh attachment owns a new producer whose sequence can restart.
+        // Transport reconnects reuse the attachment and retain their sequence fence.
+        latestRef.current = { key: "", sequence: -1 };
         activeAttachment = attachment;
         activeStream = attachment.stream;
         attachmentExpiresAt = Date.parse(attachment.expiresAt);
@@ -378,6 +396,7 @@ export function useComputerFrameStream(
             computerSessionId: attachment.computerSessionId,
             controllerGeneration: attachment.controllerGeneration,
             targetId: attachment.targetId,
+            inputAllowed: attachment.inputAllowed,
             stream: attachment.stream,
             expiresAt: attachment.expiresAt,
           },
@@ -397,7 +416,7 @@ export function useComputerFrameStream(
         connectSocket();
       } catch (cause) {
         if (attachmentAbort.signal.aborted || disposed) return;
-        fail(cause);
+        fail(cause, !isPlacementGenerationLossError(cause));
       }
     };
 
@@ -406,8 +425,7 @@ export function useComputerFrameStream(
       disposed = true;
       pendingFrame = null;
       attachmentAbort.abort();
-      if (reconnectTimer) clearTimeout(reconnectTimer);
-      if (expiryTimer) clearTimeout(expiryTimer);
+      clearRecoveryTimers();
       clearSocket(true);
     };
   }, [client, enabled, nonce, options.computerSessionId, options.targetId, workspaceId]);
@@ -430,5 +448,10 @@ async function messageBytes(value: unknown): Promise<Uint8Array> {
   if (typeof Blob !== "undefined" && value instanceof Blob) {
     return new Uint8Array(await value.arrayBuffer());
   }
-  throw new Error("computer frame stream returned a non-binary message");
+  throw new Error("desktop frame stream returned a non-binary message");
+}
+
+function isPlacementGenerationLossError(cause: unknown): boolean {
+  const message = cause instanceof Error ? cause.message : String(cause);
+  return /placement instance changed|controller authority changed/i.test(message);
 }

package/src/hooks/use-computer-input-posture.ts

@@ -0,0 +1,94 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  type EmbeddedComputerInteractionClientOverride,
+  useEmbeddedComputerInteraction,
+} from "../session-context";
+
+type PostureSource = {
+  client: ReturnType<typeof useEmbeddedComputerInteraction>["client"];
+  key: string;
+};
+
+type PostureState = {
+  source: PostureSource;
+  nonce: number;
+  inputAllowed: boolean | null;
+  pending: boolean;
+  error: Error | null;
+};
+
+/** Semantic-only targets need caller authority without opening a pixel stream.
+ * A source change synchronously discards the previous posture. */
+export function useComputerInputPosture(
+  options: EmbeddedComputerInteractionClientOverride & {
+    computerSessionId: string | null;
+    controllerGeneration: string | null;
+    enabled: boolean;
+  },
+) {
+  const { client, workspaceId } = useEmbeddedComputerInteraction(options);
+  const { computerSessionId, controllerGeneration, enabled } = options;
+  const [nonce, setNonce] = useState(0);
+  const [state, setState] = useState<PostureState | null>(null);
+  const key = JSON.stringify([workspaceId, computerSessionId, controllerGeneration, enabled]);
+  const sourceRef = useRef<PostureSource>({ client, key });
+  if (sourceRef.current.client !== client || sourceRef.current.key !== key) {
+    sourceRef.current = { client, key };
+  }
+  const source = sourceRef.current;
+  const visible = state?.source === source && state.nonce === nonce ? state : null;
+  const refresh = useCallback(() => setNonce((value) => value + 1), []);
+
+  useEffect(() => {
+    if (!enabled || !computerSessionId || !controllerGeneration) return;
+    const controller = new AbortController();
+    let disposed = false;
+    setState({ source, nonce, inputAllowed: null, pending: true, error: null });
+    void (async () => {
+      try {
+        if (!client.getComputerInputPosture) {
+          throw new Error("Desktop input availability could not be verified.");
+        }
+        const posture = await client.getComputerInputPosture(workspaceId, computerSessionId, {
+          signal: controller.signal,
+          timeoutMs: 15_000,
+        });
+        if (disposed || sourceRef.current !== source) return;
+        if (
+          posture.computerSessionId !== computerSessionId ||
+          posture.controllerGeneration !== controllerGeneration ||
+          typeof posture.inputAllowed !== "boolean"
+        ) {
+          throw new Error("Desktop input availability belongs to a different controller.");
+        }
+        setState({
+          source,
+          nonce,
+          inputAllowed: posture.inputAllowed,
+          pending: false,
+          error: null,
+        });
+      } catch (cause) {
+        if (disposed || controller.signal.aborted || sourceRef.current !== source) return;
+        setState({
+          source,
+          nonce,
+          inputAllowed: null,
+          pending: false,
+          error: cause instanceof Error ? cause : new Error(String(cause)),
+        });
+      }
+    })();
+    return () => {
+      disposed = true;
+      controller.abort();
+    };
+  }, [client, computerSessionId, controllerGeneration, enabled, nonce, source, workspaceId]);
+
+  return {
+    inputAllowed: visible?.inputAllowed ?? null,
+    pending: enabled && (visible?.pending ?? true),
+    error: visible?.error ?? null,
+    refresh,
+  };
+}

package/src/hooks/use-computer-session.ts

@@ -8,6 +8,10 @@ import type {
   ComputerTarget,
 } from "@opengeni/sdk/interaction";
 import { useCallback, useEffect, useRef, useState } from "react";
+import {
+  isInteractionControlUnavailable,
+  isNonRetryableInteractionError,
+} from "../lib/interaction-errors";
 import {
   type EmbeddedComputerInteractionClientOverride,
   useEmbeddedComputerInteraction,
@@ -28,6 +32,8 @@ export type UseComputerSessionResult = {
   loading: boolean;
   mutating: boolean;
   error: Error | null;
+  /** Control service loss, independent of target accessibility inspection and media. */
+  controlError: Error | null;
   refresh: () => Promise<void>;
   readClipboard: () => Promise<ComputerClipboard>;
   /** Changes only this viewer's target cursor; it never takes ownership or
@@ -55,6 +61,7 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
   );
   const visible =
     state.computerSessionId === computerSessionId ? state : emptyState(computerSessionId, enabled);
+  const refreshBlocked = isNonRetryableInteractionError(visible.error);
   const selectedTargetIdRef = useRef<string | null>(visible.selectedTargetId);
   selectedTargetIdRef.current = visible.selectedTargetId;
   const targetsRef = useRef<{
@@ -103,6 +110,7 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
     requestRef.current.controller?.abort();
     const controller = new AbortController();
     requestRef.current = { id, controller };
+    let discoveryCompleted = false;
     try {
       const [session, targetResponse] = await Promise.all([
         client.getComputerSession(workspaceId, computerSessionId, {
@@ -112,9 +120,38 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
           signal: controller.signal,
         }),
       ]);
+      discoveryCompleted = true;
       if (!mountedRef.current || requestRef.current.id !== id) return;
       const targets = sortComputerTargets(targetResponse.targets);
-      const selected = chooseTarget(targets, selectedTargetIdRef.current, session.platform);
+      const selected = chooseTarget(targets, selectedTargetIdRef.current);
+      // Discovery is useful independently of semantic observation. Publish it
+      // now so a slow/unresponsive application cannot block the frame stream
+      // or prevent the person from choosing a different window or screen.
+      const previous = observationRef.current.observation;
+      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 };
+      setState((current) =>
+        current.computerSessionId === computerSessionId
+          ? {
+              ...current,
+              session,
+              targets,
+              selectedTargetId: selected?.id ?? null,
+              observation: retainedObservation,
+              loading: false,
+              error: null,
+              controlError: null,
+            }
+          : current,
+      );
       const observation = selected
         ? await client.observeComputerTarget(workspaceId, computerSessionId, selected.id, {
             signal: controller.signal,
@@ -139,12 +176,19 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
       );
     } catch (cause) {
       if (controller.signal.aborted || !mountedRef.current || requestRef.current.id !== id) return;
+      const error = cause instanceof Error ? cause : new Error(String(cause));
       setState((current) =>
         current.computerSessionId === computerSessionId
           ? {
               ...current,
               loading: false,
-              error: cause instanceof Error ? cause : new Error(String(cause)),
+              error,
+              controlError: isInteractionControlUnavailable(
+                error,
+                discoveryCompleted ? "observation" : "control",
+              )
+                ? error
+                : current.controlError,
             }
           : current,
       );
@@ -173,15 +217,15 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
   }, [computerSessionId, enabled, invalidateRefresh, refresh]);
 
   useEffect(() => {
-    if (!enabled || !pageLive || visible.mutating) return;
+    if (!enabled || !pageLive || visible.mutating || refreshBlocked) return;
     const timer = setInterval(() => {
       if (!requestRef.current.controller) void refresh();
     }, pollIntervalMs);
     return () => clearInterval(timer);
-  }, [enabled, pageLive, pollIntervalMs, refresh, visible.mutating]);
+  }, [enabled, pageLive, pollIntervalMs, refresh, refreshBlocked, visible.mutating]);
 
   useEffect(() => {
-    if (!enabled || !computerSessionId || !pageLive) return;
+    if (!enabled || !computerSessionId || !pageLive || refreshBlocked) return;
     let disposed = false;
     const timer = setInterval(() => {
       void client.heartbeatComputerSession(workspaceId, computerSessionId).catch(() => {
@@ -192,7 +236,7 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
       disposed = true;
       clearInterval(timer);
     };
-  }, [client, computerSessionId, enabled, pageLive, refresh, workspaceId]);
+  }, [client, computerSessionId, enabled, pageLive, refresh, refreshBlocked, workspaceId]);
 
   const runMutation = useCallback(
     async <T>(scopeComputerSessionId: string, operation: () => Promise<T>): Promise<T> => {
@@ -210,11 +254,23 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
           : current,
       );
       try {
-        return await operation();
+        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 } : current,
+          current.computerSessionId === scopeComputerSessionId
+            ? {
+                ...current,
+                error,
+                controlError: isInteractionControlUnavailable(error) ? error : current.controlError,
+              }
+            : current,
         );
         throw error;
       } finally {
@@ -234,9 +290,9 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
 
   const selectTarget = useCallback(
     async (targetId: string): Promise<ComputerTarget> => {
-      if (!computerSessionId) throw new Error("No ComputerSession is selected.");
+      if (!computerSessionId) throw new Error("No desktop is selected.");
       const target = targetsRef.current.targets.find((candidate) => candidate.id === targetId);
-      if (!target) throw new Error("The selected computer target is no longer available.");
+      if (!target) throw new Error("The selected desktop target is no longer available.");
       invalidateRefresh();
       selectedTargetIdRef.current = target.id;
       observationRef.current = { computerSessionId, observation: null };
@@ -269,7 +325,14 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
         const error = cause instanceof Error ? cause : new Error(String(cause));
         setState((current) =>
           current.computerSessionId === computerSessionId && current.selectedTargetId === target.id
-            ? { ...current, loading: false, error }
+            ? {
+                ...current,
+                loading: false,
+                error,
+                controlError: isInteractionControlUnavailable(error, "observation")
+                  ? error
+                  : current.controlError,
+              }
             : current,
         );
         throw error;
@@ -284,9 +347,9 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
       operationId: string,
       frame: ComputerFrame | null,
     ): Promise<ComputerActionReceipt> => {
-      if (!computerSessionId) throw new Error("No ComputerSession is selected.");
+      if (!computerSessionId) throw new Error("No desktop is selected.");
       if (frame && frame.computerSessionId !== computerSessionId) {
-        throw new Error("The displayed computer frame belongs to another ComputerSession.");
+        throw new Error("The displayed desktop frame belongs to another desktop session.");
       }
       const currentObservation =
         observationRef.current.computerSessionId === computerSessionId
@@ -301,19 +364,27 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
         ? (targetsRef.current.targets.find((candidate) => candidate.id === frame.targetId) ??
           (currentObservation?.target.id === frame.targetId ? currentObservation.target : null))
         : null;
-      const target = frameTarget ?? focusTarget ?? currentObservation?.target ?? null;
-      if (!target) throw new Error("The computer target is not ready for input.");
+      const inputTarget =
+        (action.type === "keyboard" || action.type === "clipboard") &&
+        targetsRef.current.computerSessionId === computerSessionId
+          ? targetsRef.current.targets.find(
+              (candidate) => candidate.id === selectedTargetIdRef.current,
+            )
+          : null;
+      const target =
+        frameTarget ?? focusTarget ?? currentObservation?.target ?? inputTarget ?? null;
+      if (!target) throw new Error("The desktop target is not ready for input.");
       if (frame && frame.targetId !== selectedTargetIdRef.current) {
-        throw new Error("The displayed computer frame is no longer selected.");
+        throw new Error("The displayed desktop frame is no longer selected.");
       }
       if (action.type === "pointer") {
         const expectedFrameId = frame?.frameId ?? currentObservation?.frameId ?? null;
         if (!expectedFrameId || action.frameId !== expectedFrameId) {
-          throw new Error("Pointer input must reference the exact displayed computer frame.");
+          throw new Error("Pointer input must reference the exact displayed desktop frame.");
         }
       }
       if (action.type === "semantic" && !currentObservation) {
-        throw new Error("The computer accessibility tree is not ready for input.");
+        throw new Error("The desktop accessibility tree is not ready for input.");
       }
 
       return await runMutation(computerSessionId, async () => {
@@ -367,8 +438,22 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
   );
 
   const readClipboard = useCallback(async (): Promise<ComputerClipboard> => {
-    if (!computerSessionId) throw new Error("No ComputerSession is selected.");
-    return await client.readComputerClipboard(workspaceId, computerSessionId);
+    if (!computerSessionId) throw new Error("No desktop is selected.");
+    try {
+      return await client.readComputerClipboard(workspaceId, computerSessionId);
+    } catch (cause) {
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      setState((current) =>
+        current.computerSessionId === computerSessionId
+          ? {
+              ...current,
+              error,
+              controlError: isInteractionControlUnavailable(error) ? error : current.controlError,
+            }
+          : current,
+      );
+      throw error;
+    }
   }, [client, computerSessionId, workspaceId]);
 
   return {
@@ -380,6 +465,7 @@ export function useComputerSession(options: UseComputerSessionOptions): UseCompu
     loading: visible.loading,
     mutating: visible.mutating,
     error: visible.error,
+    controlError: visible.controlError,
     refresh,
     readClipboard,
     selectTarget,
@@ -397,6 +483,7 @@ type ComputerControlState = {
   loading: boolean;
   mutating: boolean;
   error: Error | null;
+  controlError: Error | null;
 };
 
 function emptyState(computerSessionId: string | null, loading: boolean): ComputerControlState {
@@ -409,32 +496,23 @@ function emptyState(computerSessionId: string | null, loading: boolean): Compute
     loading,
     mutating: false,
     error: null,
+    controlError: null,
   };
 }
 
 function chooseTarget(
   targets: readonly ComputerTarget[],
   preferredId: string | null,
-  platform: ComputerSession["platform"],
 ): ComputerTarget | null {
   const preferred = targets.find((target) => target.id === preferredId);
   if (preferred) return preferred;
-  if (platform === "linux") {
-    return (
-      targets.find((target) => target.focused && target.kind === "screen") ??
-      targets.find((target) => target.kind === "screen") ??
-      targets.find((target) => target.focused && target.kind === "window") ??
-      targets.find((target) => target.kind === "window") ??
-      targets[0] ??
-      null
-    );
-  }
   return (
+    targets.find((target) => target.focused && target.kind === "screen") ??
+    targets.find((target) => target.kind === "screen") ??
     targets.find((target) => target.focused && target.kind === "window") ??
     targets.find((target) => target.kind === "window") ??
     targets.find((target) => target.focused && target.kind === "app") ??
     targets.find((target) => target.kind === "app") ??
-    targets.find((target) => target.kind === "screen") ??
     targets[0] ??
     null
   );

package/src/hooks/use-computer-sessions.ts

@@ -74,6 +74,7 @@ export function useComputerSessions(
       requestRef.current = { id, controller };
       setState((current) => ({
         ...(current.workspaceId === workspaceId ? current : emptyState(workspaceId, true)),
+        active: true,
         loading: foreground,
         refreshing: !foreground,
         error: foreground || current.workspaceId !== workspaceId ? null : current.error,
@@ -85,6 +86,7 @@ export function useComputerSessions(
         if (!mountedRef.current || requestRef.current.id !== id) return;
         setState({
           workspaceId,
+          active: true,
           revision: response.revision,
           sessions: sortComputerSessions(response.sessions),
           loading: false,
@@ -187,7 +189,10 @@ export function useComputerSessions(
     revision: visible.revision,
     sessions: visible.sessions,
     relevantSessions,
-    loading: visible.loading,
+    // A disabled registry is deliberately empty. When its surface becomes
+    // visible again, expose that transition as loading in the same render so
+    // consumers cannot mistake the stale empty snapshot for a completed list.
+    loading: enabled ? !visible.active || visible.loading : false,
     refreshing: visible.refreshing,
     error: visible.error,
     refresh,
@@ -198,6 +203,7 @@ export function useComputerSessions(
 
 type ComputerRegistryState = {
   workspaceId: string;
+  active: boolean;
   revision: number;
   sessions: ComputerSession[];
   loading: boolean;
@@ -208,6 +214,7 @@ type ComputerRegistryState = {
 function emptyState(workspaceId: string, loading: boolean): ComputerRegistryState {
   return {
     workspaceId,
+    active: loading,
     revision: 0,
     sessions: [],
     loading,

package/src/hooks/use-connect.ts

@@ -0,0 +1,23 @@
+import type { ConnectController } from "@opengeni/connect";
+import { useMemo, useSyncExternalStore } from "react";
+
+/** Internal consumers import the hook directly so setup surfaces stay lazy. */
+export function useConnect(controller: ConnectController) {
+  const snapshot = useSyncExternalStore(
+    controller.subscribe,
+    controller.getSnapshot,
+    controller.getSnapshot,
+  );
+  const actions = useMemo(
+    () => ({
+      begin: controller.begin.bind(controller),
+      recover: controller.recover.bind(controller),
+      refresh: controller.refresh.bind(controller),
+      waitForAction: controller.waitForAction.bind(controller),
+      advance: controller.advance.bind(controller),
+      cancel: controller.cancel.bind(controller),
+    }),
+    [controller],
+  );
+  return useMemo(() => ({ ...snapshot, ...actions }), [snapshot, actions]);
+}