@hraness/dawg 0.6.1 → 0.8.0

package/src/session/store.ts

@@ -1,4 +1,5 @@
-import { mkdir, open, readFile, rename, rm } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
+import { durableWrite } from "../fs/durable.ts";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
 import { acquireSessionLock } from "./lock.ts";
@@ -20,9 +21,13 @@ const MAX_EVENT_BYTES = 64 * 1024;
 /** A rewind larger than this (a wholesale import) is not kept; the edit still lands. */
 const MAX_REWIND_BYTES = 1024 * 1024;
 const MAX_EVENTS = 2_000;
+/**
+ * When the log is full, this many of the oldest events are folded away so a
+ * long session keeps accepting edits. The composition is the checkpoint;
+ * undo still reaches back through the events that remain.
+ */
+const FOLD_BATCH = 200;
 export const MAX_RECORD_BYTES = 4 * 1024 * 1024;
-/** Oldest rewinds are dropped in batches of this size when the record fills up. */
-const COMPACT_BATCH = 64;
 const MAX_SESSION_ID_LENGTH = 64;
 const MAX_EVENT_KIND_LENGTH = 128;
 const MAX_TIMESTAMP_LENGTH = 64;
@@ -34,12 +39,36 @@ export class SessionValidationError extends Error {
   }
 }
 
+/**
+ * Who made an event. Stamped by the authority from the connection's hello,
+ * never trusted from the intent: `actorId` is the person (absent for v1
+ * clients and the file fallback), `clientId` the window, `seq` the
+ * per-(actor, client) intent number used for retry dedupe.
+ */
+export type EventActor = {
+  actorId?: string;
+  clientId: string;
+  seq?: number;
+};
+
 export type SessionEvent = {
   id: string;
   revision: number;
+  /**
+   * Opaque to the store: any bounded string is kept and passed through, so a
+   * newer peer's event kinds survive an older reader.
+   */
   kind: string;
   payload: unknown;
   at: string;
+  actor?: EventActor;
+  /**
+   * The score operations this event applied: sent by an ops intent, or
+   * derived by the authority from a composition intent. Folding `ops` from
+   * the previous composition reproduces this one. Events without `ops` are
+   * snapshots (too large to diff, or not expressible as operations).
+   */
+  ops?: unknown[];
   /**
    * How to recover the composition this event replaced from the one it
    * produced (see `delta.ts`). Absent once compacted away: the store drops
@@ -56,6 +85,13 @@ export type SessionRecord<T> = {
   updatedAt: string;
   composition: T;
   events: SessionEvent[];
+  /**
+   * Optional (0.7): how many of the oldest events were folded away when the
+   * log filled up. `revision === (folded ?? 0) + events.length`, and
+   * `events[i].revision === (folded ?? 0) + i + 1`. Absent on records that
+   * never filled, so older records load and print unchanged.
+   */
+  folded?: number;
   /** Name and lineage. Versioned separately so renames keep the revision. */
   meta: SessionMeta;
 };
@@ -192,7 +228,10 @@ export async function appendSessionEvent<T>(
   // History is the store's job: a `before` composition in the payload (the
   // pre-rewind convention) is dropped rather than persisted in full.
   const payload = stripBefore(event.payload);
-  const payloadJson = stringifyJson(payload, "session event payload");
+  const payloadJson = stringifyJson(
+    event.ops === undefined ? payload : [payload, event.ops],
+    "session event payload",
+  );
   const payloadBytes = Buffer.byteLength(payloadJson, "utf8");
   if (payloadBytes > MAX_EVENT_BYTES)
     throw new Error(`session event exceeds ${MAX_EVENT_BYTES} bytes`);
@@ -207,10 +246,9 @@ export async function appendSessionEvent<T>(
   try {
     const disk = await readRecord<T>(paths.record);
     if (disk.revision !== current.revision) throw new SessionConflictError();
-    // Re-check the bounded event budget against the locked record. A stale
-    // caller can pass the pre-lock check while another writer fills the log.
-    if (disk.events.length >= MAX_EVENTS)
-      throw new Error(`session event limit ${MAX_EVENTS} reached`);
+    // A full log folds its oldest events away instead of refusing the edit.
+    const fold = disk.events.length >= MAX_EVENTS ? FOLD_BATCH : 0;
+    const folded = (disk.folded ?? 0) + fold;
     const revision = disk.revision + 1;
     const at = new Date().toISOString();
     const appended: SessionEvent = {
@@ -220,6 +258,8 @@ export async function appendSessionEvent<T>(
       revision,
       at,
     };
+    if (event.actor !== undefined) appended.actor = { ...event.actor };
+    if (event.ops !== undefined) appended.ops = [...event.ops];
     const rewind = diffRewind(disk.composition, composition);
     if (Buffer.byteLength(JSON.stringify(rewind), "utf8") <= MAX_REWIND_BYTES)
       appended.rewind = rewind;
@@ -228,7 +268,8 @@ export async function appendSessionEvent<T>(
       revision,
       updatedAt: at,
       composition,
-      events: [...disk.events, appended],
+      events: [...disk.events.slice(fold), appended],
+      ...(folded > 0 ? { folded } : {}),
       // Metadata always comes from disk so a rename written by another window
       // between this caller's read and its write is never reverted.
       meta: disk.meta,
@@ -245,8 +286,10 @@ export async function appendSessionEvent<T>(
 /**
  * Keeps the record under its size cap by dropping the oldest events'
  * rewinds, oldest first, so the rewinds that remain are always the newest
- * contiguous run. Only the composition and the bounded payloads are
- * irreducible; a record that still does not fit is rejected as before.
+ * contiguous run. The appended (last) event's rewind is dropped only when
+ * nothing else is left to drop, so undo of the edit just made keeps working
+ * whenever its rewind fits on its own. Only the composition and the bounded
+ * payloads are irreducible; a record that still does not fit is rejected.
  */
 function compactRecord<T>(record: SessionRecord<T>): {
   record: SessionRecord<T>;
@@ -254,23 +297,27 @@ function compactRecord<T>(record: SessionRecord<T>): {
 } {
   let current = record;
   let json = JSON.stringify(current);
-  while (Buffer.byteLength(json, "utf8") > MAX_RECORD_BYTES) {
-    const first = current.events.findIndex(
-      (event) => event.rewind !== undefined,
-    );
-    if (first < 0)
-      throw new SessionValidationError(
-        `session record exceeds ${MAX_RECORD_BYTES} bytes`,
-      );
-    const events = current.events.map((event, index) => {
-      if (index < first || index >= first + COMPACT_BATCH || !event.rewind)
-        return event;
-      const { rewind: _rewind, ...rest } = event;
-      return rest;
-    });
-    current = { ...current, events };
-    json = JSON.stringify(current);
+  let bytes = Buffer.byteLength(json, "utf8");
+  if (bytes <= MAX_RECORD_BYTES) return { record: current, json };
+  const events = [...current.events];
+  const last = events.length - 1;
+  // Measured sizes let the loop strip exactly as many rewinds as needed with
+  // one final stringify instead of one per batch.
+  // The appended event comes last, after every older rewind is gone.
+  for (let index = 0; index <= last && bytes > MAX_RECORD_BYTES; index += 1) {
+    const event = events[index]!;
+    if (event.rewind === undefined) continue;
+    const { rewind, ...rest } = event;
+    // `,"rewind":<json>` is what dropping the field saves.
+    bytes -= Buffer.byteLength(JSON.stringify(rewind), "utf8") + 10;
+    events[index] = rest;
   }
+  current = { ...current, events };
+  json = JSON.stringify(current);
+  if (Buffer.byteLength(json, "utf8") > MAX_RECORD_BYTES)
+    throw new SessionValidationError(
+      `session record exceeds ${MAX_RECORD_BYTES} bytes`,
+    );
   return { record: current, json };
 }
 
@@ -383,8 +430,13 @@ export async function inheritedEvents(
     } catch {
       break;
     }
-    if (!parent || fork.revision > parent.events.length) break;
-    const prefix = parent.events.slice(0, fork.revision);
+    if (!parent || fork.revision > parent.revision) break;
+    // Events folded out of the parent are gone; what remains still ends at
+    // the fork point.
+    const prefix = parent.events.slice(
+      0,
+      Math.max(0, fork.revision - (parent.folded ?? 0)),
+    );
     chunks.unshift(prefix.slice(-(MAX_INHERITED_EVENTS - total)));
     total += prefix.length;
     fork = parent.meta.forkOf;
@@ -413,20 +465,10 @@ async function writeAtomic(path: string, contents: string): Promise<void> {
     throw new SessionValidationError(
       `session record exceeds ${MAX_RECORD_BYTES} bytes`,
     );
-  const temporary = `${path}.${process.pid}.tmp`;
   // Durable before it is visible: the data reaches the disk before the
-  // rename publishes it, so a crash never leaves a truncated record behind.
-  const handle = await open(temporary, "w", 0o644);
-  try {
-    await handle.writeFile(`${contents}\n`, "utf8");
-    await handle.sync();
-  } catch (error) {
-    await handle.close().catch(() => undefined);
-    await rm(temporary, { force: true }).catch(() => undefined);
-    throw error;
-  }
-  await handle.close();
-  await rename(temporary, path);
+  // rename publishes it, and the directory is synced so the rename survives
+  // a power loss too.
+  await durableWrite(path, `${contents}\n`, { mkdir: false });
 }
 
 async function readRecord<T>(path: string): Promise<SessionRecord<T>> {
@@ -472,7 +514,15 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
     throw new SessionValidationError(
       `session has more than ${MAX_EVENTS} events`,
     );
-  if (record.revision !== record.events.length)
+  const folded = record.folded ?? 0;
+  if (
+    !Number.isSafeInteger(folded) ||
+    (folded as number) < 0 ||
+    (record.folded !== undefined && folded === 0)
+  )
+    throw new SessionValidationError("session folded count is invalid");
+  const base = folded as number;
+  if (record.revision !== base + record.events.length)
     throw new SessionValidationError(
       "session revision does not match its event log",
     );
@@ -487,7 +537,7 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
     assertSessionId(candidate.id);
     if (
       !Number.isSafeInteger(candidate.revision) ||
-      candidate.revision !== index + 1
+      candidate.revision !== base + index + 1
     )
       throw new SessionValidationError("session event revisions are invalid");
     if (
@@ -502,7 +552,9 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
     )
       throw new SessionValidationError("session event timestamp is invalid");
     const payloadJson = stringifyJson(
-      candidate.payload,
+      candidate.ops === undefined
+        ? candidate.payload
+        : [candidate.payload, candidate.ops],
       "session event payload",
     );
     if (Buffer.byteLength(payloadJson, "utf8") > MAX_EVENT_BYTES)
@@ -527,6 +579,13 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
       at: candidate.at,
     };
     if (rewind !== undefined) parsed.rewind = rewind;
+    if (candidate.actor !== undefined)
+      parsed.actor = parseEventActor(candidate.actor);
+    if (candidate.ops !== undefined) {
+      if (!Array.isArray(candidate.ops))
+        throw new SessionValidationError("session event ops are invalid");
+      parsed.ops = candidate.ops;
+    }
     return parsed;
   });
   let meta: SessionMeta;
@@ -546,6 +605,7 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
     updatedAt: record.updatedAt,
     composition: record.composition as T,
     events,
+    ...(base > 0 ? { folded: base } : {}),
     meta,
   };
 }
@@ -579,3 +639,24 @@ function stringifyJson(value: unknown, label: string): string {
     throw new SessionValidationError(`${label} must be JSON data`);
   }
 }
+
+function parseEventActor(value: unknown): EventActor {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new SessionValidationError("session event actor is invalid");
+  const actor = value as Record<string, unknown>;
+  const valid =
+    typeof actor.clientId === "string" &&
+    actor.clientId.length > 0 &&
+    actor.clientId.length <= 64 &&
+    (actor.actorId === undefined ||
+      (typeof actor.actorId === "string" &&
+        /^a_[a-z2-7]{22}$/.test(actor.actorId))) &&
+    (actor.seq === undefined ||
+      (Number.isSafeInteger(actor.seq) && (actor.seq as number) >= 1));
+  if (!valid)
+    throw new SessionValidationError("session event actor is invalid");
+  const parsed: EventActor = { clientId: actor.clientId as string };
+  if (actor.actorId !== undefined) parsed.actorId = actor.actorId as string;
+  if (actor.seq !== undefined) parsed.seq = actor.seq as number;
+  return parsed;
+}

package/src/tui/arrange-menu.ts

@@ -7,7 +7,9 @@
 import type { Section } from "../../core/score.ts";
 import { formatForm } from "../../core/sections.ts";
 import { barsLabel } from "../commands/arrange.ts";
+import { rangeLabel } from "../../core/range.ts";
 import type { MenuContext, MenuNode } from "./menu.ts";
+import { styleMenuDetail, styleMenuNodes } from "./style-menu.ts";
 
 /** `3 sections · form A×2 B · loop chorus`, or how to start. */
 export function arrangeDetail(context: MenuContext): string {
@@ -20,41 +22,171 @@ export function arrangeDetail(context: MenuContext): string {
   return parts.join(" · ");
 }
 
-export function arrangeNodes(context: MenuContext): MenuNode[] {
+/** `loop 5–6 · 16 bars`, or the song length alone. */
+export function rangeDetail(context: MenuContext): string {
   const score = context.score;
-  const nodes: MenuNode[] = score.sections.map((section) => ({
-    kind: "menu",
-    id: `section:${section.name}`,
-    label: section.name,
-    detail: sectionDetail(context, section),
-    help: "loop, jump, mute, vary, move, rename, transitions",
-    build: (next) => sectionNodes(next, section.name),
-  }));
+  const bars = `${score.bars} bar${score.bars === 1 ? "" : "s"}`;
+  return score.loop ? `loop ${rangeLabel(score.loop)} · ${bars}` : bars;
+}
+
+/** A bar range typed as `5-6` or `5`: kept as typed, else undefined. */
+function barsText(text: string): string | undefined {
+  const value = text.trim().replace(/\s*(?:–|\.\.)\s*/u, "-");
+  return /^\d{1,4}(?:-\d{1,4})?$/u.test(value) ? value : undefined;
+}
+
+/**
+ * Arrange › range (op1-ux §6.4): each row runs the typed range command on
+ * the focused track, so the menu, the prompt and the agent share one path.
+ */
+export function rangeNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const track = context.trackId;
+  const nodes: MenuNode[] = [
+    {
+      kind: "entry",
+      label: "loop bars",
+      value: score.loop ? rangeLabel(score.loop) : "the song",
+      placeholder: "bars, e.g. 5-6",
+      example: "loop 5-6",
+      help: "loop these bars in playback; empty plays the song",
+      command: (text) => {
+        if (!text.trim()) return "loop off";
+        const bars = barsText(text);
+        return bars ? `loop ${bars}` : undefined;
+      },
+    },
+  ];
+  if (score.loop)
+    nodes.push(
+      {
+        kind: "action",
+        label: "loop next",
+        command: "loop next",
+        help: "step the loop one length later",
+      },
+      {
+        kind: "action",
+        label: "loop prev",
+        command: "loop prev",
+        help: "step the loop one length earlier",
+      },
+    );
   nodes.push(
     {
       kind: "entry",
-      label: "mark bars",
+      label: "copy bars",
       value: "",
-      placeholder: "name and bars, e.g. verse 1-8",
-      example: "section verse 1-8",
-      help: "name a bar range; re-marking a name moves its marker",
+      placeholder: "bars to bar, e.g. 5-6 to 7 x2",
+      example: `copy ${track} 5-6 to 7 x2`,
+      help: "copy this track's bars; x2 tiles, insert shifts later music",
+      command: (text) =>
+        text.trim() ? `copy ${track} ${text.trim()}` : undefined,
+    },
+    {
+      kind: "entry",
+      label: "move bars",
+      value: "",
+      placeholder: "bars to bar, e.g. 5-6 to 9",
+      example: `move ${track} 5-6 to 9`,
+      help: "move this track's bars; the source empties",
+      command: (text) =>
+        text.trim() ? `move ${track} ${text.trim()}` : undefined,
+    },
+    {
+      kind: "entry",
+      label: "clear bars",
+      value: "",
+      placeholder: "bars, e.g. 5-6",
+      example: `clear ${track} 5-6`,
+      help: "empty this track's bars; the bars stay",
       command: (text) => {
-        const trimmed = text.trim();
-        return /\S\s+\d{1,4}(?:[-–]\d{1,4})?$/u.test(trimmed)
-          ? `section ${trimmed}`
-          : undefined;
+        const bars = barsText(text);
+        return bars ? `clear ${track} ${bars}` : undefined;
       },
     },
     {
       kind: "entry",
-      label: "add section",
+      label: "reverse bars",
       value: "",
-      placeholder: "name and bars, e.g. chorus 8 (empty: next name, 8 bars)",
-      example: "section add chorus 8",
-      help: "a new section after the last one (extends the song)",
-      command: (text) => `section add ${text.trim()}`.trim(),
+      placeholder: "bars, e.g. 5-6",
+      example: `reverse ${track} 5-6`,
+      help: "mirror this track's bars in time",
+      command: (text) => {
+        const bars = barsText(text);
+        return bars ? `reverse ${track} ${bars}` : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "paste at",
+      value: "",
+      placeholder: "a bar, e.g. 9",
+      example: "paste at 9",
+      help: "lay the clipboard down (copy bars without `to` fills it)",
+      command: (text) =>
+        /^\d{1,4}$/u.test(text.trim()) ? `paste at ${text.trim()}` : undefined,
+    },
+    {
+      kind: "entry",
+      label: "insert bars",
+      value: "",
+      placeholder: "count at bar, e.g. 2 at 3",
+      example: "bars insert 2 at 3",
+      help: "add empty bars; later sections, clips, automation and tempo move right",
+      command: (text) =>
+        /^\d{1,3}\s+at\s+\d{1,4}$/u.test(text.trim())
+          ? `bars insert ${text.trim().replace(/\s+/gu, " ")}`
+          : undefined,
+    },
+    {
+      kind: "entry",
+      label: "remove bars",
+      value: "",
+      placeholder: "bars, e.g. 5-6",
+      example: "bars remove 5-6",
+      help: "cut the bars out; later music moves left",
+      command: (text) => {
+        const bars = barsText(text);
+        return bars ? `bars remove ${bars}` : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "jump",
+      value: "",
+      placeholder: "bar or bar.beat, e.g. 5.3",
+      example: "jump 5.3",
+      help: "move the playhead",
+      command: (text) =>
+        /^\d{1,4}(?:\.\d{1,2})?$/u.test(text.trim())
+          ? `jump ${text.trim()}`
+          : undefined,
     },
   );
+  return nodes;
+}
+
+/**
+ * Arrange's rows after tracks (§4a): sections (each section, mark bars,
+ * add section), then form and the style browser.
+ */
+export function arrangeNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const count = score.sections.length;
+  const nodes: MenuNode[] = [
+    {
+      kind: "menu",
+      id: "sections",
+      label: "sections",
+      detail:
+        count === 0
+          ? "none yet · mark bars"
+          : `${count} · ${score.sections.map((section) => section.name).join(", ")}`,
+      help: "mark bars, add a section, then loop, jump, mute or vary one",
+      build: sectionListNodes,
+    },
+  ];
   if (score.sections.length > 0) {
     nodes.push({
       kind: "entry",
@@ -68,7 +200,7 @@ export function arrangeNodes(context: MenuContext): MenuNode[] {
     if (score.form.length)
       nodes.push({
         kind: "action",
-        label: "bake form",
+        label: "print form to tape",
         command: "form bake",
         help: "write the form out as plain bars, then clear it",
       });
@@ -80,6 +212,37 @@ export function arrangeNodes(context: MenuContext): MenuNode[] {
         help: "play the whole song (or form) again",
       });
   }
+  // TAPE (op1-ux §6): every track across the bars, copy/cut/paste keys.
+  nodes.push({
+    kind: "action",
+    label: "tape",
+    command: "/tape",
+    help: "every track across the bars · c copy, x cut, v paste · ctrl-t",
+  });
+  // §4.7: record the loop in PLAY, one undo step per pass (r / R on TAPE).
+  nodes.push({
+    kind: "action",
+    label: "record the loop",
+    command: "keys record",
+    help: "play mode over the loop · each pass is one undo step · r on tape",
+  });
+  nodes.push({
+    kind: "menu",
+    id: "range",
+    label: "range",
+    detail: rangeDetail(context),
+    help: "loop bars, copy, move, clear, paste or reverse them, insert or remove bars",
+    build: rangeNodes,
+  });
+  // The style browser: a whole song from a style (src/tui/style-menu.ts).
+  nodes.push({
+    kind: "menu",
+    id: "style",
+    label: "style",
+    detail: styleMenuDetail(context),
+    help: "make a whole song from a style: the style tree, find and blend",
+    build: styleMenuNodes,
+  });
   return nodes;
 }
 
@@ -388,3 +551,42 @@ export function fillNodes(section: Section): MenuNode[] {
     },
   ];
 }
+
+/** Arrange › sections: one row per section, then mark bars and add section. */
+function sectionListNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const nodes: MenuNode[] = score.sections.map((section) => ({
+    kind: "menu",
+    id: `section:${section.name}`,
+    label: section.name,
+    detail: sectionDetail(context, section),
+    help: "loop, jump, mute, vary, move, rename, transitions",
+    build: (next) => sectionNodes(next, section.name),
+  }));
+  nodes.push(
+    {
+      kind: "entry",
+      label: "mark bars",
+      value: "",
+      placeholder: "name and bars, e.g. verse 1-8",
+      example: "section verse 1-8",
+      help: "name a bar range; re-marking a name moves its marker",
+      command: (text) => {
+        const trimmed = text.trim();
+        return /\S\s+\d{1,4}(?:[-–]\d{1,4})?$/u.test(trimmed)
+          ? `section ${trimmed}`
+          : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "add section",
+      value: "",
+      placeholder: "name and bars, e.g. chorus 8 (empty: next name, 8 bars)",
+      example: "section add chorus 8",
+      help: "a new section after the last one (extends the song)",
+      command: (text) => `section add ${text.trim()}`.trim(),
+    },
+  );
+  return nodes;
+}

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|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;
+  /^\/?(?:(clip|fx|effects|filter|lowpass|vocoder(?!\s+new\s*$)|formant|vowel|synth|string|bowed|modal|wind|sing|note\s+vowel|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. */