@hraness/dawg 0.4.1 → 0.5.0

package/src/tui/menu.ts

@@ -10,7 +10,16 @@
  */
 import { commandParam, sketchFor } from "./sketch.ts";
 import { HINTS } 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 type { FaderSpec } from "./fader.ts";
+import {
+  openingMeterCommand,
+  openingUnit,
+  tempoDetail,
+  tempoMenuNode,
+} from "./menu-time.ts";
 import {
   AUTOMATION_PARAMETERS,
   automationPoints,
@@ -40,7 +49,22 @@ import {
   type NumberParam,
   type ParamSpec,
 } from "../../core/fx.ts";
-import { effectValues } from "../commands/fx.ts";
+import {
+  effectValues,
+  parseEffectName,
+  parseParamName,
+} from "../commands/fx.ts";
+import {
+  LOUDNESS_TARGET_NAMES,
+  LOUDNESS_TARGETS,
+  MASTER_LIMITS,
+  MASTER_PRESETS,
+  MASTER_SPECS,
+  MASTER_UNITS,
+  describeMaster,
+  describeUnit,
+  type MasterUnit,
+} from "../../core/master.ts";
 import { SAMPLE_CONTROLS, type SampleControl } from "../commands/sample.ts";
 import { AVAILABLE_INSTRUMENTS } from "../audio/wav.ts";
 import {
@@ -53,6 +77,7 @@ 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 { loopTicksOf } from "../../core/tempo.ts";
 import {
   SYNTH_GROUPS,
   SYNTH_PARAMS,
@@ -76,10 +101,19 @@ import {
   PERFORM_MODES,
   PROGRESSION_PRESETS,
   PROGRESSION_STYLES,
+  SCALE_NAMES,
   SPREADS,
   keyName,
   parseKey,
 } from "../../core/chords.ts";
+import {
+  TUNING_LIMITS,
+  TUNING_MAPS,
+  TUNING_NAMES,
+  describeTuning,
+  type Tuning,
+} from "../../core/tuning.ts";
+import { rootName, tuningStepsText } from "../commands/tuning.ts";
 import {
   ARP_RATES,
   CHORD_MODES,
@@ -215,6 +249,8 @@ export type MenuResult =
   | { type: "unhover"; key: string }
   /** Chose a list item while the loop plays: stage it for good. */
   | { type: "choose"; command: string; key: string }
+  /** Enter on a number row: open the fader drawer on this level's values. */
+  | { type: "fader"; label: string }
   | { type: "pass" };
 
 export type MenuView = Readonly<{
@@ -389,10 +425,20 @@ export function rootNodes(context: MenuContext): MenuNode[] {
       kind: "menu",
       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",
+      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",
       build: transportNodes,
     },
+    {
+      kind: "menu",
+      id: "arrange",
+      label: "Arrange",
+      detail: arrangeDetail(context),
+      help: "song sections, the form, builds, drops and fills",
+      build: arrangeNodes,
+    },
   ];
 }
 
@@ -401,20 +447,56 @@ 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"],
 };
 
 /** Sound: instrument and voice first, then the sound browser. */
 function soundSectionNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  const tuning: MenuNode[] =
+    track && !isDrumInstrument(track.instrument)
+      ? [
+          {
+            kind: "menu",
+            id: "track-tuning",
+            label: "tuning",
+            detail: track.tuning
+              ? tuningLabel(track.tuning)
+              : `song · ${tuningLabel(context.score.tuning)}`,
+            help: "this track's tuning, or follow the song",
+            build: trackTuningNodes,
+          },
+        ]
+      : [];
   return [
     ...parameterNodes(context),
+    ...tuning,
+    {
+      kind: "menu",
+      id: "performance",
+      label: "performance",
+      detail: performanceDetail(focused(context)),
+      help: "articulation, glide, bend, vibrato, pedal, velocity curve, humanize",
+      build: performanceNodes,
+    },
     {
       kind: "menu",
       id: "browse",
@@ -464,9 +546,186 @@ function mixSectionNodes(context: MenuContext): MenuNode[] {
       help: "points that move a value over the loop",
       build: automationNodes,
     },
+    {
+      kind: "menu",
+      id: "master",
+      label: "master",
+      detail: context.score.master
+        ? describeMaster(context.score.master)
+        : "off · bypass",
+      help: "the song master on the summed mix: EQ, glue, tape, width, limiter",
+      build: masterNodes,
+    },
   ];
 }
 
+/** Mix & automation > 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
+  // other name shares them (apple and podcast are both -16 at -1 dBTP).
+  const matches = LOUDNESS_TARGET_NAMES.filter(
+    (name) =>
+      LOUDNESS_TARGETS[name].lufs === master?.target &&
+      LOUDNESS_TARGETS[name].ceiling ===
+        (master?.limiter?.ceiling ?? MASTER_LIMITS.safeCeiling),
+  );
+  const named =
+    matches.length === 1
+      ? matches[0]
+      : matches.length > 1
+        ? `${num(master!.target!)} LUFS`
+        : undefined;
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "target",
+      value: master?.target === undefined ? "off" : (named ?? "custom"),
+      options: ["off", ...LOUDNESS_TARGET_NAMES],
+      command: (name) => `master target ${name}`,
+      help: "named loudness target; loud ones also load a fast limiter",
+    },
+    {
+      kind: "number",
+      label: "target LUFS",
+      value: master?.target,
+      start: -14,
+      off: "off",
+      min: MASTER_LIMITS.minTarget,
+      max: MASTER_LIMITS.maxTarget,
+      step: (value, direction) =>
+        clamp(
+          Math.round((value + direction * 0.5) * 2) / 2,
+          MASTER_LIMITS.minTarget,
+          MASTER_LIMITS.maxTarget,
+        ),
+      format: (value) => `${num(value)} LUFS`,
+      command: (value) => `master target ${num(value)}`,
+      reset: "master target off",
+      help: "integrated loudness renders normalize to (EBU R 128 / BS.1770)",
+    },
+  ];
+  for (const unit of MASTER_UNITS) {
+    const spec = MASTER_SPECS[unit];
+    const values = master?.[unit];
+    nodes.push({
+      kind: "menu",
+      id: `master:${unit}`,
+      label: unit,
+      detail: values ? describeUnit(unit, values) : "off",
+      help: spec.doc,
+      build: (inner) => masterUnitNodes(inner, unit, false),
+    });
+  }
+  nodes.push({
+    kind: "action",
+    label: "measure the mix",
+    command: "master measure",
+    help: "render and report LUFS, true peak, LRA, balance and correlation",
+  });
+  if (master)
+    nodes.push({
+      kind: "action",
+      label: "remove master",
+      command: "master off",
+      help: "bypass: the mix renders exactly as without a master",
+    });
+  return nodes;
+}
+
+/** One master unit: on/off, preset, its simple params, then `advanced`. */
+function masterUnitNodes(
+  context: MenuContext,
+  unit: MasterUnit,
+  advanced: boolean,
+): MenuNode[] {
+  const spec = MASTER_SPECS[unit];
+  const values = context.score.master?.[unit];
+  const nodes: MenuNode[] = [];
+  if (!advanced) {
+    nodes.push({
+      kind: "toggle",
+      label: "on",
+      value: values !== undefined,
+      command: (on) => `master ${unit} ${on ? "on" : "off"}`,
+      help: `switch the master ${spec.label} on or off`,
+    });
+    const presets = Object.keys(MASTER_PRESETS[unit]);
+    if (presets.length > 0)
+      nodes.push({
+        kind: "choice",
+        label: "preset",
+        value: "—",
+        options: presets,
+        command: (preset) => `master ${unit} preset ${preset}`,
+        help: "a starting point; every value stays editable",
+      });
+  }
+  const keys = advanced ? Object.keys(spec.params) : spec.simple;
+  for (const key of keys) {
+    const param = spec.params[key]!;
+    const current = values?.[key];
+    // With a target the search sets the limiter's drive; its gain is unused.
+    if (
+      unit === "limiter" &&
+      key === "gain" &&
+      context.score.master?.target !== undefined
+    ) {
+      nodes.push({ kind: "info", label: key, value: "set by target" });
+      continue;
+    }
+    if (param.kind === "number") {
+      nodes.push({
+        kind: "number",
+        label: key,
+        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) =>
+          `master ${unit} ${key} ${formatParam(param, value)}`,
+        help: param.doc,
+        ...(values
+          ? {
+              reset: `master ${unit} ${key} ${formatParam(param, param.default)}`,
+            }
+          : {}),
+      });
+    } else if (param.kind === "enum") {
+      nodes.push({
+        kind: "choice",
+        label: key,
+        value: typeof current === "string" ? current : param.default,
+        options: param.values,
+        command: (option) => `master ${unit} ${key} ${option}`,
+        help: param.doc,
+      });
+    } else {
+      nodes.push({
+        kind: "toggle",
+        label: key,
+        value: typeof current === "boolean" ? current : param.default,
+        command: (on) => `master ${unit} ${key} ${on ? "on" : "off"}`,
+        help: param.doc,
+      });
+    }
+  }
+  if (!advanced && Object.keys(spec.params).length > spec.simple.length)
+    nodes.push({
+      kind: "menu",
+      id: `master:${unit}:advanced`,
+      label: "advanced",
+      detail: `all ${Object.keys(spec.params).length} params`,
+      build: (inner) => masterUnitNodes(inner, unit, true),
+    });
+  return nodes;
+}
+
 function chordsDetail(context: MenuContext): string {
   const chords = context.chords ?? defaultChordSettings();
   const key = parseKey(context.score.key ?? undefined);
@@ -478,7 +737,8 @@ 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";
+  // A library scale (D hijaz, C yaman) survives a tonic change.
+  const mode: string = key?.scale ?? key?.mode ?? "major";
   const presets = PROGRESSION_PRESETS.map((preset) => preset.name);
   return [
     {
@@ -500,9 +760,9 @@ function chordNodes(context: MenuContext): MenuNode[] {
     {
       kind: "choice",
       label: "key mode",
-      help: "major, minor or a church mode",
+      help: "major, minor, a church mode or any library scale",
       value: mode,
-      options: MODE_NAMES,
+      options: [...MODE_NAMES, ...SCALE_NAMES],
       command: (option) => `key ${tonic} ${option}`,
     },
     {
@@ -1310,7 +1570,7 @@ function laneNodes(
       value: "two points",
       placeholder: "from-beat:value to-beat:value",
       command: (text) => pointsCommand(lane, text, 2),
-      example: `automate ${lane} points 0:${laneFormat(lane, min)} ${context.score.beatsPerBar * context.score.bars}:${laneFormat(lane, max)}`,
+      example: `automate ${lane} points 0:${laneFormat(lane, min)} ${loopTicksOf(context.score) / context.score.ticksPerBeat}:${laneFormat(lane, max)}`,
     },
   ];
   for (const point of points)
@@ -1506,9 +1766,10 @@ function transportNodes(context: MenuContext): MenuNode[] {
       min: 1,
       max: SCORE_LIMITS.maxBeatsPerBar,
       step: linear(1, 1, SCORE_LIMITS.maxBeatsPerBar),
-      format: (value) => `${value}/4`,
-      command: (value) => `meter ${Math.round(value)}`,
+      format: (value) => `${value}/${openingUnit(score)}`,
+      command: (value) => openingMeterCommand(score, value),
     },
+    tempoMenuNode(context),
     {
       kind: "number",
       label: "loop length",
@@ -1543,7 +1804,224 @@ function transportNodes(context: MenuContext): MenuNode[] {
       options: ["0", "1", "2"],
       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,
+    },
+  ];
+}
+
+// ── tuning ────────────────────────────────────────────────────────────
+
+/** Short name of a tuning for a choice row: its library name or table. */
+function tuningLabel(tuning: Tuning | undefined): string {
+  if (!tuning) return "12-tet";
+  if (tuning.name) return tuning.name;
+  if (tuning.edo) return `${tuning.edo}-edo`;
+  if (tuning.scl) return tuning.scl.split("/").at(-1)!;
+  if (tuning.ratios || tuning.cents) return "custom";
+  return "12-tet";
+}
+
+function keyLabel(key: string | null | undefined): string {
+  const parsed = parseKey(key ?? undefined);
+  return parsed ? keyName(parsed) : "no key";
+}
+
+const ROOT_OPTIONS = [
+  "auto",
+  "C4",
+  "Db4",
+  "D4",
+  "Eb4",
+  "E4",
+  "F4",
+  "Gb4",
+  "G4",
+  "Ab4",
+  "A4",
+  "Bb4",
+  "B4",
+] as const;
+
+/** Rows shared by the song and track tuning screens. */
+function tuningRows(
+  tuning: Tuning | undefined,
+  prefix: string,
+  first: MenuNode,
+  song?: Tuning,
+): MenuNode[] {
+  // A track screen shows the song's ref and root where the track has none.
+  const ref = tuning?.ref ?? song?.ref;
+  const refFrom =
+    tuning?.ref === undefined && ref !== undefined ? " · song" : "";
+  const root = tuning?.root ?? song?.root;
+  const rootFrom =
+    tuning?.root === undefined && root !== undefined ? " · song" : "";
+  const nodes: MenuNode[] = [
+    first,
+    {
+      kind: "info",
+      label: "steps (cents)",
+      value: tuningStepsText(tuning),
+      help: describeTuning(tuning),
+    },
+    {
+      kind: "number",
+      label: "reference A4",
+      help: "12-TET A4 in Hz; the root sounds at its 12-TET pitch from it · x: 440",
+      value: ref,
+      off: "440 Hz",
+      start: 440,
+      min: TUNING_LIMITS.minRefHz,
+      max: TUNING_LIMITS.maxRefHz,
+      step: linear(1, TUNING_LIMITS.minRefHz, TUNING_LIMITS.maxRefHz),
+      format: (value) => `${num(value)} Hz${refFrom}`,
+      command: (value) => `${prefix} ref ${num(value)}`,
+      reset: `${prefix} ref off`,
+    },
+    {
+      kind: "choice",
+      label: "root",
+      help: song
+        ? `the key that plays degree 0; auto follows the song tuning's root${rootFrom ? " (now the song's)" : ""}`
+        : "the key that plays degree 0; auto follows the song key",
+      value: rootName(root),
+      options: ROOT_OPTIONS,
+      command: (option) => `${prefix} root ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "keys",
+      help: "linear: one key per step (Scala) · nearest: each of 12 keys to its nearest step",
+      value: tuning?.map ?? "linear",
+      options: TUNING_MAPS,
+      command: (option) => `${prefix} map ${option}`,
+    },
+    {
+      kind: "entry",
+      label: "equal steps",
+      value: tuning?.edo ? String(tuning.edo) : "",
+      placeholder: "steps per octave, e.g. 22",
+      command: (text) =>
+        /^\d+$/.test(text.trim()) ? `${prefix} edo ${text.trim()}` : undefined,
+      example: `${prefix} edo 22`,
+      help: "n equal divisions of the octave",
+    },
+    {
+      kind: "entry",
+      label: "Scala file",
+      value: tuning?.scl ?? "",
+      placeholder: "path to a .scl file",
+      command: (text) =>
+        text.trim() ? `${prefix} scl ${text.trim()}` : undefined,
+      example: `${prefix} scl tunings/meantone.scl`,
+      help: "a Scala scale; files outside the project are copied into tunings/",
+    },
+    {
+      kind: "entry",
+      label: "ratios",
+      value: tuning?.ratios?.join(" ") ?? "",
+      placeholder: "just ratios, the last is the period",
+      command: (text) =>
+        text.trim() ? `${prefix} ratios ${text.trim()}` : undefined,
+      example: `${prefix} ratios 9/8 5/4 3/2 2/1`,
+      help: "a just-intonation table: ratios for degrees 1..n",
+    },
+    {
+      kind: "entry",
+      label: "cents",
+      value: tuning?.cents && !tuning.scl ? tuning.cents.join(" ") : "",
+      placeholder: "cents, the last is the period",
+      command: (text) =>
+        /^[-+\d.\s]+$/.test(text.trim())
+          ? `${prefix} cents ${text.trim()}`
+          : undefined,
+      example: `${prefix} cents 231 474 717 955 1200`,
+      help: "a table in cents for degrees 1..n",
+    },
+    {
+      kind: "entry",
+      label: "keyboard map (.kbm)",
+      value: tuning?.kbm ?? "",
+      placeholder: "path to a .kbm file, or off",
+      command: (text) =>
+        text.trim() ? `${prefix} kbm ${text.trim()}` : undefined,
+      example: `${prefix} kbm tunings/white.kbm`,
+      help: "a Scala keyboard map: which key plays which degree; off removes it",
+    },
   ];
+  return nodes;
+}
+
+/** Project › tuning & scale: the song tuning and the song scale. */
+function songTuningNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const key = parseKey(score.key ?? undefined);
+  const scale = key ? (key.scale ?? key.mode) : "major";
+  const tonic = key ? keyName(key).split(" ")[0]! : "C";
+  return [
+    ...tuningRows(score.tuning, "tuning", {
+      kind: "choice",
+      label: "tuning",
+      help: "the song tuning; every track without its own follows it",
+      value: tuningLabel(score.tuning),
+      options: TUNING_NAMES,
+      command: (option) =>
+        option === "12-tet" ? "tuning off" : `tuning ${option}`,
+    }),
+    {
+      kind: "choice",
+      label: "scale",
+      help: "the song scale: modes, minors, pentatonics, maqam, ragas, Messiaen",
+      value: scale,
+      options: [...MODE_NAMES, ...SCALE_NAMES],
+      command: (option) => `scale ${option}`,
+    },
+    {
+      kind: "choice",
+      label: "tonic",
+      help: "the song key's tonic; keeps the scale",
+      value: tonic,
+      options: TONICS,
+      command: (option) => `scale ${option} ${scale}`,
+    },
+    {
+      kind: "action",
+      label: "list tunings",
+      command: "tuning list",
+      help: "every library tuning, by family",
+    },
+    {
+      kind: "action",
+      label: "list scales",
+      command: "scale list",
+      help: "every mode and scale, by family",
+    },
+  ];
+}
+
+/** Sound › tuning: the focused track's own tuning, or the song's. */
+function trackTuningNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  return tuningRows(
+    track?.tuning,
+    "tuning track",
+    {
+      kind: "choice",
+      label: "tuning",
+      help: "song: follow the song tuning · or a tuning for this track only",
+      value: track?.tuning ? tuningLabel(track.tuning) : "song",
+      options: ["song", ...TUNING_NAMES],
+      command: (option) =>
+        option === "song" ? "tuning track off" : `tuning track ${option}`,
+    },
+    context.score.tuning ?? {},
+  );
 }
 
 // ── controller ────────────────────────────────────────────────────────
@@ -1639,6 +2117,88 @@ export class EditMenu {
     }
   }
 
+  /**
+   * Open on the level a bare parameter command edits, for the fader drawer:
+   * `volume` / `pan` (Mix), `fx filter` / `fx filter cutoff` (that effect,
+   * in Effects or its "more effects" list). Returns the label to focus, or
+   * undefined when `command` names no such parameter (the menu is closed).
+   */
+  showFader(context: MenuContext, command: string): string | undefined {
+    const words = command.trim().replace(/^\//, "").toLowerCase().split(/\s+/);
+    if (words.length === 1 && (words[0] === "volume" || words[0] === "pan")) {
+      this.show(context, "mix");
+      if (this.stack.length < 2) return this.fail();
+      return this.focusLabel(context, words[0]) ?? this.fail();
+    }
+    if (words[0] !== "fx" || words.length < 2 || words.length > 3)
+      return undefined;
+    const effect = parseEffectName(words[1]!);
+    if (!effect) return undefined;
+    const param = words[2] ? parseParamName(effect, words[2]) : undefined;
+    if (words[2] && !param) return undefined;
+    this.show(context, "effects");
+    if (this.stack.length < 2) return this.fail();
+    if (!this.descend(context, effect)) {
+      if (
+        !this.descend(context, "more effects") ||
+        !this.descend(context, effect)
+      )
+        return this.fail();
+    }
+    const fields = this.faderFields(context);
+    const label = param
+      ? fields.find((field) => field.label === param)?.label
+      : fields.find((field) => field.kind === "number")?.label;
+    if (!label) return this.fail();
+    return this.focusLabel(context, label) ?? this.fail();
+  }
+
+  private fail(): undefined {
+    this.close();
+    return undefined;
+  }
+
+  /** Step into the child menu `id` of the current level. */
+  private descend(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;
+  }
+
+  /** Put the cursor on the row labelled `label`; returns it when found. */
+  private focusLabel(context: MenuContext, label: string): string | undefined {
+    const frame = this.stack.at(-1);
+    if (!frame) return undefined;
+    const index = frame
+      .build(context)
+      .findIndex((node) => node.label === label);
+    if (index < 0) return undefined;
+    frame.index = index;
+    return label;
+  }
+
+  /** Select row `index` of the current level (a click), clearing typing. */
+  select(context: MenuContext, index: number): void {
+    const frame = this.stack.at(-1);
+    if (!frame) return;
+    this.entry = undefined;
+    this.filtering = false;
+    frame.index = clamp(index, 0, Math.max(0, this.nodes(context).length - 1));
+  }
+
+  /** The row index under the cursor (the picker's). */
+  get index(): number {
+    return this.stack.at(-1)?.index ?? 0;
+  }
+
   close(): void {
     this.stack = [];
     this.filtering = false;
@@ -1821,11 +2381,8 @@ export class EditMenu {
         });
         return { type: "handled" };
       }
-      if (
-        node.kind === "entry" ||
-        node.kind === "number" ||
-        node.kind === "point"
-      ) {
+      if (node.kind === "number") return { type: "fader", label: node.label };
+      if (node.kind === "entry" || node.kind === "point") {
         this.entry = { label: node.label, buffer: "" };
         return { type: "handled" };
       }
@@ -1926,6 +2483,33 @@ export class EditMenu {
     return { type: "handled" };
   }
 
+  /**
+   * The current level's number and choice rows as fader fields (the drawer's
+   * related params: every filter control, every reverb control), built
+   * from `context` (the staged score while auditioning).
+   */
+  faderFields(context: MenuContext): FaderSpec[] {
+    const frame = this.stack.at(-1);
+    if (!frame) return [];
+    return faderSpecs(frame.build(context));
+  }
+
+  /** The same fields as committed, for the drawer's `staged ← committed`. */
+  faderCommitted(context: MenuContext): FaderSpec[] {
+    const audition = context.audition;
+    if (!audition?.dirty) return this.faderFields(context);
+    return this.faderFields({
+      ...context,
+      score: audition.committed,
+      ...(audition.committedChords ? { chords: audition.committedChords } : {}),
+    });
+  }
+
+  /** The breadcrumb, for the drawer's title. */
+  get crumbs(): string {
+    return this.stack.map((level) => level.title).join(" › ");
+  }
+
   /** The picker the TUI draws for the current level. */
   view(context: MenuContext): MenuView {
     const frame = this.stack.at(-1);
@@ -2023,6 +2607,37 @@ function placeholderFor(node: MenuNode | undefined): string {
   return "";
 }
 
+/** Menu rows → fader fields: numbers and choices, in row order. */
+export function faderSpecs(nodes: readonly MenuNode[]): FaderSpec[] {
+  const fields: FaderSpec[] = [];
+  for (const node of nodes) {
+    if (node.kind === "number")
+      fields.push({
+        kind: "number",
+        label: node.label,
+        value: node.value,
+        min: node.min,
+        max: node.max,
+        step: node.step,
+        format: node.format,
+        command: node.command,
+        parse: (text) => entryCommand(node, text),
+        reset: node.reset,
+        start: node.start,
+        off: node.off,
+      });
+    else if (node.kind === "choice")
+      fields.push({
+        kind: "choice",
+        label: node.label,
+        value: node.value,
+        options: node.options,
+        command: node.command,
+      });
+  }
+  return fields;
+}
+
 function entryCommand(node: MenuNode, text: string): string | undefined {
   const trimmed = text.trim();
   if (node.kind === "entry") return node.command(trimmed);
@@ -2134,11 +2749,17 @@ export const MENU_SECTIONS = [
   "rhythm",
   "chords",
   "mix",
+  "master",
   "project",
+  "arrange",
   // Older names, still accepted.
   "parameters",
   "sounds",
   "track",
   "automation",
   "transport",
+  // Subsections.
+  "tempo",
+  "meter",
+  "time",
 ] as const;