docs: name the opt-in column +opt, and document bmi_schedule where users look

## 表格

* `mcpp +schedule` → **`mcpp +opt` / `mcpp +优化`**。"schedule" 是**机制的名字**,
  第一次看这张表的人无从判断一个「构建调度器」是更快、更慢还是只是不一样。
  这一列要说的是「这是那个 opt-in 的提速开关」,它到底开了什么,下一行的图例
  有的是地方讲清楚。
* `mcpp (released)` → **`mcpp (old)` / `mcpp (旧版)`** —— 被测的这一版将来也会
  发布,"released" 分不出新旧。
* 每个数据格用 code span 包起来:`86.69s · 1.1x`。视口一窄,表格最先做的事就是
  把这种格子折成两行,而**数字和它的倍率被拆开会读成两个数**。

⚠️ 图例的分支原来是按字面量 `name == "mcpp +schedule"` 匹配的,改名之后这条分支
不再命中,opt-in 那一列**掉进了 else,被描述成「上一个已发布版」** —— 一句完全
错误的话,语气十足地印在那个「重点恰恰是它和第一列是同一个二进制」的列上。
现在按 `"+" in name` 判断,并且图例文本直接用生成出来的列名。

## 文档

`bmi_schedule` 和 `jobs` 都是这条分支新加的**用户可见 manifest 键**,而
`docs/05-mcpp-toml.md`(用户真正会去查 `[build]` 键的地方)**两个都没有**。
中英两份都补上了:

* 明确写出 **`auto` 是默认值,而它目前等于「关」**
* 只认 `auto|on|off`,`"ON"`/`"true"` 会被拒 —— 并说清它们不是无害的笔误:
  这个值进构建指纹,被拒的拼写以前会选到另一个构建目录(一次全量重建)
* 为什么默认关(调度改错是**无声**的),以及**它在哪里没用**
  (mcpp 本来就跳过级联的那两行)
* 实测数字:`cold` 86.7s → 35.7s、`edit-body` 80.9s → 29.8s
* gcc/clang/msvc 三种做法各自的理由

守卫相应更新:列名是短名、数据里是完整标签,映射由 `report.py` 发在表格上方的
`<!-- columns: ... -->` 注释里(渲染时不可见),守卫从那里读;**短名没有映射
直接报错**,不会静默少检查一列。

Author: speak-agent

README.md

@@ -311,16 +311,16 @@ them `import std;` — with four engines handed the **same compiler binary**.
 Each cell is the median of **3 samples** and how many times faster it is than
 cmake. Every column comes from **one run**.
 
-<!-- columns: mcpp=mcpp@2026.8.13.1; mcpp +schedule=mcpp@2026.8.13.1+schedule=on; mcpp (released)=mcpp@2026.8.11.3; cmake=cmake; xmake=xmake -->
-| scenario | what changed | `mcpp` | `mcpp +schedule` | `mcpp (released)` | `cmake` | `xmake` |
+<!-- columns: mcpp=mcpp@2026.8.13.1; mcpp +opt=mcpp@2026.8.13.1+schedule=on; mcpp (old)=mcpp@2026.8.11.3; cmake=cmake; xmake=xmake -->
+| scenario | what changed | `mcpp` | `mcpp +opt` | `mcpp (old)` | `cmake` | `xmake` |
 |---|---|---|---|---|---|---|
-| `cold` | nothing built yet | 86.69s · 1.1x | **35.73s · 2.6x** | 86.75s · 1.1x | 91.74s · 1.0x | 90.54s · 1.0x |
-| `noop` | nothing at all | **0.16s · 2.0x** | 0.18s · 1.8x | 0.24s · 1.3x | 0.32s · 1.0x | 0.38s · 0.8x |
-| `touch-hub` | mtime only, content unchanged | **0.42s · 197.7x** | 0.42s · 197.2x | 81.72s · 1.0x | 83.21s · 1.0x | 82.48s · 1.0x |
-| `edit-body` | a real edit inside a function body | 80.87s · 1.1x | **29.83s · 2.9x** | 81.19s · 1.1x | 85.30s · 1.0x | 84.33s · 1.0x |
-| `edit-comment` | a comment added to a hub interface | **0.40s · 207.0x** | **0.40s · 207.0x** | 79.11s · 1.1x | 83.21s · 1.0x | 82.15s · 1.0x |
+| `cold` | nothing built yet | `86.69s · 1.1x` | **`35.73s · 2.6x`** | `86.75s · 1.1x` | `91.74s · 1.0x` | `90.54s · 1.0x` |
+| `noop` | nothing at all | **`0.16s · 2.0x`** | `0.18s · 1.8x` | `0.24s · 1.3x` | `0.32s · 1.0x` | `0.38s · 0.8x` |
+| `touch-hub` | mtime only, content unchanged | **`0.42s · 197.7x`** | `0.42s · 197.2x` | `81.72s · 1.0x` | `83.21s · 1.0x` | `82.48s · 1.0x` |
+| `edit-body` | a real edit inside a function body | `80.87s · 1.1x` | **`29.83s · 2.9x`** | `81.19s · 1.1x` | `85.30s · 1.0x` | `84.33s · 1.0x` |
+| `edit-comment` | a comment added to a hub interface | **`0.40s · 207.0x`** | **`0.40s · 207.0x`** | `79.11s · 1.1x` | `83.21s · 1.0x` | `82.15s · 1.0x` |
 
-<sub>`mcpp` = mcpp@2026.8.13.1, the build under test · `mcpp +schedule` = the same binary with `[build] bmi_schedule = "on"` · `mcpp (released)` = mcpp@2026.8.11.3, the published release.<br>
+<sub>`mcpp` = mcpp@2026.8.13.1, the build under test · `mcpp +opt` = the SAME binary as `mcpp`, with the opt-in key `[build] bmi_schedule = "on"` (off by default) · `mcpp (old)` = mcpp@2026.8.11.3, the previously published release.<br>
 Linux x86_64 · i9-13900K · gcc 16.1.0 · n=3 · pinned workload `a749e9f` ·
 cmake 4.4.2 / xmake 3.1.0 · `-` would mean not measured, and there is none here ·
 min/max sit within 4% of every median above 1s ·
@@ -329,12 +329,12 @@ data: [`standard-20260814-linux-x86_64`](bench/results/standard-20260814-linux-x
 * **`touch-hub` and `edit-comment` are where the day goes — and that is new.**
   cmake and xmake decide by timestamp and rebuild everything downstream. mcpp
   compares the BMI the compiler just produced against the previous one and, when
-  the interface did not change, skips the cascade. The **released column shows
+  the interface did not change, skips the cascade. The **`mcpp (old)` column shows
   this was not working before**: 81.72s, level with cmake. It is 0.42s here.
   Default behaviour, no key to set.
 * **`edit-body` is the control.** There the interface really did change, so the
   cascade is owed — mcpp is 1.1x, not 200x. An engine that were faster on this
-  row would be skipping work it owed. `+schedule` does not skip it either; it
+  row would be skipping work it owed. `+opt` does not skip it either; it
   does the same owed work 2.9x faster.
 * **`bmi_schedule` is opt-in and OFF by default** (`auto` resolves to off). It
   moves code generation off the critical path, which is why it only helps where

README.zh-CN.md

@@ -306,27 +306,27 @@ import mcpplibs.cmdline;
 `import std;` —— 并且**给它们同一个编译器二进制**。每格是 **3 轮的中位数**,以及
 相对 cmake 的倍率。所有列出自**同一次跑**。
 
-<!-- columns: mcpp=mcpp@2026.8.13.1; mcpp +schedule=mcpp@2026.8.13.1+schedule=on; mcpp (released)=mcpp@2026.8.11.3; cmake=cmake; xmake=xmake -->
-| 场景 | 改了什么 | `mcpp` | `mcpp +schedule` | `mcpp (released)` | `cmake` | `xmake` |
+<!-- columns: mcpp=mcpp@2026.8.13.1; mcpp +优化=mcpp@2026.8.13.1+schedule=on; mcpp (旧版)=mcpp@2026.8.11.3; cmake=cmake; xmake=xmake -->
+| 场景 | 改了什么 | `mcpp` | `mcpp +优化` | `mcpp (旧版)` | `cmake` | `xmake` |
 |---|---|---|---|---|---|---|
-| `cold` | 还没编过 | 86.69s · 1.1x | **35.73s · 2.6x** | 86.75s · 1.1x | 91.74s · 1.0x | 90.54s · 1.0x |
-| `noop` | 什么都没改 | **0.16s · 2.0x** | 0.18s · 1.8x | 0.24s · 1.3x | 0.32s · 1.0x | 0.38s · 0.8x |
-| `touch-hub` | 只碰 mtime,内容不变 | **0.42s · 197.7x** | 0.42s · 197.2x | 81.72s · 1.0x | 83.21s · 1.0x | 82.48s · 1.0x |
-| `edit-body` | 真的改了一个函数体 | 80.87s · 1.1x | **29.83s · 2.9x** | 81.19s · 1.1x | 85.30s · 1.0x | 84.33s · 1.0x |
-| `edit-comment` | 在 hub 接口里加一行注释 | **0.40s · 207.0x** | **0.40s · 207.0x** | 79.11s · 1.1x | 83.21s · 1.0x | 82.15s · 1.0x |
+| `cold` | 还没编过 | `86.69s · 1.1x` | **`35.73s · 2.6x`** | `86.75s · 1.1x` | `91.74s · 1.0x` | `90.54s · 1.0x` |
+| `noop` | 什么都没改 | **`0.16s · 2.0x`** | `0.18s · 1.8x` | `0.24s · 1.3x` | `0.32s · 1.0x` | `0.38s · 0.8x` |
+| `touch-hub` | 只碰 mtime,内容不变 | **`0.42s · 197.7x`** | `0.42s · 197.2x` | `81.72s · 1.0x` | `83.21s · 1.0x` | `82.48s · 1.0x` |
+| `edit-body` | 真的改了一个函数体 | `80.87s · 1.1x` | **`29.83s · 2.9x`** | `81.19s · 1.1x` | `85.30s · 1.0x` | `84.33s · 1.0x` |
+| `edit-comment` | 在 hub 接口里加一行注释 | **`0.40s · 207.0x`** | **`0.40s · 207.0x`** | `79.11s · 1.1x` | `83.21s · 1.0x` | `82.15s · 1.0x` |
 
-<sub>`mcpp` = mcpp@2026.8.13.1,被测的这一版 · `mcpp +schedule` = 同一个二进制,开了 `[build] bmi_schedule = "on"` · `mcpp (released)` = mcpp@2026.8.11.3,已发布版。<br>
+<sub>`mcpp` = mcpp@2026.8.13.1,被测的这一版 · `mcpp +优化` = **和 `mcpp` 同一个二进制**,开了 opt-in 的 `[build] bmi_schedule = "on"`(默认关闭) · `mcpp (旧版)` = mcpp@2026.8.11.3,上一个已发布版。<br>
 Linux x86_64 · i9-13900K · gcc 16.1.0 · n=3 · 钉住的工作负载 `a749e9f` ·
 cmake 4.4.2 / xmake 3.1.0 · `-` 表示未测,本表没有 ·
 所有大于 1s 的中位数 min/max 都在 ±4% 以内 ·
 数据:[`standard-20260814-linux-x86_64`](bench/results/standard-20260814-linux-x86_64/)。</sub>
 
 * **`touch-hub` 与 `edit-comment` 是一天时间的去处 —— 而且这是新的。**
   cmake 和 xmake 按时间戳判断,把下游全部重编;mcpp 拿编译器刚产出的 BMI 与上一份
-  比较,接口没变就**不级联**。**已发布那一列说明它以前并没有生效**:81.72s,
+  比较,接口没变就**不级联**。**`mcpp (old)` 那一列说明它以前并没有生效**:81.72s,
   和 cmake 一个量级;这里是 0.42s。这是**默认行为**,不需要设任何键。
 * **`edit-body` 是对照组。** 那里接口是真的变了,级联是**欠着的** —— mcpp 是 1.1x
-  而不是 200x。在这一行更快的引擎,是漏掉了它该做的活。`+schedule` 也不跳过它,
+  而不是 200x。在这一行更快的引擎,是漏掉了它该做的活。`+优化` 也不跳过它,
   只是把同样欠着的活做快了 2.9 倍。
 * **`bmi_schedule` 是 opt-in,默认关闭**(`auto` 解析为 off)。它把代码生成移出关键
   路径,所以只在级联**确实欠着**时有用:`cold` 86.69s → 35.73s、`edit-body`

bench/tools/report.py

@@ -218,13 +218,23 @@ def key(e):
 # one in the data is exactly the drift this tool exists to remove, so the header
 # carries a machine-readable `<!-- columns: ... -->` line and the guard reads the
 # mapping from there instead of keeping a second copy.
-def short_name(engine, newest):
+def short_name(engine, newest, lang="en"):
+    """The column header.
+
+    ⚠️ NOT `mcpp +schedule`. "schedule" is the name of the MECHANISM, and a
+    reader meeting this table for the first time has no idea whether a build
+    scheduler makes things faster, slower or merely different. The column is
+    there to say "this is the opt-in speed-up"; what it actually turns on is one
+    line further down, in the legend, where a name has room to be precise.
+    """
     if not engine.startswith("mcpp@"):
         return engine
     base, _, opt = engine.partition("+")
     if opt:
-        return "mcpp +schedule"
-    return "mcpp" if base == newest else "mcpp (released)"
+        return "mcpp +优化" if lang == "zh" else "mcpp +opt"
+    if base == newest:
+        return "mcpp"
+    return "mcpp (旧版)" if lang == "zh" else "mcpp (old)"
 
 
 def columns_legend(short, engines, lang):
@@ -238,18 +248,24 @@ def columns_legend(short, engines, lang):
         name = short[e]
         if not e.startswith("mcpp@"):
             continue
+        # Keyed on the SHORT NAME this run produced, never on a literal spelling
+        # of it. Renaming the column used to leave this branch unmatched, and the
+        # opt-in arm then fell through to the `else` and was described as "the
+        # previously published release" — the wrong sentence, printed with total
+        # confidence, about the one column whose whole point is that it is the
+        # SAME binary as the first.
         if name == "mcpp":
             parts.append(f"`mcpp` = {e}, the build under test"
                          if lang == "en" else f"`mcpp` = {e},被测的这一版")
-        elif name == "mcpp +schedule":
-            parts.append("`mcpp +schedule` = the same binary with "
-                         "`[build] bmi_schedule = \"on\"`"
+        elif "+" in name:
+            parts.append(f"`{name}` = the SAME binary as `mcpp`, with the opt-in key "
+                         "`[build] bmi_schedule = \"on\"` (off by default)"
                          if lang == "en" else
-                         "`mcpp +schedule` = 同一个二进制,开了 "
-                         "`[build] bmi_schedule = \"on\"`")
+                         f"`{name}` = **和 `mcpp` 同一个二进制**,开了 opt-in 的 "
+                         "`[build] bmi_schedule = \"on\"`(默认关闭)")
         else:
-            parts.append(f"`mcpp (released)` = {e}, the published release"
-                         if lang == "en" else f"`mcpp (released)` = {e},已发布版")
+            parts.append(f"`{name}` = {e}, the previously published release"
+                         if lang == "en" else f"`{name}` = {e},上一个已发布版")
     return " · ".join(parts)
 
 
@@ -274,7 +290,7 @@ def headline(cells, baseline, lang):
                          "(only generated fixtures)")
     engines = engine_order({c["engine"] for c in cells})
     newest = next((e.split("+", 1)[0] for e in engines if e.startswith("mcpp@")), "")
-    short = {e: short_name(e, newest) for e in engines}
+    short = {e: short_name(e, newest, lang) for e in engines}
 
     # ⚠️ A COLD BUILD THAT IS NOT SLOWER THAN A NO-OP DID NOT BUILD ANYTHING.
     #
@@ -325,6 +341,11 @@ def headline(cells, baseline, lang):
                 txt = f"{c['median_s']:.2f}s"
                 if base and base.get("median_s"):
                     txt += f" · {base['median_s'] / c['median_s']:.1f}x"
+                # A CODE SPAN, so a narrow column cannot break `86.69s · 1.1x`
+                # across two lines — which is what a table this wide does first
+                # when the viewport shrinks, and a number split from its ratio
+                # reads as two different numbers.
+                txt = f"`{txt}`"
                 # Bold the fastest arm in the row, so the table reads without
                 # the reader dividing anything in their head.
                 cellsr.append(f"**{txt}**" if c["median_s"] == best else txt)
@@ -360,7 +381,7 @@ def main(argv):
         _engines = engine_order({c["engine"] for c in cells
                                  if not c["fixture"].startswith("synth-")})
         _newest = next((e.split("+", 1)[0] for e in _engines if e.startswith("mcpp@")), "")
-        print("COLUMNS: " + columns_legend({e: short_name(e, _newest) for e in _engines},
+        print("COLUMNS: " + columns_legend({e: short_name(e, _newest, lang) for e in _engines},
                                            _engines, lang))
         # The toolchain is recorded as the driver PATH; a footnote wants the
         # compiler, not where this machine happens to keep it.

docs/05-mcpp-toml.md

@@ -170,6 +170,8 @@ target       = "x86_64-linux-musl" # Default build target when no --target is pa
                                    # (≙ cargo build.target; e.g. "ship fully-static")
 macos_deployment_target = "14.0"   # Minimum supported OS version for macOS artifacts (macOS only)
 cache        = "global"           # Global dependency cache: global (default) | local | off (§2.10)
+jobs         = "auto"             # Concurrent compiles: a positive number, or "auto" (§ below)
+bmi_schedule = "auto"             # Module-edge scheduling: auto (= off) | on | off (§ below)
 ```
 
 `include_dirs_after` (#249) lists header directories that are searched **after**
@@ -196,6 +198,55 @@ baseline, and 14.0 is the floor of LLVM's official static libraries themselves).
 This value enters the BMI fingerprint, so switching targets automatically rebuilds
 the module cache.
 
+### Build concurrency (`jobs`) and module scheduling (`bmi_schedule`)
+
+```toml
+[build]
+jobs         = "auto"    # or a positive number; --jobs / MCPP_JOBS override it
+bmi_schedule = "off"     # auto (default, = off) | on | off
+```
+
+`jobs` is how many compiles run at once. `"auto"` is resolved **against the
+machine doing the build**, never frozen into the manifest: it takes the physical
+core count on a heterogeneous CPU (a 13900K is 8 P-cores + 16 E-cores, so its 32
+threads are not 32 equal workers) and clamps that by free memory, because a
+single module interface compile peaks at 0.5–1.0 GB. Precedence is
+`--jobs` / `MCPP_JOBS` > this key > the backend's own default. A malformed value
+is **reported, never silently treated as the default** — a typo that quietly
+restores the default is a build mysteriously slower than you asked for.
+
+`bmi_schedule` decides when importers are unblocked.
+
+| value | |
+|---|---|
+| `"auto"` | **the default, and it currently means OFF** |
+| `"on"` | split the module edge: importers start when the BMI is published, not when the compiler exits |
+| `"off"` | one edge per module |
+
+Only those three spellings are accepted. `"ON"`, `"true"` and `"yes"` are
+**rejected with a diagnostic** rather than quietly meaning off — and they are not
+harmless typos: the value enters the build fingerprint, so a rejected spelling
+used to select a different build directory (a full rebuild) while changing
+nothing about the schedule.
+
+**Why `auto` is off.** 86% of a module interface compile is code generation that
+no importer reads, so publishing the BMI early is worth a lot — measured on mcpp
+itself, `cold` 86.7s → 35.7s and `edit-body` 80.9s → 29.8s. But a scheduling
+change that is wrong is wrong *silently*: a missed dependency does not fail the
+build, it just stops rebuilding something. It stays opt-in until it has been
+through CI on every platform.
+
+**What it does not help.** Where mcpp already skips the cascade — `touch-hub`,
+`edit-comment` — there is no owed work to move off the critical path, and the
+key buys nothing. See the [benchmark](../README.md#benchmark).
+
+**How it works** differs per compiler and is chosen for you: gcc publishes its
+BMI with `rename()`, so code generation is detached and the edge returns at
+publication; clang gets two ordinary edges instead, because it writes the BMI to
+its final path with `O_TRUNC` and a reader could observe a half-written file.
+MSVC is left alone — neither `/ifcOnly`'s cost nor `.ifc` atomicity has been
+measured, and guessing either wrong is silent.
+
 ### Module interface extensions (`module_extensions`)
 
 mcpp treats `.cppm` as a module interface unit. The C++ ecosystem has not

docs/zh/05-mcpp-toml.md

@@ -161,6 +161,8 @@ defines      = ["BIZ=1", "QUX"]   # 作用于每个 TU 的预处理宏(脱糖为
 cxx_runtime  = "self-contained"   # C++ 运行时契约(见下节);static_stdlib 是旧拼写
 macos_deployment_target = "14.0"   # macOS 产物的最低支持系统版本(仅 macOS 生效)
 cache        = "global"           # 依赖的全局构建缓存:global(默认)| local | off(见 §2.10)
+jobs         = "auto"             # 并发编译数:正整数,或 "auto"(见下节)
+bmi_schedule = "auto"             # 模块边调度:auto(= 关)| on | off(见下节)
 ```
 
 `include_dirs_after`(#249)列出**排在工具链系统目录之后**搜索的头文件目录
@@ -181,6 +183,47 @@ cargo/rustc、cc 等同样尊重该变量)> 本字段(项目默认,类似 SwiftP
 14.0 即 LLVM 官方静态库自身的下限)。该值会进入 BMI 指纹——切换 target
 会自动重建模块缓存。
 
+### 构建并发(`jobs`)与模块调度(`bmi_schedule`)
+
+```toml
+[build]
+jobs         = "auto"    # 或正整数;--jobs / MCPP_JOBS 覆盖它
+bmi_schedule = "off"     # auto(默认,= 关)| on | off
+```
+
+`jobs` 是同时跑几个编译。`"auto"` **在构建这台机器上现算**,绝不冻进 manifest:
+异构 CPU 上取物理核数(13900K 是 8 P-core + 16 E-core,它的 32 个线程不是 32 个
+等价的工人),再按可用内存夹一次 —— 单个模块接口编译峰值 0.5–1.0 GB。
+优先级:`--jobs` / `MCPP_JOBS` > 这个键 > 后端自己的默认值。写错的值会被
+**明确报出来,绝不静默当成默认值** —— 一个悄悄退回默认的拼写错误,表现是
+「构建莫名其妙比我要求的慢」。
+
+`bmi_schedule` 决定**导入方什么时候被解锁**。
+
+| 值 | |
+|---|---|
+| `"auto"` | **默认值,而它目前等于「关」** |
+| `"on"` | 拆开模块边:BMI 一发布导入方就能开始,而不是等编译器退出 |
+| `"off"` | 每个模块一条边 |
+
+只认这三种拼写。`"ON"`、`"true"`、`"yes"` 会被**拒绝并给出诊断**,而不是悄悄
+当成关 —— 而且它们不是无害的笔误:这个值会进构建指纹,所以一个被拒的拼写
+以前会选到**另一个构建目录**(即一次全量重建),同时对调度没有任何影响。
+
+**为什么 `auto` 是关的。** 模块接口编译里 86% 是没有任何导入方会读的代码生成,
+所以提前发布 BMI 值很多 —— 在 mcpp 自己身上实测:`cold` 86.7s → 35.7s、
+`edit-body` 80.9s → 29.8s。但调度改错是**无声**的:少一条依赖不会让构建失败,
+只是某个东西不再重建了。所以它在所有平台走完 CI 之前保持 opt-in。
+
+**它在哪里没用。** mcpp 本来就跳过级联的地方(`touch-hub`、`edit-comment`)
+没有欠着的活可以挪出关键路径,这个键买不到任何东西。见
+[性能对比](../../README.zh-CN.md#性能对比)。
+
+**具体怎么做**按编译器而定,不需要你选:gcc 用 `rename()` 发布 BMI,所以代码
+生成被分离出去、边在发布时就返回;clang 换成两条普通边 —— 它把 BMI 直接
+`O_TRUNC` 写到最终路径,读的人可能看到写了一半的文件。MSVC 不动:`/ifcOnly`
+的代价和 `.ifc` 是否原子发布都没测过,而这两件事猜错都是无声的。
+
 ### 模块接口扩展名(`module_extensions`)
 
 mcpp 把 `.cppm` 视为模块接口单元。C++ 生态并没有收敛到一种拼法 —— Clang 还认

tests/e2e/233_bench_matrix.sh

@@ -474,6 +474,9 @@ for doc, header in (("README.md", r"\| scenario \| what changed \|"),
             raise SystemExit(1)
         for column, value in zip(engines, values):
             engine = mapping.get(column, column)
+            # Cells are code spans (`86.69s · 1.1x`) so a narrow column cannot
+            # split a number from its ratio; strip the span before parsing.
+            value = value.strip("`")
             if value == "-":
                 # Declared as not measured. Assert it really is absent, so `-`
                 # cannot be used to hide a number somebody did not like.