@waveform-playlist/browser 13.1.3 → 14.0.0

package/dist/tone.mjs

@@ -0,0 +1,1958 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/hooks/useAudioTracks.ts
+import { useState, useEffect, useRef, useMemo } from "react";
+import {
+  createTrack,
+  createClipFromSeconds
+} from "@waveform-playlist/core";
+import * as Tone from "tone";
+function buildTrackFromConfig(config, index, audioBuffer, stableIds, contextSampleRate = 48e3) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p;
+  const buffer = audioBuffer != null ? audioBuffer : config.audioBuffer;
+  const sampleRate = (_c = (_b = buffer == null ? void 0 : buffer.sampleRate) != null ? _b : (_a = config.waveformData) == null ? void 0 : _a.sample_rate) != null ? _c : contextSampleRate;
+  const sourceDuration = (_g = (_e = buffer == null ? void 0 : buffer.duration) != null ? _e : (_d = config.waveformData) == null ? void 0 : _d.duration) != null ? _g : config.duration != null ? config.duration + ((_f = config.offset) != null ? _f : 0) : void 0;
+  if (sourceDuration === void 0) {
+    console.warn(
+      `[waveform-playlist] Track ${index + 1} ("${(_h = config.name) != null ? _h : "unnamed"}"): Cannot create track \u2014 provide duration, audioBuffer, or waveformData with duration.`
+    );
+    return null;
+  }
+  const clip = createClipFromSeconds({
+    audioBuffer: buffer,
+    sampleRate,
+    sourceDuration,
+    startTime: (_i = config.startTime) != null ? _i : 0,
+    duration: (_j = config.duration) != null ? _j : sourceDuration,
+    offset: (_k = config.offset) != null ? _k : 0,
+    name: config.name || `Track ${index + 1}`,
+    fadeIn: config.fadeIn,
+    fadeOut: config.fadeOut,
+    waveformData: config.waveformData
+  });
+  if (isNaN(clip.startSample) || isNaN(clip.durationSamples) || isNaN(clip.offsetSamples)) {
+    console.error(
+      `[waveform-playlist] Invalid clip values for track ${index + 1} ("${(_l = config.name) != null ? _l : "unnamed"}"): startSample=${clip.startSample}, durationSamples=${clip.durationSamples}, offsetSamples=${clip.offsetSamples}`
+    );
+    return null;
+  }
+  const track = __spreadProps(__spreadValues({}, createTrack({
+    name: config.name || `Track ${index + 1}`,
+    clips: [clip],
+    muted: (_m = config.muted) != null ? _m : false,
+    soloed: (_n = config.soloed) != null ? _n : false,
+    volume: (_o = config.volume) != null ? _o : 1,
+    pan: (_p = config.pan) != null ? _p : 0,
+    color: config.color
+  })), {
+    effects: config.effects,
+    renderMode: config.renderMode,
+    spectrogramConfig: config.spectrogramConfig,
+    spectrogramColorMap: config.spectrogramColorMap
+  });
+  const existingIds = stableIds.get(index);
+  if (existingIds) {
+    track.id = existingIds.trackId;
+    track.clips[0] = __spreadProps(__spreadValues({}, track.clips[0]), { id: existingIds.clipId });
+  } else {
+    stableIds.set(index, { trackId: track.id, clipId: track.clips[0].id });
+  }
+  return track;
+}
+function useAudioTracks(configs, options = {}) {
+  const { immediate = false, progressive = false } = options;
+  const isImmediate = immediate || progressive;
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [loadedCount, setLoadedCount] = useState(0);
+  const totalCount = configs.length;
+  const [loadedBuffers, setLoadedBuffers] = useState(/* @__PURE__ */ new Map());
+  const stableIdsRef = useRef(/* @__PURE__ */ new Map());
+  const contextSampleRateRef = useRef(48e3);
+  const derivedTracks = useMemo(() => {
+    if (!isImmediate) return null;
+    const result = [];
+    for (let i = 0; i < configs.length; i++) {
+      const track = buildTrackFromConfig(
+        configs[i],
+        i,
+        loadedBuffers.get(i),
+        stableIdsRef.current,
+        contextSampleRateRef.current
+      );
+      if (track) result.push(track);
+    }
+    return result;
+  }, [isImmediate, configs, loadedBuffers]);
+  const [tracks, setTracks] = useState(derivedTracks != null ? derivedTracks : []);
+  const prevDerivedRef = useRef(derivedTracks);
+  if (derivedTracks !== prevDerivedRef.current) {
+    prevDerivedRef.current = derivedTracks;
+    if (derivedTracks) setTracks(derivedTracks);
+  }
+  useEffect(() => {
+    if (configs.length === 0) {
+      setTracks([]);
+      setLoading(false);
+      setLoadedCount(0);
+      return;
+    }
+    let cancelled = false;
+    const abortController = new AbortController();
+    const loadTracks = () => __async(null, null, function* () {
+      try {
+        setLoading(true);
+        setError(null);
+        setLoadedCount(0);
+        if (isImmediate) {
+          setLoadedBuffers(/* @__PURE__ */ new Map());
+        }
+        const audioContext = Tone.getContext().rawContext;
+        contextSampleRateRef.current = audioContext.sampleRate;
+        const loadPromises = configs.map((config, index) => __async(null, null, function* () {
+          if (config.audioBuffer) {
+            if (isImmediate && !cancelled) {
+              setLoadedBuffers((prev) => {
+                const next = new Map(prev);
+                next.set(index, config.audioBuffer);
+                return next;
+              });
+              setLoadedCount((prev) => prev + 1);
+              return;
+            }
+            return buildTrackFromConfig(
+              config,
+              index,
+              config.audioBuffer,
+              stableIdsRef.current,
+              audioContext.sampleRate
+            );
+          }
+          if (!config.src && config.waveformData) {
+            if (isImmediate && !cancelled) {
+              setLoadedCount((prev) => prev + 1);
+              return;
+            }
+            return buildTrackFromConfig(
+              config,
+              index,
+              void 0,
+              stableIdsRef.current,
+              audioContext.sampleRate
+            );
+          }
+          if (!config.src) {
+            throw new Error(`Track ${index + 1}: Must provide src, audioBuffer, or waveformData`);
+          }
+          const response = yield fetch(config.src, { signal: abortController.signal });
+          if (!response.ok) {
+            throw new Error(`Failed to fetch ${config.src}: ${response.statusText}`);
+          }
+          const arrayBuffer = yield response.arrayBuffer();
+          const audioBuffer = yield audioContext.decodeAudioData(arrayBuffer);
+          if (!audioBuffer || !audioBuffer.sampleRate || !audioBuffer.duration) {
+            throw new Error(`Invalid audio buffer for ${config.src}`);
+          }
+          if (isImmediate && !cancelled) {
+            setLoadedBuffers((prev) => {
+              const next = new Map(prev);
+              next.set(index, audioBuffer);
+              return next;
+            });
+            setLoadedCount((prev) => prev + 1);
+            return;
+          }
+          return buildTrackFromConfig(
+            config,
+            index,
+            audioBuffer,
+            stableIdsRef.current,
+            audioContext.sampleRate
+          );
+        }));
+        const loadedTracks = yield Promise.all(loadPromises);
+        if (!cancelled) {
+          if (!isImmediate) {
+            const validTracks = loadedTracks.filter((t) => t != null);
+            setTracks(validTracks);
+            setLoadedCount(validTracks.length);
+          }
+          setLoading(false);
+        }
+      } catch (err) {
+        if (!cancelled) {
+          const errorMessage = err instanceof Error ? err.message : "Unknown error loading audio";
+          setError(errorMessage);
+          setLoading(false);
+          console.error(`[waveform-playlist] Error loading audio tracks: ${errorMessage}`);
+        }
+      }
+    });
+    loadTracks();
+    return () => {
+      cancelled = true;
+      abortController.abort();
+    };
+  }, [configs, isImmediate]);
+  return { tracks, loading, error, loadedCount, totalCount };
+}
+
+// src/hooks/useAudioEffects.ts
+import { useRef as useRef2, useCallback } from "react";
+import { Analyser } from "tone";
+var useMasterAnalyser = (fftSize = 256) => {
+  const analyserRef = useRef2(null);
+  const masterEffects = useCallback(
+    (masterGainNode, destination, _isOffline) => {
+      const analyserNode = new Analyser("fft", fftSize);
+      masterGainNode.connect(analyserNode);
+      masterGainNode.connect(destination);
+      analyserRef.current = analyserNode;
+      return function cleanup() {
+        analyserNode.dispose();
+        analyserRef.current = null;
+      };
+    },
+    [fftSize]
+  );
+  return { analyserRef, masterEffects };
+};
+
+// src/hooks/useDynamicEffects.ts
+import { useState as useState2, useCallback as useCallback2, useRef as useRef3, useEffect as useEffect2 } from "react";
+
+// src/effects/effectDefinitions.ts
+var effectDefinitions = [
+  // === REVERB EFFECTS ===
+  {
+    id: "reverb",
+    name: "Reverb",
+    category: "reverb",
+    description: "Simple convolution reverb with adjustable decay time",
+    parameters: [
+      {
+        name: "decay",
+        label: "Decay",
+        type: "number",
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        default: 1.5,
+        unit: "s"
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  {
+    id: "freeverb",
+    name: "Freeverb",
+    category: "reverb",
+    description: "Classic Schroeder/Moorer reverb with room size and dampening",
+    parameters: [
+      {
+        name: "roomSize",
+        label: "Room Size",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        default: 0.7
+      },
+      {
+        name: "dampening",
+        label: "Dampening",
+        type: "number",
+        min: 0,
+        max: 1e4,
+        step: 100,
+        default: 3e3,
+        unit: "Hz"
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  {
+    id: "jcReverb",
+    name: "JC Reverb",
+    category: "reverb",
+    description: "Attempt at Roland JC-120 chorus reverb emulation",
+    parameters: [
+      {
+        name: "roomSize",
+        label: "Room Size",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        default: 0.5
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  // === DELAY EFFECTS ===
+  {
+    id: "feedbackDelay",
+    name: "Feedback Delay",
+    category: "delay",
+    description: "Delay line with feedback for echo effects",
+    parameters: [
+      {
+        name: "delayTime",
+        label: "Delay Time",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        default: 0.25,
+        unit: "s"
+      },
+      {
+        name: "feedback",
+        label: "Feedback",
+        type: "number",
+        min: 0,
+        max: 0.95,
+        step: 0.01,
+        default: 0.5
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  {
+    id: "pingPongDelay",
+    name: "Ping Pong Delay",
+    category: "delay",
+    description: "Stereo delay bouncing between left and right channels",
+    parameters: [
+      {
+        name: "delayTime",
+        label: "Delay Time",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        default: 0.25,
+        unit: "s"
+      },
+      {
+        name: "feedback",
+        label: "Feedback",
+        type: "number",
+        min: 0,
+        max: 0.95,
+        step: 0.01,
+        default: 0.5
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  // === MODULATION EFFECTS ===
+  {
+    id: "chorus",
+    name: "Chorus",
+    category: "modulation",
+    description: "Creates thickness by layering detuned copies of the signal",
+    parameters: [
+      {
+        name: "frequency",
+        label: "Rate",
+        type: "number",
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        default: 1.5,
+        unit: "Hz"
+      },
+      {
+        name: "delayTime",
+        label: "Delay",
+        type: "number",
+        min: 0,
+        max: 20,
+        step: 0.5,
+        default: 3.5,
+        unit: "ms"
+      },
+      { name: "depth", label: "Depth", type: "number", min: 0, max: 1, step: 0.01, default: 0.7 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  {
+    id: "phaser",
+    name: "Phaser",
+    category: "modulation",
+    description: "Classic phaser effect using allpass filters",
+    parameters: [
+      {
+        name: "frequency",
+        label: "Rate",
+        type: "number",
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        default: 0.5,
+        unit: "Hz"
+      },
+      { name: "octaves", label: "Octaves", type: "number", min: 1, max: 6, step: 1, default: 3 },
+      {
+        name: "baseFrequency",
+        label: "Base Freq",
+        type: "number",
+        min: 100,
+        max: 2e3,
+        step: 10,
+        default: 350,
+        unit: "Hz"
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  },
+  {
+    id: "tremolo",
+    name: "Tremolo",
+    category: "modulation",
+    description: "Rhythmic volume modulation",
+    parameters: [
+      {
+        name: "frequency",
+        label: "Rate",
+        type: "number",
+        min: 0.1,
+        max: 20,
+        step: 0.1,
+        default: 4,
+        unit: "Hz"
+      },
+      { name: "depth", label: "Depth", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  {
+    id: "vibrato",
+    name: "Vibrato",
+    category: "modulation",
+    description: "Pitch modulation effect",
+    parameters: [
+      {
+        name: "frequency",
+        label: "Rate",
+        type: "number",
+        min: 0.1,
+        max: 20,
+        step: 0.1,
+        default: 5,
+        unit: "Hz"
+      },
+      { name: "depth", label: "Depth", type: "number", min: 0, max: 1, step: 0.01, default: 0.1 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  {
+    id: "autoPanner",
+    name: "Auto Panner",
+    category: "modulation",
+    description: "Automatic left-right panning",
+    parameters: [
+      {
+        name: "frequency",
+        label: "Rate",
+        type: "number",
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        default: 1,
+        unit: "Hz"
+      },
+      { name: "depth", label: "Depth", type: "number", min: 0, max: 1, step: 0.01, default: 1 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  // === FILTER EFFECTS ===
+  {
+    id: "autoFilter",
+    name: "Auto Filter",
+    category: "filter",
+    description: "Automated filter sweep with LFO",
+    parameters: [
+      {
+        name: "frequency",
+        label: "Rate",
+        type: "number",
+        min: 0.1,
+        max: 10,
+        step: 0.1,
+        default: 1,
+        unit: "Hz"
+      },
+      {
+        name: "baseFrequency",
+        label: "Base Freq",
+        type: "number",
+        min: 20,
+        max: 2e3,
+        step: 10,
+        default: 200,
+        unit: "Hz"
+      },
+      {
+        name: "octaves",
+        label: "Octaves",
+        type: "number",
+        min: 0.5,
+        max: 8,
+        step: 0.5,
+        default: 2.6
+      },
+      { name: "depth", label: "Depth", type: "number", min: 0, max: 1, step: 0.01, default: 1 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  {
+    id: "autoWah",
+    name: "Auto Wah",
+    category: "filter",
+    description: "Envelope follower filter effect",
+    parameters: [
+      {
+        name: "baseFrequency",
+        label: "Base Freq",
+        type: "number",
+        min: 20,
+        max: 500,
+        step: 10,
+        default: 100,
+        unit: "Hz"
+      },
+      { name: "octaves", label: "Octaves", type: "number", min: 1, max: 8, step: 1, default: 6 },
+      {
+        name: "sensitivity",
+        label: "Sensitivity",
+        type: "number",
+        min: -40,
+        max: 0,
+        step: 1,
+        default: 0,
+        unit: "dB"
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  {
+    id: "eq3",
+    name: "3-Band EQ",
+    category: "filter",
+    description: "Three band equalizer with low, mid, and high controls",
+    parameters: [
+      {
+        name: "low",
+        label: "Low",
+        type: "number",
+        min: -24,
+        max: 24,
+        step: 0.5,
+        default: 0,
+        unit: "dB"
+      },
+      {
+        name: "mid",
+        label: "Mid",
+        type: "number",
+        min: -24,
+        max: 24,
+        step: 0.5,
+        default: 0,
+        unit: "dB"
+      },
+      {
+        name: "high",
+        label: "High",
+        type: "number",
+        min: -24,
+        max: 24,
+        step: 0.5,
+        default: 0,
+        unit: "dB"
+      },
+      {
+        name: "lowFrequency",
+        label: "Low Freq",
+        type: "number",
+        min: 20,
+        max: 500,
+        step: 10,
+        default: 400,
+        unit: "Hz"
+      },
+      {
+        name: "highFrequency",
+        label: "High Freq",
+        type: "number",
+        min: 1e3,
+        max: 1e4,
+        step: 100,
+        default: 2500,
+        unit: "Hz"
+      }
+    ]
+  },
+  // === DISTORTION EFFECTS ===
+  {
+    id: "distortion",
+    name: "Distortion",
+    category: "distortion",
+    description: "Wave shaping distortion effect",
+    parameters: [
+      {
+        name: "distortion",
+        label: "Drive",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        default: 0.4
+      },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  {
+    id: "bitCrusher",
+    name: "Bit Crusher",
+    category: "distortion",
+    description: "Reduces bit depth for lo-fi digital texture",
+    parameters: [
+      { name: "bits", label: "Bits", type: "number", min: 1, max: 16, step: 1, default: 4 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  {
+    id: "chebyshev",
+    name: "Chebyshev",
+    category: "distortion",
+    description: "Waveshaping distortion using Chebyshev polynomials",
+    parameters: [
+      { name: "order", label: "Order", type: "number", min: 1, max: 100, step: 1, default: 50 },
+      { name: "wet", label: "Mix", type: "number", min: 0, max: 1, step: 0.01, default: 1 }
+    ]
+  },
+  // === DYNAMICS EFFECTS ===
+  {
+    id: "compressor",
+    name: "Compressor",
+    category: "dynamics",
+    description: "Dynamic range compressor",
+    parameters: [
+      {
+        name: "threshold",
+        label: "Threshold",
+        type: "number",
+        min: -60,
+        max: 0,
+        step: 1,
+        default: -24,
+        unit: "dB"
+      },
+      { name: "ratio", label: "Ratio", type: "number", min: 1, max: 20, step: 0.5, default: 4 },
+      {
+        name: "attack",
+        label: "Attack",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 1e-3,
+        default: 3e-3,
+        unit: "s"
+      },
+      {
+        name: "release",
+        label: "Release",
+        type: "number",
+        min: 0,
+        max: 1,
+        step: 0.01,
+        default: 0.25,
+        unit: "s"
+      },
+      {
+        name: "knee",
+        label: "Knee",
+        type: "number",
+        min: 0,
+        max: 40,
+        step: 1,
+        default: 30,
+        unit: "dB"
+      }
+    ]
+  },
+  {
+    id: "limiter",
+    name: "Limiter",
+    category: "dynamics",
+    description: "Hard limiter to prevent clipping",
+    parameters: [
+      {
+        name: "threshold",
+        label: "Threshold",
+        type: "number",
+        min: -12,
+        max: 0,
+        step: 0.5,
+        default: -6,
+        unit: "dB"
+      }
+    ]
+  },
+  {
+    id: "gate",
+    name: "Gate",
+    category: "dynamics",
+    description: "Noise gate to silence signal below threshold",
+    parameters: [
+      {
+        name: "threshold",
+        label: "Threshold",
+        type: "number",
+        min: -100,
+        max: 0,
+        step: 1,
+        default: -40,
+        unit: "dB"
+      },
+      {
+        name: "attack",
+        label: "Attack",
+        type: "number",
+        min: 0,
+        max: 0.3,
+        step: 1e-3,
+        default: 1e-3,
+        unit: "s"
+      },
+      {
+        name: "release",
+        label: "Release",
+        type: "number",
+        min: 0,
+        max: 0.5,
+        step: 0.01,
+        default: 0.1,
+        unit: "s"
+      }
+    ]
+  },
+  // === SPATIAL EFFECTS ===
+  {
+    id: "stereoWidener",
+    name: "Stereo Widener",
+    category: "spatial",
+    description: "Expands or narrows the stereo image",
+    parameters: [
+      { name: "width", label: "Width", type: "number", min: 0, max: 1, step: 0.01, default: 0.5 }
+    ]
+  }
+];
+var getEffectDefinition = (id) => {
+  return effectDefinitions.find((def) => def.id === id);
+};
+var getEffectsByCategory = (category) => {
+  return effectDefinitions.filter((def) => def.category === category);
+};
+var effectCategories = [
+  { id: "reverb", name: "Reverb" },
+  { id: "delay", name: "Delay" },
+  { id: "modulation", name: "Modulation" },
+  { id: "filter", name: "Filter" },
+  { id: "distortion", name: "Distortion" },
+  { id: "dynamics", name: "Dynamics" },
+  { id: "spatial", name: "Spatial" }
+];
+
+// src/effects/effectFactory.ts
+import {
+  Reverb,
+  Freeverb,
+  JCReverb,
+  FeedbackDelay,
+  PingPongDelay,
+  Chorus,
+  Phaser,
+  Tremolo,
+  Vibrato,
+  AutoPanner,
+  AutoFilter,
+  AutoWah,
+  EQ3,
+  Distortion,
+  BitCrusher,
+  Chebyshev,
+  Compressor,
+  Limiter,
+  Gate,
+  StereoWidener
+} from "tone";
+function asEffectConstructor(ctor) {
+  return ctor;
+}
+var effectConstructors = {
+  reverb: asEffectConstructor(Reverb),
+  freeverb: asEffectConstructor(Freeverb),
+  jcReverb: asEffectConstructor(JCReverb),
+  feedbackDelay: asEffectConstructor(FeedbackDelay),
+  pingPongDelay: asEffectConstructor(PingPongDelay),
+  chorus: asEffectConstructor(Chorus),
+  phaser: asEffectConstructor(Phaser),
+  tremolo: asEffectConstructor(Tremolo),
+  vibrato: asEffectConstructor(Vibrato),
+  autoPanner: asEffectConstructor(AutoPanner),
+  autoFilter: asEffectConstructor(AutoFilter),
+  autoWah: asEffectConstructor(AutoWah),
+  eq3: asEffectConstructor(EQ3),
+  distortion: asEffectConstructor(Distortion),
+  bitCrusher: asEffectConstructor(BitCrusher),
+  chebyshev: asEffectConstructor(Chebyshev),
+  compressor: asEffectConstructor(Compressor),
+  limiter: asEffectConstructor(Limiter),
+  gate: asEffectConstructor(Gate),
+  stereoWidener: asEffectConstructor(StereoWidener)
+};
+var instanceCounter = 0;
+var generateInstanceId = () => {
+  return `effect_${Date.now()}_${++instanceCounter}`;
+};
+function createEffectInstance(definition, initialParams) {
+  const Constructor = effectConstructors[definition.id];
+  if (!Constructor) {
+    throw new Error(`Unknown effect type: ${definition.id}`);
+  }
+  const options = {};
+  definition.parameters.forEach((param) => {
+    var _a;
+    const value = (_a = initialParams == null ? void 0 : initialParams[param.name]) != null ? _a : param.default;
+    options[param.name] = value;
+  });
+  const effect = new Constructor(options);
+  const instanceId = generateInstanceId();
+  const effectRecord = effect;
+  return {
+    effect,
+    id: definition.id,
+    instanceId,
+    dispose() {
+      try {
+        effect.disconnect();
+        effect.dispose();
+      } catch (e) {
+        console.warn(
+          `[waveform-playlist] Error disposing effect "${definition.id}" (${instanceId}):`,
+          e
+        );
+      }
+    },
+    setParameter(name, value) {
+      const prop = effectRecord[name];
+      if (name === "wet") {
+        const wetProp = effectRecord["wet"];
+        if (wetProp && typeof wetProp === "object" && "value" in wetProp) {
+          wetProp.value = value;
+          return;
+        }
+      }
+      if (prop !== void 0) {
+        if (prop && typeof prop === "object" && "value" in prop) {
+          prop.value = value;
+        } else {
+          effectRecord[name] = value;
+        }
+      }
+    },
+    getParameter(name) {
+      if (name === "wet") {
+        const wetProp = effectRecord["wet"];
+        if (wetProp && typeof wetProp === "object" && "value" in wetProp) {
+          return wetProp.value;
+        }
+      }
+      const prop = effectRecord[name];
+      if (prop !== void 0) {
+        if (prop && typeof prop === "object" && "value" in prop) {
+          return prop.value;
+        }
+        return prop;
+      }
+      return void 0;
+    },
+    connect(destination) {
+      effect.connect(destination);
+    },
+    disconnect() {
+      try {
+        effect.disconnect();
+      } catch (e) {
+        console.warn(
+          `[waveform-playlist] Error disconnecting effect "${definition.id}" (${instanceId}):`,
+          e
+        );
+      }
+    }
+  };
+}
+function createEffectChain(effects) {
+  if (effects.length === 0) {
+    throw new Error("Cannot create effect chain with no effects");
+  }
+  for (let i = 0; i < effects.length - 1; i++) {
+    effects[i].effect.connect(effects[i + 1].effect);
+  }
+  return {
+    input: effects[0].effect,
+    output: effects[effects.length - 1].effect,
+    dispose() {
+      effects.forEach((e) => e.dispose());
+    }
+  };
+}
+
+// src/hooks/useDynamicEffects.ts
+import { Analyser as Analyser2 } from "tone";
+function useDynamicEffects(fftSize = 256) {
+  const [activeEffects, setActiveEffects] = useState2([]);
+  const activeEffectsRef = useRef3(activeEffects);
+  activeEffectsRef.current = activeEffects;
+  const effectInstancesRef = useRef3(/* @__PURE__ */ new Map());
+  const analyserRef = useRef3(null);
+  const graphNodesRef = useRef3(null);
+  const rebuildChain = useCallback2((effects) => {
+    const nodes = graphNodesRef.current;
+    if (!nodes) return;
+    const { masterGainNode, destination, analyserNode } = nodes;
+    try {
+      masterGainNode.disconnect();
+    } catch (e) {
+      console.warn("[waveform-playlist] Error disconnecting master effects chain:", e);
+    }
+    const instances = effects.map((ae) => effectInstancesRef.current.get(ae.instanceId)).filter((inst) => inst !== void 0);
+    if (instances.length === 0) {
+      masterGainNode.connect(analyserNode);
+      analyserNode.connect(destination);
+    } else {
+      let currentNode = masterGainNode;
+      instances.forEach((inst) => {
+        try {
+          inst.disconnect();
+        } catch (e) {
+          console.warn(`[waveform-playlist] Error disconnecting effect "${inst.id}":`, e);
+        }
+        currentNode.connect(inst.effect);
+        currentNode = inst.effect;
+      });
+      currentNode.connect(analyserNode);
+      analyserNode.connect(destination);
+    }
+  }, []);
+  const addEffect = useCallback2((effectId) => {
+    const definition = getEffectDefinition(effectId);
+    if (!definition) {
+      console.error(`Unknown effect: ${effectId}`);
+      return;
+    }
+    const params = {};
+    definition.parameters.forEach((p) => {
+      params[p.name] = p.default;
+    });
+    const instance = createEffectInstance(definition, params);
+    effectInstancesRef.current.set(instance.instanceId, instance);
+    const newActiveEffect = {
+      instanceId: instance.instanceId,
+      effectId: definition.id,
+      definition,
+      params,
+      bypassed: false
+    };
+    setActiveEffects((prev) => [...prev, newActiveEffect]);
+  }, []);
+  const removeEffect = useCallback2((instanceId) => {
+    const instance = effectInstancesRef.current.get(instanceId);
+    if (instance) {
+      instance.dispose();
+      effectInstancesRef.current.delete(instanceId);
+    }
+    setActiveEffects((prev) => prev.filter((e) => e.instanceId !== instanceId));
+  }, []);
+  const updateParameter = useCallback2(
+    (instanceId, paramName, value) => {
+      const instance = effectInstancesRef.current.get(instanceId);
+      if (instance) {
+        instance.setParameter(paramName, value);
+      }
+      setActiveEffects(
+        (prev) => prev.map(
+          (e) => e.instanceId === instanceId ? __spreadProps(__spreadValues({}, e), { params: __spreadProps(__spreadValues({}, e.params), { [paramName]: value }) }) : e
+        )
+      );
+    },
+    []
+  );
+  const toggleBypass = useCallback2((instanceId) => {
+    var _a;
+    const effect = activeEffectsRef.current.find((e) => e.instanceId === instanceId);
+    if (!effect) return;
+    const newBypassed = !effect.bypassed;
+    const instance = effectInstancesRef.current.get(instanceId);
+    if (instance) {
+      const originalWet = (_a = effect.params.wet) != null ? _a : 1;
+      instance.setParameter("wet", newBypassed ? 0 : originalWet);
+    }
+    setActiveEffects(
+      (prev) => prev.map((e) => e.instanceId === instanceId ? __spreadProps(__spreadValues({}, e), { bypassed: newBypassed }) : e)
+    );
+  }, []);
+  const reorderEffects = useCallback2((fromIndex, toIndex) => {
+    setActiveEffects((prev) => {
+      const newEffects = [...prev];
+      const [removed] = newEffects.splice(fromIndex, 1);
+      newEffects.splice(toIndex, 0, removed);
+      return newEffects;
+    });
+  }, []);
+  const clearAllEffects = useCallback2(() => {
+    effectInstancesRef.current.forEach((inst) => inst.dispose());
+    effectInstancesRef.current.clear();
+    setActiveEffects([]);
+  }, []);
+  useEffect2(() => {
+    rebuildChain(activeEffects);
+  }, [activeEffects, rebuildChain]);
+  const masterEffects = useCallback2(
+    (masterGainNode, destination, _isOffline) => {
+      const analyserNode = new Analyser2("fft", fftSize);
+      analyserRef.current = analyserNode;
+      graphNodesRef.current = {
+        masterGainNode,
+        destination,
+        analyserNode
+      };
+      const effects = activeEffectsRef.current;
+      const instances = effects.map((ae) => effectInstancesRef.current.get(ae.instanceId)).filter((inst) => inst !== void 0);
+      if (instances.length === 0) {
+        masterGainNode.connect(analyserNode);
+        analyserNode.connect(destination);
+      } else {
+        let currentNode = masterGainNode;
+        instances.forEach((inst) => {
+          currentNode.connect(inst.effect);
+          currentNode = inst.effect;
+        });
+        currentNode.connect(analyserNode);
+        analyserNode.connect(destination);
+      }
+      return function cleanup() {
+        analyserNode.dispose();
+        analyserRef.current = null;
+        graphNodesRef.current = null;
+      };
+    },
+    [fftSize]
+    // Only fftSize - reads effects from ref
+  );
+  useEffect2(() => {
+    const effectInstances = effectInstancesRef.current;
+    return () => {
+      effectInstances.forEach((inst) => inst.dispose());
+      effectInstances.clear();
+    };
+  }, []);
+  const createOfflineEffectsFunction = useCallback2(() => {
+    const nonBypassedEffects = activeEffects.filter((e) => !e.bypassed);
+    if (nonBypassedEffects.length === 0) {
+      return void 0;
+    }
+    return (masterGainNode, destination, _isOffline) => {
+      const offlineInstances = [];
+      for (const activeEffect of nonBypassedEffects) {
+        const instance = createEffectInstance(activeEffect.definition, activeEffect.params);
+        offlineInstances.push(instance);
+      }
+      if (offlineInstances.length === 0) {
+        masterGainNode.connect(destination);
+      } else {
+        let currentNode = masterGainNode;
+        offlineInstances.forEach((inst) => {
+          currentNode.connect(inst.effect);
+          currentNode = inst.effect;
+        });
+        currentNode.connect(destination);
+      }
+      return function cleanup() {
+        offlineInstances.forEach((inst) => inst.dispose());
+      };
+    };
+  }, [activeEffects]);
+  return {
+    activeEffects,
+    availableEffects: effectDefinitions,
+    addEffect,
+    removeEffect,
+    updateParameter,
+    toggleBypass,
+    reorderEffects,
+    clearAllEffects,
+    masterEffects,
+    createOfflineEffectsFunction,
+    analyserRef
+  };
+}
+
+// src/hooks/useTrackDynamicEffects.ts
+import { useState as useState3, useCallback as useCallback3, useRef as useRef4, useEffect as useEffect3 } from "react";
+function useTrackDynamicEffects() {
+  const [trackEffectsState, setTrackEffectsState] = useState3(
+    /* @__PURE__ */ new Map()
+  );
+  const trackEffectInstancesRef = useRef4(/* @__PURE__ */ new Map());
+  const trackGraphNodesRef = useRef4(/* @__PURE__ */ new Map());
+  const rebuildTrackChain = useCallback3((trackId, trackEffects) => {
+    const nodes = trackGraphNodesRef.current.get(trackId);
+    if (!nodes) return;
+    const { graphEnd, masterGainNode } = nodes;
+    const instancesMap = trackEffectInstancesRef.current.get(trackId);
+    try {
+      graphEnd.disconnect();
+    } catch (e) {
+      console.warn(`[waveform-playlist] Error disconnecting track "${trackId}" effect chain:`, e);
+    }
+    const instances = trackEffects.map((ae) => instancesMap == null ? void 0 : instancesMap.get(ae.instanceId)).filter((inst) => inst !== void 0);
+    if (instances.length === 0) {
+      graphEnd.connect(masterGainNode);
+    } else {
+      let currentNode = graphEnd;
+      instances.forEach((inst) => {
+        try {
+          inst.disconnect();
+        } catch (e) {
+          console.warn(
+            `[waveform-playlist] Error disconnecting effect "${inst.id}" on track "${trackId}":`,
+            e
+          );
+        }
+        currentNode.connect(inst.effect);
+        currentNode = inst.effect;
+      });
+      currentNode.connect(masterGainNode);
+    }
+  }, []);
+  const addEffectToTrack = useCallback3((trackId, effectId) => {
+    const definition = getEffectDefinition(effectId);
+    if (!definition) {
+      console.error(`Unknown effect: ${effectId}`);
+      return;
+    }
+    const params = {};
+    definition.parameters.forEach((p) => {
+      params[p.name] = p.default;
+    });
+    const instance = createEffectInstance(definition, params);
+    if (!trackEffectInstancesRef.current.has(trackId)) {
+      trackEffectInstancesRef.current.set(trackId, /* @__PURE__ */ new Map());
+    }
+    trackEffectInstancesRef.current.get(trackId).set(instance.instanceId, instance);
+    const newActiveEffect = {
+      instanceId: instance.instanceId,
+      effectId: definition.id,
+      definition,
+      params,
+      bypassed: false
+    };
+    setTrackEffectsState((prev) => {
+      const newState = new Map(prev);
+      const existing = newState.get(trackId) || [];
+      newState.set(trackId, [...existing, newActiveEffect]);
+      return newState;
+    });
+  }, []);
+  const removeEffectFromTrack = useCallback3((trackId, instanceId) => {
+    const instancesMap = trackEffectInstancesRef.current.get(trackId);
+    const instance = instancesMap == null ? void 0 : instancesMap.get(instanceId);
+    if (instance) {
+      instance.dispose();
+      instancesMap == null ? void 0 : instancesMap.delete(instanceId);
+    }
+    setTrackEffectsState((prev) => {
+      const newState = new Map(prev);
+      const existing = newState.get(trackId) || [];
+      newState.set(
+        trackId,
+        existing.filter((e) => e.instanceId !== instanceId)
+      );
+      return newState;
+    });
+  }, []);
+  const updateTrackEffectParameter = useCallback3(
+    (trackId, instanceId, paramName, value) => {
+      const instancesMap = trackEffectInstancesRef.current.get(trackId);
+      const instance = instancesMap == null ? void 0 : instancesMap.get(instanceId);
+      if (instance) {
+        instance.setParameter(paramName, value);
+      }
+      setTrackEffectsState((prev) => {
+        const newState = new Map(prev);
+        const existing = newState.get(trackId) || [];
+        newState.set(
+          trackId,
+          existing.map(
+            (e) => e.instanceId === instanceId ? __spreadProps(__spreadValues({}, e), { params: __spreadProps(__spreadValues({}, e.params), { [paramName]: value }) }) : e
+          )
+        );
+        return newState;
+      });
+    },
+    []
+  );
+  const toggleBypass = useCallback3((trackId, instanceId) => {
+    var _a;
+    const trackEffects = trackEffectsStateRef.current.get(trackId) || [];
+    const effect = trackEffects.find((e) => e.instanceId === instanceId);
+    if (!effect) return;
+    const newBypassed = !effect.bypassed;
+    const instancesMap = trackEffectInstancesRef.current.get(trackId);
+    const instance = instancesMap == null ? void 0 : instancesMap.get(instanceId);
+    if (instance) {
+      const originalWet = (_a = effect.params.wet) != null ? _a : 1;
+      instance.setParameter("wet", newBypassed ? 0 : originalWet);
+    }
+    setTrackEffectsState((prev) => {
+      const newState = new Map(prev);
+      const existing = newState.get(trackId) || [];
+      newState.set(
+        trackId,
+        existing.map((e) => e.instanceId === instanceId ? __spreadProps(__spreadValues({}, e), { bypassed: newBypassed }) : e)
+      );
+      return newState;
+    });
+  }, []);
+  const clearTrackEffects = useCallback3((trackId) => {
+    const instancesMap = trackEffectInstancesRef.current.get(trackId);
+    if (instancesMap) {
+      instancesMap.forEach((inst) => inst.dispose());
+      instancesMap.clear();
+    }
+    setTrackEffectsState((prev) => {
+      const newState = new Map(prev);
+      newState.set(trackId, []);
+      return newState;
+    });
+  }, []);
+  const trackEffectsStateRef = useRef4(trackEffectsState);
+  trackEffectsStateRef.current = trackEffectsState;
+  const getTrackEffectsFunction = useCallback3(
+    (trackId) => {
+      return (graphEnd, masterGainNode, _isOffline) => {
+        trackGraphNodesRef.current.set(trackId, {
+          graphEnd,
+          masterGainNode
+        });
+        const trackEffects = trackEffectsStateRef.current.get(trackId) || [];
+        const instancesMap = trackEffectInstancesRef.current.get(trackId);
+        const instances = trackEffects.map((ae) => instancesMap == null ? void 0 : instancesMap.get(ae.instanceId)).filter((inst) => inst !== void 0);
+        if (instances.length === 0) {
+          graphEnd.connect(masterGainNode);
+        } else {
+          let currentNode = graphEnd;
+          instances.forEach((inst) => {
+            currentNode.connect(inst.effect);
+            currentNode = inst.effect;
+          });
+          currentNode.connect(masterGainNode);
+        }
+        return function cleanup() {
+          trackGraphNodesRef.current.delete(trackId);
+        };
+      };
+    },
+    []
+    // No dependencies - stable function that reads from refs
+  );
+  useEffect3(() => {
+    trackEffectsState.forEach((effects, trackId) => {
+      rebuildTrackChain(trackId, effects);
+    });
+  }, [trackEffectsState, rebuildTrackChain]);
+  useEffect3(() => {
+    const trackEffectInstances = trackEffectInstancesRef.current;
+    return () => {
+      trackEffectInstances.forEach((instancesMap) => {
+        instancesMap.forEach((inst) => inst.dispose());
+        instancesMap.clear();
+      });
+      trackEffectInstances.clear();
+    };
+  }, []);
+  const createOfflineTrackEffectsFunction = useCallback3(
+    (trackId) => {
+      const trackEffects = trackEffectsState.get(trackId) || [];
+      const nonBypassedEffects = trackEffects.filter((e) => !e.bypassed);
+      if (nonBypassedEffects.length === 0) {
+        return void 0;
+      }
+      return (graphEnd, masterGainNode, _isOffline) => {
+        const offlineInstances = [];
+        for (const activeEffect of nonBypassedEffects) {
+          const instance = createEffectInstance(activeEffect.definition, activeEffect.params);
+          offlineInstances.push(instance);
+        }
+        if (offlineInstances.length === 0) {
+          graphEnd.connect(masterGainNode);
+        } else {
+          let currentNode = graphEnd;
+          offlineInstances.forEach((inst) => {
+            currentNode.connect(inst.effect);
+            currentNode = inst.effect;
+          });
+          currentNode.connect(masterGainNode);
+        }
+        return function cleanup() {
+          offlineInstances.forEach((inst) => inst.dispose());
+        };
+      };
+    },
+    [trackEffectsState]
+  );
+  return {
+    trackEffectsState,
+    addEffectToTrack,
+    removeEffectFromTrack,
+    updateTrackEffectParameter,
+    toggleBypass,
+    clearTrackEffects,
+    getTrackEffectsFunction,
+    createOfflineTrackEffectsFunction,
+    availableEffects: effectDefinitions
+  };
+}
+
+// src/hooks/useExportWav.ts
+import { useState as useState4, useCallback as useCallback4 } from "react";
+import {
+  gainToDb,
+  trackChannelCount,
+  applyFadeIn,
+  applyFadeOut
+} from "@waveform-playlist/core";
+import {
+  getUnderlyingAudioParam,
+  getGlobalAudioContext
+} from "@waveform-playlist/playout";
+
+// src/utils/wavEncoder.ts
+function encodeWav(audioBuffer, options = {}) {
+  const { bitDepth = 16 } = options;
+  const numChannels = audioBuffer.numberOfChannels;
+  const sampleRate = audioBuffer.sampleRate;
+  const numSamples = audioBuffer.length;
+  const bytesPerSample = bitDepth / 8;
+  const blockAlign = numChannels * bytesPerSample;
+  const byteRate = sampleRate * blockAlign;
+  const dataSize = numSamples * blockAlign;
+  const headerSize = 44;
+  const totalSize = headerSize + dataSize;
+  const buffer = new ArrayBuffer(totalSize);
+  const view = new DataView(buffer);
+  writeString(view, 0, "RIFF");
+  view.setUint32(4, totalSize - 8, true);
+  writeString(view, 8, "WAVE");
+  writeString(view, 12, "fmt ");
+  view.setUint32(16, 16, true);
+  view.setUint16(20, bitDepth === 32 ? 3 : 1, true);
+  view.setUint16(22, numChannels, true);
+  view.setUint32(24, sampleRate, true);
+  view.setUint32(28, byteRate, true);
+  view.setUint16(32, blockAlign, true);
+  view.setUint16(34, bitDepth, true);
+  writeString(view, 36, "data");
+  view.setUint32(40, dataSize, true);
+  const channelData = [];
+  for (let ch = 0; ch < numChannels; ch++) {
+    channelData.push(audioBuffer.getChannelData(ch));
+  }
+  let offset = headerSize;
+  if (bitDepth === 16) {
+    for (let i = 0; i < numSamples; i++) {
+      for (let ch = 0; ch < numChannels; ch++) {
+        const sample = channelData[ch][i];
+        const clampedSample = Math.max(-1, Math.min(1, sample));
+        const intSample = clampedSample < 0 ? clampedSample * 32768 : clampedSample * 32767;
+        view.setInt16(offset, intSample, true);
+        offset += 2;
+      }
+    }
+  } else {
+    for (let i = 0; i < numSamples; i++) {
+      for (let ch = 0; ch < numChannels; ch++) {
+        view.setFloat32(offset, channelData[ch][i], true);
+        offset += 4;
+      }
+    }
+  }
+  return new Blob([buffer], { type: "audio/wav" });
+}
+function writeString(view, offset, str) {
+  for (let i = 0; i < str.length; i++) {
+    view.setUint8(offset + i, str.charCodeAt(i));
+  }
+}
+function downloadBlob(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const a = document.createElement("a");
+  a.href = url;
+  a.download = filename;
+  a.style.display = "none";
+  document.body.appendChild(a);
+  a.click();
+  document.body.removeChild(a);
+  URL.revokeObjectURL(url);
+}
+
+// src/hooks/useExportWav.ts
+function useExportWav() {
+  const [isExporting, setIsExporting] = useState4(false);
+  const [progress, setProgress] = useState4(0);
+  const [error, setError] = useState4(null);
+  const exportWav = useCallback4(
+    (_0, _1, ..._2) => __async(null, [_0, _1, ..._2], function* (tracks, trackStates, options = {}) {
+      const {
+        filename = "export",
+        mode = "master",
+        trackIndex,
+        autoDownload = true,
+        applyEffects = true,
+        effectsFunction,
+        createOfflineTrackEffects,
+        bitDepth = 16,
+        onProgress
+      } = options;
+      setIsExporting(true);
+      setProgress(0);
+      setError(null);
+      try {
+        if (tracks.length === 0) {
+          throw new Error("No tracks to export");
+        }
+        if (mode === "individual" && (trackIndex === void 0 || trackIndex < 0 || trackIndex >= tracks.length)) {
+          throw new Error("Invalid track index for individual export");
+        }
+        const sampleRate = getGlobalAudioContext().sampleRate;
+        let totalDurationSamples = 0;
+        for (const track of tracks) {
+          for (const clip of track.clips) {
+            const clipEndSample = clip.startSample + clip.durationSamples;
+            totalDurationSamples = Math.max(totalDurationSamples, clipEndSample);
+          }
+        }
+        totalDurationSamples += Math.round(sampleRate * 0.1);
+        const duration = totalDurationSamples / sampleRate;
+        const tracksToRender = mode === "individual" ? [{ track: tracks[trackIndex], state: trackStates[trackIndex], index: trackIndex }] : tracks.map((track, index) => ({ track, state: trackStates[index], index }));
+        const hasSolo = mode === "master" && trackStates.some((state) => state.soloed);
+        const reportProgress = (p) => {
+          setProgress(p);
+          onProgress == null ? void 0 : onProgress(p);
+        };
+        const renderedBuffer = yield renderOffline(
+          tracksToRender,
+          hasSolo,
+          duration,
+          sampleRate,
+          applyEffects,
+          effectsFunction,
+          createOfflineTrackEffects,
+          reportProgress
+        );
+        reportProgress(0.9);
+        const blob = encodeWav(renderedBuffer, { bitDepth });
+        reportProgress(1);
+        if (autoDownload) {
+          const exportFilename = mode === "individual" ? `${filename}_${tracks[trackIndex].name}` : filename;
+          downloadBlob(blob, `${exportFilename}.wav`);
+        }
+        return {
+          audioBuffer: renderedBuffer,
+          blob,
+          duration
+        };
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Export failed";
+        setError(message);
+        throw err;
+      } finally {
+        setIsExporting(false);
+      }
+    }),
+    []
+  );
+  return {
+    exportWav,
+    isExporting,
+    progress,
+    error
+  };
+}
+function renderOffline(tracksToRender, hasSolo, duration, sampleRate, applyEffects, effectsFunction, createOfflineTrackEffects, onProgress) {
+  return __async(this, null, function* () {
+    const { Offline, Volume: Volume2, Gain, Panner, Player, ToneAudioBuffer } = yield import("tone");
+    onProgress(0.1);
+    const audibleTracks = tracksToRender.filter(({ state }) => {
+      if (state.muted && !state.soloed) return false;
+      if (hasSolo && !state.soloed) return false;
+      return true;
+    });
+    const outputChannels = audibleTracks.reduce(
+      (max, { track }) => Math.max(max, trackChannelCount(track)),
+      1
+    );
+    let buffer;
+    try {
+      buffer = yield Offline(
+        (_0) => __async(null, [_0], function* ({ transport, destination }) {
+          const masterVolume = new Volume2(0);
+          if (effectsFunction && applyEffects) {
+            effectsFunction(masterVolume, destination, true);
+          } else {
+            masterVolume.connect(destination);
+          }
+          for (const { track, state } of audibleTracks) {
+            const trackVolume = new Volume2(gainToDb(state.volume));
+            const trackPan = new Panner({ pan: state.pan, channelCount: trackChannelCount(track) });
+            const trackMute = new Gain(state.muted ? 0 : 1);
+            const trackEffects = createOfflineTrackEffects == null ? void 0 : createOfflineTrackEffects(track.id);
+            if (trackEffects && applyEffects) {
+              trackEffects(trackMute, masterVolume, true);
+            } else {
+              trackMute.connect(masterVolume);
+            }
+            trackPan.connect(trackMute);
+            trackVolume.connect(trackPan);
+            for (const clip of track.clips) {
+              const {
+                audioBuffer,
+                startSample,
+                durationSamples,
+                offsetSamples,
+                gain: clipGain,
+                fadeIn,
+                fadeOut
+              } = clip;
+              if (!audioBuffer) {
+                console.warn(
+                  '[waveform-playlist] Skipping clip "' + (clip.name || clip.id) + '" - no audioBuffer for export'
+                );
+                continue;
+              }
+              const startTime = startSample / sampleRate;
+              const clipDuration = durationSamples / sampleRate;
+              const offset = offsetSamples / sampleRate;
+              const toneBuffer = new ToneAudioBuffer(audioBuffer);
+              const player = new Player(toneBuffer);
+              const fadeGain = new Gain(clipGain);
+              player.connect(fadeGain);
+              fadeGain.connect(trackVolume);
+              if (applyEffects) {
+                const audioParam = getUnderlyingAudioParam(fadeGain.gain);
+                if (audioParam) {
+                  applyClipFades(audioParam, clipGain, startTime, clipDuration, fadeIn, fadeOut);
+                } else if (fadeIn || fadeOut) {
+                  console.warn(
+                    '[waveform-playlist] Cannot apply fades for clip "' + (clip.name || clip.id) + '" - AudioParam not accessible'
+                  );
+                }
+              }
+              player.start(startTime, offset, clipDuration);
+            }
+          }
+          transport.start(0);
+        }),
+        duration,
+        outputChannels,
+        sampleRate
+      );
+    } catch (err) {
+      if (err instanceof Error) {
+        throw err;
+      } else {
+        throw new Error("Tone.Offline rendering failed: " + String(err));
+      }
+    }
+    onProgress(0.9);
+    const result = buffer.get();
+    if (!result) {
+      throw new Error("Offline rendering produced no audio buffer");
+    }
+    return result;
+  });
+}
+function applyClipFades(gainParam, clipGain, startTime, clipDuration, fadeIn, fadeOut) {
+  if (fadeIn) {
+    gainParam.setValueAtTime(0, startTime);
+  } else {
+    gainParam.setValueAtTime(clipGain, startTime);
+  }
+  if (fadeIn) {
+    applyFadeIn(gainParam, startTime, fadeIn.duration, fadeIn.type || "linear", 0, clipGain);
+  }
+  if (fadeOut) {
+    const fadeOutStart = startTime + clipDuration - fadeOut.duration;
+    if (!fadeIn || fadeIn.duration < clipDuration - fadeOut.duration) {
+      gainParam.setValueAtTime(clipGain, fadeOutStart);
+    }
+    applyFadeOut(gainParam, fadeOutStart, fadeOut.duration, fadeOut.type || "linear", clipGain, 0);
+  }
+}
+
+// src/hooks/useDynamicTracks.ts
+import { useState as useState5, useCallback as useCallback5, useRef as useRef5, useEffect as useEffect4 } from "react";
+import { createTrack as createTrack2, createClipFromSeconds as createClipFromSeconds2 } from "@waveform-playlist/core";
+import { getGlobalAudioContext as getGlobalAudioContext2 } from "@waveform-playlist/playout";
+function getSourceName(source) {
+  var _a, _b, _c, _d, _e;
+  if (source instanceof File) {
+    return source.name.replace(/\.[^/.]+$/, "");
+  }
+  if (source instanceof Blob) {
+    return "Untitled";
+  }
+  if (typeof source === "string") {
+    return (_b = (_a = source.split("/").pop()) == null ? void 0 : _a.replace(/\.[^/.]+$/, "")) != null ? _b : "Untitled";
+  }
+  return (_e = (_d = source.name) != null ? _d : (_c = source.src.split("/").pop()) == null ? void 0 : _c.replace(/\.[^/.]+$/, "")) != null ? _e : "Untitled";
+}
+function decodeSource(source, audioContext, signal) {
+  return __async(this, null, function* () {
+    const name = getSourceName(source);
+    if (source instanceof Blob) {
+      const arrayBuffer2 = yield source.arrayBuffer();
+      signal == null ? void 0 : signal.throwIfAborted();
+      const audioBuffer2 = yield audioContext.decodeAudioData(arrayBuffer2);
+      return { audioBuffer: audioBuffer2, name };
+    }
+    const url = typeof source === "string" ? source : source.src;
+    const response = yield fetch(url, { signal });
+    if (!response.ok) throw new Error(`Failed to fetch ${url}: ${response.statusText}`);
+    const arrayBuffer = yield response.arrayBuffer();
+    signal == null ? void 0 : signal.throwIfAborted();
+    const audioBuffer = yield audioContext.decodeAudioData(arrayBuffer);
+    return { audioBuffer, name };
+  });
+}
+function useDynamicTracks() {
+  const [tracks, setTracks] = useState5([]);
+  const [loadingCount, setLoadingCount] = useState5(0);
+  const [errors, setErrors] = useState5([]);
+  const cancelledRef = useRef5(false);
+  const loadingIdsRef = useRef5(/* @__PURE__ */ new Set());
+  const abortControllersRef = useRef5(/* @__PURE__ */ new Map());
+  useEffect4(() => {
+    const controllers = abortControllersRef.current;
+    return () => {
+      cancelledRef.current = true;
+      for (const controller of controllers.values()) {
+        controller.abort();
+      }
+      controllers.clear();
+    };
+  }, []);
+  const addTracks = useCallback5((sources) => {
+    if (sources.length === 0) return;
+    const audioContext = getGlobalAudioContext2();
+    const placeholders = sources.map((source) => ({
+      track: createTrack2({ name: `${getSourceName(source)} (loading...)`, clips: [] }),
+      source
+    }));
+    setTracks((prev) => [...prev, ...placeholders.map((p) => p.track)]);
+    setLoadingCount((prev) => prev + sources.length);
+    for (const { track, source } of placeholders) {
+      loadingIdsRef.current.add(track.id);
+      const controller = new AbortController();
+      abortControllersRef.current.set(track.id, controller);
+      (() => __async(null, null, function* () {
+        try {
+          const { audioBuffer, name } = yield decodeSource(source, audioContext, controller.signal);
+          const clip = createClipFromSeconds2({
+            audioBuffer,
+            startTime: 0,
+            duration: audioBuffer.duration,
+            offset: 0,
+            name
+          });
+          if (!cancelledRef.current && loadingIdsRef.current.has(track.id)) {
+            setTracks(
+              (prev) => prev.map((t) => t.id === track.id ? __spreadProps(__spreadValues({}, t), { name, clips: [clip] }) : t)
+            );
+          }
+        } catch (error) {
+          if (error instanceof DOMException && error.name === "AbortError") return;
+          console.warn("[waveform-playlist] Error loading audio:", error);
+          if (!cancelledRef.current && loadingIdsRef.current.has(track.id)) {
+            setTracks((prev) => prev.filter((t) => t.id !== track.id));
+            setErrors((prev) => [
+              ...prev,
+              {
+                name: getSourceName(source),
+                error: error instanceof Error ? error : new Error(String(error))
+              }
+            ]);
+          }
+        } finally {
+          abortControllersRef.current.delete(track.id);
+          if (!cancelledRef.current && loadingIdsRef.current.delete(track.id)) {
+            setLoadingCount((prev) => prev - 1);
+          }
+        }
+      }))();
+    }
+  }, []);
+  const removeTrack = useCallback5((trackId) => {
+    setTracks((prev) => prev.filter((t) => t.id !== trackId));
+    const controller = abortControllersRef.current.get(trackId);
+    if (controller) {
+      controller.abort();
+      abortControllersRef.current.delete(trackId);
+    }
+    if (loadingIdsRef.current.delete(trackId)) {
+      setLoadingCount((prev) => prev - 1);
+    }
+  }, []);
+  return {
+    tracks,
+    addTracks,
+    removeTrack,
+    loadingCount,
+    isLoading: loadingCount > 0,
+    errors
+  };
+}
+
+// src/hooks/useOutputMeter.ts
+import { useEffect as useEffect5, useState as useState6, useRef as useRef6, useCallback as useCallback6 } from "react";
+import { getGlobalContext } from "@waveform-playlist/playout";
+import { gainToNormalized } from "@waveform-playlist/core";
+import { meterProcessorUrl } from "@waveform-playlist/worklets";
+var PEAK_DECAY = 0.98;
+function useOutputMeter(options = {}) {
+  const { channelCount = 2, updateRate = 60, isPlaying = false } = options;
+  const [levels, setLevels] = useState6(() => new Array(channelCount).fill(0));
+  const [peakLevels, setPeakLevels] = useState6(() => new Array(channelCount).fill(0));
+  const [rmsLevels, setRmsLevels] = useState6(() => new Array(channelCount).fill(0));
+  const workletNodeRef = useRef6(null);
+  const smoothedPeakRef = useRef6(new Array(channelCount).fill(0));
+  const [meterError, setMeterError] = useState6(null);
+  const resetPeak = useCallback6(
+    () => setPeakLevels(new Array(channelCount).fill(0)),
+    [channelCount]
+  );
+  useEffect5(() => {
+    if (!isPlaying) {
+      const zeros = new Array(channelCount).fill(0);
+      smoothedPeakRef.current = new Array(channelCount).fill(0);
+      setLevels(zeros);
+      setRmsLevels(zeros);
+      setPeakLevels(zeros);
+    }
+  }, [isPlaying, channelCount]);
+  useEffect5(() => {
+    let isMounted = true;
+    const setup = () => __async(null, null, function* () {
+      const context = getGlobalContext();
+      const rawCtx = context.rawContext;
+      yield rawCtx.audioWorklet.addModule(meterProcessorUrl);
+      if (!isMounted) return;
+      const workletNode = context.createAudioWorkletNode("meter-processor", {
+        channelCount,
+        channelCountMode: "explicit",
+        processorOptions: {
+          numberOfChannels: channelCount,
+          updateRate
+        }
+      });
+      workletNodeRef.current = workletNode;
+      workletNode.onprocessorerror = (event) => {
+        console.warn("[waveform-playlist] Output meter worklet processor error:", String(event));
+      };
+      const destination = context.destination;
+      destination.chain(workletNode);
+      smoothedPeakRef.current = new Array(channelCount).fill(0);
+      workletNode.port.onmessage = (event) => {
+        var _a;
+        if (!isMounted) return;
+        const { peak, rms } = event.data;
+        const smoothed = smoothedPeakRef.current;
+        const peakValues = [];
+        const rmsValues = [];
+        for (let ch = 0; ch < peak.length; ch++) {
+          smoothed[ch] = Math.max(peak[ch], ((_a = smoothed[ch]) != null ? _a : 0) * PEAK_DECAY);
+          peakValues.push(gainToNormalized(smoothed[ch]));
+          rmsValues.push(gainToNormalized(rms[ch]));
+        }
+        setLevels(peakValues);
+        setRmsLevels(rmsValues);
+        setPeakLevels((prev) => peakValues.map((val, i) => {
+          var _a2;
+          return Math.max((_a2 = prev[i]) != null ? _a2 : 0, val);
+        }));
+      };
+    });
+    setup().catch((err) => {
+      console.warn("[waveform-playlist] Failed to set up output meter:", String(err));
+      if (isMounted) {
+        setMeterError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    return () => {
+      isMounted = false;
+      if (workletNodeRef.current) {
+        try {
+          const context = getGlobalContext();
+          context.destination.chain();
+        } catch (err) {
+          console.warn("[waveform-playlist] Failed to restore destination chain:", String(err));
+        }
+        try {
+          workletNodeRef.current.disconnect();
+          workletNodeRef.current.port.close();
+        } catch (err) {
+          console.warn("[waveform-playlist] Output meter disconnect during cleanup:", String(err));
+        }
+        workletNodeRef.current = null;
+      }
+    };
+  }, [channelCount, updateRate]);
+  return { levels, peakLevels, rmsLevels, resetPeak, error: meterError };
+}
+
+// src/components/ExportControls.tsx
+import { BaseControlButton } from "@waveform-playlist/ui-components";
+
+// src/WaveformPlaylistContext.tsx
+import {
+  createContext,
+  useContext,
+  useState as useState7,
+  useEffect as useEffect6,
+  useRef as useRef7,
+  useCallback as useCallback7,
+  useMemo as useMemo2
+} from "react";
+import { ThemeProvider } from "styled-components";
+import { PlaylistEngine } from "@waveform-playlist/engine";
+import {
+  defaultTheme
+} from "@waveform-playlist/ui-components";
+import { jsx } from "react/jsx-runtime";
+var PlaybackAnimationContext = createContext(null);
+var PlaylistStateContext = createContext(null);
+var PlaylistControlsContext = createContext(null);
+var PlaylistDataContext = createContext(null);
+var usePlaylistData = () => {
+  const context = useContext(PlaylistDataContext);
+  if (!context) {
+    throw new Error("usePlaylistData must be used within WaveformPlaylistProvider");
+  }
+  return context;
+};
+
+// src/components/ExportControls.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ExportWavButton = ({
+  label = "Export WAV",
+  filename = "export",
+  mode = "master",
+  trackIndex,
+  bitDepth = 16,
+  applyEffects = true,
+  effectsFunction,
+  createOfflineTrackEffects,
+  className,
+  onExportComplete,
+  onExportError
+}) => {
+  const { tracks, trackStates } = usePlaylistData();
+  const { exportWav, isExporting, progress } = useExportWav();
+  const handleExport = () => __async(null, null, function* () {
+    try {
+      const result = yield exportWav(tracks, trackStates, {
+        filename,
+        mode,
+        trackIndex,
+        bitDepth,
+        applyEffects,
+        effectsFunction,
+        createOfflineTrackEffects,
+        autoDownload: true
+      });
+      onExportComplete == null ? void 0 : onExportComplete(result.blob);
+    } catch (error) {
+      onExportError == null ? void 0 : onExportError(error instanceof Error ? error : new Error("Export failed"));
+    }
+  });
+  const buttonLabel = isExporting ? `Exporting ${Math.round(progress * 100)}%` : label;
+  return /* @__PURE__ */ jsx2(
+    BaseControlButton,
+    {
+      onClick: handleExport,
+      disabled: isExporting || tracks.length === 0,
+      className,
+      children: buttonLabel
+    }
+  );
+};
+export {
+  ExportWavButton,
+  createEffectChain,
+  createEffectInstance,
+  effectCategories,
+  effectDefinitions,
+  getEffectDefinition,
+  getEffectsByCategory,
+  useAudioTracks,
+  useDynamicEffects,
+  useDynamicTracks,
+  useExportWav,
+  useMasterAnalyser,
+  useOutputMeter,
+  useTrackDynamicEffects
+};
+//# sourceMappingURL=tone.mjs.map