@pipedog/core 0.0.0 → 0.1.0

package/dist/audio/krisp_instance.d.ts

@@ -0,0 +1,95 @@
+/** Version triple reported by the Krisp SDK. */
+export interface KrispSdkVersion {
+    major: number;
+    minor: number;
+    patch: number;
+}
+/** The subset of the `krisp_audio` SDK surface this module uses. */
+export interface KrispAudioSdk {
+    SamplingRate: Record<string, unknown>;
+    FrameDuration: Record<string, unknown>;
+    LogLevel: {
+        Off: unknown;
+    } & Record<string, unknown>;
+    getVersion(): KrispSdkVersion;
+    globalInit(...args: unknown[]): void;
+}
+/**
+ * Install the Krisp SDK binding used by this module.
+ *
+ * STUB SUPPORT: there is no bundled binding; until one is installed every
+ * SDK call throws.
+ */
+export declare function setKrispAudioSdk(sdk: KrispAudioSdk): void;
+export declare const KRISP_SAMPLE_RATES: ReadonlyMap<number, unknown>;
+export declare const KRISP_FRAME_DURATIONS: ReadonlyMap<number, unknown>;
+/**
+ * Convert integer sample rate to Krisp SDK enum value.
+ *
+ * @param sampleRate Sample rate in Hz (e.g., 16000, 24000, 48000).
+ * @returns Corresponding Krisp SDK SampleRate enum value.
+ * @throws Error if the sample rate is not supported by Krisp SDK.
+ */
+export declare function intToKrispSampleRate(sampleRate: number): unknown;
+/**
+ * Convert integer frame duration to Krisp SDK enum value.
+ *
+ * @param frameDurationMs Frame duration in milliseconds (e.g., 10, 20, 30).
+ * @returns Corresponding Krisp SDK FrameDuration enum value.
+ * @throws Error if the frame duration is not supported by Krisp SDK.
+ */
+export declare function intToKrispFrameDuration(frameDurationMs: number): unknown;
+/** Whether the installed krisp_audio build uses nanobind bindings (>= 1.11.0). */
+export declare function krispSdkUsesNanobindBindings(): boolean;
+/**
+ * Singleton manager for Krisp VIVA SDK with reference counting.
+ *
+ * The SDK's global state is shared by every Krisp session in the process, so
+ * it is initialized once, on first use, and left up for the life of the
+ * process: destroying it while any session is still alive leaves that session
+ * reading freed memory, and there is no point in the process where every
+ * session is known to be gone. The reference count tracks how many components
+ * hold the SDK; it does not decide when to tear it down.
+ *
+ * (Upstream guards the state with a threading lock; JavaScript runs these
+ * synchronous methods atomically, so no lock is needed.)
+ */
+export declare class KrispVivaSDKManager {
+    protected static _initialized: boolean;
+    protected static _referenceCount: number;
+    /** Callback for Krisp SDK licensing errors. */
+    protected static _licenseCallback(error: unknown, errorMessage: unknown): void;
+    /** Callback for Krisp SDK logging. */
+    protected static _logCallback(logMessage: unknown, logLevel: unknown): void;
+    /**
+     * Acquire a reference to the SDK (initializes if needed).
+     *
+     * Call this before creating Krisp sessions.
+     *
+     * @param apiKey Krisp SDK API key. If empty, falls back to the
+     *   KRISP_VIVA_API_KEY environment variable. Only the key of the caller that
+     *   initializes the SDK is used.
+     * @throws If SDK initialization fails (propagated from krisp_audio).
+     */
+    static acquire(apiKey?: string): void;
+    /**
+     * Release a reference to the SDK.
+     *
+     * Call this once the caller's Krisp sessions are gone. Releasing the last
+     * reference does not tear the SDK down; see the class docs.
+     */
+    static release(): void;
+    /**
+     * Get the current reference count.
+     *
+     * @returns Current number of active references to the SDK.
+     */
+    static getReferenceCount(): number;
+    /**
+     * Check if the SDK is currently initialized.
+     *
+     * @returns True if SDK is initialized, false otherwise.
+     */
+    static isInitialized(): boolean;
+}
+//# sourceMappingURL=krisp_instance.d.ts.map

package/dist/audio/krisp_instance.js

@@ -0,0 +1,229 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/krisp_instance.py
+/**
+ * Krisp Instance manager for pipecat audio.
+ *
+ * PORTING NOTE: the Krisp VIVA SDK (`krisp_audio`) has no edge-compatible
+ * JavaScript binding. The module's logic is ported against the
+ * `KrispAudioSdk` interface below, but the default SDK is a stub whose calls
+ * throw "not ported yet". A runtime-specific package can provide the real
+ * binding with `setKrispAudioSdk()`.
+ */
+import { logger } from "../utils/logger.js";
+function notPorted() {
+    throw new Error("krisp_audio is not ported yet");
+}
+// Placeholder SDK: the enum members are their own names, every call throws.
+const STUB_KRISP_AUDIO = {
+    SamplingRate: {
+        Sr8000Hz: "Sr8000Hz",
+        Sr16000Hz: "Sr16000Hz",
+        Sr24000Hz: "Sr24000Hz",
+        Sr32000Hz: "Sr32000Hz",
+        Sr44100Hz: "Sr44100Hz",
+        Sr48000Hz: "Sr48000Hz",
+    },
+    FrameDuration: {
+        Fd10ms: "Fd10ms",
+        Fd15ms: "Fd15ms",
+        Fd20ms: "Fd20ms",
+        Fd30ms: "Fd30ms",
+        Fd32ms: "Fd32ms",
+    },
+    LogLevel: { Off: "Off" },
+    getVersion: notPorted,
+    globalInit: notPorted,
+};
+let krispAudio = STUB_KRISP_AUDIO;
+// Krisp SDK SamplingRate enum member for each sample rate (Hz)
+const SAMPLE_RATE_MEMBERS = [
+    [8000, "Sr8000Hz"],
+    [16000, "Sr16000Hz"],
+    [24000, "Sr24000Hz"],
+    [32000, "Sr32000Hz"],
+    [44100, "Sr44100Hz"],
+    [48000, "Sr48000Hz"],
+];
+// Krisp SDK FrameDuration enum member for each frame duration (ms)
+const FRAME_DURATION_MEMBERS = [
+    [10, "Fd10ms"],
+    [15, "Fd15ms"],
+    [20, "Fd20ms"],
+    [30, "Fd30ms"],
+    [32, "Fd32ms"],
+];
+const sampleRates = new Map();
+const frameDurations = new Map();
+// Upstream builds these maps from the krisp_audio enums at import time; here
+// they are rebuilt whenever an SDK binding is installed.
+function buildKrispMaps() {
+    sampleRates.clear();
+    for (const [rate, member] of SAMPLE_RATE_MEMBERS) {
+        sampleRates.set(rate, krispAudio.SamplingRate[member]);
+    }
+    frameDurations.clear();
+    for (const [duration, member] of FRAME_DURATION_MEMBERS) {
+        frameDurations.set(duration, krispAudio.FrameDuration[member]);
+    }
+}
+buildKrispMaps();
+/**
+ * Install the Krisp SDK binding used by this module.
+ *
+ * STUB SUPPORT: there is no bundled binding; until one is installed every
+ * SDK call throws.
+ */
+export function setKrispAudioSdk(sdk) {
+    krispAudio = sdk;
+    buildKrispMaps();
+}
+// Mapping of sample rates (Hz) to Krisp SDK SamplingRate enums
+export const KRISP_SAMPLE_RATES = sampleRates;
+// Mapping of frame durations (ms) to Krisp SDK FrameDuration enums
+export const KRISP_FRAME_DURATIONS = frameDurations;
+/**
+ * Convert integer sample rate to Krisp SDK enum value.
+ *
+ * @param sampleRate Sample rate in Hz (e.g., 16000, 24000, 48000).
+ * @returns Corresponding Krisp SDK SampleRate enum value.
+ * @throws Error if the sample rate is not supported by Krisp SDK.
+ */
+export function intToKrispSampleRate(sampleRate) {
+    if (!KRISP_SAMPLE_RATES.has(sampleRate)) {
+        const supportedRates = [...KRISP_SAMPLE_RATES.keys()].sort((a, b) => a - b).join(", ");
+        throw new Error(`Unsupported sample rate: ${sampleRate} Hz. Supported rates: ${supportedRates} Hz`);
+    }
+    return KRISP_SAMPLE_RATES.get(sampleRate);
+}
+/**
+ * Convert integer frame duration to Krisp SDK enum value.
+ *
+ * @param frameDurationMs Frame duration in milliseconds (e.g., 10, 20, 30).
+ * @returns Corresponding Krisp SDK FrameDuration enum value.
+ * @throws Error if the frame duration is not supported by Krisp SDK.
+ */
+export function intToKrispFrameDuration(frameDurationMs) {
+    if (!KRISP_FRAME_DURATIONS.has(frameDurationMs)) {
+        const supportedDurations = [...KRISP_FRAME_DURATIONS.keys()].sort((a, b) => a - b).join(", ");
+        throw new Error(`Unsupported frame duration: ${frameDurationMs} ms. ` +
+            `Supported durations: ${supportedDurations} ms`);
+    }
+    return KRISP_FRAME_DURATIONS.get(frameDurationMs);
+}
+// Krisp SDK switched its Python bindings from pybind11 to nanobind starting in
+// 1.11.0. Among other things, this changed the noise suppression level
+// argument from int to float and requires writable (not just readable) ndarray
+// input.
+const NANOBIND_SDK_VERSION = [1, 11, 0];
+/** Whether the installed krisp_audio build uses nanobind bindings (>= 1.11.0). */
+export function krispSdkUsesNanobindBindings() {
+    const version = krispAudio.getVersion();
+    const v = [version.major, version.minor, version.patch];
+    for (let i = 0; i < 3; i++) {
+        if (v[i] !== NANOBIND_SDK_VERSION[i]) {
+            return v[i] > NANOBIND_SDK_VERSION[i];
+        }
+    }
+    return true;
+}
+function getEnv(name) {
+    return globalThis.process?.env?.[name];
+}
+/**
+ * Singleton manager for Krisp VIVA SDK with reference counting.
+ *
+ * The SDK's global state is shared by every Krisp session in the process, so
+ * it is initialized once, on first use, and left up for the life of the
+ * process: destroying it while any session is still alive leaves that session
+ * reading freed memory, and there is no point in the process where every
+ * session is known to be gone. The reference count tracks how many components
+ * hold the SDK; it does not decide when to tear it down.
+ *
+ * (Upstream guards the state with a threading lock; JavaScript runs these
+ * synchronous methods atomically, so no lock is needed.)
+ */
+export class KrispVivaSDKManager {
+    static _initialized = false;
+    static _referenceCount = 0;
+    /** Callback for Krisp SDK licensing errors. */
+    static _licenseCallback(error, errorMessage) {
+        logger.error(`Krisp licensing error: ${error} - ${errorMessage}`);
+    }
+    /** Callback for Krisp SDK logging. */
+    static _logCallback(logMessage, logLevel) {
+        logger.info(`[${logLevel}] ${logMessage}`);
+    }
+    /**
+     * Acquire a reference to the SDK (initializes if needed).
+     *
+     * Call this before creating Krisp sessions.
+     *
+     * @param apiKey Krisp SDK API key. If empty, falls back to the
+     *   KRISP_VIVA_API_KEY environment variable. Only the key of the caller that
+     *   initializes the SDK is used.
+     * @throws If SDK initialization fails (propagated from krisp_audio).
+     */
+    static acquire(apiKey = "") {
+        // Initialize the SDK once per process.
+        if (!KrispVivaSDKManager._initialized) {
+            try {
+                const key = apiKey || getEnv("KRISP_VIVA_API_KEY") || "";
+                try {
+                    // New SDK signature (requires license key)
+                    krispAudio.globalInit("", key, KrispVivaSDKManager._licenseCallback, KrispVivaSDKManager._logCallback, krispAudio.LogLevel.Off);
+                }
+                catch (e) {
+                    if (!(e instanceof TypeError))
+                        throw e;
+                    // Old SDK signature (no license key)
+                    krispAudio.globalInit("", KrispVivaSDKManager._logCallback, krispAudio.LogLevel.Off);
+                }
+            }
+            catch (e) {
+                logger.error(`Krisp SDK initialization failed: ${e}`);
+                throw e;
+            }
+            // Set before anything else that could fail: a flag that claims the SDK
+            // is down while it is up would let a second globalInit() re-seat global
+            // state that live sessions still point at.
+            KrispVivaSDKManager._initialized = true;
+            const SDK_VERSION = krispAudio.getVersion();
+            logger.debug(`Krisp Audio Python SDK initialized - Version: ` +
+                `${SDK_VERSION.major}.${SDK_VERSION.minor}.${SDK_VERSION.patch}`);
+        }
+        KrispVivaSDKManager._referenceCount += 1;
+        logger.debug(`Krisp SDK reference count: ${KrispVivaSDKManager._referenceCount}`);
+    }
+    /**
+     * Release a reference to the SDK.
+     *
+     * Call this once the caller's Krisp sessions are gone. Releasing the last
+     * reference does not tear the SDK down; see the class docs.
+     */
+    static release() {
+        if (KrispVivaSDKManager._referenceCount > 0) {
+            KrispVivaSDKManager._referenceCount -= 1;
+            logger.debug(`Krisp SDK reference count: ${KrispVivaSDKManager._referenceCount}`);
+        }
+    }
+    /**
+     * Get the current reference count.
+     *
+     * @returns Current number of active references to the SDK.
+     */
+    static getReferenceCount() {
+        return KrispVivaSDKManager._referenceCount;
+    }
+    /**
+     * Check if the SDK is currently initialized.
+     *
+     * @returns True if SDK is initialized, false otherwise.
+     */
+    static isInitialized() {
+        return KrispVivaSDKManager._initialized;
+    }
+}
+//# sourceMappingURL=krisp_instance.js.map

package/dist/audio/mixers/base_audio_mixer.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Base audio mixer for output transport integration.
+ *
+ * Provides the abstract base class for audio mixers that can be integrated
+ * with output transports to mix incoming audio with generated audio from the
+ * mixer.
+ */
+import type { MixerControlFrame } from "../../frames/frames.ts";
+/**
+ * Base class for output transport audio mixers.
+ *
+ * If an audio mixer is provided to the output transport it will be used to
+ * mix the audio frames coming into to the transport with the audio generated
+ * from the mixer. There are control frames to update mixer settings or to
+ * enable or disable the mixer at runtime.
+ */
+export declare abstract class BaseAudioMixer {
+    /**
+     * Initialize the mixer when the output transport starts.
+     *
+     * This will be called from the output transport when the transport is
+     * started. It can be used to initialize the mixer. The output transport
+     * sample rate is provided so the mixer can adjust to that sample rate.
+     *
+     * @param sampleRate The sample rate of the output transport in Hz.
+     */
+    abstract start(sampleRate: number): Promise<void>;
+    /**
+     * Clean up the mixer when the output transport stops.
+     *
+     * This will be called from the output transport when the transport is
+     * stopping.
+     */
+    abstract stop(): Promise<void>;
+    /**
+     * Process mixer control frames from the transport.
+     *
+     * This will be called when the output transport receives a
+     * MixerControlFrame.
+     *
+     * @param frame The mixer control frame to process.
+     */
+    abstract processFrame(frame: MixerControlFrame): Promise<void>;
+    /**
+     * Mix transport audio with mixer-generated audio.
+     *
+     * This is called with the audio that is about to be sent from the output
+     * transport and that should be mixed with the mixer audio if the mixer is
+     * enabled.
+     *
+     * @param audio Raw audio bytes from the transport to mix.
+     * @returns Mixed audio bytes combining transport and mixer audio.
+     */
+    abstract mix(audio: Uint8Array): Promise<Uint8Array>;
+}
+//# sourceMappingURL=base_audio_mixer.d.ts.map

package/dist/audio/mixers/base_audio_mixer.js

@@ -0,0 +1,16 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/mixers/base_audio_mixer.py
+/**
+ * Base class for output transport audio mixers.
+ *
+ * If an audio mixer is provided to the output transport it will be used to
+ * mix the audio frames coming into to the transport with the audio generated
+ * from the mixer. There are control frames to update mixer settings or to
+ * enable or disable the mixer at runtime.
+ */
+export class BaseAudioMixer {
+}
+//# sourceMappingURL=base_audio_mixer.js.map

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

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

package/dist/audio/mixers/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/mixers/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,46 @@
+/**
+ * Base audio resampler interface for Pipecat.
+ *
+ * Defines the abstract base class for audio resampling implementations,
+ * providing a common interface for converting audio between different sample
+ * rates.
+ */
+/** SOXR resampling quality presets, from fastest (QQ) to highest quality (VHQ). */
+export type SoxrQuality = "QQ" | "LQ" | "MQ" | "HQ" | "VHQ";
+/**
+ * Abstract base class for audio resampling implementations.
+ *
+ * Defines the interface that all audio resampling implementations must
+ * follow, providing a standardized way to convert audio data between
+ * different sample rates.
+ */
+export declare abstract class BaseAudioResampler {
+    /**
+     * Resamples the given audio data to a different sample rate.
+     *
+     * @param audio The audio data to be resampled, as raw bytes.
+     * @param inRate The original sample rate of the audio data in Hz.
+     * @param outRate The desired sample rate for the output audio in Hz.
+     * @returns The resampled audio data as raw bytes.
+     */
+    abstract resample(audio: Uint8Array, inRate: number, outRate: number): Promise<Uint8Array>;
+    /**
+     * Emit any audio still held internally and reset the resampler.
+     *
+     * Streaming resamplers keep recently seen input in their filter, so the
+     * tail of a stream is only emitted once more audio arrives. Call this at
+     * the end of a continuous stream to collect that tail and start clean.
+     *
+     * @returns The remaining resampled audio as raw bytes, empty if the
+     *   resampler holds nothing.
+     */
+    flush(): Promise<Uint8Array>;
+    /**
+     * Discard any audio still held internally and reset the resampler.
+     *
+     * Use this when a stream is abandoned rather than finished (e.g. after an
+     * interruption), so its leftover tail doesn't leak into the next stream.
+     */
+    reset(): Promise<void>;
+}
+//# sourceMappingURL=base_audio_resampler.d.ts.map

package/dist/audio/resamplers/base_audio_resampler.js

@@ -0,0 +1,35 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/base_audio_resampler.py
+/**
+ * Abstract base class for audio resampling implementations.
+ *
+ * Defines the interface that all audio resampling implementations must
+ * follow, providing a standardized way to convert audio data between
+ * different sample rates.
+ */
+export class BaseAudioResampler {
+    /**
+     * Emit any audio still held internally and reset the resampler.
+     *
+     * Streaming resamplers keep recently seen input in their filter, so the
+     * tail of a stream is only emitted once more audio arrives. Call this at
+     * the end of a continuous stream to collect that tail and start clean.
+     *
+     * @returns The remaining resampled audio as raw bytes, empty if the
+     *   resampler holds nothing.
+     */
+    async flush() {
+        return new Uint8Array(0);
+    }
+    /**
+     * Discard any audio still held internally and reset the resampler.
+     *
+     * Use this when a stream is abandoned rather than finished (e.g. after an
+     * interruption), so its leftover tail doesn't leak into the next stream.
+     */
+    async reset() { }
+}
+//# sourceMappingURL=base_audio_resampler.js.map

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

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

package/dist/audio/resamplers/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/resamplers/__init__.py
+// Upstream's `__init__.py` is empty: import the package's modules directly.
+export {};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,10 @@
+/**
+ * Resampy-based audio resampler implementation.
+ *
+ * PORTING NOTE: upstream's only export, `ResampyResampler`, is deprecated
+ * (since 1.2.0, removed in 2.0.0) and is not ported. Use
+ * `SOXRAudioResampler`, `createFileResampler()` or `createStreamResampler()`
+ * instead.
+ */
+export {};
+//# sourceMappingURL=resampy_resampler.d.ts.map

package/dist/audio/resamplers/resampy_resampler.js

@@ -0,0 +1,15 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/resampy_resampler.py
+/**
+ * Resampy-based audio resampler implementation.
+ *
+ * PORTING NOTE: upstream's only export, `ResampyResampler`, is deprecated
+ * (since 1.2.0, removed in 2.0.0) and is not ported. Use
+ * `SOXRAudioResampler`, `createFileResampler()` or `createStreamResampler()`
+ * instead.
+ */
+export {};
+//# sourceMappingURL=resampy_resampler.js.map

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

@@ -0,0 +1,54 @@
+/**
+ * SoX-based audio resampler implementation.
+ *
+ * Provides an audio resampler that uses the SoX resampler library for very
+ * high-quality audio sample rate conversion.
+ *
+ * When to use the SOXRAudioResampler:
+ * 1. For batch processing of complete audio files
+ * 2. When you have all the audio data available at once
+ *
+ * PORTING NOTE: libsoxr has no edge-compatible JavaScript equivalent yet. The
+ * class logic is ported, but the actual resampling (`soxrResample`) is a stub
+ * that throws "not ported yet". A WASM build of libsoxr, injected at runtime,
+ * is the intended replacement.
+ */
+import { BaseAudioResampler, type SoxrQuality } from "./base_audio_resampler.ts";
+/**
+ * Stand-in for `soxr.resample()`: resample a whole mono signal.
+ *
+ * STUB: libsoxr is not available in JavaScript yet; always throws.
+ *
+ * @internal
+ */
+export declare function soxrResample<T extends Int16Array | Float32Array>(_audio: T, _inRate: number, _outRate: number, _quality: SoxrQuality): T;
+export interface SOXRAudioResamplerOptions {
+    /**
+     * 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;
+}
+/**
+ * Audio resampler implementation using the SoX resampler library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ */
+export declare class SOXRAudioResampler extends BaseAudioResampler {
+    protected _quality: SoxrQuality;
+    constructor(options?: SOXRAudioResamplerOptions);
+    /**
+     * Resample audio data using SoX 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>;
+}
+/** View (or copy, if unaligned) 16-bit PCM bytes as samples. @internal */
+export declare function bytesToInt16(audio: Uint8Array): Int16Array;
+//# sourceMappingURL=soxr_resampler.d.ts.map

package/dist/audio/resamplers/soxr_resampler.js

@@ -0,0 +1,69 @@
+// Copyright (c) 2024-2026, Daily
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+//
+// Ported from pipecat: src/pipecat/audio/resamplers/soxr_resampler.py
+/**
+ * SoX-based audio resampler implementation.
+ *
+ * Provides an audio resampler that uses the SoX resampler library for very
+ * high-quality audio sample rate conversion.
+ *
+ * When to use the SOXRAudioResampler:
+ * 1. For batch processing of complete audio files
+ * 2. When you have all the audio data available at once
+ *
+ * PORTING NOTE: libsoxr has no edge-compatible JavaScript equivalent yet. The
+ * class logic is ported, but the actual resampling (`soxrResample`) is a stub
+ * that throws "not ported yet". A WASM build of libsoxr, injected at runtime,
+ * is the intended replacement.
+ */
+import { BaseAudioResampler } from "./base_audio_resampler.js";
+/**
+ * Stand-in for `soxr.resample()`: resample a whole mono signal.
+ *
+ * STUB: libsoxr is not available in JavaScript yet; always throws.
+ *
+ * @internal
+ */
+export function soxrResample(_audio, _inRate, _outRate, _quality) {
+    throw new Error("soxr resampling is not ported yet");
+}
+/**
+ * Audio resampler implementation using the SoX resampler library.
+ *
+ * Configured for very high quality (VHQ) resampling by default, providing
+ * excellent audio quality at the cost of additional computational overhead.
+ */
+export class SOXRAudioResampler extends BaseAudioResampler {
+    _quality;
+    constructor(options = {}) {
+        super();
+        this._quality = options.quality ?? "VHQ";
+    }
+    /**
+     * Resample audio data using SoX 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 audioData = bytesToInt16(audio);
+        const resampledAudio = soxrResample(audioData, inRate, outRate, this._quality);
+        return new Uint8Array(resampledAudio.buffer, resampledAudio.byteOffset, resampledAudio.byteLength);
+    }
+}
+/** View (or copy, if unaligned) 16-bit PCM bytes as samples. @internal */
+export function bytesToInt16(audio) {
+    const length = audio.length >> 1;
+    if (audio.byteOffset % 2 !== 0) {
+        return new Int16Array(audio.slice(0, length * 2).buffer);
+    }
+    return new Int16Array(audio.buffer, audio.byteOffset, length);
+}
+//# sourceMappingURL=soxr_resampler.js.map