@pinkpixel/haku 0.0.0-stage → 0.1.0

package/dist/src-JrRbTOJC.mjs

@@ -0,0 +1,701 @@
+import { S as DRUM_PIECE_IDS, T as INSTRUMENTS, i as buildSceneScore, p as createRng, r as buildArrangementScore } from "./src-D5fW7AC1.mjs";
+import * as Tone from "tone";
+// ../../packages/core/src/engine/types.ts
+function beatsToSeconds(beats, bpm) {
+	return beats * 60 / bpm;
+}
+// ../../packages/core/src/samples.ts
+function pickLayer(layers, velocity) {
+	return layers.find((l) => velocity <= l.maxVelocity) ?? layers[layers.length - 1];
+}
+// ../../packages/audio/src/bank.ts
+function manifestFiles(manifest) {
+	const files = /* @__PURE__ */ new Set();
+	for (const inst of Object.values(manifest.instruments)) for (const layer of inst?.layers ?? []) for (const f of Object.values(layer.zones)) files.add(f);
+	for (const layers of Object.values(manifest.drums.pieces)) for (const layer of layers ?? []) for (const f of layer.files) files.add(f);
+	for (const a of Object.values(manifest.ambience)) files.add(a.file);
+	return [...files];
+}
+async function loadSampleBank(manifest, decode, onProgress) {
+	const files = manifestFiles(manifest);
+	const buffers = /* @__PURE__ */ new Map();
+	let loaded = 0;
+	await Promise.all(files.map(async (file) => {
+		const audio = await decode(file);
+		buffers.set(file, new Tone.ToneAudioBuffer(audio));
+		onProgress?.(++loaded, files.length);
+	}));
+	return {
+		manifest,
+		buffers
+	};
+}
+function bankBuffer(bank, file) {
+	const buf = bank.buffers.get(file);
+	if (!buf) throw new Error(`Sample ${file} isn't loaded`);
+	return buf;
+}
+// ../../packages/audio/src/levels.ts
+/** Per-instrument trim in dB, applied after the voice. Brings samplers and synths to a common level. */
+const INSTRUMENT_TRIM_DB = {
+	piano: 0,
+	wurli: -9,
+	"fm-ep": -2,
+	glock: -9,
+	marimba: -2,
+	harp: -3,
+	pad: -11,
+	pluck: -6,
+	bass: -19,
+	drums: 0
+};
+/**
+* Extra gain per velocity layer, softest first. The VSCO piano's soft layer sits about 12 dB under
+* its loud one, which is realistic but too much for lofi comping.
+*/
+const SAMPLE_LAYER_LIFT_DB = { piano: [12, 0] };
+/** Sampled layers already carry their own dynamics, so velocity only shapes level a little within one. */
+const sampleVelocityGain = (v) => .45 + .55 * v;
+/** Per-piece trim in dB inside the drum kit. The kit was normalized as a whole, so this is balance only. */
+const DRUM_TRIM_DB = {
+	kick: 0,
+	snare: -3,
+	brush: 8,
+	rim: -4,
+	hat: -9,
+	brushhat: 2,
+	openhat: -12,
+	ride: -10,
+	tom: -4
+};
+/** Reverb return level at reverb = 1. */
+const REVERB_RETURN = .55;
+/** Faders (0 to 1) use a squared curve, which feels more even than linear. */
+function faderToGain(v) {
+	return Math.max(0, Math.min(1, v)) ** 2;
+}
+const dbToGain = (db) => 10 ** (db / 20);
+// ../../packages/audio/src/instruments.ts
+/** Brush size sets brightness: 0 is a dark ~1 kHz low-pass, 1 is wide open. */
+const brightnessHz = (b) => 1e3 * 2 ** (Math.max(0, Math.min(1, b)) * 4);
+/** Wraps a playable thing with a brightness filter and the instrument trim. */
+function filteredVoice(instrument, pick, nodes, filter) {
+	const output = new Tone.Gain(dbToGain(INSTRUMENT_TRIM_DB[instrument]));
+	filter.connect(output);
+	return {
+		output,
+		play(e, time, seconds) {
+			filter.frequency.setValueAtTime(brightnessHz(e.brightness), time);
+			pick(e).triggerAttackRelease(Tone.Frequency(e.midi, "midi").toFrequency(), seconds, time, e.velocity);
+		},
+		dispose() {
+			for (const n of nodes) n.dispose();
+			filter.dispose();
+			output.dispose();
+		}
+	};
+}
+function sampledVoice(instrument, bank) {
+	const def = bank.manifest.instruments[instrument];
+	if (!def) throw new Error(`No samples for ${instrument}`);
+	const filter = new Tone.Filter({
+		type: "lowpass",
+		frequency: 12e3,
+		rolloff: -12
+	});
+	const lifts = SAMPLE_LAYER_LIFT_DB[instrument] ?? [];
+	const nodes = [];
+	const layers = def.layers.map((layer, i) => {
+		const urls = {};
+		for (const [midi, file] of Object.entries(layer.zones)) urls[Number(midi)] = bankBuffer(bank, file);
+		const lift = new Tone.Gain(dbToGain(lifts[i] ?? 0)).connect(filter);
+		const sampler = new Tone.Sampler({
+			urls,
+			release: def.release
+		}).connect(lift);
+		nodes.push(sampler, lift);
+		return {
+			maxVelocity: layer.maxVelocity,
+			sampler
+		};
+	});
+	const play = (e) => {
+		const { sampler } = pickLayer(layers, e.velocity);
+		return {
+			triggerAttackRelease: (note, dur, time, velocity) => sampler.triggerAttackRelease(note, dur, time, sampleVelocityGain(velocity)),
+			dispose() {}
+		};
+	};
+	return filteredVoice(instrument, play, nodes, filter);
+}
+function synthVoice(instrument) {
+	const filter = new Tone.Filter({
+		type: "lowpass",
+		frequency: 8e3,
+		rolloff: -12
+	});
+	let synth;
+	switch (instrument) {
+		case "fm-ep":
+			synth = new Tone.PolySynth(Tone.FMSynth, {
+				harmonicity: 1,
+				modulationIndex: 3.5,
+				oscillator: { type: "sine" },
+				modulation: { type: "sine" },
+				envelope: {
+					attack: .002,
+					decay: 1.8,
+					sustain: .18,
+					release: .9
+				},
+				modulationEnvelope: {
+					attack: .002,
+					decay: .45,
+					sustain: .08,
+					release: .6
+				}
+			});
+			break;
+		case "pad":
+			synth = new Tone.PolySynth(Tone.Synth, {
+				oscillator: {
+					type: "fatsawtooth",
+					count: 3,
+					spread: 16
+				},
+				envelope: {
+					attack: .9,
+					decay: .6,
+					sustain: .8,
+					release: 2.4
+				}
+			});
+			filter.Q.value = .5;
+			break;
+		case "pluck":
+			synth = new Tone.PolySynth(Tone.Synth, {
+				oscillator: { type: "triangle" },
+				envelope: {
+					attack: .003,
+					decay: .4,
+					sustain: 0,
+					release: .35
+				}
+			});
+			break;
+		case "bass":
+			synth = new Tone.PolySynth(Tone.MonoSynth, {
+				oscillator: { type: "triangle" },
+				envelope: {
+					attack: .008,
+					decay: .35,
+					sustain: .65,
+					release: .35
+				},
+				filter: {
+					Q: 1,
+					type: "lowpass",
+					rolloff: -24
+				},
+				filterEnvelope: {
+					attack: .005,
+					decay: .25,
+					sustain: .35,
+					release: .4,
+					baseFrequency: 110,
+					octaves: 2.6
+				}
+			});
+			synth.maxPolyphony = 4;
+			break;
+		default: throw new Error(`${instrument} isn't a synth`);
+	}
+	synth.connect(filter);
+	return filteredVoice(instrument, () => synth, [synth], filter);
+}
+function drumVoice(bank) {
+	const output = new Tone.Gain(dbToGain(INSTRUMENT_TRIM_DB.drums));
+	const pieces = new Map(DRUM_PIECE_IDS.map((piece) => [piece, new Tone.Gain(dbToGain(DRUM_TRIM_DB[piece])).connect(output)]));
+	return {
+		output,
+		play(e, time) {
+			const piece = e.drum;
+			const layers = piece && bank.manifest.drums.pieces[piece];
+			if (!piece || !layers?.length) return;
+			const files = pickLayer(layers, e.velocity).files;
+			const file = files[Math.floor(e.time * 4 + .01) % files.length];
+			const src = new Tone.ToneBufferSource({
+				url: bankBuffer(bank, file),
+				context: output.context
+			}).connect(pieces.get(piece));
+			src.onended = () => src.dispose();
+			src.start(time, 0, void 0, e.velocity ** 1.2);
+		},
+		dispose() {
+			for (const g of pieces.values()) g.dispose();
+			output.dispose();
+		}
+	};
+}
+function createVoice(instrument, bank) {
+	if (INSTRUMENTS[instrument].kind === "drums") return drumVoice(bank);
+	if (bank.manifest.instruments[instrument]) return sampledVoice(instrument, bank);
+	return synthVoice(instrument);
+}
+// ../../packages/audio/src/master.ts
+/** Seconds of generated vinyl crackle. Long enough that the loop isn't noticeable. */
+const CRACKLE_SECONDS = 7;
+function crackleBuffer(sampleRate) {
+	const rand = createRng(7);
+	const data = new Float32Array(Math.floor(sampleRate * CRACKLE_SECONDS));
+	let i = 0;
+	while (i < data.length) {
+		i += Math.floor(-Math.log(1 - rand()) * sampleRate / 38);
+		const pop = rand() < .04;
+		const amp = (pop ? .6 + rand() * .4 : .05 + rand() ** 3 * .35) * (rand() < .5 ? -1 : 1);
+		const len = pop ? 24 + Math.floor(rand() * 40) : 2 + Math.floor(rand() * 6);
+		for (let k = 0; k < len && i + k < data.length; k++) data[i + k] += amp * Math.exp(-k / (len / 3));
+	}
+	let prevIn = 0;
+	let prevOut = 0;
+	for (let k = 0; k < data.length; k++) {
+		const x = data[k];
+		prevOut = .97 * (prevOut + x - prevIn);
+		prevIn = x;
+		data[k] = prevOut;
+	}
+	return Tone.ToneAudioBuffer.fromArray(data);
+}
+/** tanh curve, normalized so full scale in stays near full scale out. */
+function tapeCurve(drive = 2.2) {
+	const n = 2048;
+	const curve = new Float32Array(n);
+	const norm = Math.tanh(drive);
+	for (let i = 0; i < n; i++) {
+		const x = i / 2047 * 2 - 1;
+		curve[i] = Math.tanh(x * drive) / norm;
+	}
+	return curve;
+}
+var MasterChain = class {
+	input = new Tone.Gain(1);
+	ready;
+	drive = new Tone.Gain(1);
+	saturate = new Tone.WaveShaper(tapeCurve(), 2048);
+	trim = new Tone.Gain(1);
+	warmth = new Tone.Filter({
+		type: "lowpass",
+		frequency: 16e3,
+		rolloff: -12,
+		Q: .4
+	});
+	wobble = new Tone.Vibrato({
+		frequency: .55,
+		depth: 0,
+		maxDelay: .006,
+		type: "sine"
+	});
+	reverb = new Tone.Reverb({
+		decay: 3.2,
+		preDelay: .02,
+		wet: 1
+	});
+	reverbReturn = new Tone.Gain(0);
+	bus = new Tone.Gain(1);
+	highpass = new Tone.Filter({
+		type: "highpass",
+		frequency: 32,
+		rolloff: -12
+	});
+	comp = new Tone.Compressor({
+		threshold: -20,
+		ratio: 3,
+		attack: .015,
+		release: .25,
+		knee: 8
+	});
+	makeup = new Tone.Gain(dbToGain(6));
+	fader = new Tone.Gain(1);
+	limiter = new Tone.Limiter(-1);
+	crackle;
+	crackleGain = new Tone.Gain(0);
+	hiss = new Tone.Noise("pink");
+	hissGain = new Tone.Gain(0);
+	hissFilter = new Tone.Filter({
+		type: "bandpass",
+		frequency: 5e3,
+		Q: .4
+	});
+	rain = new Tone.Player({
+		loop: true,
+		fadeIn: 1.5,
+		fadeOut: .5
+	});
+	rainGain = new Tone.Gain(0);
+	rainFile = null;
+	bank;
+	constructor(bank) {
+		this.bank = bank;
+		this.input.chain(this.drive, this.saturate, this.trim, this.warmth, this.wobble);
+		this.wobble.connect(this.bus);
+		this.wobble.chain(this.reverb, this.reverbReturn, this.bus);
+		this.bus.chain(this.highpass, this.comp, this.makeup, this.fader, this.limiter, Tone.getDestination());
+		this.crackle = new Tone.Player({
+			url: crackleBuffer(Tone.getContext().sampleRate),
+			loop: true
+		});
+		this.crackle.chain(this.crackleGain, this.fader);
+		this.hiss.chain(this.hissFilter, this.hissGain, this.fader);
+		this.rain.chain(this.rainGain, this.fader);
+		this.ready = this.reverb.ready;
+	}
+	apply(mix) {
+		const w = mix.warmth;
+		this.drive.gain.value = dbToGain(w * 10);
+		this.trim.gain.value = dbToGain(-w * 8);
+		this.warmth.frequency.value = 16e3 * (2600 / 16e3) ** w;
+		this.wobble.depth.value = mix.wobble * .35;
+		this.wobble.frequency.value = .4 + mix.wobble * .5;
+		this.reverbReturn.gain.value = mix.reverb * REVERB_RETURN;
+		this.fader.gain.value = faderToGain(mix.master) * 1.56;
+		this.crackleGain.gain.value = mix.crackle > 0 ? dbToGain(-12) * mix.crackle ** 1.5 : 0;
+		this.hissGain.gain.value = mix.crackle > 0 ? dbToGain(-46) * mix.crackle : 0;
+		const file = this.bank.manifest.ambience[mix.rain.kind === "roof" ? "rain_roof" : "rain_window"].file;
+		if (file !== this.rainFile) {
+			this.rainFile = file;
+			this.rain.buffer = bankBuffer(this.bank, file);
+		}
+		this.rainGain.gain.value = mix.rain.enabled ? dbToGain(12) * faderToGain(mix.rain.level) : 0;
+	}
+	/** Starts crackle, hiss, and rain. They loop on their own clock, not the transport. */
+	startAmbience(time, rainOffset = 0) {
+		if (this.crackle.state !== "started") this.crackle.start(time);
+		if (this.hiss.state !== "started") this.hiss.start(time);
+		if (this.rain.state !== "started" && this.rain.loaded) this.rain.start(time, rainOffset);
+	}
+	stopAmbience(time) {
+		this.crackle.stop(time);
+		this.hiss.stop(time);
+		this.rain.stop(time);
+	}
+	dispose() {
+		for (const n of [
+			this.input,
+			this.drive,
+			this.saturate,
+			this.trim,
+			this.warmth,
+			this.wobble,
+			this.reverb,
+			this.reverbReturn,
+			this.bus,
+			this.highpass,
+			this.comp,
+			this.makeup,
+			this.fader,
+			this.limiter,
+			this.crackle,
+			this.crackleGain,
+			this.hiss,
+			this.hissGain,
+			this.hissFilter,
+			this.rain,
+			this.rainGain
+		]) n.dispose();
+	}
+};
+// ../../packages/audio/src/rig.ts
+const BACKING = [
+	"chords",
+	"bass",
+	"drums"
+];
+/**
+* Backing tracks are per scene, so each scene's band volume holds in a full-song render.
+* Drawn layers already have unique ids.
+*/
+function trackKey(e, score) {
+	if (!e.track.startsWith("backing:")) return e.track;
+	const section = score.sections.findLast((s) => e.time >= s.start - .5) ?? score.sections[0];
+	return `${e.track}@${section?.sceneId ?? ""}`;
+}
+function trackSettings(project) {
+	const out = /* @__PURE__ */ new Map();
+	for (const scene of project.scenes) {
+		for (const layer of scene.layers) out.set(layer.id, {
+			volume: layer.volume,
+			pan: layer.pan
+		});
+		for (const part of BACKING) out.set(`backing:${part}@${scene.id}`, {
+			volume: scene.backing[part].volume,
+			pan: 0
+		});
+	}
+	return out;
+}
+var Rig = class {
+	master;
+	ready;
+	bank;
+	tracks = /* @__PURE__ */ new Map();
+	settings = /* @__PURE__ */ new Map();
+	part = null;
+	constructor(bank) {
+		this.bank = bank;
+		this.master = new MasterChain(bank);
+		this.ready = this.master.ready;
+	}
+	/** Applies volumes, pans, and the mix. Cheap, so the UI can call it on every change. */
+	sync(project) {
+		this.settings = trackSettings(project);
+		this.master.apply(project.mix);
+		for (const [key, track] of this.tracks) {
+			const s = this.settings.get(key);
+			if (!s) {
+				this.disposeTrack(key, track);
+				continue;
+			}
+			this.applySettings(track, s);
+		}
+	}
+	applySettings(track, s) {
+		const gain = faderToGain(s.volume) * 1.56;
+		track.channel.volume.value = gain > 0 ? Tone.gainToDb(gain) : -Infinity;
+		track.channel.pan.value = s.pan;
+	}
+	voice(key, instrument) {
+		let track = this.tracks.get(key);
+		if (!track) {
+			track = {
+				channel: new Tone.Channel().connect(this.master.input),
+				voices: /* @__PURE__ */ new Map()
+			};
+			this.applySettings(track, this.settings.get(key) ?? {
+				volume: .8,
+				pan: 0
+			});
+			this.tracks.set(key, track);
+		}
+		let voice = track.voices.get(instrument);
+		if (!voice) {
+			voice = createVoice(instrument, this.bank);
+			voice.output.connect(track.channel);
+			track.voices.set(instrument, voice);
+		}
+		return voice;
+	}
+	/**
+	* Schedules a score on the current context's transport, replacing whatever was scheduled before.
+	* Voices are created up front so nothing gets built in the middle of playback.
+	*/
+	schedule(score) {
+		this.part?.dispose();
+		const events = score.events.map((e) => {
+			const key = trackKey(e, score);
+			this.voice(key, e.instrument);
+			return {
+				time: Math.max(0, beatsToSeconds(e.time, score.bpm)),
+				e,
+				key,
+				seconds: Math.max(.03, beatsToSeconds(e.duration, score.bpm))
+			};
+		});
+		this.part = new Tone.Part((time, ev) => this.voice(ev.key, ev.e.instrument).play(ev.e, time, ev.seconds), events);
+		this.part.start(0);
+	}
+	clear() {
+		this.part?.dispose();
+		this.part = null;
+	}
+	disposeTrack(key, track) {
+		for (const v of track.voices.values()) v.dispose();
+		track.channel.dispose();
+		this.tracks.delete(key);
+	}
+	dispose() {
+		this.clear();
+		for (const [key, track] of this.tracks) this.disposeTrack(key, track);
+		this.master.dispose();
+	}
+};
+// ../../packages/audio/src/render.ts
+/** Humanize can nudge the first hit slightly before zero, so the transport starts a hair late. */
+const LEAD_IN = .05;
+function loopScore(score, loops) {
+	if (loops <= 1) return score;
+	const out = {
+		...score,
+		beats: score.beats * loops,
+		events: [],
+		chords: [],
+		sections: []
+	};
+	for (let i = 0; i < loops; i++) {
+		const at = i * score.beats;
+		out.events.push(...score.events.map((e) => ({
+			...e,
+			time: e.time + at
+		})));
+		out.chords.push(...score.chords.map((c) => ({
+			...c,
+			time: c.time + at
+		})));
+		out.sections.push(...score.sections.map((s) => ({
+			...s,
+			start: s.start + at
+		})));
+	}
+	return out;
+}
+function scoreFor(project, opts = {}) {
+	return opts.scope === "song" ? buildArrangementScore(project) : loopScore(buildSceneScore(project, opts.sceneId), opts.loops ?? 1);
+}
+async function renderProject(project, bank, opts = {}) {
+	const score = scoreFor(project, opts);
+	const sampleRate = opts.sampleRate ?? 44100;
+	const seconds = LEAD_IN + beatsToSeconds(score.beats, score.bpm) + (opts.tail ?? 3);
+	const buffer = (await Tone.Offline(async (ctx) => {
+		const rig = new Rig(bank);
+		rig.sync(project);
+		await rig.ready;
+		ctx.transport.bpm.value = score.bpm;
+		rig.schedule(score);
+		rig.master.startAmbience(0);
+		ctx.transport.start(LEAD_IN);
+	}, seconds, 2, sampleRate)).get();
+	if (!buffer) throw new Error("Render came back empty");
+	const channels = Array.from({ length: buffer.numberOfChannels }, (_, c) => buffer.getChannelData(c));
+	return {
+		sampleRate: buffer.sampleRate,
+		channels
+	};
+}
+/** Peak and RMS in dBFS, for checking the mix. */
+function measure({ channels }) {
+	let peak = 0;
+	let sum = 0;
+	let n = 0;
+	for (const ch of channels) for (let i = 0; i < ch.length; i++) {
+		const v = ch[i];
+		if (!Number.isFinite(v)) return {
+			peakDb: NaN,
+			rmsDb: NaN
+		};
+		peak = Math.max(peak, Math.abs(v));
+		sum += v * v;
+		n++;
+	}
+	const db = (x) => x > 0 ? 20 * Math.log10(x) : -Infinity;
+	return {
+		peakDb: db(peak),
+		rmsDb: db(Math.sqrt(sum / Math.max(1, n)))
+	};
+}
+// ../../packages/audio/src/wav.ts
+function encodeWav({ sampleRate, channels }) {
+	const numCh = channels.length;
+	const frames = channels[0]?.length ?? 0;
+	const dataBytes = frames * numCh * 2;
+	const out = new Uint8Array(44 + dataBytes);
+	const view = new DataView(out.buffer);
+	const text = (at, s) => {
+		for (let i = 0; i < s.length; i++) view.setUint8(at + i, s.charCodeAt(i));
+	};
+	text(0, "RIFF");
+	view.setUint32(4, 36 + dataBytes, true);
+	text(8, "WAVE");
+	text(12, "fmt ");
+	view.setUint32(16, 16, true);
+	view.setUint16(20, 1, true);
+	view.setUint16(22, numCh, true);
+	view.setUint32(24, sampleRate, true);
+	view.setUint32(28, sampleRate * numCh * 2, true);
+	view.setUint16(32, numCh * 2, true);
+	view.setUint16(34, 16, true);
+	text(36, "data");
+	view.setUint32(40, dataBytes, true);
+	let at = 44;
+	for (let i = 0; i < frames; i++) for (let c = 0; c < numCh; c++) {
+		const dither = (Math.random() - Math.random()) / 32768;
+		const s = Math.max(-1, Math.min(1, channels[c][i] + dither));
+		view.setInt16(at, Math.round(s * 32767), true);
+		at += 2;
+	}
+	return out;
+}
+// ../../packages/audio/src/loudness.ts
+/**
+* The two K-weighting stages for any sample rate (the spec only lists 48 kHz). This is the bilinear
+* form libebur128 uses; at 48 kHz it reproduces the spec's coefficients exactly.
+*/
+function kWeighting(fs) {
+	return [(() => {
+		const gain = 3.999843853973347;
+		const q = .7071752369554196;
+		const k = Math.tan(Math.PI * 1681.974450955533 / fs);
+		const vh = 10 ** (gain / 20);
+		const vb = vh ** .4996667741545416;
+		const a0 = 1 + k / q + k * k;
+		return {
+			b0: (vh + vb * k / q + k * k) / a0,
+			b1: 2 * (k * k - vh) / a0,
+			b2: (vh - vb * k / q + k * k) / a0,
+			a1: 2 * (k * k - 1) / a0,
+			a2: (1 - k / q + k * k) / a0
+		};
+	})(), (() => {
+		const q = .5003270373238773;
+		const k = Math.tan(Math.PI * 38.13547087602444 / fs);
+		const a0 = 1 + k / q + k * k;
+		return {
+			b0: 1,
+			b1: -2,
+			b2: 1,
+			a1: 2 * (k * k - 1) / a0,
+			a2: (1 - k / q + k * k) / a0
+		};
+	})()];
+}
+function filter(input, { b0, b1, b2, a1, a2 }) {
+	const out = new Float64Array(input.length);
+	let x1 = 0;
+	let x2 = 0;
+	let y1 = 0;
+	let y2 = 0;
+	for (let i = 0; i < input.length; i++) {
+		const x = input[i];
+		const y = b0 * x + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
+		out[i] = y;
+		x2 = x1;
+		x1 = x;
+		y2 = y1;
+		y1 = y;
+	}
+	return out;
+}
+const toLufs = (energy) => -.691 + 10 * Math.log10(energy);
+/** Integrated loudness in LUFS. -Infinity for silence or audio shorter than one 400 ms block. */
+function integratedLoudness({ sampleRate, channels }) {
+	const [shelf, highpass] = kWeighting(sampleRate);
+	const weighted = channels.map((ch) => filter(filter(ch, shelf), highpass));
+	const block = Math.round(.4 * sampleRate);
+	const hop = Math.round(.1 * sampleRate);
+	const length = channels[0]?.length ?? 0;
+	const energies = [];
+	for (let start = 0; start + block <= length; start += hop) {
+		let sum = 0;
+		for (const ch of weighted) {
+			let s = 0;
+			for (let i = start; i < start + block; i++) s += ch[i] * ch[i];
+			sum += s / block;
+		}
+		energies.push(sum);
+	}
+	const mean = (xs) => xs.reduce((a, b) => a + b, 0) / xs.length;
+	const loud = energies.filter((e) => toLufs(e) > -70);
+	if (!loud.length) return -Infinity;
+	const relative = toLufs(mean(loud)) - 10;
+	const gated = loud.filter((e) => toLufs(e) > relative);
+	return gated.length ? toLufs(mean(gated)) : -Infinity;
+}
+export { encodeWav, integratedLoudness, loadSampleBank, measure, renderProject };