@hraness/dawg 0.6.0 → 0.6.1

package/src/tui/menu.ts

@@ -14,6 +14,7 @@ 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,
@@ -47,6 +48,7 @@ import {
   RIG_PRESETS,
   RIG_STAGES,
   rigPresetOf,
+  SHOEGAZE_EFFECTS,
   effectPresetNames,
   effectSpec,
   type EffectName,
@@ -95,16 +97,29 @@ import {
   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_SIMPLE,
-  PIANO_FAMILIES,
+  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";
@@ -124,6 +139,8 @@ import {
   PROGRESSION_STYLES,
   SCALE_NAMES,
   SPREADS,
+  STROKE_PATTERN_NAMES,
+  GUITAR_TUNING_NAMES,
   keyName,
   parseKey,
 } from "../../core/chords.ts";
@@ -135,6 +152,7 @@ import {
   type Tuning,
 } from "../../core/tuning.ts";
 import { rootName, tuningStepsText } from "../commands/tuning.ts";
+import { describeGuitar } from "../commands/strum.ts";
 import {
   granularBrowseNodes,
   granularMenuDetail,
@@ -144,6 +162,7 @@ import {
 import {
   ARP_RATES,
   CHORD_MODES,
+  STROKE_SPEED_MS,
   defaultChordSettings,
   type ChordSettings,
 } from "./play-chords.ts";
@@ -384,7 +403,9 @@ function laneLabel(lane: AutomationParameter): string {
     info.effect === "synth" ||
     info.effect === "string" ||
     info.effect === "keys" ||
-    info.effect === "modal"
+    info.effect === "modal" ||
+    info.effect === "grain" ||
+    info.effect === "wind"
       ? info.effect
       : effectSpec(info.effect).label;
   return `${owner} ${info.param}${unit}`;
@@ -533,27 +554,62 @@ function soundSectionNodes(context: MenuContext): MenuNode[] {
         ]
       : [];
   const keys: MenuNode[] =
-    track && isPianoFamily(track.instrument) && track.keys
+    track && isOrganFamily(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",
+            help: "the modelled organ: preset, drawbars, registers or stops, rotary",
             build: (inner) => {
               const current = focused(inner);
-              return current
-                ? keysNodes(current, Object.keys(KEYS_PARAMS))
-                : [];
+              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",
@@ -574,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 [
@@ -881,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",
@@ -969,7 +1131,7 @@ function trackNodes(context: MenuContext): MenuNode[] {
 }
 
 function instrumentNode(track: Track): MenuNode {
-  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...PIANO_FAMILIES];
+  const options: string[] = [...AVAILABLE_INSTRUMENTS, ...KEYS_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
   return {
     kind: "choice",
@@ -1023,13 +1185,20 @@ function parameterNodes(context: MenuContext): MenuNode[] {
   if (isWavetableInstrument(track.instrument))
     nodes.push(...wavetableNodes(track, context.projectRoot));
   if (isStringTrack(track)) {
-    nodes.push(...stringNodes(track, STRING_SIMPLE_PARAMS));
+    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",
+      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
@@ -1072,22 +1241,35 @@ 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));
+  } 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: "all piano params",
-      detail: `all ${Object.keys(KEYS_PARAMS).length} params`,
-      help: "every modelled piano parameter",
+      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, Object.keys(KEYS_PARAMS)) : [];
+        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({
@@ -1233,10 +1415,103 @@ function sampleVoiceNodes(context: MenuContext, voice: string): MenuNode[] {
       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 {
@@ -1250,16 +1525,24 @@ function matchingSynthPreset(track: Track): string | undefined {
 }
 
 /** Modelled piano rows: the preset, then each parameter (`keys <p> <v>`). */
-function keysNodes(track: Track, params: readonly string[]): MenuNode[] {
+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: Object.keys(KEYS_PRESETS),
+      options: presets,
       command: (preset) => `keys preset ${preset}`,
-      help: "a starting piano; every value stays editable",
+      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) {
@@ -1300,6 +1583,174 @@ function keysNodes(track: Track, params: readonly string[]): MenuNode[] {
   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)
@@ -1571,9 +2022,28 @@ function effectNodes(context: MenuContext): MenuNode[] {
     };
   };
   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),
+    (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));
@@ -1602,6 +2072,7 @@ function effectNodes(context: MenuContext): MenuNode[] {
   return [
     ...CORE_EFFECTS.map(node),
     rig,
+    shoegaze,
     {
       kind: "menu",
       id: "more effects",
@@ -1770,8 +2241,16 @@ function automationNodes(context: MenuContext): MenuNode[] {
     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;
+    // 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));
@@ -1961,15 +2440,54 @@ function soundNodes(): MenuNode[] {
       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,
-        })),
+      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",
@@ -1979,19 +2497,37 @@ function soundNodes(): MenuNode[] {
     },
     // 0.6 instrument groups, one per lane.
     malletsMenu(),
+    windsMenu(),
     {
       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 => ({
+      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",
@@ -2129,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. */