@hraness/dawg 0.7.0 → 0.8.0

package/src/tui/menu.ts

@@ -41,6 +41,8 @@ import { malletsMenu, modalParameterNodes } from "./modal-menu.ts";
 import { windParameterNodes, windsMenu } from "./wind-menu.ts";
 import { singParameterNodes } from "./sing-menu.ts";
 import type { FaderSpec } from "./fader.ts";
+import { knobFields, type KnobField } from "./knob-fields.ts";
+import { soundFamily } from "./knob-map.ts";
 import {
   openingMeterCommand,
   openingUnit,
@@ -209,6 +211,8 @@ export type MenuContext = Readonly<{
   countInBars: number;
   /** How much agent turns show (`/showme`); absent hides the row. */
   showMe?: string;
+  /** Project › audio: the chosen devices and the lists to pick from. */
+  audio?: MenuAudioDevices;
   /** The session's name, for Project › session and export file names. */
   sessionName?: string;
   /** Play mode's chord settings (defaults when absent). */
@@ -223,6 +227,18 @@ export type MenuContext = Readonly<{
   audition?: MenuAudition;
 }>;
 
+/** One output and one input (src/audio/devices.ts); no routing. */
+export type MenuAudioDevices = Readonly<{
+  /** `Speakers` or `default (Speakers)`. */
+  output: string;
+  input: string;
+  /** Output names; empty when the backend cannot list them. */
+  outputs: readonly string[];
+  inputs: readonly string[];
+  /** Why device choice is unavailable (fallback backends). */
+  unavailable?: string;
+}>;
+
 /** What the menu needs from the audition controller. */
 export type MenuAudition = Readonly<{
   looping: boolean;
@@ -602,6 +618,8 @@ export const SECTION_ALIASES: Readonly<Record<string, readonly string[]>> =
       help: ["project", "help"],
       guides: ["project", "help"],
       model: ["project", "agent"],
+      audio: ["project", "audio"],
+      devices: ["project", "audio"],
       showme: ["project", "agent"],
       models: ["project", "agent"],
       fx: ["effects"],
@@ -1072,6 +1090,14 @@ function mixSectionNodes(context: MenuContext): MenuNode[] {
   ).join(" ");
   return [
     ...trackNodes(context),
+    {
+      kind: "menu",
+      id: "mixer",
+      label: "mixer",
+      detail: `${context.score.tracks.length} levels on one page`,
+      help: "every track's level as a fader, the drawer's all-tracks page (mix) · tab flips to this track",
+      build: mixerNodes,
+    },
     {
       kind: "menu",
       id: "tracks",
@@ -1492,6 +1518,24 @@ function trackNodes(context: MenuContext): MenuNode[] {
   ];
 }
 
+/**
+ * Mix › mixer: one level fader per track (design §8.5), each a typed
+ * `volume <track> <0..1>`, so the page sets any track without moving the
+ * focus. Labels are numbered, so two tracks with one name stay apart.
+ */
+export function mixerNodes(context: MenuContext): MenuNode[] {
+  return context.score.tracks.map((track, index): MenuNode => {
+    const base = volumeNode(track);
+    return {
+      ...(base as Extract<MenuNode, { kind: "number" }>),
+      label: `${index + 1}${track.id === context.trackId ? "›" : " "}${track.name}`,
+      command: (value: number) => `volume ${track.id} ${num(value)}`,
+      reset: `volume ${track.id} 1`,
+      help: `${track.name}'s level; 1 is unity (0 dB) · x resets`,
+    };
+  });
+}
+
 function instrumentNode(track: Track): MenuNode {
   const options: string[] = [...AVAILABLE_INSTRUMENTS, ...KEYS_FAMILIES];
   if (!options.includes(track.instrument)) options.push(track.instrument);
@@ -3113,6 +3157,16 @@ function transportNodes(context: MenuContext): MenuNode[] {
       help: "the agent's model, show-me and model key",
       build: agentNodes,
     },
+    {
+      kind: "menu",
+      id: "audio",
+      label: "audio",
+      detail: context.audio
+        ? `out ${context.audio.output} · in ${context.audio.input}`
+        : "output · input",
+      help: "pick the audio output and input (one each, saved on this machine)",
+      build: audioNodes,
+    },
     {
       kind: "menu",
       id: "help",
@@ -3124,6 +3178,71 @@ function transportNodes(context: MenuContext): MenuNode[] {
   ];
 }
 
+/** Project › audio: two rows, each opening a device list. */
+function audioNodes(context: MenuContext): MenuNode[] {
+  const audio = context.audio;
+  if (!audio || audio.unavailable)
+    return [
+      {
+        kind: "info",
+        label: "devices",
+        value: "system default",
+        help: audio?.unavailable ?? "device choice needs the native sink",
+      },
+      {
+        kind: "action",
+        label: "show audio",
+        command: "/audio",
+        help: "the current output, input and why choice is unavailable",
+      },
+    ];
+  const list = (
+    side: "out" | "in",
+    names: readonly string[],
+    current: string,
+  ): MenuNode[] => [
+    {
+      kind: "action",
+      label: current.startsWith("default") ? "● default" : "default",
+      command: `/audio ${side} default`,
+      help: "the system default device (follows the system setting)",
+    },
+    ...names.map((name): MenuNode => ({
+      kind: "action",
+      label: name === current ? `● ${name}` : name,
+      command: `/audio ${side} ${name}`,
+      help:
+        side === "out"
+          ? `play through ${name} (a soft blip confirms it)`
+          : `listen on ${name} (audio test meters it)`,
+    })),
+  ];
+  return [
+    {
+      kind: "menu",
+      id: "output",
+      label: "output",
+      detail: audio.output,
+      help: "where dawg plays: Enter picks, Esc goes back",
+      build: () => list("out", audio.outputs, audio.output),
+    },
+    {
+      kind: "menu",
+      id: "input",
+      label: "input",
+      detail: audio.input,
+      help: "the input to meter now and record from later",
+      build: () => list("in", audio.inputs, audio.input),
+    },
+    {
+      kind: "action",
+      label: "test",
+      command: "/audio test",
+      help: "a short tone on the output, then a level meter for the input",
+    },
+  ];
+}
+
 /** Project > Resample: one action per useful source and range. */
 function resampleNodes(context: MenuContext): MenuNode[] {
   const track = focused(context);
@@ -3439,6 +3558,11 @@ function childFrame(
 export class EditMenu {
   private stack: Frame[] = [];
   private filtering = false;
+  /**
+   * The fader drawer's front page (design §8.6): the open level's knob page
+   * and whether Tab paged to every param. Undefined: plain rows.
+   */
+  private knobView: { page: string; all: boolean } | undefined;
   /** Typed value for the selected row (`entry` holds the row's label). */
   private entry: { label: string; buffer: string } | undefined;
 
@@ -3475,6 +3599,21 @@ export class EditMenu {
     }
   }
 
+  /** Step into the open level's submenu `id`; false when it has none. */
+  enter(context: MenuContext, id: string): boolean {
+    const frame = this.stack.at(-1);
+    if (!frame) return false;
+    const nodes = frame.build(context);
+    const index = nodes.findIndex(
+      (node) => node.kind === "menu" && node.id === id,
+    );
+    const node = nodes[index];
+    if (node?.kind !== "menu") return false;
+    frame.index = index;
+    this.stack.push(childFrame(frame, node));
+    return true;
+  }
+
   /**
    * Open on the level a bare parameter command edits, for the fader drawer:
    * `volume` / `pan` (Mix), `fx filter` / `fx filter cutoff` (that effect,
@@ -3561,6 +3700,77 @@ export class EditMenu {
     this.stack = [];
     this.filtering = false;
     this.entry = undefined;
+    this.knobView = undefined;
+  }
+
+  /**
+   * The knob page of the open level (design §7.3), or undefined where the
+   * level has no knobs: Sound (by engine), Mix and its mixer (this track),
+   * the master, Project (tempo) and one effect.
+   */
+  knobPageHere(context: MenuContext): string | undefined {
+    const ids = this.stack.slice(1).map((frame) => frame.id ?? "");
+    const [top, sub] = ids;
+    const track = focused(context);
+    if (top === "sound" && ids.length === 1)
+      return track ? `sound:${soundFamily(track)}` : undefined;
+    if (
+      top === "mix" &&
+      (ids.length === 1 || (ids.length === 2 && sub === "mixer"))
+    )
+      return "mix";
+    if (top === "mix" && ids.length === 2 && sub === "master") return "master";
+    if (top === "project" && ids.length === 1) return "tempo";
+    const last = ids.at(-1) ?? "";
+    if (top === "effects" && (EFFECT_NAMES as readonly string[]).includes(last))
+      return `fx:${last}`;
+    return undefined;
+  }
+
+  /**
+   * Turn the drawer's knob front page on for the open level. `label` is the
+   * row the drawer opens on: when it is not one of the knobs (or the level
+   * is the mixer), the drawer opens on every param instead. Returns the
+   * label to focus, or undefined when the level has no knob page.
+   */
+  openKnobs(context: MenuContext, label?: string): string | undefined {
+    const page = this.knobPageHere(context);
+    this.knobView = undefined;
+    if (!page) return undefined;
+    const frame = this.stack.at(-1)!;
+    const fallback = faderSpecs(frame.build(context));
+    const knobs = knobFields(context, page, fallback);
+    if (knobs.length === 0) return undefined;
+    const mixer = frame.id === "mixer";
+    const onKnob =
+      label === undefined || knobs.some((knob) => knob.label === label);
+    this.knobView = { page, all: mixer || !onKnob };
+    if (this.knobView.all) return label ?? fallback[0]?.label;
+    return label ?? knobs[0]!.label;
+  }
+
+  /** Which drawer page is up: the four knobs, every param, or no knobs. */
+  get knobPage(): "knobs" | "all" | undefined {
+    return this.knobView ? (this.knobView.all ? "all" : "knobs") : undefined;
+  }
+
+  /** The knob page id behind the drawer (`sound:synth`, `mix`), if any. */
+  get knobPageId(): string | undefined {
+    return this.knobView?.page;
+  }
+
+  /**
+   * Tab in the drawer: flip between the four knobs and every param (on the
+   * mixer, between all tracks and this track). Returns the label to focus:
+   * `keep` when it is on the new page, else the page's first field.
+   */
+  pageKnobs(context: MenuContext, keep: string): string | undefined {
+    if (!this.knobView) return undefined;
+    this.knobView = { ...this.knobView, all: !this.knobView.all };
+    const fields = this.faderFields(context);
+    return fields.some((field) => field.label === keep)
+      ? keep
+      : fields[0]?.label;
   }
 
   /** The visible rows of the current level (filtered). */
@@ -3858,10 +4068,26 @@ export class EditMenu {
    * related params: every filter control, every reverb control), built
    * from `context` (the staged score while auditioning).
    */
-  faderFields(context: MenuContext): FaderSpec[] {
+  faderFields(context: MenuContext): (FaderSpec | KnobField)[] {
     const frame = this.stack.at(-1);
     if (!frame) return [];
-    return faderSpecs(frame.build(context));
+    const rows = faderSpecs(frame.build(context));
+    if (!this.knobView) return rows;
+    if (!this.knobView.all)
+      return knobFields(context, this.knobView.page, rows);
+    // The mixer's rows are all levels: each wears the orange knob.
+    if (frame.id === "mixer")
+      return rows.map((row) => ({ ...row, knob: 3 as const }));
+    return rows;
+  }
+
+  /**
+   * Every param of the current level, whichever drawer page is up: the
+   * side list a wide drawer shows beside the four knobs.
+   */
+  pageFields(context: MenuContext): FaderSpec[] {
+    const frame = this.stack.at(-1);
+    return frame ? faderSpecs(frame.build(context)) : [];
   }
 
   /** The same fields as committed, for the drawer's `staged ← committed`. */

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,
@@ -55,6 +56,7 @@ import {
   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,
@@ -105,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 {
@@ -131,6 +141,12 @@ 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;
@@ -264,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). */
@@ -360,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);
     }
@@ -407,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, {
@@ -437,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();
@@ -569,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") {
@@ -632,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);
@@ -949,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 {
@@ -986,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)}`,
@@ -1011,6 +1151,7 @@ export class PlaySession {
     currentBar: number,
     now: number,
     all: boolean,
+    pass = false,
   ): Promise<void> {
     const score = this.host.score();
     const ready: Pending[] = [];
@@ -1027,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);
@@ -1049,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,
@@ -1103,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",
     );
   }
@@ -1172,6 +1346,7 @@ export class PlaySession {
       armed: this.armed,
       recording: this.recording,
       replace: this.replace,
+      pass: this.passLabel(),
       click: this.clickOn,
       sustain: this.keyboard.sustain,
       countIn,