@symbiote-native/audio 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,249 @@
+# @symbiote-native/audio
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-audio`](https://github.com/expo/expo/tree/main/packages/expo-audio) usable from **every**
+adapter — React, Vue, Svelte, Solid, and Angular. `AudioPlayer`, `AudioRecorder`, `AudioPlaylist`,
+and `AudioStream` are JSI-backed `SharedObject` instances — per-instance native objects with real
+state and methods, not one-shot functions — so there is no hook/composable/service wrapper here
+either: the React, Vue, Svelte, Solid, and Angular entry points are plain re-exports of the same
+`core`, and each adapter's own lifecycle code (the equivalent of upstream's `useAudioPlayer`)
+decides when to create one and when to call `.remove()` / `.destroy()`.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --audio
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --audio
+```
+
+Either way: installs `@symbiote-native/audio`, wires the native autolinking automatically, and — since
+this package has an optional, policy-sensitive Android bundle — asks at the end whether to grant
+background recording too (see the note below the manual-install block). See
+[`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/audio
+```
+
+`expo-audio` and `expo-modules-core` come along as regular dependencies, pinned to exact
+versions — never install either yourself, and never add the `expo` meta-package to your project
+(it bundles its own Metro/Babel pipeline, which conflicts with this project's own).
+
+## Required one-time step: native autolinking wiring
+
+Same one-time step as every other `expo-modules-core` package this project ships — see
+[`@symbiote-native/local-auth`'s README](../local-auth/README.md#required-one-time-step-native-autolinking-wiring)
+and the `symbiote-expo-native-module` project skill. Nothing package-specific beyond one Info.plist
+string:
+
+- iOS — `NSMicrophoneUsageDescription` in `Info.plist`, wired automatically by
+  `@symbiote-native/expo-modules-link`'s aggregator (`native-link.json`'s `ios.infoPlistKeys`) the
+  next time it runs — override the default text by adding the key yourself first. Same aggregator
+  also adds `UIBackgroundModes: audio` (`ios.infoPlistArrayKeys`) — upstream's own `withAudio.ts`
+  config plugin defaults `enableBackgroundPlayback` to `true`, and without this key iOS suspends
+  playback the moment the app backgrounds.
+- Android — `RECORD_AUDIO` / `MODIFY_AUDIO_SETTINGS` already ship in `expo-audio`'s own
+  `AndroidManifest.xml` and merge automatically, same as every other autolinked permission.
+  Background **playback** is wired the same way as iOS: `native-link.json`'s
+  `android.manifestPermissions` adds `FOREGROUND_SERVICE`/`FOREGROUND_SERVICE_MEDIA_PLAYBACK`, and
+  `android.manifestServices` declares `AudioControlsService` (`foregroundServiceType="mediaPlayback"`)
+  — matching upstream's own `withAudio.ts` config plugin, whose `enableBackgroundPlayback` defaults
+  to `true`. Background **recording** (`allowsBackgroundRecording: true`) is opt-in, matching
+  upstream's own `enableBackgroundRecording` default of `false` — requesting the microphone
+  foreground-service type is exactly the kind of thing that should be a deliberate app choice, not
+  a package side effect (same reasoning as `@symbiote-native/location`'s background permission).
+
+</details>
+
+**Background recording — opt-in, asked for you.** `new --audio`/`add --audio` above already ask,
+interactively, whether to grant it; say yes and `FOREGROUND_SERVICE_MICROPHONE`/
+`POST_NOTIFICATIONS` plus the `AudioRecordingService` (`foregroundServiceType="microphone"`)
+`<service>` land in your `AndroidManifest.xml` for you, along with the `allowsBackgroundRecording`
+call reminder you still need to make in JS. Said no, or ran non-interactively (CI, piped stdin)?
+Run it any time after:
+
+```bash
+npx @symbiote-native/cli grant audio
+```
+
+Idempotent — safe to run again even if already granted.
+
+## Shape
+
+```
+src/core/     AudioPlayer / AudioRecorder / AudioPlaylist / AudioStream classes (each a thin
+              subclass of the native SharedObject, adding only the JS-side logic upstream's own
+              ExpoAudio.ts shims onto the prototype — source resolution on `replace()`, the
+              Android arg-count fix for `setPlaybackRate()`, per-platform option processing for
+              `prepareToRecordAsync()`), the createAudioPlayer / createAudioPlaylist /
+              createAudioStream factories, the audio-session/permission/preload module functions,
+              RecordingPresets, and the event-name constants `addListener` accepts.
+              native-module.ts resolves the native module via expo-modules-core's
+              requireNativeModule.
+src/angular/  @symbiote-native/audio/angular — export * from '../core'
+```
+
+`./react`, `./vue`, `./svelte`, and `./solid` are `exports`-map aliases straight onto
+`src/core/`. `./angular` stays a physical file/subpath since Angular ships through a separate
+`ngc`/AOT build (`build-ngc/`).
+
+## Use it
+
+```ts
+import {
+  createAudioPlayer,
+  PLAYBACK_STATUS_UPDATE,
+  setAudioModeAsync,
+} from '@symbiote-native/audio';
+
+await setAudioModeAsync({
+  playsInSilentMode: true,
+  shouldPlayInBackground: false,
+});
+
+const player = createAudioPlayer('https://example.com/track.mp3');
+player.play();
+
+const subscription = player.addListener(PLAYBACK_STATUS_UPDATE, status => {
+  console.log(status.currentTime, status.duration, status.playing);
+});
+
+// later, e.g. on unmount:
+subscription.remove();
+player.remove();
+```
+
+Recording:
+
+```ts
+import {
+  AudioRecorder,
+  RECORDING_STATUS_UPDATE,
+  RecordingPresets,
+  requestRecordingPermissionsAsync,
+} from '@symbiote-native/audio';
+
+const { granted } = await requestRecordingPermissionsAsync();
+if (!granted) throw new Error('Microphone permission denied');
+
+const recorder = new AudioRecorder(RecordingPresets.HIGH_QUALITY);
+await recorder.prepareToRecordAsync();
+recorder.record();
+recorder.addListener(RECORDING_STATUS_UPDATE, status => console.log(status));
+// … later
+await recorder.stop();
+```
+
+Playlist and real-time PCM streaming follow the same `create*` + `addListener` shape:
+`createAudioPlaylist({ sources: [...], loop: 'all' })` and `createAudioStream()` — the stream
+factory takes no `onBuffer` callback (unlike upstream's `useAudioStream` hook); subscribe with
+`stream.addListener(AUDIO_STREAM_BUFFER, ...)` after `stream.start()`, same as every other event
+on these classes.
+
+Identical import surface on every adapter — `@symbiote-native/audio/react`, `/vue`, `/svelte`,
+`/solid`, `/angular` all re-export the same classes and functions.
+
+## API
+
+```ts
+class AudioPlayer extends SharedObject {
+  id: string; playing: boolean; muted: boolean; loop: boolean; paused: boolean; isLoaded: boolean;
+  isAudioSamplingSupported: boolean; isBuffering: boolean; currentTime: number; duration: number;
+  volume: number; playbackRate: number; shouldCorrectPitch: boolean; currentStatus: IAudioStatus;
+  play(): void; pause(): void; replace(source: IAudioSource): void;
+  seekTo(seconds: number, toleranceMillisBefore?: number, toleranceMillisAfter?: number): Promise<void>;
+  setPlaybackRate(rate: number, pitchCorrectionQuality?: IPitchCorrectionQuality): void;
+  setAudioSamplingEnabled(enabled: boolean): void;
+  setActiveForLockScreen(active: boolean, metadata?: IAudioMetadata, options?: IAudioLockScreenOptions): void;
+  updateLockScreenMetadata(metadata: IAudioMetadata): void;
+  clearLockScreenControls(): void;
+  remove(): void;
+}
+createAudioPlayer(source?: IAudioSource, options?: IAudioPlayerOptions): AudioPlayer
+
+class AudioRecorder extends SharedObject {
+  id: string; currentTime: number; isRecording: boolean; uri: string | null;
+  record(options?: IRecordingStartOptions): void; stop(): Promise<void>; pause(): void;
+  getAvailableInputs(): IRecordingInput[]; getCurrentInput(): Promise<IRecordingInput>;
+  setInput(inputUid: string): void; getStatus(): IRecorderState;
+  prepareToRecordAsync(options?: Partial<IRecordingOptions>): Promise<void>;
+}
+
+class AudioPlaylist extends SharedObject {
+  id: string; readonly currentIndex: number; readonly trackCount: number;
+  readonly sources: IAudioSourceInfo[]; playing: boolean; muted: boolean; isLoaded: boolean;
+  isBuffering: boolean; currentTime: number; duration: number; volume: number; playbackRate: number;
+  loop: IAudioPlaylistLoopMode; currentStatus: IAudioPlaylistStatus;
+  play(): void; pause(): void; next(): void; previous(): void; skipTo(index: number): void;
+  seekTo(seconds: number): Promise<void>; add(source: IAudioSource): void;
+  insert(source: IAudioSource, index: number): void; remove(index: number): void;
+  clear(): void; destroy(): void;
+}
+createAudioPlaylist(options?: IAudioPlaylistOptions): AudioPlaylist
+
+class AudioStream extends SharedObject {
+  id: string; readonly sampleRate: number; readonly channels: number; readonly isStreaming: boolean;
+  start(): Promise<void>; stop(): void;
+}
+createAudioStream(options?: IAudioStreamOptions): AudioStream
+
+setIsAudioActiveAsync(active: boolean): Promise<void>
+setAudioModeAsync(mode: Partial<IAudioMode>): Promise<void>
+requestRecordingPermissionsAsync(): Promise<PermissionResponse>
+requestNotificationPermissionsAsync(): Promise<PermissionResponse>  // Android only, throws elsewhere
+getRecordingPermissionsAsync(): Promise<PermissionResponse>
+preload(source: IAudioSource, options?: IPreloadOptions): Promise<void>
+clearPreloadedSource(source: IAudioSource): Promise<void>
+clearAllPreloadedSources(): Promise<void>
+getPreloadedSources(): Promise<string[]>
+
+RecordingPresets: { HIGH_QUALITY: IRecordingOptions; LOW_QUALITY: IRecordingOptions }
+IOSOutputFormat, AudioQuality  // enums, ported from RecordingConstants.ts
+
+PLAYBACK_STATUS_UPDATE, AUDIO_SAMPLE_UPDATE, RECORDING_STATUS_UPDATE, PLAYLIST_STATUS_UPDATE,
+TRACK_CHANGED, AUDIO_STREAM_BUFFER, AUDIO_STREAM_STATUS  // event names for .addListener()
+```
+
+Plus the full `I`-prefixed type surface ported from upstream's `Audio.types.ts` /
+`AudioModule.types.ts` / `AudioStream.types.ts` / `AudioConstants.ts`, re-exported from the
+barrel — see `src/core/types.ts`.
+
+## Deliberately not ported
+
+- **`useAudioPlayer` / `useAudioPlayerStatus` / `useAudioSampleListener` / `useAudioRecorder` /
+  `useAudioRecorderState` / `useAudioPlaylist` / `useAudioPlaylistStatus` / `useAudioStream`** —
+  React hooks, framework-specific by construction. `createAudioPlayer` / `createAudioPlaylist` /
+  `createAudioStream` are the framework-agnostic equivalents each already exposes (upstream's own
+  hooks are thin wrappers over these plus `useReleasingSharedObject` for cleanup-on-unmount); each
+  adapter's own lifecycle wrapper is where a hook/composable/service belongs, per
+  `<components_split_logic_view_lifecycle>` in the root project CLAUDE.md. None ship yet.
+- **The `Asset`-instance form of `AudioSource`, and the `downloadFirst` player option.** Upstream
+  resolves both through `expo-asset` (`Asset.fromModule` / `Asset.downloadAsync`), which depends
+  on `expo-constants` and peers on the `expo` meta-package — this project never depends on `expo`
+  (root CLAUDE.md's dependency-scope invariant, and the `symbiote-expo-native-module` skill §1).
+  The plain `number` form (`require('./song.mp3')`) **is** supported — `resolveSource`/
+  `resolveSources` resolve it through RN's own generic `resolveAssetSource`, wired by
+  `bootstrapHost`, no `expo-asset` needed.
+- **`interruptionModeAndroid`** on `IAudioMode` — upstream marks it `@deprecated`, superseded by
+  the cross-platform `interruptionMode`.
+- **Web-only surfaces** (`ExpoAudio.web.ts`, `AudioPlayer.web.ts`, `AudioStream.web.ts`,
+  `MediaSessionController.web.ts`) — this project targets iOS + Android only.
+
+## Test it
+
+No Fabric/Descriptor angle at all — every class here is a `SharedObject` with no visual
+component. Tests fake the native `AudioPlayer`/`AudioRecorder`/`AudioPlaylist`/`AudioStream`
+classes `expoAudio` exposes (real prototype methods, so the subclass `super.*()` calls in
+`audio-player.ts`/`audio-recorder.ts` resolve correctly) and the plain async module functions
+(`src/core/audio-classes.test.ts`, `src/core/audio-module.test.ts`, `src/core/
+resolve-source.test.ts`) — no `installFabric()`, no ViewConfig.

package/build/angular/index.d.ts

@@ -0,0 +1 @@
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// @symbiote-native/audio/angular: the Angular entry over the framework-agnostic core. Same
+// reasoning as the React/Vue entries — every export here is a plain class/function with no
+// framework-specific lifecycle to wrap, so this is a plain re-export.
+export * from '../core/index.js';

package/build/core/audio-module.d.ts

@@ -0,0 +1,26 @@
+import { type PermissionResponse } from 'expo-modules-core';
+import type { IAudioMode, IAudioSource, IPreloadOptions } from './types';
+/** Enables or disables the audio subsystem globally — pauses all playback when set to `false`. */
+export declare function setIsAudioActiveAsync(active: boolean): Promise<void>;
+/** Configures the global audio session — background playback, mixing, interruption handling. */
+export declare function setAudioModeAsync(mode: Partial<IAudioMode>): Promise<void>;
+/** Requests microphone-access permission required for recording. */
+export declare function requestRecordingPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Requests permission to post notifications on Android, needed for lock-screen/notification-shade
+ * playback controls. @platform android — throws on every other platform.
+ */
+export declare function requestNotificationPermissionsAsync(): Promise<PermissionResponse>;
+/** Checks the current recording-permission status without prompting. */
+export declare function getRecordingPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Preloads an audio source for near-instant playback later — call at module scope, before any
+ * player is created from the same source.
+ */
+export declare function preload(source: IAudioSource, options?: IPreloadOptions): Promise<void>;
+/** Releases a specific preloaded source (must match what was passed to `preload`). */
+export declare function clearPreloadedSource(source: IAudioSource): Promise<void>;
+/** Releases every preloaded source. */
+export declare function clearAllPreloadedSources(): Promise<void>;
+/** URIs of every source currently in the preload cache. */
+export declare function getPreloadedSources(): Promise<string[]>;

package/build/core/audio-module.js

@@ -0,0 +1,64 @@
+import { Platform } from 'expo-modules-core';
+import { expoAudio } from './native-module.js';
+import { resolveSource } from './resolve-source.js';
+/** Enables or disables the audio subsystem globally — pauses all playback when set to `false`. */
+export async function setIsAudioActiveAsync(active) {
+    return expoAudio.setIsAudioActiveAsync(active);
+}
+/** Configures the global audio session — background playback, mixing, interruption handling. */
+export async function setAudioModeAsync(mode) {
+    const audioMode = Platform.OS === 'ios'
+        ? mode
+        : {
+            shouldPlayInBackground: mode.shouldPlayInBackground,
+            shouldRouteThroughEarpiece: mode.shouldRouteThroughEarpiece,
+            interruptionMode: mode.interruptionMode,
+            allowsBackgroundRecording: mode.allowsBackgroundRecording,
+            playsInSilentMode: mode.playsInSilentMode,
+        };
+    return expoAudio.setAudioModeAsync(audioMode);
+}
+/** Requests microphone-access permission required for recording. */
+export async function requestRecordingPermissionsAsync() {
+    return expoAudio.requestRecordingPermissionsAsync();
+}
+/**
+ * Requests permission to post notifications on Android, needed for lock-screen/notification-shade
+ * playback controls. @platform android — throws on every other platform.
+ */
+export async function requestNotificationPermissionsAsync() {
+    if (Platform.OS !== 'android') {
+        throw new Error('expo-audio: `requestNotificationPermissionsAsync` is only available on Android.');
+    }
+    return expoAudio.requestNotificationPermissionsAsync();
+}
+/** Checks the current recording-permission status without prompting. */
+export async function getRecordingPermissionsAsync() {
+    return expoAudio.getRecordingPermissionsAsync();
+}
+/**
+ * Preloads an audio source for near-instant playback later — call at module scope, before any
+ * player is created from the same source.
+ */
+export async function preload(source, options = {}) {
+    const resolved = resolveSource(source);
+    if (!resolved)
+        return;
+    const { preferredForwardBufferDuration = 10 } = options;
+    return expoAudio.preload(resolved, preferredForwardBufferDuration);
+}
+/** Releases a specific preloaded source (must match what was passed to `preload`). */
+export async function clearPreloadedSource(source) {
+    const resolved = resolveSource(source);
+    if (!resolved)
+        return;
+    return expoAudio.clearPreloadedSource(resolved);
+}
+/** Releases every preloaded source. */
+export async function clearAllPreloadedSources() {
+    return expoAudio.clearAllPreloadedSources();
+}
+/** URIs of every source currently in the preload cache. */
+export async function getPreloadedSources() {
+    return expoAudio.getPreloadedSources();
+}

package/build/core/audio-player.d.ts

@@ -0,0 +1,13 @@
+import { expoAudio } from './native-module';
+import type { IAudioPlayerOptions, IAudioSource, IPitchCorrectionQuality } from './types';
+export declare class AudioPlayer extends expoAudio.AudioPlayer {
+    replace(source: IAudioSource): void;
+    setPlaybackRate(rate: number, pitchCorrectionQuality?: IPitchCorrectionQuality): void;
+}
+/**
+ * Creates an `AudioPlayer` that does not release automatically — call `.remove()` when done with
+ * it. There is no lifecycle wrapper here (framework-agnostic core, see the package README); each
+ * adapter's own hook/composable/service is responsible for releasing it on unmount, mirroring
+ * upstream's `useReleasingSharedObject`.
+ */
+export declare function createAudioPlayer(source?: IAudioSource, options?: IAudioPlayerOptions): AudioPlayer;

package/build/core/audio-player.js

@@ -0,0 +1,31 @@
+import { Platform } from 'expo-modules-core';
+import { expoAudio } from './native-module.js';
+import { resolveSource } from './resolve-source.js';
+// Upstream shims these two methods onto `AudioModule.AudioPlayer.prototype` at module load
+// (ExpoAudio.ts). We do the equivalent by subclassing instead of monkey-patching the native
+// class's prototype — same shape packages/media-library/src/next/asset.ts uses for its own
+// platform-conditional overrides.
+export class AudioPlayer extends expoAudio.AudioPlayer {
+    replace(source) {
+        super.replace(resolveSource(source));
+    }
+    setPlaybackRate(rate, pitchCorrectionQuality) {
+        if (Platform.OS === 'android') {
+            super.setPlaybackRate(rate);
+        }
+        else {
+            super.setPlaybackRate(rate, pitchCorrectionQuality);
+        }
+    }
+}
+/**
+ * Creates an `AudioPlayer` that does not release automatically — call `.remove()` when done with
+ * it. There is no lifecycle wrapper here (framework-agnostic core, see the package README); each
+ * adapter's own hook/composable/service is responsible for releasing it on unmount, mirroring
+ * upstream's `useReleasingSharedObject`.
+ */
+export function createAudioPlayer(source = null, options = {}) {
+    const { updateInterval = 500, keepAudioSessionActive = false, preferredForwardBufferDuration = 0, } = options;
+    const resolvedSource = resolveSource(source);
+    return new AudioPlayer(resolvedSource, updateInterval, keepAudioSessionActive, preferredForwardBufferDuration);
+}

package/build/core/audio-playlist.d.ts

@@ -0,0 +1,8 @@
+import type { IAudioPlaylistOptions } from './types';
+export declare const AudioPlaylist: typeof import("./native-module").NativeAudioPlaylist;
+export type AudioPlaylist = InstanceType<typeof AudioPlaylist>;
+/**
+ * Creates an `AudioPlaylist` that does not release automatically — call `.destroy()` when done
+ * with it. See `createAudioPlayer`'s doc comment for the same lifecycle note.
+ */
+export declare function createAudioPlaylist(options?: IAudioPlaylistOptions): AudioPlaylist;

package/build/core/audio-playlist.js

@@ -0,0 +1,14 @@
+import { expoAudio } from './native-module.js';
+import { resolveSources } from './resolve-source.js';
+// No prototype shim on `AudioPlaylist` upstream (unlike `AudioPlayer`/`AudioRecorder`) — its
+// `add`/`insert` take an already-resolved source, so a plain re-export is faithful to upstream.
+export const AudioPlaylist = expoAudio.AudioPlaylist;
+/**
+ * Creates an `AudioPlaylist` that does not release automatically — call `.destroy()` when done
+ * with it. See `createAudioPlayer`'s doc comment for the same lifecycle note.
+ */
+export function createAudioPlaylist(options = {}) {
+    const { sources = [], updateInterval = 500, loop = 'none' } = options;
+    const resolvedSources = resolveSources(sources);
+    return new AudioPlaylist(resolvedSources, updateInterval, loop);
+}

package/build/core/audio-recorder.d.ts

@@ -0,0 +1,5 @@
+import { expoAudio } from './native-module';
+import type { IRecordingOptions } from './types';
+export declare class AudioRecorder extends expoAudio.AudioRecorder {
+    prepareToRecordAsync(options?: Partial<IRecordingOptions>): Promise<void>;
+}

package/build/core/audio-recorder.js

@@ -0,0 +1,40 @@
+import { Platform } from 'expo-modules-core';
+import { expoAudio } from './native-module.js';
+/**
+ * Fills in the per-platform recording config from `RecordingOptions`'s common fields, ported
+ * from upstream's `utils/options.ts`. Only the fields the current platform's native recorder
+ * reads are kept, with `options.ios`/`options.android`/`options.web` spread on top so an
+ * explicit per-platform override always wins.
+ */
+function createRecordingOptions(options) {
+    const commonOptions = {
+        extension: options.extension,
+        sampleRate: options.sampleRate,
+        numberOfChannels: options.numberOfChannels,
+        bitRate: options.bitRate,
+        isMeteringEnabled: options.isMeteringEnabled ?? false,
+    };
+    if (Platform.OS === 'ios') {
+        return { ...commonOptions, directory: options.directory, ...options.ios };
+    }
+    if (Platform.OS === 'android') {
+        return {
+            ...commonOptions,
+            directory: options.directory,
+            ...options.android,
+        };
+    }
+    return { ...commonOptions, ...options.web };
+}
+// Upstream shims `prepareToRecordAsync` onto `AudioModule.AudioRecorder.prototype` at module
+// load, EXCEPT on tvOS (recording prototypes "should not be shimmed on tvOS, where they do not
+// exist" — ExpoAudio.ts). tvOS is not a target platform of this project (root CLAUDE.md: iOS +
+// Android only), so that branch is dropped — the options are always processed.
+export class AudioRecorder extends expoAudio.AudioRecorder {
+    prepareToRecordAsync(options) {
+        const processedOptions = options
+            ? createRecordingOptions(options)
+            : undefined;
+        return super.prepareToRecordAsync(processedOptions);
+    }
+}

package/build/core/audio-stream.d.ts

@@ -0,0 +1,13 @@
+import type { IAudioStreamOptions } from './types';
+export declare const AudioStream: typeof import("./native-module").NativeAudioStream;
+export type AudioStream = InstanceType<typeof AudioStream>;
+/**
+ * Creates a native `AudioStream` for real-time PCM microphone capture. Call `.start()` to
+ * begin and `.stop()` to end; requires microphone permission — see
+ * `requestRecordingPermissionsAsync`. Upstream only exposes this via the `useAudioStream` hook
+ * (React-only, see the package README); this factory is the framework-agnostic equivalent — the
+ * hook itself just applies these same defaults and wires `addListener` for
+ * `AUDIO_STREAM_STATUS`/`AUDIO_STREAM_BUFFER` on top, which each adapter's own lifecycle wrapper
+ * is responsible for.
+ */
+export declare function createAudioStream(options?: IAudioStreamOptions): AudioStream;

package/build/core/audio-stream.js

@@ -0,0 +1,16 @@
+import { expoAudio } from './native-module.js';
+// Plain re-export — upstream has no prototype shim for `AudioStream` either.
+export const AudioStream = expoAudio.AudioStream;
+/**
+ * Creates a native `AudioStream` for real-time PCM microphone capture. Call `.start()` to
+ * begin and `.stop()` to end; requires microphone permission — see
+ * `requestRecordingPermissionsAsync`. Upstream only exposes this via the `useAudioStream` hook
+ * (React-only, see the package README); this factory is the framework-agnostic equivalent — the
+ * hook itself just applies these same defaults and wires `addListener` for
+ * `AUDIO_STREAM_STATUS`/`AUDIO_STREAM_BUFFER` on top, which each adapter's own lifecycle wrapper
+ * is responsible for.
+ */
+export function createAudioStream(options = {}) {
+    const { sampleRate = 48000, channels = 1, encoding = 'float32' } = options;
+    return new AudioStream({ sampleRate, channels, encoding });
+}

package/build/core/index.d.ts

@@ -0,0 +1,9 @@
+export { AudioPlayer, createAudioPlayer } from './audio-player';
+export { AudioRecorder } from './audio-recorder';
+export { AudioPlaylist, createAudioPlaylist } from './audio-playlist';
+export { AudioStream, createAudioStream } from './audio-stream';
+export { setIsAudioActiveAsync, setAudioModeAsync, requestRecordingPermissionsAsync, requestNotificationPermissionsAsync, getRecordingPermissionsAsync, preload, clearPreloadedSource, clearAllPreloadedSources, getPreloadedSources, } from './audio-module';
+export { resolveSource, resolveSources } from './resolve-source';
+export { RecordingPresets, IOSOutputFormat, AudioQuality, } from './recording-presets';
+export { PLAYBACK_STATUS_UPDATE, AUDIO_SAMPLE_UPDATE, RECORDING_STATUS_UPDATE, PLAYLIST_STATUS_UPDATE, TRACK_CHANGED, AUDIO_STREAM_BUFFER, AUDIO_STREAM_STATUS, } from './types';
+export type { IAudioSource, IAudioSourceInfo, IAudioPlayerOptions, IPreloadOptions, IRecordingInput, IPitchCorrectionQuality, IAudioStatus, IRecordingStatus, IRecorderState, IAndroidOutputFormat, IAndroidAudioEncoder, IRecordingStartOptions, IRecordingDirectory, IRecordingOptions, IRecordingOptionsWeb, IRecordingOptionsIos, IRecordingOptionsAndroid, IRecordingSource, IAudioMode, IInterruptionMode, IAudioMetadata, IAudioPlaylistLoopMode, IAudioPlaylistOptions, IAudioPlaylistStatus, IAudioLockScreenOptions, IAudioSample, IAudioStreamEncoding, IAudioStreamOptions, IAudioStreamBuffer, IAudioStreamStatus, } from './types';

package/build/core/index.js

@@ -0,0 +1,8 @@
+export { AudioPlayer, createAudioPlayer } from './audio-player.js';
+export { AudioRecorder } from './audio-recorder.js';
+export { AudioPlaylist, createAudioPlaylist } from './audio-playlist.js';
+export { AudioStream, createAudioStream } from './audio-stream.js';
+export { setIsAudioActiveAsync, setAudioModeAsync, requestRecordingPermissionsAsync, requestNotificationPermissionsAsync, getRecordingPermissionsAsync, preload, clearPreloadedSource, clearAllPreloadedSources, getPreloadedSources, } from './audio-module.js';
+export { resolveSource, resolveSources } from './resolve-source.js';
+export { RecordingPresets, IOSOutputFormat, AudioQuality, } from './recording-presets.js';
+export { PLAYBACK_STATUS_UPDATE, AUDIO_SAMPLE_UPDATE, RECORDING_STATUS_UPDATE, PLAYLIST_STATUS_UPDATE, TRACK_CHANGED, AUDIO_STREAM_BUFFER, AUDIO_STREAM_STATUS, } from './types.js';