@@ -68,6 +68,14 @@ def gpu_family_key(slug: str) -> str:
     tokens = _tokens(slug)
     if len(tokens) > 1 and tokens[0] == "quadro" and _QUADRO_RENAMED_RE.fullmatch(tokens[1]):
         tokens = tokens[1:]
+    # "Quadro4 200 NVS" is "NVS 200".
+    if tokens[:1] == ["quadro4"] and tokens[-1:] == ["nvs"]:
+        tokens = ["nvs", *tokens[1:-1]]
+    # "X800 XT PE" is the X800 XT Platinum Edition.
+    tokens = [
+        "platinum" if token == "pe" and tokens[i - 1 : i] == ["xt"] else token
+        for i, token in enumerate(tokens)
+    ]
     # "Radeon Instinct MI100" became "Instinct MI100".
     if tokens[:2] == ["radeon", "instinct"]:
         tokens = tokens[1:]
 
@@ -85,12 +85,16 @@ def parse_tdp_w(text: str) -> int | None:
 
     ``"45 W (35–54 W)"`` → ``45``: the default precedes its cTDP range. A cell
     that is only a range (``"12–25 W"``) states no default, so it gives ``None``;
-    neither end of the range is the part's TDP.
+    neither end of the range is the part's TDP. Two bare numbers before the
+    unit (``"92.6 68 W"``) are two parts' values and give ``None`` too.
     """
     if not text:
         return None
-    match = _TDP_RE.search(_TDP_RANGE_RE.sub(" ", text))
-    return math.floor(float(match.group(1)) + 0.5) if match else None
+    cleaned = _TDP_RANGE_RE.sub(" ", text)
+    match = _TDP_RE.search(cleaned)
+    if match is None or re.search(r"\d\s+$", cleaned[: match.start()]):
+        return None  # "92.6 68 W": one value per OPN, so neither is the part's
+    return math.floor(float(match.group(1)) + 0.5)
 
 
 def parse_frequency_range_ghz(text: str) -> tuple[float, float] | None:
 
@@ -10,11 +10,13 @@
 import json
 from collections import Counter
 from collections.abc import Iterable
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from datetime import date
 from pathlib import Path
 from typing import Any
 
+from app.coverage.normalize import slugify
+
 from .cpu_identity import cpu_key, same_cpu
 from .gpu_identity import (
     datacenter_family,
@@ -139,6 +141,11 @@ def add(self, record: dict[str, Any], path: str, manufacturer: str) -> None:
         if not isinstance(slug, str) or not slug:
             return
         names: list[object] = [slug]
+        # The curated name can be spelled unlike the slug: "3D Rage II" is
+        # rage-ii.json, "iPhone SE (2nd generation)" iphone-se-2020.json.
+        display = record.get("name")
+        if isinstance(display, str) and display:
+            names.append(slugify(display, manufacturer=manufacturer))
         if self.category == "smartphone":
             # A variant record (".../2022/galaxy-m33-5g/sm-m336b.json") names
             # its phone in base_model_slug and in its folder.
@@ -150,14 +157,30 @@ def add(self, record: dict[str, Any], path: str, manufacturer: str) -> None:
             if isinstance(name, str) and name:
                 self.slugs.setdefault(name, path)
                 self.keys.setdefault(self._key(name), path)
-        if self.category == "gpu":
-            self.families.setdefault(gpu_family_key(slug), path)
+                if self.category == "gpu":
+                    self.families.setdefault(gpu_family_key(name), path)
 
     def _key(self, slug: str) -> str:
-        return gpu_key(slug) if self.category == "gpu" else slug.replace("-", "")
+        if self.category == "gpu":
+            return gpu_key(slug)
+        tokens = slug.split("-")
+        if self.category == "smartphone":
+            # "iPhone SE (2nd)" and "iPhone SE (2nd generation)".
+            tokens = [token for token in tokens if token not in {"gen", "generation"}]
+        return "".join(tokens)
 
     def match(self, candidate: IngestCandidate) -> tuple[str, str] | None:
-        """``(path, why)`` of the record the candidate duplicates, or ``None``."""
+        """``(path, why)`` of the record the candidate or one of its
+        ``aliases`` duplicates, or ``None``."""
+        if (found := self._match(candidate)) is not None:
+            return found
+        for alias in candidate.aliases:
+            if (found := self._match(replace(candidate, slug=alias))) is not None:
+                path, why = found
+                return path, f"as {alias}: {why}"
+        return None
+
+    def _match(self, candidate: IngestCandidate) -> tuple[str, str] | None:
         target = candidate.output_path.as_posix()
         if target in self.paths:
             return target, f"path {target} already exists"
 
@@ -21,7 +21,8 @@ class IngestCandidate:
     fill but that cannot be trusted; such a candidate is never written, not
     even as a draft. ``released_by`` is the last day of the release period the
     source states (``"Q4 2026"`` → Dec 31): before it, the part may not have
-    shipped.
+    shipped. ``aliases`` are other slugs the part may be curated under (a
+    laptop-table row named without "Mobile"); dedup checks them too.
     """
 
     category: str
@@ -33,6 +34,7 @@ class IngestCandidate:
     missing_fields: tuple[str, ...] = field(default_factory=tuple)
     problems: tuple[str, ...] = field(default_factory=tuple)
     released_by: date | None = None
+    aliases: tuple[str, ...] = field(default_factory=tuple)
 
     @property
     def is_complete(self) -> bool:
 
@@ -197,6 +197,10 @@ def parse_cpu_table(table: Tag) -> Iterator[dict[str, str]]:
                 column += 1
             for sup in cell.find_all("sup"):
                 sup.decompose()
+            # {{0}} pads numbers with a hidden "0" ("065 W" shows as " 65 W").
+            for pad in cell.select('[aria-hidden="true"]'):
+                if "visibility:hidden" in str(pad.get("style", "")).replace(" ", ""):
+                    pad.decompose()
             text = re.sub(r"\[[^\]]*\]", "", cell.get_text(" ", strip=True)).strip()
             width = min(_span(cell, "colspan"), 64 - column)
             for offset in range(width):
@@ -228,6 +232,11 @@ def parse_cpu_table(table: Tag) -> Iterator[dict[str, str]]:
         parts = list(dict.fromkeys(row[column] for row in grid[start:end] if column < len(row)))
         labels.append(" / ".join(parts))
     fields = [_field(label) for label in labels]
+    # "Base / Min" and "Base / Max" pair with "TDP / Min" and "TDP / Max", and
+    # either one can be the nominal TDP's base (11980HK: Min, 11800H: Max).
+    leaves = {label.lower().split(" / ")[-1].strip() for label in labels if "base" in label.lower()}
+    if {"min", "max"} <= leaves:
+        fields = [None if field == "base_clock" else field for field in fields]
     # A colspan Model heading describes two distinct body columns.
     for column in range(len(fields) - 1):
         if fields[column : column + 2] == ["model", "model"]:
 
@@ -323,7 +323,11 @@ def _build_candidate(
 
     required = ("release_date", "architecture", "cores", "threads")
     missing = tuple(field for field in required if record.get(field) in (None, ""))
-    problems = (row["cores_note"],) if row.get("cores_note") else ()
+    problems: tuple[str, ...] = (row["cores_note"],) if row.get("cores_note") else ()
+    if release_date is None:
+        # The layout files a part under its release year; without one there is
+        # no folder to put it in, even as a draft.
+        problems += ("no release date to file it under",)
 
     year = release_date.year if release_date else "unknown"
     bucket = "enterprise" if segment in ("server", "hedt") else "consumer"
 
@@ -54,8 +54,6 @@
     ("intel", "List_of_Intel_graphics_processing_units", "Intel Graphics"),
 ]
 
-_BRAND_DISPLAY: dict[str, str] = {"nvidia": "NVIDIA", "amd": "AMD", "ati": "ATI", "intel": "Intel"}
-
 # The dataset keeps ATI-branded boards under ``ati``; AMD retired the ATI brand
 # in August 2010 and the curated records switch to ``amd`` from October 2010.
 _ATI_BRAND_END = date(2010, 10, 1)
@@ -69,14 +67,17 @@
     "DDR5", "DDR4", "DDR3", "DDR2", "DDR", "SDRAM", "SDR",
 )
 _MEMORY_TYPE_DISPLAY = {"HBM2E": "HBM2e", "HBM3E": "HBM3e"}
+# Types the curated records spell their own way ("SGRAM", "EDO DRAM"): a cell
+# naming one of them states no type from MEMORY_TYPES.
+_OTHER_MEMORY_RE = re.compile(r"(?<![A-Z0-9])(?:SGRAM|EDO|VRAM|WRAM|FPM|DRAM)(?![A-Z0-9])")
 
 _NUMBER_RE = re.compile(r"\d[\d,]*(?:\.\d+)?")
 _RANGE_RE = re.compile(r"(\d[\d,]*(?:\.\d+)?)\s*(?:–|—|-|to)\s*(\d[\d,]*(?:\.\d+)?)")
 _FOOTNOTE_RE = re.compile(r"\s*\[[^\]]{1,12}\]")
 _TRAILING_PAREN_RE = re.compile(r"\s*\([^)]*\)\s*$")
 _MULTI_GPU_RE = re.compile(r"\d\s*[×x]\s*\d")
 _BUS_RE = re.compile(r"\b(PCIe|PCI-E|PCI Express|AGP|PCI|MXM(?:-[A-Z]+)?)\b[^/,;]*", re.IGNORECASE)
-_BUS_NAME_RE = re.compile(r"\b(PCIe|AGP|PCI|MXM)\b", re.IGNORECASE)
+_BUS_NAME_RE = re.compile(r"\b(PCIe|AGP|PCI|MXM|ISA|EISA|VLB|VL-Bus|MCA)\b", re.IGNORECASE)
 # Integrated/chipset graphics are out of scope for the discrete-GPU table.
 _OUT_OF_SCOPE_RE = re.compile(r"\bIGP\b|integrated|on-?die|\bAPU\b|nForce", re.IGNORECASE)
 # Chipset IGPs: a memory cell naming only system memory ("Up to 256 from system
@@ -93,6 +94,7 @@
     r"\b(?:mobile|mobility|laptop|notebook|max-q|go)\b|\b[a-z]?\d{2,5}m[a-z]*\b|\bm\d{3,4}|\bmx\s?\d",
     re.IGNORECASE,
 )
+_LAPTOP_TIER_RE = re.compile(r"\b(?:mobile|laptop|notebook)\b")
 _BRAND_WORD_RE = re.compile(r"\b(?:geforce|radeon|quadro|firepro|firegl|tesla)\b", re.IGNORECASE)
 # "Clock Rate / Base (Boost) ( MHz )": "1291 (1392)" is base 1291, boost 1392.
 _BASE_BOOST_RE = re.compile(r"\b(?:base|core)\b[^/]*\(\s*boost|\bbase boost\b")
@@ -128,8 +130,13 @@
     (r"NV2\d", "Kelvin"),
     (r"NV3\d", "Rankine"),
     (r"NV4\d|G7\d", "Curie"),
-    (r"G8\d|G9\d|GT2\d\d", "Tesla"),
+    # Curated records name the second generations (GT200, GF11x, GK2xx) per
+    # chip; the versioned entries come before the generic ones.
+    (r"GT2\d\d", "Tesla 2.0"),
+    (r"G8\d|G9\d", "Tesla"),
+    (r"GF11\d", "Fermi 2.0"),
     (r"GF1\d\d", "Fermi"),
+    (r"GK2\d\d", "Kepler 2.0"),
     (r"GK\d", "Kepler"),
     (r"GM\d", "Maxwell"),
     (r"GP\d", "Pascal"),
@@ -269,6 +276,8 @@ def _memory_gb(text: str, unit: str) -> float | None:
 def _memory_type(text: str) -> str | None:
     """The memory type a cell names; ``None`` when it names several."""
     upper = text.upper()
+    if _OTHER_MEMORY_RE.search(upper):
+        return None
     kinds = [
         kind
         for kind in MEMORY_TYPES
@@ -279,9 +288,16 @@ def _memory_type(text: str) -> str | None:
 
 def _release_period(text: str) -> tuple[date, date] | None:
     """The release period a cell names; ``None`` for several dates or a ``?``."""
-    cleaned = _FOOTNOTE_RE.sub("", text)
-    if "?" in cleaned:
+    if "?" in text:
         return None
+    periods = _cell_periods(text)
+    return periods.pop() if len(periods) == 1 else None
+
+
+def _cell_periods(text: str) -> set[tuple[date, date]]:
+    """Every date period a cell names: ``"May 1, 2007 (PCIe) October 1, 2007 (AGP)"``
+    names two, ``"2004?"`` one."""
+    cleaned = _FOOTNOTE_RE.sub("", text)
     taken: list[tuple[int, int]] = []
     periods: set[tuple[date, date]] = set()
     for pattern in _DATE_IN_CELL_RES:
@@ -291,7 +307,7 @@ def _release_period(text: str) -> tuple[date, date] | None:
             taken.append(match.span())
             if (period := parse_date_period(match.group(0))) is not None:
                 periods.add(period)
-    return periods.pop() if len(periods) == 1 else None
+    return periods
 
 
 def normalize_bus_interface(text: str) -> str | None:
@@ -311,6 +327,9 @@ def normalize_bus_interface(text: str) -> str | None:
     if not match:
         return None
     if match.group(1).lower() != "pcie":
+        # "AGP 4x,8x": board variants again.
+        if len(set(re.findall(r"(\d+)\s*x\b", cleaned[match.start() :]))) > 1:
+            return None
         value = match.group(0)
         value = re.sub(r"\s+x\s*(\d+)", r" x\1", value)
         value = re.sub(r"(\d)\s*x\b", r"\1x", value)
@@ -418,18 +437,29 @@ def unit(key: str) -> str:
         # "2× 128": per-GPU values on dual-GPU boards don't fit one record.
         return None
     problems: tuple[str, ...] = ()
-    if headings and headings[-1].lower().startswith("mobile") and not _LAPTOP_MARKER_RE.search(
-        raw_model
-    ):
+    laptop_table = bool(headings) and headings[-1].lower().startswith("mobile")
+    if laptop_table and not _LAPTOP_MARKER_RE.search(raw_model):
         problems = ("laptop table row without a laptop marker in its name",)
 
     release_period = _release_period(text("release_date"))
     release_date = release_date_of(release_period)
-    if manufacturer == "amd" and release_period is not None and release_period[1] < _ATI_BRAND_END:
+    # Before the rebrand by every date the cell names ("2004?", "May 1, 2007
+    # (PCIe) October 1, 2007 (AGP)"), even when no one date is the release.
+    periods = _cell_periods(text("release_date"))
+    if manufacturer == "amd" and periods and all(last < _ATI_BRAND_END for _, last in periods):
         manufacturer = "ati"
     slug = slugify(model, manufacturer=manufacturer)
     if len(slug) < 4 or not any(ch.isdigit() for ch in slug):
         return None
+    if release_date is None:
+        # The layout files a board under its release year; without one there
+        # is no folder to put it in, even as a draft.
+        problems += ("no release date to file it under",)
+    # "Quadro M5500" in a laptop table is the laptop part, curated as "Quadro
+    # M5500 Mobile"; dedup checks that name too.
+    aliases: tuple[str, ...] = ()
+    if laptop_table and not _LAPTOP_TIER_RE.search(slug):
+        aliases = (f"{slug}-mobile",)
 
     base_clock = _clock_mhz(text("base_clock"), unit("base_clock"))
     boost_clock = _clock_mhz(
@@ -467,8 +497,8 @@ def unit(key: str) -> str:
         architecture_from_codename(text("codename"), manufacturer)
     )
 
-    brand = _BRAND_DISPLAY.get(manufacturer, manufacturer.title())
-    name = model if model.lower().startswith(manufacturer) else f"{brand} {model}"
+    # Dataset GPU names leave the brand to ``manufacturer``: "GeForce GTX 1660 Ti".
+    name = re.sub(r"^(?:NVIDIA|AMD|ATI|Intel)\s+", "", model, flags=re.IGNORECASE)
     record: dict[str, object | None] = {
         "slug": slug,
         "name": name,
@@ -503,4 +533,5 @@ def unit(key: str) -> str:
         missing_fields=missing,
         problems=problems,
         released_by=release_period[1] if release_period else None,
+        aliases=aliases,
     )
@@ -51,7 +51,6 @@
 from bs4 import BeautifulSoup, Tag
 
 from app.ingest.normalize import (
-    mib_to_gb,
     parse_date,
     parse_frequency_mhz,
     parse_memory_bus_bit,
@@ -230,13 +229,15 @@ def crossref_pages() -> list[tuple[str, str, str]]:
 # --- name split -----------------------------------------------------------------
 
 
-def _to_gb(value: float, unit: str) -> float | None:
+def _to_gb(value: float, unit: str) -> float:
+    """Binary GB, unrounded. Unlike ``mib_to_gb`` there is no 1 MiB floor: that
+    is a rule for writing a record, and the backfill only compares values."""
     unit_l = unit.lower()
     if unit_l == "gb":
         return value
     if unit_l == "mb":
-        return mib_to_gb(value)
-    return mib_to_gb(value / 1024)
+        return value / 1024
+    return value / (1024 * 1024)
 
 
 def memory_close(left: float, right: float) -> bool:
@@ -315,13 +316,13 @@ def parse_memory_options(text: str) -> tuple[float, ...]:
             if not piece:
                 continue
             value = _to_gb(float(piece), unit)
-            if value is not None and value not in found:
+            if value not in found:
                 found.append(value)
     for match in _MEMORY_TOKEN_RE.finditer(text):
         if any(start <= match.start() < end for start, end in consumed):
             continue
         value = _to_gb(float(match.group(1)), match.group(2))
-        if value is not None and value not in found:
+        if value not in found:
             found.append(value)
     return tuple(found)
 
@@ -419,7 +420,7 @@ def _bare_memory(text: str, unit: str) -> tuple[float, ...]:
     found: list[float] = []
     for number in numbers:
         value = _to_gb(float(number), unit)
-        if value is not None and value not in found:
+        if value not in found:
             found.append(value)
     return tuple(found)
 
 
@@ -83,8 +83,9 @@ over. A field is filled only when its cell states one value: a range, an
 estimate, a cell listing variants, or a year or half-year alone leaves it empty
 (neither end of a range stands in), and a row that then misses a required
 field is skipped. Laptop parts are their own records (`-mobile`), integrated
-GPUs are out of scope, and a phone without a release date has no
-`<year>` folder, so it is not written. Both run on manual dispatch
+GPUs are out of scope, GPU names leave the brand to `manufacturer`, and a
+record without a release date has no `<year>` folder, so it is not written
+even as a draft. Both run on manual dispatch
 and their output goes to TechAPI as a PR for human review before anything
 lands (SPEC Section 9.3). The curated
 dataset is a **subset, not exhaustive.**