@kano/stem-daw 0.1.0

package/dist/media-session-XTP6PP7Q.js

@@ -0,0 +1,3 @@
+export { pauseInMusicControl, resumeInMusicControl, setupMediaSession, setupMediaSessionModeAware, updateMediaSessionForModeChange, updateMediaSessionPrevNextTrackRef } from './chunk-TBXCZFAY.js';
+//# sourceMappingURL=media-session-XTP6PP7Q.js.map
+//# sourceMappingURL=media-session-XTP6PP7Q.js.map

package/dist/media-session-XTP6PP7Q.js.map

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

package/dist/note-detection-PPLM7R2H.js

@@ -0,0 +1,148 @@
+// src/daw/utils/note-detection.ts
+var BASIC_PITCH_SR = 22050;
+var BP_FFT_HOP = 256;
+var BP_ANNOTATIONS_FPS = Math.floor(BASIC_PITCH_SR / BP_FFT_HOP);
+var BP_CONTOURS_BINS_PER_SEMITONE = 3;
+var BP_MIDI_OFFSET = 21;
+var BP_BASE_FREQ = 27.5;
+function resampleBuffer(buffer, targetSR) {
+  const offlineCtx = new OfflineAudioContext(1, Math.ceil(buffer.duration * targetSR), targetSR);
+  const source = offlineCtx.createBufferSource();
+  source.buffer = buffer;
+  source.connect(offlineCtx.destination);
+  source.start();
+  return offlineCtx.startRendering();
+}
+function mergeSamePitchNotes(notes, maxGapSec = 0.05) {
+  if (notes.length === 0) return notes;
+  const byPitch = /* @__PURE__ */ new Map();
+  for (const n of notes) {
+    let arr = byPitch.get(n.pitchMidi);
+    if (!arr) {
+      arr = [];
+      byPitch.set(n.pitchMidi, arr);
+    }
+    arr.push({ ...n });
+  }
+  const result = [];
+  for (const [, group] of byPitch) {
+    group.sort((a, b) => a.startTimeSeconds - b.startTimeSeconds);
+    let cur = group[0];
+    for (let i = 1; i < group.length; i++) {
+      const next = group[i];
+      const curEnd = cur.startTimeSeconds + cur.durationSeconds;
+      if (next.startTimeSeconds <= curEnd + maxGapSec) {
+        const nextEnd = next.startTimeSeconds + next.durationSeconds;
+        cur.durationSeconds = Math.max(curEnd, nextEnd) - cur.startTimeSeconds;
+        cur.amplitude = Math.max(cur.amplitude, next.amplitude);
+      } else {
+        result.push(cur);
+        cur = next;
+      }
+    }
+    result.push(cur);
+  }
+  result.sort((a, b) => a.startTimeSeconds - b.startTimeSeconds);
+  return result;
+}
+async function runBasicPitchModel(buffer) {
+  const { BasicPitch } = await import('@spotify/basic-pitch');
+  const inputBuffer = buffer.sampleRate !== BASIC_PITCH_SR ? await resampleBuffer(buffer, BASIC_PITCH_SR) : buffer;
+  const modelUrl = "/models/basic-pitch/model.json";
+  const basicPitch = new BasicPitch(modelUrl);
+  const frames = [];
+  const onsets = [];
+  const contours = [];
+  await basicPitch.evaluateModel(
+    inputBuffer,
+    (f, o, c) => {
+      frames.push(...f);
+      onsets.push(...o);
+      contours.push(...c);
+    },
+    () => {
+    }
+  );
+  return { frames, onsets, contours };
+}
+async function detectNotes(buffer) {
+  const {
+    addPitchBendsToNoteEvents,
+    noteFramesToTime,
+    outputToNotesPoly
+  } = await import('@spotify/basic-pitch');
+  const { frames, onsets, contours } = await runBasicPitchModel(buffer);
+  const rawNotes = outputToNotesPoly(frames, onsets);
+  const noteEvents = noteFramesToTime(
+    addPitchBendsToNoteEvents(contours, rawNotes)
+  );
+  return mergeSamePitchNotes(noteEvents, 0.05);
+}
+async function detectPitchContourML(buffer, targetHop = 1024, onProgress) {
+  onProgress?.(0.05, "Loading Basic Pitch model\u2026");
+  const { frames, contours } = await runBasicPitchModel(buffer);
+  onProgress?.(0.6, `Model complete \u2014 ${contours.length} contour frames`);
+  const ACTIVATION_THRESHOLD = 0.12;
+  const bpFrames = [];
+  for (let t = 0; t < contours.length; t++) {
+    const row = contours[t];
+    const frameRow = frames[t];
+    let peakBin = -1;
+    let peakVal = ACTIVATION_THRESHOLD;
+    for (let b = 0; b < row.length; b++) {
+      if (row[b] > peakVal) {
+        peakVal = row[b];
+        peakBin = b;
+      }
+    }
+    if (peakBin < 0) {
+      bpFrames.push({ timeSec: t / BP_ANNOTATIONS_FPS, midi: -1, freq: -1, confidence: 0 });
+      continue;
+    }
+    const semitoneIdx = Math.floor(peakBin / BP_CONTOURS_BINS_PER_SEMITONE);
+    const frameActivation = semitoneIdx < frameRow.length ? frameRow[semitoneIdx] : 0;
+    if (frameActivation < 0.15) {
+      bpFrames.push({ timeSec: t / BP_ANNOTATIONS_FPS, midi: -1, freq: -1, confidence: 0 });
+      continue;
+    }
+    let refinedBin = peakBin;
+    if (peakBin > 0 && peakBin < row.length - 1) {
+      const s0 = row[peakBin - 1], s1 = row[peakBin], s2 = row[peakBin + 1];
+      const denom = 2 * (s0 - 2 * s1 + s2);
+      if (Math.abs(denom) > 1e-8) {
+        refinedBin = peakBin + (s0 - s2) / denom;
+      }
+    }
+    const midi = BP_MIDI_OFFSET + refinedBin / BP_CONTOURS_BINS_PER_SEMITONE;
+    const freq = BP_BASE_FREQ * Math.pow(2, refinedBin / (12 * BP_CONTOURS_BINS_PER_SEMITONE));
+    bpFrames.push({ timeSec: t / BP_ANNOTATIONS_FPS, midi, freq, confidence: peakVal });
+  }
+  onProgress?.(0.8, "Resampling to target hop rate\u2026");
+  const origSR = buffer.sampleRate;
+  const totalSamples = buffer.length;
+  const yinWindow = 1024;
+  const numTargetFrames = Math.floor((totalSamples - yinWindow) / targetHop);
+  const result = [];
+  for (let f = 0; f < numTargetFrames; f++) {
+    const timeSec = f * targetHop / origSR;
+    const bpIdx = Math.round(timeSec * BP_ANNOTATIONS_FPS);
+    if (bpIdx >= 0 && bpIdx < bpFrames.length) {
+      const bp = bpFrames[bpIdx];
+      result.push({
+        time: timeSec,
+        freq: bp.freq,
+        rms: bp.confidence,
+        midi: bp.midi,
+        frameIndex: f
+      });
+    } else {
+      result.push({ time: timeSec, freq: -1, rms: 0, midi: -1, frameIndex: f });
+    }
+  }
+  onProgress?.(1, `${result.length} frames (${result.filter((f) => f.midi > 0).length} voiced)`);
+  return result;
+}
+
+export { detectNotes, detectPitchContourML };
+//# sourceMappingURL=note-detection-PPLM7R2H.js.map
+//# sourceMappingURL=note-detection-PPLM7R2H.js.map

package/dist/note-detection-PPLM7R2H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/daw/utils/note-detection.ts"],"names":[],"mappings":"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","file":"note-detection-PPLM7R2H.js","sourcesContent":["/**\n * Note detection utility — wraps @spotify/basic-pitch for polyphonic\n * audio-to-MIDI transcription. Handles resampling to the required 22050 Hz.\n *\n * Two modes:\n *   detectNotes()              — quantised NoteEvent[] (sampler, piano roll)\n *   detectPitchContourML()     — continuous sub-semitone PitchFrame[] from the\n *                                raw 264-bin contour matrix (~86 fps), resampled\n *                                to match YIN hop rate for the autotune pipeline.\n *\n * Post-processing: consecutive notes of the EXACT same pitch that are\n * back-to-back (overlapping or tiny gap) get merged into one longer note.\n * Everything else is left alone so polyphonic content stays intact.\n */\n\nimport type { NoteEvent } from '../store/sampler-store';\n\nconst BASIC_PITCH_SR = 22050;\nconst BP_FFT_HOP = 256;\nconst BP_ANNOTATIONS_FPS = Math.floor(BASIC_PITCH_SR / BP_FFT_HOP); // ~86\nconst BP_CONTOURS_BINS_PER_SEMITONE = 3;\nconst BP_ANNOTATIONS_N_SEMITONES = 88;\nconst BP_N_FREQ_BINS = BP_ANNOTATIONS_N_SEMITONES * BP_CONTOURS_BINS_PER_SEMITONE; // 264\nconst BP_MIDI_OFFSET = 21; // A0\nconst BP_BASE_FREQ = 27.5;\n\nexport interface PitchFrameML {\n    time: number;\n    freq: number;\n    rms: number;\n    midi: number;\n    frameIndex: number;\n}\n\nfunction resampleBuffer(buffer: AudioBuffer, targetSR: number): Promise<AudioBuffer> {\n    const offlineCtx = new OfflineAudioContext(1, Math.ceil(buffer.duration * targetSR), targetSR);\n    const source = offlineCtx.createBufferSource();\n    source.buffer = buffer;\n    source.connect(offlineCtx.destination);\n    source.start();\n    return offlineCtx.startRendering();\n}\n\n/**\n * Merge consecutive notes of the EXACT same pitch when they overlap\n * or the gap between them is ≤ maxGapSec. Different pitches are never merged.\n */\nfunction mergeSamePitchNotes(notes: NoteEvent[], maxGapSec: number = 0.05): NoteEvent[] {\n    if (notes.length === 0) return notes;\n\n    const byPitch = new Map<number, NoteEvent[]>();\n    for (const n of notes) {\n        let arr = byPitch.get(n.pitchMidi);\n        if (!arr) { arr = []; byPitch.set(n.pitchMidi, arr); }\n        arr.push({ ...n });\n    }\n\n    const result: NoteEvent[] = [];\n\n    for (const [, group] of byPitch) {\n        group.sort((a, b) => a.startTimeSeconds - b.startTimeSeconds);\n\n        let cur = group[0];\n        for (let i = 1; i < group.length; i++) {\n            const next = group[i];\n            const curEnd = cur.startTimeSeconds + cur.durationSeconds;\n\n            if (next.startTimeSeconds <= curEnd + maxGapSec) {\n                const nextEnd = next.startTimeSeconds + next.durationSeconds;\n                cur.durationSeconds = Math.max(curEnd, nextEnd) - cur.startTimeSeconds;\n                cur.amplitude = Math.max(cur.amplitude, next.amplitude);\n            } else {\n                result.push(cur);\n                cur = next;\n            }\n        }\n        result.push(cur);\n    }\n\n    result.sort((a, b) => a.startTimeSeconds - b.startTimeSeconds);\n    return result;\n}\n\nasync function runBasicPitchModel(buffer: AudioBuffer): Promise<{ frames: number[][]; onsets: number[][]; contours: number[][] }> {\n    const { BasicPitch } = await import('@spotify/basic-pitch');\n\n    const inputBuffer = buffer.sampleRate !== BASIC_PITCH_SR\n        ? await resampleBuffer(buffer, BASIC_PITCH_SR)\n        : buffer;\n\n    const modelUrl = '/models/basic-pitch/model.json';\n    const basicPitch = new BasicPitch(modelUrl);\n\n    const frames: number[][] = [];\n    const onsets: number[][] = [];\n    const contours: number[][] = [];\n\n    await basicPitch.evaluateModel(\n        inputBuffer,\n        (f: number[][], o: number[][], c: number[][]) => {\n            frames.push(...f);\n            onsets.push(...o);\n            contours.push(...c);\n        },\n        () => {},\n    );\n\n    return { frames, onsets, contours };\n}\n\nexport async function detectNotes(buffer: AudioBuffer): Promise<NoteEvent[]> {\n    const {\n        addPitchBendsToNoteEvents,\n        noteFramesToTime,\n        outputToNotesPoly,\n    } = await import('@spotify/basic-pitch');\n\n    const { frames, onsets, contours } = await runBasicPitchModel(buffer);\n\n    const rawNotes = outputToNotesPoly(frames, onsets);\n\n    const noteEvents = noteFramesToTime(\n        addPitchBendsToNoteEvents(contours, rawNotes),\n    );\n\n    return mergeSamePitchNotes(noteEvents, 0.05);\n}\n\n/**\n * Run Basic Pitch and extract a continuous pitch contour from the raw\n * contour activation matrix. Each contour frame has 264 bins (3 per\n * semitone × 88 piano keys). We find the peak bin, refine with\n * parabolic interpolation for sub-bin accuracy, and convert to Hz/MIDI.\n *\n * The result is resampled to match the YIN hop rate (targetHop samples\n * at the original sampleRate) so it plugs directly into the autotune\n * correction pipeline.\n */\nexport async function detectPitchContourML(\n    buffer: AudioBuffer,\n    targetHop: number = 1024,\n    onProgress?: (pct: number, msg: string) => void,\n): Promise<PitchFrameML[]> {\n    onProgress?.(0.05, 'Loading Basic Pitch model…');\n    const { frames, contours } = await runBasicPitchModel(buffer);\n    onProgress?.(0.6, `Model complete — ${contours.length} contour frames`);\n\n    const ACTIVATION_THRESHOLD = 0.12;\n\n    // Extract dominant pitch per contour frame at ~86fps\n    const bpFrames: { timeSec: number; midi: number; freq: number; confidence: number }[] = [];\n    for (let t = 0; t < contours.length; t++) {\n        const row = contours[t];\n        const frameRow = frames[t];\n\n        // Find peak bin in contour row\n        let peakBin = -1;\n        let peakVal = ACTIVATION_THRESHOLD;\n        for (let b = 0; b < row.length; b++) {\n            if (row[b] > peakVal) { peakVal = row[b]; peakBin = b; }\n        }\n\n        if (peakBin < 0) {\n            bpFrames.push({ timeSec: t / BP_ANNOTATIONS_FPS, midi: -1, freq: -1, confidence: 0 });\n            continue;\n        }\n\n        // Check that the corresponding frames activation is also reasonably high\n        const semitoneIdx = Math.floor(peakBin / BP_CONTOURS_BINS_PER_SEMITONE);\n        const frameActivation = semitoneIdx < frameRow.length ? frameRow[semitoneIdx] : 0;\n        if (frameActivation < 0.15) {\n            bpFrames.push({ timeSec: t / BP_ANNOTATIONS_FPS, midi: -1, freq: -1, confidence: 0 });\n            continue;\n        }\n\n        // Parabolic interpolation for sub-bin accuracy\n        let refinedBin = peakBin;\n        if (peakBin > 0 && peakBin < row.length - 1) {\n            const s0 = row[peakBin - 1], s1 = row[peakBin], s2 = row[peakBin + 1];\n            const denom = 2 * (s0 - 2 * s1 + s2);\n            if (Math.abs(denom) > 1e-8) {\n                refinedBin = peakBin + (s0 - s2) / denom;\n            }\n        }\n\n        // Convert bin → MIDI (continuous, sub-semitone)\n        const midi = BP_MIDI_OFFSET + refinedBin / BP_CONTOURS_BINS_PER_SEMITONE;\n        const freq = BP_BASE_FREQ * Math.pow(2, refinedBin / (12 * BP_CONTOURS_BINS_PER_SEMITONE));\n\n        bpFrames.push({ timeSec: t / BP_ANNOTATIONS_FPS, midi, freq, confidence: peakVal });\n    }\n\n    onProgress?.(0.8, 'Resampling to target hop rate…');\n\n    // Resample from ~86fps to the target hop rate at the original sample rate\n    const origSR = buffer.sampleRate;\n    const totalSamples = buffer.length;\n    const yinWindow = 1024;\n    const numTargetFrames = Math.floor((totalSamples - yinWindow) / targetHop);\n    const result: PitchFrameML[] = [];\n\n    for (let f = 0; f < numTargetFrames; f++) {\n        const timeSec = (f * targetHop) / origSR;\n        // Find the closest Basic Pitch frame\n        const bpIdx = Math.round(timeSec * BP_ANNOTATIONS_FPS);\n        if (bpIdx >= 0 && bpIdx < bpFrames.length) {\n            const bp = bpFrames[bpIdx];\n            result.push({\n                time: timeSec,\n                freq: bp.freq,\n                rms: bp.confidence,\n                midi: bp.midi,\n                frameIndex: f,\n            });\n        } else {\n            result.push({ time: timeSec, freq: -1, rms: 0, midi: -1, frameIndex: f });\n        }\n    }\n\n    onProgress?.(1.0, `${result.length} frames (${result.filter(f => f.midi > 0).length} voiced)`);\n    return result;\n}\n"]}

package/dist/sampler-audio-B7MBG3YN.js

@@ -0,0 +1,3 @@
+export { extractRegion, fracBarToSample, renderPianoRollAsync, renderSequence, renderSequenceAsync, spliceBuffer } from './chunk-OFGZURP6.js';
+//# sourceMappingURL=sampler-audio-B7MBG3YN.js.map
+//# sourceMappingURL=sampler-audio-B7MBG3YN.js.map

package/dist/sampler-audio-B7MBG3YN.js.map

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

package/dist/sampler-store-QPHANXYP.js

@@ -0,0 +1,3 @@
+export { pianoRollTotalSteps, useSamplerStore } from './chunk-QQ5NZTHT.js';
+//# sourceMappingURL=sampler-store-QPHANXYP.js.map
+//# sourceMappingURL=sampler-store-QPHANXYP.js.map

package/dist/sampler-store-QPHANXYP.js.map

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

package/dist/services/track-search-api.d.ts

@@ -0,0 +1,152 @@
+import { a as IMusicKey, b as IMusicTonality, I as ITrackForSequence } from '../interface-DaRj7RkY.js';
+
+/**
+ * Track search & single-track loading for the DAW.
+ *
+ * Uses the same GraphQL endpoint as the streaming player but provides
+ * a simplified interface for searching and loading individual tracks
+ * (not full mixes).
+ *
+ * Also provides "similar tracks" from the same station (refresh-mix style)
+ * for the suggested stems sidebar.
+ */
+
+type SimilarityMode = 'feature' | 'remix';
+declare const SIMILARITY_MODES: {
+    id: SimilarityMode;
+    label: string;
+    description: string;
+}[];
+interface SearchResult {
+    id: string;
+    title: string;
+    artist: string;
+    artwork: string | null;
+    artworkGlowColor: string | null;
+    type: string;
+}
+interface TrackMusicalInfo {
+    bpm: number;
+    key: IMusicKey;
+    tonality: IMusicTonality;
+}
+interface CompatibilityScore {
+    bpmPct: number;
+    keyScore: number;
+    overall: number;
+    camelotTag: string;
+    bpmLabel: string;
+}
+declare function getCamelotTag(key: IMusicKey, tonality: IMusicTonality): string;
+declare function computeCompatibility(ref: TrackMusicalInfo, track: TrackMusicalInfo): CompatibilityScore;
+declare function fetchTrackMusicalInfo(trackId: string): Promise<TrackMusicalInfo | null>;
+/**
+ * Read-through accessor for the segment + duration metadata captured
+ * alongside bpm/key. Returns `null` if the beats endpoint hasn't yet
+ * resolved for this track; callers (e.g. the song-preview controller)
+ * should either await `fetchTrackMusicalInfo` first or treat `null`
+ * as "fall back to a default preview offset".
+ */
+declare function fetchTrackSegmentInfo(trackId: string): Promise<{
+    segmentInfo: [number, number, number][];
+    durationSec: number | null;
+} | null>;
+declare function isMixUrl(input: string): boolean;
+declare function isSessionTrackUrl(input: string): boolean;
+declare function isStemUrl(input: string): boolean;
+declare function fetchTracksFromMixUrl(url: string): Promise<SearchResult[]>;
+declare function fetchTracksFromSessionUrl(url: string): Promise<SearchResult[]>;
+declare function searchTracks(query: string, limit?: number, offset?: number): Promise<SearchResult[]>;
+interface TrackPreviewSources {
+    durationSec: number | null;
+    /** Multi-track fMP4 URL — the same source the DAW loader uses. We
+     *  byte-range a few segments out of this for the chorus preview. */
+    mp4Url: string | null;
+}
+declare function fetchTrackPreviewSources(trackId: string): Promise<TrackPreviewSources | null>;
+declare function fetchTrackForDAW(trackId: string): Promise<ITrackForSequence>;
+/**
+ * Fetches sonically similar tracks for a given track ID using the
+ * Feature API's /searchfeatures endpoint (PCA-based audio similarity).
+ *
+ * Tries UUID-based fingerprint lookup first. If the track doesn't have
+ * pre-indexed features (common for freshly loaded tracks), falls back
+ * to a text query using the track's title/artist from the DAW session.
+ */
+declare function fetchSimilarTracksByFeature(trackId: string, limit?: number): Promise<SearchResult[]>;
+/**
+ * Backend candidate-selection strategy. Maps 1:1 to the
+ * `SimilarTracksStrategy` enum on the GraphQL server.
+ *
+ *   • `cube_rank` (default, "Loose pool")
+ *       No hard filter on key/tempo. Ranks by torus cube distance with
+ *       optional embedding-cosine blend (`embeddingWeight`). Today's
+ *       behaviour when no `strategy` arg is passed.
+ *
+ *   • `embedding_rank_with_bbox` ("Strict pool")
+ *       Filters candidates to a ±N-semitone / ±M% bar-size bbox around
+ *       the seed, then ranks survivors by audio-embedding cosine. The
+ *       bbox knobs and `cubeWeight` only do anything in this mode.
+ */
+type SimilarTracksStrategy = 'cube_rank' | 'embedding_rank_with_bbox';
+/**
+ * Slim subset of `SimilarTracksRankingInput` we actually surface in the
+ * UI. The full input has 13 fields; the rest either redistribute the
+ * engagement budget internally (the five `*Share` fields) or have
+ * strategy-aware server defaults that are hard to expose meaningfully
+ * (`cubeWeight`, `embeddingWeight`, the bbox knobs). Anything not in
+ * this type stays on the server-side default.
+ *
+ * EVERY field is optional. The service strips unset fields before
+ * serialising so an untouched request remains byte-identical to the
+ * pre-tuning behaviour — important because production GQL introspection
+ * is disabled and we can't be 100% certain it's on the same schema rev
+ * as staging.
+ */
+interface SimilarTracksRanking {
+    /**
+     * Master gain on the engagement bonus. 0 = pure musical similarity,
+     * 1 = server default, 2 = strongly favour popular tracks. Clamped
+     * server-side to [0, 2].
+     */
+    collaborativeStrength?: number;
+    /**
+     * Absolute weight on the binary genre-overlap signal. 0 = ignore
+     * genre, server default ~0.5 in cube_rank.
+     */
+    genreWeight?: number;
+    /**
+     * Inject the caller's liked tracks into the candidate pool. Server
+     * default is `true`.
+     */
+    prioritizeUserLikes?: boolean;
+}
+/**
+ * Aggregate args passed to `fetchSimilarTracksByRemix`. Anything left
+ * `undefined` is omitted from the GraphQL variables list so the server
+ * picks its own defaults.
+ */
+interface SimilarTracksQueryArgs {
+    strategy?: SimilarTracksStrategy;
+    ranking?: SimilarTracksRanking;
+}
+/**
+ * Fetches similar tracks by key/BPM/features using the similarTracks
+ * query. No pseudo-mix creation needed — queries directly from a target track.
+ *
+ * `excludeTrackIds` filters out tracks already in the session.
+ *
+ * `args` is optional and lets callers pass strategy / ranking overrides
+ * sourced from the session store (see `selectSimilarTracksQueryArgs`).
+ * When `args` is omitted entirely, the outgoing GraphQL variables are
+ * byte-identical to the pre-tuning behaviour.
+ */
+declare function fetchSimilarTracksByRemix(trackId: string, limit?: number, excludeTrackIds?: string[], offset?: number, args?: SimilarTracksQueryArgs): Promise<SearchResult[]>;
+/**
+ * Fetches similar tracks from the same station as the given mix URL.
+ * Uses the same "refresh mix" logic: next/prev mixes in the station.
+ * Returns lightweight previews suitable for the suggested stems sidebar.
+ */
+declare function fetchSimilarTracksFromStation(mixUrl: string, limit?: number): Promise<SearchResult[]>;
+
+export { type CompatibilityScore, SIMILARITY_MODES, type SearchResult, type SimilarTracksQueryArgs, type SimilarTracksRanking, type SimilarTracksStrategy, type SimilarityMode, type TrackMusicalInfo, type TrackPreviewSources, computeCompatibility, fetchSimilarTracksByFeature, fetchSimilarTracksByRemix, fetchSimilarTracksFromStation, fetchTrackForDAW, fetchTrackMusicalInfo, fetchTrackPreviewSources, fetchTrackSegmentInfo, fetchTracksFromMixUrl, fetchTracksFromSessionUrl, getCamelotTag, isMixUrl, isSessionTrackUrl, isStemUrl, searchTracks };

package/dist/services/track-search-api.js

@@ -0,0 +1,4 @@
+export { SIMILARITY_MODES, computeCompatibility, fetchSimilarTracksByFeature, fetchSimilarTracksByRemix, fetchSimilarTracksFromStation, fetchTrackForDAW, fetchTrackMusicalInfo, fetchTrackPreviewSources, fetchTrackSegmentInfo, fetchTracksFromMixUrl, fetchTracksFromSessionUrl, getCamelotTag, isMixUrl, isSessionTrackUrl, isStemUrl, searchTracks } from '../chunk-56PWIP7O.js';
+import '../chunk-TBXCZFAY.js';
+//# sourceMappingURL=track-search-api.js.map
+//# sourceMappingURL=track-search-api.js.map

package/dist/services/track-search-api.js.map

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

package/dist/store/daw-auth-store.d.ts

@@ -0,0 +1,31 @@
+import * as zustand_middleware from 'zustand/middleware';
+import * as zustand from 'zustand';
+
+/**
+ * DAW Auth Store — NDA gate state.
+ *
+ * Tracks whether the user has accepted the beta NDA.
+ * Persisted to localStorage so they only see the gate once per browser.
+ */
+interface DAWAuthState {
+    ndaAccepted: boolean;
+    acceptNDA: () => void;
+    logout: () => void;
+}
+declare const useDAWAuthStore: zustand.UseBoundStore<Omit<zustand.StoreApi<DAWAuthState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<DAWAuthState, {
+            ndaAccepted: boolean;
+        }>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: DAWAuthState) => void) => () => void;
+        onFinishHydration: (fn: (state: DAWAuthState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<DAWAuthState, {
+            ndaAccepted: boolean;
+        }>>;
+    };
+}>;
+
+export { useDAWAuthStore };

package/dist/store/daw-auth-store.js

@@ -0,0 +1,3 @@
+export { useDAWAuthStore } from '../chunk-UKMELGZL.js';
+//# sourceMappingURL=daw-auth-store.js.map
+//# sourceMappingURL=daw-auth-store.js.map

package/dist/store/daw-auth-store.js.map

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

package/dist/store/daw-session-store.d.ts

@@ -0,0 +1,255 @@
+import * as zustand from 'zustand';
+import { P as PitchEngineSettings, ac as StemEffects, d as DAWSession, b as DAWToolMode, S as StemId, c as StemSelectionRange, i as ClipboardEntry, D as DAWTrack, f as SessionNote, I as IBeat, M as MuteRegion, R as ResampledRegion, k as DAWChannel } from '../interfaces-5ZlG0Y4Y.js';
+import { I as ITrackForSequence } from '../interface-DaRj7RkY.js';
+import { SimilarTracksQueryArgs } from '../services/track-search-api.js';
+
+/**
+ * DAW Cache Layer
+ *
+ * Two tiers:
+ * 1. localStorage — lightweight session state (track layout, positions, mute regions, etc.)
+ * 2. IndexedDB    — heavy audio data (raw fMP4 ArrayBuffers) keyed by URL
+ *
+ * Normal refresh restores from cache. Hard refresh (Ctrl+Shift+R) clears the
+ * in-memory singleton and falls through to a fresh load when localStorage is
+ * still present. Call `clearAll()` to nuke everything.
+ *
+ * Project files (.stem-project) wrap PersistedSession with version + timestamps
+ * for portable save/load across machines.
+ */
+
+interface PersistedTrack {
+    /** The original `trackData` needed to re-add via controller */
+    trackDataJson: string;
+    /** Channel layout to restore after audio is loaded */
+    channels: PersistedChannel[];
+    volume: number;
+    muted: boolean;
+    soloed: boolean;
+    expanded: boolean;
+    /** Display metadata (persisted so project files are self-describing) */
+    color?: string;
+    artwork?: string;
+    displayName?: string;
+    artistName?: string;
+    /** User transpose offset in semitones */
+    transposeSemitones?: number;
+    /** Pitch engine configuration */
+    pitchSettings?: PitchEngineSettings;
+    /** Per-bar pitch compensation for quantized speed changes */
+    perBarPitchCompensation?: boolean;
+    /** Beat grid offset in beats (fractional) */
+    beatGridOffsetBeats?: number;
+}
+interface PersistedChannel {
+    stemIndex: number;
+    volume: number;
+    muted: boolean;
+    soloed: boolean;
+    visible: boolean;
+    timelineStartBar: number;
+    trimStartBar: number;
+    trimEndBar: number;
+    muteRegions: {
+        startBar: number;
+        endBar: number;
+    }[];
+    resampledRegions?: {
+        startBar: number;
+        endBar: number;
+        sliceCount: number;
+    }[];
+    effects?: StemEffects;
+}
+
+/** The portion of state that we snapshot for undo/redo. */
+interface UndoableSnapshot {
+    tracks: DAWTrack[];
+    masterTempo: number;
+    originalTempo: number;
+    masterBarLength48000: number;
+    loopRegion: {
+        startBar: number;
+        endBar: number;
+    } | null;
+    mixName: string;
+    notes: SessionNote[];
+}
+interface DAWSessionState extends DAWSession {
+    setMixName: (name: string) => void;
+    toolMode: DAWToolMode;
+    setToolMode: (mode: DAWToolMode) => void;
+    /**
+     * "Composite View" — purely a render flag. When true, every track's
+     * channels collapse to a single shared 4-stem strip on the timeline:
+     * all stem-0 lanes share one Y, all stem-1 lanes the next, etc. The
+     * canvas naturally layers their waveforms so the user can see the
+     * whole arrangement at a glance. Audio routing, mute/solo/transpose
+     * state, and the underlying tracks list are completely untouched.
+     *
+     * Interactive editing (drag-trim, marquee select, slice, drag-move)
+     * is disabled while composite view is on — switch it off to edit.
+     */
+    compositeView: boolean;
+    setCompositeView: (on: boolean) => void;
+    toggleCompositeView: () => void;
+    /**
+     * User-facing tuning for the `similarTracks` GraphQL query, shared
+     * by the Add-Track modal and the Similar-Tracks sidebar so changes
+     * in one re-fire the fetch in the other.
+     *
+     * Two independent axes, each shown as a DJ-style tick fader:
+     *
+     *   • `balance` — 0..1, default 0.5 (centre = "use both equally").
+     *       Drives `genreWeight` as `1 - balance`, so:
+     *         balance 0   → genreWeight 1  (all musicality, tight genre)
+     *         balance 0.5 → no override (server default)
+     *         balance 1   → genreWeight 0  (all vibe, ignore genre)
+     *
+     *   • `popularity` — 0..2, default 1 (centre = server default).
+     *       Drives `collaborativeStrength` directly:
+     *         popularity 0 → no engagement boost (deep cuts)
+     *         popularity 1 → no override
+     *         popularity 2 → max engagement boost (mainstream)
+     *
+     * When both knobs are at their defaults the outgoing GraphQL
+     * variables are byte-identical to the pre-tuning shape (no
+     * `ranking` arg at all).
+     */
+    similarTracksBalance: number;
+    similarTracksPopularity: number;
+    /** Clamped internally to [0, 1]. */
+    setSimilarTracksBalance: (v: number) => void;
+    /** Clamped internally to [0, 2]. */
+    setSimilarTracksPopularity: (v: number) => void;
+    /** Restore both knobs to their untouched/default position. */
+    resetSimilarTracksTuning: () => void;
+    /** Build the GraphQL args object — `undefined` fields are dropped server-side. */
+    getSimilarTracksQueryArgs: () => SimilarTracksQueryArgs;
+    selectedStem: StemId | null;
+    setSelectedStem: (stem: StemId | null) => void;
+    /**
+     * Multi-stem selections. All entries must share the same `trackId`
+     * (selections are scoped to a single track at a time). Adding a range on
+     * a different track replaces the entire set.
+     */
+    selections: StemSelectionRange[];
+    setSelections: (ranges: StemSelectionRange[]) => void;
+    addSelection: (range: StemSelectionRange) => void;
+    clearSelections: () => void;
+    /**
+     * Compatibility shim: the "primary" (first) selection. Reading this
+     * surfaces the first selection range; writing replaces the entire set
+     * with either zero or one range. Prefer `selections` for new code.
+     */
+    selectionRange: StemSelectionRange | null;
+    setSelectionRange: (range: StemSelectionRange | null) => void;
+    /**
+     * Multi-stem clipboard. All entries are expected to share a `trackId`
+     * (copies a snapshot of one or more stems from a single track).
+     */
+    clipboardEntries: ClipboardEntry[];
+    setClipboardEntries: (entries: ClipboardEntry[]) => void;
+    /** Compatibility shim: the first clipboard entry, or null. */
+    clipboard: ClipboardEntry | null;
+    setClipboard: (entry: ClipboardEntry | null) => void;
+    _undoStack: UndoableSnapshot[];
+    _redoStack: UndoableSnapshot[];
+    /** Push current state onto the undo stack (call BEFORE making the change). */
+    pushUndo: () => void;
+    undo: () => void;
+    redo: () => void;
+    canUndo: () => boolean;
+    canRedo: () => boolean;
+    addTrack: (trackData: ITrackForSequence) => DAWTrack;
+    removeTrack: (trackId: string) => void;
+    reorderTrack: (trackId: string, newIndex: number) => void;
+    /**
+     * Tracks that exist in the persisted session but haven't been
+     * decoded into the live timeline yet. Populated by
+     * `restoreSession` when `eagerLoadCount` is smaller than the
+     * persisted tracks list; surfaced in the timeline so the user
+     * can opt-in to load them one-by-one (or all at once) instead of
+     * paying the full multi-track decode cost on refresh.
+     *
+     * These are NOT included in undo snapshots — promoting a
+     * pending track to a live track is a side-effecting load, not a
+     * structural edit, so the undo stack stays focused on
+     * user-driven timeline state.
+     */
+    pendingTracks: PersistedTrack[];
+    /** Replace the entire pending list (used by restoreSession). */
+    setPendingTracks: (tracks: PersistedTrack[]) => void;
+    /** Append more pending tracks to the existing queue. */
+    addPendingTracks: (tracks: PersistedTrack[]) => void;
+    /** Remove a single pending track by index — called after the
+     *  promote-to-live action has finished loading audio. */
+    removePendingTrackAt: (index: number) => void;
+    /** Drop all pending tracks (used when the user clears the session). */
+    clearPendingTracks: () => void;
+    setStemTimelineStart: (trackId: string, stemIndex: number, bar: number) => void;
+    setStemTrim: (trackId: string, stemIndex: number, trimStart: number, trimEnd: number) => void;
+    /** Move all stems of a track together */
+    setTrackTimelineStart: (trackId: string, bar: number) => void;
+    /** Trim all stems of a track together */
+    setTrackTrim: (trackId: string, trimStart: number, trimEnd: number) => void;
+    setPlaying: (playing: boolean) => void;
+    setPlayheadBar: (bar: number) => void;
+    setMasterTempo: (bpm: number) => void;
+    setGlobalPlaybackRate: (rate: number) => void;
+    setLoopRegion: (region: {
+        startBar: number;
+        endBar: number;
+    } | null) => void;
+    setBarSubdivisions: (n: number) => void;
+    /** Add a fully-formed note. Returns its id. Pushes undo. */
+    addNote: (note: Omit<SessionNote, 'id' | 'createdAt'>) => string;
+    /** Patch a subset of a note's fields. No-op if id is unknown. Pushes undo. */
+    updateNote: (id: string, patch: Partial<Omit<SessionNote, 'id' | 'createdAt'>>) => void;
+    /** Remove a note by id. No-op if id is unknown. Pushes undo. */
+    removeNote: (id: string) => void;
+    setTrackVolume: (trackId: string, volume: number) => void;
+    setTrackMuted: (trackId: string, muted: boolean) => void;
+    setTrackSoloed: (trackId: string, soloed: boolean) => void;
+    setTrackExpanded: (trackId: string, expanded: boolean) => void;
+    setChannelVolume: (trackId: string, stemIndex: number, volume: number) => void;
+    setChannelMuted: (trackId: string, stemIndex: number, muted: boolean) => void;
+    setChannelSoloed: (trackId: string, stemIndex: number, soloed: boolean) => void;
+    setChannelVisible: (trackId: string, stemIndex: number, visible: boolean) => void;
+    setChannelEffects: (trackId: string, stemIndex: number, effects: StemEffects) => void;
+    setTrackTranspose: (trackId: string, semitones: number) => void;
+    setTrackPitchSettings: (trackId: string, settings: PitchEngineSettings) => void;
+    setPerBarPitchCompensation: (trackId: string, enabled: boolean) => void;
+    /** Shift a track's beat grid by a fractional beat amount (recomputes barMapping) */
+    setTrackBeatGridOffset: (trackId: string, offsetBeats: number) => void;
+    /** Replace a track's raw beats array and recompute its bar mapping (used by Beats Lab model switching) */
+    replaceTrackBeats: (trackId: string, newBeats: IBeat[]) => void;
+    addMuteRegion: (trackId: string, stemIndex: number, region: MuteRegion) => void;
+    removeMuteRegion: (trackId: string, stemIndex: number, regionIndex: number) => void;
+    clearMuteRegions: (trackId: string, stemIndex: number) => void;
+    /** Replace all mute regions at once without pushing undo (for live drag previews). */
+    setMuteRegionsBatch: (trackId: string, stemIndex: number, regions: MuteRegion[]) => void;
+    /** Split a stem at a bar position — creates two mute-region-free halves by inserting a mute at the cut point */
+    splitStemAtBar: (trackId: string, stemIndex: number, bar: number) => void;
+    /**
+     * Add a single split point at the given local bar (relative to track
+     * barMapping). Pushes undo. No-op if the bar is outside the trim window
+     * or already a split point (within 0.001-bar tolerance).
+     */
+    addSplitPoint: (trackId: string, stemIndex: number, localBar: number) => void;
+    /**
+     * Replace the entire splitPoints array. Used for batch slicing
+     * (every-bar / every-beat / every-section) and for undo restore.
+     * Pushes undo when `pushUndo` is true.
+     */
+    setSplitPointsBatch: (trackId: string, stemIndex: number, points: number[], pushUndo?: boolean) => void;
+    /** Clear all split points on a stem. Pushes undo. */
+    clearSplitPoints: (trackId: string, stemIndex: number) => void;
+    addResampledRegion: (trackId: string, stemIndex: number, region: ResampledRegion) => void;
+    getTimelineLength: () => number;
+    getTrackById: (trackId: string) => DAWTrack | undefined;
+    getChannel: (trackId: string, stemIndex: number) => DAWChannel | undefined;
+}
+declare const useDAWSessionStore: zustand.UseBoundStore<zustand.StoreApi<DAWSessionState>>;
+
+export { useDAWSessionStore };