@hraness/dawg 0.5.0 → 0.6.1

package/src/tui/menu.ts

@@ -13,6 +13,8 @@ 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 { windParameterNodes, windsMenu } from "./wind-menu.ts";
 import type { FaderSpec } from "./fader.ts";
 import {
   openingMeterCommand,
@@ -25,6 +27,7 @@ import {
   automationPoints,
   automationRange,
   REVERB_IR_BUILTINS,
+  SAMPLE_FIT_MODES,
   SAMPLE_UNITS,
   SCORE_LIMITS,
   isTrackAutomationParameter,
@@ -42,6 +45,10 @@ import {
   CORE_EFFECTS,
   EFFECT_NAMES,
   FX_LANES,
+  RIG_PRESETS,
+  RIG_STAGES,
+  rigPresetOf,
+  SHOEGAZE_EFFECTS,
   effectPresetNames,
   effectSpec,
   type EffectName,
@@ -85,6 +92,35 @@ import {
   SYNTH_SIMPLE,
   normalizeSynth,
 } from "../../core/synth.ts";
+import {
+  isStringTrack,
+  STRING_PARAMS,
+  STRING_PRESET_NAMES,
+  STRING_PRESETS,
+  BOWED_PRESET_NAMES,
+  BOW_SIMPLE_PARAMS,
+  resolveString,
+  STRING_SIMPLE_PARAMS,
+  stringPresetOf,
+} from "../../core/strings.ts";
+import {
+  KEYS_PARAMS,
+  KEYS_PRESETS,
+  KEYS_FAMILIES,
+  ORGAN_ROWS,
+  ORGAN_TEXT,
+  PIPE_REGISTRATIONS,
+  PIPE_STOPS,
+  isElectricFamily,
+  isKeysFamily,
+  isOrganFamily,
+  isPianoFamily,
+  keysParamsFor,
+  keysSimpleFor,
+  pipeStops,
+  resolvedKeys,
+  type OrganFamily,
+} from "../../core/keys.ts";
 import type { PickerItem } from "../../tui/app.ts";
 import { BUILTIN_TABLES, BUILTIN_TABLE_NAMES } from "../audio/wavetable.ts";
 import {
@@ -103,6 +139,8 @@ import {
   PROGRESSION_STYLES,
   SCALE_NAMES,
   SPREADS,
+  STROKE_PATTERN_NAMES,
+  GUITAR_TUNING_NAMES,
   keyName,
   parseKey,
 } from "../../core/chords.ts";
@@ -114,9 +152,17 @@ import {
   type Tuning,
 } from "../../core/tuning.ts";
 import { rootName, tuningStepsText } from "../commands/tuning.ts";
+import { describeGuitar } from "../commands/strum.ts";
+import {
+  granularBrowseNodes,
+  granularMenuDetail,
+  granularMenuLabel,
+  granularMenuNodes,
+} from "./granular-menu.ts";
 import {
   ARP_RATES,
   CHORD_MODES,
+  STROKE_SPEED_MS,
   defaultChordSettings,
   type ChordSettings,
 } from "./play-chords.ts";
@@ -321,7 +367,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")
@@ -354,7 +400,14 @@ 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 === "grain" ||
+    info.effect === "wind"
+      ? info.effect
+      : effectSpec(info.effect).label;
   return `${owner} ${info.param}${unit}`;
 }
 
@@ -486,8 +539,77 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
           },
         ]
       : [];
+  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 && isOrganFamily(track.instrument) && track.keys
+      ? [
+          {
+            kind: "menu",
+            id: "keys",
+            label: "keys",
+            detail: `${track.instrument}${track.keys.preset ? ` · ${track.keys.preset}` : ""}`,
+            help: "the modelled organ: preset, drawbars, registers or stops, rotary",
+            build: (inner) => {
+              const current = focused(inner);
+              return current ? organNodes(current) : [];
+            },
+          },
+        ]
+      : track && isKeysFamily(track.instrument) && track.keys
+        ? [
+            {
+              kind: "menu",
+              id: "keys",
+              label: "keys",
+              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",
+              build: (inner) => {
+                const current = focused(inner);
+                return current
+                  ? keysNodes(current, keysParamsFor(current.instrument))
+                  : [];
+              },
+            },
+          ]
+        : [];
+  // 0.6.1: fretting for strum and the guitar perform mode, on guitar-like
+  // tracks (a string voice, a rig, or a guitar setup already stored).
+  const guitar: MenuNode[] =
+    track &&
+    (track.guitar ||
+      track.string ||
+      RIG_STAGES.some((stage) => track.fx?.[stage] !== undefined))
+      ? [
+          {
+            kind: "menu",
+            id: "guitar",
+            label: "guitar",
+            detail: describeGuitar(track.guitar),
+            help: "tuning, capo, hand stretch, ringing open strings and position for strum and chords perform guitar",
+            build: (inner) => guitarNodes(focused(inner)),
+          },
+        ]
+      : [];
   return [
     ...parameterNodes(context),
+    ...granular,
+    ...keys,
+    ...guitar,
     ...tuning,
     {
       kind: "menu",
@@ -508,6 +630,84 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
   ];
 }
 
+/** Sound > guitar: Track.guitar rows plus a strum action. */
+function guitarNodes(track: Track | undefined): MenuNode[] {
+  if (!track) return [];
+  const g = track.guitar;
+  const tune = g?.tune ?? "standard";
+  const tuneName = typeof tune === "string" ? tune : tune.join(" ");
+  const int = (
+    label: string,
+    field: "capo" | "hand" | "position",
+    min: number,
+    max: number,
+    fallback: number,
+    help: string,
+  ): MenuNode => ({
+    kind: "number",
+    label,
+    help,
+    value: g?.[field] ?? fallback,
+    min,
+    max,
+    step: linear(1, min, max),
+    format: (value) => num(Math.round(value)),
+    command: (value) => `guitar ${field} ${Math.round(value)}`,
+  });
+  return [
+    {
+      kind: "choice",
+      label: "tune",
+      help: "open strings; type guitar tune D A D G A D for your own",
+      value: tuneName,
+      options: (GUITAR_TUNING_NAMES as readonly string[]).includes(tuneName)
+        ? GUITAR_TUNING_NAMES
+        : [tuneName, ...GUITAR_TUNING_NAMES],
+      command: (option) => `guitar tune ${option}`,
+    },
+    int(
+      "capo",
+      "capo",
+      0,
+      12,
+      0,
+      "capo fret; chord shapes sound this many semitones up",
+    ),
+    int("hand", "hand", 3, 6, 4, "how many frets one hand shape may span"),
+    {
+      kind: "number",
+      label: "ring",
+      help: "0 closed shapes .. 1 lets open strings ring",
+      value: g?.ring ?? 0.5,
+      min: 0,
+      max: 1,
+      step: linear(0.1, 0, 1),
+      format: (value) => num(value),
+      command: (value) => `guitar ring ${Math.round(value * 10) / 10}`,
+    },
+    int(
+      "position",
+      "position",
+      0,
+      12,
+      0,
+      "preferred fret position for voicings",
+    ),
+    {
+      kind: "action",
+      label: "strum the chords on this track",
+      command: "strum",
+      help: "replaces block chords with strummed guitar notes",
+    },
+    {
+      kind: "action",
+      label: "reset",
+      command: "guitar reset",
+      help: "standard tuning, no capo",
+    },
+  ];
+}
+
 /** Rhythm: the euclid editor, then grooves and kits. */
 function rhythmNodes(): MenuNode[] {
   return [
@@ -815,6 +1015,34 @@ function chordNodes(context: MenuContext): MenuNode[] {
       options: CHORD_PATTERNS.map((pattern) => pattern.name),
       command: (option) => `/chords pattern ${option}`,
     },
+    // Strum grid and speed only act when perform is guitar.
+    ...(chords.perform !== "guitar"
+      ? []
+      : ([
+          {
+            kind: "choice",
+            label: "strokes",
+            help: "guitar strum grid (D down, U up, d u light, x chuck, - rest); type /chords strokes D-DU-UDU for your own",
+            value: chords.strokes,
+            options: (STROKE_PATTERN_NAMES as readonly string[]).includes(
+              chords.strokes,
+            )
+              ? STROKE_PATTERN_NAMES
+              : [chords.strokes, ...STROKE_PATTERN_NAMES],
+            command: (option) => `/chords strokes ${option}`,
+          },
+          {
+            kind: "number",
+            label: "speed",
+            help: "ms a full down stroke takes (0 hits every string at once); type /chords speed 1/32b to set it in beats",
+            value: chords.speed,
+            min: STROKE_SPEED_MS.min,
+            max: STROKE_SPEED_MS.max,
+            step: linear(1, STROKE_SPEED_MS.min, STROKE_SPEED_MS.max),
+            format: (value) => `${num(value)} ms`,
+            command: (value) => `/chords speed ${Math.round(value)}ms`,
+          },
+        ] satisfies MenuNode[])),
     {
       kind: "choice",
       label: "arp rate",
@@ -903,7 +1131,7 @@ function trackNodes(context: MenuContext): MenuNode[] {
 }
 
 function instrumentNode(track: Track): MenuNode {
-  const options: string[] = [...AVAILABLE_INSTRUMENTS];
+  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...KEYS_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
   return {
     kind: "choice",
@@ -956,6 +1184,37 @@ 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,
+        resolveString(track.string).exciter === "bow"
+          ? BOW_SIMPLE_PARAMS
+          : 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, bow (pressure, speed, attack, vib, vibdelay, tremhz, sord, dyn)",
+      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",
@@ -982,6 +1241,35 @@ function parameterNodes(context: MenuContext): MenuNode[] {
       label: "add a voice",
       value: "/sample <path> [as <voice>]",
     });
+  } else if (isOrganFamily(track.instrument) && track.keys) {
+    // f061-organ: preset, Drawbars/Registers/Stops sub-menus, organ rows.
+    nodes.push(...organNodes(track));
+  } else if (isKeysFamily(track.instrument) && track.keys) {
+    nodes.push(...keysNodes(track, keysSimpleFor(track.instrument)));
+    const all = keysParamsFor(track.instrument);
+    nodes.push({
+      kind: "menu",
+      id: "keys:all",
+      label: isElectricFamily(track.instrument)
+        ? `all ${track.instrument} params`
+        : "all piano params",
+      detail: `all ${all.length} params`,
+      help: isElectricFamily(track.instrument)
+        ? "every electric keys parameter for this family"
+        : "every modelled piano parameter",
+      build: (inner) => {
+        const current = focused(inner);
+        return current
+          ? keysNodes(current, keysParamsFor(current.instrument))
+          : [];
+      },
+    });
+  } else if (track.instrument === "modal") {
+    // 0.6 modal percussion: preset, mallet and MODAL_PARAMS rows.
+    nodes.push(...modalParameterNodes(track));
+  } else if (track.instrument === "wind" && track.wind) {
+    // 0.6.1 wind engine: preset and WIND_PARAMS rows.
+    nodes.push(...windParameterNodes(track));
   } else if (!isDrumInstrument(track.instrument)) {
     nodes.push(...synthNodes(track, SYNTH_SIMPLE));
     nodes.push({
@@ -1089,10 +1377,141 @@ 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,
+    },
+    // 0.6.1 shift: pitch without changing length, formants kept or moved,
+    // and the voice's fade in and out.
+    {
+      kind: "number",
+      label: "shift",
+      value: ref.shift,
+      start: 0,
+      off: "off",
+      min: -SCORE_LIMITS.maxSampleShift,
+      max: SCORE_LIMITS.maxSampleShift,
+      step: linear(
+        1,
+        -SCORE_LIMITS.maxSampleShift,
+        SCORE_LIMITS.maxSampleShift,
+      ),
+      format: num,
+      command: (value) => `/shift ${num(value)} ${voice}`,
+      reset: `/shift off ${voice}`,
+      help: SAMPLE_CONTROLS.shift,
+    },
+    {
+      kind: "number",
+      label: "formant",
+      value: ref.formant,
+      start: 0,
+      off: "follow",
+      min: -SCORE_LIMITS.maxSampleShift,
+      max: SCORE_LIMITS.maxSampleShift,
+      step: linear(
+        1,
+        -SCORE_LIMITS.maxSampleShift,
+        SCORE_LIMITS.maxSampleShift,
+      ),
+      format: (value) => (value === 0 ? "keep" : num(value)),
+      command: (value) => set(`formant ${num(value)}`),
+      reset: set("formant off"),
+      help: `${SAMPLE_CONTROLS.formant} · needs shift`,
+    },
+    {
+      kind: "number",
+      label: "fade in",
+      value: ref.fadeInTime,
+      start: 0.01,
+      off: "off",
+      min: 0,
+      max: SCORE_LIMITS.maxSampleFadeSeconds,
+      step: linear(0.01, 0, SCORE_LIMITS.maxSampleFadeSeconds),
+      format: num,
+      command: (value) => `/fade in ${num(value)} ${voice}`,
+      reset: `/fade in off ${voice}`,
+      help: SAMPLE_CONTROLS.fadeInTime,
+    },
+    {
+      kind: "number",
+      label: "fade out",
+      value: ref.fadeTime,
+      start: 0.1,
+      off: "off",
+      min: 0,
+      max: SCORE_LIMITS.maxSampleFadeSeconds,
+      step: linear(0.05, 0, SCORE_LIMITS.maxSampleFadeSeconds),
+      format: num,
+      command: (value) => `/fade out ${num(value)} ${voice}`,
+      reset: `/fade out off ${voice}`,
+      help: SAMPLE_CONTROLS.fadeTime,
+    },
+    // 0.6.1 layers: velocity layer (SFZ lovel/hivel) and round-robin group.
+    {
+      kind: "choice",
+      label: "Velocity layer",
+      value: ref.vel ? `${ref.vel[0]}-${ref.vel[1]}` : "off",
+      options: velocityLayerOptions(ref.vel),
+      command: (option) => set(`vel ${option}`),
+      help: `${SAMPLE_CONTROLS.vel} · two layers: 0-63 and 64-127 · three: 0-42 43-84 85-127`,
+    },
+    {
+      kind: "entry",
+      label: "Round robin",
+      value: ref.rr ?? "",
+      placeholder: "group name, e.g. sn",
+      command: (text) => set(`rr ${text.trim() || "off"}`),
+      example: `/sample set ${voice} rr sn`,
+      help: SAMPLE_CONTROLS.rr,
+    },
   );
   return nodes;
 }
 
+/** Common velocity splits, plus the voice's own range when it is another. */
+function velocityLayerOptions(
+  vel: readonly [number, number] | undefined,
+): string[] {
+  const options = ["off", "0-63", "64-127", "0-42", "43-84", "85-127"];
+  const own = vel ? `${vel[0]}-${vel[1]}` : undefined;
+  return own && !options.includes(own) ? [...options, own] : options;
+}
+
 /** Synth preset first, then one row per parameter. */
 /** The preset this track's voice still matches exactly, if any. */
 function matchingSynthPreset(track: Track): string | undefined {
@@ -1105,6 +1524,233 @@ 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[],
+  presets: readonly string[] = keysPresetNames(track.instrument),
+): MenuNode[] {
+  const effective = resolvedKeys(track.instrument, track.keys);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: track.keys?.preset ?? "—",
+      options: presets,
+      command: (preset) => `keys preset ${preset}`,
+      help: isOrganFamily(track.instrument)
+        ? "a starting organ; every value stays editable"
+        : isElectricFamily(track.instrument)
+          ? "a starting electric piano or clav; every value stays editable"
+          : "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;
+}
+
+// ---- f061-organ menu rows -------------------------------------------------
+
+const PIANO_PRESET_NAMES = Object.keys(KEYS_PRESETS).filter((name) =>
+  isPianoFamily(KEYS_PRESETS[name]!.instrument),
+);
+const ORGAN_PRESET_NAMES = Object.keys(KEYS_PRESETS).filter((name) =>
+  isOrganFamily(KEYS_PRESETS[name]!.instrument),
+);
+const ELECTRIC_PRESET_NAMES = Object.keys(KEYS_PRESETS).filter((name) =>
+  isElectricFamily(KEYS_PRESETS[name]!.instrument),
+);
+
+/** The presets of the track's kind of keys (pianos, electric or organs). */
+function keysPresetNames(instrument: string): readonly string[] {
+  if (isOrganFamily(instrument)) return ORGAN_PRESET_NAMES;
+  if (isElectricFamily(instrument)) return ELECTRIC_PRESET_NAMES;
+  return PIANO_PRESET_NAMES;
+}
+
+const DRAWBAR_FEET = [
+  "16'",
+  "5⅓'",
+  "8'",
+  "4'",
+  "2⅔'",
+  "2'",
+  "1⅗'",
+  "1⅓'",
+  "1'",
+];
+const REGISTER_FEET = ["16'", "8'", "4'", "2⅔'", "2'"];
+
+/**
+ * One 0-8 row per footage of a digit string (`keys drawbars 888000000`):
+ * left/right pull a bar in or out, x puts the whole set back.
+ */
+function digitNodes(
+  name: "drawbars" | "registers",
+  text: string,
+  feet: readonly string[],
+  stored: boolean,
+): MenuNode[] {
+  const digits = text.split("").map(Number);
+  const nodes: MenuNode[] = feet.map((foot, index): MenuNode => {
+    const at = (value: number) =>
+      digits.map((d, i) => (i === index ? value : d)).join("");
+    return {
+      kind: "number",
+      label: foot,
+      value: digits[index]!,
+      min: 0,
+      max: 8,
+      step: (value, direction) => Math.max(0, Math.min(8, value + direction)),
+      format: (value) =>
+        `${value}  ${"█".repeat(value)}${"·".repeat(8 - value)}`,
+      command: (value) => `keys ${name} ${at(value)}`,
+      // x resets this bar only, to its default digit.
+      reset: `keys ${name} ${at(Number(ORGAN_TEXT[name].default[index] ?? 0))}`,
+      help: `${foot} ${name === "drawbars" ? "drawbar" : "register"} 0-8`,
+    };
+  });
+  nodes.push({
+    kind: "entry",
+    label: `${name} (type)`,
+    value: stored ? text : `${text} (default)`,
+    placeholder: `${feet.length} digits 0-8`,
+    command: (typed) =>
+      new RegExp(`^[0-8]{${feet.length}}$`).test(typed.trim())
+        ? `keys ${name} ${typed.trim()}`
+        : undefined,
+    example: `keys ${name} ${text}`,
+  });
+  return nodes;
+}
+
+/** Pipe stops: a registration, then one toggle per stop. */
+function stopNodes(text: string): MenuNode[] {
+  const on = pipeStops(text);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "registration",
+      value: Object.keys(PIPE_REGISTRATIONS).includes(text) ? text : "—",
+      options: Object.keys(PIPE_REGISTRATIONS),
+      command: (option) => `keys stops ${option}`,
+      help: "a named registration (stops drawn together)",
+    },
+  ];
+  for (const stop of PIPE_STOPS)
+    nodes.push({
+      kind: "toggle",
+      label: stop,
+      value: on.includes(stop),
+      command: (value) => {
+        const next = value
+          ? PIPE_STOPS.filter((name) => name === stop || on.includes(name))
+          : on.filter((name) => name !== stop);
+        return next.length > 0
+          ? `keys stops ${next.join(" ")}`
+          : "keys stops off";
+      },
+      help: `draw or retire the ${stop} stop`,
+    });
+  return nodes;
+}
+
+/** The organ's rows: preset, its family's sub-menu, then its parameters. */
+function organNodes(track: Track): MenuNode[] {
+  const family = track.instrument as OrganFamily;
+  const effective = resolvedKeys(track.instrument, track.keys);
+  const rows = ORGAN_ROWS[family].filter((row) => row in KEYS_PARAMS);
+  const nodes = keysNodes(track, rows, ORGAN_PRESET_NAMES);
+  const text = (name: keyof typeof ORGAN_TEXT) =>
+    String(effective[name] ?? ORGAN_TEXT[name].default);
+  const sub: MenuNode =
+    family === "tonewheel"
+      ? {
+          kind: "menu",
+          id: "keys:drawbars",
+          label: "Drawbars",
+          detail: text("drawbars"),
+          help: "nine drawbars 16' to 1' (0 in, 8 full out)",
+          build: (inner) => {
+            const current = focused(inner) ?? track;
+            const value = resolvedKeys(current.instrument, current.keys);
+            return digitNodes(
+              "drawbars",
+              String(value.drawbars ?? ORGAN_TEXT.drawbars.default),
+              DRAWBAR_FEET,
+              current.keys?.drawbars !== undefined,
+            );
+          },
+        }
+      : family === "combo"
+        ? {
+            kind: "menu",
+            id: "keys:registers",
+            label: "Registers",
+            detail: text("registers"),
+            help: "five combo-organ registers 16' to 2' (0 off, 8 full)",
+            build: (inner) => {
+              const current = focused(inner) ?? track;
+              const value = resolvedKeys(current.instrument, current.keys);
+              return digitNodes(
+                "registers",
+                String(value.registers ?? ORGAN_TEXT.registers.default),
+                REGISTER_FEET,
+                current.keys?.registers !== undefined,
+              );
+            },
+          }
+        : {
+            kind: "menu",
+            id: "keys:stops",
+            label: "Stops",
+            detail: text("stops"),
+            help: "pipe stops and registrations",
+            build: (inner) => {
+              const current = focused(inner) ?? track;
+              const value = resolvedKeys(current.instrument, current.keys);
+              return stopNodes(String(value.stops ?? ORGAN_TEXT.stops.default));
+            },
+          };
+  // After the preset row, before the parameters.
+  nodes.splice(1, 0, sub);
+  return nodes;
+}
+
 function synthNodes(track: Track, keys: readonly string[]): MenuNode[] {
   const nodes: MenuNode[] = [];
   if (keys === SYNTH_SIMPLE)
@@ -1175,6 +1821,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);
@@ -1324,10 +2021,58 @@ 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[];
+  // 0.6.1 shoegaze stages get their own sub-menu.
+  const gaze = SHOEGAZE_EFFECTS as readonly string[];
+  const more = EFFECT_NAMES.filter(
+    (effect) =>
+      !CORE_EFFECTS.includes(effect) &&
+      !rigStages.includes(effect) &&
+      !gaze.includes(effect),
+  );
+  const gazeOn = SHOEGAZE_EFFECTS.filter((effect) =>
+    effectValues(track, effect),
+  );
+  const shoegaze: MenuNode = {
+    kind: "menu",
+    id: "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
+        ? "off"
+        : gazeOn.map((effect) => effectSpec(effect).label).join(", "),
+    build: () => SHOEGAZE_EFFECTS.map(node),
+  };
   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,
+    shoegaze,
     {
       kind: "menu",
       id: "more effects",
@@ -1495,6 +2240,17 @@ 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;
+    // Only the lanes this family's engine reads (keys-rotary on organs,
+    // keys-hardness on pianos); the rest wait under "all lanes".
+    if (info?.effect === "keys")
+      return (
+        track.keys !== undefined &&
+        keysParamsFor(track.instrument).includes(info.param)
+      );
+    if (info?.effect === "modal") return track.modal !== undefined;
+    if (info?.effect === "grain") return track.granular !== undefined;
+    if (info?.effect === "wind") return track.wind !== undefined;
     return info !== undefined && effectValues(track, info.effect) !== undefined;
   });
   const hidden = AUTOMATION_PARAMETERS.filter((lane) => !shown.includes(lane));
@@ -1676,14 +2432,111 @@ function patternsMenu(): MenuNode {
   };
 }
 
+const GRANULAR_PRESETS_COUNT = granularBrowseNodes().length;
+
 function soundNodes(): MenuNode[] {
   return [
+    {
+      kind: "menu",
+      id: "group:keys",
+      label: "Keys",
+      help: "modelled 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 => {
+          const preset = KEYS_PRESETS[name]!;
+          return {
+            kind: "action",
+            label: `${name.padEnd(10)} ${preset.doc}`,
+            command: `piano ${name}`,
+            help: preset.styles,
+          };
+        }),
+        // keys-electric (0.6.1): tine and reed pianos and the clavinet.
+        {
+          kind: "menu",
+          id: "group:keys:electric",
+          label: "Electric",
+          help: "electric pianos (tine, reed) and the clavinet, modelled",
+          detail: ELECTRIC_PRESET_NAMES.join(" "),
+          build: () =>
+            Object.entries(KEYS_PRESETS)
+              .filter(([, preset]) => isElectricFamily(preset.instrument))
+              .map(([name, preset]): MenuNode => ({
+                kind: "action",
+                label: `${name.padEnd(10)} ${preset.doc}`,
+                command: `keys preset ${name}`,
+                help: preset.styles,
+              })),
+        },
+        // f061-organ
+        {
+          kind: "menu",
+          id: "group:organs",
+          label: "Organs",
+          help: "tonewheel, combo and pipe organs on the keys engine",
+          detail: ORGAN_PRESET_NAMES.join(" "),
+          build: () =>
+            ORGAN_PRESET_NAMES.map((name): MenuNode => {
+              const preset = KEYS_PRESETS[name]!;
+              return {
+                kind: "action",
+                label: `${name.padEnd(10)} ${preset.doc}`,
+                command: 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(),
+    windsMenu(),
+    {
+      kind: "menu",
+      id: "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: () => [
+        ...STRING_PRESET_NAMES.filter(
+          (name) => !BOWED_PRESET_NAMES.includes(name),
+        ).map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(12)} ${STRING_PRESETS[name]!.doc}`,
+          command: `string ${name}`,
+          help: STRING_PRESETS[name]!.styles,
+        })),
+        {
+          kind: "menu",
+          id: "strings:bowed",
+          label: "Bowed",
+          help: "bowed strings: violin, viola, cello, bass, fiddle, erhu, sections",
+          detail: BOWED_PRESET_NAMES.join(" "),
+          build: () =>
+            BOWED_PRESET_NAMES.map((name): MenuNode => ({
+              kind: "action",
+              label: `${name.padEnd(12)} ${STRING_PRESETS[name]!.doc}`,
+              command: `bowed ${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",
@@ -1812,9 +2665,75 @@ function transportNodes(context: MenuContext): MenuNode[] {
       help: "the song tuning (12-TET, EDOs, just, gamelan, Scala) and scale",
       build: songTuningNodes,
     },
+    {
+      kind: "menu",
+      id: "resample",
+      label: "resample",
+      detail: "track · section · bars → new sample track",
+      help: "render a track, an orbit or the mix to a pinned WAV on a new sampler or granular track",
+      build: resampleNodes,
+    },
   ];
 }
 
+/** Project > Resample: one action per useful source and range. */
+function resampleNodes(context: MenuContext): MenuNode[] {
+  const track = focused(context);
+  const score = context.score;
+  const nodes: MenuNode[] = [];
+  if (track) {
+    nodes.push(
+      {
+        kind: "action",
+        label: `${track.id} → sampler`,
+        command: `resample ${track.id}`,
+        help: "render this track (pre-master) to a one-shot sampler track",
+      },
+      {
+        kind: "action",
+        label: `${track.id} → granular`,
+        command: `resample ${track.id} grain`,
+        help: "render this track to a granular track (cloud preset) holding one note",
+      },
+    );
+    for (const section of score.sections)
+      nodes.push({
+        kind: "action",
+        label: `${track.id} · section ${section.name}`,
+        command: `resample ${track.id} section ${section.name}`,
+        help: `render bars ${section.startBar + 1}-${section.startBar + section.bars} of this track`,
+      });
+  }
+  nodes.push(
+    {
+      kind: "entry",
+      label: "bars",
+      value: "",
+      placeholder: "a-b [grain]",
+      example: "/resample <track> bars 1-2",
+      command: (text) => {
+        const match = /^\s*(\d{1,4})(?:-(\d{1,4}))?(\s+grain)?\s*$/.exec(text);
+        if (!match || !track) return undefined;
+        return `resample ${track.id} bars ${match[1]}-${match[2] ?? match[1]}${match[3] ? " grain" : ""}`;
+      },
+      help: "render a bar range of the focused track",
+    },
+    {
+      kind: "action",
+      label: "mix → sampler (pre-master)",
+      command: "resample orbit 1",
+      help: "render every track on orbit 1 (the default bus) without the song master",
+    },
+    {
+      kind: "action",
+      label: "master → sampler",
+      command: "resample master",
+      help: "render the whole song through the master chain",
+    },
+  );
+  return nodes;
+}
+
 // ── tuning ────────────────────────────────────────────────────────────
 
 /** Short name of a tuning for a choice row: its library name or table. */
@@ -2372,11 +3291,17 @@ 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" };