@symbiote-native/audio 0.1.0

package/build-ngc/core/types.d.ts

@@ -0,0 +1,218 @@
+import type { AudioQuality, IOSOutputFormat } from './recording-presets';
+/** Audio source information returned from native when reading sources from a queue. */
+export type IAudioSourceInfo = {
+    uri?: string;
+    name?: string;
+};
+/**
+ * A URI string, an object describing a remote/local (by URI) audio source, or the numeric asset
+ * id `require('./song.mp3')` produces — resolved via `resolveSource`/`resolveSources`.
+ */
+export type IAudioSource = string | number | null | {
+    uri?: string;
+    headers?: Record<string, string>;
+    name?: string;
+};
+export type IAudioPlayerOptions = {
+    /** How often (in milliseconds) to emit playback status updates. @default 500 */
+    updateInterval?: number;
+    /** @platform web */
+    crossOrigin?: 'anonymous' | 'use-credentials';
+    /**
+     * If `true`, the audio session is not deactivated when this player pauses or finishes.
+     * @platform ios
+     * @default false
+     */
+    keepAudioSessionActive?: boolean;
+    /**
+     * Seconds to buffer ahead of the current playback position.
+     * @platform ios
+     * @platform android
+     * @default 0
+     */
+    preferredForwardBufferDuration?: number;
+};
+export type IPreloadOptions = {
+    /** @default 10 */
+    preferredForwardBufferDuration?: number;
+};
+export type IRecordingInput = {
+    name: string;
+    type: string;
+    uid: string;
+};
+export type IPitchCorrectionQuality = 'low' | 'medium' | 'high';
+export type IAudioStatus = {
+    id: string;
+    currentTime: number;
+    playbackState: string;
+    timeControlStatus: string;
+    reasonForWaitingToPlay: string;
+    mute: boolean;
+    duration: number;
+    playing: boolean;
+    loop: boolean;
+    didJustFinish: boolean;
+    isBuffering: boolean;
+    isLoaded: boolean;
+    playbackRate: number;
+    shouldCorrectPitch: boolean;
+    /** @platform ios */
+    mediaServicesDidReset?: boolean;
+    isLive: boolean;
+    currentOffsetFromLive: number | null;
+    error: string | null;
+};
+export type IRecordingStatus = {
+    id: string;
+    isFinished: boolean;
+    hasError: boolean;
+    error: string | null;
+    url: string | null;
+    /** @platform ios */
+    mediaServicesDidReset?: boolean;
+};
+export type IRecorderState = {
+    canRecord: boolean;
+    isRecording: boolean;
+    durationMillis: number;
+    mediaServicesDidReset: boolean;
+    metering?: number;
+    url: string | null;
+};
+/** @platform android */
+export type IAndroidOutputFormat = 'default' | '3gp' | 'mpeg4' | 'amrnb' | 'amrwb' | 'aac_adts' | 'mpeg2ts' | 'webm';
+/** @platform android */
+export type IAndroidAudioEncoder = 'default' | 'amr_nb' | 'amr_wb' | 'aac' | 'he_aac' | 'aac_eld';
+export type IRecordingStartOptions = {
+    /** @platform ios @platform android @platform web */
+    forDuration?: number;
+    /** @platform ios */
+    atTime?: number;
+};
+/** @platform android @platform ios */
+export type IRecordingDirectory = 'cache' | 'document';
+export type IRecordingOptionsWeb = {
+    mimeType?: string;
+    bitsPerSecond?: number;
+};
+/** @platform ios */
+export type IRecordingOptionsIos = {
+    extension?: string;
+    sampleRate?: number;
+    outputFormat?: string | IOSOutputFormat | number;
+    audioQuality: AudioQuality | number;
+    bitRateStrategy?: number;
+    bitDepthHint?: number;
+    linearPCMBitDepth?: number;
+    linearPCMIsBigEndian?: boolean;
+    linearPCMIsFloat?: boolean;
+};
+/** @platform android */
+export type IRecordingSource = 'camcorder' | 'default' | 'mic' | 'remote_submix' | 'unprocessed' | 'voice_communication' | 'voice_performance' | 'voice_recognition';
+/** @platform android */
+export type IRecordingOptionsAndroid = {
+    extension?: string;
+    sampleRate?: number;
+    outputFormat: IAndroidOutputFormat;
+    audioEncoder: IAndroidAudioEncoder;
+    maxFileSize?: number;
+    audioSource?: IRecordingSource;
+};
+export type IRecordingOptions = {
+    /** @default 'cache' */
+    directory?: IRecordingDirectory;
+    isMeteringEnabled?: boolean;
+    extension: string;
+    sampleRate: number;
+    numberOfChannels: number;
+    bitRate: number;
+    android: IRecordingOptionsAndroid;
+    ios: IRecordingOptionsIos;
+    web: IRecordingOptionsWeb;
+};
+export type IAudioMode = {
+    /** @default true */
+    playsInSilentMode: boolean;
+    /** @default 'mixWithOthers' */
+    interruptionMode: IInterruptionMode;
+    /** @default false @platform ios */
+    allowsRecording: boolean;
+    /** @default false */
+    shouldPlayInBackground: boolean;
+    /** @default false */
+    shouldRouteThroughEarpiece: boolean;
+    /** @default false @platform ios @platform android */
+    allowsBackgroundRecording?: boolean;
+};
+export type IInterruptionMode = 'mixWithOthers' | 'doNotMix' | 'duckOthers';
+export type IAudioMetadata = {
+    title?: string;
+    artist?: string;
+    albumTitle?: string;
+    artworkUrl?: string;
+};
+export type IAudioPlaylistLoopMode = 'none' | 'single' | 'all';
+export type IAudioPlaylistOptions = {
+    /** @default [] */
+    sources?: IAudioSource[];
+    /** @default 500 */
+    updateInterval?: number;
+    /** @default 'none' */
+    loop?: IAudioPlaylistLoopMode;
+    /** @platform web */
+    crossOrigin?: 'anonymous' | 'use-credentials';
+};
+export type IAudioPlaylistStatus = {
+    id: string;
+    currentIndex: number;
+    trackCount: number;
+    currentTime: number;
+    duration: number;
+    playing: boolean;
+    isBuffering: boolean;
+    isLoaded: boolean;
+    playbackRate: number;
+    muted: boolean;
+    volume: number;
+    loop: IAudioPlaylistLoopMode;
+    didJustFinish: boolean;
+};
+/** From AudioConstants.ts — which lock-screen controls to show while a player is active. */
+export type IAudioLockScreenOptions = {
+    showSeekForward?: boolean;
+    showSeekBackward?: boolean;
+    isLiveStream?: boolean;
+};
+export type IAudioSample = {
+    channels: {
+        frames: number[];
+    }[];
+    timestamp: number;
+};
+export type IAudioStreamEncoding = 'float32' | 'int16';
+export type IAudioStreamOptions = {
+    /** @default 48000 */
+    sampleRate?: number;
+    /** @default 1 */
+    channels?: number;
+    /** @default 'float32' */
+    encoding?: IAudioStreamEncoding;
+};
+export type IAudioStreamBuffer = {
+    data: ArrayBuffer;
+    sampleRate: number;
+    channels: number;
+    timestamp: number;
+};
+export type IAudioStreamStatus = {
+    isStreaming: boolean;
+};
+/** From AudioEventKeys.ts — event names the `SharedObject` classes' `addListener` accepts. */
+export declare const PLAYBACK_STATUS_UPDATE = "playbackStatusUpdate";
+export declare const AUDIO_SAMPLE_UPDATE = "audioSampleUpdate";
+export declare const RECORDING_STATUS_UPDATE = "recordingStatusUpdate";
+export declare const PLAYLIST_STATUS_UPDATE = "playlistStatusUpdate";
+export declare const TRACK_CHANGED = "trackChanged";
+export declare const AUDIO_STREAM_BUFFER = "audioStreamBuffer";
+export declare const AUDIO_STREAM_STATUS = "audioStreamStatus";

package/build-ngc/core/types.js

@@ -0,0 +1,9 @@
+/** From AudioEventKeys.ts — event names the `SharedObject` classes' `addListener` accepts. */
+export const PLAYBACK_STATUS_UPDATE = 'playbackStatusUpdate';
+export const AUDIO_SAMPLE_UPDATE = 'audioSampleUpdate';
+export const RECORDING_STATUS_UPDATE = 'recordingStatusUpdate';
+export const PLAYLIST_STATUS_UPDATE = 'playlistStatusUpdate';
+export const TRACK_CHANGED = 'trackChanged';
+export const AUDIO_STREAM_BUFFER = 'audioStreamBuffer';
+export const AUDIO_STREAM_STATUS = 'audioStreamStatus';
+//# sourceMappingURL=types.js.map

package/build-ngc/core/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAkRA,8FAA8F;AAC9F,MAAM,CAAC,MAAM,sBAAsB,GAAG,sBAAsB,CAAC;AAC7D,MAAM,CAAC,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AACvD,MAAM,CAAC,MAAM,uBAAuB,GAAG,uBAAuB,CAAC;AAC/D,MAAM,CAAC,MAAM,sBAAsB,GAAG,sBAAsB,CAAC;AAC7D,MAAM,CAAC,MAAM,aAAa,GAAG,cAAc,CAAC;AAC5C,MAAM,CAAC,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;AACvD,MAAM,CAAC,MAAM,mBAAmB,GAAG,mBAAmB,CAAC"}

package/native-link.json

@@ -0,0 +1,47 @@
+{
+  "android": {
+    "gradleProjectName": "expo-audio",
+    "modules": [
+      {
+        "importPath": "expo.modules.audio.AudioModule",
+        "className": "AudioModule",
+        "nativeName": "ExpoAudio"
+      }
+    ],
+    "manifestPermissions": [
+      "android.permission.FOREGROUND_SERVICE",
+      "android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"
+    ],
+    "manifestServices": [
+      {
+        "name": "expo.modules.audio.service.AudioControlsService",
+        "foregroundServiceType": "mediaPlayback",
+        "intentFilterActions": ["androidx.media3.session.MediaSessionService"]
+      }
+    ],
+    "optionalManifestBundles": [
+      {
+        "id": "recording",
+        "label": "Background audio recording",
+        "warning": "Requesting FOREGROUND_SERVICE_MICROPHONE triggers Play Console policy review — Google requires a clear, prominent in-app disclosure and justification before you can publish.",
+        "nextSteps": "Pass `allowsBackgroundRecording: true` to setAudioModeAsync so recording keeps running with the app backgrounded.",
+        "manifestPermissions": [
+          "android.permission.FOREGROUND_SERVICE_MICROPHONE",
+          "android.permission.POST_NOTIFICATIONS"
+        ],
+        "manifestServices": [
+          {
+            "name": "expo.modules.audio.service.AudioRecordingService",
+            "foregroundServiceType": "microphone"
+          }
+        ]
+      }
+    ]
+  },
+  "ios": {
+    "infoPlistKeys": {
+      "NSMicrophoneUsageDescription": "This app uses the microphone to record audio."
+    },
+    "infoPlistArrayKeys": { "UIBackgroundModes": ["audio"] }
+  }
+}

package/package.json

@@ -0,0 +1,150 @@
+{
+  "name": "@symbiote-native/audio",
+  "version": "0.1.0",
+  "description": "expo-audio wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. AudioPlayer / AudioRecorder / AudioPlaylist / AudioStream shared-object classes, audio-session config, and recording permissions.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OneEyed1366/symbiote-native.git",
+    "directory": "packages/audio"
+  },
+  "homepage": "https://github.com/OneEyed1366/symbiote-native/tree/master/packages/audio#readme",
+  "bugs": {
+    "url": "https://github.com/OneEyed1366/symbiote-native/issues"
+  },
+  "author": "Andrey Prokopenko <psevdoproger@gmail.com>",
+  "keywords": [
+    "react-native",
+    "symbiote-native",
+    "expo-audio",
+    "react",
+    "vue",
+    "svelte",
+    "solid",
+    "angular",
+    "audio",
+    "recording"
+  ],
+  "type": "module",
+  "main": "./build/core/index.js",
+  "module": "./build/core/index.js",
+  "types": "./build/core/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./vue": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./react": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./svelte": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./solid": {
+      "types": "./build/core/index.d.ts",
+      "default": "./build/core/index.js"
+    },
+    "./angular": {
+      "types": "./build-ngc/angular/index.d.ts",
+      "react-native": "./build-ngc/angular/index.js",
+      "default": "./src/angular/index.ts"
+    }
+  },
+  "files": [
+    "src",
+    "build",
+    "build-ngc",
+    "native-link.json",
+    "!src/**/*.test.*",
+    "!src/**/*.spec.*",
+    "!src/**/*.detox.*"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "expo-audio": "57.0.4",
+    "expo-modules-core": "57.0.5"
+  },
+  "peerDependencies": {
+    "@angular/core": ">=20",
+    "@vue/runtime-core": "^3.5.13",
+    "react": ">=19.0.0",
+    "react-native": ">=0.86",
+    "solid-js": ">=1.9.0",
+    "svelte": ">=5.56.0",
+    "vue": ">=3.5.0",
+    "@symbiote-native/angular": "^3.1.0",
+    "@symbiote-native/react": "^3.0.2",
+    "@symbiote-native/engine": "^1.3.0",
+    "@symbiote-native/solid": "^3.0.2",
+    "@symbiote-native/svelte": "^3.0.2",
+    "@symbiote-native/vue": "^3.0.2"
+  },
+  "peerDependenciesMeta": {
+    "@symbiote-native/angular": {
+      "optional": true
+    },
+    "@symbiote-native/react": {
+      "optional": true
+    },
+    "@symbiote-native/solid": {
+      "optional": true
+    },
+    "@symbiote-native/svelte": {
+      "optional": true
+    },
+    "@symbiote-native/vue": {
+      "optional": true
+    },
+    "@angular/core": {
+      "optional": true
+    },
+    "@vue/runtime-core": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    },
+    "svelte": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@angular/compiler": "~22.0.8",
+    "@angular/compiler-cli": "~22.0.8",
+    "@angular/core": "~22.0.8",
+    "@types/node": "^26.0.0",
+    "@types/react": "^19.2.0",
+    "@vue/runtime-core": "^3.5.13",
+    "react": "19.2.3",
+    "solid-js": "^1.9.14",
+    "svelte": "^5.56.0",
+    "typescript": "~6.0.0",
+    "@symbiote-native/angular": "3.1.0",
+    "@symbiote-native/solid": "3.0.2",
+    "@symbiote-native/engine": "1.3.0",
+    "@symbiote-native/svelte": "3.0.2",
+    "@symbiote-native/react": "3.0.2",
+    "@symbiote-native/vue": "3.0.2",
+    "@symbiote-native/test-utils": "0.4.2"
+  },
+  "scripts": {
+    "typecheck": "tsc --build",
+    "clean": "rm -rf build-ngc",
+    "ng:build": "pnpm run clean && ngc -p tsconfig.angular.json",
+    "format": "prettier --write \"src/**/*.{ts,tsx}\""
+  }
+}

package/src/angular/index.ts

@@ -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';

package/src/core/audio-module.ts

@@ -0,0 +1,82 @@
+import { Platform, type PermissionResponse } from 'expo-modules-core';
+import { expoAudio } from './native-module';
+import { resolveSource } from './resolve-source';
+import type { IAudioMode, IAudioSource, IPreloadOptions } from './types';
+
+/** Enables or disables the audio subsystem globally — pauses all playback when set to `false`. */
+export async function setIsAudioActiveAsync(active: boolean): Promise<void> {
+  return expoAudio.setIsAudioActiveAsync(active);
+}
+
+/** Configures the global audio session — background playback, mixing, interruption handling. */
+export async function setAudioModeAsync(
+  mode: Partial<IAudioMode>,
+): Promise<void> {
+  const audioMode: Partial<IAudioMode> =
+    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(): Promise<PermissionResponse> {
+  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(): Promise<PermissionResponse> {
+  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(): Promise<PermissionResponse> {
+  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: IAudioSource,
+  options: IPreloadOptions = {},
+): Promise<void> {
+  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: IAudioSource,
+): Promise<void> {
+  const resolved = resolveSource(source);
+  if (!resolved) return;
+  return expoAudio.clearPreloadedSource(resolved);
+}
+
+/** Releases every preloaded source. */
+export async function clearAllPreloadedSources(): Promise<void> {
+  return expoAudio.clearAllPreloadedSources();
+}
+
+/** URIs of every source currently in the preload cache. */
+export async function getPreloadedSources(): Promise<string[]> {
+  return expoAudio.getPreloadedSources();
+}

package/src/core/audio-player.ts

@@ -0,0 +1,53 @@
+import { Platform } from 'expo-modules-core';
+import { expoAudio } from './native-module';
+import { resolveSource } from './resolve-source';
+import type {
+  IAudioPlayerOptions,
+  IAudioSource,
+  IPitchCorrectionQuality,
+} from './types';
+
+// 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 {
+  override replace(source: IAudioSource): void {
+    super.replace(resolveSource(source));
+  }
+
+  override setPlaybackRate(
+    rate: number,
+    pitchCorrectionQuality?: IPitchCorrectionQuality,
+  ): void {
+    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: IAudioSource = null,
+  options: IAudioPlayerOptions = {},
+): AudioPlayer {
+  const {
+    updateInterval = 500,
+    keepAudioSessionActive = false,
+    preferredForwardBufferDuration = 0,
+  } = options;
+  const resolvedSource = resolveSource(source);
+  return new AudioPlayer(
+    resolvedSource,
+    updateInterval,
+    keepAudioSessionActive,
+    preferredForwardBufferDuration,
+  );
+}

package/src/core/audio-playlist.ts

@@ -0,0 +1,20 @@
+import { expoAudio } from './native-module';
+import { resolveSources } from './resolve-source';
+import type { IAudioPlaylistOptions } from './types';
+
+// 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;
+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 function createAudioPlaylist(
+  options: IAudioPlaylistOptions = {},
+): AudioPlaylist {
+  const { sources = [], updateInterval = 500, loop = 'none' } = options;
+  const resolvedSources = resolveSources(sources);
+  return new AudioPlaylist(resolvedSources, updateInterval, loop);
+}

package/src/core/audio-recorder.ts

@@ -0,0 +1,46 @@
+import { Platform } from 'expo-modules-core';
+import { expoAudio } from './native-module';
+import type { IRecordingOptions } from './types';
+
+/**
+ * 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: IRecordingOptions) {
+  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 {
+  override prepareToRecordAsync(
+    options?: Partial<IRecordingOptions>,
+  ): Promise<void> {
+    const processedOptions = options
+      ? createRecordingOptions(options as IRecordingOptions)
+      : undefined;
+    return super.prepareToRecordAsync(processedOptions);
+  }
+}

package/src/core/audio-stream.ts

@@ -0,0 +1,22 @@
+import { expoAudio } from './native-module';
+import type { IAudioStreamOptions } from './types';
+
+// Plain re-export — upstream has no prototype shim for `AudioStream` either.
+export const AudioStream = expoAudio.AudioStream;
+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 function createAudioStream(
+  options: IAudioStreamOptions = {},
+): AudioStream {
+  const { sampleRate = 48000, channels = 1, encoding = 'float32' } = options;
+  return new AudioStream({ sampleRate, channels, encoding });
+}