@kano/stem-daw 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,308 @@
+import { D as DAWTrack } from './interfaces-5ZlG0Y4Y.js';
+export { a4 as CamelotKey, a6 as CamelotMatchType, C as ClipEdge, i as ClipboardEntry, q as DAWBarChunk, k as DAWChannel, d as DAWSession, b as DAWToolMode, w as DAWTrackAudioNodes, a as DEFAULT_PITCH_SETTINGS, H as IBarMapping, I as IBeat, Z as ITempoMatch, M as MuteRegion, N as NOTE_COLORS, e as NOTE_EMOJI_PALETTE, o as PianoRollNote, P as PitchEngineSettings, a2 as PitchShiftStrategy, R as ResampledRegion, v as SEGMENT_COLORS, u as SEGMENT_LABELS, r as SEGMENT_TYPE, A as STEM_BUFFER_KEYS, z as STEM_COLORS, x as STEM_LABELS, y as STEM_TYPES, l as SamplerRegion, n as SamplerSequenceEntry, m as SamplerSlice, E as SectionRange, t as SegmentTypeValue, f as SessionNote, h as StemClip, S as StemId, c as StemSelectionRange, Y as TempoRatio, a9 as TransposeSuggestion, U as barDurationToBpm, J as barToSample, V as bpmToBarDuration, _ as calculateTempoMatch, a7 as camelotMatchType, K as composeBarsFromBeats, L as composeBarsFromBeatsSmoothed, $ as computeBarSpeedRatio, j as computeClips, a3 as computePitchShift, aa as computeTransposeSuggestions, B as createDefaultChannels, G as findFirstSectionOfType, g as getSelectionBoundsBars, W as keyToSemitones, T as medianBarDuration, p as parseStemIdKey, a0 as playbackRateToSemitones, Q as resolveSampleLocOfDownbeatFromBarIndex, O as resolveTimeOfDownbeatFromBarIndex, F as segmentInfoToSections, X as semitonesToKey, a1 as semitonesToPitchFactor, s as stemIdKey, a5 as toCamelot, a8 as transposeKey } from './interfaces-5ZlG0Y4Y.js';
+import { I as ITrackForSequence } from './interface-DaRj7RkY.js';
+export { D as DAWController, L as LoadProgress, S as StemAudioBuffers, l as loadTrackStems } from './daw-controller-BjRWcTol.js';
+export { ImportStemFmCallbacks, StemFmEffectEvent, StemFmEvent, StemFmMixConfig, StemFmModifierEvent, StemFmModifierType, StemFmSession, StemFmTriggerOrigin, importStemFmMixConfig, isStemFmMixConfig, planClipsFromStemFmConfig } from './engine/daw-import-stem-fm-config.js';
+export { DAWView } from './components/DAWView.js';
+import React from 'react';
+import { SimilarityMode } from './services/track-search-api.js';
+export { fetchTrackForDAW } from './services/track-search-api.js';
+export { useDAWSessionStore } from './store/daw-session-store.js';
+export { useDAWAuthStore } from './store/daw-auth-store.js';
+import 'zustand';
+import 'zustand/middleware';
+
+/**
+ * This panel responsible for putting the Mix JSON Object into AEV3Context
+ *
+ * Migrate all related code from V1 to V2
+ * And make another cleaner V1 version up and able to run with exported code
+ *
+ * 1.
+ *
+ */
+
+type STEM_FIELDS_SUPPORTED = 'mp4';
+
+interface ByteSampleSegment {
+    sampleStart: number;
+    sampleEnd: number;
+    sampleLength: number;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    path: string;
+    byteRangeStart: number;
+    byteRangeEnd: number;
+    _mp4TrackId: number;
+    tracks: {
+        [_mp4TrackId: number]: {
+            decodeByteStart: number;
+            decodeByteLength: number;
+            frames: {
+                sampleStart: number;
+                sampleEnds: number;
+                rawData: Uint8Array;
+            }[];
+            timeLog: {
+                a_extractbytes: number;
+                b_extractmoof: number;
+                c_packageAACFrames: number;
+            };
+        };
+    };
+    signatures: {
+        sequenceIdx: number;
+        sequenceId: string;
+        segmentIdx: number;
+    };
+}
+
+type FetchGroupErrorCause = {
+    detailMessage: string;
+    http_status: number;
+    segmentIdx: number;
+    sequenceId: number;
+    sequenceIdx: number;
+    type: 'mp4';
+    url: string;
+};
+
+/**
+ * Bivariant listener so handlers may narrow `{ type; detail }` while dispatch uses
+ * `{ type: string; detail: unknown }` (required under strictFunctionTypes).
+ */
+type EmitterListener = {
+    bivarianceHack(event: {
+        type: string;
+        detail: unknown;
+    }): void;
+}['bivarianceHack'];
+declare class EventEmitter {
+    events: Record<string, EmitterListener[]>;
+    constructor();
+    on(eventName: string, listener: EmitterListener): void;
+    off(eventName: string, listener: EmitterListener): void;
+    dispatchEvent(eventName: string, detail?: unknown): void;
+    clearEventEmitter(): void;
+    showListenersAttached(): Record<string, number>;
+}
+
+/**
+ * CAUTION: this is obviously a technical debt to build to just to speed up testing of MP4/AAC
+ *
+ * Goal is to replace quantised AAC with unquantise MP4 contains four stems of AACs
+ */
+
+interface IAudioSourceSequence {
+    manifest_url: string;
+    segments: IMP4SequenceChunk[];
+    headerBuffer: ArrayBuffer;
+    stemType: string;
+    sequenceId: string;
+    signature: string;
+}
+interface IMP4SequenceChunk {
+    segmentId: string;
+    nextSegmentId: string;
+    isLastSegment: boolean;
+    byteSampleSegment: ByteSampleSegment;
+    cached: {
+        arrayBuffer: ArrayBuffer | undefined;
+        cacheTimeMS: number;
+        isDownloading: boolean;
+        cacheStartTime: number;
+        firstError: string;
+        _error: FetchGroupErrorCause[];
+    };
+    parent: IAudioSourceSequence;
+}
+declare class AudioSourceSequence extends EventEmitter {
+    static AUDIO_SOURCE_MANIFEST_PARSED_CREATED: string;
+    static AUDIO_SOURCE_MANIFEST_PARSED_FAILED: string;
+    static LOADED_ALL_SEQUENCES_SEGMENTS_REQUESTED: string;
+    static LOADED_SINGLE_SEQUENCE_SEGMENTS_REQUESTED: string;
+    static UNLOADED_ALL_SEQUENCES_SEGMENTS_REQUESTED: string;
+    static PROGRESS_SINGLE_STEM_INDIVIDUAL_SEGMENT_LOADED: string;
+    static PROGRESS_MULTIPLE_STEMS_INDIVIDUAL_SEGMENT_LOADED: string;
+    static SEGMENT_LOADING_ERROR: string;
+    static SEGMENTS_BATCH_LOADING_ERROR: string;
+    static SAMPLE_RANGE_REQUESTED_NOT_EXISTED: string;
+    static SINGLE_ARRAY_BUFFER_LOAGING_PERCENT: string;
+    static GROUP_ARRAY_BUFFER_LOAGING_PERCENT: string;
+    isLoading: boolean;
+    isInitialised: 'INITIALISED' | 'NOT_YET' | 'FLAWED';
+    isDecoding: boolean;
+    trackId: string;
+    trackData: ITrackForSequence;
+    eTagOfTailSegment: string | undefined;
+    lastModifiedOfTailSegment: string | undefined;
+    dateOfTailSegment: string | undefined;
+    isMP4TailFlawed: boolean;
+    errorOnInit: string;
+    diffETagDetected: boolean;
+    sequences: IAudioSourceSequence[];
+    sourcePlaying: {
+        [sequenceIdx: number]: {
+            sampleEndOfPlayingChunk: number;
+            sequenceIdx: number;
+            sequenceId: string;
+        };
+    };
+    interval_caching: ReturnType<typeof setInterval> | undefined;
+    interval_evicting: ReturnType<typeof setInterval> | undefined;
+    constructor();
+    _log(...msg: unknown[]): void;
+    destroy(): void;
+    initialise(trackData: ITrackForSequence, field: STEM_FIELDS_SUPPORTED, token: string, diffETagDetected: boolean): Promise<unknown>;
+    preload(preloadAtMoofBoxIndex?: number, updatePlayheadAtTargetIndex?: boolean, signature?: string): Promise<boolean>;
+    preloadWithRange(preloadAtMoofIndex: number, preloadEndAtMoofIndex: number, signature?: string): Promise<boolean>;
+    preloadWithSampleRange(preloadAtSample48000: number, preloadEndAtSample48000: number, signature?: string): Promise<boolean>;
+    preloadWithTimeRange(preloadAtStartTime: number, preloadDuration: number, signature?: string): Promise<boolean>;
+    preloadSneakyVer(preloadAtIndex: number, count?: number): Promise<boolean>;
+    updateSampleLocJustPlayed(sequenceIdx: number, samplePlayed: number, signature: string): boolean;
+    updateSampleLocJustPlayedUntilManifestResolved(sequenceIdx: number, samplePlayed: number, signature: string): void;
+    getSegmentsWithSampleLoc(sequenceId: string, sample: number): number;
+    getSegmentsIdxWithSampleLoc(sequenceIdx: number, sample_: number): number;
+    getPlayingChunksInfo(): {
+        segmentId: string;
+        segmentIdx: number;
+        sequenceId: string;
+        sequenceIdx: number;
+    }[];
+    getMinimumPlayingIndex(): number;
+    isSegmentIdxCached(segmentIdx: number, sequenceIdx?: number): boolean;
+    isMoofSegmentCached(segment: IMP4SequenceChunk): boolean;
+    evictArrayBufferOnAllSequencesWithMoofIndex(moofBoxIndex: number): void;
+    evictArrayBufferAccordingToSampleRange(sequenceIdx: number, sampleStart48000: number, sampleEnd48000: number, _signature: string): void;
+    /**
+     * Trigger caching of MP4 segments, ARRAY_BUFFER_PRELOADED will be fired or error will be printed
+     * the arrayBuffer will be updated directly to sequences's items
+     *
+     * When this function resolved as true, should promise the Moof Boxes are accessible
+     *
+     * @param startIndex start (including) the MP4 segment's index
+     * @param endIndex end (including) the MP4 segment's index
+     * @param sessionId will be included in the dispatcher of events
+     */
+    loadAllSequencesWithMoofIndex(moofStartIndex: number, moofEndIndex: number, sessionId: string, isPreloadCommand?: boolean): Promise<boolean>;
+    private loadMultipleMoofSegments;
+    getAudioBuffer(sequenceIdx: number, sampleStart48000: number, sampleEnd48000: number, decodingQueueIndex: number, signature: string): Promise<[AudioBuffer | null, number, number, number, number, number, string, string]>;
+    getIsInitialised(): "INITIALISED" | "NOT_YET" | "FLAWED";
+    getSegmentInfo(sequenceIdx: number, sampleStart48000_: number, sampleEnd48000: number): [IAudioSourceSequence, IMP4SequenceChunk[], number, number];
+    fetchCacheRecord(sampleStart: number, sampleEnd: number): {
+        totalCacheTime: string;
+        cacheTimes: string;
+        firstErrorOfEachMoov: string;
+    };
+}
+
+/**
+ * Bridge between AudioSourceSequence (cache layer) and the DAW decode pipeline.
+ * Decoupled from AEV3Controller - takes the AudioSourceSequence directly.
+ */
+
+declare const GET_AUDIO_BUFFER_MESSAGE_NOT_INIT = "audio_source_not_initialised";
+declare const GET_AUDIO_BUFFER_MESSAGE_NOT_CACHED = "moof_not_cached_yet";
+declare const GET_AUDIO_BUFFER_MESSAGE_ERROR = "moof_box_error";
+interface AudioBufferResult {
+    audioBuffer: AudioBuffer | null;
+    totalTimeElapsed: number;
+    error: string | null;
+    message: string;
+    signature: string;
+}
+/**
+ * Request an AudioBuffer for a specific sample range from a given AudioSourceSequence.
+ * This is the decoupled equivalent of getAudioBufferUtil from the streaming engine.
+ */
+declare const getAudioBufferFromSource: (audioSourceSequence: AudioSourceSequence | null, sequenceIdx: number, sampleStart: number, sampleEnd: number, decodingQueueIndex: number, signature: string) => Promise<AudioBufferResult>;
+
+/**
+ * DAWTimeline – Unified timeline with sticky ruler, collapsible muted stems,
+ * and independently positionable stem blocks.
+ *
+ * The ruler is a separate sticky element at the top of the scroll container so
+ * it always stays visible. Muted stems collapse to a thin lane showing just the
+ * icon. Drag on the ruler to create loop regions.
+ */
+
+interface DAWTimelineProps {
+    onBarClick?: (bar: number) => void;
+    /** Render an "Add another song" row directly under the bottom track. */
+    onAddTrack?: () => void;
+    /**
+     * When `true`, the timeline's left track-names column is pinned to
+     * LEFT_COL_COMPACT regardless of scroll/hover state. Used by the
+     * shell (`DAWView`) to force compact whenever a side panel is open,
+     * so the panel and the track-names column never visually fight for
+     * horizontal space — you're either in "panel open + compact strip"
+     * or "panel closed + full strip", never the squeezed in-between.
+     */
+    forceCompact?: boolean;
+}
+declare const DAWTimeline: React.FC<DAWTimelineProps>;
+
+/**
+ * DAWTransportBar - Compact transport bar.
+ *
+ * Primary row: Stop | Play/Pause | Undo/Redo | Tools | Position | BPM | Add Track | ··· overflow
+ * Overflow menu: Loop, Metronome, Reset
+ *
+ * Responsive: tool labels hide at narrow widths, BPM slider shrinks, gaps tighten,
+ * Export compacts to icon-only then moves to overflow menu, central LCD trims labels.
+ */
+
+interface DAWTransportBarProps {
+    onAddTrack?: () => void;
+    onImportProject?: (file: File) => void;
+    onExport?: () => void;
+    /**
+     * Slot rendered at the far-right of the bar — carries chrome that
+     * used to live in the standalone top nav (account dropdown,
+     * "what's new" pill, etc.). Kept as an opaque ReactNode so the
+     * transport bar doesn't need to know what those bits are or how
+     * they're wired.
+     */
+    rightExtras?: React.ReactNode;
+}
+declare const DAWTransportBar: React.FC<DAWTransportBarProps>;
+
+/**
+ * DAWTrackHeader – Compact sidebar panel for a single track.
+ * Each stem has its own volume slider — that's the primary control.
+ * No track-level master volume; stem volumes ARE the mix.
+ */
+
+interface DAWTrackHeaderProps {
+    track: DAWTrack;
+}
+declare const DAWTrackHeader: React.FC<DAWTrackHeaderProps>;
+
+/**
+ * DAWAddTrackPanel – Inspirational entry-point for adding tracks.
+ * Rich category cards with gradient visuals, search, similarity matching,
+ * and URL import.
+ */
+
+type TabId = 'similar' | 'suggestions' | 'search' | 'url';
+interface DAWAddTrackPanelProps {
+    onClose: () => void;
+    initialTab?: TabId;
+}
+declare const DAWAddTrackPanel: React.FC<DAWAddTrackPanelProps>;
+
+/**
+ * DAWSuggestedStemsPanel – Sidebar of similar tracks from the same station
+ * (refresh-mix style). Draggable/clickable cards to add stems to the DAW.
+ */
+
+interface DAWSuggestedStemsPanelProps {
+    mixUrl: string;
+    onAddTrack?: () => void;
+    similarityMode?: SimilarityMode;
+    onSimilarityModeChange?: (mode: SimilarityMode) => void;
+}
+declare const DAWSuggestedStemsPanel: React.FC<DAWSuggestedStemsPanelProps>;
+
+export { type AudioBufferResult, DAWAddTrackPanel, DAWSuggestedStemsPanel, DAWTimeline, DAWTrack, DAWTrackHeader, DAWTransportBar, GET_AUDIO_BUFFER_MESSAGE_ERROR, GET_AUDIO_BUFFER_MESSAGE_NOT_CACHED, GET_AUDIO_BUFFER_MESSAGE_NOT_INIT, getAudioBufferFromSource };

package/dist/index.js

@@ -0,0 +1,332 @@
+import { useThemeMode, theme } from './chunk-LO74ZJ4H.js';
+export { DAWAddTrackPanel, DAWSuggestedStemsPanel, DAWTimeline, DAWTransportBar, DAWView } from './chunk-LO74ZJ4H.js';
+import './chunk-QQ5NZTHT.js';
+import './chunk-OFGZURP6.js';
+import './chunk-AAVC7KUW.js';
+export { importStemFmMixConfig, isStemFmMixConfig, planClipsFromStemFmConfig } from './chunk-U44X6QP5.js';
+import { DAWController } from './chunk-OYNES5W3.js';
+export { DAWController, loadTrackStems } from './chunk-OYNES5W3.js';
+export { fetchTrackForDAW } from './chunk-56PWIP7O.js';
+import './chunk-TBXCZFAY.js';
+import { useDAWSessionStore, STEM_COLORS } from './chunk-KCOOE2OP.js';
+export { DEFAULT_PITCH_SETTINGS, NOTE_COLORS, NOTE_EMOJI_PALETTE, PitchShiftStrategy, SEGMENT_COLORS, SEGMENT_LABELS, SEGMENT_TYPE, STEM_BUFFER_KEYS, STEM_COLORS, STEM_LABELS, STEM_TYPES, barDurationToBpm, barToSample, bpmToBarDuration, calculateTempoMatch, camelotMatchType, composeBarsFromBeats, composeBarsFromBeatsSmoothed, computeBarSpeedRatio, computeClips, computePitchShift, computeTransposeSuggestions, createDefaultChannels, findFirstSectionOfType, getSelectionBoundsBars, keyToSemitones, medianBarDuration, parseStemIdKey, playbackRateToSemitones, resolveSampleLocOfDownbeatFromBarIndex, resolveTimeOfDownbeatFromBarIndex, segmentInfoToSections, semitonesToKey, semitonesToPitchFactor, stemIdKey, toCamelot, transposeKey, useDAWSessionStore } from './chunk-KCOOE2OP.js';
+export { useDAWAuthStore } from './chunk-UKMELGZL.js';
+import { useState, useCallback, useRef } from 'react';
+import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
+
+// src/daw/primitives/audio-buffer-bridge.ts
+var GET_AUDIO_BUFFER_MESSAGE_NOT_INIT = "audio_source_not_initialised";
+var GET_AUDIO_BUFFER_MESSAGE_NOT_CACHED = "moof_not_cached_yet";
+var GET_AUDIO_BUFFER_MESSAGE_ERROR = "moof_box_error";
+var getAudioBufferFromSource = async (audioSourceSequence, sequenceIdx, sampleStart, sampleEnd, decodingQueueIndex, signature) => {
+  if (!audioSourceSequence) {
+    return {
+      audioBuffer: null,
+      totalTimeElapsed: -1,
+      error: "AudioSourceSequence not provided",
+      message: GET_AUDIO_BUFFER_MESSAGE_NOT_INIT,
+      signature
+    };
+  }
+  try {
+    const result = await audioSourceSequence.getAudioBuffer(
+      sequenceIdx,
+      sampleStart,
+      sampleEnd,
+      decodingQueueIndex,
+      signature
+    );
+    const [audioBuffer, totalTimeElapsed, , , , , resultSignature, message] = result;
+    return {
+      audioBuffer,
+      totalTimeElapsed,
+      error: audioBuffer === null ? GET_AUDIO_BUFFER_MESSAGE_NOT_CACHED : null,
+      message,
+      signature: resultSignature
+    };
+  } catch (err) {
+    if (err?.toString().includes("sequence is not initialised yet")) {
+      return {
+        audioBuffer: null,
+        totalTimeElapsed: -1,
+        error: GET_AUDIO_BUFFER_MESSAGE_NOT_INIT,
+        message: GET_AUDIO_BUFFER_MESSAGE_NOT_INIT,
+        signature
+      };
+    }
+    return {
+      audioBuffer: null,
+      totalTimeElapsed: -1,
+      error: err?.toString() ?? "unknown error",
+      message: GET_AUDIO_BUFFER_MESSAGE_ERROR,
+      signature
+    };
+  }
+};
+var STEM_ICONS = ["\u266A", "\u{1F3A4}", "\u{1F3B5}", "\u2B21"];
+var DAWTrackHeader = ({ track }) => {
+  useThemeMode();
+  const [showBeatNudge, setShowBeatNudge] = useState(false);
+  const handleRemove = useCallback(() => {
+    DAWController.getInstance().removeTrack(track.id);
+  }, [track.id]);
+  return /* @__PURE__ */ jsxs("div", { className: "border-b px-3 py-2", style: { borderColor: "rgba(255,255,255,0.04)" }, children: [
+    /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-2 mb-2", children: [
+      track.artwork && /* @__PURE__ */ jsx("img", { src: track.artwork, alt: "", className: "w-5 h-5 rounded-sm object-cover" }),
+      /* @__PURE__ */ jsx("span", { className: "text-[11px] font-medium text-white truncate flex-1", children: track.displayName }),
+      /* @__PURE__ */ jsx("span", { className: "text-[9px]", style: { color: "rgba(255,255,255,0.3)" }, children: Math.round(track.nativeBpm) }),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: () => setShowBeatNudge((v) => !v),
+          className: "text-[8px] font-medium rounded transition-all",
+          style: {
+            padding: "1px 4px",
+            background: showBeatNudge ? "rgba(255,214,0,0.12)" : "rgba(255,255,255,0.04)",
+            color: showBeatNudge ? "#FFD600" : "rgba(255,255,255,0.25)",
+            border: showBeatNudge ? "1px solid rgba(255,214,0,0.2)" : "1px solid transparent"
+          },
+          title: "Beat grid nudge",
+          children: "Grid"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          onClick: handleRemove,
+          className: "text-[9px] transition-colors ml-1",
+          style: { color: "rgba(255,255,255,0.25)" },
+          children: "\u2715"
+        }
+      )
+    ] }),
+    showBeatNudge && /* @__PURE__ */ jsx(BeatGridNudge, { trackId: track.id, currentOffset: track.beatGridOffsetBeats }),
+    /* @__PURE__ */ jsx("div", { className: "space-y-1", children: track.channels.map((ch) => /* @__PURE__ */ jsx(
+      StemStrip,
+      {
+        trackId: track.id,
+        stemIndex: ch.stemIndex,
+        label: ch.label,
+        volume: ch.volume,
+        muted: ch.muted,
+        visible: ch.visible
+      },
+      ch.stemIndex
+    )) })
+  ] });
+};
+var NUDGE_AMOUNTS = [
+  { label: "-1", value: -1, title: "Shift grid back 1 beat" },
+  { label: "-\xBD", value: -0.5, title: "Shift grid back half a beat" },
+  { label: "-\xBC", value: -0.25, title: "Shift grid back a quarter beat" },
+  { label: "+\xBC", value: 0.25, title: "Shift grid forward a quarter beat" },
+  { label: "+\xBD", value: 0.5, title: "Shift grid forward half a beat" },
+  { label: "+1", value: 1, title: "Shift grid forward 1 beat" }
+];
+var BeatGridNudge = ({ trackId, currentOffset }) => {
+  const setBeatGridOffset = useDAWSessionStore((s) => s.setTrackBeatGridOffset);
+  const handleNudge = useCallback((delta) => {
+    const newOffset = currentOffset + delta;
+    setBeatGridOffset(trackId, newOffset);
+    DAWController.getInstance().reloadTrackBarMap(trackId);
+  }, [trackId, currentOffset, setBeatGridOffset]);
+  const handleReset = useCallback(() => {
+    setBeatGridOffset(trackId, 0);
+    DAWController.getInstance().reloadTrackBarMap(trackId);
+  }, [trackId, setBeatGridOffset]);
+  const displayOffset = currentOffset === 0 ? "0" : `${currentOffset > 0 ? "+" : ""}${currentOffset % 1 === 0 ? currentOffset : currentOffset.toFixed(2)} beat${Math.abs(currentOffset) !== 1 ? "s" : ""}`;
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "mb-2 rounded-lg",
+      style: {
+        padding: "6px 8px",
+        background: "rgba(255,255,255,0.02)",
+        border: "1px solid rgba(255,255,255,0.04)"
+      },
+      children: [
+        /* @__PURE__ */ jsxs("div", { className: "flex items-center gap-1.5 mb-1.5", children: [
+          /* @__PURE__ */ jsx("span", { className: "text-[7px] font-semibold tracking-wider uppercase", style: { color: "rgba(255,255,255,0.25)" }, children: "Beat Grid" }),
+          /* @__PURE__ */ jsx("span", { className: "text-[8px] font-mono flex-1", style: { color: currentOffset !== 0 ? "#FFD600" : "rgba(255,255,255,0.2)" }, children: displayOffset }),
+          currentOffset !== 0 && /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: handleReset,
+              className: "text-[7px] font-semibold rounded transition-all",
+              style: {
+                padding: "1px 5px",
+                background: "rgba(239,68,68,0.08)",
+                color: "rgba(251,113,133,0.7)",
+                border: "1px solid rgba(239,68,68,0.15)"
+              },
+              children: "Reset"
+            }
+          )
+        ] }),
+        /* @__PURE__ */ jsx("div", { className: "flex items-center gap-1", children: NUDGE_AMOUNTS.map((nudge) => /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: () => handleNudge(nudge.value),
+            title: nudge.title,
+            className: "flex-1 text-[8px] font-semibold rounded transition-all",
+            style: {
+              padding: "3px 0",
+              background: "rgba(255,255,255,0.04)",
+              color: "rgba(255,255,255,0.4)",
+              border: "1px solid rgba(255,255,255,0.06)"
+            },
+            onMouseEnter: (e) => {
+              e.currentTarget.style.background = "rgba(255,255,255,0.08)";
+              e.currentTarget.style.color = "rgba(255,255,255,0.7)";
+            },
+            onMouseLeave: (e) => {
+              e.currentTarget.style.background = "rgba(255,255,255,0.04)";
+              e.currentTarget.style.color = "rgba(255,255,255,0.4)";
+            },
+            children: nudge.label
+          },
+          nudge.value
+        )) })
+      ]
+    }
+  );
+};
+var StemStrip = ({
+  trackId,
+  stemIndex,
+  label,
+  volume,
+  muted,
+  visible
+}) => {
+  const store = useDAWSessionStore();
+  const color = STEM_COLORS[stemIndex];
+  const icon = STEM_ICONS[stemIndex];
+  const volPercent = Math.round(volume * 100);
+  const toggleVisible = useCallback(() => {
+    store.setChannelVisible(trackId, stemIndex, !visible);
+    if (visible) store.setChannelMuted(trackId, stemIndex, true);
+    else store.setChannelMuted(trackId, stemIndex, false);
+    DAWController.getInstance().syncGainsForTrack(trackId);
+  }, [trackId, stemIndex, visible]);
+  const toggleMute = useCallback(() => {
+    store.setChannelMuted(trackId, stemIndex, !muted);
+    DAWController.getInstance().syncGainsForTrack(trackId);
+  }, [trackId, stemIndex, muted]);
+  const handleVolume = useCallback((e) => {
+    store.setChannelVolume(trackId, stemIndex, parseFloat(e.target.value));
+    DAWController.getInstance().syncGainsForTrack(trackId);
+  }, [trackId, stemIndex]);
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      className: "flex items-center gap-1.5 rounded py-0.5 transition-opacity",
+      style: { opacity: visible ? 1 : 0.25 },
+      children: [
+        /* @__PURE__ */ jsx(
+          "button",
+          {
+            onClick: toggleVisible,
+            className: "w-5 h-5 flex items-center justify-center rounded flex-shrink-0 text-[10px] transition-all",
+            style: {
+              backgroundColor: visible ? color : "transparent",
+              border: visible ? "none" : `1px solid ${color}33`,
+              color: visible ? "#000" : color + "66"
+            },
+            title: visible ? `Remove ${label}` : `Add ${label}`,
+            children: icon
+          }
+        ),
+        visible ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx(VolumeFader, { color, volume, onChange: handleVolume }),
+          /* @__PURE__ */ jsx("span", { className: "text-[8px] w-5 text-right tabular-nums flex-shrink-0 font-mono", style: { color: "rgba(255,255,255,0.3)" }, children: volPercent }),
+          /* @__PURE__ */ jsx(
+            "button",
+            {
+              onClick: toggleMute,
+              className: "text-[7px] font-semibold w-4 h-4 flex items-center justify-center flex-shrink-0 transition-all",
+              style: {
+                backgroundColor: muted ? "rgba(255,69,58,0.1)" : "rgba(255,255,255,0.04)",
+                color: muted ? "rgba(255,105,97,0.85)" : "rgba(255,255,255,0.3)",
+                borderRadius: 6
+              },
+              title: muted ? `Unmute ${label}` : `Mute ${label}`,
+              children: "M"
+            }
+          )
+        ] }) : /* @__PURE__ */ jsx("span", { className: "text-[9px] truncate", style: { color: "rgba(255,255,255,0.4)" }, children: label })
+      ]
+    }
+  );
+};
+var VolumeFader = ({ color, volume, onChange }) => {
+  useThemeMode();
+  const trackRef = useRef(null);
+  const pct = Math.max(0, Math.min(1, volume));
+  const updateFromPointer = (clientX) => {
+    const rect = trackRef.current?.getBoundingClientRect();
+    if (!rect) return;
+    const p = Math.max(0, Math.min(1, (clientX - rect.left) / rect.width));
+    onChange({ target: { value: String(Math.round(p * 100) / 100) } });
+  };
+  return /* @__PURE__ */ jsxs(
+    "div",
+    {
+      ref: trackRef,
+      style: {
+        flex: 1,
+        height: 14,
+        position: "relative",
+        display: "flex",
+        alignItems: "center",
+        cursor: "pointer"
+      },
+      onPointerDown: (e) => {
+        e.preventDefault();
+        e.target.setPointerCapture(e.pointerId);
+        updateFromPointer(e.clientX);
+      },
+      onPointerMove: (e) => {
+        if (e.buttons > 0) updateFromPointer(e.clientX);
+      },
+      children: [
+        /* @__PURE__ */ jsx("div", { style: {
+          position: "absolute",
+          left: 0,
+          right: 0,
+          top: "50%",
+          transform: "translateY(-50%)",
+          height: 2,
+          background: theme.border.default,
+          borderRadius: 1
+        } }),
+        /* @__PURE__ */ jsx("div", { style: {
+          position: "absolute",
+          left: 0,
+          width: `${pct * 100}%`,
+          top: "50%",
+          transform: "translateY(-50%)",
+          height: 2,
+          background: color,
+          opacity: 0.9,
+          borderRadius: 1
+        } }),
+        /* @__PURE__ */ jsx("div", { style: {
+          position: "absolute",
+          left: `${pct * 100}%`,
+          top: "50%",
+          transform: "translate(-50%, -50%)",
+          width: 3,
+          height: 12,
+          borderRadius: 1.5,
+          background: color,
+          zIndex: 2
+        } })
+      ]
+    }
+  );
+};
+
+export { DAWTrackHeader, GET_AUDIO_BUFFER_MESSAGE_ERROR, GET_AUDIO_BUFFER_MESSAGE_NOT_CACHED, GET_AUDIO_BUFFER_MESSAGE_NOT_INIT, getAudioBufferFromSource };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map