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

package/dist/alphaTab.core.mjs

@@ -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.
  *
@@ -22533,7 +22533,6 @@ class MidiSequencerState {
         this.division = MidiUtils.QuarterTime;
         this.eventIndex = 0;
         this.currentTime = 0;
-        this.currentTick = 0;
         this.syncPointIndex = 0;
         this.playbackRange = null;
         this.playbackRangeStartTime = 0;
@@ -22541,7 +22540,7 @@ class MidiSequencerState {
         this.endTick = 0;
         this.endTime = 0;
         this.currentTempo = 0;
-        this.modifiedTempo = 0;
+        this.syncPointTempo = 0;
     }
 }
 /**
@@ -22598,7 +22597,13 @@ class MidiFileSequencer {
         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
@@ -22622,7 +22627,7 @@ class MidiFileSequencer {
             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;
@@ -22735,7 +22740,7 @@ class MidiFileSequencer {
             }
         }
         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;
@@ -22852,7 +22857,7 @@ class MidiFileSequencer {
             }
         }
         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;
@@ -22867,6 +22872,9 @@ class MidiFileSequencer {
         // 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) {
@@ -22881,6 +22889,9 @@ class MidiFileSequencer {
             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) {
@@ -22893,11 +22904,11 @@ class MidiFileSequencer {
             }
             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) {
@@ -23044,7 +23055,7 @@ class MidiFileSequencer {
         state.endTime = metronomeTime;
         state.endTick = metronomeTick;
         state.currentTempo = bpm;
-        state.modifiedTempo = bpm;
+        state.syncPointTempo = bpm;
         this._countInState = state;
     }
 }
@@ -28373,6 +28384,82 @@ class PlaybackRangeChangedEventArgs {
     }
 }
 
+/**
+ * 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}.
@@ -28849,6 +28936,184 @@ class AlphaSynth extends AlphaSynthBase {
     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;
+    }
 }
 
 /**
@@ -33282,6 +33547,7 @@ AlphaSynthWorkerSynthOutput.preferredSampleRate = 0;
  */
 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);
@@ -33397,6 +33663,53 @@ class AlphaSynthWebWorker {
                 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({
@@ -41703,8 +42016,7 @@ class AlphaTabApiBase {
         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;
         }
@@ -41744,8 +42056,7 @@ class AlphaTabApiBase {
         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;
@@ -41875,9 +42186,7 @@ class AlphaTabApiBase {
             }
         });
         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);
@@ -42567,6 +42876,57 @@ class AlphaTabApiBase {
     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(AlphaTabErrorType.General, 'No song loaded');
+        }
+        let exporter;
+        switch (this._actualPlayerMode) {
+            case 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;
+    }
 }
 
 /**
@@ -43400,6 +43760,9 @@ class AlphaSynthWebWorkerApi {
     get logLevel() {
         return Logger.logLevel;
     }
+    get worker() {
+        return this._synth;
+    }
     set logLevel(value) {
         Logger.logLevel = value;
         this._synth.postMessage({
@@ -44252,6 +44615,87 @@ class AudioElementBackingTrackSynthOutput {
     }
 }
 
+/**
+ * @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(AlphaTabErrorType.General, 'Worker was destroyed'));
+                this._promise = null;
+                break;
+        }
+    }
+    async render(milliseconds) {
+        if (this._promise) {
+            throw new AlphaTabError(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
  */
@@ -44818,6 +45262,14 @@ class BrowserUiFacade {
         }
         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();
@@ -61275,9 +61727,9 @@ class VersionInfo {
         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.
@@ -61947,7 +62399,7 @@ class CoreSettings {
     /**
      * 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) {
@@ -65708,6 +66160,8 @@ const _barrel = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
     AlphaSynthScriptProcessorOutput,
     AlphaSynthWebAudioOutputBase,
     AlphaSynthWebWorkerApi,
+    AudioExportChunk,
+    AudioExportOptions,
     BackingTrackSyncPoint,
     CircularSampleBuffer,
     MidiEventsPlayedEventArgs,