@beyondwork/docx-react-component 1.0.38 → 1.0.39

package/src/ui/WordReviewEditor.tsx

@@ -50,6 +50,11 @@ import type {
   SurfaceInlineSegment,
   TableOp,
   TableOpResult,
+  PublicTableEvent,
+  PublicTableRenderPlan,
+  PublicTableRowHeight,
+  PublicTableStyle,
+  PublicTableSummary,
   TrackedChangeEntrySnapshot,
   TocRefreshResult,
   UpdateFieldsResult,
@@ -201,7 +206,12 @@ import {
   resolveChromePreset,
   resolveChromeVisibilityForPreset,
 } from "../ui-tailwind/chrome/chrome-preset-model.ts";
-import { createCollabReviewSync } from "../runtime/collab-review-sync.ts";
+import { createRuntimeCollabSync } from "../runtime/collab/runtime-collab-sync.ts";
+import {
+  clearLocalCursorState,
+  getCursorColorForUser,
+  setLocalCursorState,
+} from "../runtime/collab/remote-cursor-awareness.ts";
 
 export {
   __createFallbackRuntime,
@@ -508,6 +518,12 @@ export function __createWordReviewEditorRefBridge(
     setZoom: (level) => {
       runtime.setZoom(level);
     },
+    setEditorRole: (role) => {
+      runtime.setEditorRole(role);
+    },
+    setChromePin: (surface, pin) => {
+      runtime.setChromePin(surface, pin);
+    },
     insertSectionBreak: (type, options) => {
       applyRuntimeInsertSectionBreak(runtime, type, options);
     },
@@ -642,6 +658,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       onError,
       onEvent,
       onWarning,
+      onReviewSidebarTrackedChanges,
+      onReviewSidebarComments,
       readOnly = false,
       reviewMode = "review",
       suggestionsEnabled = false,
@@ -673,6 +691,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       runtime,
       loadError,
       activeRuntime,
+      commandAppliedBridge,
       fallbackSnapshot,
       loadingSessionState,
       loadingViewState,
@@ -993,9 +1012,48 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
 
     useEffect(() => {
       if (!ydoc || !runtime) return;
-      const handle = createCollabReviewSync(ydoc, runtime);
+      const handle = createRuntimeCollabSync({
+        ydoc,
+        runtime,
+        authorId: currentUser.userId,
+        commandAppliedBridge,
+      });
       return () => handle.destroy();
-    }, [ydoc, runtime]);
+    }, [commandAppliedBridge, currentUser.userId, runtime, ydoc]);
+
+    useEffect(() => {
+      if (!awareness) {
+        return;
+      }
+      return () => clearLocalCursorState(awareness);
+    }, [awareness]);
+
+    useEffect(() => {
+      if (!awareness) {
+        return;
+      }
+      if (!runtime) {
+        clearLocalCursorState(awareness);
+        return;
+      }
+
+      setLocalCursorState(awareness, {
+        userId: currentUser.userId,
+        displayName: currentUser.displayName,
+        color: getCursorColorForUser(currentUser.userId),
+        anchor: snapshot.selection.anchor,
+        head: snapshot.selection.head,
+        storyTarget: snapshot.activeStory,
+      });
+    }, [
+      awareness,
+      currentUser.displayName,
+      currentUser.userId,
+      runtime,
+      snapshot.activeStory,
+      snapshot.selection.anchor,
+      snapshot.selection.head,
+    ]);
 
     useEffect(() => {
       runtimeViewStateSeedRef.current = {
@@ -1331,6 +1389,12 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         setZoom: (level) => {
           activeRuntime.setZoom(level);
         },
+        setEditorRole: (role) => {
+          activeRuntime.setEditorRole(role);
+        },
+        setChromePin: (surface, pin) => {
+          activeRuntime.setChromePin(surface, pin);
+        },
         insertSectionBreak: (type, options) => {
           applyRuntimeInsertSectionBreak(activeRuntime, type, options);
         },
@@ -2188,6 +2252,10 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         openDefaultStoryVariant(activeRuntime, snapshot.pageLayout, documentNavigation, "header"),
       onOpenFooterStory: () =>
         openDefaultStoryVariant(activeRuntime, snapshot.pageLayout, documentNavigation, "footer"),
+      onOpenHeaderStoryForPage: (pageIndex: number) =>
+        openStoryForPage(activeRuntime, pageIndex, "header"),
+      onOpenFooterStoryForPage: (pageIndex: number) =>
+        openStoryForPage(activeRuntime, pageIndex, "footer"),
       onDeleteSectionBreak: (sectionIndex) =>
         applyRuntimeDeleteSectionBreak(activeRuntime, sectionIndex),
       onUpdateSectionLayout: (sectionIndex, patch) =>
@@ -2235,7 +2303,6 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       <EditorSurfaceController
         ref={surfaceRef}
         currentUser={currentUser}
-        ydoc={ydoc}
         awareness={awareness}
         snapshot={snapshot}
         canonicalDocument={canonicalDocument}
@@ -2261,6 +2328,16 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         dispatchRuntimeCommand={(command) =>
           activeRuntime.applyActiveStoryTextCommand(command as never)
         }
+        layoutFacet={activeRuntime.layout}
+        pageChromeHeaderBandPx={isPageWorkspace ? 32 : 0}
+        pageChromeFooterBandPx={isPageWorkspace ? 32 : 0}
+        pageChromeInterGapPx={isPageWorkspace ? 24 : 16}
+        onOpenHeaderStoryForPage={(pageIndex: number) =>
+          openStoryForPage(activeRuntime, pageIndex, "header")
+        }
+        onOpenFooterStoryForPage={(pageIndex: number) =>
+          openStoryForPage(activeRuntime, pageIndex, "footer")
+        }
         onCommentActivated={(commentId) => {
           activeRuntime.openComment(commentId);
           setActiveRailTab("comments");
@@ -2354,6 +2431,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         selectionToolbarRef={selectionToolbarElementRef}
         commands={commands}
         document={documentElement}
+        onReviewSidebarTrackedChanges={onReviewSidebarTrackedChanges}
+        onReviewSidebarComments={onReviewSidebarComments}
       />
     );
   },
@@ -3453,7 +3532,7 @@ function buildTablesFacet(
 ) {
   const getCapabilities = () => {
     const snapshot = runtime.getRenderSnapshot();
-    const document = runtime.getSessionState().canonicalDocument;
+    const document = runtime.getCanonicalDocument();
     return (
       clonePublicValue(
         getTableStructureContext(
@@ -3464,6 +3543,178 @@ function buildTablesFacet(
       ) ?? null
     );
   };
+
+  const buildSummary = (
+    table: Extract<ReturnType<typeof runtime.getCanonicalDocument>["content"]["children"][number], { type: "table" }>,
+    tableBlockIndex: number,
+  ): PublicTableSummary => {
+    const blockId = `table-${tableBlockIndex}`;
+    const hasVerticalMerges = table.rows.some((row) =>
+      row.cells.some((cell) => cell.verticalMerge !== undefined),
+    );
+    const hasHorizontalSpans = table.rows.some((row) =>
+      row.cells.some((cell) => (cell.gridSpan ?? 1) > 1),
+    );
+    return {
+      tableBlockIndex,
+      blockId,
+      styleId: table.styleId ?? null,
+      rowCount: table.rows.length,
+      columnCount: table.gridColumns.length,
+      gridColumnsTwips: table.gridColumns,
+      alignment: table.alignment ?? null,
+      hasVerticalMerges,
+      hasHorizontalSpans,
+      pageIndex: runtime.layout.getFirstPageIndexForBlock(blockId) ?? null,
+    };
+  };
+
+  const getTables = (options?: { sectionIndex?: number }): PublicTableSummary[] => {
+    const document = runtime.getCanonicalDocument();
+    const summaries: PublicTableSummary[] = [];
+    let idx = 0;
+    for (const block of document.content.children) {
+      if (block.type === "table") {
+        summaries.push(clonePublicValue(buildSummary(block, idx)));
+        idx++;
+      }
+    }
+    if (options?.sectionIndex != null) {
+      const section = runtime.layout.getSection(options.sectionIndex);
+      if (!section) return [];
+      return summaries.filter(
+        (s) =>
+          s.pageIndex != null &&
+          s.pageIndex >= section.firstPageIndex &&
+          s.pageIndex <= section.lastPageIndex,
+      );
+    }
+    return summaries;
+  };
+
+  const getTable = (tableBlockIndex: number): PublicTableSummary | null => {
+    const document = runtime.getCanonicalDocument();
+    let idx = 0;
+    for (const block of document.content.children) {
+      if (block.type === "table") {
+        if (idx === tableBlockIndex) {
+          return clonePublicValue(buildSummary(block, idx));
+        }
+        idx++;
+      }
+    }
+    return null;
+  };
+
+  const getTableForSelection = (): PublicTableSummary | null => {
+    const sel = mountedSurface?.getTableSelection() ?? null;
+    if (!sel) return null;
+    return getTable(sel.tableBlockIndex);
+  };
+
+  const getRenderPlan = (
+    tableBlockIndex: number,
+    pageIndex?: number,
+  ): PublicTableRenderPlan | null => {
+    const blockId = `table-${tableBlockIndex}`;
+    const effectivePage =
+      pageIndex ??
+      runtime.layout.getFirstPageIndexForBlock(blockId) ??
+      0;
+    const plan = runtime.layout.getTableRenderPlan(blockId, effectivePage);
+    if (!plan) return null;
+    return clonePublicValue({
+      blockId: plan.blockId,
+      pageIndex: plan.pageIndex,
+      columnsTwips: plan.columnsTwips,
+      bandClasses: plan.bandClasses,
+      verticalMerges: plan.verticalMerges,
+      repeatedHeaderRows: plan.repeatedHeaderRows,
+      columnResizeHandles: plan.columnResizeHandles,
+    } satisfies PublicTableRenderPlan);
+  };
+
+  const getColumnWidths = (tableBlockIndex: number): readonly number[] => {
+    const document = runtime.getCanonicalDocument();
+    let idx = 0;
+    for (const block of document.content.children) {
+      if (block.type === "table") {
+        if (idx === tableBlockIndex) {
+          return block.gridColumns;
+        }
+        idx++;
+      }
+    }
+    return [];
+  };
+
+  const getRowHeights = (tableBlockIndex: number): readonly PublicTableRowHeight[] => {
+    const document = runtime.getCanonicalDocument();
+    let idx = 0;
+    for (const block of document.content.children) {
+      if (block.type === "table") {
+        if (idx === tableBlockIndex) {
+          const blockId = `table-${tableBlockIndex}`;
+          const measurement = runtime.layout.getMeasurement(blockId);
+          const totalMeasured = measurement?.heightTwips ?? 0;
+          const rows = block.rows;
+          const perRowFallback = rows.length > 0 ? totalMeasured / rows.length : 0;
+          return rows.map((row): PublicTableRowHeight => ({
+            measured: perRowFallback,
+            ...(row.height != null ? { explicit: row.height } : {}),
+            ...(row.heightRule != null ? { rule: row.heightRule } : {}),
+            isHeader: row.isHeader ?? false,
+          }));
+        }
+        idx++;
+      }
+    }
+    return [];
+  };
+
+  const getStyleCatalog = (): readonly PublicTableStyle[] => {
+    const document = runtime.getCanonicalDocument();
+    return Object.values(document.styles.tables).map(
+      (style): PublicTableStyle =>
+        clonePublicValue({
+          styleId: style.styleId,
+          displayName: style.displayName,
+          ...(style.basedOn != null ? { basedOn: style.basedOn } : {}),
+          isDefault: style.isDefault,
+        }),
+    );
+  };
+
+  const subscribe = (
+    listener: (event: PublicTableEvent) => void,
+  ): (() => void) => {
+    const unsubRuntime = runtime.subscribeToEvents((event) => {
+      if (event.type === "dirty_changed" && event.isDirty) {
+        listener({
+          kind: "table_structure_changed",
+          revisionToken: runtime.getRenderSnapshot().revisionToken,
+        });
+      } else if (event.type === "selection_changed") {
+        listener({ kind: "table_capabilities_changed" });
+      }
+    });
+    const unsubLayout = runtime.layout.subscribe((event) => {
+      if (
+        event.kind === "layout_recomputed" ||
+        event.kind === "incremental_relayout"
+      ) {
+        listener({
+          kind: "table_render_plan_ready",
+          revision: event.revision,
+        });
+      }
+    });
+    return () => {
+      unsubRuntime();
+      unsubLayout();
+    };
+  };
+
   return {
     apply(op: TableOp): TableOpResult {
       if (op.kind === "insert") {
@@ -3487,9 +3738,19 @@ function buildTablesFacet(
       };
     },
     getCapabilities,
+    getTables,
+    getTable,
+    getTableForSelection,
+    getRenderPlan,
+    getColumnWidths,
+    getRowHeights,
+    getStyleCatalog,
+    subscribe,
   };
 }
 
+export { buildTablesFacet as __buildTablesFacet };
+
 function applyRuntimeTextCommand(
   runtime: WordReviewEditorRuntime,
   command:
@@ -3982,6 +4243,25 @@ function clonePublicValue<T>(value: T): T {
   return structuredClone(value);
 }
 
+/**
+ * Open the correct header/footer story for a specific page.  The page's
+ * resolved `stories.header` / `stories.footer` already carries the
+ * right variant (default / first / even) for that page's section, so we
+ * can hand it directly to `runtime.openStory()` without re-running the
+ * variant-pick logic.
+ */
+function openStoryForPage(
+  runtime: WordReviewEditorRuntime,
+  pageIndex: number,
+  kind: "header" | "footer",
+): void {
+  const page = runtime.layout?.getPage(pageIndex);
+  if (!page) return;
+  const target = kind === "header" ? page.stories.header : page.stories.footer;
+  if (!target) return;
+  runtime.openStory(target);
+}
+
 function openDefaultStoryVariant(
   runtime: WordReviewEditorRuntime,
   pageLayout: PageLayoutSnapshot | undefined,

package/src/ui/editor-command-bag.ts

@@ -89,6 +89,10 @@ export interface EditorCommandBag {
   onCloseStory?(): void;
   onOpenHeaderStory?(): void;
   onOpenFooterStory?(): void;
+  /** Open the header story for a specific page (double-click on its band). */
+  onOpenHeaderStoryForPage?(pageIndex: number): void;
+  /** Open the footer story for a specific page (double-click on its band). */
+  onOpenFooterStoryForPage?(pageIndex: number): void;
   onSetParagraphIndentation?(indentation: {
     left?: number;
     right?: number;

package/src/ui/editor-runtime-boundary.ts

@@ -34,6 +34,10 @@ import {
   type DocumentRuntimeEvent,
   type DocumentRuntime,
 } from "../runtime/document-runtime.ts";
+import {
+  createRuntimeCommandAppliedBridge,
+  type RuntimeCommandAppliedBridge,
+} from "../runtime/collab/runtime-collab-sync.ts";
 import { createInertLayoutFacet } from "../runtime/layout/index.ts";
 import { loadDocxEditorSession } from "../io/docx-session.ts";
 import {
@@ -71,6 +75,7 @@ export interface CreateRuntimeArgs {
   hostAdapter?: EditorHostAdapter;
   datastore?: EditorDatastoreAdapter;
   currentUserId?: string;
+  commandAppliedBridge?: RuntimeCommandAppliedBridge;
 }
 
 interface RuntimeLifecycleHandlers {
@@ -103,6 +108,7 @@ export interface EditorRuntimeBoundaryState {
   runtime: WordReviewEditorRuntime | null;
   loadError: EditorError | null;
   activeRuntime: WordReviewEditorRuntime;
+  commandAppliedBridge: RuntimeCommandAppliedBridge;
   fallbackSnapshot: RuntimeRenderSnapshot;
   loadingSessionState: EditorSessionState;
   loadingViewState: EditorViewStateSnapshot;
@@ -280,6 +286,10 @@ export function useEditorRuntimeBoundary(
   const onWarningRef = useRef(onWarning);
   const onErrorRef = useRef(onError);
   const currentUserIdRef = useRef(currentUser.userId);
+  const commandAppliedBridge = useMemo(
+    () => createRuntimeCommandAppliedBridge(),
+    [documentId],
+  );
   const runtimeViewStateSeedRef = useRef<{
     workspaceMode: WorkspaceMode;
     zoomLevel: ZoomLevel;
@@ -374,6 +384,7 @@ export function useEditorRuntimeBoundary(
             hostAdapter: hostAdapterRef.current,
             datastore: datastoreRef.current,
             currentUserId: currentUserIdRef.current,
+            commandAppliedBridge,
           },
           {
             onWarning: onWarningRef.current,
@@ -536,6 +547,7 @@ export function useEditorRuntimeBoundary(
     runtime,
     loadError,
     activeRuntime: runtime ?? loadingRuntimeBridge,
+    commandAppliedBridge,
     fallbackSnapshot,
     loadingSessionState,
     loadingViewState,
@@ -616,6 +628,7 @@ function createRuntime(
       bootstrapEvents.push(event);
     },
     defaultAuthorId: args.currentUserId,
+    onCommandApplied: args.commandAppliedBridge?.onCommandApplied,
   }), {
     drainBootstrapEvents: () => bootstrapEvents.splice(0, bootstrapEvents.length),
     emitBlockedCommand: (
@@ -782,6 +795,7 @@ function createLoadingRuntimeBridge(input: {
       ],
     }),
     dispatch: () => undefined,
+    applyRemoteCommand: () => undefined,
     undo: () => undefined,
     redo: () => undefined,
     focus: () => undefined,
@@ -807,6 +821,8 @@ function createLoadingRuntimeBridge(input: {
     getProtectionSnapshot: () => input.snapshot.protectionSnapshot,
     setWorkspaceMode: () => undefined,
     setZoom: () => undefined,
+    setEditorRole: () => undefined,
+    setChromePin: () => undefined,
     getPageLayoutSnapshot: () => null,
     getDocumentNavigationSnapshot: () => input.navigation,
     layout: inertLayoutFacet,

package/src/ui/editor-shell-view.tsx

@@ -83,6 +83,10 @@ export interface EditorShellViewProps {
   onSelectionToolbarBlurCapture?: React.FocusEventHandler<HTMLDivElement>;
   selectionToolbarRef?: React.Ref<HTMLDivElement>;
   chromeVisibility?: Partial<WordReviewEditorChromeVisibility>;
+  /** Review-role sidebar panel: open sidebar to tracked-changes panel. */
+  onReviewSidebarTrackedChanges?: () => void;
+  /** Review-role sidebar panel: open sidebar to comments panel. */
+  onReviewSidebarComments?: () => void;
 }
 
 export function EditorShellView(props: EditorShellViewProps) {

package/src/ui/editor-surface-controller.tsx

@@ -23,7 +23,6 @@ import type { MediaPreviewDescriptor } from "../ui-tailwind/editor-surface/pm-st
 
 export interface EditorSurfaceControllerProps {
   currentUser: EditorUser;
-  ydoc?: import('yjs').Doc;
   awareness?: import("y-protocols/awareness").Awareness;
   snapshot: RuntimeRenderSnapshot;
   canonicalDocument: CanonicalDocumentEnvelope;
@@ -46,6 +45,8 @@ export interface EditorSurfaceControllerProps {
   onDeleteForward?: () => void;
   onInsertTab?: () => void;
   onOutdentTab?: () => void;
+  onListIndent?: () => void;
+  onListOutdent?: () => void;
   onInsertHardBreak?: () => void;
   onSplitParagraph?: () => void;
   onUndo?: () => void;
@@ -63,6 +64,13 @@ export interface EditorSurfaceControllerProps {
   dispatchRuntimeCommand?: (
     command: import("../ui-tailwind/editor-surface/fast-text-edit-lane.ts").LaneRuntimeCommand,
   ) => import("../api/public-types.ts").TextCommandAck;
+  layoutFacet?: import("../runtime/layout/index.ts").WordReviewEditorLayoutFacet;
+  pageChromeHeaderBandPx?: number;
+  pageChromeFooterBandPx?: number;
+  pageChromeInterGapPx?: number;
+  pageBreakRevision?: number;
+  onOpenHeaderStoryForPage?: (pageIndex: number) => void;
+  onOpenFooterStoryForPage?: (pageIndex: number) => void;
 }
 
 export const EditorSurfaceController = forwardRef<

package/src/ui/headless/chrome-registry.ts

@@ -31,6 +31,8 @@ export type ToolbarChromeItemId =
   | "export"
   // R1: role-scoped action region entries
   | "editor-scope-posture-menu"
+  | "review-sidebar-tracked-changes"
+  | "review-sidebar-comments"
   | "review-queue-prev"
   | "review-queue-next"
   | "review-queue-counts"
@@ -72,7 +74,7 @@ export interface ToolbarChromeRegistryEntry extends ChromeRegistryEntryBase {
   roles: ReadonlyArray<EditorRole>;
   fullPlacement: Exclude<ToolbarChromePlacement, "hidden">;
   compactPlacement: ToolbarChromePlacement;
-  runtimeBehavior: "always" | "formatting" | "structure" | "comment";
+  runtimeBehavior: "always" | "formatting" | "structure" | "comment" | "sidebar-panel";
   scopeBehavior?: "default" | "scoped-only" | "hidden-when-scoped";
   /**
    * Optional per-role placement override.  When a role overrides the
@@ -265,6 +267,9 @@ export const TOOLBAR_CHROME_REGISTRY: ReadonlyArray<ToolbarChromeRegistryEntry>
     surfaces: ["top-toolbar"],
     group: "review",
     presets: ["simple", "advanced", "review", "workflow"],
+    // Visible in every role, but editor/review roles render it inside the
+    // role action region (see ROLE_ACTION_SETS) and the right cluster
+    // suppresses it via `isChromeItemOwnedByRoleRegion` to avoid duplication.
     roles: ALL_ROLES,
     fullPlacement: "inline",
     compactPlacement: "inline",
@@ -274,9 +279,8 @@ export const TOOLBAR_CHROME_REGISTRY: ReadonlyArray<ToolbarChromeRegistryEntry>
     id: "tracked-changes-toggle",
     surfaces: ["top-toolbar"],
     group: "review",
-    // R1 promotes this toggle to every preset that shows a toolbar so the
-    // editor role can see inline tracked changes without switching preset.
     presets: ["simple", "advanced", "review", "workflow"],
+    // Same ownership rule as `comment` — editor/review role regions own it.
     roles: ALL_ROLES,
     fullPlacement: "inline",
     compactPlacement: "inline",
@@ -323,18 +327,43 @@ export const TOOLBAR_CHROME_REGISTRY: ReadonlyArray<ToolbarChromeRegistryEntry>
     runtimeBehavior: "always",
   },
 
-  // ───── R1: Editor-role primaries ──────────────────────────────────────
+  // ───── R1: Workflow-role scope posture menu ───────────────────────────
   {
     id: "editor-scope-posture-menu",
     surfaces: ["top-toolbar"],
     group: "scope",
     presets: ["advanced", "review", "workflow"],
-    roles: EDITOR_ONLY,
+    // Scoping/tagging is a workflow-primary action; moved from editor role.
+    roles: WORKFLOW_ONLY,
     fullPlacement: "inline",
     compactPlacement: "overflow",
     runtimeBehavior: "always",
   },
 
+  // ───── R1: Review-role sidebar panel toggles (optional, host-provided) ─
+  {
+    id: "review-sidebar-tracked-changes",
+    surfaces: ["top-toolbar"],
+    group: "review-sidebar",
+    presets: ["review"],
+    roles: REVIEW_ONLY,
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    // Hidden unless the host provides the sidebar panel callback via
+    // hasSidebarPanelAccess in ResolveScopedChromePolicyInput.
+    runtimeBehavior: "sidebar-panel",
+  },
+  {
+    id: "review-sidebar-comments",
+    surfaces: ["top-toolbar"],
+    group: "review-sidebar",
+    presets: ["review"],
+    roles: REVIEW_ONLY,
+    fullPlacement: "inline",
+    compactPlacement: "inline",
+    runtimeBehavior: "sidebar-panel",
+  },
+
   // ───── R1: Review-role primaries ──────────────────────────────────────
   {
     id: "review-queue-prev",

package/src/ui/headless/scoped-chrome-policy.ts

@@ -11,6 +11,7 @@ import {
   type ToolbarChromeItemId,
   type ToolbarChromePlacement,
 } from "./chrome-registry";
+import { ROLE_ACTION_SETS } from "../../ui-tailwind/chrome/role-action-sets";
 import type { SelectionToolKind } from "./selection-tool-types";
 
 export interface ToolbarChromeItemPolicy {
@@ -44,6 +45,13 @@ export interface ResolveScopedChromePolicyInput {
    * callers that haven't adopted the role model yet).
    */
   role?: EditorRole;
+  /**
+   * Whether the host has wired sidebar-panel callbacks
+   * (`onReviewSidebarTrackedChanges` / `onReviewSidebarComments`).
+   * Defaults to `false` — sidebar panel buttons are hidden unless the host
+   * explicitly opts in (typically the harness).
+   */
+  hasSidebarPanelAccess?: boolean;
 }
 
 export function resolveScopedChromePolicy(
@@ -88,6 +96,9 @@ export function resolveScopedChromePolicy(
           case "comment":
             visible = canAddComment;
             break;
+          case "sidebar-panel":
+            visible = Boolean(input.hasSidebarPanelAccess);
+            break;
           default:
             visible = true;
             break;
@@ -152,6 +163,24 @@ export function isToolbarChromeItemVisible(
   return policy.toolbar[itemId]?.visible ?? false;
 }
 
+/**
+ * Returns true when the given chrome item is owned by the active role's
+ * inline role-action region (i.e. it appears in `ROLE_ACTION_SETS[role]`).
+ * The right-cluster render path uses this to suppress its own copy so we
+ * don't render the same button twice.
+ *
+ * When `role` is undefined (legacy host, no role model adopted) this
+ * returns `false` — the right cluster keeps ownership per the pre-R1
+ * layout.
+ */
+export function isChromeItemOwnedByRoleRegion(
+  itemId: ToolbarChromeItemId,
+  role: EditorRole | undefined,
+): boolean {
+  if (!role) return false;
+  return ROLE_ACTION_SETS[role].includes(itemId);
+}
+
 export function getToolbarChromePlacement(
   policy: ScopedChromePolicy,
   itemId: ToolbarChromeItemId,