@hraness/dawg 0.6.1 → 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

@@ -536,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({

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}`,
+  };
+}

package/src/commands/fx.ts

@@ -19,7 +19,7 @@
  * on/off/true/false; enums take one of their values. Each command is one
  * `updateTrack` revision and one undo step.
  */
-import { nearestWord } from "../audio/instrument-check.ts";
+import { nearest } from "./nearest.ts";
 import {
   EFFECT_NAMES,
   FX_PRESETS,
@@ -29,6 +29,7 @@ import {
   isEffectName,
   normalizeParam,
   FxValidationError,
+  VOWEL_VALUES,
   type EffectName,
   type FxName,
   type FxValues,
@@ -57,37 +58,69 @@ export type FxCommand =
       type: "fx-set";
       effect: EffectName;
       values: Readonly<Record<string, number | string | boolean>>;
+    }
+  /** Store exactly these values (`/vowel a` drops a previous morph). */
+  | {
+      type: "fx-replace";
+      effect: EffectName;
+      values: Readonly<Record<string, number | string | boolean>>;
     };
 
-const EFFECT_ALIASES: Readonly<Record<string, EffectName>> = Object.freeze({
-  lpf: "filter",
-  hpf: "filter",
-  bpf: "filter",
-  dj: "djf",
-  "dj-filter": "djf",
-  "auto-filter": "autofilter",
-  autof: "autofilter",
-  formant: "vowel",
-  bitcrush: "crush",
-  bitcrusher: "crush",
-  coarse: "crush",
-  distortion: "distort",
-  dist: "distort",
-  drive: "distort",
-  shape: "distort",
-  trem: "tremolo",
-  comp: "compressor",
-  compress: "compressor",
-  rotary: "leslie",
-  gain: "postgain",
-  echo: "delay",
-  bus: "orbit",
-  o: "orbit",
-  sidechain: "duck",
-  duckorbit: "duck",
-  room: "reverb",
-  verb: "reverb",
-});
+export const EFFECT_ALIASES: Readonly<Record<string, EffectName>> =
+  Object.freeze({
+    lpf: "filter",
+    hpf: "filter",
+    bpf: "filter",
+    dj: "djf",
+    "dj-filter": "djf",
+    "auto-filter": "autofilter",
+    autof: "autofilter",
+    bitcrush: "crush",
+    bitcrusher: "crush",
+    coarse: "crush",
+    distortion: "distort",
+    dist: "distort",
+    drive: "distort",
+    shape: "distort",
+    trem: "tremolo",
+    comp: "compressor",
+    compress: "compressor",
+    rotary: "leslie",
+    gain: "postgain",
+    echo: "delay",
+    bus: "orbit",
+    o: "orbit",
+    sidechain: "duck",
+    duckorbit: "duck",
+    room: "reverb",
+    verb: "reverb",
+  });
+
+/**
+ * 0.7: `formant` was an alias of the vowel filter; it now shifts formants.
+ * A vowel given to it gets this answer instead of a silent change.
+ */
+export const FORMANT_FX_USAGE =
+  "formant · shift -12..12 st, mix 0..1 · presets deep giant bright tiny";
+
+/** `/vowel morph`, `fx vowel morph` and set_fx all refuse a morph with no target. */
+export const VOWEL_MORPH_NEEDS_TO =
+  "set a target first: /vowel a o 0.5 or /vowel to o";
+
+export const FORMANT_VOWEL_HINT =
+  "formant now shifts formants at constant pitch; the vowel filter is `vowel`";
+
+/** Whether `fx formant …` words or set_fx params name a vowel. */
+export function formantGotVowel(
+  words: readonly (string | number | boolean)[],
+): boolean {
+  return words.some(
+    (word) =>
+      typeof word === "string" &&
+      (word.toLowerCase() === "vowel" ||
+        (VOWEL_VALUES as readonly string[]).includes(word.toLowerCase())),
+  );
+}
 
 export function parseEffectName(name: string): EffectName | undefined {
   const lower = name.toLowerCase();
@@ -134,10 +167,25 @@ export function parseParamValue(
   }
 }
 
+/** The effects people reach for first, for the empty `fx` read. */
+const COMMON_FIRST: readonly string[] = [
+  "reverb",
+  "delay",
+  "filter",
+  "distort",
+  "chorus",
+  "compressor",
+];
+
+const FX_LIST_WORDS: readonly string[] = ["list", "ls", "presets"];
+
 export function parseFxCommand(prompt: string): FxCommand | undefined {
   const words = prompt.trim().split(/\s+/);
   if (words[0]?.toLowerCase() !== "fx") return undefined;
   if (words.length === 1) return { type: "fx-list" };
+  // `fx list`, `fx ls`, `fx presets`: the same read as bare `fx`.
+  if (words.length === 2 && FX_LIST_WORDS.includes(words[1]!.toLowerCase()))
+    return { type: "fx-list" };
   if (prompt.length > 1_024) return undefined;
   const irWord = (word: string | undefined) =>
     word !== undefined && ["ir", "iresponse"].includes(word.toLowerCase());
@@ -203,9 +251,16 @@ export function unknownFxMessage(prompt: string): string | undefined {
   const words = prompt.trim().split(/\s+/);
   if (words[0]?.toLowerCase() !== "fx" || words.length < 2) return undefined;
   const name = words[1]!.toLowerCase();
+  if (name === "formant" && formantGotVowel(words.slice(2)))
+    return FORMANT_VOWEL_HINT;
+  // A new numeric-first effect: out-of-range values and preset typos get its
+  // ranges and presets instead of the generic unknown-command path.
+  if (name === "formant" && words.length <= 6 && !parseFxCommand(prompt))
+    return FORMANT_FX_USAGE;
   if (parseEffectName(name) || ["ir", "iresponse", "amp"].includes(name))
     return undefined;
-  const near = nearestWord(name, [
+  if (words.length === 2 && FX_LIST_WORDS.includes(name)) return undefined;
+  const near = nearest(name, [
     ...EFFECT_NAMES,
     ...Object.keys(EFFECT_ALIASES),
     "reverb",
@@ -242,6 +297,11 @@ export function effectDefaults(effect: EffectName): FxValues {
     delete out.sag;
     delete out.gate;
   }
+  // The vowel morph stays absent until set: `fx vowel on` stores 0.6 data.
+  if (effect === "vowel") {
+    delete out.to;
+    delete out.morph;
+  }
   return out;
 }
 
@@ -304,7 +364,7 @@ export function applyFxCommand(
       ok: true,
       message: on.length
         ? `fx · ${on.map((effect) => `${effect} (${describe(effect, effectValues(track, effect)!)})`).join(" → ")}`
-        : `fx · none · chain ${FX_CHAIN.join(" → ")}`,
+        : `fx · none · ${COMMON_FIRST.join(" ")} … · fx list`,
     };
   }
   if (command.type === "fx-ir")
@@ -324,7 +384,16 @@ export function applyFxCommand(
       ...effectDefaults(effect),
       ...FX_PRESETS[effect]![command.preset],
     };
+  else if (command.type === "fx-replace") values = { ...command.values };
   else values = { ...(current ?? effectDefaults(effect)), ...command.values };
+  if (
+    values &&
+    effect === "vowel" &&
+    command.type === "fx-set" &&
+    command.values.morph !== undefined &&
+    values.to === undefined
+  )
+    return { ok: false, message: `vowel · ${VOWEL_MORPH_NEEDS_TO}` };
   if (values && effect === "delay" && values.time === 0) {
     const { time: _time, ...rest } = values;
     values = rest;