@codexo/exojs 0.8.4 → 0.9.0

package/dist/esm/audio/worklets/beat-detector.worklet.js

@@ -0,0 +1,647 @@
+const beatDetectorWorkletSource = `
+// ---- Hann window + FFT (radix-2 Cooley-Tukey) ----
+function applyHannWindow(real, imag) {
+    var n = real.length;
+    for (var i = 0; i < n; i++) {
+        var w = 0.5 * (1 - Math.cos(2 * Math.PI * i / (n - 1)));
+        real[i] *= w;
+        imag[i] = 0;
+    }
+}
+
+function bitReversePermute(real, imag) {
+    var n = real.length;
+    var j = 0;
+    for (var i = 1; i < n; i++) {
+        var bit = n >> 1;
+        for (; j & bit; bit >>= 1) { j ^= bit; }
+        j ^= bit;
+        if (i < j) {
+            var t = real[i]; real[i] = real[j]; real[j] = t;
+            t = imag[i]; imag[i] = imag[j]; imag[j] = t;
+        }
+    }
+}
+
+function fftInPlace(real, imag) {
+    applyHannWindow(real, imag);
+    bitReversePermute(real, imag);
+    var n = real.length;
+    for (var len = 2; len <= n; len <<= 1) {
+        var halfLen = len >> 1;
+        var step = -2 * Math.PI / len;
+        for (var i = 0; i < n; i += len) {
+            for (var k = 0; k < halfLen; k++) {
+                var angle = step * k;
+                var cos = Math.cos(angle);
+                var sin = Math.sin(angle);
+                var re = real[i+k+halfLen]*cos - imag[i+k+halfLen]*sin;
+                var im = real[i+k+halfLen]*sin + imag[i+k+halfLen]*cos;
+                real[i+k+halfLen] = real[i+k] - re;
+                imag[i+k+halfLen] = imag[i+k] - im;
+                real[i+k] += re;
+                imag[i+k] += im;
+            }
+        }
+    }
+}
+
+// ---- Mel filterbank ----
+function buildMelFilterbank(numBands, fMin, fMax, fftSize, sampleRate) {
+    var numBins = fftSize >> 1;
+    var nyquist = sampleRate / 2;
+    var melMin = 2595 * Math.log10(1 + fMin / 700);
+    var melMax = 2595 * Math.log10(1 + fMax / 700);
+    var melPoints = new Float32Array(numBands + 2);
+    for (var i = 0; i < numBands + 2; i++) {
+        melPoints[i] = melMin + (melMax - melMin) * i / (numBands + 1);
+    }
+    var binPoints = new Float32Array(numBands + 2);
+    for (var i = 0; i < numBands + 2; i++) {
+        var hz = 700 * (Math.pow(10, melPoints[i] / 2595) - 1);
+        binPoints[i] = Math.round(hz / nyquist * (numBins - 1));
+    }
+    var bands = [];
+    for (var b = 0; b < numBands; b++) {
+        var startBin = Math.max(0, Math.min(numBins - 1, binPoints[b]));
+        var peakBin  = Math.max(0, Math.min(numBins - 1, binPoints[b+1]));
+        var endBin   = Math.max(0, Math.min(numBins - 1, binPoints[b+2]));
+        var len = endBin - startBin + 1;
+        var weights = new Float32Array(len);
+        for (var i = 0; i < len; i++) {
+            var bin = startBin + i;
+            if (bin <= peakBin && peakBin > startBin) {
+                weights[i] = (bin - startBin) / (peakBin - startBin);
+            } else if (bin > peakBin && endBin > peakBin) {
+                weights[i] = (endBin - bin) / (endBin - peakBin);
+            } else {
+                weights[i] = 1;
+            }
+        }
+        bands.push({ startBin: startBin, peakBin: peakBin, endBin: endBin, weights: weights });
+    }
+    return bands;
+}
+
+function computeMelBands(mag, bands, out) {
+    for (var b = 0; b < bands.length; b++) {
+        var band = bands[b];
+        var energy = 0;
+        for (var i = 0; i < band.weights.length; i++) {
+            energy += mag[band.startBin + i] * band.weights[i];
+        }
+        out[b] = Math.log(1 + energy);
+    }
+}
+
+// ---- Processor ----
+class BeatDetectorProcessor extends AudioWorkletProcessor {
+    constructor(options) {
+        super();
+        var opts = (options && options.processorOptions) || {};
+        this._sampleRate = sampleRate;
+        this._fftSize    = opts.fftSize    || 2048;
+        this._hopSize    = opts.hopSize    || 512;
+        this._minBpm     = opts.minBpm     || 50;
+        this._maxBpm     = opts.maxBpm     || 250;
+        this._melBands   = opts.melBands   || 24;
+        this._settlingMs = opts.settlingMs !== undefined ? opts.settlingMs : 1500;
+        this._tempoWindowSec = opts.tempoWindowSec || 6;
+        this._enableTsDetection = opts.enableTimeSignatureDetection !== false;
+
+        var numBins = this._fftSize >> 1;
+        this._real = new Float32Array(this._fftSize);
+        this._imag = new Float32Array(this._fftSize);
+        this._mag  = new Float32Array(numBins);
+        this._ringBuffer  = new Float32Array(this._fftSize);
+        this._ringWritePos = 0;
+        this._sampleCount  = 0;
+        this._hopAccum     = 0;
+
+        this._melBandFilters = buildMelFilterbank(this._melBands, 80, 8000, this._fftSize, this._sampleRate);
+        this._melOut         = new Float32Array(this._melBands);
+        var fluxWindowLen    = Math.ceil(this._tempoWindowSec * this._sampleRate / this._hopSize);
+        this._fluxWindow     = new Float32Array(fluxWindowLen);
+        this._fluxWritePos   = 0;
+        this._fluxCount      = 0;
+        var LAG_K = 3;
+        this._prevMelFrames  = [];
+        for (var i = 0; i < LAG_K; i++) {
+            this._prevMelFrames.push(new Float32Array(this._melBands));
+        }
+        this._prevMelFrameIdx = 0;
+
+        // Lag range in hops for BPM range
+        this._minLag = Math.max(1, Math.round(60 / this._maxBpm * this._sampleRate / this._hopSize));
+        this._maxLag = Math.round(60 / this._minBpm * this._sampleRate / this._hopSize);
+
+        this._hopsSinceACF = 0;
+        var ACF_INTERVAL = 15;
+        this._acfInterval = ACF_INTERVAL;
+
+        // Tempo state
+        this._bestBpm    = 0;
+        this._bestScore  = 0;
+        this._candidates = [];
+
+        // Phase state
+        this._lastBeatSample = -1;
+        this._ibiHistory     = new Float32Array(4); // last 4 inter-beat intervals
+        this._ibiIdx         = 0;
+
+        // Bar position state — parallel posteriors for 4/4 and 3/4
+        this._posterior4    = new Float32Array([0.25, 0.25, 0.25, 0.25]);
+        this._posterior3    = new Float32Array([1/3, 1/3, 1/3]);
+        this._ts4Confidence = 0.5;
+        this._ts3Confidence = 0.5;
+        this._activeTs      = '4/4';
+        this._sustainCounter = 0;
+        this._barPosition   = 1; // 1-indexed
+        this._barNumber     = 0;
+        this._beatsSinceStart = 0;
+
+        // Confidence
+        this._confidence = 0;
+
+        // State snapshot cadence (~20 Hz)
+        var STATE_INTERVAL_HOPS = Math.round(this._sampleRate / this._hopSize / 20);
+        this._stateInterval = Math.max(1, STATE_INTERVAL_HOPS);
+        this._hopsSinceState = 0;
+
+        // Settling
+        this._startSample   = currentFrame;
+        this._settledSamples = Math.round(this._settlingMs * 0.001 * this._sampleRate);
+
+        // Lookahead
+        this._lookahead = [];
+
+        // RMS / onset state
+        this._rms = 0;
+        this._onsetStrength = 0;
+
+        // Band energy (for state messages)
+        var LOW_BANDS  = Math.round(this._melBands * 0.25);
+        var MID_BANDS  = Math.round(this._melBands * 0.6);
+        this._lowBandEnd  = LOW_BANDS;
+        this._midBandEnd  = MID_BANDS;
+    }
+
+    process(inputs, _outputs, _parameters) {
+        var input = inputs[0];
+        if (!input || input.length === 0) return true;
+
+        var left  = input[0] || [];
+        var right = input[1] || left;
+        var blockLen = left.length;
+
+        for (var s = 0; s < blockLen; s++) {
+            // Mono downmix
+            var mono = (left[s] + right[s]) * 0.5;
+
+            // Accumulate RMS
+            this._rms += mono * mono;
+
+            // Fill ring buffer
+            this._ringBuffer[this._ringWritePos] = mono;
+            this._ringWritePos = (this._ringWritePos + 1) & (this._fftSize - 1);
+
+            this._hopAccum++;
+            this._sampleCount++;
+
+            if (this._hopAccum >= this._hopSize) {
+                this._hopAccum = 0;
+                this._processHop();
+            }
+        }
+
+        return true;
+    }
+
+    _processHop() {
+        // Read ring buffer into real[] (oldest first)
+        var rb = this._ringBuffer;
+        var wp = this._ringWritePos;
+        var n  = this._fftSize;
+        for (var i = 0; i < n; i++) {
+            this._real[i] = rb[(wp + i) & (n - 1)];
+        }
+
+        // FFT
+        fftInPlace(this._real, this._imag);
+
+        // Magnitude spectrum
+        var bins = n >> 1;
+        for (var i = 0; i < bins; i++) {
+            this._mag[i] = Math.sqrt(this._real[i]*this._real[i] + this._imag[i]*this._imag[i]);
+        }
+
+        // RMS (from time domain, using ring buffer)
+        var rmsAccum = 0;
+        for (var i = 0; i < n; i++) {
+            rmsAccum += rb[(wp + i) & (n - 1)] * rb[(wp + i) & (n - 1)];
+        }
+        this._rms = Math.sqrt(rmsAccum / n);
+
+        // Mel bands
+        computeMelBands(this._mag, this._melBandFilters, this._melOut);
+
+        // Spectral flux (SuperFlux-lite, lag k=3)
+        var K = this._prevMelFrames.length;
+        var flux = 0;
+        for (var b = 0; b < this._melBands; b++) {
+            var localMax = -Infinity;
+            for (var k = 0; k < K; k++) {
+                var prevVal = this._prevMelFrames[k][b];
+                if (prevVal > localMax) localMax = prevVal;
+            }
+            var diff = this._melOut[b] - localMax;
+            if (diff > 0) flux += diff;
+        }
+        this._onsetStrength = flux;
+
+        // Store current mel frame in circular buffer
+        var prevFrame = this._prevMelFrames[this._prevMelFrameIdx];
+        for (var b = 0; b < this._melBands; b++) {
+            prevFrame[b] = this._melOut[b];
+        }
+        this._prevMelFrameIdx = (this._prevMelFrameIdx + 1) % K;
+
+        // Add flux to sliding window
+        this._fluxWindow[this._fluxWritePos] = flux;
+        this._fluxWritePos = (this._fluxWritePos + 1) % this._fluxWindow.length;
+        if (this._fluxCount < this._fluxWindow.length) this._fluxCount++;
+
+        // Tempogram: compute ACF periodically
+        this._hopsSinceACF++;
+        if (this._hopsSinceACF >= this._acfInterval && this._fluxCount >= this._maxLag + 1) {
+            this._hopsSinceACF = 0;
+            this._computeACFAndCandidates();
+        }
+
+        // Phase tracker
+        var settled = (this._sampleCount - this._settledSamples) > 0;
+        if (this._bestBpm > 0 && settled) {
+            this._tickPhase(flux);
+        }
+
+        // State snapshot
+        this._hopsSinceState++;
+        if (this._hopsSinceState >= this._stateInterval) {
+            this._hopsSinceState = 0;
+            this._sendStateMessage();
+        }
+    }
+
+    _computeACFAndCandidates() {
+        var n   = this._fluxCount;
+        var buf = this._fluxWindow;
+        var wp  = this._fluxWritePos;
+        var len = buf.length;
+
+        // Compute ACF for lags in [minLag, maxLag]
+        var numLags = this._maxLag - this._minLag + 1;
+        var acf = new Float32Array(numLags);
+        for (var lagIdx = 0; lagIdx < numLags; lagIdx++) {
+            var lag = this._minLag + lagIdx;
+            var sum = 0, count = 0;
+            for (var t = lag; t < n; t++) {
+                var idxT   = (wp - 1 - (n - 1 - t) + len) % len;
+                var idxTL  = (wp - 1 - (n - 1 - (t - lag)) + len) % len;
+                sum += buf[idxT] * buf[idxTL];
+                count++;
+            }
+            acf[lagIdx] = count > 0 ? sum / count : 0;
+        }
+
+        // Normalise
+        var norm = 0;
+        for (var i = 0; i < numLags; i++) { if (acf[i] > norm) norm = acf[i]; }
+        if (norm > 0) {
+            for (var i = 0; i < numLags; i++) acf[i] /= norm;
+        }
+
+        // Find top peaks
+        var peaks = [];
+        for (var i = 1; i < numLags - 1; i++) {
+            if (acf[i] > acf[i-1] && acf[i] > acf[i+1] && acf[i] > 0) {
+                var lag2 = this._minLag + i;
+                var bpm = 60 * this._sampleRate / (lag2 * this._hopSize);
+                if (bpm >= this._minBpm && bpm <= this._maxBpm) {
+                    peaks.push({ bpm: bpm, score: acf[i], lag: lag2 });
+                }
+            }
+        }
+        peaks.sort(function(a, b) { return b.score - a.score; });
+        this._candidates = peaks.slice(0, 3);
+
+        if (this._candidates.length === 0) return;
+
+        var top = this._candidates[0];
+
+        // Hysteresis
+        if (this._bestBpm <= 0) {
+            // First lock
+            this._bestBpm   = top.bpm;
+            this._bestScore = top.score;
+        } else {
+            var isOctave = (Math.abs(top.bpm / this._bestBpm - 2) < 0.1) ||
+                           (Math.abs(top.bpm / this._bestBpm - 0.5) < 0.05);
+            var margin = isOctave ? 1.5 : 1.15;
+            if (top.score > this._bestScore * margin) {
+                var oldBpm = this._bestBpm;
+                this._bestBpm   = top.bpm;
+                this._bestScore = top.score;
+                // Only fire tempoChange if > 5% different
+                if (Math.abs(this._bestBpm - oldBpm) / oldBpm > 0.05) {
+                    this.port.postMessage({ type: 'tempoChange', newTempo: this._bestBpm, oldTempo: oldBpm });
+                }
+            } else {
+                this._bestScore = this._bestScore * 0.99 + top.score * 0.01; // slowly decay
+            }
+        }
+
+        this._updateConfidence();
+    }
+
+    _tickPhase(flux) {
+        if (this._lastBeatSample < 0) {
+            // Bootstrap: set first beat at current sample
+            this._lastBeatSample = this._sampleCount;
+            return;
+        }
+
+        var beatIntervalSamples = 60 / this._bestBpm * this._sampleRate;
+        var phase = (this._sampleCount - this._lastBeatSample) / beatIntervalSamples;
+
+        // Snap correction: if novelty peak is strong and phase is 0.7..1.3, snap
+        if (phase >= 0.7 && phase <= 1.3 && flux > 0) {
+            // Compute mean recent flux
+            var recentMean = 0;
+            var count = Math.min(this._fluxCount, 16);
+            var wp = this._fluxWritePos;
+            var len = this._fluxWindow.length;
+            for (var i = 0; i < count; i++) {
+                recentMean += this._fluxWindow[(wp - 1 - i + len) % len];
+            }
+            recentMean /= count || 1;
+            if (flux > 1.5 * recentMean && recentMean > 0) {
+                // Snap to this sample
+                this._lastBeatSample = this._sampleCount;
+                phase = 1.0;
+            }
+        }
+
+        if (phase >= 1.0) {
+            var beatTime = (this._lastBeatSample + beatIntervalSamples) / this._sampleRate;
+            this._lastBeatSample += beatIntervalSamples;
+
+            // Update IBI history
+            this._ibiHistory[this._ibiIdx] = beatIntervalSamples;
+            this._ibiIdx = (this._ibiIdx + 1) & 3;
+
+            this._beatsSinceStart++;
+
+            // Update bar position
+            this._updateBarPosition(flux);
+
+            // Compute confidence
+            this._updateConfidence();
+
+            // Lookahead
+            this._updateLookahead(beatTime);
+
+            var isDownbeat = this._barPosition === 1;
+            var beatInfo = {
+                type: 'beat',
+                audioTime: beatTime,
+                tempo: this._bestBpm,
+                confidence: this._confidence,
+                beatPhase: 0,
+                energy: flux,
+                isDownbeat: isDownbeat,
+                beatInBar: this._barPosition,
+            };
+            this.port.postMessage(beatInfo);
+
+            if (isDownbeat) {
+                this.port.postMessage({
+                    type: 'barStart',
+                    audioTime: beatTime,
+                    tempo: this._bestBpm,
+                    confidence: this._confidence,
+                    barNumber: this._barNumber,
+                });
+            }
+        }
+    }
+
+    _computeBeatLikelihood(flux) {
+        var count = Math.min(this._fluxCount, 32);
+        var wp = this._fluxWritePos;
+        var len = this._fluxWindow.length;
+        var totalFlux = 0;
+        for (var i = 0; i < count; i++) {
+            totalFlux += this._fluxWindow[(wp - 1 - i + len) % len];
+        }
+        var mean = count > 0 ? totalFlux / count : 1;
+        return Math.max(0.5, Math.min(1.5, mean > 0 ? flux / mean : 1));
+    }
+
+    _updateBarPosition(flux) {
+        var likelihood = this._computeBeatLikelihood(flux);
+
+        // --- 4/4 posterior ---
+        var p4 = this._posterior4;
+        var s4 = new Float32Array(4);
+        s4[0] = p4[3]; s4[1] = p4[0]; s4[2] = p4[1]; s4[3] = p4[2];
+        var sum4 = 0;
+        for (var i = 0; i < 4; i++) {
+            p4[i] = s4[i] * (likelihood + (i === 0 ? 0.3 : 0));
+            sum4 += p4[i];
+        }
+        if (sum4 > 0) { for (var i = 0; i < 4; i++) p4[i] /= sum4; }
+
+        // --- 3/4 posterior ---
+        var p3 = this._posterior3;
+        var s3 = new Float32Array(3);
+        s3[0] = p3[2]; s3[1] = p3[0]; s3[2] = p3[1];
+        var sum3 = 0;
+        for (var i = 0; i < 3; i++) {
+            p3[i] = s3[i] * (likelihood + (i === 0 ? 0.3 : 0));
+            sum3 += p3[i];
+        }
+        if (sum3 > 0) { for (var i = 0; i < 3; i++) p3[i] /= sum3; }
+
+        // --- Update TS confidences (EMA) ---
+        var max4 = 0;
+        for (var i = 0; i < 4; i++) { if (p4[i] > max4) max4 = p4[i]; }
+        var max3 = 0;
+        for (var i = 0; i < 3; i++) { if (p3[i] > max3) max3 = p3[i]; }
+        var alpha = 0.1;
+        this._ts4Confidence = (1 - alpha) * this._ts4Confidence + alpha * max4;
+        this._ts3Confidence = (1 - alpha) * this._ts3Confidence + alpha * max3;
+
+        // --- Hysteresis switching ---
+        if (this._enableTsDetection && this._beatsSinceStart > 8) {
+            var minSwitchMargin = 1.4;
+            var minSustainBeats = 12; // ~4 bars * 3 beats
+            var threeFavored = this._ts3Confidence > this._ts4Confidence * minSwitchMargin;
+            var fourFavored  = this._ts4Confidence > this._ts3Confidence * minSwitchMargin;
+
+            if (this._activeTs === '4/4' && threeFavored) {
+                this._sustainCounter++;
+                if (this._sustainCounter >= minSustainBeats) {
+                    this._activeTs = '3/4';
+                    this._sustainCounter = 0;
+                }
+            } else if (this._activeTs === '3/4' && fourFavored) {
+                this._sustainCounter++;
+                if (this._sustainCounter >= minSustainBeats + 4) { // 16 beats for 4/4
+                    this._activeTs = '4/4';
+                    this._sustainCounter = 0;
+                }
+            } else {
+                this._sustainCounter = 0;
+            }
+        }
+
+        // --- Determine bar position from active TS ---
+        var barLen = this._activeTs === '3/4' ? 3 : 4;
+        var posterior = this._activeTs === '3/4' ? p3 : p4;
+
+        if (this._beatsSinceStart >= barLen) {
+            var maxP = -1, maxI = 0;
+            for (var i = 0; i < barLen; i++) {
+                if (posterior[i] > maxP) { maxP = posterior[i]; maxI = i; }
+            }
+            var newPos = maxI + 1; // 1-indexed
+            if (newPos === 1 && this._barPosition !== 1) {
+                this._barNumber++;
+            }
+            this._barPosition = newPos;
+        } else {
+            // Just advance sequentially
+            this._barPosition = ((this._barPosition) % barLen) + 1;
+            if (this._barPosition === 1) this._barNumber++;
+        }
+    }
+
+    _updateConfidence() {
+        if (this._candidates.length === 0) {
+            this._confidence = 0;
+            return;
+        }
+
+        // Peak contrast
+        var top1 = this._candidates[0] ? this._candidates[0].score : 0;
+        var top2 = this._candidates[1] ? this._candidates[1].score : top1;
+        var top3 = this._candidates[2] ? this._candidates[2].score : top2;
+        var peakContrast = (top2 + top3) > 0 ? top1 / ((top2 + top3) / 2) : 1;
+
+        // Phase consistency from IBI variance
+        var ibiMean = 0;
+        for (var i = 0; i < 4; i++) ibiMean += this._ibiHistory[i];
+        ibiMean /= 4;
+        var ibiVar = 0;
+        for (var i = 0; i < 4; i++) {
+            var d = this._ibiHistory[i] - ibiMean;
+            ibiVar += d * d;
+        }
+        ibiVar /= 4;
+        var phaseConsistency = ibiMean > 0 ? Math.max(0, 1 - ibiVar / (ibiMean * ibiMean)) : 0;
+
+        // Bar consistency (use the active posterior)
+        var activePosterior = this._activeTs === '3/4' ? this._posterior3 : this._posterior4;
+        var activeLen = this._activeTs === '3/4' ? 3 : 4;
+        var maxP = 0;
+        for (var i = 0; i < activeLen; i++) {
+            if (activePosterior[i] > maxP) maxP = activePosterior[i];
+        }
+        var barConsistency = maxP;
+
+        var c = Math.sqrt(Math.max(0, peakContrast / 2)) *
+                Math.sqrt(Math.max(0, phaseConsistency)) *
+                (0.5 + 0.5 * barConsistency);
+        this._confidence = Math.max(0, Math.min(1, c));
+    }
+
+    _updateLookahead(lastBeatTime) {
+        var lookahead = [];
+        var beatInterval = 60 / this._bestBpm;
+        var barPos = this._barPosition;
+        var barLen = this._activeTs === '3/4' ? 3 : 4;
+        for (var i = 0; i < 8; i++) {
+            var t = lastBeatTime + (i + 1) * beatInterval;
+            var bp = ((barPos - 1 + i) % barLen) + 1;
+            lookahead.push({
+                audioTime: t,
+                tempo: this._bestBpm,
+                isDownbeat: bp === 1,
+                beatInBar: bp,
+            });
+        }
+        this._lookahead = lookahead;
+    }
+
+    _computeBandEnergy() {
+        var low = 0, mid = 0, high = 0;
+        for (var b = 0; b < this._lowBandEnd; b++) low += this._melOut[b];
+        for (var b = this._lowBandEnd; b < this._midBandEnd; b++) mid += this._melOut[b];
+        for (var b = this._midBandEnd; b < this._melBands; b++) high += this._melOut[b];
+        var denom = this._lowBandEnd || 1;
+        return {
+            low:  low  / denom,
+            mid:  mid  / Math.max(1, this._midBandEnd - this._lowBandEnd),
+            high: high / Math.max(1, this._melBands - this._midBandEnd),
+        };
+    }
+
+    _sendStateMessage() {
+        var settled = (this._sampleCount - this._settledSamples) > 0;
+        var beatInterval = this._bestBpm > 0 ? 60 / this._bestBpm : 0;
+        var currentTime = this._sampleCount / this._sampleRate;
+        var lastBeatTime = this._lastBeatSample >= 0 ? this._lastBeatSample / this._sampleRate : 0;
+        var beatPhase = beatInterval > 0
+            ? Math.min(1, (currentTime - lastBeatTime) / beatInterval)
+            : 0;
+        var nextBeatTime = lastBeatTime + beatInterval;
+
+        var nextDownbeatTime = nextBeatTime;
+        for (var i = 0; i < this._lookahead.length; i++) {
+            if (this._lookahead[i].isDownbeat) {
+                nextDownbeatTime = this._lookahead[i].audioTime;
+                break;
+            }
+        }
+
+        var be = this._computeBandEnergy();
+
+        this.port.postMessage({
+            type: 'state',
+            tempo: settled ? this._bestBpm : 0,
+            beatPhase: beatPhase,
+            confidence: settled ? this._confidence : 0,
+            gridStability: settled ? this._confidence : 0,
+            tempoCandidates: settled ? this._candidates.map(function(c) {
+                return { bpm: c.bpm, score: c.score };
+            }) : [],
+            rms: this._rms,
+            onsetStrength: this._onsetStrength,
+            bandEnergy: be,
+            barPosition: this._barPosition,
+            barLength: this._activeTs === '3/4' ? 3 : 4,
+            timeSignature: this._activeTs === '3/4'
+                ? { numerator: 3, denominator: 4 }
+                : { numerator: 4, denominator: 4 },
+            lookahead: this._lookahead,
+            nextBeatTime: settled ? nextBeatTime : 0,
+            nextDownbeatTime: settled ? nextDownbeatTime : 0,
+        });
+    }
+}
+
+registerProcessor('exojs-beat-detector', BeatDetectorProcessor);
+`;
+
+export { beatDetectorWorkletSource };
+//# sourceMappingURL=beat-detector.worklet.js.map

package/dist/esm/audio/worklets/beat-detector.worklet.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"beat-detector.worklet.js","sources":["../../../../../src/audio/worklets/beat-detector.worklet.ts"],"sourcesContent":[null],"names":[],"mappings":"AAAO,MAAM,yBAAyB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/audio/worklets/granular.worklet.d.ts

@@ -0,0 +1 @@
+export declare const granularWorkletSource = "\nconst sampleRate = globalThis.sampleRate;\n\nclass GranularProcessor extends AudioWorkletProcessor {\n    static get parameterDescriptors() {\n        return [\n            { name: 'grainSize', defaultValue: 0.05, minValue: 0.005, maxValue: 0.5, automationRate: 'k-rate' },\n            { name: 'density', defaultValue: 50, minValue: 1, maxValue: 500, automationRate: 'k-rate' },\n            { name: 'spread', defaultValue: 0.5, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },\n            { name: 'pitchMin', defaultValue: 1.0, minValue: 0.25, maxValue: 4.0, automationRate: 'k-rate' },\n            { name: 'pitchMax', defaultValue: 1.0, minValue: 0.25, maxValue: 4.0, automationRate: 'k-rate' },\n            { name: 'wet', defaultValue: 1.0, minValue: 0, maxValue: 1.0, automationRate: 'k-rate' },\n        ];\n    }\n\n    constructor(options) {\n        super();\n        const opts = options.processorOptions ?? {};\n        const bufferSeconds = opts.bufferSeconds ?? 2;\n        this._bufferLength = Math.floor(bufferSeconds * sampleRate);\n        this._buffer = new Float32Array(this._bufferLength);\n        this._writePos = 0;\n        this._timeUntilNextGrainSamples = 0;\n        this._grains = [];  // { startPos, ageSamples, lengthSamples, pitch }\n    }\n\n    process(inputs, outputs, parameters) {\n        const input = inputs[0]?.[0];\n        const output = outputs[0]?.[0];\n        if (!input || !output) return true;\n\n        const grainSize = parameters.grainSize[0];\n        const density = parameters.density[0];\n        const spread = parameters.spread[0];\n        const pitchMin = parameters.pitchMin[0];\n        const pitchMax = parameters.pitchMax[0];\n        const wet = parameters.wet[0];\n\n        const grainSizeSamples = Math.max(8, Math.floor(grainSize * sampleRate));\n        const samplesPerGrain = sampleRate / Math.max(1, density);\n\n        for (let i = 0; i < input.length; i++) {\n            // Write input to circular buffer\n            this._buffer[this._writePos] = input[i];\n            this._writePos = (this._writePos + 1) % this._bufferLength;\n\n            // Spawn new grain if scheduled\n            this._timeUntilNextGrainSamples -= 1;\n            if (this._timeUntilNextGrainSamples <= 0) {\n                // Random offset into recent past, biased by spread\n                const maxOffset = Math.floor(spread * this._bufferLength);\n                const offset = Math.floor(Math.random() * Math.max(1, maxOffset));\n                const startPos = (this._writePos - offset - grainSizeSamples + this._bufferLength) % this._bufferLength;\n                // Random pitch in [pitchMin, pitchMax]\n                const pitch = pitchMin + Math.random() * Math.max(0, pitchMax - pitchMin);\n\n                this._grains.push({ startPos, ageSamples: 0, lengthSamples: grainSizeSamples, pitch });\n                this._timeUntilNextGrainSamples = samplesPerGrain;\n            }\n\n            // Mix all active grains (apply Hann window)\n            let grainSum = 0;\n            for (let g = this._grains.length - 1; g >= 0; g--) {\n                const grain = this._grains[g];\n                if (grain.ageSamples >= grain.lengthSamples) {\n                    this._grains.splice(g, 1);\n                    continue;\n                }\n\n                const phase = grain.ageSamples / grain.lengthSamples;\n                const window = 0.5 * (1 - Math.cos(2 * Math.PI * phase));\n                const readPos = grain.startPos + grain.ageSamples * grain.pitch;\n                const sampleIndex = Math.floor(readPos) % this._bufferLength;\n                const safeIndex = (sampleIndex + this._bufferLength) % this._bufferLength;\n                grainSum += this._buffer[safeIndex] * window;\n\n                grain.ageSamples++;\n            }\n\n            output[i] = (1 - wet) * input[i] + wet * grainSum;\n        }\n        return true;\n    }\n}\nregisterProcessor('exojs-granular', GranularProcessor);\n";