@hraness/dawg 0.6.0 → 0.6.1

package/src/commands/resample.ts

@@ -0,0 +1,281 @@
+/**
+ * `resample <track> | orbit <n> | master [section <name> | bars a-b] [post]
+ * [grain] [as <id>]` (0.6.1): render a track, an orbit or the mix to
+ * `tracks/<slug>/samples/<name>.wav`, pin its sha256, record where it came
+ * from (`from`: source, section or bars, the source score's sha256) and add
+ * a track that plays it: a one-shot sampler track whose single note starts
+ * where the range starts and lasts the range, or with `grain` a granular
+ * track (the `cloud` preset) holding one note across the range. The source
+ * stays as it is; mute it to hear only the resample.
+ */
+import { mkdir, realpath, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { MAX_ORBIT } from "../../core/fx.ts";
+import { GRANULAR_INSTRUMENT } from "../../core/granular.ts";
+import {
+  ScoreValidationError,
+  SCORE_LIMITS,
+  TrackScore,
+  addTrack,
+  type SampleRef,
+  type TrackInput,
+} from "../../core/score.ts";
+import { trackDirectories } from "../../core/sdk/print.ts";
+import { barTicks } from "../../core/sections.ts";
+import {
+  RESAMPLE_GAIN,
+  renderResample,
+  type ResampleRender,
+  type ResampleRequest,
+} from "../audio/resample.ts";
+import type { SampleBank } from "../audio/samples.ts";
+
+export type ResampleCommand = ResampleRequest &
+  Readonly<{
+    /** Make a granular track instead of a sampler track. */
+    grain: boolean;
+    /** The new track's id (default `<source>-rs` or `<source>-grain`). */
+    as?: string;
+  }>;
+
+export const RESAMPLE_USAGE =
+  "resample <track>|orbit <n>|master [section <name>|bars a-b] [post] [grain] [as <id>]";
+
+const ID = /^[a-z][a-z0-9_-]{0,63}$/;
+
+/** Parse `resample ...` (with or without the slash). */
+export function parseResampleCommand(
+  command: string,
+): ResampleCommand | undefined {
+  const words = command.trim().split(/\s+/);
+  const head = words[0]?.toLowerCase().replace(/^\//, "");
+  if (head !== "resample" && head !== "bounce") return undefined;
+  let index = 1;
+  const next = () => words[index++];
+  const peek = () => words[index]?.toLowerCase();
+  let source: ResampleRequest["source"] | undefined;
+  const first = next();
+  if (first === undefined) return undefined;
+  if (first.toLowerCase() === "orbit") {
+    const n = Number(next());
+    if (!Number.isInteger(n) || n < 1 || n > MAX_ORBIT) return undefined;
+    source = { kind: "orbit", orbit: n };
+  } else if (first.toLowerCase() === "master" || first.toLowerCase() === "mix")
+    source = { kind: "master" };
+  else if (first.toLowerCase() === "track") {
+    const id = next();
+    if (!id) return undefined;
+    source = { kind: "track", trackId: id };
+  } else source = { kind: "track", trackId: first };
+  let range: ResampleRequest["range"] = { kind: "song" };
+  let post = false;
+  let grain = false;
+  let as: string | undefined;
+  while (index < words.length) {
+    const word = peek();
+    index += 1;
+    if (word === "section") {
+      // A section name runs to the next keyword.
+      const parts: string[] = [];
+      while (
+        index < words.length &&
+        !["post", "grain", "granular", "as", "bars"].includes(peek()!)
+      )
+        parts.push(next()!);
+      if (parts.length === 0) return undefined;
+      range = { kind: "section", name: parts.join(" ") };
+    } else if (word === "bars" || word === "bar") {
+      const match = /^(\d{1,4})(?:-(\d{1,4}))?$/.exec(next() ?? "");
+      if (!match) return undefined;
+      const from = Number(match[1]);
+      range = { kind: "bars", from, to: Number(match[2] ?? from) };
+    } else if (word === "post" || word === "master") post = true;
+    else if (word === "pre") post = false;
+    else if (word === "grain" || word === "granular") grain = true;
+    else if (word === "as") {
+      as = next()?.toLowerCase();
+      if (!as || !ID.test(as)) return undefined;
+    } else return undefined;
+  }
+  return {
+    source,
+    range,
+    ...(post ? { post } : {}),
+    grain,
+    ...(as ? { as } : {}),
+  };
+}
+
+/** A free track id near `base`: `base`, `base-2`, … */
+export function freeTrackId(score: TrackScore, base: string): string {
+  const stem = base.slice(0, 56);
+  const used = new Set(score.tracks.map((track) => track.id));
+  if (!used.has(stem)) return stem;
+  for (let n = 2; ; n += 1)
+    if (!used.has(`${stem}-${n}`)) return `${stem}-${n}`;
+}
+
+function sourceStem(command: ResampleCommand): string {
+  const source = command.source;
+  const base =
+    source.kind === "track"
+      ? source.trackId.toLowerCase().replace(/[^a-z0-9_-]/g, "")
+      : source.kind === "orbit"
+        ? `orbit${source.orbit}`
+        : "mix";
+  return /^[a-z]/.test(base) ? base : `t${base}`;
+}
+
+/** The sample's file name (without extension) from source and range. */
+export function resampleFileName(command: ResampleCommand): string {
+  const range = command.range;
+  const suffix =
+    range.kind === "section"
+      ? `-${range.name
+          .toLowerCase()
+          .replace(/[^a-z0-9]+/g, "-")
+          .replace(/^-|-$/g, "")}`
+      : range.kind === "bars"
+        ? `-b${range.from}-${range.to}`
+        : "";
+  return `${sourceStem(command)}${suffix}`.slice(0, 48) || "resample";
+}
+
+/**
+ * The score with the new track: a one-shot sampler voice (or a granular
+ * source) at `src`, and its one note across the range.
+ */
+export function addResampleTrack(
+  score: TrackScore,
+  command: ResampleCommand,
+  render: Pick<
+    ResampleRender,
+    "sha256" | "startTick" | "durationTicks" | "from"
+  >,
+  trackId: string,
+  src: string,
+): TrackScore {
+  const ref: SampleRef = {
+    src,
+    sha256: render.sha256,
+    from: render.from,
+    // A bounce starts at full level: no anti-click fade-in.
+    ...(command.grain ? {} : { gain: RESAMPLE_GAIN, fadeInTime: 0 }),
+  };
+  const track: TrackInput = command.grain
+    ? {
+        id: trackId,
+        name: trackId,
+        instrument: GRANULAR_INSTRUMENT,
+        granular: { src: ref, preset: "cloud" },
+      }
+    : {
+        id: trackId,
+        name: trackId,
+        instrument: "sampler",
+        sampler: {
+          mode: "oneshot",
+          voices: { [trackId.replace(/-/g, "_").slice(0, 32)]: ref },
+        },
+      };
+  let next = addTrack(score, track as TrackInput);
+  // One-shot slot 36 plays the only voice; a granular note at its root (60)
+  // plays the source at its own pitch.
+  const pitch = command.grain ? 60 : 36;
+  const notes = next.notes;
+  let n = 1;
+  while (notes.some((note) => note.id === `${trackId}-${n}`)) n += 1;
+  const ticks = Math.min(render.durationTicks, next.bars * barTicks(next));
+  next = new TrackScore({
+    ...next.toJSON(),
+    notes: [
+      ...notes,
+      {
+        id: `${trackId}-${n}`,
+        trackId,
+        startTick: render.startTick,
+        durationTicks: Math.max(1, ticks),
+        pitch,
+        velocity: 1,
+      },
+    ],
+  } as never);
+  return next;
+}
+
+export type ResampleResult =
+  | Readonly<{
+      ok: true;
+      next: TrackScore;
+      trackId: string;
+      src: string;
+      sha256: string;
+      message: string;
+    }>
+  | Readonly<{ ok: false; message: string }>;
+
+/**
+ * Render, write the file under the new track's directory and return the
+ * score with the new track. `samples` is the loaded bank of `score`.
+ */
+export async function runResample(
+  options: Readonly<{
+    projectRoot: string;
+    score: TrackScore;
+    command: ResampleCommand;
+    samples?: SampleBank;
+  }>,
+): Promise<ResampleResult> {
+  const { score, command } = options;
+  if (score.tracks.length >= SCORE_LIMITS.maxTracks)
+    return {
+      ok: false,
+      message: `resample · the song already has ${SCORE_LIMITS.maxTracks} tracks`,
+    };
+  let render: ResampleRender;
+  try {
+    render = renderResample(score, command, options.samples);
+  } catch (error) {
+    if (error instanceof ScoreValidationError)
+      return {
+        ok: false,
+        message: `resample · ${error.message} · ${RESAMPLE_USAGE}`,
+      };
+    throw error;
+  }
+  const trackId =
+    command.as ??
+    freeTrackId(
+      score,
+      `${sourceStem(command)}-${command.grain ? "grain" : "rs"}`,
+    );
+  if (score.tracks.some((track) => track.id === trackId))
+    return { ok: false, message: `resample · track ${trackId} already exists` };
+  // The directory follows the score that will hold the track.
+  const probe = addTrack(score, { id: trackId, name: trackId });
+  const slug = trackDirectories(probe).get(trackId) ?? trackId;
+  const root = await realpath(options.projectRoot);
+  const dir = join(root, "tracks", slug, "samples");
+  await mkdir(dir, { recursive: true });
+  const name = `${resampleFileName(command)}.wav`;
+  const target = join(dir, name);
+  const temporary = `${target}.${process.pid}.tmp`;
+  await writeFile(temporary, render.wav);
+  await rename(temporary, target);
+  const src = `samples/${name}`;
+  const next = addResampleTrack(score, command, render, trackId, src);
+  const what =
+    command.source.kind === "track"
+      ? command.source.trackId
+      : command.source.kind === "orbit"
+        ? `orbit ${command.source.orbit}`
+        : "the mix";
+  return {
+    ok: true,
+    next,
+    trackId,
+    src: `tracks/${slug}/${src}`,
+    sha256: render.sha256,
+    message: `resampled ${what} · ${render.seconds.toFixed(2)} s → tracks/${slug}/${src} · ${render.sha256.slice(0, 12)} · new ${command.grain ? "granular" : "sampler"} track ${trackId}${command.source.kind === "track" ? ` · mute ${command.source.trackId} to hear only the resample` : ""}`,
+  };
+}

package/src/commands/rig.ts

@@ -27,6 +27,7 @@ import {
   type FxValues,
   type RigStage,
   type TrackFx,
+  SHOEGAZE_EFFECTS,
 } from "../../core/fx.ts";
 import {
   instrumentForWord,
@@ -140,7 +141,7 @@ export function parseRigCommand(prompt: string): RigCommand | undefined {
 }
 
 function describeRig(values: Readonly<Record<string, FxValues | undefined>>) {
-  return RIG_STAGES.filter((stage) => values[stage])
+  const stages = RIG_STAGES.filter((stage) => values[stage])
     .map((stage) => {
       const v = values[stage]!;
       const type = String(v.type);
@@ -148,6 +149,9 @@ function describeRig(values: Readonly<Record<string, FxValues | undefined>>) {
       return `${stage} ${type}${gain}`;
     })
     .join(" → ");
+  // 0.6.1 shoegaze stages follow the cab in the chain.
+  const gaze = SHOEGAZE_EFFECTS.filter((effect) => values[effect]);
+  return gaze.length ? `${stages} + ${gaze.join(" ")}` : stages;
 }
 
 export function applyRigCommand(

package/src/commands/sample.ts

@@ -38,7 +38,8 @@ export type SampleCommand =
     }>;
 
 /** A sample control value: a number, a switch, a unit, or null to unset. */
-export type SampleControlValue = number | string | boolean | null;
+export type SampleControlValue =
+  number | string | boolean | null | readonly number[];
 
 /**
  * Per-voice sample controls `/sample set` and `set_sample` change, by
@@ -62,6 +63,12 @@ export const SAMPLE_CONTROLS = Object.freeze({
   bpm: "the sample's own tempo: it follows the song's tempo map",
   fitmode: "how a fitted sample changes time: repitch, beats or tones",
   len: "the window lasts n beats of the song's tempo map",
+  shift: "pitch in semitones (−24..24), length unchanged",
+  formant: "formants in semitones with shift: 0 keeps the voice, off follows",
+  fadeTime: "release fade in seconds (0..2); alias fadeout",
+  fadeInTime: "attack fade in seconds (0..2); alias fadein",
+  vel: "velocity layer lo-hi (MIDI 0-127): plays only for those velocities",
+  rr: "round-robin group name: voices in a group take turns",
 });
 export type SampleControl = keyof typeof SAMPLE_CONTROLS;
 
@@ -70,6 +77,8 @@ const SAMPLE_ALIASES: Readonly<Record<string, string>> = {
   loope: "loopEnd",
   legato: "clip",
   choke: "cut",
+  fadeout: "fadeTime",
+  fadein: "fadeInTime",
 };
 
 function controlName(raw: string): SampleControl | undefined {
@@ -176,6 +185,18 @@ export function setSampleControls(
       continue;
     }
     if (name === "cut" && typeof value === "number") value = `cut${value}`;
+    if (name === "rr" && typeof value === "number") value = `rr${value}`;
+    if (name === "vel" && value !== null) {
+      const range = parseVelocityRange(value);
+      if (!range)
+        return {
+          ok: false,
+          message: "sample · vel needs lo-hi MIDI velocities, e.g. vel 0-63",
+        };
+      next.vel = range;
+      changed.push(`vel ${range[0]}-${range[1]}`);
+      continue;
+    }
     if (value === null) delete next[field];
     else next[field] = value;
     changed.push(`${raw} ${value === null ? "off" : String(value)}`);
@@ -203,10 +224,24 @@ export function setSampleControls(
   return {
     ok: true,
     next: updated,
-    message: `sample · ${trackId}/${voice} · ${changed.join(" · ")}`,
+    message: `sample · ${trackId}/${voice} · ${changed.join(" · ")}${layerHint(updated, trackId, voice)}`,
   };
 }
 
+/** `0-63`, `0..63`, `64` (one velocity) → [lo, hi]; else undefined. */
+export function parseVelocityRange(
+  value: SampleControlValue | readonly number[],
+): [number, number] | undefined {
+  if (Array.isArray(value))
+    return value.length === 2 && value.every((v) => typeof v === "number")
+      ? [value[0] as number, value[1] as number]
+      : undefined;
+  if (typeof value === "number") return [value, value];
+  if (typeof value !== "string") return undefined;
+  const match = value.trim().match(/^(\d{1,3})\s*(?:-|\.\.|,)\s*(\d{1,3})$/);
+  return match ? [Number(match[1]), Number(match[2])] : undefined;
+}
+
 function unquote(value: string): string {
   const quoted = value.match(/^(["'])(.*)\1$/);
   return quoted ? quoted[2]! : value;
@@ -372,6 +407,18 @@ export function freeVoiceName(
   }
 }
 
+/**
+ * One-shot velocity layers swap only within a round-robin group: a kit
+ * voice with `vel` and no `rr` keeps its own pad, so say how to join them.
+ */
+function layerHint(score: TrackScore, trackId: string, voice: string): string {
+  const sampler = score.tracks.find((item) => item.id === trackId)?.sampler;
+  const ref = sampler?.voices[voice];
+  if (sampler?.mode !== "oneshot" || !ref?.vel || ref.rr !== undefined)
+    return "";
+  return ` · one-shot layers share a pad only within an rr group: sample ${voice} rr <group> on each layer`;
+}
+
 export class SamplePlacementError extends Error {}
 
 /**

package/src/commands/shift.ts

@@ -0,0 +1,119 @@
+/**
+ * `shift <semitones> [formant keep|follow|<n>] [<voice>]` and
+ * `fade [in|out] <seconds> [<voice>]` (0.6.1): pitch a sampler voice
+ * without changing its length, and set its fade in and out. They act on
+ * the focused sampler track's voice (named, or its only one) through
+ * `setSampleControls`, so validation and printing stay the sampler's.
+ */
+import type { TrackScore } from "../../core/score.ts";
+import { fitVoice } from "./fit.ts";
+import {
+  setSampleControls,
+  type SampleControlValue,
+  type SetSampleResult,
+} from "./sample.ts";
+
+export type ShiftCommand =
+  | Readonly<{
+      kind: "shift";
+      /** Semitones; null clears shift and formant. */
+      semitones: number | null;
+      /** 0 keeps the formants, null follows the pitch, undefined leaves it. */
+      formant?: number | null;
+      voice?: string;
+    }>
+  | Readonly<{
+      kind: "fade";
+      /** `in` is fadeInTime, `out` fadeTime, `both` sets each. */
+      edge: "in" | "out" | "both";
+      seconds: number | null;
+      voice?: string;
+    }>;
+
+const VOICE = "([a-z][a-z0-9_]{0,31})";
+const NUMBER = "([+-]?\\d+(?:\\.\\d+)?|off|none)";
+
+/** Parse `shift ...` and `fade ...` (with or without the slash). */
+export function parseShiftCommand(command: string): ShiftCommand | undefined {
+  const text = command.trim();
+  const shift = text.match(
+    new RegExp(
+      `^/?shift\\s+${NUMBER}(?:\\s+formant\\s+(keep|follow|[+-]?\\d+(?:\\.\\d+)?))?(?:\\s+(?:voice\\s+)?${VOICE})?$`,
+      "i",
+    ),
+  );
+  if (shift) {
+    const raw = shift[1]!.toLowerCase();
+    const formant = shift[2]?.toLowerCase();
+    return {
+      kind: "shift",
+      semitones: raw === "off" || raw === "none" ? null : Number(raw),
+      ...(formant === undefined
+        ? {}
+        : {
+            formant:
+              formant === "keep"
+                ? 0
+                : formant === "follow"
+                  ? null
+                  : Number(formant),
+          }),
+      ...(shift[3] ? { voice: shift[3].toLowerCase() } : {}),
+    };
+  }
+  const fade = text.match(
+    new RegExp(
+      `^/?fade(?:\\s+(in|out))?\\s+${NUMBER}(?:\\s+(?:voice\\s+)?${VOICE})?$`,
+      "i",
+    ),
+  );
+  if (!fade) return undefined;
+  const raw = fade[2]!.toLowerCase();
+  return {
+    kind: "fade",
+    edge: (fade[1]?.toLowerCase() as "in" | "out" | undefined) ?? "both",
+    seconds: raw === "off" || raw === "none" ? null : Number(raw),
+    ...(fade[3] ? { voice: fade[3].toLowerCase() } : {}),
+  };
+}
+
+/** Apply a parsed `shift` or `fade` to the focused track's voice. */
+export function applyShiftCommand(
+  score: TrackScore,
+  trackId: string,
+  command: ShiftCommand,
+): SetSampleResult {
+  const target = fitVoice(score, trackId, command.voice);
+  if ("error" in target)
+    return {
+      ok: false,
+      message: target.error.replace(/^fit · /, `${command.kind} · `),
+    };
+  const values: Record<string, SampleControlValue> = {};
+  if (command.kind === "shift") {
+    // `shift off` clears the shift and its formant setting. `shift 0`
+    // clears the shift and a kept formant (0, a no-op without a shift) but
+    // keeps a formant move, so `shift 0 formant 3` is a formant-only move
+    // and stepping the shift through 0 keeps a stored formant.
+    if (command.semitones === null) {
+      values.shift = null;
+      values.formant = null;
+    } else {
+      values.shift = command.semitones === 0 ? null : command.semitones;
+      const formant =
+        command.formant !== undefined
+          ? command.formant
+          : score.tracks.find((track) => track.id === trackId)?.sampler?.voices[
+              target.voice
+            ]?.formant;
+      if (command.semitones === 0 && (formant === 0 || formant === null))
+        values.formant = null;
+      else if (command.formant !== undefined) values.formant = command.formant;
+    }
+  } else {
+    const seconds = command.seconds === 0 ? null : command.seconds;
+    if (command.edge !== "out") values.fadeInTime = seconds;
+    if (command.edge !== "in") values.fadeTime = seconds;
+  }
+  return setSampleControls(score, trackId, target.voice, values);
+}

package/src/commands/string.ts

@@ -9,6 +9,9 @@
  *   string <param> off                  back to the preset's value
  *   string reset                        drop the overrides, keep the preset
  *   string off                          back to the track's synth voice
+ *   bowed                               play the cello preset (bowed strings)
+ *   bowed <preset>                      a bowed preset (violin viola cello …)
+ *   bowed presets                       the bowed presets
  *
  * `string sitar`, `string buzz 0.8 sym 0.5`, `string ring 6`. Each command
  * is one `updateTrack` revision and one undo step.
@@ -20,6 +23,8 @@ import {
   type TrackScore,
 } from "../../core/score.ts";
 import {
+  BOWED_PRESET_NAMES,
+  DEFAULT_BOWED_PRESET,
   DEFAULT_STRING_PRESET,
   isStringTrack,
   normalizeString,
@@ -37,7 +42,7 @@ import { parseParamValue } from "./fx.ts";
 
 export type StringCommand =
   | { type: "string-list" }
-  | { type: "string-presets" }
+  | { type: "string-presets"; bowed?: boolean }
   | { type: "string-reset" }
   | { type: "string-off" }
   | { type: "string-preset"; preset: string }
@@ -49,6 +54,7 @@ export type StringCommand =
 
 export function parseStringCommand(prompt: string): StringCommand | undefined {
   const words = prompt.trim().split(/\s+/);
+  if (words[0]?.toLowerCase() === "bowed") return parseBowed(words.slice(1));
   if (words[0]?.toLowerCase() !== "string") return undefined;
   if (words.length === 1) return { type: "string-list" };
   if (prompt.length > 1_024) return undefined;
@@ -82,6 +88,26 @@ export function parseStringCommand(prompt: string): StringCommand | undefined {
   return { type: "string-set", values };
 }
 
+/**
+ * `bowed` (0.6.1): the string engine's bowed family. `bowed` plays cello,
+ * `bowed <preset>` a bowed preset, `bowed presets` lists them, and
+ * `bowed <param> <value>…` is `string <param> <value>…`.
+ */
+function parseBowed(words: string[]): StringCommand | undefined {
+  if (words.length === 0)
+    return { type: "string-preset", preset: DEFAULT_BOWED_PRESET };
+  const rest = words.map((word) => word.toLowerCase());
+  if (rest.length === 1 && (rest[0] === "presets" || rest[0] === "list"))
+    return { type: "string-presets", bowed: true };
+  if (rest.length === 1) {
+    const preset = stringPresetName(rest[0]!);
+    return preset && BOWED_PRESET_NAMES.includes(preset)
+      ? { type: "string-preset", preset }
+      : undefined;
+  }
+  return parseStringCommand(`string ${rest.join(" ")}`);
+}
+
 /** `sitar · buzz 0.8 · sym 0.5`, or `nylon` for a bare preset. */
 export function describeString(settings: TrackString | undefined): string {
   const parts = [stringPresetOf(settings)];
@@ -108,7 +134,7 @@ export function applyStringCommand(
   if (command.type === "string-presets")
     return {
       ok: true,
-      message: `string presets · ${STRING_PRESET_NAMES.map((name) => `${name} (${STRING_PRESETS[name]!.doc})`).join(" · ")}`,
+      message: `${command.bowed ? "bowed" : "string"} presets · ${(command.bowed ? BOWED_PRESET_NAMES : STRING_PRESET_NAMES).map((name) => `${name} (${STRING_PRESETS[name]!.doc})`).join(" · ")}`,
     };
   if (track.sampler || track.kit)
     return {