ffmpeg-skill 2.18.0 → 2.20.0

package/README.md

@@ -393,12 +393,12 @@ The short list for humans. The agent-facing version, with the reasoning, is the
 - **Phrase-aware caption breaking (1.16).** `caption.py`/`graphics.py --wrap phrase` (the default) never breaks inside a word or on the wrong side of a hyphen, never leaves a lone digit, kana or punctuation pair on a line, prefers Japanese sentence ends and particles over a mid-word break, and never ends a line on an article or preposition. All four are penalties over break positions that already fit, so no line is widened and the line count never changes; `--wrap measured` restores 1.15's width-only wrap. The text itself is never rewritten or shortened. Since 1.16.1 a Thai run and a katakana word are never broken inside (Thai writes no space inside a phrase and there is no dictionary: the break goes where you put a space or `|`), and a line wider than the safe width is reported as `overlong` with the fix named.
 - **Caption size fitted to the cue (1.17, reachable from the templates since 1.17.1).** At a platform caption size a line holds about six em, so an ordinary sentence needs four lines and `--max-lines 2` used to cut it into consecutive cues — half the sentence arriving late. `caption.py --fit-size` (default `auto`) walks the size down until every cue fits, *before* laying the cues out, with a legibility floor of 4.5 % of the frame height (`--min-size`, default 13 ASS units). An explicit `--size` or a `brand.json` size is a statement about the look and is never overridden — which in 1.17.0 also silenced the fitter on every `render.py --template` run, since a template fills the size from the platform table; 1.17.1 marks that size as the default it is (`"fit_size": "on"` in the filled project), so the type shrinks and no cue is split. `--fit-size off` restores that earlier behaviour byte for byte, and the caption text is still never rewritten to make it fit.
 - **Beat-synced cuts (1.17).** `scenes.py --beats` reports the measured grid — tempo, beat times, and a confidence built from how far the winning autocorrelation lag stands above the others and how many onsets land on it. `cut.py --snap beats` (and a `"snap"` block in a `render.py` project) moves in/out points to the nearest beat within `--snap-tolerance` — and only onto the grid points a measured onset actually marks, never onto the regular grid's continuation through a passage with no music in it. Below `--min-confidence` it **refuses**: a cut point may move to a measured beat and may not appear from one, so speech and ambience get an honest "no steady pulse here" instead of an invented grid.
-- **Filler words (1.17).** `silence.py --filler --words transcript.json` removes "um" and "uh" through the same cut graph the silences use. Never without measured word timings — there is no heuristic that finds an "um" without them that would not also cut real speech — and `like`, `tipo` and `cioè` are deliberately not in the built-in lists, because a discourse marker is a content word. Whisper stays optional: `--transcribe` with no engine installed refuses and names the five installs.
+- **Filler words (1.17).** `silence.py --filler --words transcript.json` removes "um" and "uh" through the same cut graph the silences use. Never without measured word timings — there is no heuristic that finds an "um" without them that would not also cut real speech — and `like`, `tipo` and `cioè` are deliberately not in the built-in lists, because a discourse marker is a content word. Built-in lists since 2.19: English, Japanese, Korean, Chinese, Spanish, German, French, Portuguese, Italian, Dutch, Polish, Russian and Turkish; any other language takes `--filler-words FILE`. Whisper stays optional: `--transcribe` with no engine installed refuses and names the five installs.
 - **Throughput (1.17).** `batch.py --jobs N` runs several files at once, capped at `min(N, cpu_count, 8)` and sharing one `--timeout` budget rather than one per item; the per-item table keeps its order. `render.py --cache DIR` reuses stages whose inputs and arguments did not change, so swapping an export preset re-runs export only. The cache is opt-in with no default directory, and the ffmpeg, skill and contract versions are part of every key, so a cache is never reused across them.
 - **Audiogram (1.16).** `waveform.py --image cover.png` (or `render.py --template audiogram`) puts the waveform over a still plate for an episode that has no picture, with `--platform` for the frame, `--title` and burnt-in captions. The image is a local file you give: nothing is fetched and no cover art is ever invented.
 - **Emoji in captions and titles (1.15).** `caption.py`/`graphics.py --emoji-assets DIR` composites a PNG per emoji (Twemoji/Noto naming, `1f389.png`) on top of the text, because drawtext cannot load a colour emoji font at all and an installed one does not prove libass will draw it in colour — `doctor --json`'s `fonts.emoji` answers that from a render probe. Without assets the run still succeeds and reports `mode: mono`. Nothing is ever downloaded.
 - **Indic and Thai text shaped correctly in titles and lower-thirds (1.15).** `graphics.py` renders Devanagari, Bengali, Tamil, Thai and Lao through libass automatically (`text_renderer: "ass"`), because drawtext never reorders matras or re-clusters marks; Arabic and Hebrew were already correct on a fribidi build. `--text-render drawtext` with such a script is refused, never rendered wrongly.
-- **Non-Latin text picks a font by script (1.12).** Japanese, Chinese, Korean, Arabic, Hebrew, Devanagari, Thai, Cyrillic and Greek cues, titles and overlays resolve a font file that covers them automatically, and a machine with no such font fails the job (`kind: input`) instead of rendering boxes. `doctor --json`'s `fonts.scripts` says which languages this machine can render; `--lang ja|ko` disambiguates Han-only text; an explicit `--font`/`--font-file` is always kept.
+- **Non-Latin text picks a font by script (1.12).** Japanese, Chinese, Korean, Arabic, Hebrew, Devanagari, Thai, Cyrillic and Greek cues, titles and overlays resolve a font file that covers them automatically, and a machine with no such font fails the job (`kind: input`) instead of rendering boxes. `doctor --json`'s `fonts.scripts` says which languages this machine can render; `--lang ja|ko` disambiguates Han-only text, and `--lang zh-TW` (or `zh-HK`, `zh-Hant`) picks a Traditional Chinese face (2.19); an explicit `--font`/`--font-file` is always kept.
 - **Silence detection finds nothing?** The default threshold is −35 dBFS. The tool prints a hint with the track's measured level; raise the threshold (`silence.py --threshold -25`) or shorten `--min-silence`.
 - **Sync results carry a confidence.** Below 0.3, or an offset near the edge of the analysis window, is probably wrong: enlarge `--analyze-seconds` or find a clap. Recordings over ten minutes from separate devices need `sync.py --fix-drift`.
 - **Outputs are never overwritten silently.** An existing output path is refused (`kind: input`, `error.reason: output_exists`, before anything runs); pass `--overwrite` where a replacement is intended.

package/SKILL.md

@@ -34,7 +34,7 @@ Ask a short question only when the answer changes the output materially and the
 - **Duration** ("make it 60 s") without a method: speed up for ≤1.5× changes, trim otherwise, say which. Ask when the content is a talk (trimming loses words) and the change is large.
 - **Captions** without a text source: `--transcribe` if a local engine exists, else ask for the text or a timed file; never invent dialogue.
 - **Fonts and brand**: if the user mentions a brand, colours or "our font", ask for or create `brand.json` once, reuse it.
-- **CJK / non-Latin text**: let the tool pick the font by script (`--font` turns it off); `--lang ja|ko` for Han-only text. `doctor --json` `.fonts.scripts` says what renders here. Tofu is a failed job.
+- **CJK / non-Latin text**: let the tool pick the font by script (`--font` turns it off); `--lang ja|ko|zh-TW` for Han-only text. `doctor --json` `.fonts.scripts` says what renders here. Tofu is a failed job.
 - **Crop position** for `--fit crop`: centre by default, but when the request or the source names an off-centre subject ("keep the product on the right", someone visibly off-centre in the sheet) use `--crop-x`/`--crop-y` (0=left/top, 1=right/bottom) instead of guessing centre, or ask which edge to keep.
 - Anything else (transition type, caption style): pick the conventional default, say what you picked, offer the alternative in one line.
 

package/docs/contract.md

@@ -21,7 +21,7 @@ The contract is derived from the code that runs, not maintained beside it:
 | Field | Meaning | Changes when |
 |---|---|---|
 | `contract_version` | shape of this document (`1.0`) | a key is renamed, removed or changes meaning |
-| `skill.version` | the npm / package.json version (`2.18.0`) | any release |
+| `skill.version` | the npm / package.json version (`2.20.0`) | any release |
 
 A release that adds a tool or a flag keeps `contract_version`; a breaking change to the
 ToolSpec shape bumps it. Consumers pin on `contract_version` and read `skill.version`
@@ -131,7 +131,7 @@ JSON would have been rewritten for that. The flat keys, typed per tool in `outpu
   "deprecated": [{"what": "running on Python 3.9 (the requirements.python floor)", "since": "2.10.9", "replacement": "Python 3.10 or later; ...", "removed_in": "3.0.0", "where": "behaviour"},
                  {"what": "running on FFmpeg 5.x (the requirements.ffmpeg floor)", "since": "2.14.0", "replacement": "FFmpeg 6.1 or later; ...", "removed_in": "3.0.0", "where": "behaviour"}],
   "removed": [{"what": "...", "since": "1.10.0", "replacement": "...", "removed_in": "2.0.0", "where": "cli | json | mcp | behaviour"}],
-  "skill": {"id": "ffmpeg-skill", "version": "2.18.0", "execution_mode": "local", "kind": "execution",
+  "skill": {"id": "ffmpeg-skill", "version": "2.20.0", "execution_mode": "local", "kind": "execution",
             "entrypoints": {"cli": "...", "mcp": "...", "contract": "...", "doctor": "..."},
             "not_provided": ["AI reasoning", "decisions", "production plans", "project IR", "approvals", "network access", "transcription engine"]},
   "requirements": {"python": ">=3.9 (standard library only; 3.9 deprecated since 2.10.9, removed in 3.0.0; 3.10+ recommended)", "ffmpeg": ">=5.0 (5.x deprecated since 2.14.0, removed in 3.0.0; 6.1+ recommended)", "ffprobe": ">=5.0"},
@@ -699,6 +699,16 @@ from where the expected value came, and what was not measured.
 | `audio_substituted` | `join.py` (video join) | the clips that had no audio stream, whose span of the join is generated silence; `notes` says the same |
 | loudness `tolerance.tp` | `loudness.py`, `export.py`, and `check.py`'s true-peak row | the one dBTP margin every tool applies (`_platforms.TP_TOLERANCE_DB`, 0.1 dB); before 2.18 it was 0.1, 0.05 and 0.0 in the three tools |
 
+Keys added in 2.20, all additive, from the same paper's baseline experiment (each was a length or a
+silence a tool reported as fine while another measurement disagreed):
+
+| key | tool | what it holds |
+|---|---|---|
+| `verification[]` step `duration` | `export.py` (a preset with a platform maximum, without `--allow-long`) | the written file's length against the maximum, measured as `check.py` measures it (the container's duration, `tolerance` 0). A length that cannot be read fails the step with `reason: not_measured` |
+| `verification[]` step `duration` (`property: audio_duration`) | `loudness.py` | the output's sound against the input's, to one AAC frame (at least 0.03 s): a levels pass changes no timing. A length that cannot be read fails the step with `reason: not_measured` |
+| `inputs_duration`, `transition_shortening`; step `duration`'s `inputs_total` | `join.py` | the clips' own total and how much the transitions took out of it. `expected_duration` is derived from the transition the join applied, so it cannot show that on its own |
+| `silence_kinds`, `silence_breakdown` | `silence.py` | per detected silence, `digital` (at or below -90 dBFS) or `below_threshold` (quiet sound under `--threshold`), and the count and seconds of each with the level that defines it |
+
 Per-tool keys added after 2.10.11 ("nothing happens silently"), all additive:
 
 | key | tool | what it holds |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ffmpeg-skill",
-  "version": "2.18.0",
+  "version": "2.20.0",
   "description": "Agent Skill that gives coding agents (Claude Code, Cursor, Codex) a local video editor: 42 FFmpeg tools with a machine-readable contract, contract-derived MCP server, FFmpeg capability detection, probe-first / verify-last workflow. Cut, join, silence removal, fit, captions and karaoke, overlays, motion graphics, HDR to SDR, LUTs, audio clean-up and typed dynamics, sync with drift correction, multicam, loudness, delivery checks, project rendering, batch. No API keys, no cloud, no dependencies.",
   "keywords": [
     "ffmpeg",

package/references/scripts.md

@@ -578,7 +578,7 @@ each shorter clip's last frame (with silence) out to the longest.
 ### silence.py — remove dead air / jump cuts
 ```
 silence.py INPUT [--threshold -35] [--min-silence 0.6] [--margin 0.15] [--min-keep 0.2] [--list] [--edl keep.txt] [--speech-aware] [-o OUT]
-silence.py INPUT --filler --words transcript.json [--filler-lang auto|en|ja|es|de|fr|pt|it]
+silence.py INPUT --filler --words transcript.json [--filler-lang auto|en|ja|ko|zh|es|de|fr|pt|it|nl|pl|ru|tr]
            [--filler-words FILE] [--filler-extra W,W] [--filler-keep W,W] [--filler-pad 0.02]
            [--transcribe] [--engine auto|parakeet-mlx|parakeet.cpp|whisper.cpp|faster-whisper|openai-whisper]
            [--model MODEL] [--filler-list] [--max-cuts 400]
@@ -598,6 +598,11 @@ per-word `start`/`end`) or `--transcribe` (the same local engine `caption.py`
 uses, never required). There is no heuristic fallback — finding an "um" by
 looking for short quiet blips would cut real speech, so the tool refuses
 instead. `--filler-list` reports what would go and writes nothing.
+Built-in lists (2.19): en, ja, ko, zh, es, de, fr, pt, it, nl, pl, ru, tr. They hold
+hesitation sounds only; words that are as often content (`like`, 저, 那个, ну) are
+`--filler-extra` material. Chinese and Japanese are cut only where the transcript shows
+a word boundary on each side (punctuation or a 0.1 s pause), because whisper splits them
+into tokens rather than words.
 `filler.matched_untimed` counts listed words the transcript gives no usable
 timing for (not removed, and a `filler_words_untimed` warning), and
 `matched_too_long` those longer than a filler (a held vowel, kept).
@@ -608,11 +613,17 @@ Built-in lists, one per language:
 |---|---|
 | en | um, uh, erm, hmm, mm, mhm, er, ah |
 | ja | えー, えーと, えっと, あの, あのー, その, そのー, まあ, なんか |
+| ko | 어, 어어, 에, 음, 음음, 으음, 흠 |
+| zh | 呃, 呃呃, 嗯, 嗯嗯, 唔 |
 | es | eh, este, esto, mmm |
 | de | äh, ähm, hm |
 | fr | euh, hein |
 | pt | é, hum |
 | it | ehm |
+| nl | eh, ehm, uh, uhm, hm |
+| pl | yy, yyy, ee, eee, em, emm, hmm |
+| ru | э, ээ, эм, эмм, мм, хм |
+| tr | ıı, ııı, ee, eee, hmm |
 
 **Discourse markers are not disfluencies.** `like`, `tipo` and `cioè` are
 deliberately *not* in the default lists: they are grammatical words in most

package/scripts/_common/asr.py

@@ -12,10 +12,11 @@ from __future__ import annotations
 import json
 import os
 import re
+import unicodedata
 from pathlib import Path
 from typing import Any, Dict, List, NamedTuple, Optional, Tuple
 
-from _common.decision import fmt_srt_time, parse_time
+from _common.decision import _unspaced_script, fmt_srt_time, parse_time
 from _common.emit import die, info, warn
 from _common.runner import read_text_or_die
 
@@ -502,7 +503,11 @@ def _words_from_whisper_cpp_json(path: str) -> "List[Dict[str, Any]]":
 
     Token text carries leading spaces and the model's special tokens ([_BEG_], [_TT_123]); those
     are dropped, and a token that is a word continuation (no leading space) is glued onto the
-    previous word so "un" + "believable" is one word with one span, not two.
+    previous word so "un" + "believable" is one word with one span, not two. Chinese, Japanese
+    and Thai have no spaces, so there every token would continue the one before and a whole
+    segment became one "word": between two whole characters of such a script the tokens stay
+    apart, as openai-whisper and faster-whisper split them (filler_spans() finds the word
+    boundaries). A token that is part of a character (U+FFFD) is still glued.
     """
     try:
         doc = json.loads(Path(path).read_text(encoding="utf-8"))
@@ -519,7 +524,14 @@ def _words_from_whisper_cpp_json(path: str) -> "List[Dict[str, Any]]":
                 start, end = float(offsets["from"]) / 1000.0, float(offsets["to"]) / 1000.0
             except (KeyError, TypeError, ValueError):
                 continue
-            if out and not text.startswith(" "):
+            prev = out[-1]["word"] if out else ""
+            # "嗯" + "，" + "呃": the comma stays with the word before it and ends that word
+            core = prev
+            while core and unicodedata.category(core[-1]).startswith("P"):
+                core = core[:-1]
+            unspaced = (core and _unspaced_script(core[-1]) and _unspaced_script(text.lstrip()[:1] or " ")
+                        and "\ufffd" not in prev[-1:] + text)
+            if out and not text.startswith(" ") and not unspaced:
                 out[-1]["word"] += text
                 out[-1]["end"] = end
             else:

package/scripts/_common/decision.py

@@ -1158,6 +1158,18 @@ FILLER_WORDS = {
     "fr": frozenset({"euh", "hein"}),
     "pt": frozenset({"é", "hum"}),
     "it": frozenset({"ehm"}),
+    # 2.19: Korean is written with spaces, so a whisper word is a word and the list works as the
+    # English one does. 그/저/뭐/이제 are fillers as often as they are "that"/"I"/"what"/"now":
+    # discourse markers below, not defaults.
+    "ko": frozenset({"음", "으음", "음음", "어", "어어", "에", "흠"}),
+    # Chinese has no spaces: these match only as a whole token with a boundary on each side
+    # (filler_spans), so the 额 of 金额 or the 呃 inside a word is never cut. 额 itself is left
+    # out: it is a common character in its own right.
+    "zh": frozenset({"嗯", "嗯嗯", "呃", "呃呃", "唔"}),
+    "ru": frozenset({"э", "ээ", "эм", "эмм", "мм", "хм"}),
+    "nl": frozenset({"eh", "ehm", "uh", "uhm", "hm"}),
+    "pl": frozenset({"yyy", "yy", "eee", "ee", "em", "emm", "hmm"}),
+    "tr": frozenset({"ıı", "ııı", "ee", "eee", "hmm"}),
 }
 
 # Words in a default list that are also ordinary vocabulary: every run that removes one says so.
@@ -1173,11 +1185,33 @@ FILLER_DISCOURSE_MARKERS = {
     "en": ("like", "you know"),
     "pt": ("tipo",),
     "it": ("cioè",),
+    "ko": ("그", "저", "뭐", "이제", "약간", "막", "그니까"),
+    "zh": ("那个", "这个", "就是", "然后"),
+    "ru": ("ну", "типа", "короче", "как бы"),
+    "nl": ("nou", "dus", "zeg maar"),
+    "pl": ("no", "jakby", "wiesz", "znaczy"),
+    "tr": ("şey", "yani", "işte"),
 }
 
 FILLER_MAX_WORD = 1.2   # a longer "uhhh" is a held vowel someone meant
 FILLER_MIN_GAP = 0.05   # spans closer than this become one span
 FILLER_PAD = 0.02       # trimmed either side of the word
+FILLER_MAX_TOKENS = 4   # a listed word may span this many engine tokens ("えー" + "と", "you" + "know")
+FILLER_BOUNDARY_GAP = 0.1  # a pause this long between two tokens is a word boundary
+
+
+def _unspaced_script(text: str) -> bool:
+    """True when `text` has a character of a script written without spaces between words (Han,
+    kana, Thai, Lao, Myanmar, Khmer). Whisper splits those languages into tokens, not words, so a
+    token boundary there says nothing about a word boundary. Hangul is spaced and not listed."""
+    for ch in text:
+        o = ord(ch)
+        if (0x3040 <= o <= 0x30FF or 0x31F0 <= o <= 0x31FF or 0xFF66 <= o <= 0xFF9F   # kana
+                or 0x3400 <= o <= 0x4DBF or 0x4E00 <= o <= 0x9FFF or 0xF900 <= o <= 0xFAFF  # Han
+                or 0x20000 <= o <= 0x323AF  # Han extensions B-H
+                or 0x0E00 <= o <= 0x0EFF or 0x1000 <= o <= 0x109F or 0x1780 <= o <= 0x17FF):  # Thai, Lao, Myanmar, Khmer
+            return True
+    return False
 
 
 def normalise_filler_token(word: str) -> str:
@@ -1195,37 +1229,89 @@ def filler_spans(words, wordlist, *, pad: float = FILLER_PAD, min_gap: float = F
                  max_word: float = FILLER_MAX_WORD, stats: "Optional[Dict[str, int]]" = None) -> "List[Dict[str, Any]]":
     """Time spans to remove, from measured word timings. Pure: no subprocess, no I/O.
 
-    `words` is [{"word", "start", "end"}] as whisper emits. A word is removed only when its
-    normalised form is in `wordlist` AND it carries a real start < end pair AND its length is
-    <= max_word. Adjacent spans closer than min_gap merge. Returns [{"start", "end", "word"}]
-    sorted and non-overlapping.
+    `words` is [{"word", "start", "end"}] as whisper emits. A run of up to FILLER_MAX_TOKENS
+    consecutive entries is removed only when the run, joined with or without spaces and
+    normalised, is in `wordlist` AND every entry carries a real start < end pair AND the run is
+    <= max_word long. The longest run wins. Adjacent spans closer than min_gap merge. Returns
+    [{"start", "end", "word"}] sorted and non-overlapping.
+
+    Whisper splits Chinese, Japanese and Thai into tokens rather than words ("えーと" arrives as
+    "えー" + "と", "金额" as "金" + "额"), so a run in such a script also needs a word boundary on
+    each side: the start or end of the transcript, punctuation, a spaced-script neighbour, or a
+    pause of FILLER_BOUNDARY_GAP. Without one the run is part of a longer word and is kept.
 
     `stats`, when given, receives the listed words that were kept anyway, so the caller can say
     so: `matched_untimed` (no usable start < end: nothing to cut on) and `matched_too_long`
     (longer than max_word: a held vowel someone meant).
     """
+    import unicodedata as _ud
     listed = {normalise_filler_token(w) for w in (wordlist or set())}
     listed.discard("")
-    hits = []
-    untimed = too_long = 0
+    toks = []
     for entry in words or []:
         if not isinstance(entry, dict):
             continue
-        token = normalise_filler_token(entry.get("word") or entry.get("text") or "")
-        if not token or token not in listed:
-            continue
+        raw = str(entry.get("word") or entry.get("text") or "").strip()
         try:
             start, end = float(entry["start"]), float(entry["end"])
+            timed = end > start
         except (KeyError, TypeError, ValueError):
-            untimed += 1
-            continue     # no measured timing: nothing to cut
-        if not (end > start):
-            untimed += 1
-            continue
-        if (end - start) > max_word:
-            too_long += 1
-            continue
-        hits.append({"start": max(0.0, start - pad), "end": end + pad, "word": token})
+            start = end = 0.0
+            timed = False
+        toks.append({"norm": normalise_filler_token(raw), "start": start, "end": end, "timed": timed,
+                     "punct_before": bool(raw) and _ud.category(raw[0]).startswith("P"),
+                     "punct_after": bool(raw) and _ud.category(raw[-1]).startswith("P")})
+
+    def _bounded(i: int, j: int) -> bool:
+        """A word boundary before toks[i] and after toks[j - 1]."""
+        left = (i == 0 or toks[i]["punct_before"] or toks[i - 1]["punct_after"] or not toks[i - 1]["norm"]
+                or not _unspaced_script(toks[i - 1]["norm"])
+                or (toks[i - 1]["timed"] and toks[i]["start"] - toks[i - 1]["end"] >= FILLER_BOUNDARY_GAP - 1e-6))
+        right = (j == len(toks) or toks[j - 1]["punct_after"] or toks[j]["punct_before"] or not toks[j]["norm"]
+                 or not _unspaced_script(toks[j]["norm"])
+                 or (toks[j]["timed"] and toks[j]["start"] - toks[j - 1]["end"] >= FILLER_BOUNDARY_GAP - 1e-6))
+        return left and right
+
+    hits = []
+    untimed = too_long = 0
+    i = 0
+    while i < len(toks):
+        found = 0
+        rejected = None
+        for k in range(min(FILLER_MAX_TOKENS, len(toks) - i), 0, -1):
+            run = toks[i:i + k]
+            norms = [t["norm"] for t in run]
+            if not all(norms):
+                continue
+            unspaced = any(_unspaced_script(n) for n in norms)
+            joined = ("" if unspaced else " ").join(norms)
+            if joined not in listed or (unspaced and not _bounded(i, i + k)):
+                continue
+            # punctuation inside the run ("えー、" + "と") ends the word: the shorter run decides
+            if any(run[m]["punct_after"] or run[m + 1]["punct_before"] for m in range(k - 1)):
+                continue
+            # so does a pause inside an unspaced run: the tokens were two words
+            if unspaced and any(run[m]["timed"] and run[m + 1]["timed"]
+                                and run[m + 1]["start"] - run[m]["end"] >= FILLER_BOUNDARY_GAP - 1e-6
+                                for m in range(k - 1)):
+                continue
+            # a run listed out of time order has no span to cut on
+            if not all(t["timed"] for t in run) or run[-1]["end"] <= run[0]["start"]:
+                rejected = rejected or ("untimed", k)
+                continue
+            if run[-1]["end"] - run[0]["start"] > max_word:
+                rejected = rejected or ("too_long", k)
+                continue
+            hits.append({"start": max(0.0, run[0]["start"] - pad), "end": run[-1]["end"] + pad, "word": joined})
+            found = k
+            break
+        if not found and rejected:
+            # the longest listed run that could not be cut is the one reported. Its prefixes were
+            # tried here; moving on by one token lets a listed word later in it be tried too
+            untimed += rejected[0] == "untimed"
+            too_long += rejected[0] == "too_long"
+            found = 1
+        i += found or 1
     hits.sort(key=lambda h: (h["start"], h["end"]))
     merged: "List[Dict[str, Any]]" = []
     for h in hits:

package/scripts/_common/fonts.py

@@ -147,13 +147,14 @@ LANGUAGE_NAMES = {
     "ja": "Japanese", "zh": "Chinese", "ko": "Korean", "ar": "Arabic", "he": "Hebrew",
     "hi": "Devanagari (Hindi/Marathi/Nepali)", "th": "Thai", "ru": "Cyrillic (Russian and others)",
     "el": "Greek", "latin": "Latin", "bn": "Bengali", "ta": "Tamil", "lo": "Lao",
+    "zh-hant": "Traditional Chinese",
 }
 
 
 # fontconfig's own :lang= codes for each script we detect (zh uses zh-cn, the Simplified subset
 # every CJK font that claims zh carries; the rest are the plain two-letter codes).
 FC_LANG = {"ja": "ja", "zh": "zh-cn", "ko": "ko", "ar": "ar", "he": "he", "hi": "hi", "th": "th", "ru": "ru", "el": "el",
-           "bn": "bn", "ta": "ta", "lo": "lo"}
+           "bn": "bn", "ta": "ta", "lo": "lo", "zh-hant": "zh-tw"}
 
 
 # Families tried in order, best first. The names are matched case-insensitively against the start
@@ -162,6 +163,8 @@ FC_LANG = {"ja": "ja", "zh": "zh-cn", "ko": "ko", "ar": "ar", "he": "he", "hi":
 PREFERRED_FAMILIES = {
     "ja": ["Noto Sans CJK JP", "Noto Serif CJK JP", "Noto Sans JP", "Source Han Sans", "IPAPGothic", "IPAGothic", "IPA", "VL Gothic", "TakaoGothic", "WenQuanYi Zen Hei"],
     "zh": ["Noto Sans CJK SC", "Noto Serif CJK SC", "Noto Sans SC", "Source Han Sans", "WenQuanYi Zen Hei", "WenQuanYi Micro Hei", "Droid Sans Fallback"],
+    "zh-hant": ["Noto Sans CJK TC", "Noto Serif CJK TC", "Noto Sans CJK HK", "Noto Sans TC", "Noto Sans HK", "Source Han Sans TW",
+                "Source Han Sans HC", "AR PL UMing TW", "AR PL UKai TW", "PingFang TC", "WenQuanYi Zen Hei", "Droid Sans Fallback"],
     "ko": ["Noto Sans CJK KR", "Noto Serif CJK KR", "Noto Sans KR", "Source Han Sans K", "NanumGothic", "Nanum Gothic", "Malgun Gothic", "WenQuanYi Zen Hei"],
     "ar": ["Noto Sans Arabic", "Noto Naskh Arabic", "Amiri", "Scheherazade", "DejaVu Sans", "FreeSans", "FreeSerif"],
     "he": ["Noto Sans Hebrew", "Noto Serif Hebrew", "DejaVu Sans", "FreeSans", "FreeSerif"],
@@ -179,6 +182,7 @@ PREFERRED_FAMILIES = {
 WINDOWS_FONTS = {
     "ko": [("malgun.ttf", "Malgun Gothic"), ("gulim.ttc", "Gulim"), ("batang.ttc", "Batang")],
     "zh": [("msyh.ttc", "Microsoft YaHei"), ("simhei.ttf", "SimHei"), ("simsun.ttc", "SimSun")],
+    "zh-hant": [("msjh.ttc", "Microsoft JhengHei"), ("mingliu.ttc", "MingLiU")],
     "ja": [("meiryo.ttc", "Meiryo"), ("YuGothM.ttc", "Yu Gothic Medium"), ("YuGothR.ttc", "Yu Gothic"), ("msgothic.ttc", "MS Gothic")],
     "ar": [("tahoma.ttf", "Tahoma"), ("arial.ttf", "Arial")],
     "he": [("tahoma.ttf", "Tahoma"), ("arial.ttf", "Arial")],
@@ -277,6 +281,22 @@ def detect_script(text: str, lang: "Optional[str]" = None) -> str:
     return best
 
 
+# 2.19: Han-only text is Chinese, and Chinese is written in two standard forms whose glyphs differ
+# (骨, 直, 角 are drawn differently in Taipei and Beijing). A Simplified face draws a Taiwanese
+# caption in the wrong form, so a --lang naming Traditional Chinese resolves a Traditional face.
+# The script stays "zh" for wrapping; only the font lookup changes.
+HANT_TAGS = ("zh-tw", "zh-hk", "zh-mo", "zh-hant", "yue")
+
+
+def font_key(script: str, lang: "Optional[str]" = None) -> str:
+    """The font-table key for `script` under the caller's `lang`: "zh-hant" for Chinese text the
+    caller says is Traditional (zh-TW, zh-HK, zh-MO, zh-Hant-*, yue), else `script` itself."""
+    tag = (lang or "").strip().lower().replace("_", "-")
+    if script == "zh" and any(tag == t or tag.startswith(t + "-") for t in HANT_TAGS):
+        return "zh-hant"
+    return script
+
+
 _SCRIPT_FONT_CACHE: "Dict[Tuple[str, Optional[str]], Optional[Tuple[str, str]]]" = {}
 
 
@@ -359,7 +379,11 @@ def _script_font_uncached(script: str, family_hint: "Optional[str]" = None):
         mono = 1 if "mono" in joined else 0
         # regular weights before Bold/Italic/Oblique cuts, so a default caption is not bold by accident
         styled = 1 if any(k in stem for k in ("bold", "italic", "oblique", "light", "thin", "black")) else 0
-        scored.append((last_resort, _family_rank(families, preferred), mono, styled, path, families[0]))
+        rank = _family_rank(families, preferred)
+        # a .ttc lists every face it holds (Noto CJK: JP, KR, SC, TC): name the one that ranked
+        family = next((f for f in families if rank < len(preferred) and f.lower().startswith(preferred[rank].lower())),
+                      families[0])
+        scored.append((last_resort, rank, mono, styled, path, family))
     scored.sort(key=lambda row: (row[0], row[1], row[2], row[3], row[4]))
     best = scored[0]
     return best[4], best[5]
@@ -453,6 +477,11 @@ def fonts_dir_covers_script(fonts_dir: str, script: str) -> "Optional[bool]":
     return False
 
 
+def _is_last_resort(entry: "Tuple[str, str]") -> bool:
+    """Unifont, fontconfig's code-point-box face: it covers every script and renders none."""
+    return "unifont" in " ".join(str(x) for x in entry).lower()
+
+
 def script_font_for_text(text: str, *, lang: "Optional[str]" = None, font: "Optional[str]" = None,
                          font_explicit: bool = False, font_file: "Optional[str]" = None,
                          fonts_dir: "Optional[str]" = None
@@ -476,30 +505,41 @@ def script_font_for_text(text: str, *, lang: "Optional[str]" = None, font: "Opti
         return script, None, None
     if font_file:
         return script, None, None
+    key = font_key(script, lang)
     if font_explicit and font:
-        if not font_covers_script(font, script):
-            warn(f"font: '{font}' does not cover {LANGUAGE_NAMES[script]} text on this machine; keeping it as asked "
+        if not font_covers_script(font, key):
+            warn(f"font: '{font}' does not cover {LANGUAGE_NAMES[key]} text on this machine; keeping it as asked "
                  f"(drop --font, or {FONT_FLAG_HINT}, to pick one by script automatically)", "font_lacks_script",
                  font=font, script=script)
         return script, None, None
     if fonts_dir:
-        covered = fonts_dir_covers_script(fonts_dir, script)
+        covered = fonts_dir_covers_script(fonts_dir, key)
         if covered:
             return script, None, None
         if covered is None:
-            warn(f"font: could not verify that {fonts_dir} covers {LANGUAGE_NAMES[script]} text "
+            warn(f"font: could not verify that {fonts_dir} covers {LANGUAGE_NAMES[key]} text "
                  "(no fc-scan on this machine); using it as given", "font_coverage_unverified", fonts_dir=fonts_dir, script=script)
             return script, None, None
-        record_fallback(f"font: no face in {fonts_dir} covers {LANGUAGE_NAMES[script]} text; "
+        record_fallback(f"font: no face in {fonts_dir} covers {LANGUAGE_NAMES[key]} text; "
                         "picking one by script instead (the directory is still searched first)", "fonts_dir_lacks_script",
                         fonts_dir=fonts_dir, script=script)
-    entry = _script_font_entry(script)
+    entry = _script_font_entry(key)
+    if key != script and (not entry or (entry is not FC_UNKNOWN and _is_last_resort(entry))):
+        # no Traditional face (Unifont's code-point boxes are none): the Simplified one still
+        # has the characters, in the other form
+        simplified = _script_font_entry(script)
+        if simplified and simplified is not FC_UNKNOWN and (not entry or not _is_last_resort(simplified)):
+            entry = simplified
+            record_fallback(f"font: no {LANGUAGE_NAMES[key]} face is installed; drawing with {entry[0]}, a "
+                            "Simplified Chinese face whose glyph forms differ in places "
+                            "(install fonts-noto-cjk or a TC font)", "font_variant_missing", lang=lang, file=entry[0])
+            key = script
     if entry is FC_UNKNOWN:
-        warn(f"font: could not verify that this machine can render {LANGUAGE_NAMES[script]} text "
+        warn(f"font: could not verify that this machine can render {LANGUAGE_NAMES[key]} text "
              "(no working fontconfig); rendering with the font as given -- "
              "doctor --json .fonts.scripts reports what is known", "font_coverage_unverified", script=script)
         return script, None, None
     if not entry:
-        die(f"no installed font covers {LANGUAGE_NAMES[script]} text on this machine — {FONT_INSTALL_HINT}", kind="input")
-    info(f"font: {entry[0]} (covers {script})")
+        die(f"no installed font covers {LANGUAGE_NAMES[key]} text on this machine — {FONT_INSTALL_HINT}", kind="input")
+    info(f"font: {entry[0]} (covers {key})")
     return script, entry[0], entry[1]

package/scripts/_common/probe.py

@@ -300,6 +300,9 @@ def probe(path: str, role: str = "input") -> Dict[str, Any]:
             "bitrate": _to_int(audio.get("bit_rate")),
             "duration": _to_float(audio.get("duration")),
             "start_time": _to_float(audio.get("start_time")),
+            # Matroska/WebM give no stream duration, only a DURATION tag; the container's own length
+            # is the longest stream's, which is not the sound's when the picture runs longer (2.20)
+            "tagged_duration": _tag_seconds((audio.get("tags") or {}).get("DURATION")),
         }
         # every audio stream in file order: index n here is `-map 0:a:n` (audio.py --audio-stream n)
         out["audio_streams"] = [{
@@ -497,6 +500,19 @@ def analyze_levels(path: str, seconds: float = 20.0) -> Dict[str, Any]:
     }
 
 
+def _tag_seconds(value: Any) -> "Optional[float]":
+    """A Matroska DURATION tag ("00:00:04.008000000") in seconds, or None."""
+    try:
+        if "-" in str(value):  # "-00:00:01": int("-00") is 0, so the sign would be lost
+            return None
+        h, m, sec = str(value).split(":")
+        seconds = int(h) * 3600 + int(m) * 60 + float(sec)
+    except (TypeError, ValueError):
+        return None
+    # float() reads "nan" and "inf": a length that is not a finite, non-negative number is none
+    return seconds if math.isfinite(seconds) and seconds >= 0 else None
+
+
 def _to_float(v: Any) -> Optional[float]:
     try:
         return float(v) if v is not None else None

package/scripts/_contract.py

@@ -456,6 +456,7 @@ DIAGNOSTIC_CODES = {
     "font_path_copied": ("fallbacks", "a --font-file under a non-ASCII path was copied to an ASCII one, because drawtext cannot open it on Windows; {font, file}"),
     "font_path_not_ascii": ("warnings", "a --font-file under a non-ASCII path could not be given an ASCII form on Windows; drawtext may not open it; {font}"),
     "fonts_dir_lacks_script": ("fallbacks", "no face in --fonts-dir covers the text's script, so one was picked by script; {fonts_dir, script}"),
+    "font_variant_missing": ("fallbacks", "--lang named Traditional Chinese but no Traditional face is installed, so a Simplified one draws it (some glyph forms differ); {lang, file}"),
     "emoji_monochrome": ("warnings", "emoji drawn by the text font (monochrome at best): no colour path here"),
     "emoji_stripped": ("warnings", "overlay.py --emoji none: emoji removed from the drawn text; {mode}"),
     "emoji_assets_missing": ("warnings", "--emoji-assets has no PNG for these clusters; the text font draws them; {missing}"),

package/scripts/export.py

@@ -333,6 +333,20 @@ def main() -> int:
     elif platform and has_audio and args.normalize:
         spec = PLATFORMS[platform]
         notes.append(f"[dry-run] --normalize: loudness.py -I {spec['lufs']:g} --tp {spec['tp']:g} would run on the written file if it misses {platform}'s spec")
+    if p["max"] and not args.allow_long and not STATE.dry_run:
+        # the preset's length promise, measured the way check.py measures it (the container's
+        # duration, no tolerance): before 2.20 nothing re-read the length, and a --normalize pass
+        # that left the sound 0.1 s long shipped a 90.10 s Reels file as verified
+        written = probe(output, role="output").get("duration")
+        if written is not None:
+            step = {"step": "duration", "property": "duration", "ok": written <= p["max"],
+                    "expected": {"max": p["max"]}, "measured": round(written, 3),
+                    "delta": round(written - p["max"], 3), "tolerance": 0.0, "provenance": "specification"}
+        else:
+            # the preset promised a length; one that could not be read is not one that held
+            step = {"step": "duration", "property": "duration", "ok": False, "expected": {"max": p["max"]},
+                    "reason": "not_measured: the written file reports no duration"}
+        extra.setdefault("verification", []).append(step)
     if notes:
         extra["notes"] = notes
     # the delivery keeps the source's picture and, except as a GIF, its sound

package/scripts/graphics.py

@@ -294,7 +294,7 @@ def main(force_route: Optional[str] = None) -> int:
         if explicit:
             return font_family_of_file(explicit) or args.font or brand.get("font")
         if script_file:
-            return font_family_of_file(script_file) or font_family_for_script(_script)
+            return _family or font_family_of_file(script_file) or font_family_for_script(_script)
         return args.font or brand.get("font", "DejaVu Sans")
 
     def ass_fonts_dir() -> "Optional[str]":

package/scripts/join.py

@@ -81,6 +81,20 @@ def unpending_length(durs: List[float], d: float) -> Optional[float]:
     return round(sum(durs) - d * (len(durs) - 1), 3)
 
 
+def overlap_report(durs: List[float], expected: Optional[float]) -> Dict[str, Any]:
+    """The clips' own total next to the joined length (2.20). The joined length is derived from
+    the transition the join itself applied, so a check against it alone cannot show that a fade
+    took time out of the material; the sum of the inputs is the yardstick the user holds."""
+    if expected is None or STATE_PENDING:
+        return {}
+    total = round(sum(durs), 3)
+    out: Dict[str, Any] = {"inputs_duration": total, "transition_shortening": round(total - expected, 3)}
+    if out["transition_shortening"] > 0.0005:
+        STATE_NOTES.append(f"the transitions overlap the clips: {fmt_secs(total)} of clips play as {fmt_secs(expected)} "
+                           f"({out['transition_shortening']:.3f} s shorter)")
+    return out
+
+
 def clip_length(meta: Dict[str, Any], fps: float) -> float:
     """The one length a clip holds in a join, for its picture and its sound alike: the
     video stream's, or the audio stream's when the sound runs more than a frame past the picture
@@ -175,7 +189,8 @@ def join_audio(args: argparse.Namespace, metas: List[dict]) -> int:
             die(f"{output} is {a.get('sample_rate')} Hz {a.get('channels')} ch, expected {rate} Hz {channels} ch")
     info(f"wrote {output} ({fmt_secs(r['duration'])}, {expected_text(expected)}, audio {a.get('codec')} {channels}ch {rate}Hz, {n} clips, "
          + ("crossfade" if d else "butt join") + ")")
-    emit(output, mode="audio", **reported(), clips=n, transition=args.transition if d else "none", expected_duration=expected,
+    overlap = overlap_report(durs, expected)
+    emit(output, mode="audio", **overlap, **reported(), clips=n, transition=args.transition if d else "none", expected_duration=expected,
          sample_rate=rate, channels=channels, video=False)
     return 0
 
@@ -568,7 +583,7 @@ def main() -> int:
         verification.append({"step": "duration", "property": "video_duration", "ok": abs(measured - expected) <= tol,
                              "measured": round(measured, 3), "expected": expected,
                              "delta": round(measured - expected, 3), "tolerance": round(tol, 3),
-                             "provenance": "input_premeasurement"})
+                             "provenance": "input_premeasurement", "inputs_total": round(sum(lens), 3)})
     # a clip with no audio stream is joined over generated silence: the join is right to do that, but
     # the report must say which clips' sound is not theirs (the paper's join finding: absence was
     # filled and nothing in the result showed it)
@@ -577,7 +592,8 @@ def main() -> int:
         STATE_NOTES.append(f"{len(substituted)} clip(s) had no audio stream; their span of the join is generated "
                            "silence: " + ", ".join(os.path.basename(p) for p in substituted))
     info(f"wrote {output} ({fmt_secs(measured)}, {expected_text(expected)}, {w}x{h} @ {fps:g}fps, {n} clips, {args.transition})")
-    emit(output, mode="video", **reported(), clips=n, transition=args.transition, expected_duration=expected,
+    overlap = overlap_report(lens, expected)
+    emit(output, mode="video", **overlap, **reported(), clips=n, transition=args.transition, expected_duration=expected,
          verification=verification, expect_streams={"video": True, "audio": True},
          audio_substituted=substituted,
          dropped_non_av_streams=any(m.get("subtitle_streams") or m.get("data_streams") for m in metas))

package/scripts/loudness.py

@@ -20,6 +20,8 @@ import re
 import sys
 
 from _platforms import TP_TOLERANCE_DB
+
+AUDIO_LENGTH_TOLERANCE = 0.03  # seconds: one AAC frame at 48 kHz is 0.021 s
 from _common import STATE, add_common, apply_common, emit, AUDIO_CODECS, audio_codec_for, default_output, die, ffmpeg_base, info, probe, require_tool, run, run_analysis, run_keeping_subtitles, dry_run_input_pending
 
 
@@ -93,6 +95,12 @@ def main() -> int:
     bitrate = args.audio_bitrate or "192k"
 
     dropped_streams = False
+    # loudnorm emits its last block whole, and through the AAC encoder that came out as 0.1 s more
+    # sound than the input had (a 90.000 s Reels export left at 90.100 s, which check.py fails):
+    # the sound is trimmed back to the input's own length. `duration=` counts from the first sample,
+    # so sound that starts late keeps its end (`end=` is a timestamp, and cut it). atrim follows
+    # loudnorm directly: an aresample between them fails channel-layout negotiation on FFmpeg 5.1
+    in_audio = audio_length(meta)
 
     def encode(tp: float, bitrate: str) -> None:
         nonlocal dropped_streams
@@ -101,6 +109,8 @@ def main() -> int:
             f":measured_I={stats['input_i']}:measured_TP={stats['input_tp']}:measured_LRA={stats['input_lra']}"
             f":measured_thresh={stats['input_thresh']}:offset={stats['target_offset']}:linear=true:print_format=summary"
         )
+        if in_audio:
+            af += f",atrim=duration={float(in_audio):.6f}"
         cmd = ffmpeg_base() + ["-i", args.input, "-af", af, "-ar", str(sr)]
         if ext in AUDIO_CODECS or not meta.get("video"):
             cmd += ["-vn"] + audio_codec_for(output, bitrate)
@@ -158,19 +168,40 @@ def main() -> int:
             f"the encoder overshoots more than the loudnorm ceiling can absorb at this bitrate",
             kind="verification", output=output, result=result,
             hint="raise --audio-bitrate (e.g. 256k) or deliver a lossless format (wav/flac) and let the platform encode")
+    verification = [{"step": "loudness",
+                     "ok": bool(after.get("silent")) or (abs(float(after["input_i"]) - args.lufs) <= 1.0 and float(after["input_tp"]) <= args.tp + TP_TOLERANCE_DB),
+                     "lufs": float(after["input_i"]), "tp": float(after["input_tp"]), "target_lufs": args.lufs, "target_tp": args.tp,
+                     "property": "loudness", "expected": {"lufs": args.lufs, "tp_max": args.tp},
+                     "measured": {"lufs": float(after["input_i"]), "tp": float(after["input_tp"])},
+                     "delta": {"lufs": round(float(after["input_i"]) - args.lufs, 2), "tp": round(float(after["input_tp"]) - args.tp, 2)},
+                     "tolerance": {"lufs": 1.0, "tp": TP_TOLERANCE_DB}, "provenance": "user_specified"}]
+    written = probe(output, role="output")
+    out_audio = audio_length(written)
+    if in_audio and out_audio:
+        # a levels pass changes no timing: the sound is as long as the input's, to one AAC frame
+        tol = max(1024.0 / float(sr), AUDIO_LENGTH_TOLERANCE)
+        verification.append({"step": "duration", "property": "audio_duration", "ok": abs(out_audio - in_audio) <= tol,
+                             "expected": round(float(in_audio), 3), "measured": round(float(out_audio), 3),
+                             "delta": round(float(out_audio) - float(in_audio), 3), "tolerance": round(tol, 3),
+                             "provenance": "input_premeasurement"})
+    else:
+        # a length that could not be read is not a length that matched
+        verification.append({"step": "duration", "property": "audio_duration", "ok": False,
+                             "reason": "not_measured: the " + ("input" if not in_audio else "output") + " reports no duration"})
     emit(output, result=result, dropped_non_av_streams=dropped_streams,
          measured={k: stats[k] for k in ("input_i", "input_tp", "input_lra", "input_thresh", "target_offset", "silent")},
-         targets={"lufs": args.lufs, "tp": args.tp, "lra": args.lra},
-         verification=[{"step": "loudness",
-                        "ok": bool(after.get("silent")) or (abs(float(after["input_i"]) - args.lufs) <= 1.0 and float(after["input_tp"]) <= args.tp + TP_TOLERANCE_DB),
-                        "lufs": float(after["input_i"]), "tp": float(after["input_tp"]), "target_lufs": args.lufs, "target_tp": args.tp,
-                        "property": "loudness", "expected": {"lufs": args.lufs, "tp_max": args.tp},
-                        "measured": {"lufs": float(after["input_i"]), "tp": float(after["input_tp"])},
-                        "delta": {"lufs": round(float(after["input_i"]) - args.lufs, 2), "tp": round(float(after["input_tp"]) - args.tp, 2)},
-                        "tolerance": {"lufs": 1.0, "tp": TP_TOLERANCE_DB}, "provenance": "user_specified"}])
+         targets={"lufs": args.lufs, "tp": args.tp, "lra": args.lra}, verification=verification)
     return 0
 
 
+def audio_length(meta: dict) -> "Optional[float]":
+    """The sound's own length: the stream's duration, else Matroska's DURATION tag. Never the
+    container's, which is the picture's when the picture runs longer (and would fail a correct
+    output against an expected length the sound never had)."""
+    audio = meta.get("audio") or {}
+    return audio.get("duration") or audio.get("tagged_duration")
+
+
 def _kbps(value: str) -> int:
     v = value.lower().rstrip("k")
     try:

package/scripts/silence.py

@@ -15,7 +15,7 @@ import argparse
 import json
 import os
 import sys
-from typing import List, Tuple
+from typing import Any, Dict, List, Tuple
 
 # `detect` moved into _common/probe.py in 1.16.0 so metadata.py --auto-chapters can measure the
 # same silences without importing this tool; the body is unchanged and the name still lives here.
@@ -44,6 +44,7 @@ def merge_spans(spans: List[Tuple[float, float]]) -> List[Tuple[float, float]]:
     return out
 
 
+DIGITAL_SILENCE_DB = -90.0  # 2.20: at or below this a span is digital silence (16-bit dither sits near -96)
 BREATH_FLOOR = 0.12  # shortest gap silencedetect is asked for under --speech-aware
 
 
@@ -152,7 +153,10 @@ def resolve_filler(args, meta):
         # (or one that says "auto", which is no language either) keeps the English list it always had
         # the ISO 639-2 spellings of the languages that have a built-in list (the mux tag uses them)
         iso3 = {"eng": "en", "spa": "es", "deu": "de", "ger": "de", "fra": "fr", "fre": "fr",
-                "ita": "it", "jpn": "ja", "por": "pt"}
+                "ita": "it", "jpn": "ja", "por": "pt", "kor": "ko", "zho": "zh", "chi": "zh",
+                "rus": "ru", "nld": "nl", "dut": "nl", "pol": "pl", "tur": "tr"}
+        names = {"spanish": "es", "german": "de", "portuguese": "pt", "chinese": "zh", "mandarin": "zh",
+                 "dutch": "nl", "polish": "pl", "turkish": "tr"}
 
         def _code(value) -> str:
             value = str(value or "").strip().lower().replace("_", "-")
@@ -160,10 +164,13 @@ def resolve_filler(args, meta):
                 return ""
             # a regional tag names its primary language (ja-JP is ja); a three-letter code that is not
             # in the table stays as it is (est is Estonian, not the Spanish "es"); a word such as
-            # "english" is cut to its two-letter code
+            # "english" is cut to its two-letter code; a name whose first two letters are not its
+            # code ("spanish" is es, "chinese" zh) is looked up, as whisper's own language table spells it
             primary = value.split("-")[0]
             if primary in iso3:
                 return iso3[primary]
+            if primary in names:
+                return names[primary]
             return primary[:2] if len(primary) > 3 else primary
         spoken = _code((raw or {}).get("language")) if isinstance(raw, dict) else ""
         spoken = spoken or _code(transcription.get("language") or transcription.get("detected_language"))
@@ -249,6 +256,33 @@ def _words_from_transcript(data):
     return out, had_segments, untimed
 
 
+def silence_kinds(path: str, silences: "List[Tuple[float, float]]", duration: float,
+                  threshold: float) -> "Dict[str, Any]":
+    """Which detected silences are digital silence and which are quiet sound under the threshold
+    (2.20). Both are removed alike, but they are not the same finding: a room tone, a breath or a
+    whisper under --threshold is sound, and a report that called all of it "silence" hid that the
+    cut took audible material. One more silencedetect pass at DIGITAL_SILENCE_DB finds the digital
+    spans; a detected silence that is at least 99% digital counts as digital."""
+    if not silences or STATE.dry_run:
+        return {}
+    digital = [(s, duration if e == float("inf") else e) for s, e in detect(path, DIGITAL_SILENCE_DB, 0.02)]
+    labels, tally = [], {"digital": [0, 0.0], "below_threshold": [0, 0.0]}
+    for s, e in silences:
+        e = duration if e == float("inf") else e
+        span = max(e - s, 1e-9)
+        covered = sum(max(0.0, min(e, de) - max(s, ds)) for ds, de in digital)
+        kind = "digital" if covered / span >= 0.99 else "below_threshold"
+        labels.append(kind)
+        tally[kind][0] += 1
+        tally[kind][1] += e - s
+    return {"silence_kinds": labels,
+            "silence_breakdown": {"digital": {"count": tally["digital"][0], "seconds": round(tally["digital"][1], 3),
+                                              "level_db": DIGITAL_SILENCE_DB},
+                                  "below_threshold": {"count": tally["below_threshold"][0],
+                                                      "seconds": round(tally["below_threshold"][1], 3),
+                                                      "level_db": threshold}}}
+
+
 def main() -> int:
     ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
     ap.add_argument("input")
@@ -338,6 +372,7 @@ def main() -> int:
     if args.filler:
         silence_keeps = keep_ranges(merge_spans(list(silences)), duration, args.margin, args.min_keep)
         silence_only = max(0.0, duration - sum(e - s for s, e in silence_keeps))
+    kinds = silence_kinds(args.input, silences, duration, args.threshold)
     summary = {
         "silences": [[round(s, 3), None if e == float("inf") else round(e, 3)] for s, e in silences],
         "keep": [[round(s, 3), round(e, 3)] for s, e in keeps],
@@ -345,6 +380,8 @@ def main() -> int:
         "kept_duration": round(kept, 3),
         "removed_seconds": round(silence_only, 3),
     }
+    if kinds:
+        summary.update(kinds)
     if args.speech_aware:
         summary["speech_aware"] = {
             "min_silence": args.min_silence, "floor": min(BREATH_FLOOR, args.min_silence),