@@ -10,9 +10,19 @@
 
 
 def cpu_key(value: str, manufacturer: str) -> str:
+    # '6275 "Fangio"': a nickname is not part of the model number.
+    value = re.sub(r'\s*"[^"]+"\s*$', "", value)
+    # EPYC "7643 (P)" is 7643P.
+    value = re.sub(r"(\d\w*)\s*\(\s*P\s*\)", r"\1P", value)
     tokens = slugify(value, manufacturer=manufacturer).split("-")
     if tokens and tokens[0] == manufacturer:
         tokens.pop(0)
+    # "Pentium Gold G7400" is the same chip as "Pentium G7400", and the curated
+    # "Opteron X3216 APU" the same as "Opteron X3216".
+    if tokens[:1] == ["pentium"]:
+        tokens = [token for token in tokens if token not in {"gold", "silver"}]
+    if len(tokens) > 1 and tokens[-1] == "apu":
+        tokens.pop()
     # Wikipedia uses both "1700X PRO" and "PRO 1700X" for the same SKU.
     if "pro" in tokens:
         tokens = [token for token in tokens if token != "pro"] + ["pro"]
 
@@ -2,7 +2,9 @@
 
 One board is often listed under several names: ``GeForce3 Ti500`` and
 ``GeForce3 Ti 500``, ``RTX 6000 Ada Generation`` and ``RTX 6000 Ada``, a laptop
-part with and without ``Mobile``, one card per memory size. A candidate that
+part as ``Mobile`` or ``(Notebook)``, one card per memory size, an OEM card,
+``Tesla C2070`` and ``C2070 GPU Computing Module``. A laptop part is never the
+same board as the desktop card of the same name. A candidate that
 matches a curated board under any of those spellings is skipped, never added
 as a second record: a missed addition is cheap, a duplicate is not.
 """
@@ -15,12 +17,22 @@
 _QUALIFIERS = frozenset({
     "agp", "pci", "pcie",  # bus
     "generation", "edition",  # "Ada Generation", "Workstation Edition"
-    "mobile", "laptop", "notebook",  # laptop parts; Max-Q is its own power tier
     "engineering", "sample",
+    "oem",
+    "mxm", "mcm",  # embedded module packages: "E9172 MXM"
+    "cooling",  # "Vega 64 Liquid Cooling"
 })
+# Laptop markers: kept in the family key as one tier word (Max-Q stays as is).
+_LAPTOP_TIER = frozenset({"mobile", "laptop", "notebook"})
+# "H100 GPU accelerator", "C2070 GPU Computing Module": data-center board names
+# that the curated records file as "Tesla C2070" and "H100".
+_DATACENTER_SUFFIX = frozenset({"gpu", "accelerator", "computing", "module"})
+# Form-factor suffixes of data-center boards: Tesla K20c/K20m/K20X, H200 NVL/SXM.
+_FORM_FACTORS = frozenset({"c", "d", "m", "s", "t", "x", "xm", "st", "nvl", "sxm", "pcie"})
 _MEMORY_RE = re.compile(r"\d+(?:gb|mb)")
-# Turing and later workstation boards dropped the Quadro brand ("Quadro T500" is "T500").
-_QUADRO_RENAMED_RE = re.compile(r"(?:t|a|rtx)\d*")
+# Boards that dropped the Quadro brand: Turing and later ("Quadro T500" is "T500"),
+# and the NVS line ("Quadro NVS 50" is "NVS 50").
+_QUADRO_RENAMED_RE = re.compile(r"(?:t|a|rtx)\d*|nvs")
 
 
 def _tokens(slug: str) -> list[str]:
@@ -49,23 +61,51 @@ def gpu_key(slug: str) -> str:
 
 
 def gpu_family_key(slug: str) -> str:
-    """Identity with variant words dropped: bus, memory size, revision, laptop
-    markers, "Generation"/"(Workstation) Edition" and the retired Quadro brand."""
+    """Identity with variant words dropped: bus, memory size, revision, OEM,
+    "Generation"/"(Workstation) Edition", the retired Quadro, Tesla and Radeon
+    Instinct brands and data-center suffixes. The laptop tier stays (``-notebook``
+    is ``-mobile``) except on a Tesla, where it names the MXM module."""
     tokens = _tokens(slug)
     if len(tokens) > 1 and tokens[0] == "quadro" and _QUADRO_RENAMED_RE.fullmatch(tokens[1]):
         tokens = tokens[1:]
+    # "Radeon Instinct MI100" became "Instinct MI100".
+    if tokens[:2] == ["radeon", "instinct"]:
+        tokens = tokens[1:]
+    tesla = len(tokens) > 1 and tokens[0] == "tesla"
+    if tesla:
+        tokens = tokens[1:]
+    while len(tokens) > 1 and tokens[-1] in _DATACENTER_SUFFIX:
+        tokens.pop()
     kept = [
         token
         for i, token in enumerate(tokens)
         if token not in _QUALIFIERS
+        and token not in _LAPTOP_TIER
         and not _MEMORY_RE.fullmatch(token)
         and not re.fullmatch(r"rev\d*", token)
         # "RTX PRO 6000 Blackwell Workstation (Edition)" is the plain board.
         and not (token == "workstation" and tokens[i + 1 : i + 2] in ([], ["edition"]))
     ]
+    # The tier goes last: "RTX 500 Mobile Ada Generation" is "RTX 500 Ada Mobile".
+    # A "Tesla M6 Mobile" is the MXM module of the M6, not a laptop chip.
+    if not tesla and any(token in _LAPTOP_TIER for token in tokens):
+        kept.append("mobile")
     return "".join(kept)
 
 
+def datacenter_family(slug: str) -> str | None:
+    """Family key of a data-center board name ("K20 GPU accelerator"), else ``None``."""
+    tokens = _tokens(slug)
+    if tokens[:1] == ["tesla"] or (tokens and tokens[-1] in _DATACENTER_SUFFIX):
+        return gpu_family_key(slug)
+    return None
+
+
+def form_factor_of(key: str, family: str) -> bool:
+    """Whether family key ``key`` is a form factor of ``family``: ``k20c`` of ``k20``."""
+    return key.startswith(family) and key[len(family) :] in _FORM_FACTORS
+
+
 def spec_twins(candidate: dict[str, object], existing: dict[str, object]) -> bool:
     """Two names where one extends the other (``HD 2350`` / ``HD 2350 PRO``) and
     the boards share core clock and TDP: likely the same board, so not a new one."""
 
@@ -22,6 +22,11 @@
 _TDP_RE = re.compile(
     r"(?<![\d.])(\d{1,4}(?:\.\d+)?)(?:\s*/\s*\d{1,4}(?:\.\d+)?)?\s*W\b", re.IGNORECASE
 )
+# "12–25 W": a cTDP range, which names no default TDP.
+_TDP_RANGE_RE = re.compile(
+    r"(?<![\d.])\d{1,4}(?:\.\d+)?\s*(?:W\s*)?(?:–|—|−|-|to)\s*\d{1,4}(?:\.\d+)?\s*W\b",
+    re.IGNORECASE,
+)
 _FREQ_RANGE_RE = re.compile(
     r"(\d+(?:\.\d+)?)\s*(?:–|—|-|to)\s*(\d+(?:\.\d+)?)\s*(GHz|MHz)\b", re.IGNORECASE
 )
@@ -47,7 +52,9 @@
     re.IGNORECASE,
 )
 _QUARTER_RE = re.compile(r"\bQ([1-4])\s*'?(\d{2}|\d{4})\b", re.IGNORECASE)
-_MONTH_YEAR_RE = re.compile(r"\b" + _MONTH_NAME + r"\s+(\d{4})\b", re.IGNORECASE)
+# "1H 2025" and "H2 2024".
+_HALF_YEAR_RE = re.compile(r"\b(?:([12])H|H([12]))\s*(\d{4})\b", re.IGNORECASE)
+_MONTH_YEAR_RE = re.compile(r"\b" + _MONTH_NAME + r",?\s+(\d{4})\b", re.IGNORECASE)
 _YEAR_ONLY_RE = re.compile(r"\b(19\d{2}|20\d{2})\b")
 
 _MONTHS = {
@@ -74,10 +81,15 @@ def parse_frequency_ghz(text: str) -> float | None:
 
 
 def parse_tdp_w(text: str) -> int | None:
-    """``"65 W"`` → ``65``; ``"65/95 W"`` → ``65``; ``"9.5 W"`` → ``10`` (half-up)."""
+    """``"65 W"`` → ``65``; ``"65/95 W"`` → ``65``; ``"9.5 W"`` → ``10`` (half-up).
+
+    ``"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.
+    """
     if not text:
         return None
-    match = _TDP_RE.search(text)
+    match = _TDP_RE.search(_TDP_RANGE_RE.sub(" ", text))
     return math.floor(float(match.group(1)) + 0.5) if match else None
 
 
@@ -142,12 +154,29 @@ def parse_date(text: str) -> date | None:
     return period[0] if period else None
 
 
+# A quarter is the longest period whose first day still stands for the date.
+_LONGEST_DATED_PERIOD_DAYS = 92
+
+
+def release_date_of(period: tuple[date, date] | None) -> date | None:
+    """Release date a collector may write for ``period``, or ``None``.
+
+    A day, a month or a quarter gives its first day, as the curated records
+    do. A half-year or a bare year gives ``None``: January 1 would be a guess.
+    """
+    if period is None:
+        return None
+    first, last = period
+    return first if (last - first).days < _LONGEST_DATED_PERIOD_DAYS else None
+
+
 def parse_date_period(text: str) -> tuple[date, date] | None:
     """``(first, last)`` day of the period a date cell names.
 
     A full date is a one-day period. ``"Q4 2026"`` is Oct 1 – Dec 31, ``"Dec 2024"``
-    the whole month and a bare year the whole year, so a caller can tell whether
-    the period had ended (the part had shipped) by a given day.
+    the whole month, ``"1H 2025"`` Jan 1 – Jun 30 and a bare year the whole year,
+    so a caller can tell whether the period had ended (the part had shipped) by a
+    given day.
     """
     if not text:
         return None
@@ -170,6 +199,9 @@ def parse_date_period(text: str) -> tuple[date, date] | None:
         year_raw = match.group(2)
         year = 2000 + int(year_raw) if len(year_raw) == 2 else int(year_raw)
         return _months(year, (quarter - 1) * 3 + 1, 3)
+    if (match := _HALF_YEAR_RE.search(stripped)):
+        half = int(match.group(1) or match.group(2))
+        return _months(int(match.group(3)), 1 if half == 1 else 7, 6)
     if (match := _MONTH_YEAR_RE.search(stripped)):
         return _months(int(match.group(2)), _MONTHS[match.group(1).lower()[:3]], 1)
     if (match := _YEAR_ONLY_RE.search(stripped)):
@@ -220,6 +252,15 @@ def parse_memory_gb(text: str) -> float | None:
     return value if match.group(2).lower() == "gb" else round(value / 1024, 3)
 
 
+def mib_to_gb(mib: float) -> float | None:
+    """MiB → GB as the dataset stores it (binary): ``32`` → ``0.03125``.
+
+    Unrounded, so power-of-two sizes stay exact. 1 MiB and less gives ``None``:
+    0.0009765625 is under the validator's 0.001 GB floor.
+    """
+    return mib / 1024 if mib > 1 else None
+
+
 def parse_memory_bus_bit(text: str) -> int | None:
     """``"384-bit"`` → ``384``; ``"128 bit"`` → ``128``."""
     if not text:
@@ -326,6 +367,17 @@ def guess_os(text: str, *, brand: str = "") -> str | None:
     return None
 
 
+def normalize_socket(text: str) -> str | None:
+    """Socket in the model doc's form: ``"LGA 1151"`` → ``"LGA1151"``,
+    ``"Socket AM4"`` → ``"AM4"``, ``"F"`` → ``"F (1207)"``."""
+    value = " ".join(text.split())
+    value = re.sub(r"^Socket\s+", "", value, flags=re.IGNORECASE)
+    value = re.sub(r"^(FC)?LGA\s+(?=\d)", r"\1LGA", value, flags=re.IGNORECASE)
+    if value == "F":
+        value = "F (1207)"
+    return value or None
+
+
 def guess_cpu_segment(name: str) -> str:
     """Heuristic CPU segment classifier.
 
@@ -353,6 +405,7 @@ def guess_cpu_segment(name: str) -> str:
         suffix = match.group(1) if match else ""
         if any(letter in suffix for letter in ("h", "u", "y", "p", "m")) and "k" not in suffix:
             return "laptop"
-        if suffix in {"x", "xe"}:
+        # Core X/XE parts are HEDT; Ryzen X parts are ordinary desktop chips.
+        if suffix in {"x", "xe"} and re.search(r"\bcore\b", lowered):
             return "hedt"
     return "desktop"