fix(measuring): gate SD-2447 alignment heuristic on default stops only

The SD-2447 heuristic forces the last N tabs to bind to the last N
end/center/decimal stops. It was added because TOC styles often have
ONLY a right-aligned dot-leader stop, and tabStops gets seeded with
synthetic 0.5" defaults from origin (seedDefaultsFromZero=true).
Greedy then lands on a default 0.5" grid stop instead of the alignment
stop — hence the heuristic.

But for paragraphs with an EXPLICIT start-aligned stop ahead of the
alignment stop (TOC1 style with 'start@740, end@9360, end@10080':
template_format and similar Word lease templates), greedy correctly
lands on the start stop and the alignment stop downstream — no force
needed. The heuristic over-fires and binds tab 0 to the right
alignment stop, producing the broken render: leader BEFORE the title
with the page number jammed against it.

Fix: compute greedy first; only apply the heuristic when greedy would
land on a 'source: default' stop. When greedy already lands on an
explicit stop, use it. Mirrored in measuring/dom and remeasure.

Effect:
- template_format TOC: now renders '1.    BUSINESS POINTS........1'
  matching Word and the published baseline.
- HVY-25 / SD-2447 fixture / sd-1480 line 1: behavior preserved.
- All test suites pass (measuring-dom 332, layout-bridge 1192,
  layout-engine 644).

Author: tupizz

packages/layout-engine/layout-bridge/src/remeasure.ts

@@ -874,19 +874,23 @@ const applyTabLayoutToLines = (
       const absCurrentX = cursorX + effectiveIndent;
       let stop: TabStopPx | undefined;
       let target: number;
+      // Mirror of measuring/dom: only force the SD-2447 heuristic when greedy
+      // would land on a `source:default` stop (synthetic 0.5" grid). Explicit
+      // start stops should win greedy.
+      const greedy = getNextTabStopPx(absCurrentX, tabStops, tabStopCursor);
+      const greedyOnDefault = greedy.stop?.source === 'default';
       const forcedAlignment =
-        typeof tabOrdinal === 'number' && Number.isFinite(tabOrdinal)
+        greedyOnDefault && typeof tabOrdinal === 'number' && Number.isFinite(tabOrdinal)
           ? getAlignmentStopForOrdinal(tabOrdinal, tabRunIdx)
           : null;
       if (forcedAlignment && forcedAlignment.stop.pos > absCurrentX + TAB_EPSILON) {
         stop = forcedAlignment.stop;
         target = forcedAlignment.stop.pos;
         tabStopCursor = forcedAlignment.index + 1;
       } else {
-        const next = getNextTabStopPx(absCurrentX, tabStops, tabStopCursor);
-        stop = next.stop;
-        target = next.target;
-        tabStopCursor = next.nextIndex;
+        stop = greedy.stop;
+        target = greedy.target;
+        tabStopCursor = greedy.nextIndex;
       }
       const clampedTarget = Number.isFinite(maxAbsWidth) ? Math.min(target, maxAbsWidth) : target;
       const relativeTarget = clampedTarget - effectiveIndent;

packages/layout-engine/measuring/dom/src/index.ts

@@ -1564,16 +1564,26 @@ async function measureParagraphBlock(block: ParagraphBlock, maxWidth: number): P
       // inputs (explicit + synthetic TabRuns) don't produce out-of-order ordinals.
       // Mirrors consumeTabOrdinal() in layout-bridge/src/remeasure.ts.
       sequentialTabIndex = Math.max(sequentialTabIndex, resolvedTabIndex + 1);
-      const forcedAlignment = getAlignmentStopForOrdinal(resolvedTabIndex, runIndex);
+      // Compute greedy first so we can decide whether the SD-2447 heuristic is
+      // actually needed. The heuristic exists because when tabStops are seeded
+      // with synthetic 0.5" defaults from origin (TOC styles with only an
+      // alignment stop), greedy lands on a default before reaching the
+      // alignment stop. When the paragraph has an explicit start-aligned stop
+      // ahead of the alignment stop (e.g. TOC1 with `start@740, end@9360`),
+      // greedy already finds the correct stop and the heuristic over-fires.
+      // Only force the heuristic when greedy would land on a `source:default`
+      // stop — which is precisely the SD-2447 condition.
+      const greedy = getNextTabStopPx(absCurrentX, tabStops, tabStopCursor);
+      const greedyOnDefault = greedy.stop?.source === 'default';
+      const forcedAlignment = greedyOnDefault ? getAlignmentStopForOrdinal(resolvedTabIndex, runIndex) : null;
       if (forcedAlignment && forcedAlignment.stop.pos > absCurrentX + TAB_EPSILON) {
         stop = forcedAlignment.stop;
         target = forcedAlignment.stop.pos;
         tabStopCursor = forcedAlignment.index + 1;
       } else {
-        const nextStop = getNextTabStopPx(absCurrentX, tabStops, tabStopCursor);
-        target = nextStop.target;
-        tabStopCursor = nextStop.nextIndex;
-        stop = nextStop.stop;
+        target = greedy.target;
+        tabStopCursor = greedy.nextIndex;
+        stop = greedy.stop;
       }
       const maxAbsWidth = currentLine.maxWidth + effectiveIndent;
       const clampedTarget = Math.min(target, maxAbsWidth);