@driftengine/audio 3.61.0

package/dist/rhythm/beatMap.js

@@ -0,0 +1,405 @@
+import { RHYTHM_BANDS, createBandEnergies } from './bands.js';
+import { KickCore } from './kickCore.js';
+/**
+ * Analysis hop. 5 ms is a fifth of the placement tolerance and coarse enough
+ * that a three-minute track is under a tenth of a second of work.
+ */
+const HOP_SEC = 0.005;
+/** Energy envelope resolution, for structure rather than for timing. */
+const ENERGY_HZ = 10;
+/**
+ * Refractory period, from the prior art. A kick's body rings for longer than
+ * this, and without it one hit is reported three times.
+ */
+const MIN_INTERVAL_SEC = 0.074;
+/**
+ * Half-width of the peak-picking window, in hops (±40 ms).
+ *
+ * A candidate must be the largest onset within this window. Wider merges
+ * genuinely separate kicks at fast tempos; narrower lets a ringing tail count
+ * as its own peak, which is how one hit became two beats 64 ms apart in the
+ * first working version.
+ */
+const PEAK_WINDOW_HOPS = 8;
+/**
+ * Where a transient is considered to have *started*, as a fraction of its peak.
+ *
+ * Reporting the peak itself is late and, worse, late by an amount that varies
+ * with how sharp the hit is — soft kicks land tens of milliseconds behind hard
+ * ones, so an edit drifts against its own music. Walking back to a fixed
+ * fraction of the peak gives the same reference point for every hit.
+ */
+const ONSET_BACKTRACK = 0.35;
+/**
+ * Minimum strength for a beat to be reported at all.
+ *
+ * A transient that barely clears its own adaptive floor is indistinguishable
+ * from the track breathing, and its *timing* is correspondingly vague — the
+ * peak is broad, so the reported instant wanders. Nothing downstream would cut
+ * on one anyway, since the director weights by strength.
+ */
+const MIN_STRENGTH = 0.03;
+/** Plausible tempo range. Outside it the estimate is a harmonic, not a tempo. */
+const MIN_BPM = 60;
+const MAX_BPM = 200;
+/*
+ * The smoothing, whitening, floors and shape gates moved to `kickCore.ts`, which `kickDetector`
+ * now shares with this file. They were the same numbers in both, applied at different rates and
+ * to a different whitening — see that module's header. The hop below is the step they were tuned
+ * at and is what the core's own rates are derived from, so nothing about this file's output
+ * moved when they left it.
+ */
+/** How much of each masking band is subtracted from the kick band. */
+/**
+ * Settling time before any beat may be reported.
+ *
+ * Every filter and running mean starts at zero, so the first hop of any track
+ * looks like an enormous transient against a floor of nothing — a guaranteed
+ * false beat at the start of every song, including one that opens with four
+ * bars of silence. The curves are built over a warm-up prefix first and that
+ * prefix is then discarded, so a genuine downbeat at 0 is still found.
+ */
+const WARMUP_SEC = 0.5;
+/** A map with no beats in it, for when there is no music to analyse. */
+export function emptyBeatMap(durationSec = 0) {
+    return {
+        beats: new Float32Array(0),
+        strength: new Float32Array(0),
+        bpm: 0,
+        bpmConfidence: 0,
+        energy: new Float32Array(0),
+        energyHz: ENERGY_HZ,
+        durationSec,
+    };
+}
+export function analyseTrack(samples, sampleRate) {
+    const durationSec = samples.length / sampleRate;
+    const curves = buildCurves(samples, sampleRate);
+    const { beats, strength } = pickPeaks(curves);
+    const { bpm, confidence } = estimateTempo(beats);
+    return {
+        beats: Float32Array.from(beats),
+        strength: Float32Array.from(strength),
+        bpm,
+        bpmConfidence: confidence,
+        energy: curves.energy,
+        energyHz: ENERGY_HZ,
+        durationSec,
+    };
+}
+/**
+ * One pass over the samples, producing the curves peak-picking works on.
+ *
+ * Separated from peak-picking because they want opposite things: this is
+ * causal and streaming, that one needs to look forward and backward. Trying to
+ * do both at once is what produces a detector that fires on the wrong edge.
+ */
+function buildCurves(samples, sampleRate) {
+    const hopSamples = Math.max(1, Math.round(sampleRate * HOP_SEC));
+    const hops = Math.max(1, Math.floor(samples.length / hopSamples));
+    const warmupHops = Math.min(hops, Math.round(WARMUP_SEC / HOP_SEC));
+    const filters = createBandFilters(sampleRate);
+    const energies = createBandEnergies();
+    const onset = new Float32Array(hops);
+    const floor = new Float32Array(hops);
+    const shaped = new Uint8Array(hops);
+    const energyHops = Math.max(1, Math.round(1 / (ENERGY_HZ * HOP_SEC)));
+    const energy = new Float32Array(Math.max(1, Math.ceil(hops / energyHops)));
+    /* Every running mean, envelope and gate this analyser shares with the live detector. */
+    const core = new KickCore();
+    let energyAccum = 0;
+    let energyCount = 0;
+    let energyIndex = 0;
+    // Warm-up runs the same maths over the opening prefix and throws the results
+    // away, leaving the filters and running means settled for the real pass.
+    for (let pass = 0; pass < warmupHops + hops; pass++) {
+        const settling = pass < warmupHops;
+        const hop = settling ? pass : pass - warmupHops;
+        const start = hop * hopSamples;
+        measureBands(samples, start, hopSamples, filters, energies);
+        const { sub, punch, sweet, bassline, mud, lowMid, high } = energies;
+        if (!settling) {
+            energyAccum += sub + punch + bassline + mud + lowMid + high;
+            energyCount++;
+            if (energyCount >= energyHops && energyIndex < energy.length) {
+                energy[energyIndex++] = energyAccum / energyCount;
+                energyAccum = 0;
+                energyCount = 0;
+            }
+        }
+        /*
+         * The shared decision: whitening, onset, flux, the adaptive floors and the shape gates, all
+         * in `kickCore.ts` so that a kick means the same thing here and in `kickDetector.ts`. The
+         * hop is what the core smooths over, which is what its own constants were tuned at.
+         */
+        core.step(energies, HOP_SEC);
+        if (settling)
+            continue;
+        /*
+         * The offline path's own extra condition on top of the shared shape gates: the whitened
+         * level has to clear its own floor as well. Live, that is one of the two threshold tests
+         * `KickCore.rising` makes; here it belongs with the shape because peak picking applies the
+         * onset threshold itself, a few lines further on, against a curve it can look along.
+         */
+        const kickLike = core.shaped && core.whitened > core.energyFloor;
+        onset[hop] = core.onset;
+        floor[hop] = core.onsetFloor;
+        shaped[hop] = kickLike ? 1 : 0;
+    }
+    if (energyCount > 0 && energyIndex < energy.length) {
+        energy[energyIndex] = energyAccum / energyCount;
+    }
+    return { onset, floor, shaped, energy, hopSec: HOP_SEC };
+}
+/**
+ * Turn the onset curve into beat times.
+ *
+ * A beat is a local maximum of the onset that clears its adaptive floor and is
+ * shaped like a kick. Reporting the peak itself would be late by an amount that
+ * varies with how sharp the hit is, so the time is walked back to where the
+ * transient crossed a fixed fraction of that peak — the same reference point
+ * for a soft kick and a hard one.
+ */
+function pickPeaks(curves) {
+    const { onset, floor, shaped, hopSec } = curves;
+    const beats = [];
+    const strength = [];
+    let lastBeatSec = -Infinity;
+    for (let hop = 0; hop < onset.length; hop++) {
+        if (shaped[hop] !== 1)
+            continue;
+        const value = onset[hop] ?? 0;
+        const threshold = floor[hop] ?? 0;
+        if (value <= threshold)
+            continue;
+        // Must be the largest onset nearby, or a ringing tail counts as its own hit.
+        let isPeak = true;
+        const from = Math.max(0, hop - PEAK_WINDOW_HOPS);
+        const to = Math.min(onset.length - 1, hop + PEAK_WINDOW_HOPS);
+        for (let i = from; i <= to; i++) {
+            if (i === hop)
+                continue;
+            const other = onset[i] ?? 0;
+            // Ties go to the earlier hop, so a plateau reports its leading edge.
+            if (other > value || (other === value && i < hop)) {
+                isPeak = false;
+                break;
+            }
+        }
+        if (!isPeak)
+            continue;
+        // Walk back to the start of the rise.
+        let onsetHop = hop;
+        const target = value * ONSET_BACKTRACK;
+        while (onsetHop > from && (onset[onsetHop - 1] ?? 0) > target)
+            onsetHop--;
+        const atSec = onsetHop * hopSec;
+        if (atSec - lastBeatSec <= MIN_INTERVAL_SEC)
+            continue;
+        // How far past its own floor the transient reached, which scales with the
+        // track rather than with an absolute level.
+        const power = Math.min(1, (value - threshold) / Math.max(1e-6, threshold * 4));
+        if (power < MIN_STRENGTH)
+            continue;
+        lastBeatSec = atSec;
+        beats.push(atSec);
+        strength.push(power);
+    }
+    return { beats, strength };
+}
+/**
+ * The most beats a gap between two reported ones may span, and how near a whole
+ * number of beats it has to land to count as one.
+ */
+const MAX_SPANNED_BEATS = 4;
+const SPAN_TOLERANCE = 0.12;
+/**
+ * How many beats an interval spans, or 0 when it is not a whole number of them.
+ *
+ * The analyser reports the hits it is sure of, so a gap between two of them is
+ * one beat or several, and deciding which is a single question asked in one
+ * place: the tempo estimate folds an interval down by this number, and the
+ * confidence count tests regularity with it. Two copies of the rule would agree
+ * until the first time either was tuned.
+ */
+function spannedBeats(interval, beat) {
+    const ratio = interval / beat;
+    const nearest = Math.round(ratio);
+    if (nearest < 1 || nearest > MAX_SPANNED_BEATS)
+        return 0;
+    return Math.abs(ratio - nearest) <= SPAN_TOLERANCE ? nearest : 0;
+}
+/**
+ * Tempo from the gaps between the beats that were reported.
+ *
+ * The reported beats are the hits the analyser is sure of and deliberately not
+ * every beat in the track, so a gap between two of them is a whole number of
+ * beats rather than one. Both steps below follow from that: the beat is chosen
+ * as the gap that accounts for the most others, and every gap is then folded
+ * down to a single beat before the median is taken.
+ *
+ * A statistic over the raw gaps cannot work however it is chosen, and a mean is
+ * not the only thing this rules out. The gaps form one cluster per number of
+ * beats skipped, so a mean sits between clusters and a median sits at the edge
+ * of one — neither lands on a beat, and the error grows with the share of
+ * beats missed rather than staying small.
+ *
+ * Confidence is the share of gaps that are a whole number of beats. Low
+ * confidence means the hits are real but do not lie on one pulse, which is a
+ * signal a caller should use rather than an error — and it is also the honest
+ * reading when the track has no single tempo.
+ *
+ * **What this cannot do**: separate a track counted at every other kick from
+ * one played at half the speed. Their gaps are identical, so nothing here can
+ * tell them apart, and such a track is reported at half its tempo with full
+ * confidence. It takes alternate kicks about 15 dB down to reach that state.
+ * The evidence that would settle it is not in the beat list and is not usably
+ * in the onset curve either — measured, the missing kick sits below the floor
+ * that would report it; `docs/IMPROVEMENTS.md` carries both numbers.
+ */
+function estimateTempo(beats) {
+    if (beats.length < 3)
+        return { bpm: 0, confidence: 0 };
+    const intervals = [];
+    for (let i = 1; i < beats.length; i++) {
+        intervals.push((beats[i] ?? 0) - (beats[i - 1] ?? 0));
+    }
+    const sorted = [...intervals].sort((a, b) => a - b);
+    /*
+     * The beat is the gap that accounts for the most other gaps.
+     *
+     * Taking the middle of the set instead is what this replaces, and it is wrong
+     * for a reason no amount of tuning reaches: every interval is a whole number
+     * of beats, so the set has one cluster per number of beats skipped, and its
+     * middle falls at the top of one cluster or the foot of the next rather than
+     * on a beat. Measured on synthetic tracks whose kicks are two in three, that
+     * put four tempos of six at *exactly half* their true value, and a fully
+     * detected 140 counted 2.6% slow.
+     *
+     * Scoring every observed gap as a candidate is what makes it robust rather
+     * than merely better placed. A single unrepresentative gap — a ghost hit
+     * close behind a real one, or one straddling a tempo change — explains
+     * nothing but itself and loses; picking a fixed quantile cannot tell the two
+     * apart, and a 128 read that way came out at 112 off one gap of 1.14 beats.
+     *
+     * Ties go to the longer candidate: within one cluster the choice moves the
+     * base by less than the tolerance and the median below settles the value.
+     *
+     * The cost is a pass over the gaps per gap. This runs once per track, off the
+     * frame loop, and a ten-minute track at 174 counts under two million steps.
+     * What would make it wrong is calling it per frame, which is what the live
+     * detector exists for.
+     */
+    let base = 0;
+    let explainedByBase = -1;
+    for (const candidate of sorted) {
+        if (candidate <= 0)
+            continue;
+        let explained = 0;
+        for (const interval of intervals) {
+            if (spannedBeats(interval, candidate) > 0)
+                explained++;
+        }
+        if (explained >= explainedByBase) {
+            explainedByBase = explained;
+            base = candidate;
+        }
+    }
+    if (base <= 0)
+        return { bpm: 0, confidence: 0 };
+    /*
+     * The base decides only how the gaps group; the median of what they fold to
+     * decides the tempo, so a base a hop or two off its cluster costs nothing.
+     */
+    const folded = [];
+    for (const interval of intervals) {
+        const spanned = spannedBeats(interval, base);
+        if (spanned > 0)
+            folded.push(interval / spanned);
+    }
+    folded.sort((a, b) => a - b);
+    const median = folded[folded.length >> 1] ?? base;
+    if (median <= 0)
+        return { bpm: 0, confidence: 0 };
+    let bpm = 60 / median;
+    // Fold octave errors back into a plausible range: catching every other kick
+    // reads as half tempo, and catching both hits of a double reads as twice it.
+    while (bpm < MIN_BPM)
+        bpm *= 2;
+    while (bpm > MAX_BPM)
+        bpm /= 2;
+    /*
+     * Confidence counts intervals that are a whole multiple of the median, not
+     * only ones equal to it. A detector that misses the occasional quiet kick
+     * leaves a double-length gap, and that is still perfectly regular — treating
+     * it as disagreement would report a steady track as rubato.
+     */
+    let regular = 0;
+    for (const interval of intervals) {
+        if (spannedBeats(interval, median) > 0)
+            regular++;
+    }
+    return { bpm, confidence: regular / intervals.length };
+}
+function onePole(cutoffHz, sampleRate) {
+    // Clamped below Nyquist so a high band on a low sample rate degrades to a
+    // pass-through instead of going unstable.
+    const x = Math.exp((-2 * Math.PI * Math.min(cutoffHz, sampleRate * 0.49)) / sampleRate);
+    return 1 - x;
+}
+function makeFilter(lowHz, highHz, sampleRate) {
+    return {
+        lowA: onePole(highHz, sampleRate),
+        highA: onePole(lowHz, sampleRate),
+        low: 0,
+        high: 0,
+    };
+}
+function createBandFilters(sampleRate) {
+    const b = RHYTHM_BANDS;
+    return {
+        sub: makeFilter(b.sub.lowHz, b.sub.highHz, sampleRate),
+        punch: makeFilter(b.punch.lowHz, b.punch.highHz, sampleRate),
+        sweet: makeFilter(b.sweet.lowHz, b.sweet.highHz, sampleRate),
+        bassline: makeFilter(b.bassline.lowHz, b.bassline.highHz, sampleRate),
+        mud: makeFilter(b.mud.lowHz, b.mud.highHz, sampleRate),
+        lowMid: makeFilter(b.lowMid.lowHz, b.lowMid.highHz, sampleRate),
+        high: makeFilter(b.high.lowHz, b.high.highHz, sampleRate),
+    };
+}
+/** RMS in each band over one hop, written into a caller-owned record. */
+function measureBands(samples, start, count, filters, out) {
+    let sub = 0;
+    let punch = 0;
+    let sweet = 0;
+    let bassline = 0;
+    let mud = 0;
+    let lowMid = 0;
+    let high = 0;
+    const end = Math.min(start + count, samples.length);
+    for (let i = start; i < end; i++) {
+        const x = samples[i] ?? 0;
+        sub += step(filters.sub, x);
+        punch += step(filters.punch, x);
+        sweet += step(filters.sweet, x);
+        bassline += step(filters.bassline, x);
+        mud += step(filters.mud, x);
+        lowMid += step(filters.lowMid, x);
+        high += step(filters.high, x);
+    }
+    const inv = 1 / Math.max(1, end - start);
+    out.sub = Math.sqrt(sub * inv);
+    out.punch = Math.sqrt(punch * inv);
+    out.sweet = Math.sqrt(sweet * inv);
+    out.bassline = Math.sqrt(bassline * inv);
+    out.mud = Math.sqrt(mud * inv);
+    out.lowMid = Math.sqrt(lowMid * inv);
+    out.high = Math.sqrt(high * inv);
+}
+/** Advance one filter by one sample and return that sample's squared output. */
+function step(filter, x) {
+    filter.low += (x - filter.low) * filter.lowA;
+    filter.high += (x - filter.high) * filter.highA;
+    const band = filter.low - filter.high;
+    return band * band;
+}

package/dist/rhythm/kickCore.d.ts

@@ -0,0 +1,79 @@
+/**
+ * What a kick is, in one place.
+ *
+ * Two analysers decide it: `beatMap.ts` offline, where an edit is cut, and `kickDetector.ts`
+ * live, where a light flashes. Their headers have always claimed the same bands, the same
+ * whitening and the same gates, because a replay whose cuts disagree with the lights in its own
+ * footage is the most confusing possible bug. They were two copies of that claim, and two copies
+ * drift: by the time this module was written they disagreed in two ways that a reader comparing
+ * the constants would not have seen.
+ *
+ *  - **Whitening.** Offline it was `kickBand - mask`; live it was `rms * 0.6 + kickBand * 0.6 -
+ *    mask`, a different quantity with a term the offline path has no equivalent for.
+ *  - **Time.** Every envelope was a fixed per-*step* lerp, and the two step at different rates:
+ *    a 5 ms hop offline, one call per rendered frame live. The same constant `0.1` is therefore
+ *    a 47 ms time constant in one and a 158 ms time constant in the other, and live it also
+ *    changed with the consumer's frame rate, so the same track detected differently on a 60 Hz
+ *    screen and a 144 Hz one.
+ *
+ * So the shared part lives here and both call it. The envelopes take a `dtSec` and smooth in
+ * *time* rather than per step, which is what makes one set of constants mean one thing at any
+ * rate. The rates are derived from the offline hop the constants were tuned at, so the offline
+ * analyser is unchanged to the last bit and the live one moves onto its terms.
+ *
+ * What stays outside: how the bands are measured (an FFT hop offline, an `AnalyserNode` live),
+ * peak picking and tempo, which need to look forward, and the pulse envelope, which is a
+ * lighting concern rather than a detection one.
+ */
+/** The seven band levels a kick is decided from, each 0 to 1. */
+export interface KickBands {
+    readonly sub: number;
+    readonly punch: number;
+    readonly sweet: number;
+    readonly bassline: number;
+    readonly mud: number;
+    readonly lowMid: number;
+    readonly high: number;
+}
+/** Ignore a rise this soon after the last one — one hit is one pulse. */
+export declare const MIN_INTERVAL_MS = 74;
+/** Where a kick's fundamental may sit. Outside this it is not a kick drum. */
+export declare const PEAK_MIN_HZ = 45;
+export declare const PEAK_MAX_HZ = 95;
+/**
+ * The running state both analysers keep, advanced one step at a time.
+ *
+ * Allocation-free after construction: `step` writes fields and returns nothing, because the live
+ * path calls it every frame.
+ */
+export declare class KickCore {
+    private onsetFast;
+    private onsetSlow;
+    private lowBandMean;
+    private lowBandDev;
+    private transientMean;
+    private transientDev;
+    private prevSub;
+    private prevPunch;
+    /** The kick band with the bassline's contribution taken out of it. */
+    whitened: number;
+    /** How much of that arrived just now rather than being present. */
+    onset: number;
+    /** Energy that *arrived* in the kick bands, rather than energy that is there. */
+    flux: number;
+    /** The adaptive thresholds `onset` and `whitened` have to clear. */
+    onsetFloor: number;
+    energyFloor: number;
+    /** Whether the spectral shape is kick-like at all, before any threshold. */
+    shaped: boolean;
+    /**
+     * One step. `dtSec` is how long it covers, which is the hop offline and the frame time live.
+     *
+     * `peakHz` is the tracked fundamental where a caller has one; the offline path has no
+     * band-pass to track and passes the centre of the allowed range, which is the same as saying
+     * it does not use this gate.
+     */
+    step(bands: KickBands, dtSec: number, peakHz?: number): void;
+    /** Whether this step is a hit, ignoring how recently the last one was. */
+    get rising(): boolean;
+}

package/dist/rhythm/kickCore.js

@@ -0,0 +1,166 @@
+/**
+ * What a kick is, in one place.
+ *
+ * Two analysers decide it: `beatMap.ts` offline, where an edit is cut, and `kickDetector.ts`
+ * live, where a light flashes. Their headers have always claimed the same bands, the same
+ * whitening and the same gates, because a replay whose cuts disagree with the lights in its own
+ * footage is the most confusing possible bug. They were two copies of that claim, and two copies
+ * drift: by the time this module was written they disagreed in two ways that a reader comparing
+ * the constants would not have seen.
+ *
+ *  - **Whitening.** Offline it was `kickBand - mask`; live it was `rms * 0.6 + kickBand * 0.6 -
+ *    mask`, a different quantity with a term the offline path has no equivalent for.
+ *  - **Time.** Every envelope was a fixed per-*step* lerp, and the two step at different rates:
+ *    a 5 ms hop offline, one call per rendered frame live. The same constant `0.1` is therefore
+ *    a 47 ms time constant in one and a 158 ms time constant in the other, and live it also
+ *    changed with the consumer's frame rate, so the same track detected differently on a 60 Hz
+ *    screen and a 144 Hz one.
+ *
+ * So the shared part lives here and both call it. The envelopes take a `dtSec` and smooth in
+ * *time* rather than per step, which is what makes one set of constants mean one thing at any
+ * rate. The rates are derived from the offline hop the constants were tuned at, so the offline
+ * analyser is unchanged to the last bit and the live one moves onto its terms.
+ *
+ * What stays outside: how the bands are measured (an FFT hop offline, an `AnalyserNode` live),
+ * peak picking and tempo, which need to look forward, and the pulse envelope, which is a
+ * lighting concern rather than a detection one.
+ */
+/**
+ * The step the constants below were tuned at: `beatMap.ts`'s own analysis hop.
+ *
+ * Every rate is derived from this, so a smoothing factor written as "per hop" keeps meaning
+ * exactly what it meant when it was chosen, and a caller stepping at any other interval gets the
+ * same curve in time rather than a different one.
+ */
+const REFERENCE_STEP_SEC = 0.005;
+/** A per-step factor at the reference hop, as a rate per second. */
+function ratePerSecond(perStep) {
+    return -Math.log(1 - perStep) / REFERENCE_STEP_SEC;
+}
+/** Envelope smoothing, named for what it follows. Written per hop, applied in time. */
+const ONSET_FAST_RATE = ratePerSecond(0.62);
+const ONSET_SLOW_RATE = ratePerSecond(0.1);
+const FLOOR_MEAN_RATE = ratePerSecond(0.012);
+const FLOOR_DEV_RATE = ratePerSecond(0.04);
+const TRANSIENT_MEAN_RATE = ratePerSecond(0.016);
+const TRANSIENT_DEV_RATE = ratePerSecond(0.05);
+/** How much of the low end a sustained bassline is allowed to explain away. */
+const MASK_BASSLINE = 0.68;
+const MASK_MUD = 0.22;
+const MASK_LOW_MID = 0.08;
+const MASK_SCALE = 0.55;
+/** Floors, as a minimum and as a multiple of the signal's own deviation. */
+const ENERGY_FLOOR_MIN = 0.0028;
+const ENERGY_FLOOR_DEV = 1.05;
+const ONSET_FLOOR_MIN = 0.0009;
+const ONSET_FLOOR_DEV = 1.35;
+/** Shape gates. Each rejects something loud that is not a kick. */
+const PUNCH_OVER_BASSLINE = 0.55;
+const SUB_OVER_MUD = 0.24;
+const LOW_SHARE_MIN = 0.18;
+const BASS_DOMINANCE_MIN = 0.55;
+/** Ignore a rise this soon after the last one — one hit is one pulse. */
+export const MIN_INTERVAL_MS = 74;
+/** Where a kick's fundamental may sit. Outside this it is not a kick drum. */
+export const PEAK_MIN_HZ = 45;
+export const PEAK_MAX_HZ = 95;
+/**
+ * How much of an envelope's remaining distance to cover in `dtSec`.
+ *
+ * Zero for a step that did not advance and one for a step long enough that whatever was held is
+ * stale, which is the right answer to a backgrounded tab: snap to what is true now rather than
+ * ease from a value that describes a minute ago.
+ */
+function approach(rate, dtSec) {
+    if (!(dtSec > 0))
+        return 0;
+    return 1 - Math.exp(-rate * dtSec);
+}
+/**
+ * The running state both analysers keep, advanced one step at a time.
+ *
+ * Allocation-free after construction: `step` writes fields and returns nothing, because the live
+ * path calls it every frame.
+ */
+export class KickCore {
+    onsetFast = 0;
+    onsetSlow = 0;
+    lowBandMean = 0;
+    lowBandDev = 0;
+    transientMean = 0;
+    transientDev = 0;
+    prevSub = 0;
+    prevPunch = 0;
+    /** The kick band with the bassline's contribution taken out of it. */
+    whitened = 0;
+    /** How much of that arrived just now rather than being present. */
+    onset = 0;
+    /** Energy that *arrived* in the kick bands, rather than energy that is there. */
+    flux = 0;
+    /** The adaptive thresholds `onset` and `whitened` have to clear. */
+    onsetFloor = 0;
+    energyFloor = 0;
+    /** Whether the spectral shape is kick-like at all, before any threshold. */
+    shaped = false;
+    /**
+     * One step. `dtSec` is how long it covers, which is the hop offline and the frame time live.
+     *
+     * `peakHz` is the tracked fundamental where a caller has one; the offline path has no
+     * band-pass to track and passes the centre of the allowed range, which is the same as saying
+     * it does not use this gate.
+     */
+    step(bands, dtSec, peakHz = (PEAK_MIN_HZ + PEAK_MAX_HZ) / 2) {
+        const { sub, punch, sweet, bassline, mud, lowMid, high } = bands;
+        /*
+         * Whitening: the kick band minus what a sustained bassline contributes to it. This is the
+         * step that turns "the low end is loud" — true for the whole track — into "something just
+         * hit", true for a few steps.
+         */
+        const kickBand = sub * 0.35 + punch * 0.45 + sweet * 0.2;
+        const mask = bassline * MASK_BASSLINE + mud * MASK_MUD + lowMid * MASK_LOW_MID;
+        this.whitened = Math.max(0, kickBand - mask * MASK_SCALE);
+        this.onsetFast += (this.whitened - this.onsetFast) * approach(ONSET_FAST_RATE, dtSec);
+        this.onsetSlow += (this.whitened - this.onsetSlow) * approach(ONSET_SLOW_RATE, dtSec);
+        this.onset = Math.max(0, this.onsetFast - this.onsetSlow);
+        /*
+         * A decaying kick has plenty of energy present and none arriving, which is what keeps one
+         * hit one beat.
+         */
+        this.flux = Math.max(0, sub - this.prevSub) * 0.58 + Math.max(0, punch - this.prevPunch) * 0.42;
+        this.prevSub = sub;
+        this.prevPunch = punch;
+        /*
+         * Adaptive floors, so the same analyser works on tracks mastered ten decibels apart — which
+         * matters the moment somebody imports their own.
+         */
+        this.lowBandMean += (this.whitened - this.lowBandMean) * approach(FLOOR_MEAN_RATE, dtSec);
+        this.lowBandDev +=
+            (Math.abs(this.whitened - this.lowBandMean) - this.lowBandDev) *
+                approach(FLOOR_DEV_RATE, dtSec);
+        const transientSignal = this.onset + this.flux * 0.18;
+        this.transientMean +=
+            (transientSignal - this.transientMean) * approach(TRANSIENT_MEAN_RATE, dtSec);
+        this.transientDev +=
+            (Math.abs(transientSignal - this.transientMean) - this.transientDev) *
+                approach(TRANSIENT_DEV_RATE, dtSec);
+        this.energyFloor =
+            this.lowBandMean + Math.max(ENERGY_FLOOR_MIN, this.lowBandDev * ENERGY_FLOOR_DEV);
+        this.onsetFloor =
+            this.transientMean + Math.max(ONSET_FLOOR_MIN, this.transientDev * ONSET_FLOOR_DEV);
+        const lowSum = sub + punch;
+        const lowShare = lowSum / Math.max(1e-6, lowSum + bassline + mud + lowMid + high);
+        const percussiveBody = lowMid * 0.72 + high * 0.58;
+        const bassDominance = (sub * 0.62 + punch * 0.38) / Math.max(1e-6, percussiveBody + mud * 0.45);
+        this.shaped =
+            punch > bassline * PUNCH_OVER_BASSLINE &&
+                sub > mud * SUB_OVER_MUD &&
+                lowShare > LOW_SHARE_MIN &&
+                bassDominance > BASS_DOMINANCE_MIN &&
+                peakHz >= PEAK_MIN_HZ &&
+                peakHz <= PEAK_MAX_HZ;
+    }
+    /** Whether this step is a hit, ignoring how recently the last one was. */
+    get rising() {
+        return this.shaped && this.onset > this.onsetFloor && this.whitened > this.energyFloor;
+    }
+}