@hraness/dawg 0.6.1 → 0.8.0

package/core/sections.ts

@@ -13,9 +13,19 @@
  */
 import { DRUM_VOICES, isDrumInstrument } from "./drums.ts";
 import { FX_LANES } from "./fx.ts";
+import { synthKit } from "./kits.ts";
 import { resolveString } from "./strings.ts";
 import { modalSettings, windSettings } from "./resonators.ts";
-import { slicePedals } from "./expression.ts";
+import { resolveSing } from "./sing.ts";
+import { slicePedals, type PedalEvent, type PedalState } from "./expression.ts";
+import {
+  bakeClipTime,
+  copyClipBars,
+  deleteClipBars,
+  insertClipBars,
+  sliceClips,
+  type ClipPiece,
+} from "./clips.ts";
 import {
   SCORE_LIMITS,
   withNoteCap,
@@ -23,6 +33,7 @@ import {
   TrackScore,
   isSamplerInstrument,
   wavetableOf,
+  type AudioClip,
   type AutomationPoint,
   type FormEntry,
   type Note,
@@ -32,10 +43,10 @@ import {
 } from "./score.ts";
 import {
   barStartTick,
-  bpmAtTick,
   hasTrackTime,
   normalizeSongTime,
   performedNotes,
+  timeMapFor,
   type Fermata,
   type SongTime,
   type TempoEvent,
@@ -61,6 +72,11 @@ export function sliceSongTime(
     };
   const clampBpm = (bpm: number) =>
     Math.min(SCORE_LIMITS.maxTempoBpm, Math.max(SCORE_LIMITS.minTempoBpm, bpm));
+  // The written tempo: a fermata's hold belongs to its own beat and moves
+  // with it, so it must not leak into the tempo restated at a seam.
+  const map = timeMapFor(score);
+  const bpmAtTick = (_score: TrackScore, tick: number) =>
+    map ? map.tempoAt(tick) : score.tempoBpm;
   const sorted = [...pieces].sort((a, b) => a.offset - b.offset);
   const first = sorted[0];
   const tempoBpm = clampBpm(
@@ -147,7 +163,10 @@ export function bakeTrackTime(
     () =>
       new TrackScore({
         ...score.toJSON(),
-        tracks: score.tracks.map(({ time: _time, ...track }) => track),
+        tracks: score.tracks.map((track) => {
+          const { time: _time, ...rest } = bakeClipTime(track);
+          return rest;
+        }),
         notes,
       }),
   );
@@ -394,8 +413,73 @@ export function applySectionChanges(score: TrackScore): TrackScore {
     }
     notes.push(cut);
   }
+  // Clips (0.7): a section that mutes a track silences its clips there, its
+  // variation gain scales them; a clip crossing such an edge is cut.
+  const total = Math.max(
+    score.bars,
+    ...score.sections.map((s) => s.startBar + s.bars),
+  );
+  const clipTracks = score.tracks.map((track) => {
+    if (!track.clips) return track;
+    const pieces: ClipPiece[] = [];
+    for (let bar = 0; bar < total; bar += 1) {
+      const section = sectionAtBar(score, bar);
+      pieces.push({
+        from: bar * ticks,
+        to: (bar + 1) * ticks,
+        offset: bar * ticks,
+        ...clipPieceState(section, track.id),
+      });
+    }
+    // The last bar runs on, so a clip sounding past the end is not cut.
+    if (pieces.length > 0)
+      pieces[pieces.length - 1] = {
+        ...pieces[pieces.length - 1]!,
+        to: SCORE_LIMITS.maxTick + 1,
+      };
+    const next = withClips(track, sliceClips(track.clips, pieces, score));
+    if (JSON.stringify(next.clips) !== JSON.stringify(track.clips))
+      changed = true;
+    return next;
+  });
   if (!changed) return score;
-  return new TrackScore({ ...score.toJSON(), notes, sections: [], form: [] });
+  return new TrackScore({
+    ...score.toJSON(),
+    tracks: clipTracks,
+    notes,
+    sections: [],
+    form: [],
+  });
+}
+
+/** A section's mute and variation gain for one track's clips. */
+function clipPieceState(
+  section: Section | undefined,
+  trackId: string,
+): Pick<ClipPiece, "mute" | "gain"> {
+  if (!section) return {};
+  if (section.mute?.includes(trackId)) return { mute: true };
+  const gain = section.vary?.[trackId]?.gain;
+  return gain === undefined || gain === 1 ? {} : { gain };
+}
+
+/** `track` with `clips` (absent when empty). */
+function withClips(
+  track: Track,
+  clips: readonly AudioClip[] | undefined,
+): Track {
+  const { clips: _clips, ...rest } = track;
+  return clips && clips.length > 0 ? { ...rest, clips } : rest;
+}
+
+/** A track's clips cut to `pieces` (sections, forms, windows). */
+function sliceTrackClips(
+  track: Track,
+  pieces: readonly ClipPiece[],
+  time: TrackScore,
+): Track {
+  if (!track.clips) return track;
+  return withClips(track, sliceClips(track.clips, pieces, time));
 }
 
 /**
@@ -433,9 +517,13 @@ export function sectionScore(score: TrackScore, section: Section): TrackScore {
     time: timed.time ?? null,
     bars: section.bars,
     tracks: score.tracks.map((track) =>
-      slicePedals(
-        mapAutomation(track, (points) => cropPoints(points, from, to)),
-        [{ from, to, offset: 0 }],
+      sliceTrackClips(
+        slicePedals(
+          mapAutomation(track, (points) => cropPoints(points, from, to)),
+          [{ from, to, offset: 0 }],
+        ),
+        [{ from, to, offset: 0, ...clipPieceState(section, track.id) }],
+        score,
       ),
     ),
     notes,
@@ -447,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",
@@ -460,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) {
@@ -490,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) {
@@ -505,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);
@@ -594,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}`,
@@ -602,6 +693,77 @@ function checkBars(bars: number): void {
     );
 }
 
+/**
+ * The song tempo map, fermatas and pedal lanes for a ripple edit that lays
+ * `pieces` of the score end to end: they move with the music they belong
+ * to, as notes and automation do.
+ */
+function rippleTime(
+  score: TrackScore,
+  pieces: readonly { from: number; to: number; offset: number }[],
+): Readonly<{
+  tempoBpm: number;
+  time: SongTime | null;
+  pedals: (track: Track) => Track;
+}> {
+  const kept = pieces.filter((piece) => piece.to > piece.from);
+  const timed = sliceSongTime(
+    score,
+    kept.map((piece) => ({
+      ...piece,
+      to: Math.min(piece.to, SCORE_LIMITS.maxTick + 1),
+    })),
+  );
+  return {
+    tempoBpm: timed.tempoBpm,
+    time: timed.time ?? null,
+    pedals: (track) => {
+      if (!track.pedal && !track.softPedal && !track.sostenuto) return track;
+      const out: Record<string, unknown> = { ...track };
+      for (const field of ["pedal", "softPedal", "sostenuto"] as const) {
+        const events = track[field];
+        if (!events) continue;
+        const next = ripplePedal(events, kept);
+        if (next) out[field] = next;
+        else delete out[field];
+      }
+      return out as Track;
+    },
+  };
+}
+
+/**
+ * A pedal lane for `pieces` laid end to end with no lift at the seams (unlike
+ * a render slice): each piece starts in the state its source was in, and a
+ * gap left between pieces (inserted bars) holds the state before it.
+ */
+function ripplePedal(
+  events: readonly PedalEvent[],
+  pieces: readonly { from: number; to: number; offset: number }[],
+): readonly PedalEvent[] | undefined {
+  const byTick = new Map<number, PedalState>();
+  for (const { from, to, offset } of pieces) {
+    let state: PedalState = "up";
+    for (const event of events) {
+      if (event.tick > from) break;
+      state = event.state;
+    }
+    byTick.set(offset, state);
+    for (const event of events)
+      if (event.tick > from && event.tick < to)
+        byTick.set(event.tick - from + offset, event.state);
+  }
+  const out: PedalEvent[] = [];
+  let last: PedalState = "up";
+  for (const tick of [...byTick.keys()].sort((a, b) => a - b)) {
+    const state = byTick.get(tick)!;
+    if (state === last) continue;
+    out.push({ tick, state });
+    last = state;
+  }
+  return out.length > 0 ? out : undefined;
+}
+
 /** Insert `count` empty bars at `atBar`, shifting later music and sections. */
 export function insertBars(
   score: TrackScore,
@@ -613,16 +775,32 @@ export function insertBars(
   const ticks = barTicks(score);
   const at = atBar * ticks;
   const shift = count * ticks;
+  const ripple = rippleTime(score, [
+    { from: 0, to: at, offset: 0 },
+    { from: at, to: Infinity, offset: at + shift },
+  ]);
   return new TrackScore({
     ...score.toJSON(),
+    tempoBpm: ripple.tempoBpm,
+    time: ripple.time,
     bars: score.bars + count,
     tracks: score.tracks.map((track) =>
-      mapAutomation(track, (points) => insertPoints(points, at, shift)),
+      insertClipBars(
+        mapAutomation(ripple.pedals(track), (points) =>
+          insertPoints(points, at, shift),
+        ),
+        at,
+        shift,
+      ),
     ),
+    // A note's start and end stay with the music they sit in, so one held
+    // across the insertion point sounds on through the new bars.
     notes: score.notes.map((note) =>
       note.startTick >= at
         ? { ...note, startTick: note.startTick + shift }
-        : note,
+        : note.startTick + note.durationTicks > at
+          ? { ...note, durationTicks: note.durationTicks + shift }
+          : note,
     ),
     sections: score.sections.map((section) =>
       section.startBar >= atBar
@@ -631,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,
   });
 }
 
@@ -640,6 +826,12 @@ export function deleteBars(
   atBar: number,
   count: number,
 ): TrackScore {
+  if (!Number.isInteger(atBar) || atBar < 0 || !Number.isInteger(count))
+    throw new ScoreValidationError(
+      `bars to delete must start at a whole bar inside the song`,
+    );
+  // Only bars inside the song can go (a section may sit past its end).
+  count = Math.min(atBar + count, score.bars) - atBar;
   if (count <= 0) return score;
   if (count >= score.bars)
     throw new ScoreValidationError("a song keeps at least one bar");
@@ -647,16 +839,21 @@ export function deleteBars(
   const at = atBar * ticks;
   const end = (atBar + count) * ticks;
   const shift = count * ticks;
+  // Each note's start and end stay with the music they sit in; the part
+  // inside the deleted bars goes, so a note running out of them keeps its
+  // tail and one running into them is cut where they start.
+  const place = (tick: number) =>
+    tick < at ? tick : tick < end ? at : tick - shift;
   const notes: Note[] = [];
   for (const note of score.notes) {
-    if (note.startTick >= end)
-      notes.push({ ...note, startTick: note.startTick - shift });
-    else if (note.startTick < at)
-      notes.push(
-        note.startTick + note.durationTicks > at
-          ? { ...note, durationTicks: at - note.startTick }
-          : note,
-      );
+    const startTick = place(note.startTick);
+    const stop = place(note.startTick + note.durationTicks);
+    if (stop <= startTick) continue;
+    notes.push(
+      startTick === note.startTick && stop - startTick === note.durationTicks
+        ? note
+        : { ...note, startTick, durationTicks: stop - startTick },
+    );
   }
   const sections: Section[] = [];
   for (const section of score.sections) {
@@ -677,18 +874,48 @@ export function deleteBars(
     }
   }
   const names = new Set(sections.map((section) => foldName(section.name)));
+  const ripple = rippleTime(score, [
+    { from: 0, to: at, offset: 0 },
+    { from: end, to: Infinity, offset: at },
+  ]);
   return new TrackScore({
     ...score.toJSON(),
+    tempoBpm: ripple.tempoBpm,
+    time: ripple.time,
     bars: score.bars - count,
     tracks: score.tracks.map((track) =>
-      mapAutomation(track, (points) => deletePoints(points, at, shift)),
+      deleteClipBars(
+        mapAutomation(ripple.pedals(track), (points) =>
+          deletePoints(points, at, shift),
+        ),
+        at,
+        end,
+      ),
     ),
     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));
@@ -865,6 +1092,15 @@ export function duplicateSection(
   if (options.as !== undefined && findSection(score, options.as))
     throw new ScoreValidationError(`a section named ${options.as} exists`);
   const at = options.toBar ?? section.startBar + section.bars;
+  if (
+    !Number.isInteger(at) ||
+    at < 0 ||
+    at > score.bars ||
+    (at > section.startBar && at < section.startBar + section.bars)
+  )
+    throw new ScoreValidationError(
+      `a copy of ${section.name} goes at a bar 1..${score.bars + 1} outside it`,
+    );
   const opened = insertBars(score, at, section.bars);
   const source =
     section.startBar >= at ? section.startBar + section.bars : section.startBar;
@@ -881,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(),
@@ -908,10 +1169,28 @@ export function copyBars(
         Math.min(note.durationTicks, from + length - note.startTick),
       ),
     }));
+  // The copied bars bring their tempo, fermatas and pedal; the music after
+  // them goes on as it was.
+  const ripple = rippleTime(score, [
+    { from: 0, to, offset: 0 },
+    { from, to: from + length, offset: to },
+    { from: to + length, to: Infinity, offset: to + length },
+  ]);
+  const song = options.trackIds === undefined;
   return new TrackScore({
     ...score.toJSON(),
+    ...(song ? { tempoBpm: ripple.tempoBpm, time: ripple.time } : {}),
     tracks: score.tracks.map((track) =>
-      mapAutomation(track, (points) => copyPoints(points, from, length, to)),
+      picked(track.id)
+        ? copyClipBars(
+            mapAutomation(ripple.pedals(track), (points) =>
+              copyPoints(points, from, length, to),
+            ),
+            from,
+            length,
+            to,
+          )
+        : track,
     ),
     notes: [...kept, ...copies],
   });
@@ -1027,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,
@@ -1235,17 +1637,38 @@ export function arrangedSlice(
 ): TrackScore {
   const ticks = barTicks(score);
   const pieces: { from: number; to: number; offset: number }[] = [];
+  // Clips (0.7) are cut per section pass; a window's own edges inside a
+  // pass (or where the form plays straight on) are seams, never cuts, so a
+  // windowed render plays them as one pass does.
+  const clipPieces: (ClipPiece & { section: Section })[] = [];
   const end = fromBar + bars;
+  let previous: FormSegment | undefined;
   for (const segment of formSegments(score)) {
     const segEnd = segment.startBar + segment.bars;
+    const before = previous;
+    previous = segment;
     if (segEnd <= fromBar || segment.startBar >= end) continue;
     const start = Math.max(segment.startBar, fromBar);
     const stop = Math.min(segEnd, end);
     const from = (segment.section.startBar + start - segment.startBar) * ticks;
-    pieces.push({
+    const piece = {
       from,
       to: from + (stop - start) * ticks,
       offset: (start - fromBar) * ticks,
+    };
+    pieces.push(piece);
+    const straight =
+      before !== undefined &&
+      before.section.startBar + before.bars === segment.section.startBar;
+    clipPieces.push({
+      ...piece,
+      section: segment.section,
+      ...(stop < segEnd ? { to: from + (segEnd - start) * ticks } : {}),
+      ...(clipPieces.length === 0 &&
+      fromBar > 0 &&
+      (start > segment.startBar || straight)
+        ? { seam: true }
+        : {}),
     });
   }
   const shift = fromBar * ticks;
@@ -1256,7 +1679,14 @@ export function arrangedSlice(
     time: timed.time ?? null,
     bars,
     tracks: score.tracks.map((track) =>
-      slicePedals(sliceLanes(track, pieces), pieces),
+      sliceTrackClips(
+        slicePedals(sliceLanes(track, pieces), pieces),
+        clipPieces.map(({ section, ...piece }) => ({
+          ...piece,
+          ...clipPieceState(section, track.id),
+        })),
+        score,
+      ),
     ),
     notes: arrangedNotes(score, fromBar, fromBar + noteBars).map((note) => ({
       ...note,
@@ -1341,7 +1771,11 @@ function laneFallback(track: Track, lane: string): number | undefined {
             ? track.modal && modalSettings(track.modal)
             : spec.effect === "wind"
               ? track.wind && windSettings(track.wind)
-              : (track.fx as Record<string, unknown> | undefined)?.[spec.effect]
+              : spec.effect === "sing"
+                ? track.sing && resolveSing(track.sing)
+                : (track.fx as Record<string, unknown> | undefined)?.[
+                    spec.effect
+                  ]
   ) as Record<string, unknown> | undefined;
   const stored = source?.[spec.param];
   return typeof stored === "number" ? stored : spec.spec.default;
@@ -1364,6 +1798,8 @@ const TOM = DRUM_VOICES.find((voice) => voice.voice === "tom")!.pitch;
 const TOMS = [50, 47, TOM] as const;
 const KICK = DRUM_VOICES.find((voice) => voice.voice === "kick")!.pitch;
 const OPEN_HAT = DRUM_VOICES.find((voice) => voice.voice === "openhat")!.pitch;
+/** GM crash 1, which calibration 1+ renders as a cymbal. */
+const CRASH = 49;
 
 /** Generator tracks, reused by later builds and drops. */
 export const GENERATOR_TRACKS = Object.freeze({
@@ -1955,7 +2391,10 @@ export type FillOptions = Readonly<{
   /** Beats the fill lasts, default 1. */
   beats?: number;
   style?: FillStyle;
-  /** Crash (open hat with kick) on the next downbeat, default on. */
+  /**
+   * Crash with kick on the next downbeat, default on: GM 49 on a
+   * calibrated song's synth kit, else an open hat.
+   */
   crash?: boolean;
 }>;
 
@@ -2000,6 +2439,12 @@ export function generateFill(
     drums = GENERATOR_TRACKS.fills;
   }
   const style = options.style ?? "toms";
+  // Sample kits and legacy songs have no cymbal voice: keep the open hat.
+  const kit = next.tracks.find((track) => track.id === drums)?.kit;
+  const crash =
+    (next.calibration ?? 0) >= 1 && (kit === undefined || synthKit(kit))
+      ? CRASH
+      : OPEN_HAT;
   const clamped: string[] = [];
   const beats = clampNote(
     options.beats ?? 1,
@@ -2030,8 +2475,8 @@ export function generateFill(
               : SNARE
             : progress < 0.25
               ? SNARE
-              : // High, mid, low tom down the fill (GM 50/47/45); the
-                // built-in kit folds all three onto its tom.
+              : // High, mid, low tom down the fill (GM 50/47/45); a
+                // calibrated song pitches them, older songs fold them.
                 TOMS[Math.min(2, Math.floor(((progress - 0.25) / 0.75) * 3))]!;
       fill.push({
         id: nextId(),
@@ -2043,7 +2488,7 @@ export function generateFill(
       });
     }
     if ((options.crash ?? true) && end < next.bars * ticks)
-      for (const pitch of [OPEN_HAT, KICK])
+      for (const pitch of [crash, KICK])
         fill.push({
           id: nextId(),
           trackId: drums,