@beyondwork/docx-react-component 1.0.38 → 1.0.40

package/src/runtime/workflow-rail-segments.ts

@@ -15,14 +15,21 @@
 import type {
   EditorAnchorProjection,
   EditorStoryTarget,
+  IssueMetadataValue,
+  ScopeCardModel,
   WorkflowBlockedCommandReason,
   WorkflowCandidateRange,
   WorkflowLockedZone,
+  WorkflowMetadataMarkup,
   WorkflowScope,
 } from "../api/public-types";
+import { ISSUE_METADATA_ID } from "../api/public-types";
 import { MAIN_STORY_TARGET, storyTargetsEqual } from "../core/selection/mapping.ts";
 import type { RuntimePageGraph } from "./layout/page-graph.ts";
-import type { RenderFrameRect } from "./render/render-frame-types.ts";
+import type {
+  RenderAnchorIndex,
+  RenderFrameRect,
+} from "./render/render-frame-types.ts";
 
 // ---------------------------------------------------------------------------
 // Public shape
@@ -278,3 +285,144 @@ function resolveScopePosture(scope: WorkflowScope): ScopeRailPosture {
       return "view";
   }
 }
+
+// ---------------------------------------------------------------------------
+// Scope card projection (P1b — consumed by ref.layout.getAllScopeCardModels)
+// ---------------------------------------------------------------------------
+
+export interface AttachScopeCardModelInput {
+  /**
+   * Segments produced by `collectScopeRailSegments`. The card model
+   * keys off segments so per-scope card state stays aligned with the
+   * rail stripe rendering.
+   */
+  segments: readonly ScopeRailSegment[];
+  /**
+   * Original workflow scopes — used to resolve `workItemId` for each
+   * segment (the segment shape predates workItemId passthrough).
+   * Optional; when absent, cards drop `workItemId` and issue matching
+   * falls back to scope-id only.
+   */
+  scopes?: readonly WorkflowScope[];
+  /**
+   * Workflow metadata markup from `WorkflowMarkupSnapshot.metadata`.
+   * Entries with `metadataId === ISSUE_METADATA_ID` that match a
+   * segment's `workItemId` or `scopeId` attach as the card's issue.
+   */
+  metadata?: readonly WorkflowMetadataMarkup[];
+  /**
+   * Optional anchor index used to resolve each card's
+   * `primaryAnchorRect`. When omitted, cards are produced without
+   * rects — chrome consumers fall back to on-render positioning.
+   */
+  anchorIndex?: RenderAnchorIndex | null;
+}
+
+/**
+ * Project rail segments into per-scope `ScopeCardModel` values.
+ *
+ * For each unique `scopeId` in the segment list:
+ *   - use the first segment (document order) as the card's anchor
+ *   - look up an `ISSUE_METADATA_ID` metadata entry whose
+ *     `workItemId` (preferred) or `scopeId` matches the segment
+ *   - coerce that entry's `value` into `IssueMetadataValue` when the
+ *     required shape is present; drop the issue silently otherwise
+ *     so malformed host input never breaks chrome rendering
+ *
+ * P2 fields (`suggestionGroupIds`, `reviewActionCount`,
+ * `agentPending`) are populated as empty defaults and wired in a
+ * later phase.
+ */
+export function attachScopeCardModel(
+  input: AttachScopeCardModelInput,
+): ScopeCardModel[] {
+  if (input.segments.length === 0) return [];
+
+  // Take the first segment per scopeId (document order preserved by
+  // the segment collector).
+  const firstByScope = new Map<string, ScopeRailSegment>();
+  for (const segment of input.segments) {
+    if (!firstByScope.has(segment.scopeId)) {
+      firstByScope.set(segment.scopeId, segment);
+    }
+  }
+
+  const workItemByScope = new Map<string, string>();
+  for (const scope of input.scopes ?? []) {
+    if (scope.workItemId) {
+      workItemByScope.set(scope.scopeId, scope.workItemId);
+    }
+  }
+
+  const models: ScopeCardModel[] = [];
+  for (const segment of firstByScope.values()) {
+    const workItemId = workItemByScope.get(segment.scopeId);
+    const issue = resolveIssueForScope(
+      segment.scopeId,
+      workItemId,
+      input.metadata,
+    );
+    const primaryAnchorRect = input.anchorIndex
+      ? input.anchorIndex.bySelection(segment.fromOffset, segment.toOffset)
+      : null;
+
+    models.push({
+      scopeId: segment.scopeId,
+      ...(workItemId ? { workItemId } : {}),
+      label: segment.label ?? "",
+      posture: segment.posture,
+      primaryAnchorRect,
+      ...(issue ? { issue } : {}),
+      suggestionGroupIds: [],
+      reviewActionCount: 0,
+      agentPending: false,
+    });
+  }
+
+  return models;
+}
+
+function resolveIssueForScope(
+  scopeId: string,
+  workItemId: string | undefined,
+  metadata: readonly WorkflowMetadataMarkup[] | undefined,
+): IssueMetadataValue | undefined {
+  if (!metadata || metadata.length === 0) return undefined;
+  for (const entry of metadata) {
+    if (entry.metadataId !== ISSUE_METADATA_ID) continue;
+    const matchesWorkItem =
+      workItemId !== undefined &&
+      entry.workItemId !== undefined &&
+      entry.workItemId === workItemId;
+    const matchesScope =
+      entry.scopeId !== undefined && entry.scopeId === scopeId;
+    if (!matchesWorkItem && !matchesScope) continue;
+    const coerced = coerceIssueValue(entry.value);
+    if (coerced) return coerced;
+  }
+  return undefined;
+}
+
+/**
+ * Validate that a host-supplied metadata value looks like an
+ * `IssueMetadataValue`. Guards against malformed input — the card
+ * reads strongly-typed fields, so a missing severity or title must
+ * drop the issue rather than render `undefined` in the UI.
+ */
+function coerceIssueValue(
+  value: unknown,
+): IssueMetadataValue | undefined {
+  if (!value || typeof value !== "object") return undefined;
+  const candidate = value as Partial<IssueMetadataValue>;
+  if (
+    typeof candidate.issueId !== "string" ||
+    typeof candidate.topic !== "string" ||
+    typeof candidate.severity !== "string" ||
+    typeof candidate.mode !== "string" ||
+    typeof candidate.checklistState !== "string" ||
+    typeof candidate.title !== "string"
+  ) {
+    return undefined;
+  }
+  return candidate as IssueMetadataValue;
+}

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,25 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         selectionToolbarRef={selectionToolbarElementRef}
         commands={commands}
         document={documentElement}
+        onReviewSidebarTrackedChanges={onReviewSidebarTrackedChanges}
+        onReviewSidebarComments={onReviewSidebarComments}
+        onScopeModeChangeRequested={(payload) => {
+          onEventRef.current?.({
+            type: "scope-mode-change-requested",
+            documentId,
+            scopeId: payload.scopeId,
+            mode: payload.mode,
+          });
+        }}
+        onScopeIssueActionRequested={(payload) => {
+          onEventRef.current?.({
+            type: "scope-issue-action-requested",
+            documentId,
+            scopeId: payload.scopeId,
+            issueId: payload.issueId,
+            action: payload.action,
+          });
+        }}
       />
     );
   },
@@ -3453,7 +3549,7 @@ function buildTablesFacet(
 ) {
   const getCapabilities = () => {
     const snapshot = runtime.getRenderSnapshot();
-    const document = runtime.getSessionState().canonicalDocument;
+    const document = runtime.getCanonicalDocument();
     return (
       clonePublicValue(
         getTableStructureContext(
@@ -3464,6 +3560,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 +3755,19 @@ function buildTablesFacet(
       };
     },
     getCapabilities,
+    getTables,
+    getTable,
+    getTableForSelection,
+    getRenderPlan,
+    getColumnWidths,
+    getRowHeights,
+    getStyleCatalog,
+    subscribe,
   };
 }
 
+export { buildTablesFacet as __buildTablesFacet };
+
 function applyRuntimeTextCommand(
   runtime: WordReviewEditorRuntime,
   command:
@@ -3982,6 +4260,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,28 @@ 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;
+  /**
+   * Scope card mode selector fired a mode change (forwarded from the
+   * workspace).  The editor turns this into a
+   * `scope-mode-change-requested` event.
+   */
+  onScopeModeChangeRequested?: (payload: {
+    scopeId: string;
+    mode: import("../api/public-types.ts").WorkflowScopeMode;
+  }) => void;
+  /**
+   * Scope card issue action fired (forwarded from the workspace).
+   * The editor turns this into a `scope-issue-action-requested` event.
+   */
+  onScopeIssueActionRequested?: (payload: {
+    scopeId: string;
+    issueId: string;
+    action: import("../api/public-types.ts").ScopeIssueAction;
+  }) => void;
 }
 
 export function EditorShellView(props: EditorShellViewProps) {