@opengeni/react 6.5.2-canary.41607687019001 → 6.7.0

package/dist/chunk-2Z3NQNTM.js

@@ -0,0 +1,3670 @@
+"use client";
+import {
+  useSandboxFiles,
+  useUnicodeFallbackFonts
+} from "./chunk-MM4FNWI4.js";
+import {
+  WorkspaceDock
+} from "./chunk-LHPNABDH.js";
+import {
+  SessionMcpCapabilityCard
+} from "./chunk-N6AACDUW.js";
+import {
+  SessionStatus
+} from "./chunk-AXHZYXUV.js";
+import {
+  PierreDiff
+} from "./chunk-NPGISCU6.js";
+import {
+  useThemeType
+} from "./chunk-B27E3V37.js";
+import {
+  useTurnlessOutputGap
+} from "./chunk-DF5EAHDN.js";
+import {
+  invalidateSharedQueries,
+  useSharedQuery
+} from "./chunk-IWUGGOXA.js";
+import {
+  sessionAdmissionBlocked,
+  sessionDisplayStatus
+} from "./chunk-TSENLSW6.js";
+import {
+  connectionStatusForState
+} from "./chunk-6DK6Z4UN.js";
+import {
+  MACHINES_SESSION_POLL_MS,
+  useMachines
+} from "./chunk-2M3J7ZWQ.js";
+import {
+  useMutationRunner,
+  usePageLiveActivity,
+  usePolledValue
+} from "./chunk-RV3O5OCQ.js";
+import {
+  normalizeError
+} from "./chunk-CM7LVUKC.js";
+import {
+  formatRelativeTime
+} from "./chunk-5MOJZORA.js";
+import {
+  SandboxTerminal,
+  terminalCanAcquirePty,
+  xtermThemeFromTokens
+} from "./chunk-UVN5TMHU.js";
+import {
+  sandboxAcceptsLiveIo
+} from "./chunk-QV3DJVRZ.js";
+import {
+  useOpenGeni,
+  useOpenGeniClient
+} from "./chunk-TVQCDDSZ.js";
+import {
+  cn
+} from "./chunk-TXS65BB2.js";
+import {
+  useOpenGeniText
+} from "./chunk-7T2ZE3VT.js";
+
+// src/session-auth-recommendation.ts
+function sessionAuthRecommendation(t, item, catalog) {
+  if (item.authoritySource === "host" || item.reason === "unsupported_auth" || item.reason === "resource_scope_unavailable")
+    return void 0;
+  if (item.capability) return item;
+  const recoveryServerId = item.canonicalServerId ?? item.serverId;
+  const matches = catalog.filter(
+    (candidate) => recoveryServerId !== null && candidate.runtime.mcpServerId === recoveryServerId && recoveryServerId !== "opengeni" || item.connectionId !== null && candidate.connectionRef?.connectionId === item.connectionId
+  );
+  if (matches.length !== 1) return void 0;
+  const entry = matches[0];
+  const personalAccess = item.reason === "personal_authority_unavailable";
+  if (personalAccess && ((item.connectionSubjectScope ?? entry.connectionRef?.subjectScope) !== "subject" || entry.connectionRef?.authoritySource === "host"))
+    return void 0;
+  return {
+    ...item,
+    capability: {
+      id: entry.id,
+      name: entry.name,
+      kind: entry.kind,
+      source: entry.source,
+      action: "connect",
+      rationale: personalAccess ? t("sessionAuthRecommendation.reviewPermissionToUseYour") : t("sessionAuthRecommendation.reconnectThisIntegrationToUse"),
+      requiredVariables: []
+    }
+  };
+}
+
+// src/components/session-connection-request.tsx
+import { useEffect, useRef, useState } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+function SessionConnectionRequest(props) {
+  const [client, setClient] = useState(props.client);
+  const [generation, setGeneration] = useState(0);
+  if (client !== props.client) {
+    setClient(props.client);
+    setGeneration(generation + 1);
+  }
+  return /* @__PURE__ */ jsx(
+    ScopedRequest,
+    {
+      ...props
+    },
+    `${generation}:${props.workspaceId}:${props.sessionId}:${props.request.id}`
+  );
+}
+function ScopedRequest({ request, ...props }) {
+  const t = useOpenGeniText();
+  const [resolved, setResolved] = useState(null);
+  const [error, setError] = useState(null);
+  const [retry, setRetry] = useState(0);
+  const requestRef = useRef(request);
+  requestRef.current = request;
+  useEffect(() => {
+    let current = true;
+    const event = requestRef.current;
+    setResolved(null);
+    setError(null);
+    void props.client.listCapabilities(props.workspaceId).then((catalog) => {
+      if (!current) return;
+      const recommendation = sessionAuthRecommendation(t, event, catalog.items);
+      const candidate = catalog.items.find(
+        (entry) => entry.id === recommendation?.capability?.id
+      );
+      if (!recommendation || candidate?.kind !== "mcp" || candidate.authKind !== "oauth2") {
+        setError(t("sessionConnectionRequest.thisRequestCouldNotBe"));
+        return;
+      }
+      setResolved(recommendation);
+    }).catch(() => {
+      if (current) setError(t("sessionConnectionRequest.couldnTLoadConnectionDetails"));
+    });
+    return () => {
+      current = false;
+    };
+  }, [
+    props.client,
+    props.workspaceId,
+    request.id,
+    request.serverId,
+    request.connectionId,
+    request.authoritySource,
+    request.reason,
+    request.capability?.id,
+    retry,
+    t
+  ]);
+  if (!resolved?.capability)
+    return /* @__PURE__ */ jsxs("div", { className: "og-session-capability-setup", children: [
+      /* @__PURE__ */ jsx("p", { role: error ? "alert" : "status", children: error ?? t("sessionConnectionRequest.loadingConnectionDetails") }),
+      error ? /* @__PURE__ */ jsx("button", { type: "button", onClick: () => setRetry((value) => value + 1), children: t("sessionConnectionRequest.retry") }) : null
+    ] });
+  return /* @__PURE__ */ jsx(
+    SessionMcpCapabilityCard,
+    {
+      ...props,
+      capabilityId: resolved.capability.id,
+      name: resolved.capability.name,
+      rationale: resolved.capability.rationale
+    }
+  );
+}
+
+// src/hooks/use-video-artifact-playback.ts
+import { useMemo } from "react";
+function useVideoArtifactPlaybackLoader(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  return useMemo(
+    () => async (artifactId, signal) => {
+      if (typeof client.createVideoArtifactPlaybackSource !== "function") {
+        throw new Error("This Opengeni host does not expose retained-video playback.");
+      }
+      return await client.createVideoArtifactPlaybackSource(
+        workspaceId,
+        artifactId,
+        signal ? { signal } : {}
+      );
+    },
+    [client, workspaceId]
+  );
+}
+
+// src/hooks/use-scheduled-tasks.ts
+import { useCallback } from "react";
+function useScheduledTasks(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const limit = options.limit;
+  const load = useCallback(
+    async () => await client.listScheduledTasks(workspaceId, limit !== void 0 ? { limit } : {}),
+    [client, workspaceId, limit]
+  );
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled
+  });
+  return {
+    tasks: state.data ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+
+// src/hooks/use-workspace-background-commands.ts
+import { useCallback as useCallback2, useEffect as useEffect2, useRef as useRef2, useState as useState2 } from "react";
+function useWorkspaceBackgroundCommands(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const [pages, setPages] = useState2(1);
+  const enabled = options.enabled ?? true;
+  useEffect2(() => setPages(1), [client, workspaceId]);
+  const load = useCallback2(
+    async (signal) => {
+      if (!client.listWorkspaceBackgroundCommands)
+        throw new Error("The configured client does not support workspace commands");
+      const commands = /* @__PURE__ */ new Map();
+      let cursor;
+      for (let page = 0; page < pages; page += 1) {
+        signal?.throwIfAborted();
+        const result = await client.listWorkspaceBackgroundCommands(workspaceId, {
+          ...cursor ? { cursor } : {},
+          ...signal ? { signal } : {}
+        });
+        for (const command of result.commands) commands.set(command.id, command);
+        cursor = result.nextCursor ?? void 0;
+        if (!cursor) break;
+      }
+      return { commands: [...commands.values()], hasMore: Boolean(cursor) };
+    },
+    [client, workspaceId, pages]
+  );
+  const state = usePolledValue(load, { enabled, pollIntervalMs: options.pollIntervalMs ?? 5e3 });
+  const { data, refresh } = state;
+  const generation = useRef2(0);
+  useEffect2(() => {
+    generation.current += 1;
+    return () => {
+      generation.current += 1;
+    };
+  }, [client, workspaceId, enabled]);
+  const cancel = useCallback2(
+    async (commandId) => {
+      const command = data?.commands.find((item) => item.id === commandId);
+      if (!command || !enabled) return;
+      if (!client.cancelSessionBackgroundCommand)
+        throw new Error("The configured client does not support stopping commands");
+      const ticket = generation.current;
+      await client.cancelSessionBackgroundCommand(workspaceId, command.sessionId, commandId);
+      if (ticket === generation.current) await refresh();
+    },
+    [client, workspaceId, enabled, data, refresh]
+  );
+  return {
+    commands: enabled && !state.error ? state.data?.commands ?? [] : [],
+    loading: enabled && state.loading,
+    error: enabled ? state.error : null,
+    refresh: state.refresh,
+    cancel,
+    hasMore: enabled && !state.error && (state.data?.hasMore ?? false),
+    loadMore: () => setPages((value) => value + 1)
+  };
+}
+
+// src/index.ts
+import { asVaultClient, vaultsApi, vaultErrorCode, vaultErrorDetail } from "@opengeni/sdk";
+
+// src/hooks/use-workspaces.ts
+import { useCallback as useCallback3 } from "react";
+function useWorkspaces(options = {}) {
+  const client = useOpenGeniClient(options);
+  const load = useCallback3(async () => await client.listWorkspaces(), [client]);
+  const { data, loading, error, refresh } = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled
+  });
+  const { run, mutating, mutationError, clearMutationError } = useMutationRunner();
+  const create = useCallback3(
+    async (request) => {
+      const result = await run(() => client.createWorkspace(request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, run, refresh]
+  );
+  const update = useCallback3(
+    async (workspaceId, request) => {
+      const result = await run(() => client.updateWorkspace(workspaceId, request));
+      if (result) {
+        await refresh();
+      }
+      return result;
+    },
+    [client, run, refresh]
+  );
+  return {
+    workspaces: data ?? [],
+    loading,
+    error,
+    refresh,
+    create,
+    update,
+    mutating,
+    mutationError,
+    clearMutationError
+  };
+}
+
+// src/hooks/use-billing-usage.ts
+import { useCallback as useCallback4 } from "react";
+function useBillingUsage(options = {}) {
+  const client = useOpenGeniClient(options);
+  const accountId = options.accountId;
+  const workspaceId = options.workspaceId;
+  const load = useCallback4(
+    async () => await client.getBillingUsage({
+      ...accountId !== void 0 ? { accountId } : {},
+      ...workspaceId !== void 0 ? { workspaceId } : {}
+    }),
+    [client, accountId, workspaceId]
+  );
+  const state = usePolledValue(load, {
+    pollIntervalMs: options.pollIntervalMs,
+    enabled: options.enabled
+  });
+  return {
+    balance: state.data?.balance ?? null,
+    usage: state.data?.usage ?? [],
+    loading: state.loading,
+    error: state.error,
+    refresh: state.refresh
+  };
+}
+
+// src/hooks/use-session-capabilities.ts
+import {
+  OpenGeniApiError,
+  applyUrlRotation
+} from "@opengeni/sdk";
+import { useCallback as useCallback5, useEffect as useEffect3, useRef as useRef3, useState as useState3 } from "react";
+function desktopAttachable(cell) {
+  if (cell.transport !== null) return true;
+  return cell.reason === "lease_cold" || cell.reason === "not_provisioned" || cell.reason === null;
+}
+function rotationsFrom(events) {
+  const out = [];
+  for (const event of events) {
+    if (event.type === "stream.url.rotated" && event.payload && typeof event.payload === "object") {
+      out.push(event.payload);
+    }
+  }
+  return out;
+}
+function useSessionCapabilities(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const pageLive = usePageLiveActivity();
+  const lifecycleEnabled = enabled && pageLive;
+  const attachDesktop = options.attachDesktop ?? false;
+  const attachTerminal = options.attachTerminal ?? false;
+  const attachFiles = options.attachFiles ?? false;
+  const warmingPollMs = options.warmingPollMs ?? 1500;
+  const warmingDeadlineMs = options.warmingDeadlineMs ?? 3e4;
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}\0${enabled}`;
+  const [capabilities, setCapabilities] = useState3(null);
+  const [state, setState] = useState3("idle");
+  const [error, setError] = useState3(null);
+  const [acknowledgmentRequired, setAcknowledgmentRequired] = useState3(null);
+  const [viewerCapReached, setViewerCapReached] = useState3(false);
+  const [viewerId, setViewerId] = useState3(null);
+  const [stateIdentity, setStateIdentity] = useState3(identityKey);
+  const [nonce, setNonce] = useState3(0);
+  const epochRef = useRef3(0);
+  const viewerIdRef = useRef3(null);
+  const previousIdentityRef = useRef3(identityKey);
+  const renegotiate = useCallback5(() => {
+    setNonce((n) => n + 1);
+  }, []);
+  useEffect3(() => {
+    const identityChanged = previousIdentityRef.current !== identityKey;
+    previousIdentityRef.current = identityKey;
+    if (identityChanged) {
+      setStateIdentity(identityKey);
+      setCapabilities(null);
+      setState("idle");
+      setError(null);
+      setAcknowledgmentRequired(null);
+      setViewerCapReached(false);
+      setViewerId(null);
+      epochRef.current = 0;
+      viewerIdRef.current = null;
+    }
+    if (!lifecycleEnabled || !sessionId) {
+      setState("idle");
+      setCapabilities(null);
+      viewerIdRef.current = null;
+      setViewerId(null);
+      return;
+    }
+    viewerIdRef.current = null;
+    setViewerId(null);
+    let cancelled = false;
+    let pollTimer = null;
+    let heartbeatTimer = null;
+    let localViewerId = null;
+    const requestAbort = new AbortController();
+    const startedAt = Date.now();
+    const clearTimers = () => {
+      if (pollTimer !== null) clearTimeout(pollTimer);
+      if (heartbeatTimer !== null) clearTimeout(heartbeatTimer);
+      pollTimer = null;
+      heartbeatTimer = null;
+    };
+    const settle = (caps) => {
+      if (cancelled) return;
+      epochRef.current = caps.leaseEpoch;
+      setCapabilities(caps);
+      setError(null);
+    };
+    const startHeartbeat = (caps) => {
+      if (!localViewerId || heartbeatTimer !== null) return;
+      const intervalMs = caps.viewerHeartbeatIntervalMs > 0 ? caps.viewerHeartbeatIntervalMs : 3e4;
+      const schedule = () => {
+        if (cancelled || !localViewerId) return;
+        heartbeatTimer = setTimeout(() => {
+          heartbeatTimer = null;
+          if (cancelled || !localViewerId) return;
+          void client.heartbeatViewer(workspaceId, sessionId, localViewerId, {
+            leaseEpoch: epochRef.current
+          }).then((res) => {
+            if (!res.alive && !cancelled) {
+              renegotiate();
+            }
+          }).catch((cause) => {
+            if (cancelled) return;
+            if (cause instanceof OpenGeniApiError && (cause.status === 409 || cause.status === 410)) {
+              renegotiate();
+            }
+          }).finally(schedule);
+        }, intervalMs);
+      };
+      schedule();
+    };
+    const pollUntilWarm = () => {
+      pollTimer = setTimeout(() => {
+        if (cancelled) return;
+        void client.getStreamCapabilities(workspaceId, sessionId, { signal: requestAbort.signal }).then((caps) => {
+          if (cancelled) return;
+          settle(caps);
+          if (sandboxAcceptsLiveIo(caps.liveness)) {
+            setState("ready");
+            return;
+          }
+          if (warmingDeadlineMs > 0 && Date.now() - startedAt > warmingDeadlineMs) {
+            setState("error");
+            setError(new Error("sandbox did not warm in time \u2014 retry to re-negotiate"));
+            return;
+          }
+          pollUntilWarm();
+        }).catch((cause) => {
+          if (!cancelled) {
+            if (isSandboxOwnershipDisabledError(cause)) {
+              setState("on-demand");
+              setError(null);
+              return;
+            }
+            setState("error");
+            setError(normalizeError(cause));
+          }
+        });
+      }, warmingPollMs);
+    };
+    void (async () => {
+      setState("negotiating");
+      setAcknowledgmentRequired(null);
+      setViewerCapReached(false);
+      try {
+        const caps = await client.getStreamCapabilities(workspaceId, sessionId, {
+          signal: requestAbort.signal
+        });
+        if (cancelled) return;
+        settle(caps);
+        const wantDesktopAttach = attachDesktop && desktopAttachable(caps.DesktopStream);
+        const wantTerminalAttach = attachTerminal && terminalCanAcquirePty(caps.Terminal);
+        const wantFilesAttach = attachFiles && caps.FileSystem.available;
+        if (wantDesktopAttach || wantTerminalAttach || wantFilesAttach) {
+          try {
+            const holder = await client.attachViewer(workspaceId, sessionId, {
+              desktop: wantDesktopAttach,
+              terminal: wantTerminalAttach,
+              files: wantFilesAttach
+            });
+            if (cancelled) {
+              void client.detachViewer(workspaceId, sessionId, holder.viewerId).catch(() => {
+              });
+              return;
+            }
+            if (wantDesktopAttach && (!holder.dataPlaneUrl || !holder.transport || !holder.client) || wantTerminalAttach && (!holder.terminalUrl || !holder.terminalTransport)) {
+              await client.detachViewer(workspaceId, sessionId, holder.viewerId).catch(() => {
+              });
+              throw new Error("live plane unavailable");
+            }
+            localViewerId = holder.viewerId;
+            viewerIdRef.current = holder.viewerId;
+            setViewerId(holder.viewerId);
+            epochRef.current = holder.leaseEpoch;
+            setCapabilities(
+              (prev) => prev ? {
+                ...prev,
+                liveness: holder.liveness,
+                leaseEpoch: holder.leaseEpoch,
+                viewerHeartbeatIntervalMs: holder.viewerHeartbeatIntervalMs,
+                DesktopStream: wantDesktopAttach ? {
+                  ...prev.DesktopStream,
+                  transport: holder.transport ?? prev.DesktopStream.transport,
+                  client: holder.client ?? prev.DesktopStream.client,
+                  url: holder.dataPlaneUrl,
+                  token: holder.streamToken,
+                  expiresAt: holder.streamExpiresAt,
+                  resolution: holder.resolution ?? prev.DesktopStream.resolution
+                } : prev.DesktopStream,
+                Terminal: wantTerminalAttach ? {
+                  ...prev.Terminal,
+                  transport: holder.terminalTransport ?? prev.Terminal.transport,
+                  url: holder.terminalUrl,
+                  token: holder.terminalToken,
+                  expiresAt: holder.terminalExpiresAt,
+                  // A live pty-ws means the box is pty-capable for real.
+                  ptyCapable: holder.terminalTransport ? true : prev.Terminal.ptyCapable,
+                  reason: holder.terminalTransport ? null : prev.Terminal.reason
+                } : prev.Terminal
+              } : prev
+            );
+          } catch (cause) {
+            if (cancelled) return;
+            if (cause instanceof OpenGeniApiError) {
+              if (cause.status === 409) {
+                if (wantDesktopAttach) {
+                  setAcknowledgmentRequired(
+                    cause.message.includes("shared_acknowledgment") ? "shared" : "unredacted"
+                  );
+                }
+              } else if (cause.status === 429) {
+                setViewerCapReached(true);
+              } else if (cause.status === 403) {
+                setState("error");
+                setError(cause);
+                return;
+              } else {
+                throw cause;
+              }
+            } else {
+              throw cause;
+            }
+          }
+        }
+        const warmUpRequested = wantDesktopAttach || wantTerminalAttach || wantFilesAttach;
+        if (sandboxAcceptsLiveIo(caps.liveness) || localViewerId) {
+          setState("ready");
+          startHeartbeat(caps);
+        } else if (warmUpRequested) {
+          setState("cold");
+          pollUntilWarm();
+        } else {
+          setState("on-demand");
+        }
+      } catch (cause) {
+        if (cancelled) return;
+        if (isSandboxOwnershipDisabledError(cause)) {
+          setState("on-demand");
+          setError(null);
+          return;
+        }
+        if (cause instanceof OpenGeniApiError && cause.status === 403) {
+          setState("error");
+          setError(new Error("not permitted to view this session's sandbox"));
+          return;
+        }
+        setState("error");
+        setError(normalizeError(cause));
+      }
+    })();
+    return () => {
+      cancelled = true;
+      requestAbort.abort();
+      clearTimers();
+      const releaseId = localViewerId ?? viewerIdRef.current;
+      if (releaseId) {
+        void client.detachViewer(workspaceId, sessionId, releaseId).catch(() => {
+        });
+      }
+    };
+  }, [
+    client,
+    workspaceId,
+    sessionId,
+    lifecycleEnabled,
+    attachDesktop,
+    attachTerminal,
+    attachFiles,
+    warmingPollMs,
+    warmingDeadlineMs,
+    nonce,
+    identityKey
+  ]);
+  const events = options.events;
+  useEffect3(() => {
+    if (!events || events.length === 0) return;
+    setCapabilities((prev) => {
+      if (!prev || !prev.DesktopStream.url) return prev;
+      let next = prev.DesktopStream;
+      let changed = false;
+      for (const rotation of rotationsFrom(events)) {
+        if (rotation.viewerId && viewerIdRef.current && rotation.viewerId !== viewerIdRef.current) {
+          continue;
+        }
+        const applied = applyUrlRotation(next, rotation, epochRef.current);
+        if (applied) {
+          next = { ...next, url: applied.url, token: applied.token, expiresAt: applied.expiresAt };
+          epochRef.current = Math.max(epochRef.current, rotation.leaseEpoch);
+          changed = true;
+        }
+      }
+      return changed ? { ...prev, DesktopStream: next, leaseEpoch: epochRef.current } : prev;
+    });
+  }, [events]);
+  const identityMatches = enabled && stateIdentity === identityKey;
+  return {
+    capabilities: identityMatches ? capabilities : null,
+    state: identityMatches ? state : "idle",
+    error: identityMatches ? error : null,
+    acknowledgmentRequired: identityMatches ? acknowledgmentRequired : null,
+    viewerCapReached: identityMatches && viewerCapReached,
+    viewerId: identityMatches ? viewerId : null,
+    renegotiate
+  };
+}
+function isSandboxOwnershipDisabledError(error) {
+  return error instanceof OpenGeniApiError && error.status === 404 && error.message.includes("sandbox ownership is not enabled");
+}
+
+// src/hooks/use-sandbox-terminal.ts
+import { OpenGeniApiError as OpenGeniApiError2 } from "@opengeni/sdk";
+import { useCallback as useCallback6, useEffect as useEffect4, useMemo as useMemo2, useRef as useRef4, useState as useState4 } from "react";
+var SANDBOX_TERMINAL_HISTORY_ROWS = 1e3;
+var SANDBOX_TERMINAL_MAX_ROWS = 4e3;
+function useSandboxTerminal(sessionId, options) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const includeAgentFirehose = options.includeAgentFirehose ?? true;
+  const interactive = options.interactive ?? false;
+  const ptyFilter = options.ptyId;
+  const liveness = options.liveness;
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}\0${interactive}\0${ptyFilter ?? ""}`;
+  const [openedPtyId, setOpenedPtyId] = useState4(null);
+  const [openError, setOpenError] = useState4(null);
+  const [stateIdentity, setStateIdentity] = useState4(identityKey);
+  const [reopenNonce, setReopenNonce] = useState4(0);
+  const currentIdentityRef = useRef4(identityKey);
+  currentIdentityRef.current = identityKey;
+  useEffect4(() => {
+    setStateIdentity(identityKey);
+    setOpenedPtyId(null);
+    setOpenError(null);
+  }, [identityKey]);
+  const openInFlight = useRef4(false);
+  const boxWarm = liveness === void 0 || sandboxAcceptsLiveIo(liveness);
+  useEffect4(() => {
+    if (!interactive || !sessionId || ptyFilter || !boxWarm) {
+      setOpenError(null);
+      return;
+    }
+    let cancelled = false;
+    setOpenError(null);
+    openInFlight.current = true;
+    let openedId = null;
+    void client.terminalPtyOpen(workspaceId, sessionId, {}).then((res) => {
+      if (cancelled) {
+        void client.terminalPtyClose(workspaceId, sessionId, { ptyId: res.ptyId }).catch(() => {
+        });
+        return;
+      }
+      openedId = res.ptyId;
+      setOpenedPtyId(res.ptyId);
+    }).catch((cause) => {
+      if (!cancelled) setOpenError(cause instanceof Error ? cause : new Error(String(cause)));
+    }).finally(() => {
+      openInFlight.current = false;
+    });
+    return () => {
+      cancelled = true;
+      setOpenedPtyId(null);
+      const id = openedId;
+      if (id) void client.terminalPtyClose(workspaceId, sessionId, { ptyId: id }).catch(() => {
+      });
+    };
+  }, [interactive, client, workspaceId, sessionId, ptyFilter, boxWarm, reopenNonce]);
+  const outputTypes = useMemo2(
+    () => includeAgentFirehose && !ptyFilter ? ["terminal.pty.output.delta", "sandbox.command.output.delta"] : ["terminal.pty.output.delta"],
+    [includeAgentFirehose, ptyFilter]
+  );
+  const historyKey = `${workspaceId}\0${sessionId ?? ""}\0${outputTypes.join(",")}`;
+  const historyEnabled = (options.history ?? true) && Boolean(sessionId);
+  const gapGeneration = useTurnlessOutputGap(workspaceId, sessionId);
+  const [history, setHistory] = useState4(null);
+  const [historyTick, setHistoryTick] = useState4(0);
+  const readRef = useRef4(historyReadState(historyKey));
+  const mountedRef = useRef4(false);
+  useEffect4(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      const state = readRef.current;
+      if (state.timer) clearTimeout(state.timer);
+      state.timer = null;
+    };
+  }, []);
+  useEffect4(() => {
+    let state = readRef.current;
+    if (state.key !== historyKey) {
+      if (state.timer) clearTimeout(state.timer);
+      state = historyReadState(historyKey);
+      readRef.current = state;
+      setHistory(null);
+    }
+    if (!historyEnabled || !sessionId || state.inFlight || state.timer) return;
+    if (!state.failed && state.generation === gapGeneration) return;
+    const now = Date.now();
+    const wait = state.failed ? terminalHistoryRetryDelay(state.failures) - (now - state.startedAt) : state.generation === null ? 0 : SANDBOX_TERMINAL_REREAD_MIN_MS - (now - state.startedAt);
+    if (wait > 0) {
+      state.timer = setTimeout(() => {
+        state.timer = null;
+        if (mountedRef.current) setHistoryTick((tick) => tick + 1);
+      }, wait);
+      return;
+    }
+    const generation = gapGeneration;
+    state.inFlight = true;
+    state.startedAt = now;
+    const current = () => mountedRef.current && readRef.current === state;
+    void readTerminalHistory(client, workspaceId, sessionId, outputTypes).then(
+      (page) => {
+        state.inFlight = false;
+        if (!current()) return;
+        state.failed = false;
+        state.failures = 0;
+        state.generation = generation;
+        setHistory({ key: state.key, events: page.events, complete: page.complete });
+        setHistoryTick((tick) => tick + 1);
+      },
+      (cause) => {
+        state.inFlight = false;
+        if (!current()) return;
+        if (cause instanceof OpenGeniApiError2 && cause.status >= 400 && cause.status < 500 && cause.status !== 408 && cause.status !== 429) {
+          state.failed = false;
+          state.failures = 0;
+          state.generation = generation;
+          return;
+        }
+        state.failed = true;
+        state.failures += 1;
+        setHistoryTick((tick) => tick + 1);
+      }
+    );
+  }, [
+    historyEnabled,
+    historyKey,
+    gapGeneration,
+    historyTick,
+    outputTypes,
+    client,
+    workspaceId,
+    sessionId
+  ]);
+  const liveRef = useRef4({ key: historyKey, rows: /* @__PURE__ */ new Map(), below: 0 });
+  const { chunks, openPty, supportsInput } = useMemo2(() => {
+    const open = /* @__PURE__ */ new Map();
+    let lastOpened = null;
+    let lastSupportsInput = false;
+    if (liveRef.current.key !== historyKey) {
+      liveRef.current = { key: historyKey, rows: /* @__PURE__ */ new Map(), below: 0 };
+    }
+    const liveRows = liveRef.current;
+    const live = liveRows.rows;
+    const types = new Set(outputTypes);
+    for (const event of options.events) {
+      if (event.workspaceId !== workspaceId || event.sessionId !== sessionId) continue;
+      if (event.type === "terminal.pty.started") {
+        const payload = event.payload;
+        if (payload?.ptyId) {
+          open.set(payload.ptyId, { supportsInput: true });
+          lastOpened = payload.ptyId;
+        }
+        continue;
+      }
+      if (event.type === "terminal.pty.exited") {
+        const payload = event.payload;
+        if (payload?.ptyId) {
+          open.delete(payload.ptyId);
+          if (lastOpened === payload.ptyId) lastOpened = null;
+        }
+        continue;
+      }
+      if (types.has(event.type) && event.sequence >= liveRows.below && !live.has(event.id)) {
+        live.set(event.id, event);
+      }
+    }
+    trimLiveRows(liveRows);
+    const loaded = history?.key === historyKey ? history : null;
+    const floor = loaded && !loaded.complete ? loaded.events[0]?.sequence ?? 0 : 0;
+    const seen = /* @__PURE__ */ new Set();
+    const out = [];
+    const add = (event) => {
+      if (seen.has(event.id) || event.sequence < floor) return;
+      seen.add(event.id);
+      const chunk = terminalChunk(event, ptyFilter);
+      if (chunk) out.push(chunk);
+    };
+    loaded?.events.forEach(add);
+    live.forEach(add);
+    out.sort((a, b) => a.seq - b.seq);
+    const activePty = ptyFilter && open.has(ptyFilter) ? ptyFilter : lastOpened;
+    lastSupportsInput = activePty ? open.get(activePty)?.supportsInput ?? false : false;
+    return {
+      chunks: out.length > SANDBOX_TERMINAL_MAX_ROWS ? out.slice(-SANDBOX_TERMINAL_MAX_ROWS) : out,
+      openPty: activePty,
+      supportsInput: lastSupportsInput
+    };
+  }, [options.events, history, historyKey, outputTypes, ptyFilter, workspaceId, sessionId]);
+  const identityMatches = stateIdentity === identityKey;
+  const activePtyId = identityMatches ? openedPtyId ?? openPty : null;
+  const canWrite = openedPtyId !== null || supportsInput;
+  const write = useMemo2(() => {
+    if (!activePtyId || !canWrite || !sessionId) return null;
+    const writeIdentity = identityKey;
+    return (data) => {
+      void client.terminalPtyWrite(workspaceId, sessionId, { ptyId: activePtyId, data }).catch((cause) => {
+        if (cause instanceof OpenGeniApiError2 && (cause.status === 409 || cause.status === 404) && activePtyId === openedPtyId && currentIdentityRef.current === writeIdentity) {
+          setOpenedPtyId(null);
+          setReopenNonce((n) => n + 1);
+        }
+      });
+    };
+  }, [client, workspaceId, sessionId, activePtyId, canWrite, openedPtyId, identityKey]);
+  const close = useCallback6(() => {
+    if (!activePtyId || !sessionId) return;
+    void client.terminalPtyClose(workspaceId, sessionId, { ptyId: activePtyId }).catch(() => {
+    });
+  }, [client, workspaceId, sessionId, activePtyId]);
+  return {
+    chunks,
+    running: activePtyId !== null,
+    write,
+    activePtyId,
+    close,
+    error: identityMatches ? openError : null
+  };
+}
+function trimLiveRows(live) {
+  const { rows } = live;
+  if (rows.size <= SANDBOX_TERMINAL_MAX_ROWS + SANDBOX_TERMINAL_MAX_ROWS / 4) return;
+  const sorted = [...rows.values()].sort((left, right) => left.sequence - right.sequence);
+  const drop = sorted.length - SANDBOX_TERMINAL_MAX_ROWS;
+  for (const event of sorted.slice(0, drop)) rows.delete(event.id);
+  live.below = Math.max(live.below, sorted[drop].sequence);
+}
+function historyReadState(key) {
+  return {
+    key,
+    generation: null,
+    inFlight: false,
+    failed: false,
+    failures: 0,
+    startedAt: 0,
+    timer: null
+  };
+}
+var SANDBOX_TERMINAL_REREAD_MIN_MS = 1e3;
+function terminalHistoryRetryDelay(failures) {
+  return Math.min(3e4, 1e3 * 2 ** Math.max(0, failures - 1));
+}
+function terminalChunk(event, ptyFilter) {
+  if (event.type === "terminal.pty.output.delta") {
+    const payload = event.payload;
+    if (!payload || typeof payload.chunk !== "string") return null;
+    if (ptyFilter && payload.ptyId !== ptyFilter) return null;
+    return {
+      id: event.id,
+      text: payload.chunk,
+      stream: payload.stream === "stderr" ? "stderr" : "stdout",
+      seq: event.sequence
+    };
+  }
+  if (event.type === "sandbox.command.output.delta" && !ptyFilter) {
+    const payload = event.payload;
+    if (!payload?.chunk) return null;
+    return {
+      id: event.id,
+      text: payload.chunk,
+      stream: payload.stream === "stderr" ? "stderr" : "stdout",
+      seq: event.sequence
+    };
+  }
+  return null;
+}
+async function readTerminalHistory(client, workspaceId, sessionId, includeTypes) {
+  const options = {
+    includeTypes,
+    direction: "before",
+    // Explicit: a cursorless read otherwise defaults to the monitoring tail,
+    // which drops raw output deltas.
+    mode: "forensic",
+    payloadMode: "full",
+    limit: SANDBOX_TERMINAL_HISTORY_ROWS
+  };
+  const pageClient = client;
+  const page = typeof pageClient.listEventPage === "function" ? await pageClient.listEventPage(workspaceId, sessionId, options) : null;
+  const events = page ? page.events : await client.listEvents(workspaceId, sessionId, options);
+  const sorted = [...events].sort((left, right) => left.sequence - right.sequence);
+  return {
+    events: sorted,
+    // Without a continuation fact, only an empty read is known complete: the
+    // server's byte bound can cut a page short of the row limit.
+    complete: page ? !page.hasMore : sorted.length === 0
+  };
+}
+
+// src/hooks/use-sandbox-git.ts
+import { useCallback as useCallback7, useEffect as useEffect5, useMemo as useMemo3, useRef as useRef5, useState as useState5 } from "react";
+function normalizeRoot(root) {
+  const normalized = root.replaceAll("\\", "/").replace(/^\.\/+/, "").replace(/\/+$/, "");
+  return normalized === "." ? "" : normalized;
+}
+function qualifyPath(repoRoot, path) {
+  const root = normalizeRoot(repoRoot);
+  return root ? `${root}/${path}` : path;
+}
+function qualifyDiff(repoRoot, file) {
+  const root = normalizeRoot(repoRoot);
+  return {
+    ...file,
+    path: qualifyPath(root, file.path),
+    oldPath: file.oldPath === null ? null : qualifyPath(root, file.oldPath),
+    repoRoot: root
+  };
+}
+function uniqueRoots(roots) {
+  return [...new Set(roots.map(normalizeRoot))].sort((a, b) => a.localeCompare(b));
+}
+var GIT_READ_BATCH_REQUEST_LIMIT = 32;
+function repoForPath(manifest, repoPath) {
+  const want = normalizeRoot(repoPath);
+  const exact = manifest.repos.find((r) => normalizeRoot(r.root) === want);
+  if (exact) return exact;
+  if (want === "" && manifest.repos.length === 1) return manifest.repos[0] ?? null;
+  return null;
+}
+function sameFileDiff(a, b) {
+  if (a.path !== b.path || a.oldPath !== b.oldPath || a.repoRoot !== b.repoRoot || a.status !== b.status || a.isBinary !== b.isBinary || a.isImage !== b.isImage || a.additions !== b.additions || a.deletions !== b.deletions || a.truncated !== b.truncated || a.hunks.length !== b.hunks.length)
+    return false;
+  return a.hunks.every((hunk, hunkIndex) => {
+    const other = b.hunks[hunkIndex];
+    if (!other || hunk.oldStart !== other.oldStart || hunk.oldLines !== other.oldLines || hunk.newStart !== other.newStart || hunk.newLines !== other.newLines || hunk.header !== other.header || hunk.lines.length !== other.lines.length)
+      return false;
+    return hunk.lines.every((line, lineIndex) => {
+      const otherLine = other.lines[lineIndex];
+      return otherLine !== void 0 && line.type === otherLine.type && line.oldNo === otherLine.oldNo && line.newNo === otherLine.newNo && line.text === otherLine.text;
+    });
+  });
+}
+function mergeDiffs(current, next) {
+  if (current.length === 0) return next;
+  const byPath = new Map(current.map((d) => [d.path, d]));
+  let changed = current.length !== next.length;
+  const merged = next.map((file, index) => {
+    const existing = byPath.get(file.path);
+    if (existing && sameFileDiff(existing, file)) {
+      if (current[index] !== existing) changed = true;
+      return existing;
+    }
+    changed = true;
+    return file;
+  });
+  return changed ? merged : current;
+}
+function useSandboxGit(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const active = options.active ?? true;
+  const repoPath = options.repoPath ?? "";
+  const workspaceWide = options.repoPaths !== void 0;
+  const repoPathsKey = uniqueRoots(
+    options.repoPaths && options.repoPaths.length > 0 ? options.repoPaths : [repoPath]
+  ).join("\0");
+  const repoPaths = useMemo3(() => repoPathsKey.split("\0"), [repoPathsKey]);
+  const comparison = options.comparison ?? (options.staged ? "staged" : "working");
+  const hasAdvertisedRepoPaths = (options.repoPaths?.length ?? 0) > 0;
+  const capture = comparison === "staged" ? null : options.capture ?? null;
+  const isLive2 = sandboxAcceptsLiveIo(options.liveness);
+  const acceptsEventReads = options.liveness === void 0 || isLive2;
+  const acceptsEventReadsRef = useRef5(acceptsEventReads);
+  acceptsEventReadsRef.current = acceptsEventReads;
+  const hasLiveIoFence = options.liveness !== void 0;
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}\0${repoPathsKey}\0${workspaceWide}\0${comparison}`;
+  const [diff, setDiff] = useState5([]);
+  const [branch, setBranch] = useState5(null);
+  const [isRepo, setIsRepo] = useState5(false);
+  const [ahead, setAhead] = useState5(0);
+  const [behind, setBehind] = useState5(0);
+  const [repoRoots, setRepoRoots] = useState5([]);
+  const [source, setSource] = useState5(null);
+  const sourceRef = useRef5(null);
+  const [loading, setLoading] = useState5(false);
+  const [error, setError] = useState5(null);
+  const [stateIdentity, setStateIdentity] = useState5(identityKey);
+  const refreshGenerationRef = useRef5(0);
+  const refreshAbortRef = useRef5(null);
+  const refreshInFlightRef = useRef5(null);
+  const refreshPendingRef = useRef5(false);
+  const refreshWorkerEpochRef = useRef5(0);
+  const lastChangeRef = useRef5(0);
+  const eventRefreshTimerRef = useRef5(null);
+  const performRefresh = useCallback7(async () => {
+    if (!sessionId) return;
+    const refreshAbort = new AbortController();
+    refreshAbortRef.current = refreshAbort;
+    const generation = refreshGenerationRef.current += 1;
+    setLoading(true);
+    setError(null);
+    try {
+      const diffRequest = (root) => client.gitDiff(
+        workspaceId,
+        sessionId,
+        {
+          path: root,
+          ...comparison === "branch" ? { fromRef: "origin/HEAD", includeUntracked: true } : comparison === "working" ? { fromRef: "HEAD", includeUntracked: true } : { staged: true, includeUntracked: false }
+        },
+        { signal: refreshAbort.signal }
+      );
+      const prefetched = hasAdvertisedRepoPaths ? await (async () => {
+        const prefetchedRepos = [];
+        for (let offset = 0; offset < repoPaths.length; offset += GIT_READ_BATCH_REQUEST_LIMIT) {
+          const roots2 = repoPaths.slice(offset, offset + GIT_READ_BATCH_REQUEST_LIMIT);
+          const batch = await client.gitReadBatch(
+            workspaceId,
+            sessionId,
+            {
+              requests: roots2.map((root) => ({
+                status: { path: root },
+                diff: {
+                  path: root,
+                  ...comparison === "branch" ? { fromRef: "origin/HEAD", includeUntracked: true } : comparison === "working" ? { fromRef: "HEAD", includeUntracked: true } : { staged: true, includeUntracked: false }
+                }
+              }))
+            },
+            { signal: refreshAbort.signal }
+          );
+          if (batch.results.length !== roots2.length) {
+            throw new Error(
+              `Workspace Git batch returned ${batch.results.length} results for ${roots2.length} repositories.`
+            );
+          }
+          batch.results.forEach((item, index) => {
+            prefetchedRepos.push({
+              root: roots2[index],
+              status: item.status,
+              result: item.diff ?? {
+                files: [],
+                revision: item.status.revision
+              }
+            });
+          });
+        }
+        return prefetchedRepos;
+      })() : null;
+      const statuses = prefetched ?? await Promise.all(
+        repoPaths.map(async (root) => ({
+          root,
+          status: await client.gitStatus(
+            workspaceId,
+            sessionId,
+            { path: root },
+            { signal: refreshAbort.signal }
+          )
+        }))
+      );
+      if (refreshGenerationRef.current !== generation) return;
+      const repositories = statuses.filter(({ status }) => status.isRepo);
+      const roots = repositories.map(({ root }) => root);
+      setRepoRoots(roots);
+      setIsRepo(repositories.length > 0);
+      setBranch(repositories.length === 1 ? repositories[0]?.status.head ?? null : null);
+      setAhead(repositories.reduce((sum, { status }) => sum + status.ahead, 0));
+      setBehind(repositories.reduce((sum, { status }) => sum + status.behind, 0));
+      if (repositories.length === 0) {
+        setDiff([]);
+        sourceRef.current = "live";
+        setSource("live");
+        return;
+      }
+      const prefetchedByRoot = new Map(prefetched?.map(({ root, result }) => [root, result]));
+      const results = await Promise.all(
+        repositories.map(async ({ root }) => ({
+          root,
+          result: prefetchedByRoot.get(root) ?? await diffRequest(root)
+        }))
+      );
+      if (refreshGenerationRef.current !== generation) return;
+      setDiff(
+        (prev) => mergeDiffs(
+          prev,
+          results.flatMap(
+            ({ root, result }) => workspaceWide ? result.files.map((file) => qualifyDiff(root, file)) : result.files
+          )
+        )
+      );
+      sourceRef.current = "live";
+      setSource("live");
+    } catch (cause) {
+      if (refreshGenerationRef.current !== generation) return;
+      setError(cause instanceof Error ? cause : new Error(String(cause)));
+    } finally {
+      if (refreshGenerationRef.current === generation) setLoading(false);
+      if (refreshAbortRef.current === refreshAbort) refreshAbortRef.current = null;
+    }
+  }, [
+    client,
+    workspaceId,
+    sessionId,
+    repoPaths,
+    hasAdvertisedRepoPaths,
+    workspaceWide,
+    comparison
+  ]);
+  const performRefreshRef = useRef5(performRefresh);
+  performRefreshRef.current = performRefresh;
+  const refresh = useCallback7(async () => {
+    refreshPendingRef.current = true;
+    const existing = refreshInFlightRef.current;
+    if (existing) return await existing;
+    const workerEpoch = refreshWorkerEpochRef.current;
+    const run = (async () => {
+      while (refreshPendingRef.current && refreshWorkerEpochRef.current === workerEpoch) {
+        refreshPendingRef.current = false;
+        await performRefreshRef.current();
+      }
+    })();
+    refreshInFlightRef.current = run;
+    try {
+      await run;
+    } finally {
+      if (refreshInFlightRef.current === run) refreshInFlightRef.current = null;
+    }
+  }, []);
+  const seedFromCapture = useCallback7(
+    (manifest) => {
+      const repositories = workspaceWide ? manifest.repos : [repoForPath(manifest, repoPath)].filter(Boolean);
+      if (comparison === "branch" && repositories.some((repo) => repo.branchDiff === void 0)) {
+        return;
+      }
+      if (repositories.length === 0) {
+        setIsRepo(false);
+        setBranch(null);
+        setAhead(0);
+        setBehind(0);
+        setRepoRoots([]);
+        setDiff((prev) => prev.length === 0 ? prev : []);
+        sourceRef.current = "capture";
+        setSource("capture");
+        return;
+      }
+      setIsRepo(true);
+      setBranch(repositories.length === 1 ? repositories[0]?.head ?? null : null);
+      setAhead(repositories.reduce((sum, repo) => sum + repo.ahead, 0));
+      setBehind(repositories.reduce((sum, repo) => sum + repo.behind, 0));
+      setRepoRoots(repositories.map((repo) => normalizeRoot(repo.root)));
+      setDiff(
+        (prev) => mergeDiffs(
+          prev,
+          repositories.flatMap((repo) => {
+            const capturedDiff = comparison === "branch" ? repo.branchDiff ?? [] : repo.diff;
+            return workspaceWide ? capturedDiff.map((file) => qualifyDiff(repo.root, file)) : capturedDiff;
+          })
+        )
+      );
+      sourceRef.current = "capture";
+      setSource("capture");
+      setError(null);
+    },
+    [comparison, repoPath, workspaceWide]
+  );
+  const captureRef = useRef5(capture);
+  captureRef.current = capture;
+  const captureRevision = capture?.revision ?? null;
+  const previousIdentityRef = useRef5(identityKey);
+  useEffect5(() => {
+    refreshAbortRef.current?.abort();
+    refreshAbortRef.current = null;
+    refreshPendingRef.current = false;
+    refreshGenerationRef.current += 1;
+    const identityChanged = previousIdentityRef.current !== identityKey;
+    previousIdentityRef.current = identityKey;
+    if (identityChanged) {
+      refreshWorkerEpochRef.current += 1;
+      refreshInFlightRef.current = null;
+    }
+    if (identityChanged || !enabled) {
+      lastChangeRef.current = 0;
+      setDiff([]);
+      setStateIdentity(identityKey);
+      setIsRepo(false);
+      setBranch(null);
+      setAhead(0);
+      setBehind(0);
+      setRepoRoots([]);
+      sourceRef.current = null;
+      setSource(null);
+      setLoading(false);
+      setError(null);
+    }
+    if (!enabled) {
+      return;
+    }
+    const currentCapture = captureRevision !== null ? captureRef.current : null;
+    if (currentCapture && (identityChanged || !isLive2 || sourceRef.current !== "live")) {
+      seedFromCapture(currentCapture);
+    }
+    if (!active) {
+      if (!active) setLoading(false);
+      return;
+    }
+    if (isLive2 || !hasLiveIoFence && !currentCapture) {
+      void refresh();
+    }
+    return () => {
+      refreshAbortRef.current?.abort();
+      refreshAbortRef.current = null;
+      refreshPendingRef.current = false;
+      refreshGenerationRef.current += 1;
+    };
+  }, [
+    enabled,
+    active,
+    isLive2,
+    hasLiveIoFence,
+    captureRevision,
+    identityKey,
+    refresh,
+    seedFromCapture
+  ]);
+  const events = options.events;
+  useEffect5(() => {
+    if (!enabled || !events) {
+      if (eventRefreshTimerRef.current) {
+        clearTimeout(eventRefreshTimerRef.current);
+        eventRefreshTimerRef.current = null;
+      }
+      return;
+    }
+    if (!active || !acceptsEventReads) {
+      for (const event of events) {
+        if (event.sequence > lastChangeRef.current) lastChangeRef.current = event.sequence;
+      }
+      if (eventRefreshTimerRef.current) {
+        clearTimeout(eventRefreshTimerRef.current);
+        eventRefreshTimerRef.current = null;
+      }
+      return;
+    }
+    let latest = lastChangeRef.current;
+    let changed = false;
+    for (const event of events) {
+      if (event.sequence <= latest) continue;
+      if (event.type === "git.changed") {
+        latest = event.sequence;
+        changed = true;
+      }
+    }
+    if (latest > lastChangeRef.current) {
+      lastChangeRef.current = latest;
+      if (!changed) return;
+      if (eventRefreshTimerRef.current) clearTimeout(eventRefreshTimerRef.current);
+      eventRefreshTimerRef.current = setTimeout(() => {
+        eventRefreshTimerRef.current = null;
+        if (acceptsEventReadsRef.current) void refresh();
+      }, 150);
+    }
+  }, [enabled, active, acceptsEventReads, events, refresh]);
+  useEffect5(
+    () => () => {
+      if (eventRefreshTimerRef.current) clearTimeout(eventRefreshTimerRef.current);
+    },
+    []
+  );
+  const identityMatches = enabled && stateIdentity === identityKey;
+  const visibleRepoRoots = identityMatches ? repoRoots : [];
+  return {
+    diff: identityMatches ? diff : [],
+    branch: identityMatches ? branch : null,
+    isRepo: identityMatches && isRepo,
+    ahead: identityMatches ? ahead : 0,
+    behind: identityMatches ? behind : 0,
+    repoCount: visibleRepoRoots.length,
+    repoRoots: visibleRepoRoots,
+    refresh,
+    source: identityMatches ? source : null,
+    capturedAt: identityMatches && source === "capture" ? capture?.capturedAt ?? null : null,
+    loading: identityMatches && loading,
+    error: identityMatches ? error : null
+  };
+}
+
+// src/hooks/use-workspace-capture.ts
+import { useCallback as useCallback8, useEffect as useEffect6, useRef as useRef6, useState as useState6 } from "react";
+import { isRecord } from "@opengeni/contracts/values";
+var REVISION_CAPTURED = "workspace.revision.captured";
+var REVISION_DEGRADED = "workspace.revision.degraded";
+var MANIFEST_FETCH_TIMEOUT_MS = 15e3;
+var CAPTURE_STATS_NUMBER_FIELDS = [
+  "repoCount",
+  "fileCount",
+  "additions",
+  "deletions",
+  "totalBytes",
+  "tooLargeCount",
+  "binaryCount",
+  "treeEntryCount",
+  "durationMs"
+];
+function captureManifestForResponse(value, response) {
+  if (!isRecord(value) || value.version !== 1 || !Number.isSafeInteger(value.revision) || typeof value.capturedAt !== "string" || !(value.turnId === null || typeof value.turnId === "string") || !Number.isSafeInteger(value.leaseEpoch) || !isRecord(value.treeIndex) || typeof value.treeTruncated !== "boolean" || !Array.isArray(value.repos) || !Array.isArray(value.files) || !isRecord(value.stats)) {
+    throw new Error("Workspace capture manifest failed validation.");
+  }
+  if (value.revision !== response.revision || value.capturedAt !== response.capturedAt || value.turnId !== response.turnId || value.leaseEpoch !== response.leaseEpoch) {
+    throw new Error("Workspace capture manifest identity did not match its response.");
+  }
+  for (const field of CAPTURE_STATS_NUMBER_FIELDS) {
+    if (!Number.isSafeInteger(value.stats[field]) || value.stats[field] !== response.stats[field]) {
+      throw new Error("Workspace capture manifest statistics did not match its response.");
+    }
+  }
+  if (typeof value.stats.treeTruncated !== "boolean" || value.stats.treeTruncated !== response.stats.treeTruncated || (value.stats.fingerprint ?? null) !== (response.stats.fingerprint ?? null) || value.repos.length !== response.stats.repoCount || value.files.length !== response.stats.fileCount || value.treeTruncated !== response.stats.treeTruncated) {
+    throw new Error("Workspace capture manifest statistics did not match its response.");
+  }
+  return value;
+}
+function useWorkspaceCapture(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}`;
+  const [capture, setCapture] = useState6(null);
+  const [available, setAvailable] = useState6(false);
+  const [degradedReason, setDegradedReason] = useState6(null);
+  const [fileCount, setFileCount] = useState6(null);
+  const [loading, setLoading] = useState6(false);
+  const [error, setError] = useState6(null);
+  const [announcedRevision, setAnnouncedRevision] = useState6(null);
+  const [stateIdentity, setStateIdentity] = useState6(identityKey);
+  const generationRef = useRef6(0);
+  const requestAbortRef = useRef6(null);
+  const lastSeqRef = useRef6(0);
+  const refresh = useCallback8(async () => {
+    if (!sessionId) return;
+    requestAbortRef.current?.abort();
+    const requestAbort = new AbortController();
+    requestAbortRef.current = requestAbort;
+    const generation = generationRef.current += 1;
+    setStateIdentity(identityKey);
+    setLoading(true);
+    setError(null);
+    try {
+      for (let attempt = 0; attempt < 2; attempt += 1) {
+        const res = await client.getWorkspaceCapture(
+          workspaceId,
+          sessionId,
+          { signal: requestAbort.signal }
+        );
+        if (generationRef.current !== generation) return;
+        if (!res.available) {
+          setCapture(null);
+          setAvailable(false);
+          setFileCount(0);
+          setDegradedReason(res.degradedReason ?? null);
+          return;
+        }
+        setDegradedReason(null);
+        setFileCount(res.stats.fileCount);
+        let manifestValue = res.manifest;
+        if (!manifestValue && res.manifestUrl) {
+          const response = await fetch(res.manifestUrl.url, {
+            signal: AbortSignal.any([
+              requestAbort.signal,
+              AbortSignal.timeout(MANIFEST_FETCH_TIMEOUT_MS)
+            ]),
+            credentials: "omit",
+            cache: "no-store",
+            referrerPolicy: "no-referrer"
+          }).catch(() => null);
+          if (generationRef.current !== generation) return;
+          if (!response?.ok) {
+            if (attempt === 0 && (response === null || response.status === 401 || response.status === 403)) {
+              continue;
+            }
+            throw new Error(
+              `Workspace capture manifest download failed${response ? ` (${response.status})` : ""}.`
+            );
+          }
+          try {
+            manifestValue = await response.json();
+          } catch {
+            throw new Error("Workspace capture manifest was not valid JSON.");
+          }
+          if (generationRef.current !== generation) return;
+        }
+        if (!manifestValue) {
+          throw new Error("Workspace capture response did not include a manifest.");
+        }
+        const manifest = captureManifestForResponse(manifestValue, res);
+        setCapture(manifest);
+        setAvailable(true);
+        setAnnouncedRevision(
+          (prev) => prev === null || manifest.revision > prev ? manifest.revision : prev
+        );
+        return;
+      }
+      throw new Error("Workspace capture manifest download failed after refreshing its URL.");
+    } catch (cause) {
+      if (generationRef.current !== generation) return;
+      setError(cause instanceof Error ? cause : new Error(String(cause)));
+    } finally {
+      if (generationRef.current === generation) setLoading(false);
+      if (requestAbortRef.current === requestAbort) requestAbortRef.current = null;
+    }
+  }, [client, workspaceId, sessionId, identityKey]);
+  useEffect6(() => {
+    requestAbortRef.current?.abort();
+    requestAbortRef.current = null;
+    generationRef.current += 1;
+    lastSeqRef.current = 0;
+    setCapture(null);
+    setAvailable(false);
+    setDegradedReason(null);
+    setFileCount(null);
+    setAnnouncedRevision(null);
+    setError(null);
+    if (!enabled) {
+      setLoading(false);
+      return;
+    }
+    void refresh();
+    return () => {
+      requestAbortRef.current?.abort();
+      requestAbortRef.current = null;
+      generationRef.current += 1;
+    };
+  }, [enabled, refresh]);
+  const events = options.events;
+  useEffect6(() => {
+    if (!enabled || !events) return;
+    let newest = null;
+    for (const event of events) {
+      if (event.sequence <= lastSeqRef.current) continue;
+      if (event.type === REVISION_CAPTURED) {
+        const payload = event.payload;
+        if (payload && typeof payload === "object" && typeof payload.revision === "number") {
+          newest = newest === null ? payload.revision : Math.max(newest, payload.revision);
+        }
+      } else if (event.type === REVISION_DEGRADED) {
+        const payload = event.payload;
+        if (payload && typeof payload === "object" && typeof payload.revision === "number") {
+          newest = newest === null ? payload.revision : Math.max(newest, payload.revision);
+        }
+      }
+    }
+    for (const event of events)
+      if (event.sequence > lastSeqRef.current) lastSeqRef.current = event.sequence;
+    if (newest === null) return;
+    setAnnouncedRevision((prev) => prev === null || newest > prev ? newest : prev);
+  }, [enabled, events]);
+  const identityMatches = enabled && stateIdentity === identityKey;
+  const visibleCapture = identityMatches ? capture : null;
+  const visibleAnnouncedRevision = identityMatches ? announcedRevision : null;
+  const loadedRevision = visibleCapture?.revision ?? null;
+  useEffect6(() => {
+    if (!enabled) return;
+    if (visibleAnnouncedRevision === null) return;
+    if (loadedRevision !== null && visibleAnnouncedRevision <= loadedRevision) return;
+    if (requestAbortRef.current) return;
+    void refresh();
+  }, [enabled, visibleAnnouncedRevision, loadedRevision, refresh]);
+  const isStale = loadedRevision !== null && visibleAnnouncedRevision !== null && visibleAnnouncedRevision > loadedRevision;
+  return {
+    capture: visibleCapture,
+    revision: loadedRevision,
+    capturedAt: visibleCapture?.capturedAt ?? null,
+    available: identityMatches && available,
+    degradedReason: identityMatches ? degradedReason : null,
+    fileCount: identityMatches ? fileCount : null,
+    isStale,
+    loading: identityMatches && loading,
+    error: identityMatches ? error : null,
+    refresh
+  };
+}
+
+// src/hooks/use-workspace-edit.ts
+import { useCallback as useCallback9, useEffect as useEffect7, useMemo as useMemo4, useRef as useRef7, useState as useState7 } from "react";
+function isLive(liveness) {
+  return sandboxAcceptsLiveIo(liveness);
+}
+function useWorkspaceEdit(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const path = options.path ?? null;
+  const baseContent = options.baseContent ?? null;
+  const routeEpoch = options.route?.epoch;
+  const routeRoot = options.route?.root;
+  const route = useMemo4(
+    () => routeEpoch !== void 0 && routeRoot !== void 0 ? { epoch: routeEpoch, root: routeRoot } : void 0,
+    [routeEpoch, routeRoot]
+  );
+  const live = isLive(options.liveness);
+  const offline = options.offline === true;
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}\0${path ?? ""}\0${routeEpoch ?? ""}\0${routeRoot ?? ""}`;
+  const [buffer, setBuffer] = useState7(null);
+  const [wantsWarm, setWantsWarm] = useState7(false);
+  const [flush, setFlush] = useState7("idle");
+  const [conflict, setConflict] = useState7(null);
+  const [error, setError] = useState7(null);
+  const [stateIdentity, setStateIdentity] = useState7(identityKey);
+  const onWarmRequested = options.onWarmRequested;
+  const bufferRef = useRef7(null);
+  bufferRef.current = buffer;
+  const flushingRef = useRef7(false);
+  const identityGenerationRef = useRef7(0);
+  const flushAttemptRef = useRef7(0);
+  const readAbortRef = useRef7(null);
+  useEffect7(() => {
+    identityGenerationRef.current += 1;
+    flushAttemptRef.current += 1;
+    readAbortRef.current?.abort();
+    readAbortRef.current = null;
+    setStateIdentity(identityKey);
+    setBuffer(null);
+    setWantsWarm(false);
+    setFlush("idle");
+    setConflict(null);
+    setError(null);
+    flushingRef.current = false;
+    return () => {
+      identityGenerationRef.current += 1;
+      flushAttemptRef.current += 1;
+      readAbortRef.current?.abort();
+      readAbortRef.current = null;
+    };
+  }, [identityKey]);
+  const edit = useCallback9(
+    (content) => {
+      if (stateIdentity !== identityKey) return;
+      if (offline) return;
+      setBuffer((prev) => prev === content ? prev : content);
+      setFlush((prev) => prev === "flushing" ? prev : "idle");
+      setConflict(null);
+      if (!live) {
+        setWantsWarm((prev) => {
+          if (!prev) onWarmRequested?.();
+          return true;
+        });
+      }
+    },
+    [offline, live, onWarmRequested, stateIdentity, identityKey]
+  );
+  const doFlush = useCallback9(
+    async (force) => {
+      if (stateIdentity !== identityKey) return;
+      if (!sessionId || !path) return;
+      const content = bufferRef.current;
+      if (content === null) return;
+      if (flushingRef.current) return;
+      const identityGeneration = identityGenerationRef.current;
+      const flushAttempt = flushAttemptRef.current += 1;
+      flushingRef.current = true;
+      setFlush("flushing");
+      setError(null);
+      try {
+        if (!force) {
+          const readAbort = new AbortController();
+          readAbortRef.current?.abort();
+          readAbortRef.current = readAbort;
+          const liveRead = await client.fsRead(
+            workspaceId,
+            sessionId,
+            { path, ...route ? { route } : {} },
+            { signal: readAbort.signal }
+          );
+          if (readAbortRef.current === readAbort) readAbortRef.current = null;
+          if (identityGenerationRef.current !== identityGeneration) return;
+          const liveContent = liveRead.content;
+          if (baseContent !== null && liveContent !== baseContent) {
+            setConflict({ path, base: baseContent, live: liveContent });
+            setFlush("conflict");
+            return;
+          }
+        }
+        await client.fsWrite(workspaceId, sessionId, {
+          path,
+          content,
+          overwrite: true,
+          ...route ? { route } : {}
+        });
+        if (identityGenerationRef.current !== identityGeneration) return;
+        setConflict(null);
+        setFlush("flushed");
+        setWantsWarm(false);
+      } catch (cause) {
+        if (identityGenerationRef.current !== identityGeneration) return;
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+        setFlush("idle");
+      } finally {
+        if (flushAttemptRef.current === flushAttempt) {
+          flushingRef.current = false;
+          readAbortRef.current = null;
+        }
+      }
+    },
+    [client, workspaceId, sessionId, path, baseContent, route, stateIdentity, identityKey]
+  );
+  useEffect7(() => {
+    if (offline) return;
+    if (!live) return;
+    if (buffer === null) return;
+    if (flush === "flushed" || flush === "conflict" || flush === "flushing") return;
+    void doFlush(false);
+  }, [offline, live, buffer, flush, doFlush]);
+  const overwrite = useCallback9(async () => {
+    await doFlush(true);
+  }, [doFlush]);
+  const discard = useCallback9(() => {
+    setBuffer(null);
+    setWantsWarm(false);
+    setFlush("idle");
+    setConflict(null);
+    setError(null);
+  }, []);
+  let state;
+  if (offline) {
+    state = "readonly-offline";
+  } else if (flush === "flushing") {
+    state = "flushing";
+  } else if (flush === "flushed") {
+    state = "flushed";
+  } else if (flush === "conflict") {
+    state = "conflict";
+  } else if (buffer === null) {
+    state = "viewing-cold";
+  } else if (live) {
+    state = "flushing";
+  } else if (options.warming === true) {
+    state = "warming";
+  } else {
+    state = "buffering";
+  }
+  const identityMatches = stateIdentity === identityKey;
+  return {
+    state: identityMatches ? state : offline ? "readonly-offline" : "viewing-cold",
+    readOnly: offline,
+    buffer: identityMatches ? buffer : null,
+    wantsWarm: identityMatches && wantsWarm,
+    edit,
+    conflict: identityMatches ? conflict : null,
+    overwrite,
+    discard,
+    error: identityMatches ? error : null
+  };
+}
+
+// src/hooks/use-machine-chip.ts
+import { useMemo as useMemo5 } from "react";
+function formatAsOf(t, capturedAt, now) {
+  const then = Date.parse(capturedAt);
+  if (Number.isNaN(then)) return "recently";
+  const seconds = Math.max(0, Math.round((now - then) / 1e3));
+  if (seconds < 45) return t("hooks.useMachineChip.justNow");
+  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`;
+}
+function deriveMachineChip(t, input) {
+  const now = input.now ?? Date.now();
+  const asOf = input.capturedAt ?? null;
+  const managedRestingLabel = asOf ? t("hooks.useMachineChip.sleepingSavedAsof", { asOf: formatAsOf(t, asOf, now) }) : t("hooks.useMachineChip.sleeping");
+  const offlineLabel = t("hooks.useMachineChip.offline");
+  const selfhostedOnline = input.activeIsSelfhosted === true && input.activeMachineState != null && connectionStatusForState(input.activeMachineState) === "online";
+  if (sandboxAcceptsLiveIo(input.liveness) || selfhostedOnline) {
+    return { state: "live", label: t("hooks.useMachineChip.live"), asOf: null };
+  }
+  const selfhostedOffline = input.activeIsSelfhosted === true && input.activeMachineState === "offline";
+  if (input.capabilitiesState === "error") {
+    return {
+      state: "offline",
+      label: input.activeIsSelfhosted === true ? offlineLabel : managedRestingLabel,
+      asOf
+    };
+  }
+  const machineWarming = input.activeMachineState === "reconnecting" || input.activeMachineState === "enrolling";
+  if (!selfhostedOffline && (input.capabilitiesState === "negotiating" || input.wantsWarm === true || machineWarming)) {
+    return { state: "waking", label: t("hooks.useMachineChip.waking"), asOf };
+  }
+  return {
+    state: "offline",
+    label: input.activeIsSelfhosted === true ? offlineLabel : managedRestingLabel,
+    asOf
+  };
+}
+function useMachineChip(input) {
+  const t = useOpenGeniText();
+  const {
+    liveness,
+    capabilitiesState,
+    activeMachineState,
+    activeIsSelfhosted,
+    wantsWarm,
+    capturedAt,
+    now
+  } = input;
+  return useMemo5(
+    () => deriveMachineChip(t, {
+      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,
+      t
+    ]
+  );
+}
+
+// src/index.ts
+import {
+  humanizeModelSlug,
+  isRawModelLabel,
+  modelDisplayName as modelDisplayName2,
+  modelSlug,
+  modelVendor
+} from "@opengeni/sdk/model-display";
+import { parseOpenGeniLink } from "@opengeni/sdk";
+
+// src/components/fleet-tile.tsx
+import { deriveSessionDisplayTitle } from "@opengeni/sdk";
+import { modelDisplayName } from "@opengeni/sdk/model-display";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var SESSION_METADATA_TITLE_KEYS = ["title", "name"];
+function sessionDisplayTitle(session) {
+  return deriveSessionDisplayTitle(session, { metadataKeys: SESSION_METADATA_TITLE_KEYS });
+}
+function FleetTile({ session, title, subtitle, onOpen, className }) {
+  const msg = useOpenGeniText();
+  const running = session.status === "running" || session.status === "queued";
+  const needsYou = session.status === "requires_action" && !sessionAdmissionBlocked(session);
+  return /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      type: "button",
+      "data-status": session.status,
+      onClick: onOpen ? () => onOpen(session) : void 0,
+      disabled: !onOpen,
+      className: cn(
+        "og-root group relative flex w-full flex-col gap-2.5 overflow-hidden rounded-og-lg border border-og-border",
+        "bg-og-surface-1 p-4 text-left shadow-og-sm",
+        "transition-[border-color,background-color,box-shadow,transform] duration-200 ease-og-out",
+        onOpen && "hover:-translate-y-px hover:border-og-border-strong hover:bg-og-surface-2 hover:shadow-og-md",
+        "disabled:cursor-default",
+        className
+      ),
+      children: [
+        /* @__PURE__ */ jsx2(
+          "span",
+          {
+            "aria-hidden": true,
+            className: cn(
+              "absolute inset-y-0 left-0 w-0.5 transition-opacity duration-300",
+              running ? "bg-og-accent opacity-100" : needsYou ? "bg-og-status-waiting opacity-100" : "opacity-0"
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs2("span", { className: "flex w-full items-start justify-between gap-3", children: [
+          /* @__PURE__ */ jsx2("span", { className: "line-clamp-2 min-w-0 text-og-base font-medium leading-snug text-og-fg", children: title ?? sessionDisplayTitle(session) }),
+          /* @__PURE__ */ jsx2(SessionStatus, { status: sessionDisplayStatus(session), size: "sm", className: "mt-px" })
+        ] }),
+        subtitle ? /* @__PURE__ */ jsx2("span", { className: "line-clamp-1 text-og-sm text-og-fg-muted", children: subtitle }) : null,
+        /* @__PURE__ */ jsxs2("span", { className: "mt-auto flex w-full items-center gap-2 text-og-xs text-og-fg-subtle", children: [
+          /* @__PURE__ */ jsx2("span", { className: "font-og-mono", children: session.id.slice(0, 8) }),
+          /* @__PURE__ */ jsx2("span", { "aria-hidden": true, children: "\xB7" }),
+          /* @__PURE__ */ jsx2("span", { className: "truncate", children: modelDisplayName(session.model) }),
+          /* @__PURE__ */ jsx2("span", { className: "ml-auto shrink-0", title: session.updatedAt, children: formatRelativeTime(msg, session.updatedAt) })
+        ] })
+      ]
+    }
+  );
+}
+
+// src/components/workbench-changes.tsx
+import { ArrowUpRightIcon, FileWarningIcon, HistoryIcon } from "lucide-react";
+import {
+  Component,
+  useCallback as useCallback11,
+  useEffect as useEffect9,
+  useId,
+  useLayoutEffect,
+  useMemo as useMemo7,
+  useRef as useRef9,
+  useState as useState9
+} from "react";
+import { VList } from "virtua";
+
+// src/hooks/use-windowed-sections.ts
+import { useCallback as useCallback10, useEffect as useEffect8, useMemo as useMemo6, useRef as useRef8, useState as useState8 } from "react";
+function computeWindowRange(heights, scrollTop, viewport, overscan) {
+  const n = heights.length;
+  if (n === 0) return { start: 0, end: 0 };
+  const top = Math.max(scrollTop, 0);
+  const bottom = top + Math.max(viewport, 0);
+  let firstVisible = -1;
+  let lastVisible = -1;
+  let acc = 0;
+  let anchor = 0;
+  for (let i = 0; i < n; i++) {
+    const secTop = acc;
+    const secBottom = secTop + Math.max(heights[i] ?? 0, 0);
+    if (secTop <= top) anchor = i;
+    if (secBottom > top && secTop < bottom) {
+      if (firstVisible === -1) firstVisible = i;
+      lastVisible = i;
+    }
+    acc = secBottom;
+  }
+  if (firstVisible === -1) {
+    firstVisible = anchor;
+    lastVisible = anchor;
+  }
+  return {
+    start: Math.max(0, firstVisible - overscan),
+    end: Math.min(n, lastVisible + 1 + overscan)
+  };
+}
+function useWindowedSections(opts) {
+  const { count, estimateHeight, overscan = 3 } = opts;
+  const scrollRef = useRef8(null);
+  const [heights, setHeights] = useState8(
+    () => Array.from({ length: count }, (_, i) => estimateHeight(i))
+  );
+  useEffect8(() => {
+    setHeights((prev) => {
+      const next = Array.from({ length: count }, (_, i) => estimateHeight(i));
+      return prev.length === next.length && prev.every((height, index) => height === next[index]) ? prev : next;
+    });
+  }, [count, estimateHeight]);
+  const heightsRef = useRef8(heights);
+  heightsRef.current = heights;
+  const [range, setRange] = useState8(() => ({
+    start: 0,
+    end: Math.min(count, overscan + 1)
+  }));
+  const recompute = useCallback10(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    const next = computeWindowRange(heightsRef.current, el.scrollTop, el.clientHeight, overscan);
+    setRange((prev) => prev.start === next.start && prev.end === next.end ? prev : next);
+  }, [overscan]);
+  useEffect8(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    let raf = 0;
+    const onScroll = () => {
+      if (raf) return;
+      raf = typeof requestAnimationFrame === "function" ? requestAnimationFrame(() => {
+        raf = 0;
+        recompute();
+      }) : (recompute(), 0);
+    };
+    el.addEventListener("scroll", onScroll, { passive: true });
+    const ro = typeof ResizeObserver !== "undefined" ? new ResizeObserver(() => recompute()) : null;
+    ro?.observe(el);
+    recompute();
+    return () => {
+      el.removeEventListener("scroll", onScroll);
+      ro?.disconnect();
+      if (raf && typeof cancelAnimationFrame === "function") cancelAnimationFrame(raf);
+    };
+  }, [recompute, count]);
+  const measure = useCallback10((index, height) => {
+    if (height <= 0) return;
+    setHeights((prev) => {
+      if (Math.abs((prev[index] ?? 0) - height) < 1) return prev;
+      const next = prev.slice();
+      next[index] = height;
+      return next;
+    });
+  }, []);
+  const offsets = useMemo6(() => {
+    const out = new Array(count + 1);
+    out[0] = 0;
+    for (let i = 0; i < count; i++) out[i + 1] = (out[i] ?? 0) + Math.max(heights[i] ?? 0, 0);
+    return out;
+  }, [heights, count]);
+  useEffect8(() => {
+    recompute();
+  }, [offsets, recompute]);
+  const scrollToIndex = useCallback10(
+    (index) => {
+      const el = scrollRef.current;
+      if (!el) return;
+      const clamped = Math.max(0, Math.min(count - 1, index));
+      el.scrollTop = offsets[clamped] ?? 0;
+    },
+    [offsets, count]
+  );
+  return {
+    scrollRef,
+    range,
+    offsets,
+    totalHeight: offsets[count] ?? 0,
+    measure,
+    scrollToIndex
+  };
+}
+
+// src/components/workbench-changes.tsx
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var GROUP_THRESHOLD = 20;
+var OVERSCAN = 2;
+var HEADER_PX = 30;
+var LINE_PX = 18;
+var GUARD_BODY_PX = 52;
+var COMPACT_SURFACE_PX = 560;
+var useChangesLayoutEffect = typeof window === "undefined" ? useEffect9 : useLayoutEffect;
+var STATUS_TINT = {
+  added: "text-og-status-idle",
+  modified: "text-og-status-running",
+  deleted: "text-og-status-failed",
+  renamed: "text-og-accent",
+  copied: "text-og-accent",
+  untracked: "text-og-fg-subtle",
+  ignored: "text-og-fg-subtle",
+  conflicted: "text-og-status-failed",
+  typechange: "text-og-status-running"
+};
+var STATUS_LETTER = {
+  added: "A",
+  modified: "M",
+  deleted: "D",
+  renamed: "R",
+  copied: "C",
+  untracked: "U",
+  ignored: "I",
+  conflicted: "!",
+  typechange: "T"
+};
+function compactFileLabel(file) {
+  const slash = file.path.lastIndexOf("/");
+  const basename = slash >= 0 ? file.path.slice(slash + 1) : file.path;
+  const parent = slash >= 0 ? file.path.slice(0, slash + 1) : "";
+  return `${STATUS_LETTER[file.status]} \xB7 ${basename}${parent ? ` \u2014 ${parent}` : ""}`;
+}
+var ChangesRailVList = class extends Component {
+  state = {
+    renderedRowCount: this.props.rowCount,
+    resetVersion: 0
+  };
+  host = null;
+  listHandle = null;
+  pendingFocusedPath = null;
+  restoreFrame = null;
+  static getDerivedStateFromProps(props, state) {
+    if (props.rowCount === state.renderedRowCount) return null;
+    return {
+      renderedRowCount: props.rowCount,
+      resetVersion: props.rowCount < state.renderedRowCount ? state.resetVersion + 1 : state.resetVersion
+    };
+  }
+  getSnapshotBeforeUpdate(_previousProps, previousState) {
+    if (previousState.resetVersion === this.state.resetVersion) return null;
+    const scroller = this.host?.firstElementChild;
+    if (!(scroller instanceof HTMLElement)) return null;
+    const active = document.activeElement;
+    const focusedRow = active instanceof HTMLElement && scroller.contains(active) ? active.closest("[data-rail-file-path]") : null;
+    return {
+      focusedPath: focusedRow?.dataset.railFilePath ?? this.pendingFocusedPath,
+      scrollOffset: scroller.scrollTop
+    };
+  }
+  componentDidUpdate(_previousProps, _previousState, snapshot) {
+    if (!snapshot || !this.listHandle) return;
+    this.cancelRestoreFrame();
+    const maxOffset = Math.max(0, this.listHandle.scrollSize - this.listHandle.viewportSize);
+    this.listHandle.scrollTo(Math.min(Math.max(snapshot.scrollOffset, 0), maxOffset));
+    const focusedPath = snapshot.focusedPath;
+    if (!focusedPath) return;
+    this.pendingFocusedPath = focusedPath;
+    this.continueFocusRestore();
+  }
+  componentWillUnmount() {
+    this.cancelRestoreFrame();
+    this.pendingFocusedPath = null;
+  }
+  cancelRestoreFrame() {
+    if (this.restoreFrame === null) return;
+    if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(this.restoreFrame);
+    this.restoreFrame = null;
+  }
+  continueFocusRestore = () => {
+    const path = this.pendingFocusedPath;
+    if (!path) return;
+    if (this.restoreFocusedPath(path)) {
+      this.pendingFocusedPath = null;
+      return;
+    }
+    if (this.restoreFrame === null && typeof requestAnimationFrame === "function") {
+      this.restoreFrame = requestAnimationFrame(() => {
+        this.restoreFrame = null;
+        this.continueFocusRestore();
+      });
+    }
+  };
+  restoreFocusedPath(path) {
+    const host = this.host;
+    if (!host) return true;
+    const active = document.activeElement;
+    if (active instanceof HTMLElement && active.isConnected && active !== document.body) {
+      return true;
+    }
+    if (!this.props.files.some((file) => file.path === path)) return true;
+    const row = Array.from(host.querySelectorAll("[data-rail-file-path]")).find(
+      (candidate) => candidate.dataset.railFilePath === path
+    );
+    if (!row) return false;
+    row.focus({ preventScroll: true });
+    return true;
+  }
+  setHost = (host) => {
+    this.host = host;
+  };
+  setListHandle = (handle) => {
+    this.listHandle = handle;
+  };
+  render() {
+    return /* @__PURE__ */ jsx3("div", { ref: this.setHost, "data-opengeni-changes-rail": true, className: this.props.className, children: /* @__PURE__ */ jsx3(
+      VList,
+      {
+        ref: this.setListHandle,
+        className: "h-full",
+        itemSize: this.props.coarsePointer ? 44 : 28,
+        ssrCount: Math.min(30, this.props.rowCount),
+        children: this.props.children
+      },
+      this.state.resetVersion
+    ) });
+  }
+};
+function buildRail(t, files) {
+  const roots = new Set(
+    files.flatMap((file) => file.repoRoot === void 0 ? [] : [file.repoRoot])
+  );
+  const groupByRepo = roots.size > 1;
+  if (!groupByRepo && files.length <= GROUP_THRESHOLD) {
+    return {
+      orderedFiles: files,
+      rows: files.map((file, index) => ({ kind: "file", file, index })),
+      grouped: false
+    };
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const slash = file.path.indexOf("/");
+    const key = groupByRepo ? file.repoRoot || t("workbenchChanges.workspace") : slash > 0 ? file.path.slice(0, slash) : t("workbenchChanges.root");
+    const bucket = groups.get(key);
+    if (bucket) bucket.push(file);
+    else groups.set(key, [file]);
+  }
+  const labels = [...groups.keys()].sort((a, b) => a.localeCompare(b));
+  const orderedFiles = [];
+  const rows = [];
+  for (const label of labels) {
+    const bucket = (groups.get(label) ?? []).slice().sort((a, b) => a.path.localeCompare(b.path));
+    rows.push({ kind: "group", label, count: bucket.length });
+    for (const file of bucket) {
+      rows.push({ kind: "file", file, index: orderedFiles.length });
+      orderedFiles.push(file);
+    }
+  }
+  return { orderedFiles, rows, grouped: true };
+}
+function isGuarded(file) {
+  return file.isBinary || file.truncated;
+}
+function estimateSectionHeight(file) {
+  if (isGuarded(file)) return HEADER_PX + GUARD_BODY_PX;
+  let lines = 0;
+  for (const hunk of file.hunks) lines += hunk.lines.length + 1;
+  return HEADER_PX + Math.max(lines, 1) * LINE_PX + 8;
+}
+function WorkbenchChanges({
+  diff,
+  source,
+  capturedAt,
+  captureRevision,
+  themeType,
+  onOpenFile,
+  className
+}) {
+  const t = useOpenGeniText();
+  const rootRef = useRef9(null);
+  const [compact, setCompact] = useState9(false);
+  const [coarsePointer, setCoarsePointer] = useState9(false);
+  const resolvedTheme = useThemeType(themeType);
+  const [layout, setLayout] = useState9("unified");
+  const [activePath, setActivePath] = useState9(null);
+  const pickerId = useId();
+  const unicodeFontPaths = useMemo7(
+    () => diff.flatMap((file) => file.oldPath ? [file.path, file.oldPath] : [file.path]),
+    [diff]
+  );
+  useUnicodeFallbackFonts(unicodeFontPaths);
+  const { orderedFiles, rows, grouped } = useMemo7(() => buildRail(t, diff), [diff, t]);
+  const selectedIndex = orderedFiles.findIndex((file) => file.path === activePath);
+  const activeIndex = selectedIndex >= 0 ? selectedIndex : 0;
+  useChangesLayoutEffect(() => {
+    const root = rootRef.current;
+    if (!root || typeof ResizeObserver === "undefined") return;
+    const update = (width) => {
+      if (width > 0) setCompact(width < COMPACT_SURFACE_PX);
+    };
+    update(root.getBoundingClientRect().width);
+    const observer = new ResizeObserver((entries) => {
+      update(entries[0]?.contentRect.width ?? root.getBoundingClientRect().width);
+    });
+    observer.observe(root);
+    return () => observer.disconnect();
+  }, []);
+  useChangesLayoutEffect(() => {
+    if (typeof window === "undefined" || typeof window.matchMedia !== "function") return;
+    const query = window.matchMedia("(pointer: coarse)");
+    const update = () => setCoarsePointer(query.matches);
+    update();
+    if (typeof query.addEventListener === "function") {
+      query.addEventListener("change", update);
+      return () => query.removeEventListener("change", update);
+    }
+    if (typeof query.addListener === "function") {
+      query.addListener(update);
+      return () => query.removeListener(update);
+    }
+  }, []);
+  const additions = useMemo7(() => diff.reduce((sum, f) => sum + f.additions, 0), [diff]);
+  const deletions = useMemo7(() => diff.reduce((sum, f) => sum + f.deletions, 0), [diff]);
+  const estimateHeight = useCallback11(
+    (index) => {
+      const file = orderedFiles[index];
+      return file ? estimateSectionHeight(file) : HEADER_PX + LINE_PX;
+    },
+    [orderedFiles]
+  );
+  const windowed = useWindowedSections({
+    count: orderedFiles.length,
+    estimateHeight,
+    overscan: OVERSCAN
+  });
+  const jumpTo = useCallback11(
+    (index) => {
+      setActivePath(orderedFiles[index]?.path ?? null);
+      windowed.scrollToIndex(index);
+    },
+    [orderedFiles, windowed]
+  );
+  const onPaneScroll = useCallback11(() => {
+    const el = windowed.scrollRef.current;
+    if (!el) {
+      return;
+    }
+    const top = el.scrollTop;
+    const offsets = windowed.offsets;
+    let idx = 0;
+    for (let i = 0; i < orderedFiles.length; i++) {
+      if ((offsets[i] ?? 0) <= top + 4) idx = i;
+      else break;
+    }
+    const nextPath = orderedFiles[idx]?.path ?? null;
+    setActivePath((previous) => previous === nextPath ? previous : nextPath);
+  }, [windowed, orderedFiles]);
+  useEffect9(() => {
+    const el = windowed.scrollRef.current;
+    if (!el) return;
+    el.addEventListener("scroll", onPaneScroll, { passive: true });
+    return () => el.removeEventListener("scroll", onPaneScroll);
+  }, [windowed.scrollRef, onPaneScroll]);
+  const sourceBadge = describeSource(t, source, capturedAt, captureRevision ?? null);
+  const activeFile = orderedFiles[activeIndex] ?? orderedFiles[0];
+  return /* @__PURE__ */ jsxs3(
+    "div",
+    {
+      ref: rootRef,
+      className: cn("flex h-full min-h-0 min-w-0 flex-col", className),
+      "data-workbench-changes-layout": compact ? "compact" : "rail",
+      children: [
+        /* @__PURE__ */ jsxs3(
+          "div",
+          {
+            className: cn(
+              "flex shrink-0 items-center justify-between gap-2 border-b border-og-border px-3 py-1.5",
+              compact && source === "capture" && "flex-col items-stretch gap-1.5 py-2"
+            ),
+            children: [
+              /* @__PURE__ */ jsxs3(
+                "span",
+                {
+                  role: "status",
+                  "aria-atomic": "true",
+                  "aria-live": "polite",
+                  "data-contrast-audited": true,
+                  className: "min-w-0 text-og-xs text-og-fg-muted",
+                  children: [
+                    t("workbenchChanges.filesChanged", { count: diff.length }),
+                    /* @__PURE__ */ jsxs3("span", { "data-contrast-audited": true, className: "ml-2 text-og-status-idle", children: [
+                      "+",
+                      additions
+                    ] }),
+                    /* @__PURE__ */ jsxs3("span", { "data-contrast-audited": true, className: "ml-1 text-og-status-failed", children: [
+                      "\u2212",
+                      deletions
+                    ] })
+                  ]
+                }
+              ),
+              /* @__PURE__ */ jsxs3(
+                "div",
+                {
+                  className: cn(
+                    "flex shrink-0 items-center gap-2",
+                    compact && source === "capture" && "self-start"
+                  ),
+                  children: [
+                    compact ? null : /* @__PURE__ */ jsx3(LayoutToggle, { layout, onChange: setLayout }),
+                    /* @__PURE__ */ jsx3(SourceBadge, { source, capturedAt, label: sourceBadge })
+                  ]
+                }
+              )
+            ]
+          }
+        ),
+        compact ? /* @__PURE__ */ jsxs3("div", { className: "flex min-h-0 flex-1 flex-col", children: [
+          /* @__PURE__ */ jsxs3("div", { className: "shrink-0 border-b border-og-border bg-og-surface-1 p-2", children: [
+            /* @__PURE__ */ jsx3("label", { className: "sr-only", htmlFor: pickerId, children: t("workbenchChanges.changedFile") }),
+            /* @__PURE__ */ jsx3(
+              "select",
+              {
+                id: pickerId,
+                "aria-label": t("workbenchChanges.changedFile"),
+                value: activeIndex,
+                onChange: (event) => {
+                  const index = Number(event.currentTarget.value);
+                  setActivePath(orderedFiles[index]?.path ?? null);
+                },
+                title: activeFile?.path,
+                "data-compact-file-picker": true,
+                className: "h-11 w-full rounded-og-md border border-og-border bg-og-bg px-3 font-og-mono text-og-sm text-og-fg outline-hidden transition-colors focus:border-og-accent focus:ring-2 focus:ring-og-accent-soft",
+                children: orderedFiles.map((file, index) => /* @__PURE__ */ jsx3("option", { value: index, children: compactFileLabel(file) }, file.path))
+              }
+            )
+          ] }),
+          /* @__PURE__ */ jsx3(
+            "div",
+            {
+              "aria-label": t("workbenchChanges.changedFileDiff"),
+              className: "min-h-0 min-w-0 flex-1 overflow-auto outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-og-accent",
+              "data-opengeni-changes-pane": true,
+              role: "region",
+              tabIndex: 0,
+              children: activeFile ? /* @__PURE__ */ jsx3(
+                DiffSection,
+                {
+                  file: activeFile,
+                  layout: "unified",
+                  themeType: resolvedTheme,
+                  ...onOpenFile ? { onOpenFile } : {}
+                }
+              ) : null
+            }
+          )
+        ] }) : /* @__PURE__ */ jsxs3("div", { className: "flex min-h-0 flex-1", children: [
+          /* @__PURE__ */ jsx3(
+            ChangesRailVList,
+            {
+              rowCount: rows.length,
+              coarsePointer,
+              files: orderedFiles,
+              className: "w-[clamp(12rem,28%,15rem)] shrink-0 border-r border-og-border bg-og-surface-1/35",
+              children: rows.map(
+                (row) => row.kind === "group" ? /* @__PURE__ */ jsxs3(
+                  "div",
+                  {
+                    "data-rail-group": true,
+                    className: "flex items-center gap-1.5 px-2 pb-0.5 pt-2 text-og-xs font-medium uppercase tracking-wide text-og-fg-subtle",
+                    children: [
+                      /* @__PURE__ */ jsx3("span", { className: "min-w-0 truncate", children: row.label }),
+                      /* @__PURE__ */ jsx3("span", { className: "shrink-0", children: row.count })
+                    ]
+                  },
+                  `g:${row.label}`
+                ) : /* @__PURE__ */ jsx3(
+                  RailFileRow,
+                  {
+                    file: row.file,
+                    grouped,
+                    active: row.index === activeIndex,
+                    onClick: () => jumpTo(row.index)
+                  },
+                  row.file.path
+                )
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            "div",
+            {
+              ref: windowed.scrollRef,
+              "aria-label": t("workbenchChanges.changedFilesDiff"),
+              className: "min-h-0 min-w-0 flex-1 overflow-auto outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-og-accent",
+              "data-opengeni-changes-pane": true,
+              role: "region",
+              tabIndex: 0,
+              children: /* @__PURE__ */ jsx3("div", { style: { position: "relative", height: windowed.totalHeight }, children: orderedFiles.map((file, index) => {
+                if (index < windowed.range.start || index >= windowed.range.end) return null;
+                return /* @__PURE__ */ jsx3(
+                  MeasuredSection,
+                  {
+                    index,
+                    top: windowed.offsets[index] ?? 0,
+                    onMeasure: windowed.measure,
+                    children: /* @__PURE__ */ jsx3(
+                      DiffSection,
+                      {
+                        file,
+                        layout,
+                        themeType: resolvedTheme,
+                        ...onOpenFile ? { onOpenFile } : {}
+                      }
+                    )
+                  },
+                  file.path
+                );
+              }) })
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+function SourceBadge({
+  source,
+  capturedAt,
+  label
+}) {
+  const t = useOpenGeniText();
+  if (source === "capture" && capturedAt) {
+    return /* @__PURE__ */ jsxs3(
+      "span",
+      {
+        className: "inline-flex items-center gap-1 rounded-og-xs border border-og-border px-1.5 py-px text-og-xs text-og-fg-muted",
+        title: new Date(capturedAt).toLocaleString(t.locale),
+        children: [
+          /* @__PURE__ */ jsx3(HistoryIcon, { className: "size-3 shrink-0 text-og-status-running", "aria-hidden": true }),
+          label
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx3("span", { className: "rounded-og-xs bg-og-surface-2 px-1.5 py-px text-og-xs text-og-fg-subtle", children: label });
+}
+function describeSource(t, source, capturedAt, revision) {
+  if (source !== "capture" || !capturedAt) return t("workbenchChanges.liveDiff");
+  const time = formatAsOf(t, capturedAt, Date.now());
+  return revision !== null ? t("workbenchChanges.asOfTurnRevisionTime", { revision, time }) : `as of ${time}`;
+}
+function RailFileRow({
+  file,
+  grouped,
+  active,
+  onClick
+}) {
+  const repoPrefix = file.repoRoot ? `${file.repoRoot}/` : null;
+  const shown = grouped ? file.repoRoot !== void 0 ? repoPrefix && file.path.startsWith(repoPrefix) ? file.path.slice(repoPrefix.length) : file.path : file.path.slice(file.path.indexOf("/") + 1) || file.path : file.path;
+  return /* @__PURE__ */ jsxs3(
+    "button",
+    {
+      type: "button",
+      onClick,
+      title: file.path,
+      "data-rail-file": true,
+      "data-rail-file-path": file.path,
+      className: cn(
+        "relative flex min-h-7 w-full items-center gap-1.5 truncate px-2 py-0.5 text-left text-og-sm transition-colors hover:bg-og-surface-2 focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-og-accent pointer-coarse:min-h-11",
+        grouped && "pl-3",
+        active && "bg-og-accent-soft text-og-fg before:absolute before:inset-y-1 before:left-0 before:w-0.5 before:rounded-r-full before:bg-og-accent"
+      ),
+      children: [
+        /* @__PURE__ */ jsx3(
+          "span",
+          {
+            "data-contrast-audited": true,
+            className: cn("w-3 shrink-0 text-center font-og-mono text-og-xs", STATUS_TINT[file.status]),
+            children: STATUS_LETTER[file.status]
+          }
+        ),
+        /* @__PURE__ */ jsx3("span", { className: "min-w-0 flex-1 truncate", children: shown }),
+        /* @__PURE__ */ jsxs3("span", { className: "ml-auto flex shrink-0 items-center gap-1 pl-1 font-og-mono text-og-xs", children: [
+          /* @__PURE__ */ jsxs3("span", { "data-contrast-audited": true, className: "text-og-status-idle", children: [
+            "+",
+            file.additions
+          ] }),
+          /* @__PURE__ */ jsxs3("span", { "data-contrast-audited": true, className: "text-og-status-failed", children: [
+            "\u2212",
+            file.deletions
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function MeasuredSection({
+  index,
+  top,
+  onMeasure,
+  children
+}) {
+  const ref = useRef9(null);
+  useEffect9(() => {
+    const el = ref.current;
+    if (!el) return;
+    const report = () => onMeasure(index, el.offsetHeight);
+    report();
+    const ro = typeof ResizeObserver !== "undefined" ? new ResizeObserver(report) : null;
+    ro?.observe(el);
+    return () => ro?.disconnect();
+  }, [index, onMeasure]);
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      ref,
+      "data-diff-section": true,
+      "data-diff-index": index,
+      style: { position: "absolute", top, left: 0, right: 0 },
+      children
+    }
+  );
+}
+function DiffSection({
+  file,
+  layout,
+  themeType,
+  onOpenFile
+}) {
+  if (isGuarded(file)) {
+    const renamed = file.oldPath && file.oldPath !== file.path;
+    return /* @__PURE__ */ jsxs3("section", { className: "border-b border-og-border pb-1", children: [
+      /* @__PURE__ */ jsxs3("header", { className: "flex items-center justify-between gap-2 bg-og-surface-1 px-3 py-1.5 text-og-sm", children: [
+        /* @__PURE__ */ jsx3("span", { className: "min-w-0 truncate font-og-mono text-og-xs", children: renamed ? `${file.oldPath} \u2192 ${file.path}` : file.path }),
+        /* @__PURE__ */ jsxs3("span", { className: "flex shrink-0 items-center gap-2 font-og-mono text-og-xs", children: [
+          /* @__PURE__ */ jsxs3("span", { className: "text-og-status-idle", children: [
+            "+",
+            file.additions
+          ] }),
+          /* @__PURE__ */ jsxs3("span", { className: "text-og-status-failed", children: [
+            "\u2212",
+            file.deletions
+          ] })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsx3(GuardBody, { file, ...onOpenFile ? { onOpenFile } : {} })
+    ] });
+  }
+  return /* @__PURE__ */ jsx3("section", { "data-pierre-section": true, className: "border-b border-og-border pb-2", children: /* @__PURE__ */ jsx3(PierreDiff, { diff: [file], layout, themeType, className: "px-1" }) });
+}
+function GuardBody({
+  file,
+  onOpenFile
+}) {
+  const t = useOpenGeniText();
+  const reason = file.isBinary ? t("workbenchChanges.binaryFile") : t("workbenchChanges.diffTooLargeToShow");
+  return /* @__PURE__ */ jsxs3("div", { className: "flex flex-wrap items-center gap-2 px-3 py-3 text-og-sm text-og-fg-subtle", children: [
+    /* @__PURE__ */ jsx3(FileWarningIcon, { className: "size-3.5 shrink-0", "aria-hidden": true }),
+    /* @__PURE__ */ jsxs3("span", { className: "min-w-0 flex-1", children: [
+      reason,
+      "."
+    ] }),
+    onOpenFile ? /* @__PURE__ */ jsxs3(
+      "button",
+      {
+        type: "button",
+        onClick: () => onOpenFile(file.path),
+        className: "inline-flex min-h-8 shrink-0 items-center gap-1.5 rounded-og-sm border border-og-border px-2 py-1 text-og-xs font-medium text-og-fg-muted transition-colors hover:border-og-border-strong hover:bg-og-surface-2 hover:text-og-fg focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent pointer-coarse:min-h-11",
+        children: [
+          t("workbenchChanges.openInFiles"),
+          /* @__PURE__ */ jsx3(ArrowUpRightIcon, { className: "size-3.5", "aria-hidden": true })
+        ]
+      }
+    ) : null
+  ] });
+}
+function LayoutToggle({
+  layout,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx3("div", { className: "inline-flex items-center rounded-og-sm border border-og-border p-0.5", children: ["unified", "split"].map((value) => /* @__PURE__ */ jsx3(
+    "button",
+    {
+      type: "button",
+      onClick: () => onChange(value),
+      className: cn(
+        "min-h-7 rounded-og-xs px-1.5 py-0.5 text-og-xs capitalize focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent max-[1023px]:min-w-11 pointer-coarse:min-h-11 pointer-coarse:min-w-11",
+        layout === value ? "bg-og-accent-soft text-og-fg" : "text-og-fg-subtle hover:text-og-fg"
+      ),
+      children: value
+    },
+    value
+  )) });
+}
+
+// src/components/diff-view.tsx
+import { jsx as jsx4 } from "react/jsx-runtime";
+function DiffView({
+  diff,
+  fallback,
+  layout = "unified",
+  themeType,
+  isRepo = true,
+  emptyState,
+  className
+}) {
+  const t = useOpenGeniText();
+  if (diff.length === 0) {
+    return /* @__PURE__ */ jsx4("div", { className: cn("p-3 text-og-sm text-og-fg-subtle", className), children: emptyState ?? (isRepo ? t("diffView.noChanges") : t("diffView.noRepositoryMounted")) });
+  }
+  return /* @__PURE__ */ jsx4(
+    PierreDiff,
+    {
+      diff,
+      layout,
+      themeType,
+      ...fallback !== void 0 ? { fallback } : {},
+      className
+    }
+  );
+}
+
+// src/components/sandbox-workspace.tsx
+import {
+  lazy,
+  Suspense,
+  useCallback as useCallback12,
+  useEffect as useEffect10,
+  useMemo as useMemo8,
+  useRef as useRef10,
+  useState as useState10
+} from "react";
+import {
+  CircleCheckIcon,
+  CpuIcon,
+  FileCode2Icon,
+  GitCompareArrowsIcon,
+  Globe2Icon,
+  LoaderCircleIcon,
+  MonitorIcon,
+  RefreshCwIcon,
+  SquareTerminalIcon,
+  TriangleAlertIcon
+} from "lucide-react";
+import { jsx as jsx5, jsxs as jsxs4 } from "react/jsx-runtime";
+var LazySandboxFiles = lazy(
+  () => import("./sandbox-files-ESDMOFSD.js").then(({ SandboxFiles: SandboxFiles2 }) => ({ default: SandboxFiles2 })).catch(() => ({ default: FilesLoadFailed }))
+);
+function FilesLoadFailed() {
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsxs4(CenteredState, { tone: "danger", icon: /* @__PURE__ */ jsx5(TriangleAlertIcon, { className: "size-5", "aria-hidden": true }), children: [
+    /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: t("sandboxWorkspace.filesCouldNotBeLoaded") }),
+    /* @__PURE__ */ jsxs4(DockActionButton, { onClick: () => window.location.reload(), children: [
+      /* @__PURE__ */ jsx5(RefreshCwIcon, { className: "size-3", "aria-hidden": true }),
+      t("sandboxWorkspace.reload")
+    ] })
+  ] });
+}
+function FilesTabBody(props) {
+  return /* @__PURE__ */ jsx5(Suspense, { fallback: /* @__PURE__ */ jsx5(WorkbenchSurfaceLoading, { name: "Files" }), children: /* @__PURE__ */ jsx5(LazySandboxFiles, { ...props }) });
+}
+var LazyBrowserViewer = lazy(async () => {
+  const { BrowserViewer } = await import("./browser-viewer-TC27OCIP.js");
+  return { default: BrowserViewer };
+});
+var LazyComputerViewer = lazy(async () => {
+  const { ComputerViewer } = await import("./computer-viewer-TDDO25AV.js");
+  return { default: ComputerViewer };
+});
+var WORKBENCH_TAB_CHANGES = "changes";
+var WORKBENCH_TAB_FILES = "files";
+var WORKBENCH_TAB_TERMINAL = "terminal";
+var WORKBENCH_TAB_BROWSER = "browser";
+var WORKBENCH_TAB_DESKTOP = "desktop";
+var WORKBENCH_SURFACES = [
+  WORKBENCH_TAB_CHANGES,
+  WORKBENCH_TAB_FILES,
+  WORKBENCH_TAB_TERMINAL,
+  WORKBENCH_TAB_BROWSER,
+  WORKBENCH_TAB_DESKTOP
+];
+function isWorkbenchSurface(value) {
+  return WORKBENCH_SURFACES.includes(value);
+}
+function isCanonicalAbsoluteSandboxPath(value) {
+  if (!value) return false;
+  const portable = value.replaceAll("\\", "/");
+  return portable.startsWith("/") || /^[A-Za-z]:\//u.test(portable);
+}
+function sourceDrivenDefaultTab(hasChanges, changesEnabled, filesEnabled) {
+  if (hasChanges && changesEnabled) return WORKBENCH_TAB_CHANGES;
+  if (filesEnabled) return WORKBENCH_TAB_FILES;
+  if (changesEnabled) return WORKBENCH_TAB_CHANGES;
+  return null;
+}
+function WorkbenchSurfaceLoading({ name }) {
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsx5(
+    CenteredState,
+    {
+      icon: /* @__PURE__ */ jsx5(LoaderCircleIcon, { className: "size-5 animate-spin motion-reduce:animate-none", "aria-hidden": true }),
+      children: /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: t("sandboxWorkspace.openingName", { name }) })
+    }
+  );
+}
+function initialWorkspaceTab(events, override) {
+  if (override) return override;
+  let bestSeq = -1;
+  let bestFileCount = 0;
+  for (const event of events ?? []) {
+    if (event.type !== "workspace.revision.captured") continue;
+    if (event.sequence <= bestSeq) continue;
+    const stats = event.payload?.stats;
+    bestSeq = event.sequence;
+    bestFileCount = typeof stats?.fileCount === "number" ? stats.fileCount : 0;
+  }
+  if (bestFileCount > 0) return WORKBENCH_TAB_CHANGES;
+  let latestGitSeq = -1;
+  let committedOnly = false;
+  for (const event of events ?? []) {
+    if (event.type !== "git.changed" || event.sequence > bestSeq) continue;
+    if (event.sequence <= latestGitSeq) continue;
+    const payload = event.payload;
+    latestGitSeq = event.sequence;
+    committedOnly = typeof payload?.ahead === "number" && payload.ahead > 0 || payload?.reason === "commit";
+  }
+  return committedOnly ? WORKBENCH_TAB_CHANGES : WORKBENCH_TAB_FILES;
+}
+function sandboxProvisionInFlight(events) {
+  let inFlight = false;
+  for (const event of events) {
+    if (event.type !== "sandbox.operation.started" && event.type !== "sandbox.operation.completed" && event.type !== "sandbox.operation.failed") {
+      continue;
+    }
+    const payload = event.payload;
+    const name = payload && typeof payload === "object" && !Array.isArray(payload) ? payload.name : null;
+    if (name !== "sandbox.provision") continue;
+    if (event.type === "sandbox.operation.started") {
+      inFlight = true;
+    } else {
+      inFlight = false;
+    }
+  }
+  return inFlight;
+}
+function workspaceTurnInFlight(events) {
+  const activeTurnIds = /* @__PURE__ */ new Set();
+  let anonymousTurnInFlight = false;
+  let sessionOwnsWorkspace = false;
+  for (const event of events) {
+    if (event.type === "session.status.changed") {
+      const status = event.payload && typeof event.payload === "object" && !Array.isArray(event.payload) ? event.payload.status : null;
+      sessionOwnsWorkspace = status === "running" || status === "recovering";
+      continue;
+    }
+    if (event.type === "turn.started") {
+      if (event.turnId) activeTurnIds.add(event.turnId);
+      else anonymousTurnInFlight = true;
+      continue;
+    }
+    if (event.type !== "turn.completed" && event.type !== "turn.failed" && event.type !== "turn.cancelled" && event.type !== "turn.superseded") {
+      continue;
+    }
+    if (event.turnId) activeTurnIds.delete(event.turnId);
+    else anonymousTurnInFlight = false;
+  }
+  return sessionOwnsWorkspace || anonymousTurnInFlight || activeTurnIds.size > 0;
+}
+function emptyWarmIntents(sessionId) {
+  return {
+    sessionId,
+    warmTerminal: false,
+    warmFiles: false
+  };
+}
+function useSandboxWorkspaceTabs(options) {
+  const t = useOpenGeniText();
+  const { client, workspaceId, workspaceInteractionEvent } = useOpenGeni(options);
+  const {
+    sessionId,
+    events,
+    onNotify,
+    browserWebSocketFactory,
+    computerWebSocketFactory,
+    browserExtensionSetupUrl,
+    requestedFilePath,
+    requestedFileRequestId,
+    requestedFileLine,
+    onOpenFile,
+    initialFilePath,
+    onFilePathChange,
+    isFileNodeVisible,
+    initialBrowserSessionId,
+    onBrowserSessionIdChange,
+    initialComputerSessionId,
+    onComputerSessionIdChange,
+    onOpenComputerSession,
+    requestedComputerSessionId,
+    requestedComputerRequestId
+  } = options;
+  const initialTab = options.initialTab ?? null;
+  const activeTab = options.activeTab ?? initialTab;
+  const workspaceVisible = options.workspaceVisible ?? true;
+  const machinesEnabled = options.machinesEnabled ?? true;
+  const requestedSurfaces = options.surfaces ?? WORKBENCH_SURFACES;
+  const surfaceSet = new Set(requestedSurfaces);
+  const changesEnabled = surfaceSet.has(WORKBENCH_TAB_CHANGES);
+  const filesEnabled = surfaceSet.has(WORKBENCH_TAB_FILES);
+  const terminalEnabled = surfaceSet.has(WORKBENCH_TAB_TERMINAL);
+  const browserEnabled = surfaceSet.has(WORKBENCH_TAB_BROWSER);
+  const desktopEnabled = surfaceSet.has(WORKBENCH_TAB_DESKTOP);
+  const createLinkedComputer = useCallback12(
+    async (name, placement) => {
+      const response = await client.createComputerSession(workspaceId, {
+        operationId: crypto.randomUUID(),
+        sessionId,
+        name,
+        ...placement ? { placement } : {}
+      });
+      if (response.operation.state !== "completed" || response.session.lifecycle !== "active") {
+        throw new Error(
+          response.operation.error?.message ?? t("sandboxWorkspace.theDesktopCouldNotBe")
+        );
+      }
+      return {
+        id: response.session.id,
+        placement: response.session.placement
+      };
+    },
+    [client, sessionId, workspaceId, t]
+  );
+  const workspaceDataEnabled = changesEnabled || filesEnabled;
+  const machineSurfaceEnabled = workspaceDataEnabled || terminalEnabled || desktopEnabled;
+  const resolvedActiveTab = activeTab ?? initialTab;
+  const changesActive = resolvedActiveTab === WORKBENCH_TAB_CHANGES;
+  const filesActive = resolvedActiveTab === WORKBENCH_TAB_FILES;
+  const turnInFlight = workspaceTurnInFlight(events);
+  const surfaceIdentity = WORKBENCH_SURFACES.filter((surface) => surfaceSet.has(surface)).join(",");
+  const [storedWarmIntents, setStoredWarmIntents] = useState10(
+    () => emptyWarmIntents(sessionId)
+  );
+  const warmIntents = storedWarmIntents.sessionId === sessionId ? storedWarmIntents : emptyWarmIntents(sessionId);
+  const { warmTerminal, warmFiles } = warmIntents;
+  const filesWarmRequested = warmFiles || Boolean(requestedFilePath);
+  const requestWarmIntent = useCallback12(
+    (intent) => {
+      setStoredWarmIntents((previous) => {
+        const current = previous.sessionId === sessionId ? previous : emptyWarmIntents(sessionId);
+        return current[intent] ? current : { ...current, [intent]: true };
+      });
+    },
+    [sessionId]
+  );
+  const machines = useMachines({
+    workspaceId,
+    sessionId,
+    pollIntervalMs: MACHINES_SESSION_POLL_MS,
+    enabled: machineSurfaceEnabled && machinesEnabled
+  });
+  const activeMachine = machines.machines.find((m) => m.sandboxId === machines.activeSandboxId) ?? machines.machines.find((m) => m.active) ?? null;
+  const caps = useSessionCapabilities(sessionId, {
+    events,
+    enabled: machineSurfaceEnabled,
+    attachDesktop: false,
+    attachTerminal: terminalEnabled && warmTerminal,
+    // Explicit live-file intent only — NOT "the Files tab is open". A cold edit
+    // or guarded-file open wakes the box; a glance at the tree/diff does not.
+    attachFiles: workspaceDataEnabled && filesWarmRequested
+  });
+  const capabilities = caps.capabilities;
+  const liveness = capabilities?.liveness;
+  const liveIoLiveness = liveness ?? null;
+  const fileSystemOn = capabilities?.FileSystem.available ?? false;
+  const fileSystemRoute = capabilities ? { epoch: capabilities.leaseEpoch, root: capabilities.FileSystem.root } : void 0;
+  const fsReadOnly = capabilities?.FileSystem.readOnly ?? false;
+  const filesEditable = fileSystemOn && !fsReadOnly && sandboxAcceptsLiveIo(liveness);
+  const gitOn = capabilities?.Git.available ?? false;
+  const terminalOn = terminalEnabled && (capabilities?.Terminal.transport ?? null) !== null;
+  const ptyCapable = warmTerminal && (capabilities?.Terminal.ptyCapable ?? false) && capabilities?.Terminal.transport === "sse-events" && capabilities?.Terminal.reason === null;
+  const terminalShown = terminalOn && workspaceVisible && resolvedActiveTab === WORKBENCH_TAB_TERMINAL;
+  const [terminalOpenedSession, setTerminalOpenedSession] = useState10(null);
+  useEffect10(() => {
+    if (terminalShown) setTerminalOpenedSession(sessionId);
+  }, [terminalShown, sessionId]);
+  const terminal = useSandboxTerminal(sessionId, {
+    events: terminalEnabled ? events : [],
+    interactive: terminalEnabled && ptyCapable,
+    liveness,
+    history: terminalShown || terminalOpenedSession === sessionId
+  });
+  const provisioning = sandboxProvisionInFlight(events);
+  const renegotiate = caps.renegotiate;
+  const provisioningRef = useRef10({ sessionId, provisioning });
+  useEffect10(() => {
+    const previous = provisioningRef.current;
+    if (previous.sessionId === sessionId && previous.provisioning && !provisioning) {
+      renegotiate();
+    }
+    provisioningRef.current = { sessionId, provisioning };
+  }, [sessionId, provisioning, renegotiate]);
+  useEffect10(() => {
+    if (workspaceInteractionEvent?.workspaceId !== workspaceId) return;
+    renegotiate();
+  }, [workspaceId, workspaceInteractionEvent, renegotiate]);
+  const captureState = useWorkspaceCapture(sessionId, {
+    events,
+    enabled: workspaceDataEnabled
+  });
+  const captureAvailable = captureState.available;
+  const liveWorkspaceExpected = sandboxAcceptsLiveIo(liveness);
+  const capturePending = !liveWorkspaceExpected && (captureState.fileCount === null || captureState.loading);
+  const repoPaths = useMemo8(() => {
+    const advertised = capabilities?.Git.repos ?? [];
+    if (advertised.length > 0) return advertised;
+    return captureState.capture?.repos.map((repo) => repo.root) ?? [];
+  }, [capabilities?.Git.repos, captureState.capture]);
+  const files = useSandboxFiles(sessionId, {
+    events,
+    // No passive Channel-A reads while cold, even after a conclusive capture
+    // miss. A missing capture gets an explicit "Open live workspace" gate.
+    enabled: filesEnabled && (captureAvailable || fileSystemOn && liveWorkspaceExpected),
+    // A cold sandbox can become warm while the first agent command still owns
+    // startup. Do not race that command with an automatic Files read. Keeping
+    // this fence at turn scope also avoids unsafe millisecond gaps between
+    // sequential tool calls; rendered state and explicit user actions remain.
+    active: filesActive && !turnInFlight,
+    // A deliberate canonical absolute-path open browses in the selected target's
+    // advertised namespace, so the authoritative tree and link share exact paths.
+    ...isCanonicalAbsoluteSandboxPath(requestedFilePath) && capabilities?.FileSystem.root ? { rootPath: capabilities.FileSystem.root } : {},
+    ...fileSystemRoute ? { route: fileSystemRoute } : {},
+    repoPaths,
+    liveness: liveIoLiveness,
+    capture: captureState.capture,
+    // A reverted optimistic mutation (e.g. a 409 rename collision) surfaces as a
+    // host notification — the tree silently rolls back, the user sees why.
+    onMutationError: (error, op) => onNotify?.({
+      kind: "error",
+      message: t("sandboxWorkspace.couldNotOpMessage", { op, message: error.message })
+    })
+  });
+  const [storedChangesComparison, setStoredChangesComparison] = useState10(null);
+  const captureSupportsBranch = captureState.capture !== null && captureState.capture.repos.length > 0 && captureState.capture.repos.every((repo) => repo.branchDiff !== void 0);
+  const changesComparison = storedChangesComparison?.sessionId === sessionId ? storedChangesComparison.value : liveWorkspaceExpected || captureSupportsBranch ? "branch" : "working";
+  const setChangesComparison = useCallback12(
+    (value) => setStoredChangesComparison({ sessionId, value }),
+    [sessionId]
+  );
+  const git = useSandboxGit(sessionId, {
+    events,
+    enabled: changesComparison === "working" ? workspaceDataEnabled && (captureAvailable || gitOn && liveWorkspaceExpected) : changesComparison === "branch" ? workspaceDataEnabled && (captureSupportsBranch || gitOn && liveWorkspaceExpected) : workspaceDataEnabled && gitOn && liveWorkspaceExpected,
+    // Live Git belongs to the visible Changes surface. In particular, do not
+    // turn an unresolved/default tab into a hidden provider read: that races the
+    // agent's own sandbox commands and used to refresh after every tool output
+    // even while Files was visibly selected.
+    active: changesActive && !turnInFlight,
+    repoPaths,
+    liveness: liveIoLiveness,
+    comparison: changesComparison,
+    capture: changesComparison === "staged" ? null : captureState.capture
+  });
+  useEffect10(() => {
+    if (changesComparison === "branch" && git.error && storedChangesComparison?.sessionId !== sessionId) {
+      setStoredChangesComparison({ sessionId, value: "working" });
+    }
+  }, [changesComparison, git.error, sessionId, storedChangesComparison?.sessionId]);
+  const [xtermTheme, setXtermTheme] = useState10(void 0);
+  useEffect10(() => {
+    if (!terminalEnabled || typeof document === "undefined") return;
+    const derive = () => setXtermTheme(xtermThemeFromTokens());
+    derive();
+    const observer = new MutationObserver(derive);
+    observer.observe(document.documentElement, {
+      attributes: true,
+      attributeFilter: ["data-og-theme", "class"]
+    });
+    return () => observer.disconnect();
+  }, [terminalEnabled]);
+  const dirtyCount = git.diff.length;
+  const chip = useMachineChip({
+    liveness,
+    capabilitiesState: caps.state,
+    activeMachineState: activeMachine?.state ?? null,
+    activeIsSelfhosted: activeMachine?.kind === "selfhosted",
+    wantsWarm: terminalEnabled && warmTerminal || workspaceDataEnabled && filesWarmRequested,
+    capturedAt: captureState.capturedAt
+  });
+  const workspaceWaking = chip.state === "waking";
+  const defaultIdentity = `${sessionId}\0${surfaceIdentity}`;
+  const defaultTabRef = useRef10({
+    identity: defaultIdentity,
+    value: null
+  });
+  if (defaultTabRef.current.identity !== defaultIdentity) {
+    defaultTabRef.current = { identity: defaultIdentity, value: null };
+  }
+  const captureHasChanges = (captureState.fileCount ?? 0) > 0 || (captureState.capture?.repos.some((repo) => (repo.branchDiff?.length ?? 0) > 0) ?? false);
+  const captureUnavailable = !captureState.loading && (captureState.fileCount === 0 && !captureHasChanges || captureState.error !== null);
+  if (defaultTabRef.current.value === null) {
+    if (initialTab && (!isWorkbenchSurface(initialTab) || surfaceSet.has(initialTab))) {
+      defaultTabRef.current.value = initialTab;
+    } else if (captureState.fileCount !== null && captureState.available) {
+      defaultTabRef.current.value = sourceDrivenDefaultTab(
+        captureHasChanges,
+        changesEnabled,
+        filesEnabled
+      );
+    } else if (captureUnavailable && initialWorkspaceTab(events) === WORKBENCH_TAB_CHANGES) {
+      defaultTabRef.current.value = sourceDrivenDefaultTab(true, changesEnabled, filesEnabled);
+    } else if (!captureState.loading && (captureState.fileCount !== null || captureState.error !== null)) {
+      defaultTabRef.current.value = sourceDrivenDefaultTab(false, changesEnabled, filesEnabled);
+    }
+  }
+  const defaultTab = defaultTabRef.current.value;
+  const tabs = useMemo8(() => {
+    const list = [];
+    if (changesEnabled)
+      list.push({
+        id: WORKBENCH_TAB_CHANGES,
+        label: t("sandboxWorkspace.changes"),
+        icon: /* @__PURE__ */ jsx5(GitCompareArrowsIcon, {}),
+        badge: dirtyCount > 0 ? /* @__PURE__ */ jsx5(DirtyBadge, { count: dirtyCount }) : void 0,
+        content: /* @__PURE__ */ jsx5(
+          ChangesTabBody,
+          {
+            git,
+            comparison: changesComparison,
+            onComparisonChange: setChangesComparison,
+            captureAvailable,
+            captureDegraded: captureState.degradedReason !== null,
+            captureRevision: captureState.revision,
+            capturePending,
+            liveWorkspaceExpected,
+            workspaceWaking,
+            capabilitiesState: caps.state,
+            capabilitiesError: caps.error,
+            onRetry: caps.renegotiate,
+            onWake: () => requestWarmIntent("warmFiles"),
+            ...filesEnabled && onOpenFile ? {
+              onOpenFile: (path) => {
+                requestWarmIntent("warmFiles");
+                onOpenFile(path);
+              }
+            } : {}
+          }
+        )
+      });
+    if (filesEnabled)
+      list.push({
+        id: WORKBENCH_TAB_FILES,
+        label: t("sandboxWorkspace.files"),
+        icon: /* @__PURE__ */ jsx5(FileCode2Icon, {}),
+        content: /* @__PURE__ */ jsx5(
+          FilesTabBody,
+          {
+            files,
+            git,
+            isNodeVisible: isFileNodeVisible,
+            fileSystemAvailable: fileSystemOn || captureAvailable,
+            editable: filesEditable && files.source === "live" && files.error === null && !files.loading,
+            workspaceResting: !liveWorkspaceExpected && liveness !== void 0 && !capturePending && !captureAvailable && !workspaceWaking,
+            workspaceWaking: !liveWorkspaceExpected && !captureAvailable && workspaceWaking,
+            liveWorkspaceReady: liveWorkspaceExpected,
+            workspaceError: caps.error ?? (caps.viewerCapReached ? new Error(t("sandboxWorkspace.theLiveWorkspaceViewerLimit")) : filesWarmRequested && caps.state === "on-demand" && !fileSystemOn ? new Error(t("sandboxWorkspace.thisMachineDoesNotCurrently")) : null),
+            onWakeWorkspace: () => {
+              if (filesWarmRequested) caps.renegotiate();
+              else requestWarmIntent("warmFiles");
+            },
+            ...requestedFilePath ? {
+              requestedPath: requestedFilePath,
+              ...requestedFileRequestId !== null && requestedFileRequestId !== void 0 ? { requestedPathRequestId: requestedFileRequestId } : {},
+              requestedPathReady: sandboxAcceptsLiveIo(liveness),
+              ...requestedFileLine != null && requestedFileLine > 0 ? { requestedLine: requestedFileLine } : {}
+            } : {},
+            onEditIntent: () => requestWarmIntent("warmFiles"),
+            initialSelectedPath: initialFilePath,
+            onSelectedPathChange: onFilePathChange,
+            className: "h-full"
+          },
+          sessionId
+        )
+      });
+    if (terminalOn) {
+      list.push({
+        id: WORKBENCH_TAB_TERMINAL,
+        label: t("sandboxWorkspace.terminal"),
+        icon: /* @__PURE__ */ jsx5(SquareTerminalIcon, {}),
+        content: /* @__PURE__ */ jsx5("div", { className: "h-full bg-og-bg p-1", children: /* @__PURE__ */ jsx5(
+          SandboxTerminal,
+          {
+            result: terminal,
+            terminalCapability: capabilities?.Terminal ?? null,
+            onActivate: () => requestWarmIntent("warmTerminal"),
+            onReconnectNeeded: caps.renegotiate,
+            showHeader: true,
+            shell: capabilities?.Terminal.shell ?? void 0,
+            liveness,
+            ...xtermTheme ? { theme: xtermTheme } : {}
+          },
+          sessionId
+        ) })
+      });
+    }
+    if (browserEnabled) {
+      list.push({
+        id: WORKBENCH_TAB_BROWSER,
+        label: t("sandboxWorkspace.browser"),
+        icon: /* @__PURE__ */ jsx5(Globe2Icon, {}),
+        content: /* @__PURE__ */ jsx5(Suspense, { fallback: /* @__PURE__ */ jsx5(WorkbenchSurfaceLoading, { name: "Browser" }), children: /* @__PURE__ */ jsx5(
+          LazyBrowserViewer,
+          {
+            client,
+            workspaceId,
+            sessionId,
+            enabled: workspaceVisible,
+            active: resolvedActiveTab === WORKBENCH_TAB_BROWSER,
+            onNotify,
+            initialBrowserSessionId,
+            onBrowserSessionIdChange,
+            ...desktopEnabled ? { createLinkedComputer } : {},
+            ...onOpenComputerSession ? { onOpenComputer: onOpenComputerSession } : {},
+            ...browserWebSocketFactory ? { webSocketFactory: browserWebSocketFactory } : {},
+            ...browserExtensionSetupUrl ? { browserExtensionSetupUrl } : {},
+            className: "h-full"
+          },
+          sessionId
+        ) })
+      });
+    }
+    if (desktopEnabled) {
+      list.push({
+        id: WORKBENCH_TAB_DESKTOP,
+        label: t("sandboxWorkspace.desktop"),
+        icon: /* @__PURE__ */ jsx5(MonitorIcon, {}),
+        content: /* @__PURE__ */ jsx5(Suspense, { fallback: /* @__PURE__ */ jsx5(WorkbenchSurfaceLoading, { name: "Desktop" }), children: /* @__PURE__ */ jsx5(
+          LazyComputerViewer,
+          {
+            client,
+            workspaceId,
+            sessionId,
+            enabled: workspaceVisible,
+            onNotify,
+            initialComputerSessionId,
+            onComputerSessionIdChange,
+            requestedComputerSessionId,
+            requestedComputerRequestId,
+            ...computerWebSocketFactory ? { webSocketFactory: computerWebSocketFactory } : {},
+            className: "h-full"
+          },
+          sessionId
+        ) })
+      });
+    }
+    return list;
+  }, [
+    fileSystemOn,
+    changesEnabled,
+    filesEnabled,
+    terminalOn,
+    browserEnabled,
+    desktopEnabled,
+    captureAvailable,
+    captureState.degradedReason,
+    dirtyCount,
+    warmTerminal,
+    requestedFilePath,
+    requestedFileRequestId,
+    requestedFileLine,
+    onOpenFile,
+    initialFilePath,
+    onFilePathChange,
+    isFileNodeVisible,
+    initialBrowserSessionId,
+    onBrowserSessionIdChange,
+    initialComputerSessionId,
+    onComputerSessionIdChange,
+    onOpenComputerSession,
+    requestedComputerSessionId,
+    requestedComputerRequestId,
+    onNotify,
+    browserWebSocketFactory,
+    computerWebSocketFactory,
+    workspaceVisible,
+    resolvedActiveTab,
+    client,
+    workspaceId,
+    liveness,
+    sessionId,
+    files,
+    git,
+    changesComparison,
+    terminal,
+    xtermTheme,
+    capabilities,
+    workspaceWaking,
+    caps.state,
+    caps.error,
+    caps.viewerCapReached,
+    caps.renegotiate,
+    filesWarmRequested,
+    requestWarmIntent,
+    createLinkedComputer,
+    t
+  ]);
+  return {
+    tabs,
+    defaultTab,
+    machine: {
+      enabled: machineSurfaceEnabled,
+      chip,
+      activeMachine,
+      loading: machines.loading,
+      error: machines.error,
+      refresh: machines.refresh
+    }
+  };
+}
+function SandboxWorkspace(props) {
+  const {
+    sessionId,
+    events,
+    primary,
+    surfaces,
+    machinesEnabled,
+    leadingTabs,
+    trailingTabs,
+    initialTab,
+    onActiveTabChange,
+    openTabRequest,
+    initialFilePath,
+    onFilePathChange,
+    isFileNodeVisible,
+    openFileRequest,
+    initialBrowserSessionId,
+    onBrowserSessionIdChange,
+    initialComputerSessionId,
+    onComputerSessionIdChange,
+    onNotify,
+    browserWebSocketFactory,
+    computerWebSocketFactory,
+    browserExtensionSetupUrl,
+    collapsed,
+    onCollapsedChange,
+    showCollapseControl,
+    mobileLeadingControl,
+    autoSaveId,
+    defaultSize,
+    minSize,
+    maxSize,
+    className
+  } = props;
+  const [storedSelection, setStoredSelection] = useState10(null);
+  const [requestedFile, setRequestedFile] = useState10(null);
+  const [requestedComputer, setRequestedComputer] = useState10(null);
+  const nextFileRequestId = useRef10(0);
+  const nextComputerRequestId = useRef10(0);
+  const selectedTab = storedSelection?.sessionId === sessionId ? storedSelection.tab : null;
+  const handledTabRequest = useRef10(null);
+  useEffect10(() => {
+    if (!openTabRequest || handledTabRequest.current?.sessionId === sessionId && handledTabRequest.current.requestId === openTabRequest.requestId)
+      return;
+    const available = [...leadingTabs ?? [], ...trailingTabs ?? []].some(
+      (tab) => tab.id === openTabRequest.tab
+    ) || (surfaces ?? WORKBENCH_SURFACES).some((tab) => tab === openTabRequest.tab);
+    if (!available) return;
+    handledTabRequest.current = { sessionId, requestId: openTabRequest.requestId };
+    setStoredSelection({ sessionId, tab: openTabRequest.tab });
+    onActiveTabChange?.(openTabRequest.tab);
+    onCollapsedChange?.(false);
+  }, [
+    openTabRequest,
+    sessionId,
+    leadingTabs,
+    trailingTabs,
+    surfaces,
+    onActiveTabChange,
+    onCollapsedChange
+  ]);
+  const activeTabHint = selectedTab ?? initialTab ?? leadingTabs?.[0]?.id ?? null;
+  const openFile = useCallback12(
+    (path, line) => {
+      setRequestedFile({
+        sessionId,
+        path,
+        line: line != null && line > 0 ? line : null,
+        requestId: ++nextFileRequestId.current
+      });
+      setStoredSelection({ sessionId, tab: WORKBENCH_TAB_FILES });
+      onActiveTabChange?.(WORKBENCH_TAB_FILES);
+      onFilePathChange?.(path);
+      onCollapsedChange?.(false);
+    },
+    [onActiveTabChange, onCollapsedChange, onFilePathChange, sessionId]
+  );
+  const handledOpenFileRequestId = useRef10(null);
+  useEffect10(() => {
+    if (!openFileRequest) return;
+    if (handledOpenFileRequestId.current === openFileRequest.requestId) return;
+    handledOpenFileRequestId.current = openFileRequest.requestId;
+    openFile(openFileRequest.path, openFileRequest.line);
+  }, [openFile, openFileRequest]);
+  const openComputer = useCallback12(
+    (computerSessionId) => {
+      nextComputerRequestId.current += 1;
+      setRequestedComputer({
+        sessionId,
+        computerSessionId,
+        requestId: nextComputerRequestId.current
+      });
+      setStoredSelection({ sessionId, tab: WORKBENCH_TAB_DESKTOP });
+      onActiveTabChange?.(WORKBENCH_TAB_DESKTOP);
+      onComputerSessionIdChange?.(computerSessionId);
+    },
+    [onActiveTabChange, onComputerSessionIdChange, sessionId]
+  );
+  const {
+    tabs: workbenchTabs,
+    machine,
+    defaultTab
+  } = useSandboxWorkspaceTabs({
+    ...props.client ? { client: props.client } : {},
+    ...props.workspaceId ? { workspaceId: props.workspaceId } : {},
+    sessionId,
+    events,
+    ...surfaces ? { surfaces } : {},
+    ...machinesEnabled !== void 0 ? { machinesEnabled } : {},
+    ...initialTab ? { initialTab } : {},
+    activeTab: activeTabHint,
+    workspaceVisible: collapsed !== true,
+    ...onNotify ? { onNotify } : {},
+    ...browserWebSocketFactory ? { browserWebSocketFactory } : {},
+    ...computerWebSocketFactory ? { computerWebSocketFactory } : {},
+    ...browserExtensionSetupUrl ? { browserExtensionSetupUrl } : {},
+    initialFilePath,
+    onFilePathChange,
+    isFileNodeVisible,
+    initialBrowserSessionId,
+    onBrowserSessionIdChange,
+    initialComputerSessionId,
+    onComputerSessionIdChange,
+    requestedFilePath: requestedFile?.sessionId === sessionId ? requestedFile.path : null,
+    requestedFileRequestId: requestedFile?.sessionId === sessionId ? requestedFile.requestId : null,
+    requestedFileLine: requestedFile?.sessionId === sessionId ? requestedFile.line : null,
+    onOpenFile: openFile,
+    onOpenComputerSession: openComputer,
+    requestedComputerSessionId: requestedComputer?.sessionId === sessionId ? requestedComputer.computerSessionId : null,
+    requestedComputerRequestId: requestedComputer?.sessionId === sessionId ? requestedComputer.requestId : null
+  });
+  const tabs = [...leadingTabs ?? [], ...workbenchTabs, ...trailingTabs ?? []];
+  const preferredTab = selectedTab ?? defaultTab;
+  const activeTab = preferredTab && tabs.some((tab) => tab.id === preferredTab) ? preferredTab : tabs[0]?.id;
+  const selectTab = useCallback12(
+    (tab) => {
+      setStoredSelection({ sessionId, tab });
+      onActiveTabChange?.(tab);
+    },
+    [onActiveTabChange, sessionId]
+  );
+  useEffect10(() => {
+    if (selectedTab !== null || defaultTab === null) return;
+    setStoredSelection({ sessionId, tab: defaultTab });
+  }, [defaultTab, selectedTab, sessionId]);
+  return /* @__PURE__ */ jsx5(
+    WorkspaceDock,
+    {
+      primary,
+      tabs,
+      ...activeTab !== void 0 ? { activeTab } : {},
+      onActiveTabChange: selectTab,
+      ...machine.enabled && activeTab !== WORKBENCH_TAB_BROWSER && activeTab !== WORKBENCH_TAB_DESKTOP ? {
+        headerAccessory: /* @__PURE__ */ jsx5(MachineStateChip, { chip: machine.chip })
+      } : {},
+      ...mobileLeadingControl !== void 0 ? { mobileLeadingControl } : {},
+      ...collapsed !== void 0 ? { collapsed } : {},
+      ...onCollapsedChange ? { onCollapsedChange } : {},
+      ...showCollapseControl !== void 0 ? { showCollapseControl } : {},
+      ...autoSaveId !== void 0 ? { autoSaveId } : {},
+      ...defaultSize !== void 0 ? { defaultSize } : {},
+      ...minSize !== void 0 ? { minSize } : {},
+      ...maxSize !== void 0 ? { maxSize } : {},
+      ...className !== void 0 ? { className } : {}
+    }
+  );
+}
+function DirtyBadge({ count }) {
+  return /* @__PURE__ */ jsx5("span", { className: "rounded-og-xs bg-og-accent-soft px-1 text-og-xs text-og-fg-muted", children: count });
+}
+function chipDotClass(state) {
+  if (state === "live") return "bg-og-status-running";
+  if (state === "waking") return "bg-og-status-idle animate-pulse motion-reduce:animate-none";
+  return "bg-og-fg-subtle";
+}
+function MachineStateChip({ chip }) {
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsxs4(
+    "div",
+    {
+      role: "status",
+      "aria-label": t("sandboxWorkspace.machineLabel", { label: chip.label }),
+      title: chip.label,
+      className: "inline-flex min-h-7 min-w-0 max-w-full items-center gap-1.5 px-2 py-1 text-og-xs font-medium text-og-fg-muted max-[1023px]:min-h-11 pointer-coarse:min-h-11",
+      children: [
+        /* @__PURE__ */ jsx5(
+          "span",
+          {
+            className: cn("size-1.5 shrink-0 rounded-full", chipDotClass(chip.state)),
+            "aria-hidden": true
+          }
+        ),
+        /* @__PURE__ */ jsx5("span", { className: "min-w-0 max-w-[11rem] truncate", children: chip.label })
+      ]
+    }
+  );
+}
+function DockActionButton({ onClick, children }) {
+  return /* @__PURE__ */ jsx5(
+    "button",
+    {
+      type: "button",
+      onClick,
+      className: "inline-flex items-center gap-1.5 rounded-og-sm border border-og-border px-2 py-1 text-og-xs font-medium text-og-fg-muted transition-colors hover:border-og-border-strong hover:text-og-fg focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent max-[1023px]:min-h-11 pointer-coarse:min-h-11",
+      children
+    }
+  );
+}
+function ChangesTabBody({
+  comparison,
+  onComparisonChange,
+  ...props
+}) {
+  const t = useOpenGeniText();
+  return /* @__PURE__ */ jsxs4("div", { className: "flex h-full min-h-0 flex-col", children: [
+    /* @__PURE__ */ jsx5("div", { className: "flex shrink-0 items-center gap-1 border-b border-og-border bg-og-surface-1 px-2 py-1.5", children: [
+      ["branch", t("sandboxWorkspace.branch")],
+      ["working", t("sandboxWorkspace.uncommitted")],
+      ["staged", t("sandboxWorkspace.staged")]
+    ].map(([value, label]) => /* @__PURE__ */ jsx5(
+      "button",
+      {
+        type: "button",
+        "aria-pressed": comparison === value,
+        onClick: () => onComparisonChange(value),
+        className: cn(
+          "rounded-og-sm px-2 py-1 text-og-xs font-medium transition-colors focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent max-[1023px]:min-h-11 pointer-coarse:min-h-11",
+          comparison === value ? "bg-og-surface-2 text-og-fg shadow-sm" : "text-og-fg-muted hover:bg-og-surface-2 hover:text-og-fg"
+        ),
+        children: label
+      },
+      value
+    )) }),
+    /* @__PURE__ */ jsx5("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx5(ChangesTabContent, { comparison, ...props }) })
+  ] });
+}
+function ChangesTabContent({
+  git,
+  comparison,
+  captureAvailable,
+  captureDegraded,
+  captureRevision,
+  capturePending,
+  liveWorkspaceExpected,
+  workspaceWaking,
+  capabilitiesState,
+  capabilitiesError,
+  onRetry,
+  onWake,
+  onOpenFile
+}) {
+  const t = useOpenGeniText();
+  const diff = git.diff;
+  if (diff.length > 0) {
+    return /* @__PURE__ */ jsxs4("div", { className: "flex h-full min-h-0 flex-col", children: [
+      git.error ? /* @__PURE__ */ jsxs4(
+        "div",
+        {
+          role: "status",
+          "aria-live": "polite",
+          "data-opengeni-changes-degraded": true,
+          className: "flex shrink-0 items-center gap-2 border-b border-og-status-running/30 bg-og-status-running/10 px-2 py-1.5 text-og-xs text-og-fg-muted",
+          children: [
+            /* @__PURE__ */ jsx5(TriangleAlertIcon, { className: "size-3.5 shrink-0 text-og-status-running", "aria-hidden": true }),
+            /* @__PURE__ */ jsx5("span", { className: "min-w-0 flex-1", children: git.source === "capture" ? t("sandboxWorkspace.liveChangesAreTemporarilyUnavailable") : t("sandboxWorkspace.liveRefreshFailedShowingThe") }),
+            /* @__PURE__ */ jsxs4(
+              "button",
+              {
+                type: "button",
+                onClick: () => void git.refresh(),
+                disabled: git.loading,
+                className: "inline-flex min-h-7 shrink-0 items-center gap-1 rounded-og-sm border border-og-border bg-og-surface-1 px-2 font-medium text-og-fg transition-colors hover:border-og-border-strong focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent disabled:cursor-not-allowed disabled:opacity-50 pointer-coarse:min-h-11",
+                children: [
+                  /* @__PURE__ */ jsx5(
+                    RefreshCwIcon,
+                    {
+                      className: cn("size-3", git.loading && "animate-spin motion-reduce:animate-none"),
+                      "aria-hidden": true
+                    }
+                  ),
+                  t("sandboxWorkspace.retry")
+                ]
+              }
+            )
+          ]
+        }
+      ) : null,
+      /* @__PURE__ */ jsx5("div", { className: "min-h-0 flex-1", children: /* @__PURE__ */ jsx5(
+        WorkbenchChanges,
+        {
+          diff,
+          source: git.source,
+          capturedAt: git.capturedAt,
+          captureRevision,
+          ...onOpenFile ? { onOpenFile } : {}
+        }
+      ) })
+    ] });
+  }
+  if (capabilitiesError && !captureAvailable) {
+    return /* @__PURE__ */ jsxs4(CenteredState, { icon: /* @__PURE__ */ jsx5(TriangleAlertIcon, { className: "size-5", "aria-hidden": true }), tone: "danger", children: [
+      /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: t("sandboxWorkspace.sandboxUnavailable") }),
+      /* @__PURE__ */ jsx5("p", { "data-contrast-audited": true, className: "text-og-sm leading-5 text-og-fg-muted", children: capabilitiesError.message || t("sandboxWorkspace.couldnTReachTheSandbox") }),
+      /* @__PURE__ */ jsxs4(DockActionButton, { onClick: onRetry, children: [
+        /* @__PURE__ */ jsx5(RefreshCwIcon, { className: "size-3" }),
+        t("sandboxWorkspace.retry")
+      ] })
+    ] });
+  }
+  if ((capturePending || capabilitiesState === "negotiating") && !captureAvailable && !workspaceWaking) {
+    return /* @__PURE__ */ jsxs4(
+      CenteredState,
+      {
+        icon: /* @__PURE__ */ jsx5(
+          LoaderCircleIcon,
+          {
+            className: "size-5 animate-spin motion-reduce:animate-none",
+            "aria-hidden": true
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: t("sandboxWorkspace.connectingWorkspace") }),
+          /* @__PURE__ */ jsx5("p", { className: "text-og-sm leading-5 text-og-fg-subtle", children: t("sandboxWorkspace.lookingForTheLatestFiles") })
+        ]
+      }
+    );
+  }
+  if (!liveWorkspaceExpected && (comparison !== "working" || !captureAvailable)) {
+    const previewUnavailable = captureDegraded && !captureAvailable && comparison !== "staged";
+    return /* @__PURE__ */ jsxs4(
+      CenteredState,
+      {
+        icon: workspaceWaking ? /* @__PURE__ */ jsx5(
+          LoaderCircleIcon,
+          {
+            className: "size-5 animate-spin motion-reduce:animate-none",
+            "aria-hidden": true
+          }
+        ) : previewUnavailable ? /* @__PURE__ */ jsx5(TriangleAlertIcon, { className: "size-5", "aria-hidden": true }) : /* @__PURE__ */ jsx5(CpuIcon, { className: "size-5", "aria-hidden": true }),
+        children: [
+          /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: workspaceWaking ? t("sandboxWorkspace.wakingWorkspace") : previewUnavailable ? t("sandboxWorkspace.savedChangesPreviewIsUnavailable") : t("sandboxWorkspace.workspaceIsResting") }),
+          /* @__PURE__ */ jsx5("p", { className: "text-og-sm leading-5 text-og-fg-subtle", children: workspaceWaking ? t("sandboxWorkspace.connectingToTheLiveWorking") : previewUnavailable ? t("sandboxWorkspace.openTheLiveWorkspaceTo") : comparison === "branch" ? t("sandboxWorkspace.wakeTheSandboxToCompare") : comparison === "staged" ? t("sandboxWorkspace.wakeTheSandboxToInspect") : t("sandboxWorkspace.noCapturedRevisionIsAvailable") }),
+          !workspaceWaking ? /* @__PURE__ */ jsxs4(DockActionButton, { onClick: onWake, children: [
+            /* @__PURE__ */ jsx5(CpuIcon, { className: "size-3" }),
+            t("sandboxWorkspace.openLiveWorkspace")
+          ] }) : null
+        ]
+      }
+    );
+  }
+  if (git.loading && git.source === null) {
+    return /* @__PURE__ */ jsxs4(
+      CenteredState,
+      {
+        icon: /* @__PURE__ */ jsx5(
+          LoaderCircleIcon,
+          {
+            className: "size-5 animate-spin motion-reduce:animate-none",
+            "aria-hidden": true
+          }
+        ),
+        children: [
+          /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: t("sandboxWorkspace.loadingWorkspace") }),
+          /* @__PURE__ */ jsx5("p", { className: "text-og-sm leading-5 text-og-fg-subtle", children: t("sandboxWorkspace.readingTheCurrentWorkingTree") })
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs4(CenteredState, { icon: /* @__PURE__ */ jsx5(CircleCheckIcon, { className: "size-5", "aria-hidden": true }), tone: "success", children: [
+    /* @__PURE__ */ jsx5("p", { className: "text-og-sm font-medium text-og-fg", children: comparison === "branch" ? t("sandboxWorkspace.noBranchChanges") : comparison === "staged" ? t("sandboxWorkspace.noStagedChanges") : t("sandboxWorkspace.noUncommittedChanges") }),
+    /* @__PURE__ */ jsx5("p", { className: "text-og-sm leading-5 text-og-fg-subtle", children: comparison === "branch" ? t("sandboxWorkspace.thisBranchMatchesTheRemote") : comparison === "staged" ? t("sandboxWorkspace.stageFilesToReviewThe") : t("sandboxWorkspace.localEditsNotYetCommitted") })
+  ] });
+}
+function CenteredState({
+  children,
+  icon,
+  tone = "neutral"
+}) {
+  return /* @__PURE__ */ jsx5(
+    "div",
+    {
+      role: tone === "danger" ? "alert" : "status",
+      "aria-atomic": "true",
+      "aria-live": tone === "danger" ? "assertive" : "polite",
+      className: "grid h-full place-items-center p-6 text-center",
+      children: /* @__PURE__ */ jsxs4("div", { className: "flex max-w-sm flex-col items-center gap-2.5", children: [
+        icon ? /* @__PURE__ */ jsx5(
+          "span",
+          {
+            className: cn(
+              "grid size-10 place-items-center rounded-og-lg border bg-og-surface-1 shadow-sm",
+              tone === "success" && "border-og-status-idle/30 text-og-status-idle",
+              tone === "danger" && "border-og-status-failed/30 text-og-status-failed",
+              tone === "neutral" && "border-og-border text-og-fg-muted"
+            ),
+            children: icon
+          }
+        ) : null,
+        children
+      ] })
+    }
+  );
+}
+
+// src/hooks/use-supergrok-accounts.ts
+import { useCallback as useCallback13 } from "react";
+var superGrokAccountsQueryKey = (workspaceId) => ["supergrok-accounts", workspaceId];
+var EMPTY = {
+  accounts: [],
+  activeAccountId: null,
+  settings: {
+    rotationEnabled: false,
+    rotationStrategy: "sharded",
+    activeCredentialId: null
+  }
+};
+function useSuperGrokAccounts(options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const supergrokClient = options.supergrokClient ?? client;
+  const load = useCallback13(
+    async () => await supergrokClient.listSuperGrokAccounts(workspaceId),
+    [supergrokClient, workspaceId]
+  );
+  const { data, loading, refresh } = useSharedQuery(
+    supergrokClient,
+    superGrokAccountsQueryKey(workspaceId),
+    load,
+    { enabled: options.enabled, pollIntervalMs: options.pollIntervalMs }
+  );
+  const { run, mutating: activating, mutationError } = useMutationRunner();
+  const activate = useCallback13(
+    async (accountId) => {
+      if (!supergrokClient.activateSuperGrokAccount) return false;
+      const invalidated = { current: null };
+      const result = await run(async () => {
+        await supergrokClient.activateSuperGrokAccount(workspaceId, accountId);
+        invalidated.current = invalidateSharedQueries(supergrokClient, ["supergrok-accounts"]);
+        return true;
+      });
+      if (result) await invalidated.current;
+      return result === true;
+    },
+    [run, supergrokClient, workspaceId]
+  );
+  const state = data ?? EMPTY;
+  return {
+    accounts: state.accounts,
+    activeAccountId: state.activeAccountId,
+    settings: state.settings,
+    loading,
+    refresh,
+    activate,
+    activating,
+    mutationError
+  };
+}
+
+export {
+  sessionAuthRecommendation,
+  SessionConnectionRequest,
+  useVideoArtifactPlaybackLoader,
+  useScheduledTasks,
+  useWorkspaceBackgroundCommands,
+  useWorkspaces,
+  useBillingUsage,
+  useSessionCapabilities,
+  useSandboxTerminal,
+  useSandboxGit,
+  useWorkspaceCapture,
+  useWorkspaceEdit,
+  formatAsOf,
+  deriveMachineChip,
+  useMachineChip,
+  sessionDisplayTitle,
+  FleetTile,
+  WorkbenchChanges,
+  DiffView,
+  WORKBENCH_TAB_CHANGES,
+  WORKBENCH_TAB_FILES,
+  WORKBENCH_TAB_TERMINAL,
+  WORKBENCH_TAB_BROWSER,
+  WORKBENCH_TAB_DESKTOP,
+  WORKBENCH_SURFACES,
+  initialWorkspaceTab,
+  useSandboxWorkspaceTabs,
+  SandboxWorkspace,
+  useSuperGrokAccounts,
+  asVaultClient,
+  vaultsApi,
+  vaultErrorCode,
+  vaultErrorDetail,
+  humanizeModelSlug,
+  isRawModelLabel,
+  modelDisplayName2 as modelDisplayName,
+  modelSlug,
+  modelVendor,
+  parseOpenGeniLink
+};
+//# sourceMappingURL=chunk-2Z3NQNTM.js.map