@whereby.com/audio-denoiser 0.0.0-canary-20260522073902

package/LICENCE.md

@@ -0,0 +1,23 @@
+## MIT License
+
+Copyright (c) 2024 Whereby AS (https://www.whereby.com)
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,52 @@
+# `@whereby.com/audio-denoiser`
+
+Audio denoiser (noise suppression) for microphone streams.
+
+Wraps the input `MediaStream` in an `AudioWorklet` that runs an RNNoise-based
+WebAssembly model, returning a new `MediaStream` with the cleaned audio.
+Static assets (the WASM model and worklet script) are hosted on a CDN and
+loaded at runtime.
+
+## Installation
+
+```bash
+npm install @whereby.com/audio-denoiser
+```
+
+or
+
+```bash
+yarn add @whereby.com/audio-denoiser
+```
+
+or
+
+```bash
+pnpm add @whereby.com/audio-denoiser
+```
+
+## Usage
+
+```typescript
+import { applyAudioDenoiser, canUse } from "@whereby.com/audio-denoiser";
+
+if (canUse()) {
+    const { outputStream, stop } = await applyAudioDenoiser({
+        inputStream: micStream,
+        doCaptureException: (err, ctx) => reportError(err, ctx),
+    });
+
+    // hand `outputStream` to your RTC pipeline; call `stop()` when done
+}
+```
+
+`applyAudioDenoiser` also returns `audioContext` and `denoiserNode` for
+consumers that need to share the underlying `AudioContext` (e.g. wiring an
+audio analyzer onto the same node without creating a second source).
+
+## Development
+
+The static assets (WASM model + worklet script) are hosted on a CDN in
+production builds. To exercise the local copies during development, set the
+environment variable `REACT_APP_IS_DEV=true` before building. When unset (or
+`false`), the build references the CDN as in production.

package/dist/cdn/v0-0-0-canary-20260522073902-canary/assets/denoiser/processor.ext.js

@@ -0,0 +1,70 @@
+let instance;
+let heapFloat32;
+
+class DenoiserProcessor extends AudioWorkletProcessor {
+    constructor(options) {
+        super({
+            ...options,
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [1],
+        });
+
+        this.alive = true;
+
+        (async () => {
+            try {
+                if (!instance) {
+                    const wasmModule = (await WebAssembly.instantiate(options.processorOptions.wasmBuffer)).module;
+                    instance = new WebAssembly.Instance(wasmModule).exports;
+                    heapFloat32 = new Float32Array(instance.memory.buffer);
+                }
+                this.state = instance.newState();
+                this.active = true;
+                this.port.onmessage = ({ data: keepalive }) => {
+                    if (this.alive) {
+                        if (!keepalive) {
+                            this.active = false;
+                            this.alive = false;
+                            instance.deleteState(this.state);
+                            this.state = undefined;
+                        }
+                    }
+                };
+            } catch (ex) {
+                this.port.postMessage({ error: ex.toString() });
+            }
+        })();
+    }
+
+    process([input], [output]) {
+        if (this.active) {
+            if (!input.length) {
+                return true;
+            }
+            // ensure the state is truthy before proceeding, otherwise just passthrough audio
+            if (!this.state) {
+                try {
+                    output[0].set(input[0]);
+                } catch (_) {}
+                return true;
+            }
+
+            heapFloat32.set(input[0], instance.getInput(this.state) / 4);
+            const o = output[0];
+            const ptr4 = instance.pipe(this.state, o.length) / 4;
+            if (ptr4) o.set(heapFloat32.subarray(ptr4, ptr4 + o.length));
+            return true;
+        }
+        if (this.alive) {
+            // not yet loaded, or error initalizing wasm, so try to passthrough audio
+            try {
+                output[0].set(input[0]);
+            } catch (_) {}
+            return true;
+        }
+        return false; // we signal it is ok to destroy the processor
+    }
+}
+
+registerProcessor("denoiser", DenoiserProcessor);

package/dist/index.cjs

@@ -0,0 +1,181 @@
+'use strict';
+
+var media = require('@whereby.com/media');
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const CDN_BASE_URL = "https://cdn.srv.whereby.com/audio-denoiser/v0-0-0-canary-20260522073902-canary";
+const getAssetUrl = (path) => {
+    {
+        return `${CDN_BASE_URL}/${path}`;
+    }
+};
+const assetUrls = {
+    denoiser: {
+        wasm: getAssetUrl("assets/denoiser/model.ext.wasm") ,
+        processor: getAssetUrl("assets/denoiser/processor.ext.js") ,
+    },
+};
+
+const audioContexts = new Map();
+const AudioContextCtor = typeof AudioContext !== "undefined"
+    ? AudioContext
+    : globalThis.webkitAudioContext;
+function getAudioContext(name, options) {
+    var _a;
+    if (!AudioContextCtor) {
+        throw new Error("AudioContext is not supported in this environment");
+    }
+    const key = `${name}:${(_a = options === null || options === void 0 ? void 0 : options.sampleRate) !== null && _a !== void 0 ? _a : "default"}`;
+    let ctx = audioContexts.get(key);
+    if (!ctx) {
+        ctx = new AudioContextCtor(options);
+        audioContexts.set(key, ctx);
+    }
+    return ctx;
+}
+
+const getWasmUrl = () => __awaiter(void 0, void 0, void 0, function* () {
+    {
+        return assetUrls.denoiser.wasm;
+    }
+});
+const getProcessorUrl = () => __awaiter(void 0, void 0, void 0, function* () {
+    {
+        return assetUrls.denoiser.processor;
+    }
+});
+let wasmBufferPromise = null;
+const loadWasmBuffer = (doCaptureException) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!wasmBufferPromise) {
+        wasmBufferPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+            const url = yield getWasmUrl();
+            const response = yield fetch(url);
+            if (!response.ok) {
+                doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(new Error(`Failed to fetch denoiser model: ${response.status} ${response.statusText}`), { tags: { from: "audioDenoiser.loadWasmBuffer" } });
+            }
+            return response.arrayBuffer();
+        }))();
+    }
+    return wasmBufferPromise;
+});
+let workletRegistered = null;
+const ensureWorkletRegistered = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!workletRegistered)
+        workletRegistered = new WeakSet();
+    if (workletRegistered.has(context))
+        return;
+    const processorUrl = yield getProcessorUrl();
+    yield context.audioWorklet.addModule(processorUrl);
+    workletRegistered.add(context);
+});
+class Denoiser extends AudioWorkletNode {
+    constructor(context, wasmBuffer) {
+        super(context, "denoiser", {
+            channelCountMode: "explicit",
+            channelCount: 1,
+            channelInterpretation: "speakers",
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [1],
+            processorOptions: {
+                wasmBuffer,
+            },
+        });
+    }
+}
+const canUse = () => typeof AudioWorkletNode !== "undefined" && typeof AudioContext !== "undefined";
+const warmup = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield loadWasmBuffer();
+});
+const applyAudioDenoiser = (_a) => __awaiter(void 0, [_a], void 0, function* ({ inputStream, doCaptureException, }) {
+    const inputTrack = inputStream.getAudioTracks()[0];
+    const sampleRate = inputTrack === null || inputTrack === void 0 ? void 0 : inputTrack.getSettings().sampleRate;
+    const audioContext = getAudioContext("audiodenoiser", sampleRate ? { sampleRate } : undefined);
+    const destination = audioContext.createMediaStreamDestination();
+    const [wasmBuffer] = yield Promise.all([loadWasmBuffer(doCaptureException), ensureWorkletRegistered(audioContext)]);
+    const source = audioContext.createMediaStreamSource(inputStream);
+    const denoiserNode = new Denoiser(audioContext, wasmBuffer);
+    denoiserNode.port.onmessage = (event) => {
+        var _a;
+        if ((_a = event.data) === null || _a === void 0 ? void 0 : _a.error) {
+            doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(new Error(event.data.error), {
+                tags: { from: "audioDenoiser.onmessage" },
+                extra: { sampleRate },
+            });
+        }
+    };
+    denoiserNode.onprocessorerror = (errorEvent) => {
+        const event = errorEvent;
+        const error = new Error(`Denoiser processor error: ${event.error} - ${event.message}`);
+        doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(error, {
+            tags: { from: "audioDenoiser.onprocessorerror" },
+            extra: { sampleRate },
+        });
+    };
+    denoiserNode.connect(destination);
+    source.connect(denoiserNode);
+    const outputTrack = destination.stream.getAudioTracks()[0];
+    if (outputTrack && inputTrack) {
+        Object.defineProperty(outputTrack, "enabled", {
+            get() {
+                return inputTrack.enabled;
+            },
+            set(value) {
+                inputTrack.enabled = value;
+            },
+        });
+    }
+    if (outputTrack) {
+        media.trackAnnotations(outputTrack).isEffectTrack = true;
+    }
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        try {
+            denoiserNode.port.postMessage(false);
+            source.disconnect();
+            denoiserNode.disconnect();
+        }
+        catch (error) {
+            console.error("Error stopping audio denoiser", error);
+        }
+    };
+    return { outputStream: destination.stream, audioContext, denoiserNode, stop };
+});
+
+exports.applyAudioDenoiser = applyAudioDenoiser;
+exports.canUse = canUse;
+exports.warmup = warmup;

package/dist/index.d.cts

@@ -0,0 +1,21 @@
+type CaptureExceptionContext = {
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+};
+type CaptureExceptionFn = (err: Error, ctx?: CaptureExceptionContext) => void;
+type ApplyAudioDenoiserParams = {
+    inputStream: MediaStream;
+    doCaptureException?: CaptureExceptionFn;
+};
+type AudioDenoiserHandle = {
+    outputStream: MediaStream;
+    audioContext: AudioContext;
+    denoiserNode: AudioWorkletNode;
+    stop: () => void;
+};
+declare const canUse: () => boolean;
+declare const warmup: () => Promise<void>;
+declare const applyAudioDenoiser: ({ inputStream, doCaptureException, }: ApplyAudioDenoiserParams) => Promise<AudioDenoiserHandle>;
+
+export { applyAudioDenoiser, canUse, warmup };
+export type { ApplyAudioDenoiserParams, AudioDenoiserHandle, CaptureExceptionContext, CaptureExceptionFn };

package/dist/index.d.mts

@@ -0,0 +1,21 @@
+type CaptureExceptionContext = {
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+};
+type CaptureExceptionFn = (err: Error, ctx?: CaptureExceptionContext) => void;
+type ApplyAudioDenoiserParams = {
+    inputStream: MediaStream;
+    doCaptureException?: CaptureExceptionFn;
+};
+type AudioDenoiserHandle = {
+    outputStream: MediaStream;
+    audioContext: AudioContext;
+    denoiserNode: AudioWorkletNode;
+    stop: () => void;
+};
+declare const canUse: () => boolean;
+declare const warmup: () => Promise<void>;
+declare const applyAudioDenoiser: ({ inputStream, doCaptureException, }: ApplyAudioDenoiserParams) => Promise<AudioDenoiserHandle>;
+
+export { applyAudioDenoiser, canUse, warmup };
+export type { ApplyAudioDenoiserParams, AudioDenoiserHandle, CaptureExceptionContext, CaptureExceptionFn };

package/dist/index.d.ts

@@ -0,0 +1,21 @@
+type CaptureExceptionContext = {
+    tags?: Record<string, string>;
+    extra?: Record<string, unknown>;
+};
+type CaptureExceptionFn = (err: Error, ctx?: CaptureExceptionContext) => void;
+type ApplyAudioDenoiserParams = {
+    inputStream: MediaStream;
+    doCaptureException?: CaptureExceptionFn;
+};
+type AudioDenoiserHandle = {
+    outputStream: MediaStream;
+    audioContext: AudioContext;
+    denoiserNode: AudioWorkletNode;
+    stop: () => void;
+};
+declare const canUse: () => boolean;
+declare const warmup: () => Promise<void>;
+declare const applyAudioDenoiser: ({ inputStream, doCaptureException, }: ApplyAudioDenoiserParams) => Promise<AudioDenoiserHandle>;
+
+export { applyAudioDenoiser, canUse, warmup };
+export type { ApplyAudioDenoiserParams, AudioDenoiserHandle, CaptureExceptionContext, CaptureExceptionFn };

package/dist/index.mjs

@@ -0,0 +1,177 @@
+import { trackAnnotations } from '@whereby.com/media';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const CDN_BASE_URL = "https://cdn.srv.whereby.com/audio-denoiser/v0-0-0-canary-20260522073902-canary";
+const getAssetUrl = (path) => {
+    {
+        return `${CDN_BASE_URL}/${path}`;
+    }
+};
+const assetUrls = {
+    denoiser: {
+        wasm: getAssetUrl("assets/denoiser/model.ext.wasm") ,
+        processor: getAssetUrl("assets/denoiser/processor.ext.js") ,
+    },
+};
+
+const audioContexts = new Map();
+const AudioContextCtor = typeof AudioContext !== "undefined"
+    ? AudioContext
+    : globalThis.webkitAudioContext;
+function getAudioContext(name, options) {
+    var _a;
+    if (!AudioContextCtor) {
+        throw new Error("AudioContext is not supported in this environment");
+    }
+    const key = `${name}:${(_a = options === null || options === void 0 ? void 0 : options.sampleRate) !== null && _a !== void 0 ? _a : "default"}`;
+    let ctx = audioContexts.get(key);
+    if (!ctx) {
+        ctx = new AudioContextCtor(options);
+        audioContexts.set(key, ctx);
+    }
+    return ctx;
+}
+
+const getWasmUrl = () => __awaiter(void 0, void 0, void 0, function* () {
+    {
+        return assetUrls.denoiser.wasm;
+    }
+});
+const getProcessorUrl = () => __awaiter(void 0, void 0, void 0, function* () {
+    {
+        return assetUrls.denoiser.processor;
+    }
+});
+let wasmBufferPromise = null;
+const loadWasmBuffer = (doCaptureException) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!wasmBufferPromise) {
+        wasmBufferPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+            const url = yield getWasmUrl();
+            const response = yield fetch(url);
+            if (!response.ok) {
+                doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(new Error(`Failed to fetch denoiser model: ${response.status} ${response.statusText}`), { tags: { from: "audioDenoiser.loadWasmBuffer" } });
+            }
+            return response.arrayBuffer();
+        }))();
+    }
+    return wasmBufferPromise;
+});
+let workletRegistered = null;
+const ensureWorkletRegistered = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!workletRegistered)
+        workletRegistered = new WeakSet();
+    if (workletRegistered.has(context))
+        return;
+    const processorUrl = yield getProcessorUrl();
+    yield context.audioWorklet.addModule(processorUrl);
+    workletRegistered.add(context);
+});
+class Denoiser extends AudioWorkletNode {
+    constructor(context, wasmBuffer) {
+        super(context, "denoiser", {
+            channelCountMode: "explicit",
+            channelCount: 1,
+            channelInterpretation: "speakers",
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [1],
+            processorOptions: {
+                wasmBuffer,
+            },
+        });
+    }
+}
+const canUse = () => typeof AudioWorkletNode !== "undefined" && typeof AudioContext !== "undefined";
+const warmup = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield loadWasmBuffer();
+});
+const applyAudioDenoiser = (_a) => __awaiter(void 0, [_a], void 0, function* ({ inputStream, doCaptureException, }) {
+    const inputTrack = inputStream.getAudioTracks()[0];
+    const sampleRate = inputTrack === null || inputTrack === void 0 ? void 0 : inputTrack.getSettings().sampleRate;
+    const audioContext = getAudioContext("audiodenoiser", sampleRate ? { sampleRate } : undefined);
+    const destination = audioContext.createMediaStreamDestination();
+    const [wasmBuffer] = yield Promise.all([loadWasmBuffer(doCaptureException), ensureWorkletRegistered(audioContext)]);
+    const source = audioContext.createMediaStreamSource(inputStream);
+    const denoiserNode = new Denoiser(audioContext, wasmBuffer);
+    denoiserNode.port.onmessage = (event) => {
+        var _a;
+        if ((_a = event.data) === null || _a === void 0 ? void 0 : _a.error) {
+            doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(new Error(event.data.error), {
+                tags: { from: "audioDenoiser.onmessage" },
+                extra: { sampleRate },
+            });
+        }
+    };
+    denoiserNode.onprocessorerror = (errorEvent) => {
+        const event = errorEvent;
+        const error = new Error(`Denoiser processor error: ${event.error} - ${event.message}`);
+        doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(error, {
+            tags: { from: "audioDenoiser.onprocessorerror" },
+            extra: { sampleRate },
+        });
+    };
+    denoiserNode.connect(destination);
+    source.connect(denoiserNode);
+    const outputTrack = destination.stream.getAudioTracks()[0];
+    if (outputTrack && inputTrack) {
+        Object.defineProperty(outputTrack, "enabled", {
+            get() {
+                return inputTrack.enabled;
+            },
+            set(value) {
+                inputTrack.enabled = value;
+            },
+        });
+    }
+    if (outputTrack) {
+        trackAnnotations(outputTrack).isEffectTrack = true;
+    }
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        try {
+            denoiserNode.port.postMessage(false);
+            source.disconnect();
+            denoiserNode.disconnect();
+        }
+        catch (error) {
+            console.error("Error stopping audio denoiser", error);
+        }
+    };
+    return { outputStream: destination.stream, audioContext, denoiserNode, stop };
+});
+
+export { applyAudioDenoiser, canUse, warmup };

package/dist/legacy-esm.js

@@ -0,0 +1,177 @@
+import { trackAnnotations } from '@whereby.com/media';
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+const CDN_BASE_URL = "https://cdn.srv.whereby.com/audio-denoiser/v0-0-0-canary-20260522073902-canary";
+const getAssetUrl = (path) => {
+    {
+        return `${CDN_BASE_URL}/${path}`;
+    }
+};
+const assetUrls = {
+    denoiser: {
+        wasm: getAssetUrl("assets/denoiser/model.ext.wasm") ,
+        processor: getAssetUrl("assets/denoiser/processor.ext.js") ,
+    },
+};
+
+const audioContexts = new Map();
+const AudioContextCtor = typeof AudioContext !== "undefined"
+    ? AudioContext
+    : globalThis.webkitAudioContext;
+function getAudioContext(name, options) {
+    var _a;
+    if (!AudioContextCtor) {
+        throw new Error("AudioContext is not supported in this environment");
+    }
+    const key = `${name}:${(_a = options === null || options === void 0 ? void 0 : options.sampleRate) !== null && _a !== void 0 ? _a : "default"}`;
+    let ctx = audioContexts.get(key);
+    if (!ctx) {
+        ctx = new AudioContextCtor(options);
+        audioContexts.set(key, ctx);
+    }
+    return ctx;
+}
+
+const getWasmUrl = () => __awaiter(void 0, void 0, void 0, function* () {
+    {
+        return assetUrls.denoiser.wasm;
+    }
+});
+const getProcessorUrl = () => __awaiter(void 0, void 0, void 0, function* () {
+    {
+        return assetUrls.denoiser.processor;
+    }
+});
+let wasmBufferPromise = null;
+const loadWasmBuffer = (doCaptureException) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!wasmBufferPromise) {
+        wasmBufferPromise = (() => __awaiter(void 0, void 0, void 0, function* () {
+            const url = yield getWasmUrl();
+            const response = yield fetch(url);
+            if (!response.ok) {
+                doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(new Error(`Failed to fetch denoiser model: ${response.status} ${response.statusText}`), { tags: { from: "audioDenoiser.loadWasmBuffer" } });
+            }
+            return response.arrayBuffer();
+        }))();
+    }
+    return wasmBufferPromise;
+});
+let workletRegistered = null;
+const ensureWorkletRegistered = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!workletRegistered)
+        workletRegistered = new WeakSet();
+    if (workletRegistered.has(context))
+        return;
+    const processorUrl = yield getProcessorUrl();
+    yield context.audioWorklet.addModule(processorUrl);
+    workletRegistered.add(context);
+});
+class Denoiser extends AudioWorkletNode {
+    constructor(context, wasmBuffer) {
+        super(context, "denoiser", {
+            channelCountMode: "explicit",
+            channelCount: 1,
+            channelInterpretation: "speakers",
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [1],
+            processorOptions: {
+                wasmBuffer,
+            },
+        });
+    }
+}
+const canUse = () => typeof AudioWorkletNode !== "undefined" && typeof AudioContext !== "undefined";
+const warmup = () => __awaiter(void 0, void 0, void 0, function* () {
+    yield loadWasmBuffer();
+});
+const applyAudioDenoiser = (_a) => __awaiter(void 0, [_a], void 0, function* ({ inputStream, doCaptureException, }) {
+    const inputTrack = inputStream.getAudioTracks()[0];
+    const sampleRate = inputTrack === null || inputTrack === void 0 ? void 0 : inputTrack.getSettings().sampleRate;
+    const audioContext = getAudioContext("audiodenoiser", sampleRate ? { sampleRate } : undefined);
+    const destination = audioContext.createMediaStreamDestination();
+    const [wasmBuffer] = yield Promise.all([loadWasmBuffer(doCaptureException), ensureWorkletRegistered(audioContext)]);
+    const source = audioContext.createMediaStreamSource(inputStream);
+    const denoiserNode = new Denoiser(audioContext, wasmBuffer);
+    denoiserNode.port.onmessage = (event) => {
+        var _a;
+        if ((_a = event.data) === null || _a === void 0 ? void 0 : _a.error) {
+            doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(new Error(event.data.error), {
+                tags: { from: "audioDenoiser.onmessage" },
+                extra: { sampleRate },
+            });
+        }
+    };
+    denoiserNode.onprocessorerror = (errorEvent) => {
+        const event = errorEvent;
+        const error = new Error(`Denoiser processor error: ${event.error} - ${event.message}`);
+        doCaptureException === null || doCaptureException === void 0 ? void 0 : doCaptureException(error, {
+            tags: { from: "audioDenoiser.onprocessorerror" },
+            extra: { sampleRate },
+        });
+    };
+    denoiserNode.connect(destination);
+    source.connect(denoiserNode);
+    const outputTrack = destination.stream.getAudioTracks()[0];
+    if (outputTrack && inputTrack) {
+        Object.defineProperty(outputTrack, "enabled", {
+            get() {
+                return inputTrack.enabled;
+            },
+            set(value) {
+                inputTrack.enabled = value;
+            },
+        });
+    }
+    if (outputTrack) {
+        trackAnnotations(outputTrack).isEffectTrack = true;
+    }
+    let stopped = false;
+    const stop = () => {
+        if (stopped)
+            return;
+        stopped = true;
+        try {
+            denoiserNode.port.postMessage(false);
+            source.disconnect();
+            denoiserNode.disconnect();
+        }
+        catch (error) {
+            console.error("Error stopping audio denoiser", error);
+        }
+    };
+    return { outputStream: destination.stream, audioContext, denoiserNode, stop };
+});
+
+export { applyAudioDenoiser, canUse, warmup };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@whereby.com/audio-denoiser",
+  "version": "0.0.0-canary-20260522073902",
+  "description": "Audio denoiser (noise suppression) for microphone streams",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist/**",
+    "!dist/cdn",
+    "!dist/assets"
+  ],
+  "devDependencies": {
+    "@rollup/plugin-url": "^8.0.2",
+    "rimraf": "^5.0.5",
+    "rollup": "^4.22.4",
+    "@whereby.com/eslint-config": "0.1.0",
+    "@whereby.com/jest-config": "0.1.0",
+    "@whereby.com/prettier-config": "0.1.0",
+    "@whereby.com/rollup-config": "0.1.1",
+    "@whereby.com/tsconfig": "0.1.0"
+  },
+  "dependencies": {
+    "@whereby.com/media": "8.3.2"
+  },
+  "prettier": "@whereby.com/prettier-config",
+  "scripts": {
+    "build": "rollup -c",
+    "build:dev": "REACT_APP_IS_DEV=true rollup -c",
+    "build:prod": "REACT_APP_IS_DEV=false rollup -c",
+    "clean": "rimraf dist",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix ."
+  }
+}