@hraness/dawg 0.5.0 → 0.6.0

package/src/audio/warp.ts

@@ -84,3 +84,64 @@ export function warpedSpan(
     length: Math.max(1, Math.floor(to - from)),
   };
 }
+
+/**
+ * A fitted sample window's position map (0.6 `bpm`/`len`/`fit`): output
+ * frames after the note start to window frames and back, both at the
+ * render rate. Through a tempo map the window follows ramps and steps;
+ * at constant tempo both directions are linear.
+ */
+export type FitMap = Readonly<{
+  /** Output frames the whole window takes. */
+  length: number;
+  /** Window frame sounding `e` output frames after the start. */
+  at(e: number): number;
+  /** Output frame (after the start) where window frame `p` sounds. */
+  outAt(p: number): number;
+}>;
+
+/**
+ * The map for a window of `frames` render-rate frames that advances
+ * `perBeat` window frames per song beat from `startTick`. Without a warp the
+ * song runs at `tempoBpm` throughout.
+ */
+export function beatFitMap(
+  warp: SampleWarp | undefined,
+  timing: Readonly<{
+    tempoBpm: number;
+    ticksPerBeat: number;
+    sampleRate: number;
+  }>,
+  startTick: number,
+  frames: number,
+  perBeat: number,
+): FitMap {
+  const { tempoBpm, ticksPerBeat, sampleRate } = timing;
+  if (!warp) {
+    const ratio = perBeat / ((sampleRate * 60) / tempoBpm);
+    return Object.freeze({
+      length: frames / ratio,
+      at: (e: number) => e * ratio,
+      outAt: (p: number) => p / ratio,
+    });
+  }
+  const origin = warp.sample(startTick);
+  const outAt = (p: number) =>
+    warp.sample(startTick + (p / perBeat) * ticksPerBeat) - origin;
+  return Object.freeze({
+    length: outAt(frames),
+    at: (e: number) =>
+      ((warp.tick(origin + e) - startTick) / ticksPerBeat) * perBeat,
+    outAt,
+  });
+}
+
+/** `fit`: the window fills `held` output frames, linearly. */
+export function spanFitMap(frames: number, held: number): FitMap {
+  const ratio = frames / Math.max(1, held);
+  return Object.freeze({
+    length: held,
+    at: (e: number) => e * ratio,
+    outAt: (p: number) => p / ratio,
+  });
+}

package/src/audio/wav.ts

@@ -23,6 +23,7 @@ import {
 } from "./sampler.ts";
 import { EFFECT_NAMES, FX_PRESETS, effectSpec } from "../../core/fx.ts";
 import { seededRandom } from "./random.ts";
+import { engineFor, engineTailSeconds } from "./instruments.ts";
 import {
   isStereoVoice,
   renderSynthNote,
@@ -139,6 +140,9 @@ export const AVAILABLE_INSTRUMENTS = Object.freeze([
   "z_square",
   "z_tan",
   "z_noise",
+  // 0.6 instruments (src/audio/instruments.ts), one line per lane.
+  "granular",
+  "modal",
 ] as const);
 
 /** Per-track effects understood by the renderer and the agent, in chain
@@ -180,8 +184,32 @@ function oneShotSeconds(
 }
 /** Loop renders fold at most this much tail back onto the loop start. */
 const MAX_LOOP_TAIL_SECONDS = 8;
+/** A 0.6 engine's one-shot ring-out is capped here, not at the loop fold. */
+const MAX_ENGINE_TAIL_SECONDS = 30;
 
-type RenderContext = Readonly<{
+/**
+ * The longest 0.6 engine ring-out in `score`, capped at 30 s. One-shot
+ * renders (exports, previews) let engine tails reach their own cap; the
+ * 8 s cap applies only to loop folding. Zero without an engine, so legacy
+ * renders are unchanged.
+ */
+function oneShotEngineTail(score: TrackScore): number {
+  let tail = 0;
+  for (const track of score.tracks) {
+    if (!engineFor(track)) continue;
+    let lowest: number | undefined;
+    for (const note of score.notes)
+      if (
+        note.trackId === track.id &&
+        (lowest === undefined || note.pitch < lowest)
+      )
+        lowest = note.pitch;
+    tail = Math.max(tail, engineTailSeconds(track, lowest));
+  }
+  return Math.min(MAX_ENGINE_TAIL_SECONDS, tail);
+}
+
+export type RenderContext = Readonly<{
   score: TrackScore;
   sampleRate: number;
   samples: number;
@@ -314,9 +342,15 @@ export class StemRenderer {
       Math.max(
         samplerTailSeconds(score, bank, sampleRate),
         ...score.tracks.map(synthTailSeconds),
+        // Zero without a registered 0.6 instrument engine.
+        ...score.tracks.map((track) => engineTailSeconds(track)),
       ),
     );
-    return oneShotSeconds(loopSecondsOf(score), samplerTail, reverbTail);
+    return oneShotSeconds(
+      loopSecondsOf(score),
+      Math.max(samplerTail, oneShotEngineTail(score)),
+      reverbTail,
+    );
   }
 
   public render(score: TrackScore, options: RenderOptions = {}): RenderedAudio {
@@ -338,6 +372,8 @@ export class StemRenderer {
       Math.max(
         samplerTailSeconds(score, bank, sampleRate),
         ...score.tracks.map(synthTailSeconds),
+        // Zero without a registered 0.6 instrument engine.
+        ...score.tracks.map((track) => engineTailSeconds(track)),
       ),
     );
     let frames: number;
@@ -367,7 +403,11 @@ export class StemRenderer {
     } else {
       const seconds = Math.min(
         maxSeconds,
-        oneShotSeconds(loopSeconds, samplerTail, reverbTail),
+        oneShotSeconds(
+          loopSeconds,
+          Math.max(samplerTail, oneShotEngineTail(score)),
+          reverbTail,
+        ),
       );
       frames = Math.max(1, Math.ceil(seconds * sampleRate));
       samples = frames;
@@ -437,6 +477,18 @@ export class StemRenderer {
       const played = performed.get(trackId)!;
       const busOrbit = sharedOrbitOf(track);
       const sampler = isSamplerInstrument(track?.instrument);
+      // A 0.6 instrument engine (src/audio/instruments.ts), if registered
+      // and the track carries its field; undefined keeps today's voices.
+      const engine = engineFor(track);
+      // The song key always joins an engine's stem key: engines may tune to
+      // it (sympathetic strings) without a song tuning.
+      const engineDigests =
+        engine && track
+          ? [
+              ...(engine.assetDigests?.(track, bank) ?? []),
+              `key:${score.key ?? ""}`,
+            ]
+          : undefined;
       // Wavetable hook: the oscillator factory for a wavetable track (its
       // table id joins the stem key), undefined for every other instrument.
       const wavetable = track ? wavetableHook(track, bank, context) : undefined;
@@ -449,6 +501,7 @@ export class StemRenderer {
         sampler ? bank : undefined,
         wavetable?.id,
         track ? reverbImpulse(track, sampleRate, bank.irs)?.id : undefined,
+        engineDigests,
       );
       let stem = this.stems.get(trackId);
       const caching = this.maxCacheBytes > 0;
@@ -464,6 +517,7 @@ export class StemRenderer {
               sampler ? bank : undefined,
               wavetable?.id,
               reverbImpulse(track, sampleRate, bank.irs)?.id,
+              engineDigests,
             )
           : undefined;
       if (stem?.key === key) stem.used = this.renders;
@@ -490,10 +544,25 @@ export class StemRenderer {
             }
           : { left, right };
         dry.fill(0);
-        const synthVoice = !sampler && usesSynthVoice(track);
-        const stereo = synthVoice && isStereoVoice(track);
+        const synthVoice = !engine && !sampler && usesSynthVoice(track);
+        const stereo = engine
+          ? engine.stereo(track!)
+          : synthVoice && isStereoVoice(track);
         if (stereo) dryR.fill(0);
-        if (sampler) {
+        if (engine && track) {
+          engine.render(
+            dry,
+            stereo ? dryR : undefined,
+            played,
+            track,
+            {
+              ...context,
+              ticksPerBeat: score.ticksPerBeat,
+              ...(tuning ? { tuning } : {}),
+            },
+            bank,
+          );
+        } else if (sampler) {
           if (track) renderSamplerNotes(dry, played, track, context, bank);
         } else if (synthVoice && track) {
           const gainAt = (tick: number) => trackGainAt(track, tick);
@@ -826,6 +895,7 @@ function stemKey(
   bank?: SampleBank,
   wavetableId?: string,
   impulseId?: string,
+  engineDigests?: readonly string[],
 ): string {
   let settings: Record<string, unknown> | null = null;
   if (track) {
@@ -849,6 +919,8 @@ function stemKey(
     ...(wavetableId ? [wavetableId] : []),
     // A convolution reverb's impulse (its sha256 for a sample).
     ...(impulseId ? [impulseId] : []),
+    // Assets a 0.6 instrument engine reads (absent without an engine).
+    ...(engineDigests ? [engineDigests] : []),
     // The song tuning, and the key whose tonic is the default root.
     ...(context.score.tuning || track?.tuning
       ? [context.score.tuning ?? null, context.score.key]

package/src/commands/expression.ts

@@ -832,12 +832,19 @@ export function applyExpressionCommand(
           return { ok: false, message: `pedal · ${error.message}` };
         throw error;
       }
-      const downs = (pedal ?? []).filter((event) => event.state !== "up");
+      const downs = (pedal ?? []).filter((event) => event.state === "down");
+      const halves = (pedal ?? []).filter((event) => event.state === "half");
+      const held = [
+        ...(downs.length > 0 || halves.length === 0
+          ? [`${downs.length} down`]
+          : []),
+        ...(halves.length > 0 ? [`${halves.length} half`] : []),
+      ].join(", ");
       return trackResult(
         score,
         track,
         { pedal: pedal ?? null },
-        `pedal · ${pedal?.length ?? 0} event${pedal?.length === 1 ? "" : "s"} (${downs.length} down) · ${trackId}`,
+        `pedal · ${pedal?.length ?? 0} event${pedal?.length === 1 ? "" : "s"} (${held}) · ${trackId}`,
       );
     }
     case "velcurve": {

package/src/commands/fit.ts

@@ -0,0 +1,135 @@
+/**
+ * `/fitmode <mode>`, `/bpm <n>` and `/len <beats>` (0.6): fit a sampler
+ * voice to the song's time. They act on the focused sampler track's voice
+ * (named, or its only voice) through `setSampleControls`, so validation and
+ * printing stay the sampler's. `/fitmode` with no mode suggests one from
+ * the sample's content (`suggestFitMode`); song tempo stays `tempo <n>`.
+ */
+import {
+  SAMPLE_FIT_MODES,
+  isSamplerInstrument,
+  samplerVoiceSlots,
+  type SampleFitMode,
+  type TrackScore,
+} from "../../core/score.ts";
+import { setSampleControls, type SetSampleResult } from "./sample.ts";
+
+export type FitCommand = Readonly<{
+  control: "fitmode" | "bpm" | "len";
+  /** Undefined: `/fitmode` alone (suggest) or `off`-style unset is null. */
+  value: SampleFitMode | number | null | undefined;
+  voice?: string;
+}>;
+
+const VOICE = "([a-z][a-z0-9_]{0,31})";
+
+/**
+ * Parse `/fitmode [mode|auto|off [voice]]`, `/bpm <n|off> [voice]`,
+ * `/len <beats|off> [voice]`. `fitmode` and `len` also work without the
+ * slash; a bare `bpm 120` stays the song's tempo word, so `/bpm` needs it.
+ */
+export function parseFitCommand(command: string): FitCommand | undefined {
+  const text = command.trim();
+  const mode = text.match(
+    new RegExp(
+      `^/?fitmode(?:\\s+(repitch|beats|tones|auto|off|none)(?:\\s+${VOICE})?)?$`,
+      "i",
+    ),
+  );
+  if (mode) {
+    const raw = mode[1]?.toLowerCase();
+    return {
+      control: "fitmode",
+      value:
+        raw === undefined || raw === "auto"
+          ? undefined
+          : raw === "off" || raw === "none"
+            ? null
+            : (raw as SampleFitMode),
+      ...(mode[2] ? { voice: mode[2].toLowerCase() } : {}),
+    };
+  }
+  const number = text.match(
+    new RegExp(
+      `^(/bpm|/?len)\\s+(\\d+(?:\\.\\d+)?|off|none)(?:\\s+${VOICE})?$`,
+      "i",
+    ),
+  );
+  if (!number) return undefined;
+  const raw = number[2]!.toLowerCase();
+  return {
+    control: number[1]!.toLowerCase().replace("/", "") as "bpm" | "len",
+    value: raw === "off" || raw === "none" ? null : Number(raw),
+    ...(number[3] ? { voice: number[3].toLowerCase() } : {}),
+  };
+}
+
+/**
+ * The voice a fit command acts on: the named one, else the track's only
+ * voice (lowest slot first when it has several and none is named).
+ */
+export function fitVoice(
+  score: TrackScore,
+  trackId: string,
+  voice: string | undefined,
+): { voice: string } | { error: string } {
+  const track = score.tracks.find((item) => item.id === trackId);
+  const sampler = track?.sampler;
+  if (!track || !sampler || !isSamplerInstrument(track.instrument))
+    return {
+      error: `fit · ${trackId} is not a sampler track · /sample <path> first · song tempo is tempo <bpm>`,
+    };
+  if (voice) return { voice };
+  const names = Object.keys(sampler.voices);
+  if (names.length === 1) return { voice: names[0]! };
+  const slots = samplerVoiceSlots(sampler);
+  const sorted = names.sort(
+    (a, b) => (slots.get(a) ?? 0) - (slots.get(b) ?? 0) || (a < b ? -1 : 1),
+  );
+  return {
+    error: `fit · ${trackId} has ${names.length} voices · name one: ${sorted.join(" ")}`,
+  };
+}
+
+/** Apply a parsed fit command with a known value (a suggested mode resolved). */
+export function applyFitCommand(
+  score: TrackScore,
+  trackId: string,
+  command: FitCommand,
+  mode?: SampleFitMode,
+): SetSampleResult {
+  const target = fitVoice(score, trackId, command.voice);
+  if ("error" in target) return { ok: false, message: target.error };
+  const value = command.value === undefined ? (mode ?? null) : command.value;
+  if (command.control === "fitmode" && value !== null) {
+    const ref = score.tracks.find((t) => t.id === trackId)?.sampler?.voices[
+      target.voice
+    ];
+    if (
+      ref &&
+      value !== "repitch" &&
+      ref.bpm === undefined &&
+      ref.len === undefined &&
+      ref.fit !== true
+    )
+      return {
+        ok: false,
+        message: `fit · fitmode ${String(value)} needs the sample's tempo first · /bpm <n> or /len <beats>`,
+      };
+  }
+  const values: Record<string, number | string | null> = {
+    [command.control]: value,
+  };
+  // Unsetting bpm or len leaves a fitmode with nothing to fit: unset both.
+  if (value === null && command.control !== "fitmode") {
+    const ref = score.tracks.find((t) => t.id === trackId)?.sampler?.voices[
+      target.voice
+    ];
+    const other = command.control === "bpm" ? ref?.len : ref?.bpm;
+    if (ref?.fitmode && other === undefined && ref.fit !== true)
+      values.fitmode = null;
+  }
+  return setSampleControls(score, trackId, target.voice, values);
+}
+
+export const FIT_MODES = SAMPLE_FIT_MODES;

package/src/commands/fx.ts

@@ -18,6 +18,7 @@
  * on/off/true/false; enums take one of their values. Each command is one
  * `updateTrack` revision and one undo step.
  */
+import { nearestWord } from "../audio/instrument-check.ts";
 import {
   EFFECT_NAMES,
   FX_PRESETS,
@@ -190,6 +191,31 @@ export function parseFxCommand(prompt: string): FxCommand | undefined {
   return { type: "fx-set", effect, values };
 }
 
+/**
+ * A short `fx <word> …` whose word is no effect (`fx wobble on`, `fx dela
+ * mix 0.3`): the local answer, so a typo never goes to the agent. Longer
+ * free text after `fx` still does.
+ */
+export function unknownFxMessage(prompt: string): string | undefined {
+  const words = prompt.trim().split(/\s+/);
+  if (words[0]?.toLowerCase() !== "fx" || words.length < 2) return undefined;
+  const name = words[1]!.toLowerCase();
+  if (parseEffectName(name) || ["ir", "iresponse", "amp"].includes(name))
+    return undefined;
+  const near = nearestWord(name, [
+    ...EFFECT_NAMES,
+    ...Object.keys(EFFECT_ALIASES),
+    "reverb",
+  ]);
+  const rest = words.slice(2).map((word) => word.toLowerCase());
+  const commandShaped =
+    rest.length <= 1 ||
+    ["on", "off", "reset", "preset"].includes(rest[0]!) ||
+    rest.every((word, index) => index % 2 === 0 || /^-?[\d.]+/.test(word));
+  if (!near && !commandShaped) return undefined;
+  return `unknown effect ${name.slice(0, 24)}${near ? ` · did you mean ${near}?` : ""} · effects ${EFFECT_NAMES.join(", ")}`;
+}
+
 function irCommand(value: string): FxCommand | undefined {
   const lower = value.toLowerCase();
   if (lower === "off" || lower === "none") return { type: "fx-ir", ir: null };
@@ -208,6 +234,11 @@ export function effectDefaults(effect: EffectName): FxValues {
     if (!(spec.optional && spec.default === false)) out[key] = spec.default;
   // A zero `time` means "follow beats"; the canonical form omits it.
   if (effect === "delay") delete out.time;
+  // A head's sag follows its type and its noise gate is off until set.
+  if (effect === "head") {
+    delete out.sag;
+    delete out.gate;
+  }
   return out;
 }