@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/ui/WordReviewEditor.tsx

@@ -27,11 +27,15 @@ import type {
   FormattingAlignment,
   FormattingStateSnapshot,
   HeaderFooterLinkPatch,
+  HostAnnotationItem,
+  HostAnnotationOverlay,
   InteractionGuardSnapshot,
   InsertImageOptions,
   InsertTableOptions,
   PageLayoutSnapshot,
   PersistedEditorSnapshot,
+  ReviewQueueItem,
+  ReviewQueueSnapshot,
   RuntimeRenderSnapshot,
   SectionBreakType,
   SectionLayoutPatch,
@@ -39,8 +43,11 @@ import type {
   SearchOptions,
   SearchResultSnapshot,
   SelectionSnapshot as PublicSelectionSnapshot,
+  SuggestionEntrySnapshot,
+  SuggestionsSnapshot,
   StyleCatalogSnapshot,
   SurfaceBlockSnapshot,
+  SurfaceInlineSegment,
   TrackedChangeEntrySnapshot,
   TocRefreshResult,
   UpdateFieldsResult,
@@ -48,6 +55,8 @@ import type {
   WorkflowBlockedCommandReason,
   WorkflowMarkupSnapshot,
   WorkflowScopeSnapshot,
+  WordReviewEditorChromeOptions,
+  WordReviewEditorChromePreset,
   WordReviewEditorChromeVisibility,
   WordReviewEditorEvent,
   WordReviewEditorProps,
@@ -81,6 +90,8 @@ import {
   outdentListItems,
   restartNumbering as restartListNumbering,
   splitListParagraph,
+  toggleBulletedList,
+  toggleNumberedList,
 } from "../core/commands/list-commands.ts";
 import {
   resolveActiveParagraphIndex,
@@ -101,6 +112,7 @@ import {
 } from "../core/commands/image-commands.ts";
 import {
   applyTableStructureOperation,
+  getTableStructureContext,
 } from "../core/commands/table-structure-commands.ts";
 import {
   deleteSelectionOrBackward,
@@ -124,6 +136,10 @@ import {
 import { readOpcPackage } from "../io/opc/package-reader.ts";
 import { deriveCapabilities } from "../runtime/session-capabilities";
 import { searchDocument } from "../runtime/document-search.ts";
+import {
+  resolveCurrentContextAnalyticsQuery,
+  runtimeContextAnalyticsSnapshotsEqual,
+} from "../runtime/context-analytics.ts";
 import {
   createEditorViewStateSnapshot,
   createViewState,
@@ -154,7 +170,12 @@ import type {
   SelectionToolbarModel,
   SuggestionCardModel,
 } from "./headless/selection-toolbar-model";
+import { resolveActiveSelectionTool } from "./headless/selection-tool-resolver";
 import { type EditorCommandBag, useCommandBag } from "./editor-command-bag.ts";
+import {
+  resolveHeadingShortcutStyleId,
+  resolveShellShortcut,
+} from "./runtime-shortcut-dispatch";
 import { deriveVisibleWorkflowBlockedRails } from "./workflow-surface-blocked-rails.ts";
 import {
   type WordReviewEditorRuntime,
@@ -169,6 +190,10 @@ import {
 } from "./browser-export";
 import { EditorShellView } from "./editor-shell-view.tsx";
 import { EditorSurfaceController } from "./editor-surface-controller.tsx";
+import {
+  resolveChromePreset,
+  resolveChromeVisibilityForPreset,
+} from "../ui-tailwind/chrome/chrome-preset-model.ts";
 
 export {
   __createFallbackRuntime,
@@ -244,12 +269,20 @@ export function __createWordReviewEditorRefBridge(
       clonePublicValue(runtime.getRenderSnapshot().comments),
     getTrackedChangesSnapshot: () =>
       clonePublicValue(runtime.getRenderSnapshot().trackedChanges),
+    getSuggestionsSnapshot: () =>
+      clonePublicValue(runtime.getSuggestionsSnapshot()),
     getComments: () => clonePublicValue(runtime.getRenderSnapshot().comments),
     getTrackedChanges: () =>
       clonePublicValue(runtime.getRenderSnapshot().trackedChanges),
     isDirty: () => runtime.getRenderSnapshot().isDirty,
     getFormattingState: () => getFormattingStateFromRenderSnapshot(runtime.getRenderSnapshot()),
     getStyleCatalog: () => getRuntimeStyleCatalog(runtime),
+    toggleBulletedList: () => {
+      applyRuntimeListToggle(runtime, "bulleted");
+    },
+    toggleNumberedList: () => {
+      applyRuntimeListToggle(runtime, "numbered");
+    },
     toggleBold: () => {
       applyRuntimeFormattingOperation(runtime, { type: "toggle", mark: "bold" });
     },
@@ -310,6 +343,12 @@ export function __createWordReviewEditorRefBridge(
     outdent: () => {
       applyRuntimeFormattingOperation(runtime, { type: "outdent" });
     },
+    restartNumbering: () => {
+      applyRuntimeNumberingFlow(runtime, { type: "restart" });
+    },
+    continueNumbering: () => {
+      applyRuntimeNumberingFlow(runtime, { type: "continue" });
+    },
     insertPageBreak: () => {
       applyRuntimeInsertPageBreak(runtime);
     },
@@ -407,6 +446,36 @@ export function __createWordReviewEditorRefBridge(
     getDocumentNavigationSnapshot: () => {
       return clonePublicValue(runtime.getDocumentNavigationSnapshot());
     },
+    getCurrentLocation: () => {
+      return clonePublicValue(runtime.getCurrentLocation());
+    },
+    getLocationForSelection: (selection) => {
+      return clonePublicValue(runtime.getLocationForSelection(selection));
+    },
+    getLocationForAnchor: (anchor, storyTarget) => {
+      return clonePublicValue(runtime.getLocationForAnchor(anchor, storyTarget));
+    },
+    captureRestorePoint: (input) => {
+      return clonePublicValue(runtime.captureRestorePoint(input));
+    },
+    restoreToPoint: (point, options) => {
+      return clonePublicValue(runtime.restoreToPoint(point, options));
+    },
+    getOutlineSnapshot: () => {
+      return clonePublicValue(runtime.getOutlineSnapshot());
+    },
+    getTocSnapshot: () => {
+      return clonePublicValue(runtime.getTocSnapshot());
+    },
+    getSections: () => {
+      return clonePublicValue(runtime.getSections());
+    },
+    getSectionSnapshot: (input) => {
+      return clonePublicValue(runtime.getSectionSnapshot(input));
+    },
+    describeEventImpact: (event) => {
+      return clonePublicValue(runtime.describeEventImpact(event));
+    },
     getFieldSnapshot: () => {
       return clonePublicValue(runtime.getFieldSnapshot());
     },
@@ -467,6 +536,21 @@ export function __createWordReviewEditorRefBridge(
     getWorkflowMarkupSnapshot: () => {
       return clonePublicValue(runtime.getWorkflowMarkupSnapshot());
     },
+    setWorkflowMetadataDefinitions: (definitions) => {
+      runtime.setWorkflowMetadataDefinitions(clonePublicValue(definitions));
+    },
+    clearWorkflowMetadataDefinitions: () => {
+      runtime.clearWorkflowMetadataDefinitions();
+    },
+    setWorkflowMetadataEntries: (entries) => {
+      runtime.setWorkflowMetadataEntries(clonePublicValue(entries));
+    },
+    clearWorkflowMetadataEntries: () => {
+      runtime.clearWorkflowMetadataEntries();
+    },
+    getWorkflowMetadataSnapshot: () => {
+      return clonePublicValue(runtime.getWorkflowMetadataSnapshot());
+    },
     setHostAnnotationOverlay: (overlay) => {
       runtime.setHostAnnotationOverlay(clonePublicValue(overlay));
     },
@@ -476,6 +560,31 @@ export function __createWordReviewEditorRefBridge(
     getHostAnnotationSnapshot: () => {
       return clonePublicValue(runtime.getHostAnnotationSnapshot());
     },
+    getReviewQueueSnapshot: () => {
+      return clonePublicValue(
+        deriveReviewQueueSnapshot({
+          sections: runtime.getSections(),
+          comments: runtime.getRenderSnapshot().comments.threads,
+          trackedChanges: runtime.getRenderSnapshot().trackedChanges.revisions,
+          hostAnnotations: runtime.getHostAnnotationSnapshot().annotations,
+        }),
+      );
+    },
+    getRuntimeContextAnalytics: (query) => {
+      return clonePublicValue(runtime.getRuntimeContextAnalytics(query));
+    },
+    goToNextReviewItem: () => {
+      return clonePublicValue(navigateReviewQueue(runtime, "next"));
+    },
+    goToPreviousReviewItem: () => {
+      return clonePublicValue(navigateReviewQueue(runtime, "previous"));
+    },
+    markSectionForReview: (input) => {
+      return markSectionForReview(runtime, input);
+    },
+    clearSectionReviewMark: (annotationId) => {
+      clearSectionReviewMark(runtime, annotationId);
+    },
     getWorkflowCandidateRanges: (options) => {
       return clonePublicValue(runtime.getWorkflowCandidateRanges(options));
     },
@@ -514,7 +623,10 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       initialSessionState,
       initialSnapshot,
       initialSourceLabel,
+      chromePreset,
+      chromeOptions,
       markupDisplay,
+      showUnsupportedObjectPreviews = false,
       onError,
       onEvent,
       onWarning,
@@ -532,6 +644,14 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
     const [selectionToolbarAnchor, setSelectionToolbarAnchor] = useState<SelectionToolbarAnchor | null>(null);
     const [selectionToolbarDismissedKey, setSelectionToolbarDismissedKey] = useState<string | null>(null);
     const [selectionToolbarFocusWithin, setSelectionToolbarFocusWithin] = useState(false);
+    const [hostAnnotationOverlayState, setHostAnnotationOverlayState] =
+      useState<HostAnnotationOverlay | null>(null);
+    const [activeReviewQueueItemId, setActiveReviewQueueItemId] = useState<string | null>(null);
+    const [reviewSectionMarks, setReviewSectionMarks] = useState<Array<{
+      annotationId: string;
+      sectionIndex: number;
+      label: string;
+    }>>([]);
     const surfaceRef = useRef<TwProseMirrorSurfaceRef | null>(null);
     const selectionToolbarElementRef = useRef<HTMLDivElement | null>(null);
     const shellRef = useRef<HTMLDivElement | null>(null);
@@ -676,10 +796,75 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       { effectiveMode: "edit", blockedReasons: [] } satisfies InteractionGuardSnapshot,
       interactionGuardSnapshotsEqual,
     );
+    const documentContextAnalytics = useRuntimeValue(
+      runtime
+        ? {
+            subscribe: (listener) => runtime.subscribe(listener),
+            getValue: () =>
+              runtime.getRuntimeContextAnalytics({
+                scopeKind: "document",
+              }),
+          }
+        : null,
+      null,
+      runtimeContextAnalyticsSnapshotsEqual,
+    );
+    const selectionContextAnalytics = useRuntimeValue(
+      runtime
+        ? {
+            subscribe: (listener) => runtime.subscribe(listener),
+            getValue: () => runtime.getRuntimeContextAnalytics(),
+          }
+        : null,
+      null,
+      runtimeContextAnalyticsSnapshotsEqual,
+    );
+    const currentScopeContextAnalytics = useRuntimeValue(
+      runtime
+        ? {
+            subscribe: (listener) => runtime.subscribe(listener),
+            getValue: () =>
+              runtime.getRuntimeContextAnalytics(
+                resolveCurrentContextAnalyticsQuery({
+                  workflowScopeSnapshot: runtime.getWorkflowScopeSnapshot(),
+                  interactionGuardSnapshot: runtime.getInteractionGuardSnapshot(),
+                }),
+              ),
+          }
+        : null,
+      null,
+      runtimeContextAnalyticsSnapshotsEqual,
+    );
     const workflowMarkupSnapshot = useMemo(
       () => (runtime ? runtime.getWorkflowMarkupSnapshot() : null),
       [runtime, snapshot.revisionToken],
     );
+    const sections = useMemo(
+      () => (runtime ? runtime.getSections() : []),
+      [runtime, snapshot.revisionToken],
+    );
+    const reviewQueueSnapshot = useMemo(
+      () =>
+        deriveReviewQueueSnapshot({
+          sections,
+          comments: snapshot.comments.threads,
+          trackedChanges: snapshot.trackedChanges.revisions,
+          hostAnnotations: mergeHostAndReviewSectionAnnotations(
+            hostAnnotationOverlayState?.annotations ?? [],
+            reviewSectionMarks,
+            sections,
+          ),
+          activeItemId: activeReviewQueueItemId,
+        }),
+      [
+        activeReviewQueueItemId,
+        hostAnnotationOverlayState,
+        reviewSectionMarks,
+        sections,
+        snapshot.comments.threads,
+        snapshot.trackedChanges.revisions,
+      ],
+    );
     const workflowBlockedRails = useMemo(
       () => deriveVisibleWorkflowBlockedRails(snapshot.surface, workflowMarkupSnapshot),
       [snapshot.surface, workflowMarkupSnapshot],
@@ -688,12 +873,104 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       () => (runtime ? runtime.getCanonicalDocument() : loadingSessionState.canonicalDocument),
       [loadingSessionState.canonicalDocument, runtime, snapshot.revisionToken],
     );
+    const loadingSnapshot = useMemo(
+      () =>
+        persistedSnapshotFromEditorSessionState(loadingSessionState, {
+          savedAt: loadingSessionState.updatedAt,
+        }),
+      [loadingSessionState],
+    );
     const effectiveViewMode = deriveEditorViewMode(snapshot.readOnly, reviewMode);
 
+    useEffect(() => {
+      const mergedAnnotations = mergeHostAndReviewSectionAnnotations(
+        hostAnnotationOverlayState?.annotations ?? [],
+        reviewSectionMarks,
+        sections,
+      );
+      if (mergedAnnotations.length === 0) {
+        activeRuntime.clearHostAnnotationOverlay();
+        return;
+      }
+      activeRuntime.setHostAnnotationOverlay({
+        overlayVersion: "host-annotation-overlay/1",
+        annotations: mergedAnnotations,
+      });
+    }, [activeRuntime, hostAnnotationOverlayState, reviewSectionMarks, sections]);
+
     useEffect(() => {
       activeRuntime.setViewMode(effectiveViewMode);
     }, [activeRuntime, effectiveViewMode]);
 
+    const markCurrentSectionForReview = useCallback((input?: {
+      sectionIndex?: number;
+      label?: string;
+    }): string | null => {
+      const sectionIndex = input?.sectionIndex ?? documentNavigation.activeSectionIndex;
+      const targetSection = sections.find((section) => section.sectionIndex === sectionIndex);
+      if (!targetSection) {
+        return null;
+      }
+      const annotationId = createReviewSectionMarkId(targetSection.sectionIndex);
+      const label =
+        input?.label ??
+        targetSection.primaryHeadingText ??
+        `Section ${targetSection.sectionIndex + 1}`;
+      setReviewSectionMarks((current) => [
+        ...current.filter((entry) => entry.annotationId !== annotationId),
+        {
+          annotationId,
+          sectionIndex: targetSection.sectionIndex,
+          label,
+        },
+      ]);
+      setActiveReviewQueueItemId(`section:${annotationId}`);
+      return annotationId;
+    }, [documentNavigation.activeSectionIndex, sections]);
+
+    const clearReviewSectionMarkById = useCallback((annotationId: string) => {
+      setActiveReviewQueueItemId((current) =>
+        current === `section:${annotationId}` ? null : current);
+      setReviewSectionMarks((current) =>
+        current.filter((entry) => entry.annotationId !== annotationId));
+    }, []);
+
+    useEffect(() => {
+      if (snapshot.comments.activeCommentId) {
+        setActiveReviewQueueItemId(`comment:${snapshot.comments.activeCommentId}`);
+        return;
+      }
+      if (activeRevisionId) {
+        setActiveReviewQueueItemId(`change:${activeRevisionId}`);
+      }
+    }, [activeRevisionId, snapshot.comments.activeCommentId]);
+
+    useEffect(() => {
+      if (
+        activeReviewQueueItemId &&
+        !reviewQueueSnapshot.items.some((item) => item.itemId === activeReviewQueueItemId)
+      ) {
+        setActiveReviewQueueItemId(null);
+      }
+    }, [activeReviewQueueItemId, reviewQueueSnapshot.items]);
+
+    const navigateMountedReviewQueue = useCallback(
+      (direction: "next" | "previous"): ReviewQueueItem | null => {
+        const nextItem = getAdjacentReviewQueueItem(
+          reviewQueueSnapshot,
+          activeReviewQueueItemId,
+          direction,
+        );
+        if (!nextItem) {
+          return null;
+        }
+        focusReviewQueueItem(activeRuntime, nextItem);
+        setActiveReviewQueueItemId(nextItem.itemId);
+        return nextItem;
+      },
+      [activeReviewQueueItemId, activeRuntime, reviewQueueSnapshot],
+    );
+
     useEffect(() => {
       activeRuntime.setDocumentMode(suggestionsEnabled ? "suggesting" : "editing");
     }, [activeRuntime, suggestionsEnabled]);
@@ -750,6 +1027,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
                 lastSavedRevisionTokenRef,
                 autosaveTimerRef,
               })
+            : loadError
+              ? Promise.reject(loadError)
             : rejectExportWhileLoadingFromBoundary({
                 documentId,
                 hostAdapter: hostAdapterRef.current,
@@ -757,8 +1036,10 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
                 onError: onErrorRef.current,
                 onEvent: onEventRef.current,
               }),
-        getSessionState: () => activeRuntime.getSessionState(),
-        getSnapshot: () => activeRuntime.getPersistedSnapshot(),
+        getSessionState: () =>
+          clonePublicValue(runtime ? runtime.getSessionState() : loadingSessionState),
+        getSnapshot: () =>
+          clonePublicValue(runtime ? runtime.getPersistedSnapshot() : loadingSnapshot),
         getRenderSnapshot: () => clonePublicValue(activeRuntime.getRenderSnapshot()),
         getCompatibilityReport: () => activeRuntime.getCompatibilityReport(),
         getWarnings: () => activeRuntime.getWarnings(),
@@ -766,6 +1047,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
           clonePublicValue(activeRuntime.getRenderSnapshot().comments),
         getTrackedChangesSnapshot: () =>
           clonePublicValue(activeRuntime.getRenderSnapshot().trackedChanges),
+        getSuggestionsSnapshot: () =>
+          clonePublicValue(activeRuntime.getSuggestionsSnapshot()),
         getComments: () =>
           clonePublicValue(activeRuntime.getRenderSnapshot().comments),
         getTrackedChanges: () =>
@@ -774,6 +1057,12 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         getFormattingState: () =>
           getFormattingStateFromRenderSnapshot(activeRuntime.getRenderSnapshot()),
         getStyleCatalog: () => getRuntimeStyleCatalog(activeRuntime),
+        toggleBulletedList: () => {
+          applyRuntimeListToggle(activeRuntime, "bulleted");
+        },
+        toggleNumberedList: () => {
+          applyRuntimeListToggle(activeRuntime, "numbered");
+        },
         toggleBold: () => {
           applyRuntimeFormattingOperation(activeRuntime, {
             type: "toggle",
@@ -852,6 +1141,12 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         outdent: () => {
           applyRuntimeFormattingOperation(activeRuntime, { type: "outdent" });
         },
+        restartNumbering: () => {
+          applyRuntimeNumberingFlow(activeRuntime, { type: "restart" });
+        },
+        continueNumbering: () => {
+          applyRuntimeNumberingFlow(activeRuntime, { type: "continue" });
+        },
         insertPageBreak: () => {
           applyRuntimeInsertPageBreak(activeRuntime);
         },
@@ -960,6 +1255,36 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         getDocumentNavigationSnapshot: () => {
           return clonePublicValue(activeRuntime.getDocumentNavigationSnapshot());
         },
+        getCurrentLocation: () => {
+          return clonePublicValue(activeRuntime.getCurrentLocation());
+        },
+        getLocationForSelection: (selection) => {
+          return clonePublicValue(activeRuntime.getLocationForSelection(selection));
+        },
+        getLocationForAnchor: (anchor, storyTarget) => {
+          return clonePublicValue(activeRuntime.getLocationForAnchor(anchor, storyTarget));
+        },
+        captureRestorePoint: (input) => {
+          return clonePublicValue(activeRuntime.captureRestorePoint(input));
+        },
+        restoreToPoint: (point, options) => {
+          return clonePublicValue(activeRuntime.restoreToPoint(point, options));
+        },
+        getOutlineSnapshot: () => {
+          return clonePublicValue(activeRuntime.getOutlineSnapshot());
+        },
+        getTocSnapshot: () => {
+          return clonePublicValue(activeRuntime.getTocSnapshot());
+        },
+        getSections: () => {
+          return clonePublicValue(activeRuntime.getSections());
+        },
+        getSectionSnapshot: (input) => {
+          return clonePublicValue(activeRuntime.getSectionSnapshot(input));
+        },
+        describeEventImpact: (event) => {
+          return clonePublicValue(activeRuntime.describeEventImpact(event));
+        },
         getFieldSnapshot: () => {
           return clonePublicValue(activeRuntime.getFieldSnapshot());
         },
@@ -1020,15 +1345,48 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         getWorkflowMarkupSnapshot: () => {
           return clonePublicValue(activeRuntime.getWorkflowMarkupSnapshot());
         },
+        setWorkflowMetadataDefinitions: (definitions) => {
+          activeRuntime.setWorkflowMetadataDefinitions(clonePublicValue(definitions));
+        },
+        clearWorkflowMetadataDefinitions: () => {
+          activeRuntime.clearWorkflowMetadataDefinitions();
+        },
+        setWorkflowMetadataEntries: (entries) => {
+          activeRuntime.setWorkflowMetadataEntries(clonePublicValue(entries));
+        },
+        clearWorkflowMetadataEntries: () => {
+          activeRuntime.clearWorkflowMetadataEntries();
+        },
+        getWorkflowMetadataSnapshot: () => {
+          return clonePublicValue(activeRuntime.getWorkflowMetadataSnapshot());
+        },
         setHostAnnotationOverlay: (overlay) => {
-          activeRuntime.setHostAnnotationOverlay(clonePublicValue(overlay));
+          setHostAnnotationOverlayState(clonePublicValue(overlay));
         },
         clearHostAnnotationOverlay: () => {
-          activeRuntime.clearHostAnnotationOverlay();
+          setHostAnnotationOverlayState(null);
         },
         getHostAnnotationSnapshot: () => {
           return clonePublicValue(activeRuntime.getHostAnnotationSnapshot());
         },
+        getReviewQueueSnapshot: () => {
+          return clonePublicValue(reviewQueueSnapshot);
+        },
+        getRuntimeContextAnalytics: (query) => {
+          return clonePublicValue(activeRuntime.getRuntimeContextAnalytics(query));
+        },
+        goToNextReviewItem: () => {
+          return clonePublicValue(navigateMountedReviewQueue("next"));
+        },
+        goToPreviousReviewItem: () => {
+          return clonePublicValue(navigateMountedReviewQueue("previous"));
+        },
+        markSectionForReview: (input) => {
+          return markCurrentSectionForReview(input);
+        },
+        clearSectionReviewMark: (annotationId) => {
+          clearReviewSectionMarkById(annotationId);
+        },
         getWorkflowCandidateRanges: (options) => {
           return clonePublicValue(activeRuntime.getWorkflowCandidateRanges(options));
         },
@@ -1036,7 +1394,16 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
           activeRuntime.replaceWorkflowMarkupText(markupId, text);
         },
       }),
-      [activeRuntime, currentUser.userId, documentId, runtime],
+      [
+        activeRuntime,
+        clearReviewSectionMarkById,
+        currentUser.userId,
+        documentId,
+        markCurrentSectionForReview,
+        navigateMountedReviewQueue,
+        reviewQueueSnapshot,
+        runtime,
+      ],
     );
 
     useEffect(() => {
@@ -1154,6 +1521,10 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
     }
 
     function exportCurrentDocument(): void {
+      const fileName =
+        typeof snapshot.sourceLabel === "string" && snapshot.sourceLabel.trim().length > 0
+          ? snapshot.sourceLabel
+          : undefined;
       void (runtime
         ? persistAndExportFromBoundary({
             hostAdapter: hostAdapterRef.current,
@@ -1162,9 +1533,12 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
             runtime,
             onError: onErrorRef.current,
             onEvent: onEventRef.current,
+            ...(fileName ? { options: { fileName } } : {}),
             lastSavedRevisionTokenRef,
             autosaveTimerRef,
           })
+        : loadError
+          ? Promise.reject(loadError)
         : rejectExportWhileLoadingFromBoundary({
             documentId,
             hostAdapter: hostAdapterRef.current,
@@ -1179,7 +1553,10 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       reviewMode,
       workflowScopeSnapshot,
     );
+    const effectiveChromePreset = resolveChromePreset(chromePreset, reviewMode);
     const resolvedChromeVisibility = resolveWordReviewEditorChromeVisibility(
+      effectiveChromePreset,
+      chromeOptions,
       chromeVisibility,
       showReviewPanel,
     );
@@ -1263,6 +1640,20 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
           : null,
       [viewState.activeObjectFrame],
     );
+    const activeTableContext = useMemo(
+      () =>
+        getTableStructureContext(
+          canonicalDocument,
+          snapshot,
+          surfaceRef.current?.getTableSelection() ?? null,
+        ),
+      [canonicalDocument, snapshot],
+    );
+    const suggestionsSnapshot = activeRuntime.getSuggestionsSnapshot();
+    const activeCommentThread =
+      snapshot.comments.activeCommentId
+        ? snapshot.comments.threads.find((thread) => thread.commentId === snapshot.comments.activeCommentId)
+        : undefined;
     const selectionToolbar = buildSelectionToolbarModel({
       snapshot,
       viewState,
@@ -1276,6 +1667,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
     });
     const suggestionCard = buildSuggestionCardModel({
       snapshot,
+      suggestionsSnapshot,
       viewState,
       capabilities,
       workflowScopeSnapshot,
@@ -1284,15 +1676,70 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       suppressedSuggestionRevisionId,
       addCommentDisabledReason,
     });
+    useEffect(() => {
+      if (!activeRevisionId) {
+        return;
+      }
+      if (snapshot.comments.activeCommentId) {
+        setActiveRevisionId(undefined);
+        return;
+      }
+      if (!isActiveRevisionStillFocused(
+        activeRevisionId,
+        suggestionsSnapshot,
+        snapshot.selection,
+        viewState.activeStory,
+      )) {
+        setActiveRevisionId(undefined);
+      }
+    }, [
+      activeRevisionId,
+      snapshot.comments.activeCommentId,
+      snapshot.selection,
+      suggestionsSnapshot,
+      viewState.activeStory,
+    ]);
+    const activeSelectionTool = resolveActiveSelectionTool({
+      snapshot,
+      viewState,
+      capabilities,
+      documentNavigation,
+      styleCatalog,
+      formattingState,
+      workflowScopeSnapshot,
+      interactionGuardSnapshot,
+      workflowMarkupSnapshot: workflowMarkupSnapshot ?? undefined,
+      suggestionsSnapshot,
+      activeRevisionId,
+      activeCommentId: snapshot.comments.activeCommentId,
+      activeCommentThread,
+      activeTableContext,
+      activeImageContext,
+      activeObjectContext,
+      activeListContext: viewState.activeListContext,
+      preferListStructureContext: viewState.workspaceMode === "page",
+      addCommentDisabledReason,
+      suppressedSuggestionRevisionId,
+    });
     const selectionToolbarSelectionKey = useMemo(
-      () => createSelectionToolbarSelectionKey(snapshot.selection, viewState.activeStory, activeRevisionId),
-      [activeRevisionId, snapshot.selection, viewState.activeStory],
+      () =>
+        createSelectionToolbarSelectionKey(
+          snapshot.selection,
+          viewState.activeStory,
+          activeRevisionId,
+          snapshot.comments.activeCommentId,
+        ),
+      [activeRevisionId, snapshot.comments.activeCommentId, snapshot.selection, viewState.activeStory],
     );
     const shouldRenderSelectionChrome = Boolean(
-      (selectionToolbar || suggestionCard) &&
+      activeSelectionTool &&
       selectionToolbarSelectionKey &&
       selectionToolbarDismissedKey !== selectionToolbarSelectionKey &&
-      (viewState.isFocused || selectionToolbarFocusWithin),
+      (
+        viewState.isFocused ||
+        selectionToolbarFocusWithin ||
+        activeSelectionTool.kind === "structure-context"
+      ),
     );
     const accessibilityInstructionsId = `${documentId}-accessibility-instructions`;
     const accessibilityStatusId = `${documentId}-accessibility-status`;
@@ -1426,11 +1873,11 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
     }, [selectionToolbarSelectionKey]);
 
     useEffect(() => {
-      if (!selectionToolbar && !suggestionCard) {
+      if (!activeSelectionTool) {
         setSelectionToolbarAnchor(null);
         setSelectionToolbarFocusWithin(false);
       }
-    }, [selectionToolbar, suggestionCard]);
+    }, [activeSelectionTool]);
 
     useEffect(() => {
       const shell = shellRef.current;
@@ -1460,50 +1907,85 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
 
     function handleShellKeyDownCapture(event: React.KeyboardEvent<HTMLDivElement>): void {
       const targetWithinDocument = isTargetWithinDocumentSurface(event.target);
-      const isUndoShortcut = (event.ctrlKey || event.metaKey) && !event.shiftKey && event.key.toLowerCase() === "z";
-      const isRedoShortcut =
-        ((event.ctrlKey || event.metaKey) && event.shiftKey && event.key.toLowerCase() === "z") ||
-        (event.ctrlKey && event.key.toLowerCase() === "y");
-
-      if ((isUndoShortcut || isRedoShortcut) && targetWithinDocument) {
-        event.preventDefault();
-        event.stopPropagation();
-        if (isUndoShortcut) {
-          activeRuntime.undo();
-        } else {
-          activeRuntime.redo();
-        }
-        return;
-      }
-
-      if (
-        event.key === "Escape" &&
-        shouldRenderSelectionChrome &&
-        (isTargetWithinDocumentSurface(event.target) || isTargetWithinSelectionToolbar(event.target))
-      ) {
-        event.preventDefault();
-        event.stopPropagation();
-        const restoreSurfaceFocus = isTargetWithinSelectionToolbar(event.target);
-        dismissSelectionToolbar("escape");
-        if (restoreSurfaceFocus) {
-          queueMicrotask(() => {
-            focusDocumentSurface();
-          });
-        }
-        return;
-      }
-
-      if (event.key !== "F6") {
-        return;
-      }
+      const targetWithinToolbar = isTargetWithinSelectionToolbar(event.target);
+      const shortcut = resolveShellShortcut(
+        {
+          key: event.key,
+          ctrlKey: event.ctrlKey,
+          metaKey: event.metaKey,
+          altKey: event.altKey,
+          shiftKey: event.shiftKey,
+        },
+        {
+          target: targetWithinDocument
+            ? "document"
+            : targetWithinToolbar
+              ? "selection-toolbar"
+              : "shell",
+          selectionToolbarVisible: shouldRenderSelectionChrome,
+        },
+      );
 
-      const shell = shellRef.current;
-      if (!shell) {
+      if (shortcut.kind === "none" || shortcut.kind === "delegate") {
         return;
       }
 
       event.preventDefault();
-      focusRelativeRegion(shell, event.shiftKey ? -1 : 1);
+      event.stopPropagation();
+
+      switch (shortcut.kind) {
+        case "history":
+          if (shortcut.history === "undo") {
+            commands.onUndo();
+          } else {
+            commands.onRedo();
+          }
+          return;
+        case "dismiss-selection-toolbar": {
+          dismissSelectionToolbar("escape");
+          if (targetWithinToolbar) {
+            queueMicrotask(() => {
+              focusDocumentSurface();
+            });
+          }
+          return;
+        }
+        case "focus-region": {
+          const shell = shellRef.current;
+          if (!shell) {
+            return;
+          }
+          focusRelativeRegion(shell, shortcut.direction);
+          return;
+        }
+        case "toggle-formatting":
+          if (shortcut.mark === "bold") {
+            commands.onToggleBold?.();
+          } else if (shortcut.mark === "italic") {
+            commands.onToggleItalic?.();
+          } else {
+            commands.onToggleUnderline?.();
+          }
+          return;
+        case "add-comment":
+          commands.onAddComment();
+          return;
+        case "set-heading-level": {
+          const styleId = resolveHeadingShortcutStyleId(styleCatalog, shortcut.level);
+          if (!styleId) {
+            activeRuntime.emitBlockedCommand("setParagraphStyle", [{
+              code: "unsupported_surface",
+              message: `Heading ${shortcut.level} is not available in this document's style catalog.`,
+            }]);
+            return;
+          }
+          commands.onSetParagraphStyle?.(styleId);
+          return;
+        }
+        case "block":
+          activeRuntime.emitBlockedCommand(shortcut.command, [shortcut.reason]);
+          return;
+      }
     }
 
     const editorCallbacks = {
@@ -1614,6 +2096,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         applyRuntimeFormattingOperation(activeRuntime, { type: "set-highlight-color", color }),
       onSetAlignment: (alignment) =>
         applyRuntimeFormattingOperation(activeRuntime, { type: "set-alignment", alignment }),
+      onToggleBulletedList: () => applyRuntimeListToggle(activeRuntime, "bulleted"),
+      onToggleNumberedList: () => applyRuntimeListToggle(activeRuntime, "numbered"),
       onSetParagraphStyle: (styleId) => applyRuntimeParagraphStyle(activeRuntime, styleId),
       onOutdent: () => applyRuntimeFormattingOperation(activeRuntime, { type: "outdent" }),
       onIndent: () => applyRuntimeFormattingOperation(activeRuntime, { type: "indent" }),
@@ -1687,6 +2171,19 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         applyRuntimeNumberingFlow(activeRuntime, { type: "restart" }),
       onContinueNumbering: () =>
         applyRuntimeNumberingFlow(activeRuntime, { type: "continue" }),
+      onUpdateFields: () => {
+        activeRuntime.updateFields();
+      },
+      onUpdateTableOfContents: () => {
+        activeRuntime.updateTableOfContents();
+      },
+      onGoToPreviousReviewItem: () => {
+        navigateMountedReviewQueue("previous");
+      },
+      onGoToNextReviewItem: () => {
+        navigateMountedReviewQueue("next");
+      },
+      onMarkSectionForReview: () => markCurrentSectionForReview(),
       onNavigateHeading: (headingId) => {
         const heading = documentNavigation.headings.find(
           (entry) => entry.headingId === headingId,
@@ -1710,7 +2207,9 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         documentNavigation={documentNavigation}
         reviewMode={reviewMode}
         markupDisplay={liveMarkupDisplay}
+        showUnsupportedObjectPreviews={showUnsupportedObjectPreviews}
         activeRevisionId={activeRevisionId}
+        activeSelectionToolKind={activeSelectionTool?.kind ?? null}
         showTrackedChanges={showTrackedChanges}
         suggestionsEnabled={suggestionsEnabled}
         mediaPreviews={mediaPreviews}
@@ -1720,6 +2219,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         workflowBlockedReasons={workflowBlockedRails}
         activeWorkflowWorkItemId={workflowScopeSnapshot?.activeWorkItemId ?? null}
         activeWorkflowScopeIds={workflowScopeSnapshot?.activeWorkItem?.scopeIds ?? []}
+        workflowMetadata={workflowMarkupSnapshot?.metadata}
         onSelectionToolbarAnchorChange={handleSelectionToolbarAnchorChange}
         {...editorCallbacks}
         onCommentActivated={(commentId) => {
@@ -1759,6 +2259,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         workspaceMode={viewState.workspaceMode}
         zoomLevel={viewState.zoomLevel}
         formattingState={formattingState}
+        activeListContext={viewState.activeListContext}
         styleCatalog={styleCatalog}
         activeRailTab={activeRailTab}
         activeCommentId={snapshot.comments.activeCommentId}
@@ -1766,34 +2267,51 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         showTrackedChanges={showTrackedChanges}
         workflowScopeSnapshot={workflowScopeSnapshot}
         interactionGuardSnapshot={interactionGuardSnapshot}
-        selectionToolbar={shouldRenderSelectionChrome ? selectionToolbar : null}
-        suggestionCard={shouldRenderSelectionChrome ? suggestionCard : null}
-        selectionToolbarAnchor={shouldRenderSelectionChrome ? selectionToolbarAnchor : null}
+        chromePreset={effectiveChromePreset}
+        chromeOptions={chromeOptions}
+        reviewQueue={reviewQueueSnapshot}
+        documentContextAnalytics={documentContextAnalytics}
+        selectionContextAnalytics={selectionContextAnalytics}
+        currentScopeContextAnalytics={currentScopeContextAnalytics}
+        activeSelectionTool={shouldRenderSelectionChrome ? activeSelectionTool : null}
+        selectionToolAnchor={shouldRenderSelectionChrome ? selectionToolbarAnchor : null}
         onAddCommentFromSelection={addSelectionToolbarComment}
         onAddCommentFromSuggestion={addSelectionToolbarComment}
-        onAcceptSuggestion={suggestionCard
+        onAcceptSuggestion={activeSelectionTool?.kind === "suggestion-review"
           ? () => {
-              activeRuntime.acceptChange(suggestionCard.revisionId);
+              for (const changeId of activeSelectionTool.changeIds) {
+                activeRuntime.acceptChange(changeId);
+              }
               dismissSelectionToolbar("chrome-action");
             }
           : undefined}
-        onRejectSuggestion={suggestionCard
+        onRejectSuggestion={activeSelectionTool?.kind === "suggestion-review"
           ? () => {
-              activeRuntime.rejectChange(suggestionCard.revisionId);
+              for (const changeId of activeSelectionTool.changeIds) {
+                activeRuntime.rejectChange(changeId);
+              }
               dismissSelectionToolbar("chrome-action");
             }
           : undefined}
-        onEditSuggestion={suggestionCard
+        onEditSuggestion={activeSelectionTool?.kind === "suggestion-review"
           ? () => {
-              setSuppressedSuggestionRevisionId(suggestionCard.revisionId);
+              setSuppressedSuggestionRevisionId(activeSelectionTool.suggestionId);
+              const activeSuggestion = suggestionsSnapshot.suggestions.find(
+                (suggestion) => suggestion.suggestionId === activeSelectionTool.suggestionId,
+              );
+              if (activeSuggestion) {
+                applyRuntimeSelection(
+                  activeRuntime,
+                  createSelectionFromAnchor(activeSuggestion.anchor, activeSuggestion.storyTarget),
+                );
+              }
+              setSelectionToolbarFocusWithin(true);
             }
           : undefined}
         onDismissSelectionToolbar={() => dismissSelectionToolbar("chrome-action")}
         onSelectionToolbarFocusCapture={handleSelectionToolbarFocusCapture}
         onSelectionToolbarBlurCapture={handleSelectionToolbarBlurCapture}
         selectionToolbarRef={selectionToolbarElementRef}
-        activeImageContext={activeImageContext}
-        activeObjectContext={activeObjectContext}
         commands={commands}
         document={documentElement}
       />
@@ -1813,6 +2331,11 @@ function applyRuntimeFormattingOperation(
     | { type: "indent" }
     | { type: "outdent" },
 ): void {
+  if (isSelectionSuggesting(runtime)) {
+    if (applySuggestingFormattingOperation(runtime, operation)) {
+      return;
+    }
+  }
   if (emitSuggestingUnsupportedMutation(runtime, getFormattingOperationCommandName(operation))) {
     return;
   }
@@ -1837,6 +2360,159 @@ function applyRuntimeFormattingOperation(
   );
 }
 
+function applySuggestingFormattingOperation(
+  runtime: WordReviewEditorRuntime,
+  operation:
+    | { type: "toggle"; mark: "bold" | "italic" | "underline" | "strikethrough" | "superscript" | "subscript" }
+    | { type: "set-font-family"; fontFamily: string | null }
+    | { type: "set-font-size"; size: number | null }
+    | { type: "set-text-color"; color: string | null }
+    | { type: "set-highlight-color"; color: string | null }
+    | { type: "set-alignment"; alignment: FormattingAlignment }
+    | { type: "indent" }
+    | { type: "outdent" },
+): boolean {
+  const commandName = getFormattingOperationCommandName(operation);
+  const context = getStoryMutationContext(runtime, commandName);
+  if (!context) {
+    return true;
+  }
+  if (context.activeStory.kind !== "main") {
+    runtime.emitBlockedCommand(commandName, [{
+      code: "suggesting_unsupported",
+      message: `"${commandName}" is not supported in suggesting mode for this story.`,
+    }]);
+    return true;
+  }
+
+  if (operation.type === "set-alignment" || operation.type === "indent" || operation.type === "outdent") {
+    const paragraphContext = resolveActiveParagraphContext(context.localSnapshot);
+    if (!paragraphContext) {
+      return true;
+    }
+    const beforeXml = buildParagraphPropertyBeforeXml(paragraphContext.paragraph);
+    const result = applyFormattingOperationToDocument(
+      context.localDocument,
+      context.localSnapshot,
+      operation,
+    );
+    if (!result.changed) {
+      return true;
+    }
+    const nextDocument = appendPropertyChangeSuggestion(
+      result.document,
+      {
+        from: paragraphContext.paragraph.from,
+        to: paragraphContext.paragraph.to,
+      },
+      {
+        originalRevisionType: "pPrChange",
+        xmlTag: "pPrChange",
+        beforeXml,
+        semanticKind: "paragraph-property-change",
+        storyTarget: context.activeStory,
+        authorId: runtime.getDefaultAuthorId?.(),
+      },
+      context.timestamp,
+    );
+    dispatchStoryMutationResult(
+      runtime,
+      context,
+      {
+        changed: true,
+        document: nextDocument,
+        selection: toRuntimeSelectionSnapshot(result.selection),
+      },
+      context.timestamp,
+    );
+    return true;
+  }
+
+  const segment = findSingleSelectedTextSegment(context.localSnapshot);
+  if (!segment) {
+    runtime.emitBlockedCommand(commandName, [{
+      code: "suggesting_unsupported",
+      message: `"${commandName}" requires one bounded text segment in suggesting mode.`,
+    }]);
+    return true;
+  }
+  const beforeXml = buildRunPropertyBeforeXml(segment);
+  const result = applyFormattingOperationToDocument(
+    context.localDocument,
+    context.localSnapshot,
+    operation,
+  );
+  if (!result.changed) {
+    return true;
+  }
+  const nextDocument = appendPropertyChangeSuggestion(
+    result.document,
+    {
+      from: segment.from,
+      to: segment.to,
+    },
+    {
+      originalRevisionType: "rPrChange",
+      xmlTag: "rPrChange",
+      beforeXml,
+      semanticKind: "formatting-change",
+      storyTarget: context.activeStory,
+      authorId: runtime.getDefaultAuthorId?.(),
+    },
+    context.timestamp,
+  );
+  dispatchStoryMutationResult(
+    runtime,
+    context,
+    {
+      changed: true,
+      document: nextDocument,
+      selection: toRuntimeSelectionSnapshot(result.selection),
+    },
+    context.timestamp,
+  );
+  return true;
+}
+
+function applyRuntimeListToggle(
+  runtime: WordReviewEditorRuntime,
+  kind: "bulleted" | "numbered",
+): void {
+  const commandName =
+    kind === "bulleted" ? "toggleBulletedList" : "toggleNumberedList";
+  if (emitSuggestingUnsupportedMutation(runtime, commandName)) {
+    return;
+  }
+  const context = getStoryMutationContext(runtime, commandName);
+  if (!context) {
+    return;
+  }
+
+  const paragraphContext = resolveActiveParagraphContext(context.localSnapshot);
+  if (!paragraphContext) {
+    return;
+  }
+
+  const result =
+    kind === "bulleted"
+      ? toggleBulletedList(
+          context.localDocument,
+          [paragraphContext.paragraphIndex],
+          { timestamp: context.timestamp },
+        )
+      : toggleNumberedList(
+          context.localDocument,
+          [paragraphContext.paragraphIndex],
+          { timestamp: context.timestamp },
+        );
+  dispatchStoryMutationResult(
+    runtime,
+    context,
+    createListMutationResult(result, context.localSnapshot.selection),
+    context.timestamp,
+  );
+}
+
 function getRuntimeStyleCatalog(
   input:
     | WordReviewEditorRuntime
@@ -2113,6 +2789,183 @@ function emitSuggestingUnsupportedMutation(
   return true;
 }
 
+function appendPropertyChangeSuggestion(
+  document: EditorSessionState["canonicalDocument"],
+  anchor: { from: number; to: number },
+  input: {
+    originalRevisionType: "rPrChange" | "pPrChange";
+    xmlTag: "rPrChange" | "pPrChange";
+    beforeXml: string;
+    semanticKind: "formatting-change" | "paragraph-property-change";
+    storyTarget: EditorStoryTarget;
+    authorId?: string;
+  },
+  timestamp: string,
+): EditorSessionState["canonicalDocument"] {
+  const existing = document.review.revisions;
+  const changeId = createRuntimeSuggestionChangeId(existing, timestamp);
+  const resolvedAuthorId = input.authorId ?? "unknown";
+  return {
+    ...document,
+    review: {
+      ...document.review,
+      revisions: {
+        ...existing,
+        [changeId]: {
+          changeId,
+          kind: "property-change",
+          anchor: createRangeAnchor(anchor.from, anchor.to, { start: 1, end: -1 }),
+          authorId: resolvedAuthorId,
+          createdAt: timestamp,
+          warningIds: [],
+          metadata: {
+            source: "runtime",
+            storyTarget: input.storyTarget,
+            suggestionId: changeId,
+            semanticKind: input.semanticKind,
+            originalRevisionType: input.originalRevisionType,
+            propertyChangeData: {
+              xmlTag: input.xmlTag,
+              beforeXml: input.beforeXml,
+            },
+          },
+          status: "open",
+        },
+      },
+    },
+  };
+}
+
+function createRuntimeSuggestionChangeId(
+  existing: EditorSessionState["canonicalDocument"]["review"]["revisions"],
+  timestamp: string,
+): string {
+  const base = `change-${timestamp.replace(/[^0-9]/gu, "")}`;
+  let counter = Object.keys(existing).length + 1;
+  let candidate = `${base}-p${counter}`;
+  while (existing[candidate]) {
+    counter += 1;
+    candidate = `${base}-p${counter}`;
+  }
+  return candidate;
+}
+
+function findSingleSelectedTextSegment(
+  snapshot: Pick<RuntimeRenderSnapshot, "surface" | "selection">,
+): Extract<SurfaceInlineSegment, { kind: "text" }> | null {
+  if (!snapshot.surface || snapshot.selection.activeRange.kind !== "range" || snapshot.selection.isCollapsed) {
+    return null;
+  }
+  const selectionFrom = Math.min(snapshot.selection.anchor, snapshot.selection.head);
+  const selectionTo = Math.max(snapshot.selection.anchor, snapshot.selection.head);
+  const segments = collectSelectedTextSegments(snapshot.surface.blocks, selectionFrom, selectionTo);
+  if (segments.length !== 1) {
+    return null;
+  }
+  const [segment] = segments;
+  if (!segment || segment.from !== selectionFrom || segment.to !== selectionTo) {
+    return null;
+  }
+  return segment;
+}
+
+function collectSelectedTextSegments(
+  blocks: readonly SurfaceBlockSnapshot[],
+  selectionFrom: number,
+  selectionTo: number,
+  output: Array<Extract<SurfaceInlineSegment, { kind: "text" }>> = [],
+): Array<Extract<SurfaceInlineSegment, { kind: "text" }>> {
+  for (const block of blocks) {
+    if (block.kind === "paragraph") {
+      for (const segment of block.segments) {
+        if (
+          segment.kind === "text" &&
+          rangesOverlap(selectionFrom, selectionTo, segment.from, segment.to)
+        ) {
+          output.push(segment);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectSelectedTextSegments(cell.content, selectionFrom, selectionTo, output);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      collectSelectedTextSegments(block.children, selectionFrom, selectionTo, output);
+    }
+  }
+  return output;
+}
+
+function buildRunPropertyBeforeXml(
+  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
+): string {
+  const parts: string[] = [];
+  const marks = new Set(segment.marks ?? []);
+  if (marks.has("bold")) parts.push("<w:b/>");
+  if (marks.has("italic")) parts.push("<w:i/>");
+  if (marks.has("underline")) parts.push("<w:u w:val=\"single\"/>");
+  if (marks.has("strikethrough")) parts.push("<w:strike/>");
+  if (marks.has("superscript")) parts.push("<w:vertAlign w:val=\"superscript\"/>");
+  if (marks.has("subscript")) parts.push("<w:vertAlign w:val=\"subscript\"/>");
+  if (segment.markAttrs?.fontFamily) {
+    parts.push(`<w:rFonts w:ascii="${escapeAttributeXml(segment.markAttrs.fontFamily)}" w:hAnsi="${escapeAttributeXml(segment.markAttrs.fontFamily)}"/>`);
+  }
+  if (segment.markAttrs?.fontSize !== undefined) {
+    parts.push(`<w:sz w:val="${segment.markAttrs.fontSize}"/>`);
+  }
+  if (segment.markAttrs?.textColor) {
+    parts.push(`<w:color w:val="${escapeAttributeXml(segment.markAttrs.textColor)}"/>`);
+  }
+  if (segment.markAttrs?.backgroundColor) {
+    parts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttributeXml(segment.markAttrs.backgroundColor)}"/>`);
+  }
+  return `<w:rPr>${parts.join("")}</w:rPr>`;
+}
+
+function buildParagraphPropertyBeforeXml(
+  paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): string {
+  const parts: string[] = [];
+  if (paragraph.styleId) {
+    parts.push(`<w:pStyle w:val="${escapeAttributeXml(paragraph.styleId)}"/>`);
+  }
+  if (paragraph.numbering) {
+    parts.push(
+      `<w:numPr><w:ilvl w:val="${paragraph.numbering.level}"/><w:numId w:val="${escapeAttributeXml(
+        paragraph.numbering.numberingInstanceId.replace(/^num:/u, ""),
+      )}"/></w:numPr>`,
+    );
+  }
+  if (paragraph.alignment) {
+    parts.push(`<w:jc w:val="${escapeAttributeXml(paragraph.alignment)}"/>`);
+  }
+  if (paragraph.indentation) {
+    const attrs: string[] = [];
+    if (paragraph.indentation.left !== undefined) attrs.push(`w:left="${paragraph.indentation.left}"`);
+    if (paragraph.indentation.right !== undefined) attrs.push(`w:right="${paragraph.indentation.right}"`);
+    if (paragraph.indentation.firstLine !== undefined) attrs.push(`w:firstLine="${paragraph.indentation.firstLine}"`);
+    if (paragraph.indentation.hanging !== undefined) attrs.push(`w:hanging="${paragraph.indentation.hanging}"`);
+    if (attrs.length > 0) {
+      parts.push(`<w:ind ${attrs.join(" ")}/>`);
+    }
+  }
+  return `<w:pPr>${parts.join("")}</w:pPr>`;
+}
+
+function escapeAttributeXml(value: string): string {
+  return value
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;");
+}
+
 function isSelectionSuggesting(runtime: WordReviewEditorRuntime): boolean {
   return runtime.getInteractionGuardSnapshot().effectiveMode === "suggest";
 }
@@ -3262,6 +4115,8 @@ function deriveEditorViewMode(
 }
 
 function resolveWordReviewEditorChromeVisibility(
+  chromePreset: WordReviewEditorChromePreset,
+  chromeOptions: Partial<WordReviewEditorChromeOptions> | undefined,
   chromeVisibility: WordReviewEditorProps["chromeVisibility"],
   showReviewPanel: boolean,
 ): Partial<WordReviewEditorChromeVisibility> {
@@ -3269,10 +4124,14 @@ function resolveWordReviewEditorChromeVisibility(
     showReviewPanel
       ? {}
       : { reviewRail: false } satisfies Partial<WordReviewEditorChromeVisibility>;
-  return {
-    ...legacyVisibility,
-    ...chromeVisibility,
-  };
+  return resolveChromeVisibilityForPreset({
+    chromePreset,
+    chromeOptions,
+    chromeVisibility: {
+      ...legacyVisibility,
+      ...chromeVisibility,
+    },
+  });
 }
 
 function toRuntimeSelectionSnapshot(selection: PublicSelectionSnapshot) {
@@ -3508,6 +4367,7 @@ function createSelectionToolbarSelectionKey(
   selection: RuntimeRenderSnapshot["selection"],
   activeStory: EditorStoryTarget,
   activeRevisionId?: string,
+  activeCommentId?: string | null,
 ): string | null {
   if (activeRevisionId) {
     return JSON.stringify({
@@ -3515,7 +4375,19 @@ function createSelectionToolbarSelectionKey(
       revisionId: activeRevisionId,
     });
   }
-  if (selection.isCollapsed || selection.activeRange.kind !== "range") {
+  if (activeCommentId && selection.isCollapsed) {
+    return JSON.stringify({
+      story: activeStory,
+      commentId: activeCommentId,
+    });
+  }
+  if (selection.activeRange.kind !== "range") {
+    if (selection.activeRange.kind === "node") {
+      return JSON.stringify({
+        story: activeStory,
+        nodeAt: selection.activeRange.at,
+      });
+    }
     return null;
   }
 
@@ -3523,9 +4395,38 @@ function createSelectionToolbarSelectionKey(
     story: activeStory,
     from: selection.activeRange.from,
     to: selection.activeRange.to,
+    collapsed: selection.isCollapsed,
   });
 }
 
+function isActiveRevisionStillFocused(
+  activeRevisionId: string,
+  suggestionsSnapshot: SuggestionsSnapshot | null,
+  selection: RuntimeRenderSnapshot["selection"],
+  activeStory: EditorStoryTarget,
+): boolean {
+  const suggestion = suggestionsSnapshot?.suggestions.find((entry) =>
+    entry.status === "active" &&
+    entry.actionability === "actionable" &&
+    entry.anchor.kind === "range" &&
+    storyTargetsEqual(entry.storyTarget, activeStory) &&
+    entry.changeIds.includes(activeRevisionId)
+  );
+  if (!suggestion || suggestion.anchor.kind !== "range") {
+    return false;
+  }
+  if (selection.activeRange.kind !== "range") {
+    return false;
+  }
+  if (selection.isCollapsed) {
+    const point = selection.activeRange.from;
+    return point >= suggestion.anchor.from && point <= suggestion.anchor.to;
+  }
+  const selectionFrom = Math.min(selection.activeRange.from, selection.activeRange.to);
+  const selectionTo = Math.max(selection.activeRange.from, selection.activeRange.to);
+  return selectionFrom < suggestion.anchor.to && suggestion.anchor.from < selectionTo;
+}
+
 function buildSelectionToolbarModel(args: {
   snapshot: RuntimeRenderSnapshot;
   viewState: ReturnType<WordReviewEditorRuntime["getViewState"]>;
@@ -3596,6 +4497,7 @@ function buildSelectionToolbarModel(args: {
     (canAddComment ? undefined : addCommentDisabledReason);
 
   return {
+    kind: "formatting-inline",
     previewText,
     badges,
     canToggleFormatting,
@@ -3609,6 +4511,7 @@ function buildSelectionToolbarModel(args: {
 
 function buildSuggestionCardModel(args: {
   snapshot: RuntimeRenderSnapshot;
+  suggestionsSnapshot: SuggestionsSnapshot;
   viewState: ReturnType<WordReviewEditorRuntime["getViewState"]>;
   capabilities: ReturnType<typeof deriveCapabilities>;
   workflowScopeSnapshot?: WorkflowScopeSnapshot | null;
@@ -3619,6 +4522,7 @@ function buildSuggestionCardModel(args: {
 }): SuggestionCardModel | null {
   const {
     snapshot,
+    suggestionsSnapshot,
     viewState,
     capabilities,
     workflowScopeSnapshot,
@@ -3646,32 +4550,32 @@ function buildSuggestionCardModel(args: {
   const selectionTo = activeRange
     ? Math.max(activeRange.from, activeRange.to)
     : null;
-  const candidateRevisions = snapshot.trackedChanges.revisions.filter((revision) =>
-    storyTargetsEqual(revision.storyTarget ?? { kind: "main" }, viewState.activeStory) &&
-    revision.status === "active" &&
-    revision.actionability === "actionable" &&
-    revision.anchor.kind === "range" &&
+  const candidateSuggestions = suggestionsSnapshot.suggestions.filter((suggestion) =>
+    storyTargetsEqual(suggestion.storyTarget, viewState.activeStory) &&
+    suggestion.status === "active" &&
+    suggestion.actionability === "actionable" &&
+    suggestion.anchor.kind === "range" &&
     (
-      activeRevisionId === revision.revisionId ||
+      (activeRevisionId !== undefined && suggestion.changeIds.includes(activeRevisionId)) ||
       (
         selectionFrom !== null &&
         selectionTo !== null &&
         rangesOverlap(
           selectionFrom,
           selectionTo,
-          revision.anchor.from,
-          revision.anchor.to,
+          suggestion.anchor.from,
+          suggestion.anchor.to,
         )
       )
     )
   );
-  const focusedRevision = (
+  const focusedSuggestion = (
     activeRevisionId
-      ? candidateRevisions.find((revision) => revision.revisionId === activeRevisionId)
+      ? candidateSuggestions.find((suggestion) => suggestion.changeIds.includes(activeRevisionId))
       : null
-  ) ?? candidateRevisions[0];
+  ) ?? candidateSuggestions[0];
 
-  if (!focusedRevision || focusedRevision.revisionId === suppressedSuggestionRevisionId) {
+  if (!focusedSuggestion || focusedSuggestion.suggestionId === suppressedSuggestionRevisionId) {
     return null;
   }
 
@@ -3699,17 +4603,18 @@ function buildSuggestionCardModel(args: {
     (canAddComment ? undefined : addCommentDisabledReason);
 
   return {
-    revisionId: focusedRevision.revisionId,
-    kindLabel: getSuggestionKindLabel(focusedRevision.kind),
+    kind: "suggestion-review",
+    suggestionId: focusedSuggestion.suggestionId,
+    changeIds: focusedSuggestion.changeIds,
+    kindLabel: getSuggestionKindLabel(focusedSuggestion.kind),
     previewText:
-      focusedRevision.excerpt ??
-      focusedRevision.detail ??
-      focusedRevision.label ??
+      focusedSuggestion.excerpt ??
+      focusedSuggestion.detail ??
       "Suggested change",
     badges,
-    canAccept: canReviewSuggestion && capabilities.canAcceptChange && focusedRevision.canAccept,
-    canReject: canReviewSuggestion && capabilities.canRejectChange && focusedRevision.canReject,
-    canEditSuggestion: canReviewSuggestion,
+    canAccept: canReviewSuggestion && capabilities.canAcceptChange && focusedSuggestion.canAccept,
+    canReject: canReviewSuggestion && capabilities.canRejectChange && focusedSuggestion.canReject,
+    canEditSuggestion: canReviewSuggestion && focusedSuggestion.editable,
     canAddComment,
     ...(disabledReason ? { disabledReason } : {}),
   };
@@ -3897,18 +4802,28 @@ function rangesOverlap(
   return leftFrom < rightTo && rightFrom < leftTo;
 }
 
-function getSuggestionKindLabel(kind: TrackedChangeEntrySnapshot["kind"]): string {
+function getSuggestionKindLabel(
+  kind: TrackedChangeEntrySnapshot["kind"] | SuggestionEntrySnapshot["kind"],
+): string {
   switch (kind) {
     case "insertion":
       return "Suggested insertion";
     case "deletion":
       return "Suggested deletion";
+    case "replacement":
+      return "Suggested replacement";
     case "formatting":
+    case "formatting-change":
       return "Suggested formatting change";
     case "property-change":
+    case "paragraph-property-change":
       return "Suggested property change";
     case "move":
       return "Suggested move";
+    case "structural-change":
+      return "Suggested structural change";
+    case "object-change":
+      return "Suggested object change";
   }
 }
 
@@ -4084,3 +4999,270 @@ function bytesToBase64(bytes: Uint8Array): string {
   }
   return btoa(binary);
 }
+
+function deriveReviewQueueSnapshot(input: {
+  sections: Array<{
+    sectionIndex: number;
+    pageRange: { start: number; end: number };
+    anchor: EditorAnchorProjection;
+  }>;
+  comments: RuntimeRenderSnapshot["comments"]["threads"];
+  trackedChanges: RuntimeRenderSnapshot["trackedChanges"]["revisions"];
+  hostAnnotations: HostAnnotationItem[];
+  activeItemId?: string | null;
+}): ReviewQueueSnapshot {
+  const items: ReviewQueueItem[] = [
+    ...input.comments
+      .filter((thread) => thread.status !== "detached")
+      .map((thread) => {
+        const section = findSectionForAnchor(input.sections, thread.anchor);
+        const status: ReviewQueueItem["status"] =
+          thread.status === "resolved" ? "resolved" : "open";
+        return {
+          itemId: `comment:${thread.commentId}`,
+          kind: "comment" as const,
+          label: thread.excerpt || thread.anchorLabel || "Comment",
+          anchor: thread.anchor,
+          actionable: thread.status === "open",
+          status,
+          sectionIndex: section?.sectionIndex,
+        };
+      }),
+    ...input.trackedChanges
+      .filter((revision) => revision.status !== "detached")
+      .map((revision) => {
+        const section = findSectionForAnchor(input.sections, revision.anchor);
+        const status: ReviewQueueItem["status"] =
+          revision.status === "active" ? "open" : "resolved";
+        return {
+          itemId: `change:${revision.revisionId}`,
+          kind: "change" as const,
+          label: revision.label,
+          anchor: revision.anchor,
+          storyTarget: revision.storyTarget,
+          actionable:
+            revision.status === "active" &&
+            revision.actionability === "actionable" &&
+            (revision.canAccept || revision.canReject),
+          status,
+          sectionIndex: section?.sectionIndex,
+        };
+      }),
+    ...input.hostAnnotations.filter(isSectionReviewAnnotation).map((annotation) => {
+      const section = findSectionForAnchor(input.sections, annotation.anchor);
+      return {
+        itemId: `section:${annotation.annotationId}`,
+        kind: "section_mark" as const,
+        label: annotation.label,
+        anchor: annotation.anchor,
+        storyTarget: annotation.storyTarget,
+        actionable: true,
+        status: "open" as const,
+        sectionIndex: section?.sectionIndex,
+      };
+    }),
+  ].sort(compareReviewQueueItems);
+
+  const activeIndex = items.length === 0
+    ? -1
+    : input.activeItemId
+      ? items.findIndex((item) => item.itemId === input.activeItemId)
+      : items.findIndex((item) => item.actionable);
+  const openCount = items.filter((item) => item.status === "open").length;
+
+  return {
+    totalCount: items.length,
+    openCount,
+    activeIndex: activeIndex >= 0 ? activeIndex : items.length === 0 ? -1 : 0,
+    items,
+  };
+}
+
+function navigateReviewQueue(
+  runtime: WordReviewEditorRuntime,
+  direction: "next" | "previous",
+): ReviewQueueItem | null {
+  const queue = deriveReviewQueueSnapshot({
+    sections: runtime.getSections(),
+    comments: runtime.getRenderSnapshot().comments.threads,
+    trackedChanges: runtime.getRenderSnapshot().trackedChanges.revisions,
+    hostAnnotations: runtime.getHostAnnotationSnapshot().annotations,
+  });
+  const nextItem = getAdjacentReviewQueueItem(queue, null, direction);
+  if (!nextItem) {
+    return null;
+  }
+  focusReviewQueueItem(runtime, nextItem);
+  return nextItem;
+}
+
+function getAdjacentReviewQueueItem(
+  queue: ReviewQueueSnapshot,
+  activeItemId: string | null,
+  direction: "next" | "previous",
+): ReviewQueueItem | null {
+  if (queue.items.length === 0) {
+    return null;
+  }
+  const currentIndex = activeItemId
+    ? queue.items.findIndex((item) => item.itemId === activeItemId)
+    : queue.activeIndex;
+  const safeIndex = currentIndex >= 0 ? currentIndex : 0;
+  const nextIndex =
+    direction === "next"
+      ? (safeIndex + 1) % queue.items.length
+      : (safeIndex - 1 + queue.items.length) % queue.items.length;
+  return queue.items[nextIndex] ?? queue.items[0] ?? null;
+}
+
+function focusReviewQueueItem(
+  runtime: WordReviewEditorRuntime,
+  item: ReviewQueueItem,
+): void {
+  if (item.kind === "comment") {
+    runtime.openComment(item.itemId.replace(/^comment:/u, ""));
+  }
+  if (item.kind === "change") {
+    const revisionId = item.itemId.replace(/^change:/u, "");
+    const revision = runtime.getRenderSnapshot().trackedChanges.revisions.find(
+      (entry) => entry.revisionId === revisionId,
+    );
+    if (revision?.storyTarget) {
+      runtime.openStory(revision.storyTarget);
+    }
+  }
+  applyRuntimeSelection(
+    runtime,
+    createSelectionFromAnchor(item.anchor, item.storyTarget),
+  );
+}
+
+function markSectionForReview(
+  runtime: WordReviewEditorRuntime,
+  input?: { sectionIndex?: number; label?: string },
+): string | null {
+  const targetIndex =
+    input?.sectionIndex ?? runtime.getDocumentNavigationSnapshot().activeSectionIndex;
+  const section = runtime.getSectionSnapshot({ sectionIndex: targetIndex });
+  if (!section) {
+    return null;
+  }
+  const annotationId = createReviewSectionMarkId(section.sectionIndex);
+  runtime.setHostAnnotationOverlay({
+    overlayVersion: "host-annotation-overlay/1",
+    annotations: [
+      ...runtime.getHostAnnotationSnapshot().annotations.filter(
+        (annotation) => annotation.annotationId !== annotationId,
+      ),
+      {
+        annotationId,
+        kind: "note",
+        label:
+          input?.label ??
+          section.primaryHeadingText ??
+          `Section ${section.sectionIndex + 1}`,
+        anchor: section.anchor,
+        provenance: "host",
+        detail: "Marked for review",
+      },
+    ],
+  });
+  return annotationId;
+}
+
+function clearSectionReviewMark(
+  runtime: WordReviewEditorRuntime,
+  annotationId: string,
+): void {
+  const nextAnnotations = runtime
+    .getHostAnnotationSnapshot()
+    .annotations.filter((annotation) => annotation.annotationId !== annotationId);
+  if (nextAnnotations.length === 0) {
+    runtime.clearHostAnnotationOverlay();
+    return;
+  }
+  runtime.setHostAnnotationOverlay({
+    overlayVersion: "host-annotation-overlay/1",
+    annotations: nextAnnotations,
+  });
+}
+
+function mergeHostAndReviewSectionAnnotations(
+  hostAnnotations: HostAnnotationItem[],
+  reviewSectionMarks: Array<{ annotationId: string; sectionIndex: number; label: string }>,
+  sections: Array<{
+    sectionIndex: number;
+    anchor: EditorAnchorProjection;
+  }>,
+): HostAnnotationItem[] {
+  const reviewAnnotations = reviewSectionMarks.flatMap((entry) => {
+    const section = sections.find((candidate) => candidate.sectionIndex === entry.sectionIndex);
+    if (!section) {
+      return [];
+    }
+    return [{
+      annotationId: entry.annotationId,
+      kind: "note" as const,
+      label: entry.label,
+      anchor: section.anchor,
+      provenance: "host" as const,
+      detail: "Marked for review",
+    }];
+  });
+  return [...hostAnnotations, ...reviewAnnotations];
+}
+
+function isSectionReviewAnnotation(annotation: HostAnnotationItem): boolean {
+  return annotation.kind === "note" && annotation.detail === "Marked for review";
+}
+
+function createReviewSectionMarkId(sectionIndex: number): string {
+  return `review-section:${sectionIndex}`;
+}
+
+function findSectionForAnchor(
+  sections: Array<{
+    sectionIndex: number;
+    pageRange: { start: number; end: number };
+    anchor: EditorAnchorProjection;
+  }>,
+  anchor: EditorAnchorProjection,
+) {
+  const anchorStart = getAnchorStart(anchor);
+  return sections.find((section) => {
+    const sectionStart = getAnchorStart(section.anchor);
+    const sectionEnd = getAnchorEnd(section.anchor);
+    return anchorStart >= sectionStart && anchorStart <= sectionEnd;
+  });
+}
+
+function compareReviewQueueItems(left: ReviewQueueItem, right: ReviewQueueItem): number {
+  const leftSection = left.sectionIndex ?? Number.MAX_SAFE_INTEGER;
+  const rightSection = right.sectionIndex ?? Number.MAX_SAFE_INTEGER;
+  if (leftSection !== rightSection) {
+    return leftSection - rightSection;
+  }
+  return getAnchorStart(left.anchor) - getAnchorStart(right.anchor);
+}
+
+function getAnchorStart(anchor: EditorAnchorProjection): number {
+  switch (anchor.kind) {
+    case "range":
+      return anchor.from;
+    case "node":
+      return anchor.at;
+    case "detached":
+      return anchor.lastKnownRange?.from ?? Number.MAX_SAFE_INTEGER;
+  }
+}
+
+function getAnchorEnd(anchor: EditorAnchorProjection): number {
+  switch (anchor.kind) {
+    case "range":
+      return anchor.to;
+    case "node":
+      return anchor.at;
+    case "detached":
+      return anchor.lastKnownRange?.to ?? Number.MAX_SAFE_INTEGER;
+  }
+}