hyperframes 0.8.160 → 0.8.161

package/dist/chunk-FFJ5TDRD.js

@@ -0,0 +1,1181 @@
+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 {
+  findFfBinary
+} from "./chunk-VAS6HQX3.js";
+
+// src/audio/analysis/decode.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var run = promisify(execFile);
+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 };
+}
+
+// ../core/dist/audioResample.js
+var ZERO_CROSSINGS = 8;
+var STEPS_PER_CROSSING = 256;
+var CUTOFF = 0.95;
+var KERNEL = Float64Array.from({ length: ZERO_CROSSINGS * STEPS_PER_CROSSING + 2 }, (_, i) => {
+  const x = i / STEPS_PER_CROSSING;
+  if (x >= ZERO_CROSSINGS)
+    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 / ZERO_CROSSINGS));
+});
+function kernelAt(x) {
+  const at = Math.abs(x) * STEPS_PER_CROSSING;
+  const i = Math.floor(at);
+  if (i + 1 >= KERNEL.length)
+    return 0;
+  const frac = at - i;
+  return KERNEL[i] * (1 - frac) + KERNEL[i + 1] * frac;
+}
+function resample(samples, from, to) {
+  if (from === to)
+    return samples;
+  const ratio = to / from;
+  const scale = Math.min(1, ratio) * CUTOFF;
+  const reach = ZERO_CROSSINGS / scale;
+  const out = new Float32Array(Math.floor(samples.length * ratio));
+  for (let n = 0; n < out.length; n++) {
+    const t = n / ratio;
+    const last = Math.min(samples.length - 1, Math.floor(t + reach));
+    let sum = 0;
+    for (let k = Math.max(0, Math.ceil(t - reach)); k <= last; k++)
+      sum += samples[k] * kernelAt((t - k) * scale);
+    out[n] = sum * scale;
+  }
+  return out;
+}
+
+// ../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 ANALYSIS_RATE = 22050;
+var FRAME_SIZE = 1024;
+var CHROMA_SIZE = 4096;
+var CHROMA_FPS = 10;
+var FRAMES_PER_SECOND = 100;
+var LOW_BAND_HZ = 150;
+var SLOWEST_BPM = 40;
+var FASTEST_BPM = 240;
+var TIGHTNESS = 100;
+var ONSET_LAG_SECONDS = 0.015;
+var round = (t) => Math.round(t * 1e3) / 1e3;
+function bandEdges() {
+  const binHz = ANALYSIS_RATE / FRAME_SIZE;
+  const edges = [];
+  for (let hz = 30; hz < 9e3; hz *= 2 ** (1 / 5))
+    edges.push(Math.max(1, Math.round(hz / binHz)));
+  return edges;
+}
+var hann = (size) => Float64Array.from({ length: size }, (_, i) => 0.5 - 0.5 * Math.cos(2 * Math.PI * i / size));
+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 bandPower(channels) {
+  const window = hann(FRAME_SIZE);
+  const edges = bandEdges();
+  const hop = ANALYSIS_RATE / FRAMES_PER_SECOND;
+  const bands = [];
+  for (let f = 0; Math.round(f * hop) < (channels[0]?.length ?? 0); f++) {
+    const power = new Float64Array(edges.length - 1);
+    for (const channel of channels)
+      addFramePower(channel, Math.round(f * hop), window, edges, power);
+    bands.push(power.map((p) => Math.log1p(1e9 * p / channels.length)));
+  }
+  return bands;
+}
+var PITCH_CLASS = Array.from({ length: CHROMA_SIZE / 2 }, (_, bin) => {
+  const hz = bin * ANALYSIS_RATE / CHROMA_SIZE;
+  if (hz < 55 || hz > 2e3)
+    return -1;
+  return ((Math.round(12 * Math.log2(hz / 440)) + 9) % 12 + 12) % 12;
+});
+function chromaFrames(channels) {
+  const window = hann(CHROMA_SIZE);
+  const hop = ANALYSIS_RATE / CHROMA_FPS;
+  const re = new Float64Array(CHROMA_SIZE);
+  const im = new Float64Array(CHROMA_SIZE);
+  const frames = [];
+  for (let f = 0; Math.round(f * hop) < (channels[0]?.length ?? 0); f++) {
+    const chroma = new Float64Array(12);
+    const first = Math.round(f * hop) - CHROMA_SIZE / 2;
+    for (const channel of channels) {
+      for (let i = 0; i < CHROMA_SIZE; i++) {
+        const at = first + i;
+        re[i] = at >= 0 && at < channel.length ? channel[at] * window[i] : 0;
+        im[i] = 0;
+      }
+      fft(re, im);
+      PITCH_CLASS.forEach((pc, bin) => {
+        if (pc >= 0)
+          chroma[pc] += Math.hypot(re[bin], im[bin]);
+      });
+    }
+    frames.push(chroma);
+  }
+  return frames;
+}
+function bandFrames(signal) {
+  const channels = signal.channels.map((c) => resample(c, signal.sampleRate, ANALYSIS_RATE));
+  return {
+    fps: FRAMES_PER_SECOND,
+    bands: bandPower(channels),
+    chroma: chromaFrames(channels),
+    chromaFps: CHROMA_FPS
+  };
+}
+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 mean2 = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
+  const spread = Math.sqrt(curve.reduce((a, v) => a + (v - mean2) ** 2, 0) / (curve.length || 1));
+  return spread > 0 ? curve.map((v) => v / spread) : curve.map(() => 0);
+}
+function onsetCurves({ fps, bands }) {
+  const lowBands = bandEdges().filter((bin) => bin * ANALYSIS_RATE / FRAME_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 frame = bands[f];
+    const previous = bands[f - 1];
+    for (let b = 0; b < frame.length; b++) {
+      const rise = Math.max(0, frame[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 mean2 = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
+  const centred = curve.map((v) => v - mean2);
+  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) / 0.8) ** 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.9)),
+    longest: Math.min(fullRange(fps).longest, Math.ceil(period * 1.1))
+  };
+  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 (frame) => interpolate(centres, median, frame);
+}
+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;
+}
+var mean = (values) => values.reduce((a, b) => a + b, 0) / (values.length || 1);
+function zScored(values) {
+  const centre = mean(values);
+  const spread = Math.sqrt(mean(values.map((v) => (v - centre) ** 2))) || 1;
+  return values.map((v) => (v - centre) / spread);
+}
+var CHROMA_REACH_SECONDS = CHROMA_SIZE / 2 / ANALYSIS_RATE;
+function chromaBetween({ chroma, chromaFps }, from, to) {
+  const middle = Math.round((from + to) / 2 * chromaFps);
+  let first = Math.ceil(from * chromaFps);
+  let end = Math.floor((to - CHROMA_REACH_SECONDS) * chromaFps) + 1;
+  if (end <= first)
+    [first, end] = [middle, middle + 1];
+  const sum = new Array(12).fill(0);
+  for (let f = first; f < end; f++)
+    for (let c = 0; c < 12; c++)
+      sum[c] += chroma[f]?.[c] ?? 0;
+  const length = Math.hypot(...sum) || 1;
+  return sum.map((v) => v / length);
+}
+var cosine = (a, b) => a.reduce((sum, v, i) => sum + v * b[i], 0);
+function harmonicChange(beats, fps, frames, span) {
+  return beats.map((f, k) => {
+    if (k < span || k + span >= beats.length)
+      return 0;
+    const before = chromaBetween(frames, beats[k - span] / fps, f / fps);
+    return 1 - cosine(before, chromaBetween(frames, f / fps, beats[k + span] / fps));
+  });
+}
+function barStartEvidence(beats, curves, frames) {
+  const lowHit = (f) => Math.max(...[-1, 0, 1, 2].map((d) => curves.low[f + d] ?? 0));
+  const cues = [
+    zScored(beats.map(lowHit)),
+    zScored(harmonicChange(beats, curves.fps, frames, 1)),
+    zScored(harmonicChange(beats, curves.fps, frames, 2))
+  ];
+  return beats.map((_, k) => cues.reduce((sum, cue) => sum + cue[k], 0));
+}
+var TRIPLE_METER_HANDICAP = 0.7;
+function barPhase(beats, curves, frames) {
+  const evidence = barStartEvidence(beats, curves, frames);
+  let best = { meter: 4, phase: 0, contrast: -Infinity };
+  for (const meter of [4, 3])
+    for (let phase = 0; phase < meter; phase++) {
+      const on = evidence.filter((_, k) => (k - phase) % meter === 0);
+      const off = evidence.filter((_, k) => (k - phase) % meter !== 0);
+      const contrast = (mean(on) - mean(off)) * (meter === 3 ? TRIPLE_METER_HANDICAP : 1);
+      if (contrast > best.contrast)
+        best = { meter, phase, contrast };
+    }
+  return best;
+}
+function downbeatsOf(beatList, times, curves, frames) {
+  const bar = beatList.length >= 6 ? barPhase(beatList, curves, frames) : null;
+  return {
+    times: bar ? times.filter((_, k) => (k - bar.phase) % bar.meter === 0) : [],
+    meter: bar?.meter ?? null,
+    confidence: "low"
+  };
+}
+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.15;
+var beatConfidence = (clarity, lift) => round(Math.max(0, Math.min(1, clarity)) * Math.max(0, Math.min(1, lift / 3)));
+function rhythmOf(frames) {
+  const curves = onsetCurves(frames);
+  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 + ONSET_LAG_SECONDS));
+  return { beats: { times, confidence }, downbeats: downbeatsOf(beatList, times, curves, frames) };
+}
+var TEMPO_STEP_SECONDS = 4;
+function steadyInterval(times) {
+  const median = medianInterval(times);
+  if (!median)
+    return null;
+  const near = times.slice(1).map((t, i) => t - times[i]).filter((gap) => Math.abs(gap - median) <= 0.1 * median);
+  return near.reduce((a, b) => a + b, 0) / near.length;
+}
+function tempoOf(times) {
+  const interval = steadyInterval(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 = steadyInterval(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);
+}
+
+// ../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((s) => s.outcome === "unavailable" || s.outcome === "failed");
+  if (!skipped.length)
+    return null;
+  const why = skipped.map((s) => `${s.provider} ${s.outcome}${s.reason ? ` (${s.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/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(measured2, toleranceSeconds, reference) {
+  const shifts = [];
+  const unsnapped = [];
+  return {
+    snap(t) {
+      const nearest = measured2.length ? measured2[nearestIndex(measured2, 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 frame of frames)
+    for (let b = 0; b < sum.length; b++)
+      sum[b] += frame[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 mean2 = column.reduce((a, v) => a + v, 0) / column.length;
+    const spread = Math.sqrt(column.reduce((a, v) => a + (v - mean2) ** 2, 0) / column.length);
+    for (const block of blocks)
+      block[b] = (block[b] - mean2) / (spread || 1);
+  }
+}
+function blockParts({ fps, bands, chroma, chromaFps }) {
+  const per = Math.max(1, Math.round(BLOCK_SECONDS * fps));
+  const chromaPer = Math.max(1, Math.round(BLOCK_SECONDS * chromaFps));
+  const blocks = [];
+  for (let start = 0, b = 0; start + per <= bands.length; start += per, b++) {
+    const pitch = meanOf(chroma.slice(b * chromaPer, (b + 1) * chromaPer)).map(Math.log1p);
+    blocks.push([...meanOf(bands.slice(start, start + per)), ...unit(pitch)]);
+  }
+  return blocks;
+}
+function blockFeatures(frames) {
+  const blocks = blockParts(frames);
+  standardizeBands(blocks);
+  const split = frames.bands[0]?.length ?? 0;
+  return blocks.map((block) => [...unit(block.slice(0, split)), ...unit(block.slice(split))].map((v) => v * Math.SQRT1_2));
+}
+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 mean2 = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
+  const spread = Math.sqrt(curve.reduce((a, v) => a + (v - mean2) ** 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] <= mean2 + 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 s = 0; s + 1 < edges.length; s++) {
+    const part = blocks.slice(edges[s], edges[s + 1]);
+    const mean2 = unit(part[0].map((_, b) => part.reduce((a, block) => a + block[b], 0)));
+    const match = means.findIndex((other) => dot(other, mean2) >= SAME_SECTION);
+    letters.push(match >= 0 ? letters[match] : String.fromCharCode(65 + new Set(letters).size % 26));
+    means.push(mean2);
+  }
+  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, s) => ({ start: times[s], end: times[s + 1], label })),
+    snap: onBeat.report()
+  };
+}
+
+// ../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 frame of frames)
+    for (let bin = 0; bin < mixed.length; bin++)
+      mixed[bin] += frame[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 frame = 0; frame < count; frame++)
+    mixed.push(averageMagnitudes(stacked.map((channel) => channel[frame])));
+  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((frame) => {
+    let sum = 0;
+    for (const magnitude of frame)
+      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((frame) => frame.map((m) => Math.log1p(100 * m)));
+  const lastWhole = Math.floor((samples.length - fftSizeFor(signal.sampleRate) / 2) / hopSamples(signal.sampleRate, hopMs));
+  return frames.map((frame, i) => {
+    const previous = frames[i - 1];
+    if (!previous || i > lastWhole)
+      return 0;
+    let flux = 0;
+    for (let k = 0; k < frame.length; k++)
+      flux += Math.max(0, frame[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 mean2 = curve.reduce((a, b) => a + b, 0) / (curve.length || 1);
+  const centred = curve.map((v) => v - mean2);
+  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 mean2 = re.reduce((a, b) => a + b, 0) / size;
+  for (let i = 0; i < size; i++)
+    re[i] = re[i] - mean2;
+  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);
+  }
+};
+
+export {
+  medianInterval,
+  tempoOf,
+  bandFramesOf,
+  rhythm,
+  snapper,
+  runLadder,
+  signalDuration,
+  energyMix,
+  envelope,
+  signalProvider,
+  probeAudio,
+  decodeAudio
+};