@pipedog/core 0.0.0 → 0.1.0

package/dist/audio/resamplers/soxr_stream_resampler.d.ts

@@ -0,0 +1,75 @@
+import { BaseAudioResampler, type SoxrQuality } from "./base_audio_resampler.ts";
+/**
+ * Stand-in for `soxr.ResampleStream` (mono, int16).
+ *
+ * STUB: libsoxr is not available in JavaScript yet; constructing one throws.
+ *
+ * @internal
+ */
+export declare class SoxrResampleStream {
+    constructor(_options: {
+        inRate: number;
+        outRate: number;
+        numChannels: number;
+        quality: SoxrQuality;
+    });
+    resampleChunk(_chunk: Int16Array, _last?: boolean): Int16Array;
+    clear(): void;
+}
+export interface SOXRStreamAudioResamplerOptions {
+    /**
+     * SOXR quality preset. Higher quality means higher CPU cost. One of "VHQ"
+     * (default, very high quality), "HQ", "MQ", "LQ", or "QQ" (quick, lowest
+     * latency).
+     */
+    quality?: SoxrQuality;
+    /**
+     * Seconds of inactivity after which the internal resampler state is
+     * cleared to avoid audio artefacts from stale history. Set to `null` to
+     * never clear (recommended for telephony providers that have irregular gaps
+     * between chunks). Defaults to 0.2.
+     */
+    clearAfterSecs?: number | null;
+}
+/**
+ * Audio resampler implementation using the SoX ResampleStream library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ * It keeps an internal history which avoids clicks at chunk boundaries.
+ *
+ * Notes:
+ * - Only supports mono audio (1 channel).
+ * - Input must be 16-bit signed PCM audio as raw bytes.
+ */
+export declare class SOXRStreamAudioResampler extends BaseAudioResampler {
+    protected _quality: SoxrQuality;
+    protected _clearAfterSecs: number | null;
+    protected _inRate: number | null;
+    protected _outRate: number | null;
+    protected _lastResampleTime: number;
+    protected _soxrStream: SoxrResampleStream | null;
+    constructor(options?: SOXRStreamAudioResamplerOptions);
+    protected _initialize(inRate: number, outRate: number): void;
+    protected _maybeClearInternalState(): void;
+    protected _maybeInitializeSoxStream(inRate: number, outRate: number): SoxrResampleStream;
+    /**
+     * Resample audio data using soxr.ResampleStream resampler library.
+     *
+     * @param audio Input audio data as raw bytes (16-bit signed integers).
+     * @param inRate Original sample rate in Hz.
+     * @param outRate Target sample rate in Hz.
+     * @returns Resampled audio data as raw bytes (16-bit signed integers).
+     */
+    resample(audio: Uint8Array, inRate: number, outRate: number): Promise<Uint8Array>;
+    /**
+     * Emit the audio held in the filter and reset it for the next stream.
+     *
+     * @returns The remaining resampled audio as raw bytes, empty if no audio
+     *   has been resampled yet.
+     */
+    flush(): Promise<Uint8Array>;
+    /** Discard the audio held in the filter and reset it for the next stream. */
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=soxr_stream_resampler.d.ts.map

package/dist/audio/resamplers/soxr_stream_resampler.js

@@ -0,0 +1,146 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/soxr_stream_resampler.py
+/**
+ * SoX-based audio resampler stream implementation.
+ *
+ * Provides an audio resampler that uses the SoX ResampleStream library for
+ * very high quality audio sample rate conversion.
+ *
+ * When to use the SOXRStreamAudioResampler:
+ * 1. For real-time processing scenarios
+ * 2. When dealing with very long audio signals
+ * 3. When processing audio in chunks or streams
+ * 4. When you need to reuse the same resampler configuration multiple times,
+ *    as it saves initialization overhead
+ *
+ * PORTING NOTE: libsoxr has no edge-compatible JavaScript equivalent yet. The
+ * stream management (rate checks, idle clearing, flush/reset) is ported, but
+ * `SoxrResampleStream` is a stub whose constructor throws "not ported yet".
+ */
+import { time } from "@pipedog/asyncio";
+import { BaseAudioResampler } from "./base_audio_resampler.js";
+import { bytesToInt16 } from "./soxr_resampler.js";
+const EMPTY_AUDIO = new Int16Array(0);
+/**
+ * Stand-in for `soxr.ResampleStream` (mono, int16).
+ *
+ * STUB: libsoxr is not available in JavaScript yet; constructing one throws.
+ *
+ * @internal
+ */
+export class SoxrResampleStream {
+    constructor(_options) {
+        throw new Error("soxr stream resampling is not ported yet");
+    }
+    resampleChunk(_chunk, _last = false) {
+        throw new Error("soxr stream resampling is not ported yet");
+    }
+    clear() {
+        throw new Error("soxr stream resampling is not ported yet");
+    }
+}
+function int16ToBytes(samples) {
+    return new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+}
+/**
+ * Audio resampler implementation using the SoX ResampleStream library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ * It keeps an internal history which avoids clicks at chunk boundaries.
+ *
+ * Notes:
+ * - Only supports mono audio (1 channel).
+ * - Input must be 16-bit signed PCM audio as raw bytes.
+ */
+export class SOXRStreamAudioResampler extends BaseAudioResampler {
+    _quality;
+    _clearAfterSecs;
+    _inRate = null;
+    _outRate = null;
+    _lastResampleTime = 0;
+    _soxrStream = null;
+    constructor(options = {}) {
+        super();
+        this._quality = options.quality ?? "VHQ";
+        this._clearAfterSecs = options.clearAfterSecs === undefined ? 0.2 : options.clearAfterSecs;
+    }
+    _initialize(inRate, outRate) {
+        this._inRate = inRate;
+        this._outRate = outRate;
+        this._lastResampleTime = time();
+        this._soxrStream = new SoxrResampleStream({
+            inRate,
+            outRate,
+            numChannels: 1,
+            quality: this._quality,
+        });
+    }
+    _maybeClearInternalState() {
+        const currentTime = time();
+        if (this._clearAfterSecs !== null) {
+            if (currentTime - this._lastResampleTime > this._clearAfterSecs) {
+                if (this._soxrStream) {
+                    this._soxrStream.clear();
+                }
+            }
+        }
+        this._lastResampleTime = currentTime;
+    }
+    _maybeInitializeSoxStream(inRate, outRate) {
+        if (this._soxrStream === null) {
+            this._initialize(inRate, outRate);
+        }
+        else {
+            this._maybeClearInternalState();
+        }
+        if (this._inRate !== inRate || this._outRate !== outRate) {
+            throw new Error(`SOXRStreamAudioResampler cannot be reused with different sample rates: ` +
+                `expected ${this._inRate}->${this._outRate}, got ${inRate}->${outRate}`);
+        }
+        return this._soxrStream;
+    }
+    /**
+     * Resample audio data using soxr.ResampleStream resampler library.
+     *
+     * @param audio Input audio data as raw bytes (16-bit signed integers).
+     * @param inRate Original sample rate in Hz.
+     * @param outRate Target sample rate in Hz.
+     * @returns Resampled audio data as raw bytes (16-bit signed integers).
+     */
+    async resample(audio, inRate, outRate) {
+        if (inRate === outRate) {
+            return audio;
+        }
+        const stream = this._maybeInitializeSoxStream(inRate, outRate);
+        const audioData = bytesToInt16(audio);
+        const resampledAudio = stream.resampleChunk(audioData);
+        return int16ToBytes(resampledAudio);
+    }
+    /**
+     * Emit the audio held in the filter and reset it for the next stream.
+     *
+     * @returns The remaining resampled audio as raw bytes, empty if no audio
+     *   has been resampled yet.
+     */
+    async flush() {
+        if (!this._soxrStream) {
+            return new Uint8Array(0);
+        }
+        const tail = this._soxrStream.resampleChunk(EMPTY_AUDIO, true);
+        this._soxrStream.clear();
+        this._lastResampleTime = time();
+        return int16ToBytes(tail);
+    }
+    /** Discard the audio held in the filter and reset it for the next stream. */
+    async reset() {
+        if (this._soxrStream) {
+            this._soxrStream.clear();
+            this._lastResampleTime = time();
+        }
+    }
+}
+//# sourceMappingURL=soxr_stream_resampler.js.map

package/dist/audio/turn/base_turn_analyzer.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Base turn analyzer for determining end-of-turn in audio conversations.
+ *
+ * Provides the abstract base class and enumeration for analyzing when a user
+ * has finished speaking in a conversation.
+ */
+import type { MetricsData } from "../../metrics/metrics.ts";
+/**
+ * State enumeration for end-of-turn analysis results.
+ *
+ * - COMPLETE: the user has finished their turn and stopped speaking.
+ * - INCOMPLETE: the user is still speaking or may continue speaking.
+ */
+export declare const EndOfTurnState: {
+    readonly COMPLETE: 1;
+    readonly INCOMPLETE: 2;
+};
+export type EndOfTurnState = (typeof EndOfTurnState)[keyof typeof EndOfTurnState];
+/** Base class for turn analyzer parameters. */
+export declare class BaseTurnParams {
+    constructor(_options?: object);
+}
+export interface BaseTurnAnalyzerOptions {
+    /**
+     * Optional initial sample rate for audio processing. If provided, this
+     * will be used as the fixed sample rate.
+     */
+    sampleRate?: number | null;
+}
+/**
+ * Abstract base class for analyzing user end of turn.
+ *
+ * Defines the interface through abstract methods; subclasses implement the
+ * actual analysis.
+ */
+export declare abstract class BaseTurnAnalyzer {
+    protected _initSampleRate: number | null;
+    protected _sampleRate: number;
+    constructor(options?: BaseTurnAnalyzerOptions);
+    /** The effective sample rate for audio processing. */
+    get sampleRate(): number;
+    /**
+     * Sets the sample rate for audio processing.
+     *
+     * If the initial sample rate was provided, it will use that; otherwise, it
+     * sets to the provided sample rate.
+     *
+     * @param sampleRate The sample rate to set.
+     */
+    setSampleRate(sampleRate: number): void;
+    /** Whether speech has been detected. */
+    abstract get speechTriggered(): boolean;
+    /** The current turn analyzer configuration parameters. */
+    abstract get params(): BaseTurnParams;
+    /**
+     * Appends audio data for analysis.
+     *
+     * @param buffer The audio data to append.
+     * @param isSpeech Indicates whether the appended audio is speech or not.
+     * @returns The resulting state after appending the audio.
+     */
+    abstract appendAudio(buffer: Uint8Array, isSpeech: boolean): EndOfTurnState;
+    /**
+     * Analyzes if an end of turn has occurred based on the audio input.
+     *
+     * @returns The result of the end of turn analysis and optional metrics.
+     */
+    abstract analyzeEndOfTurn(): Promise<[EndOfTurnState, MetricsData | null]>;
+    /**
+     * Update the VAD start trigger time.
+     *
+     * The turn analyzer may choose to change its buffer size depending on this
+     * value.
+     *
+     * @param vadStartSecs The number of seconds of voice activity before
+     *   triggering the user speaking event.
+     */
+    updateVadStartSecs(_vadStartSecs: number): void;
+    /** Reset the turn analyzer to its initial state. */
+    abstract clear(): void;
+    /** Cleanup the turn analyzer. */
+    cleanup(): Promise<void>;
+}
+//# sourceMappingURL=base_turn_analyzer.d.ts.map

package/dist/audio/turn/base_turn_analyzer.js

@@ -0,0 +1,61 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/turn/base_turn_analyzer.py
+/**
+ * State enumeration for end-of-turn analysis results.
+ *
+ * - COMPLETE: the user has finished their turn and stopped speaking.
+ * - INCOMPLETE: the user is still speaking or may continue speaking.
+ */
+export const EndOfTurnState = {
+    COMPLETE: 1,
+    INCOMPLETE: 2,
+};
+/** Base class for turn analyzer parameters. */
+export class BaseTurnParams {
+    // Takes the options object so subclasses can forward it (Python **kwargs).
+    constructor(_options = {}) { }
+}
+/**
+ * Abstract base class for analyzing user end of turn.
+ *
+ * Defines the interface through abstract methods; subclasses implement the
+ * actual analysis.
+ */
+export class BaseTurnAnalyzer {
+    _initSampleRate;
+    _sampleRate = 0;
+    constructor(options = {}) {
+        this._initSampleRate = options.sampleRate ?? null;
+    }
+    /** The effective sample rate for audio processing. */
+    get sampleRate() {
+        return this._sampleRate;
+    }
+    /**
+     * Sets the sample rate for audio processing.
+     *
+     * If the initial sample rate was provided, it will use that; otherwise, it
+     * sets to the provided sample rate.
+     *
+     * @param sampleRate The sample rate to set.
+     */
+    setSampleRate(sampleRate) {
+        this._sampleRate = this._initSampleRate || sampleRate;
+    }
+    /**
+     * Update the VAD start trigger time.
+     *
+     * The turn analyzer may choose to change its buffer size depending on this
+     * value.
+     *
+     * @param vadStartSecs The number of seconds of voice activity before
+     *   triggering the user speaking event.
+     */
+    updateVadStartSecs(_vadStartSecs) { }
+    /** Cleanup the turn analyzer. */
+    async cleanup() { }
+}
+//# sourceMappingURL=base_turn_analyzer.js.map

package/dist/audio/turn/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/audio/turn/index.js

@@ -0,0 +1,8 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/turn/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

package/dist/audio/turn/smart_turn/_whisper_features.d.ts

@@ -0,0 +1,30 @@
+/** Number of feature frames produced for an 8 second input. */
+export declare const WHISPER_NUM_FRAMES = 800;
+/** Number of mel bins per feature frame. */
+export declare const WHISPER_NUM_MELS = 80;
+export interface ComputeWhisperLogMelFeaturesOptions {
+    /**
+     * If true, apply zero-mean unit-variance normalization to the waveform
+     * before computing the spectrogram. Matches the transformers
+     * `do_normalize=True` behavior. Defaults to true.
+     */
+    doNormalize?: boolean;
+}
+/**
+ * Compute Whisper-style log-mel features for Smart Turn v3.
+ *
+ * Replicates the output of
+ * `transformers.WhisperFeatureExtractor(chunk_length=8)(audio, sampling_rate=16000,
+ * padding="max_length", max_length=128000, truncation=True, do_normalize=...,
+ * return_tensors="np").input_features.squeeze(0)`.
+ *
+ * Assumes the caller has already padded or truncated the input to exactly
+ * 128000 samples (8 seconds at 16 kHz); shorter inputs are zero-padded at the
+ * end, longer inputs are truncated to the leading window.
+ *
+ * @param audio One-dimensional float audio at 16 kHz.
+ * @returns Float32Array holding a row-major `(80, 800)` matrix of log-mel
+ *   features in roughly the `[-1, 1]` range.
+ */
+export declare function computeWhisperLogMelFeatures(audio: Float32Array | ArrayLike<number>, options?: ComputeWhisperLogMelFeaturesOptions): Float32Array;
+//# sourceMappingURL=_whisper_features.d.ts.map

package/dist/audio/turn/smart_turn/_whisper_features.js

@@ -0,0 +1,225 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/turn/smart_turn/_whisper_features.py
+//
+// Portions derived from Hugging Face Transformers
+// (src/transformers/models/whisper/feature_extraction_whisper.py and
+// src/transformers/audio_utils.py):
+//
+//   Copyright 2022 The HuggingFace Inc. team.
+//   Copyright 2023 The HuggingFace Inc. team and the librosa & torchaudio authors.
+//
+//   Licensed under the Apache License, Version 2.0
+//   (https://www.apache.org/licenses/LICENSE-2.0). Modified by Daily.
+/**
+ * Dependency-free Whisper-style log-mel feature extraction for Smart Turn v3.
+ *
+ * Vendored from `transformers.WhisperFeatureExtractor` (upstream uses numpy;
+ * this port uses typed arrays) so Smart Turn v3 can compute features without
+ * the `transformers` package. The math mirrors
+ * `transformers.models.whisper.feature_extraction_whisper` and
+ * `transformers.audio_utils` (Apache-2.0 licensed).
+ */
+const N_FFT = 400;
+const HOP_LENGTH = 160;
+const N_MELS = 80;
+const SAMPLING_RATE = 16000;
+const MEL_FLOOR = 1e-10;
+const NORM_VARIANCE_EPS = 1e-7;
+/** Number of feature frames produced for an 8 second input. */
+export const WHISPER_NUM_FRAMES = 800;
+/** Number of mel bins per feature frame. */
+export const WHISPER_NUM_MELS = N_MELS;
+/** Convert a frequency in hertz to mels using the Slaney scale. */
+function hertzToMelSlaney(freq) {
+    const minLogHertz = 1000.0;
+    const minLogMel = 15.0;
+    const logstep = 27.0 / Math.log(6.4);
+    if (freq >= minLogHertz) {
+        return minLogMel + Math.log(freq / minLogHertz) * logstep;
+    }
+    return (3.0 * freq) / 200.0;
+}
+/** Convert a frequency in mels to hertz using the Slaney scale. */
+function melToHertzSlaney(mels) {
+    const minLogHertz = 1000.0;
+    const minLogMel = 15.0;
+    const logstep = Math.log(6.4) / 27.0;
+    if (mels >= minLogMel) {
+        return minLogHertz * Math.exp(logstep * (mels - minLogMel));
+    }
+    return (200.0 * mels) / 3.0;
+}
+/** numpy.linspace(start, stop, num). */
+function linspace(start, stop, num) {
+    const out = new Float64Array(num);
+    const step = (stop - start) / (num - 1);
+    for (let i = 0; i < num; i++)
+        out[i] = start + i * step;
+    if (num > 1)
+        out[num - 1] = stop;
+    return out;
+}
+/**
+ * Build a Slaney-normalized triangular mel filterbank.
+ *
+ * Returns a row-major matrix of shape `(numFrequencyBins, numMelFilters)`
+ * that projects a power spectrogram onto the mel scale.
+ */
+function buildMelFilterbank(numFrequencyBins, numMelFilters, minFrequency, maxFrequency, samplingRate) {
+    const melMin = hertzToMelSlaney(minFrequency);
+    const melMax = hertzToMelSlaney(maxFrequency);
+    const melFreqs = linspace(melMin, melMax, numMelFilters + 2);
+    const filterFreqs = melFreqs.map(melToHertzSlaney);
+    const fftFreqs = linspace(0, Math.floor(samplingRate / 2), numFrequencyBins);
+    const filters = new Float64Array(numFrequencyBins * numMelFilters);
+    for (let k = 0; k < numFrequencyBins; k++) {
+        for (let m = 0; m < numMelFilters; m++) {
+            const f = fftFreqs[k];
+            const lower = filterFreqs[m];
+            const center = filterFreqs[m + 1];
+            const upper = filterFreqs[m + 2];
+            const downSlope = -(lower - f) / (center - lower);
+            const upSlope = (upper - f) / (upper - center);
+            let value = Math.max(0, Math.min(downSlope, upSlope));
+            // Slaney area normalization.
+            value *= 2.0 / (upper - lower);
+            filters[k * numMelFilters + m] = value;
+        }
+    }
+    return filters;
+}
+/** Return a periodic Hann window (matches torch.hann_window). */
+function periodicHannWindow(windowLength) {
+    const out = new Float64Array(windowLength);
+    for (let n = 0; n < windowLength; n++) {
+        out[n] = 0.5 - 0.5 * Math.cos((2 * Math.PI * n) / windowLength);
+    }
+    return out;
+}
+// Precomputed constants for the Whisper feature extractor defaults used by
+// Smart Turn v3.
+const HANN_WINDOW = periodicHannWindow(N_FFT);
+const NUM_FREQUENCY_BINS = Math.floor(N_FFT / 2) + 1;
+const MEL_FILTERS = buildMelFilterbank(NUM_FREQUENCY_BINS, N_MELS, 0.0, SAMPLING_RATE / 2.0, SAMPLING_RATE);
+const COS_TABLE = new Float64Array(N_FFT);
+const SIN_TABLE = new Float64Array(N_FFT);
+for (let i = 0; i < N_FFT; i++) {
+    COS_TABLE[i] = Math.cos((2 * Math.PI * i) / N_FFT);
+    SIN_TABLE[i] = Math.sin((2 * Math.PI * i) / N_FFT);
+}
+/**
+ * Compute a centered power spectrogram (reflect-padded, real DFT, |.|^2).
+ *
+ * Returns a row-major Float64Array of shape `(numFrequencyBins, numFrames)`.
+ */
+function powerSpectrogram(waveform, window, frameLength, hopLength) {
+    const pad = Math.floor(frameLength / 2);
+    const n = waveform.length;
+    // Reflect padding (numpy mode="reflect": the edge sample is not repeated).
+    const padded = new Float64Array(n + 2 * pad);
+    for (let i = 0; i < pad; i++) {
+        padded[pad - 1 - i] = waveform[i + 1];
+        padded[pad + n + i] = waveform[n - 2 - i];
+    }
+    for (let i = 0; i < n; i++)
+        padded[pad + i] = waveform[i];
+    const numFrames = Math.floor((padded.length - frameLength) / hopLength) + 1;
+    const numBins = Math.floor(frameLength / 2) + 1;
+    const out = new Float64Array(numBins * numFrames);
+    const frame = new Float64Array(frameLength);
+    for (let t = 0; t < numFrames; t++) {
+        const start = t * hopLength;
+        for (let i = 0; i < frameLength; i++) {
+            frame[i] = padded[start + i] * window[i];
+        }
+        for (let k = 0; k < numBins; k++) {
+            let re = 0;
+            let im = 0;
+            let idx = 0;
+            for (let i = 0; i < frameLength; i++) {
+                const v = frame[i];
+                re += v * COS_TABLE[idx];
+                im -= v * SIN_TABLE[idx];
+                idx += k;
+                if (idx >= frameLength)
+                    idx -= frameLength;
+            }
+            out[k * numFrames + t] = re * re + im * im;
+        }
+    }
+    return { data: out, numFrames };
+}
+/**
+ * Compute Whisper-style log-mel features for Smart Turn v3.
+ *
+ * Replicates the output of
+ * `transformers.WhisperFeatureExtractor(chunk_length=8)(audio, sampling_rate=16000,
+ * padding="max_length", max_length=128000, truncation=True, do_normalize=...,
+ * return_tensors="np").input_features.squeeze(0)`.
+ *
+ * Assumes the caller has already padded or truncated the input to exactly
+ * 128000 samples (8 seconds at 16 kHz); shorter inputs are zero-padded at the
+ * end, longer inputs are truncated to the leading window.
+ *
+ * @param audio One-dimensional float audio at 16 kHz.
+ * @returns Float32Array holding a row-major `(80, 800)` matrix of log-mel
+ *   features in roughly the `[-1, 1]` range.
+ */
+export function computeWhisperLogMelFeatures(audio, options = {}) {
+    const doNormalize = options.doNormalize ?? true;
+    const nSamples = SAMPLING_RATE * 8; // 128000
+    let x = new Float32Array(nSamples);
+    const len = Math.min(audio.length, nSamples);
+    for (let i = 0; i < len; i++)
+        x[i] = audio[i];
+    // Zero-mean unit-variance waveform normalization happens BEFORE the
+    // spectrogram, mirroring transformers' WhisperFeatureExtractor.__call__.
+    // Done in float32 to match the reference's precision (it normalizes the
+    // padded float32 buffer before the spectrogram promotes to float64).
+    if (doNormalize) {
+        let sum = 0;
+        for (let i = 0; i < nSamples; i++)
+            sum += x[i];
+        const mean = Math.fround(sum / nSamples);
+        let sq = 0;
+        for (let i = 0; i < nSamples; i++) {
+            const d = x[i] - mean;
+            sq += d * d;
+        }
+        const variance = Math.fround(sq / nSamples);
+        const denom = Math.fround(Math.sqrt(Math.fround(variance + NORM_VARIANCE_EPS)));
+        const normalized = new Float32Array(nSamples);
+        for (let i = 0; i < nSamples; i++) {
+            normalized[i] = Math.fround(x[i] - mean) / denom;
+        }
+        x = normalized;
+    }
+    const { data: magnitudes, numFrames } = powerSpectrogram(x, HANN_WINDOW, N_FFT, HOP_LENGTH);
+    // mel_spec = max(MEL_FLOOR, MEL_FILTERS.T @ magnitudes), then log10; the
+    // trailing frame is dropped, matching the reference.
+    const outFrames = numFrames - 1;
+    const logSpec = new Float64Array(N_MELS * outFrames);
+    let maxValue = Number.NEGATIVE_INFINITY;
+    for (let m = 0; m < N_MELS; m++) {
+        for (let t = 0; t < outFrames; t++) {
+            let acc = 0;
+            for (let k = 0; k < NUM_FREQUENCY_BINS; k++) {
+                acc += MEL_FILTERS[k * N_MELS + m] * magnitudes[k * numFrames + t];
+            }
+            const value = Math.log10(Math.max(MEL_FLOOR, acc));
+            logSpec[m * outFrames + t] = value;
+            if (value > maxValue)
+                maxValue = value;
+        }
+    }
+    const floor = maxValue - 8.0;
+    const out = new Float32Array(N_MELS * outFrames);
+    for (let i = 0; i < out.length; i++) {
+        out[i] = (Math.max(logSpec[i], floor) + 4.0) / 4.0;
+    }
+    return out;
+}
+//# sourceMappingURL=_whisper_features.js.map