@hraness/dawg 0.3.0 → 0.4.1

package/core/kits.ts

@@ -0,0 +1,320 @@
+/**
+ * Synthesized drum kits: parameter sets for the built-in drum synth
+ * (`src/audio/kits.ts`). A kit is chosen per track (`kit: "syn808"` on an
+ * `instrument: "kit"` track); a track without `kit` plays the original
+ * voices, byte-for-byte unchanged.
+ *
+ * Kits are plain data so the score can validate names without importing
+ * the renderer, and every kit renders deterministically (noise is seeded
+ * per note, exactly as in the default kit).
+ *
+ * Sample kits (Roland TR banks and friends from Strudel-format packs) live
+ * in `src/audio/packs.ts` (`DEFAULT_KITS`, `/kit 909`); `src/audio/kits.ts`
+ * lists both kinds in one catalog.
+ */
+/** Pitched body with an exponential pitch drop (kick, tom). */
+export type DrumBodyParams = Readonly<{
+  /** Resting frequency, Hz. */
+  base: number;
+  /** Extra Hz at the attack, decaying at `sweepRate` per second. */
+  sweep: number;
+  sweepRate: number;
+  /** Amplitude decay rate per second (higher is shorter). */
+  decay: number;
+  /** Noise click level at the attack and its decay rate. */
+  click: number;
+  clickDecay: number;
+  /** Level of the body. */
+  level: number;
+}>;
+
+export type SnareParams = Readonly<{
+  /** Drum-head tone, Hz, with its level and decay rate. */
+  tone: number;
+  toneLevel: number;
+  toneDecay: number;
+  /** Snare-wire noise level and decay rate. */
+  noise: number;
+  noiseDecay: number;
+  /** 0 dull … 1 bright wires (white vs high-passed noise). */
+  snap: number;
+}>;
+
+export type ClapParams = Readonly<{
+  /** Seconds between the three bursts. */
+  gap: number;
+  /** Decay rate of the diffuse tail. */
+  tail: number;
+  /** Band-pass smoothing 0..1 (higher is brighter). */
+  band: number;
+  level: number;
+}>;
+
+export type HatParams = Readonly<{
+  level: number;
+  decay: number;
+  /** 0 dark … 1 bright noise. */
+  tone: number;
+  /** 0 noise … 1 six detuned square oscillators (808-style metal). */
+  metal: number;
+}>;
+
+export type RimParams = Readonly<{
+  high: number;
+  low: number;
+  decay: number;
+  level: number;
+}>;
+
+export type SynthKit = Readonly<{
+  name: string;
+  label: string;
+  /** One line for pickers. */
+  description: string;
+  kick: DrumBodyParams;
+  tom: DrumBodyParams;
+  snare: SnareParams;
+  clap: ClapParams;
+  hat: HatParams;
+  openhat: HatParams;
+  rim: RimParams;
+  /** Longest one-shot, seconds (808 booms ring longer). */
+  seconds: number;
+  /** 0..1 tanh saturation. */
+  drive: number;
+  /** Bit depth for crushing; 0 is off. */
+  bits: number;
+  /** Sample-and-hold factor (1 = off) for a dusty, aliased top end. */
+  hold: number;
+  /** Output gain. */
+  gain: number;
+}>;
+
+/** The original voices as parameters (the default kit is not routed through these). */
+type KitParams = Omit<SynthKit, "name" | "label" | "description">;
+
+const BASE: KitParams = Object.freeze({
+  kick: {
+    base: 45,
+    sweep: 105,
+    sweepRate: 28,
+    decay: 7.5,
+    click: 0.12,
+    clickDecay: 300,
+    level: 1,
+  },
+  tom: {
+    base: 105,
+    sweep: 95,
+    sweepRate: 18,
+    decay: 9,
+    click: 0,
+    clickDecay: 300,
+    level: 1,
+  },
+  snare: {
+    tone: 185,
+    toneLevel: 0.45,
+    toneDecay: 22,
+    noise: 0.7,
+    noiseDecay: 16,
+    snap: 0,
+  },
+  clap: { gap: 0.01, tail: 18, band: 0.35, level: 1 },
+  hat: { level: 0.42, decay: 60, tone: 1, metal: 0 },
+  openhat: { level: 0.36, decay: 9, tone: 1, metal: 0 },
+  rim: { high: 1_700, low: 820, decay: 90, level: 1 },
+  seconds: 0.6,
+  drive: 0,
+  bits: 0,
+  hold: 1,
+  gain: 1,
+});
+
+type KitOverrides = Readonly<
+  Partial<{
+    [K in keyof KitParams]: KitParams[K] extends object
+      ? Partial<KitParams[K]>
+      : KitParams[K];
+  }>
+>;
+
+function kit(
+  name: string,
+  label: string,
+  description: string,
+  overrides: KitOverrides,
+): SynthKit {
+  const out: Record<string, unknown> = { name, label, description };
+  for (const [key, value] of Object.entries(BASE)) {
+    const override = (overrides as Record<string, unknown>)[key];
+    out[key] =
+      typeof value === "object"
+        ? Object.freeze({ ...value, ...(override as object | undefined) })
+        : (override ?? value);
+  }
+  return Object.freeze(out) as SynthKit;
+}
+
+/** Synthesized kits in picker order. */
+export const SYNTH_KITS: readonly SynthKit[] = Object.freeze([
+  kit("syn808", "808 (synth)", "long sub boom, snappy snare, metallic hats", {
+    kick: {
+      base: 49,
+      sweep: 70,
+      sweepRate: 20,
+      decay: 2.6,
+      click: 0.03,
+      clickDecay: 400,
+    },
+    tom: { base: 95, sweep: 40, sweepRate: 14, decay: 5 },
+    snare: {
+      tone: 238,
+      toneLevel: 0.5,
+      toneDecay: 18,
+      noise: 0.55,
+      noiseDecay: 20,
+      snap: 0.8,
+    },
+    clap: { gap: 0.011, tail: 14 },
+    hat: { level: 0.36, decay: 70, metal: 1 },
+    openhat: { level: 0.3, decay: 7, metal: 1 },
+    rim: { high: 1_870, low: 470, decay: 110 },
+    seconds: 1.4,
+  }),
+  kit("syn909", "909 (synth)", "punchy clicky kick, bright noisy snare", {
+    kick: {
+      base: 52,
+      sweep: 190,
+      sweepRate: 38,
+      decay: 6,
+      click: 0.35,
+      clickDecay: 500,
+    },
+    snare: {
+      tone: 205,
+      toneLevel: 0.4,
+      toneDecay: 26,
+      noise: 0.9,
+      noiseDecay: 12,
+      snap: 1,
+    },
+    clap: { gap: 0.009, tail: 12, band: 0.5 },
+    hat: { level: 0.4, decay: 55, tone: 1, metal: 0.3 },
+    openhat: { level: 0.34, decay: 6, metal: 0.3 },
+    drive: 0.35,
+  }),
+  kit("acoustic", "Acoustic-ish", "beater kick, wire snare, darker cymbals", {
+    kick: {
+      base: 62,
+      sweep: 45,
+      sweepRate: 30,
+      decay: 11,
+      click: 0.3,
+      clickDecay: 180,
+    },
+    tom: { base: 120, sweep: 50, sweepRate: 10, decay: 7, click: 0.1 },
+    snare: {
+      tone: 175,
+      toneLevel: 0.35,
+      toneDecay: 18,
+      noise: 0.85,
+      noiseDecay: 9,
+      snap: 0.3,
+    },
+    clap: { tail: 22, band: 0.25 },
+    hat: { level: 0.4, decay: 45, tone: 0.55, metal: 0.5 },
+    openhat: { level: 0.34, decay: 4.5, tone: 0.55, metal: 0.5 },
+    rim: { high: 1_300, low: 640, decay: 70 },
+    seconds: 0.9,
+  }),
+  kit("lofi", "Lo-fi dusty", "soft round kick, crushed and dark", {
+    kick: { base: 50, sweep: 70, sweepRate: 22, decay: 8, click: 0.05 },
+    snare: { toneLevel: 0.5, noise: 0.6, noiseDecay: 14, snap: 0 },
+    hat: { level: 0.38, decay: 50, tone: 0.3 },
+    openhat: { level: 0.3, decay: 8, tone: 0.3 },
+    drive: 0.25,
+    bits: 8,
+    hold: 3,
+    gain: 0.95,
+  }),
+  kit(
+    "electro",
+    "Electro minimal",
+    "tight short kick, clicky rim, ticking hats",
+    {
+      kick: {
+        base: 56,
+        sweep: 240,
+        sweepRate: 60,
+        decay: 13,
+        click: 0.2,
+        clickDecay: 700,
+      },
+      tom: { base: 140, sweep: 160, sweepRate: 40, decay: 14 },
+      snare: {
+        tone: 310,
+        toneLevel: 0.55,
+        toneDecay: 35,
+        noise: 0.5,
+        noiseDecay: 28,
+        snap: 1,
+      },
+      clap: { gap: 0.008, tail: 26, band: 0.6 },
+      hat: { level: 0.38, decay: 120, metal: 0.6 },
+      openhat: { level: 0.32, decay: 14, metal: 0.6 },
+      rim: { high: 2_400, low: 1_100, decay: 140 },
+      seconds: 0.5,
+    },
+  ),
+  kit("trap", "Trap", "distorted long 808, crisp hats, high snare", {
+    kick: {
+      base: 43,
+      sweep: 90,
+      sweepRate: 16,
+      decay: 1.6,
+      click: 0.08,
+      clickDecay: 400,
+      level: 0.9,
+    },
+    snare: {
+      tone: 265,
+      toneLevel: 0.45,
+      toneDecay: 20,
+      noise: 0.8,
+      noiseDecay: 15,
+      snap: 1,
+    },
+    clap: { gap: 0.012, tail: 16, band: 0.55 },
+    hat: { level: 0.4, decay: 95, tone: 1, metal: 0.4 },
+    openhat: { level: 0.32, decay: 8, metal: 0.4 },
+    seconds: 1.6,
+    drive: 0.55,
+  }),
+]);
+
+const BY_NAME = new Map(SYNTH_KITS.map((entry) => [entry.name, entry]));
+
+/** Accepted spellings for kit names (`808` resolves to the sample bank instead). */
+const KIT_ALIASES: Readonly<Record<string, string>> = Object.freeze({
+  synth808: "syn808",
+  "synth-808": "syn808",
+  "syn-808": "syn808",
+  synth909: "syn909",
+  "synth-909": "syn909",
+  "syn-909": "syn909",
+  "lo-fi": "lofi",
+  dusty: "lofi",
+  minimal: "electro",
+});
+
+/** The synth kit named `name` (case-insensitive, with aliases), if any. */
+export function synthKit(name: string | undefined): SynthKit | undefined {
+  if (typeof name !== "string") return undefined;
+  const key = name.trim().toLowerCase();
+  return BY_NAME.get(KIT_ALIASES[key] ?? key);
+}
+
+export const SYNTH_KIT_NAMES: readonly string[] = Object.freeze(
+  SYNTH_KITS.map((entry) => entry.name),
+);

package/core/params.ts

@@ -0,0 +1,111 @@
+/**
+ * Typed parameter specs shared by the effects chain (core/fx.ts) and the
+ * synth voice (core/synth.ts): one table per unit drives validation,
+ * printing, the menu, prompt commands and agent tools.
+ */
+
+export type NumberParam = Readonly<{
+  kind: "number";
+  min: number;
+  max: number;
+  default: number;
+  /** Menu nudge step; `"log"` nudges by a sixth of an octave. */
+  step: number | "log";
+  unit?: string;
+  /** Round stored values to an integer. */
+  integer?: boolean;
+  /** Not filled with the default when absent (absent keeps legacy behaviour). */
+  optional?: boolean;
+  /** A lane `<effect>-<param>` exists for this parameter. */
+  automate?: boolean;
+  doc: string;
+  /** Strudel names (and aliases) that mean this parameter. */
+  strudel?: readonly string[];
+}>;
+
+export type EnumParam = Readonly<{
+  kind: "enum";
+  values: readonly string[];
+  default: string;
+  optional?: boolean;
+  doc: string;
+  strudel?: readonly string[];
+}>;
+
+export type BooleanParam = Readonly<{
+  kind: "boolean";
+  default: boolean;
+  optional?: boolean;
+  doc: string;
+  strudel?: readonly string[];
+}>;
+
+export type ParamSpec = NumberParam | EnumParam | BooleanParam;
+
+/** A validated parameter record. */
+export type FxValues = Readonly<Record<string, number | string | boolean>>;
+
+export class FxValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "FxValidationError";
+  }
+}
+
+/** Validates one parameter value against its spec. */
+export function normalizeParam(
+  spec: ParamSpec,
+  value: unknown,
+  label: string,
+): number | string | boolean {
+  if (spec.kind === "enum") {
+    if (typeof value !== "string" || !spec.values.includes(value))
+      throw new FxValidationError(
+        `${label} must be one of ${spec.values.join(", ")}`,
+      );
+    return value;
+  }
+  if (spec.kind === "boolean") {
+    if (typeof value !== "boolean")
+      throw new FxValidationError(`${label} must be true or false`);
+    return value;
+  }
+  if (typeof value !== "number" || !Number.isFinite(value))
+    throw new FxValidationError(`${label} must be a finite number`);
+  if (value < spec.min || value > spec.max)
+    throw new FxValidationError(
+      `${label} must be between ${spec.min} and ${spec.max}`,
+    );
+  return spec.integer ? Math.round(value) : value;
+}
+
+/**
+ * Validates a parameter record against `params`, filling defaults for
+ * absent keys. Unknown keys are rejected so typos never pass silently.
+ */
+export function normalizeParams(
+  params: Readonly<Record<string, ParamSpec>>,
+  input: unknown,
+  label: string,
+  fill = true,
+): FxValues {
+  if (!isRecord(input))
+    throw new FxValidationError(`${label} must be an object`);
+  for (const key of Object.keys(input))
+    if (!Object.prototype.hasOwnProperty.call(params, key))
+      throw new FxValidationError(`${label} has no parameter "${key}"`);
+  const out: Record<string, number | string | boolean> = {};
+  for (const [key, spec] of Object.entries(params)) {
+    const value = input[key];
+    if (value === undefined) {
+      if (fill && !spec.optional) out[key] = spec.default;
+      continue;
+    }
+    out[key] = normalizeParam(spec, value, `${label} ${key}`);
+  }
+  return Object.freeze(out);
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/core/rhythm.ts

@@ -0,0 +1,287 @@
+/**
+ * Rhythm rows on a score: the glue between `core/euclid.ts` generators and
+ * the stored notes.
+ *
+ * A track's `rhythm` rows each own one voice lane (a drum voice, a one-shot
+ * sampler voice, or a pitch). `withTrackRhythm` replaces the rows and
+ * regenerates exactly those lanes' notes, so an edit is one next score and
+ * therefore one revision and one undo step. Other notes on the track, and
+ * every other track, are untouched. Generated notes carry deterministic ids
+ * (`rh.<track hash>.<voice>.<n>`), so the same rows always produce the same
+ * score and `diffScores` sees only real changes.
+ */
+import { isDrumInstrument, parseDrumVoice, drumVoicePitch } from "./drums.ts";
+import { expandRow, rowSummary, type RhythmRow } from "./euclid.ts";
+import { pitchToMidi } from "./pitch.ts";
+import {
+  SCORE_LIMITS,
+  ScoreValidationError,
+  TrackScore,
+  isSamplerInstrument,
+  samplerVoiceSlots,
+  type Note,
+  type Track,
+} from "./score.ts";
+
+/** MIDI pitch a row's voice plays on `track`, or undefined when unknown. */
+export function rhythmVoicePitch(
+  track: Track,
+  voice: string,
+): number | undefined {
+  const name = voice.trim();
+  if (isSamplerInstrument(track.instrument) && track.sampler) {
+    const slot = samplerVoiceSlots(track.sampler).get(name);
+    if (slot !== undefined) return slot;
+  }
+  if (isDrumInstrument(track.instrument)) {
+    const drum = parseDrumVoice(name);
+    if (drum) return drumVoicePitch(drum);
+  }
+  if (/^\d{1,3}$/.test(name)) {
+    const midi = Number(name);
+    return midi <= 127 ? midi : undefined;
+  }
+  const midi = pitchToMidi(name);
+  return Number.isNaN(midi) ? undefined : midi;
+}
+
+function trackHash(trackId: string): string {
+  let hash = 0x811c9dc5;
+  for (let index = 0; index < trackId.length; index += 1) {
+    hash ^= trackId.charCodeAt(index);
+    hash = Math.imul(hash, 0x01000193);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+function idVoice(voice: string): string {
+  return voice.replace(/[^A-Za-z0-9_#-]/g, "_").slice(0, 32);
+}
+
+/** The notes `row` generates on `track` over the score's loop. */
+export function expandTrackRow(
+  score: TrackScore,
+  track: Track,
+  row: RhythmRow,
+): Note[] {
+  const pitch = rhythmVoicePitch(track, row.voice);
+  if (pitch === undefined)
+    throw new ScoreValidationError(
+      `track ${track.id} has no voice "${row.voice}"`,
+      "invalid-track",
+    );
+  const loopTicks = score.bars * score.beatsPerBar * score.ticksPerBeat;
+  const prefix = `rh.${trackHash(track.id)}.${idVoice(row.voice)}.`;
+  return expandRow(row, { ticksPerBeat: score.ticksPerBeat, loopTicks }).map(
+    (hit, index) => ({
+      id: `${prefix}${index}`,
+      trackId: track.id,
+      startTick: hit.startTick,
+      durationTicks: Math.min(hit.durationTicks, SCORE_LIMITS.maxTick),
+      pitch,
+      velocity: hit.velocity,
+    }),
+  );
+}
+
+/** Pitches the rows own on `track` (unresolvable voices are skipped). */
+function ownedPitches(track: Track, rows: readonly RhythmRow[]): Set<number> {
+  const pitches = new Set<number>();
+  for (const row of rows) {
+    const pitch = rhythmVoicePitch(track, row.voice);
+    if (pitch !== undefined) pitches.add(pitch);
+  }
+  return pitches;
+}
+
+/**
+ * The score with `trackId`'s rows replaced by `rows` (empty removes them)
+ * and the lanes of the old and new rows regenerated. Throws
+ * `ScoreValidationError` for an unknown track or voice, or past the note
+ * limit.
+ */
+export function withTrackRhythm(
+  score: TrackScore,
+  trackId: string,
+  rows: readonly RhythmRow[],
+): TrackScore {
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track)
+    throw new ScoreValidationError(`no track ${trackId}`, "invalid-track");
+  const nextTrack: Track = { ...track };
+  const tracks = score.tracks.map((candidate) =>
+    candidate.id === trackId
+      ? { ...candidate, rhythm: rows.length > 0 ? rows : null }
+      : candidate,
+  );
+  const cleared = ownedPitches(track, [...(track.rhythm ?? []), ...rows]);
+  const generated = rows.flatMap((row) =>
+    expandTrackRow(score, nextTrack, row),
+  );
+  const notes = [
+    ...score.notes.filter(
+      (note) => note.trackId !== trackId || !cleared.has(note.pitch),
+    ),
+    ...generated,
+  ];
+  if (notes.length > SCORE_LIMITS.maxNotes)
+    throw new ScoreValidationError(
+      `score cannot contain more than ${SCORE_LIMITS.maxNotes} notes`,
+      "invalid-score",
+    );
+  return new TrackScore({ ...score.toJSON(), tracks, notes });
+}
+
+/** Adds or replaces the row for `row.voice` on the track. */
+export function setRhythmRow(
+  score: TrackScore,
+  trackId: string,
+  row: RhythmRow,
+): TrackScore {
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  const current = track?.rhythm ?? [];
+  const index = current.findIndex((existing) => existing.voice === row.voice);
+  const rows =
+    index < 0
+      ? [...current, row]
+      : current.map((existing, at) => (at === index ? row : existing));
+  return withTrackRhythm(score, trackId, rows);
+}
+
+/**
+ * Drops the row for `voice`. With `keepNotes` its generated notes stay as
+ * plain notes (the row is "frozen"); otherwise the lane is cleared.
+ */
+export function removeRhythmRow(
+  score: TrackScore,
+  trackId: string,
+  voice: string,
+  keepNotes = false,
+): TrackScore {
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  const current = track?.rhythm ?? [];
+  const rows = current.filter((row) => row.voice !== voice);
+  if (rows.length === current.length) return score;
+  if (!keepNotes) return withTrackRhythm(score, trackId, rows);
+  return new TrackScore({
+    ...score.toJSON(),
+    tracks: score.tracks.map((candidate) =>
+      candidate.id === trackId
+        ? { ...candidate, rhythm: rows.length > 0 ? rows : null }
+        : candidate,
+    ),
+  });
+}
+
+/**
+ * Every track's rows regenerated for the current loop length (after a
+ * `bars` change, or for a score fresh from `song.ts`). Returns `score`
+ * itself when nothing changes.
+ */
+export function refreshRhythm(score: TrackScore): TrackScore {
+  let next = score;
+  for (const track of score.tracks)
+    if (track.rhythm && !rhythmInSync(next, track.id))
+      next = withTrackRhythm(next, track.id, track.rhythm);
+  return next;
+}
+
+/** True when the track's owned lanes hold exactly what its rows generate. */
+export function rhythmInSync(score: TrackScore, trackId: string): boolean {
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track?.rhythm) return true;
+  let expected: Note[];
+  try {
+    expected = track.rhythm.flatMap((row) => expandTrackRow(score, track, row));
+  } catch {
+    return false;
+  }
+  const owned = ownedPitches(track, track.rhythm);
+  const actual = score.notes.filter(
+    (note) => note.trackId === trackId && owned.has(note.pitch),
+  );
+  return sameNotes(expected, actual);
+}
+
+/** True when `row`'s lane on the track holds exactly what the row generates. */
+export function rowInSync(
+  score: TrackScore,
+  track: Track,
+  row: RhythmRow,
+): boolean {
+  const pitch = rhythmVoicePitch(track, row.voice);
+  if (pitch === undefined) return false;
+  let expected: Note[];
+  try {
+    expected = expandTrackRow(score, track, row);
+  } catch {
+    return false;
+  }
+  const actual = score.notes.filter(
+    (note) => note.trackId === track.id && note.pitch === pitch,
+  );
+  return sameNotes(expected, actual);
+}
+
+function sameNotes(
+  expected: readonly Note[],
+  actual: readonly Note[],
+): boolean {
+  if (actual.length !== expected.length) return false;
+  const key = (note: Note) =>
+    `${note.pitch}|${note.startTick}|${note.durationTicks}|${note.velocity}`;
+  const want = new Map<string, number>();
+  for (const note of expected)
+    want.set(key(note), (want.get(key(note)) ?? 0) + 1);
+  for (const note of actual) {
+    const left = want.get(key(note));
+    if (!left) return false;
+    want.set(key(note), left - 1);
+  }
+  return true;
+}
+
+/**
+ * Keeps rows and their lanes consistent after an arbitrary edit from
+ * `previous` to `next`: when the loop grid changed (bars, meter, ticks per
+ * beat) every row regenerates; otherwise a row whose lane was hand-edited
+ * is frozen (dropped, its notes kept as plain notes). Returns `next` itself
+ * when nothing needs to change.
+ */
+export function reconcileRhythm(
+  previous: TrackScore,
+  next: TrackScore,
+): TrackScore {
+  const regridded =
+    previous.bars !== next.bars ||
+    previous.beatsPerBar !== next.beatsPerBar ||
+    previous.ticksPerBeat !== next.ticksPerBeat;
+  let out = next;
+  for (const track of next.tracks) {
+    if (!track.rhythm) continue;
+    if (regridded) {
+      if (!rhythmInSync(out, track.id))
+        out = withTrackRhythm(out, track.id, track.rhythm);
+      continue;
+    }
+    const current = out.tracks.find((candidate) => candidate.id === track.id)!;
+    const kept = track.rhythm.filter((row) => rowInSync(out, current, row));
+    if (kept.length !== track.rhythm.length)
+      out = new TrackScore({
+        ...out.toJSON(),
+        tracks: out.tracks.map((candidate) =>
+          candidate.id === track.id
+            ? { ...candidate, rhythm: kept.length > 0 ? kept : null }
+            : candidate,
+        ),
+      });
+  }
+  return out;
+}
+
+/** `kick E(4,16) · hat E(7,16,r2)` for a status line. */
+export function rhythmSummary(track: Track): string {
+  return (track.rhythm ?? [])
+    .map((row) => `${row.voice} ${rowSummary(row)}`)
+    .join(" · ");
+}