hyperframes 0.8.185 → 0.8.188

package/dist/audio-65R4T74I.js

@@ -1,1154 +0,0 @@
-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-5UDRPPN2.js";
-import {
-  HyperframesCloudClient
-} from "./chunk-5UBZPG74.js";
-import {
-  describeProject
-} from "./chunk-BH7TTIPN.js";
-import "./chunk-LLMSX6V6.js";
-import {
-  decodeAudio,
-  envelope,
-  medianInterval,
-  probeAudio,
-  rhythm,
-  runLadder,
-  signalDuration,
-  signalProvider,
-  snapper,
-  tempoOf
-} from "./chunk-FFJ5TDRD.js";
-import {
-  resolveProject
-} from "./chunk-5GUKZRQN.js";
-import "./chunk-6JR2XUEE.js";
-import "./chunk-G2UANIDX.js";
-import "./chunk-K2FLNJVB.js";
-import {
-  ensureDOMParser
-} from "./chunk-442JNXRM.js";
-import "./chunk-WQLKDL35.js";
-import "./chunk-H5SM5PJI.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-I3IH5MV5.js";
-import "./chunk-IZCW2NKT.js";
-import "./chunk-KROXPHXX.js";
-import "./chunk-RQVDTPGD.js";
-import "./chunk-Q47FAYYK.js";
-import "./chunk-3NPOFC43.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 "./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-ISTRDGIX.js";
-import "./chunk-K4WIOZFP.js";
-import "./chunk-XUXGIA7H.js";
-import "./chunk-WERLJGIC.js";
-import "./chunk-ISN5GRYI.js";
-import "./chunk-I7QMXZSB.js";
-import "./chunk-KNU5COPB.js";
-import "./chunk-M2WBOQ2Q.js";
-
-// src/commands/audio.ts
-import { 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);
-
-// 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];
-function config() {
-  const url = process.env[URL_ENV]?.trim();
-  const key = process.env[KEY_ENV]?.trim();
-  const timeout = Number(process.env[TIMEOUT_ENV]);
-  return { url, key, timeoutMs: timeout > 0 ? timeout : DEFAULT_TIMEOUT_MS };
-}
-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((s2) => isNumberList([s2.start, s2.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`);
-}
-async function failure(response) {
-  const text = await response.text().catch(() => "");
-  let detail = text.slice(0, 200);
-  try {
-    detail = JSON.parse(text).error?.message ?? detail;
-  } catch {
-  }
-  return new Error(`the service answered ${response.status}${detail ? `: ${detail}` : ""}`);
-}
-var uploadedAsset = perSignal(async (analyzed) => {
-  const { url, key, timeoutMs } = config();
-  if (!url || !key) throw new Error(`${URL_ENV} and ${KEY_ENV} must both be set`);
-  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: () => ({ "x-api-key": key }),
-    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, key, timeoutMs } = config();
-  if (!url || !key) throw new Error(`${URL_ENV} and ${KEY_ENV} must both be set`);
-  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: {
-      "x-api-key": key,
-      "idempotency-key": randomUUID(),
-      "content-type": "application/json"
-    },
-    body: JSON.stringify(request),
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!response.ok) throw await failure(response);
-  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((s2) => ask(s2, together)));
-  return request(signal);
-}
-function beatSnapper(signal, beatSeconds) {
-  const measured2 = rhythm(signal).beats.times;
-  const period = beatSeconds ?? medianInterval(measured2) ?? 0;
-  return snapper(measured2, period / 4, "signal beats");
-}
-function snappedBeats(signal, body) {
-  const times = body.beats.times;
-  const onBeat = beatSnapper(signal, medianInterval(times));
-  return { times: rounded(times.map(onBeat.snap)), snap: onBeat.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 onBeat = beatSnapper(signal, beat ?? (bar && meter ? bar / meter : null));
-  return { times: rounded(times.map(onBeat.snap)), meter, snap: onBeat.report() };
-}
-function snappedSections(signal, body) {
-  const onBeat = beatSnapper(signal, null);
-  const end = (signal.channels[0]?.length ?? 0) / signal.sampleRate;
-  const move = (t) => t <= 0 || t >= end ? t : onBeat.snap(t);
-  const spans = body.sections.spans.map((s2) => ({
-    ...s2,
-    start: rounded([move(s2.start)])[0],
-    end: rounded([move(s2.end)])[0]
-  }));
-  return { spans, snap: onBeat.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,
-  available() {
-    const { url, key } = config();
-    if (!url) return unavailable(`${URL_ENV} is not set`);
-    if (!key) return unavailable(`${KEY_ENV} is not set`);
-    return 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((s2) => ({ start: at(s2.start), end: at(s2.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: (s2, at) => withSnap(
-    {
-      ...s2,
-      spans: s2.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 { 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: request.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)));
-  }
-  return analysis;
-}
-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 median = snap.medianShiftMs === null ? "" : `, median ${snap.medianShiftMs} ms`;
-  return `; ${snap.snapped}/${total} snapped to ${snap.reference}${median}`;
-}
-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((s2) => `${s2.label} ${at(s2.start)}\u2013${at(s2.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, context } = decodeSpan(target, stream);
-  const decoded = await decodeAudio(target.path, read, 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/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"
-  ],
-  [
-    "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((s2) => s2.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 analyzeRequest(flags) {
-  const quality = flags.quality ?? "best";
-  if (!QUALITIES.has(quality)) throw new CliUsageError("--quality is best, local or fast");
-  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" });
-}
-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: "best (any provider), local (this machine), 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
-    },
-    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);
-    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
-};