@hraness/dawg 0.6.0 → 0.7.0

package/src/tui/modal-menu.ts

@@ -1,10 +1,11 @@
 /**
- * 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";
 import {
+  GAMELAN_PRESETS,
   MODAL_INSTRUMENT,
   MODAL_MALLET_NAMES,
   MODAL_PARAMS,
@@ -12,25 +13,51 @@ import {
   MODAL_PRESET_NAMES,
   MODAL_SIMPLE,
   modalSettings,
+  type ModalPresetName,
 } from "../../core/resonators.ts";
 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: () =>
-      MODAL_PRESET_NAMES.map((name): MenuNode => ({
-        kind: "action",
-        label: `${name}  ${MODAL_PRESETS[name].doc}`,
-        command: `modal ${name}`,
-        help: MODAL_PRESETS[name].styles,
-      })),
+    build: () => [
+      // The core presets keep their rows (gong too); the gamelan bronzes
+      // added in 0.6.1 sit in their own sub-group.
+      ...MODAL_PRESET_NAMES.filter(
+        (name) => name === "gong" || !GAMELAN_PRESETS.includes(name),
+      ).map(presetRow),
+      gamelanMenu(),
+    ],
+  };
+}
+
+function presetRow(name: ModalPresetName): MenuNode {
+  return {
+    kind: "action",
+    label: `${name}  ${MODAL_PRESETS[name].doc}`,
+    command: `modal ${name}`,
+    help: MODAL_PRESETS[name].styles,
+  };
+}
+
+/**
+ * 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",
+    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,
@@ -12,6 +13,7 @@ import {
   VELOCITY_CURVES,
 } from "../../core/expression.ts";
 import type { Note, Track } from "../../core/score.ts";
+import { isPianoFamily } from "../../core/keys.ts";
 import {
   BEND_SHAPES,
   DEFAULT_HUMANIZE,
@@ -50,12 +52,50 @@ export function performanceDetail(track: Track | undefined): string {
   const parts = [
     track.glide ? `glide ${track.glide.mode}` : "",
     track.pedal?.length ? "pedal" : "",
+    track.softPedal?.length ? "soft" : "",
+    track.sostenuto?.length ? "sost" : "",
     track.velocityCurve ? `vel ${track.velocityCurve.curve}` : "",
     track.humanize ? "humanized" : "",
   ].filter(Boolean);
   return parts.length ? parts.join(" · ") : "as written";
 }
 
+/** Soft pedal and Sostenuto rows: off, the current lane, or the whole loop. */
+function pianoPedalNodes(track: Track): MenuNode[] {
+  const rows = [
+    {
+      lane: "soft",
+      label: "soft pedal",
+      events: track.softPedal,
+      help: "una corda: the hammers shift to strike fewer strings, softer and darker; read at each note's onset",
+    },
+    {
+      lane: "sost",
+      label: "sostenuto",
+      events: track.sostenuto,
+      help: "holds only the keys already down when it presses (the middle pedal); later notes damp normally",
+    },
+  ] as const;
+  return rows
+    .filter((row) => isPianoFamily(track.instrument) || row.events?.length)
+    .map((row): MenuNode => {
+      const value = row.events?.length ? `${row.events.length} events` : "off";
+      return {
+        kind: "choice",
+        label: row.label,
+        value,
+        options: ["off", ...(value === "off" ? [] : [value]), "bars"],
+        command: (option) =>
+          option === "bars"
+            ? `pedal ${row.lane} bars`
+            : option === "off"
+              ? `pedal ${row.lane} off`
+              : `pedal ${row.lane}`,
+        help: row.help,
+      };
+    });
+}
+
 export function performanceNodes(context: MenuContext): MenuNode[] {
   const track = context.score.tracks.find(
     (item) => item.id === context.trackId,
@@ -148,6 +188,9 @@ 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 modeled piano
+    // tracks (or wherever a lane is already set).
+    ...pianoPedalNodes(track),
     {
       kind: "choice",
       label: "velocity curve",
@@ -191,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,
@@ -231,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

@@ -35,6 +35,10 @@ import {
   EXTENSIONS,
   MAX_VOICING_STEP,
   PERFORM_MODES,
+  DEFAULT_STROKE_SPEED,
+  STROKE_PATTERN_NAMES,
+  strokeGrid,
+  type PerformOptions,
   PROGRESSION_PRESETS,
   PROGRESSION_STYLES,
   SPREADS,
@@ -100,6 +104,10 @@ export type ChordSettings = {
   /** `none` or a PROGRESSION_PRESETS name; drives the "next" suggestion. */
   preset: string;
   style: ProgressionStyle;
+  /** Guitar perform mode: a STROKE_PATTERNS name or a D U d u x - . grid. */
+  strokes: string;
+  /** Guitar perform mode: ms a full six-string down stroke takes. */
+  speed: number;
 };
 
 export function defaultChordSettings(): ChordSettings {
@@ -116,9 +124,45 @@ export function defaultChordSettings(): ChordSettings {
     sevenths: false,
     preset: "none",
     style: "pop",
+    strokes: "down",
+    speed: DEFAULT_STROKE_SPEED * 1000,
   };
 }
 
+/** Play mode's `[` / `]` strum speed step in ms. */
+export const STROKE_SPEED_STEP = 5;
+
+/** Strum speed bounds in ms (0 = every string at once). */
+export const STROKE_SPEED_MS = Object.freeze({ min: 0, max: 200 });
+
+/**
+ * A strum speed from `/chords speed` text: milliseconds (`22`, `22ms`) or
+ * beats (`1/32b`, `0.05b`) at `bpm`. Undefined when not a speed.
+ */
+export function parseStrokeSpeed(
+  text: string | undefined,
+  bpm: number,
+): number | undefined {
+  const raw = (text ?? "").trim().toLowerCase();
+  const beats = /^(\d+(?:\.\d+)?)(?:\/(\d+))?\s*(?:b|beats?)$/.exec(raw);
+  let ms: number;
+  if (beats) {
+    const value = Number(beats[1]) / (beats[2] ? Number(beats[2]) : 1);
+    ms = (value * 60_000) / bpm;
+  } else {
+    const plain = /^(\d+(?:\.\d+)?)\s*(?:ms)?$/.exec(raw);
+    if (!plain) return undefined;
+    ms = Number(plain[1]);
+  }
+  if (
+    !Number.isFinite(ms) ||
+    ms < STROKE_SPEED_MS.min ||
+    ms > STROKE_SPEED_MS.max
+  )
+    return undefined;
+  return Math.round(ms * 10) / 10;
+}
+
 /**
  * Tracks where auto chords are the default: anything pitched that is not a
  * bass, a drum kit or a one-shot sampler.
@@ -236,6 +280,16 @@ export class ChordPad {
       s.perform = PERFORM_MODES[(index + 1) % PERFORM_MODES.length]!;
       return { type: "status", status: `perform ${s.perform}` };
     }
+    if ((value === "[" || value === "]") && s.perform === "guitar") {
+      // Strum speed: slower ([) or faster (]) in 5 ms steps.
+      const wanted =
+        s.speed + (value === "[" ? STROKE_SPEED_STEP : -STROKE_SPEED_STEP);
+      s.speed = Math.max(
+        STROKE_SPEED_MS.min,
+        Math.min(STROKE_SPEED_MS.max, Math.round(wanted)),
+      );
+      return { type: "status", status: `strum speed ${s.speed}ms` };
+    }
     if (value === "b") {
       const index = BASS_MODES.indexOf(s.bass);
       s.bass = BASS_MODES[(index + 1) % BASS_MODES.length]!;
@@ -392,6 +446,9 @@ export class ChordPad {
       { key: "0", label: "clear", on: false },
       { key: "-=", label: `voicing ${signed(s.inversion)}`, on: false },
       { key: "9", label: perform, on: false },
+      ...(s.perform === "guitar"
+        ? [{ key: "[]", label: `speed ${s.speed}ms`, on: false }]
+        : []),
       { key: "b", label: `bass ${s.bass}`, on: false },
       { key: "n", label: "next", on: false },
       { key: "q", label: s.mode === "auto" ? "auto" : "manual", on: false },
@@ -412,6 +469,8 @@ export class ChordPad {
     if (s.spread !== "close") parts.push(s.spread);
     if (s.perform === "pattern")
       parts.push(`pattern ${patternLabel(s.pattern)}`);
+    else if (s.perform === "guitar")
+      parts.push(`guitar ${s.strokes} ${s.speed}ms`);
     else if (s.perform !== "block") parts.push(s.perform);
     if (s.bass !== "off") parts.push(`bass ${s.bass}`);
     return parts.join(" · ");
@@ -435,15 +494,18 @@ function signed(value: number): string {
 /**
  * `/chords …`: `auto|manual|off`, `voicing <-12..12>`, `spread <close|open|
  * wide>`, `bass off|chords|unison|single|solo` (`on` = chords), `perform
- * <mode>`, `pattern <1..13|name>`, `rate <grid|1/8…>`, `octaves
+ * <mode>`, `pattern <1..13|name>`, `strokes <name|D-DU-UDU>` (guitar
+ * mode), `speed <ms|1/32b>`, `rate <grid|1/8…>`, `octaves
  * <1..4>`, `sevenths on|off`, `preset <name|none>`, `style <pop|jazz|…>`.
  * Mutates `settings`; returns the receipt or an error.
  */
 export function applyChordsCommand(
   settings: ChordSettings,
   argument: string,
+  bpm = 120,
 ): { ok: boolean; message: string } {
-  const words = argument.trim().toLowerCase().split(/\s+/).filter(Boolean);
+  const raw = argument.trim().split(/\s+/).filter(Boolean);
+  const words = raw.map((word) => word.toLowerCase());
   const [head, value] = words;
   const done = (message: string) => ({ ok: true, message });
   const bad = (message: string) => ({ ok: false, message });
@@ -505,6 +567,28 @@ export function applyChordsCommand(
         return bad(`rate takes ${ARP_RATES.join("|")}`);
       settings.rate = value as ArpRate;
       return done(`chords rate ${value}`);
+    case "strokes": {
+      // Case matters: D is a full down stroke, d a light one.
+      const grid = raw.slice(1).join("");
+      if (!strokeGrid(grid))
+        return bad(
+          `strokes takes ${STROKE_PATTERN_NAMES.join("|")} or a grid of D U d u x - .`,
+        );
+      settings.strokes = (STROKE_PATTERN_NAMES as readonly string[]).includes(
+        grid.toLowerCase(),
+      )
+        ? grid.toLowerCase()
+        : grid;
+      settings.perform = "guitar";
+      return done(`chords strokes ${settings.strokes}`);
+    }
+    case "speed": {
+      const ms = parseStrokeSpeed(words.slice(1).join(""), bpm);
+      if (ms === undefined)
+        return bad("speed takes 0..200 ms (22, 22ms) or beats (1/32b)");
+      settings.speed = ms;
+      return done(`chords speed ${ms}ms`);
+    }
     case "octaves": {
       const n = Number(value);
       if (!Number.isInteger(n) || n < 1 || n > 4)
@@ -521,12 +605,14 @@ 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 · rate · octaves · sevenths · preset · style",
+        "/chords auto|manual|off · voicing · spread · bass · perform · pattern · strokes · speed · rate · octaves · sevenths · preset · style",
       );
   }
 }
@@ -539,6 +625,8 @@ export function chordsSummary(settings: ChordSettings): string {
     s.spread,
     s.perform,
     `pattern ${patternLabel(s.pattern)}`,
+    `strokes ${s.strokes}`,
+    `speed ${s.speed}ms`,
     `rate ${s.rate}`,
     `octaves ${s.octaves}`,
     `bass ${s.bass}`,
@@ -603,6 +691,7 @@ export function chordPhrase(
       seed: 1,
       velocity: 0.8,
       ...(mode === "pattern" ? { pattern: settings.pattern } : {}),
+      ...(mode === "guitar" ? guitarPerform(settings, score, track) : {}),
     },
   });
   // With chords off a key plays one note: the root, in the chord's octave.
@@ -630,3 +719,17 @@ export function chordPhrase(
   }
   return notes;
 }
+
+/** Perform options for the guitar mode: strokes, speed, tempo and fretting. */
+export function guitarPerform(
+  settings: Pick<ChordSettings, "strokes" | "speed">,
+  score: Pick<TrackScore, "tempoBpm">,
+  track: Pick<Track, "guitar"> | undefined,
+): Partial<PerformOptions> {
+  return {
+    strokes: settings.strokes,
+    speed: settings.speed / 1000,
+    tempo: score.tempoBpm,
+    ...(track?.guitar ? { guitar: track.guitar } : {}),
+  };
+}

package/src/tui/play-mode.ts

@@ -12,6 +12,7 @@
  *   Shift  sustain while held    Tab    sustain latch     Esc  leave the mode
  *   (while recording, sustain changes record as track pedal events)
  *   I      scale degrees: the home row plays the key's scale (any tuning)
+ *   [ / ]  strum slower / faster (chords perform guitar, 5 ms steps)
  *
  * Terminals report key-down only, so a held key is synthesized from the
  * keyboard's auto-repeat: a press sounds for the gate (one grid step by
@@ -31,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. */
@@ -111,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) {
@@ -129,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

@@ -50,6 +50,7 @@ import {
 import {
   LiveFullRenderer,
   LiveSynth,
+  warmLive,
   MAX_LIVE_NOTE_SECONDS,
   type LiveNotePcm,
 } from "../audio/live.ts";
@@ -57,20 +58,24 @@ import type { SampleBank } from "../audio/samples.ts";
 import { fitting, onFitReady } from "../audio/fit.ts";
 import {
   DEFAULT_STRUM,
+  degreeOf,
   perform,
   type PerformMode,
+  type PerformOptions,
   type PerformedNote,
 } from "../../core/chords.ts";
 import {
   ChordPad,
   chordCapable,
   defaultChordSettings,
+  guitarPerform,
   songKey,
   type ChordSettings,
   type PlayedChord,
 } 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,
@@ -89,6 +94,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;
@@ -122,6 +131,8 @@ export interface PlayHost {
   startTransport(beat: number): Promise<void>;
   stopTransport(): Promise<void>;
   card(text: string, tone: "info" | "success" | "warning" | "error"): void;
+  /** A played key that is not recorded: the screen glows its lane. */
+  ghost?(pitch: number): void;
   newNoteId(): string;
 }
 
@@ -181,6 +192,8 @@ export type RecordedChord = Readonly<{
   seed: number;
   /** CHORD_PATTERNS name when `mode` is `pattern`. */
   pattern?: string;
+  /** Guitar mode: strokes, speed, tempo, fretting and the chord root. */
+  guitar?: Partial<PerformOptions>;
 }>;
 
 /** A chord sounding live: its voices start and stop from `tick()`. */
@@ -236,6 +249,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. */
@@ -285,7 +300,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);
@@ -327,8 +343,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();
   }
@@ -479,6 +499,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);
@@ -497,6 +519,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" };
@@ -643,16 +671,21 @@ export class PlaySession {
     // The full pass runs on a worker, in key order, so a strummed chord or a
     // fast run never stalls key handling behind an oversampled render.
     if (pcm.partial)
-      void this.fullRenderer.full(synth, request).then((full) => {
-        // Not after note-off: a swap would cancel the release fade.
-        if (
-          full &&
-          this.windows.get(id) === false &&
-          engine.voicePosition?.(id) !== undefined
+      void this.fullRenderer
+        .full(
+          synth,
+          pcm.clock === undefined ? request : { ...request, clock: pcm.clock },
         )
-          engine.noteOn(id, full);
-        this.windows.delete(id);
-      });
+        .then((full) => {
+          // Not after note-off: a swap would cancel the release fade.
+          if (
+            full &&
+            this.windows.get(id) === false &&
+            engine.voicePosition?.(id) !== undefined
+          )
+            engine.noteOn(id, full);
+          this.windows.delete(id);
+        });
   }
 
   private release(ids: readonly number[], atMs: number): void {
@@ -729,6 +762,20 @@ export class PlaySession {
       octaves: settings.octaves,
       seed,
       ...(mode === "pattern" ? { pattern: settings.pattern } : {}),
+      ...(mode === "guitar" ? { guitar: this.guitarOptions(played) } : {}),
+    };
+  }
+
+  /** Guitar-mode perform options for a played chord (strokes, speed, frets). */
+  private guitarOptions(played: PlayedChord): Partial<PerformOptions> {
+    return {
+      ...guitarPerform(
+        this.chords.settings,
+        { tempoBpm: this.currentBpm() },
+        this.trackData(),
+      ),
+      root: played.chord.root,
+      ...(played.chord.bass !== undefined ? { slash: played.chord.bass } : {}),
     };
   }
 
@@ -749,6 +796,7 @@ export class PlaySession {
       seed: note.id,
       pattern: settings.pattern,
       velocity: 1,
+      ...(mode === "guitar" ? this.guitarOptions(played) : {}),
     });
     if (played.bass !== undefined)
       plan.push({
@@ -1119,7 +1167,7 @@ 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,
@@ -1129,10 +1177,14 @@ export class PlaySession {
       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,
     };
   }
 
@@ -1154,8 +1206,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);
     });
   }
 
@@ -1213,6 +1277,7 @@ export function chordNotes(
     seed: chord.seed,
     ...(chord.pattern !== undefined ? { pattern: chord.pattern } : {}),
     velocity: 1,
+    ...chord.guitar,
   }).map((note) => ({
     pitch: note.pitch,
     velocity: scaleVelocity(press.velocity, note.velocity),