Tighten heat_code extractor: reject standards numbers + material specs

Production extractor was returning 8 codes from 10720.pdf when only
2 are real heat codes. False positives were fragments of standards
references that the OCR fallback was grabbing because they appear
near 'Heat Code' headers in the doc text:
- 0103 from 'NACE MR 0103'
- 0175 from 'MR 0175'
- 2015 from 'ISO 9001:2015'
- 15156 from 'ISO 15156'
- 17945 from 'ISO 17945'
- A106B from '1/2 X 4 XH A106B SMLS TBE NIPPLE' (material spec)

Three fixes:
1) Expand year regex from 20[2-3]\d to 20[0-3]\d (catches 2015 etc).
2) Add material-spec pattern A\d{3}[A-Z] for A106B / A105N / A234B.
Distinct from real heat codes like A8633 (4 digits, no trailing
letter) so no regression on those.
3) New _collect_standards_numbers() scans the document text for
ISO/NACE/ASTM/ASME/EN/DIN/API/AISI/JIS/MSS/PED prefixes and
adds the trailing standard numbers to a reject set. The filter
rejects candidates that match any of those tokens.

Validated against all 10 sample MTRs — A8633, KB419-1 (six codes),
D460, SD55822, Y211213D40-1, 24L0604, VC9387 all still extract
correctly. Forced-OCR-path test on 10720.pdf now returns just
['10720', '114420'] — all 6 false positives killed.

app/lib/utils/heat_code.py

@@ -92,8 +92,38 @@ _REJECT_WORDS: frozenset[str] = frozenset({
 # Spec number patterns to reject (e.g., A312, SA-105, A105-21).
 _SPEC_NUM_RE = re.compile(r"^[A-Z]{1,4}-?\d{2,5}(-\d{1,3})?$", re.IGNORECASE)
 
-# Year-like standalone tokens (2020-2030).
-_YEAR_RE = re.compile(r"^(20[2-3]\d)$")
+# Year-like standalone tokens (2010-2039). Expanded from 2020-2030 because
+# MTRs reference older standards years like "ISO 9001:2015" and Tesseract
+# may misread small text producing tokens in this range.
+_YEAR_RE = re.compile(r"^(20[0-3]\d)$")
+
+# Material-spec pattern: "A106B", "A105N", "A234B" — letter A + 3 digits +
+# single trailing letter. ASTM material grade specs. Distinct from real
+# heat codes like "A8633" (letter + 4 digits, no trailing letter).
+_MATERIAL_SPEC_RE = re.compile(r"^A\d{3}[A-Z]$", re.IGNORECASE)
+
+# Standards-prefix patterns: anywhere in the document text, if a token
+# follows one of these prefixes, that token is a standards reference, NOT
+# a heat code. Examples: "ISO 15156", "NACE MR 0103", "ASTM A312", "EN 10204".
+# The capture group is the standards number we want to reject.
+_STANDARDS_REFERENCE_RES: tuple[re.Pattern[str], ...] = (
+    re.compile(r"\bISO\s+(\d{3,6})\b", re.IGNORECASE),
+    re.compile(r"\bNACE\s*MR\s*(\d{3,6})\b", re.IGNORECASE),
+    re.compile(r"\bMR\s*(\d{3,6})\b", re.IGNORECASE),
+    re.compile(r"\bASTM\s+([A-Z]?\d{3,5}[A-Z]?(?:-\d{1,3})?)\b", re.IGNORECASE),
+    re.compile(r"\bASME\s+(?:SA-?)?([A-Z]?\d{2,5}[A-Z]?(?:[.\-]\d{1,4})?)\b", re.IGNORECASE),
+    re.compile(r"\bEN\s+(\d{3,6}(?::\d{4})?)\b", re.IGNORECASE),
+    re.compile(r"\bDIN\s+(\d{3,6})\b", re.IGNORECASE),
+    re.compile(r"\bAPI\s+(\d+L?)\b", re.IGNORECASE),
+    re.compile(r"\bAISI\s+(\d{3,4}[A-Z]?)\b", re.IGNORECASE),
+    re.compile(r"\bJIS\s+(\w+)\b", re.IGNORECASE),
+    re.compile(r"\bMSS\s*SP\s*(\d{1,4})\b", re.IGNORECASE),
+    re.compile(r"\bPED\s+(\d{4}/\d{2}/[A-Z]+)\b", re.IGNORECASE),
+    # "ISO 9001:2015" — both numbers are bad
+    re.compile(r"(\d{4}):(\d{4})"),
+    # "A106/A106M-18" or "SA106/SA106M" — slash-separated material specs
+    re.compile(r"\b([A-Z]?\d{3,4}[A-Z]?(?:-\d{1,3})?)/([A-Z]?\d{3,4}[A-Z]?(?:-\d{1,3})?)\b"),
+)
 
 
 # ─── Public API ────────────────────────────────────────────────────────────────
@@ -146,8 +176,19 @@ def extract_heat_codes(file_bytes: bytes, filename: str | None = None) -> list[s
         except Exception as e:
             logger.debug("OCR fallback failed: %s", e)
 
+    # Build the set of tokens that appear as standards-references in the
+    # document text. Combine text_layer + ocr_text if both were collected.
+    combined_text = text_layer
+    if not candidates or len(text_layer) < 500:
+        # OCR fallback may have produced text we should also scan.
+        try:
+            combined_text = (text_layer or "") + "\n" + _ocr_text(file_bytes)
+        except Exception:
+            pass
+    standards_tokens = _collect_standards_numbers(combined_text)
+
     # Filter + dedupe (case-insensitive on code; preserve first-seen casing)
-    filtered = _filter_and_dedupe(candidates)
+    filtered = _filter_and_dedupe(candidates, standards_tokens)
 
     if logger.isEnabledFor(logging.DEBUG):
         logger.debug(
@@ -375,10 +416,43 @@ def _tokenize_cell(cell_text: str) -> list[str]:
     return [t.strip() for t in re.split(r"[\s,;|]+", cell_text) if t.strip()]
 
 
-def _filter_and_dedupe(candidates: list[tuple[str, str]]) -> list[str]:
+def _collect_standards_numbers(doc_text: str) -> set[str]:
+    """Scan document text for standards references (ISO 15156, NACE MR 0103,
+    ASTM A312, EN 10204, etc.) and return the set of standard-number tokens
+    that should never be treated as heat codes.
+
+    Returned tokens are uppercased and stripped of leading non-alphanumerics
+    so they can be compared directly against `code.upper()` in the filter.
+    """
+    bad: set[str] = set()
+    if not doc_text:
+        return bad
+    for pat in _STANDARDS_REFERENCE_RES:
+        for m in pat.finditer(doc_text):
+            for grp in m.groups():
+                if not grp:
+                    continue
+                tok = re.sub(r"^[^A-Za-z0-9]+", "", grp).upper()
+                if tok:
+                    bad.add(tok)
+                    # Also reject the no-dash form (e.g., "A106-18" → also drop "A106")
+                    no_dash = tok.split("-")[0]
+                    if no_dash != tok:
+                        bad.add(no_dash)
+    return bad
+
+
+def _filter_and_dedupe(
+    candidates: list[tuple[str, str]],
+    standards_tokens: set[str] | None = None,
+) -> list[str]:
     """Apply rejection rules + dedupe case-insensitively, preserving order.
     Also drops substring duplicates: if 'KB419' and 'KB419-1' are both present,
-    keep only the longer one (avoid over-counting when codes get split)."""
+    keep only the longer one (avoid over-counting when codes get split).
+    `standards_tokens` is an optional set of uppercased tokens that were
+    detected as standards references in the document text — these are rejected
+    regardless of their shape."""
+    standards_tokens = standards_tokens or set()
     seen: dict[str, str] = {}   # upper -> original-cased
 
     for code, _source in candidates:
@@ -387,6 +461,8 @@ def _filter_and_dedupe(candidates: list[tuple[str, str]]) -> list[str]:
 
         if upper in seen:
             continue
+        if upper in standards_tokens:
+            continue
         if not _is_plausible_heat_code(code):
             continue
         seen[upper] = code
@@ -411,6 +487,11 @@ def _is_plausible_heat_code(code: str) -> bool:
         return False
     if _YEAR_RE.match(upper):
         return False
+    # Material-spec pattern (A106B, A105N, A234B) — letter A + 3 digits +
+    # single trailing letter. Real heat codes like A8633 have 4 digits and
+    # no trailing letter, so they're not affected.
+    if _MATERIAL_SPEC_RE.match(upper):
+        return False
     # Pipe-spec rejection (40S, 304L, 80SS-style schedule/grade designators).
     if _PIPE_SPEC_RE.match(upper):
         return False