@pinkpixel/haku 0.0.0-stage → 0.1.0

package/dist/src-D5fW7AC1.mjs

@@ -0,0 +1,2313 @@
+import { z } from "zod";
+import * as midiModule from "@tonejs/midi";
+// ../../packages/core/src/theory/notes.ts
+const SHARP_NAMES = [
+	"C",
+	"C#",
+	"D",
+	"D#",
+	"E",
+	"F",
+	"F#",
+	"G",
+	"G#",
+	"A",
+	"A#",
+	"B"
+];
+const FLAT_NAMES = [
+	"C",
+	"Db",
+	"D",
+	"Eb",
+	"E",
+	"F",
+	"Gb",
+	"G",
+	"Ab",
+	"A",
+	"Bb",
+	"B"
+];
+const LETTERS = {
+	C: 0,
+	D: 2,
+	E: 4,
+	F: 5,
+	G: 7,
+	A: 9,
+	B: 11
+};
+const mod12 = (n) => (n % 12 + 12) % 12;
+/** Parses a pitch class like "C", "f#", "Bb", "Ebb". Returns null if it isn't one. */
+function parsePitchClass(name) {
+	const m = /^([A-Ga-g])([#b]*)$/.exec(name.trim());
+	if (!m) return null;
+	const base = LETTERS[m[1].toUpperCase()];
+	let shift = 0;
+	for (const ch of m[2]) shift += ch === "#" ? 1 : -1;
+	return mod12(base + shift);
+}
+/** Parses a note like "C4", "f#3", "Bb5" (C4 = 60) or a MIDI number string. */
+function parseNote(name) {
+	const trimmed = name.trim();
+	if (/^\d+$/.test(trimmed)) {
+		const n = Number(trimmed);
+		return n >= 0 && n <= 127 ? n : null;
+	}
+	const m = /^([A-Ga-g][#b]*)(-?\d)$/.exec(trimmed);
+	if (!m) return null;
+	const pc = parsePitchClass(m[1]);
+	if (pc === null) return null;
+	const letter = LETTERS[m[1][0].toUpperCase()];
+	const accidental = pc - letter > 6 ? pc - letter - 12 : pc - letter < -6 ? pc - letter + 12 : pc - letter;
+	const midi = (Number(m[2]) + 1) * 12 + letter + accidental;
+	return midi >= 0 && midi <= 127 ? midi : null;
+}
+function pcName(pc, flats = false) {
+	return (flats ? FLAT_NAMES : SHARP_NAMES)[mod12(pc)];
+}
+function noteName(midi, flats = false) {
+	return `${pcName(midi, flats)}${Math.floor(midi / 12) - 1}`;
+}
+// ../../packages/core/src/theory/scales.ts
+const MODES = [
+	"major",
+	"minor",
+	"dorian",
+	"mixolydian",
+	"lydian",
+	"phrygian"
+];
+const MODE_INTERVALS = {
+	major: [
+		0,
+		2,
+		4,
+		5,
+		7,
+		9,
+		11
+	],
+	minor: [
+		0,
+		2,
+		3,
+		5,
+		7,
+		8,
+		10
+	],
+	dorian: [
+		0,
+		2,
+		3,
+		5,
+		7,
+		9,
+		10
+	],
+	mixolydian: [
+		0,
+		2,
+		4,
+		5,
+		7,
+		9,
+		10
+	],
+	lydian: [
+		0,
+		2,
+		4,
+		6,
+		7,
+		9,
+		11
+	],
+	phrygian: [
+		0,
+		1,
+		3,
+		5,
+		7,
+		8,
+		10
+	]
+};
+/** Modes with a minor third use the minor pentatonic, the rest use the major one. */
+function isMinorMode(mode) {
+	return MODE_INTERVALS[mode][2] === 3;
+}
+function tonicPc(key) {
+	const pc = parsePitchClass(key.tonic);
+	if (pc === null) throw new Error(`Unknown tonic "${key.tonic}"`);
+	return pc;
+}
+/** Absolute pitch classes of the key's scale. */
+function scalePcs(key) {
+	const t = tonicPc(key);
+	return MODE_INTERVALS[key.mode].map((i) => mod12(t + i));
+}
+function pentatonicPcs(key) {
+	const t = tonicPc(key);
+	return (isMinorMode(key.mode) ? [
+		0,
+		3,
+		5,
+		7,
+		10
+	] : [
+		0,
+		2,
+		4,
+		7,
+		9
+	]).map((i) => mod12(t + i));
+}
+/** Whether to spell this key with flats. Based on the relative major's position on the circle of fifths. */
+function prefersFlats(key) {
+	if (key.tonic.includes("b")) return true;
+	if (key.tonic.includes("#")) return false;
+	const t = tonicPc(key);
+	const major = mod12(t + {
+		major: 0,
+		minor: 3,
+		dorian: -2,
+		mixolydian: 5,
+		lydian: -5,
+		phrygian: -4
+	}[key.mode]);
+	return [
+		5,
+		10,
+		3,
+		8,
+		1,
+		6
+	].includes(major);
+}
+function keyLabel(key) {
+	const pc = tonicPc(key);
+	return `${key.tonic.length > 1 ? key.tonic[0].toUpperCase() + key.tonic.slice(1) : FLAT_NAMES[pc]} ${key.mode}`;
+}
+// ../../packages/core/src/theory/chords.ts
+const QUALITIES = {
+	maj: {
+		tones: [
+			0,
+			4,
+			7
+		],
+		voicing: [
+			0,
+			4,
+			7
+		],
+		minor: false
+	},
+	m: {
+		tones: [
+			0,
+			3,
+			7
+		],
+		voicing: [
+			0,
+			3,
+			7
+		],
+		minor: true
+	},
+	dim: {
+		tones: [
+			0,
+			3,
+			6
+		],
+		voicing: [
+			0,
+			3,
+			6
+		],
+		minor: true
+	},
+	aug: {
+		tones: [
+			0,
+			4,
+			8
+		],
+		voicing: [
+			0,
+			4,
+			8
+		],
+		minor: false
+	},
+	sus2: {
+		tones: [
+			0,
+			2,
+			7
+		],
+		voicing: [
+			0,
+			2,
+			7
+		],
+		minor: false
+	},
+	sus4: {
+		tones: [
+			0,
+			5,
+			7
+		],
+		voicing: [
+			0,
+			5,
+			7
+		],
+		minor: false
+	},
+	add9: {
+		tones: [
+			0,
+			4,
+			7,
+			14
+		],
+		voicing: [
+			4,
+			14,
+			7,
+			0
+		],
+		minor: false
+	},
+	"6": {
+		tones: [
+			0,
+			4,
+			7,
+			9
+		],
+		voicing: [
+			4,
+			9,
+			7,
+			0
+		],
+		minor: false
+	},
+	m6: {
+		tones: [
+			0,
+			3,
+			7,
+			9
+		],
+		voicing: [
+			3,
+			9,
+			7,
+			0
+		],
+		minor: true
+	},
+	"69": {
+		tones: [
+			0,
+			4,
+			7,
+			9,
+			14
+		],
+		voicing: [
+			4,
+			9,
+			14,
+			7
+		],
+		minor: false
+	},
+	maj7: {
+		tones: [
+			0,
+			4,
+			7,
+			11
+		],
+		voicing: [
+			4,
+			11,
+			7,
+			0
+		],
+		minor: false
+	},
+	maj9: {
+		tones: [
+			0,
+			4,
+			7,
+			11,
+			14
+		],
+		voicing: [
+			4,
+			11,
+			14,
+			7
+		],
+		minor: false
+	},
+	m7: {
+		tones: [
+			0,
+			3,
+			7,
+			10
+		],
+		voicing: [
+			3,
+			10,
+			7,
+			0
+		],
+		minor: true
+	},
+	m9: {
+		tones: [
+			0,
+			3,
+			7,
+			10,
+			14
+		],
+		voicing: [
+			3,
+			10,
+			14,
+			7
+		],
+		minor: true
+	},
+	m11: {
+		tones: [
+			0,
+			3,
+			7,
+			10,
+			14,
+			17
+		],
+		voicing: [
+			3,
+			10,
+			14,
+			17
+		],
+		minor: true
+	},
+	"7": {
+		tones: [
+			0,
+			4,
+			7,
+			10
+		],
+		voicing: [
+			4,
+			10,
+			7,
+			0
+		],
+		minor: false
+	},
+	"9": {
+		tones: [
+			0,
+			4,
+			7,
+			10,
+			14
+		],
+		voicing: [
+			4,
+			10,
+			14,
+			7
+		],
+		minor: false
+	},
+	"13": {
+		tones: [
+			0,
+			4,
+			7,
+			10,
+			14,
+			21
+		],
+		voicing: [
+			4,
+			10,
+			14,
+			21
+		],
+		minor: false
+	},
+	"7b9": {
+		tones: [
+			0,
+			4,
+			7,
+			10,
+			13
+		],
+		voicing: [
+			4,
+			10,
+			13,
+			7
+		],
+		minor: false
+	},
+	"7sus4": {
+		tones: [
+			0,
+			5,
+			7,
+			10
+		],
+		voicing: [
+			5,
+			10,
+			7,
+			0
+		],
+		minor: false
+	},
+	"9sus4": {
+		tones: [
+			0,
+			5,
+			7,
+			10,
+			14
+		],
+		voicing: [
+			5,
+			10,
+			14,
+			7
+		],
+		minor: false
+	},
+	m7b5: {
+		tones: [
+			0,
+			3,
+			6,
+			10
+		],
+		voicing: [
+			3,
+			10,
+			6,
+			0
+		],
+		minor: true
+	},
+	dim7: {
+		tones: [
+			0,
+			3,
+			6,
+			9
+		],
+		voicing: [
+			3,
+			9,
+			6,
+			0
+		],
+		minor: true
+	}
+};
+const CHORD_QUALITIES = Object.keys(QUALITIES);
+/** Alternate spellings people (and agents) type, mapped to our canonical names. */
+const ALIASES = {
+	"": "maj",
+	M: "maj",
+	major: "maj",
+	min: "m",
+	minor: "m",
+	"-": "m",
+	mi: "m",
+	M7: "maj7",
+	Δ: "maj7",
+	Δ7: "maj7",
+	ma7: "maj7",
+	M9: "maj9",
+	Δ9: "maj9",
+	ma9: "maj9",
+	min7: "m7",
+	"-7": "m7",
+	mi7: "m7",
+	min9: "m9",
+	"-9": "m9",
+	min11: "m11",
+	"-11": "m11",
+	dom7: "7",
+	ø: "m7b5",
+	ø7: "m7b5",
+	"m7-5": "m7b5",
+	"°": "dim",
+	"°7": "dim7",
+	o: "dim",
+	o7: "dim7",
+	sus: "sus4",
+	"7sus": "7sus4",
+	"9sus": "9sus4",
+	"6/9": "69",
+	add2: "add9",
+	"+": "aug"
+};
+function normalizeQuality(q) {
+	if (q in QUALITIES) return q;
+	return ALIASES[q] ?? null;
+}
+function chordPcs(root, quality) {
+	return [...new Set(QUALITIES[quality].tones.map((t) => mod12(root + t)))];
+}
+/** Absolute root pitch class of a chord in a key. */
+function chordRootPc(chord, key) {
+	return mod12(tonicPc(key) + chord.root);
+}
+function chordSymbol(chord, key, flats) {
+	const root = pcName(chordRootPc(chord, key), flats);
+	return chord.quality === "maj" ? root : `${root}${chord.quality}`;
+}
+/** Parses an absolute chord symbol like "Em9", "Bbmaj7", "F#m7b5" into a root pitch class and quality. */
+function parseChordSymbol(symbol) {
+	const m = /^([A-Ga-g][#b]?)(.*)$/.exec(symbol.trim());
+	if (!m) return null;
+	const rootPc = parsePitchClass(m[1]);
+	const quality = normalizeQuality(m[2]);
+	if (rootPc === null || quality === null) return null;
+	return {
+		rootPc,
+		quality
+	};
+}
+// ../../packages/core/src/theory/progressions.ts
+const NUMERALS = [
+	"i",
+	"ii",
+	"iii",
+	"iv",
+	"v",
+	"vi",
+	"vii"
+];
+const NUMERAL_SEMITONES = [
+	0,
+	2,
+	4,
+	5,
+	7,
+	9,
+	11
+];
+/** Lowercase numerals turn bare "7"/"9"/"11"/"6" into their minor versions, the way people write them. */
+function qualityFor(suffix, lower) {
+	if (lower) {
+		const minorMap = {
+			"": "m",
+			"6": "m6",
+			"7": "m7",
+			"9": "m9",
+			"11": "m11"
+		};
+		if (suffix in minorMap) return normalizeQuality(minorMap[suffix]);
+	}
+	return normalizeQuality(suffix);
+}
+/** Parses one roman numeral chord like "ii9", "V13", "bVIImaj7", "viiø7". */
+function parseRoman(token) {
+	const m = /^([b#]?)(vii|iii|iv|vi|ii|v|i|VII|III|IV|VI|II|V|I)(.*)$/.exec(token.trim());
+	if (!m) return null;
+	const idx = NUMERALS.indexOf(m[2].toLowerCase());
+	const lower = m[2] === m[2].toLowerCase();
+	const quality = qualityFor(m[3], lower);
+	if (quality === null) return null;
+	const shift = m[1] === "b" ? -1 : m[1] === "#" ? 1 : 0;
+	return {
+		root: mod12(NUMERAL_SEMITONES[idx] + shift),
+		quality
+	};
+}
+/**
+* Parses a progression string. Tokens are roman numerals or chord symbols, separated by spaces or "|".
+* A ":N" suffix sets the length in beats (default 4), so "ii9:2 V13:2 Imaj9" packs two chords into one bar.
+*/
+function parseProgression(text, key) {
+	const tokens = text.split(/[\s|,]+/).filter(Boolean);
+	if (tokens.length === 0) throw new Error("Progression is empty");
+	return tokens.map((token) => {
+		const [body, beatsText] = token.split(":");
+		const beats = beatsText === void 0 ? 4 : Number(beatsText);
+		if (!Number.isFinite(beats) || beats <= 0 || beats > 32) throw new Error(`Bad chord length in "${token}"`);
+		const roman = parseRoman(body);
+		if (roman) return {
+			...roman,
+			beats
+		};
+		const symbol = parseChordSymbol(body);
+		if (symbol) return {
+			root: mod12(symbol.rootPc - tonicPc(key)),
+			quality: symbol.quality,
+			beats
+		};
+		throw new Error(`Can't read chord "${body}". Try a roman numeral like ii9 or a symbol like Em9.`);
+	});
+}
+function progressionBeats(progression) {
+	return progression.reduce((sum, c) => sum + c.beats, 0);
+}
+/** Finds the chord sounding at a beat. Progressions shorter than the scene loop around. */
+function chordAt(progression, beat) {
+	const total = progressionBeats(progression);
+	const cycle = Math.floor(beat / total) * total;
+	let pos = beat - cycle;
+	let start = cycle;
+	for (const chord of progression) {
+		if (pos < chord.beats) return {
+			chord,
+			start
+		};
+		pos -= chord.beats;
+		start += chord.beats;
+	}
+	return {
+		chord: progression[progression.length - 1],
+		start: cycle + total - progression[progression.length - 1].beats
+	};
+}
+function progressionText(progression, key) {
+	const flats = prefersFlats(key);
+	return progression.map((c) => chordSymbol(c, key, flats) + (c.beats === 4 ? "" : `:${c.beats}`)).join(" ");
+}
+const PROGRESSIONS = {
+	"jazzy-251": {
+		label: "Jazzy 2-5-1",
+		text: "ii9 V13 Imaj9 vi9"
+	},
+	"soft-turnaround": {
+		label: "Soft turnaround",
+		text: "Imaj9 vi9 ii9 V9sus4"
+	},
+	"rainy-minor": {
+		label: "Rainy minor",
+		text: "i9 iv9 bVIImaj7 bIIImaj7"
+	},
+	"neo-soul": {
+		label: "Neo soul",
+		text: "IVmaj9 iii7 vi9 Imaj9"
+	},
+	"late-night": {
+		label: "Late night",
+		text: "i9 bVImaj7 iv9 V7b9"
+	},
+	"dreamy-two": {
+		label: "Dreamy two-chord",
+		text: "Imaj9 IVmaj9"
+	},
+	"dorian-float": {
+		label: "Dorian float",
+		text: "i9 IV9 i9 IV9"
+	},
+	"sunday-walk": {
+		label: "Sunday walk",
+		text: "Imaj7 iii7 IVmaj7 iv6"
+	},
+	"city-lights": {
+		label: "City lights",
+		text: "vi9 ii9 V13 Imaj9"
+	},
+	"snowfall": {
+		label: "Snowfall",
+		text: "Imaj9 bVIImaj9 IVmaj9 iv6"
+	}
+};
+Object.keys(PROGRESSIONS);
+/** Accepts a preset id or a progression string. */
+function resolveProgression(textOrPreset, key) {
+	const preset = PROGRESSIONS[textOrPreset];
+	return parseProgression(preset ? preset.text : textOrPreset, key);
+}
+// ../../packages/core/src/model/constants.ts
+const INSTRUMENTS = {
+	piano: {
+		label: "Upright piano",
+		range: [55, 84],
+		kind: "tonal",
+		gm: 0
+	},
+	wurli: {
+		label: "Wurlitzer",
+		range: [55, 81],
+		kind: "tonal",
+		gm: 4
+	},
+	"fm-ep": {
+		label: "FM keys",
+		range: [55, 81],
+		kind: "tonal",
+		gm: 5
+	},
+	glock: {
+		label: "Glockenspiel",
+		range: [72, 96],
+		kind: "tonal",
+		gm: 9
+	},
+	marimba: {
+		label: "Marimba",
+		range: [55, 84],
+		kind: "tonal",
+		gm: 12
+	},
+	harp: {
+		label: "Harp",
+		range: [48, 84],
+		kind: "tonal",
+		gm: 46
+	},
+	pad: {
+		label: "Warm pad",
+		range: [55, 79],
+		kind: "tonal",
+		gm: 89
+	},
+	pluck: {
+		label: "Soft pluck",
+		range: [60, 84],
+		kind: "tonal",
+		gm: 24
+	},
+	bass: {
+		label: "Round bass",
+		range: [31, 55],
+		kind: "tonal",
+		gm: 33
+	},
+	drums: {
+		label: "Drums",
+		range: [0, 0],
+		kind: "drums",
+		gm: 0
+	}
+};
+const INSTRUMENT_IDS = Object.keys(INSTRUMENTS);
+/** Brushes decide the rhythmic grid a stroke is read on and how its notes are shaped. */
+const BRUSHES = {
+	pencil: {
+		label: "Pencil",
+		stepsPerBeat: 2,
+		velocity: .7,
+		note: "Melodies in eighth notes, held notes merge"
+	},
+	brush: {
+		label: "Brush",
+		stepsPerBeat: 1,
+		velocity: .55,
+		note: "Long soft notes on the beat"
+	},
+	chalk: {
+		label: "Chalk",
+		stepsPerBeat: 2,
+		velocity: .6,
+		note: "Two-note harmonies under the line"
+	},
+	spray: {
+		label: "Spray",
+		stepsPerBeat: 4,
+		velocity: .45,
+		note: "Scattered sparkly sixteenths"
+	},
+	stamp: {
+		label: "Stamp",
+		stepsPerBeat: 4,
+		velocity: .75,
+		note: "One hit per step, great for drums"
+	}
+};
+const BRUSH_IDS = Object.keys(BRUSHES);
+const HARMONY_MODES = [
+	"smart",
+	"scale",
+	"pentatonic",
+	"chord",
+	"chromatic"
+];
+const DRUM_PIECES = {
+	kick: {
+		label: "Kick",
+		gm: 36
+	},
+	snare: {
+		label: "Snare",
+		gm: 38
+	},
+	brush: {
+		label: "Brush snare",
+		gm: 40
+	},
+	rim: {
+		label: "Side stick",
+		gm: 37
+	},
+	hat: {
+		label: "Hi-hat",
+		gm: 42
+	},
+	brushhat: {
+		label: "Brush hat",
+		gm: 44
+	},
+	openhat: {
+		label: "Open hat",
+		gm: 46
+	},
+	ride: {
+		label: "Ride",
+		gm: 51
+	},
+	tom: {
+		label: "Tom",
+		gm: 45
+	}
+};
+const DRUM_PIECE_IDS = Object.keys(DRUM_PIECES);
+const DRUM_KITS = ["sticks", "brushes"];
+/** Rows of a drum layer from the bottom of the canvas to the top. */
+function drumRows(kit) {
+	return kit === "brushes" ? [
+		"kick",
+		"tom",
+		"brush",
+		"rim",
+		"brushhat",
+		"openhat",
+		"ride"
+	] : [
+		"kick",
+		"tom",
+		"snare",
+		"rim",
+		"hat",
+		"openhat",
+		"ride"
+	];
+}
+const COMP_STYLES = [
+	"sustain",
+	"lazy",
+	"stabs",
+	"arp"
+];
+const BASS_STYLES = [
+	"roots",
+	"walking",
+	"dub"
+];
+const CHORD_INSTRUMENTS = [
+	"piano",
+	"wurli",
+	"fm-ep",
+	"pad",
+	"harp"
+];
+const GROOVE_IDS = [
+	"dusty",
+	"brushes",
+	"halftime",
+	"bossa",
+	"sparse"
+];
+const WINDOW_SCENES = [
+	"rain",
+	"dusk",
+	"night-city",
+	"sunny",
+	"snow"
+];
+const RAIN_KINDS = ["roof", "window"];
+/** Layer colors, drawn from the Haku icon. */
+const LAYER_COLORS = [
+	"#e8897a",
+	"#8fae8b",
+	"#f2c48d",
+	"#a39bd1",
+	"#7fb7c9",
+	"#d98fb0",
+	"#c9a27e"
+];
+// ../../packages/core/src/model/schema.ts
+const unit = z.number().min(0).max(1);
+const KeySchema = z.object({
+	tonic: z.string().regex(/^[A-Ga-g][#b]?$/, "Tonic should look like C, F#, or Bb"),
+	mode: z.enum(MODES)
+});
+const ChordRefSchema = z.object({
+	root: z.number().int().min(0).max(11),
+	quality: z.enum(CHORD_QUALITIES),
+	beats: z.number().positive().max(32)
+});
+const StrokePointSchema = z.object({
+	x: unit,
+	y: unit,
+	/** Milliseconds since the stroke started. Drawing speed sets velocity when there's no pressure. */
+	t: z.number().min(0),
+	/** Pen pressure, 0 to 1. Leave it out for mouse input. */
+	p: unit.optional()
+});
+const StrokeSchema = z.object({
+	id: z.string(),
+	brush: z.enum(BRUSH_IDS),
+	/** Brush thickness, 0 to 1. Thicker strokes play softer and darker. */
+	size: unit,
+	points: z.array(StrokePointSchema).min(1),
+	/** Exact strokes skip harmony snapping and land on the nearest semitone. Used by draw_melody. */
+	exact: z.boolean().optional()
+});
+const LayerSchema = z.object({
+	id: z.string(),
+	name: z.string().min(1).max(40),
+	instrument: z.enum(INSTRUMENT_IDS),
+	color: z.string(),
+	volume: unit,
+	pan: z.number().min(-1).max(1),
+	muted: z.boolean(),
+	solo: z.boolean(),
+	harmony: z.enum(HARMONY_MODES),
+	octave: z.number().int().min(-2).max(2),
+	kit: z.enum(DRUM_KITS),
+	strokes: z.array(StrokeSchema)
+});
+const BackingSchema = z.object({
+	chords: z.object({
+		enabled: z.boolean(),
+		instrument: z.enum(CHORD_INSTRUMENTS),
+		style: z.enum(COMP_STYLES),
+		volume: unit
+	}),
+	bass: z.object({
+		enabled: z.boolean(),
+		style: z.enum(BASS_STYLES),
+		volume: unit
+	}),
+	drums: z.object({
+		enabled: z.boolean(),
+		groove: z.enum(GROOVE_IDS),
+		volume: unit
+	})
+});
+const SceneSchema = z.object({
+	id: z.string(),
+	name: z.string().min(1).max(40),
+	bars: z.number().int().min(1).max(16),
+	progression: z.array(ChordRefSchema).min(1),
+	layers: z.array(LayerSchema),
+	backing: BackingSchema
+});
+const MixSchema = z.object({
+	master: unit,
+	/** Low-pass and tape saturation. */
+	warmth: unit,
+	crackle: unit,
+	reverb: unit,
+	/** Tape wow and flutter. */
+	wobble: unit,
+	rain: z.object({
+		enabled: z.boolean(),
+		kind: z.enum(RAIN_KINDS),
+		level: unit
+	})
+});
+const ProjectSchema = z.object({
+	format: z.literal("haku"),
+	version: z.literal(1),
+	id: z.string(),
+	name: z.string().min(1).max(80),
+	createdAt: z.string(),
+	updatedAt: z.string(),
+	/** Seeds humanize and spray so the same project always plays the same way. */
+	seed: z.number().int(),
+	mood: z.string().nullable(),
+	window: z.enum(WINDOW_SCENES),
+	key: KeySchema,
+	bpm: z.number().min(50).max(140),
+	swing: unit,
+	humanize: unit,
+	mix: MixSchema,
+	scenes: z.array(SceneSchema).min(1),
+	arrangement: z.array(z.object({
+		sceneId: z.string(),
+		repeat: z.number().int().min(1).max(16)
+	})).min(1),
+	activeSceneId: z.string()
+});
+// ../../packages/core/src/model/moods.ts
+const MOODS = {
+	"rainy-study": {
+		label: "Rainy study",
+		bpm: 72,
+		key: {
+			tonic: "F",
+			mode: "major"
+		},
+		progression: "jazzy-251",
+		lead: "piano",
+		swing: .35,
+		window: "rain",
+		backing: {
+			chords: {
+				enabled: true,
+				instrument: "wurli",
+				style: "lazy",
+				volume: .6
+			},
+			bass: {
+				enabled: true,
+				style: "roots",
+				volume: .7
+			},
+			drums: {
+				enabled: true,
+				groove: "brushes",
+				volume: .65
+			}
+		},
+		mix: {
+			master: .8,
+			warmth: .55,
+			crackle: .35,
+			reverb: .4,
+			wobble: .25,
+			rain: {
+				enabled: true,
+				kind: "roof",
+				level: .45
+			}
+		}
+	},
+	"late-night-train": {
+		label: "Late-night train",
+		bpm: 68,
+		key: {
+			tonic: "A",
+			mode: "minor"
+		},
+		progression: "late-night",
+		lead: "wurli",
+		swing: .4,
+		window: "night-city",
+		backing: {
+			chords: {
+				enabled: true,
+				instrument: "piano",
+				style: "sustain",
+				volume: .55
+			},
+			bass: {
+				enabled: true,
+				style: "dub",
+				volume: .75
+			},
+			drums: {
+				enabled: true,
+				groove: "dusty",
+				volume: .7
+			}
+		},
+		mix: {
+			master: .8,
+			warmth: .65,
+			crackle: .45,
+			reverb: .45,
+			wobble: .4,
+			rain: {
+				enabled: true,
+				kind: "window",
+				level: .2
+			}
+		}
+	},
+	"sunny-cafe": {
+		label: "Sunny café",
+		bpm: 86,
+		key: {
+			tonic: "G",
+			mode: "major"
+		},
+		progression: "sunday-walk",
+		lead: "marimba",
+		swing: .2,
+		window: "sunny",
+		backing: {
+			chords: {
+				enabled: true,
+				instrument: "piano",
+				style: "stabs",
+				volume: .55
+			},
+			bass: {
+				enabled: true,
+				style: "walking",
+				volume: .65
+			},
+			drums: {
+				enabled: true,
+				groove: "bossa",
+				volume: .6
+			}
+		},
+		mix: {
+			master: .8,
+			warmth: .35,
+			crackle: .2,
+			reverb: .3,
+			wobble: .15,
+			rain: {
+				enabled: false,
+				kind: "roof",
+				level: .3
+			}
+		}
+	},
+	"dusk-walk": {
+		label: "Dusk walk",
+		bpm: 78,
+		key: {
+			tonic: "D",
+			mode: "dorian"
+		},
+		progression: "dorian-float",
+		lead: "harp",
+		swing: .3,
+		window: "dusk",
+		backing: {
+			chords: {
+				enabled: true,
+				instrument: "wurli",
+				style: "lazy",
+				volume: .55
+			},
+			bass: {
+				enabled: true,
+				style: "roots",
+				volume: .7
+			},
+			drums: {
+				enabled: true,
+				groove: "halftime",
+				volume: .65
+			}
+		},
+		mix: {
+			master: .8,
+			warmth: .5,
+			crackle: .3,
+			reverb: .45,
+			wobble: .3,
+			rain: {
+				enabled: false,
+				kind: "roof",
+				level: .3
+			}
+		}
+	},
+	"snowy-window": {
+		label: "Snowy window",
+		bpm: 64,
+		key: {
+			tonic: "Eb",
+			mode: "major"
+		},
+		progression: "snowfall",
+		lead: "glock",
+		swing: .25,
+		window: "snow",
+		backing: {
+			chords: {
+				enabled: true,
+				instrument: "pad",
+				style: "sustain",
+				volume: .5
+			},
+			bass: {
+				enabled: true,
+				style: "roots",
+				volume: .6
+			},
+			drums: {
+				enabled: true,
+				groove: "sparse",
+				volume: .5
+			}
+		},
+		mix: {
+			master: .8,
+			warmth: .6,
+			crackle: .3,
+			reverb: .6,
+			wobble: .2,
+			rain: {
+				enabled: false,
+				kind: "window",
+				level: .3
+			}
+		}
+	}
+};
+const MOOD_IDS = Object.keys(MOODS);
+function getMood(id) {
+	const mood = MOODS[id];
+	if (!mood) throw new Error(`Unknown mood "${id}". Try one of: ${MOOD_IDS.join(", ")}`);
+	return mood;
+}
+// ../../packages/core/src/rng.ts
+/** mulberry32: fast, tiny, and plenty random for musical jitter. */
+function createRng(seed) {
+	let a = seed >>> 0;
+	return () => {
+		a = a + 1831565813 >>> 0;
+		let t = a;
+		t = Math.imul(t ^ t >>> 15, t | 1);
+		t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+		return ((t ^ t >>> 14) >>> 0) / 4294967296;
+	};
+}
+/** Mixes strings and numbers into one 32-bit seed (FNV-1a). */
+function hashSeed(...parts) {
+	let h = 2166136261;
+	for (const part of parts) {
+		for (const ch of String(part)) {
+			h ^= ch.charCodeAt(0);
+			h = Math.imul(h, 16777619);
+		}
+		h ^= 255;
+		h = Math.imul(h, 16777619);
+	}
+	return h >>> 0;
+}
+/** Symmetric jitter in [-1, 1], a bit more likely near zero (sum of two uniforms). */
+function jitter(rng) {
+	return rng() + rng() - 1;
+}
+const ID_CHARS = "0123456789abcdefghijklmnopqrstuvwxyz";
+/** Short readable ids like "l_k3x9q2", easy for agents to type back. */
+function makeId(prefix) {
+	const bytes = crypto.getRandomValues(/* @__PURE__ */ new Uint8Array(6));
+	let id = "";
+	for (const b of bytes) id += ID_CHARS[b % 36];
+	return `${prefix}_${id}`;
+}
+// ../../packages/core/src/model/project.ts
+function createLayer({ name, instrument, color, index = 0 }) {
+	return {
+		id: makeId("l"),
+		name: name ?? INSTRUMENTS[instrument].label,
+		instrument,
+		color: color ?? LAYER_COLORS[index % LAYER_COLORS.length],
+		volume: .8,
+		pan: 0,
+		muted: false,
+		solo: false,
+		harmony: "smart",
+		octave: 0,
+		kit: "sticks",
+		strokes: []
+	};
+}
+function createScene(project, name, bars = 4) {
+	const mood = getMood(project.mood ?? "rainy-study");
+	return {
+		id: makeId("s"),
+		name,
+		bars,
+		progression: resolveProgression(mood.progression, project.key),
+		layers: [createLayer({
+			instrument: mood.lead,
+			name: "Melody"
+		})],
+		backing: structuredClone(mood.backing)
+	};
+}
+function createProject({ name = "Untitled loop", mood = "rainy-study", seed, bars = 4 } = {}) {
+	const preset = getMood(mood);
+	const now = (/* @__PURE__ */ new Date()).toISOString();
+	const base = {
+		key: { ...preset.key },
+		mood
+	};
+	const scene = createScene(base, "A", bars);
+	return {
+		format: "haku",
+		version: 1,
+		id: makeId("p"),
+		name,
+		createdAt: now,
+		updatedAt: now,
+		seed: seed ?? Math.floor(createRng(Date.now())() * 2 ** 31),
+		mood,
+		window: preset.window,
+		key: base.key,
+		bpm: preset.bpm,
+		swing: preset.swing,
+		humanize: .5,
+		mix: structuredClone(preset.mix),
+		scenes: [scene],
+		arrangement: [{
+			sceneId: scene.id,
+			repeat: 1
+		}],
+		activeSceneId: scene.id
+	};
+}
+/** Validates unknown data (a file, a bridge message) as a project. Throws with a readable message. */
+function parseProject(data) {
+	const result = ProjectSchema.safeParse(data);
+	if (!result.success) {
+		const issue = result.error.issues[0];
+		throw new Error(`Not a valid Haku project: ${issue.path.join(".") || "root"}: ${issue.message}`);
+	}
+	return result.data;
+}
+function findScene(project, sceneId) {
+	const id = sceneId ?? project.activeSceneId;
+	const scene = project.scenes.find((s) => s.id === id || s.name === id);
+	if (!scene) throw new Error(`No scene "${id}"`);
+	return scene;
+}
+/** Finds a layer by id or name. Searches the given scene, or the active one. */
+function findLayer(project, layerId, sceneId) {
+	const scene = findScene(project, sceneId);
+	const layer = layerId ? scene.layers.find((l) => l.id === layerId || l.name.toLowerCase() === layerId.toLowerCase()) : scene.layers.find((l) => INSTRUMENTS[l.instrument].kind === "tonal") ?? scene.layers[0];
+	if (!layer) throw new Error(layerId ? `No layer "${layerId}" in scene ${scene.name}` : `Scene ${scene.name} has no layers`);
+	return {
+		scene,
+		layer
+	};
+}
+// ../../packages/core/src/engine/snap.ts
+/** Beats 1 and 3 are strong, 2 and 4 medium, everything between weak. Assumes 4/4. */
+function beatStrength(beat) {
+	const inBar = (beat % 4 + 4) % 4;
+	if (Math.abs(inBar - Math.round(inBar)) > 1e-6) return "weak";
+	return Math.round(inBar) % 2 === 0 ? "strong" : "medium";
+}
+/** 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);
+	switch (ctx.mode) {
+		case "chromatic": return [
+			0,
+			1,
+			2,
+			3,
+			4,
+			5,
+			6,
+			7,
+			8,
+			9,
+			10,
+			11
+		];
+		case "scale": return scale;
+		case "pentatonic": return pentatonicPcs(ctx.key);
+		case "chord": return chord;
+		case "smart": {
+			if (ctx.strength === "strong" || ctx.long) return chord;
+			if (ctx.strength === "weak") return [.../* @__PURE__ */ new Set([...scale, ...chord])];
+			const safe = scale.filter((pc) => chord.includes(pc) || !chord.includes(mod12(pc - 1)));
+			return [.../* @__PURE__ */ new Set([...safe, ...chord])];
+		}
+	}
+}
+/** Snaps a continuous MIDI pitch (like 63.4) to the best allowed note inside the range. */
+function snapPitch(raw, ctx) {
+	const allowed = new Set(allowedPcs(ctx));
+	const [lo, hi] = ctx.range;
+	let best = Math.round(Math.min(hi, Math.max(lo, raw)));
+	let bestCost = Infinity;
+	for (let n = lo - 2; n <= hi + 2; n++) {
+		if (!allowed.has(mod12(n))) continue;
+		const outside = n < lo ? lo - n : n > hi ? n - hi : 0;
+		const cost = Math.abs(n - raw) + (ctx.prev === void 0 ? 0 : .08 * Math.abs(n - ctx.prev)) + outside * 2;
+		if (cost < bestCost) {
+			bestCost = cost;
+			best = n;
+		}
+	}
+	return best;
+}
+/** Moves a pitch by scale steps (positive is up), staying in the key. */
+function scaleStep(midi, steps, key) {
+	const scale = new Set(scalePcs(key));
+	let n = midi;
+	let remaining = Math.abs(steps);
+	const dir = Math.sign(steps);
+	while (remaining > 0) {
+		n += dir;
+		if (scale.has(mod12(n))) remaining--;
+	}
+	return n;
+}
+// ../../packages/core/src/engine/gestures.ts
+function measureStroke(stroke) {
+	const pts = stroke.points;
+	let minX = 1, maxX = 0, minY = 1, maxY = 0, length = 0;
+	for (const p of pts) {
+		minX = Math.min(minX, p.x);
+		maxX = Math.max(maxX, p.x);
+		minY = Math.min(minY, p.y);
+		maxY = Math.max(maxY, p.y);
+	}
+	for (let i = 1; i < pts.length; i++) length += Math.hypot(pts[i].x - pts[i - 1].x, pts[i].y - pts[i - 1].y);
+	const threshold = .012;
+	let reversals = 0;
+	let dir = 0;
+	let anchor = pts[0].y;
+	for (const p of pts) {
+		const d = p.y - anchor;
+		if (Math.abs(d) < threshold) continue;
+		const nd = Math.sign(d);
+		if (dir !== 0 && nd !== dir) reversals++;
+		dir = nd;
+		anchor = p.y;
+	}
+	return {
+		minX,
+		maxX,
+		minY,
+		maxY,
+		width: maxX - minX,
+		height: maxY - minY,
+		length,
+		durationMs: pts[pts.length - 1].t - pts[0].t,
+		reversals
+	};
+}
+function classifyStroke(stroke) {
+	const s = measureStroke(stroke);
+	if (stroke.points.length === 1 || s.width < .012 && s.height < .02) return "dot";
+	if (stroke.exact || stroke.brush === "stamp" || stroke.brush === "spray") return "line";
+	if (s.height > .06 && s.width < Math.max(.015, s.height * .15)) return "strum";
+	if (s.reversals >= 4 && s.width / s.reversals < .04 && s.height < .15) return "trill";
+	if (s.durationMs > 0 && s.durationMs < 180 && s.length > .03 && s.length < .12) return "flick";
+	return "line";
+}
+// ../../packages/core/src/engine/strokes.ts
+const clamp = (v, lo, hi) => Math.min(hi, Math.max(lo, v));
+function speedBetween(a, b) {
+	const dt = (b.t - a.t) / 1e3;
+	return dt > 0 ? Math.hypot(b.x - a.x, b.y - a.y) / dt : null;
+}
+/** Walks the stroke and records the y value at the center of every grid column it crosses. */
+function sampleColumns(points, columns) {
+	const colOf = (x) => clamp(Math.floor(x * columns), 0, columns - 1);
+	const samples = [];
+	const push = (s) => {
+		if (samples.length === 0 || samples[samples.length - 1].col !== s.col) samples.push(s);
+	};
+	const first = points[0];
+	push({
+		col: colOf(first.x),
+		y: first.y,
+		speed: points[1] ? speedBetween(first, points[1]) : null,
+		pressure: first.p
+	});
+	for (let i = 1; i < points.length; i++) {
+		const a = points[i - 1];
+		const b = points[i];
+		const dx = b.x - a.x;
+		if (Math.abs(dx) < 1e-9) continue;
+		const speed = speedBetween(a, b);
+		const from = colOf(a.x);
+		const to = colOf(b.x);
+		const step = to >= from ? 1 : -1;
+		for (let c = from; c !== to + step; c += step) {
+			const f = ((c + .5) / columns - a.x) / dx;
+			if (f < 0 || f > 1) continue;
+			const pressure = a.p === void 0 || b.p === void 0 ? void 0 : a.p + (b.p - a.p) * f;
+			push({
+				col: c,
+				y: a.y + (b.y - a.y) * f,
+				speed,
+				pressure
+			});
+		}
+	}
+	const last = points[points.length - 1];
+	if (points.length > 1) push({
+		col: colOf(last.x),
+		y: last.y,
+		speed: null,
+		pressure: last.p
+	});
+	return samples;
+}
+function velocityFor(sample, base, size) {
+	let v;
+	if (sample.pressure !== void 0) v = .25 + .7 * sample.pressure;
+	else if (sample.speed === null) v = base;
+	else v = base * (.75 + .5 * clamp(sample.speed / 1.2, 0, 1));
+	return clamp(v * (1 - .25 * size), .15, 1);
+}
+function layerRange(layer) {
+	const [lo, hi] = INSTRUMENTS[layer.instrument].range;
+	return [lo + layer.octave * 12, hi + layer.octave * 12];
+}
+/** The continuous pitch a y position points at, before snapping. */
+function yToPitch(y, range) {
+	return range[1] - clamp(y, 0, 1) * (range[1] - range[0]);
+}
+/** The y position that reads back as this exact pitch. */
+function pitchToY(midi, range) {
+	return clamp((range[1] - midi) / (range[1] - range[0]), 0, 1);
+}
+function strokeToNotes(stroke, ctx) {
+	if (INSTRUMENTS[ctx.layer.instrument].kind === "drums") return drumStrokeToNotes(stroke, ctx);
+	const brush = BRUSHES[stroke.brush];
+	const spb = stroke.exact ? 4 : brush.stepsPerBeat;
+	const totalBeats = ctx.bars * 4;
+	const columns = totalBeats * spb;
+	const stepLen = 1 / spb;
+	const range = layerRange(ctx.layer);
+	const brightness = clamp(1 - stroke.size * .7, 0, 1);
+	const rng = createRng(hashSeed(ctx.seed, stroke.id));
+	const base = {
+		track: ctx.layer.id,
+		instrument: ctx.layer.instrument,
+		source: "stroke",
+		brightness,
+		strokeId: stroke.id
+	};
+	const note = (time, duration, midi, velocity) => ({
+		...base,
+		time,
+		duration,
+		midi,
+		velocity
+	});
+	const snapAt = (beat, raw, prev, long = false) => {
+		if (stroke.exact) return clamp(Math.round(raw), 0, 127);
+		return snapPitch(raw, {
+			key: ctx.key,
+			chord: chordAt(ctx.progression, beat).chord,
+			mode: ctx.layer.harmony,
+			strength: beatStrength(beat),
+			long,
+			range,
+			prev
+		});
+	};
+	const gesture = classifyStroke(stroke);
+	const shape = measureStroke(stroke);
+	const firstVel = velocityFor({
+		speed: null,
+		pressure: stroke.points[0].p
+	}, brush.velocity, stroke.size);
+	if (gesture === "dot") {
+		const p = stroke.points[0];
+		const beat = Math.floor(clamp(p.x, 0, .9999) * columns) / spb;
+		const len = stroke.brush === "brush" ? 1 : stepLen;
+		return [note(beat, len, snapAt(beat, yToPitch(p.y, range), void 0, len >= 1), firstVel)];
+	}
+	if (gesture === "strum") {
+		const beat = Math.floor(clamp((shape.minX + shape.maxX) / 2, 0, .9999) * columns) / spb;
+		const { chord, start } = chordAt(ctx.progression, beat);
+		const pcs = new Set(chordPcs(mod12(tonicPc(ctx.key) + chord.root), chord.quality));
+		const top = Math.round(yToPitch(shape.minY, range));
+		const bottom = Math.round(yToPitch(shape.maxY, range));
+		const pitches = [];
+		for (let n = bottom; n <= top; n++) if (pcs.has(mod12(n))) pitches.push(n);
+		if (!(stroke.points[stroke.points.length - 1].y < stroke.points[0].y)) pitches.reverse();
+		const hold = Math.max(stepLen, Math.min(2, start + chord.beats - beat));
+		return pitches.slice(0, 6).map((m, i) => note(beat + i * .04, hold - i * .04, m, firstVel * (1 - i * .04)));
+	}
+	if (gesture === "trill") {
+		const startCol = Math.floor(clamp(shape.minX, 0, .9999) * totalBeats * 4);
+		const endCol = Math.max(startCol + 1, Math.ceil(clamp(shape.maxX, 0, 1) * totalBeats * 4));
+		const low = snapAt(startCol / 4, yToPitch((shape.minY + shape.maxY) / 2, range));
+		const high = scaleStep(low, 1, ctx.key);
+		const out = [];
+		for (let c = startCol; c < endCol; c++) out.push(note(c / 4, .25, (c - startCol) % 2 === 0 ? low : high, firstVel * .85));
+		return out;
+	}
+	if (gesture === "flick") {
+		const end = stroke.points[stroke.points.length - 1];
+		const beat = Math.floor(clamp(end.x, 0, .9999) * columns) / spb;
+		const main = snapAt(beat, yToPitch(end.y, range), void 0, true);
+		const grace = scaleStep(main, end.y < stroke.points[0].y ? -1 : 1, ctx.key);
+		const v = clamp(firstVel * 1.15, 0, 1);
+		const graceTime = Math.max(0, beat - .125);
+		return [note(graceTime, beat - graceTime || .125, grace, v * .7), note(beat, stepLen * 2, main, v)];
+	}
+	const samples = sampleColumns(stroke.points, columns);
+	const out = [];
+	let prev;
+	let lastCol = -2;
+	let melody;
+	let harmony;
+	for (const s of samples) {
+		const beat = s.col / spb;
+		const v = velocityFor(s, brush.velocity, stroke.size);
+		if (stroke.brush === "spray") {
+			if (rng() > .6) continue;
+			const raw = yToPitch(s.y, range) + jitter(rng) * 4;
+			out.push(note(beat, stepLen, snapAt(beat, raw), v * (.7 + rng() * .4)));
+			continue;
+		}
+		const midi = snapAt(beat, yToPitch(s.y, range), prev, stroke.brush === "brush");
+		if (melody && stroke.brush !== "stamp" && s.col === lastCol + 1 && melody.midi === midi) {
+			melody.duration += stepLen;
+			if (harmony) harmony.duration = melody.duration;
+		} else {
+			melody = note(beat, stepLen, midi, v);
+			out.push(melody);
+			harmony = void 0;
+			if (stroke.brush === "chalk") {
+				const below = chordToneBelow(midi, beat, ctx);
+				if (below !== null) out.push(harmony = note(beat, stepLen, below, v * .8));
+			}
+		}
+		prev = midi;
+		lastCol = s.col;
+	}
+	return out;
+}
+/** The closest chord tone at least a minor third below, for chalk harmonies. */
+function chordToneBelow(midi, beat, ctx) {
+	const { chord } = chordAt(ctx.progression, beat);
+	const pcs = new Set(chordPcs(mod12(tonicPc(ctx.key) + chord.root), chord.quality));
+	for (let n = midi - 3; n >= midi - 9; n--) if (pcs.has(mod12(n))) return n;
+	return null;
+}
+/** Drum layers split the canvas into rows, one per drum, bottom to top. */
+function drumStrokeToNotes(stroke, ctx) {
+	const brush = BRUSHES[stroke.brush];
+	const columns = ctx.bars * 4 * brush.stepsPerBeat;
+	const rows = drumRows(ctx.layer.kit);
+	const rng = createRng(hashSeed(ctx.seed, stroke.id));
+	const brightness = clamp(1 - stroke.size * .7, 0, 1);
+	const samples = classifyStroke(stroke) === "dot" ? sampleColumns(stroke.points.slice(0, 1), columns) : sampleColumns(stroke.points, columns);
+	const out = [];
+	for (const s of samples) {
+		if (stroke.brush === "spray" && rng() > .55) continue;
+		const piece = rows[clamp(Math.floor((1 - s.y) * rows.length), 0, rows.length - 1)];
+		const v = velocityFor(s, brush.velocity, stroke.size) * (stroke.brush === "spray" ? .55 : 1);
+		out.push({
+			time: s.col / brush.stepsPerBeat,
+			duration: .25,
+			midi: DRUM_PIECES[piece].gm,
+			velocity: v,
+			track: ctx.layer.id,
+			instrument: "drums",
+			source: "stroke",
+			drum: piece,
+			brightness,
+			strokeId: stroke.id
+		});
+	}
+	return out;
+}
+// ../../packages/core/src/engine/voicing.ts
+const VOICING_RANGE = [50, 76];
+function closeVoicing(order, bottom) {
+	const notes = [bottom];
+	for (let i = 1; i < order.length; i++) {
+		let n = notes[i - 1] + 1;
+		while (mod12(n) !== order[i]) n++;
+		notes.push(n);
+	}
+	return notes;
+}
+function candidateVoicings(rootPc, quality, range = VOICING_RANGE) {
+	const pcs = [...new Set(QUALITIES[quality].voicing.map((i) => mod12(rootPc + i)))];
+	const out = [];
+	for (let r = 0; r < pcs.length; r++) {
+		const order = [...pcs.slice(r), ...pcs.slice(0, r)];
+		let bottom = range[0];
+		while (mod12(bottom) !== order[0]) bottom++;
+		for (let b = bottom; b <= range[1]; b += 12) {
+			const close = closeVoicing(order, b);
+			out.push(close);
+			if (close.length >= 4) {
+				const drop = [...close];
+				drop[drop.length - 2] -= 12;
+				out.push(drop.sort((x, y) => x - y));
+			}
+		}
+	}
+	return out.filter((v) => v[0] >= range[0] - 2 && v[v.length - 1] <= range[1]);
+}
+/** How far the voices move, matching each note to its nearest neighbor in the other chord. */
+function movement(a, b) {
+	const nearest = (n, set) => Math.min(...set.map((m) => Math.abs(m - n)));
+	return (a.reduce((s, n) => s + nearest(n, b), 0) + b.reduce((s, n) => s + nearest(n, a), 0)) / 2;
+}
+function roughness(v) {
+	let penalty = 0;
+	for (let i = 1; i < v.length; i++) if (v[i - 1] < 53 && v[i] - v[i - 1] < 5) penalty += 3;
+	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);
+	let best = candidates[0] ?? [];
+	let bestCost = Infinity;
+	for (const v of candidates) {
+		const center = v.reduce((s, n) => s + n, 0) / v.length;
+		const cost = (prev ? movement(v, prev) : Math.abs(center - 62)) + roughness(v);
+		if (cost < bestCost) {
+			bestCost = cost;
+			best = v;
+		}
+	}
+	return best;
+}
+// ../../packages/core/src/engine/grooves.ts
+const GROOVES = {
+	dusty: {
+		label: "Dusty boom bap",
+		kit: "sticks",
+		bar: {
+			kick: "X......x..X.....",
+			snare: "....X.......X...",
+			hat: "x.o.x.o.x.ogx.o."
+		},
+		turnaround: {
+			kick: "X......x..X..x..",
+			snare: "....X.......X.g.",
+			hat: "x.o.x.o.x.ogx...",
+			openhat: "..............o."
+		}
+	},
+	brushes: {
+		label: "Brushes",
+		kit: "brushes",
+		bar: {
+			kick: "o.......o.......",
+			brush: "g...X..g....X.g.",
+			brushhat: "x...x.o.x...x.o."
+		}
+	},
+	halftime: {
+		label: "Half-time",
+		kit: "sticks",
+		bar: {
+			kick: "X.........x.....",
+			snare: "........X.......",
+			hat: "x.o.x.o.x.o.x.o."
+		},
+		turnaround: {
+			kick: "X.........x..o..",
+			snare: "........X.....g.",
+			hat: "x.o.x.o.x.o.x...",
+			openhat: "..............o."
+		}
+	},
+	bossa: {
+		label: "Lazy bossa",
+		kit: "sticks",
+		bar: {
+			kick: "x..ox..ox..ox..o",
+			rim: "x..x..x...x..x..",
+			hat: "o.g.o.g.o.g.o.g."
+		}
+	},
+	sparse: {
+		label: "Sparse",
+		kit: "sticks",
+		bar: {
+			kick: "x.......o.......",
+			rim: "........o.......",
+			ride: "o...o...o...o..."
+		}
+	}
+};
+const LEVELS = {
+	X: .95,
+	x: .72,
+	o: .5,
+	g: .28
+};
+function grooveBar(id, turnaround) {
+	const groove = GROOVES[id];
+	const pattern = turnaround && groove.turnaround ? groove.turnaround : groove.bar;
+	const hits = [];
+	for (const [piece, steps] of Object.entries(pattern)) for (let i = 0; i < steps.length; i++) {
+		const v = LEVELS[steps[i]];
+		if (v !== void 0) hits.push({
+			beat: i / 4,
+			piece,
+			velocity: v
+		});
+	}
+	return hits.sort((a, b) => a.beat - b.beat);
+}
+// ../../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) {
+	const out = [];
+	const tonic = tonicPc(key);
+	let t = 0;
+	for (let i = 0; t < totalBeats; i = (i + 1) % progression.length) {
+		const chord = progression[i];
+		const beats = Math.min(chord.beats, totalBeats - t);
+		out.push({
+			chord,
+			start: t,
+			beats,
+			rootPc: mod12(tonic + chord.root)
+		});
+		t += chord.beats;
+	}
+	return out;
+}
+/** Hit times (beat offset, length) for one chord, by comping style. */
+function compRhythm(style, beats) {
+	switch (style) {
+		case "sustain": return [{
+			at: 0,
+			len: beats,
+			strum: .01
+		}];
+		case "lazy": return [{
+			at: .06,
+			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),
+				strum: .01
+			});
+			return hits;
+		}
+		case "arp": return [];
+	}
+}
+function compChords(placed, backing, carry) {
+	const out = [];
+	const base = {
+		track: "backing:chords",
+		instrument: backing.instrument,
+		source: "chords",
+		brightness: .6
+	};
+	for (const p of placed) {
+		const voicing = voiceChord(p.rootPc, p.chord.quality, carry.voicing);
+		carry.voicing = voicing;
+		if (backing.style === "arp") {
+			const order = [...voicing, ...voicing.slice(1, -1).reverse()];
+			for (let i = 0; i * .5 < p.beats; i++) out.push({
+				...base,
+				time: p.start + i * .5,
+				duration: Math.min(.9, p.beats - i * .5),
+				midi: order[i % order.length],
+				velocity: i % 4 === 0 ? .55 : .42
+			});
+			continue;
+		}
+		for (const hit of compRhythm(backing.style, p.beats)) voicing.forEach((midi, i) => {
+			const at = hit.at + i * hit.strum;
+			out.push({
+				...base,
+				time: p.start + at,
+				duration: Math.max(.1, hit.len - i * hit.strum),
+				midi,
+				velocity: .5 - i * .03
+			});
+		});
+	}
+	return out;
+}
+const BASS_RANGE = [33, 52];
+function nearestInRange(pc, target, range = BASS_RANGE) {
+	let best = -1;
+	for (let n = range[0]; n <= range[1]; n++) if (mod12(n) === pc && (best < 0 || Math.abs(n - target) < Math.abs(best - target))) best = n;
+	return best;
+}
+function chordTone(p, kind) {
+	const tones = QUALITIES[p.chord.quality].tones.map((t) => t % 12);
+	const pick = (options, fallback) => options.find((o) => tones.includes(o)) ?? fallback;
+	const interval = kind === "third" ? pick([
+		4,
+		3,
+		5,
+		2
+	], 4) : kind === "fifth" ? pick([
+		7,
+		6,
+		8
+	], 7) : pick([
+		10,
+		11,
+		9
+	], 10);
+	return mod12(p.rootPc + interval);
+}
+function bassLine(placed, style, carry) {
+	const out = [];
+	const base = {
+		track: "backing:bass",
+		instrument: "bass",
+		source: "bass",
+		brightness: .5
+	};
+	const add = (time, duration, midi, velocity) => {
+		out.push({
+			...base,
+			time,
+			duration,
+			midi,
+			velocity
+		});
+		carry.last = midi;
+	};
+	placed.forEach((p, idx) => {
+		const root = nearestInRange(p.rootPc, carry.last);
+		const fifth = nearestInRange(chordTone(p, "fifth"), root + 5);
+		const next = placed[idx + 1] ?? placed[0];
+		if (style === "walking") {
+			const tones = [
+				root,
+				nearestInRange(chordTone(p, "third"), root + 4),
+				fifth,
+				nearestInRange(chordTone(p, "seventh"), root + 9)
+			];
+			for (let b = 0; b < p.beats; b++) {
+				const last = b === Math.ceil(p.beats) - 1 && p.beats > 1;
+				const nextRoot = nearestInRange(next.rootPc, carry.last);
+				const midi = b === 0 ? root : last ? nextRoot + (nextRoot > carry.last ? -1 : 1) : tones[b % tones.length];
+				add(p.start + b, .9, midi, b === 0 ? .78 : .62);
+			}
+			return;
+		}
+		for (let bar = 0; bar < p.beats; bar += 4) {
+			const left = p.beats - bar;
+			if (style === "roots") {
+				add(p.start + bar, Math.min(2.75, left - .1), root, .75);
+				if (left > 3) add(p.start + bar + 3, .75, bar % 8 === 0 ? fifth : root + 12 <= BASS_RANGE[1] ? root + 12 : root, .6);
+			} else {
+				add(p.start + bar, Math.min(1.5, left - .1), root, .8);
+				if (left > 2.5) add(p.start + bar + 2.5, .4, root, .55);
+				if (left > 3.5) add(p.start + bar + 3.5, .4, fifth, .5);
+			}
+		}
+	});
+	return out;
+}
+function drumPart(groove, totalBeats) {
+	const out = [];
+	const bars = Math.ceil(totalBeats / 4);
+	for (let bar = 0; bar < bars; bar++) {
+		const turnaround = bar === bars - 1 || bar % 4 === 3;
+		for (const hit of grooveBar(groove, turnaround)) {
+			const time = bar * 4 + hit.beat;
+			if (time >= totalBeats) continue;
+			out.push({
+				time,
+				duration: .25,
+				midi: DRUM_PIECES[hit.piece].gm,
+				velocity: hit.velocity,
+				track: "backing:drums",
+				instrument: "drums",
+				source: "drums",
+				drum: hit.piece,
+				brightness: .6
+			});
+		}
+	}
+	return out;
+}
+// ../../packages/core/src/engine/humanize.ts
+const SIXTEENTH = .25;
+/**
+* Pushes offbeat sixteenths late. At 1.0 they land on the triplet (a third of the beat after the
+* eighth), which is about as swung as lofi gets. Notes that aren't on an offbeat sixteenth are untouched.
+*/
+function swingTime(time, amount) {
+	const inPair = time % (SIXTEENTH * 2);
+	if (Math.abs(inPair - SIXTEENTH) > .01) return time;
+	return time + amount * (1 / 3 - SIXTEENTH);
+}
+function applySwing(events, amount) {
+	if (amount <= 0) return;
+	for (const e of events) {
+		const swung = swingTime(e.time, amount);
+		e.duration = Math.max(.05, e.duration - (swung - e.time));
+		e.time = swung;
+	}
+}
+/** Backbeats drag a little behind the grid, kicks stay tight. That lazy push-pull is half the genre. */
+const DRUM_LAG = {
+	snare: .012,
+	brush: .016,
+	rim: .01
+};
+/**
+* Nudges timing and velocity by small seeded amounts. The same seed and pass always give the same
+* result, so repeats of a scene vary from each other but a project plays the same everywhere.
+*/
+function applyHumanize(events, amount, seed, pass = 0) {
+	if (amount <= 0) return;
+	const rngs = /* @__PURE__ */ new Map();
+	for (const e of events) {
+		let rng = rngs.get(e.track);
+		if (!rng) rngs.set(e.track, rng = createRng(hashSeed(seed, e.track, pass)));
+		const tight = e.drum === "kick" ? .5 : 1;
+		const lag = e.drum ? (DRUM_LAG[e.drum] ?? 0) * amount : 0;
+		e.time = Math.max(0, e.time + jitter(rng) * .022 * amount * tight + lag);
+		e.velocity = Math.min(1, Math.max(.05, e.velocity * (1 + jitter(rng) * .14 * amount)));
+	}
+}
+// ../../packages/core/src/engine/score.ts
+const newCarry = () => ({
+	voicing: null,
+	bassLast: 40
+});
+/** Which layers are audible: if anything is soloed, only soloed layers play (and the backing sits out). */
+function audibleLayers(scene) {
+	const anySolo = scene.layers.some((l) => l.solo);
+	return {
+		layers: scene.layers.filter((l) => anySolo ? l.solo : !l.muted),
+		backing: !anySolo
+	};
+}
+function sceneEvents(project, scene, { offset = 0, pass = 0, carry = newCarry() } = {}) {
+	const totalBeats = scene.bars * 4;
+	const events = [];
+	const { layers, backing } = audibleLayers(scene);
+	for (const layer of layers) for (const stroke of layer.strokes) events.push(...strokeToNotes(stroke, {
+		key: project.key,
+		progression: scene.progression,
+		bars: scene.bars,
+		layer,
+		seed: project.seed
+	}));
+	const placed = placeChords(scene.progression, project.key, totalBeats);
+	if (backing) {
+		const b = scene.backing;
+		if (b.chords.enabled) {
+			const v = { voicing: carry.voicing };
+			events.push(...compChords(placed, b.chords, v));
+			carry.voicing = v.voicing;
+		}
+		if (b.bass.enabled) {
+			const c = { last: carry.bassLast };
+			events.push(...bassLine(placed, b.bass.style, c));
+			carry.bassLast = c.last;
+		}
+		if (b.drums.enabled) events.push(...drumPart(b.drums.groove, totalBeats));
+	}
+	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);
+	applyHumanize(kept, project.humanize, hashSeed(project.seed, scene.id), pass);
+	for (const e of kept) e.time += offset;
+	const flats = prefersFlats(project.key);
+	const chords = placed.map((p) => ({
+		time: p.start + offset,
+		duration: p.beats,
+		symbol: chordSymbol(p.chord, project.key, flats),
+		rootPc: p.rootPc,
+		pcs: chordPcs(p.rootPc, p.chord.quality)
+	}));
+	return {
+		events: kept.sort((a, b) => a.time - b.time || a.midi - b.midi),
+		chords
+	};
+}
+/** One scene on its own, the way the canvas loops it. */
+function buildSceneScore(project, sceneId) {
+	const scene = findScene(project, sceneId);
+	const { events, chords } = sceneEvents(project, scene);
+	return {
+		bpm: project.bpm,
+		beats: scene.bars * 4,
+		events,
+		chords,
+		sections: [{
+			sceneId: scene.id,
+			name: scene.name,
+			start: 0,
+			beats: scene.bars * 4
+		}]
+	};
+}
+/** The whole song: every arrangement entry, repeats included. */
+function buildArrangementScore(project) {
+	const carry = newCarry();
+	const score = {
+		bpm: project.bpm,
+		beats: 0,
+		events: [],
+		chords: [],
+		sections: []
+	};
+	for (const item of project.arrangement) {
+		const scene = findScene(project, item.sceneId);
+		for (let pass = 0; pass < item.repeat; pass++) {
+			const { events, chords } = sceneEvents(project, scene, {
+				offset: score.beats,
+				pass,
+				carry
+			});
+			score.events.push(...events);
+			score.chords.push(...chords);
+			score.sections.push({
+				sceneId: scene.id,
+				name: scene.name,
+				start: score.beats,
+				beats: scene.bars * 4
+			});
+			score.beats += scene.bars * 4;
+		}
+	}
+	return score;
+}
+// ../../packages/core/src/describe.ts
+const pct = (v) => `${Math.round(v * 100)}%`;
+/** A compact piano roll: one row per pitch used, one column per eighth note, "|" between bars. */
+function pianoRoll(events, beats, flats, maxRows = 14) {
+	if (events.length === 0) return ["(empty)"];
+	const cols = Math.ceil(beats * 2);
+	const pitches = [...new Set(events.map((e) => e.midi))].sort((a, b) => b - a);
+	const shown = pitches.length > maxRows ? pitches.filter((_, i) => i % Math.ceil(pitches.length / maxRows) === 0) : pitches;
+	const width = Math.max(...shown.map((p) => noteName(p, flats).length));
+	return shown.map((p) => {
+		const row = Array.from({ length: cols }, () => ".");
+		for (const e of events) {
+			if (e.midi !== p) continue;
+			const start = Math.min(cols - 1, Math.round(e.time * 2));
+			const end = Math.min(cols, Math.max(start + 1, Math.round((e.time + e.duration) * 2)));
+			row[start] = "o";
+			for (let c = start + 1; c < end; c++) if (row[c] === ".") row[c] = "-";
+		}
+		let line = "";
+		for (let c = 0; c < cols; c++) line += (c % 8 === 0 ? "|" : "") + row[c];
+		return `${noteName(p, flats).padStart(width)} ${line}|`;
+	});
+}
+function describeProject(project, sceneId) {
+	const flats = prefersFlats(project.key);
+	const scene = findScene(project, sceneId);
+	const score = buildSceneScore(project, scene.id);
+	const lines = [];
+	lines.push(`${project.name} · ${keyLabel(project.key)} · ${project.bpm} BPM · swing ${pct(project.swing)} · humanize ${pct(project.humanize)}`);
+	lines.push(`Mood: ${project.mood ?? "custom"} · window: ${project.window}`);
+	const arrangement = project.arrangement.map((a) => `${project.scenes.find((s) => s.id === a.sceneId)?.name ?? a.sceneId}${a.repeat > 1 ? `×${a.repeat}` : ""}`).join(" → ");
+	lines.push(`Scenes: ${project.scenes.map((s) => `${s.name} [${s.id}] ${s.bars} bars`).join(", ")}`);
+	lines.push(`Arrangement: ${arrangement}`);
+	const mix = project.mix;
+	lines.push(`Mix: master ${pct(mix.master)}, warmth ${pct(mix.warmth)}, crackle ${pct(mix.crackle)}, reverb ${pct(mix.reverb)}, wobble ${pct(mix.wobble)}, rain ${mix.rain.enabled ? `${mix.rain.kind} ${pct(mix.rain.level)}` : "off"}`);
+	lines.push("");
+	lines.push(`Scene ${scene.name} (${scene.bars} bars, ${scene.bars * 4} beats). Canvas x 0→1 spans the whole scene, y 0 is the top (high notes).`);
+	lines.push(`Chords: ${progressionText(scene.progression, project.key)}`);
+	const b = scene.backing;
+	lines.push(`Backing: chords ${b.chords.enabled ? `${b.chords.instrument} ${b.chords.style}` : "off"} · bass ${b.bass.enabled ? b.bass.style : "off"} · drums ${b.drums.enabled ? b.drums.groove : "off"}`);
+	for (const layer of scene.layers) {
+		const notes = score.events.filter((e) => e.track === layer.id);
+		const flags = [layer.muted && "muted", layer.solo && "solo"].filter(Boolean).join(", ");
+		const brushes = [...new Set(layer.strokes.map((s) => BRUSHES[s.brush].label.toLowerCase()))].join("/");
+		lines.push("");
+		lines.push(`Layer "${layer.name}" [${layer.id}] ${INSTRUMENTS[layer.instrument].label}, harmony ${layer.harmony}, octave ${layer.octave >= 0 ? "+" : ""}${layer.octave}, volume ${pct(layer.volume)}${flags ? ` (${flags})` : ""}`);
+		if (layer.strokes.length === 0) {
+			lines.push("  No strokes yet.");
+			continue;
+		}
+		const range = notes.length ? `${noteName(Math.min(...notes.map((n) => n.midi)), flats)} to ${noteName(Math.max(...notes.map((n) => n.midi)), flats)}` : "none";
+		lines.push(`  ${layer.strokes.length} strokes (${brushes}), ${notes.length} notes, range ${range}`);
+		if (INSTRUMENTS[layer.instrument].kind === "drums") {
+			const counts = /* @__PURE__ */ new Map();
+			for (const n of notes) counts.set(n.drum ?? "?", (counts.get(n.drum ?? "?") ?? 0) + 1);
+			lines.push(`  Hits: ${[...counts].map(([k, v]) => `${k} ${v}`).join(", ")}`);
+		} else {
+			const gridded = notes.map((n) => ({
+				...n,
+				time: Math.round(n.time * 4) / 4
+			}));
+			for (const row of pianoRoll(gridded, scene.bars * 4, flats)) lines.push(`  ${row}`);
+		}
+	}
+	return lines.join("\n");
+}
+// ../../packages/core/src/midi.ts
+const Midi = midiModule.Midi ?? midiModule.default.Midi;
+function trackName(project, track) {
+	if (track === "backing:chords") return "Chords";
+	if (track === "backing:bass") return "Bass";
+	if (track === "backing:drums") return "Drums";
+	for (const scene of project.scenes) {
+		const layer = scene.layers.find((l) => l.id === track);
+		if (layer) return layer.name;
+	}
+	return track;
+}
+/** Volume per track, so the MIDI file roughly matches the mix. */
+function trackVolume(project, track) {
+	const scene = project.scenes.find((s) => s.layers.some((l) => l.id === track)) ?? project.scenes[0];
+	if (track === "backing:chords") return scene.backing.chords.volume;
+	if (track === "backing:bass") return scene.backing.bass.volume;
+	if (track === "backing:drums") return scene.backing.drums.volume;
+	return scene.layers.find((l) => l.id === track)?.volume ?? .8;
+}
+function scoreToMidi(project, score) {
+	const midi = new Midi();
+	midi.name = project.name;
+	midi.header.setTempo(score.bpm);
+	const ppq = midi.header.ppq;
+	const tracks = /* @__PURE__ */ new Map();
+	let nextChannel = 0;
+	for (const e of score.events) {
+		let track = tracks.get(e.track);
+		if (!track) {
+			track = midi.addTrack();
+			track.name = trackName(project, e.track);
+			if (e.instrument === "drums") track.channel = 9;
+			else {
+				track.channel = nextChannel === 9 ? ++nextChannel : nextChannel;
+				nextChannel = (track.channel + 1) % 16;
+				track.instrument.number = INSTRUMENTS[e.instrument].gm;
+			}
+			tracks.set(e.track, track);
+		}
+		const velocity = Math.max(.04, Math.min(1, e.velocity * (.4 + .6 * trackVolume(project, e.track))));
+		track.addNote({
+			midi: e.midi,
+			ticks: Math.round(e.time * ppq),
+			durationTicks: Math.max(1, Math.round(e.duration * ppq)),
+			velocity
+		});
+	}
+	return midi.toArray();
+}
+export { PROGRESSIONS as A, GROOVE_IDS as C, RAIN_KINDS as D, INSTRUMENT_IDS as E, prefersFlats as F, scalePcs as I, mod12 as L, resolveProgression as M, MODES as N, WINDOW_SCENES as O, keyLabel as P, noteName as R, DRUM_PIECE_IDS as S, INSTRUMENTS as T, BASS_STYLES as _, layerRange as a, COMP_STYLES as b, createProject as c, findScene as d, parseProject as f, getMood as g, MOOD_IDS as h, buildSceneScore as i, progressionText as j, drumRows as k, createScene as l, makeId as m, describeProject as n, pitchToY as o, createRng as p, buildArrangementScore as r, createLayer as s, scoreToMidi as t, findLayer as u, BRUSH_IDS as v, HARMONY_MODES as w, DRUM_KITS as x, CHORD_INSTRUMENTS as y, parseNote as z };