@coderline/alphatab 1.6.0-alpha.1444 → 1.6.0-alpha.1448

package/dist/alphaTab.js

@@ -1,5 +1,5 @@
 /*!
- * alphaTab v1.6.0-alpha.1444 (develop, build 1444)
+ * alphaTab v1.6.0-alpha.1448 (develop, build 1448)
  *
  * Copyright © 2025, Daniel Kuschny and Contributors, All rights reserved.
  *
@@ -22539,7 +22539,6 @@
             this.division = MidiUtils.QuarterTime;
             this.eventIndex = 0;
             this.currentTime = 0;
-            this.currentTick = 0;
             this.syncPointIndex = 0;
             this.playbackRange = null;
             this.playbackRangeStartTime = 0;
@@ -22547,7 +22546,7 @@
             this.endTick = 0;
             this.endTime = 0;
             this.currentTempo = 0;
-            this.modifiedTempo = 0;
+            this.syncPointTempo = 0;
         }
     }
     /**
@@ -22604,7 +22603,13 @@
             return this._currentState.currentTempo;
         }
         get modifiedTempo() {
-            return this._currentState.modifiedTempo * this.playbackSpeed;
+            return this._currentState.syncPointTempo * this.playbackSpeed;
+        }
+        get syncPointTempo() {
+            return this._currentState.syncPointTempo;
+        }
+        get currentSyncPoints() {
+            return this._currentState.syncPoints;
         }
         mainSeek(timePosition) {
             // map to speed=1
@@ -22628,7 +22633,7 @@
                 this._mainState.syncPointIndex = 0;
                 this._mainState.tempoChangeIndex = 0;
                 this._mainState.currentTempo = this._mainState.tempoChanges[0].bpm;
-                this._mainState.modifiedTempo =
+                this._mainState.syncPointTempo =
                     this._mainState.syncPoints.length > 0
                         ? this._mainState.syncPoints[0].syncBpm
                         : this._mainState.currentTempo;
@@ -22741,7 +22746,7 @@
                 }
             }
             state.currentTempo = state.tempoChanges.length > 0 ? state.tempoChanges[0].bpm : bpm;
-            state.modifiedTempo = state.currentTempo;
+            state.syncPointTempo = state.currentTempo;
             state.synthData.sort((a, b) => {
                 if (a.time > b.time) {
                     return 1;
@@ -22858,7 +22863,7 @@
                 }
             }
             state.syncPointIndex = 0;
-            state.modifiedTempo = state.syncPoints.length > 0 ? state.syncPoints[0].syncBpm : state.currentTempo;
+            state.syncPointTempo = state.syncPoints.length > 0 ? state.syncPoints[0].syncBpm : state.currentTempo;
         }
         currentTimePositionToTickPosition(timePosition) {
             const state = this._currentState;
@@ -22873,6 +22878,9 @@
             // we add 1 for possible rounding errors.(floating point issuses)
             return lastTempoChange.ticks + ticks + 1;
         }
+        currentUpdateCurrentTempo(timePosition) {
+            this.updateCurrentTempo(this._mainState, timePosition * this.playbackSpeed);
+        }
         updateCurrentTempo(state, timePosition) {
             let tempoChangeIndex = state.tempoChangeIndex;
             if (timePosition < state.tempoChanges[tempoChangeIndex].time) {
@@ -22887,6 +22895,9 @@
                 state.currentTempo = state.tempoChanges[state.tempoChangeIndex].bpm;
             }
         }
+        currentUpdateSyncPoints(timePosition) {
+            this.updateSyncPoints(this._mainState, timePosition);
+        }
         updateSyncPoints(state, timePosition) {
             const syncPoints = state.syncPoints;
             if (syncPoints.length > 0) {
@@ -22899,11 +22910,11 @@
                 }
                 if (syncPointIndex !== state.syncPointIndex) {
                     state.syncPointIndex = syncPointIndex;
-                    state.modifiedTempo = syncPoints[syncPointIndex].syncBpm;
+                    state.syncPointTempo = syncPoints[syncPointIndex].syncBpm;
                 }
             }
             else {
-                state.modifiedTempo = state.currentTempo;
+                state.syncPointTempo = state.currentTempo;
             }
         }
         mainTimePositionFromBackingTrack(timePosition, backingTrackLength) {
@@ -23050,7 +23061,7 @@
             state.endTime = metronomeTime;
             state.endTick = metronomeTick;
             state.currentTempo = bpm;
-            state.modifiedTempo = bpm;
+            state.syncPointTempo = bpm;
             this._countInState = state;
         }
     }
@@ -28379,6 +28390,82 @@
         }
     }
 
+    /**
+     * The options controlling how to export the audio.
+     */
+    class AudioExportOptions {
+        constructor() {
+            /**
+             * The output sample rate.
+             * @default `44100`
+             */
+            this.sampleRate = 44100;
+            /**
+             * Whether to respect sync point information during export.
+             * @default `true`
+             * @remarks
+             * If the song contains sync point information for synchronization with an external media,
+             * this option allows controlling whether the synthesized audio is aligned with these points.
+             *
+             * This is useful when mixing the exported audio together with external media, keeping the same timing.
+             *
+             * Disable this option if you want the original/exact timing as per music sheet in the exported audio.
+             */
+            this.useSyncPoints = false;
+            /**
+             * The current master volume as percentage. (range: 0.0-3.0, default 1.0)
+             */
+            this.masterVolume = 1;
+            /**
+             * The metronome volume. (range: 0.0-3.0, default 0.0)
+             */
+            this.metronomeVolume = 0;
+            /**
+             * The volume for individual tracks as percentage (range: 0.0-3.0).
+             * @remarks
+             * The key is the track index, and the value is the relative volume.
+             * The configured volume (as per data model) still applies, this is an additional volume control.
+             * If no custom value is set, 100% is used.
+             * No values from the currently active synthesizer are applied.
+             *
+             * The meaning of the key changes when used with AlphaSynth directly, in this case the key is the midi channel .
+             */
+            this.trackVolume = new Map();
+            /**
+             * The additional semitone pitch transpose to apply for individual tracks.
+             * @remarks
+             * The key is the track index, and the value is the number of semitones to apply.
+             * No values from the currently active synthesizer are applied.
+             *
+             * The meaning of the key changes when used with AlphaSynth directly, in this case the key is the midi channel .
+             */
+            this.trackTranspositionPitches = new Map();
+        }
+    }
+    /**
+     * Represents a single chunk of audio produced.
+     */
+    class AudioExportChunk {
+        constructor() {
+            /**
+             * The current time position within the song in milliseconds.
+             */
+            this.currentTime = 0;
+            /**
+             * The total length of the song in milliseconds.
+             */
+            this.endTime = 0;
+            /**
+             * The current time position within the song in midi ticks.
+             */
+            this.currentTick = 0;
+            /**
+             * The total length of the song in midi ticks.
+             */
+            this.endTick = 0;
+        }
+    }
+
     /**
      * This is the base class for synthesizer components which can be used to
      * play a {@link MidiFile} via a {@link ISynthOutput}.
@@ -28855,6 +28942,184 @@
         constructor(output, bufferTimeInMilliseconds) {
             super(output, new TinySoundFont(output.sampleRate), bufferTimeInMilliseconds);
         }
+        /**
+         * Creates a new audio exporter, initialized with the given data.
+         * @param options The export options to use.
+         * The track volume and transposition pitches must lists must be filled with midi channels.
+         * @param midi The midi file to use.
+         * @param syncPoints The sync points to use
+         * @param transpositionPitches The initial transposition pitches to apply.
+         * @param transpositionPitches The initial transposition pitches to apply.
+         */
+        exportAudio(options, midi, syncPoints, mainTranspositionPitches) {
+            const exporter = new AlphaSynthAudioExporter(options);
+            exporter.loadMidiFile(midi);
+            if (options.useSyncPoints) {
+                exporter.updateSyncPoints(syncPoints);
+            }
+            exporter.applyTranspositionPitches(mainTranspositionPitches);
+            for (const [channel, semitones] of options.trackTranspositionPitches) {
+                exporter.setChannelTranspositionPitch(channel, semitones);
+            }
+            for (const [channel, volume] of options.trackVolume) {
+                exporter.channelSetMixVolume(channel, volume);
+            }
+            if (options.soundFonts) {
+                for (const f of options.soundFonts) {
+                    exporter.loadSoundFont(f);
+                }
+            }
+            else {
+                exporter.loadPresets(this.synthesizer.presets);
+            }
+            if (options.playbackRange) {
+                exporter.limitExport(options.playbackRange);
+            }
+            exporter.setup();
+            return exporter;
+        }
+    }
+    /**
+     * A audio exporter allowing streaming synthesis of audio samples with a fixed configuration.
+     */
+    class AlphaSynthAudioExporter {
+        constructor(options) {
+            this._generatedAudioCurrentTime = 0;
+            this._generatedAudioEndTime = 0;
+            this._synth = new TinySoundFont(options.sampleRate);
+            this._sequencer = new MidiFileSequencer(this._synth);
+            this._synth.masterVolume = Math.max(options.masterVolume, SynthConstants.MinVolume);
+            this._synth.metronomeVolume = Math.max(options.metronomeVolume, SynthConstants.MinVolume);
+        }
+        /**
+         * Loads the specified sound font.
+         * @param data The soundfont data.
+         */
+        loadSoundFont(data) {
+            const input = ByteBuffer.fromBuffer(data);
+            const soundFont = new Hydra();
+            soundFont.load(input);
+            const programs = this._sequencer.instrumentPrograms;
+            const percussionKeys = this._sequencer.percussionKeys;
+            this._synth.loadPresets(soundFont, programs, percussionKeys, true);
+        }
+        /**
+         * Loads the specified presets.
+         * @param presets The presets to use.
+         */
+        loadPresets(presets) {
+            this._synth.presets = presets;
+        }
+        /**
+         * Limits the time range for which the export is done.
+         * @param range The time range
+         */
+        limitExport(range) {
+            this._sequencer.mainPlaybackRange = range;
+            this._sequencer.mainSeek(this._sequencer.mainTickPositionToTimePosition(range.startTick));
+        }
+        /**
+         * Sets the transposition pitch of a given channel. This pitch is additionally applied beside the
+         * ones applied already via {@link applyTranspositionPitches}.
+         * @param channel The channel number
+         * @param semitones The number of semitones to apply as pitch offset.
+         */
+        setChannelTranspositionPitch(channel, semitones) {
+            this._synth.setChannelTranspositionPitch(channel, semitones);
+        }
+        /**
+         * Applies the given transposition pitches used for general pitch changes that should be applied to the song.
+         * Used for general transpositions applied to the file.
+         * @param transpositionPitches A map defining for a given list of midi channels the number of semitones that should be adjusted.
+         */
+        applyTranspositionPitches(mainTranspositionPitches) {
+            this._synth.applyTranspositionPitches(mainTranspositionPitches);
+        }
+        /**
+         * Loads the given midi file for synthesis.
+         * @param midi The midi file.
+         */
+        loadMidiFile(midi) {
+            this._sequencer.loadMidi(midi);
+        }
+        /**
+         * Updates the sync points used for time synchronization with a backing track.
+         * @param syncPoints  The sync points.
+         */
+        updateSyncPoints(syncPoints) {
+            this._sequencer.mainUpdateSyncPoints(syncPoints);
+        }
+        /**
+         * Sets the current and initial volume of the given channel.
+         * @param channel The channel number.
+         * @param volume The volume of of the channel (0.0-1.0)
+         */
+        channelSetMixVolume(channel, volume) {
+            volume = Math.max(volume, SynthConstants.MinVolume);
+            this._synth.channelSetMixVolume(channel, volume);
+        }
+        setup() {
+            this._synth.setupMetronomeChannel(this._synth.metronomeVolume);
+            const syncPoints = this._sequencer.currentSyncPoints;
+            const alphaTabEndTime = this._sequencer.currentEndTime;
+            if (syncPoints.length === 0) {
+                this._generatedAudioEndTime = alphaTabEndTime;
+            }
+            else {
+                const lastSyncPoint = syncPoints[syncPoints.length - 1];
+                let endTime = lastSyncPoint.syncTime;
+                const remainingTicks = this._sequencer.currentEndTick - lastSyncPoint.synthTick;
+                if (remainingTicks > 0) {
+                    endTime += MidiUtils.ticksToMillis(remainingTicks, lastSyncPoint.syncBpm);
+                }
+                this._generatedAudioEndTime = endTime;
+            }
+        }
+        render(milliseconds) {
+            if (this._sequencer.isFinished) {
+                return undefined;
+            }
+            const oneMicroBufferMillis = (SynthConstants.MicroBufferSize * 1000) / this._synth.outSampleRate;
+            const microBufferCount = Math.ceil(milliseconds / oneMicroBufferMillis);
+            let samples = new Float32Array(SynthConstants.MicroBufferSize * microBufferCount * SynthConstants.AudioChannels);
+            const syncPoints = this._sequencer.currentSyncPoints;
+            let bufferPos = 0;
+            let subBufferTime = this._generatedAudioCurrentTime;
+            let alphaTabGeneratedMillis = 0;
+            for (let i = 0; i < microBufferCount; i++) {
+                // if we're applying sync points, we calculate the needed tempo and set the playback speed
+                if (syncPoints.length > 0) {
+                    this._sequencer.currentUpdateSyncPoints(subBufferTime);
+                    this._sequencer.currentUpdateCurrentTempo(this._sequencer.currentTime);
+                    const newSpeed = this._sequencer.syncPointTempo / this._sequencer.currentTempo;
+                    if (this._sequencer.playbackSpeed !== newSpeed) {
+                        this._sequencer.playbackSpeed = newSpeed;
+                    }
+                }
+                this._sequencer.fillMidiEventQueue();
+                this._synth.synthesize(samples, bufferPos, SynthConstants.MicroBufferSize);
+                bufferPos += SynthConstants.MicroBufferSize * SynthConstants.AudioChannels;
+                subBufferTime += oneMicroBufferMillis;
+                alphaTabGeneratedMillis += oneMicroBufferMillis * this._sequencer.playbackSpeed;
+                if (this._sequencer.isFinished) {
+                    break;
+                }
+            }
+            if (bufferPos < samples.length) {
+                samples = samples.subarray(0, bufferPos);
+            }
+            const chunk = new AudioExportChunk();
+            chunk.currentTime = this._generatedAudioCurrentTime;
+            chunk.endTime = this._generatedAudioEndTime;
+            chunk.currentTick = this._sequencer.currentTimePositionToTickPosition(this._sequencer.currentTime);
+            chunk.endTick = this._sequencer.currentEndTick;
+            this._generatedAudioCurrentTime += milliseconds;
+            chunk.samples = samples;
+            if (this._sequencer.isFinished) {
+                this._synth.noteOffAll(true);
+            }
+            return chunk;
+        }
     }
 
     /**
@@ -33288,6 +33553,7 @@
      */
     class AlphaSynthWebWorker {
         constructor(main, bufferTimeInMilliseconds) {
+            this._exporter = new Map();
             this._main = main;
             this._main.addEventListener('message', this.handleMessage.bind(this));
             this._player = new AlphaSynth(new AlphaSynthWorkerSynthOutput(), bufferTimeInMilliseconds);
@@ -33403,6 +33669,53 @@
                     this._player.applyTranspositionPitches(new Map(JSON.parse(data.transpositionPitches)));
                     break;
             }
+            if (cmd.startsWith('alphaSynth.exporter')) {
+                this.handleExporterMessage(e);
+            }
+        }
+        handleExporterMessage(e) {
+            const data = e.data;
+            const cmd = data.cmd;
+            try {
+                switch (cmd) {
+                    case 'alphaSynth.exporter.initialize':
+                        const exporter = this._player.exportAudio(data.options, JsonConverter.jsObjectToMidiFile(data.midi), data.syncPoints, data.transpositionPitches);
+                        this._exporter.set(data.exporterId, exporter);
+                        this._main.postMessage({
+                            cmd: 'alphaSynth.exporter.initialized',
+                            exporterId: data.exporterId
+                        });
+                        break;
+                    case 'alphaSynth.exporter.render':
+                        if (this._exporter.has(data.exporterId)) {
+                            const exporter = this._exporter.get(data.exporterId);
+                            const chunk = exporter.render(data.milliseconds);
+                            this._main.postMessage({
+                                cmd: 'alphaSynth.exporter.rendered',
+                                exporterId: data.exporterId,
+                                chunk
+                            });
+                        }
+                        else {
+                            this._main.postMessage({
+                                cmd: 'alphaSynth.exporter.error',
+                                exporterId: data.exporterId,
+                                error: new Error('Unknown exporter ID')
+                            });
+                        }
+                        break;
+                    case 'alphaSynth.exporter.destroy':
+                        this._exporter.delete(data.exporterId);
+                        break;
+                }
+            }
+            catch (e) {
+                this._main.postMessage({
+                    cmd: 'alphaSynth.exporter.error',
+                    exporterId: data.exporterId,
+                    error: e
+                });
+            }
         }
         onPositionChanged(e) {
             this._main.postMessage({
@@ -41709,8 +42022,7 @@
             if (this._isDestroyed) {
                 return;
             }
-            if (this.hasCursor &&
-                this.settings.player.enableUserInteraction) {
+            if (this.hasCursor && this.settings.player.enableUserInteraction) {
                 this._selectionStart = new SelectionInfo(beat);
                 this._selectionEnd = null;
             }
@@ -41750,8 +42062,7 @@
             if (this._isDestroyed) {
                 return;
             }
-            if (this.hasCursor &&
-                this.settings.player.enableUserInteraction) {
+            if (this.hasCursor && this.settings.player.enableUserInteraction) {
                 if (this._selectionEnd) {
                     const startTick = this._tickCache?.getBeatStart(this._selectionStart.beat) ??
                         this._selectionStart.beat.absolutePlaybackStart;
@@ -41881,9 +42192,7 @@
                 }
             });
             this._renderer.postRenderFinished.on(() => {
-                if (!this._selectionStart ||
-                    !this.hasCursor ||
-                    !this.settings.player.enableUserInteraction) {
+                if (!this._selectionStart || !this.hasCursor || !this.settings.player.enableUserInteraction) {
                     return;
                 }
                 this.cursorSelectRange(this._selectionStart, this._selectionEnd);
@@ -42573,6 +42882,57 @@
         async getOutputDevice() {
             return await this._player.output.getOutputDevice();
         }
+        /**
+         * Starts the audio export for the currently loaded song.
+         * @remarks
+         * This will not export or use any backing track media but will always use the synthesizer to generate the output.
+         * This method works with any PlayerMode active but changing the mode during export can lead to unexpected side effects.
+         * @param options The export options.
+         * @returns An exporter instance to export the audio in a streaming fashion.
+         */
+        async exportAudio(options) {
+            if (!this.score) {
+                throw new AlphaTabError(exports.AlphaTabErrorType.General, 'No song loaded');
+            }
+            let exporter;
+            switch (this._actualPlayerMode) {
+                case exports.PlayerMode.EnabledSynthesizer:
+                    exporter = this.uiFacade.createWorkerAudioExporter(this._player.instance);
+                    break;
+                default:
+                    exporter = this.uiFacade.createWorkerAudioExporter(null);
+                    break;
+            }
+            const score = this.score;
+            const midiFile = new MidiFile();
+            const handler = new AlphaSynthMidiFileHandler(midiFile);
+            const generator = new MidiFileGenerator(score, this.settings, handler);
+            generator.applyTranspositionPitches = false;
+            generator.generate();
+            const optionsWithChannels = new AudioExportOptions();
+            optionsWithChannels.soundFonts = options.soundFonts;
+            optionsWithChannels.sampleRate = options.sampleRate;
+            optionsWithChannels.useSyncPoints = options.useSyncPoints;
+            optionsWithChannels.masterVolume = options.masterVolume;
+            optionsWithChannels.metronomeVolume = options.metronomeVolume;
+            optionsWithChannels.playbackRange = options.playbackRange;
+            for (const [trackIndex, volume] of options.trackVolume) {
+                if (trackIndex < this.score.tracks.length) {
+                    const track = this.score.tracks[trackIndex];
+                    optionsWithChannels.trackVolume.set(track.playbackInfo.primaryChannel, volume);
+                    optionsWithChannels.trackVolume.set(track.playbackInfo.secondaryChannel, volume);
+                }
+            }
+            for (const [trackIndex, semitones] of options.trackTranspositionPitches) {
+                if (trackIndex < this.score.tracks.length) {
+                    const track = this.score.tracks[trackIndex];
+                    optionsWithChannels.trackTranspositionPitches.set(track.playbackInfo.primaryChannel, semitones);
+                    optionsWithChannels.trackTranspositionPitches.set(track.playbackInfo.secondaryChannel, semitones);
+                }
+            }
+            await exporter.initialize(optionsWithChannels, midiFile, generator.syncPoints, generator.transpositionPitches);
+            return exporter;
+        }
     }
 
     /**
@@ -43406,6 +43766,9 @@
         get logLevel() {
             return Logger.logLevel;
         }
+        get worker() {
+            return this._synth;
+        }
         set logLevel(value) {
             Logger.logLevel = value;
             this._synth.postMessage({
@@ -44258,6 +44621,87 @@
         }
     }
 
+    /**
+     * @target web
+     */
+    class AlphaSynthAudioExporterWorkerApi {
+        constructor(synthWorker, ownsWorker) {
+            this._promise = null;
+            this._exporterId = AlphaSynthAudioExporterWorkerApi._nextExporterId++;
+            this._worker = synthWorker;
+            this._ownsWorker = ownsWorker;
+        }
+        async initialize(options, midi, syncPoints, transpositionPitches) {
+            const onmessage = this.handleWorkerMessage.bind(this);
+            this._worker.worker.addEventListener('message', onmessage, false);
+            this._unsubscribe = () => {
+                this._worker.worker.removeEventListener('message', onmessage, false);
+            };
+            this._promise = Promise.withResolvers();
+            this._worker.worker.postMessage({
+                cmd: 'alphaSynth.exporter.initialize',
+                exporterId: this._exporterId,
+                options: Environment.prepareForPostMessage(options),
+                midi: JsonConverter.midiFileToJsObject(Environment.prepareForPostMessage(midi)),
+                syncPoints: Environment.prepareForPostMessage(syncPoints),
+                transpositionPitches: Environment.prepareForPostMessage(transpositionPitches)
+            });
+            await this._promise.promise;
+        }
+        handleWorkerMessage(e) {
+            const data = e.data;
+            // for us?
+            if (data.exporterId !== this._exporterId) {
+                return;
+            }
+            const cmd = data.cmd;
+            switch (cmd) {
+                case 'alphaSynth.exporter.initialized':
+                    this._promise?.resolve(null);
+                    this._promise = null;
+                    break;
+                case 'alphaSynth.exporter.error':
+                    this._promise?.reject(data.error);
+                    this._promise = null;
+                    break;
+                case 'alphaSynth.exporter.rendered':
+                    this._promise?.resolve(data.chunk);
+                    this._promise = null;
+                    break;
+                case 'alphaSynth.destroyed':
+                    this._promise?.reject(new AlphaTabError(exports.AlphaTabErrorType.General, 'Worker was destroyed'));
+                    this._promise = null;
+                    break;
+            }
+        }
+        async render(milliseconds) {
+            if (this._promise) {
+                throw new AlphaTabError(exports.AlphaTabErrorType.General, 'There is already an ongoing operation, wait for initialize to complete before requesting render');
+            }
+            this._promise = Promise.withResolvers();
+            this._worker.worker.postMessage({
+                cmd: 'alphaSynth.exporter.render',
+                exporterId: this._exporterId,
+                milliseconds: milliseconds
+            });
+            return (await this._promise.promise);
+        }
+        destroy() {
+            this._worker.worker.postMessage({
+                cmd: 'alphaSynth.exporter.destroy',
+                exporterId: this._exporterId
+            });
+            this._unsubscribe();
+            if (this._ownsWorker) {
+                this._worker.destroy();
+            }
+        }
+        [Symbol.dispose]() {
+            this.destroy();
+        }
+    }
+    AlphaSynthAudioExporterWorkerApi._nextExporterId = 1;
+
     /**
      * @target web
      */
@@ -44824,6 +45268,14 @@
             }
             return player;
         }
+        createWorkerAudioExporter(synth) {
+            const needNewWorker = synth === null || !(synth instanceof AlphaSynthWebWorkerApi);
+            if (needNewWorker) {
+                // nowadays we require browsers with workers
+                synth = this.createWorkerPlayer();
+            }
+            return new AlphaSynthAudioExporterWorkerApi(synth, needNewWorker);
+        }
         beginInvoke(action) {
             window.requestAnimationFrame(() => {
                 action();
@@ -61281,9 +61733,9 @@
             print(`build date: ${VersionInfo.date}`);
         }
     }
-    VersionInfo.version = '1.6.0-alpha.1444';
-    VersionInfo.date = '2025-06-11T15:11:50.582Z';
-    VersionInfo.commit = '17557bdb7620020690fced1bc051d8a683a02c2b';
+    VersionInfo.version = '1.6.0-alpha.1448';
+    VersionInfo.date = '2025-06-14T22:07:33.833Z';
+    VersionInfo.commit = 'bfeddfaced057b74c2fa71fa58aa407467dd7460';
 
     /**
      * A factory for custom layout engines.
@@ -61953,7 +62405,7 @@
         /**
          * Builds the default SMuFL font sources for the usage with alphaTab in cases
          * where no custom {@link smuflFontSources} are provided.
-         * @param fontDirectory The {@link fontDirectory} configured.
+         * @param fontDirectory The {@link CoreSettings.fontDirectory} configured.
          * @target web
          */
         static buildDefaultSmuflFontSources(fontDirectory) {
@@ -65714,6 +66166,8 @@
         AlphaSynthScriptProcessorOutput,
         AlphaSynthWebAudioOutputBase,
         AlphaSynthWebWorkerApi,
+        AudioExportChunk,
+        AudioExportOptions,
         BackingTrackSyncPoint,
         CircularSampleBuffer,
         MidiEventsPlayedEventArgs,