@waveform-playlist/browser 15.0.0 → 15.1.0

package/dist/tone.mjs

@@ -258,6 +258,10 @@ var useMasterAnalyser = (fftSize = 256) => {
 
 // src/hooks/useDynamicEffects.ts
 import { useState as useState2, useCallback as useCallback2, useRef as useRef3, useEffect as useEffect2 } from "react";
+import {
+  isNativeGlobalContext,
+  getGlobalAudioContext
+} from "@waveform-playlist/playout";
 
 // src/effects/effectDefinitions.ts
 var effectDefinitions = [
@@ -826,7 +830,8 @@ import {
   Compressor,
   Limiter,
   Gate,
-  StereoWidener
+  StereoWidener,
+  connect
 } from "tone";
 function asEffectConstructor(ctor) {
   return ctor;
@@ -881,8 +886,7 @@ function createEffectInstance(definition, initialParams) {
         effect.dispose();
       } catch (e) {
         console.warn(
-          `[waveform-playlist] Error disposing effect "${definition.id}" (${instanceId}):`,
-          e
+          `[waveform-playlist] Error disposing effect "${definition.id}" (${instanceId}): ${e instanceof Error ? e.message : String(e)}`
         );
       }
     },
@@ -927,8 +931,7 @@ function createEffectInstance(definition, initialParams) {
         effect.disconnect();
       } catch (e) {
         console.warn(
-          `[waveform-playlist] Error disconnecting effect "${definition.id}" (${instanceId}):`,
-          e
+          `[waveform-playlist] Error disconnecting effect "${definition.id}" (${instanceId}): ${e instanceof Error ? e.message : String(e)}`
         );
       }
     }
@@ -939,7 +942,7 @@ function createEffectChain(effects) {
     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);
+    connect(effects[i].effect, effects[i + 1].effect);
   }
   return {
     input: effects[0].effect,
@@ -950,13 +953,105 @@ function createEffectChain(effects) {
   };
 }
 
+// src/effects/loadWam.ts
+function loadWamModule() {
+  return __async(this, null, function* () {
+    try {
+      return yield import("@dawcore/wam");
+    } catch (err) {
+      const detail = err instanceof Error ? err.message : String(err);
+      throw new Error(
+        "[waveform-playlist] WAM plugin support requires the optional '@dawcore/wam' package.\nInstall it with: npm install @dawcore/wam\nOriginal error: " + detail
+      );
+    }
+  });
+}
+
+// src/effects/wamEffectFactory.ts
+import { connect as connect2, disconnect } from "tone";
+var wamInstanceCounter = 0;
+function createWamEffectInstance(plugin) {
+  var _a, _b, _c;
+  const node = plugin.audioNode;
+  const instanceId = "wam_" + ++wamInstanceCounter;
+  return {
+    kind: "wam",
+    plugin,
+    url: plugin.url,
+    effect: node,
+    id: "wam:" + ((_c = (_b = (_a = plugin.descriptor) == null ? void 0 : _a.name) != null ? _b : plugin.url) != null ? _c : "plugin"),
+    instanceId,
+    dispose: () => {
+      try {
+        plugin.destroy();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] Error destroying WAM plugin: " + (err instanceof Error ? err.message : String(err))
+        );
+      }
+    },
+    setParameter: (name, value) => {
+      var _a2;
+      if (typeof value !== "number") return;
+      const target = plugin.audioNode;
+      void ((_a2 = target.setParameterValues) == null ? void 0 : _a2.call(target, { [name]: { id: name, value, normalized: false } }));
+    },
+    getParameter: () => void 0,
+    // WAM params are async; read via the plugin GUI
+    connect: (destination) => connect2(node, destination),
+    disconnect: () => disconnect(node)
+  };
+}
+
+// src/effects/offlineChain.ts
+import { connect as connect3 } from "tone";
+function buildOfflineChain(entries, getLivePlugin, rawContext) {
+  return __async(this, null, function* () {
+    const instances = [];
+    const dispose = () => {
+      instances.forEach((inst) => inst.dispose());
+    };
+    try {
+      for (const entry of entries) {
+        if (entry.kind === "native") {
+          instances.push(createEffectInstance(entry.definition, entry.params));
+          continue;
+        }
+        const livePlugin = getLivePlugin(entry.instanceId);
+        if (!livePlugin) {
+          throw new Error(
+            '[waveform-playlist] WAV export: no live WAM plugin found for "' + entry.definition.name + '" (' + entry.instanceId + ") \u2014 cannot re-instantiate it offline."
+          );
+        }
+        const wam = yield loadWamModule();
+        const { hostGroupId } = yield wam.ensureWamHost(rawContext);
+        const clone = yield wam.cloneInstanceInto(livePlugin, rawContext, hostGroupId);
+        instances.push(createWamEffectInstance(clone));
+      }
+    } catch (err) {
+      dispose();
+      throw err;
+    }
+    return { instances, dispose };
+  });
+}
+function connectOfflineChain(from, instances, to) {
+  let current = from;
+  for (const inst of instances) {
+    connect3(current, inst.effect);
+    current = inst.effect;
+  }
+  connect3(current, to);
+}
+
 // src/hooks/useDynamicEffects.ts
-import { Analyser as Analyser2 } from "tone";
+import { Analyser as Analyser2, connect as connect4 } from "tone";
 function useDynamicEffects(fftSize = 256) {
   const [activeEffects, setActiveEffects] = useState2([]);
   const activeEffectsRef = useRef3(activeEffects);
   activeEffectsRef.current = activeEffects;
   const effectInstancesRef = useRef3(/* @__PURE__ */ new Map());
+  const isMountedRef = useRef3(true);
   const analyserRef = useRef3(null);
   const graphNodesRef = useRef3(null);
   const rebuildChain = useCallback2((effects) => {
@@ -968,7 +1063,8 @@ function useDynamicEffects(fftSize = 256) {
     } 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);
+    const audible = effects.filter((ae) => !(ae.kind === "wam" && ae.bypassed));
+    const instances = audible.map((ae) => effectInstancesRef.current.get(ae.instanceId)).filter((inst) => inst !== void 0);
     if (instances.length === 0) {
       masterGainNode.connect(analyserNode);
       analyserNode.connect(destination);
@@ -980,10 +1076,10 @@ function useDynamicEffects(fftSize = 256) {
         } catch (e) {
           console.warn(`[waveform-playlist] Error disconnecting effect "${inst.id}":`, e);
         }
-        currentNode.connect(inst.effect);
+        connect4(currentNode, inst.effect);
         currentNode = inst.effect;
       });
-      currentNode.connect(analyserNode);
+      connect4(currentNode, analyserNode);
       analyserNode.connect(destination);
     }
   }, []);
@@ -1002,12 +1098,68 @@ function useDynamicEffects(fftSize = 256) {
     const newActiveEffect = {
       instanceId: instance.instanceId,
       effectId: definition.id,
+      kind: "native",
       definition,
       params,
       bypassed: false
     };
     setActiveEffects((prev) => [...prev, newActiveEffect]);
   }, []);
+  const addWamEffect = useCallback2((url, initialState) => __async(null, null, function* () {
+    var _a, _b;
+    if (!isNativeGlobalContext()) {
+      throw new Error(
+        "[waveform-playlist] WAM plugins require a native AudioContext. Call configureGlobalContext({ nativeAudioContext: true }) from @waveform-playlist/playout before any audio initialization."
+      );
+    }
+    const wam = yield loadWamModule();
+    const ctx = getGlobalAudioContext();
+    const { hostGroupId } = yield wam.ensureWamHost(ctx);
+    const plugin = yield wam.createWamInstance(
+      url,
+      ctx,
+      hostGroupId,
+      initialState !== void 0 ? { initialState } : void 0
+    );
+    if (!isMountedRef.current) {
+      try {
+        plugin.destroy();
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] Error destroying WAM plugin after unmount: " + (err instanceof Error ? err.message : String(err))
+        );
+      }
+      throw new Error(
+        "[waveform-playlist] addWamEffect aborted: hook unmounted before the plugin finished loading."
+      );
+    }
+    const instance = createWamEffectInstance(plugin);
+    effectInstancesRef.current.set(instance.instanceId, instance);
+    const definition = {
+      id: instance.id,
+      name: (_b = (_a = plugin.descriptor) == null ? void 0 : _a.name) != null ? _b : url,
+      category: "wam",
+      description: "WAM plugin",
+      parameters: []
+    };
+    setActiveEffects((prev) => [
+      ...prev,
+      {
+        instanceId: instance.instanceId,
+        effectId: instance.id,
+        kind: "wam",
+        url,
+        definition,
+        params: {},
+        bypassed: false
+      }
+    ]);
+    return instance.instanceId;
+  }), []);
+  const getWamPlugin = useCallback2((instanceId) => {
+    const inst = effectInstancesRef.current.get(instanceId);
+    return (inst == null ? void 0 : inst.kind) === "wam" ? inst.plugin : void 0;
+  }, []);
   const removeEffect = useCallback2((instanceId) => {
     const instance = effectInstancesRef.current.get(instanceId);
     if (instance) {
@@ -1035,6 +1187,12 @@ function useDynamicEffects(fftSize = 256) {
     const effect = activeEffectsRef.current.find((e) => e.instanceId === instanceId);
     if (!effect) return;
     const newBypassed = !effect.bypassed;
+    if (effect.kind === "wam") {
+      setActiveEffects(
+        (prev) => prev.map((e) => e.instanceId === instanceId ? __spreadProps(__spreadValues({}, e), { bypassed: newBypassed }) : e)
+      );
+      return;
+    }
     const instance = effectInstancesRef.current.get(instanceId);
     if (instance) {
       const originalWet = (_a = effect.params.wet) != null ? _a : 1;
@@ -1070,17 +1228,18 @@ function useDynamicEffects(fftSize = 256) {
         analyserNode
       };
       const effects = activeEffectsRef.current;
-      const instances = effects.map((ae) => effectInstancesRef.current.get(ae.instanceId)).filter((inst) => inst !== void 0);
+      const audible = effects.filter((ae) => !(ae.kind === "wam" && ae.bypassed));
+      const instances = audible.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);
+          connect4(currentNode, inst.effect);
           currentNode = inst.effect;
         });
-        currentNode.connect(analyserNode);
+        connect4(currentNode, analyserNode);
         analyserNode.connect(destination);
       }
       return function cleanup() {
@@ -1093,42 +1252,45 @@ function useDynamicEffects(fftSize = 256) {
     // Only fftSize - reads effects from ref
   );
   useEffect2(() => {
+    isMountedRef.current = true;
     const effectInstances = effectInstancesRef.current;
     return () => {
+      isMountedRef.current = false;
       effectInstances.forEach((inst) => inst.dispose());
       effectInstances.clear();
     };
   }, []);
   const createOfflineEffectsFunction = useCallback2(() => {
-    const nonBypassedEffects = activeEffects.filter((e) => !e.bypassed);
-    if (nonBypassedEffects.length === 0) {
+    const nonBypassed = activeEffects.filter((e) => !e.bypassed);
+    if (nonBypassed.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);
+    const hasWam = nonBypassed.some((e) => e.kind === "wam");
+    return (masterGainNode, destination, _isOffline) => __async(null, null, function* () {
+      if (hasWam && !isNativeGlobalContext()) {
+        throw new Error(
+          "[waveform-playlist] WAV export with WAM effects requires a native AudioContext. Call configureGlobalContext({ nativeAudioContext: true }) from @waveform-playlist/playout before any audio initialization."
+        );
       }
-      return function cleanup() {
-        offlineInstances.forEach((inst) => inst.dispose());
-      };
-    };
+      const rawContext = masterGainNode.context.rawContext;
+      const { instances, dispose } = yield buildOfflineChain(
+        nonBypassed,
+        (instanceId) => {
+          const inst = effectInstancesRef.current.get(instanceId);
+          return (inst == null ? void 0 : inst.kind) === "wam" ? inst.plugin : void 0;
+        },
+        rawContext
+      );
+      connectOfflineChain(masterGainNode, instances, destination);
+      return dispose;
+    });
   }, [activeEffects]);
   return {
     activeEffects,
     availableEffects: effectDefinitions,
     addEffect,
+    addWamEffect,
+    getWamPlugin,
     removeEffect,
     updateParameter,
     toggleBypass,
@@ -1142,11 +1304,14 @@ function useDynamicEffects(fftSize = 256) {
 
 // src/hooks/useTrackDynamicEffects.ts
 import { useState as useState3, useCallback as useCallback3, useRef as useRef4, useEffect as useEffect3 } from "react";
+import { isNativeGlobalContext as isNativeGlobalContext2, getGlobalAudioContext as getGlobalAudioContext2 } from "@waveform-playlist/playout";
+import { connect as connect5 } from "tone";
 function useTrackDynamicEffects() {
   const [trackEffectsState, setTrackEffectsState] = useState3(
     /* @__PURE__ */ new Map()
   );
   const trackEffectInstancesRef = useRef4(/* @__PURE__ */ new Map());
+  const isMountedRef = useRef4(true);
   const trackGraphNodesRef = useRef4(/* @__PURE__ */ new Map());
   const rebuildTrackChain = useCallback3((trackId, trackEffects) => {
     const nodes = trackGraphNodesRef.current.get(trackId);
@@ -1158,7 +1323,8 @@ function useTrackDynamicEffects() {
     } 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);
+    const audible = trackEffects.filter((ae) => !(ae.kind === "wam" && ae.bypassed));
+    const instances = audible.map((ae) => instancesMap == null ? void 0 : instancesMap.get(ae.instanceId)).filter((inst) => inst !== void 0);
     if (instances.length === 0) {
       graphEnd.connect(masterGainNode);
     } else {
@@ -1172,10 +1338,10 @@ function useTrackDynamicEffects() {
             e
           );
         }
-        currentNode.connect(inst.effect);
+        connect5(currentNode, inst.effect);
         currentNode = inst.effect;
       });
-      currentNode.connect(masterGainNode);
+      connect5(currentNode, masterGainNode);
     }
   }, []);
   const addEffectToTrack = useCallback3((trackId, effectId) => {
@@ -1196,6 +1362,7 @@ function useTrackDynamicEffects() {
     const newActiveEffect = {
       instanceId: instance.instanceId,
       effectId: definition.id,
+      kind: "native",
       definition,
       params,
       bypassed: false
@@ -1207,6 +1374,76 @@ function useTrackDynamicEffects() {
       return newState;
     });
   }, []);
+  const addWamEffectToTrack = useCallback3(
+    (trackId, url, initialState) => __async(null, null, function* () {
+      var _a, _b;
+      if (!isNativeGlobalContext2()) {
+        throw new Error(
+          "[waveform-playlist] WAM plugins require a native AudioContext. Call configureGlobalContext({ nativeAudioContext: true }) from @waveform-playlist/playout before any audio initialization."
+        );
+      }
+      const wam = yield loadWamModule();
+      const ctx = getGlobalAudioContext2();
+      const { hostGroupId } = yield wam.ensureWamHost(ctx);
+      const plugin = yield wam.createWamInstance(
+        url,
+        ctx,
+        hostGroupId,
+        initialState !== void 0 ? { initialState } : void 0
+      );
+      if (!isMountedRef.current) {
+        try {
+          plugin.destroy();
+        } catch (err) {
+          console.warn(
+            "[waveform-playlist] Error destroying WAM plugin after unmount: " + (err instanceof Error ? err.message : String(err))
+          );
+        }
+        throw new Error(
+          "[waveform-playlist] addWamEffectToTrack aborted: hook unmounted before the plugin finished loading."
+        );
+      }
+      const instance = createWamEffectInstance(plugin);
+      if (!trackEffectInstancesRef.current.has(trackId)) {
+        trackEffectInstancesRef.current.set(trackId, /* @__PURE__ */ new Map());
+      }
+      trackEffectInstancesRef.current.get(trackId).set(instance.instanceId, instance);
+      const definition = {
+        id: instance.id,
+        name: (_b = (_a = plugin.descriptor) == null ? void 0 : _a.name) != null ? _b : url,
+        category: "wam",
+        description: "WAM plugin",
+        parameters: []
+      };
+      setTrackEffectsState((prev) => {
+        const newState = new Map(prev);
+        const existing = newState.get(trackId) || [];
+        newState.set(trackId, [
+          ...existing,
+          {
+            instanceId: instance.instanceId,
+            effectId: instance.id,
+            kind: "wam",
+            url,
+            definition,
+            params: {},
+            bypassed: false
+          }
+        ]);
+        return newState;
+      });
+      return instance.instanceId;
+    }),
+    []
+  );
+  const getTrackWamPlugin = useCallback3(
+    (trackId, instanceId) => {
+      const instancesMap = trackEffectInstancesRef.current.get(trackId);
+      const inst = instancesMap == null ? void 0 : instancesMap.get(instanceId);
+      return (inst == null ? void 0 : inst.kind) === "wam" ? inst.plugin : void 0;
+    },
+    []
+  );
   const removeEffectFromTrack = useCallback3((trackId, instanceId) => {
     const instancesMap = trackEffectInstancesRef.current.get(trackId);
     const instance = instancesMap == null ? void 0 : instancesMap.get(instanceId);
@@ -1251,6 +1488,18 @@ function useTrackDynamicEffects() {
     const effect = trackEffects.find((e) => e.instanceId === instanceId);
     if (!effect) return;
     const newBypassed = !effect.bypassed;
+    if (effect.kind === "wam") {
+      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;
+      });
+      return;
+    }
     const instancesMap = trackEffectInstancesRef.current.get(trackId);
     const instance = instancesMap == null ? void 0 : instancesMap.get(instanceId);
     if (instance) {
@@ -1290,16 +1539,17 @@ function useTrackDynamicEffects() {
         });
         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);
+        const audible = trackEffects.filter((ae) => !(ae.kind === "wam" && ae.bypassed));
+        const instances = audible.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);
+            connect5(currentNode, inst.effect);
             currentNode = inst.effect;
           });
-          currentNode.connect(masterGainNode);
+          connect5(currentNode, masterGainNode);
         }
         return function cleanup() {
           trackGraphNodesRef.current.delete(trackId);
@@ -1315,8 +1565,10 @@ function useTrackDynamicEffects() {
     });
   }, [trackEffectsState, rebuildTrackChain]);
   useEffect3(() => {
+    isMountedRef.current = true;
     const trackEffectInstances = trackEffectInstancesRef.current;
     return () => {
+      isMountedRef.current = false;
       trackEffectInstances.forEach((instancesMap) => {
         instancesMap.forEach((inst) => inst.dispose());
         instancesMap.clear();
@@ -1327,36 +1579,38 @@ function useTrackDynamicEffects() {
   const createOfflineTrackEffectsFunction = useCallback3(
     (trackId) => {
       const trackEffects = trackEffectsState.get(trackId) || [];
-      const nonBypassedEffects = trackEffects.filter((e) => !e.bypassed);
-      if (nonBypassedEffects.length === 0) {
+      const nonBypassed = trackEffects.filter((e) => !e.bypassed);
+      if (nonBypassed.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);
+      const hasWam = nonBypassed.some((e) => e.kind === "wam");
+      return (graphEnd, masterGainNode, _isOffline) => __async(null, null, function* () {
+        if (hasWam && !isNativeGlobalContext2()) {
+          throw new Error(
+            "[waveform-playlist] WAV export with WAM effects requires a native AudioContext. Call configureGlobalContext({ nativeAudioContext: true }) from @waveform-playlist/playout before any audio initialization."
+          );
         }
-        return function cleanup() {
-          offlineInstances.forEach((inst) => inst.dispose());
-        };
-      };
+        const rawContext = graphEnd.context.rawContext;
+        const { instances, dispose } = yield buildOfflineChain(
+          nonBypassed,
+          (instanceId) => {
+            var _a;
+            const inst = (_a = trackEffectInstancesRef.current.get(trackId)) == null ? void 0 : _a.get(instanceId);
+            return (inst == null ? void 0 : inst.kind) === "wam" ? inst.plugin : void 0;
+          },
+          rawContext
+        );
+        connectOfflineChain(graphEnd, instances, masterGainNode);
+        return dispose;
+      });
     },
     [trackEffectsState]
   );
   return {
     trackEffectsState,
     addEffectToTrack,
+    addWamEffectToTrack,
+    getTrackWamPlugin,
     removeEffectFromTrack,
     updateTrackEffectParameter,
     toggleBypass,
@@ -1375,10 +1629,45 @@ import {
   applyFadeIn,
   applyFadeOut
 } from "@waveform-playlist/core";
-import {
-  getUnderlyingAudioParam,
-  getGlobalAudioContext
-} from "@waveform-playlist/playout";
+import { getUnderlyingAudioParam, getGlobalAudioContext as getGlobalAudioContext3 } from "@waveform-playlist/playout";
+
+// src/utils/renderToneOffline.ts
+import { getContext as getContext2, setContext, OfflineContext } from "tone";
+import { isNativeGlobalContext as isNativeGlobalContext3 } from "@waveform-playlist/playout";
+var renderQueue = Promise.resolve();
+function renderToneOffline(build, duration, channels, sampleRate) {
+  return __async(this, null, function* () {
+    const run = renderQueue.then(
+      () => renderToneOfflineSerial(build, duration, channels, sampleRate)
+    );
+    renderQueue = run.catch(() => void 0);
+    return run;
+  });
+}
+function renderToneOfflineSerial(build, duration, channels, sampleRate) {
+  return __async(this, null, function* () {
+    const offlineContext = isNativeGlobalContext3() ? new OfflineContext(
+      new OfflineAudioContext({
+        numberOfChannels: channels,
+        length: Math.round(duration * sampleRate),
+        sampleRate
+      })
+    ) : new OfflineContext(channels, duration, sampleRate);
+    const previousContext = getContext2();
+    setContext(offlineContext);
+    try {
+      yield build(offlineContext);
+    } finally {
+      setContext(previousContext);
+    }
+    const toneBuffer = yield offlineContext.render();
+    const audioBuffer = toneBuffer.get();
+    if (!audioBuffer) {
+      throw new Error("Offline rendering produced no audio buffer");
+    }
+    return audioBuffer;
+  });
+}
 
 // src/utils/wavEncoder.ts
 function encodeWav(audioBuffer, options = {}) {
@@ -1477,7 +1766,7 @@ function useExportWav() {
         if (mode === "individual" && (trackIndex === void 0 || trackIndex < 0 || trackIndex >= tracks.length)) {
           throw new Error("Invalid track index for individual export");
         }
-        const sampleRate = getGlobalAudioContext().sampleRate;
+        const sampleRate = getGlobalAudioContext3().sampleRate;
         let totalDurationSamples = 0;
         for (const track of tracks) {
           for (const clip of track.clips) {
@@ -1534,7 +1823,7 @@ function useExportWav() {
 }
 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");
+    const { Volume: Volume2, Gain: Gain2, Panner, Player, ToneAudioBuffer } = yield import("tone");
     onProgress(0.1);
     const audibleTracks = tracksToRender.filter(({ state }) => {
       if (state.muted && !state.soloed) return false;
@@ -1545,23 +1834,25 @@ function renderOffline(tracksToRender, hasSolo, duration, sampleRate, applyEffec
       (max, { track }) => Math.max(max, trackChannelCount(track)),
       1
     );
-    let buffer;
+    const cleanups = [];
     try {
-      buffer = yield Offline(
-        (_0) => __async(null, [_0], function* ({ transport, destination }) {
+      const audioBuffer = yield renderToneOffline(
+        (context) => __async(null, null, function* () {
           const masterVolume = new Volume2(0);
           if (effectsFunction && applyEffects) {
-            effectsFunction(masterVolume, destination, true);
+            const cleanup = yield effectsFunction(masterVolume, context.destination, true);
+            if (cleanup) cleanups.push(cleanup);
           } else {
-            masterVolume.connect(destination);
+            masterVolume.connect(context.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 trackMute = new Gain2(state.muted ? 0 : 1);
             const trackEffects = createOfflineTrackEffects == null ? void 0 : createOfflineTrackEffects(track.id);
             if (trackEffects && applyEffects) {
-              trackEffects(trackMute, masterVolume, true);
+              const cleanup = yield trackEffects(trackMute, masterVolume, true);
+              if (cleanup) cleanups.push(cleanup);
             } else {
               trackMute.connect(masterVolume);
             }
@@ -1569,7 +1860,7 @@ function renderOffline(tracksToRender, hasSolo, duration, sampleRate, applyEffec
             trackVolume.connect(trackPan);
             for (const clip of track.clips) {
               const {
-                audioBuffer,
+                audioBuffer: clipBuffer,
                 startSample,
                 durationSamples,
                 offsetSamples,
@@ -1577,7 +1868,7 @@ function renderOffline(tracksToRender, hasSolo, duration, sampleRate, applyEffec
                 fadeIn,
                 fadeOut
               } = clip;
-              if (!audioBuffer) {
+              if (!clipBuffer) {
                 console.warn(
                   '[waveform-playlist] Skipping clip "' + (clip.name || clip.id) + '" - no audioBuffer for export'
                 );
@@ -1586,9 +1877,9 @@ function renderOffline(tracksToRender, hasSolo, duration, sampleRate, applyEffec
               const startTime = startSample / sampleRate;
               const clipDuration = durationSamples / sampleRate;
               const offset = offsetSamples / sampleRate;
-              const toneBuffer = new ToneAudioBuffer(audioBuffer);
+              const toneBuffer = new ToneAudioBuffer(clipBuffer);
               const player = new Player(toneBuffer);
-              const fadeGain = new Gain(clipGain);
+              const fadeGain = new Gain2(clipGain);
               player.connect(fadeGain);
               fadeGain.connect(trackVolume);
               if (applyEffects) {
@@ -1604,25 +1895,29 @@ function renderOffline(tracksToRender, hasSolo, duration, sampleRate, applyEffec
               player.start(startTime, offset, clipDuration);
             }
           }
-          transport.start(0);
+          context.transport.start(0);
         }),
         duration,
         outputChannels,
         sampleRate
       );
+      return audioBuffer;
     } catch (err) {
       if (err instanceof Error) {
         throw err;
-      } else {
-        throw new Error("Tone.Offline rendering failed: " + String(err));
+      }
+      throw new Error("Offline rendering failed: " + String(err));
+    } finally {
+      for (const cleanup of cleanups) {
+        try {
+          cleanup();
+        } catch (err) {
+          console.warn(
+            "[waveform-playlist] Export cleanup error: " + (err instanceof Error ? err.message : 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) {
@@ -1646,7 +1941,7 @@ function applyClipFades(gainParam, clipGain, startTime, clipDuration, fadeIn, fa
 // 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";
+import { getGlobalAudioContext as getGlobalAudioContext4 } from "@waveform-playlist/playout";
 function getSourceName(source) {
   var _a, _b, _c, _d, _e;
   if (source instanceof File) {
@@ -1697,7 +1992,7 @@ function useDynamicTracks() {
   }, []);
   const addTracks = useCallback5((sources) => {
     if (sources.length === 0) return;
-    const audioContext = getGlobalAudioContext2();
+    const audioContext = getGlobalAudioContext4();
     const placeholders = sources.map((source) => ({
       track: createTrack2({ name: `${getSourceName(source)} (loading...)`, clips: [] }),
       source
@@ -1939,14 +2234,77 @@ var ExportWavButton = ({
     }
   );
 };
+
+// src/components/WamEffectGui.tsx
+import { useEffect as useEffect7, useRef as useRef8 } from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var WamEffectGui = ({ plugin, className }) => {
+  const hostRef = useRef8(null);
+  useEffect7(() => {
+    const host = hostRef.current;
+    if (!plugin || !host) return;
+    let cancelled = false;
+    let gui = null;
+    (() => __async(null, null, function* () {
+      var _a;
+      try {
+        if (plugin.createGui) {
+          gui = yield plugin.createGui();
+        } else {
+          const wam = yield loadWamModule();
+          gui = yield wam.createWamParameterPanel(
+            plugin.audioNode
+          );
+        }
+        if (cancelled) {
+          if (gui) {
+            try {
+              (_a = plugin.destroyGui) == null ? void 0 : _a.call(plugin, gui);
+            } catch (destroyErr) {
+              console.warn(
+                "[waveform-playlist] Error destroying WAM GUI: " + (destroyErr instanceof Error ? destroyErr.message : String(destroyErr))
+              );
+            }
+          }
+          gui = null;
+          return;
+        }
+        host.innerHTML = "";
+        host.appendChild(gui);
+      } catch (err) {
+        console.warn(
+          "[waveform-playlist] Failed to create WAM GUI: " + (err instanceof Error ? err.message : String(err))
+        );
+      }
+    }))();
+    return () => {
+      var _a;
+      cancelled = true;
+      if (gui) {
+        gui.remove();
+        try {
+          (_a = plugin.destroyGui) == null ? void 0 : _a.call(plugin, gui);
+        } catch (destroyErr) {
+          console.warn(
+            "[waveform-playlist] Error destroying WAM GUI: " + (destroyErr instanceof Error ? destroyErr.message : String(destroyErr))
+          );
+        }
+      }
+    };
+  }, [plugin]);
+  return /* @__PURE__ */ jsx3("div", { ref: hostRef, className: className != null ? className : "wam-effect-gui" });
+};
 export {
   ExportWavButton,
+  WamEffectGui,
   createEffectChain,
   createEffectInstance,
+  createWamEffectInstance,
   effectCategories,
   effectDefinitions,
   getEffectDefinition,
   getEffectsByCategory,
+  loadWamModule,
   useAudioTracks,
   useDynamicEffects,
   useDynamicTracks,