@hraness/dawg 0.3.0 → 0.4.1

package/core/sdk/eval-child.ts

@@ -76,35 +76,47 @@ function diagnostic(error: unknown, project: string): Diagnostic {
   return out;
 }
 
-/** Adds `sha256` to sampler voices whose file exists and is within the size limit. */
+/**
+ * Adds `sha256` to sampler voices and project wavetable files that exist
+ * and are within the size limit.
+ */
 async function withSampleHashes(
   song: object,
   project: string,
 ): Promise<unknown> {
   const plain = JSON.parse(JSON.stringify(song)) as Record<string, unknown>;
   const tracks = Array.isArray(plain.tracks) ? plain.tracks : [];
+  const refs: Record<string, unknown>[] = [];
+  const isObject = (value: unknown): value is Record<string, unknown> =>
+    typeof value === "object" && value !== null;
   for (const track of tracks) {
-    if (typeof track !== "object" || track === null) continue;
-    const sampler = (track as Record<string, unknown>).sampler;
-    if (typeof sampler !== "object" || sampler === null) continue;
-    const voices = (sampler as Record<string, unknown>).voices;
-    if (typeof voices !== "object" || voices === null) continue;
-    for (const voice of Object.values(voices as Record<string, unknown>)) {
-      if (typeof voice !== "object" || voice === null) continue;
-      const ref = voice as Record<string, unknown>;
-      if (typeof ref.src !== "string" || typeof ref.sha256 === "string")
-        continue;
-      const path = resolve(project, ref.src);
-      if (relative(project, path).startsWith("..")) continue;
-      try {
-        const info = await stat(path);
-        if (!info.isFile() || info.size > MAX_SAMPLE_FILE_BYTES) continue;
-        ref.sha256 = createHash("sha256")
-          .update(await readFile(path))
-          .digest("hex");
-      } catch {
-        // Missing sample: left for `dawg check` to report.
-      }
+    if (!isObject(track)) continue;
+    const sampler = track.sampler;
+    if (isObject(sampler) && isObject(sampler.voices))
+      for (const voice of Object.values(sampler.voices))
+        if (isObject(voice)) refs.push(voice);
+    const wavetable = track.wavetable;
+    if (isObject(wavetable) && isObject(wavetable.table))
+      refs.push(wavetable.table);
+  }
+  for (const ref of refs) {
+    if (
+      typeof ref.src !== "string" ||
+      typeof ref.sha256 === "string" ||
+      ref.src.startsWith("pack:") ||
+      ref.src.startsWith("builtin:")
+    )
+      continue;
+    const path = resolve(project, ref.src);
+    if (relative(project, path).startsWith("..")) continue;
+    try {
+      const info = await stat(path);
+      if (!info.isFile() || info.size > MAX_SAMPLE_FILE_BYTES) continue;
+      ref.sha256 = createHash("sha256")
+        .update(await readFile(path))
+        .digest("hex");
+    } catch {
+      // Missing file: left for `dawg check` to report.
     }
   }
   return plain;

package/core/sdk/eval.ts

@@ -11,6 +11,7 @@
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { decodeLoopDocument } from "../loop.ts";
+import { refreshRhythm } from "../rhythm.ts";
 import { ScoreValidationError, TrackScore } from "../score.ts";
 
 export const EVAL_TIMEOUT_MS = 10_000;
@@ -158,7 +159,9 @@ export function parseChildOutput(
     return failure(started, [diagnostic]);
   }
   try {
-    const score = decodeLoopDocument(record.score);
+    // Rhythm rows are generators: their lanes are expanded here, on the
+    // host, so `song.ts` stores parameters and the score stores notes.
+    const score = refreshRhythm(decodeLoopDocument(record.score));
     return { ok: true, score, ms: elapsed(started) };
   } catch (error) {
     return failure(started, [

package/core/sdk/print.ts

@@ -8,10 +8,19 @@
  */
 
 import { DRUM_VOICES, isDrumInstrument } from "../drums.ts";
+import type { RhythmRow } from "../euclid.ts";
+import { FX_LANES, fxSpec, type FxName, type FxValues } from "../fx.ts";
 import { midiToPitch } from "../pitch.ts";
+import { rhythmVoicePitch, rowInSync } from "../rhythm.ts";
 import {
+  BUILTIN_TABLE_PREFIX,
+  WAVETABLE_PARAMS,
   isSamplerInstrument,
+  isWavetableInstrument,
   samplerVoiceSlots,
+  wavetableOf,
+  type TrackWavetable,
+  type WavetableParam,
   TrackScore,
   type AutomationPoint,
   type Note,
@@ -121,7 +130,12 @@ const RESERVED = new Set([
   "hits",
   "every",
   "sampler",
+  "wavetable",
   "slices",
+  "euclid",
+  "euclidRot",
+  "euclidLegato",
+  "grid",
 ]);
 
 /** Import identifiers for each track, unique in score order. */
@@ -178,7 +192,15 @@ export function printSong(
 
 /** `tracks/<slug>/track.ts` for one track of a score. */
 export function printTrack(score: TrackScore, track: Track): string {
-  const notes = score.notes.filter((note) => note.trackId === track.id);
+  // Rows whose lane still matches their expansion print as generators and
+  // own their notes; a hand-edited lane prints as plain notes instead.
+  const rows = (track.rhythm ?? []).filter((row) =>
+    rowInSync(score, track, row),
+  );
+  const owned = new Set(rows.map((row) => rhythmVoicePitch(track, row.voice)));
+  const notes = score.notes.filter(
+    (note) => note.trackId === track.id && !owned.has(note.pitch),
+  );
   const kit = isDrumInstrument(track.instrument);
   const voiceSlots =
     isSamplerInstrument(track.instrument) && track.sampler
@@ -200,6 +222,10 @@ export function printTrack(score: TrackScore, track: Track): string {
     return printNote(score, note, !kit && !slots);
   });
   if (track.sampler) used.add("sampler");
+  const wavetable = isWavetableInstrument(track.instrument)
+    ? wavetableOf(track)
+    : undefined;
+  if (wavetable) used.add("wavetable");
 
   const entries: string[] = [
     `id: ${str(track.id)}`,
@@ -207,7 +233,10 @@ export function printTrack(score: TrackScore, track: Track): string {
   ];
   if (track.sampler) {
     entries.push(`instrument: ${printSampler(track.sampler, INDENT)}`);
+  } else if (wavetable) {
+    entries.push(`instrument: ${printWavetable(wavetable, INDENT)}`);
   } else entries.push(`instrument: ${str(track.instrument)}`);
+  if (track.kit) entries.push(`kit: ${str(track.kit)}`);
   if (track.muted) entries.push("muted: true");
   if (track.solo) entries.push("solo: true");
   if (track.volume !== 1) entries.push(`volume: ${num(track.volume)}`);
@@ -218,6 +247,7 @@ export function printTrack(score: TrackScore, track: Track): string {
         [
           ["cutoff", num(track.filter.cutoff)],
           ["resonance", num(track.filter.resonance)],
+          ...optional(track.filter, ["type", "ftype"]),
         ],
         INDENT,
         "filter: ".length,
@@ -231,6 +261,7 @@ export function printTrack(score: TrackScore, track: Track): string {
           ["beats", num(track.delay.beats)],
           ["feedback", num(track.delay.feedback)],
           ["mix", num(track.delay.mix)],
+          ...optional(track.delay, ["time", "pingpong", "highcut"]),
         ],
         INDENT,
         "delay: ".length,
@@ -243,12 +274,56 @@ export function printTrack(score: TrackScore, track: Track): string {
         [
           ["mix", num(track.reverb.mix)],
           ["size", num(track.reverb.size)],
+          ...optional(track.reverb, ["fade", "lowpass", "dim", "predelay"]),
+          ...(track.reverb.ir
+            ? ([
+                [
+                  "ir",
+                  track.reverb.ir.src.startsWith(BUILTIN_TABLE_PREFIX)
+                    ? str(
+                        track.reverb.ir.src.slice(BUILTIN_TABLE_PREFIX.length),
+                      )
+                    : printSample(
+                        track.reverb.ir,
+                        INDENT + INDENT,
+                        "ir: ".length,
+                      ),
+                ],
+              ] as const)
+            : []),
         ],
         INDENT,
         "reverb: ".length,
         1,
       )}`,
     );
+  if (track.fx) {
+    const effects = Object.entries(track.fx) as [FxName, FxValues][];
+    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)},`;
+    });
+    entries.push(`fx: {\n${body.join("\n")}\n${INDENT}}`);
+  }
+  if (track.synth) {
+    const params = Object.entries(track.synth).map(
+      ([key, v]) =>
+        [
+          key,
+          Array.isArray(v)
+            ? `[${(v as readonly number[]).map(num).join(", ")}]`
+            : value(v as number | string | boolean),
+        ] as const,
+    );
+    entries.push(`synth: ${obj(params, INDENT, "synth: ".length, 1)}`);
+  }
   const lanes: [string, readonly AutomationPoint[] | undefined][] = [
     ["volume", track.volumeAutomation],
     ["pan", track.panAutomation],
@@ -256,23 +331,70 @@ export function printTrack(score: TrackScore, track: Track): string {
     ["resonance", track.resonanceAutomation],
     ["delayFeedback", track.delayFeedbackAutomation],
     ["delayMix", track.delayMixAutomation],
+    ["wt", track.wtAutomation],
   ];
   const automation = lanes.filter(([, points]) => points && points.length > 0);
-  if (automation.length > 0) {
+  const fxLanes = FX_LANES.filter(
+    ({ lane }) => (track.fxAutomation?.[lane]?.length ?? 0) > 0,
+  ).map(({ lane }) => [lane, track.fxAutomation![lane]!] as const);
+  const laneLine = (
+    name: string,
+    points: readonly AutomationPoint[],
+    indent: string,
+  ) => {
+    const items = points.map(
+      (point) =>
+        `[${num(point.tick / score.ticksPerBeat)}, ${num(point.value)}]`,
+    );
+    // Prettier forces a break on arrays of 2+ arrays that each hold 2+ items.
+    return `${indent}${name}: ${list(items, indent, `${name}: `.length, 1, items.length > 1)},`;
+  };
+  if (automation.length > 0 || fxLanes.length > 0) {
     const inner = INDENT + INDENT;
-    const body = automation.map(([lane, points]) => {
-      const items = points!.map(
-        (point) =>
-          `[${num(point.tick / score.ticksPerBeat)}, ${num(point.value)}]`,
+    const body = automation.map(([lane, points]) =>
+      laneLine(lane, points!, inner),
+    );
+    if (fxLanes.length > 0) {
+      const deeper = inner + INDENT;
+      const fxBody = fxLanes.map(([lane, points]) =>
+        laneLine(str(lane), points, deeper),
       );
-      // Prettier forces a break on arrays of 2+ arrays that each hold 2+ items.
-      return `${inner}${lane}: ${list(items, inner, `${lane}: `.length, 1, items.length > 1)},`;
-    });
+      body.push(`${inner}fx: {\n${fxBody.join("\n")}\n${inner}},`);
+    }
     entries.push(`automation: {\n${body.join("\n")}\n${INDENT}}`);
   }
-  entries.push(`notes: ${list(printed, INDENT, "notes: ".length, 1)}`);
+  if (rows.length > 0) {
+    const inner = INDENT + INDENT;
+    const items = rows.map((row) => {
+      const call = printRow(row, inner);
+      used.add(call.slice(0, call.indexOf("(")));
+      return call;
+    });
+    entries.push(
+      `rhythm: ${list(
+        items,
+        INDENT,
+        "rhythm: ".length,
+        1,
+        items.some((item) => item.includes("\n")),
+      )}`,
+    );
+  }
+  if (rows.length === 0 || printed.length > 0)
+    entries.push(`notes: ${list(printed, INDENT, "notes: ".length, 1)}`);
 
-  const names = ["track", "note", "seq", "hit", "hits", "every", "sampler"]
+  const names = [
+    "track",
+    "note",
+    "seq",
+    "hit",
+    "hits",
+    "every",
+    "sampler",
+    "wavetable",
+    "euclid",
+    "grid",
+  ]
     .filter((name) => used.has(name))
     .join(", ");
   const lines = [
@@ -304,23 +426,133 @@ function printHit(score: TrackScore, note: Note, voice: string): string {
   return `hit(${args.join(", ")})`;
 }
 
+/** `euclid("hat", 7, 16, 2, { velocity: 0.5 })` or `grid("sd", "....x...")`. */
+function printRow(row: RhythmRow, indent: string): string {
+  const args: string[] = [str(row.voice)];
+  const fields: [string, string][] = [];
+  if (row.grid !== undefined) args.push(str(row.grid));
+  else {
+    args.push(num(row.pulses ?? 4), num(row.steps ?? 16));
+    if (row.rotate) args.push(num(row.rotate));
+  }
+  const inner = indent + INDENT;
+  for (const key of [
+    "division",
+    "repeats",
+    "time",
+    "pace",
+    "ramp",
+    "velocity",
+    "accent",
+    "accents",
+    "gate",
+    "legato",
+    "probability",
+    "seed",
+    "swing",
+    "nudge",
+    "cycles",
+  ] as const) {
+    const value = row[key];
+    if (value === undefined) continue;
+    if (key === "cycles") {
+      const cycles = row.cycles!.map((cycle) =>
+        Object.keys(cycle).length === 0
+          ? "{}"
+          : obj(
+              Object.entries(cycle).map(
+                ([k, v]) => [k, num(v as number)] as const,
+              ),
+              inner + INDENT,
+              0,
+              1,
+            ),
+      );
+      const force =
+        cycles.length > 1 &&
+        row.cycles!.every((cycle) => Object.keys(cycle).length > 1);
+      fields.push([key, list(cycles, inner, "cycles: ".length, 1, force)]);
+    } else
+      fields.push([
+        key,
+        typeof value === "string"
+          ? str(value)
+          : typeof value === "boolean"
+            ? String(value)
+            : num(value as number),
+      ]);
+  }
+  // Options are euclid's fifth argument, so rotate 0 is spelled out before them.
+  if (row.grid === undefined && !row.rotate && fields.length > 0)
+    args.push("0");
+  const name = row.grid !== undefined ? "grid" : "euclid";
+  const head = `${name}(${args.join(", ")}`;
+  if (fields.length === 0) return `${head})`;
+  const inlineObject = `{ ${fields.map(([k, v]) => `${k}: ${v}`).join(", ")} }`;
+  const inline = `${head}, ${inlineObject})`;
+  if (!inline.includes("\n") && indent.length + inline.length + 1 <= WIDTH)
+    return inline;
+  const body = fields.map(([k, v]) => `${inner}${k}: ${v},`).join("\n");
+  return `${head}, {\n${body}\n${indent}})`;
+}
+
 function printSampler(sampler: Sampler, indent: string): string {
   const inner = indent + INDENT;
-  const voices = Object.keys(sampler.voices)
-    .sort()
-    .map((name) => {
-      const key = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : str(name);
-      return `${inner}${key}: ${printSample(sampler.voices[name]!, inner, `${key}: `.length)},`;
-    });
-  const body = `{\n${voices.join("\n")}\n${indent}}`;
-  if (sampler.mode === "oneshot") return `sampler(${body})`;
-  // Prettier breaks every argument out when an earlier one contains a break.
-  const shifted = `{\n${voices.map((line) => INDENT + line).join("\n")}\n${inner}}`;
+  const voices = (at: string) =>
+    Object.keys(sampler.voices)
+      .sort()
+      .map((name) => {
+        const key = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : str(name);
+        return `${at}${key}: ${printSample(sampler.voices[name]!, at, `${key}: `.length)},`;
+      })
+      .join("\n");
+  if (sampler.mode === "oneshot")
+    return `sampler({\n${voices(inner)}\n${indent}})`;
+  // Prettier breaks every argument out when an earlier one contains a break,
+  // so the voices sit one level deeper (multi-line voices included).
+  const shifted = `{\n${voices(inner + INDENT)}\n${inner}}`;
   return `sampler(\n${inner}${shifted},\n${inner}{ mode: ${str(sampler.mode)} },\n${indent})`;
 }
 
+/** `wavetable("basic", { wt: 0.5 })`; pack tables keep their pin. */
+function printWavetable(settings: TrackWavetable, indent: string): string {
+  const src = settings.table.src;
+  const name = src.startsWith(BUILTIN_TABLE_PREFIX)
+    ? str(src.slice(BUILTIN_TABLE_PREFIX.length))
+    : printSample(settings.table, indent, "wavetable(".length);
+  const params: [string, string][] = [];
+  for (const key of Object.keys(WAVETABLE_PARAMS) as WavetableParam[])
+    if (settings[key] !== undefined) params.push([key, num(settings[key])]);
+  if (settings.warpmode) params.push(["warpmode", str(settings.warpmode)]);
+  if (params.length === 0) return `wavetable(${name})`;
+  const inline = `wavetable(${name}, { ${params.map(([k, v]) => `${k}: ${v}`).join(", ")} })`;
+  if (
+    !inline.includes("\n") &&
+    indent.length + "instrument: ".length + inline.length + 1 <= WIDTH
+  )
+    return inline;
+  const inner = indent + INDENT;
+  if (
+    !name.includes("\n") &&
+    indent.length + "instrument: wavetable(".length + name.length + 4 <= WIDTH
+  )
+    return `wavetable(${name}, {\n${params.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}})`;
+  // Prettier breaks every argument out when the first one breaks.
+  const deeper = inner + INDENT;
+  const table = src.startsWith(BUILTIN_TABLE_PREFIX)
+    ? name
+    : printSample(settings.table, inner, 0);
+  return `wavetable(\n${inner}${table},\n${inner}{\n${params.map(([k, v]) => `${deeper}${k}: ${v},`).join("\n")}\n${inner}},\n${indent})`;
+}
+
 function printSample(ref: SampleRef, indent: string, prefix: number): string {
   const entries: [string, string][] = [["src", str(ref.src)]];
+  // Pack sounds keep their pin in the file; local files are hashed on eval.
+  if (ref.src.startsWith("pack:")) {
+    if (ref.sha256 !== undefined) entries.push(["sha256", str(ref.sha256)]);
+    if (ref.url !== undefined) entries.push(["url", str(ref.url)]);
+    if (ref.license !== undefined) entries.push(["license", str(ref.license)]);
+  }
   if (ref.root !== undefined)
     entries.push(["root", str(midiToPitch(ref.root))]);
   if (ref.begin !== undefined) entries.push(["begin", num(ref.begin)]);
@@ -329,6 +561,15 @@ function printSample(ref: SampleRef, indent: string, prefix: number): string {
   if (ref.speed !== undefined) entries.push(["speed", num(ref.speed)]);
   if (ref.loop !== undefined) entries.push(["loop", String(ref.loop)]);
   if (ref.choke !== undefined) entries.push(["choke", str(ref.choke)]);
+  if (ref.loopBegin !== undefined)
+    entries.push(["loopBegin", num(ref.loopBegin)]);
+  if (ref.loopEnd !== undefined) entries.push(["loopEnd", num(ref.loopEnd)]);
+  if (ref.clip !== undefined) entries.push(["clip", num(ref.clip)]);
+  if (ref.unit !== undefined) entries.push(["unit", str(ref.unit)]);
+  if (ref.fit !== undefined) entries.push(["fit", String(ref.fit)]);
+  if (ref.accelerate !== undefined)
+    entries.push(["accelerate", num(ref.accelerate)]);
+  if (ref.squiz !== undefined) entries.push(["squiz", num(ref.squiz)]);
   if (entries.length === 1) return str(ref.src);
   return obj(entries, indent, prefix, 1);
 }
@@ -343,7 +584,24 @@ function obj(
   const inline = `{ ${entries.map(([k, v]) => `${k}: ${v}`).join(", ")} }`;
   if (indent.length + prefix + inline.length + trailing <= WIDTH) return inline;
   const inner = indent + INDENT;
-  return `{\n${entries.map(([k, v]) => `${inner}${k}: ${v},`).join("\n")}\n${indent}}`;
+  return `{\n${entries.map(([k, v]) => property(k, v, inner)).join("\n")}\n${indent}}`;
+}
+
+/**
+ * One expanded `key: value,` line. Like prettier, a string too long for the
+ * line moves under its key (a 64-hex sha256 pin in a nested object does).
+ */
+function property(key: string, value: string, indent: string): string {
+  const line = `${indent}${key}: ${value},`;
+  // Prettier keeps a short key (under tabWidth + 3 = 5 characters) inline.
+  if (
+    line.length <= WIDTH ||
+    key.length < 5 ||
+    !value.startsWith('"') ||
+    value.includes("\n")
+  )
+    return line;
+  return `${indent}${key}:\n${indent}${INDENT}${value},`;
 }
 
 /** Array literal: inline when the line fits (and no forced break), else one item per line. */
@@ -366,6 +624,30 @@ function list(
   return `[\n${items.map((item) => `${inner}${item},`).join("\n")}\n${indent}]`;
 }
 
+/** Effect parameter literal. */
+function value(v: number | string | boolean): string {
+  return typeof v === "number"
+    ? num(v)
+    : typeof v === "string"
+      ? str(v)
+      : `${v}`;
+}
+
+/** `[key, literal]` for each optional effect field that is set. */
+function optional(
+  record: object,
+  keys: readonly string[],
+): (readonly [string, string])[] {
+  const out: (readonly [string, string])[] = [];
+  for (const key of keys) {
+    const v = (record as Record<string, number | string | boolean | undefined>)[
+      key
+    ];
+    if (v !== undefined) out.push([key, value(v)]);
+  }
+  return out;
+}
+
 /** Number the way prettier normalizes literals. */
 export function num(value: number): string {
   if (!Number.isFinite(value)) throw new RangeError(`cannot print ${value}`);

package/core/sdk/sync-chords.ts

@@ -0,0 +1,54 @@
+/**
+ * The SDK is one vendored file with no imports, so `core/sdk/v1.ts` carries
+ * a copy of the chord engine (`core/chords.ts`) between two marker lines.
+ * This keeps the copy exact: `bun core/sdk/sync-chords.ts` rewrites it and
+ * `sync-chords.test.ts` fails when it is stale.
+ *
+ * The copy is the module body from its first section rule up to
+ * `CHORD_PROCESS` (agent prose the SDK does not need), with `export`
+ * dropped so the engine stays private to the SDK.
+ */
+
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { format } from "prettier";
+
+export const BEGIN_MARKER =
+  "// BEGIN chord engine: generated from core/chords.ts by core/sdk/sync-chords.ts";
+export const END_MARKER = "// END chord engine";
+
+const ROOT = join(import.meta.dir, "..", "..");
+export const CHORDS_PATH = join(ROOT, "core", "chords.ts");
+export const SDK_PATH = join(ROOT, "core", "sdk", "v1.ts");
+
+/** The engine block (markers included) for a `core/chords.ts` source. */
+export function chordBlock(source: string): string {
+  const start = source.indexOf("// ----");
+  const end = source.indexOf("/** How dawg builds chords");
+  if (start < 0 || end < 0) throw new Error("core/chords.ts layout changed");
+  const body = source
+    .slice(start, end)
+    .replace(/^export /gm, "")
+    .trimEnd();
+  return `${BEGIN_MARKER}\n${body}\n${END_MARKER}`;
+}
+
+/** `sdk` with its engine block replaced, formatted like the repo. */
+export async function syncedSdk(sdk: string, chords: 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 chord engine markers");
+  const next =
+    sdk.slice(0, from) + chordBlock(chords) + sdk.slice(to + END_MARKER.length);
+  return format(next, { parser: "typescript", filepath: SDK_PATH });
+}
+
+if (import.meta.main) {
+  const [sdk, chords] = await Promise.all([
+    readFile(SDK_PATH, "utf8"),
+    readFile(CHORDS_PATH, "utf8"),
+  ]);
+  const next = await syncedSdk(sdk, chords);
+  if (next !== sdk) await writeFile(SDK_PATH, next);
+  console.log(next === sdk ? "v1.ts chord engine up to date" : "v1.ts updated");
+}