@hraness/dawg 0.4.1 → 0.6.0

package/src/project/check.ts

@@ -8,6 +8,8 @@ import {
   formatDiagnostic,
   type Diagnostic,
 } from "../../core/sdk/eval.ts";
+import { legacyResonatorWarnings } from "../../core/resonators.ts";
+import { plainSineWarnings } from "../audio/instrument-check.ts";
 import { isProject } from "./init.ts";
 import { typecheckProject } from "./typecheck.ts";
 
@@ -23,6 +25,8 @@ export type CheckReport = Readonly<{
   evalMs: number;
   tracks: number;
   notes: number;
+  /** Advice that does not fail the check (0.6: legacy instrument words). */
+  warnings: readonly string[];
 }>;
 
 /** Runs both checks on `project`; never throws for project problems. */
@@ -45,6 +49,14 @@ export async function checkProject(
     evalMs: evaluated.ms,
     tracks: evaluated.ok ? evaluated.score.tracks.length : 0,
     notes: evaluated.ok ? evaluated.score.notes.length : 0,
+    warnings: Object.freeze(
+      evaluated.ok
+        ? [
+            ...legacyResonatorWarnings(evaluated.score.tracks),
+            ...plainSineWarnings(evaluated.score.tracks),
+          ]
+        : [],
+    ),
   });
 }
 
@@ -65,6 +77,7 @@ export async function runCheckCommand(
   const report = await checkProject(project, deps);
   for (const diagnostic of report.diagnostics)
     stderr.write(`${formatDiagnostic(diagnostic)}\n`);
+  for (const warning of report.warnings) stderr.write(`warning: ${warning}\n`);
   if (report.ok) {
     stdout.write(
       `ok · ${report.tracks} track${report.tracks === 1 ? "" : "s"}, ${report.notes} note${

package/src/render.ts

@@ -1,5 +1,5 @@
 /**
- * `dawg render <out.wav>`: renders a session, the project files (`song.ts`,
+ * `dawg render <out.wav>` (or `<out.mid>`): renders a session, the project files (`song.ts`,
  * in a project with no `--session`), or a `track.loop/v1` file to
  * a stereo 16-bit PCM WAV through the same deterministic renderer playback
  * uses, so two renders of one score are byte-identical. It reads the session
@@ -8,9 +8,33 @@
 import { createHash } from "node:crypto";
 import { readFile, rename, writeFile } from "node:fs/promises";
 import { resolve } from "node:path";
-import { scoreFromJSON, type TrackScore } from "../core/score.ts";
+import {
+  scoreFromJSON,
+  ScoreValidationError,
+  withNoteCap,
+  type TrackScore,
+} from "../core/score.ts";
 import { decodeLoop } from "../core/loop.ts";
-import { renderScoreWav } from "./audio/wav.ts";
+import { scoreToMidi } from "../core/midi.ts";
+import { RENDER_CHANNELS, encodeWav, withWavCues } from "./audio/wav.ts";
+import { exportSampleRate, measureRendered } from "./audio/measure.ts";
+import {
+  applyMasterCommand,
+  loudnessLine,
+  measurementLine,
+  parseMasterCommand,
+} from "./commands/master.ts";
+import {
+  BAKED_NOTE_CAP,
+  bakeTrackTime,
+  findSection,
+  sectionScore,
+} from "../core/sections.ts";
+import {
+  exportScore,
+  renderArrangedPcm,
+  sectionCues,
+} from "./audio/arrange.ts";
 import { SampleLibrary, hasSamplerTracks } from "./audio/samples.ts";
 import {
   PackStore,
@@ -29,7 +53,7 @@ import {
 } from "./session/store.ts";
 
 export const RENDER_USAGE =
-  "usage: dawg render <out.wav> [--session <name|id>] [--import <file.track.json>]";
+  "usage: dawg render <out.wav> [--session <name|id>] [--import <file.track.json>] [--section <name>] [--normalize <lufs|streaming|club|loud|…>] [--measure] [--rate <hz>] · <out.mid> writes MIDI";
 
 const MAX_LOOP_FILE_BYTES = 512 * 1024;
 
@@ -50,7 +74,14 @@ export async function runRenderCommand(
   const positional: string[] = [];
   for (let index = 0; index < rest.length; index += 1) {
     const arg = rest[index]!;
-    if (arg === "--session" || arg === "--import") {
+    if (arg === "--measure") options.set(arg, "");
+    else if (
+      arg === "--session" ||
+      arg === "--import" ||
+      arg === "--normalize" ||
+      arg === "--rate" ||
+      arg === "--section"
+    ) {
       const value = rest[index + 1];
       if (value === undefined || value.startsWith("--")) {
         stderr.write(`${arg} needs a value · ${RENDER_USAGE}\n`);
@@ -64,7 +95,7 @@ export async function runRenderCommand(
     } else positional.push(arg);
   }
   const target = positional[0];
-  if (positional.length !== 1 || !target || !/\.wav$/i.test(target)) {
+  if (positional.length !== 1 || !target || !/\.(wav|midi?)$/i.test(target)) {
     stderr.write(`${RENDER_USAGE}\n`);
     return 2;
   }
@@ -77,13 +108,104 @@ export async function runRenderCommand(
     );
     return 1;
   }
+  const only = options.get("--section");
+  if (only !== undefined) {
+    const section = findSection(score, only);
+    if (!section) {
+      const names = score.sections.map((entry) => entry.name).join(", ");
+      stderr.write(
+        `render failed · no section "${only}"${names ? ` · sections: ${names}` : ""}\n`,
+      );
+      return 1;
+    }
+    // One section as it plays when looped: its mutes and variations, no form.
+    score = withNoteCap(BAKED_NOTE_CAP, () =>
+      sectionScore(bakeTrackTime(score), section),
+    );
+  }
+  if (/\.midi?$/i.test(target)) {
+    // MIDI carries notes, not audio: the master and loudness flags do not apply.
+    const audioOnly = ["--normalize", "--measure", "--rate"].find((flag) =>
+      options.has(flag),
+    );
+    if (audioOnly) {
+      stderr.write(`render failed · ${audioOnly} applies to .wav only\n`);
+      return 2;
+    }
+    const midi = scoreToMidi(exportScore(score));
+    const midiPath = resolve(workspace, target);
+    const midiTemporary = `${midiPath}.${process.pid}.tmp`;
+    await writeFile(midiTemporary, midi);
+    await rename(midiTemporary, midiPath);
+    const midiSha = createHash("sha256").update(midi).digest("hex");
+    stdout.write(
+      `rendered · ${target} · ${midi.byteLength} bytes · ${midiSha}\n`,
+    );
+    return 0;
+  }
+  // `--normalize` is the song master's loudness target for this export only:
+  // a named target also brings the limiter in at that target's ceiling.
+  const normalize = options.get("--normalize");
+  if (normalize !== undefined) {
+    const command = parseMasterCommand(`master target ${normalize}`);
+    const result = command && applyMasterCommand(score, command);
+    if (!result?.ok) {
+      stderr.write(
+        `render failed · --normalize takes LUFS (-40 to -3) or a target name · ${RENDER_USAGE}\n`,
+      );
+      return 2;
+    }
+    score = result.next ?? score;
+    const flipped =
+      command?.type === "master-target" ? command.flipped : undefined;
+    if (flipped !== undefined)
+      stderr.write(
+        `render · --normalize ${normalize} read as ${-flipped} LUFS\n`,
+      );
+  }
   let samples;
   if (hasSamplerTracks(score)) {
     samples = await new SampleLibrary({ projectRoot: workspace }).load(score);
     for (const problem of samples.problems)
       stderr.write(`sample ${problem.level} · ${problem.message}\n`);
+    // A voice that cannot load (a missing file, a pin that no longer
+    // matches) would render as silence: fail rather than write a song with
+    // a part missing.
+    const failed = samples.problems.filter((p) => p.level === "error").length;
+    if (failed > 0) {
+      stderr.write(
+        `render failed · ${failed} sample ${failed === 1 ? "voice" : "voices"} could not load · fix or re-pick ${failed === 1 ? "it" : "them"} and render again\n`,
+      );
+      return 1;
+    }
+  }
+  // A song with a master is a deliverable: 48 kHz unless --rate says
+  // otherwise; a plain song keeps the engine's rate, as dawg 0.4 wrote it.
+  const rateArg = options.get("--rate");
+  const sampleRate =
+    rateArg === undefined ? exportSampleRate(score) : Number(rateArg);
+  if (
+    !Number.isInteger(sampleRate) ||
+    sampleRate < 8_000 ||
+    sampleRate > 48_000
+  ) {
+    stderr.write(
+      `render failed · --rate takes 8000 to 48000 Hz · ${RENDER_USAGE}\n`,
+    );
+    return 2;
   }
-  let wav = renderScoreWav(score, { samples });
+  let audio;
+  try {
+    audio = renderArrangedPcm(score, { samples, sampleRate });
+  } catch (error) {
+    if (!(error instanceof ScoreValidationError)) throw error;
+    stderr.write(`render failed · ${error.message}\n`);
+    return 1;
+  }
+  let wav = encodeWav(audio.pcm, audio.sampleRate, RENDER_CHANNELS);
+  // Section starts as cue points (a --section render is one section).
+  if (only === undefined)
+    wav = withWavCues(wav, sectionCues(score, audio.sampleRate));
   // Pack sounds: name the packs (and CC-BY attributions) in the WAV's INFO
   // comment and on stdout; CREDITS.md in a project keeps the attributions.
   const refs = score.tracks.flatMap((track) =>
@@ -102,8 +224,17 @@ export async function runRenderCommand(
   await writeFile(temporary, wav);
   await rename(temporary, path);
   const sha = createHash("sha256").update(wav).digest("hex");
-  stdout.write(`rendered · ${target} · ${wav.byteLength} bytes · ${sha}\n`);
+  const seconds = audio.frames / audio.sampleRate;
+  stdout.write(
+    `rendered · ${target} · ${seconds.toFixed(2)} s · ${wav.byteLength} bytes · ${sha}\n`,
+  );
   if (credits) stdout.write(`credits · ${credits}\n`);
+  if (options.has("--measure"))
+    stdout.write(
+      `loudness · ${measurementLine(measureRendered(audio, false).mix, audio.master)}\n`,
+    );
+  else if (audio.master)
+    stdout.write(`loudness · ${loudnessLine(audio.master)}\n`);
   return 0;
 }
 

package/src/session/daemon.ts

@@ -6,7 +6,7 @@ import {
   type ScoreOperation,
   type TrackScore,
 } from "../../core/score.ts";
-import { TransportClock } from "../audio/clock.ts";
+import { TransportClock, transportMapFor } from "../audio/clock.ts";
 import { AudioEngine } from "../audio/engine.ts";
 import { acquireSessionLock } from "./lock.ts";
 import {
@@ -127,7 +127,7 @@ export class DawgDaemon {
     }
     try {
       await this.reload();
-      this.clock.setTempo(this.score.tempoBpm);
+      this.clock.follow(this.score);
       // We hold the daemon lock, so any socket file left here belongs to a
       // crashed daemon and is safe to reclaim.
       await rm(this.socketPath, { force: true });
@@ -340,7 +340,7 @@ export class DawgDaemon {
         );
         if (result.record.revision !== this.record.revision) {
           // A file-fallback window wrote the score too; adopt everything.
-          const previousTempo = this.score.tempoBpm;
+          const previousTempo = this.timeKey();
           await this.reload();
           this.broadcast({
             v: 1,
@@ -454,7 +454,7 @@ export class DawgDaemon {
             rebasedFrom: message.base,
           }
         : message.payload;
-    const previousTempo = this.score.tempoBpm;
+    const previousTempo = this.timeKey();
     try {
       this.record = await appendSessionEvent(
         this.paths,
@@ -528,9 +528,14 @@ export class DawgDaemon {
     }
   }
 
-  private afterScoreChange(previousTempo: number): void {
-    if (this.score.tempoBpm !== previousTempo) {
-      this.clock.setTempo(this.score.tempoBpm);
+  /** Tempo and tempo map, compared to tell when the transport must follow. */
+  private timeKey(): string {
+    return JSON.stringify([this.score.tempoBpm, this.score.time ?? null]);
+  }
+
+  private afterScoreChange(previousTempo: string): void {
+    if (this.timeKey() !== previousTempo) {
+      this.clock.follow(this.score);
       this.broadcastTransport();
     }
     // Gapless: a streaming engine swaps the loop at the current beat
@@ -560,6 +565,7 @@ export class DawgDaemon {
       this.audio.seek(this.clock.beatAt());
     } else if (action === "tempo" && bpm !== undefined) {
       this.clock.setTempo(bpm);
+      this.clock.setTimeMap(transportMapFor(this.score));
     }
     this.broadcastTransport();
   }
@@ -641,7 +647,7 @@ export class DawgDaemon {
         }
         return;
       }
-      const previousTempo = this.score.tempoBpm;
+      const previousTempo = this.timeKey();
       await this.reload();
       this.broadcast({
         v: 1,
@@ -695,6 +701,10 @@ const OPERATION_TYPES = new Set([
   "moveTrack",
   "setKey",
   "setMeter",
+  "setTime",
+  "setTuning",
+  "setMaster",
+  "setSections",
 ]);
 
 /** Shape gate before the reducer, which validates every field it reads. */

package/src/session/naming.ts

@@ -107,7 +107,14 @@ export function musicalFingerprint(score: TrackScore): Fingerprint {
         : `${role}(${instrument},${register},${density})`,
     );
   }
-  const key = score.key ? score.key.toLowerCase() : estimateKey(histogram);
+  // A tuned song is named by its tuning (`pelog`), not a guessed 12-TET key.
+  const tuned = score.tuning
+    ? (score.tuning.name ??
+      (score.tuning.edo ? `${score.tuning.edo}-edo` : "tuned"))
+    : undefined;
+  const key = score.key
+    ? score.key.toLowerCase()
+    : (tuned?.toLowerCase() ?? estimateKey(histogram));
   const line = [
     `${bpm} bpm`,
     key ?? "no key",

package/src/session/rebase.ts

@@ -16,6 +16,7 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import { rewindComposition, type Rewind } from "./delta.ts";
+import { deepEqual } from "../../core/diff.ts";
 
 /** How far behind a base may be and still be rebased. */
 export const MAX_REBASE_DISTANCE = 64;
@@ -114,6 +115,26 @@ export function rebaseOperations(
         if (base.beatsPerBar !== current.beatsPerBar)
           return { ok: false, reason: "meter changed" };
         break;
+      case "setTime":
+        if (!same(base.time, current.time))
+          return { ok: false, reason: "tempo map changed" };
+        break;
+      case "setTuning":
+        if (!same(base.tuning ?? null, current.tuning ?? null))
+          return { ok: false, reason: "tuning changed" };
+        break;
+      case "setMaster":
+        if (!deepEqual(base.master, current.master))
+          return { ok: false, reason: "master changed" };
+        break;
+      case "setSections":
+        if (
+          JSON.stringify(base.sections) !== JSON.stringify(current.sections) ||
+          JSON.stringify(base.form) !== JSON.stringify(current.form) ||
+          base.loopSection !== current.loopSection
+        )
+          return { ok: false, reason: "sections changed" };
+        break;
       case "removeTrack": {
         if (added.tracks.has(operation.trackId)) break;
         if (