@hraness/dawg 0.5.0 → 0.6.0

package/src/commands/rig.ts

@@ -0,0 +1,260 @@
+/**
+ * The guitar rig prompt commands (0.6):
+ *
+ *   rig                          show the focused track's rig
+ *   rig <preset>                 load a whole rig (RIG_PRESETS): clean crunch
+ *                                punk ragged lead metal fuzz octave funk wah
+ *                                bachata spring bassdrive reese jangle alt
+ *   rig reset | rig off          remove the stomp, head and cab
+ *   stomp|head|cab <type>        pick a pedal, amp or cabinet (`head crunch`)
+ *   stomp|head|cab <param> <v>…  set parameters (`head gain 7 gate -55`)
+ *   stomp|head|cab on|off|reset  as `fx <stage> …`
+ *
+ * Stage commands are `fx stomp|head|cab …` without the `fx`. `fx amp` (and
+ * `amp`) answer with a hint: `amp` stays Strudel's linear gain, the guitar
+ * amplifier is `head`. One command is one `updateTrack` revision.
+ */
+import {
+  FX_PRESETS,
+  FxValidationError,
+  RIG_PRESETS,
+  RIG_STAGES,
+  applyRigPreset,
+  effectSpec,
+  isRigReverb,
+  rigPresetOf,
+  rigReverb,
+  type FxValues,
+  type RigStage,
+  type TrackFx,
+} from "../../core/fx.ts";
+import {
+  instrumentForWord,
+  resolveInstrumentWord,
+} from "../../core/instruments.ts";
+import {
+  ScoreValidationError,
+  updateTrack,
+  type TrackPatch,
+  type TrackScore,
+} from "../../core/score.ts";
+import {
+  applyFxCommand,
+  parseFxCommand,
+  type FxCommand,
+  type FxResult,
+} from "./fx.ts";
+
+export type RigCommand =
+  | { type: "rig-show" }
+  | { type: "rig-preset"; preset: string }
+  | { type: "rig-reset" }
+  | { type: "rig-stage"; stage: RigStage; fx: FxCommand }
+  /** A typed word that is close to a rig command: answer with a hint. */
+  | { type: "rig-hint"; message: string };
+
+export const RIG_PRESET_NAMES: readonly string[] = Object.freeze(
+  Object.keys(RIG_PRESETS),
+);
+
+const AMP_HINT =
+  "did you mean head (guitar amp)? · `head crunch`, `rig crunch` · amp stays Strudel linear gain (`fx gain`)";
+
+function isStage(word: string): word is RigStage {
+  return (RIG_STAGES as readonly string[]).includes(word);
+}
+
+/** `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}?`
+      : "";
+  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+/);
+  const head = words[0];
+  if (head === "amp" || (head === "fx" && words[1] === "amp"))
+    return { type: "rig-hint", message: AMP_HINT };
+  if (head === "rig") {
+    if (words.length === 1) return { type: "rig-show" };
+    const name = words.slice(1).join(" ");
+    if (name === "reset" || name === "off" || name === "none")
+      return { type: "rig-reset" };
+    if (Object.prototype.hasOwnProperty.call(RIG_PRESETS, name))
+      return { type: "rig-preset", preset: name };
+    return { type: "rig-hint", message: unknownRigMessage(name) };
+  }
+  if (!head || !isStage(head)) return undefined;
+  const stage = head;
+  const rest = words.slice(1);
+  if (rest.length === 0)
+    return { type: "rig-stage", stage, fx: { type: "fx-on", effect: stage } };
+  // `stomp fuzz`, `head crunch`, `cab 4x12`: the stage's type.
+  const types = effectSpec(stage).params.type;
+  if (
+    rest.length === 1 &&
+    types?.kind === "enum" &&
+    (types.values as readonly string[]).includes(rest[0]!)
+  )
+    return {
+      type: "rig-stage",
+      stage,
+      fx: { type: "fx-set", effect: stage, values: { type: rest[0]! } },
+    };
+  // `stomp muff`: a stage preset.
+  if (
+    rest.length === 1 &&
+    Object.prototype.hasOwnProperty.call(FX_PRESETS[stage] ?? {}, rest[0]!)
+  )
+    return {
+      type: "rig-stage",
+      stage,
+      fx: { type: "fx-preset", effect: stage, preset: rest[0]! },
+    };
+  const fx = parseFxCommand(`fx ${stage} ${rest.join(" ")}`);
+  return fx ? { type: "rig-stage", stage, fx } : undefined;
+}
+
+function describeRig(values: Readonly<Record<string, FxValues | undefined>>) {
+  return RIG_STAGES.filter((stage) => values[stage])
+    .map((stage) => {
+      const v = values[stage]!;
+      const type = String(v.type);
+      const gain = v.gain === undefined ? "" : ` ${String(v.gain)}`;
+      return `${stage} ${type}${gain}`;
+    })
+    .join(" → ");
+}
+
+export function applyRigCommand(
+  score: TrackScore,
+  trackId: string,
+  command: RigCommand,
+): FxResult {
+  if (command.type === "rig-hint")
+    return { ok: false, message: command.message };
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track) return { ok: false, message: `no track · ${trackId}` };
+  if (command.type === "rig-stage")
+    return applyFxCommand(score, trackId, command.fx);
+  if (command.type === "rig-show") {
+    const fx = track.fx ?? {};
+    if (!RIG_STAGES.some((stage) => fx[stage]))
+      return {
+        ok: true,
+        message: `rig · none · rigs ${RIG_PRESET_NAMES.join(" ")}`,
+      };
+    const name = rigPresetOf(track.fx);
+    return {
+      ok: true,
+      message: `rig${name ? ` ${name}` : ""} · ${describeRig(fx)}`,
+    };
+  }
+  const name = command.type === "rig-reset" ? "reset" : command.preset;
+  if (name === "reset" && !RIG_STAGES.some((stage) => track.fx?.[stage]))
+    return { ok: true, message: "rig · already off" };
+  let next: TrackScore;
+  try {
+    next = updateTrack(score, trackId, rigPatch(track, name));
+  } catch (error) {
+    if (
+      error instanceof ScoreValidationError ||
+      error instanceof FxValidationError
+    )
+      return { ok: false, message: `rig · ${error.message}` };
+    throw error;
+  }
+  const stored = next.tracks.find((candidate) => candidate.id === trackId)?.fx;
+  return {
+    ok: true,
+    message:
+      name === "reset"
+        ? "rig · off"
+        : `rig ${name} · ${describeRig(stored ?? {})}`,
+    next,
+    kind: "score.effect",
+    payload: { trackId, rig: name, fx: stored ?? null },
+  };
+}
+
+/**
+ * Track fields an instrument word sets beyond `instrument`: a rig alias
+ * (`jangle`, `punk`, `gtr-metal`…) also loads its rig over `fx`, keeping
+ * the track's other effects. Empty for every other word.
+ */
+export function rigWordPatch(
+  word: string,
+  fx: TrackFx | undefined,
+): Readonly<{ fx?: TrackFx | null; reverb?: TrackPatch["reverb"] }> {
+  const rig = resolveInstrumentWord(word)?.fx;
+  if (!rig || !Object.prototype.hasOwnProperty.call(RIG_PRESETS, rig))
+    return {};
+  return rigPatch({ fx }, rig);
+}
+
+/**
+ * The track patch for rig `name` (or `"reset"`): the stages and companion
+ * effects, plus `rig spring`'s short room. A reverb a previous rig set (and
+ * nobody changed since) is removed when the new rig has none.
+ */
+function rigPatch(
+  track: Readonly<{ fx?: TrackFx; reverb?: unknown }>,
+  name: string,
+): Readonly<{ fx: TrackFx | null; reverb?: TrackPatch["reverb"] }> {
+  const reverb = name === "reset" ? undefined : rigReverb(name);
+  return {
+    fx: applyRigPreset(track.fx, name) ?? null,
+    ...(reverb
+      ? { reverb: reverb as unknown as TrackPatch["reverb"] }
+      : isRigReverb(track.reverb)
+        ? { reverb: null }
+        : {}),
+  };
+}
+
+/**
+ * A new track's fields for instrument word `word`: a guitar alias gets its
+ * guitar voice and rig, any other word `{}` (callers pick the instrument).
+ */
+export function rigTrackFields(word: string): Readonly<{
+  instrument?: string;
+  string?: { preset: string };
+  fx?: TrackFx;
+  reverb?: TrackPatch["reverb"];
+}> {
+  const meaning = resolveInstrumentWord(word);
+  if (!meaning?.fx) return {};
+  const { fx, reverb } = rigWordPatch(word, undefined);
+  return {
+    instrument: meaning.instrument,
+    ...(meaning.field === "string" && meaning.preset
+      ? { string: { preset: meaning.preset } }
+      : {}),
+    ...(fx ? { fx } : {}),
+    ...(reverb ? { reverb } : {}),
+  };
+}

package/src/commands/sample.ts

@@ -59,6 +59,9 @@ export const SAMPLE_CONTROLS = Object.freeze({
   accelerate: "rate ramps by this × over the voice (−8..8)",
   squiz: "pitch-raise ratio per zero-crossing cycle (1..32)",
   cut: "choke group name: a new hit stops the previous one",
+  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",
 });
 export type SampleControl = keyof typeof SAMPLE_CONTROLS;
 

package/src/commands/string.ts

@@ -0,0 +1,175 @@
+/**
+ * The `string` prompt command: the focused track's plucked-string engine
+ * (core/strings.ts, `Track.string`).
+ *
+ *   string                              list this track's preset and overrides
+ *   string presets                      the plucked presets
+ *   string <preset> | preset <name>     play a preset (instrument "string")
+ *   string <param> <value> [<param> <value>…]   override parameters
+ *   string <param> off                  back to the preset's value
+ *   string reset                        drop the overrides, keep the preset
+ *   string off                          back to the track's synth voice
+ *
+ * `string sitar`, `string buzz 0.8 sym 0.5`, `string ring 6`. Each command
+ * is one `updateTrack` revision and one undo step.
+ */
+import { FxValidationError } from "../../core/params.ts";
+import {
+  ScoreValidationError,
+  updateTrack,
+  type TrackScore,
+} from "../../core/score.ts";
+import {
+  DEFAULT_STRING_PRESET,
+  isStringTrack,
+  normalizeString,
+  STRING_INSTRUMENT,
+  STRING_PARAMS,
+  STRING_PRESET_NAMES,
+  STRING_PRESETS,
+  STRING_SIMPLE_PARAMS,
+  stringParamName,
+  stringPresetName,
+  stringPresetOf,
+  type TrackString,
+} from "../../core/strings.ts";
+import { parseParamValue } from "./fx.ts";
+
+export type StringCommand =
+  | { type: "string-list" }
+  | { type: "string-presets" }
+  | { type: "string-reset" }
+  | { type: "string-off" }
+  | { type: "string-preset"; preset: string }
+  | {
+      type: "string-set";
+      /** `null` unsets a parameter (the preset's value again). */
+      values: Readonly<Record<string, number | string | null>>;
+    };
+
+export function parseStringCommand(prompt: string): StringCommand | undefined {
+  const words = prompt.trim().split(/\s+/);
+  if (words[0]?.toLowerCase() !== "string") return undefined;
+  if (words.length === 1) return { type: "string-list" };
+  if (prompt.length > 1_024) return undefined;
+  const rest = words.slice(1).map((word) => word.toLowerCase());
+  if (rest.length === 1) {
+    if (rest[0] === "reset") return { type: "string-reset" };
+    if (rest[0] === "off") return { type: "string-off" };
+    if (rest[0] === "presets" || rest[0] === "list")
+      return { type: "string-presets" };
+    const preset = stringPresetName(rest[0]!);
+    return preset ? { type: "string-preset", preset } : undefined;
+  }
+  if (rest[0] === "preset") {
+    const preset = rest.length === 2 ? stringPresetName(rest[1]!) : undefined;
+    return preset ? { type: "string-preset", preset } : undefined;
+  }
+  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 = stringParamName(rest[index]!);
+    if (!name) return undefined;
+    const word = rest[index + 1]!;
+    if (word === "off" || word === "unset") {
+      values[name] = null;
+      continue;
+    }
+    const value = parseParamValue(STRING_PARAMS[name]!, word);
+    if (value === undefined || typeof value === "boolean") return undefined;
+    values[name] = value;
+  }
+  return { type: "string-set", values };
+}
+
+/** `sitar · buzz 0.8 · sym 0.5`, or `nylon` for a bare preset. */
+export function describeString(settings: TrackString | undefined): string {
+  const parts = [stringPresetOf(settings)];
+  for (const [key, value] of Object.entries(settings ?? {}))
+    if (key !== "preset" && value !== undefined) parts.push(`${key} ${value}`);
+  return parts.join(" · ");
+}
+
+export type StringResult = Readonly<{
+  ok: boolean;
+  message: string;
+  next?: TrackScore;
+  kind?: string;
+  payload?: Record<string, unknown>;
+}>;
+
+export function applyStringCommand(
+  score: TrackScore,
+  trackId: string,
+  command: StringCommand,
+): StringResult {
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track) return { ok: false, message: `no track · ${trackId}` };
+  if (command.type === "string-presets")
+    return {
+      ok: true,
+      message: `string presets · ${STRING_PRESET_NAMES.map((name) => `${name} (${STRING_PRESETS[name]!.doc})`).join(" · ")}`,
+    };
+  if (track.sampler || track.kit)
+    return {
+      ok: false,
+      message: `string · ${trackId} is a ${track.sampler ? "sampler" : "drum"} track; the string engine plays pitched notes`,
+    };
+  const active = isStringTrack(track);
+  if (command.type === "string-list")
+    return {
+      ok: true,
+      message: active
+        ? `string · ${describeString(track.string)} · basics ${STRING_SIMPLE_PARAMS.join(" ")}`
+        : `string · off (${track.instrument}) · string ${DEFAULT_STRING_PRESET} turns it on · string presets`,
+    };
+  let instrument = track.instrument;
+  let string: Record<string, unknown> | null;
+  if (command.type === "string-off") {
+    if (!active) return { ok: true, message: "string · already off" };
+    instrument = "pluck";
+    string = null;
+  } else if (command.type === "string-reset") {
+    if (!active) return { ok: true, message: "string · already off" };
+    string = { preset: stringPresetOf(track.string) };
+  } else if (command.type === "string-preset") {
+    instrument = STRING_INSTRUMENT;
+    string = { preset: command.preset };
+  } else {
+    instrument = STRING_INSTRUMENT;
+    string = active ? { ...track.string } : { preset: DEFAULT_STRING_PRESET };
+    for (const [key, value] of Object.entries(command.values)) {
+      if (value === null) delete string[key];
+      else string[key] = value;
+    }
+  }
+  let next: TrackScore;
+  try {
+    next = updateTrack(score, trackId, {
+      instrument,
+      string: string === null ? null : (normalizeString(string) ?? null),
+    });
+  } catch (error) {
+    if (
+      error instanceof ScoreValidationError ||
+      error instanceof FxValidationError
+    )
+      return { ok: false, message: `string · ${error.message}` };
+    throw error;
+  }
+  const stored = next.tracks.find((candidate) => candidate.id === trackId);
+  return {
+    ok: true,
+    message:
+      command.type === "string-off"
+        ? `string · off · ${instrument}`
+        : `string · ${describeString(stored?.string)}`,
+    next,
+    kind: "score.string",
+    payload: {
+      trackId,
+      instrument: stored?.instrument ?? instrument,
+      string: stored?.string ?? null,
+    },
+  };
+}

package/src/commands/time.ts

@@ -446,7 +446,10 @@ function applyOrThrow(
       const tick = tickOf(score, command.at);
       const where = placeLabel(command.at);
       if (tick >= loopTicksOf(score))
-        return { ok: false, message: `tempo · ${where} is past the song end` };
+        return {
+          ok: false,
+          message: `tempo · ${where} is past the song end (${score.bars} bars) · bars <n> extends it`,
+        };
       if (tick === 0) {
         const next = applyScoreOperation(score, {
           type: "setTempo",