retrotalk 2.1.0

package/src/talk.js

@@ -0,0 +1,2094 @@
+// SPDX-FileCopyrightText: 2026 harayoki
+// SPDX-License-Identifier: MIT
+
+// 音声を合成します。
+//
+// 実機は 10ms のフレームごとにしか値を更新できず、1 回に動かせる幅も
+// 決まっていました。声のたどたどしさは、音質の粗さではなく、
+// この窮屈さから出ています。
+//
+//   音源（インパルスまたはノイズ） -> 2 次 IIR フィルタ 5 段（直列） -> 出来上がり
+//
+// 破裂音は、本体が 10ms しかなく、カ行とタ行とパ行の違いを伝えているのは
+// その前後で舌や唇が動く音のほうです。閉じているあいだに舌を持ち場へ動かし、
+// 開いたあとは息を漏らすようにしています。
+
+import { parseTalk } from './kana.js';
+import { parseAqua } from './aquestalk.js';
+import { parseVoicevox } from './voicevox.js';
+import { parseSing } from './sing.js';
+
+// ---- 実機から来ている数字 ----
+
+/**
+ * サンプリング周期(秒)。実測 約 100.6μs。設計 100μs がクロック比で間延びしたもの
+ * @private
+ */
+const TICK = 100.6e-6;
+/**
+ * 内部のサンプリング周波数。約 9940Hz
+ * @private
+ */
+const RATE = Math.round(1 / TICK);
+/**
+ * 1 フレームの長さ(秒)。実機は 10ms か 20ms を選べた
+ * @private
+ */
+const FRAME = 0.010;
+
+/**
+ * ピッチは周期で持つ。周期 = TICK × P で、P は 1〜128。初期値は 30(≒3.0ms)
+ * @private
+ */
+const P_MIN = 1, P_MAX = 128;
+
+/**
+ * フォルマントの「番地」から Hz へ。
+ * 実機の f は Hz ではなくチップ内蔵表への添字で、周波数は指数関数的に動く。
+ * 実測された 3 点(番地 28/37/53 -> 648/1028/2560Hz)から当てはめた。
+ * 1 番地あたり約 95 セント — ほぼ半音刻みになっている。
+ * @private
+ */
+const FREQ_A = 136.2, FREQ_K = 0.0552;
+const idxToHz = (idx) => FREQ_A * Math.exp(FREQ_K * idx);
+const hzToIdx = (hz) => Math.log(hz / FREQ_A) / FREQ_K;
+
+/**
+ * 5 本のフォルマントは同じ表を共有していて、持ち場だけが違う。
+ * F2 を基準にしたずれ(番地 = パラメータ値 + ここの値)。
+ * 既定位置で並べると F2 < F5 < F4 < F3 < F1 の順になり、
+ * 低いほうの 3 本(F2/F5/F4)が声の音色を作る。実機の互換 BASIC もそうしている。
+ * @private
+ */
+const F_HOME = [62, 0, 57, 47, 32];
+/**
+ * 音色を担う 3 本。F1..F5 のうち F2, F5, F4(音響でいう第 1〜3 フォルマント)
+ * @private
+ */
+const VOICED_STAGES = [1, 4, 3];
+
+/**
+ * 帯域幅 B の既定位置。使える幅(B1 は -9〜+6 など)の下限から読んだ。
+ * 位置が大きいほど帯域が広く、強度が下がる。
+ * F2 だけ 4 と浅く、他は 9〜11。だから既定では F2 だけが突出して強い。
+ * @private
+ */
+const B_HOME = [9, 4, 9, 9, 11];
+const B_STEPS = 16;
+/**
+ * 位置 0 で狭く(強い)、位置 15 で広い(弱い)
+ * @private
+ */
+const bposToBw = (pos) => 40 * Math.pow(30, pos / (B_STEPS - 1));
+
+/**
+ * 音色を担う 3 本に与える幅。持ち場の既定値をそのまま使うと、
+ * 第 2・第 3 フォルマントが広すぎて音が眠くなる。実機のデータも
+ * 音素ごとに B を指定していたので、ここで役目に合った幅を渡す。
+ * @private
+ */
+const B_VOICED = [3, 4.5, 6.5];
+/**
+ * 鼻に抜ける音の幅。第 1 は鋭いまま、第 2・第 3 を潰す。
+ *
+ * 鼻から出る音は、口の中の枝道で高いところが消える(反共鳴)。
+ * この作りは共鳴器を直列に並べただけで谷を作れないので、
+ * 代わりに上の 2 本を広げて弱める。音の重さは同じところへ来る。
+ *
+ * 母音と同じ幅で鳴らしていたころ、鼻音はただの低い母音でしかなく、
+ * 「ニュ」が言葉に聞こえなかった(2026-09-03)。
+ *
+ * 潰しすぎると、今度は無音に近づいて破裂音になる。
+ * 一度 11 / 12 まで広げたら「ニュウ」が「ドゥ」に聞こえた — 弱い低音のあと
+ * 母音が始まれば、それは口を開いた音になる。鼻は鳴っていなければならない。
+ * @private
+ */
+const B_NASAL = [3, 8, 9];
+/**
+ * 口を閉じているあいだの声(`BAR_AMP`)の幅。鼻音よりさらに潰す。
+ *
+ * ここが濁点の正体で、`カ` と `ガ` を分けているのはこの声。
+ * だから聞こえなければならない(小さくしすぎると `カ` と同じになる)。
+ *
+ * かといって大きいままだと、今度は鼻音と区別が付かない。
+ * どちらも「閉じたまま出ている低い声」なので、大きさだけでは分けられない。
+ *
+ * 分けているのは形のほう。閉じているとき、音は口からも鼻からも出ず、
+ * 出るのは喉と頬を通り抜けた低いところだけ — 口の形は音に乗らない。
+ * 鼻音は鼻から出るので形が残る。だから閉鎖のほうは潰し、
+ * 鼻音は残す(`B_NASAL`)。
+ * @private
+ */
+const B_BAR = [3, 13, 14];
+/**
+ * 鼻音のあとの渡りの幅。母音の出だしが鼻にかかる。
+ *
+ * 渡り(第 2 が 2100)を母音の幅(`B_VOICED`)で鳴らすと、狭い山が倍音のどれにも
+ * 当たらず、山が母音の 0.3 倍しか無い。次のフレームで母音へ落ちて 1.0 に跳ね、
+ * 「`ニュ` を単体で聞くと段階状の変化を 1 回感じる。不自然」と言われた(2026-09-04)。
+ * 上の 2 本を鼻音とほぼ同じ幅に広げると、山が 0.57 まで上がり、段差が半分になる。
+ * 人の声でも鼻音のあとの母音は出だしが鼻にかかり、フォルマントが太い。
+ * 鼻音のあとだけ。`ギュ` の渡りは母音の幅のまま(そちらは通っている)
+ * @private
+ */
+const B_NASALIZED = [3, 7, 9];
+/**
+ * こすれる音のときの幅。狭いほど「どこが鳴っているか」がはっきりする
+ * @private
+ */
+const B_NOISE = [8, 9, 10];
+/**
+ * 破裂とその息は、もっと広い。
+ *
+ * 破裂はどこも鳴っていて一瞬で終わる音で、こすれる音のように
+ * 決まった帯が鳴り続けるのではない。同じ幅で鳴らしていたころ、
+ * `タ` は `サ` に聞こえた(2026-09-03) — `タ` の山は 3400Hz にあり、
+ * 狭い幅でそこを鳴らせば、短くてもサ行の音になる。
+ *
+ * 幅で分ける。周波数では分けない — そちらは場所(カ / タ / パ)を
+ * 伝える役で、もう使っている。
+ * @private
+ */
+const B_BURST = [12, 13, 13];
+/**
+ * ノイズのときは使っていない 2 本も広げる。
+ * 置きっぱなしの 2 本は 3.2kHz と 4.2kHz に居るので、
+ * 摩擦音の山をそこへ持っていくと直列 5 段で共鳴が積み上がり、
+ * その一瞬だけ数百倍の音になる。そうなると音量をそろえたときに
+ * 他が全部ほぼ無音になる。
+ * @private
+ */
+const B_PARK_NOISE = 15;
+
+/**
+ * 1 フレームに動かせる幅。ここが「決まった速さでしか滑れない」の正体。
+ *
+ * 実機の上限は f が ±16 / b が ±4 / p が ±4 だが、既定はその内側に置く。
+ * 上限いっぱいで動かすと遷移が 10ms で終わってしまい、
+ * カ行の開始位置を母音ごとに分けても、そこに 1 フレームしか留まらない。
+ * 子音の場所を伝えているのはこの遷移なので、速すぎると
+ * 音色が切り替わっただけに聞こえて、何を言っているか分からなくなる。
+ *
+ * 実機のデータも全部が最速だったわけではなく、資料にも
+ * 「ゆっくりした変化が要る子音は、母音ごとに変化の過程も持つ」とある。
+ * @private
+ */
+const SLEW_F = 6, SLEW_B = 4, SLEW_P = 2;
+
+/**
+ * 一音一音の形。
+ *
+ * ---- なぜ要るか ----
+ *
+ * 歌わせると音符が音程を決めるので、しゃべりの抑揚が全部切れる。
+ * そこまではよいのだが、音量まで真っ平らになるので、
+ * 音符が並んでいるだけで歌っているように聞こえない。
+ * 人は伸ばすところで音を張り、切るところで落とす。それを付ける。
+ *
+ * 歌のときだけのものではない。しゃべりにも同じ形が付けられるので、
+ * 名前を `singStyle` から `style` に変えた(2026-09-04)。
+ *
+ * ---- しゃべりに `adsr` を掛けてはいけない ----
+ *
+ * 掛けてみたら聞き取りづらくなった(2026-09-04)。歌は 1 音が
+ * 50 フレームあるが、しゃべりの母音は 11 フレームしかない。
+ * 歌の目盛りで立ち上がりに 6 フレーム使うと、母音の半分が上り坂になる。
+ * 母音がどれだけ開いているかを聞き取るところが削れるので、字が溶ける。
+ *
+ * 浅くした `adsr` も試したが、これも良くなかった(2026-09-04)。
+ * 形を薄めても、頭を抑えることに変わりはない。
+ * そこで `natural` は形を持たない — 落ちていくだけにした。
+ * 頭がいちばん大きく、そこからほんの少し下がる。人の言い方はそれに近い。
+ *
+ * ---- 3 つのうちどれか ----
+ *
+ * | | 何が付くか |
+ * | --- | --- |
+ * | `flat` | 何も付けない。高さと長さだけ。既定はこれ |
+ * | `natural` | 一音ごとに、ほんの少しだけ落ちていく。しゃべり向け |
+ * | `adsr` | 一音ごとに立ち上がり・減り・保ち・切りを付ける。歌向け |
+ * | `vibrato` | `adsr` に加えて、伸ばしていると震えはじめる。歌向け |
+ *
+ * 上に積んである。`vibrato` は `adsr` を含む —
+ * 音量が平らなまま音程だけ震えると、震えているというよりぐらついて聞こえる。
+ * @alias TalkAudio.TALK_STYLES
+ * @static
+ */
+export const TALK_STYLES = ['flat', 'natural', 'adsr', 'vibrato'];
+
+/**
+ * 音の形の目盛り。フレーム(既定 10ms)と、4 ビットの音量の段で持つ。
+ *
+ * 音量の 1 段は約 2.5dB(`ampToGain` が 10^(1/8) 刻み)なので、
+ * 段で書くほうが耳に近い。
+ * @private
+ */
+const SING = {
+  attack: 6,      // 立ち上がりに使うフレーム数
+  attackDrop: 5,  // 立ち上がりの頭で下げておく段数
+  decay: 10,      // 立ち上がったあと落ち着くまでのフレーム数
+  sustain: 1,     // 落ち着いたあと下げたままにする段数
+  release: 6,     // 切り際に使うフレーム数
+  releaseDrop: 4, // 切り際で下げる段数
+  // 震えはじめるまで(フレーム)。短い音符では震えないのがこれ。
+  // 四分音符(t120 で 50 フレーム)の尻で震えだすと、音符ごとに尾を引いて
+  // 「震え」ではなく「ふらつき」に聞こえたので、伸ばす音まで待たせる
+  vibWait: 30,
+  vibRamp: 16,    // 震えが本気になるまで(フレーム)
+  vibHz: 4.5,     // 震える速さ。速いほど段の行き来が目立つので、少し遅く
+  // 震える幅(セント。半音の 100 分の 1)。
+  // 狭くしすぎると震えない。高さは P(周期の刻み)でしか持てないので、
+  // 幅が P の 1 目盛りに届かないと、2 つの値を行き来するだけの
+  // トリルになってしまう。45 セントで 4 段ほど動く(200Hz あたり)。
+  // 30 セントだと段を 2 つ行き来するだけで、震えではなくトリルに聞こえた
+  vibCents: 45,
+};
+
+/**
+ * `natural` の下げ幅(段)。1 音のあいだに、頭からここまで落ちる。
+ * 3 段は約 7.5dB。頭を抑えないので、聞き取りは変わらない。
+ * 2 段では `flat` と並べたときに差が分からなかった(2026-09-04)
+ * @private
+ */
+const NATURAL_DROP = 3;
+/**
+ * 落ち方。1 で真っ直ぐ。小さいほど頭のほうで速く落ちる。
+ * 真っ直ぐだと、落ちきる前に次の音が来て「まだ落ちている途中」に聞こえた
+ * @private
+ */
+const NATURAL_BEND = 0.7;
+/**
+ * 頭だけ下げる段。言いはじめは口が開ききっていないので、ほんの少し小さい。
+ * 2 フレームで戻す — ここを長くすると `adsr` と同じ失敗になる(母音が削れる)
+ * @private
+ */
+const NATURAL_HEAD = 0.6;
+
+/**
+ * 一音ずつ、落ちていくだけ。立ち上がりも切り際も持たない。
+ *
+ * 段に丸めない。丸めると 14 13 13 12 のように階段で落ちて、
+ * 落ちているというより途中で切り替わったように聞こえる(2026-09-04)。
+ * 出口の `ampToGain` は端数のまま受けられるので、そのまま渡す。
+ * 実機の 4 ビットから外れるが、`natural` はもともと実機に無いもの
+ * (`breath` や `ring` と同じ側)。歌の形は段のままにしてある
+ *
+ * @param {Array} out 目標の並び。ここへ足す
+ * @param {object} body 母音の目標(`amp` を差し替えて使う)
+ * @param {number} frames この音に使えるフレーム数
+ * @private
+ */
+function pushBang(out, body, frames, attack) {
+  // 伸ばしたぶんの尻は落とす。元の長さのところまでは張ったまま置いて、
+  // 足した尻だけを落とす。ここで消え際ができるので、
+  // 次の字との切れ目が分かって `！` の字が立つ(2026-09-06)
+  const tail = Math.max(1, Math.round(frames * (1 - 1 / BANG_LONG)));
+  const from = frames - tail;
+  // 張ったまま前半を通す。頭の数フレームで落としきると、
+  // 耳が比べる「伸びているところ」が記号の無い字と同じになって、
+  // 差が聞こえない(2026-09-06)。前半は張ったまま置いて、そこから落とす
+  const hold = Math.round(from * BANG_HOLD);
+  for (let k = 0; k < frames; k++) {
+    const t = k <= hold ? 0 : Math.min(1, (k - hold) / Math.max(1, attack));
+    // 落ちる先は元の大きさ。そこから下げると、言い切りが尻すぼみになる
+    let amp = body.amp + BANG_ATTACK * (1 - Math.pow(t, 0.6));
+    if (k >= from) amp -= BANG_TAIL_DROP * ((k - from + 1) / tail);
+    out.push({ ...body, amp: Math.max(1, amp), frames: 1 });
+  }
+}
+
+/**
+ * `！` の字が、頭で張り出す幅(4 ビットの段)。
+ *
+ * 段の上へはみ出す。出口の `ampToGain` は端数も 15 より上も受けられるので、
+ * 15 を越えたぶんはそのまま大きくなる(そろえるところで戻る)
+ * @private
+ */
+const BANG_ATTACK = 3;
+
+/**
+ * `！` の張りが落ちきるまでの長さ(フレーム)。
+ *
+ * 字の長さで割らない。長い字ほどゆるく張ることになって、
+ * 字によって突き方が変わってしまう。どの字でも同じ速さで落とす
+ * @private
+ */
+const BANG_FRAMES = 5;
+
+/**
+ * `！` の字で、張ったまま置く長さ(伸ばすぶんを除いた長さに対する割合)。
+ * 前半いっぱい。ここを短くすると、ただの立ち上がりになって言い切りに聞こえない
+ * @private
+ */
+const BANG_HOLD = 0.5;
+
+/**
+ * `！` の字を伸ばす倍率。少しだけ伸ばす。
+ * 伸ばしたぶん(`1 - 1 / BANG_LONG`)は `pushBang` が落としていく
+ * @private
+ */
+const BANG_LONG = 1.2;
+
+/**
+ * `！` の 1 つ手前の字を伸ばす倍率。下がりきるところを聞かせるぶん。
+ *
+ * 1.15 では聞き分けられなかった(2026-09-06)。音節の長さは
+ * 2 割変えれば「違う」と分かるが、「ためた」と聞こえるにはそれでは足りない。
+ * 1.8 まで伸ばして聞こえるようになったので、そこから半分に戻したのがこの値
+ * @private
+ */
+const BANG_PRE_LONG = 1.4;
+
+/**
+ * 伸ばした尻で下げる段数。消え際の深さ。
+ * 0 にすると伸ばしただけになって、ただ長い字に聞こえる
+ * @private
+ */
+const BANG_TAIL_DROP = 6;
+
+/**
+ * `！` の付いた字。頭を張って、そのまま落とす。
+ *
+ * 間を空けて区切る形も試したが、言い切りは間ではなく出だしの強さで
+ * 伝わる(2026-09-05)。頭が立つので、前の字との切れ目もそこで分かる
+ *
+ * @param {Array} out 目標の並び。ここへ足す
+ * @param {object} body 母音の目標(`amp` を差し替えて使う)
+ * @param {number} frames この音に使えるフレーム数
+ * @private
+ */
+function pushDecay(out, body, frames) {
+  for (let k = 0; k < frames; k++) {
+    const t = k / Math.max(1, frames - 1);
+    const drop = NATURAL_DROP * Math.pow(t, NATURAL_BEND)
+      + NATURAL_HEAD * Math.max(0, 1 - k / 2);
+    out.push({ ...body, amp: Math.max(1, body.amp - drop), frames: 1 });
+  }
+}
+
+/**
+ * `〜` で伸ばした母音の揺れ。歌の震えより、遅くて広い。
+ *
+ * 歌の震えは音を保ったまま飾るものだが、`〜` は言い方なので、
+ * ゆっくり大きく揺れて、そのまま落ちていく。
+ * @private
+ */
+const WAVE = {
+  hz: 4,        // 揺れる速さ
+  // 揺れる幅(セント)。歌の震え(30)より広い。言い方を表すものなので、
+  // はっきり揺れないと「伸ばしただけ」に聞こえる。
+  // 高さは周期の刻みでしか持てないので、高い声ほど段が粗くなる
+  cents: 60,
+  ramp: 5,      // 揺れが本気になるまで(フレーム)
+  sag: 2,       // 終わりまでに落とす段数
+};
+
+/**
+ * 揺らしながら伸ばす母音を、1 フレームずつに割る。
+ *
+ * @param {Array} out 目標の並び。ここへ足す
+ * @param {object} body 母音の目標
+ * @param {number} frames この母音に使えるフレーム数
+ * @param {number} f0 この母音の高さ(Hz)
+ * @param {number} frameSec 1 フレームの長さ(秒)
+ * @private
+ */
+function pushWave(out, body, frames, f0, frameSec) {
+  for (let k = 0; k < frames; k++) {
+    const depth = Math.min(1, (k + 1) / WAVE.ramp);
+    const cents = WAVE.cents * depth * Math.sin(2 * Math.PI * WAVE.hz * k * frameSec);
+    const P = Math.max(P_MIN, Math.min(P_MAX,
+      Math.round(1 / (f0 * Math.pow(2, cents / 1200) * TICK))));
+    // 尻すぼみにする。揺らしたまま同じ大きさで切ると、途中で止めたように聞こえる
+    const drop = WAVE.sag * (k / Math.max(1, frames - 1));
+    out.push({ ...body, P, amp: Math.max(1, Math.round(body.amp - drop)), frames: 1 });
+  }
+}
+
+/**
+ * 三角の揺れ。位相 0〜1 で 1 周し、返す値は -1〜1。
+ *
+ * 正弦にしないのは、高さが周期の刻みでしか持てないから。
+ * 正弦は折り返しのところで動きが止まるので、丸めると端の値に長く居座り、
+ * 段を 2 つ行き来するだけの音に聞こえる。
+ * 三角なら速さが一定なので、どの段にも同じだけ居る — 揺れて聞こえる。
+ *
+ * @param {number} phase 何周したか(整数部は捨てる)
+ * @private
+ */
+function tri(phase) {
+  const t = phase - Math.floor(phase);
+  return t < 0.5 ? 4 * t - 1 : 3 - 4 * t;
+}
+
+/**
+ * 歌う母音を、1 フレームずつに割って形をつける。
+ *
+ * 割るのは、`amp` も `P` もフレームの目標としてしか渡せないから。
+ * ここで作った並びは、そのあと `runFrames` が上限つきで追いかける
+ * (震えの幅は 1 フレームあたり `SLEW_P` に収まる程度にしてある)。
+ *
+ * @param {Array} out 目標の並び。ここへ足す
+ * @param {object} body 母音の目標(`amp` と `P` を差し替えて使う)
+ * @param {number} frames この音符に使えるフレーム数
+ * @param {number} f0 この音符の高さ(Hz)
+ * @param {string} style `adsr` か `vibrato`
+ * @private
+ */
+function pushSung(out, body, frames, f0, style) {
+  const { attackDrop, sustain, releaseDrop } = SING;
+  // 短い音符では、立ち上がりと切り際を詰める。そうしないと
+  // 十六分音符で頭と尻が重なって、音符まるごと小さくなる
+  const attack = Math.max(1, Math.min(SING.attack, Math.floor(frames / 3)));
+  const release = Math.max(1, Math.min(SING.release, Math.floor(frames / 3)));
+  const decay = Math.max(1, Math.min(SING.decay, frames - attack - release));
+  for (let k = 0; k < frames; k++) {
+    // 段で下げる。下げ幅を足し合わせて、最後に 1 回引く
+    let drop = 0;
+    if (k < attack) drop += attackDrop * (1 - (k + 1) / attack);
+    else if (k < attack + decay) drop += sustain * ((k - attack + 1) / decay);
+    else drop += sustain;
+    const left = frames - 1 - k;
+    if (left < release) drop += releaseDrop * (1 - left / release);
+
+    let P = body.P;
+    if (style === 'vibrato' && k >= SING.vibWait) {
+      const depth = Math.min(1, (k - SING.vibWait) / SING.vibRamp);
+      const cents = SING.vibCents * depth
+        * tri(SING.vibHz * (k - SING.vibWait) * (SING.frameSec || 0.01));
+      P = Math.max(P_MIN, Math.min(P_MAX,
+        Math.round(1 / (f0 * Math.pow(2, cents / 1200) * TICK))));
+    }
+    out.push({ ...body, P, amp: Math.max(1, Math.round(body.amp - drop)), frames: 1 });
+  }
+}
+
+/**
+ * ノイズ音源の大きさ。インパルスは周期に 1 回しか立たないのに対し
+ * ノイズは鳴りっぱなしなので、そのままだと子音だけ大きくなる。
+ * P=30 あたりでならすと、この比でだいたい釣り合う
+ * @private
+ */
+const NOISE_LEVEL = 0.2;
+/**
+ * 口を閉じたら、音は続かない。無音のフレームで、共鳴器に溜まったぶんを抜く割合
+ * (1 サンプルごと。0.94 で時定数 1.6ms ほど)。
+ *
+ * 放っておくと、閉鎖のあいだもフォルマントは動いているので、
+ * 溜まったぶんが動いた先の周波数で鳴り直す。5 段が直列なので、
+ * 運が悪いと重なって育ち、声の 14 倍の山が立つ
+ * (「キャベツ ト キュウリ。」の ツ の閉鎖で起きていた。2026-09-03)。
+ *
+ * 山が立つと、音量をそろえるときにそこを基準に全体が引き戻されるので、
+ * 文まるごとが 2 倍以上小さくなる。「音量的に聞き取りづらい」の正体がこれ。
+ * @private
+ */
+const SILENCE_DAMP = 0.94;
+/**
+ * 声道の長さ。既定のピッチ 280Hz とひと組で実機の女声にあたる。
+ * 実機には無いパラメータだが、既定を 0 でなく +2 にしてあるのは、
+ * 音素の表を男声の値で書いてあるため(そのままだと声が低く太い)。
+ * 耳で合わせた値で、実測ではない。
+ * @private
+ */
+const F_SHIFT = 2;
+/**
+ * 有声摩擦音(実機の FV)で、こすれる音に乗せる声の強さ
+ * @private
+ */
+const FV_LEVEL = 0.25;
+/**
+ * 破裂のあとに漏れる息。大きさ(4 ビットの音量の段)と、1 フレームごとの減り。
+ *
+ * カ・タ・パ を分けているのは、ここで聞こえる口の動き。
+ * 無声の破裂音は、開いてから声が始まるまでのあいだ息が漏れていて、
+ * その息が動いている途中の口を通る。舌がどこから母音へ向かったかは
+ * この音に出る — 破裂の一撃そのものは 10ms しかなく、そこだけでは分からない。
+ *
+ * 減らないと、こすれる音になる。同じ大きさで 30ms 続けたときは
+ * 「アカ」が「アハ」に聞こえた(2026-09-03)。無理もなくて、
+ * `h` は「母音の形をした息」そのものなので、息を母音の形のまま伸ばすと
+ * ハ行になる。摩擦音は続き、破裂の息は減っていく — 分けているのはそこ。
+ *
+ * 出だしは母音(14)より 5 段下。1 段が約 2.5dB なので、12dB ほど小さい。
+ * @private
+ */
+const ASPIRATE = 9, ASPIRATE_FADE = 3;
+/**
+ * 有声の破裂音(ガ・ダ・バ)は、閉じているあいだも声が続く。
+ * それが「濁っている」の中身で、無声の破裂音との違いはそこにある。
+ *
+ * 口は閉じているので低いところしか出ない。第 1 フォルマントを 200Hz へ下げ、
+ * 舌の位置(第 2・第 3)は子音のものを使う。
+ *
+ * 閉鎖を無音にしていたころ、`ギュウニュウ` の頭が聞こえず
+ * 「ううぬう」に聞こえた(2026-09-03)。破裂の一撃だけでは母音より 9dB 小さく、
+ * 有声の破裂音は一撃が弱いので、それだけでは立たない。
+ *
+ * 小さくしすぎてはいけない。ここは濁点の正体で、`カ` と `ガ` を
+ * 分けているのはこの声。4(母音より 25dB 下)まで落としたら
+ * `カ` と `ガ` の差が無くなった(2026-09-03)。
+ * 鼻音と紛れるのは大きさのせいではないので、そちらは形で分ける(`B_BAR`)
+ * @private
+ */
+const BAR_HZ1 = 200, BAR_AMP = 7;
+/**
+ * 母音の終わりを、次の子音へ向かって動かすフレーム数。
+ *
+ * 口は、次の音の用意を先に始める。「アカ」と言うとき、ア を言い終わってから
+ * 舌が動くのではなく、ア を言っている途中から奥へ向かっている。
+ * その動きは母音の大きさで鳴るので、いちばんよく聞こえる手がかりになる。
+ *
+ * ここが無かったころ、動きは全部閉鎖の無音の中で起きていた。
+ * 語頭(「カ。タ。パ。」)は破裂とその息だけで聞き分けられたのに、
+ * 母音のあと(「アカ。アタ。アパ。」)が 3 つとも同じに聞こえたのはこれ
+ * (2026-09-03 に聴いて分かった)。
+ *
+ * 2 フレーム = 20ms。1 フレームに動ける幅が 6 番地なので、最大 12 番地ぶん寄る。
+ * @private
+ */
+const COART = 2;
+/**
+ * 拗音の渡り。`キャ` の「子音と母音のあいだで、舌が天井へ寄っている」ところ。
+ *
+ * `キャ` は `カ` の母音を差し替えたものではない。別の子音で、
+ * 舌が硬口蓋へ寄ったまま `k` を作り、そこから母音へ開く。
+ * その「寄っている」ぶんが声のまま鳴る — ヤ行の渡りと同じ音。
+ *
+ * 母音だけ差し替えていたころ、`キャ` は `カ` とフレーム単位で同じものだった
+ * (測ると距離 0)。2026-09 に数字と英字を読ませたことで
+ * 「キュー」「ジェー」がこの口を通るようになり、露出が増えた。
+ *
+ * 2 フレーム = 20ms。長くすると「キイヤ」と 3 拍に割れて聞こえる。
+ * @private
+ */
+const PAL = 2;
+/**
+ * 拗音の鼻音(`ニャ` `ニュ` `ニョ` `ミャ` …)の長さ(フレーム)。直音の鼻音は表の 4。
+ *
+ * 「`ニュ` は舌が上あごに付いて粘る。`グ` より長い、短くできない」という
+ * 依頼者の自分の口での確かめを受けて、一度 60ms・80ms を試し、
+ * どちらも「むしろ変」だった(2026-09-03)。ただしそのときは渡りが
+ * 3kHz のチャープで、鼻音のあとに来る音が別物だった。
+ * チャープを消したあと「`ニュ` はもっと詰まった感じが欲しい」と言われたので、
+ * 条件が変わったものとして、拗音の鼻音だけ 60ms をもう一度だけ試す(2026-09-04)。
+ * 駄目なら 4 に戻す。
+ * @private
+ */
+const PAL_NASAL_FRAMES = 6;
+
+/**
+ * 音の組み替え方のパラメータ。`renderTalk(text, { assembly: { ... } })` で上書きできる。
+ *
+ * ---- なぜ要るか ----
+ *
+ * `ギュ` `ニュ` を直すとき、鼻音の長さ・渡りの幅・一撃の大きさ・開いたあとが声か無音か、
+ * を 1 つずつ変えては聴いてもらった。こちらには耳が無いので、
+ * 決めるのは聴く人で、そのたびにエンジンを固め直してページを配り直していた。
+ * 聴く人が自分で切り替えて聴き比べられれば、往復が 1 つ減る。
+ *
+ * 既定はここに書いた値で、表や定数と同じもの。ページで動かした値は
+ * 聴き比べるためのもので、良かったものはここ(と表)の既定に写す。
+ * パラメータのまま残さない。残すと「どれが本当の声か」が分からなくなる。
+ *
+ * | | 何を変えるか |
+ * | --- | --- |
+ * | `palNasalFrames` | 拗音の鼻音の長さ(フレーム)。`PAL_NASAL_FRAMES` |
+ * | `nasalAmp` | 鼻音の大きさ。`null` なら表の値 |
+ * | `nasalTail` | 鼻音の最後の 1 フレームで渡りの位置へ動きはじめるか |
+ * | `nasalizedGlide` | 鼻音のあとの渡りの幅を広げるか(`B_NASALIZED`) |
+ * | `glideAfterNasal` | 鼻音のあとの渡りの大きさ。`ramp` 12 → 14 / `full` 14 / `low` 12 |
+ * | `palF3` | 声で作る子音のあとの渡りの第 3。`vowel` 母音のまま / `y` ヤ行の 2900 |
+ * | `voicedBurstAmp` | 有声の破裂の一撃の大きさ |
+ * | `voicedBurstVoice` | 一撃に声を乗せるか |
+ * | `voicedGap` | 開いたあと。`voice` 声が戻る / `silent` 無音 |
+ * | `barAmp` | 閉じているあいだの声の大きさ。`BAR_AMP` |
+ * | `barBand` | 閉じているあいだの声の幅。`bar` 潰す / `nasal` 鼻音と同じ |
+ * @private
+ */
+const ASSEMBLY = {
+  palNasalFrames: PAL_NASAL_FRAMES,
+  nasalAmp: null,
+  nasalTail: true,
+  nasalizedGlide: true,
+  glideAfterNasal: 'ramp',
+  palF3: 'vowel',
+  voicedBurstAmp: 12,
+  voicedBurstVoice: false,
+  voicedGap: 'voice',
+  barAmp: BAR_AMP,
+  barBand: 'bar',
+};
+/**
+ * もともと硬口蓋で作る子音。渡りを入れない。
+ * `シャ` `チャ` `ジャ` `ヤ` は、子音そのものがすでにそこに在る
+ * (だから `シャ` は `サ` と混ざらず、拗音が潰れる話の外だった)。
+ * @private
+ */
+const PALATAL_ALREADY = new Set(['sh', 'ch', 'j', 'y']);
+/**
+ * 声で作る子音(ガ行・ナ行・マ行・ラ行・バ行)の拗音の口。
+ * 渡りと、手前の母音の向かう先と、子音そのもの(鼻音を除く)をここで鳴らす。
+ *
+ * 無声の子音(`キャ`)はイ段の位置(`hzBy.i`。第 3 が 3000 前後)で一撃を鳴らし、
+ * 渡りはヤ行の位置(第 3 が 2900)を通る。それで聞き分けられている(2026-09-03)。
+ *
+ * 声で作る子音に同じことをすると、音になる。第 3 が 2900〜3100 に来ると、
+ * 置きっぱなしの 2 段(3.5kHz / 4.5kHz)と重なって直列 5 段で積み上がる。
+ * 無声なら息がもともとその帯で鳴っているので気にならないが、声だと
+ * 測って 力の 97% が 3kHz より上の 20ms が、低い声と母音のあいだに挟まる。
+ * `ギュ` も `ニュ` も「低い声 → 高いチャープ → ウ」になり、
+ * 言葉ではなく音に聞こえ、2 つの差も消えた(2026-09-03)。
+ * 鼻音をイ段の位置(第 2 を 2100)へ置いても、同じ理由で母音と同じ大きさまで明るくなる。
+ *
+ * 舌が天井に寄っていることは第 2(2100)のほうで表せる。第 3 は母音のまま置く。
+ *
+ * @param {string} v 続く母音
+ * @private
+ */
+const palVoiced = (v) => [CONSONANTS2.y.hz[0], CONSONANTS2.y.hz[1], (VOWELS2[v] || VOWELS2.a)[2]];
+
+/**
+ * 声を出さない子音。無声化はこれに挟まれたときに起きる
+ * @private
+ */
+const VOICELESS = new Set(['k', 's', 't', 'h', 'p', 'sh', 'ch', 'ts', 'f']);
+/**
+ * 無声化した母音の大きさ(4 ビットの音量の段)と、長さ(フレーム)。
+ *
+ * `デス` の `ス`、`シタ` の `シ` は、口の形は作るが声を出さない。
+ * 息だけがその形を通るので、前後の子音のこすれる音とほとんど地続きになる。
+ * 声で鳴らすと「デスゥ」「シィタ」になる。
+ *
+ * 母音(14)より 6 段下 = 15dB。長さも 11 フレームから 6 へ詰める —
+ * 無声化した母音は短い。
+ * @private
+ */
+const DEVOICED = 8, DEVOICED_FRAMES = 6;
+
+/**
+ * どの母音が無声化するかを、拍の並び全体から決める。
+ *
+ * 規則で決まるので辞書は要らない。日本語では `i` `u` が無声子音に挟まれたときと、
+ * 無声子音のあとで句が終わるときに、声を出さなくなる。
+ *
+ *   デス     ス が句末    → 無声化
+ *   シタ     シ が sh と t に挟まれる → 無声化
+ *   スミ     次が m(声を出す子音)  → しない
+ *   デスー   伸ばしている            → しない
+ *
+ * 続けて 2 つは無声化しない。「シツレイ」で シ も ツ も無声化すると、
+ * 声の出ないところが 40ms 続いて言葉が消える。日本語も交互にしか無声化しない。
+ *
+ * @param {Array} moras `parseTalk()` が返した並び
+ * @returns {boolean[]} 拍ごとに、無声化するかどうか
+ */
+/**
+ * 言い切る記号。語尾の字を張って、少し長くする(`pushBang`)
+ * @private
+ */
+const BANG_MARKS = new Set(['!', '!?']);
+
+/**
+ * 語尾で高さが上がる記号。そこは無声化させない(上がりが聞こえなくなる)
+ * @private
+ */
+const LIFT_MARKS = new Set(['!', '?', '!?']);
+
+function markDevoiced(moras) {
+  const out = moras.map(() => false);
+  let prev = -1;                      // 直前に声を出した拍の番号
+  let phrase = [];                    // いまの句で、声を出す拍の番号
+  /**
+   * 句にひとつも声が残らないなら、最後のひとつは無声化しない。
+   * 「シュ。」「シ。」のように 1 拍だけの文だと、規則どおりに無声化すると
+   * 文まるごとが息だけになる。実際「ささやきに聞こえる」と言われた
+   * (2026-09-03)。人もそういう言い方はしない
+   */
+  const keepOne = () => {
+    if (!phrase.length || phrase.some((k) => !out[k])) return;
+    out[phrase[phrase.length - 1]] = false;
+  };
+  for (let i = 0; i < moras.length; i++) {
+    const m = moras[i];
+    if (m.set || m.tune) continue;    // 長さを持たない指示は飛ばす
+    if (m.pause) { keepOne(); phrase = []; prev = -1; continue; }
+    const was = prev; prev = i;
+    phrase.push(i);
+    // 書いてあるとおりにする。記号列(`format: 'aquestalk'`)は
+    // どこを無声化するかを書く人が決めているので、規則より記号が強い。
+    // 記号が無いところは無声化しない(`devoice: false`)。
+    // 書いてあるのに規則で足すと、書いた人の思ったとおりに読まれない
+    if (m.devoice !== undefined) { out[i] = !!m.devoice; continue; }
+    if (m.v !== 'i' && m.v !== 'u') continue;
+    if (m.hold) continue;             // 伸ばす母音は無声化しない
+    if (!VOICELESS.has(m.c)) continue;
+    // 次に声を出す拍。無ければ句の終わり
+    let j = i + 1;
+    while (j < moras.length && (moras[j].set || moras[j].tune)) j++;
+    const next = moras[j];
+    if (next && !next.pause && !VOICELESS.has(next.c)) continue;
+    // `！` `？` `！？` の語尾は無声化しない。どれも最後の 1 字で上がるので、
+    // そこを息だけにすると上がりを乗せる先が無くなる。
+    // 「ゲンキ？」の「キ」が上がっているのに聞こえなかった(2026-09-05)。
+    // `！` も上げるようにしたので、同じ扱いにした(2026-09-06)
+    if (next && next.pause && LIFT_MARKS.has(next.mark)) continue;
+    if (was >= 0 && out[was]) continue;   // 続けて 2 つは無声化しない
+    out[i] = true;
+  }
+  keepOne();
+  return out;
+}
+
+// ---- 音素の表 ----
+//
+// 目標は Hz で書いて、使うときに番地へ落とす。実機も表を持っていた。
+// 並びは音響でいう第 1〜3 フォルマント。値は男声。
+
+/**
+ * 母音。「ア」は実測から逆算された値がそのまま資料にある
+ * @private
+ */
+const VOWELS2 = {
+  a: [648, 1028, 2560],
+  i: [280, 2230, 3000],
+  u: [320, 1300, 2200],
+  e: [470, 1900, 2550],
+  o: [520, 850, 2500],
+  n: [280, 1200, 2400],   // 撥音。鼻へ抜けるので弱く
+};
+
+/**
+ * 撥音は 1 種類ではない。「ン」は、次に来る子音と同じ場所で作る。
+ *
+ * | 書くと | 次の子音 | 口 |
+ * | --- | --- | --- |
+ * | `ンマ` `ンパ` `ンバ` | m p b | 唇を閉じる(ローマ字なら m) |
+ * | `ンタ` `ンダ` `ンナ` `ンザ` | t d n r s z ts ch j sh | 舌の先(n) |
+ * | `ンカ` `ンガ` | k g | 舌の奥(ng) |
+ * | 語末、母音やヤ・ワ・ハ行の前 | — | 口の奥で鼻へ抜けるだけ |
+ *
+ * 自分では「ン」を 1 つしか書かないので気づきにくいが、
+ * 口はちゃんと 3 通りに動いている。1 種類で鳴らしていたころ、
+ * 「サンマ」と「サンカ」の `ン` はフレーム単位で同じものだった。
+ *
+ * 実機がこれをやっていたかは分からない(規則は ROM の中で読めない)。
+ * 日本語として正しくなるほうを採った。
+ * @private
+ */
+const NASAL = {
+  m:  [280, 1000, 2200],   // 唇。マ行と同じところ
+  n:  [280, 1500, 2500],   // 舌の先。ナ行と同じところ
+  ng: [280, 1900, 2300],   // 舌の奥。カ行と同じところ
+};
+/**
+ * 次の子音から、撥音の口を選ぶ。当てはまらなければ奥で鼻へ抜けるだけ
+ * @private
+ */
+function nasalFor(c) {
+  if (c === 'm' || c === 'p' || c === 'b') return NASAL.m;
+  if (c === 'k' || c === 'g') return NASAL.ng;
+  if (c === 't' || c === 'd' || c === 'n' || c === 'r' || c === 's' || c === 'z'
+    || c === 'ts' || c === 'ch' || c === 'j' || c === 'sh') return NASAL.n;
+  return VOWELS2.n;
+}
+
+/**
+ * 子音。開始時のフォルマントだけを持ち、そこから母音まで最速で滑る。
+ * 実機の互換 BASIC と同じ作りかた。
+ *   burst = 破裂。ためて(closure)、短く鳴らして、間を置いて母音へ
+ *   noise = 摩擦。ノイズを引き伸ばす
+ *   voiced = 有声のまま口を狭める
+ *
+ * 数はどれも 10ms のフレーム数。ここが量子化されているのが効く
+ *   closure 口を閉じてためる無音。破裂音はここの長さで破裂になる。
+ *           30ms しか無かったころは、母音のあとの `タ` が `ハ` に聞こえた
+ *           (2026-09-03)。母音 → ノイズ → 母音と続くと、
+ *           間が短いほど、耳はひと続きのこすれる音と読む。
+ *           無声は 60ms、有声は 40ms。有声が短いのは、声が閉じている
+ *           あいだも続くので、そもそも長く閉じていられないため
+ *   frames  子音そのものの長さ
+ *   gap     破裂から声が始まるまで(無声音ほど長い)
+ *
+ * `hzBy` があるものは、後ろに来る母音で開始位置が変わる。
+ * カ行とハ行のヒは、これが無いと母音の区別が付かない。
+ * 資料でも「遷移が認識の決め手になる音は、母音ごとにデータを持つ」とある。
+ * @private
+ */
+const CONSONANTS2 = {
+  // カ行とタ行は、第 2 フォルマントがほとんど同じ。分けているのは第 3 のほう —
+  // 舌の奥で閉じる音(カ・ガ)は第 2 と第 3 が近寄り、
+  // 舌の先で閉じる音(タ・ダ)は第 3 が高いところから母音へ落ちてくる。
+  // その落ちる音が、息の漏れているあいだに聞こえる(`ASPIRATE`)。
+  // ここを 2500 と 2800 にしていたころは、3 つとも同じに聞こえた(2026-09-03)
+  k:  { kind: 'burst', closure: 6, frames: 1, gap: 3, hz: [300, 1900, 2300],
+        hzBy: { i: [300, 2900, 3300], e: [300, 2500, 2900],
+                u: [300, 1300, 2200], o: [300, 1200, 2300] } },
+  // 有声の破裂の一撃は、無声と同じ大きさ(12)で、ノイズだけ。
+  // 一度 14 で声も乗せていた(閉鎖が無音だったころ、「開いた」と分かるのが
+  // 一撃だけだったため)。いまは閉鎖に声があり(`BAR_AMP`)、開いたあとも
+  // 声がすぐ戻る(`gap` を有声で鳴らす)ので、一撃で「開いた」を言う必要が無い。
+  // 声を乗せた大きな一撃は、拗音でイ段の位置に置くと `ギュ` が `シュ` に聞こえた
+  // (2026-09-03)。人の声でも、有声の破裂の一撃は無声より弱い
+  g:  { kind: 'burst', closure: 4, frames: 1, gap: 1, hz: [300, 1900, 2250], voiced: true,
+        hzBy: { i: [300, 2700, 3100], e: [300, 2400, 2800],
+                u: [300, 1300, 2100], o: [300, 1200, 2200] } },
+  // タ の息は 1 フレームだけ。破裂の一撃も、そのあとの息も、
+  // 高いところが鳴る(第 3 が 3400)。それを 30ms 続けると `サ` になる —
+  // 実際、母音のあとの `タ` が `サ` に聞こえていた(2026-09-03)。
+  // `サ` は 70ms 続くので、分けているのは長さ。20ms まで詰める
+  t:  { kind: 'burst', closure: 6, frames: 1, gap: 1, hz: [300, 1750, 3400] },
+  d:  { kind: 'burst', closure: 4, frames: 1, gap: 1, hz: [300, 1700, 3100], voiced: true },
+  p:  { kind: 'burst', closure: 6, frames: 1, gap: 1, hz: [300,  900, 2300] },
+  b:  { kind: 'burst', closure: 4, frames: 1, gap: 1, hz: [300,  900, 2200], voiced: true },
+  // サ行・シャ行は大きい。こすれる音のうち、この 2 つは山が高いところに
+  // あって母音と紛れないので、大きくしても母音へ溶けない(ハ行とは逆)。
+  // 既定(9)では母音より 11dB 下で、弱いと言われた(2026-09-03)
+  s:  { kind: 'noise', frames: 7, amp: 11, hz: [500, 3400, 4000] },
+  z:  { kind: 'noise', frames: 4, hz: [400, 3000, 3600], voiced: true },
+  sh: { kind: 'noise', frames: 7, amp: 11, hz: [500, 2300, 3100] },
+  j:  { kind: 'noise', frames: 4, hz: [400, 2300, 3000], voiced: true },
+  ch: { kind: 'noise', closure: 4, frames: 5, gap: 1, hz: [500, 2400, 3400] },
+  ts: { kind: 'burst', closure: 5, frames: 3, gap: 1, hz: [500, 3300, 3900] },
+  // ハ行は息だけの音なので、幅を広く取る(`wide`)。
+  //
+  // サ行と違って山が母音と同じあたりにあるので、狭い幅で鳴らすと
+  // ささやいた母音になる。実際「アハ」が「アア」と聞こえていた(2026-09-03)。
+  // 広げると帯ではなく息に聞こえる。
+  //
+  // 大きさを上げてはいけない。同じ形で母音に近い大きさにすると、
+  // ますますひと続きの母音になる(11 まで上げて悪くなった)
+  h:  { kind: 'noise', frames: 6, wide: true, hz: [600, 1500, 2400],
+        hzBy: { i: [300, 2800, 3300] } },   // ヒ は口の前のほうでこすれる
+  f:  { kind: 'noise', frames: 6, wide: true, hz: [500, 1600, 2500] },
+  // 鼻に抜ける音は小さい。口を閉じていて、音は鼻からしか出ない。
+  // 有声の既定(11)のままだと母音とほとんど同じ大きさなので、
+  // 言葉の切れ目にならない — 「ギュウニュウ」が 490ms ぶっ通しで鳴って、
+  // 言葉というより効果音に聞こえた(2026-09-03)。母音より 5 段(12dB)下げる
+  // 鼻音は、はっきり鳴って長い。閉じているのは口だけで、鼻からは出ている。
+  // 有声の破裂音(閉鎖はほとんど無音)と分けているのはここなので、
+  // 弱くも短くもしない — 弱くすると破裂音に寄り、実際「ニュ」が
+  // 「ドゥ」に聞こえたことがある(2026-09-03)。
+  //
+  // 長さは触らない。「`ニュ` は `グ` より長い、短くできない」という
+  // 自分の口での確かめを受けて 60ms・80ms を試したが、
+  // どちらも「むしろ変」だった(2026-09-03)。
+  // 人の発声がそうでも、この音では不自然になる。40ms のまま。
+  //
+  // 拗音(`ニャ` `ニュ` `ニョ`)は渡りの位置で鳴らす(`palVoiced`)。
+  // ここに `hzBy: { i: [280, 2100, 2500] }` を置いて試したら、
+  // 鼻音が母音と同じ大きさになった(-5dB → +0.5dB。第 2 が 2kHz を越えると
+  // 置きっぱなしの 2 段と重なって明るくなる)。鼻音は暗く小さくなければならない
+  n:  { kind: 'voiced', frames: 4, amp: 10, nasal: true, hz: [280, 1500, 2500] },
+  m:  { kind: 'voiced', frames: 4, amp: 10, nasal: true, hz: [280, 1000, 2300] },
+  r:  { kind: 'voiced', frames: 2, hz: [400, 1400, 1800] },
+  y:  { kind: 'voiced', frames: 3, hz: [300, 2100, 2900] },
+  w:  { kind: 'voiced', frames: 3, hz: [320,  800, 2200] },
+};
+
+/**
+ * 省いたときの値。`renderTalk()` の引数の既定を、1 か所にまとめたものです。
+ *
+ * マニュアルに「省くとどうなるか」を載せるとき、手で書き写すとずれるので、
+ * ここから読めるようにしてあります。ここを直せば表示もそのまま変わります。
+ *
+ * 実機に無いパラメータ(声道・息・ゆらぎ・掛け合わせ)も、省いたときは効かない
+ * ように 0 を並べてある。何も渡さなければ実機の作りに戻る。
+ * @alias TalkAudio.TALK_DEFAULTS
+ * @static
+ */
+export const TALK_DEFAULTS = {
+  pitch: 280,        // 声の高さ(Hz)
+  pitchShift: 0,     // 文の中の `@p` ごと上げ下げする量(半音)
+  tuneStep: 1,       // `＞` `＜` 1 つで動く量(半音)
+  volume: 10,        // `@v` を書かなかったときの音量(0〜15)
+  volumeShift: 0,    // 文の中の `@v` ごと上げ下げする量(段。`@v` と同じ 0〜15 の目盛り)
+  speedShift: 1,     // 文の中の `@s` ごと掛ける倍率
+  speed: 1,          // しゃべる速さ
+  fall: 4,           // 語尾へ下がる量(半音)
+  rise: 1,           // 出だしで上がる量(半音)
+  formantShift: F_SHIFT,
+  bandShift: 0,      // 共鳴の鋭さ
+  breath: 0,         // 息の混じり
+  jitter: 0,         // 周期のゆらぎ
+  ring: 0,           // 掛け合わせる音の高さ(Hz)
+  interp: false,     // フレーム間を埋めるか
+  frame: FRAME,      // 1 フレームの長さ(秒)
+  bits: 0,           // 量子化のビット数(0 で無し)
+  style: 'flat',
+  slewF: SLEW_F, slewB: SLEW_B, slewP: SLEW_P,
+  lag: 0, lagPerMora: 0,
+  seed: 1,
+  gainNorm: true, level: 0.15,
+};
+const D = TALK_DEFAULTS;
+
+/**
+ * 種を持つ乱数。鳴らすたびに変わると、書き出した音と聴いた音が食い違う
+ * @private
+ */
+function makeRandom(seed) {
+  let s = (seed | 0) || 0x9e3779b9;
+  return () => {
+    s ^= s << 13; s ^= s >>> 17; s ^= s << 5;
+    return (s >>> 0) / 0x100000000 * 2 - 1;
+  };
+}
+
+/**
+ * Hz の 3 つ組を、F1..F5 ぶんのパラメータ値へ。使わない 2 本は持ち場のまま。
+ *
+ * `shift` は声道の長さにあたる(実機に無いパラメータ)。表が番地に対して対数なので、
+ * 「口の中を 2 割短くする」が全部の番地に定数を足すだけで済む。
+ * 1 番地が約 95 セントなので、+3 でおよそ 1 割 8 分高くなる。
+ * @private
+ */
+function toParams(hz, shift = 0) {
+  const p = [shift, shift, shift, shift, shift];
+  VOICED_STAGES.forEach((stage, k) => {
+    p[stage] = hzToIdx(hz[k]) - F_HOME[stage] + shift;
+  });
+  return p;
+}
+
+/**
+ * その音のときの帯域幅の位置。使わない 2 本は持ち場のまま(ノイズなら広げる)。
+ * @param {boolean} noise ノイズを通すか
+ * @param {boolean} [wide] 幅を広く取るか(破裂とその息、それに息だけの音)
+ * @param {string} [voicedKind] 声のときの種類。`nasal`(鼻に抜ける)か
+ *   `bar`(口を閉じている)か `nasalized`(鼻音のあとで、鼻にかかっている)で、
+ *   上の 2 本の潰しかたが変わる
+ * @private
+ */
+function toBpos(noise, wide, voicedKind) {
+  const bp = noise ? B_HOME.map(() => B_PARK_NOISE) : B_HOME.slice();
+  const table = noise ? (wide ? B_BURST : B_NOISE)
+    : voicedKind === 'nasal' ? B_NASAL : voicedKind === 'bar' ? B_BAR
+      : voicedKind === 'nasalized' ? B_NASALIZED : B_VOICED;
+  VOICED_STAGES.forEach((stage, k) => { bp[stage] = table[k]; });
+  return bp;
+}
+
+/**
+ * 拍の並びを、目標の並びへ。ここではまだ滑らかさを考えない。
+ * @private
+ */
+function buildTargets(moras, opts) {
+  const frame = opts.frame ?? D.frame;
+  // 音の組み替え方。聴き比べるためのパラメータで、既定は `ASSEMBLY`
+  const A = { ...ASSEMBLY, ...(opts.assembly || {}) };
+  // 読みの側が高さを持っているときは、自動の抑揚を切る。
+  // 上げ下げが二重に掛かって、形が壊れる(VOICEVOX は拍ごとに高さを持っている)
+  const auto = opts.format !== 'voicevox';
+  const fall = auto ? (opts.fall ?? D.fall) : 0;
+  const rise = auto ? (opts.rise ?? D.rise) : 0;
+  const out = [];
+
+  // 高さと速さは文の途中で変わる。`@p200` `@s150` が来たら差し替える
+  // (parseTalk が `set` を付けた要素を並びに混ぜてくる)。だから `let`。
+  //
+  // 既定は 280Hz(P=35)。`formantShift` の既定 +2 とひと組で、
+  // これで実機の女声(`f`)にあたる。
+  //
+  // これは耳で合わせた値で、実測ではない。依頼者の「記憶の中の実機に
+  // そっくり」という判断で決めた。資料に実際の声の高さは載っていない。
+  //
+  // チップの初期値 P=30(≒331Hz)とは別物。 資料の言葉は
+  // 「デフォルトのピッチ＋累積ピッチの合計を P と呼ぶ」で、30 は
+  // 電源を入れた直後の値。音声データは喋りはじめる前に p を送って
+  // そこから動かす(男声の例では `p=+3` を必要回数繰り返している)。
+  // 一度ここを取り違えて既定を 331Hz にした。
+  //
+  // 実機の男声(`m`)は 1 オクターブ下なので `{ pitch: 140 }` あたり
+  // 文の中の `@p` ごと、まとめて上げ下げする。
+  // 写してきた文は高さが書き込まれているので、`pitch` を変えても動かない。
+  // 聞き苦しいところに当たったとき、書き換えずに動かせるようにしてある
+  const pShift = Math.pow(2, (opts.pitchShift ?? D.pitchShift) / 12);
+  let pitch = (opts.pitch ?? D.pitch) * pShift;
+  // 文の中の `@s` ごと、まとめて速さを掛ける。`@p` と同じ理由 —
+  // 写してきた文は速さが書き込まれていて、`speed` を変えても動かない
+  const sMul = Math.max(0.05, opts.speedShift ?? D.speedShift);
+  // `＞` `＜` 1 つぶんの幅
+  const tuneStep = opts.tuneStep ?? D.tuneStep;
+  let speed = (opts.speed ?? D.speed) * sMul;
+  // 音量。`@v` と歌の `v` を 0〜1 に直したものを掛け合わせて持つ。
+  // ここでは目標に付けるだけで、実際に掛けるのは仕上げのところ —
+  // 途中で掛けると、そろえる処理(`gainNorm`)に打ち消される
+  // 文の中の `@v` ごと、まとめて音量を上げ下げする。
+  // 目盛りは `@v` と同じ(0〜15 の段)で、`+2` なら 2 段ぶん大きい
+  const vAdd = (opts.volumeShift ?? D.volumeShift) / 15;
+  // 書かなかったときの音量。`@v` と同じ 0〜15 の目盛りで持つ
+  let vol = Math.max(0, Math.min(15, opts.volume ?? D.volume)) / 15;
+  /** 段ぶん動かして、0〜1 に収める */
+  const withShift = (v) => Math.max(0, Math.min(1, v + vAdd));
+  /** 拍ごとの音量。目標に付け直すのに使う */
+  const volOf = [];
+  /** 歌の `q` で切ったぶん。次の拍の前に置く(フレーム数) */
+  let postGap = 0;
+  /** `( )` で分け合っている最中の音符と、前のぶんの長さ、残り */
+  let tied = null, tiedShare = 0, tiedLeft = 0, tiedRest = 0;
+  /**
+   * その拍が使う音符を取る。`tie` が立っていれば、前の音符を分け合う。
+   *
+   * @param {object} m 拍
+   * @param {number} mi 何番目の拍か
+   */
+  const takeNote = (m, mi) => {
+    if (m.tie && tied) {
+      tiedLeft--;
+      // 長さは最後の拍に寄せる。「クヮ」の ク は渡りのように短く、
+      // ワ が音を持つ。等分すると 2 つの音に聞こえて、くくった意味が無くなる
+      const frames = tiedLeft > 0 ? tiedShare : tiedRest;
+      if (tiedLeft > 0) tiedRest -= tiedShare;
+      // 最後の 1 つに `q` の間を持たせる(途中で黙ると、そこで切れる)
+      return { ...tied, frames, gap: tiedLeft > 0 ? 0 : tied.gap };
+    }
+    const raw = notes[noteAt++];
+    if (!raw) return null;
+    // くくりの中に何拍あるか。長さを分けるのに要る
+    let n = 1;
+    for (let k = mi + 1; k < moras.length; k++) {
+      const q = moras[k];
+      if (q.set || q.tune) continue;
+      if (q.pause || !q.tie) break;
+      n++;
+    }
+    if (n < 2) { tied = null; return raw; }
+    // 前の拍は短く(n + 1 で割る)、余りを最後に寄せる
+    tiedShare = Math.max(1, Math.floor(raw.frames / (n + 1)));
+    tiedLeft = n - 1;
+    tiedRest = raw.frames - tiedShare;
+    tied = raw;
+    return { ...raw, frames: tiedShare, gap: 0 };
+  };
+  // 表はフレーム数で書いてある。実機のフレームが 10ms 固定だったので、
+  // 子音 4 フレーム・母音 11 フレームのように数えている。
+  // `frame` を変えても長さは変わらないようにする — あれは粗さのパラメータで、
+  // 動かすと速さまで変わるのでは、読む人には説明のしようがない(2026-09-05)
+  const perTick = D.frame / frame;
+  const nf = (n) => Math.max(1, Math.round(n * perTick / speed));
+  /** 秒で持っているもの(間)は、そのままフレーム数へ */
+  const nfSec = (sec) => Math.max(1, Math.round(sec / frame / speed));
+
+  // 実機は文全体に「最初少し上がって、だんだん下がる」抑揚が自動で付く
+  /**
+   * 抑揚。文の終わりの記号で言い方が変わる。
+   *
+   * | | |
+   * | --- | --- |
+   * | `。` `、` | そのまま。少し上がって、だんだん下がる |
+   * | `？` | 語尾の 1 拍だけ跳ね上がる。そこまでは普通の文と同じに下がる |
+   * | `！` | 文まるごと高くなり、下がりも強い。言い切ったように聞こえる |
+   * | `！？` | 両方。高いところから、語尾でさらに跳ね上がる |
+   * | `…` | 上がらずに、下がりきる。弱くもなる。言いさし |
+   *
+   * 書いた人は 3 つを書き分けているので、読み分けないほうが不親切。
+   *
+   * ---- ？ が最後だけなのはなぜか ----
+   *
+   * 日本語の疑問は語尾で上げる。文の頭から上がり続けると、
+   * 尋ねているというよりずっと不安げに聞こえる。
+   * 上げるのは最後の 1 拍だけにして、そこまでは言い切る文と同じに下げる。
+   *
+   * ---- ！ が高さなのはなぜか ----
+   *
+   * 張った声は、下がり方より高さに出る。下がりを強くするだけだと
+   * 「しぼんでいく」ように聞こえるので、文ごと持ち上げる。
+   */
+  /** `！` の文が持ち上がる量(半音) */
+  const BANG_LIFT = 2;
+  /**
+   * 記号ごとの、文の形。
+   *
+   * `lift` が文まるごとの持ち上げ、`up` が出だしで上がる量、
+   * `down` が語尾へ下がる量(どれも半音)。
+   *
+   * `！？` は `！` と `？` を足したもの。驚いて問い返すのは、
+   * 言い切る言い方の上に尋ねる語尾が乗る言い方で、どちらか一方ではない。
+   * `…` は上がらない。言いさしは持ち上げるところが無く、
+   * 下がりきって、そのまま消える。
+   */
+  const SHAPE = {
+    '.': { lift: 0, up: rise, down: fall },
+    // `！` は、最後の 1 字だけ上がる。そこまではふつうの文と同じに読む。
+    //
+    // 文まるごと持ち上げていたころは、出だしから裏返って聞こえた。
+    // 上がり下がりまで止めたら、こんどは手前がずっと平らになった
+    // (2026-09-04)。上げるのは尻(`TAIL_UP`)、手前は言い切る文と同じでよい。
+    // まるごと張りたいときは `（ ）` でくくる
+    '!': { lift: 0, up: rise, down: fall },
+    '?': { lift: 0, up: rise, down: fall },
+    // `！？` は文まるごとは上げない。上げると出だしから裏返って聞こえる —
+    // 「ソウナノ！？」の `ソ` からうわずっていた(2026-09-04)。
+    // 驚きは語尾で出す(下の `TAIL_UP`)
+    '!?': { lift: 0, up: rise, down: fall },
+    '…': { lift: 0, up: 0, down: fall * 1.3 },
+  };
+  /**
+   * 記号ごとの、高さの動き(半音)。`u` はどこか(0 が頭、1 が終わり)。
+   *
+   * | `！` | 動かさない。くくった中まで上がると声が裏返る |
+   * | `？` | 上がる(尋ねる) |
+   * | `！？` | `？` と同じだけ上がる。差は張りのほう |
+   *
+   * くくったときだけの表。くくらない語尾は下の `TAIL_UP` が決める。
+   * `？` と `！？` は両方で同じだけ上げるが、`！` はここだけ 0 —
+   * 語尾 1 字なら少し上げてよくても、くくった範囲まるごとを上げると
+   * 声が裏返って聞こえる。
+   *
+   * くくりが 1 字しかないときは動きようがないので、真ん中の値を使う
+   */
+  const GROUP_SHAPE = {
+    '!': () => 0,
+    // 段々に上げない。くくった中はまるごと同じだけ上がる。
+    // 上げていくと、字を追うごとに高くなって階段に聞こえた(2026-09-05)
+    '?': () => Math.max(2, fall),
+    '!?': () => Math.max(2, fall),
+  };
+  /**
+   * 語尾で動く量(半音)。後ろから数えて並べる(最後が右端)。
+   *
+   * `！` もここに居る。`？` の半分だけ上がる。ここに書くと
+   * その 1 字が下がりきる前で止まって、少し上に張り付く —
+   * `！` に欲しいのはまさにそれ(2026-09-06)
+   */
+  const TAIL_UP = {
+    // `？` の 3 分の 1。張りと長さだけでは `。` と聞き分けられなかったが、
+    // `？` に近いところまで上げると尋ねているように聞こえる
+    '!': [Math.max(1, fall / 3)],
+    '?': [Math.max(2, fall)],
+    '!?': [Math.max(2, fall)],
+  };
+  /**
+   * 記号ごとの、声の張り(4 ビットの音量の段)。
+   *
+   * 言い切るところは張り、言いさしは落とす。`！？` を `！` より張るのは、
+   * 驚きのほうが言い切りより声が出るため。
+   */
+  const PUSH = { '!': 2, '!?': 3, '…': -2 };
+  /**
+   * 文の中で手で上げ下げしたぶん。`＞` `＜` で 1 つ半音ずつ動く。
+   *
+   * 自動の抑揚は「少し上がって、だんだん下がる」しか知らないので、
+   * どこを持ち上げたいかは書いた人にしか分からない。
+   * 動かす量が半音なのは、ここが言い方の調整で、別人にする話ではないから
+   * (声そのものを変えるなら `@p` のほうを使う)。
+   */
+  let tune = 0;
+  /** 上げ下げの効く幅。外れると言葉に聞こえなくなるので止める(半音) */
+  const TUNE_MAX = 12;
+  const f0at = (t, mark, tail, flat) => {
+    // 跳ね上がるのは語尾だけ。`tail` は後ろから数えた番号(1 が最後)
+    const ups = TAIL_UP[mark];
+    if (ups && tail && tail <= ups.length) {
+      return pitch * Math.pow(2, (ups[ups.length - tail] + tune) / 12);
+    }
+    const sh = SHAPE[mark] || SHAPE['.'];
+    // `（ ）` の中は、出だしの上がりを拾わない(`flat`)。
+    // 文の頭に括弧が来ると、自動の抑揚の上がりはじめに重なって、
+    // そのぶん高いところで止まってしまう
+    const base = sh.lift + (flat
+      ? (t < 0.15 ? 0 : -sh.down * ((t - 0.15) / 0.85))
+      : (t < 0.15
+        ? sh.up * (t / 0.15)
+        : sh.up - (sh.up + sh.down) * ((t - 0.15) / 0.85)));
+    return pitch * Math.pow(2, (base + tune) / 12);
+  };
+
+  // 歌わせるとき。拍 1 つに音符 1 つを対応させる。
+  // 実機(PC-6601)の楽譜文字列と同じ考えかた。呼び出し方はまだ決めていない
+  // ので、いまは { hz, frames } の並びを直に受ける。
+  // 実機も歌うとアクセント記号が無効になるので、自動抑揚は切る
+  // 歌わせる。`sing` に音符の並びを書く(sing.js)。
+  // 低いところで組み立てたいときは `notes` に `{ hz, frames }` を直に渡す
+  let notes = opts.notes || null;
+  if (!notes && opts.sing) {
+    const got = parseSing(opts.sing);
+    if (got.warn.length) {
+      console.warn('[RetroTalk] 歌の音符に読めないものがあります — ' + got.warn.join(' ')
+        + '(使えるのは cdefgab r + # - 数字 . l o > < t &)');
+    }
+    notes = got.notes.map((n) => {
+      const all = Math.max(1, Math.round(n.sec / frame));
+      // `q` で切ったぶんは、そのまま間になる。音符の長さは変えない
+      const on = Math.max(1, Math.round(all * (n.q ?? 1)));
+      return { hz: n.hz, rest: n.rest, vol: n.vol, frames: on, gap: all - on };
+    });
+  }
+  const shift = opts.formantShift ?? D.formantShift;
+  // 歌の音の形。知らない名前は言う(黙って flat にすると、
+  // 「書いたのに効かない」になる)
+  let style = opts.style ?? D.style;
+  if (!TALK_STYLES.includes(style)) {
+    console.warn(`[RetroTalk] 音の形に ${style} はありません(${TALK_STYLES.join(' / ')})`);
+    style = 'flat';
+  }
+  SING.frameSec = frame;
+  let noteAt = 0;
+
+  /**
+   * 抑揚の位置を、文の切れ目ごとに取り直す。
+   *
+   * 実機は「少し上がって、だんだん下がる」を文全体に掛ける。1 文なら
+   * それでよいが、続けて何文も喋らせると最後まで下がり続けて沈む。
+   * 読点と句点で 0 に戻す — 息継ぎのたびに取り直すのと同じ。
+   *
+   * 空白では戻さない。あれは区切りではなく間なので、
+   * そこで戻すと文の途中で持ち上がって、言い直しているように聞こえる。
+   */
+  const ts = [];
+  // その文が何で終わるかも、拍ごとに配っておく。
+  // 「。」と「！」と「？」で言い方が変わるので、切れ目としてまとめない
+  const mk = [];
+  // その文の最後の拍にだけ目印を付ける(`？` はそこだけ上がる)
+  const tl = [];
+  {
+    let head = 0;
+    const spread = (end, mark) => {
+      const n = Math.max(1, end - head - 1);
+      for (let k = head; k < end; k++) { ts[k] = (k - head) / n; mk[k] = mark; }
+      // 休みと指示は声ではないので、後ろから見て声のところを数える。
+      // 2 つまで見るのは、`！？` が 2 拍かけて上がるため
+      let seen = 0;
+      for (let k = end - 1; k >= head; k--) {
+        if (moras[k].pause || moras[k].set || moras[k].tune) continue;
+        tl[k] = ++seen;
+        if (seen >= 2) break;
+      }
+    };
+    for (let k = 0; k < moras.length; k++) {
+      if (!moras[k].brk) continue;
+      spread(k, moras[k].mark || '.');
+      ts[k] = 0; mk[k] = moras[k].mark || '.';
+      head = k + 1;
+    }
+    spread(moras.length, '.');
+  }
+
+  // `（ ）` でくくったところは、抑揚を止める。
+  //
+  // 中はくくりの頭の高さのまま動かない。後ろに `！` `？` が来たときは、
+  // その跳ね上がりをくくり全体に掛ける — 1 字だけ跳ねるのではなく、
+  // まとめて上がる。「（ホントニ）！？」の全部が上ずるのはこれ。
+  // くくっただけなら止まるだけで、上がりも下がりもしない
+  const liftOf = [];
+  // ためる字。言い切る記号の手前を伸ばす。くくってあればくくりの手前、
+  // くくっていなければ語尾の 1 つ手前(そちらは `tl` で分かるので、ここには入れない)
+  const preLong = [];
+  for (let k = 0; k < moras.length; k++) {
+    if (!moras[k].lift) continue;
+    let end = k;
+    while (end + 1 < moras.length && moras[end + 1].lift) end++;
+    let shape = null;
+    let gm = null;
+    for (let j = end + 1; j < moras.length; j++) {
+      const q = moras[j];
+      if (q.set || q.tune) continue;              // 長さを持たない指示は飛ばす
+      if (q.pause) { gm = q.mark; shape = GROUP_SHAPE[q.mark] || null; }
+      break;
+    }
+    // くくった塊の手前も、ためる。`あ（いい）！` の `あ` は、
+    // くくらない `あいい！` の 1 つ手前の字と同じ役をしている
+    if (BANG_MARKS.has(gm)) {
+      for (let j = k - 1; j >= 0; j--) {
+        const q = moras[j];
+        if (q.set || q.tune) continue;
+        if (q.pause) break;                       // 文の切れ目より前は見ない
+        preLong[j] = true;
+        break;
+      }
+    }
+    // 声のところだけ数える。間や指示は動きの数に入らない
+    const at = [];
+    for (let j = k; j <= end; j++) if (!moras[j].pause && !moras[j].set) at.push(j);
+    for (const [n, j] of at.entries()) {
+      const u = at.length > 1 ? n / (at.length - 1) : 0.5;
+      liftOf[j] = { t: ts[k] ?? 0, up: shape ? shape(u) : 0, mark: gm };
+    }
+    k = end;
+  }
+
+  // 無声化は並び全体を見ないと決まらない(前後の子音と、句の終わり)
+  //
+  // 歌うときは掛けない。歌は母音を伸ばすもので、人も歌では無声化しない。
+  // 掛けたままだと、音符の長さぶんノイズが伸びる —
+  // 「ミワタスカギイリ」の `ス` が 600ms のノイズになって、
+  // 破裂音のように聞こえた(2026-09-04)。しゃべりの 13 フレームなら気にならないが、
+  // 音符に合わせて 60 フレームまで伸びると別の音になる
+  const devoiced = notes ? moras.map(() => false) : markDevoiced(moras);
+
+  let i = 0;
+  for (const m of moras) {
+    // どの拍から出た目標かを覚えておく。測るときに、
+    // 「キャ」と「カ」の同じ位置のフレームを突き合わせるのに要る
+    const mi = i++;
+    const t = ts[mi] ?? 0;
+    if (m.set) {
+      if (m.set.pitch > 0) pitch = m.set.pitch * pShift;
+      if (m.set.speed > 0) speed = m.set.speed * sMul;
+      if (m.set.vol !== undefined) vol = m.set.vol;
+      continue;                                  // 長さは持たない
+    }
+    volOf[mi] = withShift(vol);
+    // 上げ下げは、その場から後ろに効く。長さは持たない
+    if (m.tune) {
+      // 1 つでどれだけ動くかは、外から変えられる(`tuneStep`)。
+      // 半音刻みでは足りない声もあれば、動きすぎる声もある。
+      // 止まるところ(±12 半音)は動かさない — そこは声が別人になる境目
+      tune = Math.max(-TUNE_MAX, Math.min(TUNE_MAX, tune + m.tune * tuneStep));
+      continue;
+    }
+    if (m.pause) {
+      // 句読点で 0 に戻す。抑揚の位置を取り直すのと同じところで戻さないと、
+      // 上げたぶんだけが次の文へ持ち越されて、だんだん高くなる
+      if (m.brk) tune = 0;
+      out.push({ silent: true, frames: nfSec(m.pause), mora: mi, brk: !!m.brk });
+      continue;
+    }
+    const mark = mk[i - 1] || '.';
+    const g = liftOf[mi];
+    // `！` が付いた字。くくっていなければ最後の 1 字、
+    // くくってあればその中の全部(1 字ずつ言い切る形になる)
+    // `！？` も同じ形にする。驚いて問い返すのは「言い切る」と「尋ねる」を
+    // 足したものなので、`？` の上がりと `！` の張りが両方要る(2026-09-06)。
+    // くくったときは `！` だけ。くくった範囲まるごとを 1 字ずつ切ると、
+    // `？` の上がりが刻まれて聞こえなくなる
+    const bang = g ? (mark === '!' && g.mark === '!')
+      : (BANG_MARKS.has(mark) && tl[i - 1] === 1);
+    // くくった `！？` は、長さだけ `！` と同じにする。
+    // 1 字ずつ切って張ると、`？` の上がりが刻まれて聞こえなくなる
+    const longBody = bang || (g && g.mark === '!?');
+    // その 1 つ手前の字。そこを少し伸ばして、下がりきるところを見せる。
+    // 伸ばさないと、下がってすぐ言い切る字に移るので下がったことが分からない
+    const preBang = preLong[mi] || (!g && BANG_MARKS.has(mark) && tl[i - 1] === 2);
+    // 前の音符を `q` で切ったぶん。切ったぶんは黙る
+    if (postGap > 0) { out.push({ silent: true, frames: postGap, mora: mi }); postGap = 0; }
+    if (m.stop) out.push({ silent: true, frames: nf(6), mora: mi });   // 促音は無音でためる
+
+    // 歌の休みは、次の拍の前に置く。文の側の空白とは別のもので、
+    // 歌詞に書きようがない「歌だけの間」がここに入る
+    if (!m.tie) {
+      while (notes && notes[noteAt] && notes[noteAt].rest) {
+        out.push({ silent: true, frames: notes[noteAt++].frames, mora: mi });
+      }
+    }
+    // `( )` でくくったところは、1 つの音符を分け合う。
+    // 「チュー」のように字は 2 つでも 1 拍のところを、歌詞のまま書けるようにする。
+    // 長さは頭に多く残す(端数のぶん)。高さと音量は同じものを使う
+    const note = notes ? takeNote(m, mi) : null;
+    // `q` で切ったぶんの間。次の拍の前に置く
+    if (note && note.gap > 0) postGap = note.gap;
+    // 音量は重ねる。文の `@v` と、歌の `v` の両方が掛かる
+    if (note && note.vol !== undefined) volOf[mi] = withShift(vol * note.vol);
+    // `（ ）` の中は高さが止まる。後ろに記号があれば、そのぶん全体が上がる。
+    // 歌っているときは音符が高さを決めるので、どちらも掛からない
+    const f0 = note ? note.hz
+      // くくった中が上がるときは、`？` が語尾で行き着く高さをそのまま使う。
+      // 下がったところから上げると、くくった位置が後ろなほど低く着いて、
+      // `ソウナノ？` と `ソウ（ナノ）？` で上がりきる高さが揃わなかった
+      // (355Hz と 311Hz。2026-09-06)
+      : (g ? (g.up ? pitch * Math.pow(2, (g.up + tune) / 12)
+        : f0at(g.t, mark, 0, true))
+        : f0at(t, mark, tl[i - 1]));
+    // 記号で声の張りが変わる。言い切るところは張り、言いさしは落とす。
+    // `！` はここでは足さない — 張りは字の中の形で出す(`pushBang`)。
+    // `！？` は文まるごとも張る。驚きは 1 字では収まらない
+    const push = mark === '!' ? 0 : (PUSH[mark] || 0);
+    const P = Math.max(P_MIN, Math.min(P_MAX, Math.round(1 / (f0 * TICK))));
+    const cons = CONSONANTS2[m.c];
+    // 次に来る拍。撥音の口も、母音の終わりの曲がる先も、これで決まる
+    const next = (() => {
+      for (let k = mi + 1; k < moras.length; k++) {
+        const q = moras[k];
+        if (q.set || q.tune) continue;              // 長さを持たない指示は飛ばす
+        if (q.pause) return null;
+        return q;
+      }
+      return null;
+    })();
+    // 撥音は次の子音と同じ場所で作る(`nasalFor`)。他の母音はそのまま
+    const vowel = m.v === 'n'
+      ? nasalFor(next && next.c)
+      : (VOWELS2[m.v] || VOWELS2.a);
+    // 母音の終わりが向かう先(`COART`)。
+    // 間が入るところと、次が母音で始まるところでは動かない — 向かう先が無い。
+    //
+    // こすれる音(サ・シャ・ハ・ツ)には向けない。あちらの `hz` は
+    // 口がどこに在るかではなくノイズのどの辺りが鳴るかを書いたもので、
+    // 母音をそこへ寄せると別の母音へ滑っていくように聞こえる
+    const nextLocus = (() => {
+      if (!next) return null;
+      const c = CONSONANTS2[next.c];
+      if (!c || c.kind === 'noise' || next.c === 'ts') return null;
+      // 次が拗音なら、そちらの舌の位置へ向ける(無声はイ段、声で作る子音は渡りの位置)
+      if (next.pal && !PALATAL_ALREADY.has(next.c) && (c.kind === 'voiced' || c.voiced)) {
+        return A.palF3 === 'y' ? CONSONANTS2.y.hz : palVoiced(next.v);
+      }
+      return (c.hzBy && c.hzBy[next.pal ? 'i' : next.v]) || c.hz;
+    })();
+
+    // 拗音は、子音と母音のあいだに渡りが入る。もともと硬口蓋の子音には入れない
+    const pal = !!m.pal && !!cons && !PALATAL_ALREADY.has(m.c);
+    /** 声で作る子音(鼻音・ガ行など)。渡りと、開いたあとの声の戻りがここで変わる */
+    const voicedCons = !!cons && (cons.kind === 'voiced' || !!cons.voiced);
+    // 母音の大きさ(4 ビットの音量の段)。渡りと、有声の破裂のあとの声はここから引く
+    const vAmp = Math.min(15, (m.v === 'n' ? 11 : 14) + push);
+    // 渡りの位置。ヤ行の子音と同じところ。声で作る子音のあとは第 3 を母音のまま
+    // (`palVoiced` に理由を書いた)
+    const palHz = voicedCons && A.palF3 !== 'y' ? palVoiced(m.v) : CONSONANTS2.y.hz;
+
+    if (cons) {
+      // 後ろの母音で開始位置が変わる子音は、そちらの値を使う。
+      //
+      // 拗音のときはイ段の位置。「キャ」の k は「キ」の k と同じ場所で作る。
+      //
+      // 声で作る子音の拗音は、渡りの位置で作る(`palVoiced`)。
+      // `ギュ` をイ段の位置(2700 / 3100)で鳴らしたら「シュ」に聞こえ、
+      // 母音なりの位置(1300)に戻したら第 2 が 1300 → 渡り 2100 → ウ 1300 と
+      // 往復して、言葉から遠のいた(どちらも 2026-09-03)。
+      // 閉鎖から渡りまで第 2 を 2100 に置いたまま、開いてから ウ へ落とす。
+      //
+      // 鼻音だけは表の位置のまま。鼻に抜けているあいだの音は鼻の側の共鳴で、
+      // 舌の位置は音にほとんど乗らない。第 2 を 2100 へ持っていくと鼻音が
+      // 母音と同じ大きさまで明るくなった(-5dB → +0.5dB)。舌が天井に在ることは、
+      // 手前の母音の終わり(`COART`)と開いたあとの渡りが伝える
+      const hz = pal && voicedCons && !cons.nasal ? palHz
+        : (cons.hzBy && cons.hzBy[pal ? 'i' : m.v]) || cons.hz;
+      const noise = cons.kind !== 'voiced';
+      // 口を閉じてためる。破裂音はここが無いと破裂に聞こえない。
+      //
+      // 閉じているあいだに、舌はもう持ち場へ動いている。
+      // ここを止めていたころは、カ・タ・パ が 3 つとも同じに聞こえた。
+      // 破裂の本体は 1 フレームしかなく、1 フレームに動ける幅は 6 番地なので、
+      // 閉鎖で動かさないと、開始位置(`hz` / `hzBy`)へ届く前に鳴り終わる。
+      // 実機も無音のフレームで値を送り続けていたので、作りとしても近い
+      // 有声の破裂音は、閉じているあいだの第 1(200Hz)を一撃まで持ち越す。
+      // 口が開いて声が戻るとき、第 1 が低いところから母音へ上がっていくのが
+      // 有声の破裂音の決め手(無声なら、その動きは息の中で起きる)。
+      // 一撃のフレームで 300Hz へ動かしてしまうと、上がりきったところで声が戻り、
+      // 動きが聞こえない
+      const barHz = cons.voiced && cons.closure ? [BAR_HZ1, hz[1], hz[2]] : hz;
+      if (cons.closure && cons.voiced) {
+        // 閉じているあいだも声が出ている(`BAR_AMP`)。舌はもう持ち場へ動いている
+        out.push({
+          hz: barHz, param: toParams(barHz, shift), bpos: toBpos(false, false, A.barBand), P,
+          amp: A.barAmp, voiced: true, noise: false, frames: nf(cons.closure), mora: mi,
+        });
+      } else if (cons.closure) {
+        out.push({
+          silent: true, frames: nf(cons.closure), mora: mi,
+          glideTo: hz, glideNoise: noise,
+        });
+      }
+      out.push({
+        hz: barHz, param: toParams(barHz, shift),
+        bpos: toBpos(noise, cons.kind === 'burst' || cons.wide, cons.nasal && 'nasal'), P,
+        // 表で `amp` を持っているものはそちら(ハ行・サ行・鼻音。理由は表に書いた)
+        amp: cons.nasal ? (A.nasalAmp ?? cons.amp)
+          : cons.voiced && cons.kind === 'burst' ? A.voicedBurstAmp
+            : cons.amp ?? (cons.kind === 'noise' ? 9 : cons.kind === 'burst' ? 12 : 11),
+        // 有声の破裂の一撃は、ノイズだけ。声は閉鎖(`BAR_AMP`)と、
+        // 次のフレームからの戻りで聞こえる。一撃に声を乗せると、
+        // 拗音で高いところに置いたとき `シュ` に寄る(表の `g` に書いた)
+        voiced: cons.kind === 'voiced'
+          || (!!cons.voiced && (cons.kind === 'noise' || A.voicedBurstVoice)),
+        noise,
+        // 有声摩擦音(実機の FV)だけ、声を薄くする。
+        // ここを「ノイズを通す有声フレーム全部」に掛けていたので、
+        // 有声の破裂音(ガ・ダ・バ)の一撃まで 4 分の 1 になっていた。
+        // 「ギュウニュウ」の頭が聞こえなかったのはこれ(2026-09-03)。
+        // ザ・ジャ は声が飛び出さないよう薄いままにする
+        fv: cons.kind === 'noise' && !!cons.voiced,
+        // 拗音の鼻音だけ長い(`PAL_NASAL_FRAMES`)。最後の 1 フレームは下で別に置く
+        frames: nf(pal && cons.nasal ? A.palNasalFrames - (A.nasalTail ? 1 : 0) : cons.frames),
+        mora: mi,
+      });
+      if (pal && cons.nasal && A.nasalTail) {
+        // 鼻音の最後の 1 フレームで、舌は渡りの位置へ動きはじめる。
+        //
+        // 鼻音から渡りへ移るとき、第 2 が 1 フレームで上限(6 番地)ぶん飛び、
+        // 同時に幅が締まって大きさも跳ねる。開いた最初のフレームが +9dB 鳴り直していて、
+        // 「階段状に一気に変わるところがある。そこがなめらかになるといい」と言われた
+        // (2026-09-04)。フレームの粗さと上限は動かさないので、目標の置き方でならす —
+        // 動きの半分を、まだ鼻に抜けていて小さく幅の広いところで済ませる
+        const tail = [barHz[0], palHz[1], palHz[2]];
+        out.push({
+          hz: tail, param: toParams(tail, shift), bpos: toBpos(false, false, 'nasal'), P,
+          amp: A.nasalAmp ?? cons.amp ?? 11, voiced: true, noise: false, frames: 1, mora: mi,
+        });
+      }
+      // 破裂のあとから声が始まるまで。ここで口はもう母音へ動きはじめている。
+      //
+      // 無声の破裂音は、そのあいだ息が漏れている。動いている途中の口を
+      // 息が通るので、舌がどこから来たかがここで聞こえる(`ASPIRATE` に書いた)。
+      // 拗音なら、息も母音ではなく渡りのほうへ向かう
+      const after = pal ? palHz : vowel;
+      if (cons.gap && cons.voiced && A.voicedGap === 'silent') {
+        // 聴き比べ用。開いたあとを無音にしていたころの形(`ASSEMBLY`)
+        out.push({ silent: true, frames: nf(cons.gap), glideTo: after, mora: mi });
+      } else if (cons.gap && cons.voiced) {
+        // 有声の破裂音(ガ・ダ・バ)は、開いたら声がすぐ戻る。息は漏れない。
+        //
+        // ここを無音にしていたころ、`ギュ` は「低い声 → 一撃 → 10ms の無音 →
+        // 母音」で、濁点の決め手(第 1 が上がっていく音)が無音の中で終わっていた。
+        // 無声の破裂音で「場所を伝える音が無音の中で起きていた」のと同じ穴。
+        // 声のまま、閉じていた 200Hz から母音へ上がっていく(1 フレームに 6 番地なので
+        // `ガ` なら 40ms かけて上がる)。母音より 2 段下から入る —
+        // 開いた直後の声はまだ小さく、鼻音の「一気に開く」とはここで分かれる
+        out.push({
+          hz: after, param: toParams(after, shift), bpos: toBpos(false), P,
+          amp: Math.max(1, vAmp - 2), voiced: true, noise: false,
+          frames: nf(cons.gap), mora: mi,
+        });
+      } else if (cons.gap) {
+        // 1 フレームずつ、減らしながら置く。減らさないと摩擦音に聞こえる
+        for (let k = 0; k < nf(cons.gap); k++) {
+          out.push({
+            hz: after, param: toParams(after, shift), bpos: toBpos(true, true), P,
+            amp: Math.max(1, ASPIRATE - ASPIRATE_FADE * k),
+            voiced: false, noise: true, frames: 1, mora: mi,
+          });
+        }
+      }
+    }
+
+    // 無声化した母音は、口の形だけ作って息を通す。声は出さない
+    const dev = devoiced[mi];
+    const body = dev ? {
+      hz: vowel, param: toParams(vowel, shift), bpos: toBpos(true, true), P,
+      amp: DEVOICED, voiced: false, noise: true, mora: mi,
+    } : {
+      hz: vowel, param: toParams(vowel, shift), bpos: toBpos(false), P,
+      amp: vAmp,
+      voiced: true, noise: false,
+      mora: mi,
+    };
+    // 拗音の渡り。子音から母音へ開くまでの、舌が天井に寄っているところ。
+    // 声のまま鳴らす — ここが無いと `キャ` は `カ` と同じ音になる
+    const palFrames = pal ? nf(PAL) : 0;
+    if (palFrames) {
+      const glide = {
+        // 鼻音のあとは幅を広げる(`B_NASALIZED`)。母音の出だしが鼻にかかる
+        hz: palHz, param: toParams(palHz, shift),
+        bpos: toBpos(false, false, cons.nasal && A.nasalizedGlide && 'nasalized'), P,
+        // 母音より少し弱い。渡りであって、母音ではない
+        amp: Math.max(1, vAmp - 2),
+        voiced: true, noise: false, frames: palFrames, mora: mi,
+      };
+      if (cons.nasal && A.glideAfterNasal === 'ramp' && palFrames > 1) {
+        // 鼻音のあとは、渡りの途中で母音の大きさまで上がる(10 → 12 → 14)。
+        // 一度「鼻音は一気に開く」として渡りを頭から 14 にしたが、
+        // 「階段状に一気に変わるところがある」と言われた(2026-09-04)。
+        // 開く瞬間の跳ねをならすほうを採る
+        out.push({ ...glide, frames: 1 });
+        out.push({ ...glide, amp: vAmp, frames: palFrames - 1 });
+      } else if (cons.nasal && A.glideAfterNasal === 'full') {
+        out.push({ ...glide, amp: vAmp });        // 聴き比べ用。頭から母音の大きさ
+      } else out.push(glide);
+    }
+    // 歌うときの長さは音符が決める。子音と渡りに使ったぶんは差し引く
+    const vFrames = note
+      ? Math.max(1, note.frames - palFrames
+        - (cons ? (cons.closure || 0) + cons.frames + (cons.gap || 0) : 0))
+      // 拗音でも 1 拍は 1 拍。渡りのぶんだけ母音を詰める。
+      // 無声化した母音は短い
+      // `！` は語尾を短く切る。高さを動かさないぶん、
+      // 言い切りの勢いはここで出す(最後の 1 字だけ)
+      // `！` の字は少し長い。張って落とすぶんの間が要る
+      : Math.max(1, Math.round(nf((dev ? DEVOICED_FRAMES : 11) * (1 + m.hold * 0.9))
+        * (longBody ? BANG_LONG : preBang ? BANG_PRE_LONG : 1)) - palFrames);
+    // 終わりを次の子音へ向けるぶん(`COART`)。母音が短いときは削る。
+    // 歌うときと `〜` で揺らすときは、そちらが 1 フレームずつ組み立てるので掛けない
+    // 無声化した母音は声で鳴らないので、曲げても聞こえない
+    const coart = (note || m.wave || dev || !nextLocus)
+      ? 0 : Math.min(COART, Math.max(0, vFrames - 3));
+    // 声のまま次の子音へ寄っていく。閉じる手前で少し落ちるので 1 段下げる。
+    //
+    // 動かすのは第 2 と第 3 だけ。第 1 は母音のまま置く。
+    // 第 1 は「口がどれだけ開いているか」なので、閉じる手前の 300Hz まで
+    // 引くと母音そのものが別の母音に変わって聞こえる
+    // (「アタ」の ア が「何の母音だか分からない」と言われた。2026-09-03)。
+    // 場所を伝えているのは第 2 と第 3 のほうなので、そちらだけ向ける
+    const bend = () => out.push({
+      ...body, param: toParams([vowel[0], nextLocus[1], nextLocus[2]], shift),
+      amp: Math.max(1, body.amp - 1), frames: coart,
+    });
+    // `〜` で伸ばしたところは揺れる。歌っているときは音符が高さを決めるので掛けない
+    if (m.wave && !note) pushWave(out, body, vFrames, f0, frame);
+    // `！` の字は、頭を張って落とす。歌っているときは音符の形が先
+    else if (bang && !note) {
+      pushBang(out, body, vFrames - coart, nf(BANG_FRAMES));
+      if (coart) bend();
+    }
+    // 形を付ける。歌だけのものではない。しゃべりでも、1 音ずつ張って落とす。
+    // 渡りのぶんはそのあとに置く(形は母音の本体にだけ掛ける)
+    else if (style === 'natural') {
+      pushDecay(out, body, vFrames - coart);
+      if (coart) bend();
+    } else if (style !== 'flat') {
+      pushSung(out, body, vFrames - coart, f0, style);
+      if (coart) bend();
+    } else if (coart) {
+      out.push({ ...body, frames: vFrames - coart });
+      bend();
+    } else out.push({ ...body, frames: vFrames });
+  }
+  // 数が合わないときは言う。足りなければ残りは自動の抑揚で読み、
+  // 余ればその音符は鳴らない。黙って詰めると、どこからずれたか分からない
+  if (notes) {
+    const sung = notes.filter((n) => !n.rest).length;
+    // `( )` で分け合っている拍は、音符を取らないので数に入れない
+    const said = moras.filter((m) => !m.pause && !m.set && !m.tie).length;
+    if (sung !== said) {
+      console.warn(`[RetroTalk] 歌: 拍 ${said} 個に対して音符 ${sung} 個です`
+        + (sung < said ? '(足りないぶんは、ふつうに読みます)' : '(余ったぶんは鳴りません)'));
+    }
+  }
+  // 音量は最後に付け直す。目標を作るところが増えるたびに書き足すのを避ける
+  for (const t of out) t.vol = volOf[t.mora] ?? 1;
+  return out;
+}
+
+/**
+ * どの書き方で受け取るか。
+ *
+ * 既定は RetroTalk の書き方。`format: 'aquestalk'` を渡すと、
+ * ゆっくり(AquesTalk)風の記号列として読む(`aquestalk.js`)。
+ * 混ぜない — `'` も `_` も `/` もふつうの文に出てくる字なので、
+ * 同じ文字列に 2 つの読み方を持たせると、見てもどちらか分からなくなる
+ *
+ * @param {string} text 文
+ * @param {object} opts `format` を見る
+ * @returns {Array} 拍の並び
+ * @private
+ */
+function readText(text, opts) {
+  if (opts.format === 'aquestalk') return parseAqua(text);
+  if (opts.format === 'voicevox') return parseVoicevox(text, opts);
+  // アクセントの記号が書いてあれば、`format` を渡さなくても読む。
+  //
+  // 核(`'`)と句切り(`/` `+`)は、この仕組みが自分では出せない語のアクセントを
+  // 書く人が渡してくる記号で、辞書が要る部分がすでに解いてある。
+  // 書いてあるのに読まないほうが、書いた人には分かりにくい。
+  // 記号が 1 つも無ければ、ふつうの文としての読み方は変わらない
+  if (typeof text === 'string' && ACCENT_MARK.test(text)) {
+    return parseAqua(text, { strict: false });
+  }
+  return parseTalk(text);
+}
+
+/**
+ * アクセントの記号。1 つでもあれば、記号列として読む
+ * @private
+ */
+const ACCENT_MARK = /['\u2018\u2019\uff07/+]/;
+
+/**
+ * 目標の並びを、実際のフレームの並びへ。
+ * 1 フレームに動かせる幅が決まっているので、目標へは上限つきで寄せる。
+ * これが「繋ぎ目が切れているのではなく、決まった速さで滑っている」の実体。
+ * @private
+ */
+function runFrames(targets, opts) {
+  const slewF = opts.slewF ?? D.slewF;
+  const slewB = opts.slewB ?? D.slewB;
+  const slewP = opts.slewP ?? D.slewP;
+  const shift = opts.formantShift ?? D.formantShift;
+  const bShift = opts.bandShift ?? D.bandShift;
+  const frames = [];
+  const step = (cur, want, lim) => cur + Math.max(-lim, Math.min(lim, want - cur));
+
+  let param = [0, 0, 0, 0, 0];
+  let bpos = B_HOME.slice();
+  // 最初の高さは、最初の音に合わせる。
+  //
+  // 30(≒331Hz)から始めていたので、低い声や低い音符では頭が滑り降りていた。
+  // 1 フレームに動ける幅が決まっているぶん、C3 まで下りるのに 0.2 秒かかる。
+  // 「歌の最初の 1 字だけ変なアクセントが付く」のはこれ(2026-09-04)
+  let P = (targets.find((t) => !t.silent && t.P) || {}).P || 30;
+
+  for (let ti = 0; ti < targets.length; ti++) {
+    const t = targets[ti];
+    // 文の切れ目では、高さを跳ばす。
+    //
+    // 1 フレームに動ける幅が決まっているので、上げたところから次の文へは
+    // 滑り降りる。`（ ）！？` のあとがうわずったまま入っていた
+    // (2026-09-05)。息継ぎのところなので、跳んでも段には聞こえない
+    if (t.brk) {
+      for (let k = ti + 1; k < targets.length; k++) {
+        const nx = targets[k];
+        if (nx.silent || !nx.P) continue;
+        P = nx.P;
+        break;
+      }
+    }
+    // 無音でも口は動きつづける。破裂のあとの間に母音へ寄っていくのも、
+    // 口を閉じているあいだに舌が持ち場へ行くのも、これ
+    const want = t.silent ? (t.glideTo ? toParams(t.glideTo, shift) : param) : t.param;
+    const wantB = (t.silent ? (t.glideTo ? toBpos(!!t.glideNoise) : bpos) : t.bpos)
+      .map((v) => v + bShift);
+    const wantP = t.silent ? P : t.P;
+
+    for (let n = 0; n < t.frames; n++) {
+      param = param.map((v, k) => step(v, want[k], slewF));
+      bpos = bpos.map((v, k) =>
+        Math.max(0, Math.min(B_STEPS - 1, step(v, wantB[k], slewB))));
+      P = Math.max(P_MIN, Math.min(P_MAX, step(P, wantP, slewP)));
+      frames.push({
+        param: param.slice(), bpos: bpos.slice(), P,
+        // 絵に描くための Hz。番地のままでは読めない。並びは第 1〜3 フォルマント
+        formant: VOICED_STAGES.map((s) => idxToHz(param[s] + F_HOME[s])),
+        formantBw: VOICED_STAGES.map((s) => bposToBw(bpos[s])),
+        norm: chainNorm(param, bpos),
+        amp: t.silent ? 0 : t.amp,
+        voiced: !t.silent && t.voiced,
+        noise: !t.silent && t.noise,
+        fv: !t.silent && !!t.fv,
+        mora: t.mora,
+        vol: t.vol ?? 1,
+      });
+    }
+  }
+  return frames;
+}
+
+/**
+ * 波形にする手前の、フレームの並びを返します。
+ *
+ * 耳で聴かずに中身を測るために使います。音になったあとではフォルマントが
+ * 読みにくいので、その前の値(`param` は番地で、1 番地はおよそ 95 セント)を
+ * そのまま出します。鳴らすときと同じ道を通るので、ここで見えるものが
+ * そのまま音になります。
+ *
+ * ```js
+ * const frames = talkFrames('キャ');
+ * ```
+ *
+ * `mora` は `parseTalk()` が返した並びの添字で、「キャ」と「カ」の同じ拍を
+ * 突き合わせるのに使えます。
+ *
+ * @param {string} text カタカナ(ひらがなも可)
+ * @param {object} [opts] renderTalk と同じ
+ * @returns {Array<{param:number[], bpos:number[], P:number, amp:number,
+ *            voiced:boolean, noise:boolean, mora:number}>}
+ * @alias TalkAudio.talkFrames
+ * @static
+ */
+export function talkFrames(text, opts = {}) {
+  return runFrames(buildTargets(readText(text, opts), opts), opts);
+}
+
+/**
+ * 1 に近いところだけ寝かせる。`KNEE` までは素通しで、そこから上は 1 へ漸近する。
+ * 数サンプルの山のために、文まるごとを下げないための逃げ道
+ *
+ * @param {number} x
+ * @private
+ */
+function softClip(x) {
+  const KNEE = 0.9;
+  const a = Math.abs(x);
+  if (a <= KNEE) return x;
+  return Math.sign(x) * (KNEE + (1 - KNEE) * Math.tanh((a - KNEE) / (1 - KNEE)));
+}
+
+/**
+ * 鳴っているところの平均。
+ *
+ * 「鳴っている」の線を、どこに引くか —
+ * 0.02 と決め打ちにしていたので、そろえる前の波形が小さい文ほど、
+ * 線を越えるサンプルが減って、大きいところだけの平均になっていた。
+ * そのぶん掛ける倍率が小さく出て、文と設定で 3.8dB 違っていた。
+ *
+ * 山に対する割合にしたら、こんどは破裂音がひとつあると線が跳ね上がる。
+ * 山は数サンプルしかないのに、それで線を決めていたことになる。
+ *
+ * 間も含めた全体の平均から引く。全体の平均は波形の大きさに比例して動き、
+ * 数サンプルの山では動かない。どちらの揺れにも引きずられない
+ * @private
+ */
+function gatedRms(data, n) {
+  let all = 0;
+  for (let k = 0; k < n; k++) all += data[k] * data[k];
+  const gate = Math.sqrt(all / n) * 0.5;
+  let sum = 0, cnt = 0;
+  for (let k = 0; k < n; k++) {
+    if (Math.abs(data[k]) > gate) { sum += data[k] * data[k]; cnt++; }
+  }
+  return cnt ? Math.sqrt(sum / cnt) : 0;
+}
+
+/**
+ * 4 ビットの音量。おおむね指数関数的に効く
+ * @private
+ */
+const ampToGain = (a) => (a <= 0 ? 0 : Math.pow(10, (a - 15) * 0.125));
+
+/**
+ * 共鳴器 1 段の、周波数 f での大きさ
+ * @private
+ */
+function stageGain(hz, bw, f) {
+  const r = Math.exp(-Math.PI * bw / RATE);
+  const th = 2 * Math.PI * hz / RATE;
+  const b = 2 * r * Math.cos(th), c = -r * r, a = 1 - b - c;
+  const w = 2 * Math.PI * f / RATE;
+  const re = 1 - b * Math.cos(w) - c * Math.cos(2 * w);
+  const im = b * Math.sin(w) + c * Math.sin(2 * w);
+  return a / Math.sqrt(re * re + im * im);
+}
+
+/**
+ * このフレームで、直列 5 段を通したときの一番大きいところ。
+ *
+ * 実機のフィルタは 14 ビットの固定小数で、こんなに振れない。
+ * 直列だと山が重なったときにゲインが掛け算で積み上がり、
+ * 母音の 300 倍というフレームができてしまう。そうなると音量をそろえた瞬間、
+ * 他のところが全部ほぼ無音になる(実際そうなっていた)。
+ *
+ * ここで割っておくと、大きさを決めるのは AMP だけになる。
+ * 実機でもそうだったし、フレームの中の音色の釣り合いは変わらない。
+ * @private
+ */
+function chainNorm(param, bpos) {
+  const hz = param.map((v, s) => Math.min(idxToHz(v + F_HOME[s]), RATE * 0.45));
+  const bw = bpos.map(bposToBw);
+  let mx = 0;
+  for (const f of hz) {
+    let g = 1;
+    for (let s = 0; s < 5; s++) g *= stageGain(hz[s], bw[s], f);
+    if (g > mx) mx = g;
+  }
+  return mx > 0 ? mx : 1;
+}
+
+/**
+ * テキストから波形を生成します。再生はしません。
+ *
+ * 音として鳴らすときは `TalkAudio` が内部で呼びます。書き出したいときや、
+ * 自分で AudioBuffer を組み立てたいときに直接使います。
+ *
+ * ```js
+ * const { rate, data } = renderTalk('コンニチワ', { pitch: 200 });
+ * ```
+ *
+ * `tuneStep` から下は実機に無いパラメータです。実機は男女を子音データを
+ * 使い回してピッチだけで分けていたので、声色を変える手がありませんでした。
+ *
+ * @param {string} text カタカナ(ひらがなも可)
+ * @param {object} [opts]
+ * @param {number} [opts.pitch=280] 声の高さ Hz。
+ *   周期側で丸められるので高い声ほど音程が粗くなる。
+ *   実機の男声(`m`)は 1 オクターブ下なので 165 あたり
+ * @param {number} [opts.frame=0.010] 1 フレームの長さ(秒)。実機は 10ms か 20ms。
+ *   長くすると粗くなり、同時に遅くなる(実機がそうだった)
+ * @param {number} [opts.speed=1] しゃべる速さ
+ * @param {number} [opts.fall=4] 語尾へ下がる量(半音)
+ * @param {number} [opts.rise=1] 出だしで上がる量(半音。実機の自動抑揚)
+ * @param {boolean} [opts.interp=false] フレーム間を補間する(実機の S.I)。
+ *   切ると 10ms の階段が露骨に出る。ここがクセの本命
+ * @param {number} [opts.slewF=6] 1 フレームに動かせるフォルマントの幅。
+ *   実機の上限は 16 だが、そこまで速いと遷移が 10ms で終わり、
+ *   子音の場所が聞き取れなくなる
+ * @param {number} [opts.slewB=4] 同・帯域幅(実機の上限も 4)
+ * @param {number} [opts.slewP=2] 同・ピッチ(実機の上限は 4)
+ * @param {number} [opts.lag=0] しゃべり出すまでの間(秒)。
+ *   実機のあれは演出ではなく Z80 の計算時間だった
+ * @param {number} [opts.lagPerMora=0] 1 拍ごとに増える間(秒)
+ * @param {number} [opts.bits=0] 量子化ビット数(0 でしない)。
+ *   実機は 14 ビットなので、これは実機由来ではない
+ * @param {number} [opts.tuneStep=1] `＞` `＜` 1 つで動く量(半音)。
+ *   止まるところ(±12 半音)は変わらない
+ * @param {number} [opts.pitchShift=0] 文の中の `@p` ごと上げ下げする量(半音)。
+ *   写してきた文は高さが書き込まれているので、`pitch` では動かない
+ * @param {number} [opts.volume=10] `@v` を書かなかったときの音量(0〜15)
+ * @param {number} [opts.volumeShift=0] 文の中の `@v` ごと上げ下げする量(段)。
+ *   `@v` と同じ目盛り
+ * @param {number} [opts.speedShift=1] 文の中の `@s` ごと掛ける倍率
+ * @param {number} [opts.formantShift=0] 声道の長さ(番地)。
+ *   +3 で 1 割 8 分ほど高い声色。大人の男 -4 / 大人の女 +2 / 子ども +5 あたり
+ * @param {number} [opts.bandShift=0] 共鳴の鋭さ。+ でぼやけ、- で硬く締まる
+ * @param {number} [opts.breath=0] 息の混じり(0〜1)。かすれ声になる
+ * @param {number} [opts.jitter=0] 周期のゆらぎ(0〜1)。だみ声・年寄りの声
+ * @param {object} [opts.assembly] 音の組み替え方(`ASSEMBLY` を上書き)。
+ *   聴き比べ用で、良かった値は既定に写す。設定のまま残さない
+ * @param {string} [opts.format] 文の書き方。省くと RetroTalk の書き方。
+ *   'aquestalk' でゆっくり(AquesTalk)風の記号列として読む /
+ *   'voicevox' で VOICEVOX の `.vvproj` か `/audio_query` を読む
+ *   (`text` に JSON か、読み込んだそのままの object を渡す)
+ * @param {string} [opts.style='flat'] 一音一音の形。歌でもしゃべりでも効く。
+ *   'flat' 高さと長さだけ /
+ *   'natural' 一音ごとに少しだけ落ちる(しゃべり向け) /
+ *   'adsr' 一音ごとに立ち上がりと切りを付ける(歌向け) /
+ *   'vibrato' それに加えて、伸ばすと震えはじめる(歌向け)
+ * @param {number} [opts.seed=1] ノイズの種。同じ種なら同じ波形になる
+ * @param {boolean} [opts.gainNorm=true] 音量をそろえる。RMS で揃えるので、
+ *   破裂音のある文だけ小さくなることがない
+ * @param {number} [opts.level=0.15] 揃えたあとの RMS
+ * @returns {{rate:number, data:Float32Array, frames:number}}
+ * @alias TalkAudio.renderTalk
+ * @static
+ */
+export function renderTalk(text, opts = {}) {
+  const interp = opts.interp ?? D.interp;
+  const bits = opts.bits ?? D.bits;
+  const breath = opts.breath ?? D.breath;
+  const jitter = opts.jitter ?? D.jitter;
+  // 掛け合わせる音の高さ(Hz)。0 で切。20〜80 あたりで宇宙人、
+  // 100 を超えると声として聞き取れなくなる
+  const ring = Math.max(0, opts.ring ?? D.ring);
+  const rnd = makeRandom(opts.seed ?? D.seed);
+
+  const moras = readText(text, opts);
+  const targets = buildTargets(moras, opts);
+  const frames = runFrames(targets, opts);
+
+  const lead = Math.max(0, (opts.lag ?? D.lag) + (opts.lagPerMora ?? D.lagPerMora) * moras.length);
+  const perFrame = Math.round((opts.frame ?? D.frame) * RATE);
+  const leadN = Math.round(lead * RATE);
+  const n = leadN + frames.length * perFrame + Math.round(0.02 * RATE);
+  const data = new Float32Array(n);
+  // 音量は別に持って、そろえたあとで掛ける。
+  // 先に掛けると `gainNorm` が「小さい文」として持ち上げ直してしまう
+  const volAt = new Float32Array(n).fill(1);
+
+  // 5 段の共鳴器。実機は直列なので、前の段の出力が次の段に入る
+  const y1 = new Float64Array(5), y2 = new Float64Array(5);
+  let phase = 0;          // 次のインパルスまでの残り
+
+  let at = leadN;
+  for (let fi = 0; fi < frames.length; fi++) {
+    const f = frames[fi];
+    const prev = fi > 0 ? frames[fi - 1] : f;
+    for (let k = 0; k < perFrame; k++) {
+      // 補間が入っていればフレームの間を埋める。切ると値は階段のまま動く。
+      //
+      // 無音のフレームだけは、切ってあっても埋める。口を閉じた瞬間に
+      // 口の形が飛ぶと、溜まっていたぶんが新しい形で鳴り直して、
+      // 3 サンプルだけ声の 12 倍の音が出る(閉鎖に入るところで必ず起きる)。
+      // そこが山になると、音量をそろえるときに全体が引き戻されて、
+      // 文まるごとが半分の大きさになる(2026-09-03 に「音量的に聞き取りづらい」)。
+      //
+      // 音源が切り替わるところでも同じことが起きる(声 → こすれる音)。
+      // そこも埋める。
+      //
+      // クセは減らない。この声のたどたどしさは
+      // 声が出ているあいだにフォルマントが階段で動くところから出ていて、
+      // そこは埋めていない。埋めるのは、鳴っていないところと、
+      // 音源が入れ替わる 1 フレームだけ
+      const u = (interp || f.amp <= 0
+        || f.voiced !== prev.voiced || f.noise !== prev.noise) ? k / perFrame : 1;
+      const lerp = (a, b) => a + (b - a) * u;
+
+      // ---- 音源 ----
+      let src = 0;
+      // ノイズはずっと出っぱなし、インパルスは周期に 1 回。
+      // ならしたときの大きさを揃えるため、ノイズは薄めて渡す
+      if (f.noise) src = rnd() * NOISE_LEVEL;
+      if (f.voiced) {
+        let P = Math.max(1, Math.round(lerp(prev.P, f.P)));
+        // 息の混じり(実機に無い)。声帯が閉じきらない人の声。
+        // 有声のところへ薄くノイズを重ねる
+        if (breath > 0) src += rnd() * NOISE_LEVEL * breath;
+        // 周期のゆらぎ(実機に無い)。同じ高さでも、揺れると別人になる
+        if (jitter > 0) P = Math.max(1, Math.round(P * (1 + rnd() * jitter)));
+        // 有声摩擦音(実機の FV)は、こすれる音に声が薄く乗っているだけ。
+        // ここで声を弱めないと、ザ行・ジャ行だけ飛び出す
+        if (--phase <= 0) { src += f.fv ? FV_LEVEL : 1; phase = P; }
+      } else {
+        phase = 0;
+      }
+      src *= ampToGain(lerp(prev.amp, f.amp)) / lerp(prev.norm, f.norm);
+
+      // 閉じているあいだは、溜まったぶんを抜く(`SILENCE_DAMP`)。
+      // 閉じた最初のフレームから抜く。山が立つのはそこ —
+      // 母音のぶんが溜まったまま口の形だけ変わるので、鳴り直してしまう
+      if (f.amp <= 0) {
+        for (let s2 = 0; s2 < 5; s2++) { y1[s2] *= SILENCE_DAMP; y2[s2] *= SILENCE_DAMP; }
+      }
+
+      // ---- 共鳴器 5 段(直列) ----
+      let x = src;
+      for (let s = 0; s < 5; s++) {
+        const hz = Math.min(idxToHz(lerp(prev.param[s], f.param[s]) + F_HOME[s]),
+          RATE * 0.45);
+        const bw = bposToBw(lerp(prev.bpos[s], f.bpos[s]));
+        const r = Math.exp(-Math.PI * bw / RATE);
+        const b = 2 * r * Math.cos(2 * Math.PI * hz / RATE);
+        const c = -r * r;
+        const a = 1 - b - c;
+        const y = a * x + b * y1[s] + c * y2[s];
+        y2[s] = y1[s]; y1[s] = y;
+        x = y;
+      }
+      // リングモジュレーション。出来た声に、別の音をそのまま掛け合わせる。
+      // 実機に無いパラメータ。片方の周波数の和と差だけが残るので、
+      // 音程の感じが壊れて金属質になる — 怪獣や宇宙人の声の作り方そのもの
+      if (ring > 0) x *= Math.sin(2 * Math.PI * ring * (at / RATE));
+      if (at < n) { volAt[at] = f.vol ?? 1; data[at++] = x; }
+    }
+  }
+
+  // ---- 仕上げ ----
+  // そろえるのは山の高さではなく、鳴っているところの平均。
+  //
+  // 山でそろえていたが、それだと文によって聞こえる大きさが 10 倍も違った。
+  // 「ハッシャ！」のような破裂音が 1 つあると、そこが山になって
+  // 残り全部が下がる。人が聞いているのは平均のほうなので、そちらでそろえる。
+  //
+  // ただし山が 1 を越えると割れるので、越えるぶんだけ引き戻す。
+  if (opts.gainNorm ?? D.gainNorm) {
+    // 狙いは外から変えられる(`level`)。呼ぶ側で声の大きさをそろえたい
+    // ことがあるので、決め打ちにしない
+    // 細い声は、少し大きめに鳴らす。
+    //
+    // `formantShift` を上げると共鳴が高いほうへ寄って、同じ波形の大きさでも
+    // 痩せて小さく聞こえる。波形の大きさをそろえただけでは足りない。
+    // 既定より上げたぶんだけ、狙いを持ち上げる(1 段で 10%)。
+    //
+    // ただし上げ続けても頭打ちにする(6 段ぶんの 6 割まで)。
+    // 割合のまま伸ばすと、+8 のあたりで隣より 5dB も大きくなっていた。
+    // 下げたほうは太くなるだけなので触らない
+    const up = Math.max(0, (opts.formantShift ?? D.formantShift) - D.formantShift);
+    const AIM = (opts.level ?? D.level) * (1 + Math.min(0.6, up * 0.1));
+    const rms = gatedRms(data, n);
+    if (rms > 0) {
+      // 山を避けるために、文まるごとを下げない。
+      //
+      // 山が 1 を越えないところまで引き戻していたので、破裂音がひとつあると
+      // 文まるごとが 4dB 沈んでいた(「ワタシハ ガッコウヘ…」で 0.090)。
+      // 数えてみると越えるのは 2〜5 サンプルしかない。
+      // 3 万サンプルのうちの数個のために、全部を下げていたことになる。
+      //
+      // 狙いには乗せて、はみ出たところだけ寝かせる。
+      // 実機も 14 ビットで飽和していたので、頭が丸まるのは元からある顔でもある
+      for (let k = 0; k < n; k++) data[k] = softClip(data[k] * (AIM / rms));
+      // 寝かせたぶんだけ、狙いから下がる。
+      //
+      // 山の高い声(細い声ほど高い。`formantShift` +5 で平均の 14 倍)は、
+      // 平均のかなりを数十サンプルの山が占めている。そこを寝かせると
+      // 平均まで一緒に下がり、地の声は 1.8dB 小さいままになっていた。
+      //
+      // 寝かせたあと、もう一度測って足りないぶんを掛け直す。
+      // 山はもう寝ているので、上がるのは地の声のほうだけ。2 回で止まる
+      for (let pass = 0; pass < 2; pass++) {
+        const now = gatedRms(data, n);
+        if (!(now > 0)) break;
+        const fix = Math.min(1.5, AIM / now);
+        if (fix <= 1.01) break;
+        for (let k = 0; k < n; k++) data[k] = softClip(data[k] * fix);
+      }
+    }
+  }
+  // 音量を掛ける。`@v`(文)と `v`(歌)を掛け合わせたもの。
+  // そろえたあとに掛けるので、書いた数がそのまま出る。
+  // 呼ぶ側のパラメータ(`gain`)はここには入らない — あれは曲や SE と同じ、
+  // 鳴らすところで掛けるもので、波形の側の話ではない
+  for (let k = 0; k < n; k++) data[k] *= volAt[k];
+
+  if (bits > 0) {
+    const levels = Math.pow(2, bits) / 2;
+    for (let k = 0; k < n; k++) data[k] = Math.round(data[k] * levels) / levels;
+  }
+  return { rate: RATE, data, frames: frames.length };
+}