@djangocfg/ui-tools 2.1.413 → 2.1.416

package/dist/tree/index.cjs

@@ -6,8 +6,10 @@ var chunkPK6SKIKE_cjs = require('../chunk-PK6SKIKE.cjs');
 var React = require('react');
 var lib = require('@djangocfg/ui-core/lib');
 var components = require('@djangocfg/ui-core/components');
-var jsxRuntime = require('react/jsx-runtime');
+var dialogService = require('@djangocfg/ui-core/lib/dialog-service');
 var lucideReact = require('lucide-react');
+var jsxRuntime = require('react/jsx-runtime');
+var core = require('@dnd-kit/core');
 var hooks = require('@djangocfg/ui-core/hooks');
 
 function _interopNamespace(e) {
@@ -30,16 +32,6 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-// src/tools/data/Tree/types.ts
-var DEFAULT_TREE_LABELS = {
-  loading: "Loading\u2026",
-  empty: "Nothing to show",
-  error: "Failed to load",
-  searchPlaceholder: "Search\u2026",
-  searchMatches: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((n) => `${n} match${n === 1 ? "" : "es"}`, "searchMatches"),
-  ariaLabel: "Tree"
-};
-
 // src/tools/data/Tree/data/childCache.ts
 var createChildCache = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => /* @__PURE__ */ new Map(), "createChildCache");
 var resolveChildren = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((cache, node) => {
@@ -228,7 +220,44 @@ function rowStateClasses(a) {
   ].join(" ");
 }
 chunkPK6SKIKE_cjs.__name(rowStateClasses, "rowStateClasses");
-var reducer = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((state, action) => {
+
+// src/tools/data/Tree/types/labels.ts
+var DEFAULT_TREE_LABELS = {
+  loading: "Loading\u2026",
+  empty: "Nothing to show",
+  error: "Failed to load",
+  searchPlaceholder: "Search\u2026",
+  searchMatches: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((n) => `${n} match${n === 1 ? "" : "es"}`, "searchMatches"),
+  ariaLabel: "Tree",
+  actionOpen: "Open",
+  actionRename: "Rename",
+  actionDuplicate: "Duplicate",
+  actionCut: "Cut",
+  actionCopy: "Copy",
+  actionPaste: "Paste",
+  actionDelete: "Delete",
+  actionNewFile: "New file",
+  actionNewFolder: "New folder",
+  confirmDeleteTitle: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((n) => n === 1 ? "Delete item?" : `Delete ${n} items?`, "confirmDeleteTitle"),
+  confirmDeleteMessage: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((names) => names.length === 1 ? `"${names[0]}" will be removed. This action cannot be undone.` : `${names.length} items will be removed. This action cannot be undone.`, "confirmDeleteMessage"),
+  confirmDeleteOk: "Delete",
+  confirmDeleteCancel: "Cancel",
+  newFileTitle: "New file",
+  newFileMessage: "File name",
+  newFilePlaceholder: "untitled.txt",
+  newFileDefault: "untitled.txt",
+  newFolderTitle: "New folder",
+  newFolderMessage: "Folder name",
+  newFolderPlaceholder: "untitled folder",
+  newFolderDefault: "untitled folder",
+  renameTitle: "Rename",
+  renameMessage: "New name",
+  invalidNameEmpty: "Name cannot be empty",
+  duplicateSuffix: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((name) => `${name} copy`, "duplicateSuffix")
+};
+
+// src/tools/data/Tree/context/state/reducer.ts
+function reducer(state, action) {
   switch (action.type) {
     case "expand": {
       if (state.expanded.has(action.id)) return state;
@@ -253,100 +282,92 @@ var reducer = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((state, action) => {
     case "select": {
       if (action.mode === "none") return state;
       if (action.mode === "single") {
-        return { ...state, selected: /* @__PURE__ */ new Set([action.id]), focused: action.id };
+        return {
+          ...state,
+          selected: /* @__PURE__ */ new Set([action.id]),
+          anchor: action.id,
+          focused: action.id
+        };
       }
       const next = new Set(state.selected);
       if (next.has(action.id)) next.delete(action.id);
       else next.add(action.id);
-      return { ...state, selected: next, focused: action.id };
+      return { ...state, selected: next, anchor: action.id, focused: action.id };
     }
     case "select-many":
       return { ...state, selected: new Set(action.ids) };
     case "clear-selection":
-      return { ...state, selected: /* @__PURE__ */ new Set() };
+      return { ...state, selected: /* @__PURE__ */ new Set(), anchor: null };
+    case "selection-replace":
+      return {
+        ...state,
+        selected: new Set(action.selected),
+        anchor: action.anchor,
+        focused: action.focused
+      };
+    case "set-anchor":
+      return { ...state, anchor: action.id };
     case "focus":
       return { ...state, focused: action.id };
     case "set-query":
       return { ...state, query: action.q };
+    case "start-rename":
+      return { ...state, renaming: action.id };
+    case "stop-rename":
+      return state.renaming === null ? state : { ...state, renaming: null };
+    case "clipboard-set":
+      return { ...state, clipboard: action.payload };
     case "cache-tick":
       return { ...state, cacheTick: state.cacheTick + 1 };
     default:
       return state;
   }
-}, "reducer");
-var TreeContext = React.createContext(null);
-function useTreeContext() {
-  const ctx = React__namespace.useContext(TreeContext);
-  if (!ctx) {
-    throw new Error("useTreeContext must be used inside <TreeProvider>");
-  }
-  return ctx;
 }
-chunkPK6SKIKE_cjs.__name(useTreeContext, "useTreeContext");
-var setEqualsArr = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((set, arr) => {
-  if (set.size !== arr.length) return false;
-  for (const id of arr) if (!set.has(id)) return false;
-  return true;
-}, "setEqualsArr");
-var collectAllIds = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((roots, cache, out) => {
+chunkPK6SKIKE_cjs.__name(reducer, "reducer");
+
+// src/tools/data/Tree/context/state/initial.ts
+function createInitialState(input) {
+  const { persisted, initialExpandedIds, initialSelectedIds, persistSelection } = input;
+  const initialSelected = new Set(
+    (persistSelection ? persisted?.selectedItems : void 0) ?? initialSelectedIds ?? []
+  );
+  const initialAnchor = initialSelected.size > 0 ? initialSelected.values().next().value : null;
+  return {
+    expanded: new Set(persisted?.expandedItems ?? initialExpandedIds ?? []),
+    selected: initialSelected,
+    anchor: initialAnchor,
+    focused: null,
+    query: "",
+    renaming: null,
+    clipboard: null,
+    cacheTick: 0
+  };
+}
+chunkPK6SKIKE_cjs.__name(createInitialState, "createInitialState");
+
+// src/tools/data/Tree/context/async-children/collect-ids.ts
+function collectAllFolderIds(roots, cache, out) {
   for (const node of roots) {
     if (Array.isArray(node.children)) {
       out.push(node.id);
-      collectAllIds(node.children, cache, out);
+      collectAllFolderIds(node.children, cache, out);
     } else if (node.isFolder) {
       out.push(node.id);
       const entry = cache.get(node.id);
-      if (entry?.children) collectAllIds(entry.children, cache, out);
+      if (entry?.children) collectAllFolderIds(entry.children, cache, out);
     }
   }
-}, "collectAllIds");
-function TreeProvider(props) {
-  const {
-    data,
-    getItemName,
-    loadChildren,
-    selectionMode = "single",
-    activationMode = "single-click",
-    initialExpandedIds,
-    initialSelectedIds,
-    indent,
-    appearance,
-    onSelectionChange,
-    onExpansionChange,
-    onActivate,
-    filterNode,
-    enableSearch = false,
-    showIndentGuides = false,
-    renderIcon,
-    renderLabel,
-    renderActions,
-    renderContextMenu,
-    labels: labelsOverride,
-    persistKey,
-    persistSelection = false,
-    children
-  } = props;
-  const labels = React.useMemo(
-    () => ({ ...DEFAULT_TREE_LABELS, ...labelsOverride }),
-    [labelsOverride]
-  );
-  const resolvedAppearance = React.useMemo(
-    () => resolveAppearance(appearance, indent),
-    [appearance, indent]
-  );
-  const persisted = React.useMemo(
-    () => persistKey ? loadTreeState(persistKey) : null,
-    [persistKey]
-  );
-  const [state, dispatch] = React.useReducer(reducer, void 0, () => ({
-    expanded: new Set(persisted?.expandedItems ?? initialExpandedIds ?? []),
-    selected: new Set(
-      (persistSelection ? persisted?.selectedItems : void 0) ?? initialSelectedIds ?? []
-    ),
-    focused: null,
-    query: "",
-    cacheTick: 0
-  }));
+}
+chunkPK6SKIKE_cjs.__name(collectAllFolderIds, "collectAllFolderIds");
+
+// src/tools/data/Tree/context/async-children/use-async-children.ts
+function useAsyncChildren({
+  data,
+  loadChildren,
+  expanded,
+  cacheTick,
+  bumpCacheTick
+}) {
   const cacheRef = React.useRef(createChildCache());
   const inflightRef = React.useRef(/* @__PURE__ */ new Map());
   const fetchChildren = React.useCallback(
@@ -358,11 +379,11 @@ function TreeProvider(props) {
       const inflight = inflightRef.current.get(node.id);
       if (inflight) return inflight;
       cacheRef.current.set(node.id, { status: "loading", children: [] });
-      dispatch({ type: "cache-tick" });
+      bumpCacheTick();
       const promise = (async () => {
         try {
-          const children2 = await loadChildren(node);
-          cacheRef.current.set(node.id, { status: "loaded", children: children2 });
+          const children = await loadChildren(node);
+          cacheRef.current.set(node.id, { status: "loaded", children });
         } catch (err) {
           cacheRef.current.set(node.id, {
             status: "error",
@@ -371,13 +392,13 @@ function TreeProvider(props) {
           });
         } finally {
           inflightRef.current.delete(node.id);
-          dispatch({ type: "cache-tick" });
+          bumpCacheTick();
         }
       })();
       inflightRef.current.set(node.id, promise);
       return promise;
     },
-    [loadChildren]
+    [loadChildren, bumpCacheTick]
   );
   const nodeById = React.useMemo(() => {
     const map = /* @__PURE__ */ new Map();
@@ -393,141 +414,1056 @@ function TreeProvider(props) {
     }, "walk");
     walk(data);
     return map;
-  }, [data, state.cacheTick]);
+  }, [data, cacheTick]);
   React.useEffect(() => {
     if (!loadChildren) return;
-    for (const id of state.expanded) {
+    for (const id of expanded) {
       const node = nodeById.get(id);
       if (!node) continue;
       void fetchChildren(node);
     }
-  }, [loadChildren, state.expanded, state.cacheTick, nodeById, fetchChildren]);
-  const flatRows = React.useMemo(
-    () => flattenTree({
-      roots: data,
-      expandedIds: state.expanded,
-      cache: cacheRef.current,
-      filterNode
-    }),
-    [data, state.expanded, state.cacheTick, filterNode]
+  }, [loadChildren, expanded, cacheTick, nodeById, fetchChildren]);
+  const refresh = React.useCallback(
+    async (id) => {
+      const node = nodeById.get(id);
+      if (!node || !loadChildren) return;
+      cacheRef.current.delete(id);
+      bumpCacheTick();
+      await fetchChildren(node);
+    },
+    [nodeById, loadChildren, fetchChildren, bumpCacheTick]
   );
-  const matchingIds = React.useMemo(() => {
-    const set = /* @__PURE__ */ new Set();
-    if (!enableSearch || state.query.trim() === "") return set;
-    const q = state.query.trim().toLowerCase();
-    for (const row of flatRows) {
-      if (getItemName(row.node).toLowerCase().includes(q)) {
-        set.add(row.node.id);
+  const refreshAll = React.useCallback(async () => {
+    cacheRef.current.clear();
+    bumpCacheTick();
+    if (!loadChildren) return;
+    await Promise.all(
+      [...expanded].map((id) => {
+        const node = nodeById.get(id);
+        return node ? fetchChildren(node) : void 0;
+      })
+    );
+  }, [loadChildren, expanded, nodeById, fetchChildren, bumpCacheTick]);
+  const collectFolderIds = React.useCallback(() => {
+    const ids = [];
+    collectAllFolderIds(data, cacheRef.current, ids);
+    return ids;
+  }, [data]);
+  return {
+    cache: cacheRef.current,
+    nodeById,
+    fetchChildren,
+    refresh,
+    refreshAll,
+    collectFolderIds
+  };
+}
+chunkPK6SKIKE_cjs.__name(useAsyncChildren, "useAsyncChildren");
+function useExpansion({
+  dispatch,
+  collectFolderIds
+}) {
+  const expand = React.useCallback(
+    (id) => dispatch({ type: "expand", id }),
+    [dispatch]
+  );
+  const collapse = React.useCallback(
+    (id) => dispatch({ type: "collapse", id }),
+    [dispatch]
+  );
+  const toggle = React.useCallback(
+    (id) => dispatch({ type: "toggle", id }),
+    [dispatch]
+  );
+  const expandAll = React.useCallback(() => {
+    dispatch({ type: "set-expanded", ids: collectFolderIds() });
+  }, [dispatch, collectFolderIds]);
+  const collapseAll = React.useCallback(
+    () => dispatch({ type: "set-expanded", ids: [] }),
+    [dispatch]
+  );
+  return { expand, collapse, toggle, expandAll, collapseAll };
+}
+chunkPK6SKIKE_cjs.__name(useExpansion, "useExpansion");
+
+// src/tools/data/Tree/data/selection.ts
+function indexOf(rows, id) {
+  if (id == null) return -1;
+  for (let i = 0; i < rows.length; i++) {
+    if (rows[i].node.id === id) return i;
+  }
+  return -1;
+}
+chunkPK6SKIKE_cjs.__name(indexOf, "indexOf");
+function computeRange(rows, fromId, toId) {
+  if (fromId == null || toId == null) return [];
+  const a = indexOf(rows, fromId);
+  const b = indexOf(rows, toId);
+  if (a < 0 || b < 0) return [];
+  const [lo, hi] = a <= b ? [a, b] : [b, a];
+  const out = [];
+  for (let i = lo; i <= hi; i++) out.push(rows[i].node.id);
+  return out;
+}
+chunkPK6SKIKE_cjs.__name(computeRange, "computeRange");
+function selectionFromClick(state, rows, id, mods, multi) {
+  if (!multi) {
+    return { selected: /* @__PURE__ */ new Set([id]), anchor: id, focused: id };
+  }
+  if (mods.shift && mods.meta) {
+    const anchor = state.anchor ?? state.focused ?? id;
+    const range = computeRange(rows, anchor, id);
+    const next = new Set(state.selected);
+    for (const r of range) next.add(r);
+    return { selected: next, anchor: state.anchor ?? id, focused: id };
+  }
+  if (mods.shift) {
+    const anchor = state.anchor ?? state.focused ?? id;
+    const range = computeRange(rows, anchor, id);
+    return {
+      selected: new Set(range.length > 0 ? range : [id]),
+      anchor: state.anchor ?? anchor,
+      focused: id
+    };
+  }
+  if (mods.meta) {
+    const next = new Set(state.selected);
+    if (next.has(id)) next.delete(id);
+    else next.add(id);
+    return { selected: next, anchor: id, focused: id };
+  }
+  return { selected: /* @__PURE__ */ new Set([id]), anchor: id, focused: id };
+}
+chunkPK6SKIKE_cjs.__name(selectionFromClick, "selectionFromClick");
+function selectionFromMove(state, rows, nextFocusedId, extend, multi) {
+  if (!multi || !extend) {
+    return { selected: /* @__PURE__ */ new Set([nextFocusedId]), anchor: nextFocusedId, focused: nextFocusedId };
+  }
+  const anchor = state.anchor ?? state.focused ?? nextFocusedId;
+  const range = computeRange(rows, anchor, nextFocusedId);
+  return {
+    selected: new Set(range.length > 0 ? range : [nextFocusedId]),
+    anchor,
+    focused: nextFocusedId
+  };
+}
+chunkPK6SKIKE_cjs.__name(selectionFromMove, "selectionFromMove");
+function selectionSelectAll(rows, focused) {
+  if (rows.length === 0) {
+    return { selected: /* @__PURE__ */ new Set(), anchor: null, focused };
+  }
+  const ids = rows.map((r) => r.node.id);
+  return {
+    selected: new Set(ids),
+    anchor: ids[0],
+    focused: focused ?? ids[0]
+  };
+}
+chunkPK6SKIKE_cjs.__name(selectionSelectAll, "selectionSelectAll");
+
+// src/tools/data/Tree/context/selection/use-selection.ts
+function useSelection({
+  dispatch,
+  selectionMode,
+  flatRows,
+  selected,
+  anchor,
+  focused
+}) {
+  const flatRowsRef = React.useRef(flatRows);
+  flatRowsRef.current = flatRows;
+  const selectionRef = React.useRef({ selected, anchor, focused });
+  selectionRef.current = { selected, anchor, focused };
+  const select = React.useCallback(
+    (id) => dispatch({ type: "select", id, mode: selectionMode }),
+    [dispatch, selectionMode]
+  );
+  const setSelectedIds = React.useCallback(
+    (ids) => dispatch({ type: "select-many", ids }),
+    [dispatch]
+  );
+  const clearSelection = React.useCallback(
+    () => dispatch({ type: "clear-selection" }),
+    [dispatch]
+  );
+  const setFocus = React.useCallback(
+    (id) => dispatch({ type: "focus", id }),
+    [dispatch]
+  );
+  const clickSelect = React.useCallback(
+    (id, mods) => {
+      if (selectionMode === "none") return;
+      if (selectionMode === "single") {
+        dispatch({ type: "select", id, mode: "single" });
+        return;
+      }
+      const next = selectionFromClick(
+        selectionRef.current,
+        flatRowsRef.current,
+        id,
+        mods,
+        true
+      );
+      dispatch({
+        type: "selection-replace",
+        selected: [...next.selected],
+        anchor: next.anchor,
+        focused: next.focused
+      });
+    },
+    [dispatch, selectionMode]
+  );
+  const moveSelect = React.useCallback(
+    (id, opts) => {
+      if (selectionMode !== "multiple" || !opts.extend) {
+        dispatch({ type: "focus", id });
+        return;
+      }
+      const next = selectionFromMove(
+        selectionRef.current,
+        flatRowsRef.current,
+        id,
+        true,
+        true
+      );
+      dispatch({
+        type: "selection-replace",
+        selected: [...next.selected],
+        anchor: next.anchor,
+        focused: next.focused
+      });
+    },
+    [dispatch, selectionMode]
+  );
+  const selectAll = React.useCallback(() => {
+    if (selectionMode !== "multiple") return;
+    const next = selectionSelectAll(
+      flatRowsRef.current,
+      selectionRef.current.focused
+    );
+    dispatch({
+      type: "selection-replace",
+      selected: [...next.selected],
+      anchor: next.anchor,
+      focused: next.focused
+    });
+  }, [dispatch, selectionMode]);
+  return {
+    select,
+    setSelectedIds,
+    clearSelection,
+    clickSelect,
+    moveSelect,
+    selectAll,
+    setFocus
+  };
+}
+chunkPK6SKIKE_cjs.__name(useSelection, "useSelection");
+function useRename({
+  dispatch,
+  adapter,
+  enableInlineRename,
+  nodeById,
+  getItemName,
+  labels
+}) {
+  const enabled = enableInlineRename && !!adapter?.rename;
+  const startRename = React.useCallback(
+    (id) => {
+      if (!enableInlineRename) return;
+      if (!adapter?.rename) {
+        if (process.env.NODE_ENV !== "production") {
+          console.warn(
+            "[Tree] startRename called but adapter.rename is not defined."
+          );
+        }
+        return;
+      }
+      dispatch({ type: "start-rename", id });
+    },
+    [dispatch, enableInlineRename, adapter]
+  );
+  const cancelRename = React.useCallback(
+    () => dispatch({ type: "stop-rename" }),
+    [dispatch]
+  );
+  const commitRename = React.useCallback(
+    async (id, nextName) => {
+      if (!adapter?.rename) {
+        dispatch({ type: "stop-rename" });
+        return false;
+      }
+      const node = nodeById.get(id);
+      if (!node) {
+        dispatch({ type: "stop-rename" });
+        return false;
+      }
+      const trimmed = nextName.trim();
+      if (trimmed === getItemName(node)) {
+        dispatch({ type: "stop-rename" });
+        return true;
+      }
+      let err = null;
+      if (trimmed === "") err = labels.invalidNameEmpty;
+      else err = adapter.validateName?.(trimmed, { node }) ?? null;
+      if (err) {
+        const dialog = dialogService.getDialog();
+        await dialog?.alert({ title: labels.error, message: err });
+        return false;
+      }
+      try {
+        await adapter.rename(node, trimmed);
+      } catch (e) {
+        const dialog = dialogService.getDialog();
+        await dialog?.alert({
+          title: labels.error,
+          message: e instanceof Error ? e.message : String(e)
+        });
+        return false;
+      }
+      dispatch({ type: "stop-rename" });
+      return true;
+    },
+    [dispatch, adapter, nodeById, getItemName, labels]
+  );
+  return { enabled, startRename, cancelRename, commitRename };
+}
+chunkPK6SKIKE_cjs.__name(useRename, "useRename");
+function useClipboard({
+  dispatch,
+  clipboard,
+  adapter,
+  nodeById,
+  labels
+}) {
+  const clipboardRef = React.useRef(clipboard);
+  clipboardRef.current = clipboard;
+  const cutToClipboard = React.useCallback(
+    (ids) => {
+      if (ids.length === 0) return;
+      dispatch({ type: "clipboard-set", payload: { kind: "cut", ids } });
+    },
+    [dispatch]
+  );
+  const copyToClipboard = React.useCallback(
+    (ids) => {
+      if (ids.length === 0) return;
+      dispatch({ type: "clipboard-set", payload: { kind: "copy", ids } });
+    },
+    [dispatch]
+  );
+  const clearClipboard = React.useCallback(
+    () => dispatch({ type: "clipboard-set", payload: null }),
+    [dispatch]
+  );
+  const pasteFromClipboard = React.useCallback(
+    async (target, position = "inside") => {
+      const cb = clipboardRef.current;
+      if (!cb || cb.ids.length === 0) return;
+      if (!adapter) return;
+      const nodes = cb.ids.map((id) => nodeById.get(id)).filter((n) => !!n);
+      if (nodes.length === 0) {
+        dispatch({ type: "clipboard-set", payload: null });
+        return;
+      }
+      try {
+        if (cb.kind === "cut") {
+          if (!adapter.move) return;
+          await adapter.move(nodes, target, position);
+          dispatch({ type: "clipboard-set", payload: null });
+        } else {
+          if (!adapter.copy) return;
+          await adapter.copy(nodes, target, position);
+        }
+      } catch (e) {
+        const dialog = dialogService.getDialog();
+        await dialog?.alert({
+          title: labels.error,
+          message: e instanceof Error ? e.message : String(e)
+        });
+      }
+    },
+    [dispatch, adapter, nodeById, labels]
+  );
+  return {
+    cutToClipboard,
+    copyToClipboard,
+    pasteFromClipboard,
+    clearClipboard
+  };
+}
+chunkPK6SKIKE_cjs.__name(useClipboard, "useClipboard");
+async function confirmDelete(ctx) {
+  const dialog = dialogService.getDialog();
+  if (!dialog) return false;
+  const { selectedNodes, labels, getName } = ctx;
+  return dialog.confirm({
+    title: labels.confirmDeleteTitle(selectedNodes.length),
+    message: labels.confirmDeleteMessage(selectedNodes.map(getName)),
+    confirmText: labels.confirmDeleteOk,
+    cancelText: labels.confirmDeleteCancel,
+    variant: "destructive"
+  });
+}
+chunkPK6SKIKE_cjs.__name(confirmDelete, "confirmDelete");
+async function promptName(ctx, spec) {
+  const dialog = dialogService.getDialog();
+  if (!dialog) return null;
+  return dialog.prompt({
+    title: spec.title,
+    message: spec.message,
+    placeholder: spec.placeholder,
+    defaultValue: spec.defaultValue
+  });
+}
+chunkPK6SKIKE_cjs.__name(promptName, "promptName");
+async function alertError(ctx, message) {
+  const dialog = dialogService.getDialog();
+  if (!dialog) return;
+  await dialog.alert({ message, title: ctx.labels.error });
+}
+chunkPK6SKIKE_cjs.__name(alertError, "alertError");
+function validateName(ctx, name, validateCtx) {
+  if (name.trim() === "") return ctx.labels.invalidNameEmpty;
+  return ctx.adapter.validateName?.(name, validateCtx) ?? null;
+}
+chunkPK6SKIKE_cjs.__name(validateName, "validateName");
+var BUILTIN_ACTIONS = [
+  {
+    id: "open",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionOpen, "label"),
+    icon: lucideReact.CornerUpLeft,
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => false, "available"),
+    // wired by Tree on activate; not in menu by default
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
+    }, "run")
+  },
+  {
+    id: "rename",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionRename, "label"),
+    icon: lucideReact.Pencil,
+    shortcut: "F2",
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.rename && ctx.selectedNodes.length === 1 && !ctx.selectedNodes[0].disabled, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (ctx) => {
+      const node = ctx.selectedNodes[0];
+      if (ctx.startInlineRename) {
+        ctx.startInlineRename(node.id);
+        return;
+      }
+      const name = await promptName(ctx, {
+        title: ctx.labels.renameTitle,
+        message: ctx.labels.renameMessage,
+        placeholder: ctx.getName(node),
+        defaultValue: ctx.getName(node)
+      });
+      if (name === null) return;
+      const err = validateName(ctx, name, { node });
+      if (err) return alertError(ctx, err);
+      await ctx.adapter.rename(node, name);
+    }, "run")
+  },
+  {
+    id: "duplicate",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionDuplicate, "label"),
+    icon: lucideReact.Copy,
+    shortcut: "\u2318D",
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.duplicate && ctx.selectedNodes.length > 0, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.adapter.duplicate(ctx.selectedNodes), "run")
+  },
+  {
+    id: "cut",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionCut, "label"),
+    icon: lucideReact.Scissors,
+    shortcut: "\u2318X",
+    // Only meaningful when the adapter supports `move` (paste-after-cut)
+    // AND Tree provided a clipboard binding.
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.move && !!ctx.clipboard && ctx.selectedNodes.length > 0, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => {
+      ctx.clipboard?.cut(ctx.selectedNodes.map((n) => n.id));
+    }, "run")
+  },
+  {
+    id: "copy",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionCopy, "label"),
+    icon: lucideReact.Copy,
+    shortcut: "\u2318C",
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.copy && !!ctx.clipboard && ctx.selectedNodes.length > 0, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => {
+      ctx.clipboard?.copy(ctx.selectedNodes.map((n) => n.id));
+    }, "run")
+  },
+  {
+    id: "paste",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionPaste, "label"),
+    icon: lucideReact.CornerUpLeft,
+    shortcut: "\u2318V",
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.clipboard?.hasItems, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (ctx) => {
+      await ctx.clipboard?.paste();
+    }, "run")
+  },
+  {
+    id: "delete",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionDelete, "label"),
+    icon: lucideReact.Trash2,
+    shortcut: "\u2318\u232B",
+    destructive: true,
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.remove && ctx.selectedNodes.length > 0, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (ctx) => {
+      const ok = await confirmDelete(ctx);
+      if (!ok) return;
+      await ctx.adapter.remove(ctx.selectedNodes);
+    }, "run")
+  },
+  {
+    id: "new-file",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionNewFile, "label"),
+    icon: lucideReact.FilePlus,
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.createFile, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (ctx) => {
+      const parent = resolveParentForCreate(ctx);
+      const name = await promptName(ctx, {
+        title: ctx.labels.newFileTitle,
+        message: ctx.labels.newFileMessage,
+        placeholder: ctx.labels.newFilePlaceholder,
+        defaultValue: ctx.labels.newFileDefault
+      });
+      if (name === null) return;
+      const err = validateName(ctx, name, { parent });
+      if (err) return alertError(ctx, err);
+      await ctx.adapter.createFile(parent, name);
+    }, "run")
+  },
+  {
+    id: "new-folder",
+    label: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => ctx.labels.actionNewFolder, "label"),
+    icon: lucideReact.FolderPlus,
+    shortcut: "\u2318\u21E7N",
+    available: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((ctx) => !!ctx.adapter.createFolder, "available"),
+    run: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(async (ctx) => {
+      const parent = resolveParentForCreate(ctx);
+      const name = await promptName(ctx, {
+        title: ctx.labels.newFolderTitle,
+        message: ctx.labels.newFolderMessage,
+        placeholder: ctx.labels.newFolderPlaceholder,
+        defaultValue: ctx.labels.newFolderDefault
+      });
+      if (name === null) return;
+      const err = validateName(ctx, name, { parent });
+      if (err) return alertError(ctx, err);
+      await ctx.adapter.createFolder(parent, name);
+    }, "run")
+  }
+];
+var DEFAULT_BUILTIN_MENU_ORDER = [
+  "rename",
+  "duplicate",
+  "separator",
+  "cut",
+  "copy",
+  "paste",
+  "separator",
+  "new-file",
+  "new-folder",
+  "separator",
+  "delete"
+];
+function resolveParentForCreate(ctx) {
+  const { targetNode } = ctx;
+  if (!targetNode) return null;
+  const isFolder = Array.isArray(targetNode.children) || !!targetNode.isFolder;
+  return isFolder ? targetNode : null;
+}
+chunkPK6SKIKE_cjs.__name(resolveParentForCreate, "resolveParentForCreate");
+function buildDefaultMenuItems(ctx, order = DEFAULT_BUILTIN_MENU_ORDER) {
+  const items = [];
+  let pendingSeparator = false;
+  for (const entry of order) {
+    if (entry === "separator") {
+      pendingSeparator = items.length > 0;
+      continue;
+    }
+    const desc = BUILTIN_ACTIONS.find((a) => a.id === entry);
+    if (!desc) continue;
+    if (!desc.available(ctx)) continue;
+    if (pendingSeparator) {
+      items.push("separator");
+      pendingSeparator = false;
+    }
+    items.push({
+      id: desc.id,
+      label: desc.label(ctx),
+      icon: desc.icon,
+      shortcut: desc.shortcut,
+      destructive: desc.destructive,
+      onSelect: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => void desc.run(ctx), "onSelect")
+    });
+  }
+  return items.length > 0 ? items : null;
+}
+chunkPK6SKIKE_cjs.__name(buildDefaultMenuItems, "buildDefaultMenuItems");
+async function runBuiltinAction(id, ctx) {
+  const desc = BUILTIN_ACTIONS.find((a) => a.id === id);
+  if (!desc) return false;
+  if (!desc.available(ctx)) return false;
+  await desc.run(ctx);
+  return true;
+}
+chunkPK6SKIKE_cjs.__name(runBuiltinAction, "runBuiltinAction");
+function useResolvedMenu(opts) {
+  const {
+    adapter,
+    contextMenuActions,
+    defaultMenuItems,
+    labels,
+    selected,
+    clipboard,
+    nodeById,
+    getItemName,
+    enableInlineRename,
+    startRename,
+    cutToClipboard,
+    copyToClipboard,
+    pasteFromClipboard
+  } = opts;
+  return React.useMemo(() => {
+    if (!adapter && !contextMenuActions) return void 0;
+    return (rowProps) => {
+      const selectedIds = selected.has(rowProps.node.id) ? [...selected] : [rowProps.node.id];
+      const selectedNodes = selectedIds.map((id) => nodeById.get(id)).filter((n) => !!n);
+      const builtin = adapter ? buildDefaultMenuItems(
+        {
+          adapter,
+          labels,
+          selectedNodes,
+          targetNode: rowProps.node,
+          getName: getItemName,
+          startInlineRename: enableInlineRename && adapter.rename ? startRename : void 0,
+          clipboard: {
+            hasItems: !!clipboard && clipboard.ids.length > 0,
+            cut: cutToClipboard,
+            copy: copyToClipboard,
+            paste: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => pasteFromClipboard(rowProps.node, "inside"), "paste")
+          }
+        },
+        defaultMenuItems ? defaultMenuItems : void 0
+      ) : null;
+      const user = contextMenuActions?.({ ...rowProps, selectedNodes }) ?? null;
+      if (!builtin && !user) return null;
+      if (!user) return builtin;
+      if (!builtin) return user;
+      return [...builtin, "separator", ...user];
+    };
+  }, [
+    adapter,
+    contextMenuActions,
+    defaultMenuItems,
+    labels,
+    selected,
+    clipboard,
+    nodeById,
+    getItemName,
+    enableInlineRename,
+    startRename,
+    cutToClipboard,
+    copyToClipboard,
+    pasteFromClipboard
+  ]);
+}
+chunkPK6SKIKE_cjs.__name(useResolvedMenu, "useResolvedMenu");
+
+// src/tools/data/Tree/data/dnd.ts
+function resolveDropZone(input) {
+  const { pointerY, rowRect, isFolder } = input;
+  const offset = pointerY - rowRect.top;
+  const ratio = rowRect.height > 0 ? offset / rowRect.height : 0.5;
+  if (isFolder) {
+    if (ratio < 0.33) return "before";
+    if (ratio > 0.66) return "after";
+    return "inside";
+  }
+  return ratio < 0.5 ? "before" : "after";
+}
+chunkPK6SKIKE_cjs.__name(resolveDropZone, "resolveDropZone");
+function defaultCanDrop(input) {
+  const { source, target, position } = input;
+  if (source.length === 0) return false;
+  if (!target) return true;
+  if (position === "inside") {
+    const isFolder = Array.isArray(target.children) || !!target.isFolder;
+    if (!isFolder) return false;
+  }
+  for (const node of source) {
+    if (node.id === target.id) return false;
+    if (isDescendant(node, target.id)) return false;
+  }
+  return true;
+}
+chunkPK6SKIKE_cjs.__name(defaultCanDrop, "defaultCanDrop");
+function isDescendant(root, id) {
+  if (!Array.isArray(root.children)) return false;
+  for (const child of root.children) {
+    if (child.id === id) return true;
+    if (isDescendant(child, id)) return true;
+  }
+  return false;
+}
+chunkPK6SKIKE_cjs.__name(isDescendant, "isDescendant");
+var TREE_DND_MIME = "application/x-djangocfg-tree";
+var TREE_ROOT_DROP_ID = "__tree_root_drop__";
+
+// src/tools/data/Tree/context/dnd/use-dnd.ts
+function useDnd({
+  enabled,
+  adapter,
+  nodeById,
+  selected,
+  labels,
+  canDrop
+}) {
+  const active = enabled && !!adapter?.move;
+  const [draggingIds, setDraggingIds] = React.useState(
+    () => /* @__PURE__ */ new Set()
+  );
+  const [dropTarget, setDropTarget] = React.useState(null);
+  const beginDrag = React.useCallback(
+    (rowId) => {
+      if (!active) return;
+      const ids = selected.has(rowId) ? new Set(selected) : /* @__PURE__ */ new Set([rowId]);
+      setDraggingIds(ids);
+    },
+    [active, selected]
+  );
+  const cancelDrag = React.useCallback(() => {
+    setDraggingIds(/* @__PURE__ */ new Set());
+    setDropTarget(null);
+  }, []);
+  const resolveSourceNodes = React.useCallback(() => {
+    const out = [];
+    for (const id of draggingIds) {
+      const node = nodeById.get(id);
+      if (node) out.push(node);
+    }
+    return out;
+  }, [draggingIds, nodeById]);
+  const isAllowedDrop = React.useCallback(
+    (target, position) => {
+      if (!active) return false;
+      if (draggingIds.size === 0) return false;
+      const source = resolveSourceNodes();
+      if (!defaultCanDrop({
+        source,
+        target,
+        position})) {
+        return false;
       }
+      return canDrop?.({ source, target, position }) ?? true;
+    },
+    [active, draggingIds, resolveSourceNodes, nodeById, canDrop]
+  );
+  const commitDrop = React.useCallback(async () => {
+    if (!active || !adapter?.move) {
+      cancelDrag();
+      return;
     }
-    return set;
-  }, [enableSearch, state.query, flatRows, getItemName]);
+    const t = dropTarget;
+    if (!t) {
+      cancelDrag();
+      return;
+    }
+    const targetNode = t.id ? nodeById.get(t.id) ?? null : null;
+    const source = resolveSourceNodes();
+    if (source.length === 0) {
+      cancelDrag();
+      return;
+    }
+    if (!isAllowedDrop(targetNode, t.position)) {
+      cancelDrag();
+      return;
+    }
+    try {
+      await adapter.move(source, targetNode, t.position);
+    } catch (e) {
+      const dialog = dialogService.getDialog();
+      await dialog?.alert({
+        title: labels.error,
+        message: e instanceof Error ? e.message : String(e)
+      });
+    } finally {
+      cancelDrag();
+    }
+  }, [
+    active,
+    adapter,
+    cancelDrag,
+    dropTarget,
+    isAllowedDrop,
+    labels,
+    nodeById,
+    resolveSourceNodes
+  ]);
+  return React.useMemo(
+    () => ({
+      active,
+      draggingIds,
+      dropTarget,
+      beginDrag,
+      setDropTarget,
+      commitDrop,
+      cancelDrag,
+      isAllowedDrop
+    }),
+    [
+      active,
+      draggingIds,
+      dropTarget,
+      beginDrag,
+      commitDrop,
+      cancelDrag,
+      isAllowedDrop
+    ]
+  );
+}
+chunkPK6SKIKE_cjs.__name(useDnd, "useDnd");
+function usePersistSync({
+  expanded,
+  selected,
+  persistKey,
+  persistSelection,
+  onSelectionChange,
+  onExpansionChange
+}) {
   const onSelectionChangeRef = React.useRef(onSelectionChange);
   const onExpansionChangeRef = React.useRef(onExpansionChange);
-  const onActivateRef = React.useRef(onActivate);
   onSelectionChangeRef.current = onSelectionChange;
   onExpansionChangeRef.current = onExpansionChange;
-  onActivateRef.current = onActivate;
-  const lastSelectedArrRef = React.useRef([...state.selected]);
-  const lastExpandedArrRef = React.useRef([...state.expanded]);
+  const lastSelectedArrRef = React.useRef([...selected]);
+  const lastExpandedArrRef = React.useRef([...expanded]);
   React.useEffect(() => {
-    const arr = [...state.expanded];
-    if (!setEqualsArr(state.expanded, lastExpandedArrRef.current)) {
+    const arr = [...expanded];
+    if (!setEqualsArr(expanded, lastExpandedArrRef.current)) {
       lastExpandedArrRef.current = arr;
       onExpansionChangeRef.current?.(arr);
       if (persistKey) {
         saveTreeState(persistKey, {
           expandedItems: arr,
-          selectedItems: persistSelection ? [...state.selected] : []
+          selectedItems: persistSelection ? [...selected] : []
         });
       }
     }
-  }, [state.expanded, persistKey, persistSelection, state.selected]);
+  }, [expanded, persistKey, persistSelection, selected]);
   React.useEffect(() => {
-    const arr = [...state.selected];
-    if (!setEqualsArr(state.selected, lastSelectedArrRef.current)) {
+    const arr = [...selected];
+    if (!setEqualsArr(selected, lastSelectedArrRef.current)) {
       lastSelectedArrRef.current = arr;
       onSelectionChangeRef.current?.(arr);
       if (persistKey && persistSelection) {
         saveTreeState(persistKey, {
-          expandedItems: [...state.expanded],
+          expandedItems: [...expanded],
           selectedItems: arr
         });
       }
     }
-  }, [state.selected, persistKey, persistSelection, state.expanded]);
-  const expand = React.useCallback((id) => dispatch({ type: "expand", id }), []);
-  const collapse = React.useCallback((id) => dispatch({ type: "collapse", id }), []);
-  const toggle = React.useCallback((id) => dispatch({ type: "toggle", id }), []);
-  const expandAll = React.useCallback(() => {
-    const ids = [];
-    collectAllIds(data, cacheRef.current, ids);
-    dispatch({ type: "set-expanded", ids });
-  }, [data]);
-  const collapseAll = React.useCallback(
-    () => dispatch({ type: "set-expanded", ids: [] }),
-    []
-  );
-  const select = React.useCallback(
-    (id) => dispatch({ type: "select", id, mode: selectionMode }),
-    [selectionMode]
-  );
-  const setSelectedIds = React.useCallback(
-    (ids) => dispatch({ type: "select-many", ids }),
-    []
+  }, [selected, persistKey, persistSelection, expanded]);
+}
+chunkPK6SKIKE_cjs.__name(usePersistSync, "usePersistSync");
+function setEqualsArr(set, arr) {
+  if (set.size !== arr.length) return false;
+  for (const id of arr) if (!set.has(id)) return false;
+  return true;
+}
+chunkPK6SKIKE_cjs.__name(setEqualsArr, "setEqualsArr");
+var TreeContext = React.createContext(null);
+function useTreeContext() {
+  const ctx = React__namespace.useContext(TreeContext);
+  if (!ctx) {
+    throw new Error("useTreeContext must be used inside <TreeProvider>");
+  }
+  return ctx;
+}
+chunkPK6SKIKE_cjs.__name(useTreeContext, "useTreeContext");
+function TreeProvider(props) {
+  const {
+    data,
+    getItemName,
+    loadChildren,
+    selectionMode = "single",
+    activationMode = "single-click",
+    initialExpandedIds,
+    initialSelectedIds,
+    indent,
+    appearance,
+    onSelectionChange,
+    onExpansionChange,
+    onActivate,
+    filterNode,
+    enableSearch = false,
+    showIndentGuides = false,
+    renderIcon,
+    renderLabel,
+    renderActions,
+    renderContextMenu,
+    contextMenuActions,
+    labels: labelsOverride,
+    persistKey,
+    persistSelection = false,
+    adapter,
+    defaultMenuItems,
+    enableInlineRename = false,
+    enableDnD = false,
+    canDrop,
+    children
+  } = props;
+  const labels = React.useMemo(
+    () => ({ ...DEFAULT_TREE_LABELS, ...labelsOverride }),
+    [labelsOverride]
   );
-  const clearSelection = React.useCallback(() => dispatch({ type: "clear-selection" }), []);
-  const setFocus = React.useCallback(
-    (id) => dispatch({ type: "focus", id }),
-    []
+  const resolvedAppearance = React.useMemo(
+    () => resolveAppearance(appearance, indent),
+    [appearance, indent]
   );
-  const setQuery = React.useCallback((q) => dispatch({ type: "set-query", q }), []);
-  const refresh = React.useCallback(
-    async (id) => {
-      const node = nodeById.get(id);
-      if (!node || !loadChildren) return;
-      cacheRef.current.delete(id);
-      dispatch({ type: "cache-tick" });
-      await fetchChildren(node);
-    },
-    [nodeById, loadChildren, fetchChildren]
+  const persisted = React.useMemo(
+    () => persistKey ? loadTreeState(persistKey) : null,
+    [persistKey]
   );
-  const refreshAll = React.useCallback(async () => {
-    cacheRef.current.clear();
-    dispatch({ type: "cache-tick" });
-    if (!loadChildren) return;
-    await Promise.all(
-      [...state.expanded].map((id) => {
-        const node = nodeById.get(id);
-        return node ? fetchChildren(node) : void 0;
-      })
-    );
-  }, [loadChildren, state.expanded, nodeById, fetchChildren]);
+  const [state, dispatch] = React.useReducer(
+    reducer,
+    void 0,
+    () => createInitialState({
+      persisted,
+      initialExpandedIds,
+      initialSelectedIds,
+      persistSelection
+    })
+  );
+  const bumpCacheTick = React.useCallback(() => dispatch({ type: "cache-tick" }), []);
+  const {
+    nodeById,
+    refresh,
+    refreshAll,
+    collectFolderIds,
+    cache
+  } = useAsyncChildren({
+    data,
+    loadChildren,
+    expanded: state.expanded,
+    cacheTick: state.cacheTick,
+    bumpCacheTick
+  });
+  const flatRows = React.useMemo(
+    () => flattenTree({
+      roots: data,
+      expandedIds: state.expanded,
+      cache,
+      filterNode
+    }),
+    [data, state.expanded, state.cacheTick, cache, filterNode]
+  );
+  const matchingIds = React.useMemo(() => {
+    const set = /* @__PURE__ */ new Set();
+    if (!enableSearch || state.query.trim() === "") return set;
+    const q = state.query.trim().toLowerCase();
+    for (const row of flatRows) {
+      if (getItemName(row.node).toLowerCase().includes(q)) {
+        set.add(row.node.id);
+      }
+    }
+    return set;
+  }, [enableSearch, state.query, flatRows, getItemName]);
+  const expansion = useExpansion({ dispatch, collectFolderIds });
+  const selection = useSelection({
+    dispatch,
+    selectionMode,
+    flatRows,
+    selected: state.selected,
+    anchor: state.anchor,
+    focused: state.focused
+  });
+  const rename = useRename({
+    dispatch,
+    adapter,
+    enableInlineRename,
+    nodeById,
+    getItemName,
+    labels
+  });
+  const clipboard = useClipboard({
+    dispatch,
+    clipboard: state.clipboard,
+    adapter,
+    nodeById,
+    labels
+  });
+  const dnd = useDnd({
+    enabled: enableDnD,
+    adapter,
+    nodeById,
+    selected: state.selected,
+    labels,
+    canDrop
+  });
+  const onActivateRef = React.useRef(onActivate);
+  onActivateRef.current = onActivate;
   const activate = React.useCallback(
     (node, opts = { preview: false }) => onActivateRef.current?.(node, opts),
     []
   );
+  const setQuery = React.useCallback(
+    (q) => dispatch({ type: "set-query", q }),
+    []
+  );
+  usePersistSync({
+    expanded: state.expanded,
+    selected: state.selected,
+    persistKey,
+    persistSelection,
+    onSelectionChange,
+    onExpansionChange
+  });
+  const resolvedContextMenuActions = useResolvedMenu({
+    adapter,
+    contextMenuActions,
+    defaultMenuItems,
+    labels,
+    selected: state.selected,
+    clipboard: state.clipboard,
+    nodeById,
+    getItemName,
+    enableInlineRename,
+    startRename: rename.startRename,
+    cutToClipboard: clipboard.cutToClipboard,
+    copyToClipboard: clipboard.copyToClipboard,
+    pasteFromClipboard: clipboard.pasteFromClipboard
+  });
   const value = React.useMemo(
     () => ({
+      // state
       expanded: state.expanded,
       selected: state.selected,
+      anchor: state.anchor,
       focused: state.focused,
       query: state.query,
+      renamingId: state.renaming,
+      inlineRenameEnabled: rename.enabled,
+      clipboard: state.clipboard,
       flatRows,
       matchingIds,
-      expand,
-      collapse,
-      toggle,
-      expandAll,
-      collapseAll,
-      select,
-      setSelectedIds,
-      clearSelection,
-      setFocus,
+      // expansion
+      ...expansion,
+      // selection (note: `select` is from selection hook; expansion exports no `select`)
+      ...selection,
       setQuery,
+      // clipboard
+      ...clipboard,
+      // rename
+      startRename: rename.startRename,
+      cancelRename: rename.cancelRename,
+      commitRename: rename.commitRename,
+      // async
       refresh,
       refreshAll,
       activate,
+      // config
       labels,
       appearance: resolvedAppearance,
       indent: resolvedAppearance.indent,
@@ -536,28 +1472,34 @@ function TreeProvider(props) {
       enableSearch,
       showIndentGuides,
       getItemName,
+      // slots
       renderIcon,
       renderLabel,
       renderActions,
-      renderContextMenu
+      renderContextMenu,
+      adapter,
+      resolvedContextMenuActions,
+      getNodeById: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((id) => nodeById.get(id), "getNodeById"),
+      dnd
     }),
     [
       state.expanded,
       state.selected,
+      state.anchor,
       state.focused,
       state.query,
+      state.renaming,
+      state.clipboard,
+      rename.enabled,
+      rename.startRename,
+      rename.cancelRename,
+      rename.commitRename,
       flatRows,
       matchingIds,
-      expand,
-      collapse,
-      toggle,
-      expandAll,
-      collapseAll,
-      select,
-      setSelectedIds,
-      clearSelection,
-      setFocus,
+      expansion,
+      selection,
       setQuery,
+      clipboard,
       refresh,
       refreshAll,
       activate,
@@ -571,12 +1513,98 @@ function TreeProvider(props) {
       renderIcon,
       renderLabel,
       renderActions,
-      renderContextMenu
+      renderContextMenu,
+      adapter,
+      resolvedContextMenuActions,
+      nodeById,
+      dnd
     ]
   );
   return /* @__PURE__ */ jsxRuntime.jsx(TreeContext.Provider, { value, children });
 }
 chunkPK6SKIKE_cjs.__name(TreeProvider, "TreeProvider");
+function TreeDndProvider({ children }) {
+  const ctx = useTreeContext();
+  const { dnd } = ctx;
+  const sensors = core.useSensors(
+    core.useSensor(core.PointerSensor, { activationConstraint: { distance: 4 } }),
+    core.useSensor(core.KeyboardSensor)
+  );
+  const cursorYRef = React.useRef(0);
+  const handleDragStart = React.useCallback(
+    (e) => {
+      dnd.beginDrag(e.active.id);
+    },
+    [dnd]
+  );
+  const handleDragMove = React.useCallback(
+    (e) => {
+      const overId = e.over?.id;
+      if (overId === TREE_ROOT_DROP_ID) {
+        const current2 = dnd.dropTarget;
+        if (current2?.id !== null || current2?.position !== "inside") {
+          dnd.setDropTarget({ id: null, position: "inside" });
+        }
+        return;
+      }
+      if (typeof overId !== "string") {
+        if (dnd.dropTarget !== null) dnd.setDropTarget(null);
+        return;
+      }
+      const rect = e.over?.rect;
+      if (!rect) return;
+      const el = document.querySelector(
+        `[data-tree-row][data-id="${CSS.escape(overId)}"]`
+      );
+      const isFolder = el?.dataset.folder === "true";
+      const position = resolveDropZone({
+        pointerY: cursorYRef.current,
+        rowRect: { top: rect.top, bottom: rect.top + rect.height, height: rect.height },
+        isFolder
+      });
+      const current = dnd.dropTarget;
+      if (current?.id !== overId || current.position !== position) {
+        dnd.setDropTarget({ id: overId, position });
+      }
+    },
+    [dnd]
+  );
+  const handleDragEnd = React.useCallback(
+    async (_e) => {
+      await dnd.commitDrop();
+    },
+    [dnd]
+  );
+  const handleDragCancel = React.useCallback(() => {
+    dnd.cancelDrag();
+  }, [dnd]);
+  const handlePointerMove = React.useCallback((e) => {
+    cursorYRef.current = e.clientY;
+  }, []);
+  if (!dnd.active) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    core.DndContext,
+    {
+      sensors,
+      onDragStart: handleDragStart,
+      onDragMove: handleDragMove,
+      onDragEnd: handleDragEnd,
+      onDragCancel: handleDragCancel,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "div",
+        {
+          onPointerMove: handlePointerMove,
+          className: "contents",
+          "data-tree-dnd-surface": "",
+          children
+        }
+      )
+    }
+  );
+}
+chunkPK6SKIKE_cjs.__name(TreeDndProvider, "TreeDndProvider");
 function TreeChevronRaw({ isExpanded, isFolder, className }) {
   const { appearance } = useTreeContext();
   const size = { width: "var(--tree-icon-size)", height: "var(--tree-icon-size)" };
@@ -606,6 +1634,48 @@ function TreeChevronRaw({ isExpanded, isFolder, className }) {
 }
 chunkPK6SKIKE_cjs.__name(TreeChevronRaw, "TreeChevronRaw");
 var TreeChevron = React.memo(TreeChevronRaw);
+function TreeDropIndicator({
+  position,
+  indent,
+  invalid = false
+}) {
+  if (position === "inside") {
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      "span",
+      {
+        "aria-hidden": true,
+        "data-tree-drop": "inside",
+        className: lib.cn(
+          "pointer-events-none absolute inset-0 rounded-sm ring-1",
+          invalid ? "bg-destructive/10 ring-destructive/40" : "bg-primary/10 ring-primary/40"
+        )
+      }
+    );
+  }
+  const isBefore = position === "before";
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "span",
+    {
+      "aria-hidden": true,
+      "data-tree-drop": position,
+      style: { paddingLeft: indent },
+      className: lib.cn(
+        "pointer-events-none absolute right-0 left-0 h-px",
+        isBefore ? "top-0" : "bottom-0"
+      ),
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        "span",
+        {
+          className: lib.cn(
+            "block h-0.5 rounded-full",
+            invalid ? "bg-destructive/70" : "bg-primary"
+          )
+        }
+      )
+    }
+  );
+}
+chunkPK6SKIKE_cjs.__name(TreeDropIndicator, "TreeDropIndicator");
 function TreeIconRaw({ isFolder, isExpanded, className }) {
   const { appearance } = useTreeContext();
   const Icon = isFolder ? isExpanded ? lucideReact.FolderOpen : lucideReact.Folder : lucideReact.File;
@@ -662,6 +1732,96 @@ function TreeLabelRaw({ children, isMatchingSearch, className }) {
 }
 chunkPK6SKIKE_cjs.__name(TreeLabelRaw, "TreeLabelRaw");
 var TreeLabel = React.memo(TreeLabelRaw);
+
+// src/tools/data/Tree/data/renameUtils.ts
+function splitFileName(name) {
+  if (name.length === 0) return { base: "", ext: "" };
+  if (name.startsWith(".")) {
+    const rest = name.slice(1);
+    const dot2 = rest.lastIndexOf(".");
+    if (dot2 < 0) return { base: name, ext: "" };
+    return { base: "." + rest.slice(0, dot2), ext: rest.slice(dot2) };
+  }
+  const dot = name.lastIndexOf(".");
+  if (dot <= 0) return { base: name, ext: "" };
+  return { base: name.slice(0, dot), ext: name.slice(dot) };
+}
+chunkPK6SKIKE_cjs.__name(splitFileName, "splitFileName");
+function autoSelectRange(name, isFolder) {
+  if (isFolder) return [0, name.length];
+  const { base } = splitFileName(name);
+  return [0, base.length];
+}
+chunkPK6SKIKE_cjs.__name(autoSelectRange, "autoSelectRange");
+function TreeRenameInput({
+  initialValue,
+  isFolder,
+  onCommit,
+  onCancel,
+  className
+}) {
+  const [value, setValue] = React.useState(initialValue);
+  const inputRef = React.useRef(null);
+  const settledRef = React.useRef(false);
+  React.useEffect(() => {
+    const el = inputRef.current;
+    if (!el) return;
+    el.focus();
+    const [start, end] = autoSelectRange(initialValue, isFolder);
+    requestAnimationFrame(() => {
+      try {
+        el.setSelectionRange(start, end);
+      } catch {
+      }
+    });
+  }, []);
+  const commit = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
+    if (settledRef.current) return;
+    settledRef.current = true;
+    void onCommit(value);
+  }, "commit");
+  const cancel = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
+    if (settledRef.current) return;
+    settledRef.current = true;
+    onCancel();
+  }, "cancel");
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "input",
+    {
+      ref: inputRef,
+      type: "text",
+      value,
+      onKeyDown: (e) => {
+        e.stopPropagation();
+        if (e.key === "Enter") {
+          e.preventDefault();
+          commit();
+        } else if (e.key === "Escape") {
+          e.preventDefault();
+          cancel();
+        }
+      },
+      onChange: (e) => setValue(e.target.value),
+      onBlur: commit,
+      onClick: (e) => e.stopPropagation(),
+      onDoubleClick: (e) => e.stopPropagation(),
+      onMouseDown: (e) => e.stopPropagation(),
+      onContextMenu: (e) => e.stopPropagation(),
+      className: lib.cn(
+        "min-w-0 flex-1 rounded-sm border border-primary/50 bg-background",
+        "px-1 py-0 text-foreground outline-none",
+        "focus:ring-1 focus:ring-primary/40",
+        className
+      ),
+      style: {
+        // Match the row's font metrics so the input doesn't visibly jolt.
+        fontSize: "var(--tree-font-size)",
+        height: "calc(var(--tree-row-height) - 4px)"
+      }
+    }
+  );
+}
+chunkPK6SKIKE_cjs.__name(TreeRenameInput, "TreeRenameInput");
 function TreeRowRaw({ row, className }) {
   const ctx = useTreeContext();
   const {
@@ -673,6 +1833,7 @@ function TreeRowRaw({ row, className }) {
     matchingIds,
     select,
     setSelectedIds,
+    clickSelect,
     toggle,
     setFocus,
     activate,
@@ -680,13 +1841,19 @@ function TreeRowRaw({ row, className }) {
     renderIcon,
     renderLabel,
     renderActions,
-    renderContextMenu
+    renderContextMenu,
+    renamingId,
+    commitRename,
+    cancelRename,
+    clipboard,
+    dnd
   } = ctx;
   const { node, level, isFolder, isExpanded, isLoading, posInSet, setSize } = row;
   const isSelected = selected.has(node.id);
   const isFocused = focused === node.id;
   const isMatchingSearch = matchingIds.has(node.id);
   const isMultiSelect = ctx.selectionMode === "multiple";
+  const isCut = clipboard?.kind === "cut" && clipboard.ids.includes(node.id);
   const slot = {
     node,
     level,
@@ -697,30 +1864,57 @@ function TreeRowRaw({ row, className }) {
     isLoading,
     isMatchingSearch
   };
+  const isRenaming = renamingId === node.id;
+  const isDragging = dnd.draggingIds.has(node.id);
+  const dropTarget = dnd.dropTarget;
+  const isDropTarget = dropTarget?.id === node.id;
+  const dropPosition = isDropTarget ? dropTarget.position : null;
+  const dndDisabled = !dnd.active || isRenaming || node.disabled;
+  const draggable = core.useDraggable({ id: node.id, disabled: dndDisabled });
+  const droppable = core.useDroppable({ id: node.id, disabled: dndDisabled });
+  const setRowEl = React.useCallback(
+    (el) => {
+      draggable.setNodeRef(el);
+      droppable.setNodeRef(el);
+    },
+    [draggable, droppable]
+  );
+  const isAllowedDrop = dropPosition && !isDragging ? dnd.isAllowedDrop(node, dropPosition) : true;
   const handleClick = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((e) => {
-    if (node.disabled) return;
+    if (node.disabled || isRenaming) return;
     setFocus(node.id);
-    if (isMultiSelect && !(e.metaKey || e.ctrlKey)) {
-      setSelectedIds([node.id]);
+    if (isMultiSelect) {
+      clickSelect(node.id, { shift: e.shiftKey, meta: e.metaKey || e.ctrlKey });
     } else {
       select(node.id);
     }
     if (isFolder) {
+      if (e.shiftKey || e.metaKey || e.ctrlKey) return;
       toggle(node.id);
     } else if (activationMode === "single-click") {
+      if (e.shiftKey || e.metaKey || e.ctrlKey) return;
       activate(node, { preview: false });
     } else if (activationMode === "single-click-preview") {
+      if (e.shiftKey || e.metaKey || e.ctrlKey) return;
       activate(node, { preview: true });
     }
   }, "handleClick");
   const handleDoubleClick = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
-    if (node.disabled) return;
+    if (node.disabled || isRenaming) return;
     if (isFolder) return;
     activate(node, { preview: false });
   }, "handleDoubleClick");
+  const handleContextMenu = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
+    if (node.disabled || isRenaming) return;
+    setFocus(node.id);
+    if (!isSelected) {
+      setSelectedIds([node.id]);
+    }
+  }, "handleContextMenu");
   const trigger = /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
+      ref: dnd.active ? setRowEl : void 0,
       id: treeRowDomId(node.id),
       role: "treeitem",
       "aria-level": level + 1,
@@ -733,6 +1927,8 @@ function TreeRowRaw({ row, className }) {
       "data-id": node.id,
       "data-activation-mode": activationMode,
       "data-selected": isSelected ? "true" : void 0,
+      "data-clipboard": isCut ? "cut" : void 0,
+      "data-dragging": isDragging ? "true" : void 0,
       "data-focused": isFocused && !isSelected ? "true" : void 0,
       "data-folder": isFolder || void 0,
       "data-expanded": isExpanded || void 0,
@@ -742,8 +1938,11 @@ function TreeRowRaw({ row, className }) {
         height: "var(--tree-row-height)",
         gap: "var(--tree-gap)"
       },
+      ...dnd.active ? draggable.listeners : {},
+      ...dnd.active ? draggable.attributes : {},
       onClick: handleClick,
       onDoubleClick: handleDoubleClick,
+      onContextMenu: handleContextMenu,
       onFocus: () => setFocus(node.id),
       className: lib.cn(
         "group/row relative flex w-full select-none items-center pr-2 text-left",
@@ -753,6 +1952,8 @@ function TreeRowRaw({ row, className }) {
         rowStateClasses(appearance),
         "focus-visible:ring-1 focus-visible:ring-ring/50",
         isMatchingSearch && "ring-1 ring-primary/30",
+        isCut && "opacity-60",
+        isDragging && "opacity-40",
         node.disabled && "opacity-50",
         className
       ),
@@ -767,6 +1968,14 @@ function TreeRowRaw({ row, className }) {
             )
           }
         ) : null,
+        dropPosition && !isDragging ? /* @__PURE__ */ jsxRuntime.jsx(
+          TreeDropIndicator,
+          {
+            position: dropPosition,
+            indent: 6 + level * appearance.indent,
+            invalid: !isAllowedDrop
+          }
+        ) : null,
         showIndentGuides && level > 0 ? /* @__PURE__ */ jsxRuntime.jsx(TreeIndentGuides, { level, indent: appearance.indent }) : null,
         /* @__PURE__ */ jsxRuntime.jsx(TreeChevron, { isExpanded, isFolder }),
         isLoading ? /* @__PURE__ */ jsxRuntime.jsx(
@@ -783,7 +1992,15 @@ function TreeRowRaw({ row, className }) {
           {
             className: "flex min-w-0 flex-1 items-center",
             style: { gap: "var(--tree-gap)" },
-            children: renderLabel ? renderLabel(slot) : /* @__PURE__ */ jsxRuntime.jsx(TreeLabel, { isMatchingSearch, children: getItemName(node) })
+            children: renamingId === node.id ? /* @__PURE__ */ jsxRuntime.jsx(
+              TreeRenameInput,
+              {
+                initialValue: getItemName(node),
+                isFolder,
+                onCommit: (next) => commitRename(node.id, next),
+                onCancel: cancelRename
+              }
+            ) : renderLabel ? renderLabel(slot) : /* @__PURE__ */ jsxRuntime.jsx(TreeLabel, { isMatchingSearch, children: getItemName(node) })
           }
         ),
         renderActions ? /* @__PURE__ */ jsxRuntime.jsx(
@@ -855,6 +2072,105 @@ function TreeContent({
   );
 }
 chunkPK6SKIKE_cjs.__name(TreeContent, "TreeContent");
+function TreeEmptyArea({ className }) {
+  const ctx = useTreeContext();
+  const {
+    adapter,
+    labels,
+    getItemName,
+    clipboard,
+    cutToClipboard,
+    copyToClipboard,
+    pasteFromClipboard,
+    startRename,
+    inlineRenameEnabled,
+    dnd
+  } = ctx;
+  const { setNodeRef: setDroppableRef, isOver } = core.useDroppable({
+    id: TREE_ROOT_DROP_ID,
+    disabled: !dnd.active
+  });
+  const items = React.useMemo(() => {
+    if (!adapter) return null;
+    const builtinCtx = {
+      adapter,
+      labels,
+      selectedNodes: [],
+      targetNode: null,
+      getName: getItemName,
+      startInlineRename: inlineRenameEnabled ? startRename : void 0,
+      clipboard: {
+        hasItems: !!clipboard && clipboard.ids.length > 0,
+        cut: cutToClipboard,
+        copy: copyToClipboard,
+        paste: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => pasteFromClipboard(null, "inside"), "paste")
+      }
+    };
+    return buildDefaultMenuItems(builtinCtx);
+  }, [
+    adapter,
+    labels,
+    getItemName,
+    inlineRenameEnabled,
+    startRename,
+    clipboard,
+    cutToClipboard,
+    copyToClipboard,
+    pasteFromClipboard
+  ]);
+  const surface = /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      ref: dnd.active ? setDroppableRef : void 0,
+      "data-tree-empty-area": "",
+      "data-drop-active": dnd.active && isOver ? "true" : void 0,
+      className: lib.cn(
+        // Soaks up the remaining vertical space inside the scroll
+        // container so right-click on whitespace lands here, not on
+        // the scroll viewport.
+        "min-h-[2.5rem] flex-1",
+        dnd.active && isOver && "bg-primary/5 rounded-sm ring-1 ring-primary/30",
+        className
+      )
+    }
+  );
+  if (!items || items.length === 0) {
+    return surface;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(components.ContextMenu, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuTrigger, { asChild: true, children: surface }),
+    /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuContent, { children: items.map((item, idx) => {
+      if (item === "separator") {
+        return /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuSeparator, {}, `sep-${idx}`);
+      }
+      const Icon = item.icon;
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        components.ContextMenuItem,
+        {
+          disabled: item.disabled,
+          variant: item.destructive ? "destructive" : void 0,
+          onSelect: () => item.onSelect({
+            node: void 0,
+            level: 0,
+            isSelected: false,
+            isExpanded: false,
+            isFocused: false,
+            isFolder: false,
+            isLoading: false,
+            isMatchingSearch: false
+          }),
+          children: [
+            Icon ? /* @__PURE__ */ jsxRuntime.jsx(Icon, {}) : null,
+            item.label,
+            item.shortcut ? /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuShortcut, { children: item.shortcut }) : null
+          ]
+        },
+        item.id
+      );
+    }) })
+  ] });
+}
+chunkPK6SKIKE_cjs.__name(TreeEmptyArea, "TreeEmptyArea");
 function useTreeLabels() {
   return useTreeContext().labels;
 }
@@ -873,12 +2189,26 @@ function useTreeSelection() {
   return React.useMemo(
     () => ({
       selectedIds,
+      anchor: ctx.anchor,
       select: ctx.select,
       setSelectedIds: ctx.setSelectedIds,
       clear: ctx.clearSelection,
+      clickSelect: ctx.clickSelect,
+      moveSelect: ctx.moveSelect,
+      selectAll: ctx.selectAll,
       isSelected
     }),
-    [selectedIds, ctx.select, ctx.setSelectedIds, ctx.clearSelection, isSelected]
+    [
+      selectedIds,
+      ctx.anchor,
+      ctx.select,
+      ctx.setSelectedIds,
+      ctx.clearSelection,
+      ctx.clickSelect,
+      ctx.moveSelect,
+      ctx.selectAll,
+      isSelected
+    ]
   );
 }
 chunkPK6SKIKE_cjs.__name(useTreeSelection, "useTreeSelection");
@@ -933,6 +2263,59 @@ function useTreeSearch() {
   );
 }
 chunkPK6SKIKE_cjs.__name(useTreeSearch, "useTreeSearch");
+function useTreeDnd() {
+  const ctx = useTreeContext();
+  return ctx.dnd;
+}
+chunkPK6SKIKE_cjs.__name(useTreeDnd, "useTreeDnd");
+function useTreeClipboard() {
+  const ctx = useTreeContext();
+  const isCut = React.useCallback(
+    (id) => ctx.clipboard?.kind === "cut" && ctx.clipboard.ids.includes(id),
+    [ctx.clipboard]
+  );
+  return React.useMemo(
+    () => ({
+      clipboard: ctx.clipboard,
+      isCut,
+      cut: ctx.cutToClipboard,
+      copy: ctx.copyToClipboard,
+      paste: ctx.pasteFromClipboard,
+      clear: ctx.clearClipboard
+    }),
+    [
+      ctx.clipboard,
+      isCut,
+      ctx.cutToClipboard,
+      ctx.copyToClipboard,
+      ctx.pasteFromClipboard,
+      ctx.clearClipboard
+    ]
+  );
+}
+chunkPK6SKIKE_cjs.__name(useTreeClipboard, "useTreeClipboard");
+function useTreeRename() {
+  const ctx = useTreeContext();
+  return React.useMemo(
+    () => ({
+      /** True when the host allowed inline rename AND the adapter exposes `rename`. */
+      enabled: ctx.inlineRenameEnabled,
+      /** Currently renaming id, or `null`. */
+      renamingId: ctx.renamingId,
+      startRename: ctx.startRename,
+      cancelRename: ctx.cancelRename,
+      commitRename: ctx.commitRename
+    }),
+    [
+      ctx.inlineRenameEnabled,
+      ctx.renamingId,
+      ctx.startRename,
+      ctx.cancelRename,
+      ctx.commitRename
+    ]
+  );
+}
+chunkPK6SKIKE_cjs.__name(useTreeRename, "useTreeRename");
 function useTreeActions() {
   const ctx = useTreeContext();
   return React.useMemo(
@@ -997,16 +2380,78 @@ function TreeSearchInput({ className, showMatches = true }) {
   );
 }
 chunkPK6SKIKE_cjs.__name(TreeSearchInput, "TreeSearchInput");
+
+// src/tools/data/Tree/hooks/keyboard/arrow-nav.ts
+function nextRowId(rows, idx) {
+  if (rows.length === 0) return null;
+  const next = rows[Math.min(idx + 1, rows.length - 1)] ?? rows[0];
+  return next.node.id;
+}
+chunkPK6SKIKE_cjs.__name(nextRowId, "nextRowId");
+function prevRowId(rows, idx) {
+  if (rows.length === 0) return null;
+  const prev = rows[Math.max(idx - 1, 0)] ?? rows[0];
+  return prev.node.id;
+}
+chunkPK6SKIKE_cjs.__name(prevRowId, "prevRowId");
+function edgeRowId(rows, edge) {
+  if (rows.length === 0) return null;
+  return edge === "first" ? rows[0].node.id : rows[rows.length - 1].node.id;
+}
+chunkPK6SKIKE_cjs.__name(edgeRowId, "edgeRowId");
+
+// src/tools/data/Tree/hooks/keyboard/expand-collapse.ts
+function resolveRightArrow(current, rows, idx) {
+  if (!current) return { kind: "noop" };
+  if (current.isFolder && !current.isExpanded) {
+    return { kind: "expand", id: current.node.id };
+  }
+  if (current.isFolder && current.isExpanded) {
+    const next = rows[idx + 1];
+    return next ? { kind: "focus", id: next.node.id } : { kind: "noop" };
+  }
+  return { kind: "noop" };
+}
+chunkPK6SKIKE_cjs.__name(resolveRightArrow, "resolveRightArrow");
+function resolveLeftArrow(current) {
+  if (!current) return { kind: "noop" };
+  if (current.isFolder && current.isExpanded) {
+    return { kind: "collapse", id: current.node.id };
+  }
+  if (current.parentId) {
+    return { kind: "focus", id: current.parentId };
+  }
+  return { kind: "noop" };
+}
+chunkPK6SKIKE_cjs.__name(resolveLeftArrow, "resolveLeftArrow");
+
+// src/tools/data/Tree/hooks/keyboard/activation.ts
+function resolveActivate(current) {
+  if (!current) return { kind: "noop" };
+  if (current.isFolder) {
+    return {
+      kind: "toggle-folder",
+      id: current.node.id,
+      willExpand: !current.isExpanded
+    };
+  }
+  return { kind: "activate-leaf", id: current.node.id };
+}
+chunkPK6SKIKE_cjs.__name(resolveActivate, "resolveActivate");
+
+// src/tools/data/Tree/hooks/keyboard/use-tree-keyboard.ts
 function useTreeKeyboard({
   rows,
   focusedId,
   enabled = true,
+  multiSelect = false,
   onFocus,
   onSelect,
   onActivate,
   onExpand,
   onCollapse,
-  onClearSelection
+  onClearSelection,
+  onSelectAll
 }) {
   const rowsRef = React.useRef(rows);
   const focusedIdRef = React.useRef(focusedId);
@@ -1019,53 +2464,65 @@ function useTreeKeyboard({
     return { rows: r, idx, current: idx >= 0 ? r[idx] : null };
   }, "getCurrent");
   const refDown = hooks.useHotkey(
-    "down",
-    () => {
+    ["down", "shift+down"],
+    (e) => {
       const { rows: r, idx } = getCurrent();
-      if (r.length === 0) return;
-      const next = r[Math.min(idx + 1, r.length - 1)] ?? r[0];
-      onFocus(next.node.id);
+      const id = nextRowId(r, idx);
+      if (id) onFocus(id, { extend: multiSelect && e.shiftKey });
     },
-    { enabled, preventDefault: true, description: "Next row" }
+    { enabled, preventDefault: true, description: "Next row (Shift extends)" }
   );
   const refUp = hooks.useHotkey(
-    "up",
-    () => {
+    ["up", "shift+up"],
+    (e) => {
       const { rows: r, idx } = getCurrent();
-      if (r.length === 0) return;
-      const prev = r[Math.max(idx - 1, 0)] ?? r[0];
-      onFocus(prev.node.id);
+      const id = prevRowId(r, idx);
+      if (id) onFocus(id, { extend: multiSelect && e.shiftKey });
     },
-    { enabled, preventDefault: true, description: "Previous row" }
+    { enabled, preventDefault: true, description: "Previous row (Shift extends)" }
   );
   const refHome = hooks.useHotkey(
-    "home",
-    () => {
-      const { rows: r } = getCurrent();
-      if (r.length === 0) return;
-      onFocus(r[0].node.id);
+    ["home", "shift+home"],
+    (e) => {
+      const id = edgeRowId(rowsRef.current, "first");
+      if (id) onFocus(id, { extend: multiSelect && e.shiftKey });
     },
-    { enabled, preventDefault: true, description: "First row" }
+    { enabled, preventDefault: true, description: "First row (Shift extends)" }
   );
   const refEnd = hooks.useHotkey(
-    "end",
+    ["end", "shift+end"],
+    (e) => {
+      const id = edgeRowId(rowsRef.current, "last");
+      if (id) onFocus(id, { extend: multiSelect && e.shiftKey });
+    },
+    { enabled, preventDefault: true, description: "Last row (Shift extends)" }
+  );
+  const refSelectAll = hooks.useHotkey(
+    "mod+a",
     () => {
-      const { rows: r } = getCurrent();
-      if (r.length === 0) return;
-      onFocus(r[r.length - 1].node.id);
+      if (!multiSelect) return;
+      onSelectAll?.();
     },
-    { enabled, preventDefault: true, description: "Last row" }
+    {
+      enabled: enabled && multiSelect,
+      preventDefault: true,
+      description: "Select all visible rows"
+    }
   );
   const refRight = hooks.useHotkey(
     "right",
     () => {
       const { rows: r, idx, current } = getCurrent();
-      if (!current) return;
-      if (current.isFolder && !current.isExpanded) {
-        onExpand(current.node.id);
-      } else if (current.isFolder && current.isExpanded) {
-        const next = r[idx + 1];
-        if (next) onFocus(next.node.id);
+      const out = resolveRightArrow(current, r, idx);
+      switch (out.kind) {
+        case "expand":
+          onExpand(out.id);
+          return;
+        case "focus":
+          onFocus(out.id, { extend: false });
+          return;
+        case "noop":
+          return;
       }
     },
     { enabled, preventDefault: true, description: "Expand / first child" }
@@ -1074,11 +2531,16 @@ function useTreeKeyboard({
     "left",
     () => {
       const { current } = getCurrent();
-      if (!current) return;
-      if (current.isFolder && current.isExpanded) {
-        onCollapse(current.node.id);
-      } else if (current.parentId) {
-        onFocus(current.parentId);
+      const out = resolveLeftArrow(current);
+      switch (out.kind) {
+        case "collapse":
+          onCollapse(out.id);
+          return;
+        case "focus":
+          onFocus(out.id, { extend: false });
+          return;
+        case "noop":
+          return;
       }
     },
     { enabled, preventDefault: true, description: "Collapse / parent" }
@@ -1087,13 +2549,14 @@ function useTreeKeyboard({
     ["enter", "space"],
     () => {
       const { current } = getCurrent();
-      if (!current) return;
-      onSelect(current.node.id);
-      if (current.isFolder) {
-        if (current.isExpanded) onCollapse(current.node.id);
-        else onExpand(current.node.id);
+      const out = resolveActivate(current);
+      if (out.kind === "noop") return;
+      onSelect(out.kind === "activate-leaf" ? out.id : out.id);
+      if (out.kind === "toggle-folder") {
+        if (out.willExpand) onExpand(out.id);
+        else onCollapse(out.id);
       } else {
-        onActivate(current.node.id);
+        onActivate(out.id);
       }
     },
     { enabled, preventDefault: true, description: "Activate / toggle" }
@@ -1113,12 +2576,44 @@ function useTreeKeyboard({
       refLeft(instance);
       refActivate(instance);
       refEscape(instance);
+      refSelectAll(instance);
     },
-    [refDown, refUp, refHome, refEnd, refRight, refLeft, refActivate, refEscape]
+    [
+      refDown,
+      refUp,
+      refHome,
+      refEnd,
+      refRight,
+      refLeft,
+      refActivate,
+      refEscape,
+      refSelectAll
+    ]
   );
   return { ref };
 }
 chunkPK6SKIKE_cjs.__name(useTreeKeyboard, "useTreeKeyboard");
+
+// src/tools/data/Tree/hooks/type-ahead/match-prefix.ts
+function findRowByPrefix(rows, getName, prefix) {
+  if (prefix.length === 0) return void 0;
+  return rows.find((row) => getName(row.node).toLowerCase().startsWith(prefix));
+}
+chunkPK6SKIKE_cjs.__name(findRowByPrefix, "findRowByPrefix");
+function isResetKey(key) {
+  return key === "Escape" || key === "Enter" || key === "Tab" || key.startsWith("Arrow") || key === "Home" || key === "End" || key === "PageUp" || key === "PageDown";
+}
+chunkPK6SKIKE_cjs.__name(isResetKey, "isResetKey");
+function isTypingTarget(target) {
+  const el = target;
+  if (!el) return false;
+  const tag = el.tagName;
+  if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
+  return el.isContentEditable === true;
+}
+chunkPK6SKIKE_cjs.__name(isTypingTarget, "isTypingTarget");
+
+// src/tools/data/Tree/hooks/type-ahead/use-tree-type-ahead.ts
 var FLUSH_MS = 600;
 function useTreeTypeAhead({
   rows,
@@ -1147,11 +2642,9 @@ function useTreeTypeAhead({
       }
     }, "reset");
     const handler = /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((e) => {
-      const tag = e.target?.tagName;
-      if (tag === "INPUT" || tag === "TEXTAREA") return;
-      if (e.target?.isContentEditable) return;
+      if (isTypingTarget(e.target)) return;
       if (e.metaKey || e.ctrlKey || e.altKey) return;
-      if (e.key === "Escape" || e.key === "Enter" || e.key === "Tab" || e.key.startsWith("Arrow") || e.key === "Home" || e.key === "End" || e.key === "PageUp" || e.key === "PageDown") {
+      if (isResetKey(e.key)) {
         reset();
         return;
       }
@@ -1159,9 +2652,10 @@ function useTreeTypeAhead({
       bufferRef.current += e.key.toLowerCase();
       if (timerRef.current) clearTimeout(timerRef.current);
       timerRef.current = setTimeout(reset, FLUSH_MS);
-      const prefix = bufferRef.current;
-      const hit = rowsRef.current.find(
-        (row) => getNameRef.current(row.node).toLowerCase().startsWith(prefix)
+      const hit = findRowByPrefix(
+        rowsRef.current,
+        getNameRef.current,
+        bufferRef.current
       );
       if (hit) {
         e.preventDefault();
@@ -1176,36 +2670,166 @@ function useTreeTypeAhead({
   }, [containerRef, enabled]);
 }
 chunkPK6SKIKE_cjs.__name(useTreeTypeAhead, "useTreeTypeAhead");
-function actionsToRenderContextMenu(resolve) {
-  return (rowProps, trigger) => {
-    const items = resolve(rowProps);
-    if (!items || items.length === 0) return trigger;
-    return /* @__PURE__ */ jsxRuntime.jsxs(components.ContextMenu, { children: [
-      /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuTrigger, { asChild: true, children: trigger }),
-      /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuContent, { children: items.map((item, idx) => {
-        if (item === "separator") {
-          return /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuSeparator, {}, `sep-${idx}`);
-        }
-        const Icon = item.icon;
-        return /* @__PURE__ */ jsxRuntime.jsxs(
-          components.ContextMenuItem,
-          {
-            disabled: item.disabled,
-            variant: item.destructive ? "destructive" : void 0,
-            onSelect: () => item.onSelect(rowProps),
-            children: [
-              Icon ? /* @__PURE__ */ jsxRuntime.jsx(Icon, {}) : null,
-              item.label,
-              item.shortcut ? /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuShortcut, { children: item.shortcut }) : null
-            ]
-          },
-          item.id
-        );
-      }) })
-    ] });
+
+// src/tools/data/Tree/hooks/finder-hotkeys/build-ctx.ts
+function buildBuiltinCtx(input) {
+  if (!input.adapter) return null;
+  const selectedNodes = [];
+  for (const id of input.selected) {
+    const n = input.getNodeById(id);
+    if (n) selectedNodes.push(n);
+  }
+  const targetNode = input.focused ? input.getNodeById(input.focused) ?? null : null;
+  return {
+    adapter: input.adapter,
+    labels: input.labels,
+    selectedNodes,
+    targetNode,
+    getName: input.getItemName,
+    startInlineRename: input.startInlineRename,
+    clipboard: input.clipboard
   };
 }
-chunkPK6SKIKE_cjs.__name(actionsToRenderContextMenu, "actionsToRenderContextMenu");
+chunkPK6SKIKE_cjs.__name(buildBuiltinCtx, "buildBuiltinCtx");
+
+// src/tools/data/Tree/hooks/finder-hotkeys/use-tree-finder-hotkeys.ts
+function useTreeFinderHotkeys(opts) {
+  const optsRef = React.useRef(opts);
+  optsRef.current = opts;
+  const run = React.useCallback(async (action) => {
+    const o = optsRef.current;
+    if (o.paused) return;
+    const ctx = buildBuiltinCtx({
+      adapter: o.adapter,
+      labels: o.labels,
+      selected: o.selected,
+      focused: o.focused,
+      getNodeById: o.getNodeById,
+      getItemName: o.getItemName,
+      startInlineRename: o.startInlineRename,
+      clipboard: o.clipboard
+    });
+    if (!ctx) return;
+    await runBuiltinAction(action, ctx);
+  }, []);
+  const refDelete = hooks.useHotkey(
+    ["mod+backspace", "delete"],
+    () => void run("delete"),
+    {
+      enabled: opts.enabled,
+      preventDefault: true,
+      description: "Delete selected items",
+      scope: "tree"
+    }
+  );
+  const refRename = hooks.useHotkey("f2", () => void run("rename"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "Rename selected item",
+    scope: "tree"
+  });
+  const refDuplicate = hooks.useHotkey("mod+d", () => void run("duplicate"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "Duplicate selected items",
+    scope: "tree"
+  });
+  const refNewFolder = hooks.useHotkey("mod+shift+n", () => void run("new-folder"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "New folder",
+    scope: "tree"
+  });
+  const refNewFile = hooks.useHotkey("mod+n", () => void run("new-file"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "New file",
+    scope: "tree"
+  });
+  const refCut = hooks.useHotkey("mod+x", () => void run("cut"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "Cut",
+    scope: "tree"
+  });
+  const refCopy = hooks.useHotkey("mod+c", () => void run("copy"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "Copy",
+    scope: "tree"
+  });
+  const refPaste = hooks.useHotkey("mod+v", () => void run("paste"), {
+    enabled: opts.enabled,
+    preventDefault: true,
+    description: "Paste",
+    scope: "tree"
+  });
+  const ref = React.useCallback(
+    (instance) => {
+      refDelete(instance);
+      refRename(instance);
+      refDuplicate(instance);
+      refNewFolder(instance);
+      refNewFile(instance);
+      refCut(instance);
+      refCopy(instance);
+      refPaste(instance);
+    },
+    [
+      refDelete,
+      refRename,
+      refDuplicate,
+      refNewFolder,
+      refNewFile,
+      refCut,
+      refCopy,
+      refPaste
+    ]
+  );
+  return { ref };
+}
+chunkPK6SKIKE_cjs.__name(useTreeFinderHotkeys, "useTreeFinderHotkeys");
+function renderItemsAsContextMenu(rowProps, items, trigger) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(components.ContextMenu, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuTrigger, { asChild: true, children: trigger }),
+    /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuContent, { children: items.map((item, idx) => {
+      if (item === "separator") {
+        return /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuSeparator, {}, `sep-${idx}`);
+      }
+      const Icon = item.icon;
+      return /* @__PURE__ */ jsxRuntime.jsxs(
+        components.ContextMenuItem,
+        {
+          disabled: item.disabled,
+          variant: item.destructive ? "destructive" : void 0,
+          onSelect: () => item.onSelect(rowProps),
+          children: [
+            Icon ? /* @__PURE__ */ jsxRuntime.jsx(Icon, {}) : null,
+            item.label,
+            item.shortcut ? /* @__PURE__ */ jsxRuntime.jsx(components.ContextMenuShortcut, { children: item.shortcut }) : null
+          ]
+        },
+        item.id
+      );
+    }) })
+  ] });
+}
+chunkPK6SKIKE_cjs.__name(renderItemsAsContextMenu, "renderItemsAsContextMenu");
+function tidyMenuItems(items) {
+  const out = [];
+  for (const it of items) {
+    if (it === "separator") {
+      if (out.length === 0) continue;
+      if (out[out.length - 1] === "separator") continue;
+      out.push(it);
+    } else {
+      out.push(it);
+    }
+  }
+  while (out.length > 0 && out[out.length - 1] === "separator") out.pop();
+  return out;
+}
+chunkPK6SKIKE_cjs.__name(tidyMenuItems, "tidyMenuItems");
 function TreeRoot(props) {
   const {
     data,
@@ -1224,6 +2848,10 @@ function TreeRoot(props) {
     enableSearch = false,
     enableTypeAhead = true,
     showIndentGuides = false,
+    enableInlineRename = false,
+    enableFinderHotkeys = false,
+    enableDnD = false,
+    canDrop,
     renderRow,
     renderIcon,
     renderLabel,
@@ -1233,14 +2861,11 @@ function TreeRoot(props) {
     labels,
     persistKey,
     persistSelection = false,
+    adapter,
+    defaultMenuItems,
     className,
     style
   } = props;
-  const resolvedRenderContextMenu = React.useMemo(() => {
-    if (renderContextMenu) return renderContextMenu;
-    if (contextMenuActions) return actionsToRenderContextMenu(contextMenuActions);
-    return void 0;
-  }, [renderContextMenu, contextMenuActions]);
   return /* @__PURE__ */ jsxRuntime.jsx(
     TreeProvider,
     {
@@ -1262,7 +2887,13 @@ function TreeRoot(props) {
       renderIcon,
       renderLabel,
       renderActions,
-      renderContextMenu: resolvedRenderContextMenu,
+      renderContextMenu,
+      contextMenuActions,
+      adapter,
+      defaultMenuItems,
+      enableInlineRename,
+      enableDnD,
+      canDrop,
       labels,
       persistKey,
       persistSelection,
@@ -1273,6 +2904,7 @@ function TreeRoot(props) {
           style,
           enableSearch,
           enableTypeAhead,
+          enableFinderHotkeys,
           renderRow
         }
       )
@@ -1285,14 +2917,27 @@ function TreeRootShell({
   style,
   enableSearch,
   enableTypeAhead,
+  enableFinderHotkeys,
   renderRow
 }) {
   const containerRef = React.useRef(null);
   const ctx = useTreeContext();
+  const isMulti = ctx.selectionMode === "multiple";
   const { ref: keyboardRef } = useTreeKeyboard({
     rows: ctx.flatRows,
     focusedId: ctx.focused,
-    onFocus: ctx.setFocus,
+    multiSelect: isMulti,
+    // Pause container hotkeys while inline rename is active so the
+    // user can type freely (TreeRenameInput stops bubbling already, but
+    // gating here is the cleaner second line of defence).
+    enabled: ctx.renamingId === null,
+    onFocus: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((id, { extend }) => {
+      if (extend && isMulti) {
+        ctx.moveSelect(id, { extend: true });
+      } else {
+        ctx.setFocus(id);
+      }
+    }, "onFocus"),
     onSelect: ctx.select,
     onActivate: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name((id) => {
       const row = ctx.flatRows.find((r) => r.node.id === id);
@@ -1300,14 +2945,37 @@ function TreeRootShell({
     }, "onActivate"),
     onExpand: ctx.expand,
     onCollapse: ctx.collapse,
-    onClearSelection: ctx.clearSelection
+    onClearSelection: ctx.clearSelection,
+    onSelectAll: ctx.selectAll
+  });
+  const { ref: finderHotkeysRef } = useTreeFinderHotkeys({
+    enabled: enableFinderHotkeys,
+    paused: ctx.renamingId !== null,
+    adapter: ctx.adapter,
+    labels: ctx.labels,
+    selected: ctx.selected,
+    focused: ctx.focused,
+    getNodeById: ctx.getNodeById,
+    getItemName: ctx.getItemName,
+    startInlineRename: ctx.inlineRenameEnabled ? ctx.startRename : void 0,
+    clipboard: {
+      hasItems: !!ctx.clipboard && ctx.clipboard.ids.length > 0,
+      cut: ctx.cutToClipboard,
+      copy: ctx.copyToClipboard,
+      // Hotkey paste targets the currently focused row (or null = root).
+      paste: /* @__PURE__ */ chunkPK6SKIKE_cjs.__name(() => {
+        const target = ctx.focused ? ctx.getNodeById(ctx.focused) ?? null : null;
+        return ctx.pasteFromClipboard(target, "inside");
+      }, "paste")
+    }
   });
   const setContainerRef = React.useCallback(
     (instance) => {
       containerRef.current = instance;
       keyboardRef(instance);
+      finderHotkeysRef(instance);
     },
-    [keyboardRef]
+    [keyboardRef, finderHotkeysRef]
   );
   const focusedId = ctx.focused;
   React.useEffect(() => {
@@ -1330,7 +2998,22 @@ function TreeRootShell({
     onMatch: onTypeAheadMatch,
     enabled: enableTypeAhead
   });
-  return /* @__PURE__ */ jsxRuntime.jsxs(
+  const finalRenderContextMenu = React.useMemo(() => {
+    if (ctx.renderContextMenu) return ctx.renderContextMenu;
+    const resolve = ctx.resolvedContextMenuActions;
+    if (!resolve) return void 0;
+    return (rowProps, trigger) => {
+      const items = resolve(rowProps);
+      const cleaned = items ? tidyMenuItems(items) : null;
+      if (!cleaned || cleaned.length === 0) return trigger;
+      return renderItemsAsContextMenu(rowProps, cleaned, trigger);
+    };
+  }, [ctx.renderContextMenu, ctx.resolvedContextMenuActions]);
+  const childCtx = React.useMemo(
+    () => ({ ...ctx, renderContextMenu: finalRenderContextMenu }),
+    [ctx, finalRenderContextMenu]
+  );
+  const treeBody = /* @__PURE__ */ jsxRuntime.jsxs(
     "div",
     {
       ref: setContainerRef,
@@ -1348,13 +3031,35 @@ function TreeRootShell({
       "data-tree-root": "",
       children: [
         enableSearch ? /* @__PURE__ */ jsxRuntime.jsx(TreeSearchInput, { className: "mx-2 mt-2" }) : null,
-        /* @__PURE__ */ jsxRuntime.jsx("div", { className: "min-h-0 flex-1 overflow-auto px-1", children: /* @__PURE__ */ jsxRuntime.jsx(TreeContent, { role: "group", children: renderRow }) })
+        /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex min-h-0 flex-1 flex-col overflow-auto px-1", children: [
+          /* @__PURE__ */ jsxRuntime.jsx(TreeContent, { role: "group", children: renderRow }),
+          /* @__PURE__ */ jsxRuntime.jsx(TreeEmptyArea, {})
+        ] })
       ]
     }
   );
+  const body = finalRenderContextMenu === ctx.renderContextMenu ? treeBody : /* @__PURE__ */ jsxRuntime.jsx(TreeContext.Provider, { value: childCtx, children: treeBody });
+  return /* @__PURE__ */ jsxRuntime.jsx(TreeDndProvider, { children: body });
 }
 chunkPK6SKIKE_cjs.__name(TreeRootShell, "TreeRootShell");
 var TreeRoot_default = TreeRoot;
+function FinderTree(props) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    TreeRoot,
+    {
+      selectionMode: "multiple",
+      activationMode: "double-click",
+      enableInlineRename: true,
+      enableFinderHotkeys: true,
+      enableDnD: true,
+      enableTypeAhead: true,
+      showIndentGuides: true,
+      appearance: { density: "cozy" },
+      ...props
+    }
+  );
+}
+chunkPK6SKIKE_cjs.__name(FinderTree, "FinderTree");
 function TreeSkeleton({ rows = 6, className }) {
   return /* @__PURE__ */ jsxRuntime.jsx("div", { className: lib.cn("flex flex-col gap-1 p-2", className), "aria-hidden": true, children: Array.from({ length: rows }).map((_, i) => /* @__PURE__ */ jsxRuntime.jsxs("div", { className: "flex items-center gap-2", style: { paddingLeft: i % 3 * 16 }, children: [
     /* @__PURE__ */ jsxRuntime.jsx("span", { className: "size-4 shrink-0 animate-pulse rounded bg-muted" }),
@@ -1408,35 +3113,48 @@ chunkPK6SKIKE_cjs.__name(createDemoTree, "createDemoTree");
 
 exports.DEFAULT_TREE_APPEARANCE = DEFAULT_TREE_APPEARANCE;
 exports.DEFAULT_TREE_LABELS = DEFAULT_TREE_LABELS;
+exports.FinderTree = FinderTree;
+exports.TREE_DND_MIME = TREE_DND_MIME;
 exports.Tree = TreeRoot;
 exports.TreeChevron = TreeChevron;
 exports.TreeContent = TreeContent;
+exports.TreeDropIndicator = TreeDropIndicator;
 exports.TreeEmpty = TreeEmpty;
+exports.TreeEmptyArea = TreeEmptyArea;
 exports.TreeError = TreeError;
 exports.TreeIcon = TreeIcon;
 exports.TreeIndentGuides = TreeIndentGuides;
 exports.TreeLabel = TreeLabel;
 exports.TreeProvider = TreeProvider;
+exports.TreeRenameInput = TreeRenameInput;
 exports.TreeRoot = TreeRoot;
 exports.TreeRow = TreeRow;
 exports.TreeSearchInput = TreeSearchInput;
 exports.TreeSkeleton = TreeSkeleton;
 exports.appearanceToStyle = appearanceToStyle;
+exports.autoSelectRange = autoSelectRange;
 exports.clearTreeState = clearTreeState;
 exports.createChildCache = createChildCache;
 exports.createDemoTree = createDemoTree;
 exports.default = TreeRoot_default;
+exports.defaultCanDrop = defaultCanDrop;
 exports.flattenTree = flattenTree;
 exports.loadTreeState = loadTreeState;
 exports.resolveAppearance = resolveAppearance;
 exports.resolveChildren = resolveChildren;
+exports.resolveDropZone = resolveDropZone;
 exports.saveTreeState = saveTreeState;
+exports.splitFileName = splitFileName;
 exports.useTreeActions = useTreeActions;
+exports.useTreeClipboard = useTreeClipboard;
 exports.useTreeContext = useTreeContext;
+exports.useTreeDnd = useTreeDnd;
 exports.useTreeExpansion = useTreeExpansion;
+exports.useTreeFinderHotkeys = useTreeFinderHotkeys;
 exports.useTreeFocus = useTreeFocus;
 exports.useTreeKeyboard = useTreeKeyboard;
 exports.useTreeLabels = useTreeLabels;
+exports.useTreeRename = useTreeRename;
 exports.useTreeRows = useTreeRows;
 exports.useTreeSearch = useTreeSearch;
 exports.useTreeSelection = useTreeSelection;