@hraness/dawg 0.6.0 → 0.6.1

package/core/score.ts

@@ -23,7 +23,10 @@ import {
 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";
@@ -32,7 +35,8 @@ import {
   normalizeGranular,
   type TrackGranular,
 } from "./granular.ts";
-import { normalizeKeys, type TrackKeys } from "./keys.ts";
+import { isKeysFamily, normalizeKeys, type TrackKeys } from "./keys.ts";
+import { GUITAR_TUNING_NAMES } from "./chords.ts";
 import {
   checkSongTime,
   normalizeSongTime,
@@ -45,8 +49,11 @@ import {
 import {
   ExpressionValidationError,
   normalizeNoteExpression,
+  normalizePedal,
   normalizeTrackPerformance,
+  SOSTENUTO_STATES,
   type NoteExpression,
+  type PedalEvent,
   type NoteExpressionPatch,
   type TrackPerformance,
 } from "./expression.ts";
@@ -116,6 +123,12 @@ export const SCORE_LIMITS = Object.freeze({
   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,
@@ -413,6 +426,31 @@ export type Track = Readonly<{
    * 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
@@ -508,6 +546,51 @@ export type SampleRef = Readonly<{
    * 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. */
@@ -541,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
@@ -754,6 +845,10 @@ export type TrackPatch = Readonly<
     granular?: TrackGranular | null;
     keys?: TrackKeys | null;
     modal?: TrackModal | null;
+    softPedal?: Track["softPedal"] | null;
+    sostenuto?: Track["sostenuto"] | null;
+    guitar?: TrackGuitar | null;
+    wind?: TrackWind | null;
   }
 >;
 
@@ -802,6 +897,10 @@ export type TrackInput = Readonly<
     | "granular"
     | "keys"
     | "modal"
+    | "softPedal"
+    | "sostenuto"
+    | "guitar"
+    | "wind"
   > &
     Pick<Track, "id"> & {
       filter?: TrackFilter | null;
@@ -824,6 +923,10 @@ export type TrackInput = Readonly<
       granular?: TrackGranular | null;
       keys?: TrackKeys | null;
       modal?: TrackModal | null;
+      softPedal?: Track["softPedal"] | null;
+      sostenuto?: Track["sostenuto"] | null;
+      guitar?: TrackGuitar | null;
+      wind?: TrackWind | null;
     }
 >;
 
@@ -1224,6 +1327,18 @@ export function updateTrack(
         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;
     }),
   );
@@ -1814,6 +1929,13 @@ function normalizeTrack(input: unknown): Track {
       `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(
@@ -1835,6 +1957,28 @@ 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.
@@ -1907,9 +2051,89 @@ function normalizeTrack(input: unknown): Track {
     ...(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,
@@ -2032,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. */
@@ -2117,6 +2343,13 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
     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))
@@ -2309,6 +2542,28 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
       );
     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" &&
@@ -2320,9 +2575,100 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
       `${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:";
 

package/core/sdk/print.ts

@@ -27,6 +27,7 @@ import {
   MODAL_PARAMS,
   type TrackModal,
 } from "../resonators.ts";
+import { WIND_INSTRUMENT, WIND_PARAMS, type TrackWind } from "../winds.ts";
 import { rhythmVoicePitch, rowInSync } from "../rhythm.ts";
 import {
   BUILTIN_TABLE_PREFIX,
@@ -155,6 +156,7 @@ const RESERVED = new Set([
   "rig",
   "granular",
   "modal",
+  "wind",
   "slices",
   "euclid",
   "euclidRot",
@@ -414,6 +416,11 @@ export function printTrack(score: TrackScore, track: Track): string {
       ? printModal(track.modal, INDENT)
       : undefined;
   if (modalCall?.startsWith("modal(")) used.add("modal");
+  const windCall =
+    track.instrument === WIND_INSTRUMENT && track.wind
+      ? printWind(track.wind, INDENT)
+      : undefined;
+  if (windCall?.startsWith("wind(")) used.add("wind");
 
   const entries: string[] = [
     `id: ${str(track.id)}`,
@@ -432,6 +439,8 @@ export function printTrack(score: TrackScore, track: Track): string {
     entries.push(`instrument: ${printStringed(track.string!, INDENT)}`);
   } else if (modalCall) {
     entries.push(`instrument: ${modalCall}`);
+  } else if (windCall) {
+    entries.push(`instrument: ${windCall}`);
   } else entries.push(`instrument: ${str(track.instrument)}`);
   if (track.kit) entries.push(`kit: ${str(track.kit)}`);
   if (track.granular && !grained)
@@ -658,6 +667,7 @@ export function printTrack(score: TrackScore, track: Track): string {
     "rig",
     "granular",
     "modal",
+    "wind",
     "euclid",
     "grid",
   ]
@@ -808,13 +818,15 @@ function performanceEntries(score: TrackScore, track: Track): string[] {
             1,
           )}`,
     );
-  if (track.pedal) {
-    const events = track.pedal.map(
+  for (const key of ["pedal", "softPedal", "sostenuto"] as const) {
+    const lane = track[key];
+    if (!lane) continue;
+    const events = lane.map(
       (event) =>
         `[${num(event.tick / score.ticksPerBeat)}, ${str(event.state)}]`,
     );
     entries.push(
-      `pedal: ${list(events, INDENT, "pedal: ".length, 1, events.length > 1)}`,
+      `${key}: ${list(events, INDENT, `${key}: `.length, 1, events.length > 1)}`,
     );
   }
   if (track.velocityCurve)
@@ -851,6 +863,20 @@ function performanceEntries(score: TrackScore, track: Track): string[] {
       )}`,
     );
   }
+  if (track.guitar) {
+    const { tune, capo, hand, ring, position } = track.guitar;
+    const fields: [string, string][] = [];
+    if (tune !== undefined)
+      fields.push([
+        "tune",
+        typeof tune === "string" ? str(tune) : `[${tune.map(num).join(", ")}]`,
+      ]);
+    if (capo !== undefined) fields.push(["capo", num(capo)]);
+    if (hand !== undefined) fields.push(["hand", num(hand)]);
+    if (ring !== undefined) fields.push(["ring", num(ring)]);
+    if (position !== undefined) fields.push(["position", num(position)]);
+    entries.push(`guitar: ${obj(fields, INDENT, "guitar: ".length, 1)}`);
+  }
   return entries;
 }
 
@@ -1000,6 +1026,7 @@ function printModal(settings: TrackModal, indent: string): string {
     if (value === undefined) continue;
     params.push([key, typeof value === "number" ? num(value) : str(value)]);
   }
+  if (settings.pair !== undefined) params.push(["pair", str(settings.pair)]);
   const preset = settings.preset;
   if (params.length === 0 && preset && preset !== "marimba") return str(preset);
   const head = preset ? str(preset) : "";
@@ -1012,6 +1039,37 @@ function printModal(settings: TrackModal, indent: string): string {
   return `modal(${lead}{\n${params.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}})`;
 }
 
+/**
+ * A wind track's instrument: the preset word alone (`"flute"`) when there
+ * are no overrides, else `wind("sax", { breath: 0.8 })` with keys in
+ * `WIND_PARAMS` order. Every wind preset word is also an instrument word.
+ */
+function printWind(settings: TrackWind, indent: string): string {
+  const params: [string, string][] = [];
+  for (const key of Object.keys(WIND_PARAMS)) {
+    const value = (settings as Record<string, unknown>)[key];
+    if (value === undefined) continue;
+    params.push([
+      key,
+      typeof value === "number"
+        ? num(value)
+        : typeof value === "boolean"
+          ? String(value)
+          : str(String(value)),
+    ]);
+  }
+  const preset = settings.preset;
+  if (params.length === 0 && preset) return str(preset);
+  const head = preset ? str(preset) : "";
+  if (params.length === 0) return `wind(${head})`;
+  const lead = head ? `${head}, ` : "";
+  const inline = `wind(${lead}{ ${params.map(([k, v]) => `${k}: ${v}`).join(", ")} })`;
+  if (indent.length + "instrument: ".length + inline.length + 1 <= WIDTH)
+    return inline;
+  const inner = indent + INDENT;
+  return `wind(${lead}{\n${params.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}})`;
+}
+
 /** `wavetable("basic", { wt: 0.5 })`; pack tables keep their pin. */
 function printWavetable(settings: TrackWavetable, indent: string): string {
   const src = settings.table.src;
@@ -1071,6 +1129,23 @@ function printSample(ref: SampleRef, indent: string, prefix: number): string {
   if (ref.bpm !== undefined) entries.push(["bpm", num(ref.bpm)]);
   if (ref.fitmode !== undefined) entries.push(["fitmode", str(ref.fitmode)]);
   if (ref.len !== undefined) entries.push(["len", num(ref.len)]);
+  if (ref.shift !== undefined) entries.push(["shift", num(ref.shift)]);
+  if (ref.formant !== undefined) entries.push(["formant", num(ref.formant)]);
+  if (ref.fadeInTime !== undefined)
+    entries.push(["fadeInTime", num(ref.fadeInTime)]);
+  if (ref.fadeTime !== undefined) entries.push(["fadeTime", num(ref.fadeTime)]);
+  if (ref.from !== undefined) {
+    const from = ref.from;
+    const parts: [string, string][] = [["source", str(from.source)]];
+    if (from.section !== undefined) parts.push(["section", str(from.section)]);
+    if (from.bars !== undefined)
+      parts.push(["bars", `[${num(from.bars[0])}, ${num(from.bars[1])}]`]);
+    parts.push(["score", str(from.score)]);
+    entries.push(["from", obj(parts, indent + INDENT, "from: ".length, 1)]);
+  }
+  if (ref.vel !== undefined)
+    entries.push(["vel", `[${num(ref.vel[0])}, ${num(ref.vel[1])}]`]);
+  if (ref.rr !== undefined) entries.push(["rr", str(ref.rr)]);
   if (entries.length === 1) return str(ref.src);
   return obj(entries, indent, prefix, 1);
 }