@pipedog/resampler-wasm 0.0.0-stage → 0.1.0

package/dist/engine.d.ts

@@ -0,0 +1,138 @@
+/**
+ * Hand-written wrapper over the rubato resampler's WebAssembly exports.
+ *
+ * The module has no imports and a tiny C ABI (see `rust/src/lib.rs`), so
+ * there is no generated glue: we instantiate it, keep the exports, and copy
+ * PCM in and out of linear memory. Everything here is synchronous; only
+ * loading the module (`initResampler`) is async.
+ */
+/** Quality presets, same names as libsoxr's (QQ fastest .. VHQ best). */
+export type Quality = "QQ" | "LQ" | "MQ" | "HQ" | "VHQ";
+/** All presets, lowest quality first. */
+export declare const QUALITIES: readonly Quality[];
+export interface ResampleOptions {
+    /** Quality preset. Defaults to "VHQ" (as upstream's soxr resamplers). */
+    quality?: Quality;
+    /** Interleaved channel count, 1..8. Defaults to 1. */
+    channels?: number;
+}
+/** What a quality preset maps to in rubato (see the README for the table). */
+export interface QualityInfo {
+    quality: Quality;
+    sincLen: number;
+    oversampling: number;
+}
+interface Exports {
+    memory: WebAssembly.Memory;
+    rs_stream_new(inRate: number, outRate: number, channels: number, quality: number): number;
+    rs_stream_free(h: number): void;
+    rs_stream_input(h: number, n: number): number;
+    rs_stream_process(h: number, n: number): number;
+    rs_stream_flush(h: number): number;
+    rs_stream_output(h: number): number;
+    rs_stream_input_f32(h: number, n: number): number;
+    rs_stream_process_f32(h: number, n: number): number;
+    rs_stream_flush_f32(h: number): number;
+    rs_stream_output_f32(h: number): number;
+    rs_stream_reset(h: number): void;
+    rs_stream_delay(h: number): number;
+    rs_stream_cutoff(h: number): number;
+    rs_quality_sinc_len(q: number): number;
+    rs_quality_oversampling(q: number): number;
+}
+/**
+ * A stateful streaming resampler (one rubato instance in WASM memory).
+ *
+ * Accepts chunks of any size and keeps the filter history between them, so
+ * there are no clicks at chunk boundaries. Output is aligned with the input
+ * (the filter delay is trimmed), and `flush()` emits the tail so the stream's
+ * total output is round(totalInputFrames * outRate / inRate) frames.
+ *
+ * Call `destroy()` when done; a FinalizationRegistry frees forgotten streams
+ * eventually, but WASM memory is not reclaimed promptly by GC.
+ */
+export declare class RubatoStream {
+    #private;
+    readonly inRate: number;
+    readonly outRate: number;
+    readonly channels: number;
+    readonly quality: Quality;
+    /** @internal Use `RubatoEngine.createStream`. */
+    constructor(engine: RubatoEngine, x: Exports, inRate: number, outRate: number, opts: ResampleOptions);
+    /** Filter delay in output frames (already compensated for in the output). */
+    get delayFrames(): number;
+    /** Relative anti-aliasing cutoff (1.0 = input Nyquist; scaled when downsampling). */
+    get cutoff(): number;
+    /** Resample interleaved int16 samples. Returns a fresh array. */
+    processSamples(samples: Int16Array): Int16Array;
+    /** Resample interleaved float samples in [-1, 1] (unclipped). Returns a fresh array. */
+    processFloat32(samples: Float32Array): Float32Array;
+    /** Resample 16-bit little-endian PCM bytes. */
+    process(audio: Uint8Array): Uint8Array;
+    /** Emit the audio held in the filter as int16 samples, then reset. */
+    flushSamples(): Int16Array;
+    /** Emit the audio held in the filter as float samples, then reset. */
+    flushFloat32(): Float32Array;
+    /** Emit the audio held in the filter as PCM bytes, then reset. */
+    flush(): Uint8Array;
+    /** Discard the audio held in the filter and start a new stream. */
+    reset(): void;
+    /** Free the WASM-side state. The stream is unusable afterwards. */
+    destroy(): void;
+}
+/**
+ * The resampler engine: one instantiated WASM module. Cheap to share; all
+ * methods are synchronous.
+ */
+export declare class RubatoEngine {
+    #private;
+    constructor(instance: WebAssembly.Instance);
+    /** @internal */
+    _register(stream: RubatoStream, h: number, token: object): void;
+    /** @internal */
+    static _unregister(token: object): void;
+    /** Create a streaming resampler. */
+    createStream(inRate: number, outRate: number, opts?: ResampleOptions): RubatoStream;
+    /** One-shot resampling of interleaved int16 samples (whole clip, tail included). */
+    resampleSamples(samples: Int16Array, inRate: number, outRate: number, opts?: ResampleOptions): Int16Array;
+    /** One-shot resampling of interleaved float samples (whole clip, tail included). */
+    resampleFloat32(samples: Float32Array, inRate: number, outRate: number, opts?: ResampleOptions): Float32Array;
+    /**
+     * One-shot resampling of 16-bit little-endian PCM bytes. Returns the input
+     * unchanged when the rates are equal, like upstream.
+     */
+    resample(audio: Uint8Array, inRate: number, outRate: number, opts?: ResampleOptions): Uint8Array;
+    /** The rubato parameters behind a quality preset. */
+    qualityInfo(quality: Quality): QualityInfo;
+}
+/** Instantiate the engine from a compiled module (synchronous). */
+export declare function engineFromModule(module: WebAssembly.Module): RubatoEngine;
+/**
+ * Instantiate the engine from a module or raw bytes. Compiling from bytes is
+ * not allowed on Cloudflare Workers; use the `workerd` entry there.
+ */
+export declare function engineFromSource(source: WebAssembly.Module | BufferSource): Promise<RubatoEngine>;
+/** Mirrors python-soxr's `soxr.ResampleStream` (int16 or float32, by first use). */
+export interface SoxrCompatibleStream {
+    resampleChunk<T extends Int16Array | Float32Array>(chunk: T, last?: boolean): T;
+    clear(): void;
+    destroy(): void;
+}
+/**
+ * The shape core's `SOXRAudioResampler` / `SOXRStreamAudioResampler` delegate
+ * to: `resample` stands in for `soxr.resample()` and `createStream` for
+ * `soxr.ResampleStream(...)`.
+ */
+export interface SoxrCompatibleEngine {
+    resample<T extends Int16Array | Float32Array>(audio: T, inRate: number, outRate: number, quality: Quality): T;
+    createStream(options: {
+        inRate: number;
+        outRate: number;
+        numChannels: number;
+        quality: Quality;
+    }): SoxrCompatibleStream;
+}
+/** Wrap an engine in the soxr-shaped API core expects. */
+export declare function createSoxrCompatibleEngine(engine: RubatoEngine): SoxrCompatibleEngine;
+export {};
+//# sourceMappingURL=engine.d.ts.map

package/dist/engine.js

@@ -0,0 +1,275 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+/** All presets, lowest quality first. */
+export const QUALITIES = ["QQ", "LQ", "MQ", "HQ", "VHQ"];
+const EMPTY_BYTES = new Uint8Array(0);
+function qualityIndex(quality) {
+    const i = QUALITIES.indexOf(quality);
+    if (i < 0)
+        throw new Error(`unknown resampler quality: ${String(quality)}`);
+    return i;
+}
+/** View 16-bit PCM bytes as samples (copying when the offset is odd). */
+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);
+}
+function int16ToBytes(samples) {
+    return new Uint8Array(samples.buffer, samples.byteOffset, samples.byteLength);
+}
+/**
+ * A stateful streaming resampler (one rubato instance in WASM memory).
+ *
+ * Accepts chunks of any size and keeps the filter history between them, so
+ * there are no clicks at chunk boundaries. Output is aligned with the input
+ * (the filter delay is trimmed), and `flush()` emits the tail so the stream's
+ * total output is round(totalInputFrames * outRate / inRate) frames.
+ *
+ * Call `destroy()` when done; a FinalizationRegistry frees forgotten streams
+ * eventually, but WASM memory is not reclaimed promptly by GC.
+ */
+export class RubatoStream {
+    inRate;
+    outRate;
+    channels;
+    quality;
+    #x;
+    #h;
+    #token = {};
+    /** @internal Use `RubatoEngine.createStream`. */
+    constructor(engine, x, inRate, outRate, opts) {
+        this.inRate = inRate;
+        this.outRate = outRate;
+        this.channels = opts.channels ?? 1;
+        this.quality = opts.quality ?? "VHQ";
+        if (!Number.isInteger(inRate) || !Number.isInteger(outRate) || inRate <= 0 || outRate <= 0) {
+            throw new Error(`invalid sample rates: ${inRate}->${outRate}`);
+        }
+        if (!Number.isInteger(this.channels) || this.channels < 1 || this.channels > 8) {
+            throw new Error(`invalid channel count: ${this.channels}`);
+        }
+        this.#x = x;
+        this.#h = x.rs_stream_new(inRate, outRate, this.channels, qualityIndex(this.quality));
+        if (this.#h === 0)
+            throw new Error(`could not create resampler ${inRate}->${outRate}`);
+        engine._register(this, this.#h, this.#token);
+    }
+    #handle() {
+        if (this.#h === 0)
+            throw new Error("RubatoStream has been destroyed");
+        return this.#h;
+    }
+    /** Filter delay in output frames (already compensated for in the output). */
+    get delayFrames() {
+        return this.#x.rs_stream_delay(this.#handle());
+    }
+    /** Relative anti-aliasing cutoff (1.0 = input Nyquist; scaled when downsampling). */
+    get cutoff() {
+        return this.#x.rs_stream_cutoff(this.#handle());
+    }
+    /** Resample interleaved int16 samples. Returns a fresh array. */
+    processSamples(samples) {
+        const h = this.#handle();
+        const x = this.#x;
+        if (samples.length > 0) {
+            const ptr = x.rs_stream_input(h, samples.length);
+            new Int16Array(x.memory.buffer, ptr, samples.length).set(samples);
+        }
+        return this.#readI16(h, x.rs_stream_process(h, samples.length));
+    }
+    /** Resample interleaved float samples in [-1, 1] (unclipped). Returns a fresh array. */
+    processFloat32(samples) {
+        const h = this.#handle();
+        const x = this.#x;
+        if (samples.length > 0) {
+            const ptr = x.rs_stream_input_f32(h, samples.length);
+            new Float32Array(x.memory.buffer, ptr, samples.length).set(samples);
+        }
+        return this.#readF32(h, x.rs_stream_process_f32(h, samples.length));
+    }
+    /** Resample 16-bit little-endian PCM bytes. */
+    process(audio) {
+        const out = this.processSamples(bytesToInt16(audio));
+        return out.length === 0 ? EMPTY_BYTES : int16ToBytes(out);
+    }
+    /** Emit the audio held in the filter as int16 samples, then reset. */
+    flushSamples() {
+        const h = this.#handle();
+        return this.#readI16(h, this.#x.rs_stream_flush(h));
+    }
+    /** Emit the audio held in the filter as float samples, then reset. */
+    flushFloat32() {
+        const h = this.#handle();
+        return this.#readF32(h, this.#x.rs_stream_flush_f32(h));
+    }
+    /** Emit the audio held in the filter as PCM bytes, then reset. */
+    flush() {
+        const out = this.flushSamples();
+        return out.length === 0 ? EMPTY_BYTES : int16ToBytes(out);
+    }
+    /** Discard the audio held in the filter and start a new stream. */
+    reset() {
+        this.#x.rs_stream_reset(this.#handle());
+    }
+    /** Free the WASM-side state. The stream is unusable afterwards. */
+    destroy() {
+        if (this.#h === 0)
+            return;
+        RubatoEngine._unregister(this.#token);
+        this.#x.rs_stream_free(this.#h);
+        this.#h = 0;
+    }
+    #readI16(h, n) {
+        if (n < 0)
+            throw new Error("resampler failed");
+        if (n === 0)
+            return new Int16Array(0);
+        // Copy out: the view would be invalidated by the next call or a memory grow.
+        return new Int16Array(this.#x.memory.buffer, this.#x.rs_stream_output(h), n).slice();
+    }
+    #readF32(h, n) {
+        if (n < 0)
+            throw new Error("resampler failed");
+        if (n === 0)
+            return new Float32Array(0);
+        return new Float32Array(this.#x.memory.buffer, this.#x.rs_stream_output_f32(h), n).slice();
+    }
+}
+/**
+ * The resampler engine: one instantiated WASM module. Cheap to share; all
+ * methods are synchronous.
+ */
+export class RubatoEngine {
+    #x;
+    static #registry = typeof FinalizationRegistry === "function"
+        ? new FinalizationRegistry(({ x, h }) => x.rs_stream_free(h))
+        : null;
+    constructor(instance) {
+        this.#x = instance.exports;
+        if (typeof this.#x.rs_stream_new !== "function") {
+            throw new Error("not the @pipedog/resampler-wasm module");
+        }
+    }
+    /** @internal */
+    _register(stream, h, token) {
+        RubatoEngine.#registry?.register(stream, { x: this.#x, h }, token);
+    }
+    /** @internal */
+    static _unregister(token) {
+        RubatoEngine.#registry?.unregister(token);
+    }
+    /** Create a streaming resampler. */
+    createStream(inRate, outRate, opts = {}) {
+        return new RubatoStream(this, this.#x, inRate, outRate, opts);
+    }
+    /** One-shot resampling of interleaved int16 samples (whole clip, tail included). */
+    resampleSamples(samples, inRate, outRate, opts = {}) {
+        if (inRate === outRate)
+            return samples;
+        const stream = this.createStream(inRate, outRate, opts);
+        try {
+            const head = stream.processSamples(samples);
+            const tail = stream.flushSamples();
+            if (tail.length === 0)
+                return head;
+            const out = new Int16Array(head.length + tail.length);
+            out.set(head);
+            out.set(tail, head.length);
+            return out;
+        }
+        finally {
+            stream.destroy();
+        }
+    }
+    /** One-shot resampling of interleaved float samples (whole clip, tail included). */
+    resampleFloat32(samples, inRate, outRate, opts = {}) {
+        if (inRate === outRate)
+            return samples;
+        const stream = this.createStream(inRate, outRate, opts);
+        try {
+            const head = stream.processFloat32(samples);
+            const tail = stream.flushFloat32();
+            if (tail.length === 0)
+                return head;
+            const out = new Float32Array(head.length + tail.length);
+            out.set(head);
+            out.set(tail, head.length);
+            return out;
+        }
+        finally {
+            stream.destroy();
+        }
+    }
+    /**
+     * One-shot resampling of 16-bit little-endian PCM bytes. Returns the input
+     * unchanged when the rates are equal, like upstream.
+     */
+    resample(audio, inRate, outRate, opts = {}) {
+        if (inRate === outRate)
+            return audio;
+        return int16ToBytes(this.resampleSamples(bytesToInt16(audio), inRate, outRate, opts));
+    }
+    /** The rubato parameters behind a quality preset. */
+    qualityInfo(quality) {
+        const q = qualityIndex(quality);
+        return {
+            quality,
+            sincLen: this.#x.rs_quality_sinc_len(q),
+            oversampling: this.#x.rs_quality_oversampling(q),
+        };
+    }
+}
+/** Instantiate the engine from a compiled module (synchronous). */
+export function engineFromModule(module) {
+    return new RubatoEngine(new WebAssembly.Instance(module, {}));
+}
+/**
+ * Instantiate the engine from a module or raw bytes. Compiling from bytes is
+ * not allowed on Cloudflare Workers; use the `workerd` entry there.
+ */
+export async function engineFromSource(source) {
+    if (source instanceof WebAssembly.Module)
+        return engineFromModule(source);
+    const { instance } = await WebAssembly.instantiate(source, {});
+    return new RubatoEngine(instance);
+}
+/** Wrap an engine in the soxr-shaped API core expects. */
+export function createSoxrCompatibleEngine(engine) {
+    return {
+        resample(audio, inRate, outRate, quality) {
+            if (audio instanceof Float32Array)
+                return engine.resampleFloat32(audio, inRate, outRate, { quality });
+            return engine.resampleSamples(audio, inRate, outRate, { quality });
+        },
+        createStream({ inRate, outRate, numChannels, quality }) {
+            const stream = engine.createStream(inRate, outRate, { quality, channels: numChannels });
+            return {
+                resampleChunk(chunk, last = false) {
+                    if (chunk instanceof Float32Array) {
+                        const head = stream.processFloat32(chunk);
+                        if (!last)
+                            return head;
+                        const tail = stream.flushFloat32();
+                        const out = new Float32Array(head.length + tail.length);
+                        out.set(head);
+                        out.set(tail, head.length);
+                        return out;
+                    }
+                    const head = stream.processSamples(chunk);
+                    if (!last)
+                        return head;
+                    const tail = stream.flushSamples();
+                    const out = new Int16Array(head.length + tail.length);
+                    out.set(head);
+                    out.set(tail, head.length);
+                    return out;
+                },
+                clear: () => stream.reset(),
+                destroy: () => stream.destroy(),
+            };
+        },
+    };
+}
+//# sourceMappingURL=engine.js.map

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Default entry (Bun, Node >= 22, Deno, browsers via a bundler).
+ *
+ * `await initResampler()` once, then everything is synchronous:
+ *
+ * @example
+ * ```ts
+ * import { initResampler } from "@pipedog/resampler-wasm";
+ * const engine = await initResampler();
+ * const out = engine.resample(pcm16, 8000, 16000, { quality: "VHQ" });
+ * ```
+ *
+ * On Cloudflare Workers the package resolves to `workerd.ts` instead (the
+ * "workerd" export condition), which imports the .wasm as a module because
+ * workerd cannot compile WASM from bytes.
+ */
+import { type RubatoEngine } from "./engine.ts";
+export * from "./engine.ts";
+export type ResamplerSource = WebAssembly.Module | BufferSource | URL | Response;
+/**
+ * Load and instantiate the WASM resampler (idempotent). With no argument the
+ * bundled `wasm/resampler.wasm` is loaded next to this file. Passing a source
+ * replaces the shared engine.
+ */
+export declare function initResampler(source?: ResamplerSource): Promise<RubatoEngine>;
+/** The engine set up by `initResampler()`. Throws if it has not been awaited yet. */
+export declare function getResampler(): RubatoEngine;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,83 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+/**
+ * Default entry (Bun, Node >= 22, Deno, browsers via a bundler).
+ *
+ * `await initResampler()` once, then everything is synchronous:
+ *
+ * @example
+ * ```ts
+ * import { initResampler } from "@pipedog/resampler-wasm";
+ * const engine = await initResampler();
+ * const out = engine.resample(pcm16, 8000, 16000, { quality: "VHQ" });
+ * ```
+ *
+ * On Cloudflare Workers the package resolves to `workerd.ts` instead (the
+ * "workerd" export condition), which imports the .wasm as a module because
+ * workerd cannot compile WASM from bytes.
+ */
+import { engineFromSource } from "./engine.js";
+import { currentEngine, initOnce, setEngine } from "./state.js";
+export * from "./engine.js";
+// Resolved lazily: in a Worker bundle `import.meta.url` is not a valid base, so
+// building the URL at module load would crash any import of this entry there.
+function defaultWasmUrl() {
+    return new URL("../wasm/resampler.wasm", import.meta.url);
+}
+async function readUrl(url) {
+    if (url.protocol === "file:") {
+        // Bun and Deno fetch file: URLs; Node's fetch does not, so fall back to fs.
+        try {
+            const res = await fetch(url);
+            if (res.ok)
+                return await res.arrayBuffer();
+        }
+        catch {
+            // fall through to node:fs
+        }
+        // A variable specifier keeps bundlers (and type checkers without @types/node) out of it.
+        const specifier = "node:fs/promises";
+        const fs = (await import(__rewriteRelativeImportExtension(specifier)));
+        return (await fs.readFile(url));
+    }
+    const res = await fetch(url);
+    if (!res.ok)
+        throw new Error(`failed to fetch ${url.href}: ${res.status}`);
+    return await res.arrayBuffer();
+}
+async function load(source) {
+    if (source === undefined)
+        return engineFromSource(await readUrl(defaultWasmUrl()));
+    if (source instanceof URL)
+        return engineFromSource(await readUrl(source));
+    if (typeof Response !== "undefined" && source instanceof Response) {
+        return engineFromSource(await source.arrayBuffer());
+    }
+    return engineFromSource(source);
+}
+/**
+ * Load and instantiate the WASM resampler (idempotent). With no argument the
+ * bundled `wasm/resampler.wasm` is loaded next to this file. Passing a source
+ * replaces the shared engine.
+ */
+export async function initResampler(source) {
+    if (source !== undefined)
+        return setEngine(await load(source));
+    return initOnce(() => load(undefined));
+}
+/** The engine set up by `initResampler()`. Throws if it has not been awaited yet. */
+export function getResampler() {
+    const engine = currentEngine();
+    if (!engine)
+        throw new Error("call `await initResampler()` before using the resampler");
+    return engine;
+}
+//# sourceMappingURL=index.js.map

package/dist/state.d.ts

@@ -0,0 +1,9 @@
+/** The process-wide engine shared by both entry points. */
+import type { RubatoEngine } from "./engine.ts";
+/** @internal */
+export declare function setEngine(e: RubatoEngine): RubatoEngine;
+/** @internal */
+export declare function currentEngine(): RubatoEngine | null;
+/** @internal Run `load` once; concurrent callers share the promise. */
+export declare function initOnce(load: () => Promise<RubatoEngine>): Promise<RubatoEngine>;
+//# sourceMappingURL=state.d.ts.map

package/dist/state.js

@@ -0,0 +1,24 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+let engine = null;
+let pending = null;
+/** @internal */
+export function setEngine(e) {
+    engine = e;
+    return e;
+}
+/** @internal */
+export function currentEngine() {
+    return engine;
+}
+/** @internal Run `load` once; concurrent callers share the promise. */
+export function initOnce(load) {
+    if (engine)
+        return Promise.resolve(engine);
+    pending ??= load().then(setEngine, (e) => {
+        pending = null;
+        throw e;
+    });
+    return pending;
+}
+//# sourceMappingURL=state.js.map

package/dist/workerd.d.ts

@@ -0,0 +1,8 @@
+import { type RubatoEngine } from "./engine.ts";
+export * from "./engine.ts";
+export type ResamplerSource = WebAssembly.Module | BufferSource | URL;
+/** Instantiate the resampler (idempotent). Only a `WebAssembly.Module` source works on workerd. */
+export declare function initResampler(source?: ResamplerSource): Promise<RubatoEngine>;
+/** The shared engine, instantiated from the bundled module on first use. */
+export declare function getResampler(): RubatoEngine;
+//# sourceMappingURL=workerd.d.ts.map

package/dist/workerd.js

@@ -0,0 +1,27 @@
+// Copyright (c) 2026, pipedog contributors
+// SPDX-License-Identifier: BSD-2-Clause
+/**
+ * Cloudflare Workers entry (the "workerd" export condition).
+ *
+ * workerd forbids compiling WebAssembly from bytes at runtime, so the module
+ * is imported as a pre-compiled `WebAssembly.Module` (wrangler's default rule
+ * for `.wasm`) and instantiated synchronously. `getResampler()` works without
+ * calling `initResampler()` first.
+ */
+import wasm from "../wasm/resampler.wasm";
+import { engineFromModule, engineFromSource } from "./engine.js";
+import { currentEngine, setEngine } from "./state.js";
+export * from "./engine.js";
+/** Instantiate the resampler (idempotent). Only a `WebAssembly.Module` source works on workerd. */
+export async function initResampler(source) {
+    if (source === undefined)
+        return getResampler();
+    if (source instanceof URL)
+        throw new Error("initResampler(URL) is not supported on workerd");
+    return setEngine(await engineFromSource(source));
+}
+/** The shared engine, instantiated from the bundled module on first use. */
+export function getResampler() {
+    return currentEngine() ?? setEngine(engineFromModule(wasm));
+}
+//# sourceMappingURL=workerd.js.map

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "@pipedog/resampler-wasm",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "High-quality PCM resampling (rubato sinc, compiled to WebAssembly) for pipedog: one-shot and streaming, soxr-style quality presets, runs on Bun, Node, Deno and Cloudflare Workers.",
+  "license": "BSD-2-Clause",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/polvallverdu/pipedog.git",
+    "directory": "packages/resampler-wasm"
+  },
+  "homepage": "https://github.com/polvallverdu/pipedog/tree/main/packages/resampler-wasm#readme",
+  "bugs": {
+    "url": "https://github.com/polvallverdu/pipedog/issues"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "workerd": "./dist/workerd.js",
+      "default": "./dist/index.js"
+    },
+    "./engine": {
+      "types": "./dist/engine.d.ts",
+      "default": "./dist/engine.js"
+    },
+    "./resampler.wasm": "./wasm/resampler.wasm"
+  },
+  "files": [
+    "dist",
+    "wasm",
+    "rust/Cargo.toml",
+    "rust/Cargo.lock",
+    "rust/src",
+    "LICENSE",
+    "NOTICE",
+    "THIRD_PARTY_LICENSES.md"
+  ],
+  "scripts": {
+    "build:wasm": "bun scripts/build-wasm.ts",
+    "test": "bun test",
+    "smoke:node": "node test/smoke/node.ts",
+    "smoke:deno": "deno run -A test/smoke/deno.ts",
+    "smoke:workerd": "bun test/smoke/workerd/run.ts"
+  },
+  "pipecat": {
+    "runtimes": [
+      "bun",
+      "node",
+      "deno",
+      "workerd"
+    ]
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts"
+}