@@ -874,18 +874,32 @@ public void PerformPaint(RGraphics g)
         /// </summary>
         /// <param name="g">the device to use to render</param>
         /// <param name="fragmentainer">the fragmentainer to paint</param>
+        /// <remarks>
+        /// The pushed clip's Y origin is always 0, never <see cref="MarginTop"/>/<see cref="_location"/>'s
+        /// Y - unlike <see cref="PerformPaint(RGraphics)"/>'s multi-fragmentainer loop (which paints every
+        /// band back onto one continuous, absolute-Y surface via a per-band page-origin translate),
+        /// <paramref name="fragmentainer"/> here is painted alone onto its own fresh surface (a real PDF
+        /// page, one per <see cref="PdfGenerator"/> loop iteration) with no such translate - so its content
+        /// paints at exactly the fragment-local coordinates <see cref="Fragmentation.FragmentEmitter"/>
+        /// already produced (band-local Y = document Y - band top, per that type's own doc comment). A real
+        /// bug found while confirming this: the clip previously started at Y=<see cref="MarginTop"/>
+        /// (mirroring the single-surface overload's own absolute-Y convention), silently clipping away the
+        /// first <see cref="MarginTop"/>-tall strip of every single page's own content - confirmed by a
+        /// list item landing entirely within that clipped strip and never appearing in the paint log at all,
+        /// with no exception raised (the visibility cull is a quiet no-op, not a thrown error).
+        /// </remarks>
         internal void PerformPaint(RGraphics g, Fragments.FragmentainerFragment fragmentainer)
         {
             ArgChecker.AssertArgNotNull(g, "g");
             ArgChecker.AssertArgNotNull(fragmentainer, "fragmentainer");
 
             if (MaxSize.Height > 0)
             {
-                g.PushClip(new RRect(_location.X, _location.Y, Math.Min(_maxSize.Width, PageSize.Width), Math.Min(_maxSize.Height, PageSize.Height)));
+                g.PushClip(new RRect(_location.X, 0, Math.Min(_maxSize.Width, PageSize.Width), Math.Min(_maxSize.Height, PageSize.Height)));
             }
             else
             {
-                g.PushClip(new RRect(MarginLeft, MarginTop, PageSize.Width, PageSize.Height));
+                g.PushClip(new RRect(MarginLeft, 0, PageSize.Width, PageSize.Height));
             }
 
             new Paint.FragmentPainter(this).Paint(g, fragmentainer);
 
@@ -0,0 +1,172 @@
+using System.Collections.Generic;
+using System.Linq;
+using HtmlRenderer.IntegrationTest.TestSupport;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TheArtOfDev.HtmlRenderer.Core;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+using TheArtOfDev.HtmlRenderer.Core.Fragments;
+using TheArtOfDev.HtmlRenderer.Core.Utils;
+
+namespace TheArtOfDev.HtmlRenderer.IntegrationTest.Fragmentation;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Integration/BlockContentListMarkerTests.cs. PeachPDF's root defect
+/// (<c>CssBox.LayoutOutsideMarker</c> re-parenting a block-content item's marker into the anonymous block its
+/// inline run needs, then scanning only <i>direct</i> children to find it again) does not exist by
+/// construction here: HTML-Renderer's marker is <see cref="CssBox.ListItemBox"/>, a field entirely separate
+/// from <see cref="CssBox.Boxes"/> - it is never wrapped in an anonymous block regardless of whether the
+/// item's content is inline or block-level, so every PeachPDF test asserting that structural fact
+/// (<c>AnOutsideMarker_IsNotWrappedInTheItemsAnonymousBlock</c>), the resulting mispositioned content
+/// (<c>AnItemWhoseContentIsBlockLevel_LaysThatContentOutBelowTheItemsTop</c>), or the marker's own screen
+/// position (<c>AnItemWhoseContentIsBlockLevel_PositionsItsMarkerLikeAnInlineOne</c>,
+/// <c>AnItemMixingInlineAndBlockContent_KeepsItsAnonymousBlockAndItsMarker</c>) is general list-layout
+/// correctness unrelated to pagination, not fragment-claiming - out of scope for this porting batch per the
+/// plan's own instruction to port only the claiming-relevant half of this file.
+/// <c>AnInsideMarker_IsStillWrappedWithTheItemsInlineRun</c> is dropped outright:
+/// <c>list-style-position</c> is parsed and stored (<c>CssBoxProperties.ListStylePosition</c>) but never
+/// consulted by <c>CssBox.CreateListItemBox</c> - confirmed by reading it in full - so this port has no
+/// "inside" marker rendering mode at all, matching the parse-only-stub precedent already established for
+/// other CSS properties this porting effort has found (e.g. the <c>page</c> property in Batch 2).
+/// <c>AnItemWhoseKeptContentCarriesNoWords_KeepsItsMarkerWhereItBegins</c> is dropped: it requires a real
+/// multi-column engine (<c>column-count</c>), out of scope for this whole porting effort.
+/// <para>
+/// The 2 tests that remain are genuinely about fragment-claiming: whether a block-content item's marker is
+/// claimed by a fragment at all (single-page - the base case PeachPDF's bug broke completely, drawing the
+/// marker on <i>no</i> page), and whether the item travels whole with its marker across a real forced page
+/// break (multi-page - the pagination-relevant half of PeachPDF's own file). The second is ported but
+/// <c>[Ignore]</c>d: it hits a different, confirmed gap (forced-break ancestor propagation, not the marker
+/// mechanism) - see its own remarks below.
+/// </para>
+/// </summary>
+[TestClass]
+[DoNotParallelize]
+public sealed class BlockContentListMarkerTests
+{
+    private const string BlockItemList =
+        "<ol style='margin:0;padding-left:40px'>"
+        + "<li id='block'><p style='margin:0'>block content here</p></li>"
+        + "<li id='inline'>inline content</li></ol>";
+
+    /// <summary>
+    /// The fragment-tree statement of PeachPDF's own symptom: a marker no fragment claims is the state paint
+    /// reads when it draws nothing. Single page - this is the base case, not a pagination scenario.
+    /// </summary>
+    [TestMethod]
+    public void AnItemWhoseContentIsBlockLevel_HasItsMarkerClaimedExactlyOnce()
+    {
+        var (root, container) = PaintHarness.Layout(PaintHarness.Wrap(BlockItemList));
+
+        var claims = ClaimsByWord(container);
+
+        foreach (var item in ListItems(root))
+        {
+            var marker = item.ListItemBox;
+            Assert.IsNotNull(marker, $"'{Id(item)}' has no marker box");
+            var word = marker!.Words.Single();
+
+            Assert.IsTrue(claims.TryGetValue(word, out var slots),
+                $"the marker of '{Id(item)}' is claimed by no fragment at all");
+            Assert.AreEqual(1, slots!.Count);
+        }
+    }
+
+    /// <summary>
+    /// An item whose only content asks to start on the next page has nothing to keep on the page it was
+    /// declined on, so css-break-3 §3.1 moves the whole item - "a break before a container's own first
+    /// in-flow child is the break point before the container".
+    /// </summary>
+    /// <remarks>
+    /// Confirmed NOT to reproduce here, for a reason unrelated to the marker mechanism this file is
+    /// otherwise about: <c>BlockFragmentation.TryGetForcedBreakTarget</c>'s own doc comment documents a
+    /// deliberate scope limit - "suppressed when there's no previous sibling", since full css-break-3 §3.1
+    /// ancestor propagation (a forced break with no previous sibling really belongs to the nearest ancestor
+    /// that HAS one) is out of scope for this port. Here <c>p</c> (the <c>break-before:page</c> box) is
+    /// <c>li</c>'s only child, so <c>prevSibling == null</c> for <c>p</c> itself and the forced break is
+    /// suppressed outright - it never even reaches the point where <c>li</c> (which DOES have a previous
+    /// sibling, the earlier <c>&lt;p&gt;before&lt;/p&gt;</c>) could inherit it. Confirmed by running this
+    /// test unignored: the whole document stays on one page, never spanning more than one fragmentainer at
+    /// all. This is the same confirmed gap as this port's own <c>PageBreakIntegrationTests</c> remarks call
+    /// out for margin-truncation propagation - here it blocks a forced break instead.
+    /// </remarks>
+    [TestMethod]
+    [Ignore("Confirmed gap: BlockFragmentation.TryGetForcedBreakTarget suppresses a forced break-before " +
+        "entirely when the box has no previous sibling (full css-break-3 §3.1 ancestor propagation - " +
+        "letting a nested first-in-flow-child's break become its own parentless ancestor's - is out of " +
+        "scope for this port, per that method's own doc comment). Here <p style='break-before:page'> is " +
+        "<li>'s only child, so the break is suppressed before it could ever reach <li> (which does have a " +
+        "previous sibling). Confirmed by running this test unignored: the document never spans more than " +
+        "one fragmentainer at all.")]
+    public void AnItemDeferredBeforeItsContentWasEverFlowed_TravelsWholeWithItsMarker()
+    {
+        var html = PaintHarness.Wrap(
+            "<p style='margin:0'>before</p>"
+            + "<ol style='margin:0;padding-left:40px'>"
+            + "<li id='deferred'><p style='margin:0;break-before:page'>content here</p></li></ol>");
+
+        var (root, container) = PaintHarness.LayoutPaginated(html, pageHeight: 850, margin: 10);
+
+        var item = PaintHarness.FindById(root, "deferred")!;
+        var word = item.ListItemBox!.Words.Single();
+        var fragments = FragmentsOf(container, item);
+
+        Assert.IsTrue(container.FragmentTree!.Fragmentainers.Count > 1,
+            "the fixture must span more than one page");
+
+        // One fragment, on the page the item's content is on - no stub left behind on the page it was
+        // declined on, and the marker with it.
+        Assert.AreEqual(1, fragments.Count);
+        var fragment = fragments[0];
+
+        Assert.IsTrue(fragment.FragmentainerIndex > 0);
+        Assert.IsNotNull(fragment.MarkerFragment);
+        var claims = ClaimsByWord(container);
+        Assert.AreEqual(1, claims[word].Count);
+    }
+
+    // ── Helpers ──────────────────────────────────────────────────────────────
+
+    private static IEnumerable<CssBox> Walk(CssBox box)
+    {
+        yield return box;
+        foreach (var b in box.Boxes)
+            foreach (var d in Walk(b))
+                yield return d;
+    }
+
+    private static IEnumerable<BoxFragment> Flatten(BoxFragment fragment)
+    {
+        yield return fragment;
+        foreach (var child in fragment.Children)
+            foreach (var d in Flatten(child))
+                yield return d;
+        if (fragment.MarkerFragment != null)
+            foreach (var d in Flatten(fragment.MarkerFragment))
+                yield return d;
+    }
+
+    private static List<CssBox> ListItems(CssBox root) =>
+        Walk(root).Where(b => b.Display == CssConstants.ListItem).ToList();
+
+    private static string? Id(CssBox box) => box.HtmlTag?.TryGetAttribute("id");
+
+    private static List<BoxFragment> FragmentsOf(HtmlContainerInt container, CssBox box) =>
+        container.FragmentTree!.Fragmentainers
+            .SelectMany(f => Flatten(f.Root))
+            .Where(f => ReferenceEquals(f.Box, box))
+            .ToList();
+
+    private static Dictionary<CssRect, List<int>> ClaimsByWord(HtmlContainerInt container)
+    {
+        var claims = new Dictionary<CssRect, List<int>>(ReferenceEqualityComparer.Instance);
+        foreach (var fragmentainer in container.FragmentTree!.Fragmentainers)
+        {
+            foreach (var word in Flatten(fragmentainer.Root).SelectMany(f => f.Words))
+            {
+                if (!claims.TryGetValue(word.Word, out var slots))
+                    claims[word.Word] = slots = new List<int>();
+                slots.Add(fragmentainer.SlotIndex);
+            }
+        }
+        return claims;
+    }
+}
@@ -0,0 +1,118 @@
+using System.Collections.Generic;
+using System.Drawing;
+using System.Linq;
+using System.Reflection;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using TheArtOfDev.HtmlRenderer.Adapters.Entities;
+using TheArtOfDev.HtmlRenderer.Core;
+using TheArtOfDev.HtmlRenderer.Core.Dom;
+using TheArtOfDev.HtmlRenderer.Core.Fragments;
+using TheArtOfDev.HtmlRenderer.WinForms;
+
+namespace TheArtOfDev.HtmlRenderer.IntegrationTest.Fragmentation;
+
+/// <summary>
+/// Ported from PeachPDF.Tests/Integration/StraddlingLineClaimTests.cs: content taller than the whole page
+/// band has nowhere to go (css-break-3 §2's "content too large for any fragment" case), so layout leaves it
+/// exactly where it is - and every band it geometrically covers must still claim it. Maps to
+/// <c>FragmentEmitter.Overlaps</c> (a strict rect/band overlap test, applied independently per band with no
+/// special case for oversized content, so an oversized word is claimed by construction rather than through
+/// any dedicated "straddling" logic).
+/// </summary>
+/// <remarks>
+/// Only 1 of PeachPDF's 3 tests ports:
+/// <list type="bullet">
+/// <item><c>ContentAfterAWordTallerThanTheBand_SeesATruthfulCursor</c> is dropped: it asserts
+/// <c>HtmlContainerInt.CursorSpills</c> stays zero, a counter belonging to PeachPDF's own per-pass document
+/// cursor. Confirmed by reading <c>Core/Fragmentation/InlineFragmentation.cs</c> and
+/// <c>Core/Fragmentation/BlockFragmentation.cs</c> in full plus <c>HtmlContainerInt.cs</c>: this port has no
+/// such cursor at all (layout runs the whole document's flow in one pass; there is nothing for a "stale
+/// cursor after an oversized word" bug to corrupt).</item>
+/// <item><c>ARowOrLineTheEngineCouldNotFit_ContinuesOnTheNextPageInstead</c> is dropped: all 3
+/// <c>[InlineData]</c> rows use <c>display:grid</c>/<c>display:flex</c>, neither of which exists in
+/// HTML-Renderer - <c>MonolithicContent.RunsAnEngineOfItsOwn</c>'s own doc comment confirms this port's
+/// <c>PaginatesItsOwnContent</c> narrows to table/inline-table only, matching the general flex/grid
+/// exclusion already established for this porting effort.</item>
+/// </list>
+/// </remarks>
+[TestClass]
+[DoNotParallelize]
+public sealed class StraddlingLineClaimTests
+{
+    private static HtmlContainerInt GetInternal(HtmlContainer wrapper)
+    {
+        var prop = typeof(HtmlContainer).GetProperty("HtmlContainerInt", BindingFlags.NonPublic | BindingFlags.Instance)!;
+        return (HtmlContainerInt)prop.GetValue(wrapper)!;
+    }
+
+    private static async Task<(CssBox Root, HtmlContainerInt Container)> BuildAsync(
+        string bodyHtml, double pageHeight = 842, double pageWidth = 600, int marginTop = 10)
+    {
+        var wrapper = new HtmlContainer();
+        await wrapper.SetHtml($"<html><body style='margin:0'>{bodyHtml}</body></html>");
+
+        var container = GetInternal(wrapper);
+        container.PageSize = new RSize(pageWidth, pageHeight);
+        container.MarginTop = marginTop;
+        container.Location = new RPoint(0, marginTop);
+        wrapper.MaxSize = new SizeF((float)pageWidth, 0);
+
+        using var bitmap = new Bitmap((int)pageWidth, 60000);
+        using var g = Graphics.FromImage(bitmap);
+        wrapper.PerformLayout(g);
+
+        return (container.Root!, container);
+    }
+
+    private static IEnumerable<CssBox> Walk(CssBox box)
+    {
+        yield return box;
+        foreach (var b in box.Boxes)
+            foreach (var d in Walk(b))
+                yield return d;
+    }
+
+    private static IEnumerable<BoxFragment> Flatten(BoxFragment fragment)
+    {
+        yield return fragment;
+        foreach (var child in fragment.Children)
+            foreach (var d in Flatten(child))
+                yield return d;
+    }
+
+    private static List<int> SlotsClaiming(HtmlContainerInt container, CssRect word) =>
+        container.FragmentTree!.Fragmentainers
+            .Where(f => Flatten(f.Root).SelectMany(b => b.Words).Any(w => ReferenceEquals(w.Word, word)))
+            .Select(f => f.SlotIndex)
+            .ToList();
+
+    /// <summary>
+    /// A word taller than the whole band - the one production mechanism left that leaves a word straddling
+    /// by more than a hairline: content with nowhere to fit must not be treated as breakable (moving it only
+    /// repeats the problem forever), so layout leaves it exactly where it naturally lands, covering more than
+    /// one band by construction. The word's own rectangle straddles here because its height comes from the
+    /// font rather than from <c>line-height</c> - hence an enormous <c>font-size</c> rather than an enormous
+    /// leading, which would grow the line box while leaving the word itself small enough to fit.
+    /// </summary>
+    [TestMethod]
+    public async Task AWordTallerThanTheBand_IsClaimedByEveryBandItCovers()
+    {
+        var (root, container) = await BuildAsync("<p style='font-size:1800px;line-height:1;margin:0'>T</p>");
+
+        var word = Walk(root).SelectMany(b => b.Words).Single(w => w.Text == "T");
+        var band = container.PageIndexOf(word.Top);
+
+        Assert.IsTrue(word.Height > container.PageBottomOf(band) - container.PageTopOf(band),
+            $"the fixture must produce a word taller than the band, not {word.Height}");
+
+        // Every band the word covers, from the grid's own materialized fragmentainers - "claimed by band +
+        // 1" alone would still pass if a taller word silently lost the bands below its second.
+        var covered = container.FragmentTree!.Fragmentainers
+            .Select(f => f.SlotIndex)
+            .Where(slot => word.Bottom > container.PageTopOf(slot) && word.Top < container.PageBottomOf(slot))
+            .ToList();
+
+        Assert.IsTrue(covered.Count > 2, $"the fixture must span more than two bands, not {covered.Count}");
+        CollectionAssert.AreEqual(covered, SlotsClaiming(container, word));
+    }
+}