decibri 5.4.0 → 5.6.0

package/models/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,110 @@
+# Third-Party Notices
+
+This directory redistributes the model files listed below, together with the
+license notices they require. The notices ship inside the published npm and
+PyPI packages alongside the model weights they cover, so the attribution
+travels with the files. `README.md` beside this file documents each model's
+tensor interface.
+
+## Silero VAD
+
+- **Name:** Silero VAD
+- **Version:** v6.2
+- **License:** MIT
+- **Source:** https://github.com/snakers4/silero-vad (release `v6.2`)
+- **Files covered:** `silero_vad.onnx`
+
+### License Notice
+
+This model is a third-party artifact, not proprietary to decibri. It is
+distributed under the MIT License, reproduced in full below.
+
+```text
+MIT License
+
+Copyright (c) 2020-present Silero Team
+
+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.
+```
+
+## FastEnhancer
+
+- **Name:** FastEnhancer-T (tiny tier), VoiceBank-DEMAND checkpoint, waveform variant
+- **Version:** `onnx-vd-v1.0.0`
+- **License:** MIT
+- **Source:** https://github.com/aask1357/fastenhancer (release `onnx-vd-v1.0.0`)
+- **Files covered:** `fastenhancer_t.onnx`
+
+### License Notice
+
+This model is a third-party artifact, not proprietary to decibri. The model
+code and weights are distributed under the MIT License, reproduced in full
+below.
+
+```text
+MIT License
+
+Copyright (c) 2025 AHN Sung Hwan
+
+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.
+```
+
+### Training-Data Attribution
+
+The bundled checkpoint is trained on the VoiceBank-DEMAND noisy speech dataset,
+which pairs clean speech from the CSTR VCTK Corpus with noise from the DEMAND
+database. Each source dataset requires attribution:
+
+- **VoiceBank-DEMAND.** Valentini-Botinhao, Cassia. (2017). Noisy speech
+  database for training speech enhancement algorithms and TTS models, 2016
+  [sound]. University of Edinburgh, School of Informatics, Centre for Speech
+  Technology Research (CSTR). Licensed under Creative Commons Attribution 4.0
+  International (CC BY 4.0), https://creativecommons.org/licenses/by/4.0/.
+  https://doi.org/10.7488/ds/2117
+
+- **CSTR VCTK Corpus (version 0.92).** Yamagishi, Junichi; Veaux, Christophe;
+  MacDonald, Kirsten. (2019). CSTR VCTK Corpus: English Multi-speaker Corpus
+  for CSTR Voice Cloning Toolkit (version 0.92) [sound]. University of
+  Edinburgh, Centre for Speech Technology Research (CSTR). Licensed under the
+  Open Data Commons Attribution License (ODC-By) v1.0,
+  https://opendatacommons.org/licenses/by/1-0/.
+  https://doi.org/10.7488/ds/2645
+
+- **DEMAND.** Thiemann, Joachim; Ito, Nobutaka; Vincent, Emmanuel. (2013).
+  DEMAND: a collection of multi-channel recordings of acoustic noise in
+  diverse environments. Licensed under Creative Commons
+  Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0),
+  https://creativecommons.org/licenses/by-sa/3.0/.
+  https://doi.org/10.5281/zenodo.1227121

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "decibri",
-  "version": "5.4.0",
+  "version": "5.6.0",
   "description": "Cross-platform audio capture, playback, and processing for Node.js and browsers",
   "main": "src/decibri.js",
   "types": "src/decibri.d.ts",
@@ -72,10 +72,10 @@
     "MIGRATION.md"
   ],
   "optionalDependencies": {
-    "@decibri/decibri-win32-x64-msvc": "5.4.0",
-    "@decibri/decibri-darwin-arm64": "5.4.0",
-    "@decibri/decibri-linux-x64-gnu": "5.4.0",
-    "@decibri/decibri-linux-arm64-gnu": "5.4.0"
+    "@decibri/decibri-win32-x64-msvc": "5.6.0",
+    "@decibri/decibri-darwin-arm64": "5.6.0",
+    "@decibri/decibri-linux-x64-gnu": "5.6.0",
+    "@decibri/decibri-linux-arm64-gnu": "5.6.0"
   },
   "devDependencies": {
     "@napi-rs/cli": "^3.7.0"

package/src/browser/decibri-browser.js

@@ -6,13 +6,15 @@ const { WORKLET_SOURCE } = require('./worklet-inline.js');
 // Browser build version. Keep in sync with package.json on each release; the
 // browser bundle cannot read package.json at runtime the way the Node wrapper
 // does, so this is a maintained constant.
-const VERSION = '5.4.0';
+const VERSION = '5.6.0';
 
 /**
  * Browser microphone capture.
  *
  * Uses getUserMedia + AudioWorklet for real-time audio capture in browsers.
- * Emits 'data' events with Int16Array or Float32Array chunks.
+ * Emits 'data' events with Int16Array or Float32Array chunks holding
+ * framesPerBuffer frames of the delivered channel count, interleaved frame
+ * by frame.
  *
  * Ported from decibri-web decibri.ts. Logic identical, types removed.
  *
@@ -39,10 +41,10 @@ class Microphone extends Emitter {
 
     // ── VAD state ─────────────────────────────────────────────────────────
     // vad accepts false (disabled, default), the 'energy' shorthand, or a config
-    // object { model: 'energy', threshold?, holdoffMs? } to tune the policy. The
-    // browser runs energy VAD only; Silero needs ONNX Runtime, which is
-    // Node-only. The legacy vad: true form and the flat vadThreshold/vadHoldoff
-    // options are rejected with a migration error.
+    // object { model: 'energy', threshold?, holdoffMs?, source? } to tune the
+    // policy. The browser runs energy VAD only; Silero needs ONNX Runtime,
+    // which is Node-only. The legacy vad: true form and the flat
+    // vadThreshold/vadHoldoff options are rejected with a migration error.
     if (options.vadThreshold !== undefined || options.vadHoldoff !== undefined) {
       throw new TypeError(
         "vadThreshold and vadHoldoff are no longer supported. Pass them on the vad config object: vad: { model: 'energy', threshold: 0.01, holdoffMs: 300 }."
@@ -51,6 +53,7 @@ class Microphone extends Emitter {
     const vad = options.vad ?? false;
     let vadThreshold = 0.01;
     let vadHoldoff = 300;
+    let vadSource;
     if (vad === false) {
       this._vad = false;
     } else if (vad === true) {
@@ -82,11 +85,34 @@ class Microphone extends Emitter {
         }
         vadHoldoff = vad.holdoffMs;
       }
+      // source names the 0-based DELIVERED channel the detector reads, the
+      // position within the delivered interleaved frames after any
+      // channelMap; absent scores the frame average of every delivered
+      // channel. The checks and the messages are the node entry's. The
+      // delivered-count check runs only against a valid count; a count below
+      // one is reported as its own error below, exactly as on the node entry.
+      if (vad.source !== undefined) {
+        const source = vad.source;
+        if (typeof source !== 'number' || !Number.isInteger(source)) {
+          throw new TypeError('vad source must be an integer');
+        }
+        if (source < 0 || source > 65535) {
+          throw new RangeError('vad source must be between 0 and 65535');
+        }
+        const deliveredChannels = options.channels ?? 1;
+        if (deliveredChannels >= 1 && source >= deliveredChannels) {
+          throw new RangeError(
+            `the detector source names delivered channel ${source}; the delivered channel count is ${deliveredChannels}`
+          );
+        }
+        vadSource = source;
+      }
     } else {
-      throw new TypeError(`Invalid vad value: ${JSON.stringify(vad)}. Expected false, 'energy', or a config object { model, threshold, holdoffMs }.`);
+      throw new TypeError(`Invalid vad value: ${JSON.stringify(vad)}. Expected false, 'energy', or a config object { model, threshold, holdoffMs, source }.`);
     }
     this._vadThreshold = vadThreshold;
     this._vadHoldoff = vadHoldoff;
+    this._vadSource = vadSource;
     this._vadScore = 0;
     this._isSpeaking = false;
     this._silenceTimer = null;
@@ -94,6 +120,7 @@ class Microphone extends Emitter {
     // ── Options ───────────────────────────────────────────────────────────
     this._sampleRate = options.sampleRate ?? 16000;
     this._channels = options.channels ?? 1;
+    this._channelMap = options.channelMap;
     this._framesPerBuffer = options.framesPerBuffer ?? 1600;
     this._device = options.device;
     this._dtype = options.dtype ?? 'int16';
@@ -105,8 +132,44 @@ class Microphone extends Emitter {
     if (this._sampleRate < 1000 || this._sampleRate > 384000) {
       throw new RangeError('sample rate must be between 1000 and 384000');
     }
-    if (this._channels < 1 || this._channels > 32) {
-      throw new TypeError(`channels must be between 1 and 32, got ${this._channels}`);
+    // The number of channels delivered, interleaved frame by frame. Bounded
+    // below here; bounded above by the granted track alone, which answers
+    // when the stream starts. No fixed maximum exists on this path. The
+    // classes and the messages are the node entry's, so the same value is
+    // rejected the same way in both runtimes.
+    if (this._channels < 1) {
+      throw new RangeError('channels must be at least 1');
+    }
+    // An optional list of 0-based device channel indices, one per delivered
+    // channel: delivered channel j carries device channel channelMap[j].
+    // Entries may repeat and may appear in any order, so a map both selects
+    // and permutes. Absence derives the delivered channels from the count
+    // alone: 1 delivers the documented average of every granted channel, and
+    // the granted count delivers every granted channel in granted order. The
+    // checks here are shape-only (an array of integers that fit the channel
+    // count's width, with one entry per channel), the node entry's classes
+    // and messages; whether each entry exists on the track is checked when
+    // the stream starts, against the granted track's own report, because
+    // only the grant can say how many channels it carries. No fixed maximum
+    // exists on this path.
+    const channelMap = this._channelMap;
+    if (channelMap !== undefined) {
+      if (!Array.isArray(channelMap)) {
+        throw new TypeError(
+          `Invalid channelMap value: ${JSON.stringify(channelMap)}. Expected an array of 0-based device channel indices, such as [0].`
+        );
+      }
+      for (const entry of channelMap) {
+        if (typeof entry !== 'number' || !Number.isInteger(entry)) {
+          throw new TypeError('channelMap entries must be integers');
+        }
+        if (entry < 0 || entry > 65535) {
+          throw new RangeError('channelMap entries must be between 0 and 65535');
+        }
+      }
+      if (channelMap.length !== this._channels) {
+        throw new RangeError('channelMap must have exactly one entry per channel');
+      }
     }
     if (this._framesPerBuffer < 64 || this._framesPerBuffer > 65536) {
       throw new TypeError(`frames per buffer must be between 64 and 65536, got ${this._framesPerBuffer}`);
@@ -190,6 +253,9 @@ class Microphone extends Emitter {
   /**
    * Most recent VAD score: the normalized RMS of the last chunk in `'energy'`
    * mode, or 0 when VAD is disabled or before the first chunk is processed.
+   * A chunk carrying more than one channel is collapsed to the average of
+   * its channels, or to the one delivered channel a `vad: { source }` names,
+   * before the RMS, so the score reflects one channel's level.
    * @returns {number}
    */
   get vadScore() {
@@ -227,8 +293,14 @@ class Microphone extends Emitter {
     await this._audioContext.resume();
 
     // 2. Request microphone access
+    // The channel ask is 32 with ideal semantics, the count the Web Audio
+    // specification requires an implementation to support: the browser
+    // grants what it can serve and never rejects on this constraint. The
+    // granted track's own report, not this ask, is the authority for
+    // everything downstream, so a grant above the ask flows through
+    // unclamped.
     const audioConstraints = {
-      channelCount: this._channels,
+      channelCount: { ideal: 32 },
       echoCancellation: this._echoCancellation,
       noiseSuppression: this._noiseSuppression,
     };
@@ -246,6 +318,49 @@ class Microphone extends Emitter {
       throw error;
     }
 
+    // The granted track's report is the capture-side authority, as the
+    // resolved device's report is on the node path: the map's entries, or
+    // the unmapped count's derivation, are checked against it here, before
+    // the worklet is built, with the node entry's message for the same
+    // condition. Without a map, only two derivations have a single meaning:
+    // 1 delivers the average of every granted channel, and the granted count
+    // delivers every granted channel in granted order; a count above the
+    // grant does not exist to deliver, and a strict subset above one does
+    // not say which channels it means, so the map has to name them. A
+    // browser that omits channelCount from getSettings() defers the check to
+    // the worklet, which sees the true channel count of every block it
+    // processes. At one delivered channel with no map there is nothing to
+    // check: the average serves any granted count.
+    if (this._channelMap !== undefined || this._channels > 1) {
+      const track = this._stream.getAudioTracks()[0];
+      const settings = track && typeof track.getSettings === 'function' ? track.getSettings() : {};
+      const granted = settings.channelCount;
+      if (typeof granted === 'number') {
+        let message = null;
+        if (this._channelMap !== undefined) {
+          for (const entry of this._channelMap) {
+            if (entry >= granted) {
+              message = `the channel map names device channel ${entry}; the device reports ${granted} input channels`;
+              break;
+            }
+          }
+        } else if (this._channels > granted) {
+          message = `the input device does not support ${this._channels} delivered channels; it reports ${granted}`;
+        } else if (this._channels < granted) {
+          message = `a channel map is required to deliver ${this._channels} of the device's ${granted} input channels`;
+        }
+        if (message !== null) {
+          this._stream.getTracks().forEach(t => t.stop());
+          this._stream = null;
+          await this._audioContext.close();
+          this._audioContext = null;
+          const error = new Error(message);
+          this.emit('error', error);
+          throw error;
+        }
+      }
+    }
+
     // 3. Load AudioWorklet processor
     let blobUrl = null;
     const workletUrl = this._workletUrl ?? (blobUrl = this._createBlobUrl());
@@ -273,15 +388,31 @@ class Microphone extends Emitter {
         format: this._dtype,
         nativeSampleRate,
         targetSampleRate: this._sampleRate,
+        channels: this._channels,
+        channelMap: this._channelMap ?? null,
       },
     });
 
     // 5. Wire up data from worklet
     this._workletNode.port.onmessage = (event) => {
-      const buffer = event.data;
+      const data = event.data;
+
+      // The port carries raw ArrayBuffer chunks and tagged control objects,
+      // as on the output worklet's port. The one control message is the
+      // worklet's channel-map failure: surface it and stop, so a map naming
+      // a channel the track does not carry is never silent.
+      if (!(data instanceof ArrayBuffer)) {
+        if (data && data.type === 'error') {
+          const error = new Error(data.message);
+          this.emit('error', error);
+          this.stop();
+        }
+        return;
+      }
+
       const chunk = this._dtype === 'int16'
-        ? new Int16Array(buffer)
-        : new Float32Array(buffer);
+        ? new Int16Array(data)
+        : new Float32Array(data);
 
       this.emit('data', chunk);
 
@@ -346,11 +477,42 @@ class Microphone extends Emitter {
   }
 
   _computeRms(chunk) {
-    let sum = 0;
     const n = chunk.length;
     if (n === 0) return 0;
+    const channels = this._channels;
+    const isFloat = chunk instanceof Float32Array;
+
+    if (channels > 1) {
+      // Score one channel's level, as the node path's detector feed does:
+      // collapse each interleaved frame as the configured source directs,
+      // the engine's average (single-precision accumulation, f32 quotient)
+      // by default or one named delivered channel's sample alone, then take
+      // the RMS of the collapsed signal.
+      const frames = Math.floor(n / channels);
+      if (frames === 0) return 0;
+      const source = this._vadSource;
+      let sum = 0;
+      if (source !== undefined) {
+        for (let f = 0; f < frames; f++) {
+          const s = isFloat ? chunk[f * channels + source] : chunk[f * channels + source] / 32768;
+          sum += s * s;
+        }
+        return Math.sqrt(sum / frames);
+      }
+      for (let f = 0; f < frames; f++) {
+        let acc = 0;
+        for (let c = 0; c < channels; c++) {
+          const s = isFloat ? chunk[f * channels + c] : chunk[f * channels + c] / 32768;
+          acc = Math.fround(acc + s);
+        }
+        const mono = Math.fround(acc / channels);
+        sum += mono * mono;
+      }
+      return Math.sqrt(sum / frames);
+    }
 
-    if (chunk instanceof Float32Array) {
+    let sum = 0;
+    if (isFloat) {
       for (let i = 0; i < n; i++) sum += chunk[i] * chunk[i];
     } else {
       for (let i = 0; i < n; i++) {

package/src/browser/decibri-output-browser.js

@@ -104,6 +104,12 @@ class Speaker {
     if (this._sampleRate < 1000 || this._sampleRate > 384000) {
       throw new TypeError(`sample rate must be between 1000 and 384000, got ${this._sampleRate}`);
     }
+    // The 32 is the Web Audio specification's floor: an implementation is
+    // required to support up to 32 channels and the specification says nothing
+    // above that, so 32 is what a browser can be relied on to accept. The
+    // native surface bounds output channels below only and leaves the maximum
+    // to the device; the two differ deliberately, because they are answering to
+    // different things.
     if (this._channels < 1 || this._channels > 32) {
       throw new TypeError(`channels must be between 1 and 32, got ${this._channels}`);
     }

package/src/browser/index.d.ts

@@ -35,6 +35,16 @@ export interface VadOptions {
    * @default 300
    */
   holdoffMs?: number;
+  /**
+   * The 0-based DELIVERED channel the detector reads: the position within
+   * the delivered interleaved frames, after any `channelMap` is applied (a
+   * `channelMap` names device channels; `source` names the delivered
+   * position). Must be below the delivered channel count, which is its only
+   * ceiling; no fixed maximum exists. Affects only the detector score; the
+   * delivered audio is untouched.
+   * @default the frame average of every delivered channel
+   */
+  source?: number;
 }
 
 /** Constructor options for the browser `Microphone` class. */
@@ -47,14 +57,54 @@ export interface MicrophoneOptions {
   sampleRate?: number;
 
   /**
-   * Number of input channels.
+   * Number of channels the stream delivers, interleaved frame by frame in the
+   * emitted chunks. Bounded below at `1` (the default); bounded above by the
+   * granted track alone, which reports its own count when the stream starts.
+   * No fixed maximum exists.
+   *
+   * The capture itself asks the browser for every channel it will grant (the
+   * Web Audio specification's 32-channel floor, with ideal semantics), and
+   * decibri derives the delivered channels from the grant. Without a
+   * `channelMap`: `1` delivers the documented average of every granted
+   * channel; a count equal to the granted count delivers every granted
+   * channel in granted order; a count above the grant fails `start()` with
+   * an `Error` reading `the input device does not support N delivered
+   * channels; it reports M`; and a count above `1` and below the grant fails
+   * it with `a channel map is required to deliver N of the device's M input
+   * channels`, because which channels it means has no single answer, so
+   * `channelMap` names them. Where the browser does not report the granted
+   * channel count, the same `Error` is emitted on `'error'` and the capture
+   * stops as soon as the audio graph reports its true channel count.
    * @default 1
-   * @range 1–32
    */
   channels?: number;
 
+  /**
+   * Optional list of 0-based device channel indices selecting which granted
+   * channels feed the delivered channels: delivered channel `j` carries device
+   * channel `channelMap[j]`. The length must equal `channels`. Entries may
+   * repeat and may appear in any order, so a map both selects and permutes,
+   * and may name more delivered channels than the grant carries. Absent
+   * derives the delivered channels from `channels` as documented there.
+   *
+   * The same shape as the Node entry's `channelMap`, validated with the same
+   * classes and messages. Entries are checked against the granted track's own
+   * report: where the browser reports the granted channel count, `start()`
+   * rejects with an `Error` whose message names the entry and the granted
+   * count; where it does not, the same `Error` is emitted on `'error'` and
+   * the capture stops as soon as the audio graph reports its true channel
+   * count. The granted report is the only ceiling; no fixed maximum exists.
+   *
+   * A browser typically grants a single processed channel while
+   * `echoCancellation` or `noiseSuppression` is enabled, so a multichannel
+   * grant generally requires both disabled.
+   * @default undefined (the derivation `channels` documents)
+   */
+  channelMap?: number[];
+
   /**
    * Frames per audio chunk. Controls chunk size and delivery interval.
+   * A chunk holds this many frames of the delivered channel count.
    * @default 1600
    * @range 64–65536
    */
@@ -78,8 +128,9 @@ export interface MicrophoneOptions {
    * Voice activity detection. One of:
    * - `false`: disabled (default)
    * - `'energy'`: RMS energy threshold
-   * - a `VadOptions` config object `{ model: 'energy', threshold?, holdoffMs? }`
-   *   to tune the threshold and holdoff
+   * - a `VadOptions` config object
+   *   `{ model: 'energy', threshold?, holdoffMs?, source? }` to tune the
+   *   threshold, holdoff, and detector source
    *
    * The browser runs energy VAD only; Silero is Node-only. The string shorthand
    * uses a 0.01 threshold and a 300 ms holdoff; pass a `VadOptions` object to
@@ -144,6 +195,9 @@ export declare class Microphone {
   /**
    * Most recent VAD score: the normalized RMS of the last chunk in `'energy'`
    * mode, or 0 when VAD is disabled or before the first chunk is processed.
+   * A chunk carrying more than one channel is collapsed to the average of its
+   * channels before the RMS, or read at the one delivered channel the vad
+   * `source` names when it is set, so the score reflects one channel's level.
    */
   readonly vadScore: number;
 

package/src/browser/worklet-inline.js

@@ -7,8 +7,8 @@
  * The readable version is in worklet-processor.js (documentation/reference only).
  * If worklet-processor.js logic changes, this string MUST be regenerated.
  *
- * Generated from decibri-web v0.1.1 build output. Logic identical to worklet-processor.js.
+ * Logic identical to worklet-processor.js.
  */
-const WORKLET_SOURCE = "var u=class extends AudioWorkletProcessor{constructor(r){super();let e=r.processorOptions;this.framesPerBuffer=e.framesPerBuffer,this.format=e.format,this.ratio=e.nativeSampleRate/e.targetSampleRate,this.needsResample=e.nativeSampleRate!==e.targetSampleRate,this.position=0,this.buffer=new Float32Array(this.framesPerBuffer),this.bufferIndex=0}process(r,e,s){let t=r[0]?.[0];if(!t||t.length===0)return!0;let f;this.needsResample?f=this.resample(t):f=t;let a=0;for(;a<f.length;){let i=this.framesPerBuffer-this.bufferIndex,o=f.length-a,n=Math.min(i,o);this.buffer.set(f.subarray(a,a+n),this.bufferIndex),this.bufferIndex+=n,a+=n,this.bufferIndex>=this.framesPerBuffer&&this.flush()}return!0}resample(r){let e=r.length,s=0,t=this.position;for(;t<e-1;)s++,t+=this.ratio;let f=new Float32Array(s);t=this.position;for(let a=0;a<s;a++){let i=Math.floor(t),o=t-i;f[a]=r[i]*(1-o)+r[i+1]*o,t+=this.ratio}return this.position=Math.max(0,t-e),f}flush(){let r;if(this.format===\"int16\"){let e=new Int16Array(this.framesPerBuffer);for(let s=0;s<this.framesPerBuffer;s++)e[s]=Math.max(-32768,Math.min(32767,Math.round(this.buffer[s]*32768)));r=e.buffer}else r=this.buffer.slice(0,this.framesPerBuffer).buffer;this.port.postMessage(r,[r]),this.buffer=new Float32Array(this.framesPerBuffer),this.bufferIndex=0}};registerProcessor(\"decibri-processor\",u);\n";
+const WORKLET_SOURCE = "var e=class extends AudioWorkletProcessor{constructor(e){super();let t=e.processorOptions;this.framesPerBuffer=t.framesPerBuffer,this.format=t.format,this.ratio=t.nativeSampleRate/t.targetSampleRate,this.needsResample=t.nativeSampleRate!==t.targetSampleRate,this.channelMap=t.channelMap??null,this.channels=this.channelMap?this.channelMap.length:t.channels??1,this.channelError=!1,this.position=0,this.samplesPerChunk=this.framesPerBuffer*this.channels,this.buffer=new Float32Array(this.samplesPerChunk),this.bufferIndex=0}process(e,t,n){let r=e[0];if(!r||r.length===0||!r[0]||r[0].length===0)return!0;if(this.channelError)return!1;let i=r.length,a;if(this.channelMap){for(let e=0;e<this.channelMap.length;e++)if(this.channelMap[e]>=i)return this.refuse(`the channel map names device channel `+this.channelMap[e]+`; the device reports `+i+` input channels`);a=[];for(let e=0;e<this.channelMap.length;e++)a.push(r[this.channelMap[e]])}else if(this.channels===1)if(i===1)a=[r[0]];else{let e=r[0].length,t=new Float32Array(e);for(let n=0;n<e;n++){let e=0;for(let t=0;t<i;t++)e=Math.fround(e+r[t][n]);t[n]=e/i}a=[t]}else if(this.channels===i){a=[];for(let e=0;e<i;e++)a.push(r[e])}else if(this.channels>i)return this.refuse(`the input device does not support `+this.channels+` delivered channels; it reports `+i);else return this.refuse(`a channel map is required to deliver `+this.channels+` of the device's `+i+` input channels`);this.needsResample&&(a=this.resample(a));let o=a[0].length;for(let e=0;e<o;e++){for(let t=0;t<this.channels;t++)this.buffer[this.bufferIndex++]=a[t][e];this.bufferIndex>=this.samplesPerChunk&&this.flush()}return!0}refuse(e){return this.channelError=!0,this.port.postMessage({type:`error`,message:e}),!1}resample(e){let t=e[0].length,n=0,r=this.position;for(;r<t-1;)n++,r+=this.ratio;let i=e.map(()=>new Float32Array(n));r=this.position;for(let t=0;t<n;t++){let n=Math.floor(r),a=r-n;for(let r=0;r<e.length;r++)i[r][t]=e[r][n]*(1-a)+e[r][n+1]*a;r+=this.ratio}return this.position=Math.max(0,r-t),i}flush(){let e;if(this.format===`int16`){let t=new Int16Array(this.samplesPerChunk);for(let e=0;e<this.samplesPerChunk;e++)t[e]=Math.max(-32768,Math.min(32767,Math.round(this.buffer[e]*32768)));e=t.buffer}else e=this.buffer.slice(0,this.samplesPerChunk).buffer;this.port.postMessage(e,[e]),this.buffer=new Float32Array(this.samplesPerChunk),this.bufferIndex=0}};registerProcessor(`decibri-processor`,e);";
 
 module.exports = { WORKLET_SOURCE };