@opengeni/react 3.3.2 → 3.4.1-canary.38960406141001

package/dist/chunk-EGVHJKGJ.js

@@ -0,0 +1,3125 @@
+"use client";
+import {
+  CodeEditor
+} from "./chunk-LSW2OJVV.js";
+import {
+  useThemeType
+} from "./chunk-B27E3V37.js";
+import {
+  loadPierreDiffs,
+  pierreDiffsRevision,
+  subscribePierreDiffs
+} from "./chunk-YSRBFJMQ.js";
+import {
+  prefersReducedMotion
+} from "./chunk-OYQQJL3J.js";
+import {
+  MENU_BUTTON_CLASS,
+  MENU_SEPARATOR_CLASS,
+  MENU_SURFACE_CLASS
+} from "./chunk-PMV53IMM.js";
+import {
+  usePortalTokenSource,
+  usePortalTokenStyle
+} from "./chunk-XEA5BCMA.js";
+import {
+  useOpenGeni
+} from "./chunk-G76LSA76.js";
+import {
+  sandboxAcceptsLiveIo
+} from "./chunk-QV3DJVRZ.js";
+import {
+  cn
+} from "./chunk-TXS65BB2.js";
+
+// src/components/sandbox-files.tsx
+import { FileCode2Icon, FileWarningIcon, LoaderCircleIcon } from "lucide-react";
+import { useCallback as useCallback3, useEffect as useEffect5, useRef as useRef3, useState as useState4 } from "react";
+import { Group, Panel, Separator } from "react-resizable-panels";
+
+// src/hooks/use-sandbox-files.ts
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+var CapturedFileUnavailableError = class extends Error {
+  constructor(path, reason) {
+    super(
+      reason === "too-large" ? `${path} exceeds the captured preview limit.` : reason === "content-missing" ? `${path} is no longer available in this capture.` : `${path} was not changed in this captured turn.`
+    );
+    this.path = path;
+    this.reason = reason;
+    this.name = "CapturedFileUnavailableError";
+  }
+  code = "captured_file_unavailable";
+};
+var FileWriteConflictError = class extends Error {
+  constructor(path, expectedContent, liveContent) {
+    super(`${path} changed on the machine. Reload it or explicitly overwrite the live version.`);
+    this.path = path;
+    this.expectedContent = expectedContent;
+    this.liveContent = liveContent;
+    this.name = "FileWriteConflictError";
+  }
+  code = "file_write_conflict";
+};
+function normalizeRoot(root) {
+  const slashNormalized = root.replaceAll("\\", "/").replace(/^\.\/+/, "");
+  if (slashNormalized === "/") return "/";
+  const normalized = slashNormalized.replace(/\/+$/, "");
+  return normalized === "." ? "" : normalized;
+}
+function isAbsoluteTreePath(path) {
+  return path.startsWith("/") || /^[A-Za-z]:\//u.test(path);
+}
+function joinTreeRoot(root, path) {
+  if (!root || isAbsoluteTreePath(path)) return path;
+  return root === "/" ? `/${path}` : `${root}/${path}`;
+}
+function qualifyStatusPath(root, path, treeRoot) {
+  const normalized = normalizeRoot(root);
+  const workspaceRelative = joinTreeRoot(normalized, path);
+  return joinTreeRoot(normalizeRoot(treeRoot), workspaceRelative);
+}
+function summarizeStatuses(statuses) {
+  const repositories = statuses.filter(({ status }) => status.isRepo);
+  return {
+    branch: repositories.length === 1 ? repositories[0]?.status.head ?? null : null,
+    isRepo: repositories.length > 0,
+    repoCount: repositories.length,
+    ahead: repositories.reduce((sum, { status }) => sum + status.ahead, 0),
+    behind: repositories.reduce((sum, { status }) => sum + status.behind, 0),
+    dirtyCount: repositories.reduce((sum, { status }) => sum + status.files.length, 0)
+  };
+}
+function parentOf(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "" : path.slice(0, i);
+}
+function parentWithinTree(path, rootPath) {
+  const parent = parentOf(path);
+  return parent === "" && normalizeRoot(rootPath) === "/" && path.startsWith("/") ? "/" : parent;
+}
+function leafOf(path) {
+  const i = path.lastIndexOf("/");
+  return i < 0 ? path : path.slice(i + 1);
+}
+function sortNodes(nodes) {
+  return [...nodes].sort((a, b) => {
+    if (a.kind !== b.kind) return a.kind === "dir" ? -1 : 1;
+    return a.name.localeCompare(b.name, void 0, { sensitivity: "base" });
+  });
+}
+function fsNodeToTree(node, captureComplete = false) {
+  const kind = node.type === "dir" ? "dir" : "file";
+  const mappedChildren = node.children && node.children.length > 0 ? node.children.map((child) => fsNodeToTree(child, captureComplete)) : captureComplete && kind === "dir" ? [] : void 0;
+  return {
+    path: node.path,
+    name: node.name,
+    kind,
+    size: node.sizeBytes,
+    ...kind === "dir" ? { children: mappedChildren } : {},
+    // A collapsed residue dir from the capture index — carried through so the
+    // tree can show an inline "contents on machine" row cold instead of nothing.
+    ...kind === "dir" && node.truncated ? { truncated: true } : {}
+  };
+}
+var GIT_STATUS_TO_TREE = {
+  added: "added",
+  modified: "modified",
+  deleted: "deleted",
+  renamed: "renamed",
+  copied: "added",
+  untracked: "untracked",
+  typechange: "modified"
+};
+function replaceChildren(nodes, targetPath, children) {
+  return nodes.map((node) => {
+    if (node.path === targetPath) {
+      return { ...node, children };
+    }
+    if (node.kind === "dir" && node.children && targetPath.startsWith(`${node.path}/`)) {
+      return {
+        ...node,
+        children: replaceChildren(node.children, targetPath, children)
+      };
+    }
+    return node;
+  });
+}
+function findNodeByPath(nodes, path) {
+  for (const node of nodes) {
+    if (node.path === path) return node;
+    if (node.kind === "dir" && node.children && path.startsWith(`${node.path}/`)) {
+      const hit = findNodeByPath(node.children, path);
+      if (hit) return hit;
+    }
+  }
+  return void 0;
+}
+var FS_LIST_BATCH_REQUEST_LIMIT = 16;
+function initialDirectoryFrontier(rootPath, repoPaths) {
+  const root = normalizeRoot(rootPath);
+  const rootParts = root.split("/").filter(Boolean);
+  const rootPrefix = root.startsWith("//") ? "//" : root.startsWith("/") ? "/" : "";
+  const paths = /* @__PURE__ */ new Set();
+  for (const repoPath of repoPaths) {
+    const canonicalRepoPath = joinTreeRoot(root, normalizeRoot(repoPath));
+    const parts = canonicalRepoPath.split("/").filter(Boolean);
+    if (rootParts.some((part, index) => parts[index] !== part)) continue;
+    for (let depth = rootParts.length + 1; depth <= parts.length; depth += 1) {
+      const path = parts.slice(0, depth).join("/");
+      paths.add(`${rootPrefix}${path}`);
+    }
+  }
+  return [...paths].sort((a, b) => a.split("/").length - b.split("/").length || a.localeCompare(b)).slice(0, 8);
+}
+function parentIsLoaded(nodes, parent, rootPath = "") {
+  if (parent === normalizeRoot(rootPath)) return true;
+  const node = findNodeByPath(nodes, parent);
+  return Boolean(node && node.kind === "dir" && node.children !== void 0);
+}
+function insertNode(nodes, parent, child, rootPath = "") {
+  if (parent === normalizeRoot(rootPath)) {
+    if (nodes.some((n) => n.path === child.path)) return nodes;
+    return sortNodes([...nodes, child]);
+  }
+  return nodes.map((node) => {
+    if (node.path === parent) {
+      if (node.kind !== "dir" || node.children === void 0) return node;
+      if (node.children.some((n) => n.path === child.path)) return node;
+      return { ...node, children: sortNodes([...node.children, child]) };
+    }
+    if (node.kind === "dir" && node.children && parent.startsWith(`${node.path}/`)) {
+      return { ...node, children: insertNode(node.children, parent, child, rootPath) };
+    }
+    return node;
+  });
+}
+function removeNode(nodes, path, rootPath = "") {
+  const parent = parentWithinTree(path, rootPath);
+  if (parent === normalizeRoot(rootPath)) {
+    if (!nodes.some((n) => n.path === path)) return nodes;
+    return nodes.filter((n) => n.path !== path);
+  }
+  return nodes.map((node) => {
+    if (node.path === parent) {
+      if (node.kind !== "dir" || node.children === void 0) return node;
+      return {
+        ...node,
+        children: node.children.filter((n) => n.path !== path)
+      };
+    }
+    if (node.kind === "dir" && node.children && parent.startsWith(`${node.path}/`)) {
+      return { ...node, children: removeNode(node.children, path, rootPath) };
+    }
+    return node;
+  });
+}
+function sameNodeShallow(a, b) {
+  return a.path === b.path && a.kind === b.kind && a.name === b.name && (a.size ?? null) === (b.size ?? null) && (a.status ?? void 0) === (b.status ?? void 0) && (a.truncated ?? false) === (b.truncated ?? false);
+}
+function mergeChildren(current, listed) {
+  const byPath = new Map(current.map((n) => [n.path, n]));
+  const merged = listed.map((next) => {
+    const existing = byPath.get(next.path);
+    if (!existing) return next;
+    if (existing.kind === "dir" && next.kind === "dir" && existing.children !== void 0) {
+      const candidate = { ...next, children: existing.children };
+      return sameNodeShallow(existing, candidate) ? existing : candidate;
+    }
+    if (existing.children === next.children && sameNodeShallow(existing, next)) {
+      return existing;
+    }
+    return next;
+  });
+  return sortNodes(merged);
+}
+function mergeRootChildren(nodes, listed) {
+  return mergeChildren(nodes, listed);
+}
+function repathNode(node, fromPrefix, toPrefix) {
+  const newPath = toPrefix + node.path.slice(fromPrefix.length);
+  const next = { ...node, path: newPath, name: leafOf(newPath) };
+  if (node.children) next.children = node.children.map((c) => repathNode(c, fromPrefix, toPrefix));
+  return next;
+}
+function decodeBase64Bytes(value) {
+  const binary = atob(value);
+  const bytes = new Uint8Array(binary.length);
+  for (let index = 0; index < binary.length; index += 1) {
+    bytes[index] = binary.charCodeAt(index);
+  }
+  return bytes;
+}
+function decodeBase64Text(value) {
+  return new TextDecoder().decode(decodeBase64Bytes(value));
+}
+function encodeBase64Bytes(bytes) {
+  let binary = "";
+  const chunkSize = 32768;
+  for (let offset = 0; offset < bytes.length; offset += chunkSize) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + chunkSize));
+  }
+  return btoa(binary);
+}
+async function assertCapturedHash(bytes, expected) {
+  if (!expected) throw new Error("Captured file is missing its integrity hash.");
+  if (!globalThis.crypto?.subtle) {
+    throw new Error("Captured file integrity verification is unavailable in this browser.");
+  }
+  const buffer = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(buffer).set(bytes);
+  const digest = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-256", buffer));
+  const actual = [...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("");
+  if (actual !== expected) throw new Error("Captured file content failed its integrity check.");
+}
+function useSandboxFiles(sessionId, options = {}) {
+  const { client, workspaceId } = useOpenGeni(options);
+  const enabled = (options.enabled ?? true) && Boolean(sessionId);
+  const active = options.active ?? true;
+  const rootPath = options.rootPath ?? "";
+  const routeEpoch = options.route?.epoch ?? null;
+  const routeRoot = options.route?.root ?? null;
+  const route = useMemo(
+    () => routeEpoch !== null && routeRoot !== null ? { epoch: routeEpoch, root: routeRoot } : void 0,
+    [routeEpoch, routeRoot]
+  );
+  const repoPathsKey = [
+    ...new Set((options.repoPaths?.length ? options.repoPaths : [rootPath]).map(normalizeRoot))
+  ].join("\0");
+  const repoPaths = useMemo(() => repoPathsKey.split("\0"), [repoPathsKey]);
+  const capture = options.capture ?? null;
+  const isLive = sandboxAcceptsLiveIo(options.liveness);
+  const acceptsEventReads = options.liveness === void 0 || isLive;
+  const acceptsEventReadsRef = useRef(acceptsEventReads);
+  acceptsEventReadsRef.current = acceptsEventReads;
+  const hasLiveIoFence = options.liveness !== void 0;
+  const identityKey = `${workspaceId}\0${sessionId ?? ""}\0${rootPath}\0${repoPathsKey}\0${routeEpoch ?? ""}\0${routeRoot ?? ""}`;
+  const [tree, setTree] = useState([]);
+  const treeRef = useRef([]);
+  const [loading, setLoading] = useState(false);
+  const [expandingPaths, setExpandingPaths] = useState(/* @__PURE__ */ new Set());
+  const [error, setError] = useState(null);
+  const [gitSummary, setGitSummary] = useState(null);
+  const [gitLoading, setGitLoading] = useState(false);
+  const [contentRevision, setContentRevision] = useState(0);
+  const [stateIdentity, setStateIdentity] = useState(identityKey);
+  const [source, setSource] = useState(null);
+  const sourceRef = useRef(null);
+  const statusRef = useRef(/* @__PURE__ */ new Map());
+  const refreshGenerationRef = useRef(0);
+  const refreshAbortRef = useRef(null);
+  const identityAbortRef = useRef(new AbortController());
+  const eventReadAbortRef = useRef(new AbortController());
+  const identityGenerationRef = useRef(0);
+  const lastSeqRef = useRef(0);
+  const pendingParentsRef = useRef(/* @__PURE__ */ new Set());
+  const pendingGitRef = useRef(false);
+  const eventReconcileInFlightRef = useRef(null);
+  const eventReconcilePendingRef = useRef(false);
+  const debounceRef = useRef(null);
+  const ownRevisionsRef = useRef(/* @__PURE__ */ new Set());
+  const onMutationError = options.onMutationError;
+  treeRef.current = tree;
+  const applyStatus = useCallback((nodes) => {
+    const overlay = statusRef.current;
+    const walk = (list) => {
+      let changed = false;
+      const out = list.map((node) => {
+        const nextChildren = node.children ? walk(node.children) : node.children;
+        const wantStatus = node.kind === "file" ? overlay.get(node.path) : void 0;
+        const childrenChanged = nextChildren !== node.children;
+        const statusChanged = (node.status ?? void 0) !== (wantStatus ?? void 0);
+        if (!childrenChanged && !statusChanged) return node;
+        changed = true;
+        const next = {
+          ...node,
+          ...node.children ? { children: nextChildren } : {}
+        };
+        if (wantStatus) next.status = wantStatus;
+        else delete next.status;
+        return next;
+      });
+      return changed ? out : list;
+    };
+    return walk(nodes);
+  }, []);
+  const refresh = useCallback(async () => {
+    if (!sessionId) return;
+    refreshAbortRef.current?.abort();
+    const refreshAbort = new AbortController();
+    refreshAbortRef.current = refreshAbort;
+    const generation = refreshGenerationRef.current += 1;
+    setLoading(true);
+    setGitLoading(true);
+    setError(null);
+    try {
+      const frontierPaths = initialDirectoryFrontier(rootPath, repoPaths);
+      const listRequests = [rootPath, ...frontierPaths].map((path) => ({
+        path,
+        depth: 1,
+        ...route ? { route } : {}
+      }));
+      const listedBatch = await client.fsListBatch(
+        workspaceId,
+        sessionId,
+        { requests: listRequests },
+        { signal: refreshAbort.signal }
+      );
+      if (refreshGenerationRef.current !== generation) return;
+      const listed = listedBatch.results[0];
+      if (!listed) throw new Error("Workspace list batch did not return the root result.");
+      const children = (listed.root.children ?? []).map((node) => fsNodeToTree(node));
+      setTree((prev) => {
+        let hydrated = prev.length === 0 ? children : mergeRootChildren(prev, children);
+        for (const [index, path] of frontierPaths.entries()) {
+          const prefetched = listedBatch.results[index + 1];
+          if (!prefetched) continue;
+          hydrated = replaceChildren(
+            hydrated,
+            path,
+            (prefetched.root.children ?? []).map((node) => fsNodeToTree(node))
+          );
+        }
+        return applyStatus(hydrated);
+      });
+      sourceRef.current = "live";
+      setSource("live");
+      setLoading(false);
+      const statuses = repoPaths.length > 0 ? await client.gitReadBatch(
+        workspaceId,
+        sessionId,
+        {
+          requests: repoPaths.map((root) => ({
+            status: { path: root }
+          }))
+        },
+        { signal: refreshAbort.signal }
+      ).then(
+        (batch) => batch.results.map((result, index) => ({
+          root: repoPaths[index] ?? "",
+          status: result.status
+        }))
+      ).catch(() => null) : [];
+      if (refreshGenerationRef.current !== generation) return;
+      if (statuses) {
+        const overlay = /* @__PURE__ */ new Map();
+        for (const { root, status } of statuses) {
+          for (const file of status.files) {
+            const code = file.worktree ?? file.index;
+            const mapped = code ? GIT_STATUS_TO_TREE[code] : void 0;
+            if (mapped) overlay.set(qualifyStatusPath(root, file.path, rootPath), mapped);
+          }
+        }
+        statusRef.current = overlay;
+        setGitSummary(summarizeStatuses(statuses));
+      } else {
+        statusRef.current = /* @__PURE__ */ new Map();
+        setGitSummary(null);
+      }
+      setGitLoading(false);
+      setTree((prev) => applyStatus(prev));
+    } catch (cause) {
+      if (refreshGenerationRef.current !== generation) return;
+      setError(cause instanceof Error ? cause : new Error(String(cause)));
+    } finally {
+      if (refreshGenerationRef.current === generation) setLoading(false);
+      if (refreshGenerationRef.current === generation) setGitLoading(false);
+      if (refreshAbortRef.current === refreshAbort) refreshAbortRef.current = null;
+    }
+  }, [client, workspaceId, sessionId, rootPath, repoPaths, route, applyStatus]);
+  const seedFromCapture = useCallback(
+    (manifest) => {
+      const overlay = /* @__PURE__ */ new Map();
+      for (const file of manifest.files) {
+        if (file.deleted) continue;
+        const mapped = GIT_STATUS_TO_TREE[file.status];
+        if (mapped) overlay.set(file.path, mapped);
+      }
+      statusRef.current = overlay;
+      const children = (manifest.treeIndex.children ?? []).map((node) => fsNodeToTree(node, true));
+      setTree(
+        (prev) => applyStatus(prev.length === 0 ? children : mergeRootChildren(prev, children))
+      );
+      sourceRef.current = "capture";
+      setSource("capture");
+      setGitSummary({
+        branch: manifest.repos.length === 1 ? manifest.repos[0]?.head ?? null : null,
+        isRepo: manifest.repos.length > 0,
+        repoCount: manifest.repos.length,
+        ahead: manifest.repos.reduce((sum, repo) => sum + repo.ahead, 0),
+        behind: manifest.repos.reduce((sum, repo) => sum + repo.behind, 0),
+        dirtyCount: manifest.files.length
+      });
+      setGitLoading(false);
+      setError(null);
+    },
+    [applyStatus]
+  );
+  const expand = useCallback(
+    async (path) => {
+      if (!sessionId) return;
+      if (source === "capture" && capture) return;
+      const identityGeneration = identityGenerationRef.current;
+      const identitySignal = identityAbortRef.current.signal;
+      setExpandingPaths((prev) => {
+        const next = new Set(prev);
+        next.add(path);
+        return next;
+      });
+      try {
+        const listed = await client.fsList(
+          workspaceId,
+          sessionId,
+          { path, depth: 1, ...route ? { route } : {} },
+          { signal: identitySignal }
+        );
+        if (identityGenerationRef.current !== identityGeneration) return;
+        const children = (listed.root.children ?? []).map((node) => fsNodeToTree(node));
+        setTree((prev) => applyStatus(replaceChildren(prev, path, children)));
+      } catch (cause) {
+        if (identityGenerationRef.current !== identityGeneration) return;
+        setError(cause instanceof Error ? cause : new Error(String(cause)));
+      } finally {
+        if (identityGenerationRef.current === identityGeneration) {
+          setExpandingPaths((prev) => {
+            if (!prev.has(path)) return prev;
+            const next = new Set(prev);
+            next.delete(path);
+            return next;
+          });
+        }
+      }
+    },
+    [client, workspaceId, sessionId, capture, source, route, applyStatus]
+  );
+  const readFile = useCallback(
+    async (path, requestOptions = {}) => {
+      if (!sessionId) throw new Error("no session");
+      const identitySignal = identityAbortRef.current.signal;
+      const signal = requestOptions.signal ? AbortSignal.any([identitySignal, requestOptions.signal]) : identitySignal;
+      const captured = capture?.files.find((file) => file.path === path && !file.deleted);
+      if (source === "capture" && capture) {
+        if (!captured) {
+          throw new CapturedFileUnavailableError(path, "not-captured");
+        }
+        for (let attempt = 0; attempt < 2; attempt += 1) {
+          const result = await client.getWorkspaceCaptureFile(
+            workspaceId,
+            sessionId,
+            path,
+            capture.revision,
+            { signal }
+          );
+          if (result.path !== path || result.revision !== capture.revision) {
+            throw new Error(
+              "Captured file identity did not match the requested workspace revision."
+            );
+          }
+          if (result.hash !== captured.hash || result.sizeBytes !== captured.sizeBytes || result.isBinary !== captured.isBinary || result.tooLarge !== captured.tooLarge) {
+            throw new Error("Captured file metadata did not match its manifest.");
+          }
+          if (result.tooLarge) {
+            throw new CapturedFileUnavailableError(path, "too-large");
+          }
+          let bytes;
+          let encoding;
+          let content;
+          if (result.content !== null && result.encoding !== null) {
+            encoding = result.encoding;
+            content = result.content;
+            bytes = encoding === "base64" ? decodeBase64Bytes(content) : new TextEncoder().encode(content);
+          } else if (result.contentUrl) {
+            const response = await fetch(result.contentUrl.url, {
+              credentials: "omit",
+              cache: "no-store",
+              referrerPolicy: "no-referrer",
+              signal: AbortSignal.any([signal, AbortSignal.timeout(3e4)])
+            }).catch(() => null);
+            if (!response?.ok) {
+              if (attempt === 0 && (response === null || response.status === 401 || response.status === 403)) {
+                continue;
+              }
+              throw new Error("Captured file download failed.");
+            }
+            bytes = new Uint8Array(await response.arrayBuffer());
+            encoding = result.isBinary ? "base64" : "utf8";
+            content = result.isBinary ? encodeBase64Bytes(bytes) : new TextDecoder().decode(bytes);
+          } else {
+            throw new CapturedFileUnavailableError(path, "content-missing");
+          }
+          if (bytes.byteLength !== result.sizeBytes) {
+            throw new Error("Captured file size did not match its manifest.");
+          }
+          await assertCapturedHash(bytes, result.hash);
+          return {
+            path,
+            encoding,
+            content,
+            sizeBytes: result.sizeBytes,
+            truncated: false,
+            isBinary: result.isBinary,
+            revision: result.revision
+          };
+        }
+        throw new Error("Captured file download failed after refreshing its URL.");
+      }
+      return await client.fsRead(
+        workspaceId,
+        sessionId,
+        { path, ...route ? { route } : {} },
+        { signal }
+      );
+    },
+    [client, workspaceId, sessionId, capture, source, route]
+  );
+  const reconcilePath = useCallback(
+    async (path, requestSignal) => {
+      if (!sessionId) return;
+      const identityGeneration = identityGenerationRef.current;
+      const identitySignal = identityAbortRef.current.signal;
+      const signal = requestSignal ? AbortSignal.any([identitySignal, requestSignal]) : identitySignal;
+      if (!parentIsLoaded(treeRef.current, path, rootPath)) return;
+      try {
+        const listed = await client.fsList(
+          workspaceId,
+          sessionId,
+          { path, depth: 1, ...route ? { route } : {} },
+          { signal }
+        );
+        if (identityGenerationRef.current !== identityGeneration) return;
+        const children = (listed.root.children ?? []).map((node) => fsNodeToTree(node));
+        if (path === normalizeRoot(rootPath)) {
+          setTree((prev) => applyStatus(mergeRootChildren(prev, children)));
+        } else
+          setTree((prev) => {
+            const existing = findNodeByPath(prev, path);
+            const merged = existing?.children ? mergeChildren(existing.children, children) : children;
+            return applyStatus(replaceChildren(prev, path, merged));
+          });
+      } catch {
+      }
+    },
+    [client, workspaceId, sessionId, rootPath, route, applyStatus]
+  );
+  const reconcilePaths = useCallback(
+    async (requestedPaths, requestSignal) => {
+      if (!sessionId) return;
+      const identityGeneration = identityGenerationRef.current;
+      const identitySignal = identityAbortRef.current.signal;
+      const signal = requestSignal ? AbortSignal.any([identitySignal, requestSignal]) : identitySignal;
+      const paths = [...new Set(requestedPaths)].filter(
+        (path) => parentIsLoaded(treeRef.current, path, rootPath)
+      );
+      for (let offset = 0; offset < paths.length; offset += FS_LIST_BATCH_REQUEST_LIMIT) {
+        const chunk = paths.slice(offset, offset + FS_LIST_BATCH_REQUEST_LIMIT);
+        try {
+          const listed = await client.fsListBatch(
+            workspaceId,
+            sessionId,
+            {
+              requests: chunk.map((path) => ({
+                path,
+                depth: 1,
+                ...route ? { route } : {}
+              }))
+            },
+            { signal }
+          );
+          if (identityGenerationRef.current !== identityGeneration) return;
+          setTree((previous) => {
+            let next = previous;
+            for (const [index, path] of chunk.entries()) {
+              const result = listed.results[index];
+              if (!result) continue;
+              const children = (result.root.children ?? []).map((node) => fsNodeToTree(node));
+              if (path === normalizeRoot(rootPath)) {
+                next = mergeRootChildren(next, children);
+              } else {
+                const existing = findNodeByPath(next, path);
+                const merged = existing?.children ? mergeChildren(existing.children, children) : children;
+                next = replaceChildren(next, path, merged);
+              }
+            }
+            return applyStatus(next);
+          });
+        } catch {
+        }
+      }
+    },
+    [client, workspaceId, sessionId, rootPath, route, applyStatus]
+  );
+  const runOptimistic = useCallback(
+    async (opName, apply, op, reconcileParents) => {
+      const identityGeneration = identityGenerationRef.current;
+      const snapshot = treeRef.current;
+      setError(null);
+      setTree(applyStatus(apply(snapshot)));
+      try {
+        const res = await op();
+        if (identityGenerationRef.current !== identityGeneration) return res;
+        if (res && typeof res === "object" && "revision" in res) {
+          const rev = res.revision;
+          if (typeof rev === "number") ownRevisionsRef.current.add(rev);
+        }
+        for (const parent of reconcileParents) {
+          if (identityGenerationRef.current !== identityGeneration) return res;
+          await reconcilePath(parent);
+        }
+        return res;
+      } catch (cause) {
+        const err = cause instanceof Error ? cause : new Error(String(cause));
+        if (identityGenerationRef.current !== identityGeneration) throw err;
+        setTree(applyStatus(snapshot));
+        if (err instanceof FileWriteConflictError) throw err;
+        setError(err);
+        onMutationError?.(err, opName);
+        throw err;
+      }
+    },
+    [applyStatus, reconcilePath, onMutationError]
+  );
+  const writeFile = useCallback(
+    async (path, content, writeOptions = {}) => {
+      if (!sessionId) throw new Error("no session");
+      const identityGeneration = identityGenerationRef.current;
+      const identitySignal = identityAbortRef.current.signal;
+      const parent = parentWithinTree(path, rootPath);
+      const exists = Boolean(findNodeByPath(tree, path));
+      const node = {
+        path,
+        name: leafOf(path),
+        kind: "file",
+        size: content.length
+      };
+      return await runOptimistic(
+        "write",
+        (nodes) => exists ? nodes : insertNode(nodes, parent, node, rootPath),
+        async () => {
+          if (!writeOptions.force && writeOptions.expectedContent !== void 0) {
+            const live = await client.fsRead(
+              workspaceId,
+              sessionId,
+              { path, ...route ? { route } : {} },
+              { signal: identitySignal }
+            );
+            if (identityGenerationRef.current !== identityGeneration) {
+              throw new Error("File save cancelled because the workspace changed.");
+            }
+            const liveContent = live.encoding === "base64" ? decodeBase64Text(live.content) : live.content;
+            if (live.truncated || live.isBinary || liveContent !== writeOptions.expectedContent) {
+              throw new FileWriteConflictError(path, writeOptions.expectedContent, liveContent);
+            }
+          }
+          if (identityGenerationRef.current !== identityGeneration) {
+            throw new Error("File save cancelled because the workspace changed.");
+          }
+          return await client.fsWrite(workspaceId, sessionId, {
+            path,
+            content,
+            overwrite: true,
+            ...route ? { route } : {}
+          });
+        },
+        exists ? [] : [parent]
+      );
+    },
+    [client, workspaceId, sessionId, tree, rootPath, route, runOptimistic]
+  );
+  const createFile = useCallback(
+    async (path) => {
+      if (!sessionId) throw new Error("no session");
+      const parent = parentWithinTree(path, rootPath);
+      const node = {
+        path,
+        name: leafOf(path),
+        kind: "file",
+        size: 0
+      };
+      await runOptimistic(
+        "create file",
+        (nodes) => insertNode(nodes, parent, node, rootPath),
+        () => client.fsWrite(workspaceId, sessionId, {
+          path,
+          content: "",
+          overwrite: false,
+          ...route ? { route } : {}
+        }),
+        [parent]
+      );
+    },
+    [client, workspaceId, sessionId, rootPath, route, runOptimistic]
+  );
+  const createDir = useCallback(
+    async (path) => {
+      if (!sessionId) throw new Error("no session");
+      const parent = parentWithinTree(path, rootPath);
+      const node = {
+        path,
+        name: leafOf(path),
+        kind: "dir",
+        children: []
+      };
+      await runOptimistic(
+        "create folder",
+        (nodes) => insertNode(nodes, parent, node, rootPath),
+        () => client.fsMkdir(workspaceId, sessionId, {
+          path,
+          recursive: true,
+          ...route ? { route } : {}
+        }),
+        [parent]
+      );
+    },
+    [client, workspaceId, sessionId, rootPath, route, runOptimistic]
+  );
+  const deleteEntry = useCallback(
+    async (path, recursive = false) => {
+      if (!sessionId) throw new Error("no session");
+      await runOptimistic(
+        "delete",
+        (nodes) => removeNode(nodes, path, rootPath),
+        () => client.fsDelete(workspaceId, sessionId, {
+          path,
+          recursive,
+          ...route ? { route } : {}
+        }),
+        [parentWithinTree(path, rootPath)]
+      );
+    },
+    [client, workspaceId, sessionId, rootPath, route, runOptimistic]
+  );
+  const moveEntry = useCallback(
+    async (path, newPath, opts) => {
+      if (!sessionId) throw new Error("no session");
+      const from = parentWithinTree(path, rootPath);
+      const to = parentWithinTree(newPath, rootPath);
+      await runOptimistic(
+        "move",
+        (nodes) => {
+          const moving = findNodeByPath(nodes, path);
+          if (!moving) return nodes;
+          const moved = repathNode(moving, path, newPath);
+          return insertNode(removeNode(nodes, path, rootPath), to, moved, rootPath);
+        },
+        () => client.fsMove(workspaceId, sessionId, {
+          path,
+          newPath,
+          overwrite: opts?.overwrite ?? false,
+          ...route ? { route } : {}
+        }),
+        to === from ? [from] : [from, to]
+      );
+    },
+    [client, workspaceId, sessionId, rootPath, route, runOptimistic]
+  );
+  const captureRef = useRef(capture);
+  captureRef.current = capture;
+  const captureRevision = capture?.revision ?? null;
+  const previousIdentityRef = useRef(identityKey);
+  useEffect(() => {
+    refreshAbortRef.current?.abort();
+    refreshAbortRef.current = null;
+    refreshGenerationRef.current += 1;
+    eventReadAbortRef.current.abort();
+    eventReadAbortRef.current = new AbortController();
+    const identityChanged = previousIdentityRef.current !== identityKey;
+    previousIdentityRef.current = identityKey;
+    if (identityChanged || !enabled) {
+      if (identityChanged) eventReconcileInFlightRef.current = null;
+      identityAbortRef.current.abort();
+      identityAbortRef.current = new AbortController();
+      identityGenerationRef.current += 1;
+      lastSeqRef.current = 0;
+      pendingParentsRef.current = /* @__PURE__ */ new Set();
+      pendingGitRef.current = false;
+      eventReconcilePendingRef.current = false;
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+        debounceRef.current = null;
+      }
+      ownRevisionsRef.current = /* @__PURE__ */ new Set();
+      statusRef.current = /* @__PURE__ */ new Map();
+      treeRef.current = [];
+      setTree([]);
+      setStateIdentity(identityKey);
+      setExpandingPaths(/* @__PURE__ */ new Set());
+      sourceRef.current = null;
+      setSource(null);
+      setLoading(false);
+      setError(null);
+      setGitSummary(null);
+      setGitLoading(false);
+      setContentRevision(0);
+    }
+    if (!enabled) {
+      return;
+    }
+    const currentCapture = captureRevision !== null ? captureRef.current : null;
+    if (currentCapture && (identityChanged || !isLive || sourceRef.current !== "live")) {
+      seedFromCapture(currentCapture);
+    }
+    if (!active) {
+      if (!active) {
+        setLoading(false);
+        setGitLoading(false);
+      }
+      return;
+    }
+    if (isLive || !hasLiveIoFence && !currentCapture) {
+      void refresh();
+    }
+    return () => {
+      refreshAbortRef.current?.abort();
+      refreshAbortRef.current = null;
+      refreshGenerationRef.current += 1;
+      eventReadAbortRef.current.abort();
+      eventReconcilePendingRef.current = false;
+    };
+  }, [
+    enabled,
+    active,
+    isLive,
+    hasLiveIoFence,
+    captureRevision,
+    identityKey,
+    refresh,
+    seedFromCapture
+  ]);
+  const refreshGitOverlay = useCallback(
+    async (requestSignal) => {
+      if (!sessionId) return;
+      const identityGeneration = identityGenerationRef.current;
+      const identitySignal = identityAbortRef.current.signal;
+      const signal = requestSignal ? AbortSignal.any([identitySignal, requestSignal]) : identitySignal;
+      setGitLoading(true);
+      try {
+        const batch = await client.gitReadBatch(
+          workspaceId,
+          sessionId,
+          { requests: repoPaths.map((root) => ({ status: { path: root } })) },
+          { signal }
+        );
+        const statuses = batch.results.map((result, index) => ({
+          root: repoPaths[index] ?? "",
+          status: result.status
+        }));
+        if (identityGenerationRef.current !== identityGeneration) return;
+        const overlay = /* @__PURE__ */ new Map();
+        for (const { root, status } of statuses) {
+          for (const file of status.files) {
+            const code = file.worktree ?? file.index;
+            const mapped = code ? GIT_STATUS_TO_TREE[code] : void 0;
+            if (mapped) overlay.set(qualifyStatusPath(root, file.path, rootPath), mapped);
+          }
+        }
+        statusRef.current = overlay;
+        setGitSummary(summarizeStatuses(statuses));
+        setTree((prev) => applyStatus(prev));
+      } catch {
+      } finally {
+        if (identityGenerationRef.current === identityGeneration) setGitLoading(false);
+      }
+    },
+    [client, workspaceId, sessionId, repoPaths, rootPath, applyStatus]
+  );
+  const performEventReconcile = useCallback(async () => {
+    const parents = pendingParentsRef.current;
+    pendingParentsRef.current = /* @__PURE__ */ new Set();
+    const wantGit = pendingGitRef.current;
+    pendingGitRef.current = false;
+    const signal = eventReadAbortRef.current.signal;
+    const paths = [...parents];
+    await reconcilePaths(paths, signal);
+    if (wantGit) await refreshGitOverlay(signal);
+  }, [reconcilePaths, refreshGitOverlay]);
+  const performEventReconcileRef = useRef(performEventReconcile);
+  performEventReconcileRef.current = performEventReconcile;
+  const reconcilePendingEvents = useCallback(async () => {
+    eventReconcilePendingRef.current = true;
+    const existing = eventReconcileInFlightRef.current;
+    if (existing) return await existing;
+    const identityGeneration = identityGenerationRef.current;
+    const run = (async () => {
+      while (eventReconcilePendingRef.current && identityGenerationRef.current === identityGeneration) {
+        eventReconcilePendingRef.current = false;
+        await performEventReconcileRef.current();
+      }
+    })();
+    eventReconcileInFlightRef.current = run;
+    try {
+      await run;
+    } finally {
+      if (eventReconcileInFlightRef.current === run) eventReconcileInFlightRef.current = null;
+    }
+  }, []);
+  const events = options.events;
+  useEffect(() => {
+    if (!enabled || !events) return;
+    if (!active || !acceptsEventReads) {
+      for (const event of events) {
+        if (event.sequence > lastSeqRef.current) lastSeqRef.current = event.sequence;
+      }
+      if (debounceRef.current) {
+        clearTimeout(debounceRef.current);
+        debounceRef.current = null;
+      }
+      pendingParentsRef.current = /* @__PURE__ */ new Set();
+      pendingGitRef.current = false;
+      eventReconcilePendingRef.current = false;
+      return;
+    }
+    let sawNew = false;
+    let contentChanged = false;
+    for (const event of events) {
+      if (event.sequence <= lastSeqRef.current) continue;
+      if (event.type === "fs.changed") {
+        sawNew = true;
+        const payload = event.payload;
+        if (!payload || typeof payload !== "object") continue;
+        if (payload.source === "write") continue;
+        if (typeof payload.revision === "number" && ownRevisionsRef.current.has(payload.revision))
+          continue;
+        contentChanged = true;
+        for (const change of payload.changes ?? []) {
+          pendingParentsRef.current.add(parentWithinTree(change.path, rootPath));
+          if (change.oldPath) {
+            pendingParentsRef.current.add(parentWithinTree(change.oldPath, rootPath));
+          }
+        }
+      } else if (event.type === "git.changed") {
+        sawNew = true;
+        const payload = event.payload;
+        if (payload && typeof payload === "object" && typeof payload.revision === "number" && ownRevisionsRef.current.has(payload.revision))
+          continue;
+        pendingGitRef.current = true;
+      }
+    }
+    for (const event of events)
+      if (event.sequence > lastSeqRef.current) lastSeqRef.current = event.sequence;
+    if (!sawNew) return;
+    if (contentChanged) setContentRevision((revision) => revision + 1);
+    if (debounceRef.current) clearTimeout(debounceRef.current);
+    const identityGeneration = identityGenerationRef.current;
+    debounceRef.current = setTimeout(() => {
+      debounceRef.current = null;
+      if (identityGenerationRef.current !== identityGeneration) return;
+      if (!acceptsEventReadsRef.current) {
+        pendingParentsRef.current = /* @__PURE__ */ new Set();
+        pendingGitRef.current = false;
+        return;
+      }
+      void reconcilePendingEvents();
+    }, 150);
+  }, [enabled, active, acceptsEventReads, events, rootPath, reconcilePendingEvents]);
+  useEffect(() => {
+    if (active && acceptsEventReads) return;
+    if (debounceRef.current) {
+      clearTimeout(debounceRef.current);
+      debounceRef.current = null;
+    }
+    pendingParentsRef.current = /* @__PURE__ */ new Set();
+    pendingGitRef.current = false;
+    eventReconcilePendingRef.current = false;
+  }, [active, acceptsEventReads]);
+  useEffect(
+    () => () => {
+      refreshAbortRef.current?.abort();
+      identityAbortRef.current.abort();
+      eventReadAbortRef.current.abort();
+      eventReconcilePendingRef.current = false;
+      identityGenerationRef.current += 1;
+      if (debounceRef.current) clearTimeout(debounceRef.current);
+    },
+    []
+  );
+  const identityMatches = enabled && stateIdentity === identityKey;
+  return {
+    tree: identityMatches ? tree : [],
+    expand,
+    expandingPaths: identityMatches ? expandingPaths : /* @__PURE__ */ new Set(),
+    readFile,
+    writeFile,
+    createFile,
+    createDir,
+    deleteEntry,
+    moveEntry,
+    refresh,
+    contentRevision: identityMatches ? contentRevision : 0,
+    source: identityMatches ? source : null,
+    capturedAt: identityMatches && source === "capture" ? capture?.capturedAt ?? null : null,
+    gitSummary: identityMatches ? gitSummary : null,
+    gitLoading: identityMatches && gitLoading,
+    loading: identityMatches && loading,
+    error: identityMatches ? error : null
+  };
+}
+
+// src/file-node-visibility.ts
+function pathIsInsideDirectory(path, directory) {
+  if (!path.startsWith(directory) || path === directory) return false;
+  if (directory.endsWith("/") || directory.endsWith("\\")) return true;
+  const boundary = path[directory.length];
+  return boundary === "/" || boundary === "\\";
+}
+function visibleFileTree(nodes, predicate, parent = null, depth = 0) {
+  if (!predicate) return nodes;
+  const visible = [];
+  for (const node of nodes) {
+    if (!predicate(node, { depth, parent })) continue;
+    visible.push(
+      node.children === void 0 ? node : {
+        ...node,
+        children: visibleFileTree(node.children, predicate, node, depth + 1)
+      }
+    );
+  }
+  return visible;
+}
+function filePathVisibility(nodes, path, predicate, parent = null, depth = 0) {
+  if (!predicate) return "visible";
+  for (const node of nodes) {
+    if (node.path !== path && !pathIsInsideDirectory(path, node.path)) continue;
+    if (!predicate(node, { depth, parent })) return "hidden";
+    if (node.path === path) return "visible";
+    if (node.kind !== "dir" || node.children === void 0) return "unknown";
+    return filePathVisibility(node.children, path, predicate, node, depth + 1);
+  }
+  return "unknown";
+}
+
+// src/components/file-browser.tsx
+import {
+  ChevronRightIcon,
+  FileIcon,
+  FilePlusIcon,
+  FolderIcon,
+  FolderPlusIcon,
+  PencilIcon,
+  RefreshCwIcon,
+  TriangleAlertIcon,
+  Trash2Icon
+} from "lucide-react";
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect3,
+  useId,
+  useLayoutEffect,
+  useMemo as useMemo3,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { AlertDialog } from "radix-ui";
+import { VList } from "virtua";
+
+// src/lib/use-unicode-fonts.ts
+import { useEffect as useEffect2, useMemo as useMemo2 } from "react";
+var japaneseScript = /[\u3040-\u30ff\u3400-\u4dbf\u4e00-\u9fff\uf900-\ufaff]/u;
+var arabicScript = /[\u0600-\u06ff\u0750-\u077f\u0870-\u08ff\ufb50-\ufdff\ufe70-\ufefc]/u;
+function useUnicodeFallbackFonts(values) {
+  const content = useMemo2(() => collectUnicodeContent(values), [values]);
+  useEffect2(() => {
+    if (content.japanese) {
+      void import("./noto-sans-jp-loader.generated-MR5L6V7K.js").then(({ loadNotoSansJp }) => loadNotoSansJp(content.japanese)).catch(() => void 0);
+    }
+    if (content.arabic) {
+      void import("./noto-sans-arabic-loader-XSH2KYWJ.js").then(({ loadNotoSansArabic }) => loadNotoSansArabic()).catch(() => void 0);
+    }
+  }, [content.arabic, content.japanese]);
+}
+function collectUnicodeContent(values) {
+  const japanese = /* @__PURE__ */ new Set();
+  const arabic = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    for (const character of value) {
+      if (japaneseScript.test(character)) japanese.add(character);
+      if (arabicScript.test(character)) arabic.add(character);
+    }
+  }
+  return { japanese: [...japanese].join(""), arabic: [...arabic].join("") };
+}
+
+// src/components/file-browser.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+var STATUS_TINT = {
+  added: "text-og-status-idle",
+  modified: "text-og-status-running",
+  deleted: "text-og-status-failed line-through",
+  renamed: "text-og-accent",
+  untracked: "text-og-fg-subtle"
+};
+var useBrowserLayoutEffect = typeof window === "undefined" ? useEffect3 : useLayoutEffect;
+function parentOf2(path) {
+  const i = path.lastIndexOf("/");
+  return i <= 0 ? "" : path.slice(0, i);
+}
+function joinPath(parent, name) {
+  return parent ? `${parent}/${name}` : name;
+}
+function itemKey(item) {
+  switch (item.type) {
+    case "node":
+      return item.node.path;
+    case "create":
+      return `create:${item.parent}`;
+    case "skeleton":
+      return `skeleton:${item.path}`;
+    case "residue":
+      return `residue:${item.path}`;
+  }
+}
+function pathIsInsideDirectory2(path, directory) {
+  if (!path.startsWith(directory) || path === directory) return false;
+  if (directory.endsWith("/") || directory.endsWith("\\")) return true;
+  const boundary = path[directory.length];
+  return boundary === "/" || boundary === "\\";
+}
+function findNode(nodes, path) {
+  for (const node of nodes) {
+    if (node.path === path) return node;
+    if (node.kind === "dir" && node.children && pathIsInsideDirectory2(path, node.path)) {
+      const hit = findNode(node.children, path);
+      if (hit) return hit;
+    }
+  }
+  return void 0;
+}
+function traceRevealPath(nodes, targetPath) {
+  for (const node of nodes) {
+    if (node.path === targetPath) {
+      return {
+        directories: node.kind === "dir" ? [node.path] : [],
+        frontier: node.kind === "dir" && node.children === void 0 ? node.path : null
+      };
+    }
+    if (node.kind !== "dir" || !pathIsInsideDirectory2(targetPath, node.path)) continue;
+    if (node.children === void 0) {
+      return { directories: [node.path], frontier: node.path };
+    }
+    const child = traceRevealPath(node.children, targetPath);
+    return {
+      directories: [node.path, ...child.directories],
+      frontier: child.frontier
+    };
+  }
+  return { directories: [], frontier: null };
+}
+function FileBrowser({
+  result,
+  fallback,
+  onSelectFile,
+  selectedPath,
+  isNodeVisible,
+  revealPath,
+  revealPathRequestId,
+  renderNode,
+  emptyState,
+  editable = true,
+  confirmDelete,
+  className
+}) {
+  const [expanded, setExpanded] = useState2(/* @__PURE__ */ new Set());
+  const [loadingPaths, setLoadingPaths] = useState2(/* @__PURE__ */ new Set());
+  const [active, setActive] = useState2(null);
+  const [draftCreate, setDraftCreate] = useState2(null);
+  const [draftRename, setDraftRename] = useState2(null);
+  const [dragOver, setDragOver] = useState2(null);
+  const [menu, setMenu] = useState2(null);
+  const [pendingDelete, setPendingDelete] = useState2(null);
+  const [busy, setBusy] = useState2(false);
+  const [coarsePointer, setCoarsePointer] = useState2(false);
+  const [revealRequest, setRevealRequest] = useState2(null);
+  const handledRevealRequestRef = useRef2(null);
+  const attemptedRevealPathsRef = useRef2(/* @__PURE__ */ new Set());
+  const treeId = useId();
+  const container = usePortalTokenSource();
+  const containerRef = container.currentRef;
+  const deleteReturnFocusRef = useRef2(null);
+  const vlistRef = useRef2(null);
+  const portalTokenStyle = usePortalTokenStyle(container.source);
+  const getTreeElement = useCallback2(
+    () => typeof document === "undefined" ? null : document.getElementById(treeId),
+    [treeId]
+  );
+  const visibleTree = useMemo3(
+    () => visibleFileTree(result.tree, isNodeVisible),
+    [isNodeVisible, result.tree]
+  );
+  useBrowserLayoutEffect(() => {
+    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 effectiveRevealRequestId = revealPath ? revealPathRequestId ?? revealPath : null;
+  useEffect3(() => {
+    if (!revealPath || effectiveRevealRequestId === null) {
+      setRevealRequest(null);
+      return;
+    }
+    const handled = handledRevealRequestRef.current;
+    if (handled?.path === revealPath && handled.requestId === effectiveRevealRequestId) return;
+    handledRevealRequestRef.current = {
+      path: revealPath,
+      requestId: effectiveRevealRequestId
+    };
+    attemptedRevealPathsRef.current = /* @__PURE__ */ new Set();
+    setActive(null);
+    setRevealRequest({ path: revealPath, requestId: effectiveRevealRequestId });
+  }, [effectiveRevealRequestId, revealPath]);
+  const visibleActive = active && findNode(visibleTree, active) ? active : null;
+  const cursor = visibleActive ?? (selectedPath && findNode(visibleTree, selectedPath) ? selectedPath : null);
+  useEffect3(() => {
+    if (active !== null && visibleActive === null) setActive(null);
+  }, [active, visibleActive]);
+  const expand = useCallback2(
+    async (path) => {
+      const node = findNode(visibleTree, path);
+      if (node && node.kind === "dir" && node.children === void 0) {
+        setLoadingPaths((prev) => new Set(prev).add(path));
+        try {
+          await result.expand(path);
+        } finally {
+          setLoadingPaths((prev) => {
+            const next = new Set(prev);
+            next.delete(path);
+            return next;
+          });
+        }
+      }
+    },
+    [result, visibleTree]
+  );
+  const open = useCallback2(
+    (path) => {
+      setExpanded((prev) => new Set(prev).add(path));
+      void expand(path);
+    },
+    [expand]
+  );
+  useEffect3(() => {
+    if (!revealRequest) return;
+    const trace = traceRevealPath(visibleTree, revealRequest.path);
+    if (trace.directories.length > 0) {
+      setExpanded((previous) => {
+        const next = new Set(previous);
+        let changed = false;
+        for (const path of trace.directories) {
+          if (next.has(path)) continue;
+          next.add(path);
+          changed = true;
+        }
+        return changed ? next : previous;
+      });
+    }
+    const frontier = trace.frontier;
+    if (!frontier || attemptedRevealPathsRef.current.has(frontier) || loadingPaths.has(frontier) || result.expandingPaths.has(frontier)) {
+      return;
+    }
+    attemptedRevealPathsRef.current.add(frontier);
+    void expand(frontier);
+  }, [expand, loadingPaths, result.expandingPaths, revealRequest, visibleTree]);
+  const toggle = useCallback2(
+    async (node) => {
+      if (node.kind !== "dir") return;
+      const isOpen = expanded.has(node.path);
+      setExpanded((prev) => {
+        const next = new Set(prev);
+        if (isOpen) next.delete(node.path);
+        else next.add(node.path);
+        return next;
+      });
+      if (!isOpen) await expand(node.path);
+    },
+    [expanded, expand]
+  );
+  const cold = result.source !== "live";
+  const renderItems = useMemo3(() => {
+    const items = [];
+    if (draftCreate && draftCreate.parent === "") {
+      items.push({ type: "create", parent: "", kind: draftCreate.kind, depth: 0 });
+    }
+    const walk = (nodes, depth) => {
+      for (const node of nodes) {
+        items.push({ type: "node", node, depth });
+        if (node.kind !== "dir" || !expanded.has(node.path)) continue;
+        if (draftCreate && draftCreate.parent === node.path) {
+          items.push({
+            type: "create",
+            parent: node.path,
+            kind: draftCreate.kind,
+            depth: depth + 1
+          });
+        }
+        const childless = node.children === void 0 || node.children.length === 0;
+        const isLoading = loadingPaths.has(node.path) || result.expandingPaths.has(node.path);
+        if (node.truncated && childless && cold && !isLoading) {
+          items.push({ type: "residue", path: node.path, depth: depth + 1 });
+        } else if (node.children && node.children.length > 0) {
+          walk(node.children, depth + 1);
+        } else if (isLoading && childless) {
+          items.push({ type: "skeleton", path: node.path, depth: depth + 1 });
+        }
+      }
+    };
+    walk(visibleTree, 0);
+    return items;
+  }, [visibleTree, expanded, draftCreate, loadingPaths, result.expandingPaths, cold]);
+  const unicodeFontPaths = useMemo3(
+    () => renderItems.flatMap((item) => item.type === "node" ? [item.node.path] : []),
+    [renderItems]
+  );
+  useUnicodeFallbackFonts(unicodeFontPaths);
+  const flatRows = useMemo3(
+    () => renderItems.flatMap(
+      (item) => item.type === "node" ? [{ node: item.node, depth: item.depth }] : []
+    ),
+    [renderItems]
+  );
+  const rowIndexByPath = useMemo3(
+    () => new Map(flatRows.map((row, index) => [row.node.path, index])),
+    [flatRows]
+  );
+  const treePositionByPath = useMemo3(() => {
+    const positions = /* @__PURE__ */ new Map();
+    const visit = (nodes) => {
+      nodes.forEach((node, index) => {
+        positions.set(node.path, { position: index + 1, setSize: nodes.length });
+        if (node.children) visit(node.children);
+      });
+    };
+    visit(visibleTree);
+    return positions;
+  }, [visibleTree]);
+  const cursorIndex = cursor ? rowIndexByPath.get(cursor) ?? -1 : -1;
+  const activeDescendantId = cursorIndex >= 0 ? `${treeId}-item-${cursorIndex}` : void 0;
+  const supportsMutation = editable && result.source === "live" && result.error === null && !result.loading;
+  const performDelete = useCallback2(
+    async (node) => {
+      if (!supportsMutation) return;
+      const recursive = node.kind === "dir";
+      setBusy(true);
+      try {
+        await result.deleteEntry(node.path, recursive);
+      } catch {
+      } finally {
+        setBusy(false);
+      }
+    },
+    [supportsMutation, result]
+  );
+  const runDelete = useCallback2(
+    async (node, returnFocus) => {
+      if (!supportsMutation) return;
+      setMenu(null);
+      if (!confirmDelete) {
+        deleteReturnFocusRef.current = returnFocus ?? (typeof document !== "undefined" && document.activeElement instanceof HTMLElement ? document.activeElement : null);
+        setPendingDelete(node);
+        return;
+      }
+      if (await confirmDelete(node)) await performDelete(node);
+    },
+    [supportsMutation, confirmDelete, performDelete]
+  );
+  const closePendingDelete = useCallback2(
+    (restoreTrigger) => {
+      const returnTarget = restoreTrigger ? deleteReturnFocusRef.current : getTreeElement();
+      deleteReturnFocusRef.current = null;
+      setPendingDelete(null);
+      if (typeof window !== "undefined") {
+        window.requestAnimationFrame(() => {
+          const target = returnTarget?.isConnected ? returnTarget : getTreeElement();
+          target?.focus();
+        });
+      }
+    },
+    [getTreeElement]
+  );
+  const commitCreate = useCallback2(
+    async (name) => {
+      const draft = draftCreate;
+      setDraftCreate(null);
+      if (!draft || !supportsMutation) return;
+      const trimmed = name.trim().replace(/\/+$/, "");
+      if (!trimmed) return;
+      const path = joinPath(draft.parent, trimmed);
+      setBusy(true);
+      try {
+        if (draft.kind === "dir") {
+          await result.createDir(path);
+          open(path);
+        } else {
+          await result.createFile(path);
+          setActive(path);
+          onSelectFile?.(path);
+        }
+      } catch {
+      } finally {
+        setBusy(false);
+      }
+    },
+    [draftCreate, supportsMutation, result, open, onSelectFile]
+  );
+  const commitRename = useCallback2(
+    async (name) => {
+      const draft = draftRename;
+      setDraftRename(null);
+      if (!draft || !supportsMutation) return;
+      const node = findNode(visibleTree, draft.path);
+      const trimmed = name.trim().replace(/\/+$/, "");
+      if (!node || !trimmed || trimmed === node.name) return;
+      const newPath = joinPath(parentOf2(draft.path), trimmed);
+      setBusy(true);
+      try {
+        await result.moveEntry(draft.path, newPath);
+        if (node.kind === "file" && (selectedPath === draft.path || active === draft.path)) {
+          setActive(newPath);
+          onSelectFile?.(newPath);
+        }
+      } catch {
+      } finally {
+        setBusy(false);
+      }
+    },
+    [draftRename, supportsMutation, result, selectedPath, active, onSelectFile, visibleTree]
+  );
+  const startCreate = useCallback2(
+    (kind) => {
+      if (!supportsMutation) return;
+      const anchor = cursor ? findNode(visibleTree, cursor) : void 0;
+      const parent = anchor ? anchor.kind === "dir" ? anchor.path : parentOf2(anchor.path) : "";
+      if (parent) open(parent);
+      setDraftRename(null);
+      setMenu(null);
+      setDraftCreate({ parent, kind });
+    },
+    [supportsMutation, cursor, open, visibleTree]
+  );
+  const startRename = useCallback2(
+    (node) => {
+      if (!supportsMutation) return;
+      setDraftCreate(null);
+      setMenu(null);
+      setDraftRename({ path: node.path });
+    },
+    [supportsMutation]
+  );
+  const onDropOnto = useCallback2(
+    async (targetDir, sourcePath) => {
+      setDragOver(null);
+      if (!supportsMutation || !sourcePath) return;
+      const src = findNode(visibleTree, sourcePath);
+      if (!src) return;
+      if (parentOf2(sourcePath) === targetDir) return;
+      if (targetDir === sourcePath || targetDir.startsWith(`${sourcePath}/`)) return;
+      const newPath = joinPath(targetDir, src.name);
+      if (newPath === sourcePath) return;
+      setBusy(true);
+      try {
+        await result.moveEntry(sourcePath, newPath);
+        if (src.kind === "file" && (selectedPath === sourcePath || active === sourcePath)) {
+          setActive(newPath);
+          onSelectFile?.(newPath);
+        }
+      } catch {
+      } finally {
+        setBusy(false);
+      }
+    },
+    [supportsMutation, result, selectedPath, active, onSelectFile, visibleTree]
+  );
+  const onKeyDown = useCallback2(
+    (e) => {
+      if (draftCreate || draftRename) return;
+      if (flatRows.length === 0) return;
+      const idx = flatRows.findIndex((r) => r.node.path === cursor);
+      const move = (next) => {
+        const clamped = Math.max(0, Math.min(flatRows.length - 1, next));
+        const row = flatRows[clamped];
+        if (row) setActive(row.node.path);
+        e.preventDefault();
+      };
+      const cur = idx >= 0 ? flatRows[idx] : void 0;
+      switch (e.key) {
+        case "ArrowDown":
+          move(idx < 0 ? 0 : idx + 1);
+          break;
+        case "ArrowUp":
+          move(idx < 0 ? 0 : idx - 1);
+          break;
+        case "Home":
+          move(0);
+          break;
+        case "End":
+          move(flatRows.length - 1);
+          break;
+        case "PageDown": {
+          const pageSize = Math.max(
+            1,
+            Math.floor((containerRef.current?.clientHeight || 280) / (coarsePointer ? 44 : 28)) - 1
+          );
+          move((idx < 0 ? 0 : idx) + pageSize);
+          break;
+        }
+        case "PageUp": {
+          const pageSize = Math.max(
+            1,
+            Math.floor((containerRef.current?.clientHeight || 280) / (coarsePointer ? 44 : 28)) - 1
+          );
+          move((idx < 0 ? 0 : idx) - pageSize);
+          break;
+        }
+        case "ArrowRight":
+          if (cur?.node.kind === "dir") {
+            if (!expanded.has(cur.node.path)) open(cur.node.path);
+            else move(idx + 1);
+            e.preventDefault();
+          }
+          break;
+        case "ArrowLeft":
+          if (cur) {
+            if (cur.node.kind === "dir" && expanded.has(cur.node.path)) {
+              setExpanded((prev) => {
+                const n = new Set(prev);
+                n.delete(cur.node.path);
+                return n;
+              });
+            } else {
+              const parent = parentOf2(cur.node.path);
+              if (parent) setActive(parent);
+            }
+            e.preventDefault();
+          }
+          break;
+        case "Enter":
+          if (cur) {
+            if (cur.node.kind === "dir") void toggle(cur.node);
+            else onSelectFile?.(cur.node.path);
+            e.preventDefault();
+          }
+          break;
+        case "ContextMenu":
+        case "F10":
+          if (cur && supportsMutation && (e.key === "ContextMenu" || e.shiftKey)) {
+            const rowIndex = rowIndexByPath.get(cur.node.path) ?? 0;
+            const row = document.getElementById(`${treeId}-item-${rowIndex}`);
+            const rect = row?.getBoundingClientRect();
+            setMenu({
+              node: cur.node,
+              x: rect ? rect.left + Math.min(32, rect.width / 2) : 8,
+              y: rect ? rect.bottom : 8
+            });
+            e.preventDefault();
+          } else if (e.key === "F10") {
+            break;
+          }
+          break;
+        case "F2":
+          if (cur) {
+            startRename(cur.node);
+            e.preventDefault();
+          }
+          break;
+        case "Delete":
+        case "Backspace":
+          if (cur && supportsMutation) {
+            void runDelete(cur.node);
+            e.preventDefault();
+          }
+          break;
+      }
+    },
+    [
+      draftCreate,
+      draftRename,
+      flatRows,
+      cursor,
+      expanded,
+      open,
+      toggle,
+      onSelectFile,
+      startRename,
+      runDelete,
+      supportsMutation,
+      coarsePointer,
+      containerRef,
+      rowIndexByPath,
+      treeId
+    ]
+  );
+  useEffect3(() => {
+    if (!menu) return;
+    const close = () => setMenu(null);
+    window.addEventListener("click", close);
+    window.addEventListener("scroll", close, true);
+    window.addEventListener("resize", close);
+    return () => {
+      window.removeEventListener("click", close);
+      window.removeEventListener("scroll", close, true);
+      window.removeEventListener("resize", close);
+    };
+  }, [menu]);
+  const showErrorEmpty = result.error && visibleTree.length === 0 && !draftCreate;
+  const showDegradedTree = result.error && visibleTree.length > 0;
+  const showEmpty = !result.loading && visibleTree.length === 0 && !draftCreate;
+  const showToolbar = supportsMutation || result.loading;
+  const usesVirtualTree = !showErrorEmpty && !showEmpty && renderItems.length > 500;
+  const renderNodeRow = (node, depth) => {
+    const isOpen = expanded.has(node.path);
+    if (renderNode) {
+      return /* @__PURE__ */ jsx("div", { children: renderNode(node, depth, isOpen) });
+    }
+    const isDir = node.kind === "dir";
+    const isSelected = node.path === selectedPath || node.path === active;
+    const isCursor = node.path === cursor;
+    const isLoading = loadingPaths.has(node.path) || result.expandingPaths.has(node.path);
+    const isRenaming = draftRename?.path === node.path;
+    const isDropTarget = dragOver === (isDir ? node.path : parentOf2(node.path));
+    const dropDir = isDir ? node.path : parentOf2(node.path);
+    const treePosition = treePositionByPath.get(node.path);
+    return /* @__PURE__ */ jsx(
+      "div",
+      {
+        id: `${treeId}-item-${rowIndexByPath.get(node.path) ?? 0}`,
+        role: "treeitem",
+        "aria-level": depth + 1,
+        "aria-posinset": treePosition?.position,
+        "aria-setsize": treePosition?.setSize,
+        "aria-expanded": isDir ? isOpen : void 0,
+        "aria-selected": isCursor || void 0,
+        "aria-busy": isLoading || void 0,
+        onDragOver: supportsMutation ? (e) => {
+          e.preventDefault();
+          e.dataTransfer.dropEffect = "move";
+          setDragOver(dropDir);
+        } : void 0,
+        onDragLeave: supportsMutation ? (e) => {
+          e.stopPropagation();
+          setDragOver((cur) => cur === dropDir ? null : cur);
+        } : void 0,
+        onDrop: supportsMutation ? (e) => {
+          e.preventDefault();
+          e.stopPropagation();
+          const src = e.dataTransfer.getData("text/og-path");
+          void onDropOnto(dropDir, src);
+        } : void 0,
+        children: isRenaming ? /* @__PURE__ */ jsx(
+          InlineInput,
+          {
+            depth,
+            kind: node.kind,
+            initialValue: node.name,
+            onCommit: (name) => void commitRename(name),
+            onCancel: () => setDraftRename(null)
+          }
+        ) : /* @__PURE__ */ jsxs(
+          "button",
+          {
+            type: "button",
+            tabIndex: -1,
+            draggable: supportsMutation || void 0,
+            onDragStart: supportsMutation ? (e) => {
+              e.dataTransfer.setData("text/og-path", node.path);
+              e.dataTransfer.effectAllowed = "move";
+            } : void 0,
+            onClick: () => {
+              setActive(node.path);
+              if (isDir) void toggle(node);
+              else onSelectFile?.(node.path);
+            },
+            onDoubleClick: () => supportsMutation && startRename(node),
+            onContextMenu: (e) => {
+              if (!supportsMutation) return;
+              e.preventDefault();
+              setActive(node.path);
+              setMenu({ node, x: e.clientX, y: e.clientY });
+            },
+            className: cn(
+              "group relative flex min-h-7 w-full items-center gap-1 truncate rounded-og-sm px-1 py-0.5 text-left text-og-sm pointer-coarse:min-h-11",
+              "hover:bg-og-surface-2",
+              isSelected && "bg-og-surface-2",
+              isCursor && "outline outline-1 -outline-offset-1 outline-og-accent",
+              isDropTarget && "bg-og-accent-soft ring-1 ring-inset ring-og-accent",
+              // A thin progress shimmer on the expanding row — no per-node spinner.
+              isLoading && "after:pointer-events-none after:absolute after:inset-x-1 after:bottom-0 after:h-px after:animate-pulse after:rounded-full after:bg-og-accent-soft",
+              node.status ? STATUS_TINT[node.status] : void 0
+            ),
+            style: { paddingLeft: `${depth * 12 + 4}px` },
+            children: [
+              isDir ? /* @__PURE__ */ jsx(
+                ChevronRightIcon,
+                {
+                  className: cn(
+                    "size-3 shrink-0 transition-transform",
+                    isOpen && "rotate-90",
+                    isLoading && "text-og-accent"
+                  )
+                }
+              ) : /* @__PURE__ */ jsx("span", { className: "inline-block w-3 shrink-0" }),
+              isDir ? /* @__PURE__ */ jsx(FolderIcon, { className: "size-3.5 shrink-0" }) : /* @__PURE__ */ jsx(FileIcon, { className: "size-3.5 shrink-0" }),
+              /* @__PURE__ */ jsx("span", { className: "truncate", children: node.name }),
+              supportsMutation && /* @__PURE__ */ jsx(
+                "span",
+                {
+                  role: "button",
+                  tabIndex: -1,
+                  "aria-label": "More actions",
+                  onClick: (e) => {
+                    e.preventDefault();
+                    e.stopPropagation();
+                    setActive(node.path);
+                    const rect = e.currentTarget.getBoundingClientRect();
+                    setMenu({ node, x: rect.right, y: rect.bottom });
+                  },
+                  className: "ml-auto hidden shrink-0 px-1 text-og-fg-subtle hover:text-og-fg group-hover:inline",
+                  children: "\u22EF"
+                }
+              )
+            ]
+          }
+        )
+      }
+    );
+  };
+  const renderItem = (item) => {
+    switch (item.type) {
+      case "node":
+        return renderNodeRow(item.node, item.depth);
+      case "create":
+        return /* @__PURE__ */ jsx(
+          InlineInput,
+          {
+            depth: item.depth,
+            kind: item.kind,
+            initialValue: "",
+            onCommit: (name) => void commitCreate(name),
+            onCancel: () => setDraftCreate(null)
+          }
+        );
+      case "skeleton":
+        return /* @__PURE__ */ jsx(
+          "div",
+          {
+            role: "group",
+            "aria-hidden": true,
+            style: { paddingLeft: `${item.depth * 12 + 4}px` },
+            className: "space-y-1 py-1",
+            children: [0, 1, 2].map((i) => /* @__PURE__ */ jsx(
+              "div",
+              {
+                className: "h-2.5 animate-pulse rounded-og-sm bg-og-surface-2",
+                style: { width: `${70 - i * 12}%` }
+              },
+              i
+            ))
+          }
+        );
+      case "residue":
+        return /* @__PURE__ */ jsxs(
+          "div",
+          {
+            style: { paddingLeft: `${item.depth * 12 + 4}px` },
+            className: "flex items-center gap-1.5 py-0.5 pr-1 text-og-xs italic text-og-fg-subtle",
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "inline-block w-3 shrink-0" }),
+              /* @__PURE__ */ jsx("span", { className: "min-w-0 truncate", children: "contents on machine \u2014 open when live" })
+            ]
+          }
+        );
+    }
+  };
+  useEffect3(() => {
+    if (!cursor) return;
+    const index = renderItems.findIndex((it) => it.type === "node" && it.node.path === cursor);
+    if (index >= 0) vlistRef.current?.scrollToIndex(index);
+  }, [cursor, renderItems]);
+  useEffect3(() => {
+    if (!revealRequest) return;
+    const index = renderItems.findIndex(
+      (item) => item.type === "node" && item.node.path === revealRequest.path
+    );
+    if (index < 0) return;
+    if (usesVirtualTree) {
+      vlistRef.current?.scrollToIndex(index);
+    } else {
+      document.getElementById(`${treeId}-item-${index}`)?.scrollIntoView?.({ block: "nearest" });
+    }
+    setRevealRequest(
+      (current) => current?.path === revealRequest.path && current.requestId === revealRequest.requestId ? null : current
+    );
+  }, [renderItems, revealRequest, treeId, usesVirtualTree]);
+  return /* @__PURE__ */ jsxs("div", { className: cn("flex min-h-0 min-w-0 flex-col", className), children: [
+    showToolbar && /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "toolbar",
+        "aria-label": "File actions",
+        className: "flex shrink-0 flex-wrap items-center gap-0.5 border-b border-og-border px-1 py-1",
+        children: [
+          supportsMutation ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(ToolbarButton, { label: "New file", onClick: () => startCreate("file"), disabled: busy, children: /* @__PURE__ */ jsx(FilePlusIcon, { className: "size-3.5" }) }),
+            /* @__PURE__ */ jsx(ToolbarButton, { label: "New folder", onClick: () => startCreate("dir"), disabled: busy, children: /* @__PURE__ */ jsx(FolderPlusIcon, { className: "size-3.5" }) }),
+            /* @__PURE__ */ jsx(
+              ToolbarButton,
+              {
+                label: "Rename",
+                onClick: () => {
+                  const node = cursor ? findNode(visibleTree, cursor) : void 0;
+                  if (node) startRename(node);
+                },
+                disabled: busy || !cursor,
+                children: /* @__PURE__ */ jsx(PencilIcon, { className: "size-3.5" })
+              }
+            ),
+            /* @__PURE__ */ jsx(
+              ToolbarButton,
+              {
+                label: "Delete",
+                onClick: (event) => {
+                  const node = cursor ? findNode(visibleTree, cursor) : void 0;
+                  if (node) void runDelete(node, event.currentTarget);
+                },
+                disabled: busy || !cursor,
+                children: /* @__PURE__ */ jsx(Trash2Icon, { className: "size-3.5" })
+              }
+            )
+          ] }) : null,
+          /* @__PURE__ */ jsx("span", { className: "ml-auto" }),
+          /* @__PURE__ */ jsx(
+            ToolbarButton,
+            {
+              label: "Refresh",
+              onClick: () => void result.refresh(),
+              disabled: busy || result.loading,
+              children: /* @__PURE__ */ jsx(RefreshCwIcon, { className: cn("size-3.5", result.loading && "animate-spin") })
+            }
+          )
+        ]
+      }
+    ),
+    showDegradedTree ? /* @__PURE__ */ jsxs(
+      "div",
+      {
+        role: "status",
+        "aria-live": "polite",
+        "data-opengeni-files-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__ */ jsx(TriangleAlertIcon, { className: "size-3.5 shrink-0 text-og-status-running", "aria-hidden": true }),
+          /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1", children: result.source === "capture" ? "Live files are temporarily unavailable. Showing the latest captured revision." : "Live refresh failed. Showing the last loaded files." }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => void result.refresh(),
+              disabled: result.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__ */ jsx(
+                  RefreshCwIcon,
+                  {
+                    className: cn("size-3", result.loading && "animate-spin motion-reduce:animate-none"),
+                    "aria-hidden": true
+                  }
+                ),
+                "Retry"
+              ]
+            }
+          )
+        ]
+      }
+    ) : null,
+    /* @__PURE__ */ jsx(
+      "div",
+      {
+        ref: container.ref,
+        onFocus: (event) => {
+          if (event.target.id === treeId && cursorIndex < 0) {
+            const first = flatRows[0];
+            if (first) setActive(first.node.path);
+          }
+        },
+        onKeyDown,
+        onDragOver: supportsMutation ? (e) => {
+          e.preventDefault();
+          e.dataTransfer.dropEffect = "move";
+          setDragOver("");
+        } : void 0,
+        onDrop: supportsMutation ? (e) => {
+          e.preventDefault();
+          const src = e.dataTransfer.getData("text/og-path");
+          void onDropOnto("", src);
+        } : void 0,
+        className: cn(
+          "flex min-h-0 min-w-0 flex-1 flex-col p-1",
+          dragOver === "" && "ring-1 ring-inset ring-og-accent"
+        ),
+        "data-opengeni-file-tree": true,
+        children: showErrorEmpty ? /* @__PURE__ */ jsxs("div", { className: "flex flex-col items-start gap-2 p-2 text-og-sm text-og-fg-subtle", children: [
+          /* @__PURE__ */ jsx("div", { children: fallback ?? `Could not load files: ${result.error?.message ?? "refresh the file list to try again"}` }),
+          /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              onClick: () => void result.refresh(),
+              disabled: result.loading,
+              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 disabled:cursor-not-allowed disabled:opacity-50 pointer-coarse:min-h-11",
+              children: [
+                /* @__PURE__ */ jsx(
+                  RefreshCwIcon,
+                  {
+                    className: cn("size-3.5", result.loading && "animate-spin"),
+                    "aria-hidden": true
+                  }
+                ),
+                "Retry"
+              ]
+            }
+          )
+        ] }) : showEmpty ? /* @__PURE__ */ jsx("div", { className: "p-2 text-og-sm text-og-fg-subtle", children: emptyState ?? "This directory is empty" }) : !usesVirtualTree ? /* @__PURE__ */ jsx(
+          "div",
+          {
+            id: treeId,
+            role: "tree",
+            "aria-label": "Workspace files",
+            "aria-activedescendant": activeDescendantId,
+            "aria-multiselectable": false,
+            tabIndex: 0,
+            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",
+            children: renderItems.map((item) => /* @__PURE__ */ jsx("div", { className: "min-w-0", children: renderItem(item) }, itemKey(item)))
+          }
+        ) : (
+          // Virtualized: only the rows in/near the viewport mount, so a 3k-node
+          // tree stays responsive. The flat item list already carries the
+          // expanded subtree + synthetic (create/skeleton/residue) rows.
+          /* @__PURE__ */ jsx(
+            VList,
+            {
+              ref: vlistRef,
+              id: treeId,
+              role: "tree",
+              "aria-label": "Workspace files",
+              "aria-activedescendant": activeDescendantId,
+              "aria-multiselectable": false,
+              tabIndex: 0,
+              className: "min-h-0 flex-1 outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-og-accent",
+              itemSize: coarsePointer ? 44 : 28,
+              ssrCount: Math.min(32, renderItems.length),
+              children: renderItems.map((item) => /* @__PURE__ */ jsx("div", { className: "min-w-0", children: renderItem(item) }, itemKey(item)))
+            }
+          )
+        )
+      }
+    ),
+    menu && menu.node && /* @__PURE__ */ jsx(
+      ContextMenu,
+      {
+        node: menu.node,
+        x: menu.x,
+        y: menu.y,
+        onRename: () => menu.node && startRename(menu.node),
+        onDelete: () => menu.node && void runDelete(menu.node),
+        onNewFile: () => startCreate("file"),
+        onNewFolder: () => startCreate("dir"),
+        onClose: () => {
+          setMenu(null);
+          window.requestAnimationFrame(() => getTreeElement()?.focus());
+        }
+      }
+    ),
+    pendingDelete ? /* @__PURE__ */ jsx(
+      DeleteDialog,
+      {
+        node: pendingDelete,
+        busy,
+        portalTokenStyle,
+        onCancel: () => closePendingDelete(true),
+        onConfirm: () => {
+          const node = pendingDelete;
+          closePendingDelete(false);
+          void performDelete(node);
+        }
+      }
+    ) : null
+  ] });
+}
+function DeleteDialog({
+  node,
+  busy,
+  portalTokenStyle,
+  onCancel,
+  onConfirm
+}) {
+  const cancelRef = useRef2(null);
+  const [open, setOpen] = useState2(true);
+  const closeIntentRef = useRef2("cancel");
+  const settledRef = useRef2(false);
+  const settleTimerRef = useRef2(null);
+  const settle = () => {
+    if (settledRef.current) return;
+    settledRef.current = true;
+    if (closeIntentRef.current === "confirm") {
+      onConfirm();
+    } else {
+      onCancel();
+    }
+  };
+  const scheduleSettle = () => {
+    if (settleTimerRef.current !== null) return;
+    settleTimerRef.current = setTimeout(() => {
+      settleTimerRef.current = null;
+      settle();
+    }, 0);
+  };
+  useEffect3(
+    () => () => {
+      if (settleTimerRef.current !== null) clearTimeout(settleTimerRef.current);
+    },
+    []
+  );
+  return /* @__PURE__ */ jsx(
+    AlertDialog.Root,
+    {
+      open,
+      onOpenChange: (nextOpen) => {
+        if (!nextOpen && !busy) {
+          setOpen(false);
+          scheduleSettle();
+        }
+      },
+      children: /* @__PURE__ */ jsxs(AlertDialog.Portal, { container: typeof document === "undefined" ? null : document.body, children: [
+        /* @__PURE__ */ jsx(AlertDialog.Overlay, { className: "og-root fixed inset-0 z-[100] bg-black/45 backdrop-blur-[2px]" }),
+        /* @__PURE__ */ jsxs(
+          AlertDialog.Content,
+          {
+            className: "og-root fixed left-1/2 top-1/2 z-[101] max-h-[calc(100dvh-2rem)] w-[calc(100%-2rem)] max-w-sm -translate-x-1/2 -translate-y-1/2 overflow-y-auto rounded-og-lg border border-og-border-strong bg-og-surface-1 p-4 text-og-fg shadow-2xl outline-hidden",
+            style: portalTokenStyle,
+            onOpenAutoFocus: (event) => {
+              event.preventDefault();
+              cancelRef.current?.focus();
+            },
+            onCloseAutoFocus: (event) => {
+              event.preventDefault();
+              scheduleSettle();
+            },
+            onEscapeKeyDown: (event) => {
+              event.stopPropagation();
+              if (busy) {
+                event.preventDefault();
+              } else {
+                closeIntentRef.current = "cancel";
+              }
+            },
+            children: [
+              /* @__PURE__ */ jsxs("div", { className: "flex items-start gap-3", children: [
+                /* @__PURE__ */ jsx("span", { className: "flex size-9 shrink-0 items-center justify-center rounded-full bg-og-status-failed/12 text-og-status-failed", children: /* @__PURE__ */ jsx(Trash2Icon, { className: "size-4", "aria-hidden": true }) }),
+                /* @__PURE__ */ jsxs("div", { className: "min-w-0", children: [
+                  /* @__PURE__ */ jsxs(AlertDialog.Title, { className: "text-og-sm font-semibold", children: [
+                    "Delete ",
+                    node.kind === "dir" ? "folder" : "file",
+                    "?"
+                  ] }),
+                  /* @__PURE__ */ jsxs(AlertDialog.Description, { className: "mt-1 text-og-sm leading-relaxed text-og-fg-muted", children: [
+                    /* @__PURE__ */ jsx("span", { className: "break-all font-og-mono text-og-fg", children: node.path }),
+                    node.kind === "dir" ? " and everything inside it will be permanently removed." : " will be permanently removed."
+                  ] })
+                ] })
+              ] }),
+              /* @__PURE__ */ jsxs("div", { className: "mt-4 flex justify-end gap-2", children: [
+                /* @__PURE__ */ jsx(AlertDialog.Cancel, { asChild: true, children: /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    ref: cancelRef,
+                    type: "button",
+                    onClick: () => {
+                      closeIntentRef.current = "cancel";
+                    },
+                    disabled: busy,
+                    className: "min-h-9 rounded-og-md border border-og-border px-3 text-og-sm font-medium text-og-fg hover:bg-og-surface-2 disabled:opacity-50 pointer-coarse:min-h-11",
+                    children: "Cancel"
+                  }
+                ) }),
+                /* @__PURE__ */ jsx(AlertDialog.Action, { asChild: true, children: /* @__PURE__ */ jsx(
+                  "button",
+                  {
+                    type: "button",
+                    onClick: () => {
+                      closeIntentRef.current = "confirm";
+                    },
+                    disabled: busy,
+                    className: "min-h-9 rounded-og-md bg-og-danger-fill px-3 text-og-sm font-semibold text-og-danger-fg shadow-sm hover:brightness-110 disabled:opacity-50 pointer-coarse:min-h-11",
+                    children: "Delete permanently"
+                  }
+                ) })
+              ] })
+            ]
+          }
+        )
+      ] })
+    }
+  );
+}
+function ToolbarButton({
+  label,
+  onClick,
+  disabled,
+  children
+}) {
+  return /* @__PURE__ */ jsx(
+    "button",
+    {
+      type: "button",
+      title: label,
+      "aria-label": label,
+      onClick,
+      disabled,
+      className: cn(
+        "inline-flex size-7 items-center justify-center rounded-og-sm p-1 text-og-fg-muted max-[1023px]:size-11 pointer-coarse:min-h-11 pointer-coarse:min-w-11",
+        "hover:bg-og-surface-2 hover:text-og-fg",
+        "disabled:cursor-not-allowed disabled:opacity-40"
+      ),
+      children
+    }
+  );
+}
+function InlineInput({
+  depth,
+  kind,
+  initialValue,
+  onCommit,
+  onCancel
+}) {
+  const [value, setValue] = useState2(initialValue);
+  const ref = useRef2(null);
+  const doneRef = useRef2(false);
+  useEffect3(() => {
+    const el = ref.current;
+    if (!el) return;
+    el.focus();
+    const dot = initialValue.lastIndexOf(".");
+    if (initialValue && dot > 0) el.setSelectionRange(0, dot);
+    else el.select();
+  }, [initialValue]);
+  const finish = (commit) => {
+    if (doneRef.current) return;
+    doneRef.current = true;
+    if (commit) onCommit(value);
+    else onCancel();
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex items-center gap-1 px-1 py-0.5",
+      style: { paddingLeft: `${depth * 12 + 4}px` },
+      children: [
+        /* @__PURE__ */ jsx("span", { className: "inline-block w-3 shrink-0" }),
+        kind === "dir" ? /* @__PURE__ */ jsx(FolderIcon, { className: "size-3.5 shrink-0" }) : /* @__PURE__ */ jsx(FileIcon, { className: "size-3.5 shrink-0" }),
+        /* @__PURE__ */ jsx(
+          "input",
+          {
+            ref,
+            value,
+            spellCheck: false,
+            autoComplete: "off",
+            "aria-label": kind === "dir" ? "Folder name" : "File name",
+            onChange: (e) => setValue(e.target.value),
+            onBlur: () => finish(true),
+            onKeyDown: (e) => {
+              if (e.key === "Enter") {
+                e.preventDefault();
+                finish(true);
+              } else if (e.key === "Escape") {
+                e.preventDefault();
+                finish(false);
+              }
+              e.stopPropagation();
+            },
+            className: cn(
+              "min-w-0 flex-1 rounded-og-sm border bg-og-bg px-1 py-0 text-og-sm",
+              "border-og-accent text-og-fg",
+              "outline-hidden"
+            )
+          }
+        )
+      ]
+    }
+  );
+}
+function ContextMenu({
+  node,
+  x,
+  y,
+  onRename,
+  onDelete,
+  onNewFile,
+  onNewFolder,
+  onClose
+}) {
+  const isDir = node.kind === "dir";
+  const menuRef = useRef2(null);
+  const vw = typeof window !== "undefined" ? window.innerWidth : 9999;
+  const vh = typeof window !== "undefined" ? window.innerHeight : 9999;
+  const left = Math.max(4, Math.min(x, vw - 180));
+  const top = Math.max(4, Math.min(y, vh - 160));
+  useEffect3(() => {
+    menuRef.current?.querySelector('[role="menuitem"]')?.focus();
+  }, []);
+  const onKeyDown = (event) => {
+    const items = Array.from(
+      menuRef.current?.querySelectorAll('[role="menuitem"]') ?? []
+    );
+    if (items.length === 0) return;
+    const current = items.findIndex((item2) => item2 === document.activeElement);
+    let next = null;
+    if (event.key === "ArrowDown") next = (current + 1 + items.length) % items.length;
+    else if (event.key === "ArrowUp") next = (current - 1 + items.length) % items.length;
+    else if (event.key === "Home") next = 0;
+    else if (event.key === "End") next = items.length - 1;
+    else if (event.key === "Escape") {
+      event.preventDefault();
+      event.stopPropagation();
+      onClose();
+      return;
+    }
+    if (next === null) return;
+    event.preventDefault();
+    event.stopPropagation();
+    items[next]?.focus();
+  };
+  const item = (label, icon, onClick, danger) => /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      role: "menuitem",
+      onClick: (e) => {
+        e.stopPropagation();
+        onClick();
+      },
+      className: cn(
+        MENU_BUTTON_CLASS,
+        danger && "text-og-status-failed [&_svg]:text-og-status-failed!"
+      ),
+      children: [
+        icon,
+        label
+      ]
+    }
+  );
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: menuRef,
+      role: "menu",
+      "aria-label": `Actions for ${node.name}`,
+      onKeyDown,
+      onClick: (e) => e.stopPropagation(),
+      style: { left, top },
+      className: cn(MENU_SURFACE_CLASS, "fixed z-50 min-w-[180px] overflow-hidden"),
+      children: [
+        isDir && /* @__PURE__ */ jsxs(Fragment, { children: [
+          item("New file", /* @__PURE__ */ jsx(FilePlusIcon, {}), onNewFile),
+          item("New folder", /* @__PURE__ */ jsx(FolderPlusIcon, {}), onNewFolder),
+          /* @__PURE__ */ jsx("div", { role: "separator", className: MENU_SEPARATOR_CLASS })
+        ] }),
+        item("Rename", /* @__PURE__ */ jsx(PencilIcon, {}), onRename),
+        item("Delete", /* @__PURE__ */ jsx(Trash2Icon, {}), onDelete, true)
+      ]
+    }
+  );
+}
+
+// src/components/pierre-file.tsx
+import {
+  lazy,
+  Suspense,
+  useEffect as useEffect4,
+  useState as useState3,
+  useSyncExternalStore
+} from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var LazyFile = lazy(async () => {
+  const mod = await loadPierreDiffs();
+  return { default: mod.File };
+});
+function PierreFile({
+  path,
+  contents,
+  themeType,
+  theme,
+  disableWorkerPool,
+  loading,
+  fallback,
+  className
+}) {
+  const [failed, setFailed] = useState3(false);
+  const [ready, setReady] = useState3(false);
+  const loaderRevision = useSyncExternalStore(
+    subscribePierreDiffs,
+    pierreDiffsRevision,
+    pierreDiffsRevision
+  );
+  useEffect4(() => {
+    let cancelled = false;
+    setFailed(false);
+    loadPierreDiffs().then(
+      () => {
+        if (!cancelled) setReady(true);
+      },
+      () => {
+        if (!cancelled) setFailed(true);
+      }
+    );
+    return () => {
+      cancelled = true;
+    };
+  }, [loaderRevision]);
+  const name = path.split("/").filter(Boolean).pop() ?? path;
+  if (failed) {
+    return /* @__PURE__ */ jsx2("div", { className, children: fallback ?? /* @__PURE__ */ jsx2(PlainFile, { name, contents }) });
+  }
+  const options = {
+    overflow: "scroll",
+    stickyHeader: true,
+    showLineNumbers: true,
+    ...theme ? { theme } : {
+      theme: {
+        dark: "github-dark-high-contrast",
+        light: "github-light-high-contrast"
+      }
+    },
+    themeType: themeType ?? "dark"
+  };
+  const pierreVars = {
+    "--diffs-dark-bg": "var(--og-color-bg)",
+    "--diffs-light-bg": "var(--og-color-bg)",
+    "--diffs-bg-buffer-override": "var(--og-color-surface-1)",
+    "--diffs-bg-separator-override": "var(--og-color-surface-1)",
+    // Pierre's default (fg mixed 65% into bg) falls under 4.5:1 on the lifted
+    // graphite separator; quiet meta text keeps AA on every diff surface.
+    "--diffs-fg-number-override": "var(--og-color-fg-subtle)",
+    "--diffs-font-size": "var(--og-code-font-size)",
+    "--diffs-line-height": "var(--og-code-line-height)"
+  };
+  return /* @__PURE__ */ jsx2("div", { className: cn("min-w-0", className), "data-opengeni-pierre-file": true, style: pierreVars, children: /* @__PURE__ */ jsx2(Suspense, { fallback: loading ?? /* @__PURE__ */ jsx2(FileSkeleton, {}), children: ready ? /* @__PURE__ */ jsx2(
+    LazyFile,
+    {
+      file: { name, contents },
+      options,
+      ...disableWorkerPool !== void 0 ? { disableWorkerPool } : {}
+    }
+  ) : loading ?? /* @__PURE__ */ jsx2(FileSkeleton, {}) }) });
+}
+function PlainFile({ name, contents }) {
+  return /* @__PURE__ */ jsx2(
+    "pre",
+    {
+      className: "overflow-auto whitespace-pre p-2 font-og-mono text-og-sm text-og-fg",
+      "data-file": name,
+      children: contents
+    }
+  );
+}
+function FileSkeleton() {
+  return /* @__PURE__ */ jsx2("div", { className: "p-3 text-og-sm text-og-fg-subtle", children: "Loading file\u2026" });
+}
+
+// src/components/sandbox-files.tsx
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
+function SandboxFiles({
+  files,
+  git,
+  fileSystemAvailable = true,
+  usePierre = true,
+  editable = true,
+  onEditIntent,
+  initialSelectedPath,
+  onSelectedPathChange,
+  isNodeVisible,
+  requestedPath,
+  requestedLine,
+  requestedPathRequestId,
+  requestedPathReady = true,
+  workspaceResting = false,
+  workspaceWaking = false,
+  liveWorkspaceReady = true,
+  workspaceError = null,
+  onWakeWorkspace,
+  themeType,
+  className
+}) {
+  const [selected, setSelected] = useState4(() => initialSelectedPath ?? null);
+  const [editMode, setEditMode] = useState4(false);
+  const [focusLine, setFocusLine] = useState4(null);
+  const [treeRevealRequest, setTreeRevealRequest] = useState4(null);
+  const [liveRequestedPath, setLiveRequestedPath] = useState4(null);
+  const [viewReloadRevision, setViewReloadRevision] = useState4(0);
+  const viewerScrollRef = useRef3(null);
+  const pendingRequestRef = useRef3(null);
+  const handledRequestRef = useRef3(null);
+  const requestKey = requestedPath ? requestedPathRequestId ?? requestedPath : null;
+  useEffect5(() => {
+    if (!requestedPath || requestKey === null) {
+      pendingRequestRef.current = null;
+      handledRequestRef.current = null;
+      setTreeRevealRequest(null);
+      return;
+    }
+    if (handledRequestRef.current === requestKey) {
+      return;
+    }
+    if (!requestedPathReady) {
+      pendingRequestRef.current = requestKey;
+      setTreeRevealRequest(null);
+      return;
+    }
+    if (isNodeVisible && files.loading && files.tree.length === 0) return;
+    if (isNodeVisible && !files.loading && files.tree.length === 0) {
+      handledRequestRef.current = requestKey;
+      pendingRequestRef.current = null;
+      setTreeRevealRequest(null);
+      return;
+    }
+    if (filePathVisibility(files.tree, requestedPath, isNodeVisible) === "hidden") {
+      handledRequestRef.current = requestKey;
+      pendingRequestRef.current = null;
+      setTreeRevealRequest(null);
+      return;
+    }
+    handledRequestRef.current = requestKey;
+    pendingRequestRef.current = null;
+    setSelected(requestedPath);
+    onSelectedPathChange?.(requestedPath);
+    setEditMode(false);
+    setFocusLine(requestedLine != null && requestedLine > 0 ? requestedLine : null);
+    setTreeRevealRequest({ path: requestedPath, requestId: requestKey });
+    setViewReloadRevision((revision) => revision + 1);
+  }, [
+    files.loading,
+    files.tree,
+    isNodeVisible,
+    onSelectedPathChange,
+    requestKey,
+    requestedLine,
+    requestedPath,
+    requestedPathReady
+  ]);
+  const rootRef = useRef3(null);
+  const [wide, setWide] = useState4(false);
+  useEffect5(() => {
+    const el = rootRef.current;
+    if (!el) return;
+    const update = () => setWide(el.getBoundingClientRect().width >= 720);
+    update();
+    if (typeof ResizeObserver === "undefined") return;
+    const observer = new ResizeObserver(update);
+    observer.observe(el);
+    const surface = el.closest("[data-workspace-surface]");
+    const surfaceObserver = surface && typeof MutationObserver !== "undefined" ? new MutationObserver(update) : null;
+    surfaceObserver?.observe(surface, {
+      attributes: true,
+      attributeFilter: ["class", "style"]
+    });
+    return () => {
+      observer.disconnect();
+      surfaceObserver?.disconnect();
+    };
+  }, []);
+  const resolvedTheme = useThemeType(themeType);
+  const selectedVisibility = selected ? filePathVisibility(files.tree, selected, isNodeVisible) : "unknown";
+  const visibilityPending = Boolean(isNodeVisible && files.loading && files.tree.length === 0);
+  const viewPath = selectedVisibility === "hidden" || visibilityPending ? null : selected;
+  useEffect5(() => {
+    if (selected === null || selectedVisibility !== "hidden") return;
+    setSelected(null);
+    onSelectedPathChange?.(null);
+    setEditMode(false);
+    setFocusLine(null);
+    setTreeRevealRequest(null);
+    setLiveRequestedPath(null);
+  }, [onSelectedPathChange, selected, selectedVisibility]);
+  const fileView = useFileView(
+    viewPath,
+    files.readFile,
+    `${files.contentRevision ?? 0}:${viewReloadRevision}`
+  );
+  useEffect5(() => {
+    if (focusLine === null && viewReloadRevision > 0 && viewerScrollRef.current) {
+      viewerScrollRef.current.scrollTop = 0;
+    }
+  }, [focusLine, viewReloadRevision]);
+  const selectFile = useCallback3(
+    (path) => {
+      if (pendingRequestRef.current !== null) {
+        handledRequestRef.current = pendingRequestRef.current;
+        pendingRequestRef.current = null;
+      }
+      setSelected(path);
+      onSelectedPathChange?.(path);
+      setEditMode(false);
+      setFocusLine(null);
+      setTreeRevealRequest(null);
+      setLiveRequestedPath(null);
+      setViewReloadRevision(0);
+    },
+    [onSelectedPathChange]
+  );
+  const canEdit = editable && viewPath !== null && !fileView.loading && fileView.error === null && !fileView.isBinary && !fileView.truncated && fileView.content !== null;
+  const showEditor = canEdit && editMode;
+  const captureFileUnavailable = fileView.error instanceof CapturedFileUnavailableError ? fileView.error : null;
+  const waitingForSelectedFile = !workspaceError && liveRequestedPath === viewPath && (!liveWorkspaceReady || files.loading) && captureFileUnavailable !== null;
+  if (workspaceError && !liveWorkspaceReady && files.source !== "capture") {
+    return /* @__PURE__ */ jsxs2(Notice, { className, title: "Could not open live workspace", announce: "alert", children: [
+      /* @__PURE__ */ jsx3("p", { children: workspaceError.message }),
+      onWakeWorkspace ? /* @__PURE__ */ jsx3(WakeButton, { onClick: onWakeWorkspace, children: "Retry live workspace" }) : null
+    ] });
+  }
+  if (workspaceResting || workspaceWaking) {
+    return /* @__PURE__ */ jsx3("div", { className: cn("h-full", className), "data-opengeni-workspace-resting": true, children: /* @__PURE__ */ jsxs2(
+      Notice,
+      {
+        icon: workspaceWaking ? /* @__PURE__ */ jsx3(
+          LoaderCircleIcon,
+          {
+            className: "size-5 animate-spin motion-reduce:animate-none",
+            "aria-hidden": true
+          }
+        ) : /* @__PURE__ */ jsx3(FileCode2Icon, { className: "size-5", "aria-hidden": true }),
+        title: workspaceWaking ? "Waking workspace" : "Workspace is resting",
+        announce: "status",
+        children: [
+          /* @__PURE__ */ jsx3("p", { children: workspaceWaking ? "Connecting to the live file system\u2026" : "No captured revision is available yet. Wake the sandbox to browse its current files." }),
+          !workspaceWaking && onWakeWorkspace ? /* @__PURE__ */ jsx3(WakeButton, { onClick: onWakeWorkspace, children: "Open live workspace" }) : null
+        ]
+      }
+    ) });
+  }
+  if (!fileSystemAvailable) {
+    return /* @__PURE__ */ jsx3(
+      Notice,
+      {
+        className,
+        icon: /* @__PURE__ */ jsx3(FileWarningIcon, { className: "size-5", "aria-hidden": true }),
+        title: "Files unavailable",
+        announce: "alert",
+        children: "This sandbox does not expose a file system."
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs2("div", { ref: rootRef, className: cn("flex h-full min-h-0 min-w-0 flex-col", className), children: [
+    /* @__PURE__ */ jsx3(
+      GitHeader,
+      {
+        loading: Boolean(files.loading || files.gitLoading || files.source === null || git?.loading) && files.gitSummary === null,
+        git: files.gitSummary ?? {
+          branch: git?.branch ?? null,
+          isRepo: git?.isRepo ?? false,
+          repoCount: git?.repoCount ?? 0,
+          ahead: git?.ahead ?? 0,
+          behind: git?.behind ?? 0,
+          dirtyCount: git?.diff.length ?? 0
+        }
+      }
+    ),
+    /* @__PURE__ */ jsxs2(
+      Group,
+      {
+        orientation: wide ? "horizontal" : "vertical",
+        className: cn("min-h-0 flex-1", wide ? "flex-row" : "flex-col"),
+        children: [
+          /* @__PURE__ */ jsx3(
+            Panel,
+            {
+              id: "sandbox-files-tree",
+              defaultSize: wide ? "280px" : "40%",
+              minSize: wide ? "180px" : "120px",
+              maxSize: wide ? "60%" : "70%",
+              className: "flex min-h-0 min-w-0 flex-col",
+              children: /* @__PURE__ */ jsx3(
+                FileBrowser,
+                {
+                  result: files,
+                  isNodeVisible,
+                  selectedPath: selected ?? void 0,
+                  ...treeRevealRequest ? {
+                    revealPath: treeRevealRequest.path,
+                    revealPathRequestId: treeRevealRequest.requestId
+                  } : {},
+                  onSelectFile: selectFile,
+                  editable,
+                  emptyState: "This directory is empty",
+                  className: "min-w-0 flex-1"
+                }
+              )
+            }
+          ),
+          /* @__PURE__ */ jsx3(
+            Separator,
+            {
+              "aria-label": "Resize file tree",
+              className: cn(
+                "group relative z-10 shrink-0 cursor-col-resize outline-hidden focus-visible:ring-2 focus-visible:ring-inset focus-visible:ring-og-accent",
+                "w-px bg-og-border after:absolute after:inset-y-0 after:left-1/2 after:w-3 after:-translate-x-1/2",
+                "hover:bg-og-accent focus-visible:bg-og-accent data-[separator-state=dragging]:bg-og-accent",
+                !wide && "h-px w-full cursor-row-resize after:inset-x-0 after:inset-y-auto after:top-1/2 after:h-3 after:w-full after:-translate-x-0 after:-translate-y-1/2"
+              )
+            }
+          ),
+          /* @__PURE__ */ jsxs2(
+            Panel,
+            {
+              id: "sandbox-files-viewer",
+              minSize: wide ? "240px" : "160px",
+              className: cn("flex min-h-0 min-w-0 flex-col", !wide && "border-t border-og-border"),
+              children: [
+                /* @__PURE__ */ jsxs2("div", { className: "flex shrink-0 items-center justify-between gap-2 border-b border-og-border bg-og-surface-1 px-2 py-1", children: [
+                  /* @__PURE__ */ jsx3(
+                    "span",
+                    {
+                      "data-opengeni-selected-file": true,
+                      className: "min-w-0 truncate font-og-mono text-og-xs text-og-fg-muted",
+                      children: selected ? focusLine !== null ? `${selected}:${focusLine}` : selected : "No file selected"
+                    }
+                  ),
+                  canEdit && /* @__PURE__ */ jsx3(
+                    Segmented,
+                    {
+                      options: [
+                        { value: "view", label: "View" },
+                        { value: "edit", label: "Edit" }
+                      ],
+                      value: editMode ? "edit" : "view",
+                      onChange: (v) => setEditMode(v === "edit")
+                    }
+                  )
+                ] }),
+                /* @__PURE__ */ jsx3(
+                  "div",
+                  {
+                    ref: viewerScrollRef,
+                    className: "min-h-0 flex-1 overflow-auto",
+                    "data-opengeni-file-viewer-scroll": true,
+                    children: viewPath ? showEditor && fileView.content !== null ? /* @__PURE__ */ jsx3(
+                      CodeEditor,
+                      {
+                        path: viewPath,
+                        initialContents: fileView.content,
+                        themeType: resolvedTheme,
+                        onSave: (contents, expectedContents) => files.writeFile(viewPath, contents, { expectedContent: expectedContents }),
+                        onOverwrite: (contents) => files.writeFile(viewPath, contents, { force: true }),
+                        onReload: () => setViewReloadRevision((revision) => revision + 1),
+                        ...onEditIntent ? { onEditIntent } : {},
+                        className: "h-full"
+                      },
+                      viewPath
+                    ) : workspaceError && (liveRequestedPath === viewPath || requestedPath === viewPath) && !liveWorkspaceReady ? /* @__PURE__ */ jsxs2(Notice, { title: "Could not open live file", announce: "alert", children: [
+                      /* @__PURE__ */ jsx3("p", { children: workspaceError.message }),
+                      onWakeWorkspace ? /* @__PURE__ */ jsx3(WakeButton, { onClick: onWakeWorkspace, children: "Retry live file" }) : null
+                    ] }) : waitingForSelectedFile ? /* @__PURE__ */ jsxs2(
+                      Notice,
+                      {
+                        icon: /* @__PURE__ */ jsx3(
+                          LoaderCircleIcon,
+                          {
+                            className: "size-5 animate-spin motion-reduce:animate-none",
+                            "aria-hidden": true
+                          }
+                        ),
+                        title: "Waking workspace",
+                        announce: "status",
+                        children: [
+                          "Opening ",
+                          viewPath,
+                          " when the live file system is ready\u2026"
+                        ]
+                      }
+                    ) : captureFileUnavailable ? /* @__PURE__ */ jsxs2(Notice, { icon: /* @__PURE__ */ jsx3(FileCode2Icon, { className: "size-5", "aria-hidden": true }), title: "On machine", children: [
+                      /* @__PURE__ */ jsx3("p", { children: captureFileUnavailable.reason === "too-large" ? "This file is larger than the captured preview limit." : captureFileUnavailable.reason === "content-missing" ? "The captured copy is no longer available." : "This file was indexed, but it was not changed in the captured turn." }),
+                      onWakeWorkspace ? /* @__PURE__ */ jsx3(
+                        WakeButton,
+                        {
+                          onClick: () => {
+                            setLiveRequestedPath(viewPath);
+                            if (liveWorkspaceReady) void files.refresh();
+                            else onWakeWorkspace();
+                          },
+                          children: liveWorkspaceReady ? "Retry live file" : "Open live file"
+                        }
+                      ) : null
+                    ] }) : fileView.error ? /* @__PURE__ */ jsxs2(Notice, { announce: "alert", children: [
+                      "Could not open ",
+                      viewPath,
+                      ": ",
+                      fileView.error.message
+                    ] }) : fileView.loading ? /* @__PURE__ */ jsxs2(Notice, { announce: "status", children: [
+                      "Loading ",
+                      viewPath,
+                      "\u2026"
+                    ] }) : fileView.imageUrl ? /* @__PURE__ */ jsx3(
+                      RasterFilePreview,
+                      {
+                        src: fileView.imageUrl,
+                        path: viewPath
+                      },
+                      fileView.imageUrl
+                    ) : fileView.isBinary ? /* @__PURE__ */ jsxs2(Notice, { children: [
+                      viewPath,
+                      " is a binary file (",
+                      fileView.sizeBytes ?? 0,
+                      " bytes)."
+                    ] }) : fileView.content !== null ? /* @__PURE__ */ jsxs2(Fragment2, { children: [
+                      fileView.truncated && /* @__PURE__ */ jsxs2("div", { className: "border-b border-og-border bg-og-surface-1 px-2 py-1 text-og-xs text-og-status-running", children: [
+                        "Large file \u2014 showing a truncated preview (",
+                        fileView.sizeBytes ?? 0,
+                        " bytes loaded). Editing is disabled to avoid corrupting the file."
+                      ] }),
+                      usePierre && focusLine === null ? /* @__PURE__ */ jsx3(
+                        PierreFile,
+                        {
+                          path: viewPath,
+                          contents: fileView.content,
+                          themeType: resolvedTheme,
+                          fallback: /* @__PURE__ */ jsx3("pre", { className: "overflow-auto whitespace-pre p-2 font-og-mono text-og-sm text-og-fg", children: fileView.content }),
+                          className: "p-1"
+                        },
+                        `${viewPath}:${viewReloadRevision}`
+                      ) : focusLine !== null ? /* @__PURE__ */ jsx3(
+                        LineNumberedFile,
+                        {
+                          path: viewPath,
+                          contents: fileView.content,
+                          focusLine
+                        }
+                      ) : /* @__PURE__ */ jsx3("pre", { className: "overflow-auto whitespace-pre p-2 font-og-mono text-og-sm text-og-fg", children: fileView.content })
+                    ] }) : /* @__PURE__ */ jsxs2(Notice, { announce: "status", children: [
+                      "Loading ",
+                      viewPath,
+                      "\u2026"
+                    ] }) : (
+                      // Nothing selected — the tree shows the whole workspace; pick a file.
+                      requestedPath && !requestedPathReady ? workspaceError ? /* @__PURE__ */ jsxs2(Notice, { title: "Could not open live file", announce: "alert", children: [
+                        /* @__PURE__ */ jsx3("p", { children: workspaceError.message }),
+                        onWakeWorkspace ? /* @__PURE__ */ jsx3(WakeButton, { onClick: onWakeWorkspace, children: "Retry live file" }) : null
+                      ] }) : /* @__PURE__ */ jsxs2(
+                        Notice,
+                        {
+                          icon: /* @__PURE__ */ jsx3(
+                            LoaderCircleIcon,
+                            {
+                              className: "size-5 animate-spin motion-reduce:animate-none",
+                              "aria-hidden": true
+                            }
+                          ),
+                          title: "Waking sandbox",
+                          announce: "status",
+                          children: [
+                            "Opening ",
+                            requestedPath,
+                            " when the live workspace is ready\u2026"
+                          ]
+                        }
+                      ) : /* @__PURE__ */ jsx3(Notice, { icon: /* @__PURE__ */ jsx3(FileCode2Icon, { className: "size-5", "aria-hidden": true }), title: "Choose a file", children: "Select a file in the tree to preview it." })
+                    )
+                  }
+                )
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+function WakeButton({ children, onClick }) {
+  return /* @__PURE__ */ jsx3(
+    "button",
+    {
+      type: "button",
+      onClick,
+      className: "mt-1 inline-flex min-h-11 items-center justify-center rounded-og-md border border-og-primary-border bg-og-primary text-og-primary-fg px-3 py-2 text-og-sm font-medium transition-colors hover:bg-og-primary-hover focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent focus-visible:ring-offset-2 focus-visible:ring-offset-og-bg",
+      children
+    }
+  );
+}
+function LineNumberedFile({
+  path,
+  contents,
+  focusLine
+}) {
+  const lines = contents.split("\n");
+  const inRange = focusLine >= 1 && focusLine <= lines.length;
+  const targetRef = useRef3(null);
+  useEffect5(() => {
+    targetRef.current?.scrollIntoView({
+      block: "center",
+      behavior: prefersReducedMotion() ? "auto" : "smooth"
+    });
+  }, [path, focusLine, contents]);
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: "h-full min-h-0 overflow-auto font-og-mono text-og-sm text-og-fg",
+      role: "region",
+      "aria-label": inRange ? `${path} at line ${focusLine}` : path,
+      children: [
+        !inRange ? /* @__PURE__ */ jsxs2(
+          "p",
+          {
+            className: "border-b border-og-border bg-og-surface-1 px-2 py-1 text-og-xs text-og-fg-muted",
+            role: "status",
+            children: [
+              "Line ",
+              focusLine,
+              " is past the end of this file."
+            ]
+          }
+        ) : null,
+        /* @__PURE__ */ jsx3("div", { children: lines.map((text, index) => {
+          const lineNumber = index + 1;
+          const focused = inRange && lineNumber === focusLine;
+          return /* @__PURE__ */ jsxs2(
+            "div",
+            {
+              ref: focused ? targetRef : void 0,
+              "data-opengeni-file-line": lineNumber,
+              ...focused ? { "data-opengeni-focus-line": "" } : {},
+              "aria-current": focused ? "location" : void 0,
+              className: cn("flex gap-3 px-2 py-0.5 leading-6", focused && "bg-og-accent-soft"),
+              children: [
+                /* @__PURE__ */ jsx3("span", { className: "w-11 shrink-0 select-none text-right tabular-nums text-og-fg-subtle", children: lineNumber }),
+                /* @__PURE__ */ jsx3("pre", { className: "min-w-0 flex-1 whitespace-pre-wrap break-words", children: text || " " })
+              ]
+            },
+            lineNumber
+          );
+        }) })
+      ]
+    }
+  );
+}
+function GitHeader({ git, loading }) {
+  if (loading) {
+    return /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        className: "flex shrink-0 items-center gap-2 border-b border-og-border bg-og-surface-1 px-2 py-1 text-og-sm text-og-fg-muted",
+        role: "status",
+        "aria-live": "polite",
+        children: [
+          /* @__PURE__ */ jsx3(
+            LoaderCircleIcon,
+            {
+              className: "size-3.5 shrink-0 animate-spin motion-reduce:animate-none",
+              "aria-hidden": true
+            }
+          ),
+          /* @__PURE__ */ jsx3("span", { children: "Loading repository\u2026" })
+        ]
+      }
+    );
+  }
+  const dirty = git.dirtyCount > 0;
+  return /* @__PURE__ */ jsxs2("div", { className: "flex shrink-0 items-center gap-2 border-b border-og-border bg-og-surface-1 px-2 py-1 text-og-sm", children: [
+    /* @__PURE__ */ jsx3(
+      "span",
+      {
+        "aria-hidden": "true",
+        className: cn(
+          "size-2 shrink-0 rounded-full",
+          dirty ? "bg-og-status-running" : "bg-og-status-idle"
+        )
+      }
+    ),
+    /* @__PURE__ */ jsx3("span", { className: "sr-only", children: dirty ? `Uncommitted changes in ${git.dirtyCount} files` : "No uncommitted changes" }),
+    /* @__PURE__ */ jsx3("span", { className: "truncate font-og-mono text-og-fg", children: git.repoCount > 1 ? `${git.repoCount} repositories` : git.branch ?? (git.isRepo ? "(detached)" : "no repo") }),
+    (git.ahead > 0 || git.behind > 0) && /* @__PURE__ */ jsxs2("span", { className: "flex shrink-0 items-center gap-1.5 text-og-xs text-og-fg-subtle", children: [
+      git.ahead > 0 && /* @__PURE__ */ jsxs2("span", { "data-contrast-audited": true, children: [
+        "\u2191",
+        git.ahead
+      ] }),
+      git.behind > 0 && /* @__PURE__ */ jsxs2("span", { "data-contrast-audited": true, children: [
+        "\u2193",
+        git.behind
+      ] })
+    ] }),
+    dirty && /* @__PURE__ */ jsxs2(
+      "span",
+      {
+        "aria-hidden": "true",
+        "data-contrast-audited": true,
+        className: "ml-auto shrink-0 text-og-xs text-og-fg-subtle",
+        children: [
+          git.dirtyCount,
+          " changed"
+        ]
+      }
+    )
+  ] });
+}
+function Segmented({
+  options,
+  value,
+  onChange
+}) {
+  return /* @__PURE__ */ jsx3("div", { className: "flex flex-wrap items-center rounded-og-sm border border-og-border p-0.5", children: options.map((opt) => /* @__PURE__ */ jsx3(
+    "button",
+    {
+      type: "button",
+      onClick: () => onChange(opt.value),
+      className: cn(
+        "min-h-7 rounded-og-xs px-1.5 py-0.5 text-og-xs focus-visible:outline-hidden focus-visible:ring-2 focus-visible:ring-og-accent max-[1023px]:min-h-11 max-[1023px]:min-w-11 pointer-coarse:min-h-11 pointer-coarse:min-w-11",
+        opt.value === value ? "bg-og-accent-soft text-og-fg" : "text-og-fg-subtle hover:text-og-fg"
+      ),
+      children: opt.label
+    },
+    opt.value
+  )) });
+}
+function useFileView(path, readFile, reloadRevision = 0) {
+  const previousPathRef = useRef3(null);
+  const [state, setState] = useState4({
+    content: null,
+    isBinary: false,
+    truncated: false,
+    sizeBytes: null,
+    loading: false,
+    error: null
+  });
+  useEffect5(() => {
+    if (!path) {
+      previousPathRef.current = null;
+      setState({
+        content: null,
+        isBinary: false,
+        truncated: false,
+        sizeBytes: null,
+        loading: false,
+        error: null
+      });
+      return;
+    }
+    const pathChanged = previousPathRef.current !== path;
+    previousPathRef.current = path;
+    let cancelled = false;
+    const abort = new AbortController();
+    if (pathChanged) {
+      setState({
+        content: null,
+        isBinary: false,
+        truncated: false,
+        sizeBytes: null,
+        loading: true,
+        error: null
+      });
+    } else {
+      setState((previous) => ({ ...previous, error: null }));
+    }
+    void readFile(path, { signal: abort.signal }).then((res) => {
+      if (cancelled) return;
+      const content = res.isBinary ? null : res.encoding === "base64" ? decodeBase64Utf8(res.content) : res.content;
+      setState({
+        content,
+        imageUrl: !res.truncated && res.encoding === "base64" ? rasterImageUrl(path, res.content) : null,
+        isBinary: res.isBinary,
+        truncated: res.truncated,
+        sizeBytes: res.sizeBytes,
+        loading: false,
+        error: null
+      });
+    }).catch((cause) => {
+      if (cancelled) return;
+      const error = cause instanceof Error ? cause : new Error(String(cause));
+      setState(
+        (previous) => pathChanged ? {
+          content: null,
+          isBinary: false,
+          truncated: false,
+          sizeBytes: null,
+          loading: false,
+          error
+        } : { ...previous, loading: false, error }
+      );
+    });
+    return () => {
+      cancelled = true;
+      abort.abort();
+    };
+  }, [path, readFile, reloadRevision]);
+  return state;
+}
+function rasterImageUrl(path, content) {
+  const extension = path.split(".").pop()?.toLowerCase();
+  const mime = extension === "png" ? "image/png" : extension === "jpg" || extension === "jpeg" ? "image/jpeg" : extension === "gif" ? "image/gif" : extension === "webp" ? "image/webp" : null;
+  return mime ? `data:${mime};base64,${content}` : null;
+}
+function RasterFilePreview({ src, path }) {
+  const [failed, setFailed] = useState4(false);
+  return failed ? /* @__PURE__ */ jsxs2(Notice, { title: "Image preview unavailable", announce: "alert", children: [
+    "Could not decode ",
+    path,
+    " as an image."
+  ] }) : /* @__PURE__ */ jsx3(
+    "img",
+    {
+      src,
+      alt: path,
+      onError: () => setFailed(true),
+      className: "max-w-full object-contain"
+    }
+  );
+}
+function decodeBase64Utf8(b64) {
+  try {
+    if (typeof atob === "function") {
+      const binary = atob(b64);
+      const bytes = new Uint8Array(binary.length);
+      for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+      return new TextDecoder().decode(bytes);
+    }
+  } catch {
+  }
+  return b64;
+}
+function Notice({
+  children,
+  className,
+  icon,
+  title,
+  announce
+}) {
+  return /* @__PURE__ */ jsx3(
+    "div",
+    {
+      role: announce,
+      "aria-atomic": announce ? "true" : void 0,
+      "aria-live": announce === "alert" ? "assertive" : announce === "status" ? "polite" : void 0,
+      className: cn(
+        "flex h-full items-center justify-center p-4 text-center text-og-sm text-og-fg-subtle",
+        className
+      ),
+      children: /* @__PURE__ */ jsxs2("div", { className: "flex max-w-sm flex-col items-center gap-2.5", children: [
+        icon ? /* @__PURE__ */ jsx3("span", { className: "grid size-10 place-items-center rounded-og-lg border border-og-border bg-og-surface-1 text-og-fg-muted shadow-sm", children: icon }) : null,
+        title ? /* @__PURE__ */ jsx3("p", { className: "font-medium text-og-fg", children: title }) : null,
+        /* @__PURE__ */ jsx3("div", { "data-contrast-audited": true, className: "leading-5", children })
+      ] })
+    }
+  );
+}
+
+export {
+  visibleFileTree,
+  filePathVisibility,
+  CapturedFileUnavailableError,
+  FileWriteConflictError,
+  useSandboxFiles,
+  useUnicodeFallbackFonts,
+  FileBrowser,
+  PierreFile,
+  SandboxFiles
+};
+//# sourceMappingURL=chunk-EGVHJKGJ.js.map