@weasel-js/audio 1.10.1 → 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,553 @@ 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;
+  let suspendedSince = false;
+  let staleFloor = -Infinity;
+  const gestures = ["pointerdown", "pointerup", "touchend", "click", "keydown"];
+  const onGesture = () => {
+    void hooks.unlock().catch(() => void 0);
+  };
+  const arm = () => {
+    if (typeof window === "undefined") return;
+    for (const g of gestures) window.addEventListener(g, onGesture, { passive: true });
+  };
+  const disarm = () => {
+    if (typeof window === "undefined") return;
+    for (const g of gestures) window.removeEventListener(g, onGesture);
+  };
+  if (ctx.state !== "running") arm();
+  const onStateChange = () => {
+    if (disposed) return;
+    if (ctx.state === "running") {
+      disarm();
+      if (suspendedSince) staleFloor = hooks.now();
+      suspendedSince = false;
+      return;
+    }
+    suspendedSince = true;
+    hooks.onSuspend();
+    arm();
+  };
+  ctx.addEventListener("statechange", onStateChange);
+  return {
+    staleFloor: () => staleFloor,
+    dispose() {
+      disposed = true;
+      disarm();
+      ctx.removeEventListener("statechange", onStateChange);
+    }
+  };
+}
+
 // src/scheduler.ts
 function createScheduler(opts) {
   const lookahead = opts.lookahead ?? 100;
@@ -433,9 +984,9 @@ function createScheduler(opts) {
       opts.clearTimer(handle);
       handle = null;
     },
-    schedule(when, fire, key) {
+    schedule(when, fire, key, entryOpts) {
       const waited = when > opts.now() + lookahead;
-      queue.push({ when, fire, key, waited });
+      queue.push({ when, fire, key, waited: waited && entryOpts?.reportLate !== false });
       if (running && !flushQueued && !waited) {
         flushQueued = true;
         queueMicrotask(flush);
@@ -462,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;
@@ -486,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) {
@@ -495,114 +1046,83 @@ function createSoundCache(ctx, fetchFn = fetch) {
     register: (buffer) => store(buffer),
     buffer: (handle) => buffers.get(handle.id) ?? null
   };
-  return cache;
-}
-
-// src/spatialize.ts
-function spatialize(source, listener, opts = {}) {
-  const refDistance = opts.refDistance ?? 1;
-  const maxDistance = opts.maxDistance ?? 1e4;
-  const rolloff = opts.rolloff ?? "inverse";
-  const rolloffFactor = opts.rolloffFactor ?? 1;
-  const panWidth = opts.panWidth ?? 500;
-  const dx = source.x - listener.x;
-  const dy = source.y - listener.y;
-  const distance = Math.hypot(dx, dy);
-  let gain;
-  if (distance <= refDistance) {
-    gain = 1;
-  } else if (rolloff === "linear") {
-    const span = maxDistance - refDistance;
-    gain = span <= 0 ? 0 : 1 - rolloffFactor * ((distance - refDistance) / span);
-  } else {
-    gain = refDistance / (refDistance + rolloffFactor * (distance - refDistance));
-  }
-  gain = Math.min(1, Math.max(0, gain));
-  const pan = panWidth <= 0 ? 0 : Math.min(1, Math.max(-1, dx / panWidth));
-  return { gain, pan };
+  return cache2;
 }
 
-// src/tickTimer.ts
-var WORKER_SOURCE = `const timers = new Map();
-self.onmessage = (e) => {
-  const id = e.data.id;
-  clearTimeout(timers.get(id));
-  timers.delete(id);
-  if (e.data.ms === undefined) return;
-  timers.set(id, setTimeout(() => {
-    timers.delete(id);
-    self.postMessage(id);
-  }, e.data.ms));
-};
-`;
-function spawn() {
-  if (typeof Worker !== "function" || typeof Blob !== "function" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
-    return null;
-  }
-  let url;
-  try {
-    url = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: "text/javascript" }));
-    return { worker: new Worker(url), url };
-  } catch {
-    if (url !== void 0) URL.revokeObjectURL(url);
-    return null;
-  }
-}
-function createTickTimer() {
-  let nextId = 1;
-  const pending = /* @__PURE__ */ new Map();
-  let spawned = spawn();
-  const fire = (id) => {
-    const p = pending.get(id);
-    if (!p) return;
-    pending.delete(id);
-    p.cb();
-  };
-  const arm = (id, p) => {
-    p.fallback = setTimeout(() => fire(id), p.ms);
-  };
-  const release = () => {
-    if (!spawned) return;
-    spawned.worker.terminate();
-    URL.revokeObjectURL(spawned.url);
-    spawned = null;
-  };
-  if (spawned) {
-    spawned.worker.addEventListener("message", (e) => fire(e.data));
-    spawned.worker.addEventListener("error", () => {
-      if (!spawned) return;
-      release();
-      for (const [id, p] of pending) arm(id, p);
-    });
-  }
-  return {
-    setTimer(cb, ms) {
-      const id = nextId++;
-      const p = { cb, ms };
-      pending.set(id, p);
-      if (spawned) spawned.worker.postMessage({ id, ms });
-      else arm(id, p);
-      return id;
-    },
-    clearTimer(handle) {
-      const id = handle;
-      const p = pending.get(id);
-      if (!p) return;
-      pending.delete(id);
-      if (p.fallback !== void 0) clearTimeout(p.fallback);
-      else spawned?.worker.postMessage({ id });
+// src/streamStarter.ts
+function mediaSource(ctx, timers, el, node, into) {
+  let ended = false;
+  let cancelWait = null;
+  const finish = () => {
+    if (ended) return;
+    ended = true;
+    cancelWait?.();
+    el.pause();
+    el.removeEventListener("ended", finish);
+    el.removeEventListener("error", finish);
+    queueMicrotask(() => shim.onended?.());
+  };
+  const shim = {
+    onended: null,
+    stop(when) {
+      if (ended) return;
+      cancelWait?.();
+      cancelWait = when !== void 0 && when > ctx.currentTime ? atAudioTime(ctx, timers, when, finish) : null;
+      if (!cancelWait) finish();
     },
-    dispose() {
-      for (const p of pending.values()) {
-        if (p.fallback !== void 0) clearTimeout(p.fallback);
+    disconnect() {
+      try {
+        node.disconnect(into);
+      } catch {
       }
-      pending.clear();
-      release();
     }
   };
+  el.addEventListener("ended", finish);
+  el.addEventListener("error", finish);
+  el.play().catch((err) => {
+    if (ended) return;
+    console.warn(`@weasel-js/audio: a stream would not start \u2014 ${String(err)}`);
+    finish();
+  });
+  return shim;
 }
-
-// src/envelope.ts
+function createStreamStarters(ctx, timers) {
+  const mediaSources = /* @__PURE__ */ new WeakMap();
+  return {
+    element(media, opts) {
+      if (typeof media !== "string") return media;
+      const el = new Audio();
+      if (opts.crossOrigin !== void 0) el.crossOrigin = opts.crossOrigin;
+      el.preload = "auto";
+      el.src = media;
+      return el;
+    },
+    starter(el, opts) {
+      return {
+        ready: () => true,
+        start(voice) {
+          let node = mediaSources.get(el);
+          if (!node) {
+            node = ctx.createMediaElementSource(el);
+            mediaSources.set(el, node);
+          }
+          el.loop = opts.loop ?? false;
+          if (opts.offset !== void 0) el.currentTime = opts.offset / 1e3;
+          voice.retune = () => {
+            el.playbackRate = voice.rate;
+          };
+          voice.retune();
+          const into = voice.out.input;
+          node.connect(into);
+          return mediaSource(ctx, timers, el, node, into);
+        }
+      };
+    },
+    streaming: /* @__PURE__ */ new WeakMap()
+  };
+}
+
+// src/envelope.ts
 function resolveEnvelope(env = {}) {
   return {
     attack: Math.max(0, env.attack ?? 5),
@@ -635,6 +1155,46 @@ 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() {
+    return nodes[0].onended;
+  },
+  set onended(fn) {
+    nodes[0].onended = fn;
+  },
+  stop(when) {
+    for (const n of nodes) {
+      try {
+        n.stop(when);
+      } catch {
+      }
+    }
+  },
+  disconnect() {
+    for (const n of nodes) n.disconnect();
+  }
+});
+
 // src/pitch.ts
 function midiToFrequency(midi) {
   return 440 * 2 ** ((midi - 69) / 12);
@@ -740,6 +1300,14 @@ function resolvePartials(wave) {
     decay: p.decay
   }));
 }
+function resolveNote(note) {
+  const wave = note.wave ?? "sine";
+  return {
+    from: toFrequency(note.pitch),
+    glideTo: note.glide ? toFrequency(note.glide.to) : void 0,
+    partials: isInharmonic(wave) ? resolvePartials(wave) : null
+  };
+}
 function envelopeOnParam(param, env, gate, t0, map) {
   const [first, ...rest] = envelopePoints(env, gate);
   param.setValueAtTime(map(first.value), t0);
@@ -808,6 +1376,409 @@ var partialPresets = {
   }
 };
 
+// src/synthStarters.ts
+function synthStart(ctx, voice, whenMs, patch, make) {
+  const t0 = whenMs / 1e3;
+  const env = resolveEnvelope(patch.envelope);
+  const gate = patch.duration;
+  const shaper = ctx.createGain();
+  const amp = envelopeOnParam(shaper.gain, env, gate, t0, (v) => v);
+  const filter = patch.filter ? voiceFilter(ctx, patch.filter, gate, t0) : null;
+  filter?.node.connect(shaper);
+  shaper.connect(voice.out.input);
+  voice.env = shaper;
+  const { nodes, retune } = make(t0, filter?.node ?? shaper);
+  voice.retune = retune;
+  retune();
+  const stopAll = (at) => {
+    for (const n of nodes) n.stop(at);
+  };
+  voice.release = () => {
+    const at = ctx.currentTime;
+    if (gate !== void 0 && at * 1e3 - whenMs >= gate) return;
+    amp.release(at);
+    filter?.release(at);
+    stopAll(at + env.release / 1e3);
+  };
+  if (gate !== void 0) stopAll(t0 + (gate + env.release) / 1e3);
+  return nodes.length === 1 ? nodes[0] : sourceGroup(nodes);
+}
+function noteOscillators(ctx, note, { from, glideTo, partials }, applyWave, t0, into) {
+  const wave = note.wave ?? "sine";
+  const tone = (ratio) => {
+    const osc = ctx.createOscillator();
+    osc.frequency.setValueAtTime(from * ratio, t0);
+    if (glideTo !== void 0) {
+      const end = t0 + (note.glide.ms ?? note.duration ?? 100) / 1e3;
+      if (note.glide.curve === "linear") osc.frequency.linearRampToValueAtTime(glideTo * ratio, end);
+      else osc.frequency.exponentialRampToValueAtTime(glideTo * ratio, end);
+    }
+    return osc;
+  };
+  let oscs;
+  if (partials) {
+    oscs = partials.map((p) => {
+      const osc = tone(p.ratio);
+      const level = ctx.createGain();
+      level.gain.setValueAtTime(p.gain, t0);
+      if (p.decay !== void 0) level.gain.setTargetAtTime(0, t0, p.decay / 1e3);
+      osc.connect(level);
+      level.connect(into);
+      return osc;
+    });
+  } else {
+    const osc = tone(1);
+    applyWave(osc, wave);
+    osc.connect(into);
+    oscs = [osc];
+  }
+  for (const osc of oscs) osc.start(t0);
+  return oscs;
+}
+function createSynthStarters(ctx, random) {
+  const applyWave = (osc, wave) => {
+    if (typeof wave === "string") {
+      osc.type = wave;
+      return;
+    }
+    osc.setPeriodicWave(periodicWave(ctx, wave));
+  };
+  return {
+    note(note) {
+      const resolved = resolveNote(note);
+      return {
+        ready: () => true,
+        start: (voice, whenMs) => synthStart(ctx, voice, whenMs, note, (t0, into) => {
+          const oscs = noteOscillators(ctx, note, resolved, applyWave, t0, into);
+          return {
+            nodes: oscs,
+            retune: () => {
+              for (const osc of oscs) osc.detune.value = voice.detune + 1200 * Math.log2(voice.rate);
+            }
+          };
+        })
+      };
+    },
+    noise(noise) {
+      return {
+        ready: () => true,
+        start: (voice, whenMs) => synthStart(ctx, voice, whenMs, noise, (t0, into) => {
+          const source = ctx.createBufferSource();
+          source.buffer = noiseBuffer(ctx, noise.noise);
+          source.loop = true;
+          source.connect(into);
+          source.start(t0, random() * source.buffer.duration);
+          return {
+            nodes: [source],
+            retune: () => {
+              source.playbackRate.value = voice.rate;
+              source.detune.value = voice.detune;
+            }
+          };
+        })
+      };
+    }
+  };
+}
+
+// src/worklet/loadVoiceProcessor.ts
+var loads = /* @__PURE__ */ new WeakMap();
+function loadVoiceProcessor(ctx) {
+  let load = loads.get(ctx);
+  if (!load) {
+    load = (async () => {
+      if (!ctx.audioWorklet) throw new Error("@weasel-js/audio: this context has no audioWorklet");
+      const { voiceProcessorSource } = await import('./voiceProcessor.gen-KWFGBRBP.js');
+      const url = URL.createObjectURL(new Blob([voiceProcessorSource], { type: "text/javascript" }));
+      try {
+        await ctx.audioWorklet.addModule(url);
+      } finally {
+        URL.revokeObjectURL(url);
+      }
+    })();
+    loads.set(ctx, load);
+  }
+  return load;
+}
+
+// src/worklet/protocol.ts
+var VOICE_PROCESSOR = "weasel-voices";
+
+// src/worklet/workletVoices.ts
+function workletSource(post, id) {
+  let onended = null;
+  let ended = false;
+  const fire = () => {
+    onended?.();
+  };
+  return {
+    get onended() {
+      return onended;
+    },
+    set onended(fn) {
+      onended = fn;
+      if (ended) queueMicrotask(fire);
+    },
+    stop(when) {
+      post({ kind: "stop", id, at: when ?? 0 });
+    },
+    disconnect() {
+    },
+    end() {
+      if (ended) return;
+      ended = true;
+      fire();
+    }
+  };
+}
+function workletOut(ctx, post, id) {
+  return {
+    input: null,
+    level(value, rampMs) {
+      post({ kind: "level", id, value, end: rampMs && rampMs > 0 ? ctx.currentTime + rampMs / 1e3 : 0 });
+    },
+    pan(value) {
+      post({ kind: "pan", id, value });
+    },
+    free() {
+    },
+    abandon() {
+    }
+  };
+}
+function createWorkletVoices(ctx, busInput, random) {
+  let ready = false;
+  const loaded = loadVoiceProcessor(ctx).then(
+    () => {
+      ready = true;
+    },
+    (err) => {
+      console.warn(`@weasel-js/audio: the voice worklet did not load, so synth voices stay on nodes \u2014 ${String(err)}`);
+    }
+  );
+  const buses = /* @__PURE__ */ new Map();
+  const busFor = (name) => {
+    let bus = buses.get(name);
+    if (!bus) {
+      const node = new AudioWorkletNode(ctx, VOICE_PROCESSOR, {
+        numberOfInputs: 0,
+        numberOfOutputs: 1,
+        outputChannelCount: [2]
+      });
+      const sources = /* @__PURE__ */ new Map();
+      node.port.onmessage = (e) => {
+        const source = sources.get(e.data.id);
+        sources.delete(e.data.id);
+        source?.end();
+      };
+      node.connect(busInput(name));
+      bus = { node, sources };
+      buses.set(name, bus);
+    }
+    return bus;
+  };
+  const starter = (event) => {
+    let source = null;
+    let post = () => {
+    };
+    return {
+      ready: () => true,
+      book(voice, at) {
+        const bus = busFor(at.bus);
+        post = (e) => {
+          bus.node.port.postMessage(e);
+        };
+        post(event(voice, at.when / 1e3, at.level, at.pan));
+        source = workletSource(post, voice.id);
+        bus.sources.set(voice.id, source);
+        voice.retune = () => {
+          post({ kind: "retune", id: voice.id, rate: voice.rate, detune: voice.detune });
+        };
+        return {
+          out: workletOut(ctx, post, voice.id),
+          cancel: () => {
+            post({ kind: "stop", id: voice.id, at: 0 });
+          }
+        };
+      },
+      start(voice) {
+        voice.release = () => {
+          post({ kind: "release", id: voice.id });
+        };
+        return source;
+      }
+    };
+  };
+  return {
+    ready: () => ready,
+    loaded,
+    note(note) {
+      resolveNote(note);
+      const patch = {
+        pitch: note.pitch,
+        wave: note.wave,
+        envelope: note.envelope,
+        glide: note.glide,
+        filter: note.filter,
+        duration: note.duration
+      };
+      return starter((voice, at, level, pan) => ({
+        kind: "note",
+        id: voice.id,
+        at,
+        level,
+        pan,
+        rate: voice.rate,
+        detune: voice.detune,
+        patch
+      }));
+    },
+    noise(noise) {
+      const patch = { noise: noise.noise, envelope: noise.envelope, filter: noise.filter, duration: noise.duration };
+      return starter((voice, at, level, pan) => ({
+        kind: "noise",
+        id: voice.id,
+        at,
+        level,
+        pan,
+        rate: voice.rate,
+        detune: voice.detune,
+        patch,
+        // A random point in the loop, so two hits in a row are not the same hit.
+        seed: random()
+      }));
+    },
+    dispose() {
+      for (const bus of buses.values()) {
+        bus.node.port.postMessage({ kind: "dispose" });
+        bus.node.port.onmessage = null;
+        bus.node.disconnect();
+      }
+      buses.clear();
+    }
+  };
+}
+
+// src/tickTimer.ts
+var WORKER_SOURCE = `const timers = new Map();
+self.onmessage = (e) => {
+  const id = e.data.id;
+  clearTimeout(timers.get(id));
+  timers.delete(id);
+  if (e.data.ms === undefined) return;
+  timers.set(id, setTimeout(() => {
+    timers.delete(id);
+    self.postMessage(id);
+  }, e.data.ms));
+};
+`;
+function spawn() {
+  if (typeof Worker !== "function" || typeof Blob !== "function" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+    return null;
+  }
+  let url;
+  try {
+    url = URL.createObjectURL(new Blob([WORKER_SOURCE], { type: "text/javascript" }));
+    return { worker: new Worker(url), url };
+  } catch {
+    if (url !== void 0) URL.revokeObjectURL(url);
+    return null;
+  }
+}
+function createTickTimer() {
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  let spawned = spawn();
+  const fire = (id) => {
+    const p = pending.get(id);
+    if (!p) return;
+    pending.delete(id);
+    p.cb();
+  };
+  const arm = (id, p) => {
+    p.fallback = setTimeout(() => fire(id), p.ms);
+  };
+  const release = () => {
+    if (!spawned) return;
+    spawned.worker.terminate();
+    URL.revokeObjectURL(spawned.url);
+    spawned = null;
+  };
+  if (spawned) {
+    spawned.worker.addEventListener("message", (e) => fire(e.data));
+    spawned.worker.addEventListener("error", () => {
+      if (!spawned) return;
+      release();
+      for (const [id, p] of pending) arm(id, p);
+    });
+  }
+  return {
+    setTimer(cb, ms) {
+      const id = nextId++;
+      const p = { cb, ms };
+      pending.set(id, p);
+      if (spawned) spawned.worker.postMessage({ id, ms });
+      else arm(id, p);
+      return id;
+    },
+    clearTimer(handle) {
+      const id = handle;
+      const p = pending.get(id);
+      if (!p) return;
+      pending.delete(id);
+      if (p.fallback !== void 0) clearTimeout(p.fallback);
+      else spawned?.worker.postMessage({ id });
+    },
+    dispose() {
+      for (const p of pending.values()) {
+        if (p.fallback !== void 0) clearTimeout(p.fallback);
+      }
+      pending.clear();
+      release();
+    }
+  };
+}
+
+// src/voiceChains.ts
+function createChainPool(ctx, limit) {
+  const idle = [];
+  const newChain = () => {
+    const chain = { gain: ctx.createGain(), panner: ctx.createStereoPanner() };
+    chain.panner.connect(chain.gain);
+    return chain;
+  };
+  return {
+    take(bus, gain, pan) {
+      const chain = idle.pop() ?? newChain();
+      const { gain: amp, panner } = chain;
+      writeParam(ctx, amp.gain, gain);
+      panner.pan.value = pan;
+      amp.connect(bus);
+      let held = true;
+      return {
+        input: panner,
+        level: (value, rampMs) => writeParam(ctx, amp.gain, value, rampMs),
+        pan: (value) => {
+          panner.pan.value = value;
+        },
+        free() {
+          if (!held) return;
+          held = false;
+          amp.disconnect();
+          if (idle.length < limit) idle.push(chain);
+        },
+        abandon() {
+          held = false;
+          amp.disconnect();
+        }
+      };
+    },
+    clear() {
+      idle.length = 0;
+    }
+  };
+}
+
 // src/voiceDrops.ts
 var reportDrop = (onDrop, reason) => {
   if (onDrop) queueMicrotask(() => onDrop(reason));
@@ -891,35 +1862,304 @@ function createVoicePool(opts) {
   };
 }
 
-// src/createAudioEngine.ts
-var sourceGroup = (nodes) => ({
-  get onended() {
-    return nodes[0].onended;
+// src/spatialize.ts
+function spatialize(source, listener, opts = {}) {
+  const refDistance = opts.refDistance ?? 1;
+  const maxDistance = opts.maxDistance ?? 1e4;
+  const rolloff = opts.rolloff ?? "inverse";
+  const rolloffFactor = opts.rolloffFactor ?? 1;
+  const panWidth = opts.panWidth ?? 500;
+  const dx = source.x - listener.x;
+  const dy = source.y - listener.y;
+  const distance = Math.hypot(dx, dy);
+  let gain;
+  if (distance <= refDistance) {
+    gain = 1;
+  } else if (rolloff === "linear") {
+    const span = maxDistance - refDistance;
+    gain = span <= 0 ? 0 : 1 - rolloffFactor * ((distance - refDistance) / span);
+  } else {
+    gain = refDistance / (refDistance + rolloffFactor * (distance - refDistance));
+  }
+  gain = Math.min(1, Math.max(0, gain));
+  const pan = panWidth <= 0 ? 0 : Math.min(1, Math.max(-1, dx / panWidth));
+  return { gain, pan };
+}
+
+// src/voices.ts
+var dropped = (id) => ({
+  id,
+  stop: () => {
   },
-  set onended(fn) {
-    nodes[0].onended = fn;
+  release: () => {
   },
-  stop(when) {
-    for (const n of nodes) {
-      try {
-        n.stop(when);
-      } catch {
-      }
-    }
+  setGain: () => {
   },
-  disconnect() {
-    for (const n of nodes) n.disconnect();
-  }
+  setRate: () => {
+  },
+  setDetune: () => {
+  },
+  setPan: () => {
+  },
+  setPosition: () => {
+  },
+  isPlaying: () => false
 });
-function createAudioEngine(opts = {}) {
-  const ctx = opts.context ?? new AudioContext();
-  const ownsContext = opts.context === void 0;
-  const random = opts.random ?? Math.random;
-  const busNames = opts.buses ?? ["sfx", "music", "ui"];
-  if (busNames.length === 0) {
-    throw new Error("@weasel-js/audio: an engine needs at least one bus");
+function teardownVoice(voice, reason, live) {
+  voice.canceled = true;
+  if (!voice.playing && voice.source === null) return;
+  voice.playing = false;
+  if (voice.source === null) {
+    voice.unbook?.();
+    reportDrop(voice.onDrop, reason);
   }
-  const sounds = createSoundCache(ctx, opts.fetchFn);
+  voice.unbook = null;
+  if (voice.source) {
+    try {
+      voice.source.stop();
+    } catch {
+    }
+    voice.source.disconnect();
+  }
+  voice.source = null;
+  voice.retune = null;
+  voice.release = null;
+  voice.env?.disconnect();
+  voice.env = null;
+  voice.out?.free();
+  voice.out = null;
+  live.delete(voice.id);
+  if (voice.slot !== null) {
+    voice.slots.byToken.delete(voice.token);
+    voice.slots.pool.release(voice.slot, voice.token);
+  }
+}
+function startVoice(voice, starter, bookedAt, scheduledWhen, onDone, staleFloor, teardown) {
+  if (voice.canceled || voice.source !== null) return;
+  const booked = voice.unbook !== null;
+  if (!booked && bookedAt < staleFloor && scheduledWhen < staleFloor) {
+    teardown(voice, "stale");
+    return;
+  }
+  if (!starter.ready()) {
+    teardown(voice, "unready");
+    return;
+  }
+  const { slots } = voice;
+  const acquired = slots.pool.acquire({
+    startedAt: scheduledWhen,
+    gain: voice.baseGain * voice.spatialGain
+  });
+  voice.slot = acquired.slot;
+  voice.token = acquired.token;
+  slots.byToken.set(acquired.token, voice);
+  if (acquired.stolen !== null) {
+    const victim = slots.byToken.get(acquired.stolen);
+    if (victim) teardown(victim);
+  }
+  let source;
+  try {
+    source = starter.start(voice, scheduledWhen);
+  } catch (err) {
+    voice.out?.abandon();
+    voice.out = null;
+    teardown(voice, "failed");
+    throw err;
+  }
+  voice.unbook = null;
+  voice.catchUp = null;
+  source.onended = () => {
+    teardown(voice);
+    onDone?.();
+  };
+  voice.source = source;
+}
+function voiceHandle(ctx, voice, ops) {
+  const { teardown, applySpatial, poolGain } = ops;
+  return {
+    id: voice.id,
+    stop(fadeMs) {
+      voice.catchUp?.();
+      if (fadeMs && fadeMs > 0 && voice.source && voice.out && !voice.canceled) {
+        voice.canceled = true;
+        voice.fading = true;
+        voice.out.level(0, fadeMs);
+        try {
+          voice.source.stop(ctx.currentTime + fadeMs / 1e3);
+        } catch {
+        }
+        return;
+      }
+      teardown(voice);
+    },
+    release() {
+      if (voice.releasing) return;
+      voice.catchUp?.();
+      if (voice.release && voice.source && !voice.canceled) {
+        voice.releasing = true;
+        voice.canceled = true;
+        voice.release();
+        return;
+      }
+      teardown(voice);
+    },
+    setGain(value, rampMs) {
+      voice.baseGain = value;
+      if (!voice.out || voice.fading) return;
+      voice.rampEnd = rampMs && rampMs > 0 ? ctx.currentTime + rampMs / 1e3 : 0;
+      voice.out.level(value * voice.spatialGain, rampMs);
+      poolGain(voice);
+    },
+    setRate(value) {
+      voice.rate = value;
+      voice.retune?.();
+    },
+    setDetune(cents) {
+      voice.detune = cents;
+      voice.retune?.();
+    },
+    setPan(value) {
+      voice.position = void 0;
+      voice.out?.pan(value);
+    },
+    setPosition(p) {
+      voice.position = p;
+      applySpatial(voice);
+    },
+    isPlaying: () => voice.playing
+  };
+}
+function createVoices(deps) {
+  const { ctx, chains, warn } = deps;
+  const live = /* @__PURE__ */ new Map();
+  let nextVoiceId = 1;
+  const spatialOf = (p) => {
+    const l = deps.listener();
+    return spatialize(p, l.at, l.opts);
+  };
+  const poolGain = (voice) => {
+    if (voice.slot === null) return;
+    voice.slots.pool.setGain(voice.slot, voice.token, voice.baseGain * voice.spatialGain);
+  };
+  const applySpatial = (voice) => {
+    if (!voice.position || !voice.out) return;
+    const s = spatialOf(voice.position);
+    voice.spatialGain = s.gain;
+    voice.out.pan(s.pan);
+    if (!voice.fading) {
+      const left = (voice.rampEnd - ctx.currentTime) * 1e3;
+      voice.out.level(voice.baseGain * s.gain, left > 0 ? left : void 0);
+    }
+    poolGain(voice);
+  };
+  const teardown = (voice, reason = "stopped") => {
+    teardownVoice(voice, reason, live);
+  };
+  const ops = { teardown, applySpatial, poolGain };
+  return {
+    launch(common, starter) {
+      const id = nextVoiceId++;
+      if (deps.disposed()) {
+        warn.disposed();
+        reportDrop(common.onDrop, "disposed");
+        return dropped(id);
+      }
+      if (ctx.state !== "running") {
+        warn.locked();
+        reportDrop(common.onDrop, "locked");
+        return dropped(id);
+      }
+      const busName = common.bus ?? deps.defaultBus;
+      const slots = deps.slotsFor(busName);
+      const bookedAt = ctx.currentTime * 1e3;
+      const when = common.when ?? bookedAt;
+      const baseGain = common.gain ?? 1;
+      const spatial = common.position ? spatialOf(common.position) : { gain: 1, pan: common.pan ?? 0 };
+      const level = baseGain * spatial.gain;
+      const voice = {
+        id,
+        slots,
+        slot: null,
+        token: 0,
+        key: common.cancelKey,
+        onDrop: common.onDrop,
+        source: null,
+        env: null,
+        retune: null,
+        release: null,
+        releasing: false,
+        out: null,
+        unbook: null,
+        catchUp: null,
+        baseGain,
+        spatialGain: spatial.gain,
+        rate: common.rate ?? 1,
+        detune: common.detune ?? 0,
+        position: common.position,
+        playing: true,
+        canceled: false,
+        fading: false,
+        rampEnd: 0
+      };
+      if (starter.book) {
+        const booking = starter.book(voice, { bus: busName, when, level, pan: spatial.pan });
+        voice.out = booking.out;
+        voice.unbook = booking.cancel;
+      } else {
+        voice.out = chains.take(deps.busInput(busName), level, spatial.pan);
+      }
+      live.set(id, voice);
+      const begin = () => {
+        startVoice(voice, starter, bookedAt, when, common.onDone, deps.staleFloor(), teardown);
+      };
+      if (starter.book) {
+        voice.catchUp = () => {
+          if (ctx.currentTime * 1e3 >= when) begin();
+        };
+      }
+      deps.scheduler.schedule(when, begin, common.cancelKey, { reportLate: !starter.book });
+      return voiceHandle(ctx, voice, ops);
+    },
+    stopAll(reason) {
+      for (const voice of [...live.values()]) teardown(voice, reason);
+    },
+    stopKey(key) {
+      for (const voice of [...live.values()]) {
+        if (voice.key !== key) continue;
+        voice.catchUp?.();
+        teardown(voice);
+      }
+    },
+    respatialize() {
+      for (const voice of live.values()) applySpatial(voice);
+    }
+  };
+}
+
+// src/createAudioEngine.ts
+function bufferStarter(ctx, sounds, warn, sound, loop) {
+  return {
+    ready() {
+      if (sounds.buffer(sound)) return true;
+      warn.unknownSound(sound.id);
+      return false;
+    },
+    start(voice, when) {
+      const source = ctx.createBufferSource();
+      source.buffer = sounds.buffer(sound);
+      source.loop = loop;
+      voice.retune = () => {
+        source.playbackRate.value = voice.rate;
+        source.detune.value = voice.detune;
+      };
+      voice.retune();
+      source.connect(voice.out.input);
+      source.start(when / 1e3);
+      return source;
+    }
+  };
+}
+function busSlots(busNames, opts) {
   const slotsByBus = /* @__PURE__ */ new Map();
   for (const name of busNames) {
     slotsByBus.set(name, {
@@ -932,6 +2172,48 @@ function createAudioEngine(opts = {}) {
     if (!s) throw new Error(`@weasel-js/audio: unknown bus "${bus}"`);
     return s;
   };
+  const active = (bus) => {
+    if (bus !== void 0) return slotsFor(bus).pool.active();
+    let total = 0;
+    for (const s of slotsByBus.values()) total += s.pool.active();
+    return total;
+  };
+  return { slotsFor, active };
+}
+function engineSynth(ctx, opts, busInput) {
+  const random = opts.random ?? Math.random;
+  const nodes = createSynthStarters(ctx, random);
+  const worklet = opts.synthVoices === "worklet" ? createWorkletVoices(ctx, busInput, random) : null;
+  const pick = () => worklet?.ready() ? worklet : nodes;
+  return {
+    note: (note) => pick().note(note),
+    noise: (noise) => pick().noise(noise),
+    loaded: worklet?.loaded,
+    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;
   const timers = {
@@ -950,456 +2232,66 @@ function createAudioEngine(opts = {}) {
     onLate: opts.onLate
   });
   scheduler.start();
+  return { now, tickTimer, timers, scheduler };
+}
+function createAudioEngine(opts = {}) {
+  const ctx = opts.context ?? new AudioContext();
+  const ownsContext = opts.context === void 0;
+  const busNames = opts.buses ?? ["sfx", "music", "ui"];
+  if (busNames.length === 0) {
+    throw new Error("@weasel-js/audio: an engine needs at least one bus");
+  }
+  const sounds = createSoundCache(ctx, opts.fetchFn);
+  const { slotsFor, active } = busSlots(busNames, opts);
+  const { now, tickTimer, timers, scheduler } = engineClock(ctx, opts);
   const graph = createBusGraph(ctx, busNames, { ...timers, fadeMs: opts.insertFadeMs });
   let listener = { x: 0, y: 0 };
   let spatialOpts = {};
-  let nextVoiceId = 1;
   let disposed = false;
-  let suspendedSince = false;
-  let staleFloor = -Infinity;
-  const live = /* @__PURE__ */ new Map();
   const taps = /* @__PURE__ */ new Set();
-  const idleChains = [];
-  const idleChainLimit = (opts.voiceLimit ?? 32) * busNames.length;
-  const takeChain = (bus, gain, pan) => {
-    let chain = idleChains.pop();
-    if (!chain) {
-      chain = { gain: ctx.createGain(), panner: ctx.createStereoPanner() };
-      chain.panner.connect(chain.gain);
-    }
-    writeParam(ctx, chain.gain.gain, gain);
-    chain.panner.pan.value = pan;
-    chain.gain.connect(bus);
-    return chain;
-  };
+  const chains = createChainPool(ctx, (opts.voiceLimit ?? 32) * busNames.length);
   const warn = createDropWarnings();
-  const gestures = ["pointerdown", "pointerup", "touchend", "click", "keydown"];
-  const onGesture = () => {
-    void engine.unlock().catch(() => void 0);
-  };
-  const armGestures = () => {
-    if (typeof window === "undefined") return;
-    for (const g of gestures) window.addEventListener(g, onGesture, { passive: true });
-  };
-  const disarmGestures = () => {
-    if (typeof window === "undefined") return;
-    for (const g of gestures) window.removeEventListener(g, onGesture);
-  };
-  if (ctx.state !== "running") armGestures();
-  const onStateChange = () => {
-    if (disposed) return;
-    if (ctx.state === "running") {
-      disarmGestures();
-      if (suspendedSince) staleFloor = now();
-      suspendedSince = false;
-      return;
-    }
-    suspendedSince = true;
-    warn.rearmLocked();
-    armGestures();
-  };
-  ctx.addEventListener("statechange", onStateChange);
-  const poolGain = (voice) => {
-    if (voice.slot === null) return;
-    voice.slots.pool.setGain(voice.slot, voice.token, voice.baseGain * voice.spatialGain);
-  };
-  const applySpatial = (voice) => {
-    if (!voice.position || !voice.chain) return;
-    const s = spatialize(voice.position, listener, spatialOpts);
-    voice.spatialGain = s.gain;
-    voice.chain.panner.pan.value = s.pan;
-    if (!voice.fading) {
-      const left = (voice.rampEnd - ctx.currentTime) * 1e3;
-      writeParam(ctx, voice.chain.gain.gain, voice.baseGain * s.gain, left > 0 ? left : void 0);
-    }
-    poolGain(voice);
-  };
-  const teardown = (voice, reason = "stopped") => {
-    voice.cancelled = true;
-    if (!voice.playing && voice.source === null) return;
-    voice.playing = false;
-    if (voice.source === null) reportDrop(voice.onDrop, reason);
-    if (voice.source) {
-      try {
-        voice.source.stop();
-      } catch {
-      }
-      voice.source.disconnect();
-    }
-    voice.source = null;
-    voice.retune = null;
-    voice.release = null;
-    voice.env?.disconnect();
-    voice.env = null;
-    if (voice.chain) {
-      voice.chain.gain.disconnect();
-      if (idleChains.length < idleChainLimit) idleChains.push(voice.chain);
-      voice.chain = null;
-    }
-    live.delete(voice.id);
-    if (voice.slot !== null) {
-      voice.slots.byToken.delete(voice.token);
-      voice.slots.pool.release(voice.slot, voice.token);
-    }
-  };
-  const stopVoices = (reason) => {
-    for (const voice of [...live.values()]) teardown(voice, reason);
-  };
-  const dropped = (id) => ({
-    id,
-    stop: () => {
-    },
-    release: () => {
-    },
-    setGain: () => {
-    },
-    setRate: () => {
-    },
-    setDetune: () => {
-    },
-    setPan: () => {
-    },
-    setPosition: () => {
-    },
-    isPlaying: () => false
+  const watch = createResumeWatch(ctx, {
+    now,
+    unlock: () => engine.unlock(),
+    onSuspend: () => warn.rearmLocked()
   });
-  const launch = (common, starter) => {
-    const id = nextVoiceId++;
-    if (disposed) {
-      warn.disposed();
-      reportDrop(common.onDrop, "disposed");
-      return dropped(id);
-    }
-    if (ctx.state !== "running") {
-      warn.locked();
-      reportDrop(common.onDrop, "locked");
-      return dropped(id);
-    }
-    const busName = common.bus ?? busNames[0];
-    const slots = slotsFor(busName);
-    const bookedAt = now();
-    const when = common.when ?? bookedAt;
-    const baseGain = common.gain ?? 1;
-    const spatial = common.position ? spatialize(common.position, listener, spatialOpts) : { gain: 1, pan: common.pan ?? 0 };
-    const voice = {
-      id,
-      slots,
-      slot: null,
-      token: 0,
-      key: common.cancelKey,
-      onDrop: common.onDrop,
-      source: null,
-      env: null,
-      retune: null,
-      release: null,
-      releasing: false,
-      chain: takeChain(graph.input(busName), baseGain * spatial.gain, spatial.pan),
-      baseGain,
-      spatialGain: spatial.gain,
-      rate: common.rate ?? 1,
-      detune: common.detune ?? 0,
-      position: common.position,
-      playing: true,
-      cancelled: false,
-      fading: false,
-      rampEnd: 0
-    };
-    live.set(id, voice);
-    scheduler.schedule(when, (scheduledWhen) => {
-      if (voice.cancelled) return;
-      if (bookedAt < staleFloor && scheduledWhen < staleFloor) {
-        teardown(voice, "stale");
-        return;
-      }
-      if (!starter.ready()) {
-        teardown(voice, "unready");
-        return;
-      }
-      const acquired = slots.pool.acquire({
-        startedAt: scheduledWhen,
-        gain: voice.baseGain * voice.spatialGain
-      });
-      voice.slot = acquired.slot;
-      voice.token = acquired.token;
-      slots.byToken.set(acquired.token, voice);
-      if (acquired.stolen !== null) {
-        const victim = slots.byToken.get(acquired.stolen);
-        if (victim) teardown(victim);
-      }
-      let source;
-      try {
-        source = starter.start(voice, scheduledWhen);
-      } catch (err) {
-        voice.chain?.gain.disconnect();
-        voice.chain = null;
-        teardown(voice, "failed");
-        throw err;
-      }
-      source.onended = () => {
-        teardown(voice);
-        common.onDone?.();
-      };
-      voice.source = source;
-    }, common.cancelKey);
-    return {
-      id,
-      stop(fadeMs) {
-        if (fadeMs && fadeMs > 0 && voice.source && voice.chain && !voice.cancelled) {
-          voice.cancelled = true;
-          voice.fading = true;
-          writeParam(ctx, voice.chain.gain.gain, 0, fadeMs);
-          try {
-            voice.source.stop(ctx.currentTime + fadeMs / 1e3);
-          } catch {
-          }
-          return;
-        }
-        teardown(voice);
-      },
-      release() {
-        if (voice.releasing) return;
-        if (voice.release && voice.source && !voice.cancelled) {
-          voice.releasing = true;
-          voice.cancelled = true;
-          voice.release();
-          return;
-        }
-        teardown(voice);
-      },
-      setGain(value, rampMs) {
-        voice.baseGain = value;
-        if (!voice.chain || voice.fading) return;
-        voice.rampEnd = rampMs && rampMs > 0 ? ctx.currentTime + rampMs / 1e3 : 0;
-        writeParam(ctx, voice.chain.gain.gain, value * voice.spatialGain, rampMs);
-        poolGain(voice);
-      },
-      setRate(value) {
-        voice.rate = value;
-        voice.retune?.();
-      },
-      setDetune(cents) {
-        voice.detune = cents;
-        voice.retune?.();
-      },
-      setPan(value) {
-        voice.position = void 0;
-        if (voice.chain) voice.chain.panner.pan.value = value;
-      },
-      setPosition(p) {
-        voice.position = p;
-        applySpatial(voice);
-      },
-      isPlaying: () => voice.playing
-    };
-  };
-  const synthStart = (voice, whenMs, patch, make) => {
-    const t0 = whenMs / 1e3;
-    const env = resolveEnvelope(patch.envelope);
-    const gate = patch.duration;
-    const shaper = ctx.createGain();
-    const amp = envelopeOnParam(shaper.gain, env, gate, t0, (v) => v);
-    const filter = patch.filter ? voiceFilter(ctx, patch.filter, gate, t0) : null;
-    filter?.node.connect(shaper);
-    shaper.connect(voice.chain.panner);
-    voice.env = shaper;
-    const { nodes, retune } = make(t0, filter?.node ?? shaper);
-    voice.retune = retune;
-    retune();
-    const stopAll = (at) => {
-      for (const n of nodes) n.stop(at);
-    };
-    voice.release = () => {
-      const at = ctx.currentTime;
-      if (gate !== void 0 && at * 1e3 - whenMs >= gate) return;
-      amp.release(at);
-      filter?.release(at);
-      stopAll(at + env.release / 1e3);
-    };
-    if (gate !== void 0) stopAll(t0 + (gate + env.release) / 1e3);
-    return nodes.length === 1 ? nodes[0] : sourceGroup(nodes);
-  };
-  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);
-  };
-  const mediaSources = /* @__PURE__ */ new WeakMap();
-  const streaming = /* @__PURE__ */ new WeakMap();
-  const openMedia = (url, crossOrigin) => {
-    const el = new Audio();
-    if (crossOrigin !== void 0) el.crossOrigin = crossOrigin;
-    el.preload = "auto";
-    el.src = url;
-    return el;
-  };
-  const mediaSource = (el, node, into) => {
-    let ended = false;
-    let cancelWait = null;
-    const finish = () => {
-      if (ended) return;
-      ended = true;
-      cancelWait?.();
-      el.pause();
-      el.removeEventListener("ended", finish);
-      el.removeEventListener("error", finish);
-      queueMicrotask(() => shim.onended?.());
-    };
-    const shim = {
-      onended: null,
-      stop(when) {
-        if (ended) return;
-        cancelWait?.();
-        cancelWait = when !== void 0 && when > ctx.currentTime ? atAudioTime(ctx, timers, when, finish) : null;
-        if (!cancelWait) finish();
-      },
-      disconnect() {
-        try {
-          node.disconnect(into);
-        } catch {
-        }
-      }
-    };
-    el.addEventListener("ended", finish);
-    el.addEventListener("error", finish);
-    el.play().catch((err) => {
-      if (ended) return;
-      console.warn(`@weasel-js/audio: a stream would not start \u2014 ${String(err)}`);
-      finish();
-    });
-    return shim;
-  };
+  const voices = createVoices({
+    ctx,
+    scheduler,
+    chains,
+    slotsFor,
+    warn,
+    busInput: graph.input,
+    defaultBus: busNames[0],
+    staleFloor: watch.staleFloor,
+    disposed: () => disposed,
+    listener: () => ({ at: listener, opts: spatialOpts })
+  });
+  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,
     async unlock() {
       if (disposed) return;
       if (ctx.state !== "running") await ctx.resume();
+      await synth.loaded;
     },
     now,
     load: sounds.load,
     loadAll: sounds.loadAll,
     decode: sounds.decode,
     register: sounds.register,
-    play(sound, playOpts = {}) {
-      return launch(playOpts, {
-        ready() {
-          if (sounds.buffer(sound)) return true;
-          warn.unknownSound(sound.id);
-          return false;
-        },
-        start(voice, when) {
-          const source = ctx.createBufferSource();
-          source.buffer = sounds.buffer(sound);
-          source.loop = playOpts.loop ?? false;
-          voice.retune = () => {
-            source.playbackRate.value = voice.rate;
-            source.detune.value = voice.detune;
-          };
-          voice.retune();
-          source.connect(voice.chain.panner);
-          source.start(when / 1e3);
-          return source;
-        }
-      });
-    },
-    playNote(note) {
-      const from = toFrequency(note.pitch);
-      const glideTo = note.glide ? toFrequency(note.glide.to) : void 0;
-      const wave = note.wave ?? "sine";
-      const partials = isInharmonic(wave) ? resolvePartials(wave) : null;
-      return launch(note, {
-        ready: () => true,
-        start: (voice, whenMs) => synthStart(voice, whenMs, note, (t0, into) => {
-          const tone = (ratio) => {
-            const osc = ctx.createOscillator();
-            osc.frequency.setValueAtTime(from * ratio, t0);
-            if (glideTo !== void 0) {
-              const end = t0 + (note.glide.ms ?? note.duration ?? 100) / 1e3;
-              if (note.glide.curve === "linear") osc.frequency.linearRampToValueAtTime(glideTo * ratio, end);
-              else osc.frequency.exponentialRampToValueAtTime(glideTo * ratio, end);
-            }
-            return osc;
-          };
-          let oscs;
-          if (partials) {
-            oscs = partials.map((p) => {
-              const osc = tone(p.ratio);
-              const level = ctx.createGain();
-              level.gain.setValueAtTime(p.gain, t0);
-              if (p.decay !== void 0) level.gain.setTargetAtTime(0, t0, p.decay / 1e3);
-              osc.connect(level);
-              level.connect(into);
-              return osc;
-            });
-          } else {
-            const osc = tone(1);
-            applyWave(osc, wave);
-            osc.connect(into);
-            oscs = [osc];
-          }
-          for (const osc of oscs) osc.start(t0);
-          return {
-            nodes: oscs,
-            retune: () => {
-              for (const osc of oscs) osc.detune.value = voice.detune + 1200 * Math.log2(voice.rate);
-            }
-          };
-        })
-      });
-    },
-    playNoise(noise) {
-      return launch(noise, {
-        ready: () => true,
-        start: (voice, whenMs) => synthStart(voice, whenMs, noise, (t0, into) => {
-          const source = ctx.createBufferSource();
-          source.buffer = noiseBuffer(ctx, noise.noise);
-          source.loop = true;
-          source.connect(into);
-          source.start(t0, random() * source.buffer.duration);
-          return {
-            nodes: [source],
-            retune: () => {
-              source.playbackRate.value = voice.rate;
-              source.detune.value = voice.detune;
-            }
-          };
-        })
-      });
-    },
+    play: (sound, playOpts = {}) => voices.launch(playOpts, bufferStarter(ctx, sounds, warn, sound, playOpts.loop ?? false)),
+    playNote: (note) => voices.launch(note, synth.note(note)),
+    playNoise: (noise) => voices.launch(noise, synth.noise(noise)),
     stream(media, streamOpts = {}) {
-      const el = typeof media === "string" ? openMedia(media, streamOpts.crossOrigin) : media;
-      streaming.get(el)?.stop();
-      const handle = launch(streamOpts, {
-        ready: () => true,
-        start(voice) {
-          let node = mediaSources.get(el);
-          if (!node) {
-            node = ctx.createMediaElementSource(el);
-            mediaSources.set(el, node);
-          }
-          el.loop = streamOpts.loop ?? false;
-          if (streamOpts.offset !== void 0) el.currentTime = streamOpts.offset / 1e3;
-          voice.retune = () => {
-            el.playbackRate = voice.rate;
-          };
-          voice.retune();
-          const into = voice.chain.panner;
-          node.connect(into);
-          return mediaSource(el, node, into);
-        }
-      });
-      streaming.set(el, handle);
+      const el = streams.element(media, streamOpts);
+      streams.streaming.get(el)?.stop();
+      const handle = voices.launch(streamOpts, streams.starter(el, streamOpts));
+      streams.streaming.set(el, handle);
       return handle;
     },
     schedule(when, fire, key) {
@@ -1408,19 +2300,12 @@ function createAudioEngine(opts = {}) {
     },
     stopKey(key) {
       scheduler.cancelKey(key);
-      for (const voice of [...live.values()]) {
-        if (voice.key === key) teardown(voice);
-      }
+      voices.stopKey(key);
     },
-    stopAll: () => stopVoices("stopped"),
+    stopAll: () => voices.stopAll("stopped"),
     bus: graph.bus,
     busNames: graph.names,
-    activeVoices(bus) {
-      if (bus !== void 0) return slotsFor(bus).pool.active();
-      let total = 0;
-      for (const s of slotsByBus.values()) total += s.pool.active();
-      return total;
-    },
+    activeVoices: active,
     analyser(busName, tapOpts) {
       const tap = createAnalyserTap(ctx, busName ? graph.node(busName) : graph.master, tapOpts);
       taps.add(tap);
@@ -1432,23 +2317,28 @@ 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;
-      for (const voice of live.values()) applySpatial(voice);
+      voices.respatialize();
     },
     dispose() {
       if (disposed) return;
       disposed = true;
-      stopVoices("disposed");
-      idleChains.length = 0;
+      voices.stopAll("disposed");
+      chains.clear();
       scheduler.stop();
       scheduler.clear();
       tickTimer?.dispose();
       for (const tap of [...taps]) tap.dispose();
       taps.clear();
-      disarmGestures();
-      ctx.removeEventListener("statechange", onStateChange);
+      watch.dispose();
+      synth.dispose();
+      patches.dispose();
       graph.dispose();
       graph.master.disconnect();
       if (ownsContext) void ctx.close().catch(() => void 0);
@@ -1461,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) => {
@@ -1485,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,
@@ -1518,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,
@@ -1548,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);
@@ -1842,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);
@@ -1881,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
   };
@@ -2062,13 +2953,12 @@ function createKernel(patch, sampleRate, source) {
   };
 }
 function createNoteKernel(note, sampleRate) {
-  const from = toFrequency(note.pitch);
-  const glideTo = note.glide ? toFrequency(note.glide.to) : void 0;
+  const { from, glideTo, partials } = resolveNote(note);
   const glideMs = note.glide?.ms ?? note.duration ?? 100;
   const linear = note.glide?.curve === "linear";
   const wave = note.wave ?? "sine";
   const shape = isInharmonic(wave) ? sineShape : waveShape(wave);
-  const tones = isInharmonic(wave) ? resolvePartials(wave).map((p) => ({ ratio: p.ratio, gain: p.gain, decay: p.decay, phase: 0 })) : [{ ratio: 1, gain: 1, phase: 0 }];
+  const tones = partials ? partials.map((p) => ({ ratio: p.ratio, gain: p.gain, decay: p.decay, phase: 0 })) : [{ ratio: 1, gain: 1, phase: 0 }];
   return createKernel(note, sampleRate, (t, tune) => {
     let hz = from;
     if (glideTo !== void 0) {
@@ -2124,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