@hraness/dawg 0.6.0 → 0.7.0

package/src/commands/drums.ts

@@ -54,12 +54,13 @@ export function parsePatternCommand(
   const match = command
     .trim()
     .match(
-      /^\/patterns?(?:\s+([a-z0-9][\w-]{0,40}))?(?:\s+(keep-tempo|keep|tempo))?\s*$/i,
+      /^\/?(?:patterns?|grooves?)(?:\s+([a-z0-9][\w-]{0,40}))?(?:\s+(keep-tempo|keep|tempo))?\s*$/i,
     );
   if (!match) return undefined;
   const name = match[1]?.toLowerCase();
   if (!name) return { kind: "browse" };
-  if (name === "list" || name === "ls") return { kind: "list" };
+  if (name === "list" || name === "ls" || name === "presets")
+    return { kind: "list" };
   const flag = match[2]?.toLowerCase();
   return {
     kind: "apply",

package/src/commands/edit.ts

@@ -13,6 +13,7 @@
  * score and the session event, leaving persistence to the caller.
  */
 import {
+  AUTOMATION_PARAMETERS,
   automationPoints,
   automationRange,
   SCORE_LIMITS,
@@ -40,7 +41,13 @@ export function parseLane(name: string): AutomationParameter | undefined {
   const lower = name.toLowerCase();
   if (lower === "volume" || lower === "vol") return "volume";
   if (lower === "pan") return "pan";
-  return parseEffectLane(lower);
+  // Lanes are typed in any case: `synth-pitchjump` is `synth-pitchJump`.
+  return (
+    parseEffectLane(lower) ??
+    parseEffectLane(
+      AUTOMATION_PARAMETERS.find((lane) => lane.toLowerCase() === lower) ?? "",
+    )
+  );
 }
 
 const NUMBER = /^-?\d+(?:\.\d+)?$/;
@@ -69,7 +76,7 @@ export function parseEditCommand(prompt: string): EditCommand | undefined {
     const parsed = parseKey(value);
     return parsed ? { type: "key", key: keyName(parsed) } : undefined;
   }
-  const points = text.match(/^automate ([a-z-]+) points((?: \S+)+)$/i);
+  const points = text.match(/^automate ([a-z0-9-]+) points((?: \S+)+)$/i);
   if (points) {
     const parameter = parseLane(points[1]!);
     if (!parameter) return undefined;
@@ -89,7 +96,7 @@ export function parseEditCommand(prompt: string): EditCommand | undefined {
       return undefined;
     return { type: "automation-points", parameter, points: parsed };
   }
-  const remove = text.match(/^automate ([a-z-]+) remove (\d+(?:\.\d+)?)$/i);
+  const remove = text.match(/^automate ([a-z0-9-]+) remove (\d+(?:\.\d+)?)$/i);
   if (remove) {
     const parameter = parseLane(remove[1]!);
     return parameter
@@ -174,7 +181,7 @@ export function applyEditCommand(
     if (points.length === current.length)
       return {
         ok: false,
-        message: `no ${command.parameter} point at beat ${command.beat}`,
+        message: `no ${command.parameter} point at beat ${command.beat} · the ${command.parameter} lane shows them · help automate`,
       };
   }
   return {

package/src/commands/expression.ts

@@ -8,6 +8,7 @@
  *   glide <ms>|off <target>                  portamento into each note
  *   glide <ms>|0|off [legato|mono|poly]      the track's glide (`glide mono`)
  *   pedal <beat>-<beat>…|bars [<bar>-<bar>]|down|half|up <beat>|off
+ *   pedal soft|sost <same forms>             una corda and sostenuto (0.6.1)
  *   velcurve linear|soft|hard|fixed [<v>]
  *   humanize <ms> [<vel%> [<len%>]] [seed <n>]|on|off|reseed|seed <n>
  *   humanize <ms> [<vel%> [<len%>]]|exact|off <target>   per-note amounts
@@ -32,6 +33,7 @@ import {
   normalizeBend,
   normalizeHumanize,
   normalizePedal,
+  SOSTENUTO_STATES,
   normalizeTrackGlide,
   normalizeVelocityCurve,
   normalizeVibrato,
@@ -53,6 +55,7 @@ import {
   type Note,
   type Track,
 } from "../../core/score.ts";
+import { softPedalNote } from "../../core/keys.ts";
 import { barStartTick, loopTicksOf } from "../../core/tempo.ts";
 
 export type NoteTarget =
@@ -73,11 +76,15 @@ export type ExpressionCommand =
   | { type: "vibrato"; vibrato: NoteVibrato | null; target: NoteTarget }
   | { type: "note-glide"; glide: number | null; target: NoteTarget }
   | { type: "track-glide"; time?: number | null; mode?: GlideMode }
-  | { type: "pedal-spans"; spans: readonly { from: number; to: number }[] }
-  | { type: "pedal-bars"; from?: number; to?: number }
-  | { type: "pedal-list" }
-  | { type: "pedal-event"; state: PedalState; beat: number }
-  | { type: "pedal-off" }
+  | {
+      type: "pedal-spans";
+      spans: readonly { from: number; to: number }[];
+      lane?: PedalLane;
+    }
+  | { type: "pedal-bars"; from?: number; to?: number; lane?: PedalLane }
+  | { type: "pedal-list"; lane?: PedalLane }
+  | { type: "pedal-event"; state: PedalState; beat: number; lane?: PedalLane }
+  | { type: "pedal-off"; lane?: PedalLane }
   | { type: "velcurve"; curve: VelocityCurveName; fixed?: number }
   | {
       type: "humanize";
@@ -299,7 +306,31 @@ function nearWord(text: string, word: string): boolean {
   return previous[word.length]! <= 2;
 }
 
+/**
+ * Which pedal a `pedal` command edits (0.6.1): absent is the sustain
+ * pedal, `soft` the una corda (Track.softPedal), `sost` the sostenuto.
+ */
+export type PedalLane = "soft" | "sost";
+
+const PEDAL_LANES: Readonly<Record<string, PedalLane>> = {
+  soft: "soft",
+  unacorda: "soft",
+  sost: "sost",
+  sostenuto: "sost",
+};
+
 function parsePedal(words: string[]): ExpressionCommand | undefined {
+  const lane = words[0] ? PEDAL_LANES[words[0]] : undefined;
+  if (lane) {
+    const command = parsePedalLane(words.slice(1));
+    return command && command.type.startsWith("pedal-")
+      ? ({ ...command, lane } as ExpressionCommand)
+      : undefined;
+  }
+  return parsePedalLane(words);
+}
+
+function parsePedalLane(words: string[]): ExpressionCommand | undefined {
   const [first, ...rest] = words;
   if (!first) return { type: "pedal-list" };
   if (OFF.test(first) && rest.length === 0) return { type: "pedal-off" };
@@ -505,7 +536,7 @@ export function describeTarget(target: NoteTarget): string {
 export function patchNotes(
   score: TrackScore,
   noteIds: ReadonlySet<string>,
-  patch: NoteExpressionPatch,
+  patch: NoteExpressionPatch & Readonly<{ vowel?: string | null }>,
 ): TrackScore {
   if (noteIds.size === 0) return score;
   return new TrackScore({
@@ -564,6 +595,16 @@ export function describePerformance(score: TrackScore, track: Track): string {
   const parts = [
     `glide ${track.glide ? `${ms(track.glide.time)} ${track.glide.mode}` : "off"}`,
     `pedal ${track.pedal ? `${track.pedal.length} event${track.pedal.length === 1 ? "" : "s"}` : "off"}`,
+    ...(track.softPedal
+      ? [
+          `soft ${track.softPedal.length} event${track.softPedal.length === 1 ? "" : "s"}`,
+        ]
+      : []),
+    ...(track.sostenuto
+      ? [
+          `sost ${track.sostenuto.length} event${track.sostenuto.length === 1 ? "" : "s"}`,
+        ]
+      : []),
     `velcurve ${track.velocityCurve ? `${track.velocityCurve.curve}${track.velocityCurve.fixed !== undefined ? ` ${track.velocityCurve.fixed}` : ""}` : "linear"}`,
     `humanize ${describeHumanize(track.humanize)}`,
   ];
@@ -680,10 +721,24 @@ function mergePedal(
   current: readonly PedalEvent[] | undefined,
   added: readonly PedalEvent[],
   maxTick: number,
+  label?: string,
+  states?: readonly PedalState[],
 ): readonly PedalEvent[] | undefined {
   const byTick = new Map((current ?? []).map((event) => [event.tick, event]));
   for (const event of added) byTick.set(event.tick, event);
-  return normalizePedal([...byTick.values()], maxTick);
+  return normalizePedal([...byTick.values()], maxTick, label, states);
+}
+
+/** The Track field, message label and allowed states of a pedal lane. */
+function pedalLaneOf(lane: PedalLane | undefined): {
+  field: "pedal" | "softPedal" | "sostenuto";
+  label: string;
+  states?: readonly PedalState[];
+} {
+  if (lane === "soft") return { field: "softPedal", label: "soft pedal" };
+  if (lane === "sost")
+    return { field: "sostenuto", label: "sostenuto", states: SOSTENUTO_STATES };
+  return { field: "pedal", label: "pedal" };
 }
 
 /** Apply `command` to the focused track `trackId`. */
@@ -771,11 +826,12 @@ export function applyExpressionCommand(
       );
     }
     case "pedal-list": {
-      const events = track.pedal ?? [];
+      const { field, label } = pedalLaneOf(command.lane);
+      const events = track[field] ?? [];
       if (events.length === 0)
         return {
           ok: true,
-          message: `pedal · none on ${trackId} · pedal bars to add`,
+          message: `${label} · none on ${trackId} · ${command.lane ? `pedal ${command.lane} 0-4` : "pedal bars"} to add`,
         };
       const shown = events
         .slice(0, 12)
@@ -784,24 +840,45 @@ export function applyExpressionCommand(
             `${Math.round((event.tick / score.ticksPerBeat) * 1000) / 1000} ${event.state}`,
         );
       if (events.length > 12) shown.push(`+${events.length - 12} more`);
-      return { ok: true, message: `pedal · ${shown.join(" · ")} · ${trackId}` };
+      return {
+        ok: true,
+        message: `${label} · ${shown.join(" · ")} · ${trackId}`,
+      };
+    }
+    case "pedal-off": {
+      const { field, label } = pedalLaneOf(command.lane);
+      return track[field]
+        ? trackResult(
+            score,
+            track,
+            { [field]: null },
+            `${label} · off · ${trackId}`,
+          )
+        : { ok: true, message: `${label} · already off · ${trackId}` };
     }
-    case "pedal-off":
-      return track.pedal
-        ? trackResult(score, track, { pedal: null }, `pedal · off · ${trackId}`)
-        : { ok: true, message: `pedal · already off · ${trackId}` };
     case "pedal-spans":
     case "pedal-bars":
     case "pedal-event": {
+      const { field, label, states } = pedalLaneOf(command.lane);
       let added: PedalEvent[];
       if (command.type === "pedal-bars") {
         const from = command.from ?? 1;
         if (from > score.bars)
           return {
             ok: false,
-            message: `pedal · the loop has ${score.bars} bar${score.bars === 1 ? "" : "s"}`,
+            message: `${label} · the loop has ${score.bars} bar${score.bars === 1 ? "" : "s"}`,
           };
-        added = barPedal(score, from, command.to ?? score.bars);
+        const to = Math.min(command.to ?? score.bars, score.bars);
+        // Soft and sostenuto hold through the bars (no re-pedalling).
+        added = command.lane
+          ? [
+              { tick: barStartTick(score, from - 1), state: "down" },
+              {
+                tick: Math.min(barStartTick(score, to), maxTick),
+                state: "up",
+              },
+            ]
+          : barPedal(score, from, to);
       } else if (command.type === "pedal-event") {
         added = [
           { tick: Math.round(command.beat * tpb), state: command.state },
@@ -815,7 +892,7 @@ export function applyExpressionCommand(
       if (added.some((event) => event.tick > maxTick))
         return {
           ok: false,
-          message: `pedal · beats run 0..${maxTick / tpb} in this loop`,
+          message: `${label} · beats run 0..${maxTick / tpb} in this loop`,
         };
       let pedal: readonly PedalEvent[] | undefined;
       try {
@@ -825,11 +902,11 @@ export function applyExpressionCommand(
           command.type === "pedal-bars" &&
           command.from === undefined &&
           command.to === undefined
-            ? normalizePedal(added, maxTick)
-            : mergePedal(track.pedal, added, maxTick);
+            ? normalizePedal(added, maxTick, field, states)
+            : mergePedal(track[field], added, maxTick, field, states);
       } catch (error) {
         if (error instanceof ExpressionValidationError)
-          return { ok: false, message: `pedal · ${error.message}` };
+          return { ok: false, message: `${label} · ${error.message}` };
         throw error;
       }
       const downs = (pedal ?? []).filter((event) => event.state === "down");
@@ -840,11 +917,15 @@ export function applyExpressionCommand(
           : []),
         ...(halves.length > 0 ? [`${halves.length} half`] : []),
       ].join(", ");
+      // Una corda is stored anyway (an instrument change may follow), but
+      // say when nothing will sound different.
+      const silent =
+        field === "softPedal" && pedal ? softPedalNote(track) : undefined;
       return trackResult(
         score,
         track,
-        { pedal: pedal ?? null },
-        `pedal · ${pedal?.length ?? 0} event${pedal?.length === 1 ? "" : "s"} (${held}) · ${trackId}`,
+        { [field]: pedal ?? null },
+        `${label} · ${pedal?.length ?? 0} event${pedal?.length === 1 ? "" : "s"} (${held}) · ${trackId}${silent ? ` · no effect: ${silent}` : ""}`,
       );
     }
     case "velcurve": {
@@ -933,7 +1014,7 @@ export const EXPRESSION_USAGE = Object.freeze({
   glide:
     "glide <ms>|<s>s|off [legato|mono|poly] (track) · glide <ms>|off <target> (notes) · glide 60 mono · SDK glide: 0.06 (s)",
   pedal:
-    "pedal <beat>-<beat>…|bars [<bar>-<bar>]|down|half|up <beat>|off · pedal 0-3.5 4-7.5 · pedal bars",
+    "pedal [soft|sost] <beat>-<beat>…|bars [<bar>-<bar>]|down|half|up <beat>|off · pedal 0-3.5 4-7.5 · pedal bars · pedal soft 0-8 (una corda) · pedal sost 0-4 (holds keys down at 0)",
   velcurve:
     "velcurve linear|soft|hard|fixed [<v 0..1>] · velcurve soft · velcurve fixed 0.8",
   humanize:

package/src/commands/formant.ts

@@ -0,0 +1,221 @@
+/**
+ * `/formant` and `/vowel` (0.7): short forms of `fx formant` and `fx vowel`
+ * on the focused track. Both build the same `FxCommand` as `fx`, so the
+ * edit, validation and undo step are the fx command's.
+ *
+ *   formant                       show the shift and mix
+ *   formant <-12..12> [mix]       shift the formants (pitch stays): -4 deeper
+ *   formant <preset>              deep giant bright tiny
+ *   formant shift <st> mix <0..1> spelled out
+ *   formant on | off | reset      turn it on | remove it | back to 0 st, mix 1
+ *
+ *   vowel                         show the vowel filter
+ *   vowel <v> [<to> [<morph>]]    a, or a morphing toward o (morph 0.5);
+ *                                 keeps the mix you set
+ *   vowel <preset>                ee (also a, o)
+ *   vowel to <v> | morph <0..1>   change one part of the morph
+ *   vowel to off                  drop the morph target (keeps vowel and mix)
+ *   vowel mix <0..1> | off
+ *
+ * `/vocal formant …` runs the same `/formant` grammar.
+ */
+import { FX_PRESETS, VOWEL_VALUES } from "../../core/fx.ts";
+import type { TrackScore } from "../../core/score.ts";
+import {
+  applyFxCommand,
+  effectValues,
+  FORMANT_VOWEL_HINT,
+  parseFxCommand,
+  type FxCommand,
+  type FxResult,
+} from "./fx.ts";
+
+export const FORMANT_USAGE =
+  "formant <-12..12> [mix] | <deep|giant|bright|tiny> | on | off";
+export const VOWEL_USAGE =
+  "vowel <a|e|i|o|u…> [<to> [<morph 0..1>]] | ee | to off | off";
+
+export type FormantCommand =
+  | Readonly<{ type: "show"; effect: "formant" | "vowel" }>
+  | Readonly<{ type: "fx"; command: FxCommand }>
+  | Readonly<{ type: "error"; message: string }>;
+
+const isVowel = (word: string): boolean =>
+  (VOWEL_VALUES as readonly string[]).includes(word);
+
+/** A number word such as `-3`, `+2.5` or `-4st`. */
+function numberWord(word: string): number | undefined {
+  const match = word.match(/^([+-]?\d+(?:\.\d+)?|[+-]?\.\d+)(?:st)?$/i);
+  return match ? Number(match[1]) : undefined;
+}
+
+/** Parse `/formant …` (the slash is optional only with arguments). */
+export function parseFormantCommand(
+  command: string,
+): FormantCommand | undefined {
+  const match = command.trim().match(/^\/formant(?:\s+(.*))?$/i);
+  if (!match) return undefined;
+  return formantArgs(match[1] ?? "");
+}
+
+/** The words after `/formant` (shared with `/vocal formant`). */
+export function formantArgs(args: string): FormantCommand {
+  const words = args.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  if (words.length === 0) return { type: "show", effect: "formant" };
+  const [first, ...rest] = words as [string, ...string[]];
+  if (rest.length === 0 && (first === "off" || first === "reset"))
+    return {
+      type: "fx",
+      command: {
+        type: first === "off" ? "fx-off" : "fx-reset",
+        effect: "formant",
+      },
+    };
+  // `on` is also a nasal vowel word; as the only word it is the toggle.
+  if (rest.length === 0 && ["on", "true", "yes"].includes(first))
+    return { type: "fx", command: { type: "fx-on", effect: "formant" } };
+  if (rest.length === 0 && FX_PRESETS.formant?.[first])
+    return {
+      type: "fx",
+      command: { type: "fx-preset", effect: "formant", preset: first },
+    };
+  const shift = numberWord(first);
+  // `-4`, `-4 0.5` or `-4 mix 0.5`.
+  const mixWords = rest[0] === "mix" ? rest.slice(1) : rest;
+  if (shift !== undefined && mixWords.length <= 1 && rest.length <= 2) {
+    const mix = mixWords[0] === undefined ? undefined : numberWord(mixWords[0]);
+    if (rest.length > 0 && mix === undefined)
+      return { type: "error", message: `usage: /${FORMANT_USAGE}` };
+    return {
+      type: "fx",
+      command: {
+        type: "fx-set",
+        effect: "formant",
+        values: { shift, ...(mix === undefined ? {} : { mix }) },
+      },
+    };
+  }
+  if (isVowel(first) || words.includes("vowel"))
+    return {
+      type: "error",
+      message: `${FORMANT_VOWEL_HINT} · /vowel ${isVowel(first) ? first : "a"}`,
+    };
+  const generic = parseFxCommand(`fx formant ${words.join(" ")}`);
+  if (generic) return { type: "fx", command: generic };
+  return { type: "error", message: `usage: /${FORMANT_USAGE}` };
+}
+
+/** Parse `/vowel …`. */
+export function parseVowelCommand(command: string): FormantCommand | undefined {
+  const match = command.trim().match(/^\/vowel(?:\s+(.*))?$/i);
+  if (!match) return undefined;
+  const words = (match[1] ?? "")
+    .trim()
+    .toLowerCase()
+    .split(/\s+/)
+    .filter(Boolean);
+  if (words.length === 0) return { type: "show", effect: "vowel" };
+  const [first, second, third] = words;
+  if (words.length === 1 && (first === "off" || first === "reset"))
+    return {
+      type: "fx",
+      command: {
+        type: first === "off" ? "fx-off" : "fx-reset",
+        effect: "vowel",
+      },
+    };
+  if (words.length === 2 && first === "to" && second === "off")
+    return {
+      type: "fx",
+      command: { type: "fx-replace", effect: "vowel", values: {} },
+    };
+  if (
+    words.length === 1 &&
+    !isVowel(first!) &&
+    FX_PRESETS.vowel?.[first!] !== undefined
+  )
+    return {
+      type: "fx",
+      command: { type: "fx-preset", effect: "vowel", preset: first! },
+    };
+  if (isVowel(first!) && words.length <= 3) {
+    // `mix` is filled from the stored vowel when the command is applied.
+    if (second === undefined)
+      return {
+        type: "fx",
+        command: {
+          type: "fx-replace",
+          effect: "vowel",
+          values: { vowel: first! },
+        },
+      };
+    const morph = third === undefined ? 0.5 : numberWord(third);
+    if (!isVowel(second) || morph === undefined)
+      return { type: "error", message: `usage: /${VOWEL_USAGE}` };
+    return {
+      type: "fx",
+      command: {
+        type: "fx-replace",
+        effect: "vowel",
+        values: { vowel: first!, to: second, morph },
+      },
+    };
+  }
+  const generic = parseFxCommand(`fx vowel ${words.join(" ")}`);
+  if (generic && generic.type === "fx-set")
+    return {
+      type: "fx",
+      // `/vowel to o` alone starts halfway so the morph is audible.
+      command:
+        generic.values.to !== undefined && generic.values.morph === undefined
+          ? { ...generic, values: { morph: 0.5, ...generic.values } }
+          : generic,
+    };
+  return { type: "error", message: `usage: /${VOWEL_USAGE}` };
+}
+
+/** Run a parsed `/formant` or `/vowel` on the focused track. */
+export function applyFormantCommand(
+  score: TrackScore,
+  trackId: string,
+  command: FormantCommand,
+): FxResult {
+  if (command.type === "error") return { ok: false, message: command.message };
+  if (command.type === "fx") {
+    // `/vowel <v> [...]` replaces the vowel and its morph but keeps the
+    // stored mix; `/vowel to off` keeps vowel and mix and drops the morph.
+    const track = score.tracks.find((candidate) => candidate.id === trackId);
+    const fx = command.command;
+    if (fx.type === "fx-replace" && fx.effect === "vowel") {
+      const current = effectValues(track, "vowel");
+      const { vowel: vowelWord, ...morphPart } = fx.values;
+      if (vowelWord === undefined && !current)
+        return { ok: true, message: "vowel · off" };
+      return applyFxCommand(score, trackId, {
+        ...fx,
+        values: {
+          vowel: vowelWord ?? current?.vowel ?? "a",
+          mix: current?.mix ?? 1,
+          ...morphPart,
+        },
+      });
+    }
+    return applyFxCommand(score, trackId, fx);
+  }
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track) return { ok: false, message: `no track · ${trackId}` };
+  const values = effectValues(track, command.effect);
+  if (command.effect === "formant")
+    return {
+      ok: true,
+      message: values
+        ? `formant · shift ${values.shift} st · mix ${values.mix}`
+        : `formant · off · /${FORMANT_USAGE}`,
+    };
+  return {
+    ok: true,
+    message: values
+      ? `vowel · ${values.vowel}${values.to !== undefined ? ` → ${values.to} · morph ${values.morph ?? 0}` : ""} · mix ${values.mix}`
+      : `vowel · off · /${VOWEL_USAGE}`,
+  };
+}