@viritura/score-engine 0.1.1-next.29 → 0.1.1-next.31

package/dist/index.js

@@ -2213,9 +2213,9 @@ function interpolateBeatAnchors(bounds, beat, endX) {
 
 // packages/score-engine/src/buildInfo.ts
 init_define_import_meta_env();
-var PACKAGE_VERSION = "0.1.1-next.29", BUNDLE_WORKER_FILE = "score-engine.worker.js";
+var PACKAGE_VERSION = "0.1.1-next.31", BUNDLE_WORKER_FILE = "score-engine.worker.js";
 function buildCommit() {
-  return "861ac5447e15b8f748d78775a893a6bda2f11d6d";
+  return "90b89f13680a7855b46725024057cc9919dfbc20";
 }
 function bundledAssetBase() {
   let moduleUrl = import.meta.url;
@@ -16244,19 +16244,575 @@ init_define_import_meta_env();
 
 // packages/midi/src/repeatExpansion.ts
 init_define_import_meta_env();
-function expandMeasureOrder(globalMeasures, hints) {
-  if (globalMeasures.length === 0) return [];
-  let order = expandRepeats(globalMeasures);
-  return expandJumps(globalMeasures, order, hints?.toCodaMeasureIndex);
+
+// packages/midi/src/cadenzaTiming.ts
+init_define_import_meta_env();
+
+// packages/midi/src/tempoMap.ts
+init_define_import_meta_env();
+
+// packages/midi/src/tempoModel.ts
+init_define_import_meta_env();
+var bpmToSpb = (bpm) => 60 / bpm;
+function integrateTime(b0, b, bpm0, slope) {
+  let db = b - b0;
+  if (Math.abs(slope) < 1e-6) return bpmToSpb(bpm0) * db;
+  let bpmB = bpm0 + slope * db;
+  return 60 / slope * Math.log(bpmB / bpm0);
 }
-function detectToCodaMeasureIndex(score) {
-  for (let part of score.parts)
-    for (let i = 0; i < part.measures.length; i++) {
-      let expressions = part.measures[i]?.expressions;
-      if (!(!expressions || expressions.length === 0) && expressions.some((expr) => /\bto\s*coda\b/i.test(plainTextContent(expr.text))))
-        return i;
+function inverseBeat(dt, bpm0, slope) {
+  return Math.abs(slope) < 1e-6 ? dt * bpm0 / 60 : (bpm0 * Math.exp(dt * slope / 60) - bpm0) / slope;
+}
+var TempoModel = class _TempoModel {
+  knots;
+  constructor(knots) {
+    this.knots = knots;
+  }
+  /** Realize selected source-beat intervals on one continuous performance axis. */
+  static concatenate(source, spans) {
+    let regions = [], insertions = [], outputBeat = 0;
+    for (let span of spans) {
+      let boundaries = [
+        span.startBeat,
+        ...source.knots.filter((knot) => knot.beat > span.startBeat && knot.beat < span.endBeat).map((knot) => knot.beat),
+        span.endBeat
+      ];
+      for (let index = 0; index < boundaries.length - 1; index++) {
+        let start = boundaries[index], end = boundaries[index + 1], knot = source.knots[source.knotIndexForBeat(start)], bpm = knot.bpm + knot.slope * (start - knot.beat);
+        regions.push({
+          startBeat: outputBeat + start - span.startBeat,
+          endBeat: outputBeat + end - span.startBeat,
+          startBpm: bpm,
+          endBpm: bpm + knot.slope * (end - start)
+        });
+      }
+      for (let knot of source.knots)
+        knot.beat > span.startBeat && knot.beat <= span.endBeat && knot.insertBefore > 0 && insertions.push({ beat: outputBeat + knot.beat - span.startBeat, seconds: knot.insertBefore });
+      outputBeat += span.endBeat - span.startBeat;
+    }
+    let last = regions.at(-1);
+    return last && regions.push({ startBeat: outputBeat, endBeat: 1 / 0, startBpm: last.endBpm, endBpm: last.endBpm }), _TempoModel.build(regions, insertions);
+  }
+  /**
+   * Build a model from tempo regions and point insertions.
+   *
+   * `regions` need not be pre-sorted or gapless; they are sorted by `startBeat`
+   * and gaps are filled by extending the previous tempo (a held constant). The
+   * first region's start tempo applies from beat 0. `insertions` are point gaps
+   * (caesuras) keyed by beat.
+   */
+  static build(regions, insertions = []) {
+    let sorted = [...regions].sort((a, b) => a.startBeat - b.startBeat), insByBeat = /* @__PURE__ */ new Map();
+    for (let ins of insertions)
+      ins.seconds > 0 && insByBeat.set(ins.beat, (insByBeat.get(ins.beat) ?? 0) + ins.seconds);
+    let boundarySet = /* @__PURE__ */ new Set([0]);
+    for (let r of sorted) boundarySet.add(r.startBeat);
+    for (let ins of insByBeat.keys()) boundarySet.add(ins);
+    let boundaries = [...boundarySet].sort((a, b) => a - b), tempoAt = (beat) => {
+      let active;
+      for (let r of sorted)
+        if (r.startBeat <= beat + 1e-9) active = r;
+        else break;
+      if (!active) {
+        let first = sorted[0];
+        return { bpm: first ? first.startBpm : 120, slope: 0 };
+      }
+      let span = active.endBeat - active.startBeat, slope = span > 0 && Number.isFinite(span) ? (active.endBpm - active.startBpm) / span : 0;
+      return { bpm: active.startBpm + slope * (beat - active.startBeat), slope };
+    }, knots = [], time = 0, prevBeat = boundaries[0], prev = tempoAt(prevBeat), ins0 = insByBeat.get(prevBeat) ?? 0;
+    time += ins0, knots.push({ beat: prevBeat, time, bpm: prev.bpm, slope: prev.slope, insertBefore: ins0 });
+    for (let i = 1; i < boundaries.length; i++) {
+      let beat = boundaries[i];
+      time += integrateTime(prevBeat, beat, prev.bpm, prev.slope);
+      let ins = insByBeat.get(beat) ?? 0;
+      time += ins;
+      let t = tempoAt(beat);
+      knots.push({ beat, time, bpm: t.bpm, slope: t.slope, insertBefore: ins }), prevBeat = beat, prev = t;
+    }
+    return new _TempoModel(knots);
+  }
+  /** Index of the last knot whose beat ≤ `beat`. */
+  knotIndexForBeat(beat) {
+    let k = this.knots, lo = 0, hi = k.length - 1, ans = 0;
+    for (; lo <= hi; ) {
+      let mid = lo + hi >> 1;
+      k[mid].beat <= beat + 1e-9 ? (ans = mid, lo = mid + 1) : hi = mid - 1;
+    }
+    return ans;
+  }
+  /** Index of the last knot whose time ≤ `time`. */
+  knotIndexForTime(time) {
+    let k = this.knots, lo = 0, hi = k.length - 1, ans = 0;
+    for (; lo <= hi; ) {
+      let mid = lo + hi >> 1;
+      k[mid].time <= time + 1e-9 ? (ans = mid, lo = mid + 1) : hi = mid - 1;
+    }
+    return ans;
+  }
+  /**
+   * Absolute time (seconds) at a global quarter-note beat.
+   *
+   * `endpoint` selects how a point insertion EXACTLY at `beat` is treated:
+   *  - `"onset"` (default): time AFTER the insertion — what an event STARTING at
+   *    `beat` wants (it begins once the gap is over).
+   *  - `"release"`: time BEFORE the insertion — what a note ENDING at `beat`
+   *    wants (a caesura/gap at the release point isn't part of the note).
+   */
+  timeAtBeat(beat, endpoint = "onset") {
+    let i = this.knotIndexForBeat(beat), knot = this.knots[i], base = knot.time + integrateTime(knot.beat, beat, knot.bpm, knot.slope);
+    return endpoint === "release" && Math.abs(knot.beat - beat) < 1e-9 ? base - knot.insertBefore : base;
+  }
+  /**
+   * Seconds elapsed over `[beat, beat + beats)` — a note/event DURATION. The end
+   * uses release semantics so a point insertion (caesura) exactly at the release
+   * beat is not absorbed into the note's sounding length.
+   */
+  secondsForBeats(beat, beats) {
+    return this.timeAtBeat(beat + beats, "release") - this.timeAtBeat(beat);
+  }
+  /**
+   * Global quarter-note beat at an absolute time (inverse of {@link timeAtBeat}).
+   * Within a point-insertion gap, returns the insertion's beat (position is
+   * frozen during a caesura).
+   */
+  beatAtTime(time) {
+    let i = this.knotIndexForTime(time), knot = this.knots[i], next = this.knots[i + 1];
+    if (next) {
+      let musicEnd = next.time - next.insertBefore;
+      if (time >= musicEnd - 1e-9) return next.beat;
     }
-  return -1;
+    return knot.beat + inverseBeat(time - knot.time, knot.bpm, knot.slope);
+  }
+  /** Seconds-per-quarter-note beat at a global beat. */
+  spbAtBeat(beat) {
+    let i = this.knotIndexForBeat(beat), knot = this.knots[i], bpmHere = knot.bpm + knot.slope * (beat - knot.beat);
+    return bpmToSpb(bpmHere);
+  }
+  /** Quarter-note BPM at a global beat. */
+  bpmAtBeat(beat) {
+    return 60 / this.spbAtBeat(beat);
+  }
+  /**
+   * Generate click times (seconds) for a metronome / studio click track over
+   * `[startBeat, endBeat)`. `clickBeats` are the beat positions to click,
+   * expressed as offsets within each "grid step" — but for the common case
+   * callers pass a flat list of global beat positions and we just map them.
+   * Returns the absolute time of every beat in `beats`.
+   */
+  clickTimes(beats) {
+    return beats.map((b) => this.timeAtBeat(b));
+  }
+};
+
+// packages/midi/src/tempoMap.ts
+function playbackNominalTime(gm) {
+  return gm.__playbackNominalTime;
+}
+var DEFAULT_BPM = 120, DEFAULT_TIME = { count: 4, unit: 4 };
+function measureBeatsFromTime(ts) {
+  return ts.count * 4 / ts.unit;
+}
+function tempoNoteBeats(base, dots) {
+  let baseBeats = DURATION_BEATS[base] ?? 1;
+  return dots ? baseBeats * (2 - Math.pow(2, -dots)) : baseBeats;
+}
+function effectiveQpm(bpm, tempoBase, tempoDots) {
+  return bpm * tempoNoteBeats(tempoBase, tempoDots);
+}
+function buildTempoMap(globalMeasures, holds) {
+  let tempoMap = [], measureStartTimes = [], currentQpm = DEFAULT_BPM, currentSpq = 60 / currentQpm, currentTime = { count: DEFAULT_TIME.count, unit: DEFAULT_TIME.unit }, absoluteTime = 0, hasInitialTempo = !1;
+  for (let m = 0; m < globalMeasures.length; m++) {
+    let gm = globalMeasures[m], nominalTime = playbackNominalTime(gm) ?? gm.time;
+    nominalTime && (currentTime = { count: nominalTime.count, unit: nominalTime.unit });
+    let mBeats = measureBeatsFromTime(gm.time ?? currentTime);
+    measureStartTimes.push(absoluteTime);
+    let measureStartSpq = currentSpq, changes = [];
+    if (gm.tempos && gm.tempos.length > 0) {
+      for (let tempo of gm.tempos) {
+        let beatOffset = tempo.location ? tempo.location.fraction[0] / tempo.location.fraction[1] * mBeats : 0, qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
+        changes.push({ beatOffset, qpm });
+      }
+      changes.sort((a, b) => a.beatOffset - b.beatOffset);
+    }
+    let beatCursor = 0;
+    for (let change of changes)
+      change.beatOffset > beatCursor && (absoluteTime += (change.beatOffset - beatCursor) * currentSpq, beatCursor = change.beatOffset), tempoMap.push({
+        measureIndex: m,
+        beatInMeasure: change.beatOffset,
+        timeSeconds: absoluteTime,
+        bpm: change.qpm
+      }), m === 0 && change.beatOffset === 0 && (hasInitialTempo = !0), currentQpm = change.qpm, currentSpq = 60 / currentQpm;
+    mBeats > beatCursor && (absoluteTime += (mBeats - beatCursor) * currentSpq);
+    let measureHolds = holds?.[m];
+    if (measureHolds)
+      for (let hold of measureHolds)
+        absoluteTime += hold.extraBeats * measureStartSpq;
+  }
+  return hasInitialTempo || tempoMap.unshift({
+    measureIndex: 0,
+    beatInMeasure: 0,
+    timeSeconds: 0,
+    bpm: DEFAULT_BPM
+  }), { tempoMap, measureStartTimes };
+}
+function buildTempoModel(globalMeasures, holds) {
+  let regions = [], measureStartBeats = [], cumBeats = 0, currentTime = { count: DEFAULT_TIME.count, unit: DEFAULT_TIME.unit }, gradualDecls = [];
+  for (let m = 0; m < globalMeasures.length; m++) {
+    let gm = globalMeasures[m], nominalTime = playbackNominalTime(gm) ?? gm.time;
+    nominalTime && (currentTime = { count: nominalTime.count, unit: nominalTime.unit });
+    let mBeats = measureBeatsFromTime(gm.time ?? currentTime);
+    if (measureStartBeats.push(cumBeats), gm.tempos && gm.tempos.length > 0) {
+      let sorted = [...gm.tempos].sort((a, b) => tempoBeat(a, mBeats) - tempoBeat(b, mBeats));
+      for (let tempo of sorted) {
+        let startBeat = cumBeats + tempoBeat(tempo, mBeats), qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
+        regions.push({ startBeat, endBeat: 1 / 0, startBpm: qpm, endBpm: qpm });
+      }
+    }
+    gm.gradualTempo && gradualDecls.push({
+      declIdx: m,
+      gt: gm.gradualTempo,
+      startBeat: cumBeats + posBeats(gm.gradualTempo.position.fraction)
+    }), cumBeats += mBeats;
+  }
+  if ((regions.length === 0 || regions.every((r) => r.startBeat > 1e-9)) && regions.unshift({ startBeat: 0, endBeat: 1 / 0, startBpm: DEFAULT_BPM, endBpm: DEFAULT_BPM }), gradualDecls.length > 0) {
+    let idToIdx = buildMeasureIdToIndex(globalMeasures), constModel = TempoModel.build(regions);
+    for (let { declIdx, gt, startBeat } of gradualDecls) {
+      let endBeat = resolveGradualEndBeat(gt.end, declIdx, globalMeasures, measureStartBeats, idToIdx);
+      if (endBeat === void 0 || endBeat <= startBeat + 1e-9) continue;
+      let startBpm = gt.startBpm ?? constModel.bpmAtBeat(startBeat);
+      regions.push({ startBeat, endBeat, startBpm, endBpm: gt.endBpm }), regions.some((r) => Math.abs(r.startBeat - endBeat) < 1e-9) || regions.push({ startBeat: endBeat, endBeat: 1 / 0, startBpm: gt.endBpm, endBpm: gt.endBpm });
+    }
+  }
+  regions.sort((a, b) => a.startBeat - b.startBeat);
+  for (let i = 0; i < regions.length - 1; i++)
+    regions[i].endBeat = regions[i + 1].startBeat;
+  let regionsModel = TempoModel.build(regions), insertions = [];
+  if (holds)
+    for (let m = 0; m < holds.length; m++) {
+      let measureHolds = holds[m];
+      if (!measureHolds || measureHolds.length === 0) continue;
+      let startBeat = measureStartBeats[m], spb = regionsModel.spbAtBeat(startBeat);
+      for (let hold of measureHolds)
+        insertions.push({ beat: startBeat + hold.atBeat, seconds: hold.extraBeats * spb });
+    }
+  let model = insertions.length > 0 ? TempoModel.build(regions, insertions) : regionsModel, measureStartTimes = measureStartBeats.map((b) => model.timeAtBeat(b));
+  return { model, measureStartTimes, measureStartBeats, totalBeats: cumBeats };
+}
+function posBeats(frac) {
+  return !frac || frac[1] === 0 ? 0 : frac[0] / frac[1] * 4;
+}
+function buildMeasureIdToIndex(globalMeasures) {
+  let m = /* @__PURE__ */ new Map();
+  return globalMeasures.forEach((gm, i) => {
+    gm.id && !m.has(gm.id) && m.set(gm.id, i);
+  }), m;
+}
+function resolveGradualEndBeat(end, fromIdx, globalMeasures, measureStartBeats, idToIdx) {
+  let idx = idToIdx.get(end.measure);
+  if (idx === void 0) {
+    let parsed = Number.parseInt(end.measure, 10);
+    !Number.isNaN(parsed) && parsed >= 0 && parsed < globalMeasures.length && (idx = parsed);
+  }
+  idx === void 0 && (idx = fromIdx);
+  let start = measureStartBeats[idx];
+  if (start !== void 0)
+    return start + posBeats(end.position.fraction);
+}
+function tempoBeat(tempo, mBeats) {
+  return tempo.location ? tempo.location.fraction[0] / tempo.location.fraction[1] * mBeats : 0;
+}
+
+// packages/midi/src/cadenzaTiming.ts
+function contentBeats(content) {
+  let beats = 0;
+  for (let item of content)
+    switch (item.type) {
+      case "event":
+        beats += durationBeats2(item.duration.base, item.duration.dots);
+        break;
+      case "space":
+        beats += item.duration[0] / item.duration[1] * 4;
+        break;
+      case "tuplet":
+      case "tremolo":
+        beats += durationBeats2(item.outer.duration.base, item.outer.duration.dots) * item.outer.multiple;
+        break;
+      case "grace":
+        break;
+    }
+  return beats;
+}
+function durationBeats2(base, dots) {
+  let beats = DURATION_BEATS[base];
+  return dots ? beats * (2 - Math.pow(2, -dots)) : beats;
+}
+function writtenMeasureBeats(score, measureIndex, minimumBeats) {
+  return score.parts.reduce((maxBeats, part) => {
+    let measure = part.measures[measureIndex];
+    return measure ? Math.max(
+      maxBeats,
+      ...measure.sequences.filter((sequence) => !sequence.fullMeasure).map((sequence) => contentBeats(sequence.content))
+    ) : maxBeats;
+  }, minimumBeats);
+}
+function playbackGlobalMeasures(score, measureOrder) {
+  let activeBeats = 4, activeTime = { count: 4, unit: 4 }, activeTempo = {
+    bpm: DEFAULT_BPM,
+    value: { base: "quarter" }
+  }, resolved = score.global.measures.map((original, measureIndex) => {
+    original.time && (activeTime = original.time);
+    let measure = {
+      ...original,
+      time: { ...activeTime },
+      tempos: original.tempos?.some((tempo) => !tempo.location || tempo.location.fraction[0] === 0) ? original.tempos : [{ ...activeTempo, location: { fraction: [0, 1] } }, ...original.tempos ?? []]
+    };
+    if (original.tempos?.length && (activeTempo = [...original.tempos].sort(
+      (a, b) => (a.location?.fraction[0] ?? 0) / (a.location?.fraction[1] ?? 1) - (b.location?.fraction[0] ?? 0) / (b.location?.fraction[1] ?? 1)
+    ).at(-1)), measure.time && (activeBeats = measure.time.count * 4 / measure.time.unit), measureIndex === 0 && measure.number === 0) {
+      let pickupBeats = writtenMeasureBeats(score, measureIndex, 0);
+      if (pickupBeats > 0)
+        return {
+          ...measure,
+          __playbackNominalTime: measure.time ? { ...measure.time } : void 0,
+          time: {
+            ...measure.time,
+            count: pickupBeats,
+            unit: 4
+          }
+        };
+    }
+    if (measure.time?.display !== "senzaMisura") return measure;
+    let cadenzaBeats = writtenMeasureBeats(score, measureIndex, activeBeats);
+    return {
+      ...measure,
+      time: {
+        ...measure.time,
+        count: cadenzaBeats,
+        unit: 4
+      }
+    };
+  });
+  return measureOrder.map((index) => resolved[index]);
+}
+function suppressCadenzaFermataHolds(measures, holds) {
+  return holds.map(
+    (measureHolds, index) => measures[index]?.time?.display === "senzaMisura" ? measureHolds.filter((hold) => hold.kind !== "fermata") : [...measureHolds]
+  );
+}
+
+// packages/midi/src/navigation/index.ts
+init_define_import_meta_env();
+
+// packages/midi/src/navigation/itinerary.ts
+init_define_import_meta_env();
+function beatInPlayedSpan(beat, span) {
+  return span === void 0 || beat >= span.startBeat - 1e-9 && (beat < span.endBeat - 1e-9 || span.endBeat === span.measureBeats && Math.abs(beat - span.endBeat) < 1e-9);
+}
+function playedSpansContinue(span, next) {
+  return next !== void 0 && span.endBeat === span.measureBeats && next.startBeat === 0 && next.measureIndex === span.measureIndex + 1;
+}
+var NavigationError = class extends Error {
+  constructor(message, pointers) {
+    super(`${message} (${pointers.join(", ")})`);
+    this.pointers = pointers;
+    this.name = "NavigationError";
+  }
+  pointers;
+}, EPS = 1e-9, MAX_SPANS = 1e5;
+function locationBeat(position, length, pointer) {
+  let [numerator, denominator] = position.fraction, beat = numerator * 4 / denominator;
+  if (!Number.isFinite(beat) || denominator <= 0 || beat < 0 || beat > length + EPS)
+    throw new NavigationError("Navigation location is outside its measure", [pointer]);
+  return Math.min(beat, length);
+}
+function resolveDestinations(measures, measureLengths) {
+  let destinations = (kind) => measures.flatMap((measure, measureIndex) => {
+    let marker = measure[kind];
+    return marker ? [
+      {
+        measureIndex,
+        beat: locationBeat(
+          marker.location,
+          measureLengths[measureIndex],
+          `/global/measures/${measureIndex}/${kind}/location`
+        )
+      }
+    ] : [];
+  }), markers = { segno: destinations("segno"), coda: destinations("coda"), fine: destinations("fine") }, required = (kind, source) => {
+    let found = markers[kind];
+    if (found.length !== 1)
+      throw new NavigationError(`Navigation requires exactly one ${kind} destination`, [
+        `/global/measures/${source}/jump`,
+        ...found.map(({ measureIndex }) => `/global/measures/${measureIndex}/${kind}`)
+      ]);
+    return found[0];
+  };
+  for (let index = 0; index < measures.length; index++) {
+    let jump = measures[index]?.jump;
+    if (!jump) continue;
+    let type = jump.type;
+    if (locationBeat(jump.location, measureLengths[index], `/global/measures/${index}/jump/location`), ["segno", "dsAlFine", "dsAlCoda"].includes(type) && required("segno", index), ["dcAlFine", "dsAlFine"].includes(type) && required("fine", index), ["dcAlCoda", "dsAlCoda", "toCoda"].includes(type) && required("coda", index), ["dcAlCoda", "dsAlCoda"].includes(type) && !measures.some((measure) => String(measure.jump?.type) === "toCoda"))
+      throw new NavigationError("Al Coda requires an explicit To Coda instruction", [`/global/measures/${index}/jump`]);
+    if (!["dc", "dcAlCoda", "dcAlFine", "segno", "dsAlFine", "dsAlCoda", "toCoda"].includes(type))
+      throw new NavigationError(`Unsupported jump type: ${type}`, [`/global/measures/${index}/jump/type`]);
+  }
+  return { markers, required };
+}
+function nextInstruction(measure, cursor, length, state, fine, taken, initialOrder) {
+  let index = cursor.measureIndex, jump = measure.jump, type = jump ? String(jump.type) : "", jumpBeat = jump ? locationBeat(jump.location, length, `/global/measures/${index}/jump/location`) : 1 / 0, fineBeat = state.fineArmed && fine?.measureIndex === index ? fine.beat : 1 / 0, jumpActive = jump !== void 0 && !taken.has(index) && jumpBeat >= cursor.beat - EPS && (type !== "toCoda" || state.codaArmed) && (state.replay || initialOrder.lastIndexOf(index) === state.orderIndex), stop = fineBeat >= cursor.beat - EPS ? Math.min(length, fineBeat) : length, endBeat = jumpActive ? Math.min(stop, jumpBeat) : stop;
+  return {
+    type,
+    jumpActive,
+    jumpBeat,
+    fineReached: fineBeat >= cursor.beat - EPS && fineBeat <= endBeat + EPS,
+    endBeat
+  };
+}
+function compileNavigation(measures, initialOrder, measureLengths) {
+  let { markers, required } = resolveDestinations(measures, measureLengths), result = [], taken = /* @__PURE__ */ new Set(), state = { fineArmed: !1, codaArmed: !1, replay: !1, orderIndex: 0 }, cursor = { measureIndex: initialOrder[0] ?? 0, beat: 0 }, transitions = 0;
+  for (; cursor.measureIndex < measures.length && (state.replay || state.orderIndex < initialOrder.length); ) {
+    if (++transitions > MAX_SPANS)
+      throw new NavigationError("Navigation exceeds the safe playback traversal limit", ["/global/measures"]);
+    let index = cursor.measureIndex, measure = measures[index], length = measureLengths[index], { type, jumpActive, jumpBeat, fineReached, endBeat } = nextInstruction(
+      measure,
+      cursor,
+      length,
+      state,
+      markers.fine[0],
+      taken,
+      initialOrder
+    );
+    if (endBeat > cursor.beat + EPS && result.push({ measureIndex: index, startBeat: cursor.beat, endBeat, measureBeats: length }), state.fineArmed && fineReached) {
+      state.fineArmed = !1;
+      break;
+    }
+    if (jumpActive && jumpBeat <= endBeat + EPS) {
+      taken.add(index), state.replay = !0, type === "toCoda" ? (state.codaArmed = !1, cursor = required("coda", index)) : (state.fineArmed = type === "dcAlFine" || type === "dsAlFine", state.codaArmed = type === "dcAlCoda" || type === "dsAlCoda", cursor = ["segno", "dsAlFine", "dsAlCoda"].includes(type) ? required("segno", index) : { measureIndex: 0, beat: 0 });
+      continue;
+    }
+    state.orderIndex++, cursor = { measureIndex: state.replay ? index + 1 : initialOrder[state.orderIndex] ?? measures.length, beat: 0 };
+  }
+  if (state.fineArmed || state.codaArmed)
+    throw new NavigationError("The armed Fine or To Coda instruction is not reachable on replay", ["/global/measures"]);
+  return result;
+}
+
+// packages/midi/src/navigation/realization.ts
+init_define_import_meta_env();
+function authoredOnsetInSpan(event, start, end) {
+  return event.type === "noteOn" && event.scoreBeat !== void 0 && event.scoreBeat >= start - 1e-9 && event.scoreBeat < end - 1e-9;
+}
+function continuousEndBeat(spans, index, startBeat) {
+  let end = startBeat + spans[index].endBeat;
+  for (let nextIndex = index; playedSpansContinue(spans[nextIndex], spans[nextIndex + 1]); nextIndex++)
+    end += spans[nextIndex].measureBeats - spans[nextIndex].endBeat + spans[nextIndex + 1].endBeat;
+  return end;
+}
+function spanTempoMap(timeline, index, span, model, outputBeat) {
+  let entries = [
+    {
+      measureIndex: index,
+      beatInMeasure: 0,
+      timeSeconds: model.timeAtBeat(outputBeat),
+      bpm: model.bpmAtBeat(outputBeat)
+    }
+  ];
+  for (let entry of timeline.tempoMap) {
+    if (entry.measureIndex !== index || entry.beatInMeasure <= span.startBeat + 1e-9 || entry.beatInMeasure >= span.endBeat - 1e-9)
+      continue;
+    let beatInMeasure = entry.beatInMeasure - span.startBeat;
+    entries.push({
+      ...entry,
+      beatInMeasure,
+      timeSeconds: model.timeAtBeat(outputBeat + beatInMeasure)
+    });
+  }
+  return entries;
+}
+function realizeNavigation(timeline, spans) {
+  let sourceSpans = spans.map((span, index) => ({
+    startBeat: timeline.measureStartBeats[index] + span.startBeat,
+    endBeat: timeline.measureStartBeats[index] + span.endBeat
+  })), model = TempoModel.concatenate(timeline.model, sourceSpans), events = [], measureStartBeats = [], tempoMap = [], outputBeat = 0, activeNotes = /* @__PURE__ */ new Map();
+  for (let index = 0; index < spans.length; index++) {
+    let span = spans[index], source = sourceSpans[index], startTime = timeline.model.timeAtBeat(source.startBeat), endTime = timeline.model.timeAtBeat(source.endBeat), controllers = /* @__PURE__ */ new Map(), segmentStart = events.length;
+    measureStartBeats.push(outputBeat), tempoMap.push(...spanTempoMap(timeline, index, span, model, outputBeat));
+    let translate = (time) => model.timeAtBeat(outputBeat) + Math.min(endTime - startTime, Math.max(0, time - startTime)), noteKey = (event) => `${event.partIndex}:${event.playbackLaneId ?? event.channel}:${event.midiNote}:${event.drumKitProgram ?? ""}`;
+    for (let event of timeline.events) {
+      let authoredOnset = authoredOnsetInSpan(event, source.startBeat, source.endBeat);
+      if (event.time < startTime - 1e-9 && !authoredOnset) {
+        (event.type === "controlChange" || event.type === "programChange") && controllers.set(
+          `${event.partIndex}:${event.playbackLaneId ?? event.channel}:${event.type}:${event.cc ?? ""}`,
+          event
+        );
+        continue;
+      }
+      if (!(event.time > endTime + 1e-9 && !authoredOnset))
+        if (event.type === "noteOn") {
+          let beat = event.scoreBeat ?? timeline.model.beatAtTime(event.time);
+          if (beat < source.startBeat - 1e-9 || beat >= source.endBeat - 1e-9) continue;
+          let output = {
+            ...event,
+            time: translate(event.time),
+            scoreBeat: outputBeat + beat - source.startBeat,
+            scoreDurationBeats: event.scoreDurationBeats === void 0 ? void 0 : Math.min(
+              event.scoreDurationBeats,
+              continuousEndBeat(spans, index, timeline.measureStartBeats[index]) - beat
+            )
+          };
+          events.push(output);
+          let key = noteKey(event), pending = activeNotes.get(key) ?? [];
+          pending.push(output), activeNotes.set(key, pending);
+        } else if (event.type === "noteOff") {
+          let pending = activeNotes.get(noteKey(event));
+          if (!pending?.length) continue;
+          pending.shift(), events.push({ ...event, time: translate(event.time) });
+        } else event.time < endTime - 1e-9 && events.push({ ...event, time: translate(event.time) });
+    }
+    events.splice(
+      segmentStart,
+      0,
+      ...Array.from(controllers.values(), (event) => ({ ...event, time: model.timeAtBeat(outputBeat) }))
+    );
+    let next = spans[index + 1];
+    if (!playedSpansContinue(span, next))
+      for (let pending of activeNotes.values()) {
+        for (let onset of pending)
+          events.push({
+            ...onset,
+            type: "noteOff",
+            velocity: 0,
+            time: model.timeAtBeat(outputBeat + span.endBeat - span.startBeat, "release")
+          });
+        pending.length = 0;
+      }
+    outputBeat += span.endBeat - span.startBeat;
+  }
+  let rank = { noteOff: 0, programChange: 1, controlChange: 2, noteOn: 3 };
+  return events.sort((a, b) => a.time - b.time || rank[a.type] - rank[b.type]), {
+    ...timeline,
+    events,
+    model,
+    tempoMap,
+    totalBeats: outputBeat,
+    duration: model.timeAtBeat(outputBeat),
+    measureStartBeats,
+    measureStartTimes: measureStartBeats.map((beat) => model.timeAtBeat(beat)),
+    playedSpans: [...spans]
+  };
+}
+
+// packages/midi/src/repeatExpansion.ts
+function expandPlaybackItinerary(measures, lengths) {
+  let activeBeats = 4, measureLengths = lengths ?? measures.map((measure) => (measure.time && (activeBeats = measure.time.count * 4 / measure.time.unit), activeBeats));
+  return compileNavigation(measures, expandRepeats(measures), measureLengths);
+}
+function scorePlaybackItinerary(score) {
+  let indices = score.global.measures.map((_, index) => index), lengths = playbackGlobalMeasures(score, indices).map((measure) => {
+    let time = measure.time;
+    return time ? time.count * 4 / time.unit : 4;
+  });
+  return expandPlaybackItinerary(score.global.measures, lengths);
 }
 function appendVoltaPass(order, endings, pass, startIdx, endIdx) {
   for (let j = startIdx; j <= endIdx; j++) {
@@ -16269,7 +16825,12 @@ function expandRepeats(globalMeasures) {
   for (; i < len; ) {
     let gm = globalMeasures[i];
     if (gm.repeatEnd) {
-      let repeatTimes = gm.repeatEnd.times ?? 2, repeatStartIdx = 0;
+      let repeatTimes = gm.repeatEnd.times ?? 2;
+      if (!Number.isInteger(repeatTimes) || repeatTimes < 1 || repeatTimes > 1e3)
+        throw new NavigationError("Repeat count must be an integer between 1 and 1000", [
+          `/global/measures/${i}/repeatEnd/times`
+        ]);
+      let repeatStartIdx = 0;
       for (let j = i; j >= 0; j--)
         if (globalMeasures[j].repeatStart) {
           repeatStartIdx = j;
@@ -16299,45 +16860,6 @@ function expandRepeats(globalMeasures) {
   }
   return order;
 }
-function appendRange(order, start, endInclusive) {
-  for (let measure = start; measure <= endInclusive; measure++) order.push(measure);
-}
-function appendAlCodaReplay(result, replayStart, codaIdx, measureCount, toCodaMeasureIdx) {
-  let replayEnd = toCodaMeasureIdx !== void 0 && toCodaMeasureIdx >= replayStart && toCodaMeasureIdx < codaIdx ? toCodaMeasureIdx : codaIdx - 1;
-  appendRange(result, replayStart, replayEnd), appendRange(result, codaIdx, measureCount - 1);
-}
-function expandJumps(globalMeasures, initialOrder, toCodaMeasureIdx) {
-  let segnoIdx = -1, fineIdx = -1, codaIdx = -1;
-  for (let m = 0; m < globalMeasures.length; m++) {
-    let gm = globalMeasures[m];
-    gm.segno && (segnoIdx = m), gm.fine && (fineIdx = m), gm.coda && (codaIdx = m);
-  }
-  let jumpOrderPos = -1, jumpMeasureIdx = -1;
-  for (let p = 0; p < initialOrder.length; p++) {
-    let mi = initialOrder[p];
-    if (globalMeasures[mi].jump) {
-      jumpOrderPos = p, jumpMeasureIdx = mi;
-      break;
-    }
-  }
-  if (jumpOrderPos === -1) return [...initialOrder];
-  let jump = globalMeasures[jumpMeasureIdx].jump, result = initialOrder.slice(0, jumpOrderPos + 1);
-  switch (jump.type) {
-    case "dsAlFine":
-      segnoIdx >= 0 && fineIdx >= 0 && appendRange(result, segnoIdx, fineIdx);
-      break;
-    case "dsAlCoda":
-      segnoIdx >= 0 && codaIdx >= 0 && appendAlCodaReplay(result, segnoIdx, codaIdx, globalMeasures.length, toCodaMeasureIdx);
-      break;
-    case "dcAlCoda":
-      codaIdx >= 0 && appendAlCodaReplay(result, 0, codaIdx, globalMeasures.length, toCodaMeasureIdx);
-      break;
-    case "segno":
-      segnoIdx >= 0 && appendRange(result, segnoIdx, globalMeasures.length - 1);
-      break;
-  }
-  return result;
-}
 
 // packages/midi/src/measureRepeats.ts
 init_define_import_meta_env();
@@ -16676,7 +17198,7 @@ function fermataMultiplier(fermata) {
 function caesuraBeats(style) {
   return style === "short" ? CAESURA_SHORT_BEATS : CAESURA_BEATS;
 }
-function durationBeats2(d) {
+function durationBeats3(d) {
   let base = DURATION_BEATS[d.base] ?? 1;
   return d.dots ? base * (2 - Math.pow(2, -d.dots)) : base;
 }
@@ -16694,16 +17216,16 @@ function collectFromContent(content, startBeat, ratio, spans, caesuraByBeat) {
   let cursor = startBeat;
   for (let item of content)
     if (item.type === "event") {
-      let dur = durationBeats2(item.duration) * ratio, endBeat = cursor + dur;
+      let dur = durationBeats3(item.duration) * ratio, endBeat = cursor + dur;
       if (item.fermata && item.fermata.duration !== "none") {
         let mult = fermataMultiplier(item.fermata);
         dur > 0 && mult > 1 && spans.push({ onset: cursor, end: endBeat, duration: dur, multiplier: mult });
       }
       item.markings?.caesura && mergeMax(caesuraByBeat, endBeat, caesuraBeats(item.markings.caesura.style)), cursor = endBeat;
     } else if (item.type === "tuplet") {
-      let outerBeats = durationBeats2(item.outer.duration) * item.outer.multiple, innerBeats = durationBeats2(item.inner.duration) * item.inner.multiple, childRatio = innerBeats > 0 ? outerBeats / innerBeats * ratio : ratio;
+      let outerBeats = durationBeats3(item.outer.duration) * item.outer.multiple, innerBeats = durationBeats3(item.inner.duration) * item.inner.multiple, childRatio = innerBeats > 0 ? outerBeats / innerBeats * ratio : ratio;
       collectFromContent(item.content, cursor, childRatio, spans, caesuraByBeat), cursor += outerBeats * ratio;
-    } else item.type === "tremolo" ? cursor += durationBeats2(item.outer.duration) * item.outer.multiple * ratio : item.type === "space" && (cursor += item.duration[0] / item.duration[1] * 4 * ratio);
+    } else item.type === "tremolo" ? cursor += durationBeats3(item.outer.duration) * item.outer.multiple * ratio : item.type === "space" && (cursor += item.duration[0] / item.duration[1] * 4 * ratio);
   return cursor - startBeat;
 }
 function collectPartMeasureHolds(partMeasure, originalMeasureIndex, staffMeterTable, spans, caesuraByBeat) {
@@ -16738,94 +17260,25 @@ function buildHoldSchedule(score, measureOrder, globalMeasures) {
     let origIdx = measureOrder[expandedIdx], fermataSpans = [], caesuraByBeat = /* @__PURE__ */ new Map();
     for (let partIndex = 0; partIndex < score.parts.length; partIndex++) {
       let part = score.parts[partIndex];
-      collectPartMeasureHolds(
-        part.measures[origIdx],
-        origIdx,
-        staffMeterTables[partIndex],
-        fermataSpans,
-        caesuraByBeat
-      );
-    }
-    let globalCaesura = globalMeasures[origIdx]?.caesura;
-    if (globalCaesura) {
-      let mBeats = measureBeats2(resolveTimeSig(globalMeasures, origIdx));
-      mergeMax(caesuraByBeat, mBeats, caesuraBeats(globalCaesura.style));
-    }
-    let holds = groupFermataSpans(fermataSpans);
-    for (let [atBeat, extraBeats] of caesuraByBeat)
-      holds.push({ atBeat, extraBeats, kind: "caesura" });
-    holds.sort((a, b) => a.atBeat - b.atBeat), schedule.push(holds);
-  }
-  return schedule;
-}
-
-// packages/midi/src/cadenzaTiming.ts
-init_define_import_meta_env();
-function contentBeats(content) {
-  let beats = 0;
-  for (let item of content)
-    switch (item.type) {
-      case "event":
-        beats += durationBeats3(item.duration.base, item.duration.dots);
-        break;
-      case "space":
-        beats += item.duration[0] / item.duration[1] * 4;
-        break;
-      case "tuplet":
-      case "tremolo":
-        beats += durationBeats3(item.outer.duration.base, item.outer.duration.dots) * item.outer.multiple;
-        break;
-      case "grace":
-        break;
-    }
-  return beats;
-}
-function durationBeats3(base, dots) {
-  let beats = DURATION_BEATS[base];
-  return dots ? beats * (2 - Math.pow(2, -dots)) : beats;
-}
-function writtenMeasureBeats(score, measureIndex, minimumBeats) {
-  return score.parts.reduce((maxBeats, part) => {
-    let measure = part.measures[measureIndex];
-    return measure ? Math.max(
-      maxBeats,
-      ...measure.sequences.filter((sequence) => !sequence.fullMeasure).map((sequence) => contentBeats(sequence.content))
-    ) : maxBeats;
-  }, minimumBeats);
-}
-function playbackGlobalMeasures(score, measureOrder) {
-  let activeBeats = 4;
-  return measureOrder.map((measureIndex) => {
-    let measure = score.global.measures[measureIndex];
-    if (measure.time && (activeBeats = measure.time.count * 4 / measure.time.unit), measureIndex === 0 && measure.number === 0) {
-      let pickupBeats = writtenMeasureBeats(score, measureIndex, 0);
-      if (pickupBeats > 0)
-        return {
-          ...measure,
-          __playbackNominalTime: measure.time ? { ...measure.time } : void 0,
-          time: {
-            ...measure.time,
-            count: pickupBeats,
-            unit: 4
-          }
-        };
-    }
-    if (measure.time?.display !== "senzaMisura") return measure;
-    let cadenzaBeats = writtenMeasureBeats(score, measureIndex, activeBeats);
-    return {
-      ...measure,
-      time: {
-        ...measure.time,
-        count: cadenzaBeats,
-        unit: 4
-      }
-    };
-  });
-}
-function suppressCadenzaFermataHolds(measures, holds) {
-  return holds.map(
-    (measureHolds, index) => measures[index]?.time?.display === "senzaMisura" ? measureHolds.filter((hold) => hold.kind !== "fermata") : [...measureHolds]
-  );
+      collectPartMeasureHolds(
+        part.measures[origIdx],
+        origIdx,
+        staffMeterTables[partIndex],
+        fermataSpans,
+        caesuraByBeat
+      );
+    }
+    let globalCaesura = globalMeasures[origIdx]?.caesura;
+    if (globalCaesura) {
+      let mBeats = measureBeats2(resolveTimeSig(globalMeasures, origIdx));
+      mergeMax(caesuraByBeat, mBeats, caesuraBeats(globalCaesura.style));
+    }
+    let holds = groupFermataSpans(fermataSpans);
+    for (let [atBeat, extraBeats] of caesuraByBeat)
+      holds.push({ atBeat, extraBeats, kind: "caesura" });
+    holds.sort((a, b) => a.atBeat - b.atBeat), schedule.push(holds);
+  }
+  return schedule;
 }
 
 // packages/midi/src/legato.ts
@@ -17001,388 +17454,139 @@ function applyMeasureTechniques(expressions, ctx, state, caps, ratioForStaff = (
       });
     } else if (mark.action.kind === "mute" && muteFamily) {
       if (mark.action.muted === muted) continue;
-      muted = mark.action.muted;
-      let curve = muted ? MUTE_CURVES[muteFamily] : OPEN_CURVE;
-      emitCc(ctx, time, CC_BRIGHTNESS, curve.brightness), emitCc(ctx, time, CC_RESONANCE, curve.resonance);
-    }
-  }
-  return { program, muted, ...instrumentKey === void 0 ? {} : { instrumentKey } };
-}
-
-// packages/midi/src/instrumentPlayback/index.ts
-init_define_import_meta_env();
-function instrumentPart(part, instrument) {
-  return instrument ? {
-    ...part,
-    name: instrument.name ?? part.name,
-    _x: {
-      ...part._x,
-      viritura: {
-        ...part._x?.viritura,
-        instrumentId: instrument.instrumentId,
-        midiProgram: instrument.midiProgram,
-        initialInstrument: void 0,
-        instruments: void 0
-      }
-    }
-  } : part;
-}
-function playbackInstruments(part) {
-  let initial = initialInstrumentState(part);
-  if (initial.instrumentKey !== void 0 && !initial.instrument)
-    throw new Error(`Unknown initial instrument "${initial.instrumentKey}" in "${part.name}".`);
-  let result = [{ key: "initial", part: instrumentPart(part, initial.instrument) }], seen = /* @__PURE__ */ new Set();
-  for (let located of listInstrumentChanges(part)) {
-    let [numerator, denominator] = located.position;
-    if (denominator <= 0 || numerator < 0) throw new Error(`Invalid instrument-change position in "${part.name}".`);
-    let key = located.change.instrument;
-    if (!(key === void 0 || seen.has(key))) {
-      if (!located.state.instrument) throw new Error(`Unknown instrument "${key}" in "${part.name}".`);
-      seen.add(key), result.push({ key: `instrument:${key}`, part: instrumentPart(part, located.state.instrument) });
-    }
-  }
-  return result;
-}
-function playbackInstrumentKeyAt(part, measureIndex, beatOffset = 0) {
-  let key = "initial";
-  for (let located of listInstrumentChanges(part)) {
-    if (located.measureIndex > measureIndex || located.measureIndex === measureIndex && located.position[0] / located.position[1] * 4 > beatOffset) break;
-    located.change.instrument !== void 0 && (key = `instrument:${located.change.instrument}`);
-  }
-  return key;
-}
-function boundariesForPart(part, timing, programs, initialProgram) {
-  let instruments = playbackInstruments(part), definitions = new Map(instruments.map((instrument) => [instrument.key, instrument.part])), changes = listInstrumentChanges(part).filter((located) => located.change.instrument !== void 0), boundaries = [], add = (beat, key) => {
-    let program = programs?.get(key) ?? (key === "initial" ? initialProgram : void 0) ?? definitions.get(key)?._x?.viritura?.midiProgram;
-    boundaries.push({
-      beat,
-      time: timing.model.timeAtBeat(beat),
-      key,
-      program: typeof program == "number" && Number.isInteger(program) && program >= 0 && program <= 127 ? program : void 0
-    });
-  };
-  return timing.measureOrder.forEach((measureIndex, expandedIndex) => {
-    let start = timing.measureStartBeats[expandedIndex];
-    add(start, playbackInstrumentKeyAt(part, measureIndex));
-    for (let located of changes) {
-      if (located.measureIndex !== measureIndex || located.position[0] === 0) continue;
-      let [numerator, denominator] = located.position;
-      if (denominator <= 0 || numerator < 0) throw new Error(`Invalid instrument-change position in "${part.name}".`);
-      add(start + numerator / denominator * 4, `instrument:${located.change.instrument}`);
-    }
-  }), boundaries;
-}
-function applyInstrumentPlayback(score, events, timing, programs, initialPrograms) {
-  let diagnostics = [];
-  return score.parts.forEach((part, partIndex) => {
-    if (playbackInstruments(part).length === 1) return;
-    let boundaries = boundariesForPart(part, timing, programs?.get(partIndex), initialPrograms?.[partIndex]), partEvents = events.filter((event) => event.partIndex === partIndex), lanes = new Set(partEvents.flatMap((event) => event.playbackLaneId ? [event.playbackLaneId] : []));
-    lanes.size === 0 && lanes.add(`part:${partIndex}`);
-    let missingPrograms = [
-      ...new Set(boundaries.filter((boundary) => boundary.program === void 0).map((boundary) => boundary.key))
-    ];
-    missingPrograms.length > 0 && diagnostics.push({
-      code: "instrument-program-unavailable",
-      message: `Physical MIDI cannot select ${missingPrograms.join(", ")} in "${part.name}"; provide resolved instrumentPrograms or a MIDI program fallback.`,
-      playbackLaneIds: [...lanes]
-    });
-    for (let event of [...partEvents]) {
-      if (event.playbackLaneId) continue;
-      let [first, ...others] = lanes;
-      event.playbackLaneId = first;
-      for (let lane of others) {
-        let scoped = { ...event, playbackLaneId: lane };
-        events.push(scoped), partEvents.push(scoped);
-      }
-    }
-    let attackDelays = /* @__PURE__ */ new Map(), attackKey = (event) => JSON.stringify([event.playbackLaneId, event.channel, event.midiNote, event.scoreBeat, event.scoreEventId]);
-    for (let event of partEvents) {
-      if (event.type === "controlChange" && event.cc !== 74 && event.cc !== 71) continue;
-      let beat = event.scoreBeat ?? timing.model.beatAtTime(event.time), instrument = "initial", instrumentStart = 0;
-      for (let boundary of boundaries) {
-        if (boundary.beat > beat + 1e-9) break;
-        instrument = boundary.key, instrumentStart = boundary.time;
-      }
-      if (event.type === "noteOn") {
-        let delay = Math.max(0, instrumentStart - event.time);
-        attackDelays.set(attackKey(event), delay), event.time = Math.max(event.time, instrumentStart);
-      }
-      event.playbackInstrumentKey = instrument;
-    }
-    for (let event of partEvents)
-      event.type === "noteOff" && (event.time += attackDelays.get(attackKey(event)) ?? 0);
-    for (let lane of lanes) {
-      let previous;
-      for (let boundary of boundaries)
-        boundary.key !== previous && (previous = boundary.key, events.push({
-          type: "programChange",
-          time: boundary.time,
-          scoreBeat: boundary.beat,
-          midiNote: 0,
-          velocity: 0,
-          partIndex,
-          playbackLaneId: lane,
-          channel: partEvents.find((event) => event.playbackLaneId === lane)?.channel ?? 0,
-          playbackInstrumentKey: boundary.key,
-          instrumentChange: !0,
-          program: boundary.program
-        }));
-    }
-  }), diagnostics;
-}
-
-// packages/midi/src/tempoMap.ts
-init_define_import_meta_env();
-
-// packages/midi/src/tempoModel.ts
-init_define_import_meta_env();
-var bpmToSpb = (bpm) => 60 / bpm;
-function integrateTime(b0, b, bpm0, slope) {
-  let db = b - b0;
-  if (Math.abs(slope) < 1e-6) return bpmToSpb(bpm0) * db;
-  let bpmB = bpm0 + slope * db;
-  return 60 / slope * Math.log(bpmB / bpm0);
-}
-function inverseBeat(dt, bpm0, slope) {
-  return Math.abs(slope) < 1e-6 ? dt * bpm0 / 60 : (bpm0 * Math.exp(dt * slope / 60) - bpm0) / slope;
-}
-var TempoModel = class _TempoModel {
-  knots;
-  constructor(knots) {
-    this.knots = knots;
-  }
-  /**
-   * Build a model from tempo regions and point insertions.
-   *
-   * `regions` need not be pre-sorted or gapless; they are sorted by `startBeat`
-   * and gaps are filled by extending the previous tempo (a held constant). The
-   * first region's start tempo applies from beat 0. `insertions` are point gaps
-   * (caesuras) keyed by beat.
-   */
-  static build(regions, insertions = []) {
-    let sorted = [...regions].sort((a, b) => a.startBeat - b.startBeat), insByBeat = /* @__PURE__ */ new Map();
-    for (let ins of insertions)
-      ins.seconds > 0 && insByBeat.set(ins.beat, (insByBeat.get(ins.beat) ?? 0) + ins.seconds);
-    let boundarySet = /* @__PURE__ */ new Set([0]);
-    for (let r of sorted) boundarySet.add(r.startBeat);
-    for (let ins of insByBeat.keys()) boundarySet.add(ins);
-    let boundaries = [...boundarySet].sort((a, b) => a - b), tempoAt = (beat) => {
-      let active;
-      for (let r of sorted)
-        if (r.startBeat <= beat + 1e-9) active = r;
-        else break;
-      if (!active) {
-        let first = sorted[0];
-        return { bpm: first ? first.startBpm : 120, slope: 0 };
-      }
-      let span = active.endBeat - active.startBeat, slope = span > 0 && Number.isFinite(span) ? (active.endBpm - active.startBpm) / span : 0;
-      return { bpm: active.startBpm + slope * (beat - active.startBeat), slope };
-    }, knots = [], time = 0, prevBeat = boundaries[0], prev = tempoAt(prevBeat), ins0 = insByBeat.get(prevBeat) ?? 0;
-    time += ins0, knots.push({ beat: prevBeat, time, bpm: prev.bpm, slope: prev.slope, insertBefore: ins0 });
-    for (let i = 1; i < boundaries.length; i++) {
-      let beat = boundaries[i];
-      time += integrateTime(prevBeat, beat, prev.bpm, prev.slope);
-      let ins = insByBeat.get(beat) ?? 0;
-      time += ins;
-      let t = tempoAt(beat);
-      knots.push({ beat, time, bpm: t.bpm, slope: t.slope, insertBefore: ins }), prevBeat = beat, prev = t;
-    }
-    return new _TempoModel(knots);
-  }
-  /** Index of the last knot whose beat ≤ `beat`. */
-  knotIndexForBeat(beat) {
-    let k = this.knots, lo = 0, hi = k.length - 1, ans = 0;
-    for (; lo <= hi; ) {
-      let mid = lo + hi >> 1;
-      k[mid].beat <= beat + 1e-9 ? (ans = mid, lo = mid + 1) : hi = mid - 1;
-    }
-    return ans;
-  }
-  /** Index of the last knot whose time ≤ `time`. */
-  knotIndexForTime(time) {
-    let k = this.knots, lo = 0, hi = k.length - 1, ans = 0;
-    for (; lo <= hi; ) {
-      let mid = lo + hi >> 1;
-      k[mid].time <= time + 1e-9 ? (ans = mid, lo = mid + 1) : hi = mid - 1;
-    }
-    return ans;
-  }
-  /**
-   * Absolute time (seconds) at a global quarter-note beat.
-   *
-   * `endpoint` selects how a point insertion EXACTLY at `beat` is treated:
-   *  - `"onset"` (default): time AFTER the insertion — what an event STARTING at
-   *    `beat` wants (it begins once the gap is over).
-   *  - `"release"`: time BEFORE the insertion — what a note ENDING at `beat`
-   *    wants (a caesura/gap at the release point isn't part of the note).
-   */
-  timeAtBeat(beat, endpoint = "onset") {
-    let i = this.knotIndexForBeat(beat), knot = this.knots[i], base = knot.time + integrateTime(knot.beat, beat, knot.bpm, knot.slope);
-    return endpoint === "release" && Math.abs(knot.beat - beat) < 1e-9 ? base - knot.insertBefore : base;
-  }
-  /**
-   * Seconds elapsed over `[beat, beat + beats)` — a note/event DURATION. The end
-   * uses release semantics so a point insertion (caesura) exactly at the release
-   * beat is not absorbed into the note's sounding length.
-   */
-  secondsForBeats(beat, beats) {
-    return this.timeAtBeat(beat + beats, "release") - this.timeAtBeat(beat);
-  }
-  /**
-   * Global quarter-note beat at an absolute time (inverse of {@link timeAtBeat}).
-   * Within a point-insertion gap, returns the insertion's beat (position is
-   * frozen during a caesura).
-   */
-  beatAtTime(time) {
-    let i = this.knotIndexForTime(time), knot = this.knots[i], next = this.knots[i + 1];
-    if (next) {
-      let musicEnd = next.time - next.insertBefore;
-      if (time >= musicEnd - 1e-9) return next.beat;
+      muted = mark.action.muted;
+      let curve = muted ? MUTE_CURVES[muteFamily] : OPEN_CURVE;
+      emitCc(ctx, time, CC_BRIGHTNESS, curve.brightness), emitCc(ctx, time, CC_RESONANCE, curve.resonance);
     }
-    return knot.beat + inverseBeat(time - knot.time, knot.bpm, knot.slope);
-  }
-  /** Seconds-per-quarter-note beat at a global beat. */
-  spbAtBeat(beat) {
-    let i = this.knotIndexForBeat(beat), knot = this.knots[i], bpmHere = knot.bpm + knot.slope * (beat - knot.beat);
-    return bpmToSpb(bpmHere);
-  }
-  /** Quarter-note BPM at a global beat. */
-  bpmAtBeat(beat) {
-    return 60 / this.spbAtBeat(beat);
-  }
-  /**
-   * Generate click times (seconds) for a metronome / studio click track over
-   * `[startBeat, endBeat)`. `clickBeats` are the beat positions to click,
-   * expressed as offsets within each "grid step" — but for the common case
-   * callers pass a flat list of global beat positions and we just map them.
-   * Returns the absolute time of every beat in `beats`.
-   */
-  clickTimes(beats) {
-    return beats.map((b) => this.timeAtBeat(b));
   }
-};
-
-// packages/midi/src/tempoMap.ts
-function playbackNominalTime(gm) {
-  return gm.__playbackNominalTime;
+  return { program, muted, ...instrumentKey === void 0 ? {} : { instrumentKey } };
 }
-var DEFAULT_BPM = 120, DEFAULT_TIME = { count: 4, unit: 4 };
-function measureBeatsFromTime(ts) {
-  return ts.count * 4 / ts.unit;
+
+// packages/midi/src/instrumentPlayback/index.ts
+init_define_import_meta_env();
+function instrumentPart(part, instrument) {
+  return instrument ? {
+    ...part,
+    name: instrument.name ?? part.name,
+    _x: {
+      ...part._x,
+      viritura: {
+        ...part._x?.viritura,
+        instrumentId: instrument.instrumentId,
+        midiProgram: instrument.midiProgram,
+        initialInstrument: void 0,
+        instruments: void 0
+      }
+    }
+  } : part;
 }
-function tempoNoteBeats(base, dots) {
-  let baseBeats = DURATION_BEATS[base] ?? 1;
-  return dots ? baseBeats * (2 - Math.pow(2, -dots)) : baseBeats;
+function playbackInstruments(part) {
+  let initial = initialInstrumentState(part);
+  if (initial.instrumentKey !== void 0 && !initial.instrument)
+    throw new Error(`Unknown initial instrument "${initial.instrumentKey}" in "${part.name}".`);
+  let result = [{ key: "initial", part: instrumentPart(part, initial.instrument) }], seen = /* @__PURE__ */ new Set();
+  for (let located of listInstrumentChanges(part)) {
+    let [numerator, denominator] = located.position;
+    if (denominator <= 0 || numerator < 0) throw new Error(`Invalid instrument-change position in "${part.name}".`);
+    let key = located.change.instrument;
+    if (!(key === void 0 || seen.has(key))) {
+      if (!located.state.instrument) throw new Error(`Unknown instrument "${key}" in "${part.name}".`);
+      seen.add(key), result.push({ key: `instrument:${key}`, part: instrumentPart(part, located.state.instrument) });
+    }
+  }
+  return result;
 }
-function effectiveQpm(bpm, tempoBase, tempoDots) {
-  return bpm * tempoNoteBeats(tempoBase, tempoDots);
+function playbackInstrumentKeyAt(part, measureIndex, beatOffset = 0) {
+  let key = "initial";
+  for (let located of listInstrumentChanges(part)) {
+    if (located.measureIndex > measureIndex || located.measureIndex === measureIndex && located.position[0] / located.position[1] * 4 > beatOffset) break;
+    located.change.instrument !== void 0 && (key = `instrument:${located.change.instrument}`);
+  }
+  return key;
 }
-function buildTempoMap(globalMeasures, holds) {
-  let tempoMap = [], measureStartTimes = [], currentQpm = DEFAULT_BPM, currentSpq = 60 / currentQpm, currentTime = { count: DEFAULT_TIME.count, unit: DEFAULT_TIME.unit }, absoluteTime = 0, hasInitialTempo = !1;
-  for (let m = 0; m < globalMeasures.length; m++) {
-    let gm = globalMeasures[m], nominalTime = playbackNominalTime(gm) ?? gm.time;
-    nominalTime && (currentTime = { count: nominalTime.count, unit: nominalTime.unit });
-    let mBeats = measureBeatsFromTime(gm.time ?? currentTime);
-    measureStartTimes.push(absoluteTime);
-    let measureStartSpq = currentSpq, changes = [];
-    if (gm.tempos && gm.tempos.length > 0) {
-      for (let tempo of gm.tempos) {
-        let beatOffset = tempo.location ? tempo.location.fraction[0] / tempo.location.fraction[1] * mBeats : 0, qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
-        changes.push({ beatOffset, qpm });
-      }
-      changes.sort((a, b) => a.beatOffset - b.beatOffset);
+function boundariesForPart(part, timing, programs, initialProgram) {
+  let instruments = playbackInstruments(part), definitions = new Map(instruments.map((instrument) => [instrument.key, instrument.part])), changes = listInstrumentChanges(part).filter((located) => located.change.instrument !== void 0), boundaries = [], add = (beat, key) => {
+    let program = programs?.get(key) ?? (key === "initial" ? initialProgram : void 0) ?? definitions.get(key)?._x?.viritura?.midiProgram;
+    boundaries.push({
+      beat,
+      time: timing.model.timeAtBeat(beat),
+      key,
+      program: typeof program == "number" && Number.isInteger(program) && program >= 0 && program <= 127 ? program : void 0
+    });
+  };
+  return timing.measureOrder.forEach((measureIndex, expandedIndex) => {
+    let start = timing.measureStartBeats[expandedIndex];
+    add(start, playbackInstrumentKeyAt(part, measureIndex));
+    for (let located of changes) {
+      if (located.measureIndex !== measureIndex || located.position[0] === 0) continue;
+      let [numerator, denominator] = located.position;
+      if (denominator <= 0 || numerator < 0) throw new Error(`Invalid instrument-change position in "${part.name}".`);
+      add(start + numerator / denominator * 4, `instrument:${located.change.instrument}`);
     }
-    let beatCursor = 0;
-    for (let change of changes)
-      change.beatOffset > beatCursor && (absoluteTime += (change.beatOffset - beatCursor) * currentSpq, beatCursor = change.beatOffset), tempoMap.push({
-        measureIndex: m,
-        beatInMeasure: change.beatOffset,
-        timeSeconds: absoluteTime,
-        bpm: change.qpm
-      }), m === 0 && change.beatOffset === 0 && (hasInitialTempo = !0), currentQpm = change.qpm, currentSpq = 60 / currentQpm;
-    mBeats > beatCursor && (absoluteTime += (mBeats - beatCursor) * currentSpq);
-    let measureHolds = holds?.[m];
-    if (measureHolds)
-      for (let hold of measureHolds)
-        absoluteTime += hold.extraBeats * measureStartSpq;
-  }
-  return hasInitialTempo || tempoMap.unshift({
-    measureIndex: 0,
-    beatInMeasure: 0,
-    timeSeconds: 0,
-    bpm: DEFAULT_BPM
-  }), { tempoMap, measureStartTimes };
+  }), boundaries;
 }
-function buildTempoModel(globalMeasures, holds) {
-  let regions = [], measureStartBeats = [], cumBeats = 0, currentTime = { count: DEFAULT_TIME.count, unit: DEFAULT_TIME.unit }, gradualDecls = [];
-  for (let m = 0; m < globalMeasures.length; m++) {
-    let gm = globalMeasures[m], nominalTime = playbackNominalTime(gm) ?? gm.time;
-    nominalTime && (currentTime = { count: nominalTime.count, unit: nominalTime.unit });
-    let mBeats = measureBeatsFromTime(gm.time ?? currentTime);
-    if (measureStartBeats.push(cumBeats), gm.tempos && gm.tempos.length > 0) {
-      let sorted = [...gm.tempos].sort((a, b) => tempoBeat(a, mBeats) - tempoBeat(b, mBeats));
-      for (let tempo of sorted) {
-        let startBeat = cumBeats + tempoBeat(tempo, mBeats), qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
-        regions.push({ startBeat, endBeat: 1 / 0, startBpm: qpm, endBpm: qpm });
+function applyInstrumentPlayback(score, events, timing, programs, initialPrograms) {
+  let diagnostics = [];
+  return score.parts.forEach((part, partIndex) => {
+    if (playbackInstruments(part).length === 1) return;
+    let boundaries = boundariesForPart(part, timing, programs?.get(partIndex), initialPrograms?.[partIndex]), partEvents = events.filter((event) => event.partIndex === partIndex), lanes = new Set(partEvents.flatMap((event) => event.playbackLaneId ? [event.playbackLaneId] : []));
+    lanes.size === 0 && lanes.add(`part:${partIndex}`);
+    let missingPrograms = [
+      ...new Set(boundaries.filter((boundary) => boundary.program === void 0).map((boundary) => boundary.key))
+    ];
+    missingPrograms.length > 0 && diagnostics.push({
+      code: "instrument-program-unavailable",
+      message: `Physical MIDI cannot select ${missingPrograms.join(", ")} in "${part.name}"; provide resolved instrumentPrograms or a MIDI program fallback.`,
+      playbackLaneIds: [...lanes]
+    });
+    for (let event of [...partEvents]) {
+      if (event.playbackLaneId) continue;
+      let [first, ...others] = lanes;
+      event.playbackLaneId = first;
+      for (let lane of others) {
+        let scoped = { ...event, playbackLaneId: lane };
+        events.push(scoped), partEvents.push(scoped);
       }
     }
-    gm.gradualTempo && gradualDecls.push({
-      declIdx: m,
-      gt: gm.gradualTempo,
-      startBeat: cumBeats + posBeats(gm.gradualTempo.position.fraction)
-    }), cumBeats += mBeats;
-  }
-  if ((regions.length === 0 || regions.every((r) => r.startBeat > 1e-9)) && regions.unshift({ startBeat: 0, endBeat: 1 / 0, startBpm: DEFAULT_BPM, endBpm: DEFAULT_BPM }), gradualDecls.length > 0) {
-    let idToIdx = buildMeasureIdToIndex(globalMeasures), constModel = TempoModel.build(regions);
-    for (let { declIdx, gt, startBeat } of gradualDecls) {
-      let endBeat = resolveGradualEndBeat(gt.end, declIdx, globalMeasures, measureStartBeats, idToIdx);
-      if (endBeat === void 0 || endBeat <= startBeat + 1e-9) continue;
-      let startBpm = gt.startBpm ?? constModel.bpmAtBeat(startBeat);
-      regions.push({ startBeat, endBeat, startBpm, endBpm: gt.endBpm }), regions.some((r) => Math.abs(r.startBeat - endBeat) < 1e-9) || regions.push({ startBeat: endBeat, endBeat: 1 / 0, startBpm: gt.endBpm, endBpm: gt.endBpm });
+    let attackDelays = /* @__PURE__ */ new Map(), attackKey = (event) => JSON.stringify([event.playbackLaneId, event.channel, event.midiNote, event.scoreBeat, event.scoreEventId]);
+    for (let event of partEvents) {
+      if (event.type === "controlChange" && event.cc !== 74 && event.cc !== 71) continue;
+      let beat = event.scoreBeat ?? timing.model.beatAtTime(event.time), instrument = "initial", instrumentStart = 0;
+      for (let boundary of boundaries) {
+        if (boundary.beat > beat + 1e-9) break;
+        instrument = boundary.key, instrumentStart = boundary.time;
+      }
+      if (event.type === "noteOn") {
+        let delay = Math.max(0, instrumentStart - event.time);
+        attackDelays.set(attackKey(event), delay), event.time = Math.max(event.time, instrumentStart);
+      }
+      event.playbackInstrumentKey = instrument;
     }
-  }
-  regions.sort((a, b) => a.startBeat - b.startBeat);
-  for (let i = 0; i < regions.length - 1; i++)
-    regions[i].endBeat = regions[i + 1].startBeat;
-  let regionsModel = TempoModel.build(regions), insertions = [];
-  if (holds)
-    for (let m = 0; m < holds.length; m++) {
-      let measureHolds = holds[m];
-      if (!measureHolds || measureHolds.length === 0) continue;
-      let startBeat = measureStartBeats[m], spb = regionsModel.spbAtBeat(startBeat);
-      for (let hold of measureHolds)
-        insertions.push({ beat: startBeat + hold.atBeat, seconds: hold.extraBeats * spb });
+    for (let event of partEvents)
+      event.type === "noteOff" && (event.time += attackDelays.get(attackKey(event)) ?? 0);
+    for (let lane of lanes) {
+      let previous;
+      for (let boundary of boundaries)
+        boundary.key !== previous && (previous = boundary.key, events.push({
+          type: "programChange",
+          time: boundary.time,
+          scoreBeat: boundary.beat,
+          midiNote: 0,
+          velocity: 0,
+          partIndex,
+          playbackLaneId: lane,
+          channel: partEvents.find((event) => event.playbackLaneId === lane)?.channel ?? 0,
+          playbackInstrumentKey: boundary.key,
+          instrumentChange: !0,
+          program: boundary.program
+        }));
     }
-  let model = insertions.length > 0 ? TempoModel.build(regions, insertions) : regionsModel, measureStartTimes = measureStartBeats.map((b) => model.timeAtBeat(b));
-  return { model, measureStartTimes, measureStartBeats, totalBeats: cumBeats };
-}
-function posBeats(frac) {
-  return !frac || frac[1] === 0 ? 0 : frac[0] / frac[1] * 4;
-}
-function buildMeasureIdToIndex(globalMeasures) {
-  let m = /* @__PURE__ */ new Map();
-  return globalMeasures.forEach((gm, i) => {
-    gm.id && !m.has(gm.id) && m.set(gm.id, i);
-  }), m;
-}
-function resolveGradualEndBeat(end, fromIdx, globalMeasures, measureStartBeats, idToIdx) {
-  let idx = idToIdx.get(end.measure);
-  if (idx === void 0) {
-    let parsed = Number.parseInt(end.measure, 10);
-    !Number.isNaN(parsed) && parsed >= 0 && parsed < globalMeasures.length && (idx = parsed);
-  }
-  idx === void 0 && (idx = fromIdx);
-  let start = measureStartBeats[idx];
-  if (start !== void 0)
-    return start + posBeats(end.position.fraction);
-}
-function tempoBeat(tempo, mBeats) {
-  return tempo.location ? tempo.location.fraction[0] / tempo.location.fraction[1] * mBeats : 0;
+  }), diagnostics;
 }
 
 // packages/midi/src/dynamicsEnvelope.ts
 init_define_import_meta_env();
-var CC_EXPRESSION = 11, EPS = 1e-6, DEFAULT_DYNAMIC = { velocity: 84, cc11: 100 }, DYNAMIC_AXES = {
+var CC_EXPRESSION = 11, EPS2 = 1e-6, DEFAULT_DYNAMIC = { velocity: 84, cc11: 100 }, DYNAMIC_AXES = {
   n: { velocity: 1, cc11: 0 },
   pppppp: { velocity: 22, cc11: 11 },
   ppppp: { velocity: 28, cc11: 17 },
@@ -17449,7 +17653,7 @@ function stepRung(axes, dir) {
 function sampleAnchorsAxes(anchors, t) {
   let active = DEFAULT_DYNAMIC;
   for (let a of anchors) {
-    if (a.time > t + EPS) break;
+    if (a.time > t + EPS2) break;
     active = { velocity: a.velocity, cc11: a.cc11 };
   }
   return active;
@@ -17465,24 +17669,24 @@ function gradualTextDirection(text) {
   if (/^cresc(?:endo)?\.?$/.test(normalized)) return 1;
   if (/^(?:dim(?:inuendo)?|decresc(?:endo)?)\.?$/.test(normalized)) return -1;
 }
-function collectMeasureDynamicGroups(pm, originalMeasureIndex, measureStartBeat, model, expandedIdx, groups, staffMeterTable) {
+function collectMeasureDynamicGroups(pm, originalMeasureIndex, measureStartBeat, model, expandedIdx, groups, staffMeterTable, span) {
   for (let group of pm.dynamics ?? []) {
-    let ratio = staffMeterRatioAt(staffMeterTable, originalMeasureIndex, group.staff);
-    groups.push({
+    let ratio = staffMeterRatioAt(staffMeterTable, originalMeasureIndex, group.staff), beat = fractionToBeats2(group.position.fraction) * ratio;
+    beatInPlayedSpan(beat, span) && groups.push({
       group,
-      time: model.timeAtBeat(measureStartBeat + fractionToBeats2(group.position.fraction) * ratio),
+      time: model.timeAtBeat(measureStartBeat + beat),
       expandedIdx
     });
   }
 }
-function collectMeasureGradualTexts(pm, originalMeasureIndex, measureStartBeat, model, expandedIdx, gradualTexts, staffMeterTable) {
+function collectMeasureGradualTexts(pm, originalMeasureIndex, measureStartBeat, model, expandedIdx, gradualTexts, staffMeterTable, span) {
   for (let index = 0; index < (pm.expressions?.length ?? 0); index++) {
     let expression = pm.expressions[index], dir = gradualTextDirection(plainTextContent(expression.text));
-    dir && gradualTexts.push({
+    if (!dir) continue;
+    let beat = fractionToBeats2(expression.position.fraction) * staffMeterRatioAt(staffMeterTable, originalMeasureIndex, expression.staff);
+    beatInPlayedSpan(beat, span) && gradualTexts.push({
       id: `text-gradual-${expandedIdx}-${index}`,
-      startTime: model.timeAtBeat(
-        measureStartBeat + fractionToBeats2(expression.position.fraction) * staffMeterRatioAt(staffMeterTable, originalMeasureIndex, expression.staff)
-      ),
+      startTime: model.timeAtBeat(measureStartBeat + beat),
       dir,
       expandedIdx
     });
@@ -17505,7 +17709,7 @@ function resolveEndMeasureLocation(endMeasureId, fromExpandedIdx, measureOrder,
 }
 function explicitAnchorAt(anchors, time) {
   for (let a of anchors)
-    if (Math.abs(a.time - time) <= EPS) return { velocity: a.velocity, cc11: a.cc11 };
+    if (Math.abs(a.time - time) <= EPS2) return { velocity: a.velocity, cc11: a.cc11 };
 }
 function measureHasSoundingNotes(part, measureIndex) {
   return measureIndex === void 0 ? !1 : (part.measures[measureIndex]?.sequences ?? []).some(
@@ -17526,15 +17730,15 @@ function resolveRamps(timed, anchors) {
     startsAfterSilence,
     measureStartTime
   } of ordered) {
-    if (endTime <= startTime + EPS) continue;
-    let chained = prev !== void 0 && Math.abs(prev.endTime - startTime) <= EPS, currentMeasureAnchor = anchors.some(
-      (anchor) => anchor.time >= measureStartTime - EPS && anchor.time <= startTime + EPS
+    if (endTime <= startTime + EPS2) continue;
+    let chained = prev !== void 0 && Math.abs(prev.endTime - startTime) <= EPS2, currentMeasureAnchor = anchors.some(
+      (anchor) => anchor.time >= measureStartTime - EPS2 && anchor.time <= startTime + EPS2
     ), start = authoredStart ?? explicitAnchorAt(anchors, startTime) ?? (startsAfterSilence && !currentMeasureAnchor ? axesOf("p") : chained ? prev.end : sampleAnchorsAxes(anchors, startTime)), end = explicitAnchorAt(anchors, endTime) ?? stepRung(start, dir), ramp = { groupId, startTime, endTime, start, end };
     ramps.push(ramp), prev = ramp;
   }
   return ramps;
 }
-function collectExpandedDynamics(part, measureOrder, measureStartBeats, model, staffMeterTable, timedGroups, gradualTexts) {
+function collectExpandedDynamics(part, measureOrder, measureStartBeats, model, staffMeterTable, timedGroups, gradualTexts, playedSpans) {
   for (let expandedIdx = 0; expandedIdx < measureOrder.length; expandedIdx++) {
     let originalMeasureIndex = measureOrder[expandedIdx], measure = part.measures[originalMeasureIndex];
     if (!measure) continue;
@@ -17546,7 +17750,8 @@ function collectExpandedDynamics(part, measureOrder, measureStartBeats, model, s
       model,
       expandedIdx,
       timedGroups,
-      staffMeterTable
+      staffMeterTable,
+      playedSpans?.[expandedIdx]
     ), collectMeasureGradualTexts(
       measure,
       originalMeasureIndex,
@@ -17554,13 +17759,23 @@ function collectExpandedDynamics(part, measureOrder, measureStartBeats, model, s
       model,
       expandedIdx,
       gradualTexts,
-      staffMeterTable
+      staffMeterTable,
+      playedSpans?.[expandedIdx]
     );
   }
 }
-function buildDynamicsEnvelope(part, measureOrder, measureStartBeats, model, globalMeasures, impliedAnchors = [], resolvedStaffMeters) {
+function buildDynamicsEnvelope(part, measureOrder, measureStartBeats, model, globalMeasures, impliedAnchors = [], resolvedStaffMeters, playedSpans) {
   let anchors = [], attacks = [], timedGroups = [], gradualTexts = [], idToOrig = buildMeasureIdToOrig(globalMeasures), staffMeterTable = resolvedStaffMeters ?? resolvePartStaffMeterTable(part, globalMeasures);
-  collectExpandedDynamics(part, measureOrder, measureStartBeats, model, staffMeterTable, timedGroups, gradualTexts);
+  collectExpandedDynamics(
+    part,
+    measureOrder,
+    measureStartBeats,
+    model,
+    staffMeterTable,
+    timedGroups,
+    gradualTexts,
+    playedSpans
+  );
   let typeRank = { immediate: 0, relative: 1, accent: 2, gradual: 3 };
   timedGroups.sort(
     (a, b) => a.time - b.time || typeRank[a.group.type] - typeRank[b.group.type] || a.group.id.localeCompare(b.group.id)
@@ -17570,7 +17785,7 @@ function buildDynamicsEnvelope(part, measureOrder, measureStartBeats, model, glo
       let body = axesOf(group.value);
       anchors.push({ time, velocity: body.velocity, cc11: body.cc11 });
     } else if (group.type === "relative") {
-      let current = sampleAnchorsAxes(anchors, time - EPS), next = stepRung(current, group.relativeValue === "louder" ? 1 : -1);
+      let current = sampleAnchorsAxes(anchors, time - EPS2), next = stepRung(current, group.relativeValue === "louder" ? 1 : -1);
       anchors.push({ time, velocity: next.velocity, cc11: next.cc11 });
     } else if (group.type === "accent" && (attacks.push({ time, attackVelocity: axesOf(group.value).velocity }), group.residualValue !== void 0)) {
       let body = axesOf(group.residualValue);
@@ -17579,9 +17794,9 @@ function buildDynamicsEnvelope(part, measureOrder, measureStartBeats, model, glo
   for (let expandedIdx = 0; expandedIdx < measureOrder.length; expandedIdx++) {
     let measureIndex = measureOrder[expandedIdx];
     for (let implied of impliedAnchors) {
-      if (implied.measureIndex !== measureIndex) continue;
+      if (implied.measureIndex !== measureIndex || !beatInPlayedSpan(fractionToBeats2(implied.position), playedSpans?.[expandedIdx])) continue;
       let time = model.timeAtBeat(measureStartBeats[expandedIdx] + fractionToBeats2(implied.position));
-      if (anchors.some((anchor) => Math.abs(anchor.time - time) <= EPS)) continue;
+      if (anchors.some((anchor) => Math.abs(anchor.time - time) <= EPS2)) continue;
       let axes = axesOf(implied.value);
       anchors.push({ time, velocity: axes.velocity, cc11: axes.cc11 });
     }
@@ -17616,8 +17831,8 @@ function buildDynamicsEnvelope(part, measureOrder, measureStartBeats, model, glo
     });
   }
   for (let text of gradualTexts) {
-    if (timed.some((hairpin) => Math.abs(hairpin.startTime - text.startTime) <= EPS)) continue;
-    let endpoint = anchors.find((anchor) => anchor.time > text.startTime + EPS);
+    if (timed.some((hairpin) => Math.abs(hairpin.startTime - text.startTime) <= EPS2)) continue;
+    let endpoint = anchors.find((anchor) => anchor.time > text.startTime + EPS2);
     endpoint && timed.push({
       groupId: text.id,
       startTime: text.startTime,
@@ -17632,7 +17847,7 @@ function buildDynamicsEnvelope(part, measureOrder, measureStartBeats, model, glo
 }
 function rampAt(env, t) {
   for (let r of env.ramps)
-    if (t >= r.startTime - EPS && t <= r.endTime + EPS) return r;
+    if (t >= r.startTime - EPS2 && t <= r.endTime + EPS2) return r;
 }
 function sampleDynamics(env, t) {
   let r = rampAt(env, t);
@@ -17644,7 +17859,7 @@ function sampleDynamics(env, t) {
 }
 function attackAt(env, t) {
   for (let c of env.attacks)
-    if (Math.abs(c.time - t) <= EPS) return c;
+    if (Math.abs(c.time - t) <= EPS2) return c;
 }
 function noteVelocityAt(env, t) {
   let c = attackAt(env, t);
@@ -17652,7 +17867,7 @@ function noteVelocityAt(env, t) {
 }
 function rampQuantizationEvents(ramp) {
   let start = ramp.start.cc11, end = ramp.end.cc11;
-  if (start === end || ramp.endTime <= ramp.startTime + EPS)
+  if (start === end || ramp.endTime <= ramp.startTime + EPS2)
     return [
       { time: ramp.startTime, value: start },
       { time: ramp.endTime, value: end }
@@ -17675,13 +17890,13 @@ function cc11Events(env) {
   let out = [];
   for (let e of raw) {
     let prev = out[out.length - 1];
-    if (prev && Math.abs(prev.time - e.time) <= EPS) {
+    if (prev && Math.abs(prev.time - e.time) <= EPS2) {
       out[out.length - 1] = e;
       continue;
     }
     prev && prev.value === e.value || out.push(e);
   }
-  return (out.length === 0 || out[0].time > EPS) && out.unshift({ time: 0, value: DEFAULT_DYNAMIC.cc11 }), out;
+  return (out.length === 0 || out[0].time > EPS2) && out.unshift({ time: 0, value: DEFAULT_DYNAMIC.cc11 }), out;
 }
 function emitDynamicsCc11(env, partIndex, channel, out, playbackLaneId2) {
   for (let ev of cc11Events(env))
@@ -17824,7 +18039,7 @@ function collectRampDiagnostics(lanes) {
   }
   return diagnostics;
 }
-function compileDynamicProgram(part, partIndex, measureOrder, measureStartBeats, model, globalMeasures, gmProgram = -1, impliedAnchors = [], staffMeterTable) {
+function compileDynamicProgram(part, partIndex, measureOrder, measureStartBeats, model, globalMeasures, gmProgram = -1, impliedAnchors = [], staffMeterTable, playedSpans) {
   let scoped = part.measures.some(
     (measure) => measure.dynamics?.some((group) => group.staff !== void 0 || group.voice !== void 0)
   ), scopes = collectLaneScopes(part), selectedScopes = scoped ? scopes : [scopes[0]], profile = selectDynamicResponseProfile(gmProgram), lanes = /* @__PURE__ */ new Map();
@@ -17837,7 +18052,8 @@ function compileDynamicProgram(part, partIndex, measureOrder, measureStartBeats,
         model,
         globalMeasures,
         impliedAnchors,
-        staffMeterTable
+        staffMeterTable,
+        playedSpans
       ),
       profile
     );
@@ -17892,13 +18108,13 @@ function generateTimeline(inputScore, options) {
   let score = expandScoreMeasureRepeats(inputScore), impliedSectionDynamics = analyzeImpliedSectionDynamics(score), globalMeasures = score.global.measures;
   if (globalMeasures.length === 0)
     return emptyTimeline();
-  let chords = compileChordPlayback(score, options?.includeGlobalChords), toCodaMeasureIndex = detectToCodaMeasureIndex(score), measureOrder = options?.expandRepeats === !1 ? globalMeasures.map((_, index) => index) : expandMeasureOrder(globalMeasures, { toCodaMeasureIndex });
+  let chords = compileChordPlayback(score, options?.includeGlobalChords), spans = options?.expandRepeats === !1 ? void 0 : scorePlaybackItinerary(score), measureOrder = options?.expandRepeats === !1 ? globalMeasures.map((_, index) => index) : spans.map((span) => span.measureIndex);
   if (measureOrder.length === 0)
     return emptyTimeline();
   let expandedGlobal = playbackGlobalMeasures(score, measureOrder), holdSchedule = suppressCadenzaFermataHolds(
     expandedGlobal,
     buildHoldSchedule(score, measureOrder, globalMeasures)
-  ), { tempoMap } = buildTempoMap(expandedGlobal, holdSchedule), tempoBuild = buildTempoModel(expandedGlobal, holdSchedule), { model, measureStartTimes, measureStartBeats } = tempoBuild, timing = { tempoMap, measureStartTimes, model, measureStartBeats }, allEvents = [], partChannels = allocatePartChannels(score.parts);
+  ), { tempoMap } = buildTempoMap(expandedGlobal, holdSchedule), tempoBuild = buildTempoModel(expandedGlobal, holdSchedule), { model, measureStartTimes, measureStartBeats } = tempoBuild, timing = { tempoMap, measureStartTimes, model, measureStartBeats, playedSpans: spans }, allEvents = [], partChannels = allocatePartChannels(score.parts);
   for (let partIdx = 0; partIdx < score.parts.length; partIdx++)
     processPart(
       score,
@@ -17931,8 +18147,7 @@ function generateTimeline(inputScore, options) {
   let duration = model.timeAtBeat(tempoBuild.totalBeats), measureTimeSignatures = measureOrder.map((origIdx) => {
     let ts = resolveActiveTime(globalMeasures, origIdx);
     return { count: ts.count, unit: ts.unit };
-  });
-  return {
+  }), result = {
     events: allEvents,
     duration,
     tempoMap,
@@ -17944,6 +18159,7 @@ function generateTimeline(inputScore, options) {
     measureTimeSignatures,
     diagnostics
   };
+  return spans && (globalMeasures.some((measure) => measure.jump !== void 0) || spans.some((span) => span.startBeat > 0 || span.endBeat < span.measureBeats)) ? realizeNavigation(result, spans) : { ...result, playedSpans: spans };
 }
 function assignPhysicalMidiChannels(events, score) {
   let melodicChannels = [0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15], lanesByPart = /* @__PURE__ */ new Map();
@@ -18039,12 +18255,14 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
     globalMeasures,
     gmProgram,
     impliedDynamics,
-    staffMeterTable
+    staffMeterTable,
+    timing.playedSpans
   );
   for (let lane of dynamicProgram.lanes.values())
     emitDynamicsCc11(lane.envelope, partIdx, channel, allEvents, lane.id);
   let techniqueState = { program: gmProgram, muted: !1, instrumentKey: "initial" }, instruments = new Map(playbackInstruments(part).map(({ key, part: instrumentPart2 }) => [key, instrumentPart2])), programForInstrument = (key) => key === "initial" ? gmProgram : options?.instrumentPrograms?.get(partIdx)?.get(key) ?? instruments.get(key)?._x?.viritura?.midiProgram ?? -1;
   for (let expandedIdx = 0; expandedIdx < measureOrder.length; expandedIdx++) {
+    expandedIdx > 0 && timing.playedSpans && !playedSpansContinue(timing.playedSpans[expandedIdx - 1], timing.playedSpans[expandedIdx]) && (allEvents.push(...pendingTieOffs.values(), ...Array.from(pendingLegato.values()).flat()), pendingTieOffs.clear(), pendingLegato.clear());
     let origMeasureIdx = measureOrder[expandedIdx], partMeasure = part.measures[origMeasureIdx];
     if (!partMeasure) continue;
     let measureStartTime = measureStartTimes[expandedIdx], measureStartBeat = measureStartBeats[expandedIdx], instrumentKey = playbackInstrumentKeyAt(part, origMeasureIdx), activeProgram = programForInstrument(instrumentKey), bowCapable = ARCO_CAPABLE_PROGRAMS.has(activeProgram), muteFamily = muteFamilyForProgram(activeProgram), techniqueEnabled = bowCapable || muteFamily !== null;
@@ -18054,6 +18272,8 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       spanEndBeat: h.spanEndBeat ?? h.atBeat,
       insertBeat: h.atBeat
     })), ctx = {
+      playedSpan: timing.playedSpans?.[expandedIdx],
+      graceBoundaryBeat: timing.playedSpans && (expandedIdx === 0 || !playedSpansContinue(timing.playedSpans[expandedIdx - 1], timing.playedSpans[expandedIdx])) ? timing.playedSpans[expandedIdx].startBeat : void 0,
       tempoMap,
       model,
       measureStartBeat,
@@ -18084,7 +18304,12 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       fermataGroups
     };
     (techniqueEnabled || instruments.size > 1) && (techniqueState = applyMeasureTechniques(
-      partMeasure.expressions,
+      partMeasure.expressions?.filter(
+        (expression) => beatInPlayedSpan(
+          fractionToBeats(expression.position.fraction) * staffMeterRatioAt(staffMeterTable, origMeasureIdx, expression.staff),
+          timing.playedSpans?.[expandedIdx]
+        )
+      ),
       ctx,
       techniqueState,
       {
@@ -18185,6 +18410,7 @@ function tryProcessSpecialEvent(ctx, event, measureStartTime, beatOffset, baseVe
 function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity, tupletRatio) {
   ctx.gmProgram = ctx.instrumentAtBeatOffset?.(beatOffset * ctx.staffMeterRatio).program ?? ctx.gmProgram;
   let { partIndex, channel, tieTargets, out, timeSig, kitMidiMap, kitAltProgramMap } = ctx, beats = durationBeats4(event.duration) * tupletRatio;
+  if (!beatInPlayedSpan(beatOffset * ctx.staffMeterRatio, ctx.playedSpan)) return beats;
   if (isRest(event))
     return flushVoiceLegato(ctx.pendingLegato, ctx.voiceKey, ctx.out), beats;
   resolveVoiceLegato({
@@ -18215,7 +18441,7 @@ function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity
   for (let note of event.notes ?? []) {
     let midiNote = noteToMidi(note);
     if (midiNote < 0 || midiNote > 127) continue;
-    let noteId = note.id ?? "", isTiedTo = tieTargets.has(noteId), hasTieOut = note.ties?.some((t) => t.target) ?? !1;
+    let noteId = note.id ?? "", isTiedTo = tieTargets.has(noteId) && ctx.pendingTieOffs.has(`${midiNote}:${partIndex}:${ctx.voiceKey}`), hasTieOut = note.ties?.some((t) => t.target) ?? !1;
     isTiedTo ? extendOrFinalizeTie(ctx, midiNote, startTime, durationSec, durationScale, hasTieOut) : emitFreshNote(
       ctx,
       midiNote,
@@ -18493,19 +18719,22 @@ function tryProcessTrill(ctx, event, measureStartTime, beatOffset, baseVelocity,
 function processGrace(ctx, grace, measureStartTime, beatOffset, tupletRatio) {
   let events = grace.content;
   if (events.length === 0) return 0;
-  let graceBeats = GRACE_NOTE_BEATS * tupletRatio, totalGraceBeats = events.length * graceBeats;
-  if (grace.graceType === "stealFollowing") {
+  let graceBeats = GRACE_NOTE_BEATS * tupletRatio, totalGraceBeats = events.length * graceBeats, following = grace.graceType === "stealFollowing", principalBeat = beatOffset + (following ? totalGraceBeats : 0);
+  if (!beatInPlayedSpan(principalBeat * ctx.staffMeterRatio, ctx.playedSpan))
+    return following ? totalGraceBeats : 0;
+  let graceCtx = { ...ctx, playedSpan: void 0 };
+  if (following) {
     let cursor2 = beatOffset;
     for (let evt of events) {
       let ratio = graceBeats / durationBeats4(evt.duration);
-      processScopedNoteEvent(ctx, evt, measureStartTime, cursor2, ratio), cursor2 += graceBeats;
+      processScopedNoteEvent(graceCtx, evt, measureStartTime, cursor2, ratio), cursor2 += graceBeats;
     }
     return totalGraceBeats;
   }
-  let cursor = beatOffset - totalGraceBeats;
+  let cursor = Math.max(beatOffset - totalGraceBeats, (ctx.graceBoundaryBeat ?? -1 / 0) / ctx.staffMeterRatio);
   for (let evt of events) {
     let ratio = graceBeats / durationBeats4(evt.duration);
-    processScopedNoteEvent(ctx, evt, measureStartTime, cursor, ratio), cursor += graceBeats;
+    processScopedNoteEvent(graceCtx, evt, measureStartTime, cursor, ratio), cursor += graceBeats;
   }
   return 0;
 }