@hraness/dawg 0.6.0 → 0.6.1

package/src/tui/modal-menu.ts

@@ -5,6 +5,7 @@
  */
 import type { EnumParam, NumberParam } from "../../core/params.ts";
 import {
+  GAMELAN_PRESETS,
   MODAL_INSTRUMENT,
   MODAL_MALLET_NAMES,
   MODAL_PARAMS,
@@ -12,6 +13,7 @@ import {
   MODAL_PRESET_NAMES,
   MODAL_SIMPLE,
   modalSettings,
+  type ModalPresetName,
 } from "../../core/resonators.ts";
 import type { Track } from "../../core/score.ts";
 import { num, specStep, type MenuNode } from "./menu.ts";
@@ -24,13 +26,38 @@ export function malletsMenu(): MenuNode {
     label: "Mallets and bells",
     detail: `${MODAL_PRESET_NAMES.length} modal presets · marimba, vibes, gong …`,
     help: "struck bars, bells and bowls on the modal resonator engine",
-    build: () =>
-      MODAL_PRESET_NAMES.map((name): MenuNode => ({
-        kind: "action",
-        label: `${name}  ${MODAL_PRESETS[name].doc}`,
-        command: `modal ${name}`,
-        help: MODAL_PRESETS[name].styles,
-      })),
+    build: () => [
+      // The core presets keep their rows (gong too); the gamelan bronzes
+      // added in 0.6.1 sit in their own sub-group.
+      ...MODAL_PRESET_NAMES.filter(
+        (name) => name === "gong" || !GAMELAN_PRESETS.includes(name),
+      ).map(presetRow),
+      gamelanMenu(),
+    ],
+  };
+}
+
+function presetRow(name: ModalPresetName): MenuNode {
+  return {
+    kind: "action",
+    label: `${name}  ${MODAL_PRESETS[name].doc}`,
+    command: `modal ${name}`,
+    help: MODAL_PRESETS[name].styles,
+  };
+}
+
+/**
+ * Mallets and bells › Gamelan (f061-gamelan-winds): the Javanese and
+ * Balinese bronzes. `modal gamelan` points here.
+ */
+export function gamelanMenu(): MenuNode {
+  return {
+    kind: "menu",
+    id: "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

@@ -12,6 +12,7 @@ import {
   VELOCITY_CURVES,
 } from "../../core/expression.ts";
 import type { Note, Track } from "../../core/score.ts";
+import { isPianoFamily } from "../../core/keys.ts";
 import {
   BEND_SHAPES,
   DEFAULT_HUMANIZE,
@@ -50,12 +51,50 @@ export function performanceDetail(track: Track | undefined): string {
   const parts = [
     track.glide ? `glide ${track.glide.mode}` : "",
     track.pedal?.length ? "pedal" : "",
+    track.softPedal?.length ? "soft" : "",
+    track.sostenuto?.length ? "sost" : "",
     track.velocityCurve ? `vel ${track.velocityCurve.curve}` : "",
     track.humanize ? "humanized" : "",
   ].filter(Boolean);
   return parts.length ? parts.join(" · ") : "as written";
 }
 
+/** Soft pedal and Sostenuto rows: off, the current lane, or the whole loop. */
+function pianoPedalNodes(track: Track): MenuNode[] {
+  const rows = [
+    {
+      lane: "soft",
+      label: "soft pedal",
+      events: track.softPedal,
+      help: "una corda: the hammers shift to strike fewer strings, softer and darker; read at each note's onset",
+    },
+    {
+      lane: "sost",
+      label: "sostenuto",
+      events: track.sostenuto,
+      help: "holds only the keys already down when it presses (the middle pedal); later notes damp normally",
+    },
+  ] as const;
+  return rows
+    .filter((row) => isPianoFamily(track.instrument) || row.events?.length)
+    .map((row): MenuNode => {
+      const value = row.events?.length ? `${row.events.length} events` : "off";
+      return {
+        kind: "choice",
+        label: row.label,
+        value,
+        options: ["off", ...(value === "off" ? [] : [value]), "bars"],
+        command: (option) =>
+          option === "bars"
+            ? `pedal ${row.lane} bars`
+            : option === "off"
+              ? `pedal ${row.lane} off`
+              : `pedal ${row.lane}`,
+        help: row.help,
+      };
+    });
+}
+
 export function performanceNodes(context: MenuContext): MenuNode[] {
   const track = context.score.tracks.find(
     (item) => item.id === context.trackId,
@@ -148,6 +187,9 @@ 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
+    // tracks (or wherever a lane is already set).
+    ...pianoPedalNodes(track),
     {
       kind: "choice",
       label: "velocity curve",

package/src/tui/play-chords.ts

@@ -35,6 +35,10 @@ import {
   EXTENSIONS,
   MAX_VOICING_STEP,
   PERFORM_MODES,
+  DEFAULT_STROKE_SPEED,
+  STROKE_PATTERN_NAMES,
+  strokeGrid,
+  type PerformOptions,
   PROGRESSION_PRESETS,
   PROGRESSION_STYLES,
   SPREADS,
@@ -100,6 +104,10 @@ export type ChordSettings = {
   /** `none` or a PROGRESSION_PRESETS name; drives the "next" suggestion. */
   preset: string;
   style: ProgressionStyle;
+  /** Guitar perform mode: a STROKE_PATTERNS name or a D U d u x - . grid. */
+  strokes: string;
+  /** Guitar perform mode: ms a full six-string down stroke takes. */
+  speed: number;
 };
 
 export function defaultChordSettings(): ChordSettings {
@@ -116,9 +124,45 @@ export function defaultChordSettings(): ChordSettings {
     sevenths: false,
     preset: "none",
     style: "pop",
+    strokes: "down",
+    speed: DEFAULT_STROKE_SPEED * 1000,
   };
 }
 
+/** Play mode's `[` / `]` strum speed step in ms. */
+export const STROKE_SPEED_STEP = 5;
+
+/** Strum speed bounds in ms (0 = every string at once). */
+export const STROKE_SPEED_MS = Object.freeze({ min: 0, max: 200 });
+
+/**
+ * A strum speed from `/chords speed` text: milliseconds (`22`, `22ms`) or
+ * beats (`1/32b`, `0.05b`) at `bpm`. Undefined when not a speed.
+ */
+export function parseStrokeSpeed(
+  text: string | undefined,
+  bpm: number,
+): number | undefined {
+  const raw = (text ?? "").trim().toLowerCase();
+  const beats = /^(\d+(?:\.\d+)?)(?:\/(\d+))?\s*(?:b|beats?)$/.exec(raw);
+  let ms: number;
+  if (beats) {
+    const value = Number(beats[1]) / (beats[2] ? Number(beats[2]) : 1);
+    ms = (value * 60_000) / bpm;
+  } else {
+    const plain = /^(\d+(?:\.\d+)?)\s*(?:ms)?$/.exec(raw);
+    if (!plain) return undefined;
+    ms = Number(plain[1]);
+  }
+  if (
+    !Number.isFinite(ms) ||
+    ms < STROKE_SPEED_MS.min ||
+    ms > STROKE_SPEED_MS.max
+  )
+    return undefined;
+  return Math.round(ms * 10) / 10;
+}
+
 /**
  * Tracks where auto chords are the default: anything pitched that is not a
  * bass, a drum kit or a one-shot sampler.
@@ -236,6 +280,16 @@ export class ChordPad {
       s.perform = PERFORM_MODES[(index + 1) % PERFORM_MODES.length]!;
       return { type: "status", status: `perform ${s.perform}` };
     }
+    if ((value === "[" || value === "]") && s.perform === "guitar") {
+      // Strum speed: slower ([) or faster (]) in 5 ms steps.
+      const wanted =
+        s.speed + (value === "[" ? STROKE_SPEED_STEP : -STROKE_SPEED_STEP);
+      s.speed = Math.max(
+        STROKE_SPEED_MS.min,
+        Math.min(STROKE_SPEED_MS.max, Math.round(wanted)),
+      );
+      return { type: "status", status: `strum speed ${s.speed}ms` };
+    }
     if (value === "b") {
       const index = BASS_MODES.indexOf(s.bass);
       s.bass = BASS_MODES[(index + 1) % BASS_MODES.length]!;
@@ -392,6 +446,9 @@ export class ChordPad {
       { key: "0", label: "clear", on: false },
       { key: "-=", label: `voicing ${signed(s.inversion)}`, on: false },
       { key: "9", label: perform, on: false },
+      ...(s.perform === "guitar"
+        ? [{ key: "[]", label: `speed ${s.speed}ms`, on: false }]
+        : []),
       { key: "b", label: `bass ${s.bass}`, on: false },
       { key: "n", label: "next", on: false },
       { key: "q", label: s.mode === "auto" ? "auto" : "manual", on: false },
@@ -412,6 +469,8 @@ export class ChordPad {
     if (s.spread !== "close") parts.push(s.spread);
     if (s.perform === "pattern")
       parts.push(`pattern ${patternLabel(s.pattern)}`);
+    else if (s.perform === "guitar")
+      parts.push(`guitar ${s.strokes} ${s.speed}ms`);
     else if (s.perform !== "block") parts.push(s.perform);
     if (s.bass !== "off") parts.push(`bass ${s.bass}`);
     return parts.join(" · ");
@@ -435,15 +494,18 @@ function signed(value: number): string {
 /**
  * `/chords …`: `auto|manual|off`, `voicing <-12..12>`, `spread <close|open|
  * wide>`, `bass off|chords|unison|single|solo` (`on` = chords), `perform
- * <mode>`, `pattern <1..13|name>`, `rate <grid|1/8…>`, `octaves
+ * <mode>`, `pattern <1..13|name>`, `strokes <name|D-DU-UDU>` (guitar
+ * mode), `speed <ms|1/32b>`, `rate <grid|1/8…>`, `octaves
  * <1..4>`, `sevenths on|off`, `preset <name|none>`, `style <pop|jazz|…>`.
  * Mutates `settings`; returns the receipt or an error.
  */
 export function applyChordsCommand(
   settings: ChordSettings,
   argument: string,
+  bpm = 120,
 ): { ok: boolean; message: string } {
-  const words = argument.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const raw = argument.trim().split(/\s+/).filter(Boolean);
+  const words = raw.map((word) => word.toLowerCase());
   const [head, value] = words;
   const done = (message: string) => ({ ok: true, message });
   const bad = (message: string) => ({ ok: false, message });
@@ -505,6 +567,28 @@ export function applyChordsCommand(
         return bad(`rate takes ${ARP_RATES.join("|")}`);
       settings.rate = value as ArpRate;
       return done(`chords rate ${value}`);
+    case "strokes": {
+      // Case matters: D is a full down stroke, d a light one.
+      const grid = raw.slice(1).join("");
+      if (!strokeGrid(grid))
+        return bad(
+          `strokes takes ${STROKE_PATTERN_NAMES.join("|")} or a grid of D U d u x - .`,
+        );
+      settings.strokes = (STROKE_PATTERN_NAMES as readonly string[]).includes(
+        grid.toLowerCase(),
+      )
+        ? grid.toLowerCase()
+        : grid;
+      settings.perform = "guitar";
+      return done(`chords strokes ${settings.strokes}`);
+    }
+    case "speed": {
+      const ms = parseStrokeSpeed(words.slice(1).join(""), bpm);
+      if (ms === undefined)
+        return bad("speed takes 0..200 ms (22, 22ms) or beats (1/32b)");
+      settings.speed = ms;
+      return done(`chords speed ${ms}ms`);
+    }
     case "octaves": {
       const n = Number(value);
       if (!Number.isInteger(n) || n < 1 || n > 4)
@@ -526,7 +610,7 @@ export function applyChordsCommand(
       return done(`chords style ${value}`);
     default:
       return bad(
-        "/chords auto|manual|off · voicing · spread · bass · perform · pattern · rate · octaves · sevenths · preset · style",
+        "/chords auto|manual|off · voicing · spread · bass · perform · pattern · strokes · speed · rate · octaves · sevenths · preset · style",
       );
   }
 }
@@ -539,6 +623,8 @@ export function chordsSummary(settings: ChordSettings): string {
     s.spread,
     s.perform,
     `pattern ${patternLabel(s.pattern)}`,
+    `strokes ${s.strokes}`,
+    `speed ${s.speed}ms`,
     `rate ${s.rate}`,
     `octaves ${s.octaves}`,
     `bass ${s.bass}`,
@@ -603,6 +689,7 @@ export function chordPhrase(
       seed: 1,
       velocity: 0.8,
       ...(mode === "pattern" ? { pattern: settings.pattern } : {}),
+      ...(mode === "guitar" ? guitarPerform(settings, score, track) : {}),
     },
   });
   // With chords off a key plays one note: the root, in the chord's octave.
@@ -630,3 +717,17 @@ export function chordPhrase(
   }
   return notes;
 }
+
+/** Perform options for the guitar mode: strokes, speed, tempo and fretting. */
+export function guitarPerform(
+  settings: Pick<ChordSettings, "strokes" | "speed">,
+  score: Pick<TrackScore, "tempoBpm">,
+  track: Pick<Track, "guitar"> | undefined,
+): Partial<PerformOptions> {
+  return {
+    strokes: settings.strokes,
+    speed: settings.speed / 1000,
+    tempo: score.tempoBpm,
+    ...(track?.guitar ? { guitar: track.guitar } : {}),
+  };
+}

package/src/tui/play-mode.ts

@@ -12,6 +12,7 @@
  *   Shift  sustain while held    Tab    sustain latch     Esc  leave the mode
  *   (while recording, sustain changes record as track pedal events)
  *   I      scale degrees: the home row plays the key's scale (any tuning)
+ *   [ / ]  strum slower / faster (chords perform guitar, 5 ms steps)
  *
  * Terminals report key-down only, so a held key is synthesized from the
  * keyboard's auto-repeat: a press sounds for the gate (one grid step by

package/src/tui/play-session.ts

@@ -59,12 +59,14 @@ import {
   DEFAULT_STRUM,
   perform,
   type PerformMode,
+  type PerformOptions,
   type PerformedNote,
 } from "../../core/chords.ts";
 import {
   ChordPad,
   chordCapable,
   defaultChordSettings,
+  guitarPerform,
   songKey,
   type ChordSettings,
   type PlayedChord,
@@ -181,6 +183,8 @@ export type RecordedChord = Readonly<{
   seed: number;
   /** CHORD_PATTERNS name when `mode` is `pattern`. */
   pattern?: string;
+  /** Guitar mode: strokes, speed, tempo, fretting and the chord root. */
+  guitar?: Partial<PerformOptions>;
 }>;
 
 /** A chord sounding live: its voices start and stop from `tick()`. */
@@ -643,16 +647,21 @@ export class PlaySession {
     // The full pass runs on a worker, in key order, so a strummed chord or a
     // fast run never stalls key handling behind an oversampled render.
     if (pcm.partial)
-      void this.fullRenderer.full(synth, request).then((full) => {
-        // Not after note-off: a swap would cancel the release fade.
-        if (
-          full &&
-          this.windows.get(id) === false &&
-          engine.voicePosition?.(id) !== undefined
+      void this.fullRenderer
+        .full(
+          synth,
+          pcm.clock === undefined ? request : { ...request, clock: pcm.clock },
         )
-          engine.noteOn(id, full);
-        this.windows.delete(id);
-      });
+        .then((full) => {
+          // Not after note-off: a swap would cancel the release fade.
+          if (
+            full &&
+            this.windows.get(id) === false &&
+            engine.voicePosition?.(id) !== undefined
+          )
+            engine.noteOn(id, full);
+          this.windows.delete(id);
+        });
   }
 
   private release(ids: readonly number[], atMs: number): void {
@@ -729,6 +738,20 @@ export class PlaySession {
       octaves: settings.octaves,
       seed,
       ...(mode === "pattern" ? { pattern: settings.pattern } : {}),
+      ...(mode === "guitar" ? { guitar: this.guitarOptions(played) } : {}),
+    };
+  }
+
+  /** Guitar-mode perform options for a played chord (strokes, speed, frets). */
+  private guitarOptions(played: PlayedChord): Partial<PerformOptions> {
+    return {
+      ...guitarPerform(
+        this.chords.settings,
+        { tempoBpm: this.currentBpm() },
+        this.trackData(),
+      ),
+      root: played.chord.root,
+      ...(played.chord.bass !== undefined ? { slash: played.chord.bass } : {}),
     };
   }
 
@@ -749,6 +772,7 @@ export class PlaySession {
       seed: note.id,
       pattern: settings.pattern,
       velocity: 1,
+      ...(mode === "guitar" ? this.guitarOptions(played) : {}),
     });
     if (played.bass !== undefined)
       plan.push({
@@ -1213,6 +1237,7 @@ export function chordNotes(
     seed: chord.seed,
     ...(chord.pattern !== undefined ? { pattern: chord.pattern } : {}),
     velocity: 1,
+    ...chord.guitar,
   }).map((note) => ({
     pitch: note.pitch,
     velocity: scaleVelocity(press.velocity, note.velocity),

package/src/tui/wind-menu.ts

@@ -0,0 +1,144 @@
+/**
+ * Ctrl-k menu rows for the wind engine (0.6.1): the "Winds and brass" group
+ * under Sound › browse sounds, and the WIND_PARAMS rows under Sound ›
+ * Parameters on a wind-engine track. Every row runs a `wind …` command.
+ */
+import type { EnumParam, NumberParam } from "../../core/params.ts";
+import type { Track } from "../../core/score.ts";
+import {
+  DEFAULT_WIND_PRESET,
+  WIND_GROUPS,
+  WIND_INSTRUMENT,
+  WIND_PARAMS,
+  WIND_PRESETS,
+  WIND_PRESET_NAMES,
+  WIND_SIMPLE,
+  windSettings,
+  type WindPresetName,
+} from "../../core/winds.ts";
+import { num, specStep, type MenuNode } from "./menu.ts";
+
+function presetRow(name: WindPresetName): MenuNode {
+  return {
+    kind: "action",
+    label: `${name.padEnd(13)} ${WIND_PRESETS[name].doc}`,
+    command: `wind ${name}`,
+    help: WIND_PRESETS[name].styles,
+  };
+}
+
+/** Sound › browse sounds › Winds and brass: flutes, reeds, brass. */
+export function windsMenu(): MenuNode {
+  return {
+    kind: "menu",
+    id: "winds",
+    label: "Winds and brass",
+    detail: `${WIND_PRESET_NAMES.length} blown · flute, sax, trumpet …`,
+    help: "breath-driven waveguides: flutes, reeds and brass; wind players 4 for a section",
+    build: () =>
+      WIND_GROUPS.map((group): MenuNode => ({
+        kind: "menu",
+        id: `winds:${group.label.toLowerCase()}`,
+        label: group.label,
+        detail: group.presets.slice(0, 3).join(", ") + " …",
+        help: `${group.label.toLowerCase()} on the wind engine`,
+        build: () => group.presets.map(presetRow),
+      })),
+  };
+}
+
+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) => `wind ${name} ${num(v)}`,
+    reset: `wind ${name} off`,
+    help: `${spec.doc} · preset ${num(fallback)} · x resets`,
+  };
+}
+
+/** Sound › Parameters rows on a wind-engine track. */
+export function windParameterNodes(track: Track): MenuNode[] {
+  if (track.instrument !== WIND_INSTRUMENT || !track.wind) return [];
+  const wind = track.wind;
+  const preset = WIND_PRESETS[wind.preset ?? DEFAULT_WIND_PRESET].settings;
+  const resolved = windSettings(wind) as Readonly<
+    Record<string, number | string | boolean>
+  >;
+  const fallback = preset as Readonly<
+    Record<string, number | string | boolean>
+  >;
+  const row = (name: string): MenuNode | undefined => {
+    const spec = WIND_PARAMS[name]!;
+    const own = (wind as Record<string, unknown>)[name];
+    if (spec.kind === "enum")
+      return {
+        kind: "choice",
+        label: name,
+        value: own === undefined ? "preset" : String(own),
+        options: ["preset", ...(spec as EnumParam).values],
+        command: (option) =>
+          option === "preset" ? `wind ${name} unset` : `wind ${name} ${option}`,
+        help: `${spec.doc} · preset ${String(fallback[name])}`,
+      };
+    if (spec.kind === "boolean")
+      return {
+        kind: "choice",
+        label: name,
+        value: own === undefined ? "preset" : own ? "on" : "off",
+        options: ["preset", "on", "off"],
+        command: (option) =>
+          option === "preset" ? `wind ${name} unset` : `wind ${name} ${option}`,
+        help: `${spec.doc} · preset ${fallback[name] ? "on" : "off"}`,
+      };
+    return numberRow(
+      name,
+      spec,
+      Number(resolved[name]),
+      Number(fallback[name]),
+    );
+  };
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: wind.preset ?? DEFAULT_WIND_PRESET,
+      options: WIND_PRESET_NAMES,
+      command: (option) => `wind preset ${option}`,
+      help: "the instrument: bore, exciter, range and mute",
+    },
+  ];
+  for (const name of WIND_SIMPLE) {
+    const node = row(name);
+    if (node) nodes.push(node);
+  }
+  const rest = Object.keys(WIND_PARAMS).filter(
+    (name) => !(WIND_SIMPLE as readonly string[]).includes(name),
+  );
+  nodes.push({
+    kind: "menu",
+    id: "wind:advanced",
+    label: "advanced",
+    detail: rest.join(", "),
+    help: "every wind parameter",
+    build: () => rest.flatMap((name) => row(name) ?? []),
+  });
+  if (Object.keys(wind).some((key) => key !== "preset"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "wind reset",
+      help: "clear overrides, keep the preset",
+    });
+  return nodes;
+}