@byokit/realtime 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Unreleased
 
+## 0.3.1 (2026-10-01)
+
+
+
+- SECURITY: Lazy WebRTC capture no longer opens the Android microphone or sends untapped speech before `attachMic()`; `releaseMic()` closes recording while keeping the call connected. Apps using lazy capture should update.
+
 ## 0.3.0 (2026-10-01)
 
 

package/README.md

@@ -194,8 +194,10 @@ function endCall() { client.stop(); }
 ```
 
 `attachMic()` awaits the app's microphone permission/service lease, captures
-an audio track and uses `sender.replaceTrack(track)`. `releaseMic()` awaits
-`replaceTrack(null)`, stops capture tracks and releases the lease so the app
+an audio track and uses `sender.replaceTrack(track)` before enabling the sender's
+encoding. Lazy peers negotiate `sendrecv` with an inactive encoding: Android's
+audio device cannot start recording just because an answer is applied.
+`releaseMic()` disables that encoding before `replaceTrack(null)`, stops capture tracks and releases the lease so the app
 can stop its microphone service and clear the OS indicator. Neither operation
 renegotiates. Repeated calls are safe; release or stop during pending capture
 cleans up when that capture resolves. Reconnecting starts another lazy peer;

package/dist/webrtc.js

@@ -47,6 +47,19 @@ export async function webRtcPeer(options) {
         options.onError(error);
         stop();
     } };
+    const setSending = async (active) => {
+        if (options.capture !== 'lazy')
+            return;
+        const parameters = sender.getParameters();
+        if (!parameters.encodings.length)
+            throw new Error('Voice capture control is unavailable.');
+        parameters.encodings.forEach(encoding => { encoding.active = active; });
+        await sender.setParameters(parameters);
+        // The native bridge can resolve even when the engine rejects setParameters.
+        const applied = sender.getParameters().encodings;
+        if (!applied.length || applied.some(encoding => encoding.active !== active))
+            throw new Error('Voice capture control failed.');
+    };
     const captureMic = async (generation) => {
         await options.audio.microphone.acquire();
         acquired = true;
@@ -79,14 +92,28 @@ export async function webRtcPeer(options) {
                 const captured = await captureMic(generation);
                 if (captured) {
                     await sender.replaceTrack(captured.getAudioTracks()[0]);
+                    if (!stopped && generation === micEpoch)
+                        await setSending(true);
                     if (stopped || generation !== micEpoch) {
-                        if (!stopped)
+                        if (!stopped) {
+                            await setSending(false);
                             await sender.replaceTrack(null);
+                        }
                         clearMic();
                     }
                 }
             }
             catch (error) {
+                // Never leave a trackless native send stream recording after a failure.
+                try {
+                    if (!stopped && options.capture === 'lazy') {
+                        await setSending(false);
+                        await sender.replaceTrack(null);
+                    }
+                }
+                catch {
+                    stop();
+                }
                 clearMic();
                 throw error;
             }
@@ -97,8 +124,15 @@ export async function webRtcPeer(options) {
         stream?.getAudioTracks().forEach(track => { track.enabled = false; });
         return serializeMic(async () => {
             try {
-                if (!stopped && stream)
+                if (!stopped && stream) {
+                    await setSending(false);
                     await sender.replaceTrack(null);
+                }
+            }
+            catch (error) {
+                if (options.capture === 'lazy')
+                    stop();
+                throw error;
             }
             finally {
                 clearMic();
@@ -153,8 +187,12 @@ export async function webRtcPeer(options) {
             options.onConnectionState('connecting'); };
         current.ontrack = event => { const track = event.track; if (track.kind !== 'audio' || stopped)
             return; options.onRemoteAudio(!track.muted); track.onmute = () => options.onRemoteAudio(false); track.onunmute = () => options.onRemoteAudio(true); track.onended = () => options.onRemoteAudio(false); };
-        if (options.capture === 'lazy')
-            sender = current.addTransceiver('audio', { direction: 'sendrecv' }).sender;
+        if (options.capture === 'lazy') {
+            // Android starts the device module for an active send stream even without
+            // a track. Disable the encoding before either description can be applied.
+            sender = current.addTransceiver('audio', { direction: 'sendrecv', sendEncodings: [{ active: false }] }).sender;
+            await setSending(false);
+        }
         else {
             const input = stream.getAudioTracks()[0];
             if (!input)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@byokit/realtime",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Realtime voice sessions with host-held credentials and injected audio.",
   "license": "Apache-2.0",
   "type": "module",