@parhelia/core 0.3.12788 → 0.3.12791

package/dist/editor/client/operations.js

@@ -7,7 +7,7 @@ import { handleErrorResult } from "./helpers";
 import { isMissingEditOperationResult } from "./editHistoryReconciliation";
 import { useDebouncedCallback } from "use-debounce";
 import { createOrUpdateSuggestedEdit, deleteSuggestedEdit, } from "../services/suggestedEditsService";
-import { hasSuggestionContentChange, shouldRemoveNoOpSuggestion, } from "../reviews/suggestionContentChange";
+import { hasLiveFieldDivergedFromSuggestion, hasSuggestionContentChange, shouldRemoveNoOpSuggestion, } from "../reviews/suggestionContentChange";
 import { GUID_REGEX_EXACT, getItemDescriptor } from "../utils";
 import { cleanId } from "../utils/id-helper";
 import { copyItemsNeedsTerminalCompletion, normalizeOpId, waitForEditOperationTerminal, } from "./waitForEditOperationTerminal";
@@ -18,6 +18,7 @@ import { preferLatestLocalUndoTarget } from "./undoTargetResolution";
 import { logFieldValueDiagnostic, summarizeFieldDescriptor, summarizeFieldValue, } from "../fieldValueDiagnostics";
 import { getSuggestedEditItemLanguage, getSuggestedEditItemVersion, getSuggestionFieldIdentityKey, } from "../reviews/suggestionDisplayValue";
 import { enqueueSuggestedEditFieldTask, waitForSuggestedEditFieldTasks, } from "./suggestedEditFieldQueue";
+import { markNextBridgeRefreshAuthoritative } from "../page-viewer/bridgeInlineEditCommit";
 /** When true, the delete dialog shows "permanently delete (bypass recycle bin)". */
 const ENABLE_HARD_DELETE_IN_DELETE_DIALOG = false;
 // Track pending suggested edits to prevent creating duplicates before server response
@@ -378,7 +379,7 @@ export function getOperationsContext(state, ui) {
         }
         return true;
     };
-    const ensureLock = useCallback(async (field) => {
+    const ensureLock = useCallback(async (field, options) => {
         if (!field || !field.item) {
             return false;
         }
@@ -386,7 +387,7 @@ export function getOperationsContext(state, ui) {
         const locallyAcquiredLock = acquiredFieldLockRef.current;
         const isAlreadyLocked = fieldsMatchForLock(stateRef.current.lockedField, field) ||
             fieldsMatchForLock(locallyAcquiredLock, field);
-        if (isAlreadyLocked) {
+        if (!options?.force && isAlreadyLocked) {
             return true;
         }
         const existingPendingLock = pendingFieldLocks.current.get(lockKey);
@@ -514,6 +515,11 @@ export function getOperationsContext(state, ui) {
     const lastEditField = useRef(undefined);
     const pendingFieldSaves = useRef(new Map());
     const fieldEditGeneration = useRef(0);
+    // A blur is an undo-history boundary even when the blurred field's debounced
+    // save is still resolving. Capture this generation when an edit starts so a
+    // newer focus/edit cannot reuse the operation created by that older save.
+    const fieldOperationBoundary = useRef(0);
+    const lastOpBoundary = useRef(undefined);
     const completedFieldSaveGeneration = useRef(0);
     const latestSavedFieldEditOperationId = useRef(undefined);
     const getFieldSaveKey = (field) => {
@@ -548,9 +554,82 @@ export function getOperationsContext(state, ui) {
             ? stateRef.current.getFieldModificationStoreForSlot?.(activeSlotId)
             : undefined;
     }, []);
-    const editField = useCallback(async ({ field, value, rawValue, forceMode, refresh = "immediate", originatingSlotId, }) => {
+    const queueSuggestedEditSave = useCallback((fieldKey, pendingFieldKey, op) => {
+        const saveSnapshot = { ...op };
+        const expectedNewValue = saveSnapshot.newValue;
+        return enqueueSuggestedEditFieldTask(fieldKey, () => {
+            const persistedVersion = persistedSuggestedEditVersions.get(fieldKey);
+            const snapshotForSave = persistedVersion?.id === saveSnapshot.id
+                ? { ...saveSnapshot, updated: persistedVersion.updated }
+                : saveSnapshot;
+            return createDelayedSuggestedEditSave(snapshotForSave, persistedVersion?.id === saveSnapshot.id
+                ? persistedVersion.updated
+                : undefined);
+        })
+            .then((result) => {
+            if (result.type === "success" && result.data) {
+                const updatedEdit = result.data;
+                if (updatedEdit.updated) {
+                    persistedSuggestedEditVersions.set(fieldKey, {
+                        id: updatedEdit.id,
+                        updated: updatedEdit.updated,
+                    });
+                }
+                if (isSuggestedEditRemoved(updatedEdit.id)) {
+                    void deleteSuggestedEdit(updatedEdit).then((deleteResult) => {
+                        if (deleteResult.type !== "success") {
+                            console.warn("Failed to delete reverted suggestion after save:", deleteResult.summary, deleteResult.details);
+                        }
+                    }, () => undefined);
+                    return result;
+                }
+                stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, {
+                    expectedNewValue,
+                    source: "save-ack",
+                }));
+            }
+            else if (result.type === "conflict") {
+                if (result.suggestion) {
+                    if (result.suggestion.updated) {
+                        persistedSuggestedEditVersions.set(fieldKey, {
+                            id: result.suggestion.id,
+                            updated: result.suggestion.updated,
+                        });
+                    }
+                    stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, result.suggestion, {
+                        source: "save-ack",
+                    }));
+                    if (result.suggestion.status !== "pending" &&
+                        pendingSuggestedEdits.get(pendingFieldKey)?.id ===
+                            result.suggestion.id) {
+                        pendingSuggestedEdits.delete(pendingFieldKey);
+                    }
+                }
+            }
+            else if (result.type === "error" ||
+                result.type === "unauthorized") {
+                if (!isSuggestedEditRemoved(saveSnapshot.id)) {
+                    ui.showErrorToast({
+                        summary: result.summary || "Failed to save suggestion",
+                        details: result.details,
+                        rawDetails: result.rawDetails,
+                    });
+                }
+            }
+            return result;
+        })
+            .finally(() => {
+            const pendingEdit = pendingSuggestedEdits.get(pendingFieldKey);
+            if (pendingEdit?.id === saveSnapshot.id &&
+                pendingEdit.newValue === saveSnapshot.newValue) {
+                pendingSuggestedEdits.delete(pendingFieldKey);
+            }
+        });
+    }, [ui]);
+    const editField = useCallback(async ({ field, value, rawValue, forceMode, refresh = "immediate", saveMode = "debounced", originatingSlotId, }) => {
         const effectiveMode = forceMode ?? stateRef.current.mode;
         fieldEditGeneration.current += 1;
+        const operationBoundary = fieldOperationBoundary.current;
         if (effectiveMode === "suggestions" &&
             (stateRef.current.page || stateRef.current.currentItemDescriptor)) {
             // Create a unique key for this field to track pending saves
@@ -561,15 +640,24 @@ export function getOperationsContext(state, ui) {
                 fieldId: field.fieldId,
             });
             const pendingFieldKey = `${fieldKey}:${stateRef.current.user?.name || "unknown"}`;
-            const op = await getOrMergeSuggestedEditOp(field, rawValue, value, {
-                page: stateRef.current.page,
-                currentItemDescriptor: stateRef.current.currentItemDescriptor,
-                user: stateRef.current.user,
-                itemsRepository: itemsRepository,
-                comments: stateRef.current.comments,
-                commentsLoaded: stateRef.current.commentsLoaded,
-                suggestedEdits: stateRef.current.suggestedEdits,
-                setSuggestedEdits: stateRef.current.setSuggestedEdits,
+            let savePromise;
+            const op = await enqueueSuggestedEditFieldTask(`prepare:${pendingFieldKey}`, async () => {
+                const prepared = await getOrMergeSuggestedEditOp(field, rawValue, value, {
+                    page: stateRef.current.page,
+                    currentItemDescriptor: stateRef.current.currentItemDescriptor,
+                    user: stateRef.current.user,
+                    itemsRepository: itemsRepository,
+                    comments: stateRef.current.comments,
+                    commentsLoaded: stateRef.current.commentsLoaded,
+                    suggestedEdits: stateRef.current.suggestedEdits,
+                    setSuggestedEdits: stateRef.current.setSuggestedEdits,
+                });
+                // Register the save before releasing preparation. A rapid revert
+                // can now only queue its delete behind this create/update.
+                if (prepared) {
+                    savePromise = queueSuggestedEditSave(fieldKey, pendingFieldKey, prepared);
+                }
+                return prepared;
             });
             if (op) {
                 logFieldValueDiagnostic("operations", "suggested edit prepared", {
@@ -581,93 +669,6 @@ export function getOperationsContext(state, ui) {
                     oldValue: summarizeFieldValue(op.oldValue),
                     newValue: summarizeFieldValue(op.newValue),
                 });
-                // Keep local suggestion state in step with typing immediately, then
-                // serialize persistence behind any in-flight save for this field.
-                // Create and track the save promise. useDebouncedCallback can return
-                // undefined before the trailing call runs, so this path uses a real
-                // promise that resolves after the delayed save completes.
-                const saveSnapshot = { ...op };
-                const expectedNewValue = saveSnapshot.newValue;
-                const savePromise = enqueueSuggestedEditFieldTask(fieldKey, () => {
-                    // Input handlers may prepare several snapshots before React state
-                    // receives the first save acknowledgement. Read the durable
-                    // server-issued version at execution time so every queued save is
-                    // based on the immediately preceding one.
-                    const persistedVersion = persistedSuggestedEditVersions.get(fieldKey);
-                    const snapshotForSave = persistedVersion?.id === saveSnapshot.id
-                        ? { ...saveSnapshot, updated: persistedVersion.updated }
-                        : saveSnapshot;
-                    return createDelayedSuggestedEditSave(snapshotForSave, persistedVersion?.id === saveSnapshot.id
-                        ? persistedVersion.updated
-                        : undefined);
-                })
-                    .then((result) => {
-                    // Update the suggested edits state with the result from the server
-                    if (result.type === "success" && result.data) {
-                        const updatedEdit = result.data;
-                        if (updatedEdit.updated) {
-                            persistedSuggestedEditVersions.set(fieldKey, {
-                                id: updatedEdit.id,
-                                updated: updatedEdit.updated,
-                            });
-                        }
-                        if (isSuggestedEditRemoved(updatedEdit.id)) {
-                            // Reverted to a no-op while this save was in flight; make sure
-                            // it stays gone on the server and do not re-add it locally.
-                            void deleteSuggestedEdit(updatedEdit).then((deleteResult) => {
-                                if (deleteResult.type !== "success") {
-                                    console.warn("Failed to delete reverted suggestion after save:", deleteResult.summary, deleteResult.details);
-                                }
-                            }, () => undefined);
-                            return result;
-                        }
-                        stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, updatedEdit, {
-                            expectedNewValue,
-                            source: "save-ack",
-                        }));
-                    }
-                    else if (result.type === "conflict") {
-                        if (result.suggestion) {
-                            if (result.suggestion.updated) {
-                                persistedSuggestedEditVersions.set(fieldKey, {
-                                    id: result.suggestion.id,
-                                    updated: result.suggestion.updated,
-                                });
-                            }
-                            stateRef.current.setSuggestedEdits((current) => upsertSuggestedEdit(current, result.suggestion, {
-                                source: "save-ack",
-                            }));
-                            if (result.suggestion.status !== "pending" &&
-                                pendingSuggestedEdits.get(pendingFieldKey)?.id ===
-                                    result.suggestion.id) {
-                                pendingSuggestedEdits.delete(pendingFieldKey);
-                            }
-                        }
-                    }
-                    else if (result.type === "error" ||
-                        result.type === "unauthorized") {
-                        // Show error toast for failed suggested edit save — unless the
-                        // suggestion was reverted while the request was in flight, in
-                        // which case there is nothing for the user to see or retry.
-                        if (!isSuggestedEditRemoved(saveSnapshot.id)) {
-                            ui.showErrorToast({
-                                summary: result.summary || "Failed to save suggestion",
-                                details: result.details,
-                                rawDetails: result.rawDetails,
-                            });
-                        }
-                    }
-                    return result;
-                })
-                    .finally(() => {
-                    // Also remove from pending edits once this exact value is
-                    // persisted. If the user typed again, keep the newer draft.
-                    const pendingEdit = pendingSuggestedEdits.get(pendingFieldKey);
-                    if (pendingEdit?.id === saveSnapshot.id &&
-                        pendingEdit.newValue === saveSnapshot.newValue) {
-                        pendingSuggestedEdits.delete(pendingFieldKey);
-                    }
-                });
                 await savePromise;
             }
             logFieldValueDiagnostic("operations", "suggestions edit complete", {
@@ -682,11 +683,12 @@ export function getOperationsContext(state, ui) {
             name: "unknown",
             ai: false,
             agentId: undefined,
-        }, true, value, rawValue, fieldModificationStore);
-        if (refresh === "immediate") {
+        }, true, value, rawValue, fieldModificationStore, refresh !== "none");
+        if (refresh === "immediate" || saveMode === "immediate") {
             logFieldValueDiagnostic("operations", "saving immediately", {
                 field: summarizeFieldDescriptor(field),
                 saveSequence,
+                refresh,
             });
             return enqueueFieldSave(field, () => editFieldImmediate({
                 field,
@@ -695,6 +697,7 @@ export function getOperationsContext(state, ui) {
                 refresh,
                 saveSequence,
                 fieldModificationStore,
+                operationBoundary,
             }));
         }
         const isNewField = lastEditField.current?.fieldId !== field.fieldId ||
@@ -713,44 +716,44 @@ export function getOperationsContext(state, ui) {
             refresh,
             saveSequence,
             fieldModificationStore,
+            operationBoundary,
         });
     }, [
         itemsRepository,
         getOrMergeSuggestedEditOp,
+        queueSuggestedEditSave,
         resolveOriginatingFieldModificationStore,
         enqueueFieldSave,
     ]);
-    const editFieldImmediate = useCallback(async ({ field, value, rawValue, refresh = "immediate", saveSequence, fieldModificationStore, }) => {
+    const editFieldImmediate = useCallback(async ({ field, value, rawValue, refresh = "immediate", saveSequence, fieldModificationStore, operationBoundary, }) => {
         const val = rawValue !== undefined ? rawValue : value;
         if (val === undefined)
             return;
-        const op = await getEditOP(field, rawValue, value);
-        // Fix: Handle getEditOP returning undefined (item/field not found)
-        // Clear dirty state so the field doesn't get stuck in "saving" state
+        const op = await getEditOP(field, rawValue, value, operationBoundary);
+        // An operation that could not be constructed was not saved. Keep the
+        // modification dirty instead of publishing a false successful state.
         if (!op) {
-            console.warn("[editFieldImmediate] Could not create edit operation for field:", field.fieldId);
+            const error = new Error(`Could not create edit operation for field ${field.fieldId}`);
+            console.warn("[editFieldImmediate]", error.message);
             logFieldValueDiagnostic("operations", "editFieldImmediate no op", {
                 field: summarizeFieldDescriptor(field),
                 value: summarizeFieldValue(value),
                 rawValue: summarizeFieldValue(rawValue),
                 saveSequence,
             });
-            itemsRepository.clearDirtyState(field, fieldModificationStore);
-            return;
+            throw error;
         }
         try {
             const result = await executeOp(op, { refresh });
             // Fix: Check if the operation actually succeeded
             // If result is undefined/null, the operation likely failed
             if (!result) {
-                console.warn("[editFieldImmediate] Edit operation returned no result, clearing dirty state");
                 logFieldValueDiagnostic("operations", "editFieldImmediate no result", {
                     field: summarizeFieldDescriptor(field),
                     opId: op.id,
                     saveSequence,
                 });
-                itemsRepository.clearDirtyState(field, fieldModificationStore);
-                return;
+                throw new Error(`Edit operation returned no result for field ${field.fieldId}`);
             }
             // Don't refresh here - the websocket handler will trigger a refresh when
             // it receives the item-changed notification from the server. This avoids
@@ -759,15 +762,23 @@ export function getOperationsContext(state, ui) {
                 isWorkflowMetadataField(op.fieldId, op.fieldName)) {
                 refreshWorkboxAfterWorkflowChange();
             }
-            if (result.executionStatus !== "failed") {
-                latestSavedFieldEditOperationId.current = op.id;
-                completedFieldSaveGeneration.current += 1;
+            if (result.executionStatus === "failed") {
+                throw new Error(`Edit operation failed for field ${field.fieldId}`);
             }
+            latestSavedFieldEditOperationId.current = op.id;
+            completedFieldSaveGeneration.current += 1;
             itemsRepository.onFieldSaved(field, val, saveSequence || 0, fieldModificationStore);
+            if (refresh !== "none") {
+                // The edit response can precede rendering-host cache invalidation.
+                // The immediate refresh remains the fast path; this quiet follow-up
+                // reconciles the canvas when that first render observed stale data
+                // or the corresponding websocket notification was missed.
+                stateRef.current.requestRefresh("waitForQuietPeriod");
+            }
         }
         catch (error) {
-            // Fix: Handle network errors and other exceptions
-            // Clear the dirty state to prevent the field from getting stuck in "saving" state
+            // Network and execution errors leave the modification dirty: clearing
+            // it here makes consumers believe persistence completed successfully.
             console.error("[editFieldImmediate] Error saving field:", error);
             logFieldValueDiagnostic("operations", "editFieldImmediate failed", {
                 field: summarizeFieldDescriptor(field),
@@ -776,10 +787,10 @@ export function getOperationsContext(state, ui) {
                 saveSequence,
                 error: error instanceof Error ? error.message : String(error),
             });
-            itemsRepository.clearDirtyState(field, fieldModificationStore);
+            throw error;
         }
     }, [itemsRepository, executeOp, refreshWorkboxAfterWorkflowChange]);
-    const executeEditFieldDebounced = useDebouncedCallback(async ({ field, value, rawValue, refresh, saveSequence, fieldModificationStore, }) => {
+    const executeEditFieldDebounced = useDebouncedCallback(async ({ field, value, rawValue, refresh, saveSequence, fieldModificationStore, operationBoundary, }) => {
         // Fix: Use the saveSequence passed from editField instead of calling
         // updateFieldValue again. This prevents the race condition where the
         // field gets marked dirty twice with different sequences.
@@ -790,6 +801,7 @@ export function getOperationsContext(state, ui) {
             refresh,
             saveSequence,
             fieldModificationStore,
+            operationBoundary,
         }));
     }, stateRef.current.configuration.debounceFieldEditsInterval * 2, { trailing: true });
     const flushPendingFieldEdits = useCallback(async () => {
@@ -806,8 +818,20 @@ export function getOperationsContext(state, ui) {
             ? latestSavedFieldEditOperationId.current
             : undefined;
     }, [executeEditFieldDebounced]);
+    const prepareForModeChange = useCallback(async () => {
+        const lastField = lastEditField.current;
+        await flushPendingFieldEdits();
+        if (!lastField)
+            return;
+        // A mode switch is a consistency boundary. Refresh the field that was just
+        // persisted so suggestions are based on the committed Sitecore value, not
+        // on an older cache response that raced the save acknowledgement.
+        await itemsRepository.refreshItems([lastField.item], {
+            fields: [lastField.fieldId],
+        });
+    }, [flushPendingFieldEdits, itemsRepository]);
     // Note: We intentionally keep a single save debounce window here.
-    async function getEditOP(field, rawValue, value) {
+    async function getEditOP(field, rawValue, value, operationBoundary) {
         const item = await itemsRepository.getItem(field.item);
         if (!item)
             return;
@@ -836,7 +860,8 @@ export function getOperationsContext(state, ui) {
             op.itemId !== item.id ||
             op.fieldId !== field.fieldId ||
             op.mainItem.language !== item.language ||
-            op.mainItem.version !== item.version) {
+            op.mainItem.version !== item.version ||
+            lastOpBoundary.current !== operationBoundary) {
             // Use state.page's descriptor only if its language AND version match the field's
             // to prevent race conditions when switching languages or versions quickly
             const page = stateRef.current.page;
@@ -868,6 +893,7 @@ export function getOperationsContext(state, ui) {
         if (firstEditInheritedComponent)
             op.mainItem.language = stateRef.current.page.item.language;
         lastOp.current = op;
+        lastOpBoundary.current = operationBoundary;
         return op;
     }
     const executeUndoOperation = useCallback(async (ops) => {
@@ -876,7 +902,10 @@ export function getOperationsContext(state, ui) {
         // This ensures the UI only changes when the operation truly completes
         const operationWasRemoved = isMissingEditOperationResult(result);
         if (!operationWasRemoved) {
-            handleResult(result, { refresh: "immediate" });
+            // Reconcile the affected repository items before starting the canvas
+            // request below. Refreshing here would let a busy rendering host read
+            // the pre-undo snapshot and repaint stale content over the new value.
+            handleResult(result, { refresh: "none" });
         }
         if (result.type === "success") {
             for (const executedOp of result.data) {
@@ -902,7 +931,6 @@ export function getOperationsContext(state, ui) {
             // The targeted refresh via itemsRepository.refreshItems is not sufficient because:
             // 1. When undoing add-component, the component no longer exists to refresh
             // 2. When undoing remove-component, the component wasn't in cache
-            const hasDeleteOperations = true; // Always refresh after undo
             const itemsToRefresh = result.data
                 .map((x) => {
                 if (x.type === "edit-field")
@@ -921,8 +949,8 @@ export function getOperationsContext(state, ui) {
                 .flat()
                 .filter((x) => x != null);
             await itemsRepository.refreshItems(itemsToRefresh);
-            // handleResult already triggers the single immediate page refresh.
-            // Avoid a second request here, which can flood a busy rendering host.
+            markNextBridgeRefreshAuthoritative();
+            stateRef.current.requestRefresh("immediate");
             return true;
         }
         else {
@@ -1228,7 +1256,7 @@ export function getOperationsContext(state, ui) {
         // which merges server responses + websocket updates while enforcing scope filtering.
         const operationWasRemoved = isMissingEditOperationResult(result);
         if (!operationWasRemoved) {
-            handleResult(result, { refresh: "immediate" });
+            handleResult(result, { refresh: "none" });
         }
         if (result.type === "success") {
             for (const executedOp of result.data) {
@@ -1264,6 +1292,8 @@ export function getOperationsContext(state, ui) {
             })
                 .filter((x) => x != null);
             await itemsRepository.refreshItems(itemsToRefresh);
+            markNextBridgeRefreshAuthoritative();
+            stateRef.current.requestRefresh("immediate");
             return true;
         }
         else {
@@ -1558,6 +1588,24 @@ export function getOperationsContext(state, ui) {
         return true;
     }, [itemsRepository, executeOp, ui]);
     const moveItems = useCallback(async (items, target, index) => {
+        // Capture source parents before the background operation starts. The
+        // terminal payload does not need to carry this UI-specific context, and
+        // after completion the items already belong to the destination.
+        let sourceParents = [];
+        try {
+            const sourceItems = await itemsRepository.getItems(items);
+            sourceParents = sourceItems
+                .filter((item) => !!item.parentId)
+                .map((item) => ({
+                id: item.parentId,
+                language: item.language,
+                version: 0,
+                database: item.database,
+            }));
+        }
+        catch (error) {
+            console.warn("Could not capture move source parents:", error);
+        }
         // Use generic edit endpoint for long-running operation support
         const op = {
             type: "move-items",
@@ -1569,9 +1617,29 @@ export function getOperationsContext(state, ui) {
             id: uuid(),
             title: `Moving ${items.length} item(s)...`,
         };
-        const result = await executeOp(op);
-        return result?.executionStatus !== "failed";
-    }, [executeOp]);
+        let result = (await executeOp(op));
+        if (copyItemsNeedsTerminalCompletion(result)) {
+            try {
+                const terminal = await waitForEditOperationTerminal(result.id, 120_000);
+                result = { ...result, ...terminal };
+            }
+            catch {
+                return false;
+            }
+        }
+        if (result.executionStatus === "failed" || result.errorMessage) {
+            return false;
+        }
+        const parentsById = new Map();
+        for (const parent of [...sourceParents, { ...target, version: 0 }]) {
+            const key = cleanId(parent.id) ?? parent.id;
+            parentsById.set(key, parent);
+        }
+        await itemsRepository.refreshItems(Array.from(parentsById.values()), {
+            children: true,
+        });
+        return true;
+    }, [executeOp, itemsRepository]);
     const createItem = useCallback(async (parent, templateId, name) => {
         const op = {
             type: "create-item",
@@ -1736,24 +1804,20 @@ export function getOperationsContext(state, ui) {
         }));
         return result;
     }, [executeOp]);
-    const onFieldBlur = useCallback(() => {
+    const onFieldBlur = useCallback(async () => {
         const editGenerationAtBlur = fieldEditGeneration.current;
-        const pendingSave = executeEditFieldDebounced.isPending()
-            ? executeEditFieldDebounced.flush()
-            : undefined;
-        if (pendingSave) {
-            void Promise.resolve(pendingSave).finally(() => {
-                // Preserve a newer edit that started while the blurred field was saving.
-                if (fieldEditGeneration.current === editGenerationAtBlur) {
-                    lastOp.current = undefined;
-                }
-            });
-            return;
-        }
-        // Reset the last operation to force creation of a new operation
-        // when the user returns to edit any field after losing focus.
-        lastOp.current = undefined;
-    }, [executeEditFieldDebounced]);
+        // Advance synchronously. The DOM blur event cannot await this callback, so
+        // doing it after the save would allow an edit started during that save to
+        // coalesce into the operation that belongs to the field being left.
+        fieldOperationBoundary.current += 1;
+        await flushPendingFieldEdits();
+        // Preserve a newer edit that started while the blurred field was saving.
+        // Otherwise force a new operation when the user returns to this field.
+        if (fieldEditGeneration.current === editGenerationAtBlur) {
+            lastOp.current = undefined;
+            lastOpBoundary.current = undefined;
+        }
+    }, [flushPendingFieldEdits]);
     // Extract state values to avoid object reference changes
     const mode = stateRef.current.mode;
     const page = stateRef.current.page;
@@ -1783,6 +1847,7 @@ export function getOperationsContext(state, ui) {
         cloneItems,
         duplicateItem,
         onFieldBlur,
+        prepareForModeChange,
     }), [
         addComponent,
         ensureLock,
@@ -1810,6 +1875,7 @@ export function getOperationsContext(state, ui) {
         cloneItems,
         duplicateItem,
         onFieldBlur,
+        prepareForModeChange,
     ]);
     // Cleanup function to flush pending debounced operations on unmount
     // This prevents fields from getting stuck in "saving" state when navigating away
@@ -1924,10 +1990,10 @@ async function getOrMergeSuggestedEditOp(field, rawValue, value, state) {
     // server cascade-deletes a suggestion's comments along with it).
     state.commentsLoaded === true &&
         shouldRemoveNoOpSuggestion(edit.oldValue, nextValue, () => getSuggestionCommentCount(edit, state)) &&
-        // Only auto-remove when the typed value is also a no-op against the
-        // field's live value: if the field changed underneath the suggestion, the
-        // typed content still differs from the page and must stay recorded.
-        !hasSuggestionContentChange(fieldItem.rawValue, nextValue);
+        // A live value equal to the draft is an optimistic editor echo, not an
+        // external field change. Preserve the suggestion only when the live field
+        // contains a third value that differs from both its baseline and draft.
+        !hasLiveFieldDivergedFromSuggestion(edit.oldValue, edit.newValue, fieldItem.rawValue);
     // First check if there's a pending suggested edit for this field. A draft
     // whose suggestion was already reverted must not be revived — a new edit
     // mints a fresh suggestion instead.