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

package/dist/alphaTab.core.mjs

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1418 (develop, build 1418)
+ * alphaTab v1.6.0-alpha.1420 (develop, build 1420)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -14312,13 +14312,6 @@ class XmlDocument extends XmlNode {
  * @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;
-    }
 }
 
 /**
@@ -14351,6 +14344,7 @@ class GpifParser {
     constructor() {
         this._hasAnacrusis = false;
         this._skipApplyLyrics = false;
+        this._backingTrackPadding = 0;
         this._doubleBars = new Set();
         this._keySignatures = new Map();
     }
@@ -14583,7 +14577,7 @@ class GpifParser {
                     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;
             }
         }
@@ -16797,6 +16791,7 @@ class GpifParser {
                         masterBar.tempoAutomations.push(automation);
                         break;
                     case AutomationType.SyncPoint:
+                        automation.syncPointValue.millisecondOffset -= this._backingTrackPadding;
                         masterBar.addSyncPoint(automation);
                         break;
                 }
@@ -22285,17 +22280,6 @@ class SynthEvent {
     }
 }
 
-/**
- * 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;
@@ -22303,10 +22287,12 @@ class MidiFileSequencerTempoChange {
         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 {
@@ -22412,7 +22398,7 @@ class MidiFileSequencer {
             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;
@@ -22584,25 +22570,52 @@ class MidiFileSequencer {
     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;
@@ -22616,7 +22629,7 @@ class MidiFileSequencer {
         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;
     }
@@ -22636,16 +22649,16 @@ class MidiFileSequencer {
         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 {
@@ -22661,18 +22674,18 @@ class MidiFileSequencer {
         this.updateCurrentTempo(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;
@@ -22682,25 +22695,27 @@ class MidiFileSequencer {
         }
         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;
     }
@@ -28582,7 +28597,9 @@ class AlphaSynthBase {
     hasSamplesForPercussion(key) {
         return this.synthesizer.hasSamplesForPercussion(key);
     }
-    loadBackingTrack(_score, _syncPoints) {
+    loadBackingTrack(_score) {
+    }
+    updateSyncPoints(_syncPoints) {
     }
 }
 /**
@@ -32479,15 +32496,9 @@ class BackingTrackSerializer {
             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;
     }
 }
@@ -34950,7 +34961,13 @@ class MasterBarTickLookup {
          * 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}
@@ -35364,14 +35381,13 @@ class MidiTickLookup {
     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 = [];
         /**
@@ -35745,6 +35761,17 @@ class MidiTickLookup {
     }
 }
 
+/**
+ * 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;
@@ -35814,62 +35841,22 @@ class MidiFileGenerator {
             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) {
@@ -35914,6 +35901,81 @@ class MidiFileGenerator {
         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;
@@ -38250,21 +38312,23 @@ class BackingTrackPlayer extends AlphaSynthBase {
             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();
@@ -38307,20 +38371,19 @@ class ExternalMediaSynthOutput {
     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();
@@ -38585,9 +38648,14 @@ class AlphaSynthWrapper {
             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) {
@@ -39916,7 +39984,7 @@ class AlphaTabApiBase {
     }
     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;
@@ -40678,9 +40746,23 @@ class AlphaTabApiBase {
         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.
@@ -43348,6 +43430,8 @@ class AlphaSynthWebWorkerApi {
     }
     loadBackingTrack(_score) {
     }
+    updateSyncPoints(_syncPoints) {
+    }
 }
 
 /**
@@ -43722,7 +43806,6 @@ class AudioElementBackingTrackSynthOutput {
     constructor() {
         // fake rate
         this.sampleRate = 44100;
-        this._padding = 0;
         this._updateInterval = 0;
         this.ready = new EventEmitter();
         this.samplesPlayed = new EventEmitterOfT();
@@ -43746,13 +43829,12 @@ class AudioElementBackingTrackSynthOutput {
         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. 
@@ -43771,7 +43853,7 @@ class AudioElementBackingTrackSynthOutput {
         this.ready.trigger();
     }
     updatePosition() {
-        const timePos = (this.audioElement.currentTime + this._padding) * 1000;
+        const timePos = this.audioElement.currentTime * 1000;
         this.timeUpdate.trigger(timePos);
     }
     play() {
@@ -43990,6 +44072,7 @@ class BrowserUiFacade {
         webFont.usages--;
         if (webFont.usages <= 0) {
             webFont.element.remove();
+            BrowserUiFacade._registeredWebFonts.delete(webFont.hash);
         }
     }
     createCanvasElement() {
@@ -44146,6 +44229,7 @@ class BrowserUiFacade {
         checker.checkForFontAvailability();
         settings.display.resources.smuflFont = new Font(familyName, Environment.MusicFontSize, FontStyle.Plain, FontWeight.Regular);
         const webFont = {
+            hash,
             element: styleElement,
             fontSuffix,
             usages: 1,
@@ -60857,9 +60941,9 @@ class VersionInfo {
         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.1420';
+VersionInfo.date = '2025-05-22T03:03:04.057Z';
+VersionInfo.commit = '230bdd455a1906e6f334b63bad3b8cf773f890e6';
 
 /**
  * A factory for custom layout engines.