@lumavox/react-native 0.15.1 → 0.17.0

package/README.md

@@ -3,7 +3,7 @@
 Voice conversations with Lumavox agents in a React Native app, on iOS,
 Android and the web — **one install**: the client (`@lumavox/client`), the
 hooks (`@lumavox/react`), and the audio they lack, a player and a recorder
-for **push-to-talk**, on
+for **push-to-talk**, **half-duplex** and **hands-free**, on
 [`react-native-audio-api`](https://github.com/software-mansion/react-native-audio-api)
 on a phone and Web Audio in a browser.
 
@@ -54,10 +54,32 @@ function Talk({ agentId }: { agentId: string }) {
 - A call, Siri or another app pauses the reply and throws away a recording
   in progress — `interrupted`, `onAudioInterrupted`, `onAudioResumed`; so
   does leaving the screen: no background audio in this release.
-- Hands-free (`agent.listen()`) runs on the web, where the browser cancels
-  echo; on a phone it is refused until `react-native-audio-api` 1.0 does —
-  `listen({ assumeNoEcho: true })` with headphones on. Background audio
-  comes with 1.0 too.
+- **Half-duplex on every phone**: `agent.listen({ halfDuplex: true })` —
+  tap once and talk for the whole conversation; the microphone stays open,
+  but nothing is heard while the agent speaks, so it never hears itself
+  and needs no echo cancellation. It cannot be talked over: give a stop
+  button (`agent.cancel()`).
+- **Hands-free** (`agent.listen()`, talking over the agent to stop it):
+  on the web where the browser cancels echo, and on a phone **in early
+  access**, on one build of the audio library, exactly:
+  `npm install react-native-audio-api@1.0.0-nightly-6fd4c68-20261102`,
+  then build the app again. While it listens the phone's sound is a
+  call's — the echo taken out, the agent a little quieter — and Bluetooth
+  earbuds' microphone is used. On 0.13 it is refused (`audio.handsFree()`
+  says why): offer half-duplex, or `listen({ assumeNoEcho: true })` with
+  headphones on. Background audio comes with the library's 1.0.
+- **A clock for a lip-synced face or subtitles**, on a phone and the web:
+  `audio.onScheduled(({ pcm, sample_rate, chunk, startsAt }) => …)` tells
+  every frame as it is queued, before it plays; draw against
+  `audio.heardTime()`; `audio.onStopped` when a stop drops what was
+  queued; `audio.onCapture` for the microphone's frames.
+  `createAudio({ leadInMs: 350 })` gives a model that long to read a
+  reply's first frame (and adds it to the first word); `outputLatencyMs`
+  is what the phone's sound takes to the ear, which the library cannot
+  say — Bluetooth earbuds add about 150–250 ms.
+- On the web the app may choose the microphone, its processing and the
+  speaker (`inputs()`, `setInput`, `setProcessing`, `outputs()`,
+  `setOutputDevice`); on a phone the system does — `[]` and `false`.
 
 The guide, with the bare React Native setup: the docs' **SDKs** tab,
 *React Native*.

package/app.plugin.js

@@ -68,7 +68,10 @@ function audioApiOptions(options = {}) {
     androidFSStopWithTask: true,
     // The library's own defaults: FFmpeg decodes compressed files, which a
     // conversation's raw PCM never needs — `true` makes the app smaller.
+    // 1.0 turned the option round, FFmpeg off unless `enableFFmpeg`: each
+    // build reads its own and ignores the other's, so both say the same.
     disableFFmpeg: options.disableFFmpeg ?? false,
+    enableFFmpeg: !(options.disableFFmpeg ?? false),
     disableStaticExternalLibs: options.disableStaticExternalLibs ?? false,
   };
 }
@@ -90,7 +93,8 @@ function withLumavox(config, options, library) {
 }
 
 function loadLibrary() {
-  const plugin = require(`${LIBRARY}/app.plugin`);
+  // With its extension: 1.0's `exports` names `./app.plugin.js` alone.
+  const plugin = require(`${LIBRARY}/app.plugin.js`);
   return plugin.default ?? plugin;
 }
 

package/dist/audio.native.d.ts

@@ -1,51 +1,184 @@
+/**
+ * A phone's player and recorder, on `react-native-audio-api` — 0.13.6, or
+ * the one 1.0 nightly hands-free runs on (`session.ts`, `PINNED_NIGHTLY`):
+ * what Metro picks for `./audio` on iOS and Android (`index.ts`). With
+ * `session.ts`, the only file that touches the library.
+ *
+ * - **The reply plays through one `AudioBufferQueueSourceNode`**, started
+ *   once: each frame's PCM is a buffer enqueued behind the last, gapless,
+ *   and a queue that runs dry plays silence until the next. `clearBuffers`
+ *   stops it at once.
+ * - **The context runs at the reply's rate**, rebuilt — what is queued
+ *   dropped — when an `audio.start` brings another: 0.13.6's queue plays
+ *   every buffer at its context's rate whatever the buffer says (its
+ *   `AudioBufferBaseSourceNode`), so a 24 kHz reply in a 48 kHz context
+ *   would play an octave up. The device's own resampling does the rest.
+ * - **The agent stopped speaking when the last buffer enqueued has ended**,
+ *   counted by the ids `enqueueBuffer` answers: the queue's own
+ *   `isLastBufferInQueue` can say so just as the next frame is enqueued, and
+ *   a buffer `clearBuffers` dropped never ends.
+ * - **The clock is the context's, and the playhead ours**: the queue says
+ *   nothing of when a buffer starts, so each frame starts where the last
+ *   ends — `max(playhead, currentTime)`, as the web's player keeps it — and
+ *   is told so (`onScheduled`). A lead-in (`leadInMs`) is a buffer of
+ *   silence enqueued ahead of a frame that finds the queue dry. A new rate's
+ *   context starts its clock at 0 again, what the old one queued stopped.
+ * - **What is heard is the clock less the app's `outputLatencyMs`**:
+ *   0.13.6 says nothing of the device's latency — its source nodes'
+ *   `getLatency()` is their time-stretcher's — so the app, which can know
+ *   its earbuds are on, says it. Unset on the nightly, the context's own
+ *   (`outputLatency` and `baseLatency`, 1.0's).
+ * - **The microphone records at 16 kHz**, mono, 100 ms a buffer — less to
+ *   send than 24 kHz, and a rate the socket takes. `onAudioReady` hands the
+ *   samples over JSI as floats, at the rate the device chose, which need
+ *   not be the one asked: read from the buffer and resampled (`resample`).
+ * - **An interruption** — a call, Siri, another app, the app leaving the
+ *   screen — suspends the context, so the reply's frames keep queueing and
+ *   play from where they stopped; and closes the recorder, whose audio is
+ *   thrown away (the hook discards the recording on the socket). The audio
+ *   comes back on its own when the system says it may, else on `resume()`
+ *   or the next press.
+ * - **Half-duplex on any build** (`listen`'s `halfDuplex`): the recorder
+ *   started once for the whole conversation, which suits the library —
+ *   on iOS, 0.13.6's recorder shares the player's one engine, and each
+ *   start stops and starts it and each stop rebuilds it, a gap in the
+ *   voice; the loudspeaker holds (`defaultToSpeaker`), and Android's
+ *   recorder and player are two streams that open side by side.
+ * - **Hands-free on the pinned nightly alone** (D17, D18; `handsFree`):
+ *   0.13.6 cancels no echo, so a microphone left open hears the agent
+ *   (D12, D16) — refused there, `assumeNoEcho` with headphones on. On the
+ *   nightly a capture that asks for echo cancellation (`listen` does, on
+ *   `handsFree`'s yes) is iOS's voice processing in `videoChat`, and
+ *   Android's voice-communication input with the reply on the call's path
+ *   (`androidOutputProfile`), in its communication mode
+ *   (`session.configure`): its canceller hears only that path. The reply
+ *   moves to it — a new context — once nothing is playing, never mid-word,
+ *   and back once the capture ends. **A recorder that will not start that
+ *   way fails the capture**, and `listen` answers why: the app offers
+ *   half-duplex (D16, D19). Whether an Android phone's canceller works is
+ *   not asked: the platform says it only to native code (left-overs #177).
+ * - **`duck`**: the reply goes through a gain, lowered while it may be
+ *   talked over — barge-in's first step.
+ */
+import { type AgentAudio, type AudioDevice, type ScheduledAudio } from "@lumavox/client";
 import type { AudioOptions, CreateAudio, DeviceAudio, Output } from "./device-audio.js";
 /** Hz the microphone records at unless a rate the socket takes is asked. */
 export declare const RECORD_RATE = 16000;
-/** Why `handsFree` refuses on a phone. */
-export declare const PHONE_ECHO = "Hands-free needs echo cancellation, which comes with react-native-audio-api 1.0. Use push-to-talk, or assumeNoEcho with headphones on.";
+/** Why `handsFree` refuses on 0.13. */
+export declare const PHONE_ECHO = "Hands-free needs echo cancellation, which comes with react-native-audio-api 1.0. Use half-duplex or push-to-talk, or assumeNoEcho with headphones on.";
+/** Why it refuses on a 1.0 build that is not the one it was tested on. */
+export declare const untestedBuild: (version: string) => string;
 export declare class PhoneAudio implements DeviceAudio {
     interrupted: boolean;
+    /** On a phone the system chooses the speaker. */
+    readonly canChooseOutput = false;
     private context;
     private queue;
+    /** Between the queue and the speaker: the reply lowered while it may be talked over. */
+    private gain;
+    private volume;
+    /** The context's output on Android: the call's path while hands-free cancels echo. */
+    private profile;
+    /** A capture is cancelling echo: the session is hands-free's. */
+    private cancelling;
+    private unroute;
+    private output;
+    private disposed;
+    /** The call's route last asked on Android (`session.route`). */
+    private routed;
+    /**
+     * Until when an interruption is the session made again — Android's focus
+     * given up and taken back, told a moment later on its own thread — and
+     * not another app's.
+     */
+    private settling;
     /** The ids of the buffers enqueued and not yet played. */
     private readonly playing;
+    /** Where the last buffer enqueued ends, on the context's clock. */
+    private playhead;
     /** A byte of a sample split across two frames. */
     private carry;
     private capture;
     private readonly drained;
+    private readonly stopped;
+    private readonly scheduled;
+    private readonly captured;
     private readonly interruptions;
     private readonly unwatch;
+    /** Seconds. */
+    private readonly leadIn;
+    /** The app's, or `null`: the context's own where it says one. */
+    private readonly latency;
     constructor(options?: AudioOptions);
     prime(): Promise<void>;
-    play(pcm: ArrayBuffer, frame: {
-        sample_rate: number;
-    }): void;
+    play(pcm: ArrayBuffer, frame: Parameters<AgentAudio["play"]>[1]): void;
     stop(): void;
     onDrained(fn: () => void): () => void;
-    /** At 16 kHz, or at the rate asked when the socket takes it. */
+    now(): number;
+    heardTime(): number;
+    onScheduled(fn: (audio: ScheduledAudio) => void): () => void;
+    onStopped(fn: () => void): () => void;
+    onCapture(fn: (pcm: ArrayBuffer, rate: number) => void): () => void;
+    /** The system's microphone and speaker: none listed, none set. */
+    inputs(): Promise<AudioDevice[]>;
+    outputs(): Promise<AudioDevice[]>;
+    setInput(): void;
+    setProcessing(): void;
+    setOutputDevice(): Promise<boolean>;
+    /**
+     * At 16 kHz, or at the rate asked when the socket takes it; cancelling
+     * echo when hands-free asks and the library can.
+     */
     startCapture(onPcm: (pcm: ArrayBuffer) => void, options?: {
         rate?: number;
+        echoCancellation?: boolean;
     }): Promise<{
         rate: number;
     }>;
+    /** The recorder, open: its echo cancelled when `cancel`. */
+    private record;
     stopCapture(): Promise<void>;
     resume(): Promise<void>;
     setOutput(output: Output): void;
+    /** Hands-free's first step on sound over the reply: lowered, until the words say who it was. */
+    duck(on: boolean): void;
     handsFree(): ReturnType<DeviceAudio["handsFree"]>;
     onInterruption(fn: (interrupted: boolean) => void): () => void;
     dispose(): void;
+    /** Behind what is queued; the playhead moves to its end. */
+    private enqueue;
+    /**
+     * The session hands-free's, Android's reply on the call's path and the
+     * call's route: before the recorder starts, so the canceller hears the
+     * first reply too.
+     */
+    private enterHandsFree;
+    /** Back to push-to-talk's session; the reply leaves the call's path once it has played out. */
+    private leaveHandsFree;
+    /**
+     * The session for hands-free or not — disposed, the mode given back and
+     * nothing taken again for a screen gone — its focus's comings and goings
+     * no interruption.
+     */
+    private reconfigure;
+    private reroute;
     /** The queue for a reply at `rate`: this one, or a new context's. */
     private player;
     /**
-     * The wire's PCM as floats. **A split sample is carried, never dropped**:
-     * the edge sends whole samples (`apps/edge/src/voice/tts.ts`), but an odd
-     * byte dropped shifts every byte after it and turns the rest into noise —
-     * the bug that once made the console's playback white noise.
+     * The wire's PCM in whole samples. **A split sample is carried, never
+     * dropped**: the edge sends whole samples (`apps/edge/src/voice/tts.ts`),
+     * but an odd byte dropped shifts every byte after it and turns the rest
+     * into noise — the bug that once made the console's playback white noise.
      */
-    private samples;
+    private whole;
     /** The audio was taken: the reply waits, the recording is thrown away. */
     private interrupt;
     private quiet;
+    /**
+     * Call each of the app's handlers. One that throws is rethrown on its own
+     * turn, where the app's error reporting sees it — not here, where it
+     * would stop the player or the recorder halfway.
+     */
     private tell;
 }
 export declare const createAudio: CreateAudio;

package/dist/audio.native.js

@@ -1,6 +1,7 @@
 /**
- * A phone's player and recorder, on `react-native-audio-api` 0.13.6: what
- * Metro picks for `./audio` on iOS and Android (`index.ts`). With
+ * A phone's player and recorder, on `react-native-audio-api` — 0.13.6, or
+ * the one 1.0 nightly hands-free runs on (`session.ts`, `PINNED_NIGHTLY`):
+ * what Metro picks for `./audio` on iOS and Android (`index.ts`). With
  * `session.ts`, the only file that touches the library.
  *
  * - **The reply plays through one `AudioBufferQueueSourceNode`**, started
@@ -16,6 +17,17 @@
  *   counted by the ids `enqueueBuffer` answers: the queue's own
  *   `isLastBufferInQueue` can say so just as the next frame is enqueued, and
  *   a buffer `clearBuffers` dropped never ends.
+ * - **The clock is the context's, and the playhead ours**: the queue says
+ *   nothing of when a buffer starts, so each frame starts where the last
+ *   ends — `max(playhead, currentTime)`, as the web's player keeps it — and
+ *   is told so (`onScheduled`). A lead-in (`leadInMs`) is a buffer of
+ *   silence enqueued ahead of a frame that finds the queue dry. A new rate's
+ *   context starts its clock at 0 again, what the old one queued stopped.
+ * - **What is heard is the clock less the app's `outputLatencyMs`**:
+ *   0.13.6 says nothing of the device's latency — its source nodes'
+ *   `getLatency()` is their time-stretcher's — so the app, which can know
+ *   its earbuds are on, says it. Unset on the nightly, the context's own
+ *   (`outputLatency` and `baseLatency`, 1.0's).
  * - **The microphone records at 16 kHz**, mono, 100 ms a buffer — less to
  *   send than 24 kHz, and a rate the socket takes. `onAudioReady` hands the
  *   samples over JSI as floats, at the rate the device chose, which need
@@ -26,33 +38,91 @@
  *   thrown away (the hook discards the recording on the socket). The audio
  *   comes back on its own when the system says it may, else on `resume()`
  *   or the next press.
- * - **No hands-free**: 0.13.6 cancels no echo, so a microphone left open
- *   hears the agent (D12, D16). `handsFree` refuses until 1.0; with
- *   headphones on, the app passes `assumeNoEcho`.
+ * - **Half-duplex on any build** (`listen`'s `halfDuplex`): the recorder
+ *   started once for the whole conversation, which suits the library —
+ *   on iOS, 0.13.6's recorder shares the player's one engine, and each
+ *   start stops and starts it and each stop rebuilds it, a gap in the
+ *   voice; the loudspeaker holds (`defaultToSpeaker`), and Android's
+ *   recorder and player are two streams that open side by side.
+ * - **Hands-free on the pinned nightly alone** (D17, D18; `handsFree`):
+ *   0.13.6 cancels no echo, so a microphone left open hears the agent
+ *   (D12, D16) — refused there, `assumeNoEcho` with headphones on. On the
+ *   nightly a capture that asks for echo cancellation (`listen` does, on
+ *   `handsFree`'s yes) is iOS's voice processing in `videoChat`, and
+ *   Android's voice-communication input with the reply on the call's path
+ *   (`androidOutputProfile`), in its communication mode
+ *   (`session.configure`): its canceller hears only that path. The reply
+ *   moves to it — a new context — once nothing is playing, never mid-word,
+ *   and back once the capture ends. **A recorder that will not start that
+ *   way fails the capture**, and `listen` answers why: the app offers
+ *   half-duplex (D16, D19). Whether an Android phone's canceller works is
+ *   not asked: the platform says it only to native code (left-overs #177).
+ * - **`duck`**: the reply goes through a gain, lowered while it may be
+ *   talked over — barge-in's first step.
  */
 import { DEFAULT_SAMPLE_RATE, floatToPcm16, pcm16ToFloat, RECORDING_RATES, resample, } from "@lumavox/client";
 import { AudioContext, AudioRecorder, } from "react-native-audio-api";
 import * as session from "./session.js";
 /** Hz the microphone records at unless a rate the socket takes is asked. */
 export const RECORD_RATE = 16000;
-/** Why `handsFree` refuses on a phone. */
-export const PHONE_ECHO = "Hands-free needs echo cancellation, which comes with react-native-audio-api 1.0. Use push-to-talk, or assumeNoEcho with headphones on.";
+/** Why `handsFree` refuses on 0.13. */
+export const PHONE_ECHO = "Hands-free needs echo cancellation, which comes with react-native-audio-api 1.0. Use half-duplex or push-to-talk, or assumeNoEcho with headphones on.";
+/** Why it refuses on a 1.0 build that is not the one it was tested on. */
+export const untestedBuild = (version) => `Hands-free runs on react-native-audio-api ${session.PINNED_NIGHTLY}, the build it was tested on; this app has ${version}. Use half-duplex or push-to-talk.`;
+/** After the session is made again, how long a focus change is still its own: Android tells it on another thread, a moment later. */
+const SETTLE_MS = 500;
+/** The reply's loudness while the person may be talking over it (`duck`): about -10 dB, as the web's. */
+const DUCKED = 0.3;
 /** Seconds of microphone per buffer delivered: the recorder's own latency. */
 const RECORD_SECONDS = 0.1;
 export class PhoneAudio {
     constructor(options = {}) {
         this.interrupted = false;
+        /** On a phone the system chooses the speaker. */
+        this.canChooseOutput = false;
         this.context = null;
         this.queue = null;
+        /** Between the queue and the speaker: the reply lowered while it may be talked over. */
+        this.gain = null;
+        this.volume = 1;
+        /** The context's output on Android: the call's path while hands-free cancels echo. */
+        this.profile = "media";
+        /** A capture is cancelling echo: the session is hands-free's. */
+        this.cancelling = false;
+        this.unroute = null;
+        this.disposed = false;
+        /** The call's route last asked on Android (`session.route`). */
+        this.routed = null;
+        /**
+         * Until when an interruption is the session made again — Android's focus
+         * given up and taken back, told a moment later on its own thread — and
+         * not another app's.
+         */
+        this.settling = 0;
         /** The ids of the buffers enqueued and not yet played. */
         this.playing = new Set();
+        /** Where the last buffer enqueued ends, on the context's clock. */
+        this.playhead = 0;
         /** A byte of a sample split across two frames. */
         this.carry = null;
         this.capture = null;
         this.drained = new Set();
+        this.stopped = new Set();
+        this.scheduled = new Set();
+        this.captured = new Set();
         this.interruptions = new Set();
-        session.configure(options.output ?? "speaker");
+        this.leadIn = (options.leadInMs ?? 0) / 1000;
+        this.latency =
+            options.outputLatencyMs === undefined
+                ? null
+                : options.outputLatencyMs / 1000;
+        this.output = options.output ?? "speaker";
+        session.configure(this.output).catch(() => {
+            // swallowed: the library's defaults stand until `prime()` or a press sets the session again.
+        });
         this.unwatch = session.watch(({ began, shouldResume }) => {
+            if (Date.now() < this.settling)
+                return;
             if (began)
                 this.interrupt();
             else if (shouldResume && this.interrupted) {
@@ -67,30 +137,88 @@ export class PhoneAudio {
         this.player(this.context?.sampleRate ?? DEFAULT_SAMPLE_RATE);
     }
     play(pcm, frame) {
-        const queue = this.player(frame.sample_rate);
-        const samples = this.samples(pcm);
-        if (samples.length === 0)
+        const rate = frame.sample_rate;
+        this.player(rate);
+        const whole = this.whole(pcm);
+        if (whole.byteLength === 0)
             return;
-        const buffer = this.context.createBuffer(1, samples.length, frame.sample_rate);
+        const context = this.context;
+        const samples = pcm16ToFloat(whole);
+        const buffer = context.createBuffer(1, samples.length, rate);
         buffer.copyToChannel(samples, 0);
-        this.playing.add(queue.enqueueBuffer(buffer));
+        // Read once the buffer is made, as near its enqueue as can be: copying
+        // a frame over JSI took 11 ms on Android's emulator, and a frame that
+        // starts at once was told as starting that long before it was queued.
+        const now = context.currentTime;
+        if (this.playhead <= now) {
+            // The queue ran dry: this frame starts a run, after the lead-in.
+            this.playhead = now;
+            // Never an empty buffer: the library throws on a length of 0.
+            const silence = Math.round(this.leadIn * rate);
+            if (silence > 0)
+                this.enqueue(context.createBuffer(1, silence, rate));
+        }
+        const startsAt = this.playhead;
+        this.enqueue(buffer);
+        this.tell(this.scheduled, {
+            pcm: whole,
+            sample_rate: rate,
+            channels: frame.channels,
+            chunk: frame.chunk,
+            turn: frame.turn,
+            startsAt,
+            duration: buffer.duration,
+        });
     }
     stop() {
         const was = this.playing.size > 0;
         this.queue?.clearBuffers();
         this.playing.clear();
+        this.playhead = 0;
         // Half a sample of audio that will never play now.
         this.carry = null;
-        if (was)
-            this.tell(this.drained);
+        if (!was)
+            return;
+        this.tell(this.drained);
+        this.tell(this.stopped);
     }
     onDrained(fn) {
-        this.drained.add(fn);
-        return () => {
-            this.drained.delete(fn);
-        };
+        return add(this.drained, fn);
+    }
+    now() {
+        return this.context?.currentTime ?? 0;
+    }
+    heardTime() {
+        const context = this.context;
+        const latency = this.latency ??
+            (context?.outputLatency ?? 0) + (context?.baseLatency ?? 0);
+        return Math.max(0, this.now() - latency);
+    }
+    onScheduled(fn) {
+        return add(this.scheduled, fn);
+    }
+    onStopped(fn) {
+        return add(this.stopped, fn);
+    }
+    onCapture(fn) {
+        return add(this.captured, fn);
+    }
+    /** The system's microphone and speaker: none listed, none set. */
+    async inputs() {
+        return [];
+    }
+    async outputs() {
+        return [];
     }
-    /** At 16 kHz, or at the rate asked when the socket takes it. */
+    setInput() { }
+    setProcessing() { }
+    async setOutputDevice() {
+        return false;
+    }
+    /**
+     * At 16 kHz, or at the rate asked when the socket takes it; cancelling
+     * echo when hands-free asks and the library can.
+     */
     async startCapture(onPcm, options) {
         // A press is the person going on: the audio is taken back first.
         if (this.interrupted)
@@ -105,7 +233,22 @@ export class PhoneAudio {
         const rate = asked && RECORDING_RATES.includes(asked)
             ? asked
             : RECORD_RATE;
-        const recorder = new AudioRecorder();
+        const cancel = options?.echoCancellation === true && session.cancelsEcho();
+        try {
+            if (cancel)
+                await this.enterHandsFree();
+            return await this.record(onPcm, rate, cancel);
+        }
+        catch (failure) {
+            await this.leaveHandsFree();
+            throw failure;
+        }
+    }
+    /** The recorder, open: its echo cancelled when `cancel`. */
+    async record(onPcm, rate, cancel) {
+        const recorder = new AudioRecorder(cancel
+            ? { iosVoiceProcessing: true, androidInputPreset: "voiceCommunication" }
+            : undefined);
         const mine = { recorder, open: true };
         const ready = recorder.onAudioReady({
             sampleRate: rate,
@@ -118,7 +261,9 @@ export class PhoneAudio {
             const at = buffer.sampleRate === rate
                 ? samples
                 : resample(samples, buffer.sampleRate, rate);
-            onPcm(floatToPcm16(at).buffer);
+            const pcm = floatToPcm16(at).buffer;
+            onPcm(pcm);
+            this.tell(this.captured, pcm, rate);
         });
         if (ready.status === "error")
             throw new Error(ready.message);
@@ -138,8 +283,10 @@ export class PhoneAudio {
     async stopCapture() {
         const mine = this.capture;
         this.capture = null;
-        if (!mine)
+        if (!mine) {
+            await this.leaveHandsFree();
             return;
+        }
         try {
             // What the recorder hands over until it has stopped is the end of
             // the last word: delivered before this settles.
@@ -148,6 +295,8 @@ export class PhoneAudio {
         finally {
             mine.open = false;
             mine.recorder.clearOnAudioReady();
+            // Once the recorder has let go: Android's session is made again.
+            await this.leaveHandsFree();
         }
     }
     async resume() {
@@ -159,41 +308,126 @@ export class PhoneAudio {
         this.tell(this.interruptions, false);
     }
     setOutput(output) {
-        session.configure(output);
+        this.output = output;
+        session.configure(output, this.cancelling).catch(() => {
+            // swallowed: the session stays as it was — the route the system chose.
+        });
+        if (this.cancelling)
+            this.reroute();
+    }
+    /** Hands-free's first step on sound over the reply: lowered, until the words say who it was. */
+    duck(on) {
+        this.volume = on ? DUCKED : 1;
+        if (this.gain)
+            this.gain.gain.value = this.volume;
     }
     async handsFree() {
-        return { ok: false, reason: PHONE_ECHO };
+        if (session.cancelsEcho())
+            return { ok: true };
+        const version = session.libraryVersion();
+        return {
+            ok: false,
+            reason: version.startsWith("0.") ? PHONE_ECHO : untestedBuild(version),
+        };
     }
     onInterruption(fn) {
-        this.interruptions.add(fn);
-        return () => {
-            this.interruptions.delete(fn);
-        };
+        return add(this.interruptions, fn);
     }
     dispose() {
+        this.disposed = true;
         this.stop();
+        // Hands-free's session undone with the recorder.
         void this.stopCapture();
         this.unwatch();
         void this.context?.close();
         this.context = null;
         this.queue = null;
+        this.gain = null;
+    }
+    /** Behind what is queued; the playhead moves to its end. */
+    enqueue(buffer) {
+        this.playing.add(this.queue.enqueueBuffer(buffer));
+        this.playhead += buffer.duration;
+    }
+    /**
+     * The session hands-free's, Android's reply on the call's path and the
+     * call's route: before the recorder starts, so the canceller hears the
+     * first reply too.
+     */
+    async enterHandsFree() {
+        this.cancelling = true;
+        this.routed = null;
+        await this.reconfigure(true);
+        this.unroute ?? (this.unroute = session.watchRoutes(() => this.reroute()));
+        this.reroute();
+        if (this.context && this.playing.size === 0) {
+            this.player(this.context.sampleRate);
+        }
+    }
+    /** Back to push-to-talk's session; the reply leaves the call's path once it has played out. */
+    async leaveHandsFree() {
+        if (!this.cancelling)
+            return;
+        this.cancelling = false;
+        this.unroute?.();
+        this.unroute = null;
+        await this.reconfigure(false);
+    }
+    /**
+     * The session for hands-free or not — disposed, the mode given back and
+     * nothing taken again for a screen gone — its focus's comings and goings
+     * no interruption.
+     */
+    async reconfigure(handsFree) {
+        this.settling = Number.POSITIVE_INFINITY;
+        try {
+            await session.configure(this.output, handsFree, !this.disposed);
+        }
+        finally {
+            this.settling = Date.now() + SETTLE_MS;
+        }
+    }
+    reroute() {
+        session
+            .route(this.output, this.routed)
+            .then((device) => {
+            this.routed = device;
+        })
+            .catch(() => {
+            // swallowed: the system's route stands — the loudspeaker, or the earpiece in a call.
+        });
     }
     /** The queue for a reply at `rate`: this one, or a new context's. */
     player(rate) {
-        if (this.queue && this.context?.sampleRate === rate)
+        const profile = this.cancelling && session.android() ? "voiceCommunication" : "media";
+        if (this.queue &&
+            this.context?.sampleRate === rate &&
+            // Onto the call's path or off it, never mid-reply.
+            (this.profile === profile || this.playing.size > 0)) {
             return this.queue;
+        }
         this.stop();
         void this.context?.close();
-        const context = new AudioContext({ sampleRate: rate });
+        const context = new AudioContext(profile === "media"
+            ? { sampleRate: rate }
+            : { sampleRate: rate, androidOutputProfile: profile });
+        this.profile = profile;
         const queue = context.createBufferQueueSource();
-        queue.connect(context.destination);
-        queue.onBufferEnded = ({ bufferId }) => {
+        const gain = context.createGain();
+        gain.gain.value = this.volume;
+        queue.connect(gain);
+        gain.connect(context.destination);
+        const ended = ({ bufferId }) => {
             if (this.queue !== queue)
                 return;
             if (this.playing.delete(bufferId) && this.playing.size === 0) {
                 this.tell(this.drained);
             }
         };
+        // 0.13's name, and 1.0's: each takes the other's as a plain property,
+        // set for nothing — and with the wrong one alone no reply ever ends.
+        queue.onBufferEnded = ended;
+        queue.onbufferended = ended;
         // Never `start()`: 0.13.6's wrapper defaults `offset` to -1 and then
         // throws on its own default (`offset must be a finite non-negative
         // number: -1`), which crashed the first reply on Android's emulator.
@@ -204,15 +438,16 @@ export class PhoneAudio {
             this.quiet(context);
         this.context = context;
         this.queue = queue;
+        this.gain = gain;
         return queue;
     }
     /**
-     * The wire's PCM as floats. **A split sample is carried, never dropped**:
-     * the edge sends whole samples (`apps/edge/src/voice/tts.ts`), but an odd
-     * byte dropped shifts every byte after it and turns the rest into noise —
-     * the bug that once made the console's playback white noise.
+     * The wire's PCM in whole samples. **A split sample is carried, never
+     * dropped**: the edge sends whole samples (`apps/edge/src/voice/tts.ts`),
+     * but an odd byte dropped shifts every byte after it and turns the rest
+     * into noise — the bug that once made the console's playback white noise.
      */
-    samples(pcm) {
+    whole(pcm) {
         let bytes = new Uint8Array(pcm);
         if (this.carry !== null) {
             const joined = new Uint8Array(bytes.length + 1);
@@ -225,7 +460,7 @@ export class PhoneAudio {
             this.carry = bytes[bytes.length - 1];
             bytes = bytes.slice(0, -1);
         }
-        return pcm16ToFloat(bytes.buffer);
+        return bytes.buffer;
     }
     /** The audio was taken: the reply waits, the recording is thrown away. */
     interrupt() {
@@ -252,11 +487,30 @@ export class PhoneAudio {
             // swallowed: an interruption may have stopped the engine already.
         });
     }
+    /**
+     * Call each of the app's handlers. One that throws is rethrown on its own
+     * turn, where the app's error reporting sees it — not here, where it
+     * would stop the player or the recorder halfway.
+     */
     tell(listeners, ...args) {
-        for (const fn of listeners)
-            fn(...args);
+        for (const fn of listeners) {
+            try {
+                fn(...args);
+            }
+            catch (error) {
+                setTimeout(() => {
+                    throw error;
+                });
+            }
+        }
     }
 }
+function add(listeners, fn) {
+    listeners.add(fn);
+    return () => {
+        listeners.delete(fn);
+    };
+}
 export const createAudio = (options) => new PhoneAudio(options);
 /** Ask for the microphone, if it was not granted: whether it is now. */
 export const requestMicrophone = () => session.microphone();

package/dist/audio.web.d.ts

@@ -1,4 +1,5 @@
 import type { CreateAudio } from "./device-audio.js";
+/** The lead-in, the microphone and its processing are the browser's; `output` and `outputLatencyMs` the phone's. */
 export declare const createAudio: CreateAudio;
 /** Ask for the microphone, if it was not granted: whether it is now. */
 export declare function requestMicrophone(): Promise<boolean>;

package/dist/audio.web.js

@@ -1,45 +1,36 @@
+/**
+ * A browser's player and recorder: what Metro picks for `./audio` on the
+ * web (`index.ts`), and what anything picking no platform file gets
+ * (`audio.ts`). `react-native-audio-api` has no recorder, no queue and no
+ * real permission request on the web, so this is the client's own
+ * `@lumavox/client/web-audio` — the console's — with the phone's extras
+ * answered as a browser can.
+ *
+ * - **`prime()` must run in the press that starts the conversation**:
+ *   browsers start sound only from a gesture.
+ * - **No interruptions are told**: a browser pauses a tab's audio itself.
+ * - **No earpiece**: `setOutput` does nothing; the speaker is chosen by its
+ *   id (`setOutputDevice`), where the browser lets a page.
+ * - **Hands-free where the browser cancels echo**, as the client's says
+ *   (`handsFree`), its reply lowered while the person may be talking.
+ * - **The client's adapter itself, with the phone's extras added**: every
+ *   method it has — the clock, the frames, the devices — is passed through
+ *   by being it, so none can be left out.
+ * - **The import needs Metro's package `exports`** — on by default from
+ *   React Native 0.79 and Expo SDK 53; before, an app sets
+ *   `unstable_enablePackageExports` (the docs' React Native page).
+ */
 import { createWebAudio } from "@lumavox/client/web-audio";
-class BrowserAudio {
-    constructor() {
-        this.interrupted = false;
-        this.web = createWebAudio();
-    }
-    prime() {
-        return this.web.prime();
-    }
-    play(pcm, frame) {
-        this.web.play(pcm, frame);
-    }
-    stop() {
-        this.web.stop();
-    }
-    onDrained(fn) {
-        return this.web.onDrained(fn);
-    }
-    startCapture(onPcm, options) {
-        return this.web.startCapture(onPcm, options);
-    }
-    stopCapture() {
-        return this.web.stopCapture();
-    }
-    dispose() {
-        this.web.dispose();
-    }
-    resume() {
-        return this.web.prime();
-    }
-    setOutput(_output) { }
-    handsFree() {
-        return this.web.handsFree();
-    }
-    duck(on) {
-        this.web.duck(on);
-    }
-    onInterruption(_fn) {
-        return () => { };
-    }
-}
-export const createAudio = () => new BrowserAudio();
+/** The lead-in, the microphone and its processing are the browser's; `output` and `outputLatencyMs` the phone's. */
+export const createAudio = (options) => {
+    const web = createWebAudio(options);
+    return Object.assign(web, {
+        interrupted: false,
+        resume: () => web.prime(),
+        setOutput: () => { },
+        onInterruption: () => () => { },
+    });
+};
 /** Ask for the microphone, if it was not granted: whether it is now. */
 export async function requestMicrophone() {
     try {

package/dist/device-audio.d.ts

@@ -1,10 +1,12 @@
 /**
  * What `createAudio()` answers on every platform — a phone's
  * (`audio.native.ts`) and a browser's (`audio.web.ts`) — so an app written
- * once runs on both: the `AgentAudio` that `useAgent` drives, and what an
+ * once runs on both: the `AgentAudio` that `useAgent` drives, the clock
+ * and the frames an app draws against (`PlaybackClock`), the devices a
+ * browser lets it choose (`DeviceChoices`, none on a phone), and what an
  * app does with the device itself.
  */
-import type { AgentAudio } from "@lumavox/client";
+import type { AgentAudio, DeviceChoices, PlaybackClock, Processing } from "@lumavox/client";
 /** Where the agent is heard with no headphones on. */
 export type Output = "speaker" | "earpiece";
 export interface AudioOptions {
@@ -15,8 +17,26 @@ export interface AudioOptions {
      * 1.0 lets the earpiece be chosen.
      */
     output?: Output;
+    /**
+     * Milliseconds a reply's first frame — or one after a gap — waits before
+     * it plays, for an app that reads each frame first (`onScheduled`): as
+     * much is added to the first word heard. None on a phone unless set, 60
+     * in a browser.
+     */
+    leadInMs?: number;
+    /**
+     * Milliseconds from the phone's player to the ear, which `heardTime()`
+     * takes off the clock — and half-duplex waits out: `react-native-audio-api`
+     * 0.13 cannot say it, so `0` unless set — Bluetooth earbuds add about 150
+     * to 250. A browser says its own.
+     */
+    outputLatencyMs?: number;
+    /** The microphone, by its `inputs()` id, in a browser; a phone's system chooses. */
+    input?: string;
+    /** The browser's cleanup of the microphone; a phone's is the system's. */
+    processing?: Processing;
 }
-export interface DeviceAudio extends AgentAudio {
+export interface DeviceAudio extends AgentAudio, PlaybackClock, DeviceChoices {
     /**
      * Get ready to play. **On the web, call it from the press that starts
      * the conversation**: browsers start sound only from a gesture. On a
@@ -37,7 +57,9 @@ export interface DeviceAudio extends AgentAudio {
     /**
      * Whether hands-free may run (`useAgent`'s `listen`): on the web where
      * the browser cancels echo; on a phone not until `react-native-audio-api`
-     * 1.0 does — with headphones on, an app passes `assumeNoEcho`.
+     * 1.0 does — with headphones on, an app passes `assumeNoEcho`. Half-duplex
+     * (`listen({ halfDuplex: true })`) needs no echo cancelled, and runs
+     * everywhere.
      */
     handsFree(): Promise<{
         ok: true;
@@ -45,6 +67,8 @@ export interface DeviceAudio extends AgentAudio {
         ok: false;
         reason: string;
     }>;
+    /** Hands-free's first step: the reply quieter while it may be talked over, or as before. */
+    duck(on: boolean): void;
 }
 /** `createAudio`'s signature, which each platform's file implements. */
 export type CreateAudio = (options?: AudioOptions) => DeviceAudio;

package/dist/session.d.ts

@@ -1,6 +1,44 @@
+import { type CommunicationDevice } from "react-native-audio-api";
 import type { Output } from "./device-audio.js";
-/** The audio session's category, mode and options for `output`. */
-export declare function configure(output: Output): void;
+/**
+ * **The one `react-native-audio-api` build hands-free runs on before 1.0**
+ * (D17, D18): 1.0 is the first with echo cancellation — iOS's voice
+ * processing, Android's voice-communication audio — and is not released
+ * (no date, 2026-11-02), so one nightly, read in its source and tested,
+ * never "the latest": nightlies change under an app, and its iOS voice
+ * processing was weeks old. This one is commit 6fd4c68, built unchanged on
+ * 2026-10-31, 11-01 and 11-02 — the build npm's `audio-api-nightly` tag
+ * named on 2026-11-02. **Moved only for a fix we need, after a test on a
+ * real iPhone and Android; 1.0 replaces it.** Every other build, 0.13
+ * included, refuses hands-free and runs push-to-talk and half-duplex.
+ * `package.json`'s peer range names it too (`test/package.test.ts`).
+ */
+export declare const PINNED_NIGHTLY = "1.0.0-nightly-6fd4c68-20261102";
+/** The library's version, as installed. */
+export declare const libraryVersion: () => string;
+/** Whether this is the build hands-free runs on: echo can be cancelled. */
+export declare const cancelsEcho: () => boolean;
+/** Android, where the reply must be on the call's path for its echo to be cancelled. */
+export declare const android: () => boolean;
+/**
+ * The audio session's category, mode and options for `output`, for
+ * hands-free or not. Settles at once but for Android's session on 1.0,
+ * which takes a mode only as it is made active, so is made again.
+ */
+export declare function configure(output: Output, handsFree?: boolean, 
+/** `false` when the adapter is gone: the mode given back, the session left inactive. */
+active?: boolean): Promise<void>;
+/**
+ * Hands-free on Android: the call's voice to Bluetooth earbuds when they
+ * are connected — and their microphone with it (D8) — else to `output`.
+ * Asked again when a device comes or goes, never twice the same: the
+ * library's own Bluetooth link sets the device too, and its change is told
+ * as a route's. `asked`, the last asked; answers what is now. Nothing on
+ * iOS, whose route follows `allowBluetoothHFP` by itself, nor on 0.13.
+ */
+export declare function route(output: Output, asked: CommunicationDevice | null): Promise<CommunicationDevice | null>;
+/** Every change of the devices — earbuds connected, taken out — until the answer is called. */
+export declare function watchRoutes(fn: () => void): () => void;
 /** Make the session active: before the first sound, and after an interruption. */
 export declare function activate(): Promise<void>;
 /** Whether the app may record: asked only when not granted yet. */

package/dist/session.js

@@ -1,24 +1,33 @@
 /**
  * The phone's audio session: how the app's audio sits beside the system's
  * — the speaker, the earbuds, calls and other apps. With `audio.native.ts`
- * the only file that touches `react-native-audio-api`, so its 1.0, which
- * renames the session's API (`setSystemOptions`), changes these two and the
- * peer range, and nothing an app sees.
+ * the only file that touches `react-native-audio-api`, and **the one that
+ * knows which of the library it has**: 0.13, or the one 1.0 nightly
+ * hands-free runs on (`PINNED_NIGHTLY`), whose session API is renamed
+ * (`setSystemOptions`) — told apart by what the library has, at run time,
+ * so one build of this package runs on both.
  *
  * - **Play and record at once, from the loudspeaker** (`playAndRecord`,
  *   `defaultToSpeaker`): without it iOS plays a recording app's audio from
  *   the earpiece. Headphones and Bluetooth take over when connected; the
  *   earpiece is the app's choice (`Output`). Android keeps the loudspeaker
- *   until 1.0: 0.13.6 sets no communication mode, and so chooses no
- *   earpiece.
+ *   but in hands-free: the library sets no communication mode otherwise,
+ *   and so chooses no earpiece.
  * - **The earbuds' microphone on iPhones** (`allowBluetoothHFP`): their
  *   hands-free profile, at call quality, for the whole conversation — not
- *   switched per press, since every switch moves the route and 0.13.6's
- *   engine can die on a Bluetooth route change (its #1209, for R3). Android
- *   records from the phone until 1.0, whose `setInputDevice` works.
- * - **`default` mode, not `voiceChat`**: on 0.13.6 `voiceChat` cancels no
- *   echo — push-to-talk needs none, as the reply stops while the person
- *   speaks — and plays at the call volume, quieter on the loudspeaker.
+ *   switched per press, since every switch moves the route and the
+ *   library's engine can die on a Bluetooth route change (its #1209).
+ * - **`default` mode, not `voiceChat`**, for push-to-talk and half-duplex:
+ *   neither needs echo cancelled — the reply stops while the person speaks,
+ *   or nothing is heard while it plays — and `voiceChat` plays at the call
+ *   volume, quieter on the loudspeaker.
+ * - **Hands-free, on the pinned nightly** (`handsFree`): iOS's
+ *   `videoChat` — set before the recorder's voice processing, which would
+ *   otherwise move the session to `voiceChat` and the earpiece — and
+ *   Android's communication mode, its voice to the loudspeaker (or the
+ *   earpiece asked), to Bluetooth earbuds when they are connected: the
+ *   canceller hears only audio on the call's path, and the earbuds'
+ *   microphone comes with it (D8).
  * - **Interruptions are watched** (`observeAudioInterruptions`): a call,
  *   Siri or another app on iOS, a loss of audio focus on Android — which
  *   watching *asks for*, so other apps' audio stops while a conversation is
@@ -26,17 +35,104 @@
  *   audio in this release (the plugin turns the library's off), so the
  *   conversation pauses with the screen and goes on when it is back.
  */
-import { AppState } from "react-native";
+import { AppState, Platform } from "react-native";
 import { AudioManager } from "react-native-audio-api";
-/** The audio session's category, mode and options for `output`. */
-export function configure(output) {
-    AudioManager.setAudioSessionOptions({
-        iosCategory: "playAndRecord",
-        iosMode: "default",
-        iosOptions: output === "speaker"
-            ? ["defaultToSpeaker", "allowBluetoothHFP"]
-            : ["allowBluetoothHFP"],
+import library from "react-native-audio-api/package.json";
+/**
+ * **The one `react-native-audio-api` build hands-free runs on before 1.0**
+ * (D17, D18): 1.0 is the first with echo cancellation — iOS's voice
+ * processing, Android's voice-communication audio — and is not released
+ * (no date, 2026-11-02), so one nightly, read in its source and tested,
+ * never "the latest": nightlies change under an app, and its iOS voice
+ * processing was weeks old. This one is commit 6fd4c68, built unchanged on
+ * 2026-10-31, 11-01 and 11-02 — the build npm's `audio-api-nightly` tag
+ * named on 2026-11-02. **Moved only for a fix we need, after a test on a
+ * real iPhone and Android; 1.0 replaces it.** Every other build, 0.13
+ * included, refuses hands-free and runs push-to-talk and half-duplex.
+ * `package.json`'s peer range names it too (`test/package.test.ts`).
+ */
+export const PINNED_NIGHTLY = "1.0.0-nightly-6fd4c68-20261102";
+/** The library's version, as installed. */
+export const libraryVersion = () => library.version;
+/** 1.0's session API: `setSystemOptions` for 0.13's `setAudioSessionOptions`. */
+const isOne = () => typeof AudioManager.setSystemOptions === "function";
+/** Whether this is the build hands-free runs on: echo can be cancelled. */
+export const cancelsEcho = () => isOne() && library.version === PINNED_NIGHTLY;
+/** Android, where the reply must be on the call's path for its echo to be cancelled. */
+export const android = () => Platform.OS === "android";
+/**
+ * The audio session's category, mode and options for `output`, for
+ * hands-free or not. Settles at once but for Android's session on 1.0,
+ * which takes a mode only as it is made active, so is made again.
+ */
+export async function configure(output, handsFree = false, 
+/** `false` when the adapter is gone: the mode given back, the session left inactive. */
+active = true) {
+    const options = output === "speaker"
+        ? ["defaultToSpeaker", "allowBluetoothHFP"]
+        : ["allowBluetoothHFP"];
+    // Voice processing takes a mode that is no call's to `voiceChat` itself,
+    // and the library then sets its own again on every activation: a chat
+    // mode set first — `videoChat`, the loudspeaker's, or `voiceChat`, the
+    // earpiece's. Never without it: the call volume.
+    const mode = !handsFree
+        ? "default"
+        : output === "speaker"
+            ? "videoChat"
+            : "voiceChat";
+    if (!isOne()) {
+        AudioManager.setAudioSessionOptions?.({
+            iosCategory: "playAndRecord",
+            iosMode: mode,
+            iosOptions: options,
+        });
+        return;
+    }
+    // Both groups every time: one left out is set to its defaults.
+    AudioManager.setSystemOptions?.({
+        ios: { category: "playAndRecord", mode, options },
+        android: handsFree
+            ? { mode: "inCommunication", communicationDevice: output }
+            : {},
     });
+    if (android() && communicating !== handsFree) {
+        // Its communication mode is set, and the mode before it given back,
+        // only as the session is made active and inactive — which gives up the
+        // audio focus and takes it again: told as an interruption, which the
+        // adapter takes for none (`audio.native.ts`, `settling`).
+        communicating = handsFree;
+        await AudioManager.setAudioSessionActivity(false);
+        if (active)
+            await AudioManager.setAudioSessionActivity(true);
+    }
+}
+/** Android's communication mode is on: hands-free's session was made. */
+let communicating = false;
+/**
+ * Hands-free on Android: the call's voice to Bluetooth earbuds when they
+ * are connected — and their microphone with it (D8) — else to `output`.
+ * Asked again when a device comes or goes, never twice the same: the
+ * library's own Bluetooth link sets the device too, and its change is told
+ * as a route's. `asked`, the last asked; answers what is now. Nothing on
+ * iOS, whose route follows `allowBluetoothHFP` by itself, nor on 0.13.
+ */
+export async function route(output, asked) {
+    if (!android() || !isOne() || !AudioManager.getDevicesInfo)
+        return asked;
+    const { availableOutputs } = await AudioManager.getDevicesInfo();
+    // Earbuds with a microphone, as the library names Android's device
+    // types: a speaker on Bluetooth alone (A2DP) has none, and with
+    // `systemDefault` the call would go to the earpiece.
+    const earbuds = availableOutputs.some((device) => /^Bluetooth (SCO|LE Headset)$/.test(device.category));
+    const device = earbuds ? "systemDefault" : output;
+    if (device !== asked)
+        await AudioManager.setCommunicationDevice?.(device);
+    return device;
+}
+/** Every change of the devices — earbuds connected, taken out — until the answer is called. */
+export function watchRoutes(fn) {
+    const subscription = AudioManager.addSystemEventListener("routeChange", () => fn());
+    return () => subscription.remove();
 }
 /** Make the session active: before the first sound, and after an interruption. */
 export function activate() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@lumavox/react-native",
-  "version": "0.15.1",
-  "description": "Voice conversations with Lumavox agents in a React Native app, on iOS, Android and the web: the client, the React hooks, and push-to-talk audio on react-native-audio-api.",
+  "version": "0.17.0",
+  "description": "Voice conversations with Lumavox agents in a React Native app, on iOS, Android and the web: the client, the React hooks, and push-to-talk, half-duplex and hands-free audio on react-native-audio-api.",
   "license": "MIT",
   "files": [
     "dist",
@@ -30,13 +30,13 @@
     "typecheck": "tsc --noEmit && tsc --noEmit -p test"
   },
   "dependencies": {
-    "@lumavox/client": "0.15.1",
-    "@lumavox/react": "0.15.1"
+    "@lumavox/client": "0.17.0",
+    "@lumavox/react": "0.17.0"
   },
   "peerDependencies": {
     "react": ">=18",
     "react-native": ">=0.76",
-    "react-native-audio-api": ">=0.13.6 <0.14"
+    "react-native-audio-api": ">=0.13.6 <0.14 || 1.0.0-nightly-6fd4c68-20261102"
   },
   "peerDependenciesMeta": {
     "react-native": {