@beyondwork/docx-react-component 1.0.48 → 1.0.49

package/src/runtime/surface-projection.ts

@@ -51,6 +51,7 @@ import {
   resolveEffectiveRunFormatting,
   resolveNumberingMarkerRunFormatting,
 } from "./paragraph-style-resolver.ts";
+import { resolveHyperlinkRunFormatting } from "./hyperlink-color-resolver.ts";
 import type { CanonicalParagraphFormatting, CanonicalRunFormatting } from "../model/canonical-document.ts";
 
 interface ParagraphAccumulator {
@@ -97,6 +98,17 @@ export function createEditorSurfaceSnapshot(
   };
 
   for (let index = 0; index < root.children.length; index += 1) {
+    const isInViewport =
+      viewportBlockRange === null ||
+      (index >= viewportBlockRange.start && index < viewportBlockRange.end);
+    // L7 Phase 2.9 — viewport bail on the style-cascade work. When the
+    // block is outside the viewport, the surface block produced below is
+    // immediately discarded in favor of a `placeholder-culled` entry (we
+    // only consume `nextCursor`). Pass `cullBuild: true` so the paragraph
+    // + inline walkers skip `resolveEffectiveParagraphFormatting`,
+    // `resolveNumberingMarkerRunFormatting`, and per-segment
+    // `resolveEffectiveRunFormatting` — the expensive style-catalog walks
+    // that dominate surface-projection cost on large docs.
     const surfaceBlock = createSurfaceBlock(
       root.children[index],
       document,
@@ -104,10 +116,8 @@ export function createEditorSurfaceSnapshot(
       counters,
       numberingPrefixResolver,
       activeStory.kind !== "main",
+      !isInViewport,
     );
-    const isInViewport =
-      viewportBlockRange === null ||
-      (index >= viewportBlockRange.start && index < viewportBlockRange.end);
 
     if (isInViewport) {
       blocks.push(surfaceBlock.block);
@@ -165,6 +175,7 @@ function createSurfaceBlock(
   },
   numberingPrefixResolver: NumberingPrefixResolver,
   promoteSecondaryStoryTextBoxes: boolean,
+  cullBuild: boolean = false,
 ): { block: SurfaceBlockSnapshot; lockedFragmentIds: string[]; nextCursor: number } {
   if (block.type === "opaque_block") {
     const fragment = getOpaqueFragment(document.preservation as never, block.fragmentId);
@@ -205,6 +216,7 @@ function createSurfaceBlock(
       counters,
       numberingPrefixResolver,
       promoteSecondaryStoryTextBoxes,
+      cullBuild,
     );
   }
 
@@ -244,6 +256,7 @@ function createSurfaceBlock(
       counters,
       numberingPrefixResolver,
       promoteSecondaryStoryTextBoxes,
+      cullBuild,
     );
   }
 
@@ -336,6 +349,7 @@ function createSurfaceBlock(
     cursor,
     numberingPrefixResolver,
     promoteSecondaryStoryTextBoxes,
+    cullBuild,
   );
 }
 
@@ -354,6 +368,7 @@ function createTableBlock(
   },
   numberingPrefixResolver: NumberingPrefixResolver,
   promoteSecondaryStoryTextBoxes: boolean,
+  cullBuild: boolean = false,
 ): { block: SurfaceBlockSnapshot; lockedFragmentIds: string[]; nextCursor: number } {
   const lockedFragmentIds: string[] = [];
   let innerCursor = cursor;
@@ -374,6 +389,7 @@ function createTableBlock(
           counters,
           numberingPrefixResolver,
           promoteSecondaryStoryTextBoxes,
+          cullBuild,
         );
         cellContent.push(result.block);
         lockedFragmentIds.push(...result.lockedFragmentIds);
@@ -518,6 +534,7 @@ function createSdtBlock(
   },
   numberingPrefixResolver: NumberingPrefixResolver,
   promoteSecondaryStoryTextBoxes: boolean,
+  cullBuild: boolean = false,
 ): { block: SurfaceBlockSnapshot; lockedFragmentIds: string[]; nextCursor: number } {
   const children: SurfaceBlockSnapshot[] = [];
   const lockedFragmentIds: string[] = [];
@@ -531,6 +548,7 @@ function createSdtBlock(
       counters,
       numberingPrefixResolver,
       promoteSecondaryStoryTextBoxes,
+      cullBuild,
     );
     children.push(result.block);
     lockedFragmentIds.push(...result.lockedFragmentIds);
@@ -566,34 +584,52 @@ function createParagraphBlock(
   start: number,
   numberingPrefixResolver: NumberingPrefixResolver,
   promoteSecondaryStoryTextBoxes: boolean,
+  cullBuild: boolean = false,
 ): {
   block: SurfaceBlockSnapshot;
   nextCursor: number;
   lockedFragmentIds: string[];
 } {
-  const effectiveNumbering = resolveEffectiveParagraphNumbering(document, paragraph);
-  const resolvedNumbering = effectiveNumbering
-    ? numberingPrefixResolver.resolveDetailed(effectiveNumbering, paragraph)
-    : null;
-
-  // Task 11: compute cascaded paragraph formatting
+  // L7 Phase 2.9 — viewport bail. When the paragraph is outside the
+  // viewport, the returned block is discarded (the outer caller in
+  // `createEditorSurfaceSnapshot` replaces it with a placeholder-culled
+  // entry and only consumes `nextCursor`). Skip the two style-catalog
+  // walks (`resolveEffectiveParagraphFormatting`,
+  // `resolveNumberingMarkerRunFormatting`) — their results are not read
+  // by the placeholder path. Segment-level work inside
+  // `appendInlineSegments` is suppressed symmetrically via the same
+  // `cullBuild` flag, preserving cursor arithmetic.
+  const effectiveNumbering = cullBuild
+    ? undefined
+    : resolveEffectiveParagraphNumbering(document, paragraph);
+  const resolvedNumbering =
+    !cullBuild && effectiveNumbering
+      ? numberingPrefixResolver.resolveDetailed(effectiveNumbering, paragraph)
+      : null;
+
+  // Task 11: compute cascaded paragraph formatting (expensive — styles-catalog walk).
   const stylesCatalog = document.styles;
-  const directParagraphFormatting = buildDirectParagraphFormattingFromNode(paragraph);
-  const resolvedParagraphFormatting = resolveEffectiveParagraphFormatting(
-    { styleId: paragraph.styleId, direct: directParagraphFormatting },
-    stylesCatalog,
-  );
-
-  // Task 11: compute cascaded marker run formatting
-  const markerRunProperties = effectiveNumbering
-    ? resolveNumberingMarkerRunFormatting(
-        {
-          paragraphStyleId: paragraph.styleId,
-          levelRunProperties: resolvedNumbering?.markerRunProperties,
-        },
+  const directParagraphFormatting = cullBuild
+    ? undefined
+    : buildDirectParagraphFormattingFromNode(paragraph);
+  const resolvedParagraphFormatting = cullBuild
+    ? undefined
+    : resolveEffectiveParagraphFormatting(
+        { styleId: paragraph.styleId, direct: directParagraphFormatting },
         stylesCatalog,
-      )
-    : undefined;
+      );
+
+  // Task 11: compute cascaded marker run formatting (expensive).
+  const markerRunProperties =
+    !cullBuild && effectiveNumbering
+      ? resolveNumberingMarkerRunFormatting(
+          {
+            paragraphStyleId: paragraph.styleId,
+            levelRunProperties: resolvedNumbering?.markerRunProperties,
+          },
+          stylesCatalog,
+        )
+      : undefined;
 
   const accumulator: ParagraphAccumulator = {
     blockId: `paragraph-${paragraphIndex}`,
@@ -650,6 +686,8 @@ function createParagraphBlock(
       document,
       cursor,
       promoteSecondaryStoryTextBoxes,
+      undefined,
+      cullBuild,
     );
     cursor = result.nextCursor;
     lockedFragmentIds.push(...result.lockedFragmentIds);
@@ -812,22 +850,39 @@ function appendInlineSegments(
   start: number,
   promoteSecondaryStoryTextBoxes: boolean,
   hyperlinkHref?: string,
+  cullBuild: boolean = false,
 ): { nextCursor: number; lockedFragmentIds: string[] } {
   switch (node.type) {
     case "text": {
       const cloned = node.marks ? cloneMarks(node.marks) : { marks: [] as SurfaceTextMark[] };
-      const directRunFormatting = buildDirectRunFormattingFromMarks(
-        cloned.marks.length > 0 ? cloned.marks : undefined,
-        cloned.markAttrs,
-      );
-      const resolvedRunFormatting = resolveEffectiveRunFormatting(
-        {
-          paragraphStyleId: paragraph.styleId,
-          characterStyleId: undefined,
-          direct: directRunFormatting,
-        },
-        document.styles,
-      );
+      // L7 Phase 2.9 — skip the styles-catalog run-cascade walk when
+      // the block will be culled. `resolveEffectiveRunFormatting`
+      // dominates per-text-segment cost on style-heavy docs; the
+      // placeholder path does not read `resolvedRunFormatting`.
+      const directRunFormatting = cullBuild
+        ? undefined
+        : buildDirectRunFormattingFromMarks(
+            cloned.marks.length > 0 ? cloned.marks : undefined,
+            cloned.markAttrs,
+          );
+      // V7 — runs inside <w:hyperlink> go through the hyperlink color
+      // cascade (auto-applies the Hyperlink character style + resolves
+      // theme hlink slot with Word-default fallback). Non-hyperlink
+      // runs take the unchanged cascade path.
+      const runResolveInput = {
+        paragraphStyleId: paragraph.styleId,
+        characterStyleId: undefined,
+        direct: directRunFormatting,
+      };
+      const resolvedRunFormatting = cullBuild
+        ? {}
+        : hyperlinkHref
+          ? resolveHyperlinkRunFormatting(
+              runResolveInput,
+              document.styles,
+              document.subParts?.resolvedTheme,
+            )
+          : resolveEffectiveRunFormatting(runResolveInput, document.styles);
       paragraph.segments.push({
         segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
         kind: "text",
@@ -869,6 +924,7 @@ function appendInlineSegments(
           cursor,
           promoteSecondaryStoryTextBoxes,
           node.href,
+          cullBuild,
         );
         cursor = result.nextCursor;
       }
@@ -1003,6 +1059,8 @@ function appendInlineSegments(
             document,
             cursor,
             promoteSecondaryStoryTextBoxes,
+            undefined,
+            cullBuild,
           );
           cursor = result.nextCursor;
           lockedIds.push(...result.lockedFragmentIds);

package/src/runtime/theme-color-resolver.ts

@@ -0,0 +1,188 @@
+/**
+ * Resolve a (`<w:color>`-shaped) theme-color reference to a concrete hex
+ * string, applying the `w:themeTint` / `w:themeShade` HSL-luminance
+ * modulation per ECMA-376 §17.18.85 / §17.18.83.
+ *
+ * Usage:
+ *   - The IO layer (`parse-run-formatting.ts`) captures
+ *     `colorThemeSlot` / `colorThemeTint` / `colorThemeShade` on
+ *     `CanonicalRunFormatting` as raw strings (preserved for
+ *     byte-stable round-trip).
+ *   - The render/cascade layer calls `resolveThemeColorHex(rPr, theme)`
+ *     to collapse the reference to the actual hex colour the browser
+ *     should paint. The original fields stay intact so export still
+ *     round-trips the theme reference (not the computed hex).
+ *
+ * Lane 3 L2.c. Mirrors LibreOffice's `Color::ApplyTintOrShade` at
+ * `vendor/libreoffice/include/tools/color.hxx:200-240` (shape only; no
+ * code copied — our implementation is pure TypeScript against the
+ * ECMA-376 formulae).
+ *
+ * **Scope boundary:** this resolver handles the standard tint/shade
+ * pair. Theme-color-mapping (clrSchemeMapping — how "accent1" maps to a
+ * different `<w:clrScheme>` slot in older Word versions) is NOT applied
+ * here — `resolveThemeColor` from `src/io/ooxml/parse-theme.ts` is the
+ * authoritative slot→hex lookup and future work will layer scheme
+ * mapping into it.
+ */
+
+import type { CanonicalRunFormatting, ResolvedTheme } from "../model/canonical-document.ts";
+import { resolveThemeColor } from "../io/ooxml/parse-theme.ts";
+
+/**
+ * Collapse `<w:color>`-style theme-slot + tint + shade references into a
+ * single resolved hex colour. Returns:
+ *   - the raw `colorHex` as-is when it's a direct hex (the theme fields
+ *     are ignored because direct colour wins per ECMA-376 cascade).
+ *   - `"auto"` when the source declared `w:color w:val="auto"` (sentinel
+ *     kept verbatim per our long-standing A.9 round-trip rule).
+ *   - the theme slot's hex — tint/shade applied — when the source
+ *     declared `w:themeColor="accent1"` etc. and the theme is available.
+ *   - `undefined` otherwise (no colour declared, or theme slot absent).
+ */
+export function resolveThemeColorHex(
+  rPr: Pick<
+    CanonicalRunFormatting,
+    "colorHex" | "colorThemeSlot" | "colorThemeTint" | "colorThemeShade"
+  >,
+  theme: ResolvedTheme | undefined,
+): string | undefined {
+  if (rPr.colorHex === "auto") return "auto";
+  if (rPr.colorHex) return rPr.colorHex;
+  if (!rPr.colorThemeSlot) return undefined;
+
+  const baseHex = resolveThemeColor(theme, rPr.colorThemeSlot);
+  if (!baseHex) return undefined;
+
+  return applyThemeTintShade(baseHex, rPr.colorThemeTint, rPr.colorThemeShade);
+}
+
+/**
+ * Apply `w:themeTint` (shift toward white) and/or `w:themeShade` (shift
+ * toward black) to a base hex colour. Pure function.
+ *
+ * Tint/shade are each a 0x00–0xFF hex byte representing a fraction of
+ * 255 (ECMA-376 §17.18.85 / §17.18.83). Only one may be present per
+ * `<w:color>`; when both are omitted, the base hex is returned.
+ *
+ * Formulae (per Microsoft's Word/OOXML guidance mirrored in LibreOffice):
+ *   - tint byte T → frac = T / 255; newL = frac * L + (1 - frac) * 1.0
+ *     (at T=0 the colour becomes pure white; at T=255 it stays unchanged)
+ *   - shade byte S → frac = S / 255; newL = frac * L
+ *     (at S=0 the colour becomes pure black; at S=255 it stays unchanged)
+ *
+ * These are LUMINANCE modulations in the HSL colour space (hue + saturation
+ * preserved). The conversion hex → HSL → hex is the standard 0–1 / 0–360
+ * form.
+ */
+export function applyThemeTintShade(
+  baseHex: string,
+  tint: string | undefined,
+  shade: string | undefined,
+): string {
+  const tintByte = parseHexByte(tint);
+  const shadeByte = parseHexByte(shade);
+  if (tintByte === undefined && shadeByte === undefined) {
+    return baseHex;
+  }
+
+  const rgb = parseHexColor(baseHex);
+  if (!rgb) return baseHex;
+
+  const hsl = rgbToHsl(rgb);
+  let newL = hsl.l;
+  if (tintByte !== undefined) {
+    const frac = tintByte / 255;
+    newL = frac * hsl.l + (1 - frac);
+  } else if (shadeByte !== undefined) {
+    const frac = shadeByte / 255;
+    newL = frac * hsl.l;
+  }
+  newL = Math.max(0, Math.min(1, newL));
+
+  const out = hslToRgb({ h: hsl.h, s: hsl.s, l: newL });
+  return formatHexColor(out);
+}
+
+function parseHexByte(value: string | undefined): number | undefined {
+  if (!value) return undefined;
+  const n = Number.parseInt(value, 16);
+  if (!Number.isFinite(n)) return undefined;
+  return Math.max(0, Math.min(255, n));
+}
+
+function parseHexColor(hex: string): { r: number; g: number; b: number } | undefined {
+  const normalized = hex.replace(/^#/u, "").trim();
+  if (normalized.length !== 6) return undefined;
+  const n = Number.parseInt(normalized, 16);
+  if (!Number.isFinite(n)) return undefined;
+  return {
+    r: (n >> 16) & 0xff,
+    g: (n >> 8) & 0xff,
+    b: n & 0xff,
+  };
+}
+
+function formatHexColor(rgb: { r: number; g: number; b: number }): string {
+  const to2 = (n: number): string => Math.round(n).toString(16).padStart(2, "0").toUpperCase();
+  return `${to2(rgb.r)}${to2(rgb.g)}${to2(rgb.b)}`;
+}
+
+function rgbToHsl(rgb: { r: number; g: number; b: number }): {
+  h: number;
+  s: number;
+  l: number;
+} {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const l = (max + min) / 2;
+  let h = 0;
+  let s = 0;
+  if (max !== min) {
+    const d = max - min;
+    s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    switch (max) {
+      case r:
+        h = ((g - b) / d + (g < b ? 6 : 0)) * 60;
+        break;
+      case g:
+        h = ((b - r) / d + 2) * 60;
+        break;
+      default:
+        h = ((r - g) / d + 4) * 60;
+    }
+  }
+  return { h, s, l };
+}
+
+function hslToRgb(hsl: { h: number; s: number; l: number }): {
+  r: number;
+  g: number;
+  b: number;
+} {
+  const { h, s, l } = hsl;
+  if (s === 0) {
+    const gray = l * 255;
+    return { r: gray, g: gray, b: gray };
+  }
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const hueToRgb = (t: number): number => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p + (q - p) * 6 * tt;
+    if (tt < 1 / 2) return q;
+    if (tt < 2 / 3) return p + (q - p) * (2 / 3 - tt) * 6;
+    return p;
+  };
+  const hFrac = h / 360;
+  return {
+    r: hueToRgb(hFrac + 1 / 3) * 255,
+    g: hueToRgb(hFrac) * 255,
+    b: hueToRgb(hFrac - 1 / 3) * 255,
+  };
+}

package/src/runtime/workflow-markup.ts

@@ -22,6 +22,7 @@ import type {
   WorkflowCommentMarkup,
 } from "../api/public-types";
 import { MAIN_STORY_TARGET } from "../core/selection/mapping.ts";
+import { createPublicRangeAnchor } from "../core/selection/anchor-conversion.ts";
 import {
   projectSurfaceText,
   searchProjectedSurfaceText,
@@ -145,7 +146,7 @@ export function collectWorkflowMarkupSnapshot(input: {
         markupId: `protected-range:${range.rangeId}`,
         kind: "protected_range",
         rangeId: range.rangeId,
-        anchor: createRangeAnchor(range.start, range.end),
+        anchor: createPublicRangeAnchor(range.start, range.end),
         storyTarget: MAIN_STORY_TARGET,
         label: `Protected range ${range.rangeId}`,
         excerpt: range.enforcementReason,
@@ -283,7 +284,7 @@ function collectSurfaceMarkup(
       kind: "opaque_fragment",
       fragmentId: block.fragmentId,
       warningId: block.warningId,
-      anchor: createRangeAnchor(block.from, block.to),
+      anchor: createPublicRangeAnchor(block.from, block.to),
       storyTarget,
       label: block.label,
       excerpt: block.detail,
@@ -308,7 +309,7 @@ function collectSegmentMarkup(
     highlights.push({
       markupId: `highlight:${storyTargetKey(storyTarget)}:${segment.from}:${segment.to}:${segment.markAttrs.backgroundColor}`,
       kind: "highlight",
-      anchor: createRangeAnchor(segment.from, segment.to),
+      anchor: createPublicRangeAnchor(segment.from, segment.to),
       storyTarget,
       label: `Highlight ${segment.markAttrs.backgroundColor}`,
       excerpt: segment.text,
@@ -326,7 +327,7 @@ function collectSegmentMarkup(
       kind: "opaque_fragment",
       fragmentId: segment.fragmentId,
       warningId: segment.warningId,
-      anchor: createRangeAnchor(segment.from, segment.to),
+      anchor: createPublicRangeAnchor(segment.from, segment.to),
       storyTarget,
       label: segment.label,
       excerpt: segment.detail,
@@ -380,7 +381,7 @@ function collectFieldMarkup(
           {
             markupId: `field:${field.index}`,
             kind: "field",
-            anchor: createRangeAnchor(match.from, match.to),
+            anchor: createPublicRangeAnchor(match.from, match.to),
             storyTarget: story.storyTarget,
             label: displayText,
             excerpt: field.instruction,
@@ -417,7 +418,7 @@ function collectOpaqueFragmentMarkup(
         kind: "opaque_fragment",
         fragmentId: fragment.fragmentId,
         warningId: fragment.warningId,
-        anchor: createRangeAnchor(fragment.lastKnownRange.from, fragment.lastKnownRange.to),
+        anchor: createPublicRangeAnchor(fragment.lastKnownRange.from, fragment.lastKnownRange.to),
         storyTarget: MAIN_STORY_TARGET,
         label: descriptor.label,
         excerpt: descriptor.detail,
@@ -427,18 +428,6 @@ function collectOpaqueFragmentMarkup(
     });
 }
 
-function createRangeAnchor(from: number, to: number): EditorAnchorProjection {
-  return {
-    kind: "range",
-    from,
-    to,
-    assoc: {
-      start: -1,
-      end: 1,
-    },
-  };
-}
-
 function storyTargetKey(storyTarget: EditorStoryTarget): string {
   switch (storyTarget.kind) {
     case "main":

package/src/ui/WordReviewEditor.tsx

@@ -75,6 +75,7 @@ import type {
   ZoomLevel,
 } from "../api/public-types";
 import { MetadataResolverMissingError } from "../api/public-types";
+import { readHarnessDebugPortsFlag } from "../internal/harness-debug-ports.ts";
 import type { ScopeMetadataResolver } from "../api/scope-metadata-resolver-types.ts";
 import {
   editorSessionStateFromPersistedSnapshot,
@@ -178,6 +179,7 @@ import {
   useRuntimeSnapshotSlice,
   useRuntimeValue,
 } from "./runtime-snapshot-selectors.ts";
+import { computeEffectiveShowUnsupportedPreviews } from "./unsupported-previews-policy.ts";
 import type { MarkupDisplay } from "./headless/comment-decoration-model";
 import { resolveScopedChromePolicy } from "./headless/scoped-chrome-policy";
 import type {
@@ -779,6 +781,9 @@ export function __createWordReviewEditorRefBridge(
     clearWorkflowOverlay: () => {
       runtime.clearWorkflowOverlay();
     },
+    setSharedWorkflowState: (state) => {
+      runtime.setSharedWorkflowState(state === null ? null : clonePublicValue(state));
+    },
     getWorkflowScopeSnapshot: () => {
       return clonePublicValue(runtime.getWorkflowScopeSnapshot());
     },
@@ -1036,7 +1041,8 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       chromePreset,
       chromeOptions,
       markupDisplay,
-      showUnsupportedObjectPreviews = false,
+      __harnessDebugPorts,
+      unsupportedPreviewsPolicy = "never",
       onError,
       onEvent,
       onWarning,
@@ -1825,6 +1831,9 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         clearWorkflowOverlay: () => {
           activeRuntime.clearWorkflowOverlay();
         },
+        setSharedWorkflowState: (state) => {
+          activeRuntime.setSharedWorkflowState(state === null ? null : clonePublicValue(state));
+        },
         getWorkflowScopeSnapshot: () => {
           return clonePublicValue(activeRuntime.getWorkflowScopeSnapshot());
         },
@@ -2938,6 +2947,13 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
       },
     });
 
+    const harnessShowUnsupportedPreviews = readHarnessDebugPortsFlag(__harnessDebugPorts, "unsupportedObjectPreviews");
+    const effectiveShowUnsupportedPreviews = computeEffectiveShowUnsupportedPreviews({
+      harnessShowUnsupportedPreviews,
+      unsupportedPreviewsPolicy,
+      reviewMode,
+    });
+
     const documentElement = (
       <EditorSurfaceController
         ref={surfaceRef}
@@ -2948,7 +2964,7 @@ export const WordReviewEditor = forwardRef<WordReviewEditorRef, WordReviewEditor
         documentNavigation={documentNavigation}
         reviewMode={reviewMode}
         markupDisplay={liveMarkupDisplay}
-        showUnsupportedObjectPreviews={showUnsupportedObjectPreviews}
+        showUnsupportedObjectPreviews={effectiveShowUnsupportedPreviews}
         activeRevisionId={activeRevisionId}
         activeSelectionToolKind={activeSelectionTool?.kind ?? null}
         showTrackedChanges={showTrackedChanges}

package/src/ui/editor-runtime-boundary.ts

@@ -44,6 +44,7 @@ import {
   loadDocxEditorSession,
   loadDocxEditorSessionAsync,
 } from "../io/docx-session.ts";
+import { tryReadLaycacheEnvelope } from "../runtime/prerender/customxml-probe.ts";
 import {
   createLoadScheduler,
   type LoadScheduler,
@@ -79,6 +80,14 @@ export interface ResolvedSource {
    * does the classic synchronous load.
    */
   preloadedDocxSession?: ReturnType<typeof loadDocxEditorSession>;
+  /**
+   * L7 Phase 2.7 — when the editor-runtime-boundary probe finds a
+   * laycache envelope in `/customXml/item1.xml`, its `graph` is stashed
+   * here and forwarded to `createDocumentRuntime` as `seedLayoutCache`.
+   * This is the Plan A (graph-seed) win layered on top of the Plan B
+   * (loader short-circuit) win. Undefined when no envelope is available.
+   */
+  preloadedLaycacheGraph?: import("../runtime/layout/page-graph.ts").RuntimePageGraph;
 }
 
 export interface CreateRuntimeArgs {
@@ -404,6 +413,18 @@ export function useEditorRuntimeBoundary(
         // can paint the skeleton while the rest of the parse finishes.
         // SSR / Node tests fall through to the synchronous load inside
         // `createRuntime`.
+        //
+        // L7 Phase 2.7 — Plan B read-path wiring. Before invoking the
+        // async loader, probe the docx for a laycache envelope stashed
+        // in `/customXml/item1.xml` (shipped by Plan B Slice 2). When the
+        // probe returns a validated envelope, pass it to the loader so
+        // the five expensive parse stages short-circuit against the
+        // cached `canonicalDocument`. Measured win on 138-pp extra-large
+        // CCEP: ~947 ms cold → ~590 ms warm (Δ 376 ms), same delta the
+        // Node-side `prerender-cache.bench.ts` records. Probe is ~20–50 ms;
+        // `tryReadLaycacheEnvelope` returns null on any rejection path
+        // (missing part, stale structural hash, schema mismatch) and the
+        // loader falls through to the full parse.
         if (
           source.initialDocx !== undefined &&
           source.preloadedDocxSession === undefined &&
@@ -411,12 +432,20 @@ export function useEditorRuntimeBoundary(
         ) {
           const scheduler = createLoadScheduler();
           loadSchedulerRef.current = scheduler;
+          const probeResult = await tryReadLaycacheEnvelope(source.initialDocx);
+          if (cancelled) {
+            scheduler.dispose();
+            loadSchedulerRef.current = null;
+            return;
+          }
+          recordPerfSample("loadSession.laycacheProbe");
           const preloaded = await loadDocxEditorSessionAsync({
             documentId,
             sourceLabel: source.sourceLabel,
             bytes: source.initialDocx,
             editorBuild: "dev",
             scheduler,
+            ...(probeResult ? { laycacheEnvelope: probeResult.envelope } : {}),
           });
           if (cancelled) {
             scheduler.dispose();
@@ -424,6 +453,9 @@ export function useEditorRuntimeBoundary(
             return;
           }
           source.preloadedDocxSession = preloaded;
+          if (probeResult) {
+            source.preloadedLaycacheGraph = probeResult.envelope.graph;
+          }
         }
 
         const nextRuntime = createRuntime(
@@ -662,6 +694,9 @@ function createRuntime(
     editorBuild: runtimeSessionState.editorBuild,
     fatalError: docxSession?.fatalError,
     protectionSnapshot: docxSession?.protectionSnapshot,
+    ...(args.source.preloadedLaycacheGraph
+      ? { seedLayoutCache: args.source.preloadedLaycacheGraph }
+      : {}),
     exportDocx: async (sessionState, options) => {
       if (docxSession) {
         return docxSession.exportDocx(sessionState, options);
@@ -965,6 +1000,7 @@ function createLoadingRuntimeBridge(input: {
       Promise.reject(createLoadingBoundaryError(input.snapshot.documentId, "export")),
     setWorkflowOverlay: () => undefined,
     clearWorkflowOverlay: () => undefined,
+    setSharedWorkflowState: () => undefined,
     getWorkflowOverlay: () => null,
     getWorkflowScopeSnapshot: () => null,
     getInteractionGuardSnapshot: () => ({ effectiveMode: "edit", blockedReasons: [] }),