buf(n: number) → buffer

A new mono f32 buffer of `n` samples, zeroed.

len(b: buffer) → number

How many samples a mono f32 buffer holds.

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

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

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

blend(dst: buffer, src: buffer, offset: number, gain: number) → void

Copy `src` into `dst` at `offset` samples, scaled by `gain`.

shape(wave: string, phase: number) → number

osc(b: buffer, sr: number, spec: OscSpec) → void

Add an oscillator into `b`. `freq` and `amp` may each be a number or a function of the elapsed seconds, which is what makes a glide or a swell one call rather than a loop the caller writes.

rng(seed: number) → void

A deterministic 0..1 pseudo-random stream. Seeded so a bake is the same every time it runs — a clip that differs between two machines is a clip whose checksum differs for no reason anybody can see.

noise(b: buffer, sr: number, spec: NoiseSpec) → void

Add white noise into `b`.

lowpass(b: buffer, sr: number, cutoffHz: number) → void

One-pole low pass, in place. Cheap and gentle: 6 dB/octave.

highpass(b: buffer, sr: number, cutoffHz: number) → void

One-pole high pass, in place.

bandpass(b: buffer, sr: number, freq: number, q: number) → void

A resonant band pass (biquad), in place. `q` above ~4 rings, which is what turns a noise burst into struck metal or a reed.

ad(t: number, attack: number, decay: number, curve: number?) → number

An attack/decay envelope value at `t` seconds, 0..1. `curve` above 1 makes the tail hang; below 1 it drops away.

decay(t: number, tau: number) → number

Exponential decay, 1 at t=0, `1/e` at t=tau.

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

Scale every sample.

normalize(b: buffer, peak: number) → void

Scale so the loudest sample sits at `peak`. A silent buffer is left alone.

saturate(b: buffer, drive: number) → void

Soft-clip through tanh so a stacked mix never hands the encoder a sample outside [-1, 1] — the encoder would take it, and the speaker would not.

removeDc(b: buffer) → void

Take out any DC offset. A bed with DC in it eats headroom and thumps at the loop seam even when the waveform itself is continuous.

fadeIn(b: buffer, sr: number, seconds: number) → void

Fade the first `seconds` up from silence, in place.

fadeOut(b: buffer, sr: number, seconds: number) → void

Fade the last `seconds` down to silence, in place.

resample(b: buffer, srcSr: number, dstSr: number) → buffer

Resample a mono buffer by linear interpolation. Coming DOWN in rate it low-passes first, because the alternative is folding everything above the new Nyquist back into the band as a whistle.

monoFromPcm(pcm: string, channels: number) → buffer

Read an interleaved f32 PCM payload (the string `audio.decode` hands back) into a MONO buffer, averaging the channels.

decodeMono(zaud: string) → void

Decode a `.soundClip`'s ZAUD payload into (mono buffer, sampleRate).

loopSeam(src: buffer, sr: number, loopSeconds: number, crossSeconds: number, startSeconds: number?) → void

Cut a SEAMLESS loop of `loopSeconds` out of a longer buffer. The seam is the whole point. Take the first `loopSeconds` and the last sample runs into the first with a step in it — a click, every cycle. So the material that follows the loop point is folded back over the head under an equal-power crossfade: for the first `crossSeconds`, the output is the head fading up under the continuation fading down. The output's last sample is then the source's, and its first sample is what the source itself played next, so the join is a join the source already made. The source must be at least `loopSeconds + crossSeconds` long; a shorter one comes back as (nil, why) rather than as a quietly wrong loop.

bestLoop(src: buffer, sr: number, loopSeconds: number, crossSeconds: number, starts: { number }) → void

Cut the CLEANEST loop the source can give. A crossfaded seam joins two samples that were adjacent in the source, so the join is almost always ordinary material — unless the loop point happens to land ON a transient the source itself makes, a drum hit or a struck bell, in which case the loop reproduces that step every cycle in a place it does not belong. Which offset that happens at is a property of the material and not something a caller can know, so this tries several and keeps the one whose join reads as quietest.

stats(b: buffer, sr: number) → Stats

What a buffer actually holds. `rms` at 0 is the failure that otherwise ships silently: a clip that decodes, reports a duration, and is silence.

seam(b: buffer, sr: number) → Seam

Measure the discontinuity a loop point would produce. A click IS a step in the waveform, so the honest question is not "is the step zero" — no real signal has that — but "is the step bigger than the steps the material makes anyway". `ratio` answers it in one number.