@weasel-js/audio 1.9.4 → 1.10.0

package/README.md

@@ -17,6 +17,10 @@ dedicated Worker instead (`createTickTimer`). The worker is built from an inline
 global, or a Content-Security-Policy without `worker-src blob:` — it falls back
 to `setTimeout`, and a hidden tab books late again.
 
+The worker times the pass, but the pass itself runs on the main thread, so a
+stall there longer than the lookahead starts whatever came due late. The
+`onLate(lateMs, when)` option reports each one; if it fires, raise `lookahead`.
+
 A suspended `AudioContext` is a separate matter: its clock stops, and on resume
 the engine drops what came due meanwhile rather than firing it all at once.
 
@@ -90,6 +94,45 @@ player.start();
 player.setTempo(140);
 ```
 
+A `step` can be fractional: `{ step: 2.25 }` sounds a quarter of a step after
+step 2, which is how a pattern swings or a hit drags. The player's `detune` is
+cents added to every event, as a number or a function of the event's step, for
+a loop that drifts in pitch. `patternVoicePeaks(events, opts)` returns the most
+voices the pattern holds at once on each bus, to check against `voiceLimit`
+before it plays.
+
+## Generative scoring
+
+`createScore` writes music from a mood instead of choosing a clip. A mood is
+three numbers — `valence` (-1 dark to 1 bright), `tension` and `urgency` (0 to
+1) — and each one moves its own musical parameters: valence picks the mode, the
+register and how open the chords are; tension picks the harmony and how many
+layers build up; urgency picks the tempo, the pulse, the articulation and how
+often the chord changes.
+
+```ts
+const score = createScore(engine, {
+  mood: { valence: -1, tension: 1, urgency: 0 },
+  bus: 'music',
+  onBar: (state) => {
+    label.textContent = `${state.cue.name}: ${state.params.mode}, ${state.params.tempo} bpm`;
+  },
+});
+score.start();
+score.setMood({ valence: 0, tension: 0.7, urgency: 1 }); // from the next bar line
+```
+
+The corners of that space are the stock devices of documentary and news
+scoring, listed in `scoreCues` with a sentence each on what they do: `dread`,
+`investigation`, `wonder` and `urgency`. They work on a listener without asking
+them, so the score says what it is doing: `state()` and `onBar` give the cue in
+force, each cue's share of the mood (`cue.weights`), and every parameter the bar
+was written from. Show it.
+
+The layers underneath are usable on their own: `scoreParams(mood)` resolves a
+mood, `scoreChord` and `scoreBar` write a chord and a bar of pattern events
+from the parameters, and `readScoreCue(mood)` names the cue.
+
 ## Insert effects
 
 Each bus has an ordered insert chain, `engine.bus(name).inserts`, between where

package/dist/index.d.ts

@@ -446,6 +446,10 @@ interface AudioEngineOptions {
      *  replaces the default, and the missing half falls back to `setTimeout`'s. */
     setTimer?: (cb: () => void, ms: number) => unknown;
     clearTimer?: (handle: unknown) => void;
+    /** A voice or an `engine.schedule` callback came due `lateMs` after its
+     *  time `when`, both in engine ms: the main thread stalled for longer than
+     *  the lookahead covers, and the voice sounded late by that much. */
+    onLate?: (lateMs: number, when: number) => void;
     /** Crossfade for every insert-chain edit and bypass, in ms. Default 15. */
     insertFadeMs?: number;
     /** Uniform in [0, 1), for where in its loop a noise voice starts. Default `Math.random`. */
@@ -612,6 +616,11 @@ interface SchedulerOptions {
     lookahead?: number;
     /** Time between passes, in ms. Default 25. */
     interval?: number;
+    /** An event fired `lateMs` after its time `when`: the passes that should
+     *  have reached it inside the lookahead stalled, and whatever it starts will
+     *  sound late by that much. Never called for an event booked inside the
+     *  lookahead or for a time already past, which no pass was meant to catch. */
+    onLate?: (lateMs: number, when: number) => void;
 }
 /** A queue of callbacks keyed to engine time. See `createScheduler`. */
 interface Scheduler {
@@ -664,7 +673,11 @@ interface TickTimer {
  */
 declare function createTickTimer(): TickTimer;
 
-/** A synth note on a step. `length` is its gate in steps, default 1. */
+/** A synth note on a step. `length` is its gate in steps, default 1.
+ *
+ *  Any event's `step` may be fractional: it is booked with the step it sits in
+ *  and sounds that fraction of a step later, so `2.5` is halfway from step 2 to
+ *  step 3. That is swing, a flam, or a hit that drags. */
 interface PatternNote extends Omit<NoteOptions, 'when' | 'duration'> {
     step: number;
     length?: number;
@@ -694,10 +707,16 @@ interface PatternPlayerOptions {
     length?: number;
     /** Default true. */
     loop?: boolean;
+    /** Cents added to every event's own `detune`: a number, or a function of
+     *  the event's `step`, for a pattern that drifts in pitch as it plays. A
+     *  function is asked as each event is booked. Default 0. */
+    detune?: PatternDetune;
     /** Called as each step is booked — up to a lookahead ahead of it sounding —
      *  with its index in the pattern and its engine time in ms. */
     onStep?: (step: number, when: number) => void;
 }
+/** See `PatternPlayerOptions.detune`. */
+type PatternDetune = number | ((step: number) => number);
 /** A running sequence of steps. See `createPatternPlayer`. */
 interface PatternPlayer {
     /** Start from step 0 at engine time `when`, default now. No-op while playing. */
@@ -706,11 +725,17 @@ interface PatternPlayer {
     stop(): void;
     playing(): boolean;
     tempo(): number;
-    /** Takes effect from the next step not yet booked. */
+    /** Takes effect from the next step not yet booked. Called from `onStep`,
+     *  that is the step after the one reported, which keeps its own length. */
     setTempo(bpm: number): void;
     /** Takes effect from the next step not yet booked. */
+    setDetune(detune: PatternDetune): void;
+    /** Takes effect from the next step not yet booked. */
     setEvents(events: readonly PatternEvent[], length?: number): void;
 }
+/** Steps in one pass of `events` when no length is given: through the last
+ *  event, rounded up to a whole beat. */
+declare function patternLength(events: readonly PatternEvent[], stepsPerBeat?: number): number;
 /**
  * A step sequencer over `engine`. Each step is one `engine.schedule` booking;
  * when it fires, it books that step's events at the step's exact time and then
@@ -724,6 +749,167 @@ interface PatternPlayer {
  */
 declare function createPatternPlayer(engine: AudioEngine, opts: PatternPlayerOptions): PatternPlayer;
 
+/** Options for `patternVoicePeaks`. The first four mean what they mean to
+ *  `createPatternPlayer`, and should be the values the player is given. */
+interface PatternLoadOptions {
+    tempo: number;
+    stepsPerBeat?: number;
+    length?: number;
+    loop?: boolean;
+    /** The bus of an event that names none: the engine's first. Default 'sfx'. */
+    bus?: string;
+    /** The engine's `lookahead` in ms. Default 100. */
+    lookahead?: number;
+    /** How long a buffer hit sounds, in ms. Default: one step. */
+    hitMs?: (hit: PatternHit) => number;
+}
+/**
+ * The most voices a pattern holds at once on each bus, to set against the
+ * engine's `voiceLimit` before the pattern plays: past the limit, each new
+ * event steals a voice that is still ringing.
+ *
+ * A note or a noise holds its voice through its gate and its envelope's
+ * release. With `loop`, what rings past the end of a pass is counted against
+ * the start of the next.
+ */
+declare function patternVoicePeaks(events: readonly PatternEvent[], opts: PatternLoadOptions): Record<string, number>;
+
+/** Where a score sits on the three axes it is steered by. Values outside a
+ *  range are read as its nearest end. */
+interface ScoreMood {
+    /** -1 dark to 1 bright. */
+    valence: number;
+    /** 0 consonant and settled to 1 dissonant. */
+    tension: number;
+    /** 0 still to 1 driving. */
+    urgency: number;
+}
+/** The scoring devices of factual screen content that a mood can land on. */
+type ScoreCueName = 'dread' | 'investigation' | 'wonder' | 'urgency';
+/** One named device: the mood that produces it, and what it does to a listener
+ *  in words, for a consumer to show beside the score. */
+interface ScoreCue {
+    name: ScoreCueName;
+    mood: ScoreMood;
+    device: string;
+}
+/** The built-in cues: each names a mood and the musical device that carries it. */
+declare const scoreCues: readonly ScoreCue[];
+/** Which cue a mood is applying: the nearest, and how much of each. */
+interface ScoreCueReading {
+    name: ScoreCueName;
+    /** Each cue's share, summing to 1. A mood at a cue's own `mood` is all that cue. */
+    weights: Record<ScoreCueName, number>;
+}
+/** Name the cue a mood is applying, and weigh the others against it by
+ *  inverse squared distance. */
+declare function readScoreCue(mood: ScoreMood): ScoreCueReading;
+/** The modes a score draws on, brightest first. */
+type ScoreMode = 'lydian' | 'ionian' | 'dorian' | 'aeolian' | 'phrygian';
+/** Each mode's seven tones, in semitones above its tonic. */
+declare const scoreModes: Record<ScoreMode, readonly number[]>;
+/** The musical parameters a mood resolves to. Each follows one axis only. */
+interface ScoreParams {
+    /** From valence. */
+    mode: ScoreMode;
+    /** MIDI note of the tonic the chords are built up from. From valence. */
+    register: number;
+    /** Octaves a chord is opened across, 1 to 3. From valence. */
+    spread: number;
+    /** How the tones above a root are chosen: thirds from the mode, stacked
+     *  fourths and fifths, or a minor second and a tritone. From tension. */
+    harmony: 'triadic' | 'quartal' | 'cluster';
+    /** The most layers a pulsed score builds up to. From tension. */
+    layers: number;
+    /** Beats per minute. From urgency. */
+    tempo: number;
+    /** Notes to a beat; 0 is no pulse at all. From urgency. */
+    density: 0 | 1 | 2 | 4;
+    /** From urgency. */
+    articulation: 'sustained' | 'plucked';
+    /** Bars a chord lasts. From urgency. */
+    harmonicRhythm: number;
+    /** Envelope attack in ms. From urgency. */
+    attack: number;
+}
+/** Resolve a mood to the parameters `scoreBar` writes music from. */
+declare function scoreParams(mood: ScoreMood): ScoreParams;
+
+/** Steps in a bar of score: sixteenths in 4/4. */
+declare const SCORE_BAR_STEPS = 16;
+/** How `scoreBar` places and routes its notes. */
+interface ScoreBarOptions {
+    /** Semitones above C for the tonic. Default 0. */
+    tonic?: number;
+    /** Default: the engine's first bus. */
+    bus?: string;
+    /** The level the notes sounding on one step add up to at most. Default 0.5. */
+    gain?: number;
+    /** Chooses the order an ostinato takes a chord's tones in. Default: rising. */
+    seed?: number;
+}
+/**
+ * The chord a score plays, as MIDI notes, root first. `chord` counts chords
+ * since the score began; a cluster stays on the tonic, and the other harmonies
+ * walk a four-chord progression inside the mode.
+ */
+declare function scoreChord(params: ScoreParams, chord: number, tonic?: number): number[];
+/**
+ * One bar of score as pattern events, for a player `SCORE_BAR_STEPS` long.
+ * `bar` counts bars since the score began: it picks the chord, by the harmonic
+ * rhythm, and how many layers a pulsed score has built up to, one more every
+ * two bars. The same arguments always write the same bar.
+ *
+ * With no pulse, the bar is its chord held throughout. With one, the layers
+ * are an ostinato over the chord's tones, a bass on the root, the ostinato
+ * doubled an octave up on the off pulses, and the chord held as a pad.
+ */
+declare function scoreBar(params: ScoreParams, bar: number, opts?: ScoreBarOptions): PatternNote[];
+
+/** What a score is playing in one bar, and why: the mood it was given, the cue
+ *  that mood applies, and the parameters the bar was written from. */
+interface ScoreState {
+    /** Bars since `start`. */
+    bar: number;
+    /** Bars since the cue last changed, which is what a pulsed score's layers
+     *  build up from. */
+    cueBar: number;
+    mood: ScoreMood;
+    cue: ScoreCueReading;
+    params: ScoreParams;
+}
+/** Options for `createScore`. */
+interface ScoreOptions extends ScoreBarOptions {
+    mood: ScoreMood;
+    /** Called as each bar's first step is booked — up to a lookahead before it
+     *  sounds — with what the bar plays and its engine time in ms. */
+    onBar?: (state: ScoreState, when: number) => void;
+}
+/** A running generative score. See `createScore`. */
+interface Score {
+    /** Start from bar 0 at engine time `when`, default now. No-op while playing. */
+    start(when?: number): void;
+    /** Book nothing further, and release every voice the score started. */
+    stop(): void;
+    playing(): boolean;
+    /** The mood last set, which the next bar will take. */
+    mood(): ScoreMood;
+    /** Takes effect at the next bar line. */
+    setMood(mood: ScoreMood): void;
+    /** The bar most recently booked. */
+    state(): ScoreState;
+}
+/**
+ * Music written continuously from a mood rather than chosen from clips. Each
+ * bar is `scoreBar` of the mood's `scoreParams`, booked through a pattern
+ * player, and a new mood lands on the next bar line with its tempo.
+ *
+ * These devices work on a listener without asking them, which is what they are
+ * for. `state()` and `onBar` name the cue in force and every parameter behind
+ * it, so a consumer can show what is being applied as well as play it.
+ */
+declare function createScore(engine: AudioEngine, opts: ScoreOptions): Score;
+
 /** Samples of `color` noise, seeded so every context gets the same loop. The
  *  end is pulled onto the start, so the loop point does not click. */
 declare function noiseSamples(color: NoiseColor, length: number): Float32Array;
@@ -758,4 +944,4 @@ declare const partialPresets: {
     };
 };
 
-export { type Acquisition, type AnalyserTap, type AnalyserTapOptions, type AudioEngine, type AudioEngineOptions, type BusGraph, type BusGraphOptions, type BusHandle, type CompressorEffect, type CompressorEffectOptions, type DelayEffect, type DelayEffectOptions, type Envelope, type EnvelopePoint, type FilterEffect, type FilterEffectOptions, type Glide, type Inharmonic, type InsertAddOptions, type InsertChain, type InsertChainOptions, type InsertEffect, type InsertSlot, type NoiseColor, type NoiseOptions, type NoisePatch, type NoteOptions, type PatternEvent, type PatternHit, type PatternNoise, type PatternNote, type PatternPlayer, type PatternPlayerOptions, type Pitch, type PlayOptions, type ResolvedEnvelope, type ReverbEffect, type ReverbEffectOptions, type Scheduler, type SchedulerOptions, type SoundCache, type SoundHandle, type SpatialOptions, type StealPolicy, type StreamOptions, type SynthPartial, type SynthPatch, type TickTimer, type Vec2, type VoiceDropReason, type VoiceFilter, type VoiceHandle, type VoicePool, type VoicePoolOptions, type VoiceRecord, type Waveform, type WetDryMix, createAnalyserTap, createAudioEngine, createBusGraph, createCompressorEffect, createDelayEffect, createFilterEffect, createPatternPlayer, createReverbEffect, createScheduler, createSoundCache, createTickTimer, createVoicePool, envelopeLevel, envelopePoints, midiToFrequency, noiseSamples, noteToMidi, partialPresets, resolveEnvelope, spatialize, toFrequency };
+export { type Acquisition, type AnalyserTap, type AnalyserTapOptions, type AudioEngine, type AudioEngineOptions, type BusGraph, type BusGraphOptions, type BusHandle, type CompressorEffect, type CompressorEffectOptions, type DelayEffect, type DelayEffectOptions, type Envelope, type EnvelopePoint, type FilterEffect, type FilterEffectOptions, type Glide, type Inharmonic, type InsertAddOptions, type InsertChain, type InsertChainOptions, type InsertEffect, type InsertSlot, type NoiseColor, type NoiseOptions, type NoisePatch, type NoteOptions, type PatternDetune, type PatternEvent, type PatternHit, type PatternLoadOptions, type PatternNoise, type PatternNote, type PatternPlayer, type PatternPlayerOptions, type Pitch, type PlayOptions, type ResolvedEnvelope, type ReverbEffect, type ReverbEffectOptions, SCORE_BAR_STEPS, type Scheduler, type SchedulerOptions, type Score, type ScoreBarOptions, type ScoreCue, type ScoreCueName, type ScoreCueReading, type ScoreMode, type ScoreMood, type ScoreOptions, type ScoreParams, type ScoreState, type SoundCache, type SoundHandle, type SpatialOptions, type StealPolicy, type StreamOptions, type SynthPartial, type SynthPatch, type TickTimer, type Vec2, type VoiceDropReason, type VoiceFilter, type VoiceHandle, type VoicePool, type VoicePoolOptions, type VoiceRecord, type Waveform, type WetDryMix, 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 };

package/dist/index.js

@@ -397,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) {
@@ -432,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);
       }
@@ -943,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 });
@@ -1557,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}`);
@@ -1568,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;
@@ -1607,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 {
@@ -1645,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