@dsh-electron/dsh-plugin-multi-root-workspace 0.1.15 → 0.1.16

package/lib/client.js

@@ -128,7 +128,7 @@ window.__ModuleLoader__.load({
 			return typeof value === "function" ? value : void 0;
 		}
 		/** The factory consumes absolute, slash-separated keys and already-localized errors. */
-		function nativeTreeInput(state, failureLine, toggle, open) {
+		function nativeTreeInput(state, failureLine, toggle, open, current) {
 			const root = state.root.replace(/[/\\]+$/, "");
 			const keyOf = (path) => path === state.root ? root : path;
 			const entries = [];
@@ -155,6 +155,10 @@ window.__ModuleLoader__.load({
 				entries,
 				directories,
 				expanded: state.expanded.map(keyOf),
+				...current === void 0 ? {} : {
+					current: current.path,
+					currentRef: current.ref
+				},
 				onToggle: (entry) => {
 					const parent = entry.path.slice(0, entry.path.lastIndexOf("/"));
 					toggle(parent === root ? state.root : parent, entry.path);
@@ -5683,6 +5687,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"error.unavailable": "无法连接到 dsh 主进程。",
 			"error.copy-failed": "无法写入剪贴板，请检查浏览器的剪贴板权限。",
 			"error.session-not-found": "找不到该会话；请先打开一个工作区会话。",
+			"error.session-not-live": "该会话存在但未在本实例激活；它可能正被另一个 DSH 实例持有、仍在恢复，或格式待迁移。若另一实例持有它，请退出那个实例；也可以切换到同一工作区的活动会话；格式待迁移时请在该会话完成迁移。否则请稍后重试。",
 			"error.unsupported-path": "该路径是网络或设备路径，Windows ACL 隔离无法覆盖它。",
 			"error.protected-path": "该目录与 DSH 主目录或根登记存储目录重叠，不能登记。",
 			"error.protected-boundary-unknown": "暂时无法确定 DSH 主目录等受保护目录的位置；恢复之前不能新增登记。",
@@ -5790,6 +5795,7 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			"error.unavailable": "Could not reach the dsh host process.",
 			"error.copy-failed": "Could not write to the clipboard; check the browser's clipboard permission.",
 			"error.session-not-found": "That session is not active; open a workspace session first.",
+			"error.session-not-live": "That session exists but is not active in this instance — it may be held by another DSH instance, still resuming, or awaiting a format migration. If another instance holds it, quit that instance; alternatively, switch to an active session in the same workspace; if a migration is pending, complete it in that session. Otherwise retry shortly.",
 			"error.unsupported-path": "That is a network or device path, which Windows ACL confinement cannot cover.",
 			"error.protected-path": "That directory overlaps the DSH home or the registry storage directories; it cannot be registered.",
 			"error.protected-boundary-unknown": "The protected DSH directories cannot be resolved right now; no folder can be registered until they can.",
@@ -6123,6 +6129,27 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
   background: var(--dsw-alias-interactive-bg-hover);
 }
 
+/* The document preview's navigator aside, while the retarget holds it: the
+   native body hides (it lists the session's primary root regardless of the
+   previewed file), and the forked tree — portaled in as the aside's sibling
+   child — takes the same stretch item in the aside's column flex, right
+   down to the body's own padding and 2px scrollbar offset. The aside's
+   chrome is untouched: width, push/overlay/fill modes, and the resize
+   separator all stay native. The marker attribute is set only while a
+   takeover actually holds the aside, so a navigator we never matched — or
+   one whose plugin sheet is gone — renders exactly as upstream drew it. */
+aside[data-mrfw-navigator] > [data-files-body] {
+  display: none;
+}
+
+/* The reveal's current row, the fork's spelling of upstream's .current:
+   the interactive-active fill, kept under hover exactly as the native
+   tree's current row keeps it. */
+.mrfw-ftRow[data-files-current],
+.mrfw-ftRow[data-files-current]:hover {
+  background: var(--dsw-alias-interactive-bg-active);
+}
+
 /* ── files-tree fork (verbatim rules, renamed classes) ─────────────────────
    Copied from upstream's FilesBody.module.css (ui-sidebar-files @
    0.2.2-alpha.2) with local names mapped to mrfw-ft* so the rules cannot
@@ -7747,6 +7774,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 				/** Per tab, per absolute path: the listing generation a settlement must match; the latest request wins. */
 				const generations = /* @__PURE__ */ new Map();
 				const roots = /* @__PURE__ */ new Map();
+				/** The root each tab's store bucket belongs to; kept while a hold is released. */
+				const buckets = /* @__PURE__ */ new Map();
+				/** The record signal each tab's store bucket answers to. */
+				const bindings = /* @__PURE__ */ new Map();
 				const nextGeneration = (tabId, path) => {
 					const byPath = generations.get(tabId) ?? /* @__PURE__ */ new Map();
 					generations.set(tabId, byPath);
@@ -7765,6 +7796,39 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						return result.ok ? result.value : void 0;
 					});
 				};
+				const closeNode = (tabId) => {
+					const root = roots.get(tabId);
+					roots.delete(tabId);
+					generations.delete(tabId);
+					root?.close();
+				};
+				const forget = (tabId) => {
+					closeNode(tabId);
+					buckets.delete(tabId);
+					bindings.delete(tabId);
+					actions.forget(tabId);
+				};
+				const bindRecord = (tabId, signal) => {
+					if (bindings.get(tabId) === signal) return;
+					bindings.set(tabId, signal);
+					signal.addEventListener("abort", () => {
+						if (bindings.get(tabId) !== signal) return;
+						forget(tabId);
+					}, { once: true });
+				};
+				const open = (tabId, root, signal, restore, reset) => {
+					if (signal.aborted) return;
+					closeNode(tabId);
+					bindRecord(tabId, signal);
+					if (reset || buckets.get(tabId) !== root) {
+						actions.start(tabId, root);
+						buckets.set(tabId, root);
+						restore = [];
+					}
+					roots.set(tabId, new DirectoryNode(root, (path, lifetime) => load(tabId, path, lifetime), (path, lifetime) => watch(sessionId, path, lifetime), (path, error) => {
+						if (!signal.aborted) actions.failed(tabId, path, new RemoteError("gateway/internal", error instanceof Error ? error.message : String(error), {}));
+					}, signal, restore).open());
+				};
 				return {
 					refresh: (tabId) => {
 						roots.get(tabId)?.refreshTree();
@@ -7773,17 +7837,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						actions.autoRefresh(tabId, enabled);
 						roots.get(tabId)?.setAutomatic(enabled);
 					},
-					start(tabId, root, signal) {
-						actions.start(tabId, root);
-						signal.addEventListener("abort", () => {
-							roots.get(tabId)?.close();
-							roots.delete(tabId);
-							generations.delete(tabId);
-							actions.forget(tabId);
-						}, { once: true });
-						roots.set(tabId, new DirectoryNode(root, (path, lifetime) => load(tabId, path, lifetime), (path, lifetime) => watch(sessionId, path, lifetime), (path, error) => {
-							if (!signal.aborted) actions.failed(tabId, path, new RemoteError("gateway/internal", error instanceof Error ? error.message : String(error), {}));
-						}, signal).open());
+					start: (tabId, root, signal) => {
+						open(tabId, root, signal, [], true);
+					},
+					hold: (tabId, root, signal, restore = []) => {
+						open(tabId, root, signal, restore, false);
+					},
+					release: (tabId) => {
+						closeNode(tabId);
 					},
 					load: (tabId, path, signal) => {
 						load(tabId, path, signal);
@@ -8032,6 +8093,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		function encodePath(path) {
 			return path.split("/").map(encodeSegment).join("/");
 		}
+		/** Whether a decoded first path segment is a Windows drive (`C:`). */
+		function isDriveSegment(segment) {
+			return segment !== void 0 && /^[A-Za-z]:$/.test(segment);
+		}
 		/**
 		* Build the address of a file read through one Session.
 		* @param sessionId - the Session whose Host workspace resolves the path.
@@ -8043,6 +8108,44 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return `${FILE_ADDRESS_PREFIX}session/${encodeSegment(sessionId)}/${encodePath(normalized)}`;
 		}
 		/**
+		* Read a file address back into its parts without resolving `.` or `..`.
+		* Query and fragment suffixes are ignored; encoded path segments are decoded.
+		* @param address - a candidate address.
+		* @returns the parts, or `undefined` when the string is not a `dsh-resource://file/` URI in a known scope with a path, or a segment is not validly encoded.
+		*/
+		function parseFileAddress(address) {
+			try {
+				if (!address.startsWith(FILE_ADDRESS_PREFIX)) return void 0;
+				const end = address.search(/[?#]/);
+				const [scope, ...rest] = address.slice(20, end === -1 ? void 0 : end).split("/");
+				if (scope === "session") {
+					const [id, ...segments] = rest;
+					if (id === void 0 || id === "" || segments.length === 0) return void 0;
+					return {
+						scope,
+						sessionId: decodeURIComponent(id),
+						path: segments.map(decodeURIComponent).join("/")
+					};
+				}
+				if (scope === "absolute") {
+					const unc = rest[0] === "" && rest.length > 1;
+					const segments = (unc ? rest.slice(1) : rest).map(decodeURIComponent);
+					if (segments.length === 0 || segments[0] === "") return void 0;
+					if (unc) return {
+						scope,
+						path: `//${segments.join("/")}`
+					};
+					return {
+						scope,
+						path: isDriveSegment(segments[0]) ? segments.join("/") : `/${segments.join("/")}`
+					};
+				}
+				return;
+			} catch {
+				return;
+			}
+		}
+		/**
 		* Browser-safe Workspace path and display helpers.
 		* @module @deepseek-ai/dsh-util-workspace-path
 		*/
@@ -8077,6 +8180,110 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			return sessionFileAddress(sessionId, normalized);
 		}
 		//#endregion
+		//#region src/client/files-tree/locate.ts
+		/**
+		* Whether a root is a Windows drive or UNC path, in either separator
+		* spelling, where names compare regardless of case.
+		* @param root - the tree's root, or a prefix built from it.
+		* @returns `true` for a drive letter followed by a separator, or a leading
+		*   double separator.
+		*/
+		function windowsRoot(root) {
+			const path = root.replace(/\\/g, "/");
+			return /^[A-Za-z]:\//.test(path) || path.startsWith("//");
+		}
+		/**
+		* An absolute `/`-separated path relative to a tree's root.
+		* @param path - the absolute path, in either separator spelling.
+		* @param root - the tree's root, in either separator spelling.
+		* @returns the path under the root, or `undefined` outside it.
+		*/
+		function underRoot(path, root) {
+			const normalized = path.replace(/\\/g, "/");
+			const prefix = `${root.replace(/\\/g, "/").replace(/\/+$/, "")}/`;
+			const head = normalized.slice(0, prefix.length);
+			return (windowsRoot(prefix) ? head.toLowerCase() === prefix.toLowerCase() : head === prefix) ? normalized.slice(prefix.length) : void 0;
+		}
+		/**
+		* The workspace-relative path of a file under a tree's root, validated the
+		* way upstream's `relativeFileOf` tail validates it: nothing absolute, and
+		* no empty or dot segments.
+		* @param path - the file's absolute path, in either separator spelling.
+		* @param root - the root it must sit under.
+		* @returns the `/`-separated relative path, or `undefined` outside the root.
+		*/
+		function relativeUnderRoot(path, root) {
+			const normalized = underRoot(path, root);
+			if (normalized === void 0 || normalized === "" || /^([A-Za-z]:)?\//.test(normalized)) return void 0;
+			return normalized.split("/").some((part) => part === "" || part === "." || part === "..") ? void 0 : normalized;
+		}
+		/** One path's comparison spelling: separators unified, trailing slashes dropped. */
+		function normalized(path) {
+			return path.replace(/\\/g, "/").replace(/\/+$/, "");
+		}
+		/**
+		* The additional root that owns one absolute file path: available roots
+		* only, the longest matching root path winning when registrations nest.
+		* @param view - the session's registry view.
+		* @param path - the file's absolute path, in either separator spelling.
+		* @returns the owning root, or `undefined` when the file is outside every
+		*   available additional root (the primary root included).
+		*/
+		function rootForPath(view, path) {
+			let best;
+			const primary = view.primaryRoot === void 0 ? void 0 : normalized(view.primaryRoot);
+			for (const root of view.roots) {
+				if (root.state !== "available" || primary !== void 0 && normalized(root.path) === primary) continue;
+				if (underRoot(path, root.path) === void 0) continue;
+				if (best === void 0 || root.path.length > best.path.length) best = root;
+			}
+			return best;
+		}
+		/**
+		* Walk the listed levels to a workspace-relative file, keeping the listing's
+		* spelling of each name; a Windows root also matches names regardless of
+		* case. A verbatim port of upstream's navigator helper — the fork's
+		* `LevelState` carries no `refreshing` flag, so a stale level reports
+		* `pending: false` like a settled native one.
+		* @param tree - the tab's tree.
+		* @param relativePath - the file's path under the tree's root, `/`-separated.
+		* @returns the ancestors found so far, the file's tree key, and whether a
+		*   level is pending.
+		*/
+		function locateFile(tree, relativePath) {
+			const caseless = windowsRoot(tree.root);
+			const parts = relativePath.split("/");
+			const ancestors = [];
+			let parent = tree.root;
+			for (const [index, part] of parts.entries()) {
+				const level = tree.levels[parent];
+				if (level?.kind !== "ready") return {
+					ancestors,
+					current: void 0,
+					pending: level === void 0 || level.kind === "loading"
+				};
+				const type = index === parts.length - 1 ? "file" : "directory";
+				const candidates = level.level.entries.filter((entry) => entry.type === type);
+				const entry = candidates.find((candidate) => candidate.name === part) ?? (caseless ? candidates.find((candidate) => candidate.name.toLowerCase() === part.toLowerCase()) : void 0);
+				if (entry === void 0) return {
+					ancestors,
+					current: void 0,
+					pending: false
+				};
+				const path = childPath(parent, entry.name);
+				if (type === "directory") ancestors.push({
+					parent,
+					path
+				});
+				parent = path;
+			}
+			return {
+				ancestors,
+				current: parent,
+				pending: false
+			};
+		}
+		//#endregion
 		//#region src/client/files-tree/FilesBody.module.css.ts
 		/**
 		* Shim for the CSS-module virtual module `./FilesBody.module.css`.
@@ -8182,26 +8389,32 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					})]
 				});
 			}
-			if (entry.type === "file") return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
-				className: css$1.item,
-				"data-files-entry": "file",
-				"data-files-path": path,
-				children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
-					type: "button",
-					className: css$1.row,
-					onClick: () => {
-						tree.onOpen(path);
-					},
-					children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FileTypeIcon, {
-						kind: classifyFileType(entry.name),
-						size: 16,
-						className: css$1.fileIcon
-					}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
-						className: css$1.name,
-						children: entry.name
-					})]
-				})
-			});
+			if (entry.type === "file") {
+				const current = tree.current === path;
+				return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
+					className: css$1.item,
+					"data-files-entry": "file",
+					"data-files-path": path,
+					children: /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("button", {
+						type: "button",
+						className: css$1.row,
+						onClick: () => {
+							tree.onOpen(path);
+						},
+						ref: current ? tree.currentRef : void 0,
+						"data-files-current": current ? "" : void 0,
+						"aria-current": current ? true : void 0,
+						children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FileTypeIcon, {
+							kind: classifyFileType(entry.name),
+							size: 16,
+							className: css$1.fileIcon
+						}), /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+							className: css$1.name,
+							children: entry.name
+						})]
+					})
+				});
+			}
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("li", {
 				className: css$1.item,
 				"data-files-entry": "other",
@@ -8261,46 +8474,181 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		* has opened under it — the upstream body's scroll, seed, and render logic
 		* verbatim, with the root arriving as a prop instead of `useSessions(cwd)`.
 		*/
-		function FilesTree({ tabId, sessionId, root, signal, useStore, actions, start, toggle, onOpen, t, nativeTree }) {
+		function FilesTree({ tabId, sessionId, root, signal, useStore, actions, hold, release, toggle, onOpen, t, nativeTree, reveal, saved, onScrollOffset }) {
 			const state = useStore((store) => store.byTab[tabId]);
 			const bodyRef = (0, react.useRef)(null);
 			const scrollTopRef = (0, react.useRef)(0);
+			const [current, setCurrent] = (0, react.useState)(void 0);
+			const walk = (0, react.useRef)({
+				key: void 0,
+				settled: false,
+				canceled: false
+			});
+			const revealSeed = (0, react.useRef)(saved?.revealed);
+			const seededKey = (0, react.useRef)(void 0);
+			const wantScroll = (0, react.useRef)(false);
+			const currentRef = (0, react.useCallback)((row) => {
+				if (row instanceof HTMLElement && wantScroll.current) {
+					wantScroll.current = false;
+					row.scrollIntoView({
+						block: "nearest",
+						inline: "nearest"
+					});
+				}
+			}, []);
+			const revealPath = reveal?.path;
+			const revealSaved = saved?.revealed;
+			const revealOnSettled = reveal?.onSettled;
+			const revealKey = revealPath === void 0 || state === void 0 ? void 0 : JSON.stringify([state.root, revealPath]);
+			(0, react.useEffect)(() => {
+				if (revealPath === void 0 || revealKey === void 0 || state === void 0 || signal.aborted) {
+					seededKey.current = void 0;
+					setCurrent(void 0);
+					return;
+				}
+				if (walk.current.key !== revealKey || seededKey.current !== revealKey) {
+					walk.current = {
+						key: revealKey,
+						settled: false,
+						canceled: false
+					};
+					revealSeed.current = revealSaved;
+					seededKey.current = revealKey;
+					wantScroll.current = false;
+				}
+				const relative = relativeUnderRoot(revealPath, state.root);
+				if (relative === void 0) {
+					setCurrent(void 0);
+					return;
+				}
+				const location = locateFile(state, relative);
+				if (walk.current.settled || walk.current.canceled || revealSeed.current === revealPath) {
+					setCurrent(location?.current);
+					return;
+				}
+				const next = location?.ancestors.find((ancestor) => !state.expanded.includes(ancestor.path));
+				if (location !== void 0 && next !== void 0) {
+					toggle(tabId, next.parent, next.path, state.expanded, signal);
+					setCurrent(void 0);
+					return;
+				}
+				if (location?.pending === true) return;
+				walk.current.settled = true;
+				revealSeed.current = void 0;
+				revealOnSettled?.(revealPath);
+				if (location?.current !== void 0) wantScroll.current = true;
+				setCurrent(location?.current);
+			}, [
+				revealKey,
+				state,
+				tabId,
+				signal,
+				toggle,
+				revealPath,
+				revealOnSettled,
+				revealSaved
+			]);
+			const pendingScroll = (0, react.useRef)(0);
+			const stateRef = (0, react.useRef)(state);
+			const savedRef = (0, react.useRef)(saved);
+			(0, react.useLayoutEffect)(() => {
+				stateRef.current = state;
+				savedRef.current = saved;
+			});
 			const seeded = state !== void 0;
 			(0, react.useLayoutEffect)(() => {
 				const body = bodyRef.current;
 				if (seeded && body !== null) {
 					body.scrollTop = state.scrollTop;
 					scrollTopRef.current = body.scrollTop;
+					if ((body.parentElement?.querySelector("[data-files-body]"))?.contains(body.ownerDocument.activeElement) === true) body.focus();
 				}
 			}, [seeded]);
+			(0, react.useLayoutEffect)(() => {
+				const body = bodyRef.current;
+				if (body === null || pendingScroll.current <= 0) return;
+				const seededIdentity = seededKey.current === revealKey;
+				const seed = seededIdentity ? revealSeed.current : revealSaved;
+				const inFlight = revealPath !== void 0 && !(seededIdentity && (walk.current.settled || walk.current.canceled)) && seed !== revealPath;
+				if (inFlight || body.scrollHeight > body.clientHeight) {
+					if (!inFlight) {
+						body.scrollTop = pendingScroll.current;
+						scrollTopRef.current = body.scrollTop;
+					}
+					pendingScroll.current = 0;
+				}
+			});
+			(0, react.useLayoutEffect)(() => {
+				const body = bodyRef.current;
+				if (body === null) return;
+				const scroll = () => {
+					if (body.scrollTop !== scrollTopRef.current && pendingScroll.current > 0) pendingScroll.current = 0;
+					scrollTopRef.current = body.scrollTop;
+					onScrollOffset?.(scrollTopRef.current);
+				};
+				body.addEventListener("scroll", scroll, { passive: true });
+				return () => {
+					body.removeEventListener("scroll", scroll);
+				};
+			}, [seeded, onScrollOffset]);
 			(0, react.useEffect)(() => () => {
 				if (seeded && !signal.aborted) actions.scrolled(tabId, scrollTopRef.current);
+				onScrollOffset?.(scrollTopRef.current);
 			}, [
 				seeded,
 				signal,
 				tabId,
-				actions
+				actions,
+				onScrollOffset
 			]);
 			(0, react.useEffect)(() => {
-				if (state !== void 0 || signal.aborted) return;
-				start(tabId, root, signal);
+				if (signal.aborted) return;
+				const current = stateRef.current;
+				const resumed = current !== void 0 && current.root === root;
+				hold(tabId, root, signal, resumed ? current.expanded : void 0);
+				if (!resumed) {
+					const snapshot = savedRef.current;
+					if (snapshot?.expanded !== void 0) for (const path of snapshot.expanded) {
+						if (path === root || relativeUnderRoot(path, root) === void 0) continue;
+						toggle(tabId, path.slice(0, path.lastIndexOf("/")), path, snapshot.expanded.filter((value) => value !== path), signal);
+					}
+					if (snapshot?.scrollTop !== void 0) pendingScroll.current = snapshot.scrollTop;
+				}
+				return () => {
+					release(tabId);
+				};
 			}, [
-				state,
 				root,
 				tabId,
 				signal,
-				start
+				hold,
+				release,
+				toggle
 			]);
 			if (state === void 0) return null;
 			const tree = {
 				state,
 				onToggle: (parent, path) => {
+					const seededIdentity = seededKey.current === revealKey;
+					const seed = seededIdentity ? revealSeed.current : revealSaved;
+					if (revealPath !== void 0 && revealKey !== void 0 && seed !== revealPath && state.expanded.includes(path) && (!seededIdentity || !walk.current.settled && !walk.current.canceled)) {
+						if (!seededIdentity) walk.current = {
+							key: revealKey,
+							settled: false,
+							canceled: true
+						};
+						else walk.current.canceled = true;
+						revealSeed.current = void 0;
+						revealOnSettled?.(revealPath);
+					}
 					toggle(tabId, parent, path, state.expanded, signal);
 				},
 				onOpen: (path) => {
 					onOpen(fileAddressFor(sessionId, void 0, path));
 				},
-				t
+				t,
+				current,
+				currentRef
 			};
 			const legacy = /* @__PURE__ */ (0, react_jsx_runtime.jsx)("ul", {
 				className: css$1.level,
@@ -8309,13 +8657,14 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					tree
 				})
 			});
-			const content = nativeTree === void 0 ? legacy : nativeTree("sidebar.files.tree", nativeTreeInput(state, (failure) => failureLine(t, failure), tree.onToggle, tree.onOpen), { fallback: legacy });
+			const content = nativeTree === void 0 ? legacy : nativeTree("sidebar.files.tree", nativeTreeInput(state, (failure) => failureLine(t, failure), tree.onToggle, tree.onOpen, current === void 0 ? void 0 : {
+				path: current,
+				ref: currentRef
+			}), { fallback: legacy });
 			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
 				ref: bodyRef,
 				className: css$1.body,
-				onScroll: (event) => {
-					scrollTopRef.current = event.currentTarget.scrollTop;
-				},
+				tabIndex: -1,
 				children: content
 			});
 		}
@@ -8395,9 +8744,10 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		/**
 		* The registration's `store`/`inject` declarations, built once in `apply`.
 		*
-		* The inject face nests the verbatim files face under `face` and adds the
-		* session-bound `openFile` — keeping `FilesInjected` untouched means the
-		* fork's call sites and the sync diff stay upstream-shaped.
+		* The inject face nests the files face under `face` and adds the
+		* session-bound `openFile`; the fork's call sites stay upstream-shaped, the
+		* one lifecycle delta being the hold/release pair the preview navigator needs
+		* (see FORK.md).
 		* @param ctx - the client root context (the remote/sidebarRight lookups).
 		* @returns the store handle and the inject factory for `register`.
 		*/
@@ -8408,17 +8758,47 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			const inject = (sessionId, actions) => {
 				const selection = (0, _deepseek_ai_dsh_client_store.createSnapshotStore)({});
 				const takeovers = /* @__PURE__ */ new Map();
-				const endTakeover = (tabId) => {
-					const held = takeovers.get(tabId);
-					held?.observer?.disconnect();
-					held?.controller.abort();
-					takeovers.delete(tabId);
+				const savedTrees = /* @__PURE__ */ new Map();
+				const watchers = /* @__PURE__ */ new Map();
+				let watcherObserver;
+				const endTakeover = (key, dropSaved = false) => {
+					takeovers.get(key)?.controller.abort();
+					takeovers.delete(key);
+					if (dropSaved) savedTrees.delete(key);
+				};
+				const dropDeadOwners = () => {
+					for (const [key, alive] of watchers) if (!alive()) {
+						watchers.delete(key);
+						endTakeover(key, true);
+					}
+					if (watchers.size === 0) {
+						watcherObserver?.disconnect();
+						watcherObserver = void 0;
+					}
+				};
+				const armDeathWatch = (key, alive) => {
+					watchers.set(key, alive);
+					if (watcherObserver === void 0) {
+						watcherObserver = new MutationObserver((mutations) => {
+							if (mutations.some((mutation) => mutation.type === "attributes" || mutation.addedNodes.length !== 0 || mutation.removedNodes.length !== 0)) dropDeadOwners();
+						});
+						watcherObserver.observe(document, {
+							childList: true,
+							subtree: true,
+							attributes: true,
+							attributeFilter: ["data-dockkit-pane", "data-dockkit-float"]
+						});
+					}
+					dropDeadOwners();
 				};
 				return {
 					face: face(sessionId, actions),
 					openFile: (address) => {
 						ctx.get("sidebarRight")?.openResourceIn?.(sessionId, address);
 					},
+					openFileIn: (tabId, address) => {
+						ctx.get("sidebarRight")?.openResourceIn?.(sessionId, address, { replaceTab: tabId });
+					},
 					hooks: { treeSelection: selection },
 					selectRoot: (tabId, root) => {
 						const next = { ...selection.getSnapshot() };
@@ -8427,34 +8807,37 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 						selection.set(next);
 					},
 					takeover: {
-						signal: (tabId, root, section) => {
-							let held = takeovers.get(tabId);
+						signal: (key, root, section) => {
+							let held = takeovers.get(key);
 							if (held === void 0 || held.root !== root || held.controller.signal.aborted) {
-								held?.observer?.disconnect();
 								held?.controller.abort();
 								held = {
 									controller: new AbortController(),
-									root,
-									section: void 0,
-									observer: void 0
+									root
 								};
-								takeovers.set(tabId, held);
+								takeovers.set(key, held);
 							}
-							if (section !== void 0 && held.section !== section) {
-								held.section = section;
-								held.observer?.disconnect();
-								held.observer = new MutationObserver(() => {
-									if (!section.isConnected) endTakeover(tabId);
-								});
-								held.observer.observe(document, {
-									childList: true,
-									subtree: true
-								});
-							}
-							if (held.section !== void 0 && !held.section.isConnected) endTakeover(tabId);
+							if (section !== void 0) armDeathWatch(key, typeof section === "function" ? section : () => section.isConnected);
 							return held.controller.signal;
 						},
-						end: endTakeover
+						end: (key) => {
+							endTakeover(key);
+						},
+						saved: (key, root) => savedTrees.get(key)?.get(root),
+						save: (key, snapshot) => {
+							if (!takeovers.has(key) && !watchers.has(key)) return;
+							let perRoot = savedTrees.get(key);
+							if (perRoot === void 0) savedTrees.set(key, perRoot = /* @__PURE__ */ new Map());
+							const previous = perRoot.get(snapshot.root);
+							const merged = { root: snapshot.root };
+							const expanded = snapshot.expanded ?? previous?.expanded;
+							const scrollTop = snapshot.scrollTop ?? previous?.scrollTop;
+							const revealed = snapshot.revealed ?? previous?.revealed;
+							if (expanded !== void 0) merged.expanded = expanded;
+							if (scrollTop !== void 0) merged.scrollTop = scrollTop;
+							if (revealed !== void 0) merged.revealed = revealed;
+							perRoot.set(snapshot.root, merged);
+						}
 					}
 				};
 			};
@@ -8474,14 +8857,15 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 		*/
 		function createFilesTreeSurface(props, t) {
 			if (!filesTreeSurfaceSupported()) return void 0;
-			const { sessionId, useStore, actions, face, openFile, useTreeSelection, selectRoot, takeover } = props;
-			if (face === void 0 || openFile === void 0 || useStore === void 0 || actions === void 0 || useTreeSelection === void 0 || selectRoot === void 0 || takeover === void 0) return void 0;
+			const { sessionId, useStore, actions, face, openFile, openFileIn, useTreeSelection, selectRoot, takeover } = props;
+			if (face === void 0 || openFile === void 0 || openFileIn === void 0 || useStore === void 0 || actions === void 0 || useTreeSelection === void 0 || selectRoot === void 0 || takeover === void 0) return void 0;
 			return {
 				sessionId,
 				useStore,
 				actions,
 				face,
 				openFile,
+				openFileIn,
 				useTreeSelection,
 				selectRoot,
 				takeover,
@@ -10373,7 +10757,8 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					signal: takeover.signal,
 					useStore: filesTree.useStore,
 					actions: filesTree.actions,
-					start: filesTree.face.start,
+					hold: filesTree.face.hold,
+					release: filesTree.face.release,
 					toggle: filesTree.face.toggle,
 					onOpen: filesTree.openFile,
 					t: filesTree.t,
@@ -10393,9 +10778,293 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 			] });
 		}
 		//#endregion
+		//#region src/client/files-tree/navigator.tsx
+		/**
+		* The document-preview navigator's additional-root retarget.
+		*
+		* Upstream's `sidebar.files.navigator` Factory (`ui-sidebar-files`, added at
+		* `0.2.2-alpha.3`) is the Folder-toggle tree the document preview draws
+		* beside its body. Its root is hard-wired to the session's `cwd` — the
+		* previewed file's absolute path is located against that root, so a file
+		* that lives under an additional root lands outside every tree it can draw:
+		* the navigator opens on the primary root, unexpanded and unmarked.
+		*
+		* The Factory itself cannot be retargeted — it is a registration upstream
+		* already owns, and its root is not an input. What CAN move is what its
+		* `aside[data-files-navigator]` draws: this occupant mounts in the preview
+		* header's `sidebar.right.tab.document.actions` seat (owner prop
+		* `absolutePath` — the previewed file's host path), watches the preview's
+		* `[data-textpreview-content]` row for the aside, and when the file sits
+		* under an available additional root it lends the aside's body area to the
+		* forked tree, the same takeover the Files page's root switcher performs.
+		* The aside itself — its width, its push/overlay/fill modes, its resize
+		* separator — stays native; only the tree inside is the fork's.
+		*
+		* Everything is keyed by the dockkit PANE id (`data-files-navigator` on the
+		* aside, `data-dockkit-pane` on the content section), never by the preview
+		* tab: upstream's navigator records live in `store.byPane`, and the pane
+		* survives what the tab does not — `replaceTab` mints a fresh tab id, so
+		* opening a file from the retargeted tree destroys the preview tab that
+		* opened it. The inject-side takeover map holds the pane-record memory
+		* (`expanded`/`scrollTop`/`revealed`) across that death; the component's
+		* own refs only ever carry the live copy.
+		*
+		* Three upstream behaviors are reproduced, not approximated:
+		*
+		* - **Hold lifetime.** The native navigator holds its pane tree only while
+		*   it is open (`hold(paneId, cwd)` gated on `state.open`): closing the
+		*   navigator closes the directory node — watches and listings end — while
+		*   the pane record keeps `expanded`/`scrollTop`/`revealed` for the next
+		*   open. Here the takeover `signal` is requested when the aside appears
+		*   and ended when it leaves. The saved snapshot is written into the
+		*   inject-side map continuously — the bucket's expansion set mirrors into
+		*   it, the forked body reports its live scroll offset, and a settled
+		*   reveal records its file — so no cleanup ordering ever decides what is
+		*   remembered. A dockkit pane has no stable element (a non-empty pane's
+		*   id rides on its selected tab's host, which `replaceTab` swaps out), so
+		*   the owner's death is checked by query: the pane lives while some
+		*   connected element still carries its id, and the watch that drops the
+		*   memory outlives every `end` because the body's cleanup always wins
+		*   the unmount race.
+		* - **Reveal.** The native navigator seeds `pane.revealing` with the drawn
+		*   file's address — unless `pane.revealed` already names it — and steps
+		*   the walk open (ancestors expanded one listing at a time, then the
+		*   file's row marked current and scrolled into view). The forked tree's
+		*   `reveal` prop drives the same sequence against the additional root,
+		*   with the saved `revealed` suppressing a repeat of a completed walk, so
+		*   collapsing a directory and reopening the navigator keeps the reader's
+		*   collapse exactly as upstream's pane record does.
+		* - **Replace-tab open.** The native navigator's `onOpen` is
+		*   `tab.actions.openResource(address, { replaceTab: true })` — the opened
+		*   file takes the preview's own tab. The forked tree's opens route through
+		*   `openFileIn`, which spells the same intent to `openResourceIn` as
+		*   `{ replaceTab: tabId }` against the preview's dockkit tab id.
+		*
+		* Every step degrades silently: no `[data-textpreview-url]` ancestor, no
+		* dockkit pane id, no `panel`, an address that is not a session file of
+		* THIS session, a file outside every available additional root (the
+		* primary root's own files included), or a fork that cannot render — each
+		* leaves the native navigator completely untouched. Where the upstream
+		* hooks do not exist (a runtime without this navigator), the marker span
+		* is the only trace the occupant leaves, and it draws nothing.
+		*
+		* @module @dsh-electron/dsh-plugin-multi-root-workspace/client/files-tree/navigator
+		*/
+		/**
+		* A dockkit pane has no stable element: a non-empty pane's id rides on its
+		* SELECTED tab's host (`data-dockkit-pane`), an empty pane's on its
+		* `TabPanel`, and a floating pane's host carries `data-dockkit-float` —
+		* `replaceTab` swaps the host while the pane lives on. The owner is
+		* therefore alive while some connected element still carries its id.
+		* @param id - the dockkit pane id the aside announced.
+		* @returns whether the document still contains a carrier of the id.
+		*/
+		function paneAlive(id) {
+			for (const element of document.querySelectorAll("[data-dockkit-pane],[data-dockkit-float]")) if (element.dataset.dockkitPane === id || element.dataset.dockkitFloat === id) return true;
+			return false;
+		}
+		/**
+		* The marker that lives in the preview header and, while the file it names
+		* sits under an additional root, lends the navigator aside to the forked
+		* tree. It draws nothing of its own.
+		*/
+		function NavigatorRetarget(props) {
+			const { absolutePath, sessionId, panel, filesTree } = props;
+			const anchorRef = (0, react.useRef)(null);
+			const sectionRef = (0, react.useRef)(null);
+			const fallbackPaneId = (0, react.useRef)(void 0);
+			const paneIdentified = (0, react.useRef)(false);
+			const mounted = (0, react.useRef)(true);
+			const [preview, setPreview] = (0, react.useState)(null);
+			const [tabId, setTabId] = (0, react.useState)(void 0);
+			const [aside, setAside] = (0, react.useState)(null);
+			const [paneId, setPaneId] = (0, react.useState)(void 0);
+			const [root, setRoot] = (0, react.useState)(void 0);
+			const [resolvedPath, setResolvedPath] = (0, react.useState)(void 0);
+			const [takeover, setTakeover] = (0, react.useState)(null);
+			(0, react.useEffect)(() => {
+				mounted.current = true;
+				return () => {
+					mounted.current = false;
+				};
+			}, []);
+			(0, react.useEffect)(() => {
+				const anchor = anchorRef.current;
+				const previewEl = anchor?.closest("[data-textpreview-url]") ?? null;
+				sectionRef.current = anchor?.closest("[data-dockkit-content]") ?? null;
+				const content = sectionRef.current?.dataset.dockkitContent;
+				setTabId(content !== void 0 && content !== "" ? content : fallbackPaneId.current ??= `mrfw-nav-${Math.random().toString(36).slice(2)}`);
+				setPreview(previewEl);
+			}, []);
+			const asideRef = (0, react.useRef)(null);
+			(0, react.useEffect)(() => {
+				if (preview === null) {
+					setAside(null);
+					return;
+				}
+				const content = preview.querySelector("[data-textpreview-content]") ?? preview;
+				const query = () => {
+					const current = asideRef.current;
+					if (current !== null && current.isConnected) return;
+					const found = content.querySelector("aside[data-files-navigator]");
+					if (found !== current) {
+						asideRef.current = found;
+						setAside(found);
+					}
+				};
+				query();
+				const observer = new MutationObserver(query);
+				observer.observe(content, {
+					childList: true,
+					subtree: true
+				});
+				return () => {
+					observer.disconnect();
+					asideRef.current = null;
+				};
+			}, [preview]);
+			(0, react.useEffect)(() => {
+				if (aside === null) return;
+				const read = () => {
+					const identified = aside.dataset.filesNavigator ?? sectionRef.current?.dataset.dockkitPane;
+					paneIdentified.current = identified !== void 0 && identified !== "";
+					setPaneId(identified !== void 0 && identified !== "" ? identified : fallbackPaneId.current ??= `mrfw-nav-${Math.random().toString(36).slice(2)}`);
+				};
+				read();
+				const observer = new MutationObserver(read);
+				observer.observe(aside, {
+					attributes: true,
+					attributeFilter: ["data-files-navigator"]
+				});
+				const section = sectionRef.current;
+				if (section !== null) observer.observe(section, {
+					attributes: true,
+					attributeFilter: ["data-dockkit-pane"]
+				});
+				return () => {
+					observer.disconnect();
+				};
+			}, [aside]);
+			(0, react.useEffect)(() => {
+				if (preview === null || aside === null || sessionId === void 0 || sessionId === "" || panel === void 0) {
+					setRoot(void 0);
+					setResolvedPath(void 0);
+					return;
+				}
+				const address = preview.dataset.textpreviewUrl === void 0 ? void 0 : parseFileAddress(preview.dataset.textpreviewUrl);
+				if (address?.scope !== "session" || address.sessionId !== sessionId) {
+					setRoot(void 0);
+					setResolvedPath(void 0);
+					return;
+				}
+				const path = absolutePath;
+				const controller = new AbortController();
+				panel.call("list", { sessionId }, controller.signal).then((view) => {
+					if (controller.signal.aborted || !mounted.current) return;
+					setRoot(rootForPath(view, path));
+					setResolvedPath(path);
+				}).catch(() => {
+					if (controller.signal.aborted || !mounted.current) return;
+					setRoot(void 0);
+					setResolvedPath(path);
+				});
+				return () => {
+					controller.abort();
+				};
+			}, [
+				preview,
+				aside,
+				sessionId,
+				panel,
+				absolutePath
+			]);
+			const rootPath = root?.path;
+			const takeoverCtl = filesTree.takeover;
+			const bucket = filesTree.useStore((store) => paneId === void 0 ? void 0 : store.byTab[paneId]);
+			(0, react.useEffect)(() => {
+				if (bucket !== void 0 && takeover !== null && takeover.paneId === paneId && takeover.root === rootPath) takeoverCtl.save(takeover.paneId, {
+					root: takeover.root,
+					expanded: bucket.expanded
+				});
+			}, [
+				bucket,
+				takeover,
+				paneId,
+				rootPath,
+				takeoverCtl
+			]);
+			const onScrollOffset = (0, react.useCallback)((offset) => {
+				if (takeover !== null) takeoverCtl.save(takeover.paneId, {
+					root: takeover.root,
+					scrollTop: offset
+				});
+			}, [takeover, takeoverCtl]);
+			const savedTree = takeover === null ? void 0 : takeoverCtl.saved(takeover.paneId, takeover.root);
+			(0, react.useEffect)(() => {
+				if (aside === null || rootPath === void 0 || paneId === void 0 || takeoverCtl === void 0) {
+					setTakeover(null);
+					return;
+				}
+				setTakeover({
+					signal: takeoverCtl.signal(paneId, rootPath, paneIdentified.current ? () => paneAlive(paneId) : void 0),
+					paneId,
+					root: rootPath
+				});
+				aside.setAttribute("data-mrfw-navigator", "");
+				const capturedPaneId = paneId;
+				const identified = paneIdentified.current;
+				return () => {
+					aside.removeAttribute("data-mrfw-navigator");
+					if (!identified) takeoverCtl.end(capturedPaneId);
+				};
+			}, [
+				aside,
+				rootPath,
+				paneId,
+				takeoverCtl
+			]);
+			const onRevealSettled = (0, react.useCallback)((path) => {
+				if (takeover !== null) takeoverCtl.save(takeover.paneId, {
+					root: takeover.root,
+					revealed: path
+				});
+			}, [takeover, takeoverCtl]);
+			const revealLive = takeover !== null && rootPath !== void 0 && resolvedPath === absolutePath && takeover.root === rootPath;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)(react_jsx_runtime.Fragment, { children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				ref: anchorRef,
+				"data-mrfw-navigator-anchor": true,
+				style: { display: "none" }
+			}), aside !== null && takeover !== null ? (0, react_dom.createPortal)(/* @__PURE__ */ (0, react_jsx_runtime.jsx)(FilesTree, {
+				tabId: takeover.paneId,
+				sessionId: filesTree.sessionId,
+				root: takeover.root,
+				signal: takeover.signal,
+				useStore: filesTree.useStore,
+				actions: filesTree.actions,
+				hold: filesTree.face.hold,
+				release: filesTree.face.release,
+				toggle: filesTree.face.toggle,
+				onOpen: (address) => {
+					if (tabId === void 0) filesTree.openFile(address);
+					else filesTree.openFileIn(tabId, address);
+				},
+				t: filesTree.t,
+				nativeTree: props.nativeTree,
+				onScrollOffset,
+				reveal: revealLive ? {
+					path: absolutePath,
+					revealed: savedTree?.revealed,
+					onSettled: onRevealSettled
+				} : void 0,
+				saved: savedTree
+			}), aside) : null] });
+		}
+		//#endregion
 		//#region src/client/index.ts
 		/** The footer-action cell this plugin owns. */
 		const SLOT_ID = "multi-root-folders";
+		/** The document-preview navigator retarget's occupant id. */
+		const NAVIGATOR_SLOT_ID = "multi-root-navigator";
 		/** The id of the `<style>` element carrying this plugin's sheet. */
 		const STYLE_ELEMENT_ID = "multi-root-workspace-styles";
 		/** Services the client half needs before it may activate. */
@@ -10504,6 +11173,24 @@ Set the \`cycles\` parameter to \`"ref"\` to resolve cyclical schemas with defs.
 					nativeTree: nativeTreeRenderer(props.renderFactorySlot)
 				});
 			}));
+			ctx.slots.inject("sidebar.right.tab.document.actions", () => ctx.slots.register({
+				name: "sidebar.right.tab.document.actions",
+				id: NAVIGATOR_SLOT_ID,
+				order: 50,
+				store: filesTreeSeats.store,
+				inject: filesTreeSeats.inject
+			}, function DocumentActionsOccupant(props) {
+				const absolutePath = props?.absolutePath;
+				const filesTree = createFilesTreeSurface(props, filesTreeT);
+				if (absolutePath === void 0 || filesTree === void 0) return null;
+				return (0, react.createElement)(NavigatorRetarget, {
+					absolutePath,
+					sessionId: props?.sessionId,
+					panel,
+					filesTree,
+					nativeTree: nativeTreeRenderer(props.renderFactorySlot)
+				});
+			}));
 		}
 		/**
 		* Read one optional service by name.