@hraness/dawg 0.4.1 → 0.6.0

package/src/tui/menu.ts

@@ -10,12 +10,23 @@
  */
 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 { malletsMenu, modalParameterNodes } from "./modal-menu.ts";
+import type { FaderSpec } from "./fader.ts";
+import {
+  openingMeterCommand,
+  openingUnit,
+  tempoDetail,
+  tempoMenuNode,
+} from "./menu-time.ts";
 import {
   AUTOMATION_PARAMETERS,
   automationPoints,
   automationRange,
   REVERB_IR_BUILTINS,
+  SAMPLE_FIT_MODES,
   SAMPLE_UNITS,
   SCORE_LIMITS,
   isTrackAutomationParameter,
@@ -33,6 +44,9 @@ import {
   CORE_EFFECTS,
   EFFECT_NAMES,
   FX_LANES,
+  RIG_PRESETS,
+  RIG_STAGES,
+  rigPresetOf,
   effectPresetNames,
   effectSpec,
   type EffectName,
@@ -40,7 +54,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 +82,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,
@@ -60,6 +90,22 @@ import {
   SYNTH_SIMPLE,
   normalizeSynth,
 } from "../../core/synth.ts";
+import {
+  isStringTrack,
+  STRING_PARAMS,
+  STRING_PRESET_NAMES,
+  STRING_PRESETS,
+  STRING_SIMPLE_PARAMS,
+  stringPresetOf,
+} from "../../core/strings.ts";
+import {
+  KEYS_PARAMS,
+  KEYS_PRESETS,
+  KEYS_SIMPLE,
+  PIANO_FAMILIES,
+  isPianoFamily,
+  resolvedKeys,
+} from "../../core/keys.ts";
 import type { PickerItem } from "../../tui/app.ts";
 import { BUILTIN_TABLES, BUILTIN_TABLE_NAMES } from "../audio/wavetable.ts";
 import {
@@ -76,10 +122,25 @@ 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 {
+  granularBrowseNodes,
+  granularMenuDetail,
+  granularMenuLabel,
+  granularMenuNodes,
+} from "./granular-menu.ts";
 import {
   ARP_RATES,
   CHORD_MODES,
@@ -215,6 +276,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<{
@@ -285,7 +348,7 @@ const TRACK_LANE_LABEL: Readonly<Record<TrackAutomationParameter, string>> = {
 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(
+export function specStep(
   spec: NumberParam,
 ): (value: number, direction: 1 | -1) => number {
   if (spec.step === "log")
@@ -318,7 +381,12 @@ function laneLabel(lane: AutomationParameter): string {
   if (!info) return lane;
   const unit = info.spec.unit ? ` (${info.spec.unit})` : "";
   const owner =
-    info.effect === "synth" ? "synth" : effectSpec(info.effect).label;
+    info.effect === "synth" ||
+    info.effect === "string" ||
+    info.effect === "keys" ||
+    info.effect === "modal"
+      ? info.effect
+      : effectSpec(info.effect).label;
   return `${owner} ${info.param}${unit}`;
 }
 
@@ -389,10 +457,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 +479,90 @@ 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,
+          },
+        ]
+      : [];
+  const grainLabel = granularMenuLabel(track);
+  const granular: MenuNode[] =
+    track && grainLabel
+      ? [
+          {
+            kind: "menu",
+            id: "granular",
+            label: grainLabel,
+            detail: granularMenuDetail(track),
+            help: "grain clouds: preset, source, position, scan, grain size, pitch, shimmer",
+            build: (inner) => granularMenuNodes(focused(inner)),
+          },
+        ]
+      : [];
+  const keys: MenuNode[] =
+    track && isPianoFamily(track.instrument) && track.keys
+      ? [
+          {
+            kind: "menu",
+            id: "keys",
+            label: "keys",
+            detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
+            help: "the modelled piano: preset, touch, hammers, dampers, stretch",
+            build: (inner) => {
+              const current = focused(inner);
+              return current
+                ? keysNodes(current, Object.keys(KEYS_PARAMS))
+                : [];
+            },
+          },
+        ]
+      : [];
   return [
     ...parameterNodes(context),
+    ...granular,
+    ...keys,
+    ...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,7 +612,184 @@ 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 {
@@ -478,7 +803,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 +826,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}`,
     },
     {
@@ -643,7 +969,7 @@ function trackNodes(context: MenuContext): MenuNode[] {
 }
 
 function instrumentNode(track: Track): MenuNode {
-  const options: string[] = [...AVAILABLE_INSTRUMENTS];
+  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...PIANO_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
   return {
     kind: "choice",
@@ -696,6 +1022,30 @@ function parameterNodes(context: MenuContext): MenuNode[] {
   // A wavetable track also has the synth voice's envelope, filters and FM.
   if (isWavetableInstrument(track.instrument))
     nodes.push(...wavetableNodes(track, context.projectRoot));
+  if (isStringTrack(track)) {
+    nodes.push(...stringNodes(track, STRING_SIMPLE_PARAMS));
+    nodes.push({
+      kind: "menu",
+      id: "string:advanced",
+      label: "advanced",
+      detail: `all ${Object.keys(STRING_PARAMS).length} params`,
+      help: "every string parameter: exciter, loss, body, buzz, sympathetics",
+      build: (inner) => {
+        const current = focused(inner);
+        return current
+          ? stringNodes(current, Object.keys(STRING_PARAMS), false)
+          : [];
+      },
+    });
+    if (Object.keys(track.string ?? {}).some((key) => key !== "preset"))
+      nodes.push({
+        kind: "action",
+        label: "reset to preset",
+        command: "string reset",
+        help: "drop this track's string overrides, keep the preset",
+      });
+    return nodes;
+  }
   if (track.sampler) {
     nodes.push({
       kind: "info",
@@ -722,6 +1072,22 @@ function parameterNodes(context: MenuContext): MenuNode[] {
       label: "add a voice",
       value: "/sample <path> [as <voice>]",
     });
+  } else if (isPianoFamily(track.instrument) && track.keys) {
+    nodes.push(...keysNodes(track, KEYS_SIMPLE));
+    nodes.push({
+      kind: "menu",
+      id: "keys:all",
+      label: "all piano params",
+      detail: `all ${Object.keys(KEYS_PARAMS).length} params`,
+      help: "every modelled piano parameter",
+      build: (inner) => {
+        const current = focused(inner);
+        return current ? keysNodes(current, Object.keys(KEYS_PARAMS)) : [];
+      },
+    });
+  } else if (track.instrument === "modal") {
+    // 0.6 modal percussion: preset, mallet and MODAL_PARAMS rows.
+    nodes.push(...modalParameterNodes(track));
   } else if (!isDrumInstrument(track.instrument)) {
     nodes.push(...synthNodes(track, SYNTH_SIMPLE));
     nodes.push({
@@ -829,6 +1195,44 @@ function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
       label: "cut / loopAt",
       value: `/sample set ${voice} cut hats · loopAt 2`,
     },
+    // 0.6 fit: the sample's own tempo, its length in beats, and how it fits.
+    {
+      kind: "number",
+      label: "bpm",
+      value: ref.bpm,
+      start: Math.round(context.score.tempoBpm),
+      off: "off",
+      min: SCORE_LIMITS.minSampleBpm,
+      max: SCORE_LIMITS.maxSampleBpm,
+      step: linear(1, SCORE_LIMITS.minSampleBpm, SCORE_LIMITS.maxSampleBpm),
+      format: num,
+      command: (value) => `/bpm ${num(value)} ${voice}`,
+      reset: `/bpm off ${voice}`,
+      help: SAMPLE_CONTROLS.bpm,
+    },
+    {
+      kind: "choice",
+      label: "fitmode",
+      // off: unset (plays as repitch); auto suggests one from the sound.
+      value: ref.fitmode ?? "off",
+      options: ["off", ...SAMPLE_FIT_MODES, "auto"],
+      command: (option) => `/fitmode ${option} ${voice}`,
+      help: `${SAMPLE_CONTROLS.fitmode} · beats for drums, tones for pads · set bpm or len first`,
+    },
+    {
+      kind: "number",
+      label: "len",
+      value: ref.len,
+      start: 4,
+      off: "off",
+      min: 0.25,
+      max: SCORE_LIMITS.maxSampleLenBeats,
+      step: linear(0.25, 0.25, SCORE_LIMITS.maxSampleLenBeats),
+      format: num,
+      command: (value) => `/len ${num(value)} ${voice}`,
+      reset: `/len off ${voice}`,
+      help: SAMPLE_CONTROLS.len,
+    },
   );
   return nodes;
 }
@@ -845,6 +1249,57 @@ function matchingSynthPreset(track: Track): string | undefined {
   )?.[0];
 }
 
+/** Modelled piano rows: the preset, then each parameter (`keys <p> <v>`). */
+function keysNodes(track: Track, params: readonly string[]): MenuNode[] {
+  const effective = resolvedKeys(track.instrument, track.keys);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: track.keys?.preset ?? "—",
+      options: Object.keys(KEYS_PRESETS),
+      command: (preset) => `keys preset ${preset}`,
+      help: "a starting piano; every value stays editable",
+    },
+  ];
+  for (const key of params) {
+    const param = KEYS_PARAMS[key]!;
+    const stored = track.keys?.[key];
+    if (param.kind === "number") {
+      const base = effective[key] as number;
+      nodes.push({
+        kind: "number",
+        label: key,
+        value: typeof stored === "number" ? stored : undefined,
+        start: base,
+        off: withUnit(formatParam(param, base), param.unit),
+        min: param.min,
+        max: param.max,
+        step: specStep(param),
+        format: (value) => withUnit(formatParam(param, value), param.unit),
+        command: (value) => `keys ${key} ${formatParam(param, value)}`,
+        reset: `keys ${key} off`,
+        help: param.doc,
+      });
+    } else if (param.kind === "enum")
+      nodes.push({
+        kind: "choice",
+        label: key,
+        value: typeof stored === "string" ? stored : String(effective[key]),
+        options: param.values,
+        command: (option) => `keys ${key} ${option}`,
+        help: param.doc,
+      });
+  }
+  nodes.push({
+    kind: "action",
+    label: "reset to the family",
+    command: "keys reset",
+    help: "clear every override and the preset, and the effects the preset added (keeps the family's own sound)",
+  });
+  return nodes;
+}
+
 function synthNodes(track: Track, keys: readonly string[]): MenuNode[] {
   const nodes: MenuNode[] = [];
   if (keys === SYNTH_SIMPLE)
@@ -915,6 +1370,57 @@ const SYNTH_LABEL: Readonly<Record<string, string>> = {
   fm: "FM amount",
 };
 
+/** String preset first (simple view), then one row per parameter. */
+function stringNodes(
+  track: Track,
+  keys: readonly string[],
+  withPreset = true,
+): MenuNode[] {
+  const nodes: MenuNode[] = [];
+  const preset = STRING_PRESETS[stringPresetOf(track.string)]!;
+  if (withPreset)
+    nodes.push({
+      kind: "choice",
+      label: "preset",
+      help: preset.doc,
+      value: stringPresetOf(track.string),
+      options: STRING_PRESET_NAMES,
+      command: (name) => `string preset ${name}`,
+    });
+  for (const key of keys) {
+    const param = STRING_PARAMS[key]!;
+    const own = track.string?.[key];
+    const base = preset.values[key] ?? param.default;
+    if (param.kind === "number")
+      nodes.push({
+        kind: "number",
+        label: param.unit ? `${key} ${param.unit}` : key,
+        help: param.doc,
+        value: typeof own === "number" ? own : undefined,
+        start: typeof base === "number" ? base : param.default,
+        off: formatParam(
+          param,
+          typeof base === "number" ? base : param.default,
+        ),
+        min: param.min,
+        max: param.max,
+        step: specStep(param),
+        format: (value) => formatParam(param, value),
+        command: (value) => `string ${key} ${formatParam(param, value)}`,
+      });
+    else if (param.kind === "enum")
+      nodes.push({
+        kind: "choice",
+        label: key,
+        help: param.doc,
+        value: typeof own === "string" ? own : String(base),
+        options: param.values,
+        command: (option) => `string ${key} ${option}`,
+      });
+  }
+  return nodes;
+}
+
 /** Every synth parameter, grouped (amplitude, oscillator, FM 1..8, …). */
 function synthAdvancedNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
@@ -1064,10 +1570,38 @@ function effectNodes(context: MenuContext): MenuNode[] {
       build: (inner) => effectParamNodes(inner, effect, false),
     };
   };
-  const more = EFFECT_NAMES.filter((effect) => !CORE_EFFECTS.includes(effect));
+  const rigStages = RIG_STAGES as readonly string[];
+  const more = EFFECT_NAMES.filter(
+    (effect) => !CORE_EFFECTS.includes(effect) && !rigStages.includes(effect),
+  );
   const moreOn = more.filter((effect) => effectValues(track, effect));
+  // 0.6 guitar rig: stomp → head (with its gate) → cab, plus whole rigs.
+  const rigOn = RIG_STAGES.filter((stage) => effectValues(track, stage));
+  const rig: MenuNode = {
+    kind: "menu",
+    id: "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(" → ")),
+    build: (inner) => {
+      const current = focused(inner);
+      return [
+        {
+          kind: "choice",
+          label: "rig",
+          value: rigPresetOf(current?.fx) ?? "—",
+          options: [...Object.keys(RIG_PRESETS), "reset"],
+          command: (name) => `rig ${name}`,
+          help: "a whole rig (stomp, head, cab); every stage stays editable",
+        },
+        ...RIG_STAGES.map(node),
+      ];
+    },
+  };
   return [
     ...CORE_EFFECTS.map(node),
+    rig,
     {
       kind: "menu",
       id: "more effects",
@@ -1235,6 +1769,9 @@ function automationNodes(context: MenuContext): MenuNode[] {
     const info = FX_LANE_INFO.get(lane as FxLane);
     if (info?.effect === "synth")
       return track.synth?.[info.param] !== undefined;
+    if (info?.effect === "string") return track.string !== undefined;
+    if (info?.effect === "keys") return track.keys !== undefined;
+    if (info?.effect === "modal") return track.modal !== undefined;
     return info !== undefined && effectValues(track, info.effect) !== undefined;
   });
   const hidden = AUTOMATION_PARAMETERS.filter((lane) => !shown.includes(lane));
@@ -1310,7 +1847,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)
@@ -1416,14 +1953,54 @@ function patternsMenu(): MenuNode {
   };
 }
 
+const GRANULAR_PRESETS_COUNT = granularBrowseNodes().length;
+
 function soundNodes(): MenuNode[] {
   return [
+    {
+      kind: "menu",
+      id: "group:keys",
+      label: "Keys",
+      help: "modelled pianos, built in (no download)",
+      detail: Object.keys(KEYS_PRESETS).join(" "),
+      build: () =>
+        Object.entries(KEYS_PRESETS).map(([name, preset]): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(10)} ${preset.doc}`,
+          command: `piano ${name}`,
+          help: preset.styles,
+        })),
+    },
     {
       kind: "action",
       label: "wavetable synth  basic shapes morph · built-in",
       command: "wt basic",
       help: "switch this track to the morphing wavetable synth",
     },
+    // 0.6 instrument groups, one per lane.
+    malletsMenu(),
+    {
+      kind: "menu",
+      id: "strings",
+      label: "Strings",
+      help: "plucked strings: guitars, basses, sitar, harpsichord, oud, koto…",
+      detail: `${STRING_PRESET_NAMES.length} plucked · built-in`,
+      build: () =>
+        STRING_PRESET_NAMES.map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(12)} ${STRING_PRESETS[name]!.doc}`,
+          command: `string ${name}`,
+          help: STRING_PRESETS[name]!.styles,
+        })),
+    },
+    {
+      kind: "menu",
+      id: "granular-browse",
+      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,
+    },
     {
       kind: "menu",
       id: "instruments",
@@ -1506,9 +2083,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,9 +2121,226 @@ 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 ────────────────────────────────────────────────────────
 
 type Frame = {
@@ -1639,6 +2434,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;
@@ -1812,20 +2689,23 @@ export class EditMenu {
                     candidate.kind === "choice" &&
                     candidate.label === node.label,
                 ) ?? node;
-            return live.options.map((option) => ({
-              kind: "action",
-              label: option === live.value ? `${option}  ✓` : option,
-              command: live.command(option),
-            }));
+            // The current value is shown, not re-run: re-confirming a
+            // legacy `piano` would otherwise re-voice it as the grand.
+            return live.options.map((option): MenuNode =>
+              option === live.value
+                ? { kind: "info", label: `${option}  ✓`, value: "current" }
+                : {
+                    kind: "action",
+                    label: option,
+                    command: live.command(option),
+                  },
+            );
           },
         });
         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 +2806,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 +2930,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 +3072,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;