@hraness/dawg 0.6.0 → 0.7.0

package/src/commands/pack.ts

@@ -124,10 +124,10 @@ export type KitCommand =
 
 /** `/kit [bank]` (default kit) and `/kit list`; undefined for other commands. */
 export function parseKitCommand(command: string): KitCommand | undefined {
-  const match = command.trim().match(/^\/kit(?:\s+(\S+))?\s*$/i);
+  const match = command.trim().match(/^\/?kits?(?:\s+(\S+))?\s*$/i);
   if (!match) return undefined;
   const bank = match[1];
-  if (bank && /^(list|ls)$/i.test(bank)) return { kind: "list" };
+  if (bank && /^(list|ls|presets)$/i.test(bank)) return { kind: "list" };
   return { kind: "set", bank: bank ?? DEFAULT_KIT };
 }
 
@@ -389,6 +389,8 @@ export function kitListLines(aliases: BankAliases): string[] {
 export type CacheReport = Readonly<{
   packs: CacheUsage & { max: number };
   assets: CacheUsage & { max: number };
+  /** Pitch curves in `.dawg/analysis` (0.7); omitted when empty. */
+  analysis?: CacheUsage & { max: number };
   freed?: Readonly<{ files: number; bytes: number }>;
 }>;
 
@@ -408,6 +410,11 @@ export function cacheLines(report: CacheReport): string[] {
       : []),
     row("pack downloads", report.packs, "DAWG_PACKS_CACHE_MAX"),
     row("decoded audio (this project)", report.assets, "DAWG_ASSETS_CACHE_MAX"),
+    ...(report.analysis?.files
+      ? [
+          `pitch analysis (this project) · ${formatBytes(report.analysis.bytes)} of ${formatBytes(report.analysis.max)} · ${report.analysis.files} curve${report.analysis.files === 1 ? "" : "s"} · .dawg/analysis, re-tracked on demand`,
+        ]
+      : []),
     "least recently used files go first; this project's sounds are never evicted",
     "evicted sounds re-fetch by their pinned sha256 on next use",
     "/pack cache prune [size] · /pack cache clear",

package/src/commands/param-range.ts

@@ -0,0 +1,56 @@
+/**
+ * `✗ synth lpf 99999 · lpf takes 20…20000 Hz · synth lpf 1200`: the range
+ * card for a synth or effect parameter, built from the same specs that
+ * validate it (core/params), so the card and the check never disagree.
+ */
+import type { ParamSpec } from "../../core/params.ts";
+import { SYNTH_PARAMS, synthParamName } from "../../core/synth.ts";
+import { effectSpec } from "../../core/fx.ts";
+import { parseEffectName, parseParamName } from "./fx.ts";
+import { usageError } from "./grammar.ts";
+
+/** The range card for the first out-of-range number in the line, if any. */
+export function paramRangeError(line: string): string | undefined {
+  const words = line.trim().replace(/^\//, "").split(/\s+/);
+  const verb = words[0]?.toLowerCase();
+  if (verb === "synth")
+    return firstOutOfRange(line, words.slice(1), "synth", (word) => {
+      const name = synthParamName(word);
+      return name ? [name, SYNTH_PARAMS[name]] : undefined;
+    });
+  if (verb === "fx" && words[1]) {
+    const effect = parseEffectName(words[1]);
+    if (!effect) return undefined;
+    const params = effectSpec(effect).params;
+    return firstOutOfRange(line, words.slice(2), `fx ${effect}`, (word) => {
+      const name = parseParamName(effect, word);
+      return name ? [name, params[name]] : undefined;
+    });
+  }
+  return undefined;
+}
+
+function firstOutOfRange(
+  line: string,
+  rest: readonly string[],
+  prefix: string,
+  lookup: (word: string) => [string, ParamSpec | undefined] | undefined,
+): string | undefined {
+  for (let index = 0; index + 1 < rest.length; index += 2) {
+    const found = lookup(rest[index]!);
+    if (!found) continue;
+    const [name, spec] = found;
+    if (spec?.kind !== "number") continue;
+    const value = Number(rest[index + 1]);
+    if (!Number.isFinite(value)) continue;
+    if (value >= spec.min && value <= spec.max) continue;
+    return usageError(line.trim(), {
+      command: name,
+      min: spec.min,
+      max: spec.max,
+      unit: spec.unit ?? "",
+      example: `${prefix} ${name} ${spec.default}`,
+    });
+  }
+  return undefined;
+}

package/src/commands/parses.ts

@@ -0,0 +1,130 @@
+/**
+ * Whether a prompt line is a command the human prompt bar runs locally (no
+ * model call): every command parser the prompt tries, in one list. The TUI
+ * uses it for typo fixes; show-me (src/agent/show-me.ts) uses it in tests to
+ * prove every command it ghost-types is one a human can type.
+ */
+import type { TrackScore } from "../../core/score.ts";
+import { parsePrompt } from "../agent/ops.ts";
+import { parseSectionCommand } from "./arrange.ts";
+import { parseAutotuneCommand } from "./autotune.ts";
+import { parseClipCommand, parseLyricsCommand } from "./clips.ts";
+import { parsePatternCommand } from "./drums.ts";
+import { parseProgressionCommand } from "./progression.ts";
+import { parseEditCommand } from "./edit.ts";
+import { parseExpressionCommand } from "./expression.ts";
+import { parseFitCommand } from "./fit.ts";
+import { parseFormantCommand, parseVowelCommand } from "./formant.ts";
+import { parseFxCommand } from "./fx.ts";
+import { parseGranularCommand } from "./granular.ts";
+import { parseKeysCommand } from "./keys.ts";
+import { parseMasterCommand } from "./master.ts";
+import { parseModalCommand } from "./modal.ts";
+import { parseMusicCommand } from "./music.ts";
+import { parseKitCommand, parsePackCommand } from "./pack.ts";
+import { parseResampleCommand } from "./resample.ts";
+import { parseRhythmCommand } from "./rhythm.ts";
+import { parseRigCommand } from "./rig.ts";
+import { parseSampleCommand } from "./sample.ts";
+import { parseShiftCommand } from "./shift.ts";
+import { parseSingCommand } from "./sing.ts";
+import { parseStringCommand } from "./string.ts";
+import { parseGuitarCommand, parseStrumCommand } from "./strum.ts";
+import { parseSynthCommand } from "./synth.ts";
+import { parseTimeCommand } from "./time.ts";
+import { parseTuningCommand } from "./tuning.ts";
+import { parseVocalCommand } from "./vocal.ts";
+import { parseVocoderCommand } from "./vocoder.ts";
+import { parseWavetableCommand } from "./wavetable.ts";
+import { parseWindCommand } from "./wind.ts";
+import {
+  candidates,
+  parseExportCommand,
+  parseLoopCommand,
+  parseTrackEdit,
+} from "./grammar.ts";
+
+/** One parser's reading of a line: its name and what it parsed. */
+export type ParsedCommand = Readonly<{ parser: string; value: unknown }>;
+
+/**
+ * The first parser that takes `text` exactly as typed, with its result
+ * (no grammar rewrites): what the prompt bar would run for this spelling.
+ */
+export function parseExact(
+  text: string,
+  score: TrackScore,
+): ParsedCommand | undefined {
+  for (const parse of parsers(score)) {
+    const value = parse(text);
+    if (value !== undefined)
+      return { parser: parse.name || "anonymous", value };
+  }
+  return undefined;
+}
+
+/**
+ * What `text` runs as: the exact spelling first, then the grammar's other
+ * readings (`/x` ≡ `x`, aliases, remove and list words) in order.
+ */
+export function parseCommand(
+  text: string,
+  score: TrackScore,
+): ParsedCommand | undefined {
+  for (const line of [text, ...candidates(text)]) {
+    const parsed = parseExact(line, score);
+    if (parsed) return parsed;
+  }
+  return undefined;
+}
+
+/** Whether a line runs locally, in any spelling the grammar accepts. */
+export function commandParses(text: string, score: TrackScore): boolean {
+  return parseCommand(text, score) !== undefined;
+}
+
+function parsers(score: TrackScore): ((text: string) => unknown)[] {
+  return [
+    parsePrompt,
+    parseMusicCommand,
+    parseEditCommand,
+    parseRhythmCommand,
+    parseFxCommand,
+    parseSynthCommand,
+    parseStringCommand,
+    parseGranularCommand,
+    parseKeysCommand,
+    parseExpressionCommand,
+    parseMasterCommand,
+    function parseSection(value: string) {
+      return parseSectionCommand(value, score);
+    },
+    parsePatternCommand,
+    parseKitCommand,
+    parsePackCommand,
+    parseSampleCommand,
+    parseFitCommand,
+    parseShiftCommand,
+    parseResampleCommand,
+    parseWavetableCommand,
+    parseTimeCommand,
+    parseTuningCommand,
+    parseRigCommand,
+    parseModalCommand,
+    parseGuitarCommand,
+    parseStrumCommand,
+    parseProgressionCommand,
+    parseWindCommand,
+    parseAutotuneCommand,
+    parseSingCommand,
+    parseVocoderCommand,
+    parseVocalCommand,
+    parseFormantCommand,
+    parseVowelCommand,
+    parseClipCommand,
+    parseLyricsCommand,
+    parseExportCommand,
+    parseLoopCommand,
+    parseTrackEdit,
+  ];
+}

package/src/commands/progression.ts

@@ -0,0 +1,170 @@
+/**
+ * `progression …`: sustained, voice-led block chords on the focused track,
+ * the prompt form of the SDK's `progression()` and the agent's write_chords.
+ *
+ *   progression i7 IV7 i7 IV7 each 8     roman numerals in the song key
+ *   progression Am7 D9 at 16 bass        chord symbols, a root under each
+ *
+ * Chords run core/chords.ts renderProgression in `block` mode with voice
+ * leading, so a carrier for a vocoder or talkbox holds each chord for its
+ * whole span. Existing notes stay; chords past the end grow the song.
+ */
+import {
+  chordName,
+  keyUsesFlats,
+  parseKey,
+  renderProgression,
+  resolveChord,
+  type Chord,
+  type Key,
+} from "../../core/chords.ts";
+import { applyScoreOperations } from "../../core/diff.ts";
+import {
+  SCORE_LIMITS,
+  ScoreValidationError,
+  type ScoreOperation,
+  type TrackScore,
+} from "../../core/score.ts";
+import { barTicks } from "../../core/sections.ts";
+import { resolveTuning, snapToTuning } from "../../core/tuning.ts";
+import type { CommandResult } from "./strum.ts";
+
+export const PROGRESSION_USAGE =
+  "progression <chords> [each <beats>] [at <beat>] [bass] · progression i7 IV7 each 8 · progression Am7 D9 bass";
+
+export type ProgressionOptions = Readonly<{
+  chords: readonly string[];
+  each?: number;
+  at?: number;
+  bass?: boolean;
+}>;
+
+export type ProgressionCommand =
+  | Readonly<{ type: "progression"; options: ProgressionOptions }>
+  | Readonly<{ type: "progression-hint"; message: string }>;
+
+/** `progression …`, or undefined when the prompt is not one. */
+export function parseProgressionCommand(
+  prompt: string,
+): ProgressionCommand | undefined {
+  if (prompt.length > 1_024) return undefined;
+  const words = prompt.trim().replace(/^\//, "").split(/\s+/);
+  const head = words[0]?.toLowerCase();
+  if (head !== "progression" && head !== "prog") return undefined;
+  const chords: string[] = [];
+  let each: number | undefined;
+  let at: number | undefined;
+  let bass = false;
+  for (let i = 1; i < words.length; i += 1) {
+    const word = words[i]!;
+    const lower = word.toLowerCase();
+    if (lower === "each" || lower === "at") {
+      const value = Number(words[i + 1]);
+      if (
+        !Number.isFinite(value) ||
+        value < 0 ||
+        (lower === "each" && value <= 0)
+      )
+        return { type: "progression-hint", message: PROGRESSION_USAGE };
+      if (lower === "each") each = value;
+      else at = value;
+      i += 1;
+    } else if (lower === "bass") bass = true;
+    else chords.push(word);
+  }
+  if (chords.length === 0)
+    return { type: "progression-hint", message: PROGRESSION_USAGE };
+  if (chords.length > 64)
+    return {
+      type: "progression-hint",
+      message: "progression takes up to 64 chords",
+    };
+  return {
+    type: "progression",
+    options: {
+      chords,
+      ...(each !== undefined ? { each } : {}),
+      ...(at !== undefined ? { at } : {}),
+      ...(bass ? { bass } : {}),
+    },
+  };
+}
+
+/** Writes a progression command's chords onto `trackId`. */
+export function applyProgressionCommand(
+  score: TrackScore,
+  trackId: string,
+  command: ProgressionCommand,
+  newId: (index: number) => string,
+): CommandResult {
+  if (command.type === "progression-hint")
+    return { ok: false, message: command.message };
+  const track = score.tracks.find((candidate) => candidate.id === trackId);
+  if (!track) return { ok: false, message: `no track · ${trackId}` };
+  const { options } = command;
+  const key: Key = parseKey(score.key) ?? { tonic: 0, mode: "major" };
+  const chords: Chord[] = [];
+  for (const text of options.chords) {
+    const chord = resolveChord(key, text);
+    if (!chord)
+      return {
+        ok: false,
+        message: `unknown chord ${JSON.stringify(text.slice(0, 32))} (a symbol like Am7 or a numeral like ii7)`,
+      };
+    chords.push(chord);
+  }
+  const each = options.each ?? score.beatsPerBar;
+  const rendered = renderProgression({
+    key,
+    chords,
+    beatsPerChord: each,
+    start: options.at ?? 0,
+    bass: options.bass === true,
+    lead: true,
+    perform: { mode: "block" },
+  });
+  const performed = [...rendered.notes, ...rendered.bass];
+  if (performed.length > 4096)
+    return { ok: false, message: "progression would write over 4096 notes" };
+  const tpb = score.ticksPerBeat;
+  const table = resolveTuning(score.tuning, track.tuning, score.key);
+  const operations: ScoreOperation[] = performed.map((note, index) => ({
+    type: "addNote",
+    note: {
+      id: newId(index),
+      trackId,
+      startTick: Math.round(note.start * tpb),
+      durationTicks: Math.max(1, Math.round(note.length * tpb)),
+      pitch: snapToTuning(note.pitch, table),
+      velocity: note.velocity,
+    },
+  }));
+  let next: TrackScore;
+  try {
+    next = applyScoreOperations(score, operations);
+  } catch (error) {
+    if (error instanceof ScoreValidationError)
+      return { ok: false, message: `progression · ${error.message}` };
+    throw error;
+  }
+  const end = next.notes.reduce(
+    (max, note) => Math.max(max, note.startTick + note.durationTicks),
+    0,
+  );
+  const needed = Math.min(
+    SCORE_LIMITS.maxBars,
+    Math.ceil(end / barTicks(next)),
+  );
+  const grew = needed > next.bars;
+  if (grew)
+    next = applyScoreOperations(next, [{ type: "setBars", bars: needed }]);
+  const flats = keyUsesFlats(key);
+  const names = chords.map((chord) => chordName(chord, flats));
+  return {
+    ok: true,
+    message: `progression · ${names.join(" ")} · ${each} beats each · ${performed.length} notes${grew ? ` · song now ${needed} bars` : ""}`,
+    next,
+    kind: "score.notes",
+    payload: { trackId, progression: names },
+  };
+}

package/src/commands/resample.ts

@@ -0,0 +1,281 @@
+/**
+ * `resample <track> | orbit <n> | master [section <name> | bars a-b] [post]
+ * [grain] [as <id>]` (0.6.1): render a track, an orbit or the mix to
+ * `tracks/<slug>/samples/<name>.wav`, pin its sha256, record where it came
+ * from (`from`: source, section or bars, the source score's sha256) and add
+ * a track that plays it: a one-shot sampler track whose single note starts
+ * where the range starts and lasts the range, or with `grain` a granular
+ * track (the `cloud` preset) holding one note across the range. The source
+ * stays as it is; mute it to hear only the resample.
+ */
+import { mkdir, realpath, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { MAX_ORBIT } from "../../core/fx.ts";
+import { GRANULAR_INSTRUMENT } from "../../core/granular.ts";
+import {
+  ScoreValidationError,
+  SCORE_LIMITS,
+  TrackScore,
+  addTrack,
+  type SampleRef,
+  type TrackInput,
+} from "../../core/score.ts";
+import { trackDirectories } from "../../core/sdk/print.ts";
+import { barTicks } from "../../core/sections.ts";
+import {
+  RESAMPLE_GAIN,
+  renderResample,
+  type ResampleRender,
+  type ResampleRequest,
+} from "../audio/resample.ts";
+import type { SampleBank } from "../audio/samples.ts";
+
+export type ResampleCommand = ResampleRequest &
+  Readonly<{
+    /** Make a granular track instead of a sampler track. */
+    grain: boolean;
+    /** The new track's id (default `<source>-rs` or `<source>-grain`). */
+    as?: string;
+  }>;
+
+export const RESAMPLE_USAGE =
+  "resample <track>|orbit <n>|master [section <name>|bars a-b] [post] [grain] [as <id>]";
+
+const ID = /^[a-z][a-z0-9_-]{0,63}$/;
+
+/** Parse `resample ...` (with or without the slash). */
+export function parseResampleCommand(
+  command: string,
+): ResampleCommand | undefined {
+  const words = command.trim().split(/\s+/);
+  const head = words[0]?.toLowerCase().replace(/^\//, "");
+  if (head !== "resample" && head !== "bounce") return undefined;
+  let index = 1;
+  const next = () => words[index++];
+  const peek = () => words[index]?.toLowerCase();
+  let source: ResampleRequest["source"] | undefined;
+  const first = next();
+  if (first === undefined) return undefined;
+  if (first.toLowerCase() === "orbit") {
+    const n = Number(next());
+    if (!Number.isInteger(n) || n < 1 || n > MAX_ORBIT) return undefined;
+    source = { kind: "orbit", orbit: n };
+  } else if (first.toLowerCase() === "master" || first.toLowerCase() === "mix")
+    source = { kind: "master" };
+  else if (first.toLowerCase() === "track") {
+    const id = next();
+    if (!id) return undefined;
+    source = { kind: "track", trackId: id };
+  } else source = { kind: "track", trackId: first };
+  let range: ResampleRequest["range"] = { kind: "song" };
+  let post = false;
+  let grain = false;
+  let as: string | undefined;
+  while (index < words.length) {
+    const word = peek();
+    index += 1;
+    if (word === "section") {
+      // A section name runs to the next keyword.
+      const parts: string[] = [];
+      while (
+        index < words.length &&
+        !["post", "grain", "granular", "as", "bars"].includes(peek()!)
+      )
+        parts.push(next()!);
+      if (parts.length === 0) return undefined;
+      range = { kind: "section", name: parts.join(" ") };
+    } else if (word === "bars" || word === "bar") {
+      const match = /^(\d{1,4})(?:-(\d{1,4}))?$/.exec(next() ?? "");
+      if (!match) return undefined;
+      const from = Number(match[1]);
+      range = { kind: "bars", from, to: Number(match[2] ?? from) };
+    } else if (word === "post" || word === "master") post = true;
+    else if (word === "pre") post = false;
+    else if (word === "grain" || word === "granular") grain = true;
+    else if (word === "as") {
+      as = next()?.toLowerCase();
+      if (!as || !ID.test(as)) return undefined;
+    } else return undefined;
+  }
+  return {
+    source,
+    range,
+    ...(post ? { post } : {}),
+    grain,
+    ...(as ? { as } : {}),
+  };
+}
+
+/** A free track id near `base`: `base`, `base-2`, … */
+export function freeTrackId(score: TrackScore, base: string): string {
+  const stem = base.slice(0, 56);
+  const used = new Set(score.tracks.map((track) => track.id));
+  if (!used.has(stem)) return stem;
+  for (let n = 2; ; n += 1)
+    if (!used.has(`${stem}-${n}`)) return `${stem}-${n}`;
+}
+
+function sourceStem(command: ResampleCommand): string {
+  const source = command.source;
+  const base =
+    source.kind === "track"
+      ? source.trackId.toLowerCase().replace(/[^a-z0-9_-]/g, "")
+      : source.kind === "orbit"
+        ? `orbit${source.orbit}`
+        : "mix";
+  return /^[a-z]/.test(base) ? base : `t${base}`;
+}
+
+/** The sample's file name (without extension) from source and range. */
+export function resampleFileName(command: ResampleCommand): string {
+  const range = command.range;
+  const suffix =
+    range.kind === "section"
+      ? `-${range.name
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, "-")
+          .replace(/^-|-$/g, "")}`
+      : range.kind === "bars"
+        ? `-b${range.from}-${range.to}`
+        : "";
+  return `${sourceStem(command)}${suffix}`.slice(0, 48) || "resample";
+}
+
+/**
+ * The score with the new track: a one-shot sampler voice (or a granular
+ * source) at `src`, and its one note across the range.
+ */
+export function addResampleTrack(
+  score: TrackScore,
+  command: ResampleCommand,
+  render: Pick<
+    ResampleRender,
+    "sha256" | "startTick" | "durationTicks" | "from"
+  >,
+  trackId: string,
+  src: string,
+): TrackScore {
+  const ref: SampleRef = {
+    src,
+    sha256: render.sha256,
+    from: render.from,
+    // A bounce starts at full level: no anti-click fade-in.
+    ...(command.grain ? {} : { gain: RESAMPLE_GAIN, fadeInTime: 0 }),
+  };
+  const track: TrackInput = command.grain
+    ? {
+        id: trackId,
+        name: trackId,
+        instrument: GRANULAR_INSTRUMENT,
+        granular: { src: ref, preset: "cloud" },
+      }
+    : {
+        id: trackId,
+        name: trackId,
+        instrument: "sampler",
+        sampler: {
+          mode: "oneshot",
+          voices: { [trackId.replace(/-/g, "_").slice(0, 32)]: ref },
+        },
+      };
+  let next = addTrack(score, track as TrackInput);
+  // One-shot slot 36 plays the only voice; a granular note at its root (60)
+  // plays the source at its own pitch.
+  const pitch = command.grain ? 60 : 36;
+  const notes = next.notes;
+  let n = 1;
+  while (notes.some((note) => note.id === `${trackId}-${n}`)) n += 1;
+  const ticks = Math.min(render.durationTicks, next.bars * barTicks(next));
+  next = new TrackScore({
+    ...next.toJSON(),
+    notes: [
+      ...notes,
+      {
+        id: `${trackId}-${n}`,
+        trackId,
+        startTick: render.startTick,
+        durationTicks: Math.max(1, ticks),
+        pitch,
+        velocity: 1,
+      },
+    ],
+  } as never);
+  return next;
+}
+
+export type ResampleResult =
+  | Readonly<{
+      ok: true;
+      next: TrackScore;
+      trackId: string;
+      src: string;
+      sha256: string;
+      message: string;
+    }>
+  | Readonly<{ ok: false; message: string }>;
+
+/**
+ * Render, write the file under the new track's directory and return the
+ * score with the new track. `samples` is the loaded bank of `score`.
+ */
+export async function runResample(
+  options: Readonly<{
+    projectRoot: string;
+    score: TrackScore;
+    command: ResampleCommand;
+    samples?: SampleBank;
+  }>,
+): Promise<ResampleResult> {
+  const { score, command } = options;
+  if (score.tracks.length >= SCORE_LIMITS.maxTracks)
+    return {
+      ok: false,
+      message: `resample · the song already has ${SCORE_LIMITS.maxTracks} tracks`,
+    };
+  let render: ResampleRender;
+  try {
+    render = renderResample(score, command, options.samples);
+  } catch (error) {
+    if (error instanceof ScoreValidationError)
+      return {
+        ok: false,
+        message: `resample · ${error.message} · ${RESAMPLE_USAGE}`,
+      };
+    throw error;
+  }
+  const trackId =
+    command.as ??
+    freeTrackId(
+      score,
+      `${sourceStem(command)}-${command.grain ? "grain" : "rs"}`,
+    );
+  if (score.tracks.some((track) => track.id === trackId))
+    return { ok: false, message: `resample · track ${trackId} already exists` };
+  // The directory follows the score that will hold the track.
+  const probe = addTrack(score, { id: trackId, name: trackId });
+  const slug = trackDirectories(probe).get(trackId) ?? trackId;
+  const root = await realpath(options.projectRoot);
+  const dir = join(root, "tracks", slug, "samples");
+  await mkdir(dir, { recursive: true });
+  const name = `${resampleFileName(command)}.wav`;
+  const target = join(dir, name);
+  const temporary = `${target}.${process.pid}.tmp`;
+  await writeFile(temporary, render.wav);
+  await rename(temporary, target);
+  const src = `samples/${name}`;
+  const next = addResampleTrack(score, command, render, trackId, src);
+  const what =
+    command.source.kind === "track"
+      ? command.source.trackId
+      : command.source.kind === "orbit"
+        ? `orbit ${command.source.orbit}`
+        : "the mix";
+  return {
+    ok: true,
+    next,
+    trackId,
+    src: `tracks/${slug}/${src}`,
+    sha256: render.sha256,
+    message: `resampled ${what} · ${render.seconds.toFixed(2)} s → tracks/${slug}/${src} · ${render.sha256.slice(0, 12)} · new ${command.grain ? "granular" : "sampler"} track ${trackId}${command.source.kind === "track" ? ` · mute ${command.source.trackId} to hear only the resample` : ""}`,
+  };
+}

package/src/commands/rhythm.ts

@@ -120,6 +120,9 @@ export function parseRhythmCommand(prompt: string): RhythmCommand | undefined {
       fields[key] = Number(raw);
     }
   }
+  // `euclid hat` alone names a row to edit: the window opens the editor on
+  // it (`/euclid hat`), so it is not an empty edit here.
+  if (Object.keys(fields).length === 0) return undefined;
   return { type: "rhythm-set", voice: lowerDrum(voice), fields };
 }