@hraness/dawg 0.6.1 → 0.8.0

package/src/audio/clips.ts

@@ -0,0 +1,240 @@
+/**
+ * Audio clips (0.7): files placed on a track's timeline, summed into the
+ * track's dry buffer before its effect chain (sources.md section 7). The
+ * pure placement and section cuts live in core/clips.ts; this module reads
+ * the decoded audio, places it through the tempo map, resamples it to the
+ * render rate (4-point Hermite), applies the take's clock-drift stretch,
+ * reverse, gain and equal-power fades, and multiplies by the track's
+ * volume the way every voice does. A clip whose audio did not load renders
+ * silence (the loader reported it as a warning).
+ */
+import {
+  CLIP_VOICE_PREFIX,
+  DEFAULT_CLIP_FADE,
+  clipSongTick,
+  resolveClipLengths,
+} from "../../core/clips.ts";
+import type { AudioClip, Take, Track, TrackScore } from "../../core/score.ts";
+import { autotuneClip } from "./autotune.ts";
+import { sampleKey, type DecodedSample, type SampleBank } from "./samples.ts";
+import type { SampleWarp } from "./warp.ts";
+
+/** What clip rendering reads of the render context. */
+export type ClipContext = Readonly<{
+  sampleRate: number;
+  samples: number;
+  samplesPerTick: number;
+  warp?: SampleWarp;
+}>;
+
+/** True when a track has clips that sound. */
+export function hasClips(track: Track | undefined): boolean {
+  return track?.clips?.some((clip) => !clip.mute) ?? false;
+}
+
+/** The decoded audio of a clip, if it loaded. */
+export function clipAudio(
+  bank: SampleBank | undefined,
+  trackId: string,
+  clip: AudioClip,
+): DecodedSample | undefined {
+  if (!bank) return undefined;
+  const exact = bank.voices.get(
+    sampleKey(trackId, `${CLIP_VOICE_PREFIX}${clip.id}`),
+  );
+  if (exact) return exact;
+  // A section or form pass of a clip is `<id>~<n>`: it plays the audio
+  // the bank loaded for `<id>` from the unsliced score.
+  const pass = clip.id.lastIndexOf("~");
+  return pass > 0
+    ? bank.voices.get(
+        sampleKey(trackId, `${CLIP_VOICE_PREFIX}${clip.id.slice(0, pass)}`),
+      )
+    : undefined;
+}
+
+/**
+ * `score` with each loaded clip's missing `dur` resolved from its file
+ * (`resolveClipLengths`), so section, form and window cuts see its real
+ * end. A score without clips, or without a bank, comes back as it is.
+ */
+export function withClipLengths(
+  score: TrackScore,
+  bank: SampleBank | undefined,
+): TrackScore {
+  if (!bank || !score.tracks.some((track) => track.clips)) return score;
+  return resolveClipLengths(score, (trackId, clip) => {
+    const audio = clipAudio(bank, trackId, clip);
+    return audio && audio.frames > 0
+      ? audio.frames / audio.sampleRate
+      : undefined;
+  });
+}
+
+/** Fractional render sample where a score tick sounds. */
+function sampleAt(context: ClipContext, tick: number): number {
+  return context.warp
+    ? context.warp.sample(tick)
+    : tick * context.samplesPerTick;
+}
+
+/** The take a clip plays from, if any. */
+function takeOf(track: Track, clip: AudioClip): Take | undefined {
+  if (clip.take === undefined) return undefined;
+  return track.takes?.find((take) => take.name === clip.take);
+}
+
+/** Catmull-Rom (4-point Hermite) read at a fractional frame, 0 outside. */
+function readHermite(data: Float32Array, position: number): number {
+  const base = Math.floor(position);
+  const t = position - base;
+  const at = (index: number) =>
+    index >= 0 && index < data.length ? data[index]! : 0;
+  const y0 = at(base - 1);
+  const y1 = at(base);
+  const y2 = at(base + 1);
+  const y3 = at(base + 2);
+  const c1 = 0.5 * (y2 - y0);
+  const c2 = y0 - 2.5 * y1 + 2 * y2 - 0.5 * y3;
+  const c3 = 0.5 * (y3 - y0) + 1.5 * (y1 - y2);
+  return ((c3 * t + c2) * t + c1) * t + y1;
+}
+
+/** Equal-power fade gain for `x` in 0..1 (sin of a quarter turn). */
+export function equalPowerFade(x: number): number {
+  if (x <= 0) return 0;
+  if (x >= 1) return 1;
+  return Math.sin((x * Math.PI) / 2);
+}
+
+/**
+ * Sum `track`'s clips into `target` (the mono dry buffer). `gainAt(tick)`
+ * is the track volume with automation; `tickAt(sample)` maps a render
+ * sample back to a score tick for it. Returns the clips that did not
+ * load (they stay silent). With `score` and a `Track.autotune` (0.7), each
+ * clip plays retuned (`autotuneClip`, keyed by its offset and nudge);
+ * reversed clips play untuned.
+ */
+export function renderClips(
+  target: Float64Array,
+  track: Track,
+  context: ClipContext,
+  bank: SampleBank | undefined,
+  gainAt: (tick: number) => number,
+  score?: TrackScore,
+): string[] {
+  const missing: string[] = [];
+  if (!track.clips) return missing;
+  const { sampleRate, samples } = context;
+  const tickAt = (index: number) =>
+    context.warp ? context.warp.tick(index) : index / context.samplesPerTick;
+  for (const clip of track.clips) {
+    if (clip.mute) continue;
+    const audio = clipAudio(bank, track.id, clip);
+    if (!audio || audio.frames === 0) {
+      missing.push(clip.id);
+      continue;
+    }
+    const take = takeOf(track, clip);
+    // A take recorded on a drifting clock (`ppm`) plays slightly faster or
+    // slower so it stays on the grid; `nudge` moves it in milliseconds.
+    const drift = 1 + (take?.ppm ?? 0) / 1e6;
+    const nudge = (take?.nudge ?? 0) / 1000;
+    const fileSeconds = audio.frames / audio.sampleRate;
+    const offset = Math.min(fileSeconds, clip.offset ?? 0);
+    const length = Math.max(
+      0,
+      Math.min(
+        clip.dur ?? Number.POSITIVE_INFINITY,
+        (fileSeconds - offset) / drift,
+      ),
+    );
+    if (length <= 0) continue;
+    const start =
+      sampleAt(context, clipSongTick(clip, track.time)) + nudge * sampleRate;
+    const total = length * sampleRate;
+    const first = Math.max(0, Math.ceil(start));
+    const last = Math.min(samples, Math.ceil(start + total));
+    if (first >= last) continue;
+    const step = (audio.sampleRate / sampleRate) * drift;
+    const begin = offset * audio.sampleRate;
+    const span = length * audio.sampleRate * drift;
+    const fadeIn = Math.min(clip.fadeInTime ?? DEFAULT_CLIP_FADE, length / 2);
+    const fadeOut = Math.min(clip.fadeTime ?? DEFAULT_CLIP_FADE, length / 2);
+    const fadeInFrames = fadeIn * sampleRate;
+    const fadeOutFrames = fadeOut * sampleRate;
+    const gain = clip.gain ?? 1;
+    // 0.7 autotune: the clip's audio retuned at the song second its
+    // offset sounds (`start` already holds the nudge).
+    const tuned =
+      track.autotune && score && !clip.rev
+        ? autotuneClip(
+            score,
+            track,
+            {
+              sha256: audio.sha256,
+              sampleRate: audio.sampleRate,
+              mono: audio.mono,
+            },
+            start / sampleRate,
+            offset,
+            clip.id,
+            0,
+            nudge,
+          )
+        : undefined;
+    const data = tuned ? tuned.mono : audio.mono;
+    const shiftFrom = tuned ? tuned.from : 0;
+    // Track volume (with automation) is read once per 32-sample block.
+    let blockGain = 0;
+    for (let index = first; index < last; index += 1) {
+      if ((index - first) % 32 === 0) blockGain = gainAt(tickAt(index));
+      const elapsed = index - start;
+      let position = elapsed * step;
+      if (position >= span) break;
+      position = clip.rev ? begin + span - 1 - position : begin + position;
+      let shape = gain * blockGain;
+      if (fadeInFrames > 0 && elapsed < fadeInFrames)
+        shape *= equalPowerFade(elapsed / fadeInFrames);
+      const remaining = total - elapsed;
+      if (fadeOutFrames > 0 && remaining < fadeOutFrames)
+        shape *= equalPowerFade(remaining / fadeOutFrames);
+      target[index]! += readHermite(data, position - shiftFrom) * shape;
+    }
+  }
+  return missing;
+}
+
+/**
+ * Stem-cache key part for a track's clips: each clip's sha256 (the one
+ * loaded, so an edited file re-renders), placement, cut, gain, fades and
+ * reverse, and the drift of the take it plays from.
+ */
+export function clipsDigest(
+  track: Track,
+  bank: SampleBank | undefined,
+  guide = false,
+): string | undefined {
+  if (!track.clips || track.clips.length === 0) return undefined;
+  return (
+    (guide ? "guide|" : "") +
+    track.clips
+      .map((clip) => {
+        const take = takeOf(track, clip);
+        return [
+          clip.id,
+          clipAudio(bank, track.id, clip)?.sha256 ?? `missing:${clip.sha256}`,
+          clip.startTick,
+          clip.offset ?? "",
+          clip.dur ?? "",
+          clip.gain ?? "",
+          clip.fadeInTime ?? "",
+          clip.fadeTime ?? "",
+          clip.rev ? "r" : "",
+          clip.mute ? "m" : "",
+          take ? `${take.ppm ?? 0}/${take.nudge ?? 0}` : "",
+        ].join(",");
+      })
+      .join(";")
+  );
+}

package/src/audio/devices.ts

@@ -0,0 +1,264 @@
+/**
+ * The audio menu's one output and one input, saved per machine in
+ * `<config>/audio.json` (never in the project: a song moves between
+ * machines, its speakers do not). `DAWG_AUDIO_DEVICE` still overrides the
+ * output. Choosing a device needs the native sink, which lists and opens
+ * devices by name; sox can play on a named output (AUDIODEV) but cannot
+ * list them; ffplay and afplay always use the system default.
+ */
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { configDir } from "../auth/credentials.ts";
+import type { AudioBackendInfo } from "./engine.ts";
+import { NativeCapture, type SinkDevice, type SinkLibrary } from "./native.ts";
+
+export type AudioChoice = Readonly<{
+  /** Output device name; absent is the system default. */
+  output?: string;
+  /** Input device name; absent is the system default. */
+  input?: string;
+}>;
+
+const MAX_NAME = 200;
+
+export function audioChoicePath(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+): string {
+  return join(configDir(env), "audio.json");
+}
+
+function cleanName(value: unknown): string | undefined {
+  if (typeof value !== "string") return undefined;
+  const name = value.trim();
+  return name && name.length <= MAX_NAME && name.toLowerCase() !== "default"
+    ? name
+    : undefined;
+}
+
+/** The saved choice; a missing or malformed file is the defaults. */
+export function readAudioChoice(path = audioChoicePath()): AudioChoice {
+  try {
+    const parsed: unknown = JSON.parse(readFileSync(path, "utf8"));
+    if (typeof parsed !== "object" || parsed === null) return {};
+    const record = parsed as Record<string, unknown>;
+    const output = cleanName(record.output);
+    const input = cleanName(record.input);
+    return { ...(output ? { output } : {}), ...(input ? { input } : {}) };
+  } catch {
+    return {};
+  }
+}
+
+/** Save one side of the choice (undefined is the system default). */
+export function writeAudioChoice(
+  side: "output" | "input",
+  name: string | undefined,
+  path = audioChoicePath(),
+): AudioChoice {
+  const current = readAudioChoice(path);
+  const next: Record<string, string> = { ...current };
+  const clean = cleanName(name);
+  if (clean) next[side] = clean;
+  else delete next[side];
+  mkdirSync(join(path, ".."), { recursive: true });
+  const temp = `${path}.${process.pid}.tmp`;
+  writeFileSync(temp, `${JSON.stringify({ version: 1, ...next }, null, 2)}\n`);
+  renameSync(temp, path);
+  return next;
+}
+
+/** The output the engine opens: DAWG_AUDIO_DEVICE, then the saved choice. */
+export function resolveOutputDevice(
+  env: Readonly<Record<string, string | undefined>> = process.env,
+  choice: AudioChoice = readAudioChoice(audioChoicePath(env)),
+): string | undefined {
+  return cleanName(env.DAWG_AUDIO_DEVICE) ?? choice.output;
+}
+
+/** What the backend can do with a device choice. */
+export type DeviceSupport =
+  | Readonly<{ kind: "native"; library: SinkLibrary }>
+  | Readonly<{ kind: "sox" }>
+  | Readonly<{ kind: "none"; reason: string }>;
+
+export function deviceSupport(info: AudioBackendInfo): DeviceSupport {
+  if (info.backend === "native" && info.native)
+    return { kind: "native", library: info.native };
+  if (info.backend === "sox") return { kind: "sox" };
+  const why = info.nativeUnavailable ?? info.detail;
+  const player =
+    info.backend === "none"
+      ? "audio is off"
+      : `${info.backend} plays on the system default`;
+  return {
+    kind: "none",
+    reason: `device choice needs the native sink, which lists and opens devices by name · ${player} · native sink: ${why}`,
+  };
+}
+
+/** Device names on the native sink; empty when enumeration fails. */
+export function listDevices(
+  library: SinkLibrary,
+  input: boolean,
+): SinkDevice[] {
+  try {
+    return library.devices(input);
+  } catch {
+    return [];
+  }
+}
+
+export type AudioCommand =
+  | Readonly<{ kind: "show" }>
+  | Readonly<{
+      kind: "set";
+      side: "output" | "input";
+      name: string | undefined;
+    }>
+  | Readonly<{ kind: "test" }>;
+
+/**
+ * `audio`, `audio out <name|default>`, `audio in <name|default>`,
+ * `audio test`. Undefined when the words do not parse.
+ */
+export function parseAudioCommand(text: string): AudioCommand | undefined {
+  const words = text.trim();
+  if (!words) return { kind: "show" };
+  if (/^test$/i.test(words)) return { kind: "test" };
+  const set = words.match(/^(out|output|in|input)\s+(.+)$/i);
+  if (!set) return undefined;
+  const name = set[2]!.trim();
+  if (name.length > MAX_NAME) return undefined;
+  return {
+    kind: "set",
+    side: set[1]!.toLowerCase().startsWith("o") ? "output" : "input",
+    name: name.toLowerCase() === "default" ? undefined : name,
+  };
+}
+
+/** Match a typed name to a listed device: exact, then case-insensitive, then prefix. */
+export function matchDevice(
+  devices: readonly SinkDevice[],
+  name: string,
+): SinkDevice | undefined {
+  const lower = name.toLowerCase();
+  return (
+    devices.find((device) => device.name === name) ??
+    devices.find((device) => device.name.toLowerCase() === lower) ??
+    (() => {
+      const prefixed = devices.filter((device) =>
+        device.name.toLowerCase().startsWith(lower),
+      );
+      return prefixed.length === 1 ? prefixed[0] : undefined;
+    })()
+  );
+}
+
+/** `Speakers` or `default (Speakers)`. */
+export function deviceLabel(
+  name: string | undefined,
+  devices: readonly SinkDevice[],
+): string {
+  if (name) return name;
+  const system = devices.find((device) => device.default);
+  return system ? `default (${system.name})` : "default";
+}
+
+const BLIP_SECONDS = 0.12;
+
+/** A short, soft sine blip (or a test tone): interleaved stereo. */
+export function blipSamples(
+  rate: number,
+  seconds = BLIP_SECONDS,
+  hz = 880,
+  gain = 0.12,
+): Float32Array {
+  const frames = Math.round(rate * seconds);
+  const out = new Float32Array(frames * 2);
+  const ramp = Math.max(1, Math.round(rate * 0.01));
+  for (let frame = 0; frame < frames; frame += 1) {
+    const envelope = Math.min(1, frame / ramp, (frames - 1 - frame) / ramp);
+    const value = Math.sin((2 * Math.PI * hz * frame) / rate) * gain * envelope;
+    out[frame * 2] = value;
+    out[frame * 2 + 1] = value;
+  }
+  return out;
+}
+
+/**
+ * Play `samples` once on `device` through its own short-lived stream, so
+ * the song's player is untouched. Resolves after the sound has played.
+ */
+export async function playOnce(
+  library: SinkLibrary,
+  device: string | undefined,
+  samples: Float32Array,
+  rate = 48_000,
+  wait: (ms: number) => Promise<void> = (ms) => Bun.sleep(ms),
+): Promise<boolean> {
+  const endpoint = library.openOutput({
+    ...(device ? { device } : {}),
+    rate,
+    channels: 2,
+    bufferFrames: 0,
+    ringFrames: samples.length / 2 + rate,
+  });
+  if (!endpoint) return false;
+  try {
+    endpoint.write(samples);
+    await wait(Math.ceil((samples.length / 2 / rate) * 1000) + 80);
+    return true;
+  } finally {
+    endpoint.close();
+  }
+}
+
+/** Peak and RMS of interleaved samples, in dBFS (-Infinity for silence). */
+export function inputLevel(samples: Float32Array): {
+  peakDb: number;
+  rmsDb: number;
+} {
+  let peak = 0;
+  let sum = 0;
+  for (const sample of samples) {
+    const value = Math.abs(sample);
+    if (value > peak) peak = value;
+    sum += sample * sample;
+  }
+  const rms = samples.length > 0 ? Math.sqrt(sum / samples.length) : 0;
+  const db = (value: number) =>
+    value > 0 ? 20 * Math.log10(value) : Number.NEGATIVE_INFINITY;
+  return { peakDb: db(peak), rmsDb: db(rms) };
+}
+
+/** `▇▇▇▇▅▁▁▁▁▁ -18 dBFS`: -60…0 dBFS across ten cells. */
+export function levelMeter(db: number, cells = 10): string {
+  if (!Number.isFinite(db)) return `${"▁".repeat(cells)} silent`;
+  const fill = Math.max(0, Math.min(1, (db + 60) / 60)) * cells;
+  let bar = "";
+  for (let cell = 0; cell < cells; cell += 1)
+    bar += fill >= cell + 1 ? "▇" : fill > cell + 0.5 ? "▅" : "▁";
+  return `${bar} ${Math.round(db)} dBFS`;
+}
+
+/** Capture `seconds` from the input and measure it. */
+export async function measureInput(
+  library: SinkLibrary,
+  device: string | undefined,
+  seconds = 1,
+  rate = 48_000,
+  wait: (ms: number) => Promise<void> = (ms) => Bun.sleep(ms),
+): Promise<{ peakDb: number; rmsDb: number }> {
+  const capture = NativeCapture.open(library, {
+    rate,
+    channels: 1,
+    ...(device ? { device } : {}),
+  });
+  let samples: Float32Array;
+  try {
+    await wait(seconds * 1000);
+  } finally {
+    samples = capture.close();
+  }
+  return inputLevel(samples);
+}

package/src/audio/doctor.ts

@@ -0,0 +1,157 @@
+/**
+ * `dawg doctor`: how dawg makes sound on this machine. The backend and why
+ * it was chosen, the native sink's verification (or why it fell back), the
+ * audio devices, the output and input saved from the audio menu, and the
+ * play-mode lead.
+ */
+import {
+  AudioEngine,
+  detectAudioBackend,
+  type AudioBackendInfo,
+} from "./engine.ts";
+import {
+  audioChoicePath,
+  matchDevice,
+  readAudioChoice,
+  type AudioChoice,
+} from "./devices.ts";
+import { PREBUILT_DIR, nativeTarget, type SinkDevice } from "./native.ts";
+import { DEFAULT_SAMPLE_RATE } from "./wav.ts";
+
+export type DoctorReport = Readonly<{
+  backend: AudioBackendInfo["backend"];
+  detail: string;
+  native: Readonly<{
+    target: string | null;
+    dir: string;
+    loaded: boolean;
+    reason?: string;
+  }>;
+  playLeadMs: number;
+  outputs: readonly string[];
+  inputs: readonly string[];
+  /**
+   * The audio menu's saved choice (`audio out`/`audio in`): a name, or
+   * `default`; `missing` when the native sink lists devices and the saved
+   * one is not among them (playback falls back to the default).
+   */
+  chosen: Readonly<{
+    output: string;
+    input: string;
+    path: string;
+    /** `DAWG_AUDIO_DEVICE` overrides the saved output. */
+    override?: string;
+    missing?: readonly ("output" | "input")[];
+  }>;
+}>;
+
+export type DoctorOptions = Readonly<{
+  env?: Readonly<Record<string, string | undefined>>;
+  choice?: AudioChoice;
+}>;
+
+export function audioDoctor(
+  info = detectAudioBackend(),
+  options: DoctorOptions = {},
+): DoctorReport {
+  const env = options.env ?? process.env;
+  const path = audioChoicePath(env);
+  const choice = options.choice ?? readAudioChoice(path);
+  const engine = new AudioEngine({ info, worker: false, timer: false });
+  const playLeadMs = engine.playLeadMs;
+  void engine.dispose();
+  const devices = (input: boolean): SinkDevice[] | undefined => {
+    try {
+      return info.native?.devices(input);
+    } catch {
+      return undefined;
+    }
+  };
+  const outputDevices = devices(false);
+  const inputDevices = devices(true);
+  const list = (found: readonly SinkDevice[] | undefined) =>
+    found?.map(
+      (d) =>
+        `${d.name}${d.default ? " (default)" : ""} · ${d.channels} ch · ${d.rate} Hz`,
+    ) ?? [];
+  const override = env.DAWG_AUDIO_DEVICE?.trim() || undefined;
+  const missing: ("output" | "input")[] = [];
+  const isMissing = (
+    name: string | undefined,
+    found: readonly SinkDevice[] | undefined,
+  ) => !!name && !!found && found.length > 0 && !matchDevice(found, name);
+  if (isMissing(override ?? choice.output, outputDevices))
+    missing.push("output");
+  if (isMissing(choice.input, inputDevices)) missing.push("input");
+  return {
+    backend: info.backend,
+    detail: info.detail,
+    native: {
+      target: nativeTarget() ?? null,
+      dir: PREBUILT_DIR,
+      loaded: info.backend === "native",
+      ...(info.nativeUnavailable ? { reason: info.nativeUnavailable } : {}),
+    },
+    playLeadMs,
+    outputs: list(outputDevices),
+    inputs: list(inputDevices),
+    chosen: {
+      output: choice.output ?? "default",
+      input: choice.input ?? "default",
+      path,
+      ...(override ? { override } : {}),
+      ...(missing.length > 0 ? { missing } : {}),
+    },
+  };
+}
+
+/** `chosen: output AirPods · input default`, with what overrides or is gone. */
+function chosenLines(chosen: DoctorReport["chosen"]): string[] {
+  const missing = new Set(chosen.missing ?? []);
+  const side = (label: "output" | "input", name: string) =>
+    `${label} ${name}${missing.has(label) ? " (missing, using default)" : ""}`;
+  const lines = [
+    `chosen: ${side("output", chosen.override ?? chosen.output)} · ${side("input", chosen.input)} · ${chosen.path}`,
+  ];
+  if (chosen.override)
+    lines.push(
+      `  DAWG_AUDIO_DEVICE overrides the saved output (${chosen.output})`,
+    );
+  lines.push("  change it: audio out <name|default> · audio in <name|default>");
+  return lines;
+}
+
+export function formatAudioDoctor(report: DoctorReport): string[] {
+  const lines = [
+    `audio: ${report.backend} · ${report.detail}`,
+    report.native.loaded
+      ? `native sink: loaded (${report.native.target})`
+      : `native sink: not in use · ${report.native.reason ?? "another backend was forced"} · falls back to ffplay, sox or afplay`,
+    `play lead: ${report.playLeadMs} ms · render rate ${DEFAULT_SAMPLE_RATE} Hz`,
+    ...chosenLines(report.chosen),
+  ];
+  if (report.outputs.length > 0)
+    lines.push("outputs:", ...report.outputs.map((d) => `  ${d}`));
+  if (report.inputs.length > 0)
+    lines.push("inputs:", ...report.inputs.map((d) => `  ${d}`));
+  return lines;
+}
+
+export async function runDoctorCommand(
+  args: readonly string[],
+  stdout: { write(text: string): unknown },
+): Promise<number> {
+  if (args.some((arg) => arg === "--help" || arg === "-h")) {
+    stdout.write(
+      "usage: dawg doctor [--json]  audio backend, native sink, devices, saved choice\n",
+    );
+    return 0;
+  }
+  const report = audioDoctor();
+  stdout.write(
+    args.includes("--json")
+      ? `${JSON.stringify(report, null, 2)}\n`
+      : `${formatAudioDoctor(report).join("\n")}\n`,
+  );
+  return 0;
+}