@hraness/dawg 0.4.0 → 0.4.1

package/src/audio/wav.ts

@@ -34,12 +34,16 @@ import {
 import { synthKit } from "../../core/kits.ts";
 import { kitDrumSample, kitTailSeconds, newKitVoiceState } from "./kits.ts";
 import {
+  addReverbWet,
   applyMonoChain,
   applyStereoChain,
   delayTailFor,
   interpolateAutomation,
+  reverbActive,
   reverbImpulse,
   reverbTailFor,
+  reverbWet,
+  type ReverbWet,
 } from "./effects/chain.ts";
 import {
   createOrbitBus,
@@ -193,8 +197,16 @@ type Stem = {
   key: string;
   left: Float64Array;
   right: Float64Array;
+  /** Stem, pre-reverb pair and tail (counted in the cache budget). */
   bytes: number;
   used: number;
+  /** For a track with a reverb: its stem before the reverb, and the tail. */
+  room?: Readonly<{
+    /** `stemKey` of the track with its reverb mix and mix lane left out. */
+    key: string;
+    pre: Readonly<{ left: Float64Array; right: Float64Array }>;
+    wet: ReverbWet;
+  }>;
 };
 
 /**
@@ -351,9 +363,38 @@ export class StemRenderer {
         track ? reverbImpulse(track, sampleRate, bank.irs)?.id : undefined,
       );
       let stem = this.stems.get(trackId);
+      const caching = this.maxCacheBytes > 0;
+      // A cached track with a reverb also keeps its pre-reverb pair and the
+      // tail before its mix gain, keyed without the mix: a mix-only edit
+      // re-adds the tail instead of re-running the voices and the room.
+      const room =
+        caching && track && busOrbit === undefined && reverbActive(track)
+          ? stemKey(
+              roomTrack(track),
+              notes,
+              context,
+              sampler ? bank : undefined,
+              wavetable?.id,
+              reverbImpulse(track, sampleRate, bank.irs)?.id,
+            )
+          : undefined;
       if (stem?.key === key) stem.used = this.renders;
-      else {
-        const caching = this.maxCacheBytes > 0;
+      else if (track && room !== undefined && stem?.room?.key === room) {
+        const { pre, wet } = stem.room;
+        const target = {
+          left: Float64Array.from(pre.left),
+          right: Float64Array.from(pre.right),
+        };
+        addReverbWet(target.left, target.right, wet, track, context);
+        stem = {
+          ...stem,
+          key,
+          left: target.left,
+          right: target.right,
+          used: this.renders,
+        };
+        this.store(trackId, stem);
+      } else {
         const target = caching
           ? {
               left: new Float64Array(samples),
@@ -403,7 +444,27 @@ export class StemRenderer {
           context,
           stereo ? dryR : undefined,
         );
-        if (track)
+        let saved: Stem["room"];
+        if (track && room !== undefined) {
+          // Same chain, the reverb split in two (see `applyReverb`).
+          applyStereoChain(
+            target.left,
+            target.right,
+            track,
+            context,
+            true,
+            false,
+          );
+          const pre = {
+            left: Float64Array.from(target.left),
+            right: Float64Array.from(target.right),
+          };
+          const wet = reverbWet(target.left, target.right, track, context);
+          if (wet) {
+            addReverbWet(target.left, target.right, wet, track, context);
+            saved = { key: room, pre, wet };
+          }
+        } else if (track)
           applyStereoChain(
             target.left,
             target.right,
@@ -415,8 +476,9 @@ export class StemRenderer {
           key,
           left: target.left,
           right: target.right,
-          bytes: target.left.byteLength + target.right.byteLength,
+          bytes: target.left.byteLength * (saved ? 6 : 2),
           used: this.renders,
+          ...(saved ? { room: saved } : {}),
         };
         if (caching) this.store(trackId, stem);
       }
@@ -426,17 +488,7 @@ export class StemRenderer {
           buses.set(busOrbit, (bus = createOrbitBus(busOrbit, samples)));
         sendToBus(bus, track, stem.left, stem.right, context, key);
       }
-      const gain = ducked.get(trackId);
-      if (gain)
-        for (let index = 0; index < samples; index += 1) {
-          mixL[index]! += stem.left[index]! * gain[index]!;
-          mixR[index]! += stem.right[index]! * gain[index]!;
-        }
-      else
-        for (let index = 0; index < samples; index += 1) {
-          mixL[index]! += stem.left[index]!;
-          mixR[index]! += stem.right[index]!;
-        }
+      addStem(mixL, mixR, stem.left, stem.right, samples, ducked.get(trackId));
     }
     // Bus returns join after every stem, in orbit order; the orbit's ducking
     // applies to them as to its tracks.
@@ -455,12 +507,15 @@ export class StemRenderer {
         wet = { key, ...renderOrbitBus(bus, context) };
         if (this.maxCacheBytes > 0) this.buses.set(orbit, wet);
       }
-      const gain = busGains.get(`bus:${orbit}`);
-      for (let index = 0; index < samples; index += 1) {
-        const g = gain ? gain[index]! : 1;
-        mixL[index]! += wet.left[index]! * g;
-        mixR[index]! += wet.right[index]! * g;
-      }
+      // (x * 1 === x, so an unducked bus adds its plain samples.)
+      addStem(
+        mixL,
+        mixR,
+        wet.left,
+        wet.right,
+        samples,
+        busGains.get(`bus:${orbit}`),
+      );
     }
     for (const orbit of [...this.buses.keys()])
       if (!buses.has(orbit)) this.buses.delete(orbit);
@@ -468,19 +523,10 @@ export class StemRenderer {
     // unsoloed tracks keep theirs so toggling them back is free.
     for (const trackId of [...this.stems.keys()])
       if (!groups.has(trackId)) this.evict(trackId);
-    if (samples > frames) {
-      // Linear effects superpose, so folding the tail onto the start yields
-      // the steady state of the loop playing forever.
-      for (let index = frames; index < samples; index += 1) {
-        mixL[index % frames]! += mixL[index]!;
-        mixR[index % frames]! += mixR[index]!;
-      }
-    }
-    const pcm = new Int16Array(frames * RENDER_CHANNELS);
-    for (let index = 0; index < frames; index += 1) {
-      pcm[index * 2] = clamp16(mixL[index]! * 32767);
-      pcm[index * 2 + 1] = clamp16(mixR[index]! * 32767);
-    }
+    // Linear effects superpose, so folding the tail onto the start yields
+    // the steady state of the loop playing forever.
+    if (samples > frames) foldTail(mixL, mixR, frames, samples);
+    const pcm = toPcm(mixL, mixR, frames);
     return Object.freeze({
       sampleRate,
       channels: RENDER_CHANNELS,
@@ -543,7 +589,75 @@ export class StemRenderer {
   }
 }
 
+/*
+ * The mix loops live in small functions of their own: inside `render` (a
+ * large function the JIT optimizes late) they ran several times slower.
+ * Same operations in the same order, so the output is unchanged.
+ */
+
+/** Add a stem (times its ducking gain, if any) into the mix. */
+function addStem(
+  mixL: Float64Array,
+  mixR: Float64Array,
+  left: Float64Array,
+  right: Float64Array,
+  samples: number,
+  gain: Float64Array | undefined,
+): void {
+  if (gain)
+    for (let index = 0; index < samples; index += 1) {
+      mixL[index]! += left[index]! * gain[index]!;
+      mixR[index]! += right[index]! * gain[index]!;
+    }
+  else
+    for (let index = 0; index < samples; index += 1) {
+      mixL[index]! += left[index]!;
+      mixR[index]! += right[index]!;
+    }
+}
+
+/** Fold everything past `frames` back onto the loop start. */
+function foldTail(
+  mixL: Float64Array,
+  mixR: Float64Array,
+  frames: number,
+  samples: number,
+): void {
+  for (let index = frames; index < samples; index += 1) {
+    mixL[index % frames]! += mixL[index]!;
+    mixR[index % frames]! += mixR[index]!;
+  }
+}
+
+/** Interleaved 16-bit PCM of the first `frames` mix samples. */
+function toPcm(
+  mixL: Float64Array,
+  mixR: Float64Array,
+  frames: number,
+): Int16Array {
+  const pcm = new Int16Array(frames * RENDER_CHANNELS);
+  for (let index = 0; index < frames; index += 1) {
+    pcm[index * 2] = clamp16(mixL[index]! * 32767);
+    pcm[index * 2 + 1] = clamp16(mixR[index]! * 32767);
+  }
+  return pcm;
+}
+
 /** Everything a track's stem depends on, except mute and solo. */
+/**
+ * The track as its reverb tail sees it: everything but the reverb's mix
+ * and mix lane, which only scale the tail.
+ */
+function roomTrack(track: Track): Track {
+  const lanes = { ...track.fxAutomation };
+  delete lanes["reverb-mix"];
+  return {
+    ...track,
+    reverb: { ...track.reverb!, mix: 1 },
+    fxAutomation: lanes,
+  } as Track;
+}
+
 function stemKey(
   track: Track | undefined,
   notes: readonly Note[],

package/src/main.ts

@@ -116,14 +116,24 @@ import {
   type LiveEngine,
 } from "./tui/play-session.ts";
 import { EditMenu, MENU_SECTIONS, type MenuContext } from "./tui/menu.ts";
-import { Audition, SUPERSEDED, isStageable } from "./tui/audition.ts";
-import { EuclidEditor } from "./tui/euclid.ts";
+import {
+  Audition,
+  SUPERSEDED,
+  isChordStageable,
+  isStageable,
+} from "./tui/audition.ts";
+import { EuclidEditor, type EuclidContext } from "./tui/euclid.ts";
 import { HINTS, KEYS, keyLines, type KeySection } from "../tui/grammar.ts";
 import { renderAudition } from "./audio/audition.ts";
 import { renderScorePcm } from "./audio/wav.ts";
 import type { PreviewHost } from "./agent/preview-tool.ts";
 import { rhythmVoicePitch } from "../core/rhythm.ts";
-import { applyChordsCommand, defaultChordSettings } from "./tui/play-chords.ts";
+import {
+  applyChordsCommand,
+  chordPhrase,
+  defaultChordSettings,
+  type ChordSettings,
+} from "./tui/play-chords.ts";
 import {
   cacheLines,
   kitListLines,
@@ -469,6 +479,10 @@ const AGENT_PREVIEW_VOICE = 0x7fff_0002;
  * instead of appending, and a remote revision that lands meanwhile waits in
  * `committed` (the window's `score` is the staged base until it finishes).
  */
+/** A `/chords …` settings command (staged as window state, not a score edit). */
+const CHORDS_COMMAND = /^\/chords\s+(.+)$/i;
+/** Whether the chord settings screen was open at the last menu redraw. */
+let chordScreenWas = false;
 let stageCapture: { next?: TrackScore; committed?: TrackScore } | undefined;
 /** Redraw soon (the audition reports renders between frames). */
 let requestFrame: () => void = () => undefined;
@@ -1032,11 +1046,23 @@ async function runInteractive(): Promise<void> {
               euclid.close();
               tui.closePicker();
               if (back === "menu") openMenu();
+              else leaveAuditionScreen();
             } else if (result.type === "run") {
-              queuedPrompts.unshift(result.command);
-              if (result.audition) pendingAudition = result.audition;
-              void drainQueue();
+              if (!stageIfAuditioning(result.command)) {
+                queuedPrompts.unshift(result.command);
+                if (result.audition) pendingAudition = result.audition;
+                void drainQueue();
+              }
             } else if (result.type === "audition") audition(result.voice);
+            else if (result.type === "loop") auditionKeyPressed(result.key);
+            else if (result.type === "revert") revertStaged();
+            else if (result.type === "keep")
+              void keepStaged()
+                .then((outcome) => receipt(outcome))
+                .catch((error) =>
+                  tui.activity.pushError(describeError("keep", error)),
+                )
+                .finally(() => tick(true));
             if (result.type !== "pass") {
               refreshEuclid();
               tick(true);
@@ -2369,6 +2395,8 @@ function menuContext(): MenuContext {
       committed: score,
       hint: loop.hint(),
       status: loop.status(),
+      stageable: stageableNow,
+      committedChords: chordSettings,
     },
     trackId: requestedTrack,
     playing: clock.playing,
@@ -2376,7 +2404,7 @@ function menuContext(): MenuContext {
     grids: GRIDS.map((grid) => grid.label),
     clickOn: session?.clickOn ?? false,
     countInBars: session?.countInBars ?? 1,
-    chords: session?.chords.settings ?? chordSettings,
+    chords: stagedChordSettings() ?? session?.chords.settings ?? chordSettings,
     projectRoot: process.cwd(),
   };
 }
@@ -2415,8 +2443,20 @@ function openMenu(section?: string): void {
   refreshMenu();
 }
 
-function euclidContext() {
-  return { score, trackId: requestedTrack };
+function euclidContext(): EuclidContext {
+  const loop = auditionController();
+  loop.focus(requestedTrack);
+  return {
+    score: loop.staging ? loop.score : score,
+    trackId: requestedTrack,
+    audition: {
+      looping: loop.looping,
+      dirty: loop.dirtyEdits,
+      committed: score,
+      hint: loop.hint(),
+      status: loop.status(),
+    },
+  };
 }
 
 function openEuclid(voice?: string, origin?: string): void {
@@ -2493,6 +2533,15 @@ function auditionController(): Audition {
       clearTimer: (handle) => clearTimeout(handle as Timer),
       changed: () => requestFrame(),
       level: () => previewEngine().level,
+      // The chord settings screen loops a progression with its settings.
+      phrase: (showing) => {
+        if (!chordScreenOpen()) return undefined;
+        const settings =
+          showing === "A"
+            ? chordSettings
+            : (stagedChordSettings() ?? chordSettings);
+        return (base, track, bars) => chordPhrase(settings, base, track, bars);
+      },
     },
     score,
     requestedTrack,
@@ -2500,6 +2549,41 @@ function auditionController(): Audition {
   return auditionLoop;
 }
 
+/** True while the menu's Chords section (`/menu chords`) is open. */
+function chordScreenOpen(): boolean {
+  return menu.open && menu.section === "chords";
+}
+
+/** What stages while auditioning on the screen open now. */
+function stageableNow(command: string): boolean {
+  return (
+    isStageable(command) || (chordScreenOpen() && isChordStageable(command))
+  );
+}
+
+/**
+ * The chord settings with the staged `/chords …` commands applied, or
+ * undefined while none are staged. Chord settings are window state (not in
+ * the score), so the staged ones are derived from the staged commands.
+ */
+function stagedChordSettings(): ChordSettings | undefined {
+  const commands = auditionLoop?.dirtyEdits ? auditionLoop.commands : [];
+  const chords = commands.filter((command) => CHORDS_COMMAND.test(command));
+  if (chords.length === 0) return undefined;
+  const settings = { ...chordSettings };
+  for (const command of chords)
+    applyChordsCommand(settings, command.match(CHORDS_COMMAND)![1]!);
+  return settings;
+}
+
+/** Re-render the loop when the chord screen opens or closes. */
+function noteChordScreen(): void {
+  const now = chordScreenOpen();
+  if (now === chordScreenWas) return;
+  chordScreenWas = now;
+  auditionLoop?.request();
+}
+
 /**
  * Warm the pack cache for a staged command before it runs, so a lazy fetch
  * (a sample kit, a pack sound or table) happens outside the capture and the
@@ -2542,6 +2626,12 @@ async function applyStaged(
   base: TrackScore,
   command: string,
 ): Promise<{ next?: TrackScore; ok: boolean; message: string }> {
+  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]!);
+    return { next: base, ok: result.ok, message: result.message };
+  }
   await prefetchStaged(base, command);
   // Staged commands run one at a time, between queued prompts.
   while (stageCapture) await Bun.sleep(1);
@@ -2709,7 +2799,7 @@ function pickerAuditionKey(key: "loop" | "ab" | "context"): void {
 /** Stage a menu command while auditioning; undefined when it should run. */
 function stageIfAuditioning(command: string): boolean {
   const loop = auditionLoop;
-  if (!loop?.staging || !isStageable(command)) return false;
+  if (!loop?.staging || !stageableNow(command)) return false;
   void loop.stage(command).then((result) => {
     if (!result.ok)
       tui.activity.pushCard(result.message, {
@@ -2727,12 +2817,21 @@ async function keepStaged(): Promise<Receipt> {
   const taken = loop?.take();
   if (!loop || !taken) return warn("nothing staged");
   await materializeDraft();
+  // Chord settings are window state: they apply here, outside the revision.
+  const chordCommands = taken.commands.filter((command) =>
+    CHORDS_COMMAND.test(command),
+  );
+  for (const command of chordCommands)
+    applyChordsCommand(chordSettings, command.match(CHORDS_COMMAND)![1]!);
+  const scoreCommands = taken.commands.filter(
+    (command) => !CHORDS_COMMAND.test(command),
+  );
   let next = taken.score;
-  for (let attempt = 0; ; attempt += 1) {
+  for (let attempt = 0; scoreCommands.length && next !== score; attempt += 1) {
     try {
       await commitScore(next, "preview.commit", {
         trackId: loop.trackId,
-        commands: taken.commands,
+        commands: scoreCommands,
       });
       break;
     } catch (error) {
@@ -2741,7 +2840,7 @@ async function keepStaged(): Promise<Receipt> {
       record = await port.load();
       score = scoreFromJSON(record.composition);
       next = score;
-      for (const command of taken.commands) {
+      for (const command of scoreCommands) {
         const result = await applyStaged(next, command);
         if (result.next) next = result.next;
       }
@@ -2749,8 +2848,11 @@ async function keepStaged(): Promise<Receipt> {
   }
   loop.committedNow(score);
   await projectSync?.flushScore();
+  const kept = `kept ${taken.commands.length} change${taken.commands.length === 1 ? "" : "s"}`;
   return ok(
-    `kept ${taken.commands.length} change${taken.commands.length === 1 ? "" : "s"} · one undo step`,
+    scoreCommands.length
+      ? `${kept} · one undo step`
+      : `${kept} · chord settings (window state, no revision)`,
   );
 }
 
@@ -2772,6 +2874,7 @@ function leaveAuditionScreen(): void {
 }
 
 function refreshMenu(): void {
+  noteChordScreen();
   if (!menu.open) return;
   if (tui.ui.overlay !== undefined && tui.ui.picker?.id !== "menu") {
     // Another overlay (help, a picker) replaced the menu.

package/src/tui/audition.ts

@@ -33,6 +33,7 @@ import {
   meterBar,
   previewScore,
   type Preview,
+  type PreviewOptions,
   type SoundLevel,
 } from "../audio/preview.ts";
 
@@ -61,6 +62,12 @@ export type AuditionHost = {
   changed?(): void;
   /** Level of the loop now playing, for the title's meter. */
   level?(): SoundLevel | undefined;
+  /**
+   * A phrase that replaces the track's notes for the sound now playing (A:
+   * committed, B: staged), or undefined for the usual loop. The chord
+   * settings screen plays a progression with its settings this way.
+   */
+  phrase?(showing: "A" | "B"): PreviewOptions["phrase"];
 };
 
 export type AuditionOptions = Readonly<{
@@ -404,9 +411,11 @@ export class Audition {
   private async flush(): Promise<void> {
     if (!this.looping || this.rendering) return;
     this.cancelTimer();
+    const phrase = this.host.phrase?.(this.dirtyEdits ? this.showing : "A");
     const preview = previewScore(this.sounding, this.trackId, {
       context: this.context,
       beat: this.host.beat?.() ?? 0,
+      ...(phrase ? { phrase } : {}),
     });
     if (!preview) return;
     this.rendering = true;
@@ -491,7 +500,7 @@ export function auditionKey(value: string): AuditionKey | undefined {
  * before.
  */
 const STAGEABLE =
-  /^\/?(?:(fx|effects|filter|lowpass|synth|wt|wavetable|kit|instrument|vol|volume|pan|gain|speed|warpmode|root|pattern)\s+\S|pack\s+use\s+\S)/i;
+  /^\/?(?:(fx|effects|filter|lowpass|synth|wt|wavetable|kit|instrument|vol|volume|pan|gain|speed|warpmode|root|pattern|euclid)\s+\S|pack\s+use\s+\S)/i;
 /** Subcommands that list or show instead of changing the sound. */
 const READ_ONLY = /^\/?\S+\s+(list|show|info|help)\s*$/i;
 
@@ -499,3 +508,14 @@ export function isStageable(command: string): boolean {
   const text = command.trim();
   return STAGEABLE.test(text) && !READ_ONLY.test(text);
 }
+
+/**
+ * Chord settings and the song key, which stage only in the chord settings
+ * screen: its loop plays a progression with them (`AuditionHost.phrase`),
+ * while elsewhere they would change nothing audible.
+ */
+export function isChordStageable(command: string): boolean {
+  return (
+    /^\/chords\s+\S/i.test(command.trim()) || /^key\s+\S/i.test(command.trim())
+  );
+}

package/src/tui/euclid.ts

@@ -10,8 +10,13 @@
  * one undo step and the row's detail teaches the command.
  *
  * Keys: ↑↓ voice · ←→ (h l + -) nudge · tab / shift-tab (] [) parameter ·
- * digits type a value · enter add/edit · space audition · x off · f freeze ·
+ * digits type a value · enter add/edit · space loop · x off · f freeze ·
  * esc back.
+ *
+ * Auditioning (src/tui/audition.ts) works as in the menu: `Space` loops the
+ * track, and while it plays every change is staged (heard, not committed);
+ * `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 { DRUM_VOICES, isDrumInstrument } from "../../core/drums.ts";
@@ -30,15 +35,30 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import type { PickerItem } from "../../tui/app.ts";
+import { auditionKey, type AuditionKey } from "./audition.ts";
+import type { MenuAudition } from "./menu.ts";
 
-export type EuclidContext = Readonly<{ score: TrackScore; trackId: string }>;
+export type EuclidContext = Readonly<{
+  /** The score shown: the staged one while auditioning. */
+  score: TrackScore;
+  trackId: string;
+  /** The audition loop, when the window hosts one (as in the menu). */
+  audition?: MenuAudition;
+}>;
 
 export type EuclidResult =
   | { type: "handled" }
   | { type: "close" }
   /** Run `command`; `audition` names the voice to play once it lands. */
   | { type: "run"; command: string; audition?: string }
+  /** Play `voice` once (no audition loop in this window). */
   | { type: "audition"; voice: string }
+  /** Space (loop), `a` (A/B) or `c` (context) for the audition loop. */
+  | { type: "loop"; key: AuditionKey }
+  /** Commit the staged edits as one operation. */
+  | { type: "keep" }
+  /** Drop the staged edits. */
+  | { type: "revert" }
   | { type: "pass" };
 
 export type EuclidView = Readonly<{
@@ -362,7 +382,11 @@ export class EuclidEditor {
         this.entry = (this.entry + value).slice(0, 12);
       return { type: "handled" };
     }
-    if (value === "\u001b") return { type: "close" };
+    const audition = context.audition;
+    if (value === "\u001b")
+      return audition?.dirty ? { type: "revert" } : { type: "close" };
+    const loopKey = audition ? auditionKey(value) : undefined;
+    if (loopKey) return { type: "loop", key: loopKey };
     if (KEY_UP.has(value) || KEY_DOWN.has(value)) {
       if (lanes.length)
         this.lane =
@@ -403,6 +427,7 @@ export class EuclidEditor {
       return { type: "handled" };
     }
     if (KEY_ENTER.has(value)) {
+      if (audition?.dirty) return { type: "keep" };
       if (!lane.row)
         return {
           type: "run",
@@ -429,6 +454,12 @@ export class EuclidEditor {
     const index = Math.max(0, Math.min(this.lane, lanes.length - 1));
     const param = EUCLID_PARAMS[this.param]!;
     const width = Math.max(5, ...lanes.map((lane) => lane.label.length));
+    const audition = context.audition;
+    // Changed rows show `staged ← committed`, as in the menu.
+    const before = new Map<string, string>();
+    if (audition?.dirty)
+      for (const lane of this.lanes({ ...context, score: audition.committed }))
+        before.set(lane.voice, lane.row ? rowSummary(lane.row) : "off");
     const items: PickerItem[] = lanes.map((lane, at) => {
       const row = lane.row;
       const shown = row
@@ -436,11 +467,16 @@ export class EuclidEditor {
           ? "grid"
           : formatValue(param.value(row))
         : "—";
+      const now = row ? rowSummary(row) : "off";
+      const was = before.get(lane.voice);
+      const changed = was !== undefined && was !== now ? ` ← ${was}` : "";
       return {
         label: `${lane.label.padEnd(width)} ${ringText(row)}`,
         detail: row
-          ? `${rowSummary(row)} · ${param.label} ${shown}`
-          : "enter adds E(4,16)",
+          ? `${now}${changed} · ${param.label} ${shown}`
+          : changed
+            ? `off${changed}`
+            : "enter adds E(4,16)",
         value: String(at),
         current: row !== undefined,
       };
@@ -450,7 +486,15 @@ export class EuclidEditor {
     const value = row ? formatValue(param.value(row)) : "—";
     let title = `rhythm › ${context.trackId}${voice ? ` · ${voice}` : ""} · ${param.label} ${value}`;
     if (this.entry !== undefined) title += ` · ${param.label}: ${this.entry}▏`;
-    const hint = this.entry !== undefined ? HINTS.typing : HINTS.euclid;
+    if (audition?.dirty) title = `● ${title}`;
+    if (audition?.status && this.entry === undefined)
+      title += ` · ${audition.status}`;
+    const hint =
+      this.entry !== undefined
+        ? HINTS.typing
+        : audition && (audition.looping || audition.dirty)
+          ? audition.hint
+          : HINTS.euclid;
     return {
       title,
       items: items.length