@hraness/dawg 0.6.0 → 0.6.1

package/src/commands/keys.ts

@@ -10,6 +10,17 @@
  *   keys <param> off              unset one parameter (back to the preset's)
  *   keys reset                    the family's own sound (`keys: {}`),
  *                                 dropping the preset's unedited effects
+ *   tonewheel [888800008]         the tonewheel organ (hammond, b3), drawbars
+ *   combo [08880]                 the combo organ (farfisa), registers
+ *   pipe [plenum | flute8 …]      the pipe organ (church), stops
+ *   rotary slow|fast|stop         the organ's rotary speaker speed
+ *   rotary fast at <beat>         a keys-rotary lane point (the Leslie switch)
+ *   keys drawbars 888800008       organ text rows: drawbars registers stops
+ *   epiano | wurli | clav         the electric keys (0.6.1), also rhodes
+ *                                 suitcase dyno wurlitzer clavinet funkclav
+ *   epiano preset <name>          an electric preset
+ *   epiano <param> <value> […]    set electric parameters (vibe 0.6 …);
+ *                                 the track becomes that family first
  *
  * Every new write of `piano` stores `instrument: "grand"` with `keys`; a
  * stored legacy `instrument: "piano"` is never rewritten unless asked. Each
@@ -17,18 +28,34 @@
  */
 import { FxValidationError } from "../../core/params.ts";
 import {
+  ELECTRIC_FAMILIES,
   KEYS_PARAMS,
   KEYS_PRESETS,
-  KEYS_SIMPLE,
+  KEYS_PARAM_FAMILIES,
+  ORGAN_ALIASES,
+  ORGAN_TEXT,
+  PIANO_FAMILIES,
+  PIPE_REGISTRATIONS,
+  PIPE_STOPS,
+  isKeysFamily,
   isKeysPreset,
+  isOrganFamily,
+  isOrganText,
   isPianoFamily,
   keysParamName,
+  keysParamsFor,
+  keysSimpleFor,
+  ORGAN_ROWS,
+  ORGAN_FAMILIES,
   normalizeKeys,
   pianoWrite,
   type TrackKeys,
 } from "../../core/keys.ts";
 import {
+  automationPoints,
   createScore,
+  SCORE_LIMITS,
+  setTrackAutomation,
   ScoreValidationError,
   updateTrack,
   type TrackPatch,
@@ -38,22 +65,151 @@ import { parseParamValue } from "./fx.ts";
 
 export type KeysCommand =
   | { type: "keys-list" }
-  | { type: "keys-presets" }
+  /** `family`: `epiano preset` lists only that family's presets. */
+  | { type: "keys-presets"; family?: string }
   | { type: "keys-reset" }
-  | { type: "keys-preset"; preset: string }
+  | {
+      type: "keys-preset";
+      preset: string;
+      /** f061-organ: overrides on top of the preset (`tonewheel 888800008`). */
+      values?: Readonly<Record<string, string>>;
+    }
+  | {
+      /** f061-organ: `rotary fast at 16` writes a keys-rotary point. */
+      type: "keys-rotary-at";
+      speed: "stop" | "slow" | "fast";
+      beat: number;
+    }
   | {
       type: "keys-set";
       /** `null` unsets a parameter. */
       values: Readonly<Record<string, number | string | null>>;
+      /** `epiano vibe 0.6`: the electric family the track becomes first. */
+      family?: string;
     };
 
+/** Electric family words that also take `preset` and parameters. */
+const FAMILY_HEADS: Readonly<Record<string, string>> = Object.freeze({
+  epiano: "epiano",
+  rhodes: "epiano",
+  wurli: "wurli",
+  wurlitzer: "wurli",
+  clav: "clav",
+  clavinet: "clav",
+});
+
 /** The words that start a keys command (registered with /help). */
 export const KEYS_COMMAND_WORDS = Object.freeze([
   "keys",
   "piano",
   ...Object.keys(KEYS_PRESETS).filter((name) => name !== "lofi"),
+  "rhodes",
+  "wurlitzer",
+  "clavinet",
+  // f061-organ
+  ...Object.keys(ORGAN_ALIASES),
+  "rotary",
 ]);
 
+/** A pipe stop or registration word. */
+function isStopWord(word: string): boolean {
+  return (
+    (PIPE_STOPS as readonly string[]).includes(word) ||
+    Object.prototype.hasOwnProperty.call(PIPE_REGISTRATIONS, word)
+  );
+}
+
+/** `principal8,octave4` / `principal8+octave4` / words: the stop words. */
+function stopWords(words: readonly string[]): string[] | undefined {
+  const out = words.flatMap((word) => word.split(/[,+]/).filter(Boolean));
+  return out.length > 0 && out.every(isStopWord) ? out : undefined;
+}
+
+/**
+ * f061-organ: `tonewheel 888800008`, `combo 08880`, `pipe plenum`,
+ * `hammond gospel`: an organ preset word with its one text row.
+ */
+function parseOrganWord(words: readonly string[]): KeysCommand | undefined {
+  const head = ORGAN_ALIASES[words[0]!] ?? words[0]!;
+  if (!isKeysPreset(head)) return undefined;
+  const family = KEYS_PRESETS[head]!.instrument;
+  if (!isOrganFamily(family)) return undefined;
+  const rest = words.slice(1);
+  if (rest.length === 0) return { type: "keys-preset", preset: head };
+  if (
+    rest.length === 1 &&
+    isKeysPreset(rest[0]!) &&
+    KEYS_PRESETS[rest[0]!]!.instrument === family
+  )
+    return { type: "keys-preset", preset: rest[0]! };
+  if (family === "pipe") {
+    const stops = stopWords(rest);
+    return stops
+      ? {
+          type: "keys-preset",
+          preset: head,
+          values: { stops: stops.join(" ") },
+        }
+      : undefined;
+  }
+  const name = family === "tonewheel" ? "drawbars" : "registers";
+  const digits = ORGAN_TEXT[name].digits;
+  const values: Record<string, string> = {};
+  let at = 0;
+  if (new RegExp(`^[0-8]{${digits}}$`).test(rest[0]!)) {
+    values[name] = rest[0]!;
+    at = 1;
+  }
+  // `combo flute`: the combo voice by its word.
+  const spec = KEYS_PARAMS.voice;
+  const voices: readonly string[] = spec?.kind === "enum" ? spec.values : [];
+  if (family === "combo" && voices.includes(rest[at]!)) {
+    values.voice = rest[at]!;
+    at += 1;
+  }
+  // Then any rows as `keys` pairs: `tonewheel 888800008 perc 3rd`.
+  const pairs = rest.slice(at);
+  if (pairs.length > 0) {
+    const set = parseKeysCommand(`keys ${pairs.join(" ")}`);
+    if (set?.type !== "keys-set") return undefined;
+    for (const [key, value] of Object.entries(set.values)) {
+      if (value === null) return undefined;
+      values[key] = String(value);
+    }
+  }
+  return Object.keys(values).length > 0
+    ? { type: "keys-preset", preset: head, values }
+    : undefined;
+}
+
+/** The families that read a keys row (for the "wrong family" message). */
+function familiesReading(param: string): string[] {
+  const organs = ORGAN_FAMILIES.filter((family) =>
+    ORGAN_ROWS[family].includes(param),
+  );
+  const others = (KEYS_PARAM_FAMILIES[param] ?? []).filter(
+    (family) => !isOrganFamily(family),
+  );
+  const families = [...new Set([...others, ...organs])];
+  return families.length > 0 ? families : ["the pianos"];
+}
+
+/**
+ * A row the track's family never reads, as a message (`rotary` on a pipe
+ * organ): stored projects still load, but a typed write is refused.
+ */
+export function keysRowMismatch(
+  instrument: string,
+  params: readonly string[],
+): string | undefined {
+  const rows = keysParamsFor(instrument);
+  const wrong = params.filter(
+    (param) => param !== "preset" && !rows.includes(param),
+  );
+  if (wrong.length === 0) return undefined;
+  return `${instrument} has no ${wrong.join(" ")} (${familiesReading(wrong[0]!).join("/")} row); its parameters: ${rows.join(" ")}`;
+}
+
 export function parseKeysCommand(prompt: string): KeysCommand | undefined {
   if (prompt.length > 1_024) return undefined;
   let words = prompt.trim().toLowerCase().split(/\s+/);
@@ -66,6 +222,24 @@ export function parseKeysCommand(prompt: string): KeysCommand | undefined {
   )
     words = [words[1]!];
   const head = words[0] ?? "";
+  // f061-organ: `rotary slow|fast|stop` and the organ words with a row.
+  if (head === "rotary") {
+    const speed = words[1] as "stop" | "slow" | "fast";
+    if (!["slow", "fast", "stop"].includes(speed)) return undefined;
+    if (words.length === 2)
+      return { type: "keys-set", values: { rotary: speed } };
+    const beat = Number(words[3]);
+    return words.length === 4 &&
+      words[2] === "at" &&
+      /^\d+(\.\d+)?$/.test(words[3]!) &&
+      Number.isFinite(beat)
+      ? { type: "keys-rotary-at", speed, beat }
+      : undefined;
+  }
+  if (head !== "keys" && head !== "piano") {
+    const organ = parseOrganWord(words);
+    if (organ) return organ;
+  }
   // `piano`, `piano <preset>`, and a bare preset word (`grand`, `felt`).
   if (head === "piano" || head === "uprightpiano" || head === "feltpiano") {
     if (words.length === 1)
@@ -74,6 +248,20 @@ export function parseKeysCommand(prompt: string): KeysCommand | undefined {
       ? { type: "keys-preset", preset: words[1]! }
       : undefined;
   }
+  const family = FAMILY_HEADS[head];
+  if (family) {
+    if (words.length === 1)
+      return { type: "keys-preset", preset: pianoWrite(head)!.preset! };
+    const parsed = parseKeysCommand(["keys", ...words.slice(1)].join(" "));
+    if (!parsed || parsed.type === "keys-list") return undefined;
+    if (parsed.type === "keys-preset")
+      return KEYS_PRESETS[parsed.preset]!.instrument === family
+        ? parsed
+        : undefined;
+    if (parsed.type === "keys-set") return { ...parsed, family };
+    if (parsed.type === "keys-presets") return { ...parsed, family };
+    return parsed;
+  }
   if (head !== "keys") {
     if (words.length === 1 && isKeysPreset(head) && head !== "lofi")
       return { type: "keys-preset", preset: head };
@@ -95,16 +283,30 @@ export function parseKeysCommand(prompt: string): KeysCommand | undefined {
         : undefined;
   if (rest.length === 1 && isKeysPreset(rest[0]!))
     return { type: "keys-preset", preset: rest[0]! };
-  if (rest.length % 2 !== 0) return undefined;
   const values: Record<string, number | string | null> = {};
   for (let index = 0; index < rest.length; index += 2) {
     const name = keysParamName(rest[index]!);
     if (!name) return undefined;
-    const word = rest[index + 1]!;
+    const word = rest[index + 1];
+    if (word === undefined) return undefined;
     if (word === "off" || word === "unset") {
       values[name] = null;
       continue;
     }
+    // f061-organ text rows: digits, or stop words up to the next row name.
+    if (isOrganText(name)) {
+      if (name !== "stops") {
+        values[name] = word;
+        continue;
+      }
+      let end = index + 1;
+      while (end < rest.length && !keysParamName(rest[end]!)) end += 1;
+      const stops = stopWords(rest.slice(index + 1, end));
+      if (!stops) return undefined;
+      values[name] = stops.join(" ");
+      index = end - 2;
+      continue;
+    }
     const value = parseParamValue(KEYS_PARAMS[name]!, word);
     if (value === undefined || typeof value === "boolean") return undefined;
     values[name] = value as number | string;
@@ -239,16 +441,45 @@ export function applyKeysCommand(
   if (command.type === "keys-presets")
     return {
       ok: true,
-      message: `keys presets · ${Object.keys(KEYS_PRESETS).join(" ")}`,
+      message: `${command.family ?? "keys"} presets · ${Object.keys(
+        KEYS_PRESETS,
+      )
+        .filter(
+          (name) =>
+            !command.family ||
+            KEYS_PRESETS[name]!.instrument === command.family,
+        )
+        .join(" ")}`,
     };
-  const piano = isPianoFamily(track.instrument);
+  // f061-organ: organs take `keys` commands too.
+  const piano = isKeysFamily(track.instrument);
+  const elsewhere =
+    track.instrument === "organ"
+      ? `keys · ${trackId} is the legacy organ; type tonewheel (or combo, pipe) for drawbars and rotary, or piano for the modelled piano`
+      : `keys · ${trackId} is ${track.instrument}; type piano first (${PIANO_FAMILIES.join(" ")}), ${ELECTRIC_FAMILIES.join(" ")} or ${ORGAN_FAMILIES.join(" ")} for modelled keys`;
   if (command.type === "keys-list")
     return {
       ok: true,
       message: piano
-        ? `keys · ${track.instrument} · ${describeKeys(track.keys)} · basics ${KEYS_SIMPLE.join(" ")}`
-        : `keys · ${trackId} is ${track.instrument}; type piano (or grand upright felt honkytonk prepared) for the modelled piano`,
+        ? `keys · ${track.instrument} · ${describeKeys(track.keys)} · basics ${keysSimpleFor(track.instrument).join(" ")}`
+        : elsewhere,
     };
+  if (
+    command.type === "keys-set" &&
+    command.family &&
+    track.instrument !== command.family
+  ) {
+    // `epiano vibe 0.6` on another sound: become the family, then set.
+    const base = applyKeysCommand(score, trackId, {
+      type: "keys-preset",
+      preset: command.family,
+    });
+    if (!base.ok || !base.next) return base;
+    return applyKeysCommand(base.next, trackId, {
+      type: "keys-set",
+      values: command.values,
+    });
+  }
   if (track.sampler && command.type !== "keys-preset")
     return {
       ok: false,
@@ -261,6 +492,20 @@ export function applyKeysCommand(
       ...(track.sampler ? { sampler: null } : {}),
       ...(track.synth ? { synth: null } : {}),
     };
+    if (command.values) {
+      try {
+        patch = {
+          ...patch,
+          keys: normalizeKeys({ ...patch.keys, ...command.values }) ?? {},
+        };
+      } catch (error) {
+        if (error instanceof FxValidationError)
+          return { ok: false, message: `keys · ${error.message}` };
+        throw error;
+      }
+    }
+  } else if (!piano && command.type === "keys-rotary-at") {
+    return { ok: false, message: elsewhere };
   } else if (!piano) {
     // `keys` is also the legacy synth sound (`instrument keys`): name both
     // ways out.
@@ -272,12 +517,41 @@ export function applyKeysCommand(
       ok: false,
       message: keysSynth
         ? `keys · keys shapes the modelled piano; ${trackId} is the keys synth: use synth ${first ?? "decay"} …, or type piano`
-        : `keys · ${trackId} is ${track.instrument}; type piano first (keys shapes the modelled piano)`,
+        : elsewhere,
+    };
+  } else if (command.type === "keys-rotary-at") {
+    const wrong = keysRowMismatch(track.instrument, ["rotary"]);
+    if (wrong) return { ok: false, message: `keys · ${wrong}` };
+    const tick = Math.round(command.beat * score.ticksPerBeat);
+    const value = { stop: 0, slow: 1, fast: 2 }[command.speed];
+    const merged = new Map(
+      automationPoints(track, "keys-rotary").map((point) => [
+        point.tick,
+        point,
+      ]),
+    );
+    merged.set(tick, { tick, value });
+    const points = [...merged.values()].sort((a, b) => a.tick - b.tick);
+    if (points.length > SCORE_LIMITS.maxAutomationPoints)
+      return { ok: false, message: "keys-rotary automation is full" };
+    return {
+      ok: true,
+      message: `keys · rotary ${command.speed} at beat ${command.beat} · keys-rotary ${points.length} point${points.length === 1 ? "" : "s"}`,
+      next: setTrackAutomation(score, trackId, "keys-rotary", points),
+      kind: "score.automation",
+      payload: { trackId, parameter: "keys-rotary", points },
     };
   } else if (command.type === "keys-reset") {
     // The family's own sound: the preset and the effects it brought go.
     patch = { ...keysPresetClear(track), keys: {} };
   } else {
+    const wrong = keysRowMismatch(
+      track.instrument,
+      Object.entries(command.values)
+        .filter(([, value]) => value !== null)
+        .map(([key]) => key),
+    );
+    if (wrong) return { ok: false, message: `keys · ${wrong}` };
     const keys: Record<string, unknown> = { ...(track.keys ?? {}) };
     for (const [key, value] of Object.entries(command.values)) {
       if (value === null) delete keys[key];
@@ -315,7 +589,9 @@ export function applyKeysCommand(
     ok: true,
     message:
       command.type === "keys-preset"
-        ? `keys · ${stored.instrument} · preset ${command.preset} · ${KEYS_PRESETS[command.preset]!.doc}${extras.length > 0 ? ` · with ${extras.join(" ")}` : ""}`
+        ? command.values
+          ? `keys · ${stored.instrument} · ${describeKeys(stored.keys)}${extras.length > 0 ? ` · with ${extras.join(" ")}` : ""}`
+          : `keys · ${stored.instrument} · preset ${command.preset} · ${KEYS_PRESETS[command.preset]!.doc}${extras.length > 0 ? ` · with ${extras.join(" ")}` : ""}`
         : `keys · ${stored.instrument} · ${describeKeys(stored.keys)}`,
     next,
     kind: "score.keys",

package/src/commands/modal.ts

@@ -24,6 +24,7 @@
 import { FxValidationError } from "../../core/params.ts";
 import {
   DEFAULT_MODAL_PRESET,
+  GAMELAN_PRESETS,
   MODAL_INSTRUMENT,
   MODAL_PARAMS,
   MODAL_PRESETS,
@@ -31,6 +32,7 @@ import {
   MODAL_SIMPLE,
   modalParamName,
   modalPresetFor,
+  modalSettings,
   normalizeModal,
   type TrackModal,
 } from "../../core/resonators.ts";
@@ -48,6 +50,7 @@ export type ModalCommand =
   | { type: "modal-off" }
   | { type: "modal-preset"; preset: string }
   | { type: "modal-usage"; message: string }
+  | { type: "modal-hint"; message: string }
   | {
       type: "modal-set";
       /** `null` returns a parameter to the preset's value. */
@@ -58,7 +61,7 @@ export type ModalCommand =
 export const MODAL_OFF_INSTRUMENT = "marimba";
 
 export const MODAL_USAGE =
-  "modal <preset> | modal <body> | modal <param> <value> | modal mallet <name> | modal reset | modal off | modal presets";
+  "modal <preset> | modal <body> | modal <param> <value> | modal mallet <name> | modal pair <track> | modal gamelan | modal reset | modal off | modal presets";
 
 function rangeOf(name: string): string {
   const spec = MODAL_PARAMS[name]!;
@@ -79,6 +82,12 @@ export function parseModalCommand(prompt: string): ModalCommand | undefined {
   if (rest.length === 1 && rest[0] === "off") return { type: "modal-off" };
   if (rest.length === 1 && (rest[0] === "list" || rest[0] === "presets"))
     return { type: "modal-list" };
+  // `gamelan` is a browse group, not a preset: list the bronzes.
+  if (rest.length === 1 && rest[0] === "gamelan")
+    return {
+      type: "modal-hint",
+      message: `gamelan · ${GAMELAN_PRESETS.join(" ")} · modal gangsa to start · pair two tracks with modal pair <track> · tuning slendro or pelog · ctrl-k Sound › browse sounds › Mallets and bells › Gamelan`,
+    };
   if (rest[0] === "preset") {
     const preset = rest.length === 2 ? modalPresetFor(rest[1]!) : undefined;
     return preset
@@ -91,13 +100,26 @@ export function parseModalCommand(prompt: string): ModalCommand | undefined {
   if (rest.length === 1) {
     const preset = modalPresetFor(rest[0]!);
     if (preset) return { type: "modal-preset", preset };
-    // A body word (saron, kempul, bonang, gender ...) sets the body: the
-    // gamelan presets come later, the bodies already ship.
+    // A body word with no preset of its own (frame, bell, crotale ...)
+    // sets the body.
     const body = MODAL_PARAMS.body;
     if (body?.kind === "enum" && body.values.includes(rest[0]!))
       return { type: "modal-set", values: { body: rest[0]! } };
     return { type: "modal-usage", message: MODAL_USAGE };
   }
+  // f061-gamelan-winds: `modal pair <track>` makes this track the
+  // pengisep of an ombak pair (ids keep their case).
+  if (rest[0] === "pair" && rest.length === 2) {
+    const id = prompt.trim().split(/\s+/)[2]!;
+    if (id === "off" || id === "unset" || id === "none")
+      return { type: "modal-set", values: { pair: null } };
+    if (!/^[A-Za-z0-9_-]{1,64}$/.test(id))
+      return {
+        type: "modal-usage",
+        message: "modal pair <track id> | modal pair off",
+      };
+    return { type: "modal-set", values: { pair: id } };
+  }
   if (rest.length % 2 !== 0)
     return { type: "modal-usage", message: MODAL_USAGE };
   const values: Record<string, number | string | null> = {};
@@ -159,6 +181,16 @@ export function nextModal(
   >,
 ): TrackModal {
   const base: Record<string, unknown> = { ...current };
+  // `modal ombak 6` or `modal pair t2` on a track that is not modal yet
+  // means a gamelan pair: start from gangsa, not the default marimba.
+  if (
+    current === undefined &&
+    command.type === "modal-set" &&
+    command.values.preset === undefined &&
+    (typeof command.values.ombak === "number" ||
+      typeof command.values.pair === "string")
+  )
+    base.preset = "gangsa";
   if (command.type === "modal-reset")
     return normalizeModal(current?.preset ? { preset: current.preset } : {})!;
   if (command.type === "modal-preset") base.preset = command.preset;
@@ -183,6 +215,8 @@ export function applyModalCommand(
 ): ModalResult {
   if (command.type === "modal-usage")
     return { ok: false, message: `modal · ${command.message}` };
+  if (command.type === "modal-hint")
+    return { ok: true, message: `modal · ${command.message}` };
   if (command.type === "modal-list")
     return {
       ok: true,
@@ -223,8 +257,37 @@ export function applyModalCommand(
   }
   let modal: TrackModal;
   let next: TrackScore;
+  let partnerNote = "";
   try {
     modal = nextModal(current, command);
+    if (
+      command.type === "modal-set" &&
+      typeof command.values.pair === "string"
+    ) {
+      const partnerId = command.values.pair;
+      const partner = score.tracks.find((entry) => entry.id === partnerId);
+      if (!partner || partnerId === trackId)
+        return {
+          ok: false,
+          message: `modal · pair needs another track id (${score.tracks
+            .filter((entry) => entry.id !== trackId)
+            .map((entry) => entry.id)
+            .join(" ")})`,
+        };
+      if (partner.instrument !== MODAL_INSTRUMENT || !partner.modal)
+        return {
+          ok: false,
+          message: `modal · ${partnerId} is not a modal track · modal gangsa on it first`,
+        };
+      // The partner (pengumbang) plays straight (ombak 0) and this track
+      // (pengisep) sounds ombak Hz above it, so the pair beats at ombak Hz.
+      if (modalSettings(partner.modal).ombak !== 0) {
+        score = updateTrack(score, partnerId, {
+          modal: normalizeModal({ ...partner.modal, ombak: 0 })!,
+        });
+      }
+      partnerNote = ` · ${partnerId} is the pengumbang (ombak 0)`;
+    }
     next = updateTrack(score, trackId, {
       instrument: MODAL_INSTRUMENT,
       modal,
@@ -239,7 +302,7 @@ export function applyModalCommand(
   }
   return {
     ok: true,
-    message: `modal · ${describeModal(modal)}`,
+    message: `modal · ${describeModal(modal)}${partnerNote}`,
     next,
     kind: "score.modal",
     payload: { trackId, instrument: MODAL_INSTRUMENT, modal },