hyperframes 0.8.160 → 0.8.162

package/dist/audio-GK4OVVTH.js

@@ -1,2086 +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 {
-  describeProject
-} from "./chunk-GJQHHAAX.js";
-import "./chunk-WPNE5NEP.js";
-import {
-  resolveProject
-} from "./chunk-37LNY2EC.js";
-import "./chunk-K2FLNJVB.js";
-import {
-  ensureDOMParser
-} from "./chunk-442JNXRM.js";
-import "./chunk-6JR2XUEE.js";
-import "./chunk-KRE55WLI.js";
-import "./chunk-ICZVCVD3.js";
-import "./chunk-VWG7OQKU.js";
-import "./chunk-QWQ6GQTI.js";
-import {
-  assertKnownFlags
-} from "./chunk-UPFUC4DB.js";
-import {
-  defineCommand
-} from "./chunk-S3S4TGEH.js";
-import "./chunk-54HJ63Q2.js";
-import {
-  CliUsageError
-} from "./chunk-PBN6GBJE.js";
-import "./chunk-ZTZA4UWZ.js";
-import {
-  withMeta
-} from "./chunk-FRGYHRP6.js";
-import "./chunk-K4WIOZFP.js";
-import "./chunk-XUXGIA7H.js";
-import "./chunk-WERLJGIC.js";
-import "./chunk-ISN5GRYI.js";
-import "./chunk-TU2CQJO3.js";
-import "./chunk-XT6MXC7A.js";
-import "./chunk-PLEMSN3E.js";
-import "./chunk-LYIG2GZ5.js";
-import "./chunk-KCF6GHJP.js";
-import "./chunk-JYVGYKXG.js";
-import "./chunk-7KDQAD2W.js";
-import "./chunk-Q3TFX4OZ.js";
-import "./chunk-P47XYVEQ.js";
-import "./chunk-VC76R6W2.js";
-import "./chunk-UJKQWGFF.js";
-import "./chunk-ALLKNYC3.js";
-import "./chunk-OFQWTKPW.js";
-import "./chunk-DPVXBVLL.js";
-import "./chunk-T76PLPD6.js";
-import "./chunk-FXMKHHPO.js";
-import "./chunk-RQVDTPGD.js";
-import "./chunk-TWWSYAKJ.js";
-import "./chunk-2742O5DO.js";
-import "./chunk-IWFLMU2N.js";
-import "./chunk-3VGU2SH7.js";
-import {
-  findFfBinary
-} from "./chunk-VAS6HQX3.js";
-import "./chunk-3RM2ETQT.js";
-import "./chunk-BSQ7XANM.js";
-import "./chunk-SDYDNHEE.js";
-import "./chunk-TYXH3EKP.js";
-import "./chunk-IXLUTE6N.js";
-import "./chunk-KNU5COPB.js";
-import "./chunk-3GXQPCJC.js";
-import "./chunk-M2WBOQ2Q.js";
-
-// src/commands/audio.ts
-import { resolve as resolve2 } from "path";
-
-// ../core/dist/fft.js
-function fft(re, im) {
-  const n = re.length;
-  for (let i = 1, j = 0; i < n; i++) {
-    let bit = n >> 1;
-    for (; j & bit; bit >>= 1)
-      j ^= bit;
-    j ^= bit;
-    if (i < j) {
-      [re[i], re[j]] = [re[j], re[i]];
-      [im[i], im[j]] = [im[j], im[i]];
-    }
-  }
-  for (let len = 2; len <= n; len <<= 1) {
-    const ang = -2 * Math.PI / len;
-    const wr = Math.cos(ang);
-    const wi = Math.sin(ang);
-    for (let i = 0; i < n; i += len) {
-      let cr = 1;
-      let ci = 0;
-      for (let k = 0; k < len / 2; k++) {
-        const ur = re[i + k];
-        const ui = im[i + k];
-        const vr = re[i + k + len / 2] * cr - im[i + k + len / 2] * ci;
-        const vi = re[i + k + len / 2] * ci + im[i + k + len / 2] * cr;
-        re[i + k] = ur + vr;
-        im[i + k] = ui + vi;
-        re[i + k + len / 2] = ur - vr;
-        im[i + k + len / 2] = ui - vi;
-        const ncr = cr * wr - ci * wi;
-        ci = cr * wi + ci * wr;
-        cr = ncr;
-      }
-    }
-  }
-}
-
-// ../core/dist/audioRhythm.js
-var FRAMES_PER_SECOND = 100;
-var LOW_BAND_HZ = 150;
-var SLOWEST_BPM = 40;
-var FASTEST_BPM = 240;
-var TIGHTNESS = 100;
-var round = (t) => Math.round(t * 1e3) / 1e3;
-function bandEdges(sampleRate, size) {
-  const binHz = sampleRate / size;
-  const edges = [];
-  for (let hz = 30; hz < Math.min(9e3, sampleRate / 2); hz *= 2 ** (1 / 5))
-    edges.push(Math.max(1, Math.round(hz / binHz)));
-  return edges;
-}
-function addFramePower(samples, center, window, edges, into) {
-  const size = window.length;
-  const re = new Float64Array(size);
-  const im = new Float64Array(size);
-  const first = center - size / 2;
-  for (let i = 0; i < size; i++) {
-    const at = first + i;
-    re[i] = at >= 0 && at < samples.length ? samples[at] * window[i] : 0;
-  }
-  fft(re, im);
-  for (let b = 0; b + 1 < edges.length; b++) {
-    const end = Math.max(edges[b] + 1, edges[b + 1]);
-    let power = 0;
-    for (let k = edges[b]; k < end; k++)
-      power += re[k] * re[k] + im[k] * im[k];
-    into[b] += power / (size * size * (end - edges[b]));
-  }
-}
-function bandFrames(signal) {
-  const { sampleRate, channels } = signal;
-  const hop = Math.max(1, Math.round(sampleRate / FRAMES_PER_SECOND));
-  const size = 2 ** Math.round(Math.log2(sampleRate * 0.046));
-  const window = Float64Array.from({ length: size }, (_, i) => 0.5 - 0.5 * Math.cos(2 * Math.PI * i / size));
-  const edges = bandEdges(sampleRate, size);
-  const length = channels[0]?.length ?? 0;
-  const bands = [];
-  for (let center = 0; center < length; center += hop) {
-    const power = new Float64Array(Math.max(0, edges.length - 1));
-    for (const channel of channels)
-      addFramePower(channel, center, window, edges, power);
-    bands.push(power.map((p) => Math.log1p(1e9 * p)));
-  }
-  return { fps: sampleRate / hop, bands };
-}
-function aboveLocalMean(curve, radius) {
-  const sums = new Float64Array(curve.length + 1);
-  for (let i = 0; i < curve.length; i++)
-    sums[i + 1] = sums[i] + curve[i];
-  return curve.map((value, i) => {
-    const from = Math.max(0, i - radius);
-    const to = Math.min(curve.length, i + radius + 1);
-    return Math.max(0, value - (sums[to] - sums[from]) / (to - from));
-  });
-}
-function standardized(curve) {
-  const mean = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
-  const spread = Math.sqrt(curve.reduce((a, v) => a + (v - mean) ** 2, 0) / (curve.length || 1));
-  return spread > 0 ? curve.map((v) => v / spread) : curve.map(() => 0);
-}
-function onsetCurves({ fps, bands }, sampleRate) {
-  const size = 2 ** Math.round(Math.log2(sampleRate * 0.046));
-  const lowBands = bandEdges(sampleRate, size).filter((bin) => bin * sampleRate / size < LOW_BAND_HZ).length;
-  const broad = new Float64Array(bands.length);
-  const low = new Float64Array(bands.length);
-  for (let f = 1; f < bands.length; f++) {
-    const frame2 = bands[f];
-    const previous = bands[f - 1];
-    for (let b = 0; b < frame2.length; b++) {
-      const rise = Math.max(0, frame2[b] - previous[b]);
-      broad[f] += rise;
-      if (b < lowBands)
-        low[f] += rise;
-    }
-  }
-  const radius = Math.round(0.4 * fps);
-  return {
-    fps,
-    broad: standardized(aboveLocalMean(broad, radius)),
-    low: standardized(aboveLocalMean(low, radius))
-  };
-}
-function autocorrelation(curve, maxLag) {
-  const mean = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
-  const centred = curve.map((v) => v - mean);
-  const ac = new Float64Array(maxLag + 1);
-  for (let lag = 0; lag <= maxLag && lag < centred.length; lag++) {
-    let sum = 0;
-    for (let i = lag; i < centred.length; i++)
-      sum += centred[i] * centred[i - lag];
-    ac[lag] = sum;
-  }
-  const zero = ac[0] || 1;
-  return ac.map((v) => v / zero);
-}
-var tempoPrior = (lag, fps) => Math.exp(-0.5 * Math.log2(60 / (lag / fps) / 120) ** 2);
-var fullRange = (fps) => ({
-  shortest: Math.max(1, Math.floor(60 / FASTEST_BPM * fps)),
-  longest: Math.ceil(60 / SLOWEST_BPM * fps)
-});
-function beatPeriod(curve, fps, { shortest, longest } = fullRange(fps)) {
-  const ac = autocorrelation(curve, 2 * longest + 1);
-  const at = (lag) => ac[Math.min(ac.length - 1, Math.max(0, lag))];
-  const score = (lag) => tempoPrior(lag, fps) * (at(lag) + 0.5 * at(2 * lag) + 0.25 * (at(2 * lag - 1) + at(2 * lag + 1)));
-  let best = shortest;
-  for (let lag = shortest; lag <= longest; lag++)
-    if (score(lag) > score(best))
-      best = lag;
-  const [a, b, c] = [score(best - 1), score(best), score(best + 1)];
-  const curvature = a - 2 * b + c;
-  const shift = curvature ? Math.max(-0.5, Math.min(0.5, 0.5 * (a - c) / curvature)) : 0;
-  return { period: best + shift, clarity: Math.max(0, Math.min(1, at(best))) };
-}
-function smoothed(curve, period) {
-  const half = Math.max(1, Math.round(period / 8));
-  const kernel = Array.from({ length: 2 * half + 1 }, (_, i) => Math.exp(-0.5 * ((i - half) * 32 / period) ** 2));
-  return curve.map((_, i) => {
-    let sum = 0;
-    for (let j = 0; j < kernel.length; j++)
-      sum += kernel[j] * (curve[i + j - half] ?? 0);
-    return sum;
-  });
-}
-function cumulativeScore(local, periodAt) {
-  const score = new Float64Array(local.length);
-  const back = new Int32Array(local.length).fill(-1);
-  for (let i = 0; i < local.length; i++) {
-    const period = periodAt(i);
-    let best = -Infinity;
-    let from = -1;
-    for (let j = Math.max(0, Math.round(i - 2 * period)); j <= i - Math.round(period / 2); j++) {
-      const candidate = score[j] - TIGHTNESS * Math.log((i - j) / period) ** 2;
-      if (candidate > best)
-        [best, from] = [candidate, j];
-    }
-    score[i] = local[i] + Math.max(0, best);
-    back[i] = best > 0 ? from : -1;
-  }
-  return { score, back };
-}
-function lastBeat(score) {
-  const maxima = [];
-  for (let i = 1; i + 1 < score.length; i++)
-    if (score[i] > score[i - 1] && score[i] >= score[i + 1])
-      maxima.push(i);
-  if (!maxima.length)
-    return score.length - 1;
-  const median = maxima.map((i) => score[i]).sort((a, b) => a - b)[maxima.length >> 1];
-  for (let k = maxima.length - 1; k >= 0; k--)
-    if (score[maxima[k]] >= 0.5 * median)
-      return maxima[k];
-  return maxima[maxima.length - 1];
-}
-function trimmed(beats, local) {
-  const rms = Math.sqrt(beats.reduce((a, b) => a + local[b] ** 2, 0) / (beats.length || 1));
-  let first = 0;
-  let end = beats.length;
-  while (first < end && local[beats[first]] < 0.5 * rms)
-    first++;
-  while (end > first && local[beats[end - 1]] < 0.5 * rms)
-    end--;
-  return beats.slice(first, end);
-}
-var LOCAL_WINDOW_SECONDS = 8;
-function localPeriods(curve, fps, period) {
-  const window = Math.round(LOCAL_WINDOW_SECONDS * fps);
-  const hop = Math.round(fps);
-  const range = {
-    shortest: Math.max(fullRange(fps).shortest, Math.floor(period * 0.7)),
-    longest: Math.min(fullRange(fps).longest, Math.ceil(period * 1.4))
-  };
-  const centres = [];
-  const periods = [];
-  for (let start = 0; start === 0 || start + window <= curve.length; start += hop) {
-    const end = Math.min(curve.length, start + window);
-    periods.push(beatPeriod(curve.subarray(start, end), fps, range).period);
-    centres.push((start + end) / 2);
-  }
-  const median = periods.map((_, i) => {
-    const near = periods.slice(Math.max(0, i - 2), i + 3).sort((a, b) => a - b);
-    return near[near.length >> 1];
-  });
-  return (frame2) => interpolate(centres, median, frame2);
-}
-function interpolate(xs, ys, x) {
-  if (x <= xs[0])
-    return ys[0];
-  for (let i = 1; i < xs.length; i++)
-    if (x <= xs[i]) {
-      const t = (x - xs[i - 1]) / (xs[i] - xs[i - 1]);
-      return ys[i - 1] * (1 - t) + ys[i] * t;
-    }
-  return ys[ys.length - 1];
-}
-function beatFrames(curve, fps, period) {
-  const local = smoothed(curve, period);
-  const { score, back } = cumulativeScore(local, localPeriods(curve, fps, period));
-  const beats = [];
-  for (let i = lastBeat(score); i >= 0; i = back[i])
-    beats.push(i);
-  return { frames: trimmed(beats.reverse(), local), local };
-}
-function onsetLift(frames, local) {
-  const overall = local.reduce((a, b) => a + b, 0) / (local.length || 1);
-  const onBeats = frames.reduce((a, f) => a + local[f], 0) / (frames.length || 1);
-  return overall > 0 ? onBeats / overall - 1 : 0;
-}
-function barPhase(beats, curves) {
-  const strength = (f) => Math.max(...[-1, 0, 1, 2].map((d) => (curves.low[f + d] ?? 0) + 0.3 * (curves.broad[f + d] ?? 0)));
-  const levels = beats.map(strength);
-  let best = { meter: 4, phase: 0, contrast: -Infinity };
-  for (const meter of [4, 3])
-    for (let phase = 0; phase < meter; phase++) {
-      const on = levels.filter((_, k) => (k - phase) % meter === 0);
-      const off = levels.filter((_, k) => (k - phase) % meter !== 0);
-      const mean = (v) => v.reduce((a, b) => a + b, 0) / (v.length || 1);
-      const contrast = (mean(on) - mean(off)) * (meter === 3 ? 0.85 : 1);
-      if (contrast > best.contrast)
-        best = { meter, phase, contrast };
-    }
-  return best;
-}
-function medianInterval(times) {
-  const gaps = times.slice(1).map((t, i) => t - times[i]).sort((a, b) => a - b);
-  return gaps.length ? gaps[gaps.length >> 1] : null;
-}
-var noRhythm = (confidence, reason = "no steady beat") => ({
-  beats: { times: [], confidence, reason },
-  downbeats: { times: [], meter: null, confidence: "low" }
-});
-var SHORTEST_SECONDS = 6;
-var STEADY_BEAT_CONFIDENCE = 0.05;
-var beatConfidence = (clarity, lift) => round(Math.max(0, Math.min(1, clarity)) * Math.max(0, Math.min(1, lift / 3)));
-function rhythmOf(frames, sampleRate) {
-  const curves = onsetCurves(frames, sampleRate);
-  const { period, clarity } = beatPeriod(curves.broad, curves.fps);
-  if (curves.broad.length < SHORTEST_SECONDS * curves.fps)
-    return noRhythm(0, "too short for a steady beat");
-  if (!curves.broad.some((v) => v > 0) || curves.broad.length < 2 * period)
-    return noRhythm(0);
-  const { frames: beatList, local } = beatFrames(curves.broad, curves.fps, period);
-  const confidence = beatConfidence(clarity, onsetLift(beatList, local));
-  if (beatList.length < 4 || confidence < STEADY_BEAT_CONFIDENCE)
-    return noRhythm(confidence);
-  const times = beatList.map((f) => round(f / curves.fps));
-  const bar = beatList.length >= 6 ? barPhase(beatList, curves) : null;
-  return {
-    beats: { times, confidence },
-    downbeats: {
-      times: bar ? times.filter((_, k) => (k - bar.phase) % bar.meter === 0) : [],
-      meter: bar?.meter ?? null,
-      confidence: "low"
-    }
-  };
-}
-var TEMPO_STEP_SECONDS = 4;
-function tempoOf(times) {
-  const interval = medianInterval(times);
-  if (!interval)
-    return { value: null, curve: [] };
-  const bpm = (gap) => Math.round(600 / gap) / 10;
-  const curve = [];
-  const last = times[times.length - 1];
-  for (let t = times[0]; t <= last; t += TEMPO_STEP_SECONDS) {
-    const gap = medianInterval(times.filter((b) => Math.abs(b - t) <= TEMPO_STEP_SECONDS));
-    if (gap)
-      curve.push({ t: round(t), bpm: bpm(gap) });
-  }
-  return { value: bpm(interval), curve };
-}
-var measured = /* @__PURE__ */ new WeakMap();
-function bandFramesOf(signal) {
-  let entry = measured.get(signal);
-  if (!entry)
-    measured.set(signal, entry = { frames: bandFrames(signal) });
-  return entry.frames;
-}
-function rhythm(signal) {
-  const frames = bandFramesOf(signal);
-  const entry = measured.get(signal);
-  return entry.rhythm ??= rhythmOf(frames, signal.sampleRate);
-}
-
-// ../core/dist/audioSnap.js
-function nearestIndex(sorted, t) {
-  let low = 0;
-  let high = sorted.length - 1;
-  while (low < high) {
-    const mid = low + high >> 1;
-    if (sorted[mid] < t)
-      low = mid + 1;
-    else
-      high = mid;
-  }
-  return low > 0 && t - sorted[low - 1] <= sorted[low] - t ? low - 1 : low;
-}
-function snapper(measured3, toleranceSeconds, reference) {
-  const shifts = [];
-  const unsnapped = [];
-  return {
-    snap(t) {
-      const nearest = measured3.length ? measured3[nearestIndex(measured3, t)] : null;
-      if (nearest === null || Math.abs(nearest - t) > toleranceSeconds) {
-        unsnapped.push(t);
-        return t;
-      }
-      shifts.push(Math.abs(nearest - t));
-      return nearest;
-    },
-    report() {
-      const sorted = [...shifts].sort((a, b) => a - b);
-      const median = sorted.length ? sorted[sorted.length >> 1] : null;
-      return {
-        reference,
-        toleranceMs: Math.round(toleranceSeconds * 1e3),
-        snapped: shifts.length,
-        unsnapped: [...unsnapped],
-        medianShiftMs: median === null ? null : Math.round(median * 1e3)
-      };
-    }
-  };
-}
-
-// ../core/dist/audioSections.js
-var BLOCK_SECONDS = 0.5;
-var KERNEL_BLOCKS = 16;
-var SAME_SECTION = 0.9;
-var round2 = (t) => Math.round(t * 1e3) / 1e3;
-function meanOf(frames) {
-  const sum = new Array(frames[0]?.length ?? 0).fill(0);
-  for (const frame2 of frames)
-    for (let b = 0; b < sum.length; b++)
-      sum[b] += frame2[b];
-  return sum.map((v) => v / (frames.length || 1));
-}
-function standardizeBands(blocks) {
-  for (let b = 0; b < (blocks[0]?.length ?? 0); b++) {
-    const column = blocks.map((block) => block[b]);
-    const mean = column.reduce((a, v) => a + v, 0) / column.length;
-    const spread = Math.sqrt(column.reduce((a, v) => a + (v - mean) ** 2, 0) / column.length);
-    for (const block of blocks)
-      block[b] = (block[b] - mean) / (spread || 1);
-  }
-}
-function blockFeatures({ fps, bands }) {
-  const per = Math.max(1, Math.round(BLOCK_SECONDS * fps));
-  const blocks = [];
-  for (let start = 0; start + per <= bands.length; start += per)
-    blocks.push(meanOf(bands.slice(start, start + per)));
-  standardizeBands(blocks);
-  return blocks.map(unit);
-}
-function unit(vector) {
-  const length = Math.hypot(...vector) || 1;
-  return vector.map((v) => v / length);
-}
-var dot = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
-var CHECKERBOARD = (() => {
-  const offsets = Array.from({ length: 2 * KERNEL_BLOCKS }, (_, k) => k - KERNEL_BLOCKS);
-  const taper = (k) => Math.exp(-0.5 * (((k < 0 ? -k - 1 : k) + 0.5) / (KERNEL_BLOCKS / 2)) ** 2);
-  return offsets.map((a) => offsets.map((b) => (a < 0 === b < 0 ? 1 : -1) * taper(a) * taper(b)));
-})();
-function noveltyAt(blocks, i) {
-  let sum = 0;
-  CHECKERBOARD.forEach((row, a) => {
-    const x = blocks[i + a - KERNEL_BLOCKS];
-    if (!x)
-      return;
-    row.forEach((weight, b) => {
-      const y = blocks[i + b - KERNEL_BLOCKS];
-      if (y)
-        sum += weight * dot(x, y);
-    });
-  });
-  return sum;
-}
-var novelty = (blocks) => blocks.map((_, i) => noveltyAt(blocks, i));
-function boundaryBlocks(curve, minBlocks) {
-  const mean = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
-  const spread = Math.sqrt(curve.reduce((a, v) => a + (v - mean) ** 2, 0) / (curve.length || 1));
-  const peaks = [];
-  for (let i = minBlocks; i <= curve.length - minBlocks; i++) {
-    const neighbourhood = curve.slice(Math.max(0, i - minBlocks), i + minBlocks + 1);
-    if (curve[i] < Math.max(...neighbourhood) || curve[i] <= mean + spread)
-      continue;
-    if (!peaks.length || i - peaks[peaks.length - 1] >= minBlocks)
-      peaks.push(i);
-  }
-  return peaks;
-}
-function labels(blocks, edges) {
-  const means = [];
-  const letters = [];
-  for (let s2 = 0; s2 + 1 < edges.length; s2++) {
-    const part = blocks.slice(edges[s2], edges[s2 + 1]);
-    const mean = unit(part[0].map((_, b) => part.reduce((a, block) => a + block[b], 0)));
-    const match = means.findIndex((other) => dot(other, mean) >= SAME_SECTION);
-    letters.push(match >= 0 ? letters[match] : String.fromCharCode(65 + new Set(letters).size % 26));
-    means.push(mean);
-  }
-  return letters;
-}
-var beatTolerance = (beats) => (medianInterval(beats) ?? 0) / 2;
-function sections(signal, options = {}) {
-  const duration = round2((signal.channels[0]?.length ?? 0) / signal.sampleRate);
-  const blocks = blockFeatures(bandFramesOf(signal));
-  const minBlocks = Math.max(1, Math.round((options.minSeconds ?? 4) / BLOCK_SECONDS));
-  if (blocks.length < 2 * minBlocks)
-    return { spans: [{ start: 0, end: duration, label: "A" }] };
-  const edges = [0, ...boundaryBlocks(novelty(blocks), minBlocks), blocks.length];
-  const letters = labels(blocks, edges);
-  const beats = rhythm(signal).beats.times;
-  const onBeat = snapper(beats, beatTolerance(beats), "signal beats");
-  const times = edges.map((e, i) => i === 0 ? 0 : i === edges.length - 1 ? duration : round2(onBeat.snap(e * BLOCK_SECONDS)));
-  return {
-    spans: letters.map((label, s2) => ({ start: times[s2], end: times[s2 + 1], label })),
-    snap: onBeat.report()
-  };
-}
-
-// ../core/dist/audioAnalysisLadder.js
-function defaultLadder(capability, providers) {
-  return providers.filter((p) => p.capabilities.includes(capability)).map((p) => p.id);
-}
-function exclusion(provider, quality) {
-  if (quality === "fast" && !provider.signal)
-    return "quality fast allows signal processing only";
-  if (quality === "local" && !provider.local)
-    return "quality local keeps audio on this machine";
-  return null;
-}
-var message = (error) => error instanceof Error ? error.message : String(error);
-async function availabilityOf(provider) {
-  try {
-    return provider.available ? await provider.available() : { ok: true };
-  } catch (error) {
-    return { ok: false, reason: message(error) };
-  }
-}
-async function blocked(id, candidate, capability, quality) {
-  if (!candidate?.capabilities.includes(capability))
-    return { provider: id, outcome: "unavailable", reason: `no provider ${id} for ${capability}` };
-  const excluded = exclusion(candidate, quality);
-  if (excluded)
-    return { provider: id, outcome: "excluded", reason: excluded };
-  const availability = await availabilityOf(candidate);
-  if (!availability.ok)
-    return { provider: id, outcome: "unavailable", reason: availability.reason };
-  return null;
-}
-function passedOver(capability, steps, answered) {
-  const skipped = steps.filter((s2) => s2.outcome === "unavailable" || s2.outcome === "failed");
-  if (!skipped.length)
-    return null;
-  const why = skipped.map((s2) => `${s2.provider} ${s2.outcome}${s2.reason ? ` (${s2.reason})` : ""}`).join("; ");
-  return answered ? `${capability}: used ${answered}; ${why}` : `${capability}: ${why}`;
-}
-async function runLadder(capability, input, providers, { quality = "best", ladder, provider, options = {} } = {}) {
-  const byId = new Map(providers.map((p) => [p.id, p]));
-  const order = provider ? [provider] : ladder ?? defaultLadder(capability, providers);
-  const steps = [];
-  for (const id of order) {
-    const candidate = byId.get(id);
-    const skip = await blocked(id, candidate, capability, quality);
-    if (skip) {
-      steps.push(skip);
-      continue;
-    }
-    try {
-      const value = await candidate.analyze(capability, input, options);
-      const warning = passedOver(capability, steps, id);
-      steps.push({ provider: id, outcome: "answered" });
-      return { value, provenance: id, steps, warnings: warning ? [warning] : [] };
-    } catch (error) {
-      steps.push({ provider: id, outcome: "failed", reason: message(error) });
-    }
-  }
-  const none = order.length ? "" : " (none offers it)";
-  const why = passedOver(capability, steps, null)?.slice(capability.length + 2);
-  return {
-    value: null,
-    provenance: null,
-    steps,
-    warnings: [`${capability}: no provider answered${none}${why ? `; ${why}` : ""}`]
-  };
-}
-
-// ../core/dist/audioAnalysis.js
-var DB_FLOOR = -120;
-var signalDuration = (signal) => (signal.channels[0]?.length ?? 0) / signal.sampleRate;
-function energyMix(signal) {
-  const [first, ...rest] = signal.channels;
-  if (!first)
-    return new Float32Array(0);
-  if (!rest.length)
-    return first;
-  const mixed = new Float32Array(first.length);
-  for (const channel of signal.channels)
-    for (let i = 0; i < mixed.length; i++)
-      mixed[i] += channel[i] * channel[i];
-  const scale = 1 / signal.channels.length;
-  for (let i = 0; i < mixed.length; i++)
-    mixed[i] = Math.sqrt(mixed[i] * scale);
-  return mixed;
-}
-var toDb = (amplitude) => amplitude > 0 ? Math.max(DB_FLOOR, 20 * Math.log10(amplitude)) : DB_FLOOR;
-var hopSamples = (sampleRate, hopMs) => Math.max(1, Math.round(sampleRate * hopMs / 1e3));
-var round3 = (t) => Math.round(t * 1e4) / 1e4;
-function rmsFrames(samples, sampleRate, hopMs, windowMs) {
-  const hop = hopSamples(sampleRate, hopMs);
-  const half = Math.max(1, Math.round(sampleRate * windowMs / 2e3));
-  const frames = [];
-  for (let center = 0; center < samples.length; center += hop) {
-    const from = Math.max(0, center - half);
-    const to = Math.min(samples.length, center + half);
-    let sum = 0;
-    for (let i = from; i < to; i++)
-      sum += samples[i] * samples[i];
-    frames.push(to > from ? Math.sqrt(sum / (to - from)) : 0);
-  }
-  return frames;
-}
-var fftSizeFor = (sampleRate) => 2 ** Math.round(Math.log2(sampleRate * 0.023));
-function bandBins(sampleRate, size, band) {
-  const binHz = sampleRate / size;
-  const low = Math.max(1, Math.floor((band?.[0] ?? 0) / binHz));
-  return [low, Math.max(low, Math.min(size / 2, Math.ceil((band?.[1] ?? sampleRate / 2) / binHz)))];
-}
-function loadFrame(samples, center, window, re, im) {
-  const first = center - window.length / 2;
-  for (let i = 0; i < window.length; i++) {
-    const at = first + i;
-    re[i] = at >= 0 && at < samples.length ? samples[at] * window[i] : 0;
-    im[i] = 0;
-  }
-}
-function spectra(samples, sampleRate, hopMs, band) {
-  const size = fftSizeFor(sampleRate);
-  const hop = hopSamples(sampleRate, hopMs);
-  const window = Float64Array.from({ length: size }, (_, i) => 0.5 - 0.5 * Math.cos(2 * Math.PI * i / size));
-  const [low, high] = bandBins(sampleRate, size, band);
-  const frames = [];
-  const re = new Float64Array(size);
-  const im = new Float64Array(size);
-  for (let center = 0; center < samples.length; center += hop) {
-    loadFrame(samples, center, window, re, im);
-    fft(re, im);
-    const magnitudes = new Float64Array(high - low);
-    for (let k = low; k < high; k++)
-      magnitudes[k - low] = Math.hypot(re[k], im[k]);
-    frames.push(magnitudes);
-  }
-  return frames;
-}
-function averageMagnitudes(frames) {
-  const mixed = new Float64Array(frames[0]?.length ?? 0);
-  for (const frame2 of frames)
-    for (let bin = 0; bin < mixed.length; bin++)
-      mixed[bin] += frame2[bin];
-  const scale = frames.length || 1;
-  for (let bin = 0; bin < mixed.length; bin++)
-    mixed[bin] /= scale;
-  return mixed;
-}
-function meanSpectra(signal, hopMs, band) {
-  const stacked = signal.channels.map((channel) => spectra(channel, signal.sampleRate, hopMs, band));
-  const count = stacked[0]?.length ?? 0;
-  const mixed = [];
-  for (let frame2 = 0; frame2 < count; frame2++)
-    mixed.push(averageMagnitudes(stacked.map((channel) => channel[frame2])));
-  return mixed;
-}
-function envelope(signal, options = {}) {
-  const { hopMs = 5, scale = "db", band } = options;
-  const windowMs = options.windowMs ?? hopMs * 2;
-  const size = fftSizeFor(signal.sampleRate);
-  const amplitudes = band ? meanSpectra(signal, hopMs, band).map((frame2) => {
-    let sum = 0;
-    for (const magnitude of frame2)
-      sum += magnitude * magnitude;
-    return Math.sqrt(2 * sum / (size * size * 0.375));
-  }) : rmsFrames(energyMix(signal), signal.sampleRate, hopMs, windowMs);
-  return { hopMs, scale, values: amplitudes.map((a) => scale === "db" ? toDb(a) : a) };
-}
-function noveltyCurve(signal, method, hopMs, band) {
-  const samples = energyMix(signal);
-  if (method === "energy") {
-    const rms = rmsFrames(samples, signal.sampleRate, hopMs, hopMs * 2);
-    return rms.map((value, i) => Math.max(0, value - (rms[i - 1] ?? 0)));
-  }
-  const frames = meanSpectra(signal, hopMs, band).map((frame2) => frame2.map((m) => Math.log1p(100 * m)));
-  const lastWhole = Math.floor((samples.length - fftSizeFor(signal.sampleRate) / 2) / hopSamples(signal.sampleRate, hopMs));
-  return frames.map((frame2, i) => {
-    const previous = frames[i - 1];
-    if (!previous || i > lastWhole)
-      return 0;
-    let flux = 0;
-    for (let k = 0; k < frame2.length; k++)
-      flux += Math.max(0, frame2[k] - previous[k]);
-    return flux;
-  });
-}
-function isOnsetPeak(curve, i, gap, context, top) {
-  const value = curve[i];
-  let sum = 0;
-  let count = 0;
-  for (let j = Math.max(0, i - context); j <= Math.min(curve.length - 1, i + context); j++) {
-    if (Math.abs(j - i) <= gap && curve[j] > value)
-      return false;
-    sum += curve[j];
-    count++;
-  }
-  return value >= sum / count + 0.05 * top;
-}
-function onsets(signal, options = {}) {
-  const { method = "spectral-flux", band, threshold = 0.1, minGapMs = 30, hopMs = 5 } = options;
-  const curve = noveltyCurve(signal, method, hopMs, band);
-  const top = Math.max(0, ...curve);
-  if (top <= 0)
-    return { method, events: [] };
-  const gap = Math.max(1, Math.round(minGapMs / hopMs));
-  const context = Math.max(gap, Math.round(100 / hopMs));
-  const hopSeconds = hopSamples(signal.sampleRate, hopMs) / signal.sampleRate;
-  const events = [];
-  for (let i = 0; i < curve.length; i++) {
-    const strength = curve[i] / top;
-    if (strength < threshold || !isOnsetPeak(curve, i, gap, context, top))
-      continue;
-    const onset = { t: round3(i * hopSeconds), strength: round3(strength) };
-    const last = events[events.length - 1];
-    if (!last || onset.t - last.t >= minGapMs / 1e3)
-      events.push(onset);
-    else if (onset.strength > last.strength)
-      events[events.length - 1] = onset;
-  }
-  return { method, events };
-}
-function moments(signal, options = {}) {
-  const { onsetRatio = 0.2, tailDb = -40, hopMs = 1 } = options;
-  const rms = rmsFrames(energyMix(signal), signal.sampleRate, hopMs, Math.max(4, hopMs * 4));
-  const hopSeconds = hopSamples(signal.sampleRate, hopMs) / signal.sampleRate;
-  let peakIndex = 0;
-  for (let i = 1; i < rms.length; i++)
-    if (rms[i] > rms[peakIndex])
-      peakIndex = i;
-  const peak = rms[peakIndex] ?? 0;
-  if (peak <= 0)
-    return null;
-  let onsetIndex = rms.findIndex((value) => value >= peak * onsetRatio);
-  if (onsetIndex < 0)
-    onsetIndex = peakIndex;
-  let steepestIndex = onsetIndex;
-  let steepestRise = -Infinity;
-  for (let i = 1; i <= peakIndex; i++) {
-    const rise = rms[i] - rms[i - 1];
-    if (rise > steepestRise)
-      [steepestRise, steepestIndex] = [rise, i];
-  }
-  const floor = peak * 10 ** (tailDb / 20);
-  let tailIndex = peakIndex;
-  for (let i = rms.length - 1; i > peakIndex; i--)
-    if (rms[i] >= floor) {
-      tailIndex = i;
-      break;
-    }
-  return {
-    onset: round3(onsetIndex * hopSeconds),
-    steepest: round3(steepestIndex * hopSeconds),
-    peak: round3(peakIndex * hopSeconds),
-    tailEnd: round3(tailIndex * hopSeconds)
-  };
-}
-function kWeighting(sampleRate) {
-  let k = Math.tan(Math.PI * 1681.974450955533 / sampleRate);
-  const q = 0.7071752369554196;
-  const vh = 10 ** (3.999843853973347 / 20);
-  const vb = vh ** 0.4996667741545416;
-  let a0 = 1 + k / q + k * k;
-  const shelf = [
-    (vh + vb * k / q + k * k) / a0,
-    2 * (k * k - vh) / a0,
-    (vh - vb * k / q + k * k) / a0,
-    2 * (k * k - 1) / a0,
-    (1 - k / q + k * k) / a0
-  ];
-  k = Math.tan(Math.PI * 38.13547087602444 / sampleRate);
-  const q2 = 0.5003270373238773;
-  a0 = 1 + k / q2 + k * k;
-  const highPass = [1, -2, 1, 2 * (k * k - 1) / a0, (1 - k / q2 + k * k) / a0];
-  return [shelf, highPass];
-}
-function filtered(samples, [b0, b1, b2, a1, a2]) {
-  const out = new Float64Array(samples.length);
-  let x1 = 0, x2 = 0, y1 = 0, y2 = 0;
-  for (let i = 0; i < samples.length; i++) {
-    const x = samples[i];
-    const y = b0 * x + b1 * x1 + b2 * x2 - a1 * y1 - a2 * y2;
-    x2 = x1;
-    x1 = x;
-    y2 = y1;
-    y1 = y;
-    out[i] = y;
-  }
-  return out;
-}
-var blockLoudness = (meanSquare) => meanSquare > 0 ? -0.691 + 10 * Math.log10(meanSquare) : -Infinity;
-function squareSums(channel) {
-  const sums = new Float64Array(channel.length + 1);
-  for (let i = 0; i < channel.length; i++)
-    sums[i + 1] = sums[i] + channel[i] * channel[i];
-  return sums;
-}
-function blockPowers(sums, sampleRate, blockSeconds, stepSeconds) {
-  const length = (sums[0]?.length ?? 1) - 1;
-  if (!length)
-    return [];
-  const block = Math.min(length, Math.round(blockSeconds * sampleRate));
-  const step = Math.round(stepSeconds * sampleRate);
-  const powers = [];
-  for (let start = 0; start + block <= length; start += step)
-    powers.push(sums.reduce((power, sum) => power + (sum[start + block] - sum[start]) / block, 0));
-  return powers;
-}
-var TRUE_PEAK_OVERSAMPLE = 4;
-var TRUE_PEAK_TAPS = 12;
-var TRUE_PEAK_KERNELS = Array.from({ length: TRUE_PEAK_OVERSAMPLE - 1 }, (_, phase) => {
-  const offset = (phase + 1) / TRUE_PEAK_OVERSAMPLE;
-  return Float64Array.from({ length: 2 * TRUE_PEAK_TAPS }, (_2, tap) => {
-    const x = tap - TRUE_PEAK_TAPS + 1 - offset;
-    const sinc = x === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
-    return sinc * (0.5 + 0.5 * Math.cos(Math.PI * x / TRUE_PEAK_TAPS));
-  });
-});
-function truePeak(channel) {
-  let samplePeak = 0;
-  for (let i = 0; i < channel.length; i++)
-    samplePeak = Math.max(samplePeak, Math.abs(channel[i]));
-  const floor = samplePeak / 2;
-  const taps = 2 * TRUE_PEAK_TAPS;
-  let peak = samplePeak;
-  for (let n = 0; n + taps <= channel.length; n++) {
-    if (Math.abs(channel[n + TRUE_PEAK_TAPS - 1]) < floor && Math.abs(channel[n + TRUE_PEAK_TAPS]) < floor)
-      continue;
-    for (const kernel of TRUE_PEAK_KERNELS) {
-      let y = 0;
-      for (let tap = 0; tap < taps; tap++)
-        y += channel[n + tap] * kernel[tap];
-      if (y > peak)
-        peak = y;
-      else if (-y > peak)
-        peak = -y;
-    }
-  }
-  return peak;
-}
-function loudness(signal) {
-  const [shelf, highPass] = kWeighting(signal.sampleRate);
-  const sums = signal.channels.map((channel) => squareSums(filtered(filtered(channel, shelf), highPass)));
-  const momentary = blockPowers(sums, signal.sampleRate, 0.4, 0.1);
-  const audible = momentary.filter((power) => blockLoudness(power) > -70);
-  let lufsIntegrated = null;
-  if (audible.length) {
-    const relative = blockLoudness(audible.reduce((a, b) => a + b, 0) / audible.length) - 10;
-    const gated = audible.filter((power) => blockLoudness(power) > relative);
-    if (gated.length)
-      lufsIntegrated = Math.round(blockLoudness(gated.reduce((a, b) => a + b, 0) / gated.length) * 10) / 10;
-  }
-  const shortTerm = blockPowers(sums, signal.sampleRate, 3, 0.1).map(blockLoudness).filter(Number.isFinite);
-  let samplePeak = 0;
-  let count = 0;
-  let firstAt = null;
-  for (const channel of signal.channels)
-    for (let i = 0; i < channel.length; i++) {
-      const magnitude = Math.abs(channel[i]);
-      samplePeak = Math.max(samplePeak, magnitude);
-      if (magnitude >= 0.999) {
-        count++;
-        const t = i / signal.sampleRate;
-        if (firstAt === null || t < firstAt)
-          firstAt = round3(t);
-      }
-    }
-  return {
-    lufsIntegrated,
-    lufsShortTermMax: shortTerm.length ? Math.round(Math.max(...shortTerm) * 10) / 10 : null,
-    samplePeakDb: Math.round(toDb(samplePeak) * 10) / 10,
-    truePeakDb: Math.round(toDb(Math.max(0, ...signal.channels.map(truePeak))) * 10) / 10,
-    clipping: { count, firstAt }
-  };
-}
-function silence(signal, options = {}) {
-  const { thresholdDb = -50, minMs = 200, hopMs = 5 } = options;
-  const db = rmsFrames(energyMix(signal), signal.sampleRate, hopMs, hopMs * 2).map(toDb);
-  const hopSeconds = hopSamples(signal.sampleRate, hopMs) / signal.sampleRate;
-  const spans = [];
-  let from = null;
-  for (let i = 0; i <= db.length; i++) {
-    const quiet = i < db.length && db[i] < thresholdDb;
-    if (quiet && from === null)
-      from = i;
-    if (!quiet && from !== null) {
-      if ((i - from) * hopSeconds * 1e3 >= minMs)
-        spans.push({
-          start: round3(from * hopSeconds),
-          end: round3(Math.min(i * hopSeconds, signalDuration(signal)))
-        });
-      from = null;
-    }
-  }
-  return spans;
-}
-function periodicity(curve, hopMs) {
-  const mean = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
-  const centred = curve.map((v) => v - mean);
-  const energy = centred.reduce((a, v) => a + v * v, 0);
-  if (!energy)
-    return 0;
-  let best = 0;
-  for (let lag = Math.round(300 / hopMs); lag <= Math.round(1500 / hopMs) && lag < centred.length; lag++) {
-    let sum = 0;
-    for (let i = lag; i < centred.length; i++)
-      sum += centred[i] * centred[i - lag];
-    best = Math.max(best, sum / energy);
-  }
-  return best;
-}
-function syllableModulation(signal) {
-  const hopMs = 10;
-  const rms = rmsFrames(energyMix(signal), signal.sampleRate, hopMs, 25);
-  const size = 2 ** Math.floor(Math.log2(Math.min(rms.length, 1024)));
-  if (size < 64)
-    return 0;
-  const re = Float64Array.from(rms.slice(0, size));
-  const mean = re.reduce((a, b) => a + b, 0) / size;
-  for (let i = 0; i < size; i++)
-    re[i] = re[i] - mean;
-  const im = new Float64Array(size);
-  fft(re, im);
-  const rate = 1e3 / hopMs;
-  let inBand = 0;
-  let total = 0;
-  for (let k = 1; k < size / 2; k++) {
-    const power = re[k] * re[k] + im[k] * im[k];
-    const hz = k * rate / size;
-    total += power;
-    if (hz >= 3 && hz <= 8)
-      inBand += power;
-  }
-  return total ? inBand / total : 0;
-}
-function sustainShare(signal) {
-  const levels = rmsFrames(energyMix(signal), signal.sampleRate, 50, 100).map(toDb);
-  if (!levels.length)
-    return 0;
-  const loud = [...levels].sort((a, b) => a - b)[Math.floor((levels.length - 1) * 0.95)];
-  return levels.filter((level) => level > loud - 20).length / levels.length;
-}
-function kindFeatures(signal) {
-  return {
-    duration: round3(signalDuration(signal)),
-    regularity: round3(periodicity(noveltyCurve(signal, "spectral-flux", 10), 10)),
-    syllables: round3(syllableModulation(signal)),
-    sustain: round3(sustainShare(signal))
-  };
-}
-function classify(signal) {
-  const features = kindFeatures(signal);
-  const { duration, regularity, syllables, sustain } = features;
-  const speechLike = syllables >= 0.35 && regularity < 0.35;
-  if (duration >= 8) {
-    if (sustain < 0.4)
-      return { value: "sfx", confidence: 0.6, features };
-    if (speechLike)
-      return { value: "voice", confidence: round3(Math.min(0.9, 0.4 + syllables)), features };
-    return { value: "music", confidence: round3(Math.min(0.9, 0.5 + regularity)), features };
-  }
-  if (duration >= 1.5 && syllables >= 0.17 && regularity < 0.3 && sustain >= 0.7)
-    return { value: "voice", confidence: speechLike ? 0.8 : 0.6, features };
-  return { value: "sfx", confidence: duration <= 2 ? 0.85 : 0.65, features };
-}
-var SIGNAL_MEASURES = {
-  beats: (input) => rhythm(input).beats,
-  downbeats: (input) => rhythm(input).downbeats,
-  sections: (input, options) => sections(input, options),
-  envelope: (input, options) => envelope(input, options),
-  onsets: (input, options) => onsets(input, options),
-  moments: (input, options) => moments(input, options),
-  loudness: (input) => loudness(input),
-  silence: (input, options) => silence(input, options),
-  kind: (input) => classify(input)
-};
-var signalProvider = {
-  id: "signal",
-  local: true,
-  signal: true,
-  capabilities: [
-    "envelope",
-    "onsets",
-    "moments",
-    "loudness",
-    "silence",
-    "kind",
-    "beats",
-    "downbeats",
-    "sections"
-  ],
-  async analyze(capability, input, options) {
-    const measure = SIGNAL_MEASURES[capability];
-    if (!measure)
-      throw new Error(`signal processing does not measure ${capability}`);
-    return measure(input, options);
-  }
-};
-
-// 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 round4 = (t) => Math.round(t * 1e3) / 1e3;
-var rounded = (times) => times.map(round4);
-
-// 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 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}` : ""}`);
-}
-async function ask(signal, 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: {
-      sampleRate: signal.sampleRate,
-      channels: signal.channels.length,
-      duration: (signal.channels[0]?.length ?? 0) / signal.sampleRate
-    }
-  };
-  const form = new FormData();
-  form.append("request", new Blob([JSON.stringify(request)], { type: "application/json" }));
-  form.append(
-    "audio",
-    new Blob([new Uint8Array(encodeWav(signal))], { type: "audio/wav" }),
-    "audio.wav"
-  );
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { authorization: `Bearer ${key}` },
-    body: form,
-    signal: AbortSignal.timeout(timeoutMs)
-  });
-  if (!response.ok) throw await failure(response);
-  return await response.json();
-}
-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 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 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 measured2(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 measured2(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 round5 = (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: round5(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) => round5(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 round6 = (t) => Math.round(t * 1e3) / 1e3;
-function within(value, from, to) {
-  if (!value || typeof value !== "object" || !("events" in value)) return value;
-  const onsets2 = value;
-  return { ...onsets2, events: onsets2.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: round6(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 round7 = (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 round7(placement.start + (fileTime2 - placement.mediaStart) / placement.playbackRate);
-}
-function fileTime(placement, filmTime2) {
-  return round7(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;
-  const declaredIn = dirname(join4(projectDir, row.file));
-  return {
-    path: resolve(declaredIn, row.src),
-    file: row.src,
-    ref: row.ref || null,
-    kind: row.kind,
-    placement,
-    window: {
-      from: fileTime(placement, from),
-      seconds: round7((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(moments2, at) {
-  return `  onset ${at(moments2.onset)}  steepest ${at(moments2.steepest)}  peak ${at(moments2.peak)}  tail end ${at(moments2.tailEnd)}`;
-}
-function hitsLine(onsets2, at) {
-  if (!onsets2.events.length) return null;
-  const shown = onsets2.events.slice(0, ONSETS_SHOWN).map((e) => `${at(e.t)}(${e.strength.toFixed(2)})`);
-  const more = onsets2.events.length - shown.length;
-  return `  hits ${shown.join(" ")}${more > 0 ? ` +${more}` : ""}`;
-}
-function loudnessLine(loudness2, at) {
-  const lufs = loudness2.lufsIntegrated === null ? "below gate" : `${loudness2.lufsIntegrated} LUFS`;
-  const { count, firstAt } = loudness2.clipping;
-  const clip = count && firstAt !== null ? `, clips ${count}\xD7 from ${at(firstAt)}` : "";
-  return `  loudness ${lufs}, true peak ${loudness2.truePeakDb} dBTP${clip}`;
-}
-function silenceLine(silence2, at) {
-  return silence2.length ? `  silent ${silence2.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(sections2, at) {
-  const spans = sections2.spans.map((s2) => `${s2.label} ${at(s2.start)}\u2013${at(s2.end)}`).join("  ");
-  return `  sections ${spans}${snapNote(sections2.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";
-
-// src/audio/analysis/decode.ts
-import { execFile as execFile2 } from "child_process";
-import { promisify as promisify2 } from "util";
-var run = promisify2(execFile2);
-function requiredBinary(name) {
-  const path = findFfBinary(name, { configuredMustExist: true });
-  if (!path) throw new Error(`${name} is required to analyze audio; run: npx hyperframes doctor`);
-  return path;
-}
-async function probeAudio(file) {
-  const { stdout } = await run(
-    requiredBinary("ffprobe"),
-    [
-      "-v",
-      "error",
-      "-select_streams",
-      "a:0",
-      "-show_streams",
-      "-show_format",
-      "-of",
-      "json",
-      "--",
-      file
-    ],
-    { maxBuffer: 8 * 1024 * 1024, windowsHide: true }
-  );
-  const parsed = JSON.parse(stdout);
-  const stream = parsed.streams?.[0];
-  if (!stream) return null;
-  return {
-    sampleRate: Number(stream.sample_rate),
-    channels: stream.channels ?? 1,
-    duration: Number(stream.duration ?? parsed.format?.duration ?? 0)
-  };
-}
-async function decodeAudio(file, window = {}, probed) {
-  const info = probed ?? await probeAudio(file);
-  if (!info) return null;
-  const seek = window.from ? ["-ss", String(window.from)] : [];
-  const length = window.seconds === void 0 ? [] : ["-t", String(window.seconds)];
-  const { stdout } = await run(
-    requiredBinary("ffmpeg"),
-    [
-      "-v",
-      "error",
-      ...seek,
-      "-i",
-      file,
-      ...length,
-      "-map",
-      "0:a:0",
-      "-f",
-      "f32le",
-      "-acodec",
-      "pcm_f32le",
-      "-"
-    ],
-    { encoding: "buffer", maxBuffer: 2 * 1024 * 1024 * 1024, windowsHide: true }
-  );
-  const bytes = stdout.byteLength - stdout.byteLength % 4;
-  const interleaved = new Float32Array(
-    stdout.buffer.slice(stdout.byteOffset, stdout.byteOffset + bytes)
-  );
-  const frames = Math.floor(interleaved.length / info.channels);
-  const channels = Array.from({ length: info.channels }, (_, c) => {
-    const samples = new Float32Array(frames);
-    for (let i = 0; i < frames; i++) samples[i] = interleaved[i * info.channels + c];
-    return samples;
-  });
-  return { signal: { sampleRate: info.sampleRate, channels }, stream: info };
-}
-
-// src/audio/analysis/run.ts
-var round8 = (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 ${round8(stream.duration)} s long`
-    );
-  const length = stream ? stream.duration - mediaStart : 0;
-  return {
-    path,
-    file,
-    ref: null,
-    kind: "file",
-    placement: {
-      start: at,
-      end: round8(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 ${round8(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: round8(from), to: round8(from + analysis.analyzed) },
-    duration: round8(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
-};