@coderline/alphatab 1.6.0-alpha.1418 → 1.6.0-alpha.1421

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1418 (develop, build 1418)
+ * alphaTab v1.6.0-alpha.1421 (develop, build 1421)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -14318,13 +14318,6 @@
      * @json_strict
      */
     class BackingTrack {
-        constructor() {
-            /**
-             * The number of milliseconds the audio should be shifted to align with the song.
-             * (e.g. negative values allow skipping potential silent parts at the start of the file and directly start with the first note).
-             */
-            this.padding = 0;
-        }
     }
 
     /**
@@ -14357,6 +14350,7 @@
         constructor() {
             this._hasAnacrusis = false;
             this._skipApplyLyrics = false;
+            this._backingTrackPadding = 0;
             this._doubleBars = new Set();
             this._keySignatures = new Map();
         }
@@ -14589,7 +14583,7 @@
                         assetId = c.innerText;
                         break;
                     case 'FramePadding':
-                        backingTrack.padding = GpifParser.parseIntSafe(c.innerText, 0) / GpifParser.SampleRate * 1000;
+                        this._backingTrackPadding = GpifParser.parseIntSafe(c.innerText, 0) / GpifParser.SampleRate * 1000;
                         break;
                 }
             }
@@ -16803,6 +16797,7 @@
                             masterBar.tempoAutomations.push(automation);
                             break;
                         case AutomationType.SyncPoint:
+                            automation.syncPointValue.millisecondOffset -= this._backingTrackPadding;
                             masterBar.addSyncPoint(automation);
                             break;
                     }
@@ -22291,17 +22286,6 @@
         }
     }
 
-    /**
-     * Rerpresents a point to sync the alphaTab time axis with an external backing track.
-     */
-    class BackingTrackSyncPoint {
-        constructor(tick, data) {
-            this.tick = 0;
-            this.tick = tick;
-            this.data = data;
-        }
-    }
-
     class MidiFileSequencerTempoChange {
         constructor(bpm, ticks, time) {
             this.bpm = bpm;
@@ -22309,10 +22293,12 @@
             this.time = time;
         }
     }
-    class BackingTrackSyncPointWithTime extends BackingTrackSyncPoint {
-        constructor(tick, data, time) {
-            super(tick, data);
-            this.time = time;
+    class BackingTrackSyncPointWithTime {
+        constructor(tick, time, modifiedTempo, millisecondOffset) {
+            this.alphaTabTick = tick;
+            this.alphaTabTime = time;
+            this.modifiedTempo = modifiedTempo;
+            this.millisecondOffset = millisecondOffset;
         }
     }
     class MidiSequencerState {
@@ -22418,7 +22404,7 @@
                 this._mainState.currentTempo = this._mainState.tempoChanges[0].bpm;
                 this._mainState.modifiedTempo =
                     this._mainState.syncPoints.length > 0
-                        ? this._mainState.syncPoints[0].data.modifiedTempo
+                        ? this._mainState.syncPoints[0].modifiedTempo
                         : this._mainState.currentTempo;
                 if (this.isPlayingMain) {
                     const metronomeVolume = this._synthesizer.metronomeVolume;
@@ -22590,25 +22576,52 @@
         mainUpdateSyncPoints(syncPoints) {
             const state = this._mainState;
             syncPoints.sort((a, b) => a.tick - b.tick); // just in case
-            state.syncPoints = new Array(syncPoints.length);
+            state.syncPoints = [];
             if (syncPoints.length >= 0) {
                 let bpm = 120;
                 let absTick = 0;
                 let absTime = 0.0;
-                let previousTick = 0;
                 let tempoChangeIndex = 0;
                 for (let i = 0; i < syncPoints.length; i++) {
                     const p = syncPoints[i];
-                    const deltaTick = p.tick - previousTick;
-                    absTick += deltaTick;
-                    absTime += deltaTick * (60000.0 / (bpm * state.division));
-                    state.syncPoints[i] = new BackingTrackSyncPointWithTime(p.tick, p.data, absTime);
-                    previousTick = p.tick;
+                    let deltaTick = 0;
+                    // remember state from previous sync point (or start). to handle linear interpolation
+                    let previousModifiedTempo;
+                    let previousMillisecondOffset;
+                    let previousTick;
+                    if (i === 0) {
+                        previousModifiedTempo = bpm;
+                        previousMillisecondOffset = 0;
+                        previousTick = 0;
+                    }
+                    else {
+                        const previousSyncPoint = syncPoints[i - 1];
+                        previousModifiedTempo = previousSyncPoint.data.modifiedTempo;
+                        previousMillisecondOffset = previousSyncPoint.data.millisecondOffset;
+                        previousTick = previousSyncPoint.tick;
+                    }
+                    // process time until sync point
+                    // here it gets a bit tricky. if we have tempo changes on the synthesizer time axis (inbetween two sync points)
+                    // we have to calculate a interpolated sync point on the alphaTab time axis.
+                    // otherwise the linear interpolation later in the lookup will fail.
+                    // goal is to have always a linear increase between two points, no matter if the time axis is sliced by tempo changes or sync points
                     while (tempoChangeIndex < state.tempoChanges.length &&
-                        state.tempoChanges[tempoChangeIndex].ticks <= absTick) {
+                        state.tempoChanges[tempoChangeIndex].ticks <= p.tick) {
+                        deltaTick = state.tempoChanges[tempoChangeIndex].ticks - absTick;
+                        if (deltaTick > 0) {
+                            absTick += deltaTick;
+                            absTime += deltaTick * (60000.0 / (bpm * state.division));
+                            const millisPerTick = (p.data.millisecondOffset - previousMillisecondOffset) / (p.tick - previousTick);
+                            const interpolatedMillisecondOffset = (absTick - previousTick) * millisPerTick + previousMillisecondOffset;
+                            state.syncPoints.push(new BackingTrackSyncPointWithTime(absTick, absTime, previousModifiedTempo, interpolatedMillisecondOffset));
+                        }
                         bpm = state.tempoChanges[tempoChangeIndex].bpm;
                         tempoChangeIndex++;
                     }
+                    deltaTick = p.tick - absTick;
+                    absTick += deltaTick;
+                    absTime += deltaTick * (60000.0 / (bpm * state.division));
+                    state.syncPoints.push(new BackingTrackSyncPointWithTime(p.tick, absTime, p.data.modifiedTempo, p.data.millisecondOffset));
                 }
             }
             state.syncPointIndex = 0;
@@ -22622,7 +22635,7 @@
             this.updateCurrentTempo(state, timePosition);
             const lastTempoChange = state.tempoChanges[state.tempoChangeIndex];
             const timeDiff = timePosition - lastTempoChange.time;
-            const ticks = ((timeDiff / (60000.0 / (lastTempoChange.bpm * state.division))) | 0);
+            const ticks = (timeDiff / (60000.0 / (lastTempoChange.bpm * state.division))) | 0;
             // we add 1 for possible rounding errors.(floating point issuses)
             return lastTempoChange.ticks + ticks + 1;
         }
@@ -22639,19 +22652,21 @@
                 state.tempoChangeIndex = tempoChangeIndex;
                 state.currentTempo = state.tempoChanges[state.tempoChangeIndex].bpm;
             }
+        }
+        updateSyncPoints(state, timePosition) {
             const syncPoints = state.syncPoints;
             if (syncPoints.length > 0) {
                 let syncPointIndex = Math.min(state.syncPointIndex, syncPoints.length - 1);
-                if (timePosition < syncPoints[syncPointIndex].data.millisecondOffset) {
+                if (timePosition < syncPoints[syncPointIndex].millisecondOffset) {
                     syncPointIndex = 0;
                 }
                 while (syncPointIndex + 1 < syncPoints.length &&
-                    syncPoints[syncPointIndex + 1].data.millisecondOffset <= timePosition) {
+                    syncPoints[syncPointIndex + 1].millisecondOffset <= timePosition) {
                     syncPointIndex++;
                 }
                 if (syncPointIndex !== state.syncPointIndex) {
                     state.syncPointIndex = syncPointIndex;
-                    state.modifiedTempo = syncPoints[syncPointIndex].data.modifiedTempo;
+                    state.modifiedTempo = syncPoints[syncPointIndex].modifiedTempo;
                 }
             }
             else {
@@ -22664,21 +22679,21 @@
             if (timePosition < 0 || syncPoints.length === 0) {
                 return timePosition;
             }
-            this.updateCurrentTempo(this._mainState, timePosition);
+            this.updateSyncPoints(this._mainState, timePosition);
             const syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
             const currentSyncPoint = syncPoints[syncPointIndex];
-            const timeDiff = timePosition - currentSyncPoint.data.millisecondOffset;
+            const timeDiff = timePosition - currentSyncPoint.millisecondOffset;
             let alphaTabTimeDiff;
             if (syncPointIndex + 1 < syncPoints.length) {
                 const nextSyncPoint = syncPoints[syncPointIndex + 1];
-                const relativeTimeDiff = timeDiff / (nextSyncPoint.data.millisecondOffset - currentSyncPoint.data.millisecondOffset);
-                alphaTabTimeDiff = (nextSyncPoint.time - currentSyncPoint.time) * relativeTimeDiff;
+                const relativeTimeDiff = timeDiff / (nextSyncPoint.millisecondOffset - currentSyncPoint.millisecondOffset);
+                alphaTabTimeDiff = (nextSyncPoint.alphaTabTime - currentSyncPoint.alphaTabTime) * relativeTimeDiff;
             }
             else {
-                const relativeTimeDiff = timeDiff / (backingTrackLength - currentSyncPoint.data.millisecondOffset);
-                alphaTabTimeDiff = (mainState.endTime - currentSyncPoint.time) * relativeTimeDiff;
+                const relativeTimeDiff = timeDiff / (backingTrackLength - currentSyncPoint.millisecondOffset);
+                alphaTabTimeDiff = (mainState.endTime - currentSyncPoint.alphaTabTime) * relativeTimeDiff;
             }
-            return (currentSyncPoint.time + alphaTabTimeDiff) / this.playbackSpeed;
+            return (currentSyncPoint.alphaTabTime + alphaTabTimeDiff) / this.playbackSpeed;
         }
         mainTimePositionToBackingTrack(timePosition, backingTrackLength) {
             const mainState = this._mainState;
@@ -22688,25 +22703,27 @@
             }
             timePosition *= this.playbackSpeed;
             let syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
-            if (timePosition < syncPoints[syncPointIndex].time) {
+            if (timePosition < syncPoints[syncPointIndex].alphaTabTime) {
                 syncPointIndex = 0;
             }
-            while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].time <= timePosition) {
+            while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].alphaTabTime <= timePosition) {
                 syncPointIndex++;
             }
+            // NOTE: this logic heavily relies on the interpolation done in mainUpdateSyncPoints
+            // we ensure that we have a linear increase between two points
             const currentSyncPoint = syncPoints[syncPointIndex];
-            const alphaTabTimeDiff = timePosition - currentSyncPoint.time;
+            const alphaTabTimeDiff = timePosition - currentSyncPoint.alphaTabTime;
             let backingTrackPos;
             if (syncPointIndex + 1 < syncPoints.length) {
                 const nextSyncPoint = syncPoints[syncPointIndex + 1];
-                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (nextSyncPoint.time - currentSyncPoint.time);
-                const backingTrackDiff = nextSyncPoint.data.millisecondOffset - currentSyncPoint.data.millisecondOffset;
-                backingTrackPos = currentSyncPoint.data.millisecondOffset + backingTrackDiff * relativeAlphaTabTimeDiff;
+                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (nextSyncPoint.alphaTabTime - currentSyncPoint.alphaTabTime);
+                const backingTrackDiff = nextSyncPoint.millisecondOffset - currentSyncPoint.millisecondOffset;
+                backingTrackPos = currentSyncPoint.millisecondOffset + backingTrackDiff * relativeAlphaTabTimeDiff;
             }
             else {
-                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (mainState.endTime - currentSyncPoint.time);
-                const frameDiff = backingTrackLength - currentSyncPoint.data.millisecondOffset;
-                backingTrackPos = currentSyncPoint.data.millisecondOffset + frameDiff * relativeAlphaTabTimeDiff;
+                const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (mainState.endTime - currentSyncPoint.alphaTabTime);
+                const frameDiff = backingTrackLength - currentSyncPoint.millisecondOffset;
+                backingTrackPos = currentSyncPoint.millisecondOffset + frameDiff * relativeAlphaTabTimeDiff;
             }
             return backingTrackPos;
         }
@@ -28588,7 +28605,9 @@
         hasSamplesForPercussion(key) {
             return this.synthesizer.hasSamplesForPercussion(key);
         }
-        loadBackingTrack(_score, _syncPoints) {
+        loadBackingTrack(_score) {
+        }
+        updateSyncPoints(_syncPoints) {
         }
     }
     /**
@@ -32485,15 +32504,9 @@
                 return null;
             }
             const o = new Map();
-            o.set("padding", obj.padding);
             return o;
         }
         static setProperty(obj, property, v) {
-            switch (property) {
-                case "padding":
-                    obj.padding = v;
-                    return true;
-            }
             return false;
         }
     }
@@ -34956,7 +34969,13 @@
              * Gets the list of tempo changes within the tick lookup.
              */
             this.tempoChanges = [];
+            /**
+             * The first beat in the bar.
+             */
             this.firstBeat = null;
+            /**
+             * The last beat in the bar.
+             */
             this.lastBeat = null;
             /**
              * Gets or sets the {@link MasterBarTickLookup} of the next masterbar in the {@link Score}
@@ -35370,14 +35389,13 @@
         constructor() {
             this._currentMasterBar = null;
             /**
-             * Gets a dictionary of all master bars played. The index is the index equals to {@link MasterBar.index}.
+             * A dictionary of all master bars played. The index is the index equals to {@link MasterBar.index}.
              * This lookup only contains the first time a MasterBar is played. For a whole sequence of the song refer to {@link MasterBars}.
              * @internal
              */
             this.masterBarLookup = new Map();
             /**
-             * Gets a list of all {@link MasterBarTickLookup} sorted by time.
-             * @internal
+             * A list of all {@link MasterBarTickLookup} sorted by time.
              */
             this.masterBars = [];
             /**
@@ -35751,6 +35769,17 @@
         }
     }
 
+    /**
+     * Rerpresents a point to sync the alphaTab time axis with an external backing track.
+     */
+    class BackingTrackSyncPoint {
+        constructor(tick, data) {
+            this.tick = 0;
+            this.tick = tick;
+            this.data = data;
+        }
+    }
+
     class MidiNoteDuration {
         constructor() {
             this.noteOnly = 0;
@@ -35820,62 +35849,22 @@
                 this.generateTrack(track);
             }
             Logger.debug('Midi', 'Begin midi generation');
-            const controller = new MidiPlaybackController(this._score);
-            let previousMasterBar = null;
-            let currentTempo = this._score.tempo;
-            // store the previous played bar for repeats
-            const barOccurence = new Map();
-            while (!controller.finished) {
-                const index = controller.index;
-                const bar = this._score.masterBars[index];
-                const currentTick = controller.currentTick;
-                controller.processCurrent();
-                if (controller.shouldPlay) {
-                    let occurence = barOccurence.has(index) ? barOccurence.get(index) : -1;
-                    occurence++;
-                    barOccurence.set(index, occurence);
-                    this.generateMasterBar(bar, previousMasterBar, currentTick, currentTempo, occurence);
-                    if (bar.tempoAutomations.length > 0) {
-                        currentTempo = bar.tempoAutomations[0].value;
-                    }
-                    for (const track of this._score.tracks) {
-                        for (const staff of track.staves) {
-                            if (index < staff.bars.length) {
-                                this.generateBar(staff.bars[index], currentTick, currentTempo);
-                            }
+            this.syncPoints = [];
+            MidiFileGenerator.playThroughSong(this._score, this.syncPoints, (bar, previousMasterBar, currentTick, currentTempo, occurence) => {
+                this.generateMasterBar(bar, previousMasterBar, currentTick, currentTempo, occurence);
+            }, (index, currentTick, currentTempo) => {
+                for (const track of this._score.tracks) {
+                    for (const staff of track.staves) {
+                        if (index < staff.bars.length) {
+                            this.generateBar(staff.bars[index], currentTick, currentTempo);
                         }
                     }
-                    if (bar.tempoAutomations.length > 0) {
-                        currentTempo = bar.tempoAutomations[bar.tempoAutomations.length - 1].value;
-                    }
                 }
-                controller.moveNext();
-                previousMasterBar = bar;
-            }
-            // here we interpolate the sync point which marks the end of the sync.
-            // Sync points define new tempos at certain positions.
-            // looking from the last sync point to the end we do not assume the end where the audio ends,
-            // but where it ends according to the BPM and the remaining ticks.
-            if (this.syncPoints.length > 0) {
-                const lastSyncPoint = this.syncPoints[this.syncPoints.length - 1];
-                const endTick = controller.currentTick;
-                const remainingTicks = endTick - lastSyncPoint.tick;
-                if (remainingTicks > 0) {
-                    const syncPointData = new SyncPointData();
-                    // last occurence of the last bar
-                    syncPointData.barOccurence = barOccurence.get(this._score.masterBars.length - 1);
-                    // same tempo as last point
-                    syncPointData.modifiedTempo = lastSyncPoint.data.modifiedTempo;
-                    // interpolated end from last syncPoint
-                    syncPointData.millisecondOffset =
-                        lastSyncPoint.data.millisecondOffset +
-                            MidiUtils.ticksToMillis(remainingTicks, syncPointData.modifiedTempo);
-                    this.syncPoints.push(new BackingTrackSyncPoint(endTick, syncPointData));
+            }, endTick => {
+                for (const track of this._score.tracks) {
+                    this._handler.finishTrack(track.index, endTick);
                 }
-            }
-            for (const track of this._score.tracks) {
-                this._handler.finishTrack(track.index, controller.currentTick);
-            }
+            });
             Logger.debug('Midi', 'Midi generation done');
         }
         generateTrack(track) {
@@ -35920,6 +35909,81 @@
             this._handler.addControlChange(track.index, 0, channel, ControllerType.DataEntryCoarse, MidiFileGenerator.PitchBendRangeInSemitones);
             this.addProgramChange(track, 0, channel, playbackInfo.program);
         }
+        /**
+         * Generates the sync points for the given score without re-generating the midi itself.
+         * @remarks
+         * Use this method if a re-generation of the sync points after modification is required.
+         * It correctly handles repeats and places sync points accoridng to their absolute midi tick when they
+         * need to be considered for synchronization.
+         * @param score The song for which to regenerate the sync points.
+         * @returns The generated sync points for usage in the backing track playback.
+         */
+        static generateSyncPoints(score) {
+            const syncPoints = [];
+            MidiFileGenerator.playThroughSong(score, syncPoints, (_masterBar, _previousMasterBar, _currentTick, _currentTempo, _barOccurence) => {
+            }, (_barIndex, _currentTick, _currentTempo) => {
+            }, _endTick => {
+            });
+            return syncPoints;
+        }
+        static playThroughSong(score, syncPoints, generateMasterBar, generateTracks, finish) {
+            const controller = new MidiPlaybackController(score);
+            let currentTempo = score.tempo;
+            let previousMasterBar = null;
+            // store the previous played bar for repeats
+            const barOccurence = new Map();
+            while (!controller.finished) {
+                const index = controller.index;
+                const bar = score.masterBars[index];
+                const currentTick = controller.currentTick;
+                controller.processCurrent();
+                if (controller.shouldPlay) {
+                    let occurence = barOccurence.has(index) ? barOccurence.get(index) : -1;
+                    occurence++;
+                    barOccurence.set(index, occurence);
+                    generateMasterBar(bar, previousMasterBar, currentTick, currentTempo, occurence);
+                    const barSyncPoints = bar.syncPoints;
+                    if (barSyncPoints) {
+                        for (const syncPoint of barSyncPoints) {
+                            if (syncPoint.syncPointValue.barOccurence === occurence) {
+                                const tick = currentTick + bar.calculateDuration() * syncPoint.ratioPosition;
+                                syncPoints.push(new BackingTrackSyncPoint(tick, syncPoint.syncPointValue));
+                            }
+                        }
+                    }
+                    if (bar.tempoAutomations.length > 0) {
+                        currentTempo = bar.tempoAutomations[0].value;
+                    }
+                    generateTracks(index, currentTick, currentTempo);
+                    if (bar.tempoAutomations.length > 0) {
+                        currentTempo = bar.tempoAutomations[bar.tempoAutomations.length - 1].value;
+                    }
+                }
+                controller.moveNext();
+                previousMasterBar = bar;
+            }
+            // here we interpolate the sync point which marks the end of the sync.
+            // Sync points define new tempos at certain positions.
+            // looking from the last sync point to the end we do not assume the end where the audio ends,
+            // but where it ends according to the BPM and the remaining ticks.
+            if (syncPoints.length > 0) {
+                const lastSyncPoint = syncPoints[syncPoints.length - 1];
+                const remainingTicks = controller.currentTick - lastSyncPoint.tick;
+                if (remainingTicks > 0) {
+                    const syncPointData = new SyncPointData();
+                    // last occurence of the last bar
+                    syncPointData.barOccurence = barOccurence.get(score.masterBars.length - 1);
+                    // same tempo as last point
+                    syncPointData.modifiedTempo = lastSyncPoint.data.modifiedTempo;
+                    // interpolated end from last syncPoint
+                    syncPointData.millisecondOffset =
+                        lastSyncPoint.data.millisecondOffset +
+                            MidiUtils.ticksToMillis(remainingTicks, syncPointData.modifiedTempo);
+                    syncPoints.push(new BackingTrackSyncPoint(controller.currentTick, syncPointData));
+                }
+            }
+            finish(controller.currentTick);
+        }
         static toChannelShort(data) {
             const value = Math.max(-32768, Math.min(32767, data * 8 - 1));
             return Math.max(value, -1) + 1;
@@ -35951,15 +36015,6 @@
             else {
                 masterBarLookup.tempoChanges.push(new MasterBarTickLookupTempoChange(currentTick, currentTempo));
             }
-            const syncPoints = masterBar.syncPoints;
-            if (syncPoints) {
-                for (const syncPoint of syncPoints) {
-                    if (syncPoint.syncPointValue.barOccurence === barOccurence) {
-                        const tick = currentTick + masterBarDuration * syncPoint.ratioPosition;
-                        this.syncPoints.push(new BackingTrackSyncPoint(tick, syncPoint.syncPointValue));
-                    }
-                }
-            }
             masterBarLookup.masterBar = masterBar;
             masterBarLookup.start = currentTick;
             masterBarLookup.end = masterBarLookup.start + masterBarDuration;
@@ -38256,21 +38311,23 @@
                 this._backingTrackOutput.seekTo(this.sequencer.mainTimePositionToBackingTrack(timePosition, this._backingTrackOutput.backingTrackDuration));
             }
         }
-        loadBackingTrack(score, syncPoints) {
+        loadBackingTrack(score) {
             const backingTrackInfo = score.backingTrack;
             if (backingTrackInfo) {
                 this._backingTrackOutput.loadBackingTrack(backingTrackInfo);
-                this.sequencer.mainUpdateSyncPoints(syncPoints);
                 this.timePosition = 0;
             }
         }
+        updateSyncPoints(syncPoints) {
+            this.sequencer.mainUpdateSyncPoints(syncPoints);
+            this.tickPosition = this.tickPosition;
+        }
     }
 
     class ExternalMediaSynthOutput {
         constructor() {
             // fake rate
             this.sampleRate = 44100;
-            this._padding = 0;
             this._seekPosition = 0;
             this.ready = new EventEmitter();
             this.samplesPlayed = new EventEmitterOfT();
@@ -38313,20 +38370,19 @@
         seekTo(time) {
             const handler = this.handler;
             if (handler) {
-                handler.seekTo(time - this._padding);
+                handler.seekTo(time);
             }
             else {
-                this._seekPosition = time - this._padding;
+                this._seekPosition = time;
             }
         }
-        loadBackingTrack(backingTrack) {
-            this._padding = backingTrack.padding;
+        loadBackingTrack(_backingTrack) {
         }
         open(_bufferTimeInMilliseconds) {
             this.ready.trigger();
         }
         updatePosition(currentTime) {
-            this.timeUpdate.trigger(currentTime + this._padding);
+            this.timeUpdate.trigger(currentTime);
         }
         play() {
             this.handler?.play();
@@ -38591,9 +38647,14 @@
                 this._instance.loadMidiFile(midi);
             }
         }
-        loadBackingTrack(score, syncPoints) {
+        loadBackingTrack(score) {
             if (this._instance) {
-                this._instance.loadBackingTrack(score, syncPoints);
+                this._instance.loadBackingTrack(score);
+            }
+        }
+        updateSyncPoints(syncPoints) {
+            if (this._instance) {
+                this._instance.updateSyncPoints(syncPoints);
             }
         }
         applyTranspositionPitches(transpositionPitches) {
@@ -39922,7 +39983,7 @@
         }
         appendRenderResult(result, isLast) {
             // resizing the canvas and wrapper elements at the end is enough
-            // it avoids flickering on resizes and re-renders. 
+            // it avoids flickering on resizes and re-renders.
             // the individual partials are anyhow sized correctly
             if (isLast) {
                 this.canvasElement.width = result.totalWidth;
@@ -40684,9 +40745,23 @@
             this.onMidiLoad(midiFile);
             const player = this._player;
             player.loadMidiFile(midiFile);
-            player.loadBackingTrack(score, generator.syncPoints);
+            player.loadBackingTrack(score);
+            player.updateSyncPoints(generator.syncPoints);
             player.applyTranspositionPitches(generator.transpositionPitches);
         }
+        /**
+         * Triggers an update of the sync points for the current score after modification within the data model
+         * @category Methods - Player
+         * @since 1.6.0
+         */
+        updateSyncPoints() {
+            if (!this.score) {
+                return;
+            }
+            const score = this.score;
+            const player = this._player;
+            player.updateSyncPoints(MidiFileGenerator.generateSyncPoints(score));
+        }
         /**
          * Changes the volume of the given tracks.
          * @param tracks The tracks for which the volume should be changed.
@@ -41245,8 +41320,9 @@
                             // it can happen that the cursor reaches the target position slightly too early (especially on backing tracks)
                             // to avoid the cursor stopping, causing a wierd look, we animate the cursor to the double position in double time.
                             // beatCursor!.transitionToX((duration / cursorSpeed), nextBeatX);
-                            const doubleEndBeatX = startBeatX + (nextBeatX - startBeatX) * 2;
-                            beatCursor.transitionToX((duration / cursorSpeed) * 2, doubleEndBeatX);
+                            const factor = cursorMode === MidiTickLookupFindBeatResultCursorMode.ToNextBext ? 2 : 1;
+                            const doubleEndBeatX = startBeatX + (nextBeatX - startBeatX) * factor;
+                            beatCursor.transitionToX((duration / cursorSpeed) * factor, doubleEndBeatX);
                         });
                     }
                     else {
@@ -43354,6 +43430,8 @@
         }
         loadBackingTrack(_score) {
         }
+        updateSyncPoints(_syncPoints) {
+        }
     }
 
     /**
@@ -43728,7 +43806,6 @@
         constructor() {
             // fake rate
             this.sampleRate = 44100;
-            this._padding = 0;
             this._updateInterval = 0;
             this.ready = new EventEmitter();
             this.samplesPlayed = new EventEmitterOfT();
@@ -43752,13 +43829,12 @@
             this.audioElement.volume = value;
         }
         seekTo(time) {
-            this.audioElement.currentTime = time / 1000 - this._padding;
+            this.audioElement.currentTime = time / 1000;
         }
         loadBackingTrack(backingTrack) {
             if (this.audioElement?.src) {
                 URL.revokeObjectURL(this.audioElement.src);
             }
-            this._padding = backingTrack.padding / 1000;
             const blob = new Blob([backingTrack.rawAudioFile]);
             // https://html.spec.whatwg.org/multipage/media.html#loading-the-media-resource
             // Step 8. resets the playbackRate, we need to remember and restore it. 
@@ -43777,7 +43853,7 @@
             this.ready.trigger();
         }
         updatePosition() {
-            const timePos = (this.audioElement.currentTime + this._padding) * 1000;
+            const timePos = this.audioElement.currentTime * 1000;
             this.timeUpdate.trigger(timePos);
         }
         play() {
@@ -43996,6 +44072,7 @@
             webFont.usages--;
             if (webFont.usages <= 0) {
                 webFont.element.remove();
+                BrowserUiFacade._registeredWebFonts.delete(webFont.hash);
             }
         }
         createCanvasElement() {
@@ -44152,6 +44229,7 @@
             checker.checkForFontAvailability();
             settings.display.resources.smuflFont = new Font(familyName, Environment.MusicFontSize, FontStyle.Plain, FontWeight.Regular);
             const webFont = {
+                hash,
                 element: styleElement,
                 fontSuffix,
                 usages: 1,
@@ -60863,9 +60941,9 @@
             print(`build date: ${VersionInfo.date}`);
         }
     }
-    VersionInfo.version = '1.6.0-alpha.1418';
-    VersionInfo.date = '2025-05-21T02:08:19.492Z';
-    VersionInfo.commit = '1f6342282295a9544ebc36ddd38d73d220d2caab';
+    VersionInfo.version = '1.6.0-alpha.1421';
+    VersionInfo.date = '2025-05-22T19:50:36.984Z';
+    VersionInfo.commit = '0b4cd7b2a2c0d244d65c0c0c5254fe4814976bc4';
 
     /**
      * A factory for custom layout engines.