@hraness/dawg 0.4.0 → 0.5.0

package/src/render.ts

@@ -1,5 +1,5 @@
 /**
- * `dawg render <out.wav>`: renders a session, the project files (`song.ts`,
+ * `dawg render <out.wav>` (or `<out.mid>`): renders a session, the project files (`song.ts`,
  * in a project with no `--session`), or a `track.loop/v1` file to
  * a stereo 16-bit PCM WAV through the same deterministic renderer playback
  * uses, so two renders of one score are byte-identical. It reads the session
@@ -10,7 +10,21 @@ import { readFile, rename, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
 import { scoreFromJSON, type TrackScore } from "../core/score.ts";
 import { decodeLoop } from "../core/loop.ts";
-import { renderScoreWav } from "./audio/wav.ts";
+import { scoreToMidi } from "../core/midi.ts";
+import { RENDER_CHANNELS, encodeWav, withWavCues } from "./audio/wav.ts";
+import { exportSampleRate, measureRendered } from "./audio/measure.ts";
+import {
+  applyMasterCommand,
+  loudnessLine,
+  measurementLine,
+  parseMasterCommand,
+} from "./commands/master.ts";
+import { bakeTrackTime, findSection, sectionScore } from "../core/sections.ts";
+import {
+  exportScore,
+  renderArrangedPcm,
+  sectionCues,
+} from "./audio/arrange.ts";
 import { SampleLibrary, hasSamplerTracks } from "./audio/samples.ts";
 import {
   PackStore,
@@ -29,7 +43,7 @@ import {
 } from "./session/store.ts";
 
 export const RENDER_USAGE =
-  "usage: dawg render <out.wav> [--session <name|id>] [--import <file.track.json>]";
+  "usage: dawg render <out.wav> [--session <name|id>] [--import <file.track.json>] [--section <name>] [--normalize <lufs|streaming|club|loud|…>] [--measure] [--rate <hz>] · <out.mid> writes MIDI";
 
 const MAX_LOOP_FILE_BYTES = 512 * 1024;
 
@@ -50,7 +64,14 @@ export async function runRenderCommand(
   const positional: string[] = [];
   for (let index = 0; index < rest.length; index += 1) {
     const arg = rest[index]!;
-    if (arg === "--session" || arg === "--import") {
+    if (arg === "--measure") options.set(arg, "");
+    else if (
+      arg === "--session" ||
+      arg === "--import" ||
+      arg === "--normalize" ||
+      arg === "--rate" ||
+      arg === "--section"
+    ) {
       const value = rest[index + 1];
       if (value === undefined || value.startsWith("--")) {
         stderr.write(`${arg} needs a value · ${RENDER_USAGE}\n`);
@@ -64,7 +85,7 @@ export async function runRenderCommand(
     } else positional.push(arg);
   }
   const target = positional[0];
-  if (positional.length !== 1 || !target || !/\.wav$/i.test(target)) {
+  if (positional.length !== 1 || !target || !/\.(wav|midi?)$/i.test(target)) {
     stderr.write(`${RENDER_USAGE}\n`);
     return 2;
   }
@@ -77,13 +98,85 @@ export async function runRenderCommand(
     );
     return 1;
   }
+  const only = options.get("--section");
+  if (only !== undefined) {
+    const section = findSection(score, only);
+    if (!section) {
+      const names = score.sections.map((entry) => entry.name).join(", ");
+      stderr.write(
+        `render failed · no section "${only}"${names ? ` · sections: ${names}` : ""}\n`,
+      );
+      return 1;
+    }
+    // One section as it plays when looped: its mutes and variations, no form.
+    score = sectionScore(bakeTrackTime(score), section);
+  }
+  if (/\.midi?$/i.test(target)) {
+    // MIDI carries notes, not audio: the master and loudness flags do not apply.
+    const audioOnly = ["--normalize", "--measure", "--rate"].find((flag) =>
+      options.has(flag),
+    );
+    if (audioOnly) {
+      stderr.write(`render failed · ${audioOnly} applies to .wav only\n`);
+      return 2;
+    }
+    const midi = scoreToMidi(exportScore(score));
+    const midiPath = resolve(workspace, target);
+    const midiTemporary = `${midiPath}.${process.pid}.tmp`;
+    await writeFile(midiTemporary, midi);
+    await rename(midiTemporary, midiPath);
+    const midiSha = createHash("sha256").update(midi).digest("hex");
+    stdout.write(
+      `rendered · ${target} · ${midi.byteLength} bytes · ${midiSha}\n`,
+    );
+    return 0;
+  }
+  // `--normalize` is the song master's loudness target for this export only:
+  // a named target also brings the limiter in at that target's ceiling.
+  const normalize = options.get("--normalize");
+  if (normalize !== undefined) {
+    const command = parseMasterCommand(`master target ${normalize}`);
+    const result = command && applyMasterCommand(score, command);
+    if (!result?.ok) {
+      stderr.write(
+        `render failed · --normalize takes LUFS (-40 to -3) or a target name · ${RENDER_USAGE}\n`,
+      );
+      return 2;
+    }
+    score = result.next ?? score;
+    const flipped =
+      command?.type === "master-target" ? command.flipped : undefined;
+    if (flipped !== undefined)
+      stderr.write(
+        `render · --normalize ${normalize} read as ${-flipped} LUFS\n`,
+      );
+  }
   let samples;
   if (hasSamplerTracks(score)) {
     samples = await new SampleLibrary({ projectRoot: workspace }).load(score);
     for (const problem of samples.problems)
       stderr.write(`sample ${problem.level} · ${problem.message}\n`);
   }
-  let wav = renderScoreWav(score, { samples });
+  // A song with a master is a deliverable: 48 kHz unless --rate says
+  // otherwise; a plain song keeps the engine's rate, as dawg 0.4 wrote it.
+  const rateArg = options.get("--rate");
+  const sampleRate =
+    rateArg === undefined ? exportSampleRate(score) : Number(rateArg);
+  if (
+    !Number.isInteger(sampleRate) ||
+    sampleRate < 8_000 ||
+    sampleRate > 48_000
+  ) {
+    stderr.write(
+      `render failed · --rate takes 8000 to 48000 Hz · ${RENDER_USAGE}\n`,
+    );
+    return 2;
+  }
+  const audio = renderArrangedPcm(score, { samples, sampleRate });
+  let wav = encodeWav(audio.pcm, audio.sampleRate, RENDER_CHANNELS);
+  // Section starts as cue points (a --section render is one section).
+  if (only === undefined)
+    wav = withWavCues(wav, sectionCues(score, audio.sampleRate));
   // Pack sounds: name the packs (and CC-BY attributions) in the WAV's INFO
   // comment and on stdout; CREDITS.md in a project keeps the attributions.
   const refs = score.tracks.flatMap((track) =>
@@ -102,8 +195,17 @@ export async function runRenderCommand(
   await writeFile(temporary, wav);
   await rename(temporary, path);
   const sha = createHash("sha256").update(wav).digest("hex");
-  stdout.write(`rendered · ${target} · ${wav.byteLength} bytes · ${sha}\n`);
+  const seconds = audio.frames / audio.sampleRate;
+  stdout.write(
+    `rendered · ${target} · ${seconds.toFixed(2)} s · ${wav.byteLength} bytes · ${sha}\n`,
+  );
   if (credits) stdout.write(`credits · ${credits}\n`);
+  if (options.has("--measure"))
+    stdout.write(
+      `loudness · ${measurementLine(measureRendered(audio, false).mix, audio.master)}\n`,
+    );
+  else if (audio.master)
+    stdout.write(`loudness · ${loudnessLine(audio.master)}\n`);
   return 0;
 }
 

package/src/session/daemon.ts

@@ -6,7 +6,7 @@ import {
   type ScoreOperation,
   type TrackScore,
 } from "../../core/score.ts";
-import { TransportClock } from "../audio/clock.ts";
+import { TransportClock, transportMapFor } from "../audio/clock.ts";
 import { AudioEngine } from "../audio/engine.ts";
 import { acquireSessionLock } from "./lock.ts";
 import {
@@ -127,7 +127,7 @@ export class DawgDaemon {
     }
     try {
       await this.reload();
-      this.clock.setTempo(this.score.tempoBpm);
+      this.clock.follow(this.score);
       // We hold the daemon lock, so any socket file left here belongs to a
       // crashed daemon and is safe to reclaim.
       await rm(this.socketPath, { force: true });
@@ -340,7 +340,7 @@ export class DawgDaemon {
         );
         if (result.record.revision !== this.record.revision) {
           // A file-fallback window wrote the score too; adopt everything.
-          const previousTempo = this.score.tempoBpm;
+          const previousTempo = this.timeKey();
           await this.reload();
           this.broadcast({
             v: 1,
@@ -454,7 +454,7 @@ export class DawgDaemon {
             rebasedFrom: message.base,
           }
         : message.payload;
-    const previousTempo = this.score.tempoBpm;
+    const previousTempo = this.timeKey();
     try {
       this.record = await appendSessionEvent(
         this.paths,
@@ -528,9 +528,14 @@ export class DawgDaemon {
     }
   }
 
-  private afterScoreChange(previousTempo: number): void {
-    if (this.score.tempoBpm !== previousTempo) {
-      this.clock.setTempo(this.score.tempoBpm);
+  /** Tempo and tempo map, compared to tell when the transport must follow. */
+  private timeKey(): string {
+    return JSON.stringify([this.score.tempoBpm, this.score.time ?? null]);
+  }
+
+  private afterScoreChange(previousTempo: string): void {
+    if (this.timeKey() !== previousTempo) {
+      this.clock.follow(this.score);
       this.broadcastTransport();
     }
     // Gapless: a streaming engine swaps the loop at the current beat
@@ -560,6 +565,7 @@ export class DawgDaemon {
       this.audio.seek(this.clock.beatAt());
     } else if (action === "tempo" && bpm !== undefined) {
       this.clock.setTempo(bpm);
+      this.clock.setTimeMap(transportMapFor(this.score));
     }
     this.broadcastTransport();
   }
@@ -641,7 +647,7 @@ export class DawgDaemon {
         }
         return;
       }
-      const previousTempo = this.score.tempoBpm;
+      const previousTempo = this.timeKey();
       await this.reload();
       this.broadcast({
         v: 1,
@@ -695,6 +701,10 @@ const OPERATION_TYPES = new Set([
   "moveTrack",
   "setKey",
   "setMeter",
+  "setTime",
+  "setTuning",
+  "setMaster",
+  "setSections",
 ]);
 
 /** Shape gate before the reducer, which validates every field it reads. */

package/src/session/naming.ts

@@ -107,7 +107,14 @@ export function musicalFingerprint(score: TrackScore): Fingerprint {
         : `${role}(${instrument},${register},${density})`,
     );
   }
-  const key = score.key ? score.key.toLowerCase() : estimateKey(histogram);
+  // A tuned song is named by its tuning (`pelog`), not a guessed 12-TET key.
+  const tuned = score.tuning
+    ? (score.tuning.name ??
+      (score.tuning.edo ? `${score.tuning.edo}-edo` : "tuned"))
+    : undefined;
+  const key = score.key
+    ? score.key.toLowerCase()
+    : (tuned?.toLowerCase() ?? estimateKey(histogram));
   const line = [
     `${bpm} bpm`,
     key ?? "no key",

package/src/session/rebase.ts

@@ -16,6 +16,7 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { rewindComposition, type Rewind } from "./delta.ts";
+import { deepEqual } from "../../core/diff.ts";
 
 /** How far behind a base may be and still be rebased. */
 export const MAX_REBASE_DISTANCE = 64;
@@ -114,6 +115,26 @@ export function rebaseOperations(
         if (base.beatsPerBar !== current.beatsPerBar)
           return { ok: false, reason: "meter changed" };
         break;
+      case "setTime":
+        if (!same(base.time, current.time))
+          return { ok: false, reason: "tempo map changed" };
+        break;
+      case "setTuning":
+        if (!same(base.tuning ?? null, current.tuning ?? null))
+          return { ok: false, reason: "tuning changed" };
+        break;
+      case "setMaster":
+        if (!deepEqual(base.master, current.master))
+          return { ok: false, reason: "master changed" };
+        break;
+      case "setSections":
+        if (
+          JSON.stringify(base.sections) !== JSON.stringify(current.sections) ||
+          JSON.stringify(base.form) !== JSON.stringify(current.form) ||
+          base.loopSection !== current.loopSection
+        )
+          return { ok: false, reason: "sections changed" };
+        break;
       case "removeTrack": {
         if (added.tracks.has(operation.trackId)) break;
         if (

package/src/tui/arrange-menu.ts

@@ -0,0 +1,390 @@
+/**
+ * The ctrl-k menu's Arrange section (0.5): song sections, the form, and
+ * build/drop/fill generators. Every row runs a `section …`, `form …`,
+ * `build …`, `drop …` or `fill …` prompt command (src/commands/arrange.ts),
+ * so the menu, the prompt and the agent tools share one code path.
+ */
+import type { Section } from "../../core/score.ts";
+import { formatForm } from "../../core/sections.ts";
+import { barsLabel } from "../commands/arrange.ts";
+import type { MenuContext, MenuNode } from "./menu.ts";
+
+/** `3 sections · form A×2 B · loop chorus`, or how to start. */
+export function arrangeDetail(context: MenuContext): string {
+  const score = context.score;
+  if (score.sections.length === 0) return "no sections · mark bars";
+  const count = score.sections.length;
+  const parts = [`${count} section${count === 1 ? "" : "s"}`];
+  if (score.form.length) parts.push(`form ${formatForm(score.form)}`);
+  if (score.loopSection) parts.push(`loop ${score.loopSection}`);
+  return parts.join(" · ");
+}
+
+export function arrangeNodes(context: MenuContext): MenuNode[] {
+  const score = context.score;
+  const nodes: MenuNode[] = score.sections.map((section) => ({
+    kind: "menu",
+    id: `section:${section.name}`,
+    label: section.name,
+    detail: sectionDetail(context, section),
+    help: "loop, jump, mute, vary, move, rename, transitions",
+    build: (next) => sectionNodes(next, section.name),
+  }));
+  nodes.push(
+    {
+      kind: "entry",
+      label: "mark bars",
+      value: "",
+      placeholder: "name and bars, e.g. verse 1-8",
+      example: "section verse 1-8",
+      help: "name a bar range; re-marking a name moves its marker",
+      command: (text) => {
+        const trimmed = text.trim();
+        return /\S\s+\d{1,4}(?:[-–]\d{1,4})?$/u.test(trimmed)
+          ? `section ${trimmed}`
+          : undefined;
+      },
+    },
+    {
+      kind: "entry",
+      label: "add section",
+      value: "",
+      placeholder: "name and bars, e.g. chorus 8 (empty: next name, 8 bars)",
+      example: "section add chorus 8",
+      help: "a new section after the last one (extends the song)",
+      command: (text) => `section add ${text.trim()}`.trim(),
+    },
+  );
+  if (score.sections.length > 0) {
+    nodes.push({
+      kind: "entry",
+      label: "form",
+      value: score.form.length ? formatForm(score.form) : "bars in order",
+      placeholder: "sections in play order, e.g. intro verse chorus*2 outro",
+      example: "form intro verse chorus*2 outro",
+      help: "the order playback and export follow; empty clears it",
+      command: (text) => (text.trim() ? `form ${text.trim()}` : "form off"),
+    });
+    if (score.form.length)
+      nodes.push({
+        kind: "action",
+        label: "bake form",
+        command: "form bake",
+        help: "write the form out as plain bars, then clear it",
+      });
+    if (score.loopSection)
+      nodes.push({
+        kind: "action",
+        label: `stop looping ${score.loopSection}`,
+        command: "section loop off",
+        help: "play the whole song (or form) again",
+      });
+  }
+  return nodes;
+}
+
+function sectionDetail(context: MenuContext, section: Section): string {
+  const parts = [barsLabel(section)];
+  if (context.score.loopSection === section.name) parts.push("looping");
+  if (section.mute?.length) parts.push(`mutes ${section.mute.join(" ")}`);
+  const varied = Object.keys(section.vary ?? {});
+  if (varied.length) parts.push(`varies ${varied.join(" ")}`);
+  return parts.join(" · ");
+}
+
+function sectionNodes(context: MenuContext, name: string): MenuNode[] {
+  const score = context.score;
+  const section = score.sections.find((entry) => entry.name === name);
+  if (!section)
+    return [{ kind: "info", label: "gone", value: `${name} was removed` }];
+  const looping = score.loopSection === name;
+  const track = context.trackId;
+  const vary = section.vary?.[track];
+  const mutes: MenuNode[] = score.tracks.map((entry) => ({
+    kind: "toggle",
+    label: `mute ${entry.id}`,
+    value: section.mute?.includes(entry.id) ?? false,
+    help: `silence ${entry.name} in this section only`,
+    command: (on) => `section ${on ? "mute" : "unmute"} ${name} ${entry.id}`,
+  }));
+  return [
+    {
+      kind: "action",
+      label: looping ? "stop looping" : "loop",
+      command: looping ? "section loop off" : `section loop ${name}`,
+      help: "loop this section in playback (export still plays the song)",
+    },
+    {
+      kind: "action",
+      label: "jump here",
+      command: `section jump ${name}`,
+      help: "move the playhead to its first bar",
+    },
+    ...mutes,
+    {
+      kind: "number",
+      label: `transpose ${track}`,
+      help: "shift the focused track here, in semitones (x resets)",
+      // As written is +0, so the first nudge already moves a semitone.
+      value: vary?.transpose ?? 0,
+      min: -24,
+      max: 24,
+      step: (value, direction) =>
+        Math.max(-24, Math.min(24, Math.round(value) + direction)),
+      format: (value) => `${value > 0 ? "+" : ""}${Math.round(value)} st`,
+      command: (value) => {
+        const rounded = Math.round(value);
+        return `section vary ${name} ${track} ${rounded < 0 ? "" : "+"}${rounded}`;
+      },
+      reset: `section vary ${name} ${track} off`,
+    },
+    {
+      kind: "number",
+      label: `gain ${track}`,
+      help: "scale the focused track's velocity here (x resets)",
+      value: vary?.gain ?? 1,
+      min: 0,
+      max: 2,
+      step: (value, direction) =>
+        Math.max(
+          0,
+          Math.min(2, Math.round((value + 0.1 * direction) * 10) / 10),
+        ),
+      format: (value) => `×${value.toFixed(1)}`,
+      command: (value) =>
+        `section vary ${name} ${track} gain ${(Math.round(value * 10) / 10).toString()}`,
+      reset: `section vary ${name} ${track} off`,
+    },
+    {
+      kind: "menu",
+      id: `section:${name}:build`,
+      label: "build",
+      detail: section.startBar > 0 ? "into it or over it" : "over it",
+      help: "riser, snare roll, filter sweep and uplifter",
+      build: () => buildNodes(section),
+    },
+    ...(section.startBar > 0
+      ? ([
+          {
+            kind: "menu",
+            id: `section:${name}:drop`,
+            label: "drop",
+            detail: "cut and impact",
+            help: "a pre-drop cut before it and an impact on its downbeat",
+            build: () => dropNodes(section),
+          },
+          {
+            kind: "menu",
+            id: `section:${name}:fill`,
+            label: "fill",
+            detail: "toms, roll or kick",
+            help: "a drum fill on the beats before it and a crash on its downbeat",
+            build: () => fillNodes(section),
+          },
+        ] satisfies MenuNode[])
+      : []),
+    {
+      kind: "action",
+      label: "duplicate",
+      command: `section dup ${name}`,
+      help: "copy it and its bars right after it",
+    },
+    {
+      kind: "entry",
+      label: "duplicate as",
+      value: "",
+      placeholder: "the copy's name",
+      example: `section dup ${name} as ${name} 2`,
+      help: "copy it and its bars right after it, under a new name",
+      command: (text) =>
+        text.trim() ? `section dup ${name} as ${text.trim()}` : undefined,
+    },
+    {
+      kind: "entry",
+      label: "move to",
+      value: "",
+      placeholder: "a bar, or before/after a section, e.g. 17 or after chorus",
+      example: `section move ${name} to 17`,
+      help: "move it and its bars; later sections make room",
+      command: (text) => {
+        const trimmed = text.trim();
+        if (/^\d{1,4}$/u.test(trimmed))
+          return `section move ${name} to ${trimmed}`;
+        return /^(before|after)\s+\S/u.test(trimmed)
+          ? `section move ${name} ${trimmed}`
+          : undefined;
+      },
+    },
+    {
+      kind: "action",
+      label: "move left",
+      command: `section move ${name} left`,
+      help: "swap it with the section before (its bars move too)",
+    },
+    {
+      kind: "action",
+      label: "move right",
+      command: `section move ${name} right`,
+      help: "swap it with the section after (its bars move too)",
+    },
+    {
+      kind: "entry",
+      label: "rename",
+      value: name,
+      placeholder: "new name",
+      example: `section rename ${name} to hook`,
+      help: "the form and the loop follow the new name",
+      command: (text) =>
+        text.trim() ? `section rename ${name} to ${text.trim()}` : undefined,
+    },
+    {
+      kind: "action",
+      label: "clear mutes and variations",
+      command: `section reset ${name}`,
+      help: "every track plays as written here",
+    },
+    {
+      kind: "action",
+      label: "unmark",
+      command: `section unmark ${name}`,
+      help: "remove the marker; the music stays",
+    },
+    {
+      kind: "action",
+      label: "delete with its bars",
+      command: `section delete ${name}`,
+      help: "remove it and its bars; later bars move up",
+    },
+  ];
+}
+
+/** Build rows: into the section (the bars before it) or over it. */
+export function buildNodes(section: Section): MenuNode[] {
+  const name = section.name;
+  const nodes: MenuNode[] = [];
+  if (section.startBar > 0) {
+    const bars = Math.min(4, section.startBar);
+    nodes.push({
+      kind: "action",
+      label: `into it (${bars} bar${bars === 1 ? "" : "s"} before)`,
+      command: `build into ${name}`,
+      help: `riser, snare roll, filter sweep and uplifter over bars ${section.startBar - bars + 1}–${section.startBar}, landing on its downbeat`,
+    });
+  }
+  nodes.push(
+    {
+      kind: "action",
+      label: "over it",
+      command: `build ${name}`,
+      help: "riser, snare roll, filter sweep and uplifter over this section, landing on the bar after",
+    },
+    {
+      kind: "entry",
+      label: "custom",
+      value: "",
+      placeholder:
+        "bars and layers, e.g. 8 bars riser sweep (layers: riser roll sweep uplifter)",
+      example: `build into ${name} 8 bars riser sweep`,
+      help: "choose the length and which layers play",
+      command: (text) => {
+        const words = text.trim().toLowerCase().split(/\s+/u).filter(Boolean);
+        const ok = words.every(
+          (word, index) =>
+            /^(riser|roll|sweep|uplifter)s?$/u.test(word) ||
+            (/^\d{1,3}$/u.test(word) &&
+              /^bars?$/u.test(words[index + 1] ?? "")) ||
+            (/^bars?$/u.test(word) &&
+              /^\d{1,3}$/u.test(words[index - 1] ?? "")),
+        );
+        if (!ok) return undefined;
+        const target = section.startBar > 0 ? `into ${name}` : name;
+        return `build ${target} ${words.join(" ")}`.trim();
+      },
+    },
+  );
+  return nodes;
+}
+
+/** Drop rows: cut length and the impact. */
+export function dropNodes(section: Section): MenuNode[] {
+  const name = section.name;
+  return [
+    {
+      kind: "action",
+      label: "cut 1 beat and impact",
+      command: `drop ${name}`,
+      help: "a one-beat cut before it and an impact on its downbeat",
+    },
+    {
+      kind: "action",
+      label: "cut 2 beats and impact",
+      command: `drop ${name} cut 2`,
+      help: "a two-beat cut before it and an impact on its downbeat",
+    },
+    {
+      kind: "action",
+      label: "impact only",
+      command: `drop ${name} no cut`,
+      help: "an impact on its downbeat, no cut",
+    },
+    {
+      kind: "action",
+      label: "cut only",
+      command: `drop ${name} no impact`,
+      help: "a one-beat cut before it, no impact",
+    },
+    {
+      kind: "entry",
+      label: "custom",
+      value: "",
+      placeholder: "cut beats and impact, e.g. cut 4 no impact",
+      example: `drop ${name} cut 4 no impact`,
+      help: "cut 0 up to two bars of beats; no impact skips the hit",
+      command: (text) =>
+        /^(cut\s+\d+(\.\d+)?|no\s+cut|no\s+impact|impact|\s)*$/iu.test(
+          text.trim(),
+        )
+          ? `drop ${name} ${text.trim()}`.trim()
+          : undefined,
+    },
+  ];
+}
+
+/** Fill rows: a style each, plus length and crash. */
+export function fillNodes(section: Section): MenuNode[] {
+  const name = section.name;
+  return [
+    {
+      kind: "action",
+      label: "toms",
+      command: `fill ${name} toms`,
+      help: "snare into high, mid and low toms on the beat before it, crash on its downbeat",
+    },
+    {
+      kind: "action",
+      label: "snare roll",
+      command: `fill ${name} roll`,
+      help: "snare 16ths on the beat before it, crash on its downbeat",
+    },
+    {
+      kind: "action",
+      label: "kick and snare",
+      command: `fill ${name} kick`,
+      help: "kick and snare 16ths on the beat before it, crash on its downbeat",
+    },
+    {
+      kind: "entry",
+      label: "custom",
+      value: "",
+      placeholder: "style, beats and crash, e.g. toms 2 beats no crash",
+      example: `fill ${name} toms 2 beats no crash`,
+      help: "styles toms, roll, kick; half a beat up to two bars",
+      command: (text) =>
+        /^(toms|roll|kick|\d+(\.\d+)?\s+beats?|no\s+crash|crash|\s)*$/iu.test(
+          text.trim(),
+        )
+          ? `fill ${name} ${text.trim()}`.trim()
+          : undefined,
+    },
+  ];
+}