@weasel-js/audio 1.11.0 → 1.11.1

package/dist/index.js

@@ -19,14 +19,14 @@ function createAnalyserTap(ctx, source, opts = {}) {
   return {
     node,
     frequencies(out) {
-      const target = out ?? new Uint8Array(node.frequencyBinCount);
-      node.getByteFrequencyData(target);
-      return target;
+      const target2 = out ?? new Uint8Array(node.frequencyBinCount);
+      node.getByteFrequencyData(target2);
+      return target2;
     },
     waveform(out) {
-      const target = out ?? new Uint8Array(node.fftSize);
-      node.getByteTimeDomainData(target);
-      return target;
+      const target2 = out ?? new Uint8Array(node.fftSize);
+      node.getByteTimeDomainData(target2);
+      return target2;
     },
     level() {
       const buf = timeBuf();
@@ -49,16 +49,16 @@ function createAnalyserTap(ctx, source, opts = {}) {
       }
       const buf = freqBuf();
       node.getByteFrequencyData(buf);
-      const target = out ?? new Float32Array(n);
+      const target2 = out ?? new Float32Array(n);
       const per = buf.length / n;
       for (let b = 0; b < n; b += 1) {
         const lo = Math.floor(b * per);
         const hi = Math.max(lo + 1, Math.floor((b + 1) * per));
         let sum = 0;
         for (let i = lo; i < hi; i += 1) sum += buf[i];
-        target[b] = sum / (hi - lo) / 255;
+        target2[b] = sum / (hi - lo) / 255;
       }
-      return target;
+      return target2;
     },
     // `node.disconnect()` would cut the analyser's outgoing edges, and it has
     // none: the edge that keeps it alive is the source's.
@@ -108,6 +108,10 @@ function writeParam(ctx, param, value, rampMs) {
     param.setValueAtTime(value, now);
   }
 }
+function initParam(ctx, param, value) {
+  param.value = value;
+  writeParam(ctx, param, value);
+}
 
 // src/inserts.ts
 function createInsertChain(ctx, head, tail, opts = {}) {
@@ -388,6 +392,512 @@ function createBusGraph(ctx, names, opts = {}) {
   };
 }
 
+// src/graph/edges.ts
+function findLive(edges, from, to, port) {
+  return edges.find((e) => e.state !== "closing" && e.from === from && e.to === to && e.port === port);
+}
+var touches = (e, w) => e.from === w || e.to === w;
+var logical = (e) => e.state !== "closing";
+var wired = (e) => e.state !== "deferred";
+function reaches(edges, start, goal, admit = () => true) {
+  const seen = /* @__PURE__ */ new Set();
+  const stack = [start];
+  while (stack.length > 0) {
+    const n = stack.pop();
+    if (n === goal) return true;
+    if (seen.has(n)) continue;
+    seen.add(n);
+    for (const e of edges) if (admit(e) && e.from === n && e.to !== null) stack.push(e.to);
+  }
+  return false;
+}
+var blocked = (edges, e) => e.to !== null && reaches(edges, e.to, e.from, wired);
+function drop(edges, e) {
+  const i = edges.indexOf(e);
+  if (i >= 0) edges.splice(i, 1);
+}
+
+// src/graph/fader.ts
+function createFader(ctx, timers, from, to) {
+  const gain = ctx.createGain();
+  initParam(ctx, gain.gain, 0);
+  from.connect(gain);
+  gain.connect(to);
+  let cancel = null;
+  let closing = false;
+  let cutDone = false;
+  const cut = () => {
+    cancel?.();
+    cancel = null;
+    if (cutDone) return;
+    cutDone = true;
+    from.disconnect(gain);
+    gain.disconnect();
+  };
+  return {
+    gain,
+    open(ms) {
+      writeParam(ctx, gain.gain, 1, ms);
+    },
+    close(ms, done) {
+      if (closing || cutDone) return;
+      closing = true;
+      const length = ctx.state === "running" ? ms : 0;
+      writeParam(ctx, gain.gain, 0, length);
+      cancel = atAudioTime(ctx, timers, ctx.currentTime + length / 1e3, () => {
+        cancel = null;
+        cut();
+        done?.();
+      });
+    },
+    cut
+  };
+}
+
+// src/graph/wrapper.ts
+function createWrapper(ctx, timers, id, def) {
+  const ins = {};
+  const inFaders = {};
+  for (const port of Object.keys(def.inputs)) {
+    ins[port] = ctx.createGain();
+    inFaders[port] = createFader(ctx, timers, ins[port], def.inputs[port]);
+    inFaders[port].open(0);
+  }
+  const out = ctx.createGain();
+  const outFader = createFader(ctx, timers, def.output, out);
+  outFader.open(0);
+  return { id, def, ins, inFaders, out, outFader, taps: /* @__PURE__ */ new Set(), running: false, outgoing: /* @__PURE__ */ new Set() };
+}
+function tapWrapper(ctx, w, opts) {
+  const inner = createAnalyserTap(ctx, w.out, opts);
+  const t = {
+    ...inner,
+    dispose() {
+      w.taps.delete(t);
+      inner.dispose();
+    }
+  };
+  w.taps.add(t);
+  return t;
+}
+function startWrapper(w, when) {
+  if (w.running || !w.def.start) return;
+  w.running = true;
+  w.def.start(when);
+}
+function stopWrapper(w, when) {
+  if (!w.running) return;
+  w.running = false;
+  w.def.stop?.(when);
+}
+function releaseOutgoing(w, o, when) {
+  w.outgoing.delete(o);
+  if (o.running) o.def.stop?.(when);
+  o.running = false;
+  for (const f of o.faders) f.cut();
+  o.def.dispose?.();
+}
+function releaseWrapper(w, when) {
+  for (const o of [...w.outgoing]) releaseOutgoing(w, o, when);
+  stopWrapper(w, when);
+  for (const f of Object.values(w.inFaders)) f.cut();
+  w.outFader.cut();
+  for (const t of w.taps) t.dispose();
+  w.taps.clear();
+  w.def.dispose?.();
+}
+
+// src/graph/replace.ts
+function replaceDef(ctx, timers, w, next, ms, playing, hooks) {
+  const old = {
+    def: w.def,
+    faders: [...Object.values(w.inFaders), w.outFader],
+    running: w.running
+  };
+  w.outgoing.add(old);
+  for (const port of Object.keys(w.ins)) {
+    if (Object.prototype.hasOwnProperty.call(next.inputs, port)) continue;
+    hooks.closePort(port);
+    delete w.ins[port];
+    delete w.inFaders[port];
+  }
+  for (const port of Object.keys(next.inputs)) {
+    w.ins[port] ??= ctx.createGain();
+    w.inFaders[port] = openFader(ctx, timers, w.ins[port], next.inputs[port], ms);
+  }
+  w.outFader = openFader(ctx, timers, next.output, w.out, ms);
+  w.def = next;
+  w.running = false;
+  if (playing && next.start) {
+    w.running = true;
+    next.start(ctx.currentTime);
+  }
+  let open = old.faders.length;
+  for (const f of old.faders) {
+    f.close(ms, () => {
+      open -= 1;
+      if (open > 0 || !w.outgoing.has(old)) return;
+      releaseOutgoing(w, old, ctx.currentTime);
+      hooks.onSettle();
+    });
+  }
+}
+function openFader(ctx, timers, from, to, ms) {
+  const f = createFader(ctx, timers, from, to);
+  f.open(ms);
+  return f;
+}
+
+// src/graph/errors.ts
+var graphError = (msg) => new Error(`@weasel-js/audio: ${msg}`);
+var owns = (rec, key) => Object.prototype.hasOwnProperty.call(rec, key);
+var noNode = (id) => graphError(`no node "${id}"`);
+var duplicateNode = (id) => graphError(`a node "${id}" already exists`);
+var noPort = (id, port) => graphError(`node "${id}" has no input port "${port}"`);
+var noParam = (id, param) => graphError(`node "${id}" has no param "${param}"`);
+var closesCycle = (from, to) => graphError(`connecting "${from}" to "${to}" would close a cycle`);
+
+// src/graph/edits.ts
+function target(live, to) {
+  if ("output" in to) return [null, ""];
+  const w = live(to.node);
+  if (!owns(w.ins, to.port)) throw noPort(to.node, to.port);
+  return [w, to.port];
+}
+function createEdits(deps) {
+  const { ctx, timers, fade, output } = deps;
+  const nodes = /* @__PURE__ */ new Map();
+  const leaving = /* @__PURE__ */ new Set();
+  const edges = [];
+  const live = (id) => {
+    const w = nodes.get(id);
+    if (!w) throw noNode(id);
+    return w;
+  };
+  const wire = (e) => {
+    e.state = "open";
+    e.fader = createFader(ctx, timers, e.from.out, e.to ? e.to.ins[e.port] : output);
+    e.fader.open(fade());
+  };
+  const sweep = () => {
+    for (const e of edges) if (e.state === "deferred" && !blocked(edges, e)) wire(e);
+    for (const w of [...leaving]) {
+      if (edges.some((e) => touches(e, w))) continue;
+      leaving.delete(w);
+      releaseWrapper(w, ctx.currentTime);
+    }
+    deps.onSettle();
+  };
+  const close = (e) => {
+    if (e.state === "closing") return;
+    if (e.state === "deferred") {
+      drop(edges, e);
+      return;
+    }
+    e.state = "closing";
+    e.fader.close(fade(), () => {
+      drop(edges, e);
+      sweep();
+    });
+  };
+  return {
+    live,
+    has: (id) => nodes.has(id),
+    ids: () => [...nodes.keys()],
+    liveNodes: () => [...nodes.values()],
+    /** Live and leaving: every wrapper whose def has not been released. */
+    allNodes: () => [...nodes.values(), ...leaving],
+    /** The live nodes and the edges a caller can see, by id, for `validatePatches`. */
+    view: () => ({
+      nodes: new Map([...nodes].map(([id, w]) => [id, { ports: new Set(Object.keys(w.ins)), params: w.def.params }])),
+      edges: edges.filter(logical).map((e) => ({ from: e.from.id, to: e.to?.id ?? null, port: e.port }))
+    }),
+    /** An edge is fading out or waiting to be wired, or a replaced def is fading out. */
+    busy: () => edges.some((e) => e.state !== "open") || [...nodes.values(), ...leaving].some((w) => w.outgoing.size > 0),
+    add(id, def) {
+      if (nodes.has(id)) throw duplicateNode(id);
+      const w = createWrapper(ctx, timers, id, def);
+      nodes.set(id, w);
+      deps.onAdd(w);
+    },
+    remove(id) {
+      const w = nodes.get(id);
+      if (!w) return;
+      nodes.delete(id);
+      leaving.add(w);
+      for (const e of edges.filter((x) => touches(x, w))) close(e);
+      sweep();
+    },
+    /** Crossfade `id` into `def`; edges into a port `def` lacks close with it. */
+    replace(id, def, playing) {
+      const w = live(id);
+      replaceDef(ctx, timers, w, def, fade(), playing, {
+        closePort: (port) => {
+          for (const e of edges.filter((x) => x.to === w && x.port === port)) close(e);
+        },
+        onSettle: deps.onSettle
+      });
+      deps.onSettle();
+    },
+    connect(from, to) {
+      const w = live(from);
+      const [tw, port] = target(live, to);
+      if (findLive(edges, w, tw, port)) return;
+      if (tw && reaches(edges, tw, w, logical)) {
+        throw closesCycle(from, tw.id);
+      }
+      const e = { from: w, to: tw, port, state: "deferred", fader: null };
+      edges.push(e);
+      if (!blocked(edges, e)) wire(e);
+    },
+    disconnect(from, to) {
+      const w = nodes.get(from);
+      const tw = "output" in to ? null : nodes.get(to.node);
+      if (!w || tw === void 0) return;
+      const e = findLive(edges, w, tw, "output" in to ? "" : to.port);
+      if (!e) return;
+      close(e);
+      deps.onSettle();
+    },
+    set(id, param, value, rampMs) {
+      const w = live(id);
+      if (!owns(w.def.params, param)) throw noParam(id, param);
+      w.def.params[param](value, rampMs ?? fade());
+    },
+    /** Cut every edge, canceling its close, then release every def. */
+    dispose() {
+      for (const e of edges.splice(0)) e.fader?.cut();
+      const all = [...nodes.values(), ...leaving];
+      nodes.clear();
+      leaving.clear();
+      for (const w of all) releaseWrapper(w, ctx.currentTime);
+    }
+  };
+}
+
+// src/graph/transport.ts
+function createTransport(deps) {
+  const { ctx, timers, output } = deps;
+  let playing = false;
+  let cancel = null;
+  const fadeOutput = (value, then) => {
+    cancel?.();
+    cancel = null;
+    const ms = deps.fade();
+    writeParam(ctx, output.gain, value, ms);
+    let pending = true;
+    const c = atAudioTime(ctx, timers, ctx.currentTime + ms / 1e3, () => {
+      pending = false;
+      cancel = null;
+      then();
+      deps.onSettle();
+    });
+    if (pending) cancel = c;
+  };
+  return {
+    playing: () => playing,
+    /** An output fade is in flight. */
+    busy: () => cancel !== null,
+    start() {
+      if (playing) return;
+      playing = true;
+      fadeOutput(1, () => {
+      });
+      for (const w of deps.live()) startWrapper(w, ctx.currentTime);
+    },
+    stop() {
+      if (!playing) return;
+      playing = false;
+      fadeOutput(0, () => {
+        for (const w of deps.all()) stopWrapper(w, ctx.currentTime);
+      });
+    },
+    /** Playing, or an output fade is still in flight: the output may not be silent. */
+    audible: () => playing || cancel !== null,
+    /** Fade the output to silence, then run `then` instead of stopping the sources. */
+    fadeOut(then) {
+      playing = false;
+      fadeOutput(0, then);
+    },
+    /** Cancel the fade in flight and forget playing; the caller stops the sources. */
+    dispose() {
+      cancel?.();
+      cancel = null;
+      playing = false;
+    }
+  };
+}
+
+// src/graph/validate.ts
+var viewNode = (def) => ({
+  ports: new Set(Object.keys(def.inputs)),
+  params: def.params
+});
+var toId = (to) => "output" in to ? null : to.node;
+var toPort = (to) => "output" in to ? "" : to.port;
+function validatePatches(view, patches) {
+  const nodes = new Map(view.nodes);
+  let edges = [...view.edges];
+  const live = (id) => {
+    const n = nodes.get(id);
+    if (!n) throw noNode(id);
+    return n;
+  };
+  const same = (e, from, to) => e.from === from && e.to === toId(to) && e.port === toPort(to);
+  for (const p of patches) {
+    switch (p.kind) {
+      case "add":
+        if (nodes.has(p.id)) throw duplicateNode(p.id);
+        nodes.set(p.id, viewNode(p.def));
+        break;
+      case "remove":
+        if (nodes.delete(p.id)) edges = edges.filter((e) => e.from !== p.id && e.to !== p.id);
+        break;
+      case "replace": {
+        live(p.id);
+        const n = viewNode(p.def);
+        nodes.set(p.id, n);
+        edges = edges.filter((e) => e.to !== p.id || n.ports.has(e.port));
+        break;
+      }
+      case "connect": {
+        live(p.from);
+        const to = toId(p.to);
+        if (to !== null && !live(to).ports.has(toPort(p.to))) throw noPort(to, toPort(p.to));
+        if (edges.some((e) => same(e, p.from, p.to))) break;
+        if (to !== null && reaches(edges, to, p.from)) throw closesCycle(p.from, to);
+        edges.push({ from: p.from, to, port: toPort(p.to) });
+        break;
+      }
+      case "disconnect":
+        edges = edges.filter((e) => !same(e, p.from, p.to));
+        break;
+      case "set":
+        if (!owns(live(p.id).params, p.param)) throw noParam(p.id, p.param);
+        break;
+    }
+  }
+}
+
+// src/graph/createAudioGraph.ts
+var teardowns = /* @__PURE__ */ new WeakMap();
+function disposeNow(graph) {
+  teardowns.get(graph)?.();
+}
+function createAudioGraph(ctx, destination, opts = {}) {
+  const fadeMs = opts.fadeMs ?? 15;
+  const timers = {
+    setTimer: opts.setTimer ?? defaultTimers.setTimer,
+    clearTimer: opts.clearTimer ?? defaultTimers.clearTimer
+  };
+  const fade = () => ctx.state === "running" ? fadeMs : 0;
+  const output = ctx.createGain();
+  initParam(ctx, output.gain, 0);
+  output.connect(destination);
+  let waiters = [];
+  let disposed = false;
+  let torn = false;
+  const onSettle = () => {
+    if (!torn && (edits.busy() || transport.busy())) return;
+    const done = waiters;
+    waiters = [];
+    for (const w of done) w();
+  };
+  const edits = createEdits({
+    ctx,
+    timers,
+    fade,
+    output,
+    onSettle,
+    onAdd: (w) => {
+      if (transport.playing()) startWrapper(w, ctx.currentTime);
+    }
+  });
+  const transport = createTransport({
+    ctx,
+    timers,
+    fade,
+    output,
+    onSettle,
+    live: edits.liveNodes,
+    all: edits.allNodes
+  });
+  const guard = (f) => (...args) => {
+    if (disposed) throw graphError("graph is disposed");
+    return f(...args);
+  };
+  const graph = {
+    add: guard(edits.add),
+    remove: guard(edits.remove),
+    replace: guard((id, def) => {
+      edits.replace(id, def, transport.playing());
+    }),
+    connect: guard(edits.connect),
+    disconnect: guard(edits.disconnect),
+    set: guard(edits.set),
+    apply: guard((patches) => {
+      validatePatches(edits.view(), patches);
+      let failed = null;
+      for (const p of patches) {
+        switch (p.kind) {
+          case "add":
+            graph.add(p.id, p.def);
+            break;
+          case "remove":
+            graph.remove(p.id);
+            break;
+          case "replace":
+            graph.replace(p.id, p.def);
+            break;
+          case "connect":
+            graph.connect(p.from, p.to);
+            break;
+          case "disconnect":
+            graph.disconnect(p.from, p.to);
+            break;
+          case "set":
+            try {
+              graph.set(p.id, p.param, p.value, p.rampMs);
+            } catch (error) {
+              failed ??= { error };
+            }
+            break;
+        }
+      }
+      if (failed) throw failed.error;
+    }),
+    start: guard(transport.start),
+    stop: guard(transport.stop),
+    playing: transport.playing,
+    has: edits.has,
+    ids: edits.ids,
+    tap: guard((id, tapOpts) => tapWrapper(ctx, edits.live(id), tapOpts)),
+    settled() {
+      return new Promise((resolve) => {
+        waiters.push(resolve);
+        onSettle();
+      });
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      if (ctx.state === "running" && transport.audible()) transport.fadeOut(teardown);
+      else teardown();
+    }
+  };
+  const teardown = () => {
+    if (torn) return;
+    disposed = true;
+    torn = true;
+    transport.dispose();
+    edits.dispose();
+    output.disconnect();
+    onSettle();
+  };
+  teardowns.set(graph, teardown);
+  return graph;
+}
+
 // src/resumeWatch.ts
 function createResumeWatch(ctx, hooks) {
   let disposed = false;
@@ -503,7 +1013,7 @@ function createSoundCache(ctx, fetchFn = fetch) {
     buffers.set(id, buffer);
     return { id };
   };
-  const cache = {
+  const cache2 = {
     async load(url) {
       const existing = byUrl.get(url);
       if (existing) return existing;
@@ -527,7 +1037,7 @@ function createSoundCache(ctx, fetchFn = fetch) {
     },
     async loadAll(urls) {
       const names = Object.keys(urls);
-      const handles = await Promise.all(names.map((n) => cache.load(urls[n])));
+      const handles = await Promise.all(names.map((n) => cache2.load(urls[n])));
       return Object.fromEntries(names.map((n, i) => [n, handles[i]]));
     },
     async decode(bytes) {
@@ -536,7 +1046,7 @@ function createSoundCache(ctx, fetchFn = fetch) {
     register: (buffer) => store(buffer),
     buffer: (handle) => buffers.get(handle.id) ?? null
   };
-  return cache;
+  return cache2;
 }
 
 // src/streamStarter.ts
@@ -645,6 +1155,25 @@ function envelopePoints(e, gate) {
   return points;
 }
 
+// src/periodicWave.ts
+var cache = /* @__PURE__ */ new WeakMap();
+function periodicWave(ctx, partials) {
+  let byKey = cache.get(ctx);
+  if (!byKey) {
+    byKey = /* @__PURE__ */ new Map();
+    cache.set(ctx, byKey);
+  }
+  const key = partials.join(",");
+  let wave = byKey.get(key);
+  if (!wave) {
+    const imag = new Float32Array(partials.length + 1);
+    imag.set(partials, 1);
+    wave = ctx.createPeriodicWave(new Float32Array(partials.length + 1), imag);
+    byKey.set(key, wave);
+  }
+  return wave;
+}
+
 // src/liveVoice.ts
 var sourceGroup = (nodes) => ({
   get onended() {
@@ -907,21 +1436,12 @@ function noteOscillators(ctx, note, { from, glideTo, partials }, applyWave, t0,
   return oscs;
 }
 function createSynthStarters(ctx, random) {
-  const waves = /* @__PURE__ */ new Map();
   const applyWave = (osc, wave) => {
     if (typeof wave === "string") {
       osc.type = wave;
       return;
     }
-    const key = wave.join(",");
-    let periodic = waves.get(key);
-    if (!periodic) {
-      const imag = new Float32Array(wave.length + 1);
-      imag.set(wave, 1);
-      periodic = ctx.createPeriodicWave(new Float32Array(wave.length + 1), imag);
-      waves.set(key, periodic);
-    }
-    osc.setPeriodicWave(periodic);
+    osc.setPeriodicWave(periodicWave(ctx, wave));
   };
   return {
     note(note) {
@@ -1672,6 +2192,27 @@ function engineSynth(ctx, opts, busInput) {
     dispose: () => worklet?.dispose()
   };
 }
+function patchGraphs(ctx, busInput, opts) {
+  const live = /* @__PURE__ */ new Set();
+  return {
+    create(bus) {
+      const g = createAudioGraph(ctx, busInput(bus), opts);
+      live.add(g);
+      return {
+        ...g,
+        dispose() {
+          g.dispose();
+          void g.settled().then(() => live.delete(g));
+        }
+      };
+    },
+    /** Tear every graph down now: the engine is closing, so nothing fades. */
+    dispose() {
+      for (const g of live) disposeNow(g);
+      live.clear();
+    }
+  };
+}
 function engineClock(ctx, opts) {
   const now = () => ctx.currentTime * 1e3;
   const tickTimer = opts.setTimer === void 0 && opts.clearTimer === void 0 ? createTickTimer() : null;
@@ -1729,6 +2270,7 @@ function createAudioEngine(opts = {}) {
   });
   const synth = engineSynth(ctx, opts, graph.input);
   const streams = createStreamStarters(ctx, timers);
+  const patches = patchGraphs(ctx, graph.input, { ...timers, fadeMs: opts.insertFadeMs });
   const engine = {
     context: ctx,
     state: () => ctx.state,
@@ -1775,6 +2317,10 @@ function createAudioEngine(opts = {}) {
         }
       };
     },
+    graph(bus) {
+      if (disposed) throw new Error("@weasel-js/audio: engine is disposed");
+      return patches.create(bus ?? busNames[0]);
+    },
     setListener(p, o) {
       listener = p;
       if (o) spatialOpts = o;
@@ -1792,6 +2338,7 @@ function createAudioEngine(opts = {}) {
       taps.clear();
       watch.dispose();
       synth.dispose();
+      patches.dispose();
       graph.dispose();
       graph.master.disconnect();
       if (ownsContext) void ctx.close().catch(() => void 0);
@@ -1804,9 +2351,9 @@ function createAudioEngine(opts = {}) {
 function createFilterEffect(ctx, opts = {}) {
   const filter = ctx.createBiquadFilter();
   filter.type = opts.type ?? "lowpass";
-  if (opts.frequency !== void 0) writeParam(ctx, filter.frequency, opts.frequency);
-  if (opts.Q !== void 0) writeParam(ctx, filter.Q, opts.Q);
-  if (opts.gain !== void 0) writeParam(ctx, filter.gain, opts.gain);
+  if (opts.frequency !== void 0) initParam(ctx, filter.frequency, opts.frequency);
+  if (opts.Q !== void 0) initParam(ctx, filter.Q, opts.Q);
+  if (opts.gain !== void 0) initParam(ctx, filter.gain, opts.gain);
   return { input: filter, output: filter, filter };
 }
 var checkMix = (mix) => {
@@ -1828,7 +2375,8 @@ function wetDry(ctx, wetIn, wetOut, initial) {
     writeParam(ctx, dry.gain, 1 - mix, rampMs);
     writeParam(ctx, wet.gain, mix, rampMs);
   };
-  write();
+  initParam(ctx, dry.gain, 1 - mix);
+  initParam(ctx, wet.gain, mix);
   return {
     input,
     output,
@@ -1861,8 +2409,8 @@ function createDelayEffect(ctx, opts = {}) {
   const m = wetDry(ctx, delay, delay, opts.mix ?? 0.35);
   delay.connect(loop);
   loop.connect(delay);
-  writeParam(ctx, delay.delayTime, time / 1e3);
-  writeParam(ctx, loop.gain, fb);
+  initParam(ctx, delay.delayTime, time / 1e3);
+  initParam(ctx, loop.gain, fb);
   return {
     input: m.input,
     output: m.output,
@@ -1891,7 +2439,7 @@ function createCompressorEffect(ctx, opts = {}) {
   const makeup = ctx.createGain();
   compressor.connect(makeup);
   const set = (param, value) => {
-    if (value !== void 0) writeParam(ctx, param, value);
+    if (value !== void 0) initParam(ctx, param, value);
   };
   set(compressor.threshold, opts.threshold);
   set(compressor.knee, opts.knee);
@@ -2185,15 +2733,15 @@ function scoreBar(params, bar, opts = {}) {
 // src/score.ts
 function createScore(engine, opts) {
   const { mood: initial, onBar, ...barOpts } = opts;
-  let target = initial;
+  let target2 = initial;
   const stateAt = (bar, before) => {
-    const cue = readScoreCue(target);
+    const cue = readScoreCue(target2);
     return {
       bar,
       cueBar: before && before.cue.name === cue.name ? before.cueBar + 1 : 0,
-      mood: target,
+      mood: target2,
       cue,
-      params: scoreParams(target)
+      params: scoreParams(target2)
     };
   };
   const eventsOf = (state) => scoreBar(state.params, state.cueBar, barOpts);
@@ -2224,9 +2772,9 @@ function createScore(engine, opts) {
     },
     stop: () => player.stop(),
     playing: () => player.playing(),
-    mood: () => target,
+    mood: () => target2,
     setMood(mood) {
-      target = mood;
+      target2 = mood;
     },
     state: () => current
   };
@@ -2466,6 +3014,252 @@ function renderNoise(noise, sampleRate, random = Math.random) {
   return renderWhole(createNoiseKernel(noise, sampleRate, random), noise, sampleRate, "renderNoise");
 }
 
-export { SCORE_BAR_STEPS, biquadCoefficients, biquadResponseDb, createAnalyserTap, createAudioEngine, createBusGraph, createCompressorEffect, createDelayEffect, createFilterEffect, createNoiseKernel, createNoteKernel, createPatternPlayer, createReverbEffect, createScheduler, createScore, createSoundCache, createTickTimer, createVoicePool, envelopeLevel, envelopePoints, midiToFrequency, noiseSamples, noteToMidi, partialPresets, patternLength, patternVoicePeaks, readScoreCue, renderNoise, renderNote, resolveEnvelope, scoreBar, scoreChord, scoreCues, scoreModes, scoreParams, spatialize, toFrequency };
+// src/impulse.ts
+function mulberry32(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function impulseResponse(ctx, seconds, opts = {}) {
+  if (!(seconds > 0)) throw new RangeError(`@weasel-js/audio: impulse length ${seconds} s must be above 0`);
+  const decayDb = opts.decayDb ?? 60;
+  const channels = opts.channels ?? 2;
+  const seed = opts.seed ?? 1;
+  const length = Math.max(1, Math.round(seconds * ctx.sampleRate));
+  const buffer = ctx.createBuffer(channels, length, ctx.sampleRate);
+  const rate = decayDb / 20 * Math.LN10;
+  for (let c = 0; c < channels; c += 1) {
+    const data = buffer.getChannelData(c);
+    const rand = mulberry32(seed + c * 2654435761);
+    for (let i = 0; i < length; i += 1) {
+      data[i] = (rand() * 2 - 1) * Math.exp(-rate * i / length);
+    }
+  }
+  return buffer;
+}
+
+// src/graph/sources.ts
+function sourceShell(ctx, make) {
+  const output = ctx.createGain();
+  let live = null;
+  return {
+    output,
+    live: () => live,
+    /** `onEnd` runs if the node ends while it is still the live one: it played out. */
+    begin(when, setup, offset, onEnd) {
+      const node = make();
+      setup(node);
+      node.connect(output);
+      node.onended = () => {
+        if (live !== node) return;
+        live = null;
+        node.disconnect();
+        onEnd?.();
+      };
+      if (offset === void 0) node.start(when);
+      else node.start(when, offset);
+      live = node;
+      return node;
+    },
+    end(when) {
+      if (!live) return;
+      const node = live;
+      live = null;
+      node.onended = () => node.disconnect();
+      node.stop(when);
+    },
+    dispose() {
+      if (live) {
+        live.stop();
+        live.disconnect();
+        live = null;
+      }
+      output.disconnect();
+    },
+    level: (value, rampMs) => writeParam(ctx, output.gain, value, rampMs)
+  };
+}
+function createFileSourceNode(ctx, opts) {
+  const { buffer } = opts;
+  const loop = opts.loop ?? true;
+  let rate = 1;
+  let offset = 0;
+  let startedAt = 0;
+  const shell = sourceShell(ctx, () => ctx.createBufferSource());
+  const advance = (to) => {
+    const next = offset + Math.max(0, to - startedAt) * rate;
+    offset = loop ? next % buffer.duration : Math.min(next, buffer.duration);
+    startedAt = to;
+  };
+  return {
+    inputs: {},
+    output: shell.output,
+    params: {
+      rate(value, rampMs) {
+        const src = shell.live();
+        if (src) {
+          advance(ctx.currentTime);
+          writeParam(ctx, src.playbackRate, value, rampMs);
+        }
+        rate = value;
+      },
+      level: shell.level
+    },
+    start(when) {
+      if (shell.live()) return;
+      startedAt = when;
+      shell.begin(when, (s) => {
+        s.buffer = buffer;
+        s.loop = loop;
+        initParam(ctx, s.playbackRate, rate);
+      }, offset, () => {
+        offset = 0;
+      });
+    },
+    stop(when) {
+      if (!shell.live()) return;
+      advance(when);
+      shell.end(when);
+    },
+    dispose: shell.dispose
+  };
+}
+function createOscillatorNode(ctx, opts) {
+  const wave = opts.wave ?? "sine";
+  let frequency = opts.frequency ?? 440;
+  let detune = 0;
+  const shell = sourceShell(ctx, () => ctx.createOscillator());
+  return {
+    inputs: {},
+    output: shell.output,
+    params: {
+      frequency(value, rampMs) {
+        const osc = shell.live();
+        if (osc) writeParam(ctx, osc.frequency, value, rampMs);
+        frequency = value;
+      },
+      detune(value, rampMs) {
+        const osc = shell.live();
+        if (osc) writeParam(ctx, osc.detune, value, rampMs);
+        detune = value;
+      },
+      level: shell.level
+    },
+    start(when) {
+      if (shell.live()) return;
+      shell.begin(when, (osc) => {
+        if (typeof wave === "string") osc.type = wave;
+        else osc.setPeriodicWave(periodicWave(ctx, wave));
+        initParam(ctx, osc.frequency, frequency);
+        initParam(ctx, osc.detune, detune);
+      });
+    },
+    stop: shell.end,
+    dispose: shell.dispose
+  };
+}
+function createNoiseNode(ctx, opts) {
+  const shell = sourceShell(ctx, () => ctx.createBufferSource());
+  return {
+    inputs: {},
+    output: shell.output,
+    params: { level: shell.level },
+    start(when) {
+      if (shell.live()) return;
+      shell.begin(when, (src) => {
+        src.buffer = noiseBuffer(ctx, opts.color);
+        src.loop = true;
+      });
+    },
+    stop: shell.end,
+    dispose: shell.dispose
+  };
+}
+
+// src/graph/processors.ts
+function createGainNode(ctx, opts = {}) {
+  const node = ctx.createGain();
+  initParam(ctx, node.gain, opts.gain ?? 1);
+  return {
+    inputs: { in: node },
+    output: node,
+    params: { gain: (value, rampMs) => writeParam(ctx, node.gain, value, rampMs) }
+  };
+}
+function createPanNode(ctx, opts = {}) {
+  const node = ctx.createStereoPanner();
+  initParam(ctx, node.pan, opts.pan ?? 0);
+  return {
+    inputs: { in: node },
+    output: node,
+    params: { pan: (value, rampMs) => writeParam(ctx, node.pan, value, rampMs) }
+  };
+}
+function createMixNode(ctx, opts) {
+  if (opts.inputs.length === 0) throw new RangeError("@weasel-js/audio: a mix needs at least one input");
+  const output = ctx.createGain();
+  const inputs = {};
+  const params = {};
+  for (const name of opts.inputs) {
+    if (Object.prototype.hasOwnProperty.call(inputs, name)) {
+      throw new RangeError(`@weasel-js/audio: a mix has two inputs named "${name}"`);
+    }
+    const level = ctx.createGain();
+    level.connect(output);
+    inputs[name] = level;
+    params[name] = (value, rampMs) => writeParam(ctx, level.gain, value, rampMs);
+  }
+  return { inputs, output, params };
+}
+function insertNode(effect, params) {
+  return {
+    inputs: { in: effect.input },
+    output: effect.output,
+    params,
+    ...effect.dispose ? { dispose: () => effect.dispose() } : {}
+  };
+}
+function filterNode(ctx, opts = {}) {
+  const { filter } = createFilterEffect(ctx, opts);
+  const write = (p) => (value, rampMs) => writeParam(ctx, p, value, rampMs);
+  return insertNode({ input: filter, output: filter }, {
+    frequency: write(filter.frequency),
+    Q: write(filter.Q),
+    gain: write(filter.gain)
+  });
+}
+function delayNode(ctx, opts = {}) {
+  const fx = createDelayEffect(ctx, { ...opts, maxTime: opts.maxTime ?? Math.max(2e3, opts.time ?? 0) });
+  return insertNode(fx, {
+    time: (value, rampMs) => fx.setTime(value, rampMs),
+    feedback: (value, rampMs) => fx.setFeedback(value, rampMs),
+    mix: (value, rampMs) => fx.setMix(value, rampMs)
+  });
+}
+function reverbNode(ctx, opts = {}) {
+  const { seconds, impulse, ...rest } = opts;
+  const fx = createReverbEffect(ctx, { ...rest, impulse: impulse ?? impulseResponse(ctx, seconds ?? 2) });
+  return insertNode(fx, { mix: (value, rampMs) => fx.setMix(value, rampMs) });
+}
+function compressorNode(ctx, opts = {}) {
+  const fx = createCompressorEffect(ctx, opts);
+  const { compressor, makeup } = fx;
+  const write = (p, scale = 1) => (value, rampMs) => writeParam(ctx, p, value * scale, rampMs);
+  return insertNode(fx, {
+    threshold: write(compressor.threshold),
+    knee: write(compressor.knee),
+    ratio: write(compressor.ratio),
+    attack: write(compressor.attack, 1e-3),
+    release: write(compressor.release, 1e-3),
+    makeup: write(makeup.gain)
+  });
+}
+
+export { SCORE_BAR_STEPS, biquadCoefficients, biquadResponseDb, compressorNode, createAnalyserTap, createAudioEngine, createAudioGraph, createBusGraph, createCompressorEffect, createDelayEffect, createFileSourceNode, createFilterEffect, createGainNode, createMixNode, createNoiseKernel, createNoiseNode, createNoteKernel, createOscillatorNode, createPanNode, createPatternPlayer, createReverbEffect, createScheduler, createScore, createSoundCache, createTickTimer, createVoicePool, delayNode, envelopeLevel, envelopePoints, filterNode, impulseResponse, insertNode, midiToFrequency, noiseSamples, noteToMidi, partialPresets, patternLength, patternVoicePeaks, readScoreCue, renderNoise, renderNote, resolveEnvelope, reverbNode, scoreBar, scoreChord, scoreCues, scoreModes, scoreParams, spatialize, toFrequency };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map