@viritura/score-engine 0.2.1-next.41 → 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);
@@ -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.41", 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 "715e88d4c5a7118150857b4e89598e4560d44b58";
+  return "addcef3a89be5d1d76a3f918b2aacbdc0dd7c30a";
 }
 function bundledAssetBase() {
   let moduleUrl = import.meta.url;
@@ -17439,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;
 }
@@ -17469,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
@@ -17477,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) {
@@ -17501,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) });
@@ -17515,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]), {
@@ -18202,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) {
@@ -18955,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, rhythm = compileRhythmProgram(score), timing = { tempoMap, measureStartTimes, model, measureStartBeats, playedSpans: spans, rhythm }, 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,
@@ -19005,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();
@@ -19036,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)
@@ -19081,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,
@@ -19108,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 });
@@ -19125,7 +19202,7 @@ function processPart(score, partIdx, options, partChannels, timing, measureOrder
       measureStartBeat,
       partIndex: partIdx,
       channel,
-      tieTargets,
+      pendingTieTargets,
       pendingTieOffs,
       legatoOutIds,
       pendingLegato,
@@ -19259,7 +19336,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;
+  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;
@@ -19294,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);
@@ -19344,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,
@@ -19365,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,