fix(editor): close save/reload races, formatter mtime, lsp format style and preset rebinding

Author: crynta

src/app/hooks/useAppCloseGuard.ts

@@ -29,10 +29,11 @@ export function useAppCloseGuard(tabsRef: RefObject<Tab[]>) {
       .onCloseRequested(async (event) => {
         if (forceClose.current) return;
         event.preventDefault();
+        const busyTerminal = await anyTerminalBusy(tabsRef.current);
+        // Count after the await so edits made during the IPC check are seen.
         const dirtyEditors = tabsRef.current.filter(
           (t) => t.kind === "editor" && t.dirty,
         ).length;
-        const busyTerminal = await anyTerminalBusy(tabsRef.current);
         if (dirtyEditors > 0 || busyTerminal) {
           setPendingAppClose({ dirtyEditors, busyTerminal });
         } else {

src/modules/editor/EditorPane.tsx

@@ -185,9 +185,14 @@ export const EditorPane = memo(
       const formatter = resolveFormatter(languageRef.current, prefs);
       if (prefs.editorFormatOnSave && formatter === "lsp" && view) {
         if (lspActiveRef.current) {
-          const res = await lspFormatDocument(view).catch(
-            () => "done" as const,
-          );
+          let res: "done" | "unsupported" = "done";
+          try {
+            res = await lspFormatDocument(view);
+          } catch (e) {
+            toast.error("Language server format failed", {
+              description: String(e),
+            });
+          }
           if (res === "unsupported" && !warnedNoFormatRef.current) {
             warnedNoFormatRef.current = true;
             toast.warning("Format on save skipped", {
@@ -217,9 +222,12 @@ export const EditorPane = memo(
         if (error) {
           toast.error(`${formatter} format failed`, { description: error });
         } else {
-          const text = await readFileText(pathRef.current);
-          if (text !== null && view && view.state.doc === docAtSave) {
-            applyFormattedContent(view, adoptDiskTextRef.current(text));
+          const readBack = await readFileText(pathRef.current);
+          if (readBack !== null && view && view.state.doc === docAtSave) {
+            applyFormattedContent(
+              view,
+              adoptDiskTextRef.current(readBack.text, readBack.mtime),
+            );
           }
         }
       }

src/modules/editor/lib/externalFormat.ts

@@ -4,7 +4,7 @@ import { currentWorkspaceEnv } from "@/modules/workspace";
 import type { EditorView } from "@codemirror/view";
 import { invoke } from "@tauri-apps/api/core";
 
-type ReadResult = { kind: string; content?: string };
+type ReadResult = { kind: string; content?: string; mtime?: number };
 
 type CommandOutput = {
   stdout: string;
@@ -141,12 +141,15 @@ export async function runExternalFormatter(
   }
 }
 
-export async function readFileText(path: string): Promise<string | null> {
+export async function readFileText(
+  path: string,
+): Promise<{ text: string; mtime: number } | null> {
   const res = await invoke<ReadResult>("fs_read_file", {
     path,
     workspace: currentWorkspaceEnv(),
   }).catch(() => null);
-  return res?.kind === "text" ? (res.content ?? null) : null;
+  if (res?.kind !== "text" || res.content == null) return null;
+  return { text: res.content, mtime: res.mtime ?? 0 };
 }
 
 // Minimal change dispatch: trimming the common prefix/suffix keeps the

src/modules/editor/lib/useDocument.ts

@@ -68,7 +68,8 @@ export function useDocument({ path, onDirtyChange }: Options) {
     });
     diskMtimeRef.current = mtime;
     savedRef.current = content;
-    setDirty(false);
+    // Edits typed while the write was in flight must stay dirty.
+    setDirty(bufferRef.current !== content);
     notifyDocumentSaved(path);
   }, [path]);
 
@@ -139,6 +140,8 @@ export function useDocument({ path, onDirtyChange }: Options) {
   // Load on path change.
   useEffect(() => {
     let cancelled = false;
+    // "Open anyway" is a per-file decision; a new path starts unforced.
+    forceRef.current = false;
     setDoc({ status: "loading" });
     setDirty(false);
 
@@ -163,11 +166,14 @@ export function useDocument({ path, onDirtyChange }: Options) {
       .catch((e) => setDoc({ status: "error", message: String(e) }));
   }, [readFromDisk, adoptRead]);
 
-  // Skipped while dirty: never clobber unsaved edits.
+  // Skipped while dirty: never clobber unsaved edits. Re-checked when the
+  // read resolves, since typing can start while it is in flight.
   const reload = useCallback((): boolean => {
     if (dirtyRef.current) return false;
     void readFromDisk(forceRef.current)
-      .then((res) => adoptRead(res, true))
+      .then((res) => {
+        if (!dirtyRef.current) adoptRead(res, true);
+      })
       // Transient failures (e.g. ENOENT mid atomic-rename) must not replace
       // a healthy buffer with an error screen.
       .catch((e) => console.warn("[editor] reload failed", path, e));
@@ -181,15 +187,21 @@ export function useDocument({ path, onDirtyChange }: Options) {
   }, [clearAutoSaveTimer, saveNow]);
 
   // Adopt externally formatted disk content as the saved baseline before the
-  // matching editor dispatch lands, so the buffer never flashes dirty.
+  // matching editor dispatch lands, so the buffer never flashes dirty. The
+  // formatter's own write must also become the known mtime, or the next save
+  // would report it as an external conflict.
   // Returns the LF-normalized text the caller should dispatch.
-  const adoptDiskText = useCallback((diskText: string): string => {
-    eolRef.current = detectEol(diskText);
-    const content = normalizeToLf(diskText);
-    savedRef.current = content;
-    setDirty(bufferRef.current !== content);
-    return content;
-  }, []);
+  const adoptDiskText = useCallback(
+    (diskText: string, mtime: number): string => {
+      eolRef.current = detectEol(diskText);
+      diskMtimeRef.current = mtime;
+      const content = normalizeToLf(diskText);
+      savedRef.current = content;
+      setDirty(bufferRef.current !== content);
+      return content;
+    },
+    [],
+  );
 
   const onChange = useCallback(
     (next: string) => {

src/modules/lsp/lib/client.ts

@@ -1,4 +1,4 @@
-import { highlightingFor, language } from "@codemirror/language";
+import { highlightingFor, indentUnit, language } from "@codemirror/language";
 import {
   type Extension,
   StateEffect,
@@ -87,7 +87,10 @@ export async function formatDocumentAndWait(
   const doc = view.state.doc;
   const edits = await client.textDocumentFormatting({
     textDocument: { uri: plugin.documentUri },
-    options: { tabSize: view.state.tabSize, insertSpaces: true },
+    options: {
+      tabSize: view.state.tabSize,
+      insertSpaces: view.state.facet(indentUnit) !== "\t",
+    },
   });
   if (!edits || edits.length === 0) return "done";
   // Edits are offsets into the requested snapshot; typing during the

src/modules/lsp/lib/useLspExtension.ts

@@ -19,7 +19,9 @@ export function useLspExtension(
     preset ? (s.generations[preset.id] ?? 0) : 0,
   );
 
+  const presetId = preset?.id;
   // biome-ignore lint/correctness/useExhaustiveDependencies(generation): re-acquire after a server crash tears the session down
+  // biome-ignore lint/correctness/useExhaustiveDependencies(presetId): swapping the enabled server for a language must rebind the doc
   useEffect(() => {
     if (!ready || !langId || activation !== "enabled") {
       setExt(null);
@@ -43,7 +45,7 @@ export function useLspExtension(
       handle?.release();
       setExt(null);
     };
-  }, [path, langId, ready, activation, generation]);
+  }, [path, langId, ready, activation, generation, presetId]);
 
   return ext;
 }