@drop-ai/core 0.2.0

package/dist/audio/AudioEngine.js

@@ -0,0 +1,798 @@
+import { Session } from '../domain/Session';
+import { TrackType } from '../domain/Track';
+import { Region } from '../domain/Region';
+import { MidiRegion } from '../domain/MidiRegion';
+import { MidiNote } from '../domain/MidiNote';
+import { MidiInput } from '../midi/MidiInput';
+import { GainProcessor } from '../processing/GainProcessor';
+import { PanProcessor } from '../processing/PanProcessor';
+import { PolarityProcessor } from '../processing/PolarityProcessor';
+import { SendProcessor } from '../processing/SendProcessor';
+import { MeterProcessor } from '../processing/MeterProcessor';
+import { PluginInsert } from '../processing/PluginInsert';
+export class AudioEngine {
+    constructor(backend) {
+        this.midiRecordingNotes = new Map();
+        this.midiRecordedNotes = [];
+        this.midiNoteOnSub = null;
+        this.midiNoteOffSub = null;
+        this.syncId = null;
+        this.session = new Session(crypto.randomUUID(), 'Untitled Session');
+        this.backend = backend;
+        this.midiInput = MidiInput.getInstance();
+        this.setupSessionListeners();
+    }
+    static getInstance(backend) {
+        if (!AudioEngine.instance) {
+            if (!backend)
+                throw new Error('AudioEngine requires a backend on first initialization');
+            AudioEngine.instance = new AudioEngine(backend);
+        }
+        return AudioEngine.instance;
+    }
+    /** Reset the singleton instance. For testing only. */
+    static resetInstance() {
+        AudioEngine.instance = undefined;
+    }
+    setBackend(backend) {
+        this.backend = backend;
+        // Re-setup listeners/state if backend changes (omitted for brevity)
+    }
+    /**
+     * Pre-cache a decoded AudioBuffer so subsequent addSource/getAudioBuffer
+     * calls for the same URL hit the cache instead of re-fetching.
+     * Useful when the source was loaded from a blob URL that will be revoked.
+     */
+    precacheAudioBuffer(url, buffer) {
+        this.backend.addAudioBuffer(url, buffer);
+    }
+    getEngineType() {
+        return this.backend.getEngineType();
+    }
+    getCurrentTime() {
+        return this.backend.getCurrentTime();
+    }
+    getCurrentFrame() {
+        return this.backend.getCurrentFrame();
+    }
+    seek(time) {
+        this.backend.seek(time);
+        // Sync session transport frame immediately
+        // This ensures that commands (like SplitAtPlayhead) relying on session.transportFrame
+        // have the correct position even when the transport is paused.
+        const frame = Math.floor(time * this.session.sampleRate);
+        this.session.locateTransport(frame);
+    }
+    updateRegion(trackId, region) {
+        const _dto = Object.assign(Object.assign({}, region), { end: region.end || (region.start + region.length), timeDomain: region.timeDomain });
+        // Re-sync all regions for the track to ensure consistency
+        const track = this.session.getTrack(trackId);
+        if (track) {
+            const regions = track.playlist.getRegions();
+            const regionsDTO = regions.map(r => (Object.assign(Object.assign({}, r), { end: r.end, timeDomain: r.timeDomain })));
+            this.backend.updateRegions(trackId, regionsDTO);
+        }
+    }
+    setupSessionListeners() {
+        // Register Master Bus IO with backend
+        const masterBus = this.session.masterBus;
+        this.backend.registerMasterIO(masterBus.input.id, masterBus.output.id);
+        // Sync master bus processors
+        masterBus.processors.forEach((proc, index) => {
+            const type = this.getProcessorType(proc);
+            this.backend.addMasterProcessor(proc.id, type, index);
+            this.connectMasterProcessorSignals(proc);
+        });
+        masterBus.processorAdded.connect((proc) => {
+            const index = masterBus.processors.indexOf(proc);
+            const type = this.getProcessorType(proc);
+            this.backend.addMasterProcessor(proc.id, type, index);
+            this.connectMasterProcessorSignals(proc);
+        });
+        masterBus.processorRemoved.connect((procId) => {
+            this.backend.removeMasterProcessor(procId);
+        });
+        // Track Added: Sync backend and subscribe to processor signals
+        this.session.trackAdded.connect((track) => {
+            // Use the appropriate backend method based on track type
+            if (track.type === TrackType.AUX) {
+                this.backend.createAuxTrack(track.id, track.name, track.route.input.id, track.route.output.id);
+            }
+            else if (track.type === TrackType.BUS) {
+                this.backend.createBusTrack(track.id, track.name, track.route.input.id, track.route.output.id);
+            }
+            else if (track.type === TrackType.MIDI) {
+                this.backend.createMidiTrack(track.id, track.name, track.route.input.id, track.route.output.id);
+            }
+            else {
+                this.backend.createTrack(track.id, track.name, track.route.input.id, track.route.output.id);
+            }
+            // Sync initial processors
+            track.route.processors.forEach((proc, index) => {
+                const type = this.getProcessorType(proc);
+                this.backend.addProcessor(track.id, proc.id, type, index);
+                this.connectProcessorSignals(track.id, proc);
+            });
+            // Listen for Processor Graph Changes
+            track.route.processorAdded.connect((proc) => {
+                // Find index
+                const index = track.route.processors.indexOf(proc);
+                const type = this.getProcessorType(proc);
+                this.backend.addProcessor(track.id, proc.id, type, index);
+                this.connectProcessorSignals(track.id, proc);
+            });
+            track.route.processorRemoved.connect((procId) => {
+                this.backend.removeProcessor(track.id, procId);
+            });
+            // Listen for Playlist Changes
+            track.playlist.regionAdded.connect((region) => {
+                const dto = Object.assign(Object.assign({}, region), { end: region.end, timeDomain: region.timeDomain });
+                this.backend.scheduleRegion(track.id, dto);
+            });
+            track.playlist.regionRemoved.connect((regionId) => {
+                // this.backend.removeRegion(track.id, regionId);
+                // Note: ToneAudioProvider implementation of removeRegion is empty/TODO, but we should call it.
+                this.backend.removeRegion(track.id, regionId);
+            });
+            // Fix 4: Region changed (ripple edit, move, resize, etc.)
+            track.playlist.regionChanged.connect((region) => {
+                this.updateRegion(track.id, region);
+            });
+            // Listen for MIDI Playlist Changes
+            track.playlist.midiRegionAdded.connect((midiRegion) => {
+                const dto = {
+                    id: midiRegion.id,
+                    name: midiRegion.name,
+                    start: midiRegion.start,
+                    length: midiRegion.length,
+                    end: midiRegion.end,
+                    muted: midiRegion.muted,
+                    notes: midiRegion.getNotes().map(n => ({
+                        id: n.id,
+                        pitch: n.pitch,
+                        velocity: n.velocity,
+                        startFrame: n.startFrame,
+                        durationFrames: n.durationFrames,
+                        channel: n.channel,
+                    })),
+                };
+                this.backend.scheduleMidiRegion(track.id, dto);
+            });
+            track.playlist.midiRegionRemoved.connect((regionId) => {
+                this.backend.removeMidiRegion(track.id, regionId);
+            });
+            this.bindTrackSignals(track);
+        });
+        // Track Removed: Sync backend
+        this.session.trackRemoved.connect((trackId) => {
+            this.backend.deleteTrack(trackId);
+        });
+        // Metronome Signals
+        this.session.metronomeChanged.connect((enabled) => {
+            this.backend.enableMetronome(enabled);
+        });
+        this.session.metronomeVolumeChanged.connect((volume) => {
+            this.backend.setMetronomeVolume(volume);
+        });
+        // Tempo Signal
+        this.session.tempoChanged.connect((bpm) => {
+            this.backend.setTempo(bpm);
+            // Update all regions on all tracks with new DTO (includes playbackRate)
+            this.session.tracks.forEach(track => {
+                const regions = track.playlist.getRegions();
+                const regionsDTO = regions.map(r => (Object.assign(Object.assign({}, r), { end: r.end, timeDomain: r.timeDomain })));
+                this.backend.updateRegions(track.id, regionsDTO);
+            });
+        });
+        // Source Added
+        this.session.sourceAdded.connect((source) => {
+            this.backend.addSource(source);
+        });
+        // Send Bus Signals
+        this.session.sendBusAdded.connect((sendBus) => {
+            this.backend.addSendBus(sendBus.id, sendBus.sourceTrackId, sendBus.destId, sendBus.level, sendBus.preFader);
+            // Subscribe to level changes
+            sendBus.levelChanged.connect((levelDb) => {
+                this.backend.setSendBusLevel(sendBus.id, levelDb);
+            });
+            // Subscribe to preFader changes
+            sendBus.preFaderChanged.connect((preFader) => {
+                this.backend.setSendBusPreFader(sendBus.id, preFader);
+            });
+            // Subscribe to active changes
+            sendBus.activeChanged.connect((active) => {
+                this.backend.setSendBusActive(sendBus.id, active);
+            });
+        });
+        this.session.sendBusRemoved.connect((sendBusId) => {
+            this.backend.removeSendBus(sendBusId);
+        });
+        // Monitor Changed Setup (Initial tracks)
+        this.session.tracks.forEach(t => {
+            this.bindTrackSignals(t);
+        });
+    }
+    bindTrackSignals(track) {
+        if (track.monitorChanged) {
+            track.monitorChanged.connect((enabled) => {
+                this.backend.setMonitor(track.id, enabled);
+            });
+        }
+        // Mute / Solo
+        track.muteChanged.connect((muted) => {
+            this.backend.setTrackMute(track.id, muted);
+        });
+        track.soloChanged.connect((soloed) => {
+            this.backend.setTrackSolo(track.id, soloed);
+        });
+        // Solo Isolate / Solo Safe
+        track.soloIsolateChanged.connect((isolate) => {
+            this.backend.setTrackSoloIsolate(track.id, isolate);
+        });
+        track.soloSafeChanged.connect((safe) => {
+            this.backend.setTrackSoloSafe(track.id, safe);
+        });
+        // Monitor Mode
+        track.monitorModeChanged.connect((mode) => {
+            this.backend.setMonitorMode(track.id, mode);
+        });
+        // IO Signals
+        if (track.route) {
+            const route = track.route;
+            // Listen to Input connections (if Input acts as a destination, it might not emit connected? Input usually IS a destination)
+            // IO.connected emits when *this* IO connects TO something.
+            // Output connects TO Input.
+            // So we listen to output.connected.
+            if (route.output && route.output.connected) {
+                route.output.connected.connect((destId) => {
+                    this.backend.connectIO(route.output.id, destId);
+                });
+                route.output.disconnected.connect((destId) => {
+                    this.backend.disconnectIO(route.output.id, destId);
+                });
+            }
+            // If we allow Input to connect to something (e.g. internal routing?), listen there too.
+            // But usually Input is a sink. 
+            // However, IO class is generic.
+            if (route.input && route.input.connected) {
+                route.input.connected.connect((destId) => {
+                    this.backend.connectIO(route.input.id, destId);
+                });
+                route.input.disconnected.connect((destId) => {
+                    this.backend.disconnectIO(route.input.id, destId);
+                });
+            }
+        }
+    }
+    getProcessorType(proc) {
+        if (proc instanceof GainProcessor) {
+            return proc.name === 'Trim' ? 'Trim' : 'Fader';
+        }
+        if (proc instanceof PanProcessor)
+            return 'Panner';
+        if (proc instanceof PolarityProcessor)
+            return 'Polarity';
+        if (proc instanceof SendProcessor)
+            return 'Send';
+        if (proc instanceof MeterProcessor)
+            return 'Meter';
+        if (proc instanceof PluginInsert)
+            return `Insert: ${proc.plugin.name}`;
+        return 'Unknown';
+    }
+    connectMasterProcessorSignals(proc) {
+        if (proc instanceof GainProcessor) {
+            proc.gainChanged.connect((val) => {
+                this.backend.setMasterGain(val);
+            });
+        }
+        if (proc instanceof PluginInsert && proc.plugin && proc.plugin.parameterChanged) {
+            proc.plugin.parameterChanged.connect(({ id, value }) => {
+                this.backend.setMasterProcessorParameter(proc.id, id, value);
+            });
+        }
+    }
+    connectProcessorSignals(trackId, proc) {
+        if (proc instanceof GainProcessor) {
+            proc.gainChanged.connect((val) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'gain', val);
+            });
+        }
+        if (proc instanceof PanProcessor) {
+            proc.panChanged.connect((val) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'pan', val);
+            });
+            proc.widthChanged.connect((val) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'width', val);
+            });
+        }
+        if (proc instanceof PolarityProcessor) {
+            proc.polarityChanged.connect((inverted) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'polarity', inverted ? 1 : 0);
+            });
+        }
+        if (proc instanceof SendProcessor) {
+            proc.levelChanged.connect((val) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'level', val);
+            });
+            proc.preFaderChanged.connect((preFader) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'preFader', preFader ? 1 : 0);
+            });
+            proc.muteChanged.connect((muted) => {
+                this.backend.setProcessorParameter(trackId, proc.id, 'muted', muted ? 1 : 0);
+            });
+        }
+        // Plugin Signals
+        if (proc instanceof PluginInsert && proc.plugin && proc.plugin.parameterChanged) {
+            proc.plugin.parameterChanged.connect(({ id, value }) => {
+                this.backend.setProcessorParameter(trackId, proc.id, id, value);
+            });
+        }
+        // Listen for Automation Changes
+        if (proc.automations) {
+            proc.automations.forEach((list, param) => {
+                this.bindAutomationList(trackId, proc.id, param, list);
+            });
+        }
+        // Listen for future automations (Lazy creation)
+        if (proc.automationAdded) {
+            proc.automationAdded.connect(({ paramName, list }) => {
+                this.bindAutomationList(trackId, proc.id, paramName, list);
+            });
+        }
+    }
+    bindAutomationList(trackId, procId, param, list) {
+        if (list.changed) {
+            list.changed.connect(() => {
+                console.log(`[AudioEngine] Automation changed for ${trackId}:${procId}:${param}`);
+                const points = list.getPoints();
+                this.backend.setProcessorAutomation(trackId, procId, param, points);
+            });
+            // Initial sync if not empty
+            const points = list.getPoints();
+            if (points.length > 0) {
+                this.backend.setProcessorAutomation(trackId, procId, param, points);
+            }
+        }
+    }
+    async initialize() {
+        await this.backend.initialize();
+    }
+    // Transport
+    // Transport
+    async start() {
+        this.scheduleAutomations();
+        this.backend.setTempo(this.session.tempo);
+        this.session.startTransport();
+        await this.backend.start();
+        this.startTransportSync();
+    }
+    requestFrame(cb) {
+        if (typeof requestAnimationFrame !== 'undefined') {
+            return requestAnimationFrame(cb);
+        }
+        return setTimeout(cb, 16);
+    }
+    cancelFrame(id) {
+        if (typeof cancelAnimationFrame !== 'undefined') {
+            cancelAnimationFrame(id);
+        }
+        else {
+            clearTimeout(id);
+        }
+    }
+    startTransportSync() {
+        if (this.syncId)
+            this.cancelFrame(this.syncId);
+        const loop = () => {
+            if (!this.session.isPlaying)
+                return;
+            // Get current time from Backend
+            const currentFrame = this.backend.getCurrentFrame();
+            // Check punch range during recording
+            if (this.session.isRecording && this.session.punchEnabled && this.session.punchRangeId) {
+                const punchRange = this.session.getPunchRange();
+                if (punchRange) {
+                    const isInPunchRange = currentFrame >= punchRange.start && currentFrame < punchRange.end;
+                    const armedTracks = this.session.tracks.filter(t => t.armed);
+                    // Mute/unmute recording based on whether we are inside the punch range
+                    armedTracks.forEach(t => {
+                        this.backend.setRecordingMuted(t.id, !isInPunchRange);
+                    });
+                }
+            }
+            // Check loop
+            if (this.session.loopEnabled && this.session.loopRangeId) {
+                const loopRange = this.session.getLoopRange();
+                if (loopRange && currentFrame >= loopRange.end) {
+                    // Handle loop recording: save current take before looping
+                    if (this.session.isRecording && this.session.loopRecordingEnabled) {
+                        this.handleLoopRecordingTake(currentFrame).catch(err => {
+                            console.error('[AudioEngine] Error handling loop recording take:', err);
+                        });
+                    }
+                    // Loop back to start
+                    console.log(`[AudioEngine] Loop: ${currentFrame} >= ${loopRange.end}, seeking to ${loopRange.start}`);
+                    this.backend.seek(loopRange.start / this.session.sampleRate);
+                    this.session.locateTransport(loopRange.start);
+                }
+                else {
+                    this.session.locateTransport(currentFrame);
+                }
+            }
+            else {
+                this.session.locateTransport(currentFrame);
+            }
+            this.syncId = this.requestFrame(loop);
+        };
+        this.syncId = this.requestFrame(loop);
+    }
+    scheduleAutomations() {
+        this.session.tracks.forEach(track => {
+            track.route.processors.forEach((proc) => {
+                if (proc.automations) {
+                    proc.automations.forEach((automationList, paramName) => {
+                        const points = automationList.getPoints();
+                        if (points.length > 0) {
+                            this.backend.setProcessorAutomation(track.id, proc.id, paramName, points);
+                        }
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        this.session.stopTransport();
+        this.backend.stop();
+    }
+    pause() {
+        this.session.isPlaying = false;
+        this.backend.pause();
+    }
+    // Punch Recording
+    enablePunchRecording(enabled) {
+        this.session.setPunchEnabled(enabled);
+        // Sync punch range to backend
+        if (enabled && this.session.punchRangeId) {
+            const punchRange = this.session.getPunchRange();
+            if (punchRange) {
+                this.backend.enablePunchRecording(true);
+                this.backend.setPunchRange(punchRange.start, punchRange.end);
+            }
+        }
+        else {
+            this.backend.enablePunchRecording(false);
+        }
+    }
+    // Monitor with effects
+    setMonitorWithEffects(trackId, enabled) {
+        this.backend.setMonitorWithEffects(trackId, enabled);
+    }
+    // Input Latency
+    getInputLatencyMs() {
+        return this.backend.getInputLatencyMs();
+    }
+    /**
+     * Handle loop recording take: stop current recording, save take as a region on a new layer,
+     * then restart recording for the next pass.
+     */
+    async handleLoopRecordingTake(_endFrame) {
+        const armedTracks = this.session.tracks.filter(t => t.armed);
+        const takeNumber = this.session.incrementTakeCount();
+        const loopRange = this.session.getLoopRange();
+        if (!loopRange)
+            return;
+        console.log(`[AudioEngine] Loop recording: completing take ${takeNumber}`);
+        for (const track of armedTracks) {
+            // Stop current recording and collect blob
+            const blob = await this.backend.stopRecording(track.id);
+            if (blob.size > 0) {
+                const url = URL.createObjectURL(blob);
+                await this.backend.cacheBlob(url, blob);
+                const startFrame = loopRange.start;
+                const durationFrames = loopRange.end - loopRange.start;
+                if (durationFrames > 0) {
+                    const regionId = crypto.randomUUID();
+                    // Each take goes on a different layer
+                    const region = new Region(regionId, url, startFrame, durationFrames, 0, `Take ${takeNumber}`, takeNumber // layer = take number
+                    );
+                    track.playlist.addRegion(region);
+                    console.log(`[AudioEngine] Loop take ${takeNumber}: Region created on layer ${takeNumber}`);
+                }
+            }
+            // Restart recording for next take
+            await this.backend.prepareRecording(track.id);
+            this.backend.startRecording(track.id);
+        }
+    }
+    // ─── MIDI Input ─────────────────────────────────────────────────────────
+    /**
+     * Initialize MIDI input subsystem.
+     */
+    async initializeMidiInput() {
+        return this.midiInput.initialize();
+    }
+    /**
+     * Get available MIDI input devices.
+     */
+    getMidiInputDevices() {
+        return this.midiInput.getInputDevices();
+    }
+    /**
+     * Set the active MIDI input device.
+     */
+    setMidiInputDevice(inputId) {
+        this.midiInput.setActiveInput(inputId);
+    }
+    /**
+     * Get the MidiInput singleton for external consumers.
+     */
+    getMidiInput() {
+        return this.midiInput;
+    }
+    // ─── MIDI Recording Helpers ──────────────────────────────────────────────
+    startMidiRecording() {
+        this.midiRecordingNotes.clear();
+        this.midiRecordedNotes = [];
+        // Subscribe to MIDI note events
+        this.midiNoteOnSub = this.midiInput.noteOn.connect((event) => {
+            if (!this.session.isRecording)
+                return;
+            const currentFrame = this.backend.getCurrentFrame();
+            const key = `${event.channel}-${event.pitch}`;
+            this.midiRecordingNotes.set(key, {
+                pitch: event.pitch,
+                velocity: event.velocity,
+                channel: event.channel,
+                startFrame: currentFrame,
+            });
+        });
+        this.midiNoteOffSub = this.midiInput.noteOff.connect((event) => {
+            if (!this.session.isRecording)
+                return;
+            const currentFrame = this.backend.getCurrentFrame();
+            const key = `${event.channel}-${event.pitch}`;
+            const pending = this.midiRecordingNotes.get(key);
+            if (pending) {
+                const durationFrames = Math.max(1, currentFrame - pending.startFrame);
+                const note = new MidiNote(crypto.randomUUID(), pending.pitch, pending.velocity, pending.startFrame, durationFrames, pending.channel);
+                this.midiRecordedNotes.push(note);
+                this.midiRecordingNotes.delete(key);
+            }
+        });
+    }
+    stopMidiRecording() {
+        var _a, _b;
+        // Close any still-held notes at the current position
+        const currentFrame = this.backend.getCurrentFrame();
+        for (const [_key, pending] of this.midiRecordingNotes) {
+            const durationFrames = Math.max(1, currentFrame - pending.startFrame);
+            const note = new MidiNote(crypto.randomUUID(), pending.pitch, pending.velocity, pending.startFrame, durationFrames, pending.channel);
+            this.midiRecordedNotes.push(note);
+        }
+        this.midiRecordingNotes.clear();
+        // Unsubscribe
+        (_a = this.midiNoteOnSub) === null || _a === void 0 ? void 0 : _a.dispose();
+        (_b = this.midiNoteOffSub) === null || _b === void 0 ? void 0 : _b.dispose();
+        this.midiNoteOnSub = null;
+        this.midiNoteOffSub = null;
+    }
+    finalizeMidiRecording() {
+        if (this.midiRecordedNotes.length === 0)
+            return;
+        const armedMidiTracks = this.session.tracks.filter(t => t.armed && t.type === TrackType.MIDI);
+        for (const track of armedMidiTracks) {
+            const startFrame = this.session.recordingStartFrame;
+            // Find the extent of recorded notes
+            let minStart = Infinity;
+            let maxEnd = 0;
+            for (const note of this.midiRecordedNotes) {
+                if (note.startFrame < minStart)
+                    minStart = note.startFrame;
+                if (note.endFrame > maxEnd)
+                    maxEnd = note.endFrame;
+            }
+            const regionStart = Math.min(startFrame, minStart);
+            const regionLength = maxEnd - regionStart;
+            if (regionLength <= 0)
+                continue;
+            const regionId = crypto.randomUUID();
+            const region = new MidiRegion(regionId, 'MIDI Recording', regionStart, regionLength);
+            // Make note positions relative to region start
+            for (const note of this.midiRecordedNotes) {
+                const relativeNote = new MidiNote(note.id, note.pitch, note.velocity, note.startFrame - regionStart, note.durationFrames, note.channel);
+                region.addNote(relativeNote);
+            }
+            track.playlist.addMidiRegion(region);
+            console.log(`[AudioEngine] MIDI recording finalized: ${this.midiRecordedNotes.length} notes in region ${regionId}`);
+        }
+        this.midiRecordedNotes = [];
+    }
+    // Recording
+    async startRecording() {
+        const armedTracks = this.session.tracks.filter(t => t.armed);
+        console.log(`[AudioEngine] Starting recording. Armed tracks: ${armedTracks.length}`);
+        // Setup punch recording if enabled
+        if (this.session.punchEnabled && this.session.punchRangeId) {
+            const punchRange = this.session.getPunchRange();
+            if (punchRange) {
+                console.log(`[AudioEngine] Punch recording enabled: ${punchRange.name} (${punchRange.start} - ${punchRange.end})`);
+                this.backend.enablePunchRecording(true);
+                this.backend.setPunchRange(punchRange.start, punchRange.end);
+            }
+        }
+        // Reset loop recording take count
+        if (this.session.loopRecordingEnabled) {
+            this.session.loopRecordingTakeCount = 0;
+            console.log('[AudioEngine] Loop recording mode active');
+        }
+        // Prepare audio recording for non-MIDI armed tracks
+        const armedAudioTracks = armedTracks.filter(t => t.type !== TrackType.MIDI);
+        await Promise.all(armedAudioTracks.map(t => this.backend.prepareRecording(t.id)));
+        // Start all prepared audio tracks
+        armedAudioTracks.forEach(t => this.backend.startRecording(t.id));
+        // Start MIDI recording if any armed MIDI tracks
+        const armedMidiTracks = armedTracks.filter(t => t.type === TrackType.MIDI);
+        if (armedMidiTracks.length > 0) {
+            this.startMidiRecording();
+        }
+        this.session.startRecording();
+        // Handle pre-roll: if pre-roll is set, start playback with metronome first
+        if (this.session.preRollBars > 0) {
+            const preRollSeconds = this.session.getPreRollDurationSeconds();
+            console.log(`[AudioEngine] Pre-roll: ${this.session.preRollBars} bars (${preRollSeconds.toFixed(2)}s)`);
+            // Enable metronome for pre-roll if not already enabled
+            const wasMetronomeEnabled = this.session.metronomeEnabled;
+            if (!wasMetronomeEnabled) {
+                this.backend.enableMetronome(true);
+            }
+            // Mute recording during pre-roll
+            armedTracks.forEach(t => this.backend.setRecordingMuted(t.id, true));
+            // Start transport
+            await this.start();
+            // After pre-roll duration, unmute recording
+            setTimeout(() => {
+                armedTracks.forEach(t => this.backend.setRecordingMuted(t.id, false));
+                // Restore metronome state
+                if (!wasMetronomeEnabled) {
+                    this.backend.enableMetronome(false);
+                }
+                // Update recording start frame to after pre-roll
+                this.session.recordingStartFrame = this.backend.getCurrentFrame();
+                console.log('[AudioEngine] Pre-roll complete, recording active');
+            }, preRollSeconds * 1000);
+        }
+        else {
+            // No pre-roll, start immediately
+            await this.start();
+        }
+    }
+    async stopRecording() {
+        const armedTracks = this.session.tracks.filter(t => t.armed);
+        console.log(`[AudioEngine] Stopping recording. Armed tracks: ${armedTracks.length}`);
+        // Capture end frame BEFORE stopping transport (which resets to 0)
+        // using backend for precision or session for consistency.
+        // Backend is the source of truth for time.
+        const endFrame = this.backend.getCurrentFrame();
+        // Stop MIDI recording first (before transport stop resets frame)
+        this.stopMidiRecording();
+        this.finalizeMidiRecording();
+        // Stop Transport
+        this.stop();
+        // Stop all audio armed tracks and collect blobs
+        const armedAudioTracks = armedTracks.filter(t => t.type !== TrackType.MIDI);
+        for (const track of armedAudioTracks) {
+            const blob = await this.backend.stopRecording(track.id);
+            if (blob.size > 0) {
+                // Create Region
+                console.log(`Recorded blob for track ${track.id}, size: ${blob.size}`);
+                const url = URL.createObjectURL(blob);
+                // Cache the blob as AudioBuffer immediately for Waveform rendering
+                await this.backend.cacheBlob(url, blob);
+                // Calculate duration
+                const startFrame = this.session.recordingStartFrame;
+                const durationFrames = endFrame - startFrame;
+                // Create Region in Playlist
+                if (durationFrames > 0) {
+                    const regionId = crypto.randomUUID();
+                    const region = new Region(regionId, url, startFrame, durationFrames, 0, 'Recording');
+                    track.playlist.addRegion(region);
+                    console.log(`Created Region: ${url}, Start: ${startFrame}, Dur: ${durationFrames}`);
+                }
+            }
+        }
+        this.session.stopRecording();
+    }
+    // Track Management - Proxy to Session
+    addTrack(name, type = TrackType.AUDIO, id) {
+        return this.session.addTrack(name, type, id);
+    }
+    removeTrack(trackId) {
+        this.session.removeTrack(trackId);
+    }
+    // Direct Parameter Control - Now updates Domain, which signals Backend
+    setTrackGain(trackId, gain) {
+        const track = this.session.getTrack(trackId);
+        if (track) {
+            track.route.volume = gain; // Updates Route -> Signal -> Backend
+        }
+    }
+    setTrackPan(trackId, pan) {
+        const track = this.session.getTrack(trackId);
+        if (track) {
+            track.route.pan = pan; // Updates Route -> Signal -> Backend
+        }
+    }
+    // Export
+    getExportConfig() {
+        return this.session.getExportConfig();
+    }
+    getExportStatus() {
+        return this.session.getExportStatus();
+    }
+    async exportAudio(config, _status) {
+        const trackIds = config.exportMasterOnly
+            ? this.session.tracks.map(t => t.id)
+            : config.trackIds;
+        const _buffer = await this.backend.exportAudio(config.startFrame, config.endFrame, config.sampleRate, trackIds);
+        // This is now handled by OfflineExporter in ExportCommand
+        // But we keep this method for potential direct use
+        return;
+    }
+    async renderRegionsToBuffer(trackId, regionIds) {
+        return this.backend.renderRegionsToBuffer(trackId, regionIds);
+    }
+    // Metering
+    getMeterData(trackId) {
+        return this.backend.getMeterData(trackId);
+    }
+    getMasterMeterData() {
+        return this.backend.getMasterMeterData();
+    }
+    getAnalyserNode(trackId) {
+        return this.backend.getAnalyserNode(trackId);
+    }
+    // Region Audition
+    auditionRegion(trackId, regionId) {
+        this.backend.auditionRegion(trackId, regionId);
+    }
+    stopAudition() {
+        this.backend.stopAudition();
+    }
+    // MIDI Instrument
+    setMidiInstrument(trackId, instrumentType) {
+        this.backend.setMidiInstrument(trackId, instrumentType);
+    }
+    // Strip Silence
+    async stripSilence(trackId, regionId, thresholdDb, minLengthFrames) {
+        return this.backend.stripSilence(trackId, regionId, thresholdDb, minLengthFrames);
+    }
+    // Normalize Region
+    async normalizeRegion(trackId, regionId, targetDb) {
+        return this.backend.normalizeRegion(trackId, regionId, targetDb);
+    }
+    // MIDI Panic
+    midiPanic() {
+        this.backend.midiPanic();
+    }
+    // Stereo Master Metering
+    getMasterStereoMeterData() {
+        return this.backend.getMasterStereoMeterData();
+    }
+    // Region Reverse
+    async reverseRegionBuffer(trackId, regionId) {
+        return this.backend.reverseRegionBuffer(trackId, regionId);
+    }
+    // Session Management
+    loadSession(newSession) {
+        this.stop();
+        this.session = newSession;
+        this.setupSessionListeners();
+    }
+    loadSessionFromSnapshot(snapshot) {
+        this.stop();
+        this.session = Session.fromJSON(snapshot);
+        this.setupSessionListeners();
+    }
+}
+//# sourceMappingURL=AudioEngine.js.map