@hraness/dawg 0.2.0 → 0.3.0

package/src/project/typecheck.ts

@@ -0,0 +1,149 @@
+/**
+ * Typechecks a project with the TypeScript compiler dawg depends on.
+ *
+ * TypeScript 7 is a native binary with no JavaScript watch API, so each check
+ * is one `tsc --noEmit --incremental` run whose build info lives in
+ * `.dawg/tsbuild/`; a warm check on a small project takes tens of
+ * milliseconds. Diagnostics come back as `file:line:col message`.
+ */
+
+import { realpathSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { Diagnostic } from "../../core/sdk/eval.ts";
+import type { CommandRunner } from "../auth/runner.ts";
+import { systemRunner } from "../auth/runner.ts";
+
+export const TYPECHECK_TIMEOUT_MS = 60_000;
+const MAX_DIAGNOSTICS = 200;
+
+export type TypecheckResult = Readonly<{
+  ok: boolean;
+  diagnostics: readonly Diagnostic[];
+  ms: number;
+}>;
+
+export type TypecheckOptions = Readonly<{
+  runner?: CommandRunner;
+  /** Path of the `tsc` executable; resolved from the dependency by default. */
+  tsc?: string;
+}>;
+
+/** Native `tsc` from `@typescript/typescript-<platform>-<arch>`, else `tsc` on PATH. */
+export function resolveTsc(
+  runner: CommandRunner = systemRunner,
+): string | undefined {
+  const name = `@typescript/typescript-${process.platform}-${process.arch}/package.json`;
+  try {
+    const url = import.meta.resolve(name);
+    return join(dirname(fileURLToPath(url)), "lib", "tsc");
+  } catch {
+    return runner.which("tsc");
+  }
+}
+
+/** Runs `tsc` on `<project>/tsconfig.json` and parses its diagnostics. */
+export async function typecheckProject(
+  project: string,
+  options: TypecheckOptions = {},
+): Promise<TypecheckResult> {
+  const started = performance.now();
+  const runner = options.runner ?? systemRunner;
+  const tsc = options.tsc ?? resolveTsc(runner);
+  if (!tsc)
+    return {
+      ok: false,
+      diagnostics: [{ message: "typescript is not installed (no tsc found)" }],
+      ms: elapsed(started),
+    };
+  const stateDir = join(project, ".dawg", "tsbuild");
+  await mkdir(stateDir, { recursive: true });
+  const result = await runner.run(
+    tsc,
+    [
+      "--noEmit",
+      "--pretty",
+      "false",
+      "--incremental",
+      "--tsBuildInfoFile",
+      join(stateDir, "project.tsbuildinfo"),
+      "-p",
+      join(project, "tsconfig.json"),
+    ],
+    {
+      timeoutMs: TYPECHECK_TIMEOUT_MS,
+      maxOutputBytes: 1024 * 1024,
+      env: { NO_COLOR: "1" },
+    },
+  );
+  if (result.killed)
+    return {
+      ok: false,
+      diagnostics: [{ message: "typecheck timed out" }],
+      ms: elapsed(started),
+    };
+  const diagnostics = parseTscOutput(
+    `${result.stdout}\n${result.stderr}`,
+    project,
+  );
+  if (result.code !== 0 && diagnostics.length === 0)
+    diagnostics.push({
+      message: `tsc exited with code ${result.code}${
+        result.stderr.trim() ? `: ${result.stderr.trim().split("\n")[0]}` : ""
+      }`,
+    });
+  return {
+    ok: result.code === 0 && diagnostics.length === 0,
+    diagnostics,
+    ms: elapsed(started),
+  };
+}
+
+/**
+ * Parses `file(line,col): error TSnnnn: message` lines. tsc prints paths
+ * relative to its working directory; they come back project-relative.
+ */
+export function parseTscOutput(
+  output: string,
+  project: string,
+  cwd: string = process.cwd(),
+): Diagnostic[] {
+  const out: Diagnostic[] = [];
+  const roots = [project];
+  try {
+    roots.push(realpathSync(project));
+  } catch {
+    // An unreadable project keeps the literal path.
+  }
+  const relativize = (file: string): string => {
+    const absolute = isAbsolute(file) ? file : resolve(cwd, file);
+    for (const root of roots) {
+      const rel = relative(root, absolute);
+      if (rel && !rel.startsWith("..") && !isAbsolute(rel)) return rel;
+    }
+    return file;
+  };
+  for (const raw of output.split("\n")) {
+    const line = raw.trimEnd();
+    const match = line.match(/^(.*?)\((\d+),(\d+)\): error (TS\d+): (.*)$/);
+    if (match) {
+      const file = relativize(match[1]!);
+      out.push({
+        file,
+        line: Number(match[2]),
+        col: Number(match[3]),
+        message: `${match[5]} (${match[4]})`,
+      });
+    } else {
+      const bare = line.match(/^error (TS\d+): (.*)$/);
+      if (bare) out.push({ message: `${bare[2]} (${bare[1]})` });
+    }
+    if (out.length >= MAX_DIAGNOSTICS) break;
+  }
+  return out;
+}
+
+function elapsed(started: number): number {
+  return Math.round(performance.now() - started);
+}

package/src/render.ts

@@ -1,5 +1,6 @@
 /**
- * `dawg render <out.wav>`: renders a session (or a `track.loop/v1` file) to
+ * `dawg render <out.wav>`: 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
  * record from disk and never starts dawgd or plays audio.
@@ -10,6 +11,9 @@ import { resolve } from "node:path";
 import { scoreFromJSON, type TrackScore } from "../core/score.ts";
 import { decodeLoop } from "../core/loop.ts";
 import { renderScoreWav } from "./audio/wav.ts";
+import { SampleLibrary, hasSamplerTracks } from "./audio/samples.ts";
+import { evaluateProject, formatDiagnostic } from "../core/sdk/eval.ts";
+import { isProject } from "./project/init.ts";
 import { resolveSessionArg } from "./session/attach.ts";
 import {
   loadSession,
@@ -31,6 +35,10 @@ export async function runRenderCommand(
   stderr: Output,
 ): Promise<number> {
   const rest = argv.slice(1);
+  if (rest.includes("--help") || rest.includes("-h")) {
+    stdout.write(`${RENDER_USAGE}\n`);
+    return 0;
+  }
   const options = new Map<string, string>();
   const positional: string[] = [];
   for (let index = 0; index < rest.length; index += 1) {
@@ -38,13 +46,13 @@ export async function runRenderCommand(
     if (arg === "--session" || arg === "--import") {
       const value = rest[index + 1];
       if (value === undefined || value.startsWith("--")) {
-        stderr.write(`${arg} needs a value\n${RENDER_USAGE}\n`);
+        stderr.write(`${arg} needs a value · ${RENDER_USAGE}\n`);
         return 2;
       }
       options.set(arg, value);
       index += 1;
     } else if (arg.startsWith("--")) {
-      stderr.write(`unknown option ${arg}\n${RENDER_USAGE}\n`);
+      stderr.write(`unknown option · ${arg} · ${RENDER_USAGE}\n`);
       return 2;
     } else positional.push(arg);
   }
@@ -62,7 +70,13 @@ export async function runRenderCommand(
     );
     return 1;
   }
-  const wav = renderScoreWav(score);
+  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`);
+  }
+  const wav = renderScoreWav(score, { samples });
   const path = resolve(workspace, target);
   const temporary = `${path}.${process.pid}.tmp`;
   await writeFile(temporary, wav);
@@ -84,16 +98,24 @@ async function loadScore(
     return decodeLoop(contents.toString("utf8"));
   }
   const query = options.get("--session");
+  if (query === undefined && (await isProject(workspace))) {
+    const evaluated = await evaluateProject(workspace);
+    if (!evaluated.ok)
+      throw new Error(
+        `${evaluated.diagnostics.map(formatDiagnostic).join("; ").slice(0, 400)} · fix song.ts and retry (dawg check)`,
+      );
+    return evaluated.score;
+  }
   const sessionId =
     query === undefined
       ? await readCurrentSessionId(workspace)
       : await resolveSessionArg(workspace, query);
   if (sessionId === undefined)
-    throw new Error("no session here; run `dawg` first or pass --import");
+    throw new Error("no session here · run dawg first or pass --import");
   const record = await loadSession<unknown>(
     sessionPaths(workspace, sessionId),
   ).catch(() => {
-    throw new Error(`no session named "${query ?? sessionId}"`);
+    throw new Error(`no session named "${query ?? sessionId}" · dawg sessions`);
   });
   return scoreFromJSON(record.composition);
 }

package/src/session/attach.ts

@@ -38,8 +38,8 @@ export class SessionLookupError extends Error {
 }
 
 /**
- * Maps `--session <name|id>` to a session id. Unknown values pass through
- * unchanged when they are valid ids (a new session with that id is created);
+ * Maps `--session <name|id>` to the id of an existing session. An unknown
+ * value throws (a typo must not create a new session; `--new` does that);
  * an ambiguous name throws with the candidate list.
  */
 export async function resolveSessionArg(
@@ -54,8 +54,7 @@ export async function resolveSessionArg(
     throw new SessionLookupError(
       ambiguousSessionMessage(query, result.candidates),
     );
-  if (/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(query)) return query;
-  throw new SessionLookupError(`no session named "${query}"`);
+  throw new SessionLookupError(`no session named "${query}" · dawg sessions`);
 }
 
 export type TrackAttachment = {

package/src/session/daemon.ts

@@ -95,6 +95,21 @@ export class DawgDaemon {
     this.graceMs = options.graceMs ?? DEFAULT_GRACE_MS;
     this.audio = new AudioEngine({
       lockPath: `${this.paths.record}.audio.lock`,
+      projectRoot: options.workspace,
+      onStatus: (status) => {
+        void this.log(`audio: ${status.message}`);
+        // A player that keeps dying must not leave a silent "playing" transport.
+        if (status.state === "stopped" && this.clock.playing) {
+          this.clock.pause();
+          this.broadcastTransport();
+        }
+        this.broadcast({
+          v: 1,
+          type: "error",
+          code: "audio",
+          message: status.message,
+        });
+      },
     });
   }
 
@@ -158,7 +173,7 @@ export class DawgDaemon {
   private async shutdown(reason: string): Promise<void> {
     if (this.graceTimer) clearTimeout(this.graceTimer);
     if (this.diskTimer) clearInterval(this.diskTimer);
-    await this.audio.stopAsync();
+    await this.audio.dispose();
     for (const client of this.clients) client.socket.destroy();
     this.clients.clear();
     await this.queue.catch(() => undefined);
@@ -427,18 +442,16 @@ export class DawgDaemon {
         message: error instanceof Error ? error.message : String(error),
       };
     }
-    // Every event records the score it replaced (`before`) so undo and later
-    // rebases can recover it; after a rebase that is the score replayed on.
+    // The store records how to rewind every event, so undo and later rebases
+    // can recover the score it replaced; a rebased event also notes its base.
     const payload =
+      rebased &&
       typeof message.payload === "object" &&
       message.payload !== null &&
       !Array.isArray(message.payload)
         ? {
             ...(message.payload as Record<string, unknown>),
-            ...(rebased || !("before" in message.payload)
-              ? { before: this.record.composition }
-              : {}),
-            ...(rebased ? { rebasedFrom: message.base } : {}),
+            rebasedFrom: message.base,
           }
         : message.payload;
     const previousTempo = this.score.tempoBpm;
@@ -506,7 +519,7 @@ export class DawgDaemon {
       this.record.revision - revision > MAX_REBASE_DISTANCE
     )
       return undefined;
-    const composition = compositionAt(this.record.events, revision);
+    const composition = compositionAt(this.record, revision);
     if (composition === undefined) return undefined;
     try {
       return scoreFromJSON(composition);
@@ -678,6 +691,10 @@ const OPERATION_TYPES = new Set([
   "updateTrack",
   "setAutomation",
   "clearTrack",
+  "removeTrack",
+  "moveTrack",
+  "setKey",
+  "setMeter",
 ]);
 
 /** Shape gate before the reducer, which validates every field it reads. */

package/src/session/delta.ts

@@ -0,0 +1,249 @@
+/**
+ * Reverse deltas for session history.
+ *
+ * Every event stores a `rewind`: how to turn the composition it produced back
+ * into the one it replaced, instead of the whole previous composition.
+ * Objects diff per key, arrays of `{id}` objects diff per id and position,
+ * and anything else is replaced wholesale. Applying the rewinds of the newest
+ * events in reverse order recovers any older composition, which is what undo
+ * and the daemon's rebase need. A single-note edit costs about 150 bytes
+ * instead of a full copy of the score, so the record stays small and the
+ * session never becomes un-editable.
+ */
+export type Rewind =
+  /** The value in the earlier composition (also used for a key that was removed). */
+  | { set: unknown }
+  /** The key did not exist in the earlier composition. */
+  | { del: true }
+  /** Per-key rewinds for a plain object. */
+  | { obj: Record<string, Rewind> }
+  /**
+   * An array of `{id}` objects: remove the items at `drop` (indices into the
+   * later array), then place `put` values at their earlier indices.
+   */
+  | { arr: { drop: number[]; put: [number, unknown][] } };
+
+const MAX_DEPTH = 16;
+
+/** Applying this rewind changes nothing. */
+export const IDENTITY_REWIND: Rewind = Object.freeze({ obj: {} }) as Rewind;
+
+export function isIdentityRewind(value: Rewind | undefined): boolean {
+  return (
+    value !== undefined && "obj" in value && Object.keys(value.obj).length === 0
+  );
+}
+
+/** The rewind that turns `after` back into `before`; identity when equal. */
+export function diffRewind(before: unknown, after: unknown): Rewind {
+  return diff(before, after, 0) ?? IDENTITY_REWIND;
+}
+
+function diff(
+  before: unknown,
+  after: unknown,
+  depth: number,
+): Rewind | undefined {
+  if (depth >= MAX_DEPTH)
+    return deepEqual(before, after) ? undefined : { set: before };
+  if (isPlainObject(before) && isPlainObject(after)) {
+    const obj: Record<string, Rewind> = {};
+    for (const key of Object.keys(before)) {
+      if (!(key in after) || after[key] === undefined)
+        obj[key] = { set: before[key] };
+      else {
+        const child = diff(before[key], after[key], depth + 1);
+        if (child) obj[key] = child;
+      }
+    }
+    for (const key of Object.keys(after))
+      if (!(key in before) || before[key] === undefined)
+        obj[key] = { del: true };
+    return Object.keys(obj).length === 0 ? undefined : { obj };
+  }
+  if (isKeyedArray(before) && isKeyedArray(after)) {
+    const beforeIndex = new Map<string, number>();
+    before.forEach((item, index) => beforeIndex.set(item.id, index));
+    // Greedy common subsequence by id: an item is kept when it is unchanged
+    // and keeps its relative order. Edits touch few items, so this is near
+    // optimal and always correct; a full reorder degrades to a full copy.
+    const kept = new Set<number>();
+    const drop: number[] = [];
+    let last = -1;
+    after.forEach((item, index) => {
+      const at = beforeIndex.get(item.id);
+      if (at !== undefined && at > last && deepEqual(before[at], item)) {
+        kept.add(at);
+        last = at;
+      } else drop.push(index);
+    });
+    const put: [number, unknown][] = [];
+    before.forEach((item, index) => {
+      if (!kept.has(index)) put.push([index, item]);
+    });
+    return drop.length === 0 && put.length === 0
+      ? undefined
+      : { arr: { drop, put } };
+  }
+  return deepEqual(before, after) ? undefined : { set: before };
+}
+
+/** The earlier value: `rewind` applied to `after`. Throws on a shape mismatch. */
+export function applyRewind(after: unknown, rewind: Rewind): unknown {
+  if ("set" in rewind) return rewind.set;
+  if ("del" in rewind) return undefined;
+  if ("obj" in rewind) {
+    // The identity rewind applies to any value, not only objects.
+    if (isIdentityRewind(rewind)) return after;
+    if (!isPlainObject(after)) throw new Error("rewind expects an object");
+    const result: Record<string, unknown> = { ...after };
+    for (const [key, child] of Object.entries(rewind.obj)) {
+      if ("del" in child) delete result[key];
+      else result[key] = applyRewind(result[key], child);
+    }
+    return result;
+  }
+  if (!Array.isArray(after)) throw new Error("rewind expects an array");
+  const dropped = new Set(rewind.arr.drop);
+  const kept: unknown[] = [];
+  after.forEach((item, index) => {
+    if (!dropped.has(index)) kept.push(item);
+  });
+  const put = new Map(rewind.arr.put);
+  const length = kept.length + put.size;
+  const result: unknown[] = [];
+  let next = 0;
+  for (let index = 0; index < length; index += 1) {
+    if (put.has(index)) result.push(put.get(index));
+    else {
+      if (next >= kept.length) throw new Error("rewind indices are invalid");
+      result.push(kept[next]);
+      next += 1;
+    }
+  }
+  if (next !== kept.length) throw new Error("rewind indices are invalid");
+  return result;
+}
+
+/**
+ * The composition before `events[index]`, by rewinding `composition` (the
+ * one after the last event) through every later event. Undefined when any
+ * event in that range has no usable rewind.
+ */
+export function rewindComposition(
+  composition: unknown,
+  events: readonly { rewind?: Rewind | undefined }[],
+  index: number,
+): unknown {
+  if (!Number.isSafeInteger(index) || index < 0 || index >= events.length)
+    return undefined;
+  let value = composition;
+  try {
+    for (let at = events.length - 1; at >= index; at -= 1) {
+      const rewind = events[at]!.rewind;
+      if (rewind === undefined) return undefined;
+      value = applyRewind(value, rewind);
+    }
+  } catch {
+    return undefined;
+  }
+  return value;
+}
+
+/** Validates a stored rewind from `unknown`; `undefined` when absent. */
+export function parseRewind(value: unknown): Rewind | undefined {
+  if (value === undefined) return undefined;
+  return parse(value, 0);
+}
+
+function parse(value: unknown, depth: number): Rewind {
+  if (!isPlainObject(value) || depth > MAX_DEPTH)
+    throw new Error("session event rewind is invalid");
+  const keys = Object.keys(value);
+  if (keys.length !== 1) throw new Error("session event rewind is invalid");
+  if ("set" in value) {
+    if (value.set === undefined)
+      throw new Error("session event rewind is invalid");
+    return { set: value.set };
+  }
+  if ("del" in value) {
+    if (value.del !== true) throw new Error("session event rewind is invalid");
+    return { del: true };
+  }
+  if ("obj" in value) {
+    if (!isPlainObject(value.obj))
+      throw new Error("session event rewind is invalid");
+    const obj: Record<string, Rewind> = {};
+    for (const [key, child] of Object.entries(value.obj))
+      obj[key] = parse(child, depth + 1);
+    return { obj };
+  }
+  if ("arr" in value && isPlainObject(value.arr)) {
+    const { drop, put } = value.arr;
+    if (
+      !Array.isArray(drop) ||
+      !Array.isArray(put) ||
+      !drop.every((index) => Number.isSafeInteger(index) && index >= 0) ||
+      !put.every(
+        (entry) =>
+          Array.isArray(entry) &&
+          entry.length === 2 &&
+          Number.isSafeInteger(entry[0]) &&
+          entry[0] >= 0 &&
+          entry[1] !== undefined,
+      )
+    )
+      throw new Error("session event rewind is invalid");
+    return {
+      arr: {
+        drop: drop as number[],
+        put: put.map((entry) => [entry[0], entry[1]] as [number, unknown]),
+      },
+    };
+  }
+  throw new Error("session event rewind is invalid");
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isKeyedArray(value: unknown): value is { id: string }[] {
+  if (!Array.isArray(value)) return false;
+  const seen = new Set<string>();
+  for (const item of value) {
+    if (!isPlainObject(item) || typeof item.id !== "string") return false;
+    if (seen.has(item.id)) return false;
+    seen.add(item.id);
+  }
+  return true;
+}
+
+function deepEqual(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (
+    typeof a !== "object" ||
+    typeof b !== "object" ||
+    a === null ||
+    b === null
+  )
+    return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  if (Array.isArray(a)) {
+    const other = b as unknown[];
+    if (a.length !== other.length) return false;
+    for (let index = 0; index < a.length; index += 1)
+      if (!deepEqual(a[index], other[index])) return false;
+    return true;
+  }
+  const left = a as Record<string, unknown>;
+  const right = b as Record<string, unknown>;
+  const keys = Object.keys(left).filter((key) => left[key] !== undefined);
+  const otherKeys = Object.keys(right).filter(
+    (key) => right[key] !== undefined,
+  );
+  if (keys.length !== otherKeys.length) return false;
+  for (const key of keys)
+    if (!(key in right) || !deepEqual(left[key], right[key])) return false;
+  return true;
+}

package/src/session/naming.ts

@@ -13,6 +13,9 @@
 import { createHash } from "node:crypto";
 import type { TrackScore } from "../../core/score.ts";
 import { isDrumInstrument } from "../../core/drums.ts";
+import { estimateKey } from "../../core/key.ts";
+
+export { estimateKey };
 import type { ProviderSelection } from "../agent/provider.ts";
 import {
   DEFAULT_SESSION_NAME,
@@ -27,22 +30,6 @@ import {
 export const NAME_MAX_TOKENS = 12;
 export const NAME_TEMPERATURE = 0.3;
 const PROMPT_SNIPPET_CHARS = 60;
-const NOTE_NAMES = [
-  "c",
-  "c#",
-  "d",
-  "eb",
-  "e",
-  "f",
-  "f#",
-  "g",
-  "ab",
-  "a",
-  "bb",
-  "b",
-] as const;
-const MAJOR = [0, 2, 4, 5, 7, 9, 11];
-const MINOR = [0, 2, 3, 5, 7, 8, 10];
 
 export type TrackRole = "drums" | "bass" | "keys" | "lead";
 
@@ -141,27 +128,6 @@ export function musicalFingerprint(score: TrackScore): Fingerprint {
   };
 }
 
-/** Best-fitting major or minor scale for a pitch-class histogram, or null. */
-export function estimateKey(histogram: readonly number[]): string | null {
-  const total = histogram.reduce((sum, value) => sum + value, 0);
-  if (total <= 0) return null;
-  let best: { key: string; score: number } | undefined;
-  for (let tonic = 0; tonic < 12; tonic += 1) {
-    for (const [mode, scale] of [
-      ["major", MAJOR],
-      ["minor", MINOR],
-    ] as const) {
-      let fit = 0;
-      for (const step of scale) fit += histogram[(tonic + step) % 12]!;
-      // Tonic and fifth weigh extra so relative keys separate.
-      fit += histogram[tonic]! * 0.75 + histogram[(tonic + 7) % 12]! * 0.25;
-      if (!best || fit > best.score + 1e-9)
-        best = { key: `${NOTE_NAMES[tonic]} ${mode}`, score: fit };
-    }
-  }
-  return best!.key;
-}
-
 /** Deterministic offline name, e.g. "a minor bass groove" or "128 bpm drums + keys". */
 export function localName(fingerprint: Fingerprint): string {
   const roles = fingerprint.roles;