@viritura/score-engine 0.2.1-next.40 → 0.2.1-next.42

package/dist/index.js

@@ -358,11 +358,41 @@ init_define_import_meta_env();
 
 // packages/core/src/operations/chordSymbols/modifiers.ts
 init_define_import_meta_env();
+function parseAlteredDegree(text) {
+  let match = /^([b#♭♯])(13|11|9|5)/u.exec(text);
+  if (match)
+    return {
+      degree: Number(match[2]),
+      alter: match[1] === "b" || match[1] === "\u266D" ? -1 : 1,
+      length: match[0].length
+    };
+}
+function finishModifiers(result, inGroup, needsDegree, afterDegree, afterComma) {
+  if (!(inGroup || needsDegree || !afterDegree || afterComma))
+    return {
+      added: [...new Set(result.added)].sort((a, b) => a - b),
+      omitted: [...new Set(result.omitted)].sort((a, b) => a - b),
+      ...result.altered ? {
+        altered: result.altered.filter(
+          (item, index, items) => items.findIndex((other) => other.degree === item.degree && other.alter === item.alter) === index
+        ).sort((a, b) => a.degree - b.degree || a.alter - b.alter)
+      } : {}
+    };
+}
 function parseModifiers(text) {
   let result = { added: [], omitted: [] }, rest = text.trim().toLowerCase();
   if (!rest) return result;
   let operation, needsDegree = !1, afterDegree = !1, inGroup = !1, afterComma = !1;
   for (; rest; ) {
+    let altered = parseAlteredDegree(rest);
+    if (altered) {
+      if (needsDegree) return;
+      (result.altered ??= []).push({
+        degree: altered.degree,
+        alter: altered.alter
+      }), operation = void 0, afterDegree = !0, afterComma = !1, rest = rest.slice(altered.length).trimStart();
+      continue;
+    }
     let marker = /^(add|omit|no)/.exec(rest)?.[0];
     if (marker) {
       if (needsDegree) return;
@@ -386,14 +416,16 @@ function parseModifiers(text) {
       return;
     rest = rest.slice(1).trimStart();
   }
-  if (!(inGroup || needsDegree || !afterDegree || afterComma))
-    return {
-      added: [...new Set(result.added)].sort((a, b) => a - b),
-      omitted: [...new Set(result.omitted)].sort((a, b) => a - b)
-    };
+  return finishModifiers(result, inGroup, needsDegree, afterDegree, afterComma);
 }
 var ADDED_INTERVALS = { 2: 2, 4: 5, 6: 9, 7: 10, 9: 2, 11: 5, 13: 9 };
 function applyModifiers(degrees, modifiers) {
+  let altered = /* @__PURE__ */ new Map();
+  for (let { degree, alter } of modifiers?.altered ?? []) {
+    let natural = degree === 5 ? 7 : ADDED_INTERVALS[degree];
+    altered.set(degree, [...altered.get(degree) ?? [], natural + alter]);
+  }
+  for (let [degree, intervals] of altered) degrees.set(degree, intervals);
   for (let degree of modifiers?.added ?? [])
     degrees.set(degree, [...degrees.get(degree) ?? [], ADDED_INTERVALS[degree]]);
   for (let degree of modifiers?.omitted ?? []) degrees.delete(degree);
@@ -582,11 +614,13 @@ function parseBaseQuality(text) {
   return extension === void 0 ? { quality } : { quality, extension };
 }
 function parseQuality(text) {
-  let boundary = text.search(/add|omit|no|\(/i);
+  let complete = parseBaseQuality(text);
+  if (complete) return complete;
+  let boundary = text.search(/add|omit|no|\(|[b#♭♯](?:13|11|9|5)/iu);
   if (boundary < 0) return parseBaseQuality(text);
   let base = parseBaseQuality(text.slice(0, boundary).trim()), modifiers = parseModifiers(text.slice(boundary));
   if (!(!base || !modifiers))
-    return base.quality === "major" && base.extension === void 0 && modifiers.added.length === 1 && modifiers.added[0] === 6 && modifiers.omitted.length === 0 ? { quality: "major", extension: 6 } : { ...base, modifiers };
+    return base.quality === "major" && base.extension === void 0 && modifiers.added.length === 1 && modifiers.added[0] === 6 && modifiers.omitted.length === 0 && !modifiers.altered?.length ? { quality: "major", extension: 6 } : { ...base, modifiers };
 }
 function parseChordSymbolText(input, position) {
   let parts = splitChordSymbolText(input);
@@ -602,9 +636,9 @@ function parseChordSymbolText(input, position) {
 
 // packages/core/src/operations/lyricExtenders.ts
 init_define_import_meta_env();
-function durationBeats(duration) {
-  let base = DURATION_BEATS[duration.base], dots = 1;
-  for (let index = 0; index < (duration.dots ?? 0); index++) dots += 0.5 ** (index + 1);
+function durationBeats(duration2) {
+  let base = DURATION_BEATS[duration2.base], dots = 1;
+  for (let index = 0; index < (duration2.dots ?? 0); index++) dots += 0.5 ** (index + 1);
   return base * dots;
 }
 function quantityBeats(quantity) {
@@ -614,7 +648,7 @@ function walkTimedContent(content, startBeat, scale, partIndex, sequenceIndex, v
   let cursor = startBeat;
   for (let item of content) {
     if (item.type === "event") {
-      let duration = durationBeats(item.duration) * scale;
+      let duration2 = durationBeats(item.duration) * scale;
       output.push({
         event: item,
         partIndex,
@@ -623,10 +657,10 @@ function walkTimedContent(content, startBeat, scale, partIndex, sequenceIndex, v
         staff,
         measureIndex,
         startBeat: cursor,
-        durationBeats: duration,
+        durationBeats: duration2,
         rest: isRest(item),
         ordinal: ordinal.value++
-      }), cursor += duration;
+      }), cursor += duration2;
       continue;
     }
     if (item.type === "space") {
@@ -2231,9 +2265,9 @@ function interpolateBeatAnchors(bounds, beat, endX) {
 
 // packages/score-engine/src/buildInfo.ts
 init_define_import_meta_env();
-var PACKAGE_VERSION = "0.2.1-next.40", BUNDLE_WORKER_FILE = "score-engine.worker.js";
+var PACKAGE_VERSION = "0.2.1-next.42", BUNDLE_WORKER_FILE = "score-engine.worker.js";
 function buildCommit() {
-  return "aa2b59d2a29c0334fa5cf09255eae831c99f366d";
+  return "addcef3a89be5d1d76a3f918b2aacbdc0dd7c30a";
 }
 function bundledAssetBase() {
   let moduleUrl = import.meta.url;
@@ -16659,8 +16693,8 @@ function parseVideoMedia(raw) {
   typeof contentHash == "string" && contentHash.length > 0 && (media.contentHash = contentHash);
   let demoSourceId = raw?.demoSourceId;
   typeof demoSourceId == "string" && demoSourceId.length > 0 && (media.demoSourceId = demoSourceId);
-  let duration = raw?.durationSeconds;
-  return typeof duration == "number" && Number.isFinite(duration) && duration > 0 && (media.durationSeconds = duration), media;
+  let duration2 = raw?.durationSeconds;
+  return typeof duration2 == "number" && Number.isFinite(duration2) && duration2 > 0 && (media.durationSeconds = duration2), media;
 }
 function parseRootVideoSync(rootX) {
   let raw = rootX?.viritura?.videoSync;
@@ -17153,7 +17187,7 @@ function buildTempoMap(globalMeasures, holds) {
     if (gm.tempos && gm.tempos.length > 0) {
       for (let tempo of gm.tempos) {
         if (tempo.bpm === void 0) continue;
-        let beatOffset = tempo.location ? tempo.location.fraction[0] / tempo.location.fraction[1] * mBeats : 0, qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
+        let beatOffset = tempo.location ? posBeats(tempo.location.fraction) : 0, qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
         changes.push({ beatOffset, qpm });
       }
       changes.sort((a, b) => a.beatOffset - b.beatOffset);
@@ -17186,10 +17220,10 @@ function buildTempoModel(globalMeasures, holds) {
     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));
+      let sorted = [...gm.tempos].sort((a, b) => tempoBeat(a) - tempoBeat(b));
       for (let tempo of sorted) {
         if (tempo.bpm === void 0) continue;
-        let startBeat = cumBeats + tempoBeat(tempo, mBeats), qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
+        let startBeat = cumBeats + tempoBeat(tempo), qpm = effectiveQpm(tempo.bpm, tempo.value.base, tempo.value.dots);
         regions.push({ startBeat, endBeat: 1 / 0, startBpm: qpm, endBpm: qpm });
       }
     }
@@ -17243,8 +17277,8 @@ function resolveGradualEndBeat(end, fromIdx, globalMeasures, measureStartBeats,
   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;
+function tempoBeat(tempo) {
+  return tempo.location ? posBeats(tempo.location.fraction) : 0;
 }
 
 // packages/midi/src/cadenzaTiming.ts
@@ -17284,14 +17318,14 @@ 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);
+  }, inheritedTempos = [], resolved = score.global.measures.map((original, measureIndex) => {
+    inheritedTempos.push(activeTempo), 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(
+      tempos: original.tempos
+    }, metronomicTempos = original.tempos?.filter((tempo) => tempo.bpm !== void 0);
+    if (metronomicTempos?.length && (activeTempo = [...metronomicTempos].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);
@@ -17317,7 +17351,13 @@ function playbackGlobalMeasures(score, measureOrder) {
       }
     };
   });
-  return measureOrder.map((index) => resolved[index]);
+  return measureOrder.map((index, expandedIndex) => {
+    let measure = resolved[index];
+    return expandedIndex === 0 || index === measureOrder[expandedIndex - 1] + 1 || measure.tempos?.some((tempo) => tempo.bpm !== void 0 && (!tempo.location || tempo.location.fraction[0] === 0)) ? measure : {
+      ...measure,
+      tempos: [{ ...inheritedTempos[index], location: { fraction: [0, 1] } }, ...measure.tempos ?? []]
+    };
+  });
 }
 function suppressCadenzaFermataHolds(measures, holds) {
   return holds.map(
@@ -17433,6 +17473,17 @@ function compileNavigation(measures, initialOrder, measureLengths) {
 
 // packages/midi/src/navigation/realization.ts
 init_define_import_meta_env();
+function navigationNoteKey(event) {
+  return `${event.partIndex}:${event.playbackLaneId ?? event.channel}:${event.midiNote}:${event.drumKitProgram ?? ""}`;
+}
+function releaseUncontinuedNotes(activeNotes, continuations, time, out) {
+  let continued = new Set(continuations.map(navigationNoteKey));
+  for (let [key, pending] of activeNotes)
+    if (!continued.has(key)) {
+      for (let onset of pending) out.push({ ...onset, type: "noteOff", velocity: 0, time });
+      pending.length = 0;
+    }
+}
 function authoredOnsetInSpan(event, start, end) {
   return event.type === "noteOn" && event.scoreBeat !== void 0 && event.scoreBeat >= start - 1e-9 && event.scoreBeat < end - 1e-9;
 }
@@ -17463,7 +17514,7 @@ function spanTempoMap(timeline, index, span, model, outputBeat) {
   }
   return entries;
 }
-function realizeNavigation(timeline, spans) {
+function realizeNavigation(timeline, spans, crossJumpContinuations = /* @__PURE__ */ new Map()) {
   let sourceSpans = spans.map((span, index) => ({
     startBeat: timeline.measureStartBeats[index] + span.startBeat,
     endBeat: timeline.measureStartBeats[index] + span.endBeat
@@ -17471,7 +17522,7 @@ function realizeNavigation(timeline, spans) {
   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 ?? ""}`;
+    let translate = (time) => model.timeAtBeat(outputBeat) + Math.min(endTime - startTime, Math.max(0, time - startTime));
     for (let event of timeline.events) {
       let authoredOnset = authoredOnsetInSpan(event, source.startBeat, source.endBeat);
       if (event.time < startTime - 1e-9 && !authoredOnset) {
@@ -17495,10 +17546,10 @@ function realizeNavigation(timeline, spans) {
             )
           };
           events.push(output);
-          let key = noteKey(event), pending = activeNotes.get(key) ?? [];
+          let key = navigationNoteKey(event), pending = activeNotes.get(key) ?? [];
           pending.push(output), activeNotes.set(key, pending);
         } else if (event.type === "noteOff") {
-          let pending = activeNotes.get(noteKey(event));
+          let pending = activeNotes.get(navigationNoteKey(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) });
@@ -17509,18 +17560,12 @@ function realizeNavigation(timeline, spans) {
       ...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;
+    playedSpansContinue(span, next) || releaseUncontinuedNotes(
+      activeNotes,
+      crossJumpContinuations.get(index + 1) ?? [],
+      model.timeAtBeat(outputBeat + span.endBeat - span.startBeat, "release"),
+      events
+    ), 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]), {
@@ -17687,9 +17732,9 @@ function compileChordPlayback(score, includeGlobalChords = !0) {
 function realizeChordPlayback(program, measureOrder, timing) {
   let notes = [], pitches = [], startBeat = 0, occurrence = 0, finish = (endBeat) => {
     if (endBeat <= startBeat) return;
-    let startTime = timing.model.timeAtBeat(startBeat), duration = timing.model.timeAtBeat(endBeat) - startTime;
+    let startTime = timing.model.timeAtBeat(startBeat), duration2 = timing.model.timeAtBeat(endBeat) - startTime;
     for (let pitch of pitches)
-      notes.push({ id: `${CHORDS_PART_ID}:${occurrence}:${pitch}`, pitch, startTime, duration });
+      notes.push({ id: `${CHORDS_PART_ID}:${occurrence}:${pitch}`, pitch, startTime, duration: duration2 });
     occurrence++;
   };
   for (let expandedIndex = 0; expandedIndex < measureOrder.length; expandedIndex++) {
@@ -17758,9 +17803,9 @@ var WHOLE_DURATIONS = {
   "512th": 1 / 512,
   "1024th": 1 / 1024
 };
-function durationValue(duration) {
-  let base = WHOLE_DURATIONS[duration.base] ?? 0, value = base;
-  for (let dot = 0; dot < (duration.dots ?? 0); dot++) value += base / 2 ** (dot + 1);
+function durationValue(duration2) {
+  let base = WHOLE_DURATIONS[duration2.base] ?? 0, value = base;
+  for (let dot = 0; dot < (duration2.dots ?? 0); dot++) value += base / 2 ** (dot + 1);
   return value;
 }
 function contentInfo(content, scale = 1) {
@@ -17769,8 +17814,8 @@ function contentInfo(content, scale = 1) {
     if (item.type === "event") {
       let sounding = !!item.notes?.length || !!item.kitNotes?.length;
       sounding && (active = !0, onset ??= cursor);
-      let duration = durationValue(item.duration) * scale;
-      return cursor += duration, {
+      let duration2 = durationValue(item.duration) * scale;
+      return cursor += duration2, {
         duration: item.duration,
         sounding
       };
@@ -17780,13 +17825,13 @@ function contentInfo(content, scale = 1) {
       return nested.active && (active = !0, onset ??= cursor + nested.onset), cursor += nested.duration, { type: item.type, inner: item.inner, outer: item.outer, content: nested.signature };
     }
     if (item.type === "tremolo") {
-      let duration = durationValue(item.outer.duration) * item.outer.multiple * scale;
-      return item.content.some((event) => !!event.notes?.length || !!event.kitNotes?.length) && (active = !0, onset ??= cursor), cursor += duration, { type: item.type, outer: item.outer, content: item.content.map((event) => event.duration) };
+      let duration2 = durationValue(item.outer.duration) * item.outer.multiple * scale;
+      return item.content.some((event) => !!event.notes?.length || !!event.kitNotes?.length) && (active = !0, onset ??= cursor), cursor += duration2, { type: item.type, outer: item.outer, content: item.content.map((event) => event.duration) };
     }
     if (item.type === "grace") return { type: item.type, content: item.content.map((event) => event.duration) };
     if (item.type === "space") {
-      let duration = (item.duration[1] === 0 ? 0 : item.duration[0] / item.duration[1]) * scale;
-      return cursor += duration, { type: item.type, duration: item.duration };
+      let duration2 = (item.duration[1] === 0 ? 0 : item.duration[0] / item.duration[1]) * scale;
+      return cursor += duration2, { type: item.type, duration: item.duration };
     }
     return {};
   }), active, onset, duration: cursor };
@@ -18128,8 +18173,8 @@ function resolveVoiceLegato(a) {
   if (!bucket || bucket.length === 0) return;
   let onset = Math.max(
     0,
-    a.model.timeAtBeat(a.measureStartBeat + a.beatOffset) + timingHumanize(a.measureStartTime, a.beatOffset, a.partIndex)
-  ), nextDur = a.model.secondsForBeats(a.measureStartBeat + a.beatOffset, a.beats);
+    (a.soundingOnset ?? a.model.timeAtBeat(a.measureStartBeat + a.beatOffset)) + timingHumanize(a.measureStartTime, a.beatOffset, a.partIndex)
+  ), nextDur = a.soundingDuration ?? a.model.secondsForBeats(a.measureStartBeat + a.beatOffset, a.beats);
   resolveLegato(bucket, a.out, onset, nextDur, a.notes);
 }
 
@@ -18196,6 +18241,44 @@ function applyMeasureTechniques(expressions, ctx, state, caps, ratioForStaff = (
   return { program, muted, ...instrumentKey === void 0 ? {} : { instrumentKey } };
 }
 
+// packages/midi/src/tiePlayback/index.ts
+init_define_import_meta_env();
+function tiePlaybackKey(pitch, partIndex, voice) {
+  return `${pitch}:${partIndex}:${voice}`;
+}
+function recordTieTargets(state, key, note) {
+  let targets = note.ties?.filter((tie) => tie.lv !== !0 && tie.target !== void 0) ?? [];
+  targets.length ? state.set(key, targets) : state.delete(key);
+}
+function tieContinuesTo(state, key, note) {
+  return note.id !== void 0 && (state.get(key)?.some((tie) => tie.target === note.id) ?? !1);
+}
+function notesAtBeat(content, target, notes, offset = 0, ratio = 1) {
+  let beat = offset;
+  for (let item of content) {
+    if (item.type === "event")
+      Math.abs(beat - target) < 1e-9 && notes.push(...item.notes ?? []), beat += durationBeats4(item.duration) * ratio;
+    else if (item.type === "tuplet") {
+      let factor = durationBeats4(item.outer.duration) * item.outer.multiple / (durationBeats4(item.inner.duration) * item.inner.multiple);
+      beat = notesAtBeat(item.content, target, notes, beat, ratio * factor);
+    } else item.type === "space" ? beat += item.duration[0] / item.duration[1] * 4 * ratio : item.type === "tremolo" && (Math.abs(beat - target) < 1e-9 && notes.push(...item.content[0]?.notes ?? []), beat += durationBeats4(item.outer.duration) * item.outer.multiple * ratio);
+    if (beat > target + 1e-9) break;
+  }
+  return beat;
+}
+function crossJumpContinuationKeys(state, measure, startBeat, partIndex, ratioForStaff) {
+  let keys = /* @__PURE__ */ new Set();
+  for (let [index, sequence] of (measure?.sequences ?? []).entries()) {
+    let notes = [];
+    notesAtBeat(sequence.content, startBeat / ratioForStaff(sequence.staff ?? 1), notes);
+    for (let note of notes) {
+      let key = tiePlaybackKey(pitchToMidi(note.pitch), partIndex, sequence.voice ?? `v${index}`);
+      note.id !== void 0 && state.get(key)?.some((tie) => tie.targetType === "crossJump" && tie.target === note.id) && keys.add(key);
+    }
+  }
+  return keys;
+}
+
 // packages/midi/src/instrumentPlayback/index.ts
 init_define_import_meta_env();
 function instrumentPart(part, instrument) {
@@ -18808,6 +18891,107 @@ function laneForScope(program, partIndex, staff, voice) {
   return program.lanes.get(id) ?? program.lanes.values().next().value;
 }
 
+// packages/midi/src/rhythmRealization/index.ts
+init_define_import_meta_env();
+var EPS3 = 1e-9;
+function duration(d) {
+  return DURATION_BEATS[d.base] * (d.dots ? 2 - 2 ** -d.dots : 1);
+}
+function itemBeats(item) {
+  switch (item.type) {
+    case "event":
+      return duration(item.duration);
+    case "space":
+      return item.duration[0] * 4 / item.duration[1];
+    case "tuplet":
+    case "tremolo":
+      return duration(item.outer.duration) * item.outer.multiple;
+    case "grace":
+      return 0;
+  }
+}
+function eligible(item, sequence) {
+  return item?.type === "event" && !item.duration.dots && (item.staff === void 0 || item.staff === (sequence.staff ?? 1)) && item.markings?.tremolo === void 0 && item.markings?.trill === void 0;
+}
+function swingAt(anchors, beat) {
+  let result = { mode: "straight" };
+  for (let anchor of anchors) {
+    if (anchor.beat > beat + EPS3) break;
+    result = anchor.swing;
+  }
+  return result;
+}
+function containsGrace(content) {
+  return content.some((item) => item.type === "grace" || item.type === "tuplet" && containsGrace(item.content));
+}
+function compileSequence(sequence, anchors, metricOffset, measureBeats3, holdBeats) {
+  let timings = /* @__PURE__ */ new Map();
+  if (sequence.fullMeasure || containsGrace(sequence.content)) return timings;
+  let cursor = 0;
+  for (let index = 0; index < sequence.content.length; index++) {
+    let first = sequence.content[index], second = sequence.content[index + 1], swing2 = swingAt(anchors, cursor), beats = itemBeats(first), pairEnd = cursor + 2 * beats;
+    if (swing2.mode === "swing" && eligible(first, sequence) && eligible(second, sequence) && first.duration.base === swing2.subdivision && second.duration.base === swing2.subdivision && Math.abs((cursor + metricOffset) / (2 * beats) - Math.round((cursor + metricOffset) / (2 * beats))) < EPS3 && pairEnd <= measureBeats3 + EPS3 && !holdBeats.some((beat) => beat > cursor + EPS3 && beat < pairEnd - EPS3) && !anchors.some((anchor) => anchor.beat > cursor + EPS3 && anchor.beat < pairEnd - EPS3)) {
+      let split = cursor + 2 * beats * swing2.ratio[0] / (swing2.ratio[0] + swing2.ratio[1]);
+      timings.set(first, { start: cursor, end: split, pairStart: cursor, pairEnd }), timings.set(second, { start: split, end: pairEnd, pairStart: cursor, pairEnd });
+    }
+    cursor += beats;
+  }
+  return timings;
+}
+function compileRhythmProgram(score) {
+  let indices = score.global.measures.map((_, index) => index), playbackMeasures = playbackGlobalMeasures(score, indices), holds = buildHoldSchedule(score, indices, score.global.measures), inherited = { mode: "straight" }, anchorsByMeasure = score.global.measures.map((measure) => {
+    let anchors = [{ beat: -1 / 0, swing: inherited }], ordered = (measure.tempos ?? []).map((tempo, index) => ({
+      tempo,
+      index,
+      beat: (tempo.location?.fraction[0] ?? 0) * 4 / (tempo.location?.fraction[1] ?? 1)
+    })).sort((a, b) => a.beat - b.beat || a.index - b.index);
+    for (let { tempo, beat } of ordered)
+      if (tempo.swing) {
+        if (tempo.swing.mode === "swing" && !tempo.swing.ratio.every((value) => Number.isSafeInteger(value) && value > 0))
+          throw new Error("Swing ratios must be positive safe integers.");
+        inherited = tempo.swing, anchors.push({ beat, swing: inherited });
+      }
+    return anchors;
+  }), sequences = /* @__PURE__ */ new Map(), diagnostics = [];
+  return score.parts.forEach((part, partIndex) => {
+    let staffMeters = resolvePartStaffMeterTable(part, score.global.measures);
+    part.measures.forEach((measure, measureIndex) => {
+      let anchors = anchorsByMeasure[measureIndex];
+      if (!anchors) return;
+      let time = resolveActiveTime(score.global.measures, measureIndex), playbackTime = playbackMeasures[measureIndex].time, measureBeats3 = playbackTime.count * 4 / playbackTime.unit, metricOffset = measureIndex === 0 && score.global.measures[0].number === 0 ? time.count * 4 / time.unit - measureBeats3 : 0, diagnosed = /* @__PURE__ */ new Set(), hasSwing = [
+        0,
+        ...anchors.map((anchor) => anchor.beat).filter((beat) => beat > 0 && beat < measureBeats3)
+      ].some((beat) => swingAt(anchors, beat).mode === "swing");
+      for (let sequence of measure.sequences) {
+        let staff = sequence.staff ?? 1;
+        if (staffMeters[measureIndex]?.has(staff)) {
+          !diagnosed.has(staff) && hasSwing && (diagnostics.push({
+            code: "swing-staff-meter-unsupported",
+            source: { partIndex, measureIndex, staff },
+            message: `Swing left literal in part ${partIndex}, measure ${measureIndex}, staff ${staff}: local staff meters are not supported.`,
+            playbackLaneIds: []
+          }), diagnosed.add(staff));
+          continue;
+        }
+        time.display !== "senzaMisura" && sequences.set(
+          sequence,
+          compileSequence(
+            sequence,
+            anchors,
+            metricOffset,
+            measureBeats3,
+            (holds[measureIndex] ?? []).map((hold) => hold.atBeat)
+          )
+        );
+      }
+    });
+  }), { sequences, diagnostics };
+}
+function realizeRhythmEvent(timings, event, start, beats, span) {
+  let timing = timings?.get(event);
+  return !timing || span && (timing.pairStart < span.startBeat - EPS3 || timing.pairEnd > span.endBeat + EPS3) ? { start, beats } : { start: timing.start, beats: timing.end - timing.start };
+}
+
 // packages/midi/src/timeline.ts
 var GM_DRUM_CHANNEL = 9;
 function noteToMidi(note) {
@@ -18848,7 +19032,15 @@ function generateTimeline(inputScore, options) {
   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, playedSpans: spans }, allEvents = [], partChannels = allocatePartChannels(score.parts);
+  ), { tempoMap } = buildTempoMap(expandedGlobal, holdSchedule), tempoBuild = buildTempoModel(expandedGlobal, holdSchedule), { model, measureStartTimes, measureStartBeats } = tempoBuild, rhythm = compileRhythmProgram(score), crossJumpContinuations = /* @__PURE__ */ new Map(), timing = {
+    tempoMap,
+    measureStartTimes,
+    model,
+    measureStartBeats,
+    playedSpans: spans,
+    rhythm,
+    crossJumpContinuations
+  }, allEvents = [], partChannels = allocatePartChannels(score.parts);
   for (let partIdx = 0; partIdx < score.parts.length; partIdx++)
     processPart(
       score,
@@ -18876,14 +19068,19 @@ function generateTimeline(inputScore, options) {
     { model, measureStartBeats, measureOrder },
     options?.instrumentPrograms,
     options?.partPrograms
-  ), diagnostics = [...assignPhysicalMidiChannels(allEvents, score), ...instrumentDiagnostics];
+  ), diagnostics = [
+    ...assignPhysicalMidiChannels(allEvents, score),
+    ...instrumentDiagnostics,
+    ...rhythm.diagnostics
+  ];
+  for (let diagnostic of diagnostics) options?.onDiagnostic?.(diagnostic);
   allEvents.sort(compareEvents);
-  let duration = model.timeAtBeat(tempoBuild.totalBeats), measureTimeSignatures = measureOrder.map((origIdx) => {
+  let duration2 = model.timeAtBeat(tempoBuild.totalBeats), measureTimeSignatures = measureOrder.map((origIdx) => {
     let ts = resolveActiveTime(globalMeasures, origIdx);
     return { count: ts.count, unit: ts.unit };
   }), result = {
     events: allEvents,
-    duration,
+    duration: duration2,
     tempoMap,
     measureStartTimes,
     model,
@@ -18893,7 +19090,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 };
+  return spans && (globalMeasures.some((measure) => measure.jump !== void 0) || spans.some((span) => span.startBeat > 0 || span.endBeat < span.measureBeats)) ? realizeNavigation(result, spans, crossJumpContinuations) : { ...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();
@@ -18924,24 +19121,6 @@ function assignPhysicalMidiChannels(events, score) {
     event.channel = channelByLane.get(event.playbackLaneId ?? `part:${event.partIndex}`) ?? event.channel;
   return diagnostics;
 }
-function collectNoteTieTargets(notes, targets) {
-  if (notes) {
-    for (let note of notes)
-      if (note.ties)
-        for (let tie of note.ties)
-          tie.target && targets.add(tie.target);
-  }
-}
-function collectTieTargets(content, targets) {
-  for (let item of content)
-    if (item.type === "event")
-      collectNoteTieTargets(item.notes, targets);
-    else if (item.type === "tuplet")
-      collectTieTargets(item.content, targets);
-    else if (item.type === "grace")
-      for (let evt of item.content)
-        collectNoteTieTargets(evt.notes, targets);
-}
 function allocatePartChannels(parts) {
   let channels = [], melodicCounter = 0;
   for (let part of parts)
@@ -18969,18 +19148,17 @@ function buildKitAltProgramMap(part) {
     typeof comp.drumKit == "number" && (map ??= /* @__PURE__ */ new Map()).set(id, comp.drumKit);
   return map;
 }
-function collectPartTieTargets(part, measureOrder) {
-  let tieTargets = /* @__PURE__ */ new Set();
-  for (let expandedIdx of measureOrder) {
-    let partMeasure = part.measures[expandedIdx];
-    if (partMeasure)
-      for (let seq of partMeasure.sequences)
-        collectTieTargets(seq.content, tieTargets);
+function retainCrossJumpNoteOffs(pending, targets, continuing, cutTime, continued, out) {
+  for (let [key, noteOff] of pending) {
+    if (continuing.has(key) && noteOff.time >= cutTime - 1e-7) {
+      continued.push(noteOff);
+      continue;
+    }
+    noteOff.time = Math.min(noteOff.time, cutTime), out.push(noteOff), pending.delete(key), targets.delete(key);
   }
-  return tieTargets;
 }
 function processPart(score, partIdx, options, partChannels, timing, measureOrder, globalMeasures, holdSchedule, impliedDynamics, allEvents) {
-  let { tempoMap, measureStartTimes, model, measureStartBeats } = timing, part = score.parts[partIdx], channel = partChannels[partIdx], gmProgram = options?.partPrograms?.[partIdx] ?? -1, kitMidiMap = buildKitMidiMap(score, part), kitAltProgramMap = buildKitAltProgramMap(part), tieTargets = collectPartTieTargets(part, measureOrder), pendingTieOffs = /* @__PURE__ */ new Map(), legatoOutIds = collectPartLegatoOut(part), pendingLegato = /* @__PURE__ */ new Map(), staffMeterTable = resolvePartStaffMeterTable(part, globalMeasures), dynamicProgram = compileDynamicProgram(
+  let { tempoMap, measureStartTimes, model, measureStartBeats } = timing, part = score.parts[partIdx], channel = partChannels[partIdx], gmProgram = options?.partPrograms?.[partIdx] ?? -1, kitMidiMap = buildKitMidiMap(score, part), kitAltProgramMap = buildKitAltProgramMap(part), pendingTieTargets = /* @__PURE__ */ new Map(), pendingTieOffs = /* @__PURE__ */ new Map(), legatoOutIds = collectPartLegatoOut(part), pendingLegato = /* @__PURE__ */ new Map(), staffMeterTable = resolvePartStaffMeterTable(part, globalMeasures), dynamicProgram = compileDynamicProgram(
     part,
     partIdx,
     measureOrder,
@@ -18996,8 +19174,19 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
     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 (expandedIdx > 0 && timing.playedSpans && !playedSpansContinue(timing.playedSpans[expandedIdx - 1], timing.playedSpans[expandedIdx])) {
+      let continuing = crossJumpContinuationKeys(
+        pendingTieTargets,
+        partMeasure,
+        timing.playedSpans[expandedIdx].startBeat,
+        partIdx,
+        (staff) => staffMeterRatioAt(staffMeterTable, origMeasureIdx, staff)
+      ), cutTime = model.timeAtBeat(
+        measureStartBeats[expandedIdx - 1] + timing.playedSpans[expandedIdx - 1].endBeat
+      ), continued = timing.crossJumpContinuations.get(expandedIdx) ?? [];
+      retainCrossJumpNoteOffs(pendingTieOffs, pendingTieTargets, continuing, cutTime, continued, allEvents), timing.crossJumpContinuations.set(expandedIdx, continued), allEvents.push(...Array.from(pendingLegato.values()).flat()), pendingLegato.clear();
+    }
     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;
     instrumentKey !== techniqueState.instrumentKey && (techniqueState = { program: activeProgram, muted: !1, instrumentKey });
@@ -19013,7 +19202,7 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       measureStartBeat,
       partIndex: partIdx,
       channel,
-      tieTargets,
+      pendingTieTargets,
       pendingTieOffs,
       legatoOutIds,
       pendingLegato,
@@ -19056,7 +19245,7 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       let lane = laneForSequence(dynamicProgram, partIdx, seq, seqIdx);
       ctx.sequenceStaff = seq.staff ?? 1, ctx.sequenceVoice = lane.voice, ctx.dynamicsEnvelope = lane.envelope, ctx.playbackLaneId = lane.id;
       let effectiveStaffMeter = staffMeterTable[origMeasureIdx]?.get(ctx.sequenceStaff);
-      ctx.timeSig = effectiveStaffMeter ? effectiveStaffMeter.timeSignature : activeTime, ctx.staffMeterRatio = staffMeterRatioAt(staffMeterTable, origMeasureIdx, ctx.sequenceStaff);
+      ctx.timeSig = effectiveStaffMeter ? effectiveStaffMeter.timeSignature : activeTime, ctx.staffMeterRatio = staffMeterRatioAt(staffMeterTable, origMeasureIdx, ctx.sequenceStaff), ctx.rhythm = timing.rhythm.sequences.get(seq);
       let firstNewEvent = allEvents.length;
       processSequence(ctx, seq, measureStartTime, measureHolds, measureSpq), stampPlaybackLane(allEvents, firstNewEvent, lane.id), stampPendingLane(ctx, lane.id);
     });
@@ -19093,7 +19282,11 @@ function processScopedNoteEvent(ctx, event, measureStartTime, beatOffset, tuplet
     event,
     measureStartTime,
     beatOffset,
-    dynamicVelocityAt(ctx, measureStartTime, beatOffset),
+    dynamicVelocityAt(
+      ctx,
+      measureStartTime,
+      realizeRhythmEvent(ctx.rhythm, event, beatOffset, durationBeats4(event.duration) * tupletRatio, ctx.playedSpan).start
+    ),
     tupletRatio
   );
   return stampPlaybackLane(ctx.out, firstNewEvent, lane.id), stampPendingLane(ctx, lane.id), ctx.dynamicsEnvelope = previousEnvelope, ctx.playbackLaneId = previousLaneId, beats;
@@ -19120,13 +19313,13 @@ function processContentItem(ctx, item, measureStartTime, beatOffset, tupletRatio
       return 0;
   }
 }
-function resolveFermataDuration(ctx, event, naturalDurationSec, beatOffset) {
+function resolveFermataDuration(ctx, event, naturalDurationSec, beatOffset, soundingBeatOffset = beatOffset) {
   if (event.fermata && event.fermata.duration !== "none" && ctx.fermataGroups.length > 0) {
     let globalBeatOffset = beatOffset * ctx.staffMeterRatio, group = ctx.fermataGroups.find(
       (g) => globalBeatOffset >= g.startBeat - 1e-9 && globalBeatOffset < g.spanEndBeat - 1e-9
     );
     if (group) {
-      let startTime = eventTime(ctx, beatOffset), resumeTime = ctx.model.timeAtBeat(ctx.measureStartBeat + group.insertBeat);
+      let startTime = eventTime(ctx, soundingBeatOffset), resumeTime = ctx.model.timeAtBeat(ctx.measureStartBeat + group.insertBeat);
       return { durationSec: Math.max(naturalDurationSec, resumeTime - startTime), durationScale: 1, held: !0 };
     }
   }
@@ -19143,10 +19336,11 @@ 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;
+  let { partIndex, channel, 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;
+  let realized = realizeRhythmEvent(ctx.rhythm, event, beatOffset, beats, ctx.playedSpan), startTime = eventTime(ctx, realized.start), naturalDurationSec = eventSeconds(ctx, realized.start, realized.beats);
   resolveVoiceLegato({
     map: ctx.pendingLegato,
     voiceKey: ctx.voiceKey,
@@ -19157,15 +19351,17 @@ function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity
     measureStartTime,
     beatOffset,
     beats,
-    notes: event.notes ?? []
+    notes: event.notes ?? [],
+    soundingOnset: startTime,
+    soundingDuration: naturalDurationSec
   });
   let specialBeats = tryProcessSpecialEvent(ctx, event, measureStartTime, beatOffset, baseVelocity, beats);
   if (specialBeats !== null) return specialBeats;
-  let startTime = eventTime(ctx, beatOffset), timingOffset = timingHumanize(measureStartTime, beatOffset, partIndex), naturalDurationSec = eventSeconds(ctx, beatOffset, beats), {
+  let timingOffset = timingHumanize(measureStartTime, beatOffset, partIndex), {
     durationSec,
     durationScale,
     held: fermataHeld
-  } = resolveFermataDuration(ctx, event, naturalDurationSec, beatOffset), velocity = Math.min(
+  } = resolveFermataDuration(ctx, event, naturalDurationSec, beatOffset, realized.start), velocity = Math.min(
     127,
     Math.max(
       1,
@@ -19175,23 +19371,29 @@ 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) && 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,
-      startTime,
-      timingOffset,
-      durationSec,
-      durationScale,
-      velocity,
-      hasTieOut,
-      legatoOut,
-      {
-        scoreBeat: ctx.measureStartBeat + beatOffset * ctx.staffMeterRatio,
-        scoreDurationBeats: beats * ctx.staffMeterRatio,
-        scoreEventId: event.id
-      }
-    );
+    let key = tiePlaybackKey(midiNote, partIndex, ctx.voiceKey), isTiedTo = tieContinuesTo(ctx.pendingTieTargets, key, note) && ctx.pendingTieOffs.has(key), hasTieOut = note.ties?.some((t) => t.lv !== !0 && t.target) ?? !1;
+    if (isTiedTo)
+      extendOrFinalizeTie(ctx, midiNote, startTime, durationSec, durationScale, hasTieOut);
+    else {
+      let previous = ctx.pendingTieOffs.get(key);
+      previous && (out.push(previous), ctx.pendingTieOffs.delete(key)), emitFreshNote(
+        ctx,
+        midiNote,
+        startTime,
+        timingOffset,
+        durationSec,
+        durationScale,
+        velocity,
+        hasTieOut,
+        legatoOut,
+        {
+          scoreBeat: ctx.measureStartBeat + beatOffset * ctx.staffMeterRatio,
+          scoreDurationBeats: beats * ctx.staffMeterRatio,
+          scoreEventId: event.id
+        }
+      );
+    }
+    recordTieTargets(ctx.pendingTieTargets, key, note);
   }
   if (kitMidiMap) {
     let jitteredStart = Math.max(0, startTime + timingOffset);
@@ -19225,7 +19427,7 @@ function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity
   return beats;
 }
 function extendOrFinalizeTie(ctx, midiNote, startTime, durationSec, durationScale, hasTieOut) {
-  let { partIndex, channel, pendingTieOffs, out } = ctx, tieKey = `${midiNote}:${partIndex}:${ctx.voiceKey}`, pending = pendingTieOffs.get(tieKey);
+  let { partIndex, channel, pendingTieOffs, out } = ctx, tieKey = tiePlaybackKey(midiNote, partIndex, ctx.voiceKey), pending = pendingTieOffs.get(tieKey);
   pending && (hasTieOut ? pending.time = startTime + durationSec : (pending.time = startTime + durationSec * durationScale, out.push(pending), pendingTieOffs.delete(tieKey))), hasTieOut && !pendingTieOffs.has(tieKey) && pendingTieOffs.set(tieKey, {
     type: "noteOff",
     time: startTime + durationSec,
@@ -19246,7 +19448,7 @@ function emitFreshNote(ctx, midiNote, startTime, timingOffset, durationSec, dura
     channel,
     ...metadata
   }), hasTieOut) {
-    let tieKey = `${midiNote}:${partIndex}:${ctx.voiceKey}`;
+    let tieKey = tiePlaybackKey(midiNote, partIndex, ctx.voiceKey);
     pendingTieOffs.set(tieKey, {
       type: "noteOff",
       time: startTime + durationSec,