@beyondwork/docx-react-component 1.0.37 → 1.0.39

package/src/ui/WordReviewEditor.tsx

@@ -48,6 +48,13 @@ import type {
   StyleCatalogSnapshot,
   SurfaceBlockSnapshot,
   SurfaceInlineSegment,
+  TableOp,
+  TableOpResult,
+  PublicTableEvent,
+  PublicTableRenderPlan,
+  PublicTableRowHeight,
+  PublicTableStyle,
+  PublicTableSummary,
   TrackedChangeEntrySnapshot,
   TocRefreshResult,
   UpdateFieldsResult,
@@ -113,6 +120,7 @@ import {
 import {
   applyTableStructureOperation,
   getTableStructureContext,
+  type TableStructureOperation,
 } from "../core/commands/table-structure-commands.ts";
 import {
   deleteSelectionOrBackward,
@@ -198,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,
@@ -505,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);
     },
@@ -579,6 +598,7 @@ export function __createWordReviewEditorRefBridge(
       return clonePublicValue(runtime.getRuntimeContextAnalytics(query));
     },
     layout: runtime.layout,
+    tables: buildTablesFacet(runtime, mountedSurface ?? null),
     goToNextReviewItem: () => {
       return clonePublicValue(navigateReviewQueue(runtime, "next"));
     },
@@ -638,6 +658,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       onError,
       onEvent,
       onWarning,
+      onReviewSidebarTrackedChanges,
+      onReviewSidebarComments,
       readOnly = false,
       reviewMode = "review",
       suggestionsEnabled = false,
@@ -669,6 +691,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       runtime,
       loadError,
       activeRuntime,
+      commandAppliedBridge,
       fallbackSnapshot,
       loadingSessionState,
       loadingViewState,
@@ -989,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 = {
@@ -1327,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);
         },
@@ -1394,6 +1462,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
           return clonePublicValue(activeRuntime.getRuntimeContextAnalytics(query));
         },
         layout: activeRuntime.layout,
+        tables: buildTablesFacet(activeRuntime, surfaceRef.current ?? null),
         goToNextReviewItem: () => {
           return clonePublicValue(navigateMountedReviewQueue("next"));
         },
@@ -2183,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) =>
@@ -2230,7 +2303,6 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       <EditorSurfaceController
         ref={surfaceRef}
         currentUser={currentUser}
-        ydoc={ydoc}
         awareness={awareness}
         snapshot={snapshot}
         canonicalDocument={canonicalDocument}
@@ -2256,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");
@@ -2300,6 +2382,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         activeRevisionId={activeRevisionId}
         showTrackedChanges={showTrackedChanges}
         workflowScopeSnapshot={workflowScopeSnapshot}
+        layoutFacet={activeRuntime.layout}
         interactionGuardSnapshot={interactionGuardSnapshot}
         chromePreset={effectiveChromePreset}
         chromeOptions={chromeOptions}
@@ -2348,6 +2431,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         selectionToolbarRef={selectionToolbarElementRef}
         commands={commands}
         document={documentElement}
+        onReviewSidebarTrackedChanges={onReviewSidebarTrackedChanges}
+        onReviewSidebarComments={onReviewSidebarComments}
       />
     );
   },
@@ -3388,28 +3473,19 @@ function applyRuntimeImageReposition(
 function applyRuntimeTableStructureOperation(
   runtime: WordReviewEditorRuntime,
   mountedSurface: TwProseMirrorSurfaceRef | null | undefined,
-  operation:
-    | { type: "add-row-before" }
-    | { type: "add-row-after" }
-    | { type: "add-column-before" }
-    | { type: "add-column-after" }
-    | { type: "delete-row" }
-    | { type: "delete-column" }
-    | { type: "delete-table" }
-    | { type: "merge-cells" }
-    | { type: "split-cell" }
-    | { type: "set-cell-background"; color: string },
-): void {
+  operation: TableStructureOperation,
+): { changed: boolean; coercedReason: string | null } {
   if (isSelectionSuggesting(runtime)) {
+    const coercedReason = `Table operation "${operation.type}" is not supported in suggesting mode.`;
     runtime.emitBlockedCommand(`table.${operation.type}`, [{
       code: "unsupported_surface",
-      message: `Table operation "${operation.type}" is not supported in suggesting mode.`,
+      message: coercedReason,
     }]);
-    return;
+    return { changed: false, coercedReason };
   }
   const context = getStoryMutationContext(runtime, `table.${operation.type}`);
   if (!context) {
-    return;
+    return { changed: false, coercedReason: "No active mutation context." };
   }
 
   const result = applyTableStructureOperation(
@@ -3419,8 +3495,262 @@ function applyRuntimeTableStructureOperation(
     operation,
   );
   dispatchStoryMutationResult(runtime, context, result, context.timestamp);
+  return {
+    changed: result.changed,
+    coercedReason: result.changed ? null : "Op was a no-op against the active selection.",
+  };
+}
+
+/**
+ * Translate a public-API `TableOp` (kebab-case `kind` discriminator) to
+ * the internal `TableStructureOperation` (`type` discriminator). The
+ * shape values are identical aside from the discriminator name.
+ */
+export function __publicTableOpToInternal(op: TableOp): TableStructureOperation {
+  return publicTableOpToInternal(op);
+}
+
+function publicTableOpToInternal(op: TableOp): TableStructureOperation {
+  const { kind, ...rest } = op as { kind: string } & Record<string, unknown>;
+  if (kind === "insert") {
+    throw new Error(
+      "TableOp kind \"insert\" is not routed through ref.tables.apply; use ref.insertTable(...).",
+    );
+  }
+  return { type: kind, ...rest } as TableStructureOperation;
+}
+
+/**
+ * Build the `ref.tables` facet: a typed dispatch boundary + capability
+ * read. Delegates every op through the same `applyRuntimeTableStructureOperation`
+ * helper the flat ref verbs use, so there is exactly one server-side path
+ * for every table mutation.
+ */
+function buildTablesFacet(
+  runtime: WordReviewEditorRuntime,
+  mountedSurface: TwProseMirrorSurfaceRef | null,
+) {
+  const getCapabilities = () => {
+    const snapshot = runtime.getRenderSnapshot();
+    const document = runtime.getCanonicalDocument();
+    return (
+      clonePublicValue(
+        getTableStructureContext(
+          document,
+          snapshot,
+          mountedSurface?.getTableSelection() ?? null,
+        ),
+      ) ?? 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") {
+        applyRuntimeInsertTable(runtime, { rows: op.rows, columns: op.columns });
+        return {
+          changed: true,
+          coercedReason: null,
+          capabilities: getCapabilities(),
+        };
+      }
+      const internal = publicTableOpToInternal(op);
+      const outcome = applyRuntimeTableStructureOperation(
+        runtime,
+        mountedSurface,
+        internal,
+      );
+      return {
+        changed: outcome.changed,
+        coercedReason: outcome.coercedReason,
+        capabilities: getCapabilities(),
+      };
+    },
+    getCapabilities,
+    getTables,
+    getTable,
+    getTableForSelection,
+    getRenderPlan,
+    getColumnWidths,
+    getRowHeights,
+    getStyleCatalog,
+    subscribe,
+  };
 }
 
+export { buildTablesFacet as __buildTablesFacet };
+
 function applyRuntimeTextCommand(
   runtime: WordReviewEditorRuntime,
   command:
@@ -3913,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

@@ -55,6 +55,12 @@ export interface EditorShellViewProps {
   activeRevisionId?: string;
   showTrackedChanges: boolean;
   workflowScopeSnapshot?: WorkflowScopeSnapshot | null;
+  /**
+   * Runtime-owned layout facet passed through to the workspace so the
+   * ChromeOverlay (scope rail, workflow dock, etc.) can render over the
+   * document column and the review rail's Workflow tab can read segments.
+   */
+  layoutFacet?: import("../runtime/layout/index.ts").WordReviewEditorLayoutFacet;
   interactionGuardSnapshot?: InteractionGuardSnapshot;
   chromePreset?: WordReviewEditorChromePreset;
   chromeOptions?: Partial<WordReviewEditorChromeOptions>;
@@ -77,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<