opuslib 0.1.4 → 0.2.0

package/build/OpuslibModule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpuslibModule.d.ts","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,cAAc,EACd,UAAU,EACV,YAAY,EACb,MAAM,iBAAiB,CAAA;AAoCxB;;;;;GAKG;;IAED;;;;;;;;;;;;;;;OAeG;6BACsB,WAAW;IAEpC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;OAuBG;iBAIsE;QACvE,CACE,SAAS,EAAE,YAAY,EACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GACzC,YAAY,CAAA;QACf,CACE,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACxC,YAAY,CAAA;QACf,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,YAAY,CAAA;KAC1E;IAED;;;;;OAKG;qCAES,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KACxC,YAAY;IAEf;;;;;OAKG;iCAC0B,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,KAAG,YAAY;;AAzFzE,wBA2FC"}
+{"version":3,"file":"OpuslibModule.d.ts","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,WAAW,EACX,eAAe,EACf,cAAc,EACd,iBAAiB,EACjB,aAAa,EACb,UAAU,EACV,YAAY,EACb,MAAM,iBAAiB,CAAA;AAoCxB;;;;;GAKG;;IAED;;;;;;;;;;;;;;;OAeG;6BACsB,WAAW;IAEpC;;OAEG;;IAGH;;OAEG;;IAGH;;OAEG;;IAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;iBAgBsE;QACvE,CACE,SAAS,EAAE,YAAY,EACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,GACzC,YAAY,CAAA;QACf,CACE,SAAS,EAAE,WAAW,EACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,GACxC,YAAY,CAAA;QACf,CACE,SAAS,EAAE,cAAc,EACzB,QAAQ,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,GAC3C,YAAY,CAAA;QACf,CACE,SAAS,EAAE,UAAU,EACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,GACvC,YAAY,CAAA;QACf,CAAC,SAAS,EAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,GAAG,YAAY,CAAA;KAC1E;IAED;;;;;OAKG;qCAES,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,KACxC,YAAY;IAEf;;;;;;;OAOG;wCAES,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,KAC3C,YAAY;IAEf;;;;;;OAMG;oCAES,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,KACvC,YAAY;IAEf;;;;;OAKG;iCAC0B,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,KAAG,YAAY;;AA5IzE,wBA8IC"}

package/build/OpuslibModule.js

@@ -53,6 +53,14 @@ export default {
      *   websocket.send(event.data)
      * })
      *
+     * // Listen for session lifecycle
+     * Opuslib.addListener('audioStarted', (event) => {
+     *   console.log('Started; decoder pre-skip:', event.preSkip)
+     * })
+     * Opuslib.addListener('audioEnd', (event) => {
+     *   console.log(`Ended: ${event.totalPackets} packets in ${event.totalDuration}ms`)
+     * })
+     *
      * // Listen for errors
      * const errorSub = Opuslib.addListener('error', (event) => {
      *   console.error('Error:', event.message)
@@ -71,6 +79,23 @@ export default {
      * @returns Subscription object with remove() method
      */
     addAmplitudeListener: (listener) => emitter.addListener('amplitude', listener),
+    /**
+     * Listen for the `audioStarted` event, emitted once when streaming begins.
+     * Carries the active config and the Opus encoder `preSkip` (lookahead) so a
+     * decoder knows how many samples to skip at the start of the stream.
+     *
+     * @param listener Event listener callback
+     * @returns Subscription object with remove() method
+     */
+    addAudioStartedListener: (listener) => emitter.addListener('audioStarted', listener),
+    /**
+     * Listen for the `audioEnd` event, emitted once when streaming stops (after
+     * the final buffered audio has been flushed). Carries the session summary.
+     *
+     * @param listener Event listener callback
+     * @returns Subscription object with remove() method
+     */
+    addAudioEndListener: (listener) => emitter.addListener('audioEnd', listener),
     /**
      * Listen for error events
      *

package/build/OpuslibModule.js.map

@@ -1 +1 @@
-{"version":3,"file":"OpuslibModule.js","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAsCtE,kCAAkC;AAClC,MAAM,aAAa,GAAG,mBAAmB,CAAoB,SAAS,CAAC,CAAA;AAEvE,+CAA+C;AAC/C,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,aAAoB,CAAC,CAAA;AAEtD;;;;;GAKG;AACH,eAAe;IACb;;;;;;;;;;;;;;;OAeG;IACH,cAAc,EAAE,CAAC,MAAmB,EAAE,EAAE,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC;IAE7E;;OAEG;IACH,aAAa,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,aAAa,EAAE;IAElD;;OAEG;IACH,cAAc,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,cAAc,EAAE;IAEpD;;OAEG;IACH,eAAe,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,eAAe,EAAE;IAEtD;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,WAAW,EAAE,CAAC,CACZ,SAA+C,EAC/C,QAAwE,EAC1D,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAUnE;IAED;;;;;OAKG;IACH,oBAAoB,EAAE,CACpB,QAAyC,EAC3B,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC;IAEtE;;;;;OAKG;IACH,gBAAgB,EAAE,CAAC,QAAqC,EAAgB,EAAE,CACvE,OAAe,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC;CAClD,CAAA","sourcesContent":["import { NativeModule, requireNativeModule, EventEmitter } from 'expo'\n\nimport type {\n  AudioConfig,\n  AudioChunkEvent,\n  AmplitudeEvent,\n  ErrorEvent,\n  Subscription,\n} from './Opuslib.types'\n\n/**\n * Opuslib Native Module Interface\n *\n * Provides native audio capture and Opus 1.6.1 encoding with DRED support\n */\ndeclare class OpuslibModuleType extends NativeModule {\n  /**\n   * Start audio streaming with Opus encoding\n   * @param config Audio configuration\n   */\n  startStreaming(config: AudioConfig): Promise<void>\n\n  /**\n   * Stop audio streaming\n   */\n  stopStreaming(): Promise<void>\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming(): void\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming(): void\n}\n\n// Load the native module from JSI\nconst OpuslibModule = requireNativeModule<OpuslibModuleType>('Opuslib')\n\n// Create event emitter for listening to events\nconst emitter = new EventEmitter(OpuslibModule as any)\n\n/**\n * Opuslib - Opus 1.6.1 Audio Encoding with DRED Support\n *\n * This module provides real-time audio capture and Opus 1.6.1 encoding\n * with Deep Redundancy (DRED) for improved quality on lossy networks.\n */\nexport default {\n  /**\n   * Start audio streaming with Opus encoding\n   *\n   * @param config Audio configuration\n   * @example\n   * ```ts\n   * await Opuslib.startStreaming({\n   *   sampleRate: 16000,\n   *   channels: 1,\n   *   bitrate: 24000,\n   *   frameSize: 20,\n   *   packetDuration: 20,\n   *   dredDuration: 100, // Enable 100ms DRED recovery\n   * })\n   * ```\n   */\n  startStreaming: (config: AudioConfig) => OpuslibModule.startStreaming(config),\n\n  /**\n   * Stop audio streaming and release resources\n   */\n  stopStreaming: () => OpuslibModule.stopStreaming(),\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming: () => OpuslibModule.pauseStreaming(),\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming: () => OpuslibModule.resumeStreaming(),\n\n  /**\n   * Listen for events (audioChunk, amplitude, or error)\n   *\n   * @param eventName Event type to listen for\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   * @example\n   * ```ts\n   * // Listen for audio chunks\n   * const subscription = Opuslib.addListener('audioChunk', (event) => {\n   *   console.log('Received Opus packet:', event.data.byteLength, 'bytes')\n   *   websocket.send(event.data)\n   * })\n   *\n   * // Listen for errors\n   * const errorSub = Opuslib.addListener('error', (event) => {\n   *   console.error('Error:', event.message)\n   * })\n   *\n   * // Later: unsubscribe\n   * subscription.remove()\n   * errorSub.remove()\n   * ```\n   */\n  addListener: ((\n    eventName: 'audioChunk' | 'amplitude' | 'error',\n    listener: (event: AudioChunkEvent | AmplitudeEvent | ErrorEvent) => void,\n  ): Subscription => (emitter as any).addListener(eventName, listener)) as {\n    (\n      eventName: 'audioChunk',\n      listener: (event: AudioChunkEvent) => void,\n    ): Subscription\n    (\n      eventName: 'amplitude',\n      listener: (event: AmplitudeEvent) => void,\n    ): Subscription\n    (eventName: 'error', listener: (event: ErrorEvent) => void): Subscription\n  },\n\n  /**\n   * Listen for amplitude events (for waveform visualization)\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addAmplitudeListener: (\n    listener: (event: AmplitudeEvent) => void,\n  ): Subscription => (emitter as any).addListener('amplitude', listener),\n\n  /**\n   * Listen for error events\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addErrorListener: (listener: (event: ErrorEvent) => void): Subscription =>\n    (emitter as any).addListener('error', listener),\n}\n"]}
+{"version":3,"file":"OpuslibModule.js","sourceRoot":"","sources":["../src/OpuslibModule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,mBAAmB,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAwCtE,kCAAkC;AAClC,MAAM,aAAa,GAAG,mBAAmB,CAAoB,SAAS,CAAC,CAAA;AAEvE,+CAA+C;AAC/C,MAAM,OAAO,GAAG,IAAI,YAAY,CAAC,aAAoB,CAAC,CAAA;AAEtD;;;;;GAKG;AACH,eAAe;IACb;;;;;;;;;;;;;;;OAeG;IACH,cAAc,EAAE,CAAC,MAAmB,EAAE,EAAE,CAAC,aAAa,CAAC,cAAc,CAAC,MAAM,CAAC;IAE7E;;OAEG;IACH,aAAa,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,aAAa,EAAE;IAElD;;OAEG;IACH,cAAc,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,cAAc,EAAE;IAEpD;;OAEG;IACH,eAAe,EAAE,GAAG,EAAE,CAAC,aAAa,CAAC,eAAe,EAAE;IAEtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACH,WAAW,EAAE,CAAC,CACZ,SAKW,EACX,QAOS,EACK,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,SAAS,EAAE,QAAQ,CAAC,CAkBnE;IAED;;;;;OAKG;IACH,oBAAoB,EAAE,CACpB,QAAyC,EAC3B,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,WAAW,EAAE,QAAQ,CAAC;IAEtE;;;;;;;OAOG;IACH,uBAAuB,EAAE,CACvB,QAA4C,EAC9B,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,cAAc,EAAE,QAAQ,CAAC;IAEzE;;;;;;OAMG;IACH,mBAAmB,EAAE,CACnB,QAAwC,EAC1B,EAAE,CAAE,OAAe,CAAC,WAAW,CAAC,UAAU,EAAE,QAAQ,CAAC;IAErE;;;;;OAKG;IACH,gBAAgB,EAAE,CAAC,QAAqC,EAAgB,EAAE,CACvE,OAAe,CAAC,WAAW,CAAC,OAAO,EAAE,QAAQ,CAAC;CAClD,CAAA","sourcesContent":["import { NativeModule, requireNativeModule, EventEmitter } from 'expo'\n\nimport type {\n  AudioConfig,\n  AudioChunkEvent,\n  AmplitudeEvent,\n  AudioStartedEvent,\n  AudioEndEvent,\n  ErrorEvent,\n  Subscription,\n} from './Opuslib.types'\n\n/**\n * Opuslib Native Module Interface\n *\n * Provides native audio capture and Opus 1.6.1 encoding with DRED support\n */\ndeclare class OpuslibModuleType extends NativeModule {\n  /**\n   * Start audio streaming with Opus encoding\n   * @param config Audio configuration\n   */\n  startStreaming(config: AudioConfig): Promise<void>\n\n  /**\n   * Stop audio streaming\n   */\n  stopStreaming(): Promise<void>\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming(): void\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming(): void\n}\n\n// Load the native module from JSI\nconst OpuslibModule = requireNativeModule<OpuslibModuleType>('Opuslib')\n\n// Create event emitter for listening to events\nconst emitter = new EventEmitter(OpuslibModule as any)\n\n/**\n * Opuslib - Opus 1.6.1 Audio Encoding with DRED Support\n *\n * This module provides real-time audio capture and Opus 1.6.1 encoding\n * with Deep Redundancy (DRED) for improved quality on lossy networks.\n */\nexport default {\n  /**\n   * Start audio streaming with Opus encoding\n   *\n   * @param config Audio configuration\n   * @example\n   * ```ts\n   * await Opuslib.startStreaming({\n   *   sampleRate: 16000,\n   *   channels: 1,\n   *   bitrate: 24000,\n   *   frameSize: 20,\n   *   packetDuration: 20,\n   *   dredDuration: 100, // Enable 100ms DRED recovery\n   * })\n   * ```\n   */\n  startStreaming: (config: AudioConfig) => OpuslibModule.startStreaming(config),\n\n  /**\n   * Stop audio streaming and release resources\n   */\n  stopStreaming: () => OpuslibModule.stopStreaming(),\n\n  /**\n   * Pause audio streaming (keeps resources allocated)\n   */\n  pauseStreaming: () => OpuslibModule.pauseStreaming(),\n\n  /**\n   * Resume audio streaming\n   */\n  resumeStreaming: () => OpuslibModule.resumeStreaming(),\n\n  /**\n   * Listen for events (audioChunk, amplitude, or error)\n   *\n   * @param eventName Event type to listen for\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   * @example\n   * ```ts\n   * // Listen for audio chunks\n   * const subscription = Opuslib.addListener('audioChunk', (event) => {\n   *   console.log('Received Opus packet:', event.data.byteLength, 'bytes')\n   *   websocket.send(event.data)\n   * })\n   *\n   * // Listen for session lifecycle\n   * Opuslib.addListener('audioStarted', (event) => {\n   *   console.log('Started; decoder pre-skip:', event.preSkip)\n   * })\n   * Opuslib.addListener('audioEnd', (event) => {\n   *   console.log(`Ended: ${event.totalPackets} packets in ${event.totalDuration}ms`)\n   * })\n   *\n   * // Listen for errors\n   * const errorSub = Opuslib.addListener('error', (event) => {\n   *   console.error('Error:', event.message)\n   * })\n   *\n   * // Later: unsubscribe\n   * subscription.remove()\n   * errorSub.remove()\n   * ```\n   */\n  addListener: ((\n    eventName:\n      | 'audioChunk'\n      | 'amplitude'\n      | 'audioStarted'\n      | 'audioEnd'\n      | 'error',\n    listener: (\n      event:\n        | AudioChunkEvent\n        | AmplitudeEvent\n        | AudioStartedEvent\n        | AudioEndEvent\n        | ErrorEvent,\n    ) => void,\n  ): Subscription => (emitter as any).addListener(eventName, listener)) as {\n    (\n      eventName: 'audioChunk',\n      listener: (event: AudioChunkEvent) => void,\n    ): Subscription\n    (\n      eventName: 'amplitude',\n      listener: (event: AmplitudeEvent) => void,\n    ): Subscription\n    (\n      eventName: 'audioStarted',\n      listener: (event: AudioStartedEvent) => void,\n    ): Subscription\n    (\n      eventName: 'audioEnd',\n      listener: (event: AudioEndEvent) => void,\n    ): Subscription\n    (eventName: 'error', listener: (event: ErrorEvent) => void): Subscription\n  },\n\n  /**\n   * Listen for amplitude events (for waveform visualization)\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addAmplitudeListener: (\n    listener: (event: AmplitudeEvent) => void,\n  ): Subscription => (emitter as any).addListener('amplitude', listener),\n\n  /**\n   * Listen for the `audioStarted` event, emitted once when streaming begins.\n   * Carries the active config and the Opus encoder `preSkip` (lookahead) so a\n   * decoder knows how many samples to skip at the start of the stream.\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addAudioStartedListener: (\n    listener: (event: AudioStartedEvent) => void,\n  ): Subscription => (emitter as any).addListener('audioStarted', listener),\n\n  /**\n   * Listen for the `audioEnd` event, emitted once when streaming stops (after\n   * the final buffered audio has been flushed). Carries the session summary.\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addAudioEndListener: (\n    listener: (event: AudioEndEvent) => void,\n  ): Subscription => (emitter as any).addListener('audioEnd', listener),\n\n  /**\n   * Listen for error events\n   *\n   * @param listener Event listener callback\n   * @returns Subscription object with remove() method\n   */\n  addErrorListener: (listener: (event: ErrorEvent) => void): Subscription =>\n    (emitter as any).addListener('error', listener),\n}\n"]}

package/build/OpuslibModule.web.d.ts

@@ -16,6 +16,12 @@ declare const _default: {
     addAmplitudeListener: () => {
         remove: () => void;
     };
+    addAudioStartedListener: () => {
+        remove: () => void;
+    };
+    addAudioEndListener: () => {
+        remove: () => void;
+    };
     addErrorListener: () => {
         remove: () => void;
     };

package/build/OpuslibModule.web.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OpuslibModule.web.d.ts","sourceRoot":"","sources":["../src/OpuslibModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAElD;;;;;GAKG;;6BAE8B,WAAW,KAAG,OAAO,CAAC,IAAI,CAAC;yBAMjC,OAAO,CAAC,IAAI,CAAC;0BAMlB,IAAI;2BAMH,IAAI;;;;;;;;;;;AAnB3B,wBAoCC"}
+{"version":3,"file":"OpuslibModule.web.d.ts","sourceRoot":"","sources":["../src/OpuslibModule.web.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAElD;;;;;GAKG;;6BAE8B,WAAW,KAAG,OAAO,CAAC,IAAI,CAAC;yBAMjC,OAAO,CAAC,IAAI,CAAC;0BAMlB,IAAI;2BAMH,IAAI;;;;;;;;;;;;;;;;;AAnB3B,wBA4CC"}

package/build/OpuslibModule.web.js

@@ -23,6 +23,12 @@ export default {
     addAmplitudeListener: () => ({
         remove: () => { },
     }),
+    addAudioStartedListener: () => ({
+        remove: () => { },
+    }),
+    addAudioEndListener: () => ({
+        remove: () => { },
+    }),
     addErrorListener: () => ({
         remove: () => { },
     }),

package/build/OpuslibModule.web.js.map

@@ -1 +1 @@
-{"version":3,"file":"OpuslibModule.web.js","sourceRoot":"","sources":["../src/OpuslibModule.web.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAe;IACb,cAAc,EAAE,KAAK,EAAE,MAAmB,EAAiB,EAAE;QAC3D,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,aAAa,EAAE,KAAK,IAAmB,EAAE;QACvC,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,cAAc,EAAE,GAAS,EAAE;QACzB,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,eAAe,EAAE,GAAS,EAAE;QAC1B,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC;QAClB,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IAEF,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC3B,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IAEF,gBAAgB,EAAE,GAAG,EAAE,CAAC,CAAC;QACvB,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;CACH,CAAA","sourcesContent":["import type { AudioConfig } from './Opuslib.types'\n\n/**\n * Web implementation of Opuslib (placeholder)\n *\n * Note: Web implementation requires WebRTC or WebAssembly Opus encoder\n * This is a stub for now - native platforms only\n */\nexport default {\n  startStreaming: async (config: AudioConfig): Promise<void> => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  stopStreaming: async (): Promise<void> => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  pauseStreaming: (): void => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  resumeStreaming: (): void => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  addListener: () => ({\n    remove: () => {},\n  }),\n\n  addAmplitudeListener: () => ({\n    remove: () => {},\n  }),\n\n  addErrorListener: () => ({\n    remove: () => {},\n  }),\n}\n"]}
+{"version":3,"file":"OpuslibModule.web.js","sourceRoot":"","sources":["../src/OpuslibModule.web.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAe;IACb,cAAc,EAAE,KAAK,EAAE,MAAmB,EAAiB,EAAE;QAC3D,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,aAAa,EAAE,KAAK,IAAmB,EAAE;QACvC,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,cAAc,EAAE,GAAS,EAAE;QACzB,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,eAAe,EAAE,GAAS,EAAE;QAC1B,MAAM,IAAI,KAAK,CACb,+DAA+D,CAChE,CAAA;IACH,CAAC;IAED,WAAW,EAAE,GAAG,EAAE,CAAC,CAAC;QAClB,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IAEF,oBAAoB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC3B,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IAEF,uBAAuB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC9B,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IAEF,mBAAmB,EAAE,GAAG,EAAE,CAAC,CAAC;QAC1B,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;IAEF,gBAAgB,EAAE,GAAG,EAAE,CAAC,CAAC;QACvB,MAAM,EAAE,GAAG,EAAE,GAAE,CAAC;KACjB,CAAC;CACH,CAAA","sourcesContent":["import type { AudioConfig } from './Opuslib.types'\n\n/**\n * Web implementation of Opuslib (placeholder)\n *\n * Note: Web implementation requires WebRTC or WebAssembly Opus encoder\n * This is a stub for now - native platforms only\n */\nexport default {\n  startStreaming: async (config: AudioConfig): Promise<void> => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  stopStreaming: async (): Promise<void> => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  pauseStreaming: (): void => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  resumeStreaming: (): void => {\n    throw new Error(\n      'Opuslib is not supported on web platform. Use iOS or Android.',\n    )\n  },\n\n  addListener: () => ({\n    remove: () => {},\n  }),\n\n  addAmplitudeListener: () => ({\n    remove: () => {},\n  }),\n\n  addAudioStartedListener: () => ({\n    remove: () => {},\n  }),\n\n  addAudioEndListener: () => ({\n    remove: () => {},\n  }),\n\n  addErrorListener: () => ({\n    remove: () => {},\n  }),\n}\n"]}

package/ios/AudioEngineManager.swift

@@ -2,52 +2,42 @@ import AVFoundation
 import ExpoModulesCore
 
 /**
- * AudioEngineManager - Manages AVAudioEngine for real-time audio capture with Opus 1.6.1 DRED
+ * AudioEngineManager - Manages AVAudioEngine for real-time audio capture.
  *
- * This class handles:
- * - Audio session configuration
- * - AVAudioEngine setup and lifecycle
- * - Real-time PCM audio capture
- * - Opus 1.6.1 encoding with DRED support
- * - Audio interruption handling
- * - Microphone permission management
+ * This class handles ONLY audio capture (AVAudioEngine lifecycle, audio session
+ * configuration, the real-time tap callback, and interruption handling). All
+ * Opus 1.6.1 encoding is delegated to AudioProcessor, which runs on its own
+ * serial queue. The tap callback only converts the PCM format and copies the
+ * samples across to the encoding queue — it never blocks on the encoder.
  */
 class AudioEngineManager {
   // Audio engine and nodes
   private var audioEngine: AVAudioEngine?
   private var inputNode: AVAudioInputNode?
 
-  // Opus encoder
-  private var opusEncoder: OpusEncoder?
-
   // Audio format converter
   private var audioConverter: AVAudioConverter?
 
-  // Configuration
-  private var config: AudioConfig
-  private var sequenceNumber: Int = 0
+  // Encoding processor (owns the encoder, runs on a separate serial queue)
+  private var processor: AudioProcessor?
+
+  // Configuration (immutable after init)
+  private let config: AudioConfig
 
-  // State
+  // Recording state
   private var isRecording = false
   private var isPaused = false
   private var loggedFirstBuffer = false
 
-  // Frame accumulation for packet duration
-  private var frameBuffer: [[Int16]] = []
-  private let framesPerPacket: Int
-
   // Event callbacks
-  private var onAudioChunk: ((Data, Double, Int) -> Void)?
+  private var onAudioChunk: (([EncodedFrame], Double, Int, Double, Int) -> Void)?
+  private var onStarted: ((_ timestamp: Double, _ sampleRate: Int, _ channels: Int, _ bitrate: Int, _ frameSize: Double, _ preSkip: Int) -> Void)?
+  private var onEnd: ((_ timestamp: Double, _ totalDuration: Double, _ totalPackets: Int) -> Void)?
   private var onAmplitude: ((Float, Float, Double) -> Void)?
   private var onError: ((Error) -> Void)?
 
-  // Debug file handles
-  private var pcmFileHandle: FileHandle?
-  private var pcmFileURL: URL?
-
   init(config: AudioConfig) {
     self.config = config
-    self.framesPerPacket = Int(config.packetDuration / config.frameSize)
 
     // Register for interruption notifications
     NotificationCenter.default.addObserver(
@@ -68,15 +58,28 @@ class AudioEngineManager {
     // Configure audio session
     try configureAudioSession()
 
-    // Create Opus encoder with DRED support
-    let dredDuration = config.dredDuration ?? 100
-    opusEncoder = try OpusEncoder(
-      sampleRate: config.sampleRate,
-      channels: config.channels,
-      bitrate: config.bitrate,
-      frameSizeMs: config.frameSize,
-      dredDurationMs: dredDuration
-    )
+    // Create and start the AudioProcessor (encoding thread)
+    let proc = AudioProcessor(config: config)
+    proc.setOnAudioChunk { [weak self] frames, timestamp, seq, duration, frameCount in
+      self?.onAudioChunk?(frames, timestamp, seq, duration, frameCount)
+    }
+    proc.setOnStarted { [weak self] timestamp, sampleRate, channels, bitrate, frameSize, preSkip in
+      self?.onStarted?(timestamp, sampleRate, channels, bitrate, frameSize, preSkip)
+    }
+    proc.setOnEnd { [weak self] timestamp, totalDuration, totalPackets in
+      self?.onEnd?(timestamp, totalDuration, totalPackets)
+    }
+
+    // Debug file
+    var debugURL: URL? = nil
+    if config.saveDebugAudio == true {
+      let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
+      let timestamp = Date().timeIntervalSince1970
+      debugURL = documentsPath.appendingPathComponent("debug_pcm_\(timestamp).raw")
+    }
+
+    try proc.start(debugFileURL: debugURL)
+    processor = proc
 
     // Create and configure AVAudioEngine
     audioEngine = AVAudioEngine()
@@ -114,13 +117,13 @@ class AudioEngineManager {
     // Calculate buffer size for one frame
     let bufferSize: AVAudioFrameCount = 1024
 
-    // Install tap on input node with hardware format
+    // Install tap — real-time thread callback, only does format convert + copy + post
     inputNode.installTap(
       onBus: 0,
       bufferSize: bufferSize,
       format: hardwareFormat
-    ) { [weak self] buffer, time in
-      self?.processBuffer(buffer, time: time)
+    ) { [weak self] buffer, _ in
+      self?.onTapBuffer(buffer)
     }
 
     // Start audio engine
@@ -128,28 +131,7 @@ class AudioEngineManager {
 
     isRecording = true
 
-    // Create debug output files if enabled
-    if config.saveDebugAudio == true {
-      do {
-        let documentsPath = FileManager.default.urls(for: .documentDirectory, in: .userDomainMask)[0]
-        let timestamp = Date().timeIntervalSince1970
-
-        pcmFileURL = documentsPath.appendingPathComponent("debug_pcm_\(timestamp).raw")
-
-        // Create PCM file
-        FileManager.default.createFile(atPath: pcmFileURL!.path, contents: nil, attributes: nil)
-
-        // Open file handle for writing
-        pcmFileHandle = try FileHandle(forWritingTo: pcmFileURL!)
-
-        print("[AudioEngineManager] Debug audio file created:")
-        print("  PCM: \(pcmFileURL!.path)")
-      } catch {
-        print("[AudioEngineManager] Failed to create debug files: \(error)")
-      }
-    }
-
-    print("[AudioEngineManager] Started recording: \(hardwareFormat.sampleRate)Hz → \(config.sampleRate)Hz, \(config.channels) ch, DRED: \(dredDuration)ms")
+    print("[AudioEngineManager] Started recording: \(hardwareFormat.sampleRate)Hz → \(config.sampleRate)Hz, \(config.channels) ch")
   }
 
   func stop() {
@@ -157,26 +139,21 @@ class AudioEngineManager {
       return
     }
 
-    // Remove tap and stop engine
+    isRecording = false
+
+    // Stop audio capture
     inputNode?.removeTap(onBus: 0)
     audioEngine?.stop()
 
+    // Flush and stop the encoding thread (synchronous — drains remaining samples,
+    // pads the final partial frame with silence, and emits audioEnd)
+    processor?.flushAndStop()
+    processor = nil
+
     // Clean up
     audioEngine = nil
     inputNode = nil
-    opusEncoder = nil
     audioConverter = nil
-    frameBuffer.removeAll()
-
-    isRecording = false
-    sequenceNumber = 0
-
-    // Close debug file handle
-    if let fileHandle = pcmFileHandle {
-      fileHandle.closeFile()
-      pcmFileHandle = nil
-      print("[AudioEngineManager] Closed PCM debug file: \(pcmFileURL?.path ?? "")")
-    }
 
     print("[AudioEngineManager] Stopped recording")
   }
@@ -193,10 +170,18 @@ class AudioEngineManager {
 
   // MARK: - Event Handlers
 
-  func setOnAudioChunk(_ callback: @escaping (Data, Double, Int) -> Void) {
+  func setOnAudioChunk(_ callback: @escaping ([EncodedFrame], Double, Int, Double, Int) -> Void) {
     self.onAudioChunk = callback
   }
 
+  func setOnStarted(_ callback: @escaping (_ timestamp: Double, _ sampleRate: Int, _ channels: Int, _ bitrate: Int, _ frameSize: Double, _ preSkip: Int) -> Void) {
+    self.onStarted = callback
+  }
+
+  func setOnEnd(_ callback: @escaping (_ timestamp: Double, _ totalDuration: Double, _ totalPackets: Int) -> Void) {
+    self.onEnd = callback
+  }
+
   func setOnAmplitude(_ callback: @escaping (Float, Float, Double) -> Void) {
     self.onAmplitude = callback
   }
@@ -205,142 +190,126 @@ class AudioEngineManager {
     self.onError = callback
   }
 
-  // MARK: - Private Methods
+  // MARK: - Real-time Audio Thread (tap callback)
+  // Only does format conversion + copy + post. No encoding, no locks.
 
-  private func processBuffer(_ buffer: AVAudioPCMBuffer, time: AVAudioTime) {
-    guard !isPaused else {
-      return
-    }
-
-    guard let audioConverter = audioConverter else {
-      return
-    }
+  private func onTapBuffer(_ buffer: AVAudioPCMBuffer) {
+    guard !isPaused else { return }
+    guard let audioConverter = audioConverter else { return }
 
     // Calculate output buffer size based on sample rate conversion
-    let outputSampleRate = Double(config.sampleRate)
-    let inputSampleRate = buffer.format.sampleRate
-    let sampleRateRatio = outputSampleRate / inputSampleRate
+    let sampleRateRatio = Double(config.sampleRate) / buffer.format.sampleRate
     let outputFrameCapacity = AVAudioFrameCount(Double(buffer.frameLength) * sampleRateRatio)
 
-    // Create output buffer in desired format (16kHz, Int16)
+    // Create output buffer in desired format (e.g. 16kHz, Int16)
     guard let outputFormat = audioConverter.outputFormat as? AVAudioFormat,
           let convertedBuffer = AVAudioPCMBuffer(
             pcmFormat: outputFormat,
             frameCapacity: outputFrameCapacity
-          ) else {
-      return
-    }
+          ) else { return }
 
     // Convert audio from hardware format to desired format
     var error: NSError?
-    let inputBlock: AVAudioConverterInputBlock = { inNumPackets, outStatus in
+    let inputBlock: AVAudioConverterInputBlock = { _, outStatus in
       outStatus.pointee = .haveData
       return buffer
     }
 
     let status = audioConverter.convert(to: convertedBuffer, error: &error, withInputFrom: inputBlock)
+    if status == .error { return }
 
-    if status == .error {
-      return
-    }
-
-    // Process the converted Int16 data
-    guard let channelData = convertedBuffer.int16ChannelData else {
-      return
-    }
+    guard let channelData = convertedBuffer.int16ChannelData else { return }
 
     let frameLength = Int(convertedBuffer.frameLength)
     let channelDataPointer = channelData[0]
 
-    // DEBUG: Log first buffer to verify conversion
     if !loggedFirstBuffer {
       print("[AudioEngineManager] First converted buffer: \(frameLength) samples at \(convertedBuffer.format.sampleRate)Hz")
       loggedFirstBuffer = true
     }
 
-    // Copy PCM data to frame buffer
-    let frame = Array(UnsafeBufferPointer(start: channelDataPointer, count: frameLength))
-
-    // Save PCM to debug file if enabled
-    if let fileHandle = pcmFileHandle {
-      let data = Data(bytes: channelDataPointer, count: frameLength * MemoryLayout<Int16>.size)
-      fileHandle.write(data)
-    }
-
-    frameBuffer.append(frame)
-
-    // Calculate how many samples we need for one packet
-    let samplesPerPacket = Int(Double(config.sampleRate) * config.packetDuration / 1000.0)
-    let currentSampleCount = frameBuffer.reduce(0) { $0 + $1.count }
-
-    // When we have enough samples for a packet, encode and send
-    if currentSampleCount >= samplesPerPacket {
-      encodeAndSendPacket(timestamp: time.sampleTime)
-    }
+    // Copy the PCM and post it to the encoding queue (does not block the tap)
+    let samples = Array(UnsafeBufferPointer(start: channelDataPointer, count: frameLength))
+    processor?.pushSamples(samples)
   }
 
-  private func encodeAndSendPacket(timestamp: AVAudioFramePosition) {
-    guard let opusEncoder = opusEncoder else {
-      return
-    }
-
-    // Flatten frame buffer into continuous PCM data
-    let pcmData = frameBuffer.flatMap { $0 }
-
-    // Calculate samples per frame
-    let samplesPerFrame = Int(Double(config.sampleRate) * config.frameSize / 1000.0)
-
-    // We should only encode when we have at least one frame
-    guard pcmData.count >= samplesPerFrame else {
-      return
-    }
+  // MARK: - Audio Session
 
-    // Take only ONE frame worth of samples
-    let frameData = Array(pcmData.prefix(samplesPerFrame))
+  private func configureAudioSession() throws {
+    let audioSession = AVAudioSession.sharedInstance()
 
-    // Encode this single frame to Opus (with DRED padding if enabled)
-    var encodedPacket: Data?
-    frameData.withUnsafeBufferPointer { bufferPointer in
-      guard let baseAddress = bufferPointer.baseAddress else {
-        return
+    let sessionConfig = config.iosAudioSession
+    let category = Self.mapCategory(sessionConfig?.category)
+    let mode = Self.mapMode(sessionConfig?.mode)
+    let options = Self.mapOptions(sessionConfig?.options)
+
+    // Try the requested config first; if it is an invalid combination, fall back to safe defaults
+    do {
+      try audioSession.setCategory(category, mode: mode, options: options)
+      print("[AudioEngineManager] Audio session configured: category=\(category.rawValue), mode=\(mode.rawValue), options=\(options.rawValue)")
+    } catch {
+      print("[AudioEngineManager] Custom audio session config failed (\(error.localizedDescription)), falling back to defaults")
+      do {
+        try audioSession.setCategory(.record, mode: .measurement, options: [])
+        print("[AudioEngineManager] Audio session configured with defaults: category=record, mode=measurement, options=[]")
+      } catch {
+        print("[AudioEngineManager] Fallback audio session config also failed: \(error.localizedDescription), continuing with current session")
       }
-
-      encodedPacket = opusEncoder.encode(pcm: baseAddress, frameSize: samplesPerFrame)
     }
 
-    guard let opusData = encodedPacket, !opusData.isEmpty else {
-      print("[AudioEngineManager] Failed to encode Opus packet")
-      frameBuffer.removeAll()
-      return
-    }
-
-    // Calculate timestamp in milliseconds
-    let timestampMs = Date().timeIntervalSince1970 * 1000
+    // setPreferredSampleRate / setPreferredIOBufferDuration are hints, not hard requirements — don't let them crash
+    do { try audioSession.setPreferredSampleRate(Double(config.sampleRate)) }
+    catch { print("[AudioEngineManager] setPreferredSampleRate failed: \(error.localizedDescription)") }
 
-    // Emit audioChunk event with Opus packet (may be larger due to DRED)
-    onAudioChunk?(opusData, timestampMs, sequenceNumber)
+    do { try audioSession.setPreferredIOBufferDuration(config.frameSize / 1000.0) }
+    catch { print("[AudioEngineManager] setPreferredIOBufferDuration failed: \(error.localizedDescription)") }
 
-    sequenceNumber += 1
+    try audioSession.setActive(true)
+  }
 
-    // Keep any remaining samples for next packet
-    let remainingSamples = pcmData.count - samplesPerFrame
-    if remainingSamples > 0 {
-      frameBuffer = [Array(pcmData[samplesPerFrame...])]
-    } else {
-      frameBuffer.removeAll()
+  // MARK: - String → AVAudioSession Mapping
+
+  private static func mapCategory(_ value: String?) -> AVAudioSession.Category {
+    guard let value = value else { return .record }
+    switch value {
+    case "record":          return .record
+    case "playAndRecord":   return .playAndRecord
+    case "playback":        return .playback
+    case "ambient":         return .ambient
+    default:
+      print("[AudioEngineManager] Unknown category '\(value)', falling back to .record")
+      return .record
     }
   }
 
-  private func configureAudioSession() throws {
-    let audioSession = AVAudioSession.sharedInstance()
-
-    try audioSession.setCategory(.record, mode: .measurement, options: [])
-    try audioSession.setPreferredSampleRate(Double(config.sampleRate))
-    try audioSession.setPreferredIOBufferDuration(config.frameSize / 1000.0)
-
-    try audioSession.setActive(true)
+  private static func mapMode(_ value: String?) -> AVAudioSession.Mode {
+    guard let value = value else { return .measurement }
+    switch value {
+    case "default":         return .default
+    case "voiceChat":       return .voiceChat
+    case "measurement":     return .measurement
+    case "spokenAudio":     return .spokenAudio
+    default:
+      print("[AudioEngineManager] Unknown mode '\(value)', falling back to .measurement")
+      return .measurement
+    }
+  }
 
-    print("[AudioEngineManager] Audio session configured")
+  private static func mapOptions(_ values: [String]?) -> AVAudioSession.CategoryOptions {
+    guard let values = values else { return [] }
+    var options: AVAudioSession.CategoryOptions = []
+    for value in values {
+      switch value {
+      case "mixWithOthers":       options.insert(.mixWithOthers)
+      case "defaultToSpeaker":    options.insert(.defaultToSpeaker)
+      case "allowBluetooth":      options.insert(.allowBluetooth)
+      case "allowAirPlay":        options.insert(.allowAirPlay)
+      case "allowBluetoothA2DP":  options.insert(.allowBluetoothA2DP)
+      default:
+        print("[AudioEngineManager] Unknown option '\(value)', skipping")
+      }
+    }
+    return options
   }
 
   @objc private func handleInterruption(_ notification: Notification) {