@hraness/dawg 0.5.0 → 0.6.1

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" };
@@ -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,19 +902,30 @@ 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 !== "up");
+      const downs = (pedal ?? []).filter((event) => event.state === "down");
+      const halves = (pedal ?? []).filter((event) => event.state === "half");
+      const held = [
+        ...(downs.length > 0 || halves.length === 0
+          ? [`${downs.length} down`]
+          : []),
+        ...(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"} (${downs.length} down) · ${trackId}`,
+        { [field]: pedal ?? null },
+        `${label} · ${pedal?.length ?? 0} event${pedal?.length === 1 ? "" : "s"} (${held}) · ${trackId}${silent ? ` · no effect: ${silent}` : ""}`,
       );
     }
     case "velcurve": {
@@ -926,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/fit.ts

@@ -0,0 +1,135 @@
+/**
+ * `/fitmode <mode>`, `/bpm <n>` and `/len <beats>` (0.6): fit a sampler
+ * voice to the song's time. They act on the focused sampler track's voice
+ * (named, or its only voice) through `setSampleControls`, so validation and
+ * printing stay the sampler's. `/fitmode` with no mode suggests one from
+ * the sample's content (`suggestFitMode`); song tempo stays `tempo <n>`.
+ */
+import {
+  SAMPLE_FIT_MODES,
+  isSamplerInstrument,
+  samplerVoiceSlots,
+  type SampleFitMode,
+  type TrackScore,
+} from "../../core/score.ts";
+import { setSampleControls, type SetSampleResult } from "./sample.ts";
+
+export type FitCommand = Readonly<{
+  control: "fitmode" | "bpm" | "len";
+  /** Undefined: `/fitmode` alone (suggest) or `off`-style unset is null. */
+  value: SampleFitMode | number | null | undefined;
+  voice?: string;
+}>;
+
+const VOICE = "([a-z][a-z0-9_]{0,31})";
+
+/**
+ * Parse `/fitmode [mode|auto|off [voice]]`, `/bpm <n|off> [voice]`,
+ * `/len <beats|off> [voice]`. `fitmode` and `len` also work without the
+ * slash; a bare `bpm 120` stays the song's tempo word, so `/bpm` needs it.
+ */
+export function parseFitCommand(command: string): FitCommand | undefined {
+  const text = command.trim();
+  const mode = text.match(
+    new RegExp(
+      `^/?fitmode(?:\\s+(repitch|beats|tones|auto|off|none)(?:\\s+${VOICE})?)?$`,
+      "i",
+    ),
+  );
+  if (mode) {
+    const raw = mode[1]?.toLowerCase();
+    return {
+      control: "fitmode",
+      value:
+        raw === undefined || raw === "auto"
+          ? undefined
+          : raw === "off" || raw === "none"
+            ? null
+            : (raw as SampleFitMode),
+      ...(mode[2] ? { voice: mode[2].toLowerCase() } : {}),
+    };
+  }
+  const number = text.match(
+    new RegExp(
+      `^(/bpm|/?len)\\s+(\\d+(?:\\.\\d+)?|off|none)(?:\\s+${VOICE})?$`,
+      "i",
+    ),
+  );
+  if (!number) return undefined;
+  const raw = number[2]!.toLowerCase();
+  return {
+    control: number[1]!.toLowerCase().replace("/", "") as "bpm" | "len",
+    value: raw === "off" || raw === "none" ? null : Number(raw),
+    ...(number[3] ? { voice: number[3].toLowerCase() } : {}),
+  };
+}
+
+/**
+ * The voice a fit command acts on: the named one, else the track's only
+ * voice (lowest slot first when it has several and none is named).
+ */
+export function fitVoice(
+  score: TrackScore,
+  trackId: string,
+  voice: string | undefined,
+): { voice: string } | { error: string } {
+  const track = score.tracks.find((item) => item.id === trackId);
+  const sampler = track?.sampler;
+  if (!track || !sampler || !isSamplerInstrument(track.instrument))
+    return {
+      error: `fit · ${trackId} is not a sampler track · /sample <path> first · song tempo is tempo <bpm>`,
+    };
+  if (voice) return { voice };
+  const names = Object.keys(sampler.voices);
+  if (names.length === 1) return { voice: names[0]! };
+  const slots = samplerVoiceSlots(sampler);
+  const sorted = names.sort(
+    (a, b) => (slots.get(a) ?? 0) - (slots.get(b) ?? 0) || (a < b ? -1 : 1),
+  );
+  return {
+    error: `fit · ${trackId} has ${names.length} voices · name one: ${sorted.join(" ")}`,
+  };
+}
+
+/** Apply a parsed fit command with a known value (a suggested mode resolved). */
+export function applyFitCommand(
+  score: TrackScore,
+  trackId: string,
+  command: FitCommand,
+  mode?: SampleFitMode,
+): SetSampleResult {
+  const target = fitVoice(score, trackId, command.voice);
+  if ("error" in target) return { ok: false, message: target.error };
+  const value = command.value === undefined ? (mode ?? null) : command.value;
+  if (command.control === "fitmode" && value !== null) {
+    const ref = score.tracks.find((t) => t.id === trackId)?.sampler?.voices[
+      target.voice
+    ];
+    if (
+      ref &&
+      value !== "repitch" &&
+      ref.bpm === undefined &&
+      ref.len === undefined &&
+      ref.fit !== true
+    )
+      return {
+        ok: false,
+        message: `fit · fitmode ${String(value)} needs the sample's tempo first · /bpm <n> or /len <beats>`,
+      };
+  }
+  const values: Record<string, number | string | null> = {
+    [command.control]: value,
+  };
+  // Unsetting bpm or len leaves a fitmode with nothing to fit: unset both.
+  if (value === null && command.control !== "fitmode") {
+    const ref = score.tracks.find((t) => t.id === trackId)?.sampler?.voices[
+      target.voice
+    ];
+    const other = command.control === "bpm" ? ref?.len : ref?.bpm;
+    if (ref?.fitmode && other === undefined && ref.fit !== true)
+      values.fitmode = null;
+  }
+  return setSampleControls(score, trackId, target.voice, values);
+}
+
+export const FIT_MODES = SAMPLE_FIT_MODES;

package/src/commands/fx.ts

@@ -4,11 +4,12 @@
  *   fx                                   list the focused track's effects
  *   fx <effect> on|off|reset             enable with defaults, remove, reset
  *   fx <effect> preset <name>            load a named preset (FX_PRESETS)
+ *   fx <effect>                          turn it on (same as `on`)
  *   fx <effect> <param> <value>          set one parameter (enables it)
  *   fx <effect> <number>                 set its first parameter (`fx orbit 2`)
  *   fx <effect> <param> <value> <param> <value>…   several at once
  *   fx reverb ir <impulse>|off           convolution reverb (Strudel `ir`):
- *                                        room|hall|plate, a pack sound or a
+ *                                        room|hall|plate|reverse|gate|spring, a pack sound or a
  *                                        project file; `fx ir hall` too
  *
  * Effects are every `FX_CHAIN` stage except pan (see core/fx.ts), plus
@@ -18,6 +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 {
   EFFECT_NAMES,
   FX_PRESETS,
@@ -146,6 +148,8 @@ export function parseFxCommand(prompt: string): FxCommand | undefined {
   if (effect === "reverb" && irWord(words[2]) && words.length === 4)
     return irCommand(words[3]!);
   const rest = words.slice(2).map((word) => word.toLowerCase());
+  // `fx wobble`, `fx double`: a bare effect name turns it on.
+  if (rest.length === 0) return { type: "fx-on", effect };
   if (rest.length === 1 && (rest[0] === "on" || rest[0] === "off"))
     return { type: rest[0] === "on" ? "fx-on" : "fx-off", effect };
   if (rest.length === 1 && rest[0] === "reset")
@@ -190,6 +194,31 @@ export function parseFxCommand(prompt: string): FxCommand | undefined {
   return { type: "fx-set", effect, values };
 }
 
+/**
+ * A short `fx <word> …` whose word is no effect (`fx wobble on`, `fx dela
+ * mix 0.3`): the local answer, so a typo never goes to the agent. Longer
+ * free text after `fx` still does.
+ */
+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 (parseEffectName(name) || ["ir", "iresponse", "amp"].includes(name))
+    return undefined;
+  const near = nearestWord(name, [
+    ...EFFECT_NAMES,
+    ...Object.keys(EFFECT_ALIASES),
+    "reverb",
+  ]);
+  const rest = words.slice(2).map((word) => word.toLowerCase());
+  const commandShaped =
+    rest.length <= 1 ||
+    ["on", "off", "reset", "preset"].includes(rest[0]!) ||
+    rest.every((word, index) => index % 2 === 0 || /^-?[\d.]+/.test(word));
+  if (!near && !commandShaped) return undefined;
+  return `unknown effect ${name.slice(0, 24)}${near ? ` · did you mean ${near}?` : ""} · effects ${EFFECT_NAMES.join(", ")}`;
+}
+
 function irCommand(value: string): FxCommand | undefined {
   const lower = value.toLowerCase();
   if (lower === "off" || lower === "none") return { type: "fx-ir", ir: null };
@@ -208,6 +237,11 @@ export function effectDefaults(effect: EffectName): FxValues {
     if (!(spec.optional && spec.default === false)) out[key] = spec.default;
   // A zero `time` means "follow beats"; the canonical form omits it.
   if (effect === "delay") delete out.time;
+  // A head's sag follows its type and its noise gate is off until set.
+  if (effect === "head") {
+    delete out.sag;
+    delete out.gate;
+  }
   return out;
 }