@hraness/dawg 0.6.0 → 0.7.0

package/src/commands/rig.ts

@@ -27,6 +27,7 @@ import {
   type FxValues,
   type RigStage,
   type TrackFx,
+  SHOEGAZE_EFFECTS,
 } from "../../core/fx.ts";
 import {
   instrumentForWord,
@@ -44,6 +45,7 @@ import {
   type FxCommand,
   type FxResult,
 } from "./fx.ts";
+import { nearest } from "./nearest.ts";
 
 export type RigCommand =
   | { type: "rig-show" }
@@ -66,33 +68,11 @@ function isStage(word: string): word is RigStage {
 
 /** `unknown rig crunh · did you mean crunch? · rigs clean crunch …` */
 function unknownRigMessage(name: string): string {
-  let best: { name: string; distance: number } | undefined;
-  for (const candidate of RIG_PRESET_NAMES) {
-    const distance = editDistance(name, candidate);
-    if (!best || distance < best.distance) best = { name: candidate, distance };
-  }
-  const near =
-    best && best.distance <= Math.max(2, Math.floor(name.length / 3))
-      ? ` · did you mean ${best.name}?`
-      : "";
+  const match = nearest(name, RIG_PRESET_NAMES);
+  const near = match ? ` · did you mean ${match}?` : "";
   return `unknown rig ${name}${near} · rigs ${RIG_PRESET_NAMES.join(" ")} reset`;
 }
 
-function editDistance(a: string, b: string): number {
-  let row = Array.from({ length: b.length + 1 }, (_, i) => i);
-  for (let i = 1; i <= a.length; i++) {
-    const next = [i];
-    for (let j = 1; j <= b.length; j++)
-      next[j] = Math.min(
-        row[j]! + 1,
-        next[j - 1]! + 1,
-        row[j - 1]! + (a[i - 1] === b[j - 1] ? 0 : 1),
-      );
-    row = next;
-  }
-  return row[b.length]!;
-}
-
 export function parseRigCommand(prompt: string): RigCommand | undefined {
   if (prompt.length > 1_024) return undefined;
   const words = prompt.trim().replace(/^\//, "").toLowerCase().split(/\s+/);
@@ -140,7 +120,7 @@ export function parseRigCommand(prompt: string): RigCommand | undefined {
 }
 
 function describeRig(values: Readonly<Record<string, FxValues | undefined>>) {
-  return RIG_STAGES.filter((stage) => values[stage])
+  const stages = RIG_STAGES.filter((stage) => values[stage])
     .map((stage) => {
       const v = values[stage]!;
       const type = String(v.type);
@@ -148,6 +128,9 @@ function describeRig(values: Readonly<Record<string, FxValues | undefined>>) {
       return `${stage} ${type}${gain}`;
     })
     .join(" → ");
+  // 0.6.1 shoegaze stages follow the cab in the chain.
+  const gaze = SHOEGAZE_EFFECTS.filter((effect) => values[effect]);
+  return gaze.length ? `${stages} + ${gaze.join(" ")}` : stages;
 }
 
 export function applyRigCommand(

package/src/commands/sample.ts

@@ -38,7 +38,8 @@ export type SampleCommand =
     }>;
 
 /** A sample control value: a number, a switch, a unit, or null to unset. */
-export type SampleControlValue = number | string | boolean | null;
+export type SampleControlValue =
+  number | string | boolean | null | readonly number[];
 
 /**
  * Per-voice sample controls `/sample set` and `set_sample` change, by
@@ -62,6 +63,12 @@ export const SAMPLE_CONTROLS = Object.freeze({
   bpm: "the sample's own tempo: it follows the song's tempo map",
   fitmode: "how a fitted sample changes time: repitch, beats or tones",
   len: "the window lasts n beats of the song's tempo map",
+  shift: "pitch in semitones (−24..24), length unchanged",
+  formant: "formants in semitones with shift: 0 keeps the voice, off follows",
+  fadeTime: "release fade in seconds (0..2); alias fadeout",
+  fadeInTime: "attack fade in seconds (0..2); alias fadein",
+  vel: "velocity layer lo-hi (MIDI 0-127): plays only for those velocities",
+  rr: "round-robin group name: voices in a group take turns",
 });
 export type SampleControl = keyof typeof SAMPLE_CONTROLS;
 
@@ -70,6 +77,8 @@ const SAMPLE_ALIASES: Readonly<Record<string, string>> = {
   loope: "loopEnd",
   legato: "clip",
   choke: "cut",
+  fadeout: "fadeTime",
+  fadein: "fadeInTime",
 };
 
 function controlName(raw: string): SampleControl | undefined {
@@ -176,6 +185,18 @@ export function setSampleControls(
       continue;
     }
     if (name === "cut" && typeof value === "number") value = `cut${value}`;
+    if (name === "rr" && typeof value === "number") value = `rr${value}`;
+    if (name === "vel" && value !== null) {
+      const range = parseVelocityRange(value);
+      if (!range)
+        return {
+          ok: false,
+          message: "sample · vel needs lo-hi MIDI velocities, e.g. vel 0-63",
+        };
+      next.vel = range;
+      changed.push(`vel ${range[0]}-${range[1]}`);
+      continue;
+    }
     if (value === null) delete next[field];
     else next[field] = value;
     changed.push(`${raw} ${value === null ? "off" : String(value)}`);
@@ -203,10 +224,24 @@ export function setSampleControls(
   return {
     ok: true,
     next: updated,
-    message: `sample · ${trackId}/${voice} · ${changed.join(" · ")}`,
+    message: `sample · ${trackId}/${voice} · ${changed.join(" · ")}${layerHint(updated, trackId, voice)}`,
   };
 }
 
+/** `0-63`, `0..63`, `64` (one velocity) → [lo, hi]; else undefined. */
+export function parseVelocityRange(
+  value: SampleControlValue | readonly number[],
+): [number, number] | undefined {
+  if (Array.isArray(value))
+    return value.length === 2 && value.every((v) => typeof v === "number")
+      ? [value[0] as number, value[1] as number]
+      : undefined;
+  if (typeof value === "number") return [value, value];
+  if (typeof value !== "string") return undefined;
+  const match = value.trim().match(/^(\d{1,3})\s*(?:-|\.\.|,)\s*(\d{1,3})$/);
+  return match ? [Number(match[1]), Number(match[2])] : undefined;
+}
+
 function unquote(value: string): string {
   const quoted = value.match(/^(["'])(.*)\1$/);
   return quoted ? quoted[2]! : value;
@@ -372,6 +407,18 @@ export function freeVoiceName(
   }
 }
 
+/**
+ * One-shot velocity layers swap only within a round-robin group: a kit
+ * voice with `vel` and no `rr` keeps its own pad, so say how to join them.
+ */
+function layerHint(score: TrackScore, trackId: string, voice: string): string {
+  const sampler = score.tracks.find((item) => item.id === trackId)?.sampler;
+  const ref = sampler?.voices[voice];
+  if (sampler?.mode !== "oneshot" || !ref?.vel || ref.rr !== undefined)
+    return "";
+  return ` · one-shot layers share a pad only within an rr group: sample ${voice} rr <group> on each layer`;
+}
+
 export class SamplePlacementError extends Error {}
 
 /**

package/src/commands/shift.ts

@@ -0,0 +1,119 @@
+/**
+ * `shift <semitones> [formant keep|follow|<n>] [<voice>]` and
+ * `fade [in|out] <seconds> [<voice>]` (0.6.1): pitch a sampler voice
+ * without changing its length, and set its fade in and out. They act on
+ * the focused sampler track's voice (named, or its only one) through
+ * `setSampleControls`, so validation and printing stay the sampler's.
+ */
+import type { TrackScore } from "../../core/score.ts";
+import { fitVoice } from "./fit.ts";
+import {
+  setSampleControls,
+  type SampleControlValue,
+  type SetSampleResult,
+} from "./sample.ts";
+
+export type ShiftCommand =
+  | Readonly<{
+      kind: "shift";
+      /** Semitones; null clears shift and formant. */
+      semitones: number | null;
+      /** 0 keeps the formants, null follows the pitch, undefined leaves it. */
+      formant?: number | null;
+      voice?: string;
+    }>
+  | Readonly<{
+      kind: "fade";
+      /** `in` is fadeInTime, `out` fadeTime, `both` sets each. */
+      edge: "in" | "out" | "both";
+      seconds: number | null;
+      voice?: string;
+    }>;
+
+const VOICE = "([a-z][a-z0-9_]{0,31})";
+const NUMBER = "([+-]?\\d+(?:\\.\\d+)?|off|none)";
+
+/** Parse `shift ...` and `fade ...` (with or without the slash). */
+export function parseShiftCommand(command: string): ShiftCommand | undefined {
+  const text = command.trim();
+  const shift = text.match(
+    new RegExp(
+      `^/?shift\\s+${NUMBER}(?:\\s+formant\\s+(keep|follow|[+-]?\\d+(?:\\.\\d+)?))?(?:\\s+(?:voice\\s+)?${VOICE})?$`,
+      "i",
+    ),
+  );
+  if (shift) {
+    const raw = shift[1]!.toLowerCase();
+    const formant = shift[2]?.toLowerCase();
+    return {
+      kind: "shift",
+      semitones: raw === "off" || raw === "none" ? null : Number(raw),
+      ...(formant === undefined
+        ? {}
+        : {
+            formant:
+              formant === "keep"
+                ? 0
+                : formant === "follow"
+                  ? null
+                  : Number(formant),
+          }),
+      ...(shift[3] ? { voice: shift[3].toLowerCase() } : {}),
+    };
+  }
+  const fade = text.match(
+    new RegExp(
+      `^/?fade(?:\\s+(in|out))?\\s+${NUMBER}(?:\\s+(?:voice\\s+)?${VOICE})?$`,
+      "i",
+    ),
+  );
+  if (!fade) return undefined;
+  const raw = fade[2]!.toLowerCase();
+  return {
+    kind: "fade",
+    edge: (fade[1]?.toLowerCase() as "in" | "out" | undefined) ?? "both",
+    seconds: raw === "off" || raw === "none" ? null : Number(raw),
+    ...(fade[3] ? { voice: fade[3].toLowerCase() } : {}),
+  };
+}
+
+/** Apply a parsed `shift` or `fade` to the focused track's voice. */
+export function applyShiftCommand(
+  score: TrackScore,
+  trackId: string,
+  command: ShiftCommand,
+): SetSampleResult {
+  const target = fitVoice(score, trackId, command.voice);
+  if ("error" in target)
+    return {
+      ok: false,
+      message: target.error.replace(/^fit · /, `${command.kind} · `),
+    };
+  const values: Record<string, SampleControlValue> = {};
+  if (command.kind === "shift") {
+    // `shift off` clears the shift and its formant setting. `shift 0`
+    // clears the shift and a kept formant (0, a no-op without a shift) but
+    // keeps a formant move, so `shift 0 formant 3` is a formant-only move
+    // and stepping the shift through 0 keeps a stored formant.
+    if (command.semitones === null) {
+      values.shift = null;
+      values.formant = null;
+    } else {
+      values.shift = command.semitones === 0 ? null : command.semitones;
+      const formant =
+        command.formant !== undefined
+          ? command.formant
+          : score.tracks.find((track) => track.id === trackId)?.sampler?.voices[
+              target.voice
+            ]?.formant;
+      if (command.semitones === 0 && (formant === 0 || formant === null))
+        values.formant = null;
+      else if (command.formant !== undefined) values.formant = command.formant;
+    }
+  } else {
+    const seconds = command.seconds === 0 ? null : command.seconds;
+    if (command.edge !== "out") values.fadeInTime = seconds;
+    if (command.edge !== "in") values.fadeTime = seconds;
+  }
+  return setSampleControls(score, trackId, target.voice, values);
+}