@hraness/dawg 0.5.0 → 0.6.1

package/core/sdk/print.ts

@@ -8,11 +8,26 @@
  */
 
 import { DRUM_VOICES, isDrumInstrument } from "../drums.ts";
+import type { TrackGranular } from "../granular.ts";
 import { DEFAULT_FIXED_VELOCITY } from "../expression.ts";
 import type { RhythmRow } from "../euclid.ts";
-import { FX_LANES, fxSpec, type FxName, type FxValues } from "../fx.ts";
+import {
+  FX_LANES,
+  RIG_STAGES,
+  fxSpec,
+  rigPresetKeys,
+  rigPresetOf,
+  type FxName,
+  type FxValues,
+} from "../fx.ts";
 import { MASTER_SPECS, MASTER_UNITS, type SongMaster } from "../master.ts";
 import { midiToPitch } from "../pitch.ts";
+import {
+  MODAL_INSTRUMENT,
+  MODAL_PARAMS,
+  type TrackModal,
+} from "../resonators.ts";
+import { WIND_INSTRUMENT, WIND_PARAMS, type TrackWind } from "../winds.ts";
 import { rhythmVoicePitch, rowInSync } from "../rhythm.ts";
 import {
   BUILTIN_TABLE_PREFIX,
@@ -35,6 +50,7 @@ import {
 import { trackSlug } from "../slug.ts";
 import { barStartTick } from "../tempo.ts";
 import type { Tuning } from "../tuning.ts";
+import { DEFAULT_STRING_PRESET, type TrackString } from "../strings.ts";
 import { DEFAULT_HIT_LENGTH, DEFAULT_VELOCITY } from "./v1.ts";
 
 const WIDTH = 80;
@@ -137,6 +153,10 @@ const RESERVED = new Set([
   "every",
   "sampler",
   "wavetable",
+  "rig",
+  "granular",
+  "modal",
+  "wind",
   "slices",
   "euclid",
   "euclidRot",
@@ -381,22 +401,62 @@ export function printTrack(score: TrackScore, track: Track): string {
     used.add("note");
     return printNote(score, note, !kit && !slots, INDENT + INDENT);
   });
+  const grained =
+    track.instrument === "granular" && track.granular !== undefined;
+  if (grained) used.add("granular");
   if (track.sampler) used.add("sampler");
   const wavetable = isWavetableInstrument(track.instrument)
     ? wavetableOf(track)
     : undefined;
   if (wavetable) used.add("wavetable");
+  const stringed = track.instrument === "string" && track.string !== undefined;
+  if (stringed) used.add("stringed");
+  const modalCall =
+    track.instrument === MODAL_INSTRUMENT && track.modal
+      ? printModal(track.modal, INDENT)
+      : undefined;
+  if (modalCall?.startsWith("modal(")) used.add("modal");
+  const windCall =
+    track.instrument === WIND_INSTRUMENT && track.wind
+      ? printWind(track.wind, INDENT)
+      : undefined;
+  if (windCall?.startsWith("wind(")) used.add("wind");
 
   const entries: string[] = [
     `id: ${str(track.id)}`,
     `name: ${str(track.name)}`,
   ];
-  if (track.sampler) {
+  if (grained) {
+    entries.push(`instrument: ${printGranular(track.granular!, INDENT)}`);
+    // The sampler a granular track keeps for `grain off`.
+    if (track.sampler)
+      entries.push(`sampler: ${printSampler(track.sampler, INDENT)}`);
+  } else if (track.sampler) {
     entries.push(`instrument: ${printSampler(track.sampler, INDENT)}`);
   } else if (wavetable) {
     entries.push(`instrument: ${printWavetable(wavetable, INDENT)}`);
+  } else if (stringed) {
+    entries.push(`instrument: ${printStringed(track.string!, INDENT)}`);
+  } else if (modalCall) {
+    entries.push(`instrument: ${modalCall}`);
+  } else if (windCall) {
+    entries.push(`instrument: ${windCall}`);
   } else entries.push(`instrument: ${str(track.instrument)}`);
   if (track.kit) entries.push(`kit: ${str(track.kit)}`);
+  if (track.granular && !grained)
+    entries.push(
+      `granular: ${obj(
+        [
+          ...(track.granular.preset
+            ? [["preset", str(track.granular.preset)] as const]
+            : []),
+          ...granularEntries(track.granular, INDENT),
+        ],
+        INDENT,
+        "granular: ".length,
+        1,
+      )}`,
+    );
   if (track.time) {
     const beats = (ticks: number) => num(ticks / score.ticksPerBeat);
     const fields: (readonly [string, string])[] = [];
@@ -480,18 +540,31 @@ export function printTrack(score: TrackScore, track: Track): string {
       )}`,
     );
   if (track.fx) {
-    const effects = Object.entries(track.fx) as [FxName, FxValues][];
+    // A whole rig preset prints as `...rig("crunch")` (SDK 1.22.0).
+    const rigName = rigPresetOf(track.fx);
+    if (rigName) used.add("rig");
+    const effects = (Object.entries(track.fx) as [FxName, FxValues][]).filter(
+      ([effect]) =>
+        !rigName ||
+        !(
+          (RIG_STAGES as readonly string[]).includes(effect) ||
+          rigPresetKeys(rigName).includes(effect)
+        ),
+    );
     const inner = INDENT + INDENT;
-    const body = effects.map(([effect, values]) => {
-      // Only values that differ from the default: decoding fills the rest.
-      const params = Object.entries(fxSpec(effect).params)
-        .filter(
-          ([key, spec]) =>
-            values[key] !== undefined && values[key] !== spec.default,
-        )
-        .map(([key]) => [key, value(values[key]!)] as const);
-      return `${inner}${effect}: ${params.length === 0 ? "{}" : obj(params, inner, `${effect}: `.length, 1)},`;
-    });
+    const rigLine = rigName ? [`${inner}...rig(${str(rigName)}),`] : [];
+    const body = rigLine.concat(
+      effects.map(([effect, values]) => {
+        // Only values that differ from the default: decoding fills the rest.
+        const params = Object.entries(fxSpec(effect).params)
+          .filter(
+            ([key, spec]) =>
+              values[key] !== undefined && values[key] !== spec.default,
+          )
+          .map(([key]) => [key, value(values[key]!)] as const);
+        return `${inner}${effect}: ${params.length === 0 ? "{}" : obj(params, inner, `${effect}: `.length, 1)},`;
+      }),
+    );
     entries.push(`fx: {\n${body.join("\n")}\n${INDENT}}`);
   }
   if (track.synth) {
@@ -506,6 +579,21 @@ export function printTrack(score: TrackScore, track: Track): string {
     );
     entries.push(`synth: ${obj(params, INDENT, "synth: ".length, 1)}`);
   }
+  if (track.string && !stringed) {
+    const params = Object.entries(track.string).map(
+      ([key, v]) => [key, value(v!)] as const,
+    );
+    entries.push(`string: ${obj(params, INDENT, "string: ".length, 1)}`);
+  }
+  if (track.keys) {
+    // `{}` is meaningful: it turns the modelled piano on.
+    const params = Object.entries(track.keys).map(
+      ([key, v]) => [key, value(v)] as const,
+    );
+    entries.push(
+      `keys: ${params.length === 0 ? "{}" : obj(params, INDENT, "keys: ".length, 1)}`,
+    );
+  }
   entries.push(...performanceEntries(score, track));
   const lanes: [string, readonly AutomationPoint[] | undefined][] = [
     ["volume", track.volumeAutomation],
@@ -575,6 +663,11 @@ export function printTrack(score: TrackScore, track: Track): string {
     "every",
     "sampler",
     "wavetable",
+    "stringed",
+    "rig",
+    "granular",
+    "modal",
+    "wind",
     "euclid",
     "grid",
   ]
@@ -725,13 +818,15 @@ function performanceEntries(score: TrackScore, track: Track): string[] {
             1,
           )}`,
     );
-  if (track.pedal) {
-    const events = track.pedal.map(
+  for (const key of ["pedal", "softPedal", "sostenuto"] as const) {
+    const lane = track[key];
+    if (!lane) continue;
+    const events = lane.map(
       (event) =>
         `[${num(event.tick / score.ticksPerBeat)}, ${str(event.state)}]`,
     );
     entries.push(
-      `pedal: ${list(events, INDENT, "pedal: ".length, 1, events.length > 1)}`,
+      `${key}: ${list(events, INDENT, `${key}: `.length, 1, events.length > 1)}`,
     );
   }
   if (track.velocityCurve)
@@ -768,6 +863,20 @@ function performanceEntries(score: TrackScore, track: Track): string[] {
       )}`,
     );
   }
+  if (track.guitar) {
+    const { tune, capo, hand, ring, position } = track.guitar;
+    const fields: [string, string][] = [];
+    if (tune !== undefined)
+      fields.push([
+        "tune",
+        typeof tune === "string" ? str(tune) : `[${tune.map(num).join(", ")}]`,
+      ]);
+    if (capo !== undefined) fields.push(["capo", num(capo)]);
+    if (hand !== undefined) fields.push(["hand", num(hand)]);
+    if (ring !== undefined) fields.push(["ring", num(ring)]);
+    if (position !== undefined) fields.push(["position", num(position)]);
+    entries.push(`guitar: ${obj(fields, INDENT, "guitar: ".length, 1)}`);
+  }
   return entries;
 }
 
@@ -859,6 +968,108 @@ function printSampler(sampler: Sampler, indent: string): string {
   return `sampler(\n${inner}${shifted},\n${inner}{ mode: ${str(sampler.mode)} },\n${indent})`;
 }
 
+/** `stringed("sitar", { buzz: 0.8 })`: the preset, then its overrides. */
+function printStringed(settings: TrackString, indent: string): string {
+  const name = str(settings.preset ?? DEFAULT_STRING_PRESET);
+  const params = Object.entries(settings)
+    .filter(([key]) => key !== "preset")
+    .map(([key, v]) => [key, value(v!)] as const);
+  if (params.length === 0) return `stringed(${name})`;
+  const inline = `stringed(${name}, { ${params.map(([k, v]) => `${k}: ${v}`).join(", ")} })`;
+  if (indent.length + "instrument: ".length + inline.length + 1 <= WIDTH)
+    return inline;
+  const inner = indent + INDENT;
+  return `stringed(${name}, {\n${params.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}})`;
+}
+
+/** `[key, literal]` for each stored granular field but the preset. */
+function granularEntries(
+  settings: TrackGranular,
+  indent: string,
+): (readonly [string, string])[] {
+  return Object.entries(settings)
+    .filter(([key]) => key !== "preset")
+    .map(([key, v]) => [
+      key,
+      typeof v === "object"
+        ? printSample(v as SampleRef, indent + INDENT, `${key}: `.length)
+        : value(v as number | string | boolean),
+    ]);
+}
+
+/** `granular("cloud", { scan: 0.1 })`: the preset, then its overrides. */
+function printGranular(settings: TrackGranular, indent: string): string {
+  const inner = indent + INDENT;
+  const params = granularEntries(settings, indent);
+  const name = settings.preset ? str(settings.preset) : undefined;
+  if (params.length === 0) return name ? `granular(${name})` : "granular()";
+  const head = name ? `granular(${name}, ` : "granular(";
+  const inline = `${head}{ ${params.map(([k, v]) => `${k}: ${v}`).join(", ")} })`;
+  if (
+    !inline.includes("\n") &&
+    indent.length + "instrument: ".length + inline.length + 1 <= WIDTH
+  )
+    return inline;
+  return `${head}{\n${params.map(([k, v]) => property(k, v, inner)).join("\n")}\n${indent}})`;
+}
+
+/**
+ * A modal track's instrument: the preset word alone (`"vibes"`) when there
+ * are no overrides, else `modal("vibes", { motor: 4 })` with keys in
+ * `MODAL_PARAMS` order. `marimba` is a legacy word, so the modal marimba
+ * always prints as `modal("marimba")`.
+ */
+function printModal(settings: TrackModal, indent: string): string {
+  const params: [string, string][] = [];
+  for (const key of Object.keys(MODAL_PARAMS) as (keyof TrackModal)[]) {
+    const value = settings[key];
+    if (value === undefined) continue;
+    params.push([key, typeof value === "number" ? num(value) : str(value)]);
+  }
+  if (settings.pair !== undefined) params.push(["pair", str(settings.pair)]);
+  const preset = settings.preset;
+  if (params.length === 0 && preset && preset !== "marimba") return str(preset);
+  const head = preset ? str(preset) : "";
+  if (params.length === 0) return `modal(${head})`;
+  const lead = head ? `${head}, ` : "";
+  const inline = `modal(${lead}{ ${params.map(([k, v]) => `${k}: ${v}`).join(", ")} })`;
+  if (indent.length + "instrument: ".length + inline.length + 1 <= WIDTH)
+    return inline;
+  const inner = indent + INDENT;
+  return `modal(${lead}{\n${params.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}})`;
+}
+
+/**
+ * A wind track's instrument: the preset word alone (`"flute"`) when there
+ * are no overrides, else `wind("sax", { breath: 0.8 })` with keys in
+ * `WIND_PARAMS` order. Every wind preset word is also an instrument word.
+ */
+function printWind(settings: TrackWind, indent: string): string {
+  const params: [string, string][] = [];
+  for (const key of Object.keys(WIND_PARAMS)) {
+    const value = (settings as Record<string, unknown>)[key];
+    if (value === undefined) continue;
+    params.push([
+      key,
+      typeof value === "number"
+        ? num(value)
+        : typeof value === "boolean"
+          ? String(value)
+          : str(String(value)),
+    ]);
+  }
+  const preset = settings.preset;
+  if (params.length === 0 && preset) return str(preset);
+  const head = preset ? str(preset) : "";
+  if (params.length === 0) return `wind(${head})`;
+  const lead = head ? `${head}, ` : "";
+  const inline = `wind(${lead}{ ${params.map(([k, v]) => `${k}: ${v}`).join(", ")} })`;
+  if (indent.length + "instrument: ".length + inline.length + 1 <= WIDTH)
+    return inline;
+  const inner = indent + INDENT;
+  return `wind(${lead}{\n${params.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}})`;
+}
+
 /** `wavetable("basic", { wt: 0.5 })`; pack tables keep their pin. */
 function printWavetable(settings: TrackWavetable, indent: string): string {
   const src = settings.table.src;
@@ -915,6 +1126,26 @@ function printSample(ref: SampleRef, indent: string, prefix: number): string {
   if (ref.accelerate !== undefined)
     entries.push(["accelerate", num(ref.accelerate)]);
   if (ref.squiz !== undefined) entries.push(["squiz", num(ref.squiz)]);
+  if (ref.bpm !== undefined) entries.push(["bpm", num(ref.bpm)]);
+  if (ref.fitmode !== undefined) entries.push(["fitmode", str(ref.fitmode)]);
+  if (ref.len !== undefined) entries.push(["len", num(ref.len)]);
+  if (ref.shift !== undefined) entries.push(["shift", num(ref.shift)]);
+  if (ref.formant !== undefined) entries.push(["formant", num(ref.formant)]);
+  if (ref.fadeInTime !== undefined)
+    entries.push(["fadeInTime", num(ref.fadeInTime)]);
+  if (ref.fadeTime !== undefined) entries.push(["fadeTime", num(ref.fadeTime)]);
+  if (ref.from !== undefined) {
+    const from = ref.from;
+    const parts: [string, string][] = [["source", str(from.source)]];
+    if (from.section !== undefined) parts.push(["section", str(from.section)]);
+    if (from.bars !== undefined)
+      parts.push(["bars", `[${num(from.bars[0])}, ${num(from.bars[1])}]`]);
+    parts.push(["score", str(from.score)]);
+    entries.push(["from", obj(parts, indent + INDENT, "from: ".length, 1)]);
+  }
+  if (ref.vel !== undefined)
+    entries.push(["vel", `[${num(ref.vel[0])}, ${num(ref.vel[1])}]`]);
+  if (ref.rr !== undefined) entries.push(["rr", str(ref.rr)]);
   if (entries.length === 1) return str(ref.src);
   return obj(entries, indent, prefix, 1);
 }

package/core/sdk/sync-instruments.ts

@@ -0,0 +1,58 @@
+/**
+ * The SDK is one vendored file with no imports, so `core/sdk/v1.ts` carries
+ * a copy of the instrument word resolver (`core/instruments.ts`) between two
+ * marker lines. `bun core/sdk/sync-instruments.ts` rewrites it and
+ * `sync-instruments.test.ts` fails when it is stale. Same scheme as
+ * `sync-chords.ts`.
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { format } from "prettier";
+
+export const BEGIN_MARKER =
+  "// BEGIN instrument words: generated from core/instruments.ts by core/sdk/sync-instruments.ts";
+export const END_MARKER = "// END instrument words";
+
+const ROOT = join(import.meta.dir, "..", "..");
+export const INSTRUMENTS_PATH = join(ROOT, "core", "instruments.ts");
+export const SDK_PATH = join(ROOT, "core", "sdk", "v1.ts");
+
+/** The resolver block (markers included) for a `core/instruments.ts` source. */
+export function instrumentBlock(source: string): string {
+  const start = source.indexOf("// ---- instrument words");
+  if (start < 0) throw new Error("core/instruments.ts layout changed");
+  const body = source
+    .slice(source.indexOf("\n", start) + 1)
+    .replace(/^export /gm, "")
+    .trim();
+  return `${BEGIN_MARKER}\n${body}\n${END_MARKER}`;
+}
+
+/** `sdk` with its resolver block replaced, formatted like the repo. */
+export async function syncedSdk(
+  sdk: string,
+  instruments: string,
+): Promise<string> {
+  const from = sdk.indexOf(BEGIN_MARKER);
+  const to = sdk.indexOf(END_MARKER);
+  if (from < 0 || to < 0)
+    throw new Error("v1.ts has no instrument word markers");
+  const next =
+    sdk.slice(0, from) +
+    instrumentBlock(instruments) +
+    sdk.slice(to + END_MARKER.length);
+  return format(next, { parser: "typescript", filepath: SDK_PATH });
+}
+
+if (import.meta.main) {
+  const [sdk, instruments] = await Promise.all([
+    readFile(SDK_PATH, "utf8"),
+    readFile(INSTRUMENTS_PATH, "utf8"),
+  ]);
+  const next = await syncedSdk(sdk, instruments);
+  if (next !== sdk) await writeFile(SDK_PATH, next);
+  console.log(
+    next === sdk ? "v1.ts instrument words up to date" : "v1.ts updated",
+  );
+}