@hraness/dawg 0.7.0 → 0.8.0

package/core/sections.ts

@@ -535,9 +535,9 @@ export function sectionScore(score: TrackScore, section: Section): TrackScore {
 // ---------------------------------------------------------------------------
 // Automation over time edits
 
-type Points = readonly AutomationPoint[];
+export type Points = readonly AutomationPoint[];
 
-const TRACK_LANES = [
+export const TRACK_LANES = [
   "volumeAutomation",
   "panAutomation",
   "filterAutomation",
@@ -548,7 +548,10 @@ const TRACK_LANES = [
 ] as const;
 
 /** Applies `edit` to every automation lane of `track`. */
-function mapAutomation(track: Track, edit: (points: Points) => Points): Track {
+export function mapAutomation(
+  track: Track,
+  edit: (points: Points) => Points,
+): Track {
   const out: Record<string, unknown> = { ...track };
   let changed = false;
   for (const field of TRACK_LANES) {
@@ -578,7 +581,7 @@ function mapAutomation(track: Track, edit: (points: Points) => Points): Track {
 }
 
 /** The lane value at `tick` (undefined before the first point). */
-function valueAt(points: Points, tick: number): number | undefined {
+export function valueAt(points: Points, tick: number): number | undefined {
   const first = points[0];
   if (!first || tick < first.tick) return undefined;
   for (let index = 1; index < points.length; index += 1) {
@@ -593,7 +596,7 @@ function valueAt(points: Points, tick: number): number | undefined {
   return points[points.length - 1]!.value;
 }
 
-function sortPoints(points: AutomationPoint[]): Points {
+export function sortPoints(points: AutomationPoint[]): Points {
   const byTick = new Map<number, AutomationPoint>();
   for (const point of points) byTick.set(point.tick, point);
   return [...byTick.values()].sort((a, b) => a.tick - b.tick);
@@ -682,7 +685,7 @@ function copyPoints(
 // ---------------------------------------------------------------------------
 // Ripple edits
 
-function checkBars(bars: number): void {
+export function checkBars(bars: number): void {
   if (bars > SCORE_LIMITS.maxBars)
     throw new ScoreValidationError(
       `the song would be ${bars} bars; the limit is ${SCORE_LIMITS.maxBars}`,
@@ -806,6 +809,14 @@ export function insertBars(
           ? { ...section, bars: section.bars + count }
           : section,
     ),
+    // The loop range moves (or grows) like a section.
+    loop: score.loop
+      ? score.loop.startBar >= atBar
+        ? { ...score.loop, startBar: score.loop.startBar + count }
+        : score.loop.startBar + score.loop.bars > atBar
+          ? { ...score.loop, bars: score.loop.bars + count }
+          : score.loop
+      : null,
   });
 }
 
@@ -884,9 +895,27 @@ export function deleteBars(
     notes,
     sections,
     form: score.form.filter((entry) => names.has(foldName(entry.section))),
+    loop: score.loop ? shrinkRange(score.loop, atBar, count) : null,
   });
 }
 
+/** A bar range after bars `atBar..atBar+count` go (null when it goes too). */
+function shrinkRange(
+  range: Readonly<{ startBar: number; bars: number }>,
+  atBar: number,
+  count: number,
+): { startBar: number; bars: number } | null {
+  const until = range.startBar + range.bars;
+  if (until <= atBar) return range;
+  if (range.startBar >= atBar + count)
+    return { startBar: range.startBar - count, bars: range.bars };
+  const left = Math.max(0, atBar - range.startBar);
+  const right = Math.max(0, until - (atBar + count));
+  return left + right > 0
+    ? { startBar: Math.min(range.startBar, atBar), bars: left + right }
+    : null;
+}
+
 /** Unused note ids `prefix1`, `prefix2`, ... */
 function idMaker(score: TrackScore, prefix: string): () => string {
   const used = new Set(score.notes.map((note) => note.id));
@@ -1088,24 +1117,49 @@ export function duplicateSection(
   );
 }
 
-/** Copy the music of bars `from..from+count` onto bars `to..` (replacing it). */
+/** Options for `copyBars`: which tracks, and whether the copy overdubs. */
+export type CopyBarsOptions = Readonly<{
+  /** Only these tracks (default all). A track subset leaves tempo alone. */
+  trackIds?: ReadonlySet<string>;
+  /** Overdub: keep the destination's notes (default replaces them). */
+  merge?: boolean;
+}>;
+
+/**
+ * Copy the music of bars `from..from+count` onto bars `to..` (replacing it,
+ * or with `merge` overdubbing it). All tracks bring the song's tempo and
+ * fermatas with them; a track subset copies only its own notes, clips,
+ * pedal and automation.
+ */
 export function copyBars(
   score: TrackScore,
   fromBar: number,
   count: number,
   toBar: number,
   idPrefix = "copy-",
+  options: CopyBarsOptions = {},
 ): TrackScore {
   const ticks = barTicks(score);
   const from = fromBar * ticks;
   const length = count * ticks;
   const to = toBar * ticks;
   const nextId = idMaker(score, idPrefix);
+  const picked = (trackId: string): boolean =>
+    options.trackIds === undefined || options.trackIds.has(trackId);
   const kept = score.notes.filter(
-    (note) => note.startTick < to || note.startTick >= to + length,
+    (note) =>
+      options.merge ||
+      !picked(note.trackId) ||
+      note.startTick < to ||
+      note.startTick >= to + length,
   );
   const copies = score.notes
-    .filter((note) => note.startTick >= from && note.startTick < from + length)
+    .filter(
+      (note) =>
+        picked(note.trackId) &&
+        note.startTick >= from &&
+        note.startTick < from + length,
+    )
     .map((note) => ({
       ...note,
       id: nextId(),
@@ -1122,19 +1176,21 @@ export function copyBars(
     { from, to: from + length, offset: to },
     { from: to + length, to: Infinity, offset: to + length },
   ]);
+  const song = options.trackIds === undefined;
   return new TrackScore({
     ...score.toJSON(),
-    tempoBpm: ripple.tempoBpm,
-    time: ripple.time,
+    ...(song ? { tempoBpm: ripple.tempoBpm, time: ripple.time } : {}),
     tracks: score.tracks.map((track) =>
-      copyClipBars(
-        mapAutomation(ripple.pedals(track), (points) =>
-          copyPoints(points, from, length, to),
-        ),
-        from,
-        length,
-        to,
-      ),
+      picked(track.id)
+        ? copyClipBars(
+            mapAutomation(ripple.pedals(track), (points) =>
+              copyPoints(points, from, length, to),
+            ),
+            from,
+            length,
+            to,
+          )
+        : track,
     ),
     notes: [...kept, ...copies],
   });
@@ -1250,6 +1306,129 @@ export function resetSection(score: TrackScore, name: string): TrackScore {
   });
 }
 
+/**
+ * Split a section at `atBar` (0-based, strictly inside it) into two: the
+ * first keeps the name, the second is `<name> 2` (or `as`). Both keep the
+ * mutes and variations; the form plays both halves wherever it played the
+ * section, and a loop on it becomes the loop range over the same bars.
+ */
+export function splitSection(
+  score: TrackScore,
+  name: string,
+  atBar: number,
+  as?: string,
+): TrackScore {
+  const section = requireSection(score, name);
+  const end = section.startBar + section.bars;
+  if (!Number.isInteger(atBar) || atBar <= section.startBar || atBar >= end)
+    throw new ScoreValidationError(
+      section.bars < 2
+        ? `${section.name} is one bar; nothing to split`
+        : `split ${section.name} at a bar ${section.startBar + 2}..${end}`,
+    );
+  if (as !== undefined && findSection(score, as))
+    throw new ScoreValidationError(`a section named ${as} exists`);
+  const second = uniqueSectionName(score, as ?? `${section.name} 2`);
+  const form: FormEntry[] = [];
+  for (const entry of score.form) {
+    if (foldName(entry.section) !== foldName(section.name)) {
+      form.push(entry);
+      continue;
+    }
+    for (let pass = 0; pass < (entry.repeat ?? 1); pass += 1)
+      form.push({ section: section.name }, { section: second });
+  }
+  if (form.length > SCORE_LIMITS.maxFormEntries)
+    throw new ScoreValidationError(
+      `the form would have ${form.length} entries; the limit is ${SCORE_LIMITS.maxFormEntries}`,
+      "score-limit",
+    );
+  const looping = score.loopSection === section.name;
+  const split = score.withSections(
+    score.sections.flatMap((candidate) =>
+      candidate === section
+        ? [
+            { ...section, bars: atBar - section.startBar },
+            { ...section, name: second, startBar: atBar, bars: end - atBar },
+          ]
+        : [candidate],
+    ),
+    form,
+    looping ? null : score.loopSection,
+  );
+  return looping
+    ? split.withLoop({ startBar: section.startBar, bars: section.bars })
+    : split;
+}
+
+/**
+ * Join a section with the one that starts where it ends; it keeps the
+ * first one's name, mutes and variations. Refused when the two mute or vary
+ * differently (joining would change the sound) unless `force`, or when
+ * the form plays the second anywhere but right after the first.
+ */
+export function joinSection(
+  score: TrackScore,
+  name: string,
+  options: Readonly<{ force?: boolean }> = {},
+): TrackScore {
+  const section = requireSection(score, name);
+  const end = section.startBar + section.bars;
+  const next = score.sections.find((candidate) => candidate.startBar === end);
+  if (!next)
+    throw new ScoreValidationError(
+      `no section starts at bar ${end + 1}, right after ${section.name}`,
+    );
+  const sameMute =
+    JSON.stringify([...(section.mute ?? [])].sort()) ===
+    JSON.stringify([...(next.mute ?? [])].sort());
+  if (
+    !options.force &&
+    (!sameMute ||
+      JSON.stringify(section.vary ?? {}) !== JSON.stringify(next.vary ?? {}))
+  )
+    throw new ScoreValidationError(
+      `${section.name} and ${next.name} mute or vary differently · section join ${section.name} force`,
+    );
+  const form: FormEntry[] = [];
+  const entries = score.form;
+  for (let index = 0; index < entries.length; index += 1) {
+    const entry = entries[index]!;
+    const isFirst = foldName(entry.section) === foldName(section.name);
+    const isSecond = foldName(entry.section) === foldName(next.name);
+    const following = entries[index + 1];
+    if (
+      isFirst &&
+      (entry.repeat ?? 1) === 1 &&
+      following &&
+      foldName(following.section) === foldName(next.name) &&
+      (following.repeat ?? 1) === 1
+    ) {
+      form.push({ section: section.name });
+      index += 1;
+      continue;
+    }
+    if (isFirst || isSecond)
+      throw new ScoreValidationError(
+        `the form plays ${section.name} and ${next.name} apart · change the form first`,
+      );
+    form.push(entry);
+  }
+  const looping =
+    score.loopSection === section.name || score.loopSection === next.name;
+  return score.withSections(
+    score.sections
+      .filter((candidate) => candidate !== next)
+      .map((candidate) =>
+        candidate === section
+          ? { ...section, bars: section.bars + next.bars }
+          : candidate,
+      ),
+    form,
+    looping ? section.name : score.loopSection,
+  );
+}
+
 function omit<T extends object, K extends keyof T>(
   value: T,
   key: K,

package/guides/arrange.md

@@ -4,18 +4,19 @@ title: Arrange
 order: 9
 ---
 
-Notes make tracks, tracks make sections, sections make the form.
+Notes make tracks, bars make sections, sections make the form. Name a
+range of bars and loop, copy or move it.
 
 ## Ask
 
-- "make 16 bars of deep house" · "add a chorus that lifts at bar 9"
+- "loop bars 5 to 6" · "copy the bass in 5-6 to bar 7 twice"
 
 ## Type it yourself
 
-- `add E4 at 2 for 0.5` · `track bass` · `tracks`
-- `section chorus 9-16` · `form verse verse chorus verse`
-- `build into chorus` · `drop chorus` · `fill chorus`
-- `style deep-house 16` · `bars 8` · `extend 4 bars`
+- `loop 5-6` · `loop chorus` · `loop next` · `loop off`
+- `copy bass 5-6 to 7 x2` · `move bass 5-6 to 9` · `clear bass 5-6`
+- `copy all 1-4` then `paste at 9` · `reverse bass 5-6` · `jump 5`
+- `section chorus 9-16` · `form verse chorus` · `form print`
 
 ## Menu
 
@@ -23,8 +24,8 @@ Notes make tracks, tracks make sections, sections make the form.
 
 ## Keys
 
-- `view all` shows every track · Ctrl-O the transcript
+- Ctrl-T TAPE: every track across the bars · `\` loops the section
 
 ## Next
 
-- `guide notes` · `guide tracks` · `guide tempo` · `guide styles`
+- `guide tape` · `guide notes` · `guide tracks` · `guide panes`

package/guides/audio.md

@@ -0,0 +1,31 @@
+---
+id: audio
+title: Audio output and input
+parent: project
+order: 3
+---
+
+One output and one input, or the system default. Saved on this
+machine, not in the song. Needs the native sink (`dawg doctor`).
+
+## Ask
+
+- "which audio output am I using?"
+
+## Type it yourself
+
+- `audio` · `audio out USB Audio Interface` · `audio out default`
+- `audio in Built-in Microphone` · `audio test` (tone, input meter)
+
+## Menu
+
+- Ctrl-K › Project › audio › output · input · test
+
+## Keys
+
+- In a device list: arrows move, Enter picks (a soft blip plays), Esc
+
+## Next
+
+- Unplugged mid-song: playback moves to the default, said once
+- `DAWG_AUDIO_DEVICE` overrides · `guide project`

package/guides/mix.md

@@ -11,7 +11,8 @@ order: 8
 
 ## Type it yourself
 
-- `volume 0.7` (0..1) · `pan -0.4` (-1..1)
+- `volume 0.7` (0..1) · `pan -0.4` (-1..1) · `volume drums 0.5`
+- `knobs` four knobs for this track · `mix` the mixer page
 - `mute` · `unmute` · `solo` · `unsolo`
 - `fx orbit 2` send to a bus · `fx duck preset pump` on the kick
 - `master streaming` · `master target -14` · `master measure`
@@ -23,6 +24,7 @@ order: 8
 ## Keys
 
 - `volume` or `pan` alone opens a fader to drag or step
+- Knobs: ↑↓ pick ● ▲ ■ ◆ · ←→ turn · ⇧ coarse · x reset · Tab more
 
 ## Next
 

package/guides/panes.md

@@ -0,0 +1,32 @@
+---
+id: panes
+title: Panes
+parent: project
+order: 4
+---
+
+Open the same song in several terminals: one plays, one shows TAPE,
+one the knobs. Each pane has a letter and its own undo.
+
+## Ask
+
+- "which panes are open?"
+
+## Type it yourself
+
+- `panes` · `pane tape` (copies `dawg pane tape` to paste elsewhere)
+- `pin` keep this pane on its track · `unpin`
+- `follow b` follow pane B's track · `follow` the latest · `unfollow`
+- `undo` this pane's last edit · `undo all` anyone's
+
+## Menu
+
+- Ctrl-K › Project › session
+
+## Keys
+
+- In a shell: `dawg pane home|play|tape|sound|menu [track] [pin]`
+
+## Next
+
+- `guide sessions` · `guide tape` · `guide project`

package/guides/project.md

@@ -19,7 +19,7 @@ live here; windows on one folder stay in sync.
 
 ## Menu
 
-- Ctrl-K › Project › play · tempo · export · session · agent
+- Ctrl-K › Project › play · tempo · export · session · agent · audio
 
 ## Keys
 
@@ -27,4 +27,5 @@ live here; windows on one folder stay in sync.
 
 ## Next
 
-- `guide files` · `guide sessions` · `guide agent`
+- `guide files` · `guide sessions` · `guide agent` · `guide audio`
+- `guide panes`

package/guides/rhythm.md

@@ -23,7 +23,8 @@ A drum track has one row per drum: kick, snare, hat and more.
 
 ## Keys
 
-- In the euclid editor ↑↓ drum · ←→ adjust · Tab field · Space loop
+- In the euclid editor ↑↓ knob (● drum ▲ pulses ■ rotate
+  ◆ velocity) · ←→ turn · Tab field · Space loop
 
 ## Next
 

package/guides/tape.md

@@ -0,0 +1,32 @@
+---
+id: tape
+title: TAPE
+parent: arrange
+order: 6
+---
+
+Ctrl-T shows every track across the bars. Each key echoes the command
+it runs, so the prompt teaches the typed form. Esc goes back.
+
+## Ask
+
+- "loop the chorus and copy its drums to bar 17"
+
+## Type it yourself
+
+- `tape` · `loop chorus` · `copy drums 9-16 to 17` · `jump 5.3`
+
+## Menu
+
+- Ctrl-K › Arrange › sections · form
+
+## Keys
+
+- ↑↓ pick a knob: ● playhead ▲ loop ■ tempo ◆ volume · ←→ turn it
+- `\` loop the section here · `[` `]` `{` `}` `<` `>` shape the loop
+- `c` copy · `x` cut · `v` paste (`V` inserts) · Delete clear · `~`
+
+## Next
+
+- Form repeats are shaded `░`; an edit there says which copies it hits
+- `dawg pane tape` in another terminal · `guide arrange`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hraness/dawg",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -33,6 +33,7 @@
   "scripts": {
     "dawg": "bun run src/main.ts",
     "bench:perf": "bun bench/perf/run.ts",
+    "sizes": "bun bench/sizes/matrix.ts",
     "test": "bun test",
     "typecheck": "tsc --noEmit",
     "check": "bun test && bun run typecheck && bun run format",

package/src/agent/agent.ts

@@ -1,3 +1,4 @@
+import { newId } from "../../core/ids.ts";
 import type { CommandHost } from "./command-agent.ts";
 import { GRANULAR_PARAMS } from "../../core/granular.ts";
 import {
@@ -201,7 +202,7 @@ export type AgentTurnOptions = Readonly<{
   signal?: AbortSignal;
   budget?: AgentBudget;
   tools?: readonly AgentTool[];
-  /** Note ID factory; defaults to `${track}-${revision}-${nonce}${index}`. */
+  /** Note ID factory; defaults to `newId(track)` (core/ids.ts). */
   newNoteId?: (trackId: string, revision: number, index: number) => string;
 }>;
 
@@ -243,6 +244,7 @@ export const CONTENT_TOOLS: ReadonlySet<string> = new Set([
   "set_automation",
   "add_transition",
   "edit_section",
+  "edit_range",
   "set_form",
   "extend_loop",
   "edit_clip",
@@ -322,11 +324,9 @@ export async function runAgentTurn(
   };
   const tools = options.tools ?? AGENT_TOOLS;
   const chatToolList = chatTools(tools);
-  const nonce = Math.random().toString(36).slice(2, 6);
   const newNoteId =
     options.newNoteId ??
-    ((trackId: string, revision: number, index: number) =>
-      `${trackId.slice(0, 40)}-${revision}-${nonce}${index}`);
+    ((trackId: string, _revision: number, _index: number) => newId(trackId));
   const deadline = turnDeadline(limits.timeoutMs);
   const signal = options.signal
     ? AbortSignal.any([options.signal, deadline.signal])

package/src/agent/command-agent.ts

@@ -10,6 +10,7 @@
  * sends about a ninth of the input tokens and finishes in about half the
  * time (docs/show-me.md).
  */
+import { newId } from "../../core/ids.ts";
 import { HELP_SECTIONS } from "../commands/help.ts";
 import { MEDIA_TOOLS } from "../media/tools.ts";
 import {
@@ -64,15 +65,24 @@ export const COMMAND_MODE_TOOL_NAMES: ReadonlySet<string> = new Set([
 /** Steps per command-mode turn: each extra one is a correction round. */
 export const COMMAND_MAX_STEPS = 4;
 
+/** Reference groups the command agent is not shown. */
+const AGENT_SKIPS: ReadonlySet<string> = new Set([
+  "project · window",
+  "project · panes",
+  "project · audio",
+  "agent",
+]);
+
 function commandReference(): string {
-  // Song commands only: the window and agent groups change the person's
-  // window, which the agent never does.
-  return HELP_SECTIONS.filter(
-    (section) =>
-      section.group !== "project · window" && section.group !== "agent",
-  )
+  // Song commands only. Panes, audio devices and the window groups change the person's window or
+  // machine; the clipboard row is a two-step buffer the agent never needs.
+  return HELP_SECTIONS.filter((section) => !AGENT_SKIPS.has(section.group))
     .flatMap((section) =>
-      section.entries.map((entry) => `${entry.command} — ${entry.summary}`),
+      section.entries
+        .filter(
+          (entry) => !/\bpaste\b/.test(`${entry.command} ${entry.summary}`),
+        )
+        .map((entry) => `${entry.command} — ${entry.summary}`),
     )
     .join("\n");
 }
@@ -81,6 +91,7 @@ export const COMMAND_AGENT_PROMPT = [
   "You are dawg, a loop composer inside a terminal music workstation, and you teach it by doing.",
   "Act by writing dawg prompt commands, exactly as a human types them in the prompt bar, one per line. The user watches each command appear in their prompt bar as you write it, and each line runs the moment it ends, so they learn the commands by watching you.",
   "Prefer the gestures a person would use: a parameter as one value command (fx reverb mix 0.4, volume 0.7, pan -0.3, which the user sees as a fader moving), notes one per line with add (add C4 at 0 for 0.5, played on the user's keyboard as you write them), drums with hit, pattern and euclid on a kit track, a whole groove with groove <name>.",
+  "To arrange, name bars: loop 5-6 loops them, copy bass 5-6 to 7 and move bass 5-6 to 9 place them in one step, clear bass 5-6 empties them. Never copy to the clipboard and paste.",
   "Commands apply to the focused track. /track <name> focuses a track or creates it; instrument kit makes a drum track. Times are beats from 0: in 4/4 musicians' beats 2 and 4 are beats 1 and 3 here, and bar n starts at (n-1)×beats per bar.",
   "Write commands first, with no numbering, quotes or code fences. Then write one short plain sentence (not a command) that says what changed and names the key command so the user can do it by hand next time.",
   "If a command fails you get its error; correct it with another command or stop.",
@@ -132,11 +143,9 @@ export async function runCommandAgentTurn(
   const offered = chatTools(
     allTools.filter((tool) => COMMAND_MODE_TOOL_NAMES.has(tool.name)),
   );
-  const nonce = Math.random().toString(36).slice(2, 6);
   const newNoteId =
     options.newNoteId ??
-    ((trackId: string, revision: number, index: number) =>
-      `${trackId.slice(0, 40)}-${revision}-${nonce}${index}`);
+    ((trackId: string, _revision: number, _index: number) => newId(trackId));
   const deadline = turnDeadline(limits.timeoutMs);
   const signal = options.signal
     ? AbortSignal.any([options.signal, deadline.signal])

package/src/agent/ops.ts

@@ -52,6 +52,8 @@ export type AgentOperation =
       };
       /** The instrument word as typed (a guitar alias also loads its rig). */
       word?: string;
+      /** `volume drums 0.5`: another track than the focused one. */
+      trackId?: string;
     }
   | {
       type: "automation";
@@ -101,6 +103,19 @@ export function parsePrompt(prompt: string): AgentOperation | undefined {
     return { type: "track", patch: { muted: false } };
   const volume = text.match(/^(?:volume|vol)\s+(0(?:\.\d+)?|1(?:\.0+)?)$/);
   if (volume) return { type: "track", patch: { volume: Number(volume[1]) } };
+  // `volume drums 0.5` / `pan bass -0.2`: the mixer page's rows name their
+  // track, so a level is set without moving the focus.
+  const level = text.match(
+    /^(volume|vol|pan)\s+([a-z0-9][a-z0-9._-]{0,63})\s+(-?1(?:\.0+)?|-?0(?:\.\d+)?)$/,
+  );
+  if (level && !(level[1] !== "pan" && level[3]!.startsWith("-"))) {
+    const value = Number(level[3]);
+    return {
+      type: "track",
+      patch: level[1] === "pan" ? { pan: value } : { volume: value },
+      trackId: level[2]!,
+    };
+  }
   const clearAutomation = text.match(
     /^(?:clear|reset)\s+(?:(volume|pan)\s+)?automation$/,
   );

package/src/agent/planner.ts

@@ -178,6 +178,18 @@ function parseOperation(value: unknown): ScoreOperation {
       loopSection: (value.loopSection ?? null) as string | null,
     };
   }
+  if (
+    value.type === "setLoop" &&
+    (value.loop === null ||
+      (isRecord(value.loop) &&
+        typeof value.loop.startBar === "number" &&
+        typeof value.loop.bars === "number"))
+  )
+    // The reducer checks the range (TrackScore normalizeLoopRange).
+    return {
+      type: "setLoop",
+      loop: value.loop as { startBar: number; bars: number } | null,
+    };
   if (
     value.type === "updateTrack" &&
     typeof value.trackId === "string" &&