Update app.py

app.py

@@ -594,12 +594,15 @@ 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)
     """
@@ -704,12 +707,15 @@ 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>
@@ -719,6 +725,7 @@ 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.
@@ -814,8 +821,10 @@ 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).
@@ -903,9 +912,11 @@ 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)
@@ -1036,6 +1047,7 @@ 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
@@ -1069,15 +1081,18 @@ 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:
@@ -1196,6 +1211,7 @@ 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.
@@ -1440,13 +1456,16 @@ 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).
@@ -1456,6 +1475,7 @@ 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.
@@ -1531,15 +1551,19 @@ 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).
@@ -1631,9 +1655,11 @@ 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.
@@ -1692,6 +1718,7 @@ 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
@@ -1714,12 +1741,15 @@ 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.
     """
@@ -1832,6 +1862,7 @@ 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
@@ -1909,7 +1940,9 @@ 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.
     """
@@ -2158,335 +2191,157 @@ def convert_plaintext_bank_sections(text: str) -> str:
     return "\n".join(out)
 
 # --------------------------
-# Navy Federal full-page text-layer parser (Fix NF-1)
+# Navy Federal Summary Table extraction (Fix NF-1)
 # --------------------------
 
-def _is_nfcu_document(pdf_path: str) -> bool:
-    """
-    Strict detector for Navy Federal statements.
-    Used to gate NF-specific parsing so other banks are unaffected.
+def _extract_nfcu_summary_table(pdf_path: str, page_num: int) -> str:
     """
-    try:
-        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()
-        return (
-            ("statement of account" in t)
-            and ("access no." in t or "routing number" in t)
-            and ("navy federal" in t or "navyfederal.org" in t)
-        )
-    except Exception:
-        return False
+    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.
 
-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.
+    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.
     """
     try:
-        text = ""
+        from collections import defaultdict as _dd
+
+        words = None  # list of (x0, top, text)
+        page_h = 1000
+
+        # Try pymupdf first (HuggingFace environment)
         try:
-            import pdfplumber
-            with pdfplumber.open(pdf_path) as pdf:
-                if page_num >= len(pdf.pages):
-                    return ""
-                page = pdf.pages[page_num]
-                text = page.extract_text() or ""
-        except Exception:
-            # Fallback to pymupdf text extraction when pdfplumber isn't available.
-            import pymupdf as fitz
-            doc = fitz.open(pdf_path)
-            if page_num >= len(doc):
-                doc.close()
+            import pymupdf as _fitz_s
+            _doc_s = _fitz_s.open(pdf_path)
+            if page_num >= len(_doc_s):
+                _doc_s.close()
                 return ""
-            text = doc[page_num].get_text() or ""
-            doc.close()
+            _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
+
+        # 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
 
-        if not text:
+        if not words:
             return ""
 
-        # Guard: must match NFCU format on this page OR on page 0
-        # (pages 2+ still have "Access No." and "Statement of Account")
-        t = 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)
-            )
+        # 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
         )
-        if not is_nfcu:
+        if not summary_word:
             return ""
 
-        lines = [l.strip() for l in text.splitlines()]
+        # 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 ""
 
-        # ── Regex patterns ──────────��──────────────────────────────────────
-        # Full transaction: "02-03 Description 7.68- 3,974.66"
-        TXN_FULL = re.compile(
-            r'^(\d{2}-\d{2})\s+(.+?)\s+([\d,]+\.\d{2}-?)\s+([\d,]+\.\d{2}-?)$'
-        )
-        # Transaction with continuation: next line has "Location amt bal"
-        TXN_NOAMT = re.compile(r'^(\d{2}-\d{2})\s+(.+)$')
-        # Continuation line ending with amount + balance
-        CONT_MONEY = re.compile(r'^(.+?)\s+([\d,]+\.\d{2}-?)\s+([\d,]+\.\d{2}-?)$')
-        # Items Paid two-column row
-        ITEMS_2COL = re.compile(
-            r'^(\d{2}-\d{2})\s+(ACH|POS|CHECK|ATM|WIRE)\s+([\d,]+\.\d{2})'
-            r'\s+(\d{2}-\d{2})\s+(ACH|POS|CHECK|ATM|WIRE)\s+([\d,]+\.\d{2})$'
-        )
-        ITEMS_1COL = re.compile(
-            r'^(\d{2}-\d{2})\s+(ACH|POS|CHECK|ATM|WIRE)\s+([\d,]+\.\d{2})$'
-        )
-        BOILERPLATE = re.compile(
-            r'^(Page \d+ of \d+|Access No\.\s*\d+|Statement Period'
-            r'|\d{2}/\d{2}/\d{2}\s*-\s*\d{2}/\d{2}/\d{2}'
-            r'|Statement of Account|For VIRTUAL EDUCATION STATION'
-            r'|PO Box \d+.*|navyfederal\.org.*'
-            r'|Say\s*"?Yes"?\s*to Paperless'
-            r'|Insured\s*by\s*NCUA.*|InsuredbyNCUA.*'
-            r'|IfyouhavenT?.*|Togetstarted.*|It\'saneasy.*'
-            r'|digital statements via Mobile'
-            r'|Navy Federal Online Banking\.)$'
-        )
-        SKIP_LINE = re.compile(
-            r'^(REMITTANCE RECEIVED|VIRTUAL EDUCATION STATION|18511991'
-            r'|DEPOSIT\s*VOUCHER|FOR MAIL USE ONLY|DEPOSITS MAY NOT'
-            r'|ACCOUNT\s*NUMBER|MARK\s*"?X"?\s*TO CHANGE|ADDRESS/ORDER'
-            r'|ITEMS ON REVERSE|NFCU|PO\s*BOX\s*3100|MERRIFIELD'
-            r'|405715|CHANGE OF ADDRESS|PLEASE PRINT'
-            r'|RANK/RATE|ADDRESS\(NO|CITY|STATE|ZIP|SIGNATURE'
-            r'|EFFECTIVE DATE|HOME TELEPHONE|DAYTIME TELEPHONE'
-            r'|- -|\( \)|Say Yes to Paperless).*$',
-            re.IGNORECASE
-        )
+        # 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 ""
 
-        # ── Helper: parse transaction block ────────────────────────────────
-        def parse_txn_block(i, stop_words):
-            rows = []
-            while i < len(lines):
-                l = lines[i]
-                if not l:
-                    i += 1; continue
-                if BOILERPLATE.match(l) or SKIP_LINE.match(l):
-                    i += 1; continue
-                if any(l == sw or l.startswith(sw) for sw in stop_words):
-                    break
+        # 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)]
 
-                # Full single-line transaction
-                m = TXN_FULL.match(l)
-                if m:
-                    date, desc, amt, bal = m.group(1), m.group(2), m.group(3), m.group(4)
-                    rows.append(f'<tr><td>{date}</td><td>{desc}</td><td>{amt}</td><td>{bal}</td></tr>')
-                    i += 1
-                    continue
+        if len(rows_raw) < 3:
+            return ""
 
-                # Multi-line: first line has date + partial desc, next has rest+amt+bal
-                mn = TXN_NOAMT.match(l)
-                if mn:
-                    date, desc1 = mn.group(1), mn.group(2)
-                    i += 1
-                    if i < len(lines):
-                        nxt = lines[i]
-                        mc = CONT_MONEY.match(nxt)
-                        if mc:
-                            desc2, amt, bal = mc.group(1), mc.group(2), mc.group(3)
-                            full_desc = (desc1 + ' ' + desc2).strip()
-                            rows.append(f'<tr><td>{date}</td><td>{full_desc}</td><td>{amt}</td><td>{bal}</td></tr>')
-                            i += 1
-                            continue
-                        # Next line is not a continuation — treat as balance-only
-                        rows.append(f'<tr><td>{date}</td><td>{desc1}</td><td></td><td></td></tr>')
-                    continue
+        # 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)
 
-                i += 1
-            return rows, i
+        if not merged:
+            return ""
 
-        # ── Main parse loop ────────────────────────────────────────────────
-        out = []
-        i = 0
-        TXN_STOP = [
-            'Average Daily Balance', 'Items Paid', 'Savings', 'Checking',
-            'Mbr Business Savings -', '2024 Year to Date', 'Your share balance',
-            'Disclosure', 'What to Do', 'Errors Related', 'Errors Within', 'Payments'
+        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
         ]
-
-        while i < len(lines):
-            l = lines[i]
-
-            if not l or BOILERPLATE.match(l) or SKIP_LINE.match(l):
-                i += 1; continue
-
-            # ── Summary of your deposit accounts ──────────────────────────
-            if l == 'Summary of your deposit accounts':
-                i += 1
-                # Skip the two header lines ("Previous Deposits/..." and "Balance Credits...")
-                while i < len(lines) and not re.match(r'^(Business|Mbr|Totals)', lines[i]):
-                    i += 1
-
-                out.append('<b>Summary of your deposit accounts</b>')
-                out.append('<table>')
-                out.append('<tr><th>Account</th><th>Previous Balance</th>'
-                           '<th>Deposits/Credits</th><th>Withdrawals/Debits</th>'
-                           '<th>Ending Balance</th><th>YTD Dividends</th></tr>')
-
-                while i < len(lines):
-                    l2 = lines[i]
-                    if not l2 or re.match(r'^(Checking$|#|REMITTANCE)', l2):
-                        break
-
-                    if l2.startswith('Totals '):
-                        parts = l2.split()
-                        vals = parts[1:]
-                        while len(vals) < 5: vals.append('')
-                        cells = ''.join(f'<td>{v}</td>' for v in vals[:5])
-                        out.append(f'<tr><td><b>Totals</b></td>{cells}</tr>')
-                        i += 1
-                        break
-
-                    if re.match(r'^(Business Checking|Mbr Business Savings)', l2):
-                        acct_name = l2
-                        i += 1
-                        if i < len(lines):
-                            val_line = lines[i]
-                            parts = val_line.split()
-                            if parts and re.match(r'^\d{7,}$', parts[0]):
-                                acct_num = parts[0]
-                                vals = parts[1:]
-                            else:
-                                acct_num = ''
-                                vals = parts
-                            while len(vals) < 5: vals.append('')
-                            cells = ''.join(f'<td>{v}</td>' for v in vals[:5])
-                            name_cell = f'{acct_name} ({acct_num})' if acct_num else acct_name
-                            out.append(f'<tr><td>{name_cell}</td>{cells}</tr>')
-                            i += 1
-                        continue
-                    i += 1
-
-                out.append('</table>')
-                continue
-
-            # ── Section headers ────────────────────────────────────────────
-            if l in ('Checking', 'Savings'):
-                out.append(f'<h3>{l}</h3>')
-                i += 1
-                continue
-
-            # ── Account transaction table ──────────────────────────────────
-            m_acct = re.match(
-                r'^(Business Checking|Mbr Business Savings) - (\d+)(.*)?$', l
-            )
-            if m_acct:
-                acct_line = l
-                i += 1
-                if i < len(lines) and 'Continued' in lines[i]:
-                    acct_line += ' ' + lines[i]
-                    i += 1
-                if i < len(lines) and lines[i].startswith('Date '):
-                    i += 1  # skip "Date Transaction Detail Amount($) Balance($)"
-
-                out.append(f'<b>{acct_line}</b>')
-                out.append('<table>')
-                out.append('<tr><th>Date</th><th>Transaction Detail</th>'
-                           '<th>Amount($)</th><th>Balance($)</th></tr>')
-
-                rows, i = parse_txn_block(i, TXN_STOP)
-                out.extend(rows)
-                out.append('</table>')
-                continue
-
-            # ── Items Paid ─────────────────────────────────────────────────
-            if l == 'Items Paid' or l.startswith('Items Paid (Continued'):
-                out.append(f'<b>{l}</b>')
-                out.append('<table>')
-                out.append('<tr><th>Date</th><th>Item</th><th>Amount($)</th>'
-                           '<th>Date</th><th>Item</th><th>Amount($)</th></tr>')
-                i += 1
-                if i < len(lines) and lines[i].startswith('Date '):
-                    i += 1
-
-                ITEMS_STOP = ['Savings', '2024 Year to Date', 'Checking',
-                              'Disclosure', 'What to Do']
-                while i < len(lines):
-                    l2 = lines[i]
-                    if not l2: i += 1; continue
-                    if any(l2 == sw or l2.startswith(sw) for sw in ITEMS_STOP):
-                        break
-                    if BOILERPLATE.match(l2) or SKIP_LINE.match(l2):
-                        i += 1; continue
-
-                    m2c = ITEMS_2COL.match(l2)
-                    if m2c:
-                        d1,t1,a1,d2,t2,a2 = m2c.groups()
-                        out.append(f'<tr><td>{d1}</td><td>{t1}</td><td>{a1}</td>'
-                                   f'<td>{d2}</td><td>{t2}</td><td>{a2}</td></tr>')
-                        i += 1; continue
-
-                    m1c = ITEMS_1COL.match(l2)
-                    if m1c:
-                        d1,t1,a1 = m1c.groups()
-                        out.append(f'<tr><td>{d1}</td><td>{t1}</td><td>{a1}</td>'
-                                   f'<td></td><td></td><td></td></tr>')
-                        i += 1; continue
-                    i += 1
-
-                out.append('</table>')
-                continue
-
-            # ── Average Daily Balance ──────────────────────────────────────
-            if l.startswith('Average Daily Balance'):
-                out.append(f'<p>{l}</p>')
-                i += 1; continue
-
-            # ── 2024 Year to Date ──────────────────────────────────────────
-            if l.startswith('2024 Year to Date'):
-                out.append(f'<p><b>{l}</b></p>')
-                i += 1
-                while i < len(lines) and lines[i] and not BOILERPLATE.match(lines[i]):
-                    out.append(f'<p>{lines[i]}</p>')
-                    i += 1
-                continue
-
-            # ── Your share balance is overdrawn ───────────────────────────
-            if l.startswith('Your share balance'):
-                out.append(f'<p><i>{l}</i></p>')
-                i += 1; continue
-
-            # ── Disclosure page — output as plain text ────────────────────
-            if any(l.startswith(x) for x in
-                   ('Disclosure', 'WhattoDoif', 'What to Do', 'Errors', 'Payments',
-                    'ErrorsRelated', 'ErrorsWithin')):
-                out.append(f'<p>{l}</p>')
-                i += 1; continue
-
-            # Default: keep non-empty lines
-            if l:
-                out.append(f'<p>{l}</p>')
-            i += 1
-
-        return '\n'.join(out)
+        return (
+            "Summary of your deposit accounts\n"
+            "<table>\n" + hdr + "\n" +
+            "\n".join(rows_html) + "\n</table>"
+        )
 
     except Exception as e:
-        log.warning("_parse_nfcu_page failed (page %d): %s", page_num, e)
+        log.warning("_extract_nfcu_summary_table failed (page %d): %s", page_num, e)
         return ""
 
 def normalize_html_tables(text: str) -> str:
@@ -2654,7 +2509,6 @@ 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
         parser = get_parser()
 
         page_heights = []
@@ -2684,18 +2538,6 @@ 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 "").
-            if is_pdf and is_nfcu_doc:
-                nfcu_html = _parse_nfcu_page(path, page_num)
-                if nfcu_html:
-                    all_pages.append(nfcu_html)
-                    continue  # skip ALL OCR processing for this page
-                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:
@@ -2746,6 +2588,17 @@ 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):