@hraness/dawg 0.5.0 → 0.6.1

package/src/audio/live.ts

@@ -17,11 +17,48 @@ import {
   type Track,
 } from "../../core/score.ts";
 import { bpmAtTick } from "../../core/tempo.ts";
-import { sampleKey, type SampleBank } from "./samples.ts";
+import { EMPTY_SAMPLE_BANK, sampleKey, type SampleBank } from "./samples.ts";
 import { RENDER_CHANNELS, renderScorePcm } from "./wav.ts";
+import { engineFor, RING_OUT_FADE_SECONDS } from "./instruments.ts";
+import { chordDigest, chordTimeline } from "./granular.ts";
+import { resolveGranular } from "../../core/granular.ts";
+import { noteHz, resolveTuning } from "../../core/tuning.ts";
+import { liveFitPending, withLiveFit } from "./fit.ts";
+import { isOrganFamily } from "../../core/keys.ts";
+import type { LiveFullReply, LiveFullRequest } from "./live-worker.ts";
+import { isBowed, liveStringTrack } from "./strings/engine.ts";
+import { resolveString } from "../../core/strings.ts";
 
 /** A rendered live note: interleaved stereo 16-bit PCM. */
-export type LiveNotePcm = Readonly<{ pcm: Int16Array; frames: number }>;
+export type LiveNotePcm = Readonly<{
+  pcm: Int16Array;
+  frames: number;
+  /** Release fade on note-off, in seconds; absent is the 10 ms default. */
+  releaseSeconds?: number;
+  /**
+   * A fitted sample window (0.6 `bpm`/`len`/`fitmode`) longer than 8 s is
+   * still being computed: the note is silent and not cached; play it again
+   * once its background fit (fit.ts `onFitReady`) lands.
+   */
+  fitting?: true;
+  /**
+   * True when this is only the first window of a guitar-rig or bowed note
+   * (`LIVE_RIG_WINDOW_SECONDS`): call `LiveSynth.render` again with
+   * `full: true` off the key path and swap the result in by voice id.
+   */
+  partial?: boolean;
+  /**
+   * The organ clock tick a first window rendered at: pass it back as the
+   * request's `clock` for the full pass so the wheels and rotors continue.
+   */
+  clock?: number;
+  /**
+   * The key's release does not fade the voice: it rings to the end of its
+   * rendered tail (0.6.1 modal `damp 0`), which ends in a `RING_OUT_FADE_SECONDS`
+   * fade when the length cap cut it.
+   */
+  ringOut?: true;
+}>;
 
 export type LiveNoteRequest = Readonly<{
   score: TrackScore;
@@ -35,8 +72,20 @@ export type LiveNoteRequest = Readonly<{
   samples?: SampleBank;
   /** Song tick being played: the tempo there sets length and synced effects. */
   tick?: number;
+  /** Render the whole note even through a guitar rig (the background pass). */
+  full?: boolean;
+  /** An organ note's clock tick from its first window (`LiveNotePcm.clock`). */
+  clock?: number;
 }>;
 
+/**
+ * A guitar rig (stomp, head, cab) is oversampled and costs 15-25 ms per
+ * track-second, so a held note through one first renders only this window,
+ * at render quality, and the rest follows in the background. Every rig stage
+ * is causal, so the window is the exact prefix of the full note.
+ */
+export const LIVE_RIG_WINDOW_SECONDS = 0.75;
+
 /** Longest a single live note is rendered for (a held sustain pedal). */
 export const MAX_LIVE_NOTE_SECONDS = 8;
 const CACHE_ENTRIES = 96;
@@ -47,6 +96,8 @@ const CACHE_ENTRIES = 96;
  */
 export class LiveSynth {
   private readonly cache = new Map<string, LiveNotePcm>();
+  /** f061-organ: the live organ clock's origin (performance.now ms). */
+  private readonly organEpoch = performance.now();
 
   public constructor(private readonly sampleRate: number) {}
 
@@ -58,12 +109,24 @@ export class LiveSynth {
     return this.cache.size;
   }
 
-  public render(request: LiveNoteRequest): LiveNotePcm | undefined {
+  /**
+   * Stores a whole rig note rendered elsewhere (the background worker) so the
+   * next press of that key hits the cache and skips the window.
+   */
+  public adopt(request: LiveNoteRequest, pcm: LiveNotePcm): void {
+    const plan = this.plan(request);
+    if (!plan || pcm.partial) return;
+    this.cache.set(plan.key, pcm);
+    this.trim();
+  }
+
+  private plan(request: LiveNoteRequest) {
     const track = request.score.tracks.find(
       (candidate) => candidate.id === request.trackId,
     );
     if (!track) return undefined;
     const { score } = request;
+    const liveEngine = engineFor(track);
     const bpm =
       request.tick === undefined
         ? score.tempoBpm
@@ -79,6 +142,38 @@ export class LiveSynth {
     );
     const velocity = Math.max(0, Math.min(1, request.velocity));
     const pitch = Math.max(0, Math.min(127, Math.round(request.pitch)));
+    // f061-organ: one rotating speaker and one set of free-running wheels
+    // per organ track. Each key renders from the song tick it sounds at
+    // (or the synth's own clock when stopped), so successive notes share
+    // the track's rotor and wheel phases instead of restarting them.
+    const organTick =
+      track.keys && isOrganFamily(track.instrument)
+        ? Math.max(
+            0,
+            Math.round(
+              request.clock ??
+                request.tick ??
+                ((performance.now() - this.organEpoch) / 1000) * ticksPerSecond,
+            ),
+          )
+        : undefined;
+    // Granular `quant chord` (0.6.1): a live note snaps to the song's
+    // chords at the played tick, as the offline render of the same note.
+    const quantChord =
+      track.granular !== undefined &&
+      liveEngine?.id === "granular" &&
+      resolveGranular(track.granular).quant === "chord"
+        ? { score, tick: request.tick ?? 0 }
+        : undefined;
+    const chord = quantChord
+      ? chordDigest(
+          chordTimeline(score),
+          quantChord.tick,
+          quantChord.tick +
+            durationTicks +
+            Math.ceil(liveEngine!.tailSeconds(track, pitch) * ticksPerSecond),
+        )
+      : undefined;
     const key = JSON.stringify([
       liveTrack(track),
       pitch,
@@ -88,11 +183,67 @@ export class LiveSynth {
       score.ticksPerBeat,
       this.sampleRate,
       samplerDigest(track, request.samples),
+      // Assets a 0.6 engine reads (a granular sample source).
+      ...engineDigest(track, request.samples),
       // The song tuning and key (the default tuning root) retune live notes.
       ...(score.tuning || track.tuning
         ? [score.tuning ?? null, score.key]
         : []),
+      ...(organTick !== undefined ? [`organ:${organTick}`] : []),
+      // A 0.6 engine's assets, and the key it may tune to.
+      ...(liveEngine
+        ? [
+            liveEngine.assetDigests?.(
+              track,
+              request.samples ?? EMPTY_SAMPLE_BANK,
+            ) ?? [],
+            score.key ?? null,
+          ]
+        : []),
+      ...(chord ? [chord] : []),
     ]);
+    return {
+      track,
+      score,
+      bpm,
+      seconds,
+      durationTicks,
+      velocity,
+      pitch,
+      key,
+      organTick,
+      quantChord,
+    };
+  }
+
+  public render(request: LiveNoteRequest): LiveNotePcm | undefined {
+    const plan = this.plan(request);
+    if (!plan) return undefined;
+    const {
+      track,
+      score,
+      bpm,
+      seconds,
+      durationTicks,
+      velocity,
+      pitch,
+      key,
+      organTick,
+      quantChord,
+    } = plan;
+    const liveEngine = engineFor(track);
+    // The first window of a rig note: its own cache entry, swapped for the
+    // whole note once the background pass has rendered it.
+    // Organs too: wheels, rotors and drive cost 4-8 ms per note-second.
+    const windowed =
+      request.full !== true &&
+      (hasRig(track) || organTick !== undefined || bowedTrack(track)) &&
+      seconds > LIVE_RIG_WINDOW_SECONDS &&
+      !this.cache.has(key);
+    if (windowed) {
+      const first = this.cache.get(`${key}#window`);
+      if (first) return first;
+    }
     const hit = this.cache.get(key);
     if (hit) {
       // Refresh LRU order.
@@ -112,7 +263,7 @@ export class LiveSynth {
       ticksPerBeat: score.ticksPerBeat,
       // The song tuning, and the key whose tonic is the default root.
       ...(score.tuning ? { tuning: score.tuning } : {}),
-      ...(score.tuning || track.tuning ? { key: score.key } : {}),
+      ...(score.tuning || track.tuning || liveEngine ? { key: score.key } : {}),
       tracks: [liveTrack(track)],
       notes: [
         {
@@ -125,23 +276,73 @@ export class LiveSynth {
         },
       ],
     });
-    const audio = renderScorePcm(single, {
-      sampleRate: this.sampleRate,
-      maxSeconds: MAX_LIVE_NOTE_SECONDS + 4,
-      ...(request.samples ? { samples: request.samples } : {}),
-    });
-    const frames = audibleFrames(audio.pcm);
+    // A 0.6 engine's ring-out sets the one-note length and the key release.
+    const tail = liveEngine
+      ? Math.max(0, liveEngine.tailSeconds(track, pitch))
+      : 0;
+    // Fitted sample windows over 8 s fit in the background (silent until
+    // ready, never at the wrong pitch); shorter ones fit synchronously.
+    const audio = withLiveFit(() =>
+      renderScorePcm(single, {
+        sampleRate: this.sampleRate,
+        // The renderer's shortest one-shot is 1 s; the window is cut below.
+        maxSeconds: windowed
+          ? 1
+          : Math.max(MAX_LIVE_NOTE_SECONDS + 4, seconds + tail),
+        ...(request.samples ? { samples: request.samples } : {}),
+        ...(organTick ? { seedTick: organTick } : {}),
+        ...(quantChord ? { quantChord } : {}),
+      }),
+    );
+    const frames = windowed
+      ? Math.min(
+          audibleFrames(audio.pcm),
+          Math.round(LIVE_RIG_WINDOW_SECONDS * this.sampleRate),
+        )
+      : audibleFrames(audio.pcm);
+    const release = liveEngine?.releaseSeconds
+      ? liveEngine.releaseSeconds(
+          track,
+          pitch,
+          noteHz(
+            pitch,
+            undefined,
+            resolveTuning(score.tuning, track.tuning, score.key),
+          ),
+        )
+      : tail;
+    const ringOut = !windowed && liveEngine?.ringOut?.(track) === true;
+    const pcm = audio.pcm.subarray(0, frames * RENDER_CHANNELS);
+    if (ringOut) fadeCutTail(pcm, frames, this.sampleRate);
     const rendered: LiveNotePcm = {
-      pcm: audio.pcm.subarray(0, frames * RENDER_CHANNELS),
+      pcm,
       frames,
+      ...(ringOut ? { ringOut: true as const } : {}),
+      ...(liveEngine
+        ? {
+            releaseSeconds: Math.min(
+              Math.max(0, release),
+              MAX_LIVE_NOTE_SECONDS,
+            ),
+          }
+        : {}),
+      ...(windowed ? { partial: true } : {}),
+      ...(windowed && organTick !== undefined ? { clock: organTick } : {}),
     };
-    this.cache.set(key, rendered);
+    if (liveFitPending()) return { ...rendered, fitting: true };
+    // Organ keys render at their song tick: caching them would only evict.
+    if (organTick !== undefined) return rendered;
+    this.cache.set(windowed ? `${key}#window` : key, rendered);
+    this.trim();
+    return rendered;
+  }
+
+  private trim(): void {
     while (this.cache.size > CACHE_ENTRIES) {
       const oldest = this.cache.keys().next().value;
       if (oldest === undefined) break;
       this.cache.delete(oldest);
     }
-    return rendered;
   }
 }
 
@@ -150,17 +351,43 @@ export class LiveSynth {
  * without track `time`, so a key sounds once, as played, not re-placed.
  */
 function liveTrack(track: Track): Track {
-  // A held key is the performance: the recorded pedal and the render-time
+  // A held key is the performance: the recorded pedals and the render-time
   // humanize stay out of it. The velocity curve stays, so a key sounds like
   // the note it records as.
   const {
     solo: _solo,
     time: _time,
     pedal: _pedal,
+    softPedal: _softPedal,
+    sostenuto: _sostenuto,
     humanize: _humanize,
     ...rest
   } = track;
-  return { ...rest, muted: false };
+  // A bowed section plays two players live (f061-bowed render budget).
+  return liveStringTrack({ ...rest, muted: false });
+}
+
+/**
+ * Whether the track is a bowed string: a held bow costs about 5 ms per
+ * second, so it windows like a rig (the bow loop is causal too).
+ */
+function bowedTrack(track: Track): boolean {
+  return (
+    track.instrument === "string" &&
+    track.string !== undefined &&
+    isBowed(resolveString(track.string))
+  );
+}
+
+/** Whether the track plays through a guitar rig stage. */
+function hasRig(track: Track): boolean {
+  return Boolean(track.fx?.stomp || track.fx?.head || track.fx?.cab);
+}
+
+function engineDigest(track: Track, bank: SampleBank | undefined): string[] {
+  const engine = engineFor(track);
+  if (!engine?.assetDigests || !bank) return [];
+  return [...engine.assetDigests(track, bank)];
 }
 
 function samplerDigest(track: Track, bank: SampleBank | undefined): string[] {
@@ -172,8 +399,127 @@ function samplerDigest(track: Track, bank: SampleBank | undefined): string[] {
 }
 
 /** Frames up to the last non-silent sample, so mixing skips the dead tail. */
+/**
+ * A ring-out note cut by the render length still sounds at its last frame:
+ * fade its final `RING_OUT_FADE_SECONDS` linearly to zero so the cap never
+ * clicks (each step stays under -60 dB of full scale). A tail that already
+ * decayed to silence is left alone.
+ */
+export function fadeCutTail(
+  pcm: Int16Array,
+  frames: number,
+  sampleRate: number,
+): void {
+  if (frames === 0) return;
+  const last = (frames - 1) * RENDER_CHANNELS;
+  // Below -60 dBFS the cut is inaudible.
+  if (Math.abs(pcm[last]!) < 33 && Math.abs(pcm[last + 1]!) < 33) return;
+  const fade = Math.min(frames, Math.round(RING_OUT_FADE_SECONDS * sampleRate));
+  for (let i = 0; i < fade; i += 1) {
+    const frame = frames - fade + i;
+    const gain = (fade - 1 - i) / fade;
+    for (let c = 0; c < RENDER_CHANNELS; c += 1) {
+      const at = frame * RENDER_CHANNELS + c;
+      pcm[at] = Math.round(pcm[at]! * gain);
+    }
+  }
+}
+
 function audibleFrames(pcm: Int16Array): number {
   let last = pcm.length - 1;
   while (last >= 0 && pcm[last] === 0) last -= 1;
   return Math.ceil((last + 1) / RENDER_CHANNELS);
 }
+
+/**
+ * Renders whole guitar-rig notes on a worker (`live-worker.ts`), in request
+ * order. When a worker cannot start, `full` falls back to rendering on the
+ * calling thread in a later tick, as before.
+ */
+export class LiveFullRenderer {
+  private worker: Bun.Worker | undefined;
+  private broken = false;
+  private nextId = 1;
+  private readonly pending = new Map<
+    number,
+    (pcm: LiveNotePcm | undefined) => void
+  >();
+
+  public full(
+    synth: LiveSynth,
+    request: LiveNoteRequest,
+  ): Promise<LiveNotePcm | undefined> {
+    const worker = this.ensure();
+    if (!worker)
+      return new Promise((resolve) =>
+        setTimeout(() => resolve(synth.render({ ...request, full: true })), 0),
+      );
+    const id = this.nextId;
+    this.nextId += 1;
+    return new Promise((resolve) => {
+      this.pending.set(id, (pcm) => {
+        if (pcm) synth.adopt(request, pcm);
+        resolve(pcm);
+      });
+      const message: LiveFullRequest = {
+        id,
+        sampleRate: synth.rate,
+        score: request.score.toJSON(),
+        trackId: request.trackId,
+        pitch: request.pitch,
+        velocity: request.velocity,
+        seconds: request.seconds,
+        ...(request.tick === undefined ? {} : { tick: request.tick }),
+        ...(request.clock === undefined ? {} : { clock: request.clock }),
+        ...(request.samples ? { samples: request.samples } : {}),
+      };
+      try {
+        worker.postMessage(message);
+      } catch {
+        this.pending.delete(id);
+        this.fail();
+        setTimeout(() => resolve(synth.render({ ...request, full: true })), 0);
+      }
+    });
+  }
+
+  /** Stops the worker; pending notes resolve without a full pass. */
+  public close(): void {
+    this.fail();
+  }
+
+  private ensure(): Bun.Worker | undefined {
+    if (this.worker) return this.worker;
+    if (this.broken) return undefined;
+    try {
+      // The DOM lib's Worker type lacks Bun's `unref`; the runtime is Bun's.
+      const worker = new Worker(
+        new URL("./live-worker.ts", import.meta.url).href,
+      ) as unknown as Bun.Worker;
+      worker.addEventListener("message", (event: Event) => {
+        const reply = (event as MessageEvent<LiveFullReply>).data;
+        const done = this.pending.get(reply.id);
+        if (!done) return;
+        this.pending.delete(reply.id);
+        done(reply.pcm);
+      });
+      worker.addEventListener("error", () => this.fail());
+      worker.unref();
+      this.worker = worker;
+      return worker;
+    } catch {
+      this.broken = true;
+      return undefined;
+    }
+  }
+
+  private fail(): void {
+    this.broken = true;
+    const worker = this.worker;
+    this.worker = undefined;
+    worker?.terminate();
+    const waiters = [...this.pending.values()];
+    this.pending.clear();
+    for (const done of waiters) done(undefined);
+  }
+}

package/src/audio/loudness.ts

@@ -3,7 +3,7 @@
  * K-weighted mean square, momentary (400 ms) and short-term (3 s) loudness
  * every 100 ms, gated integrated loudness (absolute -70 LUFS, relative
  * -10 LU), loudness range per EBU Tech 3342 (short-term values gated at
- * -70 LUFS and -20 LU, 10th to 95th percentile) and true peak from a 4x
+ * -70 LUFS and -20 LU, 10th to 95th percentile) and true peak from an 8x
  * oversampled polyphase interpolator (BS.1770-4 Annex 2, with a longer
  * windowed-sinc filter than its example). Validated against
  * the synthetic test signals of EBU Tech 3341 and 3342 in loudness.test.ts.
@@ -31,7 +31,7 @@ export type Loudness = Readonly<{
   shortTermMax: number;
   /** Loudness range (LRA), LU. */
   range: number;
-  /** dBTP: the 4x oversampled peak. */
+  /** dBTP: the 8x oversampled peak. */
   truePeak: number;
   /** dBFS: the highest sample. */
   samplePeak: number;
@@ -239,15 +239,18 @@ function besselI0(x: number): number {
 let phases: Float64Array[] | undefined;
 
 /**
- * The true-peak interpolator: four Kaiser-windowed sinc phases of 32 taps,
- * each in time order over x[n-15] .. x[n+16], estimating the signal at
- * n + 1/8, 3/8, 5/8 and 7/8. With the samples themselves they give the 4x
- * oversampled true peak. BS.1770-4 Annex 2's 12-tap example filter rolls
+ * The true-peak interpolator: Kaiser-windowed sinc phases of 32 taps, each
+ * in time order over x[n-15] .. x[n+16], estimating the signal at n + 1/8,
+ * 3/8, 5/8 and 7/8, then (0.6) n + 2/8, 4/8 and 6/8. With the samples
+ * themselves they give an evenly spaced 8x oversampled true peak; the odd
+ * eighths alone left 1/4-sample gaps that read dense material up to 0.2 dB
+ * low at a peak near n + 3/4. The odd phases come first and are unchanged,
+ * so a peak they already caught reads the same. BS.1770-4 Annex 2's 12-tap example filter rolls
  * off early and reads dense, bright material (supersaws, distortion) up to
  * half a dB low; this one stays within a few hundredths of a 64x reference.
  */
 export function truePeakPhases(): readonly Float64Array[] {
-  phases ??= [1, 3, 5, 7].map((eighth) => {
+  phases ??= [1, 3, 5, 7, 2, 4, 6].map((eighth) => {
     const frac = eighth / 8;
     const taps = new Float64Array(TAPS_PER_PHASE);
     const before = TAPS_PER_PHASE / 2 - 1;
@@ -266,9 +269,23 @@ export function truePeakPhases(): readonly Float64Array[] {
   return phases;
 }
 
+let interleaved: Float64Array | undefined;
+
+/** The seven phases interleaved by tap (`tap * 7 + phase`). */
+function interleavedPhases(): Float64Array {
+  if (interleaved) return interleaved;
+  const branches = truePeakPhases();
+  const flat = new Float64Array(TAPS_PER_PHASE * branches.length);
+  branches.forEach((taps, phase) => {
+    for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1)
+      flat[tap * branches.length + phase] = taps[tap]!;
+  });
+  return (interleaved = flat);
+}
+
 /**
  * Largest absolute value between each sample and the next (both samples
- * and the four interpolated points), as `out[n]` for n .. n+1.
+ * and the seven interpolated points), as `out[n]` for n .. n+1.
  */
 export function interSamplePeaks(
   channel: Float64Array,
@@ -277,6 +294,7 @@ export function interSamplePeaks(
 ): void {
   const n = channel.length;
   const branches = truePeakPhases();
+  const flat = interleavedPhases();
   const before = TAPS_PER_PHASE / 2 - 1;
   const at = (index: number): number => {
     if (index >= 0 && index < n) return channel[index]!;
@@ -287,23 +305,50 @@ export function interSamplePeaks(
     let peak = Math.abs(channel[index]!);
     const next = Math.abs(at(index + 1));
     if (next > peak) peak = next;
-    const inside = index - before >= 0 && index + TAPS_PER_PHASE - before <= n;
-    for (const taps of branches) {
-      let sum = 0;
-      if (inside)
-        for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1)
-          sum += channel[index - before + tap]! * taps[tap]!;
-      else
+    const base = index - before;
+    if (base >= 0 && base + TAPS_PER_PHASE <= n) {
+      // Every phase in one pass over the window (the interior fast path).
+      let s0 = 0;
+      let s1 = 0;
+      let s2 = 0;
+      let s3 = 0;
+      let s4 = 0;
+      let s5 = 0;
+      let s6 = 0;
+      for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1) {
+        const x = channel[base + tap]!;
+        const k = tap * 7;
+        s0 += x * flat[k]!;
+        s1 += x * flat[k + 1]!;
+        s2 += x * flat[k + 2]!;
+        s3 += x * flat[k + 3]!;
+        s4 += x * flat[k + 4]!;
+        s5 += x * flat[k + 5]!;
+        s6 += x * flat[k + 6]!;
+      }
+      peak = Math.max(
+        peak,
+        Math.abs(s0),
+        Math.abs(s1),
+        Math.abs(s2),
+        Math.abs(s3),
+        Math.abs(s4),
+        Math.abs(s5),
+        Math.abs(s6),
+      );
+    } else
+      for (const taps of branches) {
+        let sum = 0;
         for (let tap = 0; tap < TAPS_PER_PHASE; tap += 1)
-          sum += at(index - before + tap) * taps[tap]!;
-      const magnitude = Math.abs(sum);
-      if (magnitude > peak) peak = magnitude;
-    }
+          sum += at(base + tap) * taps[tap]!;
+        const magnitude = Math.abs(sum);
+        if (magnitude > peak) peak = magnitude;
+      }
     if (peak > out[index]!) out[index] = peak;
   }
 }
 
-/** The 4x oversampled true peak of a stereo buffer, linear. */
+/** The 8x oversampled true peak of a stereo buffer, linear. */
 export function truePeakGain(
   left: Float64Array,
   right: Float64Array,

package/src/audio/preview.ts

@@ -16,6 +16,12 @@
  * wavetables so position changes are audible.
  */
 import { isDrumInstrument } from "../../core/drums.ts";
+import { slicePedals } from "../../core/expression.ts";
+import {
+  isStringTrack,
+  resolveString,
+  stringPresetOf,
+} from "../../core/strings.ts";
 import type { SongMaster } from "../../core/master.ts";
 import { MODES, parseKey } from "../../core/chords.ts";
 import { rhythmVoicePitch } from "../../core/rhythm.ts";
@@ -129,6 +135,16 @@ export function phraseRole(track: Track): PhraseRole {
   if (isSamplerInstrument(track.instrument))
     return track.sampler?.mode === "keyed" ? "chord" : "groove";
   if (isWavetableInstrument(track.instrument)) return "drone";
+  // Grain clouds are textures: held notes let them evolve.
+  if (track.instrument === "granular") return "drone";
+  if (isStringTrack(track) && resolveString(track.string).exciter === "bow") {
+    // Bowed: low strings walk a line, solo strings sing a legato line,
+    // sections and pizz/trem hold chords.
+    const preset = stringPresetOf(track.string);
+    if (/^(contrabass|contrabasses|cello|cellos)$/.test(preset)) return "riff";
+    if (/^(violin|viola|fiddle|erhu|kamancheh)$/.test(preset)) return "lead";
+    return "chord";
+  }
   const words = `${track.instrument} ${track.name} ${track.id}`.toLowerCase();
   if (/\b(bass|sub|808)/.test(words)) return "riff";
   if (/\b(lead|arp|pluck|saw|square|pulse|z_|mono|melody|hook)/.test(words))
@@ -285,7 +301,7 @@ function sliceTrack(track: Track, start: number, end: number): Track {
         lanes[name] = sliceLane(points, start, end);
     sliced.fxAutomation = lanes;
   }
-  return sliced as Track;
+  return slicePedals(sliced as Track, [{ from: start, to: end, offset: 0 }]);
 }
 
 /**