@kano/stem-daw 0.1.0

package/dist/chunk-OYNES5W3.js

@@ -0,0 +1,3085 @@
+import { AEV3Config, extractTfraData, MP4MoofExtractor, AACAdtsPackager, getWorkletPath_Phaze, getWorkletPath_RubberBand } from './chunk-TBXCZFAY.js';
+import { getCachedAudioBuffer, cacheAudioBuffer, useDAWSessionStore, barToSample, semitonesToPitchFactor, DEFAULT_PITCH_SETTINGS, calculateTempoMatch } from './chunk-KCOOE2OP.js';
+import isMobile from 'is-mobile';
+
+// src/daw/engine/event-emitter.ts
+var BrowserEventEmitter = class {
+  _listeners = /* @__PURE__ */ new Map();
+  on(event, listener) {
+    if (!this._listeners.has(event)) {
+      this._listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this._listeners.get(event).add(listener);
+    return this;
+  }
+  off(event, listener) {
+    this._listeners.get(event)?.delete(listener);
+    return this;
+  }
+  once(event, listener) {
+    const wrapper = (...args) => {
+      this.off(event, wrapper);
+      listener(...args);
+    };
+    return this.on(event, wrapper);
+  }
+  emit(event, ...args) {
+    const listeners = this._listeners.get(event);
+    if (!listeners || listeners.size === 0) return false;
+    for (const listener of listeners) {
+      try {
+        listener(...args);
+      } catch (e) {
+        console.error(`EventEmitter error on "${event}":`, e);
+      }
+    }
+    return true;
+  }
+  removeAllListeners(event) {
+    if (event) {
+      this._listeners.delete(event);
+    } else {
+      this._listeners.clear();
+    }
+    return this;
+  }
+};
+
+// src/daw/engine/progressive-track-loader.ts
+var SAMPLE_RATE = 48e3;
+var AAC_ENCODER_DELAY_SAMPLES = 2112;
+var BATCH_SEGMENTS = 8;
+var PLAYABLE_THRESHOLD_SAMPLES = 8 * SAMPLE_RATE;
+var AAC_FRAME_SAMPLES = 1024;
+var STEM_LABELS = ["bass", "drums", "other", "vocals"];
+var TFRA_STEM_MAP = {
+  0: "bass",
+  1: "drums",
+  2: "other",
+  3: "vocals"
+};
+function isProgressiveDecodeSupported() {
+  return typeof globalThis.AudioDecoder !== "undefined";
+}
+function deriveTotalSamplesFromTfra(tfraData, expectedDurationSec) {
+  const entries = tfraData[0]?.entries ?? [];
+  const lastIdx = entries.length - 1;
+  const tfraSamples = lastIdx >= 0 ? entries[lastIdx].time : 0;
+  const durationSamples = Math.ceil(expectedDurationSec * SAMPLE_RATE);
+  return Math.max(tfraSamples, durationSamples) + SAMPLE_RATE;
+}
+function planBatches(tfraData, totalFileBytes) {
+  const entryCount = tfraData[0].entries.length;
+  if (entryCount < 2) return [];
+  const usableEntries = entryCount - 1;
+  const batches = [];
+  for (let s = 0; s < usableEntries; s += BATCH_SEGMENTS) {
+    const startSeg = s;
+    const endSeg = Math.min(s + BATCH_SEGMENTS, usableEntries);
+    const byteStart = tfraData[0].entries[startSeg].moof_offset;
+    const nextSegMoofOffset = endSeg < entryCount ? tfraData[0].entries[endSeg].moof_offset : tfraData[0].entries[endSeg - 1].moof_offset;
+    const byteEnd = nextSegMoofOffset;
+    batches.push({ startSeg, endSeg, byteStart, byteEnd });
+  }
+  return batches;
+}
+function getStemSliceWithinSegment(tfraData, segIndex, stemTfraIdx) {
+  const moofOffset = tfraData[stemTfraIdx].entries[segIndex].moof_offset;
+  let moofEnd;
+  if (stemTfraIdx < 3) {
+    moofEnd = tfraData[stemTfraIdx + 1].entries[segIndex].moof_offset;
+  } else {
+    moofEnd = tfraData[0].entries[segIndex + 1].moof_offset;
+  }
+  return { moofOffsetInFile: moofOffset, moofEndInFile: moofEnd };
+}
+async function fetchRange(url, byteStart, byteEnd, token, signal) {
+  const headers = {
+    Range: `bytes=${byteStart}-${byteEnd - 1}`
+  };
+  if (token) headers["Authorization"] = `Bearer ${token}`;
+  const res = await fetch(url, { headers, cache: "no-cache", signal });
+  if (!res.ok && res.status !== 206) {
+    throw new Error(`Range fetch failed: ${res.status} for bytes=${byteStart}-${byteEnd - 1}`);
+  }
+  return res.arrayBuffer();
+}
+function createStemDecoder(onChunk, onError) {
+  const Ctor = globalThis.AudioDecoder;
+  const decoder = new Ctor({
+    output: (audioData) => {
+      const frames = audioData.numberOfFrames;
+      const channels = audioData.numberOfChannels;
+      const left = new Float32Array(frames);
+      const right = new Float32Array(frames);
+      try {
+        audioData.copyTo(left, { planeIndex: 0, format: "f32-planar" });
+        if (channels > 1) {
+          audioData.copyTo(right, { planeIndex: 1, format: "f32-planar" });
+        } else {
+          right.set(left);
+        }
+      } catch (e) {
+        onError(e);
+        audioData.close();
+        return;
+      }
+      audioData.close();
+      onChunk(left, right, frames);
+    },
+    error: (e) => onError(e)
+  });
+  decoder.configure({
+    codec: "mp4a.40.2",
+    sampleRate: SAMPLE_RATE,
+    numberOfChannels: 2
+  });
+  return decoder;
+}
+function beginProgressiveLoad(mp4Url, expectedDurationSec, options = {}) {
+  const totalSamples = options.totalSamples ?? Math.ceil(expectedDurationSec * SAMPLE_RATE) + SAMPLE_RATE;
+  const abortController = new AbortController();
+  const patchListeners = /* @__PURE__ */ new Set();
+  const progressListeners = /* @__PURE__ */ new Set();
+  let playableResolve;
+  let playableReject;
+  const playable = new Promise((resolve, reject) => {
+    playableResolve = resolve;
+    playableReject = reject;
+  });
+  let completeResolve;
+  let completeReject;
+  const complete = new Promise((resolve, reject) => {
+    completeResolve = resolve;
+    completeReject = reject;
+  });
+  let playableResolved = false;
+  let completeResolved = false;
+  let aborted = false;
+  const emitPatch = (p) => {
+    if (aborted) return;
+    for (const cb of patchListeners) {
+      try {
+        cb(p);
+      } catch (e) {
+        console.warn("[ProgressiveLoader] patch listener threw", e);
+      }
+    }
+  };
+  const emitProgress = (p) => {
+    if (aborted) return;
+    for (const cb of progressListeners) {
+      try {
+        cb(p);
+      } catch (e) {
+        console.warn("[ProgressiveLoader] progress listener threw", e);
+      }
+    }
+  };
+  const run = async () => {
+    try {
+      const token = AEV3Config.getInstance()?.getAccessToken?.() ?? "";
+      emitProgress({ phase: "fetching", percent: 0, detail: "Reading MP4 index\u2026" });
+      const tfraData = options.tfraData ?? await extractTfraData(mp4Url, token, false);
+      if (aborted) return;
+      if (!tfraData || tfraData.length < 4) {
+        throw new Error("TFRA data missing or incomplete \u2013 expected 4 tracks");
+      }
+      const batches = planBatches(tfraData, null);
+      if (batches.length === 0) {
+        throw new Error("No decodable segments found in TFRA index");
+      }
+      const moofExtractor = new MP4MoofExtractor();
+      const adtsPackager = new AACAdtsPackager();
+      const stemStates = {};
+      for (const label of STEM_LABELS) {
+        const state = {
+          decoder: null,
+          writeOffset: 0,
+          samplesToSkip: AAC_ENCODER_DELAY_SAMPLES,
+          pendingChunks: [],
+          batchSampleStart: 0,
+          decodedSamples: 0,
+          timestampUs: 0
+        };
+        state.decoder = createStemDecoder(
+          (left, right) => {
+            let l = left;
+            let r = right;
+            if (state.samplesToSkip > 0) {
+              const drop = Math.min(state.samplesToSkip, l.length);
+              l = l.subarray(drop);
+              r = r.subarray(drop);
+              state.samplesToSkip -= drop;
+              if (l.length === 0) return;
+            }
+            state.pendingChunks.push([l, r]);
+          },
+          (e) => {
+            console.error(`[ProgressiveLoader] decoder error for ${label}:`, e);
+          }
+        );
+        stemStates[label] = state;
+      }
+      const checkPlayable = () => {
+        if (playableResolved) return;
+        let minDecoded = Infinity;
+        for (const label of STEM_LABELS) {
+          if (stemStates[label].decodedSamples < minDecoded) {
+            minDecoded = stemStates[label].decodedSamples;
+          }
+        }
+        if (minDecoded >= PLAYABLE_THRESHOLD_SAMPLES) {
+          playableResolved = true;
+          playableResolve();
+        }
+      };
+      for (let batchIdx = 0; batchIdx < batches.length; batchIdx++) {
+        if (aborted) return;
+        const batch = batches[batchIdx];
+        emitProgress({
+          phase: "fetching",
+          percent: Math.round(batchIdx / batches.length * 100),
+          detail: `Batch ${batchIdx + 1}/${batches.length}`
+        });
+        let chunkBuf;
+        if (options.sourceBuffer) {
+          chunkBuf = options.sourceBuffer.slice(batch.byteStart, batch.byteEnd);
+        } else {
+          chunkBuf = await fetchRange(mp4Url, batch.byteStart, batch.byteEnd, token, abortController.signal);
+        }
+        if (aborted) return;
+        for (let tfraIdx = 0; tfraIdx < 4; tfraIdx++) {
+          const stemLabel = TFRA_STEM_MAP[tfraIdx];
+          const state = stemStates[stemLabel];
+          state.pendingChunks = [];
+          state.batchSampleStart = state.writeOffset;
+          const mp4TrackId = tfraIdx + 1;
+          for (let segIdx = batch.startSeg; segIdx < batch.endSeg; segIdx++) {
+            const { moofOffsetInFile, moofEndInFile } = getStemSliceWithinSegment(tfraData, segIdx, tfraIdx);
+            const relStart = moofOffsetInFile - batch.byteStart;
+            const relEnd = moofEndInFile - batch.byteStart;
+            if (relStart < 0 || relEnd > chunkBuf.byteLength || relEnd <= relStart) {
+              continue;
+            }
+            const segBuf = chunkBuf.slice(relStart, relEnd);
+            let adtsFrames;
+            try {
+              const { trunData, mdatData } = moofExtractor.extractMoofDataForAEV3(
+                segBuf,
+                mp4TrackId,
+                segIdx,
+                "",
+                "",
+                `stem-${stemLabel}`
+              );
+              const { buffers } = adtsPackager.packageAacFramesForAEV3(
+                mdatData,
+                trunData,
+                `stem-${stemLabel}`
+              );
+              adtsFrames = buffers;
+            } catch (e) {
+              console.warn(`[ProgressiveLoader] failed to parse seg ${segIdx} stem ${stemLabel}:`, e);
+              continue;
+            }
+            for (const frame of adtsFrames) {
+              if (aborted) return;
+              try {
+                state.decoder.decode(new EncodedAudioChunk({
+                  type: "key",
+                  timestamp: state.timestampUs,
+                  duration: Math.round(AAC_FRAME_SAMPLES * 1e6 / SAMPLE_RATE),
+                  data: frame
+                }));
+                state.timestampUs += Math.round(AAC_FRAME_SAMPLES * 1e6 / SAMPLE_RATE);
+              } catch (e) {
+                console.warn(`[ProgressiveLoader] decode() threw for ${stemLabel}:`, e);
+              }
+            }
+          }
+        }
+        await Promise.all(STEM_LABELS.map(async (label) => {
+          const state = stemStates[label];
+          try {
+            await state.decoder.flush();
+          } catch (e) {
+            console.warn(`[ProgressiveLoader] flush failed for ${label}:`, e);
+          }
+        }));
+        if (aborted) return;
+        for (const label of STEM_LABELS) {
+          const state = stemStates[label];
+          if (state.pendingChunks.length === 0) continue;
+          let total = 0;
+          for (const [l] of state.pendingChunks) total += l.length;
+          if (total === 0) continue;
+          const writeStart = state.batchSampleStart;
+          const maxWritable = Math.max(0, totalSamples - writeStart);
+          const writeLen = Math.min(total, maxWritable);
+          if (writeLen <= 0) {
+            console.warn(
+              `[ProgressiveLoader] buffer cap hit for ${label}: writeStart=${writeStart} >= totalSamples=${totalSamples} (have ${total} decoded samples queued, batch ${batchIdx + 1}/${batches.length})`
+            );
+            state.pendingChunks = [];
+            continue;
+          }
+          if (writeLen < total) {
+            console.warn(
+              `[ProgressiveLoader] truncating ${label} batch ${batchIdx + 1}: wrote ${writeLen} of ${total} samples (buffer ends at ${totalSamples})`
+            );
+          }
+          const mergedL = new Float32Array(writeLen);
+          const mergedR = new Float32Array(writeLen);
+          let off = 0;
+          for (const [l, r] of state.pendingChunks) {
+            const remaining = writeLen - off;
+            if (remaining <= 0) break;
+            const take = Math.min(l.length, remaining);
+            mergedL.set(l.subarray(0, take), off);
+            mergedR.set(r.subarray(0, take), off);
+            off += take;
+          }
+          state.pendingChunks = [];
+          state.writeOffset = writeStart + writeLen;
+          state.decodedSamples = state.writeOffset;
+          emitPatch({
+            stem: label,
+            sampleOffset: writeStart,
+            samples: [mergedL, mergedR]
+          });
+        }
+        checkPlayable();
+        emitProgress({
+          phase: "decoding",
+          percent: Math.round((batchIdx + 1) / batches.length * 100),
+          detail: `Decoded batch ${batchIdx + 1}/${batches.length}`
+        });
+      }
+      for (const label of STEM_LABELS) {
+        const state = stemStates[label];
+        try {
+          await state.decoder.flush();
+          state.decoder.close();
+        } catch {
+        }
+      }
+      if (!playableResolved) {
+        playableResolved = true;
+        playableResolve();
+      }
+      if (!completeResolved) {
+        completeResolved = true;
+        completeResolve();
+      }
+      emitProgress({ phase: "decoding", percent: 100, detail: "Done" });
+    } catch (e) {
+      if (aborted) return;
+      const err = e;
+      console.error("[ProgressiveLoader] run failed:", err);
+      if (!playableResolved) {
+        playableResolved = true;
+        playableReject(err);
+      }
+      if (!completeResolved) {
+        completeResolved = true;
+        completeReject(err);
+      }
+    }
+  };
+  void run();
+  return {
+    totalSamples,
+    playable,
+    complete,
+    abort: () => {
+      aborted = true;
+      abortController.abort();
+    },
+    onPatch: (cb) => {
+      patchListeners.add(cb);
+      return () => patchListeners.delete(cb);
+    },
+    onProgress: (cb) => {
+      progressListeners.add(cb);
+      return () => progressListeners.delete(cb);
+    }
+  };
+}
+async function cacheFullFileForOffline(url) {
+  try {
+    const existing = await getCachedAudioBuffer(url);
+    if (existing) return;
+    const token = AEV3Config.getInstance()?.getAccessToken?.() ?? "";
+    const headers = {};
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    const res = await fetch(url, { headers, cache: "force-cache" });
+    if (!res.ok) return;
+    const ab = await res.arrayBuffer();
+    await cacheAudioBuffer(url, ab);
+  } catch {
+  }
+}
+
+// src/daw/engine/daw-track-loader.ts
+var SAMPLE_RATE2 = 48e3;
+var _decodingCtx = null;
+function getDecodingContext() {
+  if (!_decodingCtx || _decodingCtx.state === "closed") {
+    _decodingCtx = new AudioContext({ sampleRate: SAMPLE_RATE2 });
+  }
+  return _decodingCtx;
+}
+var TFRA_STEM_MAP2 = {
+  0: "bass",
+  1: "drums",
+  2: "other",
+  3: "vocals"
+};
+async function loadTrackStemsFromMp3Urls(urls, onProgress) {
+  const ctx = getDecodingContext();
+  const result = {};
+  const labels = ["bass", "drums", "other", "vocals"];
+  for (let i = 0; i < labels.length; i++) {
+    const label = labels[i];
+    const url = urls[label];
+    const pct = Math.round((i + 1) / 4 * 100);
+    onProgress?.({ phase: "fetching", percent: pct, detail: `Loading ${label}\u2026` });
+    const res = await fetch(url, { cache: "no-cache" });
+    if (!res.ok) throw new Error(`Failed to fetch ${label}: ${res.status}`);
+    const ab = await res.arrayBuffer();
+    const buf = await ctx.decodeAudioData(ab);
+    if (buf.numberOfChannels === 1) {
+      const stereo = ctx.createBuffer(2, buf.length, buf.sampleRate);
+      const mono = buf.getChannelData(0);
+      stereo.copyToChannel(mono, 0);
+      stereo.copyToChannel(mono, 1);
+      result[label] = stereo;
+    } else {
+      result[label] = buf;
+    }
+  }
+  onProgress?.({ phase: "decoding", percent: 100, detail: "Done" });
+  return result;
+}
+async function loadTrackStems(mp4Url, onProgress) {
+  const token = AEV3Config.getInstance()?.getAccessToken?.() ?? "";
+  onProgress?.({ phase: "fetching", percent: 0, detail: "Reading MP4 index\u2026" });
+  const tfraData = await extractTfraData(mp4Url, token, false);
+  if (!tfraData || tfraData.length < 4) {
+    throw new Error("TFRA data missing or incomplete \u2013 expected 4 tracks");
+  }
+  let fullBuffer;
+  const cached = await getCachedAudioBuffer(mp4Url);
+  if (cached) {
+    onProgress?.({ phase: "fetching", percent: 35, detail: "Loaded from cache" });
+    fullBuffer = cached;
+  } else {
+    onProgress?.({ phase: "fetching", percent: 10, detail: "Downloading audio\u2026" });
+    const headers = {};
+    if (token) headers["Authorization"] = `Bearer ${token}`;
+    const response = await fetch(mp4Url, { headers, cache: "no-cache" });
+    if (!response.ok) throw new Error(`MP4 fetch failed: ${response.status}`);
+    fullBuffer = await response.arrayBuffer();
+    cacheAudioBuffer(mp4Url, fullBuffer.slice(0));
+  }
+  onProgress?.({ phase: "parsing", percent: 40, detail: "Extracting stems\u2026" });
+  const moofExtractor = new MP4MoofExtractor();
+  const adtsPackager = new AACAdtsPackager();
+  const stemFrames = {
+    bass: [],
+    drums: [],
+    other: [],
+    vocals: []
+  };
+  const bufLen = fullBuffer.byteLength;
+  tfraData[0].entries.length;
+  for (let tfraIdx = 0; tfraIdx < 4; tfraIdx++) {
+    const stemLabel = TFRA_STEM_MAP2[tfraIdx];
+    const entries = tfraData[tfraIdx].entries;
+    const mp4TrackId = tfraIdx + 1;
+    for (let i = 0; i < entries.length - 1; i++) {
+      const moofOffset = entries[i].moof_offset;
+      let moofEnd;
+      if (tfraIdx < 3) {
+        moofEnd = tfraData[tfraIdx + 1].entries[i].moof_offset;
+      } else {
+        moofEnd = tfraData[0].entries[i + 1].moof_offset;
+      }
+      const byteLength = moofEnd - moofOffset;
+      if (moofOffset + byteLength > bufLen || byteLength <= 0) {
+        continue;
+      }
+      const trackBuffer = fullBuffer.slice(moofOffset, moofOffset + byteLength);
+      try {
+        const { trunData, mdatData } = moofExtractor.extractMoofDataForAEV3(
+          trackBuffer,
+          mp4TrackId,
+          i,
+          "",
+          "",
+          `stem-${stemLabel}`
+        );
+        const { buffers: adtsFrames } = adtsPackager.packageAacFramesForAEV3(
+          mdatData,
+          trunData,
+          `stem-${stemLabel}`
+        );
+        stemFrames[stemLabel].push(...adtsFrames);
+      } catch {
+      }
+    }
+    const pct = 40 + Math.round((tfraIdx + 1) / 4 * 30);
+    onProgress?.({ phase: "parsing", percent: pct, detail: `Extracted ${stemLabel}` });
+  }
+  onProgress?.({ phase: "decoding", percent: 70, detail: "Decoding audio\u2026" });
+  const ctx = getDecodingContext();
+  const result = {};
+  const stemLabels = Object.keys(stemFrames);
+  for (let si = 0; si < stemLabels.length; si++) {
+    const label = stemLabels[si];
+    const frames = stemFrames[label];
+    if (frames.length === 0) {
+      result[label] = ctx.createBuffer(2, SAMPLE_RATE2, SAMPLE_RATE2);
+      continue;
+    }
+    const merged = mergeFrames(frames);
+    let decoded;
+    try {
+      decoded = await ctx.decodeAudioData(merged.buffer);
+    } catch {
+      const blob = new Blob([merged], { type: "audio/aac" });
+      const ab = await blob.arrayBuffer();
+      decoded = await ctx.decodeAudioData(ab);
+    }
+    result[label] = trimEncoderDelay(decoded, ctx);
+    const pct = 70 + Math.round((si + 1) / 4 * 28);
+    onProgress?.({ phase: "decoding", percent: pct, detail: `Decoded ${label}` });
+  }
+  onProgress?.({ phase: "decoding", percent: 100, detail: "Done" });
+  return result;
+}
+var AAC_ENCODER_DELAY_SAMPLES2 = 2112;
+function trimEncoderDelay(buf, ctx) {
+  if (buf.length <= AAC_ENCODER_DELAY_SAMPLES2) return buf;
+  const trimmedLength = buf.length - AAC_ENCODER_DELAY_SAMPLES2;
+  const trimmed = ctx.createBuffer(buf.numberOfChannels, trimmedLength, buf.sampleRate);
+  for (let ch = 0; ch < buf.numberOfChannels; ch++) {
+    const src = buf.getChannelData(ch);
+    const dst = trimmed.getChannelData(ch);
+    dst.set(src.subarray(AAC_ENCODER_DELAY_SAMPLES2));
+  }
+  return trimmed;
+}
+function mergeFrames(frames) {
+  let totalLength = 0;
+  for (const f of frames) totalLength += f.byteLength;
+  const out = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const f of frames) {
+    out.set(f, offset);
+    offset += f.byteLength;
+  }
+  return out;
+}
+function allocateEmptyStemBuffers(totalSamples, ctx) {
+  const len = Math.max(1, totalSamples);
+  return {
+    bass: ctx.createBuffer(2, len, SAMPLE_RATE2),
+    drums: ctx.createBuffer(2, len, SAMPLE_RATE2),
+    other: ctx.createBuffer(2, len, SAMPLE_RATE2),
+    vocals: ctx.createBuffer(2, len, SAMPLE_RATE2)
+  };
+}
+async function loadTrackStemsProgressively(mp4Url, expectedDurationSec, onProgress) {
+  const ctx = getDecodingContext();
+  if (!isProgressiveDecodeSupported()) {
+    const fallbackTotalSamples = Math.max(1, Math.ceil(expectedDurationSec * SAMPLE_RATE2) + SAMPLE_RATE2);
+    const initial2 = allocateEmptyStemBuffers(fallbackTotalSamples, ctx);
+    return fallbackToOneShotPatch(mp4Url, initial2, fallbackTotalSamples, onProgress);
+  }
+  const token = AEV3Config.getInstance()?.getAccessToken?.() ?? "";
+  let tfraData;
+  try {
+    tfraData = await extractTfraData(mp4Url, token, false);
+  } catch (err) {
+    console.warn("[loadTrackStemsProgressively] TFRA fetch failed, falling back to duration-only sizing:", err);
+    tfraData = null;
+  }
+  const totalSamples = tfraData && tfraData.length >= 4 ? deriveTotalSamplesFromTfra(tfraData, expectedDurationSec) : Math.max(1, Math.ceil(expectedDurationSec * SAMPLE_RATE2) + SAMPLE_RATE2);
+  const initial = allocateEmptyStemBuffers(totalSamples, ctx);
+  const cached = await getCachedAudioBuffer(mp4Url);
+  if (cached && tfraData && tfraData.length >= 4) {
+    const handle2 = beginProgressiveLoad(mp4Url, expectedDurationSec, {
+      tfraData,
+      sourceBuffer: cached,
+      totalSamples
+    });
+    if (onProgress) handle2.onProgress(onProgress);
+    return { initial, handle: handle2 };
+  }
+  const handle = beginProgressiveLoad(mp4Url, expectedDurationSec, {
+    tfraData: tfraData ?? void 0,
+    totalSamples
+  });
+  if (onProgress) handle.onProgress(onProgress);
+  return { initial, handle };
+}
+async function fallbackToOneShotPatch(mp4Url, initial, totalSamples, onProgress) {
+  const patchListeners = /* @__PURE__ */ new Set();
+  const progressListeners = /* @__PURE__ */ new Set();
+  if (onProgress) progressListeners.add(onProgress);
+  let completeResolve;
+  let completeReject;
+  const complete = new Promise((resolve, reject) => {
+    completeResolve = resolve;
+    completeReject = reject;
+  });
+  let aborted = false;
+  (async () => {
+    try {
+      const stems = await loadTrackStems(mp4Url, (p) => {
+        for (const cb of progressListeners) {
+          try {
+            cb(p);
+          } catch {
+          }
+        }
+      });
+      if (aborted) return;
+      const stemKeys = ["bass", "drums", "other", "vocals"];
+      for (const k of stemKeys) {
+        const buf = stems[k];
+        const lenToCopy = Math.min(buf.length, totalSamples);
+        const left = new Float32Array(lenToCopy);
+        const right = new Float32Array(lenToCopy);
+        left.set(buf.getChannelData(0).subarray(0, lenToCopy));
+        if (buf.numberOfChannels > 1) {
+          right.set(buf.getChannelData(1).subarray(0, lenToCopy));
+        } else {
+          right.set(left);
+        }
+        for (const cb of patchListeners) {
+          try {
+            cb({ stem: k, sampleOffset: 0, samples: [left, right] });
+          } catch {
+          }
+        }
+      }
+      completeResolve();
+    } catch (e) {
+      completeReject(e);
+    }
+  })();
+  const handle = {
+    totalSamples,
+    playable: complete,
+    complete,
+    abort: () => {
+      aborted = true;
+    },
+    onPatch: (cb) => {
+      patchListeners.add(cb);
+      return () => patchListeners.delete(cb);
+    },
+    onProgress: (cb) => {
+      progressListeners.add(cb);
+      return () => progressListeners.delete(cb);
+    }
+  };
+  return { initial, handle };
+}
+
+// src/daw/components/waveform-cache.ts
+var MIPMAP_LEVELS = [64, 256, 1024, 4096, 16384, 65536];
+var mipmapStore = /* @__PURE__ */ new Map();
+var STEM_KEYS = ["other", "vocals", "bass", "drums"];
+var changeListeners = /* @__PURE__ */ new Set();
+function subscribeMipmapChanges(cb) {
+  changeListeners.add(cb);
+  return () => changeListeners.delete(cb);
+}
+function notifyChange() {
+  for (const cb of changeListeners) {
+    try {
+      cb();
+    } catch {
+    }
+  }
+}
+function makeKey(trackId, stemKey) {
+  return `${trackId}:${stemKey}`;
+}
+function initMipmapsForTrack(trackId, stemKey, totalSamples) {
+  const key = makeKey(trackId, stemKey);
+  const existing = mipmapStore.get(key);
+  if (existing && existing.totalSamples === totalSamples) {
+    for (const arr of existing.levels.values()) arr.fill(0);
+    existing.decodedSampleHigh = 0;
+    existing.version++;
+    return existing;
+  }
+  const levels = /* @__PURE__ */ new Map();
+  for (const numBins of MIPMAP_LEVELS) {
+    if (totalSamples < numBins) continue;
+    levels.set(numBins, new Float32Array(numBins));
+  }
+  const state = {
+    levels,
+    decodedSampleHigh: 0,
+    totalSamples,
+    version: 1
+  };
+  mipmapStore.set(key, state);
+  return state;
+}
+function appendPeaksToMipmapCache(trackId, stemKey, sampleOffset, leftChannel, rightChannel) {
+  const state = mipmapStore.get(makeKey(trackId, stemKey));
+  if (!state) return;
+  const total = state.totalSamples;
+  const startSample = Math.max(0, sampleOffset);
+  const endSample = Math.min(total, sampleOffset + leftChannel.length);
+  if (endSample <= startSample) return;
+  for (const [numBins, peaks] of state.levels) {
+    const firstBin = Math.floor(startSample * numBins / total);
+    const lastBinExcl = Math.min(numBins, Math.ceil(endSample * numBins / total));
+    for (let b = firstBin; b < lastBinExcl; b++) {
+      const binStart = Math.floor(b * total / numBins);
+      const binEnd = Math.floor((b + 1) * total / numBins);
+      const sFrom = Math.max(binStart, startSample);
+      const sToExcl = Math.min(binEnd, endSample);
+      if (sToExcl <= sFrom) continue;
+      let max = peaks[b];
+      for (let i = sFrom; i < sToExcl; i++) {
+        const localI = i - sampleOffset;
+        const l = leftChannel[localI];
+        const r = rightChannel ? rightChannel[localI] : l;
+        const al = l < 0 ? -l : l;
+        const ar = r < 0 ? -r : r;
+        const v = al > ar ? al : ar;
+        if (v > max) max = v;
+      }
+      peaks[b] = max;
+    }
+  }
+  if (endSample > state.decodedSampleHigh) state.decodedSampleHigh = endSample;
+  state.version++;
+  notifyChange();
+}
+function invalidateWaveformCache(trackId, stemIndex) {
+  const key = makeKey(trackId, STEM_KEYS[stemIndex]);
+  const had = mipmapStore.has(key);
+  mipmapStore.delete(key);
+  console.log("[DAW Waveform] invalidateWaveformCache:", key, had ? "(cache cleared)" : "(was not cached)");
+}
+function clearWaveformCacheForTrack(trackId) {
+  for (const k of STEM_KEYS) {
+    mipmapStore.delete(makeKey(trackId, k));
+  }
+}
+
+// src/daw/engine/stem-effect-chain.ts
+var DEFAULT_EFFECTS = {
+  eq: { enabled: false, lowGain: 0, midGain: 0, highGain: 0, lowFreq: 320, highFreq: 3200 },
+  compressor: { enabled: false, threshold: -24, ratio: 4, attack: 3e-3, release: 0.25, knee: 30 },
+  reverb: { enabled: false, mix: 0.3, decay: 2 },
+  delay: { enabled: false, time: 0.375, feedback: 0.35, mix: 0.25 }
+};
+function hasActiveEffects(fx) {
+  return fx.eq.enabled || fx.compressor.enabled || fx.reverb.enabled || fx.delay.enabled;
+}
+var StemEffectChain = class {
+  ctx;
+  // Input/output anchors — these never change
+  input;
+  output;
+  // EQ: 3-band (lowshelf + peaking + highshelf)
+  eqLow;
+  eqMid;
+  eqHigh;
+  // Compressor
+  compressor;
+  // Reverb (algorithmic via ConvolverNode with generated impulse)
+  reverbDry;
+  reverbWet;
+  convolver;
+  // Delay
+  delayNode;
+  delayFeedback;
+  delayDry;
+  delayWet;
+  // Per-slot bypass routing
+  eqBypass;
+  compBypass;
+  reverbBypass;
+  delayBypass;
+  // Junction nodes between stages
+  postEq;
+  postComp;
+  postReverb;
+  _params;
+  constructor(ctx) {
+    this.ctx = ctx;
+    this._params = structuredClone(DEFAULT_EFFECTS);
+    this.input = ctx.createGain();
+    this.output = ctx.createGain();
+    this.eqLow = ctx.createBiquadFilter();
+    this.eqLow.type = "lowshelf";
+    this.eqLow.frequency.value = 320;
+    this.eqLow.gain.value = 0;
+    this.eqMid = ctx.createBiquadFilter();
+    this.eqMid.type = "peaking";
+    this.eqMid.frequency.value = 1e3;
+    this.eqMid.Q.value = 0.7;
+    this.eqMid.gain.value = 0;
+    this.eqHigh = ctx.createBiquadFilter();
+    this.eqHigh.type = "highshelf";
+    this.eqHigh.frequency.value = 3200;
+    this.eqHigh.gain.value = 0;
+    this.eqBypass = ctx.createGain();
+    this.compressor = ctx.createDynamicsCompressor();
+    this.compressor.threshold.value = -24;
+    this.compressor.ratio.value = 4;
+    this.compressor.attack.value = 3e-3;
+    this.compressor.release.value = 0.25;
+    this.compressor.knee.value = 30;
+    this.compBypass = ctx.createGain();
+    this.convolver = ctx.createConvolver();
+    this.convolver.buffer = this.generateImpulse(2);
+    this.reverbDry = ctx.createGain();
+    this.reverbDry.gain.value = 1;
+    this.reverbWet = ctx.createGain();
+    this.reverbWet.gain.value = 0;
+    this.reverbBypass = ctx.createGain();
+    this.delayNode = ctx.createDelay(5);
+    this.delayNode.delayTime.value = 0.375;
+    this.delayFeedback = ctx.createGain();
+    this.delayFeedback.gain.value = 0.35;
+    this.delayDry = ctx.createGain();
+    this.delayDry.gain.value = 1;
+    this.delayWet = ctx.createGain();
+    this.delayWet.gain.value = 0;
+    this.delayBypass = ctx.createGain();
+    this.delayNode.connect(this.delayFeedback);
+    this.delayFeedback.connect(this.delayNode);
+    this.postEq = ctx.createGain();
+    this.postComp = ctx.createGain();
+    this.postReverb = ctx.createGain();
+    this.rebuildRouting();
+  }
+  /**
+   * Rebuild the full routing graph based on current bypass states.
+   * Uses disconnect-all then reconnect to avoid orphaned connections.
+   */
+  rebuildRouting() {
+    const p = this._params;
+    this.input.disconnect();
+    this.eqLow.disconnect();
+    this.eqMid.disconnect();
+    this.eqHigh.disconnect();
+    this.eqBypass.disconnect();
+    this.postEq.disconnect();
+    this.compressor.disconnect();
+    this.compBypass.disconnect();
+    this.postComp.disconnect();
+    this.reverbDry.disconnect();
+    this.reverbWet.disconnect();
+    this.convolver.disconnect();
+    this.reverbBypass.disconnect();
+    this.postReverb.disconnect();
+    this.delayDry.disconnect();
+    this.delayWet.disconnect();
+    this.delayNode.disconnect();
+    this.delayFeedback.disconnect();
+    this.delayBypass.disconnect();
+    this.delayNode.connect(this.delayFeedback);
+    this.delayFeedback.connect(this.delayNode);
+    if (p.eq.enabled) {
+      this.input.connect(this.eqLow);
+      this.eqLow.connect(this.eqMid);
+      this.eqMid.connect(this.eqHigh);
+      this.eqHigh.connect(this.postEq);
+    } else {
+      this.input.connect(this.postEq);
+    }
+    if (p.compressor.enabled) {
+      this.postEq.connect(this.compressor);
+      this.compressor.connect(this.postComp);
+    } else {
+      this.postEq.connect(this.postComp);
+    }
+    if (p.reverb.enabled) {
+      this.postComp.connect(this.reverbDry);
+      this.postComp.connect(this.convolver);
+      this.convolver.connect(this.reverbWet);
+      this.reverbDry.connect(this.postReverb);
+      this.reverbWet.connect(this.postReverb);
+    } else {
+      this.postComp.connect(this.postReverb);
+    }
+    if (p.delay.enabled) {
+      this.postReverb.connect(this.delayDry);
+      this.postReverb.connect(this.delayNode);
+      this.delayNode.connect(this.delayWet);
+      this.delayDry.connect(this.output);
+      this.delayWet.connect(this.output);
+    } else {
+      this.postReverb.connect(this.output);
+    }
+  }
+  /** Generate a synthetic impulse response for reverb */
+  generateImpulse(decay) {
+    const rate = this.ctx.sampleRate;
+    const length = Math.floor(rate * Math.min(decay, 6));
+    const buf = this.ctx.createBuffer(2, length, rate);
+    for (let ch = 0; ch < 2; ch++) {
+      const data = buf.getChannelData(ch);
+      for (let i = 0; i < length; i++) {
+        data[i] = (Math.random() * 2 - 1) * Math.pow(1 - i / length, decay * 0.8);
+      }
+    }
+    return buf;
+  }
+  // ── Public API ───────────────────────────────────────────────────
+  get params() {
+    return this._params;
+  }
+  updateEQ(p) {
+    Object.assign(this._params.eq, p);
+    const eq = this._params.eq;
+    this.eqLow.frequency.value = eq.lowFreq;
+    this.eqLow.gain.value = eq.lowGain;
+    this.eqMid.gain.value = eq.midGain;
+    this.eqHigh.frequency.value = eq.highFreq;
+    this.eqHigh.gain.value = eq.highGain;
+    if ("enabled" in p) this.rebuildRouting();
+  }
+  updateCompressor(p) {
+    Object.assign(this._params.compressor, p);
+    const c = this._params.compressor;
+    const t = this.ctx.currentTime;
+    this.compressor.threshold.setValueAtTime(c.threshold, t);
+    this.compressor.ratio.setValueAtTime(c.ratio, t);
+    this.compressor.attack.setValueAtTime(c.attack, t);
+    this.compressor.release.setValueAtTime(c.release, t);
+    this.compressor.knee.setValueAtTime(c.knee, t);
+    if ("enabled" in p) this.rebuildRouting();
+  }
+  updateReverb(p) {
+    Object.assign(this._params.reverb, p);
+    const r = this._params.reverb;
+    const t = this.ctx.currentTime;
+    this.reverbDry.gain.setValueAtTime(1 - r.mix, t);
+    this.reverbWet.gain.setValueAtTime(r.mix, t);
+    if ("decay" in p) {
+      this.convolver.buffer = this.generateImpulse(r.decay);
+    }
+    if ("enabled" in p) this.rebuildRouting();
+  }
+  updateDelay(p) {
+    Object.assign(this._params.delay, p);
+    const d = this._params.delay;
+    const t = this.ctx.currentTime;
+    this.delayNode.delayTime.setValueAtTime(d.time, t);
+    this.delayFeedback.gain.setValueAtTime(d.feedback, t);
+    this.delayDry.gain.setValueAtTime(1 - d.mix, t);
+    this.delayWet.gain.setValueAtTime(d.mix, t);
+    if ("enabled" in p) this.rebuildRouting();
+  }
+  applyAll(fx) {
+    this.updateEQ(fx.eq);
+    this.updateCompressor(fx.compressor);
+    this.updateReverb(fx.reverb);
+    this.updateDelay(fx.delay);
+  }
+  dispose() {
+    try {
+      this.input.disconnect();
+      this.output.disconnect();
+    } catch {
+    }
+  }
+};
+var SAMPLE_RATE3 = 48e3;
+var STEM_LABELS2 = ["other", "vocals", "bass", "drums"];
+var DAW_WORKLET_PATH = "/workers/daw-stem-processor.js";
+var USE_PHAZE = isMobile();
+var PITCH_WORKLET_NAME = USE_PHAZE ? "phase-vocoder-processor" : "realtime-pitch-shift-processor";
+var METRO_LOOK_AHEAD_SEC = 0.1;
+var METRO_SCHEDULE_INTERVAL_MS = 25;
+var DEFAULT_MAX_DECODED_TRACKS = isMobile() ? 6 : 12;
+function buildBarMap(barMapping, masterBarLength, nativeBarLength, subdivisions = 1) {
+  const tempoMatch = calculateTempoMatch(masterBarLength, nativeBarLength);
+  const targetBarLength = tempoMatch.targetBarLength;
+  const subs = Math.max(1, subdivisions);
+  const parentSpeeds = barMapping.map((bar) => bar.duration / targetBarLength);
+  if (subs <= 1) {
+    return barMapping.map((bar, i) => ({
+      sampleStart: bar.sampleStart,
+      speed: parentSpeeds[i]
+    }));
+  }
+  const totalSubs = barMapping.length * subs;
+  const speeds = new Array(totalSubs);
+  for (let i = 0; i < totalSubs; i++) {
+    const parentPos = (i + 0.5) / subs;
+    const lo = Math.floor(parentPos - 0.5);
+    const hi = lo + 1;
+    const t = parentPos - 0.5 - lo;
+    const loSpeed = parentSpeeds[Math.max(0, Math.min(lo, parentSpeeds.length - 1))];
+    const hiSpeed = parentSpeeds[Math.max(0, Math.min(hi, parentSpeeds.length - 1))];
+    speeds[i] = loSpeed + (hiSpeed - loSpeed) * t;
+  }
+  const result = [];
+  for (let b = 0; b < barMapping.length; b++) {
+    const bar = barMapping[b];
+    const offset = b * subs;
+    let speedSum = 0;
+    for (let s = 0; s < subs; s++) speedSum += speeds[offset + s];
+    let cumSamples = 0;
+    for (let s = 0; s < subs; s++) {
+      result.push({
+        sampleStart: Math.round(bar.sampleStart + cumSamples),
+        speed: speeds[offset + s]
+      });
+      cumSamples += speeds[offset + s] / speedSum * bar.duration;
+    }
+  }
+  return result;
+}
+function buildBarPitchMap(barMap) {
+  return barMap.map((entry) => ({
+    pitchCorrectionSemitones: -12 * Math.log2(entry.speed),
+    speed: entry.speed
+  }));
+}
+var DAWController = class _DAWController extends BrowserEventEmitter {
+  ctx = null;
+  masterGain = null;
+  tracks = /* @__PURE__ */ new Map();
+  /** URL → shared decode entry. See `SourceCacheEntry`. */
+  sourceCache = /* @__PURE__ */ new Map();
+  isInitialised = false;
+  _pitchWorkletAvailable = false;
+  _playing = false;
+  _playStartCtxTime = 0;
+  _playStartOffset = 0;
+  playheadAnimationId = null;
+  _seekGen = 0;
+  /**
+   * Max number of tracks allowed to hold their decoded PCM concurrently.
+   * Beyond this we evict LRU tracks via `dumpTrackAudio`. See
+   * `DEFAULT_MAX_DECODED_TRACKS` for the rationale.
+   */
+  _maxDecodedTracks = DEFAULT_MAX_DECODED_TRACKS;
+  // Track which stems are currently playing so we can start/stop
+  // them as the playhead crosses their timeline boundaries.
+  _stemActive = /* @__PURE__ */ new Map();
+  // Metronome
+  _metronomeOn = false;
+  _metronomeDownbeatOnly = true;
+  _metronomeGain = null;
+  _metronomeScheduleId = null;
+  _metronomeNextBeat = 0;
+  // CPU monitoring
+  _cpuPollId = null;
+  _cpuUsage = 0;
+  // Native playback mode — disables tempo quantization for a single track
+  // so the beat lab can play audio at original speed (beat markers align 1:1).
+  _nativeModeTrackId = null;
+  _nativeModeOriginalBarMap = null;
+  /** Native-time offset (samples) at the moment play/seek was last called in native mode */
+  _nativeStartSample = 0;
+  static instance = null;
+  static getInstance() {
+    if (!_DAWController.instance) _DAWController.instance = new _DAWController();
+    return _DAWController.instance;
+  }
+  constructor() {
+    super();
+  }
+  // ── Init ──────────────────────────────────────────────────────────
+  async init() {
+    if (this.isInitialised) return;
+    this.ctx = new AudioContext({ sampleRate: SAMPLE_RATE3 });
+    console.log("[DAWController.init] AudioContext created, state:", this.ctx.state);
+    this.ctx.addEventListener("statechange", () => {
+      console.log("[DAWController] AudioContext statechange \u2192", this.ctx.state);
+      if (this.ctx.state === "suspended" && this._playing) {
+        console.warn("[DAWController] Context suspended while playing \u2014 auto-resuming");
+        this.ctx.resume().catch(() => {
+        });
+      }
+    });
+    await this.ctx.audioWorklet.addModule(DAW_WORKLET_PATH);
+    const pitchWorkletPath = USE_PHAZE ? getWorkletPath_Phaze() : getWorkletPath_RubberBand();
+    try {
+      await this.ctx.audioWorklet.addModule(pitchWorkletPath);
+      this._pitchWorkletAvailable = true;
+    } catch (err) {
+      console.warn("[DAWController] Pitch worklet failed to load, transpose unavailable:", err);
+      this._pitchWorkletAvailable = false;
+    }
+    this.masterGain = this.ctx.createGain();
+    this.masterGain.connect(this.ctx.destination);
+    this.isInitialised = true;
+    this.emit("initialised");
+  }
+  isReady() {
+    return this.isInitialised;
+  }
+  /**
+   * Resolve when the named track's audio has fully decoded. If the
+   * decode is already complete (common with the source-cache when
+   * multiple clips share one source), resolve immediately on the next
+   * microtask. Rejects if the track is removed or no such track exists.
+   *
+   * Use this instead of `controller.on('trackLoaded', …)` from
+   * importers / batch loaders — the event fires once and a late
+   * subscriber would miss it. This helper closes that race.
+   */
+  whenTrackLoaded(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt) return Promise.reject(new Error(`Unknown track ${trackId}`));
+    if (rt.loaded) return Promise.resolve();
+    return new Promise((resolve, reject) => {
+      const onLoaded = (loadedId) => {
+        if (loadedId !== trackId) return;
+        cleanup();
+        resolve();
+      };
+      const onRemoved = (removedId) => {
+        if (removedId !== trackId) return;
+        cleanup();
+        reject(new Error(`Track ${trackId} removed before load completed`));
+      };
+      const cleanup = () => {
+        this.off("trackLoaded", onLoaded);
+        this.off("trackRemoved", onRemoved);
+      };
+      this.on("trackLoaded", onLoaded);
+      this.on("trackRemoved", onRemoved);
+    });
+  }
+  getAudioContext() {
+    return this.ctx;
+  }
+  getMasterGainNode() {
+    return this.masterGain;
+  }
+  // ── Track lifecycle ──────────────────────────────────────────────
+  async addTrack(trackData, onProgress) {
+    if (!this.isInitialised) await this.init();
+    this.evictLRUDecodedTracks(this._maxDecodedTracks - 1);
+    let stems;
+    let loadHandle = null;
+    let sourceCacheKey = null;
+    const stemUrls = trackData.stemUrls;
+    try {
+      if (stemUrls) {
+        stems = await loadTrackStemsFromMp3Urls(stemUrls, onProgress);
+      } else {
+        sourceCacheKey = trackData.url;
+        const cached = this.sourceCache.get(sourceCacheKey);
+        if (cached) {
+          cached.refCount++;
+          stems = cached.stems;
+          loadHandle = cached.loadHandle;
+          onProgress?.({ phase: "decoding", percent: 100, detail: "Using shared source decode" });
+        } else {
+          const result = await loadTrackStemsProgressively(
+            trackData.url,
+            trackData.duration,
+            onProgress
+          );
+          stems = result.initial;
+          loadHandle = result.handle;
+          this.sourceCache.set(sourceCacheKey, {
+            url: sourceCacheKey,
+            refCount: 1,
+            stems,
+            loadHandle
+          });
+        }
+      }
+    } catch (err) {
+      console.error("[DAWController] Failed to load stems:", err);
+      return null;
+    }
+    const store = useDAWSessionStore.getState();
+    const dawTrack = store.addTrack(trackData);
+    const trackId = dawTrack.id;
+    const trackGain = this.ctx.createGain();
+    trackGain.connect(this.masterGain);
+    let pitchWorklet = null;
+    if (this._pitchWorkletAvailable) {
+      try {
+        const settings = dawTrack.pitchSettings;
+        if (USE_PHAZE) {
+          pitchWorklet = new AudioWorkletNode(this.ctx, PITCH_WORKLET_NAME, {
+            channelCount: 2,
+            channelCountMode: "explicit",
+            outputChannelCount: [2]
+          });
+        } else {
+          pitchWorklet = new AudioWorkletNode(this.ctx, PITCH_WORKLET_NAME, {
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            channelCount: 2,
+            channelCountMode: "explicit",
+            outputChannelCount: [2],
+            processorOptions: {
+              pitchTransitionStep: 1,
+              formantOption: settings.formantOption,
+              pitchOption: settings.pitchOption,
+              engineOption: settings.engineOption,
+              quality: true
+            }
+          });
+        }
+        pitchWorklet.connect(trackGain);
+        this.configurePitchWorklet(pitchWorklet, settings);
+      } catch (err) {
+        console.warn("[DAWController] Failed to create pitch worklet for track:", err);
+        pitchWorklet = null;
+      }
+    }
+    const stemTarget = pitchWorklet ?? trackGain;
+    const worklets = [];
+    const stemGains = [];
+    const stemEffects = [];
+    const freshStore = useDAWSessionStore.getState();
+    const freshTrack = freshStore.getTrackById(trackId);
+    const barMap = buildBarMap(
+      freshTrack.barMapping,
+      freshStore.masterBarLength48000,
+      freshTrack.nativeBarLength,
+      freshStore.barSubdivisions
+    );
+    STEM_LABELS2.forEach((label, stemIdx) => {
+      const stemGain = this.ctx.createGain();
+      stemGain.connect(stemTarget);
+      const fxChain = new StemEffectChain(this.ctx);
+      fxChain.output.connect(stemGain);
+      const worklet = new AudioWorkletNode(this.ctx, "daw-stem-processor", {
+        numberOfInputs: 0,
+        numberOfOutputs: 1,
+        outputChannelCount: [2]
+      });
+      worklet.connect(fxChain.input);
+      const buf = stems[label];
+      if (buf) {
+        const channels = [];
+        for (let ch = 0; ch < buf.numberOfChannels; ch++) {
+          channels.push(new Float32Array(buf.getChannelData(ch)));
+        }
+        worklet.port.postMessage({ type: "load-buffer", channels }, channels.map((c) => c.buffer));
+      }
+      worklet.port.postMessage({ type: "load-bar-map", entries: barMap });
+      worklet.port.postMessage({ type: "set-global-rate", rate: freshStore.globalPlaybackRate });
+      if (stemIdx === 0) {
+        worklet.port.onmessage = (msg) => {
+          const d = msg.data;
+          if (d?.type === "bar-changed") {
+            this.handleWorkletBarChange(trackId, d.barIndex);
+          }
+        };
+      }
+      worklets.push(worklet);
+      stemGains.push(stemGain);
+      stemEffects.push(fxChain);
+    });
+    const barPitchMap = buildBarPitchMap(barMap);
+    const rt = {
+      stems,
+      worklets,
+      stemGains,
+      stemEffects,
+      trackGain,
+      pitchWorklet,
+      barPitchMap,
+      currentPitchBar: -1,
+      autotuneOffset: 0,
+      lastPitchStr: "",
+      loadHandle,
+      sourceCacheKey,
+      unsubscribePatch: null,
+      playable: loadHandle ? false : true,
+      loaded: loadHandle ? false : true,
+      dumped: false,
+      lastAccessAt: performance.now(),
+      trackData
+    };
+    this.tracks.set(trackId, rt);
+    this.syncWorkletPitchMap(trackId);
+    this.syncPitchForTrack(trackId);
+    this.syncGainsForTrack(trackId);
+    if (loadHandle) {
+      const totalSamples = loadHandle.totalSamples;
+      for (const stemKey of ["bass", "drums", "other", "vocals"]) {
+        initMipmapsForTrack(trackId, stemKey, totalSamples);
+      }
+      const unsubscribe = loadHandle.onPatch((patch) => {
+        const rtNow = this.tracks.get(trackId);
+        if (!rtNow) return;
+        if (rtNow.dumped) return;
+        rtNow.lastAccessAt = performance.now();
+        const stemIdx = STEM_LABELS2.indexOf(patch.stem);
+        if (stemIdx < 0) return;
+        const w = rtNow.worklets[stemIdx];
+        const [left, right] = patch.samples;
+        const workletL = new Float32Array(left);
+        const workletR = new Float32Array(right);
+        const mirrorL = new Float32Array(left);
+        const mirrorR = new Float32Array(right);
+        w.port.postMessage(
+          { type: "patch-buffer", sampleOffset: patch.sampleOffset, channels: [workletL, workletR] },
+          [workletL.buffer, workletR.buffer]
+        );
+        const buf = rtNow.stems[patch.stem];
+        if (buf) {
+          const writeStart = patch.sampleOffset;
+          const remaining = buf.length - writeStart;
+          const writeLen = Math.max(0, Math.min(mirrorL.length, remaining));
+          if (writeLen > 0) {
+            const ch0 = buf.getChannelData(0);
+            ch0.set(mirrorL.subarray(0, writeLen), writeStart);
+            if (buf.numberOfChannels > 1) {
+              const ch1 = buf.getChannelData(1);
+              ch1.set(mirrorR.subarray(0, writeLen), writeStart);
+            }
+          }
+        }
+        appendPeaksToMipmapCache(
+          trackId,
+          patch.stem,
+          patch.sampleOffset,
+          mirrorL,
+          mirrorR
+        );
+      });
+      rt.unsubscribePatch = unsubscribe;
+      if (sourceCacheKey && this.sourceCache.get(sourceCacheKey)?.refCount && this.sourceCache.get(sourceCacheKey).refCount > 1) {
+        for (const stemKey of ["bass", "drums", "other", "vocals"]) {
+          const buf = stems[stemKey];
+          if (!buf) continue;
+          const ch0 = new Float32Array(buf.getChannelData(0));
+          const ch1 = buf.numberOfChannels > 1 ? new Float32Array(buf.getChannelData(1)) : ch0;
+          appendPeaksToMipmapCache(trackId, stemKey, 0, ch0, ch1);
+        }
+      }
+      loadHandle.playable.then(() => {
+        const rtNow = this.tracks.get(trackId);
+        if (!rtNow) return;
+        rtNow.playable = true;
+        this.emit("trackPlayable", trackId);
+      }).catch((err) => {
+        console.warn("[DAWController] progressive load failed before playable threshold:", err);
+      });
+      loadHandle.complete.then(() => {
+        const rtNow = this.tracks.get(trackId);
+        if (!rtNow) return;
+        rtNow.loaded = true;
+        this.emit("trackLoaded", trackId);
+        void cacheFullFileForOffline(trackData.url);
+      }).catch((err) => {
+        console.warn("[DAWController] progressive load failed:", err);
+      });
+    }
+    this.emit("trackAdded", trackId);
+    return dawTrack;
+  }
+  // ── Decoded-tracks memory cap (dump / rehydrate) ─────────────────
+  /**
+   * Read the current cap. See `DEFAULT_MAX_DECODED_TRACKS` for context.
+   */
+  get maxDecodedTracks() {
+    return this._maxDecodedTracks;
+  }
+  /**
+   * Update the soft cap on simultaneously-decoded tracks. If the new cap
+   * is lower than the current decoded count, the surplus LRU tracks are
+   * dumped immediately.
+   */
+  setMaxDecodedTracks(n) {
+    const clamped = Math.max(1, Math.floor(n));
+    if (clamped === this._maxDecodedTracks) return;
+    this._maxDecodedTracks = clamped;
+    this.evictLRUDecodedTracks(clamped);
+    this.emit("maxDecodedTracksChanged", clamped);
+  }
+  /** Tracks currently holding their decoded PCM in memory. */
+  decodedTrackCount() {
+    let n = 0;
+    for (const rt of this.tracks.values()) if (!rt.dumped) n++;
+    return n;
+  }
+  /** True if the named track is currently audible (playing into its range). */
+  isTrackAudible(trackId) {
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!track) return false;
+    const bar = store.playheadBar;
+    for (const ch of track.channels) {
+      const visStart = ch.timelineStartBar + ch.trimStartBar;
+      const visEnd = ch.timelineStartBar + ch.trimEndBar;
+      if (bar >= visStart && bar <= visEnd) return true;
+    }
+    return false;
+  }
+  /**
+   * Free PCM from the least-recently-used undumped tracks until at most
+   * `keep` tracks remain decoded. Audible tracks (containing the playhead)
+   * and currently-transitioning tracks are excluded from eviction so
+   * playback never goes silent unexpectedly.
+   */
+  evictLRUDecodedTracks(keep) {
+    const max = Math.max(0, Math.floor(keep));
+    let decoded = this.decodedTrackCount();
+    if (decoded <= max) return;
+    const candidates = [];
+    for (const [id, rt] of this.tracks) {
+      if (rt.dumped) continue;
+      if (rt.transitioning) continue;
+      if (this.isTrackAudible(id)) continue;
+      candidates.push({ id, rt });
+    }
+    candidates.sort((a, b) => a.rt.lastAccessAt - b.rt.lastAccessAt);
+    while (decoded > max && candidates.length > 0) {
+      const victim = candidates.shift();
+      if (!victim) break;
+      this.dumpTrackAudio(victim.id);
+      decoded--;
+    }
+    if (decoded > max) {
+      console.warn(
+        `[DAWController] decoded-tracks cap exceeded: have ${decoded}, want ${max}, but all extras are audible/transitioning.`
+      );
+    }
+  }
+  /**
+   * Release the decoded PCM held by a track to free memory without
+   * removing the track from the timeline. The worklets, gains, and
+   * effect chain stay wired so rehydration is a single message away.
+   *
+   *   - Worklet stem buffers: `dump-buffer` clears the Float32Arrays.
+   *   - Main-thread mirror (`rt.stems`): replaced with 1-sample silent
+   *     AudioBuffers so legacy consumers (BarSampler, paste-audio) don't
+   *     null-deref. Re-allocated to full length on rehydrate.
+   *   - Waveform mipmaps: cleared so the timeline shows a flat
+   *     centerline until the track is rehydrated.
+   *   - In-flight decode: aborted (refcount on shared source decremented).
+   */
+  dumpTrackAudio(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt || rt.dumped) return;
+    rt.transitioning = true;
+    try {
+      try {
+        rt.unsubscribePatch?.();
+      } catch {
+      }
+      rt.unsubscribePatch = null;
+      if (rt.sourceCacheKey) {
+        const entry = this.sourceCache.get(rt.sourceCacheKey);
+        if (entry) {
+          entry.refCount--;
+          if (entry.refCount <= 0) {
+            try {
+              entry.loadHandle?.abort();
+            } catch {
+            }
+            this.sourceCache.delete(rt.sourceCacheKey);
+          }
+        }
+      } else {
+        try {
+          rt.loadHandle?.abort();
+        } catch {
+        }
+      }
+      rt.loadHandle = null;
+      rt.sourceCacheKey = null;
+      for (const w of rt.worklets) {
+        try {
+          w.port.postMessage({ type: "dump-buffer" });
+        } catch {
+        }
+      }
+      for (let i = 0; i < rt.worklets.length; i++) {
+        const key = `${trackId}:${i}`;
+        this._stemActive.set(key, false);
+      }
+      if (this.ctx) {
+        const ctx = this.ctx;
+        const silent = () => ctx.createBuffer(2, 1, SAMPLE_RATE3);
+        rt.stems = {
+          other: silent(),
+          vocals: silent(),
+          bass: silent(),
+          drums: silent()
+        };
+      }
+      clearWaveformCacheForTrack(trackId);
+      rt.dumped = true;
+      rt.playable = false;
+      rt.loaded = false;
+    } finally {
+      rt.transitioning = false;
+    }
+    this.emit("trackDumped", trackId);
+  }
+  /**
+   * Re-decode a previously-dumped track from IndexedDB (the encoded fMP4
+   * stays cached even after dump). Reuses the existing worklet/audio
+   * graph — no node recreation — so rehydration is just a fresh
+   * progressive decode that streams patches back into the same
+   * worklets and mipmap cache.
+   *
+   * Returns true once `loadHandle.playable` resolves (enough audio for
+   * playback to start). Background batches continue filling the buffer.
+   */
+  async rehydrateTrackAudio(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt) return false;
+    if (!rt.dumped || rt.transitioning) return !rt.dumped;
+    if (!this.isInitialised) await this.init();
+    this.evictLRUDecodedTracks(this._maxDecodedTracks - 1);
+    rt.transitioning = true;
+    rt.lastAccessAt = performance.now();
+    try {
+      const stemUrls = rt.trackData.stemUrls;
+      let stems;
+      let loadHandle = null;
+      let sourceCacheKey = null;
+      if (stemUrls) {
+        stems = await loadTrackStemsFromMp3Urls(stemUrls);
+      } else {
+        sourceCacheKey = rt.trackData.url;
+        const cached = this.sourceCache.get(sourceCacheKey);
+        if (cached) {
+          cached.refCount++;
+          stems = cached.stems;
+          loadHandle = cached.loadHandle;
+        } else {
+          const result = await loadTrackStemsProgressively(
+            rt.trackData.url,
+            rt.trackData.duration
+          );
+          stems = result.initial;
+          loadHandle = result.handle;
+          this.sourceCache.set(sourceCacheKey, {
+            url: sourceCacheKey,
+            refCount: 1,
+            stems,
+            loadHandle
+          });
+        }
+      }
+      rt.stems = stems;
+      rt.loadHandle = loadHandle;
+      rt.sourceCacheKey = sourceCacheKey;
+      rt.dumped = false;
+      rt.playable = loadHandle ? false : true;
+      rt.loaded = loadHandle ? false : true;
+      STEM_LABELS2.forEach((label, stemIdx) => {
+        const buf = stems[label];
+        const w = rt.worklets[stemIdx];
+        if (!buf || !w) return;
+        const channels = [];
+        for (let ch = 0; ch < buf.numberOfChannels; ch++) {
+          channels.push(new Float32Array(buf.getChannelData(ch)));
+        }
+        w.port.postMessage({ type: "load-buffer", channels }, channels.map((c) => c.buffer));
+      });
+      if (loadHandle) {
+        const totalSamples = loadHandle.totalSamples;
+        for (const stemKey of ["bass", "drums", "other", "vocals"]) {
+          initMipmapsForTrack(trackId, stemKey, totalSamples);
+        }
+        rt.unsubscribePatch = loadHandle.onPatch((patch) => {
+          const rtNow = this.tracks.get(trackId);
+          if (!rtNow || rtNow.dumped) return;
+          rtNow.lastAccessAt = performance.now();
+          const stemIdx = STEM_LABELS2.indexOf(patch.stem);
+          if (stemIdx < 0) return;
+          const w = rtNow.worklets[stemIdx];
+          const [left, right] = patch.samples;
+          const workletL = new Float32Array(left);
+          const workletR = new Float32Array(right);
+          const mirrorL = new Float32Array(left);
+          const mirrorR = new Float32Array(right);
+          w.port.postMessage(
+            { type: "patch-buffer", sampleOffset: patch.sampleOffset, channels: [workletL, workletR] },
+            [workletL.buffer, workletR.buffer]
+          );
+          const buf = rtNow.stems[patch.stem];
+          if (buf) {
+            const writeStart = patch.sampleOffset;
+            const remaining = buf.length - writeStart;
+            const writeLen = Math.max(0, Math.min(mirrorL.length, remaining));
+            if (writeLen > 0) {
+              const ch0 = buf.getChannelData(0);
+              ch0.set(mirrorL.subarray(0, writeLen), writeStart);
+              if (buf.numberOfChannels > 1) {
+                const ch1 = buf.getChannelData(1);
+                ch1.set(mirrorR.subarray(0, writeLen), writeStart);
+              }
+            }
+          }
+          appendPeaksToMipmapCache(
+            trackId,
+            patch.stem,
+            patch.sampleOffset,
+            mirrorL,
+            mirrorR
+          );
+        });
+        loadHandle.playable.then(() => {
+          const rtNow = this.tracks.get(trackId);
+          if (!rtNow || rtNow.dumped) return;
+          rtNow.playable = true;
+          this.emit("trackPlayable", trackId);
+        }).catch(() => {
+        });
+        loadHandle.complete.then(() => {
+          const rtNow = this.tracks.get(trackId);
+          if (!rtNow || rtNow.dumped) return;
+          rtNow.loaded = true;
+          this.emit("trackLoaded", trackId);
+        }).catch(() => {
+        });
+      }
+      this.emit("trackRehydrated", trackId);
+      return true;
+    } catch (err) {
+      console.error("[DAWController] Failed to rehydrate track:", trackId, err);
+      return false;
+    } finally {
+      rt.transitioning = false;
+    }
+  }
+  /** True if a track's decoded PCM has been freed. */
+  isTrackDumped(trackId) {
+    return !!this.tracks.get(trackId)?.dumped;
+  }
+  removeTrack(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (rt) {
+      try {
+        rt.unsubscribePatch?.();
+      } catch {
+      }
+      if (rt.sourceCacheKey) {
+        const entry = this.sourceCache.get(rt.sourceCacheKey);
+        if (entry) {
+          entry.refCount--;
+          if (entry.refCount <= 0) {
+            try {
+              entry.loadHandle?.abort();
+            } catch {
+            }
+            this.sourceCache.delete(rt.sourceCacheKey);
+          }
+        }
+      } else {
+        try {
+          rt.loadHandle?.abort();
+        } catch {
+        }
+      }
+      rt.worklets.forEach((w) => {
+        w.port.postMessage({ type: "stop" });
+        w.disconnect();
+      });
+      rt.stemEffects.forEach((fx) => fx.dispose());
+      rt.stemGains.forEach((g) => g.disconnect());
+      try {
+        rt.pitchWorklet?.disconnect();
+      } catch {
+      }
+      rt.trackGain.disconnect();
+    }
+    this.tracks.delete(trackId);
+    clearWaveformCacheForTrack(trackId);
+    useDAWSessionStore.getState().removeTrack(trackId);
+    this.emit("trackRemoved", trackId);
+  }
+  getStemBuffers(trackId) {
+    return this.tracks.get(trackId)?.stems;
+  }
+  getStemEffectChain(trackId, stemIndex) {
+    return this.tracks.get(trackId)?.stemEffects[stemIndex] ?? null;
+  }
+  updateStemEffects(trackId, stemIndex, fx) {
+    const chain = this.getStemEffectChain(trackId, stemIndex);
+    if (chain) chain.applyAll(fx);
+    useDAWSessionStore.getState().setChannelEffects(trackId, stemIndex, fx);
+  }
+  // ── Per-bar precise seeking ──────────────────────────────────────
+  /**
+   * Compute the native buffer sample position for a stem at a given
+   * global timeline bar, using the track's barMapping for precision.
+   *
+   * Returns null if the stem is outside its active region.
+   */
+  computeStemSeekSamples(globalBar, channel, track) {
+    const visibleStart = channel.timelineStartBar + channel.trimStartBar;
+    const visibleEnd = channel.timelineStartBar + channel.trimEndBar;
+    if (globalBar < visibleStart || globalBar > visibleEnd) return null;
+    const localBar = globalBar - channel.timelineStartBar;
+    const barMapping = track.barMapping;
+    if (!barMapping || barMapping.length === 0) return null;
+    const barIdx = Math.min(Math.floor(localBar), barMapping.length - 1);
+    const barFrac = localBar - Math.floor(localBar);
+    const bar = barMapping[barIdx];
+    return Math.floor(bar.sampleStart + barFrac * bar.duration);
+  }
+  // ── Transport ────────────────────────────────────────────────────
+  async play() {
+    if (!this.isInitialised) await this.init();
+    if (this.ctx.state !== "running") {
+      console.log("[DAWController.play] AudioContext state:", this.ctx.state, "\u2014 resuming\u2026");
+      await this.ctx.resume();
+      const stateAfterResume = this.ctx.state;
+      if (stateAfterResume !== "running") {
+        await new Promise((resolve) => {
+          const check = () => {
+            if (this.ctx.state === "running") return resolve();
+            this.ctx.addEventListener("statechange", check, { once: true });
+            setTimeout(resolve, 500);
+          };
+          check();
+        });
+        console.log("[DAWController.play] AudioContext state after wait:", this.ctx.state);
+      }
+    }
+    const store = useDAWSessionStore.getState();
+    const globalBar = store.playheadBar;
+    for (const [trackId, rt] of this.tracks) {
+      if (!rt.dumped) continue;
+      if (!this.isTrackAudible(trackId)) continue;
+      rt.lastAccessAt = performance.now();
+      void this.rehydrateTrackAudio(trackId);
+    }
+    let stemsActivated = 0;
+    let stemsPaused = 0;
+    for (const [trackId, rt] of this.tracks) {
+      const track = store.getTrackById(trackId);
+      if (!track) continue;
+      track.channels.forEach((ch, i) => {
+        const key = `${trackId}:${i}`;
+        const seekPos = this.computeStemSeekSamples(globalBar, ch, track);
+        const w = rt.worklets[i];
+        if (seekPos !== null) {
+          w.port.postMessage({ type: "seek", position: seekPos });
+          w.port.postMessage({ type: "play" });
+          this._stemActive.set(key, true);
+          stemsActivated++;
+          rt.lastAccessAt = performance.now();
+        } else {
+          w.port.postMessage({ type: "pause" });
+          this._stemActive.set(key, false);
+          stemsPaused++;
+        }
+      });
+    }
+    if (stemsActivated === 0 && this.tracks.size > 0) {
+      const debugInfo = [];
+      for (const [trackId] of this.tracks) {
+        const t = store.getTrackById(trackId);
+        debugInfo.push({
+          trackId,
+          found: !!t,
+          barMappingLen: t?.barMapping?.length ?? -1,
+          channels: t?.channels.map((ch) => ({
+            timelineStart: ch.timelineStartBar,
+            trimStart: ch.trimStartBar,
+            trimEnd: ch.trimEndBar,
+            visibleStart: ch.timelineStartBar + ch.trimStartBar,
+            visibleEnd: ch.timelineStartBar + ch.trimEndBar
+          }))
+        });
+      }
+      console.warn("[DAWController.play] No stems activated!", {
+        globalBar,
+        trackCount: this.tracks.size,
+        stemsPaused,
+        audioCtxState: this.ctx.state,
+        tracks: debugInfo
+      });
+    }
+    this._playStartCtxTime = this.ctx.currentTime;
+    this._playStartOffset = this.barToSeconds(globalBar);
+    this._playing = true;
+    store.setPlaying(true);
+    if (this._nativeModeTrackId) {
+      const nTrack = store.getTrackById(this._nativeModeTrackId);
+      if (nTrack) {
+        const ch0 = nTrack.channels[0];
+        const seekPos = ch0 ? this.computeStemSeekSamples(globalBar, ch0, nTrack) : null;
+        this._nativeStartSample = seekPos ?? 0;
+      }
+    }
+    for (const [trackId, rt] of this.tracks) {
+      rt.currentPitchBar = -1;
+      rt.lastPitchStr = "";
+      this.sendInitialBarPitch(trackId, globalBar);
+    }
+    this.startPlayheadAnimation();
+    if (this._metronomeOn) this.startMetronomeScheduler();
+    this.emit("playing");
+  }
+  pause() {
+    if (this._playing) {
+      if (this._nativeModeTrackId) {
+        this._nativeStartSample = this.getNativePositionSec() * SAMPLE_RATE3;
+      }
+      const posSec = this.getCurrentPositionSec();
+      useDAWSessionStore.getState().setPlayheadBar(this.secondsToBar(posSec));
+    }
+    for (const [, rt] of this.tracks) {
+      rt.currentPitchBar = -1;
+      rt.lastPitchStr = "";
+      for (const w of rt.worklets) {
+        w.port.postMessage({ type: "pause" });
+      }
+    }
+    this._playing = false;
+    useDAWSessionStore.getState().setPlaying(false);
+    this.stopPlayheadAnimation();
+    this.stopMetronomeScheduler();
+    for (const trackId of this.tracks.keys()) {
+      this.syncPitchForTrack(trackId);
+    }
+    this.emit("paused");
+  }
+  stop() {
+    for (const [, rt] of this.tracks) {
+      for (const w of rt.worklets) {
+        w.port.postMessage({ type: "stop" });
+      }
+    }
+    this._playing = false;
+    const store = useDAWSessionStore.getState();
+    store.setPlaying(false);
+    store.setPlayheadBar(0);
+    this.stopPlayheadAnimation();
+    this.stopMetronomeScheduler();
+    this.emit("stopped");
+  }
+  async seekToBar(bar) {
+    const gen = ++this._seekGen;
+    const wasPlaying = this._playing;
+    const store = useDAWSessionStore.getState();
+    store.setPlayheadBar(bar);
+    if (wasPlaying) {
+      for (const [trackId, rt] of this.tracks) {
+        if (!rt.dumped) continue;
+        if (!this.isTrackAudible(trackId)) continue;
+        rt.lastAccessAt = performance.now();
+        void this.rehydrateTrackAudio(trackId);
+      }
+    }
+    for (const [trackId, rt] of this.tracks) {
+      const track = store.getTrackById(trackId);
+      if (!track) continue;
+      track.channels.forEach((ch, i) => {
+        const key = `${trackId}:${i}`;
+        const seekPos = this.computeStemSeekSamples(bar, ch, track);
+        const w = rt.worklets[i];
+        if (seekPos !== null) {
+          w.port.postMessage({ type: "seek", position: seekPos });
+          if (wasPlaying) w.port.postMessage({ type: "play" });
+          this._stemActive.set(key, wasPlaying);
+          if (wasPlaying) rt.lastAccessAt = performance.now();
+        } else if (wasPlaying) {
+          w.port.postMessage({ type: "pause" });
+          this._stemActive.set(key, false);
+        }
+      });
+    }
+    if (wasPlaying && gen === this._seekGen) {
+      this._playStartCtxTime = this.ctx.currentTime;
+      this._playStartOffset = this.barToSeconds(bar);
+      const seekStep = this._metronomeDownbeatOnly ? 1 : 0.25;
+      this._metronomeNextBeat = Math.ceil(bar / seekStep) * seekStep;
+    }
+    if (this._nativeModeTrackId) {
+      const nTrack = store.getTrackById(this._nativeModeTrackId);
+      if (nTrack) {
+        const ch0 = nTrack.channels[0];
+        const seekPos = ch0 ? this.computeStemSeekSamples(bar, ch0, nTrack) : null;
+        this._nativeStartSample = seekPos ?? 0;
+      }
+    }
+    for (const [trackId, rt] of this.tracks) {
+      rt.currentPitchBar = -1;
+      rt.lastPitchStr = "";
+      this.sendInitialBarPitch(trackId, bar);
+    }
+  }
+  // ── Master tempo / playback rate ────────────────────────────────
+  setMasterTempo(bpm) {
+    const wasPlaying = this._playing;
+    const store = useDAWSessionStore.getState();
+    const currentBar = wasPlaying ? this.secondsToBar(this.getCurrentPositionSec()) : store.playheadBar;
+    store.setMasterTempo(bpm);
+    const newStore = useDAWSessionStore.getState();
+    for (const [trackId, rt] of this.tracks) {
+      const track = newStore.getTrackById(trackId);
+      if (!track) continue;
+      const barMap = buildBarMap(
+        track.barMapping,
+        newStore.masterBarLength48000,
+        track.nativeBarLength,
+        newStore.barSubdivisions
+      );
+      rt.barPitchMap = buildBarPitchMap(barMap);
+      rt.currentPitchBar = -1;
+      this.syncWorkletPitchMap(trackId);
+      track.channels.forEach((ch, i) => {
+        const w = rt.worklets[i];
+        w.port.postMessage({ type: "load-bar-map", entries: barMap });
+        const seekPos = this.computeStemSeekSamples(currentBar, ch, track);
+        if (seekPos !== null) {
+          w.port.postMessage({ type: "seek", position: seekPos });
+        }
+      });
+    }
+    if (wasPlaying) {
+      this._playStartOffset = this.barToSeconds(currentBar);
+      this._playStartCtxTime = this.ctx.currentTime;
+    } else {
+      newStore.setPlayheadBar(currentBar);
+    }
+    this.emit("tempoChanged", bpm);
+  }
+  /**
+   * Reorder a track and, if it becomes the new first track, promote it as master.
+   * Handles worklet bar map / pitch resync the same way setMasterTempo does.
+   */
+  reorderTrack(trackId, newIndex) {
+    const wasPlaying = this._playing;
+    const store = useDAWSessionStore.getState();
+    const currentBar = wasPlaying ? this.secondsToBar(this.getCurrentPositionSec()) : store.playheadBar;
+    const oldMasterId = store.tracks[0]?.id;
+    store.reorderTrack(trackId, newIndex);
+    const newStore = useDAWSessionStore.getState();
+    const newMasterId = newStore.tracks[0]?.id;
+    if (newMasterId !== oldMasterId) {
+      for (const [tid, rt] of this.tracks) {
+        const track = newStore.getTrackById(tid);
+        if (!track) continue;
+        const barMap = buildBarMap(
+          track.barMapping,
+          newStore.masterBarLength48000,
+          track.nativeBarLength,
+          newStore.barSubdivisions
+        );
+        rt.barPitchMap = buildBarPitchMap(barMap);
+        rt.currentPitchBar = -1;
+        this.syncWorkletPitchMap(tid);
+        this.syncPitchForTrack(tid);
+        track.channels.forEach((ch, i) => {
+          const w = rt.worklets[i];
+          w.port.postMessage({ type: "load-bar-map", entries: barMap });
+          const seekPos = this.computeStemSeekSamples(currentBar, ch, track);
+          if (seekPos !== null) {
+            w.port.postMessage({ type: "seek", position: seekPos });
+          }
+        });
+      }
+      if (wasPlaying) {
+        this._playStartOffset = this.barToSeconds(currentBar);
+        this._playStartCtxTime = this.ctx.currentTime;
+      } else {
+        newStore.setPlayheadBar(currentBar);
+      }
+      this.emit("tempoChanged", newStore.masterTempo);
+    }
+  }
+  setGlobalPlaybackRate(rate) {
+    if (this._playing) {
+      const posSec = this.getCurrentPositionSec();
+      useDAWSessionStore.getState().setGlobalPlaybackRate(rate);
+      this._playStartOffset = posSec;
+      this._playStartCtxTime = this.ctx.currentTime;
+    } else {
+      useDAWSessionStore.getState().setGlobalPlaybackRate(rate);
+    }
+    this.broadcastGlobalRate();
+    this.emit("playbackRateChanged", rate);
+  }
+  broadcastGlobalRate() {
+    const rate = useDAWSessionStore.getState().globalPlaybackRate;
+    for (const [, rt] of this.tracks) {
+      for (const w of rt.worklets) {
+        w.port.postMessage({ type: "set-global-rate", rate });
+      }
+    }
+  }
+  // ── Gain / mute / solo sync ──────────────────────────────────────
+  syncGainsForTrack(trackId) {
+    const state = useDAWSessionStore.getState();
+    const track = state.getTrackById(trackId);
+    const rt = this.tracks.get(trackId);
+    if (!track || !rt) return;
+    const hasSoloedTrack = state.tracks.some((t) => t.soloed);
+    const trackAudible = hasSoloedTrack ? track.soloed : !track.muted;
+    rt.trackGain.gain.setValueAtTime(trackAudible ? track.volume : 0, this.ctx.currentTime);
+    const globalSoloedStems = /* @__PURE__ */ new Set();
+    for (const t of state.tracks) {
+      for (const ch of t.channels) {
+        if (ch.soloed && ch.visible) globalSoloedStems.add(ch.stemIndex);
+      }
+    }
+    const hasAnySoloedStem = globalSoloedStems.size > 0;
+    track.channels.forEach((ch, i) => {
+      const audible = ch.visible && (hasAnySoloedStem ? ch.soloed : !ch.muted);
+      rt.stemGains[i]?.gain.setValueAtTime(audible ? ch.volume : 0, this.ctx.currentTime);
+    });
+  }
+  syncAllGains() {
+    for (const trackId of this.tracks.keys()) this.syncGainsForTrack(trackId);
+  }
+  /** Send mute regions for a specific stem to its worklet (bar-based → sample-based) */
+  syncMuteRegions(trackId, stemIndex) {
+    const rt = this.tracks.get(trackId);
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!rt || !track) return;
+    const ch = track.channels.find((c) => c.stemIndex === stemIndex);
+    if (!ch) return;
+    const barMapping = track.barMapping;
+    const sampleRegions = ch.muteRegions.map((r) => {
+      const sStart = barToSample(r.startBar, barMapping);
+      const sEnd = barToSample(r.endBar, barMapping);
+      return { sampleStart: sStart, sampleEnd: sEnd };
+    });
+    const w = rt.worklets[stemIndex];
+    if (w) w.port.postMessage({ type: "load-mute-regions", regions: sampleRegions });
+  }
+  /** Sync mute regions for all stems of a track */
+  syncAllMuteRegionsForTrack(trackId) {
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!track) return;
+    for (const ch of track.channels) {
+      this.syncMuteRegions(trackId, ch.stemIndex);
+    }
+  }
+  /**
+   * Rebuild and re-send the bar map for a track to all its stem worklets.
+   * Call after the track's barMapping has been modified (e.g. beat grid nudge).
+   */
+  reloadTrackBarMap(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt) return;
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!track) return;
+    const isNativeTrack = this._nativeModeTrackId === trackId;
+    const barMap = isNativeTrack ? track.barMapping.map((bar) => ({ sampleStart: bar.sampleStart, speed: 1 })) : buildBarMap(
+      track.barMapping,
+      store.masterBarLength48000,
+      track.nativeBarLength,
+      store.barSubdivisions
+    );
+    if (isNativeTrack) {
+      rt.barPitchMap = barMap.map(() => ({ pitchCorrectionSemitones: 0, speed: 1 }));
+    } else {
+      rt.barPitchMap = buildBarPitchMap(barMap);
+    }
+    rt.currentPitchBar = -1;
+    const wasPlaying = this._playing;
+    const currentBar = store.playheadBar;
+    track.channels.forEach((ch, i) => {
+      const w = rt.worklets[i];
+      if (!w) return;
+      w.port.postMessage({ type: "load-bar-map", entries: barMap });
+      const seekPos = this.computeStemSeekSamples(currentBar, ch, track);
+      if (seekPos !== null) {
+        w.port.postMessage({ type: "seek", position: seekPos });
+        if (wasPlaying) w.port.postMessage({ type: "play" });
+      }
+    });
+    if (!isNativeTrack) {
+      this.syncWorkletPitchMap(trackId);
+      this.syncPitchForTrack(trackId);
+    }
+    this.syncAllMuteRegionsForTrack(trackId);
+    if (wasPlaying) {
+      this._playStartOffset = this.barToSeconds(currentBar);
+      this._playStartCtxTime = this.ctx.currentTime;
+    }
+  }
+  // ── Native playback mode (Beat Lab) ────────────────────────────────
+  /**
+   * Enable or disable native playback for a track. When enabled, the track
+   * plays at its original recorded tempo (speed = 1.0 for every bar) with no
+   * pitch compensation. This allows the Beat Lab to display beat markers at
+   * their true sample positions and have them match the audible audio exactly.
+   */
+  setNativePlaybackMode(trackId, enabled) {
+    const rt = this.tracks.get(trackId);
+    if (!rt) return;
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!track) return;
+    const wasPlaying = this._playing;
+    if (wasPlaying) this.pause();
+    if (enabled) {
+      const quantizedBarMap = buildBarMap(
+        track.barMapping,
+        store.masterBarLength48000,
+        track.nativeBarLength,
+        store.barSubdivisions
+      );
+      this._nativeModeOriginalBarMap = quantizedBarMap;
+      this._nativeModeTrackId = trackId;
+      const nativeBarMap = track.barMapping.map((bar) => ({
+        sampleStart: bar.sampleStart,
+        speed: 1
+      }));
+      for (const w of rt.worklets) {
+        w.port.postMessage({ type: "load-bar-map", entries: nativeBarMap });
+      }
+      rt.barPitchMap = nativeBarMap.map(() => ({ pitchCorrectionSemitones: 0, speed: 1 }));
+      rt.currentPitchBar = -1;
+      if (rt.pitchWorklet) {
+        try {
+          for (const g of rt.stemGains) {
+            g.disconnect();
+            g.connect(rt.trackGain);
+          }
+        } catch (err) {
+          console.warn("[DAWController] Failed to bypass pitch worklet for native mode:", err);
+        }
+      }
+    } else {
+      this._nativeModeTrackId = null;
+      this._nativeModeOriginalBarMap = null;
+      if (rt.pitchWorklet) {
+        try {
+          for (const g of rt.stemGains) {
+            g.disconnect();
+            g.connect(rt.pitchWorklet);
+          }
+        } catch (err) {
+          console.warn("[DAWController] Failed to restore pitch worklet routing:", err);
+        }
+      }
+      const barMap = buildBarMap(
+        track.barMapping,
+        store.masterBarLength48000,
+        track.nativeBarLength,
+        store.barSubdivisions
+      );
+      for (const w of rt.worklets) {
+        w.port.postMessage({ type: "load-bar-map", entries: barMap });
+      }
+      rt.barPitchMap = buildBarPitchMap(barMap);
+      rt.currentPitchBar = -1;
+      this.syncWorkletPitchMap(trackId);
+      this.syncPitchForTrack(trackId);
+    }
+    store.setPlayheadBar(0);
+  }
+  isNativePlaybackMode() {
+    return this._nativeModeTrackId !== null;
+  }
+  get nativeModeTrackId() {
+    return this._nativeModeTrackId;
+  }
+  /**
+   * Get the current playback position in native (unquantized) seconds.
+   * Only meaningful when native playback mode is active.
+   */
+  getNativePositionSec() {
+    if (!this.ctx || !this._nativeModeTrackId) return 0;
+    if (!this._playing) return this._nativeStartSample / SAMPLE_RATE3;
+    const globalRate = useDAWSessionStore.getState().globalPlaybackRate;
+    const elapsedSec = (this.ctx.currentTime - this._playStartCtxTime) * globalRate;
+    return this._nativeStartSample / SAMPLE_RATE3 + elapsedSec;
+  }
+  /**
+   * Seek to a native sample position (used by beat lab scrubbing).
+   * Only works when native playback mode is active.
+   */
+  seekToNativeSample(sample) {
+    if (!this._nativeModeTrackId) return;
+    const rt = this.tracks.get(this._nativeModeTrackId);
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(this._nativeModeTrackId);
+    if (!rt || !track) return;
+    this._nativeStartSample = sample;
+    for (let i = 0; i < rt.worklets.length; i++) {
+      const w = rt.worklets[i];
+      w.port.postMessage({ type: "seek", position: Math.floor(sample) });
+      if (this._playing) w.port.postMessage({ type: "play" });
+    }
+    if (this.ctx) {
+      this._playStartCtxTime = this.ctx.currentTime;
+      this._playStartOffset = sample / SAMPLE_RATE3;
+    }
+    const bm = track.barMapping;
+    if (bm.length > 0) {
+      let barIdx = 0;
+      for (let i = bm.length - 1; i >= 0; i--) {
+        if (bm[i].sampleStart <= sample) {
+          barIdx = i;
+          break;
+        }
+      }
+      const bar = bm[barIdx];
+      const barFrac = bar.duration > 0 ? Math.max(0, Math.min(1, (sample - bar.sampleStart) / bar.duration)) : 0;
+      const tlStart = track.channels[0]?.timelineStartBar ?? 0;
+      store.setPlayheadBar(barIdx + barFrac + tlStart);
+    }
+  }
+  // ── Pitch / transpose ─────────────────────────────────────────────
+  /**
+   * Send the combined pitch factor (correction + transpose) to a track's pitch worklet.
+   * When perBarPitchCompensation is enabled, the per-bar correction is added on top
+   * via updatePerBarPitch() during playback — this method sends the base correction.
+   */
+  syncPitchForTrack(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt?.pitchWorklet) return;
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!track) return;
+    if (track.perBarPitchCompensation && this._playing) {
+      return;
+    }
+    const totalSemitones = track.pitchCorrectionSemitones + track.transposeSemitones + rt.autotuneOffset;
+    const factor = semitonesToPitchFactor(totalSemitones);
+    this.sendPitchToWorklet(rt.pitchWorklet, factor);
+  }
+  /**
+   * Check if we've crossed a bar boundary and send an updated pitch factor
+   * that includes the per-bar pitch compensation for that specific bar.
+   */
+  /**
+   * rAF-driven per-bar pitch update (fallback for seeks / playback start).
+   * handleWorkletBarChange is the primary path — this catches missed bars.
+   */
+  updatePerBarPitch(_trackId, _globalBar) {
+  }
+  /** One-shot pitch send for play/seek — sends the bar's pitch and sets
+   *  lastPitchStr so the rAF path won't duplicate it. */
+  sendInitialBarPitch(trackId, globalBar) {
+    const rt = this.tracks.get(trackId);
+    if (!rt?.pitchWorklet || !this.ctx) return;
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!track?.perBarPitchCompensation) return;
+    const ch0 = track.channels[0];
+    if (!ch0) return;
+    const subs = store.barSubdivisions ?? 1;
+    const localBarF = (globalBar - ch0.timelineStartBar) * subs;
+    const localBar = Math.floor(localBarF);
+    if (localBar < 0 || localBar >= rt.barPitchMap.length) return;
+    rt.currentPitchBar = localBar;
+    const barPitch = rt.barPitchMap[localBar];
+    const totalSemitones = barPitch.pitchCorrectionSemitones + track.transposeSemitones + rt.autotuneOffset;
+    const factor = semitonesToPitchFactor(totalSemitones);
+    const pitchStr = factor.toFixed(2);
+    rt.lastPitchStr = pitchStr;
+    this.sendPitchToWorklet(rt.pitchWorklet, factor);
+  }
+  /** Set user transpose in semitones and update the worklet. */
+  setTrackTranspose(trackId, semitones) {
+    useDAWSessionStore.getState().setTrackTranspose(trackId, semitones);
+    this.syncWorkletPitchMap(trackId);
+    this.syncPitchForTrack(trackId);
+    this.emit("transposeChanged", trackId, semitones);
+  }
+  /** Toggle per-bar pitch compensation for a track. */
+  setPerBarPitchCompensation(trackId, enabled) {
+    useDAWSessionStore.getState().setPerBarPitchCompensation(trackId, enabled);
+    const rt = this.tracks.get(trackId);
+    if (rt) {
+      rt.currentPitchBar = -1;
+      rt.lastPitchStr = "";
+    }
+    this.syncWorkletPitchMap(trackId);
+    if (!enabled) {
+      this.syncPitchForTrack(trackId);
+    } else if (this._playing) {
+      const bar = useDAWSessionStore.getState().playheadBar;
+      this.sendInitialBarPitch(trackId, bar);
+    }
+    this.emit("perBarPitchChanged", trackId, enabled);
+  }
+  /**
+   * Send the per-bar pitch map to the first stem worklet so it can apply a
+   * short crossfade at bar boundaries to mask the ~3ms gap between the
+   * speed change (instant, audio-thread) and the pitch change (next render quantum).
+   * Also sends the pitch map so the worklet can forward pitch commands to
+   * Rubberband via the main thread at the exact bar crossing moment.
+   */
+  syncWorkletPitchMap(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt || rt.worklets.length === 0) return;
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!track) return;
+    const stemWorklet = rt.worklets[0];
+    if (!track.perBarPitchCompensation || !rt.pitchWorklet) {
+      stemWorklet.port.postMessage({ type: "load-pitch-map", entries: [] });
+      return;
+    }
+    const entries = rt.barPitchMap.map((bp) => ({
+      pitchFactor: semitonesToPitchFactor(
+        bp.pitchCorrectionSemitones + track.transposeSemitones + rt.autotuneOffset
+      )
+    }));
+    stemWorklet.port.postMessage({ type: "load-pitch-map", entries });
+  }
+  /** Update rubberband settings for a track. Requires worklet recreation. */
+  setTrackPitchSettings(trackId, settings) {
+    useDAWSessionStore.getState().setTrackPitchSettings(trackId, settings);
+    const rt = this.tracks.get(trackId);
+    if (!rt?.pitchWorklet || !this.ctx || USE_PHAZE) return;
+    const oldWorklet = rt.pitchWorklet;
+    try {
+      const newWorklet = new AudioWorkletNode(this.ctx, PITCH_WORKLET_NAME, {
+        numberOfInputs: 1,
+        numberOfOutputs: 1,
+        channelCount: 2,
+        channelCountMode: "explicit",
+        outputChannelCount: [2]
+      });
+      this.configurePitchWorklet(newWorklet, settings);
+      newWorklet.connect(rt.trackGain);
+      for (const sg of rt.stemGains) {
+        sg.disconnect();
+        sg.connect(newWorklet);
+      }
+      oldWorklet.disconnect();
+      rt.pitchWorklet = newWorklet;
+      this.syncPitchForTrack(trackId);
+    } catch (err) {
+      console.warn("[DAWController] Failed to recreate pitch worklet:", err);
+    }
+  }
+  /**
+   * Apply an autotune pitch offset on top of the current pitch chain.
+   * Called from the autotune panel at ~60fps during playback.
+   * Set autoSemitones=0 to clear the override.
+   */
+  applyAutotuneCorrection(trackId, autoSemitones) {
+    const rt = this.tracks.get(trackId);
+    if (!rt?.pitchWorklet) return;
+    rt.autotuneOffset = autoSemitones;
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!track) return;
+    let baseSemitones = track.transposeSemitones;
+    if (track.perBarPitchCompensation && this._playing && rt.currentPitchBar >= 0 && rt.currentPitchBar < rt.barPitchMap.length) {
+      baseSemitones += rt.barPitchMap[rt.currentPitchBar].pitchCorrectionSemitones;
+    } else {
+      baseSemitones += track.pitchCorrectionSemitones;
+    }
+    const factor = semitonesToPitchFactor(baseSemitones + autoSemitones);
+    this.sendPitchToWorklet(rt.pitchWorklet, factor);
+  }
+  /** Send a pitch factor to the Rubberband pitch worklet. */
+  sendPitchToWorklet(worklet, pitchFactor) {
+    worklet.port.postMessage(JSON.stringify(["pitch", pitchFactor.toFixed(2)]));
+  }
+  /**
+   * Configure a Rubberband pitch worklet via port messages.
+   * The worklet ignores processorOptions — all config must be sent as messages.
+   *
+   * pitchDelayMs controls how many ms the worklet waits after receiving a pitch
+   * command before applying it to Rubberband. This is the single control for
+   * aligning speed changes (instant) with pitch changes (delayed by FFT pipeline).
+   */
+  configurePitchWorklet(worklet, settings) {
+    const delaySamples = Math.round(settings.pitchDelayMs / 1e3 * SAMPLE_RATE3);
+    worklet.port.postMessage(JSON.stringify(["set-pitch-delay", { delaySamples }]));
+    worklet.port.postMessage(JSON.stringify(["pitchTransitionStep", 100]));
+    worklet.port.postMessage(JSON.stringify(["pitchOption", settings.pitchOption]));
+    worklet.port.postMessage(JSON.stringify(["formantOption", settings.formantOption]));
+    worklet.port.postMessage(JSON.stringify(["engineOption", settings.engineOption]));
+    if (!worklet.port.onmessage) {
+      worklet.port.onmessage = (e) => {
+        try {
+          const msg = typeof e.data === "string" ? JSON.parse(e.data) : e.data;
+          if (!msg?.type) return;
+          if (msg.type === "pitch-delayed") {
+            const d = msg.data ?? msg;
+            console.log(
+              `%c[RB Worklet] pitch-delayed target=${d.targetPitch} delay=${d.delaySamples}smp (${(d.delaySamples / SAMPLE_RATE3 * 1e3).toFixed(1)}ms)`,
+              "color: #4fc3f7"
+            );
+          } else if (msg.type === "pitch-applied") {
+            console.log(
+              `%c[RB Worklet] pitch-applied value=${msg.data?.value ?? "?"} @audioTime=${msg.timestamp?.toFixed(3) ?? "?"}`,
+              "color: #4ade80; font-weight: bold"
+            );
+          } else if (msg.type === "pitch-delay-updated" || msg.type === "api-created") {
+            console.log(`%c[RB Worklet] ${msg.type}`, "color: #4fc3f7", msg.data ?? msg);
+          }
+        } catch {
+        }
+      };
+    }
+    console.log(
+      `%c[DAW] Rubberband worklet configured`,
+      "color: #81c784; font-weight: bold",
+      `pitchDelay=${delaySamples} samples (${settings.pitchDelayMs}ms) | ${settings.pitchOption} | ${settings.formantOption} | ${settings.engineOption} | step=100 (instant)`
+    );
+  }
+  get pitchWorkletAvailable() {
+    return this._pitchWorkletAvailable;
+  }
+  get audioContext() {
+    return this.ctx;
+  }
+  /** Get the total semitones currently being applied to a track's pitch worklet. */
+  getCurrentPitchSemitones(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt) return 0;
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!track) return 0;
+    if (track.perBarPitchCompensation && rt.currentPitchBar >= 0 && rt.currentPitchBar < rt.barPitchMap.length) {
+      const barPitch = rt.barPitchMap[rt.currentPitchBar];
+      return barPitch.pitchCorrectionSemitones + track.transposeSemitones + rt.autotuneOffset;
+    }
+    return track.pitchCorrectionSemitones + track.transposeSemitones + rt.autotuneOffset;
+  }
+  /**
+   * Get the pitch artifact (semitones) that the current bar's speed change introduces.
+   * This is the inverse of the compensation: if speed > 1, pitch goes up, etc.
+   * Returns 0 if per-bar compensation isn't active or no bar is current.
+   */
+  getCurrentSpeedPitchArtifact(trackId) {
+    const rt = this.tracks.get(trackId);
+    if (!rt || rt.currentPitchBar < 0 || rt.currentPitchBar >= rt.barPitchMap.length) return 0;
+    return -rt.barPitchMap[rt.currentPitchBar].pitchCorrectionSemitones;
+  }
+  /** Update pitchDelayMs for a track and push it to the Rubberband worklet immediately. */
+  setTrackPitchDelay(trackId, ms) {
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!track) return;
+    const settings = { ...track.pitchSettings ?? DEFAULT_PITCH_SETTINGS, pitchDelayMs: ms };
+    store.setTrackPitchSettings(trackId, settings);
+    const rt = this.tracks.get(trackId);
+    if (rt?.pitchWorklet) {
+      const delaySamples = Math.round(ms / 1e3 * SAMPLE_RATE3);
+      rt.pitchWorklet.port.postMessage(JSON.stringify(["set-pitch-delay", { delaySamples }]));
+      console.log(
+        `%c[DAW] Pitch delay updated`,
+        "color: #81c784; font-weight: bold",
+        `${ms}ms \u2192 ${delaySamples} samples`
+      );
+    }
+  }
+  /** Change bar subdivision and reload all bar maps + pitch maps. */
+  setBarSubdivisions(n) {
+    const store = useDAWSessionStore.getState();
+    store.setBarSubdivisions(n);
+    store.barSubdivisions;
+    for (const [trackId, rt] of this.tracks) {
+      const track = store.getTrackById(trackId);
+      if (!track) continue;
+      const barMap = buildBarMap(
+        track.barMapping,
+        store.masterBarLength48000,
+        track.nativeBarLength,
+        n
+      );
+      rt.barPitchMap = buildBarPitchMap(barMap);
+      rt.currentPitchBar = -1;
+      for (const w of rt.worklets) {
+        w.port.postMessage({ type: "load-bar-map", entries: barMap });
+      }
+    }
+    console.log(
+      `%c[DAW] Bar subdivisions set to ${n}`,
+      "color: #81c784; font-weight: bold",
+      `(${n === 1 ? "bar-level" : n + " sub-bars per bar"})`
+    );
+  }
+  // ── CPU monitoring ──────────────────────────────────────────────
+  /** Start polling AudioContext render capacity (if supported). */
+  startCpuMonitor(intervalMs = 500) {
+    this.stopCpuMonitor();
+    const ac = this.ctx;
+    if (!ac?.renderCapacity) {
+      this._cpuPollId = setInterval(() => {
+        const trackCount = this.tracks.size;
+        const workletCount = trackCount * 4 + (this._pitchWorkletAvailable ? trackCount : 0);
+        this._cpuUsage = Math.min(1, workletCount * 0.03);
+        this.emit("cpuUsage", this._cpuUsage);
+      }, intervalMs);
+      return;
+    }
+    ac.renderCapacity.addEventListener("update", (e) => {
+      this._cpuUsage = e.load ?? e.averageLoad ?? 0;
+      this.emit("cpuUsage", this._cpuUsage);
+    });
+    ac.renderCapacity.start({ updateInterval: intervalMs / 1e3 });
+  }
+  stopCpuMonitor() {
+    if (this._cpuPollId) {
+      clearInterval(this._cpuPollId);
+      this._cpuPollId = null;
+    }
+    const ac = this.ctx;
+    if (ac?.renderCapacity) {
+      try {
+        ac.renderCapacity.stop();
+      } catch {
+      }
+    }
+  }
+  get cpuUsage() {
+    return this._cpuUsage;
+  }
+  // ── Playhead animation ───────────────────────────────────────────
+  startPlayheadAnimation() {
+    this.stopPlayheadAnimation();
+    const animate = () => {
+      if (!this._playing) return;
+      const posSec = this.getCurrentPositionSec();
+      const store = useDAWSessionStore.getState();
+      const currentBar = this.secondsToBar(posSec);
+      store.setPlayheadBar(currentBar);
+      this.updateStemPlayState(currentBar);
+      this.updateAllPerBarPitch(currentBar);
+      if (store.loopRegion && currentBar >= store.loopRegion.endBar) {
+        this.seekToBar(store.loopRegion.startBar);
+      }
+      this.playheadAnimationId = requestAnimationFrame(animate);
+    };
+    this.playheadAnimationId = requestAnimationFrame(animate);
+  }
+  /**
+   * Authoritative pitch update from the worklet's bar-changed message.
+   * Fires at audio-thread timing. The worklet's internal pitchDelayMs
+   * handles the alignment between speed (instant) and pitch (delayed).
+   */
+  handleWorkletBarChange(trackId, localBarIndex) {
+    if (!this._playing) return;
+    const rt = this.tracks.get(trackId);
+    if (!rt?.pitchWorklet) return;
+    const track = useDAWSessionStore.getState().getTrackById(trackId);
+    if (!track?.perBarPitchCompensation) return;
+    if (localBarIndex < 0 || localBarIndex >= rt.barPitchMap.length) return;
+    if (localBarIndex === rt.currentPitchBar) return;
+    rt.currentPitchBar = localBarIndex;
+    const barPitch = rt.barPitchMap[localBarIndex];
+    const totalSemitones = barPitch.pitchCorrectionSemitones + track.transposeSemitones + rt.autotuneOffset;
+    const factor = semitonesToPitchFactor(totalSemitones);
+    const pitchStr = factor.toFixed(2);
+    if (pitchStr === rt.lastPitchStr) return;
+    rt.lastPitchStr = pitchStr;
+    this.sendPitchToWorklet(rt.pitchWorklet, factor);
+    const subs = useDAWSessionStore.getState().barSubdivisions ?? 1;
+    const parentBar = subs > 1 ? Math.floor(localBarIndex / subs) : localBarIndex;
+    const subIdx = subs > 1 ? localBarIndex % subs : 0;
+    const prevSt = rt.lastCorrectionSt ?? barPitch.pitchCorrectionSemitones;
+    const deltaSt = barPitch.pitchCorrectionSemitones - prevSt;
+    rt.lastCorrectionSt = barPitch.pitchCorrectionSemitones;
+    const deltaColor = Math.abs(deltaSt) > 0.5 ? "color: #ef4444; font-weight: bold" : "color: #81c784";
+    console.log(
+      `%c[Bar Pitch] parentBar=${parentBar} sub=${subIdx}/${subs} | idx=${localBarIndex} pitch=${pitchStr} speed=${barPitch.speed.toFixed(4)} | correction=${barPitch.pitchCorrectionSemitones.toFixed(2)}st | \u0394=${deltaSt >= 0 ? "+" : ""}${deltaSt.toFixed(2)}st`,
+      deltaColor
+    );
+  }
+  /** Update per-bar pitch compensation for all tracks that have it enabled. */
+  updateAllPerBarPitch(globalBar) {
+    for (const trackId of this.tracks.keys()) {
+      this.updatePerBarPitch(trackId, globalBar);
+    }
+  }
+  /** Start/stop individual stem worklets as the playhead crosses their timeline boundaries */
+  updateStemPlayState(globalBar) {
+    const store = useDAWSessionStore.getState();
+    for (const [trackId, rt] of this.tracks) {
+      const track = store.getTrackById(trackId);
+      if (!track) continue;
+      let anyShouldBeActive = false;
+      track.channels.forEach((ch, i) => {
+        const key = `${trackId}:${i}`;
+        const seekPos = this.computeStemSeekSamples(globalBar, ch, track);
+        const wasActive = this._stemActive.get(key) ?? false;
+        const shouldBeActive = seekPos !== null;
+        if (shouldBeActive) anyShouldBeActive = true;
+        if (shouldBeActive && !wasActive) {
+          const w = rt.worklets[i];
+          w.port.postMessage({ type: "seek", position: seekPos });
+          w.port.postMessage({ type: "play" });
+          this._stemActive.set(key, true);
+        } else if (!shouldBeActive && wasActive) {
+          const w = rt.worklets[i];
+          w.port.postMessage({ type: "pause" });
+          this._stemActive.set(key, false);
+        }
+      });
+      if (anyShouldBeActive) {
+        rt.lastAccessAt = performance.now();
+        if (rt.dumped && !rt.transitioning) {
+          void this.rehydrateTrackAudio(trackId);
+        }
+      }
+    }
+  }
+  stopPlayheadAnimation() {
+    if (this.playheadAnimationId !== null) {
+      cancelAnimationFrame(this.playheadAnimationId);
+      this.playheadAnimationId = null;
+    }
+  }
+  getCurrentPositionSec() {
+    if (!this.ctx) return 0;
+    const globalRate = useDAWSessionStore.getState().globalPlaybackRate;
+    return this._playStartOffset + (this.ctx.currentTime - this._playStartCtxTime) * globalRate;
+  }
+  // ── Time / bar conversion ────────────────────────────────────────
+  barToSeconds(bar) {
+    const masterBar = useDAWSessionStore.getState().masterBarLength48000;
+    if (!masterBar) return 0;
+    return bar * masterBar / SAMPLE_RATE3;
+  }
+  secondsToBar(sec) {
+    const masterBar = useDAWSessionStore.getState().masterBarLength48000;
+    if (!masterBar) return 0;
+    return sec * SAMPLE_RATE3 / masterBar;
+  }
+  // ── Metronome ─────────────────────────────────────────────────────
+  get metronomeEnabled() {
+    return this._metronomeOn;
+  }
+  get metronomeVolume() {
+    return this._metronomeGain?.gain.value ?? 0.35;
+  }
+  get metronomeDownbeatOnly() {
+    return this._metronomeDownbeatOnly;
+  }
+  setMetronomeDownbeatOnly(downbeatOnly) {
+    this._metronomeDownbeatOnly = downbeatOnly;
+    if (this._metronomeOn && this._playing) {
+      this.startMetronomeScheduler();
+    }
+  }
+  toggleMetronome(on) {
+    this._metronomeOn = on ?? !this._metronomeOn;
+    if (this._metronomeOn && !this._metronomeGain && this.ctx) {
+      this._metronomeGain = this.ctx.createGain();
+      this._metronomeGain.gain.value = 0.35;
+      this._metronomeGain.connect(this.ctx.destination);
+    }
+    if (this._metronomeOn && this._playing) {
+      this.startMetronomeScheduler();
+    } else {
+      this.stopMetronomeScheduler();
+    }
+    this.emit("metronomeChanged", this._metronomeOn);
+  }
+  setMetronomeVolume(volume) {
+    if (this._metronomeGain) {
+      this._metronomeGain.gain.value = Math.max(0, Math.min(1, volume));
+    }
+    this.emit("metronomeChanged", this._metronomeOn);
+  }
+  startMetronomeScheduler() {
+    this.stopMetronomeScheduler();
+    if (!this.ctx || !this._metronomeGain) return;
+    const store = useDAWSessionStore.getState();
+    const currentBar = store.playheadBar;
+    const step = this._metronomeDownbeatOnly ? 1 : 0.25;
+    this._metronomeNextBeat = Math.ceil(currentBar / step) * step;
+    this._metronomeScheduleId = setInterval(() => this.scheduleMetronomeClicks(), METRO_SCHEDULE_INTERVAL_MS);
+  }
+  stopMetronomeScheduler() {
+    if (this._metronomeScheduleId !== null) {
+      clearInterval(this._metronomeScheduleId);
+      this._metronomeScheduleId = null;
+    }
+  }
+  scheduleMetronomeClicks() {
+    if (!this.ctx || !this._metronomeGain || !this._playing) return;
+    const store = useDAWSessionStore.getState();
+    const masterBar = store.masterBarLength48000;
+    if (!masterBar) return;
+    const globalRate = store.globalPlaybackRate;
+    const lookAheadBar = METRO_LOOK_AHEAD_SEC / (masterBar / SAMPLE_RATE3);
+    const currentBar = this.secondsToBar(this.getCurrentPositionSec());
+    const horizonBar = currentBar + lookAheadBar;
+    const step = this._metronomeDownbeatOnly ? 1 : 0.25;
+    while (this._metronomeNextBeat < horizonBar) {
+      const beatBar = this._metronomeNextBeat;
+      if (beatBar >= currentBar) {
+        const deltaSec = (beatBar - currentBar) * masterBar / SAMPLE_RATE3 / globalRate;
+        const when = this.ctx.currentTime + deltaSec;
+        this.playClick(when, Math.abs(beatBar % 1) < 0.01);
+      }
+      this._metronomeNextBeat += step;
+    }
+  }
+  playClick(when, downbeat) {
+    if (!this.ctx || !this._metronomeGain) return;
+    const osc = this.ctx.createOscillator();
+    const env = this.ctx.createGain();
+    osc.type = "sine";
+    osc.frequency.value = downbeat ? 1e3 : 800;
+    env.gain.setValueAtTime(downbeat ? 1 : 0.5, when);
+    env.gain.exponentialRampToValueAtTime(1e-3, when + 0.04);
+    osc.connect(env);
+    env.connect(this._metronomeGain);
+    osc.start(when);
+    osc.stop(when + 0.05);
+  }
+  // ── Copy/paste audio between bar ranges ─────────────────────────
+  /**
+   * Copy audio samples from one bar range and overwrite another bar range
+   * inside a track's stem buffers. Source and destination stems may be the
+   * same (default) or different stems on the same track. After writing, the
+   * modified destination buffer is sent to the worklet so playback reflects
+   * the change immediately.
+   *
+   * Both `sourceStart/End` and `targetStartBar` are in local bars (relative
+   * to the track's barMapping, not the global timeline).
+   *
+   * `targetStemIndex` defaults to `stemIndex` (source) for backwards-compatible
+   * same-stem behaviour.
+   */
+  pasteAudioRegion(trackId, stemIndex, sourceStartBar, sourceEndBar, targetStartBar, targetStemIndex = stemIndex) {
+    const rt = this.tracks.get(trackId);
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!rt || !track || !this.ctx) {
+      console.warn("[DAW pasteAudio] Missing runtime/track/ctx", { hasRt: !!rt, hasTrack: !!track, hasCtx: !!this.ctx });
+      return;
+    }
+    const stemKeys = ["other", "vocals", "bass", "drums"];
+    const srcKey = stemKeys[stemIndex];
+    const dstKey = stemKeys[targetStemIndex];
+    const srcBuf = rt.stems[srcKey];
+    const dstBuf = rt.stems[dstKey];
+    if (!srcBuf || !dstBuf) {
+      console.warn("[DAW pasteAudio] No buffer for stem", { srcKey, dstKey });
+      return;
+    }
+    const barMapping = track.barMapping;
+    const srcSampleStart = barToSample(sourceStartBar, barMapping);
+    const srcSampleEnd = barToSample(sourceEndBar, barMapping);
+    const srcLen = srcSampleEnd - srcSampleStart;
+    const dstSampleStart = barToSample(targetStartBar, barMapping);
+    const clipLen = sourceEndBar - sourceStartBar;
+    const targetEndBar = Math.min(targetStartBar + clipLen, barMapping.length);
+    const dstSampleEnd = barToSample(targetEndBar, barMapping);
+    const dstLen = dstSampleEnd - dstSampleStart;
+    if (srcLen <= 0) {
+      console.warn("[DAW pasteAudio] srcLen <= 0, aborting");
+      return;
+    }
+    if (dstLen <= 0) {
+      console.warn("[DAW pasteAudio] dstLen <= 0, aborting");
+      return;
+    }
+    const copyLen = Math.min(srcLen, dstLen);
+    const channelCount = Math.min(srcBuf.numberOfChannels, dstBuf.numberOfChannels);
+    for (let ch = 0; ch < channelCount; ch++) {
+      const srcData = srcBuf.getChannelData(ch);
+      const dstData = dstBuf.getChannelData(ch);
+      const srcCopy = srcData.slice(srcSampleStart, srcSampleStart + copyLen);
+      dstData.set(srcCopy, dstSampleStart);
+      if (dstLen > copyLen) {
+        for (let s = dstSampleStart + copyLen; s < dstSampleEnd; s++) {
+          dstData[s] = 0;
+        }
+      }
+    }
+    const w = rt.worklets[targetStemIndex];
+    const channels = [];
+    for (let ch = 0; ch < dstBuf.numberOfChannels; ch++) {
+      channels.push(new Float32Array(dstBuf.getChannelData(ch)));
+    }
+    w.port.postMessage({ type: "load-buffer", channels }, channels.map((c) => c.buffer));
+    const freshStore = useDAWSessionStore.getState();
+    const freshTrack = freshStore.getTrackById(trackId);
+    if (freshTrack) {
+      const barMap = buildBarMap(freshTrack.barMapping, freshStore.masterBarLength48000, freshTrack.nativeBarLength, freshStore.barSubdivisions);
+      w.port.postMessage({ type: "load-bar-map", entries: barMap });
+      rt.barPitchMap = buildBarPitchMap(barMap);
+      rt.currentPitchBar = -1;
+    }
+    this.syncMuteRegions(trackId, targetStemIndex);
+  }
+  // ── Selection-based batch operations ────────────────────────────
+  //
+  // These wrap pasteAudioRegion / mute regions / clipboard with the right
+  // undo/redo semantics so the keyboard handlers and the SelectionActionBar
+  // popover share one implementation.
+  /**
+   * Copy each selection's bar range into the clipboard. No mutation of
+   * the audio buffers — just snapshots the source bar ranges. No undo step
+   * (copy is non-destructive).
+   */
+  copySelections(selections) {
+    const store = useDAWSessionStore.getState();
+    if (selections.length === 0) return;
+    const entries = selections.filter((s) => s.endBar > s.startBar).map((s) => ({
+      trackId: s.trackId,
+      stemIndex: s.stemIndex,
+      sourceStartBar: Math.round(s.startBar),
+      sourceEndBar: Math.round(s.endBar)
+    }));
+    store.setClipboardEntries(entries);
+  }
+  /**
+   * Mute (silence) each selection's bar range. Single undo step covers all
+   * ranges. After muting, clears the selection set.
+   */
+  muteSelections(selections) {
+    if (selections.length === 0) return;
+    const store = useDAWSessionStore.getState();
+    store.pushUndo();
+    const touched = /* @__PURE__ */ new Set();
+    for (const sel of selections) {
+      store.addMuteRegion(sel.trackId, sel.stemIndex, {
+        startBar: Math.round(sel.startBar),
+        endBar: Math.round(sel.endBar)
+      });
+      touched.add(`${sel.trackId}:${sel.stemIndex}`);
+    }
+    for (const key of touched) {
+      const [trackId, idx] = key.split(":");
+      this.syncMuteRegions(trackId, parseInt(idx, 10));
+    }
+    store.clearSelections();
+  }
+  /**
+   * Cut: copy each selection's bar range to clipboard AND mute it. Single
+   * undo step. Clears the selection set after.
+   */
+  cutSelections(selections) {
+    if (selections.length === 0) return;
+    this.copySelections(selections);
+    this.muteSelections(selections);
+  }
+  /**
+   * Paste the current clipboard at a global timeline bar. Each clipboard
+   * entry pastes into its own stemIndex on the focused track. Cross-track
+   * paste is supported as same-stemIndex-different-track when the source
+   * track no longer exists.
+   *
+   * For a SINGLE-entry clipboard, the optional `targetStemIndex` allows
+   * cross-stem paste (e.g. paste bass clip into drums lane).
+   */
+  pasteClipboardAtBar(targetGlobalBar, targetTrackId, targetStemIndex) {
+    const store = useDAWSessionStore.getState();
+    const entries = store.clipboardEntries;
+    if (entries.length === 0) return;
+    const track = store.getTrackById(targetTrackId);
+    if (!track) return;
+    store.pushUndo();
+    const isSingleEntryCrossStem = entries.length === 1 && targetStemIndex !== void 0 && targetStemIndex !== entries[0].stemIndex;
+    for (const cb of entries) {
+      const dstStemIndex = isSingleEntryCrossStem ? targetStemIndex : cb.stemIndex;
+      const ch = store.getChannel(targetTrackId, dstStemIndex);
+      if (!ch) continue;
+      const clipLen = cb.sourceEndBar - cb.sourceStartBar;
+      const maxBar = track.barMapping.length;
+      let localPasteBar = Math.round(targetGlobalBar) - ch.timelineStartBar;
+      if (localPasteBar < 0) {
+        const shift = -localPasteBar;
+        const newTimelineStart = Math.max(0, ch.timelineStartBar - shift);
+        const actualShift = ch.timelineStartBar - newTimelineStart;
+        store.setStemTimelineStart(targetTrackId, dstStemIndex, newTimelineStart);
+        store.setStemTrim(
+          targetTrackId,
+          dstStemIndex,
+          ch.trimStartBar + actualShift,
+          ch.trimEndBar + actualShift
+        );
+        localPasteBar = Math.round(targetGlobalBar) - newTimelineStart;
+      }
+      const pasteEnd = Math.min(localPasteBar + clipLen, maxBar);
+      if (pasteEnd <= localPasteBar || localPasteBar < 0 || localPasteBar >= maxBar) {
+        continue;
+      }
+      const srcTrackId = cb.trackId === targetTrackId ? targetTrackId : targetTrackId;
+      this.pasteAudioRegion(
+        srcTrackId,
+        cb.stemIndex,
+        cb.sourceStartBar,
+        cb.sourceEndBar,
+        localPasteBar,
+        dstStemIndex
+      );
+      const freshCh = store.getChannel(targetTrackId, dstStemIndex);
+      if (!freshCh) continue;
+      const newTrimStart = Math.min(freshCh.trimStartBar, localPasteBar);
+      const newTrimEnd = Math.max(freshCh.trimEndBar, pasteEnd);
+      if (newTrimStart !== freshCh.trimStartBar || newTrimEnd !== freshCh.trimEndBar) {
+        store.setStemTrim(targetTrackId, dstStemIndex, newTrimStart, newTrimEnd);
+      }
+      const updatedCh = store.getChannel(targetTrackId, dstStemIndex);
+      if (updatedCh) {
+        const newMuteRegions = updatedCh.muteRegions.flatMap((r) => {
+          if (r.endBar <= localPasteBar || r.startBar >= pasteEnd) return [r];
+          const parts = [];
+          if (r.startBar < localPasteBar) parts.push({ startBar: r.startBar, endBar: localPasteBar });
+          if (r.endBar > pasteEnd) parts.push({ startBar: pasteEnd, endBar: r.endBar });
+          return parts;
+        });
+        store.setMuteRegionsBatch(targetTrackId, dstStemIndex, newMuteRegions);
+        this.syncMuteRegions(targetTrackId, dstStemIndex);
+      }
+    }
+    const longestClipLen = entries.reduce((m, e) => Math.max(m, e.sourceEndBar - e.sourceStartBar), 0);
+    store.setPlayheadBar(Math.round(targetGlobalBar) + longestClipLen);
+    store.clearSelections();
+  }
+  /**
+   * Duplicate each selection: copy its audio in-buffer to immediately after
+   * the selection end on the same stem. Single undo step.
+   */
+  duplicateSelections(selections) {
+    if (selections.length === 0) return;
+    const store = useDAWSessionStore.getState();
+    store.pushUndo();
+    const newSelections = [];
+    for (const sel of selections) {
+      const track = store.getTrackById(sel.trackId);
+      const ch = store.getChannel(sel.trackId, sel.stemIndex);
+      if (!track || !ch) continue;
+      const start = Math.round(sel.startBar);
+      const end = Math.round(sel.endBar);
+      const len = end - start;
+      if (len <= 0) continue;
+      const maxBar = track.barMapping.length;
+      const dstStart = end;
+      const dstEnd = Math.min(dstStart + len, maxBar);
+      if (dstEnd <= dstStart) continue;
+      this.pasteAudioRegion(sel.trackId, sel.stemIndex, start, end, dstStart, sel.stemIndex);
+      const freshCh = store.getChannel(sel.trackId, sel.stemIndex);
+      if (freshCh && dstEnd > freshCh.trimEndBar) {
+        store.setStemTrim(sel.trackId, sel.stemIndex, freshCh.trimStartBar, dstEnd);
+      }
+      const updatedCh = store.getChannel(sel.trackId, sel.stemIndex);
+      if (updatedCh) {
+        const newMuteRegions = updatedCh.muteRegions.flatMap((r) => {
+          if (r.endBar <= dstStart || r.startBar >= dstEnd) return [r];
+          const parts = [];
+          if (r.startBar < dstStart) parts.push({ startBar: r.startBar, endBar: dstStart });
+          if (r.endBar > dstEnd) parts.push({ startBar: dstEnd, endBar: r.endBar });
+          return parts;
+        });
+        store.setMuteRegionsBatch(sel.trackId, sel.stemIndex, newMuteRegions);
+        this.syncMuteRegions(sel.trackId, sel.stemIndex);
+      }
+      newSelections.push({
+        trackId: sel.trackId,
+        stemIndex: sel.stemIndex,
+        startBar: dstStart,
+        endBar: dstEnd
+      });
+    }
+    if (newSelections.length > 0) {
+      store.setSelections(newSelections);
+    }
+  }
+  // ── Resampled region insertion ──────────────────────────────────
+  /**
+   * Insert a resampled AudioBuffer into a stem, replacing the specified bar range.
+   * Rebuilds the worklet buffer and bar map, and records the resampled region in the store.
+   */
+  insertResampledRegion(trackId, stemIndex, startBar, endBar, resampledBuffer) {
+    const rt = this.tracks.get(trackId);
+    const store = useDAWSessionStore.getState();
+    const track = store.getTrackById(trackId);
+    if (!rt || !track || !this.ctx) return;
+    const stemKeys = ["other", "vocals", "bass", "drums"];
+    const stemKey = stemKeys[stemIndex];
+    const originalBuf = rt.stems[stemKey];
+    if (!originalBuf) return;
+    const barMapping = track.barMapping;
+    const insertSample = barMapping[startBar]?.sampleStart ?? 0;
+    const endSample = endBar < barMapping.length ? barMapping[endBar].sampleStart : (barMapping[barMapping.length - 1]?.sampleStart ?? 0) + (barMapping[barMapping.length - 1]?.duration ?? 0);
+    const replaceLen = endSample - insertSample;
+    const newLen = originalBuf.length - replaceLen + resampledBuffer.length;
+    const newBuf = this.ctx.createBuffer(originalBuf.numberOfChannels, Math.max(newLen, 1), originalBuf.sampleRate);
+    for (let ch = 0; ch < originalBuf.numberOfChannels; ch++) {
+      const src = originalBuf.getChannelData(ch);
+      const dst = newBuf.getChannelData(ch);
+      const rep = resampledBuffer.numberOfChannels > ch ? resampledBuffer.getChannelData(ch) : resampledBuffer.getChannelData(0);
+      dst.set(src.subarray(0, insertSample));
+      dst.set(rep, insertSample);
+      if (endSample < src.length) {
+        dst.set(src.subarray(endSample), insertSample + resampledBuffer.length);
+      }
+    }
+    rt.stems[stemKey] = newBuf;
+    const w = rt.worklets[stemIndex];
+    const channels = [];
+    for (let ch = 0; ch < newBuf.numberOfChannels; ch++) {
+      channels.push(new Float32Array(newBuf.getChannelData(ch)));
+    }
+    w.port.postMessage({ type: "load-buffer", channels }, channels.map((c) => c.buffer));
+    const freshStore = useDAWSessionStore.getState();
+    const freshTrack = freshStore.getTrackById(trackId);
+    if (freshTrack) {
+      const barMap = buildBarMap(freshTrack.barMapping, freshStore.masterBarLength48000, freshTrack.nativeBarLength, freshStore.barSubdivisions);
+      w.port.postMessage({ type: "load-bar-map", entries: barMap });
+      rt.barPitchMap = buildBarPitchMap(barMap);
+      rt.currentPitchBar = -1;
+    }
+    this.syncMuteRegions(trackId, stemIndex);
+    store.addResampledRegion(trackId, stemIndex, {
+      startBar,
+      endBar,
+      sliceCount: 0
+    });
+    this.emit("resampledRegionInserted", trackId, stemIndex);
+  }
+  // ── Cleanup ──────────────────────────────────────────────────────
+  destroy() {
+    this.stopPlayheadAnimation();
+    this.stopMetronomeScheduler();
+    this.stopCpuMonitor();
+    this._metronomeGain?.disconnect();
+    this._metronomeGain = null;
+    for (const [trackId, rt] of this.tracks) {
+      try {
+        rt.unsubscribePatch?.();
+      } catch {
+      }
+      rt.worklets.forEach((w) => {
+        w.port.postMessage({ type: "stop" });
+        w.disconnect();
+      });
+      rt.stemGains.forEach((g) => g.disconnect());
+      try {
+        rt.pitchWorklet?.disconnect();
+      } catch {
+      }
+      rt.trackGain.disconnect();
+      clearWaveformCacheForTrack(trackId);
+    }
+    for (const entry of this.sourceCache.values()) {
+      try {
+        entry.loadHandle?.abort();
+      } catch {
+      }
+    }
+    this.sourceCache.clear();
+    this.tracks.clear();
+    this.masterGain?.disconnect();
+    this.ctx?.close();
+    this.ctx = null;
+    this.masterGain = null;
+    this.isInitialised = false;
+    this._pitchWorkletAvailable = false;
+    this.removeAllListeners();
+    _DAWController.instance = null;
+  }
+};
+
+export { DAWController, DEFAULT_EFFECTS, MIPMAP_LEVELS, appendPeaksToMipmapCache, hasActiveEffects, initMipmapsForTrack, invalidateWaveformCache, loadTrackStems, mipmapStore, subscribeMipmapChanges };
+//# sourceMappingURL=chunk-OYNES5W3.js.map
+//# sourceMappingURL=chunk-OYNES5W3.js.map