refactor(painter): drop fragments param from sdt+border helpers (SD-2836)

computeSdtBoundaries and computeBetweenBorderFlags previously took both
the raw `fragments` array and the parallel resolvedItems array. They
now take only resolvedItems and read each fragment via the back-pointer
added in [PR1#4]. Updates all four call sites in renderer.ts plus the
between-borders test fixture.

This eliminates the painter's lookup into `page.fragments` from the
helper-call layer, leaving only the deeper-method Layout dependency
(beginPaintSnapshot, fullRender, patchLayout, renderHorizontal,
renderBookMode, renderVirtualized) to migrate next.

Author: tupizz

packages/layout-engine/painters/dom/src/between-borders.test.ts

@@ -102,6 +102,7 @@ const buildResolvedItems = (fragments: readonly Fragment[], blocks: TestBlockLis
       width: fragment.width,
       height: 'height' in fragment && typeof fragment.height === 'number' ? fragment.height : 0,
       fragmentKind: fragment.kind,
+      fragment,
       blockId: fragment.blockId,
       fragmentIndex: index,
       paragraphBorders: borders,
@@ -113,7 +114,7 @@ const buildResolvedItems = (fragments: readonly Fragment[], blocks: TestBlockLis
 
 /** Test helper: run computeBetweenBorderFlags given fragments and the underlying blocks. */
 const runFlags = (fragments: readonly Fragment[], blocks: TestBlockList) =>
-  computeBetweenBorderFlags(fragments, buildResolvedItems(fragments, blocks));
+  computeBetweenBorderFlags(buildResolvedItems(fragments, blocks));
 
 const paraFragment = (blockId: string, overrides?: Partial<ParaFragment>): ParaFragment => ({
   kind: 'para',

packages/layout-engine/painters/dom/src/features/paragraph-borders/group-analysis.ts

@@ -8,7 +8,7 @@
  * @ooxml w:pPr/w:pBdr/w:between — between border for grouped paragraphs
  * @spec  ECMA-376 §17.3.1.24 (pBdr)
  */
-import type { Fragment, ListItemFragment, ResolvedPaintItem, ResolvedFragmentItem } from '@superdoc/contracts';
+import type { ListItemFragment, ResolvedPaintItem, ResolvedFragmentItem } from '@superdoc/contracts';
 import { hashParagraphBorders } from '../../paragraph-hash-utils.js';
 
 /**
@@ -69,23 +69,25 @@ function isResolvedFragmentWithBorders(
  * Middle fragments in a chain of 3+ get both flags.
  */
 export const computeBetweenBorderFlags = (
-  fragments: readonly Fragment[],
   resolvedItems: readonly ResolvedPaintItem[],
 ): Map<number, BetweenBorderInfo> => {
   // Phase 1: determine which consecutive pairs form between-border groups
   const pairFlags = new Set<number>();
   const noBetweenPairs = new Set<number>();
 
-  for (let i = 0; i < fragments.length - 1; i += 1) {
-    const frag = fragments[i];
+  for (let i = 0; i < resolvedItems.length - 1; i += 1) {
+    const resolvedCur = resolvedItems[i];
+    if (resolvedCur.kind !== 'fragment') continue;
+    const frag = resolvedCur.fragment;
     if (frag.kind !== 'para' && frag.kind !== 'list-item') continue;
     if (frag.continuesOnNext) continue;
 
-    const resolvedCur = resolvedItems[i];
     if (!isResolvedFragmentWithBorders(resolvedCur)) continue;
     const borders = resolvedCur.paragraphBorders;
 
-    const next = fragments[i + 1];
+    const resolvedNext = resolvedItems[i + 1];
+    if (resolvedNext.kind !== 'fragment') continue;
+    const next = resolvedNext.fragment;
     if (next.kind !== 'para' && next.kind !== 'list-item') continue;
     if (next.continuesFromPrev) continue;
     if (next.blockId === frag.blockId && next.kind === 'para') continue;
@@ -97,7 +99,6 @@ export const computeBetweenBorderFlags = (
     )
       continue;
 
-    const resolvedNext = resolvedItems[i + 1];
     if (!isResolvedFragmentWithBorders(resolvedNext)) continue;
     const nextBorders = resolvedNext.paragraphBorders;
 
@@ -129,10 +130,12 @@ export const computeBetweenBorderFlags = (
   const result = new Map<number, BetweenBorderInfo>();
 
   for (const i of pairFlags) {
-    const frag = fragments[i];
-    const next = fragments[i + 1];
     const resolvedCur = resolvedItems[i];
-    const fragHeight = resolvedCur && 'height' in resolvedCur && resolvedCur.height != null ? resolvedCur.height : 0;
+    const resolvedNext = resolvedItems[i + 1];
+    if (resolvedCur.kind !== 'fragment' || resolvedNext.kind !== 'fragment') continue;
+    const frag = resolvedCur.fragment;
+    const next = resolvedNext.fragment;
+    const fragHeight = 'height' in resolvedCur && resolvedCur.height != null ? resolvedCur.height : 0;
     const gapBelow = Math.max(0, next.y - (frag.y + fragHeight));
     const isNoBetween = noBetweenPairs.has(i);
 

packages/layout-engine/painters/dom/src/renderer.ts

@@ -2225,8 +2225,8 @@ export class DomPainter {
     };
 
     const resolvedItems = resolvedPage?.items ?? [];
-    const sdtBoundaries = computeSdtBoundaries(page.fragments, resolvedItems, this.sdtLabelsRendered);
-    const betweenBorderFlags = computeBetweenBorderFlags(page.fragments, resolvedItems);
+    const sdtBoundaries = computeSdtBoundaries(resolvedItems, this.sdtLabelsRendered);
+    const betweenBorderFlags = computeBetweenBorderFlags(resolvedItems);
 
     resolvedItems.forEach((resolvedItem, index) => {
       if (resolvedItem.kind !== 'fragment') return;
@@ -2581,7 +2581,7 @@ export class DomPainter {
 
     // Compute between-border flags for header/footer paragraph fragments
     const decorationItems = data.items ?? [];
-    const betweenBorderFlags = computeBetweenBorderFlags(data.fragments, decorationItems);
+    const betweenBorderFlags = computeBetweenBorderFlags(decorationItems);
 
     // Separate behindDoc fragments from normal fragments.
     // Prefer explicit fragment.behindDoc when present. Keep zIndex===0 as a
@@ -2774,8 +2774,8 @@ export class DomPainter {
     const existing = new Map(state.fragments.map((frag) => [frag.key, frag]));
     const nextFragments: FragmentDomState[] = [];
     const resolvedItems = resolvedPage?.items ?? [];
-    const sdtBoundaries = computeSdtBoundaries(page.fragments, resolvedItems, this.sdtLabelsRendered);
-    const betweenBorderFlags = computeBetweenBorderFlags(page.fragments, resolvedItems);
+    const sdtBoundaries = computeSdtBoundaries(resolvedItems, this.sdtLabelsRendered);
+    const betweenBorderFlags = computeBetweenBorderFlags(resolvedItems);
 
     const contextBase: FragmentRenderContext = {
       pageNumber: page.number,
@@ -2944,8 +2944,8 @@ export class DomPainter {
     };
 
     const resolvedItems = resolvedPage?.items ?? [];
-    const sdtBoundaries = computeSdtBoundaries(page.fragments, resolvedItems, this.sdtLabelsRendered);
-    const betweenBorderFlags = computeBetweenBorderFlags(page.fragments, resolvedItems);
+    const sdtBoundaries = computeSdtBoundaries(resolvedItems, this.sdtLabelsRendered);
+    const betweenBorderFlags = computeBetweenBorderFlags(resolvedItems);
     const fragmentStates: FragmentDomState[] = resolvedItems.flatMap((resolvedItem, index) => {
       if (resolvedItem.kind !== 'fragment') return [];
       const fragment = resolvedItem.fragment;
@@ -7255,52 +7255,61 @@ export class DomPainter {
 }
 
 const computeSdtBoundaries = (
-  fragments: readonly Fragment[],
   resolvedItems: readonly ResolvedPaintItem[],
   sdtLabelsRendered: Set<string>,
 ): Map<number, SdtBoundaryOptions> => {
   const boundaries = new Map<number, SdtBoundaryOptions>();
-  const containerKeys: (string | null)[] = fragments.map((_frag, idx) => {
-    const item = resolvedItems[idx];
+  const containerKeys: (string | null)[] = resolvedItems.map((item) => {
     if (item && 'sdtContainerKey' in item) {
       const key = (item as { sdtContainerKey?: string | null }).sdtContainerKey;
       return key ?? null;
     }
     return null;
   });
 
+  const fragmentOf = (idx: number): Fragment | null => {
+    const item = resolvedItems[idx];
+    return item && item.kind === 'fragment' ? item.fragment : null;
+  };
+
   let i = 0;
-  while (i < fragments.length) {
+  while (i < resolvedItems.length) {
     const currentKey = containerKeys[i];
-    if (!currentKey) {
+    const startFrag = fragmentOf(i);
+    if (!currentKey || !startFrag) {
       i += 1;
       continue;
     }
 
-    let groupRight = fragments[i].x + fragments[i].width;
+    let groupRight = startFrag.x + startFrag.width;
     let j = i;
 
-    while (j + 1 < fragments.length && containerKeys[j + 1] === currentKey) {
+    while (j + 1 < resolvedItems.length && containerKeys[j + 1] === currentKey) {
       j += 1;
-      const fragmentRight = fragments[j].x + fragments[j].width;
+      const nextFrag = fragmentOf(j);
+      if (!nextFrag) break;
+      const fragmentRight = nextFrag.x + nextFrag.width;
       if (fragmentRight > groupRight) {
         groupRight = fragmentRight;
       }
     }
 
     for (let k = i; k <= j; k += 1) {
-      const fragment = fragments[k];
+      const fragment = fragmentOf(k);
+      if (!fragment) continue;
       const isStart = k === i;
       const isEnd = k === j;
 
       let paddingBottomOverride: number | undefined;
       if (!isEnd) {
-        const nextFragment = fragments[k + 1];
+        const nextFragment = fragmentOf(k + 1);
         const currentHeight = (resolvedItems[k] as { height?: number } | undefined)?.height ?? 0;
         const currentBottom = fragment.y + currentHeight;
-        const gapToNext = nextFragment.y - currentBottom;
-        if (gapToNext > 0) {
-          paddingBottomOverride = gapToNext;
+        if (nextFragment) {
+          const gapToNext = nextFragment.y - currentBottom;
+          if (gapToNext > 0) {
+            paddingBottomOverride = gapToNext;
+          }
         }
       }