musicxml-io 0.12.0 → 0.12.2

package/dist/chunk-626TXMVP.js

@@ -0,0 +1,706 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/query/playback-sequence.ts
+function parseEndingNumbers(numberStr) {
+  const numbers = [];
+  const parts = numberStr.split(/[,\s]+/);
+  for (const part of parts) {
+    if (part.includes("-")) {
+      const [start, end] = part.split("-").map((s) => parseInt(s.trim(), 10));
+      if (!isNaN(start) && !isNaN(end)) {
+        for (let i = start; i <= end; i++) {
+          numbers.push(i);
+        }
+      }
+    } else {
+      const num = parseInt(part.trim(), 10);
+      if (!isNaN(num)) {
+        numbers.push(num);
+      }
+    }
+  }
+  return numbers.length > 0 ? numbers : [1];
+}
+function parseJumpText(text) {
+  const t = text.toLowerCase().replace(/\s+/g, " ").trim();
+  if (t.includes("d.c. al coda") || t.includes("da capo al coda")) return "dc_al_coda";
+  if (t.includes("d.c. al fine") || t.includes("da capo al fine")) return "dc_al_fine";
+  if (t.includes("d.c.") || t.includes("da capo")) return "dc";
+  if (t.includes("d.s. al coda") || t.includes("dal segno al coda")) return "ds_al_coda";
+  if (t.includes("d.s. al fine") || t.includes("dal segno al fine")) return "ds_al_fine";
+  if (t.includes("d.s.") || t.includes("dal segno")) return "ds";
+  if (t === "fine") return "fine";
+  if (t.includes("to coda") || t.includes("al coda")) return "to_coda";
+  if (t === "coda" || t === "\u{1D14C}") return "coda";
+  if (t === "segno" || t === "\u{1D10B}") return "segno";
+  return null;
+}
+function getFirstWordsText(entry) {
+  for (const dt of entry.directionTypes) {
+    if (dt.kind === "words" && dt.text) return dt.text;
+  }
+  return void 0;
+}
+function hasDirectionKind(entry, kind) {
+  return entry.directionTypes.some((dt) => dt.kind === kind);
+}
+function extractPlaybackControls(part) {
+  const controls = {
+    repeatStarts: [],
+    repeatEnds: [],
+    voltas: [],
+    jumps: [],
+    segnoIndex: null,
+    codaIndex: null,
+    fineIndex: null,
+    toCodaIndex: null
+  };
+  const soundJumps = [];
+  for (let measureIndex = 0; measureIndex < part.measures.length; measureIndex++) {
+    const measure = part.measures[measureIndex];
+    if (measure.barlines) {
+      for (const barline of measure.barlines) {
+        if (barline.repeat) {
+          if (barline.repeat.direction === "forward") {
+            controls.repeatStarts.push(measureIndex);
+          } else if (barline.repeat.direction === "backward") {
+            controls.repeatEnds.push({
+              measureIndex,
+              times: _nullishCoalesce(barline.repeat.times, () => ( 2))
+            });
+          }
+        }
+        if (barline.ending) {
+          const numbers = parseEndingNumbers(barline.ending.number);
+          controls.voltas.push({
+            measureIndex,
+            numbers,
+            type: barline.ending.type
+          });
+        }
+      }
+    }
+    for (const entry of measure.entries) {
+      if (entry.type === "direction") {
+        const dir = entry;
+        if (hasDirectionKind(dir, "segno") && controls.segnoIndex === null) {
+          controls.segnoIndex = measureIndex;
+        }
+        if (hasDirectionKind(dir, "coda") && controls.codaIndex === null) {
+          controls.codaIndex = measureIndex;
+        }
+        const words = getFirstWordsText(dir);
+        if (words) {
+          const jt = parseJumpText(words);
+          if (jt === "fine") {
+            if (controls.fineIndex === null) controls.fineIndex = measureIndex;
+          } else if (jt === "to_coda") {
+            if (controls.toCodaIndex === null) controls.toCodaIndex = measureIndex;
+          } else if (jt === "coda") {
+            if (controls.codaIndex === null) controls.codaIndex = measureIndex;
+          } else if (jt === "segno") {
+            if (controls.segnoIndex === null) controls.segnoIndex = measureIndex;
+          } else if (jt) {
+            controls.jumps.push({ measureIndex, type: jt });
+          }
+        }
+      } else if (entry.type === "sound") {
+        const sound = entry;
+        if (sound.segno && controls.segnoIndex === null) controls.segnoIndex = measureIndex;
+        if (sound.coda && controls.codaIndex === null) controls.codaIndex = measureIndex;
+        if (sound.tocoda && controls.toCodaIndex === null) controls.toCodaIndex = measureIndex;
+        if (sound.fine && controls.fineIndex === null) controls.fineIndex = measureIndex;
+        if (sound.dacapo) soundJumps.push({ measureIndex, base: "dc" });
+        if (sound.dalsegno) soundJumps.push({ measureIndex, base: "ds" });
+      }
+    }
+  }
+  for (const sj of soundJumps) {
+    if (controls.jumps.some((j) => j.measureIndex === sj.measureIndex)) continue;
+    let type;
+    if (controls.fineIndex !== null) {
+      type = sj.base === "dc" ? "dc_al_fine" : "ds_al_fine";
+    } else if (controls.toCodaIndex !== null || controls.codaIndex !== null) {
+      type = sj.base === "dc" ? "dc_al_coda" : "ds_al_coda";
+    } else {
+      type = sj.base;
+    }
+    controls.jumps.push({ measureIndex: sj.measureIndex, type });
+  }
+  return controls;
+}
+function buildVoltaRanges(voltas, measureCount) {
+  const voltaRanges = /* @__PURE__ */ new Map();
+  let currentVoltaStart = null;
+  let currentVoltaNumbers = [];
+  for (const volta of voltas) {
+    if (volta.type === "start") {
+      currentVoltaStart = volta.measureIndex;
+      currentVoltaNumbers = volta.numbers;
+    } else if ((volta.type === "stop" || volta.type === "discontinue") && currentVoltaStart !== null) {
+      for (let i = currentVoltaStart; i <= volta.measureIndex; i++) {
+        voltaRanges.set(i, currentVoltaNumbers);
+      }
+      currentVoltaStart = null;
+    }
+  }
+  if (currentVoltaStart !== null) {
+    for (let i = currentVoltaStart; i < measureCount; i++) {
+      voltaRanges.set(i, currentVoltaNumbers);
+    }
+  }
+  return voltaRanges;
+}
+function generatePlaybackSequence(score, options) {
+  const partIndex = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _ => _.partIndex]), () => ( 0));
+  const part = score.parts[partIndex];
+  if (!part) return [];
+  const measureCount = part.measures.length;
+  const sequence = [];
+  if (measureCount === 0) return sequence;
+  const controls = extractPlaybackControls(part);
+  if (controls.repeatStarts.length === 0 && controls.repeatEnds.length === 0 && controls.voltas.length === 0 && controls.jumps.length === 0) {
+    for (let i = 0; i < measureCount; i++) {
+      sequence.push({ measureIndex: i, repeatIteration: 0 });
+    }
+    return sequence;
+  }
+  const voltaRanges = buildVoltaRanges(controls.voltas, measureCount);
+  const sortedRepeatStarts = [...controls.repeatStarts].sort((a, b) => a - b);
+  const sortedRepeatEnds = [...controls.repeatEnds].sort((a, b) => a.measureIndex - b.measureIndex);
+  const repeatSections = /* @__PURE__ */ new Map();
+  const voltaToRepeatEnd = /* @__PURE__ */ new Map();
+  const usedRepeatStarts = /* @__PURE__ */ new Set();
+  let lastRepeatEndMeasure = -1;
+  for (const repeatEnd of sortedRepeatEnds) {
+    let startIndex = null;
+    for (const startMeasure of sortedRepeatStarts) {
+      if (startMeasure <= repeatEnd.measureIndex && startMeasure > lastRepeatEndMeasure && !usedRepeatStarts.has(startMeasure)) {
+        startIndex = startMeasure;
+      } else if (startMeasure > repeatEnd.measureIndex) {
+        break;
+      }
+    }
+    if (startIndex === null) {
+      startIndex = lastRepeatEndMeasure + 1;
+    } else {
+      usedRepeatStarts.add(startIndex);
+    }
+    repeatSections.set(repeatEnd.measureIndex, {
+      startIndex,
+      times: repeatEnd.times
+    });
+    lastRepeatEndMeasure = repeatEnd.measureIndex;
+    voltaRanges.forEach((_iterations, voltaMeasure) => {
+      const isInsideRepeat = voltaMeasure >= startIndex && voltaMeasure <= repeatEnd.measureIndex;
+      const isImmediatelyAfter = voltaMeasure > repeatEnd.measureIndex && !voltaToRepeatEnd.has(voltaMeasure);
+      if (isInsideRepeat) {
+        voltaToRepeatEnd.set(voltaMeasure, repeatEnd.measureIndex);
+      } else if (isImmediatelyAfter) {
+        let belongsToLaterRepeat = false;
+        for (const otherEnd of sortedRepeatEnds) {
+          if (otherEnd.measureIndex > repeatEnd.measureIndex) {
+            const otherSection = repeatSections.get(otherEnd.measureIndex);
+            if (otherSection && voltaMeasure >= otherSection.startIndex && voltaMeasure <= otherEnd.measureIndex) {
+              belongsToLaterRepeat = true;
+              break;
+            }
+          }
+        }
+        if (!belongsToLaterRepeat) {
+          voltaToRepeatEnd.set(voltaMeasure, repeatEnd.measureIndex);
+        }
+      }
+    });
+  }
+  let currentMeasure = 0;
+  const repeatCounts = /* @__PURE__ */ new Map();
+  let lastRepeatEndIndex = null;
+  let lastRepeatIteration = 0;
+  let inRepeatJump = false;
+  let stopAtFine = false;
+  let jumpToCoda = false;
+  const maxIterations = measureCount * 10 + 10;
+  let iterations = 0;
+  while (currentMeasure < measureCount && iterations < maxIterations) {
+    iterations++;
+    const voltaIterations = voltaRanges.get(currentMeasure);
+    let repeatIteration = 0;
+    let inRepeatSection = false;
+    let currentRepeatEndIndex = null;
+    for (const [endIndex, section] of repeatSections) {
+      if (currentMeasure >= section.startIndex && currentMeasure <= endIndex) {
+        inRepeatSection = true;
+        currentRepeatEndIndex = endIndex;
+        repeatIteration = repeatCounts.get(endIndex) || 1;
+        break;
+      }
+    }
+    if (inRepeatSection && currentRepeatEndIndex !== null) {
+      lastRepeatEndIndex = currentRepeatEndIndex;
+      lastRepeatIteration = repeatIteration;
+    }
+    if (voltaIterations) {
+      let effectiveIteration = repeatIteration;
+      if (!inRepeatSection) {
+        const associatedRepeatEnd = voltaToRepeatEnd.get(currentMeasure);
+        if (associatedRepeatEnd !== void 0) {
+          effectiveIteration = repeatCounts.get(associatedRepeatEnd) || 1;
+        } else if (lastRepeatEndIndex !== null) {
+          effectiveIteration = lastRepeatIteration;
+        }
+      }
+      if (!voltaIterations.includes(effectiveIteration)) {
+        currentMeasure++;
+        continue;
+      }
+    }
+    sequence.push({
+      measureIndex: currentMeasure,
+      repeatIteration: inRepeatSection ? repeatIteration : 0
+    });
+    if (stopAtFine && controls.fineIndex === currentMeasure) {
+      break;
+    }
+    if (jumpToCoda && controls.toCodaIndex === currentMeasure && controls.codaIndex !== null) {
+      currentMeasure = controls.codaIndex;
+      jumpToCoda = false;
+      continue;
+    }
+    const repeatSection = repeatSections.get(currentMeasure);
+    if (repeatSection) {
+      const currentCount = repeatCounts.get(currentMeasure) || 1;
+      if (currentCount < repeatSection.times) {
+        repeatCounts.set(currentMeasure, currentCount + 1);
+        currentMeasure = repeatSection.startIndex;
+        continue;
+      }
+    }
+    if (voltaIterations && !inRepeatSection) {
+      const associatedRepeatEnd = voltaToRepeatEnd.get(currentMeasure);
+      if (associatedRepeatEnd !== void 0) {
+        const repeatSectionForVolta = repeatSections.get(associatedRepeatEnd);
+        if (repeatSectionForVolta) {
+          const currentCount = repeatCounts.get(associatedRepeatEnd) || 1;
+          if (currentCount < repeatSectionForVolta.times) {
+            repeatCounts.set(associatedRepeatEnd, currentCount + 1);
+            currentMeasure = repeatSectionForVolta.startIndex;
+            continue;
+          }
+        }
+      }
+    }
+    const jumpAtMeasure = controls.jumps.find((j) => j.measureIndex === currentMeasure);
+    if (jumpAtMeasure && !inRepeatJump) {
+      inRepeatJump = true;
+      switch (jumpAtMeasure.type) {
+        case "dc":
+          currentMeasure = 0;
+          continue;
+        case "dc_al_fine":
+          currentMeasure = 0;
+          stopAtFine = true;
+          continue;
+        case "dc_al_coda":
+          currentMeasure = 0;
+          jumpToCoda = true;
+          continue;
+        case "ds":
+          if (controls.segnoIndex !== null) {
+            currentMeasure = controls.segnoIndex;
+            continue;
+          }
+          break;
+        case "ds_al_fine":
+          if (controls.segnoIndex !== null) {
+            currentMeasure = controls.segnoIndex;
+            stopAtFine = true;
+            continue;
+          }
+          break;
+        case "ds_al_coda":
+          if (controls.segnoIndex !== null) {
+            currentMeasure = controls.segnoIndex;
+            jumpToCoda = true;
+            continue;
+          }
+          break;
+      }
+    }
+    currentMeasure++;
+  }
+  return sequence;
+}
+function hasPlaybackControls(score, options) {
+  const part = score.parts[_nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.partIndex]), () => ( 0))];
+  if (!part) return false;
+  const controls = extractPlaybackControls(part);
+  return controls.repeatStarts.length > 0 || controls.repeatEnds.length > 0 || controls.voltas.length > 0 || controls.jumps.length > 0 || controls.segnoIndex !== null || controls.codaIndex !== null;
+}
+
+// src/query/playback-timeline.ts
+var DEFAULT_FERMATA_HOLD = 1.75;
+var DEFAULT_CAESURA_SECONDS = 0.4;
+var DEFAULT_BREATH_SECONDS = 0.25;
+var DEFAULT_RAMP_STEPS = 12;
+function metronomeBpm(perMinute) {
+  if (perMinute === void 0) return null;
+  const bpm = typeof perMinute === "number" ? perMinute : parseFloat(perMinute);
+  return isNaN(bpm) ? null : bpm;
+}
+function measureMaxPosition(measure) {
+  let position = 0;
+  let max = 0;
+  for (const entry of measure.entries) {
+    if (entry.type === "note") {
+      if (!entry.chord && !entry.grace) {
+        position += entry.duration;
+        if (position > max) max = position;
+      }
+    } else if (entry.type === "backup") {
+      position -= entry.duration;
+    } else if (entry.type === "forward") {
+      position += entry.duration;
+      if (position > max) max = position;
+    }
+  }
+  return max;
+}
+function findTimeSignature(part, measureNumber) {
+  const targetMeasure = parseInt(String(measureNumber), 10);
+  let time;
+  for (const measure of part.measures) {
+    const mNum = parseInt(measure.number, 10);
+    if (!isNaN(targetMeasure) && !isNaN(mNum) && mNum > targetMeasure) break;
+    if (_optionalChain([measure, 'access', _3 => _3.attributes, 'optionalAccess', _4 => _4.time])) {
+      time = {
+        beats: parseInt(measure.attributes.time.beats, 10) || 4,
+        beatType: measure.attributes.time.beatType
+      };
+    }
+  }
+  return time;
+}
+function measureEndTick(measure, part, divisions, measureStartTick, maxPosition, ticksPerQuarterNote) {
+  const actualTicks = Math.round(maxPosition * ticksPerQuarterNote / divisions);
+  if (actualTicks > 0) {
+    return measureStartTick + actualTicks;
+  }
+  if (!measure.implicit) {
+    const timeAttrs = findTimeSignature(part, measure.number);
+    if (timeAttrs) {
+      const measureDuration = timeAttrs.beats / timeAttrs.beatType * 4 * divisions;
+      const calculatedTicks = Math.round(measureDuration * ticksPerQuarterNote / divisions);
+      return measureStartTick + calculatedTicks;
+    }
+  }
+  return measureStartTick;
+}
+function hasFermata(note) {
+  return _nullishCoalesce(_optionalChain([note, 'access', _5 => _5.notations, 'optionalAccess', _6 => _6.some, 'call', _7 => _7((n) => n.type === "fermata")]), () => ( false));
+}
+function pauseArticulation(note) {
+  if (!note.notations) return null;
+  for (const n of note.notations) {
+    if (n.type === "articulation") {
+      if (n.articulation === "caesura") return "caesura";
+      if (n.articulation === "breath-mark") return "breath";
+    }
+  }
+  return null;
+}
+function tempoRampWord(text) {
+  const t = text.trim().toLowerCase().replace(/[.\s]+$/, "");
+  if (!t) return null;
+  if (/^(rit|riten|rall|allarg|slarg|cala|smorz|morend)/.test(t)) return "rit";
+  if (/^(accel|string|affret|incalz|pi[uù]\s*mosso)/.test(t)) return "accel";
+  return null;
+}
+function buildGridTimeline(score, ticksPerQuarterNote, sequence, options = {}) {
+  const rawTempo = [];
+  const measures = [];
+  const rampMarkers = [];
+  const stretches = [];
+  if (score.parts.length === 0) {
+    return { tempoEvents: [], measures, totalTicks: 0, expressions: [] };
+  }
+  const fermataHold = _nullishCoalesce(options.fermataHoldMultiplier, () => ( DEFAULT_FERMATA_HOLD));
+  const caesuraSeconds = _nullishCoalesce(options.caesuraSeconds, () => ( DEFAULT_CAESURA_SECONDS));
+  const breathSeconds = _nullishCoalesce(options.breathSeconds, () => ( DEFAULT_BREATH_SECONDS));
+  const rampSteps = Math.max(1, Math.round(_nullishCoalesce(options.tempoRampSteps, () => ( DEFAULT_RAMP_STEPS))));
+  const defaultTempo = _nullishCoalesce(options.defaultTempo, () => ( 120));
+  const part = score.parts[0];
+  let divisions = 1;
+  let currentTick = 0;
+  let prevailingBpm = defaultTempo;
+  const pauseFactor = (windowTicks, bpm, pauseSeconds) => {
+    const baseSeconds = windowTicks / ticksPerQuarterNote * (60 / bpm);
+    if (baseSeconds <= 0) return 1;
+    return (baseSeconds + pauseSeconds) / baseSeconds;
+  };
+  for (const { measureIndex, repeatIteration } of sequence) {
+    const measure = part.measures[measureIndex];
+    if (!measure) continue;
+    if (_optionalChain([measure, 'access', _8 => _8.attributes, 'optionalAccess', _9 => _9.divisions])) {
+      divisions = measure.attributes.divisions;
+    }
+    const measureStartTick = currentTick;
+    let position = 0;
+    let chordBasePosition = 0;
+    const tickAt = (pos) => measureStartTick + Math.round(pos * ticksPerQuarterNote / divisions);
+    for (const entry of measure.entries) {
+      if (entry.type === "direction") {
+        for (const dirType of entry.directionTypes) {
+          if (dirType.kind === "metronome") {
+            const bpm = metronomeBpm(dirType.perMinute);
+            if (bpm !== null) {
+              rawTempo.push({ tick: tickAt(position), bpm });
+              prevailingBpm = bpm;
+            }
+          } else if (dirType.kind === "words") {
+            const kind = tempoRampWord(dirType.text);
+            if (kind) rampMarkers.push({ tick: tickAt(position), kind });
+          }
+        }
+        if (_optionalChain([entry, 'access', _10 => _10.sound, 'optionalAccess', _11 => _11.tempo])) {
+          rawTempo.push({ tick: tickAt(position), bpm: entry.sound.tempo });
+          prevailingBpm = entry.sound.tempo;
+        }
+      } else if (entry.type === "sound") {
+        if (entry.tempo) {
+          rawTempo.push({ tick: tickAt(position), bpm: entry.tempo });
+          prevailingBpm = entry.tempo;
+        }
+      } else if (entry.type === "note") {
+        const notePos = entry.chord ? chordBasePosition : position;
+        const noteStartTick = tickAt(notePos);
+        const noteEndTick = tickAt(notePos + entry.duration);
+        if (noteEndTick > noteStartTick) {
+          if (fermataHold !== 1 && hasFermata(entry)) {
+            stretches.push({
+              startTick: noteStartTick,
+              endTick: noteEndTick,
+              factor: fermataHold,
+              type: "fermata"
+            });
+          }
+          const pause = pauseArticulation(entry);
+          if (pause) {
+            const seconds = pause === "caesura" ? caesuraSeconds : breathSeconds;
+            if (seconds > 0) {
+              const window = Math.min(noteEndTick - noteStartTick, ticksPerQuarterNote);
+              stretches.push({
+                startTick: noteEndTick - window,
+                endTick: noteEndTick,
+                factor: pauseFactor(window, prevailingBpm, seconds),
+                type: pause
+              });
+            }
+          }
+        }
+        if (!entry.chord) {
+          chordBasePosition = position;
+          position += entry.duration;
+        }
+      } else if (entry.type === "backup") {
+        position -= entry.duration;
+      } else if (entry.type === "forward") {
+        position += entry.duration;
+      }
+    }
+    const endTick = measureEndTick(
+      measure,
+      part,
+      divisions,
+      measureStartTick,
+      measureMaxPosition(measure),
+      ticksPerQuarterNote
+    );
+    measures.push({
+      measureIndex,
+      repeatIteration,
+      measureNumber: measure.number,
+      startTick: measureStartTick,
+      endTick
+    });
+    currentTick = endTick;
+  }
+  const { tempoEvents, expressions } = bakeTempoMap(
+    rawTempo,
+    rampMarkers,
+    stretches,
+    defaultTempo,
+    rampSteps
+  );
+  return { tempoEvents, measures, totalTicks: currentTick, expressions };
+}
+function bakeTempoMap(rawTempo, rampMarkers, stretches, defaultTempo, rampSteps) {
+  const sortedRaw = [...rawTempo].sort((a, b) => a.tick - b.tick);
+  const startBpm = sortedRaw.length > 0 && sortedRaw[0].tick === 0 ? sortedRaw[0].bpm : defaultTempo;
+  const baseChanges = [{ tick: 0, bpm: startBpm }];
+  let lastBpm = startBpm;
+  for (const ev of sortedRaw) {
+    if (ev.tick === 0) continue;
+    if (ev.bpm === lastBpm) continue;
+    if (baseChanges[baseChanges.length - 1].tick === ev.tick) {
+      baseChanges[baseChanges.length - 1].bpm = ev.bpm;
+    } else {
+      baseChanges.push({ tick: ev.tick, bpm: ev.bpm });
+    }
+    lastBpm = ev.bpm;
+  }
+  const baseBpmAt = (tick) => {
+    let i = baseChanges.length - 1;
+    while (i > 0 && baseChanges[i].tick > tick) i--;
+    return baseChanges[i].bpm;
+  };
+  const rampExpressions = [];
+  const rampPoints = [];
+  for (const marker of rampMarkers) {
+    const from = baseBpmAt(marker.tick);
+    const next = baseChanges.find((c) => c.tick > marker.tick && c.bpm !== from);
+    if (!next) continue;
+    const span = next.tick - marker.tick;
+    if (span <= 0) continue;
+    for (let k = 1; k < rampSteps; k++) {
+      const tick = Math.round(marker.tick + span * k / rampSteps);
+      if (tick <= marker.tick || tick >= next.tick) continue;
+      const bpm = from + (next.bpm - from) * k / rampSteps;
+      rampPoints.push({ tick, bpm });
+    }
+    rampExpressions.push({ type: marker.kind, startTick: marker.tick, endTick: next.tick });
+  }
+  const baseTicks = new Set(baseChanges.map((c) => c.tick));
+  const stepList = [...baseChanges];
+  for (const p of rampPoints) {
+    if (!baseTicks.has(p.tick)) stepList.push(p);
+  }
+  stepList.sort((a, b) => a.tick - b.tick);
+  const stepBpmAt = (tick) => {
+    let i = stepList.length - 1;
+    while (i > 0 && stepList[i].tick > tick) i--;
+    return stepList[i].bpm;
+  };
+  const boundaries = new Set(stepList.map((s) => s.tick));
+  for (const s of stretches) {
+    boundaries.add(s.startTick);
+    boundaries.add(s.endTick);
+  }
+  const sortedBoundaries = [...boundaries].sort((a, b) => a - b);
+  const tempoEvents = [];
+  let emittedBpm = null;
+  for (const tick of sortedBoundaries) {
+    let bpm = stepBpmAt(tick);
+    for (const s of stretches) {
+      if (tick >= s.startTick && tick < s.endTick) bpm /= s.factor;
+    }
+    if (emittedBpm === null || bpm !== emittedBpm) {
+      tempoEvents.push({ tick, bpm });
+      emittedBpm = bpm;
+    }
+  }
+  const expressions = [
+    ...stretches.map((s) => ({ type: s.type, startTick: s.startTick, endTick: s.endTick })),
+    ...rampExpressions
+  ].sort((a, b) => a.startTick - b.startTick || a.endTick - b.endTick);
+  return { tempoEvents, expressions };
+}
+function bpmToUsPerQuarter(bpm) {
+  return Math.round(6e7 / bpm);
+}
+function makeTickToSec(tempoEvents, defaultTempo, ticksPerQuarterNote) {
+  const sorted = [...tempoEvents].sort((a, b) => a.tick - b.tick);
+  const startBpm = sorted.length > 0 && sorted[0].tick === 0 ? sorted[0].bpm : defaultTempo;
+  const changes = [
+    { tick: 0, usPerQuarter: bpmToUsPerQuarter(startBpm) }
+  ];
+  let lastBpm = startBpm;
+  for (const ev of sorted) {
+    if (ev.tick === 0) continue;
+    if (ev.bpm === lastBpm) continue;
+    changes.push({ tick: ev.tick, usPerQuarter: bpmToUsPerQuarter(ev.bpm) });
+    lastBpm = ev.bpm;
+  }
+  const secPerTick = (usPerQuarter) => usPerQuarter / 1e6 / ticksPerQuarterNote;
+  const cumSec = [0];
+  for (let i = 1; i < changes.length; i++) {
+    const dTick = changes[i].tick - changes[i - 1].tick;
+    cumSec[i] = cumSec[i - 1] + dTick * secPerTick(changes[i - 1].usPerQuarter);
+  }
+  return (tick) => {
+    let i = changes.length - 1;
+    while (i > 0 && changes[i].tick > tick) i--;
+    return cumSec[i] + (tick - changes[i].tick) * secPerTick(changes[i].usPerQuarter);
+  };
+}
+function buildTimingSidecar(grid, defaultTempo, ticksPerQuarterNote) {
+  const tickToSec = makeTickToSec(grid.tempoEvents, defaultTempo, ticksPerQuarterNote);
+  const breakpoints = [];
+  const measureStartTicks = new Set(grid.measures.map((m) => m.startTick));
+  for (const m of grid.measures) {
+    breakpoints.push({
+      midiSec: tickToSec(m.startTick),
+      quarterPos: m.startTick / ticksPerQuarterNote,
+      measureNumber: m.measureNumber,
+      beatInMeasure: 0,
+      repeatIteration: m.repeatIteration
+    });
+  }
+  for (const ev of grid.tempoEvents) {
+    if (measureStartTicks.has(ev.tick)) continue;
+    const m = grid.measures.find((mm) => ev.tick >= mm.startTick && ev.tick < mm.endTick);
+    if (!m) continue;
+    breakpoints.push({
+      midiSec: tickToSec(ev.tick),
+      quarterPos: ev.tick / ticksPerQuarterNote,
+      measureNumber: m.measureNumber,
+      beatInMeasure: (ev.tick - m.startTick) / ticksPerQuarterNote,
+      repeatIteration: m.repeatIteration
+    });
+  }
+  const last = grid.measures[grid.measures.length - 1];
+  breakpoints.push({
+    midiSec: tickToSec(grid.totalTicks),
+    quarterPos: grid.totalTicks / ticksPerQuarterNote,
+    measureNumber: last ? last.measureNumber : "0",
+    beatInMeasure: last ? (grid.totalTicks - last.startTick) / ticksPerQuarterNote : 0,
+    repeatIteration: last ? last.repeatIteration : 0
+  });
+  breakpoints.sort((a, b) => a.midiSec - b.midiSec || a.quarterPos - b.quarterPos);
+  const sidecar = {
+    version: "1",
+    durationSec: tickToSec(grid.totalTicks),
+    ticksPerQuarterNote,
+    breakpoints
+  };
+  if (grid.expressions.length > 0) {
+    sidecar.expressions = grid.expressions.map((e) => ({
+      type: e.type,
+      fromMidiSec: tickToSec(e.startTick),
+      toMidiSec: tickToSec(e.endTick)
+    })).sort((a, b) => a.fromMidiSec - b.fromMidiSec || a.toMidiSec - b.toMidiSec);
+  }
+  return sidecar;
+}
+function generatePlaybackTimeline(score, options = {}) {
+  const ticksPerQuarterNote = _nullishCoalesce(options.ticksPerQuarterNote, () => ( 480));
+  const defaultTempo = _nullishCoalesce(options.defaultTempo, () => ( 120));
+  const sequence = generatePlaybackSequence(score);
+  const grid = buildGridTimeline(score, ticksPerQuarterNote, sequence, {
+    defaultTempo,
+    fermataHoldMultiplier: options.fermataHoldMultiplier,
+    caesuraSeconds: options.caesuraSeconds,
+    breathSeconds: options.breathSeconds,
+    tempoRampSteps: options.tempoRampSteps
+  });
+  return buildTimingSidecar(grid, defaultTempo, ticksPerQuarterNote);
+}
+
+
+
+
+
+
+
+
+
+
+exports.extractPlaybackControls = extractPlaybackControls; exports.generatePlaybackSequence = generatePlaybackSequence; exports.hasPlaybackControls = hasPlaybackControls; exports.measureEndTick = measureEndTick; exports.buildGridTimeline = buildGridTimeline; exports.bpmToUsPerQuarter = bpmToUsPerQuarter; exports.buildTimingSidecar = buildTimingSidecar; exports.generatePlaybackTimeline = generatePlaybackTimeline;