pdfhell 0.1.0__py3-none-any.whl

pdfhell/generators/_common.py

@@ -0,0 +1,183 @@
+"""Shared utilities for trap-family generators.
+
+Each helper here is a small, well-typed primitive that the per-trap
+generators compose. The aim is that adding a new trap family means
+writing one new file under ``pdfhell/generators/`` and registering it in
+``__init__.py`` — without copy-pasting reportlab boilerplate.
+"""
+from __future__ import annotations
+
+import io
+import random
+from dataclasses import dataclass
+from typing import Iterable, Sequence
+
+from reportlab.lib.pagesizes import LETTER
+from reportlab.lib.styles import getSampleStyleSheet
+from reportlab.pdfgen import canvas
+
+
+# Letter portrait. We keep the page size constant across traps so visual
+# scoring across the suite is comparable.
+PAGE_WIDTH, PAGE_HEIGHT = LETTER
+
+
+@dataclass(slots=True)
+class FontSpec:
+    """Font selection + size."""
+
+    family: str = "Helvetica"
+    size: float = 11.0
+    bold: bool = False
+
+    @property
+    def name(self) -> str:
+        return f"{self.family}-Bold" if self.bold else self.family
+
+
+# A reproducible RNG that's seeded per-case. Generators must use this
+# (not the global ``random``) so byte-identical PDFs come out of byte-
+# identical seeds even when many generators run in the same process.
+def rng_for(seed: int) -> random.Random:
+    return random.Random(seed)
+
+
+def draw_paragraph(
+    c: "canvas.Canvas",
+    text: str,
+    x: float,
+    y: float,
+    *,
+    width: float = PAGE_WIDTH - 144,
+    font: FontSpec = FontSpec(),
+    leading: float | None = None,
+) -> float:
+    """Draw wrapped text with simple word-wrap. Returns the next free y.
+
+    We hand-roll wrapping rather than using Platypus flowables because
+    every trap family wants pixel-precise control over where text lands
+    (especially for tiny footnotes and split-table headers). Platypus
+    would fight us. canvas.drawString gives us the control.
+    """
+    leading = leading or (font.size * 1.25)
+    c.setFont(font.name, font.size)
+    words = text.split()
+    current: list[str] = []
+
+    def line_width(parts: list[str]) -> float:
+        return c.stringWidth(" ".join(parts), font.name, font.size)
+
+    cursor_y = y
+    for word in words:
+        current.append(word)
+        if line_width(current) > width:
+            current.pop()
+            c.drawString(x, cursor_y, " ".join(current))
+            cursor_y -= leading
+            current = [word]
+    if current:
+        c.drawString(x, cursor_y, " ".join(current))
+        cursor_y -= leading
+    return cursor_y
+
+
+def draw_invisible_text(c: "canvas.Canvas", text: str, x: float, y: float, *, size: float = 11.0) -> None:
+    """Place a string in the PDF text stream that is invisible to the eye.
+
+    This is the core trick behind :mod:`hidden_ocr_mismatch`. PDFs can
+    contain text rendered as invisible (render mode 3 — neither stroke
+    nor fill). A human reader sees nothing. An OCR/text-extraction
+    pipeline that reads the underlying text stream sees the invisible
+    string. A vision-only model reads the page's pixels. A
+    text-extraction pipeline reads the invisible layer. The two answers
+    diverge.
+
+    This is exactly how scanned-then-re-OCR'd PDFs go wrong in the wild
+    — the OCR layer can drift from the rendered page. Procedurally
+    constructing this means we *know* both answers and can score either
+    correctly.
+    """
+    text_obj = c.beginText(x, y)
+    text_obj.setFont("Helvetica", size)
+    # Render mode 3 = neither stroke nor fill, so the glyphs are placed
+    # in the text content stream but never rasterised. Visible text is
+    # mode 0.
+    text_obj.setTextRenderMode(3)
+    text_obj.textOut(text)
+    c.drawText(text_obj)
+
+
+def draw_table(
+    c: "canvas.Canvas",
+    rows: Sequence[Sequence[str]],
+    x: float,
+    y: float,
+    *,
+    col_widths: Sequence[float] | None = None,
+    row_height: float = 24,
+    font: FontSpec = FontSpec(size=10),
+    header_bold: bool = True,
+) -> float:
+    """Draw a borderless monospaced table. Returns the next free y.
+
+    Each generator that needs tables uses this to avoid reportlab's
+    Platypus tables (which paginate awkwardly when we explicitly *want*
+    to split a row across a page boundary).
+    """
+    if not rows:
+        return y
+    if col_widths is None:
+        col_count = max(len(r) for r in rows)
+        col_widths = [(PAGE_WIDTH - 144) / col_count] * col_count
+    for i, row in enumerate(rows):
+        cur_x = x
+        is_header = i == 0
+        c.setFont(
+            "Helvetica-Bold" if (is_header and header_bold) else font.name,
+            font.size,
+        )
+        for cell, w in zip(row, col_widths):
+            c.drawString(cur_x, y, cell)
+            cur_x += w
+        y -= row_height
+    return y
+
+
+def page_break(c: "canvas.Canvas") -> None:
+    c.showPage()
+
+
+def canvas_to_bytes(make: "Callable[[canvas.Canvas], None]") -> bytes:  # noqa: F821
+    """Run a draw routine against a fresh canvas and return the bytes.
+
+    Centralised so every generator does ``return canvas_to_bytes(draw)``
+    rather than duplicating BytesIO + canvas wiring.
+
+    ``invariant=True`` is non-negotiable: it tells reportlab to zero out
+    the creation timestamp and use a deterministic document ID, so the
+    same generator + seed always produces byte-identical PDFs. Without
+    this, the strategy memo's reproducibility claim is a lie and the
+    published leaderboard can't be re-derived.
+    """
+    buf = io.BytesIO()
+    c = canvas.Canvas(buf, pagesize=LETTER, invariant=True)
+    make(c)
+    c.save()
+    return buf.getvalue()
+
+
+def fmt_money(amount: int | float, currency: str = "$") -> str:
+    """Render money in a stable format. Generators set the *expected
+    answer* using this exact function so the answer string and the
+    rendered PDF text agree to the byte."""
+    return f"{currency}{amount:,.2f}"
+
+
+def pick_from(rng: random.Random, choices: Iterable):
+    """Convenience for picking one element from an iterable using rng.
+
+    ``random.Random.choice`` requires a sequence; this lets generators
+    pass generators/sets without converting upfront.
+    """
+    items = list(choices)
+    return rng.choice(items)

pdfhell/generators/footnote_override.py

@@ -0,0 +1,212 @@
+"""Trap family: footnote override.
+
+The body of the document states a contractual position confidently — for
+example, *"Customer's liability shall be capped at twelve (12) months of
+fees paid."* — but a 6pt footnote near the bottom of the page overrides
+it: *"Notwithstanding the foregoing, liability for breaches of Sections
+4.2 (Confidentiality) and 7.1 (Data Protection) shall be uncapped."*
+
+A model that summarises the document by reading only the body will state
+the cap is 12 months. The correct answer is "12 months, except for
+breaches of Sections 4.2 and 7.1, which are uncapped." Missing the
+footnote is the single most common failure mode for legal/contract AI
+agents.
+
+We procedurally fabricate this so the *exact* set of carve-outs is in
+the answer key.
+"""
+from __future__ import annotations
+
+import random
+
+from reportlab.pdfgen import canvas
+
+from ..case import HellCase
+from . import _common as C
+
+
+_CONTRACT_TYPES = [
+    "Master Services Agreement",
+    "Software License Agreement",
+    "Data Processing Addendum",
+    "Subscription Order Form",
+    "Statement of Work #4",
+]
+
+_BODY_POSITIONS = [
+    # (label, body_text_template, footnote_template, expected_answer_template)
+    (
+        "liability_cap",
+        "The aggregate liability of either party for any claims arising out of or relating to "
+        "this Agreement shall not exceed an amount equal to {months} months of fees paid by Customer "
+        "during the twelve (12) month period immediately preceding the event giving rise to such liability.",
+        "Notwithstanding Section {section_num}, liability arising from "
+        "Sections {carveout_sections} shall be uncapped.",
+        "Liability is capped at {months} months of fees paid, EXCEPT that liability arising from "
+        "Sections {carveout_sections} is uncapped.",
+        "Liability is capped at {months} months of fees paid.",  # the wrong/forbidden answer
+    ),
+    (
+        "termination_notice",
+        "Either party may terminate this Agreement for convenience upon "
+        "{notice_days} days written notice to the other party.",
+        "However, termination for convenience is not permitted during the "
+        "initial twelve (12) month term.",
+        "Either party may terminate for convenience on {notice_days} days notice, "
+        "BUT NOT during the initial 12-month term.",
+        "Either party may terminate for convenience on {notice_days} days notice.",
+    ),
+    (
+        "data_residency",
+        "Customer Data shall be stored and processed in the {primary_region} region.",
+        "Provided that, with Customer's written consent, Customer Data may also "
+        "be processed in {fallback_region} for purposes of disaster recovery.",
+        "Customer Data is stored in {primary_region}, with disaster-recovery "
+        "processing permitted in {fallback_region} ONLY with written consent.",
+        "Customer Data is stored in {primary_region}.",
+    ),
+]
+
+
+def _random_sections(rng: random.Random) -> tuple[str, str]:
+    """Return ``(section_num, carveout_sections)`` for the carve-out clause."""
+    sec = f"{rng.randint(8, 14)}.{rng.randint(1, 5)}"
+    carve = ", ".join(
+        sorted(
+            {
+                f"{rng.randint(2, 7)}.{rng.randint(1, 4)}"
+                for _ in range(rng.randint(2, 3))
+            }
+        )
+    )
+    return sec, carve
+
+
+def generate(seed: int) -> tuple[bytes, HellCase]:
+    rng = C.rng_for(seed)
+    contract = rng.choice(_CONTRACT_TYPES)
+    label, body_tpl, footnote_tpl, expected_tpl, wrong_tpl = rng.choice(_BODY_POSITIONS)
+
+    # Bind the per-template parameters.
+    # expected_tokens are the substrings any acceptable prose answer must
+    # contain — facts, not phrasing. The scorer requires ALL tokens.
+    if label == "liability_cap":
+        months = rng.choice([3, 6, 12, 24])
+        section_num, carveout_sections = _random_sections(rng)
+        ctx = {"months": months, "section_num": section_num, "carveout_sections": carveout_sections}
+        question = (
+            f"Read the attached {contract}. What is the LIABILITY CAP "
+            "and what carve-outs (if any) apply? Be precise about which Sections are uncapped."
+        )
+        # Acceptable: any prose that includes (1) the cap value, (2) the
+        # carve-out section refs, (3) the word "uncapped" or equivalent.
+        expected_tokens = [
+            f"{months} month",
+            "uncapped",
+            *carveout_sections.split(", "),
+        ]
+    elif label == "termination_notice":
+        notice_days = rng.choice([30, 60, 90])
+        ctx = {"notice_days": notice_days}
+        question = (
+            f"Read the attached {contract}. Under what conditions can either party "
+            "terminate this Agreement for convenience? Be specific about any restrictions."
+        )
+        expected_tokens = [
+            f"{notice_days} day",
+            "12 month",  # the initial-term restriction
+        ]
+    else:  # data_residency
+        primary_region = rng.choice(["us-east-1", "eu-west-1", "ap-southeast-2"])
+        fallback_region = rng.choice(["us-west-2", "eu-central-1", "ap-northeast-1"])
+        while fallback_region == primary_region:
+            fallback_region = rng.choice(["us-west-2", "eu-central-1", "ap-northeast-1"])
+        ctx = {"primary_region": primary_region, "fallback_region": fallback_region}
+        question = (
+            f"Read the attached {contract}. Where is Customer Data stored, "
+            "and under what conditions (if any) may it be processed elsewhere?"
+        )
+        expected_tokens = [
+            primary_region,
+            fallback_region,
+            "consent",
+        ]
+
+    body_text = body_tpl.format(**ctx)
+    footnote_text = footnote_tpl.format(**ctx)
+    expected_answer = expected_tpl.format(**ctx)
+    wrong_answer = wrong_tpl.format(**ctx)
+
+    section_index = rng.randint(8, 14)
+    section_label = f"{section_index}.{rng.randint(1, 5)}"
+
+    case_id = f"footnote_override-{seed:04d}"
+
+    def draw(c: canvas.Canvas) -> None:
+        # Heading
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(72, 720, contract.upper())
+        c.setFont("Helvetica-Oblique", 10)
+        c.drawString(72, 700, f"Effective Date: 2026-{rng.randint(1, 12):02d}-{rng.randint(1, 28):02d}")
+
+        # Intro paragraph (filler so the doc looks normal)
+        intro = (
+            "This Agreement is entered into between the Customer and Vendor (each a "
+            '"Party" and collectively the "Parties") and governs the Parties\' '
+            "respective rights and obligations with respect to the Services described in the Order Form. "
+            "Capitalised terms used but not defined herein have the meanings given in the Order Form."
+        )
+        y = C.draw_paragraph(c, intro, 72, 670, font=C.FontSpec(size=10))
+
+        # The clause of interest (body)
+        c.setFont("Helvetica-Bold", 11)
+        c.drawString(72, y - 10, f"{section_label}  Limitation.")
+        y = C.draw_paragraph(
+            c,
+            body_text + f"¹",  # superscript 1 — the footnote marker
+            72, y - 30,
+            font=C.FontSpec(size=11),
+        )
+
+        # More filler so the footnote isn't suspiciously isolated
+        filler = (
+            "Each Party shall comply with all applicable laws and regulations in connection with "
+            "its performance under this Agreement and shall promptly notify the other Party of any "
+            "material non-compliance of which it becomes aware. The provisions of this Section shall "
+            "survive termination of this Agreement."
+        )
+        y = C.draw_paragraph(c, filler, 72, y - 10, font=C.FontSpec(size=10))
+
+        # The footnote (6pt — the trap)
+        # We deliberately place it near the bottom of page 1 to mimic
+        # real legal-doc layout where footnotes get visually compressed.
+        c.setFont("Helvetica", 6)
+        c.drawString(72, 100, f"¹ {footnote_text}")
+
+        # Page number
+        c.setFont("Helvetica", 9)
+        c.drawCentredString(C.PAGE_WIDTH / 2, 60, "Page 1 of 1")
+
+    pdf_bytes = C.canvas_to_bytes(draw)
+
+    case = HellCase(
+        id=case_id,
+        trap_family="footnote_override",
+        seed=seed,
+        question=question,
+        expected_answer=expected_answer,
+        expected_tokens=expected_tokens,
+        forbidden_answers=[wrong_answer],
+        metadata={
+            "contract_type": contract,
+            "clause_label": label,
+            "section_label": section_label,
+            "params": ctx,
+            "footnote_text": footnote_text,
+            "expected_failure_mode": (
+                "Model reads the body clause and ignores the 6pt footnote, missing the "
+                "material carve-out / exception."
+            ),
+        },
+    )
+    return pdf_bytes, case

pdfhell/generators/hidden_ocr_mismatch.py

@@ -0,0 +1,129 @@
+"""Trap family: hidden OCR mismatch.
+
+The PDF *looks* like an invoice with an amount of ``$X``. But beneath
+that visible glyph is an invisible text layer that says ``$Y`` instead
+(rendered with PDF text render mode 3 — placed in the text content
+stream but never rasterised).
+
+A vision-only model reads the rendered pixels and answers ``$X``. A
+text-extraction pipeline (pdfminer, PyMuPDF, pdfplumber, most RAG
+loaders) reads the invisible layer and answers ``$Y``. An agent that
+combines both — without resolving the conflict — answers whichever the
+final stage trusted.
+
+This is the most common silent failure mode for "PDF understanding" in
+production: a scanned-then-OCR'd document where the OCR layer disagrees
+with the rendered page. We procedurally fabricate it so we know exactly
+which answer is correct (the visible one) and which answer is the
+specific failure mode the trap was designed to catch (the hidden one).
+"""
+from __future__ import annotations
+
+import random
+
+from reportlab.pdfgen import canvas
+
+from ..case import HellCase
+from . import _common as C
+
+
+# Visible amounts are sampled from a realistic invoice distribution.
+# The hidden amount is *not* a small perturbation — it's a meaningfully
+# different value, because if the agent's downstream user processes it,
+# the dollar gap should be visible.
+_VENDORS = [
+    "Acme Industrial Supplies LLC",
+    "Northwind Logistics Inc.",
+    "Globex Manufacturing Co.",
+    "Initech Software Solutions",
+    "Hooli Cloud Services, Inc.",
+    "Soylent Foods Corp.",
+    "Wayne Enterprises LP",
+    "Stark Industries Inc.",
+    "Tyrell Robotics Group",
+    "Cyberdyne Systems Inc.",
+]
+
+
+def generate(seed: int) -> tuple[bytes, HellCase]:
+    rng = C.rng_for(seed)
+
+    # Two distinct amounts; the visible one is the ground truth.
+    visible_amount = rng.choice([1234.56, 2750.00, 4980.40, 7820.99, 12345.67, 18900.25])
+    hidden_amount = visible_amount + rng.choice([1000, 2000, 5000, 10000])
+    vendor = rng.choice(_VENDORS)
+    invoice_no = f"INV-{rng.randint(100000, 999999)}"
+    due_day = rng.randint(1, 28)
+
+    visible_str = C.fmt_money(visible_amount)
+    hidden_str = C.fmt_money(hidden_amount)
+
+    case_id = f"hidden_ocr_mismatch-{seed:04d}"
+    question = (
+        f"You are an accounts-payable assistant. The attached PDF is invoice "
+        f"{invoice_no} from {vendor}. What is the TOTAL AMOUNT DUE? "
+        "Respond with only the amount including currency symbol, no other text."
+    )
+
+    def draw(c: canvas.Canvas) -> None:
+        # Header
+        c.setFont("Helvetica-Bold", 18)
+        c.drawString(72, 720, "INVOICE")
+        c.setFont("Helvetica", 11)
+        c.drawString(72, 700, vendor)
+        c.drawString(72, 685, f"Invoice #: {invoice_no}")
+        c.drawString(72, 670, f"Due: 2026-08-{due_day:02d}")
+
+        # Line items (3-4 plausible rows so the doc doesn't look skeletal)
+        C.draw_paragraph(
+            c,
+            "ITEM                                                   QTY    UNIT      LINE TOTAL",
+            72, 620,
+            font=C.FontSpec(size=10, bold=True),
+        )
+        items = [
+            ("Configuration consulting          ", 4, 250.00, 1000.00),
+            ("On-site implementation            ", 1, 1200.00, 1200.00),
+            ("Annual support (Tier 2)           ", 1, visible_amount - 2200, visible_amount - 2200),
+        ]
+        y = 600
+        for desc, qty, unit, total in items:
+            c.drawString(72, y, f"{desc} {qty:>4}   {C.fmt_money(unit):>10}    {C.fmt_money(total):>12}")
+            y -= 16
+
+        # The "TOTAL DUE" line is what we're asking the model about.
+        c.setFont("Helvetica-Bold", 13)
+        c.drawString(72, y - 30, "TOTAL DUE:")
+        c.drawString(220, y - 30, visible_str)
+
+        # The trap: place the *wrong* amount in an invisible text layer.
+        # It lands at the same coordinate as the visible total, so a
+        # text-extraction pipeline that reads the underlying text stream
+        # by position would see the hidden value, not the visible one.
+        C.draw_invisible_text(c, hidden_str, x=220, y=y - 30, size=13)
+
+        # Footer
+        c.setFont("Helvetica-Oblique", 9)
+        c.drawString(72, 90, "Thank you for your business. Net 30 from invoice date.")
+
+    pdf_bytes = C.canvas_to_bytes(draw)
+
+    case = HellCase(
+        id=case_id,
+        trap_family="hidden_ocr_mismatch",
+        seed=seed,
+        question=question,
+        expected_answer=visible_str,
+        forbidden_answers=[hidden_str],
+        metadata={
+            "vendor": vendor,
+            "invoice_no": invoice_no,
+            "visible_amount": visible_amount,
+            "hidden_amount": hidden_amount,
+            "expected_failure_mode": (
+                "Model answers the hidden-OCR amount when it should answer the visible amount; "
+                "indicates the model trusted a text-extraction layer over the rendered page."
+            ),
+        },
+    )
+    return pdf_bytes, case

pdfhell/generators/split_table_across_pages.py

@@ -0,0 +1,174 @@
+"""Trap family: split table across pages.
+
+A 6-column financial / inventory / pricing table is drawn so that the
+column *header* row appears at the bottom of page 1 and the *body* rows
+appear at the top of page 2. The visual continuity is obvious to a
+human flipping pages but breaks every document-pipeline that processes
+pages independently (most RAG loaders, most OCR pipelines).
+
+The trap question asks the model about a specific cell — e.g. "What is
+the Q3 Net Revenue for the Northwest region?". A model that loses the
+header context on page 2 will either confuse columns (returning Gross
+Revenue or Operating Income instead) or refuse to answer. Procedural
+ground truth means we know exactly which column the answer is in.
+"""
+from __future__ import annotations
+
+import random
+
+from reportlab.pdfgen import canvas
+
+from ..case import HellCase
+from . import _common as C
+
+
+_REGIONS = ["Northwest", "Northeast", "Southwest", "Southeast", "Central"]
+_QUARTERS = ["Q1", "Q2", "Q3", "Q4"]
+_COLUMNS = [
+    ("Region", "region"),
+    ("Quarter", "quarter"),
+    ("Gross Revenue", "gross"),
+    ("Cost of Goods", "cogs"),
+    ("Operating Income", "op_income"),
+    ("Net Revenue", "net"),
+]
+
+
+def _generate_row(rng: random.Random) -> dict:
+    region = rng.choice(_REGIONS)
+    quarter = rng.choice(_QUARTERS)
+    gross = round(rng.uniform(800_000, 5_000_000), 2)
+    cogs = round(gross * rng.uniform(0.35, 0.55), 2)
+    op_income = round(gross * rng.uniform(0.15, 0.30), 2)
+    net = round(op_income - rng.uniform(20_000, 80_000), 2)
+    return {
+        "region": region,
+        "quarter": quarter,
+        "gross": gross,
+        "cogs": cogs,
+        "op_income": op_income,
+        "net": net,
+    }
+
+
+def generate(seed: int) -> tuple[bytes, HellCase]:
+    rng = C.rng_for(seed)
+
+    # Build 8 unique (region, quarter) rows.
+    seen: set[tuple[str, str]] = set()
+    rows: list[dict] = []
+    while len(rows) < 8:
+        row = _generate_row(rng)
+        key = (row["region"], row["quarter"])
+        if key in seen:
+            continue
+        seen.add(key)
+        rows.append(row)
+
+    # The case asks about ONE specific row and ONE specific column.
+    target_row = rng.choice(rows)
+    target_column_label, target_column_key = rng.choice(_COLUMNS[2:])  # skip region/quarter
+    expected_value = target_row[target_column_key]
+    expected_str = C.fmt_money(expected_value)
+
+    # The most plausible *wrong* answer is the value from an adjacent
+    # column in the same row (the "column-confusion" failure mode that
+    # page-split tables specifically elicit).
+    other_money_cols = [k for _, k in _COLUMNS[2:] if k != target_column_key]
+    wrong_col = rng.choice(other_money_cols)
+    wrong_str = C.fmt_money(target_row[wrong_col])
+
+    case_id = f"split_table_across_pages-{seed:04d}"
+    question = (
+        f"The attached PDF contains a financial-results table. "
+        f"What was the {target_column_label} for the {target_row['region']} region in "
+        f"{target_row['quarter']} of 2026? Respond with only the dollar amount, no other text."
+    )
+
+    def draw(c: canvas.Canvas) -> None:
+        # Page 1 — intro + header row at the bottom (the trap)
+        c.setFont("Helvetica-Bold", 16)
+        c.drawString(72, 720, "FY2026 REGIONAL FINANCIAL SUMMARY")
+        c.setFont("Helvetica", 10)
+        C.draw_paragraph(
+            c,
+            "The following table summarises gross and net revenue, cost of goods sold, and operating "
+            "income by region and quarter for fiscal year 2026. All amounts are reported in USD "
+            "and exclude inter-regional transfers. See Appendix B for the methodology used to allocate "
+            "shared infrastructure costs across regions.",
+            72, 690,
+            font=C.FontSpec(size=10),
+        )
+
+        # Drop some filler so the header naturally ends up near the bottom
+        C.draw_paragraph(
+            c,
+            "Note that Q3 results reflect the regional reorganisation announced in our Q2 earnings "
+            "call. Comparisons to prior years should account for the boundary shift between the "
+            "Northwest and Central regions effective 2026-07-01.",
+            72, 620,
+            font=C.FontSpec(size=10),
+        )
+
+        # Header row at the bottom of page 1
+        col_widths = [80, 60, 100, 100, 100, 100]
+        x_start = 72
+        header_y = 130
+        c.setFont("Helvetica-Bold", 10)
+        cx = x_start
+        for (label, _), w in zip(_COLUMNS, col_widths):
+            c.drawString(cx, header_y, label)
+            cx += w
+
+        # Page footer
+        c.setFont("Helvetica", 9)
+        c.drawCentredString(C.PAGE_WIDTH / 2, 60, "Page 1 of 2")
+
+        # Page break — body rows go on page 2 with no repeated header
+        C.page_break(c)
+
+        # Page 2 — the body rows, headerless
+        y = 720
+        c.setFont("Helvetica", 10)
+        for row in rows:
+            cx = x_start
+            cells = [
+                row["region"],
+                row["quarter"],
+                C.fmt_money(row["gross"]),
+                C.fmt_money(row["cogs"]),
+                C.fmt_money(row["op_income"]),
+                C.fmt_money(row["net"]),
+            ]
+            for cell, w in zip(cells, col_widths):
+                c.drawString(cx, y, cell)
+                cx += w
+            y -= 22
+
+        # Page footer
+        c.setFont("Helvetica", 9)
+        c.drawCentredString(C.PAGE_WIDTH / 2, 60, "Page 2 of 2")
+
+    pdf_bytes = C.canvas_to_bytes(draw)
+
+    case = HellCase(
+        id=case_id,
+        trap_family="split_table_across_pages",
+        seed=seed,
+        question=question,
+        expected_answer=expected_str,
+        forbidden_answers=[wrong_str],
+        metadata={
+            "target_region": target_row["region"],
+            "target_quarter": target_row["quarter"],
+            "target_column": target_column_label,
+            "target_column_key": target_column_key,
+            "expected_value": expected_value,
+            "row_count": len(rows),
+            "expected_failure_mode": (
+                "Model loses column-header context when reading page 2 in isolation; "
+                "returns a value from an adjacent column in the same row."
+            ),
+        },
+    )
+    return pdf_bytes, case