@hraness/dawg 0.6.0 → 0.7.0

package/core/sdk/v1.ts

@@ -27,7 +27,7 @@
  */
 
 /** SDK release; dawg refreshes the vendored copy when its own is newer. */
-export const SDK_VERSION = "1.25.0";
+export const SDK_VERSION = "1.33.0";
 /** Major of `SDK_VERSION`; `dawg.json` records it as `sdk`. */
 export const SDK_MAJOR = 1;
 
@@ -242,6 +242,15 @@ export type Expression = Readonly<{
    * Humanize just bars 5-8 with `expr({ humanize: { timing: 10 } }, ...)`.
    */
   humanize?: Readonly<{ timing?: number; velocity?: number; length?: number }>;
+  /** The sung vowel on a `sing()` track (SDK 1.32.0): `"a"` .. `"u"` or a morph `"a>o"`. */
+  vowel?: string;
+  /** The syllable sung on this note (SDK 1.32.0): no spaces, `_` holds the previous one. */
+  lyric?: string;
+  /**
+   * On an autotune guide note (SDK 1.33.0): the share of slow pitch drift
+   * removed, 0..1, overriding the track's `autotune` drift.
+   */
+  drift?: number;
 }>;
 
 /** The expression a built note carries; fields are present only when set. */
@@ -251,6 +260,9 @@ export type NoteExpressionSpec = Readonly<{
   bend?: readonly BendPoint[];
   vibrato?: Readonly<{ rate: number; depth: number; delay?: number }>;
   humanize?: Readonly<{ timing?: number; velocity?: number; length?: number }>;
+  vowel?: string;
+  lyric?: string;
+  drift?: number;
 }>;
 
 const DEFAULT_VIBRATO_RATE = 5.5;
@@ -265,12 +277,20 @@ function expression(
     throw new DawgSdkError(`${label} expression must be an object`);
   for (const key of Object.keys(input))
     if (
-      !["articulation", "art", "glide", "bend", "vibrato", "humanize"].includes(
-        key,
-      )
+      ![
+        "articulation",
+        "art",
+        "glide",
+        "bend",
+        "vibrato",
+        "humanize",
+        "vowel",
+        "lyric",
+        "drift",
+      ].includes(key)
     )
       throw new DawgSdkError(
-        `${label} expression has an unknown field "${key.slice(0, 32)}" (articulation glide bend vibrato humanize)`,
+        `${label} expression has an unknown field "${key.slice(0, 32)}" (articulation glide bend vibrato humanize vowel lyric drift)`,
       );
   const out: {
     articulation?: Articulation;
@@ -282,6 +302,9 @@ function expression(
       velocity?: number;
       length?: number;
     }>;
+    vowel?: string;
+    lyric?: string;
+    drift?: number;
   } = {};
   const articulation = input.articulation ?? input.art;
   if (articulation !== undefined) {
@@ -352,9 +375,32 @@ function expression(
     }
     out.humanize = Object.freeze(amounts);
   }
+  if (input.vowel !== undefined)
+    out.vowel = singVowel(input.vowel, `${label} vowel`);
+  if (input.lyric !== undefined) out.lyric = lyricInput(input.lyric, label);
+  if (input.drift !== undefined) {
+    const drift = finite(input.drift, `${label} drift`);
+    if (drift < 0 || drift > 1)
+      throw new DawgSdkError(`${label} drift must be 0..1`);
+    out.drift = drift;
+  }
   return out;
 }
 
+/** A note's lyric: one syllable, no whitespace, at most 32 characters. */
+function lyricInput(value: unknown, label: string): string {
+  if (
+    typeof value !== "string" ||
+    value.length === 0 ||
+    value.length > LYRIC_LIMIT ||
+    /\s/u.test(value)
+  )
+    throw new DawgSdkError(
+      `${label} lyric must be one syllable of 1..${LYRIC_LIMIT} characters without spaces`,
+    );
+  return value;
+}
+
 /**
  * The same expression on many notes or hits (SDK 1.15.0); a note's own
  * fields win.
@@ -1166,16 +1212,36 @@ export const DRUM_PATTERNS: readonly DrumPattern[] = Object.freeze([
       euclid("hat", 16, 16, 0, { velocity: 0.35, accent: 0.4, accents: 4 }),
     ],
   ),
+  // The blues and rock shuffle is a triplet-8th feel: each beat is three
+  // 8th-note triplets with the first and third struck (long-short).
   drumPattern(
     "shuffle",
-    "Shuffle",
+    "Shuffle (triplet 8ths)",
     ["blues", "shuffle", "rock"],
     [90, 130, 110],
     "acoustic",
+    0,
+    [
+      grid("kick", "x.....x.....", { division: "1/8t" }),
+      grid("snare", "...x.....x..", { division: "1/8t" }),
+      grid("hat", "X.xx.xX.xx.x", {
+        division: "1/8t",
+        velocity: 0.35,
+        accent: 0.5,
+      }),
+    ],
+  ),
+  // The half-time shuffle swings 16ths against a backbeat on 3.
+  drumPattern(
+    "half-time-shuffle",
+    "Half-time shuffle (swung 16ths)",
+    ["shuffle", "rock", "funk"],
+    [70, 100, 86],
+    "acoustic",
     0.33,
     [
-      grid("kick", "x.......x......."),
-      grid("snare", "....x.......x..."),
+      grid("kick", "x.........x....."),
+      grid("snare", "........x......."),
       euclid("hat", 16, 16, 0, { velocity: 0.35, accent: 0.5, accents: 8 }),
     ],
   ),
@@ -1218,7 +1284,7 @@ export function pattern(name: string): readonly RhythmSpec[] {
   const found = findPattern(name);
   if (!found)
     throw new DawgSdkError(
-      `unknown drum pattern "${String(name).slice(0, 40)}" (${DRUM_PATTERNS.map((entry) => entry.name).join(" ")})`,
+      `unknown groove "${String(name).slice(0, 40)}" (${DRUM_PATTERNS.map((entry) => entry.name).join(" ")})`,
     );
   return found.rows;
 }
@@ -1283,6 +1349,30 @@ export type SampleSpec = Readonly<{
   fitmode?: "repitch" | "beats" | "tones";
   /** Window length in beats (SDK 1.20.0); `fit` wins over `bpm`, `bpm` over `len`. */
   len?: number;
+  /** Pitch shift in semitones at the same length (−24..24, SDK 1.29.0). */
+  shift?: number;
+  /** Formant shift in semitones with `shift` (SDK 1.29.0): absent follows the pitch, 0 keeps the formants. */
+  formant?: number;
+  /** Like Strudel `fadeTime`: release fade in seconds (0..2, SDK 1.29.0). */
+  fadeTime?: number;
+  /** Like Strudel `fadeInTime`: attack fade in seconds (0..2, SDK 1.29.0). */
+  fadeInTime?: number;
+  /** Where `resample` rendered the file from (informational, SDK 1.29.0). */
+  from?: SampleProvenanceSpec;
+  /** Velocity layer (SDK 1.31.0, SFZ lovel/hivel): MIDI velocities `[lo, hi]` this voice plays. */
+  vel?: readonly [number, number];
+  /** Round-robin group (SDK 1.31.0, SFZ seq_length): voices in a group take turns, A B A B. */
+  rr?: string;
+}>;
+
+/** `SampleSpec.from` (SDK 1.29.0): the source of a resampled file. */
+export type SampleProvenanceSpec = Readonly<{
+  /** `track:<id>`, `orbit:<n>` or `master`. */
+  source: string;
+  section?: string;
+  bars?: readonly [number, number];
+  /** sha256 of the score the file was rendered from. */
+  score: string;
 }>;
 
 /** Result of `sampler()`; pass it as a track's `instrument`. */
@@ -1446,9 +1536,13 @@ export const STRING_INSTRUMENT = "string";
  * String engine settings (SDK 1.21.0): a `preset` (`nylon`, `steel`,
  * `electric`, `jangle`, `ebass`, `slap`, `upright`, `sitar`, `tanpura`,
  * `harpsichord`, `lute`, `oud`, `setar`, `tar`, `santur`, `dulcimer`, `koto`,
- * `harp`, `banjo`, `tres`, `requinto`) plus any parameter to override
- * (`ring`, `bright`, `damp`, `pos`, `mute`, `buzz`, `body`, `sym`, ...).
- * dawg validates names and ranges; see **Strings** in DAWG.md.
+ * `harp`, `banjo`, `tres`, `requinto`; bowed since SDK 1.31.0: `violin`,
+ * `viola`, `cello`, `contrabass`, `fiddle`, `erhu`, `kamancheh`, `violins`,
+ * `violas`, `cellos`, `contrabasses`, `pizz`, `trem`) plus any parameter to
+ * override (`ring`, `bright`, `damp`, `pos`, `mute`, `buzz`, `body`, `sym`,
+ * bow: `exciter: "bow"`, `pressure`, `speed`, `attack`, `vib`, `vibmod`,
+ * `vibdelay`, `tremhz`, `sord`, `dyn`). dawg validates names and ranges;
+ * see **Strings** in DAWG.md.
  */
 export type StringInput = Readonly<
   { preset?: string } & Record<string, number | string | undefined>
@@ -1458,15 +1552,24 @@ export type StringInput = Readonly<
 export type StringSpec = Readonly<{ kind: "string" } & StringInput>;
 
 /**
- * A plucked string instrument (SDK 1.21.0): a preset and overrides.
+ * A plucked or bowed string instrument (SDK 1.21.0; bowed and the object
+ * form 1.31.0): a preset and overrides.
  *
  * instrument: stringed("nylon")
  * instrument: stringed("sitar", { buzz: 0.8, sym: 0.5 })
+ * instrument: stringed({ preset: "cello", vib: 6 })
  */
 export function stringed(
-  preset = "nylon",
+  preset: string | StringInput = "nylon",
   params: Readonly<Record<string, number | string>> = {},
 ): StringSpec {
+  if (isRecord(preset)) {
+    const { preset: name, ...rest } = preset as Record<string, unknown>;
+    return stringed(name === undefined ? "nylon" : (name as string), {
+      ...(rest as Record<string, number | string>),
+      ...params,
+    });
+  }
   if (typeof preset !== "string" || preset.length === 0)
     throw new DawgSdkError("stringed needs a preset name");
   if (!isRecord(params))
@@ -1567,7 +1670,23 @@ export type ModalPresetName =
   | "steelpan"
   | "bowl"
   | "gong"
-  | "timpani";
+  | "timpani"
+  // SDK 1.30.0: gamelan, small bells and frame drums.
+  | "crotales"
+  | "musicbox"
+  | "toypiano"
+  | "saron"
+  | "demung"
+  | "slenthem"
+  | "gangsa"
+  | "gender"
+  | "bonang"
+  | "kenong"
+  | "kethuk"
+  | "kempul"
+  | "daf"
+  | "bodhran"
+  | "tabla";
 
 /** Modal overrides; omitted means the preset's value. dawg validates ranges. */
 export type ModalParams = Readonly<{
@@ -1600,6 +1719,12 @@ export type ModalParams = Readonly<{
   gain?: number;
   /** Mode table override (`marimba`, `bell`, `gong`, …). */
   body?: string;
+  /**
+   * The partner track id of an ombak pair (SDK 1.30.0): this track (the
+   * pengisep) sounds `ombak` Hz above it. song() sets the partner's ombak
+   * to 0 (one straight voice) unless the partner gives its own.
+   */
+  pair?: string;
 }>;
 
 const MODAL_KEYS = Object.freeze([
@@ -1675,6 +1800,9 @@ const MODAL_RANGES: Readonly<Record<string, readonly [number, number]>> =
     gain: [0, 2],
   });
 
+/** Modal presets whose default carries an ombak twin bank (core/resonators.ts). */
+const MODAL_TWIN_PRESETS: readonly string[] = Object.freeze(["gangsa"]);
+
 const MODAL_PRESET_WORDS: readonly string[] = Object.freeze([
   "marimba",
   "vibes",
@@ -1688,6 +1816,21 @@ const MODAL_PRESET_WORDS: readonly string[] = Object.freeze([
   "bowl",
   "gong",
   "timpani",
+  "crotales",
+  "musicbox",
+  "toypiano",
+  "saron",
+  "demung",
+  "slenthem",
+  "gangsa",
+  "gender",
+  "bonang",
+  "kenong",
+  "kethuk",
+  "kempul",
+  "daf",
+  "bodhran",
+  "tabla",
 ]);
 
 /** Result of `modal()`; pass it as a track's `instrument`. */
@@ -1733,6 +1876,10 @@ export function modal(
           `modal ${key} "${String(value).slice(0, 32)}" is not one of ${words.join(" ")}`,
         );
       out[key] = value;
+    } else if (key === "pair") {
+      if (typeof value !== "string" || !/^[A-Za-z0-9_-]{1,64}$/.test(value))
+        throw new DawgSdkError("modal pair must be a track id");
+      out.pair = value;
     } else if ((MODAL_KEYS as readonly string[]).includes(key)) {
       const number = finite(value, `modal ${key}`);
       const [min, max] = MODAL_RANGES[key]!;
@@ -1741,12 +1888,760 @@ export function modal(
       out[key] = number;
     } else
       throw new DawgSdkError(
-        `modal has no parameter "${key.slice(0, 32)}" (${MODAL_KEYS.join(" ")})`,
+        `modal has no parameter "${key.slice(0, 32)}" (${MODAL_KEYS.join(" ")} pair)`,
       );
   }
   return Object.freeze(out) as ModalSpec;
 }
 
+// ---- winds (f061-gamelan-winds, SDK 1.30.0) ----
+
+/** The instrument value of the wind engine (core/winds.ts). */
+export const WIND_INSTRUMENT = "wind";
+
+/** Wind presets (core/winds.ts WIND_PRESET_NAMES). */
+export type WindPresetName =
+  | "flute"
+  | "recorder"
+  | "whistle"
+  | "ney"
+  | "shakuhachi"
+  | "panpipe"
+  | "suling"
+  | "bansuri"
+  | "clarinet"
+  | "bassclarinet"
+  | "oboe"
+  | "bassoon"
+  | "sax"
+  | "altosax"
+  | "barisax"
+  | "trumpet"
+  | "harmon"
+  | "plunger"
+  | "trombone"
+  | "tuba"
+  | "horn";
+
+const WIND_PRESET_WORDS: readonly string[] = Object.freeze([
+  "flute",
+  "recorder",
+  "whistle",
+  "ney",
+  "shakuhachi",
+  "panpipe",
+  "suling",
+  "bansuri",
+  "clarinet",
+  "bassclarinet",
+  "oboe",
+  "bassoon",
+  "sax",
+  "altosax",
+  "barisax",
+  "trumpet",
+  "harmon",
+  "plunger",
+  "trombone",
+  "tuba",
+  "horn",
+]);
+
+/** Wind overrides (core/winds.ts WIND_PARAMS). */
+export type WindParams = Readonly<{
+  model?: "jet" | "reed" | "sax" | "lips";
+  breath?: number;
+  noise?: number;
+  attack?: number;
+  release?: number;
+  vib?: number;
+  vibmod?: number;
+  reed?: number;
+  bright?: number;
+  stopped?: boolean;
+  mute?: "open" | "straight" | "cup" | "harmon" | "plunger";
+  wah?: number;
+  wahenv?: number;
+  growl?: number;
+  flutter?: number;
+  players?: number;
+  gain?: number;
+}>;
+
+/** Enum words per wind parameter (core/winds.ts WIND_PARAMS). */
+const WIND_ENUMS: Readonly<Record<string, readonly string[]>> = Object.freeze({
+  model: Object.freeze(["jet", "reed", "sax", "lips"]),
+  mute: Object.freeze(["open", "straight", "cup", "harmon", "plunger"]),
+});
+
+/** Numeric ranges (core/winds.ts WIND_PARAMS min..max). */
+const WIND_RANGES: Readonly<Record<string, readonly [number, number]>> =
+  Object.freeze({
+    breath: [0, 1],
+    noise: [0, 1],
+    attack: [0.001, 2],
+    release: [0.005, 2],
+    vib: [0, 12],
+    vibmod: [0, 1],
+    reed: [0, 1],
+    bright: [0, 1],
+    wah: [0, 1],
+    wahenv: [0, 1],
+    growl: [0, 1],
+    flutter: [0, 1],
+    players: [1, 8],
+    gain: [0, 2],
+  });
+
+/** Result of `wind()`; pass it as a track's `instrument`. */
+export type WindSpec = Readonly<
+  { kind: "wind"; preset?: WindPresetName } & WindParams
+>;
+
+/**
+ * Winds and brass on the wind engine (SDK 1.30.0): a preset and optional
+ * overrides. A preset word alone (`instrument: "flute"`) is the same as
+ * `wind("flute")`; the bare word `"wind"` stays the legacy wind tone.
+ *
+ * ```ts
+ * instrument: wind("sax", { breath: 0.8, growl: 0.2 })
+ * instrument: wind("trumpet", { mute: "harmon", players: 3 })
+ * instrument: wind({ bright: 0.3 }) // default preset (flute)
+ * ```
+ */
+export function wind(
+  preset?: WindPresetName | WindParams,
+  params: WindParams = {},
+): WindSpec {
+  const overrides = isRecord(preset) ? preset : params;
+  const name = isRecord(preset) ? undefined : preset;
+  if (!isRecord(overrides))
+    throw new DawgSdkError("wind params must be an object");
+  const out: Record<string, unknown> = { kind: "wind" };
+  if (name !== undefined) {
+    if (typeof name !== "string" || !WIND_PRESET_WORDS.includes(name))
+      throw new DawgSdkError(
+        `wind preset "${String(name).slice(0, 32)}" is not one of ${WIND_PRESET_WORDS.join(" ")}`,
+      );
+    out.preset = name;
+  }
+  for (const key of Object.keys(overrides)) {
+    const value = (overrides as Record<string, unknown>)[key];
+    if (value === undefined) continue;
+    const words = WIND_ENUMS[key];
+    if (words) {
+      if (typeof value !== "string" || !words.includes(value))
+        throw new DawgSdkError(
+          `wind ${key} "${String(value).slice(0, 32)}" is not one of ${words.join(" ")}`,
+        );
+      out[key] = value;
+    } else if (key === "stopped") {
+      if (typeof value !== "boolean")
+        throw new DawgSdkError("wind stopped must be true or false");
+      out.stopped = value;
+    } else if (WIND_RANGES[key]) {
+      const number = finite(value, `wind ${key}`);
+      const [min, max] = WIND_RANGES[key]!;
+      if (number < min || number > max)
+        throw new DawgSdkError(`wind ${key} must be ${min}..${max}`);
+      if (key === "players" && !Number.isInteger(number))
+        throw new DawgSdkError("wind players must be a whole number");
+      out[key] = number;
+    } else
+      throw new DawgSdkError(
+        `wind has no parameter "${key.slice(0, 32)}" (${[...Object.keys(WIND_ENUMS), "stopped", ...Object.keys(WIND_RANGES)].join(" ")})`,
+      );
+  }
+  return Object.freeze(out) as WindSpec;
+}
+
+// ---- vocoder (f07-vocoder, SDK 1.32.0) ----
+
+/** The instrument value of the built-in vocoder carrier (core/vocoder.ts). */
+export const VOCODER_INSTRUMENT = "vocoder";
+
+/** Vocoder presets (core/vocoder.ts VOCODER_PRESET_NAMES). */
+export type VocoderPresetName =
+  | "classic"
+  | "robot"
+  | "talkbox"
+  | "choir"
+  | "glass"
+  | "whisper"
+  | "smear"
+  | "lofi";
+
+const VOCODER_PRESET_WORDS: readonly string[] = Object.freeze([
+  "classic",
+  "robot",
+  "talkbox",
+  "choir",
+  "glass",
+  "whisper",
+  "smear",
+  "lofi",
+]);
+
+/** Vocoder overrides (core/vocoder.ts VOCODER_PARAMS). */
+export type VocoderParams = Readonly<{
+  /** The modulator track: an id or a name slug (`"vox"`, `"lead-vox"`). */
+  src?: string;
+  tap?: "chain" | "dry";
+  mode?: "channel" | "talkbox";
+  carrier?: "saw" | "supersaw" | "pulse" | "noise";
+  follow?: "notes" | "chords" | "drone";
+  root?: number;
+  spread?: number;
+  bands?: number;
+  lo?: number;
+  hi?: number;
+  width?: number;
+  attack?: number;
+  release?: number;
+  formant?: number;
+  unvoiced?: number;
+  sens?: number;
+  hiss?: number;
+  gate?: number | "auto";
+  enhance?: boolean;
+  depth?: number;
+  freeze?: boolean;
+  mix?: number;
+  gain?: number;
+  seed?: number;
+}>;
+
+const VOCODER_ENUMS: Readonly<Record<string, readonly string[]>> =
+  Object.freeze({
+    tap: Object.freeze(["chain", "dry"]),
+    mode: Object.freeze(["channel", "talkbox"]),
+    carrier: Object.freeze(["saw", "supersaw", "pulse", "noise"]),
+    follow: Object.freeze(["notes", "chords", "drone"]),
+  });
+
+const VOCODER_RANGES: Readonly<Record<string, readonly [number, number]>> =
+  Object.freeze({
+    root: [24, 96],
+    spread: [0, 1],
+    bands: [4, 40],
+    lo: [50, 1000],
+    hi: [2000, 12000],
+    width: [0.25, 4],
+    attack: [0.0005, 0.2],
+    release: [0.005, 2],
+    formant: [-24, 24],
+    unvoiced: [0, 1],
+    sens: [0, 1],
+    hiss: [0, 1],
+    gate: [-90, 0],
+    depth: [0, 1],
+    mix: [0, 1],
+    gain: [-24, 24],
+    seed: [0, 2 ** 31],
+  });
+
+const VOCODER_INTEGERS: readonly string[] = Object.freeze([
+  "root",
+  "bands",
+  "seed",
+]);
+
+/** Result of `vocoder()`: a track's `instrument` or its `vocoder` field. */
+export type VocoderSpec = Readonly<
+  { kind: "vocoder"; preset?: VocoderPresetName } & VocoderParams
+>;
+
+/**
+ * A vocoder (SDK 1.32.0): another track's voice (`src`) shapes this track's
+ * sound. As the `instrument` it plays the built-in carrier (a supersaw
+ * following the notes); as the `vocoder` field it vocodes the track's own
+ * synth or sampler. `src` takes a track id or a name slug.
+ *
+ * ```ts
+ * instrument: vocoder("talkbox", { src: "vox", formant: 2 })
+ * vocoder: vocoder({ src: "t-vox", bands: 24 })
+ * ```
+ */
+export function vocoder(
+  preset?: VocoderPresetName | VocoderParams,
+  params: VocoderParams = {},
+): VocoderSpec {
+  const overrides = isRecord(preset) ? preset : params;
+  const name = isRecord(preset) ? undefined : preset;
+  if (!isRecord(overrides))
+    throw new DawgSdkError("vocoder params must be an object");
+  const out: Record<string, unknown> = { kind: "vocoder" };
+  if (name !== undefined) {
+    if (typeof name !== "string" || !VOCODER_PRESET_WORDS.includes(name))
+      throw new DawgSdkError(
+        `vocoder preset "${String(name).slice(0, 32)}" is not one of ${VOCODER_PRESET_WORDS.join(" ")}`,
+      );
+    out.preset = name;
+  }
+  for (const key of Object.keys(overrides)) {
+    const value = (overrides as Record<string, unknown>)[key];
+    if (value === undefined) continue;
+    const words = VOCODER_ENUMS[key];
+    if (key === "src") {
+      if (typeof value !== "string" || value.length === 0 || value.length > 64)
+        throw new DawgSdkError("vocoder src must be a track id or name slug");
+      out.src = value;
+    } else if (words) {
+      if (typeof value !== "string" || !words.includes(value))
+        throw new DawgSdkError(
+          `vocoder ${key} "${String(value).slice(0, 32)}" is not one of ${words.join(" ")}`,
+        );
+      out[key] = value;
+    } else if (key === "enhance" || key === "freeze") {
+      if (typeof value !== "boolean")
+        throw new DawgSdkError(`vocoder ${key} must be true or false`);
+      out[key] = value;
+    } else if (key === "gate" && value === "auto") {
+      out.gate = "auto";
+    } else if (VOCODER_RANGES[key]) {
+      const number = finite(value, `vocoder ${key}`);
+      const [min, max] = VOCODER_RANGES[key]!;
+      if (number < min || number > max)
+        throw new DawgSdkError(`vocoder ${key} must be ${min}..${max}`);
+      if (VOCODER_INTEGERS.includes(key) && !Number.isInteger(number))
+        throw new DawgSdkError(`vocoder ${key} must be a whole number`);
+      out[key] = number;
+    } else
+      throw new DawgSdkError(
+        `vocoder has no parameter "${key.slice(0, 32)}" (src ${[...Object.keys(VOCODER_ENUMS), "enhance", "freeze", ...Object.keys(VOCODER_RANGES)].join(" ")})`,
+      );
+  }
+  return Object.freeze(out) as VocoderSpec;
+}
+
+/**
+ * The vocoder field a track gets: its `vocoder` property, else a
+ * `vocoder(...)` instrument, else `{}` for the bare word `"vocoder"` (the
+ * built-in carrier with every default). `null` removes it.
+ */
+function trackVocoder(
+  rawInstrument: unknown,
+  field: unknown,
+): Readonly<{ preset?: VocoderPresetName } & VocoderParams> | undefined {
+  const strip = (spec: unknown) => {
+    if (!isRecord(spec) || spec.kind !== "vocoder")
+      throw new DawgSdkError("track vocoder must come from vocoder()");
+    const { kind: _kind, ...fields } = spec as VocoderSpec;
+    return Object.freeze(fields);
+  };
+  if (field !== undefined && field !== null) return strip(field);
+  if (isRecord(rawInstrument) && rawInstrument.kind === "vocoder")
+    return strip(rawInstrument);
+  if (rawInstrument === VOCODER_INSTRUMENT) return Object.freeze({});
+  return undefined;
+}
+
+/** Lowercase dash slug of a track name (core/slug.ts trackSlug). */
+function vocoderSlug(text: string): string {
+  const slug = text
+    .normalize("NFKD")
+    .replace(/\p{M}+/gu, "")
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 64)
+    .replace(/-+$/g, "");
+  return slug.length > 0 ? slug : "track";
+}
+
+/**
+ * `src` as a track id: an id wins, then a unique name slug. Errors when
+ * nothing matches, two tracks share the slug, or the track names itself.
+ */
+function resolveVocoderSrc(
+  tracks: readonly Readonly<{ id: string; name: string }>[],
+  self: string,
+  src: string,
+): string {
+  const byId = tracks.find((track) => track.id === src);
+  const matches = byId
+    ? [byId]
+    : tracks.filter((track) => vocoderSlug(track.name) === vocoderSlug(src));
+  if (matches.length === 0)
+    throw new DawgSdkError(
+      `track ${self}: vocoder src "${src.slice(0, 64)}" names no track; delete src (the carrier plays alone) or point it at a track in this song`,
+    );
+  if (matches.length > 1)
+    throw new DawgSdkError(
+      `track ${self}: vocoder src "${src.slice(0, 64)}" matches ${matches.length} tracks; use an id`,
+    );
+  if (matches[0]!.id === self)
+    throw new DawgSdkError(`track ${self}: a track cannot vocode itself`);
+  return matches[0]!.id;
+}
+
+/**
+ * The wind field an instrument makes: `wind(...)`, or a wind preset word
+ * (`"flute"`, `"saxophone"`). The bare word `"wind"` keeps its pre-0.6.1
+ * meaning (the legacy tone) and makes none.
+ */
+function trackWind(
+  raw: unknown,
+): Readonly<{ preset?: WindPresetName } & WindParams> | undefined {
+  if (isRecord(raw) && raw.kind === "wind") {
+    const { kind: _kind, ...fields } = raw as WindSpec;
+    return Object.freeze(fields);
+  }
+  if (typeof raw !== "string" || raw === WIND_INSTRUMENT) return undefined;
+  const meaning = resolveInstrumentWord(raw);
+  if (meaning?.instrument !== WIND_INSTRUMENT || !meaning.preset)
+    return undefined;
+  return Object.freeze({ preset: meaning.preset as WindPresetName });
+}
+
+// ---- sing (f07-sing, SDK 1.32.0) ----
+
+/** The instrument value of the singing voice (core/sing.ts). */
+export const SING_INSTRUMENT = "sing";
+
+/** Sing presets (core/sing.ts SING_PRESET_NAMES). */
+export type SingPresetName =
+  | "aah"
+  | "ooh"
+  | "choir"
+  | "oohchoir"
+  | "chorale"
+  | "airy"
+  | "glass"
+  | "lament"
+  | "soprano"
+  | "basso"
+  | "drone"
+  | "khoomei"
+  | "sygyt"
+  | "kargyraa";
+
+const SING_PRESET_WORDS: readonly string[] = Object.freeze([
+  "aah",
+  "ooh",
+  "choir",
+  "oohchoir",
+  "chorale",
+  "airy",
+  "glass",
+  "lament",
+  "soprano",
+  "basso",
+  "drone",
+  "khoomei",
+  "sygyt",
+  "kargyraa",
+]);
+
+/** Sing overrides (core/sing.ts SING_PARAMS). */
+export type SingParams = Readonly<{
+  voice?: "auto" | "soprano" | "alto" | "tenor" | "bass";
+  /** `"a"`, `"e"`, `"i"`, `"o"`, `"u"` or a morph `"a>o"`. */
+  vowel?: string;
+  morph?: number;
+  formant?: number;
+  bright?: number;
+  breath?: number;
+  jitter?: number;
+  shimmer?: number;
+  attack?: number;
+  release?: number;
+  vib?: number;
+  vibmod?: number;
+  vibdelay?: number;
+  voices?: number;
+  spread?: number;
+  ring?: number;
+  /** Throat drone: a note name (`"D3"`) or MIDI 36..67. */
+  drone?: string | number;
+  overtone?: number;
+  /** Throat melody harmonic range `[lo, hi]`, 2..24. */
+  harmonics?: readonly [number, number];
+  sub?: number;
+  gain?: number;
+}>;
+
+const SING_VOWEL_LETTERS: readonly string[] = Object.freeze([
+  "a",
+  "e",
+  "i",
+  "o",
+  "u",
+]);
+
+/** Numeric ranges (core/sing.ts SING_PARAMS min..max). */
+const SING_RANGES: Readonly<Record<string, readonly [number, number]>> =
+  Object.freeze({
+    morph: [0, 1],
+    formant: [-12, 12],
+    bright: [0, 1],
+    breath: [0, 1],
+    jitter: [0, 3],
+    shimmer: [0, 1],
+    attack: [0.005, 2],
+    release: [0.01, 4],
+    vib: [0, 9],
+    vibmod: [0, 1],
+    vibdelay: [0, 2],
+    voices: [1, 8],
+    spread: [0, 40],
+    ring: [0, 1],
+    overtone: [0, 1],
+    sub: [0, 1],
+    gain: [0, 2],
+  });
+
+/** Result of `sing()`; pass it as a track's `instrument`. */
+export type SingSpec = Readonly<
+  { kind: "sing"; preset?: SingPresetName } & SingParams
+>;
+
+/** `"a"` or `"a>o"`, lower-cased; throws otherwise. */
+function singVowel(value: unknown, label: string): string {
+  const parts =
+    typeof value === "string" ? value.trim().toLowerCase().split(">") : [];
+  if (
+    (parts.length === 1 || parts.length === 2) &&
+    parts.every((part) => SING_VOWEL_LETTERS.includes(part))
+  )
+    return parts.join(">");
+  throw new DawgSdkError(
+    `${label} must be one of ${SING_VOWEL_LETTERS.join(" ")} or a morph like a>o`,
+  );
+}
+
+/**
+ * The built-in singing voice (SDK 1.32.0): an LF glottal source through
+ * SATB formants, choirs, and Tuvan throat singing. A preset word alone
+ * (`instrument: "choir"`) is the same as `sing("choir")`. Notes sing their
+ * `vowel` (`note("A3", 0, 2, 0.8, { vowel: "a>o" })`), else their lyric's
+ * vowel, else the track's.
+ *
+ * ```ts
+ * instrument: sing("choir", { vowel: "o" })
+ * instrument: sing("khoomei", { drone: "D3" }) // notes pick the overtone
+ * instrument: sing({ voices: 4, breath: 0.3 }) // default preset (aah)
+ * ```
+ */
+export function sing(
+  preset?: SingPresetName | SingParams,
+  params: SingParams = {},
+): SingSpec {
+  const overrides = isRecord(preset) ? preset : params;
+  const name = isRecord(preset) ? undefined : preset;
+  if (!isRecord(overrides))
+    throw new DawgSdkError("sing params must be an object");
+  const out: Record<string, unknown> = { kind: "sing" };
+  if (name !== undefined) {
+    if (typeof name !== "string" || !SING_PRESET_WORDS.includes(name))
+      throw new DawgSdkError(
+        `sing preset "${String(name).slice(0, 32)}" is not one of ${SING_PRESET_WORDS.join(" ")}`,
+      );
+    out.preset = name;
+  }
+  for (const key of Object.keys(overrides)) {
+    const value = (overrides as Record<string, unknown>)[key];
+    if (value === undefined) continue;
+    if (key === "voice") {
+      const voices = ["auto", "soprano", "alto", "tenor", "bass"];
+      if (typeof value !== "string" || !voices.includes(value))
+        throw new DawgSdkError(`sing voice must be one of ${voices.join(" ")}`);
+      out.voice = value;
+    } else if (key === "vowel") out.vowel = singVowel(value, "sing vowel");
+    else if (key === "drone") {
+      const midiValue =
+        typeof value === "number" ? value : midi(value as Pitch);
+      if (!Number.isInteger(midiValue) || midiValue < 36 || midiValue > 67)
+        throw new DawgSdkError(
+          'sing drone must be a note name C2..G4 (e.g. "D3") or MIDI 36..67',
+        );
+      out.drone = midiValue;
+    } else if (key === "harmonics") {
+      if (
+        !Array.isArray(value) ||
+        value.length !== 2 ||
+        !value.every((h) => Number.isInteger(h) && h >= 2 && h <= 24) ||
+        value[0] >= value[1]
+      )
+        throw new DawgSdkError(
+          "sing harmonics must be [lo, hi], whole numbers 2..24 with lo < hi",
+        );
+      out.harmonics = Object.freeze([value[0], value[1]]);
+    } else if (SING_RANGES[key]) {
+      const number = finite(value, `sing ${key}`);
+      const [min, max] = SING_RANGES[key]!;
+      if (number < min || number > max)
+        throw new DawgSdkError(`sing ${key} must be ${min}..${max}`);
+      if (key === "voices" && !Number.isInteger(number))
+        throw new DawgSdkError("sing voices must be a whole number");
+      out[key] = number;
+    } else
+      throw new DawgSdkError(
+        `sing has no parameter "${key.slice(0, 32)}" (voice vowel drone harmonics ${Object.keys(SING_RANGES).join(" ")})`,
+      );
+  }
+  return Object.freeze(out) as SingSpec;
+}
+
+/**
+ * The sing field an instrument makes: `sing(...)`, or a sing preset word
+ * (`"choir"`, `"khoomei"`); `"sing"` alone is the default preset.
+ */
+function trackSing(
+  raw: unknown,
+): Readonly<{ preset?: SingPresetName } & SingParams> | undefined {
+  if (isRecord(raw) && raw.kind === "sing") {
+    const { kind: _kind, ...fields } = raw as SingSpec;
+    return Object.freeze(fields);
+  }
+  if (typeof raw !== "string") return undefined;
+  const meaning = resolveInstrumentWord(raw);
+  if (meaning?.instrument !== SING_INSTRUMENT) return undefined;
+  return Object.freeze(
+    meaning.preset ? { preset: meaning.preset as SingPresetName } : {},
+  );
+}
+
+// ---- autotune (f07-autotune, SDK 1.33.0) ----
+
+/** Autotune presets, gentle to hard (core/autotune.ts AUTOTUNE_PRESETS). */
+export type AutotunePresetName =
+  | "hard"
+  | "robot"
+  | "warble"
+  | "trap"
+  | "pop"
+  | "natural"
+  | "gentle"
+  | "guided"
+  | "locked";
+
+const AUTOTUNE_PRESET_WORDS: readonly string[] = Object.freeze([
+  "hard",
+  "robot",
+  "warble",
+  "trap",
+  "pop",
+  "natural",
+  "gentle",
+  "guided",
+  "locked",
+]);
+
+/** Autotune fields; dawg checks the ranges (core/autotune.ts AUTOTUNE_PARAMS). */
+export type AutotuneParams = Readonly<{
+  /** Targets: `scale` (song or track key, else chromatic), `chromatic`, `chord`, `notes`. */
+  to?: "scale" | "chromatic" | "chord" | "notes";
+  /** Guide track id for `to: "notes"` (a vocal track may use its own notes). */
+  from?: string;
+  /** Scale for this track, e.g. `"D bayati"`; default the song key. */
+  key?: string;
+  /** Retune time in ms, 0..400; 0 is instant and stepped. */
+  speed?: number;
+  /** 0..1 slower retune on held notes. */
+  relax?: number;
+  /** ms 50..1000 before a note counts as held. */
+  hold?: number;
+  /** 0..100: higher only pulls notes already near a target. */
+  flex?: number;
+  /** Seconds 0..0.5 to move between targets. */
+  glide?: number;
+  /** 0..1 correction strength. */
+  amount?: number;
+  /** Added vibrato rate in Hz, 0..12 (0 off). */
+  vib?: number;
+  /** Added vibrato depth in semitones, 0..1. */
+  vibmod?: number;
+  /** Notes mode: 0..1 how far each note's middle moves to the written pitch. */
+  center?: number;
+  /** Notes mode: 0..1 share of slow drift removed. */
+  drift?: number;
+  /** Tracker range: `auto`, `bass`, `tenor`, `alto`, `soprano`. */
+  voice?: "auto" | "bass" | "tenor" | "alto" | "soprano";
+}>;
+
+/** Stored autotune settings: a preset and any fields that override it. */
+export type AutotuneSettings = Readonly<
+  { preset?: AutotunePresetName } & AutotuneParams
+>;
+
+/** Result of `autotune()`; pass it as a track's `autotune`. */
+export type AutotuneSpec = Readonly<{ kind: "autotune" } & AutotuneSettings>;
+
+const AUTOTUNE_PARAM_KEYS: readonly string[] = Object.freeze([
+  "to",
+  "from",
+  "key",
+  "speed",
+  "relax",
+  "hold",
+  "flex",
+  "glide",
+  "amount",
+  "vib",
+  "vibmod",
+  "center",
+  "drift",
+  "voice",
+]);
+
+/**
+ * Pitch correction (SDK 1.33.0), from `gentle` to `hard`; the preset word
+ * alone also works as a track's `autotune`. Fields override the preset.
+ *
+ * autotune: "hard"
+ * autotune: autotune("pop", { speed: 40, key: "D bayati" })
+ * autotune: autotune("guided", { from: "lead" })
+ */
+export function autotune(
+  preset?: AutotunePresetName | AutotuneParams,
+  params?: AutotuneParams,
+): AutotuneSpec {
+  const fields =
+    typeof preset === "object" && preset !== null ? preset : (params ?? {});
+  const name = typeof preset === "string" ? preset : undefined;
+  return Object.freeze({
+    kind: "autotune" as const,
+    ...autotuneInput(
+      { ...(name ? { preset: name } : {}), ...fields },
+      "autotune",
+    ),
+  });
+}
+
+function autotuneInput(raw: unknown, where: string): AutotuneSettings {
+  if (typeof raw === "string") raw = { preset: raw };
+  if (!isRecord(raw))
+    throw new DawgSdkError(
+      `${where} autotune must be a preset word or autotune()`,
+    );
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (key === "kind" || value === undefined) continue;
+    if (key === "preset") {
+      if (typeof value !== "string" || !AUTOTUNE_PRESET_WORDS.includes(value))
+        throw new DawgSdkError(
+          `${where} autotune preset "${String(value).slice(0, 32)}" is not one of ${AUTOTUNE_PRESET_WORDS.join(" ")}`,
+        );
+      out.preset = value;
+    } else if (!AUTOTUNE_PARAM_KEYS.includes(key)) {
+      throw new DawgSdkError(
+        `${where} autotune has no field "${key.slice(0, 32)}" (preset ${AUTOTUNE_PARAM_KEYS.join(" ")})`,
+      );
+    } else if (["to", "from", "key", "voice"].includes(key)) {
+      if (typeof value !== "string")
+        throw new DawgSdkError(`${where} autotune ${key} must be a string`);
+      out[key] = value;
+    } else out[key] = finite(value, `${where} autotune ${key}`);
+  }
+  if (Object.keys(out).length === 0)
+    throw new DawgSdkError(`${where} autotune needs a preset or fields`);
+  const ordered: Record<string, unknown> = {};
+  for (const key of ["preset", ...AUTOTUNE_PARAM_KEYS])
+    if (out[key] !== undefined) ordered[key] = out[key];
+  return Object.freeze(ordered) as AutotuneSettings;
+}
+
 /**
  * `count` equal slices of one file as voices `prefix0 … prefixN-1`, for
  * chopped breaks: `sampler(slices("samples/break.wav", 8, "brk"))`, then
@@ -1800,6 +2695,13 @@ function sampleSpec(value: string | SampleSpec, name: string): SampleSpec {
     bpm?: number;
     fitmode?: "repitch" | "beats" | "tones";
     len?: number;
+    shift?: number;
+    formant?: number;
+    fadeTime?: number;
+    fadeInTime?: number;
+    from?: SampleProvenanceSpec;
+    vel?: readonly [number, number];
+    rr?: string;
   } = { src: spec.src };
   if (spec.src.startsWith("pack:")) {
     if (spec.sha256 !== undefined)
@@ -1862,6 +2764,27 @@ function sampleSpec(value: string | SampleSpec, name: string): SampleSpec {
     out.fitmode = spec.fitmode;
   }
   if (spec.len !== undefined) out.len = finite(spec.len, `${name} len`);
+  if (spec.shift !== undefined) out.shift = finite(spec.shift, `${name} shift`);
+  if (spec.formant !== undefined)
+    out.formant = finite(spec.formant, `${name} formant`);
+  if (spec.fadeTime !== undefined)
+    out.fadeTime = finite(spec.fadeTime, `${name} fadeTime`);
+  if (spec.fadeInTime !== undefined)
+    out.fadeInTime = finite(spec.fadeInTime, `${name} fadeInTime`);
+  if (spec.from !== undefined) {
+    if (typeof spec.from !== "object" || spec.from === null)
+      throw new DawgSdkError(`${name} from must be an object`);
+    out.from = spec.from;
+  }
+  if (spec.vel !== undefined) {
+    if (!Array.isArray(spec.vel) || spec.vel.length !== 2)
+      throw new DawgSdkError(`${name} vel must be [lo, hi]`);
+    out.vel = Object.freeze([
+      finite(spec.vel[0], `${name} vel`),
+      finite(spec.vel[1], `${name} vel`),
+    ] as const);
+  }
+  if (spec.rr !== undefined) out.rr = text(spec.rr, `${name} rr`);
   return Object.freeze(out);
 }
 
@@ -2018,14 +2941,85 @@ export const RIG_PRESETS: Readonly<
     head: { type: "chime", gain: 3, treble: 7 },
     cab: { type: "2x12", mic: 0.2 },
     compressor: { threshold: -20, ratio: 4, attack: 0.01, release: 0.15 },
+    // The `rig jangle` command adds `double` since 0.6.1; rig("jangle")
+    // keeps its 0.6.0 stages so older song.ts files sound the same. Add
+    // `double: { time: 12, drift: 1.5, width: 0.5 }` for the new one.
   },
   alt: {
     stomp: { type: "rat", gain: 6, tone: 0.4 },
     head: { type: "crunch", gain: 4 },
     cab: { type: "4x12" },
   },
+  // SDK 1.27.0 shoegaze rigs. Their long wash is the track's `reverb`
+  // (see `rigReverb` in the `rig` command), not part of `rig()`.
+  shoegaze: {
+    stomp: { type: "fuzz", gain: 7, tone: 0.45 },
+    head: { type: "chime", gain: 4 },
+    cab: { type: "2x12" },
+    wobble: { depth: 25, rate: 0.4, drift: 0.4 },
+    bloom: { amount: 0.4, harm: 2, delay: 0.6, time: 1 },
+    double: { time: 18, drift: 2.5, width: 0.4 },
+    postgain: { gain: 0.86 },
+  },
+  glide: {
+    stomp: { type: "face", gain: 5, tone: 0.5 },
+    head: { type: "clean", gain: 4, treble: 5 },
+    cab: { type: "2x12" },
+    wobble: { depth: 35, rate: 0.4, drift: 0.4 },
+    postgain: { gain: 0.8 },
+  },
+  dreampop: {
+    stomp: undefined,
+    head: { type: "clean", gain: 2, treble: 6 },
+    cab: { type: "1x12" },
+    chorus: { rate: 0.6, depth: 0.3, mix: 0.35 },
+    double: { time: 14, drift: 2, width: 0.4 },
+    postgain: { gain: 1.45 },
+  },
+  swell: {
+    stomp: undefined,
+    head: { type: "clean", gain: 3, treble: 5 },
+    cab: { type: "1x12" },
+    swell: { time: 0.5 },
+    postgain: { gain: 1.25 },
+  },
+  ebow: {
+    stomp: { type: "od", gain: 3, tone: 0.5, level: 3 },
+    head: { type: "lead", gain: 5, mid: 6 },
+    cab: { type: "4x12" },
+    swell: { time: 0.25 },
+    bloom: { amount: 0.8, harm: 1, delay: 0.1, time: 0.6 },
+  },
 });
 
+/**
+ * The long wash a rig preset sets as the track's `reverb` (SDK 1.27.0),
+ * as the `rig` command stores it. `rig()` returns `fx` only, so give it
+ * as `reverb: rigReverb("shoegaze")`; `instrument: "shoegaze"` adds it
+ * when the track has no `reverb` of its own.
+ */
+const RIG_REVERBS: Readonly<Record<string, ReverbInput & { mix: number }>> =
+  Object.freeze({
+    spring: { mix: 0.3, size: 0.35, fade: 1.5, predelay: 0, dim: 3500 },
+    shoegaze: { mix: 0.35, size: 0.9, fade: 4, predelay: 0.02, dim: 6000 },
+    glide: { mix: 0.35, size: 0.7, fade: 2.5, predelay: 0.01, dim: 6000 },
+    dreampop: { mix: 0.4, size: 0.85, fade: 5, predelay: 0.03, dim: 7000 },
+    swell: { mix: 0.45, size: 0.8, fade: 4, predelay: 0.02, dim: 6500 },
+  });
+
+/** A rig preset's track reverb (`spring`, the shoegaze rigs), if any. */
+export function rigReverb(name: string): ReverbInput | undefined {
+  if (
+    typeof name !== "string" ||
+    !Object.prototype.hasOwnProperty.call(RIG_PRESETS, name)
+  )
+    throw new DawgSdkError(
+      `unknown rig "${String(name)}" (rigs: ${Object.keys(RIG_PRESETS).join(", ")})`,
+    );
+  const values = RIG_REVERBS[name];
+  return values === undefined ? undefined : Object.freeze({ ...values });
+}
+
 /**
  * A guitar rig for a track's `fx` (SDK 1.22.0): the stomp → head → cab
  * stages of rig preset `name` and its companion effects (as the `rig`
@@ -2093,15 +3087,21 @@ export type FxInput = Readonly<Record<string, EffectParams>>;
  * Every parameter, range and default: **Synth** in DAWG.md.
  */
 /**
- * Modelled piano settings (SDK 1.24.0), for a track whose instrument is a
+ * Modelled keys settings (SDK 1.24.0), for a track whose instrument is a
  * piano family (`"grand"`, `"upright"`, `"felt"`, `"honkytonk"`,
- * `"prepared"`; the words `"ballad"` and `"lofi"` pick presets). Every field
- * is optional; `{}` is the family's own sound. Automate a parameter with
+ * `"prepared"`; the words `"ballad"` and `"lofi"` pick presets) or, from
+ * SDK 1.26.0, an electric family (`"epiano"`, `"wurli"`, `"clav"`; presets
+ * epiano suitcase dyno wurli clav funkclav). Every field is optional; `{}`
+ * is the family's own sound. Automate a parameter with
  * `automation.fx["keys-<param>"]` (hardness, touch, decay, release, knock,
- * noise, felt), read at each note's onset. Ranges: **Keys** in DAWG.md.
+ * noise, felt; electric tone, vibe, trem), read at each note's onset.
+ * Ranges: **Keys** in DAWG.md.
  */
 export type KeysInput = Readonly<{
-  /** A named preset: grand ballad upright felt lofi honkytonk prepared. */
+  /**
+   * A named preset: grand ballad upright felt lofi honkytonk prepared, or
+   * electric epiano suitcase dyno wurli clav funkclav.
+   */
   preset?: string;
   /** Hammer hardness 0..1: brightness at a given velocity (0.5). */
   hardness?: number;
@@ -2137,6 +3137,53 @@ export type KeysInput = Readonly<{
   vib?: number;
   /** Pitch wobble depth in semitones (0.5). */
   vibmod?: number;
+  // keys-electric (SDK 1.26.0)
+  /** Sympathetic string resonance 0..1 under the sustain pedal (0; pianos). */
+  sym?: number;
+  /** Pickup drive 0..1: growl when played hard (0.35; epiano, wurli). */
+  bark?: number;
+  /** Tine or reed bell ping 0..1 (0.5; epiano, wurli). */
+  bell?: number;
+  /** Output low-pass in Hz, 0 off (electric keys). */
+  tone?: number;
+  /** Clav pickup switch: neck bridge both out ("both"). */
+  pickup?: "neck" | "bridge" | "both" | "out";
+  /** Clav mute slider 0..1 (0). */
+  mute?: number;
+  /** Suitcase stereo vibrato depth 0..1 (0; epiano). */
+  vibe?: number;
+  /** Suitcase vibrato rate in Hz 0.5..12 (4; epiano). */
+  vibehz?: number;
+  // Organs (SDK 1.28.0), for instrument `"tonewheel"`, `"combo"` or
+  // `"pipe"` (presets tonewheel gospel jazzorgan combo vox pipe flutes
+  // cornet reeds celeste). `"organ"` stays the legacy sine voice.
+  /** Tonewheel drawbars, nine digits 0-8, 16' to 1' (`"888000000"`). */
+  drawbars?: string;
+  /** Tonewheel percussion: off 2nd 3rd. */
+  perc?: string;
+  /** Percussion decay: fast slow. */
+  percdecay?: string;
+  /** Key click 0..1. */
+  click?: number;
+  /** Scanner vibrato/chorus: off v1 v2 v3 c1 c2 c3. */
+  scanner?: string;
+  /** Preamp drive 0..1 (lane `keys-drive`). */
+  drive?: number;
+  /** Rotary speaker: slow fast stop (lane `keys-rotary`). */
+  rotary?: string;
+  /** Combo registers, five digits 0-8, 16' 8' 4' 2⅔' 2' (`"08800"`). */
+  registers?: string;
+  /**
+   * Pipe stops: names or a registration (plenum flutes cornet reeds strings
+   * full), as one string or a list (`["principal8", "octave4"]`).
+   */
+  stops?: string | readonly string[];
+  /** Pipe chiff 0..1. */
+  chiff?: number;
+  /** Pipe wind unsteadiness 0..1. */
+  wind?: number;
+  /** Tremolo depth 0..1: reed piano (0; wurli), pipe tremulant (0; pipe). */
+  trem?: number;
 }>;
 
 export type SynthInput = Readonly<{
@@ -2231,12 +3278,26 @@ export type TrackInput = Readonly<{
     | WavetableSpec
     | StringSpec
     | GranularSpec
-    | ModalSpec;
+    | ModalSpec
+    | WindSpec
+    | SingSpec
+    | VocoderSpec;
+  /**
+   * A vocoder on this track (SDK 1.32.0): `vocoder({ src: "vox" })` lets
+   * the vox track's voice shape this track's sound; `null` removes it.
+   */
+  vocoder?: VocoderSpec | null;
   /**
    * The sampler a `granular(...)` track keeps while it grains one of its
    * voices (SDK 1.23.0); `grain off` plays it again.
    */
   sampler?: SamplerSpec | null;
+  /**
+   * The `wavetable(...)` a track keeps after it left the wavetable
+   * instrument (SDK 1.32.0), so switching back restores it. A wavetable
+   * track takes its table from `instrument` instead.
+   */
+  wavetable?: WavetableSpec | null;
   /**
    * Granular engine (SDK 1.23.0) for an `instrument: "granular"` track, or
    * use `instrument: granular("cloud", {...})` or a word (`"cloud"`).
@@ -2263,6 +3324,19 @@ export type TrackInput = Readonly<{
    * `{ ref: 432 }` alone keeps the song's table at another pitch.
    */
   tuning?: TuningInput | null;
+  /**
+   * Wind engine settings as a field (SDK 1.32.0): a preset word or
+   * `{ preset, ...params }`, the same as `instrument: wind(...)`. Use with
+   * `instrument` omitted or `"wind"`.
+   */
+  wind?:
+    WindPresetName | Readonly<{ preset?: WindPresetName } & WindParams> | null;
+  /**
+   * Singing voice settings as a field (SDK 1.32.0), the same as
+   * `instrument: sing(...)`. Use with `instrument` omitted or `"sing"`.
+   */
+  sing?:
+    SingPresetName | Readonly<{ preset?: SingPresetName } & SingParams> | null;
   /** Synth voice parameters, Strudel names (`{ attack: 0.01, lpf: 800 }`). */
   synth?: SynthInput;
   /**
@@ -2302,6 +3376,24 @@ export type TrackInput = Readonly<{
   glide?: number | Readonly<{ time?: number; mode?: GlideMode }>;
   /** Sustain pedal changes as `[beat, "down" | "half" | "up"]` (SDK 1.15.0). */
   pedal?: readonly (readonly [number, PedalState])[];
+  /**
+   * Una corda on a modelled piano (SDK 1.26.0): `[beat, "down" | "half" |
+   * "up"]`; while down each note strikes fewer strings, softer and darker.
+   */
+  softPedal?: readonly (readonly [number, PedalState])[];
+  /**
+   * Sostenuto on a modelled piano (SDK 1.26.0): `[beat, "down" | "up"]`;
+   * holds only the keys already down when it presses.
+   */
+  sostenuto?: readonly (readonly [number, "down" | "up"])[];
+  /**
+   * Audio clips on the timeline (SDK 1.32.0): `audio("samples/lead.wav",
+   * { at: 8 })`, or `...repeatAudio(audio(...), { every: 8, until: 64 })`.
+   * They sound on any instrument; on `vocal` the notes are silent guides.
+   */
+  clips?: readonly (AudioSpec | readonly AudioSpec[])[];
+  /** Takes the clips play from (SDK 1.32.0): `take("take-1", "takes/take-1.wav", {...})`. */
+  takes?: readonly TakeSpec[];
   /**
    * Velocity response (SDK 1.15.0): `soft` (quiet notes louder), `hard`
    * (needs a firm touch), `fixed` (every note at 0.8, like an organ) or
@@ -2320,6 +3412,17 @@ export type TrackInput = Readonly<{
     length?: number;
     seed?: number;
   }>;
+  /**
+   * How chords are fretted on this track (SDK 1.27.0): `{ tune: "dadgad",
+   * capo: 2 }`. dawg's `strum` command and perform mode `guitar` use it;
+   * it changes no sound by itself.
+   */
+  guitar?: GuitarInput;
+  /**
+   * Pitch correction on this track's clips and samples (SDK 1.32.0): a
+   * preset word (`"hard"`), or `autotune("pop", { speed: 40 })`.
+   */
+  autotune?: AutotunePresetName | AutotuneSpec;
   /** `note()`/`seq()` for pitched tracks, `hit()`/`hits()` for kits and one-shot samplers. */
   notes?: readonly (NoteSpec | HitSpec)[];
   /**
@@ -2430,6 +3533,9 @@ export type TrackSpec = Readonly<{
   /** Performance (SDK 1.15.0); present only when set. */
   glide?: Readonly<{ time: number; mode: GlideMode }>;
   pedal?: readonly (readonly [number, PedalState])[];
+  /** Soft and sostenuto pedals (SDK 1.26.0); present only when set. */
+  softPedal?: readonly (readonly [number, PedalState])[];
+  sostenuto?: readonly (readonly [number, PedalState])[];
   velocityCurve?: Readonly<{
     curve: Exclude<VelocityCurveName, "linear">;
     fixed?: number;
@@ -2445,6 +3551,20 @@ export type TrackSpec = Readonly<{
   keys?: KeysInput;
   /** Modal settings (SDK 1.25.0); present only on a modal track. */
   modal?: Readonly<{ preset?: ModalPresetName } & ModalParams>;
+  /** Guitar fretting (SDK 1.27.0); present only when set. */
+  guitar?: GuitarSetup;
+  /** Wind settings (SDK 1.30.0); present only on a wind-engine track. */
+  wind?: Readonly<{ preset?: WindPresetName } & WindParams>;
+  /** Sing settings (SDK 1.32.0); present only on a sing track. */
+  sing?: Readonly<{ preset?: SingPresetName } & SingParams>;
+  /** Audio clips (SDK 1.32.0), flattened, paths project-relative; present only when set. */
+  clips?: readonly AudioSpec[];
+  /** Takes (SDK 1.32.0); present only when set. */
+  takes?: readonly TakeSpec[];
+  /** Vocoder settings (SDK 1.32.0); `src` as written until `song()`. */
+  vocoder?: Readonly<{ preset?: VocoderPresetName } & VocoderParams>;
+  /** Pitch correction (SDK 1.32.0); present only when set. */
+  autotune?: AutotuneSettings;
 }>;
 
 export type GlideMode = "legato" | "mono" | "poly";
@@ -2458,10 +3578,17 @@ const DEFAULT_FIXED_VELOCITY = 0.8;
 function trackPerformance(
   input: TrackInput,
   name: string,
-): Partial<Pick<TrackSpec, "glide" | "pedal" | "velocityCurve" | "humanize">> {
+): Partial<
+  Pick<
+    TrackSpec,
+    "glide" | "pedal" | "softPedal" | "sostenuto" | "velocityCurve" | "humanize"
+  >
+> {
   const out: {
     glide?: TrackSpec["glide"];
     pedal?: TrackSpec["pedal"];
+    softPedal?: TrackSpec["softPedal"];
+    sostenuto?: TrackSpec["sostenuto"];
     velocityCurve?: TrackSpec["velocityCurve"];
     humanize?: TrackSpec["humanize"];
   } = {};
@@ -2482,29 +3609,38 @@ function trackPerformance(
       mode,
     });
   }
-  if (input.pedal !== undefined) {
-    if (!Array.isArray(input.pedal) || input.pedal.length > 1024)
+  const pedalLane = (
+    key: "pedal" | "softPedal" | "sostenuto",
+    states: readonly PedalState[],
+  ) => {
+    const value: unknown = input[key];
+    if (value === undefined) return;
+    const shape = `[beat, ${states.map((state) => `"${state}"`).join(" | ")}]`;
+    if (!Array.isArray(value) || value.length > 1024)
       throw new DawgSdkError(
-        `track ${name}: pedal must be at most 1024 [beat, "down" | "half" | "up"] events`,
+        `track ${name}: ${key} must be at most 1024 ${shape} events`,
       );
-    if (input.pedal.length > 0)
-      out.pedal = Object.freeze(
-        input.pedal.map((event: unknown, index: number) => {
+    if (value.length > 0)
+      out[key] = Object.freeze(
+        value.map((event: unknown, index: number) => {
           if (
             !Array.isArray(event) ||
             event.length !== 2 ||
-            !["down", "half", "up"].includes(event[1] as string)
+            !states.includes(event[1] as PedalState)
           )
             throw new DawgSdkError(
-              `track ${name}: pedal[${index}] must be [beat, "down" | "half" | "up"]`,
+              `track ${name}: ${key}[${index}] must be ${shape}`,
             );
           return Object.freeze([
-            beat(event[0], `${name} pedal[${index}] beat`),
+            beat(event[0], `${name} ${key}[${index}] beat`),
             event[1] as PedalState,
           ] as const);
         }),
       );
-  }
+  };
+  pedalLane("pedal", ["down", "half", "up"]);
+  pedalLane("softPedal", ["down", "half", "up"]);
+  pedalLane("sostenuto", ["down", "up"]);
   if (input.velocityCurve !== undefined) {
     const raw =
       typeof input.velocityCurve === "string"
@@ -2634,6 +3770,40 @@ const ZZFX_SHAPES = Object.freeze([
  * Sample paths without a `tracks/` prefix are made project-relative under
  * this track's `tracks/<slug>/`.
  */
+/**
+ * `wind:` or `sing:` on track() as the engine spec, so the field is never
+ * silently dropped: it needs `instrument` omitted or the engine's own word.
+ */
+function engineField(
+  input: TrackInput,
+  name: string,
+): WindSpec | SingSpec | undefined {
+  const fields = [
+    ["wind", WIND_INSTRUMENT, wind] as const,
+    ["sing", SING_INSTRUMENT, sing] as const,
+  ].filter(([key]) => input[key] !== undefined && input[key] !== null);
+  if (fields.length === 0) return undefined;
+  if (fields.length > 1)
+    throw new DawgSdkError(`track ${name}: use wind: or sing:, not both`);
+  const [key, word, make] = fields[0]!;
+  if (input.instrument !== undefined && input.instrument !== word)
+    throw new DawgSdkError(
+      `track ${name}: ${key}: needs instrument "${word}" or none (got ${typeof input.instrument === "string" ? `"${input.instrument.slice(0, 32)}"` : "an engine spec"})`,
+    );
+  const value = input[key] as unknown;
+  if (typeof value === "string")
+    return (make as (p: string) => WindSpec | SingSpec)(value);
+  if (!isRecord(value))
+    throw new DawgSdkError(
+      `track ${name}: ${key}: must be a preset word or an object`,
+    );
+  const { preset, ...params } = value as Record<string, unknown>;
+  return (make as (p: unknown, q: object) => WindSpec | SingSpec)(
+    preset ?? params,
+    preset === undefined ? {} : params,
+  );
+}
+
 export function track(input: TrackInput): TrackSpec {
   if (!isRecord(input)) throw new DawgSdkError("track() needs an object");
   if (typeof input.name !== "string" || input.name.trim().length === 0)
@@ -2645,7 +3815,7 @@ export function track(input: TrackInput): TrackSpec {
   const id = input.id ?? slug;
   if (typeof id !== "string" || id.length === 0 || id.length > 64)
     throw new DawgSdkError(`track ${name}: id must be 1..64 characters`);
-  const rawInstrument = input.instrument ?? "sine";
+  const rawInstrument = engineField(input, name) ?? input.instrument ?? "sine";
   // A granular track may keep the sampler it grains (`grain off` goes back).
   const keptSampler =
     isRecord(input.sampler) &&
@@ -2662,9 +3832,24 @@ export function track(input: TrackInput): TrackSpec {
     isRecord(rawInstrument) && rawInstrument.kind === "sampler"
       ? localizeSampler(rawInstrument as SamplerSpec, slug)
       : keptSampler;
-  const wavetableSpec =
-    isRecord(rawInstrument) && rawInstrument.kind === "wavetable"
-      ? localizeWavetable(rawInstrument as WavetableSpec, slug)
+  const playedWavetable =
+    isRecord(rawInstrument) && rawInstrument.kind === "wavetable";
+  if (input.wavetable !== undefined && input.wavetable !== null) {
+    if (!isRecord(input.wavetable) || input.wavetable.kind !== "wavetable")
+      throw new DawgSdkError(`track ${name}: wavetable: takes wavetable(...)`);
+    if (
+      playedWavetable ||
+      (typeof rawInstrument === "string" &&
+        rawInstrument.trim().toLowerCase() === WAVETABLE_INSTRUMENT)
+    )
+      throw new DawgSdkError(
+        `track ${name}: a wavetable track sets its table in instrument: wavetable(...)`,
+      );
+  }
+  const wavetableSpec = playedWavetable
+    ? localizeWavetable(rawInstrument as WavetableSpec, slug)
+    : isRecord(input.wavetable)
+      ? localizeWavetable(input.wavetable as WavetableSpec, slug)
       : null;
   const stringFromInstrument =
     isRecord(rawInstrument) && rawInstrument.kind === "string"
@@ -2679,19 +3864,29 @@ export function track(input: TrackInput): TrackSpec {
       ? resolveInstrumentWord(rawInstrument)
       : undefined;
   const modalSpec = trackModal(rawInstrument);
+  const guitarSpec = guitarInput(input.guitar, `track ${name}`);
+  const windSpec = trackWind(rawInstrument);
+  const singSpec = trackSing(rawInstrument);
+  const vocoderSpec = trackVocoder(rawInstrument, input.vocoder);
   const instrument = granularFromInstrument
     ? GRANULAR_INSTRUMENT
     : samplerSpec
       ? SAMPLER_INSTRUMENT
-      : wavetableSpec
+      : playedWavetable
         ? WAVETABLE_INSTRUMENT
         : stringFromInstrument
           ? STRING_INSTRUMENT
           : modalSpec
             ? MODAL_INSTRUMENT
-            : typeof rawInstrument === "string"
-              ? (word?.instrument ?? rawInstrument)
-              : undefined;
+            : windSpec
+              ? WIND_INSTRUMENT
+              : singSpec
+                ? SING_INSTRUMENT
+                : isRecord(rawInstrument) && rawInstrument.kind === "vocoder"
+                  ? VOCODER_INSTRUMENT
+                  : typeof rawInstrument === "string"
+                    ? (word?.instrument ?? rawInstrument)
+                    : undefined;
   // A granular word (`"cloud"`) turns the engine on with its preset.
   const granularSpec =
     granularInput(input.granular, name, slug) ??
@@ -2734,7 +3929,7 @@ export function track(input: TrackInput): TrackSpec {
     if (pitch === undefined)
       throw new DawgSdkError(
         kit
-          ? `track ${name}: unknown drum voice "${spec.voice}" (kick snare clap rim tom hat openhat)`
+          ? `track ${name}: unknown drum "${spec.voice}" (kick snare clap rim tom hat openhat)`
           : slots
             ? `track ${name}: unknown sampler voice "${spec.voice}" (${[...slots.keys()].join(" ")})`
             : `track ${name}: hit("${spec.voice}") needs instrument "kit" or sampler(...)`,
@@ -2835,6 +4030,13 @@ export function track(input: TrackInput): TrackSpec {
             `${name} delay`,
           ),
         });
+  // A rig alias with a wash (`instrument: "shoegaze"`) sets the track
+  // reverb the `track shoegaze` prompt sets, unless `reverb` is given.
+  if (input.reverb === undefined && typeof rawInstrument === "string") {
+    const rigName = resolveInstrumentWord(rawInstrument)?.fx;
+    const wash = rigName === undefined ? undefined : RIG_REVERBS[rigName];
+    if (wash) input = { ...input, reverb: wash };
+  }
   const reverb =
     input.reverb === undefined || input.reverb === null
       ? null
@@ -2907,6 +4109,14 @@ export function track(input: TrackInput): TrackSpec {
     tuning: tuningSpec(input.tuning, `track ${name}`),
     ...keysSpec(input.keys, rawInstrument, name),
     ...(modalSpec ? { modal: modalSpec } : {}),
+    ...(guitarSpec ? { guitar: guitarSpec } : {}),
+    ...(windSpec ? { wind: windSpec } : {}),
+    ...(singSpec ? { sing: singSpec } : {}),
+    ...trackClips(input, name, slug),
+    ...(vocoderSpec ? { vocoder: vocoderSpec } : {}),
+    ...(input.autotune !== undefined
+      ? { autotune: autotuneInput(input.autotune, `track ${name}`) }
+      : {}),
   });
 }
 
@@ -2931,6 +4141,12 @@ const KEYS_PRESET_FX: Readonly<
     filter: { cutoff: 3500, resonance: 0.1 },
     fx: { crush: { bits: 10 } },
   },
+  // f061-organ: the pipe presets sound in a church.
+  pipe: { reverb: { mix: 0.35, size: 0.9 } },
+  flutes: { reverb: { mix: 0.3, size: 0.8 } },
+  cornet: { reverb: { mix: 0.3, size: 0.8 } },
+  reeds: { reverb: { mix: 0.3, size: 0.85 } },
+  celeste: { reverb: { mix: 0.35, size: 0.9 } },
 });
 
 /**
@@ -2975,6 +4191,13 @@ function keysSpec(
     out.preset = preset;
   for (const [key, value] of Object.entries(input)) {
     if (value === undefined) continue;
+    // Pipe stops may be a list: stored as one space-separated string.
+    if (key === "stops" && Array.isArray(value)) {
+      if (!value.every((stop) => typeof stop === "string"))
+        throw new DawgSdkError(`track ${name}: keys.stops must be stop names`);
+      out[key] = value.join(" ");
+      continue;
+    }
     out[key] = effectValue(value, `${name} keys.${key}`);
   }
   return { keys: Object.freeze(out) };
@@ -3324,6 +4547,12 @@ export type SongInput = Readonly<{
   tracks: readonly TrackSpec[];
   /** Master chain and loudness target after every track and orbit bus (SDK 1.17.0); omit for none. */
   master?: MasterInput;
+  /**
+   * Which style and seed made the song (SDK 1.33.0), from `style()`:
+   * `style: style("deep-house", { seed: 3, bars: 8 })`. A record only: the
+   * notes are the tracks above; `/style` in dawg generates them.
+   */
+  style?: StyleSpec;
   /**
    * Named bar ranges (SDK 1.18.0): `{ name: "chorus", startBar: 8, bars: 8 }`,
    * optionally with `mute: ["pad"]` and `vary: { lead: { transpose: 12 } }`.
@@ -3337,6 +4566,13 @@ export type SongInput = Readonly<{
   form?: string | readonly (string | SongFormEntry)[];
   /** The section playback loops (SDK 1.18.0); export ignores it. */
   loopSection?: string;
+  /**
+   * Sound calibration (SDK 1.32.0): `1` renders the 0.7 level, pitch and
+   * drum-kit fixes (hat choke, tuned toms, crash and ride, level keys,
+   * steady brass). Omit it to keep an older song's sound byte-identical;
+   * `dawg init` writes the latest.
+   */
+  calibration?: number;
 }>;
 
 /** A song section (SDK 1.18.0); bars are 0-based like beats. */
@@ -3401,8 +4637,12 @@ export type ScoreNote = Readonly<{
   bend?: readonly Readonly<{ at: number; cents: number }>[];
   vibrato?: Readonly<{ rate: number; depth: number; delay?: number }>;
   humanize?: Readonly<{ timing?: number; velocity?: number; length?: number }>;
+  /** Autotune guide drift share (SDK 1.32.0). */
+  drift?: number;
   /** Static cents offset (SDK 1.16.0); absent is 0. */
   cents?: number;
+  /** Sung vowel (SDK 1.32.0); absent sings the lyric's or the track's. */
+  vowel?: string;
 }>;
 
 /** A stored automation point: integer tick. */
@@ -3431,6 +4671,11 @@ export type ScoreSampleRef = Readonly<{
   bpm?: number;
   fitmode?: "repitch" | "beats" | "tones";
   len?: number;
+  shift?: number;
+  formant?: number;
+  fadeTime?: number;
+  fadeInTime?: number;
+  from?: SampleProvenanceSpec;
 }>;
 
 /** A stored track; optional fields are present only when set. */
@@ -3480,8 +4725,20 @@ export type ScoreTrack = Readonly<{
   granular?: GranularInput;
   /** Modal settings (SDK 1.25.0). */
   modal?: TrackSpec["modal"];
+  /** Guitar fretting (SDK 1.27.0). */
+  guitar?: GuitarSetup;
+  /** Wind settings (SDK 1.30.0). */
+  wind?: TrackSpec["wind"];
+  /** Sing settings (SDK 1.32.0). */
+  sing?: TrackSpec["sing"];
+  /** Vocoder settings (SDK 1.32.0); `src` is a track id. */
+  vocoder?: TrackSpec["vocoder"];
+  /** Pitch correction (SDK 1.32.0). */
+  autotune?: AutotuneSettings;
   glide?: TrackSpec["glide"];
   pedal?: readonly Readonly<{ tick: number; state: PedalState }>[];
+  softPedal?: readonly Readonly<{ tick: number; state: PedalState }>[];
+  sostenuto?: readonly Readonly<{ tick: number; state: PedalState }>[];
   velocityCurve?: TrackSpec["velocityCurve"];
   humanize?: TrackSpec["humanize"];
 }>;
@@ -3506,14 +4763,80 @@ export type Song = Readonly<{
   tracks: readonly ScoreTrack[];
   notes: readonly ScoreNote[];
   master?: MasterInput;
+  /** Present only when the song names a style (SDK 1.33.0). */
+  style?: StyleSpec;
   /** Present only when the song has sections (SDK 1.18.0). */
   sections?: readonly SongSection[];
   /** Present only when the song has a form (SDK 1.18.0). */
   form?: readonly SongFormEntry[];
   /** Present only when a section loops (SDK 1.18.0). */
   loopSection?: string;
+  /** Present only when the song sets one (SDK 1.32.0). */
+  calibration?: number;
+}>;
+
+/** A song's style provenance (SDK 1.33.0); see `style()`. */
+export type StyleSpec = Readonly<{
+  id: string;
+  seed: number;
+  bars: number;
+  blend?: Readonly<{ id: string; weight: number }>;
+}>;
+
+export type StyleOptions = Readonly<{
+  /** Generator seed, integer 0..2147483647, default 1. */
+  seed?: number;
+  /** Bars generated, 1..256, default 8. */
+  bars?: number;
+  /** Blend partner and its weight 0..1: `blend: ["bebop", 0.3]`. */
+  blend?: readonly [string, number];
 }>;
 
+const STYLE_ID_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
+
+/**
+ * Which style and seed made a song (SDK 1.33.0), for `song({ style })`:
+ *
+ * ```ts
+ * style("deep-house", { seed: 3, bars: 8 })
+ * style("bebop", { seed: 7, blend: ["bossa-nova", 0.3] })
+ * ```
+ *
+ * The id is a taxonomy id (`dawg` lists them with `/style list`). It is a
+ * record of where the song came from; the notes live in the tracks.
+ */
+export function style(id: string, options: StyleOptions = {}): StyleSpec {
+  if (typeof id !== "string" || !STYLE_ID_PATTERN.test(id))
+    throw new DawgSdkError(
+      `style id must be lowercase words joined by hyphens, like "deep-house"; got ${JSON.stringify(id)}`,
+    );
+  if (!isRecord(options))
+    throw new DawgSdkError("style options must be an object");
+  const seed = options.seed ?? 1;
+  if (!Number.isInteger(seed) || seed < 0 || seed > 2147483647)
+    throw new DawgSdkError("style seed must be an integer 0..2147483647");
+  const bars = options.bars ?? 8;
+  if (!Number.isInteger(bars) || bars < 1 || bars > 256)
+    throw new DawgSdkError("style bars must be an integer 1..256");
+  let blend: StyleSpec["blend"];
+  if (options.blend !== undefined) {
+    const pair = options.blend;
+    if (
+      !Array.isArray(pair) ||
+      pair.length !== 2 ||
+      typeof pair[0] !== "string" ||
+      !STYLE_ID_PATTERN.test(pair[0]) ||
+      typeof pair[1] !== "number" ||
+      !(pair[1] >= 0 && pair[1] <= 1)
+    )
+      throw new DawgSdkError(
+        'style blend must be ["style-id", weight 0..1], like ["bebop", 0.3]',
+      );
+    blend = Object.freeze({ id: pair[0], weight: pair[1] });
+  }
+  return Object.freeze({ id, seed, bars, ...(blend ? { blend } : {}) });
+}
+
 /** A stored song `time`: ticks, and 0-based bar indexes. */
 export type ScoreTime = Readonly<{
   tempo?: readonly Readonly<{
@@ -3529,6 +4852,24 @@ export type ScoreTime = Readonly<{
   fermatas?: readonly Readonly<{ tick: number; beats: number }>[];
 }>;
 
+/** `song({ style })`: the `style()` record, re-checked for hand-written objects. */
+function songStyle(input: unknown): { style?: StyleSpec } {
+  if (input === undefined || input === null) return {};
+  if (!isRecord(input))
+    throw new DawgSdkError('song style must come from style("id", { seed })');
+  const blend = input.blend;
+  const spec = style(input.id as string, {
+    seed: input.seed as number,
+    bars: input.bars as number,
+    ...(blend !== undefined && blend !== null
+      ? isRecord(blend)
+        ? { blend: [blend.id, blend.weight] as unknown as [string, number] }
+        : { blend: blend as [string, number] }
+      : {}),
+  });
+  return { style: spec };
+}
+
 const MASTER_KEYS = ["eq", "glue", "tape", "width", "limiter", "target"];
 
 /** Shape checks only; dawg validates every value when it loads the song. */
@@ -3665,6 +5006,9 @@ function songSections(
  * lengths at least one tick), and every note gets a deterministic id from
  * its track and content, so two evaluations of the same files agree.
  */
+/** The newest `song({ calibration })` (mirrors core CALIBRATION_LATEST). */
+export const SONG_CALIBRATION_LATEST = 1;
+
 export function song(input: SongInput): Song {
   if (!isRecord(input)) throw new DawgSdkError("song() needs an object");
   const tempoBpm = finite(input.tempo ?? 120, "song tempo");
@@ -3690,6 +5034,16 @@ export function song(input: SongInput): Song {
     throw new DawgSdkError("song key must be a string or null");
   const songTuning = tuningSpec(input.tuning, "song");
   const master = masterData(input.master);
+  const calibration = input.calibration ?? 0;
+  if (
+    typeof calibration !== "number" ||
+    !Number.isInteger(calibration) ||
+    calibration < 0 ||
+    calibration > SONG_CALIBRATION_LATEST
+  )
+    throw new DawgSdkError(
+      `song calibration must be an integer 0..${SONG_CALIBRATION_LATEST}`,
+    );
   if (!Array.isArray(input.tracks))
     throw new DawgSdkError("song tracks must be an array of track()");
   if (input.tracks.length > 64)
@@ -3771,11 +5125,13 @@ export function song(input: SongInput): Song {
       if (Object.keys(time).length > 0) stored.time = Object.freeze(time);
     }
     if (t.glide) stored.glide = t.glide;
-    if (t.pedal && t.pedal.length > 0) {
+    for (const key of ["pedal", "softPedal", "sostenuto"] as const) {
+      const lane = t[key];
+      if (!lane || lane.length === 0) continue;
       // One event per tick (the last wins), in tick order, as dawg stores it.
       const byTick = new Map<number, PedalState>();
-      for (const [at, state] of t.pedal) byTick.set(ticks(at), state);
-      stored.pedal = Object.freeze(
+      for (const [at, state] of lane) byTick.set(ticks(at), state);
+      stored[key] = Object.freeze(
         [...byTick.entries()]
           .sort((a, b) => a[0] - b[0])
           .map(([tick, state]) => Object.freeze({ tick, state })),
@@ -3787,6 +5143,31 @@ export function song(input: SongInput): Song {
     if (t.string) stored.string = t.string;
     if (t.keys) stored.keys = t.keys;
     if (t.modal) stored.modal = t.modal;
+    if (t.guitar) stored.guitar = t.guitar;
+    if (t.wind) stored.wind = t.wind;
+    if (t.sing) stored.sing = t.sing;
+    if (t.clips && t.clips.length > 0)
+      stored.clips = Object.freeze(
+        t.clips.map((clip, index) => storedClip(clip, index, ticks)),
+      );
+    if (t.takes && t.takes.length > 0)
+      stored.takes = Object.freeze(
+        t.takes.map((spec) => storedTake(spec, ticks)),
+      );
+    if (t.vocoder)
+      stored.vocoder = Object.freeze(
+        t.vocoder.src === undefined
+          ? t.vocoder
+          : {
+              ...t.vocoder,
+              src: resolveVocoderSrc(
+                input.tracks as TrackSpec[],
+                t.id,
+                t.vocoder.src,
+              ),
+            },
+      );
+    if (t.autotune) stored.autotune = t.autotune;
     if (t.rhythm && t.rhythm.length > 0)
       stored.rhythm = Object.freeze(
         t.rhythm.map((row) => {
@@ -3826,11 +5207,33 @@ export function song(input: SongInput): Song {
             : {}),
           ...(n.vibrato ? { vibrato: n.vibrato } : {}),
           ...(n.humanize ? { humanize: n.humanize } : {}),
+          ...(n.drift !== undefined ? { drift: n.drift } : {}),
           ...(n.cents ? { cents: n.cents } : {}),
+          ...(n.vowel ? { vowel: n.vowel } : {}),
+          ...(n.lyric !== undefined ? { lyric: n.lyric } : {}),
         }),
       );
     }
   });
+  // An ombak pair (SDK 1.30.0): a partner (pengumbang) whose preset carries
+  // its own ombak twin bank plays one straight voice instead, as `modal
+  // pair` and set_modal leave it, unless it sets ombak itself.
+  for (const track of [...tracks]) {
+    const pair = (track as { modal?: { pair?: string } }).modal?.pair;
+    if (pair === undefined) continue;
+    const at = tracks.findIndex((candidate) => candidate.id === pair);
+    const partner = tracks[at] as
+      (ScoreTrack & { modal?: Readonly<Record<string, unknown>> }) | undefined;
+    if (
+      partner?.modal &&
+      partner.modal.ombak === undefined &&
+      MODAL_TWIN_PRESETS.includes(String(partner.modal.preset))
+    )
+      tracks[at] = Object.freeze({
+        ...partner,
+        modal: Object.freeze({ ...partner.modal, ombak: 0 }),
+      }) as ScoreTrack;
+  }
   const arrangement: {
     sections?: readonly SongSection[];
     form?: readonly SongFormEntry[];
@@ -3870,7 +5273,9 @@ export function song(input: SongInput): Song {
     tracks: Object.freeze(tracks),
     notes: Object.freeze(notes),
     ...(master ? { master } : {}),
+    ...songStyle(input.style),
     ...arrangement,
+    ...(calibration ? { calibration } : {}),
   });
 }
 
@@ -4383,7 +5788,7 @@ function songTime(
  * an object with at most one table source (`edo`, `ratios`, `cents` or
  * `scl`). Library names: `12-tet`, `19-edo`, `24-edo`, `31-edo`,
  * `pythagorean`, `just` (5-limit), `7-limit`, `well-tuned-piano`, `pelog`,
- * `slendro`, `nyamaropa`, `shruti`, maqam and dastgah sets (`bayati`,
+ * `slendro`, `nyamaropa`, `thai`, `shruti`, maqam and dastgah sets (`bayati`,
  * `rast`, `saba`, `shur`, `homayoun`, `chahargah`) and raga intonations
  * (`yaman`, `bhairav`, `kafi`, `todi`, …); `dawg` lists them with
  * `/tuning list`. dawg checks every value when the song loads.
@@ -4495,7 +5900,22 @@ export type ChordOptions = Readonly<{
     | "arp-random"
     | "harp"
     | "slop"
-    | "pattern";
+    | "pattern"
+    | "guitar";
+  /**
+   * With `perform: "guitar"` (SDK 1.27.0): the stroke grid, a name (`down`
+   * `folk` `pop` `punk` `funk` `reggae` `waltz` `jangle` `island`) or
+   * characters D (down) U (up) d u (light) x (muted chuck) - . (rest).
+   */
+  strokes?: string;
+  /** Guitar: grid step in beats, default 0.5 (8ths). */
+  step?: number;
+  /** Guitar: milliseconds a full six-string down stroke takes, default 22. */
+  speed?: number;
+  /** Guitar: the song tempo `speed` converts with, default 120. */
+  tempo?: number;
+  /** Guitar: tuning, capo, hand, ring and position (as a track's `guitar`). */
+  guitar?: GuitarInput;
   /**
    * With `perform: "pattern"`: a rhythm pattern by name or 1-based number
    * (SDK 1.7.0): `eighths`, `sixteenths`, `offbeat`, `pop`, `charleston`,
@@ -4646,6 +6066,7 @@ export function progression(
       seed: finite(options.seed ?? 0, "chord seed"),
       ...(options.pattern !== undefined ? { pattern: options.pattern } : {}),
       velocity: vel,
+      ...(mode === "guitar" ? guitarPerform(options) : {}),
     },
   });
   const out = [
@@ -4659,6 +6080,406 @@ export function progression(
   );
 }
 
+/** A track's guitar setup (SDK 1.27.0): see `TrackInput.guitar`. */
+export type GuitarInput = Readonly<{
+  /** `standard` `dropd` `doubledropd` `dadgad` `openg` `opend` `opene` `halfdown` `nashville` `bass` `ukulele` `requinto`, or open-string pitches low to high. */
+  tune?: string | readonly Pitch[];
+  /** 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;
+}>;
+
+function guitarInput(
+  input: GuitarInput | undefined,
+  where: string,
+): GuitarSetup | undefined {
+  if (input === undefined) return undefined;
+  if (!isRecord(input))
+    throw new DawgSdkError(`${where} guitar must be an object`);
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(input))
+    if (!["tune", "capo", "hand", "ring", "position"].includes(key))
+      throw new DawgSdkError(
+        `${where} guitar has no field "${key.slice(0, 32)}" (tune capo hand ring position)`,
+      );
+  if (input.tune !== undefined) {
+    if (typeof input.tune === "string") {
+      const name = input.tune.toLowerCase().replace(/[\s_-]/g, "");
+      if (!(GUITAR_TUNING_NAMES as readonly string[]).includes(name))
+        throw new DawgSdkError(
+          `${where} guitar tune must be one of ${GUITAR_TUNING_NAMES.join(" ")} or a list of pitches`,
+        );
+      out.tune = name;
+    } else if (
+      Array.isArray(input.tune) &&
+      input.tune.length >= 3 &&
+      input.tune.length <= 12
+    )
+      out.tune = Object.freeze(input.tune.map((p) => midi(p)));
+    else
+      throw new DawgSdkError(
+        `${where} guitar tune must be a name or 3..12 pitches`,
+      );
+  }
+  const int = (key: "capo" | "hand" | "position", min: number, max: number) => {
+    const value = input[key];
+    if (value === undefined) return;
+    if (!Number.isInteger(value) || value < min || value > max)
+      throw new DawgSdkError(
+        `${where} guitar ${key} must be an integer ${min}..${max}`,
+      );
+    out[key] = value;
+  };
+  int("capo", 0, 12);
+  int("hand", 3, 6);
+  if (input.ring !== undefined)
+    out.ring =
+      Math.round(unit(input.ring, `${where} guitar ring`) * 1000) / 1000;
+  int("position", 0, 12);
+  return Object.keys(out).length > 0 ? Object.freeze(out) : undefined;
+}
+
+function guitarPerform(options: ChordOptions): Partial<PerformOptions> {
+  if (options.strokes !== undefined && !strokeGrid(options.strokes))
+    throw new DawgSdkError(
+      `chord strokes must be one of ${STROKE_PATTERN_NAMES.join(" ")} or a grid of D U d u x - .`,
+    );
+  const setup = guitarInput(options.guitar, "chord");
+  return {
+    ...(options.strokes !== undefined ? { strokes: options.strokes } : {}),
+    ...(options.step !== undefined
+      ? { step: positive(options.step, "chord step") }
+      : {}),
+    ...(options.speed !== undefined
+      ? {
+          speed:
+            Math.min(200, Math.max(0, finite(options.speed, "chord speed"))) /
+            1000,
+        }
+      : {}),
+    ...(options.tempo !== undefined
+      ? { tempo: positive(options.tempo, "chord tempo") }
+      : {}),
+    ...(setup ? { guitar: setup } : {}),
+  };
+}
+
+/**
+ * Strummed guitar chords (SDK 1.27.0): `progression()` with
+ * `perform: "guitar"`. Each chord is fretted on the guitar (`tune`, `capo`,
+ * no barre over an open string) and strummed with a stroke grid; a down
+ * stroke sweeps the strings in `speed` ms. Pair with `guitar` on the track
+ * so dawg's prompt strums the same shapes.
+ *
+ * ```ts
+ * notes: strum("G D Em C", { strokes: "folk", speed: 25, tempo: 96 })
+ * notes: strum("i VI III VII", { key: "e minor", strokes: "D-DU-UDU", guitar: { capo: 2 } })
+ * ```
+ */
+export function strum(
+  chords: string | readonly string[],
+  options: Omit<ProgressionOptions, "perform"> = {},
+): readonly NoteSpec[] {
+  return progression(chords, { ...options, perform: "guitar" });
+}
+
+// BEGIN lyrics: generated from core/lyrics.ts by core/sdk/sync-lyrics.ts
+/** Longest lyric on one note (SCORE_LIMITS.maxLyricLength). */
+const LYRIC_LIMIT = 32;
+
+/** One lyric token: a syllable, a held note (`_`) or a skipped note (`~`). */
+type LyricToken = Readonly<{
+  syl: string;
+  /** Index of the word the token belongs to. */
+  word: number;
+  /** First syllable of its word. */
+  first: boolean;
+  kind: "syl" | "hold" | "rest";
+}>;
+
+/**
+ * The lyric grammar: words split by spaces, syllables by `-`, `_` holds the
+ * previous syllable over the next note (melisma), `~` skips a note.
+ * "sun-lit morn-ing _ glow" gives sun lit morn ing _ glow.
+ */
+function parseLyric(text: string): LyricToken[] {
+  const out: LyricToken[] = [];
+  let word = -1;
+  for (const raw of text.trim().split(/\s+/u)) {
+    if (raw === "") continue;
+    if (raw === "_") out.push({ syl: "_", word, first: false, kind: "hold" });
+    else if (raw === "~")
+      out.push({ syl: "~", word, first: false, kind: "rest" });
+    else {
+      word += 1;
+      raw
+        .split("-")
+        .filter(Boolean)
+        .forEach((syl, index) =>
+          out.push({ syl, word, first: index === 0, kind: "syl" }),
+        );
+    }
+  }
+  return out;
+}
+
+const VOWEL = /[aeiouàáâäèéêëìíîïòóôöùúûü]/u;
+/** Consonant pairs that sound as one consonant and are never split. */
+const SYL_DIGRAPHS = new Set(["th", "sh", "ch", "ph", "wh", "ng", "ck", "gh"]);
+/** Digraphs that end a syllable (no English word starts with them). */
+const SYL_CODA_ONLY = new Set(["ng", "ck", "gh", "x"]);
+/** Consonant clusters a syllable may start with (maximal onset). */
+const SYL_ONSETS = new Set(
+  (
+    "bl br cl cr dr fl fr gl gr pl pr sc sk sl sm sn sp st sw tr tw dw " +
+    "thr shr chr phr phl spl spr str scr squ skr"
+  ).split(" "),
+);
+/** Common words ending in a silent `e` that start compounds (some-thing). */
+const SYL_SILENT_E_HEADS = (
+  "some home life time love fire side care where there here more one " +
+  "make lone like name game base wide grace face place space stone bone"
+).split(" ");
+/** Suffixes kept whole after a silent `e` (love-ly, care-ful). */
+const SYL_SUFFIXES = ["ly", "ful", "less", "ness", "ment"];
+/** Unstressed endings that close a short vowel before them (nev-er). */
+const SYL_CLOSING_ENDINGS = new Set([
+  "er",
+  "en",
+  "el",
+  "et",
+  "ed",
+  "es",
+  "est",
+  "ing",
+]);
+
+/**
+ * Syllables of a word typed without hyphens: a guess for English, which a
+ * hyphen always overrides (`nev-er`). Each run of vowels (and `y` after a
+ * consonant) is one syllable; a final silent `e` does not count, but a
+ * consonant plus `le` is its own syllable (lit-tle, ta-ble). Consonant
+ * pairs that sound as one (th sh ch ph wh ng ck gh) never split. Between
+ * vowels a cluster gives the next syllable the longest onset English
+ * allows (mon-ster, chil-dren); one consonant goes with the next vowel
+ * (ba-by, to-night) unless the previous vowel is short before an
+ * unstressed ending (nev-er, sing-ing). "something" gives some thing,
+ * "forever" for ev er.
+ */
+function autoSyllabify(word: string): string[] {
+  const w = word.toLowerCase();
+  // Compounds and suffixes after a silent e: some-thing, love-ly.
+  if (w.length >= 6) {
+    for (const head of SYL_SILENT_E_HEADS)
+      if (w.startsWith(head) && VOWEL.test(w.slice(head.length)))
+        return [
+          word.slice(0, head.length),
+          ...autoSyllabify(word.slice(head.length)),
+        ];
+    for (const suffix of SYL_SUFFIXES) {
+      const stem = w.slice(0, -suffix.length);
+      if (
+        w.endsWith(suffix) &&
+        stem.length >= 3 &&
+        stem.endsWith("e") &&
+        !VOWEL.test(stem[stem.length - 2]!)
+      )
+        return [
+          ...autoSyllabify(word.slice(0, stem.length)),
+          word.slice(stem.length),
+        ];
+    }
+  }
+  // Letters into units: a vowel, a consonant, a digraph, or `qu`.
+  type Unit = { at: number; text: string; vowel: boolean };
+  const units: Unit[] = [];
+  for (let i = 0; i < w.length;) {
+    const pair = w.slice(i, i + 2);
+    if (pair === "qu" || SYL_DIGRAPHS.has(pair)) {
+      units.push({ at: i, text: pair, vowel: false });
+      i += 2;
+      continue;
+    }
+    const ch = w[i]!;
+    const prev = units.at(-1);
+    const vowel =
+      VOWEL.test(ch) || (ch === "y" && prev !== undefined && !prev.vowel);
+    units.push({ at: i, text: ch, vowel });
+    i += 1;
+  }
+  // Vowel groups as [first unit, last unit].
+  const groups: [number, number][] = [];
+  for (let u = 0; u < units.length;) {
+    if (units[u]!.vowel) {
+      let v = u;
+      while (v + 1 < units.length && units[v + 1]!.vowel) v += 1;
+      groups.push([u, v]);
+      u = v + 1;
+    } else u += 1;
+  }
+  const lastUnit = units.length - 1;
+  const finalLe =
+    w.endsWith("le") &&
+    units.length >= 3 &&
+    units[lastUnit - 1]!.text === "l" &&
+    !units[lastUnit - 2]!.vowel;
+  const last = groups.at(-1);
+  if (
+    groups.length > 1 &&
+    last &&
+    last[0] === lastUnit &&
+    last[1] === lastUnit &&
+    units[lastUnit]!.text === "e" &&
+    !units[lastUnit - 1]!.vowel &&
+    !finalLe
+  )
+    groups.pop();
+  if (groups.length <= 1) return [word];
+  const cuts: number[] = [];
+  for (let g = 1; g < groups.length; g += 1) {
+    const prev = groups[g - 1]!;
+    const next = groups[g]!;
+    const cluster = units.slice(prev[1] + 1, next[0]);
+    const n = cluster.length;
+    const isLast = g === groups.length - 1;
+    let onset: number; // units of the cluster that start the next syllable
+    if (isLast && finalLe && n >= 2)
+      onset = cluster[n - 2]!.text === "ck" ? 1 : 2;
+    else if (n === 1) {
+      const unit = cluster[0]!.text;
+      const prevText = units
+        .slice(prev[0], prev[1] + 1)
+        .map((u) => u.text)
+        .join("");
+      const ending = w.slice(units[next[0]]!.at);
+      const short = prevText.length === 1 && "eiou".includes(prevText);
+      const closes =
+        SYL_CODA_ONLY.has(unit) ||
+        (short && isLast && SYL_CLOSING_ENDINGS.has(ending)) ||
+        (unit === "r" && short && units[next[0]]!.text === "e");
+      onset = closes ? 0 : 1;
+    } else {
+      onset = 1;
+      for (let k = n - 1; k >= 2; k -= 1)
+        if (
+          SYL_ONSETS.has(
+            cluster
+              .slice(n - k)
+              .map((u) => u.text)
+              .join(""),
+          )
+        ) {
+          onset = k;
+          break;
+        }
+      if (SYL_CODA_ONLY.has(cluster[n - 1]!.text)) onset = 0;
+    }
+    const first = units[next[0] - onset]!;
+    cuts.push(onset === 0 ? units[next[0]]!.at : first.at);
+  }
+  const out: string[] = [];
+  let at = 0;
+  for (const cut of cuts) {
+    out.push(word.slice(at, cut));
+    at = cut;
+  }
+  out.push(word.slice(at));
+  return out.filter(Boolean);
+}
+
+/** What `assignLyrics` put on each note, and what did not fit. */
+type LyricAssignment = Readonly<{
+  /** Note id to its lyric (`_` holds); notes `~` skipped are absent. */
+  lyrics: ReadonlyMap<string, string>;
+  /** Syllables left over after the last note. */
+  dropped: readonly string[];
+  /** Words split automatically. */
+  split: readonly string[];
+}>;
+
+/**
+ * Lyrics onto `notes` in time order. Hyphens split syllables as typed;
+ * when the text has fewer syllables than there are notes, words typed
+ * whole are split by `autoSyllabify`, and any notes still left hold the
+ * last syllable (melisma) instead of failing. Syllables past the last note
+ * are reported in `dropped`. Notes sharing an onset take one token, on
+ * the top note, with `_` on the others. Each lyric is cut to the 32-character limit.
+ */
+function assignLyrics(
+  text: string,
+  notes: readonly Readonly<{ id: string; startTick: number; pitch: number }>[],
+): LyricAssignment {
+  const sorted = [...notes].sort(
+    (a, b) => a.startTick - b.startTick || b.pitch - a.pitch,
+  );
+  // Notes sharing an onset (a chord or a doubled note) take one token: the
+  // top note carries it and the rest hold.
+  const ordered: (typeof sorted)[number][] = [];
+  const under = new Map<string, string[]>();
+  for (const note of sorted) {
+    const top = ordered.at(-1);
+    if (top && top.startTick === note.startTick)
+      under.get(top.id)!.push(note.id);
+    else {
+      ordered.push(note);
+      under.set(note.id, []);
+    }
+  }
+  let tokens = parseLyric(text);
+  const split: string[] = [];
+  if (tokens.length < ordered.length) {
+    // Split every word typed whole; keep the split only if it still fits.
+    const out: LyricToken[] = [];
+    const words: string[] = [];
+    for (const token of tokens) {
+      const whole =
+        token.kind === "syl" &&
+        token.first &&
+        !tokens.some((t) => t.word === token.word && !t.first);
+      if (!whole) {
+        out.push(token);
+        continue;
+      }
+      const parts = autoSyllabify(token.syl);
+      if (parts.length > 1) words.push(token.syl);
+      parts.forEach((syl, index) =>
+        out.push({ syl, word: token.word, first: index === 0, kind: "syl" }),
+      );
+    }
+    if (out.length <= ordered.length) {
+      tokens = out;
+      split.push(...words);
+    }
+  }
+  const lyrics = new Map<string, string>();
+  const limit = LYRIC_LIMIT;
+  ordered.forEach((note, index) => {
+    const token = tokens[index];
+    if (!token) {
+      if (tokens.length > 0)
+        for (const id of [note.id, ...under.get(note.id)!]) lyrics.set(id, "_");
+      return;
+    }
+    if (token.kind === "rest") return;
+    lyrics.set(
+      note.id,
+      token.kind === "hold" ? "_" : token.syl.slice(0, limit),
+    );
+    for (const id of under.get(note.id)!) lyrics.set(id, "_");
+  });
+  const dropped = tokens
+    .slice(ordered.length)
+    .filter((token) => token.kind === "syl")
+    .map((token) => token.syl);
+  return { lyrics, dropped, split };
+}
+// END lyrics
+
 // BEGIN instrument words: generated from core/instruments.ts by core/sdk/sync-instruments.ts
 /** What an instrument word stores on a track. */
 type InstrumentWord = Readonly<{
@@ -4780,6 +6601,42 @@ const INSTRUMENT_WORDS: readonly InstrumentWordRow[] = Object.freeze([
     preset: "dulcimer",
   },
   { word: "sehtar", instrument: "string", field: "string", preset: "setar" },
+  // bowed (f061-bowed): bowed presets of the string engine. `cello`,
+  // `contrabass` and `strings` stay legacy words (today's voice);
+  // `bowed-cello`, `string cello` or `bowed cello` reach the engine.
+  { word: "violin", instrument: "string", field: "string", preset: "violin" },
+  { word: "viola", instrument: "string", field: "string", preset: "viola" },
+  { word: "fiddle", instrument: "string", field: "string", preset: "fiddle" },
+  { word: "erhu", instrument: "string", field: "string", preset: "erhu" },
+  {
+    word: "kamancheh",
+    instrument: "string",
+    field: "string",
+    preset: "kamancheh",
+  },
+  {
+    word: "kemence",
+    instrument: "string",
+    field: "string",
+    preset: "kamancheh",
+  },
+  { word: "violins", instrument: "string", field: "string", preset: "violins" },
+  { word: "violas", instrument: "string", field: "string", preset: "violas" },
+  { word: "cellos", instrument: "string", field: "string", preset: "cellos" },
+  {
+    word: "contrabasses",
+    instrument: "string",
+    field: "string",
+    preset: "contrabasses",
+  },
+  { word: "pizzicato", instrument: "string", field: "string", preset: "pizz" },
+  { word: "tremolo", instrument: "string", field: "string", preset: "trem" },
+  {
+    word: "bowed-cello",
+    instrument: "string",
+    field: "string",
+    preset: "cello",
+  },
   // f06-rig: guitar track aliases, a guitar voice plus a whole rig. The
   // voice is the strings lane's `electric` row (jangle: its 12-string
   // `jangle` preset); the pluck only while that row is absent. Never `lead`
@@ -4844,6 +6701,39 @@ const INSTRUMENT_WORDS: readonly InstrumentWordRow[] = Object.freeze([
     field: "keys",
     preset: "prepared",
   },
+  // keys (f061-organ): tonewheel, combo and pipe organs on the keys
+  // engine. `organ` stays legacy (the sine voice).
+  {
+    word: "tonewheel",
+    instrument: "tonewheel",
+    field: "keys",
+    preset: "tonewheel",
+  },
+  {
+    word: "hammond",
+    instrument: "tonewheel",
+    field: "keys",
+    preset: "tonewheel",
+  },
+  { word: "b3", instrument: "tonewheel", field: "keys", preset: "tonewheel" },
+  { word: "gospel", instrument: "tonewheel", field: "keys", preset: "gospel" },
+  {
+    word: "jazzorgan",
+    instrument: "tonewheel",
+    field: "keys",
+    preset: "jazzorgan",
+  },
+  { word: "combo", instrument: "combo", field: "keys", preset: "combo" },
+  { word: "farfisa", instrument: "combo", field: "keys", preset: "combo" },
+  { word: "vox", instrument: "combo", field: "keys", preset: "vox" },
+  { word: "pipe", instrument: "pipe", field: "keys", preset: "pipe" },
+  { word: "church", instrument: "pipe", field: "keys", preset: "pipe" },
+  { word: "pipeorgan", instrument: "pipe", field: "keys", preset: "pipe" },
+  { word: "churchorgan", instrument: "pipe", field: "keys", preset: "pipe" },
+  { word: "flutes", instrument: "pipe", field: "keys", preset: "flutes" },
+  { word: "cornet", instrument: "pipe", field: "keys", preset: "cornet" },
+  { word: "reeds", instrument: "pipe", field: "keys", preset: "reeds" },
+  { word: "celeste", instrument: "pipe", field: "keys", preset: "celeste" },
   // f06-modal: mallets and bells (core/resonators.ts). `marimba` is legacy;
   // `modal` alone gives the modal marimba.
   { word: "modal", instrument: "modal", field: "modal", preset: "marimba" },
@@ -4897,6 +6787,117 @@ const INSTRUMENT_WORDS: readonly InstrumentWordRow[] = Object.freeze([
     field: "modal",
     preset: "chimes",
   },
+  // keys-electric (0.6.1): electric pianos and clavinet. `keys` stays legacy.
+  { word: "epiano", instrument: "epiano", field: "keys", preset: "epiano" },
+  { word: "rhodes", instrument: "epiano", field: "keys", preset: "epiano" },
+  {
+    word: "suitcase",
+    instrument: "epiano",
+    field: "keys",
+    preset: "suitcase",
+  },
+  { word: "dyno", instrument: "epiano", field: "keys", preset: "dyno" },
+  { word: "wurli", instrument: "wurli", field: "keys", preset: "wurli" },
+  { word: "wurlitzer", instrument: "wurli", field: "keys", preset: "wurli" },
+  { word: "clav", instrument: "clav", field: "keys", preset: "clav" },
+  { word: "clavinet", instrument: "clav", field: "keys", preset: "clav" },
+  { word: "funkclav", instrument: "clav", field: "keys", preset: "funkclav" },
+  // f061-guitar: the shoegaze alias, an electric guitar voice plus the
+  // shoegaze rig and its long wash.
+  { word: "shoegaze", instrument: "pluck", voice: "electric", fx: "shoegaze" },
+  // f061 integration: the two rig names that are free as instrument words
+  // (glide and swell are taken by commands; reach them with `rig glide`).
+  { word: "dreampop", instrument: "pluck", voice: "electric", fx: "dreampop" },
+  { word: "ebow", instrument: "pluck", voice: "electric", fx: "ebow" },
+  // f061-gamelan-winds: gamelan, small bells and frame drums.
+  { word: "crotales", instrument: "modal", field: "modal", preset: "crotales" },
+  { word: "crotale", instrument: "modal", field: "modal", preset: "crotales" },
+  { word: "musicbox", instrument: "modal", field: "modal", preset: "musicbox" },
+  { word: "toypiano", instrument: "modal", field: "modal", preset: "toypiano" },
+  { word: "saron", instrument: "modal", field: "modal", preset: "saron" },
+  { word: "demung", instrument: "modal", field: "modal", preset: "demung" },
+  { word: "slenthem", instrument: "modal", field: "modal", preset: "slenthem" },
+  { word: "gangsa", instrument: "modal", field: "modal", preset: "gangsa" },
+  { word: "gender", instrument: "modal", field: "modal", preset: "gender" },
+  { word: "bonang", instrument: "modal", field: "modal", preset: "bonang" },
+  { word: "kenong", instrument: "modal", field: "modal", preset: "kenong" },
+  { word: "kethuk", instrument: "modal", field: "modal", preset: "kethuk" },
+  { word: "kempul", instrument: "modal", field: "modal", preset: "kempul" },
+  { word: "daf", instrument: "modal", field: "modal", preset: "daf" },
+  { word: "bodhran", instrument: "modal", field: "modal", preset: "bodhran" },
+  { word: "framedrum", instrument: "modal", field: "modal", preset: "bodhran" },
+  { word: "tabla", instrument: "modal", field: "modal", preset: "tabla" },
+  // f061-gamelan-winds: blown waveguides (core/winds.ts). The legacy word
+  // `wind` keeps its tone; these words and their aliases pick a wind preset.
+  { word: "flute", instrument: "wind", field: "wind", preset: "flute" },
+  { word: "recorder", instrument: "wind", field: "wind", preset: "recorder" },
+  { word: "whistle", instrument: "wind", field: "wind", preset: "whistle" },
+  { word: "ney", instrument: "wind", field: "wind", preset: "ney" },
+  {
+    word: "shakuhachi",
+    instrument: "wind",
+    field: "wind",
+    preset: "shakuhachi",
+  },
+  { word: "panpipe", instrument: "wind", field: "wind", preset: "panpipe" },
+  { word: "suling", instrument: "wind", field: "wind", preset: "suling" },
+  { word: "bansuri", instrument: "wind", field: "wind", preset: "bansuri" },
+  { word: "clarinet", instrument: "wind", field: "wind", preset: "clarinet" },
+  {
+    word: "bassclarinet",
+    instrument: "wind",
+    field: "wind",
+    preset: "bassclarinet",
+  },
+  { word: "oboe", instrument: "wind", field: "wind", preset: "oboe" },
+  { word: "bassoon", instrument: "wind", field: "wind", preset: "bassoon" },
+  { word: "sax", instrument: "wind", field: "wind", preset: "sax" },
+  { word: "altosax", instrument: "wind", field: "wind", preset: "altosax" },
+  { word: "barisax", instrument: "wind", field: "wind", preset: "barisax" },
+  { word: "trumpet", instrument: "wind", field: "wind", preset: "trumpet" },
+  { word: "harmon", instrument: "wind", field: "wind", preset: "harmon" },
+  { word: "plunger", instrument: "wind", field: "wind", preset: "plunger" },
+  { word: "trombone", instrument: "wind", field: "wind", preset: "trombone" },
+  { word: "tuba", instrument: "wind", field: "wind", preset: "tuba" },
+  { word: "horn", instrument: "wind", field: "wind", preset: "horn" },
+  { word: "tinwhistle", instrument: "wind", field: "wind", preset: "whistle" },
+  {
+    word: "pennywhistle",
+    instrument: "wind",
+    field: "wind",
+    preset: "whistle",
+  },
+  { word: "nay", instrument: "wind", field: "wind", preset: "ney" },
+  { word: "panflute", instrument: "wind", field: "wind", preset: "panpipe" },
+  { word: "panpipes", instrument: "wind", field: "wind", preset: "panpipe" },
+  { word: "saxophone", instrument: "wind", field: "wind", preset: "sax" },
+  { word: "tenorsax", instrument: "wind", field: "wind", preset: "sax" },
+  { word: "tenor", instrument: "wind", field: "wind", preset: "sax" },
+  { word: "alto", instrument: "wind", field: "wind", preset: "altosax" },
+  { word: "bari", instrument: "wind", field: "wind", preset: "barisax" },
+  { word: "baritonesax", instrument: "wind", field: "wind", preset: "barisax" },
+  { word: "frenchhorn", instrument: "wind", field: "wind", preset: "horn" },
+  { word: "mutedtrumpet", instrument: "wind", field: "wind", preset: "harmon" },
+  { word: "wahtrumpet", instrument: "wind", field: "wind", preset: "plunger" },
+  // f07-sing: the built-in singing voice (core/sing.ts).
+  { word: "sing", instrument: "sing", field: "sing" },
+  { word: "aah", instrument: "sing", field: "sing", preset: "aah" },
+  { word: "ooh", instrument: "sing", field: "sing", preset: "ooh" },
+  { word: "choir", instrument: "sing", field: "sing", preset: "choir" },
+  { word: "chorale", instrument: "sing", field: "sing", preset: "chorale" },
+  { word: "khoomei", instrument: "sing", field: "sing", preset: "khoomei" },
+  { word: "sygyt", instrument: "sing", field: "sing", preset: "sygyt" },
+  { word: "kargyraa", instrument: "sing", field: "sing", preset: "kargyraa" },
+  // f07-clips: a track of audio clips; its notes are guides.
+  { word: "vocal", instrument: "vocal" },
+  // f07-vocoder: the built-in carrier (core/vocoder.ts); set a source with
+  // `/vocoder src <track>`.
+  {
+    word: "vocoder",
+    instrument: "vocoder",
+    field: "vocoder",
+    preset: "classic",
+  },
 ]);
 
 /**
@@ -4952,6 +6953,7 @@ const QUALITIES = [
   "mb6",
   "b6",
   "7#9",
+  "b5",
 ] as const;
 type Quality = (typeof QUALITIES)[number];
 
@@ -4968,6 +6970,7 @@ const QUALITY_INTERVALS: Readonly<Record<Quality, readonly number[]>> =
     mb6: [0, 3, 7, 8],
     b6: [0, 4, 7, 8],
     "7#9": [0, 4, 7, 10, 15],
+    b5: [0, 4, 6],
   });
 
 /**
@@ -5014,6 +7017,17 @@ type Chord = Readonly<{
   extensions: readonly Extension[];
   /** Slash bass pitch class, when not the root. */
   bass?: number | undefined;
+  /**
+   * Upper tensions beyond the four extension buttons, as semitones above
+   * the root (13 b9, 15 #9, 17 11, 18 #11, 21 13): only typed symbols
+   * such as `C11`, `G13` or `A7b9` carry them (0.6.1).
+   */
+  tensions?: readonly number[] | undefined;
+  /**
+   * The root's letter, 0..6 for C..B, when a roman numeral spelled it:
+   * `bVII` in C names Bb (not A#) and `vii` in F# names E# (not F).
+   */
+  letter?: number | undefined;
 }>;
 
 function makeChord(
@@ -5021,6 +7035,7 @@ function makeChord(
   quality: Quality,
   extensions: Iterable<Extension> = [],
   bass?: number,
+  tensions: readonly number[] = [],
 ): Chord {
   const held = new Set(extensions);
   const own = SECRET_EXTENSION[quality];
@@ -5032,6 +7047,11 @@ function makeChord(
     quality,
     extensions: Object.freeze(ext),
     ...(slash !== undefined && slash !== pc ? { bass: slash } : {}),
+    ...(tensions.length > 0
+      ? {
+          tensions: Object.freeze([...new Set(tensions)].sort((a, b) => a - b)),
+        }
+      : {}),
   });
 }
 
@@ -5039,6 +7059,7 @@ function makeChord(
 function chordIntervals(chord: Chord): number[] {
   const set = new Set(QUALITY_INTERVALS[chord.quality]);
   for (const ext of chord.extensions) set.add(EXTENSION_INTERVAL[ext]);
+  for (const step of chord.tensions ?? []) set.add(step);
   // m7 and M7 together keep both; 6 with m7 on a dim triad is the dim7's bb7.
   return [...set].sort((a, b) => a - b);
 }
@@ -5085,12 +7106,43 @@ function noteName(pc: number, flats = false): string {
   return (flats ? FLAT_NAMES : SHARP_NAMES)[mod12(pc)]!;
 }
 
+const LETTERS = "CDEFGAB";
+const LETTER_PCS = [0, 2, 4, 5, 7, 9, 11] as const;
+
+/**
+ * `pc` spelled on letter `letter` (0..6, C..B) with one accidental at
+ * most (E#, Cb, Bb); undefined when that would need a double accidental.
+ */
+function spellOnLetter(pc: number, letter: number): string | undefined {
+  const l = ((Math.trunc(letter) % 7) + 7) % 7;
+  const diff = ((mod12(pc) - LETTER_PCS[l]! + 18) % 12) - 6;
+  if (Math.abs(diff) > 1) return undefined;
+  return `${LETTERS[l]}${diff === 1 ? "#" : diff === -1 ? "b" : ""}`;
+}
+
+/** The letter (0..6, C..B) a key's tonic is spelled on. */
+function tonicLetter(key: Key): number {
+  return LETTERS.indexOf(noteName(key.tonic, keyUsesFlats(key))[0]!);
+}
+
 const SECRET_SUFFIX: Readonly<Partial<Record<Quality, string>>> = Object.freeze(
   { madd4: "m(add4)", mb6: "m(b6)", b6: "(b6)", "7#9": "7#9" },
 );
 
 /** Chord symbol suffix: `m7`, `maj9`, `7sus4`, `dim7`, `m7b5`, `6/9`. */
 function chordSuffix(chord: Chord): string {
+  if (chord.tensions?.length) {
+    // A typed extended chord keeps the symbol it was typed as.
+    const typed = TENSION_SUFFIXES.find(
+      ([, quality, ext, tensions]) =>
+        quality === chord.quality &&
+        ext.join() === chord.extensions.join() &&
+        tensions.join() === chord.tensions!.join(),
+    );
+    if (typed) return typed[0];
+    const names = chord.tensions.map((step) => TENSION_NAMES[step] ?? step);
+    return `${chordSuffix({ ...chord, tensions: undefined })}(${names.join(",")})`;
+  }
   const ext = new Set(chord.extensions);
   const b7 = ext.has("m7");
   const M7 = ext.has("M7");
@@ -5151,6 +7203,9 @@ function chordSuffix(chord: Chord): string {
         base = `${seventh}(no3)`;
         if (nine) extras.push("9");
         break;
+      case "b5":
+        base = `${ninth}b5`;
+        break;
       default:
         base = seventh; // secret qualities returned above
     }
@@ -5169,6 +7224,7 @@ function chordSuffix(chord: Chord): string {
     mb6: "m(b6)",
     b6: "(b6)",
     "7#9": "7#9",
+    b5: "(b5)",
   };
   base = triad[q];
   if (six && nine && (q === "maj" || q === "min")) return `${base}6/9`;
@@ -5188,7 +7244,11 @@ function chordSuffix(chord: Chord): string {
 function chordName(chord: Chord, flats = false): string {
   const slash =
     chord.bass === undefined ? "" : `/${noteName(chord.bass, flats)}`;
-  return `${noteName(chord.root, flats)}${chordSuffix(chord)}${slash}`;
+  const root =
+    (chord.letter === undefined
+      ? undefined
+      : spellOnLetter(chord.root, chord.letter)) ?? noteName(chord.root, flats);
+  return `${root}${chordSuffix(chord)}${slash}`;
 }
 
 /** Suffix → quality and extensions, longest first when parsing. */
@@ -5253,10 +7313,74 @@ const SUFFIXES: readonly (readonly [string, Quality, readonly Extension[]])[] =
     ["(b6)", "b6", []],
     ["addb6", "b6", []],
     ["7#9", "7#9", []],
+    // 0.7: more spellings of the same chords.
+    ["-maj7", "min", ["M7"]],
+    ["mmaj7", "min", ["M7"]],
+    ["mMaj7", "min", ["M7"]],
+    ["m(maj7)", "min", ["M7"]],
+    ["-Δ7", "min", ["M7"]],
+    ["mΔ7", "min", ["M7"]],
+    ["add2", "maj", ["9"]],
+    ["2", "maj", ["9"]],
+    ["madd2", "min", ["9"]],
+    ["6add9", "maj", ["6", "9"]],
+    ["m6add9", "min", ["6", "9"]],
+    ["-6", "min", ["6"]],
+    ["-9", "min", ["m7", "9"]],
+    ["dom9", "maj", ["m7", "9"]],
+    ["aug(maj7)", "aug", ["M7"]],
+    ["augmaj7", "aug", ["M7"]],
+    ["+maj7", "aug", ["M7"]],
+    ["aug9", "aug", ["m7", "9"]],
+    ["+9", "aug", ["m7", "9"]],
+    ["m(maj9)", "min", ["M7", "9"]],
+    ["mmaj9", "min", ["M7", "9"]],
+    ["dim(maj7)", "dim", ["M7"]],
+    ["7(no3)", "5", ["m7"]],
+    ["maj7(no3)", "5", ["M7"]],
   ];
-const SUFFIX_TABLE = new Map(
-  SUFFIXES.map(([suffix, quality, ext]) => [suffix, { quality, ext }]),
-);
+
+/** Typed upper-tension chords (0.6.1): suffix, quality, buttons, tensions. */
+const TENSION_SUFFIXES: readonly (readonly [
+  string,
+  Quality,
+  readonly Extension[],
+  readonly number[],
+])[] = [
+  ["11", "maj", ["m7", "9"], [17]],
+  ["m11", "min", ["m7", "9"], [17]],
+  ["maj11", "maj", ["M7", "9"], [17]],
+  ["add11", "maj", [], [17]],
+  ["madd11", "min", [], [17]],
+  ["13", "maj", ["m7", "9"], [21]],
+  ["m13", "min", ["m7", "9"], [21]],
+  ["maj13", "maj", ["M7", "9"], [21]],
+  ["7b9", "maj", ["m7"], [13]],
+  ["7#11", "maj", ["m7"], [18]],
+  ["maj7#11", "maj", ["M7"], [18]],
+  ["M7#11", "maj", ["M7"], [18]],
+  ["7b13", "maj", ["m7"], [20]],
+  ["13b9", "maj", ["m7"], [13, 21]],
+];
+
+const TENSION_NAMES: Readonly<Record<number, string>> = Object.freeze({
+  13: "b9",
+  15: "#9",
+  17: "11",
+  18: "#11",
+  20: "b13",
+  21: "13",
+});
+
+const SUFFIX_TABLE = new Map<string, SuffixEntry>([
+  ...SUFFIXES.map(
+    ([suffix, quality, ext]) => [suffix, { quality, ext }] as const,
+  ),
+  ...TENSION_SUFFIXES.map(
+    ([suffix, quality, ext, tensions]) =>
+      [suffix, { quality, ext, tensions }] as const,
+  ),
+]);
 
 const LETTER: Readonly<Record<string, number>> = Object.freeze({
   c: 0,
@@ -5281,6 +7405,81 @@ function parsePitchClass(text: string): number | undefined {
   return mod12(LETTER[match[1]!.toLowerCase()]! + accidental);
 }
 
+/** Alteration → upper tension (semitones above the root). */
+const ALTERATION_TENSION: Readonly<Record<string, number>> = Object.freeze({
+  b9: 13,
+  "#9": 15,
+  "11": 17,
+  "#11": 18,
+  "+11": 18,
+  b13: 20,
+  "13": 21,
+});
+
+const TOKEN = "b5|#5|\\+5|b9|#9|#11|\\+11|b13|alt|add9|add11|add13|11|13|9|6";
+/** Bare alterations or parenthesized comma lists of them, in any order. */
+const ALTERATIONS = new RegExp(
+  `^(?:(?:${TOKEN})|\\((?:${TOKEN})(?:,(?:${TOKEN}))*\\))+$`,
+);
+
+type SuffixEntry = {
+  quality: Quality;
+  ext: readonly Extension[];
+  tensions?: readonly number[];
+};
+
+/**
+ * A suffix the table does not list, read as a listed base followed by
+ * alterations, bare or in parentheses: `7#5`, `9#11`, `13#11`, `7b9b13`,
+ * `9b5`, `maj7+5`, `7alt`, `7(b9,#9)`. A raised fifth makes the triad
+ * augmented, a lowered one makes a major triad `b5` (a minor one
+ * diminished); `alt` is b9, #9, #11 and b13 over a dominant seventh.
+ */
+function parseAlteredSuffix(suffix: string): SuffixEntry | undefined {
+  for (let cut = suffix.length - 1; cut >= 0; cut -= 1) {
+    const base = SUFFIX_TABLE.get(suffix.slice(0, cut));
+    if (!base) continue;
+    const raw = suffix.slice(cut);
+    if (!ALTERATIONS.test(raw)) continue;
+    const rest = raw.replace(/[(),]/g, "");
+    const tokens = rest.match(
+      /b5|#5|\+5|b9|#9|#11|\+11|b13|alt|add9|add11|add13|11|13|9|6/g,
+    );
+    if (!tokens || tokens.join("") !== rest) continue;
+    let quality: Quality = base.quality;
+    const ext = new Set<Extension>(base.ext);
+    const tensions = new Set<number>(base.tensions ?? []);
+    let ok = true;
+    for (const token of tokens) {
+      if (token === "#5" || token === "+5") {
+        if (quality === "maj" || quality === "aug") quality = "aug";
+        else ok = false;
+      } else if (token === "b5") {
+        if (quality === "maj" || quality === "b5") quality = "b5";
+        else if (quality === "min" || quality === "dim") quality = "dim";
+        else ok = false;
+      } else if (token === "alt") {
+        if (quality !== "maj") ok = false;
+        ext.add("m7");
+        for (const step of [13, 15, 18, 20]) tensions.add(step);
+      } else if (token === "9" || token === "add9") ext.add("9");
+      else if (token === "6") ext.add("6");
+      else {
+        const step = ALTERATION_TENSION[token.replace(/^add/, "")];
+        if (step === undefined) ok = false;
+        else tensions.add(step);
+      }
+    }
+    if (!ok) continue;
+    return {
+      quality,
+      ext: [...ext],
+      tensions: [...tensions].sort((a, b) => a - b),
+    };
+  }
+  return undefined;
+}
+
 /** Parse a chord symbol (`Cm7`, `F#dim`, `Bbmaj9`, `G7sus4`, `C/E`). */
 function parseChord(symbol: string): Chord | undefined {
   if (typeof symbol !== "string" || symbol.length > 24) return undefined;
@@ -5291,14 +7490,15 @@ function parseChord(symbol: string): Chord | undefined {
   const match = trimmed.match(/^([A-Ga-g])(#|b|♯|♭)?([^/]*)(?:\/(.+))?$/);
   if (!match) return undefined;
   const root = parsePitchClass(`${match[1]}${match[2] ?? ""}`);
-  const entry = SUFFIX_TABLE.get(match[3] ?? "");
+  const entry =
+    SUFFIX_TABLE.get(match[3] ?? "") ?? parseAlteredSuffix(match[3] ?? "");
   if (root === undefined || !entry) return undefined;
   let bass: number | undefined;
   if (match[4] !== undefined) {
     bass = parsePitchClass(match[4]);
     if (bass === undefined) return undefined;
   }
-  return makeChord(root, entry.quality, entry.ext, bass);
+  return makeChord(root, entry.quality, entry.ext, bass, entry.tensions);
 }
 
 // ---------------------------------------------------------------------------
@@ -5351,7 +7551,15 @@ const MODE_ALIASES: Readonly<Record<string, ModeName>> = Object.freeze({
 });
 
 type ScaleFamily =
-  "pentatonic" | "blues" | "maqam" | "dastgah" | "raga" | "messiaen";
+  | "pentatonic"
+  | "blues"
+  | "maqam"
+  | "dastgah"
+  | "raga"
+  | "messiaen"
+  | "chromatic"
+  | "overtone"
+  | "quarter-tone";
 
 /**
  * Scales beyond the chord modes, for keys such as `D bayati`, `C yaman` or
@@ -5398,6 +7606,12 @@ const SCALES = Object.freeze({
     family: "blues",
     aliases: ["major blues"],
   },
+  "yonanuki-minor": {
+    steps: [0, 2, 3, 7, 8],
+    mode: "minor",
+    family: "pentatonic",
+    aliases: ["yonanuki", "yonanuki minor", "enka minor"],
+  },
   hijaz: {
     steps: [0, 1, 4, 5, 7, 8, 10],
     mode: "phrygian-dominant",
@@ -5574,6 +7788,32 @@ const SCALES = Object.freeze({
     mode: "harmonic-minor",
     family: "messiaen",
   },
+  // All twelve pitch classes: the field of free atonality and the row.
+  chromatic: {
+    steps: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
+    mode: "minor",
+    family: "chromatic",
+    aliases: ["twelve-tone", "aggregate"],
+  },
+  // Partials 8 to 15 of the harmonic series over the tonic (Grisey,
+  // Murail): the acoustic scale with the 11th and 13th partials' and the
+  // 7th's just pitches, which its named tuning applies.
+  "harmonic-series": {
+    steps: [0, 2, 4, 6, 7, 9, 10, 11],
+    mode: "mixolydian",
+    family: "overtone",
+    intonation: [0, 204, 386, 551, 702, 841, 969, 1088],
+    aliases: ["overtone", "overtone-scale", "partials"],
+  },
+  // Each tempered degree of the major scale beside its quarter-tone
+  // shadow (Haba, Wyschnegradsky): neutral 2nd, 3rd, 6th and 7th and a
+  // quarter-sharp 4th, sounded as note cents over twelve-tone keys.
+  "quarter-tone": {
+    steps: [0, 1.5, 2, 3.5, 4, 5, 5.5, 7, 8.5, 9, 10.5],
+    mode: "major",
+    family: "quarter-tone",
+    aliases: ["quartertone", "24-tone"],
+  },
 } as const satisfies Record<string, ScaleInfo>);
 type ScaleName = keyof typeof SCALES;
 const SCALE_NAMES = Object.keys(SCALES) as ScaleName[];
@@ -5776,9 +8016,14 @@ function romanOf(key: Key, chord: Chord): string {
   if (degree < 0) {
     // Name chromatic roots against the major scale: bIII, #iv°.
     const major = MODES.major.map((step) => mod12(key.tonic + step));
+    const natural = major.indexOf(chord.root);
     const flat = major.indexOf(mod12(chord.root + 1));
     const sharp = major.indexOf(mod12(chord.root - 1));
-    if (flat >= 0) {
+    if (natural >= 0) {
+      // A major-scale note the mode alters: ♮II in Phrygian.
+      degree = natural;
+      accidental = "♮";
+    } else if (flat >= 0) {
       degree = flat;
       accidental = "b";
     } else {
@@ -5789,7 +8034,6 @@ function romanOf(key: Key, chord: Chord): string {
   const lower =
     chord.quality === "min" ||
     chord.quality === "dim" ||
-    chord.quality === "5" ||
     chord.quality === "madd4" ||
     chord.quality === "mb6";
   const numeral = NUMERALS[degree]!;
@@ -5806,7 +8050,33 @@ function romanOf(key: Key, chord: Chord): string {
         : ext.has("M7")
           ? "maj7"
           : "";
-  return `${accidental}${body}${mark}${seventh}`;
+  // The short numeral when it reads back as this chord; else the chord's
+  // own suffix in brackets (`I[7]`, `i[m6]`, `V[7#9]`), which is exact.
+  const plain = `${accidental}${body}${mark}${seventh}`;
+  const bare = makeChord(
+    chord.root,
+    chord.quality,
+    chord.extensions,
+    undefined,
+    chord.tensions,
+  );
+  for (const candidate of [
+    plain,
+    `${accidental}${body}${mark}${seventh === "7" ? "dom7" : seventh}`,
+  ])
+    if (sameChord(parseRoman(key, candidate), bare)) return candidate;
+  return `${accidental}${body}[${chordSuffix(bare)}]`;
+}
+
+function sameChord(a: Chord | undefined, b: Chord): boolean {
+  return (
+    a !== undefined &&
+    a.root === b.root &&
+    a.quality === b.quality &&
+    a.bass === b.bass &&
+    a.extensions.join() === b.extensions.join() &&
+    (a.tensions ?? []).join() === (b.tensions ?? []).join()
+  );
 }
 
 /**
@@ -5819,31 +8089,64 @@ function romanOf(key: Key, chord: Chord): string {
  * major). `7` adds the diatonic seventh; `maj7`/`M7` and `dom7` are exact.
  */
 function parseRoman(key: Key, text: string): Chord | undefined {
-  if (typeof text !== "string" || text.length > 16) return undefined;
+  return romanIn(key, text, tonicLetter(key));
+}
+
+/** `parseRoman` with the tonic spelled on `tonic` (0..6, C..B). */
+function romanIn(key: Key, text: string, tonic: number): Chord | undefined {
+  if (typeof text !== "string" || text.length > 32) return undefined;
   const trimmed = text.trim();
+  const exact = trimmed.match(
+    /^(b|#|♭|♯|♮)?(vii|vi|v|iv|iii|ii|i|VII|VI|V|IV|III|II|I)\[([^\]]*)\]$/,
+  );
+  if (exact) {
+    // `I[7]`: the numeral names the root, the bracket is a chord suffix.
+    const degree = NUMERALS.indexOf(exact[2]!.toLowerCase());
+    const shift =
+      exact[1] === "b" || exact[1] === "♭"
+        ? -1
+        : exact[1] === "♮" || !exact[1]
+          ? 0
+          : 1;
+    const root = !exact[1]
+      ? scaleOf(key)[degree]
+      : mod12(key.tonic + MODES.major[degree]! + shift);
+    if (root === undefined) return undefined;
+    const letter = (tonic + degree) % 7;
+    const chord = parseChord(
+      `${spellOnLetter(root, letter) ?? noteName(root)}${exact[3]!}`,
+    );
+    return chord && Object.freeze({ ...chord, letter });
+  }
   const slash = trimmed.match(/^(.+)\/(.+)$/);
   if (slash) {
     // V/x: the chord built on the degree of x in the key (secondary function).
-    const target = parseRoman(key, slash[2]!);
+    const target = romanIn(key, slash[2]!, tonic);
     if (!target) return undefined;
-    const sub = parseRoman({ tonic: target.root, mode: "major" }, slash[1]!);
-    return sub;
+    return romanIn(
+      { tonic: target.root, mode: "major" },
+      slash[1]!,
+      target.letter ?? tonic,
+    );
   }
   const match = trimmed.match(
-    /^(b|#|♭|♯)?(vii|vi|v|iv|iii|ii|i|VII|VI|V|IV|III|II|I)(°|o|ø|\+)?(maj7|M7|dom7|7|9|maj9|6|sus4|sus2|sus|add9)?$/,
+    /^(b|#|♭|♯|♮)?(vii|vi|v|iv|iii|ii|i|VII|VI|V|IV|III|II|I)(°|o|ø|\+)?(maj7|M7|dom7|7|9|maj9|6|sus4|sus2|sus|add9)?$/,
   );
   if (!match) return undefined;
   const accidental =
-    match[1] === "b" || match[1] === "♭" ? -1 : match[1] ? 1 : 0;
+    match[1] === "b" || match[1] === "♭"
+      ? -1
+      : match[1] === "#" || match[1] === "♯"
+        ? 1
+        : 0;
   const numeral = match[2]!;
   const lower = numeral === numeral.toLowerCase();
   const degree = NUMERALS.indexOf(numeral.toLowerCase());
   const mark = match[3];
   const suffix = match[4] ?? "";
-  const root =
-    accidental === 0
-      ? scaleOf(key)[degree]!
-      : mod12(key.tonic + MODES.major[degree]! + accidental);
+  const root = !match[1]
+    ? scaleOf(key)[degree]!
+    : mod12(key.tonic + MODES.major[degree]! + accidental);
   const inKey = degreeOf(key, root);
   const triad = inKey === undefined ? undefined : diatonicChord(key, inKey);
   const seventh =
@@ -5897,7 +8200,10 @@ function parseRoman(key: Key, text: string): Chord | undefined {
       quality = "sus2";
       break;
   }
-  return makeChord(root, quality, ext);
+  return Object.freeze({
+    ...makeChord(root, quality, ext),
+    letter: (tonic + degree) % 7,
+  });
 }
 
 // ---------------------------------------------------------------------------
@@ -5939,7 +8245,17 @@ function rotate(pitches: readonly number[], steps: number): number[] {
 
 function rootPosition(chord: Chord, anchor = 60): number[] {
   const rootPitch = anchor + mod12(chord.root - anchor);
-  return chordIntervals(chord).map((step) => rootPitch + step);
+  const steps = chordIntervals(chord);
+  // A natural 11 over a major 3rd and a 7th is the avoid-note clash (E
+  // under F a minor 9th up in C11), so the voicing drops the 3rd: C11 is
+  // C G Bb D F, the sus voicing; C13 already leaves the 11 out.
+  const clash =
+    steps.includes(4) &&
+    steps.includes(17) &&
+    (steps.includes(10) || steps.includes(11));
+  return steps
+    .filter((step) => !(clash && step === 4))
+    .map((step) => rootPitch + step);
 }
 
 /** Open voicings: `open` drops the second voice from the top an octave
@@ -6096,6 +8412,8 @@ const PERFORM_MODES = [
   "harp",
   "slop",
   "pattern",
+  // 0.6.1: fretboard-voiced strokes (see `voiceGuitar`, `strokeVoicing`).
+  "guitar",
 ] as const;
 type PerformMode = (typeof PERFORM_MODES)[number];
 
@@ -6115,6 +8433,23 @@ type PerformOptions = Readonly<{
   pattern?: string | number;
   /** 0..1. */
   velocity?: number;
+  /** Guitar mode: the stroke grid (a STROKE_PATTERNS name or D U d u x - .). */
+  strokes?: string;
+  /** Guitar mode: grid step in beats, default 1/2. */
+  step?: number;
+  /** Guitar mode: seconds a full six-string down stroke takes, default 0.022. */
+  speed?: number;
+  /** Guitar mode: tempo in BPM that `speed` converts with, default 120. */
+  tempo?: number;
+  /** Guitar mode: the guitar's tuning, capo, hand, ring and position. */
+  guitar?: GuitarSetup;
+  /** Guitar mode: the chord's root pitch class (default: the lowest note). */
+  root?: number;
+  /**
+   * Guitar mode: a slash bass pitch class that must sound lowest, even when
+   * it is not a chord tone (B/E keeps its E pedal). Default: the lowest note.
+   */
+  slash?: number;
 }>;
 
 type PerformedNote = Readonly<{
@@ -6431,6 +8766,24 @@ function perform(
         }
       return out.sort((a, b) => a.start - b.start || a.pitch - b.pitch);
     }
+    case "guitar": {
+      const bass = options.slash ?? notes[0]!;
+      const voicing = voiceGuitar(
+        notes.map(mod12),
+        mod12(bass),
+        options.root ?? mod12(bass),
+        options.guitar,
+      );
+      if (!voicing) return notes.map((pitch) => at(pitch, start, end));
+      return strokeVoicing(voicing, start, length, {
+        ...(options.strokes !== undefined ? { strokes: options.strokes } : {}),
+        ...(options.step !== undefined ? { step: options.step } : {}),
+        ...(options.speed !== undefined ? { speed: options.speed } : {}),
+        ...(options.tempo !== undefined ? { tempo: options.tempo } : {}),
+        velocity,
+        strings: guitarStrings(options.guitar?.tune).length,
+      });
+    }
     case "harp": {
       const gap = Math.max(0, options.strum ?? DEFAULT_STRUM * 2);
       return spanned.map((pitch, index) =>
@@ -6465,6 +8818,380 @@ function perform(
   }
 }
 
+// ---------------------------------------------------------------------------
+// Fretboard (0.6.1): guitar voicings and strokes
+
+/**
+ * Open-string MIDI pitches, low string to high, for `guitar tune <name>`.
+ * Ported from the guitar design lane (proto/guitar/strum.ts TUNINGS).
+ */
+const GUITAR_TUNINGS = Object.freeze({
+  standard: [40, 45, 50, 55, 59, 64],
+  dropd: [38, 45, 50, 55, 59, 64],
+  doubledropd: [38, 45, 50, 55, 59, 62],
+  dadgad: [38, 45, 50, 55, 57, 62],
+  openg: [38, 43, 50, 55, 59, 62],
+  opend: [38, 45, 50, 54, 57, 62],
+  opene: [40, 47, 52, 56, 59, 64],
+  halfdown: [39, 44, 49, 54, 58, 63],
+  nashville: [52, 57, 62, 67, 59, 64],
+  bass: [28, 33, 38, 43],
+  ukulele: [67, 60, 64, 69],
+  requinto: [45, 50, 55, 60, 64, 69],
+} as const satisfies Record<string, readonly number[]>);
+type GuitarTuningName = keyof typeof GUITAR_TUNINGS;
+const GUITAR_TUNING_NAMES = Object.keys(GUITAR_TUNINGS) as GuitarTuningName[];
+
+/** How a guitar is set up for voicing chords (`Track.guitar`). */
+type GuitarSetup = Readonly<{
+  /** A GUITAR_TUNINGS name or open-string pitches low to high. */
+  tune?: string | readonly number[];
+  /** Capo fret 0..12. */
+  capo?: number;
+  /** Hand stretch in frets 3..6 (default 4: one fret per finger). */
+  hand?: number;
+  /** 0 closed shapes (no open strings) .. 1 prefer ringing open strings. */
+  ring?: number;
+  /** Preferred fret position 0..12 (0 open position). */
+  position?: number;
+}>;
+
+/** One fretted chord: frets per string low to high (-1 muted). */
+type GuitarVoicing = Readonly<{
+  frets: readonly number[];
+  /** Sounding pitches, low string to high. */
+  pitches: readonly number[];
+  /** The string each pitch sounds on. */
+  strings: readonly number[];
+}>;
+
+/** Open-string pitches for a tuning name or list (standard when unknown). */
+function guitarStrings(tune: GuitarSetup["tune"]): readonly number[] {
+  if (Array.isArray(tune)) return tune as readonly number[];
+  const name = String(tune ?? "standard")
+    .toLowerCase()
+    .replace(/[\s_-]/g, "");
+  return (
+    (GUITAR_TUNINGS as Record<string, readonly number[]>)[name] ??
+    GUITAR_TUNINGS.standard
+  );
+}
+
+/**
+ * Fingers a fretting uses. Strings at the lowest fret count as one barre
+ * only when no open string lies between them (a barre cannot skip an open
+ * string); otherwise one finger each.
+ */
+function guitarFingers(frets: readonly number[]): number {
+  const fretted = frets.filter((f) => f > 0);
+  if (fretted.length === 0) return 0;
+  const min = Math.min(...fretted);
+  const at = frets.flatMap((f, i) => (f === min ? [i] : []));
+  const between = frets.slice(at[0]!, at[at.length - 1]! + 1);
+  const barre = at.length > 1 && !between.includes(0);
+  return (barre ? 1 : at.length) + fretted.filter((f) => f > min).length;
+}
+
+/**
+ * The chord tones a voicing must keep, most required first, after dropping
+ * `drops` tones in the guitarist's order: the 5th, then the 9th; the root,
+ * the 3rd and the 7th always stay (after the design lane's review).
+ */
+function requiredTones(tones: readonly number[], root: number, drops: number) {
+  // The 5th, then the 11th (only beside a 3rd: a sus4 keeps its 4th), then
+  // the 9th. dawg's symbols reach an 11th through m(add4)/madd4 (+9).
+  const third = tones.some((pc) => [3, 4].includes(mod12(pc - root)));
+  const order = (third ? [7, 5, 2] : [7, 2]).map((step) => mod12(root + step));
+  const dropped = order.filter((pc) => tones.includes(pc)).slice(0, drops);
+  return tones.filter((pc) => !dropped.includes(pc));
+}
+
+/**
+ * The most playable fretting of pitch classes `tones` over `bass` on a
+ * guitar `setup`: the bass is the lowest sounding note, every required
+ * tone sounds, at most four fingers within a `hand`-fret stretch, mutes
+ * only under the bass or one inside, and no barre over an open string.
+ * Cost prefers more strings, low positions, open strings (by `ring`), a
+ * fifth present, no doubled third, and small moves from `previous`.
+ * Undefined when nothing fits. Ported from proto/guitar/strum.ts.
+ */
+function voiceGuitar(
+  tones: readonly number[],
+  bass: number,
+  root: number,
+  setup: GuitarSetup = {},
+  previous?: readonly number[],
+): GuitarVoicing | undefined {
+  // Play mode voices every pad press; dense chords at a wide hand take
+  // ~15 ms to search, so repeats come from a small LRU (results are frozen).
+  const key = JSON.stringify([
+    [...new Set([...tones, bass].map(mod12))],
+    mod12(bass),
+    mod12(root),
+    setup.tune ?? null,
+    setup.capo ?? null,
+    setup.hand ?? null,
+    setup.ring ?? null,
+    setup.position ?? null,
+    previous ?? null,
+  ]);
+  if (voicingCache.has(key)) {
+    const hit = voicingCache.get(key);
+    voicingCache.delete(key);
+    voicingCache.set(key, hit);
+    return hit;
+  }
+  const voiced = searchGuitar(tones, bass, root, setup, previous);
+  voicingCache.set(key, voiced);
+  if (voicingCache.size > VOICING_CACHE_SIZE)
+    voicingCache.delete(voicingCache.keys().next().value!);
+  return voiced;
+}
+
+const VOICING_CACHE_SIZE = 256;
+const voicingCache = new Map<string, GuitarVoicing | undefined>();
+
+function searchGuitar(
+  tones: readonly number[],
+  bass: number,
+  root: number,
+  setup: GuitarSetup,
+  previous?: readonly number[],
+): GuitarVoicing | undefined {
+  const pcs = [...new Set([...tones, bass].map(mod12))];
+  const capo = clampInt(setup.capo ?? 0, 0, 12);
+  const open = guitarStrings(setup.tune).map((pitch) => pitch + capo);
+  const n = open.length;
+  const ring = Math.min(1, Math.max(0, setup.ring ?? 0.5));
+  const stretch = clampInt(setup.hand ?? 4, 3, 6);
+  const fifth = mod12(root + 7);
+  const third = pcs.find((pc) => [3, 4].includes(mod12(pc - root)));
+  const prev = previous ? [...previous].sort((a, b) => a - b) : undefined;
+  for (let drops = 0; drops <= 3; drops += 1) {
+    const required = requiredTones(pcs, root, drops);
+    let best: { frets: number[]; cost: number } | undefined;
+    const choose = (frets: readonly number[]) => {
+      const idx = frets.flatMap((f, i) => (f < 0 ? [] : [i]));
+      if (idx.length < Math.min(n, n >= 6 ? 4 : 3)) return;
+      const interior = frets.slice(idx[0]).filter((f) => f < 0).length;
+      if (interior > (n >= 6 ? 1 : 0)) return;
+      const pitches = idx.map((i) => open[i]! + frets[i]!);
+      if (mod12(Math.min(...pitches)) !== mod12(bass)) return;
+      const sounding = new Set(pitches.map(mod12));
+      if (required.some((pc) => !sounding.has(pc))) return;
+      const fingers = guitarFingers(frets);
+      if (fingers > 4) return;
+      const fretted = frets.filter((f) => f > 0);
+      const span = fretted.length
+        ? Math.max(...fretted) - Math.min(...fretted)
+        : 0;
+      if (span > stretch - 1) return;
+      const opens = frets.filter((f) => f === 0).length;
+      if (ring === 0 && opens > 0) return;
+      const pos = fretted.length ? Math.min(...fretted) : 0;
+      let cost =
+        span * 0.6 +
+        pos * 0.25 +
+        fingers * 0.4 -
+        idx.length -
+        opens * 0.7 * ring;
+      cost += interior * 1.5;
+      if (!sounding.has(fifth) && pcs.includes(fifth)) cost += 0.6;
+      if (
+        third !== undefined &&
+        pitches.filter((p) => mod12(p) === third).length > 1
+      )
+        cost += 0.5;
+      if (setup.position !== undefined)
+        cost += Math.abs(pos - setup.position) * 0.5;
+      if (prev && prev.length) {
+        const cur = [...pitches].sort((a, b) => a - b);
+        let move = 0;
+        for (let i = 0; i < cur.length; i += 1)
+          move += Math.abs(cur[i]! - prev[Math.min(i, prev.length - 1)]!);
+        cost += move * 0.05;
+      }
+      if (
+        !best ||
+        cost < best.cost - 1e-9 ||
+        (Math.abs(cost - best.cost) <= 1e-9 && frets.join() < best.frets.join())
+      )
+        best = { frets: [...frets], cost };
+    };
+    for (let p = 1; p <= 12; p += 1) {
+      const options = open.map((o) => {
+        const list = [-1];
+        if (pcs.includes(mod12(o))) list.push(0);
+        for (let f = p; f < p + stretch; f += 1)
+          if (pcs.includes(mod12(o + f))) list.push(f);
+        return list;
+      });
+      const frets = new Array<number>(n).fill(-1);
+      const walk = (s: number): void => {
+        if (s === n) return choose(frets);
+        for (const f of options[s]!) {
+          frets[s] = f;
+          walk(s + 1);
+        }
+      };
+      walk(0);
+    }
+    if (best) {
+      const { frets } = best as { frets: number[] };
+      const strings = frets.flatMap((f, i) => (f < 0 ? [] : [i]));
+      return Object.freeze({
+        frets: Object.freeze(frets),
+        pitches: Object.freeze(strings.map((i) => open[i]! + frets[i]!)),
+        strings: Object.freeze(strings),
+      });
+    }
+  }
+  return undefined;
+}
+
+/** A voicing as tab, low string first: `x 3 2 0 1 0`. */
+function guitarTab(frets: readonly number[]): string {
+  return frets.map((f) => (f < 0 ? "x" : String(f))).join(" ");
+}
+
+/**
+ * Stroke grids for perform mode `guitar`, one character per step: D down
+ * (all strings), U up (top four), d light down (top four), u light up (top
+ * three), x muted chuck, `-` or `.` rest (strings ring on). After the
+ * design lane's STRUM_PATTERNS.
+ */
+const STROKE_PATTERNS = Object.freeze({
+  down: "D",
+  folk: "D-DU-UDU",
+  pop: "D-DU-UD-",
+  punk: "DDDDDDDD",
+  funk: "xUxUDUxUxUDUxUxU",
+  reggae: "-D-D",
+  waltz: "Ddd",
+  jangle: "D-DUDUDU",
+  island: "D-DU-UDU",
+} as const satisfies Record<string, string>);
+const STROKE_PATTERN_NAMES = Object.keys(STROKE_PATTERNS);
+const STROKE_CHARS = /^[DUdux.\-]+$/;
+
+/** Default seconds a full six-string down stroke takes (22 ms). */
+const DEFAULT_STROKE_SPEED = 0.022;
+/** Default stroke grid step in beats (8ths). */
+const DEFAULT_STROKE_STEP = 0.5;
+
+/** A stroke grid by name, or a literal grid of D U d u x - .; undefined if bad. */
+function strokeGrid(text: string | undefined): string | undefined {
+  const raw = (text ?? "down").trim();
+  const named = (STROKE_PATTERNS as Record<string, string>)[raw.toLowerCase()];
+  if (named) return named;
+  const grid = raw.replace(/[|\s]/g, "");
+  return grid.length > 0 && grid.length <= 64 && STROKE_CHARS.test(grid)
+    ? grid
+    : undefined;
+}
+
+/**
+ * Strum fretted `voicing` from `start` for `length` beats with stroke grid
+ * `strokes` (repeats every grid length, one step per `step` beats). A full
+ * down stroke sweeps the six strings in `speed` seconds at `tempo` BPM;
+ * each struck string rings until it is struck again or the chord ends; a
+ * chuck (x) is a short muted hit that stops the strings. Velocity accents
+ * downbeats and lightens upstrokes.
+ */
+function strokeVoicing(
+  voicing: GuitarVoicing,
+  start: number,
+  length: number,
+  options: Readonly<{
+    strokes?: string;
+    step?: number;
+    speed?: number;
+    tempo?: number;
+    velocity?: number;
+    strings?: number;
+  }> = {},
+): PerformedNote[] {
+  const grid = strokeGrid(options.strokes) ?? "D";
+  const step =
+    options.step && options.step > 0 ? options.step : DEFAULT_STROKE_STEP;
+  const tempo = options.tempo && options.tempo > 0 ? options.tempo : 120;
+  const sweep =
+    (Math.max(0, options.speed ?? DEFAULT_STROKE_SPEED) * tempo) / 60;
+  const base = options.velocity ?? 0.8;
+  const total = Math.max(2, options.strings ?? 6);
+  const sounding = voicing.strings;
+  const end = start + length;
+  type Open = { note: PerformedNote; index: number };
+  const ringing = new Map<number, Open>();
+  const out: PerformedNote[] = [];
+  const stop = (string: number, at: number) => {
+    const held = ringing.get(string);
+    if (!held) return;
+    const cut = round6(
+      Math.max(1e-3, Math.min(held.note.length, at - held.note.start)),
+    );
+    out[held.index] = { ...held.note, length: cut };
+    ringing.delete(string);
+  };
+  const steps = Math.max(1, Math.round(length / step));
+  for (let s = 0; s < steps; s += 1) {
+    const ch = grid[s % grid.length]!;
+    if (ch === "-" || ch === ".") continue;
+    const t0 = start + s * step;
+    if (t0 >= end - 1e-9) break;
+    const beat = s * step;
+    const accent =
+      Math.abs(beat - Math.round(beat)) < 1e-9
+        ? Math.round(beat) % 2 === 0
+          ? 1
+          : 0.92
+        : 0.82;
+    let order: number[];
+    let velocity = base * accent;
+    let ring = end - t0;
+    const all = sounding.map((_, k) => k);
+    switch (ch) {
+      case "D":
+        order = all;
+        break;
+      case "U":
+        order = all.slice(-4).reverse();
+        velocity *= 0.85;
+        break;
+      case "d":
+        order = all.slice(-4);
+        velocity *= 0.62;
+        break;
+      case "u":
+        order = all.slice(-3).reverse();
+        velocity *= 0.55;
+        break;
+      default:
+        order = all;
+        velocity *= 0.5;
+        ring = Math.min(ring, 0.03 * (tempo / 60));
+    }
+    const first = sounding[order[0]!]!;
+    order.forEach((k, position) => {
+      const string = sounding[k]!;
+      const at = t0 + (Math.abs(string - first) / (total - 1)) * sweep;
+      if (at >= end - 1e-9) return;
+      stop(string, at);
+      const note: PerformedNote = {
+        pitch: voicing.pitches[k]!,
+        start: round6(at),
+        length: round6(Math.max(1e-3, Math.min(ring, end - at))),
+        velocity: round6(
+          Math.max(0.05, Math.min(1, velocity * (1 - 0.04 * position))),
+        ),
+      };
+      out.push(note);
+      if (ch !== "x") ringing.set(string, { note, index: out.length - 1 });
+    });
+  }
+  return out.sort((a, b) => a.start - b.start || a.pitch - b.pitch);
+}
+
 // ---------------------------------------------------------------------------
 // Progressions
 
@@ -6848,6 +9575,14 @@ function renderProgression(options: RenderOptions): RenderedProgression {
         ...perform(chord.pitches, at, span, {
           ...options.perform,
           seed: (options.perform?.seed ?? 0) + index,
+          ...(options.perform?.mode === "guitar"
+            ? {
+                root: options.chords[index]!.root,
+                ...(options.chords[index]!.bass !== undefined
+                  ? { slash: options.chords[index]!.bass }
+                  : {}),
+              }
+            : {}),
         }),
       );
     const source = options.chords[index]!;
@@ -6876,6 +9611,362 @@ function renderProgression(options: RenderOptions): RenderedProgression {
 }
 // END chord engine
 
+// ---------------------------------------------------------------------------
+// Audio clips, takes and lyrics (SDK 1.32.0)
+
+/** Options for `audio()`: times in beats, offsets and lengths in seconds. */
+export type AudioOptions = Readonly<{
+  /** Stable clip id; defaults to `clip`, `clip2`, ... by position. */
+  id?: string;
+  /** Beat the clip starts on, default 0. */
+  at?: number;
+  /** Seconds into the file where the clip starts, default 0. */
+  offset?: number;
+  /** Seconds of the file it plays, default to the end. */
+  dur?: number;
+  /** Linear gain 0..4, default 1. */
+  gain?: number;
+  /** Equal-power fade in, seconds (default 5 ms). */
+  fadeInTime?: number;
+  /** Equal-power fade out, seconds (default 5 ms). */
+  fadeTime?: number;
+  /** Play the slice backwards. */
+  rev?: boolean;
+  /** The track take this clip plays from (its clock drift applies). */
+  take?: string;
+  mute?: boolean;
+  /** The words sung in the clip, for the highway and lyrics. */
+  text?: string;
+  /** A text-to-speech clip's time map (0.7.1); kept as written. */
+  say?: Readonly<Record<string, unknown>>;
+  /** The file's pin; dawg fills it from the file when absent. */
+  sha256?: string;
+}>;
+
+/** One audio clip as `audio()` builds it. */
+export type AudioSpec = Readonly<
+  { kind: "audio"; src: string; at: number } & Omit<AudioOptions, "at">
+>;
+
+const AUDIO_KEYS = [
+  "id",
+  "at",
+  "offset",
+  "dur",
+  "gain",
+  "fadeInTime",
+  "fadeTime",
+  "rev",
+  "take",
+  "mute",
+  "text",
+  "say",
+  "sha256",
+] as const;
+
+/**
+ * An audio file on the track's timeline (SDK 1.32.0). `src` is relative
+ * to the track folder (`samples/lead.wav`) or the project
+ * (`tracks/vox/samples/lead.wav`).
+ *
+ * ```ts
+ * clips: [audio("samples/verse.wav", { at: 16, gain: 0.8, fadeTime: 0.2 })]
+ * ```
+ */
+export function audio(src: string, options: AudioOptions = {}): AudioSpec {
+  const file = text(src, "audio src");
+  if (!isRecord(options))
+    throw new DawgSdkError("audio options must be an object");
+  for (const key of Object.keys(options))
+    if (!(AUDIO_KEYS as readonly string[]).includes(key))
+      throw new DawgSdkError(
+        `audio has an unknown option "${key.slice(0, 32)}" (${AUDIO_KEYS.join(" ")})`,
+      );
+  const out: Record<string, unknown> = {
+    kind: "audio",
+    src: file,
+    at: beat(options.at ?? 0, "audio at"),
+  };
+  if (options.id !== undefined) out.id = text(options.id, "audio id");
+  for (const key of [
+    "offset",
+    "dur",
+    "gain",
+    "fadeInTime",
+    "fadeTime",
+  ] as const)
+    if (options[key] !== undefined) {
+      const value = finite(options[key], `audio ${key}`);
+      if (value < 0) throw new DawgSdkError(`audio ${key} must be ≥ 0`);
+      out[key] = value;
+    }
+  for (const key of ["rev", "mute"] as const)
+    if (options[key] !== undefined) {
+      if (typeof options[key] !== "boolean")
+        throw new DawgSdkError(`audio ${key} must be true or false`);
+      if (options[key]) out[key] = true;
+    }
+  if (options.take !== undefined) out.take = text(options.take, "audio take");
+  if (options.text !== undefined) {
+    if (typeof options.text !== "string" || options.text.length > 2000)
+      throw new DawgSdkError("audio text must be at most 2000 characters");
+    out.text = options.text;
+  }
+  if (options.say !== undefined) {
+    if (!isRecord(options.say))
+      throw new DawgSdkError("audio say must be an object");
+    out.say = options.say;
+  }
+  if (options.sha256 !== undefined) {
+    if (
+      typeof options.sha256 !== "string" ||
+      !/^[0-9a-f]{64}$/.test(options.sha256)
+    )
+      throw new DawgSdkError(
+        "audio sha256 must be 64 lowercase hex characters",
+      );
+    out.sha256 = options.sha256;
+  }
+  return Object.freeze(out) as AudioSpec;
+}
+
+/**
+ * Copies of `clip` every `every` beats after it while they start before
+ * `until` (SDK 1.32.0), the clip first: `...repeatAudio(hook, { every: 8,
+ * until: 64 })`. Copies of a clip with an id get `<id>-r2`, `<id>-r3`, ...
+ */
+export function repeatAudio(
+  clip: AudioSpec,
+  options: Readonly<{ every: number; until: number }>,
+): readonly AudioSpec[] {
+  if (!isRecord(clip) || clip.kind !== "audio")
+    throw new DawgSdkError("repeatAudio needs a clip from audio()");
+  if (!isRecord(options))
+    throw new DawgSdkError("repeatAudio needs { every, until } in beats");
+  const every = positive(options.every, "repeatAudio every");
+  const until = beat(options.until, "repeatAudio until");
+  const out: AudioSpec[] = [clip];
+  for (
+    let at = clip.at + every, pass = 2;
+    at < until - 1e-9 && out.length < 256;
+    at += every, pass += 1
+  )
+    out.push(
+      Object.freeze({
+        ...clip,
+        at,
+        ...(clip.id !== undefined ? { id: `${clip.id}-r${pass}` } : {}),
+      }) as AudioSpec,
+    );
+  return Object.freeze(out);
+}
+
+/** Options for `take()`: `at`, `in` and `out` in beats, the rest in seconds. */
+export type TakeOptions = Readonly<{
+  /** Beat the recording's first sample lines up with. */
+  at?: number;
+  /** Punch range in beats, default `at` to `at + 4`. */
+  in?: number;
+  out?: number;
+  /** Seconds into the file where the take starts. */
+  offset?: number;
+  /** Round-trip latency compensated, seconds. */
+  latency?: number;
+  latencyAssumed?: boolean;
+  /** Clock drift in parts per million (±1000). */
+  ppm?: number;
+  /** 0..1 fit of the alignment. */
+  fit?: number;
+  warn?: string;
+  /** Manual nudge in milliseconds (±250). */
+  nudge?: number;
+  sha256?: string;
+}>;
+
+/** One take as `take()` builds it. */
+export type TakeSpec = Readonly<
+  {
+    kind: "take";
+    name: string;
+    src: string;
+    at: number;
+    in: number;
+    out: number;
+  } & Omit<TakeOptions, "at" | "in" | "out">
+>;
+
+const TAKE_KEYS = [
+  "at",
+  "in",
+  "out",
+  "offset",
+  "latency",
+  "latencyAssumed",
+  "ppm",
+  "fit",
+  "warn",
+  "nudge",
+  "sha256",
+] as const;
+
+/**
+ * A take (SDK 1.32.0): one recorded or imported pass the track's clips can
+ * play from (`audio(src, { take: "take-1" })`). Recording itself is 0.7.1.
+ */
+export function take(
+  name: string,
+  src: string,
+  options: TakeOptions = {},
+): TakeSpec {
+  const label = `take ${text(name, "take name")}`;
+  if (!isRecord(options))
+    throw new DawgSdkError(`${label} options must be an object`);
+  for (const key of Object.keys(options))
+    if (!(TAKE_KEYS as readonly string[]).includes(key))
+      throw new DawgSdkError(
+        `${label} has an unknown option "${key.slice(0, 32)}" (${TAKE_KEYS.join(" ")})`,
+      );
+  const at = beat(options.at ?? 0, `${label} at`);
+  const from = beat(options.in ?? at, `${label} in`);
+  const to = beat(options.out ?? from + 4, `${label} out`);
+  if (to <= from) throw new DawgSdkError(`${label}: out must be after in`);
+  const out: Record<string, unknown> = {
+    kind: "take",
+    name,
+    src: text(src, `${label} src`),
+    at,
+    in: from,
+    out: to,
+  };
+  for (const key of ["offset", "latency", "ppm", "fit", "nudge"] as const)
+    if (options[key] !== undefined)
+      out[key] = finite(options[key], `${label} ${key}`);
+  if (options.latencyAssumed) out.latencyAssumed = true;
+  if (options.warn !== undefined)
+    out.warn = text(options.warn, `${label} warn`);
+  if (options.sha256 !== undefined)
+    out.sha256 = text(options.sha256 as unknown, `${label} sha256`);
+  return Object.freeze(out) as TakeSpec;
+}
+
+/**
+ * Sings `text` on `notes` in time order (SDK 1.32.0): spaces split words,
+ * `-` splits syllables, `_` holds the previous syllable over the next note
+ * (melisma), `~` skips a note. With fewer syllables than notes, words typed
+ * whole split by vowel groups and leftover notes hold the last syllable;
+ * syllables past the last note are dropped. Same rules as `/lyrics`.
+ *
+ * ```ts
+ * notes: lyrics("sun-lit morn-ing glow", seq("C4 D4 E4 G4 E4"))
+ * ```
+ */
+export function lyrics<N extends NoteSpec>(
+  text: string,
+  notes: readonly N[],
+): readonly N[] {
+  if (typeof text !== "string" || text.length > 2000)
+    throw new DawgSdkError("lyrics text must be at most 2000 characters");
+  if (!Array.isArray(notes))
+    throw new DawgSdkError("lyrics needs an array of notes");
+  const keyed = notes.map((n, index) => ({
+    id: String(index),
+    startTick: Math.round(n.start * 960),
+    pitch: n.pitch,
+  }));
+  const { lyrics: sung } = assignLyrics(text, keyed);
+  return Object.freeze(
+    notes.map((n, index) => {
+      const lyric = sung.get(String(index));
+      if (lyric === undefined) {
+        const { lyric: _drop, ...rest } = n as N & { lyric?: string };
+        return Object.freeze(rest) as unknown as N;
+      }
+      return Object.freeze({ ...n, lyric }) as N;
+    }),
+  );
+}
+
+/** A clip for `song()`, ticks resolved and its default id filled. */
+function storedClip(
+  clip: AudioSpec,
+  index: number,
+  ticks: (beats: number) => number,
+): Record<string, unknown> {
+  const { kind: _kind, at, id, ...rest } = clip;
+  return Object.freeze({
+    id: id ?? defaultClipId(index),
+    ...rest,
+    startTick: ticks(at),
+  });
+}
+
+/** The id a clip without one gets: `clip`, `clip2`, `clip3`, ... */
+export function defaultClipId(index: number): string {
+  return index === 0 ? "clip" : `clip${index + 1}`;
+}
+
+function storedTake(
+  spec: TakeSpec,
+  ticks: (beats: number) => number,
+): Record<string, unknown> {
+  const { kind: _kind, at, in: from, out: to, ...rest } = spec;
+  return Object.freeze({
+    offset: 0,
+    latency: 0,
+    ...rest,
+    startTick: ticks(at),
+    inTick: ticks(from),
+    outTick: ticks(to),
+  });
+}
+
+/** `track({ clips, takes })` as TrackSpec fields, paths project-relative. */
+function trackClips(
+  input: TrackInput,
+  name: string,
+  slug: string,
+): { clips?: readonly AudioSpec[]; takes?: readonly TakeSpec[] } {
+  const local = (src: string) => {
+    const path = src.replace(/^\.\//, "");
+    return path.startsWith("tracks/") || path.startsWith("pack:")
+      ? path
+      : `tracks/${slug}/${path}`;
+  };
+  const out: { clips?: readonly AudioSpec[]; takes?: readonly TakeSpec[] } = {};
+  if (input.clips !== undefined) {
+    if (!Array.isArray(input.clips))
+      throw new DawgSdkError(
+        `track ${name}: clips must be an array of audio()`,
+      );
+    const flat = (input.clips as readonly unknown[]).flat();
+    const clips = flat.map((item, index) => {
+      if (!isRecord(item) || item.kind !== "audio")
+        throw new DawgSdkError(
+          `track ${name}: clips[${index}] must come from audio() or repeatAudio()`,
+        );
+      const clip = item as AudioSpec;
+      return Object.freeze({ ...clip, src: local(clip.src) }) as AudioSpec;
+    });
+    if (clips.length > 256)
+      throw new DawgSdkError(`track ${name}: at most 256 clips`);
+    if (clips.length > 0) out.clips = Object.freeze(clips);
+  }
+  if (input.takes !== undefined) {
+    if (!Array.isArray(input.takes))
+      throw new DawgSdkError(`track ${name}: takes must be an array of take()`);
+    const takes = input.takes.map((item, index) => {
+      if (!isRecord(item) || item.kind !== "take")
+        throw new DawgSdkError(
+          `track ${name}: takes[${index}] must come from take()`,
+        );
+      const spec = item as TakeSpec;
+      return Object.freeze({ ...spec, src: local(spec.src) }) as TakeSpec;
+    });
+    if (takes.length > 0) out.takes = Object.freeze(takes);
+  }
+  return out;
+}
+
 // ---------------------------------------------------------------------------
 // Internals