hyperframes 0.8.185 → 0.8.186

package/dist/audio-7PBM5F3H.js

@@ -0,0 +1,2317 @@
+import { createRequire as __hf_createRequire } from "node:module";
+import { fileURLToPath as __hf_fileURLToPath } from "node:url";
+import { dirname as __hf_dirname } from "node:path";
+var require = __hf_createRequire(import.meta.url);
+var __filename = __hf_fileURLToPath(import.meta.url);
+var __dirname = __hf_dirname(__filename);
+import {
+  uploadAssetViaDirectUpload
+} from "./chunk-MY6CVBDD.js";
+import {
+  HyperframesCloudClient
+} from "./chunk-5UBZPG74.js";
+import {
+  describeProject
+} from "./chunk-Z5233OAN.js";
+import "./chunk-LLMSX6V6.js";
+import {
+  bandFramesOf,
+  decodeAudio,
+  envelope,
+  medianInterval,
+  probeAudio,
+  rhythm,
+  runLadder,
+  signalDuration,
+  signalProvider,
+  snapper,
+  tempoOf
+} from "./chunk-VHBBV5DH.js";
+import {
+  refreshIfNeeded,
+  resolveCloudBaseUrl
+} from "./chunk-HRPWRZGF.js";
+import {
+  buildAuthHeaders,
+  tryResolveCredential
+} from "./chunk-7KVVNF7B.js";
+import {
+  downloadToFile
+} from "./chunk-CZUAX3BV.js";
+import {
+  loadTranscript
+} from "./chunk-TMK4Q7JA.js";
+import {
+  resolveProject
+} from "./chunk-HZ7M2MZA.js";
+import "./chunk-6JR2XUEE.js";
+import "./chunk-DTXDQ6OP.js";
+import "./chunk-K2FLNJVB.js";
+import {
+  ensureDOMParser
+} from "./chunk-442JNXRM.js";
+import "./chunk-EOVYQ3IG.js";
+import "./chunk-77QM6YRQ.js";
+import "./chunk-6IOBAOU7.js";
+import "./chunk-VWG7OQKU.js";
+import {
+  assertKnownFlags
+} from "./chunk-HTIUNMTP.js";
+import {
+  defineCommand
+} from "./chunk-S3S4TGEH.js";
+import "./chunk-54HJ63Q2.js";
+import {
+  CliUsageError
+} from "./chunk-JVBRJMOP.js";
+import "./chunk-ZTZA4UWZ.js";
+import "./chunk-7M7TMM4S.js";
+import "./chunk-IZCW2NKT.js";
+import "./chunk-RNZEQTWZ.js";
+import "./chunk-RQVDTPGD.js";
+import "./chunk-BRTDLVK3.js";
+import "./chunk-UOZX5W5T.js";
+import "./chunk-VC76R6W2.js";
+import "./chunk-UJKQWGFF.js";
+import "./chunk-B2A56S5C.js";
+import "./chunk-OFQWTKPW.js";
+import "./chunk-DPVXBVLL.js";
+import "./chunk-3GXQPCJC.js";
+import "./chunk-634HSJ3J.js";
+import "./chunk-FXMKHHPO.js";
+import "./chunk-T6AGUTZJ.js";
+import "./chunk-XT6MXC7A.js";
+import "./chunk-4UMPIPCQ.js";
+import "./chunk-Q447CX26.js";
+import {
+  findFfBinary
+} from "./chunk-VAS6HQX3.js";
+import {
+  resolveAuthoredAssetFile
+} from "./chunk-6BNTGNGD.js";
+import "./chunk-RUOG4VB7.js";
+import "./chunk-MMQ52NIZ.js";
+import "./chunk-BSQ7XANM.js";
+import "./chunk-SDYDNHEE.js";
+import "./chunk-IXLUTE6N.js";
+import "./chunk-I5JRXMCV.js";
+import "./chunk-W2LGJSEN.js";
+import {
+  withMeta
+} from "./chunk-FRLTKTOR.js";
+import "./chunk-K4WIOZFP.js";
+import "./chunk-XUXGIA7H.js";
+import "./chunk-WERLJGIC.js";
+import "./chunk-ISN5GRYI.js";
+import "./chunk-LDW3KVGK.js";
+import "./chunk-KNU5COPB.js";
+import "./chunk-M2WBOQ2Q.js";
+
+// src/commands/audio.ts
+import { join as join7, resolve as resolve2 } from "path";
+
+// src/audio/analysis/providers/api.ts
+import { randomUUID } from "crypto";
+
+// src/audio/analysis/providers/shared.ts
+import { execFile } from "child_process";
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var runFile = promisify(execFile);
+var unavailable = (reason) => ({ ok: false, reason });
+var AVAILABLE = { ok: true };
+function encodeWav(signal) {
+  const channels = signal.channels.length;
+  const frames = signal.channels[0]?.length ?? 0;
+  const data = frames * channels * 2;
+  const wav = Buffer.alloc(44 + data);
+  wav.write("RIFF", 0);
+  wav.writeUInt32LE(36 + data, 4);
+  wav.write("WAVEfmt ", 8);
+  wav.writeUInt32LE(16, 16);
+  wav.writeUInt16LE(1, 20);
+  wav.writeUInt16LE(channels, 22);
+  wav.writeUInt32LE(signal.sampleRate, 24);
+  wav.writeUInt32LE(signal.sampleRate * channels * 2, 28);
+  wav.writeUInt16LE(channels * 2, 32);
+  wav.writeUInt16LE(16, 34);
+  wav.write("data", 36);
+  wav.writeUInt32LE(data, 40);
+  let offset = 44;
+  for (let i = 0; i < frames; i++)
+    for (const channel of signal.channels) {
+      const sample = Math.max(-1, Math.min(1, channel[i]));
+      wav.writeInt16LE(Math.round(sample * 32767), offset);
+      offset += 2;
+    }
+  return wav;
+}
+async function withWavFile(signal, use) {
+  const dir = await mkdtemp(join(tmpdir(), "hf-audio-"));
+  try {
+    const path = join(dir, "audio.wav");
+    await writeFile(path, encodeWav(signal));
+    return await use(path);
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+function perSignal(compute) {
+  const answers = /* @__PURE__ */ new WeakMap();
+  return (signal) => {
+    let answer = answers.get(signal);
+    if (!answer) answers.set(signal, answer = compute(signal));
+    return answer;
+  };
+}
+function downbeatsWithMeter(beats, downbeats) {
+  const bar = medianInterval(downbeats);
+  const beat = medianInterval(beats);
+  const meter = bar && beat ? Math.round(bar / beat) : null;
+  return { times: downbeats, meter: meter && meter > 0 ? meter : null };
+}
+var round = (t) => Math.round(t * 1e3) / 1e3;
+var rounded = (times) => times.map(round);
+var NO_HEYGEN_CREDENTIAL = "no HeyGen credential: set HEYGEN_API_KEY or run `hyperframes auth login --api-key`";
+async function heygenHeaders() {
+  try {
+    const credential = await tryResolveCredential();
+    return credential ? buildAuthHeaders(await refreshIfNeeded(credential)) : NO_HEYGEN_CREDENTIAL;
+  } catch (error) {
+    return error instanceof Error ? error.message : String(error);
+  }
+}
+async function serviceAccess(env, path, defaultMs) {
+  const timeout = Number(process.env[env.timeout]);
+  const timeoutMs = timeout > 0 ? timeout : defaultMs;
+  const url = process.env[env.url]?.trim();
+  const key = process.env[env.key]?.trim();
+  if (url === "") return `${env.url} is empty, which turns this service off`;
+  if (key)
+    return {
+      url: url || `${resolveCloudBaseUrl()}${path}`,
+      headers: { "x-api-key": key },
+      timeoutMs
+    };
+  if (url) return `${env.url} is set but ${env.key} is not`;
+  const headers = await heygenHeaders();
+  if (typeof headers === "string") return headers;
+  return { url: `${resolveCloudBaseUrl()}${path}`, headers, timeoutMs };
+}
+function errorMessageIn(text) {
+  try {
+    return JSON.parse(text).error?.message;
+  } catch {
+    return void 0;
+  }
+}
+async function serviceFailure(response, service) {
+  const text = await response.text().catch(() => "");
+  const detail = errorMessageIn(text) ?? text.slice(0, 200);
+  return new Error(`${service} answered ${response.status}${detail ? `: ${detail}` : ""}`);
+}
+
+// src/audio/analysis/providers/api.ts
+var URL_ENV = "HYPERFRAMES_AUDIO_API_URL";
+var KEY_ENV = "HYPERFRAMES_AUDIO_API_KEY";
+var TIMEOUT_ENV = "HYPERFRAMES_AUDIO_API_TIMEOUT_MS";
+var DEFAULT_TIMEOUT_MS = 12e4;
+var UPLOAD_RATE = 16e3;
+var SINC_ZEROS = 16;
+var ROLLOFF = 0.9;
+var SINC_STEPS = 512;
+var HANN_SINC = Float32Array.from({ length: SINC_ZEROS * SINC_STEPS + 2 }, (_, k) => {
+  const x = k / SINC_STEPS;
+  if (x >= SINC_ZEROS) return 0;
+  const sinc = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+  return sinc * (0.5 + 0.5 * Math.cos(Math.PI * x / SINC_ZEROS));
+});
+function resample(input, from, to) {
+  if (from === to) return input;
+  const step = from / to;
+  const scale = Math.min(1, to / from) * ROLLOFF;
+  const reach = SINC_ZEROS / scale;
+  const output = new Float32Array(Math.round(input.length / step));
+  for (let i = 0; i < output.length; i++) {
+    const center = i * step;
+    const last = Math.min(input.length - 1, Math.floor(center + reach));
+    let sum = 0;
+    let weights = 0;
+    for (let n = Math.max(0, Math.ceil(center - reach)); n <= last; n++) {
+      const at = Math.abs(n - center) * scale * SINC_STEPS;
+      const k = Math.floor(at);
+      const weight = HANN_SINC[k] + (at - k) * (HANN_SINC[k + 1] - HANN_SINC[k]);
+      sum += input[n] * weight;
+      weights += weight;
+    }
+    output[i] = weights ? sum / weights : 0;
+  }
+  return output;
+}
+function monoInput(channels) {
+  const mono = new Float32Array(channels[0]?.length ?? 0);
+  let loudest2 = mono;
+  let loudestEnergy = 0;
+  for (const channel of channels) {
+    let energy = 0;
+    for (let i = 0; i < mono.length; i++) {
+      const value = channel[i];
+      mono[i] += value / channels.length;
+      energy += value * value;
+    }
+    if (energy > loudestEnergy) {
+      loudest2 = channel;
+      loudestEnergy = energy;
+    }
+  }
+  const monoEnergy = mono.reduce((energy, value) => energy + value * value, 0);
+  return monoEnergy < loudestEnergy * 0.1 ? loudest2 : mono;
+}
+function uploaded(signal) {
+  return {
+    sampleRate: UPLOAD_RATE,
+    channels: [resample(monoInput(signal.channels), signal.sampleRate, UPLOAD_RATE)]
+  };
+}
+var askedTogether = (capability) => capability === "beats" || capability === "downbeats" ? ["beats", "downbeats"] : [capability];
+var access = () => serviceAccess(
+  { url: URL_ENV, key: KEY_ENV, timeout: TIMEOUT_ENV },
+  "/v3/audio/analysis",
+  DEFAULT_TIMEOUT_MS
+);
+async function granted() {
+  const found = await access();
+  if (typeof found === "string") throw new Error(found);
+  return found;
+}
+var isNumberList = (value) => Array.isArray(value) && value.every((t) => typeof t === "number" && Number.isFinite(t));
+function checked(capability, body) {
+  const value = body[capability];
+  if (!value || typeof value !== "object")
+    throw new Error(`the service did not answer ${capability}`);
+  const valid = {
+    beats: () => isNumberList(value.times),
+    downbeats: () => isNumberList(value.times),
+    sections: () => Array.isArray(value.spans) && value.spans.every((s3) => isNumberList([s3.start, s3.end])),
+    describe: () => Array.isArray(value.tags) && value.tags.every(
+      (t) => typeof t.label === "string" && typeof t.score === "number"
+    )
+  }[capability];
+  if (!valid())
+    throw new Error(`the service answered ${capability} in a shape this CLI cannot read`);
+}
+var uploadedAsset = perSignal(async (analyzed) => {
+  const { url, headers, timeoutMs } = await granted();
+  const deadline = AbortSignal.timeout(timeoutMs);
+  const boundedFetch = (input, init) => fetch(input, {
+    ...init,
+    redirect: "error",
+    signal: deadline
+  });
+  const client = new HyperframesCloudClient({
+    baseUrl: new URL(url).origin,
+    getAuthHeaders: () => headers,
+    fetchImpl: boundedFetch
+  });
+  const asset = await uploadAssetViaDirectUpload({
+    client,
+    bytes: new Uint8Array(encodeWav(uploaded(analyzed))),
+    filename: "audio.wav",
+    contentType: "audio/wav",
+    idempotencyKey: randomUUID(),
+    fetchImpl: boundedFetch
+  });
+  return asset.asset_id;
+});
+async function ask(analyzed, capabilities2) {
+  const { url, headers, timeoutMs } = await granted();
+  const request = {
+    version: 1,
+    capabilities: capabilities2,
+    audio: { type: "asset_id", asset_id: await uploadedAsset(analyzed) }
+  };
+  const response = await fetch(url, {
+    method: "POST",
+    redirect: "error",
+    headers: {
+      ...headers,
+      "idempotency-key": randomUUID(),
+      "content-type": "application/json"
+    },
+    body: JSON.stringify(request),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!response.ok) throw await serviceFailure(response, "the service");
+  const body = await response.json();
+  return body?.data ?? body ?? {};
+}
+var requests = /* @__PURE__ */ new Map();
+function answerFor(signal, capability) {
+  const together = askedTogether(capability);
+  const key = together.join(",");
+  let request = requests.get(key);
+  if (!request) requests.set(key, request = perSignal((s3) => ask(s3, together)));
+  return request(signal);
+}
+function beatSnapper(signal, beatSeconds) {
+  const measured3 = rhythm(signal).beats.times;
+  const period = beatSeconds ?? medianInterval(measured3) ?? 0;
+  return snapper(measured3, period / 4, "signal beats");
+}
+function snappedBeats(signal, body) {
+  const times = body.beats.times;
+  const onBeat2 = beatSnapper(signal, medianInterval(times));
+  return { times: rounded(times.map(onBeat2.snap)), snap: onBeat2.report() };
+}
+function snappedDownbeats(signal, body) {
+  const { times, meter = null } = body.downbeats;
+  const beat = body.beats ? medianInterval(body.beats.times) : null;
+  const bar = medianInterval(times);
+  const onBeat2 = beatSnapper(signal, beat ?? (bar && meter ? bar / meter : null));
+  return { times: rounded(times.map(onBeat2.snap)), meter, snap: onBeat2.report() };
+}
+function snappedSections(signal, body) {
+  const onBeat2 = beatSnapper(signal, null);
+  const end = (signal.channels[0]?.length ?? 0) / signal.sampleRate;
+  const move = (t) => t <= 0 || t >= end ? t : onBeat2.snap(t);
+  const spans = body.sections.spans.map((s3) => ({
+    ...s3,
+    start: rounded([move(s3.start)])[0],
+    end: rounded([move(s3.end)])[0]
+  }));
+  return { spans, snap: onBeat2.report() };
+}
+function measured(capability, signal, body) {
+  const value = capability === "beats" ? snappedBeats(signal, body) : capability === "downbeats" ? snappedDownbeats(signal, body) : capability === "sections" ? snappedSections(signal, body) : body.describe;
+  return body.source ? { ...value, source: body.source } : value;
+}
+var API_CAPABILITIES = ["beats", "downbeats", "sections", "describe"];
+var apiProvider = {
+  id: "api",
+  local: false,
+  capabilities: API_CAPABILITIES,
+  async available() {
+    const found = await access();
+    return typeof found === "string" ? unavailable(found) : AVAILABLE;
+  },
+  async analyze(capability, signal) {
+    const asked = capability;
+    const body = await answerFor(signal, asked);
+    checked(asked, body);
+    return measured(asked, signal, body);
+  }
+};
+
+// src/audio/analysis/providers/apple.ts
+import { createHash } from "crypto";
+import { existsSync } from "fs";
+import { mkdir, rename, writeFile as writeFile2 } from "fs/promises";
+import { homedir } from "os";
+import { join as join2 } from "path";
+var SOUND_ANALYSIS = "/System/Library/Frameworks/SoundAnalysis.framework";
+var MUSIC_UNDERSTANDING_MACOS = 27;
+var SOUND_TAGGER = `
+import Foundation
+import SoundAnalysis
+
+final class Collector: NSObject, SNResultsObserving {
+  var sums: [String: Double] = [:]
+  var windows = 0
+  var failure: Error?
+  func request(_ request: SNRequest, didProduce result: SNResult) {
+    guard let result = result as? SNClassificationResult else { return }
+    windows += 1
+    for c in result.classifications { sums[c.identifier, default: 0] += c.confidence }
+  }
+  func request(_ request: SNRequest, didFailWithError error: Error) { failure = error }
+}
+
+do {
+  let analyzer = try SNAudioFileAnalyzer(url: URL(fileURLWithPath: CommandLine.arguments[1]))
+  let collector = Collector()
+  try analyzer.add(try SNClassifySoundRequest(classifierIdentifier: .version1), withObserver: collector)
+  analyzer.analyze()
+  if let failure = collector.failure { throw failure }
+  let count = Double(max(1, collector.windows))
+  var tags: [[String: Any]] = []
+  for (label, sum) in collector.sums.sorted(by: { $0.value > $1.value }).prefix(10) {
+    let score: Double = sum / count
+    if score >= 0.01 { tags.append(["label": label, "score": (score * 1000).rounded() / 1000]) }
+  }
+  let json = try JSONSerialization.data(withJSONObject: ["tags": tags, "windows": collector.windows])
+  FileHandle.standardOutput.write(json)
+} catch {
+  FileHandle.standardError.write(Data("\\(error)".utf8))
+  exit(1)
+}
+`;
+var CLASSIFIER_WINDOW_SECONDS = 3;
+function atLeastOneWindow(signal) {
+  const length = Math.ceil(CLASSIFIER_WINDOW_SECONDS * signal.sampleRate);
+  if ((signal.channels[0]?.length ?? 0) >= length) return signal;
+  return {
+    ...signal,
+    channels: signal.channels.map((channel) => {
+      const padded = new Float32Array(length);
+      padded.set(channel);
+      return padded;
+    })
+  };
+}
+var helperDir = () => join2(homedir(), ".cache", "hyperframes", "audio-helpers");
+function helperPath(name, source) {
+  const hash = createHash("sha256").update(source).digest("hex").slice(0, 12);
+  return join2(helperDir(), `${name}-${hash}`);
+}
+async function hasSwiftCompiler() {
+  try {
+    await runFile("xcrun", ["--find", "swiftc"], { timeout: 3e4 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+var firstLine = (error) => (error.stderr || String(error)).trim().split("\n")[0];
+var builds = /* @__PURE__ */ new Map();
+function compiled(name, source) {
+  const binary = helperPath(name, source);
+  if (existsSync(binary)) return Promise.resolve(binary);
+  let build = builds.get(binary);
+  if (!build) {
+    build = (async () => {
+      await mkdir(helperDir(), { recursive: true });
+      const file = `${binary}.swift`;
+      await writeFile2(file, source);
+      const args = [
+        "--sdk",
+        "macosx",
+        "swiftc",
+        "-O",
+        "-swift-version",
+        "5",
+        file,
+        "-o",
+        `${binary}.tmp`
+      ];
+      await runFile("xcrun", args, { timeout: 5 * 6e4 }).catch((error) => {
+        throw new Error(`could not build the ${name} helper: ${firstLine(error)}`);
+      });
+      await rename(`${binary}.tmp`, binary);
+      return binary;
+    })();
+    builds.set(binary, build);
+  }
+  return build;
+}
+async function macosMajor() {
+  if (process.platform !== "darwin") return null;
+  const { stdout } = await runFile("sw_vers", ["-productVersion"], { timeout: 1e4 });
+  return Number.parseInt(stdout, 10) || null;
+}
+var appleSoundProvider = {
+  id: "apple-sound",
+  local: true,
+  capabilities: ["describe"],
+  async available() {
+    if (process.platform !== "darwin") return unavailable("macOS only");
+    if (!existsSync(SOUND_ANALYSIS))
+      return unavailable("SoundAnalysis.framework is not on this Mac");
+    if (existsSync(helperPath("apple-sound", SOUND_TAGGER))) return AVAILABLE;
+    if (!await hasSwiftCompiler()) return unavailable("no Swift compiler to build the helper");
+    return AVAILABLE;
+  },
+  async analyze(_capability, signal) {
+    const helper = await compiled("apple-sound", SOUND_TAGGER);
+    const { stdout } = await withWavFile(
+      atLeastOneWindow(signal),
+      (wav) => runFile(helper, [wav], { timeout: 5 * 6e4, maxBuffer: 8 * 1024 * 1024 })
+    );
+    const { tags } = JSON.parse(stdout);
+    return {
+      tags: tags.map((t) => ({ label: t.label, score: Math.round(t.score * 1e3) / 1e3 }))
+    };
+  }
+};
+var appleMuProvider = {
+  id: "apple-mu",
+  local: true,
+  capabilities: ["beats", "downbeats", "sections"],
+  async available() {
+    const major = await macosMajor();
+    if (major === null) return unavailable("macOS only");
+    if (major < MUSIC_UNDERSTANDING_MACOS)
+      return unavailable(
+        `Music Understanding needs macOS ${MUSIC_UNDERSTANDING_MACOS}; this Mac runs ${major}`
+      );
+    return unavailable("no Music Understanding helper yet: it needs the macOS 27 SDK to build");
+  },
+  analyze() {
+    return Promise.reject(new Error("Music Understanding is not available"));
+  }
+};
+
+// src/audio/analysis/providers/beatThis.ts
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join3 } from "path";
+var PYTHON_ENV = "HYPERFRAMES_BEAT_THIS_PYTHON";
+var CHECKPOINT_ENV = "HYPERFRAMES_BEAT_THIS_CHECKPOINT";
+function checkpointPath() {
+  const configured = process.env[CHECKPOINT_ENV]?.trim();
+  if (configured) return configured;
+  const torchHome = process.env.TORCH_HOME ?? join3(homedir2(), ".cache", "torch");
+  return join3(torchHome, "hub", "checkpoints", "beat_this-small0.ckpt");
+}
+var FIND_PACKAGE = "import importlib.util,sys; sys.exit(importlib.util.find_spec('beat_this') is None)";
+var TRACK = `
+import json, sys
+from beat_this.inference import File2Beats
+beats, downbeats = File2Beats(checkpoint_path=sys.argv[2], device="cpu", dbn=False)(sys.argv[1])
+print(json.dumps({"beats": [float(t) for t in beats], "downbeats": [float(t) for t in downbeats]}))
+`;
+var installed = /* @__PURE__ */ new Map();
+function hasPackage(python) {
+  let found = installed.get(python);
+  if (!found) {
+    found = runFile(python, ["-c", FIND_PACKAGE], { timeout: 3e4, windowsHide: true }).then(
+      () => true,
+      () => false
+    );
+    installed.set(python, found);
+  }
+  return found;
+}
+var track = perSignal(
+  (signal) => withWavFile(signal, async (wav) => {
+    const python = process.env[PYTHON_ENV].trim();
+    const { stdout } = await runFile(python, ["-c", TRACK, wav, checkpointPath()], {
+      maxBuffer: 64 * 1024 * 1024,
+      timeout: 10 * 6e4,
+      windowsHide: true
+    });
+    const answer = JSON.parse(stdout.trim().split("\n").pop());
+    return { beats: rounded(answer.beats), downbeats: rounded(answer.downbeats) };
+  })
+);
+var beatThisProvider = {
+  id: "beat-this",
+  local: true,
+  capabilities: ["beats", "downbeats"],
+  async available() {
+    const python = process.env[PYTHON_ENV]?.trim();
+    if (!python) return unavailable(`${PYTHON_ENV} is not set`);
+    if (!existsSync2(python)) return unavailable(`${PYTHON_ENV} names no file`);
+    if (!existsSync2(checkpointPath()))
+      return unavailable(`no Beat This! weights at ${checkpointPath()}`);
+    if (!await hasPackage(python)) return unavailable(`beat_this is not installed for ${python}`);
+    return AVAILABLE;
+  },
+  async analyze(capability, signal) {
+    const { beats, downbeats } = await track(signal);
+    return capability === "beats" ? { times: beats } : downbeatsWithMeter(beats, downbeats);
+  }
+};
+
+// src/audio/analysis/fileTime.ts
+var round2 = (t) => Math.round(t * 1e3) / 1e3;
+function withSnap(value, at) {
+  return value.snap ? { ...value, snap: { ...value.snap, unsnapped: value.snap.unsnapped.map(at) } } : value;
+}
+var SHIFTS = {
+  moments: (m, at) => Object.fromEntries(Object.entries(m).map(([k, t]) => [k, at(t)])),
+  onsets: (o, at) => ({ ...o, events: o.events.map((e) => ({ ...e, t: at(e.t) })) }),
+  silence: (spans, at) => spans.map((s3) => ({ start: at(s3.start), end: at(s3.end) })),
+  loudness: (l, at) => ({
+    ...l,
+    clipping: {
+      ...l.clipping,
+      firstAt: l.clipping.firstAt === null ? null : at(l.clipping.firstAt)
+    }
+  }),
+  envelope: (e, _at, offset) => ({ startsAt: round2(offset), ...e }),
+  beats: (b, at) => withSnap({ ...b, times: b.times.map(at) }, at),
+  downbeats: (b, at) => withSnap({ ...b, times: b.times.map(at) }, at),
+  bpm: (tempo, at) => ({
+    ...tempo,
+    curve: tempo.curve.map((p) => ({ ...p, t: at(p.t) }))
+  }),
+  sections: (s3, at) => withSnap(
+    {
+      ...s3,
+      spans: s3.spans.map((span) => ({ ...span, start: at(span.start), end: at(span.end) }))
+    },
+    at
+  )
+};
+function shiftedTimes(capability, value, offset) {
+  if (value === null || typeof value !== "object") return value;
+  const shift = SHIFTS[capability];
+  return shift ? shift(value, (t) => round2(t + offset), offset) : value;
+}
+
+// src/audio/analysis/analyze.ts
+var DEFAULT_CAPABILITIES = [
+  "kind",
+  "moments",
+  "onsets",
+  "loudness",
+  "silence",
+  "envelope"
+];
+function audioAnalysisProviders() {
+  return [apiProvider, appleMuProvider, beatThisProvider, appleSoundProvider, signalProvider];
+}
+function envelopeHopMs(seconds, asked) {
+  if (asked !== void 0) return asked;
+  return Math.max(5, Math.ceil(seconds * 1e3 / 2e3));
+}
+var round3 = (t) => Math.round(t * 1e3) / 1e3;
+function within(value, from, to) {
+  if (!value || typeof value !== "object" || !("events" in value)) return value;
+  const onsets = value;
+  return { ...onsets, events: onsets.events.filter((e) => e.t >= from && e.t < to) };
+}
+function frame(signal, context) {
+  const before = context?.before ?? 0;
+  const skip = Math.round(before * signal.sampleRate);
+  const length = signal.channels[0]?.length ?? 0;
+  const end = Math.max(skip, length - Math.round((context?.after ?? 0) * signal.sampleRate));
+  const cut = skip > 0 || end < length;
+  const windowed = cut ? { ...signal, channels: signal.channels.map((c) => c.subarray(skip, end)) } : signal;
+  return { windowed, before, end: end / signal.sampleRate, cut };
+}
+function optionsFor(capability, request, seconds) {
+  const options = { ...request.options?.[capability] };
+  if (capability === "envelope")
+    options.hopMs = envelopeHopMs(seconds, options.hopMs);
+  return options;
+}
+async function analyzeSignal(signal, request, providers = audioAnalysisProviders()) {
+  const quality = request.quality ?? "local";
+  const { beats, bpm } = request.provider ?? {};
+  if (beats && bpm && beats !== bpm) throw new Error("beats and bpm must use the same provider");
+  const beatProvider = beats ?? bpm;
+  const framing = frame(signal, request.context);
+  const analysis = {
+    analyzed: round3(signalDuration(framing.windowed)),
+    values: {},
+    provenance: {},
+    ladder: {},
+    warnings: []
+  };
+  const ladders = /* @__PURE__ */ new Map();
+  const ladderFor = (capability) => {
+    let result = ladders.get(capability);
+    if (!result) {
+      const withContext = capability === "onsets" && framing.cut;
+      result = runLadder(capability, withContext ? signal : framing.windowed, providers, {
+        quality,
+        provider: capability === "beats" ? beatProvider : request.provider?.[capability],
+        options: optionsFor(capability, request, analysis.analyzed)
+      });
+      ladders.set(capability, result);
+    }
+    return result;
+  };
+  for (const capability of request.capabilities) {
+    const withContext = capability === "onsets" && framing.cut;
+    const result = capability === "bpm" ? tempoFromBeats(await ladderFor("beats")) : await ladderFor(capability);
+    const value = withContext ? within(result.value, framing.before, framing.end) : result.value;
+    const offset = (request.fileOffset ?? 0) - (withContext ? framing.before : 0);
+    analysis.values[capability] = shiftedTimes(capability, value, offset);
+    analysis.provenance[capability] = result.provenance;
+    analysis.ladder[capability] = result.steps;
+    const said = new Set(analysis.warnings);
+    analysis.warnings.push(...result.warnings.filter((w) => !said.has(w)));
+  }
+  analysis.warnings.push(...serviceHint(quality, analysis, request.capabilities));
+  return analysis;
+}
+function serviceHint(quality, analysis, capabilities2) {
+  const leftToService = (capability) => analysis.values[capability] == null && (analysis.ladder[capability] ?? []).some((s3) => s3.outcome === "excluded");
+  return quality === "local" && capabilities2.some(leftToService) ? ["a service could have answered what is missing: --quality best uploads the audio to HeyGen"] : [];
+}
+function tempoFromBeats(beats) {
+  const times = beats.value?.times;
+  return { ...beats, value: times ? tempoOf(times) : null };
+}
+
+// src/audio/analysis/targets.ts
+import { dirname, join as join4, resolve } from "path";
+var round4 = (t) => Math.round(t * 1e3) / 1e3;
+function placementOf(row) {
+  return {
+    start: row.absStart,
+    end: row.absEnd,
+    dataStart: row.start,
+    mediaStart: row.mediaStart ?? 0,
+    playbackRate: row.playbackRate ?? 1,
+    volume: row.volume ?? 1
+  };
+}
+function filmTime(placement, fileTime2) {
+  return round4(placement.start + (fileTime2 - placement.mediaStart) / placement.playbackRate);
+}
+function fileTime(placement, filmTime2) {
+  return round4(placement.mediaStart + (filmTime2 - placement.start) * placement.playbackRate);
+}
+var soundingRows = (timeline) => timeline.tracks.filter((track2) => track2.kind === "audio" || track2.kind === "video").flatMap((track2) => track2.rows).filter((row) => row.src && row.volume !== 0 && /^(audio|video)$/.test(row.kind)).sort((a, b) => a.absStart - b.absStart);
+function matches(row, query) {
+  switch (query.by) {
+    case "all":
+    case "element":
+      return true;
+    case "at":
+      return row.absStart <= query.t && query.t < row.absEnd;
+    case "range":
+      return row.absStart < query.end && query.start < row.absEnd;
+  }
+}
+function targetOf(projectDir, row, query) {
+  const placement = placementOf(row);
+  const from = query.by === "range" ? Math.max(placement.start, query.start) : placement.start;
+  const to = query.by === "range" ? Math.min(placement.end, query.end) : placement.end;
+  return {
+    path: resolveAuthoredAssetFile(projectDir, row.file, row.src) ?? resolve(dirname(join4(projectDir, row.file)), row.src),
+    file: row.src,
+    ref: row.ref || null,
+    kind: row.kind,
+    placement,
+    window: {
+      from: fileTime(placement, from),
+      seconds: round4((to - from) * placement.playbackRate)
+    }
+  };
+}
+function filmTargets(projectDir, timeline, query) {
+  if (query.by === "element") {
+    const id = query.ref.startsWith("#") ? query.ref.slice(1) : null;
+    const found = timeline.tracks.flatMap((track2) => track2.rows).filter((row2) => row2.ref === query.ref || id !== null && row2.id === id);
+    if (found.length !== 1)
+      throw new Error(
+        `${query.ref} ${found.length ? `matches ${found.length} clips` : "was not found"}; use a ref from hyperframes timeline`
+      );
+    const row = found[0];
+    if (!row.src || !/^(audio|video)$/.test(row.kind))
+      throw new Error(`${query.ref} is not an audio or video clip`);
+    return [targetOf(projectDir, row, query)];
+  }
+  return soundingRows(timeline).filter((row) => matches(row, query)).map((row) => targetOf(projectDir, row, query));
+}
+
+// src/audio/analysis/format.ts
+var BARS = "\u2581\u2582\u2583\u2584\u2585\u2586\u2587\u2588";
+var SPARK_WIDTH = 48;
+var ONSETS_SHOWN = 12;
+var s = (t) => t.toFixed(3);
+function sparkline(envelope2, width = SPARK_WIDTH) {
+  const { values } = envelope2;
+  if (values.length === 0) return "";
+  const per = Math.max(1, Math.ceil(values.length / width));
+  const slices = [];
+  for (let i = 0; i < values.length; i += per) slices.push(Math.max(...values.slice(i, i + per)));
+  const top = Math.max(...slices);
+  const floor = Math.max(Math.min(...slices), top - 60);
+  if (top - floor < 1e-9) return BARS[0].repeat(slices.length);
+  return slices.map(
+    (v) => BARS[Math.round((Math.max(v, floor) - floor) / (top - floor) * (BARS.length - 1))]
+  ).join("");
+}
+function momentsLine(moments, at) {
+  return `  onset ${at(moments.onset)}  steepest ${at(moments.steepest)}  peak ${at(moments.peak)}  tail end ${at(moments.tailEnd)}`;
+}
+function hitsLine(onsets, at) {
+  if (!onsets.events.length) return null;
+  const shown = onsets.events.slice(0, ONSETS_SHOWN).map((e) => `${at(e.t)}(${e.strength.toFixed(2)})`);
+  const more = onsets.events.length - shown.length;
+  return `  hits ${shown.join(" ")}${more > 0 ? ` +${more}` : ""}`;
+}
+function loudnessLine(loudness, at) {
+  const lufs = loudness.lufsIntegrated === null ? "below gate" : `${loudness.lufsIntegrated} LUFS`;
+  const { count, firstAt } = loudness.clipping;
+  const clip = count && firstAt !== null ? `, clips ${count}\xD7 from ${at(firstAt)}` : "";
+  return `  loudness ${lufs}, true peak ${loudness.truePeakDb} dBTP${clip}`;
+}
+function silenceLine(silence, at) {
+  return silence.length ? `  silent ${silence.map((g) => `${at(g.start)}\u2013${at(g.end)}`).join(" ")}` : null;
+}
+function snapNote(snap) {
+  if (!snap) return "";
+  const total = snap.snapped + snap.unsnapped.length;
+  const median2 = snap.medianShiftMs === null ? "" : `, median ${snap.medianShiftMs} ms`;
+  return `; ${snap.snapped}/${total} snapped to ${snap.reference}${median2}`;
+}
+var listed = (times, at) => {
+  const shown = times.slice(0, ONSETS_SHOWN).map(at).join(" ");
+  return times.length > ONSETS_SHOWN ? `${shown} +${times.length - ONSETS_SHOWN}` : shown;
+};
+function beatsLine(beats, at) {
+  if (!beats.times.length) return `  beats none${beats.reason ? ` (${beats.reason})` : ""}`;
+  return `  beats ${beats.times.length}: ${listed(beats.times, at)}${snapNote(beats.snap)}`;
+}
+function downbeatsLine(downbeats, at) {
+  if (!downbeats.times.length) return null;
+  const meter = downbeats.meter ? ` in ${downbeats.meter}` : "";
+  const low = downbeats.confidence === "low" ? ", a guess" : "";
+  return `  downbeats${meter}${low}: ${listed(downbeats.times, at)}${snapNote(downbeats.snap)}`;
+}
+function tempoLine(tempo) {
+  if (tempo.value === null) return null;
+  const bpms = tempo.curve.map((p) => p.bpm);
+  const spread = bpms.length && Math.max(...bpms) - Math.min(...bpms) >= 2 ? ` (${Math.min(...bpms)}\u2013${Math.max(...bpms)})` : "";
+  return `  tempo ${tempo.value} BPM${spread}`;
+}
+function sectionsLine(sections, at) {
+  const spans = sections.spans.map((s3) => `${s3.label} ${at(s3.start)}\u2013${at(s3.end)}`).join("  ");
+  return `  sections ${spans}${snapNote(sections.snap)}`;
+}
+function describeLine(description) {
+  const tags = description.tags.map((t) => `${t.label} ${t.score.toFixed(2)}`).join(", ");
+  return `  sounds like ${[description.text, tags].filter(Boolean).join(" \u2014 ")}`;
+}
+var LINES = [
+  ["moments", momentsLine],
+  ["onsets", hitsLine],
+  ["loudness", loudnessLine],
+  ["silence", silenceLine],
+  ["envelope", (envelope2) => `  ${sparkline(envelope2)}`],
+  ["describe", describeLine],
+  ["bpm", tempoLine],
+  ["beats", beatsLine],
+  ["downbeats", downbeatsLine],
+  ["sections", sectionsLine]
+];
+function headline(item, where) {
+  const kind = item.kind;
+  const span = item.placement ? `film ${s(item.placement.start)}\u2013${s(item.placement.end)}, file from ${s(item.placement.mediaStart)}` : `${s(item.duration ?? 0)} s`;
+  return `${where}  ${span}${kind ? `  ${kind.value} (${kind.confidence})` : ""}`;
+}
+function formatItem(item) {
+  const where = item.ref ? `${item.file} ${item.ref}` : item.file;
+  if (item.error) return [`${where}: ${item.error}`];
+  const at = (t) => s(item.placement ? filmTime(item.placement, t) : t);
+  const lines = [headline(item, where)];
+  for (const [capability, line] of LINES) {
+    const value = item[capability];
+    const text = value ? line(value, at) : null;
+    if (text) lines.push(text);
+  }
+  for (const warning of item.warnings) lines.push(`  ! ${warning}`);
+  return lines;
+}
+function formatReport(report) {
+  if (report.items.length === 0) return "No audio matched.";
+  return report.items.map((item) => formatItem(item).join("\n")).join("\n\n");
+}
+
+// src/audio/analysis/run.ts
+import { existsSync as existsSync3 } from "fs";
+var round5 = (t) => Math.round(t * 1e3) / 1e3;
+var EDGE_CONTEXT_SECONDS = 0.1;
+async function previewTarget(path, file, at, mediaStart = 0) {
+  if (at === null) return { path, file, ref: null, kind: "file", placement: null };
+  const stream = existsSync3(path) ? await probeAudio(path) : null;
+  if (stream && mediaStart >= stream.duration)
+    throw new Error(
+      `skipping ${mediaStart} s leaves nothing of ${file}, which is ${round5(stream.duration)} s long`
+    );
+  const length = stream ? stream.duration - mediaStart : 0;
+  return {
+    path,
+    file,
+    ref: null,
+    kind: "file",
+    placement: {
+      start: at,
+      end: round5(at + length),
+      dataStart: at,
+      mediaStart,
+      playbackRate: 1,
+      volume: 1
+    },
+    window: { from: mediaStart, seconds: length }
+  };
+}
+var emptyItem = (target) => ({
+  file: target.file,
+  ref: target.ref,
+  element: target.kind === "file" ? null : target.kind,
+  placement: target.placement,
+  timebase: "file",
+  window: null,
+  duration: null,
+  sampleRate: null,
+  channels: null,
+  provenance: {},
+  warnings: []
+});
+function unreadable(target) {
+  if (/^[a-z][a-z\d+.-]*:\/\//i.test(target.file)) return "remote sources are not analyzed";
+  if (!existsSync3(target.path)) return "file not found";
+  return null;
+}
+function decodeSpan(target, stream) {
+  const from = target.window?.from ?? 0;
+  const seconds = target.window?.seconds ?? stream.duration - from;
+  const before = Math.min(from, EDGE_CONTEXT_SECONDS);
+  const after = Math.max(0, Math.min(EDGE_CONTEXT_SECONDS, stream.duration - from - seconds));
+  return {
+    from,
+    read: { from: from - before, seconds: seconds + before + after },
+    context: { before, after }
+  };
+}
+var loudest = (signal) => Math.max(0, ...envelope(signal, { hopMs: 10, scale: "linear" }).values);
+function retained(signal, before, after) {
+  const skip = Math.round(before * signal.sampleRate);
+  const length = signal.channels[0]?.length ?? 0;
+  const end = Math.max(skip, length - Math.round(after * signal.sampleRate));
+  if (!skip && end >= length) return signal;
+  return { ...signal, channels: signal.channels.map((channel) => channel.subarray(skip, end)) };
+}
+async function skippedPeak(target, kept, stream) {
+  const skipped = target.kind === "file" ? target.window?.from ?? 0 : 0;
+  if (skipped <= 0) return [];
+  const head = await decodeAudio(target.path, { from: 0, seconds: skipped }, stream);
+  if (!head || loudest(head.signal) <= loudest(kept)) return [];
+  return [
+    `the loudest part of ${target.file} is in the first ${round5(skipped)} s, which is skipped`
+  ];
+}
+async function analyzeTarget(target, request, full) {
+  const item = emptyItem(target);
+  const problem = unreadable(target);
+  if (problem) return { ...item, error: problem };
+  const stream = await probeAudio(target.path);
+  if (!stream) return { ...item, error: "no audio stream" };
+  const { from, read: read2, context } = decodeSpan(target, stream);
+  const decoded = await decodeAudio(target.path, read2, stream);
+  if (!decoded) return { ...item, error: "no audio stream" };
+  const analysis = await analyzeSignal(decoded.signal, { ...request, fileOffset: from, context });
+  return {
+    ...item,
+    window: { from: round5(from), to: round5(from + analysis.analyzed) },
+    duration: round5(stream.duration),
+    sampleRate: stream.sampleRate,
+    channels: stream.channels,
+    ...analysis.values,
+    provenance: analysis.provenance,
+    ...full ? { ladder: analysis.ladder } : {},
+    warnings: [
+      ...analysis.warnings,
+      ...await skippedPeak(
+        target,
+        retained(decoded.signal, context.before, context.after),
+        stream
+      )
+    ]
+  };
+}
+async function analyzeTargets(targets, request, full = false) {
+  const items = [];
+  for (const target of targets) {
+    try {
+      items.push(await analyzeTarget(target, request, full));
+    } catch (error) {
+      const reason = error instanceof Error ? error.message.split("\n")[0] : String(error);
+      items.push({ ...emptyItem(target), error: `could not read: ${reason}` });
+    }
+  }
+  return { version: 1, items };
+}
+
+// src/audio/read/signal.ts
+var READ_RATE = 22050;
+var PITCH_RATE = 8e3;
+var SILENT_DB = -120;
+async function decodeMono(path, sampleRate = READ_RATE) {
+  const decoded = await decodeAudio(path, {}, void 0, { sampleRate, mono: true });
+  if (!decoded) throw new Error(`${path} has no audio stream`);
+  return decoded.signal.channels[0];
+}
+var asSignal = (samples, sampleRate = READ_RATE) => ({
+  sampleRate,
+  channels: [samples]
+});
+function mixed(tracks) {
+  const length = Math.max(0, ...tracks.map((t) => t.length));
+  const sum = new Float32Array(length);
+  for (const track2 of tracks) for (let i = 0; i < track2.length; i++) sum[i] += track2[i];
+  return sum;
+}
+function levels(samples, sampleRate, hop, window = hop * 2) {
+  const hopSamples = Math.max(1, hop * sampleRate);
+  const half = Math.max(1, Math.round(window * sampleRate / 2));
+  const squares = new Float64Array(samples.length + 1);
+  for (let i = 0; i < samples.length; i++) squares[i + 1] = squares[i] + samples[i] ** 2;
+  const frames = Math.ceil(samples.length / hopSamples);
+  const out = new Float32Array(frames);
+  for (let f = 0; f < frames; f++) {
+    const center = Math.round(f * hopSamples);
+    const a = Math.max(0, center - half);
+    const b = Math.min(samples.length, center + half);
+    const power = b > a ? (squares[b] - squares[a]) / (b - a) : 0;
+    out[f] = power > 0 ? Math.max(SILENT_DB, 10 * Math.log10(power)) : SILENT_DB;
+  }
+  return out;
+}
+function quantile(values, q) {
+  if (!values.length) return NaN;
+  const sorted = Float64Array.from(values).sort();
+  return sorted[Math.min(sorted.length - 1, Math.max(0, Math.floor(q * (sorted.length - 1))))];
+}
+var median = (values) => quantile(values, 0.5);
+var round6 = (n, places = 2) => {
+  const k = 10 ** places;
+  return Math.round(n * k) / k;
+};
+
+// src/audio/read/pitch.ts
+var FRAME = 320;
+var HOP = 320;
+var LOW_HZ = 70;
+var HIGH_HZ = 500;
+var VOICED_DB = -35;
+var PERIODIC = 0.15;
+var MIN_LAG = Math.floor(PITCH_RATE / HIGH_HZ);
+var MAX_LAG = Math.ceil(PITCH_RATE / LOW_HZ);
+function voiced(pcm, start) {
+  let energy = 0;
+  for (let i = 0; i < FRAME; i++) energy += pcm[start + i] ** 2;
+  return 10 * Math.log10(energy / FRAME + 1e-12) >= VOICED_DB;
+}
+function difference(pcm, start, tau) {
+  let sum = 0;
+  for (let i = 0; i < FRAME; i++) {
+    const delta = pcm[start + i] - pcm[start + i + tau];
+    sum += delta * delta;
+  }
+  return sum;
+}
+function periodOf(pcm, start, d) {
+  let running = 0;
+  let lag = -1;
+  for (let tau = 1; tau <= MAX_LAG; tau++) {
+    const sum = difference(pcm, start, tau);
+    running += sum;
+    d[tau] = running > 0 ? sum * tau / running : 1;
+    if (lag === -1) {
+      if (tau >= MIN_LAG && d[tau] < PERIODIC) lag = tau;
+    } else if (d[tau] > d[tau - 1]) break;
+    else if (d[tau] < d[lag]) lag = tau;
+  }
+  return lag;
+}
+function pitchTrack(pcm) {
+  const out = [];
+  const d = new Float64Array(MAX_LAG + 1);
+  for (let start = 0; start + FRAME + MAX_LAG <= pcm.length; start += HOP) {
+    if (!voiced(pcm, start)) continue;
+    const lag = periodOf(pcm, start, d);
+    if (lag > 0) out.push({ t: (start + FRAME / 2) / PITCH_RATE, hz: PITCH_RATE / lag });
+  }
+  return out;
+}
+function within2(track2, start, end) {
+  let lo = 0;
+  let hi = track2.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (track2[mid].t < start) lo = mid + 1;
+    else hi = mid;
+  }
+  const out = [];
+  for (let i = lo; i < track2.length && track2[i].t < end; i++) out.push(track2[i].hz);
+  return out;
+}
+var semitones = (a, b) => 12 * Math.log2(a / b);
+
+// src/audio/read/format.ts
+var PITCH_NOTE_SEMITONES = 3;
+var KIND_WIDTH = 7;
+var s2 = (t) => t.toFixed(1);
+var signed = (db) => `${db >= 0 ? "+" : ""}${db} dB`;
+function when(line) {
+  return line.end === null ? s2(line.start) : `${s2(line.start)}\u2013${s2(line.end)}`;
+}
+function voiceLine(sentence, voice) {
+  const { unit, meanRate, medianPitchHz } = voice;
+  const parts = [sentence.text === null ? "(no transcript)" : `"${sentence.text}"`];
+  if (sentence.rate !== null)
+    parts.push(`${sentence.rate} ${unit}/s${meanRate !== null ? ` (mean ${meanRate})` : ""}`);
+  if (sentence.pitchHz !== null && medianPitchHz !== null && Math.abs(semitones(sentence.pitchHz, medianPitchHz)) >= PITCH_NOTE_SEMITONES)
+    parts.push(`pitch ${sentence.pitchHz} Hz (median ${medianPitchHz})`);
+  if (sentence.ending && sentence.ending !== "level") parts.push(`${sentence.ending} end`);
+  return { start: sentence.start, end: sentence.end, kind: "voice", text: parts.join("  ") };
+}
+function placeOf(t, pauses) {
+  const pause = pauses.find((p) => t >= p.start && t < p.end);
+  return pause ? `${(t - pause.start).toFixed(1)} s into the pause` : null;
+}
+function standing(effect, musicRead) {
+  if (effect.overMusicDb !== null) return `${signed(effect.overMusicDb)} over music`;
+  return musicRead ? "while the music is out" : `${signed(effect.riseDb)} over what played before`;
+}
+function effectLine(effect, pauses, musicRead) {
+  const parts = [
+    `${effect.kind}${effect.count > 1 ? ` \xD7${effect.count}` : ""} (${effect.group}): ${effect.band}`,
+    `attack ${effect.attackMs} ms`,
+    `tail ${effect.tail.toFixed(1)} s`,
+    standing(effect, musicRead)
+  ];
+  const place = placeOf(effect.t, pauses);
+  if (place) parts.push(place);
+  return { start: effect.t, end: null, kind: "effect", text: parts.join(", ") };
+}
+var ENTRY = {
+  start: "",
+  new: ", first appearance after a break",
+  resumes: ", resumes after a break",
+  returns: ", returns"
+};
+function musicLine(segment, analysis) {
+  const piece = analysis.music.pieces.find((p) => p.id === segment.piece);
+  const about = [piece.instruments.join(", "), segment.bpm ? `${segment.bpm} BPM` : null].filter(Boolean).join(" \xB7 ");
+  const fade = segment.fadeFrom !== null ? `, fades from ${s2(segment.fadeFrom)}` : "";
+  return {
+    start: segment.start,
+    end: segment.end,
+    kind: "music",
+    text: `piece ${piece.id}${about ? ` (${about})` : ""}${ENTRY[segment.entry]}${fade}`
+  };
+}
+function overlaps(line, range) {
+  if (!range) return true;
+  return line.start < range[1] && (line.end ?? line.start) >= range[0];
+}
+function header(analysis) {
+  const { voice, effects, music } = analysis;
+  const separated2 = analysis.separation === "stems" ? `stems: ${analysis.stems.join(", ")}` : "not separated";
+  const lines = [`${analysis.file} \xB7 ${s2(analysis.duration)} s \xB7 ${separated2}`];
+  if (voice) {
+    const rate = voice.meanRate !== null ? `mean ${voice.meanRate} ${voice.unit}/s` : null;
+    const pitch = voice.medianPitchHz !== null ? `median pitch ${voice.medianPitchHz} Hz` : null;
+    lines.push(
+      `voice: ${voice.sentences.length} lines, ${voice.pauses.length} pauses${[rate, pitch].filter(Boolean).map((p) => `, ${p}`).join("")}`
+    );
+  }
+  if (effects) {
+    const top = effects.groups.slice(0, 6).map((g) => `${g.id} ${g.kind} \xD7${g.count}`).join(", ");
+    lines.push(
+      `effects: ${effects.events.length} in ${effects.groups.length} sounds${top ? ` (${top})` : ""}${effects.drumHits ? `; ${effects.drumHits} drum hits on the beat left out` : ""}`
+    );
+  }
+  if (music) lines.push(`music: ${music.pieces.length} pieces, ${music.breaks.length} breaks`);
+  return lines;
+}
+function formatRead(analysis, range) {
+  const { voice, effects } = analysis;
+  const pauses = voice?.pauses ?? [];
+  const lines = [
+    ...voice?.sentences.map((x) => voiceLine(x, voice)) ?? [],
+    ...pauses.map((p) => ({
+      start: p.start,
+      end: p.end,
+      kind: "pause",
+      text: `${(p.end - p.start).toFixed(1)} s`
+    })),
+    ...effects?.events.map((e) => effectLine(e, pauses, analysis.music !== null)) ?? [],
+    ...analysis.music?.segments.map((m) => musicLine(m, analysis)) ?? [],
+    ...analysis.music?.breaks.map((b) => ({
+      start: b.start,
+      end: b.end,
+      kind: "music",
+      text: `break ${(b.end - b.start).toFixed(1)} s`
+    })) ?? []
+  ].filter((line) => overlaps(line, range)).sort((a, b) => a.start - b.start || (a.end ?? a.start) - (b.end ?? b.start));
+  const width = Math.max(0, ...lines.map((l) => when(l).length));
+  const body = lines.map((l) => `${when(l).padEnd(width)}  ${l.kind.padEnd(KIND_WIDTH)} ${l.text}`);
+  const warnings = analysis.warnings.map((w) => `! ${w}`);
+  return [...header(analysis), "", ...body, ...warnings.length ? ["", ...warnings] : []].join(
+    "\n"
+  );
+}
+
+// src/audio/read/read.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  createReadStream,
+  existsSync as existsSync5,
+  mkdirSync as mkdirSync2,
+  readFileSync as readFileSync2,
+  renameSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { basename, extname, join as join6 } from "path";
+
+// src/audio/read/effects.ts
+var HOP2 = 0.01;
+var FLOOR_FRAMES = 150;
+var FLOOR_EVERY = 10;
+var RISE_DB = 20;
+var STEP_DB = 6;
+var AUDIBLE_DB = -60;
+var MASKED_DB = 20;
+var MUSIC_OUT_DB = -60;
+var TAIL_DB = 30;
+var LONGEST = 4;
+var SAME_SOUND = 0.95;
+var TRAIN_GAP = 0.2;
+var BEAT_SLACK = 0.05;
+var ON_BEAT_SHARE = 0.7;
+var DRUM_GROUP_MIN = 8;
+var LOW_HZ2 = 150;
+var BAND_FPS = 100;
+function floors(db) {
+  const out = new Float32Array(db.length);
+  let current = db[0] ?? -120;
+  for (let f = 0; f < db.length; f++) {
+    if (f % FLOOR_EVERY === 0 && f > 0)
+      current = quantile(db.subarray(Math.max(0, f - FLOOR_FRAMES), f), 0.2);
+    out[f] = current;
+  }
+  return out;
+}
+var BLOCK = 1e-3;
+function refined(samples, sampleRate, frame2, floorDb) {
+  const block = Math.max(1, Math.round(BLOCK * sampleRate));
+  const from = Math.max(0, Math.round((frame2 - 2) * HOP2 * sampleRate));
+  const to = Math.min(samples.length, Math.round((frame2 + 2) * HOP2 * sampleRate));
+  for (let a = from; a + block <= to; a += block) {
+    let power = 0;
+    for (let i = a; i < a + block; i++) power += samples[i] ** 2;
+    if (10 * Math.log10(power / block + 1e-12) >= floorDb + RISE_DB / 2) return a / sampleRate;
+  }
+  return frame2 * HOP2;
+}
+function extent(db, f, floor) {
+  let onset = f;
+  while (onset > Math.max(0, f - 50) && db[onset - 1] > floor + STEP_DB) onset--;
+  let peak = f;
+  let end = f;
+  const last = Math.min(db.length - 1, f + LONGEST / HOP2);
+  for (let g = f; g <= last; g++) {
+    if (db[g] > db[peak]) peak = g;
+    end = g;
+    if (g > peak && (db[g] < db[peak] - TAIL_DB || db[g] < floor + 3)) break;
+  }
+  return { onset, peak, end };
+}
+function startsHere(db, f, floor) {
+  const level = db[f];
+  if (level < AUDIBLE_DB || level - floor < RISE_DB) return false;
+  return level - Math.min(db[f - 1], db[f - 2], db[f - 3], db[f - 4], db[f - 5]) >= STEP_DB;
+}
+function detect(db, samples, sampleRate, skip) {
+  const floor = floors(db);
+  const found = [];
+  for (let f = 5; f < db.length; f++) {
+    if (!startsHere(db, f, floor[f])) continue;
+    const { onset, peak, end } = extent(db, f, floor[f]);
+    const t = refined(samples, sampleRate, onset, floor[f]);
+    if (!skip(t))
+      found.push({
+        t,
+        peak: peak * HOP2,
+        end: end * HOP2,
+        peakDb: db[peak],
+        riseDb: db[peak] - floor[f]
+      });
+    f = Math.max(end, onset + 8);
+  }
+  return found;
+}
+var BIN_HZ = 22050 / 1024;
+var EDGES = (() => {
+  const edges = [];
+  for (let hz = 30; hz < 9e3; hz *= 2 ** (1 / 5)) edges.push(Math.max(1, Math.round(hz / BIN_HZ)));
+  return edges;
+})();
+var bandHz = (k) => 30 * 2 ** ((k + 0.5) / 5);
+var WIDTH = EDGES.slice(0, -1).map((edge, k) => Math.max(edge + 1, EDGES[k + 1]) - edge);
+var energies = (power) => Array.from(power, (v, k) => Math.expm1(v) * WIDTH[k]);
+var BANDS_PER_PRINT = 5;
+function shape(bands, from, to) {
+  const a = Math.max(0, Math.floor(from * BAND_FPS));
+  const b = Math.max(a + 1, Math.min(bands.length, Math.ceil(to * BAND_FPS)));
+  const size = bands[0]?.length ?? 0;
+  const mean = new Float64Array(size);
+  for (let f = a; f < b; f++) for (let k = 0; k < size; k++) mean[k] += bands[f][k] / (b - a);
+  return mean;
+}
+function lowShare(power) {
+  const e = energies(power);
+  const total = e.reduce((a, b) => a + b, 0);
+  const low = e.reduce((sum, p, k) => sum + (bandHz(k) < LOW_HZ2 ? p : 0), 0);
+  return total > 0 ? low / total : 0;
+}
+function centroidHz(power) {
+  const e = energies(power);
+  const weight = e.reduce((a, b) => a + b, 0);
+  const sum = e.reduce((acc, p, k) => acc + p * Math.log2(bandHz(k)), 0);
+  return weight > 0 ? 2 ** (sum / weight) : 0;
+}
+var tonal = (power) => {
+  const sorted = Float64Array.from(power).sort();
+  return sorted[sorted.length - 1] - sorted[Math.floor(sorted.length * 0.75)] >= 2.5;
+};
+var KINDS = [
+  [(s3) => s3.length >= 0.8 && s3.attack >= 0.45 * s3.length, () => "riser"],
+  [(s3) => s3.band === "low", (s3) => s3.tail >= 0.6 ? "boom" : "thump"],
+  [(s3) => s3.length <= 0.15, (s3) => s3.centroid >= 3e3 ? "tick" : "click"],
+  [(s3) => s3.tonal && s3.tail >= 0.4, () => "ding"],
+  [(s3) => s3.attack >= 0.06 && s3.length <= 1.5, () => "whoosh"]
+];
+function bandOf(low, centroid) {
+  if (low >= 0.5) return "low";
+  return centroid >= 2500 ? "high" : "mid";
+}
+function kindOf(found, power) {
+  const centroid = centroidHz(power);
+  const shape2 = {
+    length: found.end - found.t,
+    attack: found.peak - found.t,
+    tail: found.end - found.peak,
+    band: bandOf(lowShare(power), centroid),
+    centroid,
+    tonal: tonal(power)
+  };
+  const kind = KINDS.find(([fits]) => fits(shape2))?.[1](shape2) ?? "hit";
+  return { kind, band: shape2.band };
+}
+function printOf(power) {
+  const e = energies(power);
+  const octaves = new Float64Array(Math.ceil(e.length / BANDS_PER_PRINT));
+  e.forEach((p, k) => octaves[Math.floor(k / BANDS_PER_PRINT)] += p);
+  const total = octaves.reduce((a, b) => a + b, 0);
+  return octaves.map((p) => total > 0 ? Math.sqrt(p / total) : 0);
+}
+function cosine(a, b) {
+  let dot2 = 0;
+  let na = 0;
+  let nb = 0;
+  for (let k = 0; k < a.length; k++) {
+    dot2 += a[k] * b[k];
+    na += a[k] ** 2;
+    nb += b[k] ** 2;
+  }
+  return na && nb ? dot2 / Math.sqrt(na * nb) : 0;
+}
+function grouped(events) {
+  const prints = [];
+  for (const event of events) {
+    const length = event.end - event.t;
+    let best = -1;
+    let bestScore = SAME_SOUND;
+    prints.forEach((p, i) => {
+      const ratio = length / p.length;
+      if (ratio < 0.5 || ratio > 2) return;
+      const score = cosine(
+        event.print,
+        p.sum.map((v) => v / p.n)
+      );
+      if (score >= bestScore) {
+        best = i;
+        bestScore = score;
+      }
+    });
+    if (best < 0) {
+      prints.push({ sum: Float64Array.from(event.print), n: 1, length });
+      best = prints.length - 1;
+    } else {
+      const p = prints[best];
+      event.print.forEach((v, k) => p.sum[k] += v);
+      p.length = (p.length * p.n + length) / (p.n + 1);
+      p.n++;
+    }
+    event.group = best;
+  }
+  return prints.map((p) => p.sum);
+}
+function onBeat(t, beats) {
+  let lo = 0;
+  let hi = beats.length;
+  while (lo < hi) {
+    const mid = lo + hi >> 1;
+    if (beats[mid] < t) lo = mid + 1;
+    else hi = mid;
+  }
+  const near = [beats[lo - 1], beats[lo]].filter((b) => b !== void 0);
+  return near.some((b) => Math.abs(b - t) <= BEAT_SLACK);
+}
+function majority(kinds) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const k of kinds) counts.set(k, (counts.get(k) ?? 0) + 1);
+  return [...counts].sort((a, b) => b[1] - a[1])[0][0];
+}
+function measured2(input) {
+  const db = levels(input.source, input.sampleRate, HOP2);
+  const inSpeech = (t) => input.speech.some((s3) => t >= s3.start && t < s3.end);
+  const heardDb = input.heard ? levels(input.heard, input.sampleRate, HOP2, 0.5) : null;
+  const masked = (f) => {
+    const level = heardDb?.[Math.round(f.peak / HOP2)];
+    return level !== void 0 && f.peakDb < level - MASKED_DB;
+  };
+  const found = detect(db, input.source, input.sampleRate, inSpeech).filter((f) => !masked(f));
+  const bands = found.length ? bandFramesOf(asSignal(input.source, input.sampleRate)).bands : [];
+  const out = found.map((f) => {
+    const power = shape(bands, f.t, Math.min(f.end, f.t + 0.4));
+    return { ...f, ...kindOf(f, power), print: printOf(power), group: -1 };
+  });
+  grouped(out);
+  return out;
+}
+function drumGroups(members, beats) {
+  const drums = /* @__PURE__ */ new Set();
+  if (!beats.length) return drums;
+  for (const [id, list] of members) {
+    const onBeats = list.filter((m) => onBeat(m.t, beats)).length;
+    if (list.length >= DRUM_GROUP_MIN && onBeats >= ON_BEAT_SHARE * list.length) drums.add(id);
+  }
+  return drums;
+}
+function effectOf(m, group, kind, musicDb) {
+  const musicLevel = musicDb?.[Math.round(m.peak / HOP2)];
+  const musicPlays = musicLevel !== void 0 && musicLevel > MUSIC_OUT_DB;
+  return {
+    t: round6(m.t),
+    end: round6(m.end),
+    kind,
+    group,
+    band: m.band,
+    attackMs: Math.round((m.peak - m.t) * 1e3),
+    tail: round6(m.end - m.peak),
+    riseDb: Math.round(m.riseDb),
+    overMusicDb: musicPlays ? Math.round(m.peakDb - musicLevel) : null,
+    count: 1
+  };
+}
+function findEffects(input) {
+  const sounds = measured2(input);
+  const members = /* @__PURE__ */ new Map();
+  for (const m of sounds) members.set(m.group, [...members.get(m.group) ?? [], m]);
+  const drums = drumGroups(members, input.beats);
+  const kept = [...members].filter(([id]) => !drums.has(id)).sort((a, b) => b[1].length - a[1].length);
+  const names = new Map(kept.map(([id], i) => [id, `S${i + 1}`]));
+  const groups = kept.map(([id, list]) => ({
+    id: names.get(id),
+    kind: majority(list.map((m) => m.kind)),
+    count: list.length
+  }));
+  const kindOfGroup = new Map(groups.map((g) => [g.id, g.kind]));
+  const musicDb = input.music ? levels(input.music, input.sampleRate, HOP2, 0.5) : null;
+  const events = [];
+  for (const m of sounds) {
+    if (drums.has(m.group)) continue;
+    const group = names.get(m.group);
+    const previous = events[events.length - 1];
+    if (previous?.group === group && m.t - previous.end <= TRAIN_GAP) {
+      previous.end = round6(m.end);
+      previous.count++;
+    } else events.push(effectOf(m, group, kindOfGroup.get(group) ?? m.kind, musicDb));
+  }
+  const drumHits = [...drums].reduce((n, id) => n + members.get(id).length, 0);
+  return { events, groups, drumHits };
+}
+
+// src/audio/read/music.ts
+var HOP3 = 0.1;
+var ABSENT_DB = -55;
+var CUT_DB = 25;
+var RUNNING_FRAMES = 200;
+var LEVEL_WINDOW = 0.4;
+var CONTEXT = 2;
+var SHORTEST_BREAK = 0.5;
+var LONGEST_REST = 1;
+var SHORTEST_SEGMENT = 1;
+var SAME_PIECE = 0.92;
+var SAME_TEMPO = 0.06;
+var SAME_MIX = 0.25;
+var RESUMING_GAP = 5;
+var RESUMING_PIECE = 0.85;
+var RESUMING_MIX = 0.35;
+var FADE_DB = 10;
+var FADE_WINDOW = 3;
+var ENERGY_WINDOW = 30;
+var LEADING_SHARE = 0.2;
+function joined(spans, tooShort2) {
+  const out = [];
+  for (const span of spans) {
+    const last = out[out.length - 1];
+    if (last && (tooShort2(span) || last.quiet === span.quiet)) last.end = span.end;
+    else out.push({ ...span });
+  }
+  return out;
+}
+function powerDb(db, start, end) {
+  const a = Math.max(0, Math.round(start / HOP3));
+  const b = Math.min(db.length, Math.round(end / HOP3));
+  let sum = 0;
+  for (let f = a; f < b; f++) sum += 10 ** (db[f] / 10);
+  return b > a ? 10 * Math.log10(sum / (b - a) || 1e-12) : Number.NEGATIVE_INFINITY;
+}
+function holdsUp(db, span) {
+  const inside = powerDb(db, span.start, span.end);
+  const around = Math.max(
+    powerDb(db, span.start - CONTEXT, span.start),
+    powerDb(db, span.end, span.end + CONTEXT)
+  );
+  return inside < ABSENT_DB || inside < around - CUT_DB;
+}
+var tooShort = (span) => span.end - span.start < (span.quiet ? SHORTEST_BREAK : SHORTEST_SEGMENT);
+function candidates(quiet, from, to, absorbed = tooShort) {
+  const spans = [];
+  for (let f = from; f < to; f++) {
+    const isQuiet = quiet[f] === 1;
+    const last = spans[spans.length - 1];
+    if (last && last.quiet === isQuiet) last.end = (f + 1) * HOP3;
+    else spans.push({ quiet: isQuiet, start: f * HOP3, end: (f + 1) * HOP3 });
+  }
+  return joined(spans, absorbed);
+}
+function silencesIn(db, span) {
+  const from = Math.round(span.start / HOP3);
+  const to = Math.min(db.length, Math.round(span.end / HOP3));
+  const absent = new Uint8Array(db.length);
+  for (let f = from; f < to; f++) absent[f] = db[f] < ABSENT_DB ? 1 : 0;
+  const shortSilence = (s3) => s3.quiet && s3.end - s3.start < LONGEST_REST;
+  return candidates(absent, from, to, shortSilence).map(
+    (s3) => s3.quiet && !holdsUp(db, s3) ? { ...s3, quiet: false } : s3
+  );
+}
+function runs(db) {
+  const quiet = new Uint8Array(db.length);
+  const heard = [];
+  for (let f = 0; f < db.length; f++) {
+    const level = db[f];
+    const reference = heard.length ? median(heard.slice(-RUNNING_FRAMES)) : Number.NEGATIVE_INFINITY;
+    quiet[f] = level < ABSENT_DB || level < reference - CUT_DB ? 1 : 0;
+    if (!quiet[f]) heard.push(level);
+  }
+  const merged = candidates(quiet, 0, db.length).flatMap(
+    (span) => span.quiet && !holdsUp(db, span) ? silencesIn(db, span) : [span]
+  );
+  const settled = joined(merged, (s3) => !s3.quiet && s3.end - s3.start < SHORTEST_SEGMENT);
+  return {
+    segments: settled.filter((s3) => !s3.quiet),
+    breaks: settled.filter((s3) => s3.quiet && s3.start > 0 && s3.end < db.length * HOP3)
+  };
+}
+function chromaOf(chroma, fps, run) {
+  const a = Math.floor(run.start * fps);
+  const b = Math.max(a + 1, Math.min(chroma.length, Math.ceil(run.end * fps)));
+  const sum = new Float64Array(12);
+  for (let f = a; f < b; f++) chroma[f]?.forEach((v, k) => sum[k] += v);
+  const norm = Math.hypot(...sum);
+  return norm ? sum.map((v) => v / norm) : sum;
+}
+var dot = (a, b) => a.reduce((n, v, k) => n + v * b[k], 0);
+function energyOf(samples, sampleRate, run) {
+  const a = Math.floor(run.start * sampleRate);
+  const b = Math.min(samples.length, Math.floor(run.end * sampleRate));
+  let sum = 0;
+  for (let i = a; i < b; i++) sum += samples[i] ** 2;
+  return b > a ? sum / (b - a) : 0;
+}
+function shares(input, run) {
+  const energies2 = Object.entries(input.stems).map(
+    ([name, samples]) => [name, energyOf(samples, input.sampleRate, run)]
+  );
+  const total = energies2.reduce((n, [, e]) => n + e, 0);
+  return Object.fromEntries(energies2.map(([name, e]) => [name, total ? e / total : 0]));
+}
+function mixDistance(a, b) {
+  return Object.keys(a).reduce((n, k) => n + Math.abs(a[k] - (b[k] ?? 0)), 0) / 2;
+}
+function bpmOf(beats, run) {
+  const inside = beats.filter((t) => t >= run.start && t < run.end);
+  const interval = inside.length >= 4 ? medianInterval(inside) : null;
+  return interval ? Math.round(60 / interval) : null;
+}
+var sameTempo = (a, b) => a === null || b === null || Math.abs(a - b) / Math.max(a, b) <= SAME_TEMPO;
+function fadeFrom(db, run) {
+  const a = Math.floor(run.start / HOP3);
+  const b = Math.min(db.length, Math.floor(run.end / HOP3));
+  const body = median(db.subarray(a, b));
+  const last = db[b - 1] ?? body;
+  if (body - last < FADE_DB) return null;
+  for (let f = Math.max(a, b - FADE_WINDOW / HOP3); f < b; f++)
+    if (db[f] < body - 3) return round6(f * HOP3, 1);
+  return null;
+}
+var alike = (p, heard, piece, mix) => dot(p.print, heard.print) >= piece && mixDistance(p.mix, heard.mix) <= mix && sameTempo(p.bpm, heard.bpm);
+function pieceOf(pieces, previous, heard) {
+  const last = previous && pieces.find((p) => p.id === previous.piece);
+  if (last && heard.run.start - previous.end <= RESUMING_GAP && alike(last, heard, RESUMING_PIECE, RESUMING_MIX))
+    return last;
+  return pieces.find((p) => alike(p, heard, SAME_PIECE, SAME_MIX));
+}
+function newPiece(id, heard) {
+  return {
+    id,
+    instruments: Object.entries(heard.mix).filter(([, share]) => share >= LEADING_SHARE).sort((a, b) => b[1] - a[1]).map(([name]) => name),
+    bpm: heard.bpm,
+    firstAt: round6(heard.run.start),
+    print: heard.print,
+    mix: heard.mix
+  };
+}
+function energyCurve(melodic, sampleRate, duration) {
+  const energy = [];
+  for (let start = 0; start < duration; start += ENERGY_WINDOW) {
+    const end = Math.min(duration, start + ENERGY_WINDOW);
+    const power = energyOf(melodic, sampleRate, { start, end });
+    energy.push({
+      start,
+      end: round6(end),
+      db: power > 0 ? Math.round(10 * Math.log10(power)) : -120
+    });
+  }
+  return energy;
+}
+function readMusic(input) {
+  const melodic = mixed(Object.values(input.stems));
+  const db = levels(melodic, input.sampleRate, HOP3, LEVEL_WINDOW);
+  const { segments: found, breaks } = runs(db);
+  const frames = bandFramesOf(asSignal(melodic, input.sampleRate));
+  const beats = rhythm(
+    asSignal(input.drums ? mixed([melodic, input.drums]) : melodic, input.sampleRate)
+  ).beats.times;
+  const pieces = [];
+  const segments = [];
+  for (const run of found) {
+    const heard = {
+      run,
+      print: chromaOf(frames.chroma, frames.chromaFps, run),
+      mix: shares(input, run),
+      bpm: bpmOf(beats, run)
+    };
+    const previous = segments[segments.length - 1];
+    let piece = pieceOf(pieces, previous, heard);
+    let entry;
+    if (piece) entry = previous?.piece === piece.id ? "resumes" : "returns";
+    else {
+      piece = newPiece(pieces.length + 1, heard);
+      pieces.push(piece);
+      entry = previous ? "new" : "start";
+    }
+    segments.push({
+      start: round6(run.start),
+      end: round6(run.end),
+      piece: piece.id,
+      entry,
+      bpm: heard.bpm,
+      fadeFrom: fadeFrom(db, run)
+    });
+  }
+  return {
+    music: {
+      segments,
+      pieces: pieces.map(({ print: _print, mix: _mix, ...piece }) => piece),
+      breaks: breaks.map((b) => ({ start: round6(b.start), end: round6(b.end) })),
+      energy: energyCurve(melodic, input.sampleRate, db.length * HOP3)
+    },
+    beats
+  };
+}
+
+// src/audio/read/stems.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { existsSync as existsSync4, mkdirSync, readFileSync, statSync, writeFileSync } from "fs";
+import { mkdtemp as mkdtemp2, rm as rm2 } from "fs/promises";
+import { tmpdir as tmpdir2 } from "os";
+import { join as join5 } from "path";
+import { setTimeout as sleep } from "timers/promises";
+var URL_ENV2 = "HYPERFRAMES_AUDIO_STEMS_URL";
+var KEY_ENV2 = "HYPERFRAMES_AUDIO_API_KEY";
+var TIMEOUT_ENV2 = "HYPERFRAMES_AUDIO_STEMS_TIMEOUT_MS";
+var DEFAULT_TIMEOUT_MS2 = 30 * 6e4;
+var RETRY_MS = 5e3;
+var DONE = "stems.json";
+var STEM_NAMES = ["vocals", "drums", "bass", "guitar", "piano", "other"];
+var VOICE_STEM = "vocals";
+var DRUM_STEM = "drums";
+var stemsAccess = () => serviceAccess(
+  { url: URL_ENV2, key: KEY_ENV2, timeout: TIMEOUT_ENV2 },
+  "/v3/audio/stems",
+  DEFAULT_TIMEOUT_MS2
+);
+function cachedStems(dir) {
+  const done = join5(dir, DONE);
+  if (!existsSync4(done)) return null;
+  const names = JSON.parse(readFileSync(done, "utf8"));
+  if (!STEM_NAMES.every((name) => typeof names[name] === "string")) return null;
+  const paths = Object.fromEntries(STEM_NAMES.map((name) => [name, join5(dir, names[name])]));
+  return Object.values(paths).every((p) => existsSync4(p)) ? paths : null;
+}
+var StillRunning = class extends Error {
+};
+var DROPPED = /* @__PURE__ */ new Set(["UND_ERR_HEADERS_TIMEOUT", "UND_ERR_SOCKET"]);
+var dropped = (error) => error instanceof TypeError && DROPPED.has(error.cause?.code ?? "");
+async function stillRunning(response) {
+  if (response.status !== 409) return false;
+  const body = await response.clone().json().catch(() => null);
+  return body?.error?.code === "request_in_progress";
+}
+async function job(response) {
+  if (await stillRunning(response)) throw new StillRunning();
+  if (!response.ok) throw await serviceFailure(response, "the stems service");
+  const body = await response.json();
+  const value = body && "data" in body ? body.data : body;
+  if (!value?.id || !value.status) throw new Error("the stems service answered without a job");
+  return value;
+}
+async function encoded(path, dir, signal) {
+  const ffmpeg = findFfBinary("ffmpeg", { configuredMustExist: true });
+  if (!ffmpeg) throw new Error("ffmpeg is required to separate stems; run: npx hyperframes doctor");
+  const out = join5(dir, "upload.mp3");
+  await runFile(
+    ffmpeg,
+    ["-v", "error", "-y", "-i", path, "-vn", "-ac", "2", "-ar", "44100", "-b:a", "192k", out],
+    { windowsHide: true, maxBuffer: 8 * 1024 * 1024, signal }
+  );
+  return out;
+}
+async function separated(url, request, signal) {
+  for (; ; ) {
+    try {
+      return await job(await fetch(url, { ...request, signal }));
+    } catch (error) {
+      if (!(error instanceof StillRunning || dropped(error))) throw error;
+      await sleep(RETRY_MS, void 0, { signal });
+    }
+  }
+}
+async function fetchStems(path, dir, { url, headers, timeoutMs }) {
+  const signal = AbortSignal.timeout(timeoutMs);
+  const scratch = await mkdtemp2(join5(tmpdir2(), "hf-stems-"));
+  try {
+    const mp3 = await encoded(path, scratch, signal);
+    const client = new HyperframesCloudClient({
+      baseUrl: new URL(url).origin,
+      getAuthHeaders: () => headers,
+      fetchImpl: (input, init) => fetch(input, { ...init, redirect: "error", signal })
+    });
+    const asset = await uploadAssetViaDirectUpload({
+      client,
+      path: mp3,
+      size: statSync(mp3).size,
+      filename: "audio.mp3",
+      contentType: "audio/mpeg",
+      idempotencyKey: randomUUID2(),
+      signal
+    });
+    const current = await separated(
+      url,
+      {
+        method: "POST",
+        redirect: "error",
+        headers: {
+          ...headers,
+          "idempotency-key": randomUUID2(),
+          "content-type": "application/json"
+        },
+        body: JSON.stringify({ version: 1, audio: { type: "asset_id", asset_id: asset.asset_id } })
+      },
+      signal
+    );
+    if (current.status !== "completed")
+      throw new Error(
+        `stem separation failed${current.failure_message ? `: ${current.failure_message}` : ""}`
+      );
+    const stems = current.stems ?? [];
+    const missing = STEM_NAMES.filter((name) => !stems.some((stem) => stem.name === name));
+    if (missing.length)
+      throw new Error(
+        `the stems service returned an incomplete separation: missing ${missing.join(", ")}`
+      );
+    mkdirSync(dir, { recursive: true });
+    const names = {};
+    for (const name of STEM_NAMES) {
+      const stem = stems.find((candidate) => candidate.name === name);
+      if (!stem) continue;
+      const file = `${name}.audio`;
+      await downloadToFile(stem.url, join5(dir, file), { signal });
+      names[name] = file;
+    }
+    writeFileSync(join5(dir, DONE), JSON.stringify(names));
+    return cachedStems(dir);
+  } finally {
+    await rm2(scratch, { recursive: true, force: true });
+  }
+}
+
+// src/audio/read/types.ts
+var READ_VERSION = 2;
+
+// src/audio/read/voice.ts
+var SENTENCE_END = /[。！？!?…；;.]["'”’」』)]*$/;
+var SENTENCE_GAP = 0.6;
+var LONGEST_SENTENCE = 60;
+var PAUSE_SECONDS = 0.4;
+var CJK = /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}\p{Script=Hangul}]/gu;
+var LETTERS = new RegExp("\\p{L}", "u");
+var ENDING_SEMITONES = 2;
+var MIN_PITCH_FRAMES = 5;
+function rateUnit(words) {
+  const text = words.map((w) => w.text).join("");
+  return (text.match(CJK)?.length ?? 0) * 2 >= text.replace(/\s/g, "").length ? "chars" : "words";
+}
+function spoken(words, unit) {
+  if (unit === "chars") return words.reduce((n, w) => n + (w.text.match(CJK)?.length ?? 0), 0);
+  return words.filter((w) => LETTERS.test(w.text)).length;
+}
+function joined2(words, unit) {
+  return unit === "chars" ? words.map((w) => w.text.trim()).join("") : words.map((w) => w.text.trim()).join(" ").replace(/\s+([,.!?;:])/g, "$1");
+}
+function sentenceGroups(words) {
+  const groups = [];
+  let current = [];
+  let chars = 0;
+  words.forEach((word, i) => {
+    current.push(word);
+    chars += word.text.length;
+    const next = words[i + 1];
+    if (!next || SENTENCE_END.test(word.text.trim()) || next.start - word.end >= SENTENCE_GAP || chars >= LONGEST_SENTENCE) {
+      groups.push(current);
+      current = [];
+      chars = 0;
+    }
+  });
+  return groups;
+}
+function ending(track2, start, end) {
+  const split = start + (end - start) * 0.7;
+  const body = within2(track2, start, split);
+  const tail = within2(track2, split, end);
+  if (body.length < MIN_PITCH_FRAMES || tail.length < 2) return null;
+  const shift = semitones(median(tail), median(body));
+  if (shift >= ENDING_SEMITONES) return "rising";
+  if (shift <= -ENDING_SEMITONES) return "falling";
+  return "level";
+}
+function pitchOf(track2, start, end) {
+  const hz = within2(track2, start, end);
+  return hz.length >= MIN_PITCH_FRAMES ? Math.round(median(hz)) : null;
+}
+function summary(sentences, pauses, track2) {
+  const timed = sentences.filter((s3) => s3.rate !== null);
+  const seconds = timed.reduce((n, s3) => n + (s3.end - s3.start), 0);
+  const meanRate = seconds ? round6(timed.reduce((n, s3) => n + s3.rate * (s3.end - s3.start), 0) / seconds, 1) : null;
+  return {
+    sentences,
+    pauses,
+    meanRate,
+    medianPitchHz: track2.length ? Math.round(median(track2.map((p) => p.hz))) : null
+  };
+}
+function voiceFromWords(words, track2) {
+  const ordered = words.filter((w) => w.end > w.start).sort((a, b) => a.start - b.start);
+  const unit = rateUnit(ordered);
+  const sentences = sentenceGroups(ordered).map((group) => {
+    const start = group[0].start;
+    const end = group[group.length - 1].end;
+    const count = spoken(group, unit);
+    return {
+      start: round6(start),
+      end: round6(end),
+      text: joined2(group, unit),
+      rate: count && end > start ? round6(count / (end - start), 1) : null,
+      pitchHz: pitchOf(track2, start, end),
+      ending: ending(track2, start, end)
+    };
+  });
+  const pauses = [];
+  for (let i = 1; i < ordered.length; i++) {
+    const gap = ordered[i].start - ordered[i - 1].end;
+    if (gap >= PAUSE_SECONDS)
+      pauses.push({ start: round6(ordered[i - 1].end), end: round6(ordered[i].start) });
+  }
+  return { source: "transcript", unit, ...summary(sentences, pauses, track2) };
+}
+var ACTIVITY_HOP = 0.05;
+var SHORTEST_SPEECH = 0.3;
+function voiceFromActivity(vocals, sampleRate, track2) {
+  const db = levels(vocals, sampleRate, ACTIVITY_HOP);
+  const threshold = Math.max(-45, quantile(db, 0.9) - 30);
+  const spans = [];
+  let start = null;
+  let quietSince = null;
+  db.forEach((level, f) => {
+    const t = f * ACTIVITY_HOP;
+    if (level >= threshold) {
+      if (start === null) start = t;
+      quietSince = null;
+    } else if (start !== null) {
+      quietSince ??= t;
+      if (t - quietSince >= PAUSE_SECONDS) {
+        if (quietSince - start >= SHORTEST_SPEECH) spans.push({ start, end: quietSince });
+        start = null;
+        quietSince = null;
+      }
+    }
+  });
+  const end = db.length * ACTIVITY_HOP;
+  if (start !== null && (quietSince ?? end) - start >= SHORTEST_SPEECH)
+    spans.push({ start, end: quietSince ?? end });
+  const sentences = spans.map(
+    (s3) => ({
+      start: round6(s3.start),
+      end: round6(s3.end),
+      text: null,
+      rate: null,
+      pitchHz: pitchOf(track2, s3.start, s3.end),
+      ending: ending(track2, s3.start, s3.end)
+    })
+  );
+  const pauses = spans.slice(1).map((s3, i) => ({ start: round6(spans[i].end), end: round6(s3.start) }));
+  return { source: "activity", unit: "chars", ...summary(sentences, pauses, track2) };
+}
+
+// src/audio/read/read.ts
+async function sha256(path) {
+  const hash = createHash2("sha256");
+  for await (const chunk of createReadStream(path)) hash.update(chunk);
+  return hash.digest("hex");
+}
+function transcriptFor(path, given) {
+  if (given) return given;
+  const sidecar = `${path}.transcript.json`;
+  return existsSync5(sidecar) ? sidecar : null;
+}
+function wordsOf(transcript) {
+  return loadTranscript(transcript).words.map(({ text, start, end }) => ({ text, start, end }));
+}
+var fingerprint = (path) => path ? createHash2("sha256").update(readFileSync2(path)).digest("hex").slice(0, 16) : "none";
+function writeAtomic(path, content) {
+  const temporary = `${path}.${process.pid}.tmp`;
+  writeFileSync2(temporary, content);
+  renameSync(temporary, path);
+}
+async function stemsFor(path, dir, quality, warnings) {
+  const cached = cachedStems(dir);
+  if (cached) return cached;
+  if (quality !== "best") {
+    warnings.push(
+      `not separated into stems: quality ${quality} keeps audio on this machine; --quality best separates it through HeyGen`
+    );
+    return null;
+  }
+  const access2 = await stemsAccess();
+  if (typeof access2 === "string") {
+    warnings.push(`not separated into stems: ${access2}`);
+    return null;
+  }
+  try {
+    return await fetchStems(path, dir, access2);
+  } catch (error) {
+    warnings.push(`not separated into stems: ${error instanceof Error ? error.message : error}`);
+    return null;
+  }
+}
+async function fromStems(path, stemPaths) {
+  const pitched = {};
+  for (const [name, stemPath] of Object.entries(stemPaths))
+    if (name !== VOICE_STEM && name !== DRUM_STEM) pitched[name] = await decodeMono(stemPath);
+  const drums = stemPaths[DRUM_STEM] ? await decodeMono(stemPaths[DRUM_STEM]) : null;
+  const bed = Object.keys(pitched).length ? mixed(Object.values(pitched)) : null;
+  const { music, beats } = bed ? readMusic({ stems: pitched, drums, sampleRate: READ_RATE }) : { music: null, beats: [] };
+  const effects = findEffects({
+    source: drums ?? bed ?? new Float32Array(0),
+    sampleRate: READ_RATE,
+    music: bed,
+    heard: await decodeMono(path),
+    beats,
+    speech: []
+  });
+  return { effects, music };
+}
+var transcribeHint = (file) => `run hyperframes transcribe ${file} and pass --transcript`;
+async function analyze(path, file, sha, transcript, stemDir, quality) {
+  const warnings = [];
+  const stemPaths = await stemsFor(path, stemDir, quality, warnings);
+  const words = transcript ? wordsOf(transcript) : [];
+  const voicePath = stemPaths?.[VOICE_STEM] ?? path;
+  const voiceSamples = await decodeMono(voicePath);
+  const about = base(file, sha, round6(voiceSamples.length / READ_RATE, 3), stemPaths, transcript);
+  if (!stemPaths && !words.length) {
+    warnings.push(
+      `no transcript and no stems: voice and effects are not read, because the mix alone does not tell speech from music; ${transcribeHint(file)}`
+    );
+    return { ...about, voice: null, effects: null, music: null, warnings };
+  }
+  if (!words.length)
+    warnings.push(`no transcript: voice lines carry no words; ${transcribeHint(file)}`);
+  const pitch = pitchTrack(await decodeMono(voicePath, PITCH_RATE));
+  const voice = words.length ? voiceFromWords(words, pitch) : voiceFromActivity(voiceSamples, READ_RATE, pitch);
+  if (stemPaths) return { ...about, voice, ...await fromStems(path, stemPaths), warnings };
+  warnings.push("without stems, effects under speech are not found and music is not read");
+  const effects = findEffects({
+    source: voiceSamples,
+    sampleRate: READ_RATE,
+    music: null,
+    heard: null,
+    beats: [],
+    speech: voice.sentences
+  });
+  return { ...about, voice, effects, music: null, warnings };
+}
+function base(file, sha, duration, stemPaths, transcript) {
+  return {
+    version: READ_VERSION,
+    file,
+    sha256: sha,
+    duration,
+    separation: stemPaths ? "stems" : "mix",
+    stems: stemPaths ? Object.keys(stemPaths).sort() : [],
+    transcript: transcript ? basename(transcript) : null
+  };
+}
+async function readAudio(path, file, options) {
+  const quality = options.quality ?? "local";
+  const sha = await sha256(path);
+  const transcript = transcriptFor(path, options.transcript);
+  const transcriptKey = fingerprint(transcript);
+  const stem = `${basename(file, extname(file)).replace(/[^\w.-]/g, "_")}-${sha.slice(0, 12)}`;
+  mkdirSync2(options.cacheDir, { recursive: true });
+  const jsonPath = join6(options.cacheDir, `${stem}.json`);
+  const textPath = join6(options.cacheDir, `${stem}.txt`);
+  const stemDir = join6(options.cacheDir, "stems", sha.slice(0, 12));
+  if (existsSync5(jsonPath) && existsSync5(textPath)) {
+    const entry = JSON.parse(readFileSync2(jsonPath, "utf8"));
+    const stemsNowPossible = entry.analysis.separation === "mix" && quality === "best" && (cachedStems(stemDir) !== null || typeof await stemsAccess() !== "string");
+    if ((entry.analysis.separation !== "stems" || cachedStems(stemDir) !== null) && entry.analysis.version === READ_VERSION && entry.transcriptKey === transcriptKey && !stemsNowPossible)
+      return { analysis: entry.analysis, textPath, jsonPath, cached: true };
+  }
+  const analysis = await analyze(path, file, sha, transcript, stemDir, quality);
+  writeAtomic(jsonPath, JSON.stringify({ analysis, transcriptKey }));
+  writeAtomic(textPath, formatRead(analysis));
+  return { analysis, textPath, jsonPath, cached: false };
+}
+
+// src/commands/audio.ts
+var examples = [
+  ["Where a sound effect lands, its hits and loudness", "hyperframes audio sfx/whoosh.mp3"],
+  [
+    "Where a file not in the film yet would land if it started at 4.2 s",
+    "hyperframes audio sfx/hit.wav --place-at 4.2"
+  ],
+  ["Every sound playing at 12 s in the film", "hyperframes audio --at 12"],
+  ["One clip of the film, as JSON", "hyperframes audio --element '#riser' --json"],
+  [
+    "The beat grid, tempo and sections of a music bed",
+    "hyperframes audio music.mp3 --only beats,downbeats,bpm,sections"
+  ],
+  [
+    "A whole recording as voice, effect and music lines, 60\u201370 s shown",
+    "hyperframes audio refs/episode.mp4 --read --range 60,70"
+  ],
+  [
+    "Only onsets, from 60\u2013200 Hz, finer",
+    "hyperframes audio drums.wav --only onsets --band 60,200 --hop-ms 2"
+  ]
+];
+var CAPABILITIES = /* @__PURE__ */ new Set([
+  ...DEFAULT_CAPABILITIES,
+  "beats",
+  "downbeats",
+  "bpm",
+  "sections",
+  "describe"
+]);
+var QUALITIES = /* @__PURE__ */ new Set(["best", "local", "fast"]);
+function number(name, raw) {
+  if (raw === void 0) return void 0;
+  const value = Number(raw);
+  if (!Number.isFinite(value)) throw new CliUsageError(`--${name} must be a number, got ${raw}`);
+  return value;
+}
+function pair(name, raw) {
+  if (raw === void 0) return void 0;
+  const parts = raw.split(",").map(Number);
+  if (parts.length !== 2 || parts.some((n) => !Number.isFinite(n)) || parts[0] >= parts[1])
+    throw new CliUsageError(`--${name} takes two increasing numbers, like 2.5,4`);
+  return parts;
+}
+function capabilities(raw) {
+  if (!raw) return [...DEFAULT_CAPABILITIES];
+  const asked = raw.split(",").map((c) => c.trim()).filter(Boolean);
+  if (asked.includes("words"))
+    throw new CliUsageError("words come from hyperframes transcribe, not hyperframes audio");
+  const unknown = asked.filter((c) => !CAPABILITIES.has(c));
+  if (unknown.length)
+    throw new CliUsageError(
+      `--only does not know ${unknown.join(", ")}; use ${[...CAPABILITIES].join(", ")}`
+    );
+  return asked;
+}
+function pins(raw) {
+  if (!raw) return void 0;
+  return Object.fromEntries(
+    raw.split(",").map((entry) => {
+      const [capability, id] = entry.split("=").map((s3) => s3.trim());
+      if (!capability || !id || !CAPABILITIES.has(capability))
+        throw new CliUsageError(`--provider takes capability=provider pairs, like onsets=signal`);
+      return [capability, id];
+    })
+  );
+}
+function filmQuery(args) {
+  const given = ["element", "at", "range"].filter((k) => args[k] !== void 0);
+  if (given.length > 1) throw new CliUsageError(`use one of --element, --at, --range`);
+  if (args.element) return { by: "element", ref: args.element };
+  if (args.at !== void 0) return { by: "at", t: number("at", args.at) };
+  const range = pair("range", args.range);
+  return range ? { by: "range", start: range[0], end: range[1] } : null;
+}
+function parseQuality(flags) {
+  const quality = flags.quality ?? "local";
+  if (!QUALITIES.has(quality)) throw new CliUsageError("--quality is local, best or fast");
+  return quality;
+}
+function analyzeRequest(flags) {
+  const quality = parseQuality(flags);
+  const method = flags["onset-method"];
+  if (method && method !== "spectral-flux" && method !== "energy")
+    throw new CliUsageError("--onset-method is spectral-flux or energy");
+  const band = pair("band", flags.band);
+  return {
+    capabilities: capabilities(flags.only),
+    quality,
+    provider: pins(flags.provider),
+    options: {
+      onsets: { method, band, threshold: number("threshold", flags.threshold) },
+      envelope: { band, hopMs: number("hop-ms", flags["hop-ms"]) },
+      moments: {
+        onsetRatio: number("onset-ratio", flags["onset-ratio"]),
+        tailDb: number("tail-db", flags["tail-db"])
+      },
+      silence: { thresholdDb: number("silence-db", flags["silence-db"]) }
+    }
+  };
+}
+async function fileTargets(files, flags) {
+  const start = number("place-at", flags["place-at"]);
+  if (start !== void 0 && files.length !== 1)
+    throw new CliUsageError("--place-at places exactly one file");
+  const skip = number("skip-file-seconds", flags["skip-file-seconds"]);
+  if (skip !== void 0 && start === void 0)
+    throw new CliUsageError("--skip-file-seconds only works with --place-at");
+  const mediaStart = skip ?? 0;
+  const cwd = process.cwd();
+  return Promise.all(
+    files.map((file) => previewTarget(resolve2(cwd, file), file, start ?? null, mediaStart))
+  );
+}
+async function clipTargets(flags, query) {
+  const project = resolveProject(flags.dir);
+  ensureDOMParser();
+  const timeline = await describeProject(project.indexPath);
+  return filmTargets(project.dir, timeline, query ?? { by: "all" });
+}
+function readQuality(files, flags) {
+  if (files.length !== 1) throw new CliUsageError("--read reads exactly one file");
+  if (flags.element || flags.at || flags["place-at"])
+    throw new CliUsageError("--read takes a file and --range, not a film query");
+  return parseQuality(flags);
+}
+async function read(files, flags) {
+  const quality = readQuality(files, flags);
+  const range = pair("range", flags.range);
+  const result = await readAudio(resolve2(process.cwd(), files[0]), files[0], {
+    cacheDir: join7(resolve2(flags.dir ?? process.cwd()), ".hyperframes", "read-audio"),
+    transcript: flags.transcript ? resolve2(process.cwd(), flags.transcript) : void 0,
+    quality
+  });
+  if (flags.json) {
+    console.log(JSON.stringify(withMeta(result)));
+    return;
+  }
+  console.log(`${formatRead(result.analysis, range)}
+
+whole recording: ${result.textPath}`);
+}
+var audio_default = defineCommand({
+  meta: {
+    name: "audio",
+    description: "Measure how sound moves in time: where it lands, its hits, loudness and silence"
+  },
+  args: {
+    files: { type: "positional", description: "Audio or video files to analyze", required: false },
+    dir: { type: "string", description: "Project directory, for film queries (default: current)" },
+    element: {
+      type: "string",
+      description: "One audio or video clip of the film: #id, hf:id or audio/N"
+    },
+    at: { type: "string", description: "Every sound playing at this film second" },
+    range: { type: "string", description: "Every sound playing in start,end film seconds" },
+    "place-at": {
+      type: "string",
+      description: "For one file not in the film yet: the film second it would start at"
+    },
+    "skip-file-seconds": {
+      type: "string",
+      description: "With --place-at: seconds cut from the start of the file"
+    },
+    only: {
+      type: "string",
+      description: `Capabilities to measure (default ${DEFAULT_CAPABILITIES.join(",")}; also beats,downbeats,bpm,sections,describe)`
+    },
+    quality: {
+      type: "string",
+      description: "local (this machine, the default), best (also uploads to HeyGen's audio services, which may bill your account), fast (signal only)"
+    },
+    provider: { type: "string", description: "Pin capabilities to providers: onsets=signal,..." },
+    "onset-method": { type: "string", description: "spectral-flux (default) or energy" },
+    threshold: { type: "string", description: "Onset strength floor, 0\u20131 (default 0.1)" },
+    band: { type: "string", description: "Measure onsets and envelope in lo,hi Hz only" },
+    "hop-ms": {
+      type: "string",
+      description: "Envelope hop in ms (default: about 2,000 values per item)"
+    },
+    "onset-ratio": {
+      type: "string",
+      description: "Moments: onset is where RMS first reaches this share of the peak (0.2)"
+    },
+    "tail-db": {
+      type: "string",
+      description: "Moments: the tail ends this many dB under the peak (-40)"
+    },
+    "silence-db": { type: "string", description: "Silence below this level in dBFS (-50)" },
+    full: {
+      type: "boolean",
+      description: "Include each capability's provider ladder",
+      default: false
+    },
+    read: {
+      type: "boolean",
+      description: "Read one whole recording as voice, effect and music lines (--range picks what is shown)",
+      default: false
+    },
+    transcript: {
+      type: "string",
+      description: "With --read: the recording's transcript (default <file>.transcript.json)"
+    },
+    json: { type: "boolean", description: "Output as JSON", default: false }
+  },
+  setup({ rawArgs, cmd }) {
+    assertKnownFlags({ args: cmd.args }, rawArgs);
+  },
+  async run({ args }) {
+    const flags = args;
+    const files = args._.map(String);
+    if (flags.read) return read(files, flags);
+    if (flags.transcript) throw new CliUsageError("--transcript only works with --read");
+    const query = filmQuery(flags);
+    if (files.length && query) throw new CliUsageError("give files or a film query, not both");
+    const targets = files.length ? await fileTargets(files, flags) : await clipTargets(flags, query);
+    const report = await analyzeTargets(targets, analyzeRequest(flags), Boolean(args.full));
+    console.log(args.json ? JSON.stringify(withMeta(report)) : formatReport(report));
+  }
+});
+export {
+  audio_default as default,
+  examples
+};