@@ -19,6 +19,7 @@ Per-PR attribution and contributor credits are published automatically on the co
 - `DEFAULT_VOICE_CODE` now applies on the speech endpoints and `/dev/generate_from_phonemes` (#514, #515 by @Christian-Sidak, #516).
 - Entrypoint and `start-*.sh` honour `HOST` / `PORT`, so `HOST=::` binds IPv6-only (#408, reported by @felixls).
 - Blank lines now end a chunk, so headings, bylines, etc no longer run into the following paragraph. Single newlines still join. With `normalize: false` the text reaches the model verbatim, newlines included (#519).
+- Comma-grouped numbers like `3,497` are read as thousands, not as a year (#259). Long digit runs no longer stall or 500 the request.
 
 ## [v0.8.1] - 2026-08-24
 ### Fixed
 
@@ -184,12 +184,12 @@
 MONEY_PATTERN = re.compile(
     r"(-?)(["
     + "".join(MONEY_UNITS.keys())
-    + r"])(\d+(?:\.\d+)?)((?: hundred| thousand| (?:[bm]|tr|quadr)illion|k|m|b|t)*)\b",
+    + r"])(\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:\.\d+)?(?!,\d))((?: hundred| thousand| (?:[bm]|tr|quadr)illion|k|m|b|t)*)\b",
     re.IGNORECASE,
 )
 
 NUMBER_PATTERN = re.compile(
-    r"(-?)(\d+(?:\.\d+)?)((?: hundred| thousand| (?:[bm]|tr|quadr)illion|k|m|b)*)\b",
+    r"(-?)(\d{1,3}(?:,\d{3})+(?:\.\d+)?|\d+(?:\.\d+)?(?!,\d))((?: hundred| thousand| (?:[bm]|tr|quadr)illion|k|m|b)*)\b",
     re.IGNORECASE,
 )
 
@@ -242,12 +242,14 @@ def split_four_digit(number: float):
 
 
 def handle_numbers(n: re.Match[str]) -> str:
-    number = n.group(2)
+    raw = n.group(2)
 
     try:
-        number = float(number)
+        number = float(raw.replace(",", ""))
     except:
         return n.group()
+    if not math.isfinite(number):
+        return n.group()
 
     if n.group(1) == "-":
         number *= -1
@@ -259,7 +261,8 @@ def handle_numbers(n: re.Match[str]) -> str:
         multiplier = f" {multiplier}"
     else:
         if (
-            number % 1 == 0
+            "," not in raw
+            and number % 1 == 0
             and len(str(number)) == 4
             and number > 1500
             and number % 1000 > 9
@@ -274,12 +277,12 @@ def handle_money(m: re.Match[str]) -> str:
 
     bill, coin = MONEY_UNITS[m.group(2)]
 
-    number = m.group(3)
-
     try:
-        number = float(number)
+        number = float(m.group(3).replace(",", ""))
     except:
         return m.group()
+    if not math.isfinite(number):
+        return m.group()
 
     if m.group(1) == "-":
         number *= -1
@@ -500,11 +503,19 @@ def normalize_text(text: str, normalization_options: NormalizationOptions) -> st
     text = re.sub(r"(?i)\b(y)eah?\b", r"\1e'a", text)
 
     # Handle numbers and money BEFORE replacing special characters
-    text = re.sub(r"(?<=\d),(?=\d)", "", text)
+    text = re.sub(
+        r"(?<!\d)\d+(?:,\d+)+",
+        lambda m: (
+            m.group()
+            if re.fullmatch(r"\d{1,3}(?:,\d{3})+", m.group())
+            else m.group().replace(",", "")
+        ),
+        text,
+    )
     text = re.sub(r"(?<=\d)-(?=\d)", " to ", text)
 
     # version-like sequences (2.0.1, 10.3.2) before NUMBER_PATTERN eats the first decimal
-    text = re.sub(r"\d+(?:\.\d+){2,}", handle_version, text)
+    text = re.sub(r"(?<!\d)\d+(?:\.\d+){2,}", handle_version, text)
 
     text = MONEY_PATTERN.sub(
         handle_money,
 
@@ -289,6 +289,32 @@ def test_number():
         == "The book has three hundred and forty-two pages."
     )
 
+
+def test_comma_grouped_number_is_not_a_year():
+    """Thousands separators rule out the year reading (#259)."""
+    assert (
+        normalize_text(
+            "3,497 head of cattle", normalization_options=NormalizationOptions()
+        )
+        == "three thousand, four hundred and ninety-seven head of cattle"
+    )
+    assert (
+        normalize_text("in 3497", normalization_options=NormalizationOptions())
+        == "in thirty-four ninety-seven"
+    )
+    assert (
+        normalize_text("$3,497.50", normalization_options=NormalizationOptions())
+        == "three thousand, four hundred and ninety-seven dollars and fifty cents"
+    )
+    assert (
+        normalize_text("the 3,497th item", normalization_options=NormalizationOptions())
+        == "the 3,497th item"
+    )
+    assert (
+        normalize_text("12,34", normalization_options=NormalizationOptions())
+        == "one thousand, two hundred and thirty-four"
+    )
+
     assert (
         normalize_text(
             "He made -50 sales today.", normalization_options=NormalizationOptions()
 
@@ -63,6 +63,21 @@ def test_paragraph_split_is_fast():
         assert time.monotonic() - start < BUDGET_S
 
 
+def test_number_floods_scale_linearly():
+    """Comma runs and bare digit runs: the version regex went quadratic on the latter."""
+    for unit in ("1", "1,", "123,", "123,4", "$1,"):
+        small = _elapsed(unit * 5_000)
+        large = _elapsed(unit * 20_000)
+        assert large / max(small, 0.05) < 9.0, unit
+
+
+def test_huge_digit_run_does_not_raise():
+    """float() overflows to inf on 310+ digits, which used to crash the request."""
+    assert normalize_text("9" * 400, OPTS) == "9" * 400
+    assert normalize_text("$" + "9" * 400, OPTS).startswith(" dollar ")
+    assert normalize_text("123," * 400, OPTS)
+
+
 def test_decimal_normalization_preserved():
     """the lookbehind must not break normal decimal rendering."""
     out = normalize_text("costs 3.14 dollars", OPTS)