@ugfoundation/swaralipi-js 0.1.0

package/dist/player/index.js

@@ -0,0 +1,743 @@
+import { TAALS } from '../chunk-GWXI2HJA.js';
+
+// src/player/pitch.ts
+var OCTAVE_OFFSET = {
+  "ati-mandra": -2,
+  mandra: -1,
+  madhyam: 0,
+  taar: 1,
+  "ati-taar": 2
+};
+var SHUDDHA = {
+  s: 0,
+  r: 2,
+  g: 4,
+  m: 5,
+  p: 7,
+  d: 9,
+  n: 11
+};
+var SHARP_NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"];
+var PITCH_CLASS = {
+  c: 0,
+  "c#": 1,
+  db: 1,
+  d: 2,
+  "d#": 3,
+  eb: 3,
+  e: 4,
+  "e#": 5,
+  fb: 4,
+  f: 5,
+  "f#": 6,
+  gb: 6,
+  g: 7,
+  "g#": 8,
+  ab: 8,
+  a: 9,
+  "a#": 10,
+  bb: 10,
+  b: 11,
+  "b#": 0,
+  cb: 11
+};
+function parseTonic(tonic) {
+  if (!tonic) return 0;
+  const key = tonic.trim().toLowerCase().replace(/s/g, "#");
+  return PITCH_CLASS[key] ?? 0;
+}
+function svaraSemitone(note) {
+  if (note.svara === void 0) return null;
+  const [, letter] = note.svara;
+  let semi = SHUDDHA[letter];
+  if (note.komal === true || note.microtone !== void 0) semi -= 1;
+  if (note.tivra === true) semi += 1;
+  return semi;
+}
+function svaraToMidi(note, tonicPc, baseOctave = 4) {
+  const semi = svaraSemitone(note);
+  if (semi === null || note.svara === void 0) return null;
+  const [octave] = note.svara;
+  return (baseOctave + 1 + OCTAVE_OFFSET[octave]) * 12 + tonicPc + semi;
+}
+function kanToMidi(svara, tonicPc, baseOctave = 4) {
+  if (svara === void 0) return null;
+  const [octave, letter] = svara;
+  return (baseOctave + 1 + OCTAVE_OFFSET[octave]) * 12 + tonicPc + SHUDDHA[letter];
+}
+function midiToSampleName(midi) {
+  const pc = (midi % 12 + 12) % 12;
+  const octave = Math.floor(midi / 12) - 1;
+  return `${SHARP_NAMES[pc]}${octave}`;
+}
+function sampleFileName(midi) {
+  return midiToSampleName(midi).toLowerCase().replace("#", "s");
+}
+
+// src/player/schedule.ts
+var isSilent = (n) => n.svara === void 0 && n.rest !== true && n.sustain !== true;
+function buildSchedule(doc, opts = {}) {
+  const tonicPc = parseTonic(opts.tonic ?? doc.meta.tonic);
+  const baseOctave = opts.baseOctave ?? 4;
+  const events = [];
+  let cursor = 0;
+  let lastPitched = -1;
+  doc.parts.forEach((part, p) => {
+    part.rows.forEach((row, r) => {
+      row.notes.forEach((note, i) => {
+        if (note.bar !== void 0 || isSilent(note)) return;
+        const path = `${p}.${r}.${i}`;
+        const dur = note.durationMatra ?? 1;
+        if (note.svara !== void 0) {
+          events.push({
+            beat: cursor,
+            durationBeats: dur,
+            midi: svaraToMidi(note, tonicPc, baseOctave),
+            kan: kanToMidi(note.kan, tonicPc, baseOctave),
+            path,
+            kind: note.sustain === true ? "sustain" : "note"
+          });
+          lastPitched = events.length - 1;
+        } else if (note.sustain === true) {
+          if (lastPitched >= 0) events[lastPitched].durationBeats += dur;
+          events.push({ beat: cursor, durationBeats: dur, midi: null, kan: null, path, kind: "sustain" });
+        } else {
+          events.push({ beat: cursor, durationBeats: dur, midi: null, kan: null, path, kind: "rest" });
+        }
+        cursor += dur;
+      });
+    });
+  });
+  return { events, totalBeats: cursor };
+}
+
+// src/player/instruments.ts
+var DEFAULT_SOUNDS_BASE = "https://cdn.daserve.in/swaralipijs-instruments/";
+var SALAMANDER_BASE = "https://tonejs.github.io/audio/salamander/";
+var TONEJS_INSTRUMENTS_BASE = "https://nbrosowsky.github.io/tonejs-instruments/samples/";
+function keyMap(keys) {
+  const m = {};
+  for (const k of keys) m[k] = `${k.replace("#", "s")}.mp3`;
+  return m;
+}
+var PIANO_KEYS = [
+  "A0",
+  "C1",
+  "D#1",
+  "F#1",
+  "A1",
+  "C2",
+  "D#2",
+  "F#2",
+  "A2",
+  "C3",
+  "D#3",
+  "F#3",
+  "A3",
+  "C4",
+  "D#4",
+  "F#4",
+  "A4",
+  "C5",
+  "D#5",
+  "F#5",
+  "A5",
+  "C6",
+  "D#6",
+  "F#6",
+  "A6",
+  "C7",
+  "D#7",
+  "F#7",
+  "A7",
+  "C8"
+];
+var HARMONIUM_KEYS = [
+  "C2",
+  "C#2",
+  "D2",
+  "D#2",
+  "E2",
+  "F2",
+  "F#2",
+  "G2",
+  "G#2",
+  "A2",
+  "A#2",
+  "C3",
+  "C#3",
+  "D3",
+  "D#3",
+  "E3",
+  "F3",
+  "F#3",
+  "G3",
+  "G#3",
+  "A3",
+  "A#3",
+  "C4",
+  "C#4",
+  "D4",
+  "D#4",
+  "E4",
+  "F4",
+  "F#4",
+  "G4",
+  "G#4",
+  "A4",
+  "A#4",
+  "C5",
+  "C#5",
+  "D5"
+];
+var VIOLIN_KEYS = ["A3", "C4", "E4", "G4", "A4", "C5", "E5", "G5", "A5", "C6", "E6", "G6", "A6", "C7"];
+var FLUTE_KEYS = ["C4", "E4", "A4", "C5", "E5", "A5", "C6", "E6", "A6", "C7"];
+var INSTRUMENTS = {
+  piano: { label: "Grand piano", urls: keyMap(PIANO_KEYS), baseUrl: SALAMANDER_BASE, release: 1 },
+  santoor: { label: "Santoor", urls: santoorUrls(), baseUrl: "santoor/", local: true, release: 1.2 },
+  harmonium: { label: "Harmonium", urls: keyMap(HARMONIUM_KEYS), baseUrl: `${TONEJS_INSTRUMENTS_BASE}harmonium/`, release: 1.4 },
+  violin: { label: "Violin", urls: keyMap(VIOLIN_KEYS), baseUrl: `${TONEJS_INSTRUMENTS_BASE}violin/`, release: 1 },
+  flute: { label: "Flute", urls: keyMap(FLUTE_KEYS), baseUrl: `${TONEJS_INSTRUMENTS_BASE}flute/`, release: 1 }
+};
+var SAMPLED_TAALS = new Set(
+  Object.keys(TAALS)
+);
+var TABLA_BPMS = Array.from({ length: 17 }, (_, i) => 60 + i * 15);
+function normalizeBase(url) {
+  return url.endsWith("/") ? url : `${url}/`;
+}
+function santoorUrls() {
+  const urls = {};
+  const add = (midi) => {
+    const stem = sampleFileName(midi);
+    const name = stem.replace("s", "#").replace(/^(.)/, (c) => c.toUpperCase());
+    urls[name] = `${stem}.mp3`;
+  };
+  for (let midi = 60; midi <= 95; midi++) add(midi);
+  add(96);
+  return urls;
+}
+var PC_BASE = { c: 0, d: 2, e: 4, f: 5, g: 7, a: 9, b: 11 };
+function noteToMidi(name) {
+  const m = /^([a-g])([#sb]?)(-?\d+)$/i.exec(name.trim());
+  if (!m) return NaN;
+  const base = PC_BASE[m[1].toLowerCase()];
+  const acc = m[2] === "b" ? -1 : m[2] === "" ? 0 : 1;
+  return (Number(m[3]) + 1) * 12 + base + acc;
+}
+function subsetUrls(urls, lo, hi) {
+  const entries = Object.entries(urls).map(([k, f]) => ({ k, f, midi: noteToMidi(k) })).filter((e) => Number.isFinite(e.midi)).sort((a, b) => a.midi - b.midi);
+  if (entries.length === 0) return { ...urls };
+  const keep = /* @__PURE__ */ new Set();
+  for (const e of entries) if (e.midi >= lo && e.midi <= hi) keep.add(e.k);
+  let floor;
+  let ceil;
+  for (const e of entries) if (e.midi <= lo) floor = e.k;
+  for (const e of entries) if (e.midi >= hi) {
+    ceil = e.k;
+    break;
+  }
+  if (floor) keep.add(floor);
+  if (ceil) keep.add(ceil);
+  if (keep.size === 0) {
+    const mid = (lo + hi) / 2;
+    const nearest = entries.reduce((a, b) => Math.abs(b.midi - mid) < Math.abs(a.midi - mid) ? b : a);
+    keep.add(nearest.k);
+  }
+  const out = {};
+  for (const e of entries) if (keep.has(e.k)) out[e.k] = e.f;
+  return out;
+}
+function instrumentSampleUrl(def, soundsBaseUrl) {
+  if (def.local && soundsBaseUrl === void 0) return void 0;
+  const base = def.local ? `${normalizeBase(soundsBaseUrl ?? "")}${def.baseUrl}` : def.baseUrl;
+  const file = Object.values(def.urls)[0];
+  return file === void 0 ? void 0 : `${normalizeBase(base)}${file}`;
+}
+async function probeUrl(url, timeoutMs = 6e3) {
+  if (typeof fetch === "undefined") return false;
+  const ctrl = typeof AbortController !== "undefined" ? new AbortController() : void 0;
+  const timer = ctrl ? setTimeout(() => ctrl.abort(), timeoutMs) : void 0;
+  try {
+    const res = await fetch(url, {
+      method: "GET",
+      headers: { Range: "bytes=0-0" },
+      cache: "no-store",
+      signal: ctrl?.signal
+    });
+    return res.ok;
+  } catch {
+    return false;
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+function nearestTablaBpm(bpm) {
+  return TABLA_BPMS.reduce((best, b) => Math.abs(b - bpm) < Math.abs(best - bpm) ? b : best, TABLA_BPMS[0]);
+}
+function tablaUrl(base, taalId, bpm) {
+  return `${normalizeBase(base)}tabla/${taalId}/${taalId}${bpm}bpm.mp3`;
+}
+function metronomeUrl(base) {
+  return `${normalizeBase(base)}metronome/metro2.mp3`;
+}
+function createMetronome(Tone, base) {
+  return new Tone.Player(metronomeUrl(base));
+}
+var TANPURA_PCS = ["c", "cs", "d", "ds", "e", "f", "fs", "g", "gs", "a", "as", "b"];
+function createSampler(Tone, def, soundsBaseUrl, range) {
+  const base = def.local ? `${normalizeBase(soundsBaseUrl ?? "")}${def.baseUrl}` : def.baseUrl;
+  const urls = range ? subsetUrls(def.urls, range.lo, range.hi) : def.urls;
+  return new Tone.Sampler({ urls, baseUrl: normalizeBase(base), release: def.release ?? 1 });
+}
+function createTanpura(Tone, base, stems = TANPURA_PCS) {
+  const urls = {};
+  for (const s of stems) urls[s] = `${s}.mp3`;
+  return new Tone.Players({ urls, baseUrl: `${normalizeBase(base)}tanpura/` });
+}
+
+// src/player/player.ts
+var STOP_FADE_SEC = 0.5;
+function midiRange(schedule) {
+  let lo = Infinity;
+  let hi = -Infinity;
+  for (const ev of schedule.events) {
+    for (const m of [ev.midi, ev.kan]) {
+      if (m !== null) {
+        if (m < lo) lo = m;
+        if (m > hi) hi = m;
+      }
+    }
+  }
+  return lo <= hi ? { lo, hi } : void 0;
+}
+var SwaralipiPlayer = class {
+  #opts;
+  /** Per-song setBpm tweak: beats meta.bpm but is cleared by the next load(). */
+  #bpmTweak;
+  #doc;
+  #state = "idle";
+  #tone;
+  /** Master bus everything routes through, so stop() can fade it out. */
+  #master;
+  /** Cached melody samplers keyed by instrument id, with the MIDI range each
+   * was loaded for (rebuilt when a song needs a wider range). */
+  #samplers = /* @__PURE__ */ new Map();
+  #tanpura;
+  #tanpuraKey = "";
+  #metronome;
+  #tabla;
+  #scheduleIds = [];
+  #fadeTimer;
+  constructor(options = {}) {
+    this.#opts = {
+      soundsBaseUrl: options.soundsBaseUrl ?? DEFAULT_SOUNDS_BASE,
+      pianoBaseUrl: options.pianoBaseUrl,
+      customInstruments: options.customInstruments,
+      tonic: options.tonic,
+      bpm: options.bpm,
+      baseOctave: options.baseOctave ?? 4,
+      instrument: options.instrument ?? "piano",
+      instruments: options.instruments ?? Object.keys(INSTRUMENTS),
+      rhythm: options.rhythm ?? "tabla",
+      tanpura: options.tanpura ?? true,
+      previewLimitSec: options.previewLimitSec ?? Infinity,
+      onHighlight: options.onHighlight,
+      onState: options.onState,
+      onLimit: options.onLimit
+    };
+  }
+  /* ----------------------------------------------------------------- */
+  /* Public getters                                                     */
+  /* ----------------------------------------------------------------- */
+  get state() {
+    return this.#state;
+  }
+  get bpm() {
+    return this.#bpmTweak ?? this.#opts.bpm ?? this.#doc?.meta.bpm ?? 90;
+  }
+  /** The preview cap in seconds (`Infinity` = unlimited). */
+  get previewLimitSec() {
+    return this.#opts.previewLimitSec;
+  }
+  get instrument() {
+    return this.#effectiveInstrument();
+  }
+  get instruments() {
+    return [...this.#opts.instruments];
+  }
+  /** The taal currently driving the rhythm (auto from the doc, or an override). */
+  get taalId() {
+    return this.#taalId();
+  }
+  /** Whether the effective rhythm will actually be a sampled tabla. */
+  get usesTabla() {
+    const id = this.#taalId();
+    return this.#opts.rhythm === "tabla" && id !== void 0 && SAMPLED_TAALS.has(id) && !!this.#opts.soundsBaseUrl;
+  }
+  /* ----------------------------------------------------------------- */
+  /* Loading + transport control                                        */
+  /* ----------------------------------------------------------------- */
+  /** Set the document to play. Stops any current playback. */
+  load(doc) {
+    this.#halt();
+    this.#doc = doc;
+    this.#taalOverride = void 0;
+    this.#bpmTweak = void 0;
+    this.#setState("ready");
+  }
+  /** Start (or resume) playback. Must be triggered from a user gesture so the
+   * browser permits `AudioContext` resume. */
+  async play() {
+    if (this.#doc === void 0 || this.#state === "playing") return;
+    const Tone = await this.#ensureTone();
+    await Tone.start();
+    if (this.#state === "paused") {
+      Tone.getTransport().start();
+      this.#setState("playing");
+      return;
+    }
+    this.#cancelFade();
+    Tone.getTransport().stop();
+    this.#setState("loading");
+    await this.#arrange(Tone);
+    Tone.getTransport().start();
+    this.#setState("playing");
+    const limit = this.#opts.previewLimitSec;
+    if (Number.isFinite(limit)) {
+      Tone.getTransport().scheduleOnce(() => {
+        Tone.getDraw().schedule(() => {
+          if (this.#state === "playing") {
+            this.stop();
+            this.#opts.onLimit?.();
+          }
+        }, this.#tone.now());
+      }, limit);
+    }
+  }
+  /** Pause; `play()` resumes from the same position. */
+  pause() {
+    if (this.#tone === void 0 || this.#state !== "playing") return;
+    this.#tone.getTransport().pause();
+    this.#setState("paused");
+  }
+  /**
+   * Stop and rewind to the start. When sounding, the accompaniment (tabla /
+   * metronome / tanpura, which otherwise loop) is gently faded out over
+   * STOP_FADE_SEC before the transport is halted, so the rhythm doesn't keep
+   * playing or cut abruptly; otherwise it halts immediately.
+   */
+  stop() {
+    if (this.#tone === void 0 || this.#state === "idle") {
+      this.#halt();
+      return;
+    }
+    if ((this.#state === "playing" || this.#state === "paused") && this.#master !== void 0) {
+      const now = this.#tone.now();
+      this.#master.gain.cancelScheduledValues(now);
+      this.#master.gain.rampTo(0, STOP_FADE_SEC, now);
+      this.#emitHighlight(null);
+      this.#setState(this.#doc ? "ready" : "idle");
+      this.#cancelFadeTimer();
+      this.#fadeTimer = setTimeout(() => this.#halt(), STOP_FADE_SEC * 1e3 + 60);
+      return;
+    }
+    this.#halt();
+  }
+  /** Immediate, synchronous teardown: stop+rewind the transport, kill the
+   * looping accompaniment, restore the master gain for the next play. */
+  #halt() {
+    this.#cancelFadeTimer();
+    if (this.#tone !== void 0) {
+      const transport = this.#tone.getTransport();
+      transport.stop();
+      transport.cancel(0);
+      transport.position = 0;
+    }
+    this.#tabla?.dispose();
+    this.#tabla = void 0;
+    this.#restoreMasterGain();
+    this.#scheduleIds = [];
+    this.#emitHighlight(null);
+    if (this.#state !== "idle") this.#setState(this.#doc ? "ready" : "idle");
+  }
+  #cancelFadeTimer() {
+    if (this.#fadeTimer !== void 0) {
+      clearTimeout(this.#fadeTimer);
+      this.#fadeTimer = void 0;
+    }
+  }
+  /** Abort an in-flight stop-fade (timer + gain ramp) without touching the
+   * transport — used when play() interrupts a fade. */
+  #cancelFade() {
+    this.#cancelFadeTimer();
+    this.#restoreMasterGain();
+  }
+  #restoreMasterGain() {
+    if (this.#master !== void 0 && this.#tone !== void 0) {
+      this.#master.gain.cancelScheduledValues(this.#tone.now());
+      this.#master.gain.value = 1;
+    }
+  }
+  /* ----------------------------------------------------------------- */
+  /* Settings (re-arrange from the top if mid-playback)                 */
+  /* ----------------------------------------------------------------- */
+  setTonic(tonic) {
+    this.#opts.tonic = tonic;
+    this.#reapply();
+  }
+  setBpm(bpm) {
+    this.#bpmTweak = bpm;
+    this.#reapply();
+  }
+  /** Update the preview cap (`Infinity` lifts it). Takes effect on next play. */
+  setPreviewLimit(sec) {
+    this.#opts.previewLimitSec = sec;
+  }
+  setInstrument(instrument) {
+    this.#opts.instrument = instrument;
+    this.#reapply();
+  }
+  setRhythm(rhythm) {
+    this.#opts.rhythm = rhythm;
+    this.#reapply();
+  }
+  setTanpura(on) {
+    this.#opts.tanpura = on;
+    this.#reapply();
+  }
+  /** Override the taal (null restores auto-detection from `meta.taal`). */
+  setTaal(id) {
+    this.#taalOverride = id ?? void 0;
+    this.#taalAuto = id === null;
+    this.#reapply();
+  }
+  /** Wire highlight output to a `<swaralipi-sheet>` (or any highlight target).
+   * Pass `{ autoScroll }` to keep the active note in view while playing. */
+  bindSheet(target, opts = {}) {
+    const block = opts.autoScroll === true ? "center" : opts.autoScroll || void 0;
+    this.#opts.onHighlight = (path) => {
+      target.clearHighlights();
+      if (path === null) return;
+      const el = target.highlight(path);
+      if (block !== void 0 && el !== null) {
+        el.scrollIntoView({ block, inline: "nearest", behavior: "smooth" });
+      }
+    };
+  }
+  /**
+   * Check whether an instrument's samples are reachable (its CDN is up / the
+   * local files exist), via a one-byte ranged fetch of a representative sample.
+   * A pass means Tone can actually load it. `false` for unknown ids, local
+   * instruments with no `soundsBaseUrl`, or any network failure/timeout.
+   */
+  async checkInstrument(id, timeoutMs) {
+    const def = this.#resolveDef(id);
+    if (def === void 0) return false;
+    const url = instrumentSampleUrl(def, this.#opts.soundsBaseUrl);
+    if (url === void 0) return false;
+    return probeUrl(url, timeoutMs);
+  }
+  /**
+   * Probe several instruments at once (default: the exposed `instruments`),
+   * returning `{ id: available }`. Use it to disable picker options whose CDN
+   * or files are down. Probes run concurrently; a check never throws.
+   */
+  async checkInstruments(ids = this.#opts.instruments, timeoutMs) {
+    const entries = await Promise.all(
+      ids.map(async (id) => [id, await this.checkInstrument(id, timeoutMs)])
+    );
+    return Object.fromEntries(entries);
+  }
+  /** Release all audio resources. The instance is unusable afterward. */
+  dispose() {
+    this.#halt();
+    for (const { sampler } of this.#samplers.values()) sampler.dispose();
+    this.#samplers.clear();
+    this.#tanpura?.dispose();
+    this.#metronome?.dispose();
+    this.#tabla?.dispose();
+    this.#master?.dispose();
+    this.#tanpura = this.#metronome = this.#tabla = this.#master = void 0;
+  }
+  /* ----------------------------------------------------------------- */
+  /* Internals                                                          */
+  /* ----------------------------------------------------------------- */
+  #taalOverride;
+  #taalAuto = true;
+  #setState(state) {
+    this.#state = state;
+    this.#opts.onState?.(state);
+  }
+  #emitHighlight(path) {
+    this.#opts.onHighlight?.(path);
+  }
+  /** Resolve the active taal: an explicit override, else the doc's. */
+  #taalId() {
+    if (!this.#taalAuto && this.#taalOverride !== void 0) return this.#taalOverride;
+    const id = this.#doc?.meta.taal?.id;
+    return id !== void 0 && id in TAALS ? id : void 0;
+  }
+  /** Resolve an instrument id to its def (custom overrides built-ins; the
+   * `pianoBaseUrl` shortcut self-hosts the built-in piano). */
+  #resolveDef(id) {
+    const custom = this.#opts.customInstruments?.[id];
+    if (custom) return custom;
+    const def = INSTRUMENTS[id];
+    if (def && id === "piano" && this.#opts.pianoBaseUrl) {
+      return { ...def, baseUrl: normalizeBase(this.#opts.pianoBaseUrl) };
+    }
+    return def;
+  }
+  /** A CDN-backed instrument that needs no `soundsBaseUrl` — used when the
+   * chosen one is local-only and no samples host is set, or is unknown. */
+  #fallbackInstrument() {
+    const exposed = this.#opts.instruments.find((id) => {
+      const d = this.#resolveDef(id);
+      return d !== void 0 && d.local !== true;
+    });
+    return exposed ?? "harmonium";
+  }
+  /** The instrument actually used: the chosen one, unless it's local-only with
+   * no `soundsBaseUrl` (or unknown), in which case a CDN fallback. */
+  #effectiveInstrument() {
+    const id = this.#opts.instrument;
+    const def = this.#resolveDef(id);
+    if (def === void 0) return this.#fallbackInstrument();
+    if (def.local === true && !this.#opts.soundsBaseUrl) return this.#fallbackInstrument();
+    return id;
+  }
+  /** Effective tempo: snapped to the tabla grid while a tabla actually plays. */
+  #effectiveBpm() {
+    return this.usesTabla ? nearestTablaBpm(this.bpm) : this.bpm;
+  }
+  async #ensureTone() {
+    this.#tone ??= await import('tone');
+    return this.#tone;
+  }
+  /** Hard stop → rebuild → restart, only while playing; otherwise just store.
+   * Uses #halt (not the stop() fade) so a setting change restarts instantly. */
+  #reapply() {
+    if (this.#state !== "playing") return;
+    this.#halt();
+    void this.play();
+  }
+  /** The master bus everything routes through (created once, → destination). */
+  #ensureMaster(Tone) {
+    this.#master ??= new Tone.Gain(1).toDestination();
+    return this.#master;
+  }
+  /** Build the melody instrument(s)/rhythm/drone for the current settings and
+   * wait for their buffers, then schedule everything on the Transport. */
+  async #arrange(Tone) {
+    if (this.#doc === void 0) return;
+    const base = this.#opts.soundsBaseUrl;
+    const transport = Tone.getTransport();
+    transport.cancel(0);
+    transport.position = 0;
+    this.#scheduleIds = [];
+    this.#ensureMaster(Tone);
+    this.#restoreMasterGain();
+    const bpm = this.#effectiveBpm();
+    transport.bpm.value = bpm;
+    const spb = 60 / bpm;
+    const schedule = buildSchedule(this.#doc, {
+      tonic: this.#opts.tonic,
+      baseOctave: this.#opts.baseOctave
+    });
+    const range = midiRange(schedule);
+    const melody = this.#buildMelody(Tone, this.#effectiveInstrument(), base, range);
+    this.#buildRhythm(Tone, transport, base, spb);
+    this.#buildTanpura(Tone, transport, base, spb);
+    await Tone.loaded();
+    const draw = Tone.getDraw();
+    for (const ev of schedule.events) {
+      const at = ev.beat * spb;
+      if (ev.midi !== null) {
+        const name = midiToSampleName(ev.midi);
+        const dur = Math.max(ev.durationBeats * spb, 0.05);
+        if (ev.kan !== null) {
+          const kanName = midiToSampleName(ev.kan);
+          transport.scheduleOnce((time) => melody.triggerAttackRelease(kanName, spb * 0.4, time), Math.max(at - spb * 0.12, 0));
+        }
+        transport.scheduleOnce((time) => melody.triggerAttackRelease(name, dur, time), at);
+      }
+      transport.scheduleOnce((time) => {
+        draw.schedule(() => this.#emitHighlight(ev.path), time);
+      }, at);
+    }
+    const endAt = schedule.totalBeats * spb + spb;
+    transport.scheduleOnce((time) => {
+      draw.schedule(() => this.#emitHighlight(null), time);
+    }, schedule.totalBeats * spb);
+    transport.scheduleOnce(() => this.stop(), endAt);
+  }
+  /** Build (or reuse) the melody sampler for `id`, loading only the samples
+   * covering `range`. A cached sampler is reused while it still covers the
+   * range; otherwise it's rebuilt (so changing songs/tonic widens it lazily). */
+  #buildMelody(Tone, id, base, range) {
+    const def = this.#resolveDef(id) ?? INSTRUMENTS.harmonium;
+    const master = this.#ensureMaster(Tone);
+    const cached = this.#samplers.get(id);
+    if (cached && (range === void 0 || cached.lo <= range.lo && cached.hi >= range.hi)) {
+      return cached.sampler;
+    }
+    cached?.sampler.dispose();
+    const sampler = createSampler(Tone, def, base, range).connect(master);
+    this.#samplers.set(id, { sampler, lo: range?.lo ?? -Infinity, hi: range?.hi ?? Infinity });
+    return sampler;
+  }
+  #buildRhythm(Tone, transport, base, spb) {
+    this.#tabla?.dispose();
+    this.#tabla = void 0;
+    const master = this.#ensureMaster(Tone);
+    const taalId = this.#taalId();
+    const wantsTabla = this.#opts.rhythm === "tabla" && taalId !== void 0 && SAMPLED_TAALS.has(taalId) && base !== void 0;
+    if (wantsTabla) {
+      const url = tablaUrl(base, taalId, nearestTablaBpm(this.bpm));
+      this.#tabla = new Tone.Player({ url, loop: true }).connect(master);
+      this.#tabla.sync().start(0);
+      return;
+    }
+    if (this.#opts.rhythm === "none" || base === void 0) return;
+    this.#metronome ??= createMetronome(Tone, base).connect(master);
+    const metro = this.#metronome;
+    const cycle = taalId !== void 0 ? TAALS[taalId].numBeats : 4;
+    let beat = 0;
+    const id = transport.scheduleRepeat((time) => {
+      metro.volume.setValueAtTime(beat % cycle === 0 ? 0 : -8, time);
+      metro.start(time);
+      beat += 1;
+    }, spb, 0);
+    this.#scheduleIds.push(id);
+  }
+  #buildTanpura(Tone, transport, base, spb) {
+    if (!this.#opts.tanpura || base === void 0) return;
+    const tonicPc = (this.#tonicSemitone() % 12 + 12) % 12;
+    const sa = TANPURA_PCS[tonicPc];
+    const pa = TANPURA_PCS[(tonicPc + 7) % 12];
+    const key = `${sa},${pa}`;
+    if (this.#tanpura === void 0 || this.#tanpuraKey !== key) {
+      this.#tanpura?.dispose();
+      this.#tanpura = createTanpura(Tone, base, [sa, pa]).connect(this.#ensureMaster(Tone));
+      this.#tanpuraKey = key;
+    }
+    const players = this.#tanpura;
+    players.volume.value = -14;
+    const pattern = [pa, sa, sa, sa];
+    let i = 0;
+    const id = transport.scheduleRepeat((time) => {
+      const stem = pattern[i % pattern.length];
+      if (players.has(stem)) players.player(stem).start(time);
+      i += 1;
+    }, spb * 2, 0);
+    this.#scheduleIds.push(id);
+  }
+  #tonicSemitone() {
+    return parseTonic(this.#opts.tonic ?? this.#doc?.meta.tonic);
+  }
+};
+
+export { DEFAULT_SOUNDS_BASE, INSTRUMENTS, OCTAVE_OFFSET, SALAMANDER_BASE, SAMPLED_TAALS, SHUDDHA, SwaralipiPlayer, TABLA_BPMS, TONEJS_INSTRUMENTS_BASE, buildSchedule, instrumentSampleUrl, midiToSampleName, nearestTablaBpm, normalizeBase, parseTonic, probeUrl, sampleFileName, santoorUrls, subsetUrls, svaraSemitone, svaraToMidi, tablaUrl };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map