@cueloop/client 0.1.0-alpha.78 → 0.1.0-alpha.79

package/src/thread-controller.ts

@@ -8,6 +8,7 @@
  */
 
 import { SystemClock, type Clock, type TimerHandle } from "@opentui/core";
+import { createStore, type StoreApi } from "zustand/vanilla";
 import { DaemonClient, type SessionClient } from "@cueloop/daemon/client";
 import {
   applyPathView,
@@ -25,12 +26,14 @@ import {
   restoreLine,
   returnPaneFor,
   switchBranch,
+  threadShareLinks,
   viewOfPath,
   type Anchor,
   type Annotation,
   type AnnotationTarget,
   type Artifact,
   type DiffFileContents,
+  type ShareLink,
   type Thread,
   type SessionHistory,
   type VerdictKind,
@@ -42,10 +45,12 @@ import {
   publishShare,
   pullShare,
   pushShare,
+  revokeShare,
   watchShare,
   shareIdFromLine,
+  formatShareLine,
 } from "./share";
-import { buildDisplay, nextWorkBlock, type DisplayBlock } from "./view-plan";
+import { buildDisplay, nextWorkBlock, renderedSpanToWork, type DisplayBlock } from "./view-plan";
 import { entryTarget, treeRows, type TreeRow } from "./tree-view";
 import {
   diffRowBlocks,
@@ -191,8 +196,10 @@ export interface ShareTransport {
   publish: typeof publishShare;
   pull: typeof pullShare;
   push: typeof pushShare;
+  revoke: typeof revokeShare;
   watch: typeof watchShare;
   parseShareId: typeof shareIdFromLine;
+  formatShareLine: typeof formatShareLine;
   collaboratorAnnotations: typeof collaboratorAnnotations;
   mergeFromShare: typeof mergeFromShare;
 }
@@ -202,11 +209,20 @@ const DEFAULT_SHARE_TRANSPORT: ShareTransport = {
   pull: pullShare,
   watch: watchShare,
   push: pushShare,
+  revoke: revokeShare,
   parseShareId: shareIdFromLine,
+  formatShareLine,
   collaboratorAnnotations,
   mergeFromShare,
 };
 
+/** The editable fields of a share link, as the share wizard collects them. */
+export interface NewShareLink {
+  name?: string;
+  requireAuth: boolean;
+  allowlist: string[];
+}
+
 export interface ReviewControllerOptions {
   home?: string;
   sessionId?: string;
@@ -291,6 +307,8 @@ export interface ReviewController {
   restoreCuration(id: string): void;
   /** The $EDITOR hand-off on the working copy. */
   edit(): void;
+  /** Track an edited thread body as the working copy and re-resolve annotations against it. */
+  saveEditedBody(content: string): void;
   /**
    * Anchor and store an annotation; both plan and diff anchor constructions.
    * `end` is an offset within `endDisplayIndex` (the same block by default).
@@ -342,10 +360,22 @@ export interface ReviewController {
   walkLeave(): void;
   /** Resolve the review, run the export, start the completion hand-back. */
   submit(verdict: VerdictKind, summary: string): void;
-  /** Publish the current session as a share; the ssh line lands on the clipboard. */
+  /** Publish the current session as a public share link; the ssh line lands on the clipboard. */
   share(): void;
+  /** Stop sharing the current session, revoking every link at the gateway. Owner only. */
+  unshare(): void;
   /** Replace the private-share allowlist of GitHub logins for the current session. Owner only. */
   setShareAccess(githubLogins: string[]): void;
+  /** The current thread's share links (a legacy single share migrates to a one-element list). */
+  shareLinks(): ShareLink[];
+  /** Publish a new share link with the given name and auth; the ssh line lands on the clipboard. Owner only. */
+  createShareLink(input: NewShareLink): void;
+  /** Update a link's name and auth in place, re-pushing its access to the gateway. Owner only. */
+  updateShareLink(id: string, input: NewShareLink): void;
+  /** Revoke a link and remove it from the thread. Owner only. */
+  deleteShareLink(id: string): void;
+  /** Copy a link's ssh line to the clipboard. */
+  copyShareLink(id: string): void;
   /** The session tree as rows for the rail's Tree tab, cached per session identity. */
   treeRows(): TreeRow[];
   /**
@@ -406,7 +436,8 @@ class Controller implements ReviewController {
   readonly readOnly: boolean;
   private client: SessionClient | null = null;
   private closed = false;
-  private snapshot: ControllerSnapshot = {
+  /** The controller's state lives in a zustand store; internal reads go through the snapshot getter. */
+  private readonly store: StoreApi<ControllerSnapshot> = createStore<ControllerSnapshot>(() => ({
     session: null,
     inbox: null,
     status: "",
@@ -415,8 +446,10 @@ class Controller implements ReviewController {
     completion: { phase: "idle" },
     editOrphanCount: 0,
     walk: null,
-  };
-  private listeners = new Set<() => void>();
+  }));
+  private get snapshot(): ControllerSnapshot {
+    return this.store.getState();
+  }
   private autoClose: AutoClose = "off";
   private quickActions: QuickAction[] = [];
   private editor: string | undefined;
@@ -442,6 +475,8 @@ class Controller implements ReviewController {
   };
   /** Recently-viewed threads' parsed projections, so returning to a thread reuses its work instead of re-parsing. */
   private derivedCache = new Map<string, DerivedCacheEntry>();
+  /** The thread the view is on now; a revalidation for a since-abandoned thread is discarded. */
+  private viewingId: string | undefined;
   /** File paths whose diff body is folded to just the file band. */
   private collapsedFiles = new Set<string>();
   /** File paths woven to their full contents (unchanged lines shown as context). */
@@ -457,17 +492,12 @@ class Controller implements ReviewController {
     this.shareTransport = options.shareTransport ?? DEFAULT_SHARE_TRANSPORT;
   }
 
-  subscribe = (listener: () => void): (() => void) => {
-    this.listeners.add(listener);
+  subscribe = (listener: () => void): (() => void) => this.store.subscribe(listener);
 
-    return () => this.listeners.delete(listener);
-  };
-
-  getSnapshot = (): ControllerSnapshot => this.snapshot;
+  getSnapshot = (): ControllerSnapshot => this.store.getState();
 
   private update(patch: Partial<ControllerSnapshot>): void {
-    this.snapshot = { ...this.snapshot, ...this.freezeServed(patch) };
-    for (const listener of this.listeners) listener();
+    this.store.setState(this.freezeServed(patch));
   }
 
   /** Serve mode pins the served thread's diff to a snapshot; its annotations and the rest stay live. */
@@ -503,6 +533,7 @@ class Controller implements ReviewController {
         const inbox = await client.sessionList({ status: "pending" });
 
         if (this.options.sessionId) {
+          this.viewingId = this.options.sessionId;
           this.update({ session: await client.sessionGet(this.options.sessionId), inbox });
         } else {
           this.update({ inbox });
@@ -811,7 +842,11 @@ class Controller implements ReviewController {
   // surface that as an unhandled rejection.
   private async refreshSession(id: string): Promise<void> {
     try {
-      if (this.client) this.update({ session: await this.client.sessionGet(id) });
+      if (!this.client) return;
+      const session = await this.client.sessionGet(id);
+
+      // a rapid switch may have moved on during the fetch; never clobber the now-viewed thread
+      if (this.viewingId === session.id) this.update({ session });
     } catch (cause) {
       if (!this.closed) this.setStatus(cause instanceof Error ? cause.message : String(cause));
     }
@@ -853,22 +888,42 @@ class Controller implements ReviewController {
   // ── primitives ───────────────────────────────────
   open(id: string): void {
     this.locallyViewed.clear();
+    this.viewingId = id;
     const cached = this.snapshot.inbox?.find((candidate) => candidate.id === id);
 
+    // paint the sidebar copy at once for a snappy switch, then revalidate: the inbox
+    // copy trails the daemon for a live diff, whose session.updated refreshes the open
+    // thread but not the list, so a returned-to diff would otherwise show stale content
     if (cached) this.update({ session: cached });
-    else void this.refreshSession(id);
+    void this.refreshSession(id);
   }
 
   deleteSession(id: string): void {
     if (this.readOnly) return this.setStatus("observer - read-only");
+    // a deleted thread's links must not outlive it; revoke every one first, best-effort, so an
+    // unreachable gateway never blocks the local delete (the blob's 30-day TTL is the backstop)
+    for (const link of this.linksFor(this.sessionRecord(id)))
+      void this.shareTransport.revoke(link.id).catch(() => {});
     this.client
       ?.sessionDelete(id)
-      .then(() => this.setStatus("plan deleted"))
+      .then(() => this.setStatus("thread deleted"))
       .catch((cause: unknown) =>
         this.setStatus(`delete failed: ${cause instanceof Error ? cause.message : String(cause)}`),
       );
   }
 
+  /** The record for a thread id, whether it is the open thread or a sidebar row. */
+  private sessionRecord(id: string): Thread | undefined {
+    if (this.snapshot.session?.id === id) return this.snapshot.session;
+
+    return this.snapshot.inbox?.find((candidate) => candidate.id === id);
+  }
+
+  /** A thread's share links, migrating a legacy single share; empty when never shared. */
+  private linksFor(session: Thread | null | undefined): ShareLink[] {
+    return session ? (threadShareLinks(session) ?? []) : [];
+  }
+
   renameSession(id: string, title: string): void {
     if (this.readOnly) return this.setStatus("observer - read-only");
     this.client
@@ -1019,15 +1074,16 @@ class Controller implements ReviewController {
   }
 
   setShareAccess(githubLogins: string[]): void {
-    const session = this.snapshot.session;
-
-    if (!session) return;
-    const access = { githubLogins };
-    const expected: Thread = { ...session, access };
-
-    this.applyOptimistic(expected, this.client!.sessionSetAccess(session.id, githubLogins));
-    // an already-shared link must enforce the new access, so push it up to the gateway blob
-    if (session.shareId) void this.shareTransport.push(session.shareId, [], access).catch(() => {});
+    if (this.readOnly) return this.setStatus("observer - read-only");
+    // legacy single-allowlist entry point: apply it to the thread's primary link
+    const primary = this.linksFor(this.snapshot.session)[0];
+
+    if (!primary) return;
+    this.updateShareLink(primary.id, {
+      name: primary.name,
+      requireAuth: true,
+      allowlist: githubLogins,
+    });
   }
 
   rejectedRows(): Set<number> {
@@ -1142,8 +1198,7 @@ class Controller implements ReviewController {
       const result = editInEditor(this.working(), "plan.md", { editor: this.editor });
 
       if (result.changed) {
-        this.setWorkingCopy(result.content);
-        this.reconcileAnnotations(session, result.content);
+        this.saveEditedBody(result.content);
         this.setStatus("edits tracked - one diff");
       } else this.setStatus("no changes");
     } catch (err) {
@@ -1151,6 +1206,16 @@ class Controller implements ReviewController {
     }
   }
 
+  // no toast: leaving the inline editor is a quiet return to the read-only view
+  saveEditedBody(content: string): void {
+    const session = this.snapshot.session;
+
+    if (!session || session.status === "resolved") return;
+    if (content === this.working()) return;
+    this.setWorkingCopy(content);
+    this.reconcileAnnotations(session, content);
+  }
+
   /**
    * Edit-exit reconciliation: re-resolve every annotation against the edited
    * working copy with the quote-primary cascade. Annotations that stop
@@ -1212,12 +1277,15 @@ class Controller implements ReviewController {
       const workBlocks = display.filter((entry) => entry.work).map((entry) => entry.work!);
       const workIndexOf = (index: number): number =>
         display.slice(0, index + 1).filter((entry) => entry.work).length - 1;
+      // the plan surface hands back rendered offsets (inline markers concealed); the quote is cut
+      // from work text, so map the selection onto the work characters it covers first
+      const work = renderedSpanToWork(display, displayIndex, endDisplayIndex, start, end);
 
       anchor = makeAnchor(
         workBlocks,
         workIndexOf(displayIndex),
-        start,
-        end,
+        work.start,
+        work.end,
         workIndexOf(endDisplayIndex),
       );
     }
@@ -1359,12 +1427,16 @@ class Controller implements ReviewController {
     annotation: Omit<Annotation, "createdAt">,
   ): void {
     const session = this.snapshot.session;
-    const shareId = session?.shareId;
+    const branch = session?.history?.branch;
+    // each link follows one branch: a note lands on the links whose branch is the one being edited
+    const links = this.linksFor(session).filter(
+      (link) => branch === undefined || branch === (link.shareBranch ?? MAIN_BRANCH),
+    );
 
-    if (!shareId) return;
-    // the share follows one branch: a note left on another stays the owner's
-    if (session.history && session.history.branch !== (session.shareBranch ?? MAIN_BRANCH)) return;
-    void persisted.then(() => this.shareTransport.push(shareId, [annotation])).catch(() => {});
+    if (links.length === 0) return;
+    void persisted
+      .then(() => Promise.all(links.map((link) => this.shareTransport.push(link.id, [annotation]))))
+      .catch(() => {});
   }
 
   removeAnnotation(id: string): void {
@@ -1479,25 +1551,118 @@ class Controller implements ReviewController {
   }
 
   share(): void {
+    this.createShareLink({ requireAuth: false, allowlist: [] });
+  }
+
+  shareLinks(): ShareLink[] {
+    return this.linksFor(this.snapshot.session);
+  }
+
+  createShareLink(input: NewShareLink): void {
+    if (this.readOnly) return this.setStatus("observer - read-only");
     const session = this.snapshot.session;
 
-    if (!session) return;
+    if (!session || !this.client) return;
+    const client = this.client;
+    const shareBranch = session.history?.branch ?? MAIN_BRANCH;
+
     this.setStatus("sharing…");
     this.freezeForShare(session)
-      .then((shared) => this.shareTransport.publish(shared))
-      .then(async ({ line, copied }) => {
-        // Stamp the id back so a later pull knows which share to collect from.
-        const shareId = this.shareTransport.parseShareId(line);
+      .then((shared) => {
+        // bake this link's access into its own blob: an allowlist gates it, absent = public
+        const access = input.requireAuth ? { githubLogins: input.allowlist } : undefined;
 
-        if (shareId && this.client) await this.client.sessionSetShareId(session.id, shareId);
+        return this.shareTransport.publish({ ...shared, access, shareBranch });
+      })
+      .then(async ({ line, copied }) => {
+        const id = this.shareTransport.parseShareId(line);
+
+        if (!id) throw new Error("gateway returned no share id");
+        const link: ShareLink = {
+          id,
+          name: input.name?.trim() || undefined,
+          requireAuth: input.requireAuth,
+          allowlist: input.requireAuth ? input.allowlist : [],
+          shareBranch,
+        };
+
+        await client.sessionSetShares(session.id, [...this.linksFor(this.snapshot.session), link]);
         this.setStatus("");
-        this.showToast(line, copied ? "share link copied" : "share link");
+        this.showToast(line, copied ? "link copied" : "link created");
       })
       .catch((cause: unknown) =>
         this.setStatus(`share failed: ${cause instanceof Error ? cause.message : String(cause)}`),
       );
   }
 
+  updateShareLink(id: string, input: NewShareLink): void {
+    if (this.readOnly) return this.setStatus("observer - read-only");
+    const session = this.snapshot.session;
+
+    if (!session || !this.client) return;
+    const links = this.linksFor(session);
+
+    if (!links.some((link) => link.id === id)) return;
+    const allowlist = input.requireAuth ? input.allowlist : [];
+    // re-push the link's access to its blob: an allowlist for private, "public" clears it
+    void this.shareTransport
+      .push(id, [], input.requireAuth ? { githubLogins: allowlist } : "public")
+      .catch(() => {});
+    const next = links.map((link) =>
+      link.id === id
+        ? {
+            ...link,
+            name: input.name?.trim() || undefined,
+            requireAuth: input.requireAuth,
+            allowlist,
+          }
+        : link,
+    );
+
+    this.applyOptimistic(
+      { ...session, shares: next },
+      this.client.sessionSetShares(session.id, next),
+    );
+    this.setStatus("link updated");
+  }
+
+  deleteShareLink(id: string): void {
+    if (this.readOnly) return this.setStatus("observer - read-only");
+    const session = this.snapshot.session;
+
+    if (!session || !this.client) return;
+    const remaining = this.linksFor(session).filter((link) => link.id !== id);
+
+    void this.shareTransport.revoke(id).catch(() => {});
+    this.applyOptimistic(
+      { ...session, shares: remaining },
+      this.client.sessionSetShares(session.id, remaining),
+    );
+    this.setStatus("link revoked");
+  }
+
+  copyShareLink(id: string): void {
+    const line = this.shareTransport.formatShareLine(id);
+
+    void copyToClipboard(line).then((copied) =>
+      this.showToast(line, copied ? "link copied" : "link"),
+    );
+  }
+
+  /** Stop sharing the open thread: revoke every link so none of them resolve. */
+  unshare(): void {
+    if (this.readOnly) return this.setStatus("observer - read-only");
+    const session = this.snapshot.session;
+    const links = this.linksFor(session);
+
+    if (!session || links.length === 0) return this.setStatus("this thread is not shared");
+    this.stopShareSync();
+    void Promise.all(links.map((link) => this.shareTransport.revoke(link.id).catch(() => {})))
+      .then(() => this.setStatus("sharing stopped"))
+      .catch(() => {});
+    void this.client?.sessionSetShares(session.id, []).catch(() => {});
+  }
+
   goToEntry(entryId: string, summary?: string): void {
     const session = this.snapshot.session;
 
@@ -1581,11 +1746,15 @@ class Controller implements ReviewController {
     client
       .sessionFork(session.id)
       .then(async (fork) => {
+        const shareBranch = fork.history?.branch ?? MAIN_BRANCH;
         const shared = await this.freezeForShare(fork);
-        const { line, copied } = await this.shareTransport.publish(shared);
-        const shareId = this.shareTransport.parseShareId(line);
+        const { line, copied } = await this.shareTransport.publish({ ...shared, shareBranch });
+        const id = this.shareTransport.parseShareId(line);
 
-        if (shareId) await client.sessionSetShareId(fork.id, shareId);
+        if (id)
+          await client.sessionSetShares(fork.id, [
+            { id, requireAuth: false, allowlist: [], shareBranch },
+          ]);
         this.setStatus("");
         this.showToast(line, copied ? "fork shared - link copied" : "fork shared");
       })
@@ -1616,14 +1785,19 @@ class Controller implements ReviewController {
    * event path. Best-effort: a failed refresh is silent.
    */
   pullShared(): Promise<void> {
-    const session = this.snapshot.session;
+    const links = this.linksFor(this.snapshot.session);
 
-    if (!session?.shareId) return Promise.resolve();
+    if (links.length === 0) return Promise.resolve();
 
-    return this.shareTransport
-      .pull(session.shareId)
-      .then((remote) => this.mergeShared(remote))
-      .catch(() => {});
+    // pull every link's blob and union its collaborator notes back in
+    return Promise.all(
+      links.map((link) =>
+        this.shareTransport
+          .pull(link.id)
+          .then((remote) => this.mergeShared(remote))
+          .catch(() => {}),
+      ),
+    ).then(() => {});
   }
 
   private mergeShared(remote: Thread): Promise<void> {
@@ -1638,9 +1812,10 @@ class Controller implements ReviewController {
   }
 
   /**
-   * Follow the share live while it is open: one watch stream delivers every
-   * change as it lands; a pull on each (re)connect catches up on anything
-   * missed while the link was down, and a dropped link reconnects with
+   * Follow the thread's shares live while it is open. To bound idle cost at one
+   * connection per open thread (not one per link), a single watch stream follows
+   * the primary link for instant updates, while a pull on each (re)connect
+   * catches up every link's collaborator notes. A dropped link reconnects with
    * backoff. Returns a stop handle the caller runs on leave.
    */
   startShareSync(): () => void {
@@ -1651,7 +1826,7 @@ class Controller implements ReviewController {
 
     this.shareRun = run;
     const connect = (): void => {
-      const shareId = this.snapshot.session?.shareId;
+      const shareId = this.linksFor(this.snapshot.session)[0]?.id;
 
       if (this.shareRun !== run || this.closed || !shareId) return;
       void this.pullShared();

package/src/use-annotation-surface.tsx

@@ -37,7 +37,6 @@ import {
 } from "./thread-selection";
 import { annotationPaletteFor, type AnnotationPalette } from "./annotation-palette";
 import { printableSequence, type MarkRange, type VisualLine } from "./mark-runs";
-import { matchesLeader } from "./thread-chords";
 import {
   activeSlashToken,
   insertSlashItem,
@@ -107,8 +106,8 @@ export interface AnnotationSurfaceOptions {
   onUpdateAnnotation: (id: string, body: string) => void;
   /** The author's display name for a comment's hover tooltip; the rail resolves it against the participant registry. */
   resolveAuthorLabel?: (annotation: Annotation) => string | undefined;
-  leaderCombos?: readonly string[];
-  onLeaderCommand?: (key: KeyEvent) => void;
+  /** Resolve a nav-mode key to a session/curation/tree/diff command; true when it acted. */
+  onNavCommand?: (key: KeyEvent) => boolean;
   onExit: () => void;
 }
 
@@ -119,6 +118,8 @@ export interface AnnotationSurface {
   cursor: number;
   head: TextPosition;
   compose: ComposeState | null;
+  /** True while the surface is in nav mode: bare keys act as commands, typing does not compose. */
+  navMode: boolean;
   focusedDiscussion: string | null;
   /** The block to keep in view: an opening card, a focused discussion, else the caret. */
   revealBlockIndex: number;
@@ -183,8 +184,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     onReply,
     onUpdateAnnotation,
     resolveAuthorLabel,
-    leaderCombos,
-    onLeaderCommand,
+    onNavCommand,
     onExit,
   } = options;
   const palette = annotationPaletteFor(tokens);
@@ -199,7 +199,12 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     return { head: start, anchor: start };
   });
   const [compose, setCompose] = useState<ComposeState | null>(null);
-  const leaderPending = useRef(false);
+  const [navMode, setNavModeState] = useState(false);
+  const navModeRef = useRef(false);
+  const setNavMode = (value: boolean): void => {
+    navModeRef.current = value;
+    setNavModeState(value);
+  };
 
   useEffect(() => {
     onComposingChange?.(compose !== null);
@@ -514,7 +519,22 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     if (!composerReady.current) handlePremountKey(key, activeCompose);
   };
 
-  /** m / cmd+[ / cmd+] / tab / return - true when the key was a discussion primitive. */
+  /** Fold or unfold every discussion sitting on the caret's block (nav-mode z). */
+  const toggleFoldAtCursor = (): void => {
+    setFolded((current) => {
+      const next = new Set(current);
+
+      for (const discussion of discussions) {
+        if (discussion.blockIndex !== cursor) continue;
+        if (next.has(discussion.key)) next.delete(discussion.key);
+        else next.add(discussion.key);
+      }
+
+      return next;
+    });
+  };
+
+  /** m / cmd+[ / cmd+] / return - true when the key was a discussion primitive. */
   const handleDiscussionVerb = (key: KeyEvent): boolean => {
     // comment on selection: cmd+option+m (alt+m where cmd arrives ESC-prefixed)
     if (key.name === "m" && (key.super || key.meta || key.option)) {
@@ -538,21 +558,6 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
       return true;
     }
-    if (key.name === "tab") {
-      setFolded((current) => {
-        const next = new Set(current);
-
-        for (const discussion of discussions) {
-          if (discussion.blockIndex !== cursor) continue;
-          if (next.has(discussion.key)) next.delete(discussion.key);
-          else next.add(discussion.key);
-        }
-
-        return next;
-      });
-
-      return true;
-    }
     // enter replies into the focused discussion, else the cursor block's discussion
     if (key.name === "return") {
       const replyTarget =
@@ -668,23 +673,25 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
 
     if (activeCompose) return handleComposeKey(key, activeCompose);
     if (key.name === "escape") {
-      if (leaderPending.current) {
-        leaderPending.current = false;
-
-        return;
-      }
-      if (focusedDiscussion !== null) return setFocusedDiscussion(null);
+      // 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 (leaderPending.current) {
-      leaderPending.current = false;
-      onLeaderCommand?.(key);
-
-      return;
-    }
-    if (leaderCombos && matchesLeader(key, leaderCombos)) {
-      leaderPending.current = true;
+    if (navModeRef.current) {
+      if (handleCaretKey(key)) return;
+      if (key.name === "z") return toggleFoldAtCursor();
+      if (onNavCommand?.(key)) return;
+      if (key.name === "c") {
+        setNavMode(false);
+
+        return openNewCompose("");
+      }
+      if (printableSequence(key)) {
+        setNavMode(false);
+        startTyping(key);
+      }
 
       return;
     }
@@ -865,6 +872,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);
 
@@ -892,6 +900,7 @@ export function useAnnotationSurface(options: AnnotationSurfaceOptions): Annotat
     cursor,
     head,
     compose,
+    navMode,
     focusedDiscussion,
     revealBlockIndex,
     spanQuote,