@symbiote-native/audio 0.1.2 → 0.1.4

package/src/core/audio-stream.ts

@@ -1,19 +1,20 @@
 import { expoAudio } from './native-module';
-import type { IAudioStreamOptions } from './types';
+import type { IAudioStreamBuffer, 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 type IUseAudioStreamOptions = IAudioStreamOptions & {
+  onBuffer?: (buffer: IAudioStreamBuffer) => void;
+};
+
+export type IAudioStreamResult = {
+  stream: AudioStream;
+  isStreaming: boolean;
+};
+
+/** Requires microphone permission - see `requestRecordingPermissionsAsync`. */
 export function createAudioStream(
   options: IAudioStreamOptions = {},
 ): AudioStream {

package/src/core/index.ts

@@ -1,7 +1,19 @@
 export { AudioPlayer, createAudioPlayer } from './audio-player';
-export { AudioRecorder } from './audio-recorder';
+export { AudioRecorder, createAudioRecorder } from './audio-recorder';
 export { AudioPlaylist, createAudioPlaylist } from './audio-playlist';
 export { AudioStream, createAudioStream } from './audio-stream';
+export type {
+  IUseAudioStreamOptions,
+  IAudioStreamResult,
+} from './audio-stream';
+export { createAudioStreamController } from './audio-stream-controller';
+export {
+  subscribeAudioStreamBuffer,
+  toAudioStreamKey,
+} from './audio-stream-subscription';
+export type { IAudioStreamBufferSource } from './audio-stream-subscription';
+export { runAudioStreamBufferEffect } from './audio-stream-lifecycle';
+export { createAudioStreamHooks } from './audio-stream-hooks';
 export {
   setIsAudioActiveAsync,
   setAudioModeAsync,
@@ -14,6 +26,12 @@ export {
   getPreloadedSources,
 } from './audio-module';
 export { resolveSource, resolveSources } from './resolve-source';
+export { subscribeAudioSampleListener } from './audio-sample-listener';
+export type { IAudioSamplePlayer } from './audio-sample-listener';
+export { subscribeRecordingStatus } from './audio-recorder-status';
+export type { IStatusRecorder } from './audio-recorder-status';
+export { shouldUpdateRecorderState } from './audio-recorder-state';
+export { pollRecorderState } from './audio-recorder-polling';
 export {
   RecordingPresets,
   IOSOutputFormat,
@@ -32,6 +50,7 @@ export type {
   IAudioSource,
   IAudioSourceInfo,
   IAudioPlayerOptions,
+  IAudioLoadOptions,
   IPreloadOptions,
   IRecordingInput,
   IPitchCorrectionQuality,

package/src/core/json-keyed-resource-controller.ts

@@ -0,0 +1 @@
+export { createJsonKeyedResourceController } from '@symbiote-native/engine';

package/src/core/resolve-source.ts

@@ -1,34 +1,74 @@
-import { resolveAssetSource } from '@symbiote-native/engine';
+// Ported from expo-audio/src/utils/resolveSource.ts (sdk-57), against @symbiote-native/asset's
+// Asset class instead of importing expo-asset directly (same pattern as packages/font).
+import { Asset } from '@symbiote-native/asset';
+
 import type { IAudioSource } from './types';
 
-type IResolvedAudioSourceObject = Exclude<IAudioSource, string | number | null>;
+type IResolvedAudioSourceObject = Exclude<
+  IAudioSource,
+  string | number | Asset | null
+>;
+
+function getAssetFromSource(source?: IAudioSource): Asset | null {
+  if (!source) {
+    return null;
+  }
+  if (source instanceof Asset) {
+    return source;
+  }
+  if (typeof source === 'number') {
+    return Asset.fromModule(source);
+  }
+  if (typeof source === 'object') {
+    if ('assetId' in source && typeof source.assetId === 'number') {
+      return Asset.fromModule(source.assetId);
+    }
+    if ('uri' in source && typeof source.uri === 'string') {
+      return Asset.fromURI(source.uri);
+    }
+  }
+  if (typeof source === 'string') {
+    return Asset.fromURI(source);
+  }
+  return null;
+}
 
-// resolveAssetSource returns `unknown` by design (the seam serves every require()'d-asset
-// consumer, not just this package) — narrow it instead of casting.
-function isAudioSourceObject(
-  value: unknown,
-): value is IResolvedAudioSourceObject {
-  return typeof value === 'object' && value !== null;
+function createSourceFromAsset(
+  asset: Asset,
+  extras: { assetId?: number; headers?: Record<string, string> } = {},
+): IResolvedAudioSourceObject {
+  const result: IResolvedAudioSourceObject = {
+    uri: asset.localUri ?? asset.uri,
+  };
+  if (asset.name) {
+    result.name = asset.name;
+  }
+  if (extras.assetId != null) {
+    result.assetId = extras.assetId;
+  }
+  if (extras.headers) {
+    result.headers = extras.headers;
+  }
+  return result;
 }
 
-/**
- * Normalizes a source into the shape the native player accepts. A `number` (a `require()`'d
- * local asset) resolves via `@symbiote-native/engine`'s `resolveAssetSource` seam — RN's own
- * generic asset-registry lookup, wired by `bootstrapHost`. An actual `expo-asset` `Asset`
- * instance is still not ported, see `types.ts`'s header comment on `IAudioSource`. A plain
- * string is treated as a URI, matching upstream.
- */
 export function resolveSource(source?: IAudioSource): IAudioSource | null {
   if (source == null) {
     return null;
   }
-  if (typeof source === 'number') {
-    const resolved = resolveAssetSource(source);
-    return isAudioSourceObject(resolved) ? resolved : null;
+  if (source instanceof Asset) {
+    return createSourceFromAsset(source);
   }
   if (typeof source === 'string') {
     return { uri: source };
   }
+  if (typeof source === 'number') {
+    return createSourceFromAsset(Asset.fromModule(source), { assetId: source });
+  }
+  if ('assetId' in source && typeof source.assetId === 'number') {
+    const asset = Asset.fromModule(source.assetId);
+    return { ...source, uri: asset.localUri ?? asset.uri };
+  }
   return source;
 }
 
@@ -39,3 +79,25 @@ export function resolveSources(
     .map(source => resolveSource(source))
     .filter((source): source is NonNullable<IAudioSource> => source != null);
 }
+
+/** Resolves `source` and, unlike `resolveSource`, downloads it to a local cache file first. */
+export async function resolveSourceWithDownload(
+  source?: IAudioSource,
+): Promise<IAudioSource | null> {
+  const asset = getAssetFromSource(source);
+  const fallback = resolveSource(source);
+  if (!asset) {
+    return fallback;
+  }
+  try {
+    await asset.downloadAsync();
+    if (asset.localUri) {
+      return fallback && typeof fallback === 'object'
+        ? { ...fallback, uri: asset.localUri }
+        : { uri: asset.localUri };
+    }
+  } catch {
+    // Falls through to the un-downloaded source below, matching upstream's own recovery path.
+  }
+  return fallback;
+}

package/src/core/subscribe-single-event.ts

@@ -0,0 +1,17 @@
+// Shared shape behind `subscribeRecordingStatus`/`subscribeAudioStreamBuffer`: one optional
+// listener over one named event, unsubscribed via the returned cleanup
+export function subscribeSingleEvent<TEvent extends string, TPayload>(
+  source: {
+    addListener: (
+      event: TEvent,
+      listener: (payload: TPayload) => void,
+    ) => { remove: () => void };
+  },
+  event: TEvent,
+  listener: ((payload: TPayload) => void) | undefined,
+): () => void {
+  const subscription = source.addListener(event, payload => {
+    listener?.(payload);
+  });
+  return () => subscription.remove();
+}

package/src/core/types.ts

@@ -2,16 +2,8 @@
 // RecordingConstants.ts / AudioStream.types.ts / AudioEventKeys.ts, renamed with this repo's
 // `I`-prefix convention for object/union-shaped exported types (enums keep their upstream name,
 // matching packages/local-auth's AuthenticationType/SecurityLevel).
-//
-// `IAudioSource`'s `number` variant (a `require()`'d local asset) IS supported: it resolves via
-// `@symbiote-native/engine`'s `resolveAssetSource` seam, which wraps RN's own generic
-// `Image.resolveAssetSource` — an ordinary Metro asset-registry lookup, nothing image-specific
-// despite the name, and `mp3` is already in Metro's default `assetExts`. Only an actual `Asset`
-// CLASS instance (as opposed to the plain numeric id `require()` returns) is deliberately NOT
-// ported, along with the `downloadFirst` player option — both need `expo-asset`'s own
-// remote-caching layer, which pulls in `expo-constants` and peers on the `expo` meta-package this
-// project never depends on (root CLAUDE.md's dependency-scope invariant, and the
-// `symbiote-expo-native-module` skill §1). See the package README.
+import type { Asset } from '@symbiote-native/asset';
+
 import type { AudioQuality, IOSOutputFormat } from './recording-presets';
 
 /** Audio source information returned from native when reading sources from a queue. */
@@ -20,16 +12,16 @@ export type IAudioSourceInfo = {
   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`.
- */
+/** A URI, a `require()` module id, an `Asset`, or a source object — see resolve-source.ts. */
 export type IAudioSource =
   | string
   | number
+  | Asset
   | null
   | {
       uri?: string;
+      /** id of a local asset from `require()`; ignored if `uri` is set. */
+      assetId?: number;
       headers?: Record<string, string>;
       name?: string;
     };
@@ -52,8 +44,13 @@ export type IAudioPlayerOptions = {
    * @default 0
    */
   preferredForwardBufferDuration?: number;
+  /** Downloads the source via `Asset` before the native player loads it. @default false */
+  downloadFirst?: boolean;
 };
 
+/** @deprecated Use `IAudioPlayerOptions` instead */
+export type IAudioLoadOptions = IAudioPlayerOptions;
+
 export type IPreloadOptions = {
   /** @default 10 */
   preferredForwardBufferDuration?: number;
@@ -190,6 +187,8 @@ export type IAudioMode = {
   playsInSilentMode: boolean;
   /** @default 'mixWithOthers' */
   interruptionMode: IInterruptionMode;
+  /** @platform android @deprecated Use `interruptionMode`, which now works on both platforms */
+  interruptionModeAndroid?: IInterruptionMode;
   /** @default false @platform ios */
   allowsRecording: boolean;
   /** @default false */

package/src/react/index.ts

@@ -0,0 +1,9 @@
+export * from '../core';
+export { useAudioPlayer } from './use-audio-player';
+export { useAudioPlayerStatus } from './use-audio-player-status';
+export { useAudioSampleListener } from './use-audio-sample-listener';
+export { useAudioPlaylist } from './use-audio-playlist';
+export { useAudioPlaylistStatus } from './use-audio-playlist-status';
+export { useAudioRecorder } from './use-audio-recorder';
+export { useAudioRecorderState } from './use-audio-recorder-state';
+export { useAudioStream } from './use-audio-stream';

package/src/react/use-audio-player-status.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/react';
+import { PLAYBACK_STATUS_UPDATE } from '../core/types';
+import type { AudioPlayer } from '../core';
+import type { IAudioStatus } from '../core';
+
+/** React twin of `expo-audio`'s `useAudioPlayerStatus` */
+export const useAudioPlayerStatus = createEventValueHook<
+  AudioPlayer,
+  IAudioStatus,
+  typeof PLAYBACK_STATUS_UPDATE
+>(PLAYBACK_STATUS_UPDATE, player => player.currentStatus);

package/src/react/use-audio-player.ts

@@ -0,0 +1,14 @@
+import { createResourceHook } from '@symbiote-native/react';
+import { createAudioPlayerController } from '../core/audio-player-controller';
+import type { AudioPlayer } from '../core';
+import type { IAudioPlayerOptions, IAudioSource } from '../core';
+
+const usePlayerResource = createResourceHook(createAudioPlayerController);
+
+// React twin of `expo-audio`'s `useAudioPlayer`
+export function useAudioPlayer(
+  source: IAudioSource = null,
+  options: IAudioPlayerOptions = {},
+): AudioPlayer {
+  return usePlayerResource(source, options);
+}

package/src/react/use-audio-playlist-status.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/react';
+import { PLAYLIST_STATUS_UPDATE } from '../core/types';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistStatus } from '../core';
+
+/** React twin of `expo-audio`'s `useAudioPlaylistStatus` */
+export const useAudioPlaylistStatus = createEventValueHook<
+  AudioPlaylist,
+  IAudioPlaylistStatus,
+  typeof PLAYLIST_STATUS_UPDATE
+>(PLAYLIST_STATUS_UPDATE, playlist => playlist.currentStatus);

package/src/react/use-audio-playlist.ts

@@ -0,0 +1,13 @@
+import { createResourceHook } from '@symbiote-native/react';
+import { createAudioPlaylistController } from '../core/audio-playlist-controller';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistOptions } from '../core';
+
+const usePlaylistResource = createResourceHook(createAudioPlaylistController);
+
+/** React twin of `expo-audio`'s `useAudioPlaylist` */
+export function useAudioPlaylist(
+  options: IAudioPlaylistOptions = {},
+): AudioPlaylist {
+  return usePlaylistResource(options);
+}

package/src/react/use-audio-recorder-state.ts

@@ -0,0 +1,23 @@
+import { useEffect, useState } from 'react';
+import { pollRecorderState } from '../core/audio-recorder-polling';
+import type { AudioRecorder } from '../core';
+import type { IRecorderState } from '../core';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+
+/** React twin of `expo-audio`'s `useAudioRecorderState` */
+export function useAudioRecorderState(
+  recorder: AudioRecorder,
+  interval: number = DEFAULT_POLL_INTERVAL_MS,
+): IRecorderState {
+  const [state, setState] = useState<IRecorderState>(() =>
+    recorder.getStatus(),
+  );
+
+  useEffect(
+    () => pollRecorderState(recorder, interval, setState),
+    [recorder, interval],
+  );
+
+  return state;
+}

package/src/react/use-audio-recorder.ts

@@ -0,0 +1,23 @@
+import { useEffect } from 'react';
+import { createResourceHook } from '@symbiote-native/react';
+import { createAudioRecorderController } from '../core/audio-recorder-controller';
+import { subscribeRecordingStatus } from '../core/audio-recorder-status';
+import type { AudioRecorder } from '../core';
+import type { IRecordingOptions, IRecordingStatus } from '../core';
+
+const useRecorderResource = createResourceHook(createAudioRecorderController);
+
+/** React twin of `expo-audio`'s `useAudioRecorder` */
+export function useAudioRecorder(
+  options: IRecordingOptions,
+  statusListener?: (status: IRecordingStatus) => void,
+): AudioRecorder {
+  const recorder = useRecorderResource(options);
+
+  useEffect(
+    () => subscribeRecordingStatus(recorder, statusListener),
+    [recorder, statusListener],
+  );
+
+  return recorder;
+}

package/src/react/use-audio-sample-listener.ts

@@ -0,0 +1,15 @@
+import { useEffect } from 'react';
+import { subscribeAudioSampleListener } from '../core/audio-sample-listener';
+import type { IAudioSamplePlayer } from '../core/audio-sample-listener';
+import type { IAudioSample } from '../core/types';
+
+/** React twin of `expo-audio`'s `useAudioSampleListener` */
+export function useAudioSampleListener(
+  player: IAudioSamplePlayer,
+  listener: (data: IAudioSample) => void,
+): void {
+  useEffect(
+    () => subscribeAudioSampleListener(player, listener),
+    [player, listener],
+  );
+}

package/src/react/use-audio-stream.ts

@@ -0,0 +1,39 @@
+import { useEffect } from 'react';
+import {
+  createResourceHook,
+  createEventValueHook,
+} from '@symbiote-native/react';
+import { createAudioStreamController } from '../core/audio-stream-controller';
+import {
+  subscribeAudioStreamBuffer,
+  toAudioStreamKey,
+} from '../core/audio-stream-subscription';
+import { AUDIO_STREAM_STATUS } from '../core/types';
+import type {
+  AudioStream,
+  IAudioStreamResult,
+  IAudioStreamStatus,
+  IUseAudioStreamOptions,
+} from '../core';
+
+const useStreamResource = createResourceHook(createAudioStreamController);
+const useStreamStatus = createEventValueHook<
+  AudioStream,
+  IAudioStreamStatus,
+  typeof AUDIO_STREAM_STATUS
+>(AUDIO_STREAM_STATUS, stream => ({ isStreaming: stream.isStreaming }));
+
+/** React twin of `expo-audio`'s `useAudioStream` */
+export function useAudioStream(
+  options: IUseAudioStreamOptions = {},
+): IAudioStreamResult {
+  const stream = useStreamResource(toAudioStreamKey(options));
+  const status = useStreamStatus(stream);
+
+  useEffect(
+    () => subscribeAudioStreamBuffer(stream, options.onBuffer),
+    [stream, options.onBuffer],
+  );
+
+  return { stream, isStreaming: status.isStreaming };
+}

package/src/solid/index.ts

@@ -0,0 +1,9 @@
+export * from '../core';
+export { useAudioPlayer } from './use-audio-player';
+export { useAudioPlayerStatus } from './use-audio-player-status';
+export { useAudioSampleListener } from './use-audio-sample-listener';
+export { useAudioPlaylist } from './use-audio-playlist';
+export { useAudioPlaylistStatus } from './use-audio-playlist-status';
+export { useAudioRecorder } from './use-audio-recorder';
+export { useAudioRecorderState } from './use-audio-recorder-state';
+export { useAudioStream } from './use-audio-stream';

package/src/solid/use-audio-player-status.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/solid';
+import { PLAYBACK_STATUS_UPDATE } from '../core/types';
+import type { AudioPlayer } from '../core';
+import type { IAudioStatus } from '../core';
+
+/** Solid twin of `expo-audio`'s `useAudioPlayerStatus` */
+export const useAudioPlayerStatus = createEventValueHook<
+  AudioPlayer,
+  IAudioStatus,
+  typeof PLAYBACK_STATUS_UPDATE
+>(PLAYBACK_STATUS_UPDATE, player => player.currentStatus);

package/src/solid/use-audio-player.ts

@@ -0,0 +1,15 @@
+import type { Accessor } from 'solid-js';
+import { createResourceHook } from '@symbiote-native/solid';
+import { createAudioPlayerController } from '../core/audio-player-controller';
+import type { AudioPlayer } from '../core';
+import type { IAudioPlayerOptions, IAudioSource } from '../core';
+
+const usePlayerResource = createResourceHook(createAudioPlayerController);
+
+/** Solid twin of `expo-audio`'s `useAudioPlayer` */
+export function useAudioPlayer(
+  source: Accessor<IAudioSource>,
+  options: Accessor<IAudioPlayerOptions> = () => ({}),
+): Accessor<AudioPlayer> {
+  return usePlayerResource(() => [source(), options()]);
+}

package/src/solid/use-audio-playlist-status.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/solid';
+import { PLAYLIST_STATUS_UPDATE } from '../core/types';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistStatus } from '../core';
+
+/** Solid twin of `expo-audio`'s `useAudioPlaylistStatus` */
+export const useAudioPlaylistStatus = createEventValueHook<
+  AudioPlaylist,
+  IAudioPlaylistStatus,
+  typeof PLAYLIST_STATUS_UPDATE
+>(PLAYLIST_STATUS_UPDATE, playlist => playlist.currentStatus);

package/src/solid/use-audio-playlist.ts

@@ -0,0 +1,14 @@
+import type { Accessor } from 'solid-js';
+import { createResourceHook } from '@symbiote-native/solid';
+import { createAudioPlaylistController } from '../core/audio-playlist-controller';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistOptions } from '../core';
+
+const usePlaylistResource = createResourceHook(createAudioPlaylistController);
+
+/** Solid twin of `expo-audio`'s `useAudioPlaylist` */
+export function useAudioPlaylist(
+  getOptions: Accessor<IAudioPlaylistOptions>,
+): Accessor<AudioPlaylist> {
+  return usePlaylistResource(() => [getOptions()]);
+}

package/src/solid/use-audio-recorder-state.ts

@@ -0,0 +1,18 @@
+import { createSignal, onCleanup, type Accessor } from 'solid-js';
+import { pollRecorderState } from '../core/audio-recorder-polling';
+import type { AudioRecorder } from '../core';
+import type { IRecorderState } from '../core';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+
+/** Solid twin of `expo-audio`'s `useAudioRecorderState` */
+export function useAudioRecorderState(
+  recorder: AudioRecorder,
+  interval: number = DEFAULT_POLL_INTERVAL_MS,
+): Accessor<IRecorderState> {
+  const [state, setState] = createSignal(recorder.getStatus());
+
+  onCleanup(pollRecorderState(recorder, interval, setState));
+
+  return state;
+}

package/src/solid/use-audio-recorder.ts

@@ -0,0 +1,22 @@
+import { createEffect, onCleanup, type Accessor } from 'solid-js';
+import { createResourceHook } from '@symbiote-native/solid';
+import { createAudioRecorderController } from '../core/audio-recorder-controller';
+import { subscribeRecordingStatus } from '../core/audio-recorder-status';
+import type { AudioRecorder } from '../core';
+import type { IRecordingOptions, IRecordingStatus } from '../core';
+
+const useRecorderResource = createResourceHook(createAudioRecorderController);
+
+/** Solid twin of `expo-audio`'s `useAudioRecorder` */
+export function useAudioRecorder(
+  getOptions: Accessor<IRecordingOptions>,
+  statusListener?: (status: IRecordingStatus) => void,
+): Accessor<AudioRecorder> {
+  const recorder = useRecorderResource(() => [getOptions()]);
+
+  createEffect(() => {
+    onCleanup(subscribeRecordingStatus(recorder(), statusListener));
+  });
+
+  return recorder;
+}

package/src/solid/use-audio-sample-listener.ts

@@ -0,0 +1,14 @@
+import { createEffect, onCleanup } from 'solid-js';
+import { subscribeAudioSampleListener } from '../core/audio-sample-listener';
+import type { IAudioSamplePlayer } from '../core/audio-sample-listener';
+import type { IAudioSample } from '../core/types';
+
+/** Solid twin of `expo-audio`'s `useAudioSampleListener` */
+export function useAudioSampleListener(
+  player: IAudioSamplePlayer,
+  listener: (data: IAudioSample) => void,
+): void {
+  createEffect(() => {
+    onCleanup(subscribeAudioSampleListener(player, listener));
+  });
+}

package/src/solid/use-audio-stream.ts

@@ -0,0 +1,34 @@
+import { createMemo, onCleanup, type Accessor } from 'solid-js';
+import {
+  createResourceHook,
+  createEventValueHook,
+} from '@symbiote-native/solid';
+import { createAudioStreamHooks } from '../core/audio-stream-hooks';
+import { toAudioStreamKey } from '../core/audio-stream-subscription';
+import { runAudioStreamBufferEffect } from '../core/audio-stream-lifecycle';
+import type { IAudioStreamResult, IUseAudioStreamOptions } from '../core';
+
+const { useStreamResource, useStreamStatus } = createAudioStreamHooks(
+  createResourceHook,
+  createEventValueHook,
+);
+
+/** Solid twin of `expo-audio`'s `useAudioStream` */
+export function useAudioStream(
+  getOptions: Accessor<IUseAudioStreamOptions>,
+): Accessor<IAudioStreamResult> {
+  const stream = useStreamResource(() => [toAudioStreamKey(getOptions())]);
+  const status = useStreamStatus(stream);
+
+  runAudioStreamBufferEffect(
+    stream,
+    () => getOptions().onBuffer,
+    fn => fn(),
+    onCleanup,
+  );
+
+  return createMemo(() => ({
+    stream: stream(),
+    isStreaming: status().isStreaming,
+  }));
+}

package/src/svelte/index.ts

@@ -0,0 +1,9 @@
+export * from '../core';
+export { useAudioPlayer } from './use-audio-player.svelte';
+export { useAudioPlayerStatus } from './use-audio-player-status.svelte';
+export { useAudioSampleListener } from './use-audio-sample-listener.svelte';
+export { useAudioPlaylist } from './use-audio-playlist.svelte';
+export { useAudioPlaylistStatus } from './use-audio-playlist-status.svelte';
+export { useAudioRecorder } from './use-audio-recorder.svelte';
+export { useAudioRecorderState } from './use-audio-recorder-state.svelte';
+export { useAudioStream } from './use-audio-stream.svelte';

package/src/svelte/svelte-ambient.d.ts

@@ -0,0 +1,3 @@
+// Pulls svelte's ambient globals ($state/$effect/...) into this package's tsc program,
+// same fix as `packages/navigation/src/svelte/svelte-ambient.d.ts`
+/// <reference types="svelte" />

package/src/svelte/svelte-compile.test-helper.ts

@@ -0,0 +1,7 @@
+// Re-exports the existing harness instead of a third copy (packages/sqlite and
+// packages/navigation already carry one, not part of either package's public exports)
+export {
+  createSvelteHarness,
+  loadComponent,
+  type ISvelteHarness,
+} from '../../../sqlite/src/svelte/svelte-compile.test-helper';

package/src/svelte/use-audio-player-status.svelte.ts

@@ -0,0 +1,11 @@
+import { createEventValueHook } from '@symbiote-native/svelte/runes/create-event-value-hook';
+import { PLAYBACK_STATUS_UPDATE } from '../core/types';
+import type { AudioPlayer } from '../core';
+import type { IAudioStatus } from '../core';
+
+/** Svelte twin of `expo-audio`'s `useAudioPlayerStatus` */
+export const useAudioPlayerStatus = createEventValueHook<
+  AudioPlayer,
+  IAudioStatus,
+  typeof PLAYBACK_STATUS_UPDATE
+>(PLAYBACK_STATUS_UPDATE, player => player.currentStatus);