@cerbur/clutch-dsh-worktree 0.1.8 → 0.1.9

package/lib/client/WorktreeSurface.js

@@ -13,7 +13,7 @@ import { WorktreeCreateDialog, WorktreeRemovalDialog, WorktreeSessionRenameDialo
 import { bindingIdsFor, clearSessionGroupExpansion, includesText, isCompleteWorktreeWorkspaceSnapshot, currentSessionRevealKeys, isSessionGroupAutoExpanded, resolveCurrentSessionLocation, workspaceMatches, } from './worktree-surface-selectors.js';
 import { scrollCurrentSessionIntoView } from './worktree-session-position.js';
 import { WorktreeGroupRow, WorktreeSessionGroup, WorktreeWorkspaceRow, } from './worktree-surface-rows.js';
-import { executeWorktreeAction, createDefaultWorktreeName, createNumberedWorktreeName, createWorktreeModalViewLoader, createWorktreeRefreshGuard, filterArchivedSessionIds, loadWorktreeViews, mergeWorktreeView, reconcileBaseBranchSelection, resolveWorktreeMove, selectDefaultBaseBranch, stableWorkspaceIds, toRetryableWorktreeOrderError, toWorktreeViewError, WorktreeSessionBindingError, WorktreeSessionPermissionError, } from './worktree-view.js';
+import { executeWorktreeAction, createDefaultWorktreeName, createNumberedWorktreeName, createWorktreeModalViewLoader, createWorktreeRefreshGuard, filterArchivedSessionIds, mergeWorktreeView, mergeWorktreeViews, reconcileBaseBranchSelection, resolveWorktreeMove, selectDefaultBaseBranch, stableWorkspaceIds, toRetryableWorktreeOrderError, toWorktreeViewError, WorktreeSessionBindingError, WorktreeSessionPermissionError, } from './worktree-view.js';
 import styles from './worktree.css';
 function toNativeWorktreeViewError(error) {
     const viewError = toWorktreeViewError(error);
@@ -27,7 +27,11 @@ const EMPTY_PERMISSION_NOTICE_SUBSCRIBE = () => () => { };
 const EMPTY_PERMISSION_NOTICE_SNAPSHOT = () => EMPTY_PERMISSION_NOTICE;
 const EMPTY_FULL_ACCESS_CONFIRMATION_SUBSCRIBE = () => () => { };
 const EMPTY_FULL_ACCESS_CONFIRMATION_SNAPSHOT = () => undefined;
-const EMPTY_FORK_RECOVERY_SNAPSHOT = { revision: 0, pending: [] };
+const EMPTY_FORK_RECOVERY_SNAPSHOT = {
+    revision: 0,
+    pending: [],
+    affectedWorkspaceIds: [],
+};
 const EMPTY_FORK_RECOVERY_STORE = {
     getSnapshot: () => EMPTY_FORK_RECOVERY_SNAPSHOT,
     subscribe: () => () => { },
@@ -58,7 +62,7 @@ function useStableWorkspaceIds(workspaces) {
  * Peer Worktree navigation surface. It keeps the original DSH Workspace mode
  * intact and renders a browser-local Workspace → Worktree → Session projection.
  */
-export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces, t, available, expandState, sessionOrder, manager, permission, confirmFullAccess, fullAccessConfirmation, onPermissionResult, onPermissionNotice, permissionNotice, invalidateWorktreeContext, createWorkspace, createSessionForWorktree: createSessionCallback, createMainSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, insertSessionBefore, insertWorktreeBefore, renameSession, forkSession, archiveSession, forkRecovery, retryForkSession, ensureSessionWorkspace, syncSessionWorkspaces, openSession, }) {
+export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces, t, available, expandState, sessionOrder, manager, viewReader, permission, confirmFullAccess, fullAccessConfirmation, onPermissionResult, onPermissionNotice, permissionNotice, invalidateWorktreeContext, createWorkspace, createSessionForWorktree: createSessionCallback, createMainSession, renameWorkspace, deleteWorkspace, insertWorkspaceBefore, insertSessionBefore, insertWorktreeBefore, renameSession, forkSession, archiveSession, forkRecovery, retryForkSession, ensureSessionWorkspace, syncSessionWorkspaces, openSession, }) {
     const preferredMode = useStore((state) => state.viewMode);
     const mode = effectiveViewMode(preferredMode, available && manager !== undefined);
     const sessions = useSessions((state) => state);
@@ -67,6 +71,8 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const forkRecoverySnapshot = useSyncExternalStore(forkRecoveryStore.subscribe, forkRecoveryStore.getSnapshot, forkRecoveryStore.getSnapshot);
     const currentSessionId = sessions.current;
     const workspaceIds = useStableWorkspaceIds(workspaces.items);
+    const workspaceIdsRef = useRef(workspaceIds);
+    workspaceIdsRef.current = workspaceIds;
     const [readState, setReadState] = useState(EMPTY_READ_STATE);
     const expandSnapshot = useSyncExternalStore(expandState.subscribe, expandState.getSnapshot, expandState.getSnapshot);
     const permissionNoticeSnapshot = useSyncExternalStore(permissionNotice?.subscribe ?? EMPTY_PERMISSION_NOTICE_SUBSCRIBE, permissionNotice?.getSnapshot ?? EMPTY_PERMISSION_NOTICE_SNAPSHOT, permissionNotice?.getSnapshot ?? EMPTY_PERMISSION_NOTICE_SNAPSHOT);
@@ -131,8 +137,9 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const [worktreeDrag, setWorktreeDrag] = useState();
     const worktreeDropCommitted = useRef(false);
     const refreshGuard = useRef(createWorktreeRefreshGuard());
+    const targetRefreshGuards = useRef(new Map());
     const forkRecoveryRevisionRef = useRef(forkRecoverySnapshot.revision);
-    const modalReadLoader = useRef(createWorktreeModalViewLoader());
+    const modalReadLoader = useRef(createWorktreeModalViewLoader(viewReader));
     const modalReadViewRef = useRef();
     const importCandidatesGuard = useRef(createWorktreeRefreshGuard());
     const modalWorkspaceIdRef = useRef(worktreeModalWorkspaceId);
@@ -143,36 +150,131 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const archivedSessionIds = workspaces.archivedSessionIds ?? [];
     const pendingSessionArchived = pendingSessionBinding !== undefined &&
         archivedSessionIds.includes(pendingSessionBinding.sessionId);
+    const guardFor = (workspaceId) => {
+        const current = targetRefreshGuards.current.get(workspaceId);
+        if (current !== undefined)
+            return current;
+        const created = createWorktreeRefreshGuard();
+        targetRefreshGuards.current.set(workspaceId, created);
+        return created;
+    };
     const refresh = useCallback(async (options = {}) => {
         if (manager === undefined) {
             refreshGuard.current.invalidate();
+            for (const guard of targetRefreshGuards.current.values())
+                guard.invalidate();
             setReadState(EMPTY_READ_STATE);
             return;
         }
+        const scope = options.scope ?? { kind: 'global' };
         const preserveCurrent = options.preserveCurrent === true;
-        if (!preserveCurrent) {
-            setReadState({ status: 'loading', views: [] });
-        }
-        await refreshGuard.current.run(() => loadWorktreeViews(manager, workspaceIds, {
-            invalidateContext: options.invalidateContext !== false,
-            invalidateWorktreeContext,
-        }), (views) => {
-            setReadState({
-                status: 'ready',
-                views: modalReadViewRef.current === undefined
-                    ? views
-                    : mergeWorktreeView(views, modalReadViewRef.current),
-            });
-        }, (error) => {
-            if (preserveCurrent)
-                throw error;
-            setReadState({
-                status: 'error',
-                views: modalReadViewRef.current === undefined ? [] : [modalReadViewRef.current],
-                error: toWorktreeViewError(error),
+        const currentWorkspaceIds = workspaceIdsRef.current;
+        if (scope.kind === 'global') {
+            if (!preserveCurrent) {
+                setReadState({ status: 'loading', views: [] });
+            }
+            const selectedWorkspaceIds = [...currentWorkspaceIds];
+            for (const workspaceId of selectedWorkspaceIds) {
+                viewReader.invalidate(workspaceId);
+            }
+            const contextRefresh = options.invalidateContext === false
+                ? undefined
+                : invalidateWorktreeContext?.();
+            await refreshGuard.current.run(async () => {
+                const [views] = await Promise.all([
+                    viewReader.readMany(selectedWorkspaceIds),
+                    contextRefresh ?? Promise.resolve(),
+                ]);
+                return views;
+            }, (views) => {
+                setReadState((current) => {
+                    const merged = mergeWorktreeViews(current.views, workspaceIdsRef.current, views);
+                    return {
+                        status: 'ready',
+                        views: modalReadViewRef.current === undefined
+                            ? merged
+                            : mergeWorktreeView(merged, modalReadViewRef.current),
+                    };
+                });
+            }, (error) => {
+                if (preserveCurrent)
+                    throw error;
+                setReadState({
+                    status: 'error',
+                    views: modalReadViewRef.current === undefined ? [] : [modalReadViewRef.current],
+                    error: toWorktreeViewError(error),
+                });
             });
-        });
-    }, [invalidateWorktreeContext, manager, workspaceIds]);
+            return;
+        }
+        const requestedWorkspaceIds = scope.kind === 'workspace'
+            ? [scope.workspaceId]
+            : scope.workspaceIds;
+        const selectedWorkspaceIds = [...new Set(requestedWorkspaceIds)].filter((workspaceId) => currentWorkspaceIds.includes(workspaceId));
+        if (selectedWorkspaceIds.length === 0)
+            return;
+        await Promise.allSettled(selectedWorkspaceIds.map(async (workspaceId) => {
+            const guard = guardFor(workspaceId);
+            viewReader.invalidate(workspaceId);
+            const contextRefresh = options.invalidateContext === false
+                ? undefined
+                : invalidateWorktreeContext?.(workspaceId);
+            const generation = guard.begin();
+            try {
+                const view = await viewReader.read(workspaceId);
+                if (!guard.isCurrent(generation))
+                    return;
+                if (!workspaceIdsRef.current.includes(workspaceId))
+                    return;
+                setReadState((current) => {
+                    const remainingTargetError = current.targetError?.workspaceIds.filter((candidate) => candidate !== workspaceId) ?? [];
+                    const next = {
+                        ...current,
+                        status: 'ready',
+                        views: mergeWorktreeViews(current.views, workspaceIdsRef.current, [view]),
+                        error: undefined,
+                    };
+                    if (remainingTargetError.length === 0) {
+                        const withoutTargetError = { ...next };
+                        delete withoutTargetError.targetError;
+                        return withoutTargetError;
+                    }
+                    return {
+                        ...next,
+                        targetError: {
+                            workspaceIds: remainingTargetError,
+                            error: current.targetError.error,
+                        },
+                    };
+                });
+            }
+            catch (error) {
+                if (!guard.isCurrent(generation))
+                    return;
+                if (!workspaceIdsRef.current.includes(workspaceId))
+                    return;
+                setReadState((current) => {
+                    const previousIds = current.targetError?.workspaceIds ?? [];
+                    return {
+                        ...current,
+                        status: 'ready',
+                        views: mergeWorktreeViews(current.views, workspaceIdsRef.current, []),
+                        error: undefined,
+                        targetError: {
+                            workspaceIds: [...new Set([...previousIds, workspaceId])],
+                            error: {
+                                ...toWorktreeViewError(error),
+                                retryable: true,
+                            },
+                        },
+                    };
+                });
+            }
+            finally {
+                await contextRefresh?.catch(() => undefined);
+            }
+        }));
+    }, [invalidateWorktreeContext, manager, viewReader]);
     const loadModalWorktreeView = useCallback((workspaceId) => {
         setModalReadError(undefined);
         setModalReadLoading(true);
@@ -185,7 +287,7 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             });
             return;
         }
-        void modalReadLoader.current.load(manager, workspaceId, (view) => {
+        void modalReadLoader.current.load(workspaceId, (view) => {
             modalReadViewRef.current = view;
             setModalReadLoading(false);
             setReadState((current) => ({
@@ -196,13 +298,15 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             setModalReadLoading(false);
             setModalReadError(toWorktreeViewError(error));
         });
-    }, [manager]);
+    }, [manager, viewReader]);
     useEffect(() => {
         if (mode === 'worktree') {
             void refresh({ preserveCurrent: readStateRef.current.status === 'ready' });
         }
         else {
             refreshGuard.current.invalidate();
+            for (const guard of targetRefreshGuards.current.values())
+                guard.invalidate();
             modalReadLoader.current.invalidate();
             modalReadViewRef.current = undefined;
             setWorktreeModalWorkspaceId(undefined);
@@ -211,19 +315,67 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             setReadState(EMPTY_READ_STATE);
         }
     }, [mode, refresh]);
+    const previousWorkspaceIdsRef = useRef(workspaceIds);
+    useEffect(() => {
+        const previousWorkspaceIds = previousWorkspaceIdsRef.current;
+        previousWorkspaceIdsRef.current = workspaceIds;
+        if (mode !== 'worktree')
+            return;
+        const addedWorkspaceIds = workspaceIds.filter((workspaceId) => !previousWorkspaceIds.includes(workspaceId));
+        const removedWorkspaceIds = previousWorkspaceIds.filter((workspaceId) => !workspaceIds.includes(workspaceId));
+        for (const workspaceId of removedWorkspaceIds) {
+            targetRefreshGuards.current.delete(workspaceId);
+        }
+        setReadState((current) => {
+            const views = mergeWorktreeViews(current.views, workspaceIds, []);
+            const remainingTargetError = current.targetError?.workspaceIds.filter((workspaceId) => workspaceIds.includes(workspaceId)) ?? [];
+            const next = { ...current, views };
+            if (remainingTargetError.length === 0) {
+                const withoutTargetError = { ...next };
+                delete withoutTargetError.targetError;
+                return withoutTargetError;
+            }
+            return {
+                ...next,
+                targetError: {
+                    workspaceIds: remainingTargetError,
+                    error: current.targetError.error,
+                },
+            };
+        });
+        for (const workspaceId of addedWorkspaceIds) {
+            void refresh({
+                scope: { kind: 'workspace', workspaceId },
+                preserveCurrent: true,
+            }).catch(() => {
+                // The target error remains visible and can be retried explicitly.
+            });
+        }
+    }, [mode, refresh, workspaceIds]);
     useEffect(() => {
         if (forkRecoveryRevisionRef.current === forkRecoverySnapshot.revision)
             return;
         forkRecoveryRevisionRef.current = forkRecoverySnapshot.revision;
         if (mode !== 'worktree' || manager === undefined)
             return;
+        if (forkRecoverySnapshot.affectedWorkspaceIds.length === 0)
+            return;
         void refresh({
+            scope: {
+                kind: 'workspaces',
+                workspaceIds: forkRecoverySnapshot.affectedWorkspaceIds,
+            },
             preserveCurrent: readStateRef.current.status === 'ready',
-            invalidateContext: false,
         }).catch(() => {
             // Recovery state remains visible; the next explicit retry can refresh it again.
         });
-    }, [forkRecoverySnapshot.revision, manager, mode, refresh]);
+    }, [
+        forkRecoverySnapshot.affectedWorkspaceIds,
+        forkRecoverySnapshot.revision,
+        manager,
+        mode,
+        refresh,
+    ]);
     useEffect(() => {
         if (readState.status !== 'ready' || syncSessionWorkspaces === undefined)
             return;
@@ -376,12 +528,13 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             return createDefaultWorktreeName(existingNames);
         });
     }, [modalView, worktreeModalWorkspaceId]);
-    const runMutation = async (operation) => {
+    const runMutation = async (operation, refreshOptions) => {
         setActionPending(true);
         setActionError(undefined);
         try {
             await operation();
-            await refresh({ preserveCurrent: true });
+            if (refreshOptions !== undefined)
+                await refresh(refreshOptions);
         }
         catch (error) {
             setActionError(toWorktreeViewError(error));
@@ -578,7 +731,11 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         }
         setActionError(undefined);
         void insertWorktreeBefore(workspaceId, activeDrag.worktreeId, move.beforeWorktreeId)
-            .then(() => refresh({ preserveCurrent: true, invalidateContext: false }))
+            .then(() => refresh({
+            scope: { kind: 'workspace', workspaceId },
+            preserveCurrent: true,
+            invalidateContext: false,
+        }))
             .catch((error) => {
             setActionError(toRetryableWorktreeOrderError(error));
         });
@@ -756,7 +913,10 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
     const continueWorktreeRegistration = async (registeredWorktree) => {
         closeWorktreeCreator(true);
         if (createSessionCallback === undefined) {
-            await refresh({ preserveCurrent: true });
+            await refresh({
+                scope: { kind: 'workspace', workspaceId: registeredWorktree.workspaceId },
+                preserveCurrent: true,
+            });
             setActionError({
                 code: 'WORKTREE_REGISTRATION_SESSION_UNAVAILABLE',
                 message: '',
@@ -771,7 +931,6 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         };
         try {
             await createSessionCallback(sessionInput);
-            await invalidateWorktreeContext?.(registeredWorktree.workspaceId);
         }
         catch (error) {
             if (error instanceof WorktreeSessionBindingError && error.retryable) {
@@ -786,7 +945,10 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
             }
             throw error;
         }
-        await refresh({ preserveCurrent: true });
+        await refresh({
+            scope: { kind: 'workspace', workspaceId: registeredWorktree.workspaceId },
+            preserveCurrent: true,
+        });
     };
     const submitWorktree = async () => {
         const worktreeName = newBranch.trim();
@@ -848,8 +1010,10 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
         setPendingSessionBinding(undefined);
         try {
             await createSessionCallback(input);
-            await invalidateWorktreeContext?.(input.workspaceId);
-            await refresh({ preserveCurrent: true });
+            await refresh({
+                scope: { kind: 'workspace', workspaceId: input.workspaceId },
+                preserveCurrent: true,
+            });
         }
         catch (error) {
             if (error instanceof WorktreeSessionBindingError && error.retryable) {
@@ -888,8 +1052,10 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                 openSession,
             });
             setPendingSessionBinding(undefined);
-            await refresh({ preserveCurrent: true });
-            await invalidateWorktreeContext?.(pending.workspaceId);
+            await refresh({
+                scope: { kind: 'workspace', workspaceId: pending.workspaceId },
+                preserveCurrent: true,
+            });
         }
         catch (error) {
             if (error instanceof WorktreeSessionBindingError && !error.retryable) {
@@ -950,9 +1116,17 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                                     openSession(sessionId);
                                                 }, children: t('action.openCreatedSession') }))] })), actionError.retryable && (_jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
                                             setActionError(undefined);
-                                            void refresh();
-                                        }, children: t('action.retry') }))] })), readState.status === 'loading' && (_jsx("p", { className: styles.message, children: t('status.loading') })), readState.status === 'error' && readState.error !== undefined ? (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(readState.error, t) }), _jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
-                                            void refresh();
+                                            void refresh({ scope: { kind: 'global' } });
+                                        }, children: t('action.retry') }))] })), readState.targetError !== undefined && (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-target-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(readState.targetError.error, t) }), _jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
+                                            void refresh({
+                                                scope: {
+                                                    kind: 'workspaces',
+                                                    workspaceIds: readState.targetError.workspaceIds,
+                                                },
+                                                preserveCurrent: true,
+                                            });
+                                        }, children: t('action.retry') })] })), readState.status === 'loading' && (_jsx("p", { className: styles.message, children: t('status.loading') })), readState.status === 'error' && readState.error !== undefined ? (_jsxs("div", { className: styles.error, role: "alert", "data-worktree-error": true, children: [_jsx("p", { className: styles.message, "data-error": "true", children: formatWorktreeViewError(readState.error, t) }), _jsx("button", { type: "button", className: styles.retryButton, onClick: () => {
+                                            void refresh({ scope: { kind: 'global' } });
                                         }, children: t('action.retry') })] })) : readState.status === 'ready' ? (_jsx("div", { className: styles.workspaceList, children: visibleWorkspaces.length === 0 ? (_jsx("p", { className: styles.empty, children: t('workspace.noMatches') })) : (visibleWorkspaces.map((workspace) => {
                                     const view = viewByWorkspace.get(workspace.workspaceId);
                                     const currentBranch = view?.branches.find((branch) => branch.isCurrent)?.name;
@@ -1236,14 +1410,16 @@ export function WorktreeSurface({ useStore, actions, useSessions, useWorkspaces,
                                 mutationToken,
                             },
                         }, permission, onPermissionNotice);
-                        await invalidateWorktreeContext?.(target.workspaceId);
                         setWorktreeRemoval(undefined);
+                    }, {
+                        scope: { kind: 'workspace', workspaceId: target.workspaceId },
+                        preserveCurrent: true,
                     });
                 } }), _jsx(RiskConfirmation, { open: fullAccessConfirmationSnapshot !== undefined, title: t('permission.fullAccessTitle'), description: fullAccessConfirmationSnapshot === undefined
                     ? ''
                     : t('permission.fullAccessDescription', {
                         cwd: fullAccessConfirmationSnapshot.cwd,
-                    }), acknowledgeLabel: t('permission.fullAccessAcknowledge'), cancelLabel: t('dialog.cancel'), confirmLabel: t('permission.fullAccessEnable'), acknowledged: fullAccessAcknowledged, onAcknowledgedChange: setFullAccessAcknowledged, onCancel: () => {
+                    }), acknowledgeLabel: t('permission.fullAccessAcknowledge'), cancelLabel: t('dialog.cancel'), closeLabel: t('dialog.close'), confirmLabel: t('permission.fullAccessEnable'), acknowledged: fullAccessAcknowledged, onAcknowledgedChange: setFullAccessAcknowledged, onCancel: () => {
                     setFullAccessAcknowledged(false);
                     fullAccessConfirmation?.resolve(false);
                 }, onConfirm: () => {