@coderline/alphatab 1.6.0-alpha.1428 → 1.6.0-alpha.1432

package/dist/alphaTab.core.mjs

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1428 (develop, build 1428)
+ * alphaTab v1.6.0-alpha.1432 (develop, build 1432)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -1006,6 +1006,26 @@ class Bar {
     get isEmpty() {
         return this._isEmpty;
     }
+    /**
+     * Whether this bar has any changes applied which are not related to the voices in it.
+     * (e.g. new key signatures)
+     */
+    get hasChanges() {
+        if (this.index === 0) {
+            return true;
+        }
+        const hasChangesToPrevious = this.keySignature !== this.previousBar.keySignature ||
+            this.keySignatureType !== this.previousBar.keySignatureType ||
+            this.clef !== this.previousBar.clef ||
+            this.clefOttava !== this.previousBar.clefOttava;
+        if (hasChangesToPrevious) {
+            return true;
+        }
+        return (this.simileMark !== SimileMark.None ||
+            this.sustainPedals.length > 0 ||
+            this.barLineLeft !== BarLineStyle.Automatic ||
+            this.barLineRight !== BarLineStyle.Automatic);
+    }
     /**
      * Whether this bar is empty or has only rests.
      */
@@ -1411,12 +1431,6 @@ class SyncPointData {
          * Indicates for which repeat occurence this sync point is valid (e.g. 0 on the first time played, 1 on the second time played)
          */
         this.barOccurence = 0;
-        /**
-         * The modified tempo at which the cursor should move (aka. the tempo played within the external audio track).
-         * This information is used together with normal tempo changes to calculate how much faster/slower the
-         * cursor playback is performed to align with the audio track.
-         */
-        this.modifiedTempo = 0;
         /**
          * The audio offset marking the position within the audio track in milliseconds.
          * This information is used to regularly sync (or on seeking) to match a given external audio time axis with the internal time axis.
@@ -2625,6 +2639,33 @@ class MasterBar {
          */
         this.directions = null;
     }
+    /**
+     * Whether the masterbar is has any changes applied to it (e.g. tempo changes, time signature changes etc)
+     * The first bar is always considered changed due to initial setup of values. It does not consider
+     * elements like whether the tempo really changes to the previous bar.
+     */
+    get hasChanges() {
+        if (this.index === 0) {
+            return false;
+        }
+        const hasChangesToPrevious = this.timeSignatureCommon !== this.previousMasterBar.timeSignatureCommon ||
+            this.timeSignatureNumerator !== this.previousMasterBar.timeSignatureNumerator ||
+            this.timeSignatureDenominator !== this.previousMasterBar.timeSignatureDenominator ||
+            this.tripletFeel !== this.previousMasterBar.tripletFeel;
+        if (hasChangesToPrevious) {
+            return true;
+        }
+        return (this.alternateEndings !== 0 ||
+            this.isRepeatStart ||
+            this.isRepeatEnd ||
+            this.isFreeTime ||
+            this.isSectionStart ||
+            this.tempoAutomations.length > 0 ||
+            this.syncPoints && this.syncPoints.length > 0 ||
+            (this.fermata !== null && this.fermata.size > 0) ||
+            (this.directions !== null && this.directions.size > 0) ||
+            this.isAnacrusis);
+    }
     /**
      * The key signature used on all bars.
      * @deprecated Use key signatures on bar level
@@ -3566,6 +3607,43 @@ class ModelUtils {
             }
         }
     }
+    /**
+     * Trims any empty bars at the end of the song.
+     * @param score
+     */
+    static trimEmptyBarsAtEnd(score) {
+        while (score.masterBars.length > 1) {
+            const barIndex = score.masterBars.length - 1;
+            const masterBar = score.masterBars[barIndex];
+            if (masterBar.hasChanges) {
+                return;
+            }
+            for (const track of score.tracks) {
+                for (const staff of track.staves) {
+                    if (barIndex < staff.bars.length) {
+                        const bar = staff.bars[barIndex];
+                        if (!bar.isEmpty || bar.hasChanges) {
+                            // found a non-empty bar, stop whole cleanup
+                            return;
+                        }
+                    }
+                }
+            }
+            // if we reach here, all found bars are empty, remove the bar
+            for (const track of score.tracks) {
+                for (const staff of track.staves) {
+                    if (barIndex < staff.bars.length) {
+                        const bar = staff.bars[barIndex];
+                        staff.bars.pop();
+                        // unlink
+                        bar.previousBar.nextBar = null;
+                    }
+                }
+            }
+            score.masterBars.pop();
+            masterBar.previousMasterBar.nextMasterBar = null;
+        }
+    }
 }
 ModelUtils.TuningLetters = new Set([
     0x43 /* C */, 0x44 /* D */, 0x45 /* E */, 0x46 /* F */, 0x47 /* G */, 0x41 /* A */, 0x42 /* B */, 0x63 /* c */,
@@ -5843,7 +5921,6 @@ class SyncPointDataCloner {
     static clone(original) {
         const clone = new SyncPointData();
         clone.barOccurence = original.barOccurence;
-        clone.modifiedTempo = original.modifiedTempo;
         clone.millisecondOffset = original.millisecondOffset;
         return clone;
     }
@@ -7313,7 +7390,6 @@ class Score {
             automation.ratioPosition = Math.min(1, Math.max(0, syncPoint.barPosition));
             automation.type = AutomationType.SyncPoint;
             automation.syncPointValue = new SyncPointData();
-            automation.syncPointValue.modifiedTempo = syncPoint.modifiedTempo;
             automation.syncPointValue.millisecondOffset = syncPoint.millisecondOffset;
             automation.syncPointValue.barOccurence = syncPoint.barOccurence;
             if (syncPoint.barIndex < this.masterBars.length) {
@@ -7346,8 +7422,7 @@ class Score {
                         barIndex: masterBar.index,
                         barOccurence: syncPoint.syncPointValue.barOccurence,
                         barPosition: syncPoint.ratioPosition,
-                        millisecondOffset: syncPoint.syncPointValue.millisecondOffset,
-                        modifiedTempo: syncPoint.syncPointValue.modifiedTempo
+                        millisecondOffset: syncPoint.syncPointValue.millisecondOffset
                     });
                 }
             }
@@ -8686,6 +8761,7 @@ class AlphaTexImporter extends ScoreImporter {
         this._slurs = new Map();
         this._articulationValueToIndex = new Map();
         this._accidentalMode = AlphaTexAccidentalMode.Explicit;
+        this._syncPoints = [];
         this.logErrors = false;
     }
     get name() {
@@ -8726,10 +8802,16 @@ class AlphaTexImporter extends ScoreImporter {
                 if (!anyMetaRead && !anyBarsRead) {
                     throw new UnsupportedFormatError('No alphaTex data found');
                 }
+                if (this._sy === AlphaTexSymbols.Dot) {
+                    this._sy = this.newSy();
+                    this.syncPoints();
+                }
             }
             ModelUtils.consolidate(this._score);
             this._score.finish(this.settings);
+            ModelUtils.trimEmptyBarsAtEnd(this._score);
             this._score.rebuildRepeatGroups();
+            this._score.applyFlatSyncPoints(this._syncPoints);
             for (const [track, lyrics] of this._lyrics) {
                 this._score.tracks[track].applyLyrics(lyrics);
             }
@@ -8746,6 +8828,47 @@ class AlphaTexImporter extends ScoreImporter {
             throw e;
         }
     }
+    syncPoints() {
+        while (this._sy !== AlphaTexSymbols.Eof) {
+            this.syncPoint();
+        }
+    }
+    syncPoint() {
+        // \sync BarIndex Occurence MillisecondOffset
+        // \sync BarIndex Occurence MillisecondOffset RatioPosition
+        if (this._sy !== AlphaTexSymbols.MetaCommand || this._syData !== 'sync') {
+            this.error('syncPoint', AlphaTexSymbols.MetaCommand, true);
+        }
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarIndex', AlphaTexSymbols.Number, true);
+        }
+        const barIndex = this._syData;
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarOccurence', AlphaTexSymbols.Number, true);
+        }
+        const barOccurence = this._syData;
+        this._sy = this.newSy();
+        if (this._sy !== AlphaTexSymbols.Number) {
+            this.error('syncPointBarMillis', AlphaTexSymbols.Number, true);
+        }
+        const millisecondOffset = this._syData;
+        this._allowFloat = true;
+        this._sy = this.newSy();
+        this._allowFloat = false;
+        let barPosition = 0;
+        if (this._sy === AlphaTexSymbols.Number) {
+            barPosition = this._syData;
+            this._sy = this.newSy();
+        }
+        this._syncPoints.push({
+            barIndex,
+            barOccurence,
+            barPosition,
+            millisecondOffset
+        });
+    }
     error(nonterm, expected, wrongSymbol = true) {
         let receivedSymbol;
         let showSyData = false;
@@ -14714,9 +14837,6 @@ class GpifParser {
                                 case 'BarOccurrence':
                                     syncPointValue.barOccurence = GpifParser.parseIntSafe(vc.innerText, 0);
                                     break;
-                                case 'ModifiedTempo':
-                                    syncPointValue.modifiedTempo = GpifParser.parseFloatSafe(vc.innerText, 0);
-                                    break;
                                 case 'FrameOffset':
                                     const frameOffset = GpifParser.parseFloatSafe(vc.innerText, 0);
                                     syncPointValue.millisecondOffset = (frameOffset / GpifParser.SampleRate) * 1000;
@@ -22339,6 +22459,61 @@ class SynthEvent {
     }
 }
 
+/**
+ * Rerpresents a point to sync the alphaTab time axis with an external backing track.
+ */
+class BackingTrackSyncPoint {
+    constructor() {
+        /**
+         * The index of the masterbar to which this sync point belongs to.
+         * @remarks
+         * This property is purely informative for external use like in editors.
+         * It has no impact to the synchronization itself.
+         */
+        this.masterBarIndex = 0;
+        /**
+         * The occurence of the masterbar to which this sync point belongs to. The occurence
+         * is 0-based and increases with every repeated play of a masterbar (e.g. on repeats or jumps).
+         * @remarks
+         * This property is purely informative for external use like in editors.
+         * It has no impact to the synchronization itself.
+         */
+        this.masterBarOccurence = 0;
+        /**
+         * The BPM the synthesizer has at the exact tick position of this sync point.
+         */
+        this.synthBpm = 0;
+        /**
+         * The millisecond time position of the synthesizer when this sync point is reached.
+         */
+        this.synthTime = 0;
+        /**
+         * The midi tick position of the synthesizer when this sync point is reached.
+         */
+        this.synthTick = 0;
+        /**
+         * The millisecond time in the external media marking the synchronization point.
+         */
+        this.syncTime = 0;
+        /**
+         * The BPM the song will have virtually after this sync point to align the external media time axis
+         * with the one from the synthesizer.
+         */
+        this.syncBpm = 0;
+    }
+    /**
+     * Updates the synchronization BPM that will apply after this sync point.
+     * @param nextSyncPointSynthTime The synthesizer time of the next sync point after this one.
+     * @param nextSyncPointSyncTime The synchronization time of the next sync point after this one.
+     */
+    updateSyncBpm(nextSyncPointSynthTime, nextSyncPointSyncTime) {
+        const synthDuration = nextSyncPointSynthTime - this.synthTime;
+        const syncedDuration = nextSyncPointSyncTime - this.syncTime;
+        const modifiedTempo = (synthDuration / syncedDuration) * this.synthBpm;
+        this.syncBpm = modifiedTempo;
+    }
+}
+
 class MidiFileSequencerTempoChange {
     constructor(bpm, ticks, time) {
         this.bpm = bpm;
@@ -22346,14 +22521,6 @@ class MidiFileSequencerTempoChange {
         this.time = time;
     }
 }
-class BackingTrackSyncPointWithTime {
-    constructor(tick, time, modifiedTempo, millisecondOffset) {
-        this.alphaTabTick = tick;
-        this.alphaTabTime = time;
-        this.modifiedTempo = modifiedTempo;
-        this.millisecondOffset = millisecondOffset;
-    }
-}
 class MidiSequencerState {
     constructor() {
         this.tempoChanges = [];
@@ -22457,7 +22624,7 @@ class MidiFileSequencer {
             this._mainState.currentTempo = this._mainState.tempoChanges[0].bpm;
             this._mainState.modifiedTempo =
                 this._mainState.syncPoints.length > 0
-                    ? this._mainState.syncPoints[0].modifiedTempo
+                    ? this._mainState.syncPoints[0].syncBpm
                     : this._mainState.currentTempo;
             if (this.isPlayingMain) {
                 const metronomeVolume = this._synthesizer.metronomeVolume;
@@ -22628,7 +22795,7 @@ class MidiFileSequencer {
     }
     mainUpdateSyncPoints(syncPoints) {
         const state = this._mainState;
-        syncPoints.sort((a, b) => a.tick - b.tick); // just in case
+        syncPoints.sort((a, b) => a.synthTick - b.synthTick); // just in case
         state.syncPoints = [];
         if (syncPoints.length >= 0) {
             let bpm = 120;
@@ -22638,6 +22805,8 @@ class MidiFileSequencer {
             for (let i = 0; i < syncPoints.length; i++) {
                 const p = syncPoints[i];
                 let deltaTick = 0;
+                // TODO: merge interpolation into MidiFileGenerator where we already play through
+                // the time axis.
                 // remember state from previous sync point (or start). to handle linear interpolation
                 let previousModifiedTempo;
                 let previousMillisecondOffset;
@@ -22649,9 +22818,9 @@ class MidiFileSequencer {
                 }
                 else {
                     const previousSyncPoint = syncPoints[i - 1];
-                    previousModifiedTempo = previousSyncPoint.data.modifiedTempo;
-                    previousMillisecondOffset = previousSyncPoint.data.millisecondOffset;
-                    previousTick = previousSyncPoint.tick;
+                    previousModifiedTempo = previousSyncPoint.syncBpm;
+                    previousMillisecondOffset = previousSyncPoint.syncTime;
+                    previousTick = previousSyncPoint.synthTick;
                 }
                 // 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)
@@ -22659,27 +22828,31 @@ class MidiFileSequencer {
                 // 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 <= p.tick) {
+                    state.tempoChanges[tempoChangeIndex].ticks <= p.synthTick) {
                     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 millisPerTick = (p.syncTime - previousMillisecondOffset) / (p.synthTick - previousTick);
                         const interpolatedMillisecondOffset = (absTick - previousTick) * millisPerTick + previousMillisecondOffset;
-                        state.syncPoints.push(new BackingTrackSyncPointWithTime(absTick, absTime, previousModifiedTempo, interpolatedMillisecondOffset));
+                        const syncPoint = new BackingTrackSyncPoint();
+                        syncPoint.synthTick = absTick;
+                        syncPoint.synthBpm = bpm;
+                        syncPoint.synthTime = absTime;
+                        syncPoint.syncTime = interpolatedMillisecondOffset;
+                        syncPoint.syncBpm = previousModifiedTempo;
                     }
                     bpm = state.tempoChanges[tempoChangeIndex].bpm;
                     tempoChangeIndex++;
                 }
-                deltaTick = p.tick - absTick;
+                deltaTick = p.synthTick - 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.syncPoints.push(p);
             }
         }
         state.syncPointIndex = 0;
-        state.modifiedTempo =
-            state.syncPoints.length > 0 ? state.syncPoints[0].modifiedTempo : state.currentTempo;
+        state.modifiedTempo = state.syncPoints.length > 0 ? state.syncPoints[0].syncBpm : state.currentTempo;
     }
     currentTimePositionToTickPosition(timePosition) {
         const state = this._currentState;
@@ -22712,16 +22885,15 @@ class MidiFileSequencer {
         const syncPoints = state.syncPoints;
         if (syncPoints.length > 0) {
             let syncPointIndex = Math.min(state.syncPointIndex, syncPoints.length - 1);
-            if (timePosition < syncPoints[syncPointIndex].millisecondOffset) {
+            if (timePosition < syncPoints[syncPointIndex].syncTime) {
                 syncPointIndex = 0;
             }
-            while (syncPointIndex + 1 < syncPoints.length &&
-                syncPoints[syncPointIndex + 1].millisecondOffset <= timePosition) {
+            while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].syncTime <= timePosition) {
                 syncPointIndex++;
             }
             if (syncPointIndex !== state.syncPointIndex) {
                 state.syncPointIndex = syncPointIndex;
-                state.modifiedTempo = syncPoints[syncPointIndex].modifiedTempo;
+                state.modifiedTempo = syncPoints[syncPointIndex].syncBpm;
             }
         }
         else {
@@ -22737,18 +22909,18 @@ class MidiFileSequencer {
         this.updateSyncPoints(this._mainState, timePosition);
         const syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
         const currentSyncPoint = syncPoints[syncPointIndex];
-        const timeDiff = timePosition - currentSyncPoint.millisecondOffset;
+        const timeDiff = timePosition - currentSyncPoint.syncTime;
         let alphaTabTimeDiff;
         if (syncPointIndex + 1 < syncPoints.length) {
             const nextSyncPoint = syncPoints[syncPointIndex + 1];
-            const relativeTimeDiff = timeDiff / (nextSyncPoint.millisecondOffset - currentSyncPoint.millisecondOffset);
-            alphaTabTimeDiff = (nextSyncPoint.alphaTabTime - currentSyncPoint.alphaTabTime) * relativeTimeDiff;
+            const relativeTimeDiff = timeDiff / (nextSyncPoint.syncTime - currentSyncPoint.syncTime);
+            alphaTabTimeDiff = (nextSyncPoint.synthTime - currentSyncPoint.synthTime) * relativeTimeDiff;
         }
         else {
-            const relativeTimeDiff = timeDiff / (backingTrackLength - currentSyncPoint.millisecondOffset);
-            alphaTabTimeDiff = (mainState.endTime - currentSyncPoint.alphaTabTime) * relativeTimeDiff;
+            const relativeTimeDiff = timeDiff / (backingTrackLength - currentSyncPoint.syncTime);
+            alphaTabTimeDiff = (mainState.endTime - currentSyncPoint.synthTime) * relativeTimeDiff;
         }
-        return (currentSyncPoint.alphaTabTime + alphaTabTimeDiff) / this.playbackSpeed;
+        return (currentSyncPoint.synthTime + alphaTabTimeDiff) / this.playbackSpeed;
     }
     mainTimePositionToBackingTrack(timePosition, backingTrackLength) {
         const mainState = this._mainState;
@@ -22758,27 +22930,27 @@ class MidiFileSequencer {
         }
         timePosition *= this.playbackSpeed;
         let syncPointIndex = Math.min(mainState.syncPointIndex, syncPoints.length - 1);
-        if (timePosition < syncPoints[syncPointIndex].alphaTabTime) {
+        if (timePosition < syncPoints[syncPointIndex].synthTime) {
             syncPointIndex = 0;
         }
-        while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].alphaTabTime <= timePosition) {
+        while (syncPointIndex + 1 < syncPoints.length && syncPoints[syncPointIndex + 1].synthTime <= 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.alphaTabTime;
+        const alphaTabTimeDiff = timePosition - currentSyncPoint.synthTime;
         let backingTrackPos;
         if (syncPointIndex + 1 < syncPoints.length) {
             const nextSyncPoint = syncPoints[syncPointIndex + 1];
-            const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (nextSyncPoint.alphaTabTime - currentSyncPoint.alphaTabTime);
-            const backingTrackDiff = nextSyncPoint.millisecondOffset - currentSyncPoint.millisecondOffset;
-            backingTrackPos = currentSyncPoint.millisecondOffset + backingTrackDiff * relativeAlphaTabTimeDiff;
+            const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (nextSyncPoint.synthTime - currentSyncPoint.synthTime);
+            const backingTrackDiff = nextSyncPoint.syncTime - currentSyncPoint.syncTime;
+            backingTrackPos = currentSyncPoint.syncTime + backingTrackDiff * relativeAlphaTabTimeDiff;
         }
         else {
-            const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (mainState.endTime - currentSyncPoint.alphaTabTime);
-            const frameDiff = backingTrackLength - currentSyncPoint.millisecondOffset;
-            backingTrackPos = currentSyncPoint.millisecondOffset + frameDiff * relativeAlphaTabTimeDiff;
+            const relativeAlphaTabTimeDiff = alphaTabTimeDiff / (mainState.endTime - currentSyncPoint.synthTime);
+            const frameDiff = backingTrackLength - currentSyncPoint.syncTime;
+            backingTrackPos = currentSyncPoint.syncTime + frameDiff * relativeAlphaTabTimeDiff;
         }
         return backingTrackPos;
     }
@@ -31050,7 +31222,6 @@ class SyncPointDataSerializer {
         }
         const o = new Map();
         o.set("baroccurence", obj.barOccurence);
-        o.set("modifiedtempo", obj.modifiedTempo);
         o.set("millisecondoffset", obj.millisecondOffset);
         return o;
     }
@@ -31059,9 +31230,6 @@ class SyncPointDataSerializer {
             case "baroccurence":
                 obj.barOccurence = v;
                 return true;
-            case "modifiedtempo":
-                obj.modifiedTempo = v;
-                return true;
             case "millisecondoffset":
                 obj.millisecondOffset = v;
                 return true;
@@ -33066,7 +33234,7 @@ class AlphaSynthWorkerSynthOutput {
     addSamples(samples) {
         this._worker.postMessage({
             cmd: 'alphaSynth.output.addSamples',
-            samples: samples
+            samples: Environment.prepareForPostMessage(samples)
         });
     }
     play() {
@@ -33262,7 +33430,7 @@ class AlphaSynthWebWorker {
     onSoundFontLoadFailed(e) {
         this._main.postMessage({
             cmd: 'alphaSynth.soundFontLoadFailed',
-            error: this.serializeException(e)
+            error: this.serializeException(Environment.prepareForPostMessage(e))
         });
     }
     serializeException(e) {
@@ -33293,7 +33461,7 @@ class AlphaSynthWebWorker {
     onMidiLoadFailed(e) {
         this._main.postMessage({
             cmd: 'alphaSynth.midiLoaded',
-            error: this.serializeException(e)
+            error: this.serializeException(Environment.prepareForPostMessage(e))
         });
     }
     onReadyForPlayback() {
@@ -35824,17 +35992,6 @@ 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;
@@ -35855,6 +36012,14 @@ class RasgueadoInfo {
         this.brushInfos = [];
     }
 }
+class PlayThroughContext {
+    constructor() {
+        this.synthTick = 0;
+        this.synthTime = 0;
+        this.currentTempo = 0;
+        this.automationToSyncPoint = new Map();
+    }
+}
 /**
  * This generator creates a midi file using a score.
  */
@@ -35981,9 +36146,22 @@ class MidiFileGenerator {
         });
         return syncPoints;
     }
+    /**
+     * @internal
+     */
+    static buildModifiedTempoLookup(score) {
+        const syncPoints = [];
+        const context = MidiFileGenerator.playThroughSong(score, syncPoints, (_masterBar, _previousMasterBar, _currentTick, _currentTempo, _barOccurence) => {
+        }, (_barIndex, _currentTick, _currentTempo) => {
+        }, _endTick => {
+        });
+        return context.automationToSyncPoint;
+    }
     static playThroughSong(score, syncPoints, generateMasterBar, generateTracks, finish) {
         const controller = new MidiPlaybackController(score);
-        let currentTempo = score.tempo;
+        const playContext = new PlayThroughContext();
+        playContext.currentTempo = score.tempo;
+        playContext.syncPoints = syncPoints;
         let previousMasterBar = null;
         // store the previous played bar for repeats
         const barOccurence = new Map();
@@ -35996,23 +36174,11 @@ class MidiFileGenerator {
                 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;
-                }
+                generateMasterBar(bar, previousMasterBar, currentTick, playContext.currentTempo, occurence);
+                const trackTempo = bar.tempoAutomations.length > 0 ? bar.tempoAutomations[0].value : playContext.currentTempo;
+                generateTracks(index, currentTick, trackTempo);
+                playContext.synthTick = currentTick;
+                MidiFileGenerator.processBarTime(bar, occurence, playContext);
             }
             controller.moveNext();
             previousMasterBar = bar;
@@ -36023,21 +36189,119 @@ class MidiFileGenerator {
         // 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;
+            const remainingTicks = controller.currentTick - lastSyncPoint.synthTick;
             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));
+                const backingTrackSyncPoint = new BackingTrackSyncPoint();
+                backingTrackSyncPoint.masterBarIndex = previousMasterBar.index;
+                backingTrackSyncPoint.masterBarOccurence = barOccurence.get(previousMasterBar.index) - 1;
+                backingTrackSyncPoint.synthTick = controller.currentTick;
+                backingTrackSyncPoint.synthBpm = playContext.currentTempo;
+                // we need to assume some BPM for the last interpolated point.
+                // if we have more than just a start point, we keep the BPM before the last manual sync point
+                // otherwise we have no customized sync BPM known and keep the synthesizer one.
+                backingTrackSyncPoint.syncBpm =
+                    syncPoints.length > 1 ? syncPoints[syncPoints.length - 2].syncBpm : lastSyncPoint.synthBpm;
+                backingTrackSyncPoint.synthTime =
+                    lastSyncPoint.synthTime + MidiUtils.ticksToMillis(remainingTicks, lastSyncPoint.synthBpm);
+                backingTrackSyncPoint.syncTime =
+                    lastSyncPoint.syncTime + MidiUtils.ticksToMillis(remainingTicks, backingTrackSyncPoint.syncBpm);
+                // update the previous sync point according to the new time
+                lastSyncPoint.updateSyncBpm(backingTrackSyncPoint.synthTime, backingTrackSyncPoint.syncTime);
+                syncPoints.push(backingTrackSyncPoint);
             }
         }
         finish(controller.currentTick);
+        return playContext;
+    }
+    static processBarTime(bar, occurence, context) {
+        const duration = bar.calculateDuration();
+        const barSyncPoints = bar.syncPoints;
+        const barStartTick = context.synthTick;
+        if (barSyncPoints) {
+            MidiFileGenerator.processBarTimeWithSyncPoints(bar, occurence, context);
+        }
+        else {
+            MidiFileGenerator.processBarTimeNoSyncPoints(bar, context);
+        }
+        // don't forget the part after the last tempo change
+        const endTick = barStartTick + duration;
+        const tickOffset = endTick - context.synthTick;
+        if (tickOffset > 0) {
+            context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+            context.synthTick = endTick;
+        }
+    }
+    static processBarTimeWithSyncPoints(bar, occurence, context) {
+        const barStartTick = context.synthTick;
+        const duration = bar.calculateDuration();
+        let tempoChangeIndex = 0;
+        let tickOffset;
+        for (const syncPoint of bar.syncPoints) {
+            if (syncPoint.syncPointValue.barOccurence !== occurence) {
+                continue;
+            }
+            const syncPointTick = barStartTick + syncPoint.ratioPosition * duration;
+            // first process all tempo changes until this sync point
+            while (tempoChangeIndex < bar.tempoAutomations.length &&
+                bar.tempoAutomations[tempoChangeIndex].ratioPosition <= syncPoint.ratioPosition) {
+                const tempoChange = bar.tempoAutomations[tempoChangeIndex];
+                const absoluteTick = barStartTick + tempoChange.ratioPosition * duration;
+                tickOffset = absoluteTick - context.synthTick;
+                if (tickOffset > 0) {
+                    context.synthTick = absoluteTick;
+                    context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+                }
+                context.currentTempo = tempoChange.value;
+                tempoChangeIndex++;
+            }
+            // process time until sync point
+            tickOffset = syncPointTick - context.synthTick;
+            if (tickOffset > 0) {
+                context.synthTick = syncPointTick;
+                context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+            }
+            // update the previous sync point according to the new time
+            if (context.syncPoints.length > 0) {
+                context.syncPoints[context.syncPoints.length - 1].updateSyncBpm(context.synthTime, syncPoint.syncPointValue.millisecondOffset);
+            }
+            // create the new sync point
+            const backingTrackSyncPoint = new BackingTrackSyncPoint();
+            backingTrackSyncPoint.masterBarIndex = bar.index;
+            backingTrackSyncPoint.masterBarOccurence = occurence;
+            backingTrackSyncPoint.synthTick = syncPointTick;
+            backingTrackSyncPoint.synthBpm = context.currentTempo;
+            backingTrackSyncPoint.synthTime = context.synthTime;
+            backingTrackSyncPoint.syncTime = syncPoint.syncPointValue.millisecondOffset;
+            backingTrackSyncPoint.syncBpm = 0 /* calculated by next sync point */;
+            context.syncPoints.push(backingTrackSyncPoint);
+            context.automationToSyncPoint.set(syncPoint, backingTrackSyncPoint);
+        }
+        // process remaining tempo changes after all sync points
+        while (tempoChangeIndex < bar.tempoAutomations.length) {
+            const tempoChange = bar.tempoAutomations[tempoChangeIndex];
+            const absoluteTick = barStartTick + tempoChange.ratioPosition * duration;
+            tickOffset = absoluteTick - context.synthTick;
+            if (tickOffset > 0) {
+                context.synthTick = absoluteTick;
+                context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+            }
+            context.currentTempo = tempoChange.value;
+            tempoChangeIndex++;
+        }
+    }
+    static processBarTimeNoSyncPoints(bar, context) {
+        // walk through the tempo changes
+        const barStartTick = context.synthTick;
+        const duration = bar.calculateDuration();
+        for (const changes of bar.tempoAutomations) {
+            const absoluteTick = barStartTick + changes.ratioPosition * duration;
+            const tickOffset = absoluteTick - context.synthTick;
+            if (tickOffset > 0) {
+                context.synthTick = absoluteTick;
+                context.synthTime += MidiUtils.ticksToMillis(tickOffset, context.currentTempo);
+            }
+            context.currentTempo = changes.value;
+        }
     }
     static toChannelShort(data) {
         const value = Math.max(-32768, Math.min(32767, data * 8 - 1));
@@ -42322,6 +42586,18 @@ class FileLoadError extends AlphaTabError {
  * available importers
  */
 class ScoreLoader {
+    /**
+     * Loads the given alphaTex string.
+     * @param tex The alphaTex string.
+     * @param settings The settings to use for parsing.
+     * @returns The parsed {@see Score}.
+     */
+    static loadAlphaTex(tex, settings) {
+        const parser = new AlphaTexImporter();
+        parser.logErrors = true;
+        parser.initFromString(tex, settings ?? new Settings());
+        return parser.readScore();
+    }
     /**
      * Loads a score asynchronously from the given datasource
      * @param path the source path to load the binary file from
@@ -43172,7 +43448,7 @@ class AlphaSynthWebWorkerApi {
         this._midiEventsPlayedFilter = value;
         this._synth.postMessage({
             cmd: 'alphaSynth.setMidiEventsPlayedFilter',
-            value: value
+            value: Environment.prepareForPostMessage(value)
         });
     }
     get playbackSpeed() {
@@ -43237,7 +43513,7 @@ class AlphaSynthWebWorkerApi {
         this._playbackRange = value;
         this._synth.postMessage({
             cmd: 'alphaSynth.setPlaybackRange',
-            value: value
+            value: Environment.prepareForPostMessage(value)
         });
     }
     constructor(player, settings) {
@@ -43331,13 +43607,13 @@ class AlphaSynthWebWorkerApi {
     playOneTimeMidiFile(midi) {
         this._synth.postMessage({
             cmd: 'alphaSynth.playOneTimeMidiFile',
-            midi: JsonConverter.midiFileToJsObject(midi)
+            midi: JsonConverter.midiFileToJsObject(Environment.prepareForPostMessage(midi))
         });
     }
     loadSoundFont(data, append) {
         this._synth.postMessage({
             cmd: 'alphaSynth.loadSoundFontBytes',
-            data: data,
+            data: Environment.prepareForPostMessage(data),
             append: append
         });
     }
@@ -43349,13 +43625,13 @@ class AlphaSynthWebWorkerApi {
     loadMidiFile(midi) {
         this._synth.postMessage({
             cmd: 'alphaSynth.loadMidi',
-            midi: JsonConverter.midiFileToJsObject(midi)
+            midi: JsonConverter.midiFileToJsObject(Environment.prepareForPostMessage(midi))
         });
     }
     applyTranspositionPitches(transpositionPitches) {
         this._synth.postMessage({
             cmd: 'alphaSynth.applyTranspositionPitches',
-            transpositionPitches: JSON.stringify(Array.from(transpositionPitches.entries()))
+            transpositionPitches: JSON.stringify(Array.from(Environment.prepareForPostMessage(transpositionPitches).entries()))
         });
     }
     setChannelTranspositionPitch(channel, semitones) {
@@ -43527,7 +43803,7 @@ class AlphaTabWorkerScoreRenderer {
         });
     }
     serializeSettingsForWorker(settings) {
-        const jsObject = JsonConverter.settingsToJsObject(settings);
+        const jsObject = JsonConverter.settingsToJsObject(Environment.prepareForPostMessage(settings));
         // cut out player settings, they are only needed on UI thread side
         jsObject.delete('player');
         return jsObject;
@@ -43585,11 +43861,11 @@ class AlphaTabWorkerScoreRenderer {
         }
     }
     renderScore(score, trackIndexes) {
-        const jsObject = score == null ? null : JsonConverter.scoreToJsObject(score);
+        const jsObject = score == null ? null : JsonConverter.scoreToJsObject(Environment.prepareForPostMessage(score));
         this._worker.postMessage({
             cmd: 'alphaTab.renderScore',
             score: jsObject,
-            trackIndexes: trackIndexes,
+            trackIndexes: Environment.prepareForPostMessage(trackIndexes),
             fontSizes: FontSizes.FontSizeLookupTables
         });
     }
@@ -43780,7 +44056,7 @@ class AlphaSynthAudioWorkletOutput extends AlphaSynthWebAudioOutputBase {
     addSamples(f) {
         this._worklet?.port.postMessage({
             cmd: AlphaSynthWorkerSynthOutput.CmdOutputAddSamples,
-            samples: f
+            samples: Environment.prepareForPostMessage(f)
         });
     }
     resetSamples() {
@@ -61000,9 +61276,9 @@ class VersionInfo {
         print(`build date: ${VersionInfo.date}`);
     }
 }
-VersionInfo.version = '1.6.0-alpha.1428';
-VersionInfo.date = '2025-05-29T00:44:50.954Z';
-VersionInfo.commit = 'fa81a14da248f229511867324cee663ea70a72b3';
+VersionInfo.version = '1.6.0-alpha.1432';
+VersionInfo.date = '2025-05-31T02:06:00.256Z';
+VersionInfo.commit = '91e41f1b2cf0b786a1ca2053f51cf3f370da4bc6';
 
 /**
  * A factory for custom layout engines.
@@ -61547,6 +61823,29 @@ class Environment {
             print(`Screen Size: ${window.screen.width}x${window.screen.height}`);
         }
     }
+    /**
+     * Prepares the given object to be sent to workers. Web Frameworks like Vue might
+     * create proxy objects for all objects used. This code handles the necessary unwrapping.
+     * @internal
+     * @target web
+     */
+    static prepareForPostMessage(object) {
+        if (!object) {
+            return object;
+        }
+        // Vue toRaw:
+        // https://github.com/vuejs/core/blob/e7381761cc7971c0d40ae0a0a72687a500fd8db3/packages/reactivity/src/reactive.ts#L378-L381
+        if (typeof object === 'object') {
+            const unwrapped = object.__v_raw;
+            if (unwrapped) {
+                return Environment.prepareForPostMessage(unwrapped);
+            }
+        }
+        // Solidjs unwrap: the symbol required to access the raw object is unfortunately hidden and we cannot unwrap it without importing
+        // import { unwrap } from "solid-js/store"
+        // alternative for users is to replace this method during runtime. 
+        return object;
+    }
 }
 Environment.StaffIdBeforeSlashAlways = 'before-slash-always';
 Environment.StaffIdBeforeScoreAlways = 'before-score-always';
@@ -61818,6 +62117,7 @@ class CoreSettings {
 
 const _barrel$7 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     __proto__: null,
+    AlphaTexImporter,
     ScoreImporter,
     ScoreLoader,
     UnsupportedFormatError
@@ -62652,6 +62952,7 @@ class GpifWriter {
             : undefined;
         const millisecondPadding = initialSyncPoint ? initialSyncPoint.syncPointValue.millisecondOffset : 0;
         this.backingTrackFramePadding = (-1 * ((millisecondPadding / 1000) * GpifWriter.SampleRate)) | 0;
+        const modifiedTempoLookup = new Lazy(() => MidiFileGenerator.buildModifiedTempoLookup(score));
         for (const mb of score.masterBars) {
             for (const automation of mb.tempoAutomations) {
                 const tempoAutomation = automations.addElement('Automation');
@@ -62676,7 +62977,7 @@ class GpifWriter {
                     const value = syncPointAutomation.addElement('Value');
                     value.addElement('BarIndex').innerText = mb.index.toString();
                     value.addElement('BarOccurrence').innerText = syncPoint.syncPointValue.barOccurence.toString();
-                    value.addElement('ModifiedTempo').innerText = syncPoint.syncPointValue.modifiedTempo.toString();
+                    value.addElement('ModifiedTempo').innerText = modifiedTempoLookup.value.get(syncPoint).syncBpm.toString();
                     value.addElement('OriginalTempo').innerText = score.tempo.toString();
                     const frameOffset = (((syncPoint.syncPointValue.millisecondOffset - millisecondPadding) / 1000) *
                         GpifWriter.SampleRate) |