@kano/stem-daw 0.1.0

package/dist/chunk-KCOOE2OP.js

@@ -0,0 +1,1764 @@
+import { create } from 'zustand';
+import { v4 } from 'uuid';
+
+// src/daw/store/daw-session-store.ts
+
+// src/daw/interfaces.ts
+var DEFAULT_PITCH_SETTINGS = {
+  formantOption: "shifted",
+  pitchOption: "highConsistency",
+  engineOption: "faster",
+  pitchDelayMs: 74
+};
+var stemIdKey = (s) => `${s.trackId}:${s.stemIndex}`;
+function getSelectionBoundsBars(selections) {
+  if (selections.length === 0) return null;
+  const trackId = selections[0].trackId;
+  let startBar = Infinity;
+  let endBar = -Infinity;
+  const stemIndexes = /* @__PURE__ */ new Set();
+  for (const s of selections) {
+    if (s.startBar < startBar) startBar = s.startBar;
+    if (s.endBar > endBar) endBar = s.endBar;
+    stemIndexes.add(s.stemIndex);
+  }
+  return { trackId, startBar, endBar, stemIndexes: Array.from(stemIndexes).sort((a, b) => a - b) };
+}
+var parseStemIdKey = (key) => {
+  const [trackId, idx] = key.split(":");
+  const stemIndex = parseInt(idx, 10);
+  return trackId && !isNaN(stemIndex) ? { trackId, stemIndex } : null;
+};
+var NOTE_COLORS = [
+  "#F5C518",
+  // amber
+  "#FF6D00",
+  // orange
+  "#EF4444",
+  // red
+  "#EC4899",
+  // pink
+  "#8B5CF6",
+  // violet
+  "#3B82F6",
+  // blue
+  "#14B8A6",
+  // teal
+  "#22C55E"
+  // green
+];
+var NOTE_EMOJI_PALETTE = [
+  "\u{1F3AF}",
+  "\u{1F496}",
+  "\u{1F525}",
+  "\u2B50",
+  "\u26A1",
+  "\u{1F3B5}",
+  "\u{1F4A1}",
+  "\u2728",
+  "\u{1F680}",
+  "\u{1F3A4}"
+];
+function computeClips(ch) {
+  const clips = [];
+  const sorted = [...ch.muteRegions].sort((a, b) => a.startBar - b.startBar);
+  const splits = (ch.splitPoints ?? []).filter((p) => p > ch.trimStartBar && p < ch.trimEndBar).sort((a, b) => a - b);
+  let cursor = ch.trimStartBar;
+  const pushRange = (lo, hi, leftEdge, rightEdge) => {
+    if (hi <= lo) return;
+    let segStart = lo;
+    let segLeftEdge = leftEdge;
+    for (const sp of splits) {
+      if (sp <= segStart) continue;
+      if (sp >= hi) break;
+      clips.push({
+        sourceStartBar: segStart,
+        sourceEndBar: sp,
+        timelineBar: ch.timelineStartBar + segStart,
+        leftEdge: segLeftEdge,
+        rightEdge: "split"
+      });
+      segStart = sp;
+      segLeftEdge = "split";
+    }
+    if (segStart < hi) {
+      clips.push({
+        sourceStartBar: segStart,
+        sourceEndBar: hi,
+        timelineBar: ch.timelineStartBar + segStart,
+        leftEdge: segLeftEdge,
+        rightEdge
+      });
+    }
+  };
+  for (const mr of sorted) {
+    const muteStart = Math.max(mr.startBar, ch.trimStartBar);
+    const muteEnd = Math.min(mr.endBar, ch.trimEndBar);
+    if (muteStart >= muteEnd) continue;
+    if (cursor < muteStart) {
+      const leftEdge = cursor === ch.trimStartBar ? "trim" : "mute";
+      pushRange(cursor, muteStart, leftEdge, "mute");
+    }
+    cursor = Math.max(cursor, muteEnd);
+  }
+  if (cursor < ch.trimEndBar) {
+    const leftEdge = cursor === ch.trimStartBar ? "trim" : "mute";
+    pushRange(cursor, ch.trimEndBar, leftEdge, "trim");
+  }
+  return clips;
+}
+var SEGMENT_TYPE = {
+  START: 0,
+  END: 1,
+  INTRO: 2,
+  OUTRO: 3,
+  BREAK: 4,
+  BRIDGE: 5,
+  INST: 6,
+  SOLO: 7,
+  VERSE: 8,
+  CHORUS: 9
+};
+var SEGMENT_LABELS = {
+  [SEGMENT_TYPE.START]: "Start",
+  [SEGMENT_TYPE.END]: "End",
+  [SEGMENT_TYPE.INTRO]: "Intro",
+  [SEGMENT_TYPE.OUTRO]: "Outro",
+  [SEGMENT_TYPE.BREAK]: "Break",
+  [SEGMENT_TYPE.BRIDGE]: "Bridge",
+  [SEGMENT_TYPE.INST]: "Inst",
+  [SEGMENT_TYPE.SOLO]: "Solo",
+  [SEGMENT_TYPE.VERSE]: "Verse",
+  [SEGMENT_TYPE.CHORUS]: "Chorus"
+};
+var SEGMENT_COLORS = {
+  [SEGMENT_TYPE.START]: "#6b7280",
+  [SEGMENT_TYPE.END]: "#6b7280",
+  [SEGMENT_TYPE.INTRO]: "#FFD600",
+  [SEGMENT_TYPE.OUTRO]: "#FFD600",
+  [SEGMENT_TYPE.BREAK]: "#f59e0b",
+  [SEGMENT_TYPE.BRIDGE]: "#06b6d4",
+  [SEGMENT_TYPE.INST]: "#14b8a6",
+  [SEGMENT_TYPE.SOLO]: "#f97316",
+  [SEGMENT_TYPE.VERSE]: "#3b82f6",
+  [SEGMENT_TYPE.CHORUS]: "#ef4444"
+};
+var STEM_LABELS = ["Other", "Vocals", "Bass", "Drums"];
+var STEM_TYPES = ["0_other", "1_vocals", "2_bass", "3_drums"];
+var STEM_COLORS = ["#FF1493", "#FF6D00", "#2979FF", "#FFEA00"];
+var STEM_BUFFER_KEYS = ["other", "vocals", "bass", "drums"];
+var createDefaultChannels = (timelineStartBar = 0, trimStartBar = 0, trimEndBar = 0) => STEM_TYPES.map((stemType, i) => ({
+  stemIndex: i,
+  stemType,
+  label: STEM_LABELS[i],
+  volume: 1,
+  muted: false,
+  soloed: false,
+  visible: true,
+  timelineStartBar,
+  trimStartBar,
+  trimEndBar,
+  muteRegions: []
+}));
+function segmentInfoToSections(segmentInfo, barMapping) {
+  if (!segmentInfo?.length || !barMapping?.length) return [];
+  const barTimestamps = barMapping.map((b) => b.sampleStart / 48e3);
+  const sections = [];
+  for (const [startTime, endTime, segType] of segmentInfo) {
+    let startBar = 0;
+    let endBar = barMapping.length;
+    for (let i = 0; i < barTimestamps.length; i++) {
+      if (barTimestamps[i] <= startTime + 0.01) startBar = i;
+    }
+    for (let i = barTimestamps.length - 1; i >= 0; i--) {
+      if (barTimestamps[i] >= endTime - 0.01) {
+        endBar = i;
+        break;
+      }
+    }
+    if (endBar <= startBar) endBar = startBar + 1;
+    sections.push({
+      type: segType,
+      label: SEGMENT_LABELS[segType] || `S${segType}`,
+      startBar,
+      endBar
+    });
+  }
+  return sections;
+}
+function findFirstSectionOfType(sections, preferredTypes = [SEGMENT_TYPE.CHORUS, SEGMENT_TYPE.VERSE, SEGMENT_TYPE.BRIDGE]) {
+  for (const t of preferredTypes) {
+    const found = sections.find((s) => s.type === t);
+    if (found) return found;
+  }
+  return sections.length > 0 ? sections[0] : null;
+}
+
+// src/daw/primitives/bar-utils.ts
+var SAMPLE_RATE = 48e3;
+function barToSample(bar, barMapping) {
+  if (barMapping.length === 0) return 0;
+  const floorBar = Math.floor(bar);
+  const frac = bar - floorBar;
+  if (floorBar >= barMapping.length) {
+    const last = barMapping[barMapping.length - 1];
+    return last.sampleStart + last.duration;
+  }
+  const entry = barMapping[Math.max(0, floorBar)];
+  return Math.round(entry.sampleStart + frac * entry.duration);
+}
+var downbeatsToBars = (downbeats) => {
+  const bars = [];
+  for (let i = 0; i < downbeats.length - 1; i++) {
+    const current = downbeats[i];
+    const next = downbeats[i + 1];
+    bars.push({
+      sampleStart: current.frame,
+      sampleEnd: next.frame - 1,
+      duration: next.frame - current.frame
+    });
+  }
+  return bars;
+};
+var composeBarsFromBeats = (beats) => {
+  const downbeats = beats.filter((b) => b.number === 1);
+  return downbeatsToBars(downbeats);
+};
+var smoothDownbeats = (downbeats, sampleRate = SAMPLE_RATE, threshold = 2500) => {
+  const N = downbeats.length;
+  let adjustedDownbeats = [];
+  let i = 0;
+  while (i < N) {
+    const sectionStart = i;
+    let sectionAdjustedDownbeats = [];
+    let meanInterval = 0;
+    sectionAdjustedDownbeats.push({
+      frame: downbeats[i].frame,
+      number: downbeats[i].number,
+      timestamp: downbeats[i].frame / sampleRate
+    });
+    let j = i + 1;
+    while (j <= N) {
+      const intervals = downbeats.slice(sectionStart, j).map(
+        (_, idx, arr) => idx > 0 ? arr[idx].frame - arr[idx - 1].frame : null
+      ).slice(1);
+      if (intervals.length > 0) {
+        meanInterval = Math.round(
+          intervals.filter((i2) => i2 !== null).reduce((a, b) => a + b) / intervals.length
+        );
+      }
+      const adjustedFrames = [];
+      for (let idx = 0; idx < j - sectionStart; idx++) {
+        adjustedFrames.push(downbeats[sectionStart].frame + meanInterval * idx);
+      }
+      let deviationsWithinThreshold = true;
+      for (let idx = 0; idx < adjustedFrames.length; idx++) {
+        const deviation = Math.abs(adjustedFrames[idx] - downbeats[sectionStart + idx].frame);
+        if (deviation > threshold) {
+          deviationsWithinThreshold = false;
+          break;
+        }
+      }
+      if (deviationsWithinThreshold) {
+        sectionAdjustedDownbeats = adjustedFrames.map((af, idx) => ({
+          frame: af,
+          number: downbeats[sectionStart + idx].number,
+          timestamp: af / sampleRate
+        }));
+        j++;
+      } else {
+        break;
+      }
+    }
+    adjustedDownbeats = adjustedDownbeats.concat(sectionAdjustedDownbeats);
+    i = sectionStart + sectionAdjustedDownbeats.length;
+  }
+  return adjustedDownbeats;
+};
+var composeBarsFromBeatsSmoothed = (beats, sampleRate = SAMPLE_RATE, threshold = 2500) => {
+  const downbeats = beats.filter((b) => b.number === 1);
+  const smoothed = smoothDownbeats(downbeats, sampleRate, threshold);
+  return downbeatsToBars(smoothed);
+};
+var resolveTimeOfDownbeatFromBarIndex = (beats, barIndex) => {
+  const beat = beats[barIndex];
+  return beat ? beat.timestamp : -1;
+};
+var resolveSampleLocOfDownbeatFromBarIndex = (beats, barIndex) => {
+  const beat = beats[barIndex];
+  return beat ? Math.floor(beat.timestamp * SAMPLE_RATE) : -1;
+};
+var medianBarDuration = (bars) => {
+  if (bars.length === 0) return 0;
+  const durations = bars.map((b) => b.duration).sort((a, b) => a - b);
+  const mid = Math.floor(durations.length / 2);
+  return durations.length % 2 !== 0 ? durations[mid] : (durations[mid - 1] + durations[mid]) / 2;
+};
+var barDurationToBpm = (barDurationSamples) => {
+  if (barDurationSamples <= 0) return 0;
+  const barDurationSeconds = barDurationSamples / SAMPLE_RATE;
+  const beatsPerBar = 4;
+  return beatsPerBar * 60 / barDurationSeconds;
+};
+var bpmToBarDuration = (bpm) => {
+  if (bpm <= 0) return 0;
+  const beatsPerBar = 4;
+  const barDurationSeconds = beatsPerBar * 60 / bpm;
+  return Math.round(barDurationSeconds * SAMPLE_RATE);
+};
+
+// src/daw/primitives/tempo-utils.ts
+var calculateTempoMatch = (masterBarLength, trackBarLength) => {
+  const possibleLengths = [
+    [masterBarLength / 2, 2],
+    [masterBarLength, 1],
+    [masterBarLength * 2, 0.5]
+  ];
+  let bestTarget = possibleLengths[1];
+  let bestDiff = Math.abs(masterBarLength - trackBarLength);
+  for (const candidate of possibleLengths) {
+    const diff = Math.abs(candidate[0] - trackBarLength);
+    if (diff < bestDiff) {
+      bestDiff = diff;
+      bestTarget = candidate;
+    }
+  }
+  return {
+    targetBarLength: bestTarget[0],
+    playbackRate: trackBarLength / bestTarget[0],
+    ratio: bestTarget[1]
+  };
+};
+var computeBarSpeedRatio = (barDurationSamples, targetBarLengthSamples, ratio) => {
+  return barDurationSamples / ratio / targetBarLengthSamples;
+};
+var playbackRateToSemitones = (playbackRate) => {
+  return 12 * Math.log2(playbackRate);
+};
+var semitonesToPitchFactor = (semitones) => {
+  return Math.pow(2, semitones / 12);
+};
+var keyToSemitones = {
+  A: 1,
+  "A#": 2,
+  B: 3,
+  C: 4,
+  "C#": 5,
+  D: 6,
+  "D#": 7,
+  E: 8,
+  F: 9,
+  "F#": 10,
+  G: 11,
+  "G#": 12
+};
+var semitonesToKey = Object.entries(keyToSemitones).reduce(
+  (acc, [key, value]) => {
+    acc[value] = key;
+    return acc;
+  },
+  {}
+);
+var convertKeyToRelativeMinor = (key, tonality) => {
+  let semitones = keyToSemitones[key];
+  if (tonality === "major") {
+    semitones = (semitones - 3 + 12) % 12 || 12;
+  }
+  return semitones;
+};
+var PitchShiftStrategy = /* @__PURE__ */ ((PitchShiftStrategy2) => {
+  PitchShiftStrategy2["DEFAULT"] = "DEFAULT";
+  PitchShiftStrategy2["PRESERVE_MIX_KEY"] = "PRESERVE_MIX_KEY";
+  PitchShiftStrategy2["MATCH_SEED_KEY"] = "MATCH_SEED_KEY";
+  PitchShiftStrategy2["NO_SHIFT"] = "NO_SHIFT";
+  PitchShiftStrategy2["KEY_PRESERVE"] = "KEY_PRESERVE";
+  return PitchShiftStrategy2;
+})(PitchShiftStrategy || {});
+var computePitchShift = (refKey, refTonality, refBarLength, trackKey, trackTonality, trackBarLength, strategy = "KEY_PRESERVE" /* KEY_PRESERVE */) => {
+  if (!refBarLength || !trackBarLength || isNaN(refBarLength) || isNaN(trackBarLength)) return 0;
+  const tempoMatch = calculateTempoMatch(refBarLength, trackBarLength);
+  const semitoneChangeFromTempo = playbackRateToSemitones(tempoMatch.playbackRate);
+  if (strategy === "NO_SHIFT" /* NO_SHIFT */) return 0;
+  if (strategy === "KEY_PRESERVE" /* KEY_PRESERVE */) return -semitoneChangeFromTempo;
+  const seedKeySemitones = convertKeyToRelativeMinor(refKey, refTonality);
+  const mixKeySemitones = convertKeyToRelativeMinor(trackKey, trackTonality);
+  if (strategy === "MATCH_SEED_KEY" /* MATCH_SEED_KEY */) {
+    let shift = seedKeySemitones - mixKeySemitones;
+    if (shift > 6) shift -= 12;
+    if (shift < -6) shift += 12;
+    return -semitoneChangeFromTempo + shift;
+  }
+  const adjustedMix = (mixKeySemitones + semitoneChangeFromTempo + 12) % 12 || 12;
+  const possibleMatches = [
+    seedKeySemitones,
+    (seedKeySemitones + 5) % 12 || 12,
+    (seedKeySemitones - 5 + 12) % 12 || 12
+  ];
+  const shifts = possibleMatches.map((match) => {
+    let s = match - adjustedMix;
+    if (s > 6) s -= 12;
+    if (s < -6) s += 12;
+    const totalChange = Math.abs(s + semitoneChangeFromTempo);
+    return {
+      shift: s,
+      weightedChange: match === seedKeySemitones ? totalChange * 1 : totalChange
+    };
+  });
+  const best = shifts.reduce(
+    (prev, curr) => curr.weightedChange < prev.weightedChange ? curr : prev
+  );
+  return best.shift;
+};
+var CAMELOT_MAP = {
+  "Ab_minor": { number: 1, letter: "A", label: "1A" },
+  "B_major": { number: 1, letter: "B", label: "1B" },
+  "Eb_minor": { number: 2, letter: "A", label: "2A" },
+  "F#_major": { number: 2, letter: "B", label: "2B" },
+  "Bb_minor": { number: 3, letter: "A", label: "3A" },
+  "Db_major": { number: 3, letter: "B", label: "3B" },
+  "F_minor": { number: 4, letter: "A", label: "4A" },
+  "Ab_major": { number: 4, letter: "B", label: "4B" },
+  "C_minor": { number: 5, letter: "A", label: "5A" },
+  "Eb_major": { number: 5, letter: "B", label: "5B" },
+  "G_minor": { number: 6, letter: "A", label: "6A" },
+  "Bb_major": { number: 6, letter: "B", label: "6B" },
+  "D_minor": { number: 7, letter: "A", label: "7A" },
+  "F_major": { number: 7, letter: "B", label: "7B" },
+  "A_minor": { number: 8, letter: "A", label: "8A" },
+  "C_major": { number: 8, letter: "B", label: "8B" },
+  "E_minor": { number: 9, letter: "A", label: "9A" },
+  "G_major": { number: 9, letter: "B", label: "9B" },
+  "B_minor": { number: 10, letter: "A", label: "10A" },
+  "D_major": { number: 10, letter: "B", label: "10B" },
+  "F#_minor": { number: 11, letter: "A", label: "11A" },
+  "A_major": { number: 11, letter: "B", label: "11B" },
+  "Db_minor": { number: 12, letter: "A", label: "12A" },
+  "E_major": { number: 12, letter: "B", label: "12B" }
+};
+var SHARP_TO_FLAT = {
+  "A#": "Bb",
+  "C#": "Db",
+  "D#": "Eb",
+  "F#": "F#",
+  "G#": "Ab"
+};
+var normaliseKeyForCamelot = (key) => {
+  return SHARP_TO_FLAT[key] ?? key;
+};
+var toCamelot = (key, tonality) => {
+  const normKey = normaliseKeyForCamelot(key);
+  const lookup = `${normKey}_${tonality}`;
+  return CAMELOT_MAP[lookup] ?? null;
+};
+var REVERSE_CAMELOT = {};
+for (const [k, v] of Object.entries(CAMELOT_MAP)) {
+  const [rawKey, tonality] = k.split("_");
+  const flatToSharp = {
+    "Bb": "A#",
+    "Db": "C#",
+    "Eb": "D#",
+    "Ab": "G#"
+  };
+  const musicKey = flatToSharp[rawKey] ?? rawKey;
+  REVERSE_CAMELOT[v.label] = { key: musicKey, tonality };
+}
+var camelotMatchType = (a, b) => {
+  const numDiff = Math.abs(a.number - b.number);
+  const wrappedDiff = numDiff === 11 ? 1 : numDiff;
+  if (a.number === b.number && a.letter === b.letter) return "exact";
+  if (a.number === b.number && a.letter !== b.letter) return "relative";
+  if (a.letter === b.letter && wrappedDiff === 1) return "adjacent";
+  if (a.letter !== b.letter && wrappedDiff === 1) return "diagonal";
+  return "none";
+};
+var transposeKey = (key, tonality, semitones) => {
+  const base = keyToSemitones[key];
+  const shifted = (base - 1 + semitones % 12 + 12) % 12 + 1;
+  return { key: semitonesToKey[shifted], tonality };
+};
+var computeTransposeSuggestions = (trackKey, trackTonality, otherTrackKeys) => {
+  if (otherTrackKeys.length === 0) return [];
+  const otherCamelots = otherTrackKeys.map((t) => toCamelot(t.key, t.tonality)).filter((c) => c !== null);
+  if (otherCamelots.length === 0) return [];
+  const refCamelot = otherCamelots[0];
+  const suggestions = [];
+  for (let st = -12; st <= 12; st++) {
+    const { key: rk, tonality: rt } = transposeKey(trackKey, trackTonality, st);
+    const rc = toCamelot(rk, rt);
+    if (!rc) continue;
+    const matchType = camelotMatchType(refCamelot, rc);
+    if (matchType === "none") continue;
+    const keyStr = `${rk}${rt === "minor" ? "m" : ""}`;
+    suggestions.push({
+      semitones: st,
+      resultKey: rk,
+      resultTonality: rt,
+      resultCamelot: rc,
+      matchType,
+      label: `${st > 0 ? "+" : ""}${st} \u2192 ${keyStr} (${rc.label})`
+    });
+  }
+  const order = { exact: 0, adjacent: 1, relative: 2, diagonal: 3, none: 4 };
+  suggestions.sort((a, b) => {
+    const od = order[a.matchType] - order[b.matchType];
+    if (od !== 0) return od;
+    return Math.abs(a.semitones) - Math.abs(b.semitones);
+  });
+  return suggestions;
+};
+
+// src/daw/engine/daw-cache.ts
+var SESSION_KEY = "daw-session-v1";
+async function deriveKey(password, salt) {
+  const enc = new TextEncoder();
+  const keyMaterial = await crypto.subtle.importKey(
+    "raw",
+    enc.encode(password),
+    "PBKDF2",
+    false,
+    ["deriveKey"]
+  );
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt, iterations: 1e5, hash: "SHA-256" },
+    keyMaterial,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+function bufToBase64(buf) {
+  return btoa(String.fromCharCode(...new Uint8Array(buf)));
+}
+function base64ToBuf(b64) {
+  const bin = atob(b64);
+  const buf = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) buf[i] = bin.charCodeAt(i);
+  return buf;
+}
+async function encryptPayload(json, password) {
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const key = await deriveKey(password, salt);
+  const ciphertext = await crypto.subtle.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    new TextEncoder().encode(json)
+  );
+  return {
+    salt: bufToBase64(salt),
+    iv: bufToBase64(iv),
+    ciphertext: bufToBase64(ciphertext)
+  };
+}
+async function decryptPayload(enc, password) {
+  const salt = base64ToBuf(enc.salt);
+  const iv = base64ToBuf(enc.iv);
+  const ciphertext = base64ToBuf(enc.ciphertext);
+  const key = await deriveKey(password, salt);
+  const plainBuf = await crypto.subtle.decrypt(
+    { name: "AES-GCM", iv },
+    key,
+    ciphertext
+  );
+  return new TextDecoder().decode(plainBuf);
+}
+function saveSession(session) {
+  try {
+    localStorage.setItem(SESSION_KEY, JSON.stringify(session));
+  } catch {
+  }
+}
+function loadSession() {
+  try {
+    const raw = localStorage.getItem(SESSION_KEY);
+    if (!raw) return null;
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function clearSession() {
+  try {
+    localStorage.removeItem(SESSION_KEY);
+  } catch {
+  }
+}
+var DB_NAME = "daw-audio-cache";
+var DB_VERSION = 1;
+var STORE_NAME = "mp4-buffers";
+function openDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(DB_NAME, DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function cacheAudioBuffer(url, data) {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    tx.objectStore(STORE_NAME).put(data, url);
+    await new Promise((res, rej) => {
+      tx.oncomplete = () => res();
+      tx.onerror = () => rej(tx.error);
+    });
+  } catch {
+  }
+}
+async function getCachedAudioBuffer(url) {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, "readonly");
+    const req = tx.objectStore(STORE_NAME).get(url);
+    return new Promise((resolve) => {
+      req.onsuccess = () => resolve(req.result ?? null);
+      req.onerror = () => resolve(null);
+    });
+  } catch {
+    return null;
+  }
+}
+async function clearAudioCache() {
+  try {
+    const db = await openDB();
+    const tx = db.transaction(STORE_NAME, "readwrite");
+    tx.objectStore(STORE_NAME).clear();
+    await new Promise((res) => {
+      tx.oncomplete = () => res();
+    });
+  } catch {
+  }
+}
+async function clearAll() {
+  clearSession();
+  await clearAudioCache();
+}
+var PROJECT_FILE_VERSION = 1;
+function buildPersistedSession(s) {
+  return {
+    id: s.id,
+    mixName: s.mixName,
+    masterTempo: s.masterTempo,
+    originalTempo: s.originalTempo,
+    masterBarLength48000: s.masterBarLength48000,
+    timeSignature: s.timeSignature,
+    globalPlaybackRate: s.globalPlaybackRate,
+    playheadBar: s.playheadBar,
+    loopRegion: s.loopRegion,
+    notes: s.notes?.map((n) => ({ ...n })) ?? [],
+    tracks: s.tracks.map((t) => ({
+      trackDataJson: JSON.stringify(t.trackData),
+      channels: t.channels.map((ch) => ({
+        stemIndex: ch.stemIndex,
+        volume: ch.volume,
+        muted: ch.muted,
+        soloed: ch.soloed,
+        visible: ch.visible,
+        timelineStartBar: ch.timelineStartBar,
+        trimStartBar: ch.trimStartBar,
+        trimEndBar: ch.trimEndBar,
+        muteRegions: ch.muteRegions.map((r) => ({ startBar: r.startBar, endBar: r.endBar })),
+        resampledRegions: ch.resampledRegions?.map((r) => ({
+          startBar: r.startBar,
+          endBar: r.endBar,
+          sliceCount: r.sliceCount
+        })),
+        effects: ch.effects ? JSON.parse(JSON.stringify(ch.effects)) : void 0
+      })),
+      volume: t.volume,
+      muted: t.muted,
+      soloed: t.soloed,
+      expanded: t.expanded,
+      color: t.color,
+      artwork: t.artwork,
+      displayName: t.displayName,
+      artistName: t.artistName,
+      transposeSemitones: t.transposeSemitones ?? 0,
+      pitchSettings: t.pitchSettings,
+      perBarPitchCompensation: t.perBarPitchCompensation === false ? false : t.perBarPitchCompensation ?? true,
+      beatGridOffsetBeats: t.beatGridOffsetBeats ?? 0
+    })),
+    // Pending tracks are already in PersistedTrack shape; pass
+    // them through verbatim so the deferred-load queue survives a
+    // refresh. We deep-clone to detach from the store's reference
+    // (matches the rest of this function's "snapshot, not view"
+    // contract).
+    pendingTracks: s.pendingTracks && s.pendingTracks.length > 0 ? s.pendingTracks.map((pt) => ({ ...pt })) : void 0
+  };
+}
+async function exportProject(session, password) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let project;
+  if (password && password.length > 0) {
+    const innerProject = {
+      version: PROJECT_FILE_VERSION,
+      createdAt: now,
+      updatedAt: now,
+      session
+    };
+    const enc = await encryptPayload(JSON.stringify(innerProject), password);
+    project = {
+      version: PROJECT_FILE_VERSION,
+      createdAt: now,
+      updatedAt: now,
+      session: void 0,
+      encrypted: enc
+    };
+  } else {
+    project = {
+      version: PROJECT_FILE_VERSION,
+      createdAt: now,
+      updatedAt: now,
+      session
+    };
+  }
+  const json = JSON.stringify(project, null, 2);
+  const blob = new Blob([json], { type: "application/json" });
+  const filename = `${session.mixName || "untitled"}.stem-project`;
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+var PROJECT_DB_NAME = "daw-project-library";
+var PROJECT_DB_VERSION = 1;
+var PROJECT_STORE = "projects";
+function openProjectDB() {
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(PROJECT_DB_NAME, PROJECT_DB_VERSION);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(PROJECT_STORE)) {
+        db.createObjectStore(PROJECT_STORE, { keyPath: "meta.id" });
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}
+async function saveProjectToLibrary(session) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const project = {
+    version: PROJECT_FILE_VERSION,
+    createdAt: now,
+    updatedAt: now,
+    session
+  };
+  const artworks = session.tracks.map((t) => t.artwork).filter((a) => !!a && a.length > 0).slice(0, 4);
+  const meta = {
+    id: session.id,
+    name: session.mixName || "Untitled Mix",
+    createdAt: now,
+    updatedAt: now,
+    trackCount: session.tracks.length,
+    masterTempo: Math.round(session.masterTempo),
+    artworks
+  };
+  const stored = { meta, data: project };
+  try {
+    const db = await openProjectDB();
+    const existing = await new Promise((resolve) => {
+      const tx2 = db.transaction(PROJECT_STORE, "readonly");
+      const req = tx2.objectStore(PROJECT_STORE).get(session.id);
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => resolve(void 0);
+    });
+    if (existing) {
+      meta.createdAt = existing.meta.createdAt;
+      stored.data.createdAt = existing.data.createdAt;
+    }
+    const tx = db.transaction(PROJECT_STORE, "readwrite");
+    tx.objectStore(PROJECT_STORE).put(stored);
+    await new Promise((res, rej) => {
+      tx.oncomplete = () => res();
+      tx.onerror = () => rej(tx.error);
+    });
+  } catch (err) {
+    console.warn("[ProjectLibrary] Failed to save:", err);
+  }
+  return meta;
+}
+async function listProjects() {
+  try {
+    const db = await openProjectDB();
+    const tx = db.transaction(PROJECT_STORE, "readonly");
+    const store = tx.objectStore(PROJECT_STORE);
+    const all = await new Promise((resolve) => {
+      const req = store.getAll();
+      req.onsuccess = () => resolve(req.result);
+      req.onerror = () => resolve([]);
+    });
+    return all.map((s) => s.meta).sort((a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime());
+  } catch {
+    return [];
+  }
+}
+async function loadProjectFromLibrary(id) {
+  try {
+    const db = await openProjectDB();
+    const tx = db.transaction(PROJECT_STORE, "readonly");
+    const req = tx.objectStore(PROJECT_STORE).get(id);
+    return new Promise((resolve) => {
+      req.onsuccess = () => {
+        const stored = req.result;
+        resolve(stored?.data ?? null);
+      };
+      req.onerror = () => resolve(null);
+    });
+  } catch {
+    return null;
+  }
+}
+async function deleteProjectFromLibrary(id) {
+  try {
+    const db = await openProjectDB();
+    const tx = db.transaction(PROJECT_STORE, "readwrite");
+    tx.objectStore(PROJECT_STORE).delete(id);
+    await new Promise((res) => {
+      tx.oncomplete = () => res();
+    });
+  } catch {
+  }
+}
+function isProjectEncrypted(file) {
+  return !!(file.encrypted && typeof file.encrypted === "object");
+}
+async function importProject(file, password) {
+  const text = await file.text();
+  let parsed;
+  try {
+    parsed = JSON.parse(text);
+  } catch {
+    throw new Error("Invalid project file: not valid JSON");
+  }
+  let obj = parsed;
+  if (typeof obj !== "object" || obj === null) {
+    throw new Error("Invalid project file: expected a JSON object");
+  }
+  if (obj.version !== PROJECT_FILE_VERSION) {
+    throw new Error(`Unsupported project version: ${obj.version} (expected ${PROJECT_FILE_VERSION})`);
+  }
+  if (isProjectEncrypted(obj)) {
+    if (!password) {
+      throw new Error("PASSWORD_REQUIRED");
+    }
+    const enc = obj.encrypted;
+    let decryptedJson;
+    try {
+      decryptedJson = await decryptPayload(enc, password);
+    } catch {
+      throw new Error("WRONG_PASSWORD");
+    }
+    let inner;
+    try {
+      inner = JSON.parse(decryptedJson);
+    } catch {
+      throw new Error("WRONG_PASSWORD");
+    }
+    obj = inner;
+  }
+  const session = obj.session;
+  if (!session || typeof session !== "object") {
+    throw new Error("Invalid project file: missing session data");
+  }
+  if (!Array.isArray(session.tracks) || session.tracks.length === 0) {
+    throw new Error("Invalid project file: session has no tracks");
+  }
+  for (const t of session.tracks) {
+    if (!t.trackDataJson || typeof t.trackDataJson !== "string") {
+      throw new Error("Invalid project file: track missing trackDataJson");
+    }
+    try {
+      JSON.parse(t.trackDataJson);
+    } catch {
+      throw new Error("Invalid project file: track has corrupt trackDataJson");
+    }
+  }
+  return obj;
+}
+
+// src/daw/store/daw-session-store.ts
+var MAX_UNDO = 60;
+function captureSnapshot(state) {
+  return {
+    tracks: JSON.parse(JSON.stringify(state.tracks)),
+    masterTempo: state.masterTempo,
+    originalTempo: state.originalTempo,
+    masterBarLength48000: state.masterBarLength48000,
+    loopRegion: state.loopRegion ? { ...state.loopRegion } : null,
+    mixName: state.mixName,
+    notes: state.notes.map((n) => ({ ...n }))
+  };
+}
+var _saveTimer = null;
+var _librarySaveTimer = null;
+var SAVE_DEBOUNCE_MS = 1500;
+var LIBRARY_SAVE_DEBOUNCE_MS = 1e4;
+function schedulePersist(_state) {
+  if (_saveTimer) clearTimeout(_saveTimer);
+  _saveTimer = setTimeout(() => {
+    saveSession(buildPersistedSession(useDAWSessionStore.getState()));
+  }, SAVE_DEBOUNCE_MS);
+  if (_librarySaveTimer) clearTimeout(_librarySaveTimer);
+  _librarySaveTimer = setTimeout(() => {
+    const s = useDAWSessionStore.getState();
+    if (s.tracks.length > 0) {
+      saveProjectToLibrary(buildPersistedSession(s));
+    }
+  }, LIBRARY_SAVE_DEBOUNCE_MS);
+}
+var SAMPLE_RATE2 = 48e3;
+function composeBarsWithOffset(beats, offsetBeats) {
+  if (offsetBeats === 0) return composeBarsFromBeats(beats);
+  if (beats.length < 2) return composeBarsFromBeats(beats);
+  const intervals = [];
+  for (let i = 1; i < beats.length; i++) {
+    intervals.push(beats[i].frame - beats[i - 1].frame);
+  }
+  intervals.sort((a, b) => a - b);
+  const medianInterval = intervals[Math.floor(intervals.length / 2)] || 0;
+  const wholeBeatOffset = Math.floor(offsetBeats);
+  const fracBeatOffset = offsetBeats - wholeBeatOffset;
+  const frameFracOffset = Math.round(fracBeatOffset * medianInterval);
+  const offsetBeatsList = [];
+  for (let i = 0; i < beats.length; i++) {
+    const origBeat = beats[i];
+    const newFrame = origBeat.frame + frameFracOffset;
+    if (newFrame < 0) continue;
+    const shifted = ((origBeat.number - 1 - wholeBeatOffset) % 4 + 4) % 4 + 1;
+    offsetBeatsList.push({
+      frame: newFrame,
+      number: shifted,
+      timestamp: newFrame / SAMPLE_RATE2
+    });
+  }
+  const result = composeBarsFromBeats(offsetBeatsList);
+  if (result.length < 2) return composeBarsFromBeats(beats);
+  return result;
+}
+function mergeMuteRegions(regions) {
+  if (regions.length <= 1) return regions;
+  const sorted = [...regions].sort((a, b) => a.startBar - b.startBar);
+  const merged = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const last = merged[merged.length - 1];
+    if (sorted[i].startBar <= last.endBar) {
+      last.endBar = Math.max(last.endBar, sorted[i].endBar);
+    } else {
+      merged.push(sorted[i]);
+    }
+  }
+  return merged;
+}
+var recalculateSpeedRatios = (tracks, masterBarLength) => tracks.map((track) => {
+  const tempoMatch = calculateTempoMatch(masterBarLength, track.nativeBarLength);
+  return {
+    ...track,
+    speedRatioToMaster: tempoMatch.playbackRate,
+    tempoRatio: tempoMatch.ratio
+  };
+});
+function computeSmartAlignment(existingTracks, newBarMapping, newSegmentInfo) {
+  if (existingTracks.length === 0) return 0;
+  const newSections = segmentInfoToSections(newSegmentInfo, newBarMapping);
+  const newAnchor = findFirstSectionOfType(newSections, [
+    SEGMENT_TYPE.CHORUS,
+    SEGMENT_TYPE.VERSE,
+    SEGMENT_TYPE.BRIDGE,
+    SEGMENT_TYPE.INTRO
+  ]);
+  if (!newAnchor) return 0;
+  const refTrack = existingTracks[0];
+  const refSections = segmentInfoToSections(refTrack.segmentInfo, refTrack.barMapping);
+  const matchTypes = [newAnchor.type, SEGMENT_TYPE.CHORUS, SEGMENT_TYPE.VERSE];
+  let refAnchor = null;
+  for (const t of matchTypes) {
+    refAnchor = refSections.find((s) => s.type === t);
+    if (refAnchor) break;
+  }
+  if (!refAnchor) refAnchor = findFirstSectionOfType(refSections);
+  if (!refAnchor) return 0;
+  const refChannel = refTrack.channels.find((ch) => ch.visible) || refTrack.channels[0];
+  const refAnchorTimeline = refChannel.timelineStartBar + refAnchor.startBar;
+  const offset = refAnchorTimeline - newAnchor.startBar;
+  return Math.max(0, Math.round(offset));
+}
+var useDAWSessionStore = create((set, get) => ({
+  // ── Initial state ──
+  id: v4(),
+  mixName: "Untitled Mix",
+  masterTempo: 0,
+  originalTempo: 0,
+  masterBarLength48000: 0,
+  timeSignature: [4, 4],
+  tracks: [],
+  playheadBar: 0,
+  isPlaying: false,
+  globalPlaybackRate: 1,
+  loopRegion: null,
+  barSubdivisions: 1,
+  notes: [],
+  pendingTracks: [],
+  toolMode: "pointer",
+  compositeView: false,
+  similarTracksBalance: 0.5,
+  similarTracksPopularity: 1,
+  selectedStem: null,
+  selections: [],
+  selectionRange: null,
+  clipboardEntries: [],
+  clipboard: null,
+  _undoStack: [],
+  _redoStack: [],
+  // ──────────────────────────────────────────────────────────────────
+  // Track management
+  // ──────────────────────────────────────────────────────────────────
+  addTrack: (trackData) => {
+    get().pushUndo();
+    const state = get();
+    const barMapping = composeBarsFromBeats(trackData.beats);
+    const nativeBarLength = trackData.tempoOrigSz || medianBarDuration(barMapping);
+    const nativeBpm = trackData.bpm || barDurationToBpm(nativeBarLength);
+    const isFirstTrack = state.tracks.length === 0;
+    const masterBarLength = isFirstTrack ? nativeBarLength : state.masterBarLength48000;
+    const masterTempo = isFirstTrack ? nativeBpm : state.masterTempo;
+    const tempoMatch = calculateTempoMatch(masterBarLength, nativeBarLength);
+    const pitchCorrection = computePitchShift(
+      state.tracks[0]?.key ?? trackData.key,
+      state.tracks[0]?.tonality ?? trackData.tonality,
+      masterBarLength,
+      trackData.key,
+      trackData.tonality,
+      nativeBarLength,
+      "KEY_PRESERVE" /* KEY_PRESERVE */
+    );
+    const rawColor = trackData.colors?.[0] || trackData.artworkGlowColor || trackData.color1Hex;
+    const resolvedColor = rawColor ? rawColor.startsWith("#") ? rawColor : `#${rawColor}` : "#5b8def";
+    const segmentInfo = trackData.segmentInfo ?? [];
+    const timelineStart = computeSmartAlignment(state.tracks, barMapping, segmentInfo);
+    const trimEnd = barMapping.length - 1;
+    const newTrack = {
+      id: v4(),
+      trackData,
+      audioSourceSequenceId: trackData.trackId,
+      barMapping,
+      segmentInfo,
+      nativeBarLength,
+      nativeBpm,
+      speedRatioToMaster: tempoMatch.playbackRate,
+      tempoRatio: tempoMatch.ratio,
+      pitchCorrectionSemitones: pitchCorrection,
+      key: trackData.key,
+      tonality: trackData.tonality,
+      beatGridOffsetBeats: 0,
+      transposeSemitones: 0,
+      pitchSettings: { ...DEFAULT_PITCH_SETTINGS },
+      perBarPitchCompensation: true,
+      channels: createDefaultChannels(timelineStart, 0, trimEnd),
+      volume: 1,
+      muted: false,
+      soloed: false,
+      color: resolvedColor,
+      artwork: trackData.artwork || "",
+      displayName: trackData.name || trackData.trackDisplayName || "Untitled",
+      artistName: trackData.artistDisplayName || "Unknown",
+      expanded: false
+    };
+    const updatedTracks = [...state.tracks, newTrack];
+    if (isFirstTrack) {
+      set({
+        masterTempo,
+        originalTempo: masterTempo,
+        masterBarLength48000: masterBarLength,
+        tracks: updatedTracks
+      });
+    } else {
+      set({ tracks: recalculateSpeedRatios(updatedTracks, masterBarLength) });
+    }
+    schedulePersist(get());
+    return newTrack;
+  },
+  removeTrack: (trackId) => {
+    get().pushUndo();
+    const state = get();
+    const filtered = state.tracks.filter((t) => t.id !== trackId);
+    if (filtered.length === 0) {
+      set({ tracks: [], masterTempo: 0, originalTempo: 0, masterBarLength48000: 0 });
+      schedulePersist(get());
+      return;
+    }
+    if (state.tracks[0]?.id === trackId) {
+      const newMaster = filtered[0];
+      const masterBarLength = newMaster.nativeBarLength;
+      const masterTempo = newMaster.nativeBpm;
+      set({
+        masterTempo,
+        originalTempo: masterTempo,
+        masterBarLength48000: masterBarLength,
+        tracks: recalculateSpeedRatios(filtered, masterBarLength)
+      });
+    } else {
+      set({ tracks: filtered });
+    }
+    schedulePersist(get());
+  },
+  reorderTrack: (trackId, newIndex) => {
+    get().pushUndo();
+    const state = get();
+    const tracks = [...state.tracks];
+    const currentIdx = tracks.findIndex((t) => t.id === trackId);
+    if (currentIdx === -1) return;
+    const [track] = tracks.splice(currentIdx, 1);
+    const clampedIndex = Math.max(0, Math.min(newIndex, tracks.length));
+    tracks.splice(clampedIndex, 0, track);
+    const newMaster = tracks[0];
+    const oldMasterId = state.tracks[0]?.id;
+    if (newMaster.id !== oldMasterId) {
+      const masterBarLength = newMaster.nativeBarLength;
+      const masterTempo = newMaster.nativeBpm;
+      set({
+        masterTempo,
+        originalTempo: masterTempo,
+        masterBarLength48000: masterBarLength,
+        tracks: recalculateSpeedRatios(tracks, masterBarLength)
+      });
+    } else {
+      set({ tracks });
+    }
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Deferred-load queue
+  //
+  // Pending mutations bypass the undo stack on purpose: promoting a
+  // pending track is a network/decode operation that the user can
+  // always reverse with a normal "remove track" (which IS undoable).
+  // Conversely, blanking the queue on undo would let the user
+  // accidentally "lose" tracks they have visible in the deferred
+  // list — bad UX.
+  //
+  // Every mutator still re-persists so the queue survives a refresh
+  // and stays in lock-step with the live tracks list.
+  // ──────────────────────────────────────────────────────────────────
+  setPendingTracks: (tracks) => {
+    set({ pendingTracks: tracks.map((pt) => ({ ...pt })) });
+    schedulePersist(get());
+  },
+  addPendingTracks: (tracks) => {
+    if (tracks.length === 0) return;
+    set((state) => ({
+      pendingTracks: [...state.pendingTracks, ...tracks.map((pt) => ({ ...pt }))]
+    }));
+    schedulePersist(get());
+  },
+  removePendingTrackAt: (index) => {
+    set((state) => {
+      if (index < 0 || index >= state.pendingTracks.length) return state;
+      const next = state.pendingTracks.slice();
+      next.splice(index, 1);
+      return { pendingTracks: next };
+    });
+    schedulePersist(get());
+  },
+  clearPendingTracks: () => {
+    if (get().pendingTracks.length === 0) return;
+    set({ pendingTracks: [] });
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Per-stem timeline editing
+  // ──────────────────────────────────────────────────────────────────
+  setStemTimelineStart: (trackId, stemIndex, bar) => {
+    schedulePersist(get());
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (ch) => ch.stemIndex === stemIndex ? { ...ch, timelineStartBar: Math.round(bar) } : ch
+          )
+        } : t
+      )
+    }));
+  },
+  setStemTrim: (trackId, stemIndex, trimStart, trimEnd) => {
+    schedulePersist(get());
+    set((state) => ({
+      tracks: state.tracks.map((t) => {
+        if (t.id !== trackId) return t;
+        const maxBar = t.barMapping.length - 1;
+        return {
+          ...t,
+          channels: t.channels.map(
+            (ch) => ch.stemIndex === stemIndex ? {
+              ...ch,
+              trimStartBar: Math.max(0, Math.min(Math.round(trimStart), maxBar)),
+              trimEndBar: Math.max(0, Math.min(Math.round(trimEnd), maxBar))
+            } : ch
+          )
+        };
+      })
+    }));
+  },
+  setTrackTimelineStart: (trackId, bar) => {
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map((ch) => ({
+            ...ch,
+            timelineStartBar: Math.round(bar)
+          }))
+        } : t
+      )
+    }));
+  },
+  setTrackTrim: (trackId, trimStart, trimEnd) => {
+    set((state) => ({
+      tracks: state.tracks.map((t) => {
+        if (t.id !== trackId) return t;
+        const maxBar = t.barMapping.length - 1;
+        return {
+          ...t,
+          channels: t.channels.map((ch) => ({
+            ...ch,
+            trimStartBar: Math.max(0, Math.min(Math.round(trimStart), maxBar)),
+            trimEndBar: Math.max(0, Math.min(Math.round(trimEnd), maxBar))
+          }))
+        };
+      })
+    }));
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Transport
+  // ──────────────────────────────────────────────────────────────────
+  setMixName: (name) => set({ mixName: name.trim() || "Untitled Mix" }),
+  setToolMode: (mode) => set({ toolMode: mode }),
+  setCompositeView: (on) => set({ compositeView: on }),
+  toggleCompositeView: () => set((state) => ({ compositeView: !state.compositeView })),
+  setSimilarTracksBalance: (v) => set({
+    similarTracksBalance: Math.max(0, Math.min(1, v))
+  }),
+  setSimilarTracksPopularity: (v) => set({
+    similarTracksPopularity: Math.max(0, Math.min(2, v))
+  }),
+  resetSimilarTracksTuning: () => set({
+    similarTracksBalance: 0.5,
+    similarTracksPopularity: 1
+  }),
+  getSimilarTracksQueryArgs: () => {
+    const s = get();
+    const ranking = {};
+    if (s.similarTracksBalance !== 0.5) {
+      ranking.genreWeight = Math.max(0, Math.min(1, 1 - s.similarTracksBalance));
+    }
+    if (s.similarTracksPopularity !== 1) {
+      ranking.collaborativeStrength = Math.max(0, Math.min(2, s.similarTracksPopularity));
+    }
+    if (Object.keys(ranking).length === 0) return {};
+    return { ranking };
+  },
+  setSelectedStem: (stem) => set({ selectedStem: stem }),
+  setSelections: (ranges) => {
+    if (ranges.length === 0) {
+      set({ selections: [], selectionRange: null });
+      return;
+    }
+    const trackId = ranges[0].trackId;
+    const filtered = ranges.filter((r) => r.trackId === trackId && r.endBar > r.startBar);
+    const byStem = /* @__PURE__ */ new Map();
+    for (const r of filtered) byStem.set(r.stemIndex, r);
+    const next = Array.from(byStem.values()).sort((a, b) => a.stemIndex - b.stemIndex);
+    set({ selections: next, selectionRange: next[0] ?? null });
+  },
+  addSelection: (range) => {
+    if (range.endBar <= range.startBar) return;
+    const current = get().selections;
+    if (current.length > 0 && current[0].trackId !== range.trackId) {
+      set({ selections: [range], selectionRange: range });
+      return;
+    }
+    const byStem = /* @__PURE__ */ new Map();
+    for (const r of current) byStem.set(r.stemIndex, r);
+    byStem.set(range.stemIndex, range);
+    const next = Array.from(byStem.values()).sort((a, b) => a.stemIndex - b.stemIndex);
+    set({ selections: next, selectionRange: next[0] ?? null });
+  },
+  clearSelections: () => set({ selections: [], selectionRange: null }),
+  setSelectionRange: (range) => {
+    if (!range || range.endBar <= range.startBar) {
+      set({ selections: [], selectionRange: null });
+      return;
+    }
+    set({ selections: [range], selectionRange: range });
+  },
+  setClipboardEntries: (entries) => {
+    if (entries.length === 0) {
+      set({ clipboardEntries: [], clipboard: null });
+      return;
+    }
+    const trackId = entries[0].trackId;
+    const filtered = entries.filter((e) => e.trackId === trackId && e.sourceEndBar > e.sourceStartBar);
+    const byStem = /* @__PURE__ */ new Map();
+    for (const e of filtered) byStem.set(e.stemIndex, e);
+    const next = Array.from(byStem.values()).sort((a, b) => a.stemIndex - b.stemIndex);
+    set({ clipboardEntries: next, clipboard: next[0] ?? null });
+  },
+  setClipboard: (entry) => {
+    if (!entry) {
+      set({ clipboardEntries: [], clipboard: null });
+      return;
+    }
+    set({ clipboardEntries: [entry], clipboard: entry });
+  },
+  // ── Undo / Redo ──────────────────────────────────────────────────
+  pushUndo: () => {
+    const state = get();
+    const snap = captureSnapshot(state);
+    const stack = [...state._undoStack, snap];
+    if (stack.length > MAX_UNDO) stack.shift();
+    set({ _undoStack: stack, _redoStack: [] });
+  },
+  undo: () => {
+    const state = get();
+    if (state._undoStack.length === 0) return;
+    const stack = [...state._undoStack];
+    const snap = stack.pop();
+    const redoSnap = captureSnapshot(state);
+    set({
+      ...snap,
+      _undoStack: stack,
+      _redoStack: [...state._redoStack, redoSnap]
+    });
+    schedulePersist(get());
+  },
+  redo: () => {
+    const state = get();
+    if (state._redoStack.length === 0) return;
+    const stack = [...state._redoStack];
+    const snap = stack.pop();
+    const undoSnap = captureSnapshot(state);
+    set({
+      ...snap,
+      _undoStack: [...state._undoStack, undoSnap],
+      _redoStack: stack
+    });
+    schedulePersist(get());
+  },
+  canUndo: () => get()._undoStack.length > 0,
+  canRedo: () => get()._redoStack.length > 0,
+  setPlaying: (playing) => set({ isPlaying: playing }),
+  setPlayheadBar: (bar) => set({ playheadBar: Math.max(0, bar) }),
+  setMasterTempo: (bpm) => {
+    const state = get();
+    const masterBarLength = bpmToBarDuration(bpm);
+    set({
+      masterTempo: bpm,
+      masterBarLength48000: masterBarLength,
+      tracks: recalculateSpeedRatios(state.tracks, masterBarLength)
+    });
+  },
+  setGlobalPlaybackRate: (rate) => set({ globalPlaybackRate: rate }),
+  setLoopRegion: (region) => set({ loopRegion: region }),
+  setBarSubdivisions: (n) => set({ barSubdivisions: Math.max(1, Math.round(n)) }),
+  // ──────────────────────────────────────────────────────────────────
+  // Session notes (timeline markers)
+  //
+  // Notes live on the session itself rather than per-track because they
+  // describe moments in the listener's experience of the mix, not in any
+  // single source recording. They never feed the audio engine — they're
+  // pure visual annotation.
+  // ──────────────────────────────────────────────────────────────────
+  addNote: (note) => {
+    get().pushUndo();
+    const id = v4();
+    const full = { ...note, id, createdAt: Date.now() };
+    set({ notes: [...get().notes, full].sort((a, b) => a.startBar - b.startBar) });
+    schedulePersist(get());
+    return id;
+  },
+  updateNote: (id, patch) => {
+    const existing = get().notes.find((n) => n.id === id);
+    if (!existing) return;
+    get().pushUndo();
+    set({
+      notes: get().notes.map((n) => n.id === id ? { ...n, ...patch } : n).sort((a, b) => a.startBar - b.startBar)
+    });
+    schedulePersist(get());
+  },
+  removeNote: (id) => {
+    if (!get().notes.some((n) => n.id === id)) return;
+    get().pushUndo();
+    set({ notes: get().notes.filter((n) => n.id !== id) });
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Track controls
+  // ──────────────────────────────────────────────────────────────────
+  setTrackVolume: (trackId, volume) => set((state) => ({
+    tracks: state.tracks.map(
+      (t) => t.id === trackId ? { ...t, volume: Math.max(0, Math.min(2, volume)) } : t
+    )
+  })),
+  setTrackMuted: (trackId, muted) => set((state) => ({
+    tracks: state.tracks.map((t) => t.id === trackId ? { ...t, muted } : t)
+  })),
+  setTrackSoloed: (trackId, soloed) => set((state) => ({
+    tracks: state.tracks.map((t) => t.id === trackId ? { ...t, soloed } : t)
+  })),
+  setTrackExpanded: (trackId, expanded) => set((state) => ({
+    tracks: state.tracks.map((t) => t.id === trackId ? { ...t, expanded } : t)
+  })),
+  setTrackTranspose: (trackId, semitones) => {
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? { ...t, transposeSemitones: Math.max(-12, Math.min(12, semitones)) } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  setTrackPitchSettings: (trackId, settings) => {
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? { ...t, pitchSettings: { ...settings } } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  setPerBarPitchCompensation: (trackId, enabled) => {
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? { ...t, perBarPitchCompensation: enabled } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Beat grid alignment
+  // ──────────────────────────────────────────────────────────────────
+  setTrackBeatGridOffset: (trackId, offsetBeats) => {
+    get().pushUndo();
+    set((state2) => ({
+      tracks: state2.tracks.map((t) => {
+        if (t.id !== trackId) return t;
+        const beats = t.trackData.beats;
+        if (!beats || beats.length === 0) return t;
+        const newBarMapping = composeBarsWithOffset(beats, offsetBeats);
+        if (newBarMapping.length < 2) return t;
+        const newNativeBarLength = medianBarDuration(newBarMapping) || t.nativeBarLength;
+        const trimEnd = Math.max(0, newBarMapping.length - 1);
+        return {
+          ...t,
+          beatGridOffsetBeats: offsetBeats,
+          barMapping: newBarMapping,
+          nativeBarLength: newNativeBarLength,
+          channels: t.channels.map((ch) => ({
+            ...ch,
+            trimEndBar: Math.min(ch.trimEndBar, trimEnd),
+            trimStartBar: Math.min(ch.trimStartBar, trimEnd)
+          }))
+        };
+      })
+    }));
+    const state = get();
+    if (state.masterBarLength48000 > 0) {
+      set({ tracks: recalculateSpeedRatios(state.tracks, state.masterBarLength48000) });
+    }
+    schedulePersist(get());
+  },
+  replaceTrackBeats: (trackId, newBeats) => {
+    if (!newBeats || newBeats.length < 2) return;
+    get().pushUndo();
+    const newBarMapping = composeBarsFromBeats(newBeats);
+    if (newBarMapping.length < 2) return;
+    const newNativeBarLength = medianBarDuration(newBarMapping);
+    if (!newNativeBarLength) return;
+    const newNativeBpm = barDurationToBpm(newNativeBarLength);
+    set((state) => {
+      const isLeadTrack = state.tracks.length > 0 && state.tracks[0].id === trackId;
+      const masterBarLength = isLeadTrack ? newNativeBarLength : state.masterBarLength48000;
+      const masterTempo = isLeadTrack ? newNativeBpm || state.masterTempo : state.masterTempo;
+      const updatedTracks = state.tracks.map((t) => {
+        if (t.id !== trackId) return t;
+        const trimEnd = Math.max(0, newBarMapping.length - 1);
+        return {
+          ...t,
+          beatGridOffsetBeats: 0,
+          barMapping: newBarMapping,
+          nativeBarLength: newNativeBarLength,
+          nativeBpm: newNativeBpm || t.nativeBpm,
+          trackData: { ...t.trackData, beats: newBeats },
+          channels: t.channels.map((ch) => ({
+            ...ch,
+            trimEndBar: Math.min(ch.trimEndBar, trimEnd),
+            trimStartBar: Math.min(ch.trimStartBar, trimEnd)
+          }))
+        };
+      });
+      return {
+        masterBarLength48000: masterBarLength,
+        masterTempo,
+        tracks: recalculateSpeedRatios(updatedTracks, masterBarLength)
+      };
+    });
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Channel (stem) controls
+  // ──────────────────────────────────────────────────────────────────
+  setChannelVolume: (trackId, stemIndex, volume) => set((state) => ({
+    tracks: state.tracks.map(
+      (t) => t.id === trackId ? {
+        ...t,
+        channels: t.channels.map(
+          (ch) => ch.stemIndex === stemIndex ? { ...ch, volume: Math.max(0, Math.min(2, volume)) } : ch
+        )
+      } : t
+    )
+  })),
+  setChannelMuted: (trackId, stemIndex, muted) => set((state) => ({
+    tracks: state.tracks.map(
+      (t) => t.id === trackId ? {
+        ...t,
+        channels: t.channels.map(
+          (ch) => ch.stemIndex === stemIndex ? { ...ch, muted } : ch
+        )
+      } : t
+    )
+  })),
+  setChannelSoloed: (trackId, stemIndex, soloed) => set((state) => ({
+    tracks: state.tracks.map(
+      (t) => t.id === trackId ? {
+        ...t,
+        channels: t.channels.map(
+          (ch) => ch.stemIndex === stemIndex ? { ...ch, soloed } : ch
+        )
+      } : t
+    )
+  })),
+  setChannelVisible: (trackId, stemIndex, visible) => set((state) => ({
+    tracks: state.tracks.map(
+      (t) => t.id === trackId ? {
+        ...t,
+        channels: t.channels.map(
+          (ch) => ch.stemIndex === stemIndex ? { ...ch, visible } : ch
+        )
+      } : t
+    )
+  })),
+  setChannelEffects: (trackId, stemIndex, effects) => set((state) => ({
+    tracks: state.tracks.map(
+      (t) => t.id === trackId ? {
+        ...t,
+        channels: t.channels.map(
+          (ch) => ch.stemIndex === stemIndex ? { ...ch, effects } : ch
+        )
+      } : t
+    )
+  })),
+  // ──────────────────────────────────────────────────────────────────
+  // Mute regions
+  // ──────────────────────────────────────────────────────────────────
+  addMuteRegion: (trackId, stemIndex, region) => {
+    get().pushUndo();
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map((ch) => {
+            if (ch.stemIndex !== stemIndex) return ch;
+            const merged = mergeMuteRegions([...ch.muteRegions, region]);
+            return { ...ch, muteRegions: merged };
+          })
+        } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  removeMuteRegion: (trackId, stemIndex, regionIndex) => {
+    get().pushUndo();
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (ch) => ch.stemIndex === stemIndex ? { ...ch, muteRegions: ch.muteRegions.filter((_, i) => i !== regionIndex) } : ch
+          )
+        } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  clearMuteRegions: (trackId, stemIndex) => {
+    get().pushUndo();
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (ch) => ch.stemIndex === stemIndex ? { ...ch, muteRegions: [] } : ch
+          )
+        } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  setMuteRegionsBatch: (trackId, stemIndex, regions) => {
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (ch) => ch.stemIndex === stemIndex ? { ...ch, muteRegions: mergeMuteRegions(regions) } : ch
+          )
+        } : t
+      )
+    }));
+  },
+  splitStemAtBar: (trackId, stemIndex, bar) => {
+    get().pushUndo();
+    const state = get();
+    const track = state.tracks.find((t) => t.id === trackId);
+    if (!track) return;
+    const ch = track.channels.find((c) => c.stemIndex === stemIndex);
+    if (!ch) return;
+    const localBar = Math.round(bar);
+    if (localBar <= ch.trimStartBar || localBar >= ch.trimEndBar) return;
+    const region = { startBar: localBar, endBar: localBar + 1 };
+    const merged = mergeMuteRegions([...ch.muteRegions, region]);
+    set({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (c) => c.stemIndex === stemIndex ? { ...c, muteRegions: merged } : c
+          )
+        } : t
+      )
+    });
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Split points (logical clip boundaries — pure visual, no audio side
+  // effect). The audio engine ignores these entirely; they only feed
+  // into computeClips() so the UI knows where to break a stem into
+  // independently-movable clips.
+  // ──────────────────────────────────────────────────────────────────
+  addSplitPoint: (trackId, stemIndex, localBar) => {
+    const state = get();
+    const track = state.tracks.find((t) => t.id === trackId);
+    if (!track) return;
+    const ch = track.channels.find((c) => c.stemIndex === stemIndex);
+    if (!ch) return;
+    if (localBar <= ch.trimStartBar || localBar >= ch.trimEndBar) return;
+    const existing = ch.splitPoints ?? [];
+    if (existing.some((p) => Math.abs(p - localBar) < 0.015625)) return;
+    get().pushUndo();
+    const merged = [...existing, localBar].sort((a, b) => a - b);
+    set({
+      tracks: get().tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (c) => c.stemIndex === stemIndex ? { ...c, splitPoints: merged } : c
+          )
+        } : t
+      )
+    });
+    schedulePersist(get());
+  },
+  setSplitPointsBatch: (trackId, stemIndex, points, pushUndo = true) => {
+    const state = get();
+    const track = state.tracks.find((t) => t.id === trackId);
+    if (!track) return;
+    const ch = track.channels.find((c) => c.stemIndex === stemIndex);
+    if (!ch) return;
+    if (pushUndo) get().pushUndo();
+    const cleaned = Array.from(new Set(points.filter(
+      (p) => p > ch.trimStartBar && p < ch.trimEndBar
+    ))).sort((a, b) => a - b);
+    set({
+      tracks: get().tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (c) => c.stemIndex === stemIndex ? { ...c, splitPoints: cleaned } : c
+          )
+        } : t
+      )
+    });
+    schedulePersist(get());
+  },
+  clearSplitPoints: (trackId, stemIndex) => {
+    const state = get();
+    const track = state.tracks.find((t) => t.id === trackId);
+    if (!track) return;
+    const ch = track.channels.find((c) => c.stemIndex === stemIndex);
+    if (!ch || !ch.splitPoints || ch.splitPoints.length === 0) return;
+    get().pushUndo();
+    set({
+      tracks: get().tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (c) => c.stemIndex === stemIndex ? { ...c, splitPoints: [] } : c
+          )
+        } : t
+      )
+    });
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Resampled regions
+  // ──────────────────────────────────────────────────────────────────
+  addResampledRegion: (trackId, stemIndex, region) => {
+    set((state) => ({
+      tracks: state.tracks.map(
+        (t) => t.id === trackId ? {
+          ...t,
+          channels: t.channels.map(
+            (ch) => ch.stemIndex === stemIndex ? { ...ch, resampledRegions: [...ch.resampledRegions ?? [], region] } : ch
+          )
+        } : t
+      )
+    }));
+    schedulePersist(get());
+  },
+  // ──────────────────────────────────────────────────────────────────
+  // Derived
+  // ──────────────────────────────────────────────────────────────────
+  getTimelineLength: () => {
+    const state = get();
+    if (state.tracks.length === 0) return 0;
+    let maxEnd = 0;
+    for (const t of state.tracks) {
+      for (const ch of t.channels) {
+        if (!ch.visible) continue;
+        const end = ch.timelineStartBar + (ch.trimEndBar - ch.trimStartBar + 1);
+        if (end > maxEnd) maxEnd = end;
+      }
+    }
+    return maxEnd;
+  },
+  getTrackById: (trackId) => {
+    return get().tracks.find((t) => t.id === trackId);
+  },
+  getChannel: (trackId, stemIndex) => {
+    const track = get().tracks.find((t) => t.id === trackId);
+    return track?.channels.find((ch) => ch.stemIndex === stemIndex);
+  }
+}));
+
+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, buildPersistedSession, cacheAudioBuffer, calculateTempoMatch, camelotMatchType, clearAll, composeBarsFromBeats, composeBarsFromBeatsSmoothed, computeBarSpeedRatio, computeClips, computePitchShift, computeTransposeSuggestions, createDefaultChannels, deleteProjectFromLibrary, exportProject, findFirstSectionOfType, getCachedAudioBuffer, getSelectionBoundsBars, importProject, keyToSemitones, listProjects, loadProjectFromLibrary, loadSession, medianBarDuration, parseStemIdKey, playbackRateToSemitones, resolveSampleLocOfDownbeatFromBarIndex, resolveTimeOfDownbeatFromBarIndex, saveProjectToLibrary, segmentInfoToSections, semitonesToKey, semitonesToPitchFactor, stemIdKey, toCamelot, transposeKey, useDAWSessionStore };
+//# sourceMappingURL=chunk-KCOOE2OP.js.map
+//# sourceMappingURL=chunk-KCOOE2OP.js.map