@parhelia/core 0.3.12763 → 0.3.12768

package/dist/editor/page-viewer/PageViewerFrame.js

@@ -7,8 +7,10 @@ import { useSlotContext } from "../views/editorSlotContext";
 import { useDebouncedCallback, useThrottledCallback } from "use-debounce";
 import { PageEditorChrome } from "../page-editor-chrome/PageEditorChrome";
 import { useBridgeInlineEditing, } from "../page-editor-chrome/useBridgeInlineEditing";
+import { createBridgeInlineEditSessionCoordinator, } from "./bridgeInlineEditSession";
 import { getInlineAiAnchorFromBridgeToolbar, getVisibleBridgeToolbarRect, waitForVisibleBridgeToolbarRect, } from "../page-editor-chrome/bridgeInlineFormatToolbarLayout";
 import { IFRAME_OVERLAY_BRIDGE_DRAG_GESTURE_EVENT, IFRAME_OVERLAY_BRIDGE_GEOMETRY_EVENT, IFRAME_OVERLAY_BRIDGE_SCROLL_EVENT, IframeOverlayProvider, } from "../page-editor-chrome/overlay/IframeOverlayProvider";
+import { projectBridgeGeometryToScroll } from "../page-editor-chrome/overlay/geometry";
 import { CANVAS_REFRESH_COMPLETED_EVENT, DEVICE_CHANGE_EVENT, useViewportChangeSignal, } from "./pageViewContext";
 import uuid from "react-uuid";
 import { cn } from "../../lib/utils";
@@ -29,8 +31,8 @@ import { toSitecoreDate } from "../utils/sitecoreDate";
 import { pickVersionAtDate } from "../utils/versionAtDate";
 import { BridgeClient } from "../bridge/BridgeClient";
 import { beginPerfTrace, isPerfTraceActive, isPerfTraceEnabled, perfTraceStep, } from "../perfTrace";
-import { getSuggestionDisplayValue } from "../reviews/suggestionDisplayValue";
-import { buildBridgeFieldPatchPayload, getBridgeFieldPatchValue, isBridgePatchableTextField, reduceActiveBridgeInlineEditForRefreshEvent, } from "./bridgeFieldPatch";
+import { getPendingFieldSuggestions, getSuggestionSelectionKey, getSuggestionDisplayValue, } from "../reviews/suggestionDisplayValue";
+import { buildBridgeFieldPatchPayload, buildBridgeFieldPatchSignature, buildRemoteCaretFieldPatches, getBridgeFieldPatchValue, hasRemoteCaretDraftForField, isBridgePatchableTextField, isSuggestionPreviewPatchSignature, } from "./bridgeFieldPatch";
 import { bridgeSelectionMatchesInteraction, resolveBridgeTextCompletionInput, } from "./bridgeTextCompletion";
 import { logFieldValueDiagnostic, summarizeField, summarizeFieldDescriptor, summarizeFieldValue, } from "../fieldValueDiagnostics";
 import { createKeyboardEventFromBridgeInteraction } from "./bridgeKeyboardShortcuts";
@@ -618,18 +620,21 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     const bridgeTextRangeSourcesRef = useRef(new Map());
     const activeBridgeInlineEditRef = useRef(null);
     const [isBridgeInlineEditing, setIsBridgeInlineEditing] = useState(false);
+    const bridgeInlineEditSessionRef = useRef(null);
+    if (!bridgeInlineEditSessionRef.current) {
+        bridgeInlineEditSessionRef.current =
+            createBridgeInlineEditSessionCoordinator({
+                stateRef: activeBridgeInlineEditRef,
+                onStateChange: (state) => setIsBridgeInlineEditing(!!state),
+            });
+    }
+    const bridgeInlineEditSession = bridgeInlineEditSessionRef.current;
     const clearActiveBridgeInlineEdit = useCallback(() => {
-        activeBridgeInlineEditRef.current = null;
-        setIsBridgeInlineEditing(false);
-    }, []);
+        bridgeInlineEditSession.clear();
+    }, [bridgeInlineEditSession]);
     const reconcileActiveBridgeInlineEdit = useCallback((event) => {
-        const current = activeBridgeInlineEditRef.current;
-        const reconciled = reduceActiveBridgeInlineEditForRefreshEvent(current, event);
-        if (reconciled === current)
-            return;
-        activeBridgeInlineEditRef.current = reconciled;
-        setIsBridgeInlineEditing(!!reconciled);
-    }, []);
+        bridgeInlineEditSession.reconcileForRefreshEvent(event);
+    }, [bridgeInlineEditSession]);
     const bridgeTextCompletionRef = useRef(null);
     const bridgeTextCompletionAbortRef = useRef(null);
     const bridgeTextCompletionRequestIdRef = useRef(0);
@@ -654,6 +659,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     // skipped entirely: the bridge learns the mode via setEditorMode, and a
     // needless refresh would drop scroll position and inline-edit state.
     const lastRenderSignatureRef = useRef(undefined);
+    const lastRenderModeRef = useRef(editContext.mode);
     // Set when a canvas refresh (bridge patch or full reload) has been requested
     // and its result has not landed yet. While in flight, bridgeGeometry still
     // describes the PRE-refresh DOM — a moved component is still measured at its
@@ -806,6 +812,19 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
             setBridgeGeometryRevision((revision) => revision + 1);
         });
     }, []);
+    const projectCurrentBridgeGeometryToScroll = useCallback((scroll) => {
+        const activeContext = pageViewContextRef.current;
+        const currentGeometry = activeContext?.bridgeGeometry;
+        const projectedGeometry = projectBridgeGeometryToScroll(currentGeometry, scroll);
+        if (!activeContext ||
+            !projectedGeometry ||
+            projectedGeometry === currentGeometry) {
+            return;
+        }
+        activeContext.bridgeGeometry = projectedGeometry;
+        activeContext.setBridgeGeometry(projectedGeometry);
+        scheduleBridgeGeometryRevision();
+    }, [scheduleBridgeGeometryRevision]);
     const scheduleBridgeDomRevision = useCallback(() => {
         if (bridgeDomRevisionRafRef.current != null)
             return;
@@ -897,7 +916,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     }, []);
     const { beginInlineEdit: beginBridgeInlineEdit, clearInlineDedupe: clearBridgeInlineDedupe, endFieldFocus: endBridgeFieldFocus, handleFieldValueChanged: handleBridgeFieldValueChanged, handleInlineEditEnded: handleBridgeInlineEditEnded, } = useBridgeInlineEditing({
         pageViewContextRef,
-        activeBridgeInlineEditRef,
+        inlineEditSession: bridgeInlineEditSession,
         blockIframeBlurUntil,
         sendBeginInlineEdit,
         sendCancelInlineEdit,
@@ -916,30 +935,27 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                 selectionEndOffset: interaction.selectionEndOffset,
             },
         });
-        clearActiveBridgeInlineEdit();
-        const started = await beginBridgeInlineEdit(interaction);
-        if (started && interaction.elementKey && interaction.fieldId) {
-            const interactionItem = interaction.item?.id &&
-                interaction.item.language &&
-                typeof interaction.item.version === "number"
-                ? {
-                    id: interaction.item.id,
-                    language: interaction.item.language,
-                    version: interaction.item.version,
-                    name: interaction.item.name,
-                    displayName: interaction.item.displayName,
-                    path: interaction.item.path,
-                    database: interaction.item.database,
-                }
-                : undefined;
-            activeBridgeInlineEditRef.current = {
-                elementKey: interaction.elementKey,
-                fieldId: interaction.fieldId,
-                item: interactionItem,
-                modeAtStart: editContextRef.current?.mode ?? editContext.mode,
-            };
-            setIsBridgeInlineEditing(true);
-        }
+        if (!interaction.elementKey || !interaction.fieldId)
+            return false;
+        const interactionItem = interaction.item?.id &&
+            interaction.item.language &&
+            typeof interaction.item.version === "number"
+            ? {
+                id: interaction.item.id,
+                language: interaction.item.language,
+                version: interaction.item.version,
+                name: interaction.item.name,
+                displayName: interaction.item.displayName,
+                path: interaction.item.path,
+                database: interaction.item.database,
+            }
+            : undefined;
+        const started = await bridgeInlineEditSession.beginSession({
+            elementKey: interaction.elementKey,
+            fieldId: interaction.fieldId,
+            item: interactionItem,
+            modeAtStart: editContextRef.current?.mode ?? editContext.mode,
+        }, ({ isCurrent, sessionId }) => beginBridgeInlineEdit(interaction, { isCurrent, sessionId }));
         logFieldValueDiagnostic("bridge-frame", "tracked inline edit result", {
             started,
             nextActiveInlineEdit: activeBridgeInlineEditRef.current,
@@ -947,7 +963,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         return started;
     }, [
         beginBridgeInlineEdit,
-        clearActiveBridgeInlineEdit,
+        bridgeInlineEditSession,
         editContext.mode,
         editContextRef,
     ]);
@@ -1015,6 +1031,11 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     const getBridgePatchDisplayValue = useCallback(({ field, structureField, itemDescriptor, preferRepositoryValue, }) => {
         const showSuggestions = editContext.mode === "suggestions" || editContext.showSuggestedEdits;
         const repositoryValue = getBridgeFieldPatchValue(field);
+        const selectionKey = getSuggestionSelectionKey({
+            itemId: itemDescriptor.id,
+            language: itemDescriptor.language,
+            fieldId: field.id || structureField.fieldId,
+        });
         const display = getSuggestionDisplayValue({
             repositoryValue,
             modifiedFields: preferRepositoryValue
@@ -1027,12 +1048,14 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                 language: itemDescriptor.language,
                 version: itemDescriptor.version,
                 pageItemId: pageViewContext.pageItemDescriptor?.id,
+                pageItemLanguage: pageViewContext.pageItemDescriptor?.language,
                 pageItemVersion: pageViewContext.pageItemDescriptor?.version,
             },
             mode: showSuggestions ? "suggestions" : "baseline",
+            selectedVariantId: editContext.suggestionVariantSelection[selectionKey],
         });
         const result = {
-            value: showSuggestions ? display.mergedValue : display.baselineValue,
+            value: showSuggestions ? display.selectedValue : display.baselineValue,
             source: showSuggestions && display.hasSuggestions
                 ? "suggestion-preview"
                 : "real",
@@ -1062,6 +1085,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         editContext.mode,
         editContext.showSuggestedEdits,
         editContext.suggestedEdits,
+        editContext.suggestionVariantSelection,
         fieldsContext?.modifiedFields,
         pageViewContext.pageItemDescriptor,
     ]);
@@ -1086,12 +1110,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
     }, []);
     const sendBridgeFieldPatch = useCallback((bridge, patch, observedTextContent) => {
         const cacheKey = `${patch.elementKey}:${patch.fieldId}`;
-        const signature = JSON.stringify({
-            value: patch.value,
-            isRichText: !!patch.isRichText,
-            source: patch.source ?? "",
-            observedTextContent: observedTextContent ?? "",
-        });
+        const signature = buildBridgeFieldPatchSignature(patch, observedTextContent);
         const previousSignature = bridgePatchSignatureRef.current.get(cacheKey);
         if (previousSignature === signature) {
             logFieldValueDiagnostic("bridge-patch", "skipped duplicate send", {
@@ -1133,6 +1152,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         const offset = selection.startOffset ?? selection.endOffset;
         if (!editor ||
             !activeField?.fieldId ||
+            activeField.inlineEditing !== true ||
             !selection.collapsed ||
             offset == null) {
             clearBridgeRemoteCaretPosition();
@@ -1153,19 +1173,50 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
             ...sourceItem,
             version,
         };
-        const nextKey = `${activeField.fieldId}:${item.id}:${item.language}:${item.version}:${offset}`;
+        const nextKey = JSON.stringify({
+            fieldId: activeField.fieldId,
+            item,
+            offset,
+            value: activeField.value,
+        });
         if (lastSentBridgeCaretRef.current === nextKey)
             return;
+        logFieldValueDiagnostic("bridge-caret", "sending position", {
+            fieldId: activeField.fieldId,
+            item,
+            offset,
+            value: summarizeFieldValue(activeField.value),
+        });
         editor.sendSocketMessage({
             type: "caret-position",
             payload: {
                 fieldId: activeField.fieldId,
                 item,
                 offset,
+                value: activeField.value,
             },
         });
         lastSentBridgeCaretRef.current = nextKey;
     }, [clearBridgeRemoteCaretPosition, editContextRef, pageViewContextRef]);
+    useEffect(() => {
+        const bridge = bridgeClientRef.current;
+        const structureFields = pageViewContext.bridgeStructure?.fields ?? [];
+        if (!bridge || structureFields.length === 0)
+            return;
+        const patches = buildRemoteCaretFieldPatches({
+            remoteCarets: editContext.remoteCarets,
+            structureFields,
+            activeInlineEdit: activeBridgeInlineEditRef.current,
+        });
+        for (const patch of patches) {
+            const structureField = structureFields.find((field) => field.elementKey === patch.elementKey);
+            sendBridgeFieldPatch(bridge, patch, structureField?.textContent);
+        }
+    }, [
+        editContext.remoteCarets,
+        pageViewContext.bridgeStructure,
+        sendBridgeFieldPatch,
+    ]);
     const handleBridgeSelection = useCallback((selection, iframe) => {
         const editor = editContextRef.current;
         if (!editor)
@@ -1305,8 +1356,27 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         addCandidateItem(component?.datasourceItem);
         component?.items.forEach(addCandidateItem);
         addCandidateItem(fallbackItem);
+        const fallbackDescriptorItem = candidateItems[0];
+        if (!fallbackDescriptorItem)
+            return undefined;
+        // Limited-preview users only need read-only actions such as comments.
+        // The bridge already provides the reviewed item's field descriptor, while
+        // repository hydration may be intentionally denied by preview access.
+        if (editContextRef.current?.user?.isLimitedPreviewUser) {
+            return { fieldId, item: fallbackDescriptorItem };
+        }
         for (const item of candidateItems) {
-            const repositoryItem = await editContextRef.current?.itemsRepository.getItem(item);
+            let repositoryItem;
+            try {
+                repositoryItem =
+                    await editContextRef.current?.itemsRepository.getItem(item);
+            }
+            catch {
+                // Review-preview access may allow the rendered page while denying a
+                // repository candidate. Keep trying and fall back to the bridge
+                // descriptor so read-only context-menu actions can still load.
+                continue;
+            }
             const repositoryField = repositoryItem?.fields.find((field) => fieldIdentifierMatches(field, fieldId));
             if (repositoryField) {
                 return {
@@ -1315,9 +1385,6 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                 };
             }
         }
-        const fallbackDescriptorItem = candidateItems[0];
-        if (!fallbackDescriptorItem)
-            return undefined;
         return {
             fieldId,
             item: fallbackDescriptorItem,
@@ -1774,41 +1841,59 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     },
                 ]);
             }, 100);
-            const field = await resolveBridgeFieldDescriptor(effectiveInteraction);
-            const fieldButtons = field ? await loadFieldButtons(field) : [];
-            const handleParameterizedActionWithPosition = (field, action) => {
-                setContextMenuField(field);
-                setContextMenuFieldButtons([action]);
-                setPreSelectedAction(action);
-                window.setTimeout(() => {
-                    const tempElement = document.createElement("div");
-                    tempElement.style.position = "fixed";
-                    tempElement.style.left = menuPosition.x + "px";
-                    tempElement.style.top = menuPosition.y + "px";
-                    tempElement.style.width = "1px";
-                    tempElement.style.height = "1px";
-                    tempElement.style.visibility = "hidden";
-                    tempElement.style.pointerEvents = "none";
-                    document.body.appendChild(tempElement);
-                    const positionedEvent = new MouseEvent("click", {
-                        bubbles: true,
-                        cancelable: true,
-                        view: window,
-                        clientX: menuPosition.x,
-                        clientY: menuPosition.y,
-                    });
-                    Object.defineProperty(positionedEvent, "target", {
-                        value: tempElement,
-                        enumerable: true,
-                    });
-                    fieldActionsOverlay.current?.show(positionedEvent, action);
+            let items = [];
+            try {
+                const field = await resolveBridgeFieldDescriptor(effectiveInteraction);
+                const canLoadFieldButtons = !!field && !editor.readonly && !editor.user?.isLimitedPreviewUser;
+                const fieldButtons = canLoadFieldButtons
+                    ? await loadFieldButtons(field)
+                    : [];
+                const handleParameterizedActionWithPosition = (field, action) => {
+                    setContextMenuField(field);
+                    setContextMenuFieldButtons([action]);
+                    setPreSelectedAction(action);
                     window.setTimeout(() => {
-                        tempElement.remove();
-                    }, 1000);
-                }, 100);
-            };
-            const items = await buildComponentContextMenuItems(selectedComponents, editor, field, fieldButtons, handleParameterizedActionWithPosition);
-            window.clearTimeout(loadingTimer);
+                        const tempElement = document.createElement("div");
+                        tempElement.style.position = "fixed";
+                        tempElement.style.left = menuPosition.x + "px";
+                        tempElement.style.top = menuPosition.y + "px";
+                        tempElement.style.width = "1px";
+                        tempElement.style.height = "1px";
+                        tempElement.style.visibility = "hidden";
+                        tempElement.style.pointerEvents = "none";
+                        document.body.appendChild(tempElement);
+                        const positionedEvent = new MouseEvent("click", {
+                            bubbles: true,
+                            cancelable: true,
+                            view: window,
+                            clientX: menuPosition.x,
+                            clientY: menuPosition.y,
+                        });
+                        Object.defineProperty(positionedEvent, "target", {
+                            value: tempElement,
+                            enumerable: true,
+                        });
+                        fieldActionsOverlay.current?.show(positionedEvent, action);
+                        window.setTimeout(() => {
+                            tempElement.remove();
+                        }, 1000);
+                    }, 100);
+                };
+                items = await buildComponentContextMenuItems(selectedComponents, editor, field, fieldButtons, handleParameterizedActionWithPosition);
+            }
+            catch (error) {
+                console.error("Failed to build component context menu:", error);
+                items = [
+                    {
+                        id: "context-menu-error",
+                        label: "Unable to load menu",
+                        disabled: true,
+                    },
+                ];
+            }
+            finally {
+                window.clearTimeout(loadingTimer);
+            }
             if (loadingShown) {
                 editor.updateContextMenu(items);
             }
@@ -1906,6 +1991,8 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     return;
                 lastX = scroll.x;
                 lastY = scroll.y;
+                latestBridgeScrollRef.current = scroll;
+                projectCurrentBridgeGeometryToScroll(scroll);
                 dispatchBridgeOverlayScroll(iframe, scroll, getBridgeGeometryScrollScale(pageViewContextRef.current?.bridgeGeometry));
             };
             iframeDocument.addEventListener("scroll", handleScroll, {
@@ -1928,7 +2015,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
             detach?.();
             directOverlayScrollSyncRef.current = false;
         };
-    }, [iframeElement, loadedIframeSrc]);
+    }, [iframeElement, loadedIframeSrc, projectCurrentBridgeGeometryToScroll]);
     useEffect(() => {
         const iframe = iframeElement;
         if (!iframe)
@@ -2038,19 +2125,22 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                                 transportMs: Date.now() - event.timestamp,
                             });
                         }
-                        latestBridgeScrollRef.current = event.payload.geometry.scroll;
-                        pageViewContext.bridgeGeometry = event.payload.geometry;
-                        pageViewContext.setBridgeGeometry(event.payload.geometry);
-                        scheduleBridgeGeometryRevision();
-                        // The snapshot's scroll can be a frame older than what the direct
-                        // same-origin listener already applied; prefer the live position.
-                        const overlayScroll = (directOverlayScrollSyncRef.current
+                        // Geometry replies race the iframe's synchronous scroll event. A
+                        // reply measured before the scroll must not replace the projected
+                        // rects with a stale snapshot while the overlay layer is already
+                        // positioned at the live scroll offset.
+                        const liveScroll = (directOverlayScrollSyncRef.current
                             ? getIframeWindowScroll(iframe)
                             : undefined) ?? event.payload.geometry.scroll;
-                        dispatchBridgeOverlayScroll(iframe, overlayScroll, getBridgeGeometryScrollScale(event.payload.geometry));
-                        dispatchBridgeOverlayGeometry(iframe, event.payload.geometry, overlayScroll);
+                        const geometry = projectBridgeGeometryToScroll(event.payload.geometry, liveScroll) ?? event.payload.geometry;
+                        latestBridgeScrollRef.current = geometry.scroll;
+                        pageViewContext.bridgeGeometry = geometry;
+                        pageViewContext.setBridgeGeometry(geometry);
+                        scheduleBridgeGeometryRevision();
+                        dispatchBridgeOverlayScroll(iframe, geometry.scroll, getBridgeGeometryScrollScale(geometry));
+                        dispatchBridgeOverlayGeometry(iframe, geometry, geometry.scroll);
                         if (shouldTrackMinimapScroll()) {
-                            scrollHandlerRef.current(event.payload.geometry.scroll.y);
+                            scrollHandlerRef.current(geometry.scroll.y);
                         }
                         break;
                     }
@@ -2096,20 +2186,25 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                             pageViewContext.setBridgeStructure(event.payload.structure);
                         }
                         if (event.payload.geometry) {
-                            latestBridgeScrollRef.current = event.payload.geometry.scroll;
-                            pageViewContext.bridgeGeometry = event.payload.geometry;
-                            pageViewContext.setBridgeGeometry(event.payload.geometry);
-                            scheduleBridgeGeometryRevision();
-                            const overlayScroll = (directOverlayScrollSyncRef.current
+                            const liveScroll = (directOverlayScrollSyncRef.current
                                 ? getIframeWindowScroll(iframe)
                                 : undefined) ?? event.payload.geometry.scroll;
-                            dispatchBridgeOverlayScroll(iframe, overlayScroll, getBridgeGeometryScrollScale(event.payload.geometry));
-                            dispatchBridgeOverlayGeometry(iframe, event.payload.geometry, overlayScroll);
+                            const geometry = projectBridgeGeometryToScroll(event.payload.geometry, liveScroll) ?? event.payload.geometry;
+                            latestBridgeScrollRef.current = geometry.scroll;
+                            pageViewContext.bridgeGeometry = geometry;
+                            pageViewContext.setBridgeGeometry(geometry);
+                            scheduleBridgeGeometryRevision();
+                            dispatchBridgeOverlayScroll(iframe, geometry.scroll, getBridgeGeometryScrollScale(geometry));
+                            dispatchBridgeOverlayGeometry(iframe, geometry, geometry.scroll);
                             if (shouldTrackMinimapScroll()) {
-                                scrollHandlerRef.current(event.payload.geometry.scroll.y);
+                                scrollHandlerRef.current(geometry.scroll.y);
                             }
                         }
-                        if (event.payload.scrollIntentApplied) {
+                        const replayedScrollIsNewerThanCapture = event.payload.scrollIntentApplied &&
+                            (typeof event.payload.scrollIntentTimestamp !== "number" ||
+                                event.payload.scrollIntentTimestamp >=
+                                    pendingRefreshScrollCapturedAtRef.current);
+                        if (replayedScrollIsNewerThanCapture) {
                             // The host already replayed a scroll issued during the refresh
                             // (e.g. a minimap navigation) — restoring the pre-refresh
                             // position now would clobber that newer intent.
@@ -2148,9 +2243,6 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                         handleBridgeSelection(event.payload.selection, iframe);
                         break;
                     case "fieldValueChanged":
-                        if (event.payload.elementKey && event.payload.fieldId) {
-                            setIsBridgeInlineEditing(true);
-                        }
                         logFieldValueDiagnostic("bridge-frame", "fieldValueChanged event", {
                             elementKey: event.payload.elementKey,
                             fieldId: event.payload.fieldId,
@@ -2171,9 +2263,15 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                             value: summarizeFieldValue(event.payload.value),
                             activeInlineEdit: activeBridgeInlineEditRef.current,
                         });
-                        handleBridgeInlineEditEnded(event.payload);
-                        clearActiveBridgeInlineEdit();
-                        logFieldValueDiagnostic("bridge-frame", "active inline edit cleared after end", {
+                        const inlineEditEnd = bridgeInlineEditSession.end(event.payload);
+                        handleBridgeInlineEditEnded(event.payload, {
+                            recordSession: false,
+                            releaseFocus: inlineEditEnd.matched,
+                            endedModeAtStart: inlineEditEnd.endedState?.modeAtStart,
+                        });
+                        logFieldValueDiagnostic("bridge-frame", inlineEditEnd.matched
+                            ? "active inline edit cleared after end"
+                            : "non-current inline edit end persisted", {
                             fieldId: event.payload.fieldId,
                             reason: event.payload.reason,
                         });
@@ -2232,6 +2330,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                         break;
                     case "scrollChanged":
                         latestBridgeScrollRef.current = event.payload.scroll;
+                        projectCurrentBridgeGeometryToScroll(event.payload.scroll);
                         // With the direct same-origin listener active, this message is a
                         // late echo of a scroll the overlay already applied; re-dispatching
                         // it would briefly drag the overlay back to a stale position.
@@ -2273,6 +2372,7 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         clearBridgeTextCompletion,
         clearBridgePatchSignatures,
         clearActiveBridgeInlineEdit,
+        bridgeInlineEditSession,
         reconcileActiveBridgeInlineEdit,
         pageViewContext.editUrl,
         pageViewContext.previewUrl,
@@ -2310,6 +2410,17 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     if (!bridgeFieldMatchesChangedField(structureField.fieldId, changedFieldId, field)) {
                         continue;
                     }
+                    // A remote session is live-syncing this field: its draft is
+                    // authoritative, and the saved-value echo behind this change is
+                    // stale mid-typing — applying it would roll the canvas text back
+                    // and make the remote caret jump against the shorter text.
+                    if (hasRemoteCaretDraftForField({
+                        remoteCarets: editContextRef.current?.remoteCarets,
+                        fieldId: structureField.fieldId,
+                        item: structureField.item,
+                    })) {
+                        continue;
+                    }
                     const patch = buildBridgeFieldPatch({
                         field,
                         structureField,
@@ -2431,7 +2542,25 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
                     itemDescriptor: itemDescriptor,
                     dirtyOnly: true,
                 });
-                if (!showSuggestions && !dirtyModifiedField) {
+                // When suggestion display turns off, a field can still show suggestion
+                // text even though nothing is dirty: either its last patch was a
+                // suggestion preview, or an inline edit typed the suggestion into the
+                // DOM and the recorded suggestion only lands after the toggle. Both
+                // need an explicit restore patch back to the baseline value.
+                const needsSuggestionRestore = !showSuggestions &&
+                    (isSuggestionPreviewPatchSignature(bridgePatchSignatureRef.current.get(`${structureField.elementKey}:${structureField.fieldId}`)) ||
+                        getPendingFieldSuggestions(editContext.suggestedEdits, {
+                            fieldId: field.id || structureField.fieldId,
+                            itemId: itemDescriptor.id,
+                            language: itemDescriptor.language,
+                            version: itemDescriptor.version,
+                            pageItemId: pageViewContextRef.current?.pageItemDescriptor?.id,
+                            pageItemLanguage: pageViewContextRef.current?.pageItemDescriptor?.language,
+                            pageItemVersion: pageViewContextRef.current?.pageItemDescriptor?.version,
+                        }).length > 0);
+                if (!showSuggestions &&
+                    !dirtyModifiedField &&
+                    !needsSuggestionRestore) {
                     continue;
                 }
                 const patch = buildBridgeFieldPatch({
@@ -2698,14 +2827,18 @@ function PageViewerFrameContent({ compareView, pageViewContext, editContext, cla
         const signatureUrl = new URL(renderUrl.toString());
         signatureUrl.searchParams.delete("edit_rev");
         const renderSignature = `${signatureUrl.toString()}|rev:${editContext.revision}`;
+        const modeChanged = lastRenderModeRef.current !== editContext.mode;
+        lastRenderModeRef.current = editContext.mode;
         // Only skip when a live bridge confirms the last refresh actually reached
-        // the host. Before the bridge is connected, re-runs must keep going: the
-        // retry/fallback-reload path below is what recovers a canvas whose first
-        // load raced the bridge injection.
+        // the host, or when the only meaningful trigger is an edit/suggestions
+        // mode change. Mode is delivered by setEditorMode and cannot change the
+        // server-rendered URL/revision; reloading during a transient bridge
+        // disconnect would needlessly reset iframe scroll. Before the first bridge
+        // connection, identical non-mode re-runs still use the recovery path.
         if (!shouldUseIframeSrcReload &&
             !versionChanged &&
             lastRenderSignatureRef.current === renderSignature &&
-            bridgeClientRef.current?.supportsCapability("refresh")) {
+            (modeChanged || bridgeClientRef.current?.supportsCapability("refresh"))) {
             setCurrentItemDescriptor(pageItemDescriptor);
             return;
         }