@beyondwork/docx-react-component 1.0.66 → 1.0.69

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

@@ -0,0 +1,59 @@
+import React from "react";
+
+import { TwReviewRail, type TwReviewRailProps } from "../review/tw-review-rail";
+
+/**
+ * Rail slot for `TwReviewWorkspace`.  Three postures:
+ *
+ *   - `docked`  — render the rail inline as a sibling of the document
+ *     column (standard desktop width).
+ *   - `drawer`  — render the rail behind a dismiss-overlay button so the
+ *     narrow-viewport scrim can close it.
+ *   - `hidden`  — render nothing (the parent already decided the rail
+ *     is off).
+ *
+ * All TwReviewRailProps except `variant` are forwarded verbatim through
+ * `rail`; the wrapper owns the `variant` slot so the parent doesn't have
+ * to branch twice on posture.
+ */
+export type TwReviewWorkspaceRailMode = "docked" | "drawer" | "hidden";
+
+export interface TwReviewWorkspaceRailProps {
+  mode: TwReviewWorkspaceRailMode;
+  /** Fires when the drawer scrim is clicked.  Ignored in docked posture. */
+  onDrawerClose: () => void;
+  /**
+   * Plain rail props minus `variant` — the wrapper owns the variant
+   * slot so callers pass one bag regardless of posture.
+   */
+  rail: Omit<TwReviewRailProps, "variant">;
+}
+
+export function TwReviewWorkspaceRail({
+  mode,
+  onDrawerClose,
+  rail,
+}: TwReviewWorkspaceRailProps): React.ReactElement | null {
+  if (mode === "hidden") return null;
+
+  if (mode === "docked") {
+    return <TwReviewRail {...rail} />;
+  }
+
+  return (
+    <div
+      className="pointer-events-none absolute inset-0 z-30 flex justify-end"
+      data-testid="review-rail-drawer"
+    >
+      <button
+        type="button"
+        aria-label="Close sidebar overlay"
+        className="pointer-events-auto absolute inset-0 border-0 bg-[color:rgba(21,26,23,0.08)] dark:bg-[color:rgba(0,0,0,0.32)]"
+        onClick={onDrawerClose}
+      />
+      <div className="pointer-events-auto relative h-full">
+        <TwReviewRail variant="drawer" {...rail} />
+      </div>
+    </div>
+  );
+}

package/src/ui-tailwind/review-workspace/types.ts

@@ -0,0 +1,408 @@
+import type { FocusEventHandler, ReactNode, Ref } from "react";
+
+import type {
+  ActiveListContext,
+  CommentSidebarThreadSnapshot,
+  DocumentNavigationSnapshot,
+  EditorAnchorProjection,
+  EditorStoryTarget,
+  EditorViewStateSnapshot,
+  FormattingStateSnapshot,
+  FormattingAlignment,
+  HeaderFooterLinkPatch,
+  InteractionGuardSnapshot,
+  InsertImageOptions,
+  RuntimeContextAnalyticsSnapshot,
+  RuntimeRenderSnapshot,
+  ReviewQueueSnapshot,
+  SectionPageNumberingPatch,
+  SectionBreakType,
+  StyleCatalogSnapshot,
+  TrackedChangeEntrySnapshot,
+  WordReviewEditorChromeOptions,
+  WordReviewEditorChromePreset,
+  WordReviewEditorChromeVisibility,
+  WorkflowScopeSnapshot,
+  WorkspaceMode,
+  ZoomLevel,
+} from "../../api/public-types";
+import type { SessionCapabilities } from "../../api/public-types";
+import type {
+  ActiveSelectionToolModel,
+  SelectionToolAnchor,
+} from "../../ui/headless/selection-tool-types";
+import type { MarkupDisplay } from "../../ui/headless/comment-decoration-model";
+import type { EditorCommandBag } from "../../ui/editor-command-bag.ts";
+import type { EditorActionHostCallbacks } from "../chrome/editor-action-registry";
+import type { TwWorkspaceChromeHostController } from "../chrome/tw-workspace-chrome-host";
+import type { MediaPreviewDescriptor } from "../editor-surface/pm-state-from-snapshot.ts";
+import type { ReviewRailTab } from "../review/tw-review-rail";
+
+export type ReviewWorkspaceChromeVisibility = WordReviewEditorChromeVisibility;
+
+export interface TwReviewWorkspaceProps {
+  snapshot: RuntimeRenderSnapshot;
+  viewState: EditorViewStateSnapshot;
+  markupDisplay: MarkupDisplay;
+  currentUserId?: string;
+  capabilities?: SessionCapabilities;
+  mediaPreviews?: Record<string, MediaPreviewDescriptor>;
+  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;
+  /**
+   * Layer-05 geometry facet (`runtime.geometry`). Required by chrome
+   * overlay layers (scope rail, object selection, table grip, page-break
+   * decorations) after refactor/05 cross-lane-coord §8.4 migration.
+   * Reads render-frame + zoom through the geometry layer instead of
+   * through the now-`@deprecated` `layoutFacet.getRenderFrame` /
+   * `.getRenderZoom` methods.
+   */
+  geometryFacet?: import("../../runtime/geometry/index.ts").GeometryFacet;
+  /**
+   * Layer-06 workflow facet — canonical source of scope rail segments
+   * and scope card models (`runtime.workflow`). Required by the scope
+   * rail + scope card chrome layers after Slice 4's seam inversion
+   * removed those methods from `WordReviewEditorLayoutFacet`. When
+   * absent, those layers render nothing.
+   */
+  workflowFacet?: import("../../runtime/workflow/rail/types.ts").WorkflowFacet;
+  /**
+   * Optional shell header override.  Mounted above the formatting toolbar.
+   *
+   * Per docs/plans/chrome-composition-audit.md §2.4 the shell is always
+   * present in default composition.  When this prop is omitted the
+   * workspace mounts a default `<TwShellHeader />` with the 4-mode
+   * switcher (edit / review / workflow / more) so mode authority is
+   * always visible and centralized.
+   *
+   * Hosts that need a custom brand, mode handlers, or primary CTA pass a
+   * pre-assembled `<TwShellHeader />` here; the custom node replaces the
+   * default entirely.
+   */
+  shellHeader?: ReactNode;
+  /**
+   * Phase C.γ.3 — workspace-level chrome surfaces (right-click context
+   * menu + Ctrl/Cmd+K command palette).  When supplied, the workspace
+   * mounts `TwWorkspaceChromeHost` which consumes the shared
+   * editor-action-registry so right-click, inline "More…", and
+   * command-palette all dispatch the same actions
+   * (DESIGN-EDITOR.md §6.4).
+   *
+   * Actions without a wired callback are hidden from every surface —
+   * progressive disclosure per designsystem.md §2.1 principle 4.
+   *
+   * Omit to keep the pre-Phase-C workspace behavior (no right-click
+   * menu, no palette).
+   */
+  editorActionHost?: EditorActionHostCallbacks;
+  /**
+   * Forward ref for the workspace's chrome controller.  The runtime
+   * boundary (`editor-runtime-boundary.ts`) wires this to the
+   * `onContextMenuRequested` callback on the PM command bridge so a
+   * native `contextmenu` event opens the menu at the click coordinates.
+   *
+   * Also consumed by Phase D's inline "More…" buttons on demoted
+   * floating toolbars: the toolbar calls
+   * `chromeControllerRef.current?.openWithKinds({ kinds: ["table-cell"], … })`
+   * and reuses the same registry as right-click.
+   */
+  chromeControllerRef?: React.Ref<TwWorkspaceChromeHostController>;
+  /**
+   * Suppress the global Ctrl/Cmd+K palette listener — e.g. when a
+   * higher-priority modal captures keyboard focus.
+   */
+  commandPaletteDisabled?: boolean;
+  /**
+   * 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;
+  formattingState?: FormattingStateSnapshot;
+  activeListContext?: ActiveListContext | null;
+  styleCatalog?: StyleCatalogSnapshot;
+  activeRailTab: ReviewRailTab;
+  activeCommentId?: string;
+  activeRevisionId?: string;
+  showTrackedChanges: boolean;
+  workflowScopeSnapshot?: WorkflowScopeSnapshot | null;
+  interactionGuardSnapshot?: InteractionGuardSnapshot;
+  chromePreset?: WordReviewEditorChromePreset;
+  chromeOptions?: Partial<WordReviewEditorChromeOptions>;
+  /** P9g — live collab session for the `"collab"` chrome preset's top nav. */
+  collabSession?: import("../../runtime/collab-session.ts").CollabSession;
+  collabTransportStatus?: import("../../api/awareness-identity-types.ts").TransportStatus;
+  collabActorId?: string;
+  collabSendBaseline?: {
+    originDocumentId: string;
+    originPayloadId: string;
+    originContentHash: string;
+    payloadXml: string;
+  };
+  reviewQueue?: ReviewQueueSnapshot;
+  documentContextAnalytics?: RuntimeContextAnalyticsSnapshot | null;
+  selectionContextAnalytics?: RuntimeContextAnalyticsSnapshot | null;
+  currentScopeContextAnalytics?: RuntimeContextAnalyticsSnapshot | null;
+  commands: EditorCommandBag;
+  onActivateFloatingImage?: (payload: {
+    mediaId: string;
+    from: number;
+    to: number;
+    storyTarget: EditorStoryTarget;
+  }) => void;
+  /** N6 — release the grabbed image/shape. Wired to `runtime.deselectObject()` by the host. */
+  onDeselectObject?: () => void;
+  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;
+  onShowTrackedChangesChange?: (show: boolean) => void;
+  onUndo?: () => void;
+  onRedo?: () => void;
+  onSetParagraphStyle?: (styleId: string) => void;
+  onToggleBold?: () => void;
+  onToggleItalic?: () => void;
+  onToggleUnderline?: () => void;
+  onSetSelectionTextColor?: (color: string) => void;
+  onSetSelectionHighlightColor?: (color: string | null) => void;
+  onToggleStrikethrough?: () => void;
+  onToggleSuperscript?: () => void;
+  onToggleSubscript?: () => void;
+  onSetFontFamily?: (fontFamily: string) => void;
+  onSetFontSize?: (fontSize: number) => void;
+  onSetTextColor?: (color: string) => void;
+  onSetHighlightColor?: (color: string | null) => void;
+  onSetAlignment?: (alignment: FormattingAlignment) => void;
+  onToggleBulletedList?: () => void;
+  onToggleNumberedList?: () => void;
+  onOutdent?: () => void;
+  onIndent?: () => void;
+  onAddComment?: () => void;
+  onInsertPageBreak?: () => void;
+  onInsertTable?: () => void;
+  onInsertSectionBreak?: (type: SectionBreakType) => void;
+  onInsertImage?: (options: InsertImageOptions) => void;
+  onSetTableStyle?: (styleId: string) => void;
+  onAddRowBefore?: () => void;
+  onAddRowAfter?: () => void;
+  onAddColumnBefore?: () => void;
+  onAddColumnAfter?: () => void;
+  onDeleteRow?: () => void;
+  onDeleteColumn?: () => void;
+  onDeleteTable?: () => void;
+  onMergeCells?: () => void;
+  onSplitCell?: () => void;
+  onSetCellBackground?: (color: string) => void;
+  onSetImageLayout?: (
+    mediaId: string,
+    dimensions: { widthEmu: number; heightEmu: number },
+  ) => void;
+  onSetImageFrame?: (
+    mediaId: string,
+    offsets: { horizontalOffsetEmu?: number; verticalOffsetEmu?: number },
+  ) => void;
+  onDeleteSectionBreak?: (sectionIndex: number) => void;
+  onUpdateSectionLayout?: (
+    sectionIndex: number,
+    patch: {
+      pageSize?: { width?: number; height?: number; orientation?: "portrait" | "landscape" };
+      pageMargins?: {
+        top?: number;
+        right?: number;
+        bottom?: number;
+        left?: number;
+        header?: number;
+        footer?: number;
+        gutter?: number;
+      };
+      columns?: {
+        count?: number;
+        space?: number;
+        equalWidth?: boolean;
+        columns?: Array<{ width: number; space?: number }>;
+        separator?: boolean;
+      };
+      titlePage?: boolean;
+      sectionType?: SectionBreakType;
+    },
+  ) => void;
+  onSetSectionPageNumbering?: (
+    sectionIndex: number,
+    patch: SectionPageNumberingPatch | null,
+  ) => void;
+  onSetHeaderFooterLink?: (
+    sectionIndex: number,
+    patch: HeaderFooterLinkPatch,
+  ) => void;
+  onAddCommentFromSelection?: () => void;
+  onExport?: () => void;
+  onDismissSelectionToolbar?: () => void;
+  onAcceptSuggestion?: () => void;
+  onRejectSuggestion?: () => void;
+  onEditSuggestion?: () => void;
+  onAddCommentFromSuggestion?: () => void;
+  onSelectionToolbarFocusCapture?: FocusEventHandler<HTMLDivElement>;
+  onSelectionToolbarBlurCapture?: FocusEventHandler<HTMLDivElement>;
+  selectionToolbarRef?: Ref<HTMLDivElement>;
+  onOpenComment?: (thread: CommentSidebarThreadSnapshot) => void;
+  onResolveComment?: (commentId: string) => void;
+  onReopenComment?: (commentId: string) => void;
+  onAddReply?: (commentId: string, body: string) => void;
+  onEditBody?: (commentId: string, body: string) => void;
+  onOpenRevision?: (revision: TrackedChangeEntrySnapshot) => void;
+  onAcceptRevision?: (revisionId: string) => void;
+  onRejectRevision?: (revisionId: string) => void;
+  onAcceptAllChanges?: () => void;
+  onRejectAllChanges?: () => void;
+  onCloseStory?: () => void;
+  /**
+   * @deprecated P8.11 — the workspace no longer renders a workspace-level
+   * header band with an "Edit header" button; per-page header bands route
+   * clicks via `onOpenStory` / `runtime.openStory` directly.  The prop
+   * remains optional for one release so existing hosts continue to
+   * compile; supplying it emits a `console.warn` on mount.
+   */
+  onOpenHeaderStory?: () => void;
+  /**
+   * @deprecated P8.11 — see `onOpenHeaderStory`.  Footer variant of the
+   * same deprecation.
+   */
+  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;
+  /**
+   * P8.11 — fired when a per-page chrome band (header / footer) is
+   * clicked to promote it into the active editing surface.  Wire to
+   * `runtime.openStory(target)`; the chrome layer's portal mechanism
+   * then reparents the PM surface into the matching band's active slot.
+   */
+  onOpenStory?: (target: EditorStoryTarget) => void;
+  onSetParagraphIndentation?: (indentation: {
+    left?: number;
+    right?: number;
+    firstLine?: number;
+    hanging?: number;
+  }) => void;
+  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;
+  /**
+   * Scope card mode selector fired a mode change.  Wire to the host's
+   * existing overlay-apply path (or an equivalent CCEP workflow
+   * endpoint).  The card never mutates runtime state directly.
+   */
+  onScopeModeChangeRequested?: (payload: {
+    scopeId: string;
+    mode: import("../../api/public-types.ts").WorkflowScopeMode;
+  }) => void;
+  /**
+   * Scope card issue row fired an action (resolve/waive/escalate/
+   * acknowledge).  Host updates the attached `IssueMetadataValue`
+   * state and re-pushes via `setWorkflowMetadataEntries`.
+   */
+  onScopeIssueActionRequested?: (payload: {
+    scopeId: string;
+    issueId: string;
+    action: import("../../api/public-types.ts").ScopeIssueAction;
+  }) => void;
+  /**
+   * R3 — scope card suggestion-group accept button fired.  WordReview-
+   * Editor relays to `ref.acceptSuggestionGroup(groupId)` which fans
+   * out to individual `acceptChange` calls across the group members.
+   */
+  onScopeAcceptSuggestionGroup?: (payload: {
+    scopeId: string;
+    groupId: string;
+  }) => void;
+  /** R3 — scope card suggestion-group reject. */
+  onScopeRejectSuggestionGroup?: (payload: {
+    scopeId: string;
+    groupId: string;
+  }) => void;
+  /**
+   * K2 — scope card "Ask review agent" fired.  WordReviewEditor emits
+   * `agent-on-selection-requested` via WordReviewEditorEvent.
+   */
+  onScopeAskAgent?: (payload: {
+    scopeId: string;
+    anchor?: EditorAnchorProjection;
+  }) => void;
+  /**
+   * P3 — optional scope-tag editor slot rendered inside the scope
+   * card when `editorRole === "workflow"`.  Hosts pass a chip picker,
+   * free-text input, or whatever authoring surface they want.  Unset
+   * in editor/review roles.
+   */
+  scopeCardScopeTagEditor?: ReactNode;
+}

package/src/ui-tailwind/review-workspace/use-chrome-policy.ts

@@ -0,0 +1,104 @@
+import { useMemo } from "react";
+
+import type {
+  ActiveListContext,
+  EditorViewStateSnapshot,
+  InteractionGuardSnapshot,
+  WordReviewEditorChromePreset,
+  WorkflowScopeSnapshot,
+} from "../../api/public-types";
+import { resolveResponsiveChromeState } from "../chrome/responsive-chrome";
+import { resolveScopedChromePolicy } from "../../ui/headless/scoped-chrome-policy";
+import type { SessionCapabilities } from "../../api/public-types";
+import type { ToolbarInteractionPolicy } from "../toolbar/tw-toolbar";
+
+export interface UseChromePolicyOptions {
+  viewportWidth: number | undefined;
+  reviewRailAvailable: boolean;
+  reviewRailOpen: boolean;
+  chromePreset: WordReviewEditorChromePreset;
+  caps: SessionCapabilities | undefined;
+  interactionGuardSnapshot: InteractionGuardSnapshot | undefined;
+  workflowScopeSnapshot: WorkflowScopeSnapshot | null | undefined;
+  activeListContext: ActiveListContext | null | undefined;
+  role: EditorViewStateSnapshot["editorRole"];
+  hasSidebarPanelAccess: boolean;
+  effectiveSelectionMode: ToolbarInteractionPolicy["mode"];
+}
+
+export interface ChromePolicy {
+  responsiveChrome: ReturnType<typeof resolveResponsiveChromeState>;
+  scopedChromePolicy: ReturnType<typeof resolveScopedChromePolicy>;
+  toolbarInteractionPolicy: ToolbarInteractionPolicy | undefined;
+}
+
+/**
+ * Memoize the two compositional chrome-policy resolvers and derive the
+ * toolbar interaction policy. Bundled because `scopedChromePolicy`
+ * depends on `responsiveChrome.isNarrow`, and the toolbar policy depends
+ * on both `caps` and `effectiveSelectionMode` which flow through the
+ * same input set.
+ */
+export function useChromePolicy(options: UseChromePolicyOptions): ChromePolicy {
+  const {
+    viewportWidth,
+    reviewRailAvailable,
+    reviewRailOpen,
+    chromePreset,
+    caps,
+    interactionGuardSnapshot,
+    workflowScopeSnapshot,
+    activeListContext,
+    role,
+    hasSidebarPanelAccess,
+    effectiveSelectionMode,
+  } = options;
+
+  const responsiveChrome = useMemo(
+    () =>
+      resolveResponsiveChromeState({
+        viewportWidth,
+        reviewRailAvailable,
+        reviewRailOpen,
+      }),
+    [reviewRailAvailable, reviewRailOpen, viewportWidth],
+  );
+
+  const scopedChromePolicy = useMemo(
+    () =>
+      resolveScopedChromePolicy({
+        preset: chromePreset,
+        compactMode: responsiveChrome.isNarrow,
+        capabilities: caps,
+        interactionGuardSnapshot,
+        workflowScopeSnapshot,
+        activeListContext,
+        role,
+        hasSidebarPanelAccess,
+      }),
+    [
+      caps,
+      chromePreset,
+      hasSidebarPanelAccess,
+      activeListContext,
+      interactionGuardSnapshot,
+      workflowScopeSnapshot,
+      responsiveChrome.isNarrow,
+      role,
+    ],
+  );
+
+  const toolbarInteractionPolicy: ToolbarInteractionPolicy | undefined = caps
+    ? {
+        mode: effectiveSelectionMode,
+        canFormatText: caps.canEdit && effectiveSelectionMode === "edit",
+        canInsertStructural: caps.canEdit && effectiveSelectionMode === "edit",
+        canAddComment:
+          caps.canAddComment &&
+          effectiveSelectionMode !== "view" &&
+          effectiveSelectionMode !== "blocked",
+      }
+    : undefined;
+
+  return { responsiveChrome, scopedChromePolicy, toolbarInteractionPolicy };
+}