@beyondwork/docx-react-component 1.0.51 → 1.0.53

package/src/runtime/document-runtime.ts

@@ -298,6 +298,27 @@ export interface DocumentRuntime {
     context: CommandExecutionContext,
     meta?: Partial<CommandAppliedMeta>,
   ): void;
+  /**
+   * R1 — coalesced remote-replay entry point. Applies N envelopes as ONE
+   * commit: per-command transactions are chained (`replayState = txN.nextState`),
+   * mapping steps concatenated, `markDirty` ORed, and a single `commitRemote`
+   * call drives `finalizeState` / `invalidate` / `refreshRenderSnapshot` /
+   * `notify` exactly once. Per-command `meta.activeStory` isolation is
+   * preserved (the remote story scopes its own replay; the local cursor
+   * stays put). Behavior matches `applyRemoteCommand` invoked N times for
+   * a single envelope; for empty arrays it's a no-op.
+   *
+   * Singular effect collisions (≥2 envelopes both emitting `commentAdded` /
+   * `changeAccepted` / etc.) fall back to per-envelope replay so observers
+   * still see every effect — typical text-burst replay (all warnings-only
+   * effects) takes the fast path.
+   *
+   * History commands (`history.undo` / `history.redo`) and runtime overlay
+   * commands (`workflow.set-overlay`, etc.) inside a batch are processed
+   * individually as in the per-event path; they don't participate in the
+   * chained commit.
+   */
+  applyRemoteCommandBatch(envelopes: ReadonlyArray<RemoteCommandEnvelope>): void;
   emitBlockedCommand(command: string, reasons: WorkflowBlockedCommandReason[]): void;
   undo(): void;
   redo(): void;
@@ -433,6 +454,17 @@ export interface CommandAppliedMeta {
   priorDocument: CanonicalDocumentEnvelope;
 }
 
+/**
+ * Single envelope shape consumed by {@link DocumentRuntime.applyRemoteCommandBatch}.
+ * Mirrors the `applyRemoteCommand(command, context, meta)` signature so
+ * batch and per-event paths stay schema-compatible.
+ */
+export interface RemoteCommandEnvelope {
+  command: EditorCommand;
+  context: CommandExecutionContext;
+  meta?: Partial<CommandAppliedMeta>;
+}
+
 export interface CreateDocumentRuntimeOptions {
   documentId: string;
   initialSessionState?: EditorSessionState;
@@ -2264,6 +2296,133 @@ export function createDocumentRuntime(
         emitError(toRuntimeError(error));
       }
     },
+    applyRemoteCommandBatch(envelopes) {
+      if (envelopes.length === 0) return;
+      if (envelopes.length === 1) {
+        const e = envelopes[0]!;
+        this.applyRemoteCommand(e.command, e.context, e.meta);
+        return;
+      }
+
+      try {
+        // Chain per-command transactions before ONE commitRemote at the end.
+        // Each command runs through executeEditorCommand on the replayed
+        // state; resulting nextState becomes the input to the next command.
+        // History/overlay commands are processed individually as in the
+        // per-event path (they don't participate in the chained commit).
+        let replayState: typeof state = state;
+        const stepsAccumulator: import("../core/selection/mapping.ts").MappingStep[] = [];
+        let anyDirty = false;
+        let lastNextState: typeof state | null = null;
+        let lastCrossStoryReplay = false;
+        const warningsAdded: import("../core/state/editor-state.ts").EditorWarning[] = [];
+        const warningsCleared: Array<{ warningId: string; code: import("../core/state/editor-state.ts").EditorWarning["code"] }> = [];
+        const SINGULAR_EFFECT_KEYS = [
+          "commentAdded",
+          "commentResolved",
+          "commentReopened",
+          "commentReplyAdded",
+          "commentBodyEdited",
+          "changeAccepted",
+          "changeRejected",
+          "revisionAuthored",
+          "commandBlocked",
+        ] as const;
+        const singularEffectsCounts = new Map<string, number>();
+        const aggregatedSingular: Record<string, unknown> = {};
+
+        for (const env of envelopes) {
+          const { command, context, meta } = env;
+          if (command.type === "history.undo" || command.type === "history.redo") {
+            // Match per-event path: silently skipped on remote replay.
+            continue;
+          }
+          if (isRuntimeStateOverlayCommand(command)) {
+            // Overlays bypass commitRemote in the per-event path; mirror that
+            // here without disturbing the chained replayState.
+            applyRuntimeStateOverlayCommand(command);
+            continue;
+          }
+          const replayStory = meta?.activeStory ?? activeStory;
+          const crossStoryReplay = Boolean(
+            meta?.activeStory && !storyTargetsEqual(meta.activeStory, activeStory),
+          );
+          let stateForCommand: typeof state;
+          let snapshotForCommand: typeof cachedRenderSnapshot;
+          if (meta?.preSelection) {
+            // Reuse the R5 scratch (avoids per-command allocation across the
+            // burst). Seed from the CURRENT chain state so each command sees
+            // the prior command's nextState as its starting point.
+            Object.assign(r5ScratchReplayState, replayState);
+            r5ScratchReplayState.selection = meta.preSelection;
+            Object.assign(r5ScratchReplaySnapshot, cachedRenderSnapshot);
+            r5ScratchReplaySnapshot.selection = toPublicSelectionSnapshot(meta.preSelection, replayStory);
+            stateForCommand = r5ScratchReplayState;
+            snapshotForCommand = r5ScratchReplaySnapshot;
+          } else {
+            stateForCommand = replayState;
+            snapshotForCommand = cachedRenderSnapshot;
+          }
+          const replayContext = {
+            ...context,
+            renderSnapshot: snapshotForCommand,
+          };
+          const transaction = executeEditorCommand(stateForCommand, command, replayContext);
+          replayState = transaction.nextState;
+          stepsAccumulator.push(...transaction.mapping.steps);
+          anyDirty = anyDirty || transaction.markDirty;
+          warningsAdded.push(...transaction.effects.warningsAdded);
+          warningsCleared.push(...transaction.effects.warningsCleared);
+          for (const key of SINGULAR_EFFECT_KEYS) {
+            const v = (transaction.effects as unknown as Record<string, unknown>)[key];
+            if (v !== undefined) {
+              singularEffectsCounts.set(key, (singularEffectsCounts.get(key) ?? 0) + 1);
+              aggregatedSingular[key] = v;
+            }
+          }
+          lastNextState = transaction.nextState;
+          lastCrossStoryReplay = crossStoryReplay;
+        }
+
+        // Singular-effect collision (≥2 envelopes both setting the same
+        // singular field): fall back to per-envelope replay so observers
+        // see every effect. Common burst (all text.insert with empty
+        // effects) takes the fast path above.
+        let singularCollision = false;
+        for (const count of singularEffectsCounts.values()) {
+          if (count > 1) {
+            singularCollision = true;
+            break;
+          }
+        }
+        if (singularCollision) {
+          for (const env of envelopes) {
+            this.applyRemoteCommand(env.command, env.context, env.meta);
+          }
+          return;
+        }
+        if (lastNextState === null) {
+          // All envelopes were skip/overlay — nothing to commit.
+          return;
+        }
+        const consolidated = {
+          nextState: lastCrossStoryReplay
+            ? { ...lastNextState, selection: state.selection }
+            : lastNextState,
+          mapping: { steps: stepsAccumulator },
+          effects: {
+            warningsAdded,
+            warningsCleared,
+            ...aggregatedSingular,
+          } as import("../core/commands/index.ts").TransactionEffects,
+          historyBoundary: "skip" as const,
+          markDirty: anyDirty,
+        };
+        commitRemote(consolidated);
+      } catch (error) {
+        emitError(toRuntimeError(error));
+      }
+    },
     undo() {
       this.dispatch({
         type: "history.undo",

package/src/runtime/layout/layout-engine-version.ts

@@ -93,8 +93,37 @@
  *       pixel-geometry change; cache envelopes from v9 invalidate
  *       because page-node identity semantics on bounded splices
  *       changed.
+ *  11 — Lane 3a P10 Phase B2. `toPublicPageNode` memoizes its
+ *       `RuntimePageNode → PublicPageNode` projection via WeakMap so
+ *       Phase D1's stable runtime-node references cascade into stable
+ *       public-facet return values. `facet.getPage(pageIndex)` now
+ *       returns reference-equal `PublicPageNode`s across bounded
+ *       relayouts where the underlying runtime node was reused.
+ *       Cascades into downstream consumers (React.memo-gated page
+ *       subtrees, per-page test hooks) and closes the Phase B → D1
+ *       stable-reference chain. No pixel-geometry change; cache
+ *       envelopes from v10 invalidate because the public-facet
+ *       contract changed from "fresh object per call" to "stable ref
+ *       per underlying runtime node".
+ *  12 — Lane 3a R3 table row-split: `getTableRenderPlan` now derives
+ *       `isContinuationPage` from the page graph's fragment slice
+ *       metadata (`kind === "table-slice" && tableRowRange.from > 0`)
+ *       and passes it to `buildTableRenderPlan`. Tables split across
+ *       pages now carry non-empty `repeatedHeaderRows` on continuation
+ *       pages so chrome can prepend header rows visually. No
+ *       pixel-geometry change; cache envelopes from v11 invalidate
+ *       because the table-render-plan contract changed.
+ *  13 — Lane 3a P14.c: render-kernel gains a single-slot `DecorationIndex`
+ *       cache keyed on (revision, activeStory.kind, zoom.pxPerTwip, and
+ *       reference equality on each decoration source). When layout
+ *       changes but decoration sources are unchanged, `resolveDecorationIndex`
+ *       is skipped and the prior result is reused. The frame-level cache
+ *       already handles repeat reads; this slot targets the post-invalidate
+ *       rebuild path (on every keystroke that triggers a layout event).
+ *       No pixel-geometry change; cache envelopes from v12 invalidate
+ *       because the render-kernel source changed.
  */
-export const LAYOUT_ENGINE_VERSION = 10 as const;
+export const LAYOUT_ENGINE_VERSION = 13 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope
@@ -113,5 +142,14 @@ export const LAYOUT_ENGINE_VERSION = 10 as const;
  *       correctly invalidates. v1 envelopes are rejected on load under v2 —
  *       no corruption path exists because schemaVersion is the top-level
  *       discriminator.
+ *   3 — L7 Phase 2 Finale C3: adds optional `compatibilityReport` field so
+ *       the warm-Plan-B short-circuit can skip `buildCompatibilityReport`
+ *       (~60–100 ms on extra-large). `generatedAt` inside the cached report
+ *       is pinned to a fixed sentinel (`"__cache_normalized__"`) at
+ *       prerender write time so two sequential prerenders produce
+ *       byte-identical envelopes. The field is optional — v3 envelopes
+ *       written without the report are still valid; readers fall through
+ *       to the live `buildCompatibilityReport` call. v2 envelopes are
+ *       rejected cleanly on v3 readers (schemaVersion mismatch).
  */
-export const LAYCACHE_SCHEMA_VERSION = 2 as const;
+export const LAYCACHE_SCHEMA_VERSION = 3 as const;

package/src/runtime/layout/public-facet.ts

@@ -1231,12 +1231,27 @@ export function createLayoutFacet(
       const tableHeightTwips = graph.fragments
         .filter((f) => f.blockId === blockId)
         .reduce((total, f) => total + f.heightTwips, 0);
+      // Determine if this page holds a continuation slice of the table
+      // (rows after the first slice).  Fragment kind "table-slice" with
+      // tableRowRange.from > 0 means the table was split across pages and
+      // this page carries a non-first slice — header rows should repeat.
+      const pageNode = graph.pages.find((p) => p.pageIndex === pageIndex);
+      const sliceFragment = pageNode
+        ? graph.fragments.find(
+            (f) => f.blockId === blockId && f.pageId === pageNode.pageId,
+          )
+        : undefined;
+      const isContinuationPage =
+        sliceFragment?.kind === "table-slice" &&
+        (sliceFragment.tableRowRange?.from ?? 0) > 0;
+
       return buildTableRenderPlan({
         blockId,
         pageIndex,
         block: tableBlock,
         resolved,
         tableHeightTwips,
+        isContinuationPage,
       });
     },
 
@@ -1274,11 +1289,36 @@ export function createLayoutFacet(
 // Internal: graph → public clones
 // ---------------------------------------------------------------------------
 
+/**
+ * Per-runtime-node cache for `toPublicPageNode`.
+ *
+ * P10 Phase B2. When `spliceGraph` preserves a `RuntimePageNode`
+ * reference across a bounded relayout (Phase D1 tail-convergence
+ * reuse), this cache preserves the derived `PublicPageNode` reference
+ * too — so downstream consumers (React.memo-gated page subtrees in
+ * `TwPageStackChromeLayer`, per-page test hooks) observe stable props
+ * and can skip reconciliation.
+ *
+ * The map is a WeakMap keyed on the runtime node. When a fresh runtime
+ * node replaces a prior one (divergent-tail case), the prior cache
+ * entry is garbage-collected with the prior node; no manual eviction
+ * is required. Structural contract: consumers MUST NOT mutate the
+ * returned `PublicPageNode`, which has always been a read-only clone.
+ */
+const publicPageNodeCache = new WeakMap<RuntimePageNode, PublicPageNode>();
+
 function toPublicPageNode(
   node: RuntimePageNode,
   graph: RuntimePageGraph,
 ): PublicPageNode {
-  return {
+  const cached = publicPageNodeCache.get(node);
+  // Safety guard: reuse only when the runtime node's index still
+  // matches the cached projection. Under normal D1 tail-convergence the
+  // index is preserved, but this belt-and-braces check guarantees we
+  // never hand out a stale clone if a runtime node is ever reused at a
+  // different position by a future splice strategy.
+  if (cached && cached.pageIndex === node.pageIndex) return cached;
+  const built: PublicPageNode = {
     pageId: node.pageId,
     pageIndex: node.pageIndex,
     sectionIndex: node.sectionIndex,
@@ -1295,7 +1335,9 @@ function toPublicPageNode(
     lineBoxCount: node.lineBoxes.length,
     noteAllocations: node.noteAllocations.map(toPublicNoteAllocation),
   };
+  publicPageNodeCache.set(node, built);
   void graph; // reserved for future cross-page derivations
+  return built;
 }
 
 function toPublicResolvedPageStories(

package/src/runtime/prerender/cache-envelope.ts

@@ -1,5 +1,6 @@
 import type { EditorSurfaceSnapshot } from "../../api/public-types";
 import type { CanonicalDocument } from "../../model/canonical-document.ts";
+import type { CompatibilityReport } from "../../core/state/editor-state.ts";
 import type { RuntimePageGraph } from "../layout/page-graph.ts";
 
 /**
@@ -28,6 +29,17 @@ import type { RuntimePageGraph } from "../layout/page-graph.ts";
  *   - `canonicalDocumentHash` — sha256 of sorted-keys JSON. Also the 5th
  *     input to `deriveCacheKey`, so style/metadata/comment/preservation
  *     mutations correctly invalidate the cache.
+ *
+ * Phase 2 Finale C3 addition (schema v3):
+ *   - `compatibilityReport?` — pre-computed `CompatibilityReport`. The
+ *     report is a pure function of `canonicalDocument` (plus the
+ *     `generatedAt` timestamp, which is pinned to the fixed sentinel
+ *     `"__cache_normalized__"` at prerender write time so envelopes are
+ *     byte-identical across two prerender calls). When present on the
+ *     Plan B short-circuit path, `loadDocxEditorSessionAsync` skips the
+ *     live `buildCompatibilityReport` call (60–100 ms on extra-large).
+ *     The field is optional so v3 writers can ship envelopes without it
+ *     (graceful degradation to the existing live-computation path).
  */
 export interface CacheEnvelope {
   readonly schemaVersion: number;
@@ -38,4 +50,22 @@ export interface CacheEnvelope {
   readonly graph: RuntimePageGraph;
   readonly surface: EditorSurfaceSnapshot;
   readonly canonicalDocument: CanonicalDocument;
+  /**
+   * v3+. Optional even at v3 — absence means "compute live on read".
+   * See the Phase 2 Finale C3 banner above.
+   */
+  readonly compatibilityReport?: CompatibilityReport;
 }
+
+/**
+ * Fixed sentinel used in place of `new Date().toISOString()` when
+ * pre-computing `compatibilityReport` for the envelope. Ensures two
+ * sequential `prerenderDocument` calls on identical bytes produce
+ * byte-identical cache envelopes.
+ *
+ * Downstream consumers of `compatibilityReport.generatedAt` are
+ * diagnostic-only — the field has never been user-visible in the editor
+ * UX. Cache-hit paths observe the sentinel; cache-miss paths observe a
+ * live ISO8601 timestamp.
+ */
+export const CACHE_NORMALIZED_GENERATED_AT = "__cache_normalized__" as const;

package/src/runtime/prerender/customxml-cache.ts

@@ -194,7 +194,7 @@ function extractInlineCdata(rawXml: string): string | null {
 function isValidCacheEnvelope(value: unknown): value is CacheEnvelope {
   if (typeof value !== "object" || value === null) return false;
   const v = value as Record<string, unknown>;
-  return (
+  const requiredFieldsOk =
     v.schemaVersion === LAYCACHE_SCHEMA_VERSION &&
     v.engineVersion === LAYOUT_ENGINE_VERSION &&
     typeof v.fontFingerprint === "string" &&
@@ -205,7 +205,21 @@ function isValidCacheEnvelope(value: unknown): value is CacheEnvelope {
     typeof v.surface === "object" &&
     v.surface !== null &&
     typeof v.canonicalDocument === "object" &&
-    v.canonicalDocument !== null
-  );
+    v.canonicalDocument !== null;
+  if (!requiredFieldsOk) return false;
+  // C3 (schema v3): `compatibilityReport` is optional — if present it must
+  // be a structured object with the expected shape markers. Envelopes
+  // without the field degrade gracefully to live-computation on read.
+  if (v.compatibilityReport !== undefined) {
+    const cr = v.compatibilityReport as Record<string, unknown> | null;
+    if (typeof cr !== "object" || cr === null) return false;
+    if (cr.reportVersion !== "compatibility-report/1") return false;
+    if (typeof cr.generatedAt !== "string") return false;
+    if (typeof cr.blockExport !== "boolean") return false;
+    if (!Array.isArray(cr.featureEntries)) return false;
+    if (!Array.isArray(cr.warnings)) return false;
+    if (!Array.isArray(cr.errors)) return false;
+  }
+  return true;
 }
 

package/src/runtime/prerender/prerender-document.ts

@@ -10,7 +10,11 @@ import {
 } from "../layout/layout-engine-version.ts";
 import { createLayoutEngine } from "../layout/layout-engine-instance.ts";
 import { createEditorSurfaceSnapshot } from "../surface-projection.ts";
-import type { CacheEnvelope } from "./cache-envelope.ts";
+import { buildCompatibilityReport } from "../../validation/compatibility-engine.ts";
+import {
+  CACHE_NORMALIZED_GENERATED_AT,
+  type CacheEnvelope,
+} from "./cache-envelope.ts";
 import {
   computeStructuralHash,
   deriveCacheKey,
@@ -167,6 +171,17 @@ export async function prerenderDocument(
     canonicalDocumentHash,
   });
 
+  // Phase 2 Finale C3: pre-compute `compatibilityReport` so the warm Plan B
+  // short-circuit in `loadDocxEditorSessionAsync` can skip the live
+  // `buildCompatibilityReport` call (~60–100 ms on extra-large). The report
+  // is a pure function of `canonicalDocument` + `generatedAt`; pinning
+  // `generatedAt` to `CACHE_NORMALIZED_GENERATED_AT` keeps the envelope
+  // byte-identical across two sequential prerenders on identical input.
+  const compatibilityReport = buildCompatibilityReport({
+    document: envelope,
+    generatedAt: CACHE_NORMALIZED_GENERATED_AT,
+  });
+
   const cacheBlob: CacheEnvelope = {
     schemaVersion: LAYCACHE_SCHEMA_VERSION,
     engineVersion: LAYOUT_ENGINE_VERSION,
@@ -176,6 +191,7 @@ export async function prerenderDocument(
     graph,
     surface,
     canonicalDocument: envelope,
+    compatibilityReport,
   };
 
   // Plan B B.5 — persistToCustomXml: inject the envelope into the docx's

package/src/runtime/render/render-kernel.ts

@@ -23,12 +23,8 @@ import type {
   PublicRegionBlock,
   WordReviewEditorLayoutFacet,
 } from "../layout/public-facet.ts";
-import type {
-  CommentDecorationModel,
-} from "../../ui/headless/comment-decoration-model.ts";
-import type {
-  RevisionDecorationModel,
-} from "../../ui/headless/revision-decoration-model.ts";
+import type { CommentDecorationModel } from "../../ui/headless/comment-decoration-model.ts";
+import type { RevisionDecorationModel } from "../../ui/headless/revision-decoration-model.ts";
 import type { ScopeRailSegment } from "../workflow-rail-segments.ts";
 import {
   resolveDecorationIndex,
@@ -148,6 +144,24 @@ export function createRenderKernel(input: CreateRenderKernelInput): RenderKernel
   // is an optimizer for repeat reads at the same revision.
   let lastEmittedFrame: RenderFrame | null = null;
 
+  // P14.c — single-slot DecorationIndex cache. `resolveDecorationIndex`
+  // is O(n × m) in decorations × offsets; it is safe to reuse the prior
+  // result when the layout revision, active story, zoom, and every source
+  // reference are all unchanged from the previous build.  The frame-level
+  // `cache` already prevents rebuilds for repeat reads; this slot covers
+  // the post-invalidate rebuild where layout changed but decorations did not.
+  let diCacheKey: {
+    revision: number;
+    activeStoryKind: string;
+    zoomPxPerTwip: number;
+    workflowSegments: readonly ScopeRailSegment[] | undefined;
+    comments: CommentDecorationModel | null | undefined;
+    revisions: RevisionDecorationModel | null | undefined;
+    searchMatches: readonly SearchMatchRange[] | undefined;
+    lockedRanges: readonly LockedRangeInput[] | undefined;
+  } | null = null;
+  let diCacheValue: DecorationIndex | null = null;
+
   const listeners = new Set<(event: RenderKernelEvent) => void>();
   const unsubscribeFacet = facet.subscribe((event) => {
     // Any layout-changing event invalidates the cached frame.  We rely on
@@ -208,6 +222,14 @@ export function createRenderKernel(input: CreateRenderKernelInput): RenderKernel
       pendingDeltas,
       zoom.pxPerTwip,
     );
+    // Revision: keyed off the engine's current page graph so repeated reads
+    // at the same revision return the same cached frame.  We derive it
+    // from the first page since the engine stamps every page with the
+    // graph's revision indirectly via pageId; fall back to 0 if empty.
+    const revision = filteredPages[0]
+      ? Number(extractRevisionFromPageId(filteredPages[0].pageId))
+      : 0;
+
     const includeDecorations = options?.includeDecorations ?? true;
     const sources = input.getDecorationSources?.();
     const hasSources =
@@ -217,11 +239,45 @@ export function createRenderKernel(input: CreateRenderKernelInput): RenderKernel
         (sources.revisions?.revisions?.length ?? 0) > 0 ||
         (sources.searchMatches && sources.searchMatches.length > 0) ||
         (sources.lockedRanges && sources.lockedRanges.length > 0));
-    const decorationIndex: DecorationIndex = !includeDecorations
-      ? EMPTY_DECORATION_INDEX
-      : hasSources
-        ? resolveDecorationIndex({ anchorIndex: baseAnchorIndex, ...sources })
-        : buildDecorationIndex(renderPages);
+    // P14.c — DecorationIndex single-slot cache. Check reference equality
+    // on every source before calling the O(n × m) resolver.
+    const newDIKey = {
+      revision: Number.isFinite(revision) ? revision : 0,
+      activeStoryKind: activeStory.kind,
+      zoomPxPerTwip: zoom.pxPerTwip,
+      workflowSegments: sources?.workflowSegments,
+      comments: sources?.comments,
+      revisions: sources?.revisions,
+      searchMatches: sources?.searchMatches,
+      lockedRanges: sources?.lockedRanges,
+    };
+    const diCacheHit =
+      hasSources &&
+      diCacheKey !== null &&
+      diCacheValue !== null &&
+      diCacheKey.revision === newDIKey.revision &&
+      diCacheKey.activeStoryKind === newDIKey.activeStoryKind &&
+      diCacheKey.zoomPxPerTwip === newDIKey.zoomPxPerTwip &&
+      diCacheKey.workflowSegments === newDIKey.workflowSegments &&
+      diCacheKey.comments === newDIKey.comments &&
+      diCacheKey.revisions === newDIKey.revisions &&
+      diCacheKey.searchMatches === newDIKey.searchMatches &&
+      diCacheKey.lockedRanges === newDIKey.lockedRanges;
+
+    let decorationIndex: DecorationIndex;
+    if (!includeDecorations) {
+      decorationIndex = EMPTY_DECORATION_INDEX;
+    } else if (hasSources) {
+      if (diCacheHit) {
+        decorationIndex = diCacheValue!;
+      } else {
+        decorationIndex = resolveDecorationIndex({ anchorIndex: baseAnchorIndex, ...sources });
+        diCacheKey = newDIKey;
+        diCacheValue = decorationIndex;
+      }
+    } else {
+      decorationIndex = buildDecorationIndex(renderPages);
+    }
     const anchorIndex = buildAnchorIndex(
       renderPages,
       pendingDeltas,
@@ -229,14 +285,6 @@ export function createRenderKernel(input: CreateRenderKernelInput): RenderKernel
       decorationIndex,
     );
 
-    // Revision: keyed off the engine's current page graph so repeated reads
-    // at the same revision return the same cached frame.  We derive it
-    // from the first page since the engine stamps every page with the
-    // graph's revision indirectly via pageId; fall back to 0 if empty.
-    const revision = filteredPages[0]
-      ? Number(extractRevisionFromPageId(filteredPages[0].pageId))
-      : 0;
-
     const frame: RenderFrame = {
       revision: Number.isFinite(revision) ? revision : 0,
       measurementFidelity,

package/src/runtime/surface-projection.ts

@@ -419,6 +419,9 @@ function createTableBlock(
         ...(cellBorders.borderRight ? { borderRight: cellBorders.borderRight } : {}),
         ...(cellBorders.borderBottom ? { borderBottom: cellBorders.borderBottom } : {}),
         ...(cellBorders.borderLeft ? { borderLeft: cellBorders.borderLeft } : {}),
+        // R3.a Phase 2: per-cell text-flow direction copied from canonical
+        // TableCellNode. Node-view renders `tbRl` / `btLr` as CSS writing-mode.
+        ...(cell.textDirection ? { textDirection: cell.textDirection } : {}),
         ...(bandClasses ? { bandClasses } : {}),
         content: cellContent,
       });
@@ -437,6 +440,30 @@ function createTableBlock(
     });
   }
 
+  // R3.a Phase 2 — fold the resolver's table-level bundle onto the surface
+  // block when any field is populated. Borders carry the typed BorderSpec per
+  // side; the node-view converts the four outer sides to CSS shorthand at
+  // render time. insideH / insideV flow through for round-trip + future use,
+  // but their visual effect is realized via per-cell borders today.
+  const tr = resolvedTable.tableResolved;
+  const trHasContent =
+    tr.width !== undefined ||
+    tr.layoutMode !== undefined ||
+    tr.cellSpacing !== undefined ||
+    tr.borders !== undefined;
+  const tableResolvedAttr = trHasContent
+    ? {
+        ...(tr.width !== undefined ? { width: tr.width } : {}),
+        ...(tr.widthType !== undefined ? { widthType: tr.widthType } : {}),
+        ...(tr.layoutMode !== undefined ? { layoutMode: tr.layoutMode } : {}),
+        ...(tr.cellSpacing !== undefined ? { cellSpacing: tr.cellSpacing } : {}),
+        ...(tr.cellSpacingType !== undefined
+          ? { cellSpacingType: tr.cellSpacingType }
+          : {}),
+        ...(tr.borders ? { borders: tr.borders } : {}),
+      }
+    : undefined;
+
   return {
     block: {
       blockId: `table-${tableIndex}`,
@@ -447,6 +474,7 @@ function createTableBlock(
       gridColumns: table.gridColumns,
       ...(resolvedTable.table?.alignment ? { alignment: resolvedTable.table.alignment } : {}),
       tblLook: resolvedTable.effectiveTblLook,
+      ...(tableResolvedAttr ? { tableResolved: tableResolvedAttr } : {}),
       rows,
     },
     lockedFragmentIds,

package/src/runtime/table-schema.ts

@@ -42,6 +42,8 @@ type TableCellAttrs = {
   borderRight?: string | null;
   borderBottom?: string | null;
   borderLeft?: string | null;
+  /** R3.a Phase 2 — per-cell text-flow direction. */
+  textDirection?: "lrTb" | "tbRl" | "btLr" | null;
   bandClasses?: string | null;
 };
 
@@ -188,6 +190,13 @@ const tableCellSpecAttrs = {
   borderRight: { default: null },
   borderBottom: { default: null },
   borderLeft: { default: null },
+  /**
+   * R3.a Phase 2 — per-cell text-flow direction copied from
+   * `TableCellNode.textDirection` ("lrTb" | "tbRl" | "btLr"). Node-view maps
+   * `tbRl` → `writing-mode: vertical-rl`, `btLr` → `writing-mode: vertical-lr`,
+   * `lrTb` (or null) → unset.
+   */
+  textDirection: { default: null },
   /** R2b: space-joined band classes ("band-firstRow band-band1Horz") from the resolved style. */
   bandClasses: { default: null },
 } as const;
@@ -210,6 +219,24 @@ export const tableNodeSpec: NodeSpec = {
     tblLookNoVBand: { default: false },
     /** R2d: raw `w:tblLook/@w:val` hex preserved verbatim so vendor-extended bits survive round-trip. */
     tblLookVal: { default: null },
+    // R3.a Phase 2 — table-level resolved properties projected from
+    // ResolvedTableLevelProperties. Each is nullable so PM's null-vs-undefined
+    // preference is satisfied. Width is in twips (dxa) or fiftieths-of-percent
+    // (pct); spacing is twips (dxa). Borders are CSS shorthand strings (e.g.
+    // "1px solid #000000") for the four outer sides; insideH / insideV are
+    // realized through per-cell border attrs (CSS has no native
+    // table-inside-border property — see applyTableAttrs comment).
+    tableWidth: { default: null },
+    tableWidthType: { default: null },
+    tableLayoutMode: { default: null },
+    tableCellSpacing: { default: null },
+    tableCellSpacingType: { default: null },
+    tableBorderTop: { default: null },
+    tableBorderRight: { default: null },
+    tableBorderBottom: { default: null },
+    tableBorderLeft: { default: null },
+    tableBorderInsideH: { default: null },
+    tableBorderInsideV: { default: null },
   },
   parseDOM: [{ tag: "table" }],
   toDOM(node) {