@drop-ai/core 0.2.0

package/dist/domain/Session.js

@@ -0,0 +1,965 @@
+import { Track, TrackType } from './Track';
+import { Route } from './Route';
+import { Range } from './Range';
+import { Region } from './Region';
+import { MidiRegion } from './MidiRegion';
+import { SendBus } from './SendBus';
+import { Marker } from './Marker';
+import { RegionGroup } from './RegionGroup';
+import { Signal } from '../lib/Signal';
+import { ExportConfig } from './ExportConfig';
+import { ExportStatus } from './ExportStatus';
+import { GridSettings } from './GridSettings';
+import { TempoMap } from './temporal/TempoMap';
+import { TimeDomain } from './temporal/types';
+import { MixerSceneManager } from './MixerScene';
+import { TrackGroup } from './TrackGroup';
+import { CDMarker } from './CDMarker';
+import { VCATrack } from './VCATrack';
+import { ScrubState } from './TransportMode';
+import { TransportFSM, MotionState } from './TransportFSM';
+import { SidechainConfig } from './SidechainConfig';
+import { Take, TakeLane } from './Take';
+export class Session {
+    get isPlaying() { return this._isPlaying; }
+    set isPlaying(value) {
+        if (this._isPlaying !== value) {
+            this._isPlaying = value;
+            this.playingChanged.emit(value);
+        }
+    }
+    constructor(name, id, sampleRate = 44100) {
+        // Transport State
+        this.tempo = 120.0;
+        this.timeSignature = [4, 4];
+        this.timecodeFps = 30;
+        this.transportFrame = 0;
+        this.recordingStartFrame = 0;
+        /**
+         * Transport Finite State Machine.
+         * Manages transport motion state (stopped/rolling/declick), direction,
+         * and variable-speed playback. See TransportFSM.ts for full documentation.
+         */
+        this.transportFSM = new TransportFSM();
+        /**
+         * Backwards-compatible `isPlaying` accessor.
+         * Delegates to `transportFSM.isRolling()` for reads.
+         * Writing `true` enqueues a StartTransport event;
+         * writing `false` triggers an immediate stop (for legacy callers
+         * like AudioEngine.pause that bypass the FSM lifecycle).
+         */
+        this._isPlaying = false;
+        this.loopEnabled = false;
+        this.punchEnabled = false;
+        // Loop Recording
+        this.loopRecordingEnabled = false;
+        this.loopRecordingTakeCount = 0;
+        // Pre-roll / Count-in
+        this.preRollBars = 0;
+        // Editing Mode
+        this.rippleEdit = false;
+        // Structure
+        this._tracks = new Map();
+        this._ranges = new Map();
+        this._sendBuses = new Map();
+        this._markers = new Map();
+        this._regionGroups = new Map();
+        // Selection State
+        this._selectedRegionIds = new Set();
+        this.selectionChanged = new Signal();
+        // Signals
+        this.trackAdded = new Signal();
+        this.trackRemoved = new Signal();
+        this.rangeAdded = new Signal();
+        this.rangeRemoved = new Signal();
+        this.loopRangeChanged = new Signal();
+        this.loopEnabledChanged = new Signal();
+        this.punchRangeChanged = new Signal();
+        this.punchEnabledChanged = new Signal();
+        this.playingChanged = new Signal();
+        this.recordingChanged = new Signal();
+        this.loopRecordingChanged = new Signal();
+        this.preRollChanged = new Signal();
+        this.metronomeChanged = new Signal();
+        this.metronomeVolumeChanged = new Signal();
+        this.transportPositionChanged = new Signal();
+        this.tempoChanged = new Signal();
+        this.timeSignatureChanged = new Signal();
+        this.sendBusAdded = new Signal();
+        this.sendBusRemoved = new Signal();
+        this.markerAdded = new Signal();
+        this.markerRemoved = new Signal();
+        this.markerChanged = new Signal();
+        this.trackReordered = new Signal();
+        this.rippleEditChanged = new Signal();
+        this.regionGroupAdded = new Signal();
+        this.regionGroupRemoved = new Signal();
+        this.isRecording = false;
+        this.metronomeEnabled = false;
+        this.metronomeVolume = 1.0;
+        // Grid & Snap settings
+        this.gridSettings = new GridSettings();
+        // Mixer Scenes
+        this.mixerSceneManager = new MixerSceneManager();
+        // Track Groups (Phase 10)
+        this._trackGroups = new Map();
+        this.trackGroupAdded = new Signal();
+        this.trackGroupRemoved = new Signal();
+        // CD Markers (Phase 12)
+        this._cdMarkers = new Map();
+        this.cdMarkerAdded = new Signal();
+        this.cdMarkerRemoved = new Signal();
+        // VCA Tracks (Phase 10-4)
+        this._vcaTracks = new Map();
+        this.vcaTrackAdded = new Signal();
+        this.vcaTrackRemoved = new Signal();
+        // Scrub/Shuttle (Phase 10-2)
+        this.scrubState = new ScrubState();
+        // Sidechain Configs (Phase 12-3)
+        this._sidechainConfigs = new Map();
+        // Take Lanes (Phase 9-4)
+        this._takeLanes = new Map();
+        // Source Management
+        this._sources = new Map();
+        this.sourceAdded = new Signal();
+        this.id = id || crypto.randomUUID();
+        this.name = name;
+        this.sampleRate = sampleRate;
+        this.gridSettings = new GridSettings(undefined, undefined, this.tempo);
+        this.gridSettings.setTimeSignature(this.timeSignature[0], this.timeSignature[1]);
+        this.tempoMap = new TempoMap(sampleRate);
+        // Initialize Master Bus
+        this.masterBus = new Route(crypto.randomUUID(), 'Master');
+        // Wire up FSM signals to keep legacy state in sync.
+        this.transportFSM.stateChanged.connect((state) => {
+            const rolling = state === MotionState.ROLLING;
+            // Sync the legacy _isPlaying flag when the FSM transitions.
+            if (this._isPlaying !== rolling) {
+                this._isPlaying = rolling;
+                this.playingChanged.emit(rolling);
+            }
+        });
+        this.transportFSM.locateRequested.connect((frame) => {
+            this.locateTransport(frame);
+        });
+    }
+    addTrack(name, type = TrackType.AUDIO, id) {
+        const trackId = id || crypto.randomUUID();
+        const track = new Track(trackId, name, type);
+        this._tracks.set(trackId, track);
+        this.trackAdded.emit(track);
+        return track;
+    }
+    addAuxTrack(name, id) {
+        return this.addTrack(name, TrackType.AUX, id);
+    }
+    addBusTrack(name, id) {
+        return this.addTrack(name, TrackType.BUS, id);
+    }
+    removeTrack(id) {
+        if (this._tracks.has(id)) {
+            this._tracks.delete(id);
+            this.trackRemoved.emit(id);
+        }
+    }
+    getTrack(id) {
+        return this._tracks.get(id);
+    }
+    get tracks() {
+        return Array.from(this._tracks.values());
+    }
+    // Range Management
+    addRange(name, start, end, id, color) {
+        const rangeId = id || crypto.randomUUID();
+        const range = new Range(rangeId, name, start, end, color);
+        this._ranges.set(rangeId, range);
+        this.rangeAdded.emit(range);
+        return range;
+    }
+    removeRange(id) {
+        const range = this._ranges.get(id);
+        if (range) {
+            range.removed.emit();
+            this._ranges.delete(id);
+            this.rangeRemoved.emit(id);
+        }
+    }
+    getRange(id) {
+        return this._ranges.get(id);
+    }
+    getRangeByName(name) {
+        return Array.from(this._ranges.values()).find(r => r.name === name);
+    }
+    get ranges() {
+        return Array.from(this._ranges.values());
+    }
+    // Loop Range Management
+    setLoopRange(rangeId) {
+        const range = this.getRange(rangeId);
+        if (!range) {
+            throw new Error(`Range not found: ${rangeId}`);
+        }
+        this.loopRangeId = rangeId;
+        this.loopRangeChanged.emit(rangeId);
+    }
+    clearLoopRange() {
+        this.loopRangeId = undefined;
+        this.loopEnabled = false;
+        this.loopRangeChanged.emit(undefined);
+        this.loopEnabledChanged.emit(false);
+    }
+    getLoopRange() {
+        return this.loopRangeId ? this.getRange(this.loopRangeId) : undefined;
+    }
+    setLoopEnabled(enabled) {
+        if (!this.loopRangeId && enabled) {
+            throw new Error('Cannot enable loop without setting loop range first');
+        }
+        this.loopEnabled = enabled;
+        this.loopEnabledChanged.emit(enabled);
+    }
+    toggleLoop() {
+        if (this.loopRangeId) {
+            this.setLoopEnabled(!this.loopEnabled);
+        }
+    }
+    // Punch Range Management
+    setPunchRange(rangeId) {
+        const range = this.getRange(rangeId);
+        if (!range) {
+            throw new Error(`Range not found: ${rangeId}`);
+        }
+        this.punchRangeId = rangeId;
+        this.punchRangeChanged.emit(rangeId);
+    }
+    clearPunchRange() {
+        this.punchRangeId = undefined;
+        this.punchRangeChanged.emit(undefined);
+    }
+    getPunchRange() {
+        return this.punchRangeId ? this.getRange(this.punchRangeId) : undefined;
+    }
+    setPunchEnabled(enabled) {
+        if (!this.punchRangeId && enabled) {
+            throw new Error('Cannot enable punch without setting punch range first');
+        }
+        this.punchEnabled = enabled;
+        this.punchEnabledChanged.emit(enabled);
+    }
+    // Loop Recording
+    setLoopRecording(enabled) {
+        this.loopRecordingEnabled = enabled;
+        if (!enabled) {
+            this.loopRecordingTakeCount = 0;
+        }
+        this.loopRecordingChanged.emit(enabled);
+    }
+    incrementTakeCount() {
+        this.loopRecordingTakeCount++;
+        return this.loopRecordingTakeCount;
+    }
+    // Pre-roll / Count-in
+    setPreRollBars(bars) {
+        this.preRollBars = Math.max(0, Math.floor(bars));
+        this.preRollChanged.emit(this.preRollBars);
+    }
+    /**
+     * Calculate pre-roll duration in seconds based on current tempo and time signature.
+     */
+    getPreRollDurationSeconds() {
+        if (this.preRollBars <= 0)
+            return 0;
+        const beatsPerBar = this.timeSignature[0];
+        const totalBeats = this.preRollBars * beatsPerBar;
+        const secondsPerBeat = 60 / this.tempo;
+        return totalBeats * secondsPerBeat;
+    }
+    /**
+     * Calculate pre-roll duration in frames.
+     */
+    getPreRollDurationFrames() {
+        return Math.floor(this.getPreRollDurationSeconds() * this.sampleRate);
+    }
+    // Transport Control (Domain Level)
+    // These methods only update the 'Truth' state. 
+    // The AudioProvider will observe these changes.
+    setTempo(bpm) {
+        if (bpm <= 0 || bpm === this.tempo)
+            return;
+        console.log(`[Session.setTempo] Changing tempo from ${this.tempo} to ${bpm}`);
+        const oldBpm = this.tempo;
+        const ratio = bpm / oldBpm;
+        this.tempo = bpm;
+        // Update grid settings
+        this.gridSettings.setBPM(bpm);
+        // Update regions based on their time domain
+        this.tracks.forEach(track => {
+            const regions = track.playlist.getRegions();
+            console.log(`[Session.setTempo] Track ${track.name} has ${regions.length} region(s)`);
+            regions.forEach(region => {
+                console.log(`[Session.setTempo] Region "${region.name}": timeDomain=${region.timeDomain} (0=Audio, 1=Beat)`);
+                if (region.timeDomain === TimeDomain.BeatTime) {
+                    console.log(`[Session.setTempo] Updating Musical Mode region "${region.name}"`);
+                    // Convert current frame position to beats at old BPM
+                    const startBeats = this.tempoMap.framesToBeats(region.start, oldBpm);
+                    const lengthBeats = this.tempoMap.framesToBeats(region.length, oldBpm);
+                    console.log(`[Session.setTempo]   - Old: start=${region.start} frames, length=${region.length} frames`);
+                    console.log(`[Session.setTempo]   - Beats: start=${startBeats.toNumber()}, length=${lengthBeats.toNumber()}`);
+                    // Recalculate frames at new BPM
+                    const newStart = this.tempoMap.beatsToFrames(startBeats, bpm);
+                    const newLength = this.tempoMap.beatsToFrames(lengthBeats, bpm);
+                    console.log(`[Session.setTempo]   - New: start=${newStart} frames, length=${newLength} frames`);
+                    console.log(`[Session.setTempo]   - Playback rate: ${ratio}`);
+                    region.move(newStart);
+                    region.resize(newLength);
+                    // Adjust playback rate to compensate for tempo change
+                    region.playbackRate = ratio;
+                    // Notify UI that region has changed
+                    console.log(`[Session.setTempo] Emitting regionChanged signal for "${region.name}"`);
+                    track.playlist.regionChanged.emit(region);
+                }
+                else {
+                    console.log(`[Session.setTempo] Skipping Audio Mode region "${region.name}" (stays fixed)`);
+                }
+                // AudioTime regions stay fixed (do nothing)
+            });
+        });
+        console.log(`[Session.setTempo] Emitting tempoChanged signal with bpm=${bpm}`);
+        this.tempoChanged.emit(bpm);
+    }
+    setTimeSignature(numerator, denominator) {
+        if (numerator > 0 && denominator > 0) {
+            this.timeSignature = [numerator, denominator];
+            this.gridSettings.setTimeSignature(numerator, denominator);
+            this.timeSignatureChanged.emit(this.timeSignature);
+        }
+    }
+    startTransport() {
+        this.transportFSM.enqueue({ type: 'StartTransport' });
+        // Sync legacy flag so existing AudioEngine / UI code still works.
+        this.isPlaying = true;
+    }
+    stopTransport() {
+        this.transportFSM.enqueue({ type: 'StopTransport' });
+        // For rapid stop (no declick in domain layer), complete immediately.
+        // The audio backend handles its own declick ramp-down independently.
+        this.transportFSM.enqueue({ type: 'DeclickDone' });
+        this.isPlaying = false;
+        this.transportFrame = 0;
+        this.transportPositionChanged.emit(0);
+    }
+    locateTransport(frame) {
+        this.transportFrame = frame;
+        this.transportPositionChanged.emit(frame);
+    }
+    /**
+     * Locate via the FSM with proper declick handling.
+     * Use this when you want declick-aware relocation (e.g. from the timeline ruler).
+     *
+     * @param frame Target frame position.
+     * @param rollAfterLocate Whether to resume playback after the locate completes.
+     */
+    locateTransportViaFSM(frame, rollAfterLocate = false) {
+        this.transportFSM.enqueue({
+            type: 'Locate',
+            target: frame,
+            rollAfterLocate,
+        });
+    }
+    /**
+     * Get the current playback speed from the transport FSM.
+     * Positive = forward, negative = reverse.
+     * Range: -8.0 to +8.0 (absolute minimum 0.0625 when non-zero).
+     */
+    getSpeed() {
+        return this.transportFSM.getSpeed();
+    }
+    /**
+     * Set the playback speed via the transport FSM.
+     * If the sign changes while rolling, the FSM will handle
+     * the declick and direction reversal automatically.
+     *
+     * @param speed Desired speed. Negative = reverse. Range: -8.0 to +8.0.
+     */
+    setSpeed(speed) {
+        this.transportFSM.setSpeed(speed);
+    }
+    startRecording() {
+        this.isRecording = true;
+        this.recordingStartFrame = this.transportFrame;
+        this.recordingChanged.emit(true);
+        this.startTransport();
+    }
+    stopRecording() {
+        this.isRecording = false;
+        this.recordingChanged.emit(false);
+        this.stopTransport(); // Usually stop recording stops transport too, or independent? standard DAW behavior is stop both.
+    }
+    // Metronome
+    toggleMetronome() {
+        this.metronomeEnabled = !this.metronomeEnabled;
+        this.metronomeChanged.emit(this.metronomeEnabled);
+    }
+    setMetronomeVolume(volume) {
+        this.metronomeVolume = Math.max(0, Math.min(1, volume));
+        this.metronomeVolumeChanged.emit(this.metronomeVolume);
+    }
+    addSource(source) {
+        if (!this._sources.has(source.id)) {
+            this._sources.set(source.id, source);
+            this.sourceAdded.emit(source);
+        }
+    }
+    removeSource(id) {
+        if (this._sources.has(id)) {
+            this._sources.delete(id);
+            // emit sourceRemoved?
+        }
+    }
+    getSource(id) {
+        return this._sources.get(id);
+    }
+    get sources() {
+        return this._sources;
+    }
+    getIO(id) {
+        // Check Master Bus
+        if (this.masterBus.input.id === id)
+            return this.masterBus.input;
+        if (this.masterBus.output.id === id)
+            return this.masterBus.output;
+        // Check Tracks
+        for (const track of this._tracks.values()) {
+            if (track.route.input.id === id)
+                return track.route.input;
+            if (track.route.output.id === id)
+                return track.route.output;
+        }
+        return undefined;
+    }
+    getExportConfig() {
+        if (!this._exportConfig) {
+            this._exportConfig = new ExportConfig();
+            this._exportConfig.sampleRate = this.sampleRate;
+        }
+        return this._exportConfig;
+    }
+    getExportStatus() {
+        if (!this._exportStatus) {
+            this._exportStatus = new ExportStatus();
+        }
+        return this._exportStatus;
+    }
+    getSessionDuration() {
+        let maxEnd = 0;
+        this.tracks.forEach(track => {
+            track.playlist.getRegions().forEach(region => {
+                maxEnd = Math.max(maxEnd, region.end);
+            });
+            track.playlist.getMidiRegions().forEach(midiRegion => {
+                maxEnd = Math.max(maxEnd, midiRegion.end);
+            });
+        });
+        return maxEnd;
+    }
+    // Region Selection
+    selectRegion(regionId, addToSelection = false) {
+        if (!addToSelection) {
+            this._selectedRegionIds.clear();
+        }
+        this._selectedRegionIds.add(regionId);
+        this.selectionChanged.emit(new Set(this._selectedRegionIds));
+    }
+    selectRegions(regionIds, addToSelection = false) {
+        if (!addToSelection) {
+            this._selectedRegionIds.clear();
+        }
+        for (const id of regionIds) {
+            this._selectedRegionIds.add(id);
+        }
+        this.selectionChanged.emit(new Set(this._selectedRegionIds));
+    }
+    deselectRegion(regionId) {
+        this._selectedRegionIds.delete(regionId);
+        this.selectionChanged.emit(new Set(this._selectedRegionIds));
+    }
+    clearSelection() {
+        this._selectedRegionIds.clear();
+        this.selectionChanged.emit(new Set(this._selectedRegionIds));
+    }
+    getSelectedRegionIds() {
+        return this._selectedRegionIds;
+    }
+    isRegionSelected(regionId) {
+        return this._selectedRegionIds.has(regionId);
+    }
+    // ─── Send Bus Management ──────────────────────────────────────────────────
+    addSendBus(sourceTrackId, destId, level = 0, preFader = false, id) {
+        const sendBusId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const sendBus = new SendBus(sendBusId, sourceTrackId, destId, level, preFader);
+        this._sendBuses.set(sendBusId, sendBus);
+        this.sendBusAdded.emit(sendBus);
+        return sendBus;
+    }
+    removeSendBus(sendBusId) {
+        if (this._sendBuses.has(sendBusId)) {
+            this._sendBuses.delete(sendBusId);
+            this.sendBusRemoved.emit(sendBusId);
+        }
+    }
+    getSendBus(sendBusId) {
+        return this._sendBuses.get(sendBusId);
+    }
+    getSendBusesForTrack(sourceTrackId) {
+        return Array.from(this._sendBuses.values()).filter((sendBus) => sendBus.sourceTrackId === sourceTrackId);
+    }
+    get sendBuses() {
+        return Array.from(this._sendBuses.values());
+    }
+    // ─── Marker Management ─────────────────────────────────────────────────────
+    addMarker(name, position, color, id) {
+        const markerId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const marker = new Marker(markerId, name, position, color);
+        this._markers.set(markerId, marker);
+        // Subscribe to marker changes
+        marker.changed.connect(() => {
+            this.markerChanged.emit(marker);
+        });
+        this.markerAdded.emit(marker);
+        return marker;
+    }
+    removeMarker(markerId) {
+        const marker = this._markers.get(markerId);
+        if (marker) {
+            marker.removed.emit();
+            this._markers.delete(markerId);
+            this.markerRemoved.emit(markerId);
+        }
+    }
+    getMarker(markerId) {
+        return this._markers.get(markerId);
+    }
+    get markers() {
+        return Array.from(this._markers.values()).sort((a, b) => a.position - b.position);
+    }
+    /**
+     * Find the next marker after the given position.
+     */
+    getNextMarker(position) {
+        const sorted = this.markers;
+        return sorted.find(m => m.position > position);
+    }
+    /**
+     * Find the previous marker before the given position.
+     */
+    getPreviousMarker(position) {
+        const sorted = this.markers;
+        for (let i = sorted.length - 1; i >= 0; i--) {
+            if (sorted[i].position < position)
+                return sorted[i];
+        }
+        return undefined;
+    }
+    // ─── Track Reorder ────────────────────────────────────────────────────────
+    reorderTrack(trackId, newIndex) {
+        const trackEntries = Array.from(this._tracks.entries());
+        const currentIndex = trackEntries.findIndex(([id]) => id === trackId);
+        if (currentIndex === -1) {
+            throw new Error(`Track not found: ${trackId}`);
+        }
+        if (newIndex < 0)
+            newIndex = 0;
+        if (newIndex >= trackEntries.length)
+            newIndex = trackEntries.length - 1;
+        if (currentIndex === newIndex)
+            return;
+        const [entry] = trackEntries.splice(currentIndex, 1);
+        trackEntries.splice(newIndex, 0, entry);
+        this._tracks.clear();
+        for (const [id, track] of trackEntries) {
+            this._tracks.set(id, track);
+        }
+        this.trackReordered.emit({ trackId, newIndex });
+    }
+    getTrackIndex(trackId) {
+        const keys = Array.from(this._tracks.keys());
+        return keys.indexOf(trackId);
+    }
+    // ─── Ripple Edit ──────────────────────────────────────────────────────────
+    setRippleEdit(enabled) {
+        if (this.rippleEdit === enabled)
+            return;
+        this.rippleEdit = enabled;
+        this.rippleEditChanged.emit(enabled);
+    }
+    // ─── Region Grouping ────────────────────────────────────────────────────
+    groupRegions(regionIds, name, id) {
+        const groupId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const groupName = name !== null && name !== void 0 ? name : `Group ${this._regionGroups.size + 1}`;
+        const group = new RegionGroup(groupId, groupName, regionIds);
+        this._regionGroups.set(groupId, group);
+        this.regionGroupAdded.emit(group);
+        return groupId;
+    }
+    ungroupRegions(groupId) {
+        const group = this._regionGroups.get(groupId);
+        if (group) {
+            this._regionGroups.delete(groupId);
+            this.regionGroupRemoved.emit(groupId);
+        }
+    }
+    getRegionGroup(groupId) {
+        return this._regionGroups.get(groupId);
+    }
+    getRegionGroupForRegion(regionId) {
+        for (const group of this._regionGroups.values()) {
+            if (group.hasRegion(regionId))
+                return group;
+        }
+        return undefined;
+    }
+    get regionGroups() {
+        return Array.from(this._regionGroups.values());
+    }
+    // ─── Track Groups ────────────────────────────────────────────────────────
+    addTrackGroup(name, id) {
+        const groupId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const group = new TrackGroup(groupId, name);
+        this._trackGroups.set(groupId, group);
+        this.trackGroupAdded.emit(group);
+        return group;
+    }
+    removeTrackGroup(groupId) {
+        const group = this._trackGroups.get(groupId);
+        if (group) {
+            // Clear groupId on member tracks
+            for (const trackId of group.memberTrackIds) {
+                const track = this.getTrack(trackId);
+                if (track)
+                    track.groupId = null;
+            }
+            this._trackGroups.delete(groupId);
+            this.trackGroupRemoved.emit(groupId);
+        }
+    }
+    getTrackGroup(groupId) {
+        return this._trackGroups.get(groupId);
+    }
+    getTrackGroupForTrack(trackId) {
+        for (const group of this._trackGroups.values()) {
+            if (group.hasMember(trackId))
+                return group;
+        }
+        return undefined;
+    }
+    get trackGroups() {
+        return Array.from(this._trackGroups.values());
+    }
+    // ─── Folder Track Helpers ────────────────────────────────────────────────
+    getChildTracks(parentId) {
+        return this.tracks.filter(t => t.parentTrackId === parentId);
+    }
+    setTrackParent(trackId, parentId) {
+        const track = this.getTrack(trackId);
+        if (track) {
+            track.parentTrackId = parentId;
+        }
+    }
+    // ─── VCA Tracks ──────────────────────────────────────────────────────────
+    addVCATrack(name, id) {
+        const vcaId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const vca = new VCATrack(vcaId, name);
+        this._vcaTracks.set(vcaId, vca);
+        this.vcaTrackAdded.emit(vca);
+        return vca;
+    }
+    removeVCATrack(vcaId) {
+        if (this._vcaTracks.has(vcaId)) {
+            this._vcaTracks.delete(vcaId);
+            this.vcaTrackRemoved.emit(vcaId);
+        }
+    }
+    getVCATrack(vcaId) {
+        return this._vcaTracks.get(vcaId);
+    }
+    get vcaTracks() {
+        return Array.from(this._vcaTracks.values());
+    }
+    // ─── Sidechain Configs ──────────────────────────────────────────────────
+    addSidechainConfig(targetTrackId, targetProcessorId, id) {
+        const configId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const config = new SidechainConfig(configId, targetTrackId, targetProcessorId);
+        this._sidechainConfigs.set(configId, config);
+        return config;
+    }
+    removeSidechainConfig(configId) {
+        this._sidechainConfigs.delete(configId);
+    }
+    getSidechainConfig(configId) {
+        return this._sidechainConfigs.get(configId);
+    }
+    getSidechainConfigsForTrack(trackId) {
+        return Array.from(this._sidechainConfigs.values()).filter(c => c.targetTrackId === trackId);
+    }
+    // ─── Take Lanes ─────────────────────────────────────────────────────────
+    addTakeLane(trackId, id) {
+        const laneId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const lane = new TakeLane(laneId, trackId);
+        this._takeLanes.set(laneId, lane);
+        return lane;
+    }
+    removeTakeLane(laneId) {
+        this._takeLanes.delete(laneId);
+    }
+    getTakeLane(laneId) {
+        return this._takeLanes.get(laneId);
+    }
+    getTakeLanesForTrack(trackId) {
+        return Array.from(this._takeLanes.values()).filter(l => l.trackId === trackId);
+    }
+    // ─── CD Markers ─────────────────────────────────────────────────────────
+    addCDMarker(index, title, position, performer, isrc, id) {
+        const markerId = id !== null && id !== void 0 ? id : crypto.randomUUID();
+        const marker = new CDMarker(markerId, index, title, position, performer, isrc);
+        this._cdMarkers.set(markerId, marker);
+        this.cdMarkerAdded.emit(marker);
+        return marker;
+    }
+    removeCDMarker(markerId) {
+        if (this._cdMarkers.has(markerId)) {
+            this._cdMarkers.delete(markerId);
+            this.cdMarkerRemoved.emit(markerId);
+        }
+    }
+    getCDMarker(markerId) {
+        return this._cdMarkers.get(markerId);
+    }
+    get cdMarkers() {
+        return Array.from(this._cdMarkers.values()).sort((a, b) => a.index - b.index);
+    }
+    // ─── Serialization ────────────────────────────────────────────────────────
+    /**
+     * 세션 전체 상태를 JSON-직렬화 가능한 객체로 변환합니다.
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            name: this.name,
+            sampleRate: this.sampleRate,
+            tempo: this.tempo,
+            timeSignature: this.timeSignature,
+            transportFrame: this.transportFrame,
+            tracks: this.tracks.map(t => ({
+                id: t.id,
+                name: t.name,
+                type: t.type,
+                armed: t.armed,
+                mute: t.mute,
+                solo: t.solo,
+                color: t.color,
+                soloIsolate: t.soloIsolate,
+                soloSafe: t.soloSafe,
+                monitorMode: t.monitorMode,
+                trimGain: t.trimGain,
+                comment: t.comment,
+                regions: t.playlist.getRegions().map(r => ({
+                    id: r.id,
+                    sourceId: r.sourceId,
+                    name: r.name,
+                    start: r.start,
+                    length: r.length,
+                    sourceStart: r.sourceStart,
+                    gain: r.gain,
+                    muted: r.muted,
+                    layer: r.layer,
+                    fadeIn: r.fadeIn,
+                    fadeOut: r.fadeOut,
+                    playbackRate: r.playbackRate,
+                    timeDomain: r.timeDomain,
+                    locked: r.locked,
+                })),
+                midiRegions: t.playlist.getMidiRegions().map(mr => mr.toJSON()),
+            })),
+            ranges: Array.from(this._ranges.values()).map(r => ({
+                id: r.id,
+                name: r.name,
+                start: r.start,
+                end: r.end,
+            })),
+            sendBuses: Array.from(this._sendBuses.values()).map(sb => ({
+                id: sb.id,
+                sourceTrackId: sb.sourceTrackId,
+                destId: sb.destId,
+                level: sb.level,
+                preFader: sb.preFader,
+                active: sb.active,
+            })),
+            markers: Array.from(this._markers.values()).map(m => ({
+                id: m.id,
+                name: m.name,
+                position: m.position,
+                color: m.color,
+                locked: m.locked,
+            })),
+            loopRangeId: this.loopRangeId,
+            loopEnabled: this.loopEnabled,
+            punchRangeId: this.punchRangeId,
+            punchEnabled: this.punchEnabled,
+            preRollBars: this.preRollBars,
+            loopRecordingEnabled: this.loopRecordingEnabled,
+            rippleEdit: this.rippleEdit,
+            regionGroups: Array.from(this._regionGroups.values()).map(g => ({
+                id: g.id,
+                name: g.name,
+                regionIds: g.getRegionIds(),
+            })),
+            tempoMapEvents: this.tempoMap.getAllEvents().map(e => ({
+                frame: e.frame,
+                bpm: e.bpm,
+                timeSigNum: e.timeSigNum,
+                timeSigDen: e.timeSigDen,
+            })),
+            mixerScenes: this.mixerSceneManager.toJSON(),
+            trackGroups2: Array.from(this._trackGroups.values()).map(g => g.toJSON()),
+            cdMarkers: Array.from(this._cdMarkers.values()).map(m => m.toJSON()),
+            vcaTracks: Array.from(this._vcaTracks.values()).map(v => v.toJSON()),
+            sidechainConfigs: Array.from(this._sidechainConfigs.values()).map(c => c.toJSON()),
+            takeLanes: Array.from(this._takeLanes.values()).map(lane => ({
+                id: lane.id,
+                trackId: lane.trackId,
+                takes: lane.takes.map(t => t.toJSON()),
+            })),
+        };
+    }
+    /**
+     * JSON 스냅샷으로부터 Session을 복원합니다.
+     * 트랙, 리전, Range, SendBus를 복원하지만 Signal 연결(AudioEngine)은 별도로 처리해야 합니다.
+     */
+    static fromJSON(snapshot) {
+        var _a, _b, _c, _d;
+        const session = new Session(snapshot.name, snapshot.id, snapshot.sampleRate);
+        session.tempo = snapshot.tempo;
+        session.timeSignature = snapshot.timeSignature;
+        session.transportFrame = snapshot.transportFrame;
+        // Restore Tracks + Regions
+        for (const trackData of snapshot.tracks) {
+            const track = session.addTrack(trackData.name, trackData.type, trackData.id);
+            track.armed = trackData.armed;
+            track.mute = trackData.mute;
+            track.solo = trackData.solo;
+            if (trackData.color)
+                track.color = trackData.color;
+            if (trackData.soloIsolate)
+                track.setSoloIsolate(trackData.soloIsolate);
+            if (trackData.soloSafe)
+                track.setSoloSafe(trackData.soloSafe);
+            if (trackData.monitorMode)
+                track.setMonitorMode(trackData.monitorMode);
+            if (trackData.trimGain !== undefined)
+                track.setTrimGain(trackData.trimGain);
+            if (trackData.comment !== undefined)
+                track.comment = trackData.comment;
+            for (const regionData of trackData.regions) {
+                const region = new Region(regionData.id, regionData.sourceId, regionData.start, regionData.length, regionData.sourceStart, regionData.name, regionData.layer);
+                region.gain = regionData.gain;
+                region.muted = regionData.muted;
+                region.fadeIn = regionData.fadeIn;
+                region.fadeOut = regionData.fadeOut;
+                region.playbackRate = regionData.playbackRate;
+                region.timeDomain = regionData.timeDomain;
+                if (regionData.locked)
+                    region.locked = regionData.locked;
+                track.playlist.addRegion(region);
+            }
+            // Restore MIDI Regions
+            if (trackData.midiRegions) {
+                for (const midiRegionData of trackData.midiRegions) {
+                    const midiRegion = MidiRegion.fromJSON(midiRegionData);
+                    track.playlist.addMidiRegion(midiRegion);
+                }
+            }
+        }
+        // Restore Ranges
+        for (const rangeData of snapshot.ranges) {
+            const range = new Range(rangeData.id, rangeData.name, rangeData.start, rangeData.end);
+            session._ranges.set(range.id, range);
+        }
+        // Restore SendBuses (no signal emission – backend will sync via re-add on session load)
+        for (const sbData of snapshot.sendBuses) {
+            const sb = new SendBus(sbData.id, sbData.sourceTrackId, sbData.destId, sbData.level, sbData.preFader);
+            session._sendBuses.set(sb.id, sb);
+        }
+        // Restore Markers
+        if (snapshot.markers) {
+            for (const markerData of snapshot.markers) {
+                const marker = new Marker(markerData.id, markerData.name, markerData.position, markerData.color, markerData.locked);
+                session._markers.set(marker.id, marker);
+            }
+        }
+        session.loopRangeId = snapshot.loopRangeId;
+        session.loopEnabled = snapshot.loopEnabled;
+        session.punchRangeId = snapshot.punchRangeId;
+        session.punchEnabled = (_a = snapshot.punchEnabled) !== null && _a !== void 0 ? _a : false;
+        session.preRollBars = (_b = snapshot.preRollBars) !== null && _b !== void 0 ? _b : 0;
+        session.loopRecordingEnabled = (_c = snapshot.loopRecordingEnabled) !== null && _c !== void 0 ? _c : false;
+        session.rippleEdit = (_d = snapshot.rippleEdit) !== null && _d !== void 0 ? _d : false;
+        // Restore Region Groups
+        if (snapshot.regionGroups) {
+            for (const groupData of snapshot.regionGroups) {
+                const group = new RegionGroup(groupData.id, groupData.name, groupData.regionIds);
+                session._regionGroups.set(group.id, group);
+            }
+        }
+        // Restore Tempo Map Events
+        if (snapshot.tempoMapEvents) {
+            for (const eventData of snapshot.tempoMapEvents) {
+                session.tempoMap.addTempoChange(eventData.frame, eventData.bpm, eventData.timeSigNum, eventData.timeSigDen);
+            }
+        }
+        // Restore Mixer Scenes
+        if (snapshot.mixerScenes) {
+            session.mixerSceneManager.loadFromJSON(snapshot.mixerScenes);
+        }
+        // Restore Track Groups (Phase 10)
+        if (snapshot.trackGroups2) {
+            for (const groupData of snapshot.trackGroups2) {
+                const group = TrackGroup.fromJSON(groupData);
+                session._trackGroups.set(group.id, group);
+            }
+        }
+        // Restore CD Markers (Phase 12)
+        if (snapshot.cdMarkers) {
+            for (const markerData of snapshot.cdMarkers) {
+                const cdMarker = CDMarker.fromJSON(markerData);
+                session._cdMarkers.set(cdMarker.id, cdMarker);
+            }
+        }
+        // Restore VCA Tracks (Phase 10-4)
+        if (snapshot.vcaTracks) {
+            for (const vcaData of snapshot.vcaTracks) {
+                const vca = VCATrack.fromJSON(vcaData);
+                session._vcaTracks.set(vca.id, vca);
+            }
+        }
+        // Restore Sidechain Configs (Phase 12-3)
+        if (snapshot.sidechainConfigs) {
+            for (const scData of snapshot.sidechainConfigs) {
+                const config = SidechainConfig.fromJSON(scData);
+                session._sidechainConfigs.set(config.id, config);
+            }
+        }
+        // Restore Take Lanes (Phase 9-4)
+        if (snapshot.takeLanes) {
+            for (const laneData of snapshot.takeLanes) {
+                const lane = new TakeLane(laneData.id, laneData.trackId);
+                for (const takeData of laneData.takes) {
+                    const take = Take.fromJSON(takeData);
+                    lane.addTake(take);
+                }
+                session._takeLanes.set(lane.id, lane);
+            }
+        }
+        return session;
+    }
+}
+//# sourceMappingURL=Session.js.map