@hraness/dawg 0.6.0 → 0.7.0

package/src/session/receipt.ts

@@ -0,0 +1,258 @@
+/**
+ * Musical receipts: one line that says what changed in the song, built from
+ * the score operations a change applied (`diffScores(before, after)`).
+ *
+ *   ◆ 96 BPM · +2 notes on bass (C4 E4) · reverb 0.4
+ *
+ * Receipts name tempo in BPM, notes by pitch, and track settings by their
+ * musical value; revision numbers and validator counts stay in the ctrl-o
+ * log. The builder is pure, so the agent turn, undo and redo share it.
+ */
+import { diffScores } from "../../core/diff.ts";
+import { drumVoiceForPitch, isDrumInstrument } from "../../core/drums.ts";
+import { midiToPitch } from "../../core/pitch.ts";
+import type { ScoreOperation, TrackScore } from "../../core/score.ts";
+
+/** Parts kept before the rest collapse to `+N more`. */
+const MAX_PARTS = 5;
+/** Pitch names listed after a note count. */
+const MAX_PITCHES = 4;
+
+function plural(count: number, word: string): string {
+  return `${count} ${word}${count === 1 ? "" : "s"}`;
+}
+
+function round(value: number, places = 2): string {
+  const scale = 10 ** places;
+  return String(Math.round(value * scale) / scale);
+}
+
+function noteName(pitch: number, drum: boolean): string {
+  return drum ? drumVoiceForPitch(pitch) : midiToPitch(pitch);
+}
+
+type NoteTally = { added: number[]; removed: number[]; changed: number };
+
+/** One field of a track patch as a musical phrase, or undefined to skip. */
+function trackField(field: string, value: unknown): string | undefined {
+  if (value === null || value === undefined) {
+    if (field === "volumeAutomation" || field.endsWith("Automation"))
+      return `${field.replace(/Automation$/, "")} automation off`;
+    return `${field} off`;
+  }
+  switch (field) {
+    case "volume":
+      return typeof value === "number" ? `volume ${round(value)}` : undefined;
+    case "pan":
+      return typeof value === "number" ? `pan ${round(value)}` : undefined;
+    case "muted":
+      return value === true ? "muted" : "unmuted";
+    case "solo":
+      return value === true ? "solo" : "solo off";
+    case "instrument":
+      return typeof value === "string" ? `→ ${value}` : undefined;
+    case "name":
+      return typeof value === "string" ? `renamed ${value}` : undefined;
+    case "reverb":
+    case "delay": {
+      const mix = (value as { mix?: unknown }).mix;
+      return typeof mix === "number" ? `${field} ${round(mix)}` : field;
+    }
+    case "filter": {
+      const cutoff = (value as { cutoff?: unknown }).cutoff;
+      return typeof cutoff === "number"
+        ? `filter ${Math.round(cutoff)} Hz`
+        : "filter";
+    }
+    case "fx": {
+      const names = Object.keys(value as Record<string, unknown>);
+      return names.length ? `fx ${names.join(" ")}` : "fx off";
+    }
+    default:
+      if (Array.isArray(value) && field.endsWith("Automation"))
+        return value.length === 0
+          ? `${field.replace(/Automation$/, "")} automation off`
+          : `${field.replace(/Automation$/, "")} automation`;
+      return field;
+  }
+}
+
+/**
+ * The receipt parts for `operations` applied to `before`. Tracks are named
+ * only when the song has more than one, so a single-track edit reads
+ * `reverb 0.4` and a band edit `bass reverb 0.4`.
+ */
+export function receiptParts(
+  before: TrackScore,
+  operations: readonly ScoreOperation[],
+): string[] {
+  const parts: string[] = [];
+  // Track settings follow the notes: what you hear first reads first.
+  const settings: string[] = [];
+  const instruments = new Map(
+    before.tracks.map((track) => [track.id, track.instrument]),
+  );
+  const noteTrack = new Map(
+    before.notes.map((note) => [note.id, note.trackId]),
+  );
+  const notePitch = new Map(
+    before.notes.map((note) => [
+      note.id,
+      typeof note.pitch === "number" ? note.pitch : Number.NaN,
+    ]),
+  );
+  const tallies = new Map<string, NoteTally>();
+  const tally = (trackId: string): NoteTally => {
+    let found = tallies.get(trackId);
+    if (!found) {
+      found = { added: [], removed: [], changed: 0 };
+      tallies.set(trackId, found);
+    }
+    return found;
+  };
+  const added = new Set<string>();
+  const removed = new Set<string>();
+  const trackCount = new Set([
+    ...before.tracks.map((track) => track.id),
+    ...operations.flatMap((op) =>
+      op.type === "addTrack" ? [op.track.id ?? "track"] : [],
+    ),
+  ]).size;
+  const prefix = (trackId: string) => (trackCount > 1 ? `${trackId} ` : "");
+  // Notes are summarised per track after the song-level parts.
+  for (const op of operations) {
+    switch (op.type) {
+      case "setTempo":
+        parts.push(`${round(op.tempoBpm, 1)} BPM`);
+        break;
+      case "setKey":
+        parts.push(op.key ? `key ${op.key}` : "no key");
+        break;
+      case "setBars":
+        parts.push(plural(op.bars, "bar"));
+        break;
+      case "setMeter":
+        parts.push(`${op.beatsPerBar} beats a bar`);
+        break;
+      case "setTime":
+        parts.push(op.time ? "tempo map" : "steady tempo");
+        break;
+      case "setTuning":
+        parts.push(
+          op.tuning ? `tuning ${op.tuning.name ?? ""}`.trim() : "12-TET",
+        );
+        break;
+      case "setMaster":
+        parts.push(op.master ? "master" : "master off");
+        break;
+      case "setStyle":
+        if (op.style) parts.push(op.style.id);
+        break;
+      case "setSections":
+        parts.push(plural(op.sections.length, "section"));
+        break;
+      case "setCalibration":
+        break;
+      case "addTrack": {
+        const id = op.track.id ?? "track";
+        const instrument = op.track.instrument;
+        added.add(id);
+        instruments.set(id, instrument ?? "");
+        parts.push(
+          `+${id}${instrument && instrument !== id ? ` (${instrument})` : ""}`,
+        );
+        break;
+      }
+      case "removeTrack":
+        removed.add(op.trackId);
+        parts.push(`−${op.trackId}`);
+        break;
+      case "moveTrack":
+        parts.push(`moved ${op.trackId}`);
+        break;
+      case "clearTrack":
+        parts.push(`cleared ${op.trackId}`);
+        break;
+      case "setClips":
+        settings.push(
+          `${prefix(op.trackId)}${op.clips && op.clips.length ? plural(op.clips.length, "clip") : "no clips"}`,
+        );
+        break;
+      case "setAutomation":
+        settings.push(`${prefix(op.trackId)}${op.parameter} automation`);
+        break;
+      case "updateTrack": {
+        if (added.has(op.trackId)) break;
+        const fields = Object.entries(op.patch)
+          .map(([field, value]) => trackField(field, value))
+          .filter((text): text is string => text !== undefined);
+        if (fields.length === 0) break;
+        const name = op.patch.name;
+        const label =
+          typeof name === "string" ? op.trackId : prefix(op.trackId).trim();
+        const text = fields.slice(0, 2).join(" ");
+        settings.push(label ? `${label} ${text}` : text);
+        break;
+      }
+      case "addNote": {
+        const entry = tally(op.note.trackId);
+        entry.added.push(
+          typeof op.note.pitch === "number" ? op.note.pitch : Number.NaN,
+        );
+        break;
+      }
+      case "removeNote": {
+        const trackId = noteTrack.get(op.noteId);
+        if (trackId && !removed.has(trackId))
+          tally(trackId).removed.push(notePitch.get(op.noteId) ?? Number.NaN);
+        break;
+      }
+      case "updateNote": {
+        const trackId = noteTrack.get(op.noteId);
+        if (trackId) tally(trackId).changed += 1;
+        break;
+      }
+    }
+  }
+  for (const [trackId, entry] of tallies) {
+    const drum = isDrumInstrument(instruments.get(trackId));
+    const listed = (pitches: readonly number[]): string => {
+      const names = pitches
+        .filter((pitch) => Number.isFinite(pitch))
+        .slice(0, MAX_PITCHES)
+        .map((pitch) => noteName(pitch, drum));
+      const more = pitches.length > MAX_PITCHES ? " …" : "";
+      return names.length ? ` (${names.join(" ")}${more})` : "";
+    };
+    if (entry.added.length > 0)
+      parts.push(
+        `+${plural(entry.added.length, "note")} on ${trackId}${listed(entry.added)}`,
+      );
+    if (entry.removed.length > 0)
+      parts.push(
+        `−${plural(entry.removed.length, "note")} on ${trackId}${listed(entry.removed)}`,
+      );
+    if (entry.changed > 0)
+      parts.push(`${plural(entry.changed, "note")} edited on ${trackId}`);
+  }
+  parts.push(...settings);
+  if (parts.length > MAX_PARTS)
+    return [
+      ...parts.slice(0, MAX_PARTS - 1),
+      `+${parts.length - (MAX_PARTS - 1)} more`,
+    ];
+  return parts;
+}
+
+/** `96 BPM · +2 notes on bass (C4 E4) · reverb 0.4`, or "" for no change. */
+export function musicalReceipt(before: TrackScore, after: TrackScore): string {
+  if (before === after) return "";
+  let operations: readonly ScoreOperation[];
+  try {
+    operations = diffScores(before, after);
+  } catch {
+    // A resolution change cannot diff: say the song changed.
+    return "song changed";
+  }
+  return receiptParts(before, operations).join(" · ");
+}

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;
@@ -56,6 +61,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;
 };
@@ -207,10 +219,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 = {
@@ -228,7 +239,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 +257,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 +268,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 +401,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 +436,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 +485,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 +508,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 (
@@ -546,6 +567,7 @@ function validateSessionRecord<T>(value: unknown): SessionRecord<T> {
     updatedAt: record.updatedAt,
     composition: record.composition as T,
     events,
+    ...(base > 0 ? { folded: base } : {}),
     meta,
   };
 }

package/src/tui/arrange-menu.ts

@@ -8,6 +8,7 @@ import type { Section } from "../../core/score.ts";
 import { formatForm } from "../../core/sections.ts";
 import { barsLabel } from "../commands/arrange.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 +21,26 @@ export function arrangeDetail(context: MenuContext): string {
   return parts.join(" · ");
 }
 
+/**
+ * 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 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;
-      },
-    },
+  const count = score.sections.length;
+  const nodes: MenuNode[] = [
     {
-      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(),
+      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",
@@ -80,6 +66,15 @@ export function arrangeNodes(context: MenuContext): MenuNode[] {
         help: "play the whole song (or form) again",
       });
   }
+  // 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 +383,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|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;
+  /^\/?(?:(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. */

package/src/tui/euclid.ts

@@ -18,7 +18,18 @@
  * `a` flips A/B, `c` solo ↔ in context, Enter keeps the staged changes as
  * one undo step and Esc reverts them.
  */
-import { HINTS } from "../../tui/grammar.ts";
+import {
+  HINTS,
+  KEY_BACKSPACE,
+  KEY_BACKTAB,
+  KEY_DOWN,
+  KEY_ENTER,
+  KEY_LEFT,
+  KEY_RESET,
+  KEY_RIGHT,
+  KEY_TAB,
+  KEY_UP,
+} from "../../tui/grammar.ts";
 import { DRUM_VOICES, isDrumInstrument } from "../../core/drums.ts";
 import {
   DIVISIONS,
@@ -284,15 +295,9 @@ export function ringText(row: RhythmRow | undefined): string {
     .join("");
 }
 
-const KEY_UP = new Set(["\u001b[A", "\u001bOA", "k"]);
-const KEY_DOWN = new Set(["\u001b[B", "\u001bOB", "j"]);
-const KEY_LEFT = new Set(["\u001b[D", "\u001bOD", "h", "-", "_"]);
-const KEY_RIGHT = new Set(["\u001b[C", "\u001bOC", "l", "+", "="]);
-const KEY_NEXT_PARAM = new Set(["\t", "]"]);
-const KEY_PREV_PARAM = new Set(["\u001b[Z", "["]);
-const KEY_ENTER = new Set(["\r", "\n"]);
-const KEY_BACKSPACE = new Set(["\u007f", "\b"]);
-const KEY_OFF = new Set(["x", "\u001b[3~"]);
+/** Tab ] next field, shift-tab [ previous (the brackets are the old keys). */
+const isNextField = (value: string) => KEY_TAB.has(value) || value === "]";
+const isPrevField = (value: string) => KEY_BACKTAB.has(value) || value === "[";
 
 export class EuclidEditor {
   private visible = false;
@@ -394,8 +399,8 @@ export class EuclidEditor {
           lanes.length;
       return { type: "handled" };
     }
-    if (KEY_NEXT_PARAM.has(value) || KEY_PREV_PARAM.has(value)) {
-      const direction = KEY_NEXT_PARAM.has(value) ? 1 : -1;
+    if (isNextField(value) || isPrevField(value)) {
+      const direction = isNextField(value) ? 1 : -1;
       this.param =
         (this.param + direction + EUCLID_PARAMS.length) % EUCLID_PARAMS.length;
       return { type: "handled" };
@@ -437,7 +442,7 @@ export class EuclidEditor {
       this.entry = "";
       return { type: "handled" };
     }
-    if (KEY_OFF.has(value))
+    if (KEY_RESET.has(value))
       return lane.row
         ? { type: "run", command: `euclid ${lane.voice} off` }
         : { type: "handled" };