@mcp-b/react-components 0.16.1 → 0.18.0

package/dist/components/Workspace.js

@@ -1,33 +1,29 @@
+import { n as isWorkspacePathWithinRoot, t as canonicalizeAbsoluteWorkspacePath } from "../workspace-path-L_KmjRjq.js";
 import { getWorkspaceBasename, inferWorkspaceMedia } from "./WorkspaceFile.js";
 import * as React from "react";
+import { queryOptions, useQueries, useQuery, useQueryClient } from "@tanstack/react-query";
 //#region src/components/Workspace.ts
 const DEFAULT_MAX_INLINE_ASSET_BYTES = 32 * 1024 * 1024;
 const WORKSPACE_DIRECTORY_PAGE_SIZE = 1e3;
+const ACTIVE_FILE_GC_TIME = 2e3;
 const EMPTY_ENTRIES_BY_DIRECTORY = Object.freeze({});
 const EMPTY_ENTRY_BY_PATH = /* @__PURE__ */ new Map();
 const EMPTY_PATHS = /* @__PURE__ */ new Set();
+const INACTIVE_FILE_INFO = {
+	path: "",
+	name: "",
+	type: "file",
+	mimeType: "text/plain",
+	size: 0,
+	createdAt: 0,
+	updatedAt: 0
+};
+const INACTIVE_FILE_ASSET_RESOLVER = () => null;
 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 throwIfAborted(signal) {
+	if (signal.aborted) throw signal.reason ?? new DOMException("The query was cancelled.", "AbortError");
 }
 function getAssetDataSize(asset) {
 	if (asset.kind === "url") return void 0;
@@ -42,10 +38,7 @@ function normalizeWorkspaceAsset(asset, path, inferredMedia, info) {
 		size: asset.size ?? getAssetDataSize(asset) ?? info.size
 	};
 	return {
-		asset: asset.kind === "url" ? {
-			...asset,
-			...metadata
-		} : {
+		asset: {
 			...asset,
 			...metadata
 		},
@@ -65,360 +58,382 @@ async function readWorkspaceAssetBytes(source, path, info, maxInlineAssetBytes)
 	} : 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`.
+* Source/root prefix for cache inspection, cancellation, or removal.
+* Do not broadly invalidate this prefix: active file queries must refresh in
+* stat → resolver → content order. Use a resource option key or `refresh()`.
 */
-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
+function workspaceQueryKey(sourceKey, root) {
+	return [
+		"workspace",
+		sourceKey,
+		root
+	];
+}
+function workspaceFileQueryKey(sourceKey, root, requestedPath) {
+	return [
+		...workspaceQueryKey(sourceKey, root),
+		"file",
+		requestedPath
+	];
+}
+function workspaceFileVersion(target) {
+	return {
+		path: target.readPath,
+		name: target.info.name,
+		type: target.info.type,
+		mimeType: target.info.mimeType ?? null,
+		size: target.info.size,
+		createdAt: target.info.createdAt,
+		updatedAt: target.info.updatedAt,
+		target: target.info.target ?? null
 	};
-	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 {
+}
+/** Shared directory options for workspace components and route loaders. */
+function workspaceDirectoryQueryOptions(source, sourceKey, root, path) {
+	return queryOptions({
+		queryKey: [
+			...workspaceQueryKey(sourceKey, root),
+			"directory",
+			path
+		],
+		queryFn: async ({ signal }) => {
 			const entries = [];
 			let offset = 0;
 			for (;;) {
+				throwIfAborted(signal);
 				const page = await source.readDir(path, {
 					limit: WORKSPACE_DIRECTORY_PAGE_SIZE,
 					offset
 				});
-				if (!requestIsCurrent()) return;
+				throwIfAborted(signal);
 				entries.push(...page);
-				if (page.length < WORKSPACE_DIRECTORY_PAGE_SIZE) break;
+				if (page.length < WORKSPACE_DIRECTORY_PAGE_SIZE) return entries;
 				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);
+		},
+		staleTime: Infinity
+	});
+}
+/** Shared workspace-summary options for workspace components and route loaders. */
+function workspaceInfoQueryOptions(source, sourceKey, root) {
+	return queryOptions({
+		queryKey: [...workspaceQueryKey(sourceKey, root), "info"],
+		queryFn: async ({ signal }) => {
+			if (!("getWorkspaceInfo" in source) || typeof source.getWorkspaceInfo !== "function") return null;
+			const info = await source.getWorkspaceInfo();
+			throwIfAborted(signal);
+			return info;
+		},
+		staleTime: Infinity
+	});
+}
+/** Re-stat and validate a requested path before any resolver or file read. */
+function workspaceFileStatQueryOptions(source, sourceKey, root, requestedPath) {
+	return queryOptions({
+		queryKey: [...workspaceFileQueryKey(sourceKey, root, requestedPath), "stat"],
+		queryFn: async ({ signal }) => {
+			if (!isWorkspacePathWithinRoot(requestedPath, root)) throw new Error("This file is outside the configured workspace root.");
+			const info = await source.stat(requestedPath);
+			throwIfAborted(signal);
+			if (!info) throw new Error("File metadata is unavailable because source.stat() returned null.");
+			const readPath = canonicalizeAbsoluteWorkspacePath(info.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 (readPath !== info.path) throw new Error("The workspace source returned a non-canonical file path from stat().");
+			if (!isWorkspacePathWithinRoot(readPath, root)) throw new Error("This file's resolved path is outside the configured workspace root.");
+			return {
+				requestedPath,
+				readPath,
+				info,
+				media: inferWorkspaceMedia(readPath, info.mimeType)
 			};
-			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);
+		},
+		staleTime: 0,
+		refetchOnMount: "always",
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+		retry: false
+	});
+}
+/** Optional host asset resolution, scoped to the current stat result. */
+function workspaceFileAssetQueryOptions(sourceKey, root, target, resolveFileAsset) {
+	return queryOptions({
+		queryKey: [
+			...workspaceFileQueryKey(sourceKey, root, target.requestedPath),
+			"asset",
+			workspaceFileVersion(target)
+		],
+		queryFn: async ({ signal }) => {
+			const resolvedAsset = await resolveFileAsset({
+				path: target.readPath,
+				requestedPath: target.requestedPath,
+				root: canonicalizeAbsoluteWorkspacePath(root) ?? root,
+				info: target.info,
+				signal
+			});
+			if (!resolvedAsset) return null;
+			const normalized = normalizeWorkspaceAsset(resolvedAsset, target.readPath, target.media, target.info);
+			if (!normalized) throw new Error("The host returned an asset without a supported image, PDF, audio, or video MIME type.");
+			return normalized;
+		},
+		staleTime: 0,
+		gcTime: ACTIVE_FILE_GC_TIME,
+		refetchOnMount: "always",
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+		retry: false
+	});
+}
+/** Cached text read options, scoped to the validated stat result. */
+function workspaceTextFileQueryOptions(source, sourceKey, root, target) {
+	return queryOptions({
+		queryKey: [
+			...workspaceFileQueryKey(sourceKey, root, target.requestedPath),
+			"text",
+			workspaceFileVersion(target)
+		],
+		queryFn: async ({ signal }) => {
+			const content = await source.readFile(target.readPath);
+			throwIfAborted(signal);
+			return content;
+		},
+		staleTime: Infinity
+	});
+}
+/** Active-file-only buffered asset options, scoped to the validated stat result. */
+function workspaceBinaryFileQueryOptions(source, sourceKey, root, target, maxInlineAssetBytes) {
+	return queryOptions({
+		queryKey: [
+			...workspaceFileQueryKey(sourceKey, root, target.requestedPath),
+			"bytes",
+			workspaceFileVersion(target),
+			{ maxInlineAssetBytes }
+		],
+		queryFn: async ({ signal }) => {
+			const asset = await readWorkspaceAssetBytes(source, target.readPath, target.info, maxInlineAssetBytes);
+			throwIfAborted(signal);
+			return asset ? normalizeWorkspaceAsset(asset, target.readPath, target.media, target.info) : null;
+		},
+		staleTime: 0,
+		gcTime: ACTIVE_FILE_GC_TIME,
+		refetchOnMount: "always",
+		refetchOnWindowFocus: false,
+		refetchOnReconnect: false,
+		retry: false
+	});
+}
+async function refreshWorkspaceFile(queryClient, { source, sourceKey, root, selectedPath, resolveFileAsset, maxInlineAssetBytes }) {
+	if (!selectedPath) return;
+	const target = await queryClient.fetchQuery({
+		...workspaceFileStatQueryOptions(source, sourceKey, root, selectedPath),
+		staleTime: 0
+	});
+	if (resolveFileAsset) {
+		const options = workspaceFileAssetQueryOptions(sourceKey, root, target, resolveFileAsset);
+		if (!queryClient.getQueryState(options.queryKey)) return;
+		if (await queryClient.fetchQuery({
+			...options,
+			staleTime: 0
+		})) return;
+	}
+	if (target.media) {
+		const options = workspaceBinaryFileQueryOptions(source, sourceKey, root, target, maxInlineAssetBytes);
+		if (queryClient.getQueryState(options.queryKey)) await queryClient.fetchQuery({
+			...options,
+			staleTime: 0
 		});
+		return;
+	}
+	const options = workspaceTextFileQueryOptions(source, sourceKey, root, target);
+	if (queryClient.getQueryState(options.queryKey)) await queryClient.fetchQuery({
+		...options,
+		staleTime: 0
+	});
+}
+/**
+* Headless state for browsing a Think workspace. TanStack Query owns remote
+* directory, metadata, resolver, text, and byte lifecycles; the route owns
+* selection, while this hook only keeps local tree expansion state.
+*/
+function useWorkspace({ source, sourceKey, root = "/", selectedPath, onSelectedPathChange, resolveFileAsset, maxInlineAssetBytes = DEFAULT_MAX_INLINE_ASSET_BYTES }) {
+	const queryClient = useQueryClient();
+	const scopeKey = JSON.stringify([sourceKey, root]);
+	const [expandedPathsByScope, setExpandedPathsByScope] = React.useState({});
+	const expandedPaths = expandedPathsByScope[scopeKey] ?? EMPTY_PATHS;
+	const latestExpansionRef = React.useRef({
+		scopeKey,
+		paths: expandedPaths
+	});
+	const normalizedMaxInlineAssetBytes = Number.isFinite(maxInlineAssetBytes) && maxInlineAssetBytes >= 0 ? maxInlineAssetBytes : DEFAULT_MAX_INLINE_ASSET_BYTES;
+	const directoryPaths = React.useMemo(() => [.../* @__PURE__ */ new Set([root, ...expandedPaths])].sort(), [expandedPaths, root]);
+	const directoryQueries = useQueries({ queries: directoryPaths.map((path) => workspaceDirectoryQueryOptions(source, sourceKey, root, path)) });
+	const infoQuery = useQuery({
+		...workspaceInfoQueryOptions(source, sourceKey, root),
+		enabled: "getWorkspaceInfo" in source && typeof source.getWorkspaceInfo === "function"
+	});
+	const statQuery = useQuery({
+		...workspaceFileStatQueryOptions(source, sourceKey, root, selectedPath ?? root),
+		enabled: selectedPath !== null
+	});
+	const target = selectedPath === null ? void 0 : statQuery.data;
+	const statSettled = target !== void 0 && statQuery.isSuccess && !statQuery.isFetching;
+	const queryTarget = target ?? {
+		requestedPath: selectedPath ?? root,
+		readPath: selectedPath ?? root,
+		info: INACTIVE_FILE_INFO,
+		media: null
+	};
+	const assetQuery = useQuery({
+		...workspaceFileAssetQueryOptions(sourceKey, root, queryTarget, resolveFileAsset ?? INACTIVE_FILE_ASSET_RESOLVER),
+		enabled: statSettled && resolveFileAsset !== void 0
+	});
+	const resolvedAsset = assetQuery.data ?? null;
+	const resolverSettled = !resolveFileAsset || assetQuery.isSuccess && !assetQuery.isFetching;
+	const textQuery = useQuery({
+		...workspaceTextFileQueryOptions(source, sourceKey, root, queryTarget),
+		enabled: statSettled && resolverSettled && !resolvedAsset && !target.media
+	});
+	const binaryQuery = useQuery({
+		...workspaceBinaryFileQueryOptions(source, sourceKey, root, queryTarget, normalizedMaxInlineAssetBytes),
+		enabled: statSettled && resolverSettled && !resolvedAsset && Boolean(target.media)
+	});
+	const entriesByDirectory = React.useMemo(() => {
+		const entries = {};
+		for (const [index, path] of directoryPaths.entries()) {
+			const data = directoryQueries[index]?.data;
+			if (data) entries[path] = data;
+		}
+		return entries;
+	}, [directoryPaths, directoryQueries]);
+	const entryByPath = React.useMemo(() => {
+		const entries = /* @__PURE__ */ new Map();
+		for (const directoryEntries of Object.values(entriesByDirectory)) for (const entry of directoryEntries) entries.set(entry.path, entry);
+		return entries;
+	}, [entriesByDirectory]);
+	const setExpandedPaths = React.useCallback((next) => {
+		latestExpansionRef.current = {
+			scopeKey,
+			paths: next
+		};
+		setExpandedPathsByScope((current) => ({
+			...current,
+			[scopeKey]: next
+		}));
+	}, [scopeKey]);
+	const selectFile = React.useCallback((path) => onSelectedPathChange?.(path), [onSelectedPathChange]);
+	const selectedError = statQuery.error ?? assetQuery.error ?? textQuery.error ?? binaryQuery.error;
+	let selectedFile = null;
+	if (selectedPath && selectedError) selectedFile = {
+		path: selectedPath,
+		name: getWorkspaceBasename(selectedPath),
+		content: null,
+		asset: null,
+		info: target?.info ?? null,
+		error: toErrorMessage(selectedError)
+	};
+	else if (selectedPath && statSettled && target && resolverSettled) {
+		if (resolvedAsset) selectedFile = {
+			path: selectedPath,
+			name: getWorkspaceBasename(selectedPath),
+			content: null,
+			asset: resolvedAsset.asset,
+			info: target.info,
+			error: null
+		};
+		else if (target.media && binaryQuery.isSuccess && !binaryQuery.isFetching) selectedFile = {
+			path: selectedPath,
+			name: getWorkspaceBasename(selectedPath),
+			content: null,
+			asset: binaryQuery.data?.asset ?? null,
+			info: target.info,
+			error: null
+		};
+		else if (!target.media && textQuery.isSuccess) selectedFile = {
+			path: selectedPath,
+			name: getWorkspaceBasename(selectedPath),
+			content: textQuery.data,
+			asset: null,
+			info: target.info,
+			error: null
+		};
+	}
+	const loadingPaths = React.useMemo(() => {
+		const paths = /* @__PURE__ */ new Set();
+		for (const [index, path] of directoryPaths.entries()) if (directoryQueries[index]?.isFetching) paths.add(path);
+		if (selectedPath && [
+			statQuery,
+			assetQuery,
+			textQuery,
+			binaryQuery
+		].some((query) => query.isFetching)) paths.add(selectedPath);
+		return paths;
 	}, [
-		cancelFileLoad,
-		loadDirectory,
-		loadInfo,
-		root
+		assetQuery,
+		binaryQuery,
+		directoryPaths,
+		directoryQueries,
+		selectedPath,
+		statQuery,
+		textQuery
 	]);
-	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 rootDirectoryIndex = directoryPaths.indexOf(root);
+	const isLoading = Boolean(directoryQueries[rootDirectoryIndex]?.isFetching) || infoQuery.isFetching;
+	const error = [...new Set(directoryQueries.map((query) => query.error).filter((queryError) => queryError !== null).map(toErrorMessage))].join("; ") || null;
 	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
+			const latestExpandedPaths = latestExpansionRef.current.scopeKey === scopeKey ? latestExpansionRef.current.paths : expandedPaths;
+			const refreshedDirectoryPaths = [.../* @__PURE__ */ new Set([root, ...latestExpandedPaths])].sort();
+			await queryClient.cancelQueries({ queryKey: workspaceQueryKey(sourceKey, root) });
+			const refreshedDirectories = await Promise.all(refreshedDirectoryPaths.map(async (path) => {
+				try {
+					await queryClient.fetchQuery({
+						...workspaceDirectoryQueryOptions(source, sourceKey, root, path),
+						staleTime: 0
 					});
+					return true;
+				} catch {
+					return false;
 				}
-			} finally {
-				if (requestIsCurrent() && loadingOperationVersionRef.current === loadingOperationVersion) setIsLoading(false);
-			}
-		})();
+			}));
+			if ("getWorkspaceInfo" in source && typeof source.getWorkspaceInfo === "function") await queryClient.fetchQuery({
+				...workspaceInfoQueryOptions(source, sourceKey, root),
+				staleTime: 0
+			}).catch(() => void 0);
+			if (refreshedDirectories.includes(false)) return;
+			await refreshWorkspaceFile(queryClient, {
+				source,
+				sourceKey,
+				root,
+				selectedPath,
+				resolveFileAsset,
+				maxInlineAssetBytes: normalizedMaxInlineAssetBytes
+			});
+		})().catch(() => {});
 	}, [
 		expandedPaths,
-		loadDirectory,
-		loadFile,
-		loadInfo,
+		normalizedMaxInlineAssetBytes,
+		queryClient,
+		resolveFileAsset,
 		root,
-		source
+		scopeKey,
+		selectedPath,
+		source,
+		sourceKey
 	]);
-	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,
+		entriesByDirectory: Object.keys(entriesByDirectory).length > 0 ? entriesByDirectory : EMPTY_ENTRIES_BY_DIRECTORY,
+		entryByPath: entryByPath.size > 0 ? entryByPath : EMPTY_ENTRY_BY_PATH,
+		expandedPaths,
 		setExpandedPaths,
-		selectedPath: visibleSelectedPath,
+		selectedPath,
 		selectFile,
 		selectedFile,
-		isLoading: !stateIsCurrent || isLoading,
-		loadingPaths: stateIsCurrent ? loadingPaths : EMPTY_PATHS,
-		error: stateIsCurrent ? directoryError : null,
-		info: stateIsCurrent ? info : null,
+		isLoading,
+		loadingPaths: loadingPaths.size > 0 ? loadingPaths : EMPTY_PATHS,
+		error,
+		info: infoQuery.data ?? null,
 		refresh
 	};
 }
 //#endregion
-export { useWorkspace };
+export { useWorkspace, workspaceBinaryFileQueryOptions, workspaceDirectoryQueryOptions, workspaceFileAssetQueryOptions, workspaceFileStatQueryOptions, workspaceInfoQueryOptions, workspaceQueryKey, workspaceTextFileQueryOptions };