fix(save): harden format-on-save against tab-switch races and failure masking

- Propagate formatter.format()'s boolean through acode.format()
  (true = ran, false = failed, null = no formatter) so a handled
  formatter failure aborts the save instead of writing unformatted
  content as a successful save.
- Revalidate the active file after the formatter resolves in
  acode.format(); a mid-format tab switch now reports failure.
- Abort the format dispatch itself when the tab switched mid-format:
  prettierFormatter and LSP formatDocument return false without
  writing instead of dispatching into the newly active document.
- Run formatting before Save As/new-file target mutations (file
  creation, URI reassignment, recents updates) so a failed format
  aborts before any of them happen.

Author: xaniexane

src/cm/lsp/clientManager.ts

@@ -538,6 +538,13 @@ export class LspClientManager {
           plugin.client.sync();
           return true;
         }
+        // The user may have switched tabs while the formatting request was
+        // in flight; never apply this file's edits to another file's
+        // document. Abort without writing instead.
+        const em = (globalThis as Record<string, unknown>).editorManager as
+          | { activeFile?: unknown }
+          | undefined;
+        if (em && file && em.activeFile !== file) return false;
         const applied = applyTextEdits(plugin, view, edits);
         if (applied) {
           plugin.client.sync();

src/lib/acode.js

@@ -871,8 +871,16 @@ class Acode {
 		}
 
 		try {
-			await formatter.format();
-			return true;
+			// Propagate the formatter's own result instead of assuming
+			// success: formatters resolve `false` for handled failures
+			// (e.g. Prettier failing to parse, LSP reporting failure).
+			const didFormat = (await formatter.format()) !== false;
+			// The formatter dispatches through the shared editor view; if
+			// the user switched tabs while it was awaiting, its edits may
+			// have targeted the wrong document, so report failure instead
+			// of success and let callers abort.
+			if (editorManager.activeFile !== file) return false;
+			return didFormat;
 		} catch (error) {
 			helpers.error(error);
 			return false;

src/lib/prettierFormatter.js

@@ -98,6 +98,11 @@ export async function formatActiveFileWithPrettier() {
 
 		if (formatted === source) return true;
 
+		// The user may have switched tabs while the config/format awaits
+		// resolved; never dispatch into a document that is no longer this
+		// file's. Abort without writing instead.
+		if (editorManager?.activeFile !== file) return false;
+
 		editor.dispatch({
 			changes: {
 				from: 0,

src/lib/saveFile.js

@@ -117,6 +117,29 @@ async function saveFile(
 	let saved = false;
 
 	try {
+		if (appSettings.value.formatOnSave) {
+			// Format the in-memory content BEFORE creating/reassigning the
+			// save target below: a failed format aborts the save before any
+			// file creation, URI reassignment, or recents update happens.
+			// Formatters operate on the active editor document. If the user
+			// switched tabs while an async save step was pending, formatting
+			// here would rewrite the wrong file, so only format when the file
+			// being saved is the active one.
+			file.markChanged = false;
+			try {
+				if (editorManager.activeFile === file) {
+					// Await the formatter so the write below captures the
+					// formatted document. A failed format aborts the save;
+					// `null` means no formatter is configured, which is not
+					// a failure.
+					const formatted = await acode.exec("format", false);
+					if (formatted === false) return false;
+				}
+			} finally {
+				file.markChanged = true;
+			}
+		}
+
 		if (isSaveAs || newUrl) {
 			// if save as or new file
 			const fileUri = Url.join(newUrl, file.filename);
@@ -171,26 +194,6 @@ async function saveFile(
 			}
 		}
 
-		if (appSettings.value.formatOnSave) {
-			// Formatters operate on the active editor document. If the user
-			// switched tabs while an async save step was pending, formatting
-			// here would rewrite the wrong file, so only format when the file
-			// being saved is the active one.
-			file.markChanged = false;
-			try {
-				if (editorManager.activeFile === file) {
-					// Await the formatter so the write below captures the
-					// formatted document. A failed format aborts the save;
-					// `null` means no formatter is configured, which is not
-					// a failure.
-					const formatted = await acode.exec("format", false);
-					if (formatted === false) return false;
-				}
-			} finally {
-				file.markChanged = true;
-			}
-		}
-
 		const savedDoc = file.session?.doc || null;
 		const savedVersion = file.docVersion;
 		const data = getDocText(savedDoc);