@pipedog/core 0.0.0 → 0.2.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/engine.d.ts

@@ -0,0 +1,60 @@
+import type { SoxrQuality } from "./base_audio_resampler.ts";
+/** Options of a streaming resampler (as `soxr.ResampleStream(...)`). */
+export interface ResamplerStreamOptions {
+    inRate: number;
+    outRate: number;
+    numChannels: number;
+    quality: SoxrQuality;
+}
+/** A stateful streaming resampler; stands in for `soxr.ResampleStream`. */
+export interface ResamplerStream {
+    /**
+     * Resample a chunk of interleaved samples, keeping the filter history for
+     * the next chunk. With `last` the audio held in the filter is appended and
+     * the stream starts over.
+     */
+    resampleChunk<T extends Int16Array | Float32Array>(chunk: T, last?: boolean): T;
+    /** Discard the filter history (`soxr.ResampleStream.clear()`). */
+    clear(): void;
+    /** Free any native/WASM state. Optional. */
+    destroy?(): void;
+}
+/**
+ * A resampling engine. Structurally identical to what
+ * `createSoxrCompatibleEngine()` from `@pipedog/resampler-wasm` returns.
+ */
+export interface ResamplerEngine {
+    /** Stands in for `soxr.resample(audio, in_rate, out_rate, quality=...)` (mono). */
+    resample<T extends Int16Array | Float32Array>(audio: T, inRate: number, outRate: number, quality: SoxrQuality): T;
+    /** Stands in for `soxr.ResampleStream(in_rate=, out_rate=, num_channels=, quality=)`. */
+    createStream(options: ResamplerStreamOptions): ResamplerStream;
+}
+type EngineLoader = () => Promise<ResamplerEngine>;
+/**
+ * Install the engine every SOXR resampler uses from now on (streams already
+ * created keep theirs). Pass `null` to go back to the default
+ * (`@pipedog/resampler-wasm`, with the pure-TypeScript fallback).
+ */
+export declare function setResamplerEngine(engine: ResamplerEngine | null): void;
+/**
+ * The engine in use, loading the default one on first call.
+ *
+ * Resolves to the injected engine if there is one, else the WASM engine, else
+ * (after one warning) the pure-TypeScript fallback. Never rejects.
+ */
+export declare function getResamplerEngine(): Promise<ResamplerEngine>;
+/**
+ * The engine in use, without loading anything: the injected engine, else the
+ * default one if it has finished loading, else `null`. Lets synchronous code
+ * (e.g. `soxrResample`) use the engine once `getResamplerEngine()` resolved.
+ */
+export declare function getLoadedResamplerEngine(): ResamplerEngine | null;
+/**
+ * Replace how the default engine is loaded and forget the loaded one. For
+ * tests (e.g. simulating a WASM load failure).
+ *
+ * @internal
+ */
+export declare function _resetResamplerEngineForTests(loader?: EngineLoader): void;
+export {};
+//# sourceMappingURL=engine.d.ts.map

package/dist/audio/resamplers/engine.js

@@ -0,0 +1,89 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+/**
+ * The resampling engine behind `SOXRAudioResampler` and
+ * `SOXRStreamAudioResampler`.
+ *
+ * Upstream calls python-soxr (`soxr.resample()` and `soxr.ResampleStream`).
+ * Here those calls go through a small engine interface, so the actual
+ * implementation can be swapped:
+ *
+ * - By default the engine is `@pipedog/resampler-wasm` (rubato windowed sinc
+ *   compiled to WebAssembly), loaded lazily on first use. On Cloudflare
+ *   Workers the package's "workerd" export condition imports the `.wasm` as a
+ *   module (workerd forbids compiling WASM from bytes); elsewhere it is
+ *   fetched/read next to the package and instantiated asynchronously.
+ * - If the WASM engine cannot be loaded, core logs one warning and falls back
+ *   to a pure-TypeScript windowed-sinc engine (`sinc_engine.ts`).
+ * - Applications can inject their own engine (for example a native libsoxr
+ *   binding) with `setResamplerEngine()`.
+ *
+ * @example
+ * ```ts
+ * import { setResamplerEngine } from "@pipedog/core/audio/resamplers/engine";
+ * setResamplerEngine(myNativeSoxrEngine);
+ * ```
+ */
+import { logger } from "../../utils/logger.js";
+import { createSincResamplerEngine } from "./sinc_engine.js";
+/** Load `@pipedog/resampler-wasm` and wrap it in the soxr-shaped interface. */
+async function loadWasmEngine() {
+    const wasm = await import("@pipedog/resampler-wasm");
+    return wasm.createSoxrCompatibleEngine(await wasm.initResampler());
+}
+let injected = null;
+let loaded = null;
+let loading = null;
+let defaultLoader = loadWasmEngine;
+/**
+ * Install the engine every SOXR resampler uses from now on (streams already
+ * created keep theirs). Pass `null` to go back to the default
+ * (`@pipedog/resampler-wasm`, with the pure-TypeScript fallback).
+ */
+export function setResamplerEngine(engine) {
+    injected = engine;
+}
+/**
+ * The engine in use, loading the default one on first call.
+ *
+ * Resolves to the injected engine if there is one, else the WASM engine, else
+ * (after one warning) the pure-TypeScript fallback. Never rejects.
+ */
+export async function getResamplerEngine() {
+    if (injected)
+        return injected;
+    if (loaded)
+        return loaded;
+    loading ??= defaultLoader().then((engine) => {
+        loaded = engine;
+        return engine;
+    }, (e) => {
+        const reason = e instanceof Error ? e.message : String(e);
+        logger.warning(`Could not load the WASM resampler (@pipedog/resampler-wasm): ${reason}. ` +
+            "Falling back to the pure-TypeScript windowed-sinc resampler (lower quality, slower).");
+        loaded = createSincResamplerEngine();
+        return loaded;
+    });
+    return injected ?? (await loading);
+}
+/**
+ * The engine in use, without loading anything: the injected engine, else the
+ * default one if it has finished loading, else `null`. Lets synchronous code
+ * (e.g. `soxrResample`) use the engine once `getResamplerEngine()` resolved.
+ */
+export function getLoadedResamplerEngine() {
+    return injected ?? loaded;
+}
+/**
+ * Replace how the default engine is loaded and forget the loaded one. For
+ * tests (e.g. simulating a WASM load failure).
+ *
+ * @internal
+ */
+export function _resetResamplerEngineForTests(loader = loadWasmEngine) {
+    injected = null;
+    loaded = null;
+    loading = null;
+    defaultLoader = loader;
+}
+//# sourceMappingURL=engine.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