@hraness/dawg 0.6.1 → 0.8.0

package/src/tui/tape-view.ts

@@ -0,0 +1,263 @@
+/**
+ * The TAPE view model: a score, the playhead and this pane's state become
+ * the cells tui/tape.ts paints. Density per cell is the notes starting in
+ * it, weighted by velocity (` ▁▂▃▄▅▆▇█`); a held note shows `▁` across the
+ * cells it sustains through, and an audio clip `▃` where it plays.
+ *
+ * With a form the tape is drawn unrolled (op1-ux §4): every pass in play
+ * order, the first pass of each section solid and every later one ghosted
+ * `░`. Each cell keeps the score bar it shows, so a click, a drag or a
+ * gesture on a ghost acts on the source section.
+ */
+import { formPositionAt, formSegments } from "../../core/sections.ts";
+import type { TrackScore } from "../../core/score.ts";
+import { barStartTick, bpmAtTick } from "../../core/tempo.ts";
+import type { KnobIndex } from "../../tui/knobs.ts";
+import type {
+  TapeRow,
+  TapeSection,
+  TapeView,
+  TapeZoom,
+} from "../../tui/tape.ts";
+import {
+  barOfBeat,
+  clipboardLabel,
+  formPasses,
+  loopRange,
+  rangeLine,
+  tapeKnobs,
+  TAPE_HINT,
+  type TapeContext,
+} from "./tape-mode.ts";
+
+export type TapeViewInput = TapeContext &
+  Readonly<{
+    zoom: TapeZoom;
+    selected: KnobIndex;
+    /** Other panes on a track (§12.7): `B`, `C●`. */
+    marks: (trackId: string) => string;
+    /**
+     * Transport beat (arranged time), for the playhead on an unrolled form:
+     * which pass it is in. Absent, the playhead sits on the first pass.
+     */
+    transportBeat?: number | undefined;
+  }>;
+
+/** One drawn cell on an unrolled form: a score cell, its pass, a ghost. */
+type Unrolled = Readonly<{ cell: number; segment: number; ghost: boolean }>;
+
+/** The form in play order as score cells; undefined without a form. */
+function unroll(
+  score: TrackScore,
+  bars: readonly number[],
+): Unrolled[] | undefined {
+  const segments = formSegments(score);
+  if (segments.length === 0) return undefined;
+  const firstCellOf = new Map<number, number>();
+  bars.forEach((bar, index) => {
+    if (!firstCellOf.has(bar)) firstCellOf.set(bar, index);
+  });
+  const seen = new Set<string>();
+  const cells: Unrolled[] = [];
+  segments.forEach((segment, index) => {
+    const ghost = seen.has(segment.section.name);
+    seen.add(segment.section.name);
+    const from = firstCellOf.get(segment.section.startBar);
+    if (from === undefined) return;
+    const end = segment.section.startBar + segment.section.bars;
+    for (let cell = from; cell < bars.length && bars[cell]! < end; cell += 1)
+      cells.push({ cell, segment: index, ghost });
+  });
+  // Bars the form never plays stay reachable, after it, in score order.
+  const played = new Set(cells.map((item) => item.cell));
+  bars.forEach((_, cell) => {
+    if (!played.has(cell)) cells.push({ cell, segment: -1, ghost: false });
+  });
+  return cells;
+}
+
+/** Cell start ticks and the bar each cell is in, for a zoom. */
+export function tapeCells(
+  score: TrackScore,
+  zoom: TapeZoom,
+): { starts: number[]; bars: number[] } {
+  const starts: number[] = [];
+  const bars: number[] = [];
+  for (let bar = 0; bar < score.bars; bar += 1) {
+    const from = barStartTick(score, bar);
+    const to = barStartTick(score, bar + 1);
+    const step =
+      zoom === "bar"
+        ? to - from
+        : zoom === "beat"
+          ? score.ticksPerBeat
+          : score.ticksPerBeat / 2;
+    for (let tick = from; tick < to - 1e-6; tick += step) {
+      starts.push(tick);
+      bars.push(bar);
+    }
+  }
+  return { starts, bars };
+}
+
+function cellAt(starts: readonly number[], tick: number): number {
+  let low = 0;
+  let high = starts.length - 1;
+  if (high < 0 || tick < starts[0]!) return -1;
+  while (low < high) {
+    const mid = (low + high + 1) >> 1;
+    if (starts[mid]! <= tick) low = mid;
+    else high = mid - 1;
+  }
+  return low;
+}
+
+/** Density levels (0…8) per cell for one track. */
+export function trackLevels(
+  score: TrackScore,
+  trackId: string,
+  starts: readonly number[],
+  end: number,
+): number[] {
+  const weight = starts.map(() => 0);
+  const held = starts.map(() => false);
+  for (const note of score.notes) {
+    if (note.trackId !== trackId || note.startTick >= end) continue;
+    const cell = cellAt(starts, note.startTick);
+    if (cell < 0) continue;
+    weight[cell]! += Math.max(0.15, note.velocity);
+    const last = cellAt(
+      starts,
+      Math.min(end - 1, note.startTick + note.durationTicks - 1),
+    );
+    for (let index = cell + 1; index <= last; index += 1) held[index] = true;
+  }
+  const track = score.tracks.find((item) => item.id === trackId);
+  for (const clip of track?.clips ?? []) {
+    const first = cellAt(starts, clip.startTick);
+    if (first < 0) continue;
+    const length =
+      clip.dur !== undefined
+        ? clip.dur *
+          (bpmAtTick(score, clip.startTick) / 60) *
+          score.ticksPerBeat
+        : starts.length > first + 1
+          ? starts[first + 1]! - starts[first]!
+          : 0;
+    const last = cellAt(starts, Math.min(end - 1, clip.startTick + length - 1));
+    for (let index = first; index <= last; index += 1)
+      weight[index] = Math.max(weight[index]!, 1);
+  }
+  return weight.map((value, index) =>
+    value > 0
+      ? Math.max(1, Math.min(8, Math.ceil(value * 3)))
+      : held[index]
+        ? 1
+        : 0,
+  );
+}
+
+export function tapeView(input: TapeViewInput): TapeView {
+  const score = input.score;
+  const { starts, bars } = tapeCells(score, input.zoom);
+  const end = barStartTick(score, score.bars);
+  const tick = Math.max(0, Math.round(input.beat * score.ticksPerBeat));
+  const scoreHead = Math.max(0, cellAt(starts, Math.min(end - 1, tick)));
+  const unrolled = unroll(score, bars);
+  // The pass under the transport, so the playhead walks through ghosts.
+  const pass =
+    unrolled && input.transportBeat !== undefined
+      ? formPositionAt(score, input.transportBeat).index
+      : undefined;
+  const inPass = unrolled?.findIndex(
+    (item) =>
+      item.cell === scoreHead && (pass === undefined || item.segment === pass),
+  );
+  const playheadCell = unrolled
+    ? Math.max(
+        0,
+        inPass !== undefined && inPass >= 0
+          ? inPass
+          : unrolled.findIndex((item) => item.cell === scoreHead),
+      )
+    : scoreHead;
+  // A section the form plays more than once shows `×N` after its name.
+  const passes = formPasses(score);
+  const named = (name: string): string => {
+    const times = passes.get(name) ?? 1;
+    return times > 1 ? `${name} ×${times}` : name;
+  };
+  const sections: TapeSection[] = score.sections.map((section) => ({
+    name: named(section.name),
+    startBar: section.startBar,
+    bars: section.bars,
+  }));
+  const loopSection =
+    score.loop === undefined && score.loopSection !== undefined
+      ? sections.find((section) => section.name.startsWith(score.loopSection!))
+          ?.name
+      : undefined;
+  const tempo = [...(score.time?.tempo ?? [])]
+    .filter((event) => event.tick > 0 && event.tick < end)
+    .sort((a, b) => a.tick - b.tick);
+  const pick = <T>(values: readonly T[]): T[] =>
+    unrolled ? unrolled.map((item) => values[item.cell]!) : [...values];
+  const rows: TapeRow[] = score.tracks.map((track) => ({
+    id: track.id,
+    name: track.name,
+    muted: track.muted,
+    levels: pick(trackLevels(score, track.id, starts, end)),
+    marks: input.marks(track.id).trim(),
+  }));
+  // Tempo marks land on the cell their tick starts (the first pass).
+  const tempoCell = (at: number): number => {
+    const cell = Math.max(0, cellAt(starts, at));
+    return unrolled
+      ? Math.max(
+          0,
+          unrolled.findIndex((item) => item.cell === cell),
+        )
+      : cell;
+  };
+  const focused = Math.max(
+    0,
+    score.tracks.findIndex((track) => track.id === input.trackId),
+  );
+  return {
+    bars: score.bars,
+    cellBars: pick(bars),
+    ...(unrolled
+      ? {
+          ghosts: unrolled.map((item) => item.ghost),
+          passes: unrolled.map((item) => item.segment),
+          passNames: formSegments(score).map((segment) =>
+            named(segment.section.name),
+          ),
+        }
+      : {}),
+    playheadCell,
+    loop: loopRange(score),
+    sections,
+    loopSection,
+    tempo:
+      tempo.length > 0
+        ? [
+            { cell: 0, bpm: Math.round(score.tempoBpm) },
+            ...tempo.map((event) => ({
+              cell: tempoCell(event.tick),
+              bpm: Math.round(event.bpm),
+            })),
+          ]
+        : [],
+    rows,
+    focused,
+    range: rangeLine(input),
+    clipboard: clipboardLabel(score, input.clipboard),
+    knobs: tapeKnobs(input),
+    selected: input.selected,
+    hint: TAPE_HINT,
+  };
+}
+
+/** The playhead's bar, for the header (`5.3`) callers. */
+export { barOfBeat };

package/src/tui/vocoder-menu.ts

@@ -0,0 +1,244 @@
+/**
+ * Ctrl-k rows for the vocoder (0.7, vocoder.md §8): Effects › Voice ›
+ * Vocoder (Source picker, Preset, one row per VOCODER_PARAMS key in table
+ * order) and Voice › voice presets › Vocoder. Every row runs a
+ * `vocoder …` command, so it stages for the audition loop like any other.
+ */
+import type { NumberParam } from "../../core/params.ts";
+import type { Track } from "../../core/score.ts";
+import {
+  DEFAULT_VOCODER_PRESET,
+  VOCODER_INSTRUMENT,
+  VOCODER_PARAMS,
+  VOCODER_PRESETS,
+  VOCODER_PRESET_NAMES,
+  resolveVocoder,
+  vocoderPresetOf,
+  type TrackVocoder,
+} from "../../core/vocoder.ts";
+import {
+  vocoderEntryLines,
+  trackHasAudio,
+  vocoderCandidates,
+} from "../commands/vocoder.ts";
+import { num, specStep, type MenuContext, type MenuNode } from "./menu.ts";
+
+const NONE = "none";
+
+function trackOf(context: MenuContext): Track | undefined {
+  return context.score.tracks.find((track) => track.id === context.trackId);
+}
+
+/** One row per VOCODER_PARAMS key; x and `preset` return it to the preset. */
+function paramRow(vocoder: TrackVocoder, name: string): MenuNode {
+  const spec = VOCODER_PARAMS[name]!;
+  const own = (vocoder as Record<string, unknown>)[name];
+  const preset = vocoderPresetOf(vocoder);
+  const fallback = (VOCODER_PRESETS[preset].values as Record<string, unknown>)[
+    name
+  ];
+  const resolved = (resolveVocoder(vocoder) as Record<string, unknown>)[name];
+  if (spec.kind === "enum")
+    return {
+      kind: "choice",
+      label: name,
+      value: own === undefined ? "preset" : String(own),
+      options: ["preset", ...spec.values],
+      command: (option) =>
+        option === "preset"
+          ? `vocoder ${name} reset`
+          : `vocoder ${name} ${option}`,
+      help: `${spec.doc} · preset ${String(resolved)}`,
+    };
+  if (spec.kind === "boolean")
+    return {
+      kind: "choice",
+      label: name,
+      value: own === undefined ? "preset" : own ? "on" : "off",
+      options: ["preset", "on", "off"],
+      command: (option) =>
+        option === "preset"
+          ? `vocoder ${name} reset`
+          : `vocoder ${name} ${option}`,
+      help: `${spec.doc} · preset ${fallback ? "on" : "off"}`,
+    };
+  const number = spec as NumberParam;
+  // gate's preset value is "auto" (from the source's assets): show it as off.
+  const value = typeof resolved === "number" ? resolved : undefined;
+  return {
+    kind: "number",
+    label: name,
+    value,
+    min: number.min,
+    max: number.max,
+    step: specStep(number),
+    format: (v) => (number.unit ? `${num(v)} ${number.unit}` : num(v)),
+    command: (v) => `vocoder ${name} ${num(v)}`,
+    reset: `vocoder ${name} reset`,
+    ...(value === undefined ? { off: "auto", start: number.min } : {}),
+    help: `${number.doc} · preset ${typeof fallback === "number" ? num(fallback) : String(resolved ?? "auto")} · x resets`,
+  };
+}
+
+/** A source as the picker shows it: its name, or its id when names clash. */
+function sourceLabel(track: Track, all: readonly Track[]): string {
+  const clash = all.some((t) => t.id !== track.id && t.name === track.name);
+  return clash || !track.name.trim() ? track.id : track.name;
+}
+
+/** `vocoder src <name>`, quoted when the name has spaces. */
+function srcCommand(label: string): string {
+  return /\s/.test(label) ? `vocoder src "${label}"` : `vocoder src ${label}`;
+}
+
+function entryRows(): MenuNode[] {
+  return vocoderEntryLines().map((line, index) => ({
+    kind: "info",
+    label: index === 0 ? "no voice yet" : "",
+    value: line.trim(),
+  }));
+}
+
+/** The rows inside Effects › Voice › Vocoder for the focused track. */
+export function vocoderRows(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  if (!track || track.instrument === "kit") return [];
+  const vocoder = track.vocoder;
+  const candidates = vocoderCandidates(context.score, track.id);
+  const all = context.score.tracks;
+  if (!vocoder) {
+    if (trackHasAudio(track))
+      return [
+        {
+          kind: "action",
+          label: "vocode",
+          command: "vocoder",
+          help: "adds a vocoder track driven by this voice (follows the song's chords, or drones on the key's root); mutes it",
+        },
+      ];
+    if (candidates.length === 0) return entryRows();
+    return [
+      {
+        kind: "choice",
+        label: "source",
+        value: NONE,
+        options: [NONE, ...candidates.map((t) => sourceLabel(t, all))],
+        command: (option) =>
+          option === NONE ? "vocoder off" : srcCommand(option),
+        help: "the voice that shapes this track's sound",
+      },
+    ];
+  }
+  const others = context.score.tracks.filter(
+    (t) => t.id !== track.id && t.instrument !== "kit",
+  );
+  const options = [
+    ...candidates.map((t) => sourceLabel(t, all)),
+    ...others
+      .filter((t) => !candidates.some((c) => c.id === t.id))
+      .map((t) => sourceLabel(t, all)),
+  ];
+  const current = all.find((t) => t.id === vocoder.src);
+  const nodes: MenuNode[] = [
+    {
+      kind: "choice",
+      label: "source",
+      value: current ? sourceLabel(current, all) : (vocoder.src ?? NONE),
+      options: vocoder.src === undefined ? [NONE, ...options] : options,
+      command: (option) => (option === NONE ? "vocoder" : srcCommand(option)),
+      help: "the modulator; it is heard through the vocoder even when muted",
+    },
+    {
+      kind: "choice",
+      label: "preset",
+      value: vocoder.preset ?? DEFAULT_VOCODER_PRESET,
+      options: VOCODER_PRESET_NAMES,
+      command: (option) => `vocoder preset ${option}`,
+      help: "classic robot talkbox choir glass whisper smear lofi · keeps your overrides",
+    },
+    ...Object.keys(VOCODER_PARAMS).map((name) => paramRow(vocoder, name)),
+  ];
+  if (Object.keys(vocoder).some((key) => key !== "preset" && key !== "src"))
+    nodes.push({
+      kind: "action",
+      label: "reset to preset",
+      command: "vocoder reset",
+      help: "clear overrides, keep the source and preset",
+    });
+  nodes.push({
+    kind: "action",
+    label: "remove the vocoder",
+    command: "vocoder off",
+    help: "the track plays its own sound again",
+  });
+  return nodes;
+}
+
+/** Effects › Voice › Vocoder. */
+export function vocoderEffectNode(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  if (!track || track.instrument === "kit") return [];
+  const vocoder = track.vocoder;
+  return [
+    {
+      kind: "menu",
+      id: "voice:vocoder",
+      label: "vocoder",
+      detail: vocoder
+        ? `${vocoder.preset ?? DEFAULT_VOCODER_PRESET}${vocoder.src ? ` · from ${vocoder.src}` : " · no source"}`
+        : trackHasAudio(track)
+          ? "vocode"
+          : "off",
+      help: "a voice shapes this track's sound: robot, talkbox, choir",
+      build: vocoderRows,
+    },
+  ];
+}
+
+/** Voice › voice presets › Vocoder: the built-in carrier. */
+export function vocoderBrowseNode(context: MenuContext): MenuNode[] {
+  const track = trackOf(context);
+  return [
+    {
+      kind: "menu",
+      id: "voices:vocoder",
+      label: "vocoder",
+      detail: `${VOCODER_PRESET_NAMES.length} presets · robot, talkbox, choir …`,
+      help: "a built-in synth carrier spoken through a voice track",
+      build: (inner) => {
+        const here = trackOf(inner) ?? track;
+        if (here && trackHasAudio(here))
+          return [
+            {
+              kind: "action",
+              label: "vocode",
+              command: "vocoder",
+              help: "adds a vocoder track driven by this voice",
+            },
+          ];
+        if (here?.instrument !== VOCODER_INSTRUMENT)
+          return [
+            {
+              kind: "action",
+              label: "make a vocoder",
+              command: `instrument ${VOCODER_INSTRUMENT}`,
+              help: "a supersaw carrier; then pick its presets and source here",
+            },
+            ...(vocoderCandidates(inner.score, inner.trackId).length === 0
+              ? entryRows()
+              : []),
+          ];
+        return VOCODER_PRESET_NAMES.map((name): MenuNode => ({
+          kind: "action",
+          label: `${name.padEnd(8)} ${VOCODER_PRESETS[name].doc}`,
+          command: `vocoder ${name}`,
+          help: VOCODER_PRESETS[name].doc,
+        })).concat(
+          vocoderCandidates(inner.score, inner.trackId).length === 0
+            ? entryRows()
+            : vocoderRows(inner).filter((row) => row.label === "source"),
+        );
+      },
+    },
+  ];
+}

package/src/tui/wind-menu.ts

@@ -1,6 +1,6 @@
 /**
  * Ctrl-k menu rows for the wind engine (0.6.1): the "Winds and brass" group
- * under Sound › browse sounds, and the WIND_PARAMS rows under Sound ›
+ * under Sound › instruments, and the WIND_PARAMS rows under Sound ›
  * Parameters on a wind-engine track. Every row runs a `wind …` command.
  */
 import type { EnumParam, NumberParam } from "../../core/params.ts";
@@ -27,12 +27,12 @@ function presetRow(name: WindPresetName): MenuNode {
   };
 }
 
-/** Sound › browse sounds › Winds and brass: flutes, reeds, brass. */
+/** Sound › instruments › winds and brass: flutes, reeds, brass. */
 export function windsMenu(): MenuNode {
   return {
     kind: "menu",
     id: "winds",
-    label: "Winds and brass",
+    label: "winds and brass",
     detail: `${WIND_PRESET_NAMES.length} blown · flute, sax, trumpet …`,
     help: "breath-driven waveguides: flutes, reeds and brass; wind players 4 for a section",
     build: () =>

package/src/version.ts

@@ -0,0 +1,8 @@
+/**
+ * The package version, read from package.json by a static JSON import so
+ * `bun build --compile` embeds it: a runtime read relative to
+ * import.meta.url finds nothing inside a compiled binary.
+ */
+import pkg from "../package.json" with { type: "json" };
+
+export const VERSION: string = pkg.version;