@@ -757,6 +757,31 @@ private void LayoutCells(RGraphics g)
                     if (bottomSlot > topSlot && shouldPreserve && rowHeight < pageGridContainer.PageSize.Height)
                     {
                         var delta = pageGridContainer.PageTopOf(topSlot + 1) - cury;
+
+                        // cury == starty means nothing has been drawn above this row within the table yet
+                        // (no earlier row consumed space on the table's original page) - so this row moving
+                        // IS the table's own content moving wholesale, not one row among several straddling
+                        // independently. The table's own Location was set once, before this method ever
+                        // ran, by its parent's child loop - row-atomicity shifting cell rectangles alone
+                        // left it stale, so EnforceKeepWithNext(table) (called on the table exactly like any
+                        // other child) never saw the boundary crossing and could never pull an avoid-chained
+                        // heading along. Only the table's own Location follows here - deliberately NOT
+                        // BlockFragmentation.PropagateContainerRelocation's further climb into an ancestor:
+                        // this method can run more than once per overall document pass whenever an ancestor
+                        // is independently relocated by RelocateIfNeeded (which re-lays the whole subtree
+                        // out fresh at its own target) - climbing here too would double-count that ancestor's
+                        // own already-correct shift on top of RelocateIfNeeded's (confirmed: caused a real
+                        // regression in BoxContainingARepeatingTable_IsStillRelocated, a table inside its own
+                        // break-inside:avoid card, off by the same few pixels PageSlotOf's collapsed-border
+                        // tolerance allows). A plain, non-avoid wrapper around a table whose first row alone
+                        // triggers this path is not climbed to - a narrower fix than full css-break-3 3.1
+                        // propagation, matching what the two tests this fixes actually exercise (the table
+                        // itself as EnforceKeepWithNext's own child, not a further-wrapped one).
+                        if (Math.Abs(cury - starty) < 0.01)
+                        {
+                            _tableBox.Location = new RPoint(_tableBox.Location.X, _tableBox.Location.Y + delta);
+                        }
+
                         foreach (CssBox cell in row.Boxes)
                         {
                             // A rowspan-crossing cell's real content lives on CssSpacingBox.ExtendedBox,
 
@@ -102,17 +102,16 @@ private static CssBox FindByClass(CssBox root, string className)
     }
 
     // css-tables-3 §6.1's row-atomicity shift (CssLayoutEngineTable.LayoutCells) moves each CELL's own
-    // rectangle (cell.OffsetTop) - it never touches the outer <table> box's own Location, which stays
-    // wherever the table's own (unmoved) top naturally fell. So "did the table move" has to be read off a
-    // cell inside it, not the <table> element itself.
+    // rectangle (cell.OffsetTop); the outer <table> box's own Location follows too, but only when the
+    // shifted row is the table's very first content (nothing rendered above it within the table yet) - an
+    // ordinary row straddling further down a multi-page table correctly leaves the table's Location where
+    // its real first row is. Reading a cell directly is the robust check either way, so tests use this
+    // rather than assuming which case applies.
     private static CssBox FindFirstCell(CssBox table) => Walk(table).FirstOrDefault(b => b.HtmlTag?.Name == "td")!;
 
     // A table moved wholesale to the next page (css-tables-3 §6.1 row-atomicity, its only row too tall to
     // fit) must pull its avoid-chained heading along instead of stranding it at the bottom of the old page.
     [TestMethod]
-    [Ignore("Confirmed gap: CssLayoutEngineTable's row-atomicity shift only offsets the cell's own "
-        + "rectangle, never the outer <table> box's own Location/EffectiveTop, so EnforceKeepWithNext(table) "
-        + "never observes the boundary crossing - see this class's own doc remark.")]
     public async Task TableMovedToNextPage_PullsAvoidChainedHeadingAlong()
     {
         var (root, container) = await BuildAsync(
@@ -157,8 +156,6 @@ public async Task TableMovedToNextPage_LeavesNonAvoidHeadingBehind()
     // The chain walk must skip a display:none sibling and pull BOTH the heading and an avoid-chained intro
     // paragraph along when the table moves to the next page.
     [TestMethod]
-    [Ignore("Same confirmed gap as TableMovedToNextPage_PullsAvoidChainedHeadingAlong - see this class's "
-        + "own doc remark.")]
     public async Task TableMovedToNextPage_ChainSkipsDisplayNoneSibling_PullsHeadingAndIntroAlong()
     {
         var (root, container) = await BuildAsync(