@beyondwork/docx-react-component 1.0.37 → 1.0.39

package/src/ui-tailwind/tw-review-workspace.tsx

@@ -39,6 +39,7 @@ import type {
   ZoomLevel,
 } from "../api/public-types";
 import { findPageForOffset } from "../runtime/document-navigation.ts";
+import { createCanvasBackend } from "../runtime/layout/index.ts";
 import {
   DEFAULT_PAGE_ESTIMATE_PX_PER_TWIP,
   estimateBlockHeight,
@@ -50,6 +51,8 @@ import {
   incrementInvalidationCounter,
   recordPerfSample,
 } from "./editor-surface/perf-probe.ts";
+import { sliceBlocksForPage } from "./editor-surface/page-slice-util.ts";
+import { TwPageBlockView } from "./editor-surface/tw-page-block-view.tsx";
 import { computeLineMarkersIfEnabled } from "./page-chrome-model.ts";
 import type { SessionCapabilities } from "../runtime/session-capabilities";
 import type {
@@ -77,11 +80,13 @@ import {
   resolveChromePresetOptions,
   resolveChromeVisibilityForPreset,
 } from "./chrome/chrome-preset-model";
-import { TwReviewQueueBar } from "./chrome/review-queue-bar";
 import { TwSelectionToolHost } from "./chrome/tw-selection-tool-host";
+import { resolveSelectionAnchor } from "./chrome/tw-selection-anchor-resolver";
+import { resolveSelectionToolPlacement } from "./chrome/tw-selection-tool-placement";
 import { TwReviewRail, type ReviewRailTab } from "./review/tw-review-rail";
 import { TwStatusBar } from "./status/tw-status-bar";
 import { type ToolbarInteractionPolicy } from "./toolbar/tw-toolbar";
+import { TwChromeOverlay } from "./chrome-overlay";
 
 export type ReviewWorkspaceChromeVisibility = WordReviewEditorChromeVisibility;
 
@@ -92,6 +97,38 @@ export interface TwReviewWorkspaceProps {
   currentUserId?: string;
   capabilities?: SessionCapabilities;
   reviewMode?: "editing" | "review";
+  /**
+   * Runtime-owned layout facet.  Optional so existing tests + host apps
+   * continue to mount the workspace without installing a facet.  When
+   * supplied, the ChromeOverlay plane (scope rail, workflow dock, etc.)
+   * renders over the document column.
+   */
+  layoutFacet?: import("../runtime/layout/index.ts").WordReviewEditorLayoutFacet;
+  /**
+   * Optional shell header mounted above the formatting toolbar.  Pass a
+   * pre-assembled `<TwShellHeader />` with brand / mode switcher /
+   * primaryAction, or any other ReactNode.  Hosts that do not supply this
+   * get the legacy layout.
+   */
+  shellHeader?: ReactNode;
+  /**
+   * Optional host-provided Workflow-tab override for the review rail.
+   * When unset the rail renders the built-in `TwWorkflowTab` sourced from
+   * `layoutFacet.getAllScopeRailSegments()`.
+   */
+  reviewRailWorkflowTab?: ReactNode;
+  reviewRailWorkflowCount?: number;
+  reviewRailWorkflowScopesTitle?: string;
+  reviewRailIntelligenceEyebrow?: string;
+  /** Opt in to the editorial DOCUMENT INTELLIGENCE header + underline tab chip. */
+  reviewRailIntelligenceHeader?: boolean;
+  /** Optional SEARCH / HELP utility footer at the bottom of the rail. */
+  reviewRailFooter?: {
+    onSearch?: () => void;
+    helpHref?: string;
+    searchLabel?: string;
+    helpLabel?: string;
+  };
   document: ReactNode;
   workspaceMode: WorkspaceMode;
   zoomLevel?: ZoomLevel;
@@ -114,6 +151,17 @@ export interface TwReviewWorkspaceProps {
   activeSelectionTool?: ActiveSelectionToolModel | null;
   selectionToolAnchor?: SelectionToolAnchor | null;
   documentNavigation?: DocumentNavigationSnapshot;
+  /**
+   * R2.3: chrome-pin change handler.  When supplied, selection tools
+   * expose their detach affordance and persist pin state through to
+   * runtime ViewState (via the host's `setChromePin` action).  When
+   * omitted, the detach handle is suppressed — the tool behaves as
+   * a non-pinnable anchored panel (pre-R2 behavior for most kinds).
+   */
+  onChromePinChange?: (
+    surface: import("../api/public-types").ChromePinSurface,
+    pin: import("../api/public-types").PinState | null,
+  ) => void;
   onWorkspaceModeChange?: (value: WorkspaceMode) => void;
   onZoomChange?: (level: ZoomLevel) => void;
   onActiveRailTabChange?: (value: ReviewRailTab) => void;
@@ -218,6 +266,14 @@ export interface TwReviewWorkspaceProps {
   onCloseStory?: () => void;
   onOpenHeaderStory?: () => void;
   onOpenFooterStory?: () => void;
+  /**
+   * Open a header/footer story for a specific page.  Called when the user
+   * double-clicks a per-page header/footer band in the page-stack chrome.
+   * Must resolve the correct variant for that page's section and call
+   * `runtime.openStory()`.
+   */
+  onOpenHeaderStoryForPage?: (pageIndex: number) => void;
+  onOpenFooterStoryForPage?: (pageIndex: number) => void;
   onSetParagraphIndentation?: (indentation: {
     left?: number;
     right?: number;
@@ -227,13 +283,37 @@ export interface TwReviewWorkspaceProps {
   onSetParagraphTabStops?: (tabStops: Array<{ pos: number; val?: string; leader?: string }>) => void;
   onRestartNumbering?: () => void;
   onContinueNumbering?: () => void;
+  // P6: new table ops
+  onToggleRowHeader?: () => void;
+  onToggleRowCantSplit?: () => void;
+  onDistributeColumnsEvenly?: () => void;
+  onSetTableAlignment?: (alignment: "left" | "center" | "right") => void;
+  onSetCellVerticalAlign?: (align: "top" | "center" | "bottom") => void;
+  /** P6: active table context for chrome overlay grips. */
+  tableContext?: import("../api/public-types").TableStructureContextSnapshot | null;
+  /** P6: column resize committed from overlay grip → set-column-width op. */
+  onSetColumnWidth?: (columnIndex: number, twips: number) => void;
+  /** P6: row resize committed from overlay grip → set-row-height op. */
+  onSetRowHeight?: (rowIndex: number, twips: number, rule: "auto" | "atLeast" | "exact") => void;
+  onListIndent?: () => void;
+  onListOutdent?: () => void;
   onUpdateFields?: () => void;
   onUpdateTableOfContents?: () => void;
   onGoToPreviousReviewItem?: () => void;
   onGoToNextReviewItem?: () => void;
   onMarkSectionForReview?: () => void;
+  /** Optional: open sidebar to tracked-changes panel. When provided, the review role shows a sidebar-TC icon. */
+  onReviewSidebarTrackedChanges?: () => void;
+  /** Optional: open sidebar to comments panel. When provided, the review role shows a sidebar-comments icon. */
+  onReviewSidebarComments?: () => void;
   onNavigateHeading?: (headingId: string) => void;
   chromeVisibility?: Partial<ReviewWorkspaceChromeVisibility>;
+  /**
+   * Called when the shell-header mode tab changes or any chrome surface fires
+   * a role switch.  Wire to `runtime.setEditorRole(role)` so the workspace
+   * re-renders with the new per-role action set.
+   */
+  onEditorRoleChange?: (role: import("../api/public-types.ts").EditorRole) => void;
 }
 
 export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
@@ -275,6 +355,9 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
       reviewRailAvailable,
     }),
   );
+  // Incremented on zoom_changed / render_frame_ready so the placement
+  // useMemo below re-executes when the render kernel emits new rects.
+  const [renderFrameRevision, setRenderFrameRevision] = useState(0);
   const responsiveChromeSignatureRef = useRef<string | null>(null);
   const headings = props.documentNavigation?.headings ?? [];
   const headerVariant = snapshot.pageLayout?.headerVariants[0]?.variant ?? "default";
@@ -304,11 +387,6 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
       ),
     [props.documentNavigation, snapshot.activeStory, snapshot.pageLayout, snapshot.surface],
   );
-  const selectionToolbarPlacement = resolveSelectionToolbarPlacement(
-    props.selectionToolAnchor,
-    selectionToolbarRootRef.current,
-    zoomScale,
-  );
   const effectiveSelectionMode = props.interactionGuardSnapshot?.effectiveMode ?? "edit";
   const allowLocalChromeMutations = Boolean(caps?.canEdit) && effectiveSelectionMode === "edit";
   const gatedSelectionTool = useMemo(() => {
@@ -320,6 +398,40 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
     }
     return props.activeSelectionTool;
   }, [props.activeSelectionTool, chromeVisibility.contextToolbars]);
+  const selectionToolbarPlacement = useMemo(() => {
+    // Prefer render-frame anchors when the layout facet is available — this
+    // keeps the tool glued to kernel coordinates across zoom, scroll, and
+    // predicted-text reconciliation (R4).
+    if (props.layoutFacet && gatedSelectionTool) {
+      const anchorRect = resolveSelectionAnchor({
+        facet: props.layoutFacet,
+        selection: viewState.selection,
+        tool: gatedSelectionTool,
+      });
+      if (anchorRect && selectionToolbarRootRef.current) {
+        const containerRect = selectionToolbarRootRef.current.getBoundingClientRect();
+        const result = resolveSelectionToolPlacement({
+          anchor: anchorRect,
+          container: { widthPx: containerRect.width, heightPx: containerRect.height },
+        });
+        if (result) return result;
+      }
+    }
+    // Fall back to DOM rects for hosts that do not supply a layout facet.
+    return resolveSelectionToolbarPlacement(
+      props.selectionToolAnchor,
+      selectionToolbarRootRef.current,
+      zoomScale,
+    );
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [
+    props.layoutFacet,
+    props.selectionToolAnchor,
+    gatedSelectionTool,
+    viewState.selection,
+    zoomScale,
+    renderFrameRevision,
+  ]);
   const activePage = props.documentNavigation?.pages[props.documentNavigation.activePageIndex] ?? null;
   const pageShellMetrics = useMemo(
     () => buildPageShellMetrics(snapshot.pageLayout),
@@ -344,6 +456,9 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
       }),
     [reviewRailAvailable, reviewRailOpen, viewportWidth],
   );
+  const hasSidebarPanelAccess = Boolean(
+    props.onReviewSidebarTrackedChanges || props.onReviewSidebarComments,
+  );
   const scopedChromePolicy = useMemo(
     () =>
       resolveScopedChromePolicy({
@@ -353,14 +468,18 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
         interactionGuardSnapshot: props.interactionGuardSnapshot,
         workflowScopeSnapshot: props.workflowScopeSnapshot,
         activeListContext: props.activeListContext,
+        role: viewState.editorRole,
+        hasSidebarPanelAccess,
       }),
     [
       caps,
       chromePreset,
+      hasSidebarPanelAccess,
       props.activeListContext,
       props.interactionGuardSnapshot,
       props.workflowScopeSnapshot,
       responsiveChrome.isNarrow,
+      viewState.editorRole,
     ],
   );
   const toolbarInteractionPolicy: ToolbarInteractionPolicy | undefined = caps
@@ -402,6 +521,18 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
     };
   }, []);
 
+  // Subscribe to layout facet events so chrome re-projects on zoom changes
+  // and after incremental relayout (R4).
+  useEffect(() => {
+    if (!props.layoutFacet) return;
+    const unsub = props.layoutFacet.subscribe((event) => {
+      if (event.kind === "zoom_changed" || event.kind === "render_frame_ready") {
+        setRenderFrameRevision((n) => n + 1);
+      }
+    });
+    return unsub;
+  }, [props.layoutFacet]);
+
   useEffect(() => {
     const responsiveSignature = `${reviewRailAvailable ? "1" : "0"}:${isNarrowChromeViewport(viewportWidth) ? "n" : "d"}`;
     if (responsiveChromeSignatureRef.current === responsiveSignature) {
@@ -448,9 +579,18 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
     };
   }, [responsiveChrome.showDrawerReviewRail]);
 
+  useEffect(() => {
+    if (!props.layoutFacet) return;
+    const facet = props.layoutFacet;
+    void document.fonts.ready.then(() => {
+      facet.swapMeasurementProvider(createCanvasBackend());
+    });
+  }, [props.layoutFacet]);
+
   return (
     <Tooltip.Provider delayDuration={400}>
       <div className="flex h-full flex-col bg-canvas text-primary">
+        {props.shellHeader}
         {chromeVisibility.toolbar ? (
           <div className="px-3 pt-3">
             <ChromePresetToolbar
@@ -561,24 +701,56 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
                 dismissSelectionToolbar();
                 props.onShowTrackedChangesChange(show);
               }}
+              role={viewState.editorRole}
+              reviewQueue={props.reviewQueue}
+              markupDisplay={markupDisplay}
+              onReviewSidebarTrackedChanges={props.onReviewSidebarTrackedChanges
+                ? runWithSelectionToolbarDismiss(props.onReviewSidebarTrackedChanges)
+                : undefined}
+              onReviewSidebarComments={props.onReviewSidebarComments
+                ? runWithSelectionToolbarDismiss(props.onReviewSidebarComments)
+                : undefined}
+              onMarkScopePosture={props.onMarkSectionForReview
+                ? runWithSelectionToolbarDismiss(props.onMarkSectionForReview)
+                : undefined}
+              onReviewPrev={props.onGoToPreviousReviewItem
+                ? runWithSelectionToolbarDismiss(props.onGoToPreviousReviewItem)
+                : undefined}
+              onReviewNext={props.onGoToNextReviewItem
+                ? runWithSelectionToolbarDismiss(props.onGoToNextReviewItem)
+                : undefined}
+              onReviewAccept={(() => {
+                const active = props.reviewQueue?.items[props.reviewQueue.activeIndex];
+                if (active?.kind !== "change" || !props.onAcceptRevision) {
+                  return undefined;
+                }
+                // ReviewQueueItem.itemId for a "change" entry is the
+                // revision id (set by the runtime review-queue projection).
+                const revisionId = active.itemId;
+                return () => {
+                  dismissSelectionToolbar();
+                  props.onAcceptRevision?.(revisionId);
+                };
+              })()}
+              onReviewReject={(() => {
+                const active = props.reviewQueue?.items[props.reviewQueue.activeIndex];
+                if (active?.kind !== "change" || !props.onRejectRevision) {
+                  return undefined;
+                }
+                const revisionId = active.itemId;
+                return () => {
+                  dismissSelectionToolbar();
+                  props.onRejectRevision?.(revisionId);
+                };
+              })()}
+              chromePins={viewState.chromePins}
+              onChromePinChange={props.onChromePinChange}
             />
           </div>
         ) : null}
 
-        {chromePreset === "review" && chromeOptions.showReviewQueueBar && props.reviewQueue ? (
-          <TwReviewQueueBar
-            queue={props.reviewQueue}
-            onPrevious={props.onGoToPreviousReviewItem
-              ? runWithSelectionToolbarDismiss(props.onGoToPreviousReviewItem)
-              : undefined}
-            onNext={props.onGoToNextReviewItem
-              ? runWithSelectionToolbarDismiss(props.onGoToNextReviewItem)
-              : undefined}
-            onMarkSection={chromeOptions.showSectionTagAction && props.onMarkSectionForReview
-              ? runWithSelectionToolbarDismiss(props.onMarkSectionForReview)
-              : undefined}
-          />
-        ) : null}
+        {/* Legacy TwReviewQueueBar is suppressed — review role's action region
+            now owns queue prev/next + counts inline in the top toolbar. */}
 
         {chromeVisibility.alerts ? <TwAlertBanner
           snapshot={snapshot}
@@ -883,6 +1055,13 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
                     onSetImageFrame={props.onSetImageFrame}
                     onRestartNumbering={props.onRestartNumbering}
                     onContinueNumbering={props.onContinueNumbering}
+                    onToggleRowHeader={props.onToggleRowHeader}
+                    onToggleRowCantSplit={props.onToggleRowCantSplit}
+                    onDistributeColumnsEvenly={props.onDistributeColumnsEvenly}
+                    onSetTableAlignment={props.onSetTableAlignment}
+                    onSetCellVerticalAlign={props.onSetCellVerticalAlign}
+                    chromePins={viewState.chromePins}
+                    onChromePinChange={props.onChromePinChange}
                   />
                 ) : null}
                 <div
@@ -949,8 +1128,24 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
                           style={pageChromeModel.pageBorderStyle}
                         />
                       ) : null}
-                      <div className={isPageWorkspace ? "relative z-10" : undefined}>
+                      <div className={isPageWorkspace ? "relative z-10" : "relative"}>
+                        {/* Page chrome (frame borders, header/footer bands,
+                            page-number labels, inter-page separators) is
+                            rendered as in-flow widget decorations inside
+                            the PM surface itself — see
+                            `pm-page-break-decorations.ts`.  That keeps the
+                            chrome perfectly aligned with PM content without
+                            any absolute-positioned overlay that would drift
+                            relative to the browser's line layout. */}
                         {props.document}
+                        {props.layoutFacet ? (
+                          <TwChromeOverlay
+                            facet={props.layoutFacet}
+                            tableContext={props.tableContext}
+                            onSetColumnWidth={props.onSetColumnWidth}
+                            onSetRowHeight={props.onSetRowHeight}
+                          />
+                        ) : null}
                       </div>
                       {isPageWorkspace && chromeVisibility.pageChrome ? (
                         <div
@@ -975,6 +1170,10 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
                   </div>
                 </div>
               </div>
+              {/* Pages 2..N in page mode are now rendered by TwPageStackChrome
+                  as absolute overlays above the single flowing PM surface.
+                  The PM surface holds all editable content; page frames draw
+                  borders, header/footer bands, and per-page numbers on top. */}
             </div>
 
             {chromeVisibility.statusBar ? (
@@ -1021,6 +1220,13 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
             onRejectRevision={props.onRejectRevision}
             onAcceptAllChanges={props.onAcceptAllChanges}
             onRejectAllChanges={props.onRejectAllChanges}
+            scopeRailSegments={props.layoutFacet?.getAllScopeRailSegments?.() ?? []}
+            workflowTab={props.reviewRailWorkflowTab}
+            workflowCount={props.reviewRailWorkflowCount}
+            workflowScopesTitle={props.reviewRailWorkflowScopesTitle}
+            intelligenceEyebrow={props.reviewRailIntelligenceEyebrow}
+            intelligenceHeader={props.reviewRailIntelligenceHeader}
+            railFooter={props.reviewRailFooter}
           /> : null}
 
           {responsiveChrome.showDrawerReviewRail ? (
@@ -1062,6 +1268,13 @@ export function TwReviewWorkspace(inputProps: TwReviewWorkspaceProps) {
                   onRejectRevision={props.onRejectRevision}
                   onAcceptAllChanges={props.onAcceptAllChanges}
                   onRejectAllChanges={props.onRejectAllChanges}
+                  scopeRailSegments={props.layoutFacet?.getAllScopeRailSegments?.() ?? []}
+                  workflowTab={props.reviewRailWorkflowTab}
+                  workflowCount={props.reviewRailWorkflowCount}
+                  workflowScopesTitle={props.reviewRailWorkflowScopesTitle}
+                  intelligenceEyebrow={props.reviewRailIntelligenceEyebrow}
+                  intelligenceHeader={props.reviewRailIntelligenceHeader}
+                  railFooter={props.reviewRailFooter}
                 />
               </div>
             </div>

package/src/runtime/collab-review-sync.ts

@@ -1,254 +0,0 @@
-import * as Y from "yjs";
-
-import type { DocumentRuntime, DocumentRuntimeEvent, Unsubscribe } from "./document-runtime.ts";
-
-// ---------------------------------------------------------------------------
-// Serialised shapes stored inside the Y.Maps
-// ---------------------------------------------------------------------------
-
-interface YCommentThread {
-  commentId: string;
-  status: "open" | "resolved" | "detached";
-  anchor: { kind: string; [key: string]: unknown };
-  createdAt: string;
-  createdBy: string;
-  authorId: string;
-  body: string;
-  entries: Array<{
-    entryId: string;
-    authorId: string;
-    body: string;
-    createdAt: string;
-  }>;
-  resolvedAt?: string;
-  resolvedBy?: string;
-  warningIds: string[];
-  sourceClientId: number;
-}
-
-interface YRevisionAction {
-  changeId: string;
-  action: "accept" | "reject";
-  sourceClientId: number;
-}
-
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-
-export interface CollabReviewSyncHandle {
-  destroy(): void;
-}
-
-export function createCollabReviewSync(
-  ydoc: Y.Doc,
-  runtime: DocumentRuntime,
-): CollabReviewSyncHandle {
-  const yComments = ydoc.getMap<YCommentThread>("comments");
-  const yRevisionActions = ydoc.getMap<YRevisionAction>("revisionActions");
-  const clientId = ydoc.clientID;
-
-  let suppressLocalEvents = false;
-
-  // --- Local → Yjs ---------------------------------------------------------
-
-  const unsubEvents: Unsubscribe = runtime.subscribeToEvents((event) => {
-    if (suppressLocalEvents) return;
-
-    switch (event.type) {
-      case "comment_added":
-        pushCommentToYjs(event.commentId);
-        break;
-      case "comment_resolved":
-        syncCommentFieldToYjs(event.commentId);
-        break;
-      case "change_accepted":
-        yRevisionActions.set(revisionActionKey(event.changeId, "accept"), {
-          changeId: event.changeId,
-          action: "accept",
-          sourceClientId: clientId,
-        });
-        break;
-      case "change_rejected":
-        yRevisionActions.set(revisionActionKey(event.changeId, "reject"), {
-          changeId: event.changeId,
-          action: "reject",
-          sourceClientId: clientId,
-        });
-        break;
-    }
-  });
-
-  function pushCommentToYjs(commentId: string): void {
-    const thread = runtime
-      .getRenderSnapshot()
-      .comments.threads.find((t) => t.commentId === commentId);
-    if (!thread) return;
-
-    yComments.set(commentId, {
-      commentId: thread.commentId,
-      status: thread.status,
-      anchor: thread.anchor,
-      createdAt: thread.createdAt,
-      createdBy: thread.createdBy,
-      authorId: thread.createdBy,
-      body: thread.entries[0]?.body ?? "",
-      entries: thread.entries.map((e) => ({
-        entryId: e.entryId,
-        authorId: e.authorId,
-        body: e.body,
-        createdAt: e.createdAt,
-      })),
-      resolvedAt: thread.resolvedAt,
-      resolvedBy: thread.resolvedBy,
-      warningIds: [],
-      sourceClientId: clientId,
-    });
-  }
-
-  function syncCommentFieldToYjs(commentId: string): void {
-    const existing = yComments.get(commentId);
-    const thread = runtime
-      .getRenderSnapshot()
-      .comments.threads.find((t) => t.commentId === commentId);
-    if (!existing || !thread) return;
-
-    yComments.set(commentId, {
-      ...existing,
-      status: thread.status,
-      entries: thread.entries.map((e) => ({
-        entryId: e.entryId,
-        authorId: e.authorId,
-        body: e.body,
-        createdAt: e.createdAt,
-      })),
-      resolvedAt: thread.resolvedAt,
-      resolvedBy: thread.resolvedBy,
-      sourceClientId: clientId,
-    });
-  }
-
-  // --- Yjs → Local ---------------------------------------------------------
-
-  function onCommentMapChange(event: Y.YMapEvent<YCommentThread>): void {
-    suppressLocalEvents = true;
-    try {
-      for (const [commentId, change] of event.changes.keys) {
-        const entry = yComments.get(commentId);
-        if (!entry || entry.sourceClientId === clientId) continue;
-
-        const existing = runtime
-          .getRenderSnapshot()
-          .comments.threads.find((t) => t.commentId === commentId);
-
-        if (change.action === "add" && !existing) {
-          runtime.dispatch({
-            type: "comment.add",
-            comment: {
-              commentId: entry.commentId,
-              status: entry.status,
-              anchor: entry.anchor as never,
-              createdAt: entry.createdAt,
-              createdBy: entry.createdBy,
-              authorId: entry.authorId,
-              body: entry.body,
-              entries: entry.entries,
-              warningIds: entry.warningIds,
-              isResolved: entry.status === "resolved",
-              metadata: { source: "runtime" },
-            },
-          });
-        } else if (change.action === "update" && existing) {
-          if (entry.status === "resolved" && existing.status !== "resolved") {
-            runtime.dispatch({
-              type: "comment.resolve",
-              commentId,
-              resolvedBy: entry.resolvedBy,
-            });
-          } else if (entry.status === "open" && existing.status === "resolved") {
-            runtime.dispatch({ type: "comment.reopen", commentId });
-          }
-
-          const localEntryCount = existing.entries.length;
-          if (entry.entries.length > localEntryCount) {
-            for (const newEntry of entry.entries.slice(localEntryCount)) {
-              runtime.dispatch({
-                type: "comment.add-reply",
-                commentId,
-                body: newEntry.body,
-                authorId: newEntry.authorId,
-              });
-            }
-          }
-        }
-      }
-    } finally {
-      suppressLocalEvents = false;
-    }
-  }
-
-  function onRevisionActionMapChange(event: Y.YMapEvent<YRevisionAction>): void {
-    suppressLocalEvents = true;
-    try {
-      for (const [, change] of event.changes.keys) {
-        if (change.action !== "add") continue;
-        const entries = [...yRevisionActions.entries()];
-        const latest = entries[entries.length - 1];
-        if (!latest) continue;
-        const entry = latest[1];
-        if (entry.sourceClientId === clientId) continue;
-
-        runtime.dispatch({
-          type: entry.action === "accept" ? "change.accept" : "change.reject",
-          changeId: entry.changeId,
-        });
-      }
-    } finally {
-      suppressLocalEvents = false;
-    }
-  }
-
-  yComments.observe(onCommentMapChange);
-  yRevisionActions.observe(onRevisionActionMapChange);
-
-  // --- Initial sync: push existing comments to Yjs if first client ----------
-
-  const snapshot = runtime.getRenderSnapshot();
-  if (yComments.size === 0 && snapshot.comments.threads.length > 0) {
-    ydoc.transact(() => {
-      for (const thread of snapshot.comments.threads) {
-        yComments.set(thread.commentId, {
-          commentId: thread.commentId,
-          status: thread.status,
-          anchor: thread.anchor,
-          createdAt: thread.createdAt,
-          createdBy: thread.createdBy,
-          authorId: thread.createdBy,
-          body: thread.entries[0]?.body ?? "",
-          entries: thread.entries.map((e) => ({
-            entryId: e.entryId,
-            authorId: e.authorId,
-            body: e.body,
-            createdAt: e.createdAt,
-          })),
-          resolvedAt: thread.resolvedAt,
-          resolvedBy: thread.resolvedBy,
-          warningIds: [],
-          sourceClientId: clientId,
-        });
-      }
-    });
-  }
-
-  return {
-    destroy() {
-      unsubEvents();
-      yComments.unobserve(onCommentMapChange);
-      yRevisionActions.unobserve(onRevisionActionMapChange);
-    },
-  };
-}
-
-function revisionActionKey(changeId: string, action: string): string {
-  return `${changeId}:${action}`;
-}