@onjmin/dtm 0.1.8 → 0.1.10

package/dist/index.js

@@ -39,6 +39,7 @@ __export(index_exports, {
   LinkedList: () => LinkedList,
   MAX_VOCAL_VOLUME: () => MAX_VOCAL_VOLUME,
   MMLCore: () => MMLCore,
+  MML_END_MARKER: () => MML_END_MARKER,
   PITCH_MAP: () => PITCH_MAP,
   PREWARM_NOTES: () => PREWARM_NOTES,
   TRACKS_ADVANCED: () => TRACKS_ADVANCED,
@@ -159,18 +160,889 @@ async function buildNameToKeyMapping() {
   return nameToKey;
 }
 
-// src/chords.ts
-var C3 = 48;
-var buildChordPlacements = (options) => {
+// node_modules/.pnpm/@onjmin+chord-parser@1.0.2/node_modules/@onjmin/chord-parser/dist/index.mjs
+var SHARP_NAMES = [
+  "C",
+  "C#",
+  "D",
+  "D#",
+  "E",
+  "F",
+  "F#",
+  "G",
+  "G#",
+  "A",
+  "A#",
+  "B"
+];
+var FLAT_NAMES = [
+  "C",
+  "Db",
+  "D",
+  "Eb",
+  "E",
+  "F",
+  "Gb",
+  "G",
+  "Ab",
+  "A",
+  "Bb",
+  "B"
+];
+var toPitchClass = (n) => (n % 12 + 12) % 12;
+var noteName = (pc, flat = false) => (flat ? FLAT_NAMES : SHARP_NAMES)[toPitchClass(pc)];
+var SyntaxErrorWithPos = class extends Error {
+  constructor(input, msg) {
+    super(
+      `SyntaxError: ${msg}
+input.idx: ${input.idx}
+input.str: ${input.str}`
+    );
+    this.name = "ChordSyntaxError";
+  }
+};
+var err = (input, msg) => {
+  throw new SyntaxErrorWithPos(input, msg);
+};
+var Input = class _Input {
+  static nums = new Set("0123456789");
+  str;
+  nest;
+  idx;
+  constructor(str, nest = 0) {
+    this.str = str;
+    this.nest = nest;
+    this.idx = 0;
+  }
+  get isEOF() {
+    return this.str.length <= this.idx;
+  }
+  get char() {
+    return this.str[this.idx];
+  }
+  /** 先頭の連続する数字を消費して数値で返す（破壊的）。数字が無ければ null。 */
+  get num() {
+    let str = "";
+    while (!this.isEOF) {
+      const char = this.char;
+      if (!_Input.nums.has(char)) break;
+      str += char;
+      this.idx++;
+    }
+    return str.length ? Number(str) : null;
+  }
+  slice(i) {
+    return this.str.slice(this.idx, this.idx + i);
+  }
+};
+var Output = class {
+  pitch = null;
+  chord = null;
+  isChord = false;
+  pending = null;
+  nest = -1;
+  get value() {
+    const { pitch, chord } = this;
+    return new Set(
+      [...chord].map((v) => v + pitch)
+    );
+  }
+  set value(chord) {
+    const pitch = this.pitch;
+    this.chord = new Set([...chord].map((v) => v - pitch));
+  }
+};
+var Matcher = class {
+  map = /* @__PURE__ */ new Map();
+  /** キー長を降順で保持（最長一致のため）。 */
+  lengths = [];
+  _set(key, value) {
+    this.map.set(key, value);
+    if (!this.lengths.includes(key.length)) {
+      this.lengths.push(key.length);
+      this.lengths.sort((a, b) => b - a);
+    }
+  }
+  set(key, value) {
+    if (Array.isArray(key)) for (const k of key) this._set(k, value);
+    else this._set(key, value);
+  }
+  parse(input) {
+    for (const i of this.lengths) {
+      const s = input.slice(i);
+      if (this.map.has(s)) {
+        input.idx += s.length;
+        return this.map.get(s);
+      }
+    }
+    return null;
+  }
+};
+var BRACKET_START = 0;
+var BRACKET_END = 1;
+var COMMA = 2;
+var DIVIDE = 3;
+var formulaMatcher = new Matcher();
+formulaMatcher.set("(", BRACKET_START);
+formulaMatcher.set(")", BRACKET_END);
+formulaMatcher.set(",", COMMA);
+formulaMatcher.set(["/", "on"], DIVIDE);
+var parseFormula = (input, output = new Output(), nest = 0) => {
+  let start = input.idx;
+  const _eval = (idx) => {
+    const str = input.str.slice(start, idx);
+    if (str.length) parseTerm(new Input(str, nest), output);
+  };
+  while (true) {
+    const { idx } = input;
+    if (input.isEOF) {
+      if (nest) err(input, `Unclosed ${nest} brackets`);
+      _eval(idx);
+      return output;
+    }
+    const res = formulaMatcher.parse(input);
+    if (res === null) {
+      input.idx++;
+      continue;
+    }
+    const { pending } = output;
+    _eval(idx);
+    switch (res) {
+      case BRACKET_START:
+        parseFormula(input, output, nest + 1);
+        break;
+      case BRACKET_END:
+        if (nest - 1 < 0) err(input, "Unable to close brackets");
+        return output;
+      case COMMA:
+        output.pending = pending;
+        break;
+      case DIVIDE: {
+        const o = parseFormula(input, new Output(), nest);
+        const v = [...output.value];
+        if (o.isChord) {
+          output.value = [...o.value].concat(v);
+        } else {
+          const a = v.sort((x, y) => x - y);
+          const pitch = (o.pitch + 3) % 12 - 3;
+          if (a[0] < pitch) {
+            while (a[0] < pitch) a.push(a.shift() + 12);
+          } else {
+            while (true) {
+              const w = a[a.length - 1] - 12;
+              if (w < pitch) break;
+              a.pop();
+              a.unshift(w);
+            }
+          }
+          a.push(pitch);
+          output.value = a;
+        }
+        break;
+      }
+    }
+    start = input.idx;
+  }
+};
+var parseTerm = (input, output) => {
+  if (input.isEOF) return output;
+  if (output.pitch === null) return parsePitch(input, output);
+  if (output.pending === null) return parseFunc(input, output);
+  return parsePending(input, output);
+};
+var halfMatcher = new Matcher();
+var halfMatcherStrict = new Matcher();
+for (const m of [halfMatcher, halfMatcherStrict]) {
+  m.set(["#", "\u266F"], 1);
+  m.set(["b", "\u266D"], -1);
+}
+halfMatcher.set("+", 1);
+halfMatcher.set("-", -1);
+var parseHalf = (input, isPitch = false) => (isPitch ? halfMatcherStrict : halfMatcher).parse(input);
+var idx2pitch = [0, 2, 4, 5, 7, 9, 11];
+for (const i of [...idx2pitch.keys()]) idx2pitch.push(idx2pitch[i] + 12);
+var deg2pitch = (deg) => idx2pitch[deg - 1];
+var pitchMatcher = new Matcher();
+for (const [i, v] of [..."CDEFGAB"].entries())
+  pitchMatcher.set(v, idx2pitch[i]);
+var parsePitch = (input, output) => {
+  const pitch = pitchMatcher.parse(input);
+  if (pitch === null) err(input, "Not found pitch");
+  output.pitch = pitch;
+  const half = parseHalf(input, true);
+  if (half !== null) output.pitch += half;
+  return parseBase(input, output);
+};
+var MAJOR = [0, 4, 7];
+var DIM = [0, 3, 6];
+var baseMatcher = new Matcher();
+baseMatcher.set(["m", "min", "Min", "minor", "Minor", "-"], [0, 3, 7]);
+baseMatcher.set(["dim", "\u3007"], DIM);
+baseMatcher.set("+", [0, 4, 8]);
+baseMatcher.set(["\u03A6", "\u03C6", "\xF8"], [0, 3, 6, 10]);
+var parseBase = (input, output) => {
+  const isMajMarker = /^maj/i.test(input.str.slice(input.idx));
+  const res = isMajMarker ? null : baseMatcher.parse(input);
+  if (res !== null) output.isChord = true;
+  output.chord = new Set(res || MAJOR);
+  if (res === DIM) {
+    const { num } = input;
+    const chord = output.chord;
+    if (num !== null) chord.add(deg2pitch(num) - 2);
+  }
+  output.nest = input.nest;
+  return parseTerm(input, output);
+};
+var add = (chord, n, half) => {
+  chord.add(deg2pitch(n) + half);
+};
+var aug = (chord) => {
+  chord.delete(deg2pitch(5));
+  chord.add(deg2pitch(5) + 1);
+};
+var _7th = (chord, n, _half2, isFlat = false) => {
+  if (n === 5) chord.delete(deg2pitch(3));
+  else if (n === 6) chord.add(deg2pitch(6));
+  else if (n === 69) chord.add(deg2pitch(6)).add(deg2pitch(9));
+  else {
+    if (n >= 7) chord.add(deg2pitch(7) + (isFlat ? -1 : 0));
+    if (n >= 9) chord.add(deg2pitch(9));
+    if (n >= 11) chord.add(deg2pitch(11));
+    if (n >= 13) chord.add(deg2pitch(13));
+  }
+};
+var _half = (chord, n, half) => {
+  chord.delete(deg2pitch(n));
+  chord.add(deg2pitch(n) + half);
+};
+var funcMatcher = new Matcher();
+funcMatcher.set("add", add);
+funcMatcher.set(["omit", "no"], (chord, n, half) => {
+  chord.delete(deg2pitch(n) + half);
+});
+funcMatcher.set("sus", (chord, n, half) => {
+  chord.delete(deg2pitch(3));
+  chord.add(deg2pitch(n) + half);
+});
+funcMatcher.set(
+  ["M", "maj", "Maj", "major", "Major", "\u25B3", "\u0394"],
+  _7th
+);
+funcMatcher.set("aug", aug);
+var parseFunc = (input, output) => {
+  if (!output.isChord) output.isChord = true;
+  const func = funcMatcher.parse(input);
+  const chord = output.chord;
+  if (func === null) {
+    const isAug = input.char === "+";
+    const half = parseHalf(input);
+    const { num } = input;
+    if (num === null) {
+      if (isAug) aug(chord);
+      else err(input, "Not found number");
+    }
+    if (half === null) {
+      if (input.nest === output.nest) _7th(chord, num, 0, true);
+      else add(chord, num, 0);
+    } else {
+      _half(chord, num, half);
+    }
+  } else if (func === aug) {
+    aug(chord);
+  } else {
+    output.pending = func;
+  }
+  return parseTerm(input, output);
+};
+var parsePending = (input, output) => {
+  const half = parseHalf(input);
+  const { num } = input;
+  const { pending, chord } = output;
+  if (num === null) err(input, "Not found number");
+  pending(
+    chord,
+    num,
+    half === null ? 0 : half
+  );
+  output.pending = null;
+  return parseTerm(input, output);
+};
+var parseChord = (symbol) => {
+  const output = parseFormula(new Input(symbol));
+  const notes = [...output.value].sort((a, b) => a - b);
+  const intervals = [...output.chord].sort((a, b) => a - b);
+  const pitchClasses = [...new Set(notes.map(toPitchClass))].sort(
+    (a, b) => a - b
+  );
+  return {
+    symbol,
+    root: toPitchClass(output.pitch),
+    notes,
+    pitchClasses,
+    intervals
+  };
+};
+var QUALITY_SOURCE = [
+  "",
+  // major
+  "m",
+  // minor
+  "7",
+  // dominant 7th
+  "M7",
+  // major 7th
+  "m7",
+  // minor 7th
+  "dim",
+  // diminished triad
+  "m7b5",
+  // half-diminished
+  "aug",
+  // augmented triad
+  "6",
+  // major 6th
+  "m6",
+  // minor 6th
+  "sus4",
+  "sus2",
+  "mM7",
+  // minor major 7th
+  "dim7",
+  // diminished 7th
+  "7sus4",
+  "7#5",
+  // augmented 7th
+  "add9",
+  "madd9",
+  "9",
+  "M9",
+  "m9",
+  "69",
+  "m69",
+  "5"
+  // power chord
+];
+var QUALITIES = QUALITY_SOURCE.map(
+  (quality, priority) => ({
+    quality,
+    pitchClasses: parseChord(`C${quality}`).pitchClasses,
+    priority
+  })
+);
+var QUALITY_BY_PCSET = (() => {
+  const map = /* @__PURE__ */ new Map();
+  for (const def of QUALITIES) {
+    const key = def.pitchClasses.join(",");
+    if (!map.has(key)) map.set(key, def);
+  }
+  return map;
+})();
+var MAJOR_PROFILE = [
+  6.35,
+  2.23,
+  3.48,
+  2.33,
+  4.38,
+  4.09,
+  2.52,
+  5.19,
+  2.39,
+  3.66,
+  2.29,
+  2.88
+];
+var MINOR_PROFILE = [
+  6.33,
+  2.68,
+  3.52,
+  5.38,
+  2.6,
+  3.53,
+  2.54,
+  4.75,
+  3.98,
+  2.69,
+  3.34,
+  3.17
+];
+var mean = (a) => a.reduce((s, v) => s + v, 0) / a.length;
+var pearson = (a, b) => {
+  const ma = mean(a);
+  const mb = mean(b);
+  let num = 0;
+  let da = 0;
+  let db = 0;
+  for (let i = 0; i < a.length; i++) {
+    const x = a[i] - ma;
+    const y = b[i] - mb;
+    num += x * y;
+    da += x * x;
+    db += y * y;
+  }
+  const den = Math.sqrt(da * db);
+  return den === 0 ? 0 : num / den;
+};
+var keyName = (tonic, mode, flat) => `${noteName(tonic, flat)} ${mode}`;
+var stripScore = (c) => ({
+  tonic: c.tonic,
+  mode: c.mode,
+  name: c.name
+});
+var sameKey = (a, b) => a.tonic === b.tonic && a.mode === b.mode;
+var buildHistogram = (notes) => {
+  const h = new Array(12).fill(0);
+  for (const n of notes) {
+    if (typeof n === "number") h[toPitchClass(n)] += 1;
+    else h[toPitchClass(n.pitch)] += n.duration ?? 1;
+  }
+  return h;
+};
+var windowHistogram = (notes, start, end) => {
+  const h = new Array(12).fill(0);
+  for (const n of notes) {
+    if (n.duration <= 0) {
+      if (n.when >= start && n.when < end) h[toPitchClass(n.pitch)] += 1;
+      continue;
+    }
+    const s = Math.max(n.when, start);
+    const e = Math.min(n.when + n.duration, end);
+    const overlap = e - s;
+    if (overlap > 0) h[toPitchClass(n.pitch)] += overlap;
+  }
+  return h;
+};
+var rankKeys = (histogram, flat) => {
+  const candidates = [];
+  for (let tonic = 0; tonic < 12; tonic++) {
+    for (const mode of ["major", "minor"]) {
+      const profile = mode === "major" ? MAJOR_PROFILE : MINOR_PROFILE;
+      const rotated = histogram.map(
+        (_, pc) => profile[toPitchClass(pc - tonic)]
+      );
+      candidates.push({
+        tonic,
+        mode,
+        name: keyName(tonic, mode, flat),
+        score: pearson(histogram, rotated)
+      });
+    }
+  }
+  candidates.sort((a, b) => b.score - a.score);
+  return candidates;
+};
+var detectKey = (notes, options = {}) => {
+  if (!notes.length) return [];
+  const { flat = false } = options;
+  const histogram = buildHistogram(notes);
+  if (histogram.every((v) => v === 0)) return [];
+  return rankKeys(histogram, flat);
+};
+var coalesce = (segments) => {
+  const out = [];
+  for (const s of segments) {
+    const last = out[out.length - 1];
+    if (last && sameKey(last.key, s.key)) {
+      last.duration = s.when + s.duration - last.when;
+    } else {
+      out.push({ ...s });
+    }
+  }
+  return out;
+};
+var mergeShortSegments = (segments, min) => {
+  if (min <= 0) return segments;
+  const result = segments.map((s) => ({ ...s }));
+  let i = 0;
+  while (i < result.length && result.length > 1) {
+    if (result[i].duration >= min) {
+      i++;
+      continue;
+    }
+    if (i > 0) {
+      result[i - 1].duration += result[i].duration;
+      result.splice(i, 1);
+    } else {
+      result[i + 1].when = result[i].when;
+      result[i + 1].duration += result[i].duration;
+      result.splice(i, 1);
+    }
+  }
+  return coalesce(result);
+};
+var detectKeyChanges = (notes, options = {}) => {
+  if (!notes.length) return [];
+  const { flat = false } = options;
+  const start = notes.reduce(
+    (m, n) => Math.min(m, n.when),
+    Number.POSITIVE_INFINITY
+  );
+  const end = notes.reduce(
+    (m, n) => Math.max(m, n.when + Math.max(n.duration, 0)),
+    Number.NEGATIVE_INFINITY
+  );
+  const span = end - start;
+  if (span <= 0) {
+    const top = detectKey(
+      notes.map((n) => ({ pitch: n.pitch, duration: Math.max(n.duration, 1) })),
+      { flat }
+    )[0];
+    return top ? [{ key: stripScore(top), when: start, duration: 0 }] : [];
+  }
+  const windowSize = options.windowSize ?? span / 4;
+  const hopSize = options.hopSize ?? windowSize / 2;
+  const minSegmentDuration = options.minSegmentDuration ?? 0;
+  const switchMargin = options.switchMargin ?? 0.08;
+  const segments = [];
+  for (let t = start; t < end - 1e-9; t += hopSize) {
+    const regionEnd = Math.min(t + hopSize, end);
+    const winEnd = Math.min(t + windowSize, end);
+    const winStart = Math.max(start, winEnd - windowSize);
+    const histogram = windowHistogram(notes, winStart, winEnd);
+    const last = segments[segments.length - 1];
+    if (histogram.every((v) => v === 0)) {
+      if (last) last.duration = regionEnd - last.when;
+      continue;
+    }
+    const candidates = rankKeys(histogram, flat);
+    let chosen = candidates[0];
+    if (last) {
+      const current = candidates.find((c) => sameKey(c, last.key));
+      if (current && chosen.score - current.score <= switchMargin)
+        chosen = current;
+    }
+    if (last && sameKey(last.key, chosen)) {
+      last.duration = regionEnd - last.when;
+    } else {
+      segments.push({
+        key: stripScore(chosen),
+        when: t,
+        duration: regionEnd - t
+      });
+    }
+  }
+  return mergeShortSegments(coalesce(segments), minSegmentDuration);
+};
+var toneRoleWeight = (rel) => {
+  if (rel === 0) return 1.3;
+  if (rel === 3 || rel === 4) return 1.2;
+  if (rel === 10 || rel === 11) return 0.95;
+  if (rel === 6 || rel === 7 || rel === 8) return 0.7;
+  return 0.85;
+};
+var CHORD_TEMPLATES = (() => {
+  const templates = [];
+  for (let root = 0; root < 12; root++) {
+    for (const def of QUALITIES) {
+      const pcs = /* @__PURE__ */ new Set();
+      const weights = new Array(12).fill(0);
+      const rel = /* @__PURE__ */ new Set();
+      for (const relPc of def.pitchClasses) {
+        rel.add(relPc);
+        const pc = toPitchClass(relPc + root);
+        pcs.add(pc);
+        weights[pc] = toneRoleWeight(relPc);
+      }
+      templates.push({
+        root,
+        quality: def.quality,
+        priority: def.priority,
+        pcs,
+        weights,
+        rel
+      });
+    }
+  }
+  return templates;
+})();
+var MAJOR_SCALE = [0, 2, 4, 5, 7, 9, 11];
+var NATURAL_MINOR_SCALE = [0, 2, 3, 5, 7, 8, 10];
+var scaleOf = (key) => {
+  const base = key.mode === "major" ? MAJOR_SCALE : NATURAL_MINOR_SCALE;
+  return base.map((d) => toPitchClass(d + key.tonic));
+};
+var keyBonus = (tmpl, key) => {
+  const scale = scaleOf(key);
+  const scaleSet = new Set(scale);
+  const rootDiatonic = scaleSet.has(tmpl.root);
+  let allDiatonic = true;
+  for (const pc of tmpl.pcs)
+    if (!scaleSet.has(pc)) {
+      allDiatonic = false;
+      break;
+    }
+  let bonus = 0;
+  if (allDiatonic) bonus += 0.25;
+  else if (rootDiatonic) bonus += 0.1;
+  const degree = toPitchClass(tmpl.root - key.tonic);
+  if (degree === 0 || degree === 5 || degree === 7) bonus += 0.05;
+  return bonus;
+};
+var makeFrame = (notes, start, end) => {
+  const raw = new Array(12).fill(0);
+  let total = 0;
+  let bassPitch = Number.POSITIVE_INFINITY;
+  let bass = -1;
+  for (const n of notes) {
+    const s = Math.max(n.when, start);
+    const e = Math.min(n.when + Math.max(n.duration, 0), end);
+    const overlap = n.duration <= 0 ? n.when >= start && n.when < end ? 1 : 0 : Math.max(e - s, 0);
+    if (overlap <= 0) continue;
+    raw[toPitchClass(n.pitch)] += overlap;
+    total += overlap;
+    if (n.pitch < bassPitch) {
+      bassPitch = n.pitch;
+      bass = toPitchClass(n.pitch);
+    }
+  }
+  const profile = total > 0 ? raw.map((v) => v / total) : raw;
+  return {
+    when: start,
+    duration: end - start,
+    profile,
+    bass,
+    empty: total === 0
+  };
+};
+var emissionScore = (frame, tmpl, key, ncTonePenalty) => {
+  let hit = 0;
+  let miss = 0;
+  for (let pc = 0; pc < 12; pc++) {
+    const w = frame.profile[pc];
+    if (w === 0) continue;
+    if (tmpl.pcs.has(pc)) hit += w * tmpl.weights[pc];
+    else miss += w;
+  }
+  let score = hit - ncTonePenalty * miss;
+  if (frame.profile[tmpl.root] === 0) score -= 0.3;
+  if (frame.bass !== -1 && tmpl.root === frame.bass) score += 0.3;
+  if (key) score += keyBonus(tmpl, key);
+  score -= tmpl.priority * 2e-3;
+  return score;
+};
+var ROMAN = ["I", "II", "III", "IV", "V", "VI", "VII"];
+var chordDegree = (key, tmpl) => {
+  const scale = key.mode === "major" ? MAJOR_SCALE : NATURAL_MINOR_SCALE;
+  const rel = toPitchClass(tmpl.root - key.tonic);
+  let idx = scale.indexOf(rel);
+  let accidental = "";
+  if (idx === -1) {
+    const below = scale.indexOf(toPitchClass(rel - 1));
+    const above = scale.indexOf(toPitchClass(rel + 1));
+    if (below !== -1) {
+      idx = below;
+      accidental = "#";
+    } else if (above !== -1) {
+      idx = above;
+      accidental = "b";
+    } else {
+      idx = 0;
+      accidental = "?";
+    }
+  }
+  const hasM3 = tmpl.rel.has(4);
+  const hasm3 = tmpl.rel.has(3);
+  const hasDim5 = tmpl.rel.has(6);
+  const hasAug5 = tmpl.rel.has(8);
+  const hasMin7 = tmpl.rel.has(10);
+  let numeral = ROMAN[idx];
+  let suffix = "";
+  if (hasm3 && hasDim5) {
+    numeral = numeral.toLowerCase();
+    suffix = hasMin7 ? "\xF87" : "\xB0";
+    if (tmpl.rel.has(9)) suffix = "\xB07";
+  } else if (hasM3 && hasAug5) {
+    suffix = "+";
+  } else if (hasm3) {
+    numeral = numeral.toLowerCase();
+  } else if (!hasM3) {
+  }
+  if (!suffix) {
+    if (tmpl.rel.has(11)) suffix = "M7";
+    else if (hasMin7) suffix = "7";
+    else if (tmpl.rel.has(9) && !tmpl.rel.has(10)) suffix = "6";
+  }
+  return accidental + numeral + suffix;
+};
+var viterbi = (emissions, changePenalty) => {
+  const T = emissions.length;
+  const N = CHORD_TEMPLATES.length;
+  if (T === 0) return [];
+  const back = Array.from(
+    { length: T },
+    () => new Array(N).fill(-1)
+  );
+  let prev = emissions[0].slice();
+  for (let t = 1; t < T; t++) {
+    let bestPrevVal = Number.NEGATIVE_INFINITY;
+    let bestPrevIdx = 0;
+    for (let j = 0; j < N; j++)
+      if (prev[j] > bestPrevVal) {
+        bestPrevVal = prev[j];
+        bestPrevIdx = j;
+      }
+    const curr = new Array(N).fill(0);
+    const em = emissions[t];
+    const switchVal = bestPrevVal - changePenalty;
+    for (let i = 0; i < N; i++) {
+      if (prev[i] >= switchVal) {
+        curr[i] = em[i] + prev[i];
+        back[t][i] = i;
+      } else {
+        curr[i] = em[i] + switchVal;
+        back[t][i] = bestPrevIdx;
+      }
+    }
+    prev = curr;
+  }
+  let bestIdx = 0;
+  for (let i = 1; i < N; i++) if (prev[i] > prev[bestIdx]) bestIdx = i;
+  const path = new Array(T).fill(0);
+  path[T - 1] = bestIdx;
+  for (let t = T - 1; t > 0; t--) path[t - 1] = back[t][path[t]];
+  return path;
+};
+var keyAt = (keys, when) => {
+  for (const k of keys)
+    if (when >= k.when && when < k.when + k.duration) return k.key;
+  return keys.length ? keys[keys.length - 1].key : null;
+};
+var buildSymbol = (tmpl, bass, flat) => {
+  const rootSymbol = noteName(tmpl.root, flat) + tmpl.quality;
+  const inversion = bass !== -1 && bass !== tmpl.root && tmpl.pcs.has(bass);
+  return {
+    symbol: inversion ? `${rootSymbol}/${noteName(bass, flat)}` : rootSymbol,
+    rootSymbol,
+    inversion,
+    bass: bass === -1 ? tmpl.root : bass
+  };
+};
+var detectProgression = (notes, options = {}) => {
+  if (!notes.length) return { keys: [], chords: [] };
   const {
-    chordStr,
-    patternType,
-    rootShift,
+    flat = false,
     bpm,
-    stepsPerBar,
-    parseChord,
-    parseChords
+    frameSize = 0.5,
+    changePenalty = 0.4,
+    nonChordTonePenalty = 0.55,
+    useKey = true
   } = options;
+  const keys = detectKeyChanges(notes, options);
+  const start = notes.reduce(
+    (m, n) => Math.min(m, n.when),
+    Number.POSITIVE_INFINITY
+  );
+  const end = notes.reduce(
+    (m, n) => Math.max(m, n.when + Math.max(n.duration, 0)),
+    Number.NEGATIVE_INFINITY
+  );
+  if (end <= start) return { keys, chords: [] };
+  const frameDur = bpm ? 60 / bpm : Math.max(frameSize, 1e-3);
+  const frames = [];
+  for (let t = start; t < end - 1e-9; t += frameDur)
+    frames.push(makeFrame(notes, t, Math.min(t + frameDur, end)));
+  const emissions = frames.map((frame) => {
+    if (frame.empty) return new Array(CHORD_TEMPLATES.length).fill(0);
+    const key = useKey ? keyAt(keys, frame.when + frame.duration / 2) : null;
+    return CHORD_TEMPLATES.map(
+      (tmpl) => emissionScore(frame, tmpl, key, nonChordTonePenalty)
+    );
+  });
+  const path = viterbi(emissions, changePenalty);
+  const chords = [];
+  for (let t = 0; t < frames.length; t++) {
+    const frame = frames[t];
+    const tmpl = CHORD_TEMPLATES[path[t]];
+    const last = chords[chords.length - 1];
+    const sameAsLast = last && last.root === tmpl.root && last.quality === tmpl.quality;
+    if (sameAsLast) {
+      last.duration = frame.when + frame.duration - last.when;
+      continue;
+    }
+    const key = keyAt(keys, frame.when + frame.duration / 2);
+    const { symbol, rootSymbol, inversion, bass } = buildSymbol(
+      tmpl,
+      frame.bass,
+      flat
+    );
+    chords.push({
+      symbol,
+      rootSymbol,
+      root: tmpl.root,
+      quality: tmpl.quality,
+      bass,
+      inversion,
+      when: frame.when,
+      duration: frame.duration,
+      key,
+      degree: key ? chordDegree(key, tmpl) : null
+    });
+  }
+  return { keys, chords };
+};
+var toHan = (str) => str.replace(/[！-～]/g, (ch) => String.fromCharCode(ch.charCodeAt(0) - 65248)).replace(/　/g, " ");
+var parseChords = (str, bpm = 120) => {
+  const output = [];
+  const secBar = 60 / bpm * 4;
+  const frontChars = new Set("ABCDEFG_=%N");
+  let idx = 0;
+  let last = null;
+  for (const line of toHan(str).split("\n").map((v) => v.trim())) {
+    if (!line.length || /^#/.test(line)) continue;
+    for (const str2 of line.split(/[|lｌ→]/)) {
+      if (!str2.length) continue;
+      const when = idx++ * secBar;
+      const a = [];
+      for (let i = 0; i < str2.length; i++) {
+        const char = str2[i];
+        const prev = str2[i - 1];
+        const prev2 = str2.slice(i - 2, i);
+        if (!frontChars.has(char)) continue;
+        if (prev === "/" || prev2 === "on") continue;
+        if (prev2 === "N." && char === "C") continue;
+        a.push(i);
+      }
+      if (!a.length) continue;
+      const divide = 2 ** Math.ceil(Math.log2(a.length));
+      const unitTime = secBar / divide;
+      for (const [i, v] of a.entries()) {
+        const s = str2.slice(v, i === a.length - 1 ? str2.length : a[i + 1]).replace(/\s+/g, "");
+        const c = s[0];
+        if (c === "_" || c === "N") {
+          last = null;
+          continue;
+        }
+        if (c === "=") {
+          if (last) last.duration += unitTime;
+          continue;
+        }
+        const _when = when + i * unitTime;
+        if (c === "%") {
+          if (last === null) continue;
+          const base = last;
+          last = { ...base, when: _when, duration: unitTime };
+        } else {
+          const key = s.slice(0, s[1] === "#" ? 2 : 1);
+          const chord = s.slice(key.length).replace(/[\s・]/g, "");
+          last = {
+            key,
+            chord,
+            when: _when,
+            duration: unitTime
+          };
+        }
+        output.push(last);
+      }
+      if (last !== null && divide > a.length)
+        last.duration += unitTime * (divide - a.length);
+    }
+  }
+  return output;
+};
+
+// src/chords.ts
+var C3 = 48;
+var buildChordPlacements = (options) => {
+  const { chordStr, patternType, rootShift, bpm, stepsPerBar } = options;
   const placements = [];
   if (!chordStr.trim()) return placements;
   const offset = rootShift;
@@ -200,7 +1072,7 @@ var buildChordPlacements = (options) => {
       for (const chord of group) {
         let notes;
         try {
-          notes = [...parseChord(`${chord.key}${chord.chord}`).value];
+          notes = [...parseChord(`${chord.key}${chord.chord}`).notes];
         } catch {
           continue;
         }
@@ -287,7 +1159,7 @@ var buildChordPlacements = (options) => {
     chordNames.forEach((chordName, barIndex) => {
       let notes;
       try {
-        notes = [...parseChord(chordName).value];
+        notes = [...parseChord(chordName).notes];
       } catch {
         return;
       }
@@ -361,6 +1233,7 @@ var buildUI = (target, options) => {
     <button class="dtm-play" data-dtm="play" disabled>${icon("play")}<span>\u8A66\u8074</span></button>
     <button class="dtm-iconbtn dtm-rec" data-dtm="rec" title="\u9332\u97F3">${icon("record")}</button>
     <label class="dtm-toggle"><input type="checkbox" data-dtm="solo"><span>\u30BD\u30ED</span></label>
+    <span class="dtm-topbar-loading dtm-blink" data-dtm="topbar-loading">... LOADING ...</span>
     <span class="dtm-grow"></span>
     <span class="dtm-label">BPM</span>
     <input type="number" class="dtm-input dtm-input--num" data-dtm="bpm" value="${defaultBpm}" min="20" max="300">
@@ -453,10 +1326,10 @@ var buildUI = (target, options) => {
       <div class="dtm-row dtm-hidden" data-dtm="midi-track-selection"></div>
       <div class="dtm-row">
         <span class="dtm-label">MML</span>
-        <textarea class="dtm-textarea" data-dtm="mml-input" placeholder="MML\u3092\u5165\u529B"></textarea>
+        <textarea class="dtm-textarea dtm-grow" data-dtm="mml-input" placeholder="MML\u3092\u5165\u529B"></textarea>
+        <button class="dtm-btn dtm-btn--primary" data-dtm="mml-load">\u8AAD\u8FBC</button>
       </div>
       <div class="dtm-row">
-        <button class="dtm-btn dtm-btn--primary" data-dtm="mml-load">MML\u8AAD\u8FBC</button>
         <span class="dtm-label">\u5168\u4F53\u30B7\u30D5\u30C8</span>
         <select class="dtm-select" data-dtm="shift-select">
           <option value="-96">-2\u5206</option>
@@ -530,6 +1403,8 @@ var buildUI = (target, options) => {
   const sel = (name) => q(root, `[data-dtm="${name}"]`);
   return {
     root,
+    topbar: sel("transport"),
+    topbarLoading: sel("topbar-loading"),
     playBtn: sel("play"),
     recBtn: sel("rec"),
     soloCheckbox: sel("solo"),
@@ -1019,6 +1894,7 @@ var DEFAULT_PAN = 64;
 var DEFAULT_VELOCITY = 100;
 var DEFAULT_PLAYBACK_VELOCITY = 127;
 var DEFAULT_STEPS_PER_BAR = 192;
+var MML_END_MARKER = "#end;";
 
 // src/lyrics.ts
 var kanaTable = {
@@ -1747,8 +2623,8 @@ var createSingingVoices = (ctx, destination, options = {}) => {
     ))().then((v) => {
       loaded.set(m, v);
       return v;
-    }).catch((err) => {
-      console.warn(`[dtm] koe\u97F3\u6E90 "${m}" \u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F`, err);
+    }).catch((err2) => {
+      console.warn(`[dtm] koe\u97F3\u6E90 "${m}" \u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F`, err2);
       return null;
     });
     loading.set(m, p);
@@ -3151,7 +4027,9 @@ var parseMML = (mml, options = {}) => {
   const meta = parseMmlMeta(noComments);
   const noMeta = stripMmlMeta(noComments);
   const lyrics = collectLyrics ? parseLyrics(noMeta) : void 0;
-  const fullMML = stripLyrics(noMeta).replace(/[\n\r]+/g, " ").trim();
+  const endMarkerBase = MML_END_MARKER.replace(/;+$/, "");
+  const endRegex = new RegExp(`(?<![cdafgCDAFG])${endMarkerBase}\\b;?`, "gi");
+  const fullMML = stripLyrics(noMeta).replace(endRegex, "").replace(/[\n\r]+/g, " ").trim();
   const parts = fullMML.split(/(@\d+)/).filter((p) => p.trim().length > 0);
   let trackIndex = 0;
   let octave = 4;
@@ -3240,8 +4118,10 @@ var parseMML = (mml, options = {}) => {
           numStr += body[j];
           j++;
         }
-        if (ch === "t" && trackIndex === 0 && numStr) {
-          bpm = clamp2(Number.parseInt(numStr, 10), 1, 255);
+        if (ch === "t" && numStr) {
+          if (bpm === null) {
+            bpm = clamp2(Number.parseInt(numStr, 10), 1, 255);
+          }
         }
         pushTok("ctrl", currentStep, 0, tokStart);
       } else if (ch === "[") {
@@ -3743,6 +4623,7 @@ var DAW_CSS = `
 }
 .dtm-input--num { width: 64px; text-align: center; font-size: 16px; }
 .dtm-textarea { width: 100%; min-height: 56px; resize: vertical; line-height: 1.7; }
+.dtm-textarea.dtm-grow { width: 0; }
 .dtm-range { height: var(--dtm-tap); accent-color: var(--dtm-primary); }
 
 /* \u2500\u2500\u2500 \u30C8\u30E9\u30C3\u30AF\u30D4\u30EB\uFF08\u30AD\u30E3\u30E9\u30AF\u30BF\u30FC\u9078\u629E\u30DC\u30BF\u30F3\uFF09 \u2500\u2500\u2500 */
@@ -3910,7 +4791,7 @@ var DAW_CSS = `
 
 /* \u2500\u2500\u2500 \u30ED\u30FC\u30C7\u30A3\u30F3\u30B0\u30AA\u30FC\u30D0\u30FC\u30EC\u30A4 \u2500\u2500\u2500 */
 .dtm-overlay {
-  position: absolute; inset: 0; z-index: 1000;
+  position: absolute; inset: 0; z-index: 10;
   background: rgba(0,0,0,.92);
   display: flex; align-items: center; justify-content: center;
   flex-direction: column; gap: 14px;
@@ -3959,6 +4840,22 @@ var DAW_CSS = `
   letter-spacing: .15em;
   min-height: 1em;
 }
+.dtm-topbar-loading {
+  display: none;
+  font-family: var(--dtm-font);
+  font-size: 11px;
+  color: var(--dtm-primary);
+  margin-left: 12px;
+  letter-spacing: .15em;
+  align-self: center;
+}
+.dtm-topbar.is-loading .dtm-topbar-loading {
+  display: inline-block;
+}
+.dtm-topbar.is-loading {
+  pointer-events: none;
+  opacity: 0.7;
+}
 
 @keyframes dtm-blink { 0%,100%{opacity:1} 50%{opacity:0} }
 .dtm-blink { animation: dtm-blink 1s steps(1) infinite; }
@@ -4034,6 +4931,14 @@ var DAW_CSS = `
   min-width: 2em;
   margin-left: 4px;
 }
+.dtm-player-chord {
+  font-family: 'k8x12', monospace;
+  font-size: 11px;
+  color: var(--dtm-accent);
+  min-width: 4em;
+  margin-left: 8px;
+  font-weight: bold;
+}
 .dtm-player-dots {
   margin-left: auto;
   display: flex;
@@ -4384,7 +5289,7 @@ var mountDAW = (target, options = {}) => {
   const trackConfigs = options.tracks ?? DEFAULT_TRACKS;
   const drumPatterns = options.drumPatterns ?? DRUM_PATTERNS;
   const showMidi = !!options.parseMidi;
-  const showChord = !!(options.parseChord && options.parseChords);
+  const showChord = true;
   const refs = buildUI(target, {
     tracks: trackConfigs,
     drumPatternNames: Object.keys(drumPatterns),
@@ -5080,13 +5985,15 @@ var mountDAW = (target, options = {}) => {
     const streaming = !!voices && streamTracks.some((t) => t.notes.length > 0);
     if (streaming && voices) {
       const overlay = showLoadingOverlay(refs.rollContainer);
+      setLoading(true);
       try {
         await voices.loadModels(streamTracks.map((t) => t.model));
         await voices.warm(streamTracks);
-      } catch (err) {
-        console.warn("[dtm] voice preload failed", err);
+      } catch (err2) {
+        console.warn("[dtm] voice preload failed", err2);
       } finally {
         overlay.remove();
+        setLoading(false);
       }
     }
     if (playbackState !== "paused") {
@@ -5425,8 +6332,8 @@ var mountDAW = (target, options = {}) => {
       const decomposedMini = monoTracks.map(
         (notes, i) => `@${i}${refCore.getMMLFromNotes(notes, bpm, 100).trim().replace(/\s+/g, "")}`
       );
-      const full2 = [metaLine, ...decomposedFull].filter((s) => s.length > 0).join(";\n");
-      const minified2 = [metaLine, ...decomposedMini].filter((s) => s.length > 0).join(";");
+      const full2 = [metaLine, ...decomposedFull, MML_END_MARKER].filter((s) => s.length > 0).join(";\n");
+      const minified2 = [metaLine, ...decomposedMini, MML_END_MARKER].filter((s) => s.length > 0).join(";");
       return {
         full: full2,
         minified: minified2,
@@ -5435,21 +6342,28 @@ var mountDAW = (target, options = {}) => {
         barLimit: barLimitBars
       };
     }
-    const trackLines = trackStates.map(
-      (t, i) => `@${i} ${t.core.getMMLFromNotes(clipNotes(t.core.getNotes()), bpm, t.volume).trim()}`
-    );
-    const trackLinesMini = trackStates.map(
-      (t, i) => `@${i}${t.core.getMMLFromNotes(clipNotes(t.core.getNotes()), bpm, t.volume).trim().replace(/\s+/g, "")}`
-    );
+    const trackLines = [];
+    const trackLinesMini = [];
+    trackStates.forEach((t, i) => {
+      const notes = clipNotes(t.core.getNotes());
+      if (notes.length > 0) {
+        const mml = t.core.getMMLFromNotes(notes, bpm, t.volume).trim();
+        trackLines.push(`@${i} ${mml}`);
+        trackLinesMini.push(`@${i}${mml.replace(/\s+/g, "")}`);
+      }
+    });
     const lyricLines = trackStates.map((t, i) => ({
       i,
-      text: t.lyrics.trim(),
+      notes: clipNotes(t.core.getNotes()),
+      text: t.lyrics.replace(/[\r\n]+/g, " ").trim(),
       model: t.lyricModel.trim(),
       vol: t.vocalVolume,
       gate: t.vocalGate,
       pan: t.vocalPan,
       oct: t.vocalOctave
-    })).filter((x) => x.model.length > 0 && x.text.length > 0).map((x) => {
+    })).filter(
+      (x) => x.model.length > 0 && x.text.length > 0 && x.notes.length > 0
+    ).map((x) => {
       const params = [
         x.vol === DEFAULT_VOCAL_VOLUME ? "" : `v${x.vol}`,
         x.gate === 100 ? "" : `q${x.gate}`,
@@ -5459,13 +6373,18 @@ var mountDAW = (target, options = {}) => {
       const head = params ? `${x.model} ${params}` : x.model;
       return `@@${x.i} ${head} ${x.text}`;
     });
-    const full = [metaLine, ...trackLines, ...lyricLines].filter((s) => s.length > 0).join(";\n");
-    const minified = [metaLine, ...trackLinesMini, ...lyricLines].filter((s) => s.length > 0).join(";");
+    const full = [metaLine, ...trackLines, ...lyricLines, MML_END_MARKER].filter((s) => s.length > 0).join(";\n");
+    const minified = [
+      metaLine,
+      ...trackLinesMini,
+      ...lyricLines,
+      MML_END_MARKER
+    ].filter((s) => s.length > 0).join(";");
     return {
       full,
       minified,
       ignoredCount: 0,
-      trackCount: trackStates.length,
+      trackCount: trackLines.length,
       barLimit: barLimitBars
     };
   };
@@ -5585,7 +6504,6 @@ var mountDAW = (target, options = {}) => {
     updateUndoRedo();
   };
   const applyChord = () => {
-    if (!options.parseChord || !options.parseChords) return;
     const active = getActive();
     const chordTrack = trackStates.find((t) => t.config.id === "chord");
     if (!chordTrack) return;
@@ -5594,9 +6512,7 @@ var mountDAW = (target, options = {}) => {
       patternType: active.savedChordPattern,
       rootShift: active.savedChordRoot,
       bpm,
-      stepsPerBar: renderConfig.stepsPerBar,
-      parseChord: options.parseChord,
-      parseChords: options.parseChords
+      stepsPerBar: renderConfig.stepsPerBar
     });
     chordTrack.core.clearNotesWithoutHistory();
     chordTrack.core.beginBatch();
@@ -5681,9 +6597,11 @@ var mountDAW = (target, options = {}) => {
   };
   const overlayDuring = (fn) => {
     refs.overlay.hidden = false;
+    setLoading(true);
     setTimeout(() => {
       fn();
       refs.overlay.hidden = true;
+      setLoading(false);
     }, 30);
   };
   const wireEvents = () => {
@@ -5827,6 +6745,7 @@ var mountDAW = (target, options = {}) => {
       const file = refs.midiInput.files?.[0];
       if (!file || !options.parseMidi) return;
       refs.overlay.hidden = false;
+      setLoading(true);
       const buffer = new Uint8Array(await file.arrayBuffer());
       pendingMidi = options.parseMidi(buffer);
       detectedTracks = analyzeMidiTracks(pendingMidi);
@@ -5847,6 +6766,7 @@ var mountDAW = (target, options = {}) => {
       });
       refs.midiTrackSelection.classList.remove("dtm-hidden");
       refs.overlay.hidden = true;
+      setLoading(false);
     });
     refs.midiLoadBtn.addEventListener("click", () => {
       if (!pendingMidi) return;
@@ -5920,6 +6840,9 @@ var mountDAW = (target, options = {}) => {
   resizeObserver.observe(refs.rollContainer);
   document.addEventListener("pointermove", onPointerMove);
   document.addEventListener("pointerup", onPointerUp);
+  const setLoading = (loading) => {
+    refs.topbar.classList.toggle("is-loading", loading);
+  };
   return {
     play,
     pause,
@@ -5957,6 +6880,7 @@ var mountDAW = (target, options = {}) => {
     exportMIDI: exportMIDI2,
     setBpm,
     getPlaybackState: () => playbackState,
+    setLoading,
     destroy: () => {
       sequencer.stop();
       resizeObserver.disconnect();
@@ -6101,6 +7025,36 @@ var mountMmlPlayer = (target, mml, options = {}) => {
   const trackIndices = [...new Set(placements.map((p) => p.trackIndex))].sort(
     (a, b) => a - b
   );
+  const maxStep = placements.reduce(
+    (max, p) => Math.max(max, p.startStep + p.durationSteps),
+    0
+  );
+  const timedNotes = placements.map((p) => ({
+    pitch: p.pitch,
+    when: p.startStep * secondsPerStep,
+    duration: p.durationSteps * secondsPerStep
+  }));
+  const stepChords = [];
+  if (timedNotes.length > 0) {
+    let chordSegments = [];
+    try {
+      chordSegments = detectProgression(timedNotes, { bpm }).chords;
+    } catch {
+      chordSegments = [];
+    }
+    for (const seg of chordSegments) {
+      const startStep = Math.max(0, Math.round(seg.when / secondsPerStep));
+      const endStep = Math.round((seg.when + seg.duration) / secondsPerStep);
+      for (let s = startStep; s < endStep && s <= maxStep; s++) {
+        stepChords[s] = seg.symbol;
+      }
+    }
+    let lastChord = "";
+    for (let s = 0; s <= maxStep; s++) {
+      if (stepChords[s]) lastChord = stepChords[s];
+      else stepChords[s] = lastChord;
+    }
+  }
   const seqTracks = trackIndices.map((index) => {
     let id = 0;
     const notes = placements.filter((p) => p.trackIndex === index).map((p) => ({
@@ -6301,6 +7255,10 @@ var mountMmlPlayer = (target, mml, options = {}) => {
   barEl.className = "dtm-player-bar";
   barEl.textContent = "-";
   beatRow.appendChild(barEl);
+  const chordEl = doc.createElement("span");
+  chordEl.className = "dtm-player-chord";
+  chordEl.textContent = "";
+  beatRow.appendChild(chordEl);
   const chips = [];
   const makeChip = (label) => {
     const chip = doc.createElement("span");
@@ -6444,10 +7402,20 @@ var mountMmlPlayer = (target, mml, options = {}) => {
     lane.scrollLeft = Math.max(0, Math.min(next, maxScroll));
   };
   const renderPlayhead = (step) => {
+    const intStep = Math.floor(step);
     const beatIndex = Math.floor(step / STEPS_PER_BEAT3) % 4;
     for (let i = 0; i < 4; i++)
       beatDots[i].classList.toggle("dtm-player-beat-dot--on", i === beatIndex);
     barEl.textContent = String(Math.floor(step / STEPS_PER_BAR) + 1);
+    const chordName = stepChords[intStep] ?? "";
+    if (chordEl.textContent !== chordName) {
+      chordEl.textContent = chordName;
+      if (chordName) {
+        console.log(
+          `[dtm-player-chord] Active Chord: ${chordName} (step: ${intStep})`
+        );
+      }
+    }
     for (const view of laneViews) {
       let active = null;
       for (const t of view.tokens) {
@@ -6461,6 +7429,7 @@ var mountMmlPlayer = (target, mml, options = {}) => {
   const resetPlayhead = () => {
     for (const d of beatDots) d.classList.remove("dtm-player-beat-dot--on");
     barEl.textContent = "-";
+    chordEl.textContent = "";
     for (const view of laneViews) {
       for (const t of view.tokens) t.el.classList.remove("is-active");
       view.lane.scrollLeft = 0;
@@ -6524,6 +7493,7 @@ var mountMmlPlayer = (target, mml, options = {}) => {
       });
     }
     return {
+      id: String(index),
       model: lt.model,
       volume: vocalVolumeToGain(lt.volume ?? DEFAULT_VOCAL_VOLUME) * (trackVolume / 100),
       pan: panToStereo(lt.pan ?? DEFAULT_PAN),
@@ -6539,15 +7509,19 @@ var mountMmlPlayer = (target, mml, options = {}) => {
       try {
         await v.loadModels(tracks.map((t) => t.model));
         await v.warm(tracks);
-      } catch (err) {
-        console.warn("[dtm] voice preload failed", err);
+      } catch (err2) {
+        console.warn("[dtm] voice preload failed", err2);
       } finally {
         overlay.remove();
       }
       if (!playing || activePlayer !== instance) return;
     }
     seq.start(0);
-    if (streaming) ensureVoices().startStream(tracks, seq.getStartTime());
+    if (streaming) {
+      ensureVoices().startStream(tracks, seq.getStartTime(), {
+        isAudible: (t) => !mutedTracks.has(Number(t.id))
+      });
+    }
   };
   const play = () => {
     if (playing || trackIndices.length === 0) return;
@@ -6882,8 +7856,6 @@ var DEFAULT_CDN = {
   soundFont: "https://rpgen3.github.io/soundfont/mjs/surikov/SoundFont.mjs",
   soundFontDrum: "https://rpgen3.github.io/soundfont/mjs/surikov/SoundFont_drum.mjs",
   soundFontList: "https://rpgen3.github.io/soundfont/mjs/surikov/SoundFont_list.mjs",
-  parseChord: "https://rpgen3.github.io/piano/mjs/parseChord.mjs",
-  parseChords: "https://rpgen3.github.io/piano/mjs/parseChords.mjs",
   midiParser: "https://cdn.jsdelivr.net/npm/midi-parser-js@4.0.4/+esm"
 };
 var SOUNDFONT_NAME = "FluidR3_GM_sf2_file";
@@ -6927,24 +7899,6 @@ var createDtmStudio = async (options = {}) => {
     eng.SoundFont_drum ?? importFrom(cdn.soundFontDrum, "SoundFont_drum"),
     eng.SoundFont_list ?? importFrom(cdn.soundFontList, "SoundFont_list")
   ]);
-  let parseChord = eng.parseChord;
-  let parseChords = eng.parseChords;
-  if (features.chord && (!parseChord || !parseChords)) {
-    try {
-      [parseChord, parseChords] = await Promise.all([
-        parseChord ?? importFrom(
-          cdn.parseChord,
-          "parseChord"
-        ),
-        parseChords ?? importFrom(
-          cdn.parseChords,
-          "parseChords"
-        )
-      ]);
-    } catch (e) {
-      console.warn("[dtm] \u30B3\u30FC\u30C9\u89E3\u6790\u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557\u3057\u307E\u3057\u305F", e);
-    }
-  }
   let midiParser = null;
   let parseMidi;
   if (features.midi) {
@@ -7130,8 +8084,6 @@ var createDtmStudio = async (options = {}) => {
       onPlayNote: playNote,
       onPlayDrum: playDrum,
       singingVoices,
-      parseChord,
-      parseChords,
       parseMidi,
       onToggleRecord,
       ...dawOverrides
@@ -7153,15 +8105,32 @@ var createDtmStudio = async (options = {}) => {
       editorPresetSelects.set(target, select);
       select.addEventListener("change", async () => {
         if (!select) return;
-        daw.setInstrument(select.value);
-        await loadPreset(select.value, trackIds);
+        const wasPlaying = daw.getPlaybackState() === "playing";
+        if (wasPlaying) {
+          daw.pause();
+        }
+        const overlay = showLoadingOverlay(target);
+        daw.setLoading?.(true);
+        try {
+          daw.setInstrument(select.value);
+          await loadPreset(select.value, trackIds);
+        } finally {
+          overlay.remove();
+          daw.setLoading?.(false);
+          if (wasPlaying) {
+            daw.play();
+          }
+        }
       });
     }
     const daw = mountDAW(target, base);
     mountedEditors.push(daw);
     const presetKey = preset && INSTRUMENT_PRESETS[preset] ? preset : defaultPreset;
     daw.setInstrument(presetKey);
-    void loadPreset(presetKey, trackIds);
+    daw.setLoading?.(true);
+    void loadPreset(presetKey, trackIds).finally(() => {
+      daw.setLoading?.(false);
+    });
     const destroy = () => {
       daw.destroy();
       select?.remove();
@@ -7230,6 +8199,7 @@ var createDtmStudio = async (options = {}) => {
   LinkedList,
   MAX_VOCAL_VOLUME,
   MMLCore,
+  MML_END_MARKER,
   PITCH_MAP,
   PREWARM_NOTES,
   TRACKS_ADVANCED,