@weasel-js/audio 1.9.3 → 1.10.0

package/dist/index.js

@@ -121,6 +121,7 @@ function createInsertChain(ctx, head, tail, opts = {}) {
   const live = [];
   const links = [];
   let busy = false;
+  let leaving = null;
   let cancel = null;
   let disposed = false;
   let waiters = [];
@@ -219,9 +220,11 @@ function createInsertChain(ctx, head, tail, opts = {}) {
     const from = find(outOf(s), inOf(next));
     const direct = link(outOf(prev), inOf(next), 0);
     live.splice(i, 1);
+    leaving = s;
     writeParam(ctx, from.gain.gain, 0, ms);
     writeParam(ctx, direct.gain.gain, 1, ms);
     return () => {
+      leaving = null;
       unlink(into);
       unlink(from);
       if (s.removed) {
@@ -277,6 +280,10 @@ function createInsertChain(ctx, head, tail, opts = {}) {
         if (at < 0) return;
         order.splice(at, 1);
         s.removed = true;
+        if (!live.includes(s) && leaving !== s) {
+          destroy(s);
+          s.effect.dispose?.();
+        }
         pump();
       },
       index: () => order.indexOf(s)
@@ -312,6 +319,9 @@ function createInsertChain(ctx, head, tail, opts = {}) {
       disposed = true;
       cancel?.();
       cancel = null;
+      const done = waiters;
+      waiters = [];
+      for (const w of done) w();
     }
   };
 }
@@ -387,13 +397,15 @@ function createScheduler(opts) {
   let handle = null;
   let flushQueued = false;
   const fireDue = () => {
-    const horizon = opts.now() + lookahead;
+    const now = opts.now();
+    const horizon = now + lookahead;
     const due = [];
     const rest = [];
     for (const entry of queue) (entry.when <= horizon ? due : rest).push(entry);
     queue = rest;
     due.sort((a, b) => a.when - b.when);
     for (const entry of due) {
+      if (entry.waited && entry.when < now) opts.onLate?.(now - entry.when, entry.when);
       try {
         entry.fire(entry.when);
       } catch (err) {
@@ -422,8 +434,9 @@ function createScheduler(opts) {
       handle = null;
     },
     schedule(when, fire, key) {
-      queue.push({ when, fire, key });
-      if (running && !flushQueued && when <= opts.now() + lookahead) {
+      const waited = when > opts.now() + lookahead;
+      queue.push({ when, fire, key, waited });
+      if (running && !flushQueued && !waited) {
         flushQueued = true;
         queueMicrotask(flush);
       }
@@ -795,6 +808,40 @@ var partialPresets = {
   }
 };
 
+// src/voiceDrops.ts
+var reportDrop = (onDrop, reason) => {
+  if (onDrop) queueMicrotask(() => onDrop(reason));
+};
+function createDropWarnings() {
+  let warnedLocked = false;
+  let warnedDisposed = false;
+  let warnedUnknownSound = false;
+  return {
+    locked() {
+      if (warnedLocked) return;
+      warnedLocked = true;
+      console.warn(
+        "@weasel-js/audio: play() before the AudioContext was unlocked \u2014 the voice was dropped. Browsers require a user gesture; call engine.unlock() from one, or wait for the automatic gesture listener."
+      );
+    },
+    disposed() {
+      if (warnedDisposed) return;
+      warnedDisposed = true;
+      console.warn("@weasel-js/audio: play() after dispose() \u2014 the voice was dropped.");
+    },
+    unknownSound(id) {
+      if (warnedUnknownSound) return;
+      warnedUnknownSound = true;
+      console.warn(
+        `@weasel-js/audio: play() was handed sound "${id}", which this engine never loaded \u2014 the voice was dropped. A handle belongs to the engine that produced it.`
+      );
+    },
+    rearmLocked() {
+      warnedLocked = false;
+    }
+  };
+}
+
 // src/voicePool.ts
 function createVoicePool(opts) {
   if (!(opts.limit >= 1)) {
@@ -899,7 +946,8 @@ function createAudioEngine(opts = {}) {
     setTimer: timers.setTimer,
     clearTimer: timers.clearTimer,
     lookahead: opts.lookahead,
-    interval: opts.tickInterval
+    interval: opts.tickInterval,
+    onLate: opts.onLate
   });
   scheduler.start();
   const graph = createBusGraph(ctx, busNames, { ...timers, fadeMs: opts.insertFadeMs });
@@ -924,50 +972,30 @@ function createAudioEngine(opts = {}) {
     chain.gain.connect(bus);
     return chain;
   };
-  let warnedLocked = false;
-  const warnLocked = () => {
-    if (warnedLocked) return;
-    warnedLocked = true;
-    console.warn(
-      "@weasel-js/audio: play() before the AudioContext was unlocked \u2014 the voice was dropped. Browsers require a user gesture; call engine.unlock() from one, or wait for the automatic gesture listener."
-    );
-  };
-  let warnedDisposed = false;
-  const warnDisposed = () => {
-    if (warnedDisposed) return;
-    warnedDisposed = true;
-    console.warn("@weasel-js/audio: play() after dispose() \u2014 the voice was dropped.");
-  };
-  let warnedUnknownSound = false;
-  const warnUnknownSound = (id) => {
-    if (warnedUnknownSound) return;
-    warnedUnknownSound = true;
-    console.warn(
-      `@weasel-js/audio: play() was handed sound "${id}", which this engine never loaded \u2014 the voice was dropped. A handle belongs to the engine that produced it.`
-    );
-  };
-  const gestures = ["pointerdown", "keydown", "touchstart"];
+  const warn = createDropWarnings();
+  const gestures = ["pointerdown", "pointerup", "touchend", "click", "keydown"];
   const onGesture = () => {
-    void engine.unlock();
+    void engine.unlock().catch(() => void 0);
   };
   const armGestures = () => {
     if (typeof window === "undefined") return;
-    for (const g of gestures) window.addEventListener(g, onGesture, { once: true, passive: true });
+    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);
   };
-  armGestures();
+  if (ctx.state !== "running") armGestures();
   const onStateChange = () => {
     if (disposed) return;
     if (ctx.state === "running") {
+      disarmGestures();
       if (suspendedSince) staleFloor = now();
       suspendedSince = false;
       return;
     }
     suspendedSince = true;
-    warnedLocked = false;
+    warn.rearmLocked();
     armGestures();
   };
   ctx.addEventListener("statechange", onStateChange);
@@ -980,13 +1008,17 @@ function createAudioEngine(opts = {}) {
     const s = spatialize(voice.position, listener, spatialOpts);
     voice.spatialGain = s.gain;
     voice.chain.panner.pan.value = s.pan;
-    writeParam(ctx, voice.chain.gain.gain, voice.baseGain * s.gain);
+    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) => {
+  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();
@@ -1010,6 +1042,9 @@ function createAudioEngine(opts = {}) {
       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: () => {
@@ -1031,11 +1066,13 @@ function createAudioEngine(opts = {}) {
   const launch = (common, starter) => {
     const id = nextVoiceId++;
     if (disposed) {
-      warnDisposed();
+      warn.disposed();
+      reportDrop(common.onDrop, "disposed");
       return dropped(id);
     }
     if (ctx.state !== "running") {
-      warnLocked();
+      warn.locked();
+      reportDrop(common.onDrop, "locked");
       return dropped(id);
     }
     const busName = common.bus ?? busNames[0];
@@ -1050,6 +1087,7 @@ function createAudioEngine(opts = {}) {
       slot: null,
       token: 0,
       key: common.cancelKey,
+      onDrop: common.onDrop,
       source: null,
       env: null,
       retune: null,
@@ -1062,17 +1100,19 @@ function createAudioEngine(opts = {}) {
       detune: common.detune ?? 0,
       position: common.position,
       playing: true,
-      cancelled: false
+      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);
+        teardown(voice, "stale");
         return;
       }
       if (!starter.ready()) {
-        teardown(voice);
+        teardown(voice, "unready");
         return;
       }
       const acquired = slots.pool.acquire({
@@ -1086,7 +1126,15 @@ function createAudioEngine(opts = {}) {
         const victim = slots.byToken.get(acquired.stolen);
         if (victim) teardown(victim);
       }
-      const source = starter.start(voice, scheduledWhen);
+      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?.();
@@ -1098,6 +1146,7 @@ function createAudioEngine(opts = {}) {
       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);
@@ -1119,7 +1168,8 @@ function createAudioEngine(opts = {}) {
       },
       setGain(value, rampMs) {
         voice.baseGain = value;
-        if (!voice.chain) return;
+        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);
       },
@@ -1245,7 +1295,7 @@ function createAudioEngine(opts = {}) {
       return launch(playOpts, {
         ready() {
           if (sounds.buffer(sound)) return true;
-          warnUnknownSound(sound.id);
+          warn.unknownSound(sound.id);
           return false;
         },
         start(voice, when) {
@@ -1362,9 +1412,7 @@ function createAudioEngine(opts = {}) {
         if (voice.key === key) teardown(voice);
       }
     },
-    stopAll() {
-      for (const voice of [...live.values()]) teardown(voice);
-    },
+    stopAll: () => stopVoices("stopped"),
     bus: graph.bus,
     busNames: graph.names,
     activeVoices(bus) {
@@ -1392,7 +1440,7 @@ function createAudioEngine(opts = {}) {
     dispose() {
       if (disposed) return;
       disposed = true;
-      engine.stopAll();
+      stopVoices("disposed");
       idleChains.length = 0;
       scheduler.stop();
       scheduler.clear();
@@ -1513,6 +1561,11 @@ function createCompressorEffect(ctx, opts = {}) {
 
 // src/patternPlayer.ts
 var nextPlayer = 1;
+function patternLength(events, stepsPerBeat = 4) {
+  let last = -1;
+  for (const e of events) last = Math.max(last, Math.floor(e.step));
+  return Math.max(1, Math.ceil((last + 1) / stepsPerBeat)) * stepsPerBeat;
+}
 var checkTempo = (bpm) => {
   if (!(bpm > 0) || !Number.isFinite(bpm)) {
     throw new RangeError(`@weasel-js/audio: tempo must be a positive number of bpm, got ${bpm}`);
@@ -1524,21 +1577,22 @@ function createPatternPlayer(engine, opts) {
   const loop = opts.loop ?? true;
   const key = `\0pattern:${nextPlayer++}`;
   let bpm = opts.tempo;
+  let drift = opts.detune ?? 0;
   let length = 1;
   let byStep = /* @__PURE__ */ new Map();
   const setEvents = (events, len) => {
     byStep = /* @__PURE__ */ new Map();
-    let last = -1;
     for (const e of events) {
-      const list = byStep.get(e.step);
+      const step = Math.floor(e.step);
+      const list = byStep.get(step);
       if (list) list.push(e);
-      else byStep.set(e.step, [e]);
-      last = Math.max(last, e.step);
+      else byStep.set(step, [e]);
     }
-    length = len ?? Math.max(1, Math.ceil((last + 1) / stepsPerBeat)) * stepsPerBeat;
+    length = len ?? patternLength(events, stepsPerBeat);
   };
   setEvents(opts.events ?? [], opts.length);
   let running = false;
+  let inStep = false;
   let count = 0;
   let lastAt = null;
   let nextAt = 0;
@@ -1563,21 +1617,30 @@ function createPatternPlayer(engine, opts) {
     const step = count % length;
     for (const v of voices) if (!v.isPlaying()) voices.delete(v);
     for (const e of byStep.get(step) ?? []) {
+      const at = when + (e.step - step) * stepMs();
+      const detune = (e.detune ?? 0) + (typeof drift === "function" ? drift(e.step) : drift);
       if ("sound" in e) {
         const { step: _s, sound, ...play } = e;
-        voices.add(engine.play(sound, { ...play, when }));
+        voices.add(engine.play(sound, { ...play, detune, when: at }));
       } else if ("noise" in e) {
         const { step: _s, length: steps = 1, ...noise } = e;
-        voices.add(engine.playNoise({ ...noise, when, duration: steps * stepMs() }));
+        voices.add(engine.playNoise({ ...noise, detune, when: at, duration: steps * stepMs() }));
       } else {
         const { step: _s, length: steps = 1, ...note } = e;
-        voices.add(engine.playNote({ ...note, when, duration: steps * stepMs() }));
+        voices.add(engine.playNote({ ...note, detune, when: at, duration: steps * stepMs() }));
       }
     }
-    opts.onStep?.(step, when);
+    const ms = stepMs();
+    inStep = true;
+    try {
+      opts.onStep?.(step, when);
+    } finally {
+      inStep = false;
+    }
+    if (!running) return;
     count += 1;
     lastAt = when;
-    nextAt = when + stepMs();
+    nextAt = when + ms;
     book();
   };
   return {
@@ -1601,15 +1664,231 @@ function createPatternPlayer(engine, opts) {
     setTempo(next) {
       checkTempo(next);
       bpm = next;
-      if (!running || lastAt === null) return;
+      if (!running || lastAt === null || inStep) return;
       engine.stopKey(key);
       nextAt = Math.max(lastAt + stepMs(), engine.now());
       book();
     },
+    setDetune(next) {
+      drift = next;
+    },
     setEvents
   };
 }
 
-export { createAnalyserTap, createAudioEngine, createBusGraph, createCompressorEffect, createDelayEffect, createFilterEffect, createPatternPlayer, createReverbEffect, createScheduler, createSoundCache, createTickTimer, createVoicePool, envelopeLevel, envelopePoints, midiToFrequency, noiseSamples, noteToMidi, partialPresets, resolveEnvelope, spatialize, toFrequency };
+// src/patternLoad.ts
+function patternVoicePeaks(events, opts) {
+  const stepsPerBeat = opts.stepsPerBeat ?? 4;
+  const stepMs = 6e4 / opts.tempo / stepsPerBeat;
+  const passMs = (opts.length ?? patternLength(events, stepsPerBeat)) * stepMs;
+  const lead = opts.lookahead ?? 100;
+  const spans = events.map((e) => {
+    const sounds = "sound" in e ? opts.hitMs?.(e) ?? stepMs : (e.length ?? 1) * stepMs + resolveEnvelope(e.envelope).release;
+    const at = e.step * stepMs;
+    return { bus: e.bus ?? opts.bus ?? "sfx", from: at - lead, until: at + sounds };
+  });
+  const longest = Math.max(0, ...spans.map((s) => s.until - s.from));
+  const passes = opts.loop === false ? 0 : Math.ceil(longest / passMs);
+  const edges = /* @__PURE__ */ new Map();
+  for (const span of spans) {
+    const list = edges.get(span.bus) ?? [];
+    edges.set(span.bus, list);
+    for (let pass = 0; pass <= passes; pass++) {
+      list.push({ at: span.from + pass * passMs, by: 1 }, { at: span.until + pass * passMs, by: -1 });
+    }
+  }
+  const peaks = {};
+  for (const [bus, list] of edges) {
+    list.sort((a, b) => a.at - b.at || a.by - b.by);
+    let held = 0;
+    let peak = 0;
+    for (const edge of list) {
+      held += edge.by;
+      peak = Math.max(peak, held);
+    }
+    peaks[bus] = peak;
+  }
+  return peaks;
+}
+
+// src/scoreMood.ts
+var scoreCues = [
+  {
+    name: "dread",
+    mood: { valence: -1, tension: 1, urgency: 0 },
+    device: "Sustained low tones a minor second and a tritone apart, with no pulse."
+  },
+  {
+    name: "investigation",
+    mood: { valence: -0.4, tension: 0.5, urgency: 0.5 },
+    device: "A plucked minor ostinato that adds a layer every two bars."
+  },
+  {
+    name: "wonder",
+    mood: { valence: 1, tension: 0.1, urgency: 0.1 },
+    device: "Lydian chords in open voicings, swelling in with a soft attack."
+  },
+  {
+    name: "urgency",
+    mood: { valence: 0, tension: 0.7, urgency: 1 },
+    device: "Driving sixteenths on stacked fourths and fifths, a new chord every bar."
+  }
+];
+var clamp = (value, lo, hi) => Math.min(hi, Math.max(lo, value));
+var inRange = (mood) => ({
+  valence: clamp(mood.valence, -1, 1),
+  tension: clamp(mood.tension, 0, 1),
+  urgency: clamp(mood.urgency, 0, 1)
+});
+function readScoreCue(mood) {
+  const m = inRange(mood);
+  const distance = scoreCues.map((cue) => ((m.valence - cue.mood.valence) / 2) ** 2 + (m.tension - cue.mood.tension) ** 2 + (m.urgency - cue.mood.urgency) ** 2);
+  const exact = distance.indexOf(0);
+  const raw = distance.map((d, i) => exact >= 0 ? Number(i === exact) : 1 / d);
+  const total = raw.reduce((sum, w) => sum + w, 0);
+  const weights = {};
+  scoreCues.forEach((cue, i) => {
+    weights[cue.name] = raw[i] / total;
+  });
+  return { name: scoreCues[raw.indexOf(Math.max(...raw))].name, weights };
+}
+var scoreModes = {
+  lydian: [0, 2, 4, 6, 7, 9, 11],
+  ionian: [0, 2, 4, 5, 7, 9, 11],
+  dorian: [0, 2, 3, 5, 7, 9, 10],
+  aeolian: [0, 2, 3, 5, 7, 8, 10],
+  phrygian: [0, 1, 3, 5, 7, 8, 10]
+};
+function scoreParams(mood) {
+  const { valence, tension, urgency } = inRange(mood);
+  const sustained = urgency < 0.35;
+  return {
+    mode: valence > 0.6 ? "lydian" : valence > 0.2 ? "ionian" : valence > -0.2 ? "dorian" : valence > -0.6 ? "aeolian" : "phrygian",
+    register: 36 + 12 * Math.round(valence + 1),
+    spread: 1 + Math.round(2 * Math.max(0, valence)),
+    harmony: tension >= 0.8 ? "cluster" : tension >= 0.55 ? "quartal" : "triadic",
+    layers: 1 + Math.round(4 * tension),
+    tempo: Math.round(60 + 80 * urgency),
+    density: urgency < 0.15 ? 0 : urgency < 0.4 ? 1 : urgency < 0.75 ? 2 : 4,
+    articulation: sustained ? "sustained" : "plucked",
+    harmonicRhythm: urgency < 0.33 ? 4 : urgency < 0.66 ? 2 : 1,
+    attack: sustained ? Math.round(800 * (1 - urgency)) : 5
+  };
+}
+
+// src/scoreBar.ts
+var SCORE_BAR_STEPS = 16;
+var PROGRESSION = [0, 5, 3, 4];
+function scoreChord(params, chord, tonic = 0) {
+  const scale = scoreModes[params.mode];
+  const tone = (degree2) => params.register + tonic + scale[degree2 % 7] + 12 * Math.floor(degree2 / 7);
+  if (params.harmony === "cluster") {
+    const root2 = tone(0);
+    return [root2, root2 + 1, root2 + 6];
+  }
+  const degree = PROGRESSION[chord % PROGRESSION.length];
+  const root = tone(degree);
+  if (params.harmony === "quartal") return [root, root + 7, root + 12, root + 17];
+  if (params.spread < 2) return [root, tone(degree + 2), tone(degree + 4)];
+  const open = [root, tone(degree + 4), tone(degree + 2) + 12];
+  if (params.spread >= 3) open.push(tone(degree + 3) + 24);
+  return open;
+}
+function figure(count, seed) {
+  const order = Array.from({ length: count }, (_, i) => i);
+  if (seed === void 0) return order;
+  let state = seed >>> 0 || 1;
+  for (let i = count - 1; i > 0; i--) {
+    state = Math.imul(state, 1664525) + 1013904223 >>> 0;
+    const j = state % (i + 1);
+    [order[i], order[j]] = [order[j], order[i]];
+  }
+  return order;
+}
+var PLUCK = { attack: 5, decay: 140, sustain: 0.2, release: 80 };
+function scoreBar(params, bar, opts = {}) {
+  const gain = opts.gain ?? 0.5;
+  const chord = scoreChord(params, Math.floor(bar / params.harmonicRhythm), opts.tonic);
+  const swell = { attack: params.attack, release: params.attack };
+  const held = params.articulation === "sustained";
+  const note = (step, length, midi, level, envelope2) => ({
+    step,
+    length,
+    pitch: { midi },
+    gain: gain * level,
+    envelope: envelope2,
+    wave: held ? "sine" : "triangle",
+    ...opts.bus === void 0 ? {} : { bus: opts.bus }
+  });
+  const pad = (level, envelope2) => chord.map((midi) => note(0, SCORE_BAR_STEPS, midi, level / chord.length, envelope2));
+  if (params.density === 0) return pad(1, swell);
+  const layers = Math.min(params.layers, 1 + Math.floor(bar / 2));
+  const every = 4 / params.density;
+  const order = figure(chord.length, opts.seed);
+  const envelope = held ? swell : PLUCK;
+  const events = [];
+  for (let pulse = 0; pulse * every < SCORE_BAR_STEPS; pulse++) {
+    const midi = chord[order[pulse % order.length]];
+    events.push(note(pulse * every, every, midi, 0.4, envelope));
+    if (layers >= 3 && pulse % 2 === 1) events.push(note(pulse * every, every, midi + 12, 0.15, envelope));
+  }
+  if (layers >= 2) {
+    for (const step of [0, 8]) events.push(note(step, 8, chord[0] - 12, 0.3, { attack: 5, release: 120 }));
+  }
+  if (layers >= 4) events.push(...pad(0.15, { attack: 120, release: 200 }));
+  return events;
+}
+
+// src/score.ts
+function createScore(engine, opts) {
+  const { mood: initial, onBar, ...barOpts } = opts;
+  let target = initial;
+  const stateAt = (bar, before) => {
+    const cue = readScoreCue(target);
+    return {
+      bar,
+      cueBar: before && before.cue.name === cue.name ? before.cueBar + 1 : 0,
+      mood: target,
+      cue,
+      params: scoreParams(target)
+    };
+  };
+  const eventsOf = (state) => scoreBar(state.params, state.cueBar, barOpts);
+  let current = stateAt(0, null);
+  let next = current;
+  const player = createPatternPlayer(engine, {
+    tempo: current.params.tempo,
+    length: SCORE_BAR_STEPS,
+    events: eventsOf(current),
+    onStep(step, when) {
+      if (step === 0) {
+        current = next;
+        onBar?.(current, when);
+      }
+      if (step !== SCORE_BAR_STEPS - 1) return;
+      next = stateAt(current.bar + 1, current);
+      player.setTempo(next.params.tempo);
+      player.setEvents(eventsOf(next), SCORE_BAR_STEPS);
+    }
+  });
+  return {
+    start(when) {
+      if (player.playing()) return;
+      current = next = stateAt(0, null);
+      player.setTempo(current.params.tempo);
+      player.setEvents(eventsOf(current), SCORE_BAR_STEPS);
+      player.start(when);
+    },
+    stop: () => player.stop(),
+    playing: () => player.playing(),
+    mood: () => target,
+    setMood(mood) {
+      target = mood;
+    },
+    state: () => current
+  };
+}
+
+export { SCORE_BAR_STEPS, createAnalyserTap, createAudioEngine, createBusGraph, createCompressorEffect, createDelayEffect, createFilterEffect, createPatternPlayer, createReverbEffect, createScheduler, createScore, createSoundCache, createTickTimer, createVoicePool, envelopeLevel, envelopePoints, midiToFrequency, noiseSamples, noteToMidi, partialPresets, patternLength, patternVoicePeaks, readScoreCue, resolveEnvelope, scoreBar, scoreChord, scoreCues, scoreModes, scoreParams, spatialize, toFrequency };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map