@pinkpixel/haku 0.0.0-stage → 0.2.0

package/dist/tools-_xkF2Yfv.mjs

@@ -0,0 +1,1891 @@
+import { A as PROGRESSIONS, C as GROOVE_IDS, D as RAIN_KINDS, E as INSTRUMENT_IDS, F as prefersFlats, I as scalePcs, L as mod12, M as resolveProgression, N as MODES, O as WINDOW_SCENES, P as keyLabel, R as noteName, T as INSTRUMENTS, _ as BASS_STYLES, a as layerRange, b as COMP_STYLES, c as createProject, d as findScene, f as parseProject, g as getMood, h as MOOD_IDS, i as buildSceneScore, j as progressionText, k as drumRows, l as createScene, m as makeId, n as describeProject, o as pitchToY, r as buildArrangementScore, s as createLayer, t as scoreToMidi, u as findLayer, v as BRUSH_IDS, w as HARMONY_MODES, x as DRUM_KITS, y as CHORD_INSTRUMENTS, z as parseNote } from "./src-dP0jXhPP.mjs";
+import { readFile, rename, stat, writeFile } from "node:fs/promises";
+import { delimiter, extname, join, normalize, resolve, sep } from "node:path";
+import { z } from "zod";
+import { randomUUID } from "node:crypto";
+import { WebSocket, WebSocketServer } from "ws";
+import { spawn } from "node:child_process";
+import { createReadStream, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { fileURLToPath } from "node:url";
+import { createServer } from "node:http";
+// ../../packages/core/src/shapes.ts
+const SHAPES = [
+	"wave",
+	"arc",
+	"zigzag",
+	"stairs-up",
+	"stairs-down"
+];
+const clamp01 = (v) => Math.min(1, Math.max(0, v));
+/** Spreads timestamps evenly along the path so drawing speed is constant. */
+function timePoints(path, durationMs, pressure) {
+	const lengths = [0];
+	for (let i = 1; i < path.length; i++) lengths.push(lengths[i - 1] + Math.hypot(path[i].x - path[i - 1].x, path[i].y - path[i - 1].y));
+	const total = lengths[lengths.length - 1] || 1;
+	return path.map((p, i) => ({
+		x: clamp01(p.x),
+		y: clamp01(p.y),
+		t: Math.round(lengths[i] / total * durationMs),
+		...pressure === void 0 ? {} : { p: clamp01(pressure) }
+	}));
+}
+function linePath(from, to) {
+	const steps = Math.max(2, Math.ceil(Math.hypot(to.x - from.x, to.y - from.y) * 200));
+	return Array.from({ length: steps + 1 }, (_, i) => ({
+		x: from.x + (to.x - from.x) * i / steps,
+		y: from.y + (to.y - from.y) * i / steps
+	}));
+}
+/** A smooth Catmull-Rom curve through every control point. */
+function curvePath(points) {
+	if (points.length < 3) return points.length === 2 ? linePath(points[0], points[1]) : [...points];
+	const out = [];
+	for (let i = 0; i < points.length - 1; i++) {
+		const p0 = points[Math.max(0, i - 1)];
+		const p1 = points[i];
+		const p2 = points[i + 1];
+		const p3 = points[Math.min(points.length - 1, i + 2)];
+		const steps = Math.max(4, Math.ceil(Math.hypot(p2.x - p1.x, p2.y - p1.y) * 200));
+		for (let s = 0; s < steps; s++) {
+			const t = s / steps;
+			const t2 = t * t;
+			const t3 = t2 * t;
+			const f = (a, b, c, d) => .5 * (2 * b + (-a + c) * t + (2 * a - 5 * b + 4 * c - d) * t2 + (-a + 3 * b - 3 * c + d) * t3);
+			out.push({
+				x: f(p0.x, p1.x, p2.x, p3.x),
+				y: f(p0.y, p1.y, p2.y, p3.y)
+			});
+		}
+	}
+	out.push(points[points.length - 1]);
+	return out;
+}
+function shapePath(kind, { x, y, width, height, cycles = 2 }) {
+	const n = Math.max(24, Math.ceil(width * 240));
+	const at = (f) => x + width * f;
+	switch (kind) {
+		case "wave": return Array.from({ length: n + 1 }, (_, i) => ({
+			x: at(i / n),
+			y: y - height / 2 * Math.sin(i / n * cycles * Math.PI * 2)
+		}));
+		case "arc": return Array.from({ length: n + 1 }, (_, i) => ({
+			x: at(i / n),
+			y: y + height / 2 - height * Math.sin(i / n * Math.PI)
+		}));
+		case "zigzag": {
+			const corners = [];
+			for (let i = 0; i <= cycles * 2; i++) corners.push({
+				x: at(i / (cycles * 2)),
+				y: y + (i % 2 === 0 ? height / 2 : -height / 2)
+			});
+			return corners.flatMap((c, i) => i === 0 ? [c] : linePath(corners[i - 1], c).slice(1));
+		}
+		case "stairs-up":
+		case "stairs-down": {
+			const steps = Math.max(2, Math.round(cycles * 2));
+			const dir = kind === "stairs-up" ? -1 : 1;
+			const out = [];
+			for (let i = 0; i < steps; i++) {
+				const sy = y - dir * height / 2 + dir * height * i / (steps - 1);
+				out.push(...linePath({
+					x: at(i / steps),
+					y: sy
+				}, {
+					x: at((i + 1) / steps) - .001,
+					y: sy
+				}));
+			}
+			return out;
+		}
+	}
+}
+// ../../packages/protocol/src/schemas.ts
+const unit = z.number().min(0).max(1);
+const point = z.object({
+	x: unit.describe("0 is the start of the scene, 1 the end"),
+	y: unit.describe("0 is the top (high notes), 1 the bottom")
+});
+const target = {
+	scene: z.string().optional().describe("Scene id or name. Defaults to the active scene."),
+	layer: z.string().optional().describe("Layer id or name. Defaults to the first melodic layer.")
+};
+const pen = {
+	...target,
+	brush: z.enum(BRUSH_IDS).optional().describe("pencil: eighth-note melody. brush: long soft notes. chalk: two-note harmonies. spray: scattered sparkles. stamp: one hit per sixteenth."),
+	size: unit.optional().describe("Brush thickness. Thicker plays softer and darker. Default 0.3."),
+	velocity: unit.optional().describe("How hard to play, like pen pressure. Leave out to use drawing speed."),
+	duration_ms: z.number().min(20).max(2e4).optional().describe("How long the stroke takes to draw. Faster strokes play louder. Default 1500.")
+};
+const CommandSchema = z.discriminatedUnion("type", [
+	z.object({
+		type: z.literal("set_project"),
+		name: z.string().min(1).max(80).optional(),
+		bpm: z.number().min(50).max(140).optional(),
+		swing: unit.optional(),
+		humanize: unit.optional(),
+		window: z.enum(WINDOW_SCENES).optional().describe("What you see outside the window")
+	}),
+	z.object({
+		type: z.literal("set_key"),
+		tonic: z.string().regex(/^[A-Ga-g][#b]?$/).describe("Like C, F#, or Bb"),
+		mode: z.enum(MODES)
+	}),
+	z.object({
+		type: z.literal("set_mood"),
+		mood: z.enum(MOOD_IDS),
+		keep_key: z.boolean().optional().describe("Keep the current key instead of the mood key"),
+		scene: target.scene
+	}),
+	z.object({
+		type: z.literal("set_progression"),
+		progression: z.string().describe("A preset id, or chords like \"ii9 V13 Imaj9 vi9\" or \"Em9 A13 Dmaj9:2 Bm9:2\". \":N\" sets beats, default 4."),
+		scene: target.scene
+	}),
+	z.object({
+		type: z.literal("set_backing"),
+		scene: target.scene,
+		chords: z.object({
+			enabled: z.boolean(),
+			instrument: z.enum(CHORD_INSTRUMENTS),
+			style: z.enum(COMP_STYLES),
+			volume: unit
+		}).partial().optional(),
+		bass: z.object({
+			enabled: z.boolean(),
+			style: z.enum(BASS_STYLES),
+			volume: unit
+		}).partial().optional(),
+		drums: z.object({
+			enabled: z.boolean(),
+			groove: z.enum(GROOVE_IDS),
+			volume: unit
+		}).partial().optional()
+	}),
+	z.object({
+		type: z.literal("mix"),
+		master: unit.optional(),
+		warmth: unit.optional(),
+		crackle: unit.optional(),
+		reverb: unit.optional(),
+		wobble: unit.optional(),
+		rain: z.object({
+			enabled: z.boolean(),
+			kind: z.enum(RAIN_KINDS),
+			level: unit
+		}).partial().optional()
+	}),
+	z.object({
+		type: z.literal("add_layer"),
+		instrument: z.enum(INSTRUMENT_IDS),
+		name: z.string().min(1).max(40).optional(),
+		color: z.string().optional(),
+		harmony: z.enum(HARMONY_MODES).optional(),
+		octave: z.number().int().min(-2).max(2).optional(),
+		kit: z.enum(DRUM_KITS).optional(),
+		scene: target.scene
+	}),
+	z.object({
+		type: z.literal("update_layer"),
+		layer: z.string(),
+		scene: target.scene,
+		name: z.string().min(1).max(40).optional(),
+		instrument: z.enum(INSTRUMENT_IDS).optional(),
+		color: z.string().optional(),
+		volume: unit.optional(),
+		pan: z.number().min(-1).max(1).optional(),
+		muted: z.boolean().optional(),
+		solo: z.boolean().optional(),
+		harmony: z.enum(HARMONY_MODES).optional(),
+		octave: z.number().int().min(-2).max(2).optional(),
+		kit: z.enum(DRUM_KITS).optional()
+	}),
+	z.object({
+		type: z.literal("remove_layer"),
+		layer: z.string(),
+		scene: target.scene
+	}),
+	z.object({
+		type: z.literal("draw_path"),
+		...pen,
+		points: z.array(z.object({
+			x: unit,
+			y: unit,
+			t: z.number().min(0).optional(),
+			p: unit.optional()
+		})).min(1).max(5e3)
+	}),
+	z.object({
+		type: z.literal("draw_line"),
+		...pen,
+		from: point,
+		to: point
+	}),
+	z.object({
+		type: z.literal("draw_curve"),
+		...pen,
+		points: z.array(point).min(2).max(64).describe("A smooth curve passes through every point")
+	}),
+	z.object({
+		type: z.literal("draw_shape"),
+		...pen,
+		shape: z.enum(SHAPES),
+		x: unit.describe("Left edge"),
+		y: unit.describe("Vertical center"),
+		width: z.number().min(.005).max(1),
+		height: z.number().min(0).max(1),
+		cycles: z.number().min(.5).max(32).optional().describe("Waves, zigzags, or stair steps across the width")
+	}),
+	z.object({
+		type: z.literal("draw_melody"),
+		...target,
+		notes: z.array(z.object({
+			pitch: z.union([z.string(), z.number().int().min(0).max(127)]).describe("Like \"A4\" or a MIDI number. Played exactly, no snapping."),
+			beat: z.number().min(0).describe("Start, in beats from the start of the scene (4 per bar)"),
+			beats: z.number().min(.25).max(16).optional().describe("Length in beats. Default 1."),
+			velocity: unit.optional()
+		})).min(1).max(256)
+	}),
+	z.object({
+		type: z.literal("erase"),
+		...target,
+		strokes: z.array(z.string()).optional().describe("Stroke ids to remove"),
+		region: z.object({
+			x0: unit,
+			x1: unit,
+			y0: unit.optional(),
+			y1: unit.optional()
+		}).optional().describe("Remove strokes that pass through this box"),
+		all: z.boolean().optional().describe("Clear the whole layer")
+	}),
+	z.object({
+		type: z.literal("add_scene"),
+		name: z.string().min(1).max(40),
+		bars: z.number().int().min(1).max(16).optional(),
+		copy_from: z.string().optional().describe("Scene to copy layers, chords, and backing from"),
+		progression: z.string().optional(),
+		select: z.boolean().optional().describe("Make it the active scene. Default true.")
+	}),
+	z.object({
+		type: z.literal("update_scene"),
+		scene: z.string(),
+		name: z.string().min(1).max(40).optional(),
+		bars: z.number().int().min(1).max(16).optional()
+	}),
+	z.object({
+		type: z.literal("remove_scene"),
+		scene: z.string()
+	}),
+	z.object({
+		type: z.literal("select_scene"),
+		scene: z.string()
+	}),
+	z.object({
+		type: z.literal("arrange"),
+		items: z.array(z.object({
+			scene: z.string(),
+			repeat: z.number().int().min(1).max(16).optional()
+		})).min(1).max(64)
+	}),
+	z.object({
+		type: z.literal("describe"),
+		scene: target.scene
+	})
+]);
+/** Commands that only read the project. */
+const READ_ONLY_COMMANDS = ["describe"];
+// ../../packages/protocol/src/draw.ts
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function strokePoints(cmd) {
+	const ms = cmd.duration_ms ?? 1500;
+	switch (cmd.type) {
+		case "draw_path":
+			if (cmd.points.every((p) => p.t !== void 0)) return cmd.points.map((p) => {
+				const pressure = p.p ?? cmd.velocity;
+				return {
+					x: p.x,
+					y: p.y,
+					t: p.t,
+					...pressure === void 0 ? {} : { p: pressure }
+				};
+			});
+			return timePoints(cmd.points, ms, cmd.velocity).map((t, i) => cmd.points[i].p === void 0 ? t : {
+				...t,
+				p: cmd.points[i].p
+			});
+		case "draw_line": return timePoints(linePath(cmd.from, cmd.to), ms, cmd.velocity);
+		case "draw_curve": return timePoints(curvePath(cmd.points), ms, cmd.velocity);
+		case "draw_shape": return timePoints(shapePath(cmd.shape, cmd), ms, cmd.velocity);
+	}
+}
+/** A short readout of what a set of strokes now plays, so the drawer hears it in words. */
+function summarizeNotes(project, sceneId, layer, strokeIds) {
+	const notes = buildSceneScore({
+		...project,
+		swing: 0,
+		humanize: 0,
+		scenes: project.scenes.map((s) => s.id === sceneId ? {
+			...s,
+			layers: s.layers.map((l) => ({
+				...l,
+				muted: false,
+				solo: false
+			}))
+		} : s)
+	}, sceneId).events.filter((e) => e.strokeId && strokeIds.has(e.strokeId));
+	if (notes.length === 0) return {
+		text: "no notes (the stroke may be outside the canvas or too small)",
+		count: 0
+	};
+	const flats = prefersFlats(project.key);
+	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);
+		return {
+			text: `${plural(notes.length, "hit")} (${[...counts].map(([k, v]) => `${k} ${v}`).join(", ")})`,
+			count: notes.length
+		};
+	}
+	const shown = notes.slice(0, 16).map((n) => `${noteName(n.midi, flats)}@${Math.round(n.time * 100) / 100}`);
+	const more = notes.length > 16 ? ` and ${notes.length - 16} more` : "";
+	return {
+		text: `${plural(notes.length, "note")} (pitch@beat): ${shown.join(" ")}${more}`,
+		count: notes.length
+	};
+}
+function drawStroke(project, cmd) {
+	const { scene, layer } = findLayer(project, cmd.layer, cmd.scene);
+	const stroke = {
+		id: makeId("k"),
+		brush: cmd.brush ?? "pencil",
+		size: cmd.size ?? .3,
+		points: strokePoints(cmd)
+	};
+	layer.strokes.push(stroke);
+	const { text, count } = summarizeNotes(project, scene.id, layer, /* @__PURE__ */ new Set([stroke.id]));
+	const what = cmd.type === "draw_shape" ? `${cmd.shape} shape` : cmd.type.replace("draw_", "");
+	return {
+		project,
+		message: `Drew a ${stroke.brush} ${what} on "${layer.name}" [${stroke.id}]: ${text}`,
+		data: {
+			strokeId: stroke.id,
+			notes: count
+		}
+	};
+}
+function drawMelody(project, cmd) {
+	const { scene, layer } = findLayer(project, cmd.layer, cmd.scene);
+	if (INSTRUMENTS[layer.instrument].kind === "drums") throw new Error(`"${layer.name}" is a drum layer. Use draw_path with dots, or pick a melodic layer.`);
+	const range = layerRange(layer);
+	const totalBeats = scene.bars * 4;
+	const flats = prefersFlats(project.key);
+	const ids = /* @__PURE__ */ new Set();
+	for (const n of cmd.notes) {
+		const midi = typeof n.pitch === "number" ? n.pitch : parseNote(n.pitch);
+		if (midi === null) throw new Error(`Can't read pitch "${n.pitch}". Use a note like "A4" or a MIDI number.`);
+		if (midi < range[0] || midi > range[1]) throw new Error(`${noteName(midi, flats)} is outside "${layer.name}" (${noteName(range[0], flats)} to ${noteName(range[1], flats)}). Change the layer octave or pick another note.`);
+		const beats = n.beats ?? 1;
+		if (n.beat + beats > totalBeats + 1e-6) throw new Error(`A note at beat ${n.beat} lasting ${beats} runs past the end of the scene (${totalBeats} beats)`);
+		const y = pitchToY(midi, range);
+		const x0 = (n.beat + .01) / totalBeats;
+		const x1 = (n.beat + beats - .01) / totalBeats;
+		const points = timePoints([{
+			x: x0,
+			y
+		}, {
+			x: x1,
+			y
+		}], 200, n.velocity ?? .6);
+		const stroke = {
+			id: makeId("k"),
+			brush: "pencil",
+			size: .3,
+			points,
+			exact: true
+		};
+		layer.strokes.push(stroke);
+		ids.add(stroke.id);
+	}
+	const { text } = summarizeNotes(project, scene.id, layer, ids);
+	return {
+		project,
+		message: `Wrote a melody on "${layer.name}": ${text}`,
+		data: { strokeIds: [...ids] }
+	};
+}
+function strokeHits(stroke, region) {
+	const [xa, xb] = [Math.min(region.x0, region.x1), Math.max(region.x0, region.x1)];
+	const [ya, yb] = [Math.min(region.y0 ?? 0, region.y1 ?? 1), Math.max(region.y0 ?? 0, region.y1 ?? 1)];
+	return stroke.points.some((p) => p.x >= xa && p.x <= xb && p.y >= ya && p.y <= yb);
+}
+function erase(project, cmd) {
+	const { layer } = findLayer(project, cmd.layer, cmd.scene);
+	if (!cmd.all && !cmd.strokes && !cmd.region) throw new Error("Say what to erase: strokes, a region, or all");
+	const before = layer.strokes.length;
+	const ids = new Set(cmd.strokes ?? []);
+	layer.strokes = cmd.all ? [] : layer.strokes.filter((s) => !ids.has(s.id) && !(cmd.region && strokeHits(s, cmd.region)));
+	const removed = before - layer.strokes.length;
+	return {
+		project,
+		message: `Erased ${plural(removed, "stroke")} from "${layer.name}"`,
+		data: { removed }
+	};
+}
+// ../../packages/protocol/src/execute.ts
+/** Copies only the keys that were actually given. */
+function assignDefined(target, patch) {
+	const changed = [];
+	for (const [k, v] of Object.entries(patch)) {
+		if (v === void 0) continue;
+		target[k] = v;
+		changed.push(k);
+	}
+	return changed;
+}
+const listChanges = (changed) => changed.length ? changed.join(", ") : "nothing";
+/** Validates unknown input (from JSON, the bridge, or an agent) and runs it. */
+function executeUnknown(project, input) {
+	const parsed = CommandSchema.safeParse(input);
+	if (!parsed.success) {
+		const issue = parsed.error.issues[0];
+		throw new Error(`Bad command: ${issue.path.join(".") || "command"}: ${issue.message}`);
+	}
+	return execute(project, parsed.data);
+}
+function execute(input, cmd) {
+	const result = run(structuredClone(input), cmd);
+	if (!READ_ONLY_COMMANDS.includes(cmd.type)) result.project.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	return result;
+}
+function run(project, cmd) {
+	switch (cmd.type) {
+		case "set_project": {
+			const { type: _, ...patch } = cmd;
+			const changed = assignDefined(project, patch);
+			return {
+				project,
+				message: `Updated ${listChanges(changed)}`
+			};
+		}
+		case "set_key": {
+			project.key = {
+				tonic: cmd.tonic[0].toUpperCase() + cmd.tonic.slice(1),
+				mode: cmd.mode
+			};
+			const scene = findScene(project);
+			return {
+				project,
+				message: `Key is now ${keyLabel(project.key)}. Chords: ${progressionText(scene.progression, project.key)}`
+			};
+		}
+		case "set_mood": {
+			const mood = getMood(cmd.mood);
+			const scene = findScene(project, cmd.scene);
+			project.mood = cmd.mood;
+			project.bpm = mood.bpm;
+			project.swing = mood.swing;
+			project.window = mood.window;
+			project.mix = structuredClone(mood.mix);
+			if (!cmd.keep_key) project.key = { ...mood.key };
+			scene.progression = resolveProgression(mood.progression, project.key);
+			scene.backing = structuredClone(mood.backing);
+			return {
+				project,
+				message: `Mood is ${mood.label}: ${keyLabel(project.key)}, ${mood.bpm} BPM, chords ${progressionText(scene.progression, project.key)}. Your strokes stay put.`
+			};
+		}
+		case "set_progression": {
+			const scene = findScene(project, cmd.scene);
+			scene.progression = resolveProgression(cmd.progression, project.key);
+			return {
+				project,
+				message: `Scene ${scene.name} chords: ${progressionText(scene.progression, project.key)}`
+			};
+		}
+		case "set_backing": {
+			const scene = findScene(project, cmd.scene);
+			const changed = [
+				...assignDefined(scene.backing.chords, cmd.chords ?? {}).map((k) => `chords.${k}`),
+				...assignDefined(scene.backing.bass, cmd.bass ?? {}).map((k) => `bass.${k}`),
+				...assignDefined(scene.backing.drums, cmd.drums ?? {}).map((k) => `drums.${k}`)
+			];
+			return {
+				project,
+				message: `Scene ${scene.name} backing: updated ${listChanges(changed)}`
+			};
+		}
+		case "mix": {
+			const { type: _, rain, ...levels } = cmd;
+			const changed = [...assignDefined(project.mix, levels), ...assignDefined(project.mix.rain, rain ?? {}).map((k) => `rain.${k}`)];
+			return {
+				project,
+				message: `Mix: updated ${listChanges(changed)}`
+			};
+		}
+		case "add_layer": {
+			const scene = findScene(project, cmd.scene);
+			const layer = createLayer({
+				instrument: cmd.instrument,
+				name: cmd.name,
+				color: cmd.color,
+				index: scene.layers.length
+			});
+			assignDefined(layer, {
+				harmony: cmd.harmony,
+				octave: cmd.octave,
+				kit: cmd.kit
+			});
+			scene.layers.push(layer);
+			return {
+				project,
+				message: `Added layer "${layer.name}" [${layer.id}] (${INSTRUMENTS[layer.instrument].label}) to scene ${scene.name}`,
+				data: { layerId: layer.id }
+			};
+		}
+		case "update_layer": {
+			const { layer } = findLayer(project, cmd.layer, cmd.scene);
+			const { type: _, layer: __, scene: ___, ...patch } = cmd;
+			const changed = assignDefined(layer, patch);
+			return {
+				project,
+				message: `Layer "${layer.name}": updated ${listChanges(changed)}`
+			};
+		}
+		case "remove_layer": {
+			const { scene, layer } = findLayer(project, cmd.layer, cmd.scene);
+			scene.layers = scene.layers.filter((l) => l.id !== layer.id);
+			return {
+				project,
+				message: `Removed layer "${layer.name}" and its ${layer.strokes.length} strokes`
+			};
+		}
+		case "draw_path":
+		case "draw_line":
+		case "draw_curve":
+		case "draw_shape": return drawStroke(project, cmd);
+		case "draw_melody": return drawMelody(project, cmd);
+		case "erase": return erase(project, cmd);
+		case "add_scene": {
+			const source = cmd.copy_from ? findScene(project, cmd.copy_from) : null;
+			const scene = source ? {
+				...structuredClone(source),
+				id: makeId("s"),
+				name: cmd.name
+			} : createScene(project, cmd.name, cmd.bars ?? findScene(project).bars);
+			if (source) for (const layer of scene.layers) layer.id = makeId("l");
+			if (cmd.bars) scene.bars = cmd.bars;
+			if (cmd.progression) scene.progression = resolveProgression(cmd.progression, project.key);
+			project.scenes.push(scene);
+			project.arrangement.push({
+				sceneId: scene.id,
+				repeat: 1
+			});
+			if (cmd.select !== false) project.activeSceneId = scene.id;
+			return {
+				project,
+				message: `Added scene ${scene.name} [${scene.id}], ${scene.bars} bars, and put it at the end of the arrangement`,
+				data: { sceneId: scene.id }
+			};
+		}
+		case "update_scene": {
+			const scene = findScene(project, cmd.scene);
+			const changed = assignDefined(scene, {
+				name: cmd.name,
+				bars: cmd.bars
+			});
+			return {
+				project,
+				message: `Scene ${scene.name}: updated ${listChanges(changed)}`
+			};
+		}
+		case "remove_scene": {
+			const scene = findScene(project, cmd.scene);
+			if (project.scenes.length === 1) throw new Error("Can't remove the only scene");
+			project.scenes = project.scenes.filter((s) => s.id !== scene.id);
+			project.arrangement = project.arrangement.filter((a) => a.sceneId !== scene.id);
+			if (project.arrangement.length === 0) project.arrangement = [{
+				sceneId: project.scenes[0].id,
+				repeat: 1
+			}];
+			if (project.activeSceneId === scene.id) project.activeSceneId = project.scenes[0].id;
+			return {
+				project,
+				message: `Removed scene ${scene.name}`
+			};
+		}
+		case "select_scene": {
+			const scene = findScene(project, cmd.scene);
+			project.activeSceneId = scene.id;
+			return {
+				project,
+				message: `Now editing scene ${scene.name}`
+			};
+		}
+		case "arrange":
+			project.arrangement = cmd.items.map((i) => ({
+				sceneId: findScene(project, i.scene).id,
+				repeat: i.repeat ?? 1
+			}));
+			return {
+				project,
+				message: `Arrangement: ${project.arrangement.map((a) => `${findScene(project, a.sceneId).name}${a.repeat > 1 ? `×${a.repeat}` : ""}`).join(" → ")}`
+			};
+		case "describe": return {
+			project,
+			message: describeProject(project, cmd.scene)
+		};
+	}
+}
+// ../../packages/protocol/src/help.ts
+const COMMAND_HELP = {
+	set_project: "Rename the project or change tempo, swing, humanize, or the window view.",
+	set_key: "Change the key. Chords follow automatically, since they are stored relative to the tonic.",
+	set_mood: "Apply a mood preset: tempo, key, chords, swing, mix, backing band, and window. Drawn strokes stay.",
+	set_progression: "Set the chords for a scene, from a preset id, roman numerals, or chord symbols.",
+	set_backing: "Change the backing band for a scene: chord instrument and comping style, bass style, drum groove, and their volumes.",
+	mix: "Change the master mix: level, warmth, crackle, reverb, wobble, and rain.",
+	add_layer: "Add a layer to draw on, with its own instrument. Returns the new layer id.",
+	update_layer: "Change a layer: name, instrument, volume, pan, mute, solo, harmony snapping, octave, or drum kit.",
+	remove_layer: "Delete a layer and everything drawn on it.",
+	draw_path: "Draw a freehand stroke from raw points. x is time across the scene (0 to 1), y is pitch (0 is high). Notes snap to the chords.",
+	draw_line: "Draw a straight stroke between two points. A rising line plays a rising melody.",
+	draw_curve: "Draw a smooth curve through a few points. Good for phrases that rise and fall.",
+	draw_shape: "Draw a shape (wave, arc, zigzag, stairs up or down) inside a box. Quick way to get a musical figure.",
+	draw_melody: "Write exact notes by pitch and beat, with no snapping. Use when you know the notes you want.",
+	erase: "Remove strokes from a layer: by stroke id, by a box on the canvas, or all of them.",
+	add_scene: "Add a scene (a section like a verse or a bridge), optionally copied from another. It goes on the end of the arrangement.",
+	update_scene: "Rename a scene or change its length in bars. Strokes stretch to fit.",
+	remove_scene: "Delete a scene and take it out of the arrangement.",
+	select_scene: "Make a scene the active one, which is the default for drawing commands.",
+	arrange: "Set the song order: a list of scenes, each with an optional repeat count.",
+	describe: "Read the project back as text: key, tempo, chords, layers, and a small piano roll of what each layer plays."
+};
+// ../../packages/protocol/src/bridge.ts
+const BRIDGE_HOST = "127.0.0.1";
+const BRIDGE_PORT = 5179;
+/** What an agent can ask the tab to do. */
+const TabOpSchema = z.discriminatedUnion("op", [
+	z.object({ op: z.literal("get_project") }),
+	z.object({
+		op: z.literal("execute"),
+		commands: z.array(z.unknown()).min(1).max(500)
+	}),
+	z.object({
+		op: z.literal("open_project"),
+		project: z.unknown()
+	}),
+	z.object({
+		op: z.literal("play"),
+		mode: z.enum(["loop", "song"]).optional(),
+		scene: z.string().optional()
+	}),
+	z.object({ op: z.literal("stop") }),
+	z.object({ op: z.literal("status") })
+]);
+/** Answered by the bridge itself, without a tab. */
+const PingOpSchema = z.object({ op: z.literal("ping") });
+const BridgeMessageSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("hello"),
+		app: z.literal("haku"),
+		version: z.string().optional()
+	}),
+	z.object({
+		kind: z.literal("request"),
+		id: z.string().min(1).max(64),
+		op: z.union([TabOpSchema, PingOpSchema])
+	}),
+	z.object({
+		kind: z.literal("response"),
+		id: z.string().min(1).max(64),
+		ok: z.boolean(),
+		result: z.unknown().optional(),
+		error: z.string().optional()
+	})
+]);
+/** Parses one incoming frame. Returns null for anything that isn't a valid message. */
+function parseBridgeMessage(raw) {
+	let data;
+	try {
+		data = JSON.parse(raw);
+	} catch {
+		return null;
+	}
+	const parsed = BridgeMessageSchema.safeParse(data);
+	return parsed.success ? parsed.data : null;
+}
+// src/bridge.ts
+const NO_TAB = "No Haku tab is connected. Run \"haku web\" to open one, or pass a project file.";
+const DEFAULT_TIMEOUT = 2e4;
+function bridgePort() {
+	const env = Number(process.env.HAKU_BRIDGE_PORT);
+	return Number.isInteger(env) && env > 0 ? env : BRIDGE_PORT;
+}
+/** Pages on this machine only, plus anything listed in HAKU_ALLOW_ORIGINS (comma separated). */
+function originAllowed(origin) {
+	if (!origin) return false;
+	if ((process.env.HAKU_ALLOW_ORIGINS ?? "").split(",").map((s) => s.trim()).filter(Boolean).includes(origin)) return true;
+	try {
+		const { hostname, protocol } = new URL(origin);
+		return (protocol === "http:" || protocol === "https:") && [
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(hostname);
+	} catch {
+		return false;
+	}
+}
+const roleOf = (req) => new URL(req.url ?? "/", "http://bridge").pathname;
+/** Tracks requests sent over one socket and matches up the responses. */
+var Requests = class {
+	pending = /* @__PURE__ */ new Map();
+	send(socket, op, timeoutMs) {
+		const id = randomUUID();
+		return new Promise((resolve, reject) => {
+			const timer = setTimeout(() => {
+				this.pending.delete(id);
+				reject(/* @__PURE__ */ new Error(`The Haku tab didn't answer "${op.op}" within ${Math.round(timeoutMs / 1e3)} s`));
+			}, timeoutMs);
+			this.pending.set(id, {
+				resolve,
+				reject,
+				timer,
+				socket
+			});
+			socket.send(JSON.stringify({
+				kind: "request",
+				id,
+				op
+			}));
+		});
+	}
+	settle(msg) {
+		const p = this.pending.get(msg.id);
+		if (!p) return;
+		this.pending.delete(msg.id);
+		clearTimeout(p.timer);
+		if (msg.ok) p.resolve(msg.result);
+		else p.reject(new Error(msg.error ?? "The Haku tab reported an error"));
+	}
+	/** Fails everything still waiting on a socket that went away. */
+	drop(socket, reason) {
+		for (const [id, p] of this.pending) {
+			if (p.socket !== socket) continue;
+			this.pending.delete(id);
+			clearTimeout(p.timer);
+			p.reject(new Error(reason));
+		}
+	}
+};
+var BridgeHost = class BridgeHost {
+	tabs = [];
+	requests = new Requests();
+	/** Called with a short line when tabs come and go, for `haku bridge` to print. */
+	onEvent = null;
+	wss;
+	constructor(wss) {
+		this.wss = wss;
+		wss.on("connection", (ws, req) => roleOf(req) === "/tab" ? this.addTab(ws) : this.addAgent(ws));
+	}
+	/** Starts listening. Rejects with code EADDRINUSE when something already holds the port. */
+	static listen(port = bridgePort()) {
+		return new Promise((resolve, reject) => {
+			const wss = new WebSocketServer({
+				host: BRIDGE_HOST,
+				port,
+				maxPayload: 16777216,
+				verifyClient: ({ req, origin }) => {
+					const role = roleOf(req);
+					if (role === "/tab") return originAllowed(origin);
+					if (role === "/agent") return !req.headers.origin;
+					return false;
+				}
+			});
+			wss.once("listening", () => resolve(new BridgeHost(wss)));
+			wss.once("error", reject);
+		});
+	}
+	get tabCount() {
+		return this.tabs.length;
+	}
+	/** The port actually bound, which matters when listening on 0. */
+	get port() {
+		const addr = this.wss.address();
+		return typeof addr === "object" && addr ? addr.port : 0;
+	}
+	addTab(ws) {
+		this.tabs.push(ws);
+		this.onEvent?.(`Tab connected (${this.tabs.length} open)`);
+		ws.on("message", (raw) => {
+			const msg = parseBridgeMessage(raw.toString());
+			if (msg?.kind === "response") this.requests.settle(msg);
+			else if (msg?.kind === "hello") this.tabs = [...this.tabs.filter((t) => t !== ws), ws];
+		});
+		ws.on("close", () => {
+			this.tabs = this.tabs.filter((t) => t !== ws);
+			this.requests.drop(ws, "The Haku tab closed before it answered");
+			this.onEvent?.(`Tab disconnected (${this.tabs.length} open)`);
+		});
+	}
+	addAgent(ws) {
+		ws.on("message", async (raw) => {
+			const msg = parseBridgeMessage(raw.toString());
+			if (msg?.kind !== "request") return;
+			const reply = (body) => ws.readyState === WebSocket.OPEN && ws.send(JSON.stringify({
+				kind: "response",
+				id: msg.id,
+				...body
+			}));
+			try {
+				reply({
+					ok: true,
+					result: await this.request(msg.op)
+				});
+			} catch (err) {
+				reply({
+					ok: false,
+					error: err instanceof Error ? err.message : String(err)
+				});
+			}
+		});
+	}
+	async request(op, timeoutMs = DEFAULT_TIMEOUT) {
+		if (op.op === "ping") return {
+			tab: this.tabs.length > 0,
+			tabs: this.tabs.length
+		};
+		const tab = this.tabs.at(-1);
+		if (!tab) throw new Error(NO_TAB);
+		return this.requests.send(tab, op, timeoutMs);
+	}
+	close() {
+		for (const ws of this.wss.clients) ws.terminate();
+		return new Promise((resolve) => this.wss.close(() => resolve()));
+	}
+};
+var BridgeClient = class BridgeClient {
+	requests = new Requests();
+	onClose = null;
+	ws;
+	constructor(ws) {
+		this.ws = ws;
+		ws.on("message", (raw) => {
+			const msg = parseBridgeMessage(raw.toString());
+			if (msg?.kind === "response") this.requests.settle(msg);
+		});
+		ws.on("close", () => {
+			this.requests.drop(ws, "Lost the connection to the Haku bridge");
+			this.onClose?.();
+		});
+	}
+	/** Resolves to null when nothing is listening, so callers can fall back to offline. */
+	static connect(port = bridgePort(), timeoutMs = 1e3) {
+		return new Promise((resolve) => {
+			const ws = new WebSocket(`ws://${BRIDGE_HOST}:${port}/agent`, {
+				handshakeTimeout: timeoutMs,
+				maxPayload: 16777216
+			});
+			ws.once("open", () => resolve(new BridgeClient(ws)));
+			ws.once("error", () => resolve(null));
+		});
+	}
+	request(op, timeoutMs = DEFAULT_TIMEOUT) {
+		if (this.ws.readyState !== WebSocket.OPEN) return Promise.reject(/* @__PURE__ */ new Error("Lost the connection to the Haku bridge"));
+		return this.requests.send(this.ws, op, timeoutMs + 2e3);
+	}
+	close() {
+		if (this.ws.readyState === WebSocket.CLOSED) return Promise.resolve();
+		return new Promise((resolve) => {
+			this.ws.once("close", () => resolve());
+			this.ws.close();
+		});
+	}
+};
+const isAddrInUse = (err) => err?.code === "EADDRINUSE";
+/** Hosts the bridge when the port is free, otherwise joins the existing host. Used by the MCP server. */
+var SharedLink = class {
+	current = null;
+	connecting = null;
+	closed = false;
+	port;
+	constructor(port = bridgePort()) {
+		this.port = port;
+	}
+	get hosting() {
+		return this.current instanceof BridgeHost;
+	}
+	ensure() {
+		if (this.current) return Promise.resolve(this.current);
+		this.connecting ??= (async () => {
+			try {
+				this.current = await BridgeHost.listen(this.port);
+			} catch (err) {
+				if (!isAddrInUse(err)) throw err;
+				const client = await BridgeClient.connect(this.port);
+				if (client) client.onClose = () => {
+					this.current = null;
+					if (!this.closed) setTimeout(() => void this.ensure().catch(() => {}), 250);
+				};
+				this.current = client;
+			}
+			return this.current;
+		})().finally(() => this.connecting = null);
+		return this.connecting;
+	}
+	async request(op, timeoutMs) {
+		const link = await this.ensure();
+		if (!link) throw new Error(`Couldn't reach the Haku bridge on port ${this.port}`);
+		return link.request(op, timeoutMs);
+	}
+	async close() {
+		this.closed = true;
+		await this.current?.close();
+		this.current = null;
+	}
+};
+// src/guide.ts
+const presets = Object.entries(PROGRESSIONS).map(([id, p]) => `${id} (${p.text})`).join(", ");
+const GUIDE = `Haku turns strokes on a canvas into lofi music. A backing band (chords, bass, drums) plays along, and drawn notes snap to the chords.
+
+Where the work happens:
+- With no file argument, tools act on the project open in the Haku browser tab, live. Changes show up there and land in its undo history. If no tab is open, Haku starts its local app server and opens one in the browser.
+- With file set to a .haku.json path, tools read and write that file instead. new_project makes one.
+
+The canvas:
+- x is time: 0 is the start of the scene, 1 is the end. A scene is 1 to 16 bars of 4 beats.
+- y is pitch: 0 is the top of the layer's range (high), 1 is the bottom (low). Drum layers use 7 rows instead, bottom to top: kick, tom, snare, side stick, hi-hat, open hat, ride.
+- Brushes set the rhythm grid: pencil (eighths), brush (quarters, soft), chalk (eighths, two-note harmonies), spray (scattered sixteenths), stamp (one hit per sixteenth, good for drums).
+- Faster strokes (lower duration_ms) play louder. draw_melody skips snapping when you want exact notes.
+
+A good loop:
+1. describe to see what's there. set_mood picks a whole vibe in one go: ${MOOD_IDS.join(", ")}.
+2. add_layer for each part (piano, wurli, fm-ep, glock, marimba, harp, pad, pluck, bass, drums).
+3. Draw with draw_shape, draw_curve, or draw_line. Use batch to send many commands as one step.
+4. Check your work: describe (text piano roll), snapshot (a picture), analyze (chord fit, clashes, loudness).
+5. play to listen, export for WAV, MIDI, or the project file.
+
+Chord progressions take a preset id or chords like "ii9 V13 Imaj9 vi9" (":N" sets beats per chord). Presets: ${presets}.
+
+Scenes and layers can be named by id or by name.`;
+// src/player.ts
+const PLAYERS = [
+	{
+		cmd: "pw-play",
+		args: (f) => [f]
+	},
+	{
+		cmd: "paplay",
+		args: (f) => [f]
+	},
+	{
+		cmd: "aplay",
+		args: (f) => ["-q", f]
+	},
+	{
+		cmd: "afplay",
+		args: (f) => [f]
+	},
+	{
+		cmd: "ffplay",
+		args: (f) => [
+			"-nodisp",
+			"-autoexit",
+			"-loglevel",
+			"quiet",
+			f
+		]
+	}
+];
+function onPath(cmd) {
+	const exts = process.platform === "win32" ? (process.env.PATHEXT ?? ".EXE").split(";") : [""];
+	return (process.env.PATH ?? "").split(delimiter).some((dir) => exts.some((ext) => existsSync(join(dir, cmd + ext))));
+}
+function findPlayer(file) {
+	if (process.platform === "win32") return {
+		cmd: "powershell",
+		args: [
+			"-NoProfile",
+			"-Command",
+			`(New-Object Media.SoundPlayer '${file.replace(/'/g, "''")}').PlaySync()`
+		]
+	};
+	const p = PLAYERS.find((p) => onPath(p.cmd));
+	return p ? {
+		cmd: p.cmd,
+		args: p.args(file)
+	} : null;
+}
+var Player = class {
+	child = null;
+	/** Starts playing and returns the player's name. `done` settles when it finishes or is stopped. */
+	play(file) {
+		this.stop();
+		const player = findPlayer(file);
+		if (!player) throw new Error(`No audio player found. Install one of ${PLAYERS.map((p) => p.cmd).join(", ")}, or open Haku in a browser.`);
+		const child = spawn(player.cmd, player.args, { stdio: "ignore" });
+		this.child = child;
+		const done = new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("exit", () => resolve());
+		}).finally(() => {
+			if (this.child === child) this.child = null;
+		});
+		return {
+			name: player.cmd,
+			done
+		};
+	}
+	get playing() {
+		return this.child !== null;
+	}
+	stop() {
+		if (!this.child) return false;
+		this.child.kill();
+		this.child = null;
+		return true;
+	}
+};
+// src/analyze.ts
+const round = (v, places = 2) => Math.round(v * 10 ** places) / 10 ** places;
+function analyzeScenes(project, sceneIds) {
+	const flats = prefersFlats(project.key);
+	const scale = new Set(scalePcs(project.key));
+	return sceneIds.map((sceneId) => {
+		const scene = findScene(project, sceneId);
+		const score = buildSceneScore(project, scene.id);
+		const beats = scene.bars * 4;
+		const chordAt = (t) => score.chords.find((c) => t >= c.time - 1e-6 && t < c.time + c.duration) ?? score.chords.at(-1);
+		const layers = scene.layers.map((layer) => {
+			const notes = score.events.filter((e) => e.track === layer.id).sort((a, b) => a.time - b.time);
+			let longestRest = notes.length ? Math.max(0, notes[0].time) : beats;
+			let end = notes[0]?.time ?? 0;
+			for (const e of notes) {
+				longestRest = Math.max(longestRest, e.time - end);
+				end = Math.max(end, e.time + e.duration);
+			}
+			if (notes.length) longestRest = Math.max(longestRest, beats - end);
+			const base = {
+				id: layer.id,
+				name: layer.name,
+				instrument: layer.instrument,
+				notes: notes.length,
+				notesPerBar: round(notes.length / scene.bars, 1),
+				averageVelocity: notes.length ? round(notes.reduce((s, e) => s + e.velocity, 0) / notes.length) : 0,
+				longestRest: round(longestRest, 2)
+			};
+			if (INSTRUMENTS[layer.instrument].kind === "drums") {
+				const hits = {};
+				for (const e of notes) hits[e.drum ?? "?"] = (hits[e.drum ?? "?"] ?? 0) + 1;
+				return {
+					...base,
+					hits
+				};
+			}
+			const strong = notes.filter((e) => {
+				return Math.round(e.time * 4) / 4 % 2 === 0;
+			});
+			const chordTones = strong.filter((e) => chordAt(Math.round(e.time * 4) / 4)?.pcs.includes(mod12(e.midi))).length;
+			const pitches = notes.map((e) => e.midi);
+			return {
+				...base,
+				range: notes.length ? `${noteName(Math.min(...pitches), flats)} to ${noteName(Math.max(...pitches), flats)}` : "none",
+				strongBeatChordTones: strong.length ? round(chordTones / strong.length) : 1,
+				outOfKey: notes.filter((e) => {
+					const pc = mod12(e.midi);
+					return !scale.has(pc) && !chordAt(Math.round(e.time * 4) / 4)?.pcs.includes(pc);
+				}).length
+			};
+		});
+		const tonal = new Set(scene.layers.filter((l) => INSTRUMENTS[l.instrument].kind === "tonal").map((l) => l.id));
+		const drawn = score.events.filter((e) => tonal.has(e.track));
+		const clashes = /* @__PURE__ */ new Map();
+		for (let i = 0; i < drawn.length; i++) for (let j = i + 1; j < drawn.length; j++) {
+			const a = drawn[i];
+			const b = drawn[j];
+			if (a.track === b.track) continue;
+			const overlap = Math.min(a.time + a.duration, b.time + b.duration) - Math.max(a.time, b.time);
+			const gap = Math.abs(a.midi - b.midi);
+			if (overlap > .1 && (gap === 1 || gap === 13)) {
+				const beat = round(Math.max(a.time, b.time), 2);
+				if (!clashes.has(beat)) clashes.set(beat, `${noteName(a.midi, flats)} against ${noteName(b.midi, flats)}`);
+			}
+		}
+		return {
+			id: scene.id,
+			name: scene.name,
+			bars: scene.bars,
+			layers,
+			clashes: [...clashes].sort((a, b) => a[0] - b[0]).map(([beat, notes]) => ({
+				beat,
+				notes
+			}))
+		};
+	});
+}
+const pct = (v) => `${Math.round(v * 100)}%`;
+const db = (v) => Number.isFinite(v) ? v.toFixed(1) : "-inf";
+function formatAnalysis(scenes, levels) {
+	const lines = [];
+	for (const scene of scenes) {
+		if (lines.length) lines.push("");
+		lines.push(`Scene ${scene.name} [${scene.id}], ${scene.bars} bars`);
+		if (!scene.layers.length) lines.push("  No layers.");
+		for (const l of scene.layers) {
+			const parts = [`${l.notes} notes (${l.notesPerBar}/bar)`];
+			if (l.hits) parts.push(Object.entries(l.hits).map(([k, v]) => `${k} ${v}`).join(", ") || "no hits");
+			else if (l.notes) parts.push(`range ${l.range}`, `strong-beat chord tones ${pct(l.strongBeatChordTones ?? 1)}`, `out of key ${l.outOfKey}`);
+			if (l.notes) parts.push(`avg velocity ${l.averageVelocity}`, `longest rest ${l.longestRest} beats`);
+			lines.push(`  "${l.name}" (${l.instrument}): ${parts.join(", ")}`);
+		}
+		if (scene.clashes.length) {
+			const shown = scene.clashes.slice(0, 8).map((c) => `beat ${c.beat} ${c.notes}`);
+			lines.push(`  Half-step clashes between layers: ${shown.join("; ")}${scene.clashes.length > 8 ? `; and ${scene.clashes.length - 8} more` : ""}`);
+		} else lines.push("  No half-step clashes between layers.");
+	}
+	if (levels) {
+		lines.push("");
+		lines.push(`Render: ${levels.seconds.toFixed(1)} s, ${db(levels.lufs)} LUFS integrated, peak ${db(levels.peakDb)} dBFS, RMS ${db(levels.rmsDb)} dBFS`);
+		if (levels.peakDb > -.5) lines.push("  Peaks are close to clipping. Try lowering master or a busy layer.");
+		else if (levels.lufs < -20) lines.push("  Quiet for lofi. Most moods land around -12 to -15 LUFS.");
+	}
+	return lines.join("\n");
+}
+// src/paths.ts
+function samplesDir() {
+	if (process.env.HAKU_SAMPLES) return resolve(process.env.HAKU_SAMPLES);
+	const found = [new URL("./samples", import.meta.url), new URL("../../../assets/samples", import.meta.url)].map((u) => fileURLToPath(u)).find((dir) => existsSync(join(dir, "manifest.json")));
+	if (!found) throw new Error("Can't find Haku's samples. Set HAKU_SAMPLES to the folder that holds manifest.json.");
+	return found;
+}
+/** Figtree for snapshots. Loading every system font instead takes seconds on a well-stocked machine. */
+function fontFiles() {
+	const dir = [new URL("./fonts", import.meta.url), new URL("../assets/fonts", import.meta.url)].map((u) => fileURLToPath(u)).find((d) => existsSync(join(d, "Figtree-Regular.ttf")));
+	return dir ? ["Figtree-Regular.ttf", "Figtree-SemiBold.ttf"].map((f) => join(dir, f)) : [];
+}
+/** The built web app. A published build carries it in dist/web; in the repo it's apps/web/dist (run `pnpm --filter @haku/web build`). */
+function webDir() {
+	if (process.env.HAKU_WEB_DIR) return resolve(process.env.HAKU_WEB_DIR);
+	const found = [new URL("./web", import.meta.url), new URL("../../web/dist", import.meta.url)].map((u) => fileURLToPath(u)).find((dir) => existsSync(join(dir, "index.html")));
+	if (!found) throw new Error("Can't find the built Haku app. In the repo, run `pnpm --filter @haku/web build` first.");
+	return found;
+}
+// src/audio.ts
+let kit = null;
+function loadAudio() {
+	kit ??= (async () => {
+		const node = await import("./node-CVxAljK8.mjs");
+		node.setupNodeAudio();
+		const audio = await import("./src-CgZeiBJc.mjs");
+		const dir = samplesDir();
+		const bank = await audio.loadSampleBank(await node.readManifest(dir), node.nodeDecoder(dir));
+		return {
+			render: (project, opts) => audio.renderProject(project, bank, opts),
+			wav: (pcm) => audio.encodeWav(pcm),
+			levels: (pcm) => ({
+				seconds: (pcm.channels[0]?.length ?? 0) / pcm.sampleRate,
+				...audio.measure(pcm),
+				lufs: audio.integratedLoudness(pcm)
+			})
+		};
+	})();
+	kit.catch(() => kit = null);
+	return kit;
+}
+// src/version.ts
+const VERSION = "0.2.0";
+// src/web.ts
+const WEB_HOST = "127.0.0.1";
+const WEB_PORT = 5177;
+function webPort() {
+	const env = Number(process.env.HAKU_WEB_PORT);
+	return Number.isInteger(env) && env > 0 ? env : WEB_PORT;
+}
+/** 127.0.0.1 rather than localhost: projects are stored per origin, so the address has to stay the same. */
+const webUrl = (port = webPort()) => `http://${WEB_HOST}:${port}/`;
+const TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "text/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json",
+	".webmanifest": "application/manifest+json",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".woff2": "font/woff2",
+	".ogg": "audio/ogg",
+	".flac": "audio/flac",
+	".wav": "audio/wav"
+};
+/** Resolves a URL path inside root, or null if it tries to climb out. */
+function inside(root, urlPath) {
+	const full = normalize(join(root, urlPath));
+	return full === root || full.startsWith(root + sep) ? full : null;
+}
+async function findFile(roots, urlPath) {
+	for (const root of roots) {
+		const full = inside(root, urlPath);
+		if (!full) continue;
+		if ((await stat(full).catch(() => null))?.isFile()) return full;
+	}
+	return null;
+}
+/** Starts serving. Rejects with code EADDRINUSE when the port is taken. */
+function serveWeb(port = webPort()) {
+	const roots = [webDir(), samplesDir()];
+	const server = createServer(async (req, res) => {
+		if (req.method !== "GET" && req.method !== "HEAD") {
+			res.writeHead(405).end();
+			return;
+		}
+		let path;
+		try {
+			path = decodeURIComponent(new URL(req.url ?? "/", "http://haku").pathname);
+		} catch {
+			res.writeHead(400).end();
+			return;
+		}
+		if (path === "/__haku") {
+			res.writeHead(200, { "Content-Type": "application/json" }).end(JSON.stringify({
+				haku: true,
+				version: VERSION
+			}));
+			return;
+		}
+		const file = await findFile(roots, path === "/" ? "/index.html" : path);
+		if (!file) {
+			res.writeHead(404, { "Content-Type": "text/plain" }).end("Not found");
+			return;
+		}
+		res.writeHead(200, {
+			"Content-Type": TYPES[extname(file)] ?? "application/octet-stream",
+			"Cache-Control": path.startsWith("/assets/") ? "public, max-age=31536000, immutable" : "no-cache"
+		});
+		if (req.method === "HEAD") res.end();
+		else createReadStream(file).pipe(res);
+	});
+	return new Promise((resolve, reject) => {
+		server.once("error", reject);
+		server.listen(port, WEB_HOST, () => resolve(server));
+	});
+}
+/** True when a haku web server already answers on the port. */
+async function webRunning(port = webPort()) {
+	try {
+		const res = await fetch(`${webUrl(port)}__haku`, { signal: AbortSignal.timeout(1e3) });
+		return res.ok && (await res.json()).haku === true;
+	} catch {
+		return false;
+	}
+}
+/** Opens a URL in the default browser. Resolves false when no opener could be started. */
+function openBrowser(url) {
+	const [cmd, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["explorer.exe", [url]] : ["xdg-open", [url]];
+	return new Promise((resolve) => {
+		const child = spawn(cmd, args, {
+			stdio: "ignore",
+			detached: true
+		});
+		child.once("error", () => resolve(false));
+		child.once("spawn", () => {
+			child.unref();
+			resolve(true);
+		});
+	});
+}
+// src/launch.ts
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+/** Polls until check returns something truthy, or gives up with null. */
+async function waitFor(check, timeoutMs) {
+	const end = Date.now() + timeoutMs;
+	for (;;) {
+		const value = await check();
+		if (value) return value;
+		if (Date.now() >= end) return null;
+		await sleep(400);
+	}
+}
+async function tabOn(getLink) {
+	try {
+		const link = await getLink();
+		if (!link) return null;
+		return (await link.request({ op: "ping" })).tab ? link : null;
+	} catch {
+		return null;
+	}
+}
+async function launchTab(getLink) {
+	const port = webPort();
+	const url = webUrl(port);
+	if (!await webRunning(port)) {
+		spawn(process.execPath, [
+			process.argv[1],
+			"web",
+			"--no-open",
+			"--exit-when-idle"
+		], {
+			detached: true,
+			stdio: "ignore"
+		}).unref();
+		if (!await waitFor(() => webRunning(port), 1e4)) throw new Error(`Couldn't start haku web on port ${port}. Run "haku web" yourself to see what went wrong.`);
+	}
+	const existing = await waitFor(() => tabOn(getLink), 3e3);
+	if (existing) return existing;
+	const opened = await openBrowser(url);
+	const fresh = await waitFor(() => tabOn(getLink), 45e3);
+	if (fresh) return fresh;
+	throw new Error(opened ? `Opened Haku at ${url}, but no tab connected yet. Check the browser, then try again.` : `No Haku tab is connected and no browser could be opened. Open ${url} yourself, then try again.`);
+}
+// src/snapshot.ts
+/** The web app's walnut palette (tokens.css), as hex because resvg doesn't read oklch. */
+const C = {
+	bg: "#1b1410",
+	sunken: "#16100c",
+	raised: "#2f2520",
+	border: "#3f342e",
+	strong: "#5b4c44",
+	text: "#f2eee9",
+	muted: "#afa69d",
+	faint: "#7f756e"
+};
+const FONT = "Figtree, sans-serif";
+const esc = (s) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
+const n = (v) => Math.round(v * 10) / 10;
+function snapshotSvg(project, opts = {}) {
+	const scene = findScene(project, opts.scene);
+	const score = buildSceneScore(project, scene.id);
+	const flats = prefersFlats(project.key);
+	const W = opts.width ?? 1200;
+	const H = opts.height ?? 640;
+	const pad = 20;
+	const header = 46;
+	const strip = 30;
+	const legend = 40;
+	const x0 = pad;
+	const x1 = W - pad;
+	const top = 76;
+	const bottom = H - legend;
+	const cw = x1 - x0;
+	const ch = bottom - top;
+	const beats = scene.bars * 4;
+	const bx = (b) => x0 + b / beats * cw;
+	const noteCount = (l) => score.events.filter((e) => e.track === l.id).length;
+	const focus = scene.layers.find((l) => l.id === opts.layer || l.name.toLowerCase() === opts.layer?.toLowerCase()) ?? scene.layers.find((l) => noteCount(l) > 0) ?? scene.layers[0] ?? null;
+	const out = [];
+	out.push(`<svg xmlns="http://www.w3.org/2000/svg" width="${W}" height="${H}" viewBox="0 0 ${W} ${H}" font-family="${FONT}">`);
+	out.push(`<rect width="${W}" height="${H}" fill="${C.bg}"/>`);
+	out.push(`<text x="${x0}" y="29" font-size="17" font-weight="600" fill="${C.text}">${esc(project.name)}</text>`);
+	const info = `Scene ${scene.name} · ${scene.bars} bars · ${keyLabel(project.key)} · ${project.bpm} BPM`;
+	out.push(`<text x="${x1}" y="29" font-size="13" fill="${C.muted}" text-anchor="end">${esc(info)}</text>`);
+	out.push(`<rect x="${x0}" y="${header}" width="${cw}" height="${strip}" fill="${C.sunken}" rx="4"/>`);
+	for (const [i, chord] of score.chords.entries()) {
+		const cx = bx(chord.time);
+		const w = bx(chord.time + chord.duration) - cx;
+		if (i % 2 === 1) out.push(`<rect x="${n(cx)}" y="${header}" width="${n(w)}" height="${strip}" fill="${C.raised}" opacity="0.5"/>`);
+		out.push(`<text x="${n(cx + 9)}" y="66" font-size="12.5" font-weight="600" fill="${C.muted}">${esc(chord.symbol)}</text>`);
+	}
+	out.push(`<rect x="${x0}" y="${top}" width="${cw}" height="${ch}" fill="${C.sunken}" opacity="0.55"/>`);
+	for (let b = 0; b <= beats; b++) {
+		const gx = n(bx(b));
+		const bar = b % 4 === 0;
+		out.push(`<line x1="${gx}" y1="${bar ? header : top}" x2="${gx}" y2="${bottom}" stroke="${bar ? C.strong : C.border}" opacity="${bar ? .9 : .45}"/>`);
+		if (bar && b > 0) out.push(`<text x="${n(gx - 6)}" y="${bottom - 6}" font-size="10" fill="${C.faint}" text-anchor="end">${b / 4}</text>`);
+	}
+	if (focus && INSTRUMENTS[focus.instrument].kind === "drums") {
+		const rows = drumRows(focus.kit);
+		rows.forEach((piece, i) => {
+			const y = n(top + (1 - (i + 1) / rows.length) * ch);
+			out.push(`<line x1="${x0}" y1="${y}" x2="${x1}" y2="${y}" stroke="${C.border}" opacity="0.5"/>`);
+			out.push(`<text x="27" y="${n(y + ch / rows.length / 2 + 4)}" font-size="10.5" fill="${C.faint}">${piece}</text>`);
+		});
+	} else if (focus) {
+		const range = layerRange(focus);
+		for (let m = Math.ceil(range[0] / 12) * 12; m <= range[1]; m += 12) {
+			const y = n(top + pitchToY(m, range) * ch);
+			out.push(`<line x1="${x0}" y1="${y}" x2="${x1}" y2="${y}" stroke="${C.border}" stroke-dasharray="2 4" opacity="0.6"/>`);
+			out.push(`<text x="27" y="${n(y - top < 16 ? y + 12 : y - 5)}" font-size="10.5" fill="${C.faint}">${noteName(m, flats)}</text>`);
+		}
+	}
+	const layers = [...scene.layers].sort((a, b) => Number(a.id === focus?.id) - Number(b.id === focus?.id));
+	for (const layer of layers) {
+		const front = layer.id === focus?.id;
+		const drums = INSTRUMENTS[layer.instrument].kind === "drums";
+		const range = layerRange(layer);
+		const rows = drumRows(layer.kit);
+		out.push(`<g fill="${layer.color}" opacity="${front ? .75 : .32}">`);
+		for (const e of score.events) {
+			if (e.track !== layer.id) continue;
+			let ny;
+			let nh;
+			if (drums) {
+				ny = 1 - (Math.max(0, rows.indexOf(e.drum)) + 1) / rows.length;
+				nh = 1 / rows.length;
+			} else {
+				nh = 1 / (range[1] - range[0]);
+				ny = pitchToY(e.midi, range) - nh / 2;
+			}
+			const rx = bx(e.time);
+			const rw = Math.max(3, bx(e.time + e.duration) - rx - 1.5);
+			const rh = Math.max(4, nh * ch - 1.5);
+			out.push(`<rect x="${n(rx)}" y="${n(top + ny * ch)}" width="${n(rw)}" height="${n(rh)}" rx="${n(Math.min(3, rh / 2))}"/>`);
+		}
+		out.push("</g>");
+		for (const s of layer.strokes) {
+			const width = n(2 + s.size * 10);
+			const opacity = front ? .85 : .2;
+			if (s.points.length === 1) {
+				const p = s.points[0];
+				out.push(`<circle cx="${n(x0 + p.x * cw)}" cy="${n(top + p.y * ch)}" r="${n(width / 2 + 1)}" fill="${layer.color}" opacity="${opacity}"/>`);
+			} else {
+				const pts = s.points.map((p) => `${n(x0 + p.x * cw)},${n(top + p.y * ch)}`).join(" ");
+				out.push(`<polyline points="${pts}" fill="none" stroke="${layer.color}" stroke-width="${width}" stroke-linecap="round" stroke-linejoin="round" opacity="${opacity}"/>`);
+			}
+		}
+	}
+	let lx = x0;
+	const ly = H - legend / 2 + 4;
+	if (!scene.layers.length) out.push(`<text x="${lx}" y="${ly}" font-size="12" fill="${C.faint}">No layers yet</text>`);
+	for (const layer of scene.layers) {
+		const flags = [layer.muted && "muted", layer.solo && "solo"].filter(Boolean).join(", ");
+		const label = `${layer.name} · ${INSTRUMENTS[layer.instrument].label} · ${noteCount(layer)} notes${flags ? ` · ${flags}` : ""}`;
+		const weight = layer.id === focus?.id ? 600 : 400;
+		out.push(`<rect x="${lx}" y="${ly - 9}" width="10" height="10" rx="2" fill="${layer.color}"/>`);
+		out.push(`<text x="${lx + 16}" y="${ly}" font-size="12" font-weight="${weight}" fill="${layer.id === focus?.id ? C.text : C.muted}">${esc(label)}</text>`);
+		lx += 16 + label.length * 6.6 + 22;
+	}
+	out.push("</svg>");
+	return out.join("\n");
+}
+/** PNG bytes. resvg is a native module, so it's only loaded when a PNG is actually asked for. */
+async function snapshotPng(svg, width) {
+	const { Resvg } = await import("@resvg/resvg-js");
+	const files = fontFiles();
+	return new Resvg(svg, {
+		fitTo: width ? {
+			mode: "width",
+			value: width
+		} : { mode: "original" },
+		font: files.length ? {
+			loadSystemFonts: false,
+			fontFiles: files,
+			defaultFontFamily: "Figtree",
+			sansSerifFamily: "Figtree"
+		} : { loadSystemFonts: true }
+	}).render().asPng();
+}
+// src/target.ts
+const isReadOnly = (cmd) => READ_ONLY_COMMANDS.includes(cmd?.type);
+/** Applies commands to a project in memory. Throws on the first bad one, naming which it was. */
+function applyAll(project, commands) {
+	const messages = [];
+	const data = [];
+	for (const [i, cmd] of commands.entries()) try {
+		const r = executeUnknown(project, cmd);
+		project = r.project;
+		messages.push(r.message);
+		data.push(r.data ?? null);
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		throw new Error(commands.length > 1 ? `Command ${i + 1} (${cmd?.type ?? "?"}) failed: ${msg}. Nothing was changed.` : msg);
+	}
+	return {
+		project,
+		messages,
+		data
+	};
+}
+async function readProjectFile(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (err) {
+		if (err.code === "ENOENT") throw new Error(`No project file at ${path}. Make one with new_project.`);
+		throw err;
+	}
+	let data;
+	try {
+		data = JSON.parse(text);
+	} catch {
+		throw new Error(`${path} isn't valid JSON`);
+	}
+	return parseProject(data);
+}
+/** Writes through a temp file and a rename, so a crash never leaves half a project behind. */
+async function writeProjectFile(path, project) {
+	const tmp = `${path}.${randomUUID().slice(0, 8)}.tmp`;
+	await writeFile(tmp, `${JSON.stringify(project, null, 2)}\n`);
+	await rename(tmp, path);
+}
+var FileTarget = class {
+	kind = "file";
+	label;
+	constructor(path) {
+		this.label = path;
+	}
+	read() {
+		return readProjectFile(this.label);
+	}
+	async run(commands) {
+		const result = applyAll(await this.read(), commands);
+		if (!commands.every(isReadOnly)) await writeProjectFile(this.label, result.project);
+		return {
+			messages: result.messages,
+			data: result.data
+		};
+	}
+};
+var LiveTarget = class {
+	kind = "live";
+	label = "the Haku tab";
+	link;
+	constructor(link) {
+		this.link = link;
+	}
+	async read() {
+		return parseProject(await this.link.request({ op: "get_project" }));
+	}
+	async run(commands) {
+		if (commands.every(isReadOnly)) {
+			const { messages, data } = applyAll(await this.read(), commands);
+			return {
+				messages,
+				data
+			};
+		}
+		return await this.link.request({
+			op: "execute",
+			commands
+		});
+	}
+};
+// src/tools.ts
+const define = (tool) => tool;
+const file = z.string().optional().describe("Project file (.haku.json). Leave out to work on the project open in the Haku tab.");
+const scope = z.enum(["scene", "song"]).optional().describe("One scene, or the whole arrangement. Default scene.");
+const sceneArg = z.string().optional().describe("Scene id or name. Defaults to the active scene.");
+const outArg = (what) => z.string().describe(`Where to write the ${what}. Relative paths are from the working directory.`);
+const slug = (s) => s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "") || "haku";
+async function connectedTab(ctx) {
+	const link = await ctx.link();
+	if (!link) return null;
+	return (await link.request({ op: "ping" })).tab ? link : null;
+}
+/** The connected tab, opening Haku first when none is connected (unless auto-launch is off). */
+async function requireTab(ctx) {
+	const tab = await connectedTab(ctx);
+	if (tab) return tab;
+	if (!ctx.autoLaunch) throw new Error(NO_TAB);
+	return launchTab(ctx.link);
+}
+/** The file when one is given, otherwise the live tab. */
+async function targetFor(ctx, path) {
+	if (path) return new FileTarget(resolve(ctx.cwd, path));
+	return new LiveTarget(await requireTab(ctx));
+}
+/** The scene a tool works on, resolved to an id so file and live targets agree. */
+const sceneOf = (project, scene) => findScene(project, scene);
+const commandTools = CommandSchema.options.map((option) => {
+	const schema = option;
+	const type = schema.shape.type.value;
+	const input = schema.omit({ type: true }).extend({ file });
+	const readOnly = READ_ONLY_COMMANDS.includes(type);
+	return define({
+		name: type,
+		title: type.replace(/_/g, " "),
+		description: COMMAND_HELP[type],
+		input,
+		readOnly,
+		destructive: type === "remove_layer" || type === "remove_scene" || type === "erase",
+		async run(args, ctx) {
+			const { file: path, ...rest } = args;
+			return { text: (await (await targetFor(ctx, path)).run([{
+				type,
+				...rest
+			}])).messages.join("\n") };
+		}
+	});
+});
+const batch = define({
+	name: "batch",
+	title: "Run several commands",
+	description: "Run a list of commands in order as one step (one undo in the tab). If any fails, nothing changes. Each item is a command object with a \"type\" field, like {\"type\":\"draw_line\",...}.",
+	input: z.object({
+		file,
+		commands: z.array(CommandSchema).min(1).max(500)
+	}),
+	async run({ file: path, commands }, ctx) {
+		return { text: (await (await targetFor(ctx, path)).run(commands)).messages.map((m, i) => `${i + 1}. ${m}`).join("\n") };
+	}
+});
+const newProject = define({
+	name: "new_project",
+	title: "New project",
+	description: "Start a new project from a mood. With file, writes a new .haku.json. Without it, opens the new project in the Haku tab (the old one stays saved there).",
+	input: z.object({
+		file: z.string().optional().describe("Path for the new .haku.json. Leave out to open it in the Haku tab instead."),
+		name: z.string().min(1).max(80).optional(),
+		mood: z.enum(MOOD_IDS).optional().describe("Default rainy-study"),
+		bars: z.number().int().min(1).max(16).optional().describe("Length of the first scene. Default 4."),
+		seed: z.number().int().optional().describe("Fixes the random humanize and spray, for repeatable renders"),
+		overwrite: z.boolean().optional().describe("Replace the file if it exists")
+	}),
+	async run({ file: path, name, mood, bars, seed, overwrite }, ctx) {
+		const project = createProject({
+			name,
+			mood,
+			bars,
+			seed
+		});
+		if (path) {
+			const full = resolve(ctx.cwd, path);
+			if (existsSync(full) && !overwrite) throw new Error(`${full} already exists. Pass overwrite to replace it.`);
+			await writeProjectFile(full, project);
+			return { text: `Created "${project.name}" (${project.mood}) at ${full}` };
+		}
+		await (await requireTab(ctx)).request({
+			op: "open_project",
+			project
+		});
+		return { text: `Opened a new project "${project.name}" (${project.mood}) in the Haku tab` };
+	}
+});
+const openProject = define({
+	name: "open_project",
+	title: "Open a file in the tab",
+	description: "Send a .haku.json file to the Haku tab and open it there, so you can hear and see it live.",
+	input: z.object({ file: z.string().describe("The .haku.json to open") }),
+	async run({ file: path }, ctx) {
+		const full = resolve(ctx.cwd, path);
+		const project = await readProjectFile(full);
+		await (await requireTab(ctx)).request({
+			op: "open_project",
+			project
+		});
+		return { text: `Opened "${project.name}" from ${full} in the Haku tab` };
+	}
+});
+const saveProject = define({
+	name: "save_project",
+	title: "Save the tab to a file",
+	description: "Write the project open in the Haku tab to a .haku.json file.",
+	input: z.object({
+		file: outArg(".haku.json"),
+		overwrite: z.boolean().optional().describe("Replace the file if it exists")
+	}),
+	async run({ file: path, overwrite }, ctx) {
+		const full = resolve(ctx.cwd, path);
+		if (existsSync(full) && !overwrite) throw new Error(`${full} already exists. Pass overwrite to replace it.`);
+		const tab = await connectedTab(ctx);
+		if (!tab) throw new Error(NO_TAB);
+		const project = parseProject(await tab.request({ op: "get_project" }));
+		await writeProjectFile(full, project);
+		return { text: `Saved "${project.name}" to ${full}` };
+	}
+});
+const play = define({
+	name: "play",
+	title: "Play",
+	description: "Listen. With no file it plays in the Haku tab, opening one if needed. With a file it renders offline and plays through this machine's speakers.",
+	input: z.object({
+		file,
+		scope,
+		scene: sceneArg,
+		loops: z.number().int().min(1).max(8).optional().describe("Times through a scene when rendering offline. Default 2.")
+	}),
+	async run({ file: path, scope = "scene", scene, loops = 2 }, ctx) {
+		if (!path) {
+			const status = await (await requireTab(ctx)).request({
+				op: "play",
+				mode: scope === "song" ? "song" : "loop",
+				scene
+			});
+			return { text: `Playing ${scope === "song" ? "the song" : `scene ${status.sceneName} on a loop`} in the Haku tab` };
+		}
+		const project = await new FileTarget(resolve(ctx.cwd, path)).read();
+		const sceneId = sceneOf(project, scene).id;
+		const audio = await loadAudio();
+		const pcm = await audio.render(project, scope === "song" ? { scope: "song" } : {
+			scope: "scene",
+			sceneId,
+			loops,
+			tail: 2
+		});
+		const wav = join(tmpdir(), `haku-play-${randomUUID().slice(0, 8)}.wav`);
+		await writeFile(wav, audio.wav(pcm));
+		const { name, done } = ctx.player.play(wav);
+		const seconds = (pcm.channels[0].length / pcm.sampleRate).toFixed(1);
+		const what = scope === "song" ? "the song" : `scene ${sceneOf(project, scene).name}`;
+		if (ctx.waitForPlayback) {
+			await done;
+			return { text: `Played ${what} (${seconds} s) through ${name}` };
+		}
+		done.catch(() => {});
+		return { text: `Playing ${what} (${seconds} s) through ${name}. Call stop to end it early.` };
+	}
+});
+const stop = define({
+	name: "stop",
+	title: "Stop",
+	description: "Stop playback, in the tab and anything playing offline.",
+	input: z.object({}),
+	async run(_, ctx) {
+		const stopped = [];
+		if (ctx.player.stop()) stopped.push("offline playback");
+		const tab = await connectedTab(ctx);
+		if (tab) {
+			await tab.request({ op: "stop" });
+			stopped.push("the Haku tab");
+		}
+		return { text: stopped.length ? `Stopped ${stopped.join(" and ")}` : "Nothing was playing" };
+	}
+});
+const snapshot = define({
+	name: "snapshot",
+	title: "Snapshot",
+	description: "A picture of a scene: chords along the top, each layer's notes and strokes, and a legend. Returns a PNG. Pass out to also save it (.png or .svg).",
+	readOnly: true,
+	input: z.object({
+		file,
+		scene: sceneArg,
+		layer: z.string().optional().describe("Layer to bring to the front, with its pitch guides"),
+		width: z.number().int().min(400).max(2400).optional().describe("Image width in pixels. Default 1200."),
+		out: z.string().optional().describe("Also save the picture here (.png or .svg)")
+	}),
+	async run({ file: path, scene, layer, width = 1200, out }, ctx) {
+		const project = await (await targetFor(ctx, path)).read();
+		const s = sceneOf(project, scene);
+		const svg = snapshotSvg(project, {
+			scene: s.id,
+			layer,
+			width,
+			height: Math.round(width * .53)
+		});
+		const notes = [`Snapshot of scene ${s.name} in "${project.name}"`];
+		if (out?.toLowerCase().endsWith(".svg")) {
+			const full = resolve(ctx.cwd, out);
+			await writeFile(full, svg);
+			notes.push(`saved to ${full}`);
+		}
+		const png = await snapshotPng(svg);
+		if (out && !out.toLowerCase().endsWith(".svg")) {
+			const full = resolve(ctx.cwd, out);
+			await writeFile(full, png);
+			notes.push(`saved to ${full}`);
+		}
+		return {
+			text: notes.join(", "),
+			image: {
+				data: png,
+				mimeType: "image/png"
+			}
+		};
+	}
+});
+const analyze = define({
+	name: "analyze",
+	title: "Analyze",
+	description: "Check a scene or the song: notes per layer, how many strong-beat notes are chord tones, notes outside the key, half-step clashes between layers, and (with audio) loudness from an offline render.",
+	readOnly: true,
+	input: z.object({
+		file,
+		scope,
+		scene: sceneArg,
+		audio: z.boolean().optional().describe("Render and measure loudness too. Takes a few seconds. Default true.")
+	}),
+	async run({ file: path, scope = "scene", scene, audio = true }, ctx) {
+		const project = await (await targetFor(ctx, path)).read();
+		const ids = scope === "song" ? [...new Set(project.arrangement.map((a) => a.sceneId))] : [sceneOf(project, scene).id];
+		const scenes = analyzeScenes(project, ids);
+		let levels = null;
+		if (audio) {
+			const kit = await loadAudio();
+			const pcm = await kit.render(project, scope === "song" ? { scope: "song" } : {
+				scope: "scene",
+				sceneId: ids[0],
+				loops: 2
+			});
+			levels = kit.levels(pcm);
+		}
+		return { text: formatAnalysis(scenes, levels) };
+	}
+});
+const exportTool = define({
+	name: "export",
+	title: "Export",
+	description: "Write a WAV (rendered offline, same sound as the app), a MIDI file, or the project JSON.",
+	readOnly: true,
+	input: z.object({
+		file,
+		format: z.enum([
+			"wav",
+			"midi",
+			"json"
+		]),
+		scope,
+		scene: sceneArg,
+		out: z.string().optional().describe("Output path. Defaults to a name made from the project (and scene) in the working directory.")
+	}),
+	async run({ file: path, format, scope = "scene", scene, out }, ctx) {
+		const project = await (await targetFor(ctx, path)).read();
+		const s = sceneOf(project, scene);
+		const base = format === "json" || scope === "song" ? slug(project.name) : `${slug(project.name)}-${slug(s.name)}`;
+		const ext = {
+			wav: ".wav",
+			midi: ".mid",
+			json: ".haku.json"
+		}[format];
+		const full = resolve(ctx.cwd, out ?? base + ext);
+		if (format === "json") await writeProjectFile(full, project);
+		else if (format === "midi") {
+			const score = scope === "song" ? buildArrangementScore(project) : buildSceneScore(project, s.id);
+			await writeFile(full, scoreToMidi(project, score));
+		} else {
+			const kit = await loadAudio();
+			const pcm = await kit.render(project, scope === "song" ? { scope: "song" } : {
+				scope: "scene",
+				sceneId: s.id,
+				loops: 2
+			});
+			await writeFile(full, kit.wav(pcm));
+			const lv = kit.levels(pcm);
+			return { text: `Wrote ${full} (${lv.seconds.toFixed(1)} s, ${lv.lufs.toFixed(1)} LUFS, peak ${lv.peakDb.toFixed(1)} dBFS)` };
+		}
+		return { text: `Wrote ${full}` };
+	}
+});
+const status = define({
+	name: "status",
+	title: "Status",
+	description: "Is the bridge running, is a Haku tab connected, and what is it playing.",
+	readOnly: true,
+	input: z.object({}),
+	async run(_, ctx) {
+		const lines = [];
+		const link = await ctx.link();
+		if (!link) lines.push("Bridge: not running. Run \"haku web\" to open Haku with the bridge.");
+		else {
+			const ping = await link.request({ op: "ping" });
+			if (!ping.tab) lines.push("Bridge: running, no Haku tab connected.");
+			else {
+				const s = await link.request({ op: "status" });
+				lines.push(`Bridge: running, ${ping.tabs} tab${ping.tabs === 1 ? "" : "s"} connected.`);
+				lines.push(`Tab: "${s.projectName}", scene ${s.sceneName}, ${s.playing ? `playing (${s.mode})` : "stopped"}, sounds ${s.engine}.`);
+			}
+		}
+		if (ctx.player.playing) lines.push("Offline playback: playing.");
+		return { text: lines.join("\n") };
+	}
+});
+const TOOLS = [
+	newProject,
+	openProject,
+	saveProject,
+	...commandTools,
+	batch,
+	play,
+	stop,
+	snapshot,
+	analyze,
+	exportTool,
+	status
+];
+export { webRunning as a, Player as c, BridgeHost as d, SharedLink as f, webPort as i, GUIDE as l, openBrowser as n, webUrl as o, bridgePort as p, serveWeb as r, VERSION as s, TOOLS as t, BridgeClient as u };