@pipedog/core 0.1.0 → 0.2.0

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/sinc_engine.d.ts

@@ -0,0 +1,10 @@
+import type { ResamplerEngine } from "./engine.ts";
+/**
+ * Create the pure-TypeScript windowed-sinc engine.
+ *
+ * Applications normally never call this: core falls back to it on its own
+ * when the WASM engine cannot load. It can also be installed explicitly with
+ * `setResamplerEngine(createSincResamplerEngine())`.
+ */
+export declare function createSincResamplerEngine(): ResamplerEngine;
+//# sourceMappingURL=sinc_engine.d.ts.map

package/dist/audio/resamplers/sinc_engine.js

@@ -0,0 +1,235 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+const SPECS = {
+    QQ: { passband: 0.8, attenuation: 50 },
+    LQ: { passband: 0.676, attenuation: 96 },
+    MQ: { passband: 0.91, attenuation: 96 },
+    HQ: { passband: 0.91, attenuation: 120 },
+    VHQ: { passband: 0.91, attenuation: 140 },
+};
+/** Kaiser window design (Kaiser's formulas for beta and length). */
+function design({ passband, attenuation }) {
+    const transition = 1 - passband; // in units of the lower Nyquist frequency
+    const cutoff = (1 + passband) / 2;
+    const beta = attenuation > 50
+        ? 0.1102 * (attenuation - 8.7)
+        : 0.5842 * (attenuation - 21) ** 0.4 + 0.07886 * (attenuation - 21);
+    // Total length in samples of the lower rate, then in zero crossings per side.
+    const length = (attenuation - 7.95) / (2.285 * Math.PI * transition);
+    const zeros = Math.ceil((length / 2) * cutoff);
+    return { zeros, cutoff, beta };
+}
+const PRESETS = Object.fromEntries(Object.entries(SPECS).map(([q, spec]) => [q, design(spec)]));
+/** Table points per zero crossing (linear interpolation error ~ -118 dB). */
+const OVERSAMPLE = 1024;
+/** Zeroth-order modified Bessel function of the first kind. */
+function besselI0(x) {
+    let sum = 1;
+    let term = 1;
+    const q = (x * x) / 4;
+    for (let k = 1; k < 200; k++) {
+        term *= q / (k * k);
+        sum += term;
+        if (term < sum * 1e-17)
+            break;
+    }
+    return sum;
+}
+const TABLES = new Map();
+/** sinc(x) * kaiser(x / zeros) for x in [0, zeros], OVERSAMPLE points per unit (plus guard). */
+function kernelTable(quality) {
+    let table = TABLES.get(quality);
+    if (table)
+        return table;
+    const { zeros, beta } = PRESETS[quality];
+    const n = zeros * OVERSAMPLE;
+    table = new Float32Array(n + 2);
+    const i0b = besselI0(beta);
+    for (let i = 0; i <= n; i++) {
+        const x = i / OVERSAMPLE;
+        const r = x / zeros;
+        const w = besselI0(beta * Math.sqrt(Math.max(0, 1 - r * r))) / i0b;
+        const s = i === 0 ? 1 : Math.sin(Math.PI * x) / (Math.PI * x);
+        table[i] = s * w;
+    }
+    TABLES.set(quality, table);
+    return table;
+}
+function checkRates(inRate, outRate) {
+    if (!(inRate > 0) || !(outRate > 0) || !Number.isFinite(inRate) || !Number.isFinite(outRate)) {
+        throw new Error(`invalid sample rates: ${inRate}->${outRate}`);
+    }
+}
+/** One channel of a streaming windowed-sinc resampler. */
+class SincChannel {
+    #step; // input samples per output sample
+    #scale; // 2 * fc (fc in cycles per input sample)
+    #halfWidth; // kernel half width in input samples
+    #table;
+    #tableScale; // table index per input-sample distance
+    /** Input history; #buf[0] is absolute input index #base. */
+    #buf = new Float64Array(256);
+    #len = 0;
+    #base = 0;
+    /** Total input samples seen and next output index (absolute). */
+    #totalIn = 0;
+    #nextOut = 0;
+    constructor(inRate, outRate, quality) {
+        const preset = PRESETS[quality];
+        this.#step = inRate / outRate;
+        const fc = 0.5 * Math.min(1, outRate / inRate) * preset.cutoff;
+        this.#scale = 2 * fc;
+        this.#halfWidth = preset.zeros / this.#scale;
+        this.#table = kernelTable(quality);
+        this.#tableScale = this.#scale * OVERSAMPLE;
+    }
+    #append(samples, start, stride, count) {
+        if (this.#len + count > this.#buf.length) {
+            const grown = new Float64Array(Math.max(this.#buf.length * 2, this.#len + count));
+            grown.set(this.#buf.subarray(0, this.#len));
+            this.#buf = grown;
+        }
+        for (let i = 0; i < count; i++) {
+            this.#buf[this.#len + i] = samples[start + i * stride];
+        }
+        this.#len += count;
+        this.#totalIn += count;
+    }
+    #sampleAt(t) {
+        const lo = Math.ceil(t - this.#halfWidth);
+        const hi = Math.floor(t + this.#halfWidth);
+        const buf = this.#buf;
+        const base = this.#base;
+        const table = this.#table;
+        const ts = this.#tableScale;
+        const tableMax = table.length - 2;
+        let acc = 0;
+        const from = Math.max(lo, base);
+        const to = Math.min(hi, base + this.#len - 1);
+        for (let n = from; n <= to; n++) {
+            const pos = Math.abs(t - n) * ts;
+            const i = pos | 0;
+            if (i > tableMax)
+                continue;
+            const frac = pos - i;
+            const k = table[i] + (table[i + 1] - table[i]) * frac;
+            acc += buf[n - base] * k;
+        }
+        return acc * this.#scale;
+    }
+    /** Number of outputs computable now (or, with `end`, the remaining outputs of the stream). */
+    #available(end) {
+        if (end) {
+            const total = Math.round(this.#totalIn / this.#step);
+            return Math.max(0, total - this.#nextOut);
+        }
+        // Output k needs inputs up to floor(k*step + halfWidth) < totalIn.
+        const last = Math.floor((this.#totalIn - 1 - this.#halfWidth) / this.#step);
+        return Math.max(0, last + 1 - this.#nextOut);
+    }
+    /** Feed `count` samples (strided) and write the outputs produced to `out` (strided). */
+    process(samples, start, stride, count, end) {
+        if (count > 0)
+            this.#append(samples, start, stride, count);
+        const n = this.#available(end);
+        const out = new Float64Array(n);
+        for (let i = 0; i < n; i++) {
+            out[i] = this.#sampleAt((this.#nextOut + i) * this.#step);
+        }
+        this.#nextOut += n;
+        if (end) {
+            this.clear();
+        }
+        else {
+            // Drop history no future output can reach.
+            const keepFrom = Math.floor(this.#nextOut * this.#step - this.#halfWidth) - 1;
+            const drop = Math.min(this.#len, keepFrom - this.#base);
+            if (drop > 0) {
+                this.#buf.copyWithin(0, drop, this.#len);
+                this.#len -= drop;
+                this.#base += drop;
+            }
+        }
+        return out;
+    }
+    clear() {
+        this.#len = 0;
+        this.#base = 0;
+        this.#totalIn = 0;
+        this.#nextOut = 0;
+    }
+}
+function toInt16(x) {
+    const r = Math.round(x);
+    return r > 32767 ? 32767 : r < -32768 ? -32768 : r;
+}
+/** A streaming windowed-sinc resampler over interleaved samples. */
+class SincStream {
+    #channels;
+    #numChannels;
+    /** Samples of an incomplete frame carried to the next call. */
+    #pending = [];
+    constructor(options) {
+        checkRates(options.inRate, options.outRate);
+        const numChannels = options.numChannels;
+        if (!Number.isInteger(numChannels) || numChannels < 1) {
+            throw new Error(`invalid channel count: ${numChannels}`);
+        }
+        this.#numChannels = numChannels;
+        this.#channels = Array.from({ length: numChannels }, () => new SincChannel(options.inRate, options.outRate, options.quality));
+    }
+    resampleChunk(chunk, last = false) {
+        const c = this.#numChannels;
+        let input = chunk;
+        if (this.#pending.length > 0) {
+            input = [...this.#pending, ...chunk];
+            this.#pending = [];
+        }
+        const frames = Math.floor(input.length / c);
+        const rest = input.length - frames * c;
+        if (rest > 0 && !last) {
+            this.#pending = Array.from({ length: rest }, (_, i) => input[frames * c + i]);
+        }
+        const outs = this.#channels.map((ch, i) => ch.process(input, i, c, frames, last));
+        const outFrames = outs[0]?.length ?? 0;
+        const isFloat = chunk instanceof Float32Array;
+        const out = isFloat ? new Float32Array(outFrames * c) : new Int16Array(outFrames * c);
+        for (let ch = 0; ch < c; ch++) {
+            const data = outs[ch];
+            for (let f = 0; f < outFrames; f++) {
+                const v = data[f];
+                out[f * c + ch] = isFloat ? v : toInt16(v);
+            }
+        }
+        if (last)
+            this.#pending = [];
+        return out;
+    }
+    clear() {
+        this.#pending = [];
+        for (const ch of this.#channels)
+            ch.clear();
+    }
+    destroy() { }
+}
+/**
+ * Create the pure-TypeScript windowed-sinc engine.
+ *
+ * Applications normally never call this: core falls back to it on its own
+ * when the WASM engine cannot load. It can also be installed explicitly with
+ * `setResamplerEngine(createSincResamplerEngine())`.
+ */
+export function createSincResamplerEngine() {
+    return {
+        resample(audio, inRate, outRate, quality) {
+            if (inRate === outRate)
+                return audio;
+            const stream = new SincStream({ inRate, outRate, numChannels: 1, quality });
+            return stream.resampleChunk(audio, true);
+        },
+        createStream(options) {
+            return new SincStream(options);
+        },
+    };
+}
+//# sourceMappingURL=sinc_engine.js.map

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

@@ -8,20 +8,24 @@
  * 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.
+ * PORTING NOTE: libsoxr is not used. `soxr.resample()` is replaced by the
+ * resampler engine from `engine.ts`: `@pipedog/resampler-wasm` (rubato
+ * windowed sinc in WebAssembly) by default, a pure-TypeScript windowed-sinc
+ * fallback if that cannot load, or whatever `setResamplerEngine()` installed.
+ * Output lengths follow soxr's; the samples differ slightly because the
+ * filters differ.
  */
 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.
+ * Synchronous, like soxr's: it uses the engine already loaded (or injected)
+ * and throws if there is none yet. `await getResamplerEngine()` first when
+ * calling it outside `SOXRAudioResampler.resample()`.
  *
  * @internal
  */
-export declare function soxrResample<T extends Int16Array | Float32Array>(_audio: T, _inRate: number, _outRate: number, _quality: SoxrQuality): T;
+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"

package/dist/audio/resamplers/soxr_resampler.js

@@ -13,21 +13,30 @@
  * 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.
+ * PORTING NOTE: libsoxr is not used. `soxr.resample()` is replaced by the
+ * resampler engine from `engine.ts`: `@pipedog/resampler-wasm` (rubato
+ * windowed sinc in WebAssembly) by default, a pure-TypeScript windowed-sinc
+ * fallback if that cannot load, or whatever `setResamplerEngine()` installed.
+ * Output lengths follow soxr's; the samples differ slightly because the
+ * filters differ.
  */
 import { BaseAudioResampler } from "./base_audio_resampler.js";
+import { getLoadedResamplerEngine, getResamplerEngine } from "./engine.js";
 /**
  * Stand-in for `soxr.resample()`: resample a whole mono signal.
  *
- * STUB: libsoxr is not available in JavaScript yet; always throws.
+ * Synchronous, like soxr's: it uses the engine already loaded (or injected)
+ * and throws if there is none yet. `await getResamplerEngine()` first when
+ * calling it outside `SOXRAudioResampler.resample()`.
  *
  * @internal
  */
-export function soxrResample(_audio, _inRate, _outRate, _quality) {
-    throw new Error("soxr resampling is not ported yet");
+export function soxrResample(audio, inRate, outRate, quality) {
+    const engine = getLoadedResamplerEngine();
+    if (!engine) {
+        throw new Error("no resampler engine loaded yet: `await getResamplerEngine()` (audio/resamplers/engine) first");
+    }
+    return engine.resample(audio, inRate, outRate, quality);
 }
 /**
  * Audio resampler implementation using the SoX resampler library.
@@ -53,6 +62,7 @@ export class SOXRAudioResampler extends BaseAudioResampler {
         if (inRate === outRate) {
             return audio;
         }
+        await getResamplerEngine();
         const audioData = bytesToInt16(audio);
         const resampledAudio = soxrResample(audioData, inRate, outRate, this._quality);
         return new Uint8Array(resampledAudio.buffer, resampledAudio.byteOffset, resampledAudio.byteLength);

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

@@ -1,20 +1,23 @@
 import { BaseAudioResampler, type SoxrQuality } from "./base_audio_resampler.ts";
+import { type ResamplerEngine, type ResamplerStream } from "./engine.ts";
 /**
- * Stand-in for `soxr.ResampleStream` (mono, int16).
- *
- * STUB: libsoxr is not available in JavaScript yet; constructing one throws.
+ * Stand-in for `soxr.ResampleStream` (mono, int16): a stream of the resampler
+ * engine (the loaded/injected one unless `engine` is given).
  *
  * @internal
  */
 export declare class SoxrResampleStream {
-    constructor(_options: {
+    protected _stream: ResamplerStream;
+    constructor(options: {
         inRate: number;
         outRate: number;
         numChannels: number;
         quality: SoxrQuality;
-    });
-    resampleChunk(_chunk: Int16Array, _last?: boolean): Int16Array;
+    }, engine?: ResamplerEngine | null);
+    resampleChunk(chunk: Int16Array, last?: boolean): Int16Array;
     clear(): void;
+    /** Free the engine's state (WASM memory). */
+    destroy(): void;
 }
 export interface SOXRStreamAudioResamplerOptions {
     /**

package/dist/audio/resamplers/soxr_stream_resampler.js

@@ -16,30 +16,40 @@
  * 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".
+ * PORTING NOTE: libsoxr is not used. `soxr.ResampleStream` is replaced by a
+ * stream from the resampler engine (`engine.ts`): `@pipedog/resampler-wasm`
+ * by default, a pure-TypeScript windowed-sinc fallback if that cannot load,
+ * or whatever `setResamplerEngine()` installed. `resample()` loads the engine
+ * on first use.
  */
 import { time } from "@pipedog/asyncio";
 import { BaseAudioResampler } from "./base_audio_resampler.js";
+import { getLoadedResamplerEngine, getResamplerEngine, } from "./engine.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.
+ * Stand-in for `soxr.ResampleStream` (mono, int16): a stream of the resampler
+ * engine (the loaded/injected one unless `engine` is given).
  *
  * @internal
  */
 export class SoxrResampleStream {
-    constructor(_options) {
-        throw new Error("soxr stream resampling is not ported yet");
+    _stream;
+    constructor(options, engine = getLoadedResamplerEngine()) {
+        if (!engine) {
+            throw new Error("no resampler engine loaded yet: `await getResamplerEngine()` (audio/resamplers/engine) first");
+        }
+        this._stream = engine.createStream(options);
     }
-    resampleChunk(_chunk, _last = false) {
-        throw new Error("soxr stream resampling is not ported yet");
+    resampleChunk(chunk, last = false) {
+        return this._stream.resampleChunk(chunk, last);
     }
     clear() {
-        throw new Error("soxr stream resampling is not ported yet");
+        this._stream.clear();
+    }
+    /** Free the engine's state (WASM memory). */
+    destroy() {
+        this._stream.destroy?.();
     }
 }
 function int16ToBytes(samples) {
@@ -115,6 +125,9 @@ export class SOXRStreamAudioResampler extends BaseAudioResampler {
         if (inRate === outRate) {
             return audio;
         }
+        if (this._soxrStream === null) {
+            await getResamplerEngine();
+        }
         const stream = this._maybeInitializeSoxStream(inRate, outRate);
         const audioData = bytesToInt16(audio);
         const resampledAudio = stream.resampleChunk(audioData);

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

@@ -11,18 +11,21 @@
  *
  * PORTING NOTES:
  * - There is no ONNX runtime in core. The analyzer takes an injected
- *   `createSession` (backed by `onnxruntime-node` on Bun/Node or
- *   `onnxruntime-web` on Workers); the default one is a stub that throws
- *   "not ported yet".
- * - The model is not bundled; `smartTurnModelPath` defaults to the upstream
- *   file name and is handed to `createSession` as is.
- * - Resampling to 16 kHz uses the soxr stub, so pipelines must run at 16 kHz
- *   until a resampler is available.
+ *   `createSession`; `createLocalSmartTurnAnalyzerV3()` in
+ *   `@pipedog/audio-smart-turn` wires it to `@pipedog/onnx` (onnxruntime-node
+ *   or onnxruntime-web) and the model. Without one, the default factory throws.
+ * - The model is not in core; `smartTurnModelPath` defaults to the upstream
+ *   file name and is handed to `createSession` as is (`@pipedog/audio-smart-turn`
+ *   ships the file).
+ * - Resampling to 16 kHz uses the resampler engine (`audio/resamplers/engine`)
+ *   instead of soxr. `_predictEndpoint` makes sure it is loaded before the
+ *   (synchronous) `_resampleToModelRate` runs.
  * - `PIPECAT_SMART_TURN_LOG_DATA` WAV dumps need a filesystem, which core
  *   doesn't use; the dump is a stub that logs a warning.
  */
 import { envTruthy } from "../../../utils/env.js";
 import { logger } from "../../../utils/logger.js";
+import { getResamplerEngine } from "../../resamplers/engine.js";
 import { soxrResample } from "../../resamplers/soxr_resampler.js";
 import { computeWhisperLogMelFeatures, WHISPER_NUM_FRAMES, WHISPER_NUM_MELS, } from "./_whisper_features.js";
 import { BaseSmartTurn, } from "./base_smart_turn.js";
@@ -33,7 +36,8 @@ import { BaseSmartTurn, } from "./base_smart_turn.js";
  */
 export const MODEL_SAMPLE_RATE = 16000;
 const notPortedSessionFactory = async () => {
-    throw new Error("LocalSmartTurnAnalyzerV3: ONNX runtime is not ported yet; pass `createSession`");
+    throw new Error("LocalSmartTurnAnalyzerV3: core has no ONNX runtime; use createLocalSmartTurnAnalyzerV3() " +
+        "from @pipedog/audio-smart-turn, or pass `createSession`");
 };
 function truncateAudioToLastNSeconds(audioArray, nSeconds = 8, sampleRate = MODEL_SAMPLE_RATE) {
     // Truncate audio to last n seconds or pad with zeros to meet n seconds.
@@ -113,6 +117,10 @@ export class LocalSmartTurnAnalyzerV3 extends BaseSmartTurn {
         const audioForLogging = audioArray;
         const actualRate = this._sampleRate || MODEL_SAMPLE_RATE;
         // Resample to 16 kHz if the pipeline uses a different sample rate
+        if (actualRate !== MODEL_SAMPLE_RATE) {
+            // soxr is synchronous; our engine may still need loading.
+            await getResamplerEngine();
+        }
         audioArray = this._resampleToModelRate(audioArray);
         // Truncate to 8 seconds (keeping the end) or pad to 8 seconds
         audioArray = truncateAudioToLastNSeconds(audioArray, 8);

package/dist/audio/vad/vad_analyzer.d.ts

@@ -54,6 +54,7 @@ export interface VADAnalyzerOptions {
  * on every runtime we target, so the analysis runs inline.
  */
 export declare abstract class VADAnalyzer {
+    #private;
     protected _initSampleRate: number | null;
     protected _sampleRate: number;
     protected _params: VADParams;
@@ -85,10 +86,13 @@ export declare abstract class VADAnalyzer {
     /**
      * Calculate voice activity confidence for the given audio buffer.
      *
+     * May return a promise: JavaScript ONNX runtimes only run models
+     * asynchronously. Upstream calls this on the analyzer's model thread.
+     *
      * @param buffer Audio buffer to analyze.
      * @returns Voice confidence score between 0.0 and 1.0.
      */
-    abstract voiceConfidence(buffer: Uint8Array): number;
+    abstract voiceConfidence(buffer: Uint8Array): number | Promise<number>;
     /**
      * Set the sample rate for audio processing.
      *
@@ -113,8 +117,12 @@ export declare abstract class VADAnalyzer {
      * @returns Current VAD state after processing the buffer.
      */
     analyzeAudio(buffer: Uint8Array): Promise<VADState>;
-    /** Analyze audio buffer and return current VAD state. */
-    protected _runAnalyzer(buffer: Uint8Array): VADState;
+    /**
+     * Analyze audio buffer and return current VAD state.
+     *
+     * Synchronous when `voiceConfidence` is; otherwise returns a promise.
+     */
+    protected _runAnalyzer(buffer: Uint8Array): VADState | Promise<VADState>;
     /**
      * Release the analyzer's resources.
      *