@onjmin/dtm 0.1.21 → 0.1.22

package/dist/index.mjs

@@ -4177,6 +4177,18 @@ var VOICE_IMAGES = {
 var STEPS_PER_BEAT2 = 48;
 var PLAN_TIME = 0.5;
 var TICK_INTERVAL_MS = 20;
+var resolveLoopPoint = (point, bpm, stepsPerBar, sps) => {
+  if ("step" in point) {
+    return point.step;
+  }
+  if ("bar" in point) {
+    return Math.max(0, point.bar - 1) * stepsPerBar;
+  }
+  if ("seconds" in point) {
+    return point.seconds / sps;
+  }
+  return 0;
+};
 var createSequencer = (options) => {
   let timeline = [];
   let startTime = 0;
@@ -4186,28 +4198,74 @@ var createSequencer = (options) => {
   let active = false;
   let fromStepValue = 0;
   let trackVolumeMap = /* @__PURE__ */ new Map();
+  let isLooping = false;
+  let loopStartStep = 0;
+  let loopEndStep = 0;
+  let loopStartSec = 0;
+  let loopEndSec = 0;
+  let loopDurationSec = 0;
+  let loopStartIndex = 0;
+  let loopBase = 0;
+  let lastPlayStep = 0;
   const secondsPerStep = () => 60 / options.getBpm() / STEPS_PER_BEAT2;
+  const getWrappedPlayStep = (time, sps) => {
+    if (!isLooping || loopDurationSec <= 0 || time < loopEndSec) {
+      return fromStepValue + time / sps;
+    }
+    const elapsedInLoop = (time - loopEndSec) % loopDurationSec;
+    return loopStartStep + elapsedInLoop / sps;
+  };
   const buildTimeline = (fromStep) => {
     timeline = [];
     trackVolumeMap = /* @__PURE__ */ new Map();
     const sps = secondsPerStep();
+    const bpm = options.getBpm();
+    const stepsPerBar = options.stepsPerBar;
+    const loopOption = options.getLoop?.() ?? false;
+    isLooping = !!loopOption;
+    if (typeof loopOption === "object") {
+      loopStartStep = loopOption.start ? resolveLoopPoint(loopOption.start, bpm, stepsPerBar, sps) : 0;
+      const endVal = loopOption.end ? resolveLoopPoint(loopOption.end, bpm, stepsPerBar, sps) : null;
+      loopEndStep = endVal !== null ? endVal : -1;
+    } else {
+      loopStartStep = 0;
+      loopEndStep = -1;
+    }
+    const startLimit = isLooping ? Math.min(fromStep, loopStartStep) : fromStep;
+    let maxEndStep = 0;
     for (const track of options.getTracks()) {
       trackVolumeMap.set(track.id, track.volume);
       for (const note of track.notes) {
+        if (note.startStep < startLimit) continue;
         const relativeStart = note.startStep - fromStep;
-        if (relativeStart < 0) continue;
-        const velocity = note.velocity ?? DEFAULT_PLAYBACK_VELOCITY;
+        const when = relativeStart * sps;
+        const duration = note.durationSteps * sps;
+        maxEndStep = Math.max(maxEndStep, note.startStep + note.durationSteps);
         timeline.push({
           trackId: track.id,
           pitch: note.pitch,
           volume: track.volume / 100,
-          velocity,
-          when: relativeStart * sps,
-          duration: note.durationSteps * sps
+          velocity: note.velocity ?? DEFAULT_PLAYBACK_VELOCITY,
+          when,
+          duration
         });
       }
     }
     timeline.sort((a, b) => a.when - b.when);
+    if (loopEndStep === -1) {
+      loopEndStep = maxEndStep;
+    }
+    loopStartSec = (loopStartStep - fromStep) * sps;
+    loopEndSec = (loopEndStep - fromStep) * sps;
+    loopDurationSec = loopEndSec - loopStartSec;
+    loopStartIndex = 0;
+    while (loopStartIndex < timeline.length) {
+      const noteStartStep = fromStep + timeline[loopStartIndex].when / sps;
+      if (noteStartStep >= loopStartStep - 1e-4) {
+        break;
+      }
+      loopStartIndex++;
+    }
   };
   const scheduleTick = () => {
     const sps = secondsPerStep();
@@ -4216,9 +4274,16 @@ var createSequencer = (options) => {
     for (const track of options.getTracks()) {
       trackVolumeMap.set(track.id, track.volume);
     }
-    while (nowIndex < timeline.length) {
-      const ev = timeline[nowIndex];
-      const _when = ev.when - time;
+    while (true) {
+      let ev = timeline[nowIndex];
+      if (nowIndex >= timeline.length || isLooping && ev && ev.when >= loopEndSec) {
+        if (!isLooping || loopDurationSec <= 0) break;
+        nowIndex = loopStartIndex;
+        loopBase += loopDurationSec;
+        ev = timeline[nowIndex];
+      }
+      if (!ev) break;
+      const _when = ev.when + loopBase - time;
       if (_when > PLAN_TIME) break;
       nowIndex++;
       if (soloId && ev.trackId !== soloId) continue;
@@ -4236,7 +4301,7 @@ var createSequencer = (options) => {
     const pattern = options.getDrumPattern();
     if (pattern && pattern.length > 0) {
       const { stepsPerBar } = options;
-      const currentStep = (fromStepValue * sps + (options.getAudioTime() - startTime)) / sps;
+      const currentStep = getWrappedPlayStep(time, sps);
       const currentStepInBar = currentStep % stepsPerBar;
       const nextStep = currentStepInBar + 4;
       const crossedBar = currentStepInBar < 4;
@@ -4253,19 +4318,44 @@ var createSequencer = (options) => {
         });
       }
     }
-    const last = timeline[timeline.length - 1];
-    const lastWhen = last?.when ?? 0;
-    const lastDuration = last?.duration ?? 0;
-    if (nowIndex >= timeline.length && time > lastWhen + lastDuration + 0.1) {
-      stop();
-      options.onEnd();
+    if (time >= 0) {
+      const currentStep = getWrappedPlayStep(time, sps);
+      if (options.cues && options.cues.length > 0 && options.onCue) {
+        const bpm = options.getBpm();
+        const stepsPerBar = options.stepsPerBar;
+        const isCueCrossed = (cueStep, prevStep, currStep) => {
+          if (currStep >= prevStep) {
+            return cueStep > prevStep && cueStep <= currStep;
+          } else {
+            const reachedEnd = cueStep > prevStep && cueStep <= loopEndStep;
+            const startedNew = cueStep >= loopStartStep && cueStep <= currStep;
+            return reachedEnd || startedNew;
+          }
+        };
+        for (const cue of options.cues) {
+          const cueStep = resolveLoopPoint(cue.time, bpm, stepsPerBar, sps);
+          if (isCueCrossed(cueStep, lastPlayStep, currentStep)) {
+            options.onCue(cue.id);
+          }
+        }
+      }
+      lastPlayStep = currentStep;
+    }
+    if (!isLooping) {
+      const last = timeline[timeline.length - 1];
+      const lastWhen = last?.when ?? 0;
+      const lastDuration = last?.duration ?? 0;
+      if (nowIndex >= timeline.length && time > lastWhen + lastDuration + 0.1) {
+        stop();
+        options.onEnd();
+      }
     }
   };
   const animate = () => {
     if (!active) return;
     const sps = secondsPerStep();
     const time = options.getAudioTime() - startTime;
-    options.onTick(fromStepValue + time / sps);
+    options.onTick(getWrappedPlayStep(time, sps));
     animationId = requestAnimationFrame(animate);
   };
   const stop = () => {
@@ -4287,7 +4377,17 @@ var createSequencer = (options) => {
     if (timeline.length === 0 && !options.getDrumPattern()?.length) return;
     active = true;
     startTime = options.getAudioTime() + START_DELAY;
+    const sps = secondsPerStep();
     nowIndex = 0;
+    while (nowIndex < timeline.length) {
+      const noteStartStep = fromStepValue + timeline[nowIndex].when / sps;
+      if (noteStartStep >= fromStepValue - 1e-4) {
+        break;
+      }
+      nowIndex++;
+    }
+    loopBase = 0;
+    lastPlayStep = fromStepValue - 1e-4;
     intervalId = setInterval(scheduleTick, TICK_INTERVAL_MS);
     animationId = requestAnimationFrame(animate);
   };
@@ -4299,6 +4399,73 @@ var createSequencer = (options) => {
   };
 };
 
+// src/synth.ts
+var freqFromPitch = (pitch) => 440 * 2 ** ((pitch - 69) / 12);
+var createSynth = (ctx, destination = ctx.destination) => {
+  const playNote = (e) => {
+    const osc = ctx.createOscillator();
+    const gain = ctx.createGain();
+    osc.type = "square";
+    osc.frequency.value = freqFromPitch(e.pitch);
+    const t0 = ctx.currentTime + e.when;
+    const peak = Math.max(1e-4, 0.06 * e.volume * 1.5);
+    gain.gain.setValueAtTime(peak, t0);
+    gain.gain.exponentialRampToValueAtTime(1e-3, t0 + e.duration);
+    osc.connect(gain);
+    if (typeof ctx.createStereoPanner === "function" && e.pan) {
+      const panner = ctx.createStereoPanner();
+      panner.pan.value = Math.max(-1, Math.min(1, e.pan));
+      gain.connect(panner);
+      panner.connect(destination);
+    } else {
+      gain.connect(destination);
+    }
+    osc.start(t0);
+    osc.stop(t0 + e.duration + 0.02);
+  };
+  const playDrum = (e) => {
+    const t0 = ctx.currentTime + e.when;
+    const vol = Math.max(1e-4, Math.min(1, e.velocity));
+    const isKick = e.pitch === 35 || e.pitch === 36;
+    const isSnareLike = e.pitch === 38 || e.pitch === 39 || e.pitch === 40;
+    if (isKick) {
+      const osc = ctx.createOscillator();
+      const g2 = ctx.createGain();
+      osc.frequency.setValueAtTime(150, t0);
+      osc.frequency.exponentialRampToValueAtTime(50, t0 + 0.12);
+      g2.gain.setValueAtTime(vol * 0.9, t0);
+      g2.gain.exponentialRampToValueAtTime(1e-3, t0 + 0.18);
+      osc.connect(g2).connect(destination);
+      osc.start(t0);
+      osc.stop(t0 + 0.2);
+      osc.onended = () => osc.disconnect();
+      return;
+    }
+    const dur = isSnareLike ? 0.18 : 0.05;
+    const length = Math.max(1, Math.floor(ctx.sampleRate * dur));
+    const buffer = ctx.createBuffer(1, length, ctx.sampleRate);
+    const data = buffer.getChannelData(0);
+    for (let i = 0; i < length; i++) data[i] = Math.random() * 2 - 1;
+    const src = ctx.createBufferSource();
+    src.buffer = buffer;
+    const filter = ctx.createBiquadFilter();
+    filter.type = isSnareLike ? "bandpass" : "highpass";
+    filter.frequency.value = isSnareLike ? 2e3 : 8e3;
+    const g = ctx.createGain();
+    g.gain.setValueAtTime(vol * (isSnareLike ? 0.7 : 0.4), t0);
+    g.gain.exponentialRampToValueAtTime(1e-3, t0 + dur);
+    src.connect(filter).connect(g).connect(destination);
+    src.start(t0);
+    src.stop(t0 + dur);
+    src.onended = () => {
+      src.disconnect();
+      filter.disconnect();
+      g.disconnect();
+    };
+  };
+  return { playNote, playDrum };
+};
+
 // src/styles.ts
 var STYLE_ID = "dtm-daw-styles";
 var DAW_CSS = `
@@ -4969,6 +5136,13 @@ var DAW_CSS = `
   font-size: 13px;
   line-height: 1.6;
 }
+.dtm-modal-body a {
+  color: var(--dtm-primary);
+  text-decoration: underline;
+}
+.dtm-modal-body a:hover {
+  color: var(--dtm-accent);
+}
 .dtm-modal-body h4 {
   margin: 12px 0 6px 0;
   color: var(--dtm-primary);
@@ -5423,7 +5597,6 @@ var showBalloon = (balloonEl) => {
     hideActiveBalloon();
   }, 3e3);
 };
-var freqFromPitch = (pitch) => 440 * 2 ** ((pitch - 69) / 12);
 var mountMmlPlayer = (target, mml, options = {}) => {
   injectStyles(target.ownerDocument ?? document);
   const {
@@ -5494,68 +5667,10 @@ var mountMmlPlayer = (target, mml, options = {}) => {
     if (!audioCtx) audioCtx = new AudioContext();
     return audioCtx;
   };
-  const synthPlay = (e) => {
-    const ctx = ensureCtx();
-    const osc = ctx.createOscillator();
-    const gain = ctx.createGain();
-    osc.type = "square";
-    osc.frequency.value = freqFromPitch(e.pitch);
-    const t0 = ctx.currentTime + e.when;
-    const peak = Math.max(1e-4, 0.06 * e.volume * 1.5);
-    gain.gain.setValueAtTime(peak, t0);
-    gain.gain.exponentialRampToValueAtTime(1e-3, t0 + e.duration);
-    osc.connect(gain);
-    if (typeof ctx.createStereoPanner === "function" && e.pan) {
-      const panner = ctx.createStereoPanner();
-      panner.pan.value = Math.max(-1, Math.min(1, e.pan));
-      gain.connect(panner);
-      panner.connect(ctx.destination);
-    } else {
-      gain.connect(ctx.destination);
-    }
-    osc.start(t0);
-    osc.stop(t0 + e.duration + 0.02);
-  };
-  const drumSynth = (e) => {
-    const ctx = ensureCtx();
-    const t0 = ctx.currentTime + e.when;
-    const vol = Math.max(1e-4, Math.min(1, e.velocity));
-    const isKick = e.pitch === 35 || e.pitch === 36;
-    const isSnareLike = e.pitch === 38 || e.pitch === 39 || e.pitch === 40;
-    if (isKick) {
-      const osc = ctx.createOscillator();
-      const g2 = ctx.createGain();
-      osc.frequency.setValueAtTime(150, t0);
-      osc.frequency.exponentialRampToValueAtTime(50, t0 + 0.12);
-      g2.gain.setValueAtTime(vol * 0.9, t0);
-      g2.gain.exponentialRampToValueAtTime(1e-3, t0 + 0.18);
-      osc.connect(g2).connect(ctx.destination);
-      osc.start(t0);
-      osc.stop(t0 + 0.2);
-      osc.onended = () => osc.disconnect();
-      return;
-    }
-    const dur = isSnareLike ? 0.18 : 0.05;
-    const length = Math.max(1, Math.floor(ctx.sampleRate * dur));
-    const buffer = ctx.createBuffer(1, length, ctx.sampleRate);
-    const data = buffer.getChannelData(0);
-    for (let i = 0; i < length; i++) data[i] = Math.random() * 2 - 1;
-    const src = ctx.createBufferSource();
-    src.buffer = buffer;
-    const filter = ctx.createBiquadFilter();
-    filter.type = isSnareLike ? "bandpass" : "highpass";
-    filter.frequency.value = isSnareLike ? 2e3 : 8e3;
-    const g = ctx.createGain();
-    g.gain.setValueAtTime(vol * (isSnareLike ? 0.7 : 0.4), t0);
-    g.gain.exponentialRampToValueAtTime(1e-3, t0 + dur);
-    src.connect(filter).connect(g).connect(ctx.destination);
-    src.start(t0);
-    src.stop(t0 + dur);
-    src.onended = () => {
-      src.disconnect();
-      filter.disconnect();
-      g.disconnect();
-    };
+  let synthInstance = null;
+  const ensureSynth = () => {
+    if (!synthInstance) synthInstance = createSynth(ensureCtx());
+    return synthInstance;
   };
   let voices = null;
   const ensureVoices = () => {
@@ -5925,12 +6040,12 @@ var mountMmlPlayer = (target, mml, options = {}) => {
       if (em) jumpEmojiAt(em, e.when);
       if (lyricTracks.has(trackIdx)) return;
       options.onPlayNote?.(e);
-      if (useSynth) synthPlay(e);
+      if (useSynth) ensureSynth().playNote(e);
     },
     onPlayDrum: (e) => {
       const velocity = e.velocity * (trackVolume / 100);
       options.onPlayDrum?.({ ...e, velocity });
-      if (useSynth) drumSynth({ ...e, velocity });
+      if (useSynth) ensureSynth().playDrum({ ...e, velocity });
     },
     onTick: (step) => {
       renderPlayhead(step);
@@ -6005,13 +6120,19 @@ var mountMmlPlayer = (target, mml, options = {}) => {
     if (activePlayer && activePlayer !== instance) activePlayer.stop();
     activePlayer = instance;
     setPlayingUI(true);
-    void options.onResumeAudio?.();
-    if (useSynth) {
-      const ctx = ensureCtx();
-      if (ctx.state === "suspended") void ctx.resume();
-    }
-    if (voicesAvailable && lyricTracks.size > 0) ensureVoices().reset();
-    void startWhenReady();
+    void (async () => {
+      const resumes = [];
+      const r = options.onResumeAudio?.();
+      if (r) resumes.push(r);
+      if (useSynth) {
+        const ctx = ensureCtx();
+        if (ctx.state === "suspended") resumes.push(ctx.resume());
+      }
+      if (resumes.length > 0) await Promise.all(resumes);
+      if (!playing || activePlayer !== instance) return;
+      if (voicesAvailable && lyricTracks.size > 0) ensureVoices().reset();
+      await startWhenReady();
+    })();
   };
   const stop = () => {
     if (!playing) return;
@@ -7026,8 +7147,8 @@ var mountDAW = (target, options = {}) => {
     stepsPerBar: renderConfig.stepsPerBar
   });
   const play = async () => {
-    options.onResumeAudio?.();
     if (playbackState === "playing") return;
+    await options.onResumeAudio?.();
     const fromStep = playbackState === "paused" ? pausedPlayStep : playStartStep;
     options.singingVoices?.reset();
     const lyricMap = buildLyricsMap();
@@ -8184,6 +8305,123 @@ var INSTRUMENT_PRESETS = {
   }
 };
 
+// src/headless-player.ts
+var STEPS_PER_BAR2 = 192;
+var playMML = (mml, options = {}) => {
+  const { placements, bpm: parsedBpm, meta } = parseMML(mml);
+  const bpm = parsedBpm ?? options.defaultBpm ?? DEFAULT_BPM;
+  const drumPatternDict = options.drumPatterns ?? DRUM_PATTERNS;
+  const drumPattern = meta.drum ? drumPatternDict[meta.drum] ?? null : null;
+  let masterVolume = meta.volume ?? options.volume ?? 100;
+  const trackIndices = [...new Set(placements.map((p) => p.trackIndex))].sort(
+    (a, b) => a - b
+  );
+  const seqTracks = trackIndices.map((index) => {
+    let id = 0;
+    const notes = placements.filter((p) => p.trackIndex === index).map((p) => ({
+      id: id++,
+      startStep: p.startStep,
+      durationSteps: p.durationSteps,
+      pitch: p.pitch,
+      velocity: 100
+    }));
+    return { id: String(index), volume: masterVolume, notes };
+  });
+  const ownsCtx = !options.audioContext;
+  const ctx = options.audioContext ?? new AudioContext();
+  const destination = options.destination ?? ctx.destination;
+  const useSynth = options.synth ?? !options.onPlayNote;
+  const synth = useSynth ? createSynth(ctx, destination) : null;
+  const pauseWhenHidden = options.pauseWhenHidden ?? ownsCtx;
+  let playing = false;
+  const seq = createSequencer({
+    getTracks: () => seqTracks,
+    getBpm: () => bpm,
+    getPlayStartStep: () => 0,
+    getDrumPattern: () => drumPattern,
+    getSoloTrackId: () => null,
+    getLoop: () => options.loop ?? false,
+    cues: options.cues,
+    onCue: options.onCue,
+    getAudioTime: () => ctx.currentTime,
+    onPlayNote: (e) => {
+      options.onPlayNote?.(e);
+      synth?.playNote(e);
+    },
+    onPlayDrum: (e) => {
+      const velocity = e.velocity * (masterVolume / 100);
+      options.onPlayDrum?.({ ...e, velocity });
+      synth?.playDrum({ ...e, velocity });
+    },
+    onTick: () => {
+    },
+    onEnd: () => finish(),
+    stepsPerBar: STEPS_PER_BAR2
+  });
+  const finish = () => {
+    if (!playing) return;
+    playing = false;
+    options.onStop?.();
+  };
+  const onVisibilityChange = () => {
+    if (!playing) return;
+    if (document.hidden) {
+      void ctx.suspend();
+    } else if (ctx.state === "suspended") {
+      void ctx.resume();
+    }
+  };
+  if (pauseWhenHidden && typeof document !== "undefined") {
+    document.addEventListener("visibilitychange", onVisibilityChange);
+  }
+  playing = true;
+  void (async () => {
+    const resumes = [];
+    const r = options.onResumeAudio?.();
+    if (r) resumes.push(r);
+    if (ctx.state === "suspended") resumes.push(ctx.resume());
+    if (resumes.length > 0) await Promise.all(resumes);
+    if (!playing) return;
+    seq.start(0);
+  })();
+  const stop = () => {
+    if (!playing) return;
+    seq.stop();
+    finish();
+  };
+  const setVolume = (volume) => {
+    masterVolume = volume;
+    for (const t of seqTracks) t.volume = volume;
+  };
+  const suspend = () => ctx.suspend();
+  const resume = () => ctx.resume();
+  const destroy = () => {
+    seq.stop();
+    playing = false;
+    if (pauseWhenHidden && typeof document !== "undefined") {
+      document.removeEventListener("visibilitychange", onVisibilityChange);
+    }
+    if (ownsCtx) void ctx.close();
+  };
+  return {
+    stop,
+    isPlaying: () => playing,
+    setVolume,
+    suspend,
+    resume,
+    destroy
+  };
+};
+
+// src/headless-singing-player.ts
+var playSingingMML = (_mml, _options = {}) => {
+  return Promise.reject(
+    new Error(
+      "playSingingMML is not implemented yet. See implementation notes at the top of headless-singing-player.ts."
+    )
+  );
+};
+
 // src/piano-roll.ts
 var createPianoRoll = (options, handlers) => {
   const {
@@ -8635,7 +8873,23 @@ var DEFAULT_CDN = {
   soundFontList: "https://rpgen3.github.io/soundfont/mjs/surikov/SoundFont_list.mjs"
 };
 var SOUNDFONT_NAME = "FluidR3_GM_sf2_file";
-var TRACK_ROLES = ["melody", "submelody", "bass", "chord"];
+var TRACK_ROLES = [
+  "melody",
+  "submelody",
+  "bass",
+  "chord",
+  "t4",
+  "t5",
+  "t6",
+  "t7",
+  "t8",
+  "t9",
+  "t10",
+  "t11",
+  "t12",
+  "t13",
+  "t14"
+];
 var resolveDefaultVoiceWorkerUrl = () => {
   try {
     return new URL("./voice-worker.js", import.meta.url).href;
@@ -8667,7 +8921,8 @@ var createDtmStudio = async (options = {}) => {
   drumGain.gain.value = options.drumVolume ?? 1;
   drumGain.connect(audioCtx.destination);
   const resumeAudio = () => {
-    if (audioCtx.state === "suspended") void audioCtx.resume();
+    if (audioCtx.state === "suspended") return audioCtx.resume();
+    return Promise.resolve();
   };
   const eng = options.engines ?? {};
   const [SoundFont, SoundFont_drum, SoundFont_list] = await Promise.all([
@@ -8771,36 +9026,44 @@ var createDtmStudio = async (options = {}) => {
   })();
   let nameToKey = {};
   const soundFonts = /* @__PURE__ */ new Map();
-  const loadedKeyByTrack = /* @__PURE__ */ new Map();
-  const loadSoundFont = async (instrumentKey, trackId) => {
-    if (loadedKeyByTrack.get(trackId) === instrumentKey) return;
-    try {
-      const fullName = `${instrumentKey}_${SOUNDFONT_NAME}`;
-      soundFonts.set(
-        trackId,
-        await SoundFont.load({
-          ctx: audioCtx,
-          fontName: `_tone_${fullName}`,
-          url: SoundFont.toURL(fullName)
-        })
-      );
-      loadedKeyByTrack.set(trackId, instrumentKey);
-    } catch (e) {
+  const loadingByKey = /* @__PURE__ */ new Map();
+  const loadInstrument = (instrumentKey) => {
+    if (soundFonts.has(instrumentKey)) return Promise.resolve();
+    const inflight = loadingByKey.get(instrumentKey);
+    if (inflight) return inflight;
+    const fullName = `${instrumentKey}_${SOUNDFONT_NAME}`;
+    const p = SoundFont.load({
+      ctx: audioCtx,
+      fontName: `_tone_${fullName}`,
+      url: SoundFont.toURL(fullName)
+    }).then((sf) => {
+      soundFonts.set(instrumentKey, sf);
+    }).catch((e) => {
       console.error(`[dtm] \u697D\u5668 "${instrumentKey}" \u306E\u8AAD\u307F\u8FBC\u307F\u306B\u5931\u6557`, e);
-    }
+    }).finally(() => {
+      loadingByKey.delete(instrumentKey);
+    });
+    loadingByKey.set(instrumentKey, p);
+    return p;
   };
   const defaultPreset = options.defaultPreset ?? "retro_game";
   const instrumentNameFor = (preset, trackId) => preset[trackId] ?? preset.melody;
+  const resolveSoundFont = (presetKey, trackId) => {
+    const preset = INSTRUMENT_PRESETS[presetKey];
+    if (!preset) return void 0;
+    const key = nameToKey[instrumentNameFor(preset, trackId)];
+    return key ? soundFonts.get(key) : void 0;
+  };
   const loadPreset = async (presetKey, trackIds = [...TRACK_ROLES]) => {
     const preset = INSTRUMENT_PRESETS[presetKey];
     if (!preset) return;
     await listReady;
-    await Promise.all(
-      trackIds.map((trackId) => {
-        const key = nameToKey[instrumentNameFor(preset, trackId)];
-        return key ? loadSoundFont(key, trackId) : Promise.resolve();
-      })
-    );
+    const keys = /* @__PURE__ */ new Set();
+    for (const trackId of trackIds) {
+      const key = nameToKey[instrumentNameFor(preset, trackId)];
+      if (key) keys.add(key);
+    }
+    await Promise.all([...keys].map((key) => loadInstrument(key)));
   };
   const applyPreset = async (daw, presetKey, trackIds, loadingTarget) => {
     const wasPlaying = daw.getPlaybackState() === "playing";
@@ -8870,18 +9133,6 @@ var createDtmStudio = async (options = {}) => {
   await listReady;
   nameToKey = await buildNameToKeyMapping();
   await Promise.all([drumReady, loadPreset(defaultPreset)]);
-  const playNote = (e) => {
-    const sf = soundFonts.get(e.trackId);
-    if (!sf) return;
-    sf.play({
-      ctx: audioCtx,
-      destination: masterGain,
-      pitch: e.pitch,
-      volume: e.volume,
-      when: e.when,
-      duration: e.duration
-    });
-  };
   const playDrum = (e) => {
     if (!SoundFont_drum.font) return;
     SoundFont_drum.play({
@@ -8893,19 +9144,6 @@ var createDtmStudio = async (options = {}) => {
       duration: e.duration
     });
   };
-  const sfForPlayerTrack = (trackId) => soundFonts.get(TRACK_ROLES[Number(trackId)] ?? "") ?? soundFonts.get(`t${trackId}`);
-  const playPlayerNote = (e) => {
-    const sf = sfForPlayerTrack(e.trackId);
-    if (!sf) return;
-    sf.play({
-      ctx: audioCtx,
-      destination: masterGain,
-      pitch: e.pitch,
-      volume: e.volume,
-      when: e.when,
-      duration: e.duration
-    });
-  };
   const editorPresetSelects = /* @__PURE__ */ new WeakMap();
   const mountedEditors = [];
   const mountedPlayers = [];
@@ -8914,6 +9152,20 @@ var createDtmStudio = async (options = {}) => {
     const { preset, presetUI, ...dawOverrides } = opts;
     const tracks = dawOverrides.tracks ?? TRACKS_SIMPLE;
     const trackIds = tracks.map((t) => t.id);
+    const presetKey = preset && INSTRUMENT_PRESETS[preset] ? preset : defaultPreset;
+    let editorPreset = presetKey;
+    const playNote = (e) => {
+      const sf = resolveSoundFont(editorPreset, e.trackId);
+      if (!sf) return;
+      sf.play({
+        ctx: audioCtx,
+        destination: masterGain,
+        pitch: e.pitch,
+        volume: e.volume,
+        when: e.when,
+        duration: e.duration
+      });
+    };
     const base = {
       getAudioTime: () => audioCtx.currentTime,
       onResumeAudio: resumeAudio,
@@ -8926,7 +9178,6 @@ var createDtmStudio = async (options = {}) => {
     };
     const daw = mountDAW(target, base);
     mountedEditors.push(daw);
-    const presetKey = preset && INSTRUMENT_PRESETS[preset] ? preset : defaultPreset;
     const wantPresetUI = presetUI ?? features.presetUI;
     let presetSelect = null;
     if (wantPresetUI) {
@@ -8937,7 +9188,11 @@ var createDtmStudio = async (options = {}) => {
         getTrackIds: () => trackIds,
         value: presetKey,
         loadingTarget: rollEl ?? target,
-        position: "prepend"
+        position: "prepend",
+        // 楽器変更時、このエディタの発音解決が使うプリセットも追従させる。
+        onChange: (key) => {
+          editorPreset = key;
+        }
       });
       editorPresetSelects.set(target, presetSelect);
     }
@@ -9041,10 +9296,28 @@ var createDtmStudio = async (options = {}) => {
     return instance;
   };
   const mountPlayer = (target, mml, opts = {}) => {
-    const meta = parseMML(mml, {}).meta ?? {};
-    if (meta.instrument && INSTRUMENT_PRESETS[meta.instrument]) {
-      void loadPreset(meta.instrument);
-    }
+    const parsed = parseMML(mml, {});
+    const meta = parsed.meta ?? {};
+    const playerPreset = meta.instrument && INSTRUMENT_PRESETS[meta.instrument] ? meta.instrument : defaultPreset;
+    const trackIndices = [
+      ...new Set(parsed.placements.map((p) => p.trackIndex))
+    ];
+    const trackIds = trackIndices.map((idx) => TRACK_ROLES[idx] ?? `t${idx}`);
+    const loadTrackIds = trackIds.length > 0 ? trackIds : [...TRACK_ROLES];
+    void loadPreset(playerPreset, loadTrackIds);
+    const playPlayerNote = (e) => {
+      const role = TRACK_ROLES[Number(e.trackId)] ?? `t${e.trackId}`;
+      const sf = resolveSoundFont(playerPreset, role);
+      if (!sf) return;
+      sf.play({
+        ctx: audioCtx,
+        destination: masterGain,
+        pitch: e.pitch,
+        volume: e.volume,
+        when: e.when,
+        duration: e.duration
+      });
+    };
     const player = mountMmlPlayer(target, mml, {
       getAudioTime: () => audioCtx.currentTime,
       onResumeAudio: resumeAudio,
@@ -9122,6 +9395,7 @@ export {
   createPianoRoll,
   createSequencer,
   createSingingVoices,
+  createSynth,
   createVoiceRegistry,
   decomposeToMonophonic,
   drawGrid,
@@ -9135,6 +9409,7 @@ export {
   extractMidiPlacementsByTrack,
   fetchSoundFontList,
   formatMmlMeta,
+  freqFromPitch,
   generateRandomPattern,
   getDrawOffset,
   getGridCanvas,
@@ -9157,6 +9432,8 @@ export {
   parseLyrics,
   parseMML,
   parseMmlMeta,
+  playMML,
+  playSingingMML,
   setDrawOffset,
   setupRecorder,
   shiftNotes,