@memberjunction/ng-conversations 6.2.0-edge.3 → 6.2.0-edge.5

package/dist/lib/services/recording/libopus-worker-source.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Messages the main thread posts to the libopus Worker. The fields are PascalCase like every other MJ
+ * API shape; the worker source below reads them by these exact names.
+ */
+export type OpusWorkerRequest = {
+    Type: 'init';
+    Wasm: ArrayBuffer;
+} | {
+    Type: 'encode';
+    Pcm: Float32Array;
+} | {
+    Type: 'flush';
+    ID: number;
+};
+/** Messages the libopus Worker posts back. */
+export type OpusWorkerReply = {
+    Type: 'ready';
+} | {
+    Type: 'packets';
+    Packets: ArrayBuffer[];
+} | {
+    Type: 'flushed';
+    ID: number;
+} | {
+    Type: 'error';
+    Message: string;
+};
+/**
+ * JavaScript source of the libopus encoder Worker, started from a Blob URL.
+ *
+ * Why a source string: an Angular library cannot reliably ship a separate worker file that every
+ * host app's bundler would pick up, so — like the recorder's AudioWorklet processor — the worker is
+ * plain JS with no imports, built into a Blob at runtime. The wasm bytes arrive in the `init`
+ * message rather than being fetched, for the same reason.
+ *
+ * What it does: instantiates libopus (only stub WASI/env imports are needed), creates one encoder
+ * (48 kHz mono, OPUS_APPLICATION_VOIP = 2048, OPUS_SET_BITRATE = 4002 → 32 kbps), collects incoming
+ * Float32 samples into 960-sample (20 ms) frames, converts each to int16 and encodes it, and posts
+ * the packets back (buffers transferred). `flush` pads a pending partial frame with silence, encodes
+ * it, and answers `flushed` with the request's id. Messages that arrive while the module is still
+ * instantiating are queued and handled in order. After a fault, input is dropped and `flush` still
+ * answers, so the main thread never waits on a dead encoder. Typed-array views over wasm memory are
+ * re-created for every frame because memory may grow (and detach old views) on any allocation.
+ *
+ * It references `self` only, so tests can run it in Node with a fake `self`.
+ */
+export declare const LIBOPUS_WORKER_SOURCE = "\n'use strict';\nvar FRAME_SAMPLES = 960;\nvar MAX_PACKET_BYTES = 4000;\nvar SAMPLE_RATE = 48000;\nvar OPUS_APPLICATION_VOIP = 2048;\nvar OPUS_SET_BITRATE = 4002;\nvar BITRATE = 32000;\n\nvar wasm = null;\nvar encoder = 0;\nvar pcmPtr = 0;\nvar outPtr = 0;\nvar frame = new Float32Array(FRAME_SAMPLES);\nvar filled = 0;\nvar queue = [];\nvar failed = false;\n\nfunction describe(error) {\n    return error && error.message ? error.message : String(error);\n}\n\nfunction fail(message) {\n    failed = true;\n    self.postMessage({ Type: 'error', Message: message });\n}\n\nfunction postPackets(packets) {\n    if (packets.length > 0) {\n        self.postMessage({ Type: 'packets', Packets: packets }, packets);\n    }\n}\n\nfunction encodeFrame(packets) {\n    var view = new Int16Array(wasm.memory.buffer, pcmPtr, FRAME_SAMPLES);\n    for (var i = 0; i < FRAME_SAMPLES; i++) {\n        var s = frame[i];\n        s = s < -1 ? -1 : s > 1 ? 1 : s;\n        view[i] = s < 0 ? s * 32768 : s * 32767;\n    }\n    var length = wasm.opus_encode(encoder, pcmPtr, FRAME_SAMPLES, outPtr, MAX_PACKET_BYTES);\n    if (length < 0) {\n        throw new Error('opus_encode returned ' + length);\n    }\n    packets.push(new Uint8Array(wasm.memory.buffer, outPtr, length).slice().buffer);\n}\n\nfunction encode(pcm) {\n    var packets = [];\n    var offset = 0;\n    while (offset < pcm.length) {\n        var take = Math.min(FRAME_SAMPLES - filled, pcm.length - offset);\n        frame.set(pcm.subarray(offset, offset + take), filled);\n        filled += take;\n        offset += take;\n        if (filled === FRAME_SAMPLES) {\n            encodeFrame(packets);\n            filled = 0;\n        }\n    }\n    postPackets(packets);\n}\n\nfunction flush(id) {\n    var packets = [];\n    if (filled > 0) {\n        frame.fill(0, filled);\n        encodeFrame(packets);\n        filled = 0;\n    }\n    postPackets(packets);\n    self.postMessage({ Type: 'flushed', ID: id });\n}\n\nfunction handle(message) {\n    if (failed) {\n        if (message.Type === 'flush') {\n            self.postMessage({ Type: 'flushed', ID: message.ID });\n        }\n        return;\n    }\n    try {\n        if (message.Type === 'encode') {\n            encode(message.Pcm);\n        } else if (message.Type === 'flush') {\n            flush(message.ID);\n        }\n    } catch (error) {\n        fail('libopus ' + message.Type + ' failed: ' + describe(error));\n        if (message.Type === 'flush') {\n            self.postMessage({ Type: 'flushed', ID: message.ID });\n        }\n    }\n}\n\nfunction drainQueue() {\n    var pending = queue;\n    queue = [];\n    for (var i = 0; i < pending.length; i++) {\n        handle(pending[i]);\n    }\n}\n\nfunction init(bytes) {\n    var imports = {\n        wasi_snapshot_preview1: {\n            fd_seek: function () { return 0; },\n            fd_write: function () { return 0; },\n            fd_close: function () { return 0; },\n            proc_exit: function () {}\n        },\n        // Views are re-created per frame, so there is nothing to refresh when memory grows.\n        env: { emscripten_notify_memory_growth: function () {} }\n    };\n    WebAssembly.instantiate(bytes, imports).then(function (result) {\n        var exports = result.instance.exports;\n        var state = exports.malloc(exports.opus_encoder_get_size(1));\n        var rc = exports.opus_encoder_init(state, SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP);\n        if (rc !== 0) {\n            throw new Error('opus_encoder_init returned ' + rc);\n        }\n        rc = exports.opus_encoder_ctl_set(state, OPUS_SET_BITRATE, BITRATE);\n        if (rc !== 0) {\n            throw new Error('opus_encoder_ctl_set(OPUS_SET_BITRATE) returned ' + rc);\n        }\n        wasm = exports;\n        encoder = state;\n        pcmPtr = exports.malloc(FRAME_SAMPLES * 2);\n        outPtr = exports.malloc(MAX_PACKET_BYTES);\n        self.postMessage({ Type: 'ready' });\n        drainQueue();\n    }).catch(function (error) {\n        fail('libopus init failed: ' + describe(error));\n        drainQueue();\n    });\n}\n\nself.onmessage = function (event) {\n    var message = event.data;\n    if (message.Type === 'init') {\n        init(message.Wasm);\n        return;\n    }\n    if (!wasm && !failed) {\n        queue.push(message);\n        return;\n    }\n    handle(message);\n};\n";
+//# sourceMappingURL=libopus-worker-source.d.ts.map

package/dist/lib/services/recording/libopus-worker-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"libopus-worker-source.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/recording/libopus-worker-source.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GACvB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,WAAW,CAAA;CAAE,GACnC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,GAAG,EAAE,YAAY,CAAA;CAAE,GACrC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpC,8CAA8C;AAC9C,MAAM,MAAM,eAAe,GACrB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,OAAO,EAAE,WAAW,EAAE,CAAA;CAAE,GAC3C;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAC/B;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,yxIAqJjC,CAAC"}

package/dist/lib/services/recording/libopus-worker-source.js

@@ -0,0 +1,170 @@
+/**
+ * JavaScript source of the libopus encoder Worker, started from a Blob URL.
+ *
+ * Why a source string: an Angular library cannot reliably ship a separate worker file that every
+ * host app's bundler would pick up, so — like the recorder's AudioWorklet processor — the worker is
+ * plain JS with no imports, built into a Blob at runtime. The wasm bytes arrive in the `init`
+ * message rather than being fetched, for the same reason.
+ *
+ * What it does: instantiates libopus (only stub WASI/env imports are needed), creates one encoder
+ * (48 kHz mono, OPUS_APPLICATION_VOIP = 2048, OPUS_SET_BITRATE = 4002 → 32 kbps), collects incoming
+ * Float32 samples into 960-sample (20 ms) frames, converts each to int16 and encodes it, and posts
+ * the packets back (buffers transferred). `flush` pads a pending partial frame with silence, encodes
+ * it, and answers `flushed` with the request's id. Messages that arrive while the module is still
+ * instantiating are queued and handled in order. After a fault, input is dropped and `flush` still
+ * answers, so the main thread never waits on a dead encoder. Typed-array views over wasm memory are
+ * re-created for every frame because memory may grow (and detach old views) on any allocation.
+ *
+ * It references `self` only, so tests can run it in Node with a fake `self`.
+ */
+export const LIBOPUS_WORKER_SOURCE = `
+'use strict';
+var FRAME_SAMPLES = 960;
+var MAX_PACKET_BYTES = 4000;
+var SAMPLE_RATE = 48000;
+var OPUS_APPLICATION_VOIP = 2048;
+var OPUS_SET_BITRATE = 4002;
+var BITRATE = 32000;
+
+var wasm = null;
+var encoder = 0;
+var pcmPtr = 0;
+var outPtr = 0;
+var frame = new Float32Array(FRAME_SAMPLES);
+var filled = 0;
+var queue = [];
+var failed = false;
+
+function describe(error) {
+    return error && error.message ? error.message : String(error);
+}
+
+function fail(message) {
+    failed = true;
+    self.postMessage({ Type: 'error', Message: message });
+}
+
+function postPackets(packets) {
+    if (packets.length > 0) {
+        self.postMessage({ Type: 'packets', Packets: packets }, packets);
+    }
+}
+
+function encodeFrame(packets) {
+    var view = new Int16Array(wasm.memory.buffer, pcmPtr, FRAME_SAMPLES);
+    for (var i = 0; i < FRAME_SAMPLES; i++) {
+        var s = frame[i];
+        s = s < -1 ? -1 : s > 1 ? 1 : s;
+        view[i] = s < 0 ? s * 32768 : s * 32767;
+    }
+    var length = wasm.opus_encode(encoder, pcmPtr, FRAME_SAMPLES, outPtr, MAX_PACKET_BYTES);
+    if (length < 0) {
+        throw new Error('opus_encode returned ' + length);
+    }
+    packets.push(new Uint8Array(wasm.memory.buffer, outPtr, length).slice().buffer);
+}
+
+function encode(pcm) {
+    var packets = [];
+    var offset = 0;
+    while (offset < pcm.length) {
+        var take = Math.min(FRAME_SAMPLES - filled, pcm.length - offset);
+        frame.set(pcm.subarray(offset, offset + take), filled);
+        filled += take;
+        offset += take;
+        if (filled === FRAME_SAMPLES) {
+            encodeFrame(packets);
+            filled = 0;
+        }
+    }
+    postPackets(packets);
+}
+
+function flush(id) {
+    var packets = [];
+    if (filled > 0) {
+        frame.fill(0, filled);
+        encodeFrame(packets);
+        filled = 0;
+    }
+    postPackets(packets);
+    self.postMessage({ Type: 'flushed', ID: id });
+}
+
+function handle(message) {
+    if (failed) {
+        if (message.Type === 'flush') {
+            self.postMessage({ Type: 'flushed', ID: message.ID });
+        }
+        return;
+    }
+    try {
+        if (message.Type === 'encode') {
+            encode(message.Pcm);
+        } else if (message.Type === 'flush') {
+            flush(message.ID);
+        }
+    } catch (error) {
+        fail('libopus ' + message.Type + ' failed: ' + describe(error));
+        if (message.Type === 'flush') {
+            self.postMessage({ Type: 'flushed', ID: message.ID });
+        }
+    }
+}
+
+function drainQueue() {
+    var pending = queue;
+    queue = [];
+    for (var i = 0; i < pending.length; i++) {
+        handle(pending[i]);
+    }
+}
+
+function init(bytes) {
+    var imports = {
+        wasi_snapshot_preview1: {
+            fd_seek: function () { return 0; },
+            fd_write: function () { return 0; },
+            fd_close: function () { return 0; },
+            proc_exit: function () {}
+        },
+        // Views are re-created per frame, so there is nothing to refresh when memory grows.
+        env: { emscripten_notify_memory_growth: function () {} }
+    };
+    WebAssembly.instantiate(bytes, imports).then(function (result) {
+        var exports = result.instance.exports;
+        var state = exports.malloc(exports.opus_encoder_get_size(1));
+        var rc = exports.opus_encoder_init(state, SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP);
+        if (rc !== 0) {
+            throw new Error('opus_encoder_init returned ' + rc);
+        }
+        rc = exports.opus_encoder_ctl_set(state, OPUS_SET_BITRATE, BITRATE);
+        if (rc !== 0) {
+            throw new Error('opus_encoder_ctl_set(OPUS_SET_BITRATE) returned ' + rc);
+        }
+        wasm = exports;
+        encoder = state;
+        pcmPtr = exports.malloc(FRAME_SAMPLES * 2);
+        outPtr = exports.malloc(MAX_PACKET_BYTES);
+        self.postMessage({ Type: 'ready' });
+        drainQueue();
+    }).catch(function (error) {
+        fail('libopus init failed: ' + describe(error));
+        drainQueue();
+    });
+}
+
+self.onmessage = function (event) {
+    var message = event.data;
+    if (message.Type === 'init') {
+        init(message.Wasm);
+        return;
+    }
+    if (!wasm && !failed) {
+        queue.push(message);
+        return;
+    }
+    handle(message);
+};
+`;
+//# sourceMappingURL=libopus-worker-source.js.map

package/dist/lib/services/recording/libopus-worker-source.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"libopus-worker-source.js","sourceRoot":"","sources":["../../../../src/lib/services/recording/libopus-worker-source.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqJpC,CAAC","sourcesContent":["/**\n * Messages the main thread posts to the libopus Worker. The fields are PascalCase like every other MJ\n * API shape; the worker source below reads them by these exact names.\n */\nexport type OpusWorkerRequest =\n    | { Type: 'init'; Wasm: ArrayBuffer }\n    | { Type: 'encode'; Pcm: Float32Array }\n    | { Type: 'flush'; ID: number };\n\n/** Messages the libopus Worker posts back. */\nexport type OpusWorkerReply =\n    | { Type: 'ready' }\n    | { Type: 'packets'; Packets: ArrayBuffer[] }\n    | { Type: 'flushed'; ID: number }\n    | { Type: 'error'; Message: string };\n\n/**\n * JavaScript source of the libopus encoder Worker, started from a Blob URL.\n *\n * Why a source string: an Angular library cannot reliably ship a separate worker file that every\n * host app's bundler would pick up, so — like the recorder's AudioWorklet processor — the worker is\n * plain JS with no imports, built into a Blob at runtime. The wasm bytes arrive in the `init`\n * message rather than being fetched, for the same reason.\n *\n * What it does: instantiates libopus (only stub WASI/env imports are needed), creates one encoder\n * (48 kHz mono, OPUS_APPLICATION_VOIP = 2048, OPUS_SET_BITRATE = 4002 → 32 kbps), collects incoming\n * Float32 samples into 960-sample (20 ms) frames, converts each to int16 and encodes it, and posts\n * the packets back (buffers transferred). `flush` pads a pending partial frame with silence, encodes\n * it, and answers `flushed` with the request's id. Messages that arrive while the module is still\n * instantiating are queued and handled in order. After a fault, input is dropped and `flush` still\n * answers, so the main thread never waits on a dead encoder. Typed-array views over wasm memory are\n * re-created for every frame because memory may grow (and detach old views) on any allocation.\n *\n * It references `self` only, so tests can run it in Node with a fake `self`.\n */\nexport const LIBOPUS_WORKER_SOURCE = `\n'use strict';\nvar FRAME_SAMPLES = 960;\nvar MAX_PACKET_BYTES = 4000;\nvar SAMPLE_RATE = 48000;\nvar OPUS_APPLICATION_VOIP = 2048;\nvar OPUS_SET_BITRATE = 4002;\nvar BITRATE = 32000;\n\nvar wasm = null;\nvar encoder = 0;\nvar pcmPtr = 0;\nvar outPtr = 0;\nvar frame = new Float32Array(FRAME_SAMPLES);\nvar filled = 0;\nvar queue = [];\nvar failed = false;\n\nfunction describe(error) {\n    return error && error.message ? error.message : String(error);\n}\n\nfunction fail(message) {\n    failed = true;\n    self.postMessage({ Type: 'error', Message: message });\n}\n\nfunction postPackets(packets) {\n    if (packets.length > 0) {\n        self.postMessage({ Type: 'packets', Packets: packets }, packets);\n    }\n}\n\nfunction encodeFrame(packets) {\n    var view = new Int16Array(wasm.memory.buffer, pcmPtr, FRAME_SAMPLES);\n    for (var i = 0; i < FRAME_SAMPLES; i++) {\n        var s = frame[i];\n        s = s < -1 ? -1 : s > 1 ? 1 : s;\n        view[i] = s < 0 ? s * 32768 : s * 32767;\n    }\n    var length = wasm.opus_encode(encoder, pcmPtr, FRAME_SAMPLES, outPtr, MAX_PACKET_BYTES);\n    if (length < 0) {\n        throw new Error('opus_encode returned ' + length);\n    }\n    packets.push(new Uint8Array(wasm.memory.buffer, outPtr, length).slice().buffer);\n}\n\nfunction encode(pcm) {\n    var packets = [];\n    var offset = 0;\n    while (offset < pcm.length) {\n        var take = Math.min(FRAME_SAMPLES - filled, pcm.length - offset);\n        frame.set(pcm.subarray(offset, offset + take), filled);\n        filled += take;\n        offset += take;\n        if (filled === FRAME_SAMPLES) {\n            encodeFrame(packets);\n            filled = 0;\n        }\n    }\n    postPackets(packets);\n}\n\nfunction flush(id) {\n    var packets = [];\n    if (filled > 0) {\n        frame.fill(0, filled);\n        encodeFrame(packets);\n        filled = 0;\n    }\n    postPackets(packets);\n    self.postMessage({ Type: 'flushed', ID: id });\n}\n\nfunction handle(message) {\n    if (failed) {\n        if (message.Type === 'flush') {\n            self.postMessage({ Type: 'flushed', ID: message.ID });\n        }\n        return;\n    }\n    try {\n        if (message.Type === 'encode') {\n            encode(message.Pcm);\n        } else if (message.Type === 'flush') {\n            flush(message.ID);\n        }\n    } catch (error) {\n        fail('libopus ' + message.Type + ' failed: ' + describe(error));\n        if (message.Type === 'flush') {\n            self.postMessage({ Type: 'flushed', ID: message.ID });\n        }\n    }\n}\n\nfunction drainQueue() {\n    var pending = queue;\n    queue = [];\n    for (var i = 0; i < pending.length; i++) {\n        handle(pending[i]);\n    }\n}\n\nfunction init(bytes) {\n    var imports = {\n        wasi_snapshot_preview1: {\n            fd_seek: function () { return 0; },\n            fd_write: function () { return 0; },\n            fd_close: function () { return 0; },\n            proc_exit: function () {}\n        },\n        // Views are re-created per frame, so there is nothing to refresh when memory grows.\n        env: { emscripten_notify_memory_growth: function () {} }\n    };\n    WebAssembly.instantiate(bytes, imports).then(function (result) {\n        var exports = result.instance.exports;\n        var state = exports.malloc(exports.opus_encoder_get_size(1));\n        var rc = exports.opus_encoder_init(state, SAMPLE_RATE, 1, OPUS_APPLICATION_VOIP);\n        if (rc !== 0) {\n            throw new Error('opus_encoder_init returned ' + rc);\n        }\n        rc = exports.opus_encoder_ctl_set(state, OPUS_SET_BITRATE, BITRATE);\n        if (rc !== 0) {\n            throw new Error('opus_encoder_ctl_set(OPUS_SET_BITRATE) returned ' + rc);\n        }\n        wasm = exports;\n        encoder = state;\n        pcmPtr = exports.malloc(FRAME_SAMPLES * 2);\n        outPtr = exports.malloc(MAX_PACKET_BYTES);\n        self.postMessage({ Type: 'ready' });\n        drainQueue();\n    }).catch(function (error) {\n        fail('libopus init failed: ' + describe(error));\n        drainQueue();\n    });\n}\n\nself.onmessage = function (event) {\n    var message = event.data;\n    if (message.Type === 'init') {\n        init(message.Wasm);\n        return;\n    }\n    if (!wasm && !failed) {\n        queue.push(message);\n        return;\n    }\n    handle(message);\n};\n`;\n"]}

package/dist/lib/services/recording/linear-resampler.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Streaming linear-interpolation resampler for mono Float32 PCM.
+ *
+ * The recorder asks the browser for a 48 kHz `AudioContext`; when a browser refuses that rate the
+ * capture runs at the device rate (typically 44.1 kHz) and every captured frame passes through one
+ * of these before it reaches the Opus encoder, which only takes 48 kHz.
+ *
+ * Why the arithmetic is all integers: the recording's timing is the 48 kHz sample count, so the
+ * number of output samples must track `inputSamples × toRate / fromRate` exactly over a whole call,
+ * not drift by a sample per frame. Output sample `k` sits at input position `k × from / to`
+ * (with `from`/`to` reduced by their GCD); the resampler emits every `k` whose position has been
+ * captured, so after `N` input samples it has emitted `floor((N − 1) × to / from) + 1`. That never
+ * runs ahead of the ideal `N × to / from` and never lags it by more than one input-sample interval
+ * (`to / from` output samples, ≈ 1.09 at 44.1 → 48 kHz) — the next output is waiting for the input
+ * sample it interpolates towards — and the error never accumulates over a call. Positions stay
+ * exact integers for over a month of continuous audio.
+ *
+ * Linear interpolation is deliberately simple: the signal is speech headed for a 32 kbps voice
+ * codec, so a windowed-sinc filter would cost CPU on the audio thread for no audible gain.
+ */
+export declare class LinearResampler {
+    /** Reduced input-rate term (`fromRate / gcd`). */
+    private readonly from;
+    /** Reduced output-rate term (`toRate / gcd`). */
+    private readonly to;
+    private readonly passthrough;
+    /** Input samples consumed so far (absolute index of the next input sample). */
+    private consumed;
+    /** Output samples emitted so far (index `k` of the next output sample). */
+    private produced;
+    /** The previous block's last sample; the next output can sit between it and the new block. */
+    private lastSample;
+    /**
+     * @param fromRate capture rate in Hz (a positive integer, e.g. 44100)
+     * @param toRate target rate in Hz (a positive integer, e.g. 48000)
+     */
+    constructor(fromRate: number, toRate: number);
+    /**
+     * Resamples the next block of the stream. Blocks may be any length (including 0); state carries
+     * across calls, so a stream fed in uneven chunks yields the same samples as one fed whole.
+     * On a passthrough resampler (equal rates) the input array itself is returned, not a copy.
+     */
+    Process(input: Float32Array): Float32Array;
+}
+//# sourceMappingURL=linear-resampler.d.ts.map

package/dist/lib/services/recording/linear-resampler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-resampler.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/recording/linear-resampler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,eAAe;IACxB,kDAAkD;IAClD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,iDAAiD;IACjD,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAU;IACtC,+EAA+E;IAC/E,OAAO,CAAC,QAAQ,CAAK;IACrB,2EAA2E;IAC3E,OAAO,CAAC,QAAQ,CAAK;IACrB,8FAA8F;IAC9F,OAAO,CAAC,UAAU,CAAK;IAEvB;;;OAGG;gBACS,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IAU5C;;;;OAIG;IACI,OAAO,CAAC,KAAK,EAAE,YAAY,GAAG,YAAY;CAuBpD"}

package/dist/lib/services/recording/linear-resampler.js

@@ -0,0 +1,85 @@
+/**
+ * Streaming linear-interpolation resampler for mono Float32 PCM.
+ *
+ * The recorder asks the browser for a 48 kHz `AudioContext`; when a browser refuses that rate the
+ * capture runs at the device rate (typically 44.1 kHz) and every captured frame passes through one
+ * of these before it reaches the Opus encoder, which only takes 48 kHz.
+ *
+ * Why the arithmetic is all integers: the recording's timing is the 48 kHz sample count, so the
+ * number of output samples must track `inputSamples × toRate / fromRate` exactly over a whole call,
+ * not drift by a sample per frame. Output sample `k` sits at input position `k × from / to`
+ * (with `from`/`to` reduced by their GCD); the resampler emits every `k` whose position has been
+ * captured, so after `N` input samples it has emitted `floor((N − 1) × to / from) + 1`. That never
+ * runs ahead of the ideal `N × to / from` and never lags it by more than one input-sample interval
+ * (`to / from` output samples, ≈ 1.09 at 44.1 → 48 kHz) — the next output is waiting for the input
+ * sample it interpolates towards — and the error never accumulates over a call. Positions stay
+ * exact integers for over a month of continuous audio.
+ *
+ * Linear interpolation is deliberately simple: the signal is speech headed for a 32 kbps voice
+ * codec, so a windowed-sinc filter would cost CPU on the audio thread for no audible gain.
+ */
+export class LinearResampler {
+    /** Reduced input-rate term (`fromRate / gcd`). */
+    from;
+    /** Reduced output-rate term (`toRate / gcd`). */
+    to;
+    passthrough;
+    /** Input samples consumed so far (absolute index of the next input sample). */
+    consumed = 0;
+    /** Output samples emitted so far (index `k` of the next output sample). */
+    produced = 0;
+    /** The previous block's last sample; the next output can sit between it and the new block. */
+    lastSample = 0;
+    /**
+     * @param fromRate capture rate in Hz (a positive integer, e.g. 44100)
+     * @param toRate target rate in Hz (a positive integer, e.g. 48000)
+     */
+    constructor(fromRate, toRate) {
+        if (!Number.isInteger(fromRate) || fromRate <= 0 || !Number.isInteger(toRate) || toRate <= 0) {
+            throw new Error(`LinearResampler needs positive integer rates, got ${fromRate} → ${toRate}`);
+        }
+        const divisor = greatestCommonDivisor(fromRate, toRate);
+        this.from = fromRate / divisor;
+        this.to = toRate / divisor;
+        this.passthrough = fromRate === toRate;
+    }
+    /**
+     * Resamples the next block of the stream. Blocks may be any length (including 0); state carries
+     * across calls, so a stream fed in uneven chunks yields the same samples as one fed whole.
+     * On a passthrough resampler (equal rates) the input array itself is returned, not a copy.
+     */
+    Process(input) {
+        if (this.passthrough || input.length === 0) {
+            return this.passthrough ? input : new Float32Array(0);
+        }
+        const base = this.consumed;
+        const total = base + input.length;
+        // Last output index whose position k*from/to is <= total-1 (the newest captured sample).
+        const lastIndex = Math.floor(((total - 1) * this.to) / this.from);
+        const count = Math.max(0, lastIndex - this.produced + 1);
+        const output = new Float32Array(count);
+        for (let n = 0; n < count; n++) {
+            const scaled = (this.produced + n) * this.from;
+            const index = Math.floor(scaled / this.to);
+            const remainder = scaled - index * this.to;
+            const left = index < base ? this.lastSample : input[index - base];
+            // remainder > 0 implies index < total-1, so index+1 is always captured.
+            output[n] = remainder === 0 ? left : left + ((input[index + 1 - base] - left) * remainder) / this.to;
+        }
+        this.produced += count;
+        this.consumed = total;
+        this.lastSample = input[input.length - 1];
+        return output;
+    }
+}
+function greatestCommonDivisor(a, b) {
+    let x = a;
+    let y = b;
+    while (y !== 0) {
+        const t = x % y;
+        x = y;
+        y = t;
+    }
+    return x;
+}
+//# sourceMappingURL=linear-resampler.js.map

package/dist/lib/services/recording/linear-resampler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"linear-resampler.js","sourceRoot":"","sources":["../../../../src/lib/services/recording/linear-resampler.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Streaming linear-interpolation resampler for mono Float32 PCM.\n *\n * The recorder asks the browser for a 48 kHz `AudioContext`; when a browser refuses that rate the\n * capture runs at the device rate (typically 44.1 kHz) and every captured frame passes through one\n * of these before it reaches the Opus encoder, which only takes 48 kHz.\n *\n * Why the arithmetic is all integers: the recording's timing is the 48 kHz sample count, so the\n * number of output samples must track `inputSamples × toRate / fromRate` exactly over a whole call,\n * not drift by a sample per frame. Output sample `k` sits at input position `k × from / to`\n * (with `from`/`to` reduced by their GCD); the resampler emits every `k` whose position has been\n * captured, so after `N` input samples it has emitted `floor((N − 1) × to / from) + 1`. That never\n * runs ahead of the ideal `N × to / from` and never lags it by more than one input-sample interval\n * (`to / from` output samples, ≈ 1.09 at 44.1 → 48 kHz) — the next output is waiting for the input\n * sample it interpolates towards — and the error never accumulates over a call. Positions stay\n * exact integers for over a month of continuous audio.\n *\n * Linear interpolation is deliberately simple: the signal is speech headed for a 32 kbps voice\n * codec, so a windowed-sinc filter would cost CPU on the audio thread for no audible gain.\n */\nexport class LinearResampler {\n    /** Reduced input-rate term (`fromRate / gcd`). */\n    private readonly from: number;\n    /** Reduced output-rate term (`toRate / gcd`). */\n    private readonly to: number;\n    private readonly passthrough: boolean;\n    /** Input samples consumed so far (absolute index of the next input sample). */\n    private consumed = 0;\n    /** Output samples emitted so far (index `k` of the next output sample). */\n    private produced = 0;\n    /** The previous block's last sample; the next output can sit between it and the new block. */\n    private lastSample = 0;\n\n    /**\n     * @param fromRate capture rate in Hz (a positive integer, e.g. 44100)\n     * @param toRate target rate in Hz (a positive integer, e.g. 48000)\n     */\n    constructor(fromRate: number, toRate: number) {\n        if (!Number.isInteger(fromRate) || fromRate <= 0 || !Number.isInteger(toRate) || toRate <= 0) {\n            throw new Error(`LinearResampler needs positive integer rates, got ${fromRate} → ${toRate}`);\n        }\n        const divisor = greatestCommonDivisor(fromRate, toRate);\n        this.from = fromRate / divisor;\n        this.to = toRate / divisor;\n        this.passthrough = fromRate === toRate;\n    }\n\n    /**\n     * Resamples the next block of the stream. Blocks may be any length (including 0); state carries\n     * across calls, so a stream fed in uneven chunks yields the same samples as one fed whole.\n     * On a passthrough resampler (equal rates) the input array itself is returned, not a copy.\n     */\n    public Process(input: Float32Array): Float32Array {\n        if (this.passthrough || input.length === 0) {\n            return this.passthrough ? input : new Float32Array(0);\n        }\n        const base = this.consumed;\n        const total = base + input.length;\n        // Last output index whose position k*from/to is <= total-1 (the newest captured sample).\n        const lastIndex = Math.floor(((total - 1) * this.to) / this.from);\n        const count = Math.max(0, lastIndex - this.produced + 1);\n        const output = new Float32Array(count);\n        for (let n = 0; n < count; n++) {\n            const scaled = (this.produced + n) * this.from;\n            const index = Math.floor(scaled / this.to);\n            const remainder = scaled - index * this.to;\n            const left = index < base ? this.lastSample : input[index - base];\n            // remainder > 0 implies index < total-1, so index+1 is always captured.\n            output[n] = remainder === 0 ? left : left + ((input[index + 1 - base] - left) * remainder) / this.to;\n        }\n        this.produced += count;\n        this.consumed = total;\n        this.lastSample = input[input.length - 1];\n        return output;\n    }\n}\n\nfunction greatestCommonDivisor(a: number, b: number): number {\n    let x = a;\n    let y = b;\n    while (y !== 0) {\n        const t = x % y;\n        x = y;\n        y = t;\n    }\n    return x;\n}\n"]}

package/dist/lib/services/recording/opus-packet-encoder.d.ts

@@ -0,0 +1,50 @@
+import { AudioDataConstructor, AudioEncoderConstructor } from './webcodecs-opus-encoder';
+/**
+ * One continuous Opus encoder for a whole call: mono, 48 kHz, 32 kbps, 20 ms (960-sample) packets.
+ *
+ * Every packet it emits is one raw Opus packet (no container), in capture order. The runtime cuts
+ * that stream into `MJOPUS1` shards and the server decodes all packets with one libopus decoder,
+ * which is why the call must keep a single encoder from start to finish: encoder state carries
+ * across packets, so switching encoders mid-call would corrupt the join.
+ */
+export interface IOpusPacketEncoder {
+    /** Which implementation this is, for logs and tests. */
+    readonly Kind: 'webcodecs' | 'wasm';
+    /**
+     * Queues 48 kHz mono samples for encoding. Any length; the encoder frames them into 960-sample
+     * packets itself. The caller keeps ownership of `pcm48k` (the encoder copies what it needs).
+     * Never throws: an encoder fault is logged and later input is dropped.
+     */
+    Encode(pcm48k: Float32Array): void;
+    /**
+     * Encodes everything queued, padding a final partial frame with silence, and resolves once those
+     * packets are available to {@link TakePackets}. Never rejects; a fault or timeout is logged.
+     */
+    Flush(): Promise<void>;
+    /** Returns the packets produced since the previous call and forgets them. Works after {@link Close}. */
+    TakePackets(): Uint8Array[];
+    /** Releases the encoder. Idempotent; packets already produced stay available to {@link TakePackets}. */
+    Close(): void;
+}
+/** The platform pieces {@link SelectOpusPacketEncoder} chooses between. Injectable for tests. */
+export interface OpusEncoderEnvironment {
+    /** The WebCodecs `AudioEncoder` constructor, or `null` where the platform has none. */
+    AudioEncoder: AudioEncoderConstructor | null;
+    /** The WebCodecs `AudioData` constructor, or `null` where the platform has none. */
+    AudioData: AudioDataConstructor | null;
+    /** Starts the libopus WebAssembly encoder (the fallback). */
+    CreateWasmEncoder: () => Promise<IOpusPacketEncoder>;
+}
+/** The real browser environment: WebCodecs globals when present, the libopus Worker otherwise. */
+export declare function BrowserOpusEncoderEnvironment(): OpusEncoderEnvironment;
+/**
+ * Picks the call's encoder, once, at recording start.
+ *
+ * WebCodecs is preferred (native, no 440 KB download) but only when the browser says it can encode
+ * exactly our configuration: `AudioEncoder` existing is not enough, because Safari shipped
+ * `AudioEncoder` long before it supported Opus in it. Anything else — no WebCodecs, an unsupported
+ * config, a support probe or configure that throws — falls back to libopus in a Worker. A failure
+ * of the fallback rejects, and the recorder treats that as "recording off" for the call.
+ */
+export declare function SelectOpusPacketEncoder(env?: OpusEncoderEnvironment): Promise<IOpusPacketEncoder>;
+//# sourceMappingURL=opus-packet-encoder.d.ts.map

package/dist/lib/services/recording/opus-packet-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opus-packet-encoder.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/recording/opus-packet-encoder.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,oBAAoB,EACpB,uBAAuB,EAG1B,MAAM,0BAA0B,CAAC;AAElC;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IAC/B,wDAAwD;IACxD,QAAQ,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAAC;IACpC;;;;OAIG;IACH,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI,CAAC;IACnC;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,wGAAwG;IACxG,WAAW,IAAI,UAAU,EAAE,CAAC;IAC5B,wGAAwG;IACxG,KAAK,IAAI,IAAI,CAAC;CACjB;AAED,iGAAiG;AACjG,MAAM,WAAW,sBAAsB;IACnC,uFAAuF;IACvF,YAAY,EAAE,uBAAuB,GAAG,IAAI,CAAC;IAC7C,oFAAoF;IACpF,SAAS,EAAE,oBAAoB,GAAG,IAAI,CAAC;IACvC,6DAA6D;IAC7D,iBAAiB,EAAE,MAAM,OAAO,CAAC,kBAAkB,CAAC,CAAC;CACxD;AAED,kGAAkG;AAClG,wBAAgB,6BAA6B,IAAI,sBAAsB,CAMtE;AAED;;;;;;;;GAQG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,GAAE,sBAAwD,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAGxI"}

package/dist/lib/services/recording/opus-packet-encoder.js

@@ -0,0 +1,41 @@
+import { RECORDING_SAMPLE_RATE } from '@memberjunction/ai-core-plus';
+import { WasmOpusEncoder } from './wasm-opus-encoder';
+import { WEBCODECS_OPUS_CONFIG, WebCodecsOpusEncoder, } from './webcodecs-opus-encoder';
+/** The real browser environment: WebCodecs globals when present, the libopus Worker otherwise. */
+export function BrowserOpusEncoderEnvironment() {
+    return {
+        AudioEncoder: typeof AudioEncoder === 'undefined' ? null : AudioEncoder,
+        AudioData: typeof AudioData === 'undefined' ? null : AudioData,
+        CreateWasmEncoder: () => WasmOpusEncoder.Create(),
+    };
+}
+/**
+ * Picks the call's encoder, once, at recording start.
+ *
+ * WebCodecs is preferred (native, no 440 KB download) but only when the browser says it can encode
+ * exactly our configuration: `AudioEncoder` existing is not enough, because Safari shipped
+ * `AudioEncoder` long before it supported Opus in it. Anything else — no WebCodecs, an unsupported
+ * config, a support probe or configure that throws — falls back to libopus in a Worker. A failure
+ * of the fallback rejects, and the recorder treats that as "recording off" for the call.
+ */
+export async function SelectOpusPacketEncoder(env = BrowserOpusEncoderEnvironment()) {
+    const webCodecs = await tryCreateWebCodecsEncoder(env);
+    return webCodecs ?? env.CreateWasmEncoder();
+}
+async function tryCreateWebCodecsEncoder(env) {
+    if (!env.AudioEncoder || !env.AudioData) {
+        return null;
+    }
+    try {
+        const support = await env.AudioEncoder.isConfigSupported(WEBCODECS_OPUS_CONFIG);
+        if (support.supported !== true) {
+            return null;
+        }
+        return new WebCodecsOpusEncoder(env.AudioEncoder, env.AudioData);
+    }
+    catch (error) {
+        console.warn(`[OpusPacketEncoder] WebCodecs Opus at ${RECORDING_SAMPLE_RATE} Hz could not be set up — using the libopus WebAssembly encoder instead:`, error);
+        return null;
+    }
+}
+//# sourceMappingURL=opus-packet-encoder.js.map

package/dist/lib/services/recording/opus-packet-encoder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opus-packet-encoder.js","sourceRoot":"","sources":["../../../../src/lib/services/recording/opus-packet-encoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAGH,qBAAqB,EACrB,oBAAoB,GACvB,MAAM,0BAA0B,CAAC;AAwClC,kGAAkG;AAClG,MAAM,UAAU,6BAA6B;IACzC,OAAO;QACH,YAAY,EAAE,OAAO,YAAY,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,YAAY;QACvE,SAAS,EAAE,OAAO,SAAS,KAAK,WAAW,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;QAC9D,iBAAiB,EAAE,GAAG,EAAE,CAAC,eAAe,CAAC,MAAM,EAAE;KACpD,CAAC;AACN,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB,CAAC,MAA8B,6BAA6B,EAAE;IACvG,MAAM,SAAS,GAAG,MAAM,yBAAyB,CAAC,GAAG,CAAC,CAAC;IACvD,OAAO,SAAS,IAAI,GAAG,CAAC,iBAAiB,EAAE,CAAC;AAChD,CAAC;AAED,KAAK,UAAU,yBAAyB,CAAC,GAA2B;IAChE,IAAI,CAAC,GAAG,CAAC,YAAY,IAAI,CAAC,GAAG,CAAC,SAAS,EAAE,CAAC;QACtC,OAAO,IAAI,CAAC;IAChB,CAAC;IACD,IAAI,CAAC;QACD,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,YAAY,CAAC,iBAAiB,CAAC,qBAAqB,CAAC,CAAC;QAChF,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC;QAChB,CAAC;QACD,OAAO,IAAI,oBAAoB,CAAC,GAAG,CAAC,YAAY,EAAE,GAAG,CAAC,SAAS,CAAC,CAAC;IACrE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACb,OAAO,CAAC,IAAI,CACR,yCAAyC,qBAAqB,0EAA0E,EACxI,KAAK,CACR,CAAC;QACF,OAAO,IAAI,CAAC;IAChB,CAAC;AACL,CAAC","sourcesContent":["import { RECORDING_SAMPLE_RATE } from '@memberjunction/ai-core-plus';\nimport { WasmOpusEncoder } from './wasm-opus-encoder';\nimport {\n    AudioDataConstructor,\n    AudioEncoderConstructor,\n    WEBCODECS_OPUS_CONFIG,\n    WebCodecsOpusEncoder,\n} from './webcodecs-opus-encoder';\n\n/**\n * One continuous Opus encoder for a whole call: mono, 48 kHz, 32 kbps, 20 ms (960-sample) packets.\n *\n * Every packet it emits is one raw Opus packet (no container), in capture order. The runtime cuts\n * that stream into `MJOPUS1` shards and the server decodes all packets with one libopus decoder,\n * which is why the call must keep a single encoder from start to finish: encoder state carries\n * across packets, so switching encoders mid-call would corrupt the join.\n */\nexport interface IOpusPacketEncoder {\n    /** Which implementation this is, for logs and tests. */\n    readonly Kind: 'webcodecs' | 'wasm';\n    /**\n     * Queues 48 kHz mono samples for encoding. Any length; the encoder frames them into 960-sample\n     * packets itself. The caller keeps ownership of `pcm48k` (the encoder copies what it needs).\n     * Never throws: an encoder fault is logged and later input is dropped.\n     */\n    Encode(pcm48k: Float32Array): void;\n    /**\n     * Encodes everything queued, padding a final partial frame with silence, and resolves once those\n     * packets are available to {@link TakePackets}. Never rejects; a fault or timeout is logged.\n     */\n    Flush(): Promise<void>;\n    /** Returns the packets produced since the previous call and forgets them. Works after {@link Close}. */\n    TakePackets(): Uint8Array[];\n    /** Releases the encoder. Idempotent; packets already produced stay available to {@link TakePackets}. */\n    Close(): void;\n}\n\n/** The platform pieces {@link SelectOpusPacketEncoder} chooses between. Injectable for tests. */\nexport interface OpusEncoderEnvironment {\n    /** The WebCodecs `AudioEncoder` constructor, or `null` where the platform has none. */\n    AudioEncoder: AudioEncoderConstructor | null;\n    /** The WebCodecs `AudioData` constructor, or `null` where the platform has none. */\n    AudioData: AudioDataConstructor | null;\n    /** Starts the libopus WebAssembly encoder (the fallback). */\n    CreateWasmEncoder: () => Promise<IOpusPacketEncoder>;\n}\n\n/** The real browser environment: WebCodecs globals when present, the libopus Worker otherwise. */\nexport function BrowserOpusEncoderEnvironment(): OpusEncoderEnvironment {\n    return {\n        AudioEncoder: typeof AudioEncoder === 'undefined' ? null : AudioEncoder,\n        AudioData: typeof AudioData === 'undefined' ? null : AudioData,\n        CreateWasmEncoder: () => WasmOpusEncoder.Create(),\n    };\n}\n\n/**\n * Picks the call's encoder, once, at recording start.\n *\n * WebCodecs is preferred (native, no 440 KB download) but only when the browser says it can encode\n * exactly our configuration: `AudioEncoder` existing is not enough, because Safari shipped\n * `AudioEncoder` long before it supported Opus in it. Anything else — no WebCodecs, an unsupported\n * config, a support probe or configure that throws — falls back to libopus in a Worker. A failure\n * of the fallback rejects, and the recorder treats that as \"recording off\" for the call.\n */\nexport async function SelectOpusPacketEncoder(env: OpusEncoderEnvironment = BrowserOpusEncoderEnvironment()): Promise<IOpusPacketEncoder> {\n    const webCodecs = await tryCreateWebCodecsEncoder(env);\n    return webCodecs ?? env.CreateWasmEncoder();\n}\n\nasync function tryCreateWebCodecsEncoder(env: OpusEncoderEnvironment): Promise<IOpusPacketEncoder | null> {\n    if (!env.AudioEncoder || !env.AudioData) {\n        return null;\n    }\n    try {\n        const support = await env.AudioEncoder.isConfigSupported(WEBCODECS_OPUS_CONFIG);\n        if (support.supported !== true) {\n            return null;\n        }\n        return new WebCodecsOpusEncoder(env.AudioEncoder, env.AudioData);\n    } catch (error) {\n        console.warn(\n            `[OpusPacketEncoder] WebCodecs Opus at ${RECORDING_SAMPLE_RATE} Hz could not be set up — using the libopus WebAssembly encoder instead:`,\n            error,\n        );\n        return null;\n    }\n}\n"]}

package/dist/lib/services/recording/wasm-opus-encoder.d.ts

@@ -0,0 +1,86 @@
+import { OpusWorkerReply, OpusWorkerRequest } from './libopus-worker-source';
+import type { IOpusPacketEncoder } from './opus-packet-encoder';
+/**
+ * How long {@link WasmOpusEncoder.Flush} waits for the worker's `flushed` reply. The runtime bounds
+ * the whole recorder Stop at 2 s, so this stays below that and leaves room for closing up.
+ */
+export declare const WASM_OPUS_FLUSH_TIMEOUT_MS = 1500;
+/**
+ * How long {@link WasmOpusEncoder.Start} waits for the worker to instantiate libopus. Instantiating
+ * the ~330 KB module takes milliseconds; a worker that says nothing for this long is not running
+ * (a Content-Security-Policy without `worker-src blob:` or `'wasm-unsafe-eval'`, for instance).
+ */
+export declare const WASM_OPUS_READY_TIMEOUT_MS = 5000;
+/** The two-way channel to the encoder worker. A real `Worker` is adapted to it; tests run the worker source in-process. */
+export interface OpusWorkerPort {
+    /** Posts a request, transferring the listed buffers. */
+    Post(message: OpusWorkerRequest, transfer: Transferable[]): void;
+    /** Receives every reply the worker posts. */
+    OnReply: ((reply: OpusWorkerReply) => void) | null;
+    /** Stops the worker. */
+    Terminate(): void;
+}
+/** Decodes base64 into a fresh ArrayBuffer (one the worker can take ownership of). */
+export declare function DecodeBase64ToArrayBuffer(base64: string): ArrayBuffer;
+/**
+ * Opus encoding through libopus compiled to WebAssembly, running in a dedicated Worker so encoding
+ * never competes with the call's UI or audio on the main thread. The fallback for browsers whose
+ * WebCodecs cannot encode Opus.
+ *
+ * The worker does the 960-sample framing itself (see {@link LIBOPUS_WORKER_SOURCE}); this class only
+ * forwards audio, collects the packets the worker posts back, and turns `flush` into a promise.
+ */
+export declare class WasmOpusEncoder implements IOpusPacketEncoder {
+    private readonly port;
+    private readonly onClose;
+    readonly Kind = "wasm";
+    private packets;
+    private readonly flushWaiters;
+    private nextFlushId;
+    private closed;
+    /** Whether the worker has reported `ready`, or the error it reported instead. */
+    private startState;
+    /** Notified once when {@link startState} leaves `starting` (null = ready, else the error). */
+    private startWaiter;
+    /**
+     * @param port channel to a worker running {@link LIBOPUS_WORKER_SOURCE}
+     * @param wasmBytes the libopus module; ownership moves to the worker
+     * @param onClose extra cleanup after the worker stops (the Blob URL revoke)
+     */
+    constructor(port: OpusWorkerPort, wasmBytes: ArrayBuffer, onClose?: () => void);
+    /**
+     * Loads the embedded wasm and starts the worker from a Blob URL. Rejects if either fails, or if the
+     * worker never gets libopus running (see {@link Start}).
+     */
+    static Create(): Promise<WasmOpusEncoder>;
+    /**
+     * Creates the encoder on `port` and resolves once the worker reports libopus ready. Rejects — after
+     * closing the encoder — when the worker reports an init error or says nothing for
+     * {@link WASM_OPUS_READY_TIMEOUT_MS}: an encoder that can never produce a packet must fail selection,
+     * so the recorder turns recording off visibly instead of "recording" while producing nothing.
+     */
+    static Start(port: OpusWorkerPort, wasmBytes: ArrayBuffer, onClose?: () => void): Promise<WasmOpusEncoder>;
+    Encode(pcm48k: Float32Array): void;
+    Flush(): Promise<void>;
+    TakePackets(): Uint8Array[];
+    Close(): void;
+    /** Records the worker's start outcome (only the first one counts) and wakes {@link waitUntilStarted}. */
+    private settleStart;
+    /** Resolves once the worker is ready; rejects with its init error or after the start timeout. */
+    private waitUntilStarted;
+    private onReply;
+}
+/** The slice of a DOM `Worker` {@link BrowserWorkerPort} drives (the real `Worker` satisfies it). */
+export type WorkerLike = Pick<Worker, 'postMessage' | 'terminate'> & {
+    onmessage: ((event: MessageEvent<OpusWorkerReply>) => void) | null;
+    onerror: ((event: ErrorEvent) => void) | null;
+};
+/** Adapts a DOM `Worker` to {@link OpusWorkerPort}. */
+export declare class BrowserWorkerPort implements OpusWorkerPort {
+    private readonly worker;
+    OnReply: ((reply: OpusWorkerReply) => void) | null;
+    constructor(worker: WorkerLike);
+    Post(message: OpusWorkerRequest, transfer: Transferable[]): void;
+    Terminate(): void;
+}
+//# sourceMappingURL=wasm-opus-encoder.d.ts.map

package/dist/lib/services/recording/wasm-opus-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wasm-opus-encoder.d.ts","sourceRoot":"","sources":["../../../../src/lib/services/recording/wasm-opus-encoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAyB,eAAe,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACpG,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uBAAuB,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,OAAO,CAAC;AAE/C,2HAA2H;AAC3H,MAAM,WAAW,cAAc;IAC3B,wDAAwD;IACxD,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IACjE,6CAA6C;IAC7C,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IACnD,wBAAwB;IACxB,SAAS,IAAI,IAAI,CAAC;CACrB;AAoBD,sFAAsF;AACtF,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,WAAW,CAOrE;AAED;;;;;;;GAOG;AACH,qBAAa,eAAgB,YAAW,kBAAkB;IAgB1C,OAAO,CAAC,QAAQ,CAAC,IAAI;IAA0C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAfnG,SAAgB,IAAI,UAAU;IAC9B,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAiC;IAC9D,OAAO,CAAC,WAAW,CAAK;IACxB,OAAO,CAAC,MAAM,CAAS;IACvB,iFAAiF;IACjF,OAAO,CAAC,UAAU,CAAwD;IAC1E,8FAA8F;IAC9F,OAAO,CAAC,WAAW,CAAiD;IAEpE;;;;OAIG;gBAC0B,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAmB,OAAO,GAAE,MAAM,IAAsB;IAKjI;;;OAGG;WACiB,MAAM,IAAI,OAAO,CAAC,eAAe,CAAC;IAatD;;;;;OAKG;WACiB,KAAK,CAAC,IAAI,EAAE,cAAc,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,GAAE,MAAM,IAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;IAWjI,MAAM,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAQlC,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAmBtB,WAAW,IAAI,UAAU,EAAE;IAM3B,KAAK,IAAI,IAAI;IAepB,yGAAyG;IACzG,OAAO,CAAC,WAAW;IAUnB,iGAAiG;IACjG,OAAO,CAAC,gBAAgB;IA0BxB,OAAO,CAAC,OAAO;CAsBlB;AAED,qGAAqG;AACrG,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CAAC,GAAG;IAEjE,SAAS,EAAE,CAAC,CAAC,KAAK,EAAE,YAAY,CAAC,eAAe,CAAC,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;IAEnE,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC,GAAG,IAAI,CAAC;CACjD,CAAC;AAEF,uDAAuD;AACvD,qBAAa,iBAAkB,YAAW,cAAc;IAGxC,OAAO,CAAC,QAAQ,CAAC,MAAM;IAF5B,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAC,GAAG,IAAI,CAAQ;gBAEpC,MAAM,EAAE,UAAU;IAYxC,IAAI,CAAC,OAAO,EAAE,iBAAiB,EAAE,QAAQ,EAAE,YAAY,EAAE,GAAG,IAAI;IAIhE,SAAS,IAAI,IAAI;CAK3B"}