@pinkpixel/haku 0.1.0 → 1.0.0

package/dist/{src-D5fW7AC1.mjs → src-Bz-0ulVm.mjs}

@@ -775,18 +775,36 @@ const INSTRUMENTS = {
 		kind: "tonal",
 		gm: 9
 	},
+	vibes: {
+		label: "Vibraphone",
+		range: [53, 86],
+		kind: "tonal",
+		gm: 11
+	},
 	marimba: {
 		label: "Marimba",
 		range: [55, 84],
 		kind: "tonal",
 		gm: 12
 	},
+	kalimba: {
+		label: "Kalimba",
+		range: [60, 83],
+		kind: "tonal",
+		gm: 108
+	},
 	harp: {
 		label: "Harp",
 		range: [48, 84],
 		kind: "tonal",
 		gm: 46
 	},
+	guitar: {
+		label: "Nylon guitar",
+		range: [45, 79],
+		kind: "tonal",
+		gm: 24
+	},
 	pad: {
 		label: "Warm pad",
 		range: [55, 79],
@@ -799,6 +817,18 @@ const INSTRUMENTS = {
 		kind: "tonal",
 		gm: 24
 	},
+	celesta: {
+		label: "Celesta",
+		range: [60, 96],
+		kind: "tonal",
+		gm: 8
+	},
+	musicbox: {
+		label: "Music box",
+		range: [64, 96],
+		kind: "tonal",
+		gm: 10
+	},
 	bass: {
 		label: "Round bass",
 		range: [31, 55],
@@ -890,6 +920,14 @@ const DRUM_PIECES = {
 	tom: {
 		label: "Tom",
 		gm: 45
+	},
+	shaker: {
+		label: "Shaker",
+		gm: 82
+	},
+	cabasa: {
+		label: "Cabasa",
+		gm: 69
 	}
 };
 const DRUM_PIECE_IDS = Object.keys(DRUM_PIECES);
@@ -918,7 +956,9 @@ const COMP_STYLES = [
 	"sustain",
 	"lazy",
 	"stabs",
-	"arp"
+	"arp",
+	"rolled",
+	"shells"
 ];
 const BASS_STYLES = [
 	"roots",
@@ -930,14 +970,18 @@ const CHORD_INSTRUMENTS = [
 	"wurli",
 	"fm-ep",
 	"pad",
-	"harp"
+	"harp",
+	"vibes",
+	"guitar"
 ];
 const GROOVE_IDS = [
 	"dusty",
 	"brushes",
 	"halftime",
 	"bossa",
-	"sparse"
+	"sparse",
+	"jazz-ride",
+	"lazy-kick"
 ];
 const WINDOW_SCENES = [
 	"rain",
@@ -1412,11 +1456,20 @@ function beatStrength(beat) {
 	if (Math.abs(inBar - Math.round(inBar)) > 1e-6) return "weak";
 	return Math.round(inBar) % 2 === 0 ? "strong" : "medium";
 }
+/**
+* The key's scale bent to fit the chord. When a chord brings in a note from outside the key (G# in
+* E7 over A minor), scale tones a half step from it drop out, so G and G# never both show up.
+* Chord tones always stay.
+*/
+function fittedScale(scale, chord) {
+	const outside = chord.filter((pc) => !scale.includes(pc));
+	return scale.filter((pc) => chord.includes(pc) || !outside.some((o) => mod12(pc - o) === 1 || mod12(o - pc) === 1));
+}
 /** The pitch classes a note is allowed to land on in this context. */
 function allowedPcs(ctx) {
 	const tonic = tonicPc(ctx.key);
-	const scale = scalePcs(ctx.key);
 	const chord = chordPcs(mod12(tonic + ctx.chord.root), ctx.chord.quality);
+	const scale = ctx.mode === "smart" ? fittedScale(scalePcs(ctx.key), chord) : scalePcs(ctx.key);
 	switch (ctx.mode) {
 		case "chromatic": return [
 			0,
@@ -1742,8 +1795,17 @@ function closeVoicing(order, bottom) {
 	}
 	return notes;
 }
-function candidateVoicings(rootPc, quality, range = VOICING_RANGE) {
-	const pcs = [...new Set(QUALITIES[quality].voicing.map((i) => mod12(rootPc + i)))];
+/**
+* The intervals a comping voicing uses. Rootless leaves the root to the bass, the way jazz pianists
+* comp, as long as at least three notes are left (plain triads keep their root).
+*/
+function voicingIntervals(quality, rootless = false) {
+	const all = QUALITIES[quality].voicing;
+	const without = all.filter((i) => mod12(i) !== 0);
+	return rootless && without.length >= 3 ? without : all;
+}
+function candidateVoicings(rootPc, quality, range = VOICING_RANGE, rootless = false) {
+	const pcs = [...new Set(voicingIntervals(quality, rootless).map((i) => mod12(rootPc + i)))];
 	const out = [];
 	for (let r = 0; r < pcs.length; r++) {
 		const order = [...pcs.slice(r), ...pcs.slice(0, r)];
@@ -1772,8 +1834,8 @@ function roughness(v) {
 	if (v[v.length - 1] > 74) penalty += 1.5;
 	return penalty;
 }
-function voiceChord(rootPc, quality, prev, range = VOICING_RANGE) {
-	const candidates = candidateVoicings(rootPc, quality, range);
+function voiceChord(rootPc, quality, prev, range = VOICING_RANGE, rootless = false) {
+	const candidates = candidateVoicings(rootPc, quality, range, rootless);
 	let best = candidates[0] ?? [];
 	let bestCost = Infinity;
 	for (const v of candidates) {
@@ -1810,6 +1872,11 @@ const GROOVES = {
 			kick: "o.......o.......",
 			brush: "g...X..g....X.g.",
 			brushhat: "x...x.o.x...x.o."
+		},
+		turnaround: {
+			kick: "o.......o.....o.",
+			brush: "g...X..g....XgXg",
+			brushhat: "x...x.o.x...x..."
 		}
 	},
 	halftime: {
@@ -1833,7 +1900,14 @@ const GROOVES = {
 		bar: {
 			kick: "x..ox..ox..ox..o",
 			rim: "x..x..x...x..x..",
-			hat: "o.g.o.g.o.g.o.g."
+			hat: "o.g.o.g.o.g.o.g.",
+			cabasa: ".g.o.g.o.g.o.g.o"
+		},
+		turnaround: {
+			kick: "x..ox..ox..ox..o",
+			rim: "..x..x...x..x...",
+			hat: "o.g.o.g.o.g.o.g.",
+			cabasa: ".g.o.g.o.g.o.gxo"
 		}
 	},
 	sparse: {
@@ -1843,6 +1917,46 @@ const GROOVES = {
 			kick: "x.......o.......",
 			rim: "........o.......",
 			ride: "o...o...o...o..."
+		},
+		turnaround: {
+			kick: "x.......o.....o.",
+			rim: "........o...o...",
+			ride: "o...o...o...o.o."
+		}
+	},
+	"jazz-ride": {
+		label: "Jazzy ride",
+		kit: "sticks",
+		bar: {
+			kick: "g...g...g...g...",
+			ride: "x...X..ox...X..o",
+			hat: "....o.......o...",
+			snare: "..........g....."
+		},
+		turnaround: {
+			kick: "g...g...g...g...",
+			ride: "x...X..ox...X...",
+			hat: "....o.......o...",
+			snare: "......g...g..xg."
+		}
+	},
+	"lazy-kick": {
+		label: "Lazy kick",
+		kit: "sticks",
+		bar: {
+			kick: "X.....x...X..x..",
+			snare: "....X.......X...",
+			shaker: "xgogxgogxgogxgog"
+		},
+		turnaround: {
+			kick: "X.....x...X.....",
+			snare: "....X.......X.gg",
+			shaker: "xgogxgogxgogx...",
+			openhat: "..............o."
+		},
+		lag: {
+			kick: .06,
+			snare: .03
 		}
 	}
 };
@@ -1866,6 +1980,12 @@ function grooveBar(id, turnaround) {
 	}
 	return hits.sort((a, b) => a.beat - b.beat);
 }
+/** Pushes the band's drum hits behind the grid by the groove's lag. Run after swing. */
+function applyGrooveLag(events, id) {
+	const lag = GROOVES[id].lag;
+	if (!lag) return;
+	for (const e of events) if (e.track === "backing:drums" && e.drum) e.time += lag[e.drum] ?? 0;
+}
 // ../../packages/core/src/engine/backing.ts
 /** Lays the progression across the scene, looping it if it's shorter than the scene. */
 function placeChords(progression, key, totalBeats) {
@@ -1885,6 +2005,16 @@ function placeChords(progression, key, totalBeats) {
 	}
 	return out;
 }
+/** Splits a chord into whole bars and hits each one the same way, clipped to the chord's length. */
+function perBar(beats, pattern) {
+	const hits = [];
+	for (let bar = 0; bar < beats; bar += 4) for (const h of pattern) if (bar + h.at < beats) hits.push({
+		...h,
+		at: bar + h.at,
+		len: Math.min(h.len, beats - bar - h.at)
+	});
+	return hits;
+}
 /** Hit times (beat offset, length) for one chord, by comping style. */
 function compRhythm(style, beats) {
 	switch (style) {
@@ -1898,19 +2028,44 @@ function compRhythm(style, beats) {
 			len: beats - .3,
 			strum: .035
 		}];
-		case "stabs": {
-			const hits = [];
-			for (let bar = 0; bar < beats; bar += 4) for (const [at, len] of [
-				[0, .9],
-				[1.5, .4],
-				[3, .4]
-			]) if (bar + at < beats) hits.push({
-				at: bar + at,
-				len: Math.min(len, beats - bar - at),
+		case "stabs": return perBar(beats, [
+			{
+				at: 0,
+				len: .9,
 				strum: .01
-			});
-			return hits;
-		}
+			},
+			{
+				at: 1.5,
+				len: .4,
+				strum: .01
+			},
+			{
+				at: 3,
+				len: .4,
+				strum: .01
+			}
+		]);
+		case "rolled": return perBar(beats, [{
+			at: 0,
+			len: 2.4,
+			strum: .08
+		}, {
+			at: 2.5,
+			len: 1.5,
+			strum: .07,
+			vel: .4
+		}]);
+		case "shells": return perBar(beats, [{
+			at: 0,
+			len: 1.2,
+			strum: .012,
+			vel: .52
+		}, {
+			at: 1.5,
+			len: 2.2,
+			strum: .012,
+			vel: .44
+		}]);
 		case "arp": return [];
 	}
 }
@@ -1923,7 +2078,7 @@ function compChords(placed, backing, carry) {
 		brightness: .6
 	};
 	for (const p of placed) {
-		const voicing = voiceChord(p.rootPc, p.chord.quality, carry.voicing);
+		const voicing = voiceChord(p.rootPc, p.chord.quality, carry.voicing, VOICING_RANGE, backing.style === "shells");
 		carry.voicing = voicing;
 		if (backing.style === "arp") {
 			const order = [...voicing, ...voicing.slice(1, -1).reverse()];
@@ -1943,7 +2098,7 @@ function compChords(placed, backing, carry) {
 				time: p.start + at,
 				duration: Math.max(.1, hit.len - i * hit.strum),
 				midi,
-				velocity: .5 - i * .03
+				velocity: (hit.vel ?? .5) - i * .03
 			});
 		});
 	}
@@ -2131,6 +2286,7 @@ function sceneEvents(project, scene, { offset = 0, pass = 0, carry = newCarry()
 	const kept = events.filter((e) => e.time < totalBeats);
 	for (const e of kept) e.duration = Math.min(e.duration, totalBeats - e.time);
 	applySwing(kept, project.swing);
+	if (backing && scene.backing.drums.enabled) applyGrooveLag(kept, scene.backing.drums.groove);
 	applyHumanize(kept, project.humanize, hashSeed(project.seed, scene.id), pass);
 	for (const e of kept) e.time += offset;
 	const flats = prefersFlats(project.key);

package/dist/{src-JrRbTOJC.mjs → src-DNP73wX3.mjs}

@@ -1,4 +1,4 @@
-import { S as DRUM_PIECE_IDS, T as INSTRUMENTS, i as buildSceneScore, p as createRng, r as buildArrangementScore } from "./src-D5fW7AC1.mjs";
+import { S as DRUM_PIECE_IDS, T as INSTRUMENTS, i as buildSceneScore, p as createRng, r as buildArrangementScore } from "./src-Bz-0ulVm.mjs";
 import * as Tone from "tone";
 // ../../packages/core/src/engine/types.ts
 function beatsToSeconds(beats, bpm) {
@@ -44,8 +44,13 @@ const INSTRUMENT_TRIM_DB = {
 	glock: -9,
 	marimba: -2,
 	harp: -3,
+	vibes: -9,
+	kalimba: -3,
+	guitar: -9,
 	pad: -11,
 	pluck: -6,
+	celesta: -4.5,
+	musicbox: -3,
 	bass: -19,
 	drums: 0
 };
@@ -66,7 +71,9 @@ const DRUM_TRIM_DB = {
 	brushhat: 2,
 	openhat: -12,
 	ride: -10,
-	tom: -4
+	tom: -4,
+	shaker: -3,
+	cabasa: -10
 };
 /** Reverb return level at reverb = 1. */
 const REVERB_RETURN = .55;
@@ -172,6 +179,46 @@ function synthVoice(instrument) {
 			});
 			filter.Q.value = .5;
 			break;
+		case "celesta":
+			synth = new Tone.PolySynth(Tone.FMSynth, {
+				harmonicity: 1,
+				modulationIndex: 16,
+				oscillator: { type: "sine" },
+				modulation: { type: "sine" },
+				envelope: {
+					attack: .002,
+					decay: 2.2,
+					sustain: 0,
+					release: 1.2
+				},
+				modulationEnvelope: {
+					attack: .001,
+					decay: .35,
+					sustain: .01,
+					release: .5
+				}
+			});
+			break;
+		case "musicbox":
+			synth = new Tone.PolySynth(Tone.FMSynth, {
+				harmonicity: 6.27,
+				modulationIndex: 24,
+				oscillator: { type: "sine" },
+				modulation: { type: "sine" },
+				envelope: {
+					attack: .001,
+					decay: 1.5,
+					sustain: 0,
+					release: .7
+				},
+				modulationEnvelope: {
+					attack: .001,
+					decay: .5,
+					sustain: 0,
+					release: .4
+				}
+			});
+			break;
 		case "pluck":
 			synth = new Tone.PolySynth(Tone.Synth, {
 				oscillator: { type: "triangle" },
@@ -550,7 +597,17 @@ function loopScore(score, loops) {
 function scoreFor(project, opts = {}) {
 	return opts.scope === "song" ? buildArrangementScore(project) : loopScore(buildSceneScore(project, opts.sceneId), opts.loops ?? 1);
 }
-async function renderProject(project, bank, opts = {}) {
+/**
+* Tone.Offline swaps Tone's global context while it runs, so two overlapping renders would build
+* nodes on each other's context. Renders wait their turn instead.
+*/
+let queue = Promise.resolve();
+function renderProject(project, bank, opts = {}) {
+	const run = queue.then(() => renderNow(project, bank, opts));
+	queue = run.catch(() => {});
+	return run;
+}
+async function renderNow(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);