@aelionsdk/audio 0.1.0-beta.1

package/dist/processing.js

@@ -0,0 +1,386 @@
+import { throwIfAborted } from '@aelionsdk/core';
+export function applyChannelMatrix(input, matrix) {
+    if (!Number.isSafeInteger(matrix.inputChannels) ||
+        !Number.isSafeInteger(matrix.outputChannels) ||
+        matrix.inputChannels <= 0 ||
+        matrix.outputChannels <= 0 ||
+        matrix.gains.length !== matrix.inputChannels * matrix.outputChannels ||
+        input.length % matrix.inputChannels !== 0) {
+        throw new RangeError('Invalid channel matrix or interleaved PCM length');
+    }
+    const frames = input.length / matrix.inputChannels;
+    const output = new Float32Array(frames * matrix.outputChannels);
+    for (let frame = 0; frame < frames; frame += 1) {
+        for (let outputChannel = 0; outputChannel < matrix.outputChannels; outputChannel += 1) {
+            let sample = 0;
+            for (let inputChannel = 0; inputChannel < matrix.inputChannels; inputChannel += 1) {
+                sample +=
+                    (input[frame * matrix.inputChannels + inputChannel] ?? 0) *
+                        (matrix.gains[outputChannel * matrix.inputChannels + inputChannel] ?? 0);
+            }
+            output[frame * matrix.outputChannels + outputChannel] = sample;
+        }
+    }
+    return output;
+}
+function smoothingCoefficient(durationUs, sampleRate) {
+    return durationUs <= 0 ? 0 : Math.exp(-1 / ((durationUs / 1_000_000) * sampleRate));
+}
+export class SidechainDucker {
+    #options;
+    #delay;
+    #attack;
+    #release;
+    #delayFrame = 0;
+    #gain = 1;
+    constructor(options) {
+        if (!Number.isSafeInteger(options.sampleRate) ||
+            !Number.isSafeInteger(options.channelCount) ||
+            options.sampleRate <= 0 ||
+            options.channelCount <= 0 ||
+            options.reductionDb > 0 ||
+            options.attackUs < 0 ||
+            options.releaseUs < 0 ||
+            options.lookaheadUs < 0) {
+            throw new RangeError('Invalid sidechain ducking options');
+        }
+        this.#options = options;
+        const lookaheadFrames = Math.ceil((options.lookaheadUs * options.sampleRate) / 1_000_000);
+        this.#delay = new Float32Array(lookaheadFrames * options.channelCount);
+        this.#attack = smoothingCoefficient(options.attackUs, options.sampleRate);
+        this.#release = smoothingCoefficient(options.releaseUs, options.sampleRate);
+    }
+    get latencyFrames() {
+        return this.#delay.length / this.#options.channelCount;
+    }
+    reset() {
+        this.#delay.fill(0);
+        this.#delayFrame = 0;
+        this.#gain = 1;
+    }
+    process(program, sidechain) {
+        const frames = sidechain.length;
+        if (program.length !== frames * this.#options.channelCount) {
+            throw new RangeError('Sidechain must contain one mono sample per program frame');
+        }
+        const output = new Float32Array(program.length);
+        const minimumGain = 10 ** (this.#options.reductionDb / 20);
+        const threshold = 10 ** (this.#options.thresholdDb / 20);
+        for (let frame = 0; frame < frames; frame += 1) {
+            const detector = Math.abs(sidechain[frame] ?? 0);
+            const target = detector > threshold ? minimumGain : 1;
+            const coefficient = target < this.#gain ? this.#attack : this.#release;
+            this.#gain = target + coefficient * (this.#gain - target);
+            for (let channel = 0; channel < this.#options.channelCount; channel += 1) {
+                const inputSample = program[frame * this.#options.channelCount + channel] ?? 0;
+                if (this.latencyFrames === 0) {
+                    output[frame * this.#options.channelCount + channel] = inputSample * this.#gain;
+                    continue;
+                }
+                const delayIndex = this.#delayFrame * this.#options.channelCount + channel;
+                output[frame * this.#options.channelCount + channel] =
+                    (this.#delay[delayIndex] ?? 0) * this.#gain;
+                this.#delay[delayIndex] = inputSample;
+            }
+            if (this.latencyFrames > 0) {
+                this.#delayFrame = (this.#delayFrame + 1) % this.latencyFrames;
+            }
+        }
+        return output;
+    }
+}
+function decibels(value) {
+    return value <= 0 ? Number.NEGATIVE_INFINITY : 20 * Math.log10(value);
+}
+/** Deterministic EBU-style block gating with 4× linear true-peak estimation. */
+export function analyzeLoudness(pcm, sampleRate, channelCount) {
+    if (!Number.isSafeInteger(sampleRate) ||
+        !Number.isSafeInteger(channelCount) ||
+        sampleRate <= 0 ||
+        channelCount <= 0 ||
+        pcm.length % channelCount !== 0) {
+        throw new RangeError('Invalid loudness PCM format');
+    }
+    const frames = pcm.length / channelCount;
+    const blockFrames = Math.max(1, Math.round(sampleRate * 0.4));
+    const energies = [];
+    let samplePeak = 0;
+    let truePeak = 0;
+    for (let start = 0; start < frames; start += blockFrames) {
+        const end = Math.min(frames, start + blockFrames);
+        let sumSquares = 0;
+        let count = 0;
+        for (let frame = start; frame < end; frame += 1) {
+            for (let channel = 0; channel < channelCount; channel += 1) {
+                const current = pcm[frame * channelCount + channel] ?? 0;
+                const next = pcm[Math.min(frames - 1, frame + 1) * channelCount + channel] ?? current;
+                samplePeak = Math.max(samplePeak, Math.abs(current));
+                for (let phase = 0; phase < 4; phase += 1) {
+                    truePeak = Math.max(truePeak, Math.abs(current + ((next - current) * phase) / 4));
+                }
+                sumSquares += current * current;
+                count += 1;
+            }
+        }
+        energies.push(count === 0 ? 0 : sumSquares / count);
+    }
+    const lufs = (energy) => energy <= 0 ? Number.NEGATIVE_INFINITY : -0.691 + 10 * Math.log10(energy);
+    const absoluteGated = energies.filter(energy => lufs(energy) >= -70);
+    const ungatedEnergy = absoluteGated.reduce((sum, value) => sum + value, 0) / Math.max(1, absoluteGated.length);
+    const relativeThreshold = lufs(ungatedEnergy) - 10;
+    const gated = absoluteGated.filter(energy => lufs(energy) >= relativeThreshold);
+    const integratedEnergy = gated.reduce((sum, value) => sum + value, 0) / Math.max(1, gated.length);
+    return {
+        integratedLufs: lufs(integratedEnergy),
+        ungatedLufs: lufs(ungatedEnergy),
+        truePeakDbtp: decibels(truePeak),
+        samplePeakDbfs: decibels(samplePeak),
+        gatedBlocks: gated.length,
+        totalBlocks: energies.length,
+    };
+}
+export class TruePeakLimiter {
+    #channels;
+    #ceiling;
+    #release;
+    #delay;
+    #frame = 0;
+    #gain = 1;
+    constructor(options) {
+        if (options.sampleRate <= 0 || options.channelCount <= 0) {
+            throw new RangeError('Invalid limiter format');
+        }
+        this.#channels = options.channelCount;
+        this.#ceiling = 10 ** ((options.ceilingDbtp ?? -1) / 20);
+        this.#release = smoothingCoefficient(options.releaseUs ?? 100_000, options.sampleRate);
+        const frames = Math.max(0, Math.ceil(((options.lookaheadUs ?? 5_000) * options.sampleRate) / 1_000_000));
+        this.#delay = new Float32Array(frames * options.channelCount);
+    }
+    get latencyFrames() {
+        return this.#delay.length / this.#channels;
+    }
+    process(input) {
+        if (input.length % this.#channels !== 0)
+            throw new RangeError('Invalid limiter PCM length');
+        const output = new Float32Array(input.length);
+        for (let frame = 0; frame < input.length / this.#channels; frame += 1) {
+            let peak = 0;
+            for (let channel = 0; channel < this.#channels; channel += 1) {
+                peak = Math.max(peak, Math.abs(input[frame * this.#channels + channel] ?? 0));
+            }
+            const target = peak > this.#ceiling ? this.#ceiling / peak : 1;
+            this.#gain = target < this.#gain ? target : target + this.#release * (this.#gain - target);
+            for (let channel = 0; channel < this.#channels; channel += 1) {
+                const inputSample = input[frame * this.#channels + channel] ?? 0;
+                if (this.latencyFrames === 0) {
+                    output[frame * this.#channels + channel] = inputSample * this.#gain;
+                    continue;
+                }
+                const index = this.#frame * this.#channels + channel;
+                output[frame * this.#channels + channel] = (this.#delay[index] ?? 0) * this.#gain;
+                this.#delay[index] = inputSample;
+            }
+            if (this.latencyFrames > 0)
+                this.#frame = (this.#frame + 1) % this.latencyFrames;
+        }
+        return output;
+    }
+}
+/** Incremental variant of analyzeLoudness for bounded-memory export prepasses. */
+export class StreamingLoudnessAnalyzer {
+    #channelCount;
+    #blockFrames;
+    #energies = [];
+    #carry = [];
+    #previous;
+    #samplePeak = 0;
+    #truePeak = 0;
+    constructor(sampleRate, channelCount) {
+        if (!Number.isSafeInteger(sampleRate) ||
+            !Number.isSafeInteger(channelCount) ||
+            sampleRate <= 0 ||
+            channelCount <= 0) {
+            throw new RangeError('Invalid loudness PCM format');
+        }
+        this.#channelCount = channelCount;
+        this.#blockFrames = Math.max(1, Math.round(sampleRate * 0.4));
+        this.#previous = Array.from({ length: channelCount }, () => 0);
+    }
+    process(pcm) {
+        if (pcm.length % this.#channelCount !== 0) {
+            throw new RangeError('Invalid loudness PCM block length');
+        }
+        for (let index = 0; index < pcm.length; index += 1) {
+            const sample = pcm[index] ?? 0;
+            const channel = index % this.#channelCount;
+            const previous = this.#previous[channel] ?? sample;
+            this.#samplePeak = Math.max(this.#samplePeak, Math.abs(sample));
+            for (let phase = 1; phase <= 4; phase += 1) {
+                this.#truePeak = Math.max(this.#truePeak, Math.abs(previous + ((sample - previous) * phase) / 4));
+            }
+            this.#previous[channel] = sample;
+            this.#carry.push(sample);
+            if (this.#carry.length === this.#blockFrames * this.#channelCount) {
+                this.#commitCarry();
+            }
+        }
+    }
+    finish() {
+        if (this.#carry.length > 0)
+            this.#commitCarry();
+        const lufs = (energy) => energy <= 0 ? Number.NEGATIVE_INFINITY : -0.691 + 10 * Math.log10(energy);
+        const absoluteGated = this.#energies.filter(energy => lufs(energy) >= -70);
+        const ungatedEnergy = absoluteGated.reduce((sum, value) => sum + value, 0) / Math.max(1, absoluteGated.length);
+        const relativeThreshold = lufs(ungatedEnergy) - 10;
+        const gated = absoluteGated.filter(energy => lufs(energy) >= relativeThreshold);
+        const integratedEnergy = gated.reduce((sum, value) => sum + value, 0) / Math.max(1, gated.length);
+        return {
+            integratedLufs: lufs(integratedEnergy),
+            ungatedLufs: lufs(ungatedEnergy),
+            truePeakDbtp: decibels(this.#truePeak),
+            samplePeakDbfs: decibels(this.#samplePeak),
+            gatedBlocks: gated.length,
+            totalBlocks: this.#energies.length,
+        };
+    }
+    #commitCarry() {
+        let sumSquares = 0;
+        for (const sample of this.#carry)
+            sumSquares += sample * sample;
+        this.#energies.push(sumSquares / Math.max(1, this.#carry.length));
+        this.#carry.length = 0;
+    }
+}
+export async function buildWaveformPeaks(options) {
+    const maxPoints = options.maxPoints ?? 100_000;
+    if (options.sampleRate <= 0 ||
+        options.channelCount <= 0 ||
+        !Number.isSafeInteger(options.totalFrames) ||
+        options.totalFrames < 0 ||
+        !Number.isSafeInteger(maxPoints) ||
+        maxPoints <= 0) {
+        throw new RangeError('Invalid waveform options');
+    }
+    const requestedWindow = options.windowFrames ?? Math.max(1, Math.round(options.sampleRate / 100));
+    const windowFrames = Math.max(requestedWindow, Math.ceil(options.totalFrames / maxPoints));
+    if (!Number.isSafeInteger(windowFrames) || windowFrames <= 0) {
+        throw new RangeError('windowFrames must be a positive safe integer');
+    }
+    const peaks = [];
+    for (let startFrame = 0; startFrame < options.totalFrames; startFrame += windowFrames) {
+        throwIfAborted(options.signal, 'Waveform peak generation');
+        const frameCount = Math.min(windowFrames, options.totalFrames - startFrame);
+        const pcm = await options.readFrames(startFrame, frameCount, options.signal);
+        if (pcm.length !== frameCount * options.channelCount) {
+            throw new RangeError('Waveform source returned an unexpected PCM length');
+        }
+        const minimum = Array.from({ length: options.channelCount }, () => Number.POSITIVE_INFINITY);
+        const maximum = Array.from({ length: options.channelCount }, () => Number.NEGATIVE_INFINITY);
+        const squares = Array.from({ length: options.channelCount }, () => 0);
+        for (let frame = 0; frame < frameCount; frame += 1) {
+            for (let channel = 0; channel < options.channelCount; channel += 1) {
+                const sample = pcm[frame * options.channelCount + channel] ?? 0;
+                minimum[channel] = Math.min(minimum[channel] ?? sample, sample);
+                maximum[channel] = Math.max(maximum[channel] ?? sample, sample);
+                squares[channel] = (squares[channel] ?? 0) + sample * sample;
+            }
+        }
+        peaks.push({
+            startFrame,
+            frameCount,
+            min: minimum,
+            max: maximum,
+            rms: squares.map(sum => Math.sqrt(sum / frameCount)),
+        });
+        options.onProgress?.((startFrame + frameCount) / Math.max(1, options.totalFrames));
+    }
+    if (options.totalFrames === 0)
+        options.onProgress?.(1);
+    return {
+        sampleRate: options.sampleRate,
+        channelCount: options.channelCount,
+        totalFrames: options.totalFrames,
+        windowFrames,
+        peaks,
+    };
+}
+function invertFrameRanges(ranges, totalFrames) {
+    const result = [];
+    let cursor = 0;
+    for (const range of ranges) {
+        if (range.startFrame > cursor) {
+            result.push({ startFrame: cursor, frameCount: range.startFrame - cursor });
+        }
+        cursor = Math.max(cursor, range.startFrame + range.frameCount);
+    }
+    if (cursor < totalFrames)
+        result.push({ startFrame: cursor, frameCount: totalFrames - cursor });
+    return result;
+}
+/** Detect audible ranges with bounded reads and deterministic window merging. */
+export async function detectSilence(options) {
+    const thresholdDb = options.thresholdDb ?? -45;
+    const minimumSilenceUs = options.minimumSilenceUs ?? 250_000;
+    const paddingUs = options.paddingUs ?? 20_000;
+    const windowFrames = options.windowFrames ?? 1_024;
+    if (!Number.isSafeInteger(options.sampleRate) ||
+        !Number.isSafeInteger(options.channelCount) ||
+        !Number.isSafeInteger(options.totalFrames) ||
+        !Number.isSafeInteger(windowFrames) ||
+        options.sampleRate <= 0 ||
+        options.channelCount <= 0 ||
+        options.totalFrames < 0 ||
+        windowFrames <= 0 ||
+        !Number.isFinite(thresholdDb) ||
+        minimumSilenceUs < 0 ||
+        paddingUs < 0) {
+        throw new RangeError('Invalid silence detection options');
+    }
+    const threshold = 10 ** (thresholdDb / 20);
+    const audibleWindows = [];
+    for (let startFrame = 0; startFrame < options.totalFrames; startFrame += windowFrames) {
+        throwIfAborted(options.signal, 'Silence detection');
+        const frameCount = Math.min(windowFrames, options.totalFrames - startFrame);
+        const pcm = await options.readFrames(startFrame, frameCount, options.signal);
+        if (pcm.length !== frameCount * options.channelCount) {
+            throw new RangeError('Silence source returned an unexpected PCM length');
+        }
+        let sumSquares = 0;
+        for (const sample of pcm)
+            sumSquares += sample * sample;
+        const rms = Math.sqrt(sumSquares / Math.max(1, pcm.length));
+        if (rms > threshold)
+            audibleWindows.push({ startFrame, frameCount });
+        options.onProgress?.((startFrame + frameCount) / Math.max(1, options.totalFrames));
+    }
+    const minimumSilenceFrames = Math.round((minimumSilenceUs * options.sampleRate) / 1_000_000);
+    const paddingFrames = Math.round((paddingUs * options.sampleRate) / 1_000_000);
+    const nonSilent = [];
+    for (const window of audibleWindows) {
+        const startFrame = Math.max(0, window.startFrame - paddingFrames);
+        const endFrame = Math.min(options.totalFrames, window.startFrame + window.frameCount + paddingFrames);
+        const previous = nonSilent.at(-1);
+        if (previous !== undefined &&
+            startFrame - (previous.startFrame + previous.frameCount) <= minimumSilenceFrames) {
+            nonSilent[nonSilent.length - 1] = {
+                startFrame: previous.startFrame,
+                frameCount: endFrame - previous.startFrame,
+            };
+        }
+        else {
+            nonSilent.push({ startFrame, frameCount: endFrame - startFrame });
+        }
+    }
+    const silent = invertFrameRanges(nonSilent, options.totalFrames);
+    if (options.totalFrames === 0)
+        options.onProgress?.(1);
+    return {
+        sampleRate: options.sampleRate,
+        channelCount: options.channelCount,
+        totalFrames: options.totalFrames,
+        thresholdDb,
+        nonSilent,
+        silent,
+        removedFrames: silent.reduce((sum, range) => sum + range.frameCount, 0),
+    };
+}

package/dist/resampler.d.ts

@@ -0,0 +1,22 @@
+export interface StreamingPcmResamplerOptions {
+    readonly inputSampleRate: number;
+    readonly outputSampleRate: number;
+    readonly channelCount: number;
+}
+/**
+ * Deterministic, chunk-boundary-independent linear PCM resampler.
+ *
+ * The phase is represented with integer sample counts instead of an accumulated
+ * float, so a long render produces the same samples regardless of how providers
+ * split their PCM blocks. `push(..., true)` flushes the exact finite-duration
+ * tail and seals the instance.
+ */
+export declare class StreamingPcmResampler {
+    #private;
+    constructor(options: StreamingPcmResamplerOptions);
+    get inputFrames(): number;
+    get outputFrames(): number;
+    push(interleaved: Float32Array, final?: boolean): Float32Array;
+}
+export declare function resampleInterleavedPcm(input: Float32Array, options: StreamingPcmResamplerOptions): Float32Array;
+//# sourceMappingURL=resampler.d.ts.map

package/dist/resampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resampler.d.ts","sourceRoot":"","sources":["../src/resampler.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,gBAAgB,EAAE,MAAM,CAAC;IAClC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;CAC/B;AAiBD;;;;;;;GAOG;AACH,qBAAa,qBAAqB;;gBAUb,OAAO,EAAE,4BAA4B;IAUxD,IAAW,WAAW,IAAI,MAAM,CAE/B;IAED,IAAW,YAAY,IAAI,MAAM,CAEhC;IAEM,IAAI,CAAC,WAAW,EAAE,YAAY,EAAE,KAAK,UAAQ,GAAG,YAAY;CAyDpE;AAED,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,YAAY,EACnB,OAAO,EAAE,4BAA4B,GACpC,YAAY,CAEd"}

package/dist/resampler.js

@@ -0,0 +1,99 @@
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        throw new RangeError(`${name} must be a positive safe integer`);
+    }
+}
+function concat(left, right) {
+    if (left.length === 0)
+        return right.slice();
+    if (right.length === 0)
+        return left;
+    const result = new Float32Array(left.length + right.length);
+    result.set(left);
+    result.set(right, left.length);
+    return result;
+}
+/**
+ * Deterministic, chunk-boundary-independent linear PCM resampler.
+ *
+ * The phase is represented with integer sample counts instead of an accumulated
+ * float, so a long render produces the same samples regardless of how providers
+ * split their PCM blocks. `push(..., true)` flushes the exact finite-duration
+ * tail and seals the instance.
+ */
+export class StreamingPcmResampler {
+    #inputSampleRate;
+    #outputSampleRate;
+    #channelCount;
+    #buffer = new Float32Array();
+    #bufferStartFrame = 0;
+    #inputFrames = 0;
+    #outputFrames = 0;
+    #sealed = false;
+    constructor(options) {
+        positiveInteger(options.inputSampleRate, 'inputSampleRate');
+        positiveInteger(options.outputSampleRate, 'outputSampleRate');
+        positiveInteger(options.channelCount, 'channelCount');
+        if (options.channelCount > 8)
+            throw new RangeError('channelCount must not exceed 8');
+        this.#inputSampleRate = options.inputSampleRate;
+        this.#outputSampleRate = options.outputSampleRate;
+        this.#channelCount = options.channelCount;
+    }
+    get inputFrames() {
+        return this.#inputFrames;
+    }
+    get outputFrames() {
+        return this.#outputFrames;
+    }
+    push(interleaved, final = false) {
+        if (this.#sealed)
+            throw new ReferenceError('PCM resampler is sealed');
+        if (interleaved.length % this.#channelCount !== 0) {
+            throw new RangeError('PCM length must be divisible by channelCount');
+        }
+        this.#buffer = concat(this.#buffer, interleaved);
+        this.#inputFrames += interleaved.length / this.#channelCount;
+        const maximumOutputFrames = final
+            ? Number((BigInt(this.#inputFrames) * BigInt(this.#outputSampleRate)) /
+                BigInt(this.#inputSampleRate))
+            : Number.MAX_SAFE_INTEGER;
+        const samples = [];
+        while (this.#outputFrames < maximumOutputFrames) {
+            const positionNumerator = BigInt(this.#outputFrames) * BigInt(this.#inputSampleRate);
+            const sourceFrame = Number(positionNumerator / BigInt(this.#outputSampleRate));
+            const fractionNumerator = Number(positionNumerator % BigInt(this.#outputSampleRate));
+            const needsNext = fractionNumerator !== 0;
+            if (sourceFrame >= this.#inputFrames ||
+                (!final && needsNext && sourceFrame + 1 >= this.#inputFrames)) {
+                break;
+            }
+            const localFrame = sourceFrame - this.#bufferStartFrame;
+            if (localFrame < 0)
+                throw new Error('PCM resampler discarded a required source frame');
+            const nextLocalFrame = Math.min(this.#buffer.length / this.#channelCount - 1, localFrame + 1);
+            const fraction = fractionNumerator / this.#outputSampleRate;
+            for (let channel = 0; channel < this.#channelCount; channel += 1) {
+                const first = this.#buffer[localFrame * this.#channelCount + channel] ?? 0;
+                const next = this.#buffer[nextLocalFrame * this.#channelCount + channel] ?? first;
+                samples.push(first + (next - first) * fraction);
+            }
+            this.#outputFrames += 1;
+        }
+        const nextPositionNumerator = BigInt(this.#outputFrames) * BigInt(this.#inputSampleRate);
+        const firstRequiredFrame = Number(nextPositionNumerator / BigInt(this.#outputSampleRate));
+        const discardFrames = Math.max(0, Math.min(this.#buffer.length / this.#channelCount, firstRequiredFrame - this.#bufferStartFrame));
+        if (discardFrames > 0) {
+            this.#buffer = this.#buffer.slice(discardFrames * this.#channelCount);
+            this.#bufferStartFrame += discardFrames;
+        }
+        if (final) {
+            this.#sealed = true;
+            this.#buffer = new Float32Array();
+        }
+        return Float32Array.from(samples);
+    }
+}
+export function resampleInterleavedPcm(input, options) {
+    return new StreamingPcmResampler(options).push(input, true);
+}

package/dist/time-stretch.d.ts

@@ -0,0 +1,30 @@
+export interface PitchPreservingTimeStretchOptions {
+    readonly input: Float32Array;
+    readonly inputFrames: number;
+    readonly outputFrames: number;
+    readonly channelCount: number;
+    readonly reverse?: boolean;
+    /** Analysis grain size. The implementation clamps it to the available input. */
+    readonly grainFrames?: number;
+}
+export interface StreamingPitchPreservingTimeStretchOptions {
+    readonly inputFrames: number;
+    readonly outputFrames: number;
+    readonly channelCount: number;
+    readonly grainFrames?: number;
+}
+/**
+ * Stateful deterministic synchronous overlap-add time stretch.
+ *
+ * Input can arrive in arbitrary chunks. Grains and correlation searches stay
+ * anchored to the complete stream, and only samples that can no longer be
+ * affected by a later grain are emitted. This makes adjacent offline mixer
+ * blocks continuous without retaining the whole source or output.
+ */
+export declare class StreamingPitchPreservingTimeStretch {
+    #private;
+    constructor(options: StreamingPitchPreservingTimeStretchOptions);
+    push(interleaved: Float32Array, final?: boolean): Float32Array;
+}
+export declare function pitchPreservingTimeStretch(options: PitchPreservingTimeStretchOptions): Float32Array;
+//# sourceMappingURL=time-stretch.d.ts.map

package/dist/time-stretch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-stretch.d.ts","sourceRoot":"","sources":["../src/time-stretch.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iCAAiC;IAChD,QAAQ,CAAC,KAAK,EAAE,YAAY,CAAC;IAC7B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,gFAAgF;IAChF,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,0CAA0C;IACzD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AAiBD;;;;;;;GAOG;AACH,qBAAa,mCAAmC;;gBAiB3B,OAAO,EAAE,0CAA0C;IAkB/D,IAAI,CAAC,WAAW,EAAE,YAAY,EAAE,KAAK,UAAQ,GAAG,YAAY;CAmHpE;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,iCAAiC,GACzC,YAAY,CAwBd"}