@hraness/dawg 0.6.1 → 0.8.0

package/src/tui/modal-menu.ts

@@ -1,6 +1,6 @@
 /**
- * Ctrl-k menu rows for modal percussion (0.6): the "Mallets and bells"
- * group under Sound › browse sounds, and the MODAL_PARAMS rows under
+ * Ctrl-k menu rows for modal percussion (0.6): the "mallets"
+ * group under Sound › instruments, and the MODAL_PARAMS rows under
  * Sound › Parameters on a modal track. Every row runs a `modal …` command.
  */
 import type { EnumParam, NumberParam } from "../../core/params.ts";
@@ -18,12 +18,12 @@ import {
 import type { Track } from "../../core/score.ts";
 import { num, specStep, type MenuNode } from "./menu.ts";
 
-/** Sound › browse sounds › Mallets and bells: one row per preset. */
+/** Sound › instruments › mallets: one row per preset. */
 export function malletsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "mallets",
-    label: "Mallets and bells",
+    label: "mallets",
     detail: `${MODAL_PRESET_NAMES.length} modal presets · marimba, vibes, gong …`,
     help: "struck bars, bells and bowls on the modal resonator engine",
     build: () => [
@@ -47,14 +47,14 @@ function presetRow(name: ModalPresetName): MenuNode {
 }
 
 /**
- * Mallets and bells › Gamelan (f061-gamelan-winds): the Javanese and
+ * mallets › gamelan (f061-gamelan-winds): the Javanese and
  * Balinese bronzes. `modal gamelan` points here.
  */
 export function gamelanMenu(): MenuNode {
   return {
     kind: "menu",
     id: "gamelan",
-    label: "Gamelan",
+    label: "gamelan",
     detail: `${GAMELAN_PRESETS.length} bronzes · saron, gangsa (ombak), gong …`,
     help: "Javanese and Balinese gamelan; pair two gangsa tracks with modal pair, tune with tuning slendro or pelog",
     build: () => GAMELAN_PRESETS.map(presetRow),

package/src/tui/performance-menu.ts

@@ -3,6 +3,7 @@
  * runs the same prompt command a user could type (src/commands/expression.ts),
  * so the menu, the prompt and the agent share one grammar.
  */
+import { singVowelNodes } from "./sing-menu.ts";
 import {
   ARTICULATIONS,
   DEFAULT_FIXED_VELOCITY,
@@ -187,7 +188,7 @@ export function performanceNodes(context: MenuContext): MenuNode[] {
             : "pedal",
       help: "bars replaces the lane with a re-pedal on each downbeat; in play mode press Tab (latch) or hold Shift while recording",
     },
-    // keys-electric (0.6.1): the piano's other two pedals, on modelled piano
+    // keys-electric (0.6.1): the piano's other two pedals, on modeled piano
     // tracks (or wherever a lane is already set).
     ...pianoPedalNodes(track),
     {
@@ -233,7 +234,7 @@ export function performanceNodes(context: MenuContext): MenuNode[] {
     },
     {
       kind: "number",
-      label: "humanize velocity (%)",
+      label: "humanize vel (%)",
       value: humanize ? velocity : undefined,
       min: 0,
       max: EXPRESSION_LIMITS.maxHumanizePercent,
@@ -273,5 +274,7 @@ export function performanceNodes(context: MenuContext): MenuNode[] {
       command: "humanize reseed",
       help: "the same amounts with a different seeded performance",
     });
+  // 0.7 sing: Vowels on a sing track.
+  nodes.push(...singVowelNodes(context));
   return nodes;
 }

package/src/tui/play-chords.ts

@@ -605,9 +605,11 @@ export function applyChordsCommand(
       return done(`chords preset ${value}`);
     case "style":
       if (!(PROGRESSION_STYLES as readonly string[]).includes(value ?? ""))
-        return bad(`style takes ${PROGRESSION_STYLES.join("|")}`);
+        return bad(
+          `idiom takes ${PROGRESSION_STYLES.join("|")} · chords idiom jazz`,
+        );
       settings.style = value as ProgressionStyle;
-      return done(`chords style ${value}`);
+      return done(`chords idiom ${value}`);
     default:
       return bad(
         "/chords auto|manual|off · voicing · spread · bass · perform · pattern · strokes · speed · rate · octaves · sevenths · preset · style",

package/src/tui/play-mode.ts

@@ -32,6 +32,7 @@ import {
   type Track,
 } from "../../core/score.ts";
 import type { TuningTable } from "../../core/tuning.ts";
+import { DRUM_VOICES, isDrumInstrument } from "../../core/drums.ts";
 import { pitchName } from "../../tui/highway.ts";
 
 /** Semitone offset from the base C for each note key. */
@@ -112,10 +113,21 @@ export function defaultBaseFor(instrument: string | undefined): number {
  */
 export type PlayLayout = Readonly<{
   base: number;
-  /** Pitch → label (voice names on one-shot samplers). */
+  /** Pitch → label (voice names on one-shot samplers, drums on kits). */
   labels: ReadonlyMap<number, string>;
+  /** A drum kit: keys name drums and the chord row stays hidden. */
+  drums?: boolean | undefined;
 }>;
 
+/**
+ * A kit's keys on the GM map from C2 (36), the same keys the agent's
+ * show-me gestures press: A kick, W rim, S snare, E clap, T hat, H tom,
+ * U open hat. Other keys still sound their nearest drum, unlabeled.
+ */
+export function drumKeyLabels(): ReadonlyMap<number, string> {
+  return new Map(DRUM_VOICES.map((info) => [info.pitch, info.label]));
+}
+
 export function playLayoutFor(track: Track | undefined): PlayLayout {
   const labels = new Map<number, string>();
   if (track && isSamplerInstrument(track.instrument) && track.sampler) {
@@ -130,6 +142,8 @@ export function playLayoutFor(track: Track | undefined): PlayLayout {
     const lowest = roots.length > 0 ? Math.min(...roots) : 60;
     return { base: clampBase(Math.floor(lowest / 12) * 12), labels };
   }
+  if (track && isDrumInstrument(track.instrument))
+    return { base: 36, labels: drumKeyLabels(), drums: true };
   // A plain instrument takes its range from the track's name (`bass`, `lead`).
   const byInstrument = defaultBaseFor(track?.instrument);
   const base =

package/src/tui/play-session.ts

@@ -29,6 +29,7 @@ import {
   type PedalState,
 } from "../../core/expression.ts";
 import type { ClickBus } from "../audio/engine.ts";
+import type { RemoteClick, RemoteNote } from "../session/shared-live.ts";
 import {
   DEFAULT_CLICK_VOLUME,
   countInClicks,
@@ -50,13 +51,16 @@ import {
 import {
   LiveFullRenderer,
   LiveSynth,
+  warmLive,
   MAX_LIVE_NOTE_SECONDS,
   type LiveNotePcm,
 } from "../audio/live.ts";
 import type { SampleBank } from "../audio/samples.ts";
+import { loopedSection } from "../audio/arrange.ts";
 import { fitting, onFitReady } from "../audio/fit.ts";
 import {
   DEFAULT_STRUM,
+  degreeOf,
   perform,
   type PerformMode,
   type PerformOptions,
@@ -73,6 +77,7 @@ import {
 } from "./play-chords.ts";
 import type { PlayHeaderView, PlayStripKey } from "../../tui/play-strip.ts";
 import { resolveTuning, type Tuning } from "../../core/tuning.ts";
+import { singThroat } from "../../core/sing.ts";
 import {
   NOTE_KEYS,
   PlayKeyboard,
@@ -91,6 +96,10 @@ export interface LiveEngine {
   readonly sampleRate: number;
   readonly canMonitor: boolean;
   readonly leadMs: number;
+  /** The lead play mode pins (15 ms on the native sink, else 60 ms). */
+  readonly playLeadMs?: number;
+  /** How play mode sounds (`native sink`, `ffplay · no native sink`). */
+  readonly audioNote?: string;
   monitor(on: boolean): Promise<void>;
   setLeadMs(ms: number | undefined): void;
   noteOn(id: number, note: LiveNotePcm): number;
@@ -98,6 +107,14 @@ export interface LiveEngine {
   /** Frames of voice `id` mixed so far, or undefined once it has ended. */
   voicePosition?(id: number): number | undefined;
   setClick(click: ClickBus | undefined): void;
+  /**
+   * A shared engine (dawgd's, src/session/shared-live.ts) takes note events
+   * instead of PCM: it renders the voice itself, so one engine mixes every
+   * pane. Returns the monotonic ms the note is scheduled for.
+   */
+  remoteNote?(id: number, note: RemoteNote): number;
+  /** A shared engine's click: on/volume and the count-in, not a closure. */
+  remoteClick?(click: RemoteClick): void;
 }
 
 export interface PlayHost {
@@ -124,6 +141,14 @@ export interface PlayHost {
   startTransport(beat: number): Promise<void>;
   stopTransport(): Promise<void>;
   card(text: string, tone: "info" | "success" | "warning" | "error"): void;
+  /**
+   * Another pane recording on `trackId` (§12.4): its name (`pane B`), else
+   * undefined. A replace pass refuses while one is, since it would erase
+   * the other pane's notes.
+   */
+  recordingElsewhere?(trackId: string): string | undefined;
+  /** A played key that is not recorded: the screen glows its lane. */
+  ghost?(pitch: number): void;
   newNoteId(): string;
 }
 
@@ -240,6 +265,8 @@ export class PlaySession {
   private synth: LiveSynth | undefined;
   /** Rig voices awaiting their full render: id → released since. */
   private readonly windows = new Map<number, boolean>();
+  /** f07-sing: the sounding key on a throat track (one drone, mono). */
+  private throatId: number | undefined;
   private readonly fullRenderer = new LiveFullRenderer();
   private readonly pending = new Map<number, Pending>();
   /** Sustain changes while recording (Tab latch or Shift), as pedal events. */
@@ -253,6 +280,10 @@ export class PlaySession {
   /** Live pedal state as the playhead entered each loop bar (replace). */
   private readonly barPedal = new Map<number, PedalState>();
   private lastBar: number | undefined;
+  /** Loop recording: the pass (loop wrap) the playhead is in. */
+  private lastPass: number | undefined;
+  /** Passes committed this take (the header's `pass N`). */
+  private passCount = 0;
   private countIn: CountIn | undefined;
   private flushing: Promise<void> = Promise.resolve();
   /** Most recent key-to-sound schedule, ms (lead before device latency). */
@@ -289,7 +320,8 @@ export class PlaySession {
       settings.mode =
         chordCapable(track) &&
         twelveTet(this.host.score(), track) &&
-        (track?.glide === undefined || track.glide.mode === "poly")
+        (track?.glide === undefined || track.glide.mode === "poly") &&
+        !singThroat(track)
           ? "auto"
           : "manual";
     this.chords = new ChordPad(settings, () => this.host.score().key);
@@ -331,8 +363,12 @@ export class PlaySession {
     this.active = true;
     const engine = this.host.engine();
     if (engine?.canMonitor) {
-      engine.setLeadMs(PLAY_LEAD_MS);
+      engine.setLeadMs(engine.playLeadMs ?? PLAY_LEAD_MS);
+      // The voice's tables and loops are built now, not on the first key.
+      warmLive(this.host.score(), this.trackId, engine.sampleRate);
       await engine.monitor(true);
+      if (engine.audioNote)
+        this.status = `${engine.audioNote} · ${Math.round(engine.leadMs)} ms lead`;
     } else this.status = "no audio · keys still record";
     this.applyClick();
   }
@@ -344,7 +380,8 @@ export class PlaySession {
     this.countIn = undefined;
     const engine = this.host.engine();
     if (engine) {
-      engine.setClick(this.clickOn ? this.clickBus() : undefined);
+      if (engine.remoteClick) this.sendClick(engine.remoteClick.bind(engine));
+      else engine.setClick(this.clickOn ? this.clickBus() : undefined);
       engine.setLeadMs(undefined);
       await engine.monitor(false);
     }
@@ -391,9 +428,34 @@ export class PlaySession {
   private applyClick(): void {
     const engine = this.host.engine();
     if (!engine) return;
+    if (engine.remoteClick) {
+      this.sendClick(engine.remoteClick.bind(engine));
+      return;
+    }
     engine.setClick(this.clickOn || this.countIn ? this.clickBus() : undefined);
   }
 
+  /** The click as a shared engine takes it: on, volume, count-in. */
+  private sendClick(send: (click: RemoteClick) => void): void {
+    const count = this.countIn;
+    send({
+      on: this.clickOn,
+      volume: this.clickVolume,
+      ...(count
+        ? {
+            countIn: {
+              startMs: count.startMs,
+              startBeat: count.startBeat,
+              beats: count.beats,
+              barBeats: count.barBeats,
+              clickBeats: count.clickBeats,
+              bpm: count.bpm,
+            },
+          }
+        : {}),
+    });
+  }
+
   /** `/click on|off|<volume>`. */
   public clickCommand(argument: string): string {
     const parsed = parseClickArgument(argument, {
@@ -421,6 +483,54 @@ export class PlaySession {
     return `grid · ${match.label}`;
   }
 
+  /**
+   * `keys record [replace|off]` and the r / R keys: arm recording, overdub
+   * (additive) or replace (each pass erases the bars it crossed). With a
+   * loop set, every pass over it is one commit, so one undo step (§4.7).
+   * Replace refuses while another pane records this track (§12.4).
+   */
+  public recordCommand(
+    mode: "overdub" | "replace" | "off",
+  ): Readonly<{ ok: boolean; message: string }> {
+    if (mode === "off") {
+      const was = this.armed;
+      this.armed = false;
+      this.replace = false;
+      if (was) void this.stopRecording();
+      this.status = "record off";
+      return { ok: true, message: "record off" };
+    }
+    if (mode === "replace") {
+      const other = this.host.recordingElsewhere?.(this.trackId);
+      if (other) {
+        const message = `${other} is recording ${this.trackName()} · overdub instead (r)`;
+        this.status = `✗ ${message}`;
+        return { ok: false, message };
+      }
+    }
+    this.replace = mode === "replace";
+    this.armed = true;
+    const message = `record ${this.replace ? "replace" : "overdub"} · ${this.trackName()} · ${this.passWord()}`;
+    this.status = this.replace
+      ? "replace · each pass overwrites its bars"
+      : "overdub";
+    return { ok: true, message };
+  }
+
+  private trackName(): string {
+    return this.trackData()?.name ?? this.trackId;
+  }
+
+  /** `loop 5–6 · one undo step a pass`, or `one undo step a bar`. */
+  private passWord(): string {
+    const loop = loopedSection(this.host.score());
+    if (!loop) return "one undo step a bar";
+    const last = loop.startBar + loop.bars;
+    const bars =
+      loop.bars === 1 ? `${loop.startBar + 1}` : `${loop.startBar + 1}–${last}`;
+    return `loop ${bars} · one undo step a pass`;
+  }
+
   /** Handle one decoded key; mode commands return to the caller. */
   public press(value: string): PlayKeyResult {
     const now = this.host.now();
@@ -483,6 +593,8 @@ export class PlaySession {
         return { type: "handled" };
       case "note": {
         this.release(action.released, now);
+        // A key that is not recording glows its lane for a moment.
+        if (!this.recording) this.host.ghost?.(action.note.pitch);
         const chord = this.chords.chordFor(action.note.pitch);
         if (chord) {
           const played = this.chords.voice(chord, action.note.pitch);
@@ -501,6 +613,12 @@ export class PlaySession {
           );
           return { type: "handled" };
         }
+        // f07-sing: a throat track is one drone; a new key releases the last.
+        if (singThroat(this.trackData())) {
+          if (this.throatId !== undefined && this.throatId !== action.note.id)
+            this.release([this.throatId], now);
+          this.throatId = action.note.id;
+        }
         this.sound(action.note.id, action.note);
         this.record(action.note);
         return { type: "handled" };
@@ -545,15 +663,12 @@ export class PlaySession {
 
   private command(command: PlayCommand): PlayKeyResult {
     if (command === "record") {
-      this.armed = !this.armed;
-      if (!this.armed) void this.stopRecording();
-      this.status = this.armed ? "record armed" : "record off";
+      this.recordCommand(this.armed ? "off" : "overdub");
       return { type: "handled" };
     }
     if (command === "replace") {
-      this.replace = !this.replace;
-      this.armed = true;
-      this.status = this.replace ? "replace · bars are overwritten" : "overdub";
+      const result = this.recordCommand(this.replace ? "overdub" : "replace");
+      if (!result.ok) this.host.card(result.message, "error");
       return { type: "handled" };
     }
     if (command === "click") {
@@ -608,6 +723,18 @@ export class PlaySession {
     const seconds = Number.isFinite(note.releaseAtMs)
       ? (note.releaseAtMs - note.atMs) / 1000
       : MAX_LIVE_NOTE_SECONDS;
+    if (engine.remoteNote) {
+      const scheduled = engine.remoteNote(id, {
+        trackId: this.trackId,
+        pitch: note.pitch,
+        velocity: note.velocity / 127,
+        seconds,
+        beat: this.host.beatAt(note.atMs),
+        atMs: note.atMs,
+      });
+      this.lastLatencyMs = Math.max(0, scheduled - this.host.now());
+      return;
+    }
     const samples = this.host.samples?.();
     if (this.synth?.rate !== engine.sampleRate)
       this.synth = new LiveSynth(engine.sampleRate);
@@ -925,25 +1052,50 @@ export class PlaySession {
       if (this.pending.size > 0 || this.replaceBars.size > 0)
         void this.stopRecording();
       this.lastBar = undefined;
+      this.lastPass = undefined;
       return;
     }
     const score = this.host.score();
     const bar = transportBar(score, this.host.beatAt(now));
     if (bar !== this.lastBar)
       this.barPedal.set(this.loopBar(bar), this.pedalDown ? "down" : "up");
+    // With a loop set, a take commits once per pass (each wrap), so one
+    // pass is one undo step; without one, once per bar (§4.7).
+    const loop = loopedSection(score);
+    const pass = loop ? Math.floor(bar / loop.bars) : undefined;
     if (this.lastBar !== undefined && bar !== this.lastBar) {
+      // Every bar the playhead left (a slow frame can skip one).
       if (this.replace)
-        this.replaceBars.add(
-          this.loopBar(
-            Math.floor(
-              this.toScoreBeat(this.lastBar * score.beatsPerBar) /
-                score.beatsPerBar,
+        for (
+          let left = this.lastBar;
+          left < bar && left < this.lastBar + 256;
+          left += 1
+        )
+          this.replaceBars.add(
+            this.loopBar(
+              Math.floor(
+                this.toScoreBeat(left * score.beatsPerBar) / score.beatsPerBar,
+              ),
             ),
-          ),
-        );
-      this.queueFlush(bar, now, false);
+          );
+      if (pass === undefined) this.queueFlush(bar, now, false);
+      else if (this.lastPass !== undefined && pass !== this.lastPass)
+        this.queueFlush(bar, now, false, true);
     }
     this.lastBar = bar;
+    this.lastPass = pass;
+  }
+
+  /** `↻ 5–6 · pass 3` while loop recording; undefined otherwise. */
+  public passLabel(): string | undefined {
+    if (!this.recording) return undefined;
+    const loop = loopedSection(this.host.score());
+    if (!loop) return undefined;
+    const bars =
+      loop.bars === 1
+        ? `${loop.startBar + 1}`
+        : `${loop.startBar + 1}–${loop.startBar + loop.bars}`;
+    return `↻ ${bars} · pass ${this.passCount + 1}`;
   }
 
   private toScoreBeat(beat: number): number {
@@ -962,15 +1114,27 @@ export class PlaySession {
     if (this.pedalDown && this.host.playing())
       this.pendingPedal.push({ beat: this.host.beatAt(now), state: "up" });
     this.pedalDown = false;
-    this.queueFlush(Number.POSITIVE_INFINITY, now, true);
+    this.queueFlush(
+      Number.POSITIVE_INFINITY,
+      now,
+      true,
+      loopedSection(this.host.score()) !== undefined,
+    );
     await this.flushing;
     this.recordedIds.clear();
     this.lastBar = undefined;
+    this.lastPass = undefined;
+    this.passCount = 0;
   }
 
-  private queueFlush(currentBar: number, now: number, all: boolean): void {
+  private queueFlush(
+    currentBar: number,
+    now: number,
+    all: boolean,
+    pass = false,
+  ): void {
     this.flushing = this.flushing
-      .then(() => this.flush(currentBar, now, all))
+      .then(() => this.flush(currentBar, now, all, pass))
       .catch((error: unknown) =>
         this.host.card(
           `record failed · ${error instanceof Error ? error.message : String(error)}`,
@@ -987,6 +1151,7 @@ export class PlaySession {
     currentBar: number,
     now: number,
     all: boolean,
+    pass = false,
   ): Promise<void> {
     const score = this.host.score();
     const ready: Pending[] = [];
@@ -1003,12 +1168,39 @@ export class PlaySession {
     this.pendingPedal = this.pendingPedal.filter(
       (event) => !pedal.includes(event),
     );
-    if (ready.length === 0 && erase.length === 0 && pedal.length === 0) return;
+    if (pass) this.passCount += 1;
+    // §12.4: a replace pass never erases while another pane records this
+    // track; its notes still land, as an overdub.
+    const other =
+      erase.length > 0
+        ? this.host.recordingElsewhere?.(this.trackId)
+        : undefined;
+    if (other) {
+      erase.length = 0;
+      this.host.card(
+        `${other} is recording ${this.trackName()} · pass kept as overdub`,
+        "warning",
+      );
+    }
+    if (ready.length === 0 && erase.length === 0 && pedal.length === 0) {
+      if (pass) this.recordedIds.clear();
+      return;
+    }
     const eraseStates = new Map(
       erase.map((bar) => [bar, this.barPedal.get(bar) ?? "up"] as const),
     );
     try {
-      await this.commitTake(score, ready, erase, eraseStates, pedal, now);
+      await this.commitTake(
+        score,
+        ready,
+        erase,
+        eraseStates,
+        pedal,
+        now,
+        pass ? this.passCount : undefined,
+      );
+      // The next pass may replace this one's notes: forget them.
+      if (pass) this.recordedIds.clear();
     } catch (error) {
       // Nothing was committed: keep the take so the next flush retries it.
       for (const pending of ready) this.pending.set(pending.id, pending);
@@ -1025,6 +1217,7 @@ export class PlaySession {
     eraseStates: ReadonlyMap<number, PedalState>,
     pedal: readonly { beat: number; state: PedalState }[],
     now: number,
+    pass?: number,
   ): Promise<void> {
     const operations = recordOperations(score, {
       trackId: this.trackId,
@@ -1079,12 +1272,17 @@ export class PlaySession {
       trackId: this.trackId,
       operations,
       replace: this.replace,
+      ...(pass !== undefined ? { pass } : {}),
     });
     for (const pending of ready) this.pending.delete(pending.id);
     for (const operation of operations)
       if (operation.type === "addNote") this.recordedIds.add(operation.note.id);
+    const head =
+      pass !== undefined
+        ? `pass ${pass} · +${added} note${added === 1 ? "" : "s"}`
+        : `recorded ${added} note${added === 1 ? "" : "s"}`;
     this.host.card(
-      `recorded ${added} note${added === 1 ? "" : "s"}${pedal.length && !pedalNote ? ` · ${pedal.length} pedal` : ""}${removed ? ` · replaced ${removed}` : ""} · ${this.trackId}${pedalNote}`,
+      `${head}${pedal.length && !pedalNote ? ` · ${pedal.length} pedal` : ""}${removed ? ` · replaced ${removed}` : ""} · ${this.trackId}${pedalNote}`,
       pedalNote ? "warning" : "success",
     );
   }
@@ -1143,20 +1341,25 @@ export class PlaySession {
       };
     }
     return {
-      range: this.keyboard.range,
+      range: this.layout.drums ? "drums" : this.keyboard.range,
       velocity: this.keyboard.velocity,
       armed: this.armed,
       recording: this.recording,
       replace: this.replace,
+      pass: this.passLabel(),
       click: this.clickOn,
       sustain: this.keyboard.sustain,
       countIn,
       beat,
       grid: `grid ${this.grid}`,
-      chords: this.chords.glance(songKey(this.host.score().key).set),
+      // A kit plays drums, not harmony: no chord row and no key chip.
+      chords: this.layout.drums
+        ? undefined
+        : this.chords.glance(songKey(this.host.score().key).set),
       status: this.status,
       keys: this.strip(now),
-      legend: this.chords.on ? this.chords.legend() : undefined,
+      legend:
+        this.chords.on && !this.layout.drums ? this.chords.legend() : undefined,
     };
   }
 
@@ -1178,8 +1381,20 @@ export class PlaySession {
     ).map((cell) => {
       const chord = this.keyboard.pitchFor(cell.key);
       const name =
-        chord === undefined ? undefined : this.chords.keyLabel(chord);
-      return name ? { ...cell, label: name } : this.noteCell(cell);
+        chord === undefined || this.layout.drums
+          ? undefined
+          : this.chords.keyLabel(chord);
+      // Chords in the key are the safe ones to reach for: the strip lights
+      // them; a borrowed chord still plays but stays plain.
+      return name && chord !== undefined
+        ? {
+            ...cell,
+            label: name,
+            chord: true,
+            diatonic:
+              degreeOf(this.chords.key, ((chord % 12) + 12) % 12) !== undefined,
+          }
+        : this.noteCell(cell);
     });
   }