Harden production inference normalization and boundaries

README.md

@@ -53,7 +53,7 @@ Barbet 另固定在 `6fcd7ce4aa37f2250a3242995bef0fbc3b026ba8`，
 | Sparse completion-headroom policy | every fourth retry: 4.2 CJK / 3.6 ASCII-mixed units/sec + 1 latent step |
 | Short-text guidance | minimum CFG 3.0 at no more than 6 speech units |
 | Generation guidance | fixed mixed-CFG assignment within the bounded cascade; public NFE fixed at 10 |
-| Email / URL frontend | lexical local/domain labels, audible separators, and explicit Taiwan-Mandarin letter names for the final TLD |
+| Email / URL frontend | explicit Taiwan-Mandarin letter names for scheme and opaque labels, digit-by-digit numbers, and audible separators |
 | Stop policy | 0.50 → 0.05 from 75% to 95% predicted progress, 1 hit |
 | Endpoint cue | append terminal punctuation for model input when missing, except very short text |
 | Hard stop | native-pace target steps, independent of playback pace |
@@ -136,11 +136,14 @@ transcript。
 日期、24 小時制時間、百分比、常見單位與大寫 acronym/model code 會先轉成保守的
 zh-TW spoken form，例如 `2026/07/16`、`15:30`、`12.5%` 與 `10 km`。ASR 會先統一
 繁簡字形再評分，避免把正確的台灣華語輸出誤判為內容錯誤。
-Email 與 URL 會以可辨識的語義讀法展開：scheme 與分隔符明確朗讀，local/domain/path
-保留 lexical label，最後的 TLD 使用台灣華語字母名（例如 `.tw` 讀成「點、踢、達不溜」）。
+Email 與 URL 會以可辨識的語義讀法展開：scheme、local/domain/path 的 opaque ASCII
+labels 逐字使用台灣華語字母名，數字逐位朗讀，分隔符明確朗讀（例如 `.tw`
+讀成「點、踢、達不溜」）。
 這能降低模型把不常見 TLD 自動補成 `.com` 的風險；一般英文句子不會套用這個規則。
 URL 與後續英文 prose 應以空白或中文標點分隔；未分隔的 RFC path punctuation 會視為 URL
 本身的一部分並納入 exact gate。Quoted email local-part 暫不支援，輸入時會直接 fail closed。
+URL identifier 目前只支援 ASCII；非 ASCII IRI 必須先轉成 ASCII/percent-encoded 形式，
+否則會因字母讀音碰撞而在 normalization 前 fail closed。
 為避免 Whisper 自動句末標點和 URL 內容不可判定，URL 不接受以 `. , ! ? ; : '` 結尾；
 需要這些尾端符號時請使用 percent encoding。
 Whisper 常見的 `15点30分`/`15點30分` 會視為同一讀法；裸寫 `15點30` 只有在 target

app.py

@@ -31,6 +31,7 @@ from production import (
     finish_audio,
     join_audio_chunks,
     match_chunk_rms,
+    network_identifier_has_ambiguous_iri,
     network_protected_spoken_spans,
     normalize_spoken_forms,
     punctuation_pause_seconds,
@@ -626,7 +627,7 @@ def _assemble_trajectory_audio(
         max_gain=3.0,
     )
     waveform = _apply_speed(waveform, playback_speed)
-    finish_fade_ms = 0.0 if count_speech_units("".join(chunks)) <= 6 else 60.0
+    finish_fade_ms = 0.0 if count_speech_units("".join(chunks)) <= 6 else 5.0
     return finish_audio(waveform, SR, fade_ms=finish_fade_ms)
 
 
@@ -812,6 +813,8 @@ def _synthesize(
         raise gr.Error("CFG 必須介於 1.0 與 4.0。")
     if cfg_value != MIXED_CFG_PRIMARY:
         raise gr.Error(f"目前只支援已驗證的主 CFG {MIXED_CFG_PRIMARY:.1f}。")
+    if network_identifier_has_ambiguous_iri(text):
+        raise gr.Error("網址目前只支援 ASCII 字元；非 ASCII IRI 會與字母讀音混淆。")
     network_request = contains_network_identifier(text)
     request_cfg = MIXED_CFG_PRIMARY
     try:

production.py

@@ -72,6 +72,7 @@ _ASR_BARE_ZH_TIME_RE = re.compile(
 _ASR_ARABIC_DIGIT_RUN_RE = re.compile(
     r"(?<![A-Za-z0-9])\d+(?![A-Za-z0-9])"
 )
+_ASR_XIAOLAOSHU_ALIAS_RE = re.compile(r"(?i)xiaolaoshu")
 _ASR_STRUCTURED_NUMERIC_NEIGHBORS = frozenset(
     ".,:/\\-+_@#年月日時时分秒點点%％"
 )
@@ -297,6 +298,20 @@ _ZH_NETWORK_READING_TO_LETTER = {
     reading: letter.casefold()
     for letter, reading in _ZH_NETWORK_LETTER_READINGS.items()
 }
+_ZH_NETWORK_READING_TO_LETTER.update(
+    {
+        "爱": "i",
+        "杰": "j",
+        "凯": "k",
+        "艾尔": "l",
+        "欧": "o",
+        "阿尔": "r",
+        "优": "u",
+        "维": "v",
+        "达不溜": "w",
+        "兹": "z",
+    }
+)
 _T2S_CONVERTER = OpenCC("t2s")
 
 
@@ -1014,7 +1029,7 @@ def _canonicalize_target_proven_frequency_scales(
 
 
 def _zh_network_text(value: str) -> str:
-    """Keep lexical labels intact while making network separators audible."""
+    """Spell opaque network labels and make their separators audible."""
 
     output: list[str] = []
     buffer: list[str] = []
@@ -1025,6 +1040,8 @@ def _zh_network_text(value: str) -> str:
         token = "".join(buffer)
         if token.isdigit():
             output.append(_zh_digit_sequence(token))
+        elif token.isascii() and token.isalpha():
+            output.append(_zh_network_letters(token))
         else:
             output.append(token)
         buffer.clear()
@@ -1052,7 +1069,7 @@ def _zh_network_text(value: str) -> str:
 
 
 def _zh_network_letters(value: str) -> str:
-    """Return explicit Taiwan-Mandarin letter names for a bounded suffix."""
+    """Return explicit Taiwan-Mandarin names for opaque ASCII letters."""
 
     return " ".join(
         _ZH_NETWORK_LETTER_READINGS.get(character.upper(), character)
@@ -1080,7 +1097,7 @@ def _zh_version_qualifier(value: str) -> str:
 
 
 def _zh_network_domain(value: str) -> str:
-    """Read labels lexically but spell the final alphabetic TLD explicitly."""
+    """Spell opaque ASCII domain labels and their separators explicitly."""
 
     head, separator, suffix = value.rpartition(".")
     if separator and head and suffix.isascii() and suffix.isalpha():
@@ -1091,7 +1108,7 @@ def _zh_network_domain(value: str) -> str:
 def _zh_url(value: str) -> str:
     scheme, separator, remainder = value.partition("://")
     if separator:
-        protocol = " ".join(scheme.upper())
+        protocol = _zh_network_letters(scheme)
         prefix = f"{protocol} 冒號 斜線 斜線 "
     else:
         remainder = value
@@ -1117,6 +1134,16 @@ def contains_network_identifier(text: str) -> bool:
     return bool(_SPOKEN_URL_RE.search(raw) or _SPOKEN_EMAIL_RE.search(raw))
 
 
+def network_identifier_has_ambiguous_iri(text: str) -> bool:
+    """Reject non-ASCII URL identifiers whose speech collides with ASCII."""
+
+    raw = unicodedata.normalize("NFC", str(text or ""))
+    return any(
+        any(character.isalnum() and not character.isascii() for character in match.group(0))
+        for match in _SPOKEN_URL_RE.finditer(raw)
+    )
+
+
 _NETWORK_BOUNDARY_PUNCTUATION = (
     _NETWORK_NONASCII_BOUNDARY_PUNCTUATION + ",.!?;:()[]{}<>\"'"
 )
@@ -1149,13 +1176,21 @@ def _raw_network_spoken_spans(text: str) -> tuple[str, ...]:
 def _is_expanded_network_token(token: str) -> bool:
     if token.isalnum():
         return True
+    if token.isascii() and token and all(
+        character.isalnum() or character in _ZH_NETWORK_SYMBOL_READINGS
+        for character in token
+    ):
+        return True
     if token and all(character in _ZH_DIGITS for character in token):
         return True
     if token.startswith("符號") and token[2:] and all(
         character in _ZH_DIGITS for character in token[2:]
     ):
         return True
-    return token in _NETWORK_SPOKEN_SYMBOL_TOKENS
+    return (
+        token in _NETWORK_SPOKEN_SYMBOL_TOKENS
+        or token in _SIMPLIFIED_NETWORK_SYMBOL_READINGS
+    )
 
 
 def _network_letter_token(token: str) -> str | None:
@@ -1164,6 +1199,168 @@ def _network_letter_token(token: str) -> str | None:
     return _ZH_NETWORK_READING_TO_LETTER.get(token)
 
 
+_SPOKEN_EMAIL_SYMBOL_TOKENS = {
+    reading: symbol
+    for symbol, reading in _ZH_NETWORK_SYMBOL_READINGS.items()
+    if symbol in ".!#$%&'*+/=?^_`{|}~-@"
+}
+
+
+def _spoken_email_token_value(token: str) -> str | None:
+    letter = _network_letter_token(token)
+    if letter is not None:
+        return letter
+    if token.isascii() and token.isalnum():
+        return token.casefold()
+    if token and all(character in _ZH_DIGITS for character in token):
+        return "".join(str(_ZH_DIGITS.index(character)) for character in token)
+    canonical = _SIMPLIFIED_NETWORK_SYMBOL_READINGS.get(token, token)
+    return _SPOKEN_EMAIL_SYMBOL_TOKENS.get(canonical)
+
+
+def _spoken_email_subspan_bounds(tokens: Sequence[str]) -> tuple[tuple[int, int], ...]:
+    """Locate maximal syntactically valid spoken email token ranges."""
+
+    tokens = tuple(_SIMPLIFIED_NETWORK_SYMBOL_READINGS.get(token, token) for token in tokens)
+    output: list[tuple[int, int]] = []
+    for at, token in enumerate(tokens):
+        if token != "小老鼠":
+            continue
+        if any(
+            tokens[index : index + 3] == ["冒號", "斜線", "斜線"]
+            for index in range(max(0, at - 2))
+        ):
+            continue
+
+        www_end = None
+        for start in range(at):
+            if (
+                start + 1 < at
+                and tokens[start].casefold() == "www"
+                and tokens[start + 1] == "點"
+            ):
+                www_end = start + 2
+                break
+            if (
+                start + 3 < at
+                and [
+                    _network_letter_token(part)
+                    for part in tokens[start : start + 3]
+                ]
+                == ["w", "w", "w"]
+                and tokens[start + 3] == "點"
+            ):
+                www_end = start + 4
+                break
+        if www_end is not None and any(
+            part in {"斜線", "問號", "井號", "冒號"}
+            for part in tokens[www_end:]
+        ):
+            continue
+
+        left_floor = 0
+        for separator in range(at):
+            if tokens[separator] == "和" and "小老鼠" in tokens[:separator]:
+                left_floor = separator + 1
+        left = at
+        while left > left_floor:
+            value = _spoken_email_token_value(tokens[left - 1])
+            if value is None or value == "@":
+                break
+            left -= 1
+        right = at + 1
+        while right < len(tokens):
+            value = _spoken_email_token_value(tokens[right])
+            if value is None or value == "@":
+                break
+            right += 1
+
+        matches: list[tuple[int, int, int, int]] = []
+        for start in range(left, at):
+            for end in range(at + 2, right + 1):
+                rendered = "".join(
+                    value
+                    for part in tokens[start:end]
+                    if (value := _spoken_email_token_value(part)) is not None
+                )
+                if _SPOKEN_EMAIL_RE.fullmatch(rendered):
+                    matches.append((len(rendered), end - start, -start, end))
+        if matches:
+            match = max(matches)
+            output.append((-match[2], match[3]))
+    return tuple(output)
+
+
+def _spoken_email_subspans(span: str) -> tuple[str, ...]:
+    tokens = span.split()
+    return tuple(
+        " ".join(tokens[start:end])
+        for start, end in _spoken_email_subspan_bounds(tokens)
+    )
+
+
+_SIMPLIFIED_NETWORK_SYMBOL_READINGS = {
+    "点": "點",
+    "冒号": "冒號",
+    "斜线": "斜線",
+    "问号": "問號",
+    "等于": "等於",
+    "井号": "井號",
+    "横线": "橫線",
+    "底线": "底線",
+    "百分号": "百分號",
+    "加号": "加號",
+    "波浪号": "波浪號",
+    "惊叹号": "驚嘆號",
+    "钱字号": "錢字號",
+    "单引号": "單引號",
+    "左括号": "左括號",
+    "右括号": "右括號",
+    "星号": "星號",
+    "逗号": "逗號",
+    "分号": "分號",
+    "左方括号": "左方括號",
+    "右方括号": "右方括號",
+    "插入号": "插入號",
+    "反引号": "反引號",
+    "左大括号": "左大括號",
+    "竖线": "豎線",
+    "右大括号": "右大括號",
+}
+
+
+def _canonicalize_network_spoken_span(span: str) -> str:
+    """Normalize opaque network tokens without applying prose unit rules."""
+
+    symbol_readings = frozenset(_ZH_NETWORK_SYMBOL_READINGS.values())
+    output: list[str] = []
+    for token in span.split():
+        letter = _network_letter_token(token)
+        if letter is not None:
+            output.append(_ZH_NETWORK_LETTER_READINGS[letter.upper()])
+            continue
+        if token in symbol_readings:
+            output.append(token)
+            continue
+        if token in _SIMPLIFIED_NETWORK_SYMBOL_READINGS:
+            output.append(_SIMPLIFIED_NETWORK_SYMBOL_READINGS[token])
+            continue
+        if token and token.isascii() and all(
+            character.isalnum() or character in _ZH_NETWORK_SYMBOL_READINGS
+            for character in token
+        ):
+            for character in token:
+                if character.isdigit():
+                    output.append(_ZH_DIGITS[int(character)])
+                elif character.isalpha():
+                    output.append(_ZH_NETWORK_LETTER_READINGS[character.upper()])
+                else:
+                    output.append(_ZH_NETWORK_SYMBOL_READINGS[character])
+            continue
+        output.append(token)
+    return " ".join(output)
+
+
 def _expanded_network_spoken_spans(text: str) -> tuple[str, ...]:
     """Recover protected spans after the request frontend has expanded them.
 
@@ -1193,16 +1390,23 @@ def _expanded_network_spoken_spans(text: str) -> tuple[str, ...]:
         while end < len(records) and _is_expanded_network_token(records[end][0]):
             end += 1
         tokens = [token for token, _ in records[index:end]]
+        comparison_tokens = [
+            _SIMPLIFIED_NETWORK_SYMBOL_READINGS.get(token, token)
+            for token in tokens
+        ]
         protected_start: int | None = None
 
-        for anchor in range(1, len(tokens) - 2):
-            if tokens[anchor : anchor + 3] != ["冒號", "斜線", "斜線"]:
+        for anchor in range(1, len(comparison_tokens) - 2):
+            if comparison_tokens[anchor : anchor + 3] != ["冒號", "斜線", "斜線"]:
                 continue
             for scheme in ("https", "http", "ftp"):
                 length = len(scheme)
                 start = anchor - length
                 letters = (
-                    [_network_letter_token(token) for token in tokens[start:anchor]]
+                    [
+                        _network_letter_token(token)
+                        for token in comparison_tokens[start:anchor]
+                    ]
                     if start >= 0
                     else []
                 )
@@ -1212,27 +1416,36 @@ def _expanded_network_spoken_spans(text: str) -> tuple[str, ...]:
             if protected_start is not None:
                 break
 
-        if protected_start is None and "小老鼠" in tokens:
-            at = tokens.index("小老鼠")
-            if at > 0 and "點" in tokens[at + 1 :]:
-                protected_start = 0
+        email_bounds = (
+            _spoken_email_subspan_bounds(comparison_tokens)
+            if protected_start is None
+            else ()
+        )
 
-        if protected_start is None:
-            for start in range(max(0, len(tokens) - 3)):
-                prefix = tokens[start]
+        if protected_start is None and not email_bounds:
+            for start in range(max(0, len(comparison_tokens) - 3)):
+                prefix = comparison_tokens[start]
                 split_prefix = [
                     _network_letter_token(token)
-                    for token in tokens[start : start + 3]
+                    for token in comparison_tokens[start : start + 3]
                 ]
                 if (
-                    (prefix.casefold() == "www" and tokens[start + 1] == "點")
-                    or (split_prefix == ["w", "w", "w"] and tokens[start + 3] == "點")
+                    (
+                        prefix.casefold() == "www"
+                        and comparison_tokens[start + 1] == "點"
+                    )
+                    or (
+                        split_prefix == ["w", "w", "w"]
+                        and comparison_tokens[start + 3] == "點"
+                    )
                 ):
                     protected_start = start
                     break
 
         if protected_start is not None:
             spans.append(" ".join(tokens[protected_start:]))
+        elif email_bounds:
+            spans.extend(" ".join(tokens[start:end]) for start, end in email_bounds)
         index = max(end, index + 1)
     return tuple(spans)
 
@@ -1437,10 +1650,25 @@ def normalize_asr_spoken_forms(
     protected_network: list[str] = []
 
     def network_comparison_key(value: str) -> str:
-        normalized = _T2S_CONVERTER.convert(
-            normalize_tts_eval_text(value).casefold()
-        )
-        return "".join(character for character in normalized if character.isalnum())
+        canonical = normalize_tts_eval_text(value).casefold()
+        for reading, letter in sorted(
+            _ZH_NETWORK_READING_TO_LETTER.items(),
+            key=lambda item: len(item[0]),
+            reverse=True,
+        ):
+            canonical = canonical.replace(reading.casefold(), letter)
+        canonical = _T2S_CONVERTER.convert(canonical)
+        output: list[str] = []
+        for character in canonical:
+            if character in _ZH_DIGITS:
+                output.append(str(_ZH_DIGITS.index(character)))
+                continue
+            try:
+                output.append(str(unicodedata.decimal(character)))
+            except (TypeError, ValueError):
+                if character.isalnum():
+                    output.append(character)
+        return "".join(output)
 
     target_network_spans = network_protected_spoken_spans(normalized_target)
     target_network_keys = {
@@ -1448,13 +1676,133 @@ def normalize_asr_spoken_forms(
         for span in target_network_spans
     }
 
+    email_symbol_tokens = {
+        reading: symbol
+        for symbol, reading in _ZH_NETWORK_SYMBOL_READINGS.items()
+        if symbol in ".!#$%&'*+/=?^_`{|}~-@"
+    }
+
+    def spoken_email_token_value(token: str) -> str | None:
+        token = _SIMPLIFIED_NETWORK_SYMBOL_READINGS.get(token, token)
+        letter = _network_letter_token(token)
+        if letter is not None:
+            return letter
+        if token.isascii() and token.isalnum():
+            return token.casefold()
+        if token and all(character in _ZH_DIGITS for character in token):
+            return "".join(str(_ZH_DIGITS.index(character)) for character in token)
+        return email_symbol_tokens.get(token)
+
+    def spoken_email_subspans(span: str) -> tuple[str, ...]:
+        """Extract maximal syntactically valid emails around spoken ``@``."""
+
+        tokens = [
+            _SIMPLIFIED_NETWORK_SYMBOL_READINGS.get(token, token)
+            for token in span.split()
+        ]
+        output: list[str] = []
+        for at, token in enumerate(tokens):
+            if token != "小老鼠":
+                continue
+            if any(
+                tokens[index : index + 3] == ["冒號", "斜線", "斜線"]
+                for index in range(max(0, at - 2))
+            ):
+                continue
+
+            www_end = None
+            for start in range(at):
+                if (
+                    start + 1 < at
+                    and tokens[start].casefold() == "www"
+                    and tokens[start + 1] == "點"
+                ):
+                    www_end = start + 2
+                    break
+                if (
+                    start + 3 < at
+                    and [
+                        _network_letter_token(part)
+                        for part in tokens[start : start + 3]
+                    ]
+                    == ["w", "w", "w"]
+                    and tokens[start + 3] == "點"
+                ):
+                    www_end = start + 4
+                    break
+            if www_end is not None and any(
+                part in {"斜線", "問號", "井號", "冒號"}
+                for part in tokens[www_end:]
+            ):
+                continue
+
+            left_floor = 0
+            for separator in range(at):
+                if tokens[separator] == "和" and "小老鼠" in tokens[:separator]:
+                    left_floor = separator + 1
+            left = at
+            while left > left_floor:
+                value = spoken_email_token_value(tokens[left - 1])
+                if value is None or value == "@":
+                    break
+                left -= 1
+            right = at + 1
+            while right < len(tokens):
+                value = spoken_email_token_value(tokens[right])
+                if value is None or value == "@":
+                    break
+                right += 1
+
+            matches: list[tuple[int, int, int, str]] = []
+            for start in range(left, at):
+                for end in range(at + 2, right + 1):
+                    rendered = "".join(
+                        value
+                        for part in tokens[start:end]
+                        if (value := spoken_email_token_value(part)) is not None
+                    )
+                    if _SPOKEN_EMAIL_RE.fullmatch(rendered):
+                        matches.append(
+                            (
+                                len(rendered),
+                                end - start,
+                                -start,
+                                " ".join(tokens[start:end]),
+                            )
+                        )
+            if matches:
+                output.append(max(matches)[3])
+        return tuple(output)
+
+    target_email_key_limits: dict[str, int] = {}
+    for span in target_network_spans:
+        for email_span in spoken_email_subspans(span):
+            key = network_comparison_key(email_span)
+            if key:
+                target_email_key_limits[key] = target_email_key_limits.get(key, 0) + 1
+
     def protect_network(spoken: str) -> str:
         marker = f"\uf100{len(protected_network)}\uf101"
-        protected_network.append(spoken)
+        protected_network.append(_canonicalize_network_spoken_span(spoken))
         return marker
 
     def protect_url(match: re.Match[str]) -> str:
         matched = match.group(0)
+        alias_in_or_after_match = (
+            _ASR_XIAOLAOSHU_ALIAS_RE.search(matched) is not None
+            or re.match(
+                r"\s*xiaolaoshu",
+                match.string[match.end() :],
+                flags=re.IGNORECASE,
+            )
+            is not None
+        )
+        if target_email_key_limits and alias_in_or_after_match:
+            # A no-space ``www.fooXiaolaoshuexample.tw`` rendering is first
+            # recognized by the broad schemeless-URL regex. Leave it visible
+            # to the exact target-email alias proof below; wrong content still
+            # remains literal and fails the protected-range comparison.
+            return matched
         core = matched
         # Whisper commonly emits ASCII sentence punctuation directly after a
         # URL. Keep a trailing symbol inside the protected range only when the
@@ -1505,8 +1853,81 @@ def normalize_asr_spoken_forms(
             f" {reading} ",
             raw_text,
         )
+
+    # Whisper can render the spoken email separator ``小老鼠`` as its
+    # Mandarin pinyin ``Xiaolaoshu``, including without spaces between opaque
+    # labels. Try each occurrence independently and accept it only when the
+    # replacement adds exact coverage of a complete target email span. This
+    # keeps URL paths containing ``@``, wrong domains, missing labels, literal
+    # labels, prose aliases, and already-covered targets fail-closed.
+    def covered_target_email_counts(value: str) -> dict[str, int]:
+        unprotected = value
+        for index in range(len(protected_network)):
+            unprotected = unprotected.replace(f"\uf100{index}\uf101", "，")
+        counts = {key: 0 for key in target_email_key_limits}
+
+        for span in protected_network:
+            for email_span in spoken_email_subspans(span):
+                key = network_comparison_key(email_span)
+                limit = target_email_key_limits.get(key, 0)
+                if limit and counts[key] < limit:
+                    counts[key] += 1
+
+        for span in network_protected_spoken_spans(unprotected):
+            for email_span in spoken_email_subspans(span):
+                key = network_comparison_key(email_span)
+                limit = target_email_key_limits.get(key, 0)
+                if limit and counts[key] < limit:
+                    counts[key] += 1
+        return counts
+
+    alias_search_start = 0
+    while target_email_key_limits:
+        alias_match = _ASR_XIAOLAOSHU_ALIAS_RE.search(raw_text, alias_search_start)
+        if alias_match is None:
+            break
+        candidate = (
+            raw_text[: alias_match.start()]
+            + " 小老鼠 "
+            + raw_text[alias_match.end() :]
+        )
+        before_counts = covered_target_email_counts(raw_text)
+        after_counts = covered_target_email_counts(candidate)
+        if any(
+            after_counts[key] > before_counts[key]
+            for key in target_email_key_limits
+        ):
+            raw_text = candidate
+            alias_search_start = alias_match.start() + len(" 小老鼠 ")
+        else:
+            alias_search_start = alias_match.end()
+
+    for spoken in network_protected_spoken_spans(raw_text):
+        pattern = r"\s+".join(re.escape(token) for token in spoken.split())
+        match = re.search(pattern, raw_text)
+        if match is None:
+            continue
+        raw_text = (
+            raw_text[: match.start()]
+            + protect_network(spoken)
+            + raw_text[match.end() :]
+        )
+
+    placeholder_prefix = "藍鵲網路保護佔位符"
+    while placeholder_prefix in raw_text or placeholder_prefix in raw_target:
+        placeholder_prefix += "號"
+    network_placeholders: list[tuple[str, str]] = []
     for index, spoken in enumerate(protected_network):
-        raw_text = raw_text.replace(f"\uf100{index}\uf101", spoken)
+        marker = f"\uf100{index}\uf101"
+        placeholder = f"{placeholder_prefix}{_zh_integer(index + 1)}結束"
+        raw_text = raw_text.replace(marker, placeholder)
+        network_placeholders.append((placeholder, spoken))
+
+    def restore_network_placeholders(value: str) -> str:
+        for placeholder, spoken in network_placeholders:
+            value = value.replace(placeholder, spoken)
+        return value
+
     target_proven_text = _canonicalize_target_proven_frequency_scales(
         raw_text,
         raw_target,
@@ -1534,7 +1955,7 @@ def normalize_asr_spoken_forms(
         # A numeric ``X點Y`` construction in the target is itself ambiguous.
         # Do not let a separate, fully-spoken clock elsewhere in the sentence
         # globally authorize rewriting that decimal, duration, or score.
-        return normalized_text
+        return restore_network_placeholders(normalized_text)
 
     def replace_target_proven_time(match: re.Match[str]) -> str:
         canonical = _zh_clock_time(match.group(1), match.group(2))
@@ -1548,7 +1969,7 @@ def normalize_asr_spoken_forms(
         replace_target_proven_time,
         normalized_text,
     )
-    return normalize_tts_text(normalized_text)
+    return restore_network_placeholders(normalize_tts_text(normalized_text))
 
 
 def normalize_tts_text(text: str) -> str:
@@ -1869,7 +2290,10 @@ def select_generation_cps(
     """Reserve more generation time for ASCII words than compact CJK units."""
 
     normalized = normalize_tts_text(text)
-    if any(char.isascii() and char.isalnum() for char in normalized):
+    if (
+        any(char.isascii() and char.isalnum() for char in normalized)
+        or network_protected_spoken_spans(normalized)
+    ):
         return float(ascii_cps)
     return float(cjk_cps)
 
@@ -1906,6 +2330,29 @@ _PROTECTED_ASCII_SPAN_RE = re.compile(
     r"(?i)[a-z0-9]+(?:[._+/@:#~%-]+[a-z0-9]+)+"
     r"|(?<![a-z0-9])(?:[a-z]\s+){2,}[a-z](?![a-z0-9])"
 )
+_STRUCTURED_CLAUSE_BREAKS = frozenset("，,、：:")
+_STRUCTURED_CLAUSE_TARGET_UNITS = 32
+_NORMALIZED_ZH_NUMBER_PATTERN = (
+    r"[正負]?[" + _ZH_DIGITS + r"十百千萬億兆]+"
+    r"(?:點[" + _ZH_DIGITS + r"]+)?"
+)
+_NORMALIZED_STRUCTURED_NUMERIC_CUE_RE = re.compile(
+    rf"(?:"
+    rf"百分之{_NORMALIZED_ZH_NUMBER_PATTERN}"
+    rf"|(?:新台幣|美元|港幣|人民幣|日圓|歐元|英鎊|韓元)"
+    rf"{_NORMALIZED_ZH_NUMBER_PATTERN}"
+    rf"|{_NORMALIZED_ZH_NUMBER_PATTERN}(?:"
+    rf"公里每小時|公尺每秒|攝氏度|千赫茲|兆赫茲|"
+    rf"吉赫茲|赫茲|毫秒|公里|公尺|公分|公厘|"
+    rf"公斤|公克|���克|公升|毫升|千瓦|瓦|伏特"
+    rf")"
+    rf"|[" + _ZH_DIGITS + rf"]{{4}}年{_NORMALIZED_ZH_NUMBER_PATTERN}月"
+    rf"{_NORMALIZED_ZH_NUMBER_PATTERN}日"
+    rf"|{_NORMALIZED_ZH_NUMBER_PATTERN}點(?:整|{_NORMALIZED_ZH_NUMBER_PATTERN}分)"
+    rf"|版本{_NORMALIZED_ZH_NUMBER_PATTERN}點{_NORMALIZED_ZH_NUMBER_PATTERN}"
+    rf"點{_NORMALIZED_ZH_NUMBER_PATTERN}"
+    rf")"
+)
 
 
 def _semantic_sentence_units(text: str) -> list[str]:
@@ -1937,6 +2384,24 @@ def _ends_at_strong_boundary(text: str) -> bool:
     return bool(core and core[-1] in _SEMANTIC_STRONG_BREAKS)
 
 
+def _expanded_network_split_ranges(text: str) -> tuple[tuple[int, int], ...]:
+    """Locate frontend-expanded network spans in normalized model text."""
+
+    normalized = normalize_tts_text(text)
+    ranges: list[tuple[int, int]] = []
+    cursor = 0
+    for span in _expanded_network_spoken_spans(normalized):
+        start = normalized.find(span, cursor)
+        if start < 0:
+            start = normalized.find(span)
+        if start < 0:
+            continue
+        end = start + len(span)
+        ranges.append((start, end))
+        cursor = end
+    return tuple(ranges)
+
+
 def _protected_split_offsets(text: str, max_units: int) -> set[int]:
     """Return offsets that would bisect one bounded ASCII/network identifier."""
 
@@ -1945,9 +2410,120 @@ def _protected_split_offsets(text: str, max_units: int) -> set[int]:
         if count_speech_units(match.group(0)) > max_units:
             raise ValueError("an indivisible ASCII identifier exceeds the chunk limit")
         forbidden.update(range(match.start() + 1, match.end()))
+    for start, end in _expanded_network_split_ranges(text):
+        if count_speech_units(text[start:end]) > max_units:
+            raise ValueError("an indivisible network identifier exceeds the chunk limit")
+        forbidden.update(range(start + 1, end))
     return forbidden
 
 
+def _structured_numeric_cue_count(text: str) -> int:
+    """Count bounded, already-expanded numeric frontend constructions."""
+
+    return sum(1 for _ in _NORMALIZED_STRUCTURED_NUMERIC_CUE_RE.finditer(text))
+
+
+def _should_split_structured_clauses(text: str) -> bool:
+    return bool(network_protected_spoken_spans(text)) or (
+        _structured_numeric_cue_count(text) >= 2
+    )
+
+
+def _structured_clause_units(text: str, max_units: int) -> list[str]:
+    """Split only on real clause punctuation outside protected identifiers."""
+
+    forbidden = _protected_split_offsets(text, max_units)
+    clauses: list[str] = []
+    start = 0
+    for index, character in enumerate(text):
+        end = index + 1
+        if character not in _STRUCTURED_CLAUSE_BREAKS or end in forbidden:
+            continue
+        clause = text[start:end].strip()
+        if clause:
+            clauses.append(clause)
+        start = end
+    tail = text[start:].strip()
+    if tail:
+        clauses.append(tail)
+    return clauses
+
+
+def _pack_structured_clauses(
+    clauses: Sequence[str],
+    *,
+    max_units: int,
+    min_units: int,
+    target_units: int = _STRUCTURED_CLAUSE_TARGET_UNITS,
+) -> list[str]:
+    """Pack natural clauses near a soft target while retaining hard bounds."""
+
+    maximum = max(1, int(max_units))
+    minimum = max(1, min(int(min_units), maximum))
+    target = max(minimum, min(int(target_units), maximum))
+    atoms: list[str] = []
+    for clause in clauses:
+        normalized = normalize_tts_text(clause)
+        if not normalized:
+            continue
+        if count_speech_units(normalized) > maximum:
+            atoms.extend(_hard_split_text(normalized, maximum, minimum))
+        else:
+            atoms.append(normalized)
+    if not atoms:
+        return []
+
+    # A short opening clause is an onset risk on its own. Merge it forward
+    # before optimizing the remaining natural boundaries.
+    while len(atoms) > 1 and count_speech_units(atoms[0]) < minimum:
+        merged = f"{atoms[0]}{atoms[1]}"
+        if count_speech_units(merged) > maximum:
+            return _hard_split_text("".join(atoms), maximum, minimum)
+        atoms[:2] = [merged]
+
+    def build_plan(multi_limit: int) -> tuple[int, int, tuple[int, ...]] | None:
+        best: list[tuple[int, int, tuple[int, ...]] | None] = [None] * (
+            len(atoms) + 1
+        )
+        best[len(atoms)] = (0, 0, ())
+        for start in range(len(atoms) - 1, -1, -1):
+            for end in range(start + 1, len(atoms) + 1):
+                chunk = "".join(atoms[start:end])
+                units = count_speech_units(chunk)
+                if units > maximum:
+                    break
+                if units < minimum:
+                    continue
+                if units > multi_limit and end - start > 1:
+                    continue
+                remainder = best[end]
+                if remainder is None:
+                    continue
+                candidate = (
+                    1 + remainder[0],
+                    abs(target - units) + remainder[1],
+                    (end,) + remainder[2],
+                )
+                if best[start] is None or candidate[:2] < best[start][:2]:
+                    best[start] = candidate
+        return best[0]
+
+    # First hold multi-clause chunks to the 32-unit target. If an interior or
+    # trailing short clause makes that impossible, permit at most one
+    # minimum-sized unit of slack; protected single clauses remain indivisible.
+    plan = build_plan(target)
+    if plan is None:
+        plan = build_plan(min(maximum, target + minimum))
+    if plan is None:
+        return _hard_split_text("".join(atoms), maximum, minimum)
+    output: list[str] = []
+    start = 0
+    for end in plan[2]:
+        output.append("".join(atoms[start:end]))
+        start = end
+    return output
+
+
 def _hard_split_text(text: str, max_chars: int, min_chunk_chars: int) -> list[str]:
     """Deterministically split one overlong unit by speech units, not codepoints."""
 
@@ -2013,16 +2589,42 @@ def split_text_for_tts(text: str, max_chars: int = 80, min_chunk_chars: int = 12
     proactive_sentence_split = (
         len(sentence_units) > 1 and total_units > maximum * 0.60
     )
-    if total_units <= maximum and not proactive_sentence_split:
+    proactive_clause_split = any(
+        _should_split_structured_clauses(unit)
+        and len(_structured_clause_units(unit, maximum)) > 1
+        and count_speech_units(unit) > min(
+            maximum,
+            _STRUCTURED_CLAUSE_TARGET_UNITS,
+        )
+        for unit in sentence_units
+    )
+    if (
+        total_units <= maximum
+        and not proactive_sentence_split
+        and not proactive_clause_split
+    ):
         return [text] if text else []
 
     chunks: list[str] = []
     for unit in sentence_units:
-        pieces = (
-            _hard_split_text(unit, maximum, minimum)
-            if count_speech_units(unit) > maximum
-            else [unit]
-        )
+        clause_units = _structured_clause_units(unit, maximum)
+        if (
+            _should_split_structured_clauses(unit)
+            and len(clause_units) > 1
+            and count_speech_units(unit)
+            > min(maximum, _STRUCTURED_CLAUSE_TARGET_UNITS)
+        ):
+            pieces = _pack_structured_clauses(
+                clause_units,
+                max_units=maximum,
+                min_units=minimum,
+            )
+        else:
+            pieces = (
+                _hard_split_text(unit, maximum, minimum)
+                if count_speech_units(unit) > maximum
+                else [unit]
+            )
         for piece in pieces:
             piece_units = count_speech_units(piece)
             if piece_units < minimum and chunks:
@@ -2243,15 +2845,14 @@ def _comparison_text(
                 return None
 
         def network_boundary_key(value: str) -> str:
-            canonical = _T2S_CONVERTER.convert(
-                normalize_tts_eval_text(value).casefold()
-            )
+            canonical = normalize_tts_eval_text(value).casefold()
             for reading, letter in sorted(
                 _ZH_NETWORK_READING_TO_LETTER.items(),
                 key=lambda item: len(item[0]),
                 reverse=True,
             ):
                 canonical = canonical.replace(reading, letter)
+            canonical = _T2S_CONVERTER.convert(canonical)
             output: list[str] = []
             for character in canonical:
                 digit_key = network_digit_key(character)
@@ -2485,6 +3086,8 @@ def _network_protected_alignment_evidence(
     spoken_spans = network_protected_spoken_spans(normalized_frontend_target)
     if not spoken_spans:
         return 0, True
+    if network_identifier_has_ambiguous_iri(raw_target):
+        return len(spoken_spans), False
 
     target_alignment_text = _comparison_text(
         normalized_frontend_target,

tests/test_production.py

@@ -23,6 +23,7 @@ from production import (
     join_audio_chunks,
     normalize_asr_spoken_forms,
     mandarin_acoustic_units,
+    network_protected_spoken_spans,
     normalize_spoken_forms,
     normalize_tts_eval_text,
     normalize_tts_text,
@@ -36,6 +37,10 @@ from production import (
 )
 
 
+_SPOKEN_HTTPS = "艾取 踢 踢 批 艾斯"
+_SPOKEN_PATH = "批 欸 踢 艾取"
+
+
 def test_eval_only_pronoun_homophones_do_not_change_model_input_text():
     text = "她提醒妳，它、牠和祂都在這裡，再把她的東西放得穩穩地。"
 
@@ -108,19 +113,20 @@ def test_asr_acoustic_endpoint_gate_keeps_ascii_identifiers_literal():
 
 
 @pytest.mark.parametrize(
-    "mutate",
+    "mutated_url",
     [
-        lambda text: text.replace("H T T P S", "H T P S"),
-        lambda text: text.replace("example", "exampl1"),
-        lambda text: text.replace("踢 達不溜 斜線 path", "踢"),
-        lambda text: text.replace("museum", "museun"),
-        lambda text: text.replace("museum", "museuman"),
+        "htps://museum.example.tw/path",
+        "https://museum.exampl1.tw/path",
+        "https://museum.example.t",
+        "https://museun.example.tw/path",
+        "https://museuman.example.tw/path",
     ],
     ids=["htps", "exampl1", "tld_path_omission", "museun", "museuman"],
 )
-def test_network_protected_span_cannot_be_hidden_by_whole_cer(mutate):
+def test_network_protected_span_cannot_be_hidden_by_whole_cer(mutated_url):
+    target_url = "https://museum.example.tw/path"
     raw_target = (
-        "請先閱讀 https://museum.example.tw/path，確認展覽時間與集合位置後再回覆。"
+        f"請先閱讀 {target_url}，確認展覽時間與集合位置後再回覆。"
     )
     target = normalize_spoken_forms(raw_target)
     exact = compare_asr_text(target, target, max_cer=0.20)
@@ -128,7 +134,9 @@ def test_network_protected_span_cannot_be_hidden_by_whole_cer(mutate):
     assert exact.network_protected_spans == 1
     assert exact.network_protected_spans_passed is True
 
-    transcript = mutate(target)
+    transcript = normalize_spoken_forms(
+        raw_target.replace(target_url, mutated_url)
+    )
     comparison = compare_asr_text(
         target,
         transcript,
@@ -183,10 +191,14 @@ def test_network_boundary_provenance_keeps_adjacent_outside_insertions_outside(
 @pytest.mark.parametrize(
     "mutate",
     (
-        lambda text: text.replace("，H T T P S", "，X H T T P S"),
-        lambda text: text.replace("，H T T P S", "，§ H T T P S"),
-        lambda text: text.replace("path，", "path X，"),
-        lambda text: text.replace("path，", "path§，"),
+        lambda text: text.replace(
+            f"，{_SPOKEN_HTTPS}", f"，X {_SPOKEN_HTTPS}"
+        ),
+        lambda text: text.replace(
+            f"，{_SPOKEN_HTTPS}", f"，§ {_SPOKEN_HTTPS}"
+        ),
+        lambda text: text.replace(f"{_SPOKEN_PATH}，", f"{_SPOKEN_PATH} X，"),
+        lambda text: text.replace(f"{_SPOKEN_PATH}，", f"{_SPOKEN_PATH}§，"),
     ),
 )
 def test_network_boundary_provenance_rejects_insertions_inside_span_edges(mutate):
@@ -243,9 +255,11 @@ def test_network_boundary_sentinel_rejects_inside_insertions_after_delimiter_sub
         "前方甲乙，https://example.tw/path，後方丙丁。"
     )
     transcript = (
-        target.replace("，H T T P S", f"{boundary}X H T T P S")
+        target.replace(
+            f"，{_SPOKEN_HTTPS}", f"{boundary}X {_SPOKEN_HTTPS}"
+        )
         if side == "before"
-        else target.replace("path，", f"pathX{boundary}")
+        else target.replace(f"{_SPOKEN_PATH}，", f"{_SPOKEN_PATH}X{boundary}")
     )
     comparison = compare_asr_text(
         target,
@@ -266,9 +280,9 @@ def test_network_boundary_sentinel_allows_pure_delimiter_omission(side):
         "前方甲乙，https://example.tw/path，後方丙丁。"
     )
     transcript = (
-        target.replace("甲乙，H T T P S", "甲乙H T T P S")
+        target.replace(f"甲乙，{_SPOKEN_HTTPS}", f"甲乙{_SPOKEN_HTTPS}")
         if side == "before"
-        else target.replace("path，後方", "path後方")
+        else target.replace(f"{_SPOKEN_PATH}，後方", f"{_SPOKEN_PATH}後方")
     )
     comparison = compare_asr_text(target, transcript, max_cer=0.20)
 
@@ -287,9 +301,11 @@ def test_network_boundary_sentinel_fails_closed_when_omission_is_lexically_ambig
         "前方甲乙，https://example.tw/path，後方丙丁。"
     )
     transcript = (
-        target.replace("，H T T P S", f"{insertion} H T T P S")
+        target.replace(
+            f"，{_SPOKEN_HTTPS}", f"{insertion} {_SPOKEN_HTTPS}"
+        )
         if side == "before"
-        else target.replace("path，", f"path{insertion}")
+        else target.replace(f"{_SPOKEN_PATH}，", f"{_SPOKEN_PATH}{insertion}")
     )
     comparison = compare_asr_text(
         target,
@@ -383,6 +399,290 @@ def test_asr_network_fragment_punctuation_is_target_proven_only():
     assert normalize_asr_spoken_forms("版本v1.2", "版本v一點二") != "版本v1 點 2"
 
 
+def test_asr_xiaolaoshu_is_authorized_by_complete_target_email_coverage():
+    target = "請寄信到 museum@example.tw，完成後回覆。"
+    transcript = "請寄信到 museum Xiaolaoshu example.tw，完成後回覆。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+    comparison = compare_asr_text(target, transcript, max_cer=0.20)
+
+    assert "Xiaolaoshu" not in normalized
+    assert normalized.count("小老鼠") == 1
+    assert comparison.network_protected_spans == 1
+    assert comparison.network_protected_spans_passed is True
+    assert comparison.passed
+
+
+def test_asr_xiaolaoshu_wrong_domain_cannot_borrow_email_proof():
+    target = "請寄信到 museum@example.tw，完成後回覆。"
+    transcript = "請寄信到 museum Xiaolaoshu example.com，完成後回覆。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+    comparison = compare_asr_text(
+        target,
+        transcript,
+        max_cer=1.0,
+        max_prefix_cer=1.0,
+        max_suffix_cer=1.0,
+    )
+
+    assert "Xiaolaoshu" in normalized
+    assert comparison.network_protected_spans == 1
+    assert comparison.network_protected_spans_passed is False
+    assert not comparison.passed
+
+
+def test_asr_xiaolaoshu_network_insertion_is_not_exact_coverage():
+    target = "請寄信到 museum@example.tw，完成後回覆。"
+    transcript = "請寄信到 museum Xiaolaoshu exam§ple.tw，完成後回覆。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+    comparison = compare_asr_text(
+        target,
+        transcript,
+        max_cer=1.0,
+        max_prefix_cer=1.0,
+        max_suffix_cer=1.0,
+    )
+
+    assert "Xiaolaoshu" in normalized
+    assert comparison.network_protected_spans_passed is False
+    assert not comparison.passed
+
+
+def test_asr_xiaolaoshu_literal_network_label_is_not_rewritten():
+    target = "請看 https://example.tw/xiaolaoshu，完成後回覆。"
+    transcript = (
+        "請看 H T T P S 冒號 斜線 斜線 example 點 T W "
+        "斜線 Xiaolaoshu，完成後回覆。"
+    )
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert "小老鼠" not in normalized
+    assert compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+@pytest.mark.parametrize(
+    ("target", "transcript"),
+    (
+        (
+            "https://example.tw/a@b",
+            "H T T P S 冒號 斜線 斜線 example 點 T W 斜線 aXiaolaoshub",
+        ),
+        (
+            "www.example.tw/a@b",
+            "W W W 點 example 點 T W 斜線 aXiaolaoshub",
+        ),
+    ),
+)
+def test_asr_xiaolaoshu_alias_cannot_borrow_url_path_at_sign(target, transcript):
+    normalized = normalize_asr_spoken_forms(transcript, target)
+    comparison = compare_asr_text(
+        target,
+        transcript,
+        max_cer=1.0,
+        max_prefix_cer=1.0,
+        max_suffix_cer=1.0,
+    )
+
+    assert "小老鼠" not in normalized
+    assert comparison.network_protected_spans == 1
+    assert comparison.network_protected_spans_passed is False
+    assert not comparison.passed
+
+
+def test_asr_xiaolaoshu_no_space_email_alias_gets_token_boundaries():
+    target = "請寄到 tour.help@IslandMuseum.tw。"
+    transcript = "請寄到 tour.helpXiaolaoshuIslandMuseum.tw。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert "xiaolaoshu" not in normalized.casefold()
+    assert " 小老鼠 " in normalized
+    assert compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+def test_asr_xiaolaoshu_keeps_overlapping_email_proofs_independent():
+    target = "請寄到 a@example.tw 與 xa@example.tw。"
+    transcript = "請寄到 aXiaolaoshuexample.tw 與 xa@example.tw。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert "xiaolaoshu" not in normalized.casefold()
+    assert compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+def test_asr_xiaolaoshu_rejects_suffix_of_longer_email_local():
+    target = "請寄到 a@example.tw。"
+    transcript = "請寄到 xaXiaolaoshuexample.tw。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+    comparison = compare_asr_text(
+        target,
+        transcript,
+        max_cer=1.0,
+        max_prefix_cer=1.0,
+        max_suffix_cer=1.0,
+    )
+
+    assert "xiaolaoshu" in normalized.casefold()
+    assert comparison.network_protected_spans_passed is False
+    assert not comparison.passed
+
+
+def test_asr_xiaolaoshu_accepts_www_email_local_part():
+    target = "www.foo@example.tw"
+    transcript = "W W W 點 fooXiaolaoshuexample 點 T W"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert "xiaolaoshu" not in normalized.casefold()
+    assert compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+def test_literal_mouse_and_snack_prose_is_not_a_network_identifier():
+    target = (
+        "孩子今天看到 小老鼠 吃了 點 心，覺得很可愛。"
+        "這是一般文字而不是信箱。"
+    )
+    transcript = target.replace("小老鼠", "Xiaolaoshu")
+
+    assert network_protected_spoken_spans(target) == ()
+    assert split_text_for_tts(target, max_chars=80, min_chunk_chars=12) == [target]
+    assert select_generation_cps(target, cjk_cps=5.2, ascii_cps=4.6) == 5.2
+    assert "xiaolaoshu" in normalize_asr_spoken_forms(transcript, target).casefold()
+    assert not compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+def test_email_ampersand_cannot_be_dropped_below_whole_cer_limit():
+    target = "一般文字中放入 a&b@example.tw 之後繼續說明完整內容。"
+    transcript = target.replace("a&b@example.tw", "b@example.tw")
+    comparison = compare_asr_text(target, transcript, max_cer=0.20)
+
+    assert comparison.cer < 0.20
+    assert comparison.network_protected_spans == 1
+    assert comparison.network_protected_spans_passed is False
+    assert not comparison.passed
+
+
+def test_two_email_aliases_joined_by_he_are_proven_independently():
+    target = "a@example.tw 和 b@example.tw"
+    transcript = "aXiaolaoshuexample.tw 和 bXiaolaoshuexample.tw"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert normalized.count("小老鼠") == 2
+    assert "xiaolaoshu" not in normalized.casefold()
+    assert compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+@pytest.mark.parametrize(
+    ("target", "transcript"),
+    (
+        ("6g@example.tw", "6g Xiaolaoshu example 点 T W"),
+        (
+            "https://x.tw/8l",
+            "H T T P S 冒号 斜线 斜线 X 点 T W 斜线 8l",
+        ),
+        (
+            "https://x.tw/12.5%",
+            "H T T P S 冒号 斜线 斜线 X 点 T W 斜线 12.5%",
+        ),
+    ),
+)
+def test_network_tokens_bypass_prose_unit_normalization(target, transcript):
+    comparison = compare_asr_text(target, transcript, max_cer=0.20)
+
+    assert comparison.cer == 0.0
+    assert comparison.network_protected_spans_passed is True
+    assert comparison.passed
+
+
+def test_simplified_network_letter_reading_matches_ascii_i():
+    target = "https://i.tw"
+    transcript = "H T T P S 冒号 斜线 斜线 爱 点 T W"
+
+    assert compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+@pytest.mark.parametrize("transcript", ("https://x.tw/愛", "https://x.tw/i"))
+def test_non_ascii_iri_is_explicitly_unsupported_and_fails_closed(transcript):
+    comparison = compare_asr_text(
+        "https://x.tw/愛",
+        transcript,
+        max_cer=1.0,
+        max_prefix_cer=1.0,
+        max_suffix_cer=1.0,
+    )
+
+    assert comparison.network_protected_spans == 1
+    assert comparison.network_protected_spans_passed is False
+    assert not comparison.passed
+
+
+@pytest.mark.parametrize(
+    ("transcript", "expected_prefix_cer", "expected_suffix_cer"),
+    (
+        (
+            "前方甲乙X，H T T P S 冒號 斜線 斜線 orange 點 "
+            "伊 艾克斯 欸 艾姆 批 艾爾 伊 點 踢 達不溜 斜線 road，"
+            "後方丙丁。",
+            1.0 / 6.0,
+            0.0,
+        ),
+        (
+            "前方甲乙，H T T P S 冒號 斜線 斜線 orange 點 "
+            "伊 艾克斯 欸 艾姆 批 艾爾 伊 點 踢 達不溜 斜線 road，"
+            "X後方丙丁。",
+            0.0,
+            1.0 / 6.0,
+        ),
+    ),
+)
+def test_mixed_network_boundary_insertion_does_not_lexicalize_frontend_comma(
+    transcript,
+    expected_prefix_cer,
+    expected_suffix_cer,
+):
+    target = "前方甲乙，https://orange.example.tw/road，後方丙丁。"
+    comparison = compare_asr_text(
+        target,
+        transcript,
+        max_cer=0.10,
+        max_prefix_cer=1.0,
+        max_suffix_cer=1.0,
+    )
+
+    assert comparison.cer == pytest.approx(1.0 / 42.0)
+    assert comparison.prefix_cer == pytest.approx(expected_prefix_cer)
+    assert comparison.suffix_cer == pytest.approx(expected_suffix_cer)
+    assert comparison.network_protected_spans == 1
+    assert comparison.network_protected_spans_passed is True
+    assert comparison.passed
+
+
+def test_asr_xiaolaoshu_prose_insertion_stays_literal_while_email_is_exact():
+    target = "請寄信到 museum@example.tw，完成後回覆。"
+    transcript = "Xiaolaoshu，請寄信到 museum@example.tw，完成後回覆。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert normalized.startswith("Xiaolaoshu，")
+    assert normalized.count("小老鼠") == 1
+    assert not compare_asr_text(target, transcript, max_cer=0.20).passed
+
+
+def test_asr_xiaolaoshu_without_email_target_is_not_rewritten():
+    target = "今天說明網路用語。"
+    transcript = "今天說明 Xiaolaoshu 網路用語。"
+
+    normalized = normalize_asr_spoken_forms(transcript, target)
+
+    assert "Xiaolaoshu" in normalized
+    assert "小老鼠" not in normalized
+
+
 class _SequenceStopHead(nn.Module):
     def __init__(self, probabilities):
         super().__init__()
@@ -488,7 +788,143 @@ def test_split_uses_speech_units_instead_of_expanded_codepoints():
     )
     assert len(text) > 80
     assert count_speech_units(text) <= 80
-    assert split_text_for_tts(text, max_chars=80, min_chunk_chars=12) == [text]
+    chunks = split_text_for_tts(text, max_chars=80, min_chunk_chars=12)
+    assert chunks == [
+        "若系統顯示 H T T P S 冒號 斜線 斜線 weatherstation 點 sample 點 tw "
+        "訊號超過 百分之六十，",
+        "工作人員就改走安全替代路線，並且重新確認集合位置。",
+    ]
+    assert [count_speech_units(chunk) for chunk in chunks] == [34, 23]
+
+
+@pytest.mark.parametrize(
+    ("text_id", "raw_text", "expected_chunks"),
+    (
+        (
+            "H01",
+            "燈亮之後才開門，離開前記得關好後窗。",
+            ("燈亮之後才開門，離開前記得關好後窗。",),
+        ),
+        (
+            "H02",
+            "陶藝課今天改到二樓，學員可以先在走廊等候老師。",
+            ("陶藝課今天改到二樓，學員可以先在走廊等候老師。",),
+        ),
+        (
+            "H08",
+            "控制器版本 v5.4.2 將搭配模組 NX-730 進行相容性測試。",
+            ("控制器版本五點四點二 將搭配模組 N X 七三零 進行相容性測試。",),
+        ),
+        (
+            "H09",
+            "阿嬤笑著說：「蘿蔔糕要趁熱吃。」大家聽完都把筷子準備好了。",
+            ("阿嬤笑著說：「蘿蔔糕要趁熱吃。」大家聽完都把筷子準備好了。",),
+        ),
+        (
+            "H10",
+            (
+                "清晨開館以前，水族館人員會先量測各池的水溫與鹽度，"
+                "再觀察魚群是否正常進食。確認照明、循環馬達和緊急電源"
+                "都沒有異常後，才會打開入口讓第一批遊客進場。"
+            ),
+            (
+                "清晨開館以前，水族館人員會先量測各池的水溫與鹽度，"
+                "再觀察魚群是否正常進食。",
+                "確認照明、循環馬達和緊急電源都沒有異常後，"
+                "才會打開入口讓第一批遊客進場。",
+            ),
+        ),
+    ),
+)
+def test_frontend_clause_split_preserves_nonstructured_holdout_chunking(
+    text_id,
+    raw_text,
+    expected_chunks,
+):
+    del text_id
+    normalized = normalize_spoken_forms(raw_text)
+
+    assert split_text_for_tts(normalized, max_chars=80, min_chunk_chars=12) == list(
+        expected_chunks
+    )
+
+
+def test_frontend_clause_split_matrix_for_structured_and_network_holdouts():
+    raw_h11 = (
+        "山區步道的志工預計在 2028/10/21 上午 07:15 集合，"
+        "先用定位器 AX-520 核對座標，再分組檢查木棧道、里程牌與飲水站。"
+        "若氣象網站 https://trailweather.example.tw 顯示降雨機率超過 65%，"
+        "領隊就取消高海拔路線，改走較短的林間環線。"
+        "途中若發現落石或樹枝阻斷通行，請拍照並寄到 "
+        "patrol@forestmail.tw，不要自行搬動大型障礙物。"
+        "所有隊員回到登山口後，還要清點無線電與急救包，"
+        "確認沒有任何人落單，才結束當天的巡查。"
+    )
+    matrix = {
+        "H05": (
+            "這批咖啡豆重 2.75 kg，會員價是 NT$1,480，回饋比例為 6.5%。",
+            (
+                "這批咖啡豆重 二點七五公斤，",
+                "會員價是 新台幣一千四百八十，回饋比例為 百分之六點五。",
+            ),
+            (12, 24),
+        ),
+        "H06": (
+            "若要更換導覽場次，請寄信到 tour.help@islandmuseum.tw。",
+            (
+                "若要更換導覽場次，請寄信到，",
+                "踢 歐 優 阿爾 點 艾取 伊 艾爾 批 小老鼠 愛 艾斯 "
+                "艾爾 欸 恩 迪 艾姆 優 艾斯 伊 優 艾姆 點 踢 達不溜。",
+            ),
+            (12, 37),
+        ),
+        "H07": (
+            "潮汐預報可查詢 https://coastwatch.example.tw/tide。",
+            (
+                "潮汐預報可查詢，艾取 踢 踢 批 艾斯 冒號 斜線 斜線 西 歐 "
+                "欸 艾斯 踢 達不溜 欸 踢 西 艾取 點 伊 艾克斯 欸 艾姆 "
+                "批 艾爾 伊 點 踢 達不溜 斜線 踢 愛 迪 伊。",
+            ),
+            (57,),
+        ),
+        "H11": (
+            raw_h11,
+            (
+                "山區步道的志工預計在 二零二八年十月二十一日 上午 "
+                "七點十五分 集合，",
+                "先用定位器 A X 五二零 核對座標，再分組檢查木棧道、"
+                "里程牌與飲水站。",
+                "若氣象網站，艾取 踢 踢 批 艾斯 冒號 斜線 斜線 踢 阿爾 "
+                "欸 愛 艾爾 達不溜 伊 欸 踢 艾取 伊 阿爾 點 伊 艾克斯 "
+                "欸 艾姆 批 艾爾 伊 點 踢 達不溜，",
+                "顯示降雨機率超過 百分之六十五，",
+                "領隊就取消高海拔路線，改走較短的林間環線。",
+                "途中若發現落石或樹枝阻斷通行，請拍照並寄到，",
+                "批 欸 踢 阿爾 歐 艾爾 小老鼠 艾夫 歐 阿爾 伊 艾斯 "
+                "踢 艾姆 欸 愛 艾爾 點 踢 達不溜，不要自行搬動大型障礙物。",
+                "所有隊員回到登山口後，還要清點無線電與急救包，"
+                "確認沒有任何人落單，才結束當天的巡查。",
+            ),
+            (30, 29, 53, 14, 19, 20, 42, 38),
+        ),
+    }
+
+    for raw_text, expected_chunks, expected_units in matrix.values():
+        normalized = normalize_spoken_forms(raw_text)
+        chunks = split_text_for_tts(normalized, max_chars=80, min_chunk_chars=12)
+
+        assert chunks == list(expected_chunks)
+        assert "".join(chunks) == normalized
+        assert tuple(count_speech_units(chunk) for chunk in chunks) == expected_units
+        assert all(12 <= count_speech_units(chunk) <= 80 for chunk in chunks)
+        for protected_span in network_protected_spoken_spans(normalized):
+            protected_chunks = [chunk for chunk in chunks if protected_span in chunk]
+            assert len(protected_chunks) == 1
+            assert select_generation_cps(
+                protected_chunks[0],
+                cjk_cps=5.2,
+                ascii_cps=4.6,
+            ) == 4.6
 
 
 def test_split_preserves_long_strong_sentences_and_is_deterministic():
@@ -506,6 +942,15 @@ def test_split_preserves_long_strong_sentences_and_is_deterministic():
     assert "".join(first) == text
 
 
+def test_structured_short_leading_clause_falls_back_to_legal_hard_split():
+    text = "折扣為百分之五，會員價新台幣一千元" + "甲" * 68
+
+    chunks = split_text_for_tts(text, max_chars=80, min_chunk_chars=12)
+
+    assert "".join(chunks) == text
+    assert [count_speech_units(chunk) for chunk in chunks] == [72, 12]
+
+
 def test_chunk_coalescing_respects_runtime_budget_without_losing_text():
     sentence = "甲乙丙丁戊己庚辛壬癸子丑。"
     chunks = [sentence] * 21
@@ -613,6 +1058,14 @@ def test_ascii_text_receives_a_wider_generation_window():
     assert select_generation_cps("AI TTS 測試", cjk_cps=5.2, ascii_cps=4.6) == 4.6
 
 
+def test_explicit_letter_network_text_keeps_the_ascii_generation_window():
+    normalized = normalize_spoken_forms("https://example.tw/path")
+
+    assert not any(character.isascii() and character.isalnum() for character in normalized)
+    assert network_protected_spoken_spans(normalized)
+    assert select_generation_cps(normalized, cjk_cps=5.2, ascii_cps=4.6) == 4.6
+
+
 def test_short_text_uses_stronger_cfg_without_changing_long_text():
     assert effective_generation_cfg("你好", 2.0) == 3.0
     assert effective_generation_cfg("測試完成", 2.5) == 3.0
@@ -713,6 +1166,20 @@ def test_finish_audio_fades_endpoint_and_appends_silence():
     assert output[-5] < output[-6] < output[-7]
 
 
+def test_five_millisecond_finish_fade_preserves_the_preceding_tail_and_pad():
+    output = finish_audio(
+        np.ones(1_000, dtype=np.float32),
+        1_000,
+        fade_ms=5,
+        trailing_silence_ms=180,
+    )
+
+    assert output.shape == (1_180,)
+    np.testing.assert_allclose(output[:996], 1.0)
+    assert output[999] == 0.0
+    np.testing.assert_allclose(output[1_000:], 0.0)
+
+
 def test_spoken_form_normalizer_expands_common_zh_tw_forms():
     text = "日期 2026/07/15，成長 12.5%，距離 10 km，顯卡 RTX 5090。"
     assert normalize_spoken_forms(text) == (
@@ -740,8 +1207,9 @@ def test_spoken_form_normalizer_expands_clock_time_and_spells_urls():
         "無效 24點30分、15點60分。"
     )
     assert normalize_spoken_forms("IP 192.168.1.1，網址 https://example.test:30/path") == (
-        "I P 192.168.1.1，網址，H T T P S 冒號 斜線 斜線 "
-        "example 點 test 冒號 三零 斜線 path"
+        "I P 192.168.1.1，網址，艾取 踢 踢 批 艾斯 冒號 斜線 斜線 "
+        "伊 艾克斯 欸 艾姆 批 艾爾 伊 點 踢 伊 艾斯 踢 "
+        "冒號 三零 斜線 批 欸 踢 艾取"
     )
     assert normalize_spoken_forms(
         "音量15點05分貝，區間15點30分鐘，比分15點05分。"
@@ -1177,11 +1645,14 @@ def test_spoken_form_normalizer_expands_network_identifiers_and_versions():
     assert normalize_spoken_forms(
         "網址 https://api.example.com/v1/items?q=RTX-5090&n=2。"
     ) == (
-        "網址，H T T P S 冒號 斜線 斜線 api 點 example 點 西 歐 艾姆 斜線 v 一 "
-        "斜線 items 問號 q 等於 RTX 橫線 五零九零 和 n 等於 二。"
+        "網址，艾取 踢 踢 批 艾斯 冒號 斜線 斜線 欸 批 愛 點 "
+        "伊 艾克斯 欸 艾姆 批 艾爾 伊 點 西 歐 艾姆 斜線 維 一 "
+        "斜線 愛 踢 伊 艾姆 艾斯 問號 丘 等於 阿爾 踢 艾克斯 "
+        "橫線 五零九零 和 恩 等於 二。"
     )
     assert normalize_spoken_forms("信箱 USER.name+tts@example.com。") == (
-        "信���，USER 點 name 加號 tts 小老鼠 example 點 西 歐 艾姆。"
+        "信箱，優 艾斯 伊 阿爾 點 恩 欸 艾姆 伊 加號 踢 踢 艾斯 "
+        "小老鼠 伊 艾克斯 欸 艾姆 批 艾爾 伊 點 西 歐 艾姆。"
     )
     assert normalize_spoken_forms(
         "版本 v1.2.3，候選 version 10.4.0-beta.1+build.5。"
@@ -1224,7 +1695,10 @@ def test_network_protected_span_never_drops_supported_punctuation(target, mutati
 )
 def test_expanded_url_rejects_raw_symbol_inserted_inside_path(symbol):
     target = normalize_spoken_forms("https://example.tw/path")
-    transcript = target.replace("path", f"pa{symbol}th")
+    transcript = target.replace(
+        _SPOKEN_PATH,
+        f"批 欸{symbol}踢 艾取",
+    )
     comparison = compare_asr_text(
         target,
         transcript,
@@ -1241,7 +1715,10 @@ def test_expanded_url_rejects_raw_symbol_inserted_inside_path(symbol):
 @pytest.mark.parametrize("symbol", ("$", "!", "?", "_", "+", "§"))
 def test_expanded_email_rejects_raw_symbol_inserted_inside_local_part(symbol):
     target = normalize_spoken_forms("museum@example.tw")
-    transcript = target.replace("museum", f"mu{symbol}seum")
+    transcript = target.replace(
+        "艾姆 優 艾斯 伊 優 艾姆",
+        f"艾姆 優{symbol}艾斯 伊 優 艾姆",
+    )
     comparison = compare_asr_text(
         target,
         transcript,
@@ -1397,7 +1874,7 @@ def test_expanded_www_url_keeps_an_exact_protected_span():
     )
     comparison = compare_asr_text(
         target,
-        target.replace("path", "pat"),
+        target.replace(_SPOKEN_PATH, "批 欸 踢"),
         max_cer=0.20,
         max_prefix_cer=1.0,
         max_suffix_cer=1.0,

tests/test_quality_runtime.py

@@ -810,7 +810,10 @@ def test_quality_gate_rejects_inexact_network_span_below_whole_cer_limit():
     target = normalize_spoken_forms(
         "請先閱讀 https://museum.example.tw/path，確認展覽時間與集合位置後再回覆。"
     )
-    transcript = target.replace("museum", "museuman")
+    transcript = target.replace(
+        "艾姆 優 艾斯 伊 優 艾姆",
+        "艾姆 優 艾斯 伊 優 艾姆 欸 恩",
+    )
     result = verify_candidate(
         CandidateObservation(
             target_text=target,

tests/test_release_pins.py

@@ -252,6 +252,24 @@ def test_app_wires_candidate_offset_to_explicit_generation_policy_and_logs_it():
     assert "short_floor_applied={short_floor_applied}" in source
 
 
+def test_app_rejects_ambiguous_iri_before_frontend_normalization():
+    source = (ROOT / "app.py").read_text(encoding="utf-8")
+    synthesize_start = source.index("def _synthesize(")
+    iri_guard = source.index(
+        "if network_identifier_has_ambiguous_iri(text):",
+        synthesize_start,
+    )
+    normalization = source.index(
+        'text = normalize_spoken_forms(text, locale="zh-TW")',
+        synthesize_start,
+    )
+
+    assert synthesize_start < iri_guard < normalization
+    assert "非 ASCII IRI 必須先轉成 ASCII/percent-encoded" in (
+        ROOT / "README.md"
+    ).read_text(encoding="utf-8")
+
+
 def test_app_does_not_add_an_artificial_onset_split():
     source = (ROOT / "app.py").read_text(encoding="utf-8")
     tree = ast.parse(source)
@@ -438,8 +456,17 @@ def test_app_reverifies_the_post_join_speed_adjusted_whole_waveform():
     speed_index = assemble_source.index(
         "waveform = _apply_speed(waveform, playback_speed)"
     )
-    finish_index = assemble_source.index("return finish_audio(waveform, SR, fade_ms=finish_fade_ms)")
+    finish_index = assemble_source.index(
+        "return finish_audio(waveform, SR, fade_ms=finish_fade_ms)"
+    )
     assert speed_index < finish_index
+    assert (
+        'finish_fade_ms = 0.0 if count_speech_units("".join(chunks)) <= 6 else 5.0'
+        in assemble_source
+    )
+    assert "else 60.0" not in assemble_source
+    production_source = (ROOT / "production.py").read_text(encoding="utf-8")
+    assert "trailing_silence_ms: float = 180.0" in production_source
     assemble_index = synthesize_source.index(
         "waveform = _assemble_trajectory_audio(cascade.trajectory, chunks, speed)"
     )