@hraness/dawg 0.6.1 → 0.8.0

package/src/tui/menu.ts

@@ -8,19 +8,49 @@
  *
  * Rendering reuses the TUI's picker overlay: `view()` returns a picker.
  */
+import { TOPIC_ALIASES } from "../lang/glossary.ts";
+import {
+  voiceEffectRows,
+  voiceRootDetail,
+  voiceRootNodes,
+} from "./menu-voice.ts";
 import { commandParam, sketchFor } from "./sketch.ts";
-import { HINTS } from "../../tui/grammar.ts";
+import { nearest } from "../commands/nearest.ts";
+import {
+  ARROW_DOWN,
+  ARROW_UP,
+  HINTS,
+  KEY_BACK,
+  KEY_BACKSPACE,
+  KEY_DOWN,
+  KEY_END,
+  KEY_ENTER,
+  KEY_FORWARD,
+  KEY_HOME,
+  KEY_LEFT,
+  KEY_PAGE_DOWN,
+  KEY_PAGE_UP,
+  KEY_RESET,
+  KEY_RIGHT,
+  KEY_UP,
+} from "../../tui/grammar.ts";
 import { arrangeDetail, arrangeNodes } from "./arrange-menu.ts";
 import { auditionKey, isStageable, type AuditionKey } from "./audition.ts";
 import { performanceDetail, performanceNodes } from "./performance-menu.ts";
 import { malletsMenu, modalParameterNodes } from "./modal-menu.ts";
 import { windParameterNodes, windsMenu } from "./wind-menu.ts";
+import { singParameterNodes } from "./sing-menu.ts";
 import type { FaderSpec } from "./fader.ts";
+import { knobFields, type KnobField } from "./knob-fields.ts";
+import { soundFamily } from "./knob-map.ts";
 import {
   openingMeterCommand,
   openingUnit,
   tempoDetail,
   tempoMenuNode,
+  START_BARS,
+  START_BEATS_PER_BAR,
+  START_TEMPO_BPM,
 } from "./menu-time.ts";
 import {
   AUTOMATION_PARAMETERS,
@@ -40,6 +70,8 @@ import {
   type Track,
   type TrackAutomationParameter,
   type TrackScore,
+  CALIBRATION_LATEST,
+  createScore,
 } from "../../core/score.ts";
 import {
   CORE_EFFECTS,
@@ -49,6 +81,7 @@ import {
   RIG_STAGES,
   rigPresetOf,
   SHOEGAZE_EFFECTS,
+  VOWEL_VALUES,
   effectPresetNames,
   effectSpec,
   type EffectName,
@@ -176,6 +209,12 @@ export type MenuContext = Readonly<{
   grids: readonly string[];
   clickOn: boolean;
   countInBars: number;
+  /** How much agent turns show (`/showme`); absent hides the row. */
+  showMe?: string;
+  /** Project › audio: the chosen devices and the lists to pick from. */
+  audio?: MenuAudioDevices;
+  /** The session's name, for Project › session and export file names. */
+  sessionName?: string;
   /** Play mode's chord settings (defaults when absent). */
   chords?: ChordSettings;
   /** Project root, for the project's own wavetables (none when absent). */
@@ -188,11 +227,25 @@ export type MenuContext = Readonly<{
   audition?: MenuAudition;
 }>;
 
+/** One output and one input (src/audio/devices.ts); no routing. */
+export type MenuAudioDevices = Readonly<{
+  /** `Speakers` or `default (Speakers)`. */
+  output: string;
+  input: string;
+  /** Output names; empty when the backend cannot list them. */
+  outputs: readonly string[];
+  inputs: readonly string[];
+  /** Why device choice is unavailable (fallback backends). */
+  unavailable?: string;
+}>;
+
 /** 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;
+  /** How many edits are staged, for the drawer's A/B badge. */
+  staged?: number;
   /** The committed score, for `staged ← committed` on changed rows. */
   committed: TrackScore;
   /** The footer while auditioning. */
@@ -361,7 +414,7 @@ const TRACK_LANE_LABEL: Readonly<Record<TrackAutomationParameter, string>> = {
   resonance: "filter resonance",
   "delay-feedback": "delay feedback",
   "delay-mix": "delay mix",
-  wt: "wavetable position",
+  wt: "table position",
 };
 
 const FX_LANE_INFO = new Map(FX_LANES.map((entry) => [entry.lane, entry]));
@@ -405,7 +458,9 @@ function laneLabel(lane: AutomationParameter): string {
     info.effect === "keys" ||
     info.effect === "modal" ||
     info.effect === "grain" ||
-    info.effect === "wind"
+    info.effect === "wind" ||
+    info.effect === "sing" ||
+    info.effect === "vocoder"
       ? info.effect
       : effectSpec(info.effect).label;
   return `${owner} ${info.param}${unit}`;
@@ -439,9 +494,17 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       id: "sound",
       label: "Sound",
       detail: `${name} · ${track?.instrument ?? "?"}`,
-      help: "the focused track's instrument and its voice",
+      help: "the focused track's instrument, its controls and performance",
       build: soundSectionNodes,
     },
+    {
+      kind: "menu",
+      id: "voice",
+      label: "Voice",
+      detail: voiceRootDetail(context),
+      help: "sing, lyrics, clips, pitch, autotune, formant and vocoder",
+      build: voiceRootNodes,
+    },
     {
       kind: "menu",
       id: "effects",
@@ -454,26 +517,34 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       kind: "menu",
       id: "rhythm",
       label: "Rhythm",
-      detail: "euclid editor · patterns · kits",
-      help: "drum hits per voice, ready-made grooves and drum kits",
+      detail: "euclid editor · grooves · kits",
+      help: "hits per drum, ready-made grooves and kits",
       build: rhythmNodes,
     },
     {
       kind: "menu",
       id: "chords",
-      label: "Chords",
+      label: "Chords and key",
       detail: chordsDetail(context),
-      help: "song key and how chords play in play mode (Ctrl-P)",
+      help: "the song key and tuning, and how chords play in play mode (Ctrl-P)",
       build: chordNodes,
     },
     {
       kind: "menu",
       id: "mix",
-      label: "Mix & automation",
+      label: "Mix",
       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",
+      help: "volume, pan, mute and solo per track, automation and the master",
       build: mixSectionNodes,
     },
+    {
+      kind: "menu",
+      id: "arrange",
+      label: "Arrange",
+      detail: arrangeDetail(context),
+      help: "tracks, song sections, the form, builds, drops, fills and styles",
+      build: arrangeRootNodes,
+    },
     {
       kind: "menu",
       id: "project",
@@ -481,47 +552,94 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       detail: context.score.time
         ? `${tempoDetail(context.score)} · ${context.score.bars} bars`
         : `${num(context.score.tempoBpm)} BPM · ${context.score.beatsPerBar}/4 · ${context.score.bars} bars`,
-      help: "tempo, meter, tempo map, loop length, play, click and count-in",
+      help: "play, tempo, meter, loop, click, export, session, agent and help",
       build: transportNodes,
     },
-    {
-      kind: "menu",
-      id: "arrange",
-      label: "Arrange",
-      detail: arrangeDetail(context),
-      help: "song sections, the form, builds, drops and fills",
-      build: arrangeNodes,
-    },
   ];
 }
 
-/** 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"],
-  performance: ["sound", "performance"],
-  expression: ["sound", "performance"],
-  effects: ["effects"],
-  rhythm: ["rhythm"],
-  chords: ["chords"],
-  mix: ["mix"],
-  track: ["mix"],
-  automation: ["mix", "automation"],
-  master: ["mix", "master"],
-  project: ["project"],
-  transport: ["project"],
-  tempo: ["project", "tempo"],
-  meter: ["project", "tempo"],
-  time: ["project", "tempo"],
-  tuning: ["project", "tuning"],
-  scale: ["project", "tuning"],
-  arrange: ["arrange"],
-  sections: ["arrange"],
-  form: ["arrange"],
-};
+/**
+ * Where each `/menu <id>` opens: the ten topic ids (sound voice effects
+ * rhythm chords mix arrange project keys agent) first, then every older id,
+ * as a path of menu ids from the root. `keys` opens Project › help and
+ * guides; the ? panel itself belongs to the window.
+ */
+export const SECTION_ALIASES: Readonly<Record<string, readonly string[]>> =
+  Object.freeze(
+    withTopicAliases({
+      sound: ["sound"],
+      voice: ["voice"],
+      effects: ["effects"],
+      rhythm: ["rhythm"],
+      chords: ["chords"],
+      mix: ["mix"],
+      arrange: ["arrange"],
+      project: ["project"],
+      keys: ["project", "help"],
+      agent: ["project", "agent"],
+      // Older ids, kept as aliases.
+      parameters: ["sound"],
+      sounds: ["sound", "browse"],
+      instruments: ["sound", "browse"],
+      performance: ["sound", "performance"],
+      expression: ["sound", "performance"],
+      clips: ["voice"],
+      lyrics: ["voice"],
+      autotune: ["voice"],
+      sing: ["voice"],
+      vocoder: ["voice"],
+      formant: ["voice"],
+      grooves: ["rhythm", "patterns"],
+      groove: ["rhythm", "patterns"],
+      patterns: ["rhythm", "patterns"],
+      kits: ["rhythm", "kits"],
+      euclid: ["rhythm"],
+      tuning: ["chords", "tuning"],
+      scale: ["chords"],
+      key: ["chords"],
+      track: ["mix"],
+      automation: ["mix", "automation"],
+      master: ["mix", "master"],
+      tracks: ["arrange", "tracks"],
+      music: ["arrange"],
+      style: ["arrange", "style"],
+      styles: ["arrange", "style"],
+      genre: ["arrange", "style"],
+      sections: ["arrange", "sections"],
+      form: ["arrange"],
+      transport: ["project"],
+      tempo: ["project", "tempo"],
+      meter: ["project", "tempo"],
+      time: ["project", "tempo"],
+      export: ["project", "export"],
+      session: ["project", "session"],
+      sessions: ["project", "session"],
+      window: ["project", "help"],
+      help: ["project", "help"],
+      guides: ["project", "help"],
+      model: ["project", "agent"],
+      audio: ["project", "audio"],
+      devices: ["project", "audio"],
+      showme: ["project", "agent"],
+      models: ["project", "agent"],
+      fx: ["effects"],
+    }),
+  );
+
+/**
+ * Every glossary topic alias (`/help drums`, `/guide mixer`) opens the same
+ * topic in `/menu` too: a word with no deeper path here opens its topic.
+ */
+function withTopicAliases(
+  paths: Record<string, readonly string[]>,
+): Record<string, readonly string[]> {
+  const all = { ...paths };
+  for (const [word, topic] of Object.entries(TOPIC_ALIASES))
+    if (!all[word] && all[topic]) all[word] = all[topic]!;
+  return all;
+}
 
-/** Sound: instrument and voice first, then the sound browser. */
+/** Sound: the instrument and its controls first, then the instruments. */
 function soundSectionNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   const tuning: MenuNode[] =
@@ -530,7 +648,7 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
           {
             kind: "menu",
             id: "track-tuning",
-            label: "tuning",
+            label: "track tuning",
             detail: track.tuning
               ? tuningLabel(track.tuning)
               : `song · ${tuningLabel(context.score.tuning)}`,
@@ -561,7 +679,7 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
             id: "keys",
             label: "keys",
             detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
-            help: "the modelled organ: preset, drawbars, registers or stops, rotary",
+            help: "the modeled organ: preset, drawbars, registers or stops, rotary",
             build: (inner) => {
               const current = focused(inner);
               return current ? organNodes(current) : [];
@@ -577,7 +695,7 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
               detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
               help: isElectricFamily(track.instrument)
                 ? "electric keys: preset, bark, bell, tone, vibe/trem, pickup and mute"
-                : "the modelled piano: preset, touch, hammers, dampers, stretch",
+                : "the modeled piano: preset, touch, hammers, dampers, stretch",
               build: (inner) => {
                 const current = focused(inner);
                 return current
@@ -622,9 +740,9 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
     {
       kind: "menu",
       id: "browse",
-      label: "browse sounds",
+      label: "instruments",
       detail: soundsDetail(focused(context)),
-      help: "instruments, wavetables, sample packs",
+      help: "every instrument: keys, strings, mallets, winds, granular, wavetables, sample packs",
       build: soundNodes,
     },
   ];
@@ -709,20 +827,262 @@ function guitarNodes(track: Track | undefined): MenuNode[] {
 }
 
 /** Rhythm: the euclid editor, then grooves and kits. */
-function rhythmNodes(): MenuNode[] {
+function rhythmNodes(context: MenuContext): MenuNode[] {
   return [
     {
       kind: "action",
       label: "euclid editor",
       command: "/euclid",
-      help: "hits, steps and rotation per drum voice",
+      help: "hits, steps and rotation per drum",
     },
     patternsMenu(),
     kitsMenu(),
+    gridNode(context),
   ];
 }
 
-/** Mix & automation: this track, every track, then automation lanes. */
+/** The record and euclid grid (Rhythm and Project share this row). */
+function gridNode(context: MenuContext): MenuNode {
+  return {
+    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}`,
+  };
+}
+
+/** Arrange: the tracks first, then sections, form and styles. */
+function arrangeRootNodes(context: MenuContext): MenuNode[] {
+  const count = context.score.tracks.length;
+  return [
+    {
+      kind: "menu",
+      id: "tracks",
+      label: "tracks",
+      detail: `${count} track${count === 1 ? "" : "s"} · add, focus, move, remove`,
+      help: "add a track, focus one, rename, reorder or remove it",
+      build: tracksNodes,
+    },
+    ...arrangeNodes(context),
+  ];
+}
+
+/** Arrange › tracks: add, focus, rename, move and remove. */
+function tracksNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const track = focused(context);
+  const nodes: MenuNode[] = [
+    {
+      kind: "entry",
+      label: "add a track",
+      value: "",
+      placeholder: "name, e.g. bass or piano b",
+      example: "/track bass",
+      help: "a new track with that name (or focus it when it exists)",
+      command: (text) => {
+        const name = text.trim().replace(/\s+/g, " ");
+        return /^[a-z0-9._ -]{1,64}$/i.test(name)
+          ? `/track ${name}`
+          : undefined;
+      },
+    },
+    ...score.tracks.map((item): MenuNode => ({
+      kind: "action",
+      label: `${item.id === context.trackId ? "● " : ""}${item.name ?? item.id}`,
+      command: `/track ${item.id}`,
+      help: `focus ${item.id} · ${item.instrument}`,
+    })),
+  ];
+  if (track) {
+    nodes.push({
+      kind: "entry",
+      label: "rename",
+      value: track.name,
+      placeholder: "new name",
+      command: (text) =>
+        text.trim() ? `track name ${text.trim()}` : undefined,
+      example: `track name ${track.name}`,
+      help: "rename the focused track",
+    });
+    if (score.tracks.length > 1) {
+      const index = score.tracks.findIndex((item) => item.id === track.id);
+      nodes.push(
+        {
+          kind: "number",
+          label: "position",
+          help: "where the focused track sits in the list",
+          value: index + 1,
+          min: 1,
+          max: score.tracks.length,
+          step: linear(1, 1, score.tracks.length),
+          format: (value) => `${num(value)} of ${score.tracks.length}`,
+          command: (value) => `/track move ${track.id} ${Math.round(value)}`,
+        },
+        {
+          kind: "action",
+          label: `remove ${track.id}`,
+          command: `/track remove ${track.id}`,
+          help: "remove the focused track (^z brings it back)",
+        },
+      );
+    }
+  }
+  return nodes;
+}
+
+/** A file-safe stem for export names: the session's song name or `song`. */
+function exportStem(context: MenuContext): string {
+  const stem = (context.sessionName ?? "song")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+  return stem || "song";
+}
+
+/** Project › export: the project file and MIDI; audio renders offline. */
+function exportNodes(context: MenuContext): MenuNode[] {
+  const stem = exportStem(context);
+  return [
+    {
+      kind: "entry",
+      label: "project file",
+      value: "",
+      placeholder: `file name, e.g. ${stem}.track.json`,
+      example: `/export ${stem}.track.json`,
+      help: "the whole song as one .track.json file (open it with /import)",
+      command: (text) => {
+        const name = text.trim() || `${stem}.track.json`;
+        return /^\S+$/.test(name)
+          ? `/export ${/\.json$/i.test(name) ? name : `${name}.track.json`}`
+          : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "MIDI",
+      value: "",
+      placeholder: `file name, e.g. ${stem}.mid`,
+      example: `/export ${stem}.mid`,
+      help: "notes, tempo and tracks as a standard MIDI file",
+      command: (text) => {
+        const name = text.trim() || `${stem}.mid`;
+        return /^\S+$/.test(name)
+          ? `/export ${/\.midi?$/i.test(name) ? name : `${name}.mid`}`
+          : undefined;
+      },
+    },
+    {
+      kind: "info",
+      label: "WAV and stems",
+      value: `dawg render ${stem}.wav`,
+      help: "audio renders offline in the shell: dawg render out.wav (--stems for one file per track)",
+    },
+  ];
+}
+
+/** Project › session: rename, fork and resume (the window's verbs). */
+function sessionNodes(context: MenuContext): MenuNode[] {
+  return [
+    {
+      kind: "entry",
+      label: "rename",
+      value: context.sessionName ?? "",
+      placeholder: "song name (--auto names it for you)",
+      example: "/rename night drive",
+      help: "name this session; --auto hands naming back to dawg",
+      command: (text) => (text.trim() ? `/rename ${text.trim()}` : undefined),
+    },
+    {
+      kind: "action",
+      label: "fork",
+      command: "/fork",
+      help: "a copy of this session to try something; the original stays",
+    },
+    {
+      kind: "action",
+      label: "resume",
+      command: "/resume",
+      help: "pick an earlier session in this folder",
+    },
+    {
+      kind: "action",
+      label: "list sessions",
+      command: "/sessions",
+      help: "every session in this folder, newest first",
+    },
+  ];
+}
+
+/** Project › agent: the model, show-me and the model key. */
+function agentNodes(context: MenuContext): MenuNode[] {
+  return [
+    {
+      kind: "action",
+      label: "model",
+      command: "/model",
+      help: "pick the model the agent runs on",
+    },
+    ...(context.showMe === undefined
+      ? []
+      : [
+          {
+            kind: "choice" as const,
+            label: "show me",
+            help: "agent turns: its commands as ghost text, faders, keys",
+            value: context.showMe,
+            options: ["on", "quiet", "off"],
+            command: (option: string) => `/showme ${option}`,
+          },
+        ]),
+    {
+      kind: "action",
+      label: "model key",
+      command: "/model key",
+      help: "add a model key so typed requests reach the agent (dawg works offline without it)",
+    },
+    {
+      kind: "action",
+      label: "agent help",
+      command: "/help agent",
+      help: "what the agent can do and how its turns show",
+    },
+  ];
+}
+
+/** Project › help and guides: the reference, guides and keys. */
+function helpNodes(): MenuNode[] {
+  return [
+    {
+      kind: "action",
+      label: "help",
+      command: "/help",
+      help: "start here: the ten topics",
+    },
+    {
+      kind: "action",
+      label: "all commands",
+      command: "/help all",
+      help: "the full command reference",
+    },
+    {
+      kind: "action",
+      label: "guides",
+      command: "/guide",
+      help: "short walkthroughs, one screen each",
+    },
+    {
+      kind: "action",
+      label: "keys",
+      command: "/help keys",
+      help: "every key in the window (? shows them too)",
+    },
+  ];
+}
+
+/** Mix: this track, every track, automation lanes, then the master. */
 function mixSectionNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
   const automated = AUTOMATION_PARAMETERS.filter(
@@ -730,6 +1090,14 @@ function mixSectionNodes(context: MenuContext): MenuNode[] {
   ).join(" ");
   return [
     ...trackNodes(context),
+    {
+      kind: "menu",
+      id: "mixer",
+      label: "mixer",
+      detail: `${context.score.tracks.length} levels on one page`,
+      help: "every track's level as a fader, the drawer's all-tracks page (mix) · tab flips to this track",
+      build: mixerNodes,
+    },
     {
       kind: "menu",
       id: "tracks",
@@ -759,7 +1127,7 @@ function mixSectionNodes(context: MenuContext): MenuNode[] {
   ];
 }
 
-/** Mix & automation > Master: the loudness target, then each unit in order. */
+/** Mix › master: the loudness target, then each unit in order. */
 function masterNodes(context: MenuContext): MenuNode[] {
   const master = context.score.master;
   // A name only when the LUFS and the limiter ceiling both match it, and no
@@ -932,7 +1300,7 @@ function chordsDetail(context: MenuContext): string {
   return `${chords.mode} · ${key ? keyName(key) : "no key"} · ${chords.perform}`;
 }
 
-/** Play mode's chord settings and the song key (`/chords …`, `key …`). */
+/** Chords and key: the song key and tuning, then play mode's chord settings. */
 function chordNodes(context: MenuContext): MenuNode[] {
   const chords = context.chords ?? defaultChordSettings();
   const key = parseKey(context.score.key ?? undefined);
@@ -965,11 +1333,20 @@ function chordNodes(context: MenuContext): MenuNode[] {
       options: [...MODE_NAMES, ...SCALE_NAMES],
       command: (option) => `key ${tonic} ${option}`,
     },
+    {
+      kind: "menu",
+      id: "tuning",
+      label: "tuning",
+      detail: `${tuningLabel(context.score.tuning)} · ${keyLabel(context.score.key)}`,
+      help: "the song tuning: 12-TET, EDOs, just, gamelan, Scala, and the scale",
+      build: songTuningNodes,
+    },
     {
       kind: "number",
       label: "voicing",
       help: "inversion steps up or down (play mode: - =)",
       value: chords.inversion,
+      start: 0,
       min: -MAX_VOICING_STEP,
       max: MAX_VOICING_STEP,
       step: linear(1, -MAX_VOICING_STEP, MAX_VOICING_STEP),
@@ -1056,6 +1433,7 @@ function chordNodes(context: MenuContext): MenuNode[] {
       label: "arp octaves",
       help: "how many octaves an arpeggio climbs",
       value: chords.octaves,
+      start: 1,
       min: 1,
       max: 4,
       step: linear(1, 1, 4),
@@ -1072,12 +1450,22 @@ function chordNodes(context: MenuContext): MenuNode[] {
     },
     {
       kind: "choice",
-      label: "style",
-      help: "the style n suggests next chords in",
+      label: "idiom",
+      help: "the musical idiom n suggests next chords in (pop, jazz, blues…)",
       value: chords.style,
       options: PROGRESSION_STYLES,
       command: (option) => `/chords style ${option}`,
     },
+    {
+      kind: "entry",
+      label: "progression",
+      value: "",
+      placeholder: "chords, e.g. i7 IV7 each 8",
+      help: "sustained, voice-led block chords on this track in the song key",
+      command: (text) =>
+        text.trim() ? `progression ${text.trim()}` : undefined,
+      example: "progression i7 IV7 each 8",
+    },
   ];
 }
 
@@ -1130,6 +1518,24 @@ function trackNodes(context: MenuContext): MenuNode[] {
   ];
 }
 
+/**
+ * Mix › mixer: one level fader per track (design §8.5), each a typed
+ * `volume <track> <0..1>`, so the page sets any track without moving the
+ * focus. Labels are numbered, so two tracks with one name stay apart.
+ */
+export function mixerNodes(context: MenuContext): MenuNode[] {
+  return context.score.tracks.map((track, index): MenuNode => {
+    const base = volumeNode(track);
+    return {
+      ...(base as Extract<MenuNode, { kind: "number" }>),
+      label: `${index + 1}${track.id === context.trackId ? "›" : " "}${track.name}`,
+      command: (value: number) => `volume ${track.id} ${num(value)}`,
+      reset: `volume ${track.id} 1`,
+      help: `${track.name}'s level; 1 is unity (0 dB) · x resets`,
+    };
+  });
+}
+
 function instrumentNode(track: Track): MenuNode {
   const options: string[] = [...AVAILABLE_INSTRUMENTS, ...KEYS_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
@@ -1173,7 +1579,7 @@ function panNode(track: Track): MenuNode {
         : `${num(Math.abs(value))} ${value < 0 ? "L" : "R"}`,
     command: (value) => `pan ${num(value)}`,
     reset: "pan 0",
-    help: "-1 left … 1 right · x centres",
+    help: "-1 left … 1 right · x centers",
   };
 }
 
@@ -1256,7 +1662,7 @@ function parameterNodes(context: MenuContext): MenuNode[] {
       detail: `all ${all.length} params`,
       help: isElectricFamily(track.instrument)
         ? "every electric keys parameter for this family"
-        : "every modelled piano parameter",
+        : "every modeled piano parameter",
       build: (inner) => {
         const current = focused(inner);
         return current
@@ -1270,6 +1676,11 @@ function parameterNodes(context: MenuContext): MenuNode[] {
   } else if (track.instrument === "wind" && track.wind) {
     // 0.6.1 wind engine: preset and WIND_PARAMS rows.
     nodes.push(...windParameterNodes(track));
+  } else if (track.instrument === "sing" && track.sing) {
+    // 0.7 sing engine: preset, SING_PARAMS rows and a Throat sub-menu.
+    nodes.push(
+      ...singParameterNodes(track, parseKey(context.score.key)?.tonic),
+    );
   } else if (!isDrumInstrument(track.instrument)) {
     nodes.push(...synthNodes(track, SYNTH_SIMPLE));
     nodes.push({
@@ -1484,7 +1895,7 @@ function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
     // 0.6.1 layers: velocity layer (SFZ lovel/hivel) and round-robin group.
     {
       kind: "choice",
-      label: "Velocity layer",
+      label: "velocity layer",
       value: ref.vel ? `${ref.vel[0]}-${ref.vel[1]}` : "off",
       options: velocityLayerOptions(ref.vel),
       command: (option) => set(`vel ${option}`),
@@ -1492,7 +1903,7 @@ function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
     },
     {
       kind: "entry",
-      label: "Round robin",
+      label: "round robin",
       value: ref.rr ?? "",
       placeholder: "group name, e.g. sn",
       command: (text) => set(`rr ${text.trim() || "off"}`),
@@ -1524,7 +1935,7 @@ function matchingSynthPreset(track: Track): string | undefined {
   )?.[0];
 }
 
-/** Modelled piano rows: the preset, then each parameter (`keys <p> <v>`). */
+/** Modeled piano rows: the preset, then each parameter (`keys <p> <v>`). */
 function keysNodes(
   track: Track,
   params: readonly string[],
@@ -1702,7 +2113,7 @@ function organNodes(track: Track): MenuNode[] {
       ? {
           kind: "menu",
           id: "keys:drawbars",
-          label: "Drawbars",
+          label: "drawbars",
           detail: text("drawbars"),
           help: "nine drawbars 16' to 1' (0 in, 8 full out)",
           build: (inner) => {
@@ -1720,7 +2131,7 @@ function organNodes(track: Track): MenuNode[] {
         ? {
             kind: "menu",
             id: "keys:registers",
-            label: "Registers",
+            label: "registers",
             detail: text("registers"),
             help: "five combo-organ registers 16' to 2' (0 off, 8 full)",
             build: (inner) => {
@@ -1737,7 +2148,7 @@ function organNodes(track: Track): MenuNode[] {
         : {
             kind: "menu",
             id: "keys:stops",
-            label: "Stops",
+            label: "stops",
             detail: text("stops"),
             help: "pipe stops and registrations",
             build: (inner) => {
@@ -1814,9 +2225,9 @@ function synthParamNode(track: Track, key: string, named: boolean): MenuNode {
 
 /** 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",
+  lpf: "synth filter",
+  lpq: "synth filter res",
+  lpenv: "synth filter env",
   vib: "vibrato",
   fm: "FM amount",
 };
@@ -2000,7 +2411,7 @@ function wavetableNodes(track: Track, projectRoot?: string): MenuNode[] {
     nodes.push({
       kind: "info",
       label: "position automation",
-      value: `${track.wtAutomation!.length} points · Automation › wavetable position`,
+      value: `${track.wtAutomation!.length} points · Automation › table position`,
     });
   return nodes;
 }
@@ -2015,7 +2426,7 @@ function effectNodes(context: MenuContext): MenuNode[] {
     return {
       kind: "menu",
       id: effect,
-      label: spec.label[0]!.toUpperCase() + spec.label.slice(1),
+      label: spec.label,
       detail: values ? effectSummary(effect, values) : "off",
       help: spec.doc,
       build: (inner) => effectParamNodes(inner, effect, false),
@@ -2028,7 +2439,9 @@ function effectNodes(context: MenuContext): MenuNode[] {
     (effect) =>
       !CORE_EFFECTS.includes(effect) &&
       !rigStages.includes(effect) &&
-      !gaze.includes(effect),
+      !gaze.includes(effect) &&
+      // 0.7: the formant shift lives in Effects > Voice.
+      effect !== "formant",
   );
   const gazeOn = SHOEGAZE_EFFECTS.filter((effect) =>
     effectValues(track, effect),
@@ -2036,7 +2449,7 @@ function effectNodes(context: MenuContext): MenuNode[] {
   const shoegaze: MenuNode = {
     kind: "menu",
     id: "shoegaze",
-    label: "Shoegaze",
+    label: "shoegaze",
     help: "wobble (tremolo-arm bend), bloom (feedback), swell (volume swell), double (two takes); `rig shoegaze` loads them all",
     detail:
       gazeOn.length === 0
@@ -2050,7 +2463,7 @@ function effectNodes(context: MenuContext): MenuNode[] {
   const rig: MenuNode = {
     kind: "menu",
     id: "guitar rig",
-    label: "Guitar rig",
+    label: "guitar rig",
     help: "stomp box, amp head with noise gate and speaker cabinet; `rig <name>` loads a whole rig",
     detail:
       rigOn.length === 0 ? "off" : (rigPresetOf(track.fx) ?? rigOn.join(" → ")),
@@ -2073,6 +2486,19 @@ function effectNodes(context: MenuContext): MenuNode[] {
     ...CORE_EFFECTS.map(node),
     rig,
     shoegaze,
+    // Formant and vocoder live under Voice; this row is the way there.
+    ...(voiceEffectRows(context).length > 0
+      ? [
+          {
+            kind: "menu" as const,
+            id: "voice",
+            label: "voice effects",
+            detail: "formant · vocoder · also in Voice",
+            help: "formant and vocoder for voices (the same rows as Ctrl-K › Voice)",
+            build: voiceEffectRows,
+          },
+        ]
+      : []),
     {
       kind: "menu",
       id: "more effects",
@@ -2109,16 +2535,17 @@ function withUnit(text: string, unit: string | undefined): string {
 
 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);
+  const text =
+    spec.step === "log" && value >= 100 ? `${Math.round(value)}` : num(value);
+  // Rounding never leaves the range: attack 0.0001 types as 0.0001, not 0.
+  return Number(text) < spec.min ? String(spec.min) : text;
 }
 
 /**
  * One effect's rows: on/off, presets, then its simple parameters; the
  * `advanced` submenu holds every parameter with its Strudel names.
  */
-function effectParamNodes(
+export function effectParamNodes(
   context: MenuContext,
   effect: EffectName,
   advanced: boolean,
@@ -2209,6 +2636,37 @@ function effectParamNodes(
       });
     }
   }
+  if (!advanced && effect === "vowel") {
+    // 0.7 vowel morph: To picks the target (morph starts halfway), Morph
+    // moves between the two; both through `/vowel`.
+    const to = values?.to;
+    nodes.push(
+      {
+        kind: "choice",
+        label: "to",
+        value: typeof to === "string" ? to : "—",
+        options: ["—", ...VOWEL_VALUES],
+        command: (option) =>
+          option === "—" ? "/vowel to off" : `/vowel to ${option}`,
+        help: "a second vowel to morph toward (— keeps one vowel)",
+      },
+      {
+        kind: "number",
+        label: "morph",
+        value: typeof values?.morph === "number" ? values.morph : undefined,
+        start: 0.5,
+        off: typeof to === "string" ? "0" : "set to first",
+        min: 0,
+        max: 1,
+        step: specStep(spec.params.morph as NumberParam),
+        format: (value) => num(value),
+        command: (value) =>
+          typeof to === "string" ? `/vowel morph ${num(value)}` : `/vowel to o`,
+        help: "0 is the vowel, 1 is the to vowel; log-frequency formant glide, automatable as vowel-morph",
+        ...(typeof to === "string" ? { reset: "/vowel morph 0" } : {}),
+      },
+    );
+  }
   if (!advanced) {
     nodes.push({
       kind: "menu",
@@ -2251,6 +2709,8 @@ function automationNodes(context: MenuContext): MenuNode[] {
     if (info?.effect === "modal") return track.modal !== undefined;
     if (info?.effect === "grain") return track.granular !== undefined;
     if (info?.effect === "wind") return track.wind !== undefined;
+    if (info?.effect === "sing") return track.sing !== undefined;
+    if (info?.effect === "vocoder") return track.vocoder !== undefined;
     return info !== undefined && effectValues(track, info.effect) !== undefined;
   });
   const hidden = AUTOMATION_PARAMETERS.filter((lane) => !shown.includes(lane));
@@ -2376,14 +2836,14 @@ function soundsDetail(track: Track | undefined): string {
 }
 
 /**
- * The instrument browser: drum kits and soundfont instruments from the
+ * The instrument browser: 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",
+    label: "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.
@@ -2420,27 +2880,27 @@ function patternsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "patterns",
-    label: "drum patterns",
-    detail: `${DRUM_PATTERNS.length} grooves`,
+    label: "grooves",
+    detail: `${DRUM_PATTERNS.length} ready-made drum parts`,
     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}`,
+        command: `/groove ${entry.name}`,
       })),
   };
 }
 
 const GRANULAR_PRESETS_COUNT = granularBrowseNodes().length;
 
-function soundNodes(): MenuNode[] {
+function soundNodes(context: MenuContext): MenuNode[] {
   return [
     {
       kind: "menu",
       id: "group:keys",
-      label: "Keys",
-      help: "modelled pianos, electric keys and organs, built in (no download)",
+      label: "keys",
+      help: "modeled pianos, electric keys and organs, built in (no download)",
       detail: `${PIANO_PRESET_NAMES.join(" ")} · electric: ${ELECTRIC_PRESET_NAMES.join(" ")} · organs: ${ORGAN_PRESET_NAMES.join(" ")}`,
       build: () => [
         ...PIANO_PRESET_NAMES.map((name): MenuNode => {
@@ -2456,8 +2916,8 @@ function soundNodes(): MenuNode[] {
         {
           kind: "menu",
           id: "group:keys:electric",
-          label: "Electric",
-          help: "electric pianos (tine, reed) and the clavinet, modelled",
+          label: "electric",
+          help: "electric pianos (tine, reed) and the clavinet, modeled",
           detail: ELECTRIC_PRESET_NAMES.join(" "),
           build: () =>
             Object.entries(KEYS_PRESETS)
@@ -2473,7 +2933,7 @@ function soundNodes(): MenuNode[] {
         {
           kind: "menu",
           id: "group:organs",
-          label: "Organs",
+          label: "organs",
           help: "tonewheel, combo and pipe organs on the keys engine",
           detail: ORGAN_PRESET_NAMES.join(" "),
           build: () =>
@@ -2491,7 +2951,7 @@ function soundNodes(): MenuNode[] {
     },
     {
       kind: "action",
-      label: "wavetable synth  basic shapes morph · built-in",
+      label: "wavetable  basic shapes morph · built-in",
       command: "wt basic",
       help: "switch this track to the morphing wavetable synth",
     },
@@ -2501,7 +2961,7 @@ function soundNodes(): MenuNode[] {
     {
       kind: "menu",
       id: "strings",
-      label: "Strings",
+      label: "strings",
       help: "plucked strings: guitars, basses, sitar, harpsichord, oud, koto…; Bowed: violin to contrabass, sections",
       detail: `${STRING_PRESET_NAMES.length - BOWED_PRESET_NAMES.length} plucked · ${BOWED_PRESET_NAMES.length} bowed · built-in`,
       build: () => [
@@ -2516,7 +2976,7 @@ function soundNodes(): MenuNode[] {
         {
           kind: "menu",
           id: "strings:bowed",
-          label: "Bowed",
+          label: "bowed",
           help: "bowed strings: violin, viola, cello, bass, fiddle, erhu, sections",
           detail: BOWED_PRESET_NAMES.join(" "),
           build: () =>
@@ -2532,7 +2992,7 @@ function soundNodes(): MenuNode[] {
     {
       kind: "menu",
       id: "granular-browse",
-      label: "Granular",
+      label: "granular",
       help: "grain clouds from a built-in synth or this track's own sound",
       detail: `${GRANULAR_PRESETS_COUNT} presets · built-in`,
       build: granularBrowseNodes,
@@ -2540,7 +3000,7 @@ function soundNodes(): MenuNode[] {
     {
       kind: "menu",
       id: "instruments",
-      label: "instruments",
+      label: "all instruments",
       help: "sampled piano and General MIDI instruments",
       detail: "General MIDI soundfont, piano",
       build: () => [
@@ -2558,9 +3018,9 @@ function soundNodes(): MenuNode[] {
     },
     {
       kind: "entry",
-      label: "use a sound",
+      label: "use a sample",
       value: "",
-      help: "type a pack sound name, e.g. dirt-samples/bd:3",
+      help: "type a pack sample 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",
@@ -2605,6 +3065,7 @@ function transportNodes(context: MenuContext): MenuNode[] {
       label: "tempo",
       help: "beats per minute",
       value: score.tempoBpm,
+      start: START_TEMPO_BPM,
       min: SCORE_LIMITS.minTempoBpm,
       max: SCORE_LIMITS.maxTempoBpm,
       step: linear(1, SCORE_LIMITS.minTempoBpm, SCORE_LIMITS.maxTempoBpm),
@@ -2616,6 +3077,7 @@ function transportNodes(context: MenuContext): MenuNode[] {
       label: "beats per bar",
       help: "the meter",
       value: score.beatsPerBar,
+      start: START_BEATS_PER_BAR,
       min: 1,
       max: SCORE_LIMITS.maxBeatsPerBar,
       step: linear(1, 1, SCORE_LIMITS.maxBeatsPerBar),
@@ -2628,20 +3090,14 @@ function transportNodes(context: MenuContext): MenuNode[] {
       label: "loop length",
       help: "how long the loop is",
       value: score.bars,
+      start: START_BARS,
       min: 1,
       max: SCORE_LIMITS.maxBars,
       step: linear(1, 1, SCORE_LIMITS.maxBars),
       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}`,
-    },
+    gridNode(context),
     {
       kind: "toggle",
       label: "click",
@@ -2658,12 +3114,14 @@ function transportNodes(context: MenuContext): MenuNode[] {
       command: (option) => `/count-in ${option}`,
     },
     {
-      kind: "menu",
-      id: "tuning",
-      label: "tuning & scale",
-      detail: `${tuningLabel(score.tuning)} · ${keyLabel(score.key)}`,
-      help: "the song tuning (12-TET, EDOs, just, gamelan, Scala) and scale",
-      build: songTuningNodes,
+      kind: "choice",
+      label: "calibration",
+      help: "sound fixes: 1 chokes hats, tunes toms, levels keys, steadies brass · 0 keeps the legacy sound",
+      value: String(score.calibration ?? 0),
+      options: Array.from({ length: CALIBRATION_LATEST + 1 }, (_, i) =>
+        String(i),
+      ),
+      command: (option) => `/calibration ${option}`,
     },
     {
       kind: "menu",
@@ -2673,6 +3131,115 @@ function transportNodes(context: MenuContext): MenuNode[] {
       help: "render a track, an orbit or the mix to a pinned WAV on a new sampler or granular track",
       build: resampleNodes,
     },
+    {
+      kind: "menu",
+      id: "export",
+      label: "export",
+      detail: "project file · MIDI · WAV",
+      help: "save the song as a project file or MIDI; audio renders offline",
+      build: exportNodes,
+    },
+    {
+      kind: "menu",
+      id: "session",
+      label: "session",
+      detail: context.sessionName ?? "rename · fork · resume",
+      help: "rename, fork or resume a session",
+      build: sessionNodes,
+    },
+    {
+      kind: "menu",
+      id: "agent",
+      label: "agent",
+      detail: context.showMe
+        ? `show me ${context.showMe}`
+        : "model · model key",
+      help: "the agent's model, show-me and model key",
+      build: agentNodes,
+    },
+    {
+      kind: "menu",
+      id: "audio",
+      label: "audio",
+      detail: context.audio
+        ? `out ${context.audio.output} · in ${context.audio.input}`
+        : "output · input",
+      help: "pick the audio output and input (one each, saved on this machine)",
+      build: audioNodes,
+    },
+    {
+      kind: "menu",
+      id: "help",
+      label: "help and guides",
+      detail: "help · guides · keys",
+      help: "the command reference, the guides and the keys",
+      build: helpNodes,
+    },
+  ];
+}
+
+/** Project › audio: two rows, each opening a device list. */
+function audioNodes(context: MenuContext): MenuNode[] {
+  const audio = context.audio;
+  if (!audio || audio.unavailable)
+    return [
+      {
+        kind: "info",
+        label: "devices",
+        value: "system default",
+        help: audio?.unavailable ?? "device choice needs the native sink",
+      },
+      {
+        kind: "action",
+        label: "show audio",
+        command: "/audio",
+        help: "the current output, input and why choice is unavailable",
+      },
+    ];
+  const list = (
+    side: "out" | "in",
+    names: readonly string[],
+    current: string,
+  ): MenuNode[] => [
+    {
+      kind: "action",
+      label: current.startsWith("default") ? "● default" : "default",
+      command: `/audio ${side} default`,
+      help: "the system default device (follows the system setting)",
+    },
+    ...names.map((name): MenuNode => ({
+      kind: "action",
+      label: name === current ? `● ${name}` : name,
+      command: `/audio ${side} ${name}`,
+      help:
+        side === "out"
+          ? `play through ${name} (a soft blip confirms it)`
+          : `listen on ${name} (audio test meters it)`,
+    })),
+  ];
+  return [
+    {
+      kind: "menu",
+      id: "output",
+      label: "output",
+      detail: audio.output,
+      help: "where dawg plays: Enter picks, Esc goes back",
+      build: () => list("out", audio.outputs, audio.output),
+    },
+    {
+      kind: "menu",
+      id: "input",
+      label: "input",
+      detail: audio.input,
+      help: "the input to meter now and record from later",
+      build: () => list("in", audio.inputs, audio.input),
+    },
+    {
+      kind: "action",
+      label: "test",
+      command: "/audio test",
+      help: "a short tone on the output, then a level meter for the input",
+    },
   ];
 }
 
@@ -2720,9 +3287,9 @@ function resampleNodes(context: MenuContext): MenuNode[] {
     },
     {
       kind: "action",
-      label: "mix → sampler (pre-master)",
+      label: "mix → sampler",
       command: "resample orbit 1",
-      help: "render every track on orbit 1 (the default bus) without the song master",
+      help: "pre-master: render every track on orbit 1 (the default bus) without the song master",
     },
     {
       kind: "action",
@@ -2899,7 +3466,7 @@ function songTuningNodes(context: MenuContext): MenuNode[] {
       help: "the song scale: modes, minors, pentatonics, maqam, ragas, Messiaen",
       value: scale,
       options: [...MODE_NAMES, ...SCALE_NAMES],
-      command: (option) => `scale ${option}`,
+      command: (option) => `key ${option}`,
     },
     {
       kind: "choice",
@@ -2907,7 +3474,7 @@ function songTuningNodes(context: MenuContext): MenuNode[] {
       help: "the song key's tonic; keeps the scale",
       value: tonic,
       options: TONICS,
-      command: (option) => `scale ${option} ${scale}`,
+      command: (option) => `key ${option} ${scale}`,
     },
     {
       kind: "action",
@@ -2918,7 +3485,7 @@ function songTuningNodes(context: MenuContext): MenuNode[] {
     {
       kind: "action",
       label: "list scales",
-      command: "scale list",
+      command: "key list",
       help: "every mode and scale, by family",
     },
   ];
@@ -2960,14 +3527,7 @@ type Frame = {
   hovering?: boolean;
 };
 
-const KEY_UP = new Set(["\u001b[A", "\u001bOA", "k"]);
-const KEY_DOWN = new Set(["\u001b[B", "\u001bOB", "j"]);
-const KEY_LEFT = new Set(["\u001b[D", "\u001bOD", "h", "-", "_"]);
-const KEY_RIGHT = new Set(["\u001b[C", "\u001bOC", "l", "+", "="]);
-const KEY_ENTER = new Set(["\r", "\n"]);
-const KEY_BACKSPACE = new Set(["\u007f", "\b"]);
-const KEY_DELETE = new Set(["\u001b[3~", "x"]);
-const LABEL_WIDTH = 16;
+export const LABEL_WIDTH = 16;
 
 /**
  * A submenu frame whose rows are rebuilt from the parent's fresh build, so
@@ -2998,6 +3558,11 @@ function childFrame(
 export class EditMenu {
   private stack: Frame[] = [];
   private filtering = false;
+  /**
+   * The fader drawer's front page (design §8.6): the open level's knob page
+   * and whether Tab paged to every param. Undefined: plain rows.
+   */
+  private knobView: { page: string; all: boolean } | undefined;
   /** Typed value for the selected row (`entry` holds the row's label). */
   private entry: { label: string; buffer: string } | undefined;
 
@@ -3020,10 +3585,8 @@ export class EditMenu {
     this.stack = [{ title: "menu", build: rootNodes, index: 0, query: "" }];
     this.filtering = false;
     this.entry = undefined;
-    // Walk the section path (`automation` is Mix & automation › automation).
-    for (const id of section
-      ? (SECTION_ALIASES[section.toLowerCase()] ?? [])
-      : []) {
+    // Walk the section path (`automation` is Mix › automation).
+    for (const id of section ? (menuSectionPath(context, section) ?? []) : []) {
       const frame = this.stack.at(-1)!;
       const nodes = frame.build(context);
       const index = nodes.findIndex(
@@ -3036,6 +3599,21 @@ export class EditMenu {
     }
   }
 
+  /** Step into the open level's submenu `id`; false when it has none. */
+  enter(context: MenuContext, id: string): boolean {
+    const frame = this.stack.at(-1);
+    if (!frame) return false;
+    const nodes = frame.build(context);
+    const index = nodes.findIndex(
+      (node) => node.kind === "menu" && node.id === id,
+    );
+    const node = nodes[index];
+    if (node?.kind !== "menu") return false;
+    frame.index = index;
+    this.stack.push(childFrame(frame, node));
+    return true;
+  }
+
   /**
    * Open on the level a bare parameter command edits, for the fader drawer:
    * `volume` / `pan` (Mix), `fx filter` / `fx filter cutoff` (that effect,
@@ -3122,6 +3700,77 @@ export class EditMenu {
     this.stack = [];
     this.filtering = false;
     this.entry = undefined;
+    this.knobView = undefined;
+  }
+
+  /**
+   * The knob page of the open level (design §7.3), or undefined where the
+   * level has no knobs: Sound (by engine), Mix and its mixer (this track),
+   * the master, Project (tempo) and one effect.
+   */
+  knobPageHere(context: MenuContext): string | undefined {
+    const ids = this.stack.slice(1).map((frame) => frame.id ?? "");
+    const [top, sub] = ids;
+    const track = focused(context);
+    if (top === "sound" && ids.length === 1)
+      return track ? `sound:${soundFamily(track)}` : undefined;
+    if (
+      top === "mix" &&
+      (ids.length === 1 || (ids.length === 2 && sub === "mixer"))
+    )
+      return "mix";
+    if (top === "mix" && ids.length === 2 && sub === "master") return "master";
+    if (top === "project" && ids.length === 1) return "tempo";
+    const last = ids.at(-1) ?? "";
+    if (top === "effects" && (EFFECT_NAMES as readonly string[]).includes(last))
+      return `fx:${last}`;
+    return undefined;
+  }
+
+  /**
+   * Turn the drawer's knob front page on for the open level. `label` is the
+   * row the drawer opens on: when it is not one of the knobs (or the level
+   * is the mixer), the drawer opens on every param instead. Returns the
+   * label to focus, or undefined when the level has no knob page.
+   */
+  openKnobs(context: MenuContext, label?: string): string | undefined {
+    const page = this.knobPageHere(context);
+    this.knobView = undefined;
+    if (!page) return undefined;
+    const frame = this.stack.at(-1)!;
+    const fallback = faderSpecs(frame.build(context));
+    const knobs = knobFields(context, page, fallback);
+    if (knobs.length === 0) return undefined;
+    const mixer = frame.id === "mixer";
+    const onKnob =
+      label === undefined || knobs.some((knob) => knob.label === label);
+    this.knobView = { page, all: mixer || !onKnob };
+    if (this.knobView.all) return label ?? fallback[0]?.label;
+    return label ?? knobs[0]!.label;
+  }
+
+  /** Which drawer page is up: the four knobs, every param, or no knobs. */
+  get knobPage(): "knobs" | "all" | undefined {
+    return this.knobView ? (this.knobView.all ? "all" : "knobs") : undefined;
+  }
+
+  /** The knob page id behind the drawer (`sound:synth`, `mix`), if any. */
+  get knobPageId(): string | undefined {
+    return this.knobView?.page;
+  }
+
+  /**
+   * Tab in the drawer: flip between the four knobs and every param (on the
+   * mixer, between all tracks and this track). Returns the label to focus:
+   * `keep` when it is on the new page, else the page's first field.
+   */
+  pageKnobs(context: MenuContext, keep: string): string | undefined {
+    if (!this.knobView) return undefined;
+    this.knobView = { ...this.knobView, all: !this.knobView.all };
+    const fields = this.faderFields(context);
+    return fields.some((field) => field.label === keep)
+      ? keep
+      : fields[0]?.label;
   }
 
   /** The visible rows of the current level (filtered). */
@@ -3130,9 +3779,15 @@ export class EditMenu {
     if (!frame) return [];
     const all = frame.build(context);
     const needle = frame.query.toLowerCase();
-    return needle
-      ? all.filter((node) => nodeText(node).toLowerCase().includes(needle))
-      : all;
+    if (!needle) return all;
+    const direct = all.filter((node) =>
+      nodeText(node).toLowerCase().includes(needle),
+    );
+    // At the root a filter also looks two levels down for groups
+    // (`/autotune`, `/formant`, `/tuning`) and offers them by path, after
+    // the roots that match.
+    if (this.stack.length !== 1) return direct;
+    return [...direct, ...deepGroups(all, context, needle)];
   }
 
   private selected(context: MenuContext): MenuNode | undefined {
@@ -3160,11 +3815,7 @@ export class EditMenu {
         frame.index = 0;
         return { type: "handled" };
       }
-      if (
-        KEY_ENTER.has(value) ||
-        value === "\u001b[B" ||
-        value === "\u001b[A"
-      ) {
+      if (KEY_ENTER.has(value) || value === ARROW_DOWN || value === ARROW_UP) {
         this.filtering = false;
         return this.key(value, context);
       }
@@ -3203,11 +3854,11 @@ export class EditMenu {
         frame.index = (frame.index + step + nodes.length) % nodes.length;
       return this.hovered(frame, context);
     }
-    if (value === "\u001b[5~" || value === "\u001b[H") {
+    if (KEY_PAGE_UP.has(value) || KEY_HOME.has(value)) {
       frame.index = 0;
       return this.hovered(frame, context);
     }
-    if (value === "\u001b[6~" || value === "\u001b[F") {
+    if (KEY_PAGE_DOWN.has(value) || KEY_END.has(value)) {
       frame.index = Math.max(0, nodes.length - 1);
       return this.hovered(frame, context);
     }
@@ -3226,11 +3877,19 @@ export class EditMenu {
         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") {
+    // ← → adjust a value; on any other row ← h go back and → l go in
+    // (or run the action), and - + do nothing.
+    const isValue = isValueNode(node);
+    if (isValue && (KEY_LEFT.has(value) || KEY_RIGHT.has(value)))
+      return this.nudge(node, KEY_RIGHT.has(value) ? 1 : -1);
+    if (!isValue && KEY_BACK.has(value)) return this.back();
+    if (!isValue && (KEY_LEFT.has(value) || KEY_RIGHT.has(value)))
+      if (!(
+        KEY_FORWARD.has(value) &&
+        (node.kind === "menu" || node.kind === "action")
+      ))
+        return { type: "handled" };
+    if (KEY_RESET.has(value) && node.kind === "number") {
       const reset =
         node.reset ??
         (node.start !== undefined && node.value !== undefined
@@ -3238,7 +3897,7 @@ export class EditMenu {
           : undefined);
       return reset ? { type: "run", command: reset } : { type: "handled" };
     }
-    if (KEY_DELETE.has(value) && node.kind === "point")
+    if (KEY_RESET.has(value) && node.kind === "point")
       return {
         type: "run",
         command: `automate ${node.lane} remove ${num(node.beat)}`,
@@ -3250,7 +3909,7 @@ export class EditMenu {
       this.entry = { label: node.label, buffer: value };
       return { type: "handled" };
     }
-    if (KEY_ENTER.has(value) || value === " ") {
+    if (KEY_ENTER.has(value) || KEY_FORWARD.has(value) || value === " ") {
       if (node.kind === "menu") {
         // Going back lands on the opened row with the filter cleared.
         if (frame.query) {
@@ -3326,15 +3985,16 @@ export class EditMenu {
     return { type: "hover", command: node.command, key: frame.hover };
   }
 
+  /** ← on a row that is not a value: up one level (never past the root). */
+  private back(): MenuResult {
+    if (this.stack.length <= 1) return { type: "handled" };
+    const left = this.stack.pop();
+    if (left?.hover && left.hovering)
+      return { type: "unhover", key: left.hover };
+    return { type: "handled" };
+  }
+
   private nudge(node: MenuNode, direction: 1 | -1): MenuResult {
-    if (node.kind === "menu") {
-      if (direction > 0) {
-        this.stack.push(childFrame(this.stack.at(-1)!, node));
-        return { type: "handled" };
-      }
-      if (this.stack.length > 1) this.stack.pop();
-      return { type: "handled" };
-    }
     if (node.kind === "number") {
       const next =
         node.value === undefined
@@ -3367,11 +4027,6 @@ export class EditMenu {
         ? { type: "handled" }
         : { type: "run", command: node.command(next) };
     }
-    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" };
   }
 
@@ -3413,10 +4068,26 @@ export class EditMenu {
    * related params: every filter control, every reverb control), built
    * from `context` (the staged score while auditioning).
    */
-  faderFields(context: MenuContext): FaderSpec[] {
+  faderFields(context: MenuContext): (FaderSpec | KnobField)[] {
     const frame = this.stack.at(-1);
     if (!frame) return [];
-    return faderSpecs(frame.build(context));
+    const rows = faderSpecs(frame.build(context));
+    if (!this.knobView) return rows;
+    if (!this.knobView.all)
+      return knobFields(context, this.knobView.page, rows);
+    // The mixer's rows are all levels: each wears the orange knob.
+    if (frame.id === "mixer")
+      return rows.map((row) => ({ ...row, knob: 3 as const }));
+    return rows;
+  }
+
+  /**
+   * Every param of the current level, whichever drawer page is up: the
+   * side list a wide drawer shows beside the four knobs.
+   */
+  pageFields(context: MenuContext): FaderSpec[] {
+    const frame = this.stack.at(-1);
+    return frame ? faderSpecs(frame.build(context)) : [];
   }
 
   /** The same fields as committed, for the drawer's `staged ← committed`. */
@@ -3502,6 +4173,16 @@ export class EditMenu {
   }
 }
 
+/** Rows that hold a value: ← → adjust them instead of navigating. */
+function isValueNode(node: MenuNode): boolean {
+  return (
+    node.kind === "number" ||
+    node.kind === "point" ||
+    node.kind === "toggle" ||
+    node.kind === "choice"
+  );
+}
+
 /** The focused row's one-line description. */
 function describe(node: MenuNode): string {
   if (node.help) return node.help;
@@ -3663,28 +4344,155 @@ function commandText(node: MenuNode): string | undefined {
   }
 }
 
+/** Menu groups below `nodes` (two levels) whose label matches `needle`. */
+function deepGroups(
+  nodes: readonly MenuNode[],
+  context: MenuContext,
+  needle: string,
+): MenuNode[] {
+  const found: MenuNode[] = [];
+  const visit = (list: readonly MenuNode[], path: string, depth: number) => {
+    for (const node of list) {
+      if (node.kind !== "menu" || found.length >= 12) continue;
+      const label = path ? `${path} › ${node.label}` : node.label;
+      if (path && node.label.toLowerCase().includes(needle))
+        found.push({ ...node, label });
+      if (depth < 2) {
+        let children: MenuNode[] = [];
+        try {
+          children = node.build(context);
+        } catch {
+          continue;
+        }
+        visit(children, label, depth + 1);
+      }
+    }
+  };
+  visit(nodes, "", 0);
+  return found;
+}
+
 function nodeText(node: MenuNode): string {
   return `${node.label} ${valueText(node)} ${commandText(node) ?? ""}`;
 }
 
-/** Root sections, for `/menu <section>`. */
-export const MENU_SECTIONS = [
-  "sound",
-  "effects",
-  "rhythm",
-  "chords",
-  "mix",
-  "master",
-  "project",
-  "arrange",
-  // Older names, still accepted.
-  "parameters",
-  "sounds",
-  "track",
-  "automation",
-  "transport",
-  // Subsections.
-  "tempo",
-  "meter",
-  "time",
-] as const;
+/** Every id `/menu <id>` opens: the ten topics first, then older ids. */
+export const MENU_SECTIONS: readonly string[] = Object.freeze(
+  Object.keys(SECTION_ALIASES),
+);
+
+/** The ten topic ids, the roots `/menu` names first. */
+export const MENU_TOPICS: readonly string[] = Object.freeze(
+  MENU_SECTIONS.slice(0, 10),
+);
+
+/** The names `/menu` and `/help menu` list: one per topic, no aliases. */
+export const MENU_SHOWN_SECTIONS: readonly string[] = MENU_TOPICS;
+
+/** `/menu`'s usage line: the short form; `/help menu` lists every topic. */
+export const MENU_USAGE = "usage: /menu <topic or row> · /help menu lists them";
+
+/**
+ * The error for `/menu <section>` when nothing matches: the nearest topic
+ * or row name first, so it fits 80 columns, then the short usage.
+ */
+export function menuUsage(context: MenuContext, section: string): string {
+  const names = new Set<string>(MENU_SECTIONS);
+  for (const node of rootNodes(context))
+    if (node.kind === "menu") {
+      let children: MenuNode[] = [];
+      try {
+        children = node.build(context);
+      } catch {
+        continue;
+      }
+      for (const child of children)
+        if (child.kind === "menu") names.add(labelName(child.label));
+    }
+  const near = nearest(section, names);
+  return `no menu "${section}"${near ? ` · did you mean /menu ${near}?` : ""} · /menu <topic or row>`;
+}
+
+/** A row label without its padded detail: `granular  12 presets` → `granular`. */
+function labelName(label: string): string {
+  return label
+    .split(/\s{2,}/)[0]!
+    .trim()
+    .toLowerCase();
+}
+
+/**
+ * The path of menu ids `/menu <section>` walks: a topic or older id from
+ * SECTION_ALIASES, else the first menu row (three levels deep, breadth
+ * first) whose id or label is `section`. Undefined when nothing matches.
+ */
+export function menuSectionPath(
+  context: MenuContext,
+  section: string,
+): readonly string[] | undefined {
+  const needle = section.trim().toLowerCase();
+  if (!needle) return undefined;
+  const alias = SECTION_ALIASES[needle];
+  if (alias) return alias;
+  type Step = { nodes: readonly MenuNode[]; path: readonly string[] };
+  let level: Step[] = [{ nodes: rootNodes(context), path: [] }];
+  for (let depth = 0; depth < 3 && level.length; depth += 1) {
+    const next: Step[] = [];
+    for (const { nodes, path } of level) {
+      for (const node of nodes) {
+        if (node.kind !== "menu") continue;
+        const at = [...path, node.id];
+        if (node.id === needle || node.label.toLowerCase() === needle)
+          return at;
+        if (depth < 2) {
+          try {
+            next.push({ nodes: node.build(context), path: at });
+          } catch {
+            // A section that cannot build here has no rows to match.
+          }
+        }
+      }
+    }
+    level = next;
+  }
+  return undefined;
+}
+
+/** A one-track project, for breadcrumbs asked for without a window. */
+function breadcrumbContext(): MenuContext {
+  return {
+    score: createScore({
+      tempoBpm: 120,
+      bars: 8,
+      tracks: [{ id: "keys", name: "keys", instrument: "piano" }],
+      notes: [],
+    }),
+    trackId: "keys",
+    playing: false,
+    grid: "1/16",
+    grids: ["1/16"],
+    clickOn: false,
+    countInBars: 1,
+  };
+}
+
+/**
+ * `Ctrl-K › Chords and key › tuning`: where `/menu <id>` opens, from the
+ * live labels. Undefined when `id` opens nothing.
+ */
+export function menuPath(
+  id: string,
+  context: MenuContext = breadcrumbContext(),
+): string | undefined {
+  const path = menuSectionPath(context, id);
+  if (!path) return undefined;
+  const labels: string[] = [];
+  let nodes: readonly MenuNode[] = rootNodes(context);
+  for (const step of path) {
+    const node = nodes.find((row) => row.kind === "menu" && row.id === step);
+    if (node?.kind !== "menu") return undefined;
+    labels.push(node.label);
+    nodes = node.build(context);
+  }
+  return ["Ctrl-K", ...labels].join(" › ");
+}