@mcp-b/react-components 0.14.2 → 0.16.1

package/dist/components/ToggleGroup.d.ts

@@ -1,73 +1,2 @@
-import { ToggleVariantsOptions } from "./Toggle.js";
-import * as React from "react";
-import { ToggleGroup as ToggleGroup$1 } from "@base-ui/react/toggle-group";
-import { Toggle } from "@base-ui/react/toggle";
-
-//#region src/components/ToggleGroup.d.ts
-type ToggleGroupSize = ToggleVariantsOptions["size"] | "md";
-interface ToggleGroupProps extends Omit<React.ComponentPropsWithRef<typeof ToggleGroup$1>, "className"> {
-  className?: string;
-  variant?: ToggleVariantsOptions["variant"];
-  /**
-   * The size of the toggle group.
-   * @default 'md'
-   */
-  size?: ToggleGroupSize;
-  spacing?: number;
-}
-interface ToggleGroupItemProps extends Omit<React.ComponentPropsWithRef<typeof Toggle>, "className">, ToggleVariantsOptions {}
-/**
- * A toggle group component for selecting one or multiple options.
- *
- * @example
- * ```tsx
- * // Single selection (defaultValue is an array)
- * <ToggleGroup defaultValue={["center"]}>
- *   <ToggleGroupItem value="left">Left</ToggleGroupItem>
- *   <ToggleGroupItem value="center">Center</ToggleGroupItem>
- *   <ToggleGroupItem value="right">Right</ToggleGroupItem>
- * </ToggleGroup>
- * ```
- *
- * @example
- * ```tsx
- * // Multiple selection
- * <ToggleGroup multiple defaultValue={["bold", "italic"]}>
- *   <ToggleGroupItem value="bold">Bold</ToggleGroupItem>
- *   <ToggleGroupItem value="italic">Italic</ToggleGroupItem>
- *   <ToggleGroupItem value="underline">Underline</ToggleGroupItem>
- * </ToggleGroup>
- * ```
- *
- * @see {@link https://base-ui.com/react/components/toggle-group | Base UI Toggle Group}
- */
-declare function ToggleGroupRoot({
-  size,
-  spacing,
-  variant,
-  className,
-  children,
-  style,
-  ref,
-  ...props
-}: ToggleGroupProps & {
-  ref?: React.Ref<HTMLDivElement>;
-}): React.JSX.Element;
-/**
- * A single toggle item within a ToggleGroup.
- */
-declare function ToggleGroupItem({
-  className,
-  variant,
-  size,
-  ref,
-  ...props
-}: ToggleGroupItemProps & {
-  ref?: React.Ref<HTMLButtonElement>;
-}): React.JSX.Element;
-declare const ToggleGroup: {
-  Root: typeof ToggleGroupRoot;
-  Item: typeof ToggleGroupItem;
-};
-//#endregion
+import { n as ToggleGroupItemProps, r as ToggleGroupProps, t as ToggleGroup } from "../ToggleGroup-8hPv-b69.js";
 export { ToggleGroup, ToggleGroupItemProps, ToggleGroupProps };

package/dist/components/Tooltip.d.ts

@@ -49,6 +49,7 @@ declare function TooltipTrigger(props: TooltipTriggerProps): React.JSX.Element;
 declare function TooltipPopup({
   className,
   ref,
+  role,
   ...props
 }: TooltipPopupProps & {
   ref?: React.Ref<HTMLDivElement>;
@@ -73,7 +74,8 @@ declare function TooltipArrow({
   ref?: React.Ref<HTMLDivElement>;
 }): React.JSX.Element;
 /**
- * An accessible tooltip assembled from explicit Base UI parts.
+ * An accessible tooltip assembled from explicit Base UI parts. Popup defaults
+ * to `role="tooltip"` so assistive technology can identify revealed help text.
  */
 declare const Tooltip: {
   createHandle: typeof Tooltip$1.createHandle;

package/dist/components/Tooltip.js

@@ -36,7 +36,7 @@ function TooltipTrigger(props) {
 		...props
 	});
 }
-function TooltipPopup({ className = "", ref, ...props }) {
+function TooltipPopup({ className = "", ref, role = "tooltip", ...props }) {
 	const classes = [
 		"tooltip__popup",
 		"base-ui-popup",
@@ -44,6 +44,7 @@ function TooltipPopup({ className = "", ref, ...props }) {
 	].filter(Boolean).join(" ");
 	return /* @__PURE__ */ jsx(Tooltip$1.Popup, {
 		ref,
+		role,
 		"data-slot": "tooltip-content",
 		className: classes,
 		...props
@@ -73,7 +74,8 @@ function TooltipArrow({ className = "", ref, ...props }) {
 	});
 }
 /**
-* An accessible tooltip assembled from explicit Base UI parts.
+* An accessible tooltip assembled from explicit Base UI parts. Popup defaults
+* to `role="tooltip"` so assistive technology can identify revealed help text.
 */
 const Tooltip = {
 	createHandle: Tooltip$1.createHandle,

package/dist/components/WebPreview.js

@@ -1,5 +1,5 @@
 import { t as cx } from "../class-names-9UtZwb0J.js";
-import { A as RefreshIcon, n as ArrowLeftIcon, o as ChevronDownIcon, r as ArrowRightIcon } from "../icons-Ba9THQKz.js";
+import { L as RefreshIcon, n as ArrowLeftIcon, r as ArrowRightIcon, s as ChevronDownIcon } from "../icons-CpfUer49.js";
 import { Button } from "./Button.js";
 import { Tooltip } from "./Tooltip.js";
 import { Badge } from "./Badge.js";

package/dist/components/Workspace.d.ts

@@ -0,0 +1,2 @@
+import { a as useWorkspace, i as WorkspaceState, n as WorkspaceInfo, r as WorkspaceSource, t as UseWorkspaceOptions } from "../Workspace-D39LxGvP.js";
+export { UseWorkspaceOptions, WorkspaceInfo, WorkspaceSource, WorkspaceState, useWorkspace };

package/dist/components/Workspace.js

@@ -0,0 +1,424 @@
+import { getWorkspaceBasename, inferWorkspaceMedia } from "./WorkspaceFile.js";
+import * as React from "react";
+//#region src/components/Workspace.ts
+const DEFAULT_MAX_INLINE_ASSET_BYTES = 32 * 1024 * 1024;
+const WORKSPACE_DIRECTORY_PAGE_SIZE = 1e3;
+const EMPTY_ENTRIES_BY_DIRECTORY = Object.freeze({});
+const EMPTY_ENTRY_BY_PATH = /* @__PURE__ */ new Map();
+const EMPTY_PATHS = /* @__PURE__ */ new Set();
+function toErrorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+function normalizeWorkspacePath(path) {
+	if (!path.startsWith("/") || path.includes("\0")) return null;
+	const segments = [];
+	for (const segment of path.split("/")) {
+		if (!segment || segment === ".") continue;
+		if (segment === "..") segments.pop();
+		else segments.push(segment);
+	}
+	return `/${segments.join("/")}`;
+}
+function isPathWithinWorkspaceRoot(path, root) {
+	const normalizedPath = normalizeWorkspacePath(path);
+	const normalizedRoot = normalizeWorkspacePath(root);
+	if (!normalizedPath || !normalizedRoot) return false;
+	return normalizedRoot === "/" || normalizedPath === normalizedRoot || normalizedPath.startsWith(`${normalizedRoot}/`);
+}
+function getWorkspaceParentPath(path) {
+	const separatorIndex = path.lastIndexOf("/");
+	return separatorIndex <= 0 ? "/" : path.slice(0, separatorIndex);
+}
+function getAssetDataSize(asset) {
+	if (asset.kind === "url") return void 0;
+	if (asset.data instanceof ArrayBuffer || asset.data instanceof Uint8Array) return asset.data.byteLength;
+	return asset.data.size;
+}
+function normalizeWorkspaceAsset(asset, path, inferredMedia, info) {
+	const media = asset.mimeType?.trim() ? inferWorkspaceMedia(path, asset.mimeType) : inferredMedia;
+	if (!media) return null;
+	const metadata = {
+		mimeType: media.mimeType,
+		size: asset.size ?? getAssetDataSize(asset) ?? info.size
+	};
+	return {
+		asset: asset.kind === "url" ? {
+			...asset,
+			...metadata
+		} : {
+			...asset,
+			...metadata
+		},
+		media: inferWorkspaceMedia(path, media.mimeType) ?? media
+	};
+}
+async function readWorkspaceAssetBytes(source, path, info, maxInlineAssetBytes) {
+	if (info.size > maxInlineAssetBytes) {
+		const maximumMiB = Math.floor(maxInlineAssetBytes / (1024 * 1024));
+		throw new Error(`This file is too large for the built-in byte preview (${maximumMiB.toLocaleString()} MiB maximum). Provide resolveFileAsset with a URL instead.`);
+	}
+	const data = await source.readFileBytes(path);
+	if (data && data.byteLength > maxInlineAssetBytes) throw new Error("The returned bytes exceed the built-in preview limit. Provide resolveFileAsset with a URL instead.");
+	return data ? {
+		kind: "data",
+		data
+	} : null;
+}
+/**
+* Headless state for browsing a Think workspace: lazy directory loading,
+* cached file reads, expansion/selection, and refresh. Feed the result to
+* `WorkspaceExplorer`, or compose `WorkspaceBrowser` and `WorkspaceFileView`.
+*/
+function useWorkspace({ source, root = "/", resolveFileAsset, maxInlineAssetBytes = DEFAULT_MAX_INLINE_ASSET_BYTES }) {
+	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 [directoryErrorsByPath, setDirectoryErrorsByPath] = React.useState({});
+	const [info, setInfo] = React.useState(null);
+	const [activeAssetFile, setActiveAssetFile] = React.useState(null);
+	const [stateGeneration, setStateGeneration] = React.useState(0);
+	const loadedDirectoriesRef = React.useRef(/* @__PURE__ */ new Set());
+	const directoryRequestVersionsRef = React.useRef(/* @__PURE__ */ new Map());
+	const nextDirectoryRequestVersionRef = React.useRef(0);
+	const nextInfoRequestVersionRef = React.useRef(0);
+	const refreshRequestVersionRef = React.useRef(0);
+	const loadingOperationVersionRef = React.useRef(0);
+	const selectedPathRef = React.useRef(null);
+	const fileRequestRef = React.useRef(null);
+	const resolveFileAssetRef = React.useRef(resolveFileAsset);
+	resolveFileAssetRef.current = resolveFileAsset;
+	const maxInlineAssetBytesRef = React.useRef(DEFAULT_MAX_INLINE_ASSET_BYTES);
+	maxInlineAssetBytesRef.current = Number.isFinite(maxInlineAssetBytes) && maxInlineAssetBytes >= 0 ? maxInlineAssetBytes : DEFAULT_MAX_INLINE_ASSET_BYTES;
+	const sourceIdentityRef = React.useRef({
+		source,
+		root,
+		generation: 0
+	});
+	if (sourceIdentityRef.current.source !== source || sourceIdentityRef.current.root !== root) sourceIdentityRef.current = {
+		source,
+		root,
+		generation: sourceIdentityRef.current.generation + 1
+	};
+	const 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]);
+	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 setDirectoryError = React.useCallback((path, message) => {
+		setDirectoryErrorsByPath((current) => {
+			if (message !== null) {
+				if (current[path] === message) return current;
+				return {
+					...current,
+					[path]: message
+				};
+			}
+			if (!Object.hasOwn(current, path)) return current;
+			const next = { ...current };
+			delete next[path];
+			return next;
+		});
+	}, []);
+	const activateAssetFile = React.useCallback((file) => {
+		setFilesByPath((current) => {
+			if (!Object.hasOwn(current, file.path)) return current;
+			const next = { ...current };
+			delete next[file.path];
+			return next;
+		});
+		setActiveAssetFile(file);
+	}, []);
+	const cacheTextFile = React.useCallback((file) => {
+		setActiveAssetFile((current) => current?.path === file.path ? null : current);
+		setFilesByPath((current) => ({
+			...current,
+			[file.path]: file
+		}));
+	}, []);
+	const cancelFileLoad = React.useCallback(() => {
+		const request = fileRequestRef.current;
+		if (!request) return;
+		request.controller.abort();
+		fileRequestRef.current = null;
+		markLoading(request.path, false);
+	}, [markLoading]);
+	const loadDirectory = React.useCallback(async (path, { force = false } = {}) => {
+		if (!force && loadedDirectoriesRef.current.has(path)) return;
+		const identity = sourceIdentityRef.current;
+		if (identity.source !== source || identity.root !== root) return;
+		const generation = identity.generation;
+		const requestVersion = nextDirectoryRequestVersionRef.current + 1;
+		nextDirectoryRequestVersionRef.current = requestVersion;
+		directoryRequestVersionsRef.current.set(path, requestVersion);
+		const requestIsCurrent = () => generation === sourceIdentityRef.current.generation && directoryRequestVersionsRef.current.get(path) === requestVersion;
+		markLoading(path, true);
+		try {
+			const entries = [];
+			let offset = 0;
+			for (;;) {
+				const page = await source.readDir(path, {
+					limit: WORKSPACE_DIRECTORY_PAGE_SIZE,
+					offset
+				});
+				if (!requestIsCurrent()) return;
+				entries.push(...page);
+				if (page.length < WORKSPACE_DIRECTORY_PAGE_SIZE) break;
+				offset += page.length;
+			}
+			loadedDirectoriesRef.current.add(path);
+			setEntriesByDirectory((current) => ({
+				...current,
+				[path]: entries
+			}));
+			setDirectoryError(path, null);
+			return entries;
+		} catch (listError) {
+			if (!requestIsCurrent()) return;
+			setDirectoryError(path, toErrorMessage(listError));
+			return null;
+		} finally {
+			if (requestIsCurrent()) markLoading(path, false);
+		}
+	}, [
+		source,
+		root,
+		markLoading,
+		setDirectoryError
+	]);
+	const loadFile = React.useCallback(async (path, { force = false, refreshRequestVersion } = {}) => {
+		const listedFileInfo = entryByPath.get(path) ?? null;
+		const cachedFile = filesByPath[path];
+		if (!force && cachedFile && !inferWorkspaceMedia(path, listedFileInfo?.mimeType)) return;
+		const identity = sourceIdentityRef.current;
+		if (identity.source !== source || identity.root !== root) return;
+		const generation = identity.generation;
+		cancelFileLoad();
+		const controller = new AbortController();
+		const request = {
+			path,
+			controller
+		};
+		fileRequestRef.current = request;
+		markLoading(path, true);
+		let fileInfo = listedFileInfo;
+		let media = inferWorkspaceMedia(path, fileInfo?.mimeType);
+		const requestIsCurrent = () => !controller.signal.aborted && generation === sourceIdentityRef.current.generation && selectedPathRef.current === path && (refreshRequestVersion === void 0 || refreshRequestVersionRef.current === refreshRequestVersion);
+		try {
+			if (!isPathWithinWorkspaceRoot(path, root)) throw new Error("This file is outside the configured workspace root.");
+			const resolvedInfo = await source.stat(path);
+			if (!requestIsCurrent()) return;
+			if (!resolvedInfo) {
+				fileInfo = null;
+				throw new Error("File metadata is unavailable because source.stat() returned null.");
+			}
+			fileInfo = resolvedInfo;
+			const readPath = normalizeWorkspacePath(resolvedInfo.path);
+			if (!readPath) throw new Error("The workspace source returned an invalid file path from stat().");
+			if (readPath !== resolvedInfo.path) throw new Error("The workspace source returned a non-canonical file path from stat().");
+			if (!isPathWithinWorkspaceRoot(readPath, root)) throw new Error("This file's resolved path is outside the configured workspace root.");
+			media = inferWorkspaceMedia(readPath, resolvedInfo.mimeType);
+			const resolver = resolveFileAssetRef.current;
+			const resolvedAsset = resolver ? await resolver({
+				path: readPath,
+				requestedPath: path,
+				root: normalizeWorkspacePath(root) ?? root,
+				info: resolvedInfo,
+				signal: controller.signal
+			}) : null;
+			if (!requestIsCurrent()) return;
+			if (resolvedAsset) {
+				const normalized = normalizeWorkspaceAsset(resolvedAsset, readPath, media, resolvedInfo);
+				if (!normalized) throw new Error("The host returned an asset without a supported image, PDF, audio, or video MIME type.");
+				media = normalized.media;
+				activateAssetFile({
+					path,
+					name: getWorkspaceBasename(path),
+					content: null,
+					asset: normalized.asset,
+					info: resolvedInfo,
+					error: null
+				});
+				return;
+			}
+			if (media) {
+				const byteAsset = await readWorkspaceAssetBytes(source, readPath, resolvedInfo, maxInlineAssetBytesRef.current);
+				if (!requestIsCurrent()) return;
+				const normalized = byteAsset ? normalizeWorkspaceAsset(byteAsset, readPath, media, resolvedInfo) : null;
+				activateAssetFile({
+					path,
+					name: getWorkspaceBasename(path),
+					content: null,
+					asset: normalized?.asset ?? null,
+					info: resolvedInfo,
+					error: null
+				});
+				return;
+			}
+			const content = await source.readFile(readPath);
+			if (!requestIsCurrent()) return;
+			cacheTextFile({
+				path,
+				name: getWorkspaceBasename(path),
+				content,
+				asset: null,
+				info: resolvedInfo,
+				error: null
+			});
+		} catch (readError) {
+			if (!requestIsCurrent()) return;
+			const failedFile = {
+				path,
+				name: getWorkspaceBasename(path),
+				content: null,
+				asset: null,
+				info: fileInfo,
+				error: toErrorMessage(readError)
+			};
+			if (media) activateAssetFile(failedFile);
+			else cacheTextFile(failedFile);
+		} finally {
+			if (fileRequestRef.current === request && generation === sourceIdentityRef.current.generation) {
+				fileRequestRef.current = null;
+				markLoading(path, false);
+			}
+		}
+	}, [
+		activateAssetFile,
+		cacheTextFile,
+		cancelFileLoad,
+		entryByPath,
+		filesByPath,
+		markLoading,
+		root,
+		source
+	]);
+	const loadInfo = React.useCallback(async () => {
+		if (!("getWorkspaceInfo" in source)) return;
+		if (typeof source.getWorkspaceInfo !== "function") return;
+		const identity = sourceIdentityRef.current;
+		if (identity.source !== source || identity.root !== root) return;
+		const generation = identity.generation;
+		const requestVersion = nextInfoRequestVersionRef.current + 1;
+		nextInfoRequestVersionRef.current = requestVersion;
+		const requestIsCurrent = () => generation === sourceIdentityRef.current.generation && nextInfoRequestVersionRef.current === requestVersion;
+		try {
+			const nextInfo = await source.getWorkspaceInfo();
+			if (requestIsCurrent()) setInfo(nextInfo);
+		} catch {
+			if (requestIsCurrent()) setInfo(null);
+		}
+	}, [source, root]);
+	React.useEffect(() => {
+		const generation = sourceIdentityRef.current.generation;
+		const loadingOperationVersion = loadingOperationVersionRef.current + 1;
+		loadingOperationVersionRef.current = loadingOperationVersion;
+		refreshRequestVersionRef.current += 1;
+		cancelFileLoad();
+		setEntriesByDirectory({});
+		setFilesByPath({});
+		setActiveAssetFile(null);
+		setExpandedPathsState(/* @__PURE__ */ new Set());
+		setSelectedPath(null);
+		selectedPathRef.current = null;
+		setLoadingPaths(/* @__PURE__ */ new Set());
+		setDirectoryErrorsByPath({});
+		setInfo(null);
+		setStateGeneration(generation);
+		loadedDirectoriesRef.current = /* @__PURE__ */ new Set();
+		directoryRequestVersionsRef.current = /* @__PURE__ */ new Map();
+		setIsLoading(true);
+		Promise.all([loadDirectory(root, { force: true }), loadInfo()]).finally(() => {
+			if (generation === sourceIdentityRef.current.generation && loadingOperationVersionRef.current === loadingOperationVersion) setIsLoading(false);
+		});
+	}, [
+		cancelFileLoad,
+		loadDirectory,
+		loadInfo,
+		root
+	]);
+	React.useEffect(() => () => {
+		fileRequestRef.current?.controller.abort();
+	}, []);
+	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) => {
+		cancelFileLoad();
+		selectedPathRef.current = path;
+		setActiveAssetFile(null);
+		setSelectedPath(path);
+		if (path !== null) loadFile(path);
+	}, [cancelFileLoad, loadFile]);
+	const refresh = React.useCallback(() => {
+		(async () => {
+			const identity = sourceIdentityRef.current;
+			if (identity.source !== source || identity.root !== root) return;
+			const generation = identity.generation;
+			const refreshRequestVersion = refreshRequestVersionRef.current + 1;
+			refreshRequestVersionRef.current = refreshRequestVersion;
+			const loadingOperationVersion = loadingOperationVersionRef.current + 1;
+			loadingOperationVersionRef.current = loadingOperationVersion;
+			const requestIsCurrent = () => generation === sourceIdentityRef.current.generation && refreshRequestVersionRef.current === refreshRequestVersion;
+			setIsLoading(true);
+			try {
+				const directoryPaths = [.../* @__PURE__ */ new Set([root, ...expandedPaths])];
+				const [refreshedListings] = await Promise.all([Promise.all(directoryPaths.map((path) => loadDirectory(path, { force: true }))), loadInfo()]);
+				if (!requestIsCurrent()) return;
+				const refreshedSelectedPath = selectedPathRef.current;
+				if (refreshedSelectedPath) {
+					const selectedDirectoryIndex = directoryPaths.indexOf(getWorkspaceParentPath(refreshedSelectedPath));
+					const selectedDirectoryListing = refreshedListings[selectedDirectoryIndex];
+					if (selectedDirectoryIndex >= 0 && (selectedDirectoryListing === null || selectedDirectoryListing === void 0)) return;
+					await loadFile(refreshedSelectedPath, {
+						force: true,
+						refreshRequestVersion
+					});
+				}
+			} finally {
+				if (requestIsCurrent() && loadingOperationVersionRef.current === loadingOperationVersion) setIsLoading(false);
+			}
+		})();
+	}, [
+		expandedPaths,
+		loadDirectory,
+		loadFile,
+		loadInfo,
+		root,
+		source
+	]);
+	const stateIsCurrent = stateGeneration === sourceIdentityRef.current.generation;
+	const directoryError = [...new Set(Object.values(directoryErrorsByPath))].join("; ") || null;
+	const visibleSelectedPath = stateIsCurrent ? selectedPath : null;
+	const selectedFile = visibleSelectedPath ? activeAssetFile?.path === visibleSelectedPath ? activeAssetFile : filesByPath[visibleSelectedPath] ?? null : null;
+	return {
+		root,
+		entriesByDirectory: stateIsCurrent ? entriesByDirectory : EMPTY_ENTRIES_BY_DIRECTORY,
+		entryByPath: stateIsCurrent ? entryByPath : EMPTY_ENTRY_BY_PATH,
+		expandedPaths: stateIsCurrent ? expandedPaths : EMPTY_PATHS,
+		setExpandedPaths,
+		selectedPath: visibleSelectedPath,
+		selectFile,
+		selectedFile,
+		isLoading: !stateIsCurrent || isLoading,
+		loadingPaths: stateIsCurrent ? loadingPaths : EMPTY_PATHS,
+		error: stateIsCurrent ? directoryError : null,
+		info: stateIsCurrent ? info : null,
+		refresh
+	};
+}
+//#endregion
+export { useWorkspace };

package/dist/components/WorkspaceBrowser.d.ts

@@ -0,0 +1,32 @@
+import { i as WorkspaceState } from "../Workspace-D39LxGvP.js";
+import * as React from "react";
+
+//#region src/components/WorkspaceBrowser.d.ts
+interface WorkspaceBrowserProps {
+  workspace: WorkspaceState;
+  title?: React.ReactNode;
+  /** Leading workspace control, such as a host-owned Back to chat button. */
+  leading?: React.ReactNode;
+  actions?: React.ReactNode;
+  showFilter?: boolean;
+  filterPlaceholder?: string;
+  emptyState?: React.ReactNode;
+  onSelectFile?: (path: string) => void;
+  onBack?: () => void;
+  onForward?: () => void;
+}
+/** Workspace tree and filter surface, usable independently from the file preview. */
+declare function WorkspaceBrowser({
+  workspace,
+  title,
+  leading,
+  actions,
+  showFilter,
+  filterPlaceholder,
+  emptyState,
+  onSelectFile,
+  onBack,
+  onForward
+}: WorkspaceBrowserProps): React.JSX.Element;
+//#endregion
+export { WorkspaceBrowser, WorkspaceBrowserProps };

package/dist/components/WorkspaceBrowser.js

@@ -0,0 +1,103 @@
+import { R as SearchIcon } from "../icons-CpfUer49.js";
+import { Field } from "./Field.js";
+import { i as FileTreeFolder, r as FileTreeFile, t as FileTree } from "../FileTree-CkVbIMWV.js";
+import { WorkspaceHeader } from "./WorkspaceHeader.js";
+import * as React from "react";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+//#region src/components/WorkspaceBrowser.tsx
+function compareFilteredWorkspaceFiles(left, right) {
+	return left.path.localeCompare(right.path) || left.name.localeCompare(right.name);
+}
+/** Workspace tree and filter surface, usable independently from the file preview. */
+function WorkspaceBrowser({ workspace, title = "Workspace", leading, actions, showFilter = true, filterPlaceholder = "Filter files...", emptyState, onSelectFile, onBack, onForward }) {
+	const [filter, setFilter] = React.useState("");
+	const filterQuery = filter.trim().toLowerCase();
+	const { root, entriesByDirectory, entryByPath, expandedPaths, setExpandedPaths, selectedPath, selectFile, isLoading, error, info, refresh } = workspace;
+	const handleSelect = React.useCallback((path) => {
+		if (entryByPath.get(path)?.type === "directory") return;
+		selectFile(path);
+		onSelectFile?.(path);
+	}, [
+		entryByPath,
+		onSelectFile,
+		selectFile
+	]);
+	const filteredFiles = React.useMemo(() => {
+		if (!filterQuery) return [];
+		return [...entryByPath.values()].filter((entry) => entry.type !== "directory" && entry.path.toLowerCase().includes(filterQuery)).sort(compareFilteredWorkspaceFiles);
+	}, [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] ?? [];
+	return /* @__PURE__ */ jsxs(Fragment, { children: [/* @__PURE__ */ jsx(WorkspaceHeader, {
+		title,
+		fileCount: info?.fileCount,
+		leading,
+		actions,
+		isRefreshing: isLoading,
+		onBack,
+		onForward,
+		onRefresh: refresh
+	}), /* @__PURE__ */ jsxs("div", {
+		className: "workspace-explorer__body",
+		"data-workspace-browser-focus-target": "",
+		role: "region",
+		"aria-label": "Workspace files",
+		tabIndex: -1,
+		children: [showFilter ? /* @__PURE__ */ jsxs(Field.Root, {
+			className: "workspace-explorer__filter",
+			name: "workspace-filter",
+			children: [/* @__PURE__ */ jsx(Field.Label, {
+				className: "workspace-explorer__filter-label",
+				children: "Filter workspace files"
+			}), /* @__PURE__ */ jsxs("div", {
+				className: "workspace-explorer__filter-control",
+				children: [/* @__PURE__ */ jsx(SearchIcon, { "aria-hidden": "true" }), /* @__PURE__ */ jsx(Field.Control, {
+					type: "search",
+					value: filter,
+					onChange: (event) => setFilter(event.currentTarget.value),
+					placeholder: filterPlaceholder,
+					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"
+		})]
+	})] });
+}
+//#endregion
+export { WorkspaceBrowser };