@opengeni/react 0.11.0 → 0.13.0

package/src/hooks/use-environments.ts

@@ -1,118 +1,163 @@
 import type {
-  CreateWorkspaceEnvironmentRequest,
-  UpdateWorkspaceEnvironmentRequest,
-  WorkspaceEnvironment,
-  WorkspaceEnvironmentVariableMetadata,
+  CreateVariableSetRequest,
+  UpdateVariableSetRequest,
+  VariableSet,
+  VariableSetVariableMetadata,
 } from "@opengeni/sdk";
-import { useCallback } from "react";
+import { useCallback, useMemo } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
 import { useMutationRunner, usePolledValue } from "./internal";
 
-export type UseEnvironmentsOptions = ClientOverride & {
+export type UseVariableSetsOptions = ClientOverride & {
   pollIntervalMs?: number | undefined;
   enabled?: boolean | undefined;
 };
 
-export type UseEnvironmentsResult = {
-  environments: WorkspaceEnvironment[];
+export type UseVariableSetsResult = {
+  variableSets: VariableSet[];
   loading: boolean;
   error: Error | null;
   refresh: () => Promise<void>;
-  create: (request: CreateWorkspaceEnvironmentRequest) => Promise<WorkspaceEnvironment | null>;
-  update: (environmentId: string, request: UpdateWorkspaceEnvironmentRequest) => Promise<WorkspaceEnvironment | null>;
-  remove: (environmentId: string) => Promise<boolean>;
+  create: (request: CreateVariableSetRequest) => Promise<VariableSet | null>;
+  update: (variableSetId: string, request: UpdateVariableSetRequest) => Promise<VariableSet | null>;
+  remove: (variableSetId: string) => Promise<boolean>;
   /** Set/rotate a variable. Values are write-only — reads expose metadata only. */
-  setVariable: (environmentId: string, name: string, value: string) => Promise<WorkspaceEnvironmentVariableMetadata | null>;
-  deleteVariable: (environmentId: string, name: string) => Promise<boolean>;
+  setVariable: (
+    variableSetId: string,
+    name: string,
+    value: string,
+  ) => Promise<VariableSetVariableMetadata | null>;
+  deleteVariable: (variableSetId: string, name: string) => Promise<boolean>;
   mutating: boolean;
   mutationError: Error | null;
   clearMutationError: () => void;
 };
 
 /**
- * Workspace environments (named, encrypted variable sets attached to sessions
+ * Variable sets (named, encrypted variable sets attached to sessions
  * and scheduled tasks). Variable values are write-only end to end: this hook
  * never sees a value after it is sent.
  */
-export function useEnvironments(options: UseEnvironmentsOptions = {}): UseEnvironmentsResult {
+export function useVariableSets(options: UseVariableSetsOptions = {}): UseVariableSetsResult {
   const { client, workspaceId } = useOpenGeni(options);
-  const load = useCallback(async () => await client.listEnvironments(workspaceId), [client, workspaceId]);
-  const state = usePolledValue(load, { pollIntervalMs: options.pollIntervalMs, enabled: options.enabled });
-  const mutation = useMutationRunner();
+  const load = useCallback(
+    async () => await client.listVariableSets(workspaceId),
+    [client, workspaceId],
+  );
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled,
+  });
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
 
   const create = useCallback(
-    async (request: CreateWorkspaceEnvironmentRequest): Promise<WorkspaceEnvironment | null> => {
-      const result = await mutation.run(() => client.createEnvironment(workspaceId, request));
+    async (request: CreateVariableSetRequest): Promise<VariableSet | null> => {
+      const result = await run(() => client.createVariableSet(workspaceId, request));
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   const update = useCallback(
-    async (environmentId: string, request: UpdateWorkspaceEnvironmentRequest): Promise<WorkspaceEnvironment | null> => {
-      const result = await mutation.run(() => client.updateEnvironment(workspaceId, environmentId, request));
+    async (
+      variableSetId: string,
+      request: UpdateVariableSetRequest,
+    ): Promise<VariableSet | null> => {
+      const result = await run(() => client.updateVariableSet(workspaceId, variableSetId, request));
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   const remove = useCallback(
-    async (environmentId: string): Promise<boolean> => {
-      const result = await mutation.run(async () => {
-        await client.deleteEnvironment(workspaceId, environmentId);
+    async (variableSetId: string): Promise<boolean> => {
+      const result = await run(async () => {
+        await client.deleteVariableSet(workspaceId, variableSetId);
         return true;
       });
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result === true;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   const setVariable = useCallback(
-    async (environmentId: string, name: string, value: string): Promise<WorkspaceEnvironmentVariableMetadata | null> => {
-      const result = await mutation.run(() => client.setEnvironmentVariable(workspaceId, environmentId, name, value));
+    async (
+      variableSetId: string,
+      name: string,
+      value: string,
+    ): Promise<VariableSetVariableMetadata | null> => {
+      const result = await run(() =>
+        client.setVariableSetVariable(workspaceId, variableSetId, name, value),
+      );
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   const deleteVariable = useCallback(
-    async (environmentId: string, name: string): Promise<boolean> => {
-      const result = await mutation.run(async () => {
-        await client.deleteEnvironmentVariable(workspaceId, environmentId, name);
+    async (variableSetId: string, name: string): Promise<boolean> => {
+      const result = await run(async () => {
+        await client.deleteVariableSetVariable(workspaceId, variableSetId, name);
         return true;
       });
       if (result) {
-        await state.refresh();
+        await refresh();
       }
       return result === true;
     },
-    [client, workspaceId, mutation.run, state.refresh],
+    [client, workspaceId, run, refresh],
   );
 
   return {
-    environments: state.data ?? [],
-    loading: state.loading,
-    error: state.error,
-    refresh: state.refresh,
+    variableSets: data ?? [],
+    loading,
+    error,
+    refresh,
     create,
     update,
     remove,
     setVariable,
     deleteVariable,
-    mutating: mutation.mutating,
-    mutationError: mutation.mutationError,
-    clearMutationError: mutation.clearMutationError,
+    mutating,
+    mutationError,
+    clearMutationError,
   };
 }
+
+/** @deprecated use UseVariableSetsOptions */
+export type UseEnvironmentsOptions = UseVariableSetsOptions;
+/** @deprecated use UseVariableSetsResult */
+export type UseEnvironmentsResult = UseVariableSetsResult & { environments: VariableSet[] };
+/** @deprecated use useVariableSets */
+export function useEnvironments(options: UseEnvironmentsOptions = {}): UseEnvironmentsResult {
+  const legacyClient = useMemo(() => {
+    if (!options.client) {
+      return undefined;
+    }
+    return {
+      ...options.client,
+      listVariableSets: options.client.listEnvironments ?? options.client.listVariableSets,
+      createVariableSet: options.client.createEnvironment ?? options.client.createVariableSet,
+      updateVariableSet: options.client.updateEnvironment ?? options.client.updateVariableSet,
+      deleteVariableSet: options.client.deleteEnvironment ?? options.client.deleteVariableSet,
+      setVariableSetVariable:
+        options.client.setEnvironmentVariable ?? options.client.setVariableSetVariable,
+      deleteVariableSetVariable:
+        options.client.deleteEnvironmentVariable ?? options.client.deleteVariableSetVariable,
+    };
+  }, [options.client]);
+  const result = useVariableSets({ ...options, ...(legacyClient ? { client: legacyClient } : {}) });
+  return { ...result, environments: result.variableSets };
+}

package/src/hooks/use-file-attachments.ts

@@ -61,7 +61,9 @@ const isImage = (file: File): boolean => file.type.startsWith("image/");
  * `resources`. Workspace-scoped, so it resolves both client and workspace from
  * the {@link OpenGeniProvider} (or a per-call `{ client, workspaceId }`).
  */
-export function useFileAttachments(options: UseFileAttachmentsOptions = {}): UseFileAttachmentsResult {
+export function useFileAttachments(
+  options: UseFileAttachmentsOptions = {},
+): UseFileAttachmentsResult {
   const { client, workspaceId } = useOpenGeni(options);
   const pasteFilter = options.pasteFilter ?? isImage;
   const [attachments, setAttachments] = useState<FileAttachment[]>([]);
@@ -72,60 +74,102 @@ export function useFileAttachments(options: UseFileAttachmentsOptions = {}): Use
   // Run (or re-run) the upload for one already-tracked attachment id. Sets it
   // back to `uploading`, then resolves to `ready` (with the asset) or `failed`
   // (with the error message).
-  const startUpload = useCallback((id: string, file: File) => {
-    void client.uploadFile(workspaceId, {
-      filename: file.name || "file",
-      contentType: file.type || "application/octet-stream",
-      data: file,
-    }).then((asset) => {
-      setAttachments((current) => current.map((attachment) => attachment.id === id
-        ? { ...attachment, status: "ready", file: asset, name: asset.filename, contentType: asset.contentType, sizeBytes: asset.sizeBytes, error: undefined }
-        : attachment));
-    }).catch((error: unknown) => {
-      setAttachments((current) => current.map((attachment) => attachment.id === id
-        ? { ...attachment, status: "failed", error: error instanceof Error ? error.message : String(error) }
-        : attachment));
-    });
-  }, [client, workspaceId]);
+  const startUpload = useCallback(
+    (id: string, file: File) => {
+      void client
+        .uploadFile(workspaceId, {
+          filename: file.name || "file",
+          contentType: file.type || "application/octet-stream",
+          data: file,
+        })
+        .then((asset) => {
+          setAttachments((current) =>
+            current.map((attachment) =>
+              attachment.id === id
+                ? {
+                    ...attachment,
+                    status: "ready",
+                    file: asset,
+                    name: asset.filename,
+                    contentType: asset.contentType,
+                    sizeBytes: asset.sizeBytes,
+                    error: undefined,
+                  }
+                : attachment,
+            ),
+          );
+        })
+        .catch((error: unknown) => {
+          setAttachments((current) =>
+            current.map((attachment) =>
+              attachment.id === id
+                ? {
+                    ...attachment,
+                    status: "failed",
+                    error: error instanceof Error ? error.message : String(error),
+                  }
+                : attachment,
+            ),
+          );
+        });
+    },
+    [client, workspaceId],
+  );
 
-  const addFiles = useCallback((files: Iterable<File>) => {
-    for (const file of files) {
-      const id = crypto.randomUUID();
-      sources.current.set(id, file);
-      const previewUrl = isImage(file) ? URL.createObjectURL(file) : undefined;
-      setAttachments((current) => [...current, {
-        id,
-        name: file.name || "image",
-        contentType: file.type || "application/octet-stream",
-        sizeBytes: file.size,
-        status: "uploading",
-        ...(previewUrl ? { previewUrl } : {}),
-      }]);
-      startUpload(id, file);
-    }
-  }, [startUpload]);
+  const addFiles = useCallback(
+    (files: Iterable<File>) => {
+      for (const file of files) {
+        const id = crypto.randomUUID();
+        sources.current.set(id, file);
+        const previewUrl = isImage(file) ? URL.createObjectURL(file) : undefined;
+        setAttachments((current) => [
+          ...current,
+          {
+            id,
+            name: file.name || "image",
+            contentType: file.type || "application/octet-stream",
+            sizeBytes: file.size,
+            status: "uploading",
+            ...(previewUrl ? { previewUrl } : {}),
+          },
+        ]);
+        startUpload(id, file);
+      }
+    },
+    [startUpload],
+  );
 
-  const retry = useCallback((id: string) => {
-    const file = sources.current.get(id);
-    if (!file) {
-      return;
-    }
-    setAttachments((current) => current.map((attachment) => attachment.id === id
-      ? { ...attachment, status: "uploading", error: undefined }
-      : attachment));
-    startUpload(id, file);
-  }, [startUpload]);
+  const retry = useCallback(
+    (id: string) => {
+      const file = sources.current.get(id);
+      if (!file) {
+        return;
+      }
+      setAttachments((current) =>
+        current.map((attachment) =>
+          attachment.id === id
+            ? { ...attachment, status: "uploading", error: undefined }
+            : attachment,
+        ),
+      );
+      startUpload(id, file);
+    },
+    [startUpload],
+  );
 
-  const addFromPaste = useCallback((event: { clipboardData: DataTransfer | null }) => {
-    const clipboardFiles = event.clipboardData?.files;
-    if (!clipboardFiles) {
-      return;
-    }
-    const files = [...clipboardFiles].filter(pasteFilter);
-    if (files.length > 0) {
-      addFiles(files);
-    }
-  }, [addFiles, pasteFilter]);
+  const addFromPaste = useCallback(
+    (event: { clipboardData: DataTransfer | null }) => {
+      const clipboardFiles = event.clipboardData?.files;
+      if (!clipboardFiles) {
+        return;
+      }
+      const files = [...clipboardFiles].filter(pasteFilter);
+      if (files.length > 0) {
+        addFiles(files);
+      }
+    },
+    [addFiles, pasteFilter],
+  );
 
   const remove = useCallback((id: string) => {
     sources.current.delete(id);
@@ -152,9 +196,11 @@ export function useFileAttachments(options: UseFileAttachmentsOptions = {}): Use
 
   return {
     attachments,
-    readyResources: attachments.flatMap((attachment): FileResourceRef[] => attachment.status === "ready" && attachment.file
-      ? [{ kind: "file", fileId: attachment.file.id }]
-      : []),
+    readyResources: attachments.flatMap((attachment): FileResourceRef[] =>
+      attachment.status === "ready" && attachment.file
+        ? [{ kind: "file", fileId: attachment.file.id }]
+        : [],
+    ),
     uploading: attachments.some((attachment) => attachment.status === "uploading"),
     addFiles,
     addFromPaste,

package/src/hooks/use-goal.ts

@@ -1,17 +1,23 @@
 import { OpenGeniApiError, type SessionEvent, type SessionGoal } from "@opengeni/sdk";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { useOpenGeni, type ClientOverride } from "../provider";
-import { useDebouncedCallback, useMutationRunner, useSessionEventTrigger, type SessionEventFeedOptions } from "./internal";
+import {
+  useDebouncedCallback,
+  useMutationRunner,
+  useSessionEventTrigger,
+  type SessionEventFeedOptions,
+} from "./internal";
 
 /** Event types that change the session goal (set/updated/completed/paused/...). */
 export function isGoalEvent(event: Pick<SessionEvent, "type">): boolean {
   return event.type.startsWith("goal.");
 }
 
-export type UseGoalOptions = ClientOverride & SessionEventFeedOptions & {
-  /** Optional safety-net polling (ms). Off by default — goal.* events drive updates. */
-  pollIntervalMs?: number | undefined;
-};
+export type UseGoalOptions = ClientOverride &
+  SessionEventFeedOptions & {
+    /** Optional safety-net polling (ms). Off by default — goal.* events drive updates. */
+    pollIntervalMs?: number | undefined;
+  };
 
 export type UseGoalResult = {
   /** The session goal, or null when the session has none. */
@@ -27,7 +33,11 @@ export type UseGoalResult = {
   pause: (rationale?: string) => Promise<SessionGoal | null>;
   /** Resume a paused goal: resets counters and re-arms continuations. */
   resume: () => Promise<SessionGoal | null>;
-  /** True while a pause/resume is in flight. */
+  /** Clear the session goal; goal-less sessions remain a successful no-op. */
+  clearGoal: () => Promise<void>;
+  /** Alias for `clearGoal`. */
+  deleteGoal: () => Promise<void>;
+  /** True while a pause/resume/clear is in flight. */
   updating: boolean;
   mutationError: Error | null;
   clearMutationError: () => void;
@@ -39,7 +49,10 @@ export type UseGoalResult = {
  * `goal: null` (the 404 is absorbed). Live-updates on `goal.*` events —
  * pass `options.events` from `useSessionEvents` to reuse its stream.
  */
-export function useGoal(sessionId: string | null | undefined, options: UseGoalOptions = {}): UseGoalResult {
+export function useGoal(
+  sessionId: string | null | undefined,
+  options: UseGoalOptions = {},
+): UseGoalResult {
   const { client, workspaceId } = useOpenGeni(options);
   const enabled = (options.enabled ?? true) && Boolean(sessionId);
   const sharedEvents = options.events;
@@ -47,7 +60,7 @@ export function useGoal(sessionId: string | null | undefined, options: UseGoalOp
   const [goal, setGoal] = useState<SessionGoal | null>(null);
   const [loading, setLoading] = useState(enabled);
   const [error, setError] = useState<Error | null>(null);
-  const mutation = useMutationRunner();
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
   const generation = useRef(0);
   const targetKeyRef = useRef<string | null>(null);
 
@@ -121,29 +134,50 @@ export function useGoal(sessionId: string | null | undefined, options: UseGoalOp
       if (!sessionId) {
         return null;
       }
-      const result = await mutation.run(() =>
+      const result = await run(() =>
         client.updateGoal(workspaceId, sessionId, {
           status: "paused",
           ...(rationale !== undefined ? { rationale } : {}),
-        }));
+        }),
+      );
       if (result) {
         setGoal(result);
       }
       return result;
     },
-    [client, workspaceId, sessionId, mutation.run],
+    [client, workspaceId, sessionId, run],
   );
 
   const resume = useCallback(async (): Promise<SessionGoal | null> => {
     if (!sessionId) {
       return null;
     }
-    const result = await mutation.run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
+    const result = await run(() => client.updateGoal(workspaceId, sessionId, { status: "active" }));
     if (result) {
       setGoal(result);
     }
     return result;
-  }, [client, workspaceId, sessionId, mutation.run]);
+  }, [client, workspaceId, sessionId, run]);
+
+  const clearGoal = useCallback(async (): Promise<void> => {
+    if (!sessionId) {
+      return;
+    }
+    // deleteGoal resolves void, so distinguish success (a truthy sentinel) from
+    // mutation.run's null-on-failure. Only a SUCCESSFUL delete hides the goal:
+    // a failed one leaves the pill up so its mutationError renders. And invalidate
+    // any in-flight load first so a slower getGoal started before the delete can't
+    // commit and repopulate the just-cleared goal.
+    const ok = await run(async () => {
+      await client.deleteGoal(workspaceId, sessionId);
+      return true as const;
+    });
+    if (ok) {
+      generation.current += 1;
+      setGoal(null);
+      setError(null);
+    }
+  }, [client, workspaceId, sessionId, run]);
 
   return {
     goal,
@@ -155,8 +189,10 @@ export function useGoal(sessionId: string | null | undefined, options: UseGoalOp
     refresh: load,
     pause,
     resume,
-    updating: mutation.mutating,
-    mutationError: mutation.mutationError,
-    clearMutationError: mutation.clearMutationError,
+    clearGoal,
+    deleteGoal: clearGoal,
+    updating: mutating,
+    mutationError,
+    clearMutationError,
   };
 }

package/src/hooks/use-machine-chip.ts

@@ -0,0 +1,134 @@
+import { useMemo } from "react";
+import type { MachineState } from "@opengeni/sdk";
+import type { SessionCapabilitiesState } from "./use-session-capabilities";
+
+/** The one truthful machine indicator (dossier §3 #10). Honest staleness beats
+ *  fake liveness: a cold/asleep box reads "offline — as of <time>", never "live". */
+export type MachineChipState = "live" | "waking" | "offline";
+
+export type MachineChip = {
+  state: MachineChipState;
+  /** A ready-to-render label ("Live" / "Waking…" / "Offline — as of 3m ago"). */
+  label: string;
+  /** The capture time backing an offline/stale label (ISO), or null. M4 may
+   *  reformat this; `label` already embeds a relative form. */
+  asOf: string | null;
+};
+
+export type DeriveMachineChipInput = {
+  /** `capabilities.liveness` — "warm" | "draining" | "cold" (or null pre-negotiation). */
+  liveness?: string | null | undefined;
+  /** `useSessionCapabilities().state` — drives the "waking" (negotiating) read. */
+  capabilitiesState?: SessionCapabilitiesState | null | undefined;
+  /** The ACTIVE machine's connection state (from `useMachines`), when known. A
+   *  self-hosted machine that is `offline` cannot be remotely woken. */
+  activeMachineState?: MachineState | null | undefined;
+  /** Whether the active sandbox is a user-owned self-hosted machine (no remote wake). */
+  activeIsSelfhosted?: boolean | undefined;
+  /** An interaction (wake-on-edit, terminal focus) is actively warming the box. */
+  wantsWarm?: boolean | undefined;
+  /** The latest capture's `capturedAt` (ISO) — the "as of <time>" backing. */
+  capturedAt?: string | null | undefined;
+  /** Injectable clock for deterministic relative labels (defaults to Date.now). */
+  now?: number | undefined;
+};
+
+/** Compact relative-time for the "as of" label. Pure, no Intl dependency. */
+export function formatAsOf(capturedAt: string, now: number): string {
+  const then = Date.parse(capturedAt);
+  if (Number.isNaN(then)) return "recently";
+  const seconds = Math.max(0, Math.round((now - then) / 1000));
+  if (seconds < 45) return "just now";
+  const minutes = Math.round(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.round(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.round(hours / 24);
+  return `${days}d ago`;
+}
+
+/**
+ * Derive the machine-state chip from the live capability/liveness surface, the
+ * active machine's connection state, and the latest capture time. PURE (M4 renders
+ * it; the whole point is a deterministic, testable projection).
+ *
+ * Precedence:
+ *   1. warm/draining lease → **live** (a warm box always wins).
+ *   2. actively warming (negotiating, wake-on-edit, or a reconnecting/enrolling
+ *      machine) → **waking**.
+ *   3. everything else (a cold/asleep box, a self-hosted machine that's offline,
+ *      an error) → **offline**, labelled "as of <capture time>".
+ */
+export function deriveMachineChip(input: DeriveMachineChipInput): MachineChip {
+  const now = input.now ?? Date.now();
+  const asOf = input.capturedAt ?? null;
+  const offlineLabel = asOf ? `Offline — as of ${formatAsOf(asOf, now)}` : "Offline";
+
+  // 1. A warm (or draining) lease is live regardless of anything else.
+  if (input.liveness === "warm" || input.liveness === "draining") {
+    return { state: "live", label: "Live", asOf: null };
+  }
+
+  // A self-hosted machine that reports offline cannot be woken remotely — honest
+  // "offline", never "waking" (dossier §3 #5 / #10).
+  const selfhostedOffline =
+    input.activeIsSelfhosted === true && input.activeMachineState === "offline";
+
+  // 2. Actively coming up: negotiation in flight, an edit/terminal is warming, or
+  //    the active machine is (re)connecting. Never when self-hosted is hard-offline.
+  const machineWarming =
+    input.activeMachineState === "reconnecting" || input.activeMachineState === "enrolling";
+  if (
+    !selfhostedOffline &&
+    (input.capabilitiesState === "negotiating" || input.wantsWarm === true || machineWarming)
+  ) {
+    return { state: "waking", label: "Waking…", asOf };
+  }
+
+  // 3. Cold / asleep / offline / error → honest stale label.
+  return { state: "offline", label: offlineLabel, asOf };
+}
+
+export type UseMachineChipOptions = DeriveMachineChipInput;
+
+/**
+ * Thin memoized wrapper over `deriveMachineChip` for the dock header (M4). The
+ * dock already runs `useSessionCapabilities` + `useMachines` + `useWorkspace
+ * capture`; it feeds their `liveness` / `state` / active-machine state /
+ * `capturedAt` here. Pass a periodically-updated `now` if you want the relative
+ * "as of" label to tick.
+ */
+export function useMachineChip(input: UseMachineChipOptions): MachineChip {
+  const {
+    liveness,
+    capabilitiesState,
+    activeMachineState,
+    activeIsSelfhosted,
+    wantsWarm,
+    capturedAt,
+    now,
+  } = input;
+  return useMemo(
+    () =>
+      deriveMachineChip({
+        liveness,
+        capabilitiesState,
+        activeMachineState,
+        activeIsSelfhosted,
+        wantsWarm,
+        capturedAt,
+        now,
+      }),
+    // Depend on the primitive fields (not the object identity) so a caller passing
+    // a fresh object each render doesn't recompute needlessly.
+    [
+      liveness,
+      capabilitiesState,
+      activeMachineState,
+      activeIsSelfhosted,
+      wantsWarm,
+      capturedAt,
+      now,
+    ],
+  );
+}