@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/runtime/document-runtime.ts

@@ -17,8 +17,13 @@ import type {
   CommentSidebarSnapshot,
   CommentSidebarThreadSnapshot,
   CompatibilityReport,
+  DocumentChunkSnapshot,
+  DocumentLocationSnapshot,
   DocumentMode,
   DocumentNavigationSnapshot,
+  DocumentOutlineSnapshot,
+  DocumentSectionSnapshot,
+  DocumentTextToken,
   EditorSessionState,
   EditorAnchorProjection,
   EditorError,
@@ -36,8 +41,19 @@ import type {
   PageLayoutSnapshot,
   PersistedEditorSnapshot,
   ProtectionSnapshot,
+  RestorePointSnapshot,
+  RestoreResult,
+  ReviewWorkSnapshot,
+  RuntimeContextAnalyticsQuery,
+  RuntimeContextAnalyticsSnapshot,
   RuntimeRenderSnapshot,
   SelectionSnapshot,
+  SnapshotRefreshHints,
+  SuggestionsSnapshot,
+  SurfaceBlockSnapshot,
+  SurfaceInlineSegment,
+  StoryTextStreamSnapshot,
+  TocSnapshot,
   StyleCatalogSnapshot,
   TocRefreshOptions,
   TocRefreshResult,
@@ -49,6 +65,9 @@ import type {
   WorkflowCandidateRange,
   WorkflowCandidateRangeOptions,
   WorkflowBlockedCommandReason,
+  WorkflowMetadataDefinition,
+  WorkflowMetadataEntry,
+  WorkflowMetadataSnapshot,
   WorkflowMarkupSnapshot,
   WorkflowOverlay,
   WorkflowScopeSnapshot,
@@ -82,6 +101,7 @@ import { buildBookmarkNameMap } from "../legal/bookmarks.ts";
 import {
   describeOpaqueFragment,
   findOpaqueFragmentsIntersectingRange,
+  isBlockedImportFeatureKey,
 } from "../preservation/store.ts";
 import { createCommentSidebarProjection } from "../review/store/comment-store.ts";
 import { createCommentStoreFromRuntimeComments } from "../review/store/runtime-comment-store.ts";
@@ -89,6 +109,7 @@ import {
   createRevisionSidebarProjection,
   type RevisionStore,
 } from "../review/store/revision-store.ts";
+import { createSuggestionsSnapshot } from "./suggestions-snapshot.ts";
 import { buildCompatibilityReport } from "../validation/compatibility-engine.ts";
 import { mergeCompatibilityReports } from "../validation/compatibility-report.ts";
 import { createEditorSurfaceSnapshot } from "./surface-projection.ts";
@@ -100,6 +121,29 @@ import {
   createDocumentNavigationSnapshot,
   findPageForOffset,
 } from "./document-navigation.ts";
+import {
+  createDocumentOutlineSnapshot,
+  createDocumentSectionSnapshots,
+  createSectionLocations,
+  createTocSnapshot,
+  findDocumentSectionSnapshot,
+} from "./document-outline.ts";
+import {
+  createCurrentLocation,
+  createDocumentChunks,
+  createDocumentLocationSnapshot,
+  createDocumentTextStreamSnapshots,
+  createLocationFromSelection,
+  createRestorePoint,
+  createReviewWorkSnapshot,
+  createWorkflowChunks,
+} from "./document-locations.ts";
+import { describeEventImpact } from "./event-refresh-hints.ts";
+import {
+  createRuntimeContextAnalyticsSnapshot,
+  resolveCurrentContextAnalyticsQuery,
+  runtimeContextAnalyticsSnapshotsEqual,
+} from "./context-analytics.ts";
 import {
   buildPageLayoutSnapshot,
   buildResolvedSections,
@@ -177,6 +221,7 @@ export interface DocumentRuntime {
   focus(): void;
   blur(): void;
   setDefaultAuthorId?(authorId?: string): void;
+  getDefaultAuthorId?(): string | undefined;
   addComment(params: AddCommentParams): string;
   openComment(commentId: string): void;
   resolveComment(commentId: string): void;
@@ -198,6 +243,28 @@ export interface DocumentRuntime {
   setZoom(level: ZoomLevel): void;
   getPageLayoutSnapshot(): PageLayoutSnapshot | null;
   getDocumentNavigationSnapshot(): DocumentNavigationSnapshot;
+  getCurrentLocation(): DocumentLocationSnapshot | null;
+  getLocationForSelection(selection: SelectionSnapshot): DocumentLocationSnapshot | null;
+  getLocationForAnchor(
+    anchor: EditorAnchorProjection,
+    storyTarget?: EditorStoryTarget,
+  ): DocumentLocationSnapshot | null;
+  captureRestorePoint(
+    input?: SelectionSnapshot | EditorAnchorProjection,
+  ): RestorePointSnapshot | null;
+  restoreToPoint(
+    point: RestorePointSnapshot,
+    options?: { behavior?: "exact" | "semantic"; scroll?: boolean },
+  ): RestoreResult;
+  getOutlineSnapshot(): DocumentOutlineSnapshot;
+  getTocSnapshot(): TocSnapshot | null;
+  getSections(): DocumentSectionSnapshot[];
+  getSectionSnapshot(input: {
+    sectionIndex?: number;
+    headingId?: string;
+    bookmarkName?: string;
+  }): DocumentSectionSnapshot | null;
+  describeEventImpact(event: WordReviewEditorEvent): SnapshotRefreshHints;
   getFieldSnapshot(): FieldSnapshot;
   updateFields(options?: UpdateFieldsOptions): UpdateFieldsResult;
   updateTableOfContents(options?: TocRefreshOptions): TocRefreshResult;
@@ -206,16 +273,30 @@ export interface DocumentRuntime {
   getCompatibilityReport(): CompatibilityReport;
   getWarnings(): EditorWarning[];
   exportDocx(options?: ExportDocxOptions): Promise<ExportResult>;
+  getSuggestionsSnapshot(): SuggestionsSnapshot;
   setWorkflowOverlay(overlay: WorkflowOverlay): void;
   clearWorkflowOverlay(): void;
   getWorkflowScopeSnapshot(): WorkflowScopeSnapshot | null;
   getInteractionGuardSnapshot(): InteractionGuardSnapshot;
   getWorkflowMarkupSnapshot(): WorkflowMarkupSnapshot;
+  setWorkflowMetadataDefinitions(definitions: WorkflowMetadataDefinition[]): void;
+  clearWorkflowMetadataDefinitions(): void;
+  setWorkflowMetadataEntries(entries: WorkflowMetadataEntry[]): void;
+  clearWorkflowMetadataEntries(): void;
+  getWorkflowMetadataSnapshot(): WorkflowMetadataSnapshot;
   setHostAnnotationOverlay(overlay: HostAnnotationOverlay): void;
   clearHostAnnotationOverlay(): void;
   getHostAnnotationSnapshot(): HostAnnotationSnapshot;
   getWorkflowCandidateRanges(options?: WorkflowCandidateRangeOptions): WorkflowCandidateRange[];
   replaceWorkflowMarkupText(markupId: string, text: string): void;
+  getDocumentTextStream(): StoryTextStreamSnapshot[];
+  getStoryTextStream(target: EditorStoryTarget): StoryTextStreamSnapshot | null;
+  getDocumentChunks(): DocumentChunkSnapshot[];
+  getWorkflowChunks(): DocumentChunkSnapshot[];
+  getReviewWorkSnapshot(): ReviewWorkSnapshot;
+  getRuntimeContextAnalytics(
+    query?: RuntimeContextAnalyticsQuery,
+  ): RuntimeContextAnalyticsSnapshot | null;
 }
 
 export interface CreateDocumentRuntimeOptions {
@@ -274,6 +355,14 @@ export function createDocumentRuntime(
     preservedRangeCount: 0,
   };
   let workflowOverlay: WorkflowOverlay | null = null;
+  let workflowMetadataDefinitions: WorkflowMetadataDefinition[] =
+    options.initialSessionState?.workflowMetadata?.definitions
+    ?? options.initialSnapshot?.workflowMetadata?.definitions
+    ?? [];
+  let workflowMetadataEntries: WorkflowMetadataEntry[] =
+    options.initialSessionState?.workflowMetadata?.entries
+    ?? options.initialSnapshot?.workflowMetadata?.entries
+    ?? [];
   let hostAnnotationOverlay: HostAnnotationOverlay | null = null;
   const initialPersistedSnapshot = options.initialSessionState
     ? persistedSnapshotFromEditorSessionState(options.initialSessionState, {
@@ -320,6 +409,12 @@ export function createDocumentRuntime(
         snapshot: TrackedChangesSnapshot;
       }
     | undefined;
+  let cachedSuggestions:
+    | {
+        trackedChanges: TrackedChangesSnapshot;
+        snapshot: SuggestionsSnapshot;
+      }
+    | undefined;
   let cachedPageLayout:
     | {
         revisionToken: string;
@@ -371,9 +466,30 @@ export function createDocumentRuntime(
         activeStoryKey: string;
         protectionSnapshot: ProtectionSnapshot;
         preservation: CanonicalDocumentEnvelope["preservation"];
+        workflowOverlay: WorkflowOverlay | null;
+        workflowMetadataDefinitions: WorkflowMetadataDefinition[];
+        workflowMetadataEntries: WorkflowMetadataEntry[];
         snapshot: WorkflowMarkupSnapshot;
       }
     | undefined;
+  const cachedContextAnalyticsSnapshots = new Map<
+    string,
+    {
+      revisionToken: string;
+      activeStoryKey: string;
+      selection: EditorState["selection"];
+      readOnly: boolean;
+      documentMode: DocumentMode;
+      workflowOverlay: WorkflowOverlay | null;
+      protectionSnapshot: ProtectionSnapshot;
+      warnings: EditorState["warnings"];
+      fatalError: EditorState["fatalError"];
+      snapshot: RuntimeContextAnalyticsSnapshot | null;
+    }
+  >();
+  let lastEmittedContextAnalyticsSnapshots:
+    | Map<string, RuntimeContextAnalyticsSnapshot | null>
+    | undefined;
 
   function getCachedSurface(
     document: CanonicalDocumentEnvelope,
@@ -471,6 +587,30 @@ export function createDocumentRuntime(
     return snapshot;
   }
 
+  function getCachedSuggestionsSnapshot(nextState: EditorState): SuggestionsSnapshot {
+    const trackedChanges = getCachedTrackedChangesSnapshot(nextState, undefined);
+    if (
+      cachedSuggestions &&
+      cachedSuggestions.trackedChanges === trackedChanges
+    ) {
+      return cachedSuggestions.snapshot;
+    }
+
+    const snapshot = createSuggestionsSnapshot(trackedChanges);
+    cachedSuggestions = {
+      trackedChanges,
+      snapshot,
+    };
+    return snapshot;
+  }
+
+  function findSuggestionByChangeId(
+    snapshot: SuggestionsSnapshot,
+    changeId: string,
+  ) {
+    return snapshot.suggestions.find((suggestion) => suggestion.changeIds.includes(changeId));
+  }
+
   function getCachedDocumentNavigationSnapshot(
     nextState: EditorState,
     nextActiveStory: EditorStoryTarget,
@@ -612,15 +752,6 @@ export function createDocumentRuntime(
     const effectiveDocumentMode = getEffectiveDocumentMode(selection);
 
     if (effectiveDocumentMode === "suggesting" && commandType) {
-      if (
-        activeStory.kind !== "main" &&
-        SUGGESTING_SECONDARY_STORY_UNSUPPORTED_COMMANDS.has(commandType)
-      ) {
-        reasons.push({
-          code: "suggesting_unsupported",
-          message: "Suggesting mode is not yet export-safe in this story.",
-        });
-      }
       if (SUGGESTING_UNSUPPORTED_COMMANDS.has(commandType)) {
         reasons.push({
           code: "suggesting_unsupported",
@@ -708,6 +839,11 @@ export function createDocumentRuntime(
   function deriveOpaqueWorkflowBlockedReason(
     range: { from: number; to: number },
   ): WorkflowBlockedCommandReason | null {
+    const surfaceReason = deriveSurfaceOpaqueWorkflowBlockedReason(range);
+    if (surfaceReason) {
+      return surfaceReason;
+    }
+
     const targetPartPath = getStoryTargetOpaquePartPath(activeStory);
     if (!targetPartPath) {
       return null;
@@ -721,14 +857,9 @@ export function createDocumentRuntime(
       return null;
     }
 
-    const blockedImportFeatureKeys = new Set([
-      "alt-chunk",
-      "alternate-content",
-      "custom-xml",
-    ]);
     const blockedImportFragment =
       fragments.find((fragment) =>
-        blockedImportFeatureKeys.has(describeOpaqueFragment(fragment).featureKey),
+        isBlockedImportFeatureKey(describeOpaqueFragment(fragment).featureKey),
       ) ?? null;
     const fragment = blockedImportFragment ?? fragments[0]!;
     const descriptor = describeOpaqueFragment(fragment);
@@ -749,6 +880,149 @@ export function createDocumentRuntime(
     };
   }
 
+  function deriveSurfaceOpaqueWorkflowBlockedReason(
+    range: { from: number; to: number },
+  ): WorkflowBlockedCommandReason | null {
+    const blocks = getActiveStorySurfaceBlocks();
+    if (!blocks) {
+      return null;
+    }
+
+    const opaqueTarget = findSurfaceOpaqueTargetIntersectingRange(blocks, range);
+    if (!opaqueTarget) {
+      return null;
+    }
+
+    const code = opaqueTarget.blockedReasonCode ?? "workflow_preserve_only";
+    return {
+      code,
+      message:
+        code === "workflow_blocked_import"
+          ? `${opaqueTarget.label} remains a blocked import and cannot be edited.`
+          : `${opaqueTarget.label} remains preserve-only and cannot be edited.`,
+      anchor: toPublicAnchorProjection(
+        createRangeAnchor(opaqueTarget.from, opaqueTarget.to, {
+          start: -1,
+          end: 1,
+        }),
+      ),
+      storyTarget: activeStory,
+    };
+  }
+
+  function getActiveStorySurfaceBlocks(): readonly SurfaceBlockSnapshot[] | null {
+    const surface = cachedRenderSnapshot.surface;
+    if (!surface) {
+      return null;
+    }
+
+    if (activeStory.kind === "main") {
+      return surface.blocks;
+    }
+
+    const activeStoryKey = storyTargetKey(activeStory);
+    return (
+      surface.secondaryStories.find((story) => storyTargetKey(story.target) === activeStoryKey)?.blocks ??
+      null
+    );
+  }
+
+  function findSurfaceOpaqueTargetIntersectingRange(
+    blocks: readonly SurfaceBlockSnapshot[],
+    range: { from: number; to: number },
+  ): {
+    from: number;
+    to: number;
+    label: string;
+    blockedReasonCode: "workflow_preserve_only" | "workflow_blocked_import";
+  } | null {
+    for (const block of blocks) {
+      if (block.kind === "paragraph") {
+        for (const segment of block.segments) {
+          const match = matchOpaqueInlineSegment(segment, range);
+          if (match) {
+            return match;
+          }
+        }
+        continue;
+      }
+
+      if (block.kind === "table") {
+        for (const row of block.rows) {
+          for (const cell of row.cells) {
+            const match = findSurfaceOpaqueTargetIntersectingRange(cell.content, range);
+            if (match) {
+              return match;
+            }
+          }
+        }
+        continue;
+      }
+
+      if (block.kind === "sdt_block") {
+        const match = findSurfaceOpaqueTargetIntersectingRange(block.children, range);
+        if (match) {
+          return match;
+        }
+        continue;
+      }
+
+      if (block.kind !== "opaque_block") {
+        continue;
+      }
+
+      const blockRange = {
+        from: block.from,
+        to: block.to > block.from ? block.to : block.from + 1,
+      };
+      if (rangesIntersect(blockRange, range)) {
+        if (!block.blockedReasonCode) {
+          continue;
+        }
+        return {
+          from: blockRange.from,
+          to: blockRange.to,
+          label: block.label,
+          blockedReasonCode: block.blockedReasonCode,
+        };
+      }
+    }
+
+    return null;
+  }
+
+  function matchOpaqueInlineSegment(
+    segment: SurfaceInlineSegment,
+    range: { from: number; to: number },
+  ): {
+    from: number;
+    to: number;
+    label: string;
+    blockedReasonCode: "workflow_preserve_only" | "workflow_blocked_import";
+  } | null {
+    if (segment.kind !== "opaque_inline") {
+      return null;
+    }
+    if (!segment.blockedReasonCode) {
+      return null;
+    }
+
+    const segmentRange = {
+      from: segment.from,
+      to: segment.to > segment.from ? segment.to : segment.from + 1,
+    };
+    if (!rangesIntersect(segmentRange, range)) {
+      return null;
+    }
+
+    return {
+      from: segmentRange.from,
+      to: segmentRange.to,
+      label: segment.label,
+      blockedReasonCode: segment.blockedReasonCode,
+    };
+  }
+
   function getStoryTargetOpaquePartPath(storyTarget: EditorStoryTarget): string | null {
     if (storyTarget.kind === "main") {
       return "/word/document.xml";
@@ -778,6 +1052,13 @@ export function createDocumentRuntime(
     return null;
   }
 
+  function rangesIntersect(
+    left: { from: number; to: number },
+    right: { from: number; to: number },
+  ): boolean {
+    return left.from < right.to && right.from < left.to;
+  }
+
   function deriveWorkflowScopeSnapshot(): WorkflowScopeSnapshot | null {
     if (!workflowOverlay) return null;
     const blockedReasons = getCachedInteractionGuardSnapshot().blockedReasons;
@@ -803,6 +1084,13 @@ export function createDocumentRuntime(
     };
   }
 
+  function deriveWorkflowMetadataSnapshot(): WorkflowMetadataSnapshot {
+    return {
+      definitions: structuredClone(workflowMetadataDefinitions),
+      entries: structuredClone(workflowMetadataEntries),
+    };
+  }
+
   function getEffectiveWorkflowScopes(overlay: WorkflowOverlay): WorkflowOverlay["scopes"] {
     const activeWorkItemId = overlay.activeWorkItemId ?? null;
     const activeWorkItemScopeIds =
@@ -847,20 +1135,48 @@ export function createDocumentRuntime(
     const blockedReasons = evaluateWorkflowBlockedReasons(state.selection);
     const matchingScope = getMatchingWorkflowScope(state.selection);
     const primaryBlockedReason = blockedReasons[0];
+    const effectiveMode = primaryBlockedReason
+      ? (
+        primaryBlockedReason.code === "workflow_comment_only"
+          ? "comment"
+          : primaryBlockedReason.code === "workflow_view_only"
+            ? "view"
+            : "blocked"
+      )
+      : getEffectiveDocumentMode(state.selection) === "suggesting"
+        ? "suggest"
+        : matchingScope?.mode ?? "edit";
     const snapshot: InteractionGuardSnapshot = {
-      effectiveMode: primaryBlockedReason
-        ? (
-          primaryBlockedReason.code === "workflow_comment_only"
-            ? "comment"
-            : primaryBlockedReason.code === "workflow_view_only"
-              ? "view"
-              : "blocked"
-        )
-        : getEffectiveDocumentMode(state.selection) === "suggesting"
-          ? "suggest"
-          : matchingScope?.mode ?? "edit",
+      effectiveMode,
       ...(matchingScope?.scopeId ? { matchedScopeId: matchingScope.scopeId } : {}),
       ...(matchingScope?.mode ? { matchedScopeMode: matchingScope.mode } : {}),
+      targetAccess:
+        effectiveMode === "edit"
+          ? "direct-edit"
+          : effectiveMode === "suggest"
+            ? "suggest"
+            : effectiveMode === "comment"
+              ? "comment-only"
+              : effectiveMode === "view"
+                ? "view-only"
+                : "blocked",
+      commandCapabilities: [
+        {
+          family: "text",
+          supported: evaluateWorkflowBlockedReasons(state.selection, "text.insert").length === 0,
+          blockedReasons: evaluateWorkflowBlockedReasons(state.selection, "text.insert"),
+        },
+        {
+          family: "formatting",
+          supported: evaluateWorkflowBlockedReasons(state.selection, "toggleBold").length === 0,
+          blockedReasons: evaluateWorkflowBlockedReasons(state.selection, "toggleBold"),
+        },
+        {
+          family: "structure",
+          supported: evaluateWorkflowBlockedReasons(state.selection, "insertTable").length === 0,
+          blockedReasons: evaluateWorkflowBlockedReasons(state.selection, "insertTable"),
+        },
+      ],
       ...(primaryBlockedReason ? { disabledReason: primaryBlockedReason.message } : {}),
       blockedReasons,
     };
@@ -907,7 +1223,10 @@ export function createDocumentRuntime(
       cachedWorkflowMarkupSnapshot.revisionToken === state.revisionToken &&
       cachedWorkflowMarkupSnapshot.activeStoryKey === activeStoryKey &&
       cachedWorkflowMarkupSnapshot.protectionSnapshot === protectionSnapshot &&
-      cachedWorkflowMarkupSnapshot.preservation === state.document.preservation
+      cachedWorkflowMarkupSnapshot.preservation === state.document.preservation &&
+      cachedWorkflowMarkupSnapshot.workflowOverlay === workflowOverlay &&
+      cachedWorkflowMarkupSnapshot.workflowMetadataDefinitions === workflowMetadataDefinitions &&
+      cachedWorkflowMarkupSnapshot.workflowMetadataEntries === workflowMetadataEntries
     ) {
       return cachedWorkflowMarkupSnapshot.snapshot;
     }
@@ -917,17 +1236,150 @@ export function createDocumentRuntime(
       fieldSnapshot: buildFieldSnapshot(state.document),
       protectionSnapshot,
       preservation: state.document.preservation,
+      workflowMetadataSnapshot: deriveWorkflowMetadataSnapshot(),
     });
     cachedWorkflowMarkupSnapshot = {
       revisionToken: state.revisionToken,
       activeStoryKey,
       protectionSnapshot,
       preservation: state.document.preservation,
+      workflowOverlay,
+      workflowMetadataDefinitions,
+      workflowMetadataEntries,
       snapshot,
     };
     return snapshot;
   }
 
+  function getCachedRuntimeContextAnalytics(
+    query?: RuntimeContextAnalyticsQuery,
+  ): RuntimeContextAnalyticsSnapshot | null {
+    const activeStoryKey = storyTargetKey(activeStory);
+    const queryKey = getRuntimeContextAnalyticsQueryKey(query);
+    const cachedEntry = cachedContextAnalyticsSnapshots.get(queryKey);
+    if (
+      cachedEntry &&
+      cachedEntry.revisionToken === state.revisionToken &&
+      cachedEntry.activeStoryKey === activeStoryKey &&
+      cachedEntry.selection === state.selection &&
+      cachedEntry.readOnly === state.readOnly &&
+      cachedEntry.documentMode === viewState.documentMode &&
+      cachedEntry.workflowOverlay === workflowOverlay &&
+      cachedEntry.protectionSnapshot === protectionSnapshot &&
+      cachedEntry.warnings === state.warnings &&
+      cachedEntry.fatalError === state.fatalError
+    ) {
+      return cachedEntry.snapshot;
+    }
+
+    const snapshot = createRuntimeContextAnalyticsSnapshot({
+      query,
+      renderSnapshot: cachedRenderSnapshot,
+      workflowOverlay,
+      workflowScopeSnapshot: getCachedWorkflowScopeSnapshot(),
+      interactionGuardSnapshot: getCachedInteractionGuardSnapshot(),
+      workflowMarkupSnapshot: getCachedWorkflowMarkupSnapshot(),
+      suggestionsSnapshot: getCachedSuggestionsSnapshot(state),
+      reviewWorkSnapshot: createReviewWorkSnapshot({
+        comments: cachedRenderSnapshot.comments,
+        trackedChanges: cachedRenderSnapshot.trackedChanges,
+        workflowMarkup: getCachedWorkflowMarkupSnapshot(),
+        document: state.document,
+        navigation: getCachedDocumentNavigationSnapshot(state, activeStory),
+      }),
+      warnings: state.warnings.map(toPublicWarning),
+      compatibility: toPublicCompatibilityReport(createDerivedCompatibility(state)),
+    });
+    cachedContextAnalyticsSnapshots.set(queryKey, {
+      revisionToken: state.revisionToken,
+      activeStoryKey,
+      selection: state.selection,
+      readOnly: state.readOnly,
+      documentMode: viewState.documentMode,
+      workflowOverlay,
+      protectionSnapshot,
+      warnings: state.warnings,
+      fatalError: state.fatalError,
+      snapshot,
+    });
+    return snapshot;
+  }
+
+  function getRuntimeContextAnalyticsQueryKey(query?: RuntimeContextAnalyticsQuery): string {
+    return JSON.stringify({
+      scopeKind: query?.scopeKind ?? "selection",
+      scopeId: query?.scopeId ?? null,
+      workItemId: query?.workItemId ?? null,
+    });
+  }
+
+  function getTrackedContextAnalyticsQueries(): Array<RuntimeContextAnalyticsQuery | undefined> {
+    const queries: Array<RuntimeContextAnalyticsQuery | undefined> = [
+      undefined,
+      { scopeKind: "document" },
+    ];
+    const workflowScopeSnapshot = getCachedWorkflowScopeSnapshot();
+    const seenScopeIds = new Set<string>();
+    for (const scope of workflowScopeSnapshot?.scopes ?? []) {
+      if (seenScopeIds.has(scope.scopeId)) {
+        continue;
+      }
+      seenScopeIds.add(scope.scopeId);
+      queries.push({
+        scopeKind: "workflow_scope",
+        scopeId: scope.scopeId,
+      });
+    }
+    const seenWorkItemIds = new Set<string>();
+    for (const workItem of workflowOverlay?.workItems ?? []) {
+      if (seenWorkItemIds.has(workItem.workItemId)) {
+        continue;
+      }
+      seenWorkItemIds.add(workItem.workItemId);
+      queries.push({
+        scopeKind: "work_item",
+        workItemId: workItem.workItemId,
+      });
+    }
+    const activeWorkItemId = workflowScopeSnapshot?.activeWorkItemId ?? null;
+    if (activeWorkItemId && !seenWorkItemIds.has(activeWorkItemId)) {
+      queries.push({
+        scopeKind: "work_item",
+        workItemId: activeWorkItemId,
+      });
+    }
+    return queries;
+  }
+
+  function collectTrackedContextAnalyticsSnapshots(): Map<string, RuntimeContextAnalyticsSnapshot | null> {
+    const snapshots = new Map<string, RuntimeContextAnalyticsSnapshot | null>();
+    for (const query of getTrackedContextAnalyticsQueries()) {
+      snapshots.set(
+        getRuntimeContextAnalyticsQueryKey(query),
+        getCachedRuntimeContextAnalytics(query),
+      );
+    }
+    return snapshots;
+  }
+
+  function trackedContextAnalyticsSnapshotsEqual(
+    left: Map<string, RuntimeContextAnalyticsSnapshot | null>,
+    right: Map<string, RuntimeContextAnalyticsSnapshot | null>,
+  ): boolean {
+    if (left.size !== right.size) {
+      return false;
+    }
+    for (const [key, snapshot] of left.entries()) {
+      if (!right.has(key)) {
+        return false;
+      }
+      if (!runtimeContextAnalyticsSnapshotsEqual(snapshot, right.get(key) ?? null)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   function refreshRenderSnapshot(): RuntimeRenderSnapshot {
     const surface = getCachedSurface(state.document, activeStory);
     return {
@@ -1124,6 +1576,9 @@ export function createDocumentRuntime(
     setDefaultAuthorId(authorId) {
       defaultAuthorId = authorId;
     },
+    getDefaultAuthorId() {
+      return defaultAuthorId;
+    },
     replaceText(text, target) {
       try {
         const timestamp = clock();
@@ -1151,7 +1606,18 @@ export function createDocumentRuntime(
     },
     addComment(params) {
       if (viewState.documentMode === "viewing") {
-        throw new Error("Cannot add comments in viewing mode.");
+        const error: InternalEditorError = {
+          errorId: createSessionId("comment-viewing-mode", clock()),
+          code: "validation_failed",
+          isFatal: false,
+          message: "Cannot add comments in viewing mode.",
+          source: "runtime",
+          details: {
+            reason: "viewing_mode",
+          },
+        };
+        emitError(error);
+        throw toStructuredRuntimeException(error);
       }
       const commentId = createEntityId("comment", state.document.review.comments, clock());
       const anchor = params.anchor
@@ -1161,16 +1627,19 @@ export function createDocumentRuntime(
         ? createSelectionFromPublicAnchor(params.anchor)
         : state.selection;
       if (!canCreateDocxCommentAnchor(state.document.content, anchor)) {
-        const message =
-          "DOCX comments must use a non-empty range that stays within a single paragraph.";
-        emitError({
+        const error: InternalEditorError = {
           errorId: createSessionId("comment-anchor", clock()),
           code: "validation_failed",
           isFatal: false,
-          message,
+          message:
+            "DOCX comments must use a non-empty range that stays within a single paragraph.",
           source: "runtime",
-        });
-        throw new Error(message);
+          details: {
+            reason: "invalid_comment_anchor",
+          },
+        };
+        emitError(error);
+        throw toStructuredRuntimeException(error);
       }
       const authorId = params.authorId ?? defaultAuthorId ?? "unknown";
       const createdAt = clock();
@@ -1339,6 +1808,139 @@ export function createDocumentRuntime(
     getDocumentNavigationSnapshot() {
       return getCachedDocumentNavigationSnapshot(state, activeStory);
     },
+    getCurrentLocation() {
+      const navigation = getCachedDocumentNavigationSnapshot(state, activeStory);
+      return createCurrentLocation({
+        document: state.document,
+        renderSnapshot: cachedRenderSnapshot,
+        navigation,
+        sections: createDocumentSectionSnapshots(state.document, navigation),
+      });
+    },
+    getLocationForSelection(selection: SelectionSnapshot) {
+      const selectionStory = selection.storyTarget ?? activeStory;
+      const navigation = getCachedDocumentNavigationSnapshot(state, selectionStory);
+      return createLocationFromSelection({
+        document: state.document,
+        navigation,
+        sections: createDocumentSectionSnapshots(state.document, navigation),
+        selection,
+      });
+    },
+    getLocationForAnchor(anchor: EditorAnchorProjection, storyTarget?: EditorStoryTarget) {
+      const resolvedStory = storyTarget ?? activeStory;
+      const navigation = getCachedDocumentNavigationSnapshot(state, resolvedStory);
+      return createDocumentLocationSnapshot({
+        document: state.document,
+        navigation,
+        sections: createDocumentSectionSnapshots(state.document, navigation),
+        anchor,
+        storyTarget: resolvedStory,
+        source: { kind: "navigation" },
+      });
+    },
+    captureRestorePoint(input?: SelectionSnapshot | EditorAnchorProjection) {
+      const location =
+        input === undefined
+          ? this.getCurrentLocation()
+          : "activeRange" in input
+            ? this.getLocationForSelection(input)
+            : this.getLocationForAnchor(input, activeStory);
+      if (!location) {
+        return null;
+      }
+      return createRestorePoint({
+        location,
+        revisionToken: state.revisionToken,
+        createdAt: clock(),
+        checkpointType:
+          input === undefined
+            ? "selection"
+            : "activeRange" in input
+              ? "selection"
+              : "manual",
+      });
+    },
+    restoreToPoint(point, options) {
+      if (point.location.anchor.kind === "detached") {
+        return {
+          status: "detached",
+          reasons: [point.location.anchor.reason],
+          location: point.location,
+        };
+      }
+
+      const behavior = options?.behavior ?? "semantic";
+      if (behavior === "exact" && point.revisionToken !== state.revisionToken) {
+        return {
+          status: "blocked",
+          reasons: [
+            "restore point no longer matches the current revision; use semantic replay after content changes",
+          ],
+          location: point.location,
+        };
+      }
+
+      if (
+        point.location.storyTarget &&
+        !storyTargetsEqual(activeStory, point.location.storyTarget)
+      ) {
+        if (point.location.storyTarget.kind === "main") {
+          this.closeStory();
+        } else {
+          this.openStory(point.location.storyTarget);
+        }
+      }
+      const selection = createSelectionFromPublicAnchor(point.location.anchor);
+      this.dispatch({
+        type: "selection.set",
+        selection,
+        origin: createOrigin("api", clock()),
+      });
+      const location = this.getCurrentLocation() ?? point.location;
+      return {
+        status: point.revisionToken === state.revisionToken ? "restored" : "remapped",
+        selection: cachedRenderSnapshot.selection,
+        location,
+      };
+    },
+    getOutlineSnapshot() {
+      return createDocumentOutlineSnapshot({
+        navigation: getCachedDocumentNavigationSnapshot(state, activeStory),
+        activeStory,
+        selectionHead: state.selection.head,
+      });
+    },
+    getTocSnapshot() {
+      return createTocSnapshot(
+        state.document,
+        getCachedDocumentNavigationSnapshot(state, activeStory),
+      );
+    },
+    getSections() {
+      return createDocumentSectionSnapshots(
+        state.document,
+        getCachedDocumentNavigationSnapshot(state, activeStory),
+      );
+    },
+    getSectionSnapshot(input) {
+      const navigation = getCachedDocumentNavigationSnapshot(state, activeStory);
+      const sections = createDocumentSectionSnapshots(state.document, navigation);
+      if (input.headingId) {
+        const heading = navigation.headings.find((entry) => entry.headingId === input.headingId);
+        if (heading) {
+          return sections.find((section) => section.sectionIndex === heading.sectionIndex) ?? null;
+        }
+      }
+      return findDocumentSectionSnapshot(
+        sections,
+        input,
+        createSectionLocations(state.document, sections),
+      );
+    },
+    describeEventImpact(event) {
+      return describeEventImpact(event);
+    },
     getFieldSnapshot() {
       return buildFieldSnapshot(state.document);
     },
@@ -1386,12 +1988,15 @@ export function createDocumentRuntime(
     getSessionState() {
       const compatibility = createDerivedCompatibility(state);
       return editorSessionStateFromPersistedSnapshot(
-        createPersistedEditorSnapshot(state, {
-          editorBuild,
-          savedAt: clock(),
-          compatibility,
-          protectionSnapshot,
-        }) as unknown as PersistedEditorSnapshot,
+        {
+          ...(createPersistedEditorSnapshot(state, {
+            editorBuild,
+            savedAt: clock(),
+            compatibility,
+            protectionSnapshot,
+          }) as unknown as PersistedEditorSnapshot),
+          workflowMetadata: deriveWorkflowMetadataSnapshot(),
+        },
       );
     },
     getPersistedSnapshot() {
@@ -1405,6 +2010,9 @@ export function createDocumentRuntime(
     getWarnings() {
       return state.warnings.map((warning) => toPublicWarning(warning));
     },
+    getSuggestionsSnapshot() {
+      return getCachedSuggestionsSnapshot(state);
+    },
     async exportDocx(exportOptions) {
       if (!options.exportDocx) {
         const error: InternalEditorError = {
@@ -1418,7 +2026,7 @@ export function createDocumentRuntime(
           },
         };
         emitError(error);
-        throw new Error(error.message);
+        throw toStructuredRuntimeException(error);
       }
 
       const result = await options.exportDocx(this.getSessionState(), exportOptions);
@@ -1483,6 +2091,57 @@ export function createDocumentRuntime(
     getWorkflowMarkupSnapshot() {
       return getCachedWorkflowMarkupSnapshot();
     },
+    setWorkflowMetadataDefinitions(definitions) {
+      workflowMetadataDefinitions = structuredClone(definitions);
+      const snapshot = deriveWorkflowMetadataSnapshot();
+      emit({
+        type: "workflow_metadata_changed",
+        documentId: state.documentId,
+        snapshot,
+      });
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    clearWorkflowMetadataDefinitions() {
+      workflowMetadataDefinitions = [];
+      const snapshot = deriveWorkflowMetadataSnapshot();
+      emit({
+        type: "workflow_metadata_changed",
+        documentId: state.documentId,
+        snapshot,
+      });
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    setWorkflowMetadataEntries(entries) {
+      workflowMetadataEntries = structuredClone(entries);
+      const snapshot = deriveWorkflowMetadataSnapshot();
+      emit({
+        type: "workflow_metadata_changed",
+        documentId: state.documentId,
+        snapshot,
+      });
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    clearWorkflowMetadataEntries() {
+      workflowMetadataEntries = [];
+      const snapshot = deriveWorkflowMetadataSnapshot();
+      emit({
+        type: "workflow_metadata_changed",
+        documentId: state.documentId,
+        snapshot,
+      });
+      for (const listener of listeners) {
+        listener();
+      }
+    },
+    getWorkflowMetadataSnapshot() {
+      return deriveWorkflowMetadataSnapshot();
+    },
     setHostAnnotationOverlay(overlay) {
       hostAnnotationOverlay = structuredClone(overlay);
       emit({
@@ -1528,6 +2187,43 @@ export function createDocumentRuntime(
       }
       this.replaceText(text, target.anchor);
     },
+    getDocumentTextStream() {
+      return cachedRenderSnapshot.surface
+        ? createDocumentTextStreamSnapshots({
+            surface: cachedRenderSnapshot.surface,
+            navigation: getCachedDocumentNavigationSnapshot(state, activeStory),
+          })
+        : [];
+    },
+    getStoryTextStream(target: EditorStoryTarget) {
+      return this.getDocumentTextStream().find((stream) => storyTargetsEqual(stream.target, target)) ?? null;
+    },
+    getDocumentChunks() {
+      return createDocumentChunks({
+        document: state.document,
+        renderSnapshot: cachedRenderSnapshot,
+        navigation: getCachedDocumentNavigationSnapshot(state, activeStory),
+      });
+    },
+    getWorkflowChunks() {
+      return createWorkflowChunks({
+        document: state.document,
+        navigation: getCachedDocumentNavigationSnapshot(state, activeStory),
+        workflowMarkup: getCachedWorkflowMarkupSnapshot(),
+      });
+    },
+    getReviewWorkSnapshot() {
+      return createReviewWorkSnapshot({
+        comments: cachedRenderSnapshot.comments,
+        trackedChanges: cachedRenderSnapshot.trackedChanges,
+        workflowMarkup: getCachedWorkflowMarkupSnapshot(),
+        document: state.document,
+        navigation: getCachedDocumentNavigationSnapshot(state, activeStory),
+      });
+    },
+    getRuntimeContextAnalytics(query) {
+      return getCachedRuntimeContextAnalytics(query);
+    },
   };
 
   function applyHistory(direction: "undo" | "redo"): void {
@@ -1579,6 +2275,7 @@ export function createDocumentRuntime(
     next: EditorState,
     transaction: EditorTransaction,
   ): void {
+    const emittedSuggestionIds = new Set<string>();
     if (previous.isDirty !== next.isDirty) {
       emit({
         type: "dirty_changed",
@@ -1618,6 +2315,22 @@ export function createDocumentRuntime(
         documentId: next.documentId,
         changeId: transaction.effects.changeAccepted.changeId,
       });
+      const updatedSuggestion = findSuggestionByChangeId(
+        getCachedSuggestionsSnapshot(next),
+        transaction.effects.changeAccepted.changeId,
+      );
+      if (updatedSuggestion) {
+        emit({
+          type: "suggestion_updated",
+          documentId: next.documentId,
+          suggestionId: updatedSuggestion.suggestionId,
+          changeIds: updatedSuggestion.changeIds,
+          suggestionKind: updatedSuggestion.kind,
+          status: updatedSuggestion.status,
+          storyTarget: updatedSuggestion.storyTarget,
+          anchor: updatedSuggestion.anchor,
+        });
+      }
     }
 
     if (transaction.effects.changeRejected) {
@@ -1626,6 +2339,22 @@ export function createDocumentRuntime(
         documentId: next.documentId,
         changeId: transaction.effects.changeRejected.changeId,
       });
+      const updatedSuggestion = findSuggestionByChangeId(
+        getCachedSuggestionsSnapshot(next),
+        transaction.effects.changeRejected.changeId,
+      );
+      if (updatedSuggestion) {
+        emit({
+          type: "suggestion_updated",
+          documentId: next.documentId,
+          suggestionId: updatedSuggestion.suggestionId,
+          changeIds: updatedSuggestion.changeIds,
+          suggestionKind: updatedSuggestion.kind,
+          status: updatedSuggestion.status,
+          storyTarget: updatedSuggestion.storyTarget,
+          anchor: updatedSuggestion.anchor,
+        });
+      }
     }
 
     if (transaction.effects.revisionAuthored) {
@@ -1635,6 +2364,47 @@ export function createDocumentRuntime(
         changeId: transaction.effects.revisionAuthored.changeId,
         kind: transaction.effects.revisionAuthored.kind,
       });
+      const authoredSuggestion = findSuggestionByChangeId(
+        getCachedSuggestionsSnapshot(next),
+        transaction.effects.revisionAuthored.changeId,
+      );
+      if (authoredSuggestion) {
+        emittedSuggestionIds.add(authoredSuggestion.suggestionId);
+        emit({
+          type: "suggestion_authored",
+          documentId: next.documentId,
+          suggestionId: authoredSuggestion.suggestionId,
+          changeIds: authoredSuggestion.changeIds,
+          suggestionKind: authoredSuggestion.kind,
+          storyTarget: authoredSuggestion.storyTarget,
+          anchor: authoredSuggestion.anchor,
+          isReplacement: authoredSuggestion.isReplacement,
+        });
+      }
+    }
+
+    const addedRevisionIds = Object.keys(next.document.review.revisions).filter(
+      (revisionId) => previous.document.review.revisions[revisionId] === undefined,
+    );
+    if (addedRevisionIds.length > 0) {
+      const suggestionsSnapshot = getCachedSuggestionsSnapshot(next);
+      for (const revisionId of addedRevisionIds) {
+        const authoredSuggestion = findSuggestionByChangeId(suggestionsSnapshot, revisionId);
+        if (!authoredSuggestion || emittedSuggestionIds.has(authoredSuggestion.suggestionId)) {
+          continue;
+        }
+        emittedSuggestionIds.add(authoredSuggestion.suggestionId);
+        emit({
+          type: "suggestion_authored",
+          documentId: next.documentId,
+          suggestionId: authoredSuggestion.suggestionId,
+          changeIds: authoredSuggestion.changeIds,
+          suggestionKind: authoredSuggestion.kind,
+          storyTarget: authoredSuggestion.storyTarget,
+          anchor: authoredSuggestion.anchor,
+          isReplacement: authoredSuggestion.isReplacement,
+        });
+      }
     }
 
     if (transaction.effects.commandBlocked) {
@@ -1681,6 +2451,23 @@ export function createDocumentRuntime(
     } = {},
   ): void {
     const selection = options.selection ?? state.selection;
+    if (
+      activeStory.kind !== "main" &&
+      getEffectiveDocumentMode(selection) === "suggesting" &&
+      command.type === "paragraph.split"
+    ) {
+      emit({
+        type: "command_blocked",
+        documentId: state.documentId,
+        command: options.blockedCommandName ?? command.type,
+        reasons: [{
+          code: "suggesting_unsupported",
+          message: `"${command.type}" is not supported in suggesting mode for this story.`,
+          storyTarget: activeStory,
+        }],
+      });
+      return;
+    }
     const blockedReasons = evaluateWorkflowBlockedReasons(selection, command.type);
     if (blockedReasons.length > 0) {
       emit({
@@ -1832,12 +2619,75 @@ export function createDocumentRuntime(
   }
 
   function emit(event: DocumentRuntimeEvent): void {
+    emitInternal(event);
+    if (shouldEmitContextAnalyticsChanged(event)) {
+      emitContextAnalyticsChanged();
+    }
+  }
+
+  function emitInternal(event: DocumentRuntimeEvent): void {
     options.onEvent?.(event);
     for (const listener of eventListeners) {
       listener(event);
     }
   }
 
+  function shouldEmitContextAnalyticsChanged(event: DocumentRuntimeEvent): boolean {
+    switch (event.type) {
+      case "selection_changed":
+      case "story_changed":
+      case "workflow_overlay_changed":
+      case "workflow_active_work_item_changed":
+      case "change_authored":
+      case "change_accepted":
+      case "change_rejected":
+      case "comment_added":
+      case "comment_resolved":
+      case "warning_added":
+      case "warning_cleared":
+      case "error":
+      case "ready":
+      case "command_blocked":
+      case "suggestion_authored":
+      case "suggestion_updated":
+        return true;
+      case "context_analytics_changed":
+      case "dirty_changed":
+      case "autosave_state":
+      case "snapshot_saved":
+      case "session_saved":
+      case "export_completed":
+      case "host_annotation_overlay_changed":
+        return false;
+      default:
+        return false;
+    }
+  }
+
+  function emitContextAnalyticsChanged(): void {
+    const trackedSnapshots = collectTrackedContextAnalyticsSnapshots();
+    if (
+      lastEmittedContextAnalyticsSnapshots !== undefined &&
+      trackedContextAnalyticsSnapshotsEqual(lastEmittedContextAnalyticsSnapshots, trackedSnapshots)
+    ) {
+      return;
+    }
+    lastEmittedContextAnalyticsSnapshots = trackedSnapshots;
+    emitInternal({
+      type: "context_analytics_changed",
+      documentId: state.documentId,
+      snapshot:
+        trackedSnapshots.get(
+          getRuntimeContextAnalyticsQueryKey(
+            resolveCurrentContextAnalyticsQuery({
+              workflowScopeSnapshot: getCachedWorkflowScopeSnapshot(),
+              interactionGuardSnapshot: getCachedInteractionGuardSnapshot(),
+            }),
+          ),
+        ) ?? null,
+    });
+  }
+
   function emitError(error: InternalEditorError): void {
     const nextState: EditorState = {
       ...state,
@@ -1949,6 +2799,30 @@ function finalizeState(
 
 function toRuntimeError(error: unknown): InternalEditorError {
   if (typeof error === "object" && error && "message" in error) {
+    if (
+      "code" in error
+      && "source" in error
+      && "isFatal" in error
+      && typeof (error as { code?: unknown }).code === "string"
+      && typeof (error as { source?: unknown }).source === "string"
+      && typeof (error as { isFatal?: unknown }).isFatal === "boolean"
+    ) {
+      return {
+        errorId:
+          typeof (error as { errorId?: unknown }).errorId === "string"
+            ? String((error as { errorId?: unknown }).errorId)
+            : createSessionId("runtime-error", new Date().toISOString()),
+        code: (error as { code: InternalEditorError["code"] }).code,
+        isFatal: (error as { isFatal: boolean }).isFatal,
+        message: String((error as { message?: unknown }).message ?? "Runtime error"),
+        source: (error as { source: InternalEditorError["source"] }).source,
+        details:
+          typeof (error as { details?: unknown }).details === "object"
+            && (error as { details?: unknown }).details !== null
+            ? ((error as { details?: Record<string, unknown> }).details)
+            : undefined,
+      };
+    }
     return {
       errorId: createSessionId("runtime-error", new Date().toISOString()),
       code: "internal_invariant",
@@ -1967,6 +2841,12 @@ function toRuntimeError(error: unknown): InternalEditorError {
   };
 }
 
+function toStructuredRuntimeException<T extends InternalEditorError>(
+  error: T,
+): Error & T {
+  return Object.assign(new Error(error.message), error);
+}
+
 function toPublicDocumentStats(state: Pick<EditorState, "document">) {
   const stats = deriveDocumentStats(state);
   return {
@@ -2150,6 +3030,8 @@ function toPublicCommentSidebarSnapshot(
         createdBy: thread.createdBy,
         warningCount: thread.warningCount,
         anchorLabel: thread.anchorLabel,
+        detachedReason: sourceThread?.metadata?.detachedReason,
+        actionabilityNote: sourceThread?.metadata?.actionabilityNote,
         isActive: thread.isActive,
         resolvedAt: thread.resolvedAt,
         resolvedBy: thread.resolvedBy,
@@ -2188,6 +3070,11 @@ function toPublicTrackedChangesSnapshot(
       return {
         revisionId: revision.revisionId,
         kind: revision.kind,
+        source: sourceRevision?.metadata?.source ?? "runtime",
+        suggestionId: sourceRevision?.metadata?.suggestionId,
+        semanticKind: sourceRevision?.metadata?.semanticKind,
+        linkedRevisionIds: sourceRevision?.metadata?.linkedRevisionIds,
+        predecessorSuggestionId: sourceRevision?.metadata?.predecessorSuggestionId,
         label: revision.label,
         status: revision.status,
         actionability: revision.actionability,
@@ -2234,6 +3121,10 @@ function createRevisionStoreFromDocument(
             source: revision.metadata?.source ?? "runtime",
             storyTarget: revision.metadata?.storyTarget,
             preserveOnlyReason: revision.metadata?.preserveOnlyReason,
+            suggestionId: revision.metadata?.suggestionId,
+            semanticKind: revision.metadata?.semanticKind,
+            linkedRevisionIds: revision.metadata?.linkedRevisionIds,
+            predecessorSuggestionId: revision.metadata?.predecessorSuggestionId,
             importedRevisionForm: revision.metadata?.importedRevisionForm,
             originalRevisionType: revision.metadata?.originalRevisionType,
             ooxmlRevisionId: revision.metadata?.ooxmlRevisionId,
@@ -2251,6 +3142,13 @@ function getRevisionStoryTarget(
   return storyTarget ? { ...storyTarget } : MAIN_STORY_TARGET;
 }
 
+function findSuggestionByChangeId(
+  snapshot: SuggestionsSnapshot,
+  changeId: string,
+) {
+  return snapshot.suggestions.find((suggestion) => suggestion.changeIds.includes(changeId));
+}
+
 function createSecondaryStoryLocalReviewState(
   review: EditorState["document"]["review"],
   storyTarget: EditorStoryTarget,
@@ -2451,11 +3349,9 @@ const NON_MUTATION_COMMANDS = new Set([
 ]);
 
 /** Mutation commands that are not yet supported in suggesting mode. */
-const SUGGESTING_UNSUPPORTED_COMMANDS = new Set([
-  "paragraph.split",
-]);
+const SUGGESTING_UNSUPPORTED_COMMANDS = new Set<string>([]);
 
-const SUGGESTING_SECONDARY_STORY_UNSUPPORTED_COMMANDS = new Set([
+const SUGGESTING_SECONDARY_STORY_UNSUPPORTED_COMMANDS = new Set<string>([
   "text.insert",
   "text.delete-backward",
   "text.delete-forward",