@beyondwork/docx-react-component 1.0.35 → 1.0.37

package/src/runtime/layout/resolved-formatting-state.ts

@@ -0,0 +1,430 @@
+/**
+ * Centralized formatting resolution for the layout engine.
+ *
+ * Takes a surface block snapshot and resolves the effective formatting
+ * properties needed for measurement and page composition.  This includes:
+ *
+ * - Paragraph spacing (before, after, line height, line rule)
+ * - Indentation (left, right, firstLine, hanging)
+ * - Tab stops with numbering geometry override
+ * - Font size for line height calculation
+ * - Pagination properties (keepNext, keepLines, widowControl, pageBreakBefore)
+ * - Contextual spacing suppression
+ *
+ * The resolver produces a flat, inspectable structure so that the measurement
+ * engine never needs to reach back into multiple sources.
+ */
+
+import type {
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+import type {
+  ParagraphSpacing,
+} from "../../model/canonical-document.ts";
+
+/** Tab stop as it appears on the surface snapshot. */
+interface SurfaceTabStop {
+  pos: number;
+  val?: string;
+  leader?: string;
+}
+
+/** Normalized tab stop for layout computation. */
+export interface LayoutTabStop {
+  position: number;
+  align: string;
+  leader?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Font metric tables — common fonts used in CCEP/legal contracts
+// ---------------------------------------------------------------------------
+
+/**
+ * Average character width in twips per half-point of font size.
+ * These are empirical values from measuring common document fonts.
+ * Key insight: Word uses font metrics from the OS font table; we use
+ * bounded approximations that are close enough for page composition.
+ */
+const FONT_AVG_CHAR_WIDTH: Record<string, number> = {
+  // Proportional serif
+  "times new roman": 9.2,
+  "georgia": 10.0,
+  "garamond": 8.8,
+  "book antiqua": 9.6,
+  "palatino linotype": 9.8,
+  "cambria": 9.6,
+  // Proportional sans-serif
+  "arial": 10.4,
+  "calibri": 9.0,
+  "helvetica": 10.4,
+  "verdana": 12.0,
+  "tahoma": 10.6,
+  "segoe ui": 9.8,
+  "trebuchet ms": 10.2,
+  // Monospace
+  "courier new": 12.0,
+  "consolas": 11.0,
+  "lucida console": 12.0,
+};
+
+const DEFAULT_FONT_AVG_CHAR_WIDTH = 10.0; // reasonable fallback
+const DEFAULT_FONT_SIZE_HALF_POINTS = 24; // 12pt
+const DEFAULT_LINE_HEIGHT_FACTOR = 1.15; // Word default for Calibri body
+const TWIPS_PER_POINT = 20;
+
+// ---------------------------------------------------------------------------
+// Resolved types
+// ---------------------------------------------------------------------------
+
+export interface ResolvedParagraphFormatting {
+  /** Effective spacing before in twips. */
+  spacingBefore: number;
+  /** Effective spacing after in twips. */
+  spacingAfter: number;
+  /** Effective line height in twips. */
+  lineHeight: number;
+  /** Line rule governing how lineHeight is interpreted. */
+  lineRule: "auto" | "exact" | "atLeast";
+  /** Left indentation in twips. */
+  indentLeft: number;
+  /** Right indentation in twips. */
+  indentRight: number;
+  /** First-line indent in twips (positive = indent, negative = outdent). */
+  firstLineIndent: number;
+  /** Hanging indent in twips (mutually exclusive with firstLineIndent). */
+  hangingIndent: number;
+  /** Resolved font size in half-points for the dominant run. */
+  fontSizeHalfPoints: number;
+  /** Average character width in twips for the dominant font. */
+  averageCharWidthTwips: number;
+  /** Effective tab stops sorted by position. */
+  tabStops: LayoutTabStop[];
+  /** Keep with next paragraph. */
+  keepNext: boolean;
+  /** Keep all lines of this paragraph on the same page. */
+  keepLines: boolean;
+  /** Force page break before this paragraph. */
+  pageBreakBefore: boolean;
+  /** Widow/orphan control (default true in Word). */
+  widowControl: boolean;
+  /** Contextual spacing — suppress before/after when adjacent styles match. */
+  contextualSpacing: boolean;
+}
+
+export interface ResolvedTableRowFormatting {
+  /** Explicit row height in twips, 0 if auto. */
+  explicitHeight: number;
+  /** Height rule. */
+  heightRule: "auto" | "exact" | "atLeast";
+  /** Whether this row is a header row (repeats on page breaks). */
+  isHeader: boolean;
+  /** Whether this row can split across pages. */
+  cantSplit: boolean;
+}
+
+// ---------------------------------------------------------------------------
+// Paragraph formatting resolution
+// ---------------------------------------------------------------------------
+
+export function resolveBlockFormatting(
+  block: SurfaceBlockSnapshot,
+): ResolvedParagraphFormatting | null {
+  if (block.kind !== "paragraph") {
+    return null;
+  }
+
+  const spacing = resolveSpacing(block);
+  const indent = resolveIndentation(block);
+  const fontInfo = resolveDominantFont(block);
+  const lineHeight = resolveLineHeight(spacing, fontInfo.fontSizeHalfPoints);
+
+  return {
+    spacingBefore: spacing.before ?? 0,
+    spacingAfter: spacing.after ?? 0,
+    lineHeight: lineHeight.height,
+    lineRule: lineHeight.rule,
+    indentLeft: indent.left,
+    indentRight: indent.right,
+    firstLineIndent: indent.firstLine,
+    hangingIndent: indent.hanging,
+    fontSizeHalfPoints: fontInfo.fontSizeHalfPoints,
+    averageCharWidthTwips: fontInfo.avgCharWidth,
+    tabStops: resolveTabStops(block),
+    keepNext: Boolean(block.keepNext),
+    keepLines: Boolean(block.keepLines),
+    pageBreakBefore: Boolean(block.pageBreakBefore),
+    widowControl: block.widowControl !== false, // default true in Word
+    contextualSpacing: Boolean(block.contextualSpacing),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Spacing resolution
+// ---------------------------------------------------------------------------
+
+function resolveSpacing(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): ParagraphSpacing {
+  // Numbering geometry spacing overrides direct paragraph spacing
+  const numbering = block.resolvedNumbering?.geometry.spacing;
+  const direct = block.spacing;
+
+  const normalizeLineRule = (
+    rule: string | undefined,
+  ): ParagraphSpacing["lineRule"] => {
+    if (rule === "auto" || rule === "exact" || rule === "atLeast") return rule;
+    return undefined;
+  };
+
+  if (numbering) {
+    return {
+      before: numbering.before ?? direct?.before,
+      after: numbering.after ?? direct?.after,
+      line: numbering.line ?? direct?.line,
+      lineRule: normalizeLineRule(numbering.lineRule) ?? normalizeLineRule(direct?.lineRule),
+    };
+  }
+
+  if (direct) {
+    return {
+      before: direct.before,
+      after: direct.after,
+      line: direct.line,
+      lineRule: normalizeLineRule(direct.lineRule),
+    };
+  }
+
+  return {};
+}
+
+// ---------------------------------------------------------------------------
+// Indentation resolution
+// ---------------------------------------------------------------------------
+
+function resolveIndentation(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): { left: number; right: number; firstLine: number; hanging: number } {
+  // Numbering geometry provides precise text column placement for legal numbering
+  const numGeometry = block.resolvedNumbering?.geometry;
+
+  if (numGeometry?.textColumn) {
+    const tc = numGeometry.textColumn;
+    return {
+      left: tc.start,
+      right: tc.right ?? 0,
+      firstLine: tc.firstLine ?? 0,
+      hanging: tc.hanging ?? 0,
+    };
+  }
+
+  if (numGeometry?.indentation) {
+    const ni = numGeometry.indentation;
+    return {
+      left: ni.left ?? 0,
+      right: ni.right ?? 0,
+      firstLine: ni.firstLine ?? 0,
+      hanging: ni.hanging ?? 0,
+    };
+  }
+
+  const ind = block.indentation;
+  if (!ind) {
+    return { left: 0, right: 0, firstLine: 0, hanging: 0 };
+  }
+
+  return {
+    left: ind.left ?? 0,
+    right: ind.right ?? 0,
+    firstLine: ind.firstLine ?? 0,
+    hanging: ind.hanging ?? (typeof ind.firstLine === "number" && ind.firstLine < 0 ? Math.abs(ind.firstLine) : 0),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Font / character width resolution
+// ---------------------------------------------------------------------------
+
+function resolveDominantFont(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): { fontSizeHalfPoints: number; avgCharWidth: number; fontFamily: string | undefined } {
+  // Find the dominant font from the segments (most common or first text run)
+  let fontFamily: string | undefined;
+  let fontSizeHalfPoints: number | undefined;
+  let maxTextLength = 0;
+
+  for (const segment of block.segments) {
+    if (segment.kind !== "text") continue;
+    const segFontFamily = segment.markAttrs?.fontFamily;
+    const segFontSize = segment.markAttrs?.fontSize;
+    const textLength = segment.text.length;
+
+    if (textLength > maxTextLength) {
+      maxTextLength = textLength;
+      if (typeof segFontFamily === "string") {
+        fontFamily = segFontFamily;
+      }
+      if (typeof segFontSize === "number") {
+        fontSizeHalfPoints = segFontSize;
+      }
+    }
+  }
+
+  const effectiveSize = fontSizeHalfPoints ?? DEFAULT_FONT_SIZE_HALF_POINTS;
+  const normalizedFamily = fontFamily?.toLowerCase();
+  const charWidthFactor = normalizedFamily !== undefined
+    ? (FONT_AVG_CHAR_WIDTH[normalizedFamily] ?? DEFAULT_FONT_AVG_CHAR_WIDTH)
+    : DEFAULT_FONT_AVG_CHAR_WIDTH;
+
+  // Average char width in twips = factor * (fontSize in half-points)
+  const avgCharWidth = Math.max(96, Math.round(charWidthFactor * effectiveSize));
+
+  return { fontSizeHalfPoints: effectiveSize, avgCharWidth, fontFamily };
+}
+
+// ---------------------------------------------------------------------------
+// Line height resolution
+// ---------------------------------------------------------------------------
+
+function resolveLineHeight(
+  spacing: ParagraphSpacing,
+  fontSizeHalfPoints: number,
+): { height: number; rule: "auto" | "exact" | "atLeast" } {
+  const lineRule = spacing.lineRule ?? "auto";
+
+  if (lineRule === "exact" && typeof spacing.line === "number" && spacing.line > 0) {
+    return { height: spacing.line, rule: "exact" };
+  }
+
+  if (lineRule === "atLeast" && typeof spacing.line === "number" && spacing.line > 0) {
+    // atLeast: use the larger of the specified height or the auto-calculated height
+    const autoHeight = calculateAutoLineHeight(fontSizeHalfPoints);
+    return { height: Math.max(spacing.line, autoHeight), rule: "atLeast" };
+  }
+
+  // Auto: line is in 240ths of a line (240 = single space, 480 = double)
+  if (typeof spacing.line === "number" && spacing.line > 0) {
+    // Convert from 240ths: line/240 * fontSize * 20 (twips per pt)
+    const fontSizePoints = fontSizeHalfPoints / 2;
+    const lineSpacingFactor = spacing.line / 240;
+    const height = Math.round(fontSizePoints * TWIPS_PER_POINT * lineSpacingFactor * DEFAULT_LINE_HEIGHT_FACTOR);
+    return { height: Math.max(height, 200), rule: "auto" };
+  }
+
+  // Default: single space at current font size
+  return { height: calculateAutoLineHeight(fontSizeHalfPoints), rule: "auto" };
+}
+
+function calculateAutoLineHeight(fontSizeHalfPoints: number): number {
+  const fontSizePoints = fontSizeHalfPoints / 2;
+  return Math.max(200, Math.round(fontSizePoints * TWIPS_PER_POINT * DEFAULT_LINE_HEIGHT_FACTOR));
+}
+
+// ---------------------------------------------------------------------------
+// Tab stop resolution
+// ---------------------------------------------------------------------------
+
+function resolveTabStops(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): LayoutTabStop[] {
+  // Surface tab stops use { pos, val, leader } format
+  const surfaceTabs: SurfaceTabStop[] | undefined = block.tabStops;
+  // Numbering geometry tab stops are on the geometry, not the snapshot root
+  const numSurfaceTabs: SurfaceTabStop[] | undefined = block.resolvedNumbering?.geometry.tabStops;
+
+  const normalize = (tab: SurfaceTabStop): LayoutTabStop => ({
+    position: tab.pos,
+    align: tab.val ?? "left",
+    leader: tab.leader,
+  });
+
+  if (numSurfaceTabs && numSurfaceTabs.length > 0 && surfaceTabs && surfaceTabs.length > 0) {
+    const numPositions = new Set(numSurfaceTabs.map((t) => t.pos));
+    const merged = [
+      ...numSurfaceTabs.map(normalize),
+      ...surfaceTabs.filter((t) => !numPositions.has(t.pos)).map(normalize),
+    ];
+    return merged.sort((a, b) => a.position - b.position);
+  }
+
+  if (numSurfaceTabs && numSurfaceTabs.length > 0) {
+    return numSurfaceTabs.map(normalize).sort((a, b) => a.position - b.position);
+  }
+
+  if (surfaceTabs && surfaceTabs.length > 0) {
+    return surfaceTabs.map(normalize).sort((a, b) => a.position - b.position);
+  }
+
+  return [];
+}
+
+// ---------------------------------------------------------------------------
+// Precise measurement helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Calculate the usable text width for a paragraph line, accounting for
+ * indentation and column width.
+ */
+export function resolveTextWidth(
+  formatting: ResolvedParagraphFormatting,
+  columnWidth: number,
+  isFirstLine: boolean,
+): number {
+  const baseWidth = columnWidth - formatting.indentLeft - formatting.indentRight;
+
+  if (isFirstLine) {
+    if (formatting.hangingIndent > 0) {
+      // Hanging indent: first line starts further left (wider available)
+      return Math.max(1, baseWidth + formatting.hangingIndent);
+    }
+    if (formatting.firstLineIndent !== 0) {
+      return Math.max(1, baseWidth - formatting.firstLineIndent);
+    }
+  }
+
+  return Math.max(1, baseWidth);
+}
+
+/**
+ * Calculate characters per line for a given text width and font.
+ */
+export function resolveCharsPerLine(
+  textWidth: number,
+  avgCharWidth: number,
+): number {
+  return Math.max(1, Math.floor(textWidth / avgCharWidth));
+}
+
+/**
+ * Calculate the total height of a paragraph from its resolved formatting.
+ */
+export function calculateParagraphHeight(
+  formatting: ResolvedParagraphFormatting,
+  lineCount: number,
+): number {
+  const contentHeight = formatting.lineHeight * lineCount;
+  return Math.max(240, contentHeight + formatting.spacingBefore + formatting.spacingAfter);
+}
+
+/**
+ * Estimate the number of prefix characters added by numbering.
+ */
+export function resolveNumberingPrefixLength(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+): number {
+  if (block.resolvedNumbering?.geometry.textColumn) {
+    // When text column is resolved, the numbering marker is placed in its
+    // own lane — it doesn't consume characters from the text line.
+    return 0;
+  }
+
+  const prefix = block.numberingPrefix ?? "";
+  const suffix =
+    block.numberingSuffix === "space"
+      ? 1
+      : block.numberingSuffix === "tab"
+        ? 4
+        : 0;
+  return prefix.length + suffix;
+}

package/src/runtime/scope-tag-registry.ts

@@ -0,0 +1,95 @@
+/**
+ * Scope tag registry — describes how each annotation family responds to
+ * ordinary text edits. The predicted-text lane uses this registry to:
+ *   - classify an `adjusted` ack (comment anchor extended, revision trimmed)
+ *   - decide whether to bail on prediction when an unknown tag is in range
+ *   - drive decoration redraws after a reconciled commit
+ *
+ * Known annotation families ship as `DEFAULT_REGISTRY_ENTRIES`. Host
+ * integrations can register additional families; unknown families default
+ * to "bailIfCrossed" so the lane falls back to the canonical round-trip.
+ */
+
+export interface ScopeTagBehavior {
+  /** Inserting text at the left edge extends the tag leftward. */
+  extendOnInsertLeft: boolean;
+  /** Inserting text at the right edge extends the tag rightward. */
+  extendOnInsertRight: boolean;
+  /** Deleting a tag edge trims the tag boundary. */
+  trimOnDelete: boolean;
+  /** Any edit that crosses this tag must abort prediction and rebuild canonically. */
+  bailIfCrossed: boolean;
+}
+
+export const DEFAULT_UNKNOWN_BEHAVIOR: ScopeTagBehavior = {
+  extendOnInsertLeft: false,
+  extendOnInsertRight: false,
+  trimOnDelete: false,
+  bailIfCrossed: true,
+};
+
+export const DEFAULT_REGISTRY_ENTRIES: Readonly<Record<string, ScopeTagBehavior>> = {
+  comment: {
+    extendOnInsertLeft: true,
+    extendOnInsertRight: true,
+    trimOnDelete: true,
+    bailIfCrossed: false,
+  },
+  revision: {
+    extendOnInsertLeft: true,
+    extendOnInsertRight: true,
+    trimOnDelete: true,
+    bailIfCrossed: false,
+  },
+  field: {
+    extendOnInsertLeft: false,
+    extendOnInsertRight: false,
+    trimOnDelete: false,
+    bailIfCrossed: true,
+  },
+  bookmark: {
+    extendOnInsertLeft: true,
+    extendOnInsertRight: true,
+    trimOnDelete: true,
+    bailIfCrossed: false,
+  },
+  sdt: {
+    extendOnInsertLeft: false,
+    extendOnInsertRight: false,
+    trimOnDelete: false,
+    bailIfCrossed: true,
+  },
+  opaque: {
+    extendOnInsertLeft: false,
+    extendOnInsertRight: false,
+    trimOnDelete: false,
+    bailIfCrossed: true,
+  },
+};
+
+export interface ScopeTagRegistry {
+  get(tagType: string): ScopeTagBehavior;
+  register(tagType: string, behavior: ScopeTagBehavior): void;
+  has(tagType: string): boolean;
+  list(): ReadonlyArray<readonly [string, ScopeTagBehavior]>;
+}
+
+export function createScopeTagRegistry(): ScopeTagRegistry {
+  const entries = new Map<string, ScopeTagBehavior>(
+    Object.entries(DEFAULT_REGISTRY_ENTRIES),
+  );
+  return {
+    get(tagType) {
+      return entries.get(tagType) ?? DEFAULT_UNKNOWN_BEHAVIOR;
+    },
+    register(tagType, behavior) {
+      entries.set(tagType, behavior);
+    },
+    has(tagType) {
+      return entries.has(tagType);
+    },
+    list() {
+      return Array.from(entries.entries());
+    },
+  };
+}

package/src/runtime/session-capabilities.ts

@@ -23,7 +23,7 @@ export interface SessionCapabilities {
 
   // ── Document mode ──
   /** Runtime document mode — editing authority, distinct from view/workspace mode. */
-  documentMode: "editing" | "suggesting" | "viewing";
+  documentMode: "editing" | "suggesting" | "viewing" | "commenting";
 
   // ── Command capabilities ──
   canUndo: boolean;
@@ -101,12 +101,15 @@ export function deriveCapabilities(
       ? "read-only-diagnostics"
       : reviewMode;
 
-  // Command capabilities — document mode "viewing" disables editing
-  const canEdit = isReady && !isReadOnly && !hasFatalError && documentMode !== "viewing";
+  // Command capabilities — "viewing" and "commenting" modes both disable editing;
+  // "commenting" additionally keeps comment creation enabled.
+  const canEdit = isReady && !isReadOnly && !hasFatalError
+    && documentMode !== "viewing" && documentMode !== "commenting";
   const canUndo = snapshot.commandState.canUndo && canEdit;
   const canRedo = snapshot.commandState.canRedo && canEdit;
+  const canComment = isReady && !hasFatalError && documentMode !== "viewing";
   const canAddComment =
-    canEdit &&
+    canComment &&
     activeStory.kind === "main" &&
     !snapshot.selection.isCollapsed &&
     Boolean(snapshot.surface) &&

package/src/runtime/surface-projection.ts

@@ -553,6 +553,7 @@ function createParagraphBlock(
     ...(paragraph.keepNext ? { keepNext: true } : {}),
     ...(paragraph.keepLines ? { keepLines: true } : {}),
     ...(paragraph.pageBreakBefore ? { pageBreakBefore: true } : {}),
+    ...(paragraph.widowControl !== undefined ? { widowControl: paragraph.widowControl } : {}),
     ...(paragraph.outlineLevel !== undefined ? { outlineLevel: paragraph.outlineLevel } : {}),
     ...(paragraph.bidi ? { bidi: true } : {}),
     ...(paragraph.suppressLineNumbers ? { suppressLineNumbers: true } : {}),

package/src/runtime/text-ack-range.ts

@@ -0,0 +1,49 @@
+/**
+ * Computes the post-edit range that the runtime's text-command ack reports
+ * as `adjustedRange`. The semantics: the union of all step post-edit ranges
+ * (where each step covers `[step.from, step.from + step.insertSize]` in the
+ * new document). When the transaction has no steps (e.g., a non-main-story
+ * `document.replace` that uses `createEmptyMapping()`), fall back to the
+ * normalized prior selection range so consumers still receive a meaningful
+ * pointer.
+ *
+ * Note: only `step.from` and `step.insertSize` are considered; `step.to`
+ * (the pre-edit end of the replaced range) is intentionally ignored. A pure
+ * delete (`insertSize === 0`) therefore yields a zero-width range at the
+ * post-delete cursor position, not the pre-edit affected span. If a consumer
+ * needs the source span of a delete, derive it from `step.to` directly.
+ */
+export interface PriorSelectionRange {
+  from: number;
+  to: number;
+}
+
+export interface TextAckStepShape {
+  from: number;
+  insertSize: number;
+}
+
+export interface AdjustedRuntimeRange {
+  fromRuntime: number;
+  toRuntime: number;
+}
+
+export function computeAdjustedRange(
+  priorSelection: PriorSelectionRange,
+  steps: readonly TextAckStepShape[],
+): AdjustedRuntimeRange {
+  if (steps.length === 0) {
+    return {
+      fromRuntime: Math.min(priorSelection.from, priorSelection.to),
+      toRuntime: Math.max(priorSelection.from, priorSelection.to),
+    };
+  }
+  let from = Infinity;
+  let to = -Infinity;
+  for (const step of steps) {
+    if (step.from < from) from = step.from;
+    const stepEnd = step.from + step.insertSize;
+    if (stepEnd > to) to = stepEnd;
+  }
+  return { fromRuntime: from, toRuntime: to };
+}

package/src/ui/WordReviewEditor.tsx

@@ -165,6 +165,7 @@ import {
   useRuntimeValue,
 } from "./runtime-snapshot-selectors.ts";
 import type { MarkupDisplay } from "./headless/comment-decoration-model";
+import { resolveScopedChromePolicy } from "./headless/scoped-chrome-policy";
 import type {
   SelectionToolbarAnchor,
   SelectionToolbarModel,
@@ -577,6 +578,7 @@ export function __createWordReviewEditorRefBridge(
     getRuntimeContextAnalytics: (query) => {
       return clonePublicValue(runtime.getRuntimeContextAnalytics(query));
     },
+    layout: runtime.layout,
     goToNextReviewItem: () => {
       return clonePublicValue(navigateReviewQueue(runtime, "next"));
     },
@@ -1391,6 +1393,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         getRuntimeContextAnalytics: (query) => {
           return clonePublicValue(activeRuntime.getRuntimeContextAnalytics(query));
         },
+        layout: activeRuntime.layout,
         goToNextReviewItem: () => {
           return clonePublicValue(navigateMountedReviewQueue("next"));
         },
@@ -1670,6 +1673,14 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       snapshot.comments.activeCommentId
         ? snapshot.comments.threads.find((thread) => thread.commentId === snapshot.comments.activeCommentId)
         : undefined;
+    const scopedChromePolicy = resolveScopedChromePolicy({
+      preset: effectiveChromePreset,
+      compactMode: false,
+      capabilities,
+      interactionGuardSnapshot,
+      workflowScopeSnapshot,
+      activeListContext: viewState.activeListContext,
+    });
     const selectionToolbar = buildSelectionToolbarModel({
       snapshot,
       viewState,
@@ -1736,6 +1747,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       preferListStructureContext: viewState.workspaceMode === "page",
       addCommentDisabledReason,
       suppressedSuggestionRevisionId,
+      scopedChromePolicy,
     });
     const selectionToolbarSelectionKey = useMemo(
       () =>
@@ -2241,6 +2253,9 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         workflowMetadata={workflowMarkupSnapshot?.metadata}
         onSelectionToolbarAnchorChange={handleSelectionToolbarAnchorChange}
         {...editorCallbacks}
+        dispatchRuntimeCommand={(command) =>
+          activeRuntime.applyActiveStoryTextCommand(command as never)
+        }
         onCommentActivated={(commentId) => {
           activeRuntime.openComment(commentId);
           setActiveRailTab("comments");