egatari 0.0.0-stage → 0.6.4

package/kit/core/attachments.mjs

@@ -0,0 +1,255 @@
+// 添付（format spec §3.8。名前と識別子は kit/core/format.mjs の ATTACH_*）：読み手のためのファイル（元の原稿・PDF・コード・データ・補足）。
+// 組み立てには使わない。再生器はダウンロードだけを出し、開かない・実行しない。Node にもブラウザにも依存しない
+//
+//   作業フォルダ：ファイルは attachments/ の下。役割と題は設定のファイル（FORMAT.CONFIG_FILE）の項目 FORMAT.ATTACH_KEY：
+//     {"docId": …, "attachments": [{"path": "attachments/paper.pdf", "role": "pdf", "title": "論文（PDF）"}]}（索引の index.attachments と同じ形）
+//   1 ファイル（.ega.html）：ファイルは files（archive path 'attachments/…'）、一覧は index.attachments（役割のあるものだけ）
+//
+//   configEntries(conf)                 設定のファイルの一覧 → {entries: Map(path → 項目), problems}
+//   planAttachments(files, conf, opts)  作業フォルダの attachments/ のファイル（[{path, size}]）と設定 → {include, list, problems}
+//   attachmentsOf(index)                文書の索引から、再生器・編集器が出す添付（files にあり、役割が正しいもの）
+//   attachmentName(path)                ダウンロードの名前（パスの最後。危ない字を _ に）
+// problems：{code, path?, …}。code は kit/check-messages.mjs の attach…（品質チェックと書き出しの知らせが同じ言葉を使う）
+import { FORMAT } from './format.mjs';
+import { pathProblem, excludedReason, foldPath } from './portable.mjs';
+import { inspectAttachment, nameProblem, roleProblem, blocking, kindOfName, roleAllows, attachmentMime, ROLE_KINDS, TITLE_CHARS, DESCRIPTION_CHARS, titleProblem, descriptionProblem, clipChars } from './attach-content.mjs';
+export { inspectAttachment, nameProblem, roleProblem, blocking, kindOfName, roleAllows, attachmentMime, ROLE_KINDS, titleProblem, descriptionProblem, clipChars };
+
+const MiB = 1024 * 1024;
+// 添付の上限：1 つ 10 MiB、合わせて 20 MiB（形式の §3.8 の案の推奨と同じ。超えるものは断る）、100 個まで。書き出した 1 ファイルは base64 で 4/3 倍になる
+// （20 MiB → 約 27 MiB。形式の上限は §11）。題は要る（§3.8 の案）・120 字まで・1 行。説明（description。1〜2 文の文字だけ）は 300 字まで・1 行
+export const ATTACH_LIMITS = Object.freeze({ fileBytes: 10 * MiB, totalBytes: 20 * MiB, count: 100, titleChars: TITLE_CHARS, descriptionChars: DESCRIPTION_CHARS });
+
+// 音声と動画は添付にしない（§3.8 の案：教材が鳴らさないものは添付しない）。拡張子と、先頭のバイト（よくある形式の印）で見分ける
+const MEDIA_EXT = {
+  audio: ['mp3', 'm4a', 'm4b', 'aac', 'wav', 'wave', 'ogg', 'oga', 'opus', 'flac', 'aif', 'aiff', 'wma', 'amr', 'weba', 'mka'],
+  video: ['mp4', 'm4v', 'mov', 'qt', 'webm', 'mkv', 'ogv', 'avi', 'wmv', 'mpg', 'mpeg', '3gp', '3g2'],
+};
+// 拡張子から：'audio' | 'video' | null
+export function mediaKindOfName(p) {
+  const ext = (String(p || '').match(/\.([^./]+)$/)?.[1] || '').toLowerCase();
+  for (const [k, list] of Object.entries(MEDIA_EXT)) if (list.includes(ext)) return k;
+  return null;
+}
+// 先頭のバイト（16 バイトあれば足りる）から：'audio' | 'video' | null。mp3（ID3・MPEG の音声の枠）・AAC（ADTS・ADIF）・WAV・AIFF・AVI・
+// Ogg（Vorbis・Opus・Theora）・FLAC・WebM/Matroska・MP4/M4A/MOV（ftyp・moov・mdat。HEIF・AVIF の画像の ftyp は除く）
+const IMAGE_BRANDS = new Set(['heic', 'heix', 'heim', 'heis', 'hevc', 'hevx', 'mif1', 'msf1', 'avif', 'avis', 'crx ']);
+const AUDIO_BRANDS = new Set(['M4A ', 'M4B ', 'M4P ', 'F4A ', 'F4B ']);
+export function sniffMedia(bytes) {
+  const b = bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes || []);
+  const asc = (i, n) => String.fromCharCode(...b.subarray(i, i + n));
+  if (b.length < 4) return null;
+  if (asc(0, 3) === 'ID3' || asc(0, 4) === 'ADIF' || asc(0, 4) === 'fLaC') return 'audio';
+  if (asc(0, 4) === 'OggS') return /theora/i.test(asc(28, 8)) ? 'video' : 'audio';
+  if (b[0] === 0x1a && b[1] === 0x45 && b[2] === 0xdf && b[3] === 0xa3) return 'video';
+  if (b.length >= 12 && asc(0, 4) === 'RIFF') { const t = asc(8, 4); if (t === 'WAVE') return 'audio'; if (t === 'AVI ') return 'video'; return null; }
+  if (b.length >= 12 && asc(0, 4) === 'FORM' && /^AIF[FC]$/.test(asc(8, 4))) return 'audio';
+  if (b.length >= 8) {
+    const box = asc(4, 4);
+    if (box === 'ftyp' && b.length >= 12) { const brand = asc(8, 4); if (IMAGE_BRANDS.has(brand)) return null; return AUDIO_BRANDS.has(brand) ? 'audio' : 'video'; }
+    if (box === 'moov' || box === 'mdat' || box === 'wide') return 'video';
+  }
+  // MPEG の音声の枠（mp3 など）と AAC の ADTS：FF Ex/Fx。UTF-16 の BOM（FF FE）と FF FF は除く
+  if (b[0] === 0xff && (b[1] & 0xe0) === 0xe0 && b[1] !== 0xfe && b[1] !== 0xff && b.length >= 3) {
+    const layer = (b[1] >> 1) & 3;
+    if (layer === 0) return (b[1] & 0xf6) === 0xf0 ? 'audio' : null;   // ADTS
+    if (((b[1] >> 3) & 3) !== 1 && (b[2] >> 4) !== 15 && ((b[2] >> 2) & 3) !== 3) return 'audio';
+  }
+  return null;
+}
+// 音声・動画の添付の問題（なければ null）：{code: 'attachMedia', path, kind, by: 'name' | 'content'}
+export function attachMediaProblem(p, bytes) {
+  const byName = mediaKindOfName(p);
+  if (byName) return { code: 'attachMedia', path: p, level: 'must', kind: byName, by: 'name' };
+  const byContent = bytes ? sniffMedia(bytes) : null;
+  return byContent ? { code: 'attachMedia', path: p, level: 'must', kind: byContent, by: 'content' } : null;
+}
+// 題（title。§3.8・Schema：1〜120 字・1 行・空白だけでない）と説明（description。300 字まで・1 行）の検査は attach-content.mjs の titleProblem・descriptionProblem
+const hasTitle = (e) => !titleProblem(e.title);
+const blankTitle = (e) => !own(e, 'title') || (typeof e.title === 'string' && !e.title.trim());
+export const ATTACH_ROLES = FORMAT.ATTACH_ROLES;
+const PREFIX = FORMAT.ATTACH_DIR + '/';
+export const ATTACH_PREFIX = PREFIX;
+export const isAttachPath = (p) => typeof p === 'string' && p.startsWith(PREFIX) && p.length > PREFIX.length;
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const own = (o, k) => o != null && Object.prototype.hasOwnProperty.call(o, k);
+
+// 1 つのパスの問題（添付として）。なければ null
+export function attachPathProblem(p) {
+  if (typeof p !== 'string' || !p) return 'not a path';
+  if (!isAttachPath(p)) return `not under ${PREFIX}`;
+  const why = pathProblem(p);
+  if (why) return why;
+  const ex = excludedReason(p);
+  if (ex) return `excluded (${ex})`;
+  return null;
+}
+
+// 設定のファイル（parse した object）の添付の一覧。並びは書いた順。同じパスが 2 度なら後のものを捨てる
+export function configEntries(conf) {
+  const entries = new Map(), problems = [];
+  const list = isObj(conf) ? conf[FORMAT.ATTACH_KEY] : undefined;
+  if (list === undefined) return { entries, problems };
+  if (!Array.isArray(list)) { problems.push({ code: 'attachBadConfig', why: `"${FORMAT.ATTACH_KEY}" is not an array` }); return { entries, problems }; }
+  const seen = new Map();
+  list.forEach((e, j) => {
+    if (!isObj(e) || typeof e.path !== 'string') { problems.push({ code: 'attachBadConfig', why: `${FORMAT.ATTACH_KEY}[${j}] has no "path"` }); return; }
+    const why = attachPathProblem(e.path);
+    if (why) { problems.push({ code: 'attachBadName', path: e.path, why }); return; }
+    const f = foldPath(e.path);
+    if (seen.has(f)) { problems.push({ code: 'attachDuplicate', path: e.path, other: seen.get(f) }); return; }
+    seen.set(f, e.path);
+    if (own(e, 'role') && !ATTACH_ROLES.includes(e.role)) problems.push({ code: 'attachBadRole', path: e.path, role: String(e.role).slice(0, 40) });
+    entries.set(e.path, e);
+  });
+  return { entries, problems };
+}
+
+// 索引に書く項目：path・role・title（要る）・description（正しいときだけ。空なら書かない）と、ほかの書き手が足した知らない項目（そのまま残す。§7.1）
+function indexEntry(e) {
+  const o = { path: e.path, role: e.role, title: e.title };
+  if (typeof e.description === 'string' && e.description.trim() && !descriptionProblem(e.description)) o.description = e.description.trim();
+  for (const k of Object.keys(e)) if (!own(o, k) && k !== 'title' && k !== 'description') o[k] = e[k];
+  return o;
+}
+
+// files：作業フォルダの attachments/ の下のファイル [{path, size}]（size は分からなければ null）。conf：設定のファイルの object。
+// opts.carry：開いた文書の index.attachments（その文書を作り直すとき、設定のファイルに書いていない役割と題を引き継ぐ。ほかの書き手の文書）
+// opts.limits：上限（試験用）
+// opts.keep：§3.8 の型の検査（名前・役割と型の組・中身）をしないパスの Set（段 A の保存で、前からあって中身も記録も変わらない添付。
+//   前の版で入れたものを、口述原稿を直しただけの保存で落とさない。知らせは呼び手が出す）
+// 返すもの：include（文書に入れるパス。並びは設定の順、残りはパスの順）・list（index.attachments：役割のあるもの）・problems
+export function planAttachments(files, conf, opts = {}) {
+  const L = { ...ATTACH_LIMITS, ...(opts.limits || {}) };
+  const { entries, problems } = configEntries(conf);
+  const carry = new Map();
+  if (Array.isArray(opts.carry)) for (const c of opts.carry) if (isObj(c) && typeof c.path === 'string' && !entries.has(c.path)) carry.set(c.path, c);
+  const sizeOf = new Map();
+  const all = [], refused = new Set();
+  for (const f of files || []) {
+    const p = typeof f === 'string' ? f : f && f.path;
+    if (!isAttachPath(p)) continue;
+    const why = attachPathProblem(p);
+    if (why) { problems.push({ code: /^excluded/.test(why) ? 'attachExcluded' : 'attachBadName', path: p, why }); refused.add(p); continue; }
+    const media = attachMediaProblem(p, f && f.head);
+    if (media) { problems.push(media); refused.add(p); continue; }
+    // 型（§3.8）：名前が許されない型（実行できるもの・入れ物など）・どの役割にもない型は入れない。中身の検査の結果（f.problems。
+    // inspectAttachment）があれば、入れない問題（must・should）のあるものも入れない
+    const kept = opts.keep instanceof Set && opts.keep.has(p);
+    const np = kept ? null : nameProblem(p);
+    if (np) { problems.push(np); refused.add(p); continue; }
+    const cps = f && Array.isArray(f.problems) ? f.problems : [];
+    for (const x of cps) problems.push(x);
+    if (cps.some(blocking)) { refused.add(p); continue; }
+    sizeOf.set(p, f && Number.isFinite(f.size) ? f.size : null);
+    all.push(p);
+  }
+  for (const p of entries.keys()) if (!sizeOf.has(p) && !refused.has(p)) problems.push({ code: 'attachMissing', path: p });
+  const order = [...[...entries.keys()].filter((p) => sizeOf.has(p)), ...all.filter((p) => !entries.has(p)).sort()];
+  const include = [], list = [];
+  let total = 0;
+  for (const p of order) {
+    const n = sizeOf.get(p);
+    const e0 = entries.get(p) || carry.get(p) || null;
+    // 役割と型の組（pdf に CSV など）：入れない
+    const rp = e0 && ATTACH_ROLES.includes(e0.role) && !(opts.keep instanceof Set && opts.keep.has(p)) ? roleProblem(p, e0.role) : null;
+    if (rp) { problems.push(rp); continue; }
+    if (n !== null && n > L.fileBytes) { problems.push({ code: 'attachTooLarge', path: p, n, max: L.fileBytes }); continue; }
+    if (include.length >= L.count) { problems.push({ code: 'attachCount', path: p, max: L.count }); continue; }
+    if (n !== null && total + n > L.totalBytes) { problems.push({ code: 'attachTotal', path: p, n: total + n, max: L.totalBytes }); continue; }
+    total += n || 0;
+    include.push(p);
+    const e = entries.get(p) || carry.get(p) || null;
+    if (!e || !ATTACH_ROLES.includes(e.role)) { if (!e || !own(e, 'role')) problems.push({ code: 'attachNoRole', path: p }); continue; }
+    // 題が正しくない：入れるが一覧に出さない（知らせる）。説明が正しくない：説明を落として一覧に出す（知らせる）
+    if (!hasTitle(e)) { problems.push(blankTitle(e) ? { code: 'attachNoTitle', path: p } : { code: 'attachBadTitle', path: p, why: titleProblem(e.title), max: ATTACH_LIMITS.titleChars }); continue; }
+    if (own(e, 'description')) { const why = descriptionProblem(e.description); if (why) problems.push({ code: 'attachBadDescription', path: p, why, max: ATTACH_LIMITS.descriptionChars }); }
+    list.push(indexEntry({ ...e, path: p }));
+  }
+  return { include, list, problems, total, limits: L };
+}
+
+// 文書の索引の添付：files にあり、役割と題が正しく、パスが添付の場所で、型が役割に許され拡張子と媒体型が合うもの。題・役割・大きさ・塊を添える（読み手は塊を復号して hash を確かめてから渡す）
+export function attachmentsOf(index) {
+  const out = [];
+  if (!isObj(index) || !Array.isArray(index[FORMAT.ATTACH_KEY]) || !isObj(index.files) || !isObj(index.blobs)) return out;
+  const seen = new Set();
+  for (const e of index[FORMAT.ATTACH_KEY]) {
+    if (!isObj(e) || typeof e.path !== 'string' || !isAttachPath(e.path) || pathProblem(e.path) || !ATTACH_ROLES.includes(e.role) || !hasTitle(e) || seen.has(e.path)) continue;
+    if (!own(index.files, e.path)) continue;
+    const b = index.blobs[index.files[e.path]];
+    if (!isObj(b)) continue;
+    // §3.8：役割に許されない型、拡張子と媒体型の合わないものは出さない
+    const k = kindOfName(e.path);
+    if (!k || !k.kind || !roleAllows(e.role, k.kind) || b.mime !== k.mime) continue;
+    seen.add(e.path);
+    out.push({ path: e.path, role: e.role, title: e.title, ...(typeof e.description === 'string' && !descriptionProblem(e.description) ? { description: e.description } : {}), mime: b.mime, bytes: b.bytes, sha256: b.sha256, blob: index.files[e.path] });
+  }
+  return out;
+}
+// 索引の添付の一覧の問題（読み手の知らせ。文書は断らない：一覧から外すだけ）
+export function attachmentIndexWarnings(index) {
+  const w = [];
+  if (!isObj(index) || !own(index, FORMAT.ATTACH_KEY)) return w;
+  const list = index[FORMAT.ATTACH_KEY];
+  if (!Array.isArray(list)) return [`${FORMAT.ATTACH_KEY}: not an array; ignored`];
+  list.forEach((e, j) => {
+    const at = `${FORMAT.ATTACH_KEY}[${j}]`;
+    if (!isObj(e) || typeof e.path !== 'string') { w.push(`${at}: no path; ignored`); return; }
+    if (!isAttachPath(e.path) || pathProblem(e.path)) { w.push(`${at}: "${e.path.slice(0, 80)}" is not a path under ${PREFIX}; ignored`); return; }
+    if (!ATTACH_ROLES.includes(e.role)) w.push(`${at}: role "${String(e.role).slice(0, 40)}" is not one of ${ATTACH_ROLES.join(', ')}; ignored`);
+    else if (!hasTitle(e)) w.push(blankTitle(e) ? `${at}: "${e.path.slice(0, 80)}" has no title (required); ignored` : `${at}: "${e.path.slice(0, 80)}": the title ${titleProblem(e.title)} (at most ${ATTACH_LIMITS.titleChars} characters, one line); ignored`);
+    else if (!isObj(index.files) || !own(index.files, e.path)) w.push(`${at}: "${e.path.slice(0, 80)}" is not in files; ignored`);
+    else {
+      // 型（§3.8）：名前の型が役割に許されないか、塊の媒体型が名前の型と違う（再生器はダウンロードに出さない）
+      const k = kindOfName(e.path), b = isObj(index.blobs) ? index.blobs[index.files[e.path]] : null;
+      if (!k || !k.kind) w.push(`${at}: "${e.path.slice(0, 80)}" is not a type that may be attached (${k && k.forbidden ? k.forbidden : 'not allowed'}); players do not offer it`);
+      else if (!roleAllows(e.role, k.kind)) w.push(`${at}: "${e.path.slice(0, 80)}" (${k.kind}) is not allowed for the role ${e.role}; players do not offer it`);
+      else if (isObj(b) && b.mime !== k.mime) w.push(`${at}: "${e.path.slice(0, 80)}" has the media type ${String(b.mime).slice(0, 80)}, expected ${k.mime}; players do not offer it`);
+      if (own(e, 'description') && descriptionProblem(e.description)) w.push(`${at}: the description ${descriptionProblem(e.description)}; not shown`);
+    }
+  });
+  return w;
+}
+
+// ダウンロードの名前：パスの最後の部分。制御文字と、OS が断る字（\ / : * ? " < > |）は _ に。空なら "attachment"
+export function attachmentName(p) {
+  const n = String(p || '').split('/').pop().replace(/[\u0000-\u001f\u007f-\u009f\\/:*?"<>|]/g, '_').trim();
+  return n || 'attachment';
+}
+
+const FORBIDDEN_TEXT = { script: 'a file type that operating systems run or open as a script', executable: 'an executable', wasm: 'WebAssembly', 'office-legacy': 'a legacy binary Office or RTF document', 'office-macro': 'a macro-enabled Office document',
+  html: 'HTML', svg: 'SVG', egatari: `another ${FORMAT.DISPLAY_NAME} file`, archive: 'an archive or container' };
+const UNSAFE_TEXT = { javascript: 'the PDF contains JavaScript', 'auto-action': 'the PDF runs an action when opened', launch: 'the PDF can launch programs', 'embedded-file': 'the PDF carries embedded files',
+  action: 'the PDF has actions other than going to a place in the document or opening a link', 'active-content': 'the PDF has active content', macro: 'the document contains macros', activex: 'the document contains ActiveX controls', 'embedded-object': 'the document contains embedded objects',
+  'external-link': 'the document refers to external files or data', 'external-data': 'the document fetches external data', dde: 'the spreadsheet uses DDE', 'field-code': 'the document has a field code that runs or fetches',
+  'remote-template': 'the document uses a remote template' };
+// 書き出しの知らせ（英語、'portable: …'）
+export function problemText(x) {
+  const p = x.path ? `"${x.path}"` : '';
+  switch (x.code) {
+    case 'attachBadConfig': return `attachments: ${x.why}`;
+    case 'attachBadName': return `attachment ${p}: ${x.why}; not included`;
+    case 'attachExcluded': return `attachment ${p}: ${x.why}; not included`;
+    case 'attachDuplicate': return `attachment ${p} is listed twice (also as "${x.other}"); the second entry is ignored`;
+    case 'attachBadRole': return `attachment ${p}: role "${x.role}" is not one of ${ATTACH_ROLES.join(', ')}; it is included but not listed for readers`;
+    case 'attachBadTitle': return `attachment ${p}: the title ${x.why || 'is not valid'} (at most ${x.max} characters, one line); it is included but not listed for readers`;
+    case 'attachMissing': return `attachment ${p} is listed in ${FORMAT.CONFIG_FILE} but the file does not exist`;
+    case 'attachTooLarge': return `attachment ${p} is ${x.n} bytes, over the limit of ${x.max}; not included`;
+    case 'attachTotal': return `attachment ${p}: the attachments would be ${x.n} bytes together, over the limit of ${x.max}; not included`;
+    case 'attachCount': return `attachment ${p}: more than ${x.max} attachments; not included`;
+    case 'attachNoTitle': return `attachment ${p} has no title in ${FORMAT.CONFIG_FILE} (required); it is included but not listed for readers`;
+    case 'attachMedia': return `attachment ${p} is ${x.kind === 'video' ? 'a video' : 'audio'} (${x.by === 'content' ? 'by its content' : 'by its name'}); audio and video are not attachments, not included`;
+    case 'attachType': return x.role ? `attachment ${p}: a .${x.ext} file is not allowed for the role ${x.role} (allowed: ${(ROLE_KINDS[x.role] || []).join(', ')}); not included` : `attachment ${p}: .${x.ext} is not a type that may be attached (§3.8); not included`;
+    case 'attachForbidden': return `attachment ${p} is ${FORBIDDEN_TEXT[x.kind] || x.kind} (${x.by === 'content' ? 'by its content' : 'by its name'}), which must not be attached (§3.8); not included`;
+    case 'attachMismatch': return `attachment ${p}: the content is not ${x.kind}${x.actual ? ` (it looks like ${x.actual})` : ''}${x.why ? ` (${x.why})` : ''}; not included`;
+    case 'attachPolyglot': return `attachment ${p} is also ${x.also} (a file of two types); not included`;
+    case 'attachUnsafe': return `attachment ${p}: ${UNSAFE_TEXT[x.what] || x.what}${x.detail ? ` (${x.detail})` : ''}, not allowed for attachments (§3.8); not included`;
+    case 'attachUnchecked': return `attachment ${p} cannot be checked (${x.why}); not included`;
+    case 'attachInjection': return `attachment ${p}: ${x.n} value(s) start with = + - @ or a tab and may be read as formulas by a spreadsheet${x.row ? ` (first at row ${x.row}, column ${x.col})` : x.where ? ` (in ${x.where})` : ''}; check before sharing`;
+    case 'attachPrivate': return `attachment ${p} seems to contain a ${x.what}; check before sharing`;
+    case 'attachBadDescription': return `attachment ${p}: the description ${x.why}; it is left out`;
+    case 'attachNoRole': return `attachment ${p} has no role in ${FORMAT.CONFIG_FILE} (${ATTACH_ROLES.join(', ')}); it is included but not listed for readers`;
+    default: return `attachment ${p}: ${x.code}`;
+  }
+}

package/kit/core/audio-core.mjs

@@ -0,0 +1,263 @@
+// 段階の音声の後処理と記録（編集アプリの音声の板 app/audio-panel.js と、試験・道具が共有する。node: も fs も使わない）
+//
+// 後処理は tts/core.py と同じ意図・同じ数にする（同じ入力なら、同じ長さ・同じ音量の音声になる。tools/test-audio-core.mjs が
+// ffmpeg と比べる）：
+//   モノラル（チャンネルの平均）→ 44.1 kHz（窓付き sinc）→ 前後の無音を削る（-45 dB、20 ms の窓の RMS、削った後に 50 ms 残す。
+//   ffmpeg の silenceremove=start_periods=1:start_silence=0.05:start_threshold=-45dB を前と、逆にして後ろに）→
+//   音量を -20 LUFS に（EBU R128 / ITU-R BS.1770 の積分ラウドネスを測り、一律のゲインで当てる。ffmpeg の loudnorm の linear=true）
+//   違い：ffmpeg の loudnorm は、一律のゲインでトゥルーピークが -1.5 dBTP を超えるときは動的な処理に切り替える（抑揚が変わる）。
+//   ここでは切り替えず、ピークが -1.5 dBTP になるところでゲインを止める（小さめになるが、抑揚は変えない）
+// 行間：同じ段階の中の発言（ターン）の間に PAUSE_MS の無音（tts/synth.py と同じ。{cue} の区切りの間には入れない）。
+// 段階の末尾の間（pad_after）は実行系が足すので、音声には付けない
+//
+//   processTake(channels, sr)              → {pcm: Float32Array（44.1 kHz モノラル）, sr, dur, gainDb, loudness, peakDb, trimmed: {head, tail}}
+//   joinParts(turns, sr)                    turns：[[Float32Array…]…]（ターンごとの {cue} の部分）→ {pcm, cues}
+//   integratedLoudness(pcm, sr)             LUFS（測れなければ null）
+//   truePeakDb(pcm)                         4 倍の補間で見たピーク（dBTP）
+//   encodeWav(pcm, sr) / decodeWav(bytes)   16 bit の WAV
+//   clickCut(times, sr, length) / applyClickCut(pcm, cut)   録音の開始・停止の操作音を除く範囲と、その適用
+//   cuesFromTaps(taps, n, {head, dur})      録音中に C で置いた時刻 → 音声の cue（数が n と違えば sync none）
+//   takeEntry({...})                        audio/manifest.json の段階の記録（kind・inputHash・recipe・sync。format spec §5）
+//   setManifestEntry(text, key, entry, order)   manifest の文字列に段階の記録を入れる（ほかの段階の記録はそのまま）
+//   audioState(entry, seg, segJson)         'fresh' | 'stale' | 'unknown'（§5.4。inputHash の無い manifest は TTS の控えの digest で）
+
+export const SR = 44100;                 // tts/core.py の normalize_level・concat と同じ（-ar 44100）
+export const PAUSE_MS = 350;             // tts/core.py の PAUSE_MS
+export const TRIM = Object.freeze({ thresholdDb: -45, keepS: 0.05, windowS: 0.02 });   // TRIM_THRESHOLD・TRIM_KEEP_S（窓は silenceremove の既定）
+export const TARGET = Object.freeze({ lufs: -20, tpDb: -1.5, lra: 11 });               // TARGET_LUFS・TARGET_TP_DB・TARGET_LRA
+// MP3：組み立ての AAC（64 kbps・モノラル）と同じ大きさの見当。delaySamples：LAME の符号化の遅れ 576 と、復号の遅れ 529（LAME の
+// 情報フレームを書かないので、ブラウザと ffmpeg の復号器は先頭のこれだけを余分に出す。tools/test-audio-core.mjs と test-audio.mjs が測る）。
+// その秒数を記録の startOffset（format spec §5.2）に書き、実行系はそこから鳴らす
+export const MP3 = Object.freeze({ kbps: 64, sr: SR, channels: 1, delaySamples: 576 + 529, startOffset: Math.round(((576 + 529) / SR) * 1e6) / 1e6 });
+// 後処理の版（記録の recipe.processing。数を変えたら名前も変える。format spec §5.2 の例と同じ形）
+// tts/core.py と同じ数だが、トゥルーピークが -1.5 dBTP を超えるところで ffmpeg の loudnorm は動的な処理に切り替え、ここは一律のゲインを
+// 止める（cap）。振る舞いが違うので、tts/core.py の音とは別の名前にする
+export const PROCESSING = 'trim-45-loud-20-cap-v1';
+// 1 つの音声の上限：長さ（秒）と、読む・書くバイト数（取り込む音声のファイル・作業場所の音声）
+export const AUDIO_LIMITS = Object.freeze({ maxSeconds: 600, fileBytes: 64 * 1048576 });
+
+import { inputHash, sha256Hex } from './portable.mjs';
+import { toMono, resample, encodeWav, decodeWav } from './wav-core.mjs';
+export { toMono, resample, encodeWav, decodeWav };   // 置き場は wav-core.mjs（portable.mjs → parse5 の鎖を引かずに使えるように。colab/irodori_node.mjs）
+
+const isObj = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+const own = (o, k) => o != null && Object.prototype.hasOwnProperty.call(o, k);
+
+// 録音モードの操作音を除く範囲（[head, tail)。元の標本化周波数での位置）。時刻は performance.now() と同じミリ秒。
+// recStart は MediaRecorder.onstart の時刻。解放が来なければ押下から 120 ms、そこからさらに 30 ms を除く。
+// inputLatency は入力の遅れ（ms、最大 1 秒）。実際の開始操作があれば、開始前に解放されても先頭の 30 ms と遅れを除く。
+// processTake の前に録音モードだけが使う（TTS・取り込みの後処理と PROCESSING の名前は変えない）。
+export function clickCut({ startDown, startUp, stopDown, recStart, startEvent = false, inputLatency = 0 }, sampleRate, length) {
+  if (![startDown, recStart, sampleRate, length, inputLatency].every(Number.isFinite) || sampleRate <= 0 || length < 0 || !Number.isInteger(length) || inputLatency < 0) throw new RangeError('invalid click-cut timeline');
+  inputLatency = Math.min(1000, inputLatency);
+  const clamp = (n) => Math.max(0, Math.min(length, n));
+  const up = Number.isFinite(startUp) ? startUp : startDown + 120;
+  const headMs = Math.max(startEvent ? 30 : -Infinity, Math.max(up, startDown + 120) + 30 - recStart) + inputLatency;
+  const head = clamp(Math.ceil(headMs * sampleRate / 1000));
+  const tail = Number.isFinite(stopDown) ? clamp(Math.floor((stopDown - 30 - recStart + inputLatency) * sampleRate / 1000)) : length;
+  return { head, tail };
+}
+// 範囲が重なる短い録音は空にし、理由を返す（slice の負の位置・長さに頼らない）。入力は変えない。
+export function applyClickCut(samples, { head, tail }) {
+  const pcm = tail > head ? samples.slice(head, tail) : new Float32Array(0);
+  return { pcm, reason: pcm.length ? null : 'click-cut-empty' };
+}
+
+// ---------------------------------------------------------------- 無音を削る（silenceremove の rms 検出と同じ：直前の窓の RMS がしきい値を超えた所）
+// 返すもの：音のある最初の標本の位置（なければ -1）
+function onset(x, sr, step) {
+  const win = Math.max(1, Math.round(TRIM.windowS * sr)), thr = Math.pow(10, TRIM.thresholdDb / 20), thr2 = thr * thr * win;
+  let sum = 0;
+  const n = x.length;
+  for (let j = 0; j < n; j++) {
+    const i = step > 0 ? j : n - 1 - j;
+    sum += x[i] * x[i];
+    if (j >= win) { const o = step > 0 ? j - win : n - 1 - (j - win); sum -= x[o] * x[o]; }
+    if (sum > thr2) return j;
+  }
+  return -1;
+}
+export function trimSilence(x, sr) {
+  const keep = Math.round(TRIM.keepS * sr);
+  const a = onset(x, sr, 1);
+  if (a < 0) return { pcm: new Float32Array(0), head: x.length, tail: 0 };
+  const b = onset(x, sr, -1);
+  const start = Math.max(0, a - keep), end = Math.min(x.length, x.length - b + keep);
+  return { pcm: x.slice(start, end), head: start, tail: x.length - end };
+}
+
+// ---------------------------------------------------------------- ラウドネス（ITU-R BS.1770-4。K 特性の係数は標本化周波数から作る：libebur128 と同じ式）
+function kWeight(sr) {
+  let f0 = 1681.974450955533, G = 3.999843853973347, Q = 0.7071752369554196;
+  let K = Math.tan((Math.PI * f0) / sr);
+  const Vh = Math.pow(10, G / 20), Vb = Math.pow(Vh, 0.4996667741545416);
+  let a0 = 1 + K / Q + K * K;
+  const pre = { b: [(Vh + (Vb * K) / Q + K * K) / a0, (2 * (K * K - Vh)) / a0, (Vh - (Vb * K) / Q + K * K) / a0], a: [1, (2 * (K * K - 1)) / a0, (1 - K / Q + K * K) / a0] };
+  f0 = 38.13547087602444; Q = 0.5003270373238773; K = Math.tan((Math.PI * f0) / sr);
+  a0 = 1 + K / Q + K * K;
+  const rlb = { b: [1, -2, 1], a: [1, (2 * (K * K - 1)) / a0, (1 - K / Q + K * K) / a0] };
+  return [pre, rlb];
+}
+function biquad(x, { b, a }) {
+  const y = new Float64Array(x.length);
+  let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
+  for (let n = 0; n < x.length; n++) {
+    const v = x[n], o = b[0] * v + b[1] * x1 + b[2] * x2 - a[1] * y1 - a[2] * y2;
+    y[n] = o; x2 = x1; x1 = v; y2 = y1; y1 = o;
+  }
+  return y;
+}
+// 積分ラウドネス（LUFS）。400 ms の区間を 100 ms ずつずらし、-70 LUFS の絶対ゲートと -10 LU の相対ゲート。短すぎる・無音なら null
+export function integratedLoudness(x, sr) {
+  let d = x;
+  for (const f of kWeight(sr)) d = biquad(d, f);
+  const block = Math.round(0.4 * sr), hop = Math.round(0.1 * sr);
+  if (d.length < block) return null;
+  const z = [];
+  // 累積和で区間の平均を取る（区間は 400 ms をまるごと含むものだけ）
+  const cum = new Float64Array(d.length + 1);
+  for (let i = 0; i < d.length; i++) cum[i + 1] = cum[i] + d[i] * d[i];
+  for (let s = 0; s + block <= d.length; s += hop) z.push((cum[s + block] - cum[s]) / block);
+  const L = (e) => -0.691 + 10 * Math.log10(e);
+  const abs = z.filter((e) => e > 0 && L(e) > -70);
+  if (!abs.length) return null;
+  const rel = L(abs.reduce((a, b) => a + b, 0) / abs.length) - 10;
+  const keep = abs.filter((e) => L(e) > rel);
+  if (!keep.length) return null;
+  return L(keep.reduce((a, b) => a + b, 0) / keep.length);
+}
+// トゥルーピーク（dBTP）：4 倍に補間した波形の絶対値の最大（BS.1770 の考え方。補間は窓付き sinc の 48 タップ）
+export function truePeakDb(x) {
+  let peak = 0;
+  for (let i = 0; i < x.length; i++) { const v = Math.abs(x[i]); if (v > peak) peak = v; }
+  const OS = 4, HALF = 12;
+  const taps = [];
+  for (let p = 1; p < OS; p++) {
+    const frac = p / OS, t = [];
+    for (let k = -HALF + 1; k <= HALF; k++) {
+      const d = k - frac, sinc = Math.sin(Math.PI * d) / (Math.PI * d);
+      t.push(sinc * (0.5 + 0.5 * Math.cos((Math.PI * d) / HALF)));
+    }
+    taps.push(t);
+  }
+  for (let i = 0; i + 1 < x.length; i++) {
+    // 隣の標本の片方でも大きくなければ、その間の補間がピークを超えることは少ない：大きな所だけ調べる（ピークの 1/2 以上）
+    if (Math.max(Math.abs(x[i]), Math.abs(x[i + 1])) < peak * 0.5) continue;
+    for (const t of taps) {
+      let s = 0;
+      for (let k = -HALF + 1, j = 0; k <= HALF; k++, j++) { const idx = i + k; if (idx >= 0 && idx < x.length) s += x[idx] * t[j]; }
+      const v = Math.abs(s); if (v > peak) peak = v;
+    }
+  }
+  return peak > 0 ? 20 * Math.log10(peak) : -Infinity;
+}
+// 音量を揃える：測れないもの（短すぎる・無音）はそのまま（tts/core.py と同じ：音が消えるよりはレベルが揃わないほうがよい）
+export function normalizeLevel(x, sr) {
+  const loud = integratedLoudness(x, sr);
+  if (loud === null || !Number.isFinite(loud)) return { pcm: Float32Array.from(x), gainDb: 0, loudness: loud, peakDb: truePeakDb(x) };
+  const tp = truePeakDb(x);
+  let gainDb = TARGET.lufs - loud;
+  if (Number.isFinite(tp) && tp + gainDb > TARGET.tpDb) gainDb = TARGET.tpDb - tp;
+  const g = Math.pow(10, gainDb / 20), out = new Float32Array(x.length);
+  for (let i = 0; i < x.length; i++) out[i] = x[i] * g;
+  return { pcm: out, gainDb, loudness: loud, peakDb: tp + gainDb };
+}
+
+// ---------------------------------------------------------------- 1 つの音声（録音・TTS の 1 行・取り込んだファイル）を整える
+export function processTake(channels, sr, { normalize = true, trim = true } = {}) {
+  let x = toMono(channels);
+  if (x.length > AUDIO_LIMITS.maxSeconds * sr) throw Object.assign(new Error(`audio longer than ${AUDIO_LIMITS.maxSeconds} s`), { code: 'audio-too-long' });
+  x = resample(x, sr, SR);
+  let head = 0, tail = 0;
+  if (trim) { const t = trimSilence(x, SR); x = t.pcm; head = t.head; tail = t.tail; }
+  const n = normalize ? normalizeLevel(x, SR) : { pcm: x, gainDb: 0, loudness: integratedLoudness(x, SR), peakDb: truePeakDb(x) };
+  return { pcm: n.pcm, sr: SR, dur: round3(n.pcm.length / SR), gainDb: n.gainDb, loudness: n.loudness, peakDb: n.peakDb, trimmed: { head: round3(head / SR), tail: round3(tail / SR) } };
+}
+const round3 = (v) => Math.round(v * 1000) / 1000;
+
+// 段階の音声：ターンの間に PAUSE_MS の無音。cues は 2 つ目からの {cue} の部分の始まり（秒。tts/synth.py の synth_segment と同じ）
+export function joinParts(turns, sr = SR) {
+  const pause = Math.round((PAUSE_MS / 1000) * sr);
+  const pieces = [], cues = [];
+  let n = 0;
+  turns.forEach((parts, ti) => {
+    if (ti > 0 && pause > 0) { pieces.push(new Float32Array(pause)); n += pause; }
+    parts.forEach((p, pi) => {
+      if (pi > 0) cues.push(round3(n / sr));
+      if (p && p.length) { pieces.push(p); n += p.length; }
+    });
+  });
+  const out = new Float32Array(n);
+  let o = 0;
+  for (const p of pieces) { out.set(p, o); o += p.length; }
+  return { pcm: out, cues, dur: round3(n / sr) };
+}
+
+// 録音中に C を押した時刻（録音の始めからの秒。生の時刻）を、後処理した音声の cue にする（録音モード。#47・#24）。
+// head：後処理で前から削った秒（processTake の trimmed.head）、dur：後処理した音声の長さ。時刻は head を引いて [0, dur] に収める。
+// 押した数が区切りの数 n と違う・時刻が前後する・n が 0 なら sync none（cues なし）：間違った同期は作らない（format spec §5.3）。
+// 戻り値：{sync: 'manual', cues} か {sync: 'none', cues: null, taps（押した数）}
+export function cuesFromTaps(taps, n, { head = 0, dur = Infinity } = {}) {
+  const t = Array.isArray(taps) ? taps.filter((x) => typeof x === 'number' && Number.isFinite(x)) : [];
+  if (!(n > 0) || t.length !== n || t.some((x, j) => j > 0 && x < t[j - 1])) return { sync: 'none', cues: null, taps: t.length };
+  const hi = Number.isFinite(dur) ? dur : Infinity;
+  return { sync: 'manual', cues: t.map((x) => round3(Math.max(0, Math.min(hi, x - head)))) };
+}
+
+// ---------------------------------------------------------------- 記録（audio/manifest.json の段階。format spec §5：kind・inputHash・recipe・sync）
+// source：{kind: 'recorded' | 'tts' | 'imported', recipe?（tts のとき。engine・model・voice・seed・dictionary・processing）}
+// cues：{cue} の区切りの時刻（TTS で部分ごとに作ったとき）。録音・取り込みは区切りを置いていないので sync "none"（cues は空）
+// processing：後処理の版（すべての種類。§5.2）。startOffset：符号化の遅れ（MP3 のとき。0 なら書かない）。
+// 機器の名前・元のファイル名など人を特定しうる記録は書かない（§3.6。ここに渡す項目はこれだけ）
+// sync：'manual'（録音中に C で置いた cue。cues が配列のときだけ）を渡せる。渡さなければ cues があれば auto、なければ none
+export function takeEntry({ file, dur, cues = null, kind, inputHash, recipe = null, processing = PROCESSING, startOffset = 0, sync = null }) {
+  if (!['recorded', 'tts', 'imported'].includes(kind)) throw new Error('bad take kind: ' + kind);
+  if (!(typeof dur === 'number' && dur > 0)) throw Object.assign(new Error('the take is empty (no sound after trimming silence)'), { code: 'audio-empty' });
+  const e = { file, dur: round3(dur), cues: Array.isArray(cues) ? cues.slice() : [] };
+  e.sync = sync === 'manual' && Array.isArray(cues) ? 'manual' : Array.isArray(cues) ? 'auto' : 'none';
+  if (kind === 'tts') { if (!isObj(recipe)) throw new Error('tts take without recipe'); e.engine = String(recipe.engine); }
+  e.kind = kind;
+  e.inputHash = typeof inputHash === 'string' ? inputHash : null;
+  if (kind === 'tts') e.recipe = recipe;
+  if (typeof processing === 'string') e.processing = processing;
+  if (typeof startOffset === 'number' && startOffset > 0 && startOffset <= 1) e.startOffset = startOffset;
+  return e;
+}
+// manifest の文字列（なければ null）に、段階 key の記録を入れる（ほかの段階の記録はそのまま。並びは order（口述原稿の段階の順）に）。
+// 形の違う manifest（JSON でない・segments が object でない）は断る（上書きして消さない）
+export function setManifestEntry(text, key, entry, order = []) {
+  let man = { segments: {} };
+  if (text != null && String(text).trim()) {
+    man = JSON.parse(text);
+    if (!isObj(man) || (own(man, 'segments') && !isObj(man.segments))) throw Object.assign(new Error('audio/manifest.json is not {segments: {...}}'), { code: 'bad-manifest' });
+    if (!own(man, 'segments')) man.segments = {};
+  }
+  const seg = { ...man.segments };
+  if (entry === null) delete seg[key]; else seg[key] = entry;
+  // 口述原稿の順。口述原稿にない段階は、今の並びのまま後ろに
+  const pos = new Map(order.map((k, i) => [k, i]));
+  const was = new Map(Object.keys(seg).map((k, i) => [k, i]));
+  const rank = (k) => (pos.has(k) ? pos.get(k) : 1e9 + was.get(k));
+  const keys = Object.keys(seg).sort((a, b) => rank(a) - rank(b));
+  man.segments = Object.fromEntries(keys.map((k) => [k, seg[k]]));
+  return JSON.stringify(man, null, 1) + '\n';
+}
+// 音声のファイルの名前：中身の sha256 の先頭 16 字（同じ中身は同じ名前。前の取り直しのファイルは消さない：tts/synth.py と同じ）
+export const takeFileName = (kind, sha256, ext = 'mp3') => `${kind === 'tts' ? 'tts' : kind === 'imported' ? 'imp' : 'rec'}_${String(sha256).slice(0, 16)}.${ext}`;
+
+// tts/synth.py の音声の digest（kit/narration.mjs の segDigest と同じ値。ブラウザでも作れるように Web Crypto で）
+export const segDigest = async (seg, voice = {}) => (await sha256Hex(JSON.stringify({ turns: seg.turns.map((t) => [t.role, t.ttsParts]), voice }))).slice(0, 12);
+// 音声が今の口述原稿に合っているか（§5.4）。entry：manifest の段階の記録、seg：今の口述原稿のその段階（parseNarration。なければ古い）、
+// segJson：audio/seg_<digest>.json（任意。tts/synth.py の控え）
+//   inputHash がある → 合えば 'fresh'、違えば 'stale'。null → 'stale'（分からない）。無い（tts/synth.py の manifest）→ 控えの声で digest を
+//   作り直して比べ、控えがなければ 'unknown'（知らせない）
+export async function audioState(entry, seg, segJson = null) {
+  if (!isObj(entry)) return 'unknown';
+  if (!seg) return 'stale';
+  if (own(entry, 'inputHash')) {
+    if (entry.inputHash === null) return 'stale';
+    return entry.inputHash === await inputHash(seg) ? 'fresh' : 'stale';
+  }
+  if (isObj(segJson) && isObj(segJson.voice) && typeof entry.digest === 'string') return (await segDigest(seg, segJson.voice)) === entry.digest ? 'fresh' : 'stale';
+  return 'unknown';
+}

package/kit/core/backup-name.mjs

@@ -0,0 +1,8 @@
+// 書き換える前の控えの名前（.cache/edits/<時刻>-<名前>）。開発サーバー・npm run の書き込み（kit/safe-fs.mjs）と
+// 編集アプリ（app/fsx.js・app/memfs.js）が同じものを使う。控えの掃除は、この形の名前のファイルだけを消す（ほかのものには触れない）
+//   backupStamp(ms)    時刻：new Date(ms).toISOString() の : と . を - にしたもの
+//   BACKUP_RE          控えの名前：<時刻>-<元の名前>（同じ時刻の控えは <時刻>-<番号>-<元の名前>）
+//   isBackupName(name)
+export const BACKUP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z-[^/\\]+$/;
+export const backupStamp = (ms = Date.now()) => new Date(ms).toISOString().replace(/[:.]/g, '-');
+export const isBackupName = (name) => typeof name === 'string' && BACKUP_RE.test(name);

package/kit/core/bounded-html.mjs

@@ -0,0 +1,57 @@
+// 上限つきの HTML の解析（持ち運べる 1 ファイルの読み取り。format spec §11：確保の前に上限を確かめる）。
+// parse5 の解析の規則（字句と木の組み立て）はそのままに、木を作る口（tree adapter）を差し替えて、解析の途中で上限を数える：
+//   要素の数・属性の数・入れ子の深さ・残す文字の大きさ。超えたらその場で止める（全部の木を作ってから数えない）
+// 残すのは watch(attrs) が真の要素の文字と位置だけで、ほかの文字・注釈の中身・位置は捨てる（木の形だけを保つ）。
+// 何も実行しない（parse5 は解析するだけ）。解析はブラウザがスクリプトを動かすときと同じ規則（scriptingEnabled: true。<noscript> の中は文字。
+// format spec §6：判定・境目・持ち運べる形式の読み取りはどれも同じ規則で、表示するブラウザと食い違わない）。Node にもブラウザにも依存しない
+//
+//   boundedParse(text, {watch, limits, fail})
+//     watch(attrs)  その要素の文字（直接の子の文字）と位置を残すか
+//     limits        {elements, attributes, nesting, keptChars}
+//     fail(code, message)  上限を超えたときに呼ぶ（投げること）
+import { parse, defaultTreeAdapter as D } from 'parse5';
+
+export const PARSE_LIMITS = Object.freeze({ elements: 200000, attributes: 400000, nesting: 512, keptChars: 128 * 1024 * 1024 });
+
+export function boundedParse(text, { watch = () => false, limits = PARSE_LIMITS, fail } = {}) {
+  const L = { ...PARSE_LIMITS, ...(limits || {}) };
+  const stop = fail || ((code, message) => { throw Object.assign(new Error(message), { code }); });
+  let elements = 0, attributes = 0, kept = 0;
+  const countAttrs = (n) => { attributes += n; if (attributes > L.attributes) stop('too-complex', `the document has more than ${L.attributes} attributes`); };
+  const depthOf = (parent, node) => {
+    if (!node || !node.tagName) return;
+    node.__d = (parent && parent.__d ? parent.__d : 0) + 1;
+    if (node.__d > L.nesting) stop('too-complex', `elements are nested more than ${L.nesting} deep`);
+  };
+  // 文字：残す要素の子なら残す。ほかは中身のない文字の節を 1 つだけ置く（兄弟の並びを保つ。parse5 は直前の兄弟を文字の節として扱う）
+  const keep = (parent, t) => { kept += t.length; if (kept > L.keptChars) stop('too-complex', 'the document keeps too much text'); };
+  const adapter = {
+    ...D,
+    createElement(tagName, namespaceURI, attrs) {
+      if (++elements > L.elements) stop('too-complex', `the document has more than ${L.elements} elements`);
+      countAttrs(attrs.length);
+      const el = D.createElement(tagName, namespaceURI, attrs);
+      if (watch(attrs)) el.__w = true;
+      return el;
+    },
+    createCommentNode() { return D.createCommentNode(''); },
+    appendChild(parent, node) { D.appendChild(parent, node); depthOf(parent, node); },
+    insertBefore(parent, node, ref) { D.insertBefore(parent, node, ref); depthOf(parent, node); },
+    adoptAttributes(recipient, attrs) { countAttrs(attrs.length); D.adoptAttributes(recipient, attrs); },
+    insertText(parent, t) {
+      if (parent.__w) { keep(parent, t); return D.insertText(parent, t); }
+      const last = parent.childNodes[parent.childNodes.length - 1];
+      if (!(last && last.nodeName === '#text')) D.appendChild(parent, D.createTextNode(''));
+    },
+    insertTextBefore(parent, t, ref) {
+      if (parent.__w) { keep(parent, t); return D.insertTextBefore(parent, t, ref); }
+      const i = parent.childNodes.indexOf(ref), prev = parent.childNodes[i - 1];
+      if (!(prev && prev.nodeName === '#text')) D.insertBefore(parent, D.createTextNode(''), ref);
+    },
+    // 位置は残す要素のものだけ（文字の節の位置も捨てる）
+    setNodeSourceCodeLocation(node, loc) { if (node && node.__w) node.sourceCodeLocation = loc; },
+    getNodeSourceCodeLocation(node) { return node ? node.sourceCodeLocation : undefined; },
+    updateNodeSourceCodeLocation(node, end) { if (node && node.__w && node.sourceCodeLocation) node.sourceCodeLocation = { ...node.sourceCodeLocation, ...end }; },
+  };
+  return parse(String(text), { scriptingEnabled: true, sourceCodeLocationInfo: true, treeAdapter: adapter });
+}