@tutti-os/workspace-file-manager 0.0.1

package/dist/index.js

@@ -0,0 +1,2802 @@
+import {
+  buildWorkspaceFileBreadcrumbs,
+  classifyWorkspaceFilePreviewKind,
+  createWorkspaceFileManagerService,
+  decodeWorkspaceTextFile,
+  formatWorkspaceFileBytes,
+  formatWorkspaceFileModifiedTime,
+  isWorkspaceFileBrowserOpenable,
+  isWorkspaceTextFileTooLarge,
+  looksLikeBinaryText,
+  normalizeWorkspaceFilePath,
+  resolveWorkspaceFileActivationTarget,
+  resolveWorkspaceFileExtension,
+  resolveWorkspaceFileVisualKind,
+  resolveWorkspaceImageMimeType,
+  splitWorkspaceFileName,
+  workspaceFilePreviewMaxBytes,
+  workspaceFileTextMaxBytes
+} from "./chunk-IMOFXYBB.js";
+import {
+  createWorkspaceFileManagerI18nRuntime,
+  resolveRevealInFolderLabel,
+  workspaceFileManagerI18nNamespace,
+  workspaceFileManagerI18nResources
+} from "./chunk-2AG4ND4D.js";
+
+// src/ui/WorkspaceFileManager.tsx
+import { useEffect as useEffect3, useRef as useRef3, useState as useState4 } from "react";
+import { cn as cn4 } from "@tutti-os/ui-system";
+
+// src/ui/WorkspaceFileManagerMenus.tsx
+import {
+  ArrowRightIcon,
+  Button,
+  ConfirmationDialog,
+  CopyIcon,
+  DeleteIcon,
+  DownloadIcon,
+  EditIcon,
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  EyeIcon,
+  FileLinedIcon,
+  Input,
+  LaunchIcon,
+  LocateFolderIcon,
+  MenuSurface,
+  NewWorkspaceLinedIcon,
+  UploadIcon as ImportIcon,
+  ViewportMenuSurface,
+  WebIcon,
+  cn
+} from "@tutti-os/ui-system";
+import {
+  useCallback,
+  useEffect,
+  useLayoutEffect,
+  useRef,
+  useState
+} from "react";
+
+// src/ui/contextMenuPlacement.ts
+var CONTEXT_MENU_ITEM_HEIGHT_PX = 32;
+var CONTEXT_MENU_PADDING_PX = 8;
+var CONTEXT_MENU_SUBMENU_GAP_PX = 4;
+function clampContextMenuPosition(input) {
+  const padding = input.padding ?? CONTEXT_MENU_PADDING_PX;
+  const maxX = Math.max(
+    padding,
+    input.boundaryWidth - input.menuWidth - padding
+  );
+  const maxY = Math.max(
+    padding,
+    input.boundaryHeight - input.menuHeight - padding
+  );
+  return {
+    x: Math.min(Math.max(input.x, padding), maxX),
+    y: Math.min(Math.max(input.y, padding), maxY)
+  };
+}
+function estimateOpenWithSubmenuHeight(input) {
+  let itemCount = 0;
+  if (input.showOpenInAppBrowser) {
+    itemCount += 1;
+  }
+  if (input.showExternalSection) {
+    itemCount += 1;
+  }
+  if (input.isLoading) {
+    itemCount += 1;
+  }
+  itemCount += input.applicationCount;
+  if (input.showOpenInDefaultBrowser) {
+    itemCount += 1;
+  }
+  if (input.showOpenWithOther) {
+    itemCount += 2;
+  }
+  return itemCount * CONTEXT_MENU_ITEM_HEIGHT_PX + CONTEXT_MENU_PADDING_PX * 2;
+}
+
+// src/ui/WorkspaceFileManagerMenus.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function WorkspaceFileManagerContextMenu({
+  busy,
+  copy,
+  contextMenu,
+  contextMenuRef,
+  openInAppBrowserIcon,
+  showCopyAction,
+  showImportAction,
+  showExportAction,
+  showOpenInAppBrowserAction,
+  showOpenInDefaultBrowserAction,
+  showOpenWithAction,
+  showOpenWithOtherAction,
+  showRevealInFolderAction,
+  showRenameAction,
+  revealInFolderLabel,
+  openWithApplications,
+  openWithLoading,
+  resolveOpenWithApplicationIcon,
+  onClose,
+  onCreateDirectory,
+  onCreateFile,
+  onCopy,
+  onCopyPath,
+  onDelete,
+  onExport,
+  onOpen,
+  onOpenInAppBrowser,
+  onOpenInDefaultBrowser,
+  onOpenWithApplication,
+  onOpenWithOtherApplication,
+  onImport,
+  onRevealInFolder,
+  onRename
+}) {
+  const [position, setPosition] = useState({
+    x: contextMenu?.x ?? 0,
+    y: contextMenu?.y ?? 0
+  });
+  useLayoutEffect(() => {
+    if (!contextMenu) {
+      return;
+    }
+    setPosition({ x: contextMenu.x, y: contextMenu.y });
+  }, [contextMenu?.x, contextMenu?.y]);
+  useLayoutEffect(() => {
+    if (!contextMenu) {
+      return;
+    }
+    const menu = contextMenuRef.current;
+    const boundary = menu?.closest("[data-workspace-file-manager]");
+    if (!menu || !boundary) {
+      return;
+    }
+    const boundaryRect = boundary.getBoundingClientRect();
+    const menuRect = menu.getBoundingClientRect();
+    setPosition(
+      clampContextMenuPosition({
+        boundaryHeight: boundaryRect.height,
+        boundaryWidth: boundaryRect.width,
+        menuHeight: menuRect.height,
+        menuWidth: menuRect.width,
+        x: contextMenu.x,
+        y: contextMenu.y
+      })
+    );
+  }, [
+    contextMenu,
+    contextMenuRef,
+    openWithApplications.length,
+    openWithLoading,
+    showCopyAction,
+    showExportAction,
+    showImportAction,
+    showOpenInAppBrowserAction,
+    showOpenInDefaultBrowserAction,
+    showOpenWithAction,
+    showOpenWithOtherAction,
+    showRevealInFolderAction,
+    showRenameAction
+  ]);
+  if (!contextMenu) {
+    return null;
+  }
+  const entry = contextMenu.entry;
+  const isDirectory = entry?.kind === "directory";
+  const editItems = [];
+  const transferItems = [];
+  const dangerItems = [];
+  const createItems = [];
+  if (entry) {
+    if (showRenameAction) {
+      editItems.push({
+        action: onRename,
+        disabled: busy,
+        icon: /* @__PURE__ */ jsx(EditIcon, { className: "size-4" }),
+        key: "rename",
+        label: copy.t("renameLabel")
+      });
+    }
+    if (showCopyAction) {
+      editItems.push({
+        action: onCopy,
+        disabled: busy,
+        icon: /* @__PURE__ */ jsx(CopyIcon, { className: "size-4" }),
+        key: "copy",
+        label: copy.t("copyLabel")
+      });
+    }
+    editItems.push({
+      action: onCopyPath,
+      disabled: busy,
+      icon: /* @__PURE__ */ jsx(CopyIcon, { className: "size-4" }),
+      key: "copy-path",
+      label: copy.t("copyPathLabel")
+    });
+    if (showRevealInFolderAction) {
+      editItems.push({
+        action: onRevealInFolder,
+        disabled: busy,
+        icon: /* @__PURE__ */ jsx(LocateFolderIcon, { className: "size-4" }),
+        key: "reveal-in-folder",
+        label: revealInFolderLabel
+      });
+    }
+    if (isDirectory && showImportAction) {
+      transferItems.push({
+        action: onImport,
+        disabled: busy,
+        icon: /* @__PURE__ */ jsx(ImportIcon, { className: "size-4" }),
+        key: "import",
+        label: copy.t("importLabel")
+      });
+    }
+    if (showExportAction) {
+      transferItems.push({
+        action: onExport,
+        disabled: busy,
+        icon: /* @__PURE__ */ jsx(DownloadIcon, { className: "size-4" }),
+        key: "export",
+        label: copy.t("downloadLabel")
+      });
+    }
+    dangerItems.push({
+      action: onDelete,
+      disabled: busy,
+      danger: true,
+      icon: /* @__PURE__ */ jsx(DeleteIcon, { className: "size-4" }),
+      key: "delete",
+      label: copy.t("deleteLabel")
+    });
+  } else {
+    createItems.push({
+      action: onCreateFile,
+      disabled: busy,
+      icon: /* @__PURE__ */ jsx(NewWorkspaceLinedIcon, { className: "size-4" }),
+      key: "create-file",
+      label: copy.t("createFileLabel")
+    });
+    createItems.push({
+      action: onCreateDirectory,
+      disabled: busy,
+      icon: /* @__PURE__ */ jsx(FileLinedIcon, { className: "size-4" }),
+      key: "create-directory",
+      label: copy.t("createDirectoryLabel")
+    });
+    if (showImportAction) {
+      transferItems.push({
+        action: onImport,
+        disabled: busy,
+        icon: /* @__PURE__ */ jsx(ImportIcon, { className: "size-4" }),
+        key: "import",
+        label: copy.t("importLabel")
+      });
+    }
+  }
+  const menuGroups = entry ? [
+    { items: editItems, key: "edit" },
+    { items: transferItems, key: "transfer" },
+    { items: dangerItems, key: "danger" }
+  ] : [
+    { items: createItems, key: "create" },
+    { items: transferItems, key: "transfer" }
+  ];
+  const visibleMenuGroups = menuGroups.filter(
+    (group) => group.items.length > 0
+  );
+  return /* @__PURE__ */ jsxs(
+    MenuSurface,
+    {
+      ref: contextMenuRef,
+      className: "absolute w-[220px] overflow-visible p-1",
+      role: "menu",
+      style: {
+        left: `${position.x}px`,
+        top: `${position.y}px`,
+        zIndex: "calc(var(--workspace-file-manager-dialog-overlay-z-index) - 1)"
+      },
+      onContextMenu: (event) => {
+        event.preventDefault();
+      },
+      children: [
+        entry ? /* @__PURE__ */ jsx(
+          ContextMenuActionButton,
+          {
+            disabled: busy,
+            icon: /* @__PURE__ */ jsx(EyeIcon, { className: "size-4" }),
+            label: copy.t("openLabel"),
+            onClick: () => {
+              onClose();
+              void onOpen();
+            }
+          }
+        ) : null,
+        entry && showOpenWithAction ? /* @__PURE__ */ jsx(
+          OpenWithMenuItem,
+          {
+            applications: openWithApplications,
+            busy,
+            copy,
+            isLoading: openWithLoading,
+            openInAppBrowserIcon,
+            resolveOpenWithApplicationIcon,
+            showOpenInAppBrowser: showOpenInAppBrowserAction,
+            showOpenInDefaultBrowser: showOpenInDefaultBrowserAction,
+            showOpenWithOther: showOpenWithOtherAction,
+            onClose,
+            onOpenInAppBrowser,
+            onOpenInDefaultBrowser,
+            onOpenWithApplication,
+            onOpenWithOtherApplication
+          }
+        ) : null,
+        visibleMenuGroups.map((group, groupIndex) => /* @__PURE__ */ jsx(
+          ContextMenuActionGroup,
+          {
+            items: group.items,
+            showDivider: entry !== null || groupIndex > 0,
+            onClose
+          },
+          group.key
+        ))
+      ]
+    }
+  );
+}
+function ContextMenuActionGroup({
+  items,
+  onClose,
+  showDivider
+}) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    showDivider ? /* @__PURE__ */ jsx(ContextMenuDivider, {}) : null,
+    items.map((item) => /* @__PURE__ */ jsx(
+      ContextMenuActionButton,
+      {
+        danger: item.danger,
+        disabled: item.disabled,
+        icon: item.icon,
+        label: item.label,
+        onClick: () => {
+          onClose();
+          void item.action();
+        }
+      },
+      item.key
+    ))
+  ] });
+}
+function ContextMenuActionButton({
+  danger = false,
+  disabled = false,
+  icon,
+  label,
+  onClick
+}) {
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      className: cn(
+        "flex h-8 w-full items-center gap-2 rounded-md border-0 bg-transparent px-2 text-left text-sm transition-colors disabled:cursor-default disabled:opacity-50",
+        danger ? "text-[var(--state-danger)] hover:bg-[var(--on-danger)]" : "text-[var(--text-primary)] hover:bg-transparency-block"
+      ),
+      disabled,
+      role: "menuitem",
+      type: "button",
+      onClick,
+      children: [
+        /* @__PURE__ */ jsx(
+          "span",
+          {
+            className: cn(
+              "grid size-4 flex-none place-items-center",
+              danger ? "text-[var(--state-danger)]" : "text-[var(--text-secondary)]"
+            ),
+            children: icon
+          }
+        ),
+        label
+      ]
+    }
+  );
+}
+function ContextMenuDivider() {
+  return /* @__PURE__ */ jsx("div", { className: "mx-2 my-0.5 h-px bg-[var(--border-1)]", role: "separator" });
+}
+function OpenWithMenuItem({
+  applications,
+  busy,
+  copy,
+  isLoading,
+  openInAppBrowserIcon,
+  resolveOpenWithApplicationIcon,
+  showOpenInAppBrowser,
+  showOpenInDefaultBrowser,
+  showOpenWithOther,
+  onClose,
+  onOpenInAppBrowser,
+  onOpenInDefaultBrowser,
+  onOpenWithApplication,
+  onOpenWithOtherApplication
+}) {
+  const triggerRef = useRef(null);
+  const [open, setOpen] = useState(false);
+  const [placementPoint, setPlacementPoint] = useState({ x: 0, y: 0 });
+  const closeTimerRef = useRef(null);
+  const showExternalSection = showOpenInDefaultBrowser || showOpenWithOther || isLoading || applications.length > 0;
+  const estimatedSubmenuHeight = estimateOpenWithSubmenuHeight({
+    applicationCount: applications.length,
+    isLoading,
+    showExternalSection,
+    showOpenInAppBrowser,
+    showOpenInDefaultBrowser,
+    showOpenWithOther
+  });
+  const cancelClose = useCallback(() => {
+    if (closeTimerRef.current !== null) {
+      window.clearTimeout(closeTimerRef.current);
+      closeTimerRef.current = null;
+    }
+  }, []);
+  const scheduleClose = useCallback(() => {
+    cancelClose();
+    closeTimerRef.current = window.setTimeout(() => {
+      setOpen(false);
+      closeTimerRef.current = null;
+    }, 120);
+  }, [cancelClose]);
+  const openSubmenu = useCallback(() => {
+    cancelClose();
+    setOpen(true);
+  }, [cancelClose]);
+  useEffect(() => {
+    return () => {
+      cancelClose();
+    };
+  }, [cancelClose]);
+  useLayoutEffect(() => {
+    if (!open) {
+      return;
+    }
+    const trigger = triggerRef.current;
+    if (!trigger) {
+      return;
+    }
+    const rect = trigger.getBoundingClientRect();
+    setPlacementPoint({
+      x: rect.right + CONTEXT_MENU_SUBMENU_GAP_PX,
+      y: rect.top
+    });
+  }, [open, estimatedSubmenuHeight]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: triggerRef,
+      className: "relative",
+      onPointerEnter: openSubmenu,
+      onPointerLeave: scheduleClose,
+      children: [
+        /* @__PURE__ */ jsxs(
+          "button",
+          {
+            "aria-expanded": open,
+            "aria-haspopup": "menu",
+            className: cn(
+              "flex h-8 w-full items-center gap-2 rounded-md border-0 bg-transparent px-2 text-left text-sm text-[var(--text-primary)] transition-colors hover:bg-transparency-block disabled:cursor-default disabled:opacity-50",
+              open && "bg-transparency-block"
+            ),
+            disabled: busy,
+            role: "menuitem",
+            type: "button",
+            onClick: () => {
+              setOpen((current) => {
+                const next = !current;
+                if (next) {
+                  cancelClose();
+                }
+                return next;
+              });
+            },
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "grid size-4 flex-none place-items-center text-[var(--text-secondary)]", children: /* @__PURE__ */ jsx(LaunchIcon, { className: "size-4" }) }),
+              /* @__PURE__ */ jsx("span", { className: "min-w-0 flex-1 truncate", children: copy.t("openWithLabel") }),
+              /* @__PURE__ */ jsx(
+                "span",
+                {
+                  "aria-hidden": "true",
+                  className: "grid size-4 flex-none place-items-center text-[var(--text-tertiary)]",
+                  children: /* @__PURE__ */ jsx(ArrowRightIcon, { className: "size-4" })
+                }
+              )
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(
+          ViewportMenuSurface,
+          {
+            "data-workspace-file-manager-submenu": "",
+            open,
+            className: "w-[220px] max-h-[min(480px,calc(100vh-24px))] overflow-y-auto p-1",
+            dismissOnEscape: false,
+            dismissOnPointerDownOutside: false,
+            dismissOnScroll: false,
+            placement: {
+              type: "point",
+              point: placementPoint,
+              alignX: "start",
+              alignY: "auto",
+              estimatedSize: {
+                width: 220,
+                height: estimatedSubmenuHeight
+              }
+            },
+            role: "menu",
+            onPointerEnter: openSubmenu,
+            onPointerLeave: scheduleClose,
+            children: [
+              showOpenInAppBrowser ? /* @__PURE__ */ jsx(
+                ContextMenuActionButton,
+                {
+                  disabled: busy,
+                  icon: openInAppBrowserIcon ?? /* @__PURE__ */ jsx(WebIcon, { className: "size-4" }),
+                  label: copy.t("openInAppBrowserLabel"),
+                  onClick: () => {
+                    onClose();
+                    void onOpenInAppBrowser();
+                  }
+                }
+              ) : null,
+              showExternalSection ? /* @__PURE__ */ jsx(ContextMenuDivider, {}) : null,
+              isLoading ? /* @__PURE__ */ jsx("div", { className: "px-2 py-1.5 text-xs text-[var(--text-tertiary)]", children: copy.t("openWithLoadingLabel") }) : null,
+              applications.map((application) => {
+                const resolvedIcon = resolveOpenWithApplicationIcon?.(application);
+                return /* @__PURE__ */ jsx(
+                  ContextMenuActionButton,
+                  {
+                    disabled: busy,
+                    icon: resolvedIcon ?? (application.iconDataUrl ? /* @__PURE__ */ jsx(
+                      "img",
+                      {
+                        alt: "",
+                        className: "size-4 rounded-[4px] object-contain",
+                        src: application.iconDataUrl
+                      }
+                    ) : /* @__PURE__ */ jsx(EyeIcon, { className: "size-4" })),
+                    label: application.name,
+                    onClick: () => {
+                      onClose();
+                      void onOpenWithApplication(application.applicationPath);
+                    }
+                  },
+                  application.applicationPath
+                );
+              }),
+              showOpenInDefaultBrowser ? /* @__PURE__ */ jsx(
+                ContextMenuActionButton,
+                {
+                  disabled: busy,
+                  icon: /* @__PURE__ */ jsx(WebIcon, { className: "size-4" }),
+                  label: copy.t("openInDefaultBrowserLabel"),
+                  onClick: () => {
+                    onClose();
+                    void onOpenInDefaultBrowser();
+                  }
+                }
+              ) : null,
+              showOpenWithOther ? /* @__PURE__ */ jsx(
+                ContextMenuActionButton,
+                {
+                  disabled: busy,
+                  icon: /* @__PURE__ */ jsx(LaunchIcon, { className: "size-4" }),
+                  label: copy.t("openWithOtherLabel"),
+                  onClick: () => {
+                    onClose();
+                    void onOpenWithOtherApplication();
+                  }
+                }
+              ) : null
+            ]
+          }
+        )
+      ]
+    }
+  );
+}
+function WorkspaceFileManagerCreateDialog({
+  busy,
+  copy,
+  dialog,
+  onClose,
+  onConfirm,
+  onNameChange
+}) {
+  if (!dialog) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open: true,
+      onOpenChange: (nextOpen) => {
+        if (!nextOpen) {
+          onClose();
+        }
+      },
+      children: /* @__PURE__ */ jsx(DialogContent, { "aria-busy": busy, showCloseButton: false, children: /* @__PURE__ */ jsxs(
+        "form",
+        {
+          className: "grid gap-3",
+          onSubmit: (event) => {
+            event.preventDefault();
+            onConfirm();
+          },
+          children: [
+            /* @__PURE__ */ jsx(DialogHeader, { children: /* @__PURE__ */ jsx(DialogTitle, { children: dialog.kind === "directory" ? copy.t("createDirectoryLabel") : copy.t("createFileLabel") }) }),
+            /* @__PURE__ */ jsx(
+              Input,
+              {
+                autoFocus: true,
+                placeholder: dialog.kind === "directory" ? copy.t("createDirectoryPlaceholder") : copy.t("createFilePlaceholder"),
+                value: dialog.name,
+                onChange: (event) => {
+                  onNameChange(event.currentTarget.value);
+                }
+              }
+            ),
+            dialog.errorMessage ? /* @__PURE__ */ jsx("p", { className: "text-sm text-[var(--state-danger)]", children: dialog.errorMessage }) : null,
+            /* @__PURE__ */ jsxs(DialogFooter, { children: [
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  disabled: busy,
+                  size: "dialog",
+                  type: "button",
+                  variant: "ghost",
+                  onClick: onClose,
+                  children: copy.t("cancelLabel")
+                }
+              ),
+              /* @__PURE__ */ jsx(Button, { disabled: busy, size: "dialog", type: "submit", children: copy.t("createActionLabel") })
+            ] })
+          ]
+        }
+      ) })
+    }
+  );
+}
+function WorkspaceFileManagerDeleteDialog({
+  busy,
+  copy,
+  entry,
+  onClose,
+  onConfirm
+}) {
+  if (!entry) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    ConfirmationDialog,
+    {
+      cancelLabel: copy.t("cancelLabel"),
+      confirmBusy: busy,
+      confirmLabel: busy ? copy.t("deletingLabel") : copy.t("deleteLabel"),
+      description: copy.t("deleteConfirmDescription", { name: entry.name }),
+      open: true,
+      title: copy.t("deleteLabel"),
+      tone: "destructive",
+      onConfirm,
+      onOpenChange: (nextOpen) => {
+        if (!nextOpen) {
+          onClose();
+        }
+      }
+    }
+  );
+}
+function WorkspaceFileManagerUnsupportedDialog({
+  copy,
+  dialog,
+  isViewing,
+  onAction,
+  onClose
+}) {
+  if (!dialog) {
+    return null;
+  }
+  const title = dialog.title ?? (dialog.kind === "import" ? copy.t("unsupportedImportTitle") : copy.t("unsupportedViewTitle"));
+  const body = dialog.message ?? (dialog.kind === "import" ? copy.t("unsupportedImportBody") : copy.t("unsupportedViewBody", { name: dialog.entry?.name ?? "" }));
+  const actions = dialog.actions?.filter((action) => action.kind !== "none") ?? [];
+  return /* @__PURE__ */ jsx(
+    Dialog,
+    {
+      open: true,
+      onOpenChange: (nextOpen) => {
+        if (!nextOpen) {
+          onClose();
+        }
+      },
+      children: /* @__PURE__ */ jsxs(
+        DialogContent,
+        {
+          showCloseButton: false,
+          onEscapeKeyDown: (event) => {
+            if (isViewing) {
+              event.preventDefault();
+            }
+          },
+          onInteractOutside: (event) => {
+            if (isViewing) {
+              event.preventDefault();
+            }
+          },
+          children: [
+            /* @__PURE__ */ jsxs(DialogHeader, { children: [
+              /* @__PURE__ */ jsx(DialogTitle, { children: title }),
+              /* @__PURE__ */ jsx(DialogDescription, { children: body })
+            ] }),
+            /* @__PURE__ */ jsxs(DialogFooter, { children: [
+              /* @__PURE__ */ jsx(
+                Button,
+                {
+                  disabled: isViewing,
+                  size: "dialog",
+                  type: "button",
+                  variant: "ghost",
+                  onClick: onClose,
+                  children: copy.t("closeLabel")
+                }
+              ),
+              actions.map((action) => /* @__PURE__ */ jsx(
+                Button,
+                {
+                  disabled: isViewing,
+                  size: "dialog",
+                  type: "button",
+                  className: "shadow-none",
+                  onClick: () => {
+                    onAction(action);
+                  },
+                  children: action.label ?? (action.kind === "download" ? copy.t("downloadLabel") : copy.t("openLabel"))
+                },
+                action.kind
+              ))
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+function WorkspaceFileManagerImportConflictDialog({
+  busy,
+  copy,
+  dialog,
+  onClose,
+  onConfirm
+}) {
+  if (!dialog) {
+    return null;
+  }
+  const hasBlockedConflict = dialog.conflicts.some(
+    (conflict) => conflict.conflictKind === "type_mismatch"
+  );
+  return /* @__PURE__ */ jsxs(
+    ConfirmationDialog,
+    {
+      cancelLabel: hasBlockedConflict ? copy.t("closeLabel") : copy.t("cancelLabel"),
+      className: "max-w-lg",
+      confirmBusy: busy,
+      confirmLabel: hasBlockedConflict ? copy.t("closeLabel") : copy.t("importConflictReplaceLabel"),
+      description: hasBlockedConflict ? copy.t("importTypeConflictDescription", {
+        count: dialog.conflicts.length
+      }) : copy.t("importConflictDescription", {
+        count: dialog.conflicts.length
+      }),
+      hideConfirmButton: hasBlockedConflict,
+      open: true,
+      title: hasBlockedConflict ? copy.t("importTypeConflictTitle") : copy.t("importConflictTitle"),
+      tone: hasBlockedConflict ? "default" : "destructive",
+      onConfirm: hasBlockedConflict ? onClose : onConfirm,
+      onOpenChange: (nextOpen) => {
+        if (!nextOpen) {
+          onClose();
+        }
+      },
+      children: [
+        /* @__PURE__ */ jsx(ImportConflictSummary, { copy, dialog }),
+        /* @__PURE__ */ jsx("div", { className: "max-h-60 overflow-auto rounded-lg border border-[var(--border-1)] bg-transparency-block", children: /* @__PURE__ */ jsx("div", { className: "divide-y divide-[var(--border-1)]", children: dialog.conflicts.map((conflict) => /* @__PURE__ */ jsxs(
+          "div",
+          {
+            className: "flex flex-col gap-1 px-4 py-3 text-sm",
+            children: [
+              /* @__PURE__ */ jsx("span", { className: "font-medium text-[var(--text-primary)]", children: conflict.name }),
+              /* @__PURE__ */ jsxs("span", { className: "text-xs text-[var(--text-secondary)]", children: [
+                copy.t("importConflictReviewLabel"),
+                ":",
+                " ",
+                conflict.destinationPath
+              ] })
+            ]
+          },
+          `${conflict.destinationPath}:${conflict.sourcePath}`
+        )) }) })
+      ]
+    }
+  );
+}
+function ImportConflictSummary({
+  copy,
+  dialog
+}) {
+  const summaryItems = [];
+  const hasReasonBreakdown = dialog.summary?.reasonBreakdown?.some((reason) => reason.count > 0) ?? false;
+  if (typeof dialog.summary?.selectedCount === "number" && dialog.summary.selectedCount > 0) {
+    summaryItems.push(
+      copy.t("importConflictSummarySelected", {
+        count: dialog.summary.selectedCount
+      })
+    );
+  }
+  if (!hasReasonBreakdown && typeof dialog.summary?.filteredCount === "number" && dialog.summary.filteredCount > 0) {
+    summaryItems.push(
+      copy.t("importConflictSummaryFiltered", {
+        count: dialog.summary.filteredCount
+      })
+    );
+  }
+  if (!hasReasonBreakdown && typeof dialog.summary?.ignoredCount === "number" && dialog.summary.ignoredCount > 0) {
+    summaryItems.push(
+      copy.t("importConflictSummaryIgnored", {
+        count: dialog.summary.ignoredCount
+      })
+    );
+  }
+  for (const reason of dialog.summary?.reasonBreakdown ?? []) {
+    if (reason.count <= 0) {
+      continue;
+    }
+    const copyKey = importSummaryReasonCopyKey(reason.reason);
+    if (!copyKey) {
+      continue;
+    }
+    summaryItems.push(copy.t(copyKey, { count: reason.count }));
+  }
+  if (summaryItems.length === 0) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx("div", { className: "flex flex-wrap gap-2 text-xs text-[var(--text-secondary)]", children: summaryItems.map((item) => /* @__PURE__ */ jsx(
+    "span",
+    {
+      className: "rounded-md border border-[var(--border-1)] px-2 py-1",
+      children: item
+    },
+    item
+  )) });
+}
+function importSummaryReasonCopyKey(reason) {
+  switch (reason) {
+    case "ignored":
+      return "importConflictSummaryReasonIgnored";
+    case "symlink":
+      return "importConflictSummaryReasonSymlink";
+    case "system_metadata":
+      return "importConflictSummaryReasonSystemMetadata";
+  }
+}
+
+// src/ui/WorkspaceFileManagerPanels.tsx
+import {
+  FileCodeIcon,
+  FileTextIcon,
+  FolderFilledIcon,
+  ImageFileIcon,
+  LoadingIcon,
+  ScrollArea,
+  VideoFileIcon,
+  cn as cn2
+} from "@tutti-os/ui-system";
+import { WorkspaceFilePreviewSurface as SharedWorkspaceFilePreviewSurface } from "@tutti-os/workspace-file-preview/react";
+import {
+  useCallback as useCallback2,
+  useEffect as useEffect2,
+  useLayoutEffect as useLayoutEffect2,
+  useRef as useRef2,
+  useState as useState2
+} from "react";
+import { Fragment as Fragment2, jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var workspaceFileManagerTableGridClassName = "grid-cols-[minmax(0,_1fr)_148px_96px]";
+var workspaceFileManagerTableGridStyle = {
+  gridTemplateColumns: "minmax(0, 1fr) 148px 96px"
+};
+var workspaceFileManagerCompactTableGridClassName = "grid-cols-[minmax(0,_1fr)_96px_72px]";
+var workspaceFileManagerCompactTableGridStyle = {
+  gridTemplateColumns: "minmax(0, 1fr) 96px 72px"
+};
+var workspaceFileManagerPreviewDetailGridStyle = {
+  gridTemplateColumns: "minmax(82px, 0.8fr) minmax(0, 1.2fr)"
+};
+var workspaceFileManagerStackedBreakpoint = 600;
+var workspaceFileManagerPreviewDefaultWidth = 280;
+var workspaceFileManagerPreviewMinWidth = 220;
+var workspaceFileManagerTableMinWidth = 360;
+var workspaceFileManagerMoveDragThreshold = 4;
+var workspaceFileManagerMoveDragAutoScrollDelayMs = 500;
+var workspaceFileManagerMoveDragAutoScrollEdgePx = 48;
+var workspaceFileManagerMoveDragAutoScrollStepPx = 12;
+var workspaceFileManagerEntryOpenClickIntervalMs = 500;
+function WorkspaceFileManagerPanels({
+  canMove,
+  contextMenuEntryPath,
+  dateLocale,
+  entryDragMode,
+  entrySelectionEnabled = true,
+  copy,
+  inlineRenameEntryPath,
+  inlineRenameValidation,
+  isRenaming,
+  pendingDirectoryPath,
+  previewState,
+  selectedEntry,
+  selectedPath,
+  state,
+  showDropOverlay,
+  onBlankContextMenu,
+  onCancelInlineRename,
+  onClearInlineRenameValidation,
+  onConfirmInlineRename,
+  onEntryContextMenu,
+  onEntryDragStart,
+  onMoveEntry,
+  onOpenEntry,
+  onSelect
+}) {
+  const { isStacked, rootRef } = useWorkspaceFileManagerStackedLayout(
+    workspaceFileManagerStackedBreakpoint
+  );
+  const previewResizeRef = useRef2(null);
+  const [previewPaneWidth, setPreviewPaneWidth] = useState2(
+    workspaceFileManagerPreviewDefaultWidth
+  );
+  const [moveDragPreview, setMoveDragPreview] = useState2(null);
+  const lastEntryClickRef = useRef2(
+    null
+  );
+  const moveDragAutoScrollRef = useRef2(null);
+  const moveDragRef = useRef2(null);
+  const suppressNextClickRef = useRef2(false);
+  const entriesRef = useRef2(state.entries);
+  const nativeEntryDragEnabled = onEntryDragStart !== void 0 && (entryDragMode === "external" || entryDragMode === void 0 && !canMove);
+  const internalMoveEnabled = canMove && !nativeEntryDragEnabled;
+  const stopMoveDragAutoScroll = useCallback2(() => {
+    const autoScroll = moveDragAutoScrollRef.current;
+    if (autoScroll?.frameId !== null && autoScroll?.frameId !== void 0) {
+      window.cancelAnimationFrame(autoScroll.frameId);
+    }
+    moveDragAutoScrollRef.current = null;
+  }, []);
+  const updateMoveDragAutoScroll = useCallback2(
+    (clientY) => {
+      const scrollViewport = resolveWorkspaceFileManagerTableScrollViewport(
+        rootRef.current
+      );
+      const direction = resolveWorkspaceFileManagerMoveDragAutoScrollDirection(
+        scrollViewport,
+        clientY
+      );
+      if (!scrollViewport || direction === null) {
+        stopMoveDragAutoScroll();
+        return;
+      }
+      const current = moveDragAutoScrollRef.current;
+      if (current?.scrollViewport === scrollViewport && current.direction === direction) {
+        current.lastClientY = clientY;
+        return;
+      }
+      stopMoveDragAutoScroll();
+      const nextAutoScroll = {
+        direction,
+        enteredAtMs: window.performance.now(),
+        frameId: null,
+        lastClientY: clientY,
+        scrollViewport
+      };
+      const step = (timestamp) => {
+        if (moveDragAutoScrollRef.current !== nextAutoScroll) {
+          return;
+        }
+        const nextDirection = resolveWorkspaceFileManagerMoveDragAutoScrollDirection(
+          nextAutoScroll.scrollViewport,
+          nextAutoScroll.lastClientY
+        );
+        if (nextDirection !== nextAutoScroll.direction) {
+          stopMoveDragAutoScroll();
+          return;
+        }
+        if (timestamp - nextAutoScroll.enteredAtMs >= workspaceFileManagerMoveDragAutoScrollDelayMs) {
+          nextAutoScroll.scrollViewport.scrollTop += nextAutoScroll.direction * workspaceFileManagerMoveDragAutoScrollStepPx;
+        }
+        nextAutoScroll.frameId = window.requestAnimationFrame(step);
+      };
+      moveDragAutoScrollRef.current = nextAutoScroll;
+      nextAutoScroll.frameId = window.requestAnimationFrame(step);
+    },
+    [rootRef, stopMoveDragAutoScroll]
+  );
+  const handleEntryPointerDown = useCallback2(
+    (entry, event) => {
+      if (!internalMoveEnabled || event.button !== 0) {
+        return;
+      }
+      moveDragRef.current = {
+        active: false,
+        entry,
+        startX: event.clientX,
+        startY: event.clientY
+      };
+    },
+    [internalMoveEnabled]
+  );
+  const shouldSuppressEntryClick = useCallback2(() => {
+    if (!suppressNextClickRef.current) {
+      return false;
+    }
+    suppressNextClickRef.current = false;
+    return true;
+  }, []);
+  const handleTablePanelContextMenu = useCallback2(
+    (event) => {
+      const target = event.target;
+      if (target instanceof Element && target.closest("[data-workspace-file-entry-path]")) {
+        return;
+      }
+      onBlankContextMenu(event);
+    },
+    [onBlankContextMenu]
+  );
+  const handleEntryClick = useCallback2(
+    (entry) => {
+      if (shouldSuppressEntryClick()) {
+        lastEntryClickRef.current = null;
+        return;
+      }
+      const now = Date.now();
+      const lastClick = lastEntryClickRef.current;
+      if (lastClick?.path === entry.path && now - lastClick.timeMs <= workspaceFileManagerEntryOpenClickIntervalMs) {
+        lastEntryClickRef.current = null;
+        onOpenEntry(entry);
+        return;
+      }
+      lastEntryClickRef.current = { path: entry.path, timeMs: now };
+      if (!entrySelectionEnabled) {
+        return;
+      }
+      onSelect(entry.path);
+    },
+    [entrySelectionEnabled, onOpenEntry, onSelect, shouldSuppressEntryClick]
+  );
+  useEffect2(() => {
+    lastEntryClickRef.current = null;
+    entriesRef.current = state.entries;
+  }, [state.entries]);
+  useEffect2(() => {
+    function handleDocumentPointerMove(event) {
+      const drag = moveDragRef.current;
+      if (!drag) {
+        return;
+      }
+      const deltaX = event.clientX - drag.startX;
+      const deltaY = event.clientY - drag.startY;
+      if (!drag.active && Math.hypot(deltaX, deltaY) >= workspaceFileManagerMoveDragThreshold) {
+        drag.active = true;
+      }
+      if (drag.active) {
+        const targetEntry = resolveMoveDragTargetEntry(
+          entriesRef.current,
+          drag.entry,
+          event.clientX,
+          event.clientY
+        );
+        setMoveDragPreview({
+          entry: drag.entry,
+          targetDirectoryPath: targetEntry?.path ?? null,
+          x: event.clientX,
+          y: event.clientY
+        });
+        updateMoveDragAutoScroll(event.clientY);
+        event.preventDefault();
+      }
+    }
+    function handleDocumentPointerUp(event) {
+      const drag = moveDragRef.current;
+      moveDragRef.current = null;
+      stopMoveDragAutoScroll();
+      setMoveDragPreview(null);
+      if (!drag?.active) {
+        return;
+      }
+      suppressNextClickRef.current = true;
+      event.preventDefault();
+      if (!internalMoveEnabled) {
+        return;
+      }
+      const targetEntry = resolveMoveDragTargetEntry(
+        entriesRef.current,
+        drag.entry,
+        event.clientX,
+        event.clientY
+      );
+      if (targetEntry) {
+        onMoveEntry(drag.entry, targetEntry.path);
+      }
+    }
+    document.addEventListener("pointermove", handleDocumentPointerMove, true);
+    document.addEventListener("mousemove", handleDocumentPointerMove, true);
+    document.addEventListener("pointerup", handleDocumentPointerUp, true);
+    document.addEventListener("mouseup", handleDocumentPointerUp, true);
+    return () => {
+      document.removeEventListener(
+        "pointermove",
+        handleDocumentPointerMove,
+        true
+      );
+      document.removeEventListener(
+        "mousemove",
+        handleDocumentPointerMove,
+        true
+      );
+      document.removeEventListener("pointerup", handleDocumentPointerUp, true);
+      document.removeEventListener("mouseup", handleDocumentPointerUp, true);
+      stopMoveDragAutoScroll();
+    };
+  }, [
+    internalMoveEnabled,
+    onMoveEntry,
+    stopMoveDragAutoScroll,
+    updateMoveDragAutoScroll
+  ]);
+  const previewPaneClassName = isStacked ? "min-w-0 border-t border-[var(--border-1)]" : "min-w-[220px] border-l border-[var(--border-1)]";
+  const tableGridClassName = isStacked ? workspaceFileManagerCompactTableGridClassName : workspaceFileManagerTableGridClassName;
+  const tableGridStyle = isStacked ? workspaceFileManagerCompactTableGridStyle : workspaceFileManagerTableGridStyle;
+  const tableCellPaddingClassName = "px-4";
+  const clampPreviewPaneWidth = useCallback2(
+    (width, maxWidth) => {
+      const resolvedMaxWidth = typeof maxWidth === "number" ? Math.max(workspaceFileManagerPreviewMinWidth, maxWidth) : Number.POSITIVE_INFINITY;
+      return Math.min(
+        Math.max(width, workspaceFileManagerPreviewMinWidth),
+        resolvedMaxWidth
+      );
+    },
+    []
+  );
+  useLayoutEffect2(() => {
+    const element = rootRef.current;
+    if (!element || isStacked) {
+      return;
+    }
+    const publishLayout = () => {
+      const containerWidth = Math.round(element.getBoundingClientRect().width);
+      const maxWidth = Math.max(
+        workspaceFileManagerPreviewMinWidth,
+        containerWidth - workspaceFileManagerTableMinWidth
+      );
+      setPreviewPaneWidth(
+        (currentWidth) => clampPreviewPaneWidth(currentWidth, maxWidth)
+      );
+    };
+    publishLayout();
+    if (typeof ResizeObserver === "undefined") {
+      window.addEventListener("resize", publishLayout);
+      return () => {
+        window.removeEventListener("resize", publishLayout);
+      };
+    }
+    const observer = new ResizeObserver(publishLayout);
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+    };
+  }, [clampPreviewPaneWidth, isStacked, rootRef]);
+  const handlePreviewResizePointerDown = useCallback2(
+    (event) => {
+      if (event.button !== 0) {
+        return;
+      }
+      const containerWidth = rootRef.current?.getBoundingClientRect().width ?? 0;
+      const maxWidth = Math.max(
+        workspaceFileManagerPreviewMinWidth,
+        containerWidth - workspaceFileManagerTableMinWidth
+      );
+      event.preventDefault();
+      event.stopPropagation();
+      event.currentTarget.setPointerCapture(event.pointerId);
+      previewResizeRef.current = {
+        pointerId: event.pointerId,
+        startX: event.clientX,
+        startWidth: previewPaneWidth,
+        maxWidth
+      };
+    },
+    [previewPaneWidth, rootRef]
+  );
+  const handlePreviewResizePointerMove = useCallback2(
+    (event) => {
+      const resize = previewResizeRef.current;
+      if (!resize || resize.pointerId !== event.pointerId) {
+        return;
+      }
+      const deltaX = event.clientX - resize.startX;
+      setPreviewPaneWidth(
+        clampPreviewPaneWidth(resize.startWidth - deltaX, resize.maxWidth)
+      );
+    },
+    [clampPreviewPaneWidth]
+  );
+  const handlePreviewResizePointerEnd = useCallback2(
+    (event) => {
+      const resize = previewResizeRef.current;
+      if (!resize || resize.pointerId !== event.pointerId) {
+        return;
+      }
+      previewResizeRef.current = null;
+      event.currentTarget.releasePointerCapture(event.pointerId);
+    },
+    []
+  );
+  const tablePanel = /* @__PURE__ */ jsx2(
+    "div",
+    {
+      className: cn2(
+        "flex min-h-0 min-w-0 flex-col overflow-hidden",
+        isStacked ? "h-[44%] max-h-[48%] flex-none" : "flex-1"
+      ),
+      onContextMenu: handleTablePanelContextMenu,
+      children: state.error ? /* @__PURE__ */ jsx2(FeedbackState, { message: state.error }) : state.isLoading && state.entries.length === 0 ? /* @__PURE__ */ jsx2(FeedbackState, { message: copy.t("loading") }) : state.entries.length === 0 ? /* @__PURE__ */ jsx2(FeedbackState, { message: copy.t("emptyDirectory") }) : /* @__PURE__ */ jsx2(ScrollArea, { className: "min-h-0 flex-1 [&_[data-orientation=vertical][data-slot=scroll-area-scrollbar]]:opacity-100", children: /* @__PURE__ */ jsxs2("div", { className: "flex flex-col", children: [
+        /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            className: cn2(
+              "grid h-9 min-h-9 items-center gap-x-6 border-b border-[var(--border-1)] text-xs font-normal text-[var(--text-secondary)]",
+              tableGridClassName
+            ),
+            style: tableGridStyle,
+            children: [
+              /* @__PURE__ */ jsx2("span", { className: tableCellPaddingClassName, children: copy.t("nameLabel") }),
+              /* @__PURE__ */ jsx2(
+                "span",
+                {
+                  className: cn2("whitespace-nowrap", tableCellPaddingClassName),
+                  children: copy.t("modifiedLabel")
+                }
+              ),
+              /* @__PURE__ */ jsx2(
+                "span",
+                {
+                  className: cn2("whitespace-nowrap", tableCellPaddingClassName),
+                  children: copy.t("sizeLabel")
+                }
+              )
+            ]
+          }
+        ),
+        state.entries.map((entry) => /* @__PURE__ */ jsx2(
+          EntryRow,
+          {
+            contextMenuActive: contextMenuEntryPath === entry.path,
+            copy,
+            dateLocale,
+            entry,
+            canMove: internalMoveEnabled,
+            draggable: nativeEntryDragEnabled,
+            gridClassName: tableGridClassName,
+            gridStyle: tableGridStyle,
+            inlineRenameValidation: inlineRenameEntryPath === entry.path ? inlineRenameValidation : null,
+            isEnteringDirectory: pendingDirectoryPath === entry.path,
+            isInlineRenaming: inlineRenameEntryPath === entry.path,
+            isRenaming,
+            moveDragActive: moveDragPreview !== null,
+            moveDragSource: moveDragPreview?.entry.path === entry.path,
+            moveDragTarget: moveDragPreview?.targetDirectoryPath === entry.path,
+            tableCellPaddingClassName,
+            selected: selectedPath === entry.path,
+            onCancelInlineRename,
+            onClearInlineRenameValidation,
+            onConfirmInlineRename,
+            onContextMenu: onEntryContextMenu,
+            onDragStart: onEntryDragStart,
+            onClick: handleEntryClick,
+            onPointerDown: handleEntryPointerDown
+          },
+          entry.path
+        ))
+      ] }) })
+    }
+  );
+  const previewPanel = /* @__PURE__ */ jsx2(
+    "aside",
+    {
+      className: cn2(
+        "relative flex h-full min-h-0 flex-col gap-[14px] overflow-auto p-4",
+        isStacked ? "max-h-[44%] flex-none" : "flex-none",
+        previewPaneClassName
+      ),
+      style: isStacked ? void 0 : { width: previewPaneWidth },
+      children: /* @__PURE__ */ jsx2(
+        PreviewPane,
+        {
+          copy,
+          dateLocale,
+          entry: selectedEntry,
+          previewState
+        }
+      )
+    }
+  );
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: "relative min-h-0 min-w-0 flex-1 overflow-hidden",
+      ref: rootRef,
+      children: [
+        /* @__PURE__ */ jsxs2(
+          "div",
+          {
+            className: cn2(
+              "h-full min-h-0 min-w-0 bg-transparent",
+              isStacked ? "flex flex-col gap-3" : "flex"
+            ),
+            children: [
+              tablePanel,
+              isStacked ? null : /* @__PURE__ */ jsx2(
+                "div",
+                {
+                  "aria-orientation": "vertical",
+                  className: "nodrag absolute top-0 bottom-0 z-[1] w-2 cursor-col-resize touch-none",
+                  role: "separator",
+                  style: {
+                    right: previewPaneWidth - 4
+                  },
+                  onPointerCancel: handlePreviewResizePointerEnd,
+                  onPointerDown: handlePreviewResizePointerDown,
+                  onPointerMove: handlePreviewResizePointerMove,
+                  onPointerUp: handlePreviewResizePointerEnd
+                }
+              ),
+              previewPanel
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          "div",
+          {
+            "aria-hidden": "true",
+            className: cn2(
+              "pointer-events-none absolute inset-0 grid place-items-center rounded-[var(--workbench-window-radius,8px)] border border-dashed border-[var(--border-focus)] bg-[var(--accent-bg)] opacity-0 transition-opacity duration-150 ease-out",
+              showDropOverlay && "opacity-100"
+            ),
+            children: /* @__PURE__ */ jsx2("div", { className: "rounded-lg border border-[var(--border-1)] bg-[var(--background-fronted)] px-5 py-3 text-sm font-normal text-[var(--text-primary)] shadow-panel", children: copy.t("dropToImportLabel") })
+          }
+        ),
+        moveDragPreview ? /* @__PURE__ */ jsx2(MoveDragPreview, { preview: moveDragPreview }) : null
+      ]
+    }
+  );
+}
+function useWorkspaceFileManagerStackedLayout(breakpoint) {
+  const rootRef = useRef2(null);
+  const [isStacked, setIsStacked] = useState2(false);
+  useLayoutEffect2(() => {
+    const element = rootRef.current;
+    if (!element) {
+      return;
+    }
+    const publishLayout = () => {
+      const nextIsStacked = Math.round(element.getBoundingClientRect().width) <= breakpoint;
+      setIsStacked(
+        (current) => current === nextIsStacked ? current : nextIsStacked
+      );
+    };
+    publishLayout();
+    if (typeof ResizeObserver === "undefined") {
+      window.addEventListener("resize", publishLayout);
+      return () => {
+        window.removeEventListener("resize", publishLayout);
+      };
+    }
+    const observer = new ResizeObserver(publishLayout);
+    observer.observe(element);
+    return () => {
+      observer.disconnect();
+    };
+  }, [breakpoint]);
+  return { isStacked, rootRef };
+}
+function EntryRow({
+  canMove,
+  contextMenuActive,
+  copy,
+  dateLocale,
+  draggable,
+  entry,
+  gridClassName,
+  gridStyle,
+  inlineRenameValidation,
+  isEnteringDirectory,
+  isInlineRenaming,
+  isRenaming,
+  moveDragActive,
+  moveDragSource,
+  moveDragTarget,
+  selected,
+  tableCellPaddingClassName,
+  onCancelInlineRename,
+  onClearInlineRenameValidation,
+  onConfirmInlineRename,
+  onContextMenu,
+  onDragStart,
+  onClick,
+  onPointerDown
+}) {
+  const buttonRowRef = useRef2(null);
+  const divRowRef = useRef2(null);
+  useLayoutEffect2(() => {
+    if (!selected) {
+      return;
+    }
+    (buttonRowRef.current ?? divRowRef.current)?.scrollIntoView({
+      block: "nearest",
+      inline: "nearest"
+    });
+  }, [selected]);
+  const rowClassName = cn2(
+    "grid min-h-10 w-full items-center gap-x-6 border-b border-[var(--border-1)] px-0 text-left transition-colors",
+    gridClassName,
+    isInlineRenaming ? "cursor-default" : "cursor-pointer hover:bg-transparency-block",
+    canMove && moveDragActive && "cursor-grabbing",
+    selected || contextMenuActive || isInlineRenaming ? "bg-transparency-block text-[var(--text-primary)]" : "text-[var(--text-secondary)]",
+    moveDragSource && "opacity-55",
+    moveDragTarget && "bg-[var(--accent-bg)] text-[var(--text-primary)] outline outline-1 -outline-offset-1 outline-[var(--border-focus)]",
+    moveDragActive && !moveDragSource && !moveDragTarget && "opacity-90"
+  );
+  const rowProps = {
+    "aria-label": entry.name,
+    className: rowClassName,
+    "data-workspace-file-entry-path": entry.path,
+    draggable: isInlineRenaming ? false : draggable,
+    style: gridStyle,
+    onContextMenu: (event) => {
+      onContextMenu(event, entry);
+    }
+  };
+  const nameCell = /* @__PURE__ */ jsx2("span", { className: tableCellPaddingClassName, children: /* @__PURE__ */ jsx2(
+    EntryNameCell,
+    {
+      copy,
+      entry,
+      inlineRenameValidation,
+      isEnteringDirectory,
+      isInlineRenaming,
+      isRenaming,
+      onCancelInlineRename,
+      onClearInlineRenameValidation,
+      onConfirmInlineRename
+    }
+  ) });
+  const modifiedCell = /* @__PURE__ */ jsx2(
+    "span",
+    {
+      className: cn2(
+        "truncate text-xs text-[var(--text-secondary)]",
+        tableCellPaddingClassName
+      ),
+      children: formatWorkspaceFileModifiedTime(entry.mtimeMs, dateLocale)
+    }
+  );
+  const sizeCell = /* @__PURE__ */ jsx2(
+    "span",
+    {
+      className: cn2(
+        "truncate text-xs text-[var(--text-secondary)]",
+        tableCellPaddingClassName
+      ),
+      children: entry.kind === "directory" ? "--" : formatWorkspaceFileBytes(entry.sizeBytes)
+    }
+  );
+  if (isInlineRenaming) {
+    return /* @__PURE__ */ jsxs2("div", { ...rowProps, ref: divRowRef, children: [
+      nameCell,
+      modifiedCell,
+      sizeCell
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      ...rowProps,
+      ref: buttonRowRef,
+      type: "button",
+      onDragStart: (event) => {
+        if (!draggable) {
+          event.preventDefault();
+          return;
+        }
+        onDragStart?.(entry, event.dataTransfer);
+      },
+      onPointerDown: (event) => {
+        onPointerDown(entry, event);
+      },
+      onClick: () => {
+        onClick(entry);
+      },
+      children: [
+        nameCell,
+        modifiedCell,
+        sizeCell
+      ]
+    }
+  );
+}
+function MoveDragPreview({
+  preview
+}) {
+  const visualKind = resolveWorkspaceFileVisualKind(preview.entry);
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      "aria-hidden": "true",
+      className: "pointer-events-none fixed z-[60] flex max-w-[280px] items-center gap-2 rounded-md border border-[var(--line-1)] bg-[var(--background-fronted)] px-3 py-2 text-sm font-normal text-[var(--text-primary)] shadow-panel",
+      style: {
+        left: preview.x,
+        top: preview.y,
+        transform: "translate(12px, 12px)"
+      },
+      children: [
+        /* @__PURE__ */ jsx2(
+          "span",
+          {
+            className: cn2(
+              "grid size-[18px] flex-none place-items-center",
+              entryIconColorClassName(visualKind)
+            ),
+            children: /* @__PURE__ */ jsx2(EntryIcon, { visualKind })
+          }
+        ),
+        /* @__PURE__ */ jsx2("span", { className: "min-w-0 truncate", children: preview.entry.name })
+      ]
+    }
+  );
+}
+function resolveWorkspaceFileManagerTableScrollViewport(rootElement) {
+  return rootElement?.querySelector(
+    '[data-slot="scroll-area-viewport"]'
+  ) ?? null;
+}
+function resolveWorkspaceFileManagerMoveDragAutoScrollDirection(scrollViewport, clientY) {
+  if (!scrollViewport) {
+    return null;
+  }
+  const { bottom, top } = scrollViewport.getBoundingClientRect();
+  const canScrollUp = scrollViewport.scrollTop > 0;
+  const canScrollDown = scrollViewport.scrollTop + scrollViewport.clientHeight < scrollViewport.scrollHeight;
+  if (canScrollUp && clientY <= top + workspaceFileManagerMoveDragAutoScrollEdgePx) {
+    return -1;
+  }
+  if (canScrollDown && clientY >= bottom - workspaceFileManagerMoveDragAutoScrollEdgePx) {
+    return 1;
+  }
+  return null;
+}
+function resolveMoveDragTargetEntry(entries, movedEntry, x, y) {
+  const targetElement = document.elementFromPoint(x, y);
+  const rowElement = targetElement?.closest(
+    "[data-workspace-file-entry-path]"
+  );
+  const targetPath = rowElement?.dataset.workspaceFileEntryPath;
+  const targetEntry = targetPath ? entries.find((entry) => entry.path === targetPath) : null;
+  if (!targetEntry || !canMoveEntryToDirectory(movedEntry, targetEntry)) {
+    return null;
+  }
+  return targetEntry;
+}
+function canMoveEntryToDirectory(movedEntry, targetEntry) {
+  return movedEntry.kind !== "unknown" && targetEntry.kind === "directory" && movedEntry.path !== targetEntry.path && !targetEntry.path.startsWith(`${movedEntry.path}/`);
+}
+function EntryNameCell({
+  copy,
+  entry,
+  inlineRenameValidation = null,
+  isEnteringDirectory = false,
+  isInlineRenaming = false,
+  isRenaming = false,
+  onCancelInlineRename,
+  onClearInlineRenameValidation,
+  onConfirmInlineRename
+}) {
+  const visualKind = resolveWorkspaceFileVisualKind(entry);
+  const nameParts = splitWorkspaceFileName(entry.name);
+  const hasFileExtension = nameParts.end.length > 0 && nameParts.end.startsWith(".");
+  const [name, setName] = useState2(entry.name);
+  const inputRef = useRef2(null);
+  const skipBlurRef = useRef2(false);
+  useEffect2(() => {
+    if (!isInlineRenaming) {
+      return;
+    }
+    setName(entry.name);
+    skipBlurRef.current = false;
+  }, [entry.name, entry.path, isInlineRenaming]);
+  useLayoutEffect2(() => {
+    if (!isInlineRenaming) {
+      return;
+    }
+    const input = inputRef.current;
+    if (!input) {
+      return;
+    }
+    input.focus();
+    if (hasFileExtension) {
+      input.setSelectionRange(0, nameParts.start.length);
+    } else {
+      input.select();
+    }
+  }, [hasFileExtension, isInlineRenaming, nameParts.start.length]);
+  const validationMessage = inlineRenameValidation === "required" ? copy.t("createNameRequired") : inlineRenameValidation === "invalid" ? copy.t("createNameInvalid") : null;
+  const handleConfirm = useCallback2(async () => {
+    const confirmed = await onConfirmInlineRename(name);
+    if (!confirmed) {
+      inputRef.current?.focus();
+    }
+  }, [name, onConfirmInlineRename]);
+  if (isInlineRenaming) {
+    return /* @__PURE__ */ jsxs2("span", { className: "flex min-w-0 items-center gap-2", children: [
+      /* @__PURE__ */ jsx2(
+        "span",
+        {
+          className: cn2(
+            "grid size-[18px] flex-none place-items-center",
+            entryIconColorClassName(visualKind)
+          ),
+          children: /* @__PURE__ */ jsx2(EntryIcon, { visualKind })
+        }
+      ),
+      /* @__PURE__ */ jsxs2("span", { className: "flex min-w-0 flex-1 flex-col gap-0.5", children: [
+        /* @__PURE__ */ jsx2(
+          "input",
+          {
+            "aria-invalid": inlineRenameValidation !== null,
+            "aria-label": copy.t("renameLabel"),
+            className: cn2(
+              "min-w-0 max-w-full rounded-md border border-transparent bg-[var(--transparency-block)] px-1.5 py-0.5 text-sm text-[var(--text-primary)] outline-none transition-colors duration-200 selection:bg-[var(--transparency-active)] selection:text-[var(--text-primary)] hover:bg-[var(--transparency-hover)] focus:bg-[var(--transparency-hover)] focus-visible:border-transparent focus-visible:bg-[var(--transparency-hover)] disabled:bg-[var(--transparency-block)] disabled:text-[var(--text-disabled)] disabled:opacity-100",
+              inlineRenameValidation !== null && "border-[var(--state-danger)]"
+            ),
+            disabled: isRenaming,
+            ref: inputRef,
+            value: name,
+            onBlur: () => {
+              if (skipBlurRef.current) {
+                skipBlurRef.current = false;
+                return;
+              }
+              void handleConfirm();
+            },
+            onChange: (event) => {
+              setName(event.currentTarget.value);
+              onClearInlineRenameValidation();
+            },
+            onFocus: (event) => {
+              if (hasFileExtension) {
+                event.currentTarget.setSelectionRange(
+                  0,
+                  nameParts.start.length
+                );
+              } else {
+                event.currentTarget.select();
+              }
+            },
+            onKeyDown: (event) => {
+              if (event.key === "Enter") {
+                event.preventDefault();
+                void handleConfirm();
+                return;
+              }
+              if (event.key === "Escape") {
+                event.preventDefault();
+                skipBlurRef.current = true;
+                onCancelInlineRename();
+              }
+            }
+          }
+        ),
+        validationMessage ? /* @__PURE__ */ jsx2("span", { className: "text-xs text-[var(--state-danger)]", children: validationMessage }) : null
+      ] })
+    ] });
+  }
+  return /* @__PURE__ */ jsxs2("span", { className: "flex min-w-0 items-center gap-2", children: [
+    /* @__PURE__ */ jsx2(
+      "span",
+      {
+        className: cn2(
+          "grid size-[18px] flex-none place-items-center",
+          isEnteringDirectory ? "text-[var(--text-tertiary)]" : entryIconColorClassName(visualKind)
+        ),
+        children: isEnteringDirectory ? /* @__PURE__ */ jsx2(LoadingIcon, { className: "size-4 animate-spin" }) : /* @__PURE__ */ jsx2(EntryIcon, { visualKind })
+      }
+    ),
+    /* @__PURE__ */ jsxs2("span", { className: "flex min-w-0 max-w-full overflow-hidden whitespace-nowrap text-sm", children: [
+      /* @__PURE__ */ jsx2("span", { className: "min-w-0 overflow-hidden text-ellipsis", children: nameParts.start }),
+      nameParts.end ? /* @__PURE__ */ jsx2("span", { className: "flex-none overflow-hidden text-ellipsis", children: nameParts.end }) : null
+    ] })
+  ] });
+}
+function entryIconColorClassName(visualKind) {
+  return visualKind === "directory" ? "text-[var(--rich-text-mention-file)]" : "text-[var(--text-tertiary)]";
+}
+function EntryIcon({
+  className = "size-4",
+  visualKind
+}) {
+  switch (visualKind) {
+    case "directory":
+      return /* @__PURE__ */ jsx2(FolderFilledIcon, { className });
+    case "image":
+      return /* @__PURE__ */ jsx2(ImageFileIcon, { className });
+    case "video":
+      return /* @__PURE__ */ jsx2(VideoFileIcon, { className });
+    case "markdown":
+    case "document":
+      return /* @__PURE__ */ jsx2(FileTextIcon, { className });
+    case "code":
+      return /* @__PURE__ */ jsx2(FileCodeIcon, { className });
+    case "binary":
+      return /* @__PURE__ */ jsx2(FileTextIcon, { className });
+    default:
+      return /* @__PURE__ */ jsx2(FileTextIcon, { className });
+  }
+}
+function PreviewPane({
+  copy,
+  dateLocale,
+  entry,
+  previewState
+}) {
+  if (!entry || previewState.status === "empty") {
+    return /* @__PURE__ */ jsx2("div", { className: "grid h-full min-h-[180px] place-items-center overflow-hidden p-8 text-center text-sm leading-5 text-[var(--text-tertiary)]", children: /* @__PURE__ */ jsx2("span", { className: "max-w-[24ch] [overflow-wrap:anywhere]", children: copy.t("previewEmptyLabel") }) });
+  }
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
+    /* @__PURE__ */ jsx2(PreviewSurface, { copy, previewState }),
+    /* @__PURE__ */ jsxs2("div", { className: "flex min-w-0 flex-col gap-[14px]", children: [
+      /* @__PURE__ */ jsxs2("div", { className: "flex min-w-0 flex-col gap-[3px]", children: [
+        /* @__PURE__ */ jsx2("strong", { className: "min-w-0 truncate text-[15px] font-semibold text-[var(--text-primary)]", children: entry.name }),
+        /* @__PURE__ */ jsx2("p", { className: "min-w-0 truncate text-xs text-[var(--text-secondary)]", children: entry.path })
+      ] }),
+      /* @__PURE__ */ jsxs2("dl", { className: "border-t border-[var(--border-1)]", children: [
+        /* @__PURE__ */ jsx2(
+          PreviewDetail,
+          {
+            label: copy.t("modifiedLabel"),
+            value: formatWorkspaceFileModifiedTime(entry.mtimeMs, dateLocale)
+          }
+        ),
+        /* @__PURE__ */ jsx2(
+          PreviewDetail,
+          {
+            label: copy.t("sizeLabel"),
+            value: entry.kind === "directory" ? "--" : formatWorkspaceFileBytes(entry.sizeBytes)
+          }
+        )
+      ] })
+    ] })
+  ] });
+}
+function PreviewSurface({
+  copy,
+  previewState
+}) {
+  return /* @__PURE__ */ jsx2(
+    SharedWorkspaceFilePreviewSurface,
+    {
+      directoryMessage: copy.t("previewDirectoryLabel"),
+      emptyMessage: copy.t("previewEmptyLabel"),
+      frameClassName: "flex h-60 min-h-60 max-h-60 items-center justify-center overflow-hidden rounded-lg border border-[var(--border-1)] bg-[var(--transparency-block)]",
+      imageAlt: (entry) => entry.name,
+      imageFrameClassName: "p-4",
+      loadingIndicator: /* @__PURE__ */ jsx2("span", { className: "mx-auto grid size-11 place-items-center rounded-lg bg-[var(--transparency-block)]", children: /* @__PURE__ */ jsx2(LoadingIcon, { className: "size-4 animate-spin" }) }),
+      loadingMessage: copy.t("previewLoadingLabel"),
+      messageClassName: "max-w-[24ch] [overflow-wrap:anywhere]",
+      renderIcon: (entry) => /* @__PURE__ */ jsx2(
+        EntryIcon,
+        {
+          className: "mx-auto size-7",
+          visualKind: resolveWorkspaceFilePreviewIconKind(entry)
+        }
+      ),
+      state: previewState,
+      textFrameClassName: "items-stretch justify-stretch"
+    }
+  );
+}
+function resolveWorkspaceFilePreviewIconKind(entry) {
+  if ("kind" in entry) {
+    return resolveWorkspaceFileVisualKind(entry);
+  }
+  return entry.fileKind === "image" ? "image" : "document";
+}
+function PreviewDetail({
+  label,
+  value
+}) {
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: "@max-[600px]/workspace-file-manager:grid-cols-1 @max-[600px]/workspace-file-manager:gap-0.5 grid gap-2.5 border-b border-[var(--border-1)] py-2.5 text-xs",
+      style: workspaceFileManagerPreviewDetailGridStyle,
+      children: [
+        /* @__PURE__ */ jsx2("dt", { className: "truncate text-[var(--text-secondary)]", children: label }),
+        /* @__PURE__ */ jsx2("dd", { className: "@max-[600px]/workspace-file-manager:text-left truncate text-right text-[var(--text-primary)]", children: value })
+      ]
+    }
+  );
+}
+function FeedbackState({ message }) {
+  return /* @__PURE__ */ jsx2("div", { className: "grid min-h-0 flex-1 place-items-center p-6 text-center text-sm text-[var(--text-tertiary)]", children: /* @__PURE__ */ jsx2("span", { className: "max-w-[34ch] [overflow-wrap:anywhere]", children: message }) });
+}
+function hasFileDragPayload(dataTransfer) {
+  return Array.from(dataTransfer.types).includes("Files");
+}
+
+// src/ui/WorkspaceFileManagerToolbar.tsx
+import {
+  ArrowLeftIcon,
+  ArrowRightIcon as ArrowRightIcon2,
+  Button as Button2,
+  LoadingIcon as LoadingIcon2,
+  RefreshIcon,
+  cn as cn3
+} from "@tutti-os/ui-system";
+import { useState as useState3 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function WorkspaceFileManagerToolbar({
+  breadcrumbs,
+  canGoBack,
+  canGoForward,
+  copy,
+  currentDirectoryPath,
+  isBusy,
+  isLoading,
+  isMutating,
+  onGoBack,
+  onGoForward,
+  onLoadDirectory,
+  onRefresh
+}) {
+  const [refreshAnimationKey, setRefreshAnimationKey] = useState3(0);
+  const handleRefresh = () => {
+    setRefreshAnimationKey((currentKey) => currentKey + 1);
+    onRefresh();
+  };
+  return /* @__PURE__ */ jsxs3("header", { className: "@max-[600px]/workspace-file-manager:flex-nowrap flex h-10 min-h-10 w-full min-w-0 items-center gap-2 border-b border-[var(--border-1)] px-2 py-1", children: [
+    /* @__PURE__ */ jsx3(
+      ToolbarIconButton,
+      {
+        ariaLabel: copy.t("backLabel"),
+        disabled: !canGoBack || isLoading || isBusy,
+        title: copy.t("backLabel"),
+        onClick: onGoBack,
+        children: /* @__PURE__ */ jsx3(ArrowLeftIcon, { className: "size-4" })
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      ToolbarIconButton,
+      {
+        ariaLabel: copy.t("forwardLabel"),
+        disabled: !canGoForward || isLoading || isBusy,
+        title: copy.t("forwardLabel"),
+        onClick: onGoForward,
+        children: /* @__PURE__ */ jsx3(ArrowRightIcon2, { className: "size-4" })
+      }
+    ),
+    /* @__PURE__ */ jsx3(
+      "nav",
+      {
+        "aria-label": currentDirectoryPath,
+        className: "@max-[600px]/workspace-file-manager:flex-auto flex min-w-0 flex-1 overflow-hidden pr-2",
+        "data-workspace-file-manager-path": "",
+        children: /* @__PURE__ */ jsx3("ol", { className: "flex min-w-0 max-w-full flex-1 items-center gap-2 overflow-hidden", children: breadcrumbs.map((crumb, index) => /* @__PURE__ */ jsx3(
+          BreadcrumbButton,
+          {
+            active: index === breadcrumbs.length - 1,
+            label: crumb.label,
+            showSeparator: index > 0,
+            onClick: () => {
+              onLoadDirectory(crumb.path);
+            }
+          },
+          crumb.path
+        )) })
+      }
+    ),
+    /* @__PURE__ */ jsx3("div", { className: "@max-[600px]/workspace-file-manager:justify-end flex flex-none items-center gap-1.5", children: /* @__PURE__ */ jsxs3(
+      ToolbarActionButton,
+      {
+        disabled: isLoading || isMutating || isBusy,
+        onClick: handleRefresh,
+        children: [
+          isLoading ? /* @__PURE__ */ jsx3(LoadingIcon2, { className: "size-4 animate-spin" }) : /* @__PURE__ */ jsx3(
+            RefreshIcon,
+            {
+              className: cn3(
+                "size-4",
+                refreshAnimationKey > 0 && "motion-safe:animate-[spin_520ms_cubic-bezier(0.4,0,0.2,1)_1_reverse]"
+              )
+            },
+            refreshAnimationKey
+          ),
+          /* @__PURE__ */ jsx3("span", { className: "@max-[600px]/workspace-file-manager:hidden", children: copy.t("refreshLabel") })
+        ]
+      }
+    ) })
+  ] });
+}
+function ToolbarIconButton({
+  ariaLabel,
+  children,
+  disabled,
+  onClick,
+  title
+}) {
+  return /* @__PURE__ */ jsx3(
+    Button2,
+    {
+      "aria-label": ariaLabel,
+      className: "size-7 min-w-7 rounded-sm p-0 text-[var(--text-primary)]",
+      disabled,
+      size: "icon-sm",
+      title,
+      type: "button",
+      variant: "ghost",
+      onClick,
+      children
+    }
+  );
+}
+function ToolbarActionButton({
+  children,
+  disabled,
+  onClick
+}) {
+  return /* @__PURE__ */ jsx3(
+    Button2,
+    {
+      className: "@max-[600px]/workspace-file-manager:size-7 @max-[600px]/workspace-file-manager:min-w-7 @max-[600px]/workspace-file-manager:px-0 cursor-pointer",
+      disabled,
+      size: "sm",
+      type: "button",
+      variant: "ghost",
+      onClick,
+      children
+    }
+  );
+}
+function BreadcrumbButton({
+  active,
+  label,
+  onClick,
+  showSeparator
+}) {
+  return /* @__PURE__ */ jsxs3("li", { className: "flex min-w-0 items-center gap-2", children: [
+    showSeparator ? /* @__PURE__ */ jsx3("span", { className: "flex-none text-[var(--text-tertiary)]", children: "/" }) : null,
+    /* @__PURE__ */ jsx3(
+      "button",
+      {
+        className: cn3(
+          "min-w-0 overflow-hidden text-ellipsis whitespace-nowrap border-0 bg-transparent text-sm font-normal transition-colors",
+          active ? "font-semibold text-[var(--text-primary)]" : "text-[var(--text-secondary)] hover:text-[var(--text-primary)]"
+        ),
+        type: "button",
+        onClick,
+        children: label
+      }
+    )
+  ] });
+}
+
+// src/ui/workspaceFileManagerAnalytics.ts
+function shouldTrackDirectoryExpanded(input) {
+  return normalizeDirectoryPath(input.currentDirectoryPath) !== normalizeDirectoryPath(input.nextDirectoryPath);
+}
+function normalizeDirectoryPath(path) {
+  return path.trim().replaceAll("\\", "/").replace(/\/+$/u, "");
+}
+
+// src/ui/useWorkspaceFileManagerService.ts
+import { useSnapshot } from "valtio";
+
+// src/services/internal/workspaceFileManagerViewModel.ts
+function resolveWorkspaceFileManagerRootViewState(input) {
+  const { state } = input;
+  return {
+    canImportFromDrop: state.capabilities.canImportFromDrop,
+    currentDirectoryPath: state.currentDirectoryPath,
+    isBusy: state.busyAction !== null
+  };
+}
+function resolveWorkspaceFileManagerToolbarViewState(input) {
+  const { copy, state } = input;
+  const currentDirectoryPath = normalizeWorkspaceFilePath(
+    state.currentDirectoryPath,
+    state.root
+  );
+  return {
+    breadcrumbs: buildWorkspaceFileBreadcrumbs(
+      currentDirectoryPath,
+      copy.t("breadcrumbRootLabel"),
+      state.root
+    ),
+    canGoBack: currentDirectoryPath !== normalizeWorkspaceFilePath(state.root) && state.navigationBackStack.length > 0,
+    canGoForward: state.navigationForwardStack.length > 0,
+    currentDirectoryPath,
+    isBusy: state.busyAction !== null,
+    isLoading: state.isLoading,
+    isMutating: state.isMutating,
+    isImporting: state.busyAction === "import",
+    showImportAction: state.capabilities.canImportFromPicker
+  };
+}
+function resolveWorkspaceFileManagerPanelsViewState(input) {
+  const { state } = input;
+  return {
+    canMove: state.capabilities.canMove,
+    contextMenuEntryPath: state.contextMenuEntryPath,
+    entries: state.entries,
+    error: state.error,
+    inlineRenameEntryPath: state.inlineRenameEntryPath,
+    inlineRenameValidation: state.inlineRenameValidation,
+    isLoading: state.isLoading,
+    isRenaming: state.busyAction === "rename",
+    pendingDirectoryPath: state.pendingDirectoryPath,
+    previewState: state.previewState,
+    selectedEntry: findSelectedEntry(state),
+    selectedPath: state.selectedPath,
+    showDropOverlay: state.capabilities.canImportFromDrop && state.dragDepth > 0 && state.busyAction === null
+  };
+}
+function resolveWorkspaceFileManagerDialogsViewState(input) {
+  const { state } = input;
+  const unsupportedDialogEntry = state.unsupportedDialog?.entryPath ? findEntry(state, state.unsupportedDialog.entryPath) : null;
+  return {
+    createDialog: state.createDialog,
+    deleteDialogEntry: state.deleteDialog ? findEntry(state, state.deleteDialog.entryPath) : null,
+    isBusy: state.busyAction !== null,
+    isDeleting: state.busyAction === "delete",
+    isImporting: state.busyAction === "import",
+    isRenaming: state.busyAction === "rename",
+    isViewing: state.busyAction === "view",
+    unsupportedDialog: state.unsupportedDialog ? {
+      actions: state.unsupportedDialog.actions,
+      entry: unsupportedDialogEntry ?? void 0,
+      kind: state.unsupportedDialog.kind,
+      message: state.unsupportedDialog.message,
+      title: state.unsupportedDialog.title
+    } : null,
+    importConflictDialog: state.importConflictDialog
+  };
+}
+function resolveWorkspaceFileManagerContextMenuViewState(input) {
+  const { state } = input;
+  const contextMenuEntry = state.contextMenu?.entryPath ? findEntry(state, state.contextMenu.entryPath) : null;
+  const isContextMenuFile = contextMenuEntry?.kind === "file";
+  return {
+    contextMenu: state.contextMenu ? {
+      entry: contextMenuEntry,
+      x: state.contextMenu.x,
+      y: state.contextMenu.y
+    } : null,
+    currentDirectoryPath: state.currentDirectoryPath,
+    isBusy: state.busyAction !== null,
+    isLoading: state.isLoading,
+    isMutating: state.isMutating,
+    showCopyAction: state.capabilities.canCopy,
+    showExportAction: state.capabilities.canExport,
+    showImportAction: state.capabilities.canImportFromPicker,
+    showMoveAction: state.capabilities.canMove,
+    showOpenInAppBrowserAction: state.capabilities.canOpenInAppBrowser,
+    showOpenInDefaultBrowserAction: state.capabilities.canOpenInDefaultBrowser,
+    showOpenWithAction: state.capabilities.canOpenWith && isContextMenuFile,
+    showOpenWithOtherAction: state.capabilities.canPickOtherOpenWithApplication && isContextMenuFile,
+    showRevealInFolderAction: state.capabilities.canRevealInFolder,
+    showRenameAction: state.capabilities.canRename
+  };
+}
+function findSelectedEntry(state) {
+  return state.entries.find((entry) => entry.path === state.selectedPath) ?? null;
+}
+function findEntry(state, entryPath) {
+  return state.entries.find((entry) => entry.path === entryPath) ?? null;
+}
+
+// src/ui/useWorkspaceFileManagerService.ts
+function useWorkspaceFileManagerRootView(session) {
+  const state = useSnapshot(
+    session.store
+  );
+  return resolveWorkspaceFileManagerRootViewState({ state });
+}
+function useWorkspaceFileManagerToolbarView(session, i18n) {
+  const state = useSnapshot(
+    session.store
+  );
+  return {
+    view: resolveWorkspaceFileManagerToolbarViewState({
+      copy: i18n,
+      state
+    })
+  };
+}
+function useWorkspaceFileManagerPanelsView(session) {
+  const state = useSnapshot(
+    session.store
+  );
+  return {
+    state,
+    view: resolveWorkspaceFileManagerPanelsViewState({
+      state
+    })
+  };
+}
+function useWorkspaceFileManagerDialogsView(session) {
+  const state = useSnapshot(
+    session.store
+  );
+  return {
+    state,
+    view: resolveWorkspaceFileManagerDialogsViewState({
+      state
+    })
+  };
+}
+function useWorkspaceFileManagerContextMenuView(session) {
+  const state = useSnapshot(
+    session.store
+  );
+  return {
+    state,
+    view: resolveWorkspaceFileManagerContextMenuViewState({
+      state
+    })
+  };
+}
+
+// src/ui/WorkspaceFileManager.tsx
+import { Fragment as Fragment3, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function WorkspaceFileManager({
+  className,
+  dateLocale,
+  entryDragMode,
+  i18n,
+  onCopyEntry,
+  onCopyPath,
+  onDirectoryExpanded,
+  onEntryDragStart,
+  openInAppBrowserIcon,
+  resolveOpenWithApplicationIcon,
+  hostOs = "linux",
+  session,
+  surface = "card"
+}) {
+  const rootRef = useRef3(null);
+  const rootView = useWorkspaceFileManagerRootView(session);
+  const { state: panelsState, view: panelsView } = useWorkspaceFileManagerPanelsView(session);
+  useEffect3(() => {
+    function handleCopyShortcut(event) {
+      if (!(event.metaKey || event.ctrlKey) || event.key !== "c" || event.shiftKey) {
+        return;
+      }
+      if (isEditableKeyboardTarget(event.target)) {
+        return;
+      }
+      if (!rootRef.current?.contains(event.target)) {
+        return;
+      }
+      if (!panelsState.capabilities.canCopy || panelsState.busyAction !== null || panelsState.isLoading || panelsState.isMutating) {
+        return;
+      }
+      const entry = panelsView.selectedEntry;
+      if (!entry) {
+        return;
+      }
+      event.preventDefault();
+      void (async () => {
+        await session.copyToClipboard(entry);
+        await onCopyEntry?.();
+      })();
+    }
+    window.addEventListener("keydown", handleCopyShortcut);
+    return () => {
+      window.removeEventListener("keydown", handleCopyShortcut);
+    };
+  }, [onCopyEntry, panelsState, panelsView.selectedEntry, session]);
+  useEffect3(() => {
+    function handleRenameShortcut(event) {
+      if (event.key !== "Enter" || event.metaKey || event.ctrlKey || event.altKey) {
+        return;
+      }
+      if (isEditableKeyboardTarget(event.target)) {
+        return;
+      }
+      if (!rootRef.current?.contains(event.target)) {
+        return;
+      }
+      if (!panelsState.capabilities.canRename || panelsState.busyAction !== null || panelsState.isLoading || panelsState.isMutating || panelsState.inlineRenameEntryPath !== null) {
+        return;
+      }
+      const entry = panelsView.selectedEntry;
+      if (!entry) {
+        return;
+      }
+      event.preventDefault();
+      session.startInlineRename(entry);
+    }
+    window.addEventListener("keydown", handleRenameShortcut);
+    return () => {
+      window.removeEventListener("keydown", handleRenameShortcut);
+    };
+  }, [panelsState, panelsView.selectedEntry, session]);
+  useEffect3(() => {
+    function resetDropOverlay() {
+      session.resetDragDepth();
+    }
+    function handleDocumentDragOver(event) {
+      if (isPointInsideElement(rootRef.current, event.clientX, event.clientY)) {
+        return;
+      }
+      session.resetDragDepth();
+    }
+    window.addEventListener("blur", resetDropOverlay);
+    window.addEventListener("dragend", resetDropOverlay);
+    window.addEventListener("drop", resetDropOverlay);
+    document.addEventListener("dragover", handleDocumentDragOver, true);
+    return () => {
+      window.removeEventListener("blur", resetDropOverlay);
+      window.removeEventListener("dragend", resetDropOverlay);
+      window.removeEventListener("drop", resetDropOverlay);
+      document.removeEventListener("dragover", handleDocumentDragOver, true);
+    };
+  }, [session]);
+  function openContextMenu(event, entry) {
+    event.preventDefault();
+    event.stopPropagation();
+    const rootBounds = rootRef.current?.getBoundingClientRect();
+    if (!rootBounds) {
+      return;
+    }
+    const menuWidth = 220;
+    const menuHeight = 280;
+    const x = clampContextMenuCoordinate(
+      event.clientX - rootBounds.left,
+      rootBounds.width,
+      menuWidth
+    );
+    const y = clampContextMenuCoordinate(
+      event.clientY - rootBounds.top,
+      rootBounds.height,
+      menuHeight
+    );
+    session.openContextMenu({
+      entryPath: entry?.path ?? null,
+      x,
+      y
+    });
+  }
+  function handleDragEnter(event) {
+    if (!rootView.canImportFromDrop || rootView.isBusy || !hasFileDragPayload(event.dataTransfer)) {
+      return;
+    }
+    event.preventDefault();
+    session.incrementDragDepth();
+  }
+  function handleDragOver(event) {
+    if (!rootView.canImportFromDrop || rootView.isBusy || !hasFileDragPayload(event.dataTransfer)) {
+      return;
+    }
+    event.preventDefault();
+    event.dataTransfer.dropEffect = "copy";
+  }
+  function handleDragLeave(event) {
+    if (!rootView.canImportFromDrop || !hasFileDragPayload(event.dataTransfer)) {
+      return;
+    }
+    event.preventDefault();
+    const nextTarget = event.relatedTarget;
+    if (nextTarget instanceof Node && rootRef.current?.contains(nextTarget)) {
+      return;
+    }
+    session.resetDragDepth();
+  }
+  function handleDrop(event) {
+    if (!rootView.canImportFromDrop || rootView.isBusy || !hasFileDragPayload(event.dataTransfer)) {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    session.resetDragDepth();
+    void session.importDroppedFiles(
+      event.dataTransfer,
+      rootView.currentDirectoryPath
+    );
+  }
+  return /* @__PURE__ */ jsxs4(
+    "section",
+    {
+      className: cn4(
+        "@container/workspace-file-manager relative flex h-full min-h-0 w-full overflow-hidden text-[14px] text-[var(--text-primary)]",
+        surface === "card" ? "rounded-lg border border-[var(--border-1)] bg-[var(--background-panel)]" : "rounded-none border-0 bg-transparent",
+        className
+      ),
+      "data-slot": "viewport-menu-boundary",
+      "data-workspace-file-manager": "",
+      onDragEnter: handleDragEnter,
+      onDragLeave: handleDragLeave,
+      onDragOver: handleDragOver,
+      onDrop: handleDrop,
+      ref: rootRef,
+      children: [
+        /* @__PURE__ */ jsxs4("div", { className: "flex min-h-0 min-w-0 flex-1 flex-col overflow-hidden", children: [
+          /* @__PURE__ */ jsx4(
+            WorkspaceFileManagerToolbarContainer,
+            {
+              i18n,
+              onDirectoryExpanded,
+              session
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            "div",
+            {
+              className: "@max-[600px]/workspace-file-manager:flex-col @max-[600px]/workspace-file-manager:gap-3 flex min-h-0 min-w-0 flex-1 overflow-hidden",
+              style: {
+                "--workspace-file-manager-dialog-overlay-z-index": "20"
+              },
+              children: /* @__PURE__ */ jsx4(
+                WorkspaceFileManagerPanelsContainer,
+                {
+                  dateLocale,
+                  entryDragMode,
+                  i18n,
+                  onDirectoryExpanded,
+                  onEntryDragStart,
+                  onOpenContextMenu: openContextMenu,
+                  session
+                }
+              )
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx4(WorkspaceFileManagerDialogsContainer, { i18n, session }),
+        /* @__PURE__ */ jsx4(
+          WorkspaceFileManagerContextMenuContainer,
+          {
+            hostOs,
+            i18n,
+            onCopyEntry,
+            onCopyPath,
+            openInAppBrowserIcon,
+            resolveOpenWithApplicationIcon,
+            session
+          }
+        )
+      ]
+    }
+  );
+}
+function WorkspaceFileManagerToolbarContainer({
+  i18n,
+  onDirectoryExpanded,
+  session
+}) {
+  const { view } = useWorkspaceFileManagerToolbarView(session, i18n);
+  return /* @__PURE__ */ jsx4(
+    WorkspaceFileManagerToolbar,
+    {
+      breadcrumbs: view.breadcrumbs,
+      canGoBack: view.canGoBack,
+      canGoForward: view.canGoForward,
+      copy: i18n,
+      currentDirectoryPath: view.currentDirectoryPath,
+      isBusy: view.isBusy,
+      isLoading: view.isLoading,
+      isMutating: view.isMutating,
+      onGoBack: () => {
+        void session.goBack();
+      },
+      onGoForward: () => {
+        void session.goForward();
+      },
+      onLoadDirectory: (path) => {
+        if (shouldTrackDirectoryExpanded({
+          currentDirectoryPath: view.currentDirectoryPath,
+          nextDirectoryPath: path
+        })) {
+          onDirectoryExpanded?.(path);
+        }
+        void session.loadDirectory(path);
+      },
+      onRefresh: () => {
+        void session.refresh();
+      }
+    }
+  );
+}
+function WorkspaceFileManagerPanelsContainer({
+  dateLocale,
+  entryDragMode,
+  i18n,
+  onDirectoryExpanded,
+  onEntryDragStart,
+  onOpenContextMenu,
+  session
+}) {
+  const { state, view } = useWorkspaceFileManagerPanelsView(session);
+  return /* @__PURE__ */ jsx4(
+    WorkspaceFileManagerPanels,
+    {
+      canMove: view.canMove,
+      contextMenuEntryPath: view.contextMenuEntryPath,
+      copy: i18n,
+      dateLocale,
+      entryDragMode,
+      inlineRenameEntryPath: view.inlineRenameEntryPath,
+      inlineRenameValidation: view.inlineRenameValidation,
+      isRenaming: view.isRenaming,
+      pendingDirectoryPath: view.pendingDirectoryPath,
+      previewState: view.previewState,
+      selectedEntry: view.selectedEntry,
+      selectedPath: view.selectedPath,
+      showDropOverlay: view.showDropOverlay,
+      state: {
+        entries: state.entries,
+        error: state.error,
+        isLoading: state.isLoading
+      },
+      onBlankContextMenu: (event) => {
+        onOpenContextMenu(event, null);
+      },
+      onCancelInlineRename: () => {
+        session.cancelInlineRename();
+      },
+      onClearInlineRenameValidation: () => {
+        session.clearInlineRenameValidation();
+      },
+      onConfirmInlineRename: (newName) => {
+        return session.confirmInlineRename(newName);
+      },
+      onEntryContextMenu: onOpenContextMenu,
+      onEntryDragStart,
+      onMoveEntry: (entry, targetDirectoryPath) => {
+        void session.moveEntry(entry, targetDirectoryPath);
+      },
+      onOpenEntry: (entry) => {
+        if (entry.kind === "directory") {
+          onDirectoryExpanded?.(entry.path);
+        }
+        void session.openEntry(entry);
+      },
+      onSelect: (path) => {
+        session.select(path);
+      }
+    }
+  );
+}
+function WorkspaceFileManagerDialogsContainer({
+  i18n,
+  session
+}) {
+  const { state, view } = useWorkspaceFileManagerDialogsView(session);
+  return /* @__PURE__ */ jsxs4(Fragment3, { children: [
+    /* @__PURE__ */ jsx4(
+      WorkspaceFileManagerCreateDialog,
+      {
+        busy: view.isBusy && state.busyAction === "create",
+        copy: i18n,
+        dialog: view.createDialog,
+        onClose: () => {
+          session.closeCreateDialog();
+        },
+        onConfirm: () => {
+          void session.confirmCreateDialog();
+        },
+        onNameChange: (name) => {
+          session.updateCreateDialogName(name);
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      WorkspaceFileManagerDeleteDialog,
+      {
+        busy: view.isDeleting,
+        copy: i18n,
+        entry: view.deleteDialogEntry,
+        onClose: () => {
+          session.closeDeleteDialog();
+        },
+        onConfirm: () => {
+          void session.confirmDeleteDialog();
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      WorkspaceFileManagerImportConflictDialog,
+      {
+        busy: view.isImporting,
+        copy: i18n,
+        dialog: view.importConflictDialog,
+        onClose: () => {
+          session.closeImportConflictDialog();
+        },
+        onConfirm: () => {
+          void session.confirmImportConflict();
+        }
+      }
+    ),
+    /* @__PURE__ */ jsx4(
+      WorkspaceFileManagerUnsupportedDialog,
+      {
+        copy: i18n,
+        dialog: view.unsupportedDialog,
+        isViewing: view.isViewing,
+        onAction: (action) => {
+          void session.handleActivationFallbackAction(action);
+        },
+        onClose: () => {
+          session.closeUnsupportedDialog();
+        }
+      }
+    )
+  ] });
+}
+function WorkspaceFileManagerContextMenuContainer({
+  hostOs,
+  i18n,
+  onCopyEntry,
+  onCopyPath,
+  openInAppBrowserIcon,
+  resolveOpenWithApplicationIcon,
+  session
+}) {
+  const contextMenuRef = useRef3(null);
+  const { view } = useWorkspaceFileManagerContextMenuView(session);
+  const [openWithApplications, setOpenWithApplications] = useState4([]);
+  const [openWithLoading, setOpenWithLoading] = useState4(false);
+  useEffect3(() => {
+    const entry = view.contextMenu?.entry;
+    if (!entry || !view.showOpenWithAction) {
+      return;
+    }
+    const cachedApplications = session.getCachedOpenWithApplications(entry);
+    if (cachedApplications) {
+      setOpenWithApplications(cachedApplications);
+      setOpenWithLoading(false);
+      return;
+    }
+    let cancelled = false;
+    setOpenWithLoading(true);
+    void session.listOpenWithApplications(entry).then((applications) => {
+      if (cancelled) {
+        return;
+      }
+      setOpenWithApplications(applications);
+      setOpenWithLoading(false);
+    }).catch(() => {
+      if (cancelled) {
+        return;
+      }
+      setOpenWithApplications([]);
+      setOpenWithLoading(false);
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [session, view.contextMenu?.entry?.path, view.showOpenWithAction]);
+  useCloseContextMenuOnOutsideInteraction({
+    contextMenuRef,
+    isOpen: view.contextMenu !== null,
+    session
+  });
+  return /* @__PURE__ */ jsx4(
+    WorkspaceFileManagerContextMenu,
+    {
+      busy: view.isBusy || view.isLoading || view.isMutating,
+      copy: i18n,
+      contextMenu: view.contextMenu,
+      contextMenuRef,
+      showCopyAction: view.showCopyAction,
+      showImportAction: view.showImportAction,
+      showExportAction: view.showExportAction,
+      showOpenInAppBrowserAction: view.showOpenInAppBrowserAction && !!view.contextMenu?.entry && isWorkspaceFileBrowserOpenable(view.contextMenu.entry),
+      showOpenInDefaultBrowserAction: view.showOpenInDefaultBrowserAction && !!view.contextMenu?.entry && isWorkspaceFileBrowserOpenable(view.contextMenu.entry),
+      showOpenWithAction: view.showOpenWithAction,
+      showOpenWithOtherAction: view.showOpenWithOtherAction,
+      showRevealInFolderAction: view.showRevealInFolderAction,
+      showRenameAction: view.showRenameAction,
+      revealInFolderLabel: resolveRevealInFolderLabel(i18n, hostOs),
+      openInAppBrowserIcon,
+      openWithApplications,
+      openWithLoading,
+      resolveOpenWithApplicationIcon,
+      onClose: () => {
+        session.closeContextMenu();
+      },
+      onCreateDirectory: () => {
+        session.openCreateDirectoryDialog();
+      },
+      onCreateFile: () => {
+        session.openCreateFileDialog();
+      },
+      onCopy: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        session.closeContextMenu();
+        await session.copyToClipboard(entry);
+        if (onCopyEntry) {
+          await onCopyEntry();
+        }
+      },
+      onCopyPath: async () => {
+        const path = view.contextMenu?.entry?.path;
+        if (!path) {
+          return;
+        }
+        session.closeContextMenu();
+        if (onCopyPath) {
+          await onCopyPath(path);
+          return;
+        }
+        await navigator.clipboard.writeText(path);
+      },
+      onDelete: () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        session.openDeleteDialog(entry);
+      },
+      onRename: () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        session.startInlineRename(entry);
+      },
+      onExport: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.exportEntry(entry);
+      },
+      onOpen: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.openEntry(entry);
+      },
+      onOpenInAppBrowser: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.openFileInAppBrowser(entry);
+      },
+      onOpenInDefaultBrowser: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.openFileInDefaultBrowser(entry);
+      },
+      onOpenWithApplication: async (applicationPath) => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.openFileWithApplication(entry, applicationPath);
+      },
+      onOpenWithOtherApplication: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.openFileWithOtherApplication(entry);
+      },
+      onRevealInFolder: async () => {
+        const entry = view.contextMenu?.entry;
+        if (!entry) {
+          return;
+        }
+        await session.revealEntry(entry);
+      },
+      onImport: async () => {
+        session.closeContextMenu();
+        await session.importFiles(
+          view.contextMenu?.entry?.kind === "directory" ? view.contextMenu.entry.path : view.currentDirectoryPath
+        );
+      }
+    }
+  );
+}
+function useCloseContextMenuOnOutsideInteraction(input) {
+  const { contextMenuRef, isOpen, session } = input;
+  useEffect3(() => {
+    if (!isOpen) {
+      return;
+    }
+    function handlePointerDown(event) {
+      const target = event.target;
+      if (target instanceof Node && contextMenuRef.current?.contains(target)) {
+        return;
+      }
+      if (target instanceof Element && target.closest("[data-workspace-file-manager-submenu]")) {
+        return;
+      }
+      session.closeContextMenu();
+    }
+    function handleKeyDown(event) {
+      if (event.key === "Escape") {
+        session.closeContextMenu();
+      }
+    }
+    window.addEventListener("pointerdown", handlePointerDown);
+    window.addEventListener("keydown", handleKeyDown);
+    return () => {
+      window.removeEventListener("pointerdown", handlePointerDown);
+      window.removeEventListener("keydown", handleKeyDown);
+    };
+  }, [contextMenuRef, isOpen, session]);
+}
+function isEditableKeyboardTarget(target) {
+  if (!(target instanceof HTMLElement)) {
+    return false;
+  }
+  if (target.isContentEditable) {
+    return true;
+  }
+  const tagName = target.tagName;
+  return tagName === "INPUT" || tagName === "TEXTAREA" || tagName === "SELECT";
+}
+function clampContextMenuCoordinate(coordinate, boundarySize, menuSize) {
+  const max = Math.max(8, boundarySize - menuSize - 8);
+  return Math.min(Math.max(coordinate, 8), max);
+}
+function isPointInsideElement(element, clientX, clientY) {
+  if (!element) {
+    return false;
+  }
+  const bounds = element.getBoundingClientRect();
+  return clientX >= bounds.left && clientX <= bounds.right && clientY >= bounds.top && clientY <= bounds.bottom;
+}
+export {
+  WorkspaceFileManager,
+  classifyWorkspaceFilePreviewKind,
+  createWorkspaceFileManagerI18nRuntime,
+  createWorkspaceFileManagerService,
+  decodeWorkspaceTextFile,
+  isWorkspaceTextFileTooLarge,
+  looksLikeBinaryText,
+  resolveWorkspaceFileActivationTarget,
+  resolveWorkspaceFileExtension,
+  resolveWorkspaceImageMimeType,
+  workspaceFileManagerI18nNamespace,
+  workspaceFileManagerI18nResources,
+  workspaceFilePreviewMaxBytes,
+  workspaceFileTextMaxBytes
+};
+//# sourceMappingURL=index.js.map