decibri 5.6.0 → 5.8.0

package/CHANGELOG.md

@@ -9,6 +9,39 @@ For other decibri packages, see:
 - Rust core: [crates/decibri/CHANGELOG.md](../../crates/decibri/CHANGELOG.md)
 - Python package: [bindings/python/CHANGELOG.md](../../bindings/python/CHANGELOG.md)
 
+## [5.8.0] - 2026-10-04
+
+### Breaking changes
+
+- **The browser `Microphone` refuses the options it cannot serve: `modelPath`, `dcRemoval`, `denoise`, `highpass`, `agc`, `limiter` and `aec`.** It accepted each of them and did nothing with it, so the delivered audio was unconditioned with nothing to indicate the option was ignored. Passing any of them now throws `TypeError: <option> is not supported in the browser` from the constructor, naming the first one present in the order above, whatever its value; an explicit `undefined` counts as absent. Code passing one of these options to the browser entry has to drop it, and code sharing one options object between the Node and browser entries has to strip them for the browser. The Node entry accepts the same options as before. The browser entry's other options, `sampleRate`, `channels`, `channelMap`, `framesPerBuffer`, `device`, `dtype`, `vad`, `echoCancellation`, `noiseSuppression` and `workletUrl`, are unchanged, as is every other browser `Microphone` message.
+
+### Changed
+
+- `File.save` and `AudioWriter` refuse an AIFF above 32767 channels, reported as a `DecibriError` with code `AUDIO_FORMAT_UNSUPPORTED` carrying the container layer's own text (`File.save` rejects with it; `AudioWriter` destroys the stream with it when the stream finishes), the refusal a FLAC above 8 channels and a WAV above 32767 already receive: an AIFF `COMM` chunk's `numChannels` is a signed 16-bit field, so 32767 is the format's own maximum. There is nothing a caller needs to do, because no container decibri writes accepts more. Reading an AIFF, every count up to 32767, WAV, FLAC and `File.buffer` delivery at any count are unchanged.
+- A device failure during capture or playback is no longer written to stderr. The failure reaches the consumer as before: `Microphone` emits it on `'error'` with code `DEVICE_FAILED`, and `Speaker` reports it from the next `write` or `drain`.
+- The `File.save` and `SaveReport.nonFiniteSamples` documentation states that when the conditioning chain runs it has already replaced every non-finite sample with silence at its entry, so the save's own replacement (NaN with silence, an infinity with full scale) and the `nonFiniteSamples` count cover the direct path only, a mono source already at `sampleRate` with no conditioning enabled. The behaviour is unchanged.
+- The `Speaker.isPlaying` documentation states that it reports whether the output stream is running: `true` once a non-empty write opens it, until `stop()`, `end()` once the queued audio has played, or a device failure, with `drainAsync()` leaving it `true`. The behaviour is unchanged.
+
+### Fixed
+
+- With a VAD active on a multichannel stream that has an enhancement step enabled, the detector feed holds two seconds of frames at every channel count and evicts whole frames. A stream whose delivered block exceeded the feed's bound (more than 20 channels at 16 kHz, or 60 at 48 kHz, at the default `framesPerBuffer` of 1600; fewer channels with a larger `framesPerBuffer`) lost feed frames on every block, and at a channel count that does not divide the bound also fed the detector a channel other than the one `vad: { source }` named. Mono streams and streams with no enhancement step are unchanged.
+- The browser `Microphone` and `Speaker` resamplers deliver the exact number of samples for the audio they receive. Each carried the resampling position across blocks and clamped a negative carry to zero, so a sample whose time fell between one block's last input sample and the next block's first was moved onto that first sample, and one input sample's time was dropped at every such boundary: at a 48 kHz context capturing at 16 kHz the `Microphone` delivered 15,937.5 samples a second, 0.39 % short, about 14 seconds an hour, with 44.1 kHz contexts, 44.1 kHz targets and the `Speaker` at the common source rates short by between 0.03 % and 0.62 % depending on the block size. Both now keep the previous block's last sample and carry the position across the boundary as an exact integer phase, and the delivered count matches the input at every rate pair over any length of audio. Capture and playback at the context's own rate never resampled and are unchanged.
+- On Windows, listing devices and constructing or starting a `Microphone` or `Speaker` work from any thread, including after a `worker_threads` worker that made the process's first device call has exited. The first device call in a process takes a usage reference on the process's multithreaded COM apartment and holds it for the life of the process. Device lists, identifiers and errors are unchanged, and so is every other platform.
+
+## [5.7.0] - 2026-08-21
+
+### Added
+
+- Prebuilt binaries for Windows ARM64, published as the fifth platform package `@decibri/decibri-win32-arm64-msvc` and selected automatically on `win32` / `arm64`. It bundles ONNX Runtime 1.28.1 and ships the same `THIRD-PARTY-NOTICES.md` as the other platform packages. Native ARM64 Node.js previously failed at load with the napi `Cannot find native binding` message; x64 Node.js under emulation is unchanged.
+
+### Changed
+
+- The bundled ONNX Runtime is 1.28.1 in every platform package, and the native addon is built against `ort` 2.0.0-rc.13 (`api-28`). An `ORT_DYLIB_PATH` override must point at ONNX Runtime 1.28 or newer.
+
+### Fixed
+
+- A bundled or `ORT_DYLIB_PATH` ONNX Runtime that cannot be used (not a loadable library, or older than 1.28) rejects with `ORT_LOAD_FAILED` on every silero or denoise attempt; a second attempt after such a failure no longer aborts the process.
+
 ## [5.6.0] - 2026-08-16
 
 ### Breaking changes

package/README.md

@@ -1,6 +1,6 @@
 # decibri
 
-Cross-platform audio capture, conditioning, and playback for Node.js and browsers, with voice activity detection on live and recorded audio.
+Cross-platform audio capture, conditioning, and playback for Node.js, with browser capture and voice activity detection on live and recorded audio.
 
 ## Installation
 
@@ -110,6 +110,7 @@ Creates a Readable stream that captures from the microphone.
 | `highpass` | `80` \| `100` | off | High-pass cutoff in Hz (second-order Butterworth) that removes low-frequency rumble. Runs after denoise. Out-of-set values throw a `RangeError` |
 | `agc` | number | off | AGC target level in dBFS, an integer in -40 to -3 (typical -18). Runs after the high-pass. Out-of-range throws a `RangeError` |
 | `limiter` | number | off | Peak limiter ceiling in dBFS, a number in -3.0 to 0.0 (typical -1.0). Runs last. Out-of-range throws a `RangeError` |
+| `aec` | `'tau'` \| `AecOptions` | off | Acoustic echo cancellation of the far-end audio pushed through `pushAecReference`. `'tau'` names the model; an object `{ model, tailMs, suppression, referenceSampleRate, referenceChannels }` tunes it. Runs before voice activity detection, so `vadScore` and the `'speech'` / `'silence'` events read the echo-removed signal. Requires `sampleRate` in 8000 to 48000. See [Echo cancellation](#echo-cancellation) |
 
 Standard `ReadableOptions` (e.g. `highWaterMark`) are also accepted.
 
@@ -122,6 +123,8 @@ Multichannel capture delivers interleaved frames: each chunk holds `framesPerBuf
 | Method | Description |
 | --- | --- |
 | `mic.stop()` | Stop capture and end stream. Safe to call multiple times |
+| `mic.pushAecReference(data)` | Queue far-end reference audio for the echo canceller, pushed as it is played, in played order. Accepts the same input shapes `Speaker.write` accepts. Never blocks and never throws on a full queue; a no-op when `aec` is unset. See [Echo cancellation](#echo-cancellation) |
+| `mic.aecMetrics()` | The echo canceller's metrics, or `null` when `aec` is unset or capture is not running |
 | `Microphone.open(options?)` | Construct without blocking the event loop. Returns a `Promise<Microphone>`. See [Non-blocking API](#non-blocking-api) |
 | `Microphone.devices()` | List available input devices |
 | `Microphone.version()` | Version info: `{ decibri, audioBackend, binding }` |
@@ -168,7 +171,7 @@ Standard `WritableOptions` (e.g. `highWaterMark`) are also accepted.
 | `speaker.end()` | Signal end. Drains remaining audio, then emits `'finish'` |
 | `speaker.drainAsync()` | Wait for queued audio to finish without blocking the event loop. Returns a `Promise` |
 | `speaker.stop()` | Immediate stop. Discards remaining audio |
-| `speaker.isPlaying` | `true` while audio is being output |
+| `speaker.isPlaying` | Whether the output stream is running: `true` once a non-empty write opens it, until `stop()`, `end()` once the queued audio has played, or a device failure. `drainAsync()` leaves it `true` |
 | `Speaker.open(options?)` | Construct without blocking the event loop. Returns a `Promise<Speaker>` |
 | `Speaker.devices()` | List available output devices |
 | `Speaker.version()` | Same as `Microphone.version()` |
@@ -229,15 +232,17 @@ The browser API uses `getUserMedia` and `AudioWorklet`. It differs from the Node
 
 ### `new Microphone(options?)` (browser)
 
-Same options as Node.js, plus:
+Takes `sampleRate`, `channels`, `channelMap`, `framesPerBuffer`, `dtype` and `vad` as Node.js does, plus:
 
 | Option | Type | Default | Description |
 | --- | --- | --- | --- |
 | `device` | string | system default | Device ID from `Microphone.devices()` (not index) |
-| `echoCancellation` | boolean | true | Browser echo cancellation |
-| `noiseSuppression` | boolean | true | Browser noise suppression |
+| `echoCancellation` | boolean | true | Browser echo cancellation, applied by the platform before decibri sees the audio |
+| `noiseSuppression` | boolean | true | Browser noise suppression, applied by the platform before decibri sees the audio |
 | `workletUrl` | string | inline blob | Custom worklet URL for strict CSP |
 
+The conditioning options run in the native Node.js capture path: `dcRemoval`, `denoise`, `highpass`, `agc`, `limiter`, `aec` and `modelPath`. The browser `Microphone` throws a `TypeError` naming the option if one is passed.
+
 The browser runs energy-mode VAD only, so its `vad` option accepts `false`, `'energy'`, or a config object `{ model: 'energy', threshold, holdoffMs, source }`. The browser `version()` returns `{ decibri }` only: the browser build has no native core, so `decibri` reports the installed package version. In Node, `version().decibri` reports the native core version.
 
 ### Key differences from Node.js
@@ -250,6 +255,8 @@ The browser runs energy-mode VAD only, so its `vad` option accepts `false`, `'en
 | `devices()` | Sync, returns array | Async, returns Promise |
 | Sample rate | Native device rate | Resampled from native rate |
 | VAD | `'silero'` or `'energy'` | `'energy'` only |
+| Conditioning | ACE chain and `aec` | Platform `echoCancellation` and `noiseSuppression` |
+| Offline audio | `File` and `AudioWriter` | Capture and playback only |
 
 ### `new Speaker(options?)` (browser)
 
@@ -340,6 +347,42 @@ setTimeout(() => mic.stop(), 5000);
 
 VAD reads the signal before the chain, so `vadScore` and the `'speech'` / `'silence'` events are unaffected by which conditioning stages you enable. The conditioning chain runs in the native Node.js capture path; the browser build does not include it.
 
+## Echo cancellation
+
+Acoustic echo cancellation removes the echo of far-end audio (what your application is playing out) from the captured audio. It is opt-in: set `aec` on the `Microphone` and push the far-end audio through `pushAecReference` as it is played, in played order. With `aec` unset the capture path is unchanged, and with no reference pushed the captured audio passes through unchanged. The canceller runs before voice activity detection, so `vadScore` and the `'speech'` / `'silence'` events read the echo-removed signal and playback stops triggering detection. It requires `sampleRate` in 8000 to 48000.
+
+`aec: 'tau'` selects the model with its defaults; an `AecOptions` object tunes it:
+
+| Option | Default | Range |
+| --- | --- | --- |
+| `model` | required | `'tau'`, the one model |
+| `tailMs` | 200 | 16 to 500 ms |
+| `suppression` | `'conservative'` | `'conservative'` or `'off'` |
+| `referenceSampleRate` | the capture `sampleRate` | 1000 to 384000 Hz |
+| `referenceChannels` | 1 | 1 or more |
+
+```javascript
+const { Microphone, Speaker } = require('decibri');
+
+const mic = new Microphone({ sampleRate: 16000, aec: 'tau' });
+const speaker = new Speaker({ sampleRate: 16000, channels: 1 });
+
+// Push the far-end audio as it is played, in played order: the same
+// input shapes Speaker.write accepts, in the microphone's dtype.
+function playFarEnd(pcmBuffer) {
+  speaker.write(pcmBuffer);
+  mic.pushAecReference(pcmBuffer);
+}
+
+mic.on('data', (chunk) => { /* Buffer of echo-cancelled Int16 PCM */ });
+```
+
+`pushAecReference` never blocks and never throws on a full queue: samples that do not fit are discarded and counted by `aecMetrics().referenceDropped`. Silence between played audio need not be pushed. The canceller reads one mono reference: a reference at a `referenceSampleRate` other than the capture rate is converted before the canceller sees it, and with `referenceChannels` above 1 each frame is averaged to one mono sample. With `channels` above 1, one canceller runs per delivered channel, each fed the same pushed reference, so one push serves every channel.
+
+`aecMetrics()` returns the canceller's report merged with the reference queue's counters (`delaySamples`, `erleDb`, `doubleTalk`, `referenceStarved`, `acquisitionParked`, `referenceReanchors`, `referenceDropped`, `referenceSilence`), or `null` when `aec` is unset or capture is not running. Its `channels` array carries each delivered channel's report in delivered order; the top-level fields report the first delivered channel's. `erleDb` is not a quality ranking across channels: it rises with echo distance, so a far microphone reports a higher figure than a near one while removing less echo in absolute terms.
+
+Echo cancellation runs in the native Node.js capture path; the browser `Microphone` does not take the option, because browser capture already carries the platform's own echo cancellation through its `echoCancellation` constraint, on by default.
+
 ## ONNX Runtime telemetry
 
 Silero mode (`vad: 'silero'`) and the ACE `denoise` stage run on ONNX Runtime, which carries its own telemetry, separate from anything decibri does. Decibri disables it on the environment it commits when it initializes the runtime. Set `DECIBRI_ORT_TELEMETRY=1` in the environment before first use to leave it enabled; every other value, an empty value, and an absent variable leave it disabled.
@@ -350,15 +393,32 @@ Neither ONNX Runtime nor this setting applies to the browser build, which has no
 
 ## API: File (offline source)
 
-Everything a `Microphone` does to live audio, `File` does to audio you already have: the same conditioning options, the same Readable stream of conditioned chunks (finite: it ends at EOF), and the same opt-in `vad`. Because a `File` is a complete recording, it can also analyze the whole recording for speech.
+`File` runs the same conditioning chain on audio you already have. Because a `File` is a complete recording, it can also analyze the whole recording for speech.
 
 - `await File.open(path, options?)`: read a file off the event loop (recommended, like `Microphone.open`). Reads WAV, AIFF, AIFF-C and FLAC, identified from the file's own bytes rather than its extension.
 - `new File(path, options?)`: the same result, synchronous (blocks on disk I/O; fine for scripts).
 - `File.buffer(samples, options)`: wrap a `Float32Array` of samples you already hold. `options.inputRate` is required (raw samples carry no header); a raw `Buffer` of bytes is rejected as ambiguous. `options.inputChannels` states the interleave of the samples, `1` by default, the channel counterpart of `inputRate`.
 - `await file.analyze()` (also spelled `analyse()`): consume the source and resolve to a `VadReport` of per-window `scores` (`{ start, end, vadScore, isSpeech }`) and merged speech `segments` (`{ start, end }`), in seconds of file time. Requires `vad: 'silero'`; a `File` opened without `vad` rejects with `analysis requires VAD`.
+- `await file.save(path, options?)`: write the conditioned recording to disk, off the event loop, as 16-bit PCM at `sampleRate` and at the delivered channel count, in WAV, AIFF or FLAC. The container comes from the path's extension (`.wav`, `.aiff`, `.aif`, `.aifc` or `.flac`) or from `options.format`; an extension it does not recognise rejects rather than defaulting. `options.compression` sets the FLAC compression level, 0 to 8 with 5 the default. Resolves to a `SaveReport` (`{ clippedSamples, nonFiniteSamples }`). Consumes the source, and rejects with `FILE_ENGAGED` once the stream is engaged, exactly as `analyze()` does.
 - `file.vadScore`, `'speech'` / `'silence'` events: per-chunk VAD alongside the stream, with the holdoff measured in FILE time (sample positions), never wall-clock time, so processing speed does not change the reported events.
 
-Options mirror `Microphone` (`sampleRate`, `channels`, `channelMap`, `dtype`, `vad`, `dcRemoval`, `denoise`, `highpass`, `agc`, `limiter`), with `channels` and `channelMap` read against the source's own channel count (the file's header, or `inputChannels` for `File.buffer`) where the live path reads the device's report, and the vad `source` naming a delivered channel exactly as on `Microphone`; the live-capture options (`device`, `framesPerBuffer`) do not apply. Iteration and analysis are separate single passes: construct one `File` per operation. Note: Node also has a global `File` (the web File API); import decibri's explicitly to avoid shadowing surprises.
+Options mirror `Microphone` (`sampleRate`, `channels`, `channelMap`, `dtype`, `vad`, `dcRemoval`, `denoise`, `highpass`, `agc`, `limiter`), with `channels` and `channelMap` read against the source's own channel count (the file's header, or `inputChannels` for `File.buffer`) where the live path reads the device's report, and the vad `source` naming a delivered channel exactly as on `Microphone`; the live-capture options (`device`, `framesPerBuffer`, `aec`) do not apply. A save clamps finite samples outside full scale to `[-1.0, 1.0]` and counts them in `clippedSamples`, and replaces non-finite samples before they reach the file (NaN as silence, an infinity as full scale), counted in `nonFiniteSamples`. When the conditioning chain runs it has already replaced every non-finite sample with silence at its entry, so `nonFiniteSamples` covers the direct path only, a mono source already at `sampleRate` with no conditioning enabled. Iteration, analysis and saving are separate single passes: construct one `File` per operation. Note: Node also has a global `File` (the web File API); import decibri's explicitly to avoid shadowing surprises.
+
+## API: AudioWriter (file sink)
+
+`AudioWriter` is a Writable file sink for PCM audio: the stream to pair with decibri's Readable sources (`File`, `Microphone`) and with any other stream of PCM bytes. It collects the whole stream, then writes it as one audio file when the stream finishes, exactly as `File.save` writes: the same containers from the same extension rule, the same 16-bit PCM encoding, the same clamp and non-finite handling, the same bytes.
+
+```javascript
+const { pipeline } = require('node:stream/promises');
+const { File, AudioWriter } = require('decibri');
+
+await pipeline(
+  new File('noisy.wav', { denoise: 'fastenhancer-t' }),
+  new AudioWriter('clean.flac', { sampleRate: 16000 }),
+);
+```
+
+`sampleRate` is required (raw audio carries no header to read a rate from). `channels` (default 1) and `dtype` (default `'int16'`) describe the incoming bytes: the stream's total sample count must be a whole number of frames at `channels`, and each container's own channel ceiling applies at the write. The `File.save` options (`format`, `compression`) are accepted as well. `'finish'` fires after the file is on disk, and `writer.report` then carries the `SaveReport`; a failure destroys the stream with the error.
 
 ## Device Selection
 
@@ -409,6 +469,7 @@ decibri 4.0.0 renames the API to a microphone and speaker vocabulary and switche
 | Platform | Architecture | Audio Backend |
 | --- | --- | --- |
 | Windows | x64 | WASAPI |
+| Windows | arm64 | WASAPI |
 | macOS | arm64 | CoreAudio |
 | Linux | x64 | ALSA |
 | Linux | arm64 | ALSA |

package/examples/decibri.browser.js

@@ -63,14 +63,23 @@ var decibri = (function() {
 	//#endregion
 	//#region npm/decibri/src/browser/worklet-inline.js
 	var require_worklet_inline = /* @__PURE__ */ __commonJSMin(((exports, module) => {
-		module.exports = { 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: "var e=class extends AudioWorkletProcessor{constructor(e){super();let t=e.processorOptions;this.framesPerBuffer=t.framesPerBuffer,this.format=t.format,this.native=t.nativeSampleRate,this.target=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.phase=0,this.last=new Float32Array(this.channels),this.planar=Array(this.channels),this.mono=null,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=this.planar;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`);for(let e=0;e<this.channelMap.length;e++)a[e]=r[this.channelMap[e]]}else if(this.channels===1)if(i===1)a[0]=r[0];else{let e=r[0].length;(this.mono===null||this.mono.length!==e)&&(this.mono=new Float32Array(e));let t=this.mono;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[0]=t}else if(this.channels===i)for(let e=0;e<i;e++)a[e]=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`);return this.needsResample?this.resample(a):this.accumulate(a),!0}accumulate(e){let t=e[0].length,n=this.channels;for(let r=0;r<t;r++){for(let t=0;t<n;t++)this.buffer[this.bufferIndex++]=e[t][r];this.bufferIndex>=this.samplesPerChunk&&this.flush()}}refuse(e){return this.channelError=!0,this.port.postMessage({type:`error`,message:e}),!1}resample(e){let t=e[0].length,n=this.channels,r=this.native,i=this.target,a=this.last,o=this.phase,s=(t-1)*i;for(;o<s;){let t=Math.floor(o/i),s=(o-t*i)/i;if(t<0)for(let t=0;t<n;t++)this.buffer[this.bufferIndex++]=a[t]*(1-s)+e[t][0]*s;else for(let r=0;r<n;r++)this.buffer[this.bufferIndex++]=e[r][t]*(1-s)+e[r][t+1]*s;this.bufferIndex>=this.samplesPerChunk&&this.flush(),o+=r}this.phase=o-t*i;for(let r=0;r<n;r++)a[r]=e[r][t-1]}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.buffer,this.buffer=new Float32Array(this.samplesPerChunk);this.port.postMessage(e,[e]),this.bufferIndex=0}};registerProcessor(`decibri-processor`,e);" };
 	}));
 	//#endregion
 	//#region npm/decibri/src/browser/decibri-browser.js
 	var require_decibri_browser = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 		const { Emitter } = require_emitter();
 		const { WORKLET_SOURCE } = require_worklet_inline();
-		const VERSION = "5.6.0";
+		const VERSION = "5.8.0";
+		const UNSUPPORTED_OPTIONS = [
+			"modelPath",
+			"dcRemoval",
+			"denoise",
+			"highpass",
+			"agc",
+			"limiter",
+			"aec"
+		];
 		/**
 		* Browser microphone capture.
 		*
@@ -100,6 +109,7 @@ var decibri = (function() {
 				this._starting = null;
 				this._stopRequested = false;
 				if (options.vadThreshold !== void 0 || options.vadHoldoff !== void 0) 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 }.");
+				for (const key of UNSUPPORTED_OPTIONS) if (options[key] !== void 0) throw new TypeError(`${key} is not supported in the browser`);
 				const vad = options.vad ?? false;
 				let vadThreshold = .01;
 				let vadHoldoff = 300;
@@ -402,33 +412,41 @@ var decibri = (function() {
 		/**
 		* Linear-interpolation resampler, the inverse of the capture worklet's: it
 		* takes samples at the user's rate and produces samples at the context rate.
-		* Carries a fractional position across calls so successive writes stay
-		* continuous. Logic mirrors worklet-processor.js resample(), with from and to
-		* swapped (from = user rate, to = context rate).
+		* Carries its phase and the previous call's last sample across calls, so
+		* successive writes stay continuous and the delivered count over any number
+		* of writes is exact. Logic mirrors worklet-processor.js resample(), with
+		* from and to swapped (from = user rate, to = context rate).
 		*/
 		var Resampler = class {
 			constructor(fromRate, toRate) {
-				this.ratio = fromRate / toRate;
-				this.position = 0;
+				this.from = fromRate;
+				this.to = toRate;
+				this.identity = fromRate === toRate;
+				this.phase = 0;
+				this.last = 0;
 			}
 			process(input) {
-				if (this.ratio === 1) return input;
+				if (this.identity) return input;
 				const inputLength = input.length;
+				const from = this.from;
+				const to = this.to;
+				const end = (inputLength - 1) * to;
 				let count = 0;
-				let pos = this.position;
-				while (pos < inputLength - 1) {
+				let phase = this.phase;
+				while (phase < end) {
 					count++;
-					pos += this.ratio;
+					phase += from;
 				}
 				const output = new Float32Array(count);
-				pos = this.position;
+				phase = this.phase;
 				for (let i = 0; i < count; i++) {
-					const idx = Math.floor(pos);
-					const frac = pos - idx;
-					output[i] = input[idx] * (1 - frac) + input[idx + 1] * frac;
-					pos += this.ratio;
+					const idx = Math.floor(phase / to);
+					const frac = (phase - idx * to) / to;
+					output[i] = (idx < 0 ? this.last : input[idx]) * (1 - frac) + input[idx + 1] * frac;
+					phase += from;
 				}
-				this.position = Math.max(0, pos - inputLength);
+				this.phase = phase - inputLength * to;
+				if (inputLength > 0) this.last = input[inputLength - 1];
 				return output;
 			}
 		};

package/index.d.ts

@@ -320,11 +320,10 @@ export interface DecibriOptions {
   channels?: number
   /**
    * Capture channel map: 0-based device channel indices, one per delivered
-   * channel (the shape of CoreAudio AUHAL's channel map, an index list, not
-   * miniaudio's spatial `channelMap`). Absent delivers the documented
-   * average of every opened channel. Entries are validated against the
-   * resolved device's own report when the stream starts; no fixed maximum
-   * exists.
+   * channel, selecting device channels by index rather than describing a
+   * spatial layout. Absent delivers the documented average of every opened
+   * channel. Entries are validated against the resolved device's own report
+   * when the stream starts; no fixed maximum exists.
    */
   channelMap?: Array<number>
   framesPerBuffer?: number
@@ -486,6 +485,9 @@ export interface SaveOptions {
  * What a save did to the samples on their way into the file: finite
  * samples outside full scale clamped and counted, non-finite samples
  * replaced (NaN with silence, an infinity with full scale) and counted.
+ * When the conditioning chain runs it has already replaced every
+ * non-finite sample with silence at its entry, so the non-finite count is
+ * what the save's own repair saw, not what the source carried.
  */
 export interface SaveReport {
   clippedSamples: number

package/index.js

@@ -77,8 +77,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-android-arm64')
         const bindingPackageVersion = require('@decibri/decibri-android-arm64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -93,8 +93,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-android-arm-eabi')
         const bindingPackageVersion = require('@decibri/decibri-android-arm-eabi/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -114,8 +114,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-win32-x64-gnu')
         const bindingPackageVersion = require('@decibri/decibri-win32-x64-gnu/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -130,8 +130,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-win32-x64-msvc')
         const bindingPackageVersion = require('@decibri/decibri-win32-x64-msvc/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -147,8 +147,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-win32-ia32-msvc')
         const bindingPackageVersion = require('@decibri/decibri-win32-ia32-msvc/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -163,8 +163,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-win32-arm64-msvc')
         const bindingPackageVersion = require('@decibri/decibri-win32-arm64-msvc/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -182,8 +182,8 @@ function requireNative() {
     try {
       const binding = require('@decibri/decibri-darwin-universal')
       const bindingPackageVersion = require('@decibri/decibri-darwin-universal/package.json').version
-      if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-        throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+      if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+        throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
       }
       return binding
     } catch (e) {
@@ -198,8 +198,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-darwin-x64')
         const bindingPackageVersion = require('@decibri/decibri-darwin-x64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -214,8 +214,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-darwin-arm64')
         const bindingPackageVersion = require('@decibri/decibri-darwin-arm64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -234,8 +234,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-freebsd-x64')
         const bindingPackageVersion = require('@decibri/decibri-freebsd-x64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -250,8 +250,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-freebsd-arm64')
         const bindingPackageVersion = require('@decibri/decibri-freebsd-arm64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -271,8 +271,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-x64-musl')
           const bindingPackageVersion = require('@decibri/decibri-linux-x64-musl/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -287,8 +287,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-x64-gnu')
           const bindingPackageVersion = require('@decibri/decibri-linux-x64-gnu/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -305,8 +305,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-arm64-musl')
           const bindingPackageVersion = require('@decibri/decibri-linux-arm64-musl/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -321,8 +321,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-arm64-gnu')
           const bindingPackageVersion = require('@decibri/decibri-linux-arm64-gnu/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -339,8 +339,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-arm-musleabihf')
           const bindingPackageVersion = require('@decibri/decibri-linux-arm-musleabihf/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -355,8 +355,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-arm-gnueabihf')
           const bindingPackageVersion = require('@decibri/decibri-linux-arm-gnueabihf/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -373,8 +373,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-loong64-musl')
           const bindingPackageVersion = require('@decibri/decibri-linux-loong64-musl/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -389,8 +389,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-loong64-gnu')
           const bindingPackageVersion = require('@decibri/decibri-linux-loong64-gnu/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -407,8 +407,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-riscv64-musl')
           const bindingPackageVersion = require('@decibri/decibri-linux-riscv64-musl/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -423,8 +423,8 @@ function requireNative() {
         try {
           const binding = require('@decibri/decibri-linux-riscv64-gnu')
           const bindingPackageVersion = require('@decibri/decibri-linux-riscv64-gnu/package.json').version
-          if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-            throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+          if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+            throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
           }
           return binding
         } catch (e) {
@@ -440,8 +440,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-linux-ppc64-gnu')
         const bindingPackageVersion = require('@decibri/decibri-linux-ppc64-gnu/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -456,8 +456,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-linux-s390x-gnu')
         const bindingPackageVersion = require('@decibri/decibri-linux-s390x-gnu/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -476,8 +476,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-openharmony-arm64')
         const bindingPackageVersion = require('@decibri/decibri-openharmony-arm64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -492,8 +492,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-openharmony-x64')
         const bindingPackageVersion = require('@decibri/decibri-openharmony-x64/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {
@@ -508,8 +508,8 @@ function requireNative() {
       try {
         const binding = require('@decibri/decibri-openharmony-arm')
         const bindingPackageVersion = require('@decibri/decibri-openharmony-arm/package.json').version
-        if (bindingPackageVersion !== '5.6.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
-          throw new Error(`Native binding package version mismatch, expected 5.6.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
+        if (bindingPackageVersion !== '5.8.0' && process.env.NAPI_RS_ENFORCE_VERSION_CHECK && process.env.NAPI_RS_ENFORCE_VERSION_CHECK !== '0') {
+          throw new Error(`Native binding package version mismatch, expected 5.8.0 but got ${bindingPackageVersion}. You can reinstall dependencies to fix this issue.`)
         }
         return binding
       } catch (e) {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "decibri",
-  "version": "5.6.0",
-  "description": "Cross-platform audio capture, playback, and processing for Node.js and browsers",
+  "version": "5.8.0",
+  "description": "Cross-platform audio capture, conditioning, and playback for Node.js, with browser capture and voice activity detection on live and recorded audio",
   "main": "src/decibri.js",
   "types": "src/decibri.d.ts",
   "browser": "./src/browser/index.js",
@@ -56,6 +56,7 @@
     "binaryName": "decibri",
     "targets": [
       "x86_64-pc-windows-msvc",
+      "aarch64-pc-windows-msvc",
       "aarch64-apple-darwin",
       "x86_64-unknown-linux-gnu",
       "aarch64-unknown-linux-gnu"
@@ -72,10 +73,11 @@
     "MIGRATION.md"
   ],
   "optionalDependencies": {
-    "@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"
+    "@decibri/decibri-win32-x64-msvc": "5.8.0",
+    "@decibri/decibri-win32-arm64-msvc": "5.8.0",
+    "@decibri/decibri-darwin-arm64": "5.8.0",
+    "@decibri/decibri-linux-x64-gnu": "5.8.0",
+    "@decibri/decibri-linux-arm64-gnu": "5.8.0"
   },
   "devDependencies": {
     "@napi-rs/cli": "^3.7.0"

package/src/browser/decibri-browser.js

@@ -6,7 +6,13 @@ 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.6.0';
+const VERSION = '5.8.0';
+
+// The node entry's options this entry cannot serve: the conditioning chain
+// and the detector model file. Each is refused on presence, whatever its
+// value; an explicit undefined is absence, as on the node entry. Node option
+// table order, so the first present key is the one the error names.
+const UNSUPPORTED_OPTIONS = ['modelPath', 'dcRemoval', 'denoise', 'highpass', 'agc', 'limiter', 'aec'];
 
 /**
  * Browser microphone capture.
@@ -50,6 +56,11 @@ class Microphone extends Emitter {
         "vadThreshold and vadHoldoff are no longer supported. Pass them on the vad config object: vad: { model: 'energy', threshold: 0.01, holdoffMs: 300 }."
       );
     }
+    for (const key of UNSUPPORTED_OPTIONS) {
+      if (options[key] !== undefined) {
+        throw new TypeError(`${key} is not supported in the browser`);
+      }
+    }
     const vad = options.vad ?? false;
     let vadThreshold = 0.01;
     let vadHoldoff = 300;

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

@@ -10,39 +10,60 @@ const BUFFER_SECONDS = 2;
 /**
  * Linear-interpolation resampler, the inverse of the capture worklet's: it
  * takes samples at the user's rate and produces samples at the context rate.
- * Carries a fractional position across calls so successive writes stay
- * continuous. Logic mirrors worklet-processor.js resample(), with from and to
- * swapped (from = user rate, to = context rate).
+ * Carries its phase and the previous call's last sample across calls, so
+ * successive writes stay continuous and the delivered count over any number
+ * of writes is exact. Logic mirrors worklet-processor.js resample(), with
+ * from and to swapped (from = user rate, to = context rate).
  */
 class Resampler {
   constructor(fromRate, toRate) {
-    this.ratio = fromRate / toRate;
-    this.position = 0;
+    this.from = fromRate;
+    this.to = toRate;
+    this.identity = fromRate === toRate;
+    // The position of the next output sample in input samples relative to
+    // the current call's first sample, held as an integer numerator over the
+    // context rate so it is exact across any number of calls. It may sit
+    // below zero, down to one input sample before the call, for a sample
+    // whose time falls between the previous call's last sample, kept in
+    // `last`, and this call's first. The first call starts at zero, on its
+    // own first sample.
+    this.phase = 0;
+    this.last = 0;
   }
 
   process(input) {
-    if (this.ratio === 1) return input;
+    if (this.identity) return input;
 
     const inputLength = input.length;
+    const from = this.from;
+    const to = this.to;
+    // A sample needs the input sample after its floor, so the call serves
+    // every position below inputLength - 1.
+    const end = (inputLength - 1) * to;
 
     let count = 0;
-    let pos = this.position;
-    while (pos < inputLength - 1) {
+    let phase = this.phase;
+    while (phase < end) {
       count++;
-      pos += this.ratio;
+      phase += from;
     }
 
     const output = new Float32Array(count);
-    pos = this.position;
+    phase = this.phase;
 
     for (let i = 0; i < count; i++) {
-      const idx = Math.floor(pos);
-      const frac = pos - idx;
-      output[i] = input[idx] * (1 - frac) + input[idx + 1] * frac;
-      pos += this.ratio;
+      const idx = Math.floor(phase / to);
+      const frac = (phase - idx * to) / to;
+      const before = idx < 0 ? this.last : input[idx];
+      output[i] = before * (1 - frac) + input[idx + 1] * frac;
+      phase += from;
     }
 
-    this.position = Math.max(0, pos - inputLength);
+    // Carry the phase relative to the next call's first sample, and keep
+    // this call's last sample for the output that may fall before that call
+    // begins. An empty call leaves both as they are.
+    this.phase = phase - inputLength * to;
+    if (inputLength > 0) this.last = input[inputLength - 1];
 
     return output;
   }

package/src/browser/worklet-inline.js

@@ -9,6 +9,6 @@
  *
  * Logic identical to worklet-processor.js.
  */
-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);";
+const WORKLET_SOURCE = "var e=class extends AudioWorkletProcessor{constructor(e){super();let t=e.processorOptions;this.framesPerBuffer=t.framesPerBuffer,this.format=t.format,this.native=t.nativeSampleRate,this.target=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.phase=0,this.last=new Float32Array(this.channels),this.planar=Array(this.channels),this.mono=null,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=this.planar;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`);for(let e=0;e<this.channelMap.length;e++)a[e]=r[this.channelMap[e]]}else if(this.channels===1)if(i===1)a[0]=r[0];else{let e=r[0].length;(this.mono===null||this.mono.length!==e)&&(this.mono=new Float32Array(e));let t=this.mono;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[0]=t}else if(this.channels===i)for(let e=0;e<i;e++)a[e]=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`);return this.needsResample?this.resample(a):this.accumulate(a),!0}accumulate(e){let t=e[0].length,n=this.channels;for(let r=0;r<t;r++){for(let t=0;t<n;t++)this.buffer[this.bufferIndex++]=e[t][r];this.bufferIndex>=this.samplesPerChunk&&this.flush()}}refuse(e){return this.channelError=!0,this.port.postMessage({type:`error`,message:e}),!1}resample(e){let t=e[0].length,n=this.channels,r=this.native,i=this.target,a=this.last,o=this.phase,s=(t-1)*i;for(;o<s;){let t=Math.floor(o/i),s=(o-t*i)/i;if(t<0)for(let t=0;t<n;t++)this.buffer[this.bufferIndex++]=a[t]*(1-s)+e[t][0]*s;else for(let r=0;r<n;r++)this.buffer[this.bufferIndex++]=e[r][t]*(1-s)+e[r][t+1]*s;this.bufferIndex>=this.samplesPerChunk&&this.flush(),o+=r}this.phase=o-t*i;for(let r=0;r<n;r++)a[r]=e[r][t-1]}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.buffer,this.buffer=new Float32Array(this.samplesPerChunk);this.port.postMessage(e,[e]),this.bufferIndex=0}};registerProcessor(`decibri-processor`,e);";
 
 module.exports = { WORKLET_SOURCE };

package/src/browser/worklet-processor.js

@@ -23,7 +23,8 @@ class DecibriProcessor extends AudioWorkletProcessor {
     const opts = options.processorOptions;
     this.framesPerBuffer = opts.framesPerBuffer;
     this.format = opts.format;
-    this.ratio = opts.nativeSampleRate / opts.targetSampleRate;
+    this.native = opts.nativeSampleRate;
+    this.target = opts.targetSampleRate;
     this.needsResample = opts.nativeSampleRate !== opts.targetSampleRate;
     // Optional list of 0-based channel indices into the granted track's
     // channels; delivered channel j carries granted channel channelMap[j].
@@ -38,7 +39,23 @@ class DecibriProcessor extends AudioWorkletProcessor {
     // channel, so its length is the count when one is present.
     this.channels = this.channelMap ? this.channelMap.length : (opts.channels ?? 1);
     this.channelError = false;
-    this.position = 0;
+    // The resampler's phase: the position of the next delivered frame in
+    // input samples relative to the current block's first sample, held as an
+    // integer numerator over the target rate so it is exact across any
+    // number of blocks. It may sit below zero, down to one input sample
+    // before the block, for a frame whose time falls between the previous
+    // block's last sample and this block's first; that last sample is kept
+    // per delivered channel in `last`. The first block starts at zero, on
+    // its own first sample.
+    this.phase = 0;
+    this.last = new Float32Array(this.channels);
+    // The delivered channels of the current block, planar, gathered into
+    // this array in place so a block allocates nothing.
+    this.planar = new Array(this.channels);
+    // The average of every granted channel, for one delivered channel
+    // derived from more than one granted: sized to the block on first use
+    // and reused while the block length holds.
+    this.mono = null;
     // The accumulation buffer holds framesPerBuffer frames of the delivered
     // count, interleaved frame by frame; bufferIndex counts samples. Chunks
     // are flushed at whole frames only.
@@ -54,9 +71,9 @@ class DecibriProcessor extends AudioWorkletProcessor {
 
     const granted = input.length;
     // The delivered channels, planar: one Float32Array per delivered
-    // channel, equal lengths. Gathered here, resampled per channel in
-    // lockstep, interleaved at accumulation.
-    let planar;
+    // channel, equal lengths. Gathered here into the preallocated array,
+    // resampled per channel in lockstep, interleaved at accumulation.
+    const planar = this.planar;
 
     if (this.channelMap) {
       // The granted track's channel count is the only ceiling. A map entry
@@ -71,20 +88,22 @@ class DecibriProcessor extends AudioWorkletProcessor {
       // Delivered channel j is granted channel channelMap[j], in map order.
       // Entries may repeat and may appear in any order, so a map both
       // selects and permutes.
-      planar = [];
       for (let j = 0; j < this.channelMap.length; j++) {
-        planar.push(input[this.channelMap[j]]);
+        planar[j] = input[this.channelMap[j]];
       }
     } else if (this.channels === 1) {
       if (granted === 1) {
-        planar = [input[0]];
+        planar[0] = input[0];
       } else {
         // The documented average of every granted channel: each frame's
         // arithmetic mean, accumulated at single precision (Math.fround per
         // step) and stored as f32, matching the engine's average sample for
         // sample.
         const frames = input[0].length;
-        const mono = new Float32Array(frames);
+        if (this.mono === null || this.mono.length !== frames) {
+          this.mono = new Float32Array(frames);
+        }
+        const mono = this.mono;
         for (let i = 0; i < frames; i++) {
           let sum = 0;
           for (let c = 0; c < granted; c++) {
@@ -92,12 +111,11 @@ class DecibriProcessor extends AudioWorkletProcessor {
           }
           mono[i] = sum / granted;
         }
-        planar = [mono];
+        planar[0] = mono;
       }
     } else if (this.channels === granted) {
       // Every granted channel, in granted order: the unmapped identity.
-      planar = [];
-      for (let c = 0; c < granted; c++) planar.push(input[c]);
+      for (let c = 0; c < granted; c++) planar[c] = input[c];
     } else if (this.channels > granted) {
       return this.refuse('the input device does not support ' + this.channels +
         ' delivered channels; it reports ' + granted);
@@ -109,23 +127,30 @@ class DecibriProcessor extends AudioWorkletProcessor {
     }
 
     if (this.needsResample) {
-      planar = this.resample(planar);
+      this.resample(planar);
+    } else {
+      this.accumulate(planar);
     }
 
-    // Interleave the planar channels into the accumulation buffer frame by
-    // frame, flushing at whole chunks, so every posted chunk is a whole
-    // number of frames.
+    return true;
+  }
+
+  /**
+   * Interleave the block's frames into the accumulation buffer as they are,
+   * flushing at whole chunks, so every posted chunk is a whole number of
+   * frames.
+   */
+  accumulate(planar) {
     const frames = planar[0].length;
+    const channels = this.channels;
     for (let i = 0; i < frames; i++) {
-      for (let c = 0; c < this.channels; c++) {
+      for (let c = 0; c < channels; c++) {
         this.buffer[this.bufferIndex++] = planar[c][i];
       }
       if (this.bufferIndex >= this.samplesPerChunk) {
         this.flush();
       }
     }
-
-    return true;
   }
 
   /**
@@ -139,54 +164,75 @@ class DecibriProcessor extends AudioWorkletProcessor {
     return false;
   }
 
+  /**
+   * Resample the block by linear interpolation at one phase shared by every
+   * channel, so a delivered frame stays a frame, interleaving each frame
+   * straight into the accumulation buffer and flushing at whole chunks.
+   * Frame k of the stream sits at k * native / target input samples. The
+   * phase carries that position across blocks as an exact integer numerator
+   * over the target rate, without clamping, and the previous block's last
+   * sample per channel is kept, so a frame whose time falls between two
+   * blocks is interpolated across the boundary. Every input sample's time is
+   * represented once, and the delivered count over any length of capture is
+   * exact.
+   */
   resample(planar) {
     const inputLength = planar[0].length;
-
-    // Calculate how many output frames we can produce. One position shared
-    // by every channel: the channels advance in lockstep, so a delivered
-    // frame stays a frame.
-    let count = 0;
-    let pos = this.position;
-    while (pos < inputLength - 1) {
-      count++;
-      pos += this.ratio;
-    }
-
-    const output = planar.map(() => new Float32Array(count));
-    pos = this.position;
-
-    for (let i = 0; i < count; i++) {
-      const idx = Math.floor(pos);
-      const frac = pos - idx;
-      for (let c = 0; c < planar.length; c++) {
-        output[c][i] = planar[c][idx] * (1 - frac) + planar[c][idx + 1] * frac;
+    const channels = this.channels;
+    const native = this.native;
+    const target = this.target;
+    const last = this.last;
+    let phase = this.phase;
+
+    // A frame needs the input sample after its floor, so the block serves
+    // every position below inputLength - 1.
+    const end = (inputLength - 1) * target;
+    while (phase < end) {
+      const idx = Math.floor(phase / target);
+      const frac = (phase - idx * target) / target;
+      if (idx < 0) {
+        // Between the stored sample and this block's first.
+        for (let c = 0; c < channels; c++) {
+          this.buffer[this.bufferIndex++] = last[c] * (1 - frac) + planar[c][0] * frac;
+        }
+      } else {
+        for (let c = 0; c < channels; c++) {
+          this.buffer[this.bufferIndex++] = planar[c][idx] * (1 - frac) + planar[c][idx + 1] * frac;
+        }
       }
-      pos += this.ratio;
+      if (this.bufferIndex >= this.samplesPerChunk) {
+        this.flush();
+      }
+      phase += native;
     }
 
-    // Carry fractional remainder relative to consumed input.
-    this.position = Math.max(0, pos - inputLength);
-
-    return output;
+    // Carry the phase relative to the next block's first sample; it sits in
+    // [-target, native - target). Keep the block's last sample for the frame
+    // that may fall before that block begins.
+    this.phase = phase - inputLength * target;
+    for (let c = 0; c < channels; c++) last[c] = planar[c][inputLength - 1];
   }
 
   flush() {
     let transferBuffer;
 
     if (this.format === 'int16') {
+      // The posted buffer is transferred, so each chunk converts into a
+      // fresh Int16Array; the accumulation buffer stays and is refilled from
+      // its start.
       const int16 = new Int16Array(this.samplesPerChunk);
       for (let i = 0; i < this.samplesPerChunk; i++) {
         int16[i] = Math.max(-32768, Math.min(32767, Math.round(this.buffer[i] * 32768)));
       }
       transferBuffer = int16.buffer;
     } else {
-      transferBuffer = this.buffer.slice(0, this.samplesPerChunk).buffer;
+      // The accumulation buffer itself is transferred, so a fresh one
+      // replaces it.
+      transferBuffer = this.buffer.buffer;
+      this.buffer = new Float32Array(this.samplesPerChunk);
     }
 
     this.port.postMessage(transferBuffer, [transferBuffer]);
-
-    // Reset accumulation buffer
-    this.buffer = new Float32Array(this.samplesPerChunk);
     this.bufferIndex = 0;
   }
 }

package/src/decibri-output.js

@@ -242,7 +242,9 @@ class Speaker extends Writable {
   }
 
   /**
-   * Whether audio is currently being output.
+   * Whether the output stream is running: `true` once a non-empty write opens
+   * it, until `stop()`, `end()` once the queued audio has played, or a device
+   * failure. `drainAsync()` leaves it `true`.
    * @returns {boolean}
    */
   get isPlaying() {

package/src/decibri.d.ts

@@ -296,14 +296,12 @@ export interface MicrophoneOptions extends ReadableOptions {
    * and may name more delivered channels than the device has. Absent derives
    * the delivered channels from `channels` as documented there.
    *
-   * The same shape as CoreAudio AUHAL's channel map
-   * (`kAudioOutputUnitProperty_ChannelMap`: an array of device channel
-   * indices, one entry per client channel). NOT miniaudio's `channelMap`,
-   * which names a spatial layout. Entries are validated against the resolved
-   * device's own report when the stream starts: an entry the device does not
-   * have throws a `DecibriError` with code `'CHANNEL_MAP_OUT_OF_RANGE'` naming
-   * the entry and the count the device reports. The device's report is the
-   * only ceiling; no fixed maximum exists.
+   * The map selects device channels by index, one entry per delivered
+   * channel; it does not describe a spatial layout. Entries are validated
+   * against the resolved device's own report when the stream starts: an entry
+   * the device does not have throws a `DecibriError` with code
+   * `'CHANNEL_MAP_OUT_OF_RANGE'` naming the entry and the count the device
+   * reports. The device's report is the only ceiling; no fixed maximum exists.
    * @default undefined (the derivation `channels` documents)
    */
   channelMap?: number[];
@@ -772,7 +770,11 @@ export interface SaveReport {
   clippedSamples: number;
   /**
    * Non-finite samples replaced before writing: NaN with silence, an
-   * infinity with full scale. The same replacement on every format.
+   * infinity with full scale. The same replacement on every format. When
+   * the conditioning chain runs it has already replaced every non-finite
+   * sample with silence at its entry, so this count covers the direct path
+   * only (a mono source already at `sampleRate` with no conditioning
+   * enabled).
    */
   nonFiniteSamples: number;
 }
@@ -828,9 +830,10 @@ export declare class File extends Readable {
 
   /**
    * Wrap in-memory samples as an offline source. `samples` must be a
-   * `Float32Array` of mono samples in [-1.0, 1.0]; a raw `Buffer` of PCM
-   * bytes is rejected as ambiguous. `inputRate` is required (raw samples
-   * carry no header). Synchronous: no I/O is involved.
+   * `Float32Array` of samples in [-1.0, 1.0], frame-interleaved at
+   * `inputChannels` (1, mono, by default); a raw `Buffer` of PCM bytes is
+   * rejected as ambiguous. `inputRate` is required (raw samples carry no
+   * header). Synchronous: no I/O is involved.
    */
   static buffer(samples: Float32Array, options: FileBufferOptions): File;
 
@@ -876,15 +879,18 @@ export declare class File extends Readable {
   /**
    * Write the conditioned recording to disk, off the event loop. Runs the
    * recording once through the same conditioning pass iteration delivers,
-   * whole, and writes it as 16-bit PCM mono at `sampleRate`. The container
-   * comes from the path's extension (`.wav`, `.aiff`, `.aif`, `.aifc` or
-   * `.flac`), or from `options.format`: decibri reads a file by its content
-   * and writes one by its name. Consumes the source (a `File` is a single
-   * pass).
+   * whole, and writes it as 16-bit PCM at `sampleRate`, frame-interleaved at
+   * the delivered channel count. The container comes from the path's
+   * extension (`.wav`, `.aiff`, `.aif`, `.aifc` or `.flac`), or from
+   * `options.format`: decibri reads a file by its content and writes one by
+   * its name. Consumes the source (a `File` is a single pass).
    *
    * Resolves to a `SaveReport`: how many samples were clamped to full scale
    * and how many non-finite samples were replaced (NaN as silence, an
-   * infinity as full scale).
+   * infinity as full scale). When the conditioning chain runs it has already
+   * replaced every non-finite sample with silence at its entry, so the file
+   * carries silence where one was and the count covers the direct path only
+   * (a mono source already at `sampleRate` with no conditioning enabled).
    *
    * Requires a File that is not already being streamed: once the stream has
    * been engaged this rejects with a `DecibriError` carrying the code
@@ -928,9 +934,10 @@ export interface AudioWriterOptions extends SaveOptions, WritableOptions {
    * number of frames at this count. Bounded below at `1` (the default);
    * above it, each container's own ceiling applies (a FLAC frame carries at
    * most 8 channels; a WAV `fmt ` chunk's `nBlockAlign` is a 16-bit field,
-   * so 16-bit samples allow at most 32767), reported when the stream
-   * finishes as the container layer's own refusal. decibri enforces no
-   * ceiling of its own.
+   * so 16-bit samples allow at most 32767; an AIFF `COMM` chunk's
+   * `numChannels` is a signed 16-bit field, so at most 32767), reported
+   * when the stream finishes as the container layer's own refusal. decibri
+   * enforces no ceiling of its own.
    * @default 1
    */
   channels?: number;
@@ -1087,7 +1094,11 @@ export declare class Speaker extends Writable {
   /** Immediate stop. Discards remaining buffered audio. */
   stop(): void;
 
-  /** Whether audio is currently being output. */
+  /**
+   * Whether the output stream is running: `true` once a non-empty write opens
+   * it, until `stop()`, `end()` once the queued audio has played, or a device
+   * failure. `drainAsync()` leaves it `true`.
+   */
   readonly isPlaying: boolean;
 
   /**

package/src/decibri.js

@@ -25,18 +25,19 @@ const PACKAGE_VERSION = require('../package.json').version;
  *                                           file: bundled ORT dylib filename }
  *
  * Dylib filenames are unversioned across all platforms for consistency. The
- * release workflow (.github/workflows/release.yml) copies Microsoft's
- * versioned upstream tarball file (e.g. libonnxruntime.1.24.4.dylib) into the
+ * publish workflow (.github/workflows/publish-npm.yml) copies Microsoft's
+ * versioned upstream tarball file (e.g. libonnxruntime.1.28.1.dylib) into the
  * platform package with the unversioned name listed here.
  *
  * If you add a new platform, update this table AND the matching platform job
- * in release.yml.
+ * in publish-npm.yml.
  */
 const PLATFORM_DYLIB = {
   'darwin-arm64': { pkg: '@decibri/decibri-darwin-arm64',    file: 'libonnxruntime.dylib' },
   'linux-x64':    { pkg: '@decibri/decibri-linux-x64-gnu',   file: 'libonnxruntime.so' },
   'linux-arm64':  { pkg: '@decibri/decibri-linux-arm64-gnu', file: 'libonnxruntime.so' },
   'win32-x64':    { pkg: '@decibri/decibri-win32-x64-msvc',  file: 'onnxruntime.dll' },
+  'win32-arm64':  { pkg: '@decibri/decibri-win32-arm64-msvc', file: 'onnxruntime.dll' },
 };
 
 /**
@@ -899,7 +900,7 @@ class File extends Readable {
    * Validate the constructor options and resolve them into the native options
    * object plus the wrapper-side state. The checks and messages mirror
    * `Microphone._prepareOptions` exactly for every shared option; the
-   * live-capture-only options (device, channels, framesPerBuffer) do not
+   * live-capture-only options (device, framesPerBuffer, aec) do not
    * apply to an offline source.
    * @internal
    * @param {import('./decibri').FileOptions} options
@@ -1422,8 +1423,9 @@ class File extends Readable {
   /**
    * Write the conditioned recording to disk, off the event loop. Runs the
    * recording once through the same conditioning pass iteration delivers,
-   * whole, and writes it as 16-bit PCM mono at `sampleRate`. Consumes the
-   * source: a save is a single pass, separate from iteration and analysis.
+   * whole, and writes it as 16-bit PCM at `sampleRate`, frame-interleaved at
+   * the delivered channel count. Consumes the source: a save is a single
+   * pass, separate from iteration and analysis.
    *
    * The container comes from the path's extension (`.wav`, `.aiff`, `.aif`,
    * `.aifc` or `.flac`), or from `options.format`: decibri reads a file by
@@ -1435,7 +1437,11 @@ class File extends Readable {
    * outside full scale clamped to `[-1.0, 1.0]` (AGC or AEC without a
    * limiter can overshoot, and 16-bit PCM cannot hold it), and
    * `nonFiniteSamples` counts NaN samples written as silence and infinite
-   * samples written as full scale.
+   * samples written as full scale. When the conditioning chain runs it has
+   * already replaced every non-finite sample with silence at its entry, so
+   * the file carries silence where one was and `nonFiniteSamples` covers
+   * the direct path only (a mono source already at `sampleRate` with no
+   * conditioning enabled).
    *
    * Requires a `File` that is not already being streamed: once the stream
    * has been engaged this rejects with a `DecibriError` carrying the code