dsh-plugin-core 0.20.4 → 0.20.7

package/dist/explorer/FileBrowser.js

@@ -8,104 +8,37 @@
 // 两个消费场景共用本组件（用户 2026-10-20 拍板：同一套内容，两种展现形式）：
 //  · 浏览（dock）：由 **核心 PanelDock** 承载（openFilePreview），拖宽与关闭都由它负责，
 //    本组件不再自绘拖拽条 / 侧边栏外壳；
-//  · 选择（picker）：`picker` + `onPick(path, isDir)`（path 为**工作区相对**路径），点文件即回调。
+//  · 选择（picker）：`picker` + `onPick(picked)`（`path` 是**绝对路径**，另带工作区归属），点文件即回调。
 //
 // 控件纪律：能用核心控件的一律核心（ghost 面包屑 / IconButton / Segmented / MarqueeText）；
 // 核心没有的那一项 = ▾ 选层浮层，按兄弟项目 dsh-task-dispatch-table 的 `.dsh-tdt-sv-crumbs-*`
 // 逐像素照抄（间距 / 圆角 / 最大高度 / 空态），不自创度量。
 import { createElement as h, Fragment, useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState, useSyncExternalStore, } from 'react';
-import { IconCheckOutlineRegular, IconChevronDownOutlineRegular, IconChevronRightOutlineRegular, IconCloseOutlineRegular, IconCopyOutlineRegular, IconFolderCloseRegular, IconFolderOpenOutlineRegular, IconRefreshOutlineRegular, writeClipboard, FileTypeIcon, } from '../ui/official.js';
+import { IconChevronRightOutlineRegular, writeClipboard, FileTypeIcon, } from '../ui/official.js';
 import { Button, IconButton } from '../ui/Button.js';
-import { MarqueeText } from '../ui/MarqueeText.js';
-import { Segmented } from '../ui/Segmented.js';
 import { workspaceList } from '../ui/host-data.js';
 import { t } from '../utils/i18n.js';
 import { FilePreview } from './preview/index.js';
-import { absolutizeDir, bareCode, baseNameOfPath, crumbsOfDir, createRequestGate, createRootCache, dirnameOf, errView, findAnyFileAbs, isAborted, isAbsoluteish, isFailed, joinPath, learnRoot, listingOf, listPathOf, matchesFilter, relativizeToRoot, sortEntries, workspaceAnchorForPath, } from './types.js';
+import { bareCode, baseNameOfPath, crumbsOfDir, createRequestGate, dirnameOf, errView, isAborted, isAbsoluteish, isFailed, joinPath, listingOf, matchesFilter, relativizeToDir, sortEntries, normalizePath, workspaceOfPath, } from './types.js';
 import { ensureComponentStyles } from '../ui/css.js';
+import { PANEL_CSS } from '../ui/panel-css.js';
 import { EXPLORER_CSS } from './explorer-css.js';
+import { crumbsMenuEntries } from './crumbs-menu.js';
+import { CrumbNav, PlainNav } from './crumb-nav.js';
+import { LandingBody } from './landing.js';
+import { PreviewTitleBar } from './preview-title-bar.js';
 /**
- * ▾ 下拉条目构造（**picker 与 dock 共用同一段代码**，差别只在入参——源实现用户 2026-09-29
- * 点名提炼，严禁两处各写一份）：
- *  - 当前工作区排第一（打开文件夹图标 + 加粗），**其下路径紧跟**（每层一个右箭头位缩进），
- *   再列其他工作区（关合图标 + 灰）——「打开哪个就跟在哪个下面」；点当前工作区 = 回到其根目录。
- *  - 当前工作区未知（rootName 空或不在清单）时路径段置顶、全部工作区按「其他」罗列；
- *  - workspaces 不传 = 不显示工作区段（根无箭头、其下逐层缩进）。
- *
- * 条目是**自写浮层**（核心没有「带缩进的选择层菜单」这类控件 ⇒ 按兄弟项目
- * `dsh-task-dispatch-table` 的 `.dsh-tdt-sv-crumbs-menu*` 逐条照抄间距）：
- * backdrop + 菜单本体 + `-item`（4px 8px / 最大宽 280 / 超出滚动 / 空态）。
+ * 「根」在 POSIX 上的落点 `/`。Windows 没有这一个根 —— 根层是盘符清单，由宿主 `op:'roots'` 给出
+ * （见下面 `roots` 状态），本常量只在 POSIX / 探不到盘符时用。
  */
-function crumbsMenuEntries(params) {
-    const { workspaces, rootName, rootFallbackLabel, crumbs, onPickWorkspace, onLoadDir } = params;
-    const out = [];
-    // 内联样式照抄兄弟项目（wsEntry 的 gap 6px 覆盖类的 2px：图标与文字的间距以它为准）。
-    const wsEntry = (ws, current) => h('button', {
-        key: `ws:${ws}`,
-        type: 'button',
-        role: 'menuitem',
-        className: 'dshpc-fb__menu-item',
-        style: { paddingLeft: 8, display: 'flex', alignItems: 'center', gap: '6px' },
-        title: ws,
-        // 点当前工作区 = 回到该工作区根目录（浏览深处时唯一的「回根」入口，兄弟 2026-10-10）；
-        // 点其他工作区才走 onPickWorkspace（换会话）。
-        onClick: () => {
-            if (current)
-                onLoadDir?.('');
-            else
-                onPickWorkspace?.(ws);
-        },
-    }, h('span', { className: 'dshpc-fb__menu-icon', style: { color: current ? 'var(--dshpc-fg)' : 'var(--dshpc-fg-2)' } }, h(current ? IconFolderOpenOutlineRegular : IconFolderCloseRegular, { size: 13 })), h('span', { className: 'dshpc-fb__menu-label', style: { fontWeight: current ? 600 : 400 } }, ws));
-    const pathEntry = (crumb, depth, withArrow = true) => h('button', {
-        key: `dir:${crumb.path}`,
-        type: 'button',
-        role: 'menuitem',
-        className: 'dshpc-fb__menu-item',
-        style: { paddingLeft: 8 },
-        title: crumb.path,
-        onClick: () => {
-            onLoadDir?.(crumb.path);
-        },
-    }, withArrow
-        ? h(Fragment, null, Array.from({ length: depth }, (_, s) => h('span', { key: `s${s}`, className: 'dshpc-fb__menu-chev-slot', 'aria-hidden': true })), h('span', { className: 'dshpc-fb__menu-chev' }, h(IconChevronRightOutlineRegular, { size: 11 })))
-        : null, h('span', { className: 'dshpc-fb__menu-label' }, crumb.label));
-    if (workspaces === undefined) {
-        if (crumbs.length === 0)
-            return [h('div', { key: 'empty', className: 'dshpc-fb__menu-empty' }, rootFallbackLabel)];
-        return crumbs.map((crumb, index) => pathEntry(crumb, index === 0 ? 0 : index - 1, index !== 0));
-    }
-    // 路径段：根 crumb（path=''）已由工作区段表达时剔除，深度从根下一层起算。
-    const segments = rootName !== '' && crumbs.length > 0 && crumbs[0]?.path === '' ? crumbs.slice(1) : crumbs;
-    if (rootName !== '' && workspaces.includes(rootName)) {
-        // 当前工作区排第一，其下路径紧跟，然后是其他工作区（保持原相对顺序）。
-        out.push(wsEntry(rootName, true));
-        segments.forEach((crumb, i) => {
-            out.push(pathEntry(crumb, i));
-        });
-        for (const ws of workspaces) {
-            if (ws !== rootName)
-                out.push(wsEntry(ws, false));
-        }
-    }
-    else {
-        segments.forEach((crumb, i) => {
-            out.push(pathEntry(crumb, i));
-        });
-        for (const ws of workspaces)
-            out.push(wsEntry(ws, false));
-    }
-    return out;
-}
+const FS_ROOT = '/';
 /** 目录浏览器面板。详见 {@link FileBrowserProps}。 */
 export function FileBrowser(props) {
     ensureComponentStyles('explorer', EXPLORER_CSS);
+    // ▾ 选层用浮层 menu 档（panel.css）：跟弹窗同一套底色/描边/圆角/阴影。
+    ensureComponentStyles('panel', PANEL_CSS);
     const tt = props.translate ?? t;
     const picker = props.picker === true;
-    // 根缓存：调用方可注入（多实例/清理策略归调用方）；不传则内部自建、随组件废弃。
-    const cacheRef = useRef(null);
-    if (cacheRef.current === null)
-        cacheRef.current = props.rootCache ?? createRootCache();
-    const rootCache = props.rootCache ?? cacheRef.current;
     // mode：加载/目录树/文件预览/列举错误。viewing 非空 ⇒ 在 dir 树内预览文件。
     const [mode, setMode] = useState('loading');
     const [dir, setDir] = useState('');
@@ -125,11 +58,15 @@ export function FileBrowser(props) {
     // 内联展开：openDirs = 已展开目录路径集合；childCache = 各展开目录拉到的子项。
     const [openDirs, setOpenDirs] = useState(new Set());
     const [childCache, setChildCache] = useState({});
-    // 工作区根补学完成信号（缓存非响应式，学成后 bump 触发面包屑重算）。
-    const [rootNonce, setRootNonce] = useState(0);
     // 当前目录在会话工作区之外（官方 list 限工作区内，越界即报 outside-workspace）。
     // 依据 = list 的**真实错误码**，不靠缓存猜（根学不出时会误判成"在区内"）。
     const [outside, setOutside] = useState(false);
+    // picker 且路径/会话都没给 ⇒ 落地页：主窗体先列「根目录 + 各工作区」让用户自己选（用户 2026-11-03 定）。
+    const [landing, setLanding] = useState(props.picker === true && props.path === '' && props.sessionId === undefined);
+    const landingRef = useRef(landing);
+    useLayoutEffect(() => {
+        landingRef.current = landing;
+    }, [landing]);
     const revision = props.revision ?? 0;
     // 请求闸门（latest-wins）：顶层列举 / 补学根 各一口；内联展开每个目录一口。
     // begin() 先 abort 上一次，回调用 token.current() 判新旧 ⇒ 连续切换只认最后一次，
@@ -138,10 +75,6 @@ export function FileBrowser(props) {
     if (listGateRef.current === null)
         listGateRef.current = createRequestGate();
     const listGate = listGateRef.current;
-    const rootGateRef = useRef(null);
-    if (rootGateRef.current === null)
-        rootGateRef.current = createRequestGate();
-    const rootGate = rootGateRef.current;
     const childAbortsRef = useRef(new Map());
     const abortChildren = useCallback(() => {
         for (const controller of childAbortsRef.current.values())
@@ -155,18 +88,56 @@ export function FileBrowser(props) {
         dirRef.current = dir;
         listingRef.current = listing;
     }, [dir, listing]);
-    // 路径 → 工作区匹配：props.path 是绝对路径时，找出它所属的工作区（最长前缀），
-    // list / 学根 / 相对化**全部**换用该工作区的会话与根——官方 list 按 sessionId 解析工作区根，
-    // 只换 list 的 sessionId 不换学根的键，面包屑会露出工作区之外的层级（2026-10-22 真机：
-    // 匹配生效但 rootCache 仍按 props.sessionId 学根 ⇒ 相对化失败 ⇒ 显示 `C.x > workspace > …`）。
-    // 匹配不到 ⇒ 整体回落 props.sessionId（旧行为）。
+    // 路径 → 工作区匹配：props.path 是绝对路径时按最长前缀找出所属工作区，面包屑根名与
+    // 相对化就用它（路径本来就在 FS 面里，不需要再「反推工作区根」）。
+    // 匹配不到 ⇒ 回落 props.rootName（调用方给的显示名）。
     // 工作区清单来源（优先级从高到低）：① props.workspaceAnchors（调用方显式给，可覆盖）；
     // ② 宿主 workspaces 快照（connectHost 注入的 workspaceList，官方 WorkspaceView 镜像）。
-    // 快照异步到达时会重算 + 重跑初始 effect（listSessionId 在其依赖里）⇒ 自愈，无感。
+    // 快照异步到达时会重算 + 重跑初始 effect（rootBase 在其依赖里）⇒ 自愈，无感。
     const hostWorkspaces = useSyncExternalStore(workspaceList.subscribe, workspaceList.getSnapshot);
     const anchors = props.workspaceAnchors ?? hostWorkspaces;
-    const anchorMatch = useMemo(() => workspaceAnchorForPath(props.path, anchors), [props.path, anchors]);
-    const listSessionId = anchorMatch?.sessionId ?? props.sessionId;
+    // 根层清单：问宿主要（`op:'roots'`）。POSIX 回 `['/']`；Windows 回盘符 —— **Windows 没有「根目录」
+    // 这一个东西，根就是盘符清单**（用户 2026-11-03）。拿不到（文件面没这能力）⇒ 按 POSIX 单根。
+    const [roots, setRoots] = useState([FS_ROOT]);
+    useEffect(() => {
+        const ask = props.files.roots;
+        if (ask === undefined)
+            return;
+        let alive = true;
+        void Promise.resolve()
+            .then(() => ask.call(props.files))
+            .then((list) => {
+            if (!alive || list.length === 0)
+                return;
+            // 内容相同就不换引用：调用方每次渲染都给新的 files 对象时，否则会「effect → setState → 渲染 → effect」空转。
+            setRoots((prev) => (prev.length === list.length && prev.every((item, index) => item === list[index]) ? prev : list));
+        })
+            .catch(() => { });
+        return () => { alive = false; };
+    }, [props.files]);
+    const anchorMatch = useMemo(() => workspaceOfPath(props.path, anchors), [props.path, anchors]);
+    /** 相对路径的基准目录（工作区根）：匹配出的工作区 > 调用方给的 > 无（只认绝对路径）。 */
+    const sessionAnchor = props.sessionId === undefined
+        ? null
+        : anchors.find((item) => item.sessionIds?.includes(props.sessionId) === true) ?? null;
+    const rootBase = anchorMatch?.path ?? props.rootPath ?? sessionAnchor?.path ?? anchors.find((item) => item.path !== undefined)?.path;
+    /** 任意入参 → 绝对路径（FS 面只认绝对路径）。 */
+    const absOf = useCallback((p) => {
+        if (isAbsoluteish(p))
+            return normalizePath(p);
+        // '' = 「根」：有工作区基准就是该工作区根，没有就是文件系统根（`/`；Windows 上是当前盘根）。
+        if (rootBase === undefined || rootBase === '')
+            return p === '' ? FS_ROOT : p;
+        return p === '' ? normalizePath(rootBase) : normalizePath(`${rootBase}/${p.replace(/^\/+/, '')}`);
+    }, [rootBase]);
+    /** 面板回传（绝对路径 + 工作区归属）。 */
+    const toPicked = useCallback((p, isDir) => {
+        const abs = absOf(p);
+        const owner = workspaceOfPath(abs, anchors);
+        return owner === null
+            ? { path: abs, isDir }
+            : { path: abs, isDir, workspaceRel: relativizeToDir(abs, owner.path ?? null), workspace: owner.title };
+    }, [absOf, anchors]);
     /** 记一次 list 结果的"是否越界"（outside-workspace / not-found 均视为不可浏览）。 */
     const noteOutside = useCallback((parsed) => {
         if (parsed === null || parsed === undefined)
@@ -183,7 +154,8 @@ export function FileBrowser(props) {
     const fetchDir = useCallback((targetDir) => {
         const token = listGate.begin();
         abortChildren();
-        setDir(targetDir);
+        const absTarget = absOf(targetDir);
+        setDir(absTarget);
         setViewing(null);
         setListErr(null);
         setMenuOpen(false);
@@ -191,8 +163,8 @@ export function FileBrowser(props) {
         // 切换顶层目录：清空内联展开态（展开树只属于当前这一层）。
         setOpenDirs(new Set());
         setChildCache({});
-        props.workspaceFiles
-            .list(listSessionId, listPathOf(targetDir), token.signal)
+        props.files
+            .list(absTarget, token.signal)
             .then((result) => {
             if (!token.current())
                 return;
@@ -218,21 +190,26 @@ export function FileBrowser(props) {
             setListErr(errView(error));
             setMode('error');
         });
-    }, [abortChildren, listGate, listSessionId, noteOutside, props.workspaceFiles]);
+    }, [abortChildren, absOf, listGate, noteOutside, props.files]);
     /** 进入某目录；点到当前目录本身 = 重列本层（刷新）。 */
     const loadDir = useCallback((targetDir) => {
-        if (targetDir === dir) {
-            fetchDir(targetDir);
-            return;
-        }
+        // 落地页上点 ▾ 选根目录 / 工作区：必须先退出落地页，否则主体还是落地页那张表，
+        // 点了跟没点一样（用户 2026-11-03 真机："选里面的任何一个都没有任何效果"）。
+        if (landingRef.current)
+            setLanding(false);
         fetchDir(targetDir);
-    }, [dir, fetchDir]);
+    }, [fetchDir]);
     // 初次进入（path 可能是文件或目录）：
     // list(path) 成功 ⇒ 目录树（dir 尽量取宿主绝对路径 ⇒ 面包屑从工作区根往下列）；
     // 报错 ⇒ 文件预览态（dir = 父目录，面包屑保留可返回）。
     // ⚠️ 切勿改用服务端 list 返回的 path 当面包屑：那是 workspacePathOf 的工作区**相对**形式，
     //    会丢掉根以下的前导段，面包屑只剩最近一层（源实现 2026-09-29 踩过 ⇒ 已回退为入参路径）。
     useEffect(() => {
+        // 落地页（还没选根目录/工作区）：什么都不列，等用户点。
+        // 用 ref 读、**不进依赖**：否则从落地页点进目录那一刻 landing 变 false 会重跑本 effect，
+        // 又把目录拉回 absOf('') = 第一个工作区（真机 2026-11-03）。
+        if (landingRef.current)
+            return;
         // 同目录换文件（侧栏连点 / 重开同一文件）：只换 viewing——目录树、展开态、滚动位置保留，
         // 也不再额外触发一次 list。旧目录列举已由上一轮 effect 的清理函数 abort。
         // 判据用 listingRef（不是 props.path 的类型）：只有「当前已列出的这一层里确实有这个文件」
@@ -241,7 +218,7 @@ export function FileBrowser(props) {
         const name = baseNameOfPath(props.path);
         const knownFile = listingRef.current?.some((entry) => entry.name === name && entry.type === 'file') === true;
         if (props.path !== '' && dirRef.current !== '' && parent === dirRef.current && knownFile) {
-            setViewing(props.path);
+            setViewing(absOf(props.path));
             setMode('file');
             setSourceView(false);
             // 同路径再点一次也要重读内容（对齐旧版「每次打开都重读」；不重挂只换 key）。
@@ -251,7 +228,6 @@ export function FileBrowser(props) {
             return;
         }
         const token = listGate.begin();
-        const rootToken = rootGate.begin();
         abortChildren();
         setMode('loading');
         setListErr(null);
@@ -261,94 +237,28 @@ export function FileBrowser(props) {
         setMenuOpen(false);
         setOpenDirs(new Set());
         setChildCache({});
-        /** 补学工作区根（面包屑根名显示 + picker 相对化要用）：列目录 → 有文件就 stat 反推，没有就走有界 BFS。 */
-        const ensureRootLearned = (currentDir) => {
-            if (rootCache.get(listSessionId) !== undefined)
-                return;
-            void (async () => {
-                try {
-                    const parsed = listingOf(await props.workspaceFiles.list(listSessionId, listPathOf(currentDir), rootToken.signal));
-                    if (!rootToken.current() || parsed === null || isFailed(parsed))
-                        return;
-                    const stat = props.workspaceFiles.stat;
-                    if (stat === undefined)
-                        return;
-                    const rel = parsed.path;
-                    const file = parsed.entries.find((entry) => entry.type === 'file');
-                    if (file !== undefined) {
-                        const sub = rel === '' ? file.name : `${rel}/${file.name}`;
-                        const abs = (await stat(listSessionId, sub, rootToken.signal).catch(() => null));
-                        if (!rootToken.current())
-                            return;
-                        const absPath = typeof abs?.absolutePath === 'string' ? abs.absolutePath : null;
-                        if (absPath !== null && learnRoot(rootCache, listSessionId, sub, absPath) !== null) {
-                            setRootNonce((n) => n + 1);
-                            return;
-                        }
-                    }
-                    const found = await findAnyFileAbs(props.workspaceFiles, listSessionId, rel, rootToken.signal);
-                    if (!rootToken.current())
-                        return;
-                    if (found !== null && learnRoot(rootCache, listSessionId, found.relativePath, found.absolutePath) !== null) {
-                        setRootNonce((n) => n + 1);
-                    }
-                }
-                catch {
-                    /* 学不出就维持退化显示 */
-                }
-            })();
-        };
-        props.workspaceFiles
-            .list(listSessionId, listPathOf(props.path), token.signal)
-            .then(async (result) => {
+        const entry = absOf(props.path);
+        props.files
+            .list(entry, token.signal)
+            .then((result) => {
             if (!token.current())
                 return;
             const parsed = listingOf(result);
             if (!isFailed(parsed) && parsed !== null) {
                 setOutside(false);
-                // 入口可能是工作区相对名 ⇒ 用目录里任一文件子项的 stat 反推绝对路径；
-                // 解析不出（空目录/只有子目录/stat 缺失）就退回入参，不阻塞浏览。
-                const absDir = await absolutizeDir(rootCache, props.workspaceFiles, listSessionId, props.path, parsed.path, parsed.entries, token.signal);
-                if (!token.current())
-                    return;
-                setDir(absDir);
+                setDir(entry);
                 setListing(parsed.entries);
                 setTruncated(parsed.truncated);
                 setMode('dir');
-                ensureRootLearned(absDir);
                 return;
             }
             // 不是目录 ⇒ 当作文件预览，dir 取父目录，尽量把父树也列出来。
-            let parentDir = dirnameOf(props.path);
-            if (!isAbsoluteish(props.path)) {
-                const stat = props.workspaceFiles.stat;
-                if (stat !== undefined) {
-                    try {
-                        const res = await stat(listSessionId, props.path, token.signal);
-                        if (!token.current())
-                            return;
-                        const abs = typeof res.absolutePath === 'string'
-                            ? res.absolutePath
-                            : null;
-                        if (abs !== null) {
-                            parentDir = dirnameOf(abs);
-                            // 记住工作区根 ⇒ 之后同会话里相对名也能解析
-                            learnRoot(rootCache, listSessionId, props.path, abs);
-                        }
-                    }
-                    catch {
-                        /* 解析不出就用入参父目录 */
-                    }
-                }
-            }
-            if (!token.current())
-                return;
+            const parentDir = dirnameOf(entry);
             setDir(parentDir);
-            setViewing(props.path);
+            setViewing(entry);
             setMode('file');
-            ensureRootLearned(parentDir);
-            props.workspaceFiles
-                .list(listSessionId, listPathOf(parentDir), token.signal)
+            props.files
+                .list(parentDir, token.signal)
                 .then((pres) => {
                 if (!token.current())
                     return;
@@ -367,21 +277,28 @@ export function FileBrowser(props) {
             if (!token.current() || isAborted(token.signal, error))
                 return;
             // 传输层失败：仍尝试按文件预览（预览体内部会给出错误态）。
-            const parentDir = dirnameOf(props.path);
-            setDir(parentDir);
-            setViewing(props.path);
+            setDir(dirnameOf(entry));
+            setViewing(entry);
             setMode('file');
-            ensureRootLearned(parentDir);
         });
         return () => {
             listGate.abort();
-            rootGate.abort();
         };
         // ⚠️ 这里**不** abort 内联展开的子请求：同目录换文件时它们仍然有效（树也保留着）。
         // 子请求只在「换顶层目录」（fetchDir）与卸载时取消。
-    }, [abortChildren, listGate, listSessionId, noteOutside, props.workspaceFiles, props.path, revision, rootCache, rootGate]);
+    }, [abortChildren, absOf, listGate, noteOutside, props.files, props.path, revision]);
     // 卸载时把内联展开的在途请求一起取消（依赖为空 ⇒ 只有卸载才跑清理）。
     useEffect(() => () => abortChildren(), [abortChildren]);
+    /** ▾ 里点别的工作区：调用方没接管就直接列该工作区根（不需要会话）。 */
+    const switchWorkspace = useCallback((name) => {
+        if (props.onSelectWorkspace !== undefined) {
+            props.onSelectWorkspace(name);
+            return;
+        }
+        const target = anchors.find((item) => item.title === name);
+        if (target?.path !== undefined)
+            loadDir(target.path);
+    }, [anchors, loadDir, props.onSelectWorkspace]);
     // 面包屑溢出测量：隐藏测量条渲染与可见态完全相同的 crumb 按钮（含 padding/max-width），
     // 使溢出判定与真实排版一致——不超长时必定还原完整路径。ResizeObserver 同时覆盖
     // dock 宽度变化 / 初次布局。
@@ -400,7 +317,7 @@ export function FileBrowser(props) {
         // 依赖要带上「根反推完成」「越界态变化」：这两样会让面包屑从超长绝对路径相对化成
         // 短路径，但若不重算，crumbsOverflow 会卡在首帧的 true（只显示末段），直到下次导航才复原
         // （2026-10-28 真机：打开工作区内的绝对路径，面包屑只剩末段，点一下目录才恢复）。
-    }, [dir, viewing, mode, listing, rootNonce, outside]);
+    }, [dir, viewing, mode, listing, outside]);
     const reload = useCallback(() => {
         if (viewing !== null) {
             setReloadNonce((n) => n + 1);
@@ -413,7 +330,7 @@ export function FileBrowser(props) {
         const target = viewing ?? dir;
         if (target === '')
             return;
-        const rel = relativizeToRoot(rootCache, listSessionId, target);
+        const rel = relativizeToDir(target, rootBase ?? null);
         writeClipboard(rel)
             .then((ok) => {
             if (ok) {
@@ -424,7 +341,7 @@ export function FileBrowser(props) {
             .catch(() => {
             /* 剪贴板不可用（非安全上下文等）：静默，不弹错 */
         });
-    }, [viewing, dir, rootCache, listSessionId]);
+    }, [viewing, dir, rootBase]);
     /** 内联展开/收起某目录（点 ▸）：只切展开态，不导航；首次展开才拉子项。 */
     const toggleDir = useCallback((path) => {
         setOpenDirs((prev) => {
@@ -440,8 +357,8 @@ export function FileBrowser(props) {
             const controller = new AbortController();
             childAbortsRef.current.set(path, controller);
             setChildCache((prev) => ({ ...prev, [path]: { status: 'loading' } }));
-            props.workspaceFiles
-                .list(listSessionId, listPathOf(path), controller.signal)
+            props.files
+                .list(absOf(path), controller.signal)
                 .then((result) => {
                 if (controller.signal.aborted)
                     return;
@@ -463,7 +380,7 @@ export function FileBrowser(props) {
                     childAbortsRef.current.delete(path);
             });
         }
-    }, [childCache, props.workspaceFiles, listSessionId]);
+    }, [absOf, childCache, props.files]);
     // 过滤点名了扩展名 ⇒ 要的是**文件**：目录只作导航（点行就地展开），不给「选择」、也回传不了 isDir。
     // （旧实现「目录永远保留且永远带选择钮」，于是「仅 JS/MD」下出现「文件夹旁边有选择、
     //   MD 文件旁边反而没有」，选中还回传一个文件夹——与过滤语义直接打架。）
@@ -480,8 +397,8 @@ export function FileBrowser(props) {
         if (!isDir) {
             const pick = () => {
                 if (picker && props.onPick !== undefined) {
-                    // 回传**工作区相对**路径（源实现真机 bug：绝对路径被宿主 zod 拒）。
-                    props.onPick(relativizeToRoot(rootCache, listSessionId, childPath), false);
+                    // 回传绝对路径 + 工作区归属（用户 2026-11-03 定 `PickedPath`）。
+                    props.onPick(toPicked(childPath, false));
                     return;
                 }
                 // 逐层展开后选中文件：面包屑要跟随到该文件所在目录。
@@ -532,7 +449,7 @@ export function FileBrowser(props) {
             if (picker) {
                 // 扩展名过滤下这里不该被触发（目录行根本不渲染这枚钮）；兜住是为了语义不被绕过。
                 if (!extsOnly && props.onPick !== undefined)
-                    props.onPick(relativizeToRoot(rootCache, listSessionId, childPath), true);
+                    props.onPick(toPicked(childPath, true));
                 return;
             }
             loadDir(childPath);
@@ -588,132 +505,100 @@ export function FileBrowser(props) {
                     ? h('div', { className: 'dshpc-fb__row-err' }, tt(cached.error.key, cached.error.params))
                     : h(Fragment, null, renderTree(cached.entries, childPath), cached.truncated ? h('div', { className: 'dshpc-fb__row-note' }, tt('explorerTruncated')) : null))
             : null);
-    }), [childCache, openDirs, picker, dirPickable, extsOnly, props.filter, props.onPick, listSessionId, rootCache, dir, loadDir, tt]);
-    // 面包屑 = 工作区根 + 其下相对层级。根名优先级：**匹配出的工作区名**（当前路径所属，
-    // 不写死）> 调用方 rootName > 缓存根末段。学根/相对化一律按 listSessionId——
-    // 用调用方原始 sessionId 学根会学出别的根 ⇒ 相对化失败 ⇒ 露出工作区外层级（真机 2026-10-22）。
-    const rootAbs = rootCache.get(listSessionId);
-    const rootLabel = anchorMatch?.title ?? props.rootName ?? (rootAbs !== undefined ? baseNameOfPath(rootAbs.replace(/\/+$/, '')) : '');
-    const relDir = relativizeToRoot(rootCache, listSessionId, dir);
-    // 根还没反推出来时 dir 仍是整条绝对路径：逐段铺开会露出「root/.local/share/…」十几段工作区之外的
-    // 层级（点不动、也没信息量），根一学成又整条缩回 ⇒ 中间闪一下。这里先只给「根名 + 当前层」，
-    // 根学成后由 rootNonce 触发重算，自动补全成完整层级（2026-10-28 真机：绝对路径打开时的闪段）。
-    const rootPending = rootAbs === undefined && dir !== '' && isAbsoluteish(dir);
-    const crumbs = [
-        ...(rootLabel !== '' ? [{ label: rootLabel, path: '' }] : []),
-        ...(rootPending ? [{ label: baseNameOfPath(dir), path: dir }] : crumbsOfDir(relDir)),
-    ];
+    }), [childCache, openDirs, picker, dirPickable, extsOnly, props.filter, props.onPick, toPicked, dir, loadDir, tt]);
+    // 根层条目：有盘符（Windows）就一条一档；否则单条「根目录」（POSIX）。
+    // 两者都是**可选目标**（用户 2026-11-03：Linux 的 `/` 也可以选；Windows 至少能选盘）。
+    const drives = roots.filter((root) => root !== FS_ROOT);
+    const rootRows = drives.length > 0
+        ? drives.map((path) => ({ label: path.replace(/\/+$/, ''), path }))
+        : [{ label: tt('explorerRootDir'), path: FS_ROOT }];
+    // 面包屑（用户 2026-11-03 定）：**按当前目录**去比所有工作区。
+    // 命中 ⇒ 第一段是工作区名，其下按相对层级；没命中 ⇒ 第一段是根（「根目录」或盘符），其下逐层。
+    // 判据只看 `dir`（不比 props.path）：浏览途中切进别的工作区也要立刻跟着切根。
+    const owner = workspaceOfPath(dir, anchors);
+    const rootLabel = owner?.title ?? '';
+    const crumbs = owner === null
+        ? (/^[a-zA-Z]:/.test(normalizePath(dir))
+            // 盘符路径：根段由 crumbsOfDir 自己出（`C:`），再补一段「根目录」就重复了。
+            ? crumbsOfDir(dir)
+            : [{ label: rootRows[0]?.label ?? tt('explorerRootDir'), path: FS_ROOT }, ...crumbsOfDir(dir)])
+        : [{ label: rootLabel, path: '' }, ...crumbsOfDir(relativizeToDir(dir, owner.path ?? null))];
     // md / html 都出「渲染 ⇄ 源码」切换（默认渲染）。
     const viewingIsMd = viewing !== null && /\.(md|markdown)$/i.test(viewing);
     const viewingIsHtml = viewing !== null && /\.(html|htm)$/i.test(viewing);
     const switchable = viewingIsMd || viewingIsHtml;
+    // 工作区清单：调用方没传就用宿主快照里的（picker 与 dock 同一条逻辑 —— 用户 2026-11-03：
+    // 两处显示必须一致，不能 dock 有清单、picker 只有一个根目录）。
     const menuItems = crumbsMenuEntries({
-        workspaces: props.workspaces,
+        workspaces: props.workspaces ?? anchors.map((item) => item.title),
+        roots: rootRows,
         rootName: rootLabel,
         rootFallbackLabel: tt('explorerRootName'),
         crumbs,
-        onPickWorkspace: props.onSelectWorkspace,
+        onPickWorkspace: switchWorkspace,
         onLoadDir: loadDir,
     });
-    /** 一段面包屑（核心 ghost 钮：无底无边；度量条与可见态必须逐字同构）。 */
-    const crumbButton = (label, onClick, current = false) => h(Button, {
-        variant: 'ghost',
-        size: 'sm',
-        className: `dshpc-fb__crumb${current ? ' dshpc-fb__crumb--current' : ''}`,
-        disabled: onClick === undefined,
-        tabIndex: onClick === undefined ? -1 : 0,
-        onClick,
-    }, h(MarqueeText, { text: label, className: 'dshpc-fb__crumb-mq' }));
-    const crumbBar = h('nav', { className: 'dshpc-fb__bar', 'aria-label': tt('explorerCrumbsAria') }, h('div', { className: 'dshpc-fb__menu-wrap' }, h(IconButton, {
-        variant: 'plain',
-        size: 'md',
-        icon: h(IconChevronDownOutlineRegular, { size: 14 }),
-        label: tt('explorerLevels'),
-        'aria-expanded': menuOpen,
-        onClick: () => setMenuOpen((v) => !v),
-    }), 
-    // 选层下拉 = 自写浮层（抄兄弟 .dsh-tdt-sv-crumbs-*）：透明遮罩点一下即收，
-    // 遮罩层序高于 picker 面板（1100）⇒ 菜单开着时点面板也算「点外部」。
-    menuOpen
-        ? h(Fragment, null, h('div', {
-            className: 'dshpc-fb__crumbs-backdrop',
-            onClick: () => setMenuOpen(false),
-        }), h('div', { className: 'dshpc-fb__crumbs-menu', role: 'menu' }, menuItems))
-        : null), h('div', { ref: regionRef, className: 'dshpc-fb__crumbs' }, 
-    // 隐藏测量条：与可见态完全同构的 crumb 按钮，确保溢出判定精确。
-    h('span', { ref: measureRef, className: 'dshpc-fb__crumbs-measure', 'aria-hidden': true }, crumbs.length === 0
-        ? crumbButton(tt('explorerRootName'))
-        : crumbs.map((crumb, index) => h(Fragment, { key: crumb.path }, index > 0 ? h(IconChevronRightOutlineRegular, { className: 'dshpc-fb__crumb-sep', size: 12 }) : null, crumbButton(crumb.label)))), 
-    // 工作区根目录（crumbs 空）也要有可见的面包屑占位。
-    crumbsOverflow
-        ? crumbButton(crumbs.length > 0 ? crumbs[crumbs.length - 1]?.label ?? tt('explorerRootName') : tt('explorerRootName'), undefined, true)
-        : crumbs.length === 0
-            ? crumbButton(tt('explorerRootName'), undefined, true)
-            : crumbs.map((crumb, index) => h(Fragment, { key: crumb.path }, index > 0 ? h(IconChevronRightOutlineRegular, { className: 'dshpc-fb__crumb-sep', size: 12 }) : null, crumbButton(crumb.label, () => loadDir(crumb.path))))), h('div', { className: 'dshpc-fb__actions' }, props.onClose === undefined
-        ? null
-        : h(IconButton, {
-            variant: 'plain',
-            size: 'md',
-            icon: h(IconCloseOutlineRegular, { size: 14 }),
-            label: tt('previewClose'),
-            onClick: props.onClose,
-        })));
-    // 越界（outside-workspace）：第一排整条换成只读完整路径，不给任何会失败的入口。
-    const crumbBarPlain = h('nav', { className: 'dshpc-fb__bar', 'aria-label': tt('explorerCrumbsAria') }, h(MarqueeText, {
-        text: dir,
-        title: dir,
-        className: 'dshpc-fb__bar-plain',
-        style: { flex: '1 1 auto', minWidth: 0 },
-    }), h('div', { className: 'dshpc-fb__actions' }, props.onClose === undefined
-        ? null
-        : h(IconButton, {
-            variant: 'plain',
-            size: 'md',
-            icon: h(IconCloseOutlineRegular, { size: 14 }),
-            label: tt('previewClose'),
-            onClick: props.onClose,
-        })));
-    // 第二排（仅预览态显示）：文件名 + 渲染⇄源码切换 / 复制路径 / 刷新。
-    // 档位照兄弟项目调用点：Segmented `sm` + 图标钮 `md`（核心 Segmented 高度由 CSS 定，不随档变）。
+    // 选择器的「选当前目录」入口（用户 2026-11-03：进到某一层之后，行上没有它自己，
+    // 树里也点不到「当前这层」⇒ 在 ✕ 左边给一枚按钮）。落地页还没进任何目录、扩展名过滤下
+    // 目录不是合法结果 —— 这两种情况不出按钮。
+    const pickNow = picker && props.onPick !== undefined && !landing && dirPickable && dir !== ''
+        ? h(Button, {
+            // 描边（outline）：ghost 在这一排**看不出来是按钮**——它无底无边，与面板同色，
+            // 用户 2026-11-03 实测「就像没有背景一样」，于是改回有 border 的一档（覆盖当天早些的 ghost 结论）。
+            variant: 'outline',
+            size: 'sm',
+            className: 'dshpc-fb__pick',
+            'aria-label': tt('explorerPickDirAria'),
+            onClick: () => props.onPick?.(toPicked(dir, true)),
+        }, tt('explorerPickDir'))
+        : null;
+    const nav = outside
+        ? h(PlainNav, { translate: tt, path: dir, pickNow, onClose: props.onClose })
+        : h(CrumbNav, {
+            translate: tt,
+            landing,
+            crumbs,
+            overflow: crumbsOverflow,
+            menuItems,
+            menuOpen,
+            onToggleMenu: () => setMenuOpen((v) => !v),
+            onCloseMenu: () => setMenuOpen(false),
+            onLoadDir: loadDir,
+            pickNow,
+            onClose: props.onClose,
+            regionRef,
+            measureRef,
+        });
     const titleBar = viewing === null
         ? null
-        : h('div', { className: 'dshpc-fb__title' }, h(MarqueeText, {
-            text: baseNameOfPath(viewing),
-            title: viewing,
-            className: 'dshpc-fb__title-inner',
-            style: { flex: '1 1 auto', minWidth: 0 },
-        }), h('div', { className: 'dshpc-fb__actions' }, switchable
-            ? h(Segmented, {
-                size: 'sm',
-                label: viewingIsMd ? tt('previewMdSwitchAria') : tt('previewHtmlSwitchAria'),
-                value: sourceView ? 'source' : 'render',
-                items: [
-                    { value: 'render', label: tt('previewRender') },
-                    { value: 'source', label: tt('previewSource') },
-                ],
-                onChange: (next) => setSourceView(next === 'source'),
-            })
-            : null, h(IconButton, {
-            variant: 'plain',
-            size: 'md',
-            icon: copied ? h(IconCheckOutlineRegular, { size: 14 }) : h(IconCopyOutlineRegular, { size: 14 }),
-            label: tt('previewCopyPath'),
-            onClick: copyPath,
-        }), h(IconButton, {
-            variant: 'plain',
-            size: 'md',
-            icon: h(IconRefreshOutlineRegular, { size: 14 }),
-            label: tt('previewRefresh'),
-            onClick: reload,
-        })));
+        : h(PreviewTitleBar, {
+            translate: tt,
+            path: viewing,
+            switchable,
+            isMarkdown: viewingIsMd,
+            sourceView,
+            onSourceViewChange: setSourceView,
+            copied,
+            onCopyPath: copyPath,
+            onReload: reload,
+        });
     // ── 主体 ──
     let body;
-    if (viewing !== null) {
+    if (landing) {
+        body = h(LandingBody, {
+            translate: tt,
+            roots: rootRows,
+            anchors,
+            pickable: picker && props.onPick !== undefined && !extsOnly,
+            onOpen: loadDir,
+            onPickDir: (target) => props.onPick?.(toPicked(target, true)),
+        });
+    }
+    else if (viewing !== null) {
         body = h(FilePreview, {
             key: `${viewing}:${reloadNonce}`,
-            workspaceFiles: props.workspaceFiles,
+            files: props.files,
             officeToPdf: props.officeToPdf ?? null,
-            sessionId: listSessionId,
             path: viewing,
             sourceView,
             translate: tt,
@@ -737,6 +622,6 @@ export function FileBrowser(props) {
     return h('div', {
         className: 'dshpc-fb',
         style: props.style ?? undefined,
-    }, outside ? crumbBarPlain : crumbBar, titleBar, body);
+    }, nav, titleBar, body);
 }
 //# sourceMappingURL=FileBrowser.js.map