@hraness/dawg 0.5.0 → 0.6.1

package/src/tui/modal-menu.ts

@@ -0,0 +1,145 @@
+/**
+ * Ctrl-k menu rows for modal percussion (0.6): the "Mallets and bells"
+ * group under Sound › browse sounds, 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";
+import {
+  GAMELAN_PRESETS,
+  MODAL_INSTRUMENT,
+  MODAL_MALLET_NAMES,
+  MODAL_PARAMS,
+  MODAL_PRESETS,
+  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";
+
+/** Sound › browse sounds › Mallets and bells: one row per preset. */
+export function malletsMenu(): MenuNode {
+  return {
+    kind: "menu",
+    id: "mallets",
+    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: () => [
+      // 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),
+  };
+}
+
+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) => `modal ${name} ${num(v)}`,
+    reset: `modal ${name} off`,
+    help: `${spec.doc} · preset ${num(fallback)} · x resets`,
+  };
+}
+
+/** Sound › Parameters rows on a modal track. */
+export function modalParameterNodes(track: Track): MenuNode[] {
+  if (track.instrument !== MODAL_INSTRUMENT) return [];
+  const modal = track.modal;
+  const preset = MODAL_PRESETS[modal?.preset ?? "marimba"].settings;
+  const resolved = modalSettings(modal) as Readonly<
+    Record<string, number | string>
+  >;
+  const row = (name: string): MenuNode | undefined => {
+    const spec = MODAL_PARAMS[name]!;
+    if (name === "mallet")
+      return {
+        kind: "choice",
+        label: "mallet",
+        value: modal?.mallet ?? "preset",
+        options: ["preset", ...MODAL_MALLET_NAMES],
+        command: (option) =>
+          option === "preset" ? "modal mallet off" : `modal mallet ${option}`,
+        help: (spec as EnumParam).doc,
+      };
+    if (spec.kind !== "number") return undefined;
+    return numberRow(
+      name,
+      spec,
+      Number(resolved[name]),
+      Number(preset[name as keyof typeof preset]),
+    );
+  };
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "preset",
+      value: modal?.preset ?? "marimba",
+      options: MODAL_PRESET_NAMES,
+      command: (option) => `modal preset ${option}`,
+      help: "the instrument: mode table, mallet and ring",
+    },
+  ];
+  for (const name of MODAL_SIMPLE) {
+    const node = row(name);
+    if (node) nodes.push(node);
+  }
+  const rest = Object.keys(MODAL_PARAMS).filter(
+    (name) => !(MODAL_SIMPLE as readonly string[]).includes(name),
+  );
+  nodes.push({
+    kind: "menu",
+    id: "modal:advanced",
+    label: "advanced",
+    detail: `motor, ombak, buzz, click, strike glide, gain`,
+    help: "every modal parameter",
+    build: () => rest.flatMap((name) => row(name) ?? []),
+  });
+  if (modal && Object.keys(modal).some((key) => key !== "preset"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "modal reset",
+      help: "clear overrides, keep the preset",
+    });
+  return nodes;
+}

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

@@ -48,21 +48,25 @@ import {
   transportBarStart,
 } from "../../core/tempo.ts";
 import {
+  LiveFullRenderer,
   LiveSynth,
   MAX_LIVE_NOTE_SECONDS,
   type LiveNotePcm,
 } from "../audio/live.ts";
 import type { SampleBank } from "../audio/samples.ts";
+import { fitting, onFitReady } from "../audio/fit.ts";
 import {
   DEFAULT_STRUM,
   perform,
   type PerformMode,
+  type PerformOptions,
   type PerformedNote,
 } from "../../core/chords.ts";
 import {
   ChordPad,
   chordCapable,
   defaultChordSettings,
+  guitarPerform,
   songKey,
   type ChordSettings,
   type PlayedChord,
@@ -91,6 +95,8 @@ export interface LiveEngine {
   setLeadMs(ms: number | undefined): void;
   noteOn(id: number, note: LiveNotePcm): number;
   noteOff(id: number): void;
+  /** Frames of voice `id` mixed so far, or undefined once it has ended. */
+  voicePosition?(id: number): number | undefined;
   setClick(click: ClickBus | undefined): void;
 }
 
@@ -134,6 +140,8 @@ export const GRIDS: readonly Readonly<{ label: string; beats: number }>[] =
 export const DEFAULT_GRID = "1/16";
 /** Play mode's queue lead: short enough that a key feels immediate. */
 export const PLAY_LEAD_MS = 60;
+/** Status while a long fitted sample window computes (fit.ts). */
+const FITTING_STATUS = "fitting · the sample plays once ready";
 export const FLASH_MS = 110;
 
 export function gridBeats(label: string): number | undefined {
@@ -175,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()`. */
@@ -221,11 +231,16 @@ export class PlaySession {
   public countInBars = 1;
   public grid = DEFAULT_GRID;
   public status: string | undefined;
+  /** Unsubscribes the pending "fit ready" listener (fit.ts). */
+  private stopFitWait: (() => void) | undefined;
   /** Scale-degree layout on (`i`); follows key and tuning changes. */
   public degreesOn = false;
   private degreeKey: string | undefined;
   private active = false;
   private synth: LiveSynth | undefined;
+  /** Rig voices awaiting their full render: id → released since. */
+  private readonly windows = new Map<number, boolean>();
+  private readonly fullRenderer = new LiveFullRenderer();
   private readonly pending = new Map<number, Pending>();
   /** Sustain changes while recording (Tab latch or Shift), as pedal events. */
   private pendingPedal: { beat: number; state: PedalState }[] = [];
@@ -597,7 +612,7 @@ export class PlaySession {
     if (this.synth?.rate !== engine.sampleRate)
       this.synth = new LiveSynth(engine.sampleRate);
     const score = this.host.score();
-    const pcm = this.synth.render({
+    const request = {
       score,
       trackId: this.trackId,
       pitch: note.pitch,
@@ -607,16 +622,53 @@ export class PlaySession {
       ...(score.time?.tempo
         ? { tick: loopTickAt(score, this.host.beatAt(note.atMs)) }
         : {}),
-    });
+    };
+    const synth = this.synth;
+    const pcm = synth.render(request);
     if (!pcm) return;
+    if (pcm.fitting) {
+      // A long fitted sample window is computing: silent, never off-pitch.
+      this.status = FITTING_STATUS;
+      this.stopFitWait ??= onFitReady(() => {
+        if (fitting()) return;
+        this.stopFitWait?.();
+        this.stopFitWait = undefined;
+        if (this.status === FITTING_STATUS)
+          this.status = "fit ready · play the key again";
+      });
+      return;
+    }
     const scheduled = engine.noteOn(id, pcm);
     this.lastLatencyMs = Math.max(0, scheduled - this.host.now());
+    // A guitar rig sounds its first window now; the rest renders after the
+    // key event and replaces the voice in place while it is still sounding.
+    this.windows.delete(id);
+    if (pcm.partial) this.windows.set(id, false);
+    // 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,
+          pcm.clock === undefined ? request : { ...request, clock: pcm.clock },
+        )
+        .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 {
     const engine = this.host.engine();
     for (const id of ids) {
       engine?.noteOff(id);
+      if (this.windows.has(id)) this.windows.set(id, true);
       const live = this.liveChords.get(id);
       if (live) live.releaseAtMs = Math.min(live.releaseAtMs, atMs);
       const pending = this.pending.get(id);
@@ -686,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 } : {}),
     };
   }
 
@@ -706,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({
@@ -1170,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),