@hraness/dawg 0.5.0 → 0.6.0

package/core/score.ts

@@ -20,7 +20,19 @@ import {
   type FxLane,
   type TrackFx,
 } from "./fx.ts";
+import {
+  MODAL_INSTRUMENT,
+  normalizeModal,
+  type TrackModal,
+} from "./resonators.ts";
 import { normalizeSynth, type TrackSynth } from "./synth.ts";
+import { normalizeString, type TrackString } from "./strings.ts";
+import {
+  isGranularInstrument,
+  normalizeGranular,
+  type TrackGranular,
+} from "./granular.ts";
+import { normalizeKeys, type TrackKeys } from "./keys.ts";
 import {
   checkSongTime,
   normalizeSongTime,
@@ -99,6 +111,11 @@ export const SCORE_LIMITS = Object.freeze({
   maxSampleAccelerate: 8,
   /** Sampler `squiz` ratio bound. */
   maxSampleSquiz: 32,
+  /** Sampler `bpm` (source tempo) bounds. */
+  minSampleBpm: 20,
+  maxSampleBpm: 400,
+  /** Sampler `len` (window length in beats) bound. */
+  maxSampleLenBeats: 1024,
   /** Per sample file, enforced by the decoder and the import tool. */
   maxSampleFileBytes: 50 * 1024 * 1024,
   maxSampleSeconds: 600,
@@ -373,6 +390,29 @@ export type Track = Readonly<{
    * `ref`/`root` over the song tuning. Absent follows the song tuning.
    */
   tuning?: Tuning;
+  /**
+   * String engine settings (`core/strings.ts`): a preset plus overrides.
+   * Played only when `instrument` is "string"; absent keeps today's voice.
+   */
+  string?: TrackString;
+  /**
+   * Granular instrument settings (0.6, `core/granular.ts`). Played when
+   * `instrument` is `"granular"`; kept when the instrument changes.
+   */
+  granular?: TrackGranular;
+  /**
+   * Optional (0.6): modelled piano settings (`core/keys.ts`), `{ preset?,
+   * ...overrides }`. The modelled piano plays only when `instrument` is a
+   * piano family (grand upright felt honkytonk prepared) and this is
+   * present; `{}` is the family's defaults.
+   */
+  keys?: TrackKeys;
+  /**
+   * Optional (0.6): modal percussion (`core/resonators.ts`), a preset plus
+   * overrides. Plays only when `instrument` is `"modal"`; any other
+   * instrument with this field is rejected. Absent keeps today's tone.
+   */
+  modal?: TrackModal;
 }> &
   /**
    * Performance (`core/expression.ts`): glide default, sustain pedal
@@ -449,8 +489,35 @@ export type SampleRef = Readonly<{
    * (1 is off, up to 32).
    */
   squiz?: number;
+  /**
+   * Optional: the sample's own tempo (20..400). The window then follows
+   * the song's tempo map (ramps included): a 174 BPM break in a 128 BPM
+   * song plays 128/174 as fast. `fitmode` picks how.
+   */
+  bpm?: number;
+  /**
+   * Optional: how a fitted sample changes its time. `repitch` (default)
+   * changes speed and pitch together like tape; `beats` cuts the window at
+   * its onsets and places each slice on its new time, unstretched (drums,
+   * speech); `tones` time-stretches with a phase vocoder and keeps the
+   * pitch (pads, loops, vocals). Needs `bpm`, `len` or `fit`.
+   */
+  fitmode?: SampleFitMode;
+  /**
+   * Optional: the window's length in beats (0 < len ≤ 1024), followed
+   * through the song's tempo map. `fit` wins over `bpm`, `bpm` over `len`.
+   */
+  len?: number;
 }>;
 
+/** Sampler `fitmode`: how a fitted window changes its time. */
+export type SampleFitMode = "repitch" | "beats" | "tones";
+export const SAMPLE_FIT_MODES: readonly SampleFitMode[] = Object.freeze([
+  "repitch",
+  "beats",
+  "tones",
+]);
+
 /** Sample `unit`: rate, cycles (bars) or seconds. */
 export type SampleUnit = "r" | "c" | "s";
 export const SAMPLE_UNITS: readonly SampleUnit[] = Object.freeze([
@@ -683,6 +750,10 @@ export type TrackPatch = Readonly<
     velocityCurve?: Track["velocityCurve"] | null;
     humanize?: Track["humanize"] | null;
     tuning?: Tuning | null;
+    string?: TrackString | null;
+    granular?: TrackGranular | null;
+    keys?: TrackKeys | null;
+    modal?: TrackModal | null;
   }
 >;
 
@@ -727,6 +798,10 @@ export type TrackInput = Readonly<
     | "velocityCurve"
     | "humanize"
     | "tuning"
+    | "string"
+    | "granular"
+    | "keys"
+    | "modal"
   > &
     Pick<Track, "id"> & {
       filter?: TrackFilter | null;
@@ -745,6 +820,10 @@ export type TrackInput = Readonly<
       velocityCurve?: Track["velocityCurve"] | string | null;
       humanize?: Track["humanize"] | null;
       tuning?: Tuning | null;
+      string?: TrackString | null;
+      granular?: TrackGranular | null;
+      keys?: TrackKeys | null;
+      modal?: TrackModal | null;
     }
 >;
 
@@ -1134,9 +1213,19 @@ export function updateTrack(
 ): TrackScore {
   if (!score.tracks.some((track) => track.id === trackId)) return score;
   return score.withTracks(
-    score.tracks.map((track) =>
-      track.id === trackId ? { ...track, ...patch } : track,
-    ),
+    score.tracks.map((track) => {
+      if (track.id !== trackId) return track;
+      const next: Record<string, unknown> = { ...track, ...patch };
+      // A modal field only belongs to a modal track: switching the
+      // instrument away drops it unless the patch sets it too.
+      if (
+        patch.instrument !== undefined &&
+        patch.modal === undefined &&
+        patch.instrument !== MODAL_INSTRUMENT
+      )
+        delete next.modal;
+      return next as Track;
+    }),
   );
 }
 
@@ -1717,7 +1806,14 @@ function normalizeTrack(input: unknown): Track {
   const fx = fxOrThrow(() => normalizeFx(input.fx));
   const fxAutomation = normalizeFxAutomation(input.fxAutomation);
   const synth = fxOrThrow(() => normalizeSynth(input.synth));
+  const keys = fxOrThrow(() => normalizeKeys(input.keys));
   const wavetable = normalizeWavetable(input.wavetable);
+  const modal = fxOrThrow(() => normalizeModal(input.modal));
+  if (modal && instrument !== MODAL_INSTRUMENT)
+    throw new ScoreValidationError(
+      `track ${id} has modal settings but its instrument is "${instrument}"`,
+      "invalid-track",
+    );
   const sampler = normalizeSampler(input.sampler);
   const rhythm = normalizeRhythm(input.rhythm, id);
   const time = timeOrThrow(
@@ -1739,6 +1835,15 @@ function normalizeTrack(input: unknown): Track {
     () => normalizeTuning(input.tuning, `track ${id} tuning`),
     "invalid-track",
   );
+  const string = fxOrThrow(() => normalizeString(input.string));
+  // A bare `granular` instrument (set_instrument, `instrument granular`)
+  // gets an empty object, so the engine plays its defaults.
+  const granular =
+    fxOrThrow(() =>
+      normalizeGranular(input.granular, (ref) =>
+        normalizeSampleRef(ref, "granular src"),
+      ),
+    ) ?? (isGranularInstrument(instrument) ? Object.freeze({}) : undefined);
   let kit: string | undefined;
   if (input.kit !== undefined && input.kit !== null) {
     const found =
@@ -1760,7 +1865,12 @@ function normalizeTrack(input: unknown): Track {
       `track ${id} instrument "sampler" needs a sampler`,
       "invalid-track",
     );
-  if (sampler && !isSamplerInstrument(instrument))
+  // A granular track keeps the sampler it grains (`grain off` goes back).
+  if (
+    sampler &&
+    !isSamplerInstrument(instrument) &&
+    !isGranularInstrument(instrument)
+  )
     throw new ScoreValidationError(
       `track ${id} has a sampler but its instrument is "${instrument}"`,
       "invalid-track",
@@ -1793,6 +1903,10 @@ function normalizeTrack(input: unknown): Track {
     ...(time ? { time } : {}),
     ...performance,
     ...(tuning ? { tuning } : {}),
+    ...(string ? { string } : {}),
+    ...(granular ? { granular } : {}),
+    ...(keys ? { keys } : {}),
+    ...(modal ? { modal } : {}),
   });
 }
 
@@ -2000,6 +2114,9 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
     fit?: boolean;
     accelerate?: number;
     squiz?: number;
+    bpm?: number;
+    fitmode?: SampleFitMode;
+    len?: number;
   } = { src };
   if (input.sha256 !== undefined) {
     if (typeof input.sha256 !== "string" || !SHA256_HEX.test(input.sha256))
@@ -2163,6 +2280,46 @@ export function normalizeSampleRef(input: unknown, name: string): SampleRef {
       1,
       SCORE_LIMITS.maxSampleSquiz,
     );
+  if (input.bpm !== undefined)
+    ref.bpm = boundedNumber(
+      input.bpm,
+      `${label} bpm`,
+      SCORE_LIMITS.minSampleBpm,
+      SCORE_LIMITS.maxSampleBpm,
+    );
+  if (input.fitmode !== undefined) {
+    if (!SAMPLE_FIT_MODES.includes(input.fitmode as SampleFitMode))
+      throw new ScoreValidationError(
+        `${label} fitmode must be "repitch", "beats" or "tones"`,
+        "invalid-track",
+      );
+    ref.fitmode = input.fitmode as SampleFitMode;
+  }
+  if (input.len !== undefined) {
+    const len = boundedNumber(
+      input.len,
+      `${label} len`,
+      0,
+      SCORE_LIMITS.maxSampleLenBeats,
+    );
+    if (len === 0)
+      throw new ScoreValidationError(
+        `${label} len must be greater than 0`,
+        "invalid-track",
+      );
+    ref.len = len;
+  }
+  if (
+    ref.fitmode !== undefined &&
+    ref.fitmode !== "repitch" &&
+    ref.bpm === undefined &&
+    ref.len === undefined &&
+    ref.fit !== true
+  )
+    throw new ScoreValidationError(
+      `${label} fitmode ${ref.fitmode} needs bpm, len or fit`,
+      "invalid-track",
+    );
   return Object.freeze(ref);
 }
 
@@ -2403,10 +2560,28 @@ function normalizeAutomation(
   return freezeArray(points);
 }
 
+/** The note cap `normalizeNotes` enforces; see `withNoteCap`. */
+let noteCap: number = SCORE_LIMITS.maxNotes;
+
+/**
+ * Runs `fn` with the note cap raised to `cap`. Stored scores keep
+ * SCORE_LIMITS.maxNotes; the arranged renderer bakes timed tracks (cycle,
+ * rate) into plain notes and may hold more than a stored score allows.
+ */
+export function withNoteCap<T>(cap: number, fn: () => T): T {
+  const previous = noteCap;
+  noteCap = Math.max(previous, cap);
+  try {
+    return fn();
+  } finally {
+    noteCap = previous;
+  }
+}
+
 function normalizeNotes(inputs: readonly unknown[]): Note[] {
-  if (!Array.isArray(inputs) || inputs.length > SCORE_LIMITS.maxNotes) {
+  if (!Array.isArray(inputs) || inputs.length > noteCap) {
     throw new ScoreValidationError(
-      `score cannot contain more than ${SCORE_LIMITS.maxNotes} notes`,
+      `score cannot contain more than ${noteCap} notes`,
       "score-limit",
     );
   }

package/core/sdk/eval-child.ts

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

package/core/sdk/print.ts

@@ -8,11 +8,25 @@
  */
 
 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 { rhythmVoicePitch, rowInSync } from "../rhythm.ts";
 import {
   BUILTIN_TABLE_PREFIX,
@@ -35,6 +49,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 +152,9 @@ const RESERVED = new Set([
   "every",
   "sampler",
   "wavetable",
+  "rig",
+  "granular",
+  "modal",
   "slices",
   "euclid",
   "euclidRot",
@@ -381,22 +399,55 @@ 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 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 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 +531,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 +570,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 +654,10 @@ export function printTrack(score: TrackScore, track: Track): string {
     "every",
     "sampler",
     "wavetable",
+    "stringed",
+    "rig",
+    "granular",
+    "modal",
     "euclid",
     "grid",
   ]
@@ -859,6 +942,76 @@ 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)]);
+  }
+  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}})`;
+}
+
 /** `wavetable("basic", { wt: 0.5 })`; pack tables keep their pin. */
 function printWavetable(settings: TrackWavetable, indent: string): string {
   const src = settings.table.src;
@@ -915,6 +1068,9 @@ 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 (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",
+  );
+}