egatari 0.0.0-stage → 0.6.4

package/kit/core/check-result.mjs

@@ -0,0 +1,14 @@
+// kit/check.mjs の結果（終了コードと --json の出力）を読む側の共通の部品。Node にもブラウザにも依存しない
+// 検査が終わっていない（ブラウザが起動できない・落ちた）ときは、終了コード 2・JSON は status: "crashed"（指摘なし）。
+// 「指摘 0」「エラー 0」と取り違えないように、結果を読むところはこの関数を通す（無効な結果は例外）
+//   parseCheck(stdout, status?) → check --json の結果（{ok, lang, counts, results}）。status は終了コード（分かれば）
+//   checkFinished(result, status?) → bool：検査が終わった結果か
+export function checkFinished(result, status) {
+  return status !== 2 && !!result && result.status !== 'crashed' && Array.isArray(result.results);
+}
+export function parseCheck(stdout, status) {
+  let j = null;
+  try { j = JSON.parse(String(stdout)); } catch { /* 下で例外 */ }
+  if (!checkFinished(j, status)) throw new Error(`check did not finish (exit ${status ?? '?'}${j && j.status ? `, status ${j.status}` : ''}): the result is invalid, not "0 errors"`);
+  return j;
+}

package/kit/core/code-scan.mjs

@@ -0,0 +1,202 @@
+// 「このデッキはコードを動かせるか」を、申告（持ち運べる 1 ファイルの index.profile）ではなく中身から決める（format spec §6）。
+// 編集アプリが、プレビューと発表者ビューでデッキのコードを動かす前に知らせて確かめるかどうかに使い、持ち運べる 1 ファイルの書き出しも
+// profile をこれで決める。何も実行しない（parse5 で文字列として読むだけ）。Node にもブラウザにも依存しない
+//
+//   codeReasons(files, {entry})  files：Map か {相対パス: Uint8Array | 文字列}。返すもの：理由の文字列の配列（空ならコードなし）
+//   markupReasons(text, where)   1 つの文書（HTML・SVG・XML、組み立てが取り込みうるテキスト）の中の理由
+//   documentReasons(html, trusted) 組んだ文書（表示するバイトそのもの）の中の理由。組み立てとエディタはこれで決める（build の stats.codeReasons）。
+//                                codeReasons は原稿のフォルダ・取り出した原稿の全体を見る補い（同じバイトから、少しでも疑わしいものを足す）
+//
+// コードと見なすもの（どれか 1 つでもあれば、そのデッキのコードが動く）：
+//   - JavaScript のファイル（.js・.mjs・.cjs。原稿のフォルダの部品 components/<名前>/index.js も）
+//   （原稿のほかの .html は、原稿がその名前を書いているときだけ。書き出した教材などを数えない）
+//   - データの type を持たない <script>（type なし・JavaScript の MIME・module・importmap、知らない type も含む）。
+//     ただし src のない、中身が空か空白だけの <script> はコードではない（format spec §6。何も動かない。コメントだけのものはコード）
+//   - on で始まる属性（onerror・onload などのイベントの処理）
+//   - javascript: / vbscript: の URL を値に持つ属性（SVG の <animate values="…; javascript:…"> も）
+//   - srcdoc 属性、文書を入れる要素（iframe・frame・frameset・object・embed・portal）
+//   - 部品庫の部品で式を new Function で作るもの（m-sweep の f・m-curves の系列の f。部品庫 v1.0.1 まで。v1.0.2 からは算術の構文解析器で計算し、
+//     コードとしては動かさないが、古い版で組む文書があるので判定は続ける）の、決まった数式の形に入らない式
+// 中身を読めないもの（大きすぎるテキスト・解けない {{JSON:…}}）も、確かめられないのでコードと見なす（少しでも疑わしければ聞く側に倒す）
+import { parse } from 'parse5';
+import { FORMAT } from './format.mjs';
+
+const BINARY = new Set(['png', 'jpg', 'jpeg', 'gif', 'webp', 'avif', 'ico', 'bmp', 'tif', 'tiff', 'woff', 'woff2', 'ttf', 'otf', 'eot',
+  'wav', 'mp3', 'm4a', 'aac', 'ogg', 'oga', 'opus', 'flac', 'mp4', 'm4v', 'webm', 'mov', 'pdf', 'zip', 'gz']);
+const JS_EXT = new Set(['js', 'mjs', 'cjs']);
+// 中身を読まないもの：口述原稿・コメント・音声の記録・秒数（組み立ては JSON の中に < を逃がして入れるだけで、文書には入れない）
+const NOT_MARKUP = new Set(['comments.json', 'audio/manifest.json', 'timeline.json', 'narration.md', 'voice.json']);
+// データの type（実行しない）
+const DATA_TYPES = new Set(['application/json', 'application/ld+json', 'application/octet-stream', 'text/x-tex-macros', 'text/plain', FORMAT.MIME]);
+const EMBED = new Set(['iframe', 'frame', 'frameset', 'object', 'embed', 'portal']);
+const MAX_SCAN = 16 * 1024 * 1024;
+// 解析の規則：表示するブラウザと同じ、スクリプトを動かすときのもの（format spec §6。<noscript> の中は文字で、最初の </noscript> で閉じる。
+// スクリプトを止めた規則で読むと、<noscript><p title="</noscript><script>…"> が属性の文字に見えるが、ブラウザではスクリプトが動く）。
+// parse5 は解析するだけで何も実行しない。組み立ての境目（kit/core/build-core.mjs）と持ち運べる形式の読み取り（kit/core/bounded-html.mjs）も同じ規則
+export const SCRIPTING = true;
+const dec = new TextDecoder();
+const extOf = (rel) => { const m = /\.([A-Za-z0-9]+)$/.exec(rel); return m ? m[1].toLowerCase() : ''; };
+
+// ---------------------------------------------------------------- 部品庫の部品の式（m-sweep・m-curves）
+const MATH_NAMES = new Set(Object.getOwnPropertyNames(Math));
+const EXPR = {
+  'm-sweep': { attrs: ['f'], vars: ['u', 'c'], withMath: false },
+  'm-curves': { json: 'f', vars: ['x', 'N'], withMath: true },
+};
+// 決まった数式の形：数・許した名前（変数・Math・Math.<名前>、with(Math) の部品では Math の名前そのまま）・演算子・括弧・コンマ・?:。
+// 文字列・[ ]・{ }・代入・; ・\ は通さない（[ ] と文字列がなければ、許した名前の外の値に届かない）
+export function safeExpression(expr, { vars = [], withMath = false } = {}) {
+  if (typeof expr !== 'string' || expr.length > 2000) return false;
+  const allowed = new Set([...vars, 'Math', ...(withMath ? MATH_NAMES : [])]);
+  const re = /\s+|(\d+\.?\d*(?:[eE][+-]?\d+)?|\.\d+(?:[eE][+-]?\d+)?)|([A-Za-z_$][\w$]*)|(\*\*|===|!==|==|!=|<=|>=|&&|\|\||[-+*/%<>!?:,().&|^~])/y;
+  let i = 0, prev = null, prevIdent = null;
+  while (i < expr.length) {
+    re.lastIndex = i;
+    const m = re.exec(expr);
+    if (!m || m.index !== i) return false;
+    i = re.lastIndex;
+    if (m[0].trim() === '') continue;
+    if (m[2]) {
+      const id = m[2];
+      if (prev === '.') { if (prevIdent !== 'Math' || !MATH_NAMES.has(id)) return false; }
+      else if (!allowed.has(id)) return false;
+      prevIdent = id; prev = 'id';
+      continue;
+    }
+    if (m[3] === '.' && prev !== 'id') return false;
+    prev = m[3] || 'num'; if (m[3] !== '.') prevIdent = null;
+  }
+  return true;
+}
+
+// 部品の子のデータの <script>（kit/deck.js の MotionElement の data と同じ選び方：type の前後の空白を除き、大文字小文字を区別せずに
+// application/json。id によらない）。実行系と判定はこの規則を共有する（変えるときは両方を同時に。試験が両方を比べる）
+export function isDataBlock(type) { return String(type ?? '').trim().toLowerCase() === 'application/json'; }
+// 部品の系列（配列か 1 つのもの）の式がどれも決まった数式の形か。実行系（m-curves）は配列の各項目の f を読む。
+// 項目が物でないもの・f が文字列でないものも通さない（文字列にして式にされうる）
+function formulasOk(data, ex) {
+  for (const item of Array.isArray(data) ? data : [data]) {
+    if (item === null || typeof item !== 'object') continue;
+    if (Object.prototype.hasOwnProperty.call(item, ex.json) && !safeExpression(item[ex.json], ex)) return false;
+  }
+  return true;
+}
+
+// ---------------------------------------------------------------- 文書の中
+const attr = (n, name) => { const a = (n.attrs || []).find((x) => x.name === name); return a ? a.value : null; };
+const textOf = (n) => (n.childNodes || []).filter((c) => c.nodeName === '#text').map((c) => c.value).join('');
+// src のない、中身が空か空白（空白・タブ・改行・改ページ・垂直タブ）だけの <script>（format spec §6：コードではない）。
+// 空白はわざと狭く取る（ほかの字が 1 つでもあればコードとする。コメント・; だけのものもコード）
+export function emptyScript(n) { return attr(n, 'src') === null && /^[ \t\n\r\f\v]*$/.test(textOf(n)); }
+const JS_URL = /(^|[\s;,])(javascript|vbscript|livescript):/;
+// resolveJson(name)：{{JSON:name}} の中身（文字列か null）。m-curves の子の JSON が取り込みのとき
+export function markupReasons(text, where = '', resolveJson = null) {
+  return scanTree(parse(String(text), { scriptingEnabled: SCRIPTING }), where, resolveJson, null);
+}
+
+// 組んだ文書（表示するのと同じバイト）の中の理由（format spec §6：判定は取り込み・前処理の後の原稿全体に対し、表示するのと同じバイトで行う）。
+// trusted：組み立て・エディタが自分で入れた部分 [{start, end, tags}]（文字の位置。tags はその範囲にあるはずの要素の名前の並び）。
+// 範囲の中にすっかり収まる要素だけを飛ばす。tags のある範囲は、範囲から作られた要素の並びが tags と違えば（信頼しないバイトに飲み込まれた・抜け出された）、
+// その範囲は信頼せずに読み、そのことも理由にする（少しでも疑わしければコードとする）
+export function documentReasons(html, trusted = []) {
+  const text = String(html);
+  const ranges = (trusted || []).map((r) => ({ ...r, ok: true }));
+  const inside = (loc) => loc && typeof loc.startOffset === 'number' && typeof loc.endOffset === 'number' ? ranges.find((r) => r.ok && loc.startOffset >= r.start && loc.endOffset <= r.end) || null : null;
+  const doc = parse(text, { scriptingEnabled: SCRIPTING, sourceCodeLocationInfo: true });
+  // 範囲ごとに、すっかり収まる一番外側の要素の名前を並べて、tags と比べる
+  const seen = new Map(ranges.map((r) => [r, []]));
+  const look = (n) => {
+    if (n.tagName) {
+      const r = inside(n.sourceCodeLocation);
+      if (r) { seen.get(r).push(n.tagName); return; }
+      const l = n.sourceCodeLocation;
+      // 範囲の中で始まって外で終わる要素（範囲を飲み込んだ・範囲から抜け出した）
+      if (l && typeof l.startOffset === 'number') for (const q of ranges) if (q.tags && l.startOffset >= q.start && l.startOffset < q.end && !(l.endOffset <= q.end)) q.spill = true;
+    }
+    for (const c of n.childNodes || []) look(c);
+    if (n.content) look(n.content);
+  };
+  look(doc);
+  const extra = [];
+  for (const r of ranges) {
+    if (r.spill || (r.tags && seen.get(r).join(',') !== r.tags.join(','))) { r.ok = false; extra.push(`trusted part ${r.name || r.start} was not parsed as inserted`); }
+  }
+  return [...extra, ...scanTree(doc, '', null, (n) => !!inside(n.sourceCodeLocation))];
+}
+
+// skip(n)：その要素（と中身）を読まない（信頼する部分）
+function scanTree(doc, where, resolveJson, skip) {
+  const out = new Set();
+  const visit = (n) => {
+    if (n.tagName && skip && skip(n)) return;
+    if (n.tagName) {
+      const tag = n.tagName.toLowerCase();
+      if (tag === 'script') {
+        const t = (attr(n, 'type') || '').trim().toLowerCase().split(';')[0].trim();
+        if (!DATA_TYPES.has(t) && !emptyScript(n)) out.add(`<script${t ? ` type="${t}"` : ''}>${where}`);
+      }
+      if (EMBED.has(tag)) out.add(`<${tag}>${where}`);
+      if (tag === 'meta' && (attr(n, 'http-equiv') || '').trim().toLowerCase() === 'refresh') out.add(`<meta http-equiv="refresh">${where}`);
+      for (const a of n.attrs || []) {
+        const name = a.name.toLowerCase();
+        if (/^on/.test(name)) out.add(`${name}=${where}`);
+        if (name === 'srcdoc') out.add(`srcdoc=${where}`);
+        if (JS_URL.test(String(a.value).toLowerCase().replace(/[\u0000-\u001f]/g, ''))) out.add(`${name}="javascript:…"${where}`);
+      }
+      const ex = EXPR[tag];
+      if (ex) {
+        for (const k of ex.attrs || []) { const v = attr(n, k); if (v !== null && !safeExpression(v, ex)) out.add(`<${tag} ${k}="…"> (not a plain formula)${where}`); }
+        if (ex.json) {
+          // 実行系（kit/deck.js の MotionElement の data）が選ぶのは、直接の子のうち isDataBlock に当たる <script> がちょうど 1 つのとき。
+          // 2 つ以上なら実行系は使わないが、どれが選ばれるかを判定と実行系で食い違わせないために、判定できないもの（コード）とする。
+          // 直接の子に限らず、部品の中の isDataBlock に当たる <script> はどれも式を確かめる（木の作り方の違いで選ばれるものが変わっても通らないように）
+          const direct = (n.childNodes || []).filter((c) => c.tagName === 'script' && isDataBlock(attr(c, 'type')));
+          if (direct.length > 1) out.add(`<${tag}> has ${direct.length} data blocks (ambiguous)${where}`);
+          const all = [];
+          const collect = (x) => { for (const c of x.childNodes || []) { if (c.tagName === 'script' && isDataBlock(attr(c, 'type'))) all.push(c); collect(c); } if (x.content) collect(x.content); };
+          collect(n);
+          if (all.length > direct.length) out.add(`<${tag}> has a nested data block (ambiguous)${where}`);
+          for (const s of all) {
+            let raw = textOf(s);
+            const inc = /^\s*\{\{JSON:([^}]+?)\}\}\s*$/.exec(raw);
+            if (inc) raw = resolveJson ? resolveJson(inc[1].trim()) : null;
+            let data = null;
+            try { data = raw === null ? undefined : JSON.parse(raw); } catch { data = undefined; }
+            if (data === undefined) out.add(`<${tag}> data (cannot check the formulas)${where}`);
+            else if (!formulasOk(data, ex)) out.add(`<${tag}> ${ex.json}: (not a plain formula)${where}`);
+          }
+        }
+      }
+    }
+    for (const c of n.childNodes || []) visit(c);
+    if (n.content) visit(n.content);
+  };
+  visit(doc);
+  return [...out];
+}
+
+// ---------------------------------------------------------------- 原稿のフォルダ・取り出した原稿の全体
+export function codeReasons(files, { entry = 'deck.html' } = {}) {
+  const map = files instanceof Map ? files : new Map(Object.entries(files || {}));
+  const text = (v) => (typeof v === 'string' ? v : dec.decode(v));
+  const out = [];
+  const resolveJson = (name) => {
+    for (const p of ['data/' + name, name]) if (map.has(p)) { const v = map.get(p); return (typeof v === 'string' ? v.length : v.length) > MAX_SCAN ? null : text(v); }
+    return null;
+  };
+  let et = null;
+  const entryText = () => (et ??= map.has(entry) ? text(map.get(entry)) : '');
+  for (const [rel, v] of [...map].sort(([a], [b]) => (a === entry ? -1 : b === entry ? 1 : a < b ? -1 : a > b ? 1 : 0))) {
+    if (rel.split('/').some((s) => s.startsWith('.'))) continue;            // 控え（.cache）など
+    if (rel.startsWith(FORMAT.ATTACH_DIR + '/')) continue;                   // 添付（§3.8）：組み立てに使わず、再生器はダウンロードだけ（実行しない）
+    const ext = extOf(rel);
+    if (JS_EXT.has(ext)) { out.push(`script file ${rel}`); continue; }
+    if (BINARY.has(ext) || (NOT_MARKUP.has(rel) && rel !== entry)) continue;
+    // 原稿のほかの HTML（書き出した教材・持ち運べる 1 ファイルなど）は、原稿がその名前を書いているとき（取り込みうるとき）だけ読む
+    if ((ext === 'html' || ext === 'htm') && rel !== entry && !entryText().includes(rel.split('/').pop())) continue;
+    const size = typeof v === 'string' ? v.length : v.length;
+    if (size > MAX_SCAN) { out.push(`${rel} is too large to check`); continue; }
+    out.push(...markupReasons(text(v), rel === entry ? '' : ` in ${rel}`, resolveJson));
+  }
+  return out;
+}

package/kit/core/colab-core.mjs

@@ -0,0 +1,197 @@
+// Colab 往復 TTS（WebGPU の無い PC のため。docs/editor.md「Make the audio in Colab」）：エディタが書き出す tts-job.json と、
+// 公式ノートブック（colab/egatari-tts.ipynb）が返す zip（audio/*.wav と records.json）の定義・検証・突き合わせ。node: も fs も使わない
+//
+// tts-job.json と records.json はこの製品の中の取り決め（仕様物ではない）。records.json の各段階の記録の形は format spec §5.2 の音声の記録
+// （kind・cues・inputHash・recipe）と同じ。取り込みは、今の口述原稿から inputHash を計算し直して照合する（ノートブックには検証を任せない。§5.3）
+//
+//   buildJob({segs, docId, lang, voices, yomi, version, keys?})   → tts-job.json の中身（keys：書き出す段階の key。なければ全部）
+//   parseRecords(text)                                           → {records: Map<key, 記録>, docId, generator, problems: [{key?, why}]}
+//   planImport({zip: {files}, segs, docId, yomi})                → {reject?, applied: [], marked: [], skipped: [], warnings: []}（読むだけ。書かない）
+//   decodeStepAudio(bytes, rec)                                  → {pcm（44.1 kHz・モノラル）, sr, dur, cues}（WAV を検証して復号）
+//   readColabZip(bytes)                                          → readZip を、この取り込みの上限で
+import { inputHash } from './portable.mjs';
+import { applyYomi } from './yomi.mjs';
+import { TEXT_NORMALIZE } from './tts-normalize.mjs';
+import { PROCESSING, AUDIO_LIMITS, SR, decodeWav, toMono, resample } from './audio-core.mjs';
+import { readZip, ZipError } from './zip-read.mjs';
+
+// 確かめた範囲の記し（ノートブックの最初のセル・それを案内する docs・エディタの「Colab で音声を作る」の説明に出す）。1 か所だけに書く。
+// 確かめる範囲が変わったら（Kokoro・CPU を通したなど）ここの文を直し、`npm run gen` と docs の <!-- colab-verified --> の行を揃える
+// （tools/test-colab.mjs が、記しのある所が揃っているかを確かめる）。固定した版（tools/make-colab-notebook.mjs の COLAB_PINS）での GPU は 2026-10-24 に確認した。
+export const COLAB_VERIFIED = Object.freeze({
+  ja: '確認済み：2026-10-23、CPU（講習で、Irodori）。2026-10-24、T4 で固定した版（cuda13 の組）：Irodori 23 ステップを 42 秒、Kokoro 59 ステップを 30 秒。2026-10-25、持ち主の手での計測（10 ステップ・話者 1 人。日本語 209 字・英語 518 字）：T4 の日本語（Irodori）は読み込み 34 秒・合成 19 秒、T4 の英語（Kokoro）は読み込み 4 秒・合成 4 秒、CPU の英語は読み込み 7 秒・合成 33 秒（1 ステップ約 3 秒で十分使える）、CPU の日本語は読み込み 1 分・1 ステップ約 60 秒（steps=40）。1 ステップだけの手での計測は steps=40 で 90 秒、steps=16 で 52.5 秒（この版より前の、fp16 の重みで参照音声を毎回符号化していたとき）',
+  en: "Verified: 2026-10-23, CPU (at a workshop, Irodori). 2026-10-24, T4 with the cuda13 pin set: Irodori 23 steps in 42 s, Kokoro 59 steps in 30 s. 2026-10-25, the owner's hand check (10 steps, one speaker; 209 Japanese / 518 English characters): T4 Japanese (Irodori) load 34 s, synthesis 19 s; T4 English (Kokoro) load 4 s, synthesis 4 s; CPU English load 7 s, synthesis 33 s (about 3 s per step, fine); CPU Japanese load 1 min, about 60 s per step at steps=40; a single step timed by hand took 90 s at steps=40 and 52.5 s at steps=16 (before this version, with fp16 weights and the reference voice encoded on every call).",
+});
+// Colab での手順（音声の板の「クラウドで作る」の C2 と、ノートブックの最初のセルに同じ文を出す。1 か所だけに書く）。
+// handoff/audio-flow-2026-10-25.md §4 の cloud.c2Steps・§7。時間の目安は T4 のものだけ（CPU の数は実測してから足す）
+export const COLAB_STEPS = Object.freeze({
+  ja: Object.freeze([
+    '右上の「接続」を押す（T4 GPU につなぎます）。つながらないと知らせが出たら、メニューの「ランタイム」→「ランタイムのタイプを変更」で「CPU」を選んでから、もう一度「接続」（CPU でも作れますが、時間がかかります）',
+    '「ランタイム」→「すべてのセルを実行」',
+    'ファイルを選ぶ画面が出たら、書き出したファイルを選ぶ',
+    '終わると音声の ZIP ファイルがダウンロードされます',
+  ]),
+  en: Object.freeze([
+    'Press “Connect” at the top right (it connects to a T4 GPU). If it says it cannot connect, choose Runtime → Change runtime type → “CPU” and press “Connect” again (CPU works too, only slower)',
+    'Runtime → Run all',
+    'When asked to choose a file, choose the file you exported',
+    'When it finishes, a ZIP file of the audio is downloaded',
+  ]),
+});
+export const COLAB_TIME = Object.freeze({ ja: 'T4 で 10 ステップ 20 秒ほど。Google のアカウントが要ります', en: 'About 20 s for 10 steps on a T4. You need a Google account' });
+export const COLAB_NOTE_MARK = 'colab-verified';   // docs では <!-- colab-verified --> を付けた行にする
+
+export const JOB = Object.freeze({ tag: 'tts-job', recordsTag: 'tts-records', v: 1 });
+export const COLAB = Object.freeze({
+  repo: 'egatari/egatari-studio', notebook: 'colab/egatari-tts.ipynb',
+  ref: 'v0.6.4',   // バッジの URL は版のタグに固定する（リリースの手順で替える。RELEASING.md）
+  pause: 0.35,
+  models: Object.freeze({ irodori: 'irodori-tts-500m-v3', kokoro: 'kokoro-82m-v1.0' }),
+  // 後処理の版（records の recipe.processing は PROCESSING に '+colab<ノートブックの版>' を付けたもの）：ノートブック（colab/egatari_tts.py）の後処理は audio-core.mjs と同じ数。数を変えたら名前も変える
+  notebookVersion: 1,
+});
+export const colabUrl = (ref = COLAB.ref) => `https://colab.research.google.com/github/${COLAB.repo}/blob/${ref}/${COLAB.notebook}`;
+
+// 取り込みの上限（割り当てる前に課す。zip はダウンロード物）
+export const COLAB_LIMITS = Object.freeze({ zipBytes: 512 * 1048576, memberBytes: AUDIO_LIMITS.fileBytes, recordsBytes: 4 * 1048576, steps: 400, totalBytes: 512 * 1048576 });
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const own = (o, k) => o != null && Object.prototype.hasOwnProperty.call(o, k);
+const round3 = (v) => Math.round(v * 1000) / 1000;
+const HEX64 = /^[0-9a-f]{64}$/;
+const KEY = /^[^\s:]{1,120}:[^\s:]{1,120}$/;
+const VOICE = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const FILE = /^audio\/[A-Za-z0-9][A-Za-z0-9._-]{0,120}\.wav$/;
+// recipe.runtime：ノートブックが書く「<版の組>/<実際の実行プロバイダ>」（cuda12/cuda・cuda13/cpu など。colab/egatari_tts.py の runtime_label）。
+// どの環境で作った音かの記録で、inputHash には入らない（版の組や GPU/CPU で音は少し違う）。形の合わないものは落とす（取り込みは止めない）
+const RUNTIME = /^[A-Za-z0-9._-]{1,32}\/[A-Za-z0-9._?-]{1,32}$/;
+// recipe.diffusionSteps（Irodori の diffusion の steps。GPU は 40、CPU は少ない。colab/egatari_tts.py の IRODORI_STEPS・IRODORI_CPU_STEPS）と
+// recipe.precision（重みの精度。GPU は fp16、CPU は fp32）：runtime と同じく、どう作ったかの記録だけで inputHash には入らない（音は少し違うが、
+// 台本は同じなので段階は古くならない）。形の合わないものは落とす
+const STEPS_MAX = 200;
+const PRECISIONS = Object.freeze(['fp16', 'fp32']);
+
+// {cue}/{mark} で区切った部分の数から、cue の数（ターンの中の区切りだけ。ターンの間には cue を置かない。joinParts と同じ）
+export const expectedCues = (seg) => seg.turns.reduce((n, t) => n + Math.max(0, t.ttsParts.length - 1), 0);
+export const engineOfLang = (lang) => (/^ja\b/i.test(lang || '') ? 'irodori' : 'kokoro');
+
+// ---------------------------------------------------------------- tts-job.json
+const cleanTitle = (t) => (typeof t === 'string' ? t.replace(/\s+/g, ' ').trim().slice(0, 120) : '');
+export async function buildJob({ segs, docId = null, title = null, lang, voices, yomi = null, version = '0', keys = null }) {
+  const engine = engineOfLang(lang), ja = engine === 'irodori';
+  const terms = (yomi && yomi.terms) || [];
+  const want = keys ? new Set(keys) : null;
+  const steps = [];
+  for (const seg of segs) {
+    const key = `${seg.slideKey}:${seg.stepKey}`;
+    if (want && !want.has(key)) continue;
+    steps.push({
+      key, lang, inputHash: await inputHash(seg),
+      turns: seg.turns.map((t) => ({
+        role: t.role === 'novice' ? 'novice' : 'expert',
+        voice: (voices && voices[t.role === 'novice' ? 'novice' : 'expert']) || (t.role === 'novice' ? 'alice' : 'bob'),
+        segments: t.ttsParts.map((p) => (ja ? applyYomi(p, terms).text : p)),   // 読みを適用した文（辞書の版の食い違いを避ける）
+      })),
+    });
+  }
+  return {
+    egatari: JOB.tag, v: JOB.v, docId,
+    ...(cleanTitle(title) ? { title: cleanTitle(title) } : {}),   // 取り込みの断り書きに教材の題を出すためだけ（inputHash や検証には使わない）
+    generator: { name: 'egatari-studio', version: String(version) },
+    recipe: { engine, model: COLAB.models[engine], seed: 0, dictionary: ja && yomi ? yomi.sha256 : null, processing: PROCESSING, textNormalize: TEXT_NORMALIZE },   // 文は前処理しない（ノートブックが合成の直前に textNormalize の規則をかける）
+    steps,
+  };
+}
+
+// ---------------------------------------------------------------- records.json
+export function parseRecords(text) {
+  const problems = [], records = new Map();
+  let j;
+  try { j = JSON.parse(text); } catch { return { records, docId: null, generator: null, problems: [{ why: 'records.json is not JSON' }], fatal: true }; }
+  if (!isObj(j) || j.egatari !== JOB.recordsTag || j.v !== JOB.v || !isObj(j.steps)) return { records, docId: null, generator: null, problems: [{ why: 'records.json is not a tts-records v1 file' }], fatal: true };
+  const docId = typeof j.docId === 'string' ? j.docId : null;
+  const title = cleanTitle(j.title) || null;
+  const generator = isObj(j.generator) && typeof j.generator.name === 'string' ? { name: j.generator.name.slice(0, 80), version: String(j.generator.version ?? '').slice(0, 40) } : null;
+  const keys = Object.keys(j.steps);
+  if (keys.length > COLAB_LIMITS.steps) return { records, docId, title, generator, problems: [{ why: `too many steps (${keys.length}; at most ${COLAB_LIMITS.steps})` }], fatal: true };
+  for (const key of keys) {
+    const r = j.steps[key];
+    const no = (why) => problems.push({ key, why });
+    if (!KEY.test(key)) { no('bad step key'); continue; }
+    if (!isObj(r)) { no('not an object'); continue; }
+    if (r.kind !== 'tts') { no('kind is not tts'); continue; }
+    if (typeof r.file !== 'string' || !FILE.test(r.file)) { no('bad audio path (audio/<name>.wav only)'); continue; }
+    if (!HEX64.test(String(r.inputHash))) { no('bad inputHash'); continue; }
+    if (!(typeof r.dur === 'number' && r.dur > 0 && r.dur <= AUDIO_LIMITS.maxSeconds)) { no('bad dur'); continue; }
+    if (!Array.isArray(r.cues) || r.cues.length > 10000 || !r.cues.every((c, i) => typeof c === 'number' && Number.isFinite(c) && c >= 0 && c <= r.dur + 0.05 && (i === 0 || c >= r.cues[i - 1]))) { no('bad cues'); continue; }
+    const rc = r.recipe;
+    if (!isObj(rc) || typeof rc.engine !== 'string' || typeof rc.model !== 'string' || !isObj(rc.voice) || typeof rc.processing !== 'string') { no('bad recipe'); continue; }
+    if (!(rc.seed === null || Number.isInteger(rc.seed)) || !(rc.dictionary === null || typeof rc.dictionary === 'string' || rc.dictionary === undefined)) { no('bad recipe'); continue; }
+    const voice = {};
+    for (const role of ['expert', 'novice']) if (own(rc.voice, role)) { if (!VOICE.test(String(rc.voice[role]))) { no('bad voice name'); voice.bad = true; break; } voice[role] = String(rc.voice[role]); }
+    if (voice.bad) continue;
+    records.set(key, {
+      file: r.file, dur: r.dur, cues: r.cues.map(round3), inputHash: r.inputHash,
+      recipe: { engine: rc.engine.slice(0, 80), model: rc.model.slice(0, 200), voice, seed: rc.seed ?? null, dictionary: rc.dictionary ?? null, processing: rc.processing.slice(0, 80), ...(typeof rc.textNormalize === 'string' && rc.textNormalize ? { textNormalize: rc.textNormalize.slice(0, 80) } : {}), ...(typeof rc.runtime === 'string' && RUNTIME.test(rc.runtime) ? { runtime: rc.runtime } : {}), ...(Number.isInteger(rc.diffusionSteps) && rc.diffusionSteps >= 1 && rc.diffusionSteps <= STEPS_MAX ? { diffusionSteps: rc.diffusionSteps } : {}), ...(PRECISIONS.includes(rc.precision) ? { precision: rc.precision } : {}) },
+    });
+  }
+  return { records, docId, title, generator, problems };
+}
+
+// ---------------------------------------------------------------- zip
+export async function readColabZip(bytes) {
+  if (bytes.length > COLAB_LIMITS.zipBytes) throw new ZipError('zip-over', `the zip is over ${COLAB_LIMITS.zipBytes} bytes`);
+  return readZip(bytes, {
+    maxMembers: COLAB_LIMITS.steps + 8, maxTotalBytes: COLAB_LIMITS.totalBytes,
+    accept: (n) => n === 'records.json' || /^audio\/[^/]+$/.test(n),
+    maxMemberBytes: (n) => (n === 'records.json' ? COLAB_LIMITS.recordsBytes : COLAB_LIMITS.memberBytes),
+  });
+}
+
+// ---------------------------------------------------------------- 取り込みの計画（読むだけ）
+// applied：inputHash が今の口述原稿と合う（そのまま使う）／marked：書き出した後に原稿が変わった（印付き。自動では使わない）／
+// skipped：今の原稿にない段階・記録の不備・cue の数が合わない・音声がない／reject：別の教材（docId 不一致）・records.json がない・読めない
+export async function planImport({ zip, segs, docId = null, yomi = null }) {
+  const out = { reject: null, applied: [], marked: [], skipped: [], warnings: [], generator: null };
+  const rj = zip.files.get('records.json');
+  if (!rj) { out.reject = { code: 'no-records', why: 'records.json is missing' }; return out; }
+  const pr = parseRecords(new TextDecoder().decode(rj));
+  if (pr.fatal) { out.reject = { code: 'bad-records', why: pr.problems[0].why }; return out; }
+  out.generator = pr.generator;
+  if (docId !== null && pr.docId !== null && docId !== pr.docId) { out.reject = { code: 'doc-id', why: 'the job was made for another lesson (docId differs)', title: pr.title }; return out; }
+  for (const p of pr.problems) out.skipped.push({ key: p.key || null, why: p.why });
+  const byKey = new Map(segs.map((s) => [`${s.slideKey}:${s.stepKey}`, s]));
+  for (const [key, rec] of pr.records) {
+    const seg = byKey.get(key);
+    if (!seg) { out.skipped.push({ key, why: 'no-step' }); continue; }
+    if (!zip.files.has(rec.file)) { out.skipped.push({ key, why: 'no-audio' }); continue; }
+    const fresh = rec.inputHash === await inputHash(seg);
+    const cuesOk = rec.cues.length === expectedCues(seg);
+    const item = { key, rec, file: rec.file, cuesOk };
+    if (fresh) {
+      if (!cuesOk) { out.skipped.push({ key, why: 'cues' }); continue; }
+      out.applied.push(item);
+    } else out.marked.push(item);
+    const rc = rec.recipe;
+    if (yomi && rc.dictionary !== null && rc.dictionary !== yomi.sha256 && !out.warnings.includes('dictionary')) out.warnings.push('dictionary');
+    if (!rc.processing.startsWith(PROCESSING) && !out.warnings.includes('processing')) out.warnings.push('processing');
+  }
+  return out;
+}
+
+// 音声の WAV（ノートブックが後処理まで済ませたもの）を検証して復号する。ここでは後処理を重ねない（cue の時刻がずれるため）。
+// 44.1 kHz のモノラルにして返す（標本化周波数が違えば再標本化。cue は時間なので変わらない）。長さは復号した実際の音から
+export function decodeStepAudio(bytes, rec) {
+  const w = decodeWav(bytes);
+  if (!w) throw Object.assign(new Error(`${rec.file}: not a WAV file`), { code: 'audio-not-wav' });
+  if (!(w.sr >= 8000 && w.sr <= 96000)) throw Object.assign(new Error(`${rec.file}: unsupported sample rate ${w.sr}`), { code: 'audio-bad' });
+  let x = toMono(w.channels);
+  if (x.length > AUDIO_LIMITS.maxSeconds * w.sr) throw Object.assign(new Error(`${rec.file}: longer than ${AUDIO_LIMITS.maxSeconds} s`), { code: 'audio-too-long' });
+  let peak = 0;
+  for (let i = 0; i < x.length; i++) { if (!Number.isFinite(x[i])) throw Object.assign(new Error(`${rec.file}: not a number in the samples`), { code: 'audio-bad' }); peak = Math.max(peak, Math.abs(x[i])); }
+  if (!(peak > 0)) throw Object.assign(new Error(`${rec.file}: silent`), { code: 'audio-empty' });
+  x = resample(x, w.sr, SR);
+  const dur = round3(x.length / SR);
+  if (Math.abs(dur - rec.dur) > 0.25) throw Object.assign(new Error(`${rec.file}: length ${dur} s differs from the record (${rec.dur} s)`), { code: 'audio-bad' });
+  return { pcm: x, sr: SR, dur, cues: rec.cues.map((c) => Math.min(c, dur)) };
+}

package/kit/core/color-check.mjs

@@ -0,0 +1,49 @@
+// 色の検査の計算（テーマの検査 tools/test-themes.mjs と、テーマを作る画面 #58 が使う）。外の名前を使わない（ブラウザでも Node でも動く）。
+// handoff/theme-builder の colorlib.js（design-theme/tools/colorcheck.py を移したもの。Python と照らして一致を確かめた）から、要るものだけ：
+//   コントラスト比（WCAG 2.x）、色覚の模擬（Machado ほか 2009、強さ 1.0、線形 RGB で。1 型 protan・2 型 deutan・3 型 tritan）、
+//   CIELAB（D65）、色差 ΔE*ab（CIE76。テーマの見比べ 2026-10-27 とペンの色 #132 の数字はこれ）と CIEDE2000（テーマの工房の C4・C5 の基準）
+// 色は '#rrggbb' か [r, g, b]（0〜1）
+export const hex2rgb = (h) => { if (Array.isArray(h)) return h.slice(0, 3); let s = String(h).trim().replace(/^#/, ''); if (s.length === 3) s = s.replace(/./g, '$&$&'); return [0, 2, 4].map((i) => parseInt(s.substr(i, 2), 16) / 255); };
+const clip = (v) => Math.min(1, Math.max(0, v));
+export const rgb2hex = (c) => '#' + c.map((v) => ('0' + Math.round(clip(v) * 255).toString(16)).slice(-2)).join('').toUpperCase();
+const lin1 = (v) => (v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4));
+const delin1 = (v) => { v = clip(v); return v <= 0.0031308 ? 12.92 * v : 1.055 * Math.pow(v, 1 / 2.4) - 0.055; };
+const lin = (c) => c.map(lin1), delin = (c) => c.map(delin1);
+const mul = (M, v) => M.map((r) => r[0] * v[0] + r[1] * v[1] + r[2] * v[2]);
+export const relLum = (c) => { const l = lin(hex2rgb(c)); return 0.2126 * l[0] + 0.7152 * l[1] + 0.0722 * l[2]; };
+export const contrast = (a, b) => { const x = relLum(a), y = relLum(b); return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05); };
+export const MACHADO = {
+  protan: [[0.152286, 1.052583, -0.204868], [0.114503, 0.786281, 0.099216], [-0.003882, -0.048116, 1.051998]],
+  deutan: [[0.367322, 0.860646, -0.227968], [0.280085, 0.672501, 0.047413], [-0.011820, 0.042940, 0.968881]],
+  tritan: [[1.255528, -0.076749, -0.178779], [-0.078411, 0.930809, 0.147602], [0.004733, 0.691367, 0.303900]],
+};
+export const VISION = ['normal', 'protan', 'deutan', 'tritan'];
+export const simulate = (c, kind) => { c = hex2rgb(c); return kind === 'normal' ? c : delin(mul(MACHADO[kind], lin(c))); };
+const M_XYZ = [[0.4124564, 0.3575761, 0.1804375], [0.2126729, 0.7151522, 0.0721750], [0.0193339, 0.1191920, 0.9503041]], WHITE = [0.95047, 1.0, 1.08883];
+export function lab(c) {
+  const xyz = mul(M_XYZ, lin(hex2rgb(c))).map((v, i) => v / WHITE[i]), d = 6 / 29;
+  const f = xyz.map((t) => (t > d * d * d ? Math.cbrt(t) : t / (3 * d * d) + 4 / 29));
+  return [116 * f[1] - 16, 500 * (f[0] - f[1]), 200 * (f[1] - f[2])];
+}
+export const de76 = (a, b) => { const A = lab(a), B = lab(b); return Math.hypot(A[0] - B[0], A[1] - B[1], A[2] - B[2]); };
+const R = Math.PI / 180;
+export function de2000(c1, c2) {
+  const [L1, a1, b1] = lab(c1), [L2, a2, b2] = lab(c2);
+  const C1 = Math.hypot(a1, b1), C2 = Math.hypot(a2, b2), Cb = (C1 + C2) / 2;
+  const G = 0.5 * (1 - Math.sqrt(Cb ** 7 / (Cb ** 7 + 25 ** 7)));
+  const a1p = (1 + G) * a1, a2p = (1 + G) * a2, C1p = Math.hypot(a1p, b1), C2p = Math.hypot(a2p, b2);
+  const h1p = ((Math.atan2(b1, a1p) / R) % 360 + 360) % 360, h2p = ((Math.atan2(b2, a2p) / R) % 360 + 360) % 360;
+  const dLp = L2 - L1, dCp = C2p - C1p;
+  let dhp;
+  if (C1p * C2p === 0) dhp = 0; else if (Math.abs(h2p - h1p) <= 180) dhp = h2p - h1p; else dhp = h2p > h1p ? h2p - h1p - 360 : h2p - h1p + 360;
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin((dhp / 2) * R), Lbp = (L1 + L2) / 2, Cbp = (C1p + C2p) / 2;
+  let hbp;
+  if (C1p * C2p === 0) hbp = h1p + h2p; else if (Math.abs(h1p - h2p) <= 180) hbp = (h1p + h2p) / 2; else hbp = h1p + h2p < 360 ? (h1p + h2p + 360) / 2 : (h1p + h2p - 360) / 2;
+  const T = 1 - 0.17 * Math.cos((hbp - 30) * R) + 0.24 * Math.cos(2 * hbp * R) + 0.32 * Math.cos((3 * hbp + 6) * R) - 0.20 * Math.cos((4 * hbp - 63) * R);
+  const dth = 30 * Math.exp(-(((hbp - 275) / 25) ** 2)), Rc = 2 * Math.sqrt(Cbp ** 7 / (Cbp ** 7 + 25 ** 7));
+  const Sl = 1 + (0.015 * (Lbp - 50) ** 2) / Math.sqrt(20 + (Lbp - 50) ** 2), Sc = 1 + 0.045 * Cbp, Sh = 1 + 0.015 * Cbp * T;
+  const Rt = -Math.sin(2 * dth * R) * Rc;
+  return Math.sqrt((dLp / Sl) ** 2 + (dCp / Sc) ** 2 + (dHp / Sh) ** 2 + Rt * (dCp / Sc) * (dHp / Sh));
+}
+// 色覚の型 kind で模擬した 2 色の差（metric：'de76' か 'de2000'）
+export const deUnder = (a, b, kind, metric = 'de76') => (metric === 'de2000' ? de2000 : de76)(simulate(a, kind), simulate(b, kind));

package/kit/core/comment-core.mjs

@@ -0,0 +1,93 @@
+// コメント（comments.json）の点（pin）を確かめる。開発サーバー（server/dev.mjs）と編集アプリ（app/devapi.js）が共有する
+// （信頼する編集の画面 server/editor-ui.js は、開発サーバーが 1 ファイルのまま配るので同じ規則を自分の中に持つ）
+//   pin：Alt/⌥+クリックした点のスライドの座標 {x, y}（1280×720。表示の倍率によらない）。プレビュー（信頼しない）からの知らせが元なので、
+//   数（number で有限）でなければ点なし、スライドの外は端に寄せ、0.1 に丸め、ほかの項目は捨てる。点が偽でも、変わるのは印の位置だけ
+//   （指示の本文は信頼する画面で人が書き、残すボタンを押したときだけ書かれる）
+export const SLIDE_W = 1280, SLIDE_H = 720;
+const clamp = (v, hi) => Math.round(Math.max(0, Math.min(hi, v)) * 10) / 10;
+export function normPin(p) {
+  if (!p || typeof p !== 'object' || Array.isArray(p)) return null;
+  if (typeof p.x !== 'number' || typeof p.y !== 'number' || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return null;
+  return { x: clamp(p.x, SLIDE_W), y: clamp(p.y, SLIDE_H) };
+}
+
+// strokes：編集モードのマーカー（コメントのペン、m）で描いた線。1 つのメモに線は何本でも（丸と矢印など。STROKES_MAX 本まで）。
+//   線はスライドの座標の点の並び [[x, y], …]（1280×720、表示の倍率によらない）。形は docs/contract.md「Review notes」（§13）
+//   pin と同じく信頼しない知らせが元なので、線ごとに：配列でなければ・点（有限の数の組）が 2 つに満たなければその線は捨てる。
+//   スライドの外は端に寄せ、0.1 に丸め、続けて同じ点は 1 つにする。STROKE_MAX（500）点を超える線は、収まるまで許す誤差を倍にしながら
+//   間引く（Ramer–Douglas–Peucker、端の点は残す）。受け取る点は線ごとに STROKE_IN（5000）までで、それを超える線は捨てる。
+//   残った線の初めの STROKES_MAX（20）本を使い、点の合計が STROKES_POINTS（2000）を超えれば、全部の線を同じ誤差で（0.25 から倍にしながら）
+//   さらに間引く。線が 1 本も残らなければ線なし。並びが STROKES_IN（200）本を超える・受け取る点の合計が STROKES_IN_POINTS（20000）を超えるものも線なし
+//   前の形（1 本だけの stroke: [[x, y], …]）は entryStrokes が strokes: [stroke] として読む。書くのは strokes だけ
+export const STROKE_MAX = 500, STROKE_IN = 5000, STROKES_MAX = 20, STROKES_POINTS = 2000, STROKES_IN = 200, STROKES_IN_POINTS = 20000;
+function rdp(P, eps) {
+  const keep = new Uint8Array(P.length); keep[0] = keep[P.length - 1] = 1;
+  const st = [[0, P.length - 1]];
+  while (st.length) {
+    const [a, b] = st.pop();
+    const [ax, ay] = P[a], [bx, by] = P[b], dx = bx - ax, dy = by - ay, L = Math.hypot(dx, dy);
+    let best = -1, bd = eps;
+    for (let i = a + 1; i < b; i++) {
+      const d = L ? Math.abs(dy * (P[i][0] - ax) - dx * (P[i][1] - ay)) / L : Math.hypot(P[i][0] - ax, P[i][1] - ay);
+      if (d > bd) { bd = d; best = i; }
+    }
+    if (best >= 0) { keep[best] = 1; st.push([a, best], [best, b]); }
+  }
+  return P.filter((_, i) => keep[i]);
+}
+function cleanStroke(s) {
+  if (!Array.isArray(s) || s.length > STROKE_IN) return null;
+  const out = [];
+  for (const q of s) {
+    if (!Array.isArray(q) || q.length < 2 || typeof q[0] !== 'number' || typeof q[1] !== 'number' || !Number.isFinite(q[0]) || !Number.isFinite(q[1])) continue;
+    const p = [clamp(q[0], SLIDE_W), clamp(q[1], SLIDE_H)], l = out[out.length - 1];
+    if (!l || l[0] !== p[0] || l[1] !== p[1]) out.push(p);
+  }
+  return out.length < 2 ? null : out;
+}
+function simplify(P, max) {
+  let r = P;
+  for (let eps = 0.25; r.length > max; eps *= 2) r = rdp(P, eps);
+  return r;
+}
+// 1 本の線（前の形の stroke。normStrokes の線ごとの規則）
+export function normStroke(s) {
+  const c = cleanStroke(s);
+  return c ? simplify(c, STROKE_MAX) : null;
+}
+export function normStrokes(v) {
+  if (!Array.isArray(v) || v.length > STROKES_IN) return null;
+  let seen = 0;
+  for (const s of v) if (Array.isArray(s)) seen += s.length;
+  if (seen > STROKES_IN_POINTS) return null;
+  const raw = [];
+  for (const s of v) {
+    const c = cleanStroke(s);
+    if (c) raw.push(simplify(c, STROKE_MAX));
+    if (raw.length === STROKES_MAX) break;
+  }
+  if (!raw.length) return null;
+  let r = raw;
+  const total = (a) => a.reduce((n, P) => n + P.length, 0);
+  for (let eps = 0.25; total(r) > STROKES_POINTS; eps *= 2) r = raw.map((P) => (P.length > 2 ? rdp(P, eps) : P));
+  return r;
+}
+// comments.json の項目（や書き込みの知らせ）の線：strokes があればそれ、なければ前の形の stroke を 1 本の線として
+export function entryStrokes(c) {
+  if (!c || typeof c !== 'object') return null;
+  if (c.strokes !== undefined) return normStrokes(c.strokes);
+  if (c.stroke !== undefined) return normStrokes([c.stroke]);
+  return null;
+}
+// 線の重心（全部の線の区間の中点を、区間の長さで重みを付けて平均したもの）。マーカーの pin はこれ。長さが 0 なら 1 本目の最初の点
+export function strokesCentroid(S) {
+  let sx = 0, sy = 0, sl = 0;
+  for (const s of S) {
+    for (let i = 1; i < s.length; i++) {
+      const l = Math.hypot(s[i][0] - s[i - 1][0], s[i][1] - s[i - 1][1]);
+      sx += l * (s[i][0] + s[i - 1][0]) / 2; sy += l * (s[i][1] + s[i - 1][1]) / 2; sl += l;
+    }
+  }
+  return sl > 0 ? { x: clamp(sx / sl, SLIDE_W), y: clamp(sy / sl, SLIDE_H) } : { x: S[0][0][0], y: S[0][0][1] };
+}
+export const strokeCentroid = (s) => strokesCentroid([s]);