mk(n: number) → buffer

rd(b: buffer, i: number) → number

wr(b: buffer, i: number, v: number) → void

ad(b: buffer, i: number, v: number) → void

mix(dst: buffer, src: buffer, n: number, g: number) → void

Fold one buffer into another at a gain, so layers built apart can be mixed.

mixAt(dst: buffer, dstFrames: number, src: buffer, srcFrames: number, offset: number, g: number) → void

Fold one buffer into another starting at a frame offset, for placed events.

mixWrap(dst: buffer, dstFrames: number, src: buffer, srcFrames: number, offset: number, g: number) → void

Fold into a buffer that WRAPS, so an event straddling the loop seam is heard on both sides of it instead of being cut. Used by the beds.

reseed(s: number) → void

rnd( ) → number

rnd01( ) → number

0..1 rather than -1..1, for choosing times and pitches.

at(c: Curve, t: number) → number

env(peak: number, a: number, decay: number) → void

The common envelope: an attack in `a` seconds, then an exponential tail.

sine(b: buffer, n: number, sr: number, freq: Curve, amp: Curve, phase0: number?) → void

tri(b: buffer, n: number, sr: number, freq: Curve, amp: Curve) → void

Softer than a square, brighter than a sine: the body of most tuned things.

saw(b: buffer, n: number, sr: number, freq: Curve, amp: Curve, partials: number?) → void

A reedy stack: what a horn and the alien throats are built from.

noise(b: buffer, n: number, sr: number, amp: Curve) → void

lp1(b: buffer, n: number, sr: number, cut: Curve) → void

hp1(b: buffer, n: number, sr: number, cut: Curve) → void

svf(b: buffer, n: number, sr: number, cut: Curve, q: number, mode: string) → void

Chamberlin state-variable filter; the cutoff may move, which is a sweep.

softclip(b: buffer, n: number, drive: number) → void

gain(b: buffer, n: number, g: number) → void

normalise(b: buffer, n: number, peak: number) → void

ends(b: buffer, n: number, sr: number, ms: number) → void

A short fade at each end, so a one-shot never clicks on its own edges.

comb(dst: buffer, src: buffer, n: number, d: number, g: number) → void

allpass(b: buffer, n: number, d: number, g: number) → void

reverb(b: buffer, n: number, sr: number, wet: number, decay: number) → void

slap(b: buffer, n: number, sr: number, ms: number, g: number) → void

A single hard slapback off the canyon wall, cheaper than the room and the thing that actually reads as "fired in a pass".

wrapFold(b: buffer, n: number, x: number) → buffer

A bed is rendered `n + x` samples long and folded back on itself: the last `x` samples crossfade into the first `x`, so sample n-1 runs into sample 0 with no step. Tonal layers additionally use whole-cycles-per-loop frequencies (`cyc`), already continuous across the seam by construction.

cyc(want: number, seconds: number) → number

The nearest frequency to `want` that completes a whole number of cycles in `seconds`.

bedBuffer(sr: number, seconds: number) → void

A bed's working buffer: `n` frames of loop plus `x` frames of overlap.

bake(name: string, folder: string, samples: buffer, frames: number, sampleRate: number, channels: number, loop: boolean) → BakeReport

Encode and file one clip. `loop` decides both the codec and whether the seam is measured. Returns a report rather than raising, so a whole bank bakes and reports what failed instead of stopping at the first one.