egatari 0.0.0-stage → 0.6.4

package/kit/core/llm-pack.mjs

@@ -0,0 +1,96 @@
+// チャットの AI への指示（AI instruction pack）を組み立てる。Node にもブラウザにも依存しない（純粋な ESM）
+// 指示は「共通の本体」（規格 R-…・大きさ・出力の形・標準の部品）と、束ごとの専門の部品の指示（stats・math・maps・kokugo・english・music・business・tools …。
+// パーツライブラリ 2.0 の manifest の set）からなる。特殊（extra）の部品は入れない（handoff/parts-tiers-2026-10-27.md §1、backlog #125）。
+// 材料（kit/core/llm-pack-data.mjs）は tools/make-llm-guide.mjs が tools/llm-guide/・docs/contract・部品の README から作る（手で直さない）。
+// 同じ関数を、編集アプリの「AI への指示をコピー」（app/llm.js）・コマンド（kit/llm-pack.mjs）・docs の書き出し（tools/make-llm-guide.mjs）・
+// 修正依頼（kit/core/llm-fix.mjs）が使う
+//
+//   buildPack({sets, lang, plan, exclude, off}) → 文字列   sets：束の名前の配列（[] なら共通の本体だけ）か 'all'（全部。比べる・CI 用）か 'a,b'。
+//                                                plan：'free'（既定。中核の 4 つのほかの標準の部品は一覧の 1 行だけ）| 'paid'（どの部品も詳しく）
+//   SETS                                        束の名前（決まった順）
+//   PACK_VERSION                                指示の版（材料の SHA-256 の先頭 8 字。指示のはじめの行に出る）
+//   commonBody(lang, opts?)・setPart(name, lang, opts?)  共通の本体・1 つの束の部分（docs/authoring-with-llms*.md・docs/llm-parts/*.md と同じ中身は plan: 'paid'。
+//                                                opts：{exclude, sets, off, plan}）
+//   PURPOSES                                     言いたいこと（新規作成の札と指示の表の材料。kit/core/purposes.mjs）
+//   requestBody(lang)                            最後に付く「頼みたいこと」（記入欄の付いた頼み方。docs/authoring-with-llms*.md の最後と同じ）
+//   setOf(tag)                                   部品（'m-kpi'）の居場所：'standard' か束の名前（指示にない部品・特殊の部品は null）
+//   componentsIn(html)                           デッキで使っている、指示にある部品（名前の並び）
+//   setsForDeck(html)                            デッキの部品・テーマから推した束（スライドの挿入の既定の選び方）
+//   componentNotes(names, lang)                  部品の説明（共通の本体・束にあるものと同じ文章。拡張の節も付ける）。修正依頼が使う
+//   packSize(text)                               UTF-8 のバイト数
+//   kbOf(bytes)・packKb(text)                    大きさの表示（KB、小数 1 桁。CLI の --list と編集アプリが同じ計算）
+//   PLANS・FREE_CORE・BRIEF                      お使いの AI のプラン・無料のプランでも詳しく書く中核の 4 つ・無料のプランで一覧の 1 行だけの標準の部品
+//   PACK_CAP_KB・PAID_PACK_KB                   指示の大きさの上限（{free, paid}。kit/core/llm-pack-assemble.mjs）
+//   assemble(data, {sets, lang, plan})           buildPack の本体（材料を渡す。tools/make-llm-guide.mjs が作りたての材料で使う）
+//   TIERS                                       パーツの段と束（パーツライブラリ 2.0 の manifest から。{catalogue, parts: {タグ: {tier, set?, purposes}}, purposes}。
+//                                                新規作成 ④ のパーツの一覧：kit/core/new-deck.mjs）
+//   loadedParts(sets)                            その束で組み立てに入る部品（標準と、選んだ束の部品）
+//   trimCandidates・fitPlan・fitPack             無料のプランの目安に収める（中核の 4 つを短く → 専門のパーツを外す候補に）。編集アプリ（kit/core/new-deck.mjs が出し直す）と
+//                                                コマンド（kit/llm-pack.mjs）が同じ関数を使う
+//   partsPackOpts(tags, plan, {short})           選んだパーツだけの指示の組み立ての引数 {sets, exclude, plan, short?}（buildPack・packWithRequest に渡す。
+//                                                選んだ専門のパーツの束を入れ、選ばないパーツは除く。プランは詳しさだけを変える。short：無料のプランで中核の 4 つも短く）
+import { PACK } from './llm-pack-data.mjs';
+import { assemble, normalizeSets as norm, commonOf, partOf, requestOf, membersOf, langOf, partSpans, PACK_CAP_KB, PAID_PACK_KB, PLANS, FREE_CORE, STANDARD, briefParts, planName, trimCandidates as trimCandidatesOf, fitPlan as fitPlanOf, fitPack as fitPackOf, packOptsOf } from './llm-pack-assemble.mjs';
+
+export { assemble, PACK_CAP_KB, PAID_PACK_KB, PLANS, FREE_CORE, STANDARD };
+export const BRIEF = briefParts(PACK, 'free');   // 無料のプランで一覧の 1 行だけの標準の部品
+export const SETS = PACK.sets;
+export const TIERS = PACK.tiers;
+export const normalizeSets = (sets) => norm(sets, PACK);
+// その束で組み立てに入る部品（標準と、選んだ束の部品。どちらのプランでも同じ。無料のプランの BRIEF も一覧に入る）
+export function loadedParts(sets = []) {
+  const ss = norm(sets, PACK);
+  return Object.keys(PACK.en.components).sort().filter((t) => { const s = PACK.en.components[t].set; return s === STANDARD || ss.includes(s); });
+}
+export const partsPackOpts = (tags, plan = 'free', opts = {}) => packOptsOf(PACK, tags, plan, opts);
+// 目安に収める（本体は kit/core/llm-pack-assemble.mjs。材料はこの指示の PACK）
+export const trimCandidates = trimCandidatesOf;
+export const fitPlan = (ticked, plan, opts) => fitPlanOf(PACK, ticked, plan, opts);
+export const fitPack = (ticked, plan, opts) => fitPackOf(PACK, ticked, plan, opts);
+
+export const PACK_VERSION = PACK.version;   // 指示の版（指示のはじめの「Pack version」の行と同じ。tools/make-llm-guide.mjs が材料から決める）
+
+export const buildPack = (opts) => assemble(PACK, opts);
+// sets：入っている束（表が指す部品。省くと [] = 標準だけ）。off：外した札。plan：'free'（既定）| 'paid'
+export const commonBody = (lang = 'en', { exclude = [], sets = [], off = [], plan = 'free' } = {}) => commonOf(PACK, lang, { exclude, sets, off, plan }) + '\n';
+export const setPart = (name, lang = 'en', { exclude = [] } = {}) => partOf(PACK, name, lang, { exclude }) + '\n';
+export const PURPOSES = PACK.purposes;   // 言いたいこと（kit/core/purposes.mjs の形。source が 'manifest' か 'fallback'）
+export const requestBody = (lang = 'en') => requestOf(PACK, lang) + '\n';
+
+export function setOf(tag) {
+  const c = PACK.en.components[String(tag).toLowerCase()];
+  return c ? c.set : null;
+}
+// 束の部品（'standard' なら標準の部品）
+export const membersOfSet = (name) => membersOf(PACK.en, name);
+
+// 指示にある部品のうち、デッキに出てくるもの（コメントの中も数える。軽い見積もりでよい）
+export function componentsIn(html) {
+  const found = new Set();
+  for (const m of String(html || '').matchAll(/<(m-[a-z0-9-]+)[\s>/]/gi)) { const t = m[1].toLowerCase(); if (PACK.en.components[t]) found.add(t); }
+  return [...found].sort();
+}
+// デッキの専門の部品の束と、テーマ・縦書きから推した束（business・sumi のテーマはビジネス、kokugo のテーマか縦書きは国語）
+export function setsForDeck(html) {
+  const s = new Set(componentsIn(html).map((t) => setOf(t)).filter((x) => x && x !== STANDARD));
+  const h = String(html || '');
+  const theme = (h.match(/<html[^>]*\sdata-theme\s*=\s*["']?([\w-]+)/i) || [])[1];
+  if (theme === 'business' || theme === 'sumi') s.add('business');
+  if (theme === 'kokugo' || /class\s*=\s*["'][^"']*\blayout-tate\b/i.test(h)) s.add('kokugo');
+  return PACK.sets.filter((x) => s.has(x));
+}
+
+// 部品の説明（buildPack に入るものと同じ文章）。拡張の節（m-flow のお金の流れなど）も付ける
+export function componentNotes(names, lang = 'en') {
+  const D = langOf(PACK, lang);
+  return names.filter((n) => D.components[n]).map((n) => {
+    const c = D.components[n];
+    const ext = Object.entries(c.ext || {}).map(([, t]) => D.extHead.replace('{name}', n) + '\n\n' + t);
+    return partSpans([c.entry, ...ext].join('\n\n'), []);   // 印（<!--part:…-->）だけを外す
+  }).join('\n\n');
+}
+
+export const packSize = (text) => new TextEncoder().encode(String(text)).length;
+// 大きさの表示（KB = UTF-8 のバイト数 / 1024、小数 1 桁）。node kit/llm-pack.mjs --list と編集アプリの貼り付けの窓が同じ計算を使う
+export const kbOf = (bytes) => (bytes / 1024).toFixed(1);
+export const packKb = (text) => kbOf(packSize(text));

package/kit/core/llm-request.mjs

@@ -0,0 +1,55 @@
+// AI への指示の最後に付く「頼みたいこと」を、編集アプリの窓で先に埋める（app/llm.js の「新規作成…」→「チャットの AI に書いてもらう」の ①）。Node にもブラウザにも依存しない
+// Claude などは長い貼り付けを添付のファイルの形にし、チャットの中では記入欄を直せない。そこで頼みたいことを窓で書き、指示の最後に入れてから写す。
+// 記入欄の見出し・既定の値は指示の材料（tools/llm-guide/template*.md の「頼みたいこと」。kit/core/llm-pack.mjs の requestBody）から読む。
+// 指示の本体（共通の本体・系列）はそのままで、最後の節だけを埋めたものに替える（指示の文章を変えないので、毎晩の評価の記録は動かない）
+//
+//   requestForm(lang) → {title, A: {head, fields: [{key, label, sep, value}]}, B: {head, text, fields: […]}}
+//     A（新しく作る）の key：topic・audience・length・language・speakers・examples。B（渡した資料と話し合いの内容で作る）の key も同じ
+//   filledRequest({kind: 'A' | 'B', values: {key: 文字列}}, lang) → 埋めた「頼みたいこと」（選ばなかった方と、空の項目は入れない）
+//   packWithRequest({sets, lang, request}) → buildPack と同じ組み立てで、最後の節を request（filledRequest の結果）に替えたもの。
+//     request がなければ buildPack と同じ。plan：お使いの AI（'free' 既定 | 'paid'。kit/core/llm-pack-assemble.mjs）。exclude：使わせない部品（新規作成で印を外したパーツ。一覧と説明・表・見本から除く）。off：外した札（表の行を出さない）。short：無料のプランで中核の 4 つも一覧の 1 行だけに
+import { PACK } from './llm-pack-data.mjs';
+import { requestOf, packParts } from './llm-pack-assemble.mjs';
+
+const KEYS = { A: ['title', 'audience', 'length', 'language', 'speakers', 'wishes'], B: ['title', 'audience', 'length', 'language', 'speakers', 'wishes'] };
+
+export function requestForm(lang = 'en') {
+  const lines = requestOf(PACK, lang).split('\n');
+  const title = lines[0].replace(/^#\s+/, '');
+  const out = { title };
+  let cur = null;
+  for (const ln of lines.slice(1)) {
+    const h = ln.match(/^\*\*([AB])\.\s*(.+?)\*\*\s*$/);
+    if (h) { cur = { head: `${h[1]}. ${h[2]}`, text: [], fields: [] }; out[h[1]] = cur; continue; }
+    if (!cur) continue;
+    const f = ln.match(/^-\s+(.+?)([：:])\s*(.*)$/);
+    if (f) { cur.fields.push({ label: f[1], sep: f[2], value: f[3].trim() }); continue; }
+    if (ln.trim()) cur.text.push(ln.trim());
+  }
+  for (const k of ['A', 'B']) {
+    const s = out[k];
+    if (!s || s.fields.length !== KEYS[k].length) throw new Error(`llm-request: the "${title}" section of the instructions (${lang}) does not have the expected fields for ${k}`);
+    s.fields.forEach((f, i) => { f.key = KEYS[k][i]; });
+    s.text = s.text.join('\n');
+  }
+  return out;
+}
+
+export function filledRequest({ kind = 'A', values = {} } = {}, lang = 'en') {
+  const F = requestForm(lang);
+  const s = F[kind === 'B' ? 'B' : 'A'];
+  const rows = [];
+  for (const f of s.fields) {
+    const v = String(values[f.key] ?? '').replace(/\r\n?/g, '\n').trim();
+    if (!v) continue;
+    const [first, ...rest] = v.split('\n').map((x) => x.trim()).filter(Boolean);
+    rows.push(`- ${f.label}${f.sep}${f.sep === ':' ? ' ' : ''}${first}` + rest.map((x) => `\n  ${x}`).join(''));
+  }
+  return [`# ${F.title}`, `**${s.head}**`, s.text, rows.join('\n')].filter(Boolean).join('\n\n') + '\n';
+}
+
+export function packWithRequest({ sets = [], lang = 'en', request = null, exclude = [], off = [], plan = 'free', short = false } = {}) {
+  const tail = request ? String(request).trim() : requestOf(PACK, lang);
+  const parts = [...packParts(PACK, { sets, lang, exclude, off, plan, short }), tail].filter(Boolean);
+  return parts.join('\n\n') + '\n';
+}

package/kit/core/mp3.mjs

@@ -0,0 +1,28 @@
+// MP3 にする（LAME を WebAssembly にしたもの：npm の lame-wasm。版は package.json で固定。LAME は LGPL、包みは MIT。NOTICE）。
+// LAME はこのリポジトリ（MIT）のコードに組み込まない：呼び手が lame-wasm の init を渡す。編集アプリは配信版の別のファイル
+// （dist/vendor/lame-wasm/index.js。手を加えない npm のもの）を、MP3 にするときだけ読み込む（app/mp3-loader.js）。
+// 試験（tools/test-audio-core.mjs）は node_modules の lame-wasm を渡す。Node とブラウザのどちらでも動き、ネットワークも fs も使わない
+//   encodeMp3(pcm, {init, sr, kbps}) → Promise<Uint8Array>   モノラルの Float32（-1〜1）→ CBR の MP3（設定は kit/core/audio-core.mjs の MP3）
+import { MP3 } from './audio-core.mjs';
+
+const CHUNK = 1152 * 64;   // 一度に渡す標本数（LAME の出力の場所が大きくなりすぎない）
+
+export async function encodeMp3(pcm, { init, sr = MP3.sr, kbps = MP3.kbps } = {}) {
+  if (typeof init !== 'function') throw new TypeError('encodeMp3: pass the init function of lame-wasm');
+  const lame = await init({ channels: 1, sampleRate: sr, kilobitRate: kbps });
+  const parts = [];
+  try {
+    for (let i = 0; i < pcm.length; i += CHUNK) {
+      // lame-wasm は Float32Array の buffer の全体を写すので、自分の buffer を持つ写しを渡す
+      const part = new Float32Array(pcm.subarray(i, Math.min(pcm.length, i + CHUNK)));
+      const out = lame.encodeFloat(part);
+      if (out.length) parts.push(out);
+    }
+    const tail = lame.flush();
+    if (tail.length) parts.push(tail);
+  } finally { lame.close(); }
+  const n = parts.reduce((a, p) => a + p.length, 0), out = new Uint8Array(n);
+  let o = 0;
+  for (const p of parts) { out.set(p, o); o += p.length; }
+  return out;
+}

package/kit/core/narration-core.mjs

@@ -0,0 +1,141 @@
+// 口述原稿（narration.md）の解析と書き換え。Node にもブラウザにも依存しない（fs・crypto を使わない）
+// kit/narration.mjs（build・TTS）、server/dev.mjs（開発サーバー）、app/（編集アプリ）が共有する
+// 書式は docs/contract.md §4
+import { short } from './sha1.mjs';
+
+export * from './narration-parse.mjs';
+import { parseNarration, parseHeading, normalizeKey, headingLine, isStepKey, joinLines, parseExtLine } from './narration-parse.mjs';
+const HEAD = /^##\s+(.+?)\s*$/;
+const ROLE = /^(Expert|Novice|E|N)\s*[:：]\s*/;
+
+// ---------------------------------------------------------------- 書き換え（開発サーバーと編集アプリの口述原稿の引き出し。その段階の行だけを置き換える）
+const stepOrder = (s) => (s === 'concl' ? Infinity : +s);
+
+// parseNarration と同じ規則で、節（## 見出し）と段階（[k]）の行の範囲を求める
+function scanNarration(lines) {
+  const sections = [];
+  let sec = null, blk = null, inComment = false;
+  lines.forEach((ln, idx) => {
+    if (inComment) { if (ln.includes('-->')) inComment = false; return; }
+    if (/^\s*<!--/.test(ln) && !ln.includes('-->')) { inComment = true; return; }
+    if (/^\s*<!--.*-->\s*$/.test(ln)) return;
+    const h = ln.match(HEAD);
+    if (h) {
+      if (sec) sec.end = idx;
+      sec = { key: parseHeading(h[1]).key, head: idx, end: lines.length, blocks: [], lastContent: idx };
+      sections.push(sec); blk = null; return;
+    }
+    if (/^#\s/.test(ln)) return;
+    const m = ln.match(/^\s*\[(\d+|concl)\]\s*(.*)$/);
+    // 使えない番号（[01] など）は段階ではないが、前の段階の続きにもしない（parseNarration と同じ）
+    if (m && sec && !isStepKey(m[1])) { blk = null; sec.lastContent = idx; return; }
+    if (m && sec) {
+      blk = { step: m[1], start: idx, end: idx + 1 };
+      sec.blocks.push(blk); sec.lastContent = idx; return;
+    }
+    if (ln.trim() && sec) { sec.lastContent = idx; if (blk) blk.end = idx + 1; }
+  });
+  return sections;
+}
+function oneLine(s) { return String(s).split(/\r?\n/).map((x) => x.trim()).filter(Boolean).join(''); }
+function formatBlock(step, turns) {
+  // 話者の表記：全員が Expert で 1 発言なら書かない。Expert が複数の発言のときは、書かないと 1 発言に
+  // 繋がってしまう（parseNarration は話者のない行を前の発言の続きとして読む）ので Expert: を書く
+  const allExpert = turns.every((t) => t.role !== 'novice');
+  const bare = allExpert && turns.length === 1 && !ROLE.test(turns[0].text);
+  return turns.map((t, j) => (j ? '    ' : `[${step}] `) +
+    (bare ? '' : t.role === 'novice' ? 'Novice: ' : 'Expert: ') + t.text);
+}
+// slideOrder：原稿のスライドの順。鍵の文字列か {key, id, heading}（build の slides）の配列。
+// 新しい節の見出しは、id のあるスライドなら「## 見出し {#id}」にする
+export function rewriteNarration(text, slideKey, stepKey, turns, slideOrder = []) {
+  if (!isStepKey(stepKey)) throw new Error(`bad step key: ${stepKey}`);
+  const eol = text.includes('\r\n') ? '\r\n' : '\n';
+  // 行ごとの改行（CRLF / LF）を覚えておき、触らない行はそのまま書き戻す。新しい行は文書の改行で
+  const parts = String(text).split(/(\r?\n)/);
+  const lines = [], eols = [];
+  for (let j = 0; j < parts.length; j += 2) { lines.push(parts[j]); eols.push(parts[j + 1] ?? null); }
+  const splice = (at, del, add) => { lines.splice(at, del, ...add); eols.splice(at, del, ...add.map(() => null)); };
+  turns = turns.map((t) => ({ role: t.role === 'novice' ? 'novice' : 'expert', text: oneLine(t.text) })).filter((t) => t.text);
+  const block = turns.length ? formatBlock(stepKey, turns) : [];
+  const sections = scanNarration(lines);
+  const sec = [...sections].reverse().find((s) => s.key === slideKey);
+  if (sec) {
+    const same = sec.blocks.filter((b) => b.step === stepKey);
+    if (same.length) {
+      // 同じ段階が複数あれば、効いている最後のものを置き換え、前のものは消す
+      const last = same[same.length - 1];
+      const keep = extLinesOf(lines, last);
+      const add = withExt(stepKey, block, keep);
+      // 拡張の行は文字も改行もそのまま
+      // 新しい行は、置き換える行の同じ位置の改行を使う（改行の混ざった原稿でも、ほかの行と同じ書き方に）
+      const was = eols.slice(last.start, last.end);
+      const addEols = add.map((l, j) => { const k = keep.find((x) => x.text === l && !x.used); if (k) { k.used = true; return eols[k.idx]; } return was[Math.min(j, was.length - 1)] ?? null; });
+      lines.splice(last.start, last.end - last.start, ...add);
+      eols.splice(last.start, last.end - last.start, ...addEols);
+      for (const b of same.slice(0, -1).reverse()) splice(b.start, b.end - b.start, []);
+    } else if (block.length) {
+      const later = sec.blocks.find((b) => stepOrder(b.step) > stepOrder(stepKey));
+      const at = later ? later.start : sec.lastContent + 1;
+      splice(at, 0, block);
+    }
+  } else if (block.length) {
+    // 新しい節：原稿のスライドの順で、次のスライドの節の前に入れる
+    const order = slideOrder.map((s) => (typeof s === 'string' ? { key: s } : s));
+    const idx = order.findIndex((s) => s.key === slideKey);
+    const nextSec = idx >= 0 ? order.slice(idx + 1).map((o) => sections.find((s) => s.key === o.key)).find(Boolean) : null;
+    const add = [idx >= 0 && typeof slideOrder[idx] !== 'string' ? headingLine(order[idx]) : `## ${slideKey}`, ...block, ''];
+    if (nextSec) splice(nextSec.head, 0, add);
+    else {
+      while (lines.length && lines[lines.length - 1] === '') { lines.pop(); eols.pop(); }
+      splice(lines.length, 0, ['', ...add]);
+    }
+  }
+  return lines.map((l, j) => l + (j < lines.length - 1 ? (eols[j] ?? eol) : '')).join('');
+}
+// 段階の行の範囲の中の拡張の行と、その前にある発言の数（書き換えた後も同じ発言の後ろに置く）
+function extLinesOf(lines, blk) {
+  const out = [];
+  let n = 0;
+  for (let j = blk.start; j < blk.end; j++) {
+    const ln = lines[j];
+    if (j === blk.start) { const m = ln.match(/^\s*\[(\d+|concl)\]\s*(.*)$/); if (m && m[2].trim()) n = 1; continue; }
+    if (parseExtLine(ln)) { out.push({ idx: j, text: ln, after: n }); continue; }
+    if (!ln.trim() || /^\s*<!--/.test(ln)) continue;
+    if (ROLE.test(ln.trim()) || n === 0) n++;
+  }
+  return out;
+}
+// 新しい段階の行に拡張の行を差し込む。最初の発言の前のもの（と、発言が空になったとき）は「[k]」だけの行の後ろに
+function withExt(step, block, ext) {
+  if (!ext.length) return block;
+  const n = block.length;
+  const lead = ext.filter((x) => x.after === 0 || n === 0);
+  const out = [];
+  let body = block;
+  if (lead.length) {
+    out.push(`[${step}]`, ...lead.map((x) => x.text));
+    body = block.map((l, j) => (j ? l : '    ' + l.replace(/^\[[^\]]*\]\s?/, '')));
+  }
+  body.forEach((l, j) => {
+    out.push(l);
+    for (const x of ext) if (x.after > 0 && Math.min(x.after, n) === j + 1) out.push(x.text);
+  });
+  return out;
+}
+// その段階の行（同じ段階が複数あればすべて）の短い hash。口述原稿の保存の衝突を見分けるのに使う
+export function narrationRev(text, slideKey, stepKey) {
+  const lines = String(text).split(/\r?\n/);
+  const sec = [...scanNarration(lines)].reverse().find((s) => s.key === slideKey);
+  const blocks = sec ? sec.blocks.filter((b) => b.step === stepKey).map((b) => lines.slice(b.start, b.end).join('\n')) : [];
+  return short(JSON.stringify(blocks));
+}
+// その段階の発言（書いたままの文字列）。同じ段階が複数あれば効いている最後のもの
+export function rawTurns(text, slideKey, stepKey) {
+  if (text == null) return { turns: [], exists: false };
+  const segs = parseNarration(text).filter((s) => s.slideKey === slideKey && s.stepKey === stepKey);
+  const seg = segs[segs.length - 1];
+  return seg ? { turns: seg.turns.map((t) => ({ role: t.role, text: t.raw })), exists: true, line: seg.line } : { turns: [], exists: false };
+}
+// "鍵:段階" → [スライドの鍵, 段階]（スライドの鍵に : があってもよい）
+export function splitKey(key) { const p = String(key).lastIndexOf(':'); return p < 0 ? [String(key), '0'] : [key.slice(0, p), key.slice(p + 1)]; }

package/kit/core/narration-lint.mjs

@@ -0,0 +1,146 @@
+// 口述原稿（narration.md）の書き方の品質チェックで、コマンド版（kit/check.mjs）とブラウザ版（編集アプリ、app/llm.js）が共有するもの。
+// Node にもブラウザにも依存しない（純粋な ESM）。書式は docs/contract.md §4
+//
+//   readingProblems(raw)          段階の発言の元の文字列（{…} を含む）→ [{display, reading, why: 'operator' | 'several', text}]
+//     読みの指定 {x|y} は 1 つの記号か用語だけに付ける（{θ|シータ}、{N₀|エヌゼロ}、{ReLU|レルー}）。飾りの付いた 1 つの記号はよい
+//     （{Q*|キュースター}、{x′|エックスプライム}、{x_0|…}、{x^2|…}、{θ̂|シータハット}、{\hat{\theta}|…}、{\theta|シータ}）。
+//     x に演算子（= + − × / < > ^ _ \ など、数字や記号の隣の -）があれば 'operator'（式を読み上げている）、
+//     記号が 2 つ以上（θとη、a, b、x y）なら 'several'。f(x) の形（記号の後ろに括弧で 1 つ）は 1 つとみなす
+//   stepKeysOf({max, cstep, static}) 段階の鍵の集まり（kit/deck.js の stepKey と同じ：cstep の段階は concl）
+//   orphanSteps(segs, slides)     narration.md の段階のうち、スライドにないもの → [{slideKey, stepKey, line, valid}]
+//     slides：[{key, max, cstep, static}]（組んだデッキの DECK.slides の _key・_max・_cstep）。どのスライドにも合わない節は build が知らせる
+//   orphanDetail(o, slide, text)  orphanSteps の 1 つを直す手がかり → {keys: ['0', …, 'concl'], n（番号の段階の最後）, concl, static,
+//     target（行を合わせる先の段階の鍵）, lines: [{n: 行番号, text: その行のまま}]}。text は narration.md の全体（なければ lines は空）
+import { stripNotes } from './narration-parse.mjs';
+
+const READING = /\{([^{}|]+)\|([^{}]+)\}/g;
+const OPS = /[=+−×÷*/<>≤≥≠≈∝^_\\∑∫√]/;
+const SYM_START = 'A-Za-z\\u0370-\\u03FF';
+const SYM_BODY = `${SYM_START}0-9\\u0300-\\u036F\\u2070-\\u209C\\u00B2\\u00B3\\u00B9'′`;
+const RUN = new RegExp(`[${SYM_START}][${SYM_BODY}]*(?:-[${SYM_START}][${SYM_BODY}]*)*`, 'g');
+const FUNC = new RegExp(`^[${SYM_START}][${SYM_BODY}]*\\([${SYM_START}][${SYM_BODY}]*\\)$`);
+
+// 1 つの記号の飾りを外す：上付き・下付き（x₀ x_0 x^2 x_{i+1}）、星（Q*。後ろに記号が続かないもの）、プライム（x′ x'）、
+// 上の印（θ̂ x̄ の結合文字、\hat{θ} \bar{x} \tilde{x} など）、LaTeX の 1 つのマクロ（\theta）。残りで演算子と記号の数を見る
+const DECOR = /\\(?:hat|bar|tilde|dot|ddot|vec|overline|widehat|widetilde|check|breve|acute|grave|mathbf|mathrm|mathit|mathsf|mathcal|mathbb|mathfrak|boldsymbol|bm)\s*\{([^{}]*)\}/g;
+function bare(display) {
+  let x = display;
+  for (let n = 0; n < 3 && DECOR.test(x); n++) x = x.replace(DECOR, '$1');
+  x = x.replace(/\\[A-Za-z]+/g, 'α')                        // \theta など 1 つのマクロ = 1 つの記号
+    .replace(/[_^]\{[^{}]*\}/g, '').replace(/[_^][A-Za-z0-9Ͱ-Ͽ*′'+\-]/g, '')
+    .replace(/[̀-ͯ⁰-₟²³¹ᵢ-ᵪ]/g, '')
+    .replace(/[′'″‴]+/g, '')
+    .replace(/\*+(?![A-Za-zͰ-Ͽ0-9(])/g, '');     // 後置の星（Q*、x*_i）。a*b の * は掛け算として残す
+  return x;
+}
+export function readingProblems(raw) {
+  const out = [];
+  for (const m of stripNotes(raw).matchAll(READING)) {
+    const display = m[1].trim(), reading = m[2].trim();
+    if (/^(mark:|cue$)/.test(display)) continue;   // {mark:ID|effect} は読みではない
+    const x = bare(display);
+    let why = null;
+    // 数字・ギリシャ文字の隣の - は引き算（1-η）。英字どうしの - は語の一部（t-SNE）
+    if (OPS.test(x) || /[0-9Ͱ-Ͽ]\s*-|-\s*[0-9Ͱ-Ͽ]/.test(x)) why = 'operator';
+    else if (!FUNC.test(x)) {
+      const runs = x.match(RUN) || [];
+      if (runs.length >= 2 || (runs.length === 1 && /[\s,、，・]/.test(x.trim()))) why = 'several';
+    }
+    if (why) out.push({ display, reading, why, text: m[0] });
+  }
+  return out;
+}
+
+export function stepKeysOf(s) {
+  const keys = new Set();
+  const max = s.static ? 0 : s.max;
+  for (let k = 0; k <= max; k++) keys.add(k === s.cstep && !s.static ? 'concl' : String(k));
+  return keys;
+}
+
+export function orphanSteps(segs, slides) {
+  const byKey = new Map(slides.map((s) => [s.key, s]));
+  const out = [];
+  for (const seg of segs) {
+    const s = byKey.get(seg.slideKey);
+    if (!s) continue;
+    const valid = stepKeysOf(s);
+    if (!valid.has(seg.stepKey)) out.push({ slideKey: seg.slideKey, stepKey: seg.stepKey, line: seg.line, end: seg.end || seg.line, valid: [...valid] });
+  }
+  return out;
+}
+
+export function orphanDetail(o, s, text) {
+  const keys = [...stepKeysOf(s)];
+  const concl = keys.includes('concl');
+  const nums = keys.filter((k) => k !== 'concl').map(Number);
+  const n = nums.length ? Math.max(...nums) : 0;
+  // 合わせる先：番号なら k−1（なければ番号の最後）、[concl] なら番号の最後
+  const k = /^\d+$/.test(o.stepKey) ? +o.stepKey : null;
+  const target = String(k !== null && k - 1 >= 0 && k - 1 <= n ? k - 1 : n);
+  const src = text ? String(text).replace(/\r\n?/g, '\n').split('\n') : [];
+  const lines = [];
+  for (let i = o.line; i <= (o.end || o.line) && i <= src.length; i++) if (src[i - 1].trim()) lines.push({ n: i, text: src[i - 1] });
+  return { keys, n, concl, static: !!s.static, target, lines };
+}
+
+// ---------------------------------------------------------------- 口述原稿の言語と、式の読み上げらしさ（R-formula）
+// スライドの言語（<html lang>）と口述原稿の言語は別のことがある（日本語のスライドに英語の口述原稿・字幕だけ別の言語）。
+//   narrationLang({voiceLang, deckLang, texts}) → {lang: 'ja' | <その言語>, source: 'voice.json' | 'text' | 'deck'}
+//     voice.json の "lang"（TTS の tts/synth.py と同じ。あればそれ）＞ 発言の文字（日本語の字がほとんどない・ほとんどの発言にある）＞ デッキの <html lang>
+//   textLang(text, narrLang) → 'ja' | 'en'：1 つの発言にどちらの規則を当てるか。日本語の字（かな・漢字）があれば日本語、
+//     なければ英語の文らしければ（3 字以上の英単語が 3 つ以上）英語。日本語の口述原稿の中の「sin x cos y」は日本語の規則のまま
+//   formulaLike(text, lang) → bool：式を読み上げているらしい（kit/check.mjs の narrFormula）
+const JA_CHAR = /[぀-ヿ㐀-鿿豈-﫿ｦ-ﾟ]/;
+// 式の中の関数の名前（3 字以上でも記号として数える）
+const MATH_WORDS = new Set(['sin', 'cos', 'tan', 'sec', 'csc', 'cot', 'sinh', 'cosh', 'tanh', 'log', 'exp', 'lim', 'max', 'min', 'arg', 'argmax', 'argmin', 'det', 'mod', 'sup', 'inf', 'gcd', 'lcm', 'var', 'cov', 'erf']);
+const isJaLang = (l) => !l || /^ja\b/i.test(l);
+export const hasJapanese = (s) => JA_CHAR.test(String(s));
+function englishLike(s) {
+  const words = String(s).match(/[A-Za-z][A-Za-z']*/g) || [];
+  return words.filter((w) => w.length >= 3 && !MATH_WORDS.has(w.toLowerCase())).length >= 3;
+}
+export function narrationLang({ voiceLang, deckLang, texts = [] } = {}) {
+  if (typeof voiceLang === 'string' && /^[A-Za-z]{2,3}(-[A-Za-z0-9]{1,8})*$/.test(voiceLang.trim())) return { lang: voiceLang.trim().toLowerCase(), source: 'voice.json' };
+  const ts = texts.map(String).filter((t) => t.trim());
+  if (ts.length >= 3) {
+    const ja = ts.filter(hasJapanese).length, en = ts.filter((t) => !hasJapanese(t) && englishLike(t)).length;
+    if (isJaLang(deckLang) && ja <= ts.length * 0.1 && en >= ts.length * 0.5) return { lang: 'en', source: 'text' };
+    if (!isJaLang(deckLang) && ja >= ts.length * 0.5) return { lang: 'ja', source: 'text' };
+  }
+  return { lang: isJaLang(deckLang) ? 'ja' : String(deckLang).toLowerCase(), source: 'deck' };
+}
+export function textLang(text, narrLang) {
+  if (hasJapanese(text)) return 'ja';
+  if (!isJaLang(narrLang)) return 'en';
+  return englishLike(text) ? 'en' : 'ja';
+}
+// 15 字の区間に ops の字が n 個以上
+function denseOps(s, ops, n) {
+  for (let i = 0; i < s.length; i++) {
+    let c = 0;
+    for (let j = i; j < Math.min(s.length, i + 15); j++) if (ops.includes(s[j])) c++;
+    if (c >= n) return true;
+  }
+  return false;
+}
+// 日本語の発言：バックスラッシュ・^・_、15 字に = + − × * が 4 つ以上、記号らしい英字が密（英字の名前・語は数えない）
+//   名前・語とみなす英字の並び：3 字以上（sin・log などの関数の名前を除く）か、2 字以上の大文字（AI・HTML）。
+//   残る英字（x・ax・dx・f など）が 4 つ以上で、名前・語を除いた後の字（空白を除く）の半分を超えれば式。
+//   前の規則（英字をすべて数える）より警告が増えることはない
+function formulaLikeJa(s) {
+  if (/\\|\^|_/.test(s)) return true;
+  if (denseOps(s, '=+−×*', 4)) return true;
+  const rest = s.replace(/[A-Za-z]+/g, (w) => (w.length >= 3 && !MATH_WORDS.has(w.toLowerCase())) || /^[A-Z]{2,}$/.test(w) ? '' : w);
+  const letters = (rest.match(/[A-Za-z]/g) || []).length;
+  const total = rest.replace(/\s/g, '').length;
+  return total > 0 && letters >= 4 && letters / total > 0.5;
+}
+// 英語の発言：ラテン文字が多いのは当たり前なので、バックスラッシュ・^・_ と、15 字に演算子 3 つ以上だけを見る
+function formulaLikeEn(s) {
+  if (/\\|\^|_/.test(s)) return true;
+  return denseOps(s, '=+−×*<>≤≥/', 3);
+}
+export function formulaLike(text, lang) {
+  return isJaLang(lang) ? formulaLikeJa(String(text)) : formulaLikeEn(String(text));
+}