polyphon 0.0.0-stage → 0.1.0

package/src/engine/output.ts

@@ -0,0 +1,59 @@
+// The final stage every song goes through, live or rendered: the level songs are balanced for, then a gentle limiter.
+// A song mastered loud (`master.loud`) ends in a stage of its own instead, a brickwall limiter, and goes around this one.
+
+import type { Song } from '../song.ts';
+
+/** Songs are mixed to sound right at this bus level */
+export const MIX_LEVEL = 0.36;
+
+/** Level and limiter in front of a destination; returns the stage's input */
+export function createOutputStage(ctx: BaseAudioContext, destination: AudioNode): GainNode {
+  const level = ctx.createGain();
+  level.gain.value = MIX_LEVEL;
+  const limiter = ctx.createDynamicsCompressor();
+  limiter.threshold.value = -14;
+  limiter.ratio.value = 4;
+  level.connect(limiter).connect(destination);
+  return level;
+}
+
+/** Songs mastered loud end in a limiter of their own, so they skip the output stage */
+export function mastersItself(song: Song): boolean {
+  return song.master?.loud !== undefined;
+}
+
+/** The loudest a song mastered loud peaks, dBFS: the clipper's oversampling overshoots it by about 0.25 dB between the samples, which stays under -1 */
+const CEILING = -1.5;
+
+/**
+ * The final stage of a song mastered loud: `loud` dB of drive into a brickwall limiter (songs peak around full scale before the
+ * bus level, so that is about how much their loudest moments are turned down), then a soft clipper that rounds off whatever gets
+ * past it, under the ceiling. Returns its input.
+ */
+export function createLoudStage(ctx: BaseAudioContext, loud: number, destination: AudioNode): GainNode {
+  const drive = ctx.createGain();
+  drive.gain.value = dB(loud);
+  const limiter = new DynamicsCompressorNode(ctx, { threshold: CEILING, knee: 0, ratio: 20, attack: 0.001, release: 0.06 });
+  // Take back the makeup gain Web Audio adds, (1 / the gain at 0 dBFS) ^ 0.6; and halve the signal, since a WaveShaper reads
+  // inputs from -1 to 1 and the clipper's curve covers peaks up to 6 dB over full scale
+  const trim = ctx.createGain();
+  trim.gain.value = dB(0.6 * CEILING * (1 - 1 / 20)) / 2;
+  const clipper = ctx.createWaveShaper();
+  clipper.curve = softClip(dB(CEILING - 2), dB(CEILING));
+  clipper.oversample = '4x';
+  drive.connect(limiter).connect(trim).connect(clipper).connect(destination);
+  return drive;
+}
+
+/** WaveShaper curve over inputs -2 to 2: straight up to `knee`, then bending smoothly over towards `ceiling` */
+function softClip(knee: number, ceiling: number): Float32Array<ArrayBuffer> {
+  const room = ceiling - knee;
+  return Float32Array.from({ length: 4097 }, (_, i) => {
+    const x = (i / 2048 - 1) * 2;
+    const a = Math.abs(x);
+    return a <= knee ? x : Math.sign(x) * (knee + room * Math.tanh((a - knee) / room));
+  });
+}
+
+/** Decibels to a gain */
+const dB = (db: number): number => Math.pow(10, db / 20);

package/src/engine/playback.ts

@@ -0,0 +1,349 @@
+// A song being played (one playback). Notes are scheduled ahead of time in small windows (call schedule() regularly, as the Jukebox does),
+// so timing stays sample-accurate while nothing is computed during playback except starting buffers and voices.
+
+import { getInstrument } from '../instruments/registry.ts';
+import { playNote } from '../instruments/play.ts';
+import { stepsPerBar } from '../notation/part.ts';
+import { DEFAULT_REVERB, trackName, type Song, type Track } from '../song.ts';
+import { tempoClock, type TempoClock } from '../tempo.ts';
+import { pump, sweep } from './automation.ts';
+import { compileSection, type CompiledSection, type ScheduledNote } from './compile.ts';
+import { createMixer, type Strip } from './mixer.ts';
+
+export interface PlaybackOptions {
+  /** When to start, in context seconds (default: 80 ms from now) */
+  at?: number;
+  /** Start this many seconds into the song (default 0) */
+  from?: number;
+  /** Fade in over this many seconds (default 0) */
+  fadeIn?: number;
+  /** How many times the body plays before the song ends (default: once if `song.loop` is false, otherwise forever) */
+  loops?: number;
+}
+
+/** One track of a playing song, for mixers and meters */
+export interface PlaybackTrack {
+  readonly name: string;
+  readonly instrument: string;
+  readonly section: 'intro' | 'loop';
+  /** The track's signal after its level, filters and ducking, before pan and effects (connect an AnalyserNode here for a meter) */
+  readonly output: AudioNode;
+  muted: boolean;
+}
+
+/** Where a playback is in its song */
+export interface SongPosition {
+  /** Seconds since the start of the song */
+  seconds: number;
+  section: 'intro' | 'loop';
+  /** Bar within the section, from 1 */
+  bar: number;
+  /** How many passes of the body have completed */
+  loop: number;
+}
+
+const INTRO = 0;
+const BODY = 1;
+
+export class Playback {
+  readonly song: Song;
+  readonly context: BaseAudioContext;
+  /** The song's output node */
+  readonly output: GainNode;
+  readonly tracks: readonly PlaybackTrack[];
+  /** Seconds */
+  readonly introDuration: number;
+  /** Seconds for one pass of the body */
+  readonly loopDuration: number;
+  /** Seconds from start to end (Infinity when the body loops forever) */
+  readonly duration: number;
+  /** Context time the song started (or would have started, when playing from a later point) */
+  readonly startTime: number;
+  /** Resolves when a song with an end reaches it (never resolves if stopped first) */
+  readonly finished: Promise<void>;
+  /** The song's tempo: steps from the start of the song (the intro's, then one pass of the body's) as seconds, and back */
+  readonly clock: TempoClock;
+
+  private readonly sections: [CompiledSection, CompiledSection];
+  private readonly strips: [Strip[], Strip[]];
+  /** Closes for the song's silences */
+  private readonly gate: GainNode;
+  /** Each section's silences, [from, to] in steps from its start */
+  private readonly silences: [[number, number][], [number, number][]];
+  /** Where each section starts on the clock, in steps */
+  private readonly base: [number, number];
+  private readonly loops: number;
+  private sec = INTRO;
+  private idx = 0;
+  /** Context time where the current section starts */
+  private secStart: number;
+  /** Completed passes of the body */
+  private passes = 0;
+  private state: 'playing' | 'ended' | 'stopped' = 'playing';
+  private resolveFinished!: () => void;
+
+  constructor(context: BaseAudioContext, destination: AudioNode, song: Song, options: PlaybackOptions = {}) {
+    this.context = context;
+    this.song = song;
+    const meter = song.meter ?? 16;
+    this.clock = tempoClock(song);
+    this.loops = Math.max(1, options.loops ?? (song.loop === false ? 1 : Infinity));
+    this.sections = [song.intro?.length ? compileSection(song.intro, meter) : { duration: 0, notes: [], ducks: [], desks: [] }, compileSection(song.tracks, meter)];
+    const introSteps = this.sections[INTRO].duration;
+    this.base = [0, introSteps];
+    this.introDuration = this.clock.seconds(introSteps);
+    this.loopDuration = this.clock.seconds(introSteps + this.sections[BODY].duration) - this.introDuration;
+    this.duration = this.introDuration + this.loops * this.loopDuration;
+    this.finished = new Promise((resolve) => (this.resolveFinished = resolve));
+
+    const mixer = createMixer(context, song, destination);
+    this.output = mixer.output;
+    this.gate = mixer.gate;
+    this.strips = mixer.strips;
+    this.silences = [INTRO, BODY].map((s) => {
+      const { duration } = this.sections[s];
+      return (song.silences ?? [])
+        .map(({ bar, beats }): [number, number] => {
+          const from = (bar - 1) * stepsPerBar(meter) - this.base[s];
+          return [from, Math.min(duration, from + 4 * beats)];
+        })
+        .filter(([from, to]) => from >= 0 && from < duration && to > from);
+    }) as [[number, number][], [number, number][]];
+    this.tracks = [...trackHandles(song.intro ?? [], mixer.strips[INTRO], 'intro'), ...trackHandles(song.tracks, mixer.strips[BODY], 'loop')];
+
+    const at = options.at ?? context.currentTime + 0.08;
+    const fadeIn = options.fadeIn ?? 0;
+    this.output.gain.setValueAtTime(fadeIn > 0 ? 0 : 1, context.currentTime);
+    if (fadeIn > 0) {
+      this.output.gain.setValueAtTime(0, at);
+      this.output.gain.linearRampToValueAtTime(1, at + fadeIn);
+    }
+    const from = Math.min(Math.max(0, options.from ?? 0), this.duration - 0.001);
+    this.secStart = at;
+    if (from > 0) this.seek(from, at);
+    else this.automate(0);
+    this.startTime = at - from;
+  }
+
+  /** Still producing notes (not stopped, not past its end) */
+  get playing(): boolean {
+    return this.state === 'playing';
+  }
+
+  /** Schedule every note that starts before `until` (context seconds). Call this regularly, a little ahead of the clock. */
+  schedule(until: number): void {
+    if (this.state !== 'playing') return;
+    for (let guard = 0; guard < 64; guard++) {
+      const sec = this.sections[this.sec];
+      while (this.idx < sec.notes.length) {
+        const n = sec.notes[this.idx];
+        const at = this.timeOf(n.time);
+        if (at >= until) return;
+        this.fire(this.sec, n, at);
+        this.duckUnder(n.track, at);
+        this.idx++;
+      }
+      const end = this.secStart + (this.sec === INTRO ? this.introDuration : this.loopDuration);
+      if (end >= until) return;
+      if (this.sec === BODY) {
+        if (this.passes + 1 >= this.loops) {
+          this.end(end);
+          return;
+        }
+        this.passes++;
+      }
+      // Next section: after the intro comes the body; the body repeats
+      const again = this.sec === BODY;
+      this.secStart = end;
+      this.sec = BODY;
+      this.idx = 0;
+      this.automate(0, again);
+    }
+  }
+
+  /** Where the song is at a context time (default: now) */
+  position(time = this.context.currentTime): SongPosition {
+    const sectionStart = this.sec === INTRO ? 0 : this.introDuration + this.passes * this.loopDuration;
+    const seconds = Math.min(this.duration, Math.max(0, sectionStart + time - this.secStart));
+    const bar = (step: number) => Math.floor(step / stepsPerBar(this.song.meter) + 1e-6) + 1;
+    if (seconds < this.introDuration) return { seconds, section: 'intro', bar: bar(this.clock.step(seconds)), loop: 0 };
+    const inBody = seconds - this.introDuration;
+    const loop = Math.min(Math.floor(inBody / this.loopDuration), this.loops - 1);
+    const step = this.clock.step(this.introDuration + inBody - loop * this.loopDuration) - this.base[BODY];
+    return { seconds, section: 'loop', bar: bar(step), loop };
+  }
+
+  /** Fade out and release */
+  stop(fade = 0.8): void {
+    if (this.state === 'stopped') return;
+    this.state = 'stopped';
+    const now = this.context.currentTime;
+    const g = this.output.gain;
+    g.cancelScheduledValues(now);
+    g.setValueAtTime(g.value, now);
+    g.linearRampToValueAtTime(0, now + fade);
+    onClock(this.context, now + fade + 0.3, () => this.output.disconnect());
+  }
+
+  /** Context time of a step in the current section, with swing applied to on-grid steps */
+  private timeOf(step: number): number {
+    const { swing, swing16 } = this.song;
+    let s = step;
+    const i = Math.floor(step + 1e-6);
+    if (Math.abs(step - i) < 1e-6) {
+      if (swing && i % 4 === 2) s += swing * 2;
+      else if (swing16 && i % 2 === 1) s += swing16;
+    }
+    return this.at(s);
+  }
+
+  /** Context time of a step in the current section, on the grid */
+  private at(step: number): number {
+    const base = this.base[this.sec];
+    return this.secStart + this.clock.seconds(base + step) - this.clock.seconds(base);
+  }
+
+  /** Seconds between two steps of a section */
+  private span(section: number, from: number, to: number): number {
+    const base = this.base[section];
+    return this.clock.seconds(base + to) - this.clock.seconds(base + from);
+  }
+
+  private fire(section: number, n: ScheduledNote, at: number): void {
+    const track = this.trackOf(section, n.track);
+    const def = getInstrument(track.instrument);
+    const drum = def.kind === 'sample' && (def.variants ?? 0) > 0;
+    const humanize = track.humanize ?? (drum ? 0.003 : 0.008);
+    const t = Math.max(this.context.currentTime + 0.005, at + (Math.random() - 0.5) * humanize);
+    const vel = Math.min(1, n.velocity * (1 + (Math.random() - 0.5) * 0.1));
+    const dur = this.span(section, n.time, n.time + n.duration);
+    const transpose = track.transpose ?? 0;
+    const desk = this.sections[section].desks[n.track];
+    const pitches = n.pitches.length ? n.pitches : [0];
+    pitches.forEach((m, k) => {
+      playNote(track.instrument, {
+        ctx: this.context,
+        out: this.strips[section][n.track].input,
+        t: t + (n.strum ? k * n.strum : 0),
+        dur,
+        m: m ? m + transpose : 0,
+        vel,
+        bends: n.bends?.map(([s, bm]) => [this.span(section, n.time, n.time + s), bm + transpose] as [number, number]),
+        params: track.params,
+        desk,
+      });
+    });
+  }
+
+  /** Jump to `seconds` into the song; sustained notes already sounding at that point are picked up */
+  private seek(seconds: number, at: number): void {
+    let into = seconds;
+    if (seconds >= this.introDuration) {
+      this.passes = Math.floor((seconds - this.introDuration) / this.loopDuration);
+      into = seconds - this.introDuration - this.passes * this.loopDuration;
+      this.sec = BODY;
+    }
+    const base = this.base[this.sec];
+    const offset = this.clock.step(this.clock.seconds(base) + into) - base;
+    this.secStart = at - into;
+    const { notes, ducks } = this.sections[this.sec];
+    /** The last hit of each track that others duck under */
+    const hits = new Map<number, number>();
+    while (this.idx < notes.length && notes[this.idx].time < offset - 1e-9) {
+      const n = notes[this.idx++];
+      if (ducks[n.track].length) hits.set(n.track, n.time);
+      const left = n.time + n.duration - offset;
+      if (left > 0.5 && sustains(this.trackOf(this.sec, n.track))) {
+        const into = offset - n.time;
+        const bends = n.bends?.filter(([s]) => s > into).map(([s, m]) => [s - into, m] as [number, number]);
+        this.fire(this.sec, { ...n, time: offset, duration: left, bends }, at);
+      }
+    }
+    // Pick up the pumping, the filter sweeps and any silence where they would be by now
+    for (const [track, time] of hits) this.duckUnder(track, this.timeOf(time), at);
+    this.automate(offset);
+  }
+
+  /** A track's hit at `hit` (context seconds): the tracks that duck under it pump (picked up at `from` when the hit is past) */
+  private duckUnder(track: number, hit: number, from = hit): void {
+    for (const k of this.sections[this.sec].ducks[track]) pump(this.strips[this.sec][k].pump!, hit, from);
+  }
+
+  /**
+   * A pass of the current section begins (`from` steps in; `again` when it follows a pass of the same section): send its filters along
+   * their sweeps and close the gate for its silences. The gate shuts in 10 ms (a hard cut clicks) and is open again a few milliseconds
+   * before the music returns, so a note humanized early keeps its attack
+   */
+  private automate(from: number, again = false): void {
+    const { duration } = this.sections[this.sec];
+    for (const strip of this.strips[this.sec]) for (const s of strip.sweeps) sweep(s.cutoff, s.points, from, duration, (step) => this.at(step), again);
+    const gate = this.gate.gain;
+    for (const [a, b] of this.silences[this.sec]) {
+      if (b <= from) continue;
+      const start = this.at(Math.max(a, from));
+      const end = this.at(b);
+      if (a < from) gate.setValueAtTime(0, start);
+      else {
+        gate.setValueAtTime(1, start);
+        gate.linearRampToValueAtTime(0, start + 0.01);
+      }
+      gate.setValueAtTime(0, end - 0.009);
+      gate.linearRampToValueAtTime(1, end - 0.005);
+    }
+  }
+
+  private trackOf(section: number, index: number): Track {
+    return section === INTRO ? this.song.intro![index] : this.song.tracks[index];
+  }
+
+  /** A song with an end has played its last section: release after the reverb tail */
+  private end(at: number): void {
+    this.state = 'ended';
+    onClock(this.context, at, () => this.resolveFinished());
+    onClock(this.context, at + (this.song.reverb ?? DEFAULT_REVERB).size + 1.5, () => this.output.disconnect());
+  }
+}
+
+/**
+ * Run `fn` when the context's own clock reaches `time`. A wall-clock timer would drift from the audio: an offline render runs
+ * faster or slower than real time, and a suspended context does not advance at all.
+ */
+function onClock(ctx: BaseAudioContext, time: number, fn: () => void): void {
+  const tick = ctx.createConstantSource();
+  const silent = ctx.createGain();
+  silent.gain.value = 0;
+  tick.connect(silent).connect(ctx.destination);
+  tick.onended = () => {
+    tick.disconnect();
+    silent.disconnect();
+    fn();
+  };
+  tick.start(ctx.currentTime);
+  tick.stop(Math.max(ctx.currentTime, time));
+}
+
+/** Instruments whose notes can be picked up mid-way when seeking (pads, bowed strings, ambience), as opposed to struck ones */
+function sustains(track: Track): boolean {
+  const def = getInstrument(track.instrument);
+  return def.kind === 'live' || !!def.bow || !!def.loop;
+}
+
+function trackHandles(tracks: Track[], strips: Strip[], section: 'intro' | 'loop'): PlaybackTrack[] {
+  return tracks.map((track, i) => {
+    const { input, output } = strips[i];
+    let muted = false;
+    return {
+      name: trackName(track),
+      instrument: track.instrument,
+      section,
+      output,
+      get muted() {
+        return muted;
+      },
+      set muted(value: boolean) {
+        muted = value;
+        input.gain.setTargetAtTime(value ? 0 : (track.gain ?? 1), input.context.currentTime, 0.015);
+      },
+    };
+  });
+}

package/src/engine/prepare.ts

@@ -0,0 +1,15 @@
+// Render every sample a song needs before it plays, so playback never has to compute audio.
+
+import { prepareSamples, prepareSamplesSync } from '../instruments/samples.ts';
+import type { Song } from '../song.ts';
+import { sampleRequests } from './compile.ts';
+
+/** Render a song's samples in the background (yields to the main thread every 12 ms) */
+export function prepareSong(context: BaseAudioContext, song: Song): Promise<void> {
+  return prepareSamples(context, sampleRequests(song));
+}
+
+/** Render a song's samples right now (for short jingles and offline rendering) */
+export function prepareSongSync(context: BaseAudioContext, song: Song): void {
+  prepareSamplesSync(context, sampleRequests(song));
+}

package/src/engine/render.ts

@@ -0,0 +1,71 @@
+// Offline rendering: play a song into a buffer as fast as the machine allows (for exporting audio files, tests and measurements).
+
+import { songDuration, type Song } from '../song.ts';
+import { createOutputStage, mastersItself } from './output.ts';
+import { Playback } from './playback.ts';
+import { prepareSongSync } from './prepare.ts';
+
+export interface RenderOptions {
+  /** Seconds to render (default: the intro, `loops` passes of the body, and 3 s for the tail to ring out) */
+  duration?: number;
+  /** How many passes of the body (default 1) */
+  loops?: number;
+  /** Default 44100 */
+  sampleRate?: number;
+}
+
+/**
+ * Seconds of music scheduled at a time while rendering, as live playback schedules a little ahead of the clock: scheduled all at once,
+ * every note of a long song would sit in the audio graph from the start, and the render would take quadratic time
+ */
+const WINDOW = 1;
+
+/** Render a song to a stereo AudioBuffer, through the same output stage as live playback (browsers only: needs OfflineAudioContext) */
+export async function renderSong(song: Song, { duration, loops = 1, sampleRate = 44100 }: RenderOptions = {}): Promise<AudioBuffer> {
+  if (typeof OfflineAudioContext === 'undefined') throw new Error('renderSong needs OfflineAudioContext (a browser)');
+  const { intro, loop } = songDuration(song);
+  const length = duration ?? intro + loops * loop + 3;
+  const ctx = new OfflineAudioContext(2, Math.ceil(length * sampleRate), sampleRate);
+  prepareSongSync(ctx, song);
+  const out = mastersItself(song) ? ctx.destination : createOutputStage(ctx, ctx.destination);
+  const playback = new Playback(ctx, out, song, { at: 0.05, loops });
+  // Suspend the render once a window to schedule the next one
+  playback.schedule(2 * WINDOW);
+  for (let t = WINDOW; t < length; t += WINDOW) {
+    void ctx.suspend(t).then(() => {
+      playback.schedule(t + 2 * WINDOW);
+      void ctx.resume();
+    });
+  }
+  return ctx.startRendering();
+}
+
+/** Encode an AudioBuffer as a 16-bit PCM WAV file */
+export function encodeWav(buffer: AudioBuffer): ArrayBuffer {
+  const channels = buffer.numberOfChannels;
+  const frames = buffer.length;
+  const bytes = frames * channels * 2;
+  const out = new DataView(new ArrayBuffer(44 + bytes));
+  const text = (at: number, s: string) => [...s].forEach((c, i) => out.setUint8(at + i, c.charCodeAt(0)));
+  text(0, 'RIFF');
+  out.setUint32(4, 36 + bytes, true);
+  text(8, 'WAVE');
+  text(12, 'fmt ');
+  out.setUint32(16, 16, true);
+  out.setUint16(20, 1, true);
+  out.setUint16(22, channels, true);
+  out.setUint32(24, buffer.sampleRate, true);
+  out.setUint32(28, buffer.sampleRate * channels * 2, true);
+  out.setUint16(32, channels * 2, true);
+  out.setUint16(34, 16, true);
+  text(36, 'data');
+  out.setUint32(40, bytes, true);
+  const data = Array.from({ length: channels }, (_, c) => buffer.getChannelData(c));
+  for (let i = 0, at = 44; i < frames; i++) {
+    for (let c = 0; c < channels; c++, at += 2) {
+      const x = Math.max(-1, Math.min(1, data[c][i]));
+      out.setInt16(at, x < 0 ? x * 0x8000 : x * 0x7fff, true);
+    }
+  }
+  return out.buffer;
+}

package/src/index.ts

@@ -0,0 +1,28 @@
+// Polyphon: music for the browser, written as code.
+//
+//   Write    melody, rhythm, chords, pad, arpeggio, bassline, roots, strum, and the part transforms
+//   Declare  defineSong: tempo, room, tracks (instrument + part), mixing and mastering
+//   Play     Jukebox: crossfades, preloading, ducking, pause and seek
+//   Export   renderSong + encodeWav
+//   Import   songFromMidi, and transcribe for a sung melody
+//   Extend   registerInstrument
+
+export { melody, rhythm, type RhythmOptions } from './notation/melody.ts';
+export { formatMelody } from './notation/format.ts';
+export { chords, chordsDuration, pad, arpeggio, roots, bassline, strum, type Chord, type PadOptions, type ArpeggioOptions, type RootsOptions, type BasslineOptions, type StrumOptions } from './notation/harmony.ts';
+export { sequence, stack, repeat, rest, transpose, mapPitch, scaleVelocity, slice, pedal } from './notation/transform.ts';
+export { stepsPerBar, VELOCITY, type Note, type Part, type Meter } from './notation/part.ts';
+export { midi, frequency, noteName, parseChord, voiceChord, scaleDegree, remapToMode, romanChord, MODES, type Pitch, type Mode, type ChordInfo, type VoicingOptions } from './theory.ts';
+
+export { defineSong, songDuration, DEFAULT_REVERB, type Song, type Track, type Reverb, type Delay, type Master, type Duck, type Sweep, type Silence } from './song.ts';
+export { tempoClock, type TempoChange, type TempoClock } from './tempo.ts';
+
+export { Jukebox, type JukeboxOptions, type JukeboxState, type PlayOptions, type DuckOptions, type SongSource } from './engine/jukebox.ts';
+export { Playback, type PlaybackOptions, type PlaybackTrack, type SongPosition } from './engine/playback.ts';
+export { prepareSong, prepareSongSync } from './engine/prepare.ts';
+export { renderSong, encodeWav, type RenderOptions } from './engine/render.ts';
+export { compileSection, type CompiledSection, type ScheduledNote } from './engine/compile.ts';
+export { songFromMidi, type MidiImportOptions } from './midi.ts';
+export { PitchTracker, transcribe, type PitchFrame, type TranscribeOptions, type Transcription } from './transcribe.ts';
+
+export { registerInstrument, instrumentNames, type InstrumentName, type CustomInstrument, type CustomSampledInstrument, type CustomSynthInstrument, type SynthNote } from './instruments/registry.ts';