@@ -1,5 +1,6 @@
 using System.Linq;
 using HtmlRenderer.Test.TestSupport;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
 
 namespace HtmlRenderer.Test.Dom;
 
@@ -142,4 +143,98 @@ public void TableLayout_RespectsSpecifiedColumnWidths()
         // explicitly-widened column) instead of an arbitrary absolute threshold.
         Assert.IsTrue(auto1Width < wideWidth, $"Auto cell ({auto1Width}) should be narrower than the explicitly-widened first cell ({wideWidth})");
     }
+
+    // Cherry-picked from PeachPDF's CssLayoutEngineTableTests (the rest of that file is general table
+    // layout, already out of scope for this port - see Fragmentation/CssLayoutEngineTablePageBreakTests.cs
+    // for the dedicated pagination-focused port). Adapted: PeachPDF's own version asserts against
+    // table.Boxes.OfType<CssProxyBox>() (its in-tree header-repeat proxy mechanism); this fork instead
+    // detaches repeated header clones onto CssBox.RepeatedHeaderRows (Core/Fragmentation/TableHeaderRepeat.cs)
+    // rather than inserting them into the live tree, so the assertions are rewritten onto that. Also drops
+    // the source's "@page { size: A4; margin: 20mm }" CSS rule (this fork's page grid is set on the
+    // container directly, via LayoutHarness's pageHeight parameter, not through @page).
+    [TestMethod]
+    public void TableLayout_DetectsPageBreaksCorrectly()
+    {
+        var html = LayoutHarness.Wrap(
+            "<table style='width:100%;border-collapse:collapse;'>" +
+            "<thead style='break-inside:avoid;'><tr><th style='border:1px solid black;padding:10px;'>Header</th></tr></thead>" +
+            "<tbody>" +
+            string.Concat(Enumerable.Range(1, 30).Select(i =>
+                $"<tr><td style='border:1px solid black;padding:10px;'>Row {i}</td></tr>")) +
+            "</tbody></table>");
+
+        const double pageHeight = 400.0;
+        var (root, container) = LayoutHarness.Layout(html, pageHeight: pageHeight, margin: 20);
+
+        var table = FindTableBox(root);
+        Assert.IsNotNull(table);
+
+        var tableHeight = table!.ActualBottom - table.Location.Y;
+
+        Assert.IsTrue(tableHeight > pageHeight, $"Table height ({tableHeight}) should exceed page height ({pageHeight})");
+        Assert.IsNotNull(table.RepeatedHeaderRows);
+        Assert.IsTrue(table.RepeatedHeaderRows!.Count >= 2,
+            $"Should have at least 2 repeated header row-sets for a multi-page table, found {table.RepeatedHeaderRows.Count}");
+    }
+
+    [TestMethod]
+    public void TableLayout_PositionsHeadersAtCorrectPageStarts()
+    {
+        var html = LayoutHarness.Wrap(
+            // Deliberately not border-collapse:collapse/padding - see
+            // CssLayoutEngineTablePageBreakTests.RepeatedThead_SinglePageBorderCollapseTable_... for a
+            // dedicated, [Ignore]d test pinning down why that combination can shift a table's own top
+            // fractionally off a page boundary and produce a spurious extra repeat.
+            "<table style='width:100%;'>" +
+            "<thead style='break-inside:avoid;'><tr><th style='height:20px;padding:0;margin:0;'>Header</th></tr></thead>" +
+            "<tbody>" +
+            string.Concat(Enumerable.Range(1, 10).Select(i =>
+                $"<tr><td style='height:20px;padding:0;margin:0;'>Row {i}</td></tr>")) +
+            "</tbody></table>");
+
+        // Very short pages to force multiple page breaks.
+        var (root, container) = LayoutHarness.Layout(html, pageHeight: 200, margin: 20);
+
+        var table = FindTableBox(root);
+        Assert.IsNotNull(table);
+        Assert.IsNotNull(table!.RepeatedHeaderRows);
+        Assert.IsTrue(table.RepeatedHeaderRows!.Count >= 1, "Should have at least one repeated header row-set");
+
+        // Each repeated header row's own cell carries its real position - the row box itself is never
+        // positioned by table layout (see CssLayoutEngineTablePageBreakTests' identical note).
+        var headerYPositions = table.RepeatedHeaderRows
+            .Select(row => row.Boxes.Count > 0 ? row.Boxes[0].Location.Y : row.Location.Y)
+            .OrderBy(y => y)
+            .ToList();
+
+        // Every repeated header should land at one of this page grid's own real page tops.
+        foreach (var y in headerYPositions)
+        {
+            var slot = container.PageIndexOf(y);
+            Assert.AreEqual(container.PageTopOf(slot), y, 0.5, $"repeated header at Y={y} should sit flush at page-slot {slot}'s content top");
+        }
+
+        // If there are multiple repeats, they must be at different Y positions - not all collapsed onto
+        // the same page.
+        if (headerYPositions.Count > 1)
+        {
+            var uniquePositions = headerYPositions.Distinct().Count();
+            Assert.IsTrue(uniquePositions > 1,
+                $"Multiple repeated headers should be at different Y positions, but all {headerYPositions.Count} were the same");
+        }
+    }
+
+    private static CssBox? FindTableBox(CssBox box)
+    {
+        if (box.Display == TheArtOfDev.HtmlRenderer.Core.Utils.CssConstants.Table)
+            return box;
+
+        foreach (var child in box.Boxes)
+        {
+            var found = FindTableBox(child);
+            if (found is not null) return found;
+        }
+
+        return null;
+    }
 }
@@ -0,0 +1,109 @@
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+using TheArtOfDev.HtmlRenderer.Core.Fragmentation;
+
+namespace HtmlRenderer.Test.Fragmentation;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Html/Core/Fragmentation/BreakTokenTests.cs (BreakTokenTests).
+/// </summary>
+/// <remarks>
+/// The resumption record: says <i>where</i> layout stopped and nothing about geometry - the box tree still
+/// holds the coordinates - so these pin its shape rather than any placement. PeachPDF's own file also covers
+/// <c>InlineBreakToken</c>/<c>FlexBreakToken</c>/<c>GridBreakToken</c>/<c>FlexColumnBreakToken</c>, none of
+/// which exist here - <c>BreakToken.cs</c>'s own doc comment confirms only forced <c>break-before</c>/
+/// <c>break-after: page</c> ever produces a real cross-pass token in this port (everything else - overflow,
+/// break-inside:avoid, keep-with-next, widows/orphans, table-row breaks - turned out to be same-pass local
+/// corrections instead), so <see cref="BlockBreakToken"/> is the only concrete <see cref="BreakToken"/> to
+/// test. Every test below that PeachPDF built over a different token kind is dropped as out of scope rather
+/// than adapted; <c>Chain_...</c> is kept but rewritten to chain only <see cref="BlockBreakToken"/> links,
+/// since that's the only concrete kind this port has to chain.
+/// </remarks>
+[TestClass]
+public sealed class BreakTokenTests
+{
+    [TestMethod]
+    public void BreakBefore_CarriesNoChildToken()
+    {
+        var box = new CssBox(null, null);
+
+        var token = new BlockBreakToken(box, ResumeSlotIndex: 1, ResumeChildIndex: 3, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+
+        // A break *before* a child means the child was never entered, so there is nothing inside it
+        // to resume - this is what makes "no fragment in the earlier fragmentainer" structural.
+        Assert.IsTrue(token.IsBreakBefore);
+        Assert.IsNull(token.ChildToken);
+        Assert.AreEqual(3, token.ResumeChildIndex);
+        Assert.AreSame(box, token.Box);
+    }
+
+    [TestMethod]
+    public void BreakInside_CarriesTheChildsOwnToken()
+    {
+        var parent = new CssBox(null, null);
+        var child = new CssBox(null, null);
+
+        var childToken = new BlockBreakToken(child, ResumeSlotIndex: 1, ResumeChildIndex: 1, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+        var token = new BlockBreakToken(parent, ResumeSlotIndex: 1, ResumeChildIndex: 0, ChildToken: childToken, IsBreakBefore: false, ResumeTopOverride: null);
+
+        Assert.IsFalse(token.IsBreakBefore);
+        Assert.AreSame(childToken, token.ChildToken);
+    }
+
+    [TestMethod]
+    public void Chain_NestsOneLinkPerAncestorOnThePathToTheContextRoot()
+    {
+        var root = new CssBox(null, null);
+        var middle = new CssBox(null, null);
+        var leaf = new CssBox(null, null);
+
+        var leafToken = new BlockBreakToken(leaf, ResumeSlotIndex: 1, ResumeChildIndex: 2, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+        var middleToken = new BlockBreakToken(middle, ResumeSlotIndex: 1, ResumeChildIndex: 1, ChildToken: leafToken, IsBreakBefore: false, ResumeTopOverride: null);
+        var rootToken = new BlockBreakToken(root, ResumeSlotIndex: 1, ResumeChildIndex: 2, ChildToken: middleToken, IsBreakBefore: false, ResumeTopOverride: null);
+
+        // Walking the chain down from the root is exactly how a resumed pass re-enters each ancestor
+        // mid-flight while leaving boxes off the path alone.
+        var boxes = new List<CssBox>();
+        for (BlockBreakToken? t = rootToken; t is not null; t = t.ChildToken as BlockBreakToken)
+            boxes.Add(t.Box);
+
+        CollectionAssert.AreEqual(new[] { root, middle, leaf }, boxes);
+    }
+
+    [TestMethod]
+    public void ResumeTopOverride_IsCarriedForTheAdjustedTargetPathsThatComputeIt()
+    {
+        var box = new CssBox(null, null);
+
+        var token = new BlockBreakToken(box, ResumeSlotIndex: 1, ResumeChildIndex: 0, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: 1234.5);
+
+        // Margin truncation and the keep-with-next pull have already worked out where the box goes;
+        // the resumed pass must use that value rather than re-deriving it.
+        Assert.AreEqual(1234.5, token.ResumeTopOverride);
+    }
+
+    [TestMethod]
+    public void BlockBreakToken_IsARecord_WithStructuralEquality()
+    {
+        var box = new CssBox(null, null);
+
+        // A record's compiler-generated equality is what lets a resumed pass compare "did this pass land
+        // on the same resumption point as a previous one" without hand-written Equals/GetHashCode - two
+        // independently-built tokens over the same field values must compare equal.
+        var first = new BlockBreakToken(box, ResumeSlotIndex: 2, ResumeChildIndex: 4, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+        var second = new BlockBreakToken(box, ResumeSlotIndex: 2, ResumeChildIndex: 4, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+
+        Assert.AreEqual(first, second);
+        Assert.AreEqual(first.GetHashCode(), second.GetHashCode());
+    }
+
+    [TestMethod]
+    public void BlockBreakToken_WithADifferentResumeChildIndex_ComparesUnequal()
+    {
+        var box = new CssBox(null, null);
+
+        var first = new BlockBreakToken(box, ResumeSlotIndex: 2, ResumeChildIndex: 4, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+        var second = new BlockBreakToken(box, ResumeSlotIndex: 2, ResumeChildIndex: 5, ChildToken: null, IsBreakBefore: true, ResumeTopOverride: null);
+
+        Assert.AreNotEqual(first, second);
+    }
+}
@@ -0,0 +1,60 @@
+using TheArtOfDev.HtmlRenderer.Core.Fragmentation;
+
+namespace HtmlRenderer.Test.Fragmentation;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Html/Core/Fragmentation/BreakValuesTests.cs (BreakValuesTests).
+/// </summary>
+/// <remarks>
+/// PeachPDF's <c>BreakValues</c> answers several questions - a full css-break-3 §3.1 forced-break value
+/// set (including the four directional values), a <c>RequiredSide</c>/<c>PageSide</c> resolver for them, a
+/// two-context (<c>page</c>/<c>column</c>) <c>AvoidsBreak</c>/<c>IsForcedBreak</c>, a <c>SlotIsOn</c> parity
+/// helper, and <c>PageRuleResolver.IsRightPage</c>. This port's own <see cref="BreakValues"/> is reduced to
+/// exactly what this port's engine (pages only, no multi-column, no directional/<c>@page :left</c>/<c>:right</c>
+/// matching - see its own class doc comment) needs: <see cref="BreakValues.IsForcedBreak"/> and
+/// <see cref="BreakValues.AvoidsBreak"/>, each single-argument (no <c>FragmentationContext</c> - there is
+/// only ever one context, the page) and single-context-valued (only <c>page</c>/<c>always</c> force a break;
+/// only <c>avoid</c>/<c>avoid-page</c> forbid one). Every PeachPDF theory row naming a directional
+/// (<c>left</c>/<c>right</c>/<c>recto</c>/<c>verso</c>), <c>region</c>/<c>avoid-region</c>, or
+/// <c>column</c>/<c>avoid-column</c> value is dropped per the port plan's scope decision, and with them the
+/// entire <c>RequiredSide</c>/<c>PageSide</c>/<c>SlotIsOn</c>/<c>PageRuleResolver</c> surface, which has no
+/// counterpart here at all.
+///
+/// One real divergence from PeachPDF found while porting: PeachPDF's classifier rejects the legacy
+/// <c>always</c> spelling outright (it only ever reaches a box through the legacy <c>page-break-*</c> alias,
+/// which PeachPDF's own CssUtils rewrites to <c>page</c> before the classifier ever sees it). This port's
+/// <see cref="BreakValues.IsForcedBreak"/> (Core/Fragmentation/BreakValues.cs) accepts <c>always</c> directly
+/// instead, per its own doc comment: "HTML-Renderer's CSS engine accepts directly on the modern properties
+/// too... rather than normalizing it away at parse time - so both spellings are classified here." Confirmed
+/// independently by <c>PropertyBreakTests.BreakBeforeAfter_AcceptsAlwaysUnlikePeachPdf</c>
+/// (Css/PropertyBreakTests.cs), which documents the same divergence at the CSS-parsing layer.
+/// </remarks>
+[TestClass]
+public sealed class BreakValuesTests
+{
+    [TestMethod]
+    [DataRow("page", true)]
+    [DataRow("always", true)]
+    [DataRow("auto", false)]
+    [DataRow("avoid", false)]
+    [DataRow("avoid-page", false)]
+    [DataRow(null, false)]
+    public void IsForcedBreak_MatchesThisPortsReducedValueSet(string value, bool expected) =>
+        Assert.AreEqual(expected, BreakValues.IsForcedBreak(value));
+
+    // The divergence from PeachPDF documented in the class remarks: unlike PeachPDF's
+    // IsForcedPageBreak_RejectsTheLegacyAlwaysSpelling, this port's classifier accepts "always" directly.
+    [TestMethod]
+    public void IsForcedBreak_AcceptsTheLegacyAlwaysSpellingUnlikePeachPdf() =>
+        Assert.IsTrue(BreakValues.IsForcedBreak("always"));
+
+    [TestMethod]
+    [DataRow("avoid", true)]
+    [DataRow("avoid-page", true)]
+    [DataRow("auto", false)]
+    [DataRow("page", false)]
+    [DataRow("always", false)]
+    [DataRow(null, false)]
+    public void AvoidsBreak_MatchesThisPortsReducedValueSet(string value, bool expected) =>
+        Assert.AreEqual(expected, BreakValues.AvoidsBreak(value));
+}