@mcp-b/react-components 0.14.2 → 0.16.0

package/dist/components/WorkspaceExplorer.d.ts

@@ -1,100 +1,33 @@
-import { A as CodeBlockLanguage } from "../CodeBlock-DUh9WOGo.js";
+import { a as WorkspaceFileLinkProps, c as WorkspaceLinkResolution, d as WorkspaceNavigationProvider, f as WorkspaceNavigationProviderProps, i as WorkspaceFileLink, l as WorkspaceNavigationAdapter, n as WorkspaceDestination, o as WorkspaceInvalidDestination, p as resolveWorkspaceLink, r as WorkspaceExternalDestination, s as WorkspaceLinkBase, t as ResolveWorkspaceLinkOptions, u as WorkspaceNavigationEntry } from "../WorkspaceLink-DK1DWMHe.js";
+import { a as WorkspaceMediaInfo, c as WorkspaceMediaTrackKind, d as inferWorkspaceLanguage, f as inferWorkspaceMedia, g as parseWorkspaceSkill, h as isWorkspaceSkillPath, i as WorkspaceFileState, l as WorkspaceSkillDocument, m as isWorkspaceMediaPath, n as WorkspaceFileAssetRequest, o as WorkspaceMediaKind, p as isWorkspaceMarkdownPath, r as WorkspaceFileAssetResolver, s as WorkspaceMediaTrack, t as WorkspaceFileAsset } from "../WorkspaceFile-DOZkPwzu.js";
+import { a as useWorkspace, i as WorkspaceState, n as WorkspaceInfo, r as WorkspaceSource, t as UseWorkspaceOptions } from "../Workspace-D39LxGvP.js";
 import * as React from "react";
-import { FileInfo, Workspace } from "@cloudflare/shell";
 
 //#region src/components/WorkspaceExplorer.d.ts
-/** Workspace summary, as returned by `Workspace.getWorkspaceInfo()` upstream. */
-type WorkspaceInfo = Awaited<ReturnType<Workspace["getWorkspaceInfo"]>>;
-/**
- * What the explorer actually calls: `readDir` and `readFile`, plus
- * `getWorkspaceInfo` for the header's file-count chip when available. A full
- * `Workspace` from `@cloudflare/shell`, Think's `WorkspaceLike`, or any
- * cross-DO RPC proxy exposing these methods satisfies it.
- */
-type WorkspaceSource = Pick<Workspace, "readDir" | "readFile"> & Partial<Pick<Workspace, "getWorkspaceInfo">>;
-interface UseWorkspaceOptions {
-  /** Must be referentially stable (memoize in the app) — a new source resets the workspace. */
-  source: WorkspaceSource;
-  /** Root directory to list first. Defaults to "/". */
-  root?: string;
-}
-interface WorkspaceFileState {
-  path: string;
-  name: string;
-  /** `null` means the file is missing or binary, matching upstream `readFile`. */
-  content: string | null;
-  error: string | null;
-}
-interface WorkspaceState {
-  root: string;
-  /** Loaded directory listings, keyed by directory path. */
-  entriesByDirectory: Readonly<Record<string, readonly FileInfo[]>>;
-  /** Every loaded entry, keyed by its path. */
-  entryByPath: ReadonlyMap<string, FileInfo>;
-  expandedPaths: ReadonlySet<string>;
-  /** Update expansion; newly expanded directories load lazily. */
-  setExpandedPaths: (next: Set<string>) => void;
-  selectedPath: string | null;
-  /** Select a file and load its content (cached after the first read). */
-  selectFile: (path: string | null) => void;
-  /** The selected file once its read settles; null while loading. */
-  selectedFile: WorkspaceFileState | null;
-  /** Root listing in flight. */
-  isLoading: boolean;
-  /** Directory and file paths with a request in flight. */
-  loadingPaths: ReadonlySet<string>;
-  /** Root/directory listing failure. Per-file read errors live on the file state. */
-  error: string | null;
-  /** Workspace summary, when the source provides `getWorkspaceInfo`. */
-  info: WorkspaceInfo | null;
-  /** Reload the root, every expanded directory, and the selected file. */
-  refresh: () => void;
-}
-/**
- * Headless state for browsing a Think workspace: lazy directory loading,
- * cached file reads, expansion/selection, and refresh. Feed the result to
- * `WorkspaceExplorer`, or render your own UI from it.
- */
-declare function useWorkspace({
-  source,
-  root
-}: UseWorkspaceOptions): WorkspaceState;
-/** Best-effort syntax-highlighting language from a file path; unknown extensions render as plain text. */
-declare function inferWorkspaceLanguage(path: string): CodeBlockLanguage;
 interface WorkspaceExplorerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "title"> {
   workspace: WorkspaceState;
+  /** Host-owned URL/history adapter shared by chat links and the file explorer. */
+  navigation: WorkspaceNavigationAdapter;
   /** Header label. Defaults to "Workspace". */
   title?: React.ReactNode;
+  /** Leading workspace control, such as a host-owned Back to chat button. */
+  leading?: React.ReactNode;
   /** Extra header actions, rendered next to the built-in refresh button. */
   actions?: React.ReactNode;
-  /** Hide the file filter input. */
+  /** Show the file filter input. Hidden by default to keep the browser compact. */
   showFilter?: boolean;
   filterPlaceholder?: string;
   emptyState?: React.ReactNode;
 }
 /**
- * A Think workspace file browser with a preview pane: lazy directory tree,
- * filter, refresh, and syntax-highlighted file view with copy. Drive it with
- * `useWorkspace(source)`.
- *
- * @example
- * ```tsx
- * const workspace = useWorkspace({ source: agent.workspace, root: "/workspace" });
- * <WorkspaceExplorer workspace={workspace} />
- * ```
+ * Convenience workspace application composed from `WorkspaceBrowser` and
+ * `WorkspaceFileView`. The host adapter owns URLs and history; the explorer
+ * only restores presentation state for stable navigation entry keys.
  */
 declare function WorkspaceExplorer({
-  workspace,
-  className,
-  title,
-  actions,
-  showFilter,
-  filterPlaceholder,
-  emptyState,
-  ref,
   ...props
 }: WorkspaceExplorerProps & {
   ref?: React.Ref<HTMLDivElement>;
 }): React.JSX.Element;
 //#endregion
-export { type FileInfo, UseWorkspaceOptions, WorkspaceExplorer, WorkspaceExplorerProps, WorkspaceFileState, WorkspaceInfo, WorkspaceSource, WorkspaceState, inferWorkspaceLanguage, useWorkspace };
+export { type ResolveWorkspaceLinkOptions, type UseWorkspaceOptions, type WorkspaceDestination, WorkspaceExplorer, WorkspaceExplorerProps, type WorkspaceExternalDestination, type WorkspaceFileAsset, type WorkspaceFileAssetRequest, type WorkspaceFileAssetResolver, WorkspaceFileLink, type WorkspaceFileLinkProps, type WorkspaceFileState, type WorkspaceInfo, type WorkspaceInvalidDestination, type WorkspaceLinkBase, type WorkspaceLinkResolution, type WorkspaceMediaInfo, type WorkspaceMediaKind, type WorkspaceMediaTrack, type WorkspaceMediaTrackKind, type WorkspaceNavigationAdapter, type WorkspaceNavigationEntry, WorkspaceNavigationProvider, type WorkspaceNavigationProviderProps, type WorkspaceSkillDocument, type WorkspaceSource, type WorkspaceState, inferWorkspaceLanguage, inferWorkspaceMedia, isWorkspaceMarkdownPath, isWorkspaceMediaPath, isWorkspaceSkillPath, parseWorkspaceSkill, resolveWorkspaceLink, useWorkspace };

package/dist/components/WorkspaceExplorer.js

@@ -1,355 +1,141 @@
 import { t as cx } from "../class-names-9UtZwb0J.js";
-import { A as RefreshIcon, h as FileIcon, j as SearchIcon, n as ArrowLeftIcon } from "../icons-Ba9THQKz.js";
-import { Button } from "./Button.js";
-import { a as CodeBlockCopyButton, i as CodeBlockContent, n as CodeBlockActions, o as CodeBlockFilename, p as CodeBlockTitle, r as CodeBlockContainer, s as CodeBlockHeader, t as CodeBlock } from "../CodeBlock-BUFXG8HW.js";
-import { Input } from "./Input.js";
-import { i as FileTreeFolder, r as FileTreeFile, t as FileTree } from "../FileTree-mpEIcfzA.js";
+import { a as WorkspaceNavigationRestorationBoundary, n as WorkspaceNavigationProvider, o as useRequiredWorkspaceNavigationRestoration, r as resolveWorkspaceLink, t as WorkspaceFileLink } from "../WorkspaceLink-DIPbXrUM.js";
+import { n as mergeRefs } from "../merge-refs-DF_7w2x_.js";
+import { WorkspaceBrowser } from "./WorkspaceBrowser.js";
+import { inferWorkspaceLanguage, inferWorkspaceMedia, isWorkspaceMarkdownPath, isWorkspaceMediaPath, isWorkspaceSkillPath, parseWorkspaceSkill } from "./WorkspaceFile.js";
+import { t as WorkspaceFileView } from "../WorkspaceFileView-rSN_yT0L.js";
+import { useWorkspace } from "./Workspace.js";
 import * as React from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { jsx } from "react/jsx-runtime";
 //#region src/components/WorkspaceExplorer.tsx
-function basename(path) {
-	return path.split("/").filter(Boolean).at(-1) ?? path;
+function encodeWorkspaceDestination(destination) {
+	const path = destination.path.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+	return destination.fragment === null ? path : `${path}#${encodeURIComponent(destination.fragment)}`;
 }
-function sortEntries(entries) {
-	return [...entries].sort((left, right) => {
-		if (left.type !== right.type) return left.type === "directory" ? -1 : 1;
-		return left.name.localeCompare(right.name);
+function getValidatedFileDestination(destination, root) {
+	if (destination.kind !== "file") return null;
+	const resolved = resolveWorkspaceLink({
+		href: encodeWorkspaceDestination(destination),
+		root,
+		base: {
+			kind: "directory",
+			path: root
+		}
 	});
+	if (resolved.kind !== "file" || resolved.path !== destination.path || resolved.fragment !== destination.fragment) return null;
+	return resolved;
 }
-function toErrorMessage(error) {
-	return error instanceof Error ? error.message : String(error);
+function getDirectoryAncestors(path, root) {
+	const ancestors = [];
+	let parent = path.slice(0, path.lastIndexOf("/")) || "/";
+	while (parent !== root && (root === "/" || parent.startsWith(`${root}/`))) {
+		ancestors.unshift(parent);
+		parent = parent.slice(0, parent.lastIndexOf("/")) || "/";
+	}
+	return ancestors;
 }
 /**
-* Headless state for browsing a Think workspace: lazy directory loading,
-* cached file reads, expansion/selection, and refresh. Feed the result to
-* `WorkspaceExplorer`, or render your own UI from it.
+* Convenience workspace application composed from `WorkspaceBrowser` and
+* `WorkspaceFileView`. The host adapter owns URLs and history; the explorer
+* only restores presentation state for stable navigation entry keys.
 */
-function useWorkspace({ source, root = "/" }) {
-	const [entriesByDirectory, setEntriesByDirectory] = React.useState({});
-	const [filesByPath, setFilesByPath] = React.useState({});
-	const [expandedPaths, setExpandedPathsState] = React.useState(/* @__PURE__ */ new Set());
-	const [selectedPath, setSelectedPath] = React.useState(null);
-	const [isLoading, setIsLoading] = React.useState(false);
-	const [loadingPaths, setLoadingPaths] = React.useState(/* @__PURE__ */ new Set());
-	const [error, setError] = React.useState(null);
-	const [info, setInfo] = React.useState(null);
-	const loadedDirectoriesRef = React.useRef(/* @__PURE__ */ new Set());
-	const markLoading = React.useCallback((path, loading) => {
-		setLoadingPaths((current) => {
-			const next = new Set(current);
-			if (loading) next.add(path);
-			else next.delete(path);
-			return next;
-		});
-	}, []);
-	const loadDirectory = React.useCallback(async (path, { force = false } = {}) => {
-		if (!force && loadedDirectoriesRef.current.has(path)) return;
-		markLoading(path, true);
-		try {
-			const entries = sortEntries(await source.readDir(path));
-			loadedDirectoriesRef.current.add(path);
-			setEntriesByDirectory((current) => ({
-				...current,
-				[path]: entries
-			}));
-			setError(null);
-		} catch (listError) {
-			setError(toErrorMessage(listError));
-		} finally {
-			markLoading(path, false);
-		}
-	}, [source, markLoading]);
-	const loadFile = React.useCallback(async (path, { force = false } = {}) => {
-		if (!force && Object.hasOwn(filesByPath, path)) return;
-		markLoading(path, true);
-		try {
-			const content = await source.readFile(path);
-			setFilesByPath((current) => ({
-				...current,
-				[path]: {
-					path,
-					name: basename(path),
-					content,
-					error: null
-				}
-			}));
-		} catch (readError) {
-			setFilesByPath((current) => ({
-				...current,
-				[path]: {
-					path,
-					name: basename(path),
-					content: null,
-					error: toErrorMessage(readError)
-				}
-			}));
-		} finally {
-			markLoading(path, false);
-		}
+function WorkspaceExplorer({ ...props }) {
+	return /* @__PURE__ */ jsx(WorkspaceNavigationRestorationBoundary, { children: /* @__PURE__ */ jsx(WorkspaceExplorerContent, { ...props }) });
+}
+function WorkspaceExplorerContent({ workspace, navigation, className, title = "Workspace", leading, actions, showFilter = false, filterPlaceholder = "Filter files...", emptyState, ref, ...props }) {
+	const explorerRef = React.useRef(null);
+	const pendingTreeFocusRef = React.useRef(null);
+	const previousDestinationRef = React.useRef(navigation.current.destination);
+	const restoration = useRequiredWorkspaceNavigationRestoration();
+	const { entriesByDirectory, expandedPaths, selectedPath, selectedFile, isLoading, loadingPaths, refresh, selectFile, setExpandedPaths } = workspace;
+	const fileDestination = getValidatedFileDestination(navigation.current.destination, workspace.root);
+	React.useEffect(() => {
+		if (fileDestination && selectedPath !== fileDestination.path) selectFile(fileDestination.path);
 	}, [
-		source,
-		filesByPath,
-		markLoading
+		fileDestination?.path,
+		selectFile,
+		selectedPath
 	]);
-	const loadInfo = React.useCallback(async () => {
-		if (!source.getWorkspaceInfo) return;
-		try {
-			setInfo(await source.getWorkspaceInfo());
-		} catch {
-			setInfo(null);
-		}
-	}, [source]);
 	React.useEffect(() => {
-		setEntriesByDirectory({});
-		setFilesByPath({});
-		setExpandedPathsState(/* @__PURE__ */ new Set());
-		setSelectedPath(null);
-		setError(null);
-		setInfo(null);
-		loadedDirectoriesRef.current = /* @__PURE__ */ new Set();
-		setIsLoading(true);
-		Promise.all([loadDirectory(root, { force: true }), loadInfo()]).finally(() => setIsLoading(false));
+		const previous = previousDestinationRef.current;
+		if (navigation.current.destination.kind === "files" && previous.kind === "file") {
+			const saved = restoration.get(navigation.current.key);
+			pendingTreeFocusRef.current = saved?.focusDestination ? null : {
+				entryKey: navigation.current.key,
+				path: previous.path
+			};
+		}
+		previousDestinationRef.current = navigation.current.destination;
 	}, [
-		loadDirectory,
-		loadInfo,
-		root
+		navigation.current.key,
+		navigation.current.destination,
+		restoration
 	]);
-	const setExpandedPaths = React.useCallback((next) => {
-		setExpandedPathsState((current) => {
-			for (const path of next) if (!current.has(path)) loadDirectory(path);
-			return next;
-		});
-	}, [loadDirectory]);
-	const selectFile = React.useCallback((path) => {
-		setSelectedPath(path);
-		if (path !== null) loadFile(path);
-	}, [loadFile]);
-	const refresh = React.useCallback(() => {
-		(async () => {
-			setIsLoading(true);
-			try {
-				await Promise.all([...[root, ...expandedPaths].map((path) => loadDirectory(path, { force: true })), loadInfo()]);
-				if (selectedPath) await loadFile(selectedPath, { force: true });
-			} finally {
-				setIsLoading(false);
-			}
-		})();
+	React.useEffect(() => {
+		const pending = pendingTreeFocusRef.current;
+		if (!pending || pending.entryKey !== navigation.current.key || navigation.current.destination.kind !== "files") return;
+		const ancestors = getDirectoryAncestors(pending.path, workspace.root);
+		if (ancestors.some((path) => !expandedPaths.has(path))) {
+			setExpandedPaths(/* @__PURE__ */ new Set([...expandedPaths, ...ancestors]));
+			return;
+		}
+		const surface = explorerRef.current;
+		const target = [...surface?.querySelectorAll(".file-tree__node") ?? []].find((candidate) => candidate.dataset.workspacePath === pending.path);
+		if (target) {
+			target.focus();
+			pendingTreeFocusRef.current = null;
+			return;
+		}
+		if (isLoading || ancestors.some((path) => loadingPaths.has(path))) return;
+		(surface?.querySelector(".file-tree__node") ?? surface?.querySelector("[data-workspace-browser-focus-target]"))?.focus();
+		pendingTreeFocusRef.current = null;
 	}, [
-		expandedPaths,
-		loadDirectory,
-		loadFile,
-		loadInfo,
-		root,
-		selectedPath
-	]);
-	return {
-		root,
 		entriesByDirectory,
-		entryByPath: React.useMemo(() => {
-			const map = /* @__PURE__ */ new Map();
-			for (const entries of Object.values(entriesByDirectory)) for (const entry of entries) map.set(entry.path, entry);
-			return map;
-		}, [entriesByDirectory]),
 		expandedPaths,
-		setExpandedPaths,
-		selectedPath,
-		selectFile,
-		selectedFile: selectedPath ? filesByPath[selectedPath] ?? null : null,
 		isLoading,
 		loadingPaths,
-		error,
-		info,
-		refresh
-	};
-}
-const LANGUAGE_BY_EXTENSION = {
-	ts: "ts",
-	mts: "ts",
-	cts: "ts",
-	tsx: "tsx",
-	js: "js",
-	mjs: "js",
-	cjs: "js",
-	jsx: "jsx",
-	json: "json",
-	jsonc: "jsonc",
-	css: "css",
-	html: "html",
-	md: "md",
-	mdx: "mdx",
-	sh: "bash",
-	bash: "bash",
-	zsh: "bash",
-	yml: "yaml",
-	yaml: "yaml",
-	toml: "toml",
-	py: "python",
-	rs: "rust",
-	go: "go",
-	sql: "sql",
-	xml: "xml",
-	svg: "xml",
-	vue: "vue",
-	svelte: "svelte"
-};
-/** Best-effort syntax-highlighting language from a file path; unknown extensions render as plain text. */
-function inferWorkspaceLanguage(path) {
-	const extension = basename(path).split(".").at(-1)?.toLowerCase() ?? "";
-	return LANGUAGE_BY_EXTENSION[extension] ?? "text";
-}
-/**
-* A Think workspace file browser with a preview pane: lazy directory tree,
-* filter, refresh, and syntax-highlighted file view with copy. Drive it with
-* `useWorkspace(source)`.
-*
-* @example
-* ```tsx
-* const workspace = useWorkspace({ source: agent.workspace, root: "/workspace" });
-* <WorkspaceExplorer workspace={workspace} />
-* ```
-*/
-function WorkspaceExplorer({ workspace, className, title = "Workspace", actions, showFilter = true, filterPlaceholder = "Filter files...", emptyState, ref, ...props }) {
-	const [view, setView] = React.useState("tree");
-	const [filter, setFilter] = React.useState("");
-	const filterQuery = filter.trim().toLowerCase();
-	const { root, entriesByDirectory, entryByPath, expandedPaths, setExpandedPaths, selectedPath, selectFile, selectedFile, isLoading, loadingPaths, error, info, refresh } = workspace;
-	const handleSelect = React.useCallback((path) => {
-		if (entryByPath.get(path)?.type === "directory") return;
-		selectFile(path);
-		setView("file");
-	}, [entryByPath, selectFile]);
-	const filteredFiles = React.useMemo(() => {
-		if (!filterQuery) return [];
-		return sortEntries([...entryByPath.values()].filter((entry) => entry.type !== "directory" && entry.path.toLowerCase().includes(filterQuery)));
-	}, [entryByPath, filterQuery]);
-	const renderEntry = (entry) => {
-		if (entry.type === "directory") return /* @__PURE__ */ jsx(FileTreeFolder, {
-			path: entry.path,
-			name: entry.name,
-			children: (entriesByDirectory[entry.path] ?? []).map(renderEntry)
-		}, entry.path);
-		return /* @__PURE__ */ jsx(FileTreeFile, {
-			path: entry.path,
-			name: entry.name
-		}, entry.path);
-	};
-	const rootEntries = entriesByDirectory[root] ?? [];
-	const showFileView = view === "file" && selectedPath !== null;
-	const selectedFileLoading = selectedPath !== null && loadingPaths.has(selectedPath);
-	return /* @__PURE__ */ jsxs("div", {
-		ref,
+		navigation.current.destination,
+		navigation.current.key,
+		setExpandedPaths,
+		workspace.root
+	]);
+	return /* @__PURE__ */ jsx("div", {
+		ref: mergeRefs(explorerRef, ref),
 		className: cx("workspace-explorer", className),
 		...props,
-		children: [/* @__PURE__ */ jsxs("div", {
-			className: "workspace-explorer__header",
-			children: [showFileView ? /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(Button, {
-				variant: "ghost",
-				color: "neutral",
-				size: "icon-xs",
-				onClick: () => setView("tree"),
-				"aria-label": "Back to files",
-				children: /* @__PURE__ */ jsx(ArrowLeftIcon, { "aria-hidden": "true" })
-			}), /* @__PURE__ */ jsx("span", {
-				className: "workspace-explorer__path",
-				title: selectedPath,
-				children: selectedPath
-			})] }) : /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx("span", {
-				className: "workspace-explorer__title",
-				children: title
-			}), info ? /* @__PURE__ */ jsxs("span", {
-				className: "workspace-explorer__count",
-				children: [info.fileCount.toLocaleString(), " files"]
-			}) : null] }), /* @__PURE__ */ jsxs("div", {
-				className: "workspace-explorer__actions",
-				children: [actions, /* @__PURE__ */ jsx(Button, {
-					variant: "ghost",
-					color: "neutral",
-					size: "icon-xs",
-					onClick: refresh,
-					disabled: isLoading,
-					"aria-label": "Refresh workspace",
-					children: /* @__PURE__ */ jsx(RefreshIcon, { "aria-hidden": "true" })
-				})]
-			})]
-		}), showFileView ? /* @__PURE__ */ jsx(WorkspaceFileView, {
-			file: selectedFile,
-			isLoading: selectedFileLoading
-		}) : /* @__PURE__ */ jsxs("div", {
-			className: "workspace-explorer__body",
-			children: [showFilter ? /* @__PURE__ */ jsxs("label", {
-				className: "workspace-explorer__filter",
-				children: [/* @__PURE__ */ jsx(SearchIcon, { "aria-hidden": "true" }), /* @__PURE__ */ jsx(Input, {
-					type: "search",
-					value: filter,
-					onChange: (event) => setFilter(event.currentTarget.value),
-					placeholder: filterPlaceholder,
-					className: "workspace-explorer__filter-input",
-					"aria-label": "Filter workspace files",
-					autoComplete: "off"
-				})]
-			}) : null, error ? /* @__PURE__ */ jsx("div", {
-				className: "workspace-explorer__empty",
-				role: "alert",
-				children: error
-			}) : filterQuery ? filteredFiles.length > 0 ? /* @__PURE__ */ jsx(FileTree, {
-				className: "workspace-explorer__tree",
-				selectedPath,
-				onSelect: handleSelect,
-				"aria-label": "Workspace files",
-				children: filteredFiles.map((entry) => /* @__PURE__ */ jsx(FileTreeFile, {
-					path: entry.path,
-					name: entry.path
-				}, entry.path))
-			}) : /* @__PURE__ */ jsx("div", {
-				className: "workspace-explorer__empty",
-				children: "No matching files"
-			}) : rootEntries.length > 0 ? /* @__PURE__ */ jsx(FileTree, {
-				className: "workspace-explorer__tree",
-				expanded: new Set(expandedPaths),
-				onExpandedChange: setExpandedPaths,
-				selectedPath,
-				onSelect: handleSelect,
-				"aria-label": "Workspace files",
-				children: rootEntries.map(renderEntry)
-			}) : /* @__PURE__ */ jsx("div", {
-				className: "workspace-explorer__empty",
-				children: isLoading ? "Loading workspace..." : emptyState ?? "No workspace files"
-			})]
-		})]
-	});
-}
-function WorkspaceFileView({ file, isLoading }) {
-	if (isLoading) return /* @__PURE__ */ jsx("div", {
-		className: "workspace-explorer__empty",
-		children: "Loading file..."
-	});
-	if (!file) return /* @__PURE__ */ jsx("div", {
-		className: "workspace-explorer__empty",
-		children: "File preview is unavailable."
-	});
-	if (file.error) return /* @__PURE__ */ jsxs("div", {
-		className: "workspace-explorer__empty",
-		role: "alert",
-		children: ["Could not preview this file: ", file.error]
-	});
-	if (file.content === null) return /* @__PURE__ */ jsx("div", {
-		className: "workspace-explorer__empty",
-		children: "This file has no text preview."
-	});
-	if (file.content.length === 0) return /* @__PURE__ */ jsx("div", {
-		className: "workspace-explorer__empty",
-		children: "This file is empty."
-	});
-	return /* @__PURE__ */ jsx("div", {
-		className: "workspace-explorer__file",
-		children: /* @__PURE__ */ jsxs(CodeBlock, {
-			className: "workspace-explorer__code",
-			code: file.content,
-			language: inferWorkspaceLanguage(file.path),
-			showLineNumbers: true,
-			children: [/* @__PURE__ */ jsxs(CodeBlockHeader, { children: [/* @__PURE__ */ jsxs(CodeBlockTitle, { children: [/* @__PURE__ */ jsx(FileIcon, { "aria-hidden": "true" }), /* @__PURE__ */ jsx(CodeBlockFilename, { children: file.name })] }), /* @__PURE__ */ jsx(CodeBlockActions, { children: /* @__PURE__ */ jsx(CodeBlockCopyButton, {}) })] }), /* @__PURE__ */ jsx(CodeBlockContainer, { children: /* @__PURE__ */ jsx(CodeBlockContent, {}) })]
+		children: fileDestination ? /* @__PURE__ */ jsx(WorkspaceNavigationProvider, {
+			root: workspace.root,
+			base: {
+				kind: "file",
+				path: fileDestination.path
+			},
+			navigation,
+			children: /* @__PURE__ */ jsx(WorkspaceFileView, {
+				file: selectedFile?.path === fileDestination.path ? selectedFile : null,
+				path: fileDestination.path,
+				isLoading: selectedPath !== fileDestination.path || loadingPaths.has(fileDestination.path),
+				isRefreshing: isLoading,
+				leading,
+				actions,
+				onRefresh: refresh
+			})
+		}) : /* @__PURE__ */ jsx(WorkspaceBrowser, {
+			workspace,
+			title,
+			leading,
+			actions,
+			showFilter,
+			filterPlaceholder,
+			emptyState,
+			onSelectFile: (path) => navigation.navigate({
+				kind: "file",
+				path,
+				fragment: null
+			}),
+			onBack: navigation.canGoBack ? () => navigation.goBack() : void 0,
+			onForward: navigation.canGoForward ? () => navigation.goForward() : void 0
 		})
 	});
 }
 //#endregion
-export { WorkspaceExplorer, inferWorkspaceLanguage, useWorkspace };
+export { WorkspaceExplorer, WorkspaceFileLink, WorkspaceNavigationProvider, inferWorkspaceLanguage, inferWorkspaceMedia, isWorkspaceMarkdownPath, isWorkspaceMediaPath, isWorkspaceSkillPath, parseWorkspaceSkill, resolveWorkspaceLink, useWorkspace };

package/dist/components/WorkspaceFile.d.ts

@@ -0,0 +1,2 @@
+import { a as WorkspaceMediaInfo, c as WorkspaceMediaTrackKind, d as inferWorkspaceLanguage, f as inferWorkspaceMedia, g as parseWorkspaceSkill, h as isWorkspaceSkillPath, i as WorkspaceFileState, l as WorkspaceSkillDocument, m as isWorkspaceMediaPath, n as WorkspaceFileAssetRequest, o as WorkspaceMediaKind, p as isWorkspaceMarkdownPath, r as WorkspaceFileAssetResolver, s as WorkspaceMediaTrack, t as WorkspaceFileAsset, u as getWorkspaceBasename } from "../WorkspaceFile-DOZkPwzu.js";
+export { WorkspaceFileAsset, WorkspaceFileAssetRequest, WorkspaceFileAssetResolver, WorkspaceFileState, WorkspaceMediaInfo, WorkspaceMediaKind, WorkspaceMediaTrack, WorkspaceMediaTrackKind, WorkspaceSkillDocument, getWorkspaceBasename, inferWorkspaceLanguage, inferWorkspaceMedia, isWorkspaceMarkdownPath, isWorkspaceMediaPath, isWorkspaceSkillPath, parseWorkspaceSkill };