@dawcore/components 0.0.23 → 0.0.24

package/dist/index.mjs

@@ -201,6 +201,68 @@ var DawTrackElement = class extends LitElement2 {
   createRenderRoot() {
     return this;
   }
+  // --- Effects API (delegates to the owning <daw-editor>) ---
+  addEffect(type, params) {
+    return this._effectsEditor()._trackAddEffect(this.trackId, this, type, params);
+  }
+  /** Load a WAM plugin (via the optional @dawcore/wam peer) into this track's chain. */
+  addWamPlugin(url, initialState) {
+    return this._effectsEditor()._trackAddWamPlugin(this.trackId, this, url, initialState);
+  }
+  /**
+   * Compile Faust DSP source in the browser (via the optional @dawcore/faust
+   * peer) and add the resulting WAM to this track's chain. Compile errors
+   * keep their Faust line/column diagnostics and leave the chain untouched.
+   */
+  addFaustEffect(dspCode, options) {
+    return this._effectsEditor()._trackAddFaustEffect(this.trackId, this, dspCode, options);
+  }
+  /** Snapshot this track's chain in its persisted form (see dawcore README). */
+  getEffectsState() {
+    const editor = this.closest("daw-editor");
+    return editor?._trackGetEffectsState(this.trackId) ?? Promise.resolve([]);
+  }
+  /** Replace this track's chain with a persisted snapshot. */
+  setEffectsState(entries) {
+    return this._effectsEditor()._trackSetEffectsState(this.trackId, this, entries);
+  }
+  /**
+   * Open (lazily creating) the GUI for one of this track's effects into a
+   * consumer-provided container. Closing hides without interrupting audio;
+   * the element is cached for reopen. See <daw-editor>.openEffectGui.
+   */
+  openEffectGui(effectId, container) {
+    return this._effectsEditor()._trackOpenEffectGui(this.trackId, this, effectId, container);
+  }
+  /** Hide an effect's GUI (cached for reopen — never destroys). */
+  closeEffectGui(effectId) {
+    this._effectsEditor()._trackCloseEffectGui(this.trackId, effectId);
+  }
+  removeEffect(effectId) {
+    this._effectsEditor()._trackEffectOp(this.trackId, this, "remove", effectId);
+  }
+  setEffectParams(effectId, params) {
+    this._effectsEditor()._trackEffectOp(this.trackId, this, "setParams", effectId, params);
+  }
+  setEffectBypassed(effectId, bypassed) {
+    this._effectsEditor()._trackEffectOp(this.trackId, this, "setBypassed", effectId, bypassed);
+  }
+  moveEffect(effectId, newIndex) {
+    this._effectsEditor()._trackEffectOp(this.trackId, this, "move", effectId, newIndex);
+  }
+  get effects() {
+    const editor = this.closest("daw-editor");
+    return editor?._trackEffects(this.trackId) ?? [];
+  }
+  _effectsEditor() {
+    const editor = this.closest("daw-editor");
+    if (!editor) {
+      throw new Error(
+        "[waveform-playlist] <daw-track> effects API requires the track to be inside a <daw-editor>"
+      );
+    }
+    return editor;
+  }
   connectedCallback() {
     super.connectedCallback();
     setTimeout(() => {
@@ -1386,7 +1448,7 @@ function createPeaksWorker() {
   }
   const pending = /* @__PURE__ */ new Map();
   let terminated = false;
-  let idCounter = 0;
+  let idCounter2 = 0;
   worker.onmessage = (e) => {
     const msg = e.data;
     const entry = pending.get(msg.id);
@@ -1419,7 +1481,7 @@ function createPeaksWorker() {
   return {
     generate(params) {
       if (terminated) return Promise.reject(new Error("Worker terminated"));
-      const messageId = String(++idCounter);
+      const messageId = String(++idCounter2);
       return new Promise((resolve, reject) => {
         pending.set(messageId, { resolve, reject });
         worker.postMessage(
@@ -4096,6 +4158,1088 @@ function findAudioBufferForClip(host, clip, track) {
   return null;
 }
 
+// src/effects/effects-chain-controller.ts
+var idCounter = 0;
+var EffectsChainController = class {
+  constructor(audioContext) {
+    this._entries = [];
+    this._disposed = false;
+    this._input = audioContext.createGain();
+    this._output = audioContext.createGain();
+    this._input.connect(this._output);
+  }
+  /** Connect the upstream source (track mute node, master gain) into this. */
+  get input() {
+    return this._input;
+  }
+  /** Route this onward (to the master bus / destination). */
+  get output() {
+    return this._output;
+  }
+  get entries() {
+    return this._entries.map((entry) => ({
+      id: entry.id,
+      kind: entry.kind,
+      type: entry.type,
+      params: { ...entry.params },
+      bypassed: entry.bypassed,
+      ...entry.url !== void 0 ? { url: entry.url } : {},
+      ...entry.source !== void 0 ? { source: { ...entry.source } } : {},
+      ...entry.label !== void 0 ? { label: entry.label } : {},
+      ...entry.error !== void 0 ? { error: entry.error } : {}
+    }));
+  }
+  /** Snapshot the chain in its persisted form. WAM entries are asked for
+   *  their live state; placeholders re-emit the state they were saved with. */
+  serialize() {
+    return Promise.all(
+      this._entries.map(async (entry) => {
+        if (entry.kind === "wam") {
+          const sourceFields = entry.source?.faust !== void 0 ? {
+            faustDsp: entry.source.faust,
+            ...entry.label !== void 0 ? { faustName: entry.label } : {}
+          } : { url: entry.url ?? "" };
+          if (entry.placeholder) {
+            return {
+              kind: "wam",
+              ...sourceFields,
+              bypassed: entry.placeholder.bypassed,
+              ...entry.placeholder.state !== void 0 ? { state: entry.placeholder.state } : {}
+            };
+          }
+          let state5;
+          try {
+            state5 = await entry.instance.getState?.();
+          } catch (err) {
+            console.warn(
+              '[waveform-playlist] serialize: plugin "' + (entry.url ?? entry.label ?? entry.type) + '" getState failed: ' + String(err)
+            );
+          }
+          return {
+            kind: "wam",
+            ...sourceFields,
+            bypassed: entry.bypassed,
+            ...state5 !== void 0 ? { state: state5 } : {}
+          };
+        }
+        return {
+          kind: "native",
+          type: entry.type,
+          params: { ...entry.params },
+          bypassed: entry.bypassed
+        };
+      })
+    );
+  }
+  get disposed() {
+    return this._disposed;
+  }
+  /** Internal (manager-facing): the live entry — including its instance —
+   *  for GUI wiring. Returns undefined (no warning) when the id is unknown. */
+  getEntry(effectId) {
+    return this._entries.find((e) => e.id === effectId);
+  }
+  add(item, index) {
+    if (this._disposed) {
+      throw new Error(
+        "[waveform-playlist] EffectsChainController.add: chain is disposed \u2014 entries cannot be added"
+      );
+    }
+    const id = "effect-" + ++idCounter;
+    const entry = { ...item, params: { ...item.params }, id, bypassed: false };
+    const at = index === void 0 ? this._entries.length : Math.max(0, Math.min(index, this._entries.length));
+    this._entries = [...this._entries.slice(0, at), entry, ...this._entries.slice(at)];
+    this._rebuild();
+    return id;
+  }
+  remove(effectId) {
+    const entry = this._find("remove", effectId);
+    if (!entry) return;
+    this._entries = this._entries.filter((e) => e.id !== effectId);
+    entry.instance.output.disconnect();
+    entry.instance.dispose?.();
+    this._rebuild();
+  }
+  move(effectId, newIndex) {
+    const entry = this._find("move", effectId);
+    if (!entry) return;
+    const without = this._entries.filter((e) => e.id !== effectId);
+    const at = Math.max(0, Math.min(newIndex, without.length));
+    this._entries = [...without.slice(0, at), entry, ...without.slice(at)];
+    this._rebuild();
+  }
+  setParams(effectId, params) {
+    const entry = this._find("setParams", effectId);
+    if (!entry) return;
+    entry.params = { ...entry.params, ...params };
+    if (entry.bypassed && entry.wetParam && entry.wetParam in params) {
+      const { [entry.wetParam]: _stored, ...rest } = params;
+      if (Object.keys(rest).length > 0) {
+        entry.instance.applyParams(rest);
+      }
+      return;
+    }
+    entry.instance.applyParams(params);
+  }
+  setBypassed(effectId, bypassed) {
+    const entry = this._find("setBypassed", effectId);
+    if (!entry || entry.bypassed === bypassed) return;
+    entry.bypassed = bypassed;
+    if (entry.wetParam) {
+      const wet = bypassed ? 0 : entry.params[entry.wetParam] ?? 0;
+      entry.instance.applyParams({ [entry.wetParam]: wet });
+      return;
+    }
+    this._rebuild();
+  }
+  dispose() {
+    if (this._disposed) return;
+    this._disposed = true;
+    this._severOwnEdges();
+    for (const entry of this._entries) {
+      entry.instance.dispose?.();
+    }
+    this._entries = [];
+    try {
+      this._output.disconnect();
+    } catch {
+    }
+  }
+  _find(op, effectId) {
+    const entry = this._entries.find((e) => e.id === effectId);
+    if (!entry) {
+      console.warn(
+        "[waveform-playlist] EffectsChainController." + op + ': unknown effectId "' + effectId + '"'
+      );
+    }
+    return entry;
+  }
+  /** Sever only this chain's outgoing edges — never the consumer's. */
+  _severOwnEdges() {
+    this._input.disconnect();
+    for (const entry of this._entries) {
+      entry.instance.output.disconnect();
+    }
+  }
+  _rebuild() {
+    this._severOwnEdges();
+    let previous = this._input;
+    for (const entry of this._entries) {
+      if (entry.bypassed && !entry.wetParam) {
+        continue;
+      }
+      previous.connect(entry.instance.input);
+      previous = entry.instance.output;
+    }
+    previous.connect(this._output);
+  }
+};
+
+// src/effects/optional-modules.ts
+var PREFIX = "[waveform-playlist] ";
+async function loadOptionalModule(importer, packageName, feature) {
+  try {
+    return await importer();
+  } catch (originalErr) {
+    console.warn(PREFIX + packageName + " dynamic import failed: " + String(originalErr));
+    throw new Error(
+      PREFIX + packageName + " is required for " + feature + ". Install with: npm install " + packageName + " (import failed: " + String(originalErr) + ")"
+    );
+  }
+}
+function loadWamModule(feature) {
+  return loadOptionalModule(() => import("@dawcore/wam"), "@dawcore/wam", feature);
+}
+function loadFaustModule(feature) {
+  return loadOptionalModule(() => import("@dawcore/faust"), "@dawcore/faust", feature);
+}
+
+// src/effects/effect-registry.ts
+var MAX_DELAY_SECONDS = 10;
+var registry = /* @__PURE__ */ new Map();
+function registerEffect(type, definition) {
+  if (registry.has(type)) {
+    console.warn(
+      '[waveform-playlist] registerEffect: overwriting existing effect type "' + type + '"'
+    );
+  }
+  registry.set(type, definition);
+}
+function getEffectDefinitions() {
+  return new Map(registry);
+}
+function createEffectInstance(type, audioContext, params = {}) {
+  const definition = registry.get(type);
+  if (!definition) {
+    throw new Error(
+      '[waveform-playlist] createEffectInstance: unknown effect type "' + type + '". Available types: ' + [...registry.keys()].join(", ")
+    );
+  }
+  const merged = { ...definition.defaults, ...params };
+  const instance = definition.create(audioContext, merged);
+  instance.applyParams(merged);
+  return { instance, params: merged, wetParam: definition.wetParam };
+}
+function singleNode(node, applyParams) {
+  return { input: node, output: node, applyParams };
+}
+function registerBuiltIns() {
+  registry.set("native-gain", {
+    label: "Gain",
+    category: "dynamics",
+    defaults: { gain: 1 },
+    params: { gain: { min: 0, max: 2, step: 0.01 } },
+    create: (ctx) => {
+      const node = ctx.createGain();
+      return singleNode(node, (p) => {
+        if (p.gain !== void 0) node.gain.value = p.gain;
+      });
+    }
+  });
+  registry.set("native-filter", {
+    label: "Lowpass Filter",
+    category: "filter",
+    defaults: { frequency: 1e3, q: 1 },
+    params: {
+      frequency: { min: 20, max: 2e4, step: 1, unit: "Hz" },
+      q: { min: 0.1, max: 20, step: 0.1 }
+    },
+    create: (ctx) => {
+      const node = ctx.createBiquadFilter();
+      node.type = "lowpass";
+      return singleNode(node, (p) => {
+        if (p.frequency !== void 0) node.frequency.value = p.frequency;
+        if (p.q !== void 0) node.Q.value = p.q;
+      });
+    }
+  });
+  registry.set("native-compressor", {
+    label: "Compressor",
+    category: "dynamics",
+    defaults: { threshold: -24, knee: 30, ratio: 12, attack: 3e-3, release: 0.25 },
+    params: {
+      threshold: { min: -60, max: 0, step: 1, unit: "dB" },
+      knee: { min: 0, max: 40, step: 1, unit: "dB" },
+      ratio: { min: 1, max: 20, step: 0.5 },
+      attack: { min: 0, max: 1, step: 1e-3, unit: "s" },
+      release: { min: 0, max: 1, step: 0.01, unit: "s" }
+    },
+    create: (ctx) => {
+      const node = ctx.createDynamicsCompressor();
+      return singleNode(node, (p) => {
+        if (p.threshold !== void 0) node.threshold.value = p.threshold;
+        if (p.knee !== void 0) node.knee.value = p.knee;
+        if (p.ratio !== void 0) node.ratio.value = p.ratio;
+        if (p.attack !== void 0) node.attack.value = p.attack;
+        if (p.release !== void 0) node.release.value = p.release;
+      });
+    }
+  });
+  registry.set("native-stereo-panner", {
+    label: "Stereo Panner",
+    category: "spatial",
+    defaults: { pan: 0 },
+    params: { pan: { min: -1, max: 1, step: 0.01 } },
+    create: (ctx) => {
+      const node = ctx.createStereoPanner();
+      return singleNode(node, (p) => {
+        if (p.pan !== void 0) node.pan.value = p.pan;
+      });
+    }
+  });
+  registry.set("native-delay", {
+    label: "Delay",
+    category: "delay",
+    defaults: { delayTime: 0.25, feedback: 0.4, wet: 0.35 },
+    params: {
+      delayTime: { min: 0, max: MAX_DELAY_SECONDS, step: 0.01, unit: "s" },
+      feedback: { min: 0, max: 0.95, step: 0.01 },
+      wet: { min: 0, max: 1, step: 0.01 }
+    },
+    wetParam: "wet",
+    create: (ctx) => {
+      const input = ctx.createGain();
+      const output = ctx.createGain();
+      const delay = ctx.createDelay(MAX_DELAY_SECONDS);
+      const feedback = ctx.createGain();
+      const wet = ctx.createGain();
+      const dry = ctx.createGain();
+      input.connect(dry);
+      dry.connect(output);
+      input.connect(delay);
+      delay.connect(feedback);
+      feedback.connect(delay);
+      delay.connect(wet);
+      wet.connect(output);
+      return {
+        input,
+        output,
+        applyParams: (p) => {
+          if (p.delayTime !== void 0) delay.delayTime.value = p.delayTime;
+          if (p.feedback !== void 0) feedback.gain.value = p.feedback;
+          if (p.wet !== void 0) {
+            wet.gain.value = p.wet;
+            dry.gain.value = 1 - p.wet;
+          }
+        }
+      };
+    }
+  });
+}
+registerBuiltIns();
+
+// src/effects/effects-manager.ts
+var PREFIX2 = "[waveform-playlist] ";
+function makeGuiRecord(element, destroyImpl) {
+  let destroyed = false;
+  return {
+    element,
+    destroy: () => {
+      if (destroyed) return;
+      destroyed = true;
+      destroyImpl();
+    }
+  };
+}
+var EffectsManager = class {
+  constructor(getAdapter, masterEventTarget) {
+    this._masterChain = null;
+    this._trackChains = /* @__PURE__ */ new Map();
+    /** Per-chain restore ownership — a newer setEffectsState supersedes a stale in-flight one. */
+    this._restoreTokens = /* @__PURE__ */ new WeakMap();
+    /** Cached GUI elements by effectId — close hides, only removal destroys. */
+    this._guis = /* @__PURE__ */ new Map();
+    /** In-flight GUI creation by effectId — concurrent opens share one build. */
+    this._guiPending = /* @__PURE__ */ new Map();
+    /** Live WAM plugin nodes across all chains, fed to the wam-transport bridge. */
+    this._wamNodes = /* @__PURE__ */ new Set();
+    this._transportBridge = null;
+    this._getAdapter = getAdapter;
+    this._masterTarget = masterEventTarget;
+  }
+  // --- Master chain ---
+  addMasterEffect(type, params) {
+    const chain = this._ensureMasterChain();
+    return this._addToChain(chain, this._masterTarget, type, params);
+  }
+  masterEffects() {
+    return this._masterChain?.entries ?? [];
+  }
+  masterOp(op, effectId, arg) {
+    this._runOp(this._masterChain, this._masterTarget, op, effectId, arg);
+  }
+  addMasterWamPlugin(url, initialState) {
+    const chain = this._ensureMasterChain();
+    return this._addWamToChain(chain, this._masterTarget, url, initialState);
+  }
+  addMasterFaustEffect(dspCode, options) {
+    const chain = this._ensureMasterChain();
+    return this._addFaustToChain(chain, this._masterTarget, dspCode, { name: options?.name });
+  }
+  getMasterEffectsState() {
+    return this._masterChain?.serialize() ?? Promise.resolve([]);
+  }
+  async setMasterEffectsState(entries) {
+    validateSerializedEntries(entries);
+    await this._restoreChain(this._ensureMasterChain(), this._masterTarget, entries);
+  }
+  // --- Track chains ---
+  addTrackEffect(trackId, target, type, params) {
+    const chain = this._ensureTrackChain(trackId);
+    return this._addToChain(chain, target, type, params);
+  }
+  addTrackWamPlugin(trackId, target, url, initialState) {
+    const chain = this._ensureTrackChain(trackId);
+    return this._addWamToChain(chain, target, url, initialState);
+  }
+  addTrackFaustEffect(trackId, target, dspCode, options) {
+    const chain = this._ensureTrackChain(trackId);
+    return this._addFaustToChain(chain, target, dspCode, { name: options?.name });
+  }
+  trackEffects(trackId) {
+    return this._trackChains.get(trackId)?.entries ?? [];
+  }
+  getTrackEffectsState(trackId) {
+    return this._trackChains.get(trackId)?.serialize() ?? Promise.resolve([]);
+  }
+  async setTrackEffectsState(trackId, target, entries) {
+    validateSerializedEntries(entries);
+    await this._restoreChain(this._ensureTrackChain(trackId), target, entries);
+  }
+  trackOp(trackId, target, op, effectId, arg) {
+    this._runOp(this._trackChains.get(trackId) ?? null, target, op, effectId, arg);
+  }
+  // --- Effect GUIs ---
+  /** Open (lazily creating) the GUI for a master-chain effect. */
+  openMasterEffectGui(effectId, container) {
+    return this._openGui(this._masterChain, this._masterTarget, effectId, container);
+  }
+  /** Open (lazily creating) the GUI for a track-chain effect. */
+  openTrackEffectGui(trackId, target, effectId, container) {
+    return this._openGui(this._trackChains.get(trackId) ?? null, target, effectId, container);
+  }
+  /** Hide an open GUI. The element stays cached so reopen is instant —
+   *  audio processing is never interrupted. */
+  closeEffectGui(effectId) {
+    const record = this._guis.get(effectId);
+    if (!record) {
+      console.warn(PREFIX2 + 'closeEffectGui: no open GUI for effectId "' + effectId + '"');
+      return;
+    }
+    record.element.remove();
+  }
+  // --- Lifecycle ---
+  /** Transport setTracks rebuilds TrackNodes, severing chain hookups — re-wire. */
+  rewireTrackChains() {
+    const transport = this._getAdapter()?.transport;
+    if (!transport) return;
+    for (const [trackId, chain] of this._trackChains) {
+      transport.connectTrackOutput(trackId, chain.input);
+      chain.output.connect(transport.masterOutputNode);
+    }
+  }
+  disposeTrackChain(trackId) {
+    const chain = this._trackChains.get(trackId);
+    if (!chain) return;
+    this._trackChains.delete(trackId);
+    for (const entry of chain.entries) {
+      this._destroyGui(entry.id);
+    }
+    try {
+      this._getAdapter()?.transport?.disconnectTrackOutput(trackId);
+    } catch (err) {
+      console.warn(PREFIX2 + "EffectsManager: error disconnecting track output: " + String(err));
+    }
+    chain.dispose();
+  }
+  disposeAll() {
+    this._transportBridge?.dispose();
+    this._transportBridge = null;
+    this._wamNodes.clear();
+    for (const trackId of [...this._trackChains.keys()]) {
+      this.disposeTrackChain(trackId);
+    }
+    if (this._masterChain) {
+      for (const entry of this._masterChain.entries) {
+        this._destroyGui(entry.id);
+      }
+      try {
+        this._getAdapter()?.transport?.disconnectMasterOutput();
+      } catch (err) {
+        console.warn(PREFIX2 + "EffectsManager: error disconnecting master output: " + String(err));
+      }
+      this._masterChain.dispose();
+      this._masterChain = null;
+    }
+  }
+  // --- Private ---
+  _requireWiring() {
+    const adapter = this._getAdapter();
+    if (!adapter) {
+      throw new Error(
+        PREFIX2 + "effects require an adapter \u2014 set editor.adapter before adding effects."
+      );
+    }
+    const { audioContext, transport } = adapter;
+    if (!audioContext || !transport || typeof transport.connectTrackOutput !== "function") {
+      throw new Error(
+        PREFIX2 + "the current adapter does not expose effects hooks (transport.connectTrackOutput / connectMasterOutput)."
+      );
+    }
+    return { audioContext, transport };
+  }
+  /** Dynamic-import the optional @dawcore/wam peer with an actionable error. */
+  _loadWamModule(feature) {
+    return loadWamModule(feature);
+  }
+  /** Dynamic-import the optional @dawcore/faust peer with an actionable error. */
+  _loadFaustModule(feature) {
+    return loadFaustModule(feature);
+  }
+  async _openGui(chain, target, effectId, container) {
+    if (!container || typeof container.appendChild !== "function") {
+      throw new Error(PREFIX2 + "openEffectGui: container must be a DOM element");
+    }
+    const entry = chain?.getEntry(effectId);
+    if (!chain || !entry) {
+      throw new Error(PREFIX2 + 'openEffectGui: unknown effectId "' + effectId + '"');
+    }
+    if (entry.error !== void 0) {
+      throw new Error(
+        PREFIX2 + 'openEffectGui: effect "' + effectId + '" is a failed-plugin placeholder (' + entry.error + ") \u2014 no GUI is available. Remove it or retry the restore."
+      );
+    }
+    const cached = this._guis.get(effectId);
+    if (cached) {
+      container.appendChild(cached.element);
+      return cached.element;
+    }
+    let pending = this._guiPending.get(effectId);
+    if (!pending) {
+      pending = this._createGuiRecord(chain, target, entry, effectId).finally(() => {
+        this._guiPending.delete(effectId);
+      });
+      this._guiPending.set(effectId, pending);
+    }
+    const record = await pending;
+    if (chain.disposed || !chain.getEntry(effectId)) {
+      this._guis.delete(effectId);
+      record.element.remove();
+      try {
+        record.destroy();
+      } catch (err) {
+        console.warn(
+          PREFIX2 + 'openEffectGui: destroying a late GUI for "' + effectId + '" failed: ' + String(err)
+        );
+      }
+      throw new Error(
+        PREFIX2 + 'openEffectGui: effect "' + effectId + '" was removed while its GUI was loading; the GUI was discarded.'
+      );
+    }
+    this._guis.set(effectId, record);
+    container.appendChild(record.element);
+    return record.element;
+  }
+  /** Build a GUI record: the plugin's own GUI when available, otherwise the
+   *  generic parameter panel from @dawcore/wam. */
+  async _createGuiRecord(chain, target, entry, effectId) {
+    const { instance } = entry;
+    if (typeof instance.createGui === "function") {
+      try {
+        const element2 = await instance.createGui();
+        return makeGuiRecord(element2, () => instance.destroyGui?.(element2));
+      } catch (err) {
+        console.warn(
+          PREFIX2 + 'openEffectGui: plugin createGui failed for "' + effectId + '" \u2014 falling back to the generic parameter panel: ' + String(err)
+        );
+      }
+    }
+    const element = await this._createFallbackPanel(chain, target, entry, effectId);
+    return makeGuiRecord(element, () => {
+    });
+  }
+  /** The generic parameter panel — one code path for "no custom GUI":
+   *  native entries render from the registry's params metadata, WAM entries
+   *  from getParameterInfo(). Edits route through the regular setParams op so
+   *  they hit the audio (applyParams → setParameterValues for WAM) AND
+   *  dispatch daw-effect-change like any other parameter edit. */
+  async _createFallbackPanel(chain, target, entry, effectId) {
+    const wamModule = await this._loadWamModule("openEffectGui() parameter panels");
+    const onChange = (paramId, value) => {
+      this._runOp(chain, target, "setParams", effectId, { [paramId]: value });
+    };
+    if (entry.kind === "native") {
+      const definition = getEffectDefinitions().get(entry.type);
+      if (!definition) {
+        throw new Error(
+          PREFIX2 + 'openEffectGui: no registry definition for effect type "' + entry.type + '"'
+        );
+      }
+      const params = Object.entries(definition.params).map(([id, def]) => ({
+        id,
+        min: def.min,
+        max: def.max,
+        ...def.step !== void 0 ? { step: def.step } : {},
+        ...def.unit !== void 0 ? { unit: def.unit } : {},
+        value: entry.params[id] ?? definition.defaults[id]
+      }));
+      return wamModule.createParameterPanel(params, onChange);
+    }
+    if (typeof entry.instance.getParameterInfo !== "function") {
+      throw new Error(
+        PREFIX2 + 'openEffectGui: effect "' + effectId + '" has no GUI and exposes no parameter info \u2014 nothing to render.'
+      );
+    }
+    return wamModule.createWamParameterPanel(
+      { getParameterInfo: () => entry.instance.getParameterInfo() },
+      { onParamChange: onChange }
+    );
+  }
+  /** Detach + destroy a cached GUI. Called only from removal paths — close
+   *  never destroys. Safe when no GUI was ever opened. */
+  _destroyGui(effectId) {
+    const record = this._guis.get(effectId);
+    if (!record) return;
+    this._guis.delete(effectId);
+    record.element.remove();
+    try {
+      record.destroy();
+    } catch (err) {
+      console.warn(PREFIX2 + 'destroyGui failed for effect "' + effectId + '": ' + String(err));
+    }
+  }
+  _ensureMasterChain() {
+    if (this._masterChain) return this._masterChain;
+    const { audioContext, transport } = this._requireWiring();
+    const chain = new EffectsChainController(audioContext);
+    transport.connectMasterOutput(chain.input);
+    chain.output.connect(audioContext.destination);
+    this._masterChain = chain;
+    return chain;
+  }
+  _ensureTrackChain(trackId) {
+    const existing = this._trackChains.get(trackId);
+    if (existing) return existing;
+    const { audioContext, transport } = this._requireWiring();
+    const chain = new EffectsChainController(audioContext);
+    transport.connectTrackOutput(trackId, chain.input);
+    chain.output.connect(transport.masterOutputNode);
+    this._trackChains.set(trackId, chain);
+    return chain;
+  }
+  _addToChain(chain, target, type, params) {
+    const audioContext = this._requireWiring().audioContext;
+    const created = createEffectInstance(type, audioContext, params);
+    const effectId = chain.add({
+      kind: "native",
+      type,
+      instance: created.instance,
+      params: created.params,
+      wetParam: created.wetParam
+    });
+    const index = chain.entries.findIndex((e) => e.id === effectId);
+    this._dispatch(target, "daw-effect-add", {
+      effectId,
+      kind: "native",
+      type,
+      params: { ...created.params },
+      index
+    });
+    return effectId;
+  }
+  /**
+   * Load a WAM plugin (via the optional @dawcore/wam peer dep) and add it to
+   * a chain as a kind:'wam' entry. WAM entries participate in every chain
+   * operation with no special-casing: remove destroys the plugin (via the
+   * entry's dispose), bypass uses disconnection semantics (no wet param),
+   * and setParams maps onto the plugin's setParameterValues.
+   */
+  async _addWamToChain(chain, target, url, initialState) {
+    const { audioContext } = this._requireWiring();
+    const wamModule = await this._loadWamModule("addWamPlugin()");
+    const { hostGroupId } = await wamModule.ensureWamHost(audioContext);
+    const plugin = await wamModule.createWamInstance(url, audioContext, hostGroupId, {
+      initialState
+    });
+    return this._insertWamPlugin(chain, target, wamModule, plugin, { url });
+  }
+  /**
+   * Compile Faust DSP source in the browser (via the optional @dawcore/faust
+   * peer) and add the resulting WAM to a chain. Compilation happens BEFORE
+   * any chain work, so a Faust error (with its line/column diagnostics intact)
+   * leaves the chain untouched. The entry lands as kind:'wam' with a
+   * `source: { faust }` marker so persistence recompiles instead of fetching.
+   */
+  async _addFaustToChain(chain, target, dspCode, opts) {
+    if (typeof dspCode !== "string" || dspCode.trim().length === 0) {
+      throw new Error(PREFIX2 + "addFaustEffect: dspCode must be a non-empty string");
+    }
+    this._requireWiring();
+    const faustModule = await this._loadFaustModule("addFaustEffect()");
+    const compiled = await faustModule.compileFaustToWam(dspCode, { name: opts.name });
+    const { audioContext } = this._requireWiring();
+    const wamModule = await this._loadWamModule("addFaustEffect()");
+    const { hostGroupId } = await wamModule.ensureWamHost(audioContext);
+    const plugin = await wamModule.createWamInstanceFromFactory(
+      compiled.factory,
+      audioContext,
+      hostGroupId,
+      { initialState: opts.initialState, label: compiled.name }
+    );
+    return this._insertWamPlugin(chain, target, wamModule, plugin, {
+      source: { faust: compiled.dspCode }
+    });
+  }
+  /**
+   * Wire a live WAM plugin instance into a chain as a kind:'wam' entry —
+   * shared by the url path (addWamPlugin) and the Faust path (addFaustEffect).
+   * WAM entries participate in every chain operation with no special-casing:
+   * remove destroys the plugin (via the entry's dispose), bypass uses
+   * disconnection semantics (no wet param), and setParams maps onto the
+   * plugin's setParameterValues.
+   */
+  _insertWamPlugin(chain, target, wamModule, plugin, meta) {
+    const node = plugin.audioNode;
+    const label = plugin.descriptor.name;
+    if (chain.disposed) {
+      plugin.destroy();
+      throw new Error(
+        PREFIX2 + 'addWamPlugin: the effects chain was disposed while "' + (meta.url ?? label) + '" was loading; the plugin was discarded.'
+      );
+    }
+    let effectId;
+    try {
+      effectId = chain.add({
+        kind: "wam",
+        type: "wam",
+        ...meta.url !== void 0 ? { url: meta.url } : {},
+        ...meta.source !== void 0 ? { source: meta.source } : {},
+        label,
+        instance: {
+          input: node,
+          output: node,
+          applyParams: (params) => {
+            node.setParameterValues?.(toWamParameterMap(params))?.catch((err) => {
+              console.warn(PREFIX2 + "WAM setParameterValues failed: " + String(err));
+            });
+          },
+          dispose: () => {
+            this._wamNodes.delete(node);
+            plugin.destroy();
+          },
+          getState: () => plugin.getState(),
+          getParameterInfo: () => plugin.getParameterInfo(),
+          ...plugin.createGui ? { createGui: () => plugin.createGui() } : {},
+          ...plugin.destroyGui ? { destroyGui: (gui) => plugin.destroyGui(gui) } : {}
+        },
+        params: {}
+      });
+    } catch (err) {
+      try {
+        plugin.destroy();
+      } catch (destroyErr) {
+        console.warn(
+          PREFIX2 + "addWamPlugin: cleanup after failed insertion also failed: " + String(destroyErr)
+        );
+      }
+      throw err;
+    }
+    this._wamNodes.add(node);
+    this._ensureTransportBridge(wamModule)?.notifyNodeAdded(node);
+    const index = chain.entries.findIndex((e) => e.id === effectId);
+    this._dispatch(target, "daw-effect-add", {
+      effectId,
+      kind: "wam",
+      type: "wam",
+      ...meta.url !== void 0 ? { url: meta.url } : {},
+      ...meta.source !== void 0 ? { source: meta.source } : {},
+      params: {},
+      index
+    });
+    return effectId;
+  }
+  /**
+   * Lazily create the wam-transport bridge so tempo-synced plugins lock to
+   * the timeline. Skipped (not an error) when the adapter's transport lacks
+   * the query/event surface — the bridge is an enhancement, not a
+   * requirement for audio processing.
+   */
+  _ensureTransportBridge(wamModule) {
+    if (this._transportBridge) return this._transportBridge;
+    if (typeof wamModule.createWamTransportBridge !== "function") return null;
+    const transport = this._getAdapter()?.transport;
+    if (!transport || typeof transport.on !== "function" || typeof transport.getTempo !== "function" || typeof transport.tickToBar !== "function" || typeof transport.timeToTick !== "function") {
+      return null;
+    }
+    this._transportBridge = wamModule.createWamTransportBridge(transport, () => [
+      ...this._wamNodes
+    ]);
+    return this._transportBridge;
+  }
+  /**
+   * Replace a chain's contents with a persisted snapshot. Entries restore
+   * sequentially so chain order survives async WAM loads. A WAM url that
+   * fails to load becomes a bypassed passthrough placeholder at its saved
+   * position — the restore continues, a daw-effect-error fires, and the
+   * saved state is retained so a later snapshot/retry round-trips it.
+   */
+  async _restoreChain(chain, target, entries) {
+    const token = /* @__PURE__ */ Symbol("restore");
+    this._restoreTokens.set(chain, token);
+    const superseded = () => this._restoreTokens.get(chain) !== token;
+    for (const existing of chain.entries) {
+      this._runOp(chain, target, "remove", existing.id);
+    }
+    for (const entry of entries) {
+      if (superseded()) return;
+      if (entry.kind === "native") {
+        const id = this._addToChain(chain, target, entry.type, entry.params);
+        if (entry.bypassed) {
+          this._runOp(chain, target, "setBypassed", id, true);
+        }
+        continue;
+      }
+      try {
+        const id = entry.faustDsp !== void 0 ? await this._addFaustToChain(chain, target, entry.faustDsp, {
+          name: entry.faustName,
+          initialState: entry.state
+        }) : await this._addWamToChain(chain, target, entry.url ?? "", entry.state);
+        if (superseded()) {
+          this._runOp(chain, target, "remove", id);
+          return;
+        }
+        if (entry.bypassed) {
+          this._runOp(chain, target, "setBypassed", id, true);
+        }
+      } catch (err) {
+        if (superseded()) return;
+        const message = err instanceof Error ? err.message : String(err);
+        const sourceLabel = entry.url ?? entry.faustName ?? "Faust effect";
+        console.warn(
+          PREFIX2 + 'setEffectsState: plugin "' + sourceLabel + '" failed to restore: ' + message
+        );
+        const effectId = this._addWamPlaceholder(chain, entry, message);
+        this._dispatch(target, "daw-effect-error", {
+          effectId,
+          ...entry.url !== void 0 ? { url: entry.url } : {},
+          ...entry.faustDsp !== void 0 ? { source: { faust: entry.faustDsp } } : {},
+          message
+        });
+      }
+    }
+  }
+  /** A silent passthrough occupying the failed plugin's chain position. */
+  _addWamPlaceholder(chain, entry, message) {
+    const { audioContext } = this._requireWiring();
+    const node = audioContext.createGain();
+    const effectId = chain.add({
+      kind: "wam",
+      type: "wam",
+      ...entry.url !== void 0 ? { url: entry.url } : {},
+      ...entry.faustDsp !== void 0 ? { source: { faust: entry.faustDsp } } : {},
+      label: entry.url ?? entry.faustName ?? "Faust effect",
+      error: message,
+      placeholder: { state: entry.state, bypassed: entry.bypassed },
+      instance: { input: node, output: node, applyParams: () => {
+      } },
+      params: {}
+    });
+    chain.setBypassed(effectId, true);
+    return effectId;
+  }
+  _runOp(chain, target, op, effectId, arg) {
+    const entries = chain?.entries ?? [];
+    const fromIndex = entries.findIndex((e) => e.id === effectId);
+    if (!chain || fromIndex === -1) {
+      console.warn(PREFIX2 + "effects." + op + ': unknown effectId "' + effectId + '"');
+      return;
+    }
+    if (entries[fromIndex].error !== void 0 && (op === "setParams" || op === "setBypassed")) {
+      console.warn(
+        PREFIX2 + "effects." + op + ': effect "' + effectId + '" is a failed-plugin placeholder (' + entries[fromIndex].error + ") \u2014 edit ignored. Remove it or retry the restore."
+      );
+      return;
+    }
+    switch (op) {
+      case "remove":
+        this._destroyGui(effectId);
+        chain.remove(effectId);
+        this._dispatch(target, "daw-effect-remove", { effectId });
+        break;
+      case "setParams":
+        chain.setParams(effectId, arg);
+        this._dispatch(target, "daw-effect-change", { effectId, params: { ...arg } });
+        break;
+      case "setBypassed":
+        chain.setBypassed(effectId, arg);
+        this._dispatch(target, "daw-effect-bypass", { effectId, bypassed: arg });
+        break;
+      case "move":
+        chain.move(effectId, arg);
+        this._dispatch(target, "daw-effect-reorder", { effectId, fromIndex, toIndex: arg });
+        break;
+    }
+  }
+  _dispatch(target, name, detail) {
+    target.dispatchEvent(new CustomEvent(name, { bubbles: true, composed: true, detail }));
+  }
+};
+function validateSerializedEntries(entries) {
+  if (!Array.isArray(entries)) {
+    throw new Error(PREFIX2 + "setEffectsState: expected an array of serialized effect entries");
+  }
+  entries.forEach((entry, i) => {
+    const at = " (entry " + i + ")";
+    if (entry === null || typeof entry !== "object") {
+      throw new Error(PREFIX2 + "setEffectsState: entry must be an object" + at);
+    }
+    const e = entry;
+    if (e.kind === "native") {
+      if (typeof e.type !== "string" || e.type.length === 0) {
+        throw new Error(PREFIX2 + "setEffectsState: native entry requires a type string" + at);
+      }
+      if (e.params === null || typeof e.params !== "object") {
+        throw new Error(PREFIX2 + "setEffectsState: native entry requires a params object" + at);
+      }
+    } else if (e.kind === "wam") {
+      const hasUrl = typeof e.url === "string" && e.url.length > 0;
+      const hasFaustDsp = typeof e.faustDsp === "string" && e.faustDsp.trim().length > 0;
+      if (!hasUrl && !hasFaustDsp) {
+        throw new Error(
+          PREFIX2 + "setEffectsState: wam entry requires a url string or a faustDsp source string" + at
+        );
+      }
+      if (e.faustName !== void 0 && typeof e.faustName !== "string") {
+        throw new Error(PREFIX2 + "setEffectsState: faustName must be a string when provided" + at);
+      }
+    } else {
+      throw new Error(PREFIX2 + 'setEffectsState: unknown entry kind "' + String(e.kind) + '"' + at);
+    }
+    if (typeof e.bypassed !== "boolean") {
+      throw new Error(PREFIX2 + "setEffectsState: entry requires a boolean bypassed flag" + at);
+    }
+  });
+}
+function toWamParameterMap(params) {
+  const map = {};
+  for (const [id, value] of Object.entries(params)) {
+    map[id] = { id, value, normalized: false };
+  }
+  return map;
+}
+
+// src/interactions/export-audio.ts
+var PREFIX3 = "[waveform-playlist] ";
+async function exportAudioImpl(host, options = {}) {
+  const sampleRate = options.sampleRate ?? host.effectiveSampleRate;
+  const startTime = options.startTime ?? 0;
+  const duration = options.duration ?? Math.max(0, host.duration - startTime);
+  const channels = options.channels ?? 2;
+  if (!Number.isFinite(sampleRate) || sampleRate <= 0) {
+    throw new Error(PREFIX3 + "exportAudio: invalid sampleRate " + String(sampleRate));
+  }
+  if (!Number.isFinite(duration) || duration <= 0) {
+    throw new Error(PREFIX3 + "exportAudio: nothing to render (duration " + String(duration) + ")");
+  }
+  const ctx = new OfflineAudioContext({
+    numberOfChannels: channels,
+    length: Math.round(duration * sampleRate),
+    sampleRate
+  });
+  const cleanups = [];
+  try {
+    const masterChain = await buildOfflineChain(ctx, await host.getMasterEffectsState());
+    cleanups.push(masterChain.dispose);
+    masterChain.output.connect(ctx.destination);
+    const anySoloed = host.tracks.some((t) => t.soloed);
+    for (const track of host.tracks) {
+      if (track.muted || anySoloed && !track.soloed) {
+        continue;
+      }
+      const chain = await buildOfflineChain(ctx, await host.getTrackEffectsState(track.id));
+      cleanups.push(chain.dispose);
+      const volume = ctx.createGain();
+      volume.gain.value = track.volume;
+      const panner = ctx.createStereoPanner();
+      panner.pan.value = track.pan;
+      volume.connect(panner);
+      panner.connect(chain.input);
+      chain.output.connect(masterChain.input);
+      for (const clip of track.clips) {
+        scheduleClip(ctx, clip, startTime, duration, volume);
+      }
+    }
+    return await ctx.startRendering();
+  } finally {
+    for (const dispose of cleanups) {
+      try {
+        dispose();
+      } catch (err) {
+        console.warn(PREFIX3 + "exportAudio: cleanup error: " + String(err));
+      }
+    }
+  }
+}
+function scheduleClip(ctx, clip, windowStart, windowDuration, destination) {
+  if (!clip.audioBuffer || clip.durationSamples <= 0) {
+    return;
+  }
+  const clipRate = clip.sampleRate;
+  const clipStart = clip.startSample / clipRate;
+  const clipDuration = clip.durationSamples / clipRate;
+  let offset = clip.offsetSamples / clipRate;
+  let when = clipStart - windowStart;
+  let remaining = clipDuration;
+  if (when < 0) {
+    offset += -when;
+    remaining += when;
+    when = 0;
+  }
+  remaining = Math.min(remaining, windowDuration - when);
+  if (remaining <= 0) {
+    return;
+  }
+  const source = ctx.createBufferSource();
+  source.buffer = clip.audioBuffer;
+  let out = source;
+  if (clip.gain !== void 0 && clip.gain !== 1) {
+    const gainNode = ctx.createGain();
+    gainNode.gain.value = clip.gain;
+    out.connect(gainNode);
+    out = gainNode;
+  }
+  out.connect(destination);
+  source.start(when, offset, remaining);
+}
+async function buildOfflineChain(ctx, entries) {
+  const input = ctx.createGain();
+  const output = ctx.createGain();
+  const cleanups = [];
+  const dispose = () => {
+    for (const cleanup of cleanups) {
+      try {
+        cleanup();
+      } catch (err) {
+        console.warn(PREFIX3 + "exportAudio: chain cleanup error: " + String(err));
+      }
+    }
+  };
+  let previous = input;
+  try {
+    await wireEntries();
+  } catch (err) {
+    dispose();
+    throw err;
+  }
+  previous.connect(output);
+  return { input, output, dispose };
+  async function wireEntries() {
+    for (const entry of entries) {
+      if (entry.kind === "native") {
+        const created = createEffectInstance(entry.type, ctx, entry.params);
+        if (entry.bypassed) {
+          if (!created.wetParam) {
+            created.instance.dispose?.();
+            continue;
+          }
+          created.instance.applyParams({ [created.wetParam]: 0 });
+        }
+        if (created.instance.dispose) {
+          cleanups.push(created.instance.dispose);
+        }
+        previous.connect(created.instance.input);
+        previous = created.instance.output;
+        continue;
+      }
+      if (entry.bypassed) {
+        continue;
+      }
+      const wamModule = await loadWamModule("exportAudio() with WAM effects");
+      const { hostGroupId } = await wamModule.ensureWamHost(ctx);
+      let plugin;
+      if (entry.faustDsp !== void 0) {
+        const faustModule = await loadFaustModule("exportAudio() with Faust effects");
+        const compiled = await faustModule.compileFaustToWam(entry.faustDsp, {
+          name: entry.faustName
+        });
+        plugin = await wamModule.createWamInstanceFromFactory(
+          compiled.factory,
+          ctx,
+          hostGroupId,
+          { initialState: entry.state, label: compiled.name }
+        );
+      } else {
+        plugin = await wamModule.createWamInstance(entry.url ?? "", ctx, hostGroupId, {
+          initialState: entry.state
+        });
+      }
+      cleanups.push(() => plugin.destroy());
+      previous.connect(plugin.audioNode);
+      previous = plugin.audioNode;
+    }
+  }
+}
+
 // src/interactions/peaks-loader.ts
 import WaveformData2 from "waveform-data";
 async function loadWaveformDataFromUrl(src) {
@@ -4286,6 +5430,8 @@ var DawEditorElement = class extends LitElement11 {
     this._selectionEndTime = 0;
     this._currentTime = 0;
     this._externalAdapter = null;
+    // --- Effects (master chain; per-track chains delegated from <daw-track>) ---
+    this._effectsManager = null;
     this._engine = null;
     this._warnedMissingTicksToSeconds = false;
     this._warnedMissingSecondsToTicks = false;
@@ -4643,11 +5789,122 @@ var DawEditorElement = class extends LitElement11 {
         "[dawcore] adapter set after engine is built. The engine will continue using the previous adapter."
       );
     }
+    if (this._effectsManager) {
+      console.warn(
+        "[dawcore] adapter replaced \u2014 existing effect chains were disposed. Re-add effects on the new adapter."
+      );
+      this._effectsManager.disposeAll();
+      this._effectsManager = null;
+    }
     this._externalAdapter = value;
   }
   get adapter() {
     return this._externalAdapter;
   }
+  get _effects() {
+    if (!this._effectsManager) {
+      this._effectsManager = new EffectsManager(() => this._externalAdapter, this);
+    }
+    return this._effectsManager;
+  }
+  /** Master effects chain — inserted between the master bus and the destination. */
+  addEffect(type, params) {
+    return this._effects.addMasterEffect(type, params);
+  }
+  removeEffect(effectId) {
+    this._effects.masterOp("remove", effectId);
+  }
+  setEffectParams(effectId, params) {
+    this._effects.masterOp("setParams", effectId, params);
+  }
+  setEffectBypassed(effectId, bypassed) {
+    this._effects.masterOp("setBypassed", effectId, bypassed);
+  }
+  moveEffect(effectId, newIndex) {
+    this._effects.masterOp("move", effectId, newIndex);
+  }
+  get effects() {
+    return this._effectsManager?.masterEffects() ?? [];
+  }
+  /** Load a WAM plugin (via the optional @dawcore/wam peer) into the master chain. */
+  addWamPlugin(url, initialState) {
+    return this._effects.addMasterWamPlugin(url, initialState);
+  }
+  /**
+   * Compile Faust DSP source in the browser (via the optional @dawcore/faust
+   * peer) and add the resulting WAM to the master chain. Compile errors keep
+   * their Faust line/column diagnostics and leave the chain untouched.
+   */
+  addFaustEffect(dspCode, options) {
+    return this._effects.addMasterFaustEffect(dspCode, options);
+  }
+  /**
+   * Open (lazily creating) the GUI for a master-chain effect into a
+   * consumer-provided container. WAM plugins mount their own GUI; plugins
+   * without one — and native effects — get the generic parameter panel from
+   * @dawcore/wam. The element is cached: closeEffectGui hides it without
+   * interrupting audio, reopening remounts the same element.
+   */
+  openEffectGui(effectId, container) {
+    return this._effects.openMasterEffectGui(effectId, container);
+  }
+  /** Hide a master-chain effect's GUI (cached for reopen — never destroys). */
+  closeEffectGui(effectId) {
+    this._effects.closeEffectGui(effectId);
+  }
+  /** Snapshot the master chain in its persisted form (see dawcore README). */
+  getEffectsState() {
+    return this._effectsManager?.getMasterEffectsState() ?? Promise.resolve([]);
+  }
+  /** Replace the master chain with a persisted snapshot. */
+  setEffectsState(entries) {
+    return this._effects.setMasterEffectsState(entries);
+  }
+  /**
+   * Render the session offline through all effect chains (per-track +
+   * master), including WAM plugins (re-instantiated on the offline context
+   * with their live state). Returns the rendered AudioBuffer.
+   */
+  exportAudio(options) {
+    return exportAudioImpl(
+      {
+        effectiveSampleRate: this.effectiveSampleRate,
+        duration: this._duration,
+        tracks: [...this._engineTracks.values()],
+        getMasterEffectsState: () => this.getEffectsState(),
+        getTrackEffectsState: (trackId) => this._trackGetEffectsState(trackId)
+      },
+      options
+    );
+  }
+  /** Internal — <daw-track> effects API delegates here (dawcore-internal contract). */
+  _trackAddEffect(trackId, target, type, params) {
+    return this._effects.addTrackEffect(trackId, target, type, params);
+  }
+  _trackEffectOp(trackId, target, op, effectId, arg) {
+    this._effects.trackOp(trackId, target, op, effectId, arg);
+  }
+  _trackEffects(trackId) {
+    return this._effectsManager?.trackEffects(trackId) ?? [];
+  }
+  _trackAddWamPlugin(trackId, target, url, initialState) {
+    return this._effects.addTrackWamPlugin(trackId, target, url, initialState);
+  }
+  _trackAddFaustEffect(trackId, target, dspCode, options) {
+    return this._effects.addTrackFaustEffect(trackId, target, dspCode, options);
+  }
+  _trackOpenEffectGui(trackId, target, effectId, container) {
+    return this._effects.openTrackEffectGui(trackId, target, effectId, container);
+  }
+  _trackCloseEffectGui(_trackId, effectId) {
+    this._effects.closeEffectGui(effectId);
+  }
+  _trackGetEffectsState(trackId) {
+    return this._effectsManager?.getTrackEffectsState(trackId) ?? Promise.resolve([]);
+  }
+  _trackSetEffectsState(trackId, target, entries) {
+    return this._effects.setTrackEffectsState(trackId, target, entries);
+  }
   get audioContext() {
     if (!this._externalAdapter) {
       throw new Error(NO_ADAPTER_ERROR);
@@ -4819,6 +6076,8 @@ var DawEditorElement = class extends LitElement11 {
   }
   disconnectedCallback() {
     super.disconnectedCallback();
+    this._effectsManager?.disposeAll();
+    this._effectsManager = null;
     this.removeEventListener("daw-track-connected", this._onTrackConnected);
     this.removeEventListener("daw-track-update", this._onTrackUpdate);
     this.removeEventListener("daw-track-control", this._onTrackControl);
@@ -4894,6 +6153,7 @@ var DawEditorElement = class extends LitElement11 {
   }
   _onTrackRemoved(trackId) {
     this._trackElements.delete(trackId);
+    this._effectsManager?.disposeTrackChain(trackId);
     const removedTrack = this._engineTracks.get(trackId);
     if (removedTrack) {
       const nextPeaks = new Map(this._peaksData);
@@ -5544,6 +6804,7 @@ var DawEditorElement = class extends LitElement11 {
           nextTracks.set(track.id, track);
         }
         this._engineTracks = nextTracks;
+        this._effectsManager?.rewireTrackChains();
         const audioTracks = engineState.tracks.filter((t) => {
           const desc = this._tracks.get(t.id);
           return desc?.renderMode !== "piano-roll";
@@ -7019,7 +8280,10 @@ export {
   DawWaveformElement,
   RecordingController,
   SpectrogramController,
+  createEffectInstance,
+  getEffectDefinitions,
   isDomClip,
+  registerEffect,
   splitAtPlayhead
 };
 //# sourceMappingURL=index.mjs.map