Update app.py

app.py

@@ -594,15 +594,12 @@ def _extract_fused_header_artifacts(header_row):
     """
     Generic detector for the OCR artifact where the first data row of a table
     gets fused into the header cells during OCR.
-
     The artifact pattern (BOTH signals must fire simultaneously):
       - Signal 1 — text-fused: a header cell contains KEYWORD + free descriptive text
         e.g.  "DESCRIPTIONBeginning Balance"  "NARRATIONOpening Balance"
       - Signal 2 — money-fused: a DIFFERENT header cell contains KEYWORD + money amount
         e.g.  "BALANCE$3,447.10"  "AMOUNT 5,000.00"
-
     Two-signal guard prevents false positives on clean PDFs from any bank.
-
     Returns:
         (cleaned_header : list[str], recovered_row : list[str] | None)
     """
@@ -707,15 +704,12 @@ def _promote_misplaced_header_row(grid):
     """
     Detects and fixes the OCR artifact where real column headers land in a
     <td> data row instead of the <th> header row.
-
     Two scenarios handled:
-
     Scenario A — Simple misplaced header (e.g. TD Bank):
       <th>ACCOUNT ACTIVITY</th>        ← section title, not a real header
       <td>DATE DESCRIPTION</td> ...    ← real column headers in a data row
       <td>01/05 ...</td>               ← data
     → Promote the keyword row to header, discard the section title rows above.
-
     Scenario B — Metadata header + misplaced column headers (e.g. Citi page 1):
       <th>208479667</th> <th>Beginning Balance:$20.48 Ending Balance:$3.46</th>
       <td>Date Description</td> <td>Debits</td> <td>Credits</td> <td>Balance</td>
@@ -725,7 +719,6 @@ def _promote_misplaced_header_row(grid):
     → Preserve metadata row cells as a plain-text prefix OUTSIDE the table
       by embedding them as a leading data row with colspan (kept for reference).
     → Split any "Date Description" fused cells in data rows.
-
     Guard conditions (no-op if not met — safe for all other PDFs):
       - Current header keyword score < threshold.
       - A data row within the first 5 rows has keyword score >= threshold.
@@ -821,10 +814,8 @@ def _fix_fused_keyvalue_rows(grid):
     Fix rows where label+value are fused into the first cell with all other
     cells empty — common in Interest Summary / Fee Summary sections appended
     to a transaction table by OCR.
-
     e.g. "Beginning Interest Rate0.00%"  → label="Beginning Interest Rate"  value="0.00%"
          "Number of days in this Period31" → label="..."  value="31"
-
     Guard conditions (no-op if not met — safe for all other tables):
       - All cells except first must be empty.
       - A non-space character must immediately precede the digit run (fused).
@@ -912,11 +903,9 @@ def _fix_fused_keyvalue_rows(grid):
 def _extract_textlayer_rows(pdf_path: str, page_num: int):
     """
     Extract structured transaction rows from the PDF text layer using pymupdf.
-
     Returns list of {"date": str, "desc": str, "amount": str} dicts, or []
     if the PDF has no text layer, pymupdf is unavailable, or fewer than 2
     transaction rows are found (guards against non-transaction pages).
-
     Supports multiple date formats:
       - Numeric:    MM/DD, MM/DD/YY, MM/DD/YYYY  (Chase, TD, BoA, Citi)
       - Month-name: Jan 16, Feb 7, Mar 05         (Capital One, Amex)
@@ -1047,7 +1036,6 @@ def _extract_textlayer_rows(pdf_path: str, page_num: int):
         log.debug("_extract_textlayer_rows failed (page %d): %s", page_num, e)
         return []
 
-
 def _jb_extract_checks_fallback(text_layer: str) -> List[Tuple[str, str, str]]:
     """
     Johnson Bank: when pdfminer column extraction fails (e.g. pymupdf line text or
@@ -1081,18 +1069,15 @@ def _jb_extract_checks_fallback(text_layer: str) -> List[Tuple[str, str, str]]:
             out.append(t)
     return out
 
-
 def _extract_jb_summary_sections(text_layer: str, needs_checks: bool = True, needs_dab: bool = True) -> str:
     """
     Parse Johnson Bank Checks and Daily Account Balance from pdfminer column-separated
     page text and return as HTML tables.
-
     pdfminer outputs multi-column sections as separate column lists:
         Date      Number    Amount
         04-14     3259      45.72
     becomes:
         "Date\n04-14\n04-09\n\nNumber\n3259\n3260\n\nAmount\n45.72\n1,628.00"
-
     Uses pdfminer (always available) not pymupdf.
     """
     if not text_layer:
@@ -1211,7 +1196,6 @@ def _patch_ocr_with_textlayer(page_md: str, pdf_path: str, page_num: int) -> str
     """
     Compare OCR table rows against PDF text-layer rows and inject any rows
     the OCR model silently dropped (typically identical consecutive rows).
-
     Guard conditions (all must pass for any injection):
       1. PDF text layer must exist and yield >= 2 transaction rows.
       2. The OCR table must have DATE + DESCRIPTION + AMOUNT columns.
@@ -1456,16 +1440,13 @@ def _reconstruct_separator_rows(grid):
     """
     Detect and reconstruct mid-table separator / label rows that OCR has
     incorrectly split across columns.
-
     The artifact (Bank of America and similar):
       A section label like "Card account # XXXX XXXX XXXX 2889" sits between
       transaction rows as a full-width label. OCR splits the trailing digits
       across columns because they are right-aligned, producing variations like:
-
         2-cell split:  ["Card account # XXXX XXXX XXXX 2", "",    "889"]
         3-cell split:  ["Card account # XXXX XXXX XXXX",   "2",   "889"]
         clean 1-cell:  ["Card account # XXXX XXXX XXXX 2889", "", ""]
-
     Detection criteria (ALL must hold — guards safe for all other PDFs):
       1. First cell is NOT a date token (transaction rows always start with date).
       2. First cell contains letters (it is a label, not a bare number).
@@ -1475,7 +1456,6 @@ def _reconstruct_separator_rows(grid):
               — these are the split-off tails of the account/card number.
       4. There must be at least one non-empty cell after the first (to detect
          the split; single-cell rows are also handled as clean label rows).
-
     The fix:
       Concatenate all non-empty cells in order, place the result in col 0,
       blank all other cells.
@@ -1551,19 +1531,15 @@ def _merge_split_rows(grid):
     """
     Fix OCR artifact where a transaction row is split across two <tr> rows
     because the description wrapped to a second line in the source PDF.
-
     Two patterns detected (Hardin County Bank and similar monospace statements):
-
     Pattern A — description + empty continuation:
       Row N:   [desc, '', '', '', '']          ← description, no date/money
       Row N+1: ['', debit, credit, date, bal]  ← money/date, no description
       → Merge into: [desc, debit, credit, date, bal]
-
     Pattern B — description + text continuation + money:
       Row N:   [desc, '', '', '', '']               ← first line of description
       Row N+1: [desc_cont, debit, credit, date, bal] ← continuation + money
       → Merge into: [desc + ' ' + desc_cont, debit, credit, date, bal]
-
     Guard conditions (no-op unless both rows match the pattern):
       - Row N must have non-empty col 0 (description).
       - Row N must have empty date column (col 3 or wherever DATE is).
@@ -1655,11 +1631,9 @@ def _extract_fused_desc_amount(grid):
     """
     Fix OCR artifact where a trailing money amount gets fused into the
     description cell instead of its own debit/credit column.
-
     Example (Hardin County Bank):
       OCR: ['CHASE CREDIT CRD EPAY 8319249882 500.00', '', '', '04/11/25', '16,699.04']
       Fix: ['CHASE CREDIT CRD EPAY 8319249882', '500.00', '', '04/11/25', '16,699.04']
-
     Guard conditions (all must hold):
       - Description ends with a space + money amount (NNN.NN or N,NNN.NN).
       - ALL debit AND credit columns are empty for this row.
@@ -1718,7 +1692,6 @@ def _is_junk_table(grid):
     """
     Detect and suppress known junk tables that are OCR artifacts from
     page headers/footers, not real transaction data.
-
     Current patterns:
     1. CUSTOMER INFORMATION fragment tables (First Horizon Bank):
        Single-column table with header "CUSTOMER INFORMATION" and
@@ -1741,15 +1714,12 @@ def _is_junk_table(grid):
 def _split_fused_multicolumn_header(grid):
     """
     Fix OCR artifact where multiple column headers are fused into one <th> cell.
-
     Example (First Horizon Bank alternating pages):
       Fused:   ['DATE DESCRIPTION CARD #', 'DEPOSIT', 'WITHDRAWAL']
       Correct: ['DATE', 'DESCRIPTION', 'DEPOSIT', 'WITHDRAWAL', 'CARD #']
-
     The data rows also have date + description + card# all in col 0:
       Fused:   ['01/16 PURCHASE - UBER TRIP... 4919', '', '$21.02']
       Correct: ['01/16', 'PURCHASE - UBER TRIP...', '', '$21.02', '4919']
-
     Detection: first header cell contains 2+ keyword terms separated by spaces,
     AND remaining header cells are valid money column keywords.
     """
@@ -1862,7 +1832,6 @@ def _normalize_daily_balance_table(grid):
     - OCR produces N DATE columns followed by N BALANCE columns
       instead of interleaved DATE|BALANCE|DATE|BALANCE pairs
     - Multiple dates are stacked in one cell "01/02\n01/03\n01/04\n01/05"
-
     Reorders columns and expands stacked date cells into proper rows.
     Only fires when ALL of these hold:
     - Header has exactly 2N columns where N >= 2
@@ -1940,9 +1909,7 @@ def _normalize_checks_paid_table(grid):
     - Remaining headers = "AMOUNT AMOUNT AMOUNT"
     - Data col0 = "01/24 4701 01/18 4704 * 01/18 916831 *" (all groups fused)
     - Remaining data cells = amount values
-
     Expands to proper: DATE | CHECK # | AMOUNT | DATE | CHECK # | AMOUNT | ...
-
     Detection: first header cell matches pattern (DATE CHECK #)+ 
     and remaining headers are all AMOUNT.
     """
@@ -2191,157 +2158,224 @@ def convert_plaintext_bank_sections(text: str) -> str:
     return "\n".join(out)
 
 # --------------------------
-# Navy Federal Summary Table extraction (Fix NF-1)
+# Navy Federal full-page text-layer parser (Fix NF-1)
 # --------------------------
 
-def _extract_nfcu_summary_table(pdf_path: str, page_num: int) -> str:
+def _is_nfcu_document(pdf_path: str) -> bool:
     """
-    Extract Navy Federal "Summary of your deposit accounts" table from the PDF
-    text layer using word coordinates.
-
-    GLM-OCR fails on this table because the five data columns are spread very
-    wide across the page with no visible borders.
-
-    Uses word x/y coordinates to reconstruct the table spatially.
-    Tries pymupdf first (HuggingFace), falls back to pdfplumber (local).
-
-    Detection guards (safe no-op for all other banks):
-      1. Word "Summary" in top 55% of page.
-      2. Words "deposit" or "accounts" within 15pt of it.
-
-    Returns HTML table string, or "" if not found/applicable.
+    Strict detector for Navy Federal statements.
+    Used to gate NF-specific parsing so other banks are unaffected.
     """
     try:
-        from collections import defaultdict as _dd
+        import pymupdf as fitz
+        doc = fitz.open(pdf_path)
+        pages_to_check = min(2, len(doc))
+        text = ""
+        for i in range(pages_to_check):
+            text += "\n" + (doc[i].get_text() or "")
+        doc.close()
+        t = text.lower()
+        # Accept either explicit Navy branding OR the NFCU statement signature fields.
+        has_brand = ("navy federal" in t or "navyfederal.org" in t)
+        has_signature_fields = (
+            ("statement of account" in t)
+            and ("statement period" in t)
+            and ("access no." in t)
+            and ("routing number" in t)
+        )
+        return has_brand or has_signature_fields
+    except Exception:
+        return False
 
-        words = None  # list of (x0, top, text)
-        page_h = 1000
 
-        # Try pymupdf first (HuggingFace environment)
-        try:
-            import pymupdf as _fitz_s
-            _doc_s = _fitz_s.open(pdf_path)
-            if page_num >= len(_doc_s):
-                _doc_s.close()
-                return ""
-            _pg_s = _doc_s[page_num]
-            page_h = _pg_s.rect.height
-            words = [(w[0], w[1], w[4]) for w in _pg_s.get_text("words")]
-            _doc_s.close()
-        except Exception:
-            pass
+def _parse_nfcu_page(pdf_path: str, page_num: int) -> str:
+    """
+    Full text-layer parser for Navy Federal Credit Union statements.
+    GLM-OCR fails on NFCU pages because:
+      - The summary table has 5 wide columns with no visible borders
+      - Transaction tables have Amount($) and Balance($) spatially far right
+      - Multi-line descriptions (wrapped lines) confuse OCR table detection
+    This function reads the PDF text layer directly via pdfplumber and produces
+    correct, complete HTML for every section: summary table, transaction tables,
+    items paid, savings, disclosures.
+    Detection guards (all must pass — safe no-op for all other banks):
+      1. Page text must contain 'Access No.' AND 'Statement of Account'
+         (unique to Navy Federal statement format)
+      2. pdfplumber must return extractable text (not a scanned page)
+    Returns complete HTML string for the page, or "" if not NFCU / any error.
+    """
+    try:
+        import pymupdf as fitz
 
-        # Fallback: pdfplumber (local environment)
-        if not words:
-            try:
-                import pdfplumber as _plumber_s
-                with _plumber_s.open(pdf_path) as _pdf_s:
-                    if page_num >= len(_pdf_s.pages):
-                        return ""
-                    page_h = _pdf_s.pages[page_num].height
-                    words = [(w["x0"], w["top"], w["text"])
-                             for w in _pdf_s.pages[page_num].extract_words()]
-            except Exception:
-                pass
+        doc = fitz.open(pdf_path)
+        if page_num >= len(doc):
+            doc.close()
+            return ""
+        page = doc[page_num]
+        page_text = page.get_text() or ""
+        words = page.get_text("words") or []
+        doc.close()
 
-        if not words:
+        if not page_text or not words:
             return ""
 
-        # Guard 1: "Summary" word in top 55% of page
-        summary_word = next(
-            (w for w in words if w[2].lower() == "summary" and w[1] < page_h * 0.55),
-            None
+        t = page_text.lower()
+        is_nfcu = (
+            ("statement of account" in t)
+            and (("access no." in t) or ("routing number" in t) or ("navy federal" in t) or ("navyfederal.org" in t))
         )
-        if not summary_word:
+        if not is_nfcu:
             return ""
 
-        # Guard 2: "deposit" or "accounts" within 15pt
-        nearby = [w[2].lower() for w in words if abs(w[1] - summary_word[1]) < 15]
-        if "deposit" not in nearby and "accounts" not in nearby:
-            return ""
+        # Group words into reading lines by y-position.
+        buckets = []
+        for w in words:
+            if len(w) < 5:
+                continue
+            x0 = float(w[0])
+            y0 = float(w[1])
+            token = w[4].strip()
+            if not token:
+                continue
+            bi = None
+            for i, (yb, _) in enumerate(buckets):
+                if abs(yb - y0) <= 2.0:
+                    bi = i
+                    break
+            if bi is None:
+                buckets.append((y0, [(x0, token)]))
+            else:
+                buckets[bi][1].append((x0, token))
+
+        lines = []
+        for y, arr in sorted(buckets, key=lambda x: x[0]):
+            toks = [tok for _, tok in sorted(arr, key=lambda x: x[0])]
+            xs = [x for x, _ in sorted(arr, key=lambda x: x[0])]
+            lines.append((y, xs, toks, " ".join(toks)))
+
+        date_re = re.compile(r"^\d{2}-\d{2}$")
+        money_re = re.compile(r"^[\d,]+\.\d{2}-?$")
+        acct_re = re.compile(r"^(Business Checking|Mbr Business Savings)\s*-\s*(\d+)")
+        stop_markers = (
+            "Items Paid",
+            "Average Daily Balance",
+            "2024 Year to Date",
+            "Disclosure",
+            "What to Do",
+            "Errors",
+            "Payments",
+            "SAVINGS DIVIDENDS",
+        )
 
-        # Band: 15-115pt below the heading
-        y_start = summary_word[1] + 15
-        y_end   = summary_word[1] + 115
-        band = [w for w in words if y_start <= w[1] <= y_end]
-        if not band:
-            return ""
+        def parse_account_rows(start_idx):
+            rows = []
+            i = start_idx
+            pending = None
+            while i < len(lines):
+                _, _, toks, text = lines[i]
+                if not text:
+                    i += 1
+                    continue
+
+                # Section/account boundaries
+                if acct_re.match(text) and i != start_idx:
+                    break
+                if any(text.startswith(s) for s in stop_markers):
+                    break
+                if text in ("Checking", "Savings"):
+                    break
+                if text.startswith("Date Transaction Detail"):
+                    i += 1
+                    continue
 
-        # Group into lines by y-bucket (5pt tolerance)
-        lines_by_y = _dd(list)
-        for w in band:
-            lines_by_y[round(w[1] / 5) * 5].append(w)
-        rows_raw = [sorted(lines_by_y[y], key=lambda w: w[0])
-                    for y in sorted(lines_by_y)]
+                def flush_pending():
+                    nonlocal pending
+                    if pending is not None:
+                        rows.append(pending)
+                        pending = None
+
+                if toks and date_re.match(toks[0]):
+                    flush_pending()
+                    date = toks[0]
+                    rest = toks[1:]
+                    mvals = [tok for tok in rest if money_re.match(tok)]
+                    desc_tokens = [tok for tok in rest if not money_re.match(tok)]
+
+                    amount = ""
+                    balance = ""
+                    if len(mvals) >= 2:
+                        amount = mvals[-2]
+                        balance = mvals[-1]
+                    elif len(mvals) == 1:
+                        # Many NFCU lines can be split; single amount token is usually balance.
+                        balance = mvals[-1]
+
+                    pending = {
+                        "date": date,
+                        "desc": " ".join(desc_tokens).strip(),
+                        "amount": amount,
+                        "balance": balance,
+                    }
+                else:
+                    if pending is not None:
+                        mvals = [tok for tok in toks if money_re.match(tok)]
+                        desc_tokens = [tok for tok in toks if not money_re.match(tok)]
+                        if desc_tokens:
+                            pending["desc"] = (pending["desc"] + " " + " ".join(desc_tokens)).strip()
+                        if len(mvals) >= 2 and (not pending["amount"] or not pending["balance"]):
+                            if not pending["amount"]:
+                                pending["amount"] = mvals[-2]
+                            if not pending["balance"]:
+                                pending["balance"] = mvals[-1]
+                        elif len(mvals) == 1 and not pending["balance"]:
+                            pending["balance"] = mvals[-1]
+                    # else ignore stray line
+                i += 1
 
-        if len(rows_raw) < 3:
-            return ""
+            if pending is not None:
+                rows.append(pending)
+            # keep rows that have at least date+desc, and preferably balance
+            cleaned = [r for r in rows if r["date"] and r["desc"] and (r["amount"] or r["balance"])]
+            return cleaned, i
 
-        # Column centers from first two header rows
-        header_xs = sorted(w[0] for r in rows_raw[:2] for w in r)
-        col_centers = []
-        cluster = [header_xs[0]]
-        for x in header_xs[1:]:
-            if x - cluster[-1] > 30:
-                col_centers.append(sum(cluster) / len(cluster))
-                cluster = [x]
-            else:
-                cluster.append(x)
-        col_centers.append(sum(cluster) / len(cluster))
-
-        def _assign(x):
-            return min(range(len(col_centers)), key=lambda i: abs(col_centers[i] - x))
-
-        # Build column labels from first two rows
-        col_labels = [""] * len(col_centers)
-        for r in rows_raw[:2]:
-            for w in r:
-                ci = _assign(w[0])
-                col_labels[ci] = (col_labels[ci] + " " + w[2]).strip()
-
-        # Parse data rows
-        _MONEY = re.compile(r"^\$?-?[\d,]+\.\d{2}-?$")
-        merged, cur_name, cur_vals = [], [], {}
-
-        for line in rows_raw[2:]:
-            texts = [w[2] for w in line]
-            has_money = any(_MONEY.match(t) for t in texts)
-            is_totals = any(w[2].lower() == "totals" for w in line)
-
-            if has_money:
-                for w in line:
-                    if not re.match(r"^\d{7,}$", w[2]) and w[2].lower() != "totals":
-                        cur_vals[_assign(w[0])] = w[2]
-                acct_num = next((w[2] for w in line if re.match(r"^\d{7,}$", w[2])), "")
-                name = " ".join(cur_name)
-                if acct_num:
-                    name = (name + " " + acct_num).strip()
-                if is_totals:
-                    name = "Totals"
-                merged.append((name, dict(cur_vals)))
-                cur_name, cur_vals = [], {}
-            else:
-                cur_name.extend(texts)
+        out = []
+        i = 0
+        while i < len(lines):
+            _, _, _, text = lines[i]
+            if not text:
+                i += 1
+                continue
 
-        if not merged:
-            return ""
+            m = acct_re.match(text)
+            if m:
+                acct_name = m.group(1)
+                acct_no = m.group(2)
+                title = f"{acct_name} - {acct_no}"
+                if i + 1 < len(lines) and "Continued" in lines[i + 1][3]:
+                    title += " (Continued from previous page)"
+                out.append(f"<b>{title}</b>")
+                out.append("<table>")
+                out.append("<tr><th>Date</th><th>Transaction Detail</th><th>Amount($)</th><th>Balance($)</th></tr>")
+                rows, i2 = parse_account_rows(i + 1)
+                for r in rows:
+                    out.append(
+                        f"<tr><td>{r['date']}</td><td>{r['desc']}</td><td>{r['amount']}</td><td>{r['balance']}</td></tr>"
+                    )
+                out.append("</table>")
+                i = i2
+                continue
 
-        n = len(col_labels)
-        hdr = "<tr><th>Account</th>" + "".join(f"<th>{l}</th>" for l in col_labels) + "</tr>"
-        rows_html = [
-            "<tr><td>" + name + "</td>" +
-            "".join(f"<td>{vals.get(i, '')}</td>" for i in range(n)) +
-            "</tr>"
-            for name, vals in merged
-        ]
-        return (
-            "Summary of your deposit accounts\n"
-            "<table>\n" + hdr + "\n" +
-            "\n".join(rows_html) + "\n</table>"
-        )
+            # Keep section headers only (avoid noisy paragraph dump)
+            if text in ("Checking", "Savings"):
+                out.append(f"<h3>{text}</h3>")
+            elif text.startswith("Items Paid"):
+                out.append("<b>Items Paid</b>")
+            i += 1
+
+        return "\n".join(out).strip()
 
     except Exception as e:
-        log.warning("_extract_nfcu_summary_table failed (page %d): %s", page_num, e)
+        log.warning("_parse_nfcu_page failed (page %d): %s", page_num, e)
         return ""
 
 def normalize_html_tables(text: str) -> str:
@@ -2509,6 +2543,8 @@ def run_ocr(uploaded_file):
     try:
         path = uploaded_file.name if hasattr(uploaded_file, "name") else str(uploaded_file)
         is_pdf = path.lower().endswith(".pdf")
+        is_nfcu_doc = _is_nfcu_document(path) if is_pdf else False
+        nfcu_mode = is_nfcu_doc
         parser = get_parser()
 
         page_heights = []
@@ -2538,6 +2574,21 @@ def run_ocr(uploaded_file):
 
             parts = []
 
+            # Fix NF-1: Navy Federal full text-layer parse.
+            # Must run FIRST — before header/OCR/footer — so that when NFCU is
+            # detected, the entire page output is replaced with clean text-layer
+            # data and none of the garbled OCR pipeline runs at all.
+            # Safe no-op for all other banks (_parse_nfcu_page returns "").
+            # Try NFCU structured parsing on known NFCU docs, and on page 1 as a probe.
+            if is_pdf and (nfcu_mode or page_num == 0):
+                nfcu_html = _parse_nfcu_page(path, page_num)
+                if nfcu_html:
+                    nfcu_mode = True
+                    all_pages.append(nfcu_html)
+                    continue  # skip ALL OCR processing for this page
+                if nfcu_mode:
+                    log.warning("NFCU parser returned empty output for page %d", page_num + 1)
+
             # Header inclusion: PDF text -> band words -> OCR band
             hdr = ""
             if is_pdf:
@@ -2588,17 +2639,6 @@ def run_ocr(uploaded_file):
 
                 parts.append(stabilized)
 
-            # Fix NF-1: prepend Navy Federal summary table from text layer.
-            # Replaces the garbled OCR summary table with correct data.
-            # Safe no-op for all non-NFCU PDFs (returns "" when guards fail).
-            if is_pdf:
-                try:
-                    nfcu_summary = _extract_nfcu_summary_table(path, page_num)
-                    if nfcu_summary:
-                        parts.insert(0, nfcu_summary)
-                except Exception:
-                    pass
-
             # Footer extraction: PDF text layer -> band words -> OCR crop
             # Deduplication guard prevents double-printing when body OCR already captured it.
             if ENABLE_FOOTER_OCR and page_num < len(page_images):