@hraness/dawg 0.3.0 → 0.4.1

package/src/tui/menu.ts

@@ -8,15 +8,84 @@
  *
  * Rendering reuses the TUI's picker overlay: `view()` returns a picker.
  */
+import { commandParam, sketchFor } from "./sketch.ts";
+import { HINTS } from "../../tui/grammar.ts";
+import { auditionKey, isStageable, type AuditionKey } from "./audition.ts";
 import {
-  AUTOMATION_LANES,
+  AUTOMATION_PARAMETERS,
+  automationPoints,
+  automationRange,
+  REVERB_IR_BUILTINS,
+  SAMPLE_UNITS,
   SCORE_LIMITS,
+  isTrackAutomationParameter,
+  WARP_MODES,
+  WAVETABLE_PARAMS,
+  isWavetableInstrument,
+  wavetableOf,
+  type WavetableParam,
   type AutomationParameter,
   type Track,
+  type TrackAutomationParameter,
   type TrackScore,
 } from "../../core/score.ts";
+import {
+  CORE_EFFECTS,
+  EFFECT_NAMES,
+  FX_LANES,
+  effectPresetNames,
+  effectSpec,
+  type EffectName,
+  type FxLane,
+  type NumberParam,
+  type ParamSpec,
+} from "../../core/fx.ts";
+import { effectValues } from "../commands/fx.ts";
+import { SAMPLE_CONTROLS, type SampleControl } from "../commands/sample.ts";
 import { AVAILABLE_INSTRUMENTS } from "../audio/wav.ts";
+import {
+  DEFAULT_KITS,
+  GM_INSTRUMENTS,
+  PACK_CATALOG,
+  STRUDEL_BANK_ALIASES,
+} from "../audio/packs.ts";
+import { kitCatalog } from "../audio/kits.ts";
+import { SYNTH_KIT_NAMES } from "../../core/kits.ts";
+import { DRUM_PATTERNS } from "../../core/sdk/v1.ts";
+import { isDrumInstrument } from "../../core/drums.ts";
+import {
+  SYNTH_GROUPS,
+  SYNTH_PARAMS,
+  SYNTH_PRESETS,
+  SYNTH_SIMPLE,
+  normalizeSynth,
+} from "../../core/synth.ts";
 import type { PickerItem } from "../../tui/app.ts";
+import { BUILTIN_TABLES, BUILTIN_TABLE_NAMES } from "../audio/wavetable.ts";
+import {
+  UZU_WAVETABLES,
+  WAVETABLE_PACK,
+  describeTable,
+  listLocalWavetables,
+} from "../commands/wavetable.ts";
+import {
+  BASS_MODES,
+  CHORD_PATTERNS,
+  MAX_VOICING_STEP,
+  MODE_NAMES,
+  PERFORM_MODES,
+  PROGRESSION_PRESETS,
+  PROGRESSION_STYLES,
+  SPREADS,
+  keyName,
+  parseKey,
+} from "../../core/chords.ts";
+import {
+  ARP_RATES,
+  CHORD_MODES,
+  defaultChordSettings,
+  type ChordSettings,
+} from "./play-chords.ts";
 
 /** What the menu needs to know beyond the score. */
 export type MenuContext = Readonly<{
@@ -27,6 +96,36 @@ export type MenuContext = Readonly<{
   grids: readonly string[];
   clickOn: boolean;
   countInBars: number;
+  /** Play mode's chord settings (defaults when absent). */
+  chords?: ChordSettings;
+  /** Project root, for the project's own wavetables (none when absent). */
+  projectRoot?: string;
+  /**
+   * The audition loop (src/tui/audition.ts), when the window hosts one.
+   * `score` above is then the staged score; changed rows show the
+   * committed value beside the staged one.
+   */
+  audition?: MenuAudition;
+}>;
+
+/** What the menu needs from the audition controller. */
+export type MenuAudition = Readonly<{
+  looping: boolean;
+  /** Edits are staged (an Enter keeps them, Esc reverts them). */
+  dirty: boolean;
+  /** The committed score, for `staged ← committed` on changed rows. */
+  committed: TrackScore;
+  /** The footer while auditioning. */
+  hint: string;
+  /** `♪ solo · B staged 2 · 42 ms`, shown in the title. */
+  status?: string | undefined;
+  /**
+   * Which commands stage while auditioning (default `isStageable`); the
+   * chord settings screen also stages `/chords …` and `key …`.
+   */
+  stageable?: (command: string) => boolean;
+  /** The committed chord settings, for `staged ← committed` on Chords rows. */
+  committedChords?: ChordSettings;
 }>;
 
 type NumberField = Readonly<{
@@ -44,9 +143,11 @@ type NumberField = Readonly<{
   off?: string;
   /** Starting value for a nudge while off. */
   start?: number;
+  /** The command `x` runs to put the value back to its default. */
+  reset?: string;
 }>;
 
-export type MenuNode =
+export type MenuNode = (
   | Readonly<{
       kind: "menu";
       id: string;
@@ -87,13 +188,33 @@ export type MenuNode =
       beat: number;
       value: number;
     }>
-  | Readonly<{ kind: "info"; label: string; value: string }>;
+  | Readonly<{ kind: "info"; label: string; value: string }>
+) &
+  Readonly<{
+    /** One line on what the focused row does, shown under the list. */
+    help?: string;
+  }>;
 
 /** What a key did; `run` carries the command to execute. */
 export type MenuResult =
   | { type: "handled" }
   | { type: "close" }
   | { type: "run"; command: string }
+  /** Space (loop), `a` (A/B) or `c` (context) for the audition loop. */
+  | { type: "audition"; key: AuditionKey }
+  /** Commit the staged edits as one operation. */
+  | { type: "keep" }
+  /** Drop the staged edits. */
+  | { type: "revert" }
+  /**
+   * The cursor moved in a list while the loop plays: audition `command`
+   * in place of the previous hover of `key` (one per list).
+   */
+  | { type: "hover"; command: string; key: string }
+  /** Left a list without choosing: drop its hover (`key`). */
+  | { type: "unhover"; key: string }
+  /** Chose a list item while the loop plays: stage it for good. */
+  | { type: "choose"; command: string; key: string }
   | { type: "pass" };
 
 export type MenuView = Readonly<{
@@ -101,6 +222,8 @@ export type MenuView = Readonly<{
   items: PickerItem[];
   index: number;
   hint: string;
+  /** What the focused row does, and the prompt command it stands for. */
+  note: string;
 }>;
 
 // ── formatting and steps ──────────────────────────────────────────────
@@ -137,8 +260,8 @@ function clamp(value: number, min: number, max: number): number {
   return Math.min(max, Math.max(min, value));
 }
 
-const LANE_STEP: Readonly<
-  Record<AutomationParameter, (value: number, direction: 1 | -1) => number>
+const TRACK_LANE_STEP: Readonly<
+  Record<TrackAutomationParameter, (value: number, direction: 1 | -1) => number>
 > = {
   volume: linear(0.05, 0, SCORE_LIMITS.maxVolume),
   pan: linear(0.1, -1, 1),
@@ -146,20 +269,65 @@ const LANE_STEP: Readonly<
   resonance: linear(0.05, 0, SCORE_LIMITS.maxFilterResonance),
   "delay-feedback": linear(0.05, 0, SCORE_LIMITS.maxDelayFeedback),
   "delay-mix": linear(0.05, 0, SCORE_LIMITS.maxDelayMix),
+  wt: linear(0.05, 0, 1),
 };
 
-const LANE_LABEL: Readonly<Record<AutomationParameter, string>> = {
+const TRACK_LANE_LABEL: Readonly<Record<TrackAutomationParameter, string>> = {
   volume: "volume",
   pan: "pan",
   filter: "filter cutoff (Hz)",
   resonance: "filter resonance",
   "delay-feedback": "delay feedback",
   "delay-mix": "delay mix",
+  wt: "wavetable position",
 };
 
+const FX_LANE_INFO = new Map(FX_LANES.map((entry) => [entry.lane, entry]));
+
+/** Nudge for a number spec: linear by its step, or a sixth of an octave. */
+function specStep(
+  spec: NumberParam,
+): (value: number, direction: 1 | -1) => number {
+  if (spec.step === "log")
+    return (value, direction) => {
+      const next = Math.max(value, 1) * 2 ** (direction / 6);
+      return clamp(
+        next >= 100 ? Math.round(next) : Math.round(next * 10) / 10,
+        spec.min,
+        spec.max,
+      );
+    };
+  const size = spec.step;
+  return (value, direction) => {
+    const next = Math.round((value + size * direction) / size) * size;
+    return clamp(Number(next.toFixed(6)), spec.min, spec.max);
+  };
+}
+
+function laneStep(
+  lane: AutomationParameter,
+): (value: number, direction: 1 | -1) => number {
+  if (isTrackAutomationParameter(lane)) return TRACK_LANE_STEP[lane];
+  const info = FX_LANE_INFO.get(lane);
+  return info ? specStep(info.spec) : linear(0.05, 0, 1);
+}
+
+function laneLabel(lane: AutomationParameter): string {
+  if (isTrackAutomationParameter(lane)) return TRACK_LANE_LABEL[lane];
+  const info = FX_LANE_INFO.get(lane);
+  if (!info) return lane;
+  const unit = info.spec.unit ? ` (${info.spec.unit})` : "";
+  const owner =
+    info.effect === "synth" ? "synth" : effectSpec(info.effect).label;
+  return `${owner} ${info.param}${unit}`;
+}
+
 /** `volume 0.8`, `pan -0.3`: the command that sets a lane's static value. */
 function laneFormat(lane: AutomationParameter, value: number): string {
-  return lane === "filter" ? `${Math.round(value)}` : num(value);
+  if (lane === "filter") return `${Math.round(value)}`;
+  const info = FX_LANE_INFO.get(lane as FxLane);
+  if (info?.spec.step === "log" && value >= 100) return `${Math.round(value)}`;
+  return num(value);
 }
 
 // ── the tree ──────────────────────────────────────────────────────────
@@ -171,60 +339,275 @@ function focused(context: MenuContext): Track | undefined {
 export function rootNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   const name = track?.name ?? context.trackId;
-  const effects = [
-    track?.filter ? "filter" : undefined,
-    track?.delay ? "delay" : undefined,
-    track?.reverb ? "reverb" : undefined,
-  ].filter(Boolean);
-  const automated = (Object.keys(AUTOMATION_LANES) as AutomationParameter[])
-    .filter((lane) => (track?.[AUTOMATION_LANES[lane].field]?.length ?? 0) > 0)
-    .join(" ");
+  const effects = EFFECT_NAMES.filter((effect) => effectValues(track, effect));
+  const automated = AUTOMATION_PARAMETERS.filter(
+    (lane) => automationPoints(track, lane).length > 0,
+  ).length;
+  const tracks = context.score.tracks.length;
   return [
     {
       kind: "menu",
-      id: "track",
-      label: "Track",
+      id: "sound",
+      label: "Sound",
       detail: `${name} · ${track?.instrument ?? "?"}`,
-      build: trackNodes,
-    },
-    {
-      kind: "menu",
-      id: "parameters",
-      label: "Parameters",
-      detail: `${track?.instrument ?? "?"}`,
-      build: parameterNodes,
+      help: "the focused track's instrument and its voice",
+      build: soundSectionNodes,
     },
     {
       kind: "menu",
       id: "effects",
       label: "Effects",
-      detail: effects.length ? effects.join(" · ") : "none",
+      detail: effects.length ? effects.join(" · ") : "none on",
+      help: "filter, delay, reverb and more on the focused track",
       build: effectNodes,
     },
     {
       kind: "menu",
-      id: "automation",
-      label: "Automation",
-      detail: automated || "no lanes",
-      build: automationNodes,
+      id: "rhythm",
+      label: "Rhythm",
+      detail: "euclid editor · patterns · kits",
+      help: "drum hits per voice, ready-made grooves and drum kits",
+      build: rhythmNodes,
+    },
+    {
+      kind: "menu",
+      id: "chords",
+      label: "Chords",
+      detail: chordsDetail(context),
+      help: "song key and how chords play in play mode (Ctrl-P)",
+      build: chordNodes,
     },
     {
       kind: "menu",
       id: "mix",
-      label: "Mix",
-      detail: `${context.score.tracks.length} track${context.score.tracks.length === 1 ? "" : "s"}`,
-      build: mixNodes,
+      label: "Mix & automation",
+      detail: `${tracks} track${tracks === 1 ? "" : "s"} · ${automated} lane${automated === 1 ? "" : "s"} moving`,
+      help: "volume, pan, mute and solo per track; values that change over time",
+      build: mixSectionNodes,
     },
     {
       kind: "menu",
-      id: "transport",
-      label: "Transport",
-      detail: `${num(context.score.tempoBpm)} BPM · ${context.score.beatsPerBar}/4 · ${context.score.bars} bars · grid ${context.grid}`,
+      id: "project",
+      label: "Project",
+      detail: `${num(context.score.tempoBpm)} BPM · ${context.score.beatsPerBar}/4 · ${context.score.bars} bars`,
+      help: "tempo, meter, loop length, play, click and count-in",
       build: transportNodes,
     },
   ];
 }
 
+/** Old section names still open the menu where that content now lives. */
+const SECTION_ALIASES: Readonly<Record<string, readonly string[]>> = {
+  sound: ["sound"],
+  parameters: ["sound"],
+  sounds: ["sound", "browse"],
+  effects: ["effects"],
+  rhythm: ["rhythm"],
+  chords: ["chords"],
+  mix: ["mix"],
+  track: ["mix"],
+  automation: ["mix", "automation"],
+  project: ["project"],
+  transport: ["project"],
+};
+
+/** Sound: instrument and voice first, then the sound browser. */
+function soundSectionNodes(context: MenuContext): MenuNode[] {
+  return [
+    ...parameterNodes(context),
+    {
+      kind: "menu",
+      id: "browse",
+      label: "browse sounds",
+      detail: soundsDetail(focused(context)),
+      help: "instruments, wavetables, sample packs",
+      build: soundNodes,
+    },
+  ];
+}
+
+/** Rhythm: the euclid editor, then grooves and kits. */
+function rhythmNodes(): MenuNode[] {
+  return [
+    {
+      kind: "action",
+      label: "euclid editor",
+      command: "/euclid",
+      help: "hits, steps and rotation per drum voice",
+    },
+    patternsMenu(),
+    kitsMenu(),
+  ];
+}
+
+/** Mix & automation: this track, every track, then automation lanes. */
+function mixSectionNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  const automated = AUTOMATION_PARAMETERS.filter(
+    (lane) => automationPoints(track, lane).length > 0,
+  ).join(" ");
+  return [
+    ...trackNodes(context),
+    {
+      kind: "menu",
+      id: "tracks",
+      label: "all tracks",
+      detail: `${context.score.tracks.length} · focus another track`,
+      help: "pick a track to edit; ● is the focused one",
+      build: mixNodes,
+    },
+    {
+      kind: "menu",
+      id: "automation",
+      label: "automation",
+      detail: automated || "no lanes yet",
+      help: "points that move a value over the loop",
+      build: automationNodes,
+    },
+  ];
+}
+
+function chordsDetail(context: MenuContext): string {
+  const chords = context.chords ?? defaultChordSettings();
+  const key = parseKey(context.score.key ?? undefined);
+  return `${chords.mode} · ${key ? keyName(key) : "no key"} · ${chords.perform}`;
+}
+
+/** Play mode's chord settings and the song key (`/chords …`, `key …`). */
+function chordNodes(context: MenuContext): MenuNode[] {
+  const chords = context.chords ?? defaultChordSettings();
+  const key = parseKey(context.score.key ?? undefined);
+  const tonic = key ? keyName(key).split(" ")[0]! : "C";
+  const mode = key?.mode ?? "major";
+  const presets = PROGRESSION_PRESETS.map((preset) => preset.name);
+  return [
+    {
+      kind: "choice",
+      label: "mode",
+      help: "auto: keys play chords in the song key · manual: latch 1–8 · off",
+      value: chords.mode,
+      options: CHORD_MODES,
+      command: (option) => `/chords ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "key tonic",
+      help: "the song key; auto chord mode follows it",
+      value: tonic,
+      options: TONICS,
+      command: (option) => `key ${option} ${mode}`,
+    },
+    {
+      kind: "choice",
+      label: "key mode",
+      help: "major, minor or a church mode",
+      value: mode,
+      options: MODE_NAMES,
+      command: (option) => `key ${tonic} ${option}`,
+    },
+    {
+      kind: "number",
+      label: "voicing",
+      help: "inversion steps up or down (play mode: - =)",
+      value: chords.inversion,
+      min: -MAX_VOICING_STEP,
+      max: MAX_VOICING_STEP,
+      step: linear(1, -MAX_VOICING_STEP, MAX_VOICING_STEP),
+      format: (value) => (value > 0 ? `+${value}` : String(value)),
+      command: (value) => `/chords voicing ${Math.round(value)}`,
+    },
+    {
+      kind: "choice",
+      label: "spread",
+      help: "close, open or wide chord voicing",
+      value: chords.spread,
+      options: SPREADS,
+      command: (option) => `/chords spread ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "bass",
+      help: "what the left hand plays under the chord (play mode: b)",
+      value: chords.bass,
+      options: BASS_MODES,
+      command: (option) => `/chords bass ${option}`,
+    },
+    {
+      kind: "toggle",
+      label: "sevenths",
+      help: "auto mode plays sevenths instead of triads",
+      value: chords.sevenths,
+      command: (on) => `/chords sevenths ${on ? "on" : "off"}`,
+    },
+    {
+      kind: "choice",
+      label: "perform",
+      help: "block, strum, arpeggio or a rhythm pattern (play mode: 9)",
+      value: chords.perform,
+      options: PERFORM_MODES,
+      command: (option) => `/chords perform ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "pattern",
+      help: "the rhythm used when perform is pattern",
+      value: chords.pattern,
+      options: CHORD_PATTERNS.map((pattern) => pattern.name),
+      command: (option) => `/chords pattern ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "arp rate",
+      help: "arpeggio step length",
+      value: chords.rate,
+      options: ARP_RATES,
+      command: (option) => `/chords rate ${option}`,
+    },
+    {
+      kind: "number",
+      label: "arp octaves",
+      help: "how many octaves an arpeggio climbs",
+      value: chords.octaves,
+      min: 1,
+      max: 4,
+      step: linear(1, 1, 4),
+      format: (value) => `${num(value)} oct`,
+      command: (value) => `/chords octaves ${Math.round(value)}`,
+    },
+    {
+      kind: "choice",
+      label: "progression",
+      help: "a preset the n key walks through",
+      value: chords.preset,
+      options: ["none", ...presets],
+      command: (option) => `/chords preset ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "style",
+      help: "the style n suggests next chords in",
+      value: chords.style,
+      options: PROGRESSION_STYLES,
+      command: (option) => `/chords style ${option}`,
+    },
+  ];
+}
+
+const TONICS = [
+  "C",
+  "Db",
+  "D",
+  "Eb",
+  "E",
+  "F",
+  "F#",
+  "G",
+  "Ab",
+  "A",
+  "Bb",
+  "B",
+] as const;
+
 function trackNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   if (!track)
@@ -238,19 +621,21 @@ function trackNodes(context: MenuContext): MenuNode[] {
       command: (text) =>
         text.trim() ? `track name ${text.trim()}` : undefined,
       example: `track name ${track.name}`,
+      help: "rename the focused track",
     },
-    instrumentNode(track),
     {
       kind: "toggle",
       label: "mute",
       value: track.muted,
       command: (on) => (on ? "mute" : "unmute"),
+      help: "silence this track",
     },
     {
       kind: "toggle",
       label: "solo",
       value: track.solo === true,
       command: (on) => (on ? "solo" : "unsolo"),
+      help: "hear only soloed tracks",
     },
     volumeNode(track),
     panNode(track),
@@ -266,6 +651,7 @@ function instrumentNode(track: Track): MenuNode {
     value: track.instrument,
     options,
     command: (option) => `instrument ${option}`,
+    help: "the sound source; drums use kit",
   };
 }
 
@@ -276,9 +662,12 @@ function volumeNode(track: Track): MenuNode {
     value: track.volume,
     min: 0,
     max: SCORE_LIMITS.maxVolume,
-    step: LANE_STEP.volume,
-    format: num,
+    step: TRACK_LANE_STEP.volume,
+    format: (value) =>
+      `${num(value)} · ${value > 0 ? `${(20 * Math.log10(value)).toFixed(1)} dB` : "silent"}`,
     command: (value) => `volume ${num(value)}`,
+    reset: "volume 1",
+    help: "track gain; 1 is unity (0 dB) · x resets",
   };
 }
 
@@ -289,9 +678,14 @@ function panNode(track: Track): MenuNode {
     value: track.pan,
     min: -1,
     max: 1,
-    step: LANE_STEP.pan,
-    format: num,
+    step: TRACK_LANE_STEP.pan,
+    format: (value) =>
+      value === 0
+        ? "center"
+        : `${num(Math.abs(value))} ${value < 0 ? "L" : "R"}`,
     command: (value) => `pan ${num(value)}`,
+    reset: "pan 0",
+    help: "-1 left … 1 right · x centres",
   };
 }
 
@@ -299,6 +693,9 @@ function parameterNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   if (!track) return [];
   const nodes: MenuNode[] = [instrumentNode(track)];
+  // A wavetable track also has the synth voice's envelope, filters and FM.
+  if (isWavetableInstrument(track.instrument))
+    nodes.push(...wavetableNodes(track, context.projectRoot));
   if (track.sampler) {
     nodes.push({
       kind: "info",
@@ -312,9 +709,12 @@ function parameterNodes(context: MenuContext): MenuNode[] {
         ref.speed !== undefined ? `speed ${num(ref.speed)}` : "",
       ].filter(Boolean);
       nodes.push({
-        kind: "info",
+        kind: "menu",
+        id: `sample:${voice}`,
         label: voice,
-        value: [ref.src.split("/").at(-1), ...extras].join(" · "),
+        detail: [ref.src.split("/").at(-1), ...extras].join(" · "),
+        help: "this voice's sample controls (Strudel names)",
+        build: (context) => sampleVoiceNodes(context, voice),
       });
     }
     nodes.push({
@@ -322,188 +722,546 @@ function parameterNodes(context: MenuContext): MenuNode[] {
       label: "add a voice",
       value: "/sample <path> [as <voice>]",
     });
-  } else {
+  } else if (!isDrumInstrument(track.instrument)) {
+    nodes.push(...synthNodes(track, SYNTH_SIMPLE));
     nodes.push({
-      kind: "info",
-      label: "voice",
-      value:
-        "the synth has no knobs beyond the instrument; shape it with Effects",
+      kind: "menu",
+      id: "synth:advanced",
+      label: "advanced",
+      detail: `all ${Object.keys(SYNTH_PARAMS).length} params`,
+      help: "every voice parameter, grouped, under its Strudel name",
+      build: synthAdvancedNodes,
     });
+    if (track.synth)
+      nodes.push({
+        kind: "action",
+        label: "reset to defaults",
+        command: "synth reset",
+        help: "clear every voice setting on this track",
+      });
   }
   return nodes;
 }
 
-function effectNodes(context: MenuContext): MenuNode[] {
-  const track = focused(context);
-  if (!track) return [];
-  const filter = track.filter;
-  const delay = track.delay;
-  const reverb = track.reverb;
-  return [
+/** Number rows for `/sample set`: [control, min, max, step, default]. */
+const SAMPLE_NUMBER_ROWS: readonly (readonly [
+  SampleControl,
+  number,
+  number,
+  number,
+  number,
+])[] = [
+  ["begin", 0, 0.99, 0.01, 0],
+  ["end", 0.01, 1, 0.01, 1],
+  ["gain", 0, SCORE_LIMITS.maxSampleGain, 0.05, 1],
+  ["speed", -SCORE_LIMITS.maxSampleSpeed, SCORE_LIMITS.maxSampleSpeed, 0.05, 1],
+  ["loopBegin", 0, 0.99, 0.01, 0],
+  ["loopEnd", 0.01, 1, 0.01, 1],
+  ["clip", 0.05, SCORE_LIMITS.maxSampleClip, 0.05, 1],
+  [
+    "accelerate",
+    -SCORE_LIMITS.maxSampleAccelerate,
+    SCORE_LIMITS.maxSampleAccelerate,
+    0.1,
+    0,
+  ],
+  ["squiz", 1, SCORE_LIMITS.maxSampleSquiz, 0.5, 1],
+];
+
+/** One sampler voice: every sample control, run through `/sample set`. */
+function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
+  const track = context.score.tracks.find(
+    (item) => item.id === context.trackId,
+  );
+  const ref = track?.sampler?.voices[voice];
+  if (!ref) return [];
+  const set = (rest: string) => `/sample set ${voice} ${rest}`;
+  const nodes: MenuNode[] = [{ kind: "info", label: "file", value: ref.src }];
+  for (const [control, min, max, step, start] of SAMPLE_NUMBER_ROWS) {
+    const current = (ref as Record<string, unknown>)[control];
+    nodes.push({
+      kind: "number",
+      label: control,
+      value: typeof current === "number" ? current : undefined,
+      start,
+      off: num(start),
+      min,
+      max,
+      step:
+        control === "speed"
+          ? (value, direction) => {
+              // Speed 0 is invalid: step over it.
+              const next = linear(step, min, max)(value, direction);
+              return next === 0 ? step * direction : next;
+            }
+          : linear(step, min, max),
+      format: num,
+      command: (value) => set(`${control} ${num(value)}`),
+      reset: set(`${control} off`),
+      help: SAMPLE_CONTROLS[control],
+    });
+  }
+  nodes.push(
     {
-      kind: "menu",
-      id: "filter",
-      label: "Filter",
-      detail: filter
-        ? `${Math.round(filter.cutoff)} Hz · res ${num(filter.resonance)}`
-        : "off",
-      build: () => [
-        {
-          kind: "toggle",
-          label: "on",
-          value: filter !== undefined,
-          command: (on) => (on ? "filter 2000 0.2" : "filter off"),
-        },
-        {
-          kind: "number",
-          label: "cutoff Hz",
-          value: filter?.cutoff,
-          start: 2000,
-          off: "off",
-          min: SCORE_LIMITS.minFilterCutoff,
-          max: SCORE_LIMITS.maxFilterCutoff,
-          step: cutoffStep,
-          format: (value) => `${Math.round(value)}`,
-          command: (value) =>
-            `filter ${Math.round(value)} ${num(filter?.resonance ?? 0)}`,
-        },
-        {
-          kind: "number",
-          label: "resonance",
-          value: filter?.resonance,
-          start: 0.2,
-          off: "off",
-          min: 0,
-          max: SCORE_LIMITS.maxFilterResonance,
-          step: LANE_STEP.resonance,
-          format: num,
-          command: (value) =>
-            `filter ${Math.round(filter?.cutoff ?? 2000)} ${num(value)}`,
-        },
-      ],
+      kind: "choice",
+      label: "unit",
+      value: ref.unit ?? "r",
+      options: SAMPLE_UNITS,
+      command: (option) => set(`unit ${option}`),
+      help: SAMPLE_CONTROLS.unit,
     },
     {
+      kind: "toggle",
+      label: "loop",
+      value: ref.loop === true,
+      command: (on) => set(`loop ${on ? "on" : "off"}`),
+      help: SAMPLE_CONTROLS.loop,
+    },
+    {
+      kind: "toggle",
+      label: "fit",
+      value: ref.fit === true,
+      command: (on) => set(`fit ${on ? "on" : "off"}`),
+      help: SAMPLE_CONTROLS.fit,
+    },
+    {
+      kind: "info",
+      label: "cut / loopAt",
+      value: `/sample set ${voice} cut hats · loopAt 2`,
+    },
+  );
+  return nodes;
+}
+
+/** Synth preset first, then one row per parameter. */
+/** The preset this track's voice still matches exactly, if any. */
+function matchingSynthPreset(track: Track): string | undefined {
+  if (!track.synth) return undefined;
+  const current = JSON.stringify(track.synth);
+  return Object.entries(SYNTH_PRESETS).find(
+    ([, preset]) =>
+      preset.instrument === track.instrument &&
+      JSON.stringify(normalizeSynth(preset.synth)) === current,
+  )?.[0];
+}
+
+function synthNodes(track: Track, keys: readonly string[]): MenuNode[] {
+  const nodes: MenuNode[] = [];
+  if (keys === SYNTH_SIMPLE)
+    nodes.push({
+      kind: "choice",
+      label: "preset",
+      value: matchingSynthPreset(track) ?? "—",
+      options: Object.keys(SYNTH_PRESETS),
+      command: (preset) => `synth preset ${preset}`,
+      help: "a starting voice; every value stays editable",
+    });
+  for (const key of keys)
+    nodes.push(synthParamNode(track, key, keys !== SYNTH_SIMPLE));
+  return nodes;
+}
+
+function synthParamNode(track: Track, key: string, named: boolean): MenuNode {
+  const param = SYNTH_PARAMS[key]!;
+  const current = track.synth?.[key];
+  const aliases = (param.strudel ?? []).filter((name) => name !== key);
+  const label = named
+    ? aliases.length
+      ? `${key} (${aliases.join("/")})`
+      : key
+    : (SYNTH_LABEL[key] ?? key);
+  if (param.kind === "number")
+    return {
+      kind: "number",
+      label,
+      value: typeof current === "number" ? current : undefined,
+      start: param.default,
+      // An unset filter cutoff means no filter, not the default cutoff.
+      off: /^(lpf|hpf|bpf)$/.test(key)
+        ? "off"
+        : withUnit(formatParam(param, param.default), param.unit),
+      min: param.min,
+      max: param.max,
+      step: specStep(param),
+      format: (value) => withUnit(formatParam(param, value), param.unit),
+      command: (value) => `synth ${key} ${formatParam(param, value)}`,
+      reset: `synth ${key} off`,
+      help: param.doc,
+    };
+  if (param.kind === "enum")
+    return {
+      kind: "choice",
+      label,
+      value: typeof current === "string" ? current : param.default,
+      options: param.values,
+      command: (option) => `synth ${key} ${option}`,
+      help: param.doc,
+    };
+  return {
+    kind: "toggle",
+    label,
+    value: typeof current === "boolean" ? current : param.default,
+    command: (on) => `synth ${key} ${on ? "on" : "off"}`,
+    help: param.doc,
+  };
+}
+
+/** Plain names for the simple synth rows; the note shows the command name. */
+const SYNTH_LABEL: Readonly<Record<string, string>> = {
+  lpf: "filter cutoff",
+  lpq: "filter res",
+  lpenv: "filter env",
+  vib: "vibrato",
+  fm: "FM amount",
+};
+
+/** Every synth parameter, grouped (amplitude, oscillator, FM 1..8, …). */
+function synthAdvancedNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  if (!track) return [];
+  const nodes: MenuNode[] = SYNTH_GROUPS.map((group) => {
+    const set = group.params.filter((key) => track.synth?.[key] !== undefined);
+    return {
       kind: "menu",
-      id: "delay",
-      label: "Delay",
-      detail: delay
-        ? `${num(delay.beats)} beats · fb ${num(delay.feedback)} · mix ${num(delay.mix)}`
-        : "off",
-      build: () => {
-        const beats = delay?.beats ?? 0.5;
-        const feedback = delay?.feedback ?? 0.3;
-        const mix = delay?.mix ?? 0.35;
-        return [
-          {
-            kind: "toggle",
-            label: "on",
-            value: delay !== undefined,
-            command: (on) => (on ? "delay 0.5 0.3 0.35" : "delay off"),
-          },
-          {
-            kind: "number",
-            label: "time beats",
-            value: delay?.beats,
-            start: 0.5,
-            off: "off",
-            min: SCORE_LIMITS.minDelayBeats,
-            max: SCORE_LIMITS.maxDelayBeats,
-            step: delayStep,
-            format: num,
-            command: (value) =>
-              `delay ${num(value)} ${num(feedback)} ${num(mix)}`,
-          },
-          {
-            kind: "number",
-            label: "feedback",
-            value: delay?.feedback,
-            start: 0.3,
-            off: "off",
-            min: 0,
-            max: SCORE_LIMITS.maxDelayFeedback,
-            step: LANE_STEP["delay-feedback"],
-            format: num,
-            command: (value) => `delay ${num(beats)} ${num(value)} ${num(mix)}`,
-          },
-          {
-            kind: "number",
-            label: "mix",
-            value: delay?.mix,
-            start: 0.35,
-            off: "off",
-            min: 0,
-            max: SCORE_LIMITS.maxDelayMix,
-            step: LANE_STEP["delay-mix"],
-            format: num,
-            command: (value) =>
-              `delay ${num(beats)} ${num(feedback)} ${num(value)}`,
-          },
-        ];
+      id: `synth:${group.id}`,
+      label: group.label,
+      detail: set.length
+        ? set.map((key) => `${key} ${String(track.synth![key])}`).join(" · ")
+        : "defaults",
+      build: (inner) => {
+        const current = focused(inner);
+        return current ? synthNodes(current, group.params) : [];
       },
+    };
+  });
+  const partials = track.synth?.partials;
+  nodes.push({
+    kind: "entry",
+    label: "partials",
+    value: Array.isArray(partials) ? partials.join(" ") : "—",
+    placeholder: "harmonic amplitudes, e.g. 1 0.5 0.33",
+    command: (text) =>
+      text.trim() ? `synth partials ${text.trim()}` : "synth partials off",
+    example: "synth partials 1 0.5 0.33 0.25",
+  });
+  nodes.push({
+    kind: "entry",
+    label: "zzfx array",
+    value: "—",
+    placeholder: "a raw ZzFX array, e.g. ,,129,.01,,.15,2",
+    command: (text) => `synth zzfx ${text.trim()}`,
+    example: "synth zzfx ,,129,.01,,.15,2",
+  });
+  return nodes;
+}
+
+/** Short help for each wavetable parameter row. */
+const WAVETABLE_LABELS: Readonly<Record<WavetableParam, string>> = {
+  wt: "position (wt)",
+  wtenv: "position env amount",
+  wtattack: "position env attack s",
+  wtdecay: "position env decay s",
+  wtsustain: "position env sustain",
+  wtrelease: "position env release s",
+  wtrate: "position LFO Hz",
+  wtdepth: "position LFO depth",
+  warp: "warp",
+  wtphaserand: "phase randomness",
+};
+
+const WAVETABLE_STEP: Readonly<Record<WavetableParam, number>> = {
+  wt: 0.05,
+  wtenv: 0.1,
+  wtattack: 0.01,
+  wtdecay: 0.05,
+  wtsustain: 0.05,
+  wtrelease: 0.05,
+  wtrate: 0.25,
+  wtdepth: 0.05,
+  warp: 0.05,
+  wtphaserand: 0.1,
+};
+
+function wavetableNodes(track: Track, projectRoot?: string): MenuNode[] {
+  const settings = wavetableOf(track);
+  const local = listLocalWavetables(projectRoot);
+  const tables: MenuNode[] = [
+    ...local.map((path): MenuNode => ({
+      kind: "action",
+      label: `${path.split("/").pop()}  project · ${path.split("/")[1]}`,
+      command: `wt ${path}`,
+    })),
+    ...BUILTIN_TABLE_NAMES.map((name): MenuNode => ({
+      kind: "action",
+      label: `${name}  ${BUILTIN_TABLES[name]!.title} · built-in`,
+      command: `wt ${name}`,
+    })),
+    ...Object.entries(UZU_WAVETABLES).map(([set, names]): MenuNode => ({
+      kind: "menu",
+      id: `wt-${set}`,
+      label: set,
+      detail: `${names.length} tables · ${WAVETABLE_PACK}`,
+      build: () =>
+        names.map((name, index): MenuNode => ({
+          kind: "action",
+          label: `${set}:${index}  ${name}`,
+          command: `wt ${set}:${index}`,
+        })),
+    })),
+  ];
+  const nodes: MenuNode[] = [
+    {
+      kind: "menu",
+      id: "wavetables",
+      label: "table",
+      detail: describeTable(settings.table.src),
+      build: () => tables,
     },
+  ];
+  for (const name of Object.keys(WAVETABLE_PARAMS) as WavetableParam[]) {
+    const [min, max, fallback] = WAVETABLE_PARAMS[name];
+    nodes.push({
+      kind: "number",
+      label: WAVETABLE_LABELS[name],
+      value: settings[name] ?? fallback,
+      min,
+      max,
+      step: linear(WAVETABLE_STEP[name], min, max),
+      format: num,
+      command: (value) => `${name} ${num(value)}`,
+      reset: `${name} ${num(fallback)}`,
+    });
+  }
+  nodes.push({
+    kind: "choice",
+    label: "warp mode",
+    value: settings.warpmode ?? "none",
+    options: WARP_MODES,
+    command: (option) => `warpmode ${option}`,
+  });
+  if ((track.wtAutomation?.length ?? 0) > 0)
+    nodes.push({
+      kind: "info",
+      label: "position automation",
+      value: `${track.wtAutomation!.length} points · Automation › wavetable position`,
+    });
+  return nodes;
+}
+
+/** Effects in chain order; each opens on its presets and simple params. */
+function effectNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  if (!track) return [];
+  const node = (effect: EffectName): MenuNode => {
+    const spec = effectSpec(effect);
+    const values = effectValues(track, effect);
+    return {
+      kind: "menu",
+      id: effect,
+      label: spec.label[0]!.toUpperCase() + spec.label.slice(1),
+      detail: values ? effectSummary(effect, values) : "off",
+      help: spec.doc,
+      build: (inner) => effectParamNodes(inner, effect, false),
+    };
+  };
+  const more = EFFECT_NAMES.filter((effect) => !CORE_EFFECTS.includes(effect));
+  const moreOn = more.filter((effect) => effectValues(track, effect));
+  return [
+    ...CORE_EFFECTS.map(node),
     {
       kind: "menu",
-      id: "reverb",
-      label: "Reverb",
-      detail: reverb
-        ? `mix ${num(reverb.mix)} · size ${num(reverb.size)}`
-        : "off",
-      build: () => [
-        {
-          kind: "toggle",
-          label: "on",
-          value: reverb !== undefined,
-          command: (on) => (on ? "reverb 0.3 0.5" : "reverb off"),
-        },
-        {
-          kind: "number",
-          label: "mix",
-          value: reverb?.mix,
-          start: 0.3,
-          off: "off",
-          min: 0,
-          max: SCORE_LIMITS.maxReverbMix,
-          step: linear(0.05, 0, SCORE_LIMITS.maxReverbMix),
-          format: num,
-          command: (value) =>
-            `reverb ${num(value)} ${num(reverb?.size ?? 0.5)}`,
-        },
-        {
-          kind: "number",
-          label: "size",
-          value: reverb?.size,
-          start: 0.5,
-          off: "off",
-          min: SCORE_LIMITS.minReverbSize,
-          max: SCORE_LIMITS.maxReverbSize,
-          step: linear(
-            0.05,
-            SCORE_LIMITS.minReverbSize,
-            SCORE_LIMITS.maxReverbSize,
-          ),
-          format: num,
-          command: (value) => `reverb ${num(reverb?.mix ?? 0.3)} ${num(value)}`,
-        },
-      ],
+      id: "more effects",
+      label: "more effects",
+      help: "less common effects, each with the same controls",
+      detail:
+        moreOn.length > 0
+          ? `on: ${moreOn.map((effect) => effectSpec(effect).label).join(", ")}`
+          : more.map((effect) => effectSpec(effect).label).join(", "),
+      build: () => more.map(node),
     },
   ];
 }
 
+function effectSummary(
+  effect: EffectName,
+  values: Readonly<Record<string, number | string | boolean>>,
+): string {
+  const spec = effectSpec(effect);
+  return spec.simple
+    .filter((key) => values[key] !== undefined)
+    .map((key) => {
+      const value = values[key]!;
+      const param = spec.params[key]!;
+      return `${key} ${typeof value === "number" ? formatParam(param, value) : String(value)}`;
+    })
+    .join(" · ");
+}
+
+/** `800 Hz`, `0.2 s`: a value with its unit, when it has one. */
+function withUnit(text: string, unit: string | undefined): string {
+  return unit ? `${text} ${unit}` : text;
+}
+
+function formatParam(spec: ParamSpec, value: number): string {
+  if (spec.kind !== "number") return num(value);
+  return spec.step === "log" && value >= 100
+    ? `${Math.round(value)}`
+    : num(value);
+}
+
+/**
+ * One effect's rows: on/off, presets, then its simple parameters; the
+ * `advanced` submenu holds every parameter with its Strudel names.
+ */
+function effectParamNodes(
+  context: MenuContext,
+  effect: EffectName,
+  advanced: boolean,
+): MenuNode[] {
+  const track = focused(context);
+  if (!track) return [];
+  const spec = effectSpec(effect);
+  const values = effectValues(track, effect);
+  const nodes: MenuNode[] = [];
+  if (!advanced) {
+    nodes.push({
+      kind: "toggle",
+      label: "on",
+      value: values !== undefined,
+      command: (on) => `fx ${effect} ${on ? "on" : "off"}`,
+      help: `switch the ${spec.label} on or off (settings are kept)`,
+    });
+    const presets = effectPresetNames(effect);
+    if (presets.length > 0)
+      nodes.push({
+        kind: "choice",
+        label: "preset",
+        value: "—",
+        options: presets,
+        command: (preset) => `fx ${effect} preset ${preset}`,
+        help: "a starting point; every value stays editable",
+      });
+    if (effect === "reverb") {
+      // Convolution (Strudel `ir`): a generated impulse, or `fx ir <file>`.
+      const ir = track.reverb?.ir?.src;
+      const current = ir?.startsWith("builtin:")
+        ? ir.slice("builtin:".length)
+        : (ir ?? "off");
+      nodes.push({
+        kind: "choice",
+        label: "impulse (ir)",
+        value: current,
+        options: ["off", ...REVERB_IR_BUILTINS],
+        command: (choice) => `fx reverb ir ${choice}`,
+      });
+    }
+  }
+  const keys = advanced ? Object.keys(spec.params) : spec.simple;
+  for (const key of keys) {
+    const param = spec.params[key]!;
+    const current = values?.[key];
+    const label =
+      advanced && param.strudel?.length
+        ? `${key} (${param.strudel.filter((name) => !name.includes(" ")).join("/")})`
+        : key;
+    if (param.kind === "number") {
+      nodes.push({
+        kind: "number",
+        label,
+        value: typeof current === "number" ? current : undefined,
+        start: param.default,
+        off: values
+          ? withUnit(formatParam(param, param.default), param.unit)
+          : "off",
+        min: param.min,
+        max: param.max,
+        step: specStep(param),
+        format: (value) => withUnit(formatParam(param, value), param.unit),
+        command: (value) => `fx ${effect} ${key} ${formatParam(param, value)}`,
+        help: param.doc,
+        ...(values
+          ? {
+              reset: `fx ${effect} ${key} ${formatParam(param, param.default)}`,
+            }
+          : {}),
+      });
+    } else if (param.kind === "enum") {
+      nodes.push({
+        kind: "choice",
+        label,
+        value: typeof current === "string" ? current : param.default,
+        options: param.values,
+        command: (option) => `fx ${effect} ${key} ${option}`,
+        help: param.doc,
+      });
+    } else {
+      nodes.push({
+        kind: "toggle",
+        label,
+        value: typeof current === "boolean" ? current : param.default,
+        command: (on) => `fx ${effect} ${key} ${on ? "on" : "off"}`,
+        help: param.doc,
+      });
+    }
+  }
+  if (!advanced) {
+    nodes.push({
+      kind: "menu",
+      id: `${effect}:advanced`,
+      label: "advanced",
+      detail: `all ${Object.keys(spec.params).length} params`,
+      help: `Strudel: ${spec.strudel}`,
+      build: (inner) => effectParamNodes(inner, effect, true),
+    });
+    if (values)
+      nodes.push({
+        kind: "action",
+        label: "reset to defaults",
+        command: `fx ${effect} reset`,
+        help: `put every ${spec.label} value back to its default`,
+      });
+  }
+  return nodes;
+}
+
 function automationNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   if (!track) return [];
-  return (Object.keys(AUTOMATION_LANES) as AutomationParameter[]).map(
-    (lane) => {
-      const count = track[AUTOMATION_LANES[lane].field]?.length ?? 0;
-      return {
-        kind: "menu",
-        id: `lane:${lane}`,
-        label: LANE_LABEL[lane],
-        detail: `${count} point${count === 1 ? "" : "s"}`,
-        build: (inner) => laneNodes(inner, lane),
-      };
-    },
-  );
+  // Track lanes, the lanes of effects that are on, and any lane with
+  // points; every other effect lane is under "all lanes".
+  const shown = AUTOMATION_PARAMETERS.filter((lane) => {
+    if (isTrackAutomationParameter(lane)) return true;
+    if (automationPoints(track, lane).length > 0) return true;
+    const info = FX_LANE_INFO.get(lane as FxLane);
+    if (info?.effect === "synth")
+      return track.synth?.[info.param] !== undefined;
+    return info !== undefined && effectValues(track, info.effect) !== undefined;
+  });
+  const hidden = AUTOMATION_PARAMETERS.filter((lane) => !shown.includes(lane));
+  const nodes = shown.map((lane) => laneMenu(track, lane));
+  if (hidden.length > 0)
+    nodes.push({
+      kind: "menu",
+      id: "lanes:all",
+      label: "all lanes",
+      detail: `${hidden.length} more effect lanes`,
+      build: (inner) => {
+        const current = focused(inner);
+        return current ? hidden.map((lane) => laneMenu(current, lane)) : [];
+      },
+    });
+  return nodes;
+}
+
+function laneMenu(track: Track, lane: AutomationParameter): MenuNode {
+  const count = automationPoints(track, lane).length;
+  return {
+    kind: "menu",
+    id: `lane:${lane}`,
+    label: laneLabel(lane),
+    detail: `${count} point${count === 1 ? "" : "s"}`,
+    build: (inner) => laneNodes(inner, lane),
+  };
 }
 
 /** `4:0.5 8:1` → `automate <lane> points 4:0.5 8:1`, when every pair parses. */
@@ -518,7 +1276,7 @@ function pointsCommand(
     .filter(Boolean);
   if (pairs.length === 0 || (exactly !== undefined && pairs.length !== exactly))
     return undefined;
-  const { min, max } = AUTOMATION_LANES[lane];
+  const { min, max } = automationRange(lane);
   for (const pair of pairs) {
     const match = pair.match(/^(\d+(?:\.\d+)?):(-?\d+(?:\.\d+)?)$/);
     if (!match) return undefined;
@@ -534,9 +1292,9 @@ function laneNodes(
 ): MenuNode[] {
   const track = focused(context);
   if (!track) return [];
-  const { min, max, field } = AUTOMATION_LANES[lane];
+  const { min, max } = automationRange(lane);
   const range = `${laneFormat(lane, min)}…${laneFormat(lane, max)}`;
-  const points = track[field] ?? [];
+  const points = automationPoints(track, lane);
   const nodes: MenuNode[] = [
     {
       kind: "entry",
@@ -592,6 +1350,134 @@ function mixNodes(context: MenuContext): MenuNode[] {
   });
 }
 
+// ── sounds (sample packs) ──────────────────────────────────────────────
+
+function soundsDetail(track: Track | undefined): string {
+  const packs = new Set<string>();
+  for (const ref of Object.values(track?.sampler?.voices ?? {}))
+    if (ref.src.startsWith("pack:")) packs.add(ref.src.slice(5).split("/")[0]!);
+  return packs.size ? [...packs].join(" · ") : "kits, instruments, packs";
+}
+
+/**
+ * The instrument browser: drum kits and soundfont instruments from the
+ * built-in packs (fetched on first use), and the pack list.
+ */
+function kitsMenu(): MenuNode {
+  return {
+    kind: "menu",
+    id: "kits",
+    label: "drum kits",
+    help: "make this a drum track with a synth or sample kit",
+    detail: `synth ${SYNTH_KIT_NAMES.join(" ")} · samples ${Object.keys(DEFAULT_KITS).join(" ")}`,
+    // Synth kits first (offline), then the pack sample kits.
+    build: () => [
+      ...kitCatalog().map((entry): MenuNode => ({
+        kind: "action",
+        label:
+          entry.kind === "synth"
+            ? `${entry.label} · ${entry.detail}`
+            : `${entry.label} · ${DEFAULT_KITS[entry.name]?.pack ?? entry.detail}`,
+        command: entry.command,
+      })),
+      {
+        kind: "menu",
+        id: "kit-nicknames",
+        label: "Strudel banks",
+        detail: `${Object.keys(STRUDEL_BANK_ALIASES).length} drum machines by nickname`,
+        build: () =>
+          Object.entries(STRUDEL_BANK_ALIASES)
+            .sort(([, a], [, b]) =>
+              a.toLowerCase() < b.toLowerCase() ? -1 : 1,
+            )
+            .map(([bank, nickname]): MenuNode => ({
+              kind: "action",
+              label: `${nickname}  ${bank}`,
+              command: `/kit ${nickname}`,
+            })),
+      },
+    ],
+  };
+}
+
+function patternsMenu(): MenuNode {
+  return {
+    kind: "menu",
+    id: "patterns",
+    label: "drum patterns",
+    detail: `${DRUM_PATTERNS.length} grooves`,
+    help: "replace the drum part with a ready-made groove",
+    build: () =>
+      DRUM_PATTERNS.map((entry): MenuNode => ({
+        kind: "action",
+        label: `${entry.label}  ${entry.tempo.bpm} BPM · ${entry.tags.join(", ")}`,
+        command: `/pattern ${entry.name}`,
+      })),
+  };
+}
+
+function soundNodes(): MenuNode[] {
+  return [
+    {
+      kind: "action",
+      label: "wavetable synth  basic shapes morph · built-in",
+      command: "wt basic",
+      help: "switch this track to the morphing wavetable synth",
+    },
+    {
+      kind: "menu",
+      id: "instruments",
+      label: "instruments",
+      help: "sampled piano and General MIDI instruments",
+      detail: "General MIDI soundfont, piano",
+      build: () => [
+        {
+          kind: "action",
+          label: "piano  Salamander grand · piano",
+          command: "/pack use piano/piano",
+        },
+        ...GM_INSTRUMENTS.map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.replace(/^gm_/, "").replace(/_/g, " ")} · gm`,
+          command: `/pack use gm/${name}`,
+        })),
+      ],
+    },
+    {
+      kind: "entry",
+      label: "use a sound",
+      value: "",
+      help: "type a pack sound name, e.g. dirt-samples/bd:3",
+      placeholder: "<pack>/<sound>[:<n>]",
+      command: (text) => (text.trim() ? `/pack use ${text.trim()}` : undefined),
+      example: "/pack use dirt-samples/bd:3",
+    },
+    {
+      kind: "menu",
+      id: "packs",
+      label: "sample packs",
+      help: "browse built-in packs or add one by URL",
+      detail: `${PACK_CATALOG.length} built in`,
+      build: () => [
+        ...PACK_CATALOG.map((pack): MenuNode => ({
+          kind: "action",
+          label: `${pack.name}  ${pack.license}`,
+          command: `/pack info ${pack.name}`,
+        })),
+        {
+          kind: "entry",
+          label: "add a pack",
+          value: "",
+          placeholder: "manifest URL or github:user/repo",
+          command: (text) =>
+            text.trim() ? `/pack add ${text.trim()}` : undefined,
+          example: "/pack add github:yaxu/clean-breaks",
+        },
+      ],
+    },
+  ];
+}
+
 function transportNodes(context: MenuContext): MenuNode[] {
   const score = context.score;
   return [
@@ -599,20 +1485,23 @@ function transportNodes(context: MenuContext): MenuNode[] {
       kind: "action",
       label: context.playing ? "pause" : "play",
       command: context.playing ? "pause" : "play",
+      help: "start or stop the loop (space on an empty prompt)",
     },
     {
       kind: "number",
-      label: "tempo BPM",
+      label: "tempo",
+      help: "beats per minute",
       value: score.tempoBpm,
       min: SCORE_LIMITS.minTempoBpm,
       max: SCORE_LIMITS.maxTempoBpm,
       step: linear(1, SCORE_LIMITS.minTempoBpm, SCORE_LIMITS.maxTempoBpm),
-      format: num,
+      format: (value) => `${num(value)} BPM`,
       command: (value) => `tempo ${num(value)}`,
     },
     {
       kind: "number",
       label: "beats per bar",
+      help: "the meter",
       value: score.beatsPerBar,
       min: 1,
       max: SCORE_LIMITS.maxBeatsPerBar,
@@ -622,17 +1511,19 @@ function transportNodes(context: MenuContext): MenuNode[] {
     },
     {
       kind: "number",
-      label: "loop bars",
+      label: "loop length",
+      help: "how long the loop is",
       value: score.bars,
       min: 1,
       max: SCORE_LIMITS.maxBars,
       step: linear(1, 1, SCORE_LIMITS.maxBars),
-      format: num,
+      format: (value) => `${num(value)} bar${value === 1 ? "" : "s"}`,
       command: (value) => `bars ${Math.round(value)}`,
     },
     {
       kind: "choice",
       label: "grid",
+      help: "the step play-mode recording and the euclid editor snap to",
       value: context.grid,
       options: context.grids,
       command: (option) => `/grid ${option}`,
@@ -640,12 +1531,14 @@ function transportNodes(context: MenuContext): MenuNode[] {
     {
       kind: "toggle",
       label: "click",
+      help: "metronome while playing and recording",
       value: context.clickOn,
       command: (on) => `/click ${on ? "on" : "off"}`,
     },
     {
       kind: "choice",
       label: "count-in bars",
+      help: "bars of click before recording starts",
       value: String(context.countInBars),
       options: ["0", "1", "2"],
       command: (option) => `/count-in ${option}`,
@@ -657,9 +1550,17 @@ function transportNodes(context: MenuContext): MenuNode[] {
 
 type Frame = {
   title: string;
+  /** The submenu's node id (`chords`), for `EditMenu.section`. */
+  id?: string;
   build: (context: MenuContext) => MenuNode[];
   index: number;
   query: string;
+  /**
+   * Lists audition the item under the cursor while the loop plays: the
+   * hover key, and whether this frame has staged a hover yet.
+   */
+  hover?: string;
+  hovering?: boolean;
 };
 
 const KEY_UP = new Set(["\u001b[A", "\u001bOA", "k"]);
@@ -681,8 +1582,10 @@ function childFrame(
 ): Frame {
   return {
     title: node.label,
+    id: node.id,
     index: 0,
     query: "",
+    hover: `menu:${node.id}`,
     build: (context) => {
       const fresh = parent
         .build(context)
@@ -705,21 +1608,34 @@ export class EditMenu {
     return this.stack.length > 0;
   }
 
+  /** True while the menu takes typed text (a filter or a value). */
+  get typing(): boolean {
+    return this.filtering || this.entry !== undefined;
+  }
+
+  /** The root section open now (`chords`), or undefined at the root. */
+  get section(): string | undefined {
+    return this.stack[1]?.id;
+  }
+
   /** Open at the root, or at a section id (`effects`, `automation`). */
   show(context: MenuContext, section?: string): void {
     this.stack = [{ title: "menu", build: rootNodes, index: 0, query: "" }];
     this.filtering = false;
     this.entry = undefined;
-    if (section) {
-      const nodes = rootNodes(context);
+    // Walk the section path (`automation` is Mix & automation › automation).
+    for (const id of section
+      ? (SECTION_ALIASES[section.toLowerCase()] ?? [])
+      : []) {
+      const frame = this.stack.at(-1)!;
+      const nodes = frame.build(context);
       const index = nodes.findIndex(
-        (node) => node.kind === "menu" && node.id === section.toLowerCase(),
+        (node) => node.kind === "menu" && node.id === id,
       );
       const node = nodes[index];
-      if (node?.kind === "menu") {
-        this.stack[0]!.index = index;
-        this.stack.push(childFrame(this.stack[0]!, node));
-      }
+      if (node?.kind !== "menu") break;
+      frame.index = index;
+      this.stack.push(childFrame(frame, node));
     }
   }
 
@@ -787,6 +1703,13 @@ export class EditMenu {
         frame.query = "";
         return { type: "handled" };
       }
+      // In a list, Esc drops the hovered item and goes back; elsewhere it
+      // reverts staged edits first, then goes back as usual.
+      if (frame.hover && frame.hovering && context.audition) {
+        this.stack.pop();
+        return { type: "unhover", key: frame.hover };
+      }
+      if (context.audition?.dirty) return { type: "revert" };
       this.stack.pop();
       return this.stack.length ? { type: "handled" } : { type: "close" };
     }
@@ -799,21 +1722,43 @@ export class EditMenu {
       const step = KEY_UP.has(value) ? -1 : 1;
       if (nodes.length)
         frame.index = (frame.index + step + nodes.length) % nodes.length;
-      return { type: "handled" };
+      return this.hovered(frame, context);
     }
     if (value === "\u001b[5~" || value === "\u001b[H") {
       frame.index = 0;
-      return { type: "handled" };
+      return this.hovered(frame, context);
     }
     if (value === "\u001b[6~" || value === "\u001b[F") {
       frame.index = Math.max(0, nodes.length - 1);
-      return { type: "handled" };
+      return this.hovered(frame, context);
     }
+    // Space hears the focused track (it still switches a toggle row);
+    // `a` and `c` are A/B and context while the window hosts an audition.
+    const audition = context.audition ? auditionKey(value) : undefined;
+    if (audition && !(audition === "loop" && node?.kind === "toggle"))
+      return { type: "audition", key: audition };
     if (!node) return { type: "handled" };
+    if (
+      KEY_ENTER.has(value) &&
+      context.audition?.dirty &&
+      (node.kind === "number" ||
+        node.kind === "toggle" ||
+        node.kind === "point" ||
+        node.kind === "info")
+    )
+      return { type: "keep" };
     if (KEY_LEFT.has(value) || KEY_RIGHT.has(value)) {
       const direction = KEY_RIGHT.has(value) ? 1 : -1;
       return this.nudge(node, direction);
     }
+    if (KEY_DELETE.has(value) && node.kind === "number") {
+      const reset =
+        node.reset ??
+        (node.start !== undefined && node.value !== undefined
+          ? node.command(node.start)
+          : undefined);
+      return reset ? { type: "run", command: reset } : { type: "handled" };
+    }
     if (KEY_DELETE.has(value) && node.kind === "point")
       return {
         type: "run",
@@ -844,13 +1789,19 @@ export class EditMenu {
       }
       if (node.kind === "toggle")
         return { type: "run", command: node.command(!node.value) };
-      if (node.kind === "action") return { type: "run", command: node.command };
+      if (node.kind === "action")
+        return frame.hover &&
+          context.audition?.looping &&
+          (context.audition.stageable ?? isStageable)(node.command)
+          ? { type: "choose", command: node.command, key: frame.hover }
+          : { type: "run", command: node.command };
       if (node.kind === "choice") {
         const current = node.options.indexOf(node.value);
         this.stack.push({
           title: node.label,
           index: Math.max(0, current),
           query: "",
+          hover: node.label,
           build: (fresh) => {
             const parent = this.stack.at(-2);
             const live =
@@ -882,6 +1833,17 @@ export class EditMenu {
     return { type: "handled" };
   }
 
+  /** After a move: audition the item under the cursor in a list. */
+  private hovered(frame: Frame, context: MenuContext): MenuResult {
+    if (!frame.hover || !context.audition?.looping) return { type: "handled" };
+    const node = this.selected(context);
+    const stageable = context.audition?.stageable ?? isStageable;
+    if (node?.kind !== "action" || !stageable(node.command))
+      return { type: "handled" };
+    frame.hovering = true;
+    return { type: "hover", command: node.command, key: frame.hover };
+  }
+
   private nudge(node: MenuNode, direction: 1 | -1): MenuResult {
     if (node.kind === "menu") {
       if (direction > 0) {
@@ -901,8 +1863,8 @@ export class EditMenu {
       return { type: "run", command: node.command(next) };
     }
     if (node.kind === "point") {
-      const { min, max } = AUTOMATION_LANES[node.lane];
-      const next = clamp(LANE_STEP[node.lane](node.value, direction), min, max);
+      const { min, max } = automationRange(node.lane);
+      const next = clamp(laneStep(node.lane)(node.value, direction), min, max);
       if (Math.abs(next - node.value) < 1e-9) return { type: "handled" };
       return {
         type: "run",
@@ -923,7 +1885,11 @@ export class EditMenu {
         ? { type: "handled" }
         : { type: "run", command: node.command(next) };
     }
-    if (direction < 0 && this.stack.length > 1) this.stack.pop();
+    if (direction < 0 && this.stack.length > 1) {
+      const left = this.stack.pop();
+      if (left?.hover && left.hovering)
+        return { type: "unhover", key: left.hover };
+    }
     return { type: "handled" };
   }
 
@@ -973,23 +1939,78 @@ export class EditMenu {
     if (frame?.query || this.filtering) title += ` · /${frame?.query ?? ""}`;
     if (this.entry)
       title += ` · ${this.entry.label}: ${this.entry.buffer || placeholderFor(selected)}▏`;
-    const items = nodes.map((node, at) => ({
-      label: `${node.label.padEnd(LABEL_WIDTH)} ${valueText(node)}`.trimEnd(),
-      detail: commandText(node),
-      value: String(at),
-    }));
+    const audition = context.audition;
+    if (audition?.dirty) title = `● ${title}`;
+    if (audition?.status && !this.entry) title += ` · ${audition.status}`;
+    // Changed rows show `staged ← committed` (Elektron's compare, inline).
+    const before = new Map<string, string>();
+    if (audition?.dirty && frame && !frame.query)
+      for (const node of frame.build({
+        ...context,
+        score: audition.committed,
+        ...(audition.committedChords
+          ? { chords: audition.committedChords }
+          : {}),
+      }))
+        before.set(node.label, valueText(node));
+    const items = nodes.map((node, at) => {
+      const now = valueText(node);
+      const was = node.kind === "menu" ? undefined : before.get(node.label);
+      const shown = was !== undefined && was !== now ? `${now} ← ${was}` : now;
+      return {
+        label: `${node.label.padEnd(LABEL_WIDTH)} ${shown}`.trimEnd(),
+        value: String(at),
+      };
+    });
+    const command = selected ? commandText(selected) : undefined;
+    const note = [
+      selected ? describe(selected) : "",
+      selected?.kind === "number" && command
+        ? rowSketch(selected, command, nodes)
+        : "",
+      command ? `› ${command}` : "",
+    ]
+      .filter(Boolean)
+      .join("  ");
     const hint = this.entry
-      ? " type a value · enter apply · esc cancel "
+      ? HINTS.typing
       : this.filtering
-        ? " type to filter · enter choose · esc clear "
-        : selected?.kind === "point"
-          ? " ←→ nudge · digits set · x delete · esc back "
-          : selected?.kind === "number" ||
-              selected?.kind === "toggle" ||
-              selected?.kind === "choice"
-            ? " ←→/+- nudge · digits set · enter edit · / filter · esc back "
-            : " ↑↓ move · enter open · / filter · esc back ";
-    return { title, items, index, hint };
+        ? HINTS.filtering
+        : audition?.looping && frame?.hover && selected?.kind === "action"
+          ? HINTS.hover
+          : audition && (audition.looping || audition.dirty)
+            ? audition.hint
+            : selected?.kind === "point"
+              ? HINTS.point
+              : selected?.kind === "number" ||
+                  selected?.kind === "toggle" ||
+                  selected?.kind === "choice"
+                ? HINTS.value
+                : selected?.kind === "action"
+                  ? HINTS.action
+                  : HINTS.menu;
+    return { title, items, index, hint, note };
+  }
+}
+
+/** The focused row's one-line description. */
+function describe(node: MenuNode): string {
+  if (node.help) return node.help;
+  switch (node.kind) {
+    case "number":
+      return node.reset || node.start !== undefined
+        ? "←→ adjust · type a number · x resets"
+        : "←→ adjust · type a number";
+    case "toggle":
+      return "space or enter switches it";
+    case "choice":
+      return `${node.options.length} choices · enter lists them`;
+    case "point":
+      return "←→ change · type beat:value · x deletes";
+    case "entry":
+      return "enter, then type";
+    default:
+      return "";
   }
 }
 
@@ -1013,7 +2034,7 @@ function entryCommand(node: MenuNode, text: string): string | undefined {
   }
   if (node.kind === "point") {
     // `0.8` sets the value; `6:0.8` moves to beat 6.
-    const { min, max } = AUTOMATION_LANES[node.lane];
+    const { min, max } = automationRange(node.lane);
     const match = trimmed.match(/^(?:(\d+(?:\.\d+)?):)?(-?\d+(?:\.\d+)?)$/);
     if (!match) return undefined;
     const value = Number(match[2]);
@@ -1049,6 +2070,40 @@ function valueText(node: MenuNode): string {
 }
 
 /** The command a row stands for, shown so the menu teaches commands. */
+/** A filter curve, envelope or table position for a focused number row. */
+function rowSketch(
+  node: Extract<MenuNode, { kind: "number" }>,
+  command: string,
+  nodes: readonly MenuNode[],
+): string {
+  const value = node.value ?? node.start ?? node.min;
+  return (
+    sketchFor(
+      command,
+      value,
+      (param) => {
+        for (const sibling of nodes) {
+          if (sibling.kind !== "number") continue;
+          const text = commandText(sibling);
+          if (text && commandParam(text) === param)
+            return sibling.value ?? sibling.start;
+        }
+        return undefined;
+      },
+      filterTypeOf(nodes),
+    ) ?? ""
+  );
+}
+
+function filterTypeOf(nodes: readonly MenuNode[]): string | undefined {
+  const row = nodes.find(
+    (node) => node.kind === "choice" && node.label === "type",
+  );
+  return row?.kind === "choice" && typeof row.value === "string"
+    ? row.value
+    : undefined;
+}
+
 function commandText(node: MenuNode): string | undefined {
   switch (node.kind) {
     case "number":
@@ -1074,10 +2129,16 @@ function nodeText(node: MenuNode): string {
 
 /** Root sections, for `/menu <section>`. */
 export const MENU_SECTIONS = [
-  "track",
-  "parameters",
+  "sound",
   "effects",
-  "automation",
+  "rhythm",
+  "chords",
   "mix",
+  "project",
+  // Older names, still accepted.
+  "parameters",
+  "sounds",
+  "track",
+  "automation",
   "transport",
 ] as const;