@onjmin/dtm 0.1.8 → 0.1.9

package/dist/index.js

@@ -159,18 +159,534 @@ async function buildNameToKeyMapping() {
   return nameToKey;
 }
 
+// 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 detectChord = (notes, options = {}) => {
+  if (!notes.length) return [];
+  const { flat = false } = options;
+  const pcs = [...new Set(notes.map(toPitchClass))].sort((a, b) => a - b);
+  const bass = toPitchClass(
+    options.bass ?? notes.reduce((m, v) => Math.min(m, v), notes[0])
+  );
+  const scored = [];
+  for (const root of pcs) {
+    const relSet = new Set(pcs.map((pc) => toPitchClass(pc - root)));
+    for (const def of QUALITY_BY_PCSET.values()) {
+      let matchCount = 0;
+      let hasRoot = false;
+      for (const pc of def.pitchClasses) {
+        if (relSet.has(pc)) {
+          matchCount++;
+          if (pc === 0) hasRoot = true;
+        }
+      }
+      if (!hasRoot) continue;
+      if (matchCount < Math.min(2, def.pitchClasses.length)) continue;
+      const missingCount = def.pitchClasses.length - matchCount;
+      let extraCount = 0;
+      const defSet = new Set(def.pitchClasses);
+      for (const pc of relSet) {
+        if (!defSet.has(pc)) {
+          extraCount++;
+        }
+      }
+      const score = matchCount * 2 - missingCount * 1 - extraCount * 0.5;
+      const rootSymbol = noteName(root, flat) + def.quality;
+      const inversion = root !== bass;
+      scored.push({
+        score,
+        priority: def.priority,
+        candidate: {
+          symbol: inversion ? `${rootSymbol}/${noteName(bass, flat)}` : rootSymbol,
+          rootSymbol,
+          root,
+          quality: def.quality,
+          bass,
+          inversion
+        }
+      });
+    }
+  }
+  scored.sort((a, b) => {
+    if (Math.abs(a.score - b.score) > 1e-3) return b.score - a.score;
+    if (a.candidate.inversion !== b.candidate.inversion)
+      return a.candidate.inversion ? 1 : -1;
+    if (a.priority !== b.priority) return a.priority - b.priority;
+    return a.candidate.root - b.candidate.root;
+  });
+  return scored.map((s) => s.candidate);
+};
+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 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,
-    parseChord,
-    parseChords
-  } = options;
+  const { chordStr, patternType, rootShift, bpm, stepsPerBar } = options;
   const placements = [];
   if (!chordStr.trim()) return placements;
   const offset = rootShift;
@@ -200,7 +716,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 +803,7 @@ var buildChordPlacements = (options) => {
     chordNames.forEach((chordName, barIndex) => {
       let notes;
       try {
-        notes = [...parseChord(chordName).value];
+        notes = [...parseChord(chordName).notes];
       } catch {
         return;
       }
@@ -361,6 +877,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 +970,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 +1047,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"),
@@ -1747,8 +2266,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);
@@ -3240,8 +3759,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 +4264,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 +4432,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 +4481,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 +4572,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 +4930,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 +5626,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") {
@@ -5435,21 +5983,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}`,
@@ -5465,7 +6020,7 @@ var mountDAW = (target, options = {}) => {
       full,
       minified,
       ignoredCount: 0,
-      trackCount: trackStates.length,
+      trackCount: trackLines.length,
       barLimit: barLimitBars
     };
   };
@@ -5585,7 +6140,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 +6148,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 +6233,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 +6381,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 +6402,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 +6476,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 +6516,7 @@ var mountDAW = (target, options = {}) => {
     exportMIDI: exportMIDI2,
     setBpm,
     getPlaybackState: () => playbackState,
+    setLoading,
     destroy: () => {
       sequencer.stop();
       resizeObserver.disconnect();
@@ -6101,6 +6661,117 @@ var mountMmlPlayer = (target, mml, options = {}) => {
   const trackIndices = [...new Set(placements.map((p) => p.trackIndex))].sort(
     (a, b) => a - b
   );
+  const trackStats = trackIndices.map((index) => {
+    const trackPlacements = placements.filter((p) => p.trackIndex === index);
+    if (trackPlacements.length === 0) {
+      return { index, isChords: false, avgPitch: 0, noteCount: 0 };
+    }
+    const sumPitch = trackPlacements.reduce((sum, p) => sum + p.pitch, 0);
+    const avgPitch = sumPitch / trackPlacements.length;
+    const stepCounts = /* @__PURE__ */ new Map();
+    for (const p of trackPlacements) {
+      for (let s = p.startStep; s < p.startStep + p.durationSteps; s++) {
+        stepCounts.set(s, (stepCounts.get(s) ?? 0) + 1);
+      }
+    }
+    const polyphonicSteps = Array.from(stepCounts.values()).filter(
+      (c) => c >= 2
+    ).length;
+    const isChords = polyphonicSteps > 0;
+    return {
+      index,
+      isChords,
+      avgPitch,
+      noteCount: trackPlacements.length
+    };
+  });
+  const chordTrackIndices = trackStats.filter((s) => s.isChords).map((s) => s.index);
+  const nonChordTracks = trackStats.filter(
+    (s) => !s.isChords && s.noteCount > 0
+  );
+  let bassTrackIndex = null;
+  if (nonChordTracks.length > 0) {
+    nonChordTracks.sort((a, b) => a.avgPitch - b.avgPitch);
+    bassTrackIndex = nonChordTracks[0].index;
+  }
+  const priorityTrackIndices = /* @__PURE__ */ new Set();
+  for (const idx of chordTrackIndices) {
+    priorityTrackIndices.add(idx);
+  }
+  if (bassTrackIndex !== null) {
+    priorityTrackIndices.add(bassTrackIndex);
+  }
+  const hasPriorityTracksInMml = priorityTrackIndices.size > 0;
+  const maxStep = placements.reduce(
+    (max, p) => Math.max(max, p.startStep + p.durationSteps),
+    0
+  );
+  const priorityPitches = Array.from(
+    { length: maxStep + 1 },
+    () => /* @__PURE__ */ new Set()
+  );
+  const allPitches = Array.from(
+    { length: maxStep + 1 },
+    () => /* @__PURE__ */ new Set()
+  );
+  for (const p of placements) {
+    for (let s = p.startStep; s < p.startStep + p.durationSteps; s++) {
+      if (s >= 0 && s <= maxStep) {
+        allPitches[s].add(p.pitch);
+        if (priorityTrackIndices.has(p.trackIndex)) {
+          priorityPitches[s].add(p.pitch);
+        }
+      }
+    }
+  }
+  const stepChords = [];
+  const chordCache = /* @__PURE__ */ new Map();
+  let lastChord = "";
+  let hasPriorityStarted = false;
+  const GRID_SIZE = 48;
+  const MIN_DURATION = 12;
+  for (let g = 0; g <= Math.ceil(maxStep / GRID_SIZE); g++) {
+    const startS = g * GRID_SIZE;
+    const endS = Math.min(maxStep, (g + 1) * GRID_SIZE - 1);
+    if (startS > maxStep) break;
+    for (let s = startS; s <= endS; s++) {
+      const priorityPitchesAtStep = Array.from(priorityPitches[s]);
+      if (priorityPitchesAtStep.length > 0) {
+        hasPriorityStarted = true;
+      }
+    }
+    const pitchDurations = /* @__PURE__ */ new Map();
+    for (let s = startS; s <= endS; s++) {
+      const usePriority = hasPriorityStarted && hasPriorityTracksInMml;
+      const pitches = usePriority ? Array.from(priorityPitches[s]) : Array.from(allPitches[s]);
+      for (const p of pitches) {
+        pitchDurations.set(p, (pitchDurations.get(p) ?? 0) + 1);
+      }
+    }
+    let activePitches = Array.from(pitchDurations.entries()).filter(([_, dur]) => dur >= MIN_DURATION).map(([p, _]) => p);
+    if (activePitches.length === 0 && pitchDurations.size > 0) {
+      const maxDur = Math.max(...pitchDurations.values());
+      activePitches = Array.from(pitchDurations.entries()).filter(([_, dur]) => dur === maxDur).map(([p, _]) => p);
+    }
+    let gridChord = lastChord;
+    if (activePitches.length > 0) {
+      const sortedPitches = activePitches.sort((a, b) => a - b);
+      const cacheKey = sortedPitches.join(",");
+      if (chordCache.has(cacheKey)) {
+        const chordName = chordCache.get(cacheKey);
+        if (chordName) gridChord = chordName;
+      } else {
+        const candidates = detectChord(sortedPitches);
+        const chordName = candidates[0]?.symbol ?? "";
+        if (chordName) gridChord = chordName;
+        chordCache.set(cacheKey, chordName);
+      }
+    }
+    for (let s = startS; s <= endS; s++) {
+      stepChords[s] = gridChord;
+    }
+    lastChord = gridChord;
+  }
   const seqTracks = trackIndices.map((index) => {
     let id = 0;
     const notes = placements.filter((p) => p.trackIndex === index).map((p) => ({
@@ -6301,6 +6972,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 +7119,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 +7146,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 +7210,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 +7226,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 +7573,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 +7616,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 +7801,6 @@ var createDtmStudio = async (options = {}) => {
       onPlayNote: playNote,
       onPlayDrum: playDrum,
       singingVoices,
-      parseChord,
-      parseChords,
       parseMidi,
       onToggleRecord,
       ...dawOverrides
@@ -7153,15 +7822,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();