@cueloop/client 0.1.0-alpha.101 → 0.1.0-alpha.103

package/src/annotations/use-annotation-surface.tsx

@@ -47,7 +47,7 @@ import {
   slashItemsFrom,
 } from "../keyboard/slash-palette";
 import { SlashSkillsContext } from "../keyboard/skills";
-import { discussionsFrom, type Discussion } from "./discussions";
+import { discussionsFrom, spanKey, type Discussion } from "./discussions";
 import {
   CommentRow,
   Composer,
@@ -107,13 +107,13 @@ export interface AnnotationSurfaceOptions {
   ) => boolean;
   focusedAnnotationId?: string;
   onFocusAnnotation?: (annotationId: string | undefined) => void;
-  onAnnotate: (span: TextSpan, body: string) => void;
-  onReply: (rootAnnotationId: string, body: string) => void;
+  onAnnotate: (span: TextSpan, body: string) => string | void;
+  onReply: (rootAnnotationId: string, body: string) => string | void;
   onUpdateAnnotation: (id: string, body: string) => void;
   isAnnotationReadOnly?: (id: string) => boolean;
   annotationAction?: (id: string) => { label: string; run: () => void } | undefined;
   requestedBlock?: { blockIndex: number };
-  onInvoke?: () => void;
+  onInvoke?: (commentId?: string) => void;
   isPromptBlock?: (blockIndex: number) => boolean;
   promptFocusRequest?: PromptFocusRequest;
   promptRestoreRequest?: PromptRestoreRequest;
@@ -176,6 +176,7 @@ function firstAnnotatable(source: LineSource): number {
 /** The visual-row direction requested by an arrow or readline-style caret key. */
 function verticalCaretDelta(key: KeyEvent): -1 | 0 | 1 {
   if (key.name === "up" || (key.ctrl && key.name === "p")) return -1;
+
   if (key.name === "down" || (key.ctrl && key.name === "n")) return 1;
 
   return 0;
@@ -228,6 +229,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
   useEffect(() => {
     if (requestedBlock === undefined) return;
+
     const next = { blockIndex: requestedBlock.blockIndex, char: 0 };
 
     setCursor(requestedBlock.blockIndex);
@@ -259,7 +261,9 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const { blockIndex } = caret.head;
 
     if (source.count === 0) return;
+
     if (blockIndex < source.count && source.annotatable(blockIndex)) return;
+
     const clamped = Math.min(blockIndex, source.count - 1);
     const next = source.annotatable(clamped)
       ? clamped
@@ -277,17 +281,26 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   // app owns it (onFocusAnnotation), the focused discussion is the one holding
   // the focused card and focusing here names the root comment; standalone, it
   // is local state
-  const [localFocus, setLocalFocus] = useState<string | null>(null);
-  const focusedDiscussion =
-    onFocusAnnotation === undefined
-      ? localFocus
-      : (discussions.find((discussion) =>
-          discussion.annotations.some((annotation) => annotation.id === focusedAnnotationId),
-        )?.key ?? null);
+  const [localFocus, setLocalFocus] = useState<{ key: string; annotationId?: string } | null>(null);
+  const getFocusedDiscussion = (): string | null => {
+    if (onFocusAnnotation === undefined) return localFocus?.key ?? null;
+
+    return (
+      discussions.find((discussion) =>
+        discussion.annotations.some((annotation) => annotation.id === focusedAnnotationId),
+      )?.key ?? null
+    );
+  };
+  const focusedDiscussion = getFocusedDiscussion();
   const setFocusedDiscussion = (key: string | null): void => {
-    if (onFocusAnnotation === undefined) return setLocalFocus(key);
+    if (onFocusAnnotation === undefined) return setLocalFocus(key === null ? null : { key });
+
     onFocusAnnotation(discussions.find((discussion) => discussion.key === key)?.rootId);
   };
+  const focusSavedComment = (annotationId: string, key: string): void => {
+    if (onFocusAnnotation) onFocusAnnotation(annotationId);
+    else setLocalFocus({ key, annotationId });
+  };
   const [folded, setFolded] = useState<Set<string>>(new Set());
   const [composeText, setComposeText] = useState("");
   const [composerFocusRequest, setComposerFocusRequest] = useState(0);
@@ -331,7 +344,9 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   /** Agent comments require a held selection; legacy surfaces may use the caret word. */
   const caretSpan = (): TextSpan | null => {
     if (heldSpan) return heldSpan;
+
     if (onInvoke) return isPromptBlock?.(head.blockIndex) ? { start: head, end: head } : null;
+
     const word = wordRangeAt(blockText(head.blockIndex), head.char);
 
     return word
@@ -381,15 +396,18 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     return (delta, top, bottom) => {
       if (delta === 0 || oldHeadY === undefined || compose || focusedDiscussion || caretIsSelection)
         return;
+
       const shiftedHeadY = oldHeadY - delta;
 
       if (shiftedHeadY >= top && shiftedHeadY <= bottom) return;
+
       const visible = lines
         .filter((line) => line.y - delta >= top && line.y - delta <= bottom)
         .toSorted((left, right) => left.y - right.y || left.x - right.x);
       const target = delta < 0 ? visible.at(-1) : visible[0];
 
       if (!target) return;
+
       const next = { blockIndex: target.blockIndex, char: target.start };
 
       flushSync(() => {
@@ -416,6 +434,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const target = currentIndex === -1 ? undefined : lines[currentIndex + direction];
 
     if (!target) return null;
+
     const current = lines[currentIndex]!;
     const column = Math.max(0, position.char - current.start);
 
@@ -431,8 +450,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   const openCompose = (state: ComposeState): void => {
     // a view-only surface (a non-diff thread's live diff) never opens a draft
     if (!commentsEnabled) return;
+
     if (observer) return onObserverBlocked?.("observer");
+
     if (resolved) return onObserverBlocked?.("resolved");
+
     composerReady.current = false;
     readComposerText.current = null;
     composeRef.current = state;
@@ -468,31 +490,55 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const prompt = target?.kind === "prompt";
 
     if (prompt && !invoke) return;
+
     closeCompose();
     collapseCaret();
+
     if (!target || body.trim().length === 0) return;
+
     if (target.editAnnotationId !== null) {
       onUpdateAnnotation(target.editAnnotationId, body);
-      if (invoke) onInvoke?.();
+
+      if (target.discussionKey) focusSavedComment(target.editAnnotationId, target.discussionKey);
+
+      if (invoke) onInvoke?.(target.editAnnotationId);
 
       return;
     }
+
     if (target.discussionKey !== null) {
       const discussion = discussions.find((candidate) => candidate.key === target.discussionKey);
 
       if (discussion) {
-        onReply(discussion.rootId, body);
-        if (invoke) onInvoke?.();
+        const commentId = onReply(discussion.rootId, body);
+
+        if (commentId) focusSavedComment(commentId, discussion.key);
+
+        if (invoke && commentId) onInvoke?.(commentId);
 
         return;
       }
     }
+
     const span = target.span ?? caretSpan();
 
     if (span) {
-      onAnnotate(span, body);
-      if (invoke) onInvoke?.();
+      const commentId = onAnnotate(span, body);
+
+      completeSavedComment(span, commentId, prompt, invoke);
+    }
+  };
+  const completeSavedComment = (
+    span: TextSpan,
+    commentId: string | void,
+    prompt: boolean,
+    invoke: boolean,
+  ): void => {
+    if (!prompt && commentId) {
+      focusSavedComment(commentId, spanKey(span));
     }
+
+    if (invoke && (prompt || commentId)) onInvoke?.(commentId || undefined);
   };
   /** A new discussion on the typing anchor; the card renders under the span's last block. */
   const openNewCompose = (seed: string): void => {
@@ -503,6 +549,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       agentInputTarget(Boolean(isPromptBlock?.(head.blockIndex)), Boolean(heldSpan)) === "none"
     )
       return;
+
     if (isPromptBlock?.(head.blockIndex) && span) {
       openCompose({
         kind: "prompt",
@@ -522,6 +569,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
         editAnnotationId: null,
       });
     }
+
     if (isPromptBlock?.(head.blockIndex)) promptDraft.current = "";
   };
 
@@ -531,14 +579,17 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const target = composeRef.current;
 
     if (!target) return;
+
     if (target.kind === "prompt") {
       promptDraft.current = composeTextRef.current;
 
       return closeCompose();
     }
+
     if (isStandaloneSlashQuery(composeText) || composeText.trim().length === 0) {
       return closeCompose();
     }
+
     saveComment(composeText, false);
   };
 
@@ -547,6 +598,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const drag = dragging.current;
 
     if (!drag) return;
+
     let next = { head: pointer, anchor: drag.anchor };
 
     if (drag.wordMode) {
@@ -561,7 +613,9 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
           : { anchor: snapped.end, head: snapped.start };
       }
     }
+
     if (comparePositions(next.head, drag.head) === 0) return;
+
     drag.head = next.head;
     setCursor(next.head.blockIndex);
     setCaret({ head: next.head, anchor: next.anchor });
@@ -574,19 +628,23 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   // on screen - the mark follows the pointer across blocks.
   const handleRootDrag = (event: TerminalMouseEvent): void => {
     if (!dragging.current) return;
+
     dragPointer.current = { x: event.x, y: event.y };
     const position = positionAt(allGeometry(), event.x, event.y);
 
     if (position) extendSelectionTo(position);
+
     if (edgeScrollTimer.current === null) {
       edgeScrollTimer.current = setInterval(() => {
         const pointer = dragPointer.current;
         const viewport = dragViewportRef.current?.();
 
         if (!dragging.current || !pointer || !viewport) return;
+
         const direction = pointer.y <= viewport.top ? -1 : pointer.y >= viewport.bottom ? 1 : 0;
 
         if (direction === 0 || !viewport.scrollBy(direction)) return;
+
         const next = positionAt(allGeometry(), pointer.x, pointer.y);
 
         if (next) extendSelectionTo(next);
@@ -596,7 +654,9 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   const endDrag = (): void => {
     dragging.current = null;
     dragPointer.current = null;
+
     if (edgeScrollTimer.current !== null) clearInterval(edgeScrollTimer.current);
+
     edgeScrollTimer.current = null;
   };
 
@@ -606,6 +666,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const target = discussions.find((discussion) => discussion.key === key);
 
     if (!target) return;
+
     blurSaveCompose();
     setCursor(target.blockIndex);
     setFocusedDiscussion(key);
@@ -615,6 +676,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
   const handleSlashKey = (key: KeyEvent, activeCompose: ComposeState): boolean => {
     if (!slashActive || slashItems.length === 0) return false;
+
     const selected = Math.min(slashIndex, slashItems.length - 1);
 
     if (key.name === "up") {
@@ -622,11 +684,13 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return true;
     }
+
     if (key.name === "down") {
       setSlashIndex(Math.min(slashItems.length - 1, selected + 1));
 
       return true;
     }
+
     if (key.name === "return" || key.name === "tab") {
       const inserted = insertSlashItem(composeText, caretOffset, slashItems[selected]!.name);
 
@@ -643,8 +707,10 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   const handlePremountKey = (key: KeyEvent, activeCompose: ComposeState): void => {
     if (key.name === "return") {
       if (key.super && onInvoke) return;
+
       if (key.meta || key.ctrl || key.super)
         return saveComment(activeCompose.seed, isAgentInvokeKey(key, onInvoke));
+
       const grown = { ...activeCompose, seed: `${activeCompose.seed}\n` };
 
       composeRef.current = grown;
@@ -653,6 +719,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return setCompose(grown);
     }
+
     const sequence = printableSequence(key);
 
     if (sequence) {
@@ -671,11 +738,13 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return;
     }
+
     if (isAgentInvokeKey(key, onInvoke)) {
       key.preventDefault();
 
       return saveComment(readComposerText.current?.() ?? activeCompose.seed, true);
     }
+
     // the textarea owns every key while open; the view takes dismiss (which
     // also releases the discussion focus), the slash palette, and pre-mount input
     if (key.name === "escape") {
@@ -683,6 +752,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return closeCompose();
     }
+
     // backspace on an already empty draft undoes it: the card dissolves
     // and the caret sits back on the still-held selection, ready to re-type
     // (an edit of an existing comment is never deleted this way)
@@ -693,7 +763,9 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     ) {
       return closeCompose();
     }
+
     if (handleSlashKey(key, activeCompose)) return;
+
     if (!composerReady.current) handlePremountKey(key, activeCompose);
   };
 
@@ -704,6 +776,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       for (const discussion of discussions) {
         if (discussion.blockIndex !== cursor) continue;
+
         if (next.has(discussion.key)) next.delete(discussion.key);
         else next.add(discussion.key);
       }
@@ -720,8 +793,10 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return true;
     }
+
     if ((key.super || key.meta || key.ctrl) && (key.name === "[" || key.name === "]")) {
       if (discussions.length === 0) return true;
+
       const currentIndex = discussions.findIndex(
         (discussion) => discussion.key === focusedDiscussion,
       );
@@ -736,6 +811,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return true;
     }
+
     // enter replies into the focused discussion, else the cursor block's discussion
     if (key.name === "return") {
       const replyTarget =
@@ -772,15 +848,19 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     };
 
     if (target !== null) return moveTo(head.blockIndex, target);
+
     if (extend && head.char !== (delta === 1 ? text.length : 0)) {
       // the block edge first, then the next step crosses into the neighbour
       return moveTo(head.blockIndex, delta === 1 ? text.length : 0);
     }
+
     // the neighbour is the next block the caret may rest on: headers are skipped
     const neighbour = nearestAnnotatable(source, head.blockIndex, delta);
 
     if (neighbour === head.blockIndex) return;
+
     if (delta === 1) return moveTo(neighbour, 0);
+
     const previousText = blockText(neighbour);
 
     moveTo(
@@ -794,6 +874,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const visualTarget = verticalTextPosition(head, vertical);
 
     if (!visualTarget && nextBlock === head.blockIndex) return;
+
     const nextHead = visualTarget?.position ?? {
       blockIndex: nextBlock,
       char: key.shift ? Math.min(head.char, textLengthOf(nextBlock)) : 0,
@@ -817,11 +898,13 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return true;
     }
+
     if (key.name === "right" || (key.ctrl && key.name === "l")) {
       moveCaretHorizontal(1, Boolean(key.shift || key.meta || key.ctrl));
 
       return true;
     }
+
     if (key.name === "left" || (key.ctrl && key.name === "h")) {
       moveCaretHorizontal(-1, Boolean(key.shift || key.meta || key.ctrl));
 
@@ -836,6 +919,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const sequence = printableSequence(key);
 
     if (!sequence) return;
+
     const discussion = discussions.find((candidate) => candidate.key === focusedDiscussion);
 
     if (discussion) {
@@ -851,36 +935,57 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
         editAnnotationId: editingOwn ? last.id : null,
       });
     }
+
     openNewCompose(sequence);
   };
 
+  const invokeFocusedComment = (): void => {
+    const discussion = discussions.find((candidate) => candidate.key === focusedDiscussion);
+    const focusedCommentId = focusedAnnotationId ?? localFocus?.annotationId;
+    const commentId =
+      discussion?.annotations.find((annotation) => annotation.id === focusedCommentId)?.id ??
+      discussion?.annotations.at(-1)?.id;
+
+    onInvoke?.(commentId);
+  };
+
   useSharedKeyboard((key) => {
     if (suspended) return;
+
     if (key.ctrl && key.name === "q") return onExit();
+
     const activeCompose = composeRef.current;
 
     if (activeCompose) return handleComposeKey(key, activeCompose);
+
     if (isAgentInvokeKey(key, onInvoke)) {
       key.preventDefault();
 
-      return onInvoke?.();
+      return invokeFocusedComment();
     }
+
     if (key.name === "escape") {
       // from type mode esc only enters nav, so a held mark survives for `c`
       if (!navModeRef.current) return setNavMode(true);
+
       if (focusedDiscussion !== null) setFocusedDiscussion(null);
 
       return collapseCaret();
     }
+
     if (navModeRef.current) {
       if (handleCaretKey(key)) return;
+
       if (key.name === "z") return toggleFoldAtCursor();
+
       if (onNavCommand?.(key, heldSpan)) return;
+
       if (key.name === "c") {
         setNavMode(false);
 
         return openNewCompose("");
       }
+
       if (printableSequence(key)) {
         setNavMode(false);
         startTyping(key);
@@ -888,8 +993,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return;
     }
+
     if (handleDiscussionVerb(key)) return;
+
     if (handleCaretKey(key)) return;
+
     startTyping(key);
   });
 
@@ -951,6 +1059,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
             tokens={tokens}
             authorLabel={resolveAuthorLabel?.(annotation)}
             action={annotationAction?.(annotation.id)}
+            onFocus={() => {
+              blurSaveCompose();
+              focusSavedComment(annotation.id, discussion.key);
+              setCursor(discussion.blockIndex);
+            }}
           />
         ),
       };
@@ -968,6 +1081,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
         focused={focusedDiscussion === discussion.key}
         onFocus={() => {
           if (composeRef.current?.discussionKey === discussion.key) return;
+
           blurSaveCompose();
           setFocusedDiscussion(discussion.key);
           setCursor(discussion.blockIndex);
@@ -986,8 +1100,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     };
 
     for (const discussion of discussions) pushSpan(discussion.span);
+
     if (compose) pushSpan(compose.span);
+
     if (caretIsSelection && !compose) pushSpan(heldSpan);
+
     // the idle caret cell sits at the head, also at the end of a held mark;
     // an open card takes the cursor with it, so no cell is painted then
     if (blockIndex === head.blockIndex && !compose && textLength > 0) {
@@ -1025,6 +1142,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
         return;
       }
+
       nodes.push(
         <DiscussionCard
           key="compose-new"
@@ -1041,6 +1159,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
     for (const discussion of discussions) {
       if (discussion.blockIndex !== blockIndex || !endsInLine(discussion.span.end.char)) continue;
+
       if (
         composePending &&
         composeStart &&
@@ -1049,15 +1168,19 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
         pushComposeCard();
         composePending = false;
       }
+
       const composingHere = Boolean(composeHere && compose.discussionKey === discussion.key);
 
       if (folded.has(discussion.key) && !composingHere) {
         nodes.push(foldedSummaryFor(discussion));
         continue;
       }
+
       nodes.push(discussionCardFor(discussion, composingHere));
+
       if (composingHere) nodes.push(paletteNode);
     }
+
     if (composePending) pushComposeCard();
 
     return nodes;
@@ -1105,6 +1228,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       active.blockIndex === blockIndex
     )
       return;
+
     const position = { blockIndex, char: 0 };
 
     openCompose({
@@ -1123,12 +1247,15 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   const restoredPrompt = useRef<number | null>(null);
   const restorePrompt = useEffectEvent(() => {
     if (!promptRestoreRequest || suspended || !onInvoke) return;
+
     if (restoredPrompt.current === promptRestoreRequest.id) return;
+
     restoredPrompt.current = promptRestoreRequest.id;
     const active = composeRef.current;
     const newerDraft = active?.kind === "prompt" ? composeTextRef.current : promptDraft.current;
 
     if (active?.kind !== "prompt") blurSaveCompose();
+
     promptDraft.current = [promptRestoreRequest.text, newerDraft].filter(Boolean).join("\n");
     focusPrompt(source.count - 1);
   });
@@ -1139,10 +1266,14 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   const focusedReply = useRef<string | null>(null);
   const continueConversation = useEffectEvent(() => {
     if (!promptFocusRequest || suspended || !onInvoke) return;
+
     if (focusedReply.current === promptFocusRequest.replyId) return;
+
     focusedReply.current = promptFocusRequest.replyId;
+
     // An arriving answer cannot replace a draft or a marked passage under review.
     if (composeRef.current || heldSpan || dragging.current || promptDraft.current) return;
+
     focusPrompt(promptFocusRequest.blockIndex);
   });
 
@@ -1151,6 +1282,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
   }, [promptFocusRequest?.replyId, promptFocusRequest?.blockIndex, suspended]);
   const onPromptMouseDown = (event: TerminalMouseEvent): void => {
     if (!onInvoke || suspended) return;
+
     const blockIndex = source.count - 1;
     const geometry = allGeometry();
     const promptLine = geometry.find((entry) => isPromptBlock?.(entry.blockIndex));
@@ -1168,9 +1300,11 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
       (viewport && event.y >= viewport.bottom)
     )
       return;
+
     if (composeRef.current?.kind === "prompt") {
       promptDraft.current = composeTextRef.current;
     } else blurSaveCompose();
+
     endDrag();
     focusPrompt(blockIndex);
   };
@@ -1180,6 +1314,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     const pressed = positionAt(allGeometry(), event.x, event.y);
 
     if (!pressed || !source.annotatable(pressed.blockIndex)) return;
+
     setNavMode(false);
     const stamp = { time: Date.now(), x: event.x, y: event.y };
     const wordMode = isDoubleClick(lastClick.current, stamp);
@@ -1231,7 +1366,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
 function isAgentInvokeKey(
   key: { name: string; ctrl?: boolean; meta?: boolean; super?: boolean },
-  onInvoke?: () => void,
+  onInvoke?: (commentId?: string) => void,
 ): boolean {
   return Boolean(
     onInvoke &&

package/src/app/App.deleted-scroll.test.tsx

@@ -73,9 +73,11 @@ test("deleted file caret scrolls one row and stays at the file boundaries", asyn
     const box = findScrollbox(setup.renderer.root);
 
     if (!box) throw new Error("file diff scrollbox missing");
+
     for (let offset = 0; offset < 1000; offset += 20) {
       box.scrollTo({ x: 0, y: offset });
       await settle(setup);
+
       if (setup.captureCharFrame().includes("row 130")) break;
     }
     const target = locateText(setup, "row 130");
@@ -127,6 +129,7 @@ test("deleted file caret scrolls one row and stays at the file boundaries", asyn
         .findIndex((line) => line.includes("▎"));
 
       if (marker === box.viewport.screenY) anchored = true;
+
       if (anchored && box.scrollTop > 0) expect(marker).toBe(box.viewport.screenY);
     }
     expect(anchored).toBe(true);