@hraness/dawg 0.3.0 → 0.4.1

package/src/media/cli.ts

@@ -7,7 +7,9 @@
  *   dawg media analyze <file>
  *   dawg media notes <file> [--kind drums|bass|vocals|guitar|piano|other] [--from s] [--to s]
  *   dawg media sample <file> <name> [--begin 0..1] [--end 0..1] [--root C4]
- *   dawg media lyrics <file> [--lang en]
+ *   dawg media wavetable <file> <name> [--frames 64] [--start s] [--end s] [--method auto|slice|spectral] [--smooth 0..1]
+                                         2048-sample frames → tracks/<slug>/wavetables/<name>.wav
+  dawg media lyrics <file> [--lang en]
  *
  * Progress goes to stderr, the JSON result to stdout. Ctrl-C sends SIGTERM to
  * the helper (SIGKILL after 15 s) and exits 130.
@@ -32,6 +34,8 @@ export const MEDIA_HELP = `dawg media — local media tools (see DAWG.md "Media
                                          notes/hits + quantized snippet → <file>.<kind>.notes.json
   dawg media sample <file> <name> [--begin f] [--end f] [--root C4]
                                          48 kHz wav → tracks/<slug>/samples/<name>.wav + sampler snippet
+  dawg media wavetable <file> <name> [--frames 64] [--start s] [--end s] [--method auto|slice|spectral] [--smooth 0..1]
+                                         2048-sample frames → tracks/<slug>/wavetables/<name>.wav
   dawg media lyrics <file> [--lang en]   whisper transcript → <file>.lyrics.json/.txt
 
 Options: --track <name> picks the track folder (default main); --json prints only the result.
@@ -44,9 +48,18 @@ const VERBS: Record<string, { tool: string; positional: string[] }> = {
   notes: { tool: "transcribe_notes", positional: ["file"] },
   sample: { tool: "import_sample", positional: ["file", "name"] },
   lyrics: { tool: "transcribe_lyrics", positional: ["file"] },
+  wavetable: { tool: "make_wavetable", positional: ["file", "name"] },
 };
 
-const NUMERIC = new Set(["from", "to", "begin", "end"]);
+const NUMERIC = new Set([
+  "from",
+  "to",
+  "begin",
+  "end",
+  "frames",
+  "start",
+  "smooth",
+]);
 
 export function parseMediaArgv(argv: readonly string[]): {
   verb: string | undefined;

package/src/media/tools.ts

@@ -1,5 +1,5 @@
 /**
- * The six media tools as `AgentTool`s. `plan()` validates arguments from
+ * The seven media tools as `AgentTool`s. `plan()` validates arguments from
  * `unknown` and returns a `media` plan whose `run()` the agent loop executes
  * with the host's `MediaHost` (project root, focused slug, runner, fetch),
  * a cancellation signal and a progress sink. `dawg media <verb>` reuses the
@@ -9,6 +9,14 @@ import type { AgentTool, ToolPlan } from "../agent/tools.ts";
 import { analyzeAudio } from "./analyze.ts";
 import { downloadAudio } from "./download.ts";
 import { importSample } from "./import.ts";
+import { makeWavetableFile } from "./wavetable.ts";
+import {
+  MAKE_MAX_FRAMES,
+  MAKE_METHODS,
+  MAKE_NORMALIZE,
+  type MakeMethod,
+  type MakeNormalize,
+} from "../audio/wavetable-maker.ts";
 import { transcribeLyrics } from "./lyrics.ts";
 import { NOTE_KINDS, transcribeNotes, type NoteKind } from "./notes.ts";
 import { MAX_NAME_LENGTH, trackSlug } from "./paths.ts";
@@ -259,6 +267,103 @@ export const MEDIA_TOOLS: readonly AgentTool[] = Object.freeze([
       );
     },
   },
+  {
+    name: "make_wavetable",
+    description:
+      "Make a wavetable from any audio file in the project (download, stem, imported sample): writes tracks/<slug>/wavetables/<name>.wav (float32, 2048-sample frames) and reports the detected pitch, method and how the timbre moves across the frames. Region defaults to the most stable tonal 2 s; method auto picks slice (pitched single cycles) or spectral (vocals, pads, noise). Then set_wavetable with that path as table.",
+    parameters: {
+      type: "object",
+      properties: {
+        file: fileSchema,
+        name: {
+          type: "string",
+          maxLength: MAX_NAME_LENGTH,
+          description: "Table name: lowercase identifier such as vox or growl.",
+        },
+        frames: {
+          type: "integer",
+          minimum: 1,
+          maximum: MAKE_MAX_FRAMES,
+          description: "Frame count (default 64).",
+        },
+        start: {
+          type: "number",
+          minimum: 0,
+          description: "Region start, seconds.",
+        },
+        end: {
+          type: "number",
+          minimum: 0,
+          description: "Region end, seconds.",
+        },
+        method: { type: "string", enum: [...MAKE_METHODS] },
+        smooth: {
+          type: "number",
+          minimum: 0,
+          maximum: 1,
+          description: "Blend frames with neighbours for a smoother morph.",
+        },
+        normalize: { type: "string", enum: [...MAKE_NORMALIZE] },
+      },
+      required: ["file", "name"],
+      additionalProperties: false,
+    },
+    plan: (args) => {
+      const file = text(args, "file", 1024);
+      const name = sampleName(args);
+      const frames = args.frames;
+      if (
+        frames !== undefined &&
+        (typeof frames !== "number" ||
+          !Number.isInteger(frames) ||
+          frames < 1 ||
+          frames > MAKE_MAX_FRAMES)
+      )
+        throw new MediaArgumentError(
+          `frames must be an integer 1..${MAKE_MAX_FRAMES}`,
+        );
+      const seconds = (key: "start" | "end") => {
+        const value = args[key];
+        if (value === undefined) return undefined;
+        if (typeof value !== "number" || !Number.isFinite(value) || value < 0)
+          throw new MediaArgumentError(`${key} must be seconds ≥ 0`);
+        return value;
+      };
+      const start = seconds("start");
+      const end = seconds("end");
+      if (start !== undefined && end !== undefined && end <= start)
+        throw new MediaArgumentError("end must be greater than start");
+      const method = optionalText(args, "method", 16);
+      if (method !== undefined && !MAKE_METHODS.includes(method as MakeMethod))
+        throw new MediaArgumentError(
+          `method must be ${MAKE_METHODS.join(", ")}`,
+        );
+      const normalize = optionalText(args, "normalize", 16);
+      if (
+        normalize !== undefined &&
+        !MAKE_NORMALIZE.includes(normalize as MakeNormalize)
+      )
+        throw new MediaArgumentError(
+          `normalize must be ${MAKE_NORMALIZE.join(", ")}`,
+        );
+      const smooth = optionalFraction(args, "smooth");
+      return media(`make wavetable ${name} from ${file}`, (context) =>
+        makeWavetableFile(
+          {
+            file,
+            name,
+            ...(frames !== undefined ? { frames: frames as number } : {}),
+            ...(start !== undefined ? { start } : {}),
+            ...(end !== undefined ? { end } : {}),
+            ...(method ? { method: method as MakeMethod } : {}),
+            ...(smooth !== undefined ? { smooth } : {}),
+            ...(normalize ? { normalize: normalize as MakeNormalize } : {}),
+          },
+          context,
+        ),
+      );
+    },
+  },
   {
     name: "transcribe_lyrics",
     description:

package/src/media/wavetable.ts

@@ -0,0 +1,202 @@
+/**
+ * `make_wavetable(file, name, {...})`: turns any audio file in the project
+ * (a download, a stem, an imported sample) into a wavetable at
+ * `tracks/<slug>/wavetables/<name>.wav` — float32 frames of 2048 samples
+ * with a `clm ` chunk, the format Serum, Vital and uzu-wavetables use — and
+ * reports how the timbre moves across it so the model can pick a position.
+ *
+ * WAV inputs are read directly; anything else goes through ffmpeg to
+ * 48 kHz mono float. The extraction itself is `src/audio/wavetable-maker.ts`.
+ */
+import { rename, stat } from "node:fs/promises";
+import { join } from "node:path";
+import { SCORE_LIMITS } from "../../core/score.ts";
+import {
+  MAKE_FRAME_SIZE,
+  WavetableMakeError,
+  encodeWavetableWav,
+  makeWavetable,
+  type MakeMethod,
+  type MakeNormalize,
+} from "../audio/wavetable-maker.ts";
+import { missingTool } from "./backend.ts";
+import {
+  ensureDir,
+  formatBytes,
+  projectPath,
+  resolveInput,
+  sha256File,
+} from "./paths.ts";
+import { MediaToolError, runHelper } from "./process.ts";
+import {
+  MEDIA_LIMITS,
+  type MediaHost,
+  type MediaResult,
+  type MediaRunContext,
+} from "./types.ts";
+import { parseWav } from "./vendor/wav.ts";
+
+/** Longest source read; the maker only analyses a bounded region of it. */
+const MAX_SOURCE_SECONDS = 10 * 60;
+const DECODE_RATE = 48_000;
+
+export type MakeWavetableArgs = Readonly<{
+  file: string;
+  name: string;
+  frames?: number;
+  start?: number;
+  end?: number;
+  method?: MakeMethod;
+  smooth?: number;
+  normalize?: MakeNormalize;
+}>;
+
+export function wavetablesDir(
+  host: Pick<MediaHost, "projectRoot" | "trackSlug">,
+): string {
+  return join(host.projectRoot, "tracks", host.trackSlug, "wavetables");
+}
+
+function mixdown(
+  wav: ReturnType<typeof parseWav>,
+  maxFrames: number,
+): Float32Array {
+  const frames = Math.min(wav.sampleCount, maxFrames);
+  const out = new Float32Array(frames);
+  for (let i = 0; i < frames; i += 1) {
+    let sum = 0;
+    for (let c = 0; c < wav.channels; c += 1) sum += wav.sample(i, c);
+    out[i] = sum / wav.channels;
+  }
+  return out;
+}
+
+async function readSource(
+  context: MediaRunContext,
+  absolute: string,
+  size: number,
+): Promise<{ mono: Float32Array; sampleRate: number }> {
+  const options = {
+    maximumBytes: 2 ** 31,
+    maximumDurationSeconds: 24 * 3600,
+    maximumChannels: 32,
+  };
+  if (/\.wav$/i.test(absolute) && size <= MEDIA_LIMITS.downloadMaxBytes) {
+    try {
+      const wav = parseWav(
+        new Uint8Array(await Bun.file(absolute).arrayBuffer()),
+        options,
+      );
+      return {
+        mono: mixdown(wav, MAX_SOURCE_SECONDS * wav.sampleRate),
+        sampleRate: wav.sampleRate,
+      };
+    } catch {
+      // Unusual WAV (ADPCM, extensible quirks): let ffmpeg read it.
+    }
+  }
+  if (!context.runner.which("ffmpeg"))
+    throw new MediaToolError(missingTool("ffmpeg"));
+  const temp = join(
+    await ensureDir(wavetablesDir(context)),
+    `.decode-${process.pid}-${Date.now()}.part.wav`,
+  );
+  context.progress("ffmpeg → mono 48 kHz");
+  try {
+    await runHelper(
+      context,
+      [
+        "ffmpeg",
+        "-hide_banner",
+        "-nostdin",
+        "-loglevel",
+        "error",
+        "-y",
+        "-i",
+        absolute,
+        "-vn",
+        "-t",
+        String(MAX_SOURCE_SECONDS),
+        "-ar",
+        String(DECODE_RATE),
+        "-ac",
+        "1",
+        "-c:a",
+        "pcm_f32le",
+        temp,
+      ],
+      { timeoutMs: MEDIA_LIMITS.sampleTimeoutMs },
+    );
+    const wav = parseWav(
+      new Uint8Array(await Bun.file(temp).arrayBuffer()),
+      options,
+    );
+    return { mono: mixdown(wav, wav.sampleCount), sampleRate: wav.sampleRate };
+  } finally {
+    await Bun.file(temp)
+      .delete()
+      .catch(() => undefined);
+  }
+}
+
+export async function makeWavetableFile(
+  args: MakeWavetableArgs,
+  context: MediaRunContext,
+): Promise<MediaResult> {
+  const input = await resolveInput(context, args.file);
+  const { mono, sampleRate } = await readSource(
+    context,
+    input.absolute,
+    input.size,
+  );
+  context.progress(`analysing ${input.relative}`);
+  let made;
+  try {
+    made = makeWavetable(mono, sampleRate, {
+      ...(args.frames !== undefined ? { frames: args.frames } : {}),
+      ...(args.start !== undefined ? { start: args.start } : {}),
+      ...(args.end !== undefined ? { end: args.end } : {}),
+      ...(args.method !== undefined ? { method: args.method } : {}),
+      ...(args.smooth !== undefined ? { smooth: args.smooth } : {}),
+      ...(args.normalize !== undefined ? { normalize: args.normalize } : {}),
+    });
+  } catch (error) {
+    if (error instanceof WavetableMakeError)
+      throw new MediaToolError(error.message);
+    throw error;
+  }
+  const bytes = encodeWavetableWav(made.frames);
+  if (bytes.byteLength > SCORE_LIMITS.maxSampleFileBytes)
+    throw new MediaToolError(
+      `${formatBytes(bytes.byteLength)} is over the sample file limit; use fewer frames`,
+    );
+  const dir = await ensureDir(wavetablesDir(context));
+  const target = join(dir, `${args.name}.wav`);
+  const temp = `${target}.part`;
+  await Bun.write(temp, bytes);
+  await rename(temp, target);
+  const sha256 = await sha256File(target);
+  const path = projectPath(context.projectRoot, target);
+  const size = (await stat(target)).size;
+  const region = `${made.region.start.toFixed(2)}–${made.region.end.toFixed(2)} s${made.region.auto ? " (auto)" : ""}`;
+  return {
+    summary: `wavetable ${args.name} · ${made.frames.length} frames · ${made.method} · ${region}`,
+    outputs: [path],
+    content: {
+      wavetable: {
+        name: args.name,
+        path,
+        sha256,
+        frames: made.frames.length,
+        frameSize: MAKE_FRAME_SIZE,
+        bytes: size,
+        source: input.relative,
+        method: made.method,
+        region: made.region,
+        ...(made.pitch ? { pitch: made.pitch } : {}),
+      },
+      sweep: made.sweep,
+      next: `set_wavetable with table "${path}" plays it on a track (wt 0..1 picks the frame; wtenv or set_automation wt sweeps it). In track.ts: instrument: wavetable("./wavetables/${args.name}.wav").`,
+    },
+  };
+}

package/src/render.ts

@@ -12,6 +12,13 @@ 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 {
+  PackStore,
+  creditsLine,
+  packCredits,
+  withWavComment,
+  writeCredits,
+} from "./audio/packs.ts";
 import { evaluateProject, formatDiagnostic } from "../core/sdk/eval.ts";
 import { isProject } from "./project/init.ts";
 import { resolveSessionArg } from "./session/attach.ts";
@@ -76,13 +83,27 @@ export async function runRenderCommand(
     for (const problem of samples.problems)
       stderr.write(`sample ${problem.level} · ${problem.message}\n`);
   }
-  const wav = renderScoreWav(score, { samples });
+  let wav = renderScoreWav(score, { samples });
+  // 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) =>
+    Object.values(track.sampler?.voices ?? {}),
+  );
+  let credits: string | undefined;
+  if (refs.some((ref) => ref.src.startsWith("pack:"))) {
+    const list = packCredits(refs, await new PackStore().list());
+    credits = creditsLine(list);
+    if (credits) wav = withWavComment(wav, `samples: ${credits}`);
+    if (await isProject(workspace).catch(() => false))
+      await writeCredits(workspace, list).catch(() => undefined);
+  }
   const path = resolve(workspace, target);
   const temporary = `${path}.${process.pid}.tmp`;
   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`);
+  if (credits) stdout.write(`credits · ${credits}\n`);
   return 0;
 }
 

package/src/session/naming.ts

@@ -89,13 +89,15 @@ export function musicalFingerprint(score: TrackScore): Fingerprint {
     if (track.filter) effects.add("filter");
     if (track.delay) effects.add("delay");
     if (track.reverb) effects.add("reverb");
+    for (const name of Object.keys(track.fx ?? {})) effects.add(name);
     if (track.volumeAutomation.length || track.panAutomation.length)
       effects.add("automation");
     if (
       track.filterAutomation?.length ||
       track.resonanceAutomation?.length ||
       track.delayFeedbackAutomation?.length ||
-      track.delayMixAutomation?.length
+      track.delayMixAutomation?.length ||
+      Object.keys(track.fxAutomation ?? {}).length
     )
       effects.add("sweep");
     const instrument = track.instrument.toLowerCase().slice(0, 24);