@hraness/dawg 0.6.1 → 0.7.0

package/src/tui/modal-menu.ts

@@ -1,6 +1,6 @@
 /**
- * Ctrl-k menu rows for modal percussion (0.6): the "Mallets and bells"
- * group under Sound › browse sounds, and the MODAL_PARAMS rows under
+ * Ctrl-k menu rows for modal percussion (0.6): the "mallets"
+ * group under Sound › instruments, and the MODAL_PARAMS rows under
  * Sound › Parameters on a modal track. Every row runs a `modal …` command.
  */
 import type { EnumParam, NumberParam } from "../../core/params.ts";
@@ -18,12 +18,12 @@ import {
 import type { Track } from "../../core/score.ts";
 import { num, specStep, type MenuNode } from "./menu.ts";
 
-/** Sound › browse sounds › Mallets and bells: one row per preset. */
+/** Sound › instruments › mallets: one row per preset. */
 export function malletsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "mallets",
-    label: "Mallets and bells",
+    label: "mallets",
     detail: `${MODAL_PRESET_NAMES.length} modal presets · marimba, vibes, gong …`,
     help: "struck bars, bells and bowls on the modal resonator engine",
     build: () => [
@@ -47,14 +47,14 @@ function presetRow(name: ModalPresetName): MenuNode {
 }
 
 /**
- * Mallets and bells › Gamelan (f061-gamelan-winds): the Javanese and
+ * mallets › gamelan (f061-gamelan-winds): the Javanese and
  * Balinese bronzes. `modal gamelan` points here.
  */
 export function gamelanMenu(): MenuNode {
   return {
     kind: "menu",
     id: "gamelan",
-    label: "Gamelan",
+    label: "gamelan",
     detail: `${GAMELAN_PRESETS.length} bronzes · saron, gangsa (ombak), gong …`,
     help: "Javanese and Balinese gamelan; pair two gangsa tracks with modal pair, tune with tuning slendro or pelog",
     build: () => GAMELAN_PRESETS.map(presetRow),

package/src/tui/performance-menu.ts

@@ -3,6 +3,7 @@
  * runs the same prompt command a user could type (src/commands/expression.ts),
  * so the menu, the prompt and the agent share one grammar.
  */
+import { singVowelNodes } from "./sing-menu.ts";
 import {
   ARTICULATIONS,
   DEFAULT_FIXED_VELOCITY,
@@ -187,7 +188,7 @@ export function performanceNodes(context: MenuContext): MenuNode[] {
             : "pedal",
       help: "bars replaces the lane with a re-pedal on each downbeat; in play mode press Tab (latch) or hold Shift while recording",
     },
-    // keys-electric (0.6.1): the piano's other two pedals, on modelled piano
+    // keys-electric (0.6.1): the piano's other two pedals, on modeled piano
     // tracks (or wherever a lane is already set).
     ...pianoPedalNodes(track),
     {
@@ -233,7 +234,7 @@ export function performanceNodes(context: MenuContext): MenuNode[] {
     },
     {
       kind: "number",
-      label: "humanize velocity (%)",
+      label: "humanize vel (%)",
       value: humanize ? velocity : undefined,
       min: 0,
       max: EXPRESSION_LIMITS.maxHumanizePercent,
@@ -273,5 +274,7 @@ export function performanceNodes(context: MenuContext): MenuNode[] {
       command: "humanize reseed",
       help: "the same amounts with a different seeded performance",
     });
+  // 0.7 sing: Vowels on a sing track.
+  nodes.push(...singVowelNodes(context));
   return nodes;
 }

package/src/tui/play-chords.ts

@@ -605,9 +605,11 @@ export function applyChordsCommand(
       return done(`chords preset ${value}`);
     case "style":
       if (!(PROGRESSION_STYLES as readonly string[]).includes(value ?? ""))
-        return bad(`style takes ${PROGRESSION_STYLES.join("|")}`);
+        return bad(
+          `idiom takes ${PROGRESSION_STYLES.join("|")} · chords idiom jazz`,
+        );
       settings.style = value as ProgressionStyle;
-      return done(`chords style ${value}`);
+      return done(`chords idiom ${value}`);
     default:
       return bad(
         "/chords auto|manual|off · voicing · spread · bass · perform · pattern · strokes · speed · rate · octaves · sevenths · preset · style",

package/src/tui/play-mode.ts

@@ -32,6 +32,7 @@ import {
   type Track,
 } from "../../core/score.ts";
 import type { TuningTable } from "../../core/tuning.ts";
+import { DRUM_VOICES, isDrumInstrument } from "../../core/drums.ts";
 import { pitchName } from "../../tui/highway.ts";
 
 /** Semitone offset from the base C for each note key. */
@@ -112,10 +113,21 @@ export function defaultBaseFor(instrument: string | undefined): number {
  */
 export type PlayLayout = Readonly<{
   base: number;
-  /** Pitch → label (voice names on one-shot samplers). */
+  /** Pitch → label (voice names on one-shot samplers, drums on kits). */
   labels: ReadonlyMap<number, string>;
+  /** A drum kit: keys name drums and the chord row stays hidden. */
+  drums?: boolean | undefined;
 }>;
 
+/**
+ * A kit's keys on the GM map from C2 (36), the same keys the agent's
+ * show-me gestures press: A kick, W rim, S snare, E clap, T hat, H tom,
+ * U open hat. Other keys still sound their nearest drum, unlabeled.
+ */
+export function drumKeyLabels(): ReadonlyMap<number, string> {
+  return new Map(DRUM_VOICES.map((info) => [info.pitch, info.label]));
+}
+
 export function playLayoutFor(track: Track | undefined): PlayLayout {
   const labels = new Map<number, string>();
   if (track && isSamplerInstrument(track.instrument) && track.sampler) {
@@ -130,6 +142,8 @@ export function playLayoutFor(track: Track | undefined): PlayLayout {
     const lowest = roots.length > 0 ? Math.min(...roots) : 60;
     return { base: clampBase(Math.floor(lowest / 12) * 12), labels };
   }
+  if (track && isDrumInstrument(track.instrument))
+    return { base: 36, labels: drumKeyLabels(), drums: true };
   // A plain instrument takes its range from the track's name (`bass`, `lead`).
   const byInstrument = defaultBaseFor(track?.instrument);
   const base =

package/src/tui/play-session.ts

@@ -50,6 +50,7 @@ import {
 import {
   LiveFullRenderer,
   LiveSynth,
+  warmLive,
   MAX_LIVE_NOTE_SECONDS,
   type LiveNotePcm,
 } from "../audio/live.ts";
@@ -57,6 +58,7 @@ import type { SampleBank } from "../audio/samples.ts";
 import { fitting, onFitReady } from "../audio/fit.ts";
 import {
   DEFAULT_STRUM,
+  degreeOf,
   perform,
   type PerformMode,
   type PerformOptions,
@@ -73,6 +75,7 @@ import {
 } from "./play-chords.ts";
 import type { PlayHeaderView, PlayStripKey } from "../../tui/play-strip.ts";
 import { resolveTuning, type Tuning } from "../../core/tuning.ts";
+import { singThroat } from "../../core/sing.ts";
 import {
   NOTE_KEYS,
   PlayKeyboard,
@@ -91,6 +94,10 @@ export interface LiveEngine {
   readonly sampleRate: number;
   readonly canMonitor: boolean;
   readonly leadMs: number;
+  /** The lead play mode pins (15 ms on the native sink, else 60 ms). */
+  readonly playLeadMs?: number;
+  /** How play mode sounds (`native sink`, `ffplay · no native sink`). */
+  readonly audioNote?: string;
   monitor(on: boolean): Promise<void>;
   setLeadMs(ms: number | undefined): void;
   noteOn(id: number, note: LiveNotePcm): number;
@@ -124,6 +131,8 @@ export interface PlayHost {
   startTransport(beat: number): Promise<void>;
   stopTransport(): Promise<void>;
   card(text: string, tone: "info" | "success" | "warning" | "error"): void;
+  /** A played key that is not recorded: the screen glows its lane. */
+  ghost?(pitch: number): void;
   newNoteId(): string;
 }
 
@@ -240,6 +249,8 @@ export class PlaySession {
   private synth: LiveSynth | undefined;
   /** Rig voices awaiting their full render: id → released since. */
   private readonly windows = new Map<number, boolean>();
+  /** f07-sing: the sounding key on a throat track (one drone, mono). */
+  private throatId: number | undefined;
   private readonly fullRenderer = new LiveFullRenderer();
   private readonly pending = new Map<number, Pending>();
   /** Sustain changes while recording (Tab latch or Shift), as pedal events. */
@@ -289,7 +300,8 @@ export class PlaySession {
       settings.mode =
         chordCapable(track) &&
         twelveTet(this.host.score(), track) &&
-        (track?.glide === undefined || track.glide.mode === "poly")
+        (track?.glide === undefined || track.glide.mode === "poly") &&
+        !singThroat(track)
           ? "auto"
           : "manual";
     this.chords = new ChordPad(settings, () => this.host.score().key);
@@ -331,8 +343,12 @@ export class PlaySession {
     this.active = true;
     const engine = this.host.engine();
     if (engine?.canMonitor) {
-      engine.setLeadMs(PLAY_LEAD_MS);
+      engine.setLeadMs(engine.playLeadMs ?? PLAY_LEAD_MS);
+      // The voice's tables and loops are built now, not on the first key.
+      warmLive(this.host.score(), this.trackId, engine.sampleRate);
       await engine.monitor(true);
+      if (engine.audioNote)
+        this.status = `${engine.audioNote} · ${Math.round(engine.leadMs)} ms lead`;
     } else this.status = "no audio · keys still record";
     this.applyClick();
   }
@@ -483,6 +499,8 @@ export class PlaySession {
         return { type: "handled" };
       case "note": {
         this.release(action.released, now);
+        // A key that is not recording glows its lane for a moment.
+        if (!this.recording) this.host.ghost?.(action.note.pitch);
         const chord = this.chords.chordFor(action.note.pitch);
         if (chord) {
           const played = this.chords.voice(chord, action.note.pitch);
@@ -501,6 +519,12 @@ export class PlaySession {
           );
           return { type: "handled" };
         }
+        // f07-sing: a throat track is one drone; a new key releases the last.
+        if (singThroat(this.trackData())) {
+          if (this.throatId !== undefined && this.throatId !== action.note.id)
+            this.release([this.throatId], now);
+          this.throatId = action.note.id;
+        }
         this.sound(action.note.id, action.note);
         this.record(action.note);
         return { type: "handled" };
@@ -1143,7 +1167,7 @@ export class PlaySession {
       };
     }
     return {
-      range: this.keyboard.range,
+      range: this.layout.drums ? "drums" : this.keyboard.range,
       velocity: this.keyboard.velocity,
       armed: this.armed,
       recording: this.recording,
@@ -1153,10 +1177,14 @@ export class PlaySession {
       countIn,
       beat,
       grid: `grid ${this.grid}`,
-      chords: this.chords.glance(songKey(this.host.score().key).set),
+      // A kit plays drums, not harmony: no chord row and no key chip.
+      chords: this.layout.drums
+        ? undefined
+        : this.chords.glance(songKey(this.host.score().key).set),
       status: this.status,
       keys: this.strip(now),
-      legend: this.chords.on ? this.chords.legend() : undefined,
+      legend:
+        this.chords.on && !this.layout.drums ? this.chords.legend() : undefined,
     };
   }
 
@@ -1178,8 +1206,20 @@ export class PlaySession {
     ).map((cell) => {
       const chord = this.keyboard.pitchFor(cell.key);
       const name =
-        chord === undefined ? undefined : this.chords.keyLabel(chord);
-      return name ? { ...cell, label: name } : this.noteCell(cell);
+        chord === undefined || this.layout.drums
+          ? undefined
+          : this.chords.keyLabel(chord);
+      // Chords in the key are the safe ones to reach for: the strip lights
+      // them; a borrowed chord still plays but stays plain.
+      return name && chord !== undefined
+        ? {
+            ...cell,
+            label: name,
+            chord: true,
+            diatonic:
+              degreeOf(this.chords.key, ((chord % 12) + 12) % 12) !== undefined,
+          }
+        : this.noteCell(cell);
     });
   }
 

package/src/tui/sing-menu.ts

@@ -0,0 +1,278 @@
+/**
+ * Ctrl-k menu rows for the sing engine (0.7): the Choir, Solo and Throat
+ * groups under Voice › voice presets, the SING_PARAMS rows under
+ * Sound › Parameters on a sing track (with a Throat sub-menu) and the
+ * Vowels row under Sound › Performance. Every row runs a `sing …` or
+ * `note vowel …` command, so it stages for the audition loop's A/B.
+ */
+import type { EnumParam, NumberParam } from "../../core/params.ts";
+import type { Note, Track } from "../../core/score.ts";
+import {
+  DEFAULT_SING_PRESET,
+  resolveSing,
+  SING_GROUPS,
+  SING_PARAMS,
+  SING_PRESETS,
+  SING_PRESET_NAMES,
+  SING_THROAT_PARAMS,
+  SING_VOWELS,
+  singNoteName,
+  singDroneFollows,
+  singTrack,
+  type SingPreset,
+} from "../../core/sing.ts";
+import { num, specStep, type MenuContext, type MenuNode } from "./menu.ts";
+
+function presetRow(name: SingPreset): MenuNode {
+  return {
+    kind: "action",
+    label: `${name.padEnd(9)} ${SING_PRESETS[name].doc}`,
+    command: `sing ${name}`,
+    help: SING_PRESETS[name].styles,
+  };
+}
+
+/** Voice › voice presets: choir, solo and throat (sing lane). */
+export function singBrowseRows(): MenuNode[] {
+  return SING_GROUPS.map((group): MenuNode => ({
+    kind: "menu",
+    id: `voices:${group.label.toLowerCase()}`,
+    label: group.label.toLowerCase(),
+    detail: group.presets.slice(0, 4).join(", ") + " …",
+    help:
+      group.label === "Throat"
+        ? "Tuvan throat singing: a held drone, notes steer the overtone"
+        : `${group.label.toLowerCase()} on the built-in singing voice`,
+    build: () => group.presets.map(presetRow),
+  }));
+}
+
+/** Parameters shown first; the rest sit under "advanced". */
+const SING_SIMPLE = Object.freeze([
+  "vowel",
+  "voice",
+  "voices",
+  "bright",
+  "breath",
+  "vibmod",
+  "formant",
+  "ring",
+] as const);
+
+function numberRow(
+  name: string,
+  spec: NumberParam,
+  value: number,
+  fallback: number,
+): MenuNode {
+  return {
+    kind: "number",
+    label: name,
+    value,
+    min: spec.min,
+    max: spec.max,
+    step: specStep(spec),
+    format: (v) => (spec.unit ? `${num(v)} ${spec.unit}` : num(v)),
+    command: (v) => `sing ${name} ${num(v)}`,
+    reset: `sing ${name} off`,
+    help: `${spec.doc} · preset ${num(fallback)} · x resets`,
+  };
+}
+
+/** Every vowel and two-vowel morph, for the pickers. */
+export function vowelOptions(): string[] {
+  const out: string[] = [...SING_VOWELS];
+  for (const from of SING_VOWELS)
+    for (const to of SING_VOWELS) if (from !== to) out.push(`${from}>${to}`);
+  return out;
+}
+
+/** Sound › Parameters rows on a sing track. */
+export function singParameterNodes(track: Track, keyRoot?: number): MenuNode[] {
+  if (!singTrack(track)) return [];
+  const sing = track.sing!;
+  const follows = singDroneFollows(sing, keyRoot);
+  const resolved = resolveSing(sing, keyRoot) as unknown as Readonly<
+    Record<string, unknown>
+  >;
+  const fallback = SING_PRESETS[sing.preset ?? DEFAULT_SING_PRESET]
+    .settings as unknown as Readonly<Record<string, unknown>>;
+  const own = sing as Readonly<Record<string, unknown>>;
+  const row = (name: string): MenuNode | undefined => {
+    if (name === "vowel")
+      return {
+        kind: "choice",
+        label: "vowel",
+        value: String(resolved.vowel),
+        options: vowelOptions(),
+        command: (option) => `sing vowel ${option}`,
+        help: `${SING_PARAMS.vowel!.doc} · preset ${String(fallback.vowel)}`,
+      };
+    if (name === "drone") {
+      const drone = resolved.drone as number | undefined;
+      const spec = SING_PARAMS.drone as NumberParam;
+      return {
+        kind: "number",
+        label: "drone",
+        value: drone,
+        min: spec.min,
+        max: spec.max,
+        step: (v, direction) =>
+          Math.max(spec.min, Math.min(spec.max, Math.round(v) + direction)),
+        // The drone you hear: the preset's moved to the song key.
+        format: (v) =>
+          follows && v === drone ? `${singNoteName(v)} (key)` : singNoteName(v),
+        command: (v) => `sing drone ${singNoteName(v)}`,
+        off: "off (melody)",
+        start: 50,
+        reset: "sing drone off",
+        help: `${spec.doc} · x back to the preset`,
+      };
+    }
+    if (name === "harmonics") {
+      const [lo, hi] = resolved.harmonics as readonly [number, number];
+      const options = ["4-8", "4-12", "5-10", "6-12", "6-16", "8-16", "8-24"];
+      const value = `${lo}-${hi}`;
+      return {
+        kind: "choice",
+        label: "harmonics",
+        value,
+        options: options.includes(value) ? options : [value, ...options],
+        command: (option) => `sing harmonics ${option}`,
+        help: "the overtone range a throat track's notes pick from (khoomei 6-12, sygyt 8-16)",
+      };
+    }
+    const spec = SING_PARAMS[name]!;
+    if (spec.kind === "enum")
+      return {
+        kind: "choice",
+        label: name,
+        value: own[name] === undefined ? "preset" : String(own[name]),
+        options: ["preset", ...(spec as EnumParam).values],
+        command: (option) =>
+          option === "preset" ? `sing ${name} unset` : `sing ${name} ${option}`,
+        help: `${spec.doc} · preset ${String(fallback[name])}`,
+      };
+    if (spec.kind !== "number") return undefined;
+    return numberRow(
+      name,
+      spec,
+      Number(resolved[name]),
+      Number(fallback[name]),
+    );
+  };
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: sing.preset ?? DEFAULT_SING_PRESET,
+      options: SING_PRESET_NAMES,
+      command: (option) => `sing preset ${option}`,
+      help: "the voice: choir, solo or throat singing",
+    },
+  ];
+  for (const name of SING_SIMPLE) {
+    const node = row(name);
+    if (node) nodes.push(node);
+  }
+  const throat = SING_THROAT_PARAMS as readonly string[];
+  nodes.push({
+    kind: "menu",
+    id: "sing:throat",
+    label: "throat",
+    detail:
+      resolved.drone === undefined
+        ? "off · drone, overtone, harmonics, sub"
+        : `drone ${singNoteName(resolved.drone as number)} · ${throat.slice(1).join(", ")}`,
+    help: "throat singing: a drone, notes pick its overtones; sub for kargyraa",
+    build: () => throat.flatMap((name) => row(name) ?? []),
+  });
+  const rest = Object.keys(SING_PARAMS).filter(
+    (name) =>
+      !(SING_SIMPLE as readonly string[]).includes(name) &&
+      !throat.includes(name),
+  );
+  nodes.push({
+    kind: "menu",
+    id: "sing:advanced",
+    label: "advanced",
+    detail: rest.join(", "),
+    help: "every sing parameter",
+    build: () => rest.flatMap((name) => row(name) ?? []),
+  });
+  if (Object.keys(sing).some((key) => key !== "preset"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "sing reset",
+      help: "clear overrides, keep the preset",
+    });
+  return nodes;
+}
+
+function sharedVowel(notes: readonly Note[]): string {
+  const values = new Set(notes.map((note) => note.vowel ?? "track"));
+  if (values.size === 0) return "track";
+  return values.size === 1 ? [...values][0]! : "mixed";
+}
+
+/**
+ * Sound › Performance › Vowels on a sing track: left/right steps the notes'
+ * vowel through a e i o u, enter opens the morph picker, and a pattern
+ * row cycles vowels over the notes in order.
+ */
+export function singVowelNodes(context: MenuContext): MenuNode[] {
+  const track = context.score.tracks.find(
+    (item) => item.id === context.trackId,
+  );
+  if (!singTrack(track)) return [];
+  const notes = context.score.notes.filter(
+    (note) => note.trackId === track!.id,
+  );
+  const current = sharedVowel(notes);
+  return [
+    {
+      kind: "menu",
+      id: "sing:vowels",
+      label: "vowels",
+      detail: `${current} · ${notes.length} notes`,
+      help: "the sung vowel of every note on the track (a note's vowel wins over the track's)",
+      build: (inner) => {
+        const now = inner.score.notes.filter(
+          (note) => note.trackId === context.trackId,
+        );
+        return [
+          {
+            kind: "choice",
+            label: "vowel",
+            value: sharedVowel(now),
+            options: ["track", ...SING_VOWELS],
+            command: (option) =>
+              `note vowel ${option === "track" ? "off" : option}`,
+            help: "left/right steps a e i o u; track uses the track's vowel",
+          },
+          {
+            kind: "choice",
+            label: "morph",
+            value: sharedVowel(now),
+            options: [
+              "track",
+              ...vowelOptions().filter((v) => v.includes(">")),
+            ],
+            command: (option) =>
+              `note vowel ${option === "track" ? "off" : option}`,
+            help: "each note travels from the first vowel to the second",
+          },
+          {
+            kind: "choice",
+            label: "pattern",
+            value: "",
+            options: ["a e i o u", "a o", "o u", "a e i", "u o a"],
+            command: (option) => `sing vowels ${option}`,
+            help: "vowels over the notes in time order, cycled",
+          },
+        ];
+      },
+    },
+  ];
+}

package/src/tui/style-menu.ts

@@ -0,0 +1,104 @@
+/**
+ * ctrl-k › Style: the style taxonomy as a menu tree (families, then each
+ * branch down to its leaves). Every row is a `style` command, so the menu
+ * and the prompt share one grammar; typing filters the rows of a level.
+ */
+import { hasCard, STYLE_TREE } from "../../core/styles/index.ts";
+import { STYLE_FAMILIES } from "../../core/styles/taxonomy.ts";
+import type { StyleId } from "../../core/styles/schema.ts";
+import type { MenuContext, MenuNode } from "./menu.ts";
+
+const BAR_CHOICES = [4, 8, 16, 32] as const;
+
+/** The Style row's detail: the song's style, or a hint. */
+export function styleMenuDetail(context: MenuContext): string {
+  const style = context.score.style;
+  if (!style) return "a whole song from a style";
+  const name = style.blend ? `${style.id} + ${style.blend.id}` : style.id;
+  return `${name} · seed ${style.seed}`;
+}
+
+function styleActions(id: StyleId): MenuNode[] {
+  const node = STYLE_TREE.get(id)!;
+  return [
+    ...BAR_CHOICES.map((bars): MenuNode => ({
+      kind: "action",
+      label: `make ${bars} bars`,
+      command: `/style ${id} ${bars}`,
+      help: `replace the song with ${bars} bars of ${node.title} (undo restores it)`,
+    })),
+    {
+      kind: "action",
+      label: "about",
+      command: `/style info ${id}`,
+      help: "meter, tempo, groove, tuning, harmony and roles",
+    },
+  ];
+}
+
+function styleNode(id: StyleId): MenuNode {
+  const node = STYLE_TREE.get(id)!;
+  const card = hasCard(id) ? "" : " · inherits";
+  return {
+    kind: "menu",
+    id: `style:${id}`,
+    label: node.title,
+    detail: node.leaf
+      ? `${id}${card}`
+      : `${node.children.length} styles${card}`,
+    help: node.region.length ? `${id} · ${node.region.join(", ")}` : id,
+    build: () => [
+      ...styleActions(id),
+      ...node.children.map((child) => styleNode(child)),
+    ],
+  };
+}
+
+/** Style: again, find, then the families. */
+export function styleMenuNodes(context: MenuContext): MenuNode[] {
+  const current = context.score.style;
+  return [
+    ...(current
+      ? [
+          {
+            kind: "action",
+            label: "again",
+            command: "/style again",
+            help: `${current.id} with the next seed`,
+          } satisfies MenuNode,
+        ]
+      : []),
+    {
+      kind: "entry",
+      label: "find",
+      value: "",
+      placeholder: "style name, alias or region",
+      command: (text) =>
+        text.trim() ? `/style search ${text.trim()}` : undefined,
+      example: "/style search samba",
+      help: "search every style by name, alias or region",
+    },
+    {
+      kind: "entry",
+      label: "blend",
+      value: "",
+      placeholder: "a b [weight]",
+      command: (text) => {
+        const words = text.trim().split(/\s+/).filter(Boolean);
+        return words.length >= 2 && words.length <= 3
+          ? `/style blend ${words.join(" ")}`
+          : undefined;
+      },
+      example: "/style blend bebop bossa-nova 0.3",
+      help: "mix two styles; weight 0 is the first, 1 the second",
+    },
+    ...STYLE_FAMILIES.map((family): MenuNode => ({
+      kind: "menu",
+      id: `family:${family.key}`,
+      label: family.title,
+      detail: family.roots.join(" · "),
+      help: `${family.key} family`,
+      build: () => family.roots.map((root) => styleNode(root)),
+    })),
+  ];
+}