@hraness/dawg 0.4.0 → 0.4.1

package/src/tui/menu.ts

@@ -119,6 +119,13 @@ export type MenuAudition = Readonly<{
   hint: string;
   /** `♪ solo · B staged 2 · 42 ms`, shown in the title. */
   status?: string | undefined;
+  /**
+   * Which commands stage while auditioning (default `isStageable`); the
+   * chord settings screen also stages `/chords …` and `key …`.
+   */
+  stageable?: (command: string) => boolean;
+  /** The committed chord settings, for `staged ← committed` on Chords rows. */
+  committedChords?: ChordSettings;
 }>;
 
 type NumberField = Readonly<{
@@ -1543,6 +1550,8 @@ function transportNodes(context: MenuContext): MenuNode[] {
 
 type Frame = {
   title: string;
+  /** The submenu's node id (`chords`), for `EditMenu.section`. */
+  id?: string;
   build: (context: MenuContext) => MenuNode[];
   index: number;
   query: string;
@@ -1573,6 +1582,7 @@ function childFrame(
 ): Frame {
   return {
     title: node.label,
+    id: node.id,
     index: 0,
     query: "",
     hover: `menu:${node.id}`,
@@ -1603,6 +1613,11 @@ export class EditMenu {
     return this.filtering || this.entry !== undefined;
   }
 
+  /** The root section open now (`chords`), or undefined at the root. */
+  get section(): string | undefined {
+    return this.stack[1]?.id;
+  }
+
   /** Open at the root, or at a section id (`effects`, `automation`). */
   show(context: MenuContext, section?: string): void {
     this.stack = [{ title: "menu", build: rootNodes, index: 0, query: "" }];
@@ -1777,7 +1792,7 @@ export class EditMenu {
       if (node.kind === "action")
         return frame.hover &&
           context.audition?.looping &&
-          isStageable(node.command)
+          (context.audition.stageable ?? isStageable)(node.command)
           ? { type: "choose", command: node.command, key: frame.hover }
           : { type: "run", command: node.command };
       if (node.kind === "choice") {
@@ -1822,7 +1837,8 @@ export class EditMenu {
   private hovered(frame: Frame, context: MenuContext): MenuResult {
     if (!frame.hover || !context.audition?.looping) return { type: "handled" };
     const node = this.selected(context);
-    if (node?.kind !== "action" || !isStageable(node.command))
+    const stageable = context.audition?.stageable ?? isStageable;
+    if (node?.kind !== "action" || !stageable(node.command))
       return { type: "handled" };
     frame.hovering = true;
     return { type: "hover", command: node.command, key: frame.hover };
@@ -1932,6 +1948,9 @@ export class EditMenu {
       for (const node of frame.build({
         ...context,
         score: audition.committed,
+        ...(audition.committedChords
+          ? { chords: audition.committedChords }
+          : {}),
       }))
         before.set(node.label, valueText(node));
     const items = nodes.map((node, at) => {

package/src/tui/play-chords.ts

@@ -25,6 +25,11 @@
 import {
   BASS_MODES,
   CHORD_PATTERNS,
+  DEFAULT_ARP_RATE,
+  DEFAULT_STRUM,
+  generateProgression,
+  presetChords,
+  renderProgression,
   CHORD_TYPES,
   EXTENSIONS,
   MAX_VOICING_STEP,
@@ -56,7 +61,12 @@ import {
   type ProgressionStyle,
   type Spread,
 } from "../../core/chords.ts";
-import { isSamplerInstrument, type Track } from "../../core/score.ts";
+import {
+  isSamplerInstrument,
+  type NoteInput,
+  type Track,
+  type TrackScore,
+} from "../../core/score.ts";
 
 export const CHORD_MODES = ["auto", "manual", "off"] as const;
 export type ChordMode = (typeof CHORD_MODES)[number];
@@ -536,3 +546,85 @@ export function chordsSummary(settings: ChordSettings): string {
     `style ${s.style}`,
   ].join(" · ");
 }
+
+/** Chords in the chord settings screen's audition phrase. */
+const PHRASE_CHORDS = 4;
+
+/**
+ * What the chord settings sound like, for the audition loop: the chosen
+ * progression (the preset, or four chords of the style's seeded walk) in the
+ * song key, voiced and performed with `settings` (voicing, spread, sevenths,
+ * perform mode, pattern, arp rate and octaves, bass mode), one chord per bar
+ * or two per bar in a one-bar loop. With chords `off` it plays each chord's
+ * root alone, as play mode would. Deterministic: the same settings and key
+ * always give the same notes.
+ */
+export function chordPhrase(
+  settings: ChordSettings,
+  score: TrackScore,
+  track: Track,
+  bars: number,
+): NoteInput[] {
+  const key = parseKey(score.key) ?? { tonic: 0, mode: "major" as const };
+  const preset =
+    settings.preset === "none" ? undefined : findPreset(settings.preset);
+  const progression = preset
+    ? presetChords(key, preset)
+    : generateProgression({
+        key,
+        length: PHRASE_CHORDS,
+        style: settings.style,
+        seed: 1,
+        sevenths: settings.sevenths,
+      });
+  const tpb = score.ticksPerBeat;
+  const totalBeats = Math.max(1, bars) * score.beatsPerBar;
+  const count = Math.max(2, Math.max(1, bars));
+  const span = totalBeats / count;
+  const chords = Array.from(
+    { length: count },
+    (_, index) => progression[index % progression.length]!,
+  );
+  const mode = settings.perform;
+  const rendered = renderProgression({
+    key,
+    chords,
+    beatsPerChord: span,
+    inversion: settings.inversion,
+    spread: settings.spread,
+    bassMode: settings.mode === "off" ? "solo" : settings.bass,
+    perform: {
+      mode,
+      rate:
+        settings.rate === "grid" ? DEFAULT_ARP_RATE : RATE_BEATS[settings.rate],
+      octaves: settings.octaves,
+      strum: mode === "harp" ? DEFAULT_STRUM * 2 : DEFAULT_STRUM,
+      seed: 1,
+      velocity: 0.8,
+      ...(mode === "pattern" ? { pattern: settings.pattern } : {}),
+    },
+  });
+  // With chords off a key plays one note: the root, in the chord's octave.
+  const performed =
+    settings.mode === "off"
+      ? rendered.bass.map((note) => ({ ...note, pitch: note.pitch + 24 }))
+      : [...rendered.notes, ...rendered.bass];
+  const end = totalBeats * tpb;
+  const notes: NoteInput[] = [];
+  for (const note of performed) {
+    const startTick = Math.round(note.start * tpb);
+    if (startTick >= end) continue;
+    notes.push({
+      id: `chords-${notes.length + 1}`,
+      trackId: track.id,
+      startTick,
+      durationTicks: Math.max(
+        1,
+        Math.min(Math.round(note.length * tpb), end - startTick),
+      ),
+      pitch: note.pitch,
+      velocity: note.velocity,
+    });
+  }
+  return notes;
+}

package/tui/grammar.ts

@@ -80,7 +80,7 @@ export const HINTS = {
   action: " ↑↓ move · enter apply · / filter · esc back · ? keys ",
   typing: " type a value · enter apply · esc cancel ",
   euclid:
-    " ↑↓ voice · ←→ adjust · tab field · space hear · x off · esc back · ? keys ",
+    " ↑↓ voice · ←→ adjust · tab field · space loop · x off · esc back · ? keys ",
   text: " ↑↓ scroll · pgup pgdn page · esc back · ? keys ",
   log: " ↑↓ scroll · / filter · esc back · ? keys ",
   keys: " any key closes ",
@@ -88,6 +88,27 @@ export const HINTS = {
 
 // ── the `?` panel ─────────────────────────────────────────────────────
 
+/** The audition loop's keys, shared by the menu and the rhythm editor. */
+const AUDITIONING: readonly KeySection[] = [
+  {
+    title: "auditioning",
+    rows: [
+      ["space", "loop the focused track · again stops"],
+      ["c", "solo ↔ in context (the whole mix)"],
+      ["a", "A/B: committed ↔ staged"],
+      ["enter", "keep staged changes (one undo step)"],
+      ["esc", "revert staged changes"],
+    ],
+  },
+  {
+    title: "every change",
+    rows: [
+      ["", "while looping, stages; otherwise runs the command shown"],
+      ["ctrl-z", "undoes it"],
+    ],
+  },
+];
+
 const LIST: readonly KeyRow[] = [
   ["↑ ↓  j k", "move"],
   ["pgup pgdn", "page"],
@@ -166,23 +187,7 @@ export const KEYS = {
         ["x  delete", "reset to default (deletes an automation point)"],
       ],
     },
-    {
-      title: "auditioning",
-      rows: [
-        ["space", "loop the focused track · again stops"],
-        ["c", "solo ↔ in context (the whole mix)"],
-        ["a", "A/B: committed ↔ staged"],
-        ["enter", "keep staged changes (one undo step)"],
-        ["esc", "revert staged changes"],
-      ],
-    },
-    {
-      title: "every change",
-      rows: [
-        ["", "while looping, stages; otherwise runs the command shown"],
-        ["ctrl-z", "undoes it"],
-      ],
-    },
+    ...AUDITIONING,
   ],
   euclid: [
     {
@@ -193,12 +198,12 @@ export const KEYS = {
         ["tab shift-tab  ] [", "next / previous field"],
         ["0-9", "type a value, enter applies"],
         ["enter", "add a row (or type a value)"],
-        ["space", "hear the voice"],
         ["x", "turn the row off"],
         ["f", "freeze into plain hits"],
         ["esc", "back"],
       ],
     },
+    ...AUDITIONING,
   ],
   text: [
     {