@kano/stem-daw 0.1.0

package/dist/daw-controller-BjRWcTol.d.ts

@@ -0,0 +1,339 @@
+import { D as DAWTrack, ab as StemEffectChain, ac as StemEffects, P as PitchEngineSettings, c as StemSelectionRange } from './interfaces-5ZlG0Y4Y.js';
+import { I as ITrackForSequence } from './interface-DaRj7RkY.js';
+
+/**
+ * Minimal browser-compatible EventEmitter replacement.
+ * Avoids importing Node.js "events" module which Vite externalises.
+ */
+type Listener = (...args: any[]) => void;
+declare class BrowserEventEmitter {
+    private _listeners;
+    on(event: string, listener: Listener): this;
+    off(event: string, listener: Listener): this;
+    once(event: string, listener: Listener): this;
+    emit(event: string, ...args: any[]): boolean;
+    removeAllListeners(event?: string): this;
+}
+
+/**
+ * DAWTrackLoader – Downloads a full fMP4 file and decodes all 4 stems
+ * into separate AudioBuffers for offline/DAW-style manipulation.
+ *
+ * This intentionally avoids the streaming AudioSourceSequence pipeline.
+ * The trade-off is a longer initial load, but after that every stem is
+ * instantly accessible at any sample position.
+ */
+
+interface StemAudioBuffers {
+    other: AudioBuffer;
+    vocals: AudioBuffer;
+    bass: AudioBuffer;
+    drums: AudioBuffer;
+}
+type LoadProgress = {
+    phase: 'fetching' | 'parsing' | 'decoding';
+    percent: number;
+    detail?: string;
+};
+/**
+ * Download an fMP4 track and decode each stem into a standalone AudioBuffer.
+ */
+declare function loadTrackStems(mp4Url: string, onProgress?: (p: LoadProgress) => void): Promise<StemAudioBuffers>;
+
+declare class DAWController extends BrowserEventEmitter {
+    private ctx;
+    private masterGain;
+    private tracks;
+    /** URL → shared decode entry. See `SourceCacheEntry`. */
+    private sourceCache;
+    private isInitialised;
+    private _pitchWorkletAvailable;
+    private _playing;
+    private _playStartCtxTime;
+    private _playStartOffset;
+    private playheadAnimationId;
+    private _seekGen;
+    /**
+     * Max number of tracks allowed to hold their decoded PCM concurrently.
+     * Beyond this we evict LRU tracks via `dumpTrackAudio`. See
+     * `DEFAULT_MAX_DECODED_TRACKS` for the rationale.
+     */
+    private _maxDecodedTracks;
+    private _stemActive;
+    private _metronomeOn;
+    private _metronomeDownbeatOnly;
+    private _metronomeGain;
+    private _metronomeScheduleId;
+    private _metronomeNextBeat;
+    private _cpuPollId;
+    private _cpuUsage;
+    private _nativeModeTrackId;
+    private _nativeModeOriginalBarMap;
+    /** Native-time offset (samples) at the moment play/seek was last called in native mode */
+    private _nativeStartSample;
+    private static instance;
+    static getInstance(): DAWController;
+    private constructor();
+    init(): Promise<void>;
+    isReady(): boolean;
+    /**
+     * Resolve when the named track's audio has fully decoded. If the
+     * decode is already complete (common with the source-cache when
+     * multiple clips share one source), resolve immediately on the next
+     * microtask. Rejects if the track is removed or no such track exists.
+     *
+     * Use this instead of `controller.on('trackLoaded', …)` from
+     * importers / batch loaders — the event fires once and a late
+     * subscriber would miss it. This helper closes that race.
+     */
+    whenTrackLoaded(trackId: string): Promise<void>;
+    getAudioContext(): AudioContext;
+    getMasterGainNode(): GainNode;
+    addTrack(trackData: ITrackForSequence, onProgress?: (p: LoadProgress) => void): Promise<DAWTrack | null>;
+    /**
+     * Read the current cap. See `DEFAULT_MAX_DECODED_TRACKS` for context.
+     */
+    get maxDecodedTracks(): number;
+    /**
+     * Update the soft cap on simultaneously-decoded tracks. If the new cap
+     * is lower than the current decoded count, the surplus LRU tracks are
+     * dumped immediately.
+     */
+    setMaxDecodedTracks(n: number): void;
+    /** Tracks currently holding their decoded PCM in memory. */
+    private decodedTrackCount;
+    /** True if the named track is currently audible (playing into its range). */
+    private isTrackAudible;
+    /**
+     * Free PCM from the least-recently-used undumped tracks until at most
+     * `keep` tracks remain decoded. Audible tracks (containing the playhead)
+     * and currently-transitioning tracks are excluded from eviction so
+     * playback never goes silent unexpectedly.
+     */
+    private evictLRUDecodedTracks;
+    /**
+     * Release the decoded PCM held by a track to free memory without
+     * removing the track from the timeline. The worklets, gains, and
+     * effect chain stay wired so rehydration is a single message away.
+     *
+     *   - Worklet stem buffers: `dump-buffer` clears the Float32Arrays.
+     *   - Main-thread mirror (`rt.stems`): replaced with 1-sample silent
+     *     AudioBuffers so legacy consumers (BarSampler, paste-audio) don't
+     *     null-deref. Re-allocated to full length on rehydrate.
+     *   - Waveform mipmaps: cleared so the timeline shows a flat
+     *     centerline until the track is rehydrated.
+     *   - In-flight decode: aborted (refcount on shared source decremented).
+     */
+    dumpTrackAudio(trackId: string): void;
+    /**
+     * Re-decode a previously-dumped track from IndexedDB (the encoded fMP4
+     * stays cached even after dump). Reuses the existing worklet/audio
+     * graph — no node recreation — so rehydration is just a fresh
+     * progressive decode that streams patches back into the same
+     * worklets and mipmap cache.
+     *
+     * Returns true once `loadHandle.playable` resolves (enough audio for
+     * playback to start). Background batches continue filling the buffer.
+     */
+    rehydrateTrackAudio(trackId: string): Promise<boolean>;
+    /** True if a track's decoded PCM has been freed. */
+    isTrackDumped(trackId: string): boolean;
+    removeTrack(trackId: string): void;
+    getStemBuffers(trackId: string): StemAudioBuffers | undefined;
+    getStemEffectChain(trackId: string, stemIndex: number): StemEffectChain | null;
+    updateStemEffects(trackId: string, stemIndex: number, fx: StemEffects): void;
+    /**
+     * Compute the native buffer sample position for a stem at a given
+     * global timeline bar, using the track's barMapping for precision.
+     *
+     * Returns null if the stem is outside its active region.
+     */
+    private computeStemSeekSamples;
+    play(): Promise<void>;
+    pause(): void;
+    stop(): void;
+    seekToBar(bar: number): Promise<void>;
+    setMasterTempo(bpm: number): void;
+    /**
+     * Reorder a track and, if it becomes the new first track, promote it as master.
+     * Handles worklet bar map / pitch resync the same way setMasterTempo does.
+     */
+    reorderTrack(trackId: string, newIndex: number): void;
+    setGlobalPlaybackRate(rate: number): void;
+    private broadcastGlobalRate;
+    syncGainsForTrack(trackId: string): void;
+    syncAllGains(): void;
+    /** Send mute regions for a specific stem to its worklet (bar-based → sample-based) */
+    syncMuteRegions(trackId: string, stemIndex: number): void;
+    /** Sync mute regions for all stems of a track */
+    syncAllMuteRegionsForTrack(trackId: string): void;
+    /**
+     * Rebuild and re-send the bar map for a track to all its stem worklets.
+     * Call after the track's barMapping has been modified (e.g. beat grid nudge).
+     */
+    reloadTrackBarMap(trackId: string): void;
+    /**
+     * Enable or disable native playback for a track. When enabled, the track
+     * plays at its original recorded tempo (speed = 1.0 for every bar) with no
+     * pitch compensation. This allows the Beat Lab to display beat markers at
+     * their true sample positions and have them match the audible audio exactly.
+     */
+    setNativePlaybackMode(trackId: string, enabled: boolean): void;
+    isNativePlaybackMode(): boolean;
+    get nativeModeTrackId(): string | null;
+    /**
+     * Get the current playback position in native (unquantized) seconds.
+     * Only meaningful when native playback mode is active.
+     */
+    getNativePositionSec(): number;
+    /**
+     * Seek to a native sample position (used by beat lab scrubbing).
+     * Only works when native playback mode is active.
+     */
+    seekToNativeSample(sample: number): void;
+    /**
+     * Send the combined pitch factor (correction + transpose) to a track's pitch worklet.
+     * When perBarPitchCompensation is enabled, the per-bar correction is added on top
+     * via updatePerBarPitch() during playback — this method sends the base correction.
+     */
+    syncPitchForTrack(trackId: string): void;
+    /**
+     * Check if we've crossed a bar boundary and send an updated pitch factor
+     * that includes the per-bar pitch compensation for that specific bar.
+     */
+    /**
+     * rAF-driven per-bar pitch update (fallback for seeks / playback start).
+     * handleWorkletBarChange is the primary path — this catches missed bars.
+     */
+    private updatePerBarPitch;
+    /** One-shot pitch send for play/seek — sends the bar's pitch and sets
+     *  lastPitchStr so the rAF path won't duplicate it. */
+    private sendInitialBarPitch;
+    /** Set user transpose in semitones and update the worklet. */
+    setTrackTranspose(trackId: string, semitones: number): void;
+    /** Toggle per-bar pitch compensation for a track. */
+    setPerBarPitchCompensation(trackId: string, enabled: boolean): void;
+    /**
+     * Send the per-bar pitch map to the first stem worklet so it can apply a
+     * short crossfade at bar boundaries to mask the ~3ms gap between the
+     * speed change (instant, audio-thread) and the pitch change (next render quantum).
+     * Also sends the pitch map so the worklet can forward pitch commands to
+     * Rubberband via the main thread at the exact bar crossing moment.
+     */
+    private syncWorkletPitchMap;
+    /** Update rubberband settings for a track. Requires worklet recreation. */
+    setTrackPitchSettings(trackId: string, settings: PitchEngineSettings): void;
+    /**
+     * Apply an autotune pitch offset on top of the current pitch chain.
+     * Called from the autotune panel at ~60fps during playback.
+     * Set autoSemitones=0 to clear the override.
+     */
+    applyAutotuneCorrection(trackId: string, autoSemitones: number): void;
+    /** Send a pitch factor to the Rubberband pitch worklet. */
+    private sendPitchToWorklet;
+    /**
+     * Configure a Rubberband pitch worklet via port messages.
+     * The worklet ignores processorOptions — all config must be sent as messages.
+     *
+     * pitchDelayMs controls how many ms the worklet waits after receiving a pitch
+     * command before applying it to Rubberband. This is the single control for
+     * aligning speed changes (instant) with pitch changes (delayed by FFT pipeline).
+     */
+    private configurePitchWorklet;
+    get pitchWorkletAvailable(): boolean;
+    get audioContext(): AudioContext | null;
+    /** Get the total semitones currently being applied to a track's pitch worklet. */
+    getCurrentPitchSemitones(trackId: string): number;
+    /**
+     * Get the pitch artifact (semitones) that the current bar's speed change introduces.
+     * This is the inverse of the compensation: if speed > 1, pitch goes up, etc.
+     * Returns 0 if per-bar compensation isn't active or no bar is current.
+     */
+    getCurrentSpeedPitchArtifact(trackId: string): number;
+    /** Update pitchDelayMs for a track and push it to the Rubberband worklet immediately. */
+    setTrackPitchDelay(trackId: string, ms: number): void;
+    /** Change bar subdivision and reload all bar maps + pitch maps. */
+    setBarSubdivisions(n: number): void;
+    /** Start polling AudioContext render capacity (if supported). */
+    startCpuMonitor(intervalMs?: number): void;
+    stopCpuMonitor(): void;
+    get cpuUsage(): number;
+    private startPlayheadAnimation;
+    /**
+     * Authoritative pitch update from the worklet's bar-changed message.
+     * Fires at audio-thread timing. The worklet's internal pitchDelayMs
+     * handles the alignment between speed (instant) and pitch (delayed).
+     */
+    private handleWorkletBarChange;
+    /** Update per-bar pitch compensation for all tracks that have it enabled. */
+    private updateAllPerBarPitch;
+    /** Start/stop individual stem worklets as the playhead crosses their timeline boundaries */
+    private updateStemPlayState;
+    private stopPlayheadAnimation;
+    private getCurrentPositionSec;
+    barToSeconds(bar: number): number;
+    secondsToBar(sec: number): number;
+    get metronomeEnabled(): boolean;
+    get metronomeVolume(): number;
+    get metronomeDownbeatOnly(): boolean;
+    setMetronomeDownbeatOnly(downbeatOnly: boolean): void;
+    toggleMetronome(on?: boolean): void;
+    setMetronomeVolume(volume: number): void;
+    private startMetronomeScheduler;
+    private stopMetronomeScheduler;
+    private scheduleMetronomeClicks;
+    private playClick;
+    /**
+     * Copy audio samples from one bar range and overwrite another bar range
+     * inside a track's stem buffers. Source and destination stems may be the
+     * same (default) or different stems on the same track. After writing, the
+     * modified destination buffer is sent to the worklet so playback reflects
+     * the change immediately.
+     *
+     * Both `sourceStart/End` and `targetStartBar` are in local bars (relative
+     * to the track's barMapping, not the global timeline).
+     *
+     * `targetStemIndex` defaults to `stemIndex` (source) for backwards-compatible
+     * same-stem behaviour.
+     */
+    pasteAudioRegion(trackId: string, stemIndex: number, sourceStartBar: number, sourceEndBar: number, targetStartBar: number, targetStemIndex?: number): void;
+    /**
+     * Copy each selection's bar range into the clipboard. No mutation of
+     * the audio buffers — just snapshots the source bar ranges. No undo step
+     * (copy is non-destructive).
+     */
+    copySelections(selections: StemSelectionRange[]): void;
+    /**
+     * Mute (silence) each selection's bar range. Single undo step covers all
+     * ranges. After muting, clears the selection set.
+     */
+    muteSelections(selections: StemSelectionRange[]): void;
+    /**
+     * Cut: copy each selection's bar range to clipboard AND mute it. Single
+     * undo step. Clears the selection set after.
+     */
+    cutSelections(selections: StemSelectionRange[]): void;
+    /**
+     * Paste the current clipboard at a global timeline bar. Each clipboard
+     * entry pastes into its own stemIndex on the focused track. Cross-track
+     * paste is supported as same-stemIndex-different-track when the source
+     * track no longer exists.
+     *
+     * For a SINGLE-entry clipboard, the optional `targetStemIndex` allows
+     * cross-stem paste (e.g. paste bass clip into drums lane).
+     */
+    pasteClipboardAtBar(targetGlobalBar: number, targetTrackId: string, targetStemIndex?: number): void;
+    /**
+     * Duplicate each selection: copy its audio in-buffer to immediately after
+     * the selection end on the same stem. Single undo step.
+     */
+    duplicateSelections(selections: StemSelectionRange[]): void;
+    /**
+     * Insert a resampled AudioBuffer into a stem, replacing the specified bar range.
+     * Rebuilds the worklet buffer and bar map, and records the resampled region in the store.
+     */
+    insertResampledRegion(trackId: string, stemIndex: number, startBar: number, endBar: number, resampledBuffer: AudioBuffer): void;
+    destroy(): void;
+}
+
+export { DAWController as D, type LoadProgress as L, type StemAudioBuffers as S, loadTrackStems as l };

package/dist/engine/daw-controller.d.ts

@@ -0,0 +1,3 @@
+import '../interfaces-5ZlG0Y4Y.js';
+export { D as DAWController } from '../daw-controller-BjRWcTol.js';
+import '../interface-DaRj7RkY.js';

package/dist/engine/daw-controller.js

@@ -0,0 +1,5 @@
+export { DAWController } from '../chunk-OYNES5W3.js';
+import '../chunk-TBXCZFAY.js';
+import '../chunk-KCOOE2OP.js';
+//# sourceMappingURL=daw-controller.js.map
+//# sourceMappingURL=daw-controller.js.map

package/dist/engine/daw-controller.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"daw-controller.js"}

package/dist/engine/daw-import-stem-fm-config.d.ts

@@ -0,0 +1,224 @@
+/**
+ * Import a stem.fm mix-config JSON into the DAW.
+ *
+ * The mix-config is a flat list of *sessions* — each one a "scene" on the
+ * master timeline of length `length.bars`. The model is:
+ *
+ *   • `trackChannels[]`  — which tracks are present in this scene (canonical).
+ *   • `originAnchors[]`  — parallel array; where each track starts in its
+ *                          source for this scene (originalBarIndex / sample).
+ *   • modifier events    — `volume` (per-stem), `rate`, `pitch`. They describe
+ *                          how the present tracks are *played* within the scene
+ *                          (per-bar tempo + pitch + per-stem volume automation).
+ *   • effect events      — `reverb` (and friends). Currently ignored —
+ *                          they don't affect clip placement, only sound.
+ *
+ * High-level mapping to the DAW (initial implementation):
+ *
+ *   ONE clip per (session, trackChannel) pair, length = session.length.bars,
+ *   source position = anchor.originalBarIndex.
+ *
+ *   Per-stem channel volume + mute regions are derived from the session's
+ *   volume events. A track that's "loaded but silent" (all volumes 0) still
+ *   gets a clip on the timeline — it just renders muted, ready to come alive
+ *   in a later session.
+ *
+ *   Rate/pitch automation within a session is collapsed: a single average
+ *   rate per clip and the first pitch event's value as a constant transpose.
+ *   This is the right trade-off until the DAW grows per-section variable
+ *   tempo + clip-level volume automation; until then a session imports as
+ *   a clean structural skeleton, and we layer the richer automation on top.
+ *
+ * Track ids are resolved once each via `fetchTrackForDAW` — a track that
+ * appears in many sessions is fetched once and the same `ITrackForSequence`
+ * is reused for every clip referencing it.
+ *
+ * Public entry point: `importStemFmMixConfig`.
+ */
+/** Stems live in this order in the DAW (0..3). Must match `STEM_TYPES` /
+ *  `STEM_LABELS` in `interfaces.ts`. */
+declare const STEM_NAMES: readonly ["other", "vocals", "bass", "drums"];
+type StemName = (typeof STEM_NAMES)[number];
+/** Modifier events shape clip playback (rate / pitch / per-stem volume).
+ *  Effect events (`reverb`, …) come as a separate `category: 'effect'`
+ *  shape — see `StemFmEffectEvent`. We currently parse modifiers only. */
+type StemFmModifierType = 'rate' | 'pitch' | 'volume';
+type StemFmCurve = 'instant' | 'linear';
+interface StemFmTriggerOrigin {
+    /** 0-based bar index in the original (source) audio. */
+    originalBarIndex: number;
+    /** Wall-clock position of the bar in the source audio (seconds). */
+    originalStartTimeSec: number;
+    /** Sample position of the bar in the source audio (48 kHz). */
+    originalSampleStart: number;
+}
+/**
+ * Modifier event (rate / pitch / volume). Carries `startValue` / `endValue`
+ * in `behavior` — for `instant` events these are equal; for `linear` events
+ * they describe a ramp of length `schedule.length.bars` master bars.
+ */
+interface StemFmModifierEvent {
+    category: 'modifier';
+    type: StemFmModifierType;
+    schedule: {
+        /** `bar` is 1-based in the session timeline. */
+        triggerTime: {
+            bar: number;
+            position: string;
+        };
+        /** Ramp length. `bars: 0` ⇒ instant. */
+        length: {
+            bars: number;
+            offset: string;
+        };
+        triggerOrigin?: StemFmTriggerOrigin;
+    };
+    target: {
+        trackId: string;
+        /** Volume events target a specific stem; rate / pitch events
+         *  target the whole track and omit this field. */
+        stem?: StemName;
+    };
+    behavior: {
+        startValue: number;
+        endValue: number;
+        curve: StemFmCurve;
+        signatureLabel?: string | null;
+    };
+}
+/**
+ * Effect events (e.g. reverb) carry an entirely different `behavior` shape
+ * (`startEnabled / endEnabled / startMix / endMix / startDecay / endDecay`)
+ * and are not yet wired through to the DAW's `StemEffectChain`. We type
+ * them loosely here so they can flow through the validator without
+ * crashing the importer; consumers should ignore unknown event types.
+ */
+interface StemFmEffectEvent {
+    category: 'effect';
+    type: string;
+    schedule: StemFmModifierEvent['schedule'];
+    target: {
+        trackId: string;
+        stem?: StemName;
+    };
+    behavior: Record<string, unknown>;
+}
+type StemFmEvent = StemFmModifierEvent | StemFmEffectEvent;
+interface StemFmSession {
+    type: 'playback' | 'transition';
+    trackChannels: {
+        id: string;
+    }[];
+    length: {
+        bars: number;
+        offset: string;
+    };
+    events: StemFmEvent[];
+    /** Convenience duplicate of `length.bars` (newer exports include this). */
+    bars?: number;
+    /**
+     * Where each track in `trackChannels` starts in its source audio for
+     * this session. Same length & order as `trackChannels`. Newer exports
+     * include this; older ones don't, and we fall back to the first rate
+     * event's `triggerOrigin` for the track.
+     */
+    originAnchors?: StemFmTriggerOrigin[];
+}
+type StemFmMixConfig = StemFmSession[];
+/**
+ * One scheduled clip on the DAW timeline — corresponds 1:1 with a
+ * (session, trackChannel) pair from the mix-config.
+ */
+interface PlannedClip {
+    /** Which session this clip came from (0-based). For diagnostics. */
+    sessionIndex: number;
+    /** stem.fm track id (source). */
+    sourceTrackId: string;
+    /** Where on the global DAW timeline this clip starts. */
+    timelineStartBar: number;
+    /** Inclusive first source bar (relative to the original track). */
+    sourceStartBar: number;
+    /** Exclusive last source bar (relative to the original track). */
+    sourceEndBar: number;
+    /** Per-stem volume to apply on this clip (length 4, [other, vocals, bass, drums]). */
+    stemVolumes: [number, number, number, number];
+    /** Per-stem mute regions inside the clip (local bars relative to
+     *  `sourceStartBar`). Each entry shadows a bar range where the
+     *  stem volume was 0 in the session. */
+    stemMuteRegions: [
+        Array<{
+            startBar: number;
+            endBar: number;
+        }>,
+        Array<{
+            startBar: number;
+            endBar: number;
+        }>,
+        Array<{
+            startBar: number;
+            endBar: number;
+        }>,
+        Array<{
+            startBar: number;
+            endBar: number;
+        }>
+    ];
+    /** Pitch shift in semitones for this clip (constant across the clip). */
+    transposeSemitones: number;
+    /** Average rate over the clip (informational; the DAW computes a per-bar
+     *  speed map on its own from `barMapping` vs master tempo). */
+    avgRate: number;
+}
+/**
+ * Build the full list of planned DAW clips from a mix-config.
+ *
+ * Initial-implementation rule: emit ONE clip per (session, trackChannel)
+ * pair. Source position comes from `originAnchors` (or the first rate
+ * event's `triggerOrigin` as a fallback). Length is `session.length.bars`.
+ * Per-stem volumes & mute regions come from the session's volume events.
+ *
+ * No run-splitting on rate-event jumps, no skipping silent placeholders —
+ * a track that's "loaded silent" appears on the timeline as a muted clip,
+ * ready to come alive in a later session.
+ *
+ * Pure / synchronous so it can be unit-tested without the audio engine.
+ */
+declare function planClipsFromStemFmConfig(config: StemFmMixConfig): {
+    clips: PlannedClip[];
+    totalTimelineBars: number;
+    trackIds: string[];
+};
+interface ImportStemFmCallbacks {
+    onStatus?: (message: string) => void;
+    onPercent?: (percent: number) => void;
+    /**
+     * Limit the import to the first N sessions of the mix-config. Useful
+     * while the DAW doesn't yet de-duplicate repeated source tracks — a
+     * long playback session that jumps backwards in its source track
+     * (e.g. session 3 of the test file revisits "What Goes Around" 7
+     * times) explodes into many independently-decoded clips of the same
+     * audio. Defaults to `Infinity` (import everything).
+     */
+    maxSessions?: number;
+}
+/**
+ * Validate that a parsed object looks like a stem.fm mix-config (an array of
+ * sessions). Throws a `TypeError` with a human-friendly message when the
+ * shape doesn't match, so callers can show the error directly.
+ */
+declare function isStemFmMixConfig(value: unknown): value is StemFmMixConfig;
+/**
+ * Import a stem.fm mix-config JSON, replacing the current DAW session.
+ *
+ * Caller is expected to have already cleared the previous session (matches
+ * the `restoreSession` pattern in `daw-session-restore.ts`).
+ *
+ * Returns the planned clips so the caller can show a summary to the user.
+ */
+declare function importStemFmMixConfig(config: StemFmMixConfig, callbacks?: ImportStemFmCallbacks): Promise<{
+    clips: PlannedClip[];
+    totalTimelineBars: number;
+    addedTrackInstances: number;
+}>;
+
+export { type ImportStemFmCallbacks, type StemFmCurve, type StemFmEffectEvent, type StemFmEvent, type StemFmMixConfig, type StemFmModifierEvent, type StemFmModifierType, type StemFmSession, type StemFmTriggerOrigin, importStemFmMixConfig, isStemFmMixConfig, planClipsFromStemFmConfig };

package/dist/engine/daw-import-stem-fm-config.js

@@ -0,0 +1,7 @@
+export { importStemFmMixConfig, isStemFmMixConfig, planClipsFromStemFmConfig } from '../chunk-U44X6QP5.js';
+import '../chunk-OYNES5W3.js';
+import '../chunk-56PWIP7O.js';
+import '../chunk-TBXCZFAY.js';
+import '../chunk-KCOOE2OP.js';
+//# sourceMappingURL=daw-import-stem-fm-config.js.map
+//# sourceMappingURL=daw-import-stem-fm-config.js.map

package/dist/engine/daw-import-stem-fm-config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"daw-import-stem-fm-config.js"}

package/dist/fetchStationTracks-SKFT4V3U.js

@@ -0,0 +1,3 @@
+export { BARE_SESSION_STATION_TRACK_LIMIT, extractBareSessionStationId, extractStationIdFromUrl, extractStationIdVer2, extractStationTrackIdVer2, fetchStationTrackDataWithSharedURL, getStationTracksGeneric, getStationTracksPageFirstN, isStationIdLibraryArtistStation, loadStationTrackFromJsonForPrototype, login, removeDuplicatesById, uniqueTrackIds } from './chunk-TBXCZFAY.js';
+//# sourceMappingURL=fetchStationTracks-SKFT4V3U.js.map
+//# sourceMappingURL=fetchStationTracks-SKFT4V3U.js.map

package/dist/fetchStationTracks-SKFT4V3U.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"fetchStationTracks-SKFT4V3U.js"}