@hraness/dawg 0.6.0 → 0.7.0

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)),
+    })),
+  ];
+}

package/src/tui/vocoder-menu.ts

@@ -0,0 +1,244 @@
+/**
+ * Ctrl-k rows for the vocoder (0.7, vocoder.md §8): Effects › Voice ›
+ * Vocoder (Source picker, Preset, one row per VOCODER_PARAMS key in table
+ * order) and Voice › voice presets › Vocoder. Every row runs a
+ * `vocoder …` command, so it stages for the audition loop like any other.
+ */
+import type { NumberParam } from "../../core/params.ts";
+import type { Track } from "../../core/score.ts";
+import {
+  DEFAULT_VOCODER_PRESET,
+  VOCODER_INSTRUMENT,
+  VOCODER_PARAMS,
+  VOCODER_PRESETS,
+  VOCODER_PRESET_NAMES,
+  resolveVocoder,
+  vocoderPresetOf,
+  type TrackVocoder,
+} from "../../core/vocoder.ts";
+import {
+  vocoderEntryLines,
+  trackHasAudio,
+  vocoderCandidates,
+} from "../commands/vocoder.ts";
+import { num, specStep, type MenuContext, type MenuNode } from "./menu.ts";
+
+const NONE = "none";
+
+function trackOf(context: MenuContext): Track | undefined {
+  return context.score.tracks.find((track) => track.id === context.trackId);
+}
+
+/** One row per VOCODER_PARAMS key; x and `preset` return it to the preset. */
+function paramRow(vocoder: TrackVocoder, name: string): MenuNode {
+  const spec = VOCODER_PARAMS[name]!;
+  const own = (vocoder as Record<string, unknown>)[name];
+  const preset = vocoderPresetOf(vocoder);
+  const fallback = (VOCODER_PRESETS[preset].values as Record<string, unknown>)[
+    name
+  ];
+  const resolved = (resolveVocoder(vocoder) as Record<string, unknown>)[name];
+  if (spec.kind === "enum")
+    return {
+      kind: "choice",
+      label: name,
+      value: own === undefined ? "preset" : String(own),
+      options: ["preset", ...spec.values],
+      command: (option) =>
+        option === "preset"
+          ? `vocoder ${name} reset`
+          : `vocoder ${name} ${option}`,
+      help: `${spec.doc} · preset ${String(resolved)}`,
+    };
+  if (spec.kind === "boolean")
+    return {
+      kind: "choice",
+      label: name,
+      value: own === undefined ? "preset" : own ? "on" : "off",
+      options: ["preset", "on", "off"],
+      command: (option) =>
+        option === "preset"
+          ? `vocoder ${name} reset`
+          : `vocoder ${name} ${option}`,
+      help: `${spec.doc} · preset ${fallback ? "on" : "off"}`,
+    };
+  const number = spec as NumberParam;
+  // gate's preset value is "auto" (from the source's assets): show it as off.
+  const value = typeof resolved === "number" ? resolved : undefined;
+  return {
+    kind: "number",
+    label: name,
+    value,
+    min: number.min,
+    max: number.max,
+    step: specStep(number),
+    format: (v) => (number.unit ? `${num(v)} ${number.unit}` : num(v)),
+    command: (v) => `vocoder ${name} ${num(v)}`,
+    reset: `vocoder ${name} reset`,
+    ...(value === undefined ? { off: "auto", start: number.min } : {}),
+    help: `${number.doc} · preset ${typeof fallback === "number" ? num(fallback) : String(resolved ?? "auto")} · x resets`,
+  };
+}
+
+/** A source as the picker shows it: its name, or its id when names clash. */
+function sourceLabel(track: Track, all: readonly Track[]): string {
+  const clash = all.some((t) => t.id !== track.id && t.name === track.name);
+  return clash || !track.name.trim() ? track.id : track.name;
+}
+
+/** `vocoder src <name>`, quoted when the name has spaces. */
+function srcCommand(label: string): string {
+  return /\s/.test(label) ? `vocoder src "${label}"` : `vocoder src ${label}`;
+}
+
+function entryRows(): MenuNode[] {
+  return vocoderEntryLines().map((line, index) => ({
+    kind: "info",
+    label: index === 0 ? "no voice yet" : "",
+    value: line.trim(),
+  }));
+}
+
+/** The rows inside Effects › Voice › Vocoder for the focused track. */
+export function vocoderRows(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  if (!track || track.instrument === "kit") return [];
+  const vocoder = track.vocoder;
+  const candidates = vocoderCandidates(context.score, track.id);
+  const all = context.score.tracks;
+  if (!vocoder) {
+    if (trackHasAudio(track))
+      return [
+        {
+          kind: "action",
+          label: "vocode",
+          command: "vocoder",
+          help: "adds a vocoder track driven by this voice (follows the song's chords, or drones on the key's root); mutes it",
+        },
+      ];
+    if (candidates.length === 0) return entryRows();
+    return [
+      {
+        kind: "choice",
+        label: "source",
+        value: NONE,
+        options: [NONE, ...candidates.map((t) => sourceLabel(t, all))],
+        command: (option) =>
+          option === NONE ? "vocoder off" : srcCommand(option),
+        help: "the voice that shapes this track's sound",
+      },
+    ];
+  }
+  const others = context.score.tracks.filter(
+    (t) => t.id !== track.id && t.instrument !== "kit",
+  );
+  const options = [
+    ...candidates.map((t) => sourceLabel(t, all)),
+    ...others
+      .filter((t) => !candidates.some((c) => c.id === t.id))
+      .map((t) => sourceLabel(t, all)),
+  ];
+  const current = all.find((t) => t.id === vocoder.src);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "source",
+      value: current ? sourceLabel(current, all) : (vocoder.src ?? NONE),
+      options: vocoder.src === undefined ? [NONE, ...options] : options,
+      command: (option) => (option === NONE ? "vocoder" : srcCommand(option)),
+      help: "the modulator; it is heard through the vocoder even when muted",
+    },
+    {
+      kind: "choice",
+      label: "preset",
+      value: vocoder.preset ?? DEFAULT_VOCODER_PRESET,
+      options: VOCODER_PRESET_NAMES,
+      command: (option) => `vocoder preset ${option}`,
+      help: "classic robot talkbox choir glass whisper smear lofi · keeps your overrides",
+    },
+    ...Object.keys(VOCODER_PARAMS).map((name) => paramRow(vocoder, name)),
+  ];
+  if (Object.keys(vocoder).some((key) => key !== "preset" && key !== "src"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "vocoder reset",
+      help: "clear overrides, keep the source and preset",
+    });
+  nodes.push({
+    kind: "action",
+    label: "remove the vocoder",
+    command: "vocoder off",
+    help: "the track plays its own sound again",
+  });
+  return nodes;
+}
+
+/** Effects › Voice › Vocoder. */
+export function vocoderEffectNode(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  if (!track || track.instrument === "kit") return [];
+  const vocoder = track.vocoder;
+  return [
+    {
+      kind: "menu",
+      id: "voice:vocoder",
+      label: "vocoder",
+      detail: vocoder
+        ? `${vocoder.preset ?? DEFAULT_VOCODER_PRESET}${vocoder.src ? ` · from ${vocoder.src}` : " · no source"}`
+        : trackHasAudio(track)
+          ? "vocode"
+          : "off",
+      help: "a voice shapes this track's sound: robot, talkbox, choir",
+      build: vocoderRows,
+    },
+  ];
+}
+
+/** Voice › voice presets › Vocoder: the built-in carrier. */
+export function vocoderBrowseNode(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  return [
+    {
+      kind: "menu",
+      id: "voices:vocoder",
+      label: "vocoder",
+      detail: `${VOCODER_PRESET_NAMES.length} presets · robot, talkbox, choir …`,
+      help: "a built-in synth carrier spoken through a voice track",
+      build: (inner) => {
+        const here = trackOf(inner) ?? track;
+        if (here && trackHasAudio(here))
+          return [
+            {
+              kind: "action",
+              label: "vocode",
+              command: "vocoder",
+              help: "adds a vocoder track driven by this voice",
+            },
+          ];
+        if (here?.instrument !== VOCODER_INSTRUMENT)
+          return [
+            {
+              kind: "action",
+              label: "make a vocoder",
+              command: `instrument ${VOCODER_INSTRUMENT}`,
+              help: "a supersaw carrier; then pick its presets and source here",
+            },
+            ...(vocoderCandidates(inner.score, inner.trackId).length === 0
+              ? entryRows()
+              : []),
+          ];
+        return VOCODER_PRESET_NAMES.map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(8)} ${VOCODER_PRESETS[name].doc}`,
+          command: `vocoder ${name}`,
+          help: VOCODER_PRESETS[name].doc,
+        })).concat(
+          vocoderCandidates(inner.score, inner.trackId).length === 0
+            ? entryRows()
+            : vocoderRows(inner).filter((row) => row.label === "source"),
+        );
+      },
+    },
+  ];
+}