@onjmin/dtm 2.1.12 → 2.1.14

package/dist/index.mjs

@@ -2657,7 +2657,7 @@ var buildChordPlacements = (options) => {
   return placements;
 };
 
-// node_modules/.pnpm/@onjmin+koe@1.0.5/node_modules/@onjmin/koe/dist/index.js
+// node_modules/.pnpm/@onjmin+koe@1.0.10/node_modules/@onjmin/koe/dist/index.js
 var u8 = Uint8Array;
 var u16 = Uint16Array;
 var i32 = Int32Array;
@@ -3045,6 +3045,130 @@ var Worldline = class _Worldline {
    * @returns Float32 PCM, or null when `pcm` is shorter than
    *          {@link MIN_WORLDLINE_SAMPLES} (too short for stable F0 analysis).
    */
+  renderPhrase(params) {
+    const {
+      units: units2,
+      pitch,
+      gender = 0.5,
+      tension = 0.5,
+      breathiness = 0.5,
+      voicing = 1,
+      tempo = 120
+    } = params;
+    if (units2.length === 0) return null;
+    const WL = this.wasm;
+    const FS2 = WORLDLINE_SAMPLE_RATE;
+    let totalMs = 0;
+    for (const u of units2) {
+      const endMs = u.posMs + u.lengthMs;
+      if (endMs > totalMs) totalMs = endMs;
+    }
+    const ps = WL._PhraseSynthNew();
+    if (!ps) return null;
+    const pointersToFree = [];
+    for (const u of units2) {
+      if (!u.pcm || u.pcm.length < MIN_WORLDLINE_SAMPLES) continue;
+      const reqPtr = WL._malloc(SYNTH_REQ_SIZE);
+      if (!reqPtr) continue;
+      pointersToFree.push(reqPtr);
+      const samplePtr = WL._malloc(u.pcm.length * 8);
+      if (!samplePtr) continue;
+      pointersToFree.push(samplePtr);
+      WL.HEAPF64.set(u.pcm, samplePtr >> 3);
+      const sv = (off, val, type) => WL.setValue(reqPtr + off, val, type);
+      sv(0, FS2, "i32");
+      sv(4, u.pcm.length, "i32");
+      sv(8, samplePtr, "*");
+      sv(12, 0, "i32");
+      sv(16, 0, "*");
+      sv(20, u.tone ?? 69, "i32");
+      sv(24, 100, "double");
+      sv(32, 0, "double");
+      sv(40, u.requiredLengthMs ?? u.lengthMs, "double");
+      sv(48, u.consonantMs, "double");
+      const cutMs = u.cutMs ?? WL_FRAME_MS * 2;
+      sv(56, cutMs, "double");
+      sv(64, u.volume ?? 100, "double");
+      sv(72, 0, "double");
+      sv(80, tempo, "double");
+      sv(88, 0, "i32");
+      sv(92, 0, "*");
+      sv(96, 0, "i32");
+      sv(100, 0, "i32");
+      sv(104, 100, "i32");
+      sv(108, 0, "i32");
+      sv(112, 0, "i32");
+      sv(116, 100, "i32");
+      WL._PhraseSynthAddRequest(
+        ps,
+        reqPtr,
+        u.posMs,
+        u.skipMs,
+        u.lengthMs,
+        u.fadeInMs,
+        u.fadeOutMs,
+        0
+      );
+    }
+    totalMs += WL_FRAME_MS * 2;
+    const nFrames = Math.ceil(totalMs / WL_FRAME_MS) + 4;
+    const f0Arr = new Float64Array(nFrames);
+    const gArr = new Float64Array(nFrames);
+    const tArr = new Float64Array(nFrames);
+    const bArr = new Float64Array(nFrames);
+    const vArr = new Float64Array(nFrames);
+    for (let i2 = 0; i2 < nFrames; i2++) {
+      const tMs = i2 * WL_FRAME_MS;
+      f0Arr[i2] = sampleCurve(tMs, pitch, totalMs);
+      gArr[i2] = sampleCurve(tMs, gender, totalMs);
+      tArr[i2] = sampleCurve(tMs, tension, totalMs);
+      bArr[i2] = sampleCurve(tMs, breathiness, totalMs);
+      vArr[i2] = sampleCurve(tMs, voicing, totalMs);
+    }
+    const f0Ptr = WL._malloc(nFrames * 8);
+    const gPtr = WL._malloc(nFrames * 8);
+    const tPtr = WL._malloc(nFrames * 8);
+    const bPtr = WL._malloc(nFrames * 8);
+    const vPtr = WL._malloc(nFrames * 8);
+    if (f0Ptr && gPtr && tPtr && bPtr && vPtr) {
+      WL.HEAPF64.set(f0Arr, f0Ptr >> 3);
+      WL.HEAPF64.set(gArr, gPtr >> 3);
+      WL.HEAPF64.set(tArr, tPtr >> 3);
+      WL.HEAPF64.set(bArr, bPtr >> 3);
+      WL.HEAPF64.set(vArr, vPtr >> 3);
+      WL._PhraseSynthSetCurves(
+        ps,
+        f0Ptr,
+        gPtr,
+        tPtr,
+        bPtr,
+        vPtr,
+        nFrames,
+        WL_FRAME_MS
+      );
+    }
+    if (f0Ptr) WL._free(f0Ptr);
+    if (gPtr) WL._free(gPtr);
+    if (tPtr) WL._free(tPtr);
+    if (bPtr) WL._free(bPtr);
+    if (vPtr) WL._free(vPtr);
+    const yPtrPtr = WL._malloc(4);
+    let audio = null;
+    if (yPtrPtr) {
+      const outLen = WL._PhraseSynthSynth(ps, yPtrPtr, 0);
+      const yPtr = WL.getValue(yPtrPtr, "*");
+      if (outLen > 0 && yPtr) {
+        audio = new Float32Array(WL.HEAPF32.buffer, yPtr, outLen).slice();
+        WL._free(yPtr);
+      }
+      WL._free(yPtrPtr);
+    }
+    for (const ptr of pointersToFree) {
+      WL._free(ptr);
+    }
+    WL._PhraseSynthDelete(ps);
+    return audio;
+  }
   renderNote(params) {
     const {
       pcm,
@@ -3060,8 +3184,12 @@ var Worldline = class _Worldline {
     } = params;
     if (!pcm || pcm.length < MIN_WORLDLINE_SAMPLES) return null;
     const WL = this.wasm;
-    const FS = WORLDLINE_SAMPLE_RATE;
-    const basePitch = sampleCurve(preMs + durationMs / 2, pitch, preMs + durationMs);
+    const FS2 = WORLDLINE_SAMPLE_RATE;
+    const basePitch = sampleCurve(
+      preMs + durationMs / 2,
+      pitch,
+      preMs + durationMs
+    );
     const midiNote2 = Math.round(69 + 12 * Math.log2(basePitch / 440));
     const posMs = 0;
     const reqLen = preMs + durationMs;
@@ -3081,7 +3209,7 @@ var Worldline = class _Worldline {
     }
     WL.HEAPF64.set(pcm, samplePtr >> 3);
     const sv = (off, val, type) => WL.setValue(reqPtr + off, val, type);
-    sv(0, FS, "i32");
+    sv(0, FS2, "i32");
     sv(4, pcm.length, "i32");
     sv(8, samplePtr, "*");
     sv(12, 0, "i32");
@@ -3169,6 +3297,836 @@ var Worldline = class _Worldline {
     return audio;
   }
 };
+var RATE = 16e3;
+var HOP_MS = 2;
+var HOP = RATE * HOP_MS / 1e3;
+var FFT_SIZE = 512;
+var BINS = FFT_SIZE / 2;
+var PITCH_DECIM = 2;
+var PITCH_RATE = RATE / PITCH_DECIM;
+var WINDOW_CENTRE_MS = FFT_SIZE / 2 / RATE * 1e3;
+var DEFAULT_CACHE = "koe-tts-assets-v1";
+async function openCache(name) {
+  if (name === null) return null;
+  try {
+    if (typeof caches === "undefined") return null;
+    return await caches.open(name ?? DEFAULT_CACHE);
+  } catch {
+    return null;
+  }
+}
+async function cachedCopyIsCurrent(url2, cached, signal) {
+  let head;
+  try {
+    head = await fetch(url2, { method: "HEAD", signal, cache: "no-cache" });
+  } catch {
+    return true;
+  }
+  if (!head.ok) return true;
+  for (const name of ["etag", "last-modified", "content-length"]) {
+    const remote = head.headers.get(name);
+    const local = cached.headers.get(name);
+    if (remote && local) return remote === local;
+  }
+  return true;
+}
+async function fetchAsset(url2, options = {}) {
+  const { onProgress, signal, revalidate = true } = options;
+  const cache2 = await openCache(options.cacheName);
+  if (cache2) {
+    try {
+      const hit = await cache2.match(url2);
+      if (hit && (!revalidate || await cachedCopyIsCurrent(url2, hit, signal))) {
+        const total2 = Number(hit.headers.get("content-length")) || 0;
+        onProgress?.({ url: url2, loaded: total2, total: total2, fromCache: true });
+        return hit;
+      }
+    } catch {
+    }
+  }
+  const response = await fetch(url2, { signal });
+  if (!response.ok) {
+    throw new Error(`fetch ${url2}: HTTP ${response.status}`);
+  }
+  const total = Number(response.headers.get("content-length")) || 0;
+  let body;
+  if (response.body && onProgress) {
+    const reader = response.body.getReader();
+    const parts = [];
+    let loaded = 0;
+    onProgress({ url: url2, loaded, total, fromCache: false });
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      parts.push(value);
+      loaded += value.byteLength;
+      onProgress({ url: url2, loaded, total, fromCache: false });
+    }
+    body = new Uint8Array(new ArrayBuffer(loaded));
+    let offset = 0;
+    for (const part of parts) {
+      body.set(part, offset);
+      offset += part.byteLength;
+    }
+  } else {
+    body = new Uint8Array(await response.arrayBuffer());
+    onProgress?.({
+      url: url2,
+      loaded: body.byteLength,
+      total: total || body.byteLength,
+      fromCache: false
+    });
+  }
+  const headers = new Headers();
+  for (const name of ["content-type", "etag", "last-modified"]) {
+    const value = response.headers.get(name);
+    if (value) headers.set(name, value);
+  }
+  headers.set("content-length", String(body.byteLength));
+  const buffered = new Response(body, { status: 200, headers });
+  if (cache2) {
+    try {
+      await cache2.put(url2, buffered.clone());
+    } catch {
+    }
+  }
+  return buffered;
+}
+async function fetchAssetBytes(url2, options) {
+  return new Uint8Array(await (await fetchAsset(url2, options)).arrayBuffer());
+}
+async function fetchAssetText(url2, options) {
+  return (await fetchAsset(url2, options)).text();
+}
+var NAIST_JDIC_FILES = [
+  "metadata.json",
+  "char_def.bin",
+  "matrix.mtx",
+  "dict.da",
+  "dict.vals",
+  "unk.bin",
+  "dict.wordsidx",
+  "dict.words"
+];
+async function inflate(bytes) {
+  if (typeof DecompressionStream === "undefined") {
+    throw new Error(
+      "DecompressionStream is not available; serve the dictionary uncompressed"
+    );
+  }
+  const stream = new Blob([bytes]).stream().pipeThrough(new DecompressionStream("gzip"));
+  return new Uint8Array(await new Response(stream).arrayBuffer());
+}
+async function loadNaistJdic(baseUrl, options = {}) {
+  const { compressed = true, ...fetchOptions } = options;
+  const base = baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+  const entries = await Promise.all(
+    NAIST_JDIC_FILES.map(async (name) => {
+      const raw = await fetchAssetBytes(
+        `${base}${name}${compressed ? ".gz" : ""}`,
+        fetchOptions
+      );
+      return [name, compressed ? await inflate(raw) : raw];
+    })
+  );
+  return Object.fromEntries(entries);
+}
+function initJpreprocessDictionary(module, data) {
+  module.init_dictionary(
+    data["metadata.json"],
+    data["char_def.bin"],
+    data["matrix.mtx"],
+    data["dict.da"],
+    data["dict.vals"],
+    data["unk.bin"],
+    data["dict.wordsidx"],
+    data["dict.words"]
+  );
+}
+var NUCLEUS = /* @__PURE__ */ new Set([
+  "a",
+  "i",
+  "u",
+  "e",
+  "o",
+  "A",
+  "I",
+  "U",
+  "E",
+  "O",
+  "N",
+  "cl"
+]);
+function softLimit(value, knee, max2) {
+  const magnitude = Math.abs(value);
+  const limited = magnitude <= knee ? magnitude : knee + (magnitude - knee) * 0.5;
+  return Math.sign(value) * Math.min(max2, limited);
+}
+var DEVOICED = /* @__PURE__ */ new Set(["A", "I", "U", "E", "O"]);
+function segmentPhonemes(phonemes) {
+  const segments = [];
+  let openStart = null;
+  for (let i2 = 0; i2 < phonemes.length; i2++) {
+    const { phone, start_ms, duration_ms } = phonemes[i2];
+    if (phone === "sil" || phone === "pau") {
+      if (openStart !== null) {
+        segments.push({
+          pause: false,
+          startMs: openStart,
+          durationMs: start_ms - openStart,
+          devoiced: false
+        });
+        openStart = null;
+      }
+      if (i2 === 0) continue;
+      segments.push({
+        pause: true,
+        startMs: start_ms,
+        durationMs: duration_ms,
+        devoiced: false
+      });
+      continue;
+    }
+    if (openStart === null) openStart = start_ms;
+    if (NUCLEUS.has(phone)) {
+      segments.push({
+        pause: false,
+        startMs: openStart,
+        durationMs: start_ms + duration_ms - openStart,
+        devoiced: DEVOICED.has(phone)
+      });
+      openStart = null;
+    }
+  }
+  if (openStart !== null) {
+    const last = phonemes[phonemes.length - 1];
+    segments.push({
+      pause: false,
+      startMs: openStart,
+      durationMs: last.start_ms + last.duration_ms - openStart,
+      devoiced: false
+    });
+  }
+  return segments;
+}
+function alignHtsProsody(frames, features, options = {}) {
+  const {
+    intonationStrength = 1,
+    frameMs = 10,
+    fallbackPauseMs = 150,
+    kneeCents = 400,
+    maxCents = 700
+  } = options;
+  const segments = segmentPhonemes(frames.phonemes);
+  const durations = new Array(features.length).fill(0);
+  const htsStart = new Array(features.length).fill(null);
+  const devoiced = new Array(features.length).fill(false);
+  let s = 0;
+  for (let f2 = 0; f2 < features.length; f2++) {
+    const feature = features[f2];
+    while (s < segments.length && segments[s].pause && !feature.pause) s++;
+    const segment = segments[s];
+    if (feature.pause) {
+      if (segment?.pause) {
+        durations[f2] = segment.durationMs;
+        htsStart[f2] = segment.startMs;
+        s++;
+      } else {
+        durations[f2] = fallbackPauseMs;
+      }
+      continue;
+    }
+    if (!segment) return null;
+    durations[f2] = segment.durationMs;
+    htsStart[f2] = segment.startMs;
+    devoiced[f2] = segment.devoiced;
+    s++;
+  }
+  if (segments.slice(s).some((segment) => !segment.pause)) return null;
+  const f0 = frames.f0_hz;
+  const logF0 = new Float64Array(f0.length);
+  const voiced = [];
+  for (let i2 = 0; i2 < f0.length; i2++) if (f0[i2] > 0) voiced.push(i2);
+  if (voiced.length === 0) return null;
+  const sorted = voiced.map((i2) => f0[i2]).sort((a, b) => a - b);
+  const medianHz = sorted[Math.floor(sorted.length / 2)];
+  for (let i2 = 0, v = 0; i2 < f0.length; i2++) {
+    if (f0[i2] > 0) {
+      logF0[i2] = Math.log2(f0[i2]);
+      continue;
+    }
+    while (v < voiced.length && voiced[v] < i2) v++;
+    const right = voiced[v];
+    const left = v > 0 ? voiced[v - 1] : void 0;
+    if (left === void 0) logF0[i2] = Math.log2(f0[right]);
+    else if (right === void 0) logF0[i2] = Math.log2(f0[left]);
+    else {
+      const t = (i2 - left) / (right - left);
+      logF0[i2] = Math.log2(f0[left]) * (1 - t) + Math.log2(f0[right]) * t;
+    }
+  }
+  const logMedian = Math.log2(medianHz);
+  const htsCentsAt = (tMs) => {
+    const position = Math.max(0, tMs) / frames.frame_ms;
+    const left = Math.min(logF0.length - 1, Math.floor(position));
+    const right = Math.min(logF0.length - 1, left + 1);
+    const t = position - Math.floor(position);
+    return (logF0[left] * (1 - t) + logF0[right] * t - logMedian) * 1200;
+  };
+  const planStart = [];
+  let cursor = 0;
+  for (let f2 = 0; f2 < features.length; f2++) {
+    planStart.push(cursor);
+    cursor += durations[f2];
+  }
+  const durationMs = cursor;
+  const count = Math.max(2, Math.ceil(durationMs / frameMs) + 2);
+  const cents = new Array(count);
+  let f = 0;
+  for (let frame = 0; frame < count; frame++) {
+    const tMs = frame * frameMs;
+    while (f + 1 < features.length && tMs >= planStart[f + 1]) f++;
+    const start = htsStart[f];
+    let htsMs;
+    if (start !== null) htsMs = start + (tMs - planStart[f]);
+    else {
+      const next = htsStart.slice(f + 1).find((value) => value !== null);
+      htsMs = next ?? frames.phonemes.at(-1)?.start_ms ?? 0;
+    }
+    cents[frame] = softLimit(
+      htsCentsAt(htsMs) * intonationStrength,
+      kneeCents,
+      maxCents
+    );
+  }
+  return {
+    moraDurationsMs: durations,
+    pitchCurve: { frame_ms: frameMs, cents },
+    medianHz,
+    durationMs,
+    devoiced
+  };
+}
+var PUNCTUATION = /* @__PURE__ */ new Set(["\u3001", "\u3002", "\uFF1F", "\uFF01", ",", ".", "?", "!"]);
+var SMALL_KANA = /* @__PURE__ */ new Set(["\u3041", "\u3043", "\u3045", "\u3047", "\u3049", "\u3083", "\u3085", "\u3087", "\u308E", "\u3095", "\u3096"]);
+function toHiragana2(character) {
+  const code = character.charCodeAt(0);
+  if (12449 <= code && code <= 12534) {
+    return String.fromCharCode(code - 96);
+  }
+  return character;
+}
+function splitMorae(reading) {
+  const result = [];
+  const normalized = reading.normalize("NFC").replace(/'/g, "").replace(/’/g, "");
+  for (const character of normalized) {
+    if (/\s/.test(character) || PUNCTUATION.has(character)) {
+      if (result.length > 0 && !result[result.length - 1].pause) {
+        result.push({ mora: "", pause: true });
+      }
+      continue;
+    }
+    const mora = toHiragana2(character);
+    if (SMALL_KANA.has(mora) && result.length > 0 && !result[result.length - 1].pause) {
+      result[result.length - 1].mora += mora;
+    } else {
+      result.push({ mora, pause: false });
+    }
+  }
+  return result;
+}
+function isHigh(position, accent) {
+  if (accent === 1) return position === 1;
+  if (accent > 1) return 2 <= position && position <= accent;
+  return position >= 2;
+}
+function analyze2(nodes) {
+  const reading_parts = [];
+  const result = [];
+  let index = 0;
+  while (index < nodes.length) {
+    const node = nodes[index];
+    const pronunciation = (node.pron || "").replace(/'/g, "").replace(/’/g, "");
+    if (node.mora_size === 0 || PUNCTUATION.has(node.string)) {
+      reading_parts.push(node.string || "\u3001");
+      if (result.length > 0 && !result[result.length - 1].pause) {
+        result.push({ mora: "", pause: true });
+      }
+      index++;
+      continue;
+    }
+    const phrase_nodes = [];
+    while (index < nodes.length) {
+      const current = nodes[index];
+      if (current.mora_size === 0 || PUNCTUATION.has(current.string)) {
+        break;
+      }
+      if (phrase_nodes.length > 0 && current.chain_flag !== 1) {
+        break;
+      }
+      const current_pronunciation = (current.pron || "").replace(/'/g, "").replace(/’/g, "");
+      const morae = splitMorae(current_pronunciation).filter((item) => !item.pause);
+      phrase_nodes.push({ current, morae });
+      reading_parts.push(current_pronunciation);
+      index++;
+    }
+    const phrase_length = phrase_nodes.reduce((sum, item) => sum + item.morae.length, 0);
+    const accent = phrase_nodes[0].current.acc || 0;
+    let phrase_position = 0;
+    for (const { current, morae } of phrase_nodes) {
+      for (let word_position = 1; word_position <= morae.length; word_position++) {
+        phrase_position++;
+        result.push({
+          mora: morae[word_position - 1].mora,
+          pause: false,
+          accent_phrase_position: phrase_position,
+          accent_phrase_length: phrase_length,
+          accent_nucleus: accent,
+          accent_high: isHigh(phrase_position, accent),
+          accent_phrase_start: phrase_position === 1,
+          accent_phrase_end: phrase_position === phrase_length,
+          word_start: word_position === 1,
+          word_end: word_position === morae.length,
+          pos: current.pos || "*",
+          pos_group1: current.pos_group1 || "*"
+        });
+      }
+    }
+  }
+  return { reading: reading_parts.join(""), features: result };
+}
+function sparse_features(token) {
+  if (token.pause || token.accent_phrase_position === void 0 || token.accent_phrase_length === void 0 || token.accent_nucleus === void 0) {
+    return {};
+  }
+  const phrase_length = Math.max(1, token.accent_phrase_length);
+  const phrase_position = token.accent_phrase_position;
+  const nucleus = token.accent_nucleus;
+  const result = {
+    "accent_position": phrase_position / phrase_length,
+    "accent_from_end": (phrase_length - phrase_position) / phrase_length,
+    "accent_nucleus_position": nucleus / phrase_length,
+    "accent_high": token.accent_high ? 1 : 0,
+    "accent_phrase_start": token.accent_phrase_start ? 1 : 0,
+    "accent_phrase_end": token.accent_phrase_end ? 1 : 0,
+    "word_start": token.word_start ? 1 : 0,
+    "word_end": token.word_end ? 1 : 0
+  };
+  result[`pos=${token.pos || "*"}`] = 1;
+  result[`pos_group1=${token.pos_group1 || "*"}`] = 1;
+  if (nucleus === 0) {
+    result["accent_type=heiban"] = 1;
+  } else if (phrase_position < nucleus) {
+    result["accent_type=before"] = 1;
+  } else if (phrase_position === nucleus) {
+    result["accent_type=nucleus"] = 1;
+  } else {
+    result["accent_type=after"] = 1;
+  }
+  return result;
+}
+var TRAILING = /[\s」』）)〕】＞>"'”’]+$/u;
+function isQuestion(text) {
+  return /[？?]$/u.test(text.replace(TRAILING, ""));
+}
+function smoothstep(t) {
+  const x2 = Math.min(1, Math.max(0, t));
+  return x2 * x2 * (3 - 2 * x2);
+}
+function shapeProsody(prosody, features, options = {}) {
+  const {
+    question = false,
+    questionRiseCents = 350,
+    energyDbPerSemitone = 0.5,
+    devoicedGain = 0.5,
+    minGain = 0.35,
+    maxGain = 1.8
+  } = options;
+  const { frame_ms: frameMs } = prosody.pitchCurve;
+  const cents = prosody.pitchCurve.cents.slice();
+  const count = Math.min(features.length, prosody.moraDurationsMs.length);
+  const startFrame = [];
+  const endFrame = [];
+  let cursor = 0;
+  for (let f = 0; f < count; f++) {
+    startFrame.push(cursor / frameMs);
+    cursor += prosody.moraDurationsMs[f];
+    endFrame.push(cursor / frameMs);
+  }
+  const frameRange = (f) => [
+    Math.max(0, Math.min(cents.length, Math.round(startFrame[f]))),
+    Math.max(0, Math.min(cents.length, Math.round(endFrame[f])))
+  ];
+  if (question && questionRiseCents > 0) {
+    let last = -1;
+    for (let f = count - 1; f >= 0; f--) {
+      if (!features[f].pause) {
+        last = f;
+        break;
+      }
+    }
+    if (last >= 0) {
+      const [from, to] = frameRange(last);
+      if (to > from) {
+        const existing = cents[to - 1] - cents[from];
+        const shortfall = questionRiseCents - existing;
+        if (shortfall > 0) {
+          for (let frame = from; frame < cents.length; frame++) {
+            const t = (frame - from) / (to - from);
+            cents[frame] += shortfall * smoothstep((t - 0.25) / 0.75);
+          }
+        }
+      }
+    }
+  }
+  const moraGains = new Array(features.length).fill(1);
+  for (let f = 0; f < count; f++) {
+    if (features[f].pause) continue;
+    let gainDb = 0;
+    if (energyDbPerSemitone !== 0) {
+      const [from, to] = frameRange(f);
+      if (to > from) {
+        let sum = 0;
+        for (let frame = from; frame < to; frame++) sum += cents[frame];
+        gainDb += sum / (to - from) / 100 * energyDbPerSemitone;
+      }
+    }
+    let gain = 10 ** (gainDb / 20);
+    if (prosody.devoiced[f]) gain *= devoicedGain;
+    moraGains[f] = Math.min(maxGain, Math.max(minGain, gain));
+  }
+  return {
+    ...prosody,
+    pitchCurve: { frame_ms: frameMs, cents },
+    moraGains
+  };
+}
+function readingFromFeatures(features) {
+  return features.map((frame) => frame.pause ? "\u3001" : frame.mora).join("");
+}
+var FS = WORLDLINE_SAMPLE_RATE;
+var msToSamples2 = (ms) => Math.round(ms / 1e3 * FS);
+function f0At(timeline, tMs) {
+  const curve = timeline.f0_curve;
+  if (curve.length === 0) return timeline.reference_hz || 220;
+  const position = Math.max(0, tMs) / timeline.frame_ms;
+  const left = Math.floor(position);
+  if (left >= curve.length - 1) return curve[curve.length - 1];
+  const progress = position - left;
+  return curve[left] * (1 - progress) + curve[left + 1] * progress;
+}
+function applyMoraGains(plan, gains) {
+  const morae = plan.morae ?? [];
+  const timings = plan.mora_timings ?? [];
+  const byIndex = morae.length === gains.length;
+  const moraAt = (unit) => {
+    if (byIndex) return unit.position;
+    let found = -1;
+    for (let i2 = 0; i2 < timings.length && i2 < gains.length; i2++) {
+      if (timings[i2].StartMS <= unit.note_start_ms + 1e-6) found = i2;
+      else break;
+    }
+    return found;
+  };
+  for (const unit of plan.timeline.units) {
+    const index = moraAt(unit);
+    const gain = gains[index];
+    if (index < 0 || gain === void 0 || !Number.isFinite(gain)) continue;
+    unit.volume *= gain;
+  }
+}
+function planChunks(units2, firstChunkUnits, chunkUnits) {
+  const ranges = [];
+  if (units2.length === 0) return ranges;
+  let start = 0;
+  let coveredEndMs = units2[0].position_ms + units2[0].length_ms;
+  let headSeam = false;
+  for (let i2 = 1; i2 <= units2.length; i2++) {
+    const limit = ranges.length === 0 ? firstChunkUnits : chunkUnits;
+    const atEnd = i2 === units2.length;
+    const clean = !atEnd && units2[i2].position_ms >= coveredEndMs - 1e-6;
+    const full = !atEnd && i2 - start >= limit;
+    if (atEnd || clean || full) {
+      const tailSeam = !atEnd && !clean;
+      ranges.push({ start, end: i2, headSeam, tailSeam });
+      start = i2;
+      headSeam = tailSeam;
+      if (!atEnd) coveredEndMs = units2[i2].position_ms + units2[i2].length_ms;
+      continue;
+    }
+    coveredEndMs = Math.max(
+      coveredEndMs,
+      units2[i2].position_ms + units2[i2].length_ms
+    );
+  }
+  return ranges;
+}
+function seamTimeMs(next, crossfadeMs) {
+  const earliest = next.position_ms + next.fade_in_ms + crossfadeMs / 2;
+  const latest = next.position_ms + next.length_ms - crossfadeMs / 2;
+  return Math.min(
+    earliest,
+    Math.max(next.position_ms + crossfadeMs / 2, latest)
+  );
+}
+function applyFade(pcm, fromSample, samples, fadeIn) {
+  const n = Math.max(1, Math.min(samples, pcm.length - fromSample));
+  for (let k = 0; k < n; k++) {
+    const t = (k + 0.5) / n;
+    const gain = fadeIn ? Math.sin(Math.PI / 2 * t) : Math.cos(Math.PI / 2 * t);
+    pcm[fromSample + k] *= gain;
+  }
+}
+var UtauTTSAdapter = class _UtauTTSAdapter {
+  constructor(worldline) {
+    this.worldline = worldline;
+  }
+  worldline;
+  static modelId = null;
+  bankAliases = /* @__PURE__ */ new WeakMap();
+  currentBank = null;
+  pcmCache = /* @__PURE__ */ new Map();
+  /**
+   * Load the UtauTTS Go wasm. `wasm_exec.js` must already be on the page.
+   * Pass `fetch` (e.g. koe's `fetchAsset`) to stream from the Cache API.
+   */
+  static async initializeWasm(wasmUrl = "utautts.wasm", options = {}) {
+    if (typeof utautts_plan === "function") return;
+    if (typeof Go === "undefined") {
+      throw new Error(
+        "wasm_exec.js must be loaded before calling initializeWasm."
+      );
+    }
+    const go = new Go();
+    const responsePromise = (options.fetch ?? fetch)(wasmUrl);
+    let instance;
+    try {
+      instance = (await WebAssembly.instantiateStreaming(responsePromise, go.importObject)).instance;
+    } catch {
+      const bytes = await (await (options.fetch ?? fetch)(wasmUrl)).arrayBuffer();
+      instance = (await WebAssembly.instantiate(bytes, go.importObject)).instance;
+    }
+    void go.run(instance);
+    for (let attempt = 0; attempt < 100 && typeof utautts_plan !== "function"; attempt++) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
+    }
+    if (typeof utautts_plan !== "function") {
+      throw new Error("utautts_plan failed to initialize in global scope.");
+    }
+  }
+  static get ready() {
+    return typeof utautts_plan === "function";
+  }
+  /** Parse and cache a prosody model (e.g. `frame-intonation-v8.json`) inside the wasm. */
+  static setModel(modelJSON) {
+    _UtauTTSAdapter.assertReady();
+    const result = utautts_set_model(modelJSON);
+    if (!result.success)
+      throw new Error(`UtauTTS model error: ${result.error}`);
+    _UtauTTSAdapter.modelId = result.id ?? null;
+    return _UtauTTSAdapter.modelId;
+  }
+  static get currentModelId() {
+    return _UtauTTSAdapter.modelId;
+  }
+  static assertReady() {
+    if (typeof utautts_plan !== "function") {
+      throw new Error(
+        "UtauTTS wasm is not initialized; call UtauTTSAdapter.initializeWasm() first."
+      );
+    }
+  }
+  /**
+   * Register a koe voice bank with the planner: the manifest becomes a virtual
+   * oto.ini (koe PCM is pre-trimmed, so offset is 0) plus each sample's
+   * recorded pitch. Called automatically by {@link plan}; cheap when unchanged.
+   */
+  setBank(bank) {
+    _UtauTTSAdapter.assertReady();
+    if (this.currentBank === bank && this.bankAliases.has(bank)) return;
+    const entries = {};
+    const pitch = {};
+    for (const [alias, phoneme] of Object.entries(bank.manifest.phonemes)) {
+      entries[alias] = [
+        {
+          Filename: `koe:${alias}`,
+          Alias: alias,
+          Offset: 0,
+          Fixed: phoneme.consonant / 48,
+          Blank: 0,
+          Preutterance: phoneme.pre / 48,
+          Overlap: phoneme.overlap / 48,
+          SourceGroup: "koe"
+        }
+      ];
+      if (phoneme.pitch > 0) pitch[alias] = phoneme.pitch;
+    }
+    const result = utautts_set_bank(
+      JSON.stringify({
+        name: "koe",
+        oto_entries: entries,
+        source_pitch_hz: pitch
+      })
+    );
+    if (!result.success) throw new Error(`UtauTTS bank error: ${result.error}`);
+    this.bankAliases.set(bank, result.aliases ?? 0);
+    this.currentBank = bank;
+    this.pcmCache.clear();
+  }
+  /**
+   * Plan an utterance: unit selection, timing, pitch contour and worldline
+   * placement. `features` are the mora-level frames from `openjtalkAnalyze`
+   * (pauses included); the kana reading is derived from them.
+   */
+  plan(bank, text, features, options = {}) {
+    this.setBank(bank);
+    const request = {
+      text,
+      reading: readingFromFeatures(features),
+      frames: features.map((frame) => sparse_features(frame)),
+      tone: options.tone ?? "C4",
+      mora_duration_ms: options.moraDurationMs ?? 0,
+      pause_duration_ms: options.pauseDurationMs ?? 0,
+      release_ms: options.releaseMs ?? 20,
+      leading_preutterance_ms: options.leadingPreutteranceMs ?? 0,
+      apply_pitch: options.applyPitch ?? true,
+      intonation_strength: options.intonationStrength ?? 1,
+      speech_timing: options.speechTiming ?? false,
+      word_boundary_envelope: options.wordBoundaryEnvelope ?? false,
+      mora_durations_ms: options.prosody?.moraDurationsMs,
+      pitch_curve: options.prosody?.pitchCurve
+    };
+    const response = utautts_plan(JSON.stringify(request));
+    if (!response.success || !response.plan) {
+      throw new Error(`UtauTTS error: ${response.error ?? "no plan"}`);
+    }
+    const plan = JSON.parse(response.plan);
+    const gains = options.prosody?.moraGains;
+    if (gains) applyMoraGains(plan, gains);
+    return plan;
+  }
+  getPcm(bank, alias) {
+    let cached = this.pcmCache.get(alias);
+    if (!cached) {
+      cached = bank.getPcm(alias);
+      this.pcmCache.set(alias, cached);
+    }
+    return cached;
+  }
+  /**
+   * Render a plan chunk by chunk. Each chunk is independent audio positioned
+   * at `startMs`; schedule them as they arrive (see the demo) or sum them.
+   *
+   * Chunk breaks fall on pauses when possible. Inside a phrase a break renders
+   * one neighbouring unit of context on each side so the unit crossfade stays
+   * WORLD's spectral one, then the two renders are joined with a short
+   * equal-power crossfade in the following vowel.
+   */
+  async *renderChunks(bank, plan, options = {}) {
+    const {
+      firstChunkUnits = 3,
+      chunkUnits = 6,
+      seamCrossfadeMs = 20,
+      signal
+    } = options;
+    const timeline = plan.timeline;
+    const units2 = timeline.units.filter((unit) => unit.length_ms > 0);
+    const ranges = planChunks(
+      units2,
+      Math.max(1, firstChunkUnits),
+      Math.max(1, chunkUnits)
+    );
+    const crossfadeSamples = Math.max(2, msToSamples2(seamCrossfadeMs));
+    for (let index = 0; index < ranges.length; index++) {
+      if (signal?.aborted) return;
+      const range = ranges[index];
+      const renderStart = range.headSeam ? range.start - 1 : range.start;
+      const renderEnd = range.tailSeam ? range.end + 1 : range.end;
+      const rendered = units2.slice(renderStart, renderEnd);
+      const baseMs = Math.min(...rendered.map((unit) => unit.position_ms));
+      const phraseUnits = [];
+      for (const unit of rendered) {
+        const pcm2 = await this.getPcm(bank, unit.alias);
+        if (!pcm2 || pcm2.length < MIN_WORLDLINE_SAMPLES) {
+          console.warn(
+            `[utautts] no usable PCM for alias "${unit.alias}"; skipped`
+          );
+          continue;
+        }
+        phraseUnits.push({
+          pcm: pcm2,
+          posMs: unit.position_ms - baseMs,
+          skipMs: unit.skip_ms,
+          lengthMs: unit.length_ms,
+          fadeInMs: unit.fade_in_ms,
+          fadeOutMs: unit.fade_out_ms,
+          consonantMs: unit.consonant_ms,
+          requiredLengthMs: unit.required_length_ms,
+          volume: unit.volume,
+          tone: unit.tone
+        });
+      }
+      if (signal?.aborted) return;
+      if (phraseUnits.length === 0) continue;
+      const audio = this.worldline.renderPhrase({
+        units: phraseUnits,
+        pitch: (tMs) => f0At(timeline, baseMs + tMs),
+        gender: options.gender,
+        tension: options.tension,
+        breathiness: options.breathiness,
+        voicing: options.voicing
+      });
+      if (!audio || audio.length === 0) continue;
+      let fromSample = 0;
+      let toSample = audio.length;
+      let startMs = baseMs;
+      if (range.headSeam) {
+        const seamMs = seamTimeMs(units2[range.start], seamCrossfadeMs);
+        fromSample = Math.max(
+          0,
+          msToSamples2(seamMs - baseMs) - crossfadeSamples / 2
+        );
+        startMs = baseMs + fromSample / FS * 1e3;
+      }
+      if (range.tailSeam) {
+        const seamMs = seamTimeMs(units2[range.end], seamCrossfadeMs);
+        toSample = Math.min(
+          audio.length,
+          msToSamples2(seamMs - baseMs) + crossfadeSamples / 2
+        );
+      }
+      if (toSample <= fromSample) continue;
+      const pcm = audio.slice(fromSample, toSample);
+      if (range.headSeam) applyFade(pcm, 0, crossfadeSamples, true);
+      if (range.tailSeam)
+        applyFade(
+          pcm,
+          Math.max(0, pcm.length - crossfadeSamples),
+          crossfadeSamples,
+          false
+        );
+      yield { pcm, startMs, index, units: units2.slice(range.start, range.end) };
+      await new Promise((resolve) => setTimeout(resolve, 0));
+    }
+  }
+  /**
+   * Plan + render an utterance into one buffer (Float32, 48 kHz) covering the
+   * whole timeline. Use {@link plan} + {@link renderChunks} for streaming.
+   */
+  async synthesizeText(bank, text, features, options = {}) {
+    const plan = this.plan(bank, text, features, options);
+    const total = msToSamples2(plan.timeline.duration_ms) + msToSamples2(200);
+    const out = new Float32Array(total);
+    let any = false;
+    for await (const chunk of this.renderChunks(bank, plan, options)) {
+      any = true;
+      const offset = msToSamples2(chunk.startMs);
+      const n = Math.min(chunk.pcm.length, out.length - offset);
+      for (let k = 0; k < n; k++) out[offset + k] += chunk.pcm[k];
+    }
+    return any ? out : null;
+  }
+};
 
 // src/vibrato.ts
 var VIBRATO_MIN_SEC = 0.35;
@@ -3190,7 +4148,7 @@ var MAX_PORTAMENTO_MS = 400;
 var MIN_GLIDE_MS = 4;
 var MAX_GLIDE_SPAN_RATIO = 0.9;
 var unitsToHz2 = (units2) => 440 * 2 ** ((units2 - 2139) / 372);
-var smoothstep = (u) => u * u * (3 - 2 * u);
+var smoothstep2 = (u) => u * u * (3 - 2 * u);
 var glideMsForSegments = (segments, totalMs) => segments.map((seg, i2) => {
   const atMs = seg.atSec * 1e3;
   const prevMs = i2 === 0 ? 0 : segments[i2 - 1].atSec * 1e3;
@@ -3224,7 +4182,7 @@ var pitchCurveFor = (baseHz, segments, preMs, vibrato, totalMs) => {
           continue;
         }
         if (sinceOnset <= k.startMs) break;
-        const u = smoothstep((sinceOnset - k.startMs) / k.glideMs);
+        const u = smoothstep2((sinceOnset - k.startMs) / k.glideMs);
         hz = hz * (k.hz / hz) ** u;
         break;
       }
@@ -3240,6 +4198,177 @@ var segmentsCacheKey = (segments) => segments?.length ? `|s${segments.map(
   (s) => `${s.pitch}@${Math.round(s.atSec * 100)}${s.portamento ? "~" : ""}`
 ).join(",")}` : "";
 
+// src/speech.ts
+var DEFAULT_TTS_BASE_URL = "https://onjmin.github.io/koe/demo/utautts/";
+var joinUrl = (base, path) => `${base.endsWith("/") ? base : `${base}/`}${path}`;
+var loadGoRuntime = (url2) => new Promise((resolve, reject) => {
+  if (typeof globalThis.Go !== "undefined") {
+    resolve();
+    return;
+  }
+  if (typeof document === "undefined") {
+    reject(new Error("wasm_exec.js needs a document to load into"));
+    return;
+  }
+  const script = document.createElement("script");
+  script.src = url2;
+  script.async = true;
+  script.onload = () => resolve();
+  script.onerror = () => reject(new Error(`failed to load ${url2}`));
+  document.head.appendChild(script);
+});
+var importJpreprocess = (url2) => import(
+  /* @vite-ignore */
+  /* webpackIgnore: true */
+  url2
+);
+var shared = null;
+var getSpeechPlanner = (options = {}) => {
+  const baseUrl = options.baseUrl ?? DEFAULT_TTS_BASE_URL;
+  if (shared) {
+    if (shared.baseUrl !== baseUrl) {
+      console.warn(
+        `[dtm] TTS assets are already loaded from ${shared.baseUrl}; ignoring ${baseUrl}`
+      );
+    }
+    return shared.planner;
+  }
+  const planner = createSpeechPlanner({ ...options, baseUrl });
+  shared = { baseUrl, planner };
+  return planner;
+};
+var createSpeechPlanner = (options = {}) => {
+  const baseUrl = options.baseUrl ?? DEFAULT_TTS_BASE_URL;
+  let jp = null;
+  let adapter = null;
+  let readyPromise = null;
+  let isReady = false;
+  const load2 = async () => {
+    const progress = /* @__PURE__ */ new Map();
+    const onProgress = (p) => {
+      if (!options.onProgress) return;
+      progress.set(p.url, p);
+      let loaded = 0;
+      let total = 0;
+      for (const item of progress.values()) {
+        loaded += item.loaded;
+        total += item.total;
+      }
+      options.onProgress(loaded, total);
+    };
+    const fetchWithProgress = (url2) => fetchAsset(url2, { onProgress });
+    const jpreprocessReady = (async () => {
+      const glue2 = await importJpreprocess(
+        joinUrl(baseUrl, "jpreprocess_wasm/jpreprocess_wasm.js")
+      );
+      await glue2.default({
+        module_or_path: fetchWithProgress(
+          joinUrl(baseUrl, "jpreprocess_wasm/jpreprocess_wasm_bg.wasm")
+        )
+      });
+      if (!glue2.is_ready()) {
+        const dict = await loadNaistJdic(
+          joinUrl(baseUrl, "jpreprocess_wasm/naist-jdic"),
+          { onProgress }
+        );
+        initJpreprocessDictionary(glue2, dict);
+      }
+      return glue2;
+    })();
+    const utauttsReady = (async () => {
+      await loadGoRuntime(joinUrl(baseUrl, "wasm_exec.js"));
+      await UtauTTSAdapter.initializeWasm(joinUrl(baseUrl, "utautts.wasm"), {
+        fetch: fetchWithProgress
+      });
+      UtauTTSAdapter.setModel(
+        await fetchAssetText(joinUrl(baseUrl, "frame-intonation-v8.json"), {
+          onProgress
+        })
+      );
+    })();
+    const htsVoiceReady = fetchAssetBytes(
+      joinUrl(baseUrl, "hts/tohoku-f01-neutral.htsvoice"),
+      { onProgress }
+    );
+    const [glue, , htsVoice] = await Promise.all([
+      jpreprocessReady,
+      utauttsReady,
+      htsVoiceReady
+    ]);
+    if (!glue.is_voice_ready()) glue.init_voice(htsVoice);
+    jp = glue;
+    adapter = new UtauTTSAdapter(null);
+    isReady = true;
+  };
+  const ready = () => {
+    if (!readyPromise) {
+      readyPromise = load2().catch((err2) => {
+        readyPromise = null;
+        throw err2;
+      });
+    }
+    return readyPromise;
+  };
+  const plan = (bank, text, o = {}) => {
+    if (!jp || !adapter) {
+      throw new Error("speech planner is not ready; await ready() first");
+    }
+    const intonationStrength = o.intonationStrength ?? 1;
+    const nodes = JSON.parse(jp.analyze_text(text));
+    const { features } = analyze2(nodes);
+    if (features.length === 0) {
+      throw new Error(`no readable morae in "${text}"`);
+    }
+    let prosody = null;
+    if (jp.is_voice_ready()) {
+      const frames = JSON.parse(jp.analyze_prosody(text, 1));
+      prosody = alignHtsProsody(frames, features, { intonationStrength });
+      if (prosody) {
+        prosody = shapeProsody(prosody, features, {
+          question: isQuestion(text)
+        });
+      }
+    }
+    return adapter.plan(bank, text, features, {
+      tone: o.tone ?? "C4",
+      intonationStrength,
+      prosody: prosody ?? void 0
+    });
+  };
+  return { ready, isReady: () => isReady, plan };
+};
+var prepareSpeechPlan = (plan, ratio, toReal = (a) => a) => {
+  const timeline = plan.timeline;
+  return {
+    ...plan,
+    timeline: {
+      ...timeline,
+      f0_curve: timeline.f0_curve.map((hz) => hz * ratio),
+      units: timeline.units.map((u) => ({
+        ...u,
+        alias: toReal(u.alias),
+        target_f0_hz: u.target_f0_hz * ratio
+      }))
+    }
+  };
+};
+var speechPlanLeadingSec = (plan) => Math.max(0, plan.timeline.leading_ms || 0) / 1e3;
+var speechPlanDurationSec = (plan) => {
+  const timeline = plan.timeline;
+  let endMs = 0;
+  for (const u of timeline.units) {
+    endMs = Math.max(endMs, u.position_ms + u.length_ms);
+  }
+  if (endMs <= 0) endMs = timeline.duration_ms;
+  return Math.max(0, endMs / 1e3 - speechPlanLeadingSec(plan));
+};
+var medianRecordedPitchHz = (phonemes) => {
+  const pitches = Object.values(phonemes).map((p) => p.pitch).filter((hz) => hz > 0).sort((a, b) => a - b);
+  if (pitches.length === 0) return void 0;
+  const mid = pitches.length >> 1;
+  return pitches.length % 2 ? pitches[mid] : (pitches[mid - 1] + pitches[mid]) / 2;
+};
+
 // src/types.ts
 var DEFAULT_VOCAL_VOLUME = 200;
 var DEFAULT_BPM = 120;
@@ -3338,7 +4467,7 @@ var kanaTable = {
   \u307D: ["p", "o"],
   \u3093: ["N", "N"]
 };
-var SMALL_KANA = "\u3041\u3043\u3045\u3047\u3049\u3083\u3085\u3087";
+var SMALL_KANA2 = "\u3041\u3043\u3045\u3047\u3049\u3083\u3085\u3087";
 var VOWEL_KANA = {
   a: "\u3042",
   i: "\u3044",
@@ -3353,13 +4482,43 @@ var REST_MARK = "_";
 var BREATH_MARK = "\u3001";
 var FADE_OUT_MARK = "\u2193";
 var FADE_IN_MARK = "\u2191";
+var SPEAK_OPEN = "\u300C";
+var SPEAK_CLOSE = "\u300D";
+var splitSpeech = (text) => {
+  const pieces = [];
+  let sung = "";
+  let i2 = 0;
+  while (i2 < text.length) {
+    const ch = text[i2];
+    if (ch === SPEAK_OPEN || ch === "\uFF62") {
+      let end = -1;
+      for (let j = i2 + 1; j < text.length; j++) {
+        if (text[j] === SPEAK_CLOSE || text[j] === "\uFF63") {
+          end = j;
+          break;
+        }
+      }
+      if (sung) pieces.push({ sung });
+      sung = "";
+      const body = end < 0 ? text.slice(i2 + 1) : text.slice(i2 + 1, end);
+      pieces.push({ speak: body });
+      i2 = end < 0 ? text.length : end + 1;
+      continue;
+    }
+    sung += ch;
+    i2++;
+  }
+  if (sung) pieces.push({ sung });
+  return pieces;
+};
+var sanitizeSpeech = (text) => text.replace(/[\r\n;]+/g, " ").replace(/\s+/g, " ").trim();
 var sanitizeText = (text) => text.normalize("NFKC").replace(/[ァ-ヶ]/g, (c) => String.fromCharCode(c.charCodeAt(0) - 96)).replace(/~/g, PORTAMENTO_MARK).replace(/,/g, BREATH_MARK).replace(/[↡⇩⬇🡇]/gu, FADE_OUT_MARK).replace(/[↟⇧⬆🡅]/gu, FADE_IN_MARK).replace(/[^ぁ-ゖー〜_、↓↑]/g, "");
 var splitSyllables = (text) => {
   const MARKS = `${TIE_MARK}${PORTAMENTO_MARK}${REST_MARK}${BREATH_MARK}${FADE_OUT_MARK}${FADE_IN_MARK}`;
   const result = [];
   for (const ch of text) {
     const prev = result[result.length - 1];
-    if (prev !== void 0 && SMALL_KANA.includes(ch) && !MARKS.includes(prev[prev.length - 1])) {
+    if (prev !== void 0 && SMALL_KANA2.includes(ch) && !MARKS.includes(prev[prev.length - 1])) {
       result[result.length - 1] += ch;
     } else {
       result.push(ch);
@@ -3408,42 +4567,52 @@ var analyzeSyllable = (syllable) => {
 var normalizeLyrics = (text) => {
   const result = [];
   let prevVowel = "";
-  for (const mark of splitSyllables(sanitizeText(text))) {
-    if (mark === BREATH_MARK) {
-      const last = result[result.length - 1];
-      if (last) last.breathAfter = true;
+  for (const piece of splitSpeech(text)) {
+    if ("speak" in piece) {
+      const body = sanitizeSpeech(piece.speak);
+      result.push(
+        body ? { kana: body, consonant: "", vowel: "", kind: "speak", text: body } : { kana: REST_MARK, consonant: "", vowel: "", kind: "rest" }
+      );
       prevVowel = "";
       continue;
     }
-    if (mark === FADE_OUT_MARK) {
-      const last = result[result.length - 1];
-      if (last) last.fadeOut = true;
-      continue;
-    }
-    if (mark === FADE_IN_MARK) {
-      const last = result[result.length - 1];
-      if (last) last.fadeIn = true;
-      continue;
-    }
-    const syl = analyzeSyllable(mark);
-    if (syl.kind === "tie") {
-      if (!prevVowel) continue;
-      result.push({
-        ...syl,
-        kana: prevVowel === "N" ? "\u3093" : VOWEL_KANA[prevVowel] ?? syl.kana,
-        consonant: "",
-        vowel: prevVowel
-      });
-      continue;
+    for (const mark of splitSyllables(sanitizeText(piece.sung))) {
+      if (mark === BREATH_MARK) {
+        const last = result[result.length - 1];
+        if (last) last.breathAfter = true;
+        prevVowel = "";
+        continue;
+      }
+      if (mark === FADE_OUT_MARK) {
+        const last = result[result.length - 1];
+        if (last) last.fadeOut = true;
+        continue;
+      }
+      if (mark === FADE_IN_MARK) {
+        const last = result[result.length - 1];
+        if (last) last.fadeIn = true;
+        continue;
+      }
+      const syl = analyzeSyllable(mark);
+      if (syl.kind === "tie") {
+        if (!prevVowel) continue;
+        result.push({
+          ...syl,
+          kana: prevVowel === "N" ? "\u3093" : VOWEL_KANA[prevVowel] ?? syl.kana,
+          consonant: "",
+          vowel: prevVowel
+        });
+        continue;
+      }
+      if (syl.kind === "rest") prevVowel = "";
+      else if (syl.vowel) prevVowel = syl.vowel;
+      result.push(syl);
     }
-    if (syl.kind === "rest") prevVowel = "";
-    else if (syl.vowel) prevVowel = syl.vowel;
-    result.push(syl);
   }
   return result;
 };
 var displayKana = (syl) => {
-  const head = syl.kind === "tie" ? syl.portamento ? PORTAMENTO_MARK : TIE_MARK : syl.kind === "rest" ? REST_MARK : syl.kana;
+  const head = syl.kind === "tie" ? syl.portamento ? PORTAMENTO_MARK : TIE_MARK : syl.kind === "rest" ? REST_MARK : syl.kind === "speak" ? `${SPEAK_OPEN}${syl.text ?? syl.kana}${SPEAK_CLOSE}` : syl.kana;
   let out = syl.breathAfter ? head + BREATH_MARK : head;
   if (syl.fadeIn) out += FADE_IN_MARK;
   if (syl.fadeOut) out += FADE_OUT_MARK;
@@ -3932,6 +5101,40 @@ var collectPitchTokens = (aliases) => {
   }
   return [...seen].map(([token, midi]) => ({ token, midi }));
 };
+var nearestPitchToken = (pitchTokens, noteNum) => {
+  let best = null;
+  for (const t of pitchTokens) {
+    if (!best || Math.abs(t.midi - noteNum) < Math.abs(best.midi - noteNum))
+      best = t;
+  }
+  return best;
+};
+var createSpeechToneView = (phonemes, token) => {
+  if (!token) {
+    return {
+      view: { manifest: { phonemes } },
+      toReal: (a) => a,
+      referenceHz: medianRecordedPitchHz(phonemes)
+    };
+  }
+  const suffix = `_${token}`;
+  const stripped = {};
+  const real = /* @__PURE__ */ new Map();
+  for (const [alias, entry] of Object.entries(phonemes)) {
+    if (alias.endsWith(suffix)) {
+      const bare = alias.slice(0, -suffix.length);
+      stripped[bare] = entry;
+      real.set(bare, alias);
+    } else if (!PITCH_SUFFIX.test(alias) && !(alias in stripped)) {
+      stripped[alias] = entry;
+    }
+  }
+  return {
+    view: { manifest: { phonemes: stripped } },
+    toReal: (a) => real.get(a) ?? a,
+    referenceHz: medianRecordedPitchHz(stripped)
+  };
+};
 var resolveKoeAlias = (hasAlias, pitchTokens, syl, prevVowel, noteNum) => {
   const kana = syl.kana;
   const cons = syl.consonant === "N" ? "n" : syl.consonant;
@@ -4087,10 +5290,29 @@ var createLocalBackend = async (options) => {
       rate
     };
   };
+  let speechAdapter = null;
+  const renderSpeech = async (plan, expr, onChunk, signal) => {
+    if (!worldline) return;
+    speechAdapter ??= new UtauTTSAdapter(worldline);
+    try {
+      for await (const chunk of speechAdapter.renderChunks(bank, plan, {
+        signal,
+        gender: expr?.gender,
+        breathiness: expr?.breathiness,
+        tension: expr?.tension
+      })) {
+        onChunk({ pcm: chunk.pcm, startMs: chunk.startMs, index: chunk.index });
+      }
+    } catch (err2) {
+      console.warn("[dtm] speech synthesis failed", err2);
+    }
+  };
   return {
     hasAlias: (a) => bank.has(a),
     pitchTokens: collectPitchTokens(Object.keys(bank.manifest.phonemes)),
     renderAlias,
+    phonemes: bank.manifest.phonemes,
+    renderSpeech,
     dispose: () => {
     }
   };
@@ -4106,7 +5328,9 @@ var spawnVoiceWorker = async (url2) => {
 var createWorkerBackend = async (workerUrl, options) => {
   const worker2 = await spawnVoiceWorker(workerUrl);
   const aliasSet = /* @__PURE__ */ new Set();
+  let phonemes = {};
   const pending = /* @__PURE__ */ new Map();
+  const speechPending = /* @__PURE__ */ new Map();
   let reqId = 0;
   let onReady = null;
   let onFail = null;
@@ -4114,6 +5338,7 @@ var createWorkerBackend = async (workerUrl, options) => {
     const m = ev.data;
     if (m.type === "ready") {
       for (const a of m.aliases) aliasSet.add(a);
+      phonemes = m.phonemes ?? {};
       onReady?.();
     } else if (m.type === "error") {
       onFail?.(new Error(m.message));
@@ -4123,6 +5348,15 @@ var createWorkerBackend = async (workerUrl, options) => {
         pending.delete(m.id);
         cb(m);
       }
+    } else if (m.type === "speech-chunk") {
+      speechPending.get(m.id)?.onChunk({ pcm: m.pcm, startMs: m.startMs, index: m.index });
+    } else if (m.type === "speech-end") {
+      const s = speechPending.get(m.id);
+      if (s) {
+        speechPending.delete(m.id);
+        if (m.error) console.warn("[dtm] speech synthesis failed", m.error);
+        s.done();
+      }
     }
   };
   worker2.onerror = (e) => {
@@ -4162,10 +5396,32 @@ var createWorkerBackend = async (workerUrl, options) => {
       pitchSegments
     });
   });
+  const renderSpeech = (plan, expr, onChunk, signal) => new Promise((resolve) => {
+    const id = ++reqId;
+    speechPending.set(id, { onChunk, done: resolve });
+    signal?.addEventListener("abort", () => {
+      worker2.postMessage({
+        type: "speak-abort",
+        id
+      });
+    });
+    worker2.postMessage({
+      type: "speak",
+      id,
+      plan,
+      gender: expr?.gender,
+      breathiness: expr?.breathiness,
+      tension: expr?.tension
+    });
+  });
   return {
     hasAlias: (a) => aliasSet.has(a),
     pitchTokens: collectPitchTokens(aliasSet),
     renderAlias,
+    get phonemes() {
+      return phonemes;
+    },
+    renderSpeech,
     dispose: () => worker2.terminate()
   };
 };
@@ -4353,6 +5609,206 @@ var createKoeVoice = async (ctx, destination, options) => {
         durationSec
       );
   };
+  const planner = getSpeechPlanner({
+    baseUrl: options.ttsBaseUrl
+  });
+  const toneViews = /* @__PURE__ */ new Map();
+  const toneViewFor = (token) => {
+    const k = token ?? "";
+    let v = toneViews.get(k);
+    if (!v) {
+      v = createSpeechToneView(backend.phonemes, token);
+      toneViews.set(k, v);
+    }
+    return v;
+  };
+  const toneFor = (pitch) => nearestPitchToken(backend.pitchTokens, unitsToMidiFloat(pitch))?.token ?? null;
+  const plans = /* @__PURE__ */ new Map();
+  const planFor = (text, token) => {
+    const k = `${token ?? ""}|${text}`;
+    let p = plans.get(k);
+    if (!p) {
+      p = (async () => {
+        try {
+          await planner.ready();
+          return planner.plan(toneViewFor(token).view, text, {
+            tone: token ?? "C4"
+          });
+        } catch (err2) {
+          console.warn(`[dtm] speech plan failed for "${text}"`, err2);
+          return null;
+        }
+      })();
+      plans.set(k, p);
+    }
+    return p;
+  };
+  const speechCache = /* @__PURE__ */ new Map();
+  const speechKeyOf = (text, pitch, expr) => `speak|${text}|${Math.round(pitch)}${expr?.gender !== void 0 ? `|g${Math.round(expr.gender * 100)}` : ""}${expr?.breathiness !== void 0 ? `|h${Math.round(expr.breathiness * 100)}` : ""}${expr?.tension !== void 0 ? `|t${Math.round(expr.tension * 100)}` : ""}`;
+  const SPEECH_PITCH_RATIO_MAX = 4;
+  const speechEntryFor = (text, pitch, expr) => {
+    const key = speechKeyOf(text, pitch, expr);
+    let entry = speechCache.get(key);
+    if (entry) return entry;
+    const abort = new AbortController();
+    let resolvePlanned;
+    const planned = new Promise((r) => {
+      resolvePlanned = r;
+    });
+    const e = {
+      planned,
+      rendered: Promise.resolve(),
+      durationSec: 0,
+      chunks: [],
+      done: false,
+      listeners: /* @__PURE__ */ new Set(),
+      abort
+    };
+    e.rendered = (async () => {
+      const token = toneFor(pitch);
+      const plan = await planFor(text, token);
+      if (!plan) {
+        e.done = true;
+        resolvePlanned(null);
+        return;
+      }
+      const view = toneViewFor(token);
+      const reference = plan.timeline.reference_hz || view.referenceHz || 0;
+      const ratio = reference > 0 ? Math.min(
+        SPEECH_PITCH_RATIO_MAX,
+        Math.max(
+          1 / SPEECH_PITCH_RATIO_MAX,
+          unitsToFreq(pitch) / reference
+        )
+      ) : 1;
+      const prepared = prepareSpeechPlan(plan, ratio, view.toReal);
+      e.durationSec = speechPlanDurationSec(prepared);
+      const leadingSec = speechPlanLeadingSec(prepared);
+      resolvePlanned(e.durationSec);
+      await backend.renderSpeech(
+        prepared,
+        expr,
+        (chunk) => {
+          const buf = ctx.createBuffer(1, chunk.pcm.length, KOE_SAMPLE_RATE);
+          buf.copyToChannel(chunk.pcm, 0);
+          const r = {
+            audio: buf,
+            startSec: chunk.startMs / 1e3 - leadingSec
+          };
+          e.chunks.push(r);
+          for (const l of e.listeners) l(r);
+        },
+        abort.signal
+      );
+      e.done = true;
+      e.listeners.clear();
+    })();
+    entry = e;
+    speechCache.set(key, entry);
+    return entry;
+  };
+  const placeSpeechChunk = (r, t0, peak, pan, reverbSend = 0, delaySend = 0, destOverride) => {
+    const dest = destOverride ?? destination;
+    let startAt = t0 + r.startSec;
+    let offset = 0;
+    const earliest = ctx.currentTime + 0.01;
+    if (startAt < earliest) {
+      offset = earliest - startAt;
+      startAt = earliest;
+    }
+    if (offset >= r.audio.duration - 5e-3) return;
+    let out = dest;
+    let panner = null;
+    if (typeof ctx.createStereoPanner === "function") {
+      panner = ctx.createStereoPanner();
+      panner.pan.value = Math.max(-1, Math.min(1, pan));
+      panner.connect(dest);
+      out = panner;
+    }
+    let reverbSendGain = null;
+    if (options.reverbBus && reverbSend > 0 && panner) {
+      reverbSendGain = ctx.createGain();
+      reverbSendGain.gain.value = Math.max(0, Math.min(1, reverbSend));
+      panner.connect(reverbSendGain).connect(options.reverbBus);
+    }
+    let delaySendGain = null;
+    if (options.delayBus && delaySend > 0 && panner) {
+      delaySendGain = ctx.createGain();
+      delaySendGain.gain.value = Math.max(0, Math.min(1, delaySend));
+      panner.connect(delaySendGain).connect(options.delayBus);
+    }
+    const env = ctx.createGain();
+    if (offset > 0) {
+      env.gain.setValueAtTime(1e-4, startAt);
+      env.gain.exponentialRampToValueAtTime(peak, startAt + 5e-3);
+    } else {
+      env.gain.setValueAtTime(peak, startAt);
+    }
+    const src = ctx.createBufferSource();
+    src.buffer = r.audio;
+    src.connect(env).connect(out);
+    src.start(startAt, offset);
+    active.add(src);
+    src.onended = () => {
+      active.delete(src);
+      src.disconnect();
+      env.disconnect();
+      panner?.disconnect();
+      reverbSendGain?.disconnect();
+      delaySendGain?.disconnect();
+    };
+  };
+  const speechListeners = /* @__PURE__ */ new Set();
+  model.speakToCache = async (text, pitch, expr, awaitRender) => {
+    const entry = speechEntryFor(text, pitch, expr);
+    const duration = await entry.planned;
+    if (duration === null) return null;
+    if (awaitRender) await entry.rendered;
+    return speechKeyOf(text, pitch, expr);
+  };
+  model.scheduleSpeech = (key, t0, peak, pan, reverbSend, delaySend, dest) => {
+    const entry = speechCache.get(key);
+    if (!entry) return;
+    const place = (r) => placeSpeechChunk(r, t0, peak, pan, reverbSend, delaySend, dest);
+    for (const r of entry.chunks) place(r);
+    if (!entry.done) {
+      entry.listeners.add(place);
+      const reg = { entry, listener: place };
+      speechListeners.add(reg);
+      void entry.rendered.then(() => speechListeners.delete(reg));
+    }
+  };
+  model.speechDurationSec = (key) => {
+    const entry = speechCache.get(key);
+    return entry && entry.durationSec > 0 ? entry.durationSec : void 0;
+  };
+  const previewDurations = /* @__PURE__ */ new Map();
+  model.planSpeech = async (text) => {
+    const cached = previewDurations.get(text);
+    if (cached !== void 0) return cached;
+    const token = backend.pitchTokens.length > 0 ? nearestPitchToken(
+      backend.pitchTokens,
+      unitsToMidiFloat(model.speechReferenceUnits?.() ?? 0)
+    )?.token ?? null : null;
+    const plan = await planFor(text, token);
+    if (!plan) return null;
+    const d = speechPlanDurationSec(plan);
+    previewDurations.set(text, d);
+    return d;
+  };
+  model.peekSpeechDurationSec = (text) => previewDurations.get(text);
+  model.speechReferenceUnits = () => {
+    const tokens = backend.pitchTokens;
+    let hz;
+    if (tokens.length > 0) {
+      const sorted = tokens.slice().sort((a, b) => a.midi - b.midi);
+      hz = toneViewFor(sorted[sorted.length >> 1].token).referenceHz;
+    } else {
+      hz = toneViewFor(null).referenceHz;
+    }
+    if (!hz || hz <= 0) return void 0;
+    return Math.round(2139 + 372 * Math.log2(hz / 440));
+  };
   model.stopAll = () => {
     for (const src of active) {
       try {
@@ -4362,6 +5818,9 @@ var createKoeVoice = async (ctx, destination, options) => {
       src.disconnect();
     }
     active.clear();
+    for (const { entry, listener } of speechListeners)
+      entry.listeners.delete(listener);
+    speechListeners.clear();
   };
   model.reset = () => {
     prevVowel = "";
@@ -4540,7 +5999,8 @@ var createSingingVoices = (ctx, destination, options = {}) => {
         lightweight: options.lightweight,
         voiceWorkerUrl: options.voiceWorkerUrl,
         reverbBus: options.reverbBus,
-        delayBus: options.delayBus
+        delayBus: options.delayBus,
+        ttsBaseUrl: options.ttsBaseUrl
       })
     ))().then((v) => {
       loaded.set(m, v);
@@ -4575,6 +6035,11 @@ var createSingingVoices = (ctx, destination, options = {}) => {
         prevVowel = "";
         continue;
       }
+      if (syl.kind === "speak") {
+        fn(note, "");
+        prevVowel = "";
+        continue;
+      }
       if (syl.consonant === "Q" || syl.vowel === "") continue;
       fn(note, prevVowel);
       if (syl.vowel && syl.vowel !== "N") prevVowel = syl.vowel;
@@ -4595,6 +6060,17 @@ var createSingingVoices = (ctx, destination, options = {}) => {
       forEachSungNote(track, (note, prevVowel) => {
         if (n >= count && note.startSec >= STREAM_LOOKAHEAD_SEC) return;
         n++;
+        if (note.syllable.kind === "speak") {
+          tasks.push({
+            model: m,
+            note,
+            prevVowel: "",
+            pitch: note.pitch,
+            expr,
+            speak: note.syllable.text ?? ""
+          });
+          return;
+        }
         tasks.push({
           model: m,
           note,
@@ -4625,15 +6101,24 @@ var createSingingVoices = (ctx, destination, options = {}) => {
     let done = 0;
     onProgress?.(done, total);
     const promises = tasks.map(async (task) => {
-      await (task.model.renderToCache?.(
-        task.note.syllable,
-        task.prevVowel,
-        task.pitch,
-        task.note.durationSec * 1e3,
-        task.vibrato,
-        task.expr,
-        task.pitchSegments
-      ) ?? Promise.resolve(null));
+      if (task.speak !== void 0) {
+        await (task.model.speakToCache?.(
+          task.speak,
+          task.pitch,
+          task.expr,
+          true
+        ) ?? Promise.resolve(null));
+      } else {
+        await (task.model.renderToCache?.(
+          task.note.syllable,
+          task.prevVowel,
+          task.pitch,
+          task.note.durationSec * 1e3,
+          task.vibrato,
+          task.expr,
+          task.pitchSegments
+        ) ?? Promise.resolve(null));
+      }
       done++;
       onProgress?.(done, total);
     });
@@ -4670,6 +6155,49 @@ var createSingingVoices = (ctx, destination, options = {}) => {
           }
           if (opts?.isAudible && !opts.isAudible(track)) continue;
           const t0 = anchorTime + startSec;
+          if (note.syllable.kind === "speak") {
+            const text = note.syllable.text ?? "";
+            if (text && model.speakToCache && model.scheduleSpeech) {
+              const speakToCache = model.speakToCache;
+              const scheduleSpeech = model.scheduleSpeech;
+              const dest = options.getTrackDestination?.(track.id ?? "");
+              const effPeak = dest ? peak * masterVolumeScalar : peak;
+              void (async () => {
+                const key = await speakToCache(text, note.pitch, {
+                  gender: track.gender,
+                  breathiness: track.breathiness,
+                  tension: track.tension
+                });
+                if (session !== streamSession || !key) return;
+                const delay = ctx.currentTime - t0;
+                if (delay < 1) {
+                  scheduleSpeech(
+                    key,
+                    t0,
+                    effPeak,
+                    track.pan,
+                    track.reverbSend,
+                    track.delaySend,
+                    dest
+                  );
+                  opts?.onScheduled?.(
+                    track,
+                    {
+                      ...note,
+                      durationSec: model.speechDurationSec?.(key) ?? note.durationSec
+                    },
+                    t0
+                  );
+                } else {
+                  console.warn(
+                    `[dtm] Speech late skip: \u300C${text}\u300D at ${startSec}s (delayed by ${delay.toFixed(3)}s)`
+                  );
+                  opts?.onLateSkip?.(note, delay);
+                }
+              })();
+            }
+            continue;
+          }
           const dispatchNote = (offsetUnits, peakScale) => {
             const pitch = units(note.pitch + offsetUnits);
             const pitchSegments = transposeSegments(
@@ -4796,6 +6324,12 @@ var createSingingVoices = (ctx, destination, options = {}) => {
     masterGain.gain.value = g;
     masterVolumeScalar = g;
   };
+  const planSpeech = async (model, text) => {
+    const v = await load2(model);
+    return v?.planSpeech ? v.planSpeech(text) : null;
+  };
+  const peekSpeechDurationSec = (model, text) => loaded.get(model.toLowerCase())?.peekSpeechDurationSec?.(text);
+  const getSpeechReferenceUnits = (model) => loaded.get(model.toLowerCase())?.speechReferenceUnits?.();
   return {
     loadModels,
     registerVoicebanks,
@@ -4803,7 +6337,10 @@ var createSingingVoices = (ctx, destination, options = {}) => {
     startStream,
     stopStream,
     reset,
-    setVolume
+    setVolume,
+    planSpeech,
+    peekSpeechDurationSec,
+    getSpeechReferenceUnits
   };
 };
 var createVoiceRegistry = (models = {}, fallback = "klatt") => {
@@ -4824,7 +6361,7 @@ var NATURAL_STEPS2 = {
 };
 var isNatural = (ch) => Object.hasOwn(NATURAL_STEPS2[12], ch);
 var clamp3 = (value, lo, hi) => Math.min(hi, Math.max(lo, value));
-var META_DIRECTIVE = /#(inst|drum|drumfont|volume|drumvolume|reverb|reverbdecay|reverbpredelay|delay|delaydiv|mastercomp|fadein|fadeout|mode|edo|loop)=([\w:-]+)/gi;
+var META_DIRECTIVE = /#(ver|seed|compose|inst|drum|drumfont|volume|drumvolume|reverb|reverbdecay|reverbpredelay|delay|delaydiv|mastercomp|fadein|fadeout|mode|edo|loop)=([\w:.-]+)/gi;
 var AUDIO_URL_DIRECTIVE = /#audio=([^\s#;\r\n]+)/gi;
 var AUDIO_NUM_DIRECTIVE = /#audio(start|end|offset|at|vol)=(-?\d+(?:\.\d+)?)/gi;
 var TRACK_INST_DIRECTIVE = /#t(\d+)inst=([^#;\r\n]+)/gi;
@@ -4841,6 +6378,10 @@ var parseMmlMeta = (mml) => {
   for (const m of mml.matchAll(META_DIRECTIVE)) {
     const key = m[1].toLowerCase();
     if (key === "ver") meta.version = m[2];
+    else if (key === "seed") {
+      const n = Number.parseInt(m[2], 10);
+      if (Number.isFinite(n) && n >= 0) meta.seed = n;
+    } else if (key === "compose") meta.compose = m[2];
     else if (key === "inst") meta.instrument = m[2];
     else if (key === "drum") meta.drum = m[2];
     else if (key === "drumfont") meta.drumFont = m[2];
@@ -5008,6 +6549,8 @@ var formatMmlMeta = (meta, space = "") => {
   if (meta.mode) parts.push(`#mode=${meta.mode}`);
   if (meta.edo !== void 0 && meta.edo !== 12) parts.push(`#edo=${meta.edo}`);
   if (meta.loop) parts.push("#loop=on");
+  if (meta.seed !== void 0) parts.push(`#seed=${meta.seed}`);
+  if (meta.compose) parts.push(`#compose=${meta.compose}`);
   if (meta.audio) {
     parts.push(`#audio=${meta.audio}`);
     if (meta.audioStart) parts.push(`#audiostart=${round3(meta.audioStart)}`);
@@ -8438,6 +9981,78 @@ var DAW_CSS = `
 .dtm-daw *::before,
 .dtm-daw *::after { box-sizing: border-box; }
 
+/* \u2500\u2500\u2500 \u30EC\u30A4\u30A2\u30A6\u30C8\uFF08\u7DE8\u96C6\u30D8\u30C3\u30C9\u306E\u8CBC\u308A\u4ED8\u3051\uFF09 \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
+   \u30D1\u30CD\u30EB\u306F\u7E26\u306B\u7A4D\u3080\u3057\u304B\u306A\u3044\u306E\u3067\u3001\u958B\u304F\u307B\u3069\u30D4\u30A2\u30CE\u30ED\u30FC\u30EB\u304C\u753B\u9762\u5916\u3078\u6D41\u308C\u3066\u3044\u304F\u3002
+   \u30D8\u30C3\u30C9\uFF08\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u30FB\u30C4\u30FC\u30EB\u30FB\u30ED\u30FC\u30EB\uFF09\u3092 sticky \u3067\u753B\u9762\u4E0A\u90E8\u306B\u7559\u3081\u308C\u3070\u3001
+   \u4F55\u679A\u958B\u3044\u3066\u3082\u30ED\u30FC\u30EB\u3068\u306E\u8DDD\u96E2\u306F0\u306E\u307E\u307E\u306B\u306A\u308B\u3002
+
+   \u305F\u3060\u30571\u30AB\u30E9\u30E0\u306E\u3042\u3044\u3060\u3001\u8CBC\u3063\u305F\u30D8\u30C3\u30C9\u306F\u305D\u306E\u9AD8\u3055\u3076\u3093\u753B\u9762\u3092\u5360\u6709\u3057\u7D9A\u3051\u308B\u3002
+   \u30D8\u30C3\u30C9\u306E\u9AD8\u3055\u306F\u300C\u56FA\u5B9A\u90E8\u304A\u3088\u305D194px \uFF0B \u30ED\u30FC\u30EB32vh\u300D\u306A\u306E\u3067\u3001\u753B\u9762\u304C\u4F4E\u3044\u307B\u3069
+   \u5360\u6709\u7387\u304C\u4E0A\u304C\u308B\uFF08844px\u306755%\u3001667px\u306764%\uFF09\u3002\u5360\u6709\u7387\u304C6\u5272\u3092\u5207\u308B\u7E26760px\u4EE5\u4E0A\u3067
+   \u3060\u3051\u8CBC\u308A\u3001\u305D\u308C\u672A\u6E80\u306F\u5F93\u6765\u3069\u304A\u308A\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u3060\u3051\u3092\u8CBC\u308B\u3002
+   \uFF08\u6A2A\u306B\u5272\u3063\u3066\u7E26\u306E\u53D6\u308A\u5408\u3044\u3092\u7121\u304F\u30592\u30AB\u30E9\u30E0\u6848\u306F\u3001\u30C7\u30E2\u306E #app \u304C max-w-4xl \u306E
+   \u305F\u3081\u4ECA\u306E\u307E\u307E\u3060\u3068\u30ED\u30FC\u30EB\u304C\u7D30\u304F\u306A\u308B\u306E\u3067\u898B\u9001\u3063\u3066\u3044\u308B\u3002\uFF09 */
+.dtm-daw-panels {
+  display: flex;
+  flex-direction: column;
+  gap: var(--dtm-gap);
+  min-width: 0;
+}
+/* \u8CBC\u3089\u306A\u3044\u753B\u9762\u3067\u306F\u7BB1\u3054\u3068\u7573\u3080\u3002display:contents \u306A\u3089\u4E2D\u8EAB\u304C .dtm-daw \u306E\u76F4\u63A5\u306E
+   \u5B50\u306B\u623B\u308B\u306E\u3067\u3001\u4F59\u767D\u3082\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u306E sticky \u57FA\u6E96\u3082\u5F93\u6765\u306E\u307E\u307E\u5909\u308F\u3089\u306A\u3044\u3002 */
+.dtm-daw-head { display: contents; }
+.dtm-topbar {
+  position: sticky;
+  top: 0;
+  z-index: 20;
+}
+@media (min-height: 760px) {
+  .dtm-daw-head {
+    display: flex;
+    flex-direction: column;
+    gap: var(--dtm-gap);
+    min-width: 0;
+    position: sticky;
+    top: 0;
+    z-index: 20;
+    /* \u4E0B\u3092\u304F\u3050\u308B\u30D1\u30CD\u30EB\u3092\u900F\u304B\u3055\u306A\u3044\u305F\u3081\u306E\u4E0D\u900F\u660E\u306A\u4E0B\u6577\u304D\u3002
+       .dtm-daw \u306E gap \u3076\u3093\u3092 padding \u3067\u57CB\u3081\u3001\u9699\u9593\u304B\u3089\u4E2D\u8EAB\u3092\u898B\u305B\u306A\u3044\u3002 */
+    background: var(--dtm-bg);
+    padding-bottom: var(--dtm-gap);
+  }
+}
+
+/* \u30A8\u30C7\u30A3\u30BF\u81EA\u8EAB\u304C\u5341\u5206\u306B\u5E83\u3044\u3068\u304D\u306F\u3001\u30D8\u30C3\u30C9\u3068\u30D1\u30CD\u30EB\u3092\u5DE6\u53F3\u306B\u4E26\u3079\u3066\u3001\u7E26\u306E
+   \u7A4D\u307F\u4E0A\u304C\u308A\u3092\u6A2A\u3078\u9003\u304C\u3059\u3002\u3053\u3046\u306A\u308B\u3068\u30D8\u30C3\u30C9\u306F\u30D1\u30CD\u30EB\u304B\u3089\u7E26\u3092\u596A\u308F\u306A\u3044\u306E\u3067\u3001
+   \u753B\u9762\u306E\u9AD8\u3055\u306B\u95A2\u4FC2\u306A\u304F\u8CBC\u308C\u308B\u3057\u3001\u30ED\u30FC\u30EB\u3082\u5E83\u304F\u4F7F\u3048\u308B
+   \uFF08.dtm-daw--wide \u306F daw.ts \u306E ResizeObserver \u304C\u4ED8\u3051\u308B\uFF09\u3002 */
+.dtm-daw--wide {
+  flex-direction: row;
+  align-items: flex-start;
+}
+.dtm-daw--wide .dtm-daw-head {
+  display: flex;
+  flex-direction: column;
+  gap: var(--dtm-gap);
+  min-width: 0;
+  flex: 1 1 auto;
+  position: sticky;
+  top: 0;
+  z-index: 20;
+  background: var(--dtm-bg);
+  padding-bottom: 0;
+}
+.dtm-daw--wide .dtm-daw-panels {
+  flex: 0 0 360px;
+}
+/* 768px \u6642\u70B9\u306E height:420px \u306F max-height:32vh \u306B\u982D\u6253\u3061\u306B\u3055\u308C\u3066\u3044\u305F\u3002
+   2\u30AB\u30E9\u30E0\u3067\u306F\u7E26\u3092\u53D6\u308A\u5408\u308F\u306A\u3044\u306E\u3067\u3001\u305D\u306E\u610F\u56F3\u3069\u304A\u308A\u306E\u9AD8\u3055\u3092\u89E3\u7981\u3059\u308B
+   \uFF08\u4F4E\u3044\u753B\u9762\u3067\u306F 45vh \u3067\u982D\u6253\u3061\u306B\u3057\u3066\u753B\u9762\u3092\u98DF\u3044\u6F70\u3055\u306A\u3044\u3088\u3046\u306B\u3059\u308B\uFF09\u3002 */
+.dtm-daw--wide .dtm-roll {
+  height: min(420px, 45vh);
+  max-height: none;
+}
+
 /* \u2500\u2500\u2500 \u30B2\u30FC\u30E0\u30A6\u30A3\u30F3\u30C9\u30A6\u5171\u901A\u67A0 \u2500\u2500\u2500 */
 /* \u5916\u67A0(\u9ED22px) \u2192 \u8272\u4ED8\u304D2px border \u2192 \u5185\u67A0(\u9ED2inset2px) \u306E3\u91CD\u69CB\u9020 */
 .dtm-win {
@@ -8500,9 +10115,6 @@ var DAW_CSS = `
 
 /* \u2500\u2500\u2500 \u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u30D0\u30FC\uFF08HUD\u30B9\u30BF\u30A4\u30EB\uFF09 \u2500\u2500\u2500 */
 .dtm-topbar {
-  position: sticky;
-  top: 0;
-  z-index: 20;
   display: flex;
   flex-wrap: wrap;
   align-items: center;
@@ -8947,19 +10559,17 @@ var DAW_CSS = `
 .dtm-row { display: flex; flex-wrap: wrap; align-items: center; gap: 8px; }
 .dtm-track-body { display: flex; flex-direction: column; gap: 10px; }
 
-/* \u2500\u2500\u2500 \u81EA\u52D5\u4F5C\u66F2\u30B3\u30F3\u30C6\u30CA\uFF08\u30DE\u30AF\u30ED\u30D1\u30CD\u30EB\u5185\u306E\u5C02\u7528\u30AB\u30FC\u30C9\u98A8\u30B0\u30EB\u30FC\u30D7\u67A0\uFF09 \u2500\u2500\u2500 */
-.dtm-compose-container {
-  background: var(--dtm-deep);
-  border: 2px solid var(--c-black);
+/* \u2500\u2500\u2500 \u81EA\u52D5\u4F5C\u66F2\u30D1\u30CD\u30EB\uFF08\u770B\u677F\u6A5F\u80FD\u306A\u306E\u3067\u67A0\u3068\u898B\u51FA\u3057\u3092 success \u8272\u3067\u5DEE\u5225\u5316\u3059\u308B\uFF09 \u2500\u2500\u2500 */
+.dtm-panel--compose {
   box-shadow:
-    inset 0 0 0 1px var(--dtm-border2),
-    0 0 0 1px var(--dtm-success),
-    3px 3px 0 var(--c-black);
-  padding: 10px 12px 12px;
-  display: flex;
-  flex-direction: column;
-  gap: 10px;
-  margin-bottom: 6px;
+    inset 0 0 0 2px var(--c-black),
+    0 0 0 2px var(--dtm-success),
+    4px 4px 0 var(--c-black);
+}
+.dtm-panel--compose > summary { color: var(--dtm-success); }
+.dtm-panel--compose > summary::before,
+.dtm-panel--compose[open] > summary::before {
+  background: var(--dtm-success);
 }
 
 /* \u2500\u2500\u2500 \u30A2\u30AF\u30C6\u30A3\u30D6\u30C8\u30E9\u30C3\u30AF\u8272\uFF08\u500B\u5225\u30C8\u30E9\u30C3\u30AF\u8A2D\u5B9A\u30D1\u30CD\u30EB\u306E\u5DE6\u7AEF\u30E9\u30A4\u30F3\uFF09 \u2500\u2500\u2500 */
@@ -10072,6 +11682,8 @@ var DAW_CSS = `
 /* \u4FC3\u97F3\uFF08\u3063\uFF09\u30FB\u4F11\u7B26\uFF08_\uFF09\u306F\u6B4C\u308F\u306A\u3044\u30CE\u30FC\u30C8\u3002\u3055\u3089\u306B\u843D\u3068\u3057\u3066\u7121\u97F3\u3067\u3042\u308B\u3053\u3068\u3092\u793A\u3059 */
 .dtm-tk--lyric-stop,
 .dtm-tk--lyric-rest { color: var(--dtm-border2); }
+/* \u8A9E\u308A\uFF08\u300C\u2026\u300D\uFF09\u306F\u6B4C\u308F\u305A\u306B\u8AAD\u307F\u4E0A\u3052\u308B 1 \u30CE\u30FC\u30C8\u3002\u6B4C\u8A5E\u3068\u533A\u5225\u3067\u304D\u308B\u3088\u3046\u5F37\u8ABF\u8272\u306B\u3059\u308B */
+.dtm-tk--lyric-speak { color: var(--dtm-primary); letter-spacing: 0; }
 .dtm-tk--break { color: var(--dtm-muted); opacity: 0.7; margin: 0 2px; }
 .dtm-tk--meta { color: var(--dtm-border2); margin-right: 4px; }
 .dtm-tk.is-active {
@@ -21765,6 +23377,16 @@ var BASS_SKELETONS = [
   "pedal"
 ];
 var pick = (items, rnd) => items[Math.floor(rnd() * items.length)];
+var seededRandom = (seed) => {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+};
 var durationEntropy = (durations) => {
   if (durations.length === 0) return 0;
   const counts = /* @__PURE__ */ new Map();
@@ -24708,6 +26330,10 @@ var buildUI = (target, options) => {
   ).join("");
   target.innerHTML = `
 <div class="dtm-daw" data-dtm="root">
+  <!-- \u7DE8\u96C6\u30D8\u30C3\u30C9\u3002\u30C8\u30E9\u30F3\u30B9\u30DD\u30FC\u30C8\u30FB\u30C4\u30FC\u30EB\u30FB\u30D4\u30A2\u30CE\u30ED\u30FC\u30EB\u3092\u3072\u3068\u307E\u3068\u3081\u306B\u3057\u3066
+       \u753B\u9762\u4E0A\u90E8\u3078\u8CBC\u308A\u4ED8\u3051\u308B\uFF08.dtm-daw-head \u304C position:sticky\uFF09\u3002\u30D1\u30CD\u30EB\u3092
+       \u3044\u304F\u3064\u958B\u3044\u3066\u3082\u30ED\u30FC\u30EB\u304C\u8996\u754C\u304B\u3089\u6D88\u3048\u306A\u3044\u3088\u3046\u306B\u3059\u308B\u305F\u3081\u306E\u7BB1\u3002 -->
+  <div class="dtm-daw-head">
   <div class="dtm-topbar" data-dtm="transport">
     <div class="dtm-topbar-row1">
       <button class="dtm-iconbtn" data-dtm="prev-bar" title="1\u5C0F\u7BC0\u524D">${icon("chevronLeft")}</button>
@@ -24752,6 +26378,10 @@ var buildUI = (target, options) => {
     <div class="dtm-vscroll" data-dtm="vscroll"><div class="dtm-vscroll-thumb" data-dtm="vscroll-thumb"></div></div>
   </div>
   <div class="dtm-hscroll" data-dtm="hscroll"><div class="dtm-hscroll-thumb" data-dtm="hscroll-thumb"></div></div>
+  </div>
+
+  <!-- \u8A2D\u5B9A\u30D1\u30CD\u30EB\u7FA4\u3002\u5E83\u3044\u753B\u9762\u3067\u306F\u30D8\u30C3\u30C9\u306E\u53F3\u96A3\u306B\u7ACB\u3064\u72EC\u7ACB\u3057\u305F\u5217\u306B\u306A\u308B\u3002 -->
+  <div class="dtm-daw-panels">
 
   <details class="dtm-panel" data-dtm-acc="track" open>
     <summary>\u500B\u5225\u30C8\u30E9\u30C3\u30AF\u8A2D\u5B9A</summary>
@@ -24950,7 +26580,7 @@ var buildUI = (target, options) => {
   </details>
 
   <details class="dtm-panel ${showMidi ? "" : "dtm-hidden"}" data-dtm="midi-panel" data-dtm-acc="io-in">
-    <summary>MIDI / UST / MML \u5165\u529B</summary>
+    <summary>MIDI / MusicXML / UST / MML \u5165\u529B</summary>
     <div class="dtm-panel-body">
       <div class="dtm-row" style="flex-wrap:nowrap">
         <div style="display: inline-flex; flex-direction: column; align-items: center; gap: 4px; justify-content: center; flex-shrink:0;">
@@ -24961,6 +26591,16 @@ var buildUI = (target, options) => {
         <button class="dtm-btn dtm-btn--success" data-dtm="midi-load" style="flex-shrink:0">\u8AAD\u8FBC</button>
       </div>
       <div class="dtm-row dtm-hidden" data-dtm="midi-track-selection"></div>
+      <div class="dtm-row" style="flex-wrap:nowrap">
+        <div style="display: inline-flex; flex-direction: column; align-items: center; gap: 4px; justify-content: center; flex-shrink:0;">
+          <span class="dtm-label" style="line-height: 1;">MusicXML</span>
+          <button class="dtm-infobtn" data-dtm="musicxml-info" title="MusicXML\u306E\u8AAD\u307F\u8FBC\u307F\u89E3\u8AAC">${icon("info", 12)}</button>
+        </div>
+        <input type="file" class="dtm-input dtm-grow" accept=".musicxml,.xml" data-dtm="musicxml-input" style="min-width:0">
+        <button class="dtm-btn dtm-btn--success" data-dtm="musicxml-load" style="flex-shrink:0">\u8AAD\u8FBC</button>
+      </div>
+      <div class="dtm-row dtm-hidden" data-dtm="musicxml-part-selection"></div>
+      <p class="dtm-load-note dtm-hidden" data-dtm="musicxml-load-note"></p>
       <div class="dtm-row" style="flex-wrap:nowrap">
         <div style="display: inline-flex; flex-direction: column; align-items: center; gap: 4px; justify-content: center; flex-shrink:0;">
           <span class="dtm-label" style="line-height: 1;">UST</span>
@@ -24990,129 +26630,135 @@ var buildUI = (target, options) => {
     </div>
   </details>
 
-  <details class="dtm-panel" data-dtm-acc="macro">
-    <summary>\u30DE\u30AF\u30ED</summary>
+  <details class="dtm-panel dtm-panel--compose ${showCompose ? "" : "dtm-hidden"}" data-dtm-acc="compose">
+    <summary>\u81EA\u52D5\u4F5C\u66F2</summary>
     <div class="dtm-panel-body">
-      <div class="dtm-compose-container ${showCompose ? "" : "dtm-hidden"}" data-dtm="compose-container">
-        <div class="dtm-row" data-dtm="compose-row">
-          <button class="dtm-btn dtm-btn--success" data-dtm="macro-compose" title="\u30B3\u30FC\u30C9\u9032\u884C\u30FB\u30E1\u30ED\u30C7\u30A3\u30FB\u30B5\u30D6\u30E1\u30ED\u30FB\u30D9\u30FC\u30B9\u30FB\u4F34\u594F\u30FB\u30C9\u30E9\u30E0\u3092\u81EA\u52D5\u3067\u4F5C\u308A\u307E\u3059">\u4F5C\u66F2</button>
-          <button class="dtm-btn dtm-btn--success" data-dtm="macro-compose-vocal" title="\u4F5C\u66F2\u3057\u305F\u3046\u3048\u3067\u3001\u30E1\u30ED\u30C7\u30A3\u306B\u6B4C\u8A5E\u3092\u4ED8\u3051\u3066\u6B4C\u308F\u305B\u307E\u3059">\u6B4C\u5165\u308A\u4F5C\u66F2</button>
-          <button class="dtm-infobtn" data-dtm="macro-compose-info" title="\u4F5C\u66F2\u306E\u89E3\u8AAC">${icon("info", 12)}</button>
-          <!--
-            **\u30AD\u30FC\u30D7\u67A0\u306F1\u3064\u3060\u3051\u3002** \u81EA\u52D5\u4F5C\u66F2\u306F\u6C17\u306B\u5165\u308B\u307E\u3067\u5F15\u304D\u76F4\u3059\u4F7F\u3044\u65B9\u306B\u306A\u308B\u304C\u3001
-            \u300C\u5F15\u304D\u76F4\u3059\u3068\u4ECA\u306E\u304C\u6D88\u3048\u308B\u300D\u3068\u601D\u3046\u3068\u5F15\u304D\u76F4\u305B\u306A\u304F\u306A\u308B\u3002\u53D6\u3063\u3066\u304A\u3051\u308B\u5834\u6240\u304C
-            1\u3064\u3042\u308C\u3070\u30012\u3064\u3092\u6BD4\u3079\u3066\u9078\u3076\u3053\u3068\u306F\u6210\u7ACB\u3059\u308B\u3002\u5019\u88DC\u3092\u4E26\u3079\u308BUI\u306F\u30B9\u30DE\u30DB\u3067\u306F
-            \u6210\u7ACB\u3057\u306A\u3044\uFF08\u8A66\u8074\u6642\u9593\u30FB\u753B\u9762\u30FB\u751F\u6210\u30B3\u30B9\u30C8\u306E\u3069\u308C\u3082\u8DB3\u308A\u306A\u3044\uFF09\u3002
-          -->
-          <button class="dtm-btn" data-dtm="compose-keep" title="\u4ECA\u306E\u66F2\u30921\u3064\u3060\u3051\u53D6\u3063\u3066\u304A\u304D\u307E\u3059\u3002\u4F5C\u66F2\u3092\u62BC\u3057\u76F4\u3057\u3066\u3082\u6D88\u3048\u307E\u305B\u3093">\u30AD\u30FC\u30D7</button>
-          <button class="dtm-btn" data-dtm="compose-recall" title="\u30AD\u30FC\u30D7\u3057\u305F\u66F2\u306B\u623B\u3057\u307E\u3059" disabled>\u547C\u3073\u51FA\u3059</button>
-          <span class="dtm-grow"></span>
-        </div>
-        <div class="dtm-row" data-dtm="compose-template-row">
-          <span class="dtm-label">\u69CB\u6210</span>
-          <select class="dtm-select" data-dtm="compose-template" title="J-POP\u738B\u9053\u306A\u3069\u306E\u30D7\u30EA\u30BB\u30C3\u30C8\u69CB\u6210\u3092\u9078\u3073\u307E\u3059">
-            <option value="custom">\u81EA\u7531\u9078\u629E\uFF08\u4E0B\u8A18\u30C1\u30A7\u30C3\u30AF\uFF09</option>
-            <option value="1chorus">1\u30B3\u30FC\u30E9\u30B9\uFF08\u77ED\u3081\u30FB\u521D\u5FC3\u8005\u5411\u3051\uFF09</option>
-            <option value="jpop_standard">JPOP\u738B\u9053\uFF08\u30DE\u30EA\u30FC\u30B4\u30FC\u30EB\u30C9\u578B 2\u756A/C\u30E1\u30ED/\u30E9\u30B9\u30B5\u30D3\uFF09</option>
-            <option value="jpop_drop">\u843D\u3061\u30B5\u30D3\u5165\u308A\uFF08JPOP\u738B\u9053 + \u30E9\u30B9\u30B5\u30D3\u524D\u843D\u3061\u30B5\u30D3\uFF09</option>
-            <option value="vocaloid">\u30DC\u30AB\u30ED\u738B\u9053\uFF08\u75BE\u8D70\u30FB2\u756A/C\u30E1\u30ED/\u30E9\u30B9\u30B5\u30D3\uFF09</option>
-            <option value="verse_chorus">Verse-Chorus\uFF08B\u30E1\u30ED\u306A\u3057\u30FB\u6D0B\u697D\u98A8\uFF09</option>
-          </select>
-        </div>
-        <div class="dtm-row" data-dtm="compose-sections-row">
-          <span class="dtm-label">\u4F5C\u308B\u90E8\u5206</span>
-          <div class="dtm-checks" data-dtm="compose-sections">
-            <label class="dtm-check"><input type="checkbox" value="intro" checked>\u30A4\u30F3\u30C8\u30ED</label>
-            <label class="dtm-check"><input type="checkbox" value="verse" checked>A\u30E1\u30ED</label>
-            <label class="dtm-check"><input type="checkbox" value="prechorus" checked>B\u30E1\u30ED</label>
-            <label class="dtm-check"><input type="checkbox" value="chorus" checked>\u30B5\u30D3</label>
-            <label class="dtm-check"><input type="checkbox" value="bridge">C\u30E1\u30ED</label>
-            <label class="dtm-check"><input type="checkbox" value="drop_chorus">\u843D\u3061\u30B5\u30D3</label>
-            <label class="dtm-check"><input type="checkbox" value="interlude">\u9593\u594F</label>
-            <label class="dtm-check"><input type="checkbox" value="outro">\u30A2\u30A6\u30C8\u30ED</label>
-          </div>
-          <span class="dtm-grow"></span>
-          <span class="dtm-hint" data-dtm="compose-sections-len"></span>
-        </div>
-        <div class="dtm-row" data-dtm="compose-key-row">
-          <span class="dtm-label">\u30D9\u30FC\u30B9\u8ABF</span>
-          <select class="dtm-select" data-dtm="compose-key" title="\u81EA\u52D5\u4F5C\u66F2\u306E\u30D9\u30FC\u30B9\u3068\u306A\u308B\u8ABF\u3084\u96F0\u56F2\u6C17\u3092\u9078\u3073\u307E\u3059">
-            <option value="any" title="\u516824\u8ABF\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u6C7A\u5B9A\u3057\u307E\u3059">\u5E0C\u671B\u306A\u3057</option>
-            <optgroup label="\u57FA\u672C">
-              <option value="major" title="12\u306E\u9577\u8ABF\u306E\u4E2D\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u62BD\u9078\u3057\u307E\u3059">\u9577\u8ABF</option>
-              <option value="minor" title="12\u306E\u77ED\u8ABF\u306E\u4E2D\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u62BD\u9078\u3057\u307E\u3059">\u77ED\u8ABF</option>
-            </optgroup>
-            <optgroup label="\u96F0\u56F2\u6C17\u304B\u3089\u9078\u3076\uFF08\u62BD\u9078\uFF09">
-              <option value="mood_happy" title="\u30CF\u9577\u8ABF\u30FB\u30A4\u9577\u8ABF\u30FB\u5909\u30ED\u9577\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u7121\u57A2\u306B\u559C\u3070\u3057\u3044\u3001\u7267\u6B4C\u7684\u3001\u967D\u6C17\uFF09">\u559C\u3070\u3057\u3044\u30FB\u967D\u6C17\u306A\u66F2</option>
-              <option value="mood_triumphant" title="\u30CB\u9577\u8ABF\u30FB\u5909\u30C8\u9577\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u610F\u6C17\u63DA\u3005\u3001\u52DD\u5229\u306E\u558A\u58F0\u3001\u56F0\u96E3\u6253\u7834\u3001\u5B89\u5835\uFF09">\u52DD\u5229\u30FB\u529B\u5F37\u3044\u66F2</option>
-              <option value="mood_fierce" title="\u30DB\u9577\u8ABF\u30FB\u30D8\u9577\u8ABF\u30FB\u30ED\u9577\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u3051\u3093\u304B\u3063\u65E9\u3044\u3001\u6012\u308A\u72C2\u3063\u305F\u8352\u3005\u3057\u3055\u3001\u3069\u304E\u3064\u304F\u731B\u70C8\uFF09">\u6FC0\u3057\u3044\u30FB\u8352\u3005\u3057\u3044\u66F2</option>
-              <option value="mood_solemn" title="\u30C8\u9577\u8ABF\u30FB\u30CB\u77ED\u8ABF\u30FB\u30A4\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u53B3\u7C9B\u3001\u5D07\u9AD8\u3001\u5E7B\u60F3\u3001\u656C\u8654\u3001\u601D\u7D22\u7684\uFF09">\u53B3\u7C9B\u30FB\u5E7B\u60F3\u7684\u306A\u66F2</option>
-              <option value="mood_plaintive" title="\u30CF\u77ED\u8ABF\u30FB\u30DB\u77ED\u8ABF\u30FB\u30D8\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u7D14\u7C8B\u306B\u60B2\u3057\u3052\u3001\u604B\u308F\u305A\u3089\u3044\u3001\u843D\u3061\u7740\u304D\u306E\u306A\u3044\u3001\u7269\u60B2\u3057\u3044\u54C0\u6101\uFF09">\u7269\u60B2\u3057\u3044\u30FB\u54C0\u6101\u306E\u66F2</option>
-              <option value="mood_melancholy" title="\u5909\u30CB\u9577\u8ABF\u30FB\u30ED\u77ED\u8ABF\u30FB\u5B30\u30CF\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u60B2\u3057\u307F\u3001\u6182\u9B31\u3001\u5B64\u72EC\u3001\u5FCD\u8010\u3001\u843D\u80C6\u3001\u60B2\u6D99\uFF09">\u6182\u9B31\u30FB\u5B64\u72EC\u306A\u66F2</option>
-              <option value="mood_anxious" title="\u30C8\u77ED\u8ABF\u30FB\u5909\u30DB\u77ED\u8ABF\u30FB\u5B30\u30D8\u77ED\u8ABF\u30FB\u5909\u30A4\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u4E0D\u6E80\u3001\u4E0D\u5B89\u3001\u6DF1\u3044\u82E6\u60A9\u3001\u9670\u6C17\u306A\u61A4\u308A\uFF09">\u4E0D\u5B89\u30FB\u82E6\u60A9\u306A\u66F2</option>
-              <option value="mood_dark" title="\u5909\u30DB\u9577\u8ABF\u30FB\u5909\u30A4\u9577\u8ABF\u30FB\u5909\u30ED\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u53B3\u3057\u3044\u611B\u3001\u6B7B\u3001\u6C38\u9060\u3001\u88C1\u304D\u3001\u6697\u95C7\u3001\u6050\u308D\u3057\u3044\u5632\u308A\uFF09">\u6697\u95C7\u30FB\u91CD\u539A\u306A\u66F2</option>
-            </optgroup>
-            <optgroup label="\u9577\u8ABF\uFF08\u500B\u5225\u6307\u5B9A\uFF09">
-              <option value="key_C" title="\u7121\u57A2\u306B\u559C\u3070\u3057\u3044\u3001\u7D14\u7C8B\u3001\u7D20\u6734\u3001\u51FA\u767A">\u30CF\u9577\u8ABF (C)</option>
-              <option value="key_Db" title="\u60B2\u3057\u307F\u3001\u6182\u9B31\u306A\u3001\u7518\u7F8E\u306A\u611F\u50B7">\u5909\u30CB\u9577\u8ABF (D\u266D)</option>
-              <option value="key_D" title="\u610F\u6C17\u63DA\u3005\u3068\u3057\u305F\u3001\u52DD\u5229\u306E\u3001\u558A\u58F0">\u30CB\u9577\u8ABF (D)</option>
-              <option value="key_Eb" title="\u53B3\u3057\u3044\u3001\u304D\u3064\u3044\u3001\u305D\u308C\u3067\u3044\u3066\u611B\u306B\u6E80\u3061\u305F">\u5909\u30DB\u9577\u8ABF (E\u266D)</option>
-              <option value="key_E" title="\u3051\u3093\u304B\u3063\u65E9\u3044\u3001\u8352\u3005\u3057\u3044\u3001\u8F1D\u304B\u3057\u3044\u60C5\u71B1">\u30DB\u9577\u8ABF (E)</option>
-              <option value="key_F" title="\u6012\u308A\u72C2\u3063\u305F\u3001\u6C17\u6027\u306E\u8352\u3044\u3001\u4E00\u6642\u7684\u306A\u60B2\u5606">\u30D8\u9577\u8ABF (F)</option>
-              <option value="key_Gb" title="\u56F0\u96E3\u306E\u6253\u7834\u3001\u5B89\u5835\u306E\u305F\u3081\u606F\u3001\u51F1\u65CB">\u5909\u30C8\u9577\u8ABF (G\u266D)</option>
-              <option value="key_G" title="\u53B3\u7C9B\u306A\u3001\u5D07\u9AD8\u306A\u3001\u5E7B\u60F3\u3001\u8AA0\u5B9F">\u30C8\u9577\u8ABF (G)</option>
-              <option value="key_Ab" title="\u6B7B\u3001\u6C38\u9060\u3001\u88C1\u304D\u3001\u6DF1\u9060\u306A\u7791\u60F3">\u5909\u30A4\u9577\u8ABF (A\u266D)</option>
-              <option value="key_A" title="\u3046\u308C\u3057\u3044\u3001\u7267\u6B4C\u7684\u306A\u3001\u611B\u306E\u544A\u767D">\u30A4\u9577\u8ABF (A)</option>
-              <option value="key_Bb" title="\u559C\u3070\u3057\u3044\u3001\u98A8\u5909\u308F\u308A\u306A\u3001\u967D\u6C17\u306A\u3001\u8EFD\u5FEB">\u5909\u30ED\u9577\u8ABF (B\u266D)</option>
-              <option value="key_B" title="\u3069\u304E\u3064\u3044\u3001\u5F37\u70C8\u306A\u3001\u8352\u3063\u307D\u3044\u3001\u731B\u70C8">\u30ED\u9577\u8ABF (B)</option>
-            </optgroup>
-            <optgroup label="\u77ED\u8ABF\uFF08\u500B\u5225\u6307\u5B9A\uFF09">
-              <option value="key_Am" title="\u67D4\u3089\u304B\u306A\u3001\u7269\u60B2\u3057\u3044\u3001\u656C\u8654\u306A\u3001\u7D20\u6734\u306A\u54C0\u6101">\u30A4\u77ED\u8ABF (Am)</option>
-              <option value="key_Bbm" title="\u6050\u308D\u3057\u3044\u3001\u6697\u95C7\u3001\u5632\u308B\u3088\u3046\u306A\u3001\u4E0D\u6C17\u5473">\u5909\u30ED\u77ED\u8ABF (B\u266Dm)</option>
-              <option value="key_Bm" title="\u5B64\u72EC\u306A\u3001\u6182\u9B31\u306A\u3001\u5FCD\u8010\u3001\u9759\u304B\u306A\u8AE6\u5FF5">\u30ED\u77ED\u8ABF (Bm)</option>
-              <option value="key_Cm" title="\u7D14\u7C8B\u306B\u60B2\u3057\u3052\u306A\u3001\u604B\u308F\u305A\u3089\u3044\u306E\u3001\u60B2\u5287\u7684">\u30CF\u77ED\u8ABF (Cm)</option>
-              <option value="key_Csm" title="\u843D\u80C6\u3001\u6CE3\u304D\u53EB\u3093\u3060\u3001\u60B2\u6D99\u306E\u3001\u6DF1\u3044\u5606\u304D">\u5B30\u30CF\u77ED\u8ABF (C\u266Fm)</option>
-              <option value="key_Dm" title="\u53B3\u7C9B\u306A\u3001\u656C\u8654\u306A\u3001\u601D\u7D22\u7684\u306A\u3001\u91CD\u539A\u306A\u7948\u308A">\u30CB\u77ED\u8ABF (Dm)</option>
-              <option value="key_Ebm" title="\u6DF1\u3044\u82E6\u60A9\u3001\u5B9F\u5B58\u7684\u306A\u4E0D\u5B89\u3001\u6226\u6144">\u5909\u30DB\u77ED\u8ABF (E\u266Dm)</option>
-              <option value="key_Em" title="\u5F31\u3005\u3057\u3044\u3001\u306A\u307E\u3081\u304B\u3057\u3044\u3001\u843D\u3061\u7740\u304D\u306E\u306A\u3044">\u30DB\u77ED\u8ABF (Em)</option>
-              <option value="key_Fm" title="\u307C\u3093\u3084\u308A\u3057\u305F\u3001\u7269\u60B2\u3057\u3044\u3001\u3057\u3081\u3084\u304B\u306A\u3001\u846C\u9001">\u30D8\u77ED\u8ABF (Fm)</option>
-              <option value="key_Fsm" title="\u9670\u6C17\u306A\u3001\u6FC0\u3057\u3044\u61A4\u308A\u3001\u6697\u3044\u60C5\u5FF5">\u5B30\u30D8\u77ED\u8ABF (F\u266Fm)</option>
-              <option value="key_Gm" title="\u4E0D\u6E80\u3001\u4E0D\u5B89\u3001\u3084\u308B\u305B\u306A\u3055\u3001\u60B2\u75DB\u306A\u53EB\u3073">\u30C8\u77ED\u8ABF (Gm)</option>
-              <option value="key_Abm" title="\u4E0D\u670D\u306A\u3001\u5606\u304D\u306E\u3001\u6CE3\u304D\u53EB\u3093\u3060">\u5909\u30A4\u77ED\u8ABF (A\u266Dm)</option>
-            </optgroup>
-          </select>
-          <span class="dtm-grow"></span>
-          <span class="dtm-hint" data-dtm="compose-key-hint"></span>
-        </div>
-        <div class="dtm-row" data-dtm="compose-scale-row">
-          <span class="dtm-label">\u97F3\u968E</span>
-          <select class="dtm-select" data-dtm="compose-scale" title="\u65CB\u5F8B\u304C\u4F7F\u3046\u97F3\u968E\u3092\u9078\u3073\u307E\u3059\u3002\u30D9\u30FC\u30B9\u8ABF\uFF08\u4E3B\u97F3\u306E\u9AD8\u3055\uFF09\u3068\u306F\u72EC\u7ACB\u3057\u305F\u8A2D\u5B9A\u3067\u3059">
-            <option value="auto" title="\u30D9\u30FC\u30B9\u8ABF\u306E\u9577\u77ED\u306B\u5408\u308F\u305B\u3066\u3001\u967D\u97F3\u968E\uFF08\u9577\u8ABF\uFF09\u304B\u6C11\u8B21\u97F3\u968E\uFF08\u77ED\u8ABF\uFF09\u3092\u4F7F\u3044\u307E\u3059">\u304A\u307E\u304B\u305B\uFF08\u5F93\u6765\u3069\u304A\u308A\uFF09</option>
-            <option value="any" title="9\u3064\u306E\u97F3\u968E\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u62BD\u9078\u3057\u307E\u3059">\u5E0C\u671B\u306A\u3057\uFF08\u5168\u97F3\u968E\u304B\u3089\u62BD\u9078\uFF09</option>
-            <optgroup label="\u30DA\u30F3\u30BF\u30C8\u30CB\u30C3\u30AF\uFF085\u97F3\u97F3\u968E\uFF09">
-              <option value="yo" title="J-POP\u306E\u6A19\u6E96\u3002\u660E\u308B\u304F\u7D20\u76F4\u3067\u6B4C\u3044\u3084\u3059\u3044\u3002\u5F93\u6765\u306E\u9577\u8ABF\u3068\u540C\u3058">\u967D\u97F3\u968E\uFF08\u9577\u8ABF\u30DA\u30F3\u30BF\uFF09</option>
-              <option value="minyo" title="\u308F\u3089\u3079\u6B4C\u30FB\u6C11\u8B21\u306E\u97F3\u968E\u3002\u7FF3\u308A\u304C\u3042\u308B\u304C\u6697\u3059\u304E\u306A\u3044\u3002\u5F93\u6765\u306E\u77ED\u8ABF\u3068\u540C\u3058">\u6C11\u8B21\u97F3\u968E\uFF08\u77ED\u8ABF\u30DA\u30F3\u30BF\uFF09</option>
-              <option value="ryukyu" title="\u6C96\u7E04\u97F3\u968E\u3002\u30EC\u3068\u30E9\u3092\u629C\u304D\u3001\u30D5\u30A1\u3068\u30B7\u3092\u67F1\u306B\u3059\u308B\u3002\u660E\u308B\u304F\u8DF3\u306D\u308B">\u7409\u7403\u97F3\u968E\uFF08\u6C96\u7E04\uFF09</option>
-              <option value="miyakobushi" title="\u300E\u3055\u304F\u3089\u3055\u304F\u3089\u300F\u306E\u97F3\u968E\u3002\u4E3B\u97F3\u306E\u3059\u3050\u4E0A\u304C\u534A\u97F3\u3067\u3001\u7FF3\u308A\u304C\u6FC3\u3044">\u90FD\u7BC0\u97F3\u968E\uFF08\u9670\u97F3\u968E\uFF09</option>
-              <option value="ritsu" title="\u96C5\u697D\u30FB\u58F0\u660E\u306E\u97F3\u968E\u3002\u534A\u97F3\u3092\u542B\u307E\u305A\u3001\u5E73\u3089\u3067\u8358\u91CD\u306B\u6D41\u308C\u308B">\u5F8B\u97F3\u968E\uFF08\u96C5\u697D\uFF09</option>
-            </optgroup>
-            <optgroup label="\u30C1\u30E3\u30FC\u30C1\u30E2\u30FC\u30C9\uFF087\u97F3\u97F3\u968E\uFF09">
-              <option value="dorian" title="\u77ED\u8ABF\u3060\u304C6\u5EA6\u304C\u660E\u308B\u3044\u3002\u30B1\u30EB\u30C8\u30FB\u30ED\u30C3\u30AF\u30FB\u30B7\u30C6\u30A3\u30DD\u30C3\u30D7">\u30C9\u30EA\u30A2\u30F3</option>
-              <option value="phrygian" title="\u4E3B\u97F3\u306E\u4E0A\u304C\u534A\u97F3\u3002\u30B9\u30D1\u30CB\u30C3\u30B7\u30E5\uFF0F\u30E1\u30BF\u30EB\u306E\u7DCA\u8FEB\u3057\u305F\u97FF\u304D">\u30D5\u30EA\u30B8\u30A2\u30F3</option>
-              <option value="lydian" title="4\u5EA6\u304C\u9AD8\u304F\u3001\u6D6E\u904A\u3057\u3066\u5E83\u304C\u308B\u3002\u6620\u753B\u97F3\u697D\u30FB\u30B2\u30FC\u30E0\u306E\u7A7A\u306E\u8272">\u30EA\u30C7\u30A3\u30A2\u30F3</option>
-              <option value="mixolydian" title="\u9577\u8ABF\u3060\u304C7\u5EA6\u304C\u4F4E\u3044\u3002\u30D6\u30EB\u30FC\u30B9\u30ED\u30C3\u30AF\u30FB\u6C11\u65CF\u97F3\u697D\u306E\u571F\u304F\u3055\u3055">\u30DF\u30AF\u30BD\u30EA\u30C7\u30A3\u30A2\u30F3</option>
-            </optgroup>
-            <optgroup label="\u7279\u6B8A\u97F3\u968E\uFF08\u97F3\u7A0B\u96C6\u5408\u3054\u3068\u5165\u308C\u66FF\u308F\u308B\uFF09">
-              <option value="harmonic_minor" title="\u5C0E\u97F3\u30BD\u266F\u3092\u6301\u3064\u77ED\u8ABF\u3002\u58972\u5EA6\u304C\u6CE3\u304D\u3092\u4F5C\u308B\u3002\u30AF\u30E9\u30B7\u30C3\u30AF\u30FBV\u7CFB\u30FB\u5287\u4F34">\u548C\u58F0\u7684\u77ED\u97F3\u968E</option>
-              <option value="hijaz" title="\u4E3B\u97F3\u306E\u4E0A\u304C\u534A\u97F3\u3001\u4E3B\u548C\u97F3\u306F\u9577\u4E09\u548C\u97F3\u3002\u4E2D\u6771\u30FB\u30B9\u30D1\u30CB\u30C3\u30B7\u30E5\u30FB\u30E1\u30BF\u30EB">\u30D2\u30B8\u30E3\u30FC\u30BA\uFF08\u30D5\u30EA\u30B8\u30A2\u30F3\u30FB\u30C9\u30DF\u30CA\u30F3\u30C8\uFF09</option>
-              <option value="hungarian" title="\u58972\u5EA6\u304C2\u304B\u6240\u3002\u97F3\u968E\u306E\u4E2D\u3067\u3044\u3061\u3070\u3093\u8DF3\u306D\u305F\u3001\u7570\u56FD\u3081\u3044\u305F\u97FF\u304D">\u30CF\u30F3\u30AC\u30EA\u30A2\u30F3\u30FB\u30DE\u30A4\u30CA\u30FC\uFF08\u30B8\u30D7\u30B7\u30FC\uFF09</option>
-              <option value="blues" title="\u30D6\u30EB\u30FC\u30CE\u30FC\u30C8\u5165\u308A\u306E6\u97F3\u97F3\u968E\u3002\u77ED3\u5EA6\u3067\u6B4C\u3044\u3001\u4F34\u594F\u306F\u95773\u5EA6\u3067\u9CF4\u308B">\u30D6\u30EB\u30FC\u30B9\u97F3\u968E</option>
-            </optgroup>
-          </select>
-          <span class="dtm-grow"></span>
-          <span class="dtm-hint" data-dtm="compose-scale-hint"></span>
+      <div class="dtm-row" data-dtm="compose-row">
+        <button class="dtm-btn dtm-btn--success" data-dtm="macro-compose" title="\u30B3\u30FC\u30C9\u9032\u884C\u30FB\u30E1\u30ED\u30C7\u30A3\u30FB\u30B5\u30D6\u30E1\u30ED\u30FB\u30D9\u30FC\u30B9\u30FB\u4F34\u594F\u30FB\u30C9\u30E9\u30E0\u3092\u81EA\u52D5\u3067\u4F5C\u308A\u307E\u3059">\u4F5C\u66F2</button>
+        <button class="dtm-btn dtm-btn--success" data-dtm="macro-compose-vocal" title="\u4F5C\u66F2\u3057\u305F\u3046\u3048\u3067\u3001\u30E1\u30ED\u30C7\u30A3\u306B\u6B4C\u8A5E\u3092\u4ED8\u3051\u3066\u6B4C\u308F\u305B\u307E\u3059">\u6B4C\u5165\u308A\u4F5C\u66F2</button>
+        <button class="dtm-infobtn" data-dtm="macro-compose-info" title="\u4F5C\u66F2\u306E\u89E3\u8AAC">${icon("info", 12)}</button>
+        <!--
+          **\u30AD\u30FC\u30D7\u67A0\u306F1\u3064\u3060\u3051\u3002** \u81EA\u52D5\u4F5C\u66F2\u306F\u6C17\u306B\u5165\u308B\u307E\u3067\u5F15\u304D\u76F4\u3059\u4F7F\u3044\u65B9\u306B\u306A\u308B\u304C\u3001
+          \u300C\u5F15\u304D\u76F4\u3059\u3068\u4ECA\u306E\u304C\u6D88\u3048\u308B\u300D\u3068\u601D\u3046\u3068\u5F15\u304D\u76F4\u305B\u306A\u304F\u306A\u308B\u3002\u53D6\u3063\u3066\u304A\u3051\u308B\u5834\u6240\u304C
+          1\u3064\u3042\u308C\u3070\u30012\u3064\u3092\u6BD4\u3079\u3066\u9078\u3076\u3053\u3068\u306F\u6210\u7ACB\u3059\u308B\u3002\u5019\u88DC\u3092\u4E26\u3079\u308BUI\u306F\u30B9\u30DE\u30DB\u3067\u306F
+          \u6210\u7ACB\u3057\u306A\u3044\uFF08\u8A66\u8074\u6642\u9593\u30FB\u753B\u9762\u30FB\u751F\u6210\u30B3\u30B9\u30C8\u306E\u3069\u308C\u3082\u8DB3\u308A\u306A\u3044\uFF09\u3002
+          \u300C\u5165\u308C\u66FF\u3048\u300D\u306F\u4ECA\u306E\u66F2\u3068\u30AD\u30FC\u30D7\u3092\u4EA4\u63DB\u3059\u308B\u3002\u547C\u3073\u51FA\u3059\u3060\u3051\u3060\u3068\u4ECA\u306E\u66F2\u304C\u6D88\u3048\u3066
+          2\u66F2\u3092\u884C\u304D\u6765\u3067\u304D\u306A\u3044\u305F\u3081\u3002\u67A0\u306F\u30EA\u30ED\u30FC\u30C9\u3092\u307E\u305F\u3044\u3067\u6B8B\u308B\uFF08localStorage\uFF09\u3002
+        -->
+        <button class="dtm-btn" data-dtm="compose-keep" title="\u4ECA\u306E\u66F2\u30921\u3064\u3060\u3051\u53D6\u3063\u3066\u304A\u304D\u307E\u3059\u3002\u4F5C\u66F2\u3092\u62BC\u3057\u76F4\u3057\u3066\u3082\u3001\u30DA\u30FC\u30B8\u3092\u958B\u304D\u76F4\u3057\u3066\u3082\u6D88\u3048\u307E\u305B\u3093">\u30AD\u30FC\u30D7</button>
+        <button class="dtm-btn" data-dtm="compose-recall" title="\u30AD\u30FC\u30D7\u3057\u305F\u66F2\u3068\u4ECA\u306E\u66F2\u3092\u5165\u308C\u66FF\u3048\u3066\u3001\u30AD\u30FC\u30D7\u3057\u3066\u3044\u305F\u66F2\u3092\u9CF4\u3089\u3057\u307E\u3059\u3002\u3082\u3046\u4E00\u5EA6\u62BC\u3059\u3068\u623B\u308A\u307E\u3059" disabled>\u5165\u308C\u66FF\u3048</button>
+        <span class="dtm-grow"></span>
+      </div>
+      <div class="dtm-row" data-dtm="compose-template-row">
+        <span class="dtm-label">\u69CB\u6210</span>
+        <select class="dtm-select" data-dtm="compose-template" title="J-POP\u738B\u9053\u306A\u3069\u306E\u30D7\u30EA\u30BB\u30C3\u30C8\u69CB\u6210\u3092\u9078\u3073\u307E\u3059">
+          <option value="custom">\u81EA\u7531\u9078\u629E\uFF08\u4E0B\u8A18\u30C1\u30A7\u30C3\u30AF\uFF09</option>
+          <option value="1chorus">1\u30B3\u30FC\u30E9\u30B9\uFF08\u77ED\u3081\u30FB\u521D\u5FC3\u8005\u5411\u3051\uFF09</option>
+          <option value="jpop_standard">JPOP\u738B\u9053\uFF08\u30DE\u30EA\u30FC\u30B4\u30FC\u30EB\u30C9\u578B 2\u756A/C\u30E1\u30ED/\u30E9\u30B9\u30B5\u30D3\uFF09</option>
+          <option value="jpop_drop">\u843D\u3061\u30B5\u30D3\u5165\u308A\uFF08JPOP\u738B\u9053 + \u30E9\u30B9\u30B5\u30D3\u524D\u843D\u3061\u30B5\u30D3\uFF09</option>
+          <option value="vocaloid">\u30DC\u30AB\u30ED\u738B\u9053\uFF08\u75BE\u8D70\u30FB2\u756A/C\u30E1\u30ED/\u30E9\u30B9\u30B5\u30D3\uFF09</option>
+          <option value="verse_chorus">Verse-Chorus\uFF08B\u30E1\u30ED\u306A\u3057\u30FB\u6D0B\u697D\u98A8\uFF09</option>
+        </select>
+      </div>
+      <div class="dtm-row" data-dtm="compose-sections-row">
+        <span class="dtm-label">\u4F5C\u308B\u90E8\u5206</span>
+        <div class="dtm-checks" data-dtm="compose-sections">
+          <label class="dtm-check"><input type="checkbox" value="intro" checked>\u30A4\u30F3\u30C8\u30ED</label>
+          <label class="dtm-check"><input type="checkbox" value="verse" checked>A\u30E1\u30ED</label>
+          <label class="dtm-check"><input type="checkbox" value="prechorus" checked>B\u30E1\u30ED</label>
+          <label class="dtm-check"><input type="checkbox" value="chorus" checked>\u30B5\u30D3</label>
+          <label class="dtm-check"><input type="checkbox" value="bridge">C\u30E1\u30ED</label>
+          <label class="dtm-check"><input type="checkbox" value="drop_chorus">\u843D\u3061\u30B5\u30D3</label>
+          <label class="dtm-check"><input type="checkbox" value="interlude">\u9593\u594F</label>
+          <label class="dtm-check"><input type="checkbox" value="outro">\u30A2\u30A6\u30C8\u30ED</label>
         </div>
+        <span class="dtm-grow"></span>
+        <span class="dtm-hint" data-dtm="compose-sections-len"></span>
+      </div>
+      <div class="dtm-row" data-dtm="compose-key-row">
+        <span class="dtm-label">\u30D9\u30FC\u30B9\u8ABF</span>
+        <select class="dtm-select" data-dtm="compose-key" title="\u81EA\u52D5\u4F5C\u66F2\u306E\u30D9\u30FC\u30B9\u3068\u306A\u308B\u8ABF\u3084\u96F0\u56F2\u6C17\u3092\u9078\u3073\u307E\u3059">
+          <option value="any" title="\u516824\u8ABF\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u6C7A\u5B9A\u3057\u307E\u3059">\u5E0C\u671B\u306A\u3057</option>
+          <optgroup label="\u57FA\u672C">
+            <option value="major" title="12\u306E\u9577\u8ABF\u306E\u4E2D\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u62BD\u9078\u3057\u307E\u3059">\u9577\u8ABF</option>
+            <option value="minor" title="12\u306E\u77ED\u8ABF\u306E\u4E2D\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u62BD\u9078\u3057\u307E\u3059">\u77ED\u8ABF</option>
+          </optgroup>
+          <optgroup label="\u96F0\u56F2\u6C17\u304B\u3089\u9078\u3076\uFF08\u62BD\u9078\uFF09">
+            <option value="mood_happy" title="\u30CF\u9577\u8ABF\u30FB\u30A4\u9577\u8ABF\u30FB\u5909\u30ED\u9577\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u7121\u57A2\u306B\u559C\u3070\u3057\u3044\u3001\u7267\u6B4C\u7684\u3001\u967D\u6C17\uFF09">\u559C\u3070\u3057\u3044\u30FB\u967D\u6C17\u306A\u66F2</option>
+            <option value="mood_triumphant" title="\u30CB\u9577\u8ABF\u30FB\u5909\u30C8\u9577\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u610F\u6C17\u63DA\u3005\u3001\u52DD\u5229\u306E\u558A\u58F0\u3001\u56F0\u96E3\u6253\u7834\u3001\u5B89\u5835\uFF09">\u52DD\u5229\u30FB\u529B\u5F37\u3044\u66F2</option>
+            <option value="mood_fierce" title="\u30DB\u9577\u8ABF\u30FB\u30D8\u9577\u8ABF\u30FB\u30ED\u9577\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u3051\u3093\u304B\u3063\u65E9\u3044\u3001\u6012\u308A\u72C2\u3063\u305F\u8352\u3005\u3057\u3055\u3001\u3069\u304E\u3064\u304F\u731B\u70C8\uFF09">\u6FC0\u3057\u3044\u30FB\u8352\u3005\u3057\u3044\u66F2</option>
+            <option value="mood_solemn" title="\u30C8\u9577\u8ABF\u30FB\u30CB\u77ED\u8ABF\u30FB\u30A4\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u53B3\u7C9B\u3001\u5D07\u9AD8\u3001\u5E7B\u60F3\u3001\u656C\u8654\u3001\u601D\u7D22\u7684\uFF09">\u53B3\u7C9B\u30FB\u5E7B\u60F3\u7684\u306A\u66F2</option>
+            <option value="mood_plaintive" title="\u30CF\u77ED\u8ABF\u30FB\u30DB\u77ED\u8ABF\u30FB\u30D8\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u7D14\u7C8B\u306B\u60B2\u3057\u3052\u3001\u604B\u308F\u305A\u3089\u3044\u3001\u843D\u3061\u7740\u304D\u306E\u306A\u3044\u3001\u7269\u60B2\u3057\u3044\u54C0\u6101\uFF09">\u7269\u60B2\u3057\u3044\u30FB\u54C0\u6101\u306E\u66F2</option>
+            <option value="mood_melancholy" title="\u5909\u30CB\u9577\u8ABF\u30FB\u30ED\u77ED\u8ABF\u30FB\u5B30\u30CF\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u60B2\u3057\u307F\u3001\u6182\u9B31\u3001\u5B64\u72EC\u3001\u5FCD\u8010\u3001\u843D\u80C6\u3001\u60B2\u6D99\uFF09">\u6182\u9B31\u30FB\u5B64\u72EC\u306A\u66F2</option>
+            <option value="mood_anxious" title="\u30C8\u77ED\u8ABF\u30FB\u5909\u30DB\u77ED\u8ABF\u30FB\u5B30\u30D8\u77ED\u8ABF\u30FB\u5909\u30A4\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u4E0D\u6E80\u3001\u4E0D\u5B89\u3001\u6DF1\u3044\u82E6\u60A9\u3001\u9670\u6C17\u306A\u61A4\u308A\uFF09">\u4E0D\u5B89\u30FB\u82E6\u60A9\u306A\u66F2</option>
+            <option value="mood_dark" title="\u5909\u30DB\u9577\u8ABF\u30FB\u5909\u30A4\u9577\u8ABF\u30FB\u5909\u30ED\u77ED\u8ABF\u304B\u3089\u62BD\u9078\uFF08\u53B3\u3057\u3044\u611B\u3001\u6B7B\u3001\u6C38\u9060\u3001\u88C1\u304D\u3001\u6697\u95C7\u3001\u6050\u308D\u3057\u3044\u5632\u308A\uFF09">\u6697\u95C7\u30FB\u91CD\u539A\u306A\u66F2</option>
+          </optgroup>
+          <optgroup label="\u9577\u8ABF\uFF08\u500B\u5225\u6307\u5B9A\uFF09">
+            <option value="key_C" title="\u7121\u57A2\u306B\u559C\u3070\u3057\u3044\u3001\u7D14\u7C8B\u3001\u7D20\u6734\u3001\u51FA\u767A">\u30CF\u9577\u8ABF (C)</option>
+            <option value="key_Db" title="\u60B2\u3057\u307F\u3001\u6182\u9B31\u306A\u3001\u7518\u7F8E\u306A\u611F\u50B7">\u5909\u30CB\u9577\u8ABF (D\u266D)</option>
+            <option value="key_D" title="\u610F\u6C17\u63DA\u3005\u3068\u3057\u305F\u3001\u52DD\u5229\u306E\u3001\u558A\u58F0">\u30CB\u9577\u8ABF (D)</option>
+            <option value="key_Eb" title="\u53B3\u3057\u3044\u3001\u304D\u3064\u3044\u3001\u305D\u308C\u3067\u3044\u3066\u611B\u306B\u6E80\u3061\u305F">\u5909\u30DB\u9577\u8ABF (E\u266D)</option>
+            <option value="key_E" title="\u3051\u3093\u304B\u3063\u65E9\u3044\u3001\u8352\u3005\u3057\u3044\u3001\u8F1D\u304B\u3057\u3044\u60C5\u71B1">\u30DB\u9577\u8ABF (E)</option>
+            <option value="key_F" title="\u6012\u308A\u72C2\u3063\u305F\u3001\u6C17\u6027\u306E\u8352\u3044\u3001\u4E00\u6642\u7684\u306A\u60B2\u5606">\u30D8\u9577\u8ABF (F)</option>
+            <option value="key_Gb" title="\u56F0\u96E3\u306E\u6253\u7834\u3001\u5B89\u5835\u306E\u305F\u3081\u606F\u3001\u51F1\u65CB">\u5909\u30C8\u9577\u8ABF (G\u266D)</option>
+            <option value="key_G" title="\u53B3\u7C9B\u306A\u3001\u5D07\u9AD8\u306A\u3001\u5E7B\u60F3\u3001\u8AA0\u5B9F">\u30C8\u9577\u8ABF (G)</option>
+            <option value="key_Ab" title="\u6B7B\u3001\u6C38\u9060\u3001\u88C1\u304D\u3001\u6DF1\u9060\u306A\u7791\u60F3">\u5909\u30A4\u9577\u8ABF (A\u266D)</option>
+            <option value="key_A" title="\u3046\u308C\u3057\u3044\u3001\u7267\u6B4C\u7684\u306A\u3001\u611B\u306E\u544A\u767D">\u30A4\u9577\u8ABF (A)</option>
+            <option value="key_Bb" title="\u559C\u3070\u3057\u3044\u3001\u98A8\u5909\u308F\u308A\u306A\u3001\u967D\u6C17\u306A\u3001\u8EFD\u5FEB">\u5909\u30ED\u9577\u8ABF (B\u266D)</option>
+            <option value="key_B" title="\u3069\u304E\u3064\u3044\u3001\u5F37\u70C8\u306A\u3001\u8352\u3063\u307D\u3044\u3001\u731B\u70C8">\u30ED\u9577\u8ABF (B)</option>
+          </optgroup>
+          <optgroup label="\u77ED\u8ABF\uFF08\u500B\u5225\u6307\u5B9A\uFF09">
+            <option value="key_Am" title="\u67D4\u3089\u304B\u306A\u3001\u7269\u60B2\u3057\u3044\u3001\u656C\u8654\u306A\u3001\u7D20\u6734\u306A\u54C0\u6101">\u30A4\u77ED\u8ABF (Am)</option>
+            <option value="key_Bbm" title="\u6050\u308D\u3057\u3044\u3001\u6697\u95C7\u3001\u5632\u308B\u3088\u3046\u306A\u3001\u4E0D\u6C17\u5473">\u5909\u30ED\u77ED\u8ABF (B\u266Dm)</option>
+            <option value="key_Bm" title="\u5B64\u72EC\u306A\u3001\u6182\u9B31\u306A\u3001\u5FCD\u8010\u3001\u9759\u304B\u306A\u8AE6\u5FF5">\u30ED\u77ED\u8ABF (Bm)</option>
+            <option value="key_Cm" title="\u7D14\u7C8B\u306B\u60B2\u3057\u3052\u306A\u3001\u604B\u308F\u305A\u3089\u3044\u306E\u3001\u60B2\u5287\u7684">\u30CF\u77ED\u8ABF (Cm)</option>
+            <option value="key_Csm" title="\u843D\u80C6\u3001\u6CE3\u304D\u53EB\u3093\u3060\u3001\u60B2\u6D99\u306E\u3001\u6DF1\u3044\u5606\u304D">\u5B30\u30CF\u77ED\u8ABF (C\u266Fm)</option>
+            <option value="key_Dm" title="\u53B3\u7C9B\u306A\u3001\u656C\u8654\u306A\u3001\u601D\u7D22\u7684\u306A\u3001\u91CD\u539A\u306A\u7948\u308A">\u30CB\u77ED\u8ABF (Dm)</option>
+            <option value="key_Ebm" title="\u6DF1\u3044\u82E6\u60A9\u3001\u5B9F\u5B58\u7684\u306A\u4E0D\u5B89\u3001\u6226\u6144">\u5909\u30DB\u77ED\u8ABF (E\u266Dm)</option>
+            <option value="key_Em" title="\u5F31\u3005\u3057\u3044\u3001\u306A\u307E\u3081\u304B\u3057\u3044\u3001\u843D\u3061\u7740\u304D\u306E\u306A\u3044">\u30DB\u77ED\u8ABF (Em)</option>
+            <option value="key_Fm" title="\u307C\u3093\u3084\u308A\u3057\u305F\u3001\u7269\u60B2\u3057\u3044\u3001\u3057\u3081\u3084\u304B\u306A\u3001\u846C\u9001">\u30D8\u77ED\u8ABF (Fm)</option>
+            <option value="key_Fsm" title="\u9670\u6C17\u306A\u3001\u6FC0\u3057\u3044\u61A4\u308A\u3001\u6697\u3044\u60C5\u5FF5">\u5B30\u30D8\u77ED\u8ABF (F\u266Fm)</option>
+            <option value="key_Gm" title="\u4E0D\u6E80\u3001\u4E0D\u5B89\u3001\u3084\u308B\u305B\u306A\u3055\u3001\u60B2\u75DB\u306A\u53EB\u3073">\u30C8\u77ED\u8ABF (Gm)</option>
+            <option value="key_Abm" title="\u4E0D\u670D\u306A\u3001\u5606\u304D\u306E\u3001\u6CE3\u304D\u53EB\u3093\u3060">\u5909\u30A4\u77ED\u8ABF (A\u266Dm)</option>
+          </optgroup>
+        </select>
+        <span class="dtm-grow"></span>
+        <span class="dtm-hint" data-dtm="compose-key-hint"></span>
+      </div>
+      <div class="dtm-row" data-dtm="compose-scale-row">
+        <span class="dtm-label">\u97F3\u968E</span>
+        <select class="dtm-select" data-dtm="compose-scale" title="\u65CB\u5F8B\u304C\u4F7F\u3046\u97F3\u968E\u3092\u9078\u3073\u307E\u3059\u3002\u30D9\u30FC\u30B9\u8ABF\uFF08\u4E3B\u97F3\u306E\u9AD8\u3055\uFF09\u3068\u306F\u72EC\u7ACB\u3057\u305F\u8A2D\u5B9A\u3067\u3059">
+          <option value="auto" title="\u30D9\u30FC\u30B9\u8ABF\u306E\u9577\u77ED\u306B\u5408\u308F\u305B\u3066\u3001\u967D\u97F3\u968E\uFF08\u9577\u8ABF\uFF09\u304B\u6C11\u8B21\u97F3\u968E\uFF08\u77ED\u8ABF\uFF09\u3092\u4F7F\u3044\u307E\u3059">\u304A\u307E\u304B\u305B\uFF08\u5F93\u6765\u3069\u304A\u308A\uFF09</option>
+          <option value="any" title="9\u3064\u306E\u97F3\u968E\u304B\u3089\u30E9\u30F3\u30C0\u30E0\u306B\u62BD\u9078\u3057\u307E\u3059">\u5E0C\u671B\u306A\u3057\uFF08\u5168\u97F3\u968E\u304B\u3089\u62BD\u9078\uFF09</option>
+          <optgroup label="\u30DA\u30F3\u30BF\u30C8\u30CB\u30C3\u30AF\uFF085\u97F3\u97F3\u968E\uFF09">
+            <option value="yo" title="J-POP\u306E\u6A19\u6E96\u3002\u660E\u308B\u304F\u7D20\u76F4\u3067\u6B4C\u3044\u3084\u3059\u3044\u3002\u5F93\u6765\u306E\u9577\u8ABF\u3068\u540C\u3058">\u967D\u97F3\u968E\uFF08\u9577\u8ABF\u30DA\u30F3\u30BF\uFF09</option>
+            <option value="minyo" title="\u308F\u3089\u3079\u6B4C\u30FB\u6C11\u8B21\u306E\u97F3\u968E\u3002\u7FF3\u308A\u304C\u3042\u308B\u304C\u6697\u3059\u304E\u306A\u3044\u3002\u5F93\u6765\u306E\u77ED\u8ABF\u3068\u540C\u3058">\u6C11\u8B21\u97F3\u968E\uFF08\u77ED\u8ABF\u30DA\u30F3\u30BF\uFF09</option>
+            <option value="ryukyu" title="\u6C96\u7E04\u97F3\u968E\u3002\u30EC\u3068\u30E9\u3092\u629C\u304D\u3001\u30D5\u30A1\u3068\u30B7\u3092\u67F1\u306B\u3059\u308B\u3002\u660E\u308B\u304F\u8DF3\u306D\u308B">\u7409\u7403\u97F3\u968E\uFF08\u6C96\u7E04\uFF09</option>
+            <option value="miyakobushi" title="\u300E\u3055\u304F\u3089\u3055\u304F\u3089\u300F\u306E\u97F3\u968E\u3002\u4E3B\u97F3\u306E\u3059\u3050\u4E0A\u304C\u534A\u97F3\u3067\u3001\u7FF3\u308A\u304C\u6FC3\u3044">\u90FD\u7BC0\u97F3\u968E\uFF08\u9670\u97F3\u968E\uFF09</option>
+            <option value="ritsu" title="\u96C5\u697D\u30FB\u58F0\u660E\u306E\u97F3\u968E\u3002\u534A\u97F3\u3092\u542B\u307E\u305A\u3001\u5E73\u3089\u3067\u8358\u91CD\u306B\u6D41\u308C\u308B">\u5F8B\u97F3\u968E\uFF08\u96C5\u697D\uFF09</option>
+          </optgroup>
+          <optgroup label="\u30C1\u30E3\u30FC\u30C1\u30E2\u30FC\u30C9\uFF087\u97F3\u97F3\u968E\uFF09">
+            <option value="dorian" title="\u77ED\u8ABF\u3060\u304C6\u5EA6\u304C\u660E\u308B\u3044\u3002\u30B1\u30EB\u30C8\u30FB\u30ED\u30C3\u30AF\u30FB\u30B7\u30C6\u30A3\u30DD\u30C3\u30D7">\u30C9\u30EA\u30A2\u30F3</option>
+            <option value="phrygian" title="\u4E3B\u97F3\u306E\u4E0A\u304C\u534A\u97F3\u3002\u30B9\u30D1\u30CB\u30C3\u30B7\u30E5\uFF0F\u30E1\u30BF\u30EB\u306E\u7DCA\u8FEB\u3057\u305F\u97FF\u304D">\u30D5\u30EA\u30B8\u30A2\u30F3</option>
+            <option value="lydian" title="4\u5EA6\u304C\u9AD8\u304F\u3001\u6D6E\u904A\u3057\u3066\u5E83\u304C\u308B\u3002\u6620\u753B\u97F3\u697D\u30FB\u30B2\u30FC\u30E0\u306E\u7A7A\u306E\u8272">\u30EA\u30C7\u30A3\u30A2\u30F3</option>
+            <option value="mixolydian" title="\u9577\u8ABF\u3060\u304C7\u5EA6\u304C\u4F4E\u3044\u3002\u30D6\u30EB\u30FC\u30B9\u30ED\u30C3\u30AF\u30FB\u6C11\u65CF\u97F3\u697D\u306E\u571F\u304F\u3055\u3055">\u30DF\u30AF\u30BD\u30EA\u30C7\u30A3\u30A2\u30F3</option>
+          </optgroup>
+          <optgroup label="\u7279\u6B8A\u97F3\u968E\uFF08\u97F3\u7A0B\u96C6\u5408\u3054\u3068\u5165\u308C\u66FF\u308F\u308B\uFF09">
+            <option value="harmonic_minor" title="\u5C0E\u97F3\u30BD\u266F\u3092\u6301\u3064\u77ED\u8ABF\u3002\u58972\u5EA6\u304C\u6CE3\u304D\u3092\u4F5C\u308B\u3002\u30AF\u30E9\u30B7\u30C3\u30AF\u30FBV\u7CFB\u30FB\u5287\u4F34">\u548C\u58F0\u7684\u77ED\u97F3\u968E</option>
+            <option value="hijaz" title="\u4E3B\u97F3\u306E\u4E0A\u304C\u534A\u97F3\u3001\u4E3B\u548C\u97F3\u306F\u9577\u4E09\u548C\u97F3\u3002\u4E2D\u6771\u30FB\u30B9\u30D1\u30CB\u30C3\u30B7\u30E5\u30FB\u30E1\u30BF\u30EB">\u30D2\u30B8\u30E3\u30FC\u30BA\uFF08\u30D5\u30EA\u30B8\u30A2\u30F3\u30FB\u30C9\u30DF\u30CA\u30F3\u30C8\uFF09</option>
+            <option value="hungarian" title="\u58972\u5EA6\u304C2\u304B\u6240\u3002\u97F3\u968E\u306E\u4E2D\u3067\u3044\u3061\u3070\u3093\u8DF3\u306D\u305F\u3001\u7570\u56FD\u3081\u3044\u305F\u97FF\u304D">\u30CF\u30F3\u30AC\u30EA\u30A2\u30F3\u30FB\u30DE\u30A4\u30CA\u30FC\uFF08\u30B8\u30D7\u30B7\u30FC\uFF09</option>
+            <option value="blues" title="\u30D6\u30EB\u30FC\u30CE\u30FC\u30C8\u5165\u308A\u306E6\u97F3\u97F3\u968E\u3002\u77ED3\u5EA6\u3067\u6B4C\u3044\u3001\u4F34\u594F\u306F\u95773\u5EA6\u3067\u9CF4\u308B">\u30D6\u30EB\u30FC\u30B9\u97F3\u968E</option>
+          </optgroup>
+        </select>
+        <span class="dtm-grow"></span>
+        <span class="dtm-hint" data-dtm="compose-scale-hint"></span>
       </div>
+    </div>
+  </details>
+
+  <details class="dtm-panel" data-dtm-acc="macro">
+    <summary>\u4E00\u62EC\u7DE8\u96C6</summary>
+    <div class="dtm-panel-body">
       <div class="dtm-row">
         <span class="dtm-label">\u5168\u4F53\u30B7\u30D5\u30C8</span>
         <select class="dtm-select" data-dtm="shift-select">
@@ -25163,10 +26809,11 @@ var buildUI = (target, options) => {
   </details>
 
   <details class="dtm-panel" data-dtm-acc="io-out">
-    <summary>MIDI / UST / MML \u51FA\u529B</summary>
+    <summary>MIDI / MusicXML / UST / MML \u51FA\u529B</summary>
     <div class="dtm-panel-body">
       <div class="dtm-row">
         <button class="dtm-btn dtm-btn--accent" data-dtm="export-midi">MIDI\u51FA\u529B</button>
+        <button class="dtm-btn dtm-btn--accent" data-dtm="export-musicxml" title="\u5168\u30C8\u30E9\u30C3\u30AF\u3092MusicXML\uFF08\u697D\u8B5C\uFF09\u5F62\u5F0F\u3067\u66F8\u304D\u51FA\u3057\u307E\u3059">MusicXML\u51FA\u529B</button>
         <button class="dtm-btn dtm-btn--accent" data-dtm="export-ust" title="\u73FE\u5728\u9078\u629E\u4E2D\u306E\u30C8\u30E9\u30C3\u30AF\u3060\u3051\u3092UST\u3067\u66F8\u304D\u51FA\u3057\u307E\u3059">UST\u51FA\u529B</button>
         <button class="dtm-btn dtm-btn--success" data-dtm="generate-mml">MML\u751F\u6210</button>
         <button class="dtm-btn dtm-btn--primary dtm-hidden" data-dtm="export-wav">WAV\u66F8\u304D\u51FA\u3057</button>
@@ -25216,6 +26863,7 @@ var buildUI = (target, options) => {
       </div>
     </div>
   </details>
+  </div>
 
   <!-- \u2550\u2550\u2550\u2550 \u89E3\u8AAC\u30E2\u30FC\u30C0\u30EB \u2550\u2550\u2550\u2550 -->
   <div class="dtm-modal-overlay" data-dtm="modal-overlay" hidden>
@@ -25322,6 +26970,11 @@ var buildUI = (target, options) => {
     midiTrackSelection: sel("midi-track-selection"),
     midiPanel: sel("midi-panel"),
     midiSearchOpenBtn: sel("midi-search-open"),
+    musicXmlInput: sel("musicxml-input"),
+    musicXmlLoadBtn: sel("musicxml-load"),
+    musicXmlInfoBtn: sel("musicxml-info"),
+    musicXmlPartSelection: sel("musicxml-part-selection"),
+    musicXmlLoadNote: sel("musicxml-load-note"),
     ustInput: sel("ust-input"),
     ustLoadBtn: sel("ust-load"),
     ustInfoBtn: sel("ust-info"),
@@ -25353,6 +27006,7 @@ var buildUI = (target, options) => {
     macroHarmonic: sel("macro-harmonic"),
     macroMono: sel("macro-mono"),
     exportMidiBtn: sel("export-midi"),
+    exportMusicXmlBtn: sel("export-musicxml"),
     exportUstBtn: sel("export-ust"),
     exportWavBtn: sel("export-wav"),
     drumJsonExportBtn: sel("drum-json-export"),
@@ -25421,6 +27075,32 @@ var readMacroSections = () => {
 var writeMacroSections = (sections) => {
   writeMacroSetting("sections", JSON.stringify(sections));
 };
+var KEPT_STORAGE_KEY = "dtm-macro:kept";
+var readKeptSong = () => {
+  try {
+    if (typeof localStorage === "undefined" || !localStorage) return null;
+    const raw = localStorage.getItem(KEPT_STORAGE_KEY);
+    if (!raw) return null;
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === "object" && typeof parsed.mml === "string" && parsed.mml.length > 0) {
+      const startStep = typeof parsed.startStep === "number" && Number.isFinite(parsed.startStep) && parsed.startStep >= 0 ? Math.floor(parsed.startStep) : 0;
+      return { mml: parsed.mml, startStep };
+    }
+  } catch (_) {
+  }
+  return null;
+};
+var writeKeptSong = (kept) => {
+  try {
+    if (typeof localStorage === "undefined" || !localStorage) return;
+    if (kept === null) {
+      localStorage.removeItem(KEPT_STORAGE_KEY);
+      return;
+    }
+    localStorage.setItem(KEPT_STORAGE_KEY, JSON.stringify(kept));
+  } catch (_) {
+  }
+};
 
 // src/macros.ts
 var SCALES = [
@@ -25567,7 +27247,7 @@ var transposeNotes = (cores, steps) => {
 };
 
 // src/version.ts
-var DTM_VERSION = "2.1.12";
+var DTM_VERSION = "2.1.14";
 
 // src/midi-io.ts
 var STEPS_PER_BEAT3 = 48;
@@ -26734,6 +28414,275 @@ var isChordHeavyTrack = (notes, threshold = 0.6) => {
   return chordNotes / notes.length >= threshold;
 };
 
+// src/musicxml-io.ts
+var STEPS_PER_BEAT4 = 48;
+var PITCH_CLASS = {
+  C: 0,
+  D: 2,
+  E: 4,
+  F: 5,
+  G: 7,
+  A: 9,
+  B: 11
+};
+var textOf = (el, tag) => el?.getElementsByTagName(tag)[0]?.textContent?.trim() ?? "";
+var numOf = (el, tag, fallback = 0) => {
+  const raw = textOf(el, tag);
+  if (!raw) return fallback;
+  const v = Number.parseFloat(raw);
+  return Number.isFinite(v) ? v : fallback;
+};
+var pitchOf = (note) => {
+  const p = note.getElementsByTagName("pitch")[0];
+  if (!p) return null;
+  const step = textOf(p, "step").toUpperCase();
+  const base = PITCH_CLASS[step];
+  if (base === void 0) return null;
+  const octave = numOf(p, "octave", 4);
+  const alter = Math.round(numOf(p, "alter", 0));
+  return (octave + 1) * 12 + base + alter;
+};
+var parseMusicXML = (xml) => {
+  const doc = new DOMParser().parseFromString(xml, "application/xml");
+  if (doc.getElementsByTagName("parserror").length > 0)
+    throw new Error("MusicXML \u3068\u3057\u3066\u8AAD\u3081\u307E\u305B\u3093");
+  const nameById = /* @__PURE__ */ new Map();
+  for (const sp of Array.from(doc.getElementsByTagName("score-part"))) {
+    const id = sp.getAttribute("id");
+    if (id) nameById.set(id, textOf(sp, "part-name") || id);
+  }
+  const placements = [];
+  const parts = [];
+  let bpm = 0;
+  const partEls = Array.from(doc.getElementsByTagName("part"));
+  partEls.forEach((partEl, partIndex) => {
+    const id = partEl.getAttribute("id") ?? "";
+    let divisions = 1;
+    let cursor = 0;
+    let measureStart = 0;
+    let lastStart = 0;
+    let lastDurSteps = 0;
+    const tied = /* @__PURE__ */ new Map();
+    let count = 0;
+    let pitchSum = 0;
+    let lyricSeen = false;
+    for (const measure of Array.from(partEl.getElementsByTagName("measure"))) {
+      measureStart += cursor;
+      cursor = 0;
+      for (const child of Array.from(measure.children)) {
+        const tag = child.tagName.toLowerCase();
+        if (tag === "attributes") {
+          const d = numOf(child, "divisions", 0);
+          if (d > 0) divisions = d;
+          continue;
+        }
+        if (tag === "direction") {
+          const sound = child.getElementsByTagName("sound")[0];
+          const t = Number.parseFloat(sound?.getAttribute("tempo") ?? "");
+          if (!bpm && Number.isFinite(t) && t > 0) bpm = t;
+          continue;
+        }
+        if (tag === "backup" || tag === "forward") {
+          const steps = numOf(child, "duration", 0) / divisions * STEPS_PER_BEAT4;
+          cursor += tag === "backup" ? -steps : steps;
+          continue;
+        }
+        if (tag !== "note") continue;
+        const durSteps = Math.round(
+          numOf(child, "duration", 0) / divisions * STEPS_PER_BEAT4
+        );
+        const isChord = child.getElementsByTagName("chord").length > 0;
+        const isRest = child.getElementsByTagName("rest").length > 0;
+        const start = isChord ? lastStart : measureStart + cursor;
+        if (!isRest) {
+          const pitch = pitchOf(child);
+          if (pitch !== null) {
+            const lyric = textOf(
+              child.getElementsByTagName("lyric")[0],
+              "text"
+            );
+            if (lyric) lyricSeen = true;
+            const ties = Array.from(child.getElementsByTagName("tie"));
+            const stops = ties.some((t) => t.getAttribute("type") === "stop");
+            const starts = ties.some((t) => t.getAttribute("type") === "start");
+            const held = tied.get(pitch);
+            if (stops && held) {
+              held.durationSteps += durSteps;
+              if (!starts) tied.delete(pitch);
+            } else {
+              const placed = {
+                partIndex,
+                startStep: Math.max(0, Math.round(start)),
+                pitch,
+                durationSteps: Math.max(1, durSteps),
+                lyric
+              };
+              placements.push(placed);
+              count++;
+              pitchSum += pitch;
+              if (starts) tied.set(pitch, placed);
+            }
+          }
+        }
+        if (!isChord) {
+          lastStart = start;
+          lastDurSteps = durSteps;
+          cursor += durSteps;
+        } else {
+          lastDurSteps = Math.max(lastDurSteps, durSteps);
+        }
+      }
+    }
+    parts.push({
+      index: partIndex,
+      name: nameById.get(id) || `Part ${partIndex + 1}`,
+      noteCount: count,
+      hasLyrics: lyricSeen,
+      avgPitch: count > 0 ? pitchSum / count : 0
+    });
+  });
+  return { parts, placements, bpm: bpm > 0 ? Math.round(bpm) : 120 };
+};
+var SHARP_SPELLING = [
+  ["C", 0],
+  ["C", 1],
+  ["D", 0],
+  ["D", 1],
+  ["E", 0],
+  ["F", 0],
+  ["F", 1],
+  ["G", 0],
+  ["G", 1],
+  ["A", 0],
+  ["A", 1],
+  ["B", 0]
+];
+var NOTE_TYPES = [
+  [STEPS_PER_BEAT4 * 4, "whole"],
+  [STEPS_PER_BEAT4 * 2, "half"],
+  [STEPS_PER_BEAT4, "quarter"],
+  [STEPS_PER_BEAT4 / 2, "eighth"],
+  [STEPS_PER_BEAT4 / 4, "16th"],
+  [STEPS_PER_BEAT4 / 8, "32nd"]
+];
+var typeOf = (steps) => {
+  for (const [len, type] of NOTE_TYPES) {
+    if (steps >= len) {
+      const dots = steps >= len * 1.5 && steps < len * 2 ? 1 : 0;
+      return { type, dots };
+    }
+  }
+  return { type: "32nd", dots: 0 };
+};
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var exportMusicXML = (options) => {
+  const { parts, bpm, stepsPerBar, title } = options;
+  const beatsPerBar = Math.max(1, Math.round(stepsPerBar / STEPS_PER_BEAT4));
+  const partList = parts.map(
+    (p, i2) => `    <score-part id="P${i2 + 1}">
+      <part-name>${esc(p.name)}</part-name>
+    </score-part>`
+  ).join("\n");
+  const body = parts.map((part, pi) => {
+    const notes = [...part.notes].sort((a, b) => a.startStep - b.startStep);
+    const end = notes.reduce(
+      (m, n) => Math.max(m, n.startStep + n.durationSteps),
+      0
+    );
+    const bars = Math.max(1, Math.ceil(end / stepsPerBar));
+    const lines = [`  <part id="P${pi + 1}">`];
+    let li = 0;
+    for (let bar = 0; bar < bars; bar++) {
+      const from = bar * stepsPerBar;
+      const to = from + stepsPerBar;
+      lines.push(`    <measure number="${bar + 1}">`);
+      if (bar === 0) {
+        lines.push(
+          `      <attributes>
+        <divisions>${STEPS_PER_BEAT4}</divisions>`,
+          `        <key><fifths>0</fifths></key>`,
+          `        <time><beats>${beatsPerBar}</beats><beat-type>4</beat-type></time>`,
+          `        <clef><sign>G</sign><line>2</line></clef>
+      </attributes>`
+        );
+        if (pi === 0)
+          lines.push(
+            `      <direction placement="above"><direction-type><metronome><beat-unit>quarter</beat-unit><per-minute>${Math.round(bpm)}</per-minute></metronome></direction-type><sound tempo="${Math.round(bpm)}"/></direction>`
+          );
+      }
+      let cursor = from;
+      const inBar = notes.filter(
+        (n) => n.startStep >= from && n.startStep < to
+      );
+      const groups = /* @__PURE__ */ new Map();
+      for (const n of inBar) {
+        const g = groups.get(n.startStep);
+        if (g) g.push(n);
+        else groups.set(n.startStep, [n]);
+      }
+      const starts = [...groups.keys()].sort((a, b) => a - b);
+      for (let gi = 0; gi < starts.length; gi++) {
+        const at = starts[gi];
+        const group = groups.get(at);
+        if (at > cursor) {
+          const { type, dots } = typeOf(at - cursor);
+          lines.push(
+            `      <note><rest/><duration>${at - cursor}</duration><type>${type}</type>${"<dot/>".repeat(dots)}</note>`
+          );
+          cursor = at;
+        }
+        const nextAt = gi + 1 < starts.length ? starts[gi + 1] : to;
+        const room = Math.min(to, nextAt) - at;
+        const dur = Math.max(
+          1,
+          Math.min(Math.max(...group.map((n) => n.durationSteps)), room)
+        );
+        group.forEach((n, ni) => {
+          const semi = Math.round(n.pitchUnits / UNITS_PER_SEMITONE);
+          const [step, alter] = SHARP_SPELLING[(semi % 12 + 12) % 12];
+          const octave = Math.floor(semi / 12) - 1;
+          const { type, dots } = typeOf(dur);
+          const lyric = part.lyrics?.[li];
+          lines.push(
+            `      <note>${ni > 0 ? "<chord/>" : ""}<pitch><step>${step}</step>${alter ? `<alter>${alter}</alter>` : ""}<octave>${octave}</octave></pitch><duration>${dur}</duration><type>${type}</type>${"<dot/>".repeat(dots)}` + (ni === 0 && lyric ? `<lyric><syllabic>single</syllabic><text>${esc(lyric)}</text></lyric>` : "") + `</note>`
+          );
+          if (ni === 0) li++;
+        });
+        cursor = at + dur;
+      }
+      if (cursor < to) {
+        const { type, dots } = typeOf(to - cursor);
+        lines.push(
+          `      <note><rest/><duration>${to - cursor}</duration><type>${type}</type>${"<dot/>".repeat(dots)}</note>`
+        );
+      }
+      lines.push("    </measure>");
+    }
+    lines.push("  </part>");
+    return lines.join("\n");
+  }).join("\n");
+  return [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">',
+    '<score-partwise version="4.0">',
+    `  <work><work-title>${esc(title ?? "Untitled")}</work-title></work>`,
+    // 書き出し元を残す。MML・MIDI と揃えてある（`src/version.ts` に理由）。
+    `  <identification><encoding><software>dtm ${DTM_VERSION}</software></encoding></identification>`,
+    "  <part-list>",
+    partList,
+    "  </part-list>",
+    body,
+    "</score-partwise>",
+    ""
+  ].join("\n");
+};
+var musicXmlToNotes = (placements, partIndex) => placements.filter((p) => p.partIndex === partIndex).map((p) => ({
+  startStep: p.startStep,
+  durationSteps: p.durationSteps,
+  pitchUnits: p.pitch * UNITS_PER_SEMITONE,
+  velocity: 100
+}));
+
 // src/renderer.ts
 var KEYBOARD_WIDTH = 60;
 var HEADER_HEIGHT = 20;
@@ -27062,6 +29011,76 @@ var createRenderer = (mountTarget, width = 800, height = 450, config) => {
       }
     }
   };
+  const drawSpeechSpans = (spans, color = [255, 241, 232]) => {
+    if (spans.length === 0) return;
+    const {
+      keyHeight,
+      stepWidth,
+      keyCount,
+      pitchRangeStart,
+      unitsPerRow: upr = UNITS_PER_SEMITONE
+    } = g_config;
+    const [r, g, b] = color;
+    g_grid_ctx.save();
+    for (const { note, durationSteps } of spans) {
+      if (durationSteps <= 0) continue;
+      const x2 = note.startStep * stepWidth - g_draw_offset_x;
+      const y = (keyCount - 1 - (note.pitchUnits - pitchRangeStart) / upr) * keyHeight - g_draw_offset_y;
+      const w = durationSteps * stepWidth;
+      if (x2 + w < 0 || x2 > g_grid_canvas.width) continue;
+      if (y + keyHeight < 0 || y > g_grid_canvas.height) continue;
+      const h = Math.max(2, Math.floor(keyHeight * 0.35));
+      const top = y + keyHeight - h - 1;
+      g_grid_ctx.fillStyle = `rgba(${r},${g},${b},0.28)`;
+      g_grid_ctx.fillRect(x2 + 1, top, w - 2, h);
+      g_grid_ctx.strokeStyle = `rgba(${r},${g},${b},0.75)`;
+      g_grid_ctx.lineWidth = 1;
+      g_grid_ctx.setLineDash([3, 2]);
+      g_grid_ctx.strokeRect(x2 + 1.5, top + 0.5, w - 3, h - 1);
+      g_grid_ctx.setLineDash([]);
+      g_grid_ctx.beginPath();
+      g_grid_ctx.moveTo(x2 + w - 1.5, y + 1);
+      g_grid_ctx.lineTo(x2 + w - 1.5, y + keyHeight - 1);
+      g_grid_ctx.stroke();
+    }
+    g_grid_ctx.restore();
+  };
+  const drawPitchGuide = (pitchUnits, label) => {
+    const {
+      keyHeight,
+      keyCount,
+      pitchRangeStart,
+      unitsPerRow: upr = UNITS_PER_SEMITONE
+    } = g_config;
+    const row = Math.round((pitchUnits - pitchRangeStart) / upr);
+    if (row < 0 || row >= keyCount) return;
+    const y = (keyCount - 1 - row) * keyHeight - g_draw_offset_y;
+    if (y + keyHeight < 0 || y > g_grid_canvas.height) return;
+    g_grid_ctx.save();
+    g_grid_ctx.fillStyle = "rgba(255,236,39,0.10)";
+    g_grid_ctx.fillRect(0, y, g_grid_canvas.width, keyHeight);
+    g_grid_ctx.strokeStyle = "rgba(255,236,39,0.55)";
+    g_grid_ctx.lineWidth = 1;
+    g_grid_ctx.setLineDash([6, 4]);
+    g_grid_ctx.beginPath();
+    g_grid_ctx.moveTo(0, y + keyHeight / 2 + 0.5);
+    g_grid_ctx.lineTo(g_grid_canvas.width, y + keyHeight / 2 + 0.5);
+    g_grid_ctx.stroke();
+    if (keyHeight >= 7) {
+      const fontSize = Math.min(11, Math.floor(keyHeight * 0.85));
+      g_grid_ctx.setLineDash([]);
+      g_grid_ctx.font = `${fontSize}px 'k8x12',sans-serif`;
+      g_grid_ctx.textAlign = "left";
+      g_grid_ctx.textBaseline = "middle";
+      g_grid_ctx.lineWidth = 3;
+      g_grid_ctx.lineJoin = "round";
+      g_grid_ctx.strokeStyle = "rgba(0,0,0,0.85)";
+      g_grid_ctx.strokeText(label, 4, y + keyHeight / 2);
+      g_grid_ctx.fillStyle = "#ffec27";
+      g_grid_ctx.fillText(label, 4, y + keyHeight / 2);
+    }
+    g_grid_ctx.restore();
+  };
   const drawNoteLyrics = (notes, syllables) => {
     if (syllables.length === 0) return;
     const {
@@ -27211,6 +29230,8 @@ var createRenderer = (mountTarget, width = 800, height = 450, config) => {
     drawGrid,
     drawNotes,
     drawNoteLyrics,
+    drawSpeechSpans,
+    drawPitchGuide,
     drawSelectionRect,
     drawSelectedNotes,
     getXY,
@@ -27809,7 +29830,7 @@ var VOWEL_KANA2 = {
   o: "\u304A",
   \u00FC: "\u3086"
 };
-var SMALL_KANA2 = {
+var SMALL_KANA3 = {
   a: "\u3083",
   u: "\u3085",
   e: "\u3047",
@@ -27881,7 +29902,7 @@ var pinyinToMoras = (raw) => {
     const zero = initial === "" && medial === "i";
     const head = zero ? ZERO_PALATAL[nucleus] : onset[medial];
     if (!head) return null;
-    const small = SMALL_KANA2[nucleus];
+    const small = SMALL_KANA3[nucleus];
     if (zero) moras.push(head);
     else if (head.length === 1 && small) moras.push(head + small);
     else moras.push(head, VOWEL_KANA2[nucleus]);
@@ -27891,10 +29912,10 @@ var pinyinToMoras = (raw) => {
 };
 
 // src/ust-io.ts
-var STEPS_PER_BEAT4 = 48;
+var STEPS_PER_BEAT5 = 48;
 var UST_TICKS_PER_BEAT = 480;
-var TICKS_TO_STEPS = STEPS_PER_BEAT4 / UST_TICKS_PER_BEAT;
-var STEPS_TO_TICKS = UST_TICKS_PER_BEAT / STEPS_PER_BEAT4;
+var TICKS_TO_STEPS = STEPS_PER_BEAT5 / UST_TICKS_PER_BEAT;
+var STEPS_TO_TICKS = UST_TICKS_PER_BEAT / STEPS_PER_BEAT5;
 var MORA_TAIL_MAX_STEPS = 12;
 var UST_CONTINUE_LYRICS = ["+", "+~", "+-", "+*", "*", "\u30FC", "-"];
 var TIE = "\u30FC";
@@ -27977,12 +29998,12 @@ var ROMAJI_KANA = (() => {
   return map;
 })();
 var KANA_HEAD_RE = /^[ぁ-ゖァ-ヶー〜]+/;
-var SMALL_KANA3 = "\u3041\u3043\u3045\u3047\u3049\u3083\u3085\u3087";
+var SMALL_KANA4 = "\u3041\u3043\u3045\u3047\u3049\u3083\u3085\u3087";
 var splitMoras = (kana) => {
   const moras = [];
   for (const ch of kana) {
     const last = moras.length - 1;
-    if (last >= 0 && SMALL_KANA3.includes(ch)) moras[last] += ch;
+    if (last >= 0 && SMALL_KANA4.includes(ch)) moras[last] += ch;
     else moras.push(ch);
   }
   return moras;
@@ -28167,7 +30188,7 @@ var parseUst = (source, name = "") => {
   const syllables = [];
   let unknownLyricCount = 0;
   let hasVoiced = false;
-  const msPerStep = 6e4 / (bpm ?? 120) / STEPS_PER_BEAT4;
+  const msPerStep = 6e4 / (bpm ?? 120) / STEPS_PER_BEAT5;
   for (const fields of sections) {
     const length = Number.parseFloat(fields.length ?? "");
     if (!Number.isFinite(length) || length <= 0) continue;
@@ -28263,6 +30284,7 @@ var ustLyricOf = (kana) => {
   if (kana === "") return DEFAULT_UST_LYRIC;
   if (kana === TIE || kana === "\u301C") return "+";
   if (kana === REST) return "R";
+  if (kana.startsWith("\u300C")) return "R";
   return kana;
 };
 var UST_ENVELOPE_ATTACK_MS = 5;
@@ -28406,7 +30428,9 @@ var buildUst = (options) => {
     cursorTick = startTick + length;
   }
   assignFadeEnvelopes(out);
-  out.forEach((note, index) => lines.push(...ustNoteSection(index, note)));
+  for (const [index, note] of out.entries()) {
+    lines.push(...ustNoteSection(index, note));
+  }
   lines.push("[#TRACKEND]");
   return `${lines.join("\r\n")}\r
 `;
@@ -28460,8 +30484,22 @@ c  d  e  f   g    \u2190 \u97F3\u7B265\u3064</pre>
     <li><code>\u3001</code> <strong>\u30D6\u30EC\u30B9</strong>\uFF08\u8AAD\u70B9\uFF09\u2026 <strong>\u97F3\u7B26\u306F\u6D88\u8CBB\u305B\u305A</strong>\u3001\u76F4\u524D\u306E\u97F3\u3092\u5C11\u3057\u77ED\u304F\u3057\u3066\u606F\u7D99\u304E\u3092\u5165\u308C\u307E\u3059\u3002</li>
     <li><code>\u2193</code> <strong>\u3060\u3093\u3060\u3093\u5C0F\u3055\u304F</strong>\uFF08\u4E0B\u5411\u304D\u77E2\u5370\uFF09\u2026 <strong>\u97F3\u7B26\u306F\u6D88\u8CBB\u305B\u305A</strong>\u3001\u305D\u306E\u97F3\u3092\u6B4C\u3063\u305F\u307E\u307E\u58F0\u91CF\u3092\u843D\u3068\u3057\u307E\u3059\u3002\u8907\u6570\u66F8\u304F\u3068\u6E1B\u308A\u65B9\u3092\u523B\u3081\u307E\u3059\u3002</li>
     <li><code>\u2191</code> <strong>\u3060\u3093\u3060\u3093\u5927\u304D\u304F</strong>\uFF08\u4E0A\u5411\u304D\u77E2\u5370\uFF09\u2026 <code>\u2193</code> \u306E\u5BFE\u3002\u5C0F\u3055\u304F\u5165\u3063\u3066\u58F0\u91CF\u3092\u4E0A\u3052\u3066\u3044\u304D\u307E\u3059\u3002</li>
+    <li><code>\u300C\u2026\u300D</code> <strong>\u8A9E\u308A</strong>\uFF08\u304B\u304E\u62EC\u5F27\uFF09\u2026 \u56F2\u3093\u3060\u90E8\u5206\u3092\u6B4C\u308F\u305A\u306B<strong>\u8AAD\u307F\u4E0A\u3052</strong>\u307E\u3059\u3002\u62EC\u5F27\u3072\u3068\u304B\u305F\u307E\u308A\u3067\u97F3\u7B26\u30921\u3064\u6D88\u8CBB\u3057\u3001\u305D\u306E\u97F3\u7B26\u306E\u4F4D\u7F6E\u304B\u3089\u8A71\u3057\u59CB\u3081\u307E\u3059\u3002</li>
+  </ul>
+  <p><small>\u5168\u89D2\u30C1\u30EB\u30C0 <code>\uFF5E</code> \u306F <code>\u301C</code>\u3001\u534A\u89D2\u30AB\u30F3\u30DE <code>,</code> \u306F <code>\u3001</code>\u3001<code>\u21E9</code> <code>\u2B07</code> \u306F <code>\u2193</code>\u3001<code>\u21E7</code> <code>\u2B06</code> \u306F <code>\u2191</code> \u3068\u3057\u3066\u6271\u308F\u308C\u307E\u3059\u3002\u3053\u308C\u3089\u4EE5\u5916\u306E\u8A18\u53F7\uFF08\u82F1\u6570\u5B57\u30FB\u30B9\u30DA\u30FC\u30B9\u30FB\u53E5\u8AAD\u70B9\u306A\u3069\uFF09\u306F\u7121\u8996\u3055\u308C\u307E\u3059\uFF08<code>\u300C\u2026\u300D</code> \u306E\u4E2D\u3060\u3051\u306F\u4F8B\u5916\u3067\u3001\u305D\u306E\u307E\u307E\u8AAD\u307F\u4E0A\u3052\u306B\u6E21\u3055\u308C\u307E\u3059\uFF09\u3002</small></p>
+
+  <h4>\u6B4C\u306E\u4E2D\u3067\u8A9E\u308B\uFF08<code>\u300C\u2026\u300D</code>\uFF09</h4>
+  <p>\u6B4C\u8A5E\u306E\u9014\u4E2D\u306B <code>\u300C\u2026\u300D</code> \u3092\u66F8\u304F\u3068\u3001\u305D\u306E\u90E8\u5206\u3060\u3051\u3092<strong>\u8A71\u3057\u58F0\u3067\u8AAD\u307F\u4E0A\u3052</strong>\u307E\u3059\uFF08UTAU\u97F3\u6E90\u306E\u307F\u3002klatt \u3067\u306F\u9CF4\u308A\u307E\u305B\u3093\uFF09\u3002\u4E2D\u8EAB\u306F\u6F22\u5B57\u30FB\u6570\u5B57\u30FB\u53E5\u8AAD\u70B9\u3092\u542B\u3093\u3067\u304B\u307E\u3044\u307E\u305B\u3093\u2014\u2014\u8AAD\u307F\u3068\u30A2\u30AF\u30BB\u30F3\u30C8\u306F\u8F9E\u66F8\u304C\u6C7A\u3081\u307E\u3059\u3002<code>\uFF1F</code> \u3067\u7D42\u308F\u308B\u3068\u8A9E\u5C3E\u304C\u4E0A\u304C\u308A\u307E\u3059\u3002</p>
+  <pre>\u3075\u3064\u3046\u306B\u3046\u305F\u3046\u300C\u304B\u305F\u308B\u3070\u3057\u3087\u300D\u3075\u3064\u3046\u306B\u3046\u305F\u3046
+\u3069\u3093\u3050\u308A\u3053\u308D\u3053\u308D\u300C\u307F\u306A\u3055\u3093\u3001\u3053\u3093\u306B\u3061\u306F\uFF01\u300D\u3069\u3093\u3050\u308A\u3053
+\u300C\u30BB\u30EA\u30D5\u3060\u3051\u306E\u30C8\u30E9\u30C3\u30AF\u3082\u4F5C\u308C\u307E\u3059\u3002\u300D</pre>
+  <ul>
+    <li><strong>\u97F3\u7B26\u306E\u4F4D\u7F6E</strong>\u304C\u8A71\u3057\u59CB\u3081\u3067\u3059\u3002<strong>\u9577\u3055\u306F\u8AAD\u307F\u4E0A\u3052\u304C\u6C7A\u3081\u308B</strong>\u306E\u3067\u3001\u97F3\u7B26\u306E\u9577\u3055\u306F\u4F7F\u3044\u307E\u305B\u3093\u3002\u30D4\u30A2\u30CE\u30ED\u30FC\u30EB\u306B\u306F\u5B9F\u969B\u306B\u558B\u308B\u9577\u3055\u304C\u7834\u7DDA\u306E\u5E2F\u3067\u51FA\u308B\u306E\u3067\u3001\u6B21\u306E\u6B4C\u3044\u51FA\u3057\u3068\u91CD\u306A\u3089\u306A\u3044\u304B\u78BA\u304B\u3081\u3089\u308C\u307E\u3059\u3002</li>
+    <li><strong>\u97F3\u7B26\u306E\u9AD8\u3055</strong>\u306F\u8A71\u3059\u58F0\u306E\u9AD8\u3055\u3067\u3059\u3002\u9EC4\u8272\u3044\u300C\u8A9E\u308A\u306E\u57FA\u6E96\u300D\u306E\u884C\u306B\u7F6E\u304F\u3068\u97F3\u6E90\u306E\u7D20\u306E\u58F0\u3001\u4E0A\u306B\u7F6E\u304F\u307B\u3069\u9AD8\u3044\u58F0\u306B\u306A\u308A\u307E\u3059\uFF08\u76EE\u5B89\u306F\xB17\u534A\u97F3\u307E\u3067\uFF09\u3002</li>
+    <li>\u7A7A\u306E <code>\u300C\u300D</code> \u306F <code>_</code> \u3068\u540C\u3058\uFF08\u97F3\u7B26\u30921\u3064\u6D88\u8CBB\u3057\u3066\u7121\u97F3\uFF09\u3002\u9589\u3058\u62EC\u5F27\u304C\u7121\u3051\u308C\u3070\u884C\u672B\u307E\u3067\u304C\u8A9E\u308A\u306B\u306A\u308A\u307E\u3059\u3002</li>
+    <li>\u4E2D\u8EAB\u306B <code>;</code> \u3068\u6539\u884C\u306F\u66F8\u3051\u307E\u305B\u3093\uFF08MML\u306E\u533A\u5207\u308A\u6587\u5B57\u306E\u305F\u3081\uFF09\u3002</li>
+    <li>\u521D\u3081\u3066\u8A9E\u308A\u3092\u9CF4\u3089\u3059\u3068\u304D\u306F\u8F9E\u66F8\u3068\u97F3\u58F0\u30E2\u30C7\u30EB\uFF08\u7D0445MB\uFF09\u3092\u53D6\u5F97\u3059\u308B\u306E\u3067\u3001\u518D\u751F\u958B\u59CB\u307E\u3067\u5C11\u3057\u5F85\u3061\u307E\u3059\u30022\u56DE\u76EE\u4EE5\u964D\u306F\u4FDD\u5B58\u6E08\u307F\u306E\u3082\u306E\u3092\u4F7F\u3044\u307E\u3059\u3002</li>
   </ul>
-  <p><small>\u5168\u89D2\u30C1\u30EB\u30C0 <code>\uFF5E</code> \u306F <code>\u301C</code>\u3001\u534A\u89D2\u30AB\u30F3\u30DE <code>,</code> \u306F <code>\u3001</code>\u3001<code>\u21E9</code> <code>\u2B07</code> \u306F <code>\u2193</code>\u3001<code>\u21E7</code> <code>\u2B06</code> \u306F <code>\u2191</code> \u3068\u3057\u3066\u6271\u308F\u308C\u307E\u3059\u3002\u3053\u308C\u3089\u4EE5\u5916\u306E\u8A18\u53F7\uFF08\u82F1\u6570\u5B57\u30FB\u30B9\u30DA\u30FC\u30B9\u30FB\u53E5\u8AAD\u70B9\u306A\u3069\uFF09\u306F\u7121\u8996\u3055\u308C\u307E\u3059\u3002</small></p>
 
   <h4>\u5F37\u5F31\u3092\u3064\u3051\u308B\uFF08<code>\u2193</code> <code>\u2191</code>\uFF09</h4>
   <p>\u4F38\u3070\u3057\u305F\u97F3\u306B\u4ED8\u3051\u308B\u3068\u3001<strong>\u8A00\u3044\u76F4\u3055\u305A\u306B\u4F38\u3070\u3057\u305F\u307E\u307E</strong>\u58F0\u91CF\u3060\u3051\u304C\u52D5\u304D\u307E\u3059\u3002\u66F2\u306E\u7D42\u308F\u308A\u306E\u4F59\u97FB\u3084\u3001\u30B5\u30D3\u3078\u306E\u76DB\u308A\u4E0A\u3052\u306B\u4F7F\u3044\u307E\u3059\u3002</p>
@@ -28848,6 +30886,27 @@ var MIDI_INFO_HTML = `
   <p>UTAU\u306EUST\u30D5\u30A1\u30A4\u30EB\u306F\u3001\u97F3\u7B26\u3068\u6B4C\u8A5E\u3092\u307E\u3068\u3081\u3066\u76F4\u63A5\u8AAD\u307F\u8FBC\u3081\u307E\u3059\uFF08MIDI\u3078\u66F8\u304D\u51FA\u3059\u5FC5\u8981\u306F\u3042\u308A\u307E\u305B\u3093\uFF09\u3002\u4E0B\u306E\u300CUST\u300D\u6B04\u3092\u304A\u4F7F\u3044\u304F\u3060\u3055\u3044\u3002</p>
 </div>
 `;
+var MUSICXML_INFO_HTML = `
+<div class="dtm-modal-body-content">
+  <h4>1. MusicXML\u3068\u306F</h4>
+  <p>MuseScore\u3001Finale\u3001Sibelius\u306A\u3069\u306E\u697D\u8B5C\u4F5C\u6210\u30BD\u30D5\u30C8\u3067\u5E83\u304F\u4F7F\u308F\u308C\u3066\u3044\u308B\u697D\u8B5C\u30D5\u30A9\u30FC\u30DE\u30C3\u30C8\u3067\u3059\u3002MIDI\u3068\u9055\u3063\u3066<strong>\u30D1\u30FC\u30C8\u69CB\u6210\u3084\u97F3\u7B26\u306B\u7D10\u3065\u3044\u305F\u6B4C\u8A5E</strong>\u3092\u4FDD\u6301\u3067\u304D\u308B\u305F\u3081\u3001\u4E3B\u65CB\u5F8B\u306E\u7279\u5B9A\u3084\u6B4C\u58F0\u5408\u6210\u3078\u306E\u53D7\u3051\u6E21\u3057\u304C\u78BA\u5B9F\u306B\u884C\u3048\u307E\u3059\u3002</p>
+
+  <h4>2. \u8AAD\u307F\u8FBC\u307F\u306E\u3057\u304B\u305F</h4>
+  <ul>
+    <li>\u300C\u30D5\u30A1\u30A4\u30EB\u3092\u9078\u629E\u300D\u304B\u3089 <code>.musicxml</code> \u307E\u305F\u306F <code>.xml</code> \u30D5\u30A1\u30A4\u30EB\u3092\u9078\u3073\u307E\u3059\u3002</li>
+    <li>\u30D5\u30A1\u30A4\u30EB\u5185\u306B\u542B\u307E\u308C\u308B\u30D1\u30FC\u30C8\u4E00\u89A7\u304C\u8868\u793A\u3055\u308C\u308B\u306E\u3067\u3001\u8AAD\u307F\u8FBC\u307F\u305F\u3044\u30D1\u30FC\u30C8\u3092\u9078\u629E\u3057\u3066\u300C\u8AAD\u8FBC\u300D\u3092\u62BC\u3057\u307E\u3059\u3002</li>
+    <li>\u6B4C\u8A5E\u304C\u542B\u307E\u308C\u3066\u3044\u308B\u30D1\u30FC\u30C8\u306F\u81EA\u52D5\u7684\u306B\u6B4C\u58F0\u5408\u6210\uFF08UTAU\uFF09\u30C8\u30E9\u30C3\u30AF\u3068\u3057\u3066\u8A2D\u5B9A\u3055\u308C\u3001\u6B4C\u8A5E\u3082\u6D41\u3057\u8FBC\u307E\u308C\u307E\u3059\u3002</li>
+    <li>\u30C6\u30F3\u30DD\uFF08BPM\uFF09\u60C5\u5831\u304C\u3042\u308B\u5834\u5408\u306F\u81EA\u52D5\u7684\u306B\u53CD\u6620\u3055\u308C\u307E\u3059\u3002</li>
+    <li>\u300C\u73FE\u5728\u306E\u30C8\u30E9\u30C3\u30AF\u306E\u307F\u5BFE\u8C61\u3068\u3059\u308B\u300D\u304C\u6709\u52B9\u306A\u3068\u304D\u306F\u3001\u9078\u629E\u3057\u305F\u6700\u521D\u306E\u30D1\u30FC\u30C8\u3060\u3051\u304C\u73FE\u5728\u30A2\u30AF\u30C6\u30A3\u30D6\u306A\u30C8\u30E9\u30C3\u30AF\u306B\u8AAD\u307F\u8FBC\u307E\u308C\u307E\u3059\u3002</li>
+  </ul>
+
+  <h4>3. \u66F8\u304D\u51FA\u3057</h4>
+  <ul>
+    <li>\u300CMIDI / MusicXML / UST / MML \u51FA\u529B\u300D\u306E\u300CMusicXML\u51FA\u529B\u300D\u3067\u3001\u5168\u30C8\u30E9\u30C3\u30AF\u3092 <code>score-partwise</code> \u5F62\u5F0F\u306E MusicXML \u30D5\u30A1\u30A4\u30EB\u3068\u3057\u3066\u66F8\u304D\u51FA\u305B\u307E\u3059\u3002</li>
+    <li>\u97F3\u7B26\u3084\u30C8\u30E9\u30C3\u30AF\u540D\u306B\u52A0\u3048\u3066\u3001\u8A2D\u5B9A\u3055\u308C\u305F\u6B4C\u8A5E\u3082\u305D\u306E\u307E\u307E\u697D\u8B5C\u306E\u6B4C\u8A5E\u3068\u3057\u3066\u51FA\u529B\u3055\u308C\u307E\u3059\u3002</li>
+  </ul>
+</div>
+`;
 var UST_INFO_HTML = `
 <div class="dtm-modal-body-content">
   <h4>1. UST\u30D5\u30A1\u30A4\u30EB\u3068\u306F</h4>
@@ -28989,6 +31048,7 @@ var HELP_INFO_HTML = `
     <button class="dtm-btn dtm-btn--ghost" data-dtm-help="koe">\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0(.koe)</button>
     <button class="dtm-btn dtm-btn--ghost" data-dtm-help="chord">\u30B3\u30FC\u30C9\u9032\u884C</button>
     <button class="dtm-btn dtm-btn--ghost" data-dtm-help="midi">MIDI\u306E\u8AAD\u307F\u8FBC\u307F</button>
+    <button class="dtm-btn dtm-btn--ghost" data-dtm-help="musicxml">MusicXML</button>
     <button class="dtm-btn dtm-btn--ghost" data-dtm-help="ust">UST(UTAU)</button>
     <button class="dtm-btn dtm-btn--ghost" data-dtm-help="mml">MML\u306E\u66F8\u304D\u65B9</button>
     <button class="dtm-btn dtm-btn--ghost" data-dtm-help="loop">\u30EB\u30FC\u30D7\u518D\u751F</button>
@@ -29007,6 +31067,7 @@ var HELP_TOPICS = {
   koe: { title: "\u30AB\u30B9\u30BF\u30E0\u97F3\u58F0(.koe)\u306E\u4F7F\u3044\u65B9", html: KOE_INFO_HTML },
   chord: { title: "\u30B3\u30FC\u30C9\u9032\u884C\u306E\u81EA\u52D5\u5165\u529B\u89E3\u8AAC", html: CHORD_INFO_HTML2 },
   midi: { title: "MIDI\u306E\u8AAD\u307F\u8FBC\u307F\u89E3\u8AAC", html: MIDI_INFO_HTML },
+  musicxml: { title: "MusicXML\u306E\u5165\u51FA\u529B\u89E3\u8AAC", html: MUSICXML_INFO_HTML },
   ust: { title: "UST\u306E\u8AAD\u307F\u8FBC\u307F\u89E3\u8AAC", html: UST_INFO_HTML },
   mml: { title: "MML\u306E\u66F8\u304D\u65B9\u89E3\u8AAC", html: MML_INFO_HTML },
   loop: { title: "\u30EB\u30FC\u30D7\u518D\u751F\u306E\u89E3\u8AAC", html: LOOP_INFO_HTML },
@@ -29461,6 +31522,8 @@ var mountDAW = (target, options = {}) => {
   };
   let currentInstrument = "";
   let autoComposeInstrument = null;
+  let composeSeed = null;
+  let composeSetting = null;
   let activeTrackId = options.initialActiveTrack ?? trackConfigs[0].id;
   let trackFxAdvancedOpen = readPanelOpen("track-fx-advanced") ?? false;
   let lyricAdvancedOpen = readPanelOpen("lyric-advanced") ?? false;
@@ -29703,17 +31766,66 @@ var mountDAW = (target, options = {}) => {
   const getActive = () => trackStates.find((t) => t.config.id === activeTrackId) ?? trackStates[0];
   let lyricKanaCacheText = "";
   let lyricKanaCache = [];
-  const getActiveLyricKana = () => {
+  let lyricSyllableCache = [];
+  const getActiveLyricSyllables = () => {
     const t = getActive();
     if (!t?.lyricModel.trim()) return [];
     const text = t.lyrics.trim();
     if (!text) return [];
     if (text !== lyricKanaCacheText) {
       lyricKanaCacheText = text;
-      lyricKanaCache = normalizeLyrics(text).map(displayKana);
+      lyricSyllableCache = normalizeLyrics(text);
+      lyricKanaCache = lyricSyllableCache.map(displayKana);
     }
+    return lyricSyllableCache;
+  };
+  const getActiveLyricKana = () => {
+    getActiveLyricSyllables();
     return lyricKanaCache;
   };
+  const speechPreviewRequested = /* @__PURE__ */ new Set();
+  const requestSpeechPreview = (model, text) => {
+    const voices = options.singingVoices;
+    if (!voices?.planSpeech) return;
+    const key = `${model}|${text}`;
+    if (speechPreviewRequested.has(key)) return;
+    speechPreviewRequested.add(key);
+    void voices.planSpeech(model, text).then((d) => {
+      if (d !== null) redrawAll();
+    }).catch(() => {
+    });
+  };
+  const drawSpeechPreview = (notes) => {
+    const voices = options.singingVoices;
+    if (!voices) return;
+    const syllables = getActiveLyricSyllables();
+    if (!syllables.some((s) => s.kind === "speak")) return;
+    const model = getActive().lyricModel.trim().toLowerCase();
+    const sorted = [...notes].sort((a, b) => a.startStep - b.startStep);
+    const count = Math.min(sorted.length, syllables.length);
+    const secondsPerStep = 60 / bpm / 48;
+    const spans = [];
+    for (let i2 = 0; i2 < count; i2++) {
+      const syl = syllables[i2];
+      if (syl.kind !== "speak" || !syl.text) continue;
+      const d = voices.peekSpeechDurationSec?.(model, syl.text);
+      if (d === void 0) {
+        requestSpeechPreview(model, syl.text);
+        continue;
+      }
+      spans.push({ note: sorted[i2], durationSteps: d / secondsPerStep });
+    }
+    renderer.drawSpeechSpans(spans, getActive().config.color);
+  };
+  const drawSpeechPitchGuide = () => {
+    const voices = options.singingVoices;
+    if (!voices?.getSpeechReferenceUnits) return;
+    if (!getActiveLyricSyllables().some((s) => s.kind === "speak")) return;
+    const ref = voices.getSpeechReferenceUnits(
+      getActive().lyricModel.trim().toLowerCase()
+    );
+    if (ref !== void 0) renderer.drawPitchGuide(ref, "\u8A9E\u308A\u306E\u57FA\u6E96");
+  };
   let showModal;
   let showConfirm;
   const playableNotes = (t) => {
@@ -29798,6 +31910,7 @@ var mountDAW = (target, options = {}) => {
   };
   const redrawAll = () => {
     renderer.drawGrid(gridLineSteps);
+    drawSpeechPitchGuide();
     let lyricTargetNotes = null;
     let activeTrackState = null;
     for (const t of trackStates) {
@@ -29846,8 +31959,10 @@ var mountDAW = (target, options = {}) => {
         1
       ]);
     }
-    if (lyricTargetNotes)
+    if (lyricTargetNotes) {
+      drawSpeechPreview(lyricTargetNotes);
       renderer.drawNoteLyrics(lyricTargetNotes, getActiveLyricKana());
+    }
     drawStartLine();
     if (playbackState === "playing") drawPlayhead();
     updateScrollbars();
@@ -31452,9 +33567,9 @@ var mountDAW = (target, options = {}) => {
         </details>
         <div class="dtm-row">
           <span class="dtm-label dtm-grow">\u6B4C\u8A5E</span>
-          <button class="dtm-infobtn" data-dtm="lyric-input-info" title="\u6B4C\u8A5E\u306E\u66F8\u304D\u65B9\uFF08\u30FC\u30FB\u301C\u30FB\u3063\u30FB_\u30FB\u3001\u306E\u610F\u5473\uFF09">${icon("info", 12)}</button>
+          <button class="dtm-infobtn" data-dtm="lyric-input-info" title="\u6B4C\u8A5E\u306E\u66F8\u304D\u65B9\uFF08\u30FC\u30FB\u301C\u30FB\u3063\u30FB_\u30FB\u3001\u30FB\u300C\u300D\u306E\u610F\u5473\uFF09">${icon("info", 12)}</button>
         </div>
-        <textarea class="dtm-textarea" data-dtm="lyric-input" rows="2" placeholder="\u3072\u3089\u304C\u306A\u30FB\u30AB\u30BF\u30AB\u30CA\u3067\u6B4C\u8A5E\uFF08\u4F8B: \u3069\u308C\u307F\u3075\u3041\u305D\u3089\u3057\u3069\uFF09&#10;\u30FC=\u4F38\u3070\u3059 \u301C=\u3057\u3083\u304F\u308A \u3063=\u8A70\u307E\u308B _=\u6B4C\u308F\u306A\u3044 \u3001=\u30D6\u30EC\u30B9"></textarea>
+        <textarea class="dtm-textarea" data-dtm="lyric-input" rows="2" placeholder="\u3072\u3089\u304C\u306A\u30FB\u30AB\u30BF\u30AB\u30CA\u3067\u6B4C\u8A5E\uFF08\u4F8B: \u3069\u308C\u307F\u3075\u3041\u305D\u3089\u3057\u3069\uFF09&#10;\u30FC=\u4F38\u3070\u3059 \u301C=\u3057\u3083\u304F\u308A \u3063=\u8A70\u307E\u308B _=\u6B4C\u308F\u306A\u3044 \u3001=\u30D6\u30EC\u30B9 \u300C\u2026\u300D=\u8A9E\u308A\uFF08\u8AAD\u307F\u4E0A\u3052\uFF09"></textarea>
       </div>`;
       refs.trackBody.appendChild(lyricDiv);
       lyricDiv.querySelector(
@@ -31654,8 +33769,10 @@ var mountDAW = (target, options = {}) => {
       lyricVibrato.checked = active.vocalVibrato;
       lyricOctaveUnison.value = active.vocalOctaveUnison;
       const updateLyricCount = () => {
-        const n = normalizeLyrics(lyricInput.value).length;
-        lyricCount.textContent = active.lyricModel && n > 0 ? `${n}\u97F3\u7BC0` : "";
+        const syllables = normalizeLyrics(lyricInput.value);
+        const n = syllables.length;
+        const speak = syllables.filter((s) => s.kind === "speak").length;
+        lyricCount.textContent = active.lyricModel && n > 0 ? `${n}\u97F3\u7BC0${speak > 0 ? `\uFF08\u8A9E\u308A${speak}\uFF09` : ""}` : "";
       };
       const syncLyricTerms = () => {
         if (customVocalsMap.has(active.lyricModel)) {
@@ -31967,6 +34084,8 @@ var mountDAW = (target, options = {}) => {
         mode,
         edo: renderConfig.edo,
         loop: loopEnabled ? true : void 0,
+        seed: composeSeed ?? void 0,
+        compose: composeSetting ?? void 0,
         // アップロードされたファイルは url が空＝音源関連の宣言ごと出力されない
         audio: backing.url || void 0,
         audioStart: backing.rangeStartSec || void 0,
@@ -32006,6 +34125,8 @@ var mountDAW = (target, options = {}) => {
         mode,
         edo: renderConfig.edo,
         loop: loopEnabled ? true : void 0,
+        seed: composeSeed ?? void 0,
+        compose: composeSetting ?? void 0,
         // アップロードされたファイルは url が空＝音源関連の宣言ごと出力されない
         audio: backing.url || void 0,
         audioStart: backing.rangeStartSec || void 0,
@@ -32062,7 +34183,8 @@ var mountDAW = (target, options = {}) => {
     const lyricLines = trackStates.map((t, i2) => ({
       i: i2,
       notes: clipNotes(t.core.getNotes()),
-      text: t.lyrics.replace(/[\r\n]+/g, " ").trim(),
+      // `;` は MML の区切り文字なので、語り（「…」）の本文に紛れていても全角へ逃がす。
+      text: t.lyrics.replace(/[\r\n]+/g, " ").replace(/;/g, "\uFF1B").trim(),
       model: t.lyricModel.trim(),
       vol: t.vocalVolume,
       gate: t.vocalGate,
@@ -32205,6 +34327,8 @@ var mountDAW = (target, options = {}) => {
       clampTrackCount: trackStates.length
     });
     if (!applyActiveOnly) {
+      composeSeed = meta.seed ?? null;
+      composeSetting = meta.compose ?? null;
       if (meta.instrument && INSTRUMENT_PRESETS[meta.instrument]) {
         currentInstrument = meta.instrument;
         options.onInstrumentChange?.(meta.instrument);
@@ -32594,6 +34718,92 @@ var mountDAW = (target, options = {}) => {
       dropped: ustTracks.length - targets.length
     };
   };
+  const applyMusicXmlSelection = (xml, selectedIndices, startIndex) => {
+    stop();
+    const applyActiveOnly = refs.applyActiveOnly?.checked ?? false;
+    const from = Math.max(
+      0,
+      startIndex ?? (applyActiveOnly ? activeTrackIndexOf() : selectedIndices.length > 1 ? 0 : activeTrackIndexOf())
+    );
+    const maxCount = applyActiveOnly ? 1 : trackStates.length - from;
+    const targetIndices = selectedIndices.slice(0, Math.max(0, maxCount));
+    const voice = trackStates[from]?.lyricModel || pickComposeVocal();
+    targetIndices.forEach((partIndex, i2) => {
+      const t = trackStates[from + i2];
+      if (!t) return;
+      const notes = musicXmlToNotes(xml.placements, partIndex);
+      t.core.setLoadMode(true);
+      t.core.clearNotesWithoutHistory();
+      for (const n of notes) {
+        t.core.addNote(n.startStep, snapToEdoGrid(n.pitchUnits), {
+          noteLengthSteps: n.durationSteps,
+          velocity: n.velocity
+        });
+      }
+      t.core.setLoadMode(false);
+      t.core.addHistoryOnce();
+      const partPlacements = xml.placements.filter((p) => p.partIndex === partIndex).sort((a, b) => a.startStep - b.startStep);
+      const hasLyrics = partPlacements.some(
+        (p) => Boolean(p.lyric && p.lyric.trim())
+      );
+      if (hasLyrics) {
+        const syllables = [];
+        for (const p of partPlacements) {
+          const l = p.lyric?.trim();
+          syllables.push(l || "\u30FC");
+        }
+        t.lyrics = syllables.join("");
+        t.vocalVolume = DEFAULT_VOCAL_VOLUME;
+        t.vocalGate = 100;
+        t.vocalPan = 64;
+        t.vocalOctave = 0;
+        t.vocalVibrato = false;
+        t.vocalReverb = 0;
+        t.vocalDelay = 0;
+        t.vocalGender = 50;
+        t.vocalBreathiness = 50;
+        t.vocalTension = 50;
+        t.vocalOctaveUnison = "none";
+        if (!t.lyricModel) t.lyricModel = voice;
+        fireLyricsChange(t);
+      } else {
+        t.lyrics = "";
+        t.lyricModel = "";
+      }
+    });
+    if (xml.bpm > 0) setBpm(Math.round(xml.bpm));
+    playStartStep = 0;
+    currentOffsetX = 0;
+    const firstPitch = getFirstDetectedPitch();
+    centerPitch(firstPitch ?? pitchV1ToUnits(60));
+    redrawAll();
+    updateTrackPanel();
+    updateUndoRedo();
+    return {
+      applied: targetIndices.length,
+      dropped: selectedIndices.length - targetIndices.length
+    };
+  };
+  const exportMusicXML2 = () => {
+    const parts = trackStates.map((t) => {
+      const notes = playableNotes(t);
+      const syllables = t.lyrics ? normalizeLyrics(t.lyrics).map(displayKana) : void 0;
+      return {
+        name: t.config.name,
+        notes,
+        lyrics: syllables
+      };
+    });
+    const xml = exportMusicXML({
+      parts,
+      bpm,
+      stepsPerBar: renderConfig.stepsPerBar,
+      title: "DTM Project"
+    });
+    return new Blob([xml], {
+      type: "application/vnd.recordare.musicxml+xml;charset=utf-8"
+    });
+  };
   const exportUST = () => {
     const t = getActive();
     const syllables = normalizeLyrics(t.lyrics).map(displayKana);
@@ -33273,17 +35483,29 @@ var mountDAW = (target, options = {}) => {
       stop();
       overlayDuring(() => {
         const tmpl = selectedComposeTemplate();
+        const sections = selectedComposeSections();
+        const baseKey = refs.composeKey?.value ?? "any";
+        const scale = refs.composeScale?.value ?? "auto";
+        const seed = Math.random() * 4294967296 >>> 0;
         const song = composeSong({
           stepsPerBar: renderConfig.stepsPerBar,
           edo: renderConfig.edo,
-          sections: selectedComposeSections(),
+          sections,
           template: tmpl,
-          baseKey: refs.composeKey?.value ?? "any",
-          scale: refs.composeScale?.value ?? "auto",
+          baseKey,
+          scale,
+          random: seededRandom(seed),
           // 直近に作った曲の特徴を渡すと、それらから離れた候補に加点される。
           // 「作曲」を続けて押したときに似た曲が並ぶのを防ぐ。
           recent: recentComposeFingerprints
         });
+        composeSeed = seed;
+        composeSetting = [
+          tmpl ?? "custom",
+          baseKey,
+          scale,
+          sections.join("-")
+        ].join(":");
         recentComposeFingerprints.push(song.stats.fingerprint);
         if (recentComposeFingerprints.length > 5)
           recentComposeFingerprints.shift();
@@ -33464,6 +35686,7 @@ var mountDAW = (target, options = {}) => {
         updateTrackPanel();
         updateUndoRedo();
         composedSignature = trackSignature();
+        void play();
       });
     };
     const composeWithConfirm = (withVocal) => {
@@ -33483,28 +35706,47 @@ var mountDAW = (target, options = {}) => {
     refs.macroCompose.addEventListener("click", () => {
       composeWithConfirm(false);
     });
-    let keptMml = null;
+    let kept = readKeptSong();
     const updateKeepUI = () => {
-      refs.composeRecall.disabled = keptMml === null;
-      refs.composeKeep.textContent = keptMml === null ? "\u30AD\u30FC\u30D7" : "\u30AD\u30FC\u30D7\u6E08";
+      refs.composeRecall.disabled = kept === null;
+      refs.composeKeep.textContent = kept === null ? "\u30AD\u30FC\u30D7" : "\u30AD\u30FC\u30D7\u6E08";
     };
+    const snapshotKept = () => ({
+      // 小節数の上限は共有リンクの文字数のためのもので、アプリ内の退避には
+      // 効かせない（効かせると長い曲がキープした時点で切れる）。
+      mml: generateMML({ ignoreBarLimit: true }).full,
+      startStep: playStartStep
+    });
     refs.composeKeep.addEventListener("click", () => {
       const hasNotes = trackStates.some((t) => t.core.getNotes().length > 0);
       if (!hasNotes) return;
-      keptMml = generateMML({ ignoreBarLimit: true }).full;
+      kept = snapshotKept();
+      writeKeptSong(kept);
       updateKeepUI();
     });
-    refs.composeRecall.addEventListener("click", () => {
-      if (keptMml === null) return;
+    const loadKept = (song) => {
       const box = refs.applyActiveOnly;
       const was = box?.checked ?? false;
       if (box) box.checked = false;
       try {
-        loadMML(keptMml);
+        loadMML(song.mml);
       } finally {
         if (box) box.checked = was;
       }
+      playStartStep = Math.min(song.startStep, getMaxNoteStep());
       composedSignature = null;
+      void play();
+    };
+    refs.composeRecall.addEventListener("click", () => {
+      if (kept === null) return;
+      const previous = kept;
+      const hasNotes = trackStates.some((t) => t.core.getNotes().length > 0);
+      if (hasNotes) {
+        kept = snapshotKept();
+        writeKeptSong(kept);
+      }
+      loadKept(previous);
+      updateKeepUI();
     });
     updateKeepUI();
     refs.macroComposeVocal.addEventListener("click", () => {
@@ -33563,6 +35805,9 @@ var mountDAW = (target, options = {}) => {
     refs.exportMidiBtn.addEventListener("click", () => {
       download(exportMIDI2(), "dtm.mid");
     });
+    refs.exportMusicXmlBtn.addEventListener("click", () => {
+      download(exportMusicXML2(), "dtm.musicxml");
+    });
     refs.exportUstBtn.addEventListener("click", () => {
       const name = getActive().config.name.replace(/[/:*?"<>|\s]+/g, "_");
       download(exportUST(), `dtm_${name}.ust`);
@@ -33830,6 +36075,7 @@ var mountDAW = (target, options = {}) => {
     });
     if (showMidi) {
       wireMidi();
+      wireMusicXml();
       wireUst();
     }
     if (showAudio) {
@@ -33930,6 +36176,125 @@ var mountDAW = (target, options = {}) => {
       overlayDuring(() => applyMidiSelection(pendingMidi, selected));
     });
   };
+  let pendingMusicXml = null;
+  const setMusicXmlNote = (text) => {
+    refs.musicXmlLoadNote.textContent = text;
+    refs.musicXmlLoadNote.classList.toggle("dtm-hidden", text === "");
+  };
+  const getSelectedMusicXmlPartIndices = () => {
+    if (!pendingMusicXml) return [];
+    const selected = [];
+    const btns = refs.musicXmlPartSelection.querySelectorAll("button");
+    btns.forEach((b, i2) => {
+      if (b.dataset.selected === "true") {
+        selected.push(pendingMusicXml.parts[i2].index);
+      }
+    });
+    return selected;
+  };
+  const updateMusicXmlAssignmentNote = () => {
+    if (!pendingMusicXml) return;
+    const selected = getSelectedMusicXmlPartIndices();
+    if (selected.length === 0) {
+      setMusicXmlNote("\u8AAD\u307F\u8FBC\u3080\u30D1\u30FC\u30C8\u3092\u9078\u629E\u3057\u3066\u304F\u3060\u3055\u3044");
+      return;
+    }
+    const applyActiveOnly = refs.applyActiveOnly?.checked ?? false;
+    const from = applyActiveOnly ? activeTrackIndexOf() : selected.length > 1 ? 0 : activeTrackIndexOf();
+    const maxCount = applyActiveOnly ? 1 : trackStates.length - from;
+    const appliedCount = Math.min(selected.length, maxCount);
+    const selectedParts = selected.map((idx) => pendingMusicXml.parts.find((p) => p.index === idx)).filter(Boolean);
+    const names = selectedParts.slice(0, appliedCount).map(
+      (p, i2) => `${trackStates[from + i2]?.config.name ?? `\u30C8\u30E9\u30C3\u30AF${from + i2 + 1}`}\u2190${p.name}`
+    ).join(" / ");
+    const dropped = selected.length - appliedCount;
+    const dropReason = applyActiveOnly ? "\u300C\u73FE\u5728\u306E\u30C8\u30E9\u30C3\u30AF\u306E\u307F\u300D\u304C\u6709\u52B9\u306A\u305F\u3081" : "\u30C8\u30E9\u30C3\u30AF\u4E0D\u8DB3\u306E\u305F\u3081";
+    setMusicXmlNote(
+      dropped > 0 ? `${names}\uFF08${dropReason}${dropped}\u30D1\u30FC\u30C8\u306F\u8AAD\u307F\u8FBC\u307F\u307E\u305B\u3093\uFF09` : names
+    );
+  };
+  const wireMusicXml = () => {
+    refs.musicXmlInfoBtn.addEventListener("click", () => {
+      showModal("MusicXML\u306E\u5165\u51FA\u529B\u89E3\u8AAC", MUSICXML_INFO_HTML);
+    });
+    refs.musicXmlInput.addEventListener("change", async () => {
+      const file = refs.musicXmlInput.files?.[0];
+      pendingMusicXml = null;
+      refs.musicXmlPartSelection.innerHTML = "";
+      if (!file) {
+        setMusicXmlNote("");
+        refs.musicXmlPartSelection.classList.add("dtm-hidden");
+        return;
+      }
+      refs.overlay.hidden = false;
+      setLoading(true);
+      try {
+        const text = await file.text();
+        pendingMusicXml = parseMusicXML(text);
+        if (pendingMusicXml.parts.length === 0) {
+          setMusicXmlNote("\u30D1\u30FC\u30C8\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093\u3067\u3057\u305F");
+          refs.musicXmlPartSelection.classList.add("dtm-hidden");
+          return;
+        }
+        refs.musicXmlPartSelection.innerHTML = `<span class="dtm-label">\u30D1\u30FC\u30C8</span>`;
+        pendingMusicXml.parts.forEach((p) => {
+          const btn = document.createElement("button");
+          btn.className = "dtm-btn dtm-btn--primary";
+          btn.dataset.selected = "true";
+          const lyricBadge = p.hasLyrics ? " \u{1F3A4}" : "";
+          btn.textContent = `${p.name} (${p.noteCount}\u97F3${lyricBadge})`;
+          btn.title = `\u5E73\u5747\u97F3\u9AD8: MIDI ${Math.round(p.avgPitch)}${p.hasLyrics ? " / \u6B4C\u8A5E\u3042\u308A" : ""}`;
+          btn.addEventListener("click", () => {
+            const on = btn.dataset.selected !== "true";
+            btn.dataset.selected = String(on);
+            btn.classList.toggle("dtm-btn--primary", on);
+            btn.classList.toggle("dtm-btn--ghost", !on);
+            updateMusicXmlAssignmentNote();
+          });
+          refs.musicXmlPartSelection.appendChild(btn);
+        });
+        refs.musicXmlPartSelection.classList.remove("dtm-hidden");
+        updateMusicXmlAssignmentNote();
+      } catch (e) {
+        setMusicXmlNote("MusicXML\u3068\u3057\u3066\u89E3\u6790\u3067\u304D\u307E\u305B\u3093\u3067\u3057\u305F");
+        refs.musicXmlPartSelection.classList.add("dtm-hidden");
+        console.error(e);
+      } finally {
+        refs.overlay.hidden = true;
+        setLoading(false);
+      }
+    });
+    refs.musicXmlLoadBtn.addEventListener("click", async () => {
+      if (!pendingMusicXml) return;
+      const selected = getSelectedMusicXmlPartIndices();
+      if (selected.length === 0) return;
+      const applyActiveOnly = refs.applyActiveOnly?.checked ?? false;
+      const from = applyActiveOnly ? activeTrackIndexOf() : selected.length > 1 ? 0 : activeTrackIndexOf();
+      const maxCount = applyActiveOnly ? 1 : trackStates.length - from;
+      if (!isAdvanced && options.onRequestAdvancedMode && !applyActiveOnly && selected.length > maxCount) {
+        const confirmed = await showConfirmModal(
+          "\u521D\u5FC3\u8005\u30E2\u30FC\u30C9\u3067\u306F\u30C8\u30E9\u30C3\u30AF\u304C\u8DB3\u308A\u305A\u3001\u4E00\u90E8\u306E\u30D1\u30FC\u30C8\u3092\u8AAD\u307F\u8FBC\u3081\u307E\u305B\u3093\u3002<br>\u4E0A\u7D1A\u8005\u30E2\u30FC\u30C9\u306B\u5207\u308A\u66FF\u3048\u307E\u3059\u304B\uFF1F"
+        );
+        if (confirmed) {
+          const xml = pendingMusicXml;
+          const sel = selected.slice();
+          options.onRequestAdvancedMode(void 0, (newDaw) => {
+            newDaw.applyMusicXmlParsed?.(xml, sel);
+          });
+          return;
+        }
+      }
+      overlayDuring(() => {
+        const { applied, dropped } = applyMusicXmlSelection(
+          pendingMusicXml,
+          selected
+        );
+        setMusicXmlNote(
+          dropped > 0 ? `${applied}\u30D1\u30FC\u30C8\u3092\u8AAD\u307F\u8FBC\u307F\u307E\u3057\u305F\uFF08${dropped}\u30D1\u30FC\u30C8\u306F\u30C8\u30E9\u30C3\u30AF\u4E0D\u8DB3\u306E\u305F\u3081\u7701\u7565\uFF09` : `${applied}\u30D1\u30FC\u30C8\u3092\u8AAD\u307F\u8FBC\u307F\u307E\u3057\u305F`
+        );
+      });
+    });
+  };
   let pendingUsts = [];
   const setUstNote = (text) => {
     refs.ustLoadNote.textContent = text;
@@ -34526,6 +36891,15 @@ var mountDAW = (target, options = {}) => {
     resizeTimer = setTimeout(() => setupCanvas(), 150);
   });
   resizeObserver.observe(refs.rollContainer);
+  const WIDE_LAYOUT_MIN_WIDTH = 1e3;
+  const applyWideLayout = (width) => {
+    refs.root.classList.toggle("dtm-daw--wide", width >= WIDE_LAYOUT_MIN_WIDTH);
+  };
+  const layoutObserver = new ResizeObserver((entries) => {
+    for (const entry of entries) applyWideLayout(entry.contentRect.width);
+  });
+  layoutObserver.observe(refs.root);
+  applyWideLayout(refs.root.getBoundingClientRect().width);
   document.addEventListener("pointermove", onPointerMove);
   document.addEventListener("pointerup", onPointerUp);
   const setLoading = (loading) => {
@@ -34627,10 +37001,14 @@ var mountDAW = (target, options = {}) => {
     applyMidiParsed: (midi, selectedIndices) => {
       overlayDuring(() => applyMidiSelection(midi, selectedIndices));
     },
+    applyMusicXmlParsed: (xml, selectedIndices) => {
+      overlayDuring(() => applyMusicXmlSelection(xml, selectedIndices));
+    },
     applyUstParsed: (ustTracks, startIndex) => {
       overlayDuring(() => applyUstTracks(ustTracks, startIndex));
     },
     exportMIDI: exportMIDI2,
+    exportMusicXML: exportMusicXML2,
     exportUST,
     setBpm,
     getLoop: () => loopEnabled,
@@ -34765,6 +37143,7 @@ var mountDAW = (target, options = {}) => {
       unsubscribeClip?.();
       stopPeakSampling();
       resizeObserver.disconnect();
+      layoutObserver.disconnect();
       document.removeEventListener("pointermove", onPointerMove);
       document.removeEventListener("pointerup", onPointerUp);
       document.removeEventListener("keydown", onKeyDown);
@@ -34817,7 +37196,7 @@ var readGlobalBool = (key) => {
 };
 
 // src/headless-singing-player.ts
-var STEPS_PER_BEAT5 = 48;
+var STEPS_PER_BEAT6 = 48;
 var STEPS_PER_BAR3 = 192;
 var TRACK_ID_BY_INDEX2 = ["melody", "submelody", "bass", "chord"];
 var playSingingMML = async (mml, options = {}) => {
@@ -34834,7 +37213,7 @@ var playSingingMML = async (mml, options = {}) => {
     parseCustomVocals(mml).map((d) => [d.key, d])
   );
   const bpm = parsedBpm ?? options.defaultBpm ?? DEFAULT_BPM;
-  const secondsPerStep = 60 / bpm / STEPS_PER_BEAT5;
+  const secondsPerStep = 60 / bpm / STEPS_PER_BEAT6;
   const drumPatternDict = {
     ...DRUM_PATTERNS,
     ...SONG_DRUM_PATTERNS,
@@ -35002,7 +37381,8 @@ var playSingingMML = async (mml, options = {}) => {
     if (lyricTracks.size > 0) {
       if (!voices) {
         voices = createSingingVoices(ctx, destination, {
-          voiceWorkerUrl: options.voiceWorkerUrl
+          voiceWorkerUrl: options.voiceWorkerUrl,
+          ttsBaseUrl: options.ttsBaseUrl
         });
       }
       if (customVocalByKey.size > 0 && voices.registerVoicebanks) {
@@ -35066,275 +37446,6 @@ var playSingingMML = async (mml, options = {}) => {
   return playback;
 };
 
-// src/musicxml-io.ts
-var STEPS_PER_BEAT6 = 48;
-var PITCH_CLASS = {
-  C: 0,
-  D: 2,
-  E: 4,
-  F: 5,
-  G: 7,
-  A: 9,
-  B: 11
-};
-var textOf = (el, tag) => el?.getElementsByTagName(tag)[0]?.textContent?.trim() ?? "";
-var numOf = (el, tag, fallback = 0) => {
-  const raw = textOf(el, tag);
-  if (!raw) return fallback;
-  const v = Number.parseFloat(raw);
-  return Number.isFinite(v) ? v : fallback;
-};
-var pitchOf = (note) => {
-  const p = note.getElementsByTagName("pitch")[0];
-  if (!p) return null;
-  const step = textOf(p, "step").toUpperCase();
-  const base = PITCH_CLASS[step];
-  if (base === void 0) return null;
-  const octave = numOf(p, "octave", 4);
-  const alter = Math.round(numOf(p, "alter", 0));
-  return (octave + 1) * 12 + base + alter;
-};
-var parseMusicXML = (xml) => {
-  const doc = new DOMParser().parseFromString(xml, "application/xml");
-  if (doc.getElementsByTagName("parserror").length > 0)
-    throw new Error("MusicXML \u3068\u3057\u3066\u8AAD\u3081\u307E\u305B\u3093");
-  const nameById = /* @__PURE__ */ new Map();
-  for (const sp of Array.from(doc.getElementsByTagName("score-part"))) {
-    const id = sp.getAttribute("id");
-    if (id) nameById.set(id, textOf(sp, "part-name") || id);
-  }
-  const placements = [];
-  const parts = [];
-  let bpm = 0;
-  const partEls = Array.from(doc.getElementsByTagName("part"));
-  partEls.forEach((partEl, partIndex) => {
-    const id = partEl.getAttribute("id") ?? "";
-    let divisions = 1;
-    let cursor = 0;
-    let measureStart = 0;
-    let lastStart = 0;
-    let lastDurSteps = 0;
-    const tied = /* @__PURE__ */ new Map();
-    let count = 0;
-    let pitchSum = 0;
-    let lyricSeen = false;
-    for (const measure of Array.from(partEl.getElementsByTagName("measure"))) {
-      measureStart += cursor;
-      cursor = 0;
-      for (const child of Array.from(measure.children)) {
-        const tag = child.tagName.toLowerCase();
-        if (tag === "attributes") {
-          const d = numOf(child, "divisions", 0);
-          if (d > 0) divisions = d;
-          continue;
-        }
-        if (tag === "direction") {
-          const sound = child.getElementsByTagName("sound")[0];
-          const t = Number.parseFloat(sound?.getAttribute("tempo") ?? "");
-          if (!bpm && Number.isFinite(t) && t > 0) bpm = t;
-          continue;
-        }
-        if (tag === "backup" || tag === "forward") {
-          const steps = numOf(child, "duration", 0) / divisions * STEPS_PER_BEAT6;
-          cursor += tag === "backup" ? -steps : steps;
-          continue;
-        }
-        if (tag !== "note") continue;
-        const durSteps = Math.round(
-          numOf(child, "duration", 0) / divisions * STEPS_PER_BEAT6
-        );
-        const isChord = child.getElementsByTagName("chord").length > 0;
-        const isRest = child.getElementsByTagName("rest").length > 0;
-        const start = isChord ? lastStart : measureStart + cursor;
-        if (!isRest) {
-          const pitch = pitchOf(child);
-          if (pitch !== null) {
-            const lyric = textOf(
-              child.getElementsByTagName("lyric")[0],
-              "text"
-            );
-            if (lyric) lyricSeen = true;
-            const ties = Array.from(child.getElementsByTagName("tie"));
-            const stops = ties.some((t) => t.getAttribute("type") === "stop");
-            const starts = ties.some((t) => t.getAttribute("type") === "start");
-            const held = tied.get(pitch);
-            if (stops && held) {
-              held.durationSteps += durSteps;
-              if (!starts) tied.delete(pitch);
-            } else {
-              const placed = {
-                partIndex,
-                startStep: Math.max(0, Math.round(start)),
-                pitch,
-                durationSteps: Math.max(1, durSteps),
-                lyric
-              };
-              placements.push(placed);
-              count++;
-              pitchSum += pitch;
-              if (starts) tied.set(pitch, placed);
-            }
-          }
-        }
-        if (!isChord) {
-          lastStart = start;
-          lastDurSteps = durSteps;
-          cursor += durSteps;
-        } else {
-          lastDurSteps = Math.max(lastDurSteps, durSteps);
-        }
-      }
-    }
-    parts.push({
-      index: partIndex,
-      name: nameById.get(id) || `Part ${partIndex + 1}`,
-      noteCount: count,
-      hasLyrics: lyricSeen,
-      avgPitch: count > 0 ? pitchSum / count : 0
-    });
-  });
-  return { parts, placements, bpm: bpm > 0 ? Math.round(bpm) : 120 };
-};
-var SHARP_SPELLING = [
-  ["C", 0],
-  ["C", 1],
-  ["D", 0],
-  ["D", 1],
-  ["E", 0],
-  ["F", 0],
-  ["F", 1],
-  ["G", 0],
-  ["G", 1],
-  ["A", 0],
-  ["A", 1],
-  ["B", 0]
-];
-var NOTE_TYPES = [
-  [STEPS_PER_BEAT6 * 4, "whole"],
-  [STEPS_PER_BEAT6 * 2, "half"],
-  [STEPS_PER_BEAT6, "quarter"],
-  [STEPS_PER_BEAT6 / 2, "eighth"],
-  [STEPS_PER_BEAT6 / 4, "16th"],
-  [STEPS_PER_BEAT6 / 8, "32nd"]
-];
-var typeOf = (steps) => {
-  for (const [len, type] of NOTE_TYPES) {
-    if (steps >= len) {
-      const dots = steps >= len * 1.5 && steps < len * 2 ? 1 : 0;
-      return { type, dots };
-    }
-  }
-  return { type: "32nd", dots: 0 };
-};
-var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
-var exportMusicXML = (options) => {
-  const { parts, bpm, stepsPerBar, title } = options;
-  const beatsPerBar = Math.max(1, Math.round(stepsPerBar / STEPS_PER_BEAT6));
-  const partList = parts.map(
-    (p, i2) => `    <score-part id="P${i2 + 1}">
-      <part-name>${esc(p.name)}</part-name>
-    </score-part>`
-  ).join("\n");
-  const body = parts.map((part, pi) => {
-    const notes = [...part.notes].sort((a, b) => a.startStep - b.startStep);
-    const end = notes.reduce(
-      (m, n) => Math.max(m, n.startStep + n.durationSteps),
-      0
-    );
-    const bars = Math.max(1, Math.ceil(end / stepsPerBar));
-    const lines = [`  <part id="P${pi + 1}">`];
-    let li = 0;
-    for (let bar = 0; bar < bars; bar++) {
-      const from = bar * stepsPerBar;
-      const to = from + stepsPerBar;
-      lines.push(`    <measure number="${bar + 1}">`);
-      if (bar === 0) {
-        lines.push(
-          `      <attributes>
-        <divisions>${STEPS_PER_BEAT6}</divisions>`,
-          `        <key><fifths>0</fifths></key>`,
-          `        <time><beats>${beatsPerBar}</beats><beat-type>4</beat-type></time>`,
-          `        <clef><sign>G</sign><line>2</line></clef>
-      </attributes>`
-        );
-        if (pi === 0)
-          lines.push(
-            `      <direction placement="above"><direction-type><metronome><beat-unit>quarter</beat-unit><per-minute>${Math.round(bpm)}</per-minute></metronome></direction-type><sound tempo="${Math.round(bpm)}"/></direction>`
-          );
-      }
-      let cursor = from;
-      const inBar = notes.filter(
-        (n) => n.startStep >= from && n.startStep < to
-      );
-      const groups = /* @__PURE__ */ new Map();
-      for (const n of inBar) {
-        const g = groups.get(n.startStep);
-        if (g) g.push(n);
-        else groups.set(n.startStep, [n]);
-      }
-      const starts = [...groups.keys()].sort((a, b) => a - b);
-      for (let gi = 0; gi < starts.length; gi++) {
-        const at = starts[gi];
-        const group = groups.get(at);
-        if (at > cursor) {
-          const { type, dots } = typeOf(at - cursor);
-          lines.push(
-            `      <note><rest/><duration>${at - cursor}</duration><type>${type}</type>${"<dot/>".repeat(dots)}</note>`
-          );
-          cursor = at;
-        }
-        const nextAt = gi + 1 < starts.length ? starts[gi + 1] : to;
-        const room = Math.min(to, nextAt) - at;
-        const dur = Math.max(
-          1,
-          Math.min(Math.max(...group.map((n) => n.durationSteps)), room)
-        );
-        group.forEach((n, ni) => {
-          const semi = Math.round(n.pitchUnits / UNITS_PER_SEMITONE);
-          const [step, alter] = SHARP_SPELLING[(semi % 12 + 12) % 12];
-          const octave = Math.floor(semi / 12) - 1;
-          const { type, dots } = typeOf(dur);
-          const lyric = part.lyrics?.[li];
-          lines.push(
-            `      <note>${ni > 0 ? "<chord/>" : ""}<pitch><step>${step}</step>${alter ? `<alter>${alter}</alter>` : ""}<octave>${octave}</octave></pitch><duration>${dur}</duration><type>${type}</type>${"<dot/>".repeat(dots)}` + (ni === 0 && lyric ? `<lyric><syllabic>single</syllabic><text>${esc(lyric)}</text></lyric>` : "") + `</note>`
-          );
-          if (ni === 0) li++;
-        });
-        cursor = at + dur;
-      }
-      if (cursor < to) {
-        const { type, dots } = typeOf(to - cursor);
-        lines.push(
-          `      <note><rest/><duration>${to - cursor}</duration><type>${type}</type>${"<dot/>".repeat(dots)}</note>`
-        );
-      }
-      lines.push("    </measure>");
-    }
-    lines.push("  </part>");
-    return lines.join("\n");
-  }).join("\n");
-  return [
-    '<?xml version="1.0" encoding="UTF-8"?>',
-    '<!DOCTYPE score-partwise PUBLIC "-//Recordare//DTD MusicXML 4.0 Partwise//EN" "http://www.musicxml.org/dtds/partwise.dtd">',
-    '<score-partwise version="4.0">',
-    `  <work><work-title>${esc(title ?? "Untitled")}</work-title></work>`,
-    // 書き出し元を残す。MML・MIDI と揃えてある（`src/version.ts` に理由）。
-    `  <identification><encoding><software>dtm ${DTM_VERSION}</software></encoding></identification>`,
-    "  <part-list>",
-    partList,
-    "  </part-list>",
-    body,
-    "</score-partwise>",
-    ""
-  ].join("\n");
-};
-var musicXmlToNotes = (placements, partIndex) => placements.filter((p) => p.partIndex === partIndex).map((p) => ({
-  startStep: p.startStep,
-  durationSteps: p.durationSteps,
-  pitchUnits: p.pitch * UNITS_PER_SEMITONE,
-  velocity: 100
-}));
-
 // src/piano-roll.ts
 var createPianoRoll = (options, handlers) => {
   const {
@@ -36269,6 +38380,7 @@ var createDtmStudio = async (options = {}) => {
     voiceWorkerUrl,
     voicebanks,
     worldlineScriptUrl: options.worldlineScriptUrl,
+    ttsBaseUrl: options.ttsBaseUrl,
     // ボーカルトラック個別のリバーブセンド（`r`トークン）先。マスタリバーブの
     // Convolver 入力へ直接センドする（PreDelayは経由しない。チャンネルストリップの
     // reverbSend とは別経路の、音節単位でより細かく制御できるセンド）。
@@ -37318,6 +39430,7 @@ export {
   DEFAULT_PLAYBACK_VELOCITY,
   DEFAULT_SECTIONS,
   DEFAULT_STEPS_PER_BAR,
+  DEFAULT_TTS_BASE_URL,
   DEFAULT_UST_LYRIC,
   DEFAULT_VELOCITY,
   DEFAULT_VOCAL_VOLUME,
@@ -37361,6 +39474,8 @@ export {
   SECTION_ORDER,
   SECTION_SPECS,
   SEQUENCER_START_DELAY,
+  SPEAK_CLOSE,
+  SPEAK_OPEN,
   STOP_MARK,
   TIE_MARK,
   TIE_MERGE_MAX_SEC,
@@ -37402,6 +39517,8 @@ export {
   createRenderer,
   createSequencer,
   createSingingVoices,
+  createSpeechPlanner,
+  createSpeechToneView,
   createSynth,
   createVoiceRegistry,
   decodeMml,
@@ -37430,6 +39547,7 @@ export {
   getComposeScaleDescription,
   getDrumPatternKeys,
   getMidiBPM,
+  getSpeechPlanner,
   hasSeenTour,
   icon,
   injectStyles,
@@ -37444,6 +39562,7 @@ export {
   looksLikePinyin,
   lyricToSyllable,
   markTourSeen,
+  medianRecordedPitchHz,
   midiNote,
   midiToUnits,
   mountChordPlayer,
@@ -37469,10 +39588,12 @@ export {
   playNote,
   playPlacements,
   playSingingMML,
+  prepareSpeechPlan,
   programOfInstrumentName,
   readGlobalBool,
   readGlobalNumber,
   readGlobalSetting,
+  readKeptSong,
   readMacroSections,
   readMacroSetting,
   resolveCenter,
@@ -37487,6 +39608,8 @@ export {
   semitonesToUnits,
   shiftNotes,
   showLoadingOverlay,
+  speechPlanDurationSec,
+  speechPlanLeadingSec,
   spelledToUnits,
   spellingToUnits,
   startTour,
@@ -37506,6 +39629,7 @@ export {
   unitsToPitchV1,
   vocalVolumeToGain,
   writeGlobalSetting,
+  writeKeptSong,
   writeMacroSections,
   writeMacroSetting
 };