@hraness/dawg 0.5.0 → 0.6.1

package/core/score.ts

@@ -20,7 +20,23 @@ import {
   type FxLane,
   type TrackFx,
 } from "./fx.ts";
+import {
+  MODAL_INSTRUMENT,
+  normalizeModal,
+  normalizeWind,
+  WIND_INSTRUMENT,
+  type TrackModal,
+  type TrackWind,
+} from "./resonators.ts";
 import { normalizeSynth, type TrackSynth } from "./synth.ts";
+import { normalizeString, type TrackString } from "./strings.ts";
+import {
+  isGranularInstrument,
+  normalizeGranular,
+  type TrackGranular,
+} from "./granular.ts";
+import { isKeysFamily, normalizeKeys, type TrackKeys } from "./keys.ts";
+import { GUITAR_TUNING_NAMES } from "./chords.ts";
 import {
   checkSongTime,
   normalizeSongTime,
@@ -33,8 +49,11 @@ import {
 import {
   ExpressionValidationError,
   normalizeNoteExpression,
+  normalizePedal,
   normalizeTrackPerformance,
+  SOSTENUTO_STATES,
   type NoteExpression,
+  type PedalEvent,
   type NoteExpressionPatch,
   type TrackPerformance,
 } from "./expression.ts";
@@ -99,6 +118,17 @@ export const SCORE_LIMITS = Object.freeze({
   maxSampleAccelerate: 8,
   /** Sampler `squiz` ratio bound. */
   maxSampleSquiz: 32,
+  /** Sampler `bpm` (source tempo) bounds. */
+  minSampleBpm: 20,
+  maxSampleBpm: 400,
+  /** Sampler `len` (window length in beats) bound. */
+  maxSampleLenBeats: 1024,
+  /** Sampler `shift` and `formant` bound in semitones (0.6.1). */
+  maxSampleShift: 24,
+  /** Sampler `fadeTime`/`fadeInTime` bound in seconds (0.6.1). */
+  maxSampleFadeSeconds: 2,
+  /** Longest `resample` render in seconds (0.6.1). */
+  maxResampleSeconds: 600,
   /** Per sample file, enforced by the decoder and the import tool. */
   maxSampleFileBytes: 50 * 1024 * 1024,
   maxSampleSeconds: 600,
@@ -373,6 +403,54 @@ export type Track = Readonly<{
    * `ref`/`root` over the song tuning. Absent follows the song tuning.
    */
   tuning?: Tuning;
+  /**
+   * String engine settings (`core/strings.ts`): a preset plus overrides.
+   * Played only when `instrument` is "string"; absent keeps today's voice.
+   */
+  string?: TrackString;
+  /**
+   * Granular instrument settings (0.6, `core/granular.ts`). Played when
+   * `instrument` is `"granular"`; kept when the instrument changes.
+   */
+  granular?: TrackGranular;
+  /**
+   * Optional (0.6): modelled piano settings (`core/keys.ts`), `{ preset?,
+   * ...overrides }`. The modelled piano plays only when `instrument` is a
+   * piano family (grand upright felt honkytonk prepared) and this is
+   * present; `{}` is the family's defaults.
+   */
+  keys?: TrackKeys;
+  /**
+   * Optional (0.6): modal percussion (`core/resonators.ts`), a preset plus
+   * overrides. Plays only when `instrument` is `"modal"`; any other
+   * instrument with this field is rejected. Absent keeps today's tone.
+   */
+  modal?: TrackModal;
+  /**
+   * Optional (0.6.1): una corda (soft pedal) events, same shape as `pedal`.
+   * Modelled pianos read it at each onset (half is half the shift); other
+   * instruments ignore it.
+   */
+  softPedal?: readonly PedalEvent[];
+  /**
+   * Optional (0.6.1): sostenuto pedal events (down and up only). Keys held
+   * when it goes down ring until it lifts; later keys damp as usual.
+   */
+  sostenuto?: readonly PedalEvent[];
+  /**
+   * Optional (0.6.1): how the track is fretted when chords are strummed
+   * (`strum`, perform mode `guitar`): tuning, capo, hand stretch, how much
+   * open strings ring and a preferred position. Notes only; never read at
+   * render, so it changes no sound by itself.
+   */
+  guitar?: TrackGuitar;
+  /**
+   * Optional (0.6.1): a blown waveguide (`core/winds.ts`), a preset plus
+   * overrides. Plays only when `instrument` is `"wind"`; without it the
+   * legacy `wind` tone plays unchanged. Any other instrument with this
+   * field is rejected.
+   */
+  wind?: TrackWind;
 }> &
   /**
    * Performance (`core/expression.ts`): glide default, sustain pedal
@@ -449,8 +527,80 @@ export type SampleRef = Readonly<{
    * (1 is off, up to 32).
    */
   squiz?: number;
+  /**
+   * Optional: the sample's own tempo (20..400). The window then follows
+   * the song's tempo map (ramps included): a 174 BPM break in a 128 BPM
+   * song plays 128/174 as fast. `fitmode` picks how.
+   */
+  bpm?: number;
+  /**
+   * Optional: how a fitted sample changes its time. `repitch` (default)
+   * changes speed and pitch together like tape; `beats` cuts the window at
+   * its onsets and places each slice on its new time, unstretched (drums,
+   * speech); `tones` time-stretches with a phase vocoder and keeps the
+   * pitch (pads, loops, vocals). Needs `bpm`, `len` or `fit`.
+   */
+  fitmode?: SampleFitMode;
+  /**
+   * Optional: the window's length in beats (0 < len ≤ 1024), followed
+   * through the song's tempo map. `fit` wins over `bpm`, `bpm` over `len`.
+   */
+  len?: number;
+  /**
+   * Optional (0.6.1): pitch shift in semitones (−24..24) at constant
+   * length, a cached phase-vocoder preprocess (`src/audio/dsp/shift.ts`).
+   * Applied after any fit, so it follows `fitmode`.
+   */
+  shift?: number;
+  /**
+   * Optional (0.6.1, with `shift`): formant shift in semitones (−24..24).
+   * Absent: formants follow the pitch (chipmunk); 0 keeps them in place.
+   */
+  formant?: number;
+  /** Optional (0.6.1, Strudel `fadeTime`): release fade in seconds (0..2). */
+  fadeTime?: number;
+  /** Optional (0.6.1, Strudel `fadeInTime`): attack fade in seconds (0..2). */
+  fadeInTime?: number;
+  /**
+   * Optional (0.6.1): where `resample` rendered this file from; kept for
+   * reference only (never read by the renderer).
+   */
+  from?: SampleProvenance;
+  /**
+   * Optional (0.6.1, SFZ `lovel`/`hivel`): the MIDI velocity range
+   * [lo, hi] (0..127, lo ≤ hi) this voice plays. Keyed voices with the same
+   * root are velocity layers; a one-shot voice outside its range is silent
+   * unless its `rr` group has a voice for that velocity.
+   */
+  vel?: readonly [number, number];
+  /**
+   * Optional (0.6.1, SFZ `seq_length`): round-robin group name. One-shot
+   * voices in a group are one sound (any member's slot plays it); voices
+   * that match a note's velocity take turns, A B A B, in note order.
+   */
+  rr?: string;
+}>;
+
+/** `SampleRef.from`: the source of a resampled file (0.6.1). */
+export type SampleProvenance = Readonly<{
+  /** `track:<id>`, `orbit:<n>` or `master`. */
+  source: string;
+  /** Section name the render covered. */
+  section?: string;
+  /** Bars a..b (1-based, inclusive) the render covered. */
+  bars?: readonly [number, number];
+  /** sha256 of the canonical score JSON the file was rendered from. */
+  score: string;
 }>;
 
+/** Sampler `fitmode`: how a fitted window changes its time. */
+export type SampleFitMode = "repitch" | "beats" | "tones";
+export const SAMPLE_FIT_MODES: readonly SampleFitMode[] = Object.freeze([
+  "repitch",
+  "beats",
+  "tones",
+]);
+
 /** Sample `unit`: rate, cycles (bars) or seconds. */
 export type SampleUnit = "r" | "c" | "s";
 export const SAMPLE_UNITS: readonly SampleUnit[] = Object.freeze([
@@ -474,14 +624,22 @@ export type TrackReverb = Readonly<{
   predelay?: number;
   /**
    * Optional (Strudel `iresponse`/`ir`): convolve with this impulse instead
-   * of the algorithmic tail. `builtin:room|hall|plate`, a pinned pack sound
+   * of the algorithmic tail. `builtin:room|hall|plate|reverse|gate|spring`, a pinned pack sound
    * or a project file; `size`, `fade` and `dim` then do nothing.
    */
   ir?: SampleRef;
 }>;
 
 /** Generated impulse responses `reverb.ir` can name as `builtin:<name>`. */
-export const REVERB_IR_BUILTINS = Object.freeze(["room", "hall", "plate"]);
+export const REVERB_IR_BUILTINS = Object.freeze([
+  "room",
+  "hall",
+  "plate",
+  // 0.6.1: a reverse (rising) wash, a gated tail, a spring tank.
+  "reverse",
+  "gate",
+  "spring",
+]);
 
 /**
  * Validates `reverb.ir`: a string or `{ src, … }`. Bare built-in names and
@@ -683,6 +841,14 @@ export type TrackPatch = Readonly<
     velocityCurve?: Track["velocityCurve"] | null;
     humanize?: Track["humanize"] | null;
     tuning?: Tuning | null;
+    string?: TrackString | null;
+    granular?: TrackGranular | null;
+    keys?: TrackKeys | null;
+    modal?: TrackModal | null;
+    softPedal?: Track["softPedal"] | null;
+    sostenuto?: Track["sostenuto"] | null;
+    guitar?: TrackGuitar | null;
+    wind?: TrackWind | null;
   }
 >;
 
@@ -727,6 +893,14 @@ export type TrackInput = Readonly<
     | "velocityCurve"
     | "humanize"
     | "tuning"
+    | "string"
+    | "granular"
+    | "keys"
+    | "modal"
+    | "softPedal"
+    | "sostenuto"
+    | "guitar"
+    | "wind"
   > &
     Pick<Track, "id"> & {
       filter?: TrackFilter | null;
@@ -745,6 +919,14 @@ export type TrackInput = Readonly<
       velocityCurve?: Track["velocityCurve"] | string | null;
       humanize?: Track["humanize"] | null;
       tuning?: Tuning | null;
+      string?: TrackString | null;
+      granular?: TrackGranular | null;
+      keys?: TrackKeys | null;
+      modal?: TrackModal | null;
+      softPedal?: Track["softPedal"] | null;
+      sostenuto?: Track["sostenuto"] | null;
+      guitar?: TrackGuitar | null;
+      wind?: TrackWind | null;
     }
 >;
 
@@ -1134,9 +1316,31 @@ export function updateTrack(
 ): TrackScore {
   if (!score.tracks.some((track) => track.id === trackId)) return score;
   return score.withTracks(
-    score.tracks.map((track) =>
-      track.id === trackId ? { ...track, ...patch } : track,
-    ),
+    score.tracks.map((track) => {
+      if (track.id !== trackId) return track;
+      const next: Record<string, unknown> = { ...track, ...patch };
+      // A modal field only belongs to a modal track: switching the
+      // instrument away drops it unless the patch sets it too.
+      if (
+        patch.instrument !== undefined &&
+        patch.modal === undefined &&
+        patch.instrument !== MODAL_INSTRUMENT
+      )
+        delete next.modal;
+      // The legacy word `wind` is the legacy tone, so naming any instrument
+      // (`wind` included) without a wind field leaves the wind engine.
+      if (patch.instrument !== undefined && patch.wind === undefined)
+        delete next.wind;
+      // Keys settings only belong to a keys family (piano, electric, organ):
+      // switching to another instrument drops them unless the patch sets them.
+      if (
+        patch.instrument !== undefined &&
+        patch.keys === undefined &&
+        !isKeysFamily(patch.instrument)
+      )
+        delete next.keys;
+      return next as Track;
+    }),
   );
 }
 
@@ -1717,7 +1921,21 @@ function normalizeTrack(input: unknown): Track {
   const fx = fxOrThrow(() => normalizeFx(input.fx));
   const fxAutomation = normalizeFxAutomation(input.fxAutomation);
   const synth = fxOrThrow(() => normalizeSynth(input.synth));
+  const keys = fxOrThrow(() => normalizeKeys(input.keys));
   const wavetable = normalizeWavetable(input.wavetable);
+  const modal = fxOrThrow(() => normalizeModal(input.modal));
+  if (modal && instrument !== MODAL_INSTRUMENT)
+    throw new ScoreValidationError(
+      `track ${id} has modal settings but its instrument is "${instrument}"`,
+      "invalid-track",
+    );
+  const guitar = normalizeGuitar(input.guitar);
+  const wind = fxOrThrow(() => normalizeWind(input.wind));
+  if (wind && instrument !== WIND_INSTRUMENT)
+    throw new ScoreValidationError(
+      `track ${id} has wind settings but its instrument is "${instrument}"`,
+      "invalid-track",
+    );
   const sampler = normalizeSampler(input.sampler);
   const rhythm = normalizeRhythm(input.rhythm, id);
   const time = timeOrThrow(
@@ -1739,6 +1957,37 @@ function normalizeTrack(input: unknown): Track {
     () => normalizeTuning(input.tuning, `track ${id} tuning`),
     "invalid-track",
   );
+  let softPedal: readonly PedalEvent[] | undefined;
+  let sostenuto: readonly PedalEvent[] | undefined;
+  try {
+    softPedal = normalizePedal(
+      input.softPedal,
+      SCORE_LIMITS.maxTick,
+      "softPedal",
+    );
+    sostenuto = normalizePedal(
+      input.sostenuto,
+      SCORE_LIMITS.maxTick,
+      "sostenuto",
+      SOSTENUTO_STATES,
+    );
+  } catch (error) {
+    if (error instanceof ExpressionValidationError)
+      throw new ScoreValidationError(
+        `track ${id} ${error.message}`,
+        "invalid-track",
+      );
+    throw error;
+  }
+  const string = fxOrThrow(() => normalizeString(input.string));
+  // A bare `granular` instrument (set_instrument, `instrument granular`)
+  // gets an empty object, so the engine plays its defaults.
+  const granular =
+    fxOrThrow(() =>
+      normalizeGranular(input.granular, (ref) =>
+        normalizeSampleRef(ref, "granular src"),
+      ),
+    ) ?? (isGranularInstrument(instrument) ? Object.freeze({}) : undefined);
   let kit: string | undefined;
   if (input.kit !== undefined && input.kit !== null) {
     const found =
@@ -1760,7 +2009,12 @@ function normalizeTrack(input: unknown): Track {
       `track ${id} instrument "sampler" needs a sampler`,
       "invalid-track",
     );
-  if (sampler && !isSamplerInstrument(instrument))
+  // A granular track keeps the sampler it grains (`grain off` goes back).
+  if (
+    sampler &&
+    !isSamplerInstrument(instrument) &&
+    !isGranularInstrument(instrument)
+  )
     throw new ScoreValidationError(
       `track ${id} has a sampler but its instrument is "${instrument}"`,
       "invalid-track",
@@ -1793,9 +2047,93 @@ function normalizeTrack(input: unknown): Track {
     ...(time ? { time } : {}),
     ...performance,
     ...(tuning ? { tuning } : {}),
+    ...(string ? { string } : {}),
+    ...(granular ? { granular } : {}),
+    ...(keys ? { keys } : {}),
+    ...(modal ? { modal } : {}),
+    ...(softPedal ? { softPedal } : {}),
+    ...(sostenuto ? { sostenuto } : {}),
+    ...(guitar ? { guitar } : {}),
+    ...(wind ? { wind } : {}),
   });
 }
 
+/** Track.guitar (0.6.1): a tuning name or open-string pitches plus fretting. */
+export type TrackGuitar = Readonly<{
+  /** A GUITAR_TUNINGS name or 3..12 open-string MIDI pitches, low to high. */
+  tune?: string | readonly number[];
+  /** Capo fret 0..12. */
+  capo?: number;
+  /** Hand stretch in frets 3..6 (default 4). */
+  hand?: number;
+  /** 0 closed shapes .. 1 ringing open strings (default 0.5). */
+  ring?: number;
+  /** Preferred fret position 0..12. */
+  position?: number;
+}>;
+
+/** Validates Track.guitar; `{}` and null normalize to absent. */
+export function normalizeGuitar(input: unknown): TrackGuitar | undefined {
+  if (input === undefined || input === null) return undefined;
+  const fail = (message: string): never => {
+    throw new ScoreValidationError(`track guitar ${message}`, "invalid-track");
+  };
+  if (typeof input !== "object" || Array.isArray(input))
+    fail("must be an object or null");
+  const out: Record<string, unknown> = {};
+  const record = input as Record<string, unknown>;
+  for (const key of Object.keys(record))
+    if (!["tune", "capo", "hand", "ring", "position"].includes(key))
+      fail(`has no field "${key.slice(0, 32)}"`);
+  const tune = record.tune;
+  if (tune !== undefined && tune !== null) {
+    if (typeof tune === "string") {
+      const name = tune.toLowerCase().replace(/[\s_-]/g, "");
+      if (!(GUITAR_TUNING_NAMES as readonly string[]).includes(name))
+        fail(
+          `tune must be one of ${GUITAR_TUNING_NAMES.join(", ")} or a list of pitches`,
+        );
+      out.tune = name;
+    } else if (
+      Array.isArray(tune) &&
+      tune.length >= 3 &&
+      tune.length <= 12 &&
+      tune.every((p) => Number.isInteger(p) && p >= 0 && p <= 127)
+    )
+      out.tune = Object.freeze([...(tune as number[])]);
+    else fail("tune must be a tuning name or 3..12 MIDI pitches");
+  }
+  const int = (key: string, min: number, max: number) => {
+    const value = record[key];
+    if (value === undefined || value === null) return;
+    if (
+      typeof value !== "number" ||
+      !Number.isInteger(value) ||
+      value < min ||
+      value > max
+    )
+      fail(`${key} must be an integer ${min}..${max}`);
+    out[key] = value;
+  };
+  int("capo", 0, 12);
+  int("hand", 3, 6);
+  const ring = record.ring;
+  if (ring !== undefined && ring !== null) {
+    if (
+      typeof ring !== "number" ||
+      !Number.isFinite(ring) ||
+      ring < 0 ||
+      ring > 1
+    )
+      fail("ring must be 0..1");
+    out.ring = Math.round((ring as number) * 1000) / 1000;
+  }
+  int("position", 0, 12);
+  return Object.keys(out).length > 0
+    ? (Object.freeze(out) as TrackGuitar)
+    : undefined;
+}
+
 export function normalizeRhythm(
   input: unknown,
   trackId: string,
@@ -1918,6 +2256,8 @@ function trackEffectExtras(
 }
 
 const VOICE_NAME = /^[A-Za-z][A-Za-z0-9_]*$/;
+/** A sampler round-robin group name (`SampleRef.rr`). */
+const SAMPLE_RR_GROUP = /^[A-Za-z0-9_]{1,32}$/;
 const SHA256_HEX = /^[0-9a-f]{64}$/;
 
 /** Validates a `Sampler` from unknown; `undefined`/`null` means none. */
@@ -2000,6 +2340,16 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
     fit?: boolean;
     accelerate?: number;
     squiz?: number;
+    bpm?: number;
+    fitmode?: SampleFitMode;
+    len?: number;
+    shift?: number;
+    formant?: number;
+    fadeTime?: number;
+    fadeInTime?: number;
+    from?: SampleProvenance;
+    vel?: readonly [number, number];
+    rr?: string;
   } = { src };
   if (input.sha256 !== undefined) {
     if (typeof input.sha256 !== "string" || !SHA256_HEX.test(input.sha256))
@@ -2163,9 +2513,162 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
       1,
       SCORE_LIMITS.maxSampleSquiz,
     );
+  if (input.bpm !== undefined)
+    ref.bpm = boundedNumber(
+      input.bpm,
+      `${label} bpm`,
+      SCORE_LIMITS.minSampleBpm,
+      SCORE_LIMITS.maxSampleBpm,
+    );
+  if (input.fitmode !== undefined) {
+    if (!SAMPLE_FIT_MODES.includes(input.fitmode as SampleFitMode))
+      throw new ScoreValidationError(
+        `${label} fitmode must be "repitch", "beats" or "tones"`,
+        "invalid-track",
+      );
+    ref.fitmode = input.fitmode as SampleFitMode;
+  }
+  if (input.len !== undefined) {
+    const len = boundedNumber(
+      input.len,
+      `${label} len`,
+      0,
+      SCORE_LIMITS.maxSampleLenBeats,
+    );
+    if (len === 0)
+      throw new ScoreValidationError(
+        `${label} len must be greater than 0`,
+        "invalid-track",
+      );
+    ref.len = len;
+  }
+  if (input.vel !== undefined) {
+    const vel = input.vel;
+    if (
+      !Array.isArray(vel) ||
+      vel.length !== 2 ||
+      !vel.every((v) => Number.isInteger(v) && v >= 0 && v <= 127) ||
+      vel[0] > vel[1]
+    )
+      throw new ScoreValidationError(
+        `${label} vel must be [lo, hi], MIDI velocities 0..127 with lo ≤ hi`,
+        "invalid-track",
+      );
+    ref.vel = Object.freeze([vel[0] as number, vel[1] as number] as const);
+  }
+  if (input.rr !== undefined) {
+    if (typeof input.rr !== "string" || !SAMPLE_RR_GROUP.test(input.rr))
+      throw new ScoreValidationError(
+        `${label} rr must be a round-robin group name (letters, digits, _; at most 32)`,
+        "invalid-track",
+      );
+    ref.rr = input.rr;
+  }
+  if (
+    ref.fitmode !== undefined &&
+    ref.fitmode !== "repitch" &&
+    ref.bpm === undefined &&
+    ref.len === undefined &&
+    ref.fit !== true
+  )
+    throw new ScoreValidationError(
+      `${label} fitmode ${ref.fitmode} needs bpm, len or fit`,
+      "invalid-track",
+    );
+  if (input.shift !== undefined)
+    ref.shift = boundedNumber(
+      input.shift,
+      `${label} shift`,
+      -SCORE_LIMITS.maxSampleShift,
+      SCORE_LIMITS.maxSampleShift,
+    );
+  if (input.formant !== undefined)
+    ref.formant = boundedNumber(
+      input.formant,
+      `${label} formant`,
+      -SCORE_LIMITS.maxSampleShift,
+      SCORE_LIMITS.maxSampleShift,
+    );
+  if (input.fadeTime !== undefined)
+    ref.fadeTime = boundedNumber(
+      input.fadeTime,
+      `${label} fadeTime`,
+      0,
+      SCORE_LIMITS.maxSampleFadeSeconds,
+    );
+  if (input.fadeInTime !== undefined)
+    ref.fadeInTime = boundedNumber(
+      input.fadeInTime,
+      `${label} fadeInTime`,
+      0,
+      SCORE_LIMITS.maxSampleFadeSeconds,
+    );
+  if (input.from !== undefined)
+    ref.from = normalizeProvenance(input.from, `${label} from`);
   return Object.freeze(ref);
 }
 
+const PROVENANCE_SOURCE =
+  /^(?:track:[A-Za-z0-9_-]{1,64}|orbit:[0-9]{1,2}|master)$/;
+
+function normalizeProvenance(input: unknown, label: string): SampleProvenance {
+  if (
+    !isRecord(input) ||
+    typeof input.source !== "string" ||
+    !PROVENANCE_SOURCE.test(input.source) ||
+    typeof input.score !== "string" ||
+    !SHA256_HEX.test(input.score)
+  )
+    throw new ScoreValidationError(
+      `${label} must be { source: track:<id>|orbit:<n>|master, score: <sha256> }`,
+      "invalid-track",
+    );
+  const from: {
+    source: string;
+    section?: string;
+    bars?: [number, number];
+    score: string;
+  } = {
+    source: input.source,
+    score: input.score,
+  };
+  if (input.section !== undefined) {
+    if (
+      typeof input.section !== "string" ||
+      input.section.length === 0 ||
+      input.section.length > 64
+    )
+      throw new ScoreValidationError(
+        `${label} section must be a section name`,
+        "invalid-track",
+      );
+    from.section = input.section;
+  }
+  if (input.bars !== undefined) {
+    const bars = input.bars;
+    if (
+      !Array.isArray(bars) ||
+      bars.length !== 2 ||
+      !bars.every((b) => Number.isInteger(b) && b >= 1 && b <= 100_000) ||
+      bars[0] > bars[1]
+    )
+      throw new ScoreValidationError(
+        `${label} bars must be [a, b] with 1 ≤ a ≤ b`,
+        "invalid-track",
+      );
+    from.bars = [bars[0], bars[1]];
+  }
+  // Key order is fixed so the printed JSON is stable.
+  return Object.freeze({
+    source: from.source,
+    ...(from.section !== undefined ? { section: from.section } : {}),
+    ...(from.bars !== undefined
+      ? { bars: Object.freeze(from.bars) as readonly [number, number] }
+      : {}),
+    score: from.score,
+  });
+}
+
 /** Prefix of a pack sound reference in `SampleRef.src`. */
 export const PACK_PREFIX = "pack:";
 
@@ -2403,10 +2906,28 @@ function normalizeAutomation(
   return freezeArray(points);
 }
 
+/** The note cap `normalizeNotes` enforces; see `withNoteCap`. */
+let noteCap: number = SCORE_LIMITS.maxNotes;
+
+/**
+ * Runs `fn` with the note cap raised to `cap`. Stored scores keep
+ * SCORE_LIMITS.maxNotes; the arranged renderer bakes timed tracks (cycle,
+ * rate) into plain notes and may hold more than a stored score allows.
+ */
+export function withNoteCap<T>(cap: number, fn: () => T): T {
+  const previous = noteCap;
+  noteCap = Math.max(previous, cap);
+  try {
+    return fn();
+  } finally {
+    noteCap = previous;
+  }
+}
+
 function normalizeNotes(inputs: readonly unknown[]): Note[] {
-  if (!Array.isArray(inputs) || inputs.length > SCORE_LIMITS.maxNotes) {
+  if (!Array.isArray(inputs) || inputs.length > noteCap) {
     throw new ScoreValidationError(
-      `score cannot contain more than ${SCORE_LIMITS.maxNotes} notes`,
+      `score cannot contain more than ${noteCap} notes`,
       "score-limit",
     );
   }

package/core/sdk/eval-child.ts

@@ -104,6 +104,8 @@ async function withSampleHashes(
     const wavetable = track.wavetable;
     if (isObject(wavetable) && isObject(wavetable.table))
       refs.push(wavetable.table);
+    const granular = track.granular;
+    if (isObject(granular) && isObject(granular.src)) refs.push(granular.src);
   }
   for (const ref of refs) {
     if (