Update app.py

app.py

@@ -26,8 +26,6 @@ Included (data-driven, no institution names):
     but do not disable an entire table. Stabilization runs in multiple passes.
   - Split single cells that clearly contain transaction amount + trailing balance
     (two money tokens, tight gap) into two cells so classifiers can see a balance column.
-  - Long runs of plain-text ledger lines (date + description + amount, optional balance)
-    are coerced into one HTML table when 5+ consecutive lines match generic patterns.
   - thead uses th only; degenerate empty/sparse non-financial tables are dropped.
 
 Configure GLMOCR_API_KEY (environment variable). Optional: glmocr + gradio +
@@ -55,6 +53,7 @@ import logging
 import os
 import re
 import tempfile
+import uuid
 from collections import Counter
 from typing import List, Optional, Tuple
 
@@ -86,12 +85,12 @@ if not GLMOCR_API_KEY:
 
 # Rasterization: higher scale = more pixels per PDF point (helps small type,
 # boxed headers, and narrow columns). Same constant for all uploads.
-RENDER_SCALE = 3.35
+RENDER_SCALE = 3.0
 
 # White margin as a fraction of page width/height after render. Extra right
 # margin helps right-aligned currency columns that hug the page edge.
 PAD_LEFT_FRAC = 0.035
-PAD_RIGHT_FRAC = 0.125
+PAD_RIGHT_FRAC = 0.10
 PAD_TOP_FRAC = 0.018
 PAD_BOTTOM_FRAC = 0.018
 
@@ -118,11 +117,6 @@ MIN_CROP_PIXELS = 112 * 112
 PAGE_PNG_COMPRESS_LEVEL = 3
 # JPEG quality for small header/footer crops sent to the API.
 ZONE_JPEG_QUALITY = 95
-PAGE_JPEG_QUALITY = 88
-MAX_PAGE_UPLOAD_BYTES = 9_200_000
-# Keep page PNGs under MaaS input constraints to avoid 400 errors.
-MAX_PAGE_LONG_SIDE = 3600
-MAX_PAGE_TOTAL_PIXELS = 7_800_000
 
 MIN_PDF_TEXT_CHARS_NATIVE_LAYER = 1500
 
@@ -169,7 +163,7 @@ if CONFIG_PATH:
         with open(CONFIG_PATH, "r", encoding="utf-8") as f:
             config = yaml.safe_load(f)
         config.setdefault("pipeline", {}).setdefault("maas", {})
-        config["pipeline"]["maas"]["enabled"] = TrueCONFIG_PATH
+        config["pipeline"]["maas"]["enabled"] = True
         config["pipeline"]["maas"]["api_key"] = GLMOCR_API_KEY
         with open(CONFIG_PATH, "w", encoding="utf-8") as f:
             yaml.dump(config, f, default_flow_style=False, sort_keys=False)
@@ -743,323 +737,6 @@ def strip_degenerate_html_tables(md: str) -> str:
 _GLUED_HEADER_ROW_RE = re.compile(r"date\d{1,2}/\d{1,2}|typedeposit|amount\d", re.IGNORECASE)
 
 
-def strip_malformed_leading_table_rows(md: str) -> str:
-    """
-    Remove malformed leading rows in HTML tables when they are clearly bogus
-    header artifacts and the table already contains a proper header row below.
-    """
-    if not md or "<table" not in md.lower():
-        return md
-
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
-        trs = list(re.finditer(r"<tr\b[^>]*>.*?</tr>", full, flags=re.IGNORECASE | re.DOTALL))
-        if len(trs) < 2:
-            return full
-
-        first = trs[0].group(0)
-        second = trs[1].group(0)
-        first_plain = _cell_plain_text(first).lower()
-        second_plain = _cell_plain_text(second).lower()
-
-        first_is_malformed = bool(_GLUED_HEADER_ROW_RE.search(first_plain))
-        second_looks_header = (
-            ("date" in second_plain and "description" in second_plain)
-            or ("posting date" in second_plain and "description" in second_plain)
-            or ("date" in second_plain and "balance" in second_plain)
-        )
-        if not (first_is_malformed and second_looks_header):
-            return full
-
-        return full.replace(first, "", 1)
-
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
-
-
-def strip_subtotal_rows_from_transaction_tables(md: str) -> str:
-    """
-    Remove subtotal/total line-item rows from transaction tables so aggregate
-    amounts are not mistaken as individual transactions.
-    """
-    if not md or "<table" not in md.lower():
-        return md
-
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
-        rows = list(re.finditer(r"<tr\b[^>]*>.*?</tr>", full, flags=re.IGNORECASE | re.DOTALL))
-        if len(rows) < 2:
-            return full
-        # Some tables start with a title row, then the actual header appears in row 2/3.
-        sample_headers = [_cell_plain_text(r.group(0)).lower() for r in rows[:4]]
-        is_txn_like = any(
-            ("date" in hp or "posting date" in hp)
-            and ("description" in hp)
-            and ("amount" in hp or "debit" in hp or "credit" in hp)
-            for hp in sample_headers
-        )
-        if not is_txn_like:
-            return full
-
-        out = full
-        for r in rows[1:]:
-            rp = _cell_plain_text(r.group(0)).lower()
-            if "subtotal" in rp or rp.startswith("total "):
-                out = out.replace(r.group(0), "", 1)
-        return out
-
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
-
-
-# Match long digit runs even when OCR glues trailing letters (e.g. 9257403599CCD).
-_LONG_NUM_TOKEN = re.compile(r"(?<!\d)\d{7,}(?!\d)")
-
-
-def mask_non_monetary_long_numbers(md: str) -> str:
-    """
-    Prevent long reference/trace/account IDs from being interpreted as monetary
-    values by downstream transaction extraction.
-    """
-    if not md:
-        return md
-
-    def repl(m: re.Match) -> str:
-        tok = m.group(0)
-        # Keep common money-like tokens (handled elsewhere with decimal cents).
-        if re.match(r"^\d+\.\d{2}$", tok):
-            return tok
-        # Keep YYYYMMDD-like date compact tokens.
-        if len(tok) == 8 and tok.startswith(("19", "20")):
-            return tok
-        # Replace digits entirely so downstream cannot reinterpret ID tokens as money.
-        return "IDNUM"
-
-    return _LONG_NUM_TOKEN.sub(repl, md)
-
-
-def directionalize_amount_headers(md: str) -> str:
-    """
-    Convert ambiguous 'Amount' headers into 'Credit' or 'Debit' when table
-    context clearly indicates transaction direction (e.g. Deposits, Checks).
-    """
-    if not md or "<table" not in md.lower():
-        return md
-
-    def map_header_token(label: str, ctx: str) -> str:
-        low = label.strip().lower()
-        if "amount" not in low:
-            return label
-        if re.search(r"\bcredit|deposit|deposits|incoming|received|interest earned|payment received\b", ctx):
-            return re.sub(r"amount", "Credit", label, flags=re.IGNORECASE)
-        if re.search(r"\bdebit|debits|withdrawal|withdrawals|check|checks|fee|fees|charge|charges|payment|payments\b", ctx):
-            return re.sub(r"amount", "Debit", label, flags=re.IGNORECASE)
-        return label
-
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
-        # Table-local context from headers and first rows.
-        ctx = _cell_plain_text(full).lower()
-        changed = False
-
-        def repl_th(thm: re.Match) -> str:
-            nonlocal changed
-            tag = thm.group(0)
-            inner_m = re.search(r"<th\b[^>]*>(.*?)</th>", tag, flags=re.IGNORECASE | re.DOTALL)
-            if not inner_m:
-                return tag
-            inner = inner_m.group(1)
-            plain = _cell_plain_text(inner)
-            mapped = map_header_token(plain, ctx)
-            if mapped == plain:
-                return tag
-            changed = True
-            return re.sub(
-                r"(<th\b[^>]*>)(.*?)(</th>)",
-                rf"\1{html.escape(mapped)}\3",
-                tag,
-                count=1,
-                flags=re.IGNORECASE | re.DOTALL,
-            )
-
-        out = re.sub(r"<th\b[^>]*>.*?</th>", repl_th, full, flags=re.IGNORECASE | re.DOTALL)
-        if changed:
-            return out
-        # Fallback for OCR tables that put header row in <td>.
-        if "amount" in ctx and ("deposit" in ctx or "debit" in ctx or "withdraw" in ctx or "check" in ctx or "fee" in ctx):
-            out2 = re.sub(
-                r"(<td\b[^>]*>\s*)amount(\s*</td>)",
-                lambda mm: mm.group(1)
-                + (
-                    "Credit"
-                    if ("deposit" in ctx or "credit" in ctx or "incoming" in ctx or "received" in ctx)
-                    else "Debit"
-                )
-                + mm.group(2),
-                full,
-                flags=re.IGNORECASE,
-            )
-            return out2
-        return full
-
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
-
-
-def directionalize_amount_headers_by_nearby_context(md: str) -> str:
-    """
-    Use nearby narrative labels around each table (outside HTML cells) to set
-    Amount->Credit/Debit when the table itself is ambiguous.
-    """
-    if not md or "<table" not in md.lower():
-        return md
-
-    credit_hint_re = re.compile(
-        r"\b(all\s+credit\s+activity|credit\s+activity|deposits?|credits?|money\s+in)\b",
-        re.IGNORECASE,
-    )
-    debit_hint_re = re.compile(
-        r"\b(all\s+debit\s+activity|debit\s+activity|withdrawals?|debits?|checks?|money\s+out)\b",
-        re.IGNORECASE,
-    )
-
-    table_re = re.compile(r"<table\b[^>]*>.*?</table>", re.IGNORECASE | re.DOTALL)
-    out_parts: List[str] = []
-    last_end = 0
-    for tm in table_re.finditer(md):
-        out_parts.append(md[last_end:tm.start()])
-        tbl = tm.group(0)
-
-        left = re.sub(r"<[^>]+>", " ", md[max(0, tm.start() - 700): tm.start()])
-        right = re.sub(r"<[^>]+>", " ", md[tm.end(): min(len(md), tm.end() + 250)])
-        ctx = f"{left} {right}"
-        is_credit = bool(credit_hint_re.search(ctx))
-        is_debit = bool(debit_hint_re.search(ctx))
-        if is_credit ^ is_debit:
-            w = "Credit" if is_credit else "Debit"
-            tbl = re.sub(r"(<th\b[^>]*>\s*)amount(\s*</th>)", rf"\1{w}\2", tbl, flags=re.IGNORECASE)
-            tbl = re.sub(r"(<td\b[^>]*>\s*)amount(\s*</td>)", rf"\1{w}\2", tbl, flags=re.IGNORECASE)
-
-        out_parts.append(tbl)
-        last_end = tm.end()
-    out_parts.append(md[last_end:])
-    return "".join(out_parts)
-
-
-def _strip_trailing_money_tokens(rest: str, max_take: int = 2) -> Tuple[str, List[str]]:
-    """Strip 1–2 currency tokens from the right of *rest*; return (description, tokens oldest-first)."""
-    cur = rest.rstrip()
-    toks: List[str] = []
-    for _ in range(max_take):
-        cur = cur.rstrip()
-        m = _EOL_MONEY.search(cur)
-        if not m or m.end() != len(cur):
-            break
-        toks.append(m.group().strip())
-        cur = cur[: m.start()].rstrip()
-    toks.reverse()
-    return cur, toks
-
-
-def _parse_ledger_line(line: str) -> Optional[Tuple[str, str, str, str]]:
-    """
-    If *line* looks like a bank-style ledger row (date, description, amount, optional balance),
-    return (date, description, amount, balance_or_empty); else None.
-    """
-    ln = line.strip()
-    if not ln or ln[0] in "#|!<":
-        return None
-    mm = re.match(
-        r"^(?P<d>(?:\d{1,2}[/-]\d{1,2}(?:[/-]\d{2,4})?|"
-        r"(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)[a-z]*\.?\s+\d{1,2},?\s+\d{4}))"
-        r"\s+",
-        ln,
-        re.I,
-    )
-    if not mm:
-        return None
-    d = mm.group("d")
-    tail = ln[mm.end() :]
-    desc, toks = _strip_trailing_money_tokens(tail, 2)
-    desc = desc.strip()
-    if not toks or len(desc) < 2 or len(desc) > 420:
-        return None
-    amt = toks[0]
-    bal = toks[1] if len(toks) > 1 else ""
-    return (d, desc, amt, bal)
-
-
-def _ledger_rows_to_html(rows: List[Tuple[str, str, str, str]]) -> str:
-    has_bal = any(r[3] for r in rows)
-    head = (
-        "<tr><th>Date</th><th>Description</th><th>Amount</th>"
-        + ("<th>Balance</th>" if has_bal else "")
-        + "</tr>"
-    )
-    body_lines = []
-    for d, desc, amt, bal in rows:
-        cells = [
-            f"<td>{html.escape(d)}</td>",
-            f"<td>{html.escape(desc)}</td>",
-            f"<td>{html.escape(amt)}</td>",
-        ]
-        if has_bal:
-            cells.append(f"<td>{html.escape(bal)}</td>" if bal else "<td></td>")
-        body_lines.append("<tr>" + "".join(cells) + "</tr>")
-    return "<table>\n" + head + "\n" + "\n".join(body_lines) + "\n</table>"
-
-
-def coalesce_loose_ledger_lines(text: str) -> str:
-    """
-    When the model emits many consecutive plain-text ledger lines (no HTML table),
-    downstream classification sees no tables and skips. Convert long runs of
-    generic date + amount lines into a single HTML table. Requires 5+ matching
-    consecutive non-empty lines; does not match institution names.
-    """
-    if not text or "<table" in text.lower():
-        return text
-    lines = text.split("\n")
-    out: List[str] = []
-    i = 0
-    while i < len(lines):
-        if not lines[i].strip():
-            out.append(lines[i])
-            i += 1
-            continue
-        run_rows: List[Tuple[str, str, str, str]] = []
-        j = i
-        while j < len(lines):
-            raw = lines[j]
-            if not raw.strip():
-                break
-            parsed = _parse_ledger_line(raw)
-            if parsed is None:
-                break
-            run_rows.append(parsed)
-            j += 1
-        if len(run_rows) >= 5:
-            if i > 0 and out and out[-1].strip():
-                out.append("")
-            out.append(_ledger_rows_to_html(run_rows))
-            i = j
-            continue
-        out.append(lines[i])
-        i += 1
-    return "\n".join(out)
-
-
 def looks_like_markdown_table(block: str) -> bool:
     lines = [ln.rstrip() for ln in block.strip().splitlines() if ln.strip()]
     if len(lines) < 2:
@@ -1117,7 +794,7 @@ def normalize_money_glyphs(text: str) -> str:
 
 
 def light_stabilize_markdown(page_md: str) -> str:
-    """Convert obvious GitHub-style pipe tables to HTML; normalize money glyphs; repair tags."""
+    """Convert obvious GitHub-style pipe tables to HTML; normalize money glyphs; light table pass."""
     if not page_md:
         return page_md
     page_md = normalize_money_glyphs(page_md)
@@ -1127,27 +804,34 @@ def light_stabilize_markdown(page_md: str) -> str:
         if looks_like_markdown_table(b):
             out_blocks.append(md_table_to_html(b))
         else:
-            out_blocks.append(coalesce_loose_ledger_lines(b))
-    merged = close_unclosed_html("\n\n".join(out_blocks))
-    merged = strip_malformed_leading_table_rows(merged)
-    merged = strip_subtotal_rows_from_transaction_tables(merged)
-    merged = mask_non_monetary_long_numbers(merged)
+            out_blocks.append(b)
+    merged = close_unclosed_html('\n\n'.join(out_blocks))
     merged = repair_thead_cell_semantics(merged)
-    merged = stabilize_table_markup(merged, rounds=4)
+    merged = stabilize_table_markup(merged, rounds=2)
     merged = strip_degenerate_html_tables(merged)
     return merged
 
 
 def _parse_amount_or_none(s: str):
-    t = (s or "").strip()
-    if not t:
+    raw = (s or "").strip()
+    if not raw:
+        return None
+    if re.search(r"\d{10,}", raw) and "." not in raw and "," not in raw:
         return None
+    t = raw
     t = t.replace("$", "").replace(",", "").replace("(", "-").replace(")", "")
     t = t.replace("−", "-").replace("–", "-").replace("—", "-")
     if not re.search(r"\d", t):
         return None
+    if "." not in t and len(re.sub(r"[^\d]", "", t)) >= 8:
+        return None
     try:
-        return float(t)
+        v = float(t)
+        # Guardrail: reject clearly implausible values (OCR-glued IDs/garbage),
+        # which can explode statement-level reconciliation arithmetic.
+        if abs(v) > 10_000_000:
+            return None
+        return v
     except Exception:
         return None
 
@@ -1171,493 +855,279 @@ def _fmt_money(v: float) -> str:
 
 def _is_date_like(s: str) -> bool:
     t = (s or "").strip()
-    return bool(re.match(r"^(?:\d{1,2}[/-]\d{1,2}(?:[/-]\d{2,4})?)$", t))
-
-
-def normalize_ambiguous_amount_balance_tables(md: str) -> str:
-    """
-    For transaction-like tables that expose only a single Amount column plus
-    Balance, convert to explicit Credit/Debit using generic running-balance
-    inference. This avoids sign ambiguity and improves reconcile stability.
-    """
-    if not md or "<table" not in md.lower():
-        return md
-
-    credit_hint_re = re.compile(
-        r"\b(deposit|deposits|credit|credits|incoming|received|interest earned|refund|return)\b",
-        re.IGNORECASE,
-    )
-    debit_hint_re = re.compile(
-        r"\b(debit|debits|withdrawal|withdrawals|check|checks|fee|fees|charge|charges|payment|transfer out|purchase)\b",
-        re.IGNORECASE,
+    if not t:
+        return False
+    if re.match(r"^(?:\d{1,2}[/-]\d{1,2}(?:[/-]\d{2,4})?)$", t):
+        return True
+    if re.match(r"^\d{4}[/-]\d{1,2}[/-]\d{1,2}$", t):
+        return True
+    return bool(
+        re.match(
+            r"^(?:(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Sept|Oct|Nov|Dec)[a-z]*\.?\s+\d{1,2},?\s+\d{4})$",
+            t,
+            re.I,
+        )
     )
 
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
-        rows = _extract_rows_plain_from_table(full)
-        if len(rows) < 3:
-            return full
-
-        hdr = [c.strip().lower() for c in rows[0]]
-        amount_idxs = [i for i, c in enumerate(hdr) if "amount" in c]
-        balance_idxs = [i for i, c in enumerate(hdr) if "balance" in c]
-        has_credit = any("credit" in c for c in hdr)
-        has_debit = any("debit" in c for c in hdr)
-        date_idxs = [i for i, c in enumerate(hdr) if "date" in c]
-        desc_idxs = [i for i, c in enumerate(hdr) if "description" in c or "memo" in c or "details" in c]
-
-        if has_credit or has_debit or not amount_idxs or not balance_idxs:
-            return full
-
-        amount_idx = amount_idxs[0]
-        balance_idx = balance_idxs[0]
-        date_idx = date_idxs[0] if date_idxs else 0
-        desc_idx = desc_idxs[0] if desc_idxs else min(1, max(0, len(rows[0]) - 1))
-
-        new_rows: List[List[str]] = [["Date", "Description", "Credit", "Debit", "Balance"]]
-        prev_bal = None
-        section_hint = ""
-        converted = 0
 
-        for r in rows[1:]:
-            if not r:
-                continue
-            padded = r + [""] * (max(amount_idx, balance_idx, date_idx, desc_idx) + 1 - len(r))
-            date_txt = (padded[date_idx] or "").strip()
-            desc_txt = (padded[desc_idx] or "").strip()
-            amt_txt = (padded[amount_idx] or "").strip()
-            bal_txt = (padded[balance_idx] or "").strip()
-            amt = _parse_amount_or_none(amt_txt)
-            bal = _parse_amount_or_none(bal_txt)
-
-            row_blob = " ".join((c or "").strip() for c in padded).strip()
-            if row_blob and not _is_date_like(date_txt) and amt is None:
-                section_hint = row_blob
-                continue
-            if amt is None and bal is None:
-                continue
-
-            direction = ""
-            # Primary: infer from balance delta between consecutive rows.
-            if amt is not None and bal is not None and prev_bal is not None:
-                delta = bal - prev_bal
-                tol = max(0.55, 0.025 * abs(amt))
-                if abs(abs(delta) - abs(amt)) <= tol:
-                    direction = "credit" if delta > 0 else "debit"
-
-            # Secondary: section + description lexical hints.
-            ctx = f"{section_hint} {desc_txt}"
-            if not direction and credit_hint_re.search(ctx):
-                direction = "credit"
-            if not direction and debit_hint_re.search(ctx):
-                direction = "debit"
-
-            credit = ""
-            debit = ""
-            if amt is not None:
-                if direction == "credit":
-                    credit = _fmt_money(abs(amt))
-                elif direction == "debit":
-                    debit = _fmt_money(abs(amt))
-                else:
-                    # Conservative fallback for ambiguous rows: preserve as debit
-                    # to avoid overstating inflows.
-                    debit = _fmt_money(abs(amt))
-
-            balance_out = _fmt_money(bal) if bal is not None else ""
-            new_rows.append([date_txt, desc_txt, credit, debit, balance_out])
-            if bal is not None:
-                prev_bal = bal
-            converted += 1
-
-        if converted < 5:
-            return full
-
-        html_rows = []
-        html_rows.append(
-            "<tr>" + "".join(f"<th>{html.escape(c)}</th>" for c in new_rows[0]) + "</tr>"
-        )
-        for rr in new_rows[1:]:
-            html_rows.append(
-                "<tr>" + "".join(f"<td>{html.escape(c)}</td>" for c in rr) + "</tr>"
-            )
-        return "<table>\n" + "\n".join(html_rows) + "\n</table>"
-
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
+def infer_credit_debit_from_balance_deltas(md: str) -> str:
+    # Intentionally disabled in the simplified app.
+    return md
 
 
-def normalize_amount_only_transaction_tables(md: str) -> str:
-    """
-    Convert transaction-like tables with Date/Description/Amount (no Credit/Debit)
-    into explicit Credit/Debit columns using generic lexical heuristics.
-    """
-    if not md or "<table" not in md.lower():
+def normalize_balance_snapshot(md: str) -> str:
+    """Replace noisy/incorrect snapshot text with values parsed from statement summary."""
+    if not md:
         return md
-
-    credit_hint_re = re.compile(
-        r"\b(deposit|deposits|credit|credits|incoming|received|return|refund|interest|pmt cr)\b",
-        re.IGNORECASE,
-    )
-    debit_hint_re = re.compile(
-        r"\b(debit|debits|withdrawal|withdrawals|check|checks|fee|fees|charge|charges|payment|purchase|ach|bill)\b",
-        re.IGNORECASE,
+    start_bal, end_bal = _parse_statement_edge_balances(md)
+    if start_bal is None and end_bal is None:
+        return md
+    # Remove any existing markdown snapshot block at document start.
+    md2 = re.sub(
+        r"^\s*##\s*Balance\s+Snapshot\s*\n(?:[^\n]*\n){0,8}\s*",
+        "",
+        md,
+        count=1,
+        flags=re.IGNORECASE,
     )
+    lines = ["## Balance Snapshot"]
+    if start_bal is not None:
+        lines.append(f"Beginning balance: {start_bal:,.2f}")
+    if end_bal is not None:
+        lines.append(f"Ending balance: {end_bal:,.2f}")
+    return "\n".join(lines) + "\n\n" + md2.lstrip()
 
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
-        rows = _extract_rows_plain_from_table(full)
-        if len(rows) < 3:
-            return full
-        hdr = [c.strip().lower() for c in rows[0]]
-        if any("credit" in c for c in hdr) or any("debit" in c for c in hdr):
-            return full
-        amount_idxs = [i for i, c in enumerate(hdr) if "amount" in c]
-        date_idxs = [i for i, c in enumerate(hdr) if "date" in c]
-        desc_idxs = [i for i, c in enumerate(hdr) if "description" in c or "memo" in c or "details" in c]
-        if not amount_idxs or not date_idxs:
-            return full
-        amount_idx = amount_idxs[0]
-        date_idx = date_idxs[0]
-        desc_idx = desc_idxs[0] if desc_idxs else min(1, len(rows[0]) - 1)
-        table_ctx = _cell_plain_text(full)
 
-        new_rows = [["Date", "Description", "Credit", "Debit"]]
-        converted = 0
-        for r in rows[1:]:
+def _parse_statement_edge_balances(md: str) -> Tuple[Optional[float], Optional[float]]:
+    """Extract statement beginning/ending balances using generic wording patterns."""
+    # Prefer account-summary table rows (most reliable for statements).
+    for tm in re.finditer(r"<table\b[^>]*>.*?</table>", md, flags=re.IGNORECASE | re.DOTALL):
+        tbl = tm.group(0)
+        plain_tbl = _cell_plain_text(tbl).lower()
+        if "account summary" not in plain_tbl:
+            continue
+        start = None
+        end = None
+        rows = _extract_rows_plain_from_table(tbl)
+        for r in rows:
             if not r:
                 continue
-            padded = r + [""] * (max(amount_idx, date_idx, desc_idx) + 1 - len(r))
-            date_txt = (padded[date_idx] or "").strip()
-            if not _is_date_like(date_txt):
-                continue
-            desc_txt = (padded[desc_idx] or "").strip()
-            amt = _parse_amount_or_none((padded[amount_idx] or "").strip())
-            if amt is None:
+            key = " ".join((c or "").strip().lower() for c in r[:2])
+            amts = []
+            for c in r:
+                for m in re.finditer(r"-?\d{1,3}(?:,\d{3})*(?:\.\d{2})", c or ""):
+                    v = _parse_amount_or_none(m.group(0))
+                    if v is not None:
+                        amts.append(v)
+            if not amts:
                 continue
-            ctx = f"{table_ctx} {desc_txt}"
-            credit = ""
-            debit = ""
-            if credit_hint_re.search(ctx) and not debit_hint_re.search(ctx):
-                credit = _fmt_money(abs(amt))
-            elif debit_hint_re.search(ctx) and not credit_hint_re.search(ctx):
-                debit = _fmt_money(abs(amt))
-            else:
-                # Conservative default for unknown direction.
-                debit = _fmt_money(abs(amt))
-            new_rows.append([date_txt, desc_txt, credit, debit])
-            converted += 1
-
-        if converted < 5:
-            return full
+            if start is None and ("beginning balance" in key or "starting balance" in key):
+                start = amts[0]
+            if end is None and "ending balance" in key:
+                end = amts[-1]
+        if start is not None or end is not None:
+            return start, end
+
+    # Fallback: free-text scan with all candidates, choose the largest magnitude match.
+    # Additional fallback forms common in statements.
+    start_cands = []
+    for m in re.finditer(
+        r"(?:Balance\s+Forward(?:\s+From)?|Beginning\s+balance\s+on)\s*[^\n$]{0,60}\$?\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d{2})?)\+?",
+        md,
+        flags=re.IGNORECASE,
+    ):
+        v = _parse_amount_or_none(m.group(1))
+        if v is not None:
+            start_cands.append(v)
+    for m in re.finditer(
+        r"(?:Beginning|Starting)\s+balance[^$\n]{0,120}\$?\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d{2})?)",
+        md,
+        flags=re.IGNORECASE,
+    ):
+        v = _parse_amount_or_none(m.group(1))
+        if v is not None:
+            start_cands.append(v)
+    end_cands = []
+    for m in re.finditer(
+        r"Ending\s+balance(?:\s+on)?[^\n$]{0,60}\$?\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d{2})?)\+?",
+        md,
+        flags=re.IGNORECASE,
+    ):
+        v = _parse_amount_or_none(m.group(1))
+        if v is not None:
+            end_cands.append(v)
+    for m in re.finditer(
+        r"Ending\s+balance[^$\n]{0,120}\$?\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d{2})?)",
+        md,
+        flags=re.IGNORECASE,
+    ):
+        v = _parse_amount_or_none(m.group(1))
+        if v is not None:
+            end_cands.append(v)
+    start = max(start_cands, key=lambda x: abs(x)) if start_cands else None
+    end = max(end_cands, key=lambda x: abs(x)) if end_cands else None
+    return start, end
 
-        html_rows = ["<tr>" + "".join(f"<th>{html.escape(c)}</th>" for c in new_rows[0]) + "</tr>"]
-        for rr in new_rows[1:]:
-            html_rows.append("<tr>" + "".join(f"<td>{html.escape(c)}</td>" for c in rr) + "</tr>")
-        return "<table>\n" + "\n".join(html_rows) + "\n</table>"
 
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
+def _table_sign_bias(ctx: str) -> int:
+    """Estimate sign direction for amount-only tables from local context."""
+    c = (ctx or "").lower()
+    if re.search(r"\b(deposit|deposits|credit|credits|other credits|rtp\s*rcvd|money\s+in)\b", c):
+        return 1
+    if re.search(
+        r"\b(payment|payments|withdrawal|withdrawals|debit|debits|checks?\s+paid|service\s+charge|fee|fees|money\s+out)\b",
+        c,
+    ):
+        return -1
+    return 0
 
 
-def infer_credit_debit_from_balance_deltas(md: str) -> str:
+def _signed_amount_from_row(desc: str, amount: Optional[float], table_bias: int) -> Optional[float]:
+    if amount is None:
+        return None
+    d = (desc or "").lower()
+    if re.search(r"\b(deposit|credit|recd|received|refund|interest|rtp\s*rcvd)\b", d):
+        return abs(amount)
+    if re.search(r"\b(payment|withdraw|debit|purchase|fee|charge|check|ach)\b", d):
+        return -abs(amount)
+    if table_bias > 0:
+        return abs(amount)
+    if table_bias < 0:
+        return -abs(amount)
+    return None
+
+
+def synthesize_running_balances(md: str) -> str:
     """
-    When OCR leaves Credit/Debit empty but a running Balance column is present,
-    infer signed movement from consecutive balance deltas (same for all banks).
+    For transaction-like tables lacking a Balance column, synthesize running balances
+    from statement beginning balance and signed amounts. Generic, pattern-based only.
     """
     if not md or "<table" not in md.lower():
         return md
+    start_bal, end_bal = _parse_statement_edge_balances(md)
+    if start_bal is None:
+        return md
 
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
+    table_re = re.compile(r"<table\b[^>]*>.*?</table>", re.IGNORECASE | re.DOTALL)
+    table_matches = list(table_re.finditer(md))
+    if not table_matches:
+        return md
+
+    plans = []
+    signed_known = []
+    signed_unknown = []
+    for ti, tm in enumerate(table_matches):
+        full = tm.group(0)
         rows = _extract_rows_plain_from_table(full)
         if len(rows) < 3:
-            return full
-
+            continue
         hdr = [c.strip() for c in rows[0]]
         hdr_l = [h.lower() for h in hdr]
         date_i = next((i for i, h in enumerate(hdr_l) if "date" in h), None)
-        desc_i = next(
-            (i for i, h in enumerate(hdr_l) if "description" in h or "memo" in h or "details" in h),
-            None,
-        )
+        desc_i = next((i for i, h in enumerate(hdr_l) if "description" in h or "memo" in h or "details" in h), None)
+        if date_i is None or desc_i is None:
+            continue
+        balance_i = next((i for i, h in enumerate(hdr_l) if "balance" in h), None)
+        amount_i = next((i for i, h in enumerate(hdr_l) if "amount" in h and "balance" not in h), None)
         credit_i = next((i for i, h in enumerate(hdr_l) if "credit" in h), None)
         debit_i = next((i for i, h in enumerate(hdr_l) if "debit" in h), None)
-        balance_i = next((i for i, h in enumerate(hdr_l) if "balance" in h), None)
+        if amount_i is None and (credit_i is None or debit_i is None):
+            continue
 
-        if date_i is None or desc_i is None or credit_i is None or debit_i is None or balance_i is None:
-            return full
+        ctx_left = re.sub(r"<[^>]+>", " ", md[max(0, tm.start() - 320): tm.start()])
+        ctx_tbl = re.sub(r"<[^>]+>", " ", full[:800])
+        bias = _table_sign_bias(ctx_left + " " + ctx_tbl)
 
         max_len = max(len(hdr), max((len(r) for r in rows), default=0))
-        body_bals: List[Optional[float]] = []
-        body_rows: List[List[str]] = []
-        for r in rows[1:]:
-            padded = (r + [""] * (max_len - len(r)))[:max_len]
-            dt = (padded[date_i] or "").strip()
+        recs = []
+        for ri, r in enumerate(rows[1:], start=1):
+            row = (r + [""] * (max_len - len(r)))[:max_len]
+            dt = (row[date_i] or "").strip()
             if not _is_date_like(dt):
                 continue
-            cr = _parse_amount_or_none((padded[credit_i] or "").strip()) if credit_i < len(padded) else None
-            db = _parse_amount_or_none((padded[debit_i] or "").strip()) if debit_i < len(padded) else None
-            bal = _parse_amount_or_none((padded[balance_i] or "").strip()) if balance_i < len(padded) else None
-            body_rows.append(padded)
-            body_bals.append(bal)
-
-        if len(body_rows) < 3:
-            return full
-
-        empty_cd = 0
-        for i, pr in enumerate(body_rows):
-            cr = _parse_amount_or_none((pr[credit_i] or "").strip()) if credit_i < len(pr) else None
-            db = _parse_amount_or_none((pr[debit_i] or "").strip()) if debit_i < len(pr) else None
-            if cr is None and db is None:
-                empty_cd += 1
-        if empty_cd < max(3, int(0.6 * len(body_rows))):
-            return full
-
-        new_body: List[List[str]] = []
-        for i, pr in enumerate(body_rows):
-            row = pr[:]
-            cr0 = _parse_amount_or_none((row[credit_i] or "").strip()) if credit_i < len(row) else None
-            db0 = _parse_amount_or_none((row[debit_i] or "").strip()) if debit_i < len(row) else None
-            if cr0 is not None or db0 is not None:
-                new_body.append(row)
-                continue
-            if i == 0 or body_bals[i] is None:
-                new_body.append(row)
-                continue
-            prev_b = body_bals[i - 1]
-            cur_b = body_bals[i]
-            if prev_b is None or cur_b is None:
-                new_body.append(row)
-                continue
-            delta = cur_b - prev_b
-            if abs(delta) < 1e-6:
-                new_body.append(row)
-                continue
-            tol = max(0.55, 0.025 * abs(delta))
-            if abs(delta) <= tol:
-                new_body.append(row)
-                continue
-            if delta > 0:
-                row[credit_i] = _fmt_money(delta)
-            else:
-                row[debit_i] = _fmt_money(-delta)
-            new_body.append(row)
-
-        filled = 0
-        for i, pr in enumerate(new_body):
-            cr = _parse_amount_or_none((pr[credit_i] or "").strip()) if credit_i < len(pr) else None
-            db = _parse_amount_or_none((pr[debit_i] or "").strip()) if debit_i < len(pr) else None
-            if cr is not None or db is not None:
-                filled += 1
-        if filled < max(2, int(0.35 * len(new_body))):
-            return full
-
-        html_rows = ["<tr>" + "".join(f"<th>{html.escape(c)}</th>" for c in hdr) + "</tr>"]
-        for pr in new_body:
-            cells = (pr + [""] * (len(hdr) - len(pr)))[: len(hdr)]
-            html_rows.append(
-                "<tr>" + "".join(f"<td>{html.escape((c or '').strip())}</td>" for c in cells) + "</tr>"
+            desc = (row[desc_i] or "").strip()
+            bal = (
+                _parse_amount_or_none((row[balance_i] or "").strip())
+                if balance_i is not None and balance_i < len(row)
+                else None
             )
-        return "<table>\n" + "\n".join(html_rows) + "\n</table>"
-
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
-
+            if amount_i is not None and amount_i < len(row):
+                amt = _parse_amount_or_none((row[amount_i] or "").strip())
+                signed = _signed_amount_from_row(desc, amt, bias)
+            else:
+                cr = _parse_amount_or_none((row[credit_i] or "").strip()) if credit_i < len(row) else None
+                db = _parse_amount_or_none((row[debit_i] or "").strip()) if debit_i < len(row) else None
+                signed = None
+                if cr is not None and db is None:
+                    signed = abs(cr)
+                elif db is not None and cr is None:
+                    signed = -abs(db)
+            recs.append({"ri": ri, "row": row, "signed": signed, "balance": bal})
+            if signed is None:
+                signed_unknown.append((ti, ri))
+            else:
+                signed_known.append(float(signed))
+        if len(recs) >= 3:
+            plans.append({"ti": ti, "hdr": hdr, "balance_i": balance_i, "records": recs})
 
-def sanitize_transaction_tables(md: str) -> str:
-    """
-    Final defensive cleanup for transaction-like tables:
-    - remove in-body header repeats and subtotal rows
-    - deduplicate repeated rows
-    - correct likely credit/debit direction using row text and balance deltas
-    """
-    if not md or "<table" not in md.lower():
+    if not plans:
         return md
 
-    credit_kw = re.compile(
-        r"\b(deposit|deposits|credit|credits|recd|received|return|refund|interest|rtp\s*rcvd|pmt\s*cr)\b",
-        re.IGNORECASE,
-    )
-    debit_kw = re.compile(
-        r"\b(debit|debits|withdrawal|withdrawals|check|checks|payment|purchase|charge|fee|ach)\b",
-        re.IGNORECASE,
-    )
+    # If signs are mostly inverted for this statement, flip unknown-bias outcomes globally.
+    flip_unknown = False
+    if end_bal is not None and signed_known:
+        fwd = start_bal + sum(signed_known)
+        rev = start_bal - sum(signed_known)
+        flip_unknown = abs(rev - end_bal) + 1e-6 < abs(fwd - end_bal)
 
-    def parse_money(txt: str):
-        t = (txt or "").strip()
-        if not t:
-            return None
-        return _parse_amount_or_none(t)
-
-    def fmt_money(v: float) -> str:
-        return f"{abs(v):,.2f}"
-
-    def repl_table(m: re.Match) -> str:
-        full = m.group(0)
-        rows = _extract_rows_plain_from_table(full)
-        if len(rows) < 2:
-            return full
+    pieces = []
+    last = 0
+    for ti, tm in enumerate(table_matches):
+        pieces.append(md[last:tm.start()])
+        full = tm.group(0)
+        plan = next((p for p in plans if p["ti"] == ti), None)
+        if not plan:
+            pieces.append(full)
+            last = tm.end()
+            continue
 
-        hdr = [c.strip() for c in rows[0]]
-        hdr_l = [h.lower() for h in hdr]
-        date_i = next((i for i, h in enumerate(hdr_l) if "date" in h), None)
-        desc_i = next((i for i, h in enumerate(hdr_l) if "description" in h or "memo" in h or "details" in h), None)
-        credit_i = next((i for i, h in enumerate(hdr_l) if "credit" in h), None)
-        debit_i = next((i for i, h in enumerate(hdr_l) if "debit" in h), None)
-        amount_i = next((i for i, h in enumerate(hdr_l) if "amount" in h), None)
-        balance_i = next((i for i, h in enumerate(hdr_l) if "balance" in h), None)
-        is_txn = (date_i is not None) and (desc_i is not None) and (
-            credit_i is not None or debit_i is not None or amount_i is not None
-        )
-        if not is_txn:
-            return full
-        # Without a real balance column, do not rewrite the table (avoids blank balances).
+        hdr = plan["hdr"][:]
+        balance_i = plan["balance_i"]
         if balance_i is None:
-            return full
-
-        max_cols = max(len(hdr), max((len(r) for r in rows), default=len(hdr)))
-        if max_cols < 4:
-            max_cols = 4
-
-        new_hdr = hdr[:]
-        if amount_i is not None and credit_i is None and debit_i is None:
-            new_hdr[amount_i] = "Debit"
-            debit_i = amount_i
-            amount_i = None
-        if credit_i is None:
-            new_hdr.append("Credit")
-            credit_i = len(new_hdr) - 1
-        if debit_i is None:
-            new_hdr.append("Debit")
-            debit_i = len(new_hdr) - 1
-
-        records = []
-        seen = set()
-        for r in rows[1:]:
-            padded = r + [""] * (len(new_hdr) - len(r))
-            low = [c.strip().lower() for c in padded]
-            joined = " ".join(low)
-
-            # Remove duplicate header rows inside body and subtotal/total lines.
-            if any(
-                x in low
-                for x in ("date", "posting date", "description", "amount", "credit", "debit", "balance")
-            ):
-                continue
-            if "subtotal" in joined or joined.startswith("total "):
-                continue
-
-            dt = padded[date_i].strip() if date_i is not None and date_i < len(padded) else ""
-            if not _is_date_like(dt):
-                continue
-            desc = padded[desc_i].strip() if desc_i is not None and desc_i < len(padded) else ""
-            bal = parse_money(padded[balance_i]) if balance_i < len(padded) else None
-            cr = parse_money(padded[credit_i]) if credit_i < len(padded) else None
-            db = parse_money(padded[debit_i]) if debit_i < len(padded) else None
-
-            if cr is None and db is None:
-                continue
-
-            amt = cr if cr is not None else db
-            direction = "credit" if cr is not None else "debit"
-
-            # Row-level lexical correction
-            if amt is not None:
-                if credit_kw.search(desc) and not debit_kw.search(desc):
-                    direction = "credit"
-                elif debit_kw.search(desc) and not credit_kw.search(desc):
-                    direction = "debit"
-
-            key = (dt, desc, f"{amt:.2f}" if isinstance(amt, (int, float)) else "", f"{bal:.2f}" if isinstance(bal, (int, float)) else "")
-            if key in seen:
-                continue
-            seen.add(key)
-            records.append(
-                {
-                    "row": padded[: len(new_hdr)],
-                    "amount": abs(amt) if amt is not None else None,
-                    "balance": bal,
-                    "lex_dir": direction,
-                }
-            )
-
-        if not records:
-            return full
-
-        # Choose balance interpretation direction (forward vs reverse row order)
-        # based on which one produces more valid delta-to-amount matches.
-        def delta_match(delta: float, amt_val: float) -> str:
-            tol = max(0.75, 0.03 * abs(amt_val))
-            if abs(delta - abs(amt_val)) <= tol:
-                return "credit"
-            if abs(delta + abs(amt_val)) <= tol:
-                return "debit"
-            return ""
-
-        fwd_matches = 0
-        rev_matches = 0
-        prev_bal = None
-        for rec in records:
-            bal = rec["balance"]
-            amt_val = rec["amount"]
-            if bal is None or amt_val is None:
+            hdr.append("Balance")
+            balance_i = len(hdr) - 1
+
+        run = start_bal
+        row_by_ri = {}
+        for rec in plan["records"]:
+            signed = rec["signed"]
+            if signed is None:
+                row_by_ri[rec["ri"]] = rec["row"]
                 continue
-            if prev_bal is not None:
-                if delta_match(bal - prev_bal, amt_val):
-                    fwd_matches += 1
-                if delta_match(prev_bal - bal, amt_val):
-                    rev_matches += 1
-            prev_bal = bal
-
-        use_reverse = rev_matches > fwd_matches
-
-        body = []
-        prev_bal = None
-        for rec in records:
-            out = rec["row"][:]
-            amt_val = rec["amount"]
-            bal = rec["balance"]
-            direction = rec["lex_dir"]
-
-            if amt_val is not None and bal is not None and prev_bal is not None:
-                delta = (prev_bal - bal) if use_reverse else (bal - prev_bal)
-                d = delta_match(delta, amt_val)
-                if d:
-                    direction = d
-            if bal is not None:
-                prev_bal = bal
-
-            out[credit_i] = fmt_money(amt_val) if (amt_val is not None and direction == "credit") else ""
-            out[debit_i] = fmt_money(amt_val) if (amt_val is not None and direction == "debit") else ""
-            out[balance_i] = f"{bal:,.2f}" if bal is not None else out[balance_i]
-            body.append(out)
-
-        if not body:
-            return full
-        html_rows = ["<tr>" + "".join(f"<th>{html.escape(c)}</th>" for c in new_hdr) + "</tr>"]
-        for rr in body:
-            html_rows.append("<tr>" + "".join(f"<td>{html.escape(c)}</td>" for c in rr) + "</tr>")
-        return "<table>\n" + "\n".join(html_rows) + "\n</table>"
+            if flip_unknown:
+                signed = -signed
+            run += signed
+            row = rec["row"][:]
+            if len(row) < len(hdr):
+                row += [""] * (len(hdr) - len(row))
+            row[balance_i] = _fmt_money(run)
+            row_by_ri[rec["ri"]] = row
+
+        base_rows = _extract_rows_plain_from_table(full)
+        if len(base_rows) < 2:
+            pieces.append(full)
+            last = tm.end()
+            continue
+        out_rows = ["<tr>" + "".join(f"<th>{html.escape(c)}</th>" for c in hdr) + "</tr>"]
+        for ri, old in enumerate(base_rows[1:], start=1):
+            row = row_by_ri.get(ri, old)
+            row = (row + [""] * (len(hdr) - len(row)))[: len(hdr)]
+            out_rows.append("<tr>" + "".join(f"<td>{html.escape((c or '').strip())}</td>" for c in row) + "</tr>")
+        pieces.append("<table>\n" + "\n".join(out_rows) + "\n</table>")
+        last = tm.end()
 
-    return re.sub(
-        r"<table\b[^>]*>.*?</table>",
-        repl_table,
-        md,
-        flags=re.IGNORECASE | re.DOTALL,
-    )
+    pieces.append(md[last:])
+    return "".join(pieces)
 
 
 def _extract_daily_balance_by_date(md: str):
@@ -1705,333 +1175,6 @@ def _extract_daily_balance_by_date(md: str):
     return out
 
 
-def enrich_transaction_tables_with_daily_balances(md: str) -> str:
-    """
-    If transaction tables have Date+Amount but no Balance column, append a Balance
-    column using date-matched daily ending balances from the same document.
-    """
-    if not md or "<table" not in md.lower():
-        return md
-    dmap = _extract_daily_balance_by_date(md)
-    if not dmap:
-        return md
-
-    def repl(m: re.Match) -> str:
-        table = m.group(0)
-        if re.search(r"(?:colspan|rowspan)\s*=", table, flags=re.IGNORECASE):
-            return table
-        tr_blocks = list(re.finditer(r"<tr\b[^>]*>.*?</tr>", table, flags=re.IGNORECASE | re.DOTALL))
-        if len(tr_blocks) < 2:
-            return table
-        first = tr_blocks[0].group(0)
-        h_inner_m = re.search(r"<tr\b[^>]*>(.*)</tr>", first, flags=re.IGNORECASE | re.DOTALL)
-        if not h_inner_m:
-            return table
-        h_inner = h_inner_m.group(1)
-        h_cells = list(_CELL.finditer(h_inner))
-        if not h_cells:
-            return table
-        hdr_txt = [_cell_plain_text(c.group(0)).strip().lower() for c in h_cells]
-        if any("balance" in c for c in hdr_txt):
-            return table
-        if not any("date" in c for c in hdr_txt):
-            return table
-        if not any(("amount" in c) or ("debit" in c) or ("credit" in c) for c in hdr_txt):
-            return table
-        date_idx = next((i for i, c in enumerate(hdr_txt) if "date" in c), -1)
-        if date_idx < 0:
-            return table
-
-        new_parts: List[str] = []
-        cursor = 0
-        added = 0
-        for i, trm in enumerate(tr_blocks):
-            new_parts.append(table[cursor : trm.start()])
-            tr_seg = trm.group(0)
-            inner_m = re.search(r"<tr\b[^>]*>(.*)</tr>", tr_seg, flags=re.IGNORECASE | re.DOTALL)
-            if not inner_m:
-                new_parts.append(tr_seg)
-                cursor = trm.end()
-                continue
-            tr_open_m = re.search(r"<tr\b[^>]*>", tr_seg, flags=re.IGNORECASE)
-            tr_open = tr_open_m.group(0) if tr_open_m else "<tr>"
-            tr_close = "</tr>"
-            inner = inner_m.group(1)
-            cells = [c.group(0) for c in _CELL.finditer(inner)]
-            if i == 0:
-                new_inner = inner + "<th>Balance</th>"
-                new_parts.append(tr_open + new_inner + tr_close)
-            else:
-                if date_idx >= len(cells):
-                    new_parts.append(tr_seg)
-                    cursor = trm.end()
-                    continue
-                d_txt = _cell_plain_text(cells[date_idx])
-                dm = re.search(r"\d{1,2}/\d{1,2}(?:/\d{2,4})?", d_txt or "")
-                bal = dmap.get(dm.group(0)) if dm else None
-                if bal is None and dm:
-                    bal = dmap.get("/".join(dm.group(0).split("/")[:2]))
-                if bal is None:
-                    new_parts.append(tr_seg)
-                    cursor = trm.end()
-                    continue
-                new_inner = inner + f"<td>{bal:,.2f}</td>"
-                new_parts.append(tr_open + new_inner + tr_close)
-                added += 1
-            cursor = trm.end()
-        new_parts.append(table[cursor:])
-        if added < 3:
-            return table
-        return "".join(new_parts)
-
-    return re.sub(r"<table\b[^>]*>.*?</table>", repl, md, flags=re.IGNORECASE | re.DOTALL)
-
-
-def _parse_statement_edge_balances(md: str):
-    start = None
-    end = None
-    m1 = re.search(
-        r"(?:Beginning|Starting)\s+balance[^$\n]{0,80}\$?\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d{2})?)",
-        md,
-        flags=re.IGNORECASE,
-    )
-    if m1:
-        start = _parse_amount_or_none(m1.group(1))
-    m2 = re.search(
-        r"Ending\s+balance[^$\n]{0,80}\$?\s*(-?\d{1,3}(?:,\d{3})*(?:\.\d{2})?)",
-        md,
-        flags=re.IGNORECASE,
-    )
-    if m2:
-        end = _parse_amount_or_none(m2.group(1))
-    return start, end
-
-
-def synthesize_running_balance_columns(md: str) -> str:
-    """
-    Fallback when no explicit balance column exists: infer running balances from
-    statement beginning/ending balance and signed transaction amounts.
-    """
-    if not md or "<table" not in md.lower():
-        return md
-    start_bal, end_bal = _parse_statement_edge_balances(md)
-    if start_bal is None and end_bal is None:
-        return md
-
-    table_re = re.compile(r"<table\b[^>]*>.*?</table>", re.IGNORECASE | re.DOTALL)
-    tr_re = re.compile(r"<tr\b[^>]*>.*?</tr>", re.IGNORECASE | re.DOTALL)
-
-    tables = list(table_re.finditer(md))
-    row_refs = []
-    amounts = []
-    headers = {}
-
-    for ti, tm in enumerate(tables):
-        t = tm.group(0)
-        if re.search(r"(?:colspan|rowspan)\s*=", t, flags=re.IGNORECASE):
-            continue
-        trs = list(tr_re.finditer(t))
-        if len(trs) < 2:
-            continue
-        h_inner_m = re.search(r"<tr\b[^>]*>(.*)</tr>", trs[0].group(0), flags=re.IGNORECASE | re.DOTALL)
-        if not h_inner_m:
-            continue
-        h_cells = [c.group(0) for c in _CELL.finditer(h_inner_m.group(1))]
-        if not h_cells:
-            continue
-        htxt = [_cell_plain_text(c).strip().lower() for c in h_cells]
-        if any("balance" in h for h in htxt):
-            continue
-        date_idx = next((i for i, h in enumerate(htxt) if "date" in h), -1)
-        amt_idx = next((i for i, h in enumerate(htxt) if "amount" in h or "debit" in h or "credit" in h), -1)
-        if date_idx < 0 or amt_idx < 0:
-            continue
-        headers[ti] = (date_idx, amt_idx)
-        for ri, trm in enumerate(trs[1:], 1):
-            inner_m = re.search(r"<tr\b[^>]*>(.*)</tr>", trm.group(0), flags=re.IGNORECASE | re.DOTALL)
-            if not inner_m:
-                continue
-            cells = [c.group(0) for c in _CELL.finditer(inner_m.group(1))]
-            if len(cells) <= max(date_idx, amt_idx):
-                continue
-            d_txt = _cell_plain_text(cells[date_idx])
-            if not re.search(r"\d{1,2}/\d{1,2}(?:/\d{2,4})?", d_txt or ""):
-                continue
-            amt = _parse_amount_or_none(_cell_plain_text(cells[amt_idx]))
-            if amt is None:
-                continue
-            row_refs.append((ti, ri))
-            amounts.append(amt)
-
-    if len(amounts) < 20:
-        return md
-    if start_bal is None:
-        start_bal = (end_bal or 0.0) - sum(amounts)
-
-    running = []
-    cur = float(start_bal)
-    for a in amounts:
-        cur += float(a)
-        running.append(cur)
-    bal_by_ref = {row_refs[i]: running[i] for i in range(len(row_refs))}
-
-    pieces = []
-    last = 0
-    for ti, tm in enumerate(tables):
-        pieces.append(md[last : tm.start()])
-        t = tm.group(0)
-        if ti not in headers:
-            pieces.append(t)
-            last = tm.end()
-            continue
-        date_idx, amt_idx = headers[ti]
-        trs = list(tr_re.finditer(t))
-        out_t = []
-        cur2 = 0
-        for idx, trm in enumerate(trs):
-            out_t.append(t[cur2 : trm.start()])
-            tr_seg = trm.group(0)
-            inner_m = re.search(r"<tr\b[^>]*>(.*)</tr>", tr_seg, flags=re.IGNORECASE | re.DOTALL)
-            tr_open_m = re.search(r"<tr\b[^>]*>", tr_seg, flags=re.IGNORECASE)
-            tr_open = tr_open_m.group(0) if tr_open_m else "<tr>"
-            if not inner_m:
-                out_t.append(tr_seg)
-                cur2 = trm.end()
-                continue
-            inner = inner_m.group(1)
-            if idx == 0:
-                out_t.append(tr_open + inner + "<th>Balance</th></tr>")
-            else:
-                b = bal_by_ref.get((ti, idx))
-                if b is None:
-                    out_t.append(tr_seg)
-                else:
-                    out_t.append(tr_open + inner + f"<td>{b:,.2f}</td></tr>")
-            cur2 = trm.end()
-        out_t.append(t[cur2:])
-        pieces.append("".join(out_t))
-        last = tm.end()
-    pieces.append(md[last:])
-    return "".join(pieces)
-
-
-def _extract_txn_date_balance_pairs(md: str):
-    pairs = []
-    for tm in re.finditer(r"<table\b[^>]*>.*?</table>", md, flags=re.IGNORECASE | re.DOTALL):
-        t = tm.group(0)
-        rows = _extract_rows_plain_from_table(t)
-        if len(rows) < 2:
-            continue
-        hdr = [c.strip().lower() for c in rows[0]]
-        if not hdr:
-            continue
-        d_i = next((i for i, h in enumerate(hdr) if "date" in h), -1)
-        b_i = next((i for i, h in enumerate(hdr) if "balance" in h), -1)
-        a_i = next((i for i, h in enumerate(hdr) if "amount" in h or "debit" in h or "credit" in h), -1)
-        if d_i < 0 or b_i < 0 or a_i < 0:
-            continue
-        for r in rows[1:]:
-            if len(r) <= max(d_i, b_i):
-                continue
-            dm = re.search(r"\d{1,2}/\d{1,2}(?:/\d{2,4})?", (r[d_i] or ""))
-            if not dm:
-                continue
-            bal = _parse_amount_or_none(r[b_i])
-            if bal is None:
-                continue
-            pairs.append((dm.group(0), bal))
-    return pairs
-
-
-def augment_with_derived_balance_views(md: str) -> str:
-    """
-    Add a compact derived daily balance table and inferred beginning/ending summary
-    when the document lacks a robust explicit daily balance section.
-    """
-    if not md:
-        return md
-    # If there is already a clear daily-balance section, keep output unchanged.
-    if re.search(r"daily\s+(?:ledger\s+)?balances", md, flags=re.IGNORECASE):
-        return md
-
-    pairs = _extract_txn_date_balance_pairs(md)
-    if len(pairs) < 12:
-        return md
-
-    by_day = {}
-    for d, b in pairs:
-        k = "/".join(d.split("/")[:2])
-        by_day[k] = b
-    if len(by_day) < 8:
-        return md
-
-    days = sorted(
-        by_day.keys(),
-        key=lambda x: (int(x.split("/")[0]), int(x.split("/")[1])),
-    )
-    begin = by_day[days[0]]
-    end = by_day[days[-1]]
-
-    has_begin = bool(re.search(r"(?:beginning|starting)\s+balance", md, flags=re.IGNORECASE))
-    has_end = bool(re.search(r"ending\s+balance", md, flags=re.IGNORECASE))
-
-    rows = ["<tr><th>Date</th><th>Balance</th></tr>"]
-    for d in days:
-        rows.append(f"<tr><td>{html.escape(d)}</td><td>{by_day[d]:,.2f}</td></tr>")
-    daily_tbl = "<table>\n" + "\n".join(rows) + "\n</table>"
-
-    extra = ["", "<div align=\"center\">Derived daily balances</div>", daily_tbl]
-    if not has_begin or not has_end:
-        extra.insert(
-            0,
-            (
-                f"Inferred beginning balance: {begin:,.2f}\n"
-                f"Inferred ending balance: {end:,.2f}"
-            ),
-        )
-    return md.rstrip() + "\n\n" + "\n\n".join(extra) + "\n"
-
-
-def prepend_balance_snapshot(md: str) -> str:
-    """
-    Add a compact, explicit balance snapshot near the top so downstream metadata
-    extraction consistently captures beginning/ending balances.
-    """
-    if not md:
-        return md
-    if "balance snapshot" in md.lower():
-        return md
-
-    start_bal, end_bal = _parse_statement_edge_balances(md)
-    if start_bal is None and end_bal is None:
-        # Try account-summary table fallback
-        for tm in re.finditer(r"<table\b[^>]*>.*?</table>", md, flags=re.IGNORECASE | re.DOTALL):
-            rows = _extract_rows_plain_from_table(tm.group(0))
-            for r in rows:
-                if len(r) < 2:
-                    continue
-                key = (r[0] or "").strip().lower()
-                val = _parse_amount_or_none(r[1] if len(r) > 1 else "")
-                if val is None:
-                    continue
-                if start_bal is None and ("beginning balance" in key or "starting balance" in key):
-                    start_bal = val
-                if end_bal is None and "ending balance" in key:
-                    end_bal = val
-            if start_bal is not None or end_bal is not None:
-                break
-    if start_bal is None and end_bal is None:
-        return md
-
-    lines = ["## Balance Snapshot"]
-    if start_bal is not None:
-        lines.append(f"Beginning balance: {start_bal:,.2f}")
-    if end_bal is not None:
-        lines.append(f"Ending balance: {end_bal:,.2f}")
-    header = "\n".join(lines)
-    return header + "\n\n" + md
-
-
 def render_pdf_pages_to_images(pdf_path: str) -> Tuple[List[str], List[int]]:
     import pymupdf as fitz
     from PIL import Image
@@ -2058,44 +1201,10 @@ def render_pdf_pages_to_images(pdf_path: str) -> Tuple[List[str], List[int]]:
             canvas.paste(img, (pad_l, pad_t))
             img = canvas
 
-        # Deterministic guardrail: downscale oversized pages before upload.
-        iw, ih = img.size
-        long_side = max(iw, ih)
-        total_px = iw * ih
-        if long_side > MAX_PAGE_LONG_SIDE or total_px > MAX_PAGE_TOTAL_PIXELS:
-            scale_long = MAX_PAGE_LONG_SIDE / float(long_side)
-            scale_area = (MAX_PAGE_TOTAL_PIXELS / float(total_px)) ** 0.5
-            scale = min(scale_long, scale_area, 1.0)
-            nw = max(900, int(iw * scale))
-            nh = max(900, int(ih * scale))
-            img = img.resize((nw, nh), Image.Resampling.LANCZOS)
-
-        base_path = os.path.join(tempfile.gettempdir(), f"glmocr_page_{os.getpid()}_{i}")
-        img_path = f"{base_path}.png"
+        # Include a per-run unique tag to avoid filename collisions across parallel local runs.
+        uniq = uuid.uuid4().hex[:10]
+        img_path = os.path.join(tempfile.gettempdir(), f"glmocr_page_{os.getpid()}_{uniq}_{i}.png")
         img.save(img_path, "PNG", compress_level=PAGE_PNG_COMPRESS_LEVEL)
-        try:
-            size_bytes = os.path.getsize(img_path)
-        except OSError:
-            size_bytes = 0
-        if size_bytes > MAX_PAGE_UPLOAD_BYTES:
-            jpg_path = f"{base_path}.jpg"
-            quality = PAGE_JPEG_QUALITY
-            work = img
-            for _ in range(5):
-                work.save(jpg_path, "JPEG", quality=quality, optimize=True)
-                try:
-                    jsize = os.path.getsize(jpg_path)
-                except OSError:
-                    jsize = 0
-                if 0 < jsize <= MAX_PAGE_UPLOAD_BYTES:
-                    img_path = jpg_path
-                    break
-                quality = max(68, quality - 6)
-                nw = max(900, int(work.width * 0.93))
-                nh = max(900, int(work.height * 0.93))
-                work = work.resize((nw, nh), Image.Resampling.LANCZOS)
-            else:
-                img_path = jpg_path
         page_images.append(img_path)
         page_heights.append(img.height)
 
@@ -2204,17 +1313,6 @@ def run_ocr(uploaded_file):
 
         merged = "\n\n---page-separator---\n\n".join(all_pages) if all_pages else "(No content)"
         if merged and merged != "(No content)" and not merged.lstrip().startswith("Error:"):
-            merged = strip_malformed_leading_table_rows(merged)
-            merged = strip_subtotal_rows_from_transaction_tables(merged)
-            merged = mask_non_monetary_long_numbers(merged)
-            merged = normalize_ambiguous_amount_balance_tables(merged)
-            merged = normalize_amount_only_transaction_tables(merged)
-            merged = infer_credit_debit_from_balance_deltas(merged)
-            merged = sanitize_transaction_tables(merged)
-            merged = stabilize_table_markup(merged, rounds=4)
-            merged = enrich_transaction_tables_with_daily_balances(merged)
-            # Keep transaction amounts untouched; add explicit snapshot for metadata extraction.
-            merged = prepend_balance_snapshot(merged)
             merged = stabilize_table_markup(merged, rounds=2)
             merged = repair_thead_cell_semantics(merged)
             merged = strip_degenerate_html_tables(merged)
@@ -2229,11 +1327,7 @@ def run_ocr(uploaded_file):
     finally:
         for p in page_images:
             try:
-                if (
-                isinstance(p, str)
-                and "glmocr_page_" in os.path.basename(p)
-                and (p.endswith(".png") or p.endswith(".jpg") or p.endswith(".jpeg"))
-            ):
+                if isinstance(p, str) and p.endswith(".png") and "glmocr_page_" in os.path.basename(p):
                     os.unlink(p)
             except Exception:
                 pass