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

package/dist/index.js

@@ -602,9 +602,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 +614,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 +623,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 +2231,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.41", BUNDLE_WORKER_FILE = "score-engine.worker.js";
 function buildCommit() {
-  return "aa2b59d2a29c0334fa5cf09255eae831c99f366d";
+  return "715e88d4c5a7118150857b4e89598e4560d44b58";
 }
 function bundledAssetBase() {
   let moduleUrl = import.meta.url;
@@ -16659,8 +16659,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 +17153,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 +17186,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 +17243,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 +17284,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 +17317,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(
@@ -17687,9 +17693,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 +17764,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 +17775,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 +17786,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 +18134,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);
 }
 
@@ -18808,6 +18814,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 +18955,7 @@ 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), timing = { tempoMap, measureStartTimes, model, measureStartBeats, playedSpans: spans, rhythm }, allEvents = [], partChannels = allocatePartChannels(score.parts);
   for (let partIdx = 0; partIdx < score.parts.length; partIdx++)
     processPart(
       score,
@@ -18876,14 +18983,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,
@@ -19056,7 +19168,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 +19205,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 +19236,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 };
     }
   }
@@ -19147,6 +19263,7 @@ function processNoteEvent(ctx, event, measureStartTime, beatOffset, baseVelocity
   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 +19274,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,