@hraness/dawg 0.7.0 → 0.8.0

package/src/session/shared-live.ts

@@ -0,0 +1,131 @@
+/**
+ * A pane's handle on the machine's one live engine (design §12.3). It looks
+ * like the local `LiveEngine` to play mode, but notes go to dawgd as note
+ * events (`remoteNote`) and the click as a structured request
+ * (`remoteClick`): no audio crosses the socket. dawgd renders each voice
+ * from the score it holds and mixes every pane into one stream and one
+ * click.
+ *
+ * Times cross the seam on the authority's clock: local monotonic ms plus
+ * `performance.timeOrigin` plus the port's clock offset (0 on one machine).
+ */
+import type { ClickBus } from "../audio/engine.ts";
+import type { LiveNotePcm } from "../audio/live.ts";
+import type { LiveClick, LiveMessage, LiveStatus } from "./protocol.ts";
+
+/** What the shared engine needs from the session connection. */
+export interface LiveLink {
+  liveMonitor(on: boolean): Promise<LiveStatus>;
+  live(message: Exclude<LiveMessage, { action: "monitor" }>): void;
+  /** Authority clock minus this machine's, in ms. */
+  readonly clockOffsetMs: number;
+}
+
+/** A played note as play mode hands it to a shared engine. */
+export type RemoteNote = Readonly<{
+  trackId: string;
+  pitch: number;
+  /** 0..1. */
+  velocity: number;
+  seconds: number;
+  /** Transport beat of the press (unwrapped). */
+  beat: number;
+  /** Monotonic ms of the press. */
+  atMs: number;
+}>;
+
+/** A structured click request (a shared engine cannot take closures). */
+export type RemoteClick = Readonly<{
+  on: boolean;
+  volume: number;
+  countIn?: Readonly<{
+    /** Monotonic ms the count-in starts. */
+    startMs: number;
+    startBeat: number;
+    beats: number;
+    barBeats: number;
+    clickBeats: number;
+    bpm: number;
+  }>;
+}>;
+
+export class SharedLiveEngine {
+  public sampleRate = 48_000;
+  public canMonitor = true;
+  public leadMs = 15;
+  public playLeadMs: number | undefined;
+  public audioNote: string | undefined = "shared engine";
+  /** Notes sent (tests and the status line read it). */
+  public sent = 0;
+
+  public constructor(private readonly link: LiveLink) {}
+
+  public async monitor(on: boolean): Promise<void> {
+    try {
+      const status = await this.link.liveMonitor(on);
+      this.sampleRate = status.sampleRate;
+      this.canMonitor = status.canMonitor;
+      this.leadMs = status.leadMs;
+      this.playLeadMs = status.leadMs;
+      this.audioNote = status.note ?? "shared engine";
+    } catch {
+      // dawgd is reconnecting; the link resends monitor once it is back.
+    }
+  }
+
+  /** The lead is dawgd's: a pane never retimes the shared engine. */
+  public setLeadMs(_ms: number | undefined): void {}
+
+  /** Local PCM never reaches a shared engine; play mode uses `remoteNote`. */
+  public noteOn(_id: number, _note: LiveNotePcm): number {
+    return performance.now() + this.leadMs;
+  }
+
+  public remoteNote(id: number, note: RemoteNote): number {
+    this.sent += 1;
+    this.link.live({
+      v: 1,
+      type: "live",
+      action: "on",
+      voice: id,
+      trackId: note.trackId,
+      pitch: note.pitch,
+      velocity: Math.max(0, Math.min(1, note.velocity)),
+      seconds: Math.max(0, Math.min(600, note.seconds)),
+      beat: note.beat,
+      atMs: this.authority(note.atMs),
+    });
+    return performance.now() + this.leadMs;
+  }
+
+  public noteOff(id: number): void {
+    this.link.live({
+      v: 1,
+      type: "live",
+      action: "off",
+      voice: id,
+      atMs: this.authority(performance.now()),
+    });
+  }
+
+  /** A pane cannot hand dawgd a click closure; see `remoteClick`. */
+  public setClick(click: ClickBus | undefined): void {
+    if (!click) this.remoteClick({ on: false, volume: 0 });
+  }
+
+  public remoteClick(click: RemoteClick): void {
+    const message: LiveClick = {
+      on: click.on,
+      volume: Math.max(0, Math.min(1, click.volume)),
+    };
+    if (click.countIn) {
+      const { startMs, ...rest } = click.countIn;
+      message.countIn = { ...rest, startAtMs: this.authority(startMs) };
+    }
+    this.link.live({ v: 1, type: "live", action: "click", ...message });
+  }
+
+  private authority(monotonicMs: number): number {
+    return performance.timeOrigin + monotonicMs + this.link.clockOffsetMs;
+  }
+}

package/src/session/store.ts

@@ -39,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
@@ -204,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`);
@@ -231,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;
@@ -523,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)
@@ -548,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;
@@ -601,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,6 +7,7 @@
 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";
 
@@ -21,6 +22,151 @@ export function arrangeDetail(context: MenuContext): string {
   return parts.join(" · ");
 }
 
+/** `loop 5–6 · 16 bars`, or the song length alone. */
+export function rangeDetail(context: MenuContext): string {
+  const score = context.score;
+  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: "copy bars",
+      value: "",
+      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 bars = barsText(text);
+        return bars ? `clear ${track} ${bars}` : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "reverse bars",
+      value: "",
+      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.
@@ -54,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",
       });
@@ -66,6 +212,28 @@ 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",

package/src/tui/euclid.ts

@@ -9,7 +9,8 @@
  * runs through the normal prompt path, so every change is one revision and
  * one undo step and the row's detail teaches the command.
  *
- * Keys: ↑↓ voice · ←→ (h l + -) nudge · tab / shift-tab (] [) parameter ·
+ * Keys: ↑↓ knob (● drum ▲ pulses ■ rotate ◆ velocity) · ←→ (h l + -) turn ·
+ * tab / shift-tab (] [) every parameter ·
  * digits type a value · enter add/edit · space loop · x off · f freeze ·
  * esc back.
  *
@@ -48,6 +49,8 @@ import {
 import type { PickerItem } from "../../tui/app.ts";
 import { auditionKey, type AuditionKey } from "./audition.ts";
 import type { MenuAudition } from "./menu.ts";
+import { KNOB_MAPS } from "./knob-map.ts";
+import { knobGlyph, KNOBS, nextKnob, type KnobIndex } from "../../tui/knobs.ts";
 
 export type EuclidContext = Readonly<{
   /** The score shown: the staged one while auditioning. */
@@ -295,6 +298,28 @@ export function ringText(row: RhythmRow | undefined): string {
     .join("");
 }
 
+/**
+ * The four knobs (KNOB_MAPS.euclid): blue `drum` picks the row, the others
+ * name EUCLID_PARAMS fields.
+ */
+const EUCLID_KNOBS = KNOB_MAPS.euclid!;
+
+/** After the strip, the knob keys, then the way out; fitHint drops the knob keys first. */
+const KNOB_KEYS = "↑↓ knob · ←→ turn · esc back · ? keys";
+
+/** The knob that turns `param`, if one does. */
+function knobOfParam(param: number): KnobIndex | undefined {
+  const at = EUCLID_KNOBS.indexOf(EUCLID_PARAMS[param]!.field);
+  return at < 0 ? undefined : (at as KnobIndex);
+}
+
+/** EUCLID_PARAMS index a knob turns; undefined for the drum knob. */
+function paramOfKnob(knob: KnobIndex): number | undefined {
+  const field = EUCLID_KNOBS[knob];
+  const at = EUCLID_PARAMS.findIndex((param) => param.field === field);
+  return at < 0 ? undefined : at;
+}
+
 /** 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 === "[";
@@ -303,6 +328,8 @@ export class EuclidEditor {
   private visible = false;
   private lane = 0;
   private param = 0;
+  /** True while the blue knob (which drum) has focus, not a field. */
+  private onDrum = true;
   private entry: string | undefined;
   /** Where Esc returns to (`menu` when opened from `/menu`). */
   private origin: string | undefined;
@@ -327,6 +354,10 @@ export class EuclidEditor {
     this.origin = origin;
     const lanes = this.lanes(context);
     const at = voice ? lanes.findIndex((lane) => lane.voice === voice) : -1;
+    // Opened on a named drum, the green knob (pulses) has focus; otherwise
+    // the blue one, to pick the drum.
+    this.onDrum = at < 0;
+    if (!this.onDrum) this.param = paramOfKnob(1) ?? 0;
     if (at >= 0) this.lane = at;
     else {
       // Land on the first voice that already has a row.
@@ -352,9 +383,14 @@ export class EuclidEditor {
     return lanes[Math.min(this.lane, lanes.length - 1)]?.voice;
   }
 
-  /** Parameter under the cursor. */
+  /** Parameter under the cursor (`drum` on the blue knob). */
   get selectedParam(): string {
-    return EUCLID_PARAMS[this.param]!.field;
+    return this.onDrum ? "drum" : EUCLID_PARAMS[this.param]!.field;
+  }
+
+  /** The knob with focus; undefined on a field no knob turns. */
+  get selectedKnob(): KnobIndex | undefined {
+    return this.onDrum ? 0 : knobOfParam(this.param);
   }
 
   key(value: string, context: EuclidContext): EuclidResult {
@@ -376,7 +412,8 @@ export class EuclidEditor {
       if (KEY_ENTER.has(value)) {
         const text = this.entry.trim();
         this.entry = undefined;
-        if (!lane || !/^-?[0-9./tT]+$/.test(text)) return { type: "handled" };
+        if (this.onDrum || !lane || !/^-?[0-9./tT]+$/.test(text))
+          return { type: "handled" };
         return {
           type: "run",
           command: `euclid ${lane.voice} ${param.field} ${text}`,
@@ -392,21 +429,45 @@ export class EuclidEditor {
       return audition?.dirty ? { type: "revert" } : { type: "close" };
     const loopKey = audition ? auditionKey(value) : undefined;
     if (loopKey) return { type: "loop", key: loopKey };
+    // ↑↓ pick a knob (design §8.7); from a field no knob turns, ↑ lands
+    // on orange and ↓ on blue.
     if (KEY_UP.has(value) || KEY_DOWN.has(value)) {
-      if (lanes.length)
-        this.lane =
-          (this.lane + (KEY_UP.has(value) ? -1 : 1) + lanes.length) %
-          lanes.length;
+      const up = KEY_UP.has(value);
+      const from = this.selectedKnob;
+      const knob =
+        from === undefined
+          ? up
+            ? 3
+            : 0
+          : nextKnob(from, up ? -1 : 1, (index) =>
+              index === 0 ? true : paramOfKnob(index) !== undefined,
+            );
+      this.onDrum = knob === 0;
+      if (!this.onDrum) this.param = paramOfKnob(knob) ?? this.param;
       return { type: "handled" };
     }
+    // Tab walks every field (the full list behind the knobs).
     if (isNextField(value) || isPrevField(value)) {
       const direction = isNextField(value) ? 1 : -1;
-      this.param =
-        (this.param + direction + EUCLID_PARAMS.length) % EUCLID_PARAMS.length;
+      if (this.onDrum) {
+        this.onDrum = false;
+        this.param = direction > 0 ? 0 : EUCLID_PARAMS.length - 1;
+      } else
+        this.param =
+          (this.param + direction + EUCLID_PARAMS.length) %
+          EUCLID_PARAMS.length;
       return { type: "handled" };
     }
     if (!lane) return { type: "handled" };
     if (value === " ") return { type: "audition", voice: lane.voice };
+    if (this.onDrum && (KEY_LEFT.has(value) || KEY_RIGHT.has(value))) {
+      // The blue knob turns which drum row has focus.
+      if (lanes.length)
+        this.lane =
+          (this.lane + (KEY_RIGHT.has(value) ? 1 : -1) + lanes.length) %
+          lanes.length;
+      return { type: "handled" };
+    }
     if (KEY_LEFT.has(value) || KEY_RIGHT.has(value)) {
       const direction = KEY_RIGHT.has(value) ? 1 : -1;
       const row: RhythmRow = lane.row ?? { voice: lane.voice };
@@ -427,7 +488,7 @@ export class EuclidEditor {
         audition: lane.voice,
       };
     }
-    if (/^[0-9]$/.test(value)) {
+    if (/^[0-9]$/.test(value) && !this.onDrum) {
       this.entry = value;
       return { type: "handled" };
     }
@@ -439,7 +500,7 @@ export class EuclidEditor {
           command: `euclid ${lane.voice} ${RHYTHM_DEFAULTS.pulses} ${RHYTHM_DEFAULTS.steps}`,
           audition: lane.voice,
         };
-      this.entry = "";
+      if (!this.onDrum) this.entry = "";
       return { type: "handled" };
     }
     if (KEY_RESET.has(value))
@@ -454,6 +515,23 @@ export class EuclidEditor {
     return { type: "handled" };
   }
 
+  /**
+   * The knob strip for the hint row: `●›kick ▲ pulses 4 ■ rotate 0 ◆ velocity
+   * 0.8`, the focused knob marked `›`. Glyphs carry which knob is which.
+   */
+  private strip(drum: string | undefined, row: RhythmRow | undefined): string {
+    const focused = this.selectedKnob;
+    return KNOBS.map((knob) => {
+      const mark = knob.index === focused ? "›" : " ";
+      if (knob.index === 0) return `${knob.glyph}${mark}${drum ?? "·"}`;
+      const at = paramOfKnob(knob.index);
+      if (at === undefined) return `${knob.glyph} ·`;
+      const param = EUCLID_PARAMS[at]!;
+      const shown = row ? formatValue(param.value(row)) : "—";
+      return `${knob.glyph}${mark}${param.label} ${shown}`;
+    }).join(" ");
+  }
+
   view(context: EuclidContext): EuclidView {
     const lanes = this.lanes(context);
     const index = Math.max(0, Math.min(this.lane, lanes.length - 1));
@@ -489,7 +567,10 @@ export class EuclidEditor {
     const voice = lanes[index]?.voice ?? "";
     const row = lanes[index]?.row;
     const value = row ? formatValue(param.value(row)) : "—";
-    let title = `rhythm › ${context.trackId}${voice ? ` · ${voice}` : ""} · ${param.label} ${value}`;
+    const focus = this.onDrum
+      ? `${knobGlyph(0, true)} drum`
+      : `${param.label} ${value}`;
+    let title = `rhythm › ${context.trackId}${voice ? ` · ${voice}` : ""} · ${focus}`;
     if (this.entry !== undefined) title += ` · ${param.label}: ${this.entry}▏`;
     if (audition?.dirty) title = `● ${title}`;
     if (audition?.status && this.entry === undefined)
@@ -499,7 +580,7 @@ export class EuclidEditor {
         ? HINTS.typing
         : audition && (audition.looping || audition.dirty)
           ? audition.hint
-          : HINTS.euclid;
+          : `${this.strip(lanes[index]?.label.trim(), row)} · ${KNOB_KEYS}`;
     return {
       title,
       items: items.length