@hraness/dawg 0.6.0 → 0.6.1

package/src/commands/wind.ts

@@ -0,0 +1,244 @@
+/**
+ * The `wind` prompt command (0.6.1): blown waveguides on the focused track
+ * (core/winds.ts). The menu and the `set_wind` agent tool build the same
+ * edits.
+ *
+ *   wind                               show the track's preset and overrides
+ *   wind <preset>                      play a preset: flute recorder whistle
+ *                                      ney shakuhachi panpipe suling bansuri
+ *                                      clarinet bassclarinet oboe bassoon sax
+ *                                      altosax barisax trumpet harmon plunger
+ *                                      trombone tuba horn (and aliases such
+ *                                      as saxophone frenchhorn panflute)
+ *   wind <preset> <param> <value>…     a preset with overrides
+ *   wind preset <name>                 the same, spelled out
+ *   wind mute <open|straight|cup|harmon|plunger>
+ *   wind <param> <value> [<param> <value>…]   breath 0.8, players 4 …
+ *   wind <param> off                   back to the preset's value
+ *   wind reset                         clear overrides (keep the preset)
+ *   wind off                           back to the legacy wind tone
+ *   wind list | presets wind           the presets with one-line characters
+ *
+ * Any edit turns the track into a wind-engine track (`instrument "wind"`
+ * plus a `wind` field); a stored `wind` with no field keeps the legacy tone.
+ * One `updateTrack` revision and one undo step per command.
+ */
+import { FxValidationError } from "../../core/params.ts";
+import {
+  DEFAULT_WIND_PRESET,
+  normalizeWind,
+  WIND_INSTRUMENT,
+  WIND_PARAMS,
+  WIND_PRESETS,
+  WIND_PRESET_NAMES,
+  WIND_SIMPLE,
+  windParamName,
+  windPresetFor,
+  type TrackWind,
+} from "../../core/resonators.ts";
+import {
+  ScoreValidationError,
+  updateTrack,
+  type TrackScore,
+} from "../../core/score.ts";
+import { nearestWord } from "../audio/instrument-check.ts";
+import { parseParamValue } from "./fx.ts";
+
+export type WindCommand =
+  | { type: "wind-show" }
+  | { type: "wind-list" }
+  | { type: "wind-reset" }
+  | { type: "wind-off" }
+  | { type: "wind-preset"; preset: string }
+  | { type: "wind-usage"; message: string }
+  | {
+      type: "wind-set";
+      /** A preset applied before the values (`wind trumpet mute harmon`). */
+      preset?: string;
+      /** `null` returns a parameter to the preset's value. */
+      values: Readonly<Record<string, number | string | boolean | null>>;
+    };
+
+export const WIND_USAGE =
+  "wind <preset> | wind <param> <value> | wind mute <name> | wind reset | wind off | wind presets";
+
+function rangeOf(name: string): string {
+  const spec = WIND_PARAMS[name]!;
+  if (spec.kind === "number") return `${name} is ${spec.min}..${spec.max}`;
+  if (spec.kind === "enum") return `${name} is one of ${spec.values.join(" ")}`;
+  return `${name} is on or off`;
+}
+
+export function parseWindCommand(prompt: string): WindCommand | undefined {
+  const words = prompt.trim().toLowerCase().split(/\s+/);
+  if (words[0] === "presets" && words[1] === "wind" && words.length === 2)
+    return { type: "wind-list" };
+  if (words[0] !== "wind") return undefined;
+  if (words.length === 1) return { type: "wind-show" };
+  if (prompt.length > 512) return undefined;
+  const rest = words.slice(1);
+  if (rest.length === 1 && rest[0] === "reset") return { type: "wind-reset" };
+  if (rest.length === 1 && rest[0] === "off") return { type: "wind-off" };
+  if (rest.length === 1 && (rest[0] === "list" || rest[0] === "presets"))
+    return { type: "wind-list" };
+  if (rest[0] === "preset") {
+    const preset = rest.length === 2 ? windPresetFor(rest[1]!) : undefined;
+    return preset
+      ? { type: "wind-preset", preset }
+      : {
+          type: "wind-usage",
+          message: `wind preset is one of ${WIND_PRESET_NAMES.join(" ")}`,
+        };
+  }
+  if (rest.length === 1) {
+    const preset = windPresetFor(rest[0]!);
+    if (preset) return { type: "wind-preset", preset };
+    const mute = WIND_PARAMS.mute;
+    if (mute?.kind === "enum" && mute.values.includes(rest[0]!))
+      return { type: "wind-set", values: { mute: rest[0]! } };
+    return { type: "wind-usage", message: WIND_USAGE };
+  }
+  // `wind <preset> <param> <value>…`: the preset, then its overrides.
+  const lead = rest.length % 2 === 1 ? windPresetFor(rest[0]!) : undefined;
+  if (lead) rest.shift();
+  if (rest.length % 2 !== 0) return { type: "wind-usage", message: WIND_USAGE };
+  const values: Record<string, number | string | boolean | null> = {};
+  for (let index = 0; index < rest.length; index += 2) {
+    const name = windParamName(rest[index]!);
+    if (!name) {
+      const word = rest[index]!.slice(0, 24);
+      const near = nearestWord(word, Object.keys(WIND_PARAMS));
+      return {
+        type: "wind-usage",
+        message: `wind has no parameter ${word}${near ? ` · did you mean ${near}?` : ""} · ${WIND_SIMPLE.join(" ")} …`,
+      };
+    }
+    const word = rest[index + 1]!;
+    if (word === "off" && name !== "stopped") {
+      values[name] = null;
+      continue;
+    }
+    if (word === "unset") {
+      values[name] = null;
+      continue;
+    }
+    const value = parseParamValue(WIND_PARAMS[name]!, word);
+    if (value === undefined)
+      return { type: "wind-usage", message: rangeOf(name) };
+    values[name] = value;
+  }
+  return lead
+    ? { type: "wind-set", preset: lead, values }
+    : { type: "wind-set", values };
+}
+
+/** `preset sax · breath 0.8 · players 4`, overrides in canonical order. */
+export function describeWind(wind: TrackWind | undefined): string {
+  if (!wind) return "not a wind-engine track";
+  const preset = wind.preset ?? DEFAULT_WIND_PRESET;
+  const overrides = Object.entries(wind)
+    .filter(([key]) => key !== "preset")
+    .map(([key, value]) => `${key} ${value}`);
+  return [`preset ${preset}`, ...overrides].join(" · ");
+}
+
+/** One line per preset, for `wind list` and the agent brief. */
+export function windListLines(): string[] {
+  return WIND_PRESET_NAMES.map(
+    (name) => `${name.padEnd(13)} ${WIND_PRESETS[name].doc}`,
+  );
+}
+
+export type WindResult = Readonly<{
+  ok: boolean;
+  message: string;
+  next?: TrackScore;
+  kind?: string;
+  payload?: Record<string, unknown>;
+}>;
+
+/**
+ * The wind field a command leaves on a track (pure; the agent tool shares
+ * it). A preset switch keeps the overrides; `reset` keeps the preset.
+ */
+export function nextWind(
+  current: TrackWind | undefined,
+  command: Extract<
+    WindCommand,
+    { type: "wind-reset" | "wind-preset" | "wind-set" }
+  >,
+): TrackWind {
+  if (command.type === "wind-reset")
+    return normalizeWind(current?.preset ? { preset: current.preset } : {})!;
+  const base: Record<string, unknown> = { ...current };
+  if (command.type === "wind-preset") base.preset = command.preset;
+  else {
+    if (command.preset) base.preset = command.preset;
+    for (const [key, value] of Object.entries(command.values)) {
+      if (value === null) delete base[key];
+      else base[key] = value;
+    }
+  }
+  return normalizeWind(base)!;
+}
+
+export function applyWindCommand(
+  score: TrackScore,
+  trackId: string,
+  command: WindCommand,
+): WindResult {
+  if (command.type === "wind-usage")
+    return { ok: false, message: `wind · ${command.message}` };
+  if (command.type === "wind-list")
+    return {
+      ok: true,
+      message: `wind presets · ${WIND_PRESET_NAMES.join(" ")}`,
+    };
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track) return { ok: false, message: `no track · ${trackId}` };
+  const current = track.instrument === WIND_INSTRUMENT ? track.wind : undefined;
+  if (command.type === "wind-show")
+    return {
+      ok: true,
+      message: current
+        ? `wind · ${describeWind(current)}`
+        : `wind · ${trackId} plays ${track.instrument} · wind <preset> to switch (${WIND_PRESET_NAMES.join(" ")})`,
+    };
+  if (track.sampler || track.instrument === "kit")
+    return {
+      ok: false,
+      message: `wind · ${trackId} is a ${track.sampler ? "sampler" : "drum"} track`,
+    };
+  if (command.type === "wind-off") {
+    if (!current) return { ok: true, message: "wind · already off" };
+    // The stored word stays `wind`, which is the legacy tone without a field.
+    const next = updateTrack(score, trackId, { wind: null });
+    return {
+      ok: true,
+      message: `wind · off (legacy wind tone) · wind ${current.preset ?? DEFAULT_WIND_PRESET} turns it back on`,
+      next,
+      kind: "score.wind",
+      payload: { trackId, instrument: WIND_INSTRUMENT, wind: null },
+    };
+  }
+  let wind: TrackWind;
+  let next: TrackScore;
+  try {
+    wind = nextWind(current, command);
+    next = updateTrack(score, trackId, { instrument: WIND_INSTRUMENT, wind });
+  } catch (error) {
+    if (
+      error instanceof ScoreValidationError ||
+      error instanceof FxValidationError
+    )
+      return { ok: false, message: `wind · ${error.message}` };
+    throw error;
+  }
+  return {
+    ok: true,
+    message: `wind · ${describeWind(wind)}`,
+    next,
+    kind: "score.wind",
+    payload: { trackId, instrument: WIND_INSTRUMENT, wind },
+  };
+}

package/src/main.ts

@@ -69,11 +69,22 @@ import {
   rigTrackFields,
   rigWordPatch,
 } from "./commands/rig.ts";
+import {
+  applyGuitarCommand,
+  applyStrumCommand,
+  parseGuitarCommand,
+  parseStrumCommand,
+} from "./commands/strum.ts";
 import {
   applyModalCommand,
   modalListLines,
   parseModalCommand,
 } from "./commands/modal.ts";
+import {
+  applyWindCommand,
+  parseWindCommand,
+  windListLines,
+} from "./commands/wind.ts";
 import { applySynthCommand, parseSynthCommand } from "./commands/synth.ts";
 import { applyStringCommand, parseStringCommand } from "./commands/string.ts";
 import { instrumentPatchForWord, isModalWord } from "../core/resonators.ts";
@@ -127,6 +138,8 @@ import {
   voiceNameFrom,
 } from "./commands/sample.ts";
 import { applyFitCommand, fitVoice, parseFitCommand } from "./commands/fit.ts";
+import { applyShiftCommand, parseShiftCommand } from "./commands/shift.ts";
+import { parseResampleCommand, runResample } from "./commands/resample.ts";
 import { suggestFitMode } from "./audio/dsp/onset.ts";
 import {
   SampleLibrary,
@@ -307,11 +320,16 @@ function parsesLocally(text: string): boolean {
     parsePackCommand,
     parseSampleCommand,
     parseFitCommand,
+    parseShiftCommand,
+    parseResampleCommand,
     parseWavetableCommand,
     parseTimeCommand,
     parseTuningCommand,
     parseRigCommand,
     parseModalCommand,
+    parseGuitarCommand,
+    parseStrumCommand,
+    parseWindCommand,
   ].some((parse) => parse(text) !== undefined);
 }
 
@@ -487,6 +505,22 @@ const freshWorkspace = !(await stat(join(process.cwd(), ".dawg")).then(
   () => true,
   () => false,
 ));
+// Decode the import before a session exists, so a bad file is one line.
+let importedScore: TrackScore | undefined;
+if (importPath) {
+  try {
+    importedScore = decodeLoop(await readLoopFile(importPath));
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    const midi = /\.midi?$/i.test(importPath)
+      ? " · MIDI files are not imported; --import takes a .track.json loop"
+      : "";
+    process.stderr.write(
+      `dawg: cannot import ${importPath} · ${reason.split("\n")[0]!.slice(0, 160)}${midi}\n`,
+    );
+    process.exit(1);
+  }
+}
 const session = await ensureSession(initial.toJSON(), sessionOptions);
 // dawgd when connected, the file-lock path otherwise (see src/session/port.ts).
 let port = await openSessionPort<ReturnType<TrackScore["toJSON"]>>({
@@ -499,9 +533,8 @@ let port = await openSessionPort<ReturnType<TrackScore["toJSON"]>>({
 let record: SessionRecord<ReturnType<TrackScore["toJSON"]>> =
   port.mode === "daemon" ? await port.load() : session.record;
 let score = scoreFromJSON(record.composition);
-if (importPath) {
-  const imported = decodeLoop(await readLoopFile(importPath));
-  score = imported;
+if (importPath && importedScore) {
+  score = importedScore;
   record = await port.append(
     record,
     {
@@ -1656,7 +1689,11 @@ async function submit(prompt: string): Promise<string | Receipt> {
   }
   const chordsCommand = command.match(/^\/chords(?:\s+(.+))?$/i);
   if (chordsCommand) {
-    const result = applyChordsCommand(chordSettings, chordsCommand[1] ?? "");
+    const result = applyChordsCommand(
+      chordSettings,
+      chordsCommand[1] ?? "",
+      score.tempoBpm,
+    );
     return result.ok ? ok(result.message) : fail(result.message);
   }
   const countIn = command.match(/^\/count-?in\s+([0-2])$/i);
@@ -1731,6 +1768,16 @@ async function submit(prompt: string): Promise<string | Receipt> {
   if (sample) return sampleCommand(sample);
   const fit = parseFitCommand(command);
   if (fit) return fitCommand(fit);
+  const shift = parseShiftCommand(command);
+  if (shift) {
+    const result = applyShiftCommand(score, requestedTrack, shift);
+    if (!result.ok) return fail(result.message);
+    await commitScore(result.next, "sample.set", { trackId: requestedTrack });
+    await projectSync?.flushScore();
+    return ok(result.message);
+  }
+  const resample = parseResampleCommand(command);
+  if (resample) return resampleCommand(resample);
   const pack = parsePackCommand(command);
   if (pack) return packCommand(pack);
   const pattern = parsePatternCommand(command);
@@ -1765,6 +1812,25 @@ async function submit(prompt: string): Promise<string | Receipt> {
       await commitScore(result.next, result.kind, result.payload);
     return result.ok ? ok(result.message) : fail(result.message);
   }
+  const guitar = parseGuitarCommand(command);
+  if (guitar) {
+    if (guitar.type !== "guitar-show" && guitar.type !== "guitar-hint")
+      await materializeDraft();
+    const result = applyGuitarCommand(score, requestedTrack, guitar);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
+  const strum = parseStrumCommand(command);
+  if (strum) {
+    if (strum.type === "strum") await materializeDraft();
+    const result = applyStrumCommand(score, requestedTrack, strum, () =>
+      randomUUID().slice(0, 12),
+    );
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
   const rig = parseRigCommand(command);
   if (rig) {
     if (rig.type !== "rig-show" && rig.type !== "rig-hint")
@@ -1827,6 +1893,17 @@ async function submit(prompt: string): Promise<string | Receipt> {
       await commitScore(result.next, result.kind, result.payload);
     return result.ok ? ok(result.message) : fail(result.message);
   }
+  const windCommand = parseWindCommand(command);
+  if (windCommand) {
+    if (windCommand.type === "wind-list")
+      tui.openText("wind presets", windListLines());
+    if (windCommand.type !== "wind-show" && windCommand.type !== "wind-list")
+      await materializeDraft();
+    const result = applyWindCommand(score, requestedTrack, windCommand);
+    if (result.next && result.kind)
+      await commitScore(result.next, result.kind, result.payload);
+    return result.ok ? ok(result.message) : fail(result.message);
+  }
   const synth = parseSynthCommand(command);
   if (synth) {
     if (synth.type !== "synth-list") await materializeDraft();
@@ -2078,6 +2155,9 @@ async function submit(prompt: string): Promise<string | Receipt> {
     // Plain `marimba` keeps the legacy tone; point at the mallet engine.
     if (parsed.patch.instrument === "marimba" && !("modal" in parsed.patch))
       return `track · ${requestedTrack} · marimba (legacy tone) · modal marimba for the mallet engine`;
+    // Plain `wind` keeps the legacy tone; point at the wind engine.
+    if (parsed.patch.instrument === "wind" && !("wind" in parsed.patch))
+      return `track · ${requestedTrack} · wind (legacy tone) · wind flute (or sax, trumpet …) for the wind engine`;
     const sine =
       word !== undefined && !("string" in parsed.patch)
         ? plainSineAdvice(word)
@@ -2375,6 +2455,36 @@ async function fitCommand(
   );
 }
 
+async function resampleCommand(
+  command: NonNullable<ReturnType<typeof parseResampleCommand>>,
+): Promise<Receipt> {
+  await materializeDraft();
+  // The source's own samples must be loaded for the render.
+  if (hasSamplerTracks(score)) await sampleProblems(score);
+  const result = await runResample({
+    projectRoot: process.cwd(),
+    score,
+    command,
+    ...(liveSampleBank ? { samples: liveSampleBank } : {}),
+  });
+  if (!result.ok) return fail(result.message);
+  const problems = (await sampleProblems(result.next)).filter(
+    (problem) =>
+      problem.trackId === result.trackId && problem.level === "error",
+  );
+  if (problems.length > 0) return fail(`resample · ${problems[0]!.message}`);
+  await commitScore(result.next, "resample", {
+    trackId: result.trackId,
+    src: result.src,
+    sha256: result.sha256,
+  });
+  await port.focus(result.trackId);
+  requestedTrack = result.trackId;
+  draftTrack = false;
+  await projectSync?.flushScore();
+  return ok(result.message);
+}
+
 async function sampleCommand(
   command: NonNullable<ReturnType<typeof parseSampleCommand>>,
 ): Promise<Receipt> {
@@ -3167,7 +3277,11 @@ function stagedChordSettings(): ChordSettings | undefined {
   if (chords.length === 0) return undefined;
   const settings = { ...chordSettings };
   for (const command of chords)
-    applyChordsCommand(settings, command.match(CHORDS_COMMAND)![1]!);
+    applyChordsCommand(
+      settings,
+      command.match(CHORDS_COMMAND)![1]!,
+      score.tempoBpm,
+    );
   return settings;
 }
 
@@ -3224,7 +3338,11 @@ async function applyStaged(
   const chords = command.trim().match(CHORDS_COMMAND);
   if (chords) {
     // Window state: checked on a copy; kept settings apply on Enter.
-    const result = applyChordsCommand({ ...chordSettings }, chords[1]!);
+    const result = applyChordsCommand(
+      { ...chordSettings },
+      chords[1]!,
+      base.tempoBpm,
+    );
     return { next: base, ok: result.ok, message: result.message };
   }
   await prefetchStaged(base, command);
@@ -3417,7 +3535,11 @@ async function keepStaged(): Promise<Receipt> {
     CHORDS_COMMAND.test(command),
   );
   for (const command of chordCommands)
-    applyChordsCommand(chordSettings, command.match(CHORDS_COMMAND)![1]!);
+    applyChordsCommand(
+      chordSettings,
+      command.match(CHORDS_COMMAND)![1]!,
+      score.tempoBpm,
+    );
   const scoreCommands = taken.commands.filter(
     (command) => !CHORDS_COMMAND.test(command),
   );

package/src/project/check.ts

@@ -8,7 +8,10 @@ import {
   formatDiagnostic,
   type Diagnostic,
 } from "../../core/sdk/eval.ts";
-import { legacyResonatorWarnings } from "../../core/resonators.ts";
+import {
+  legacyResonatorWarnings,
+  modalPairWarnings,
+} from "../../core/resonators.ts";
 import { plainSineWarnings } from "../audio/instrument-check.ts";
 import { isProject } from "./init.ts";
 import { typecheckProject } from "./typecheck.ts";
@@ -53,6 +56,7 @@ export async function checkProject(
       evaluated.ok
         ? [
             ...legacyResonatorWarnings(evaluated.score.tracks),
+            ...modalPairWarnings(evaluated.score.tracks),
             ...plainSineWarnings(evaluated.score.tracks),
           ]
         : [],

package/src/render.ts

@@ -229,6 +229,15 @@ export async function runRenderCommand(
     `rendered · ${target} · ${seconds.toFixed(2)} s · ${wav.byteLength} bytes · ${sha}\n`,
   );
   if (credits) stdout.write(`credits · ${credits}\n`);
+  const clipped = clippedSamples(audio.pcm);
+  if (clipped > 0)
+    stderr.write(
+      `warning · ${clipped} ${clipped === 1 ? "sample clips" : "samples clip"} at full scale · ${
+        audio.master
+          ? "add master limiter or lower the master gain"
+          : "lower track volumes or add a master with a limiter (master streaming, or master: { limiter: {} } in song.ts)"
+      }\n`,
+    );
   if (options.has("--measure"))
     stdout.write(
       `loudness · ${measurementLine(measureRendered(audio, false).mix, audio.master)}\n`,
@@ -238,6 +247,13 @@ export async function runRenderCommand(
   return 0;
 }
 
+/** Samples at or past 16-bit full scale: the mix bus hit the rails. */
+export function clippedSamples(pcm: Int16Array): number {
+  let count = 0;
+  for (const value of pcm) if (value >= 32_767 || value <= -32_768) count += 1;
+  return count;
+}
+
 async function loadScore(
   workspace: string,
   options: ReadonlyMap<string, string>,

package/src/session/presence.ts

@@ -32,6 +32,8 @@ export class FilePresence {
   private readonly lock: string;
   private entry: PresenceEntry;
   private timer: ReturnType<typeof setInterval> | undefined;
+  private writing: Promise<void> = Promise.resolve();
+  private writes = 0;
 
   public constructor(paths: SessionPaths, entry: PresenceEntry) {
     this.dir = `${paths.record}.presence`;
@@ -56,7 +58,8 @@ export class FilePresence {
 
   public async focus(trackId: string | null): Promise<void> {
     this.entry = { ...this.entry, focusedTrackId: trackId };
-    await this.write();
+    // Presence is advisory: a failed heartbeat write never refuses a focus change.
+    await this.write().catch(() => undefined);
   }
 
   public async claim(
@@ -133,9 +136,19 @@ export class FilePresence {
     return join(this.dir, `${this.entry.clientId}.json`);
   }
 
-  private async write(): Promise<void> {
+  /** Writes are serialized so the heartbeat and focus() never share a rename. */
+  private write(): Promise<void> {
+    const next = this.writing.then(
+      () => this.writeNow(),
+      () => this.writeNow(),
+    );
+    this.writing = next.catch(() => undefined);
+    return next;
+  }
+
+  private async writeNow(): Promise<void> {
     await mkdir(this.dir, { recursive: true });
-    const temporary = `${this.file()}.${process.pid}.tmp`;
+    const temporary = `${this.file()}.${process.pid}.${++this.writes}.tmp`;
     await writeFile(
       temporary,
       JSON.stringify({ ...this.entry, at: Date.now() }),

package/src/tui/audition.ts

@@ -528,7 +528,7 @@ export function auditionKey(value: string): AuditionKey | undefined {
  * before.
  */
 const STAGEABLE =
-  /^\/?(?:(fx|effects|filter|lowpass|synth|string|modal|wt|wavetable|grain|kit|instrument|vol|volume|pan|gain|speed|warpmode|root|pattern|euclid|art|articulation|bend|vibrato|glide|portamento|velcurve|vel-curve|pedal|sustain|humanize|tuning|tune|master|keys|piano)\s+\S|pack\s+use\s+\S|(?:piano|grand|upright|felt|honkytonk|prepared|ballad)(?:\s+piano)?\s*$)/i;
+  /^\/?(?:(fx|effects|filter|lowpass|synth|string|bowed|modal|wind|wt|wavetable|grain|kit|instrument|vol|volume|pan|gain|speed|warpmode|root|pattern|euclid|art|articulation|bend|vibrato|glide|portamento|velcurve|vel-curve|pedal|sustain|humanize|tuning|tune|master|keys|piano|epiano|rhodes|wurli|wurlitzer|clav|clavinet)\s+\S|pack\s+use\s+\S|(?:piano|grand|upright|felt|honkytonk|prepared|ballad)(?:\s+piano)?\s*$|(?:epiano|rhodes|suitcase|dyno|wurli|wurlitzer|clav|clavinet|funkclav)\s*$|(?:tonewheel|hammond|b3|gospel|jazzorgan|combo|farfisa|vox|pipe|church|pipeorgan|churchorgan|flutes|cornet|reeds|celeste)(?:\s+\S.*)?$|rotary\s+(?:slow|fast|stop)\s*$)/i;
 /** Subcommands that list or show instead of changing the sound. */
 const READ_ONLY = /^\/?\S+\s+(list|show|info|help|measure|meter|presets?)\s*$/i;
 /** `master <unit>` alone only shows the unit. */