@beyondwork/docx-react-component 1.0.66 → 1.0.69

package/src/ui/WordReviewEditor.tsx

@@ -85,83 +85,53 @@ import {
   persistedSnapshotFromEditorSessionState,
 } from "../api/session-state.ts";
 import {
-  createDetachedAnchor,
-  createNodeAnchor,
-  createRangeAnchor,
   storyTargetsEqual,
-  type TransactionMapping,
-} from "../core/selection/mapping.ts";
-import {
-  applyFormattingOperationToDocument,
   getFormattingStateFromRenderSnapshot,
-} from "../core/commands/formatting-commands.ts";
-import {
-  applyParagraphStyleToDocument,
-  applyTableStyleToDocument,
-} from "../core/commands/style-commands.ts";
-import {
-  continueNumbering as continueListNumbering,
-  restartNumbering as restartListNumbering,
-  toggleBulletedList,
-  toggleNumberedList,
-} from "../core/commands/list-commands.ts";
-import {
   dispatchTextCommand,
-  type DispatchContext,
   type DispatchTextCommand,
-} from "../runtime/edit-dispatch/index.ts";
-import {
-  resolveActiveParagraphIndex,
-  setActiveParagraphIndentation,
-  setActiveParagraphTabStops,
-} from "../core/commands/paragraph-layout-commands.ts";
-import {
-  deleteSectionBreakAtSectionIndex,
-  insertSectionBreakAfterSectionIndex,
-  setHeaderFooterLinkAtSectionIndex,
-  setSectionPageNumberingAtSectionIndex,
-  updateSectionLayoutAtSectionIndex,
-} from "../core/commands/section-layout-commands.ts";
-import {
-  insertImage as insertImageInDocument,
-  resizeImage as resizeImageInCatalog,
-  repositionFloatingImage as repositionFloatingImageInDocument,
-} from "../core/commands/image-commands.ts";
-import {
-  applyTableStructureOperation,
   getTableStructureContext,
-  type TableStructureOperation,
-} from "../core/commands/table-structure-commands.ts";
-import {
-  deleteSelectionOrBackward,
-  deleteSelectionOrForward,
-  insertHardBreak as insertHardBreakInDocument,
-  insertPageBreak as insertPageBreakInDocument,
-  insertTab as insertTabInDocument,
-  insertText as insertTextInDocument,
-  insertTable as insertTableInDocument,
-  splitParagraph as splitParagraphInDocument,
-} from "../core/commands/text-commands.ts";
-import { type SelectionSnapshot as InternalSelectionSnapshot } from "../core/state/editor-state.ts";
-import {
   getStoryBlocks,
-  replaceStoryBlocks,
-} from "../runtime/story-targeting.ts";
+} from "../shell/ref-utilities.ts";
 import {
-  decodePersistedSourcePackageBytes,
-  hasValidPersistedSourcePackageDigest,
-} from "../io/source-package-provenance.ts";
-import { readOpcPackage } from "../io/opc/package-reader.ts";
-import { deriveCapabilities } from "../runtime/session-capabilities";
-import { findTextMatches, searchDocument } from "../runtime/document-search.ts";
+  DISPATCH_CONTEXT,
+  applyRuntimeDeleteComment,
+  applyRuntimeDeleteSectionBreak,
+  applyRuntimeFormattingOperation,
+  applyRuntimeImageReposition,
+  applyRuntimeImageResize,
+  applyRuntimeInsertImage,
+  applyRuntimeInsertPageBreak,
+  applyRuntimeInsertSectionBreak,
+  applyRuntimeInsertTable,
+  applyRuntimeListToggle,
+  applyRuntimeNumberingFlow,
+  applyRuntimeParagraphIndentation,
+  applyRuntimeParagraphStyle,
+  applyRuntimeParagraphTabStops,
+  applyRuntimeSelection,
+  applyRuntimeSetHeaderFooterLink,
+  applyRuntimeSetSectionPageNumbering,
+  applyRuntimeTableStructureOperation,
+  applyRuntimeTableStyle,
+  applyRuntimeUpdateSectionLayout,
+  applySuggestionGroupAction,
+  createCollapsedPublicSelection,
+  createSelectionFromAnchor,
+  getRuntimeStyleCatalog,
+  normalizeRequestedSelection,
+  publicTableOpToInternal,
+  toRuntimeSelectionSnapshot,
+  type TableStructureOperation,
+} from "../shell/ref-commands.ts";
+import { buildMediaPreviews } from "../shell/media-previews.ts";
 import {
+  deriveCapabilities,
   resolveCurrentContextAnalyticsQuery,
   runtimeContextAnalyticsSnapshotsEqual,
-} from "../runtime/context-analytics.ts";
-import {
   createEditorViewStateSnapshot,
   createViewState,
-} from "../runtime/view-state.ts";
+} from "../shell/ref-utilities.ts";
+import { findTextMatchesForRuntime, searchRuntimeDocument } from "../shell/search.ts";
 import {
   type TwProseMirrorSurfaceRef,
 } from "../ui-tailwind/editor-surface/tw-prosemirror-surface";
@@ -207,35 +177,77 @@ import {
   persistSession as persistSessionFromBoundary,
   rejectExportWhileLoading as rejectExportWhileLoadingFromBoundary,
   useEditorRuntimeBoundary,
-} from "./editor-runtime-boundary.ts";
+} from "../shell/session-bootstrap.ts";
 import {
   downloadExportResult,
   withExportDelivery,
 } from "./browser-export";
 import { EditorShellView } from "./editor-shell-view.tsx";
+import { TwDebugPresentation } from "../ui-tailwind/debug/index.ts";
+import { shellPasteFragmentParser as SHELL_PASTE_FRAGMENT_PARSER } from "../shell/paste-adapter.ts";
 import { EditorSurfaceController } from "./editor-surface-controller.tsx";
+import type { TwWorkspaceChromeHostController } from "../ui-tailwind/chrome/tw-workspace-chrome-host";
 import {
   resolveChromePreset,
   resolveChromeVisibilityForPreset,
-} from "../ui-tailwind/chrome/chrome-preset-model.ts";
+} from "../api/v3/ui/chrome-preset-model.ts";
 import { TwRuntimeReplDialog } from "../ui-tailwind/chrome/tw-runtime-repl-dialog.tsx";
-import { createRuntimeCollabSync } from "../runtime/collab/runtime-collab-sync.ts";
 import {
-  clearLocalCursorState,
-  getCursorColorForUser,
-  setLocalCursorState,
-} from "../runtime/collab/remote-cursor-awareness.ts";
+  useRemoteCursorPublish,
+  useRuntimeCollabSync,
+} from "../shell/use-collab-sync.ts";
+import {
+  collectChartSnapshots,
+  lookupChartSnapshot,
+} from "../shell/chart-snapshots.ts";
+import { wrapRefForTelemetry } from "../shell/ref-utilities.ts";
+import { createApiV3, type ApiV3 } from "../api/v3/index.ts";
+import { UiApiProvider } from "../ui-tailwind/ui-api-context.tsx";
+import {
+  UiShellChannelsProvider,
+  type UiShellChannels,
+} from "../ui-tailwind/ui-shell-channels-context.tsx";
+import { OverlayAnchorBridgeProvider } from "../ui-tailwind/overlay-anchor-bridge-context.tsx";
 import {
-  stableChartId,
-} from "../runtime/chart/chart-model-store.ts";
+  createShellOverlayAnchorBridge,
+  type ShellOverlayAnchorBridge,
+} from "../shell/overlay-anchor-bridge.ts";
 import {
-  projectChartSnapshot,
-} from "../runtime/chart/chart-snapshot.ts";
+  createUiSubscriberChannel,
+  type UiSubscriberChannel,
+} from "../shell/ui-subscriber-channels.ts";
+import {
+  deriveShellPinnedSurfaces,
+  makeShellUiControllerFactory,
+  shellUiControllerFactory,
+} from "./ui-controller-factory.ts";
+import type {
+  ChromeHostPosture,
+  ChromePosture,
+  OverlayAnchorQuery,
+  ViewportState,
+} from "../api/v3/ui/_types.ts";
 
 export {
   __createFallbackRuntime,
   __resolveWordReviewEditorSource,
-} from "./editor-runtime-boundary.ts";
+} from "../shell/session-bootstrap.ts";
+
+/**
+ * Map a host-facing `markupDisplay` prop value to the narrow
+ * `ChromeMarkupDisplay` enum on `ChromeHostPosture` (`"final" | "markup"
+ * | "original"`). Prop shape is richer for legacy reasons; `ui.chrome.
+ * getPosture` normalizes to the narrow enum.
+ */
+function normalizeHostMarkupDisplay(
+  raw: WordReviewEditorProps["markupDisplay"],
+): ChromeHostPosture["markupDisplay"] | undefined {
+  if (raw === undefined) return undefined;
+  if (raw === "original") return "original";
+  if (raw === "no-markup" || raw === "clean") return "final";
+  // "all-markup" | "simple-markup" | "simple" | "all" → markup
+  return "markup";
+}
 
 const VISUALLY_HIDDEN_STYLES: React.CSSProperties = {
   position: "absolute",
@@ -249,21 +261,6 @@ const VISUALLY_HIDDEN_STYLES: React.CSSProperties = {
   border: 0,
 };
 
-const BROWSER_SAFE_PREVIEW_TYPES = new Set([
-  "image/png",
-  "image/jpeg",
-  "image/jpg",
-  "image/gif",
-  "image/webp",
-  "image/bmp",
-  // SVG is served through `<img src="data:image/svg+xml;base64,...">` by
-  // `createImageDataUrl`. Chromium sandboxes SVGs loaded via <img> — scripts
-  // don't execute, external references are blocked, XSS surface matches PNG.
-  // Needed for docs/plans/lane-5-charts.md Stage 0B synthesized chart previews and
-  // any host that ships .svg inside `word/media/` as a logo or figure.
-  "image/svg+xml",
-]);
-
 const ACCESSIBLE_REGION_ORDER = [
   "toolbar",
   "document",
@@ -280,279 +277,26 @@ type SelectionToolbarDismissReason =
   | "escape";
 
 // ---------------------------------------------------------------------------
-// P17 module-level helpers — metadata persistence
+// P17 metadata persistence — imported from Layer 06
+//
+// The conflict-key function, persistence-mode cascade, pending-conflict
+// type, conflict emitter, and internal/external conversion routines used
+// to live in this file as ~200 lines of UI-layer code. They had no UI
+// dependencies — they operated on the runtime's workflow metadata
+// snapshot + a host-supplied resolver — so Layer-06 Slice 4 moved them
+// to `src/runtime/workflow/metadata-persistence.ts` (W9-purity
+// compliant). The UI now delegates via the imports below.
 // ---------------------------------------------------------------------------
 
-function conflictKey(input: {
-  scopeId?: string;
-  entryId?: string;
-  fieldKey?: string;
-}): string {
-  return `${input.scopeId ?? ""}|${input.entryId ?? ""}|${input.fieldKey ?? ""}`;
-}
-
-function resolveEffective(input: {
-  overlay?: MetadataPersistenceMode;
-  scope?: ScopeMetadataPersistence;
-  field?: ScopeMetadataPersistence;
-}): "internal" | "external" {
-  if (input.field === "internal" || input.field === "external") return input.field;
-  if (input.scope === "internal" || input.scope === "external") return input.scope;
-  return input.overlay ?? "internal";
-}
-
-/**
- * A pending conflict record held in `metadataConflictPendingRef` while
- * the host decides how to resolve.  Keyed by `conflictKey(...)`.
- */
-interface PendingConflict {
-  scopeId?: string;
-  entryId?: string;
-  fieldKey?: string;
-  embedded: { value?: Record<string, unknown>; version?: number } | null;
-  external: { value?: Record<string, unknown>; version?: number } | null;
-  defaultPolicy: "prefer-latest";
-}
-
-/** Emit a single `metadata_conflict_detected` event and register the pending conflict. */
-function registerAndEmitConflict(args: {
-  onEvent: ((event: WordReviewEditorEvent) => void) | undefined;
-  documentId: string;
-  conflict: PendingConflict;
-  pendingConflicts: Map<string, PendingConflict>;
-}): void {
-  const key = conflictKey(args.conflict);
-  // Guard: do not emit duplicate events for the same key in a single pass.
-  if (args.pendingConflicts.has(key)) return;
-  args.pendingConflicts.set(key, args.conflict);
-  args.onEvent?.({
-    type: "metadata_conflict_detected",
-    documentId: args.documentId,
-    scopeId: args.conflict.scopeId,
-    entryId: args.conflict.entryId,
-    fieldKey: args.conflict.fieldKey,
-    embedded: args.conflict.embedded,
-    external: args.conflict.external,
-    defaultPolicy: args.conflict.defaultPolicy,
-  });
-}
-
-async function runConvertScopesToInternal(args: {
-  runtime: WordReviewEditorRuntime;
-  scopeIds: string[];
-  resolver: ScopeMetadataResolver | null;
-  /** When provided, version mismatches emit `metadata_conflict_detected`. */
-  documentId?: string;
-  onEvent?: (event: WordReviewEditorEvent) => void;
-  pendingConflicts?: Map<string, PendingConflict>;
-}): Promise<void> {
-  if (!args.resolver) throw new MetadataResolverMissingError();
-  const snapshot = args.runtime.getWorkflowMetadataSnapshot();
-  const overlay = args.runtime.getWorkflowOverlay();
-
-  const nextEntries = await Promise.all(
-    snapshot.entries.map(async (entry) => {
-      if (!entry.scopeId || !args.scopeIds.includes(entry.scopeId)) return entry;
-      const scope = overlay?.scopes.find((s) => s.scopeId === entry.scopeId);
-      const effective = resolveEffective({
-        overlay: overlay?.metadataPersistence,
-        scope: scope?.metadataPersistence,
-        field: entry.metadataPersistence,
-      });
-      if (effective !== "external" || !entry.storageRef) return entry;
-      const resolved = await args.resolver!.resolve(entry.storageRef);
-      if (!resolved) return entry;
-
-      // Conflict detection: compare embedded metadataVersion vs resolver version.
-      if (
-        args.pendingConflicts &&
-        args.documentId !== undefined &&
-        entry.metadataVersion !== undefined &&
-        resolved.version !== undefined &&
-        entry.metadataVersion !== resolved.version
-      ) {
-        registerAndEmitConflict({
-          onEvent: args.onEvent,
-          documentId: args.documentId,
-          pendingConflicts: args.pendingConflicts,
-          conflict: {
-            scopeId: entry.scopeId,
-            entryId: entry.entryId,
-            // External entries have no inline value; embedded side carries version only.
-            embedded: { version: entry.metadataVersion },
-            external: { value: resolved.value, version: resolved.version },
-            defaultPolicy: "prefer-latest",
-          },
-        });
-      }
-
-      // Default behavior: always apply the resolved value (host can override via resolveMetadataConflict).
-      return {
-        ...entry,
-        value: resolved.value,
-        metadataPersistence: "internal" as const,
-        storageRef: undefined,
-        metadataVersion: resolved.version ?? entry.metadataVersion,
-      };
-    }),
-  );
-
-  args.runtime.setWorkflowMetadataEntries(nextEntries);
-}
-
-async function runConvertScopesToExternal(args: {
-  runtime: WordReviewEditorRuntime;
-  scopeIds: string[];
-  resolver: ScopeMetadataResolver | null;
-  /** When provided, version-conflict publish errors emit `metadata_conflict_detected`. */
-  documentId?: string;
-  onEvent?: (event: WordReviewEditorEvent) => void;
-  pendingConflicts?: Map<string, PendingConflict>;
-}): Promise<void> {
-  if (!args.resolver) throw new MetadataResolverMissingError();
-  const snapshot = args.runtime.getWorkflowMetadataSnapshot();
-  const overlay = args.runtime.getWorkflowOverlay();
-
-  const nextEntries = await Promise.all(
-    snapshot.entries.map(async (entry) => {
-      if (!entry.scopeId || !args.scopeIds.includes(entry.scopeId)) return entry;
-      const scope = overlay?.scopes.find((s) => s.scopeId === entry.scopeId);
-      const effective = resolveEffective({
-        overlay: overlay?.metadataPersistence,
-        scope: scope?.metadataPersistence,
-        field: entry.metadataPersistence,
-      });
-      if (effective === "external") return entry;
-
-      try {
-        const { ref, version } = await args.resolver!.publish({
-          scopeId: entry.scopeId,
-          metadataId: entry.metadataId,
-          entryId: entry.entryId,
-          value: entry.value ?? {},
-          expectedVersion: entry.metadataVersion,
-        });
-        return {
-          ...entry,
-          value: undefined,
-          metadataPersistence: "external" as const,
-          storageRef: ref,
-          metadataVersion: version,
-        };
-      } catch (err: unknown) {
-        // Duck-type version-conflict errors (HarnessVersionConflictError or compatible shapes).
-        if (
-          args.pendingConflicts &&
-          args.documentId !== undefined &&
-          err instanceof Error &&
-          (err.name === "HarnessVersionConflictError" ||
-            ("ref" in err && "expected" in err && "actual" in err))
-        ) {
-          const conflictErr = err as Error & { ref?: string; expected?: number; actual?: number };
-          registerAndEmitConflict({
-            onEvent: args.onEvent,
-            documentId: args.documentId,
-            pendingConflicts: args.pendingConflicts,
-            conflict: {
-              scopeId: entry.scopeId,
-              entryId: entry.entryId,
-              // Embedded side: the entry's current inline value and metadataVersion.
-              embedded: { value: entry.value, version: entry.metadataVersion },
-              // External side: only the rowstore's actual version (no value available from error).
-              external: { version: conflictErr.actual },
-              defaultPolicy: "prefer-latest",
-            },
-          });
-          // Skip this entry — do not publish; leave it unchanged.
-          return entry;
-        }
-        // Non-conflict errors propagate normally.
-        throw err;
-      }
-    }),
-  );
-
-  args.runtime.setWorkflowMetadataEntries(nextEntries);
-}
+import {
+  conflictKey,
+  convertScopesToInternal as runConvertScopesToInternal,
+  convertScopesToExternal as runConvertScopesToExternal,
+  type PendingConflict,
+} from "../shell/ref-utilities.ts";
 
 // ---------------------------------------------------------------------------
 
-type CanonicalDocType = ReturnType<WordReviewEditorRuntime["getCanonicalDocument"]>;
-
-function collectChartSnapshots(doc: CanonicalDocType): import("../api/public-types").ChartSnapshot[] {
-  const results: import("../api/public-types").ChartSnapshot[] = [];
-  collectChartSnapshotsFromBlocks(doc.content.children, results);
-  return results;
-}
-
-/**
- * Walk the canonical document, compute each chart_preview's stableChartId,
- * and project a snapshot for the first matching id. Short-circuits on
- * match so the happy path is O(k) in blocks-until-match rather than the
- * O(N) the `collect().find()` fallback incurred for every ref call. For
- * hosts that call `getChartSnapshot` in a tight loop over many chartIds,
- * this reduces the cost from O(N²) to O(N·k).
- */
-function lookupChartSnapshot(
-  doc: CanonicalDocType,
-  chartId: string,
-): import("../api/public-types").ChartSnapshot | null {
-  return lookupChartSnapshotInBlocks(doc.content.children, chartId);
-}
-
-function lookupChartSnapshotInBlocks(
-  blocks: CanonicalDocType["content"]["children"],
-  chartId: string,
-): import("../api/public-types").ChartSnapshot | null {
-  for (const block of blocks) {
-    if (block.type === "paragraph") {
-      for (const inline of block.children) {
-        if (inline.type === "chart_preview" && inline.parsedData) {
-          const id = stableChartId(inline.rawXml);
-          if (id === chartId) {
-            return projectChartSnapshot(id, inline.parsedData);
-          }
-        }
-      }
-    } else if (block.type === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          const found = lookupChartSnapshotInBlocks(cell.children, chartId);
-          if (found) return found;
-        }
-      }
-    } else if (block.type === "sdt" || block.type === "custom_xml") {
-      const found = lookupChartSnapshotInBlocks(block.children, chartId);
-      if (found) return found;
-    }
-  }
-  return null;
-}
-
-function collectChartSnapshotsFromBlocks(
-  blocks: CanonicalDocType["content"]["children"],
-  results: import("../api/public-types").ChartSnapshot[],
-): void {
-  for (const block of blocks) {
-    if (block.type === "paragraph") {
-      for (const inline of block.children) {
-        if (inline.type === "chart_preview" && inline.parsedData) {
-          const chartId = stableChartId(inline.rawXml);
-          results.push(projectChartSnapshot(chartId, inline.parsedData));
-        }
-      }
-    } else if (block.type === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          collectChartSnapshotsFromBlocks(cell.children, results);
-        }
-      }
-    } else if (block.type === "sdt" || block.type === "custom_xml") {
-      collectChartSnapshotsFromBlocks(block.children, results);
-    }
-  }
-}
-
 // ---------------------------------------------------------------------------
 
 export function __createWordReviewEditorRefBridge(
@@ -579,7 +323,44 @@ export function __createWordReviewEditorRefBridge(
     return r;
   });
 
+  // L07 closure pass — cache the V3 surface per-bridge. `runtime` is stable
+  // across this bridge's lifetime; `createApiV3` freezes the result, so a
+  // single shared instance is safe and avoids re-running family factories
+  // on every `ref.getApiV3()` call.
+  //
+  // refactor/11 Slice 4 — wire the UI factory here too so the
+  // non-mounted ref path (headless harness, tests, services) returns an
+  // `api` with the `ui` namespace in lockstep with the mounted shell path.
+  let cachedApiV3: ApiV3 | null = null;
+
   const refValue: WordReviewEditorRef = {
+    getApiV3: () => {
+      if (cachedApiV3 === null) {
+        const built = createApiV3(runtime, { ui: shellUiControllerFactory });
+        cachedApiV3 = built;
+        // L03 §5b activation — hand the runtime a callback that
+        // returns the composed effective markup mode (L06 policy ×
+        // L10 local preference). Closure captures the freshly-built
+        // api so subsequent `ui.viewport.setLocalMarkupMode` calls
+        // flip the value observed on the next projection. The paired
+        // subscribe below invalidates the surface cache when the
+        // composed mode changes due to a class-C preference flip,
+        // so the new posture reaches the render without waiting for
+        // the next mutation. Both hooks are guarded on the `ui`
+        // family being present — headless consumers that bypass the
+        // factory skip the wire.
+        const uiApi = built.ui;
+        if (uiApi) {
+          runtime.setEffectiveMarkupModeProvider(() =>
+            uiApi.viewport.getEffectiveMarkupMode(),
+          );
+          uiApi.viewport.subscribeEffectiveMarkupMode(() => {
+            runtime.invalidateForMarkupModeChange();
+          });
+        }
+      }
+      return cachedApiV3;
+    },
     focus: () => runtime.focus(),
     blur: () => runtime.blur(),
     undo: () => runtime.undo(),
@@ -929,6 +710,30 @@ export function __createWordReviewEditorRefBridge(
     getWorkflowMetadataSnapshot: () => {
       return clonePublicValue(runtime.getWorkflowMetadataSnapshot());
     },
+    getVisibilityPolicy: (kind) => {
+      return clonePublicValue(runtime.getVisibilityPolicy(kind));
+    },
+    getVisibilityPolicies: () => {
+      return clonePublicValue(runtime.getVisibilityPolicies());
+    },
+    setVisibilityPolicy: (policy) => {
+      return runtime.setVisibilityPolicy(clonePublicValue(policy));
+    },
+    clearVisibilityPolicy: (kind) => {
+      return runtime.clearVisibilityPolicy(kind);
+    },
+    subscribeVisibilityPolicy: (listener) => {
+      return runtime.subscribeVisibilityPolicy(listener);
+    },
+    getMarkupModePolicy: () => {
+      return clonePublicValue(runtime.getMarkupModePolicy());
+    },
+    setMarkupModePolicy: (policy) => {
+      return runtime.setMarkupModePolicy(policy ? clonePublicValue(policy) : null);
+    },
+    subscribeMarkupModePolicy: (listener) => {
+      return runtime.subscribeMarkupModePolicy(listener);
+    },
     queryScopes: (filter) => {
       return clonePublicValue(runtime.queryScopes(filter));
     },
@@ -1164,8 +969,15 @@ export function __createWordReviewEditorRefBridge(
     },
     ...projections,
   };
-  refHolder.current = refValue;
-  return refValue;
+  // Phase 1 api-channel — Proxy wrap so every invocation emits when enabled.
+  const telemetryBus = runtime.debug?.bus;
+  if (!telemetryBus) {
+    refHolder.current = refValue;
+    return refValue;
+  }
+  const tracedRef = wrapRefForTelemetry(refValue, telemetryBus);
+  refHolder.current = tracedRef;
+  return tracedRef;
 }
 
 export function __applyRuntimeTextCommand(
@@ -1218,7 +1030,11 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       showReviewPanel = true,
       chromeVisibility,
       density,
+      editorActionHost,
+      chromeControllerRef,
+      commandPaletteDisabled,
       customSelectionTools,
+      debugMode = "off",
     } = props;
 
     const [activeRailTab, setActiveRailTab] = useState<ReviewRailTab>("comments");
@@ -1239,6 +1055,11 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
     const surfaceRef = useRef<TwProseMirrorSurfaceRef | null>(null);
     const selectionToolbarElementRef = useRef<HTMLDivElement | null>(null);
     const shellRef = useRef<HTMLDivElement | null>(null);
+    // §3.1 — internal handle on the workspace chrome controller so the
+    // PM surface's `onContextMenuRequested` can dispatch to it.  Teed
+    // to the host-supplied `chromeControllerRef` below so both the
+    // internal wire and any external consumer see the same instance.
+    const internalChromeControllerRef = useRef<TwWorkspaceChromeHostController | null>(null);
     const editorRefForRepl = useRef<WordReviewEditorRef | null>(null);
     const lastSelectionToolbarKeyRef = useRef<string | null>(null);
     const lastAnnouncedErrorIdRef = useRef<string | null>(null);
@@ -1266,6 +1087,167 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       lastSavedRevisionTokenRef,
       runtimeViewStateSeedRef,
     } = useEditorRuntimeBoundary(props);
+
+    // refactor/10 Task 1 — the mounted `UiController` reads live shell
+    // state via refs. Refs hold a pointer to the current render's host
+    // posture + preset input so the factory's closure getters always
+    // return current values (React-native stable-getter pattern — the
+    // factory is memoized on `activeRuntime`, the ref body mutates per
+    // render).
+    const shellUiStateRef = useRef<{
+      hostPosture: ChromeHostPosture;
+      chromePresetInput: {
+        chromePreset: WordReviewEditorChromePreset;
+        chromeOptions?: Partial<WordReviewEditorChromeOptions>;
+      };
+    }>({
+      hostPosture: {},
+      chromePresetInput: { chromePreset: "advanced" },
+    });
+    shellUiStateRef.current = {
+      hostPosture: {
+        reviewMode: reviewMode === "review" ? "reviewer" : "author",
+        markupDisplay: normalizeHostMarkupDisplay(markupDisplay),
+        debugMode,
+        chromePreset,
+      },
+      chromePresetInput: {
+        chromePreset: resolveChromePreset(chromePreset, reviewMode),
+        chromeOptions,
+      },
+    };
+
+    // refactor/11 Slice 4 — construct the v3 API with the UI namespace
+    // wired so `<UiApiProvider>` can expose `api.ui` to chrome hooks that
+    // read via `useUiApi()`. Memoized on `activeRuntime` (stable across
+    // PM transactions per Performance Invariant 8); `createApiV3` freezes
+    // the returned record so sharing it between the provider + the ref
+    // (see useImperativeHandle below) is safe. Called once per runtime
+    // bridge; re-runs only when the editor receives a new runtime handle.
+    //
+    // DS-C1 (designsystem.md §8.8.1 "Selection toolbar" row) — the shell
+    // overlay-anchor bridge is a stable `useRef` box consulted by the
+    // controller's `getOverlayAnchor` hook so
+    // `ui.overlays.getAnchor({ kind: "selection" })` returns a real rect
+    // without re-creating the API on every selection change. The factory
+    // closes over the ref box identity (never changes); per-render updates
+    // to the box contents land via `useShellSelectionAnchorBridge` inside
+    // the review workspace.
+    const overlayAnchorBridgeRef = useRef<ShellOverlayAnchorBridge>(
+      createShellOverlayAnchorBridge(),
+    );
+
+    // refactor/10 chrome-contract Slice 2 (2026-04-23) — subscriber
+    // channels for `ui.chrome.subscribe` / `ui.viewport.subscribe` /
+    // `ui.overlays.subscribe`. Each is a stable `useRef` emitter the
+    // factory closes over. Emission is driven from React effects below
+    // on the appropriate state-source changes. Before this slice those
+    // subscribe methods threw on mount ("controller lacks hook");
+    // Playwright drivers + debug service couldn't observe posture /
+    // viewport / overlay-invalidation over time on the mounted editor.
+    const chromeChannelRef = useRef<UiSubscriberChannel<ChromePosture> | null>(
+      null,
+    );
+    if (chromeChannelRef.current === null) {
+      chromeChannelRef.current = createUiSubscriberChannel<ChromePosture>();
+    }
+    const viewportChannelRef = useRef<UiSubscriberChannel<ViewportState> | null>(
+      null,
+    );
+    if (viewportChannelRef.current === null) {
+      viewportChannelRef.current = createUiSubscriberChannel<ViewportState>();
+    }
+    const overlaysChannelRef = useRef<
+      UiSubscriberChannel<OverlayAnchorQuery> | null
+    >(null);
+    if (overlaysChannelRef.current === null) {
+      overlaysChannelRef.current = createUiSubscriberChannel<OverlayAnchorQuery>();
+    }
+
+    // refactor/10 Task 1 — mounted factory populates getHostPosture +
+    // getPinnedSurfaces + the DS-C1 selection bridge + the three
+    // subscriber channels so every `api.ui.*.subscribe` on the mounted
+    // path is a real subscription, not a throw.
+    const api = useMemo(
+      () =>
+        createApiV3(activeRuntime, {
+          ui: makeShellUiControllerFactory({
+            getHostPosture: () => shellUiStateRef.current.hostPosture,
+            getPinnedSurfaces: () =>
+              deriveShellPinnedSurfaces(
+                shellUiStateRef.current.chromePresetInput.chromePreset,
+                shellUiStateRef.current.chromePresetInput.chromeOptions,
+              ),
+            getOverlayAnchor: (query) => {
+              if (query.kind === "selection") {
+                return overlayAnchorBridgeRef.current.getSelectionAnchor?.() ?? null;
+              }
+              return null;
+            },
+            subscribeChrome: (listener) =>
+              chromeChannelRef.current!.subscribe(listener),
+            subscribeViewport: (listener) =>
+              viewportChannelRef.current!.subscribe(listener),
+            subscribeOverlays: (listener) =>
+              overlaysChannelRef.current!.subscribe(listener),
+          }),
+        }),
+      [activeRuntime],
+    );
+
+    // L03 §5b activation (mounted-shell path). Hand the runtime a
+    // callback that returns the composed effective markup mode (L06
+    // policy × L10 local preference). Subscribe to class-C preference
+    // changes so the surface cache busts and the new posture reaches
+    // the render without waiting for a mutation. Re-wires when
+    // `activeRuntime` or `api` changes (effect cleanup clears the
+    // previous provider + unsubscribes).
+    useEffect(() => {
+      const uiApi = api.ui;
+      if (!uiApi) return;
+      activeRuntime.setEffectiveMarkupModeProvider(() =>
+        uiApi.viewport.getEffectiveMarkupMode(),
+      );
+      const unsubscribe = uiApi.viewport.subscribeEffectiveMarkupMode(() => {
+        activeRuntime.invalidateForMarkupModeChange();
+      });
+      return () => {
+        unsubscribe();
+        activeRuntime.setEffectiveMarkupModeProvider(undefined);
+      };
+    }, [activeRuntime, api]);
+
+    // Chrome emit — fire posture subscribers whenever a host-posture
+    // source changes. Runtime-owned posture fields (effectiveMode,
+    // blockedReasons, documentMode, readOnly) are captured via the
+    // snapshot-slice subscriptions below — they trigger re-renders that
+    // in turn re-run this effect on dep changes.
+    useEffect(() => {
+      if (!api.ui) return;
+      chromeChannelRef.current?.emit(api.ui.chrome.getPosture());
+    }, [
+      api,
+      reviewMode,
+      markupDisplay,
+      debugMode,
+      chromePreset,
+      readOnly,
+    ]);
+
+    // Channel teardown on unmount — belt-and-suspenders vs stale
+    // listeners after a later remount. The refs are per-instance so
+    // lifetime is bounded, but clearing avoids a latent leak if a
+    // host re-mounts the editor in the same tab.
+    useEffect(() => {
+      const chrome = chromeChannelRef.current;
+      const viewport = viewportChannelRef.current;
+      const overlays = overlaysChannelRef.current;
+      return () => {
+        chrome?.dispose();
+        viewport?.dispose();
+        overlays?.dispose();
+      };
+    }, []);
     const metaSlice = useRuntimeSnapshotSlice(
       runtime,
       fallbackSnapshot,
@@ -1586,54 +1568,21 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       [activeReviewQueueItemId, activeRuntime, reviewQueueSnapshot],
     );
 
-    useEffect(() => {
-      if (!ydoc || !runtime) return;
-      const handle = createRuntimeCollabSync({
-        ydoc,
-        runtime,
-        authorId: currentUser.userId,
-        commandAppliedBridge,
-      });
-      return () => handle.destroy();
-    }, [commandAppliedBridge, currentUser.userId, runtime, ydoc]);
-
-    useEffect(() => {
-      if (!awareness) {
-        return;
-      }
-      return () => clearLocalCursorState(awareness);
-    }, [awareness]);
-
-    useEffect(() => {
-      if (!awareness) {
-        return;
-      }
-      if (!runtime) {
-        clearLocalCursorState(awareness);
-        return;
-      }
+    useRuntimeCollabSync({
+      ydoc,
+      runtime,
+      authorId: currentUser.userId,
+      commandAppliedBridge,
+    });
 
-      if (suppressNextAwarenessPublishRef.current) {
-        suppressNextAwarenessPublishRef.current = false;
-      } else {
-        setLocalCursorState(awareness, {
-          userId: currentUser.userId,
-          displayName: currentUser.displayName,
-          color: getCursorColorForUser(currentUser.userId),
-          anchor: snapshot.selection.anchor,
-          head: snapshot.selection.head,
-          storyTarget: snapshot.activeStory,
-        });
-      }
-    }, [
+    useRemoteCursorPublish({
       awareness,
-      currentUser.displayName,
-      currentUser.userId,
       runtime,
-      snapshot.activeStory,
-      snapshot.selection.anchor,
-      snapshot.selection.head,
-    ]);
+      currentUser,
+      selection: { anchor: snapshot.selection.anchor, head: snapshot.selection.head },
+      activeStory: snapshot.activeStory,
+      suppressNextPublishRef: suppressNextAwarenessPublishRef,
+    });
 
     useEffect(() => {
       runtimeViewStateSeedRef.current = {
@@ -1659,7 +1608,14 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
           if (!r) throw new Error("ref projection used before ref initialization");
           return r;
         });
+        // L07 closure pass — share the v3 surface with the render-time
+        // `api` memo (refactor/11 Slice 4). The provider mounts the same
+        // frozen ApiV3 that `ref.getApiV3()` returns; consumers reading
+        // through `useUiApi()` see the identical `api.ui` the host-side
+        // ref exposes, so provider path and ref path cannot drift.
+        const cachedApiV3: ApiV3 = api;
         const refValue: WordReviewEditorRef = ({
+        getApiV3: () => cachedApiV3,
         focus: () => activeRuntime.focus(),
         blur: () => activeRuntime.blur(),
         undo: () => activeRuntime.undo(),
@@ -2081,6 +2037,30 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         getWorkflowMetadataSnapshot: () => {
           return clonePublicValue(activeRuntime.getWorkflowMetadataSnapshot());
         },
+        getVisibilityPolicy: (kind) => {
+          return clonePublicValue(activeRuntime.getVisibilityPolicy(kind));
+        },
+        getVisibilityPolicies: () => {
+          return clonePublicValue(activeRuntime.getVisibilityPolicies());
+        },
+        setVisibilityPolicy: (policy) => {
+          return activeRuntime.setVisibilityPolicy(clonePublicValue(policy));
+        },
+        clearVisibilityPolicy: (kind) => {
+          return activeRuntime.clearVisibilityPolicy(kind);
+        },
+        subscribeVisibilityPolicy: (listener) => {
+          return activeRuntime.subscribeVisibilityPolicy(listener);
+        },
+        getMarkupModePolicy: () => {
+          return clonePublicValue(activeRuntime.getMarkupModePolicy());
+        },
+        setMarkupModePolicy: (policy) => {
+          return activeRuntime.setMarkupModePolicy(policy ? clonePublicValue(policy) : null);
+        },
+        subscribeMarkupModePolicy: (listener) => {
+          return activeRuntime.subscribeMarkupModePolicy(listener);
+        },
         queryScopes: (filter) => {
           return clonePublicValue(activeRuntime.queryScopes(filter));
         },
@@ -2307,12 +2287,21 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         },
         ...projections,
       }) as WordReviewEditorRef;
-        refHolder.current = refValue;
-        editorRefForRepl.current = refValue;
-        return refValue;
+        // Phase 1 api-channel — Proxy wrap for trace events when enabled.
+        const telemetryBus = activeRuntime.debug?.bus;
+        if (!telemetryBus) {
+          refHolder.current = refValue;
+          editorRefForRepl.current = refValue;
+          return refValue;
+        }
+        const tracedRef = wrapRefForTelemetry(refValue, telemetryBus);
+        refHolder.current = tracedRef;
+        editorRefForRepl.current = tracedRef;
+        return tracedRef;
       },
       [
         activeRuntime,
+        api,
         clearReviewSectionMarkById,
         currentUser.userId,
         documentId,
@@ -2515,38 +2504,10 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       )
       .sort()
       .join("|");
-    const mediaPreviews = useMemo(() => {
-      if (!sourcePackage) {
-        return {} as Record<string, MediaPreviewDescriptor>;
-      }
-      try {
-        const bytes = decodePersistedSourcePackageBytes(sourcePackage);
-        if (!hasValidPersistedSourcePackageDigest(sourcePackage, bytes)) {
-          return {} as Record<string, MediaPreviewDescriptor>;
-        }
-        const opc = readOpcPackage(bytes);
-        const previews: Record<string, MediaPreviewDescriptor> = {};
-        for (const item of Object.values(canonicalDocument.media.items)) {
-          const contentType = item.contentType?.toLowerCase();
-          const part = opc.parts.get(item.packagePartName);
-          if (
-            !part?.bytes ||
-            !contentType ||
-            !BROWSER_SAFE_PREVIEW_TYPES.has(contentType)
-          ) {
-            continue;
-          }
-          previews[item.mediaId] = {
-            src: createImageDataUrl(contentType, part.bytes),
-            ...(item.widthEmu !== undefined ? { widthEmu: item.widthEmu } : {}),
-            ...(item.heightEmu !== undefined ? { heightEmu: item.heightEmu } : {}),
-          };
-        }
-        return previews;
-      } catch {
-        return {} as Record<string, MediaPreviewDescriptor>;
-      }
-    }, [mediaPreviewCatalogKey, sourcePackage?.sha256Hex]);
+    const mediaPreviews = useMemo(
+      () => buildMediaPreviews(sourcePackage, canonicalDocument),
+      [mediaPreviewCatalogKey, sourcePackage?.sha256Hex],
+    );
     const activeObjectContext = useMemo(
       () =>
         viewState.activeObjectFrame && viewState.activeObjectFrame.kind !== "image"
@@ -2791,6 +2752,36 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       [],
     );
 
+    // §3.1 — merged ref that writes to the internal ref AND forwards to
+    // the host-supplied `chromeControllerRef` (when present).  Supports
+    // both callback refs and mutable ref objects.
+    const teedChromeControllerRef = useCallback(
+      (instance: TwWorkspaceChromeHostController | null) => {
+        internalChromeControllerRef.current = instance;
+        if (!chromeControllerRef) return;
+        if (typeof chromeControllerRef === "function") {
+          chromeControllerRef(instance);
+        } else {
+          (chromeControllerRef as React.MutableRefObject<
+            TwWorkspaceChromeHostController | null
+          >).current = instance;
+        }
+      },
+      [chromeControllerRef],
+    );
+
+    // §3.1 — contextmenu dispatch: when `editorActionHost` is wired,
+    // forward PM's `contextmenu` DOM events to the workspace chrome
+    // host's controller, which resolves target kinds and mounts the
+    // menu portal.  Without `editorActionHost` the chrome host is
+    // unmounted, so we leave the native menu alone (back-compat).
+    const handleContextMenuRequested = useCallback(
+      (event: { clientX: number; clientY: number; target: EventTarget | null }) => {
+        internalChromeControllerRef.current?.handleContextMenuRequest(event);
+      },
+      [],
+    );
+
     useEffect(() => {
       if (!selectionToolbarSelectionKey) {
         setSuppressedSuggestionRevisionId(null);
@@ -3327,6 +3318,9 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         ref={surfaceRef}
         currentUser={currentUser}
         awareness={awareness}
+        pasteFragmentParser={SHELL_PASTE_FRAGMENT_PARSER}
+        runtimeSearchDocument={api.runtime.search.searchDocument}
+        runtimeGetTableSelectionDescriptor={api.runtime.table.getSelectionDescriptor}
         snapshot={snapshot}
         canonicalDocument={canonicalDocument}
         documentNavigation={documentNavigation}
@@ -3347,11 +3341,13 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         activeWorkflowScopeIds={workflowScopeSnapshot?.activeWorkItem?.scopeIds ?? []}
         workflowMetadata={workflowMarkupSnapshot?.metadata}
         onSelectionToolbarAnchorChange={handleSelectionToolbarAnchorChange}
+        {...(editorActionHost ? { onContextMenuRequested: handleContextMenuRequested } : {})}
         {...editorCallbacks}
         dispatchRuntimeCommand={(command) =>
           activeRuntime.applyActiveStoryTextCommand(command as never)
         }
         layoutFacet={activeRuntime.layout}
+        geometryFacet={activeRuntime.geometry}
         pageChromeHeaderBandPx={isPageWorkspace ? 32 : 0}
         pageChromeFooterBandPx={isPageWorkspace ? 32 : 0}
         pageChromeInterGapPx={isPageWorkspace ? 24 : 16}
@@ -3372,7 +3368,16 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       />
     );
 
+    const shellChannels: UiShellChannels = {
+      chrome: chromeChannelRef.current!,
+      viewport: viewportChannelRef.current!,
+      overlays: overlaysChannelRef.current!,
+    };
+
     return (
+      <UiApiProvider value={api.ui ?? null}>
+      <UiShellChannelsProvider value={shellChannels}>
+      <OverlayAnchorBridgeProvider value={overlayAnchorBridgeRef.current}>
       <>
       <EditorShellView
         shellRef={shellRef}
@@ -3391,6 +3396,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         onShellKeyDownCapture={handleShellKeyDownCapture}
         shellHeader={shellHeader}
         viewState={viewState}
+        onEditorRoleChange={(role) => activeRuntime.setEditorRole(role)}
         markupDisplay={liveMarkupDisplay}
         currentUserId={currentUser.userId}
         capabilities={capabilities}
@@ -3408,9 +3414,16 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         showTrackedChanges={showTrackedChanges}
         workflowScopeSnapshot={workflowScopeSnapshot}
         layoutFacet={activeRuntime.layout}
+        geometryFacet={activeRuntime.geometry}
+        workflowFacet={activeRuntime.workflow}
         interactionGuardSnapshot={interactionGuardSnapshot}
         chromePreset={effectiveChromePreset}
         chromeOptions={chromeOptions}
+        {...(editorActionHost ? { editorActionHost } : {})}
+        {...(editorActionHost ? { chromeControllerRef: teedChromeControllerRef } : {})}
+        {...(commandPaletteDisabled !== undefined
+          ? { commandPaletteDisabled }
+          : {})}
         {...(props.collabSession ? { collabSession: props.collabSession } : {})}
         {...(props.collabTransportStatus
           ? { collabTransportStatus: props.collabTransportStatus }
@@ -3511,13 +3524,11 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         }}
         onDeselectObject={() => activeRuntime.deselectObject()}
         onScopeAskAgent={(payload) => {
-          // Resolve the scope's anchor + story from the facet's card
-          // model so the agent request carries the canonical range.
-          const facet = activeRuntime.layout;
-          const models =
-            facet && typeof facet.getAllScopeCardModels === "function"
-              ? facet.getAllScopeCardModels()
-              : [];
+          // Resolve the scope's anchor + story from the workflow
+          // facet's card model so the agent request carries the
+          // canonical range. Layer-06 Slice 4 made `runtime.workflow`
+          // the canonical source for scope-card data.
+          const models = activeRuntime.workflow.getAllScopeCardModels();
           const model = models.find((entry) => entry.scopeId === payload.scopeId);
           if (!model) return;
           const scopeSnapshot = activeRuntime.getWorkflowScopeSnapshot();
@@ -3546,1182 +3557,52 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         }}
       />
       <TwRuntimeReplDialog runtime={activeRuntime} editorRef={editorRefForRepl} />
+      <TwDebugPresentation
+        mode={debugMode}
+        sessionId={documentId}
+      />
       </>
+      </OverlayAnchorBridgeProvider>
+      </UiShellChannelsProvider>
+      </UiApiProvider>
     );
   },
 );
 
 /**
- * R3 — best-effort suggestion-group accept/reject fan-out.  Resolves
- * the group's suggestions from the current snapshot, then fans out
- * `acceptChange` / `rejectChange` across every changeId in each
- * group member.  P2 batches these in rapid succession; the runtime
- * commit boundary collapses them into a single logical transaction.
- * A future phase adds true atomicity at the runtime level.
+ * Translate a public-API `TableOp` (kebab-case `kind` discriminator) to
+ * the internal `TableStructureOperation` (`type` discriminator). Thin
+ * re-export of the shell `publicTableOpToInternal` helper so legacy
+ * tests keep their existing import path
+ * (`test/api/table-op-translation.test.ts`).
  */
-function applySuggestionGroupAction(
-  runtime: WordReviewEditorRuntime,
-  groupId: string,
-  action: "accept" | "reject",
-): void {
-  const snapshot = runtime.getSuggestionsSnapshot();
-  const group = snapshot.groups?.find((entry) => entry.groupId === groupId);
-  const op = action === "accept" ? "acceptSuggestionGroup" : "rejectSuggestionGroup";
-  if (!group) {
-    runtime.emitTransientWarning({
-      warningId: `suggestion-group-unknown-${groupId}-${Date.now()}`,
-      code: "review_target_not_found",
-      severity: "info",
-      message: `${op}("${groupId}") skipped: unknown groupId.`,
-      source: "review",
-      details: { op, targetId: groupId, reason: "group_unknown" },
-    });
-    return;
-  }
-  const byId = new Map(
-    snapshot.suggestions.map((entry) => [entry.suggestionId, entry]),
-  );
-  const skippedSuggestions: string[] = [];
-  for (const suggestionId of group.suggestionIds) {
-    const suggestion = byId.get(suggestionId);
-    if (!suggestion) {
-      skippedSuggestions.push(suggestionId);
-      continue;
-    }
-    for (const changeId of suggestion.changeIds) {
-      if (action === "accept") {
-        runtime.acceptChange(changeId);
-      } else {
-        runtime.rejectChange(changeId);
-      }
-    }
-  }
-  if (skippedSuggestions.length > 0) {
-    runtime.emitTransientWarning({
-      warningId: `suggestion-group-stale-${groupId}-${Date.now()}`,
-      code: "review_target_not_found",
-      severity: "info",
-      message: `${op}("${groupId}") partially skipped: ${skippedSuggestions.length} suggestion(s) no longer in snapshot.`,
-      source: "review",
-      details: {
-        op,
-        targetId: groupId,
-        reason: "suggestion_stale",
-        skippedSuggestionIds: skippedSuggestions,
-      },
-    });
-  }
+export function __publicTableOpToInternal(op: TableOp): TableStructureOperation {
+  return publicTableOpToInternal(op);
 }
 
-function applyRuntimeFormattingOperation(
+/**
+ * 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,
-  operation:
-    | { type: "toggle"; mark: "bold" | "italic" | "underline" | "strikethrough" | "superscript" | "subscript" }
-    | { type: "set-font-family"; fontFamily: string | null }
-    | { type: "set-font-size"; size: number | null }
-    | { type: "set-text-color"; color: string | null }
-    | { type: "set-highlight-color"; color: string | null }
-    | { type: "set-alignment"; alignment: FormattingAlignment }
-    | { type: "indent" }
-    | { type: "outdent" },
-): void {
-  if (isSelectionSuggesting(runtime)) {
-    if (applySuggestingFormattingOperation(runtime, operation)) {
-      return;
-    }
-  }
-  if (emitSuggestingUnsupportedMutation(runtime, getFormattingOperationCommandName(operation))) {
-    return;
-  }
-  const context = getStoryMutationContext(runtime, getFormattingOperationCommandName(operation));
-  if (!context) {
-    return;
-  }
-
-  const result = applyFormattingOperationToDocument(
-    context.localDocument,
-    context.localSnapshot,
-    operation,
-  );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      ...result,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function applySuggestingFormattingOperation(
-  runtime: WordReviewEditorRuntime,
-  operation:
-    | { type: "toggle"; mark: "bold" | "italic" | "underline" | "strikethrough" | "superscript" | "subscript" }
-    | { type: "set-font-family"; fontFamily: string | null }
-    | { type: "set-font-size"; size: number | null }
-    | { type: "set-text-color"; color: string | null }
-    | { type: "set-highlight-color"; color: string | null }
-    | { type: "set-alignment"; alignment: FormattingAlignment }
-    | { type: "indent" }
-    | { type: "outdent" },
-): boolean {
-  const commandName = getFormattingOperationCommandName(operation);
-  const context = getStoryMutationContext(runtime, commandName);
-  if (!context) {
-    return true;
-  }
-  if (context.activeStory.kind !== "main") {
-    runtime.emitBlockedCommand(commandName, [{
-      code: "suggesting_unsupported",
-      message: `"${commandName}" is not supported in suggesting mode for this story.`,
-    }]);
-    return true;
-  }
-
-  if (operation.type === "set-alignment" || operation.type === "indent" || operation.type === "outdent") {
-    const paragraphContext = resolveActiveParagraphContext(context.localSnapshot);
-    if (!paragraphContext) {
-      return true;
-    }
-    const beforeXml = buildParagraphPropertyBeforeXml(paragraphContext.paragraph);
-    const result = applyFormattingOperationToDocument(
-      context.localDocument,
-      context.localSnapshot,
-      operation,
-    );
-    if (!result.changed) {
-      return true;
-    }
-    const nextDocument = appendPropertyChangeSuggestion(
-      result.document,
-      {
-        from: paragraphContext.paragraph.from,
-        to: paragraphContext.paragraph.to,
-      },
-      {
-        originalRevisionType: "pPrChange",
-        xmlTag: "pPrChange",
-        beforeXml,
-        semanticKind: "paragraph-property-change",
-        storyTarget: context.activeStory,
-        authorId: runtime.getDefaultAuthorId?.(),
-      },
-      context.timestamp,
-    );
-    dispatchStoryMutationResult(
-      runtime,
-      context,
-      {
-        changed: true,
-        document: nextDocument,
-        selection: toRuntimeSelectionSnapshot(result.selection),
-      },
-      context.timestamp,
-    );
-    return true;
-  }
-
-  const segment = findSingleSelectedTextSegment(context.localSnapshot);
-  if (!segment) {
-    runtime.emitBlockedCommand(commandName, [{
-      code: "suggesting_unsupported",
-      message: `"${commandName}" requires one bounded text segment in suggesting mode.`,
-    }]);
-    return true;
-  }
-  const beforeXml = buildRunPropertyBeforeXml(segment);
-  const result = applyFormattingOperationToDocument(
-    context.localDocument,
-    context.localSnapshot,
-    operation,
-  );
-  if (!result.changed) {
-    return true;
-  }
-  const nextDocument = appendPropertyChangeSuggestion(
-    result.document,
-    {
-      from: segment.from,
-      to: segment.to,
-    },
-    {
-      originalRevisionType: "rPrChange",
-      xmlTag: "rPrChange",
-      beforeXml,
-      semanticKind: "formatting-change",
-      storyTarget: context.activeStory,
-      authorId: runtime.getDefaultAuthorId?.(),
-    },
-    context.timestamp,
-  );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      changed: true,
-      document: nextDocument,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    context.timestamp,
-  );
-  return true;
-}
-
-function applyRuntimeListToggle(
-  runtime: WordReviewEditorRuntime,
-  kind: "bulleted" | "numbered",
-): void {
-  const commandName =
-    kind === "bulleted" ? "toggleBulletedList" : "toggleNumberedList";
-  if (emitSuggestingUnsupportedMutation(runtime, commandName)) {
-    return;
-  }
-  const context = getStoryMutationContext(runtime, commandName);
-  if (!context) {
-    return;
-  }
-
-  const paragraphContext = resolveActiveParagraphContext(context.localSnapshot);
-  if (!paragraphContext) {
-    return;
-  }
-
-  const result =
-    kind === "bulleted"
-      ? toggleBulletedList(
-          context.localDocument,
-          [paragraphContext.paragraphIndex],
-          { timestamp: context.timestamp },
-        )
-      : toggleNumberedList(
-          context.localDocument,
-          [paragraphContext.paragraphIndex],
-          { timestamp: context.timestamp },
-        );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      changed: result.affectedParagraphIndexes.length > 0,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(context.localSnapshot.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function getRuntimeStyleCatalog(
-  input:
-    | WordReviewEditorRuntime
-    | EditorSessionState["canonicalDocument"]["styles"],
-): StyleCatalogSnapshot {
-  const styles =
-    "getSessionState" in input
-      ? input.getSessionState().canonicalDocument.styles
-      : input;
-  const mapRecord = <
-    T extends {
-      styleId: string;
-      displayName: string;
-      kind: "paragraph" | "character" | "table";
-      isDefault: boolean;
-      basedOn?: string;
-      nextStyle?: string;
-    },
-  >(
-    record: Record<string, T>,
-  ) =>
-    Object.values(record)
-      .map((entry) => ({
-        styleId: entry.styleId,
-        displayName: entry.displayName,
-        kind: entry.kind,
-        isDefault: entry.isDefault,
-        ...(entry.basedOn ? { basedOn: entry.basedOn } : {}),
-        ...(entry.nextStyle ? { nextStyle: entry.nextStyle } : {}),
-      }))
-      .sort((left, right) =>
-        left.displayName.localeCompare(right.displayName) ||
-        left.styleId.localeCompare(right.styleId),
-      );
-
-  return {
-    paragraphs: mapRecord(styles.paragraphs),
-    characters: mapRecord(styles.characters),
-    tables: mapRecord(styles.tables),
-    fromPackage: styles.fromPackage === true,
-  };
-}
-
-function applyRuntimeParagraphStyle(
-  runtime: WordReviewEditorRuntime,
-  styleId: string | null,
-): void {
-  if (emitSuggestingUnsupportedMutation(runtime, "setParagraphStyle")) {
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "setParagraphStyle");
-  if (!context) {
-    return;
-  }
-
-  const result = applyParagraphStyleToDocument(
-    context.localDocument,
-    context.localSnapshot,
-    styleId,
-  );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      ...result,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function applyRuntimeTableStyle(
-  runtime: WordReviewEditorRuntime,
-  styleId: string | null,
-): void {
-  if (emitSuggestingUnsupportedMutation(runtime, "setTableStyle")) {
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "setTableStyle");
-  if (!context) {
-    return;
-  }
-
-  const result = applyTableStyleToDocument(
-    context.localDocument,
-    context.localSnapshot,
-    styleId,
-  );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      ...result,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function applyRuntimeParagraphIndentation(
-  runtime: WordReviewEditorRuntime,
-  indentation: {
-    left?: number;
-    right?: number;
-    firstLine?: number;
-    hanging?: number;
-  },
-): void {
-  if (emitSuggestingUnsupportedMutation(runtime, "setParagraphIndentation")) {
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "setParagraphIndentation");
-  if (!context) {
-    return;
-  }
-
-  const result = setActiveParagraphIndentation(
-    context.localDocument,
-    context.localSnapshot,
-    indentation,
-    { timestamp: context.timestamp },
-  );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      ...result,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function applyRuntimeParagraphTabStops(
-  runtime: WordReviewEditorRuntime,
-  tabStops: Array<{ pos: number; val?: string; leader?: string }>,
-): void {
-  if (emitSuggestingUnsupportedMutation(runtime, "setParagraphTabStops")) {
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "setParagraphTabStops");
-  if (!context) {
-    return;
-  }
-
-  const result = setActiveParagraphTabStops(
-    context.localDocument,
-    context.localSnapshot,
-    tabStops,
-    { timestamp: context.timestamp },
-  );
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      ...result,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function applyRuntimeNumberingFlow(
-  runtime: WordReviewEditorRuntime,
-  operation: { type: "restart"; startAt?: number } | { type: "continue" },
-): void {
-  if (
-    emitSuggestingUnsupportedMutation(
-      runtime,
-      operation.type === "restart" ? "restartNumbering" : "continueNumbering",
-    )
-  ) {
-    return;
-  }
-  const context = getStoryMutationContext(
-    runtime,
-    operation.type === "restart" ? "restartNumbering" : "continueNumbering",
-  );
-  if (!context) {
-    return;
-  }
-
-  const paragraphContext = resolveActiveParagraphContext(context.localSnapshot);
-  if (!paragraphContext?.paragraph.numbering) {
-    return;
-  }
-
-  const result =
-    operation.type === "restart"
-      ? restartListNumbering(
-          context.localDocument,
-          paragraphContext.paragraphIndex,
-          { timestamp: context.timestamp },
-          operation.startAt,
-        )
-      : continueListNumbering(
-          context.localDocument,
-          paragraphContext.paragraphIndex,
-          { timestamp: context.timestamp },
-        );
-
-  dispatchStoryMutationResult(
-    runtime,
-    context,
-    {
-      changed: result.affectedParagraphIndexes.length > 0,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(context.localSnapshot.selection),
-    },
-    context.timestamp,
-  );
-}
-
-function applyRuntimeInsertSectionBreak(
-  runtime: WordReviewEditorRuntime,
-  breakType: SectionBreakType,
-  options?: { afterSectionIndex?: number },
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot) || snapshot.activeStory.kind !== "main") {
-    return;
-  }
-  if (emitWorkflowBlockedMutation(runtime, "insertSectionBreak")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("insertSectionBreak", [{
-      code: "unsupported_surface",
-      message: "Section break insertion is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-
-  const sessionState = runtime.getSessionState();
-  const timestamp = new Date().toISOString();
-  const result =
-    typeof options?.afterSectionIndex === "number"
-      ? insertSectionBreakAfterSectionIndex(
-          sessionState.canonicalDocument,
-          options.afterSectionIndex,
-          breakType,
-          { timestamp },
-        )
-      : insertSectionBreakAfterSectionIndex(
-          sessionState.canonicalDocument,
-          runtime.getDocumentNavigationSnapshot().activeSectionIndex,
-          breakType,
-          { timestamp },
-        );
-
-  dispatchRuntimeDocumentMutation(
-    runtime,
-    {
-      changed: result.changed,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    timestamp,
-  );
-}
-
-function emitSuggestingUnsupportedMutation(
-  runtime: WordReviewEditorRuntime,
-  command: string,
-): boolean {
-  if (!isSelectionSuggesting(runtime)) {
-    return false;
-  }
-
-  runtime.emitBlockedCommand(command, [{
-    code: "suggesting_unsupported",
-    message: `"${command}" is not supported in suggesting mode.`,
-  }]);
-  return true;
-}
-
-function appendPropertyChangeSuggestion(
-  document: EditorSessionState["canonicalDocument"],
-  anchor: { from: number; to: number },
-  input: {
-    originalRevisionType: "rPrChange" | "pPrChange";
-    xmlTag: "rPrChange" | "pPrChange";
-    beforeXml: string;
-    semanticKind: "formatting-change" | "paragraph-property-change";
-    storyTarget: EditorStoryTarget;
-    authorId?: string;
-  },
-  timestamp: string,
-): EditorSessionState["canonicalDocument"] {
-  const existing = document.review.revisions;
-  const changeId = createRuntimeSuggestionChangeId(existing, timestamp);
-  const resolvedAuthorId = input.authorId ?? "unknown";
-  return {
-    ...document,
-    review: {
-      ...document.review,
-      revisions: {
-        ...existing,
-        [changeId]: {
-          changeId,
-          kind: "property-change",
-          anchor: createRangeAnchor(anchor.from, anchor.to, { start: 1, end: -1 }),
-          authorId: resolvedAuthorId,
-          createdAt: timestamp,
-          warningIds: [],
-          metadata: {
-            source: "runtime",
-            storyTarget: input.storyTarget,
-            suggestionId: changeId,
-            semanticKind: input.semanticKind,
-            originalRevisionType: input.originalRevisionType,
-            propertyChangeData: {
-              xmlTag: input.xmlTag,
-              beforeXml: input.beforeXml,
-            },
-          },
-          status: "open",
-        },
-      },
-    },
-  };
-}
-
-function createRuntimeSuggestionChangeId(
-  existing: EditorSessionState["canonicalDocument"]["review"]["revisions"],
-  timestamp: string,
-): string {
-  const base = `change-${timestamp.replace(/[^0-9]/gu, "")}`;
-  let counter = Object.keys(existing).length + 1;
-  let candidate = `${base}-p${counter}`;
-  while (existing[candidate]) {
-    counter += 1;
-    candidate = `${base}-p${counter}`;
-  }
-  return candidate;
-}
-
-function findSingleSelectedTextSegment(
-  snapshot: Pick<RuntimeRenderSnapshot, "surface" | "selection">,
-): Extract<SurfaceInlineSegment, { kind: "text" }> | null {
-  if (!snapshot.surface || snapshot.selection.activeRange.kind !== "range" || snapshot.selection.isCollapsed) {
-    return null;
-  }
-  const selectionFrom = Math.min(snapshot.selection.anchor, snapshot.selection.head);
-  const selectionTo = Math.max(snapshot.selection.anchor, snapshot.selection.head);
-  const segments = collectSelectedTextSegments(snapshot.surface.blocks, selectionFrom, selectionTo);
-  if (segments.length !== 1) {
-    return null;
-  }
-  const [segment] = segments;
-  if (!segment || segment.from !== selectionFrom || segment.to !== selectionTo) {
-    return null;
-  }
-  return segment;
-}
-
-function collectSelectedTextSegments(
-  blocks: readonly SurfaceBlockSnapshot[],
-  selectionFrom: number,
-  selectionTo: number,
-  output: Array<Extract<SurfaceInlineSegment, { kind: "text" }>> = [],
-): Array<Extract<SurfaceInlineSegment, { kind: "text" }>> {
-  for (const block of blocks) {
-    if (block.kind === "paragraph") {
-      for (const segment of block.segments) {
-        if (
-          segment.kind === "text" &&
-          rangesOverlap(selectionFrom, selectionTo, segment.from, segment.to)
-        ) {
-          output.push(segment);
-        }
-      }
-      continue;
-    }
-    if (block.kind === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          collectSelectedTextSegments(cell.content, selectionFrom, selectionTo, output);
-        }
-      }
-      continue;
-    }
-    if (block.kind === "sdt_block") {
-      collectSelectedTextSegments(block.children, selectionFrom, selectionTo, output);
-    }
-  }
-  return output;
-}
-
-function buildRunPropertyBeforeXml(
-  segment: Extract<SurfaceInlineSegment, { kind: "text" }>,
-): string {
-  const parts: string[] = [];
-  const marks = new Set(segment.marks ?? []);
-  if (marks.has("bold")) parts.push("<w:b/>");
-  if (marks.has("italic")) parts.push("<w:i/>");
-  if (marks.has("underline")) parts.push("<w:u w:val=\"single\"/>");
-  if (marks.has("strikethrough")) parts.push("<w:strike/>");
-  if (marks.has("superscript")) parts.push("<w:vertAlign w:val=\"superscript\"/>");
-  if (marks.has("subscript")) parts.push("<w:vertAlign w:val=\"subscript\"/>");
-  if (segment.markAttrs?.fontFamily) {
-    parts.push(`<w:rFonts w:ascii="${escapeAttributeXml(segment.markAttrs.fontFamily)}" w:hAnsi="${escapeAttributeXml(segment.markAttrs.fontFamily)}"/>`);
-  }
-  if (segment.markAttrs?.fontSize !== undefined) {
-    parts.push(`<w:sz w:val="${segment.markAttrs.fontSize}"/>`);
-  }
-  if (segment.markAttrs?.textColor) {
-    parts.push(`<w:color w:val="${escapeAttributeXml(segment.markAttrs.textColor)}"/>`);
-  }
-  if (segment.markAttrs?.backgroundColor) {
-    parts.push(`<w:shd w:val="clear" w:color="auto" w:fill="${escapeAttributeXml(segment.markAttrs.backgroundColor)}"/>`);
-  }
-  return `<w:rPr>${parts.join("")}</w:rPr>`;
-}
-
-function buildParagraphPropertyBeforeXml(
-  paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
-): string {
-  const parts: string[] = [];
-  if (paragraph.styleId) {
-    parts.push(`<w:pStyle w:val="${escapeAttributeXml(paragraph.styleId)}"/>`);
-  }
-  if (paragraph.numbering) {
-    parts.push(
-      `<w:numPr><w:ilvl w:val="${paragraph.numbering.level}"/><w:numId w:val="${escapeAttributeXml(
-        paragraph.numbering.numberingInstanceId.replace(/^num:/u, ""),
-      )}"/></w:numPr>`,
-    );
-  }
-  if (paragraph.alignment) {
-    parts.push(`<w:jc w:val="${escapeAttributeXml(paragraph.alignment)}"/>`);
-  }
-  if (paragraph.indentation) {
-    const attrs: string[] = [];
-    if (paragraph.indentation.left !== undefined) attrs.push(`w:left="${paragraph.indentation.left}"`);
-    if (paragraph.indentation.right !== undefined) attrs.push(`w:right="${paragraph.indentation.right}"`);
-    if (paragraph.indentation.firstLine !== undefined) attrs.push(`w:firstLine="${paragraph.indentation.firstLine}"`);
-    if (paragraph.indentation.hanging !== undefined) attrs.push(`w:hanging="${paragraph.indentation.hanging}"`);
-    if (attrs.length > 0) {
-      parts.push(`<w:ind ${attrs.join(" ")}/>`);
-    }
-  }
-  return `<w:pPr>${parts.join("")}</w:pPr>`;
-}
-
-function escapeAttributeXml(value: string): string {
-  return value
-    .replace(/&/g, "&amp;")
-    .replace(/</g, "&lt;")
-    .replace(/>/g, "&gt;")
-    .replace(/"/g, "&quot;");
-}
-
-function isSelectionSuggesting(runtime: WordReviewEditorRuntime): boolean {
-  return runtime.getInteractionGuardSnapshot().effectiveMode === "suggest";
-}
-
-function getFormattingOperationCommandName(
-  operation:
-    | { type: "toggle"; mark: "bold" | "italic" | "underline" | "strikethrough" | "superscript" | "subscript" }
-    | { type: "set-font-family"; fontFamily: string | null }
-    | { type: "set-font-size"; size: number | null }
-    | { type: "set-text-color"; color: string | null }
-    | { type: "set-highlight-color"; color: string | null }
-    | { type: "set-alignment"; alignment: FormattingAlignment }
-    | { type: "indent" }
-    | { type: "outdent" },
-): string {
-  switch (operation.type) {
-    case "toggle":
-      return `toggle${operation.mark.charAt(0).toUpperCase()}${operation.mark.slice(1)}`;
-    case "set-font-family":
-      return "setFontFamily";
-    case "set-font-size":
-      return "setFontSize";
-    case "set-text-color":
-      return "setTextColor";
-    case "set-highlight-color":
-      return "setHighlightColor";
-    case "set-alignment":
-      return "setAlignment";
-    case "indent":
-      return "indent";
-    case "outdent":
-      return "outdent";
-  }
-}
-
-function applyRuntimeDeleteSectionBreak(
-  runtime: WordReviewEditorRuntime,
-  sectionIndex: number,
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot) || snapshot.activeStory.kind !== "main") {
-    return;
-  }
-  if (emitWorkflowBlockedMutation(runtime, "deleteSectionBreak")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("deleteSectionBreak", [{
-      code: "unsupported_surface",
-      message: "Section break deletion is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-
-  const sessionState = runtime.getSessionState();
-  const timestamp = new Date().toISOString();
-  const result = deleteSectionBreakAtSectionIndex(
-    sessionState.canonicalDocument,
-    sectionIndex,
-    { timestamp },
-  );
-
-  dispatchRuntimeDocumentMutation(
-    runtime,
-    {
-      changed: result.changed,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    timestamp,
-  );
-}
-
-function applyRuntimeUpdateSectionLayout(
-  runtime: WordReviewEditorRuntime,
-  sectionIndex: number,
-  patch: SectionLayoutPatch,
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot) || snapshot.activeStory.kind !== "main") {
-    return;
-  }
-  if (emitWorkflowBlockedMutation(runtime, "updateSectionLayout")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("updateSectionLayout", [{
-      code: "unsupported_surface",
-      message: "Section layout updates are not supported in suggesting mode.",
-    }]);
-    return;
-  }
-
-  const sessionState = runtime.getSessionState();
-  const timestamp = new Date().toISOString();
-  const result = updateSectionLayoutAtSectionIndex(
-    sessionState.canonicalDocument,
-    sectionIndex,
-    {
-      ...(patch.pageSize ? { pageSize: patch.pageSize } : {}),
-      ...(patch.pageMargins ? { pageMargins: patch.pageMargins } : {}),
-      ...(patch.columns ? { columns: patch.columns } : {}),
-      ...(patch.titlePage !== undefined ? { titlePage: patch.titlePage } : {}),
-      ...(patch.sectionType ? { sectionType: patch.sectionType } : {}),
-    },
-    { timestamp },
-  );
-
-  dispatchRuntimeDocumentMutation(
-    runtime,
-    {
-      changed: result.changed,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    timestamp,
-  );
-}
-
-function applyRuntimeSetSectionPageNumbering(
-  runtime: WordReviewEditorRuntime,
-  sectionIndex: number,
-  patch: SectionPageNumberingPatch | null,
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot) || snapshot.activeStory.kind !== "main") {
-    return;
-  }
-  if (emitWorkflowBlockedMutation(runtime, "setSectionPageNumbering")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("setSectionPageNumbering", [{
-      code: "unsupported_surface",
-      message: "Section page numbering updates are not supported in suggesting mode.",
-    }]);
-    return;
-  }
-
-  const sessionState = runtime.getSessionState();
-  const timestamp = new Date().toISOString();
-  const normalizedPatch =
-    patch === null
-      ? null
-      : {
-          ...(patch.format !== undefined
-            ? { format: patch.format ?? undefined }
-            : {}),
-          ...(patch.start !== undefined
-            ? { start: patch.start ?? undefined }
-            : {}),
-          ...(patch.chapterStyle !== undefined
-            ? { chapStyle: patch.chapterStyle ?? undefined }
-            : {}),
-          ...(patch.chapterSeparator !== undefined
-            ? { chapSep: patch.chapterSeparator ?? undefined }
-            : {}),
-        };
-  const result = setSectionPageNumberingAtSectionIndex(
-    sessionState.canonicalDocument,
-    sectionIndex,
-    normalizedPatch,
-    { timestamp },
-  );
-
-  dispatchRuntimeDocumentMutation(
-    runtime,
-    {
-      changed: result.changed,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    timestamp,
-  );
-}
-
-function applyRuntimeSetHeaderFooterLink(
-  runtime: WordReviewEditorRuntime,
-  sectionIndex: number,
-  patch: HeaderFooterLinkPatch,
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot) || snapshot.activeStory.kind !== "main") {
-    return;
-  }
-  if (emitWorkflowBlockedMutation(runtime, "setHeaderFooterLink")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("setHeaderFooterLink", [{
-      code: "unsupported_surface",
-      message: "Header and footer linkage updates are not supported in suggesting mode.",
-    }]);
-    return;
-  }
-
-  const sessionState = runtime.getSessionState();
-  const timestamp = new Date().toISOString();
-  const result = setHeaderFooterLinkAtSectionIndex(
-    sessionState.canonicalDocument,
-    sectionIndex,
-    patch,
-    { timestamp },
-  );
-
-  dispatchRuntimeDocumentMutation(
-    runtime,
-    {
-      changed: result.changed,
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(result.selection),
-    },
-    timestamp,
-  );
-}
-
-function applyRuntimeInsertPageBreak(runtime: WordReviewEditorRuntime): void {
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("insertPageBreak", [{
-      code: "unsupported_surface",
-      message: "Page break insertion is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "insertPageBreak");
-  if (!context) {
-    return;
-  }
-
-  const result = insertPageBreakInDocument(
-    context.localDocument,
-    toRuntimeSelectionSnapshot(context.localSnapshot.selection),
-    { timestamp: context.timestamp },
-  );
-  dispatchStoryMutationResult(runtime, context, result, context.timestamp);
-}
-
-function applyRuntimeInsertTable(
-  runtime: WordReviewEditorRuntime,
-  options: InsertTableOptions,
-): void {
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("insertTable", [{
-      code: "unsupported_surface",
-      message: "Table insertion is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "insertTable");
-  if (!context) {
-    return;
-  }
-
-  const result = insertTableInDocument(
-    context.localDocument,
-    toRuntimeSelectionSnapshot(context.localSnapshot.selection),
-    options,
-    { timestamp: context.timestamp },
-  );
-  dispatchStoryMutationResult(runtime, context, result, context.timestamp);
-}
-
-function applyRuntimeInsertImage(
-  runtime: WordReviewEditorRuntime,
-  options: InsertImageOptions,
-): void {
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("insertImage", [{
-      code: "unsupported_surface",
-      message: "Image insertion is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "insertImage");
-  if (!context) {
-    return;
-  }
-
-  try {
-    const result = insertImageInDocument(
-      context.localDocument,
-      toRuntimeSelectionSnapshot(context.localSnapshot.selection),
-      options.data,
-      options.mimeType,
-      options.width,
-      options.height,
-      {
-        timestamp: context.timestamp,
-        altText: options.altText,
-      },
-    );
-    dispatchStoryMutationResult(runtime, context, {
-      changed: true,
-      document: result.document,
-      selection: result.selection,
-      mapping: result.mapping,
-    }, context.timestamp);
-  } catch {
-    return;
-  }
-}
-
-function applyRuntimeImageResize(
-  runtime: WordReviewEditorRuntime,
-  mediaId: string,
-  dimensions: { widthEmu: number; heightEmu: number },
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot)) {
-    return;
-  }
-  if (emitWorkflowBlockedMutation(runtime, "setImageLayout")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("setImageLayout", [{
-      code: "unsupported_surface",
-      message: "Image resize is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-
-  try {
-    const sessionState = runtime.getSessionState();
-    const result = resizeImageInCatalog(
-      sessionState.canonicalDocument,
-      mediaId,
-      dimensions,
-    );
-    runtime.dispatch({
-      type: "document.replace",
-      document: result.document,
-      selection: toRuntimeSelectionSnapshot(snapshot.selection),
-      origin: { source: "api", timestamp: new Date().toISOString() },
-    });
-  } catch {
-    return;
-  }
-}
-
-function applyRuntimeImageReposition(
-  runtime: WordReviewEditorRuntime,
-  mediaId: string,
-  offsets: { horizontalOffsetEmu?: number; verticalOffsetEmu?: number },
-): void {
-  if (emitWorkflowBlockedMutation(runtime, "setImageFrame")) {
-    return;
-  }
-  if (isSelectionSuggesting(runtime)) {
-    runtime.emitBlockedCommand("setImageFrame", [{
-      code: "unsupported_surface",
-      message: "Image reposition is not supported in suggesting mode.",
-    }]);
-    return;
-  }
-  const context = getStoryMutationContext(runtime, "setImageFrame");
-  if (!context) {
-    return;
-  }
-
-  try {
-    const result = repositionFloatingImageInDocument(
-      context.localDocument,
-      mediaId,
-      offsets,
-      context.timestamp,
-    );
-    dispatchStoryMutationResult(
-      runtime,
-      context,
-      {
-        changed: true,
-        document: result.document,
-        selection: toRuntimeSelectionSnapshot(context.localSnapshot.selection),
-      },
-      context.timestamp,
-    );
-  } catch {
-    return;
-  }
-}
-
-// deriveViewState removed — the runtime's getViewState() is now the single
-// source of truth for EditorViewStateSnapshot, backed by view-state.ts.
-
-function applyRuntimeTableStructureOperation(
-  runtime: WordReviewEditorRuntime,
-  mountedSurface: TwProseMirrorSurfaceRef | null | undefined,
-  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: coercedReason,
-    }]);
-    return { changed: false, coercedReason };
-  }
-  const context = getStoryMutationContext(runtime, `table.${operation.type}`);
-  if (!context) {
-    return { changed: false, coercedReason: "No active mutation context." };
-  }
-
-  const result = applyTableStructureOperation(
-    context.localDocument,
-    context.localSnapshot,
-    mountedSurface?.getTableSelection() ?? null,
-    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
-    );
-  };
+  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" }>,
@@ -4930,324 +3811,8 @@ function buildTablesFacet(
 
 export { buildTablesFacet as __buildTablesFacet };
 
-const DISPATCH_CONTEXT: DispatchContext = {
-  getStoryMutationContext,
-  dispatchStoryMutationResult,
-  resolveActiveParagraphContext,
-  toRuntimeSelectionSnapshot,
-};
-
-function resolveActiveParagraphContext(
-  snapshot: Pick<RuntimeRenderSnapshot, "surface" | "selection">,
-): {
-  paragraphIndex: number;
-  paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>;
-  atParagraphStart: boolean;
-  isEmpty: boolean;
-} | null {
-  if (!snapshot.surface) {
-    return null;
-  }
-
-  const paragraphIndex = resolveActiveParagraphIndex(
-    snapshot.surface.blocks,
-    snapshot.selection,
-  );
-  if (paragraphIndex === null) {
-    return null;
-  }
-
-  const selectionPosition =
-    snapshot.selection.activeRange.kind === "node"
-      ? snapshot.selection.activeRange.at
-      : snapshot.selection.head;
-  const paragraph = findSurfaceParagraphAtPosition(snapshot.surface.blocks, selectionPosition);
-  if (!paragraph) {
-    return null;
-  }
-
-  return {
-    paragraphIndex,
-    paragraph,
-    atParagraphStart:
-      snapshot.selection.isCollapsed &&
-      snapshot.selection.activeRange.kind !== "node" &&
-      snapshot.selection.anchor === snapshot.selection.head &&
-      snapshot.selection.head === paragraph.from,
-    isEmpty: isSurfaceParagraphEmpty(paragraph),
-  };
-}
-
-function findSurfaceParagraphAtPosition(
-  blocks: readonly SurfaceBlockSnapshot[],
-  position: number,
-): Extract<SurfaceBlockSnapshot, { kind: "paragraph" }> | null {
-  for (const block of blocks) {
-    if (position < block.from || position > block.to) {
-      continue;
-    }
-    if (block.kind === "paragraph") {
-      return block;
-    }
-    if (block.kind === "table") {
-      for (const row of block.rows) {
-        for (const cell of row.cells) {
-          const paragraph = findSurfaceParagraphAtPosition(cell.content, position);
-          if (paragraph) {
-            return paragraph;
-          }
-        }
-      }
-      continue;
-    }
-    if (block.kind === "sdt_block") {
-      const paragraph = findSurfaceParagraphAtPosition(block.children, position);
-      if (paragraph) {
-        return paragraph;
-      }
-    }
-  }
-  return null;
-}
-
-function isSurfaceParagraphEmpty(
-  paragraph: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
-): boolean {
-  if (paragraph.segments.length === 0) {
-    return true;
-  }
-  return paragraph.segments.every((segment) => segment.kind === "text" && segment.text.length === 0);
-}
-
-function applyRuntimeSelection(
-  runtime: WordReviewEditorRuntime,
-  selection: PublicSelectionSnapshot,
-): void {
-  const requestedStory = selection.storyTarget ?? { kind: "main" };
-  if (requestedStory.kind === "main") {
-    runtime.closeStory();
-  } else if (!storyTargetsEqual(runtime.getActiveStory(), requestedStory)) {
-    if (!runtime.openStory(requestedStory)) {
-      return;
-    }
-  }
-
-  runtime.dispatch({
-    type: "selection.set",
-    selection: toRuntimeSelectionSnapshot(stripStoryTarget(selection)),
-  });
-}
-
-function canApplyRuntimeMutation(snapshot: RuntimeRenderSnapshot): boolean {
-  return snapshot.isReady && !snapshot.readOnly && !snapshot.fatalError;
-}
-
-function emitWorkflowBlockedMutation(
-  runtime: WordReviewEditorRuntime,
-  command: string,
-): boolean {
-  const interactionGuardSnapshot = runtime.getInteractionGuardSnapshot();
-  if (interactionGuardSnapshot.blockedReasons.length === 0) {
-    return false;
-  }
-  runtime.emitBlockedCommand(command, interactionGuardSnapshot.blockedReasons);
-  return true;
-}
-
-function getStoryMutationContext(
-  runtime: WordReviewEditorRuntime,
-  command?: string,
-): {
-  timestamp: string;
-  activeStory: EditorStoryTarget;
-  persistedDocument: EditorSessionState["canonicalDocument"];
-  localDocument: EditorSessionState["canonicalDocument"];
-  localSnapshot: RuntimeRenderSnapshot;
-} | null {
-  const snapshot = runtime.getRenderSnapshot();
-  if (!canApplyRuntimeMutation(snapshot)) {
-    return null;
-  }
-  if (command && emitWorkflowBlockedMutation(runtime, command)) {
-    return null;
-  }
-
-  const persistedDocument = runtime.getSessionState().canonicalDocument;
-  const activeStory = snapshot.activeStory;
-  if (activeStory.kind === "main") {
-    return {
-      timestamp: new Date().toISOString(),
-      activeStory,
-      persistedDocument,
-      localDocument: persistedDocument,
-      localSnapshot: snapshot,
-    };
-  }
-
-  return {
-    timestamp: new Date().toISOString(),
-    activeStory,
-    persistedDocument,
-    localDocument: {
-      ...persistedDocument,
-      content: {
-        type: "doc",
-        children: [...getStoryBlocks(persistedDocument, activeStory)],
-      },
-    },
-    localSnapshot: {
-      ...snapshot,
-      activeStory: { kind: "main" },
-      selection: stripStoryTarget(snapshot.selection),
-    },
-  };
-}
-
-function dispatchStoryMutationResult(
-  runtime: WordReviewEditorRuntime,
-  context: {
-    activeStory: EditorStoryTarget;
-    persistedDocument: EditorSessionState["canonicalDocument"];
-  },
-  result: {
-    changed: boolean;
-    document: EditorSessionState["canonicalDocument"];
-    selection: InternalSelectionSnapshot;
-    mapping?: TransactionMapping;
-  },
-  timestamp: string,
-): void {
-  if (context.activeStory.kind === "main") {
-    dispatchRuntimeDocumentMutation(runtime, result, timestamp);
-    return;
-  }
-
-  if (!result.changed) {
-    return;
-  }
-
-  const nextDocument = replaceStoryBlocks(
-    context.persistedDocument,
-    context.activeStory,
-    result.document.content.children,
-  );
-  dispatchRuntimeDocumentMutation(
-    runtime,
-    {
-      changed: true,
-      document: nextDocument,
-      selection: result.selection,
-    },
-    timestamp,
-  );
-}
-
-function dispatchRuntimeDocumentMutation(
-  runtime: WordReviewEditorRuntime,
-  result: {
-    changed: boolean;
-    document: EditorSessionState["canonicalDocument"];
-    selection: InternalSelectionSnapshot;
-    mapping?: TransactionMapping;
-  },
-  timestamp: string,
-): void {
-  if (!result.changed) {
-    return;
-  }
-
-  runtime.dispatch({
-    type: "document.replace",
-    document: {
-      ...result.document,
-      updatedAt: timestamp,
-    },
-    mapping: result.mapping,
-    selection: result.selection,
-    origin: {
-      source: "api",
-      timestamp,
-    },
-  });
-}
-
-function stripStoryTarget(
-  selection: PublicSelectionSnapshot,
-): PublicSelectionSnapshot {
-  const { storyTarget: _storyTarget, ...rest } = selection;
-  return rest;
-}
-
-function applyRuntimeDeleteComment(
-  runtime: WordReviewEditorRuntime,
-  commentId: string,
-): void {
-  const snapshot = runtime.getRenderSnapshot();
-  // Pre-ready / fatal states stay silent: the host called too early, and
-  // there is no meaningful document yet to signal against. Emitting a
-  // warning here would only add noise to load-time error handling.
-  if (!snapshot.isReady || snapshot.fatalError) {
-    return;
-  }
-  if (snapshot.readOnly) {
-    runtime.emitTransientWarning({
-      warningId: `delete-comment-readonly-${commentId}-${Date.now()}`,
-      code: "review_target_not_found",
-      severity: "info",
-      message: `deleteComment("${commentId}") skipped: editor is read-only.`,
-      source: "review",
-      details: { op: "deleteComment", targetId: commentId, reason: "read_only" },
-    });
-    return;
-  }
-
-  const sessionState = runtime.getSessionState();
-  if (!sessionState.canonicalDocument.review.comments[commentId]) {
-    runtime.emitTransientWarning({
-      warningId: `delete-comment-unknown-${commentId}-${Date.now()}`,
-      code: "review_target_not_found",
-      severity: "info",
-      message: `deleteComment("${commentId}") skipped: unknown commentId.`,
-      source: "review",
-      details: { op: "deleteComment", targetId: commentId, reason: "comment_unknown" },
-    });
-    return;
-  }
 
-  const nextComments = {
-    ...sessionState.canonicalDocument.review.comments,
-  };
-  delete nextComments[commentId];
-
-  runtime.dispatch({
-    type: "document.replace",
-    document: {
-      ...sessionState.canonicalDocument,
-      review: {
-        ...sessionState.canonicalDocument.review,
-        comments: nextComments,
-      },
-    },
-    selection: toRuntimeSelectionSnapshot(snapshot.selection),
-    origin: {
-      source: "api",
-      timestamp: new Date().toISOString(),
-    },
-  });
-}
 
-function normalizeRequestedSelection(
-  snapshot: RuntimeRenderSnapshot,
-  selection: PublicSelectionSnapshot | null,
-): PublicSelectionSnapshot {
-  return (
-    selection ??
-    createCollapsedPublicSelection(
-      snapshot.selection.head,
-      snapshot.activeStory.kind === "main" ? undefined : snapshot.activeStory,
-    )
-  );
-}
 
 export function __resolveLiveMarkupDisplay(
   requested: MarkupDisplay | undefined,
@@ -5256,45 +3821,11 @@ export function __resolveLiveMarkupDisplay(
   return requested ?? (isPageWorkspace ? "all" : "clean");
 }
 
-function createCollapsedPublicSelection(
-  position: number,
-  storyTarget?: EditorStoryTarget,
-): PublicSelectionSnapshot {
-  return {
-    anchor: position,
-    head: position,
-    isCollapsed: true,
-    activeRange: {
-      kind: "range",
-      from: position,
-      to: position,
-      assoc: {
-        start: -1,
-        end: 1,
-      },
-    },
-    ...(storyTarget ? { storyTarget } : {}),
-  };
-}
 
 function clonePublicValue<T>(value: T): T {
   return structuredClone(value);
 }
 
-function findTextMatchesForRuntime(
-  runtime: WordReviewEditorRuntime,
-  query: string,
-  options: SearchOptions | undefined,
-): EditorAnchorProjection[] {
-  const snapshot = runtime.getRenderSnapshot();
-  return findTextMatches(
-    runtime.getSessionState().canonicalDocument,
-    snapshot.selection,
-    query,
-    options ?? {},
-  );
-}
-
 /**
  * Open the correct header/footer story for a specific page.  The page's
  * resolved `stories.header` / `stories.footer` already carries the
@@ -5314,27 +3845,6 @@ function openStoryForPage(
   runtime.openStory(target);
 }
 
-function searchRuntimeDocument(
-  runtime: WordReviewEditorRuntime,
-  mountedSurface: TwProseMirrorSurfaceRef | null,
-  query: string,
-  options: SearchOptions = {},
-): SearchResultSnapshot[] {
-  if (mountedSurface) {
-    return mountedSurface.search(query, options);
-  }
-
-  const snapshot = runtime.getRenderSnapshot();
-  return searchDocument(
-    runtime.getSessionState().canonicalDocument,
-    snapshot.selection,
-    snapshot.activeStory,
-    runtime.getDocumentNavigationSnapshot(),
-    query,
-    options,
-  );
-}
-
 function applyRegionAttributes(shell: HTMLElement): void {
   const toolbar = shell.querySelector<HTMLElement>("header");
   if (toolbar) {
@@ -5528,58 +4038,6 @@ function resolveWordReviewEditorChromeVisibility(
   });
 }
 
-function toRuntimeSelectionSnapshot(selection: PublicSelectionSnapshot) {
-  return {
-    anchor: selection.anchor,
-    head: selection.head,
-    isCollapsed: selection.isCollapsed,
-    activeRange:
-      selection.activeRange.kind === "range"
-        ? createRangeAnchor(
-            selection.activeRange.from,
-            selection.activeRange.to,
-            selection.activeRange.assoc,
-          )
-        : selection.activeRange.kind === "node"
-          ? createNodeAnchor(selection.activeRange.at, selection.activeRange.assoc)
-          : createDetachedAnchor(
-              selection.activeRange.lastKnownRange,
-              selection.activeRange.reason,
-            ),
-  };
-}
-
-function createSelectionFromAnchor(
-  anchor: PublicSelectionSnapshot["activeRange"],
-  storyTarget?: EditorStoryTarget,
-): PublicSelectionSnapshot {
-  switch (anchor.kind) {
-    case "range":
-      return {
-        anchor: anchor.from,
-        head: anchor.to,
-        isCollapsed: anchor.from === anchor.to,
-        activeRange: anchor,
-        ...(storyTarget ? { storyTarget } : {}),
-      };
-    case "node":
-      return {
-        anchor: anchor.at,
-        head: anchor.at,
-        isCollapsed: true,
-        activeRange: anchor,
-        ...(storyTarget ? { storyTarget } : {}),
-      };
-    case "detached":
-      return {
-        anchor: anchor.lastKnownRange.from,
-        head: anchor.lastKnownRange.to,
-        isCollapsed: anchor.lastKnownRange.from === anchor.lastKnownRange.to,
-        activeRange: anchor,
-        ...(storyTarget ? { storyTarget } : {}),
-      };
-  }
-}
 
 function estimateStoryLength(
   sessionStateOrSnapshot?: EditorSessionState | PersistedEditorSnapshot,
@@ -6381,19 +4839,6 @@ function findImageNodeInValue(
   return null;
 }
 
-function createImageDataUrl(contentType: string, bytes: Uint8Array): string {
-  const base64 = bytesToBase64(bytes);
-  return `data:${contentType};base64,${base64}`;
-}
-
-function bytesToBase64(bytes: Uint8Array): string {
-  let binary = "";
-  for (let index = 0; index < bytes.length; index += 1) {
-    binary += String.fromCharCode(bytes[index] ?? 0);
-  }
-  return btoa(binary);
-}
-
 function deriveReviewQueueSnapshot(input: {
   sections: Array<{
     sectionIndex: number;