@beyondwork/docx-react-component 1.0.66 → 1.0.69

package/src/ui-tailwind/chrome/tw-table-grip-layer.tsx

@@ -27,6 +27,7 @@ import type {
   TableStructureContextSnapshot,
   WordReviewEditorLayoutFacet,
 } from "../../api/public-types";
+import type { GeometryFacet } from "../../api/public-types";
 import type { OverlayCoordinateSpace } from "../chrome-overlay/chrome-overlay-projector";
 import { projectRectToOverlay } from "../chrome-overlay/chrome-overlay-projector";
 import { DEFAULT_PX_PER_TWIP } from "../../runtime/render/render-frame-types";
@@ -39,7 +40,19 @@ const MIN_COLUMN_TWIPS = 720;
 const MIN_ROW_TWIPS = 120;
 
 export interface TwTableGripLayerProps {
+  /**
+   * Layout facet — still used for layout-semantic reads
+   * (`getFirstPageIndexForBlock`, `getTableRenderPlan`). These stay
+   * on the layout facet per architecture-04 (twip-valued,
+   * page-graph-derived data, not pixel geometry).
+   */
   facet: WordReviewEditorLayoutFacet;
+  /**
+   * Geometry facet — used for render-frame + zoom access. Migrated
+   * from `facet.getRenderFrame` / `facet.getRenderZoom` in the
+   * refactor/05 cross-lane-coord §8.4 pass.
+   */
+  geometryFacet: GeometryFacet;
   tableContext: TableStructureContextSnapshot | null;
   space?: OverlayCoordinateSpace;
   disabled?: boolean;
@@ -53,6 +66,7 @@ export interface TwTableGripLayerProps {
 
 export function TwTableGripLayer({
   facet,
+  geometryFacet,
   tableContext,
   space,
   disabled,
@@ -61,10 +75,7 @@ export function TwTableGripLayer({
 }: TwTableGripLayerProps) {
   if (!tableContext) return null;
 
-  const frame =
-    typeof facet.getRenderFrame === "function"
-      ? (facet.getRenderFrame() ?? null)
-      : null;
+  const frame = geometryFacet.getRenderFrame() ?? null;
   if (!frame) return null;
 
   const blockId = `table-${tableContext.tableBlockIndex}`;
@@ -72,10 +83,7 @@ export function TwTableGripLayer({
   const plan = facet.getTableRenderPlan(blockId, pageIndex);
   if (!plan) return null;
 
-  const pxPerTwip =
-    typeof facet.getRenderZoom === "function"
-      ? (facet.getRenderZoom()?.pxPerTwip ?? DEFAULT_PX_PER_TWIP)
-      : DEFAULT_PX_PER_TWIP;
+  const pxPerTwip = geometryFacet.getRenderZoom()?.pxPerTwip ?? DEFAULT_PX_PER_TWIP;
 
   return (
     <>

package/src/ui-tailwind/chrome/tw-workspace-chrome-host.tsx

@@ -0,0 +1,276 @@
+/**
+ * TwWorkspaceChromeHost — composition-level mount that wires together:
+ *   - the right-click context menu (portal-based, viewport-clamped)
+ *   - the global command palette (Ctrl/Cmd+K)
+ *   - the shared editor-action registry
+ *
+ * Per DESIGN-EDITOR.md §6.4 the three access routes (right-click,
+ * inline "More…" buttons shipped in Phase D, and command palette)
+ * all read from the same registry so they cannot diverge.  This
+ * component is the single mount point that routes all three.
+ *
+ * Progressive-disclosure discipline (designsystem.md §2.1 principle 4):
+ *   - Context menu opens only on user right-click and closes on
+ *     Escape, outside-click, or row selection.
+ *   - Menu is suppressed when no wired callback would produce at
+ *     least one entry — no empty menus.
+ *   - Command palette opens only on Ctrl/Cmd+K and fuzzy-matches
+ *     across the same registry.
+ *   - All surfaces dismiss themselves (run → dismiss) so focus
+ *     returns to the editor immediately after an action fires.
+ *
+ * Host-side contract (TwReviewWorkspaceProps will thread this in):
+ *   - `editorActionHost`: callback bag wired from ref methods
+ *     (WordReviewEditorRef) that the shared registry dispatches to.
+ *     Actions without a wired callback are hidden from every access
+ *     route.
+ *   - `mode`: current ChromeComposition.mode — drives mode-filtered
+ *     actions (e.g. scope-only actions hide in edit mode).
+ *   - `onContextMenuRequest` is the handler hosts pass into
+ *     `tw-prosemirror-surface`'s command-bridge callback.
+ *
+ * Perf invariants honored:
+ *   - No DOM reads on the edit path (invariant 7).
+ *   - No PM-transaction subscriptions.
+ *   - Portal mounts only while open (invariant 4).
+ */
+
+import React, { useImperativeHandle, useMemo, useRef } from "react";
+
+import type {
+  EditorChromeMode,
+  EditorRailTab,
+} from "../../api/v3/ui/chrome-composition";
+import type {
+  EditorActionHostCallbacks,
+  TargetKind,
+} from "./editor-action-registry";
+import { buildPaletteGroupsFromRegistry } from "./editor-actions-to-palette";
+import { TwCommandPaletteMount } from "./tw-command-palette-mount";
+import { TwContextMenuPortal } from "./tw-context-menu-portal";
+import {
+  useContextMenuController,
+  type ContextMenuRequest,
+} from "./use-context-menu-controller";
+
+/**
+ * Build a stable host-callbacks proxy that always reads from the
+ * supplied ref.  Pattern mirrors `callbacksRef` in
+ * `src/ui-tailwind/editor-surface/tw-prosemirror-surface.tsx:370–408`:
+ * the owning component sync-writes `hostRef.current = freshProps` at
+ * the top of every render, and consumers read through this proxy so
+ * they see the latest callbacks without the proxy identity ever
+ * changing.  That stability lets the palette + registry + controller
+ * memo their outputs on (mode, proxy) — (mode) in practice, since the
+ * proxy is static per component lifetime.
+ */
+function createStableHostProxy(
+  hostRef: { current: EditorActionHostCallbacks },
+): EditorActionHostCallbacks {
+  // Proxy construction is ~free and happens exactly once per component
+  // lifetime (see the empty-dep useMemo call site below).  The `get`
+  // trap forwards to whichever callback the host currently has.
+  return new Proxy({} as EditorActionHostCallbacks, {
+    get: (_target, prop) => {
+      // Only read declared keys — filter `Symbol.toPrimitive` etc. so
+      // `typeof host[key] === "function"` checks elsewhere behave
+      // predictably.
+      if (typeof prop !== "string") return undefined;
+      return (hostRef.current as Record<string, unknown>)[prop];
+    },
+    has: (_target, prop) => {
+      if (typeof prop !== "string") return false;
+      return prop in (hostRef.current as Record<string, unknown>);
+    },
+    // `ownKeys` + `getOwnPropertyDescriptor` left default — iteration
+    // over the proxy isn't part of the registry contract.
+  });
+}
+
+export interface TwWorkspaceChromeHostProps {
+  /** Current composition mode; filters mode-scoped actions. */
+  mode: EditorChromeMode;
+  /**
+   * Callback bag for shared editor actions.  Actions whose callback is
+   * absent are hidden from every surface (progressive disclosure).
+   */
+  editorActionHost: EditorActionHostCallbacks;
+  /**
+   * Optional scope root for target-kind resolution.  Traversal stops
+   * here so right-click on a scope card doesn't walk into the shell.
+   */
+  surfaceRoot?: Element | null;
+  /**
+   * Suppress the global Ctrl+K listener (e.g. while a higher-priority
+   * modal captures keyboard focus).
+   */
+  paletteDisabled?: boolean;
+  /**
+   * When defined, the host routes keyboard Shift+F10 + "More…" button
+   * invocations here.  Typically just the workspace's `contextMenuRef`
+   * — wiring below.
+   */
+  controllerRef?: React.Ref<TwWorkspaceChromeHostController>;
+  /**
+   * Element to return focus to when the menu/palette closes.  Usually
+   * the PM editor surface so typing resumes where it left off.
+   */
+  returnFocusTo?: HTMLElement | null;
+  /**
+   * Host-supplied callback invoked when another chrome surface asks the
+   * rail to pivot to a specific tab — Phase E uses this for the signal-
+   * only diagnostics button (opens `"health"`) and the alert-banner's
+   * "Show detail" handoff.  Hosts typically implement it by opening the
+   * rail drawer and forwarding `tab` to the rail's active-tab change
+   * handler.  Omitting the prop turns `controller.openRailTab` into a
+   * no-op so hosts that haven't opted in see no behavior change.
+   */
+  onOpenRailTab?: (tab: EditorRailTab, itemId?: string) => void;
+  /**
+   * Optional live table-structure context (Chrome Closure Pass · Task 3).
+   * When supplied and the right-click target lands inside a table cell,
+   * the menu controller adds tier-specific kinds (`"table-row"` /
+   * `"table-column"` / `"table-whole"`) so the menu entries match the
+   * §6.9 tier ladder. Pass null when no table is active or the snapshot
+   * is unavailable.
+   */
+  tableContext?: import("../../api/public-types").TableStructureContextSnapshot | null;
+}
+
+/**
+ * Imperative surface exposed via `controllerRef` so the workspace can:
+ *   - forward contextmenu events from the pm-command-bridge into the
+ *     menu controller
+ *   - open the menu at the current caret (Shift+F10 from the shortcut
+ *     dispatcher)
+ *   - open the menu with pre-resolved target kinds ("More…" buttons
+ *     on demoted floating toolbars — Phase D)
+ */
+export interface TwWorkspaceChromeHostController {
+  handleContextMenuRequest: (request: ContextMenuRequest) => void;
+  openWithKinds: (args: {
+    clientX: number;
+    clientY: number;
+    kinds: readonly TargetKind[];
+  }) => void;
+  dismissContextMenu: () => void;
+  /**
+   * Ask the host to pivot the management rail to `tab`.  The host
+   * implementation (typically `TwReviewWorkspace`) opens the rail drawer
+   * and calls `onActiveRailTabChange(tab)`.  No-op when the host didn't
+   * supply `onOpenRailTab`.
+   */
+  openRailTab: (tab: EditorRailTab, itemId?: string) => void;
+}
+
+export function TwWorkspaceChromeHost(
+  props: TwWorkspaceChromeHostProps,
+): React.JSX.Element {
+  const {
+    mode,
+    editorActionHost,
+    surfaceRoot,
+    paletteDisabled,
+    controllerRef,
+    returnFocusTo,
+    onOpenRailTab,
+  } = props;
+
+  // B1 fix — mirror the `callbacksRef` pattern in tw-prosemirror-surface
+  // so the host-callbacks proxy passed into the controller and the
+  // palette adapter stays referentially stable across renders, even
+  // when the integrator rebuilds `editorActionHost` inline on every
+  // parent render.  Perf invariant 4: palette memo deps collapse to
+  // `[mode]` so wholesale-snapshot re-renders don't rebuild groups.
+  const hostRef = useRef<EditorActionHostCallbacks>(editorActionHost);
+  hostRef.current = editorActionHost;
+  const stableHost = useMemo(() => createStableHostProxy(hostRef), []);
+
+  const controller = useContextMenuController({
+    mode,
+    host: stableHost,
+    root: surfaceRoot ?? null,
+    ...(props.tableContext !== undefined ? { tableContext: props.tableContext } : {}),
+  });
+
+  // N2 fix — imperative handle identity must be stable across the
+  // component lifetime so downstream effects that read controllerRef
+  // don't self-trigger on every menu state change.  Ref-wrap each
+  // method, then bind to empty deps.
+  const requestRef = useRef(controller.request);
+  requestRef.current = controller.request;
+  const requestWithKindsRef = useRef(controller.requestWithKinds);
+  requestWithKindsRef.current = controller.requestWithKinds;
+  const dismissRef = useRef(controller.dismiss);
+  dismissRef.current = controller.dismiss;
+  // Phase E.0 — ref-sync the rail-tab callback so the imperative handle
+  // identity stays stable while still dispatching to the freshest host
+  // closure on every call.  `undefined` is kept in the ref when the host
+  // omits the prop so `openRailTab` becomes a safe no-op.
+  const openRailTabRef = useRef<
+    ((tab: EditorRailTab, itemId?: string) => void) | undefined
+  >(onOpenRailTab);
+  openRailTabRef.current = onOpenRailTab;
+
+  useImperativeHandle(
+    controllerRef,
+    () => ({
+      handleContextMenuRequest: (req) => requestRef.current(req),
+      openWithKinds: (args) => requestWithKindsRef.current(args),
+      dismissContextMenu: () => dismissRef.current(),
+      openRailTab: (tab, itemId) => {
+        openRailTabRef.current?.(tab, itemId);
+      },
+    }),
+    [],
+  );
+
+  // Palette groups rebuild only on mode change — host-callback identity
+  // is pinned via `stableHost`.  `dismiss` passed into the registry is
+  // a no-op here: TwCommandPalette closes itself via `onOpenChange`.
+  const paletteGroups = useMemo(
+    () =>
+      buildPaletteGroupsFromRegistry({
+        mode,
+        host: stableHost,
+        dismiss: noopDismiss,
+      }),
+    [mode, stableHost],
+  );
+
+  // When the palette would be empty (no wired callbacks), we still
+  // mount the adapter so the Ctrl+K listener is consistent, but pass
+  // an empty-state message so users see "nothing here" rather than a
+  // naked input.
+  const emptyMessage =
+    paletteGroups.length === 0
+      ? "No commands are available in this posture."
+      : undefined;
+
+  return (
+    <>
+      <TwContextMenuPortal
+        open={controller.state.open}
+        clientX={controller.state.clientX}
+        clientY={controller.state.clientY}
+        entries={controller.state.entries}
+        onDismiss={controller.dismiss}
+        {...(returnFocusTo !== undefined ? { returnFocusTo } : {})}
+      />
+      <TwCommandPaletteMount
+        groups={paletteGroups}
+        {...(paletteDisabled !== undefined ? { disabled: paletteDisabled } : {})}
+        {...(emptyMessage !== undefined ? { emptyMessage } : {})}
+      />
+    </>
+  );
+}
+
+// Module-scope constant so the dismiss reference fed into the palette
+// adapter is stable across the component's lifetime — contributes to
+// the useMemo([mode, stableHost]) cache stability.  The palette's
+// TwCommandPaletteMount owns its open state, so command invocations
+// dismiss via the palette's own onOpenChange; this is just a hook.
+function noopDismiss(): void {
+  // intentionally empty
+}

package/src/ui-tailwind/chrome/use-context-menu-controller.ts

@@ -0,0 +1,201 @@
+/**
+ * useContextMenuController — React hook that owns workspace-level
+ * context-menu state.  Consumers (TwReviewWorkspace, Phase C.γ.3) wire
+ * the returned `request(event)` into their `onContextMenuRequested`
+ * callback, then render `<TwContextMenuPortal {...state} />`.
+ *
+ * Progressive-disclosure discipline (designsystem.md §2.1 principle 4):
+ *   - No work happens until the user right-clicks.  Target resolution,
+ *     entry building, and portal mount all run ONLY inside `request()`.
+ *   - The edit path is untouched (invariant 7).
+ *
+ * State shape is intentionally minimal — the hook doesn't own
+ * composition, host callbacks, or target-kind classification; those
+ * are passed in per request so the same hook works for right-click,
+ * "More…" buttons (Phase D), and keyboard Shift+F10 (Phase C.γ.5).
+ */
+
+import { useCallback, useState } from "react";
+
+import type { TableStructureContextSnapshot } from "../../api/public-types";
+import type { EditorChromeMode } from "../../api/v3/ui/chrome-composition";
+import {
+  buildContextMenuEntries,
+  type BuildContextMenuInput,
+} from "./build-context-menu-entries";
+import type {
+  EditorActionHostCallbacks,
+  TargetKind,
+} from "./editor-action-registry";
+import { resolveTargetKind } from "./resolve-target-kind";
+import type { ContextMenuEntry } from "./tw-context-menu";
+import { resolveTableTier } from "./tw-table-context-toolbar";
+
+/**
+ * Project a `TableTier` to additional `TargetKind`s the menu should
+ * include. Mirrors the §6.9 tier ladder: a row-selected context (T3)
+ * surfaces both `"table-row"` and `"table-cell"` actions; a whole-
+ * table context (T5) surfaces every tier. Used by the menu controller
+ * when the host supplies a live table structure context — Chrome
+ * Closure Pass · Task 3.
+ */
+function tableContextToKinds(
+  ctx: TableStructureContextSnapshot | null,
+): readonly TargetKind[] {
+  if (!ctx) return [];
+  const tier = resolveTableTier(ctx);
+  switch (tier) {
+    case "caret-in-cell":
+      return ["table-cell"];
+    case "multi-cell":
+      return ["table-cell"];
+    case "row-selected":
+      return ["table-cell", "table-row"];
+    case "column-selected":
+      return ["table-cell", "table-column"];
+    case "whole-table":
+      return ["table-cell", "table-row", "table-column", "table-whole"];
+  }
+}
+
+export interface ContextMenuRequest {
+  readonly clientX: number;
+  readonly clientY: number;
+  readonly target: EventTarget | null;
+}
+
+export interface ContextMenuState {
+  readonly open: boolean;
+  readonly clientX: number;
+  readonly clientY: number;
+  readonly entries: ContextMenuEntry[];
+}
+
+export interface UseContextMenuControllerOptions {
+  readonly mode: EditorChromeMode;
+  readonly host: EditorActionHostCallbacks;
+  /**
+   * Optional root passed through to `resolveTargetKind` so traversal
+   * stops at the editor surface instead of walking into the shell
+   * header or rail.
+   */
+  readonly root?: Element | null;
+  /**
+   * Advanced: override the builder (for "More…" buttons that know
+   * their target kind a priori and don't need DOM resolution).
+   */
+  readonly resolveKinds?: (target: EventTarget | null) => readonly TargetKind[];
+  /**
+   * Optional live table structure context — when present and the
+   * right-click target resolves to `"table-cell"`, the controller
+   * adds tier-specific kinds (`"table-row"` / `"table-column"` /
+   * `"table-whole"`) so the menu entries match the §6.9 tier ladder
+   * (Chrome Closure Pass · Task 3). Pass null when no table is
+   * active or you do not have access to the snapshot.
+   */
+  readonly tableContext?: TableStructureContextSnapshot | null;
+}
+
+export interface ContextMenuController {
+  readonly state: ContextMenuState;
+  /** Call from the `onContextMenuRequested` bridge callback. */
+  request: (request: ContextMenuRequest) => void;
+  /** Open with pre-resolved kinds (Phase D "More…" buttons). */
+  requestWithKinds: (args: {
+    clientX: number;
+    clientY: number;
+    kinds: readonly TargetKind[];
+  }) => void;
+  dismiss: () => void;
+}
+
+const EMPTY_STATE: ContextMenuState = {
+  open: false,
+  clientX: 0,
+  clientY: 0,
+  entries: [],
+};
+
+export function useContextMenuController(
+  options: UseContextMenuControllerOptions,
+): ContextMenuController {
+  const { mode, host, root, resolveKinds, tableContext } = options;
+  const [state, setState] = useState<ContextMenuState>(EMPTY_STATE);
+
+  const dismiss = useCallback(() => {
+    setState(EMPTY_STATE);
+  }, []);
+
+  const buildEntries = useCallback(
+    (kinds: readonly TargetKind[]): ContextMenuEntry[] => {
+      const input: BuildContextMenuInput = {
+        targetKinds: kinds,
+        mode,
+        host,
+        dismiss,
+      };
+      return buildContextMenuEntries(input);
+    },
+    [mode, host, dismiss],
+  );
+
+  const request = useCallback(
+    (req: ContextMenuRequest) => {
+      const baseKinds = resolveKinds
+        ? resolveKinds(req.target)
+        : resolveTargetKind(req.target, { root: root ?? undefined });
+      // Chrome Closure Pass · Task 3 — augment with tier-specific
+      // kinds when a live table context is supplied and the target
+      // is in a table cell. Cell-level ops carry every table-* kind
+      // (so they are still visible) and tier-only ops (delete row /
+      // delete column) gate on the matching kind.
+      const tierKinds =
+        baseKinds.includes("table-cell") && tableContext
+          ? tableContextToKinds(tableContext)
+          : [];
+      const merged = [...baseKinds];
+      for (const k of tierKinds) {
+        if (!merged.includes(k)) merged.push(k);
+      }
+      const entries = buildEntries(merged);
+      // Progressive disclosure: if no actions resolve (every host callback
+      // absent + no scope-anchor + etc), don't open an empty menu.  Let
+      // the browser fall through instead.
+      if (entries.length === 0) {
+        return;
+      }
+      setState({
+        open: true,
+        clientX: req.clientX,
+        clientY: req.clientY,
+        entries,
+      });
+    },
+    [buildEntries, resolveKinds, root, tableContext],
+  );
+
+  const requestWithKinds = useCallback(
+    (args: {
+      clientX: number;
+      clientY: number;
+      kinds: readonly TargetKind[];
+    }) => {
+      const entries = buildEntries(args.kinds);
+      if (entries.length === 0) return;
+      setState({
+        open: true,
+        clientX: args.clientX,
+        clientY: args.clientY,
+        entries,
+      });
+    },
+    [buildEntries],
+  );
+
+  // D.5.Nit1 — the return value is consumed directly by the caller
+  // (the component that called this hook).  It isn't handed to any
+  // downstream memoizer, so `useMemo` here just pre-allocates an
+  // object that React's reconciler would allocate anyway.  Plain
+  // object literal is clearer + one less hook slot to track.
+  return { state, request, requestWithKinds, dismiss };
+}

package/src/ui-tailwind/chrome-overlay/chrome-overlay-projector.ts

@@ -8,7 +8,7 @@
  * rect math can be unit-tested and reused.
  */
 
-import type { RenderFrameRect } from "../../runtime/render/index.ts";
+import type { RenderFrameRect } from "../../api/public-types.ts";
 import { recordPerfSample } from "../editor-surface/perf-probe.ts";
 
 export interface OverlayCoordinateSpace {

package/src/ui-tailwind/chrome-overlay/tw-chrome-overlay.tsx

@@ -14,7 +14,7 @@
 
 import * as React from "react";
 import type { OverlayCoordinateSpace } from "./chrome-overlay-projector";
-import type { ScopeRailSegment } from "../../runtime/layout";
+import type { ScopeRailSegment } from "../../api/public-types.ts";
 import type {
   EditorRole,
   EditorStoryTarget,
@@ -30,8 +30,21 @@ import { TwTableGripLayer } from "../chrome/tw-table-grip-layer";
 import { TwObjectSelectionOverlay } from "./tw-object-selection-overlay";
 
 export interface TwChromeOverlayProps {
-  /** Layout facet the overlay layers read from. */
+  /** Layout facet the overlay layers read from (layout-semantic data). */
   facet: WordReviewEditorLayoutFacet;
+  /**
+   * Geometry facet for render-frame + zoom access. Migrated from
+   * `facet.getRenderFrame` / `.getRenderZoom` in refactor/05
+   * cross-lane-coord §8.4.
+   */
+  geometryFacet: import("../../runtime/geometry/index.ts").GeometryFacet;
+  /**
+   * Workflow facet — Layer-06 canonical source of scope rail segments
+   * + scope card models (`runtime.workflow`). Required for scope-rail
+   * / scope-card rendering; pass `null` when no runtime is attached
+   * (e.g., during initial mount).
+   */
+  workflowFacet: import("../../runtime/workflow/rail/types.ts").WorkflowFacet | null;
   /** Optional coordinate space override.  Defaults to the overlay origin. */
   space?: OverlayCoordinateSpace;
   /** Active scope id (for emphasis + rail tab sync). */
@@ -182,7 +195,9 @@ export interface TwChromeOverlayProps {
  *     pointer events on their interactive elements (buttons, handles).
  */
 export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
+  workflowFacet,
   facet,
+  geometryFacet,
   space,
   activeScopeId,
   onScopeStripeClick,
@@ -231,7 +246,8 @@ export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
         />
       ) : null}
       <TwScopeRailLayer
-        facet={facet}
+        geometryFacet={geometryFacet}
+        workflowFacet={workflowFacet}
         space={space}
         activeScopeId={activeScopeId}
         onStripeClick={onScopeStripeClick}
@@ -239,6 +255,7 @@ export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
       />
       <TwScopeCardLayer
         facet={facet}
+        workflowFacet={workflowFacet}
         activeScopeId={activeScopeId ?? null}
         onClose={onScopeCardClose ?? noop}
         onModeChange={onScopeCardModeChange ?? noopModeChange}
@@ -252,6 +269,7 @@ export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
       />
       <TwTableGripLayer
         facet={facet}
+        geometryFacet={geometryFacet}
         tableContext={tableContext ?? null}
         space={space}
         onSetColumnWidth={onSetColumnWidth}
@@ -261,7 +279,7 @@ export const TwChromeOverlay: React.FC<TwChromeOverlayProps> = ({
         grabbedObjectId={grabbedObjectId ?? null}
         grabbedObjectFromOffset={grabbedObjectFromOffset ?? null}
         grabbedObjectToOffset={grabbedObjectToOffset ?? null}
-        facet={facet}
+        geometryFacet={geometryFacet}
         space={space}
         onDeselect={onDeselectObject}
       />

package/src/ui-tailwind/chrome-overlay/tw-comment-balloon-layer.tsx

@@ -1,5 +1,5 @@
 import * as React from "react";
-import type { RenderBlockDecoration } from "../../runtime/render/render-frame-types";
+import type { RenderBlockDecoration } from "../../api/public-types.ts";
 import { TwCommentPreview } from "../chrome/tw-comment-preview";
 
 const WIDE_BREAKPOINT_PX = 1024;

package/src/ui-tailwind/chrome-overlay/tw-locked-block-layer.tsx

@@ -1,6 +1,6 @@
 import * as React from "react";
 import { Lock } from "lucide-react";
-import type { RenderBlockDecoration } from "../../runtime/render/render-frame-types";
+import type { RenderBlockDecoration } from "../../api/public-types.ts";
 
 const OUTLINE_INSET_PX = 2;
 const BADGE_SIZE_PX = 20;

package/src/ui-tailwind/chrome-overlay/tw-object-selection-overlay.tsx

@@ -20,7 +20,7 @@
 
 import * as React from "react";
 import { useEffect, useRef } from "react";
-import type { WordReviewEditorLayoutFacet } from "../../api/public-types";
+import type { GeometryFacet } from "../../api/public-types";
 import type { OverlayCoordinateSpace } from "./chrome-overlay-projector";
 import { projectRectToOverlay } from "./chrome-overlay-projector";
 
@@ -45,8 +45,14 @@ export interface TwObjectSelectionOverlayProps {
   grabbedObjectFromOffset: number | null;
   /** Document offset (`to`) of the grabbed object's inline segment. Null when no object grabbed. */
   grabbedObjectToOffset: number | null;
-  /** Layout facet for render-frame + anchor-index access. */
-  facet: WordReviewEditorLayoutFacet;
+  /**
+   * Geometry facet for render-frame + anchor-index access. Migrated
+   * from `facet: WordReviewEditorLayoutFacet` in the refactor/05
+   * cross-lane-coord §8.4 pass — layout-facet's `getRenderFrame` /
+   * `getRenderZoom` are being deleted; consumers read through
+   * `runtime.geometry` now.
+   */
+  geometryFacet: GeometryFacet;
   /** Optional overlay coordinate-space override. */
   space?: OverlayCoordinateSpace;
   /** Called when the user clicks outside the selection box. */
@@ -57,7 +63,7 @@ export function TwObjectSelectionOverlay({
   grabbedObjectId,
   grabbedObjectFromOffset,
   grabbedObjectToOffset,
-  facet,
+  geometryFacet,
   space,
   onDeselect,
 }: TwObjectSelectionOverlayProps) {
@@ -77,7 +83,7 @@ export function TwObjectSelectionOverlay({
 
   if (!grabbedObjectId || grabbedObjectFromOffset == null) return null;
 
-  const frame = typeof facet.getRenderFrame === "function" ? facet.getRenderFrame() : null;
+  const frame = geometryFacet.getRenderFrame();
   if (!frame) return null;
 
   const rawRect = grabbedObjectToOffset != null