@symbiote-native/audio 0.1.2 → 0.1.4

package/build-ngc/core/subscribe-single-event.js

@@ -0,0 +1,9 @@
+// Shared shape behind `subscribeRecordingStatus`/`subscribeAudioStreamBuffer`: one optional
+// listener over one named event, unsubscribed via the returned cleanup
+export function subscribeSingleEvent(source, event, listener) {
+    const subscription = source.addListener(event, payload => {
+        listener?.(payload);
+    });
+    return () => subscription.remove();
+}
+//# sourceMappingURL=subscribe-single-event.js.map

package/build-ngc/core/subscribe-single-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subscribe-single-event.js","sourceRoot":"","sources":["../../src/core/subscribe-single-event.ts"],"names":[],"mappings":"AAAA,4FAA4F;AAC5F,uEAAuE;AACvE,MAAM,UAAU,oBAAoB,CAClC,MAKC,EACD,KAAa,EACb,QAAmD;IAEnD,MAAM,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE;QACvD,QAAQ,EAAE,CAAC,OAAO,CAAC,CAAC;IACtB,CAAC,CAAC,CAAC;IACH,OAAO,GAAG,EAAE,CAAC,YAAY,CAAC,MAAM,EAAE,CAAC;AACrC,CAAC"}

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

@@ -1,15 +1,15 @@
+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. */
 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 | {
+/** 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;
 };
@@ -31,7 +31,11 @@ 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;
@@ -136,6 +140,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/build-ngc/core/types.js.map

@@ -1 +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"}
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/core/types.ts"],"names":[],"mappings":"AAiRA,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/audio",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "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": {
@@ -35,20 +35,20 @@
       "default": "./build/core/index.js"
     },
     "./vue": {
-      "types": "./build/core/index.d.ts",
-      "default": "./build/core/index.js"
+      "types": "./build/vue/index.d.ts",
+      "default": "./build/vue/index.js"
     },
     "./react": {
-      "types": "./build/core/index.d.ts",
-      "default": "./build/core/index.js"
+      "types": "./build/react/index.d.ts",
+      "default": "./build/react/index.js"
     },
     "./svelte": {
-      "types": "./build/core/index.d.ts",
-      "default": "./build/core/index.js"
+      "types": "./build/svelte/index.d.ts",
+      "default": "./build/svelte/index.js"
     },
     "./solid": {
-      "types": "./build/core/index.d.ts",
-      "default": "./build/core/index.js"
+      "types": "./build/solid/index.d.ts",
+      "default": "./build/solid/index.js"
     },
     "./angular": {
       "types": "./build-ngc/angular/index.d.ts",
@@ -70,7 +70,8 @@
   },
   "dependencies": {
     "expo-audio": "57.0.4",
-    "expo-modules-core": "57.0.5"
+    "expo-modules-core": "57.0.20",
+    "@symbiote-native/asset": "0.1.2"
   },
   "peerDependencies": {
     "@angular/core": ">=20",
@@ -80,12 +81,12 @@
     "solid-js": ">=1.9.0",
     "svelte": ">=5.56.0",
     "vue": ">=3.5.0",
-    "@symbiote-native/angular": "^3.1.2",
-    "@symbiote-native/engine": "^1.3.1",
-    "@symbiote-native/react": "^3.0.4",
-    "@symbiote-native/solid": "^3.0.4",
-    "@symbiote-native/svelte": "^3.0.4",
-    "@symbiote-native/vue": "^3.0.4"
+    "@symbiote-native/angular": "^3.3.0",
+    "@symbiote-native/engine": "^1.6.0",
+    "@symbiote-native/react": "^3.3.0",
+    "@symbiote-native/solid": "^3.2.0",
+    "@symbiote-native/svelte": "^3.2.0",
+    "@symbiote-native/vue": "^3.3.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -133,13 +134,13 @@
     "solid-js": "^1.9.14",
     "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "3.1.2",
-    "@symbiote-native/engine": "1.3.1",
-    "@symbiote-native/react": "3.0.4",
-    "@symbiote-native/solid": "3.0.4",
-    "@symbiote-native/svelte": "3.0.4",
-    "@symbiote-native/test-utils": "0.4.4",
-    "@symbiote-native/vue": "3.0.4"
+    "@symbiote-native/angular": "3.3.0",
+    "@symbiote-native/engine": "1.6.0",
+    "@symbiote-native/react": "3.3.0",
+    "@symbiote-native/solid": "3.2.0",
+    "@symbiote-native/svelte": "3.2.0",
+    "@symbiote-native/test-utils": "0.4.7",
+    "@symbiote-native/vue": "3.3.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/index.ts

@@ -1,4 +1,9 @@
-// @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';
+export { injectAudioPlayer } from './inject-audio-player';
+export { injectAudioPlayerStatus } from './inject-audio-player-status';
+export { injectAudioSampleListener } from './inject-audio-sample-listener';
+export { injectAudioPlaylist } from './inject-audio-playlist';
+export { injectAudioPlaylistStatus } from './inject-audio-playlist-status';
+export { injectAudioRecorder } from './inject-audio-recorder';
+export { injectAudioRecorderState } from './inject-audio-recorder-state';
+export { injectAudioStream } from './inject-audio-stream';

package/src/angular/inject-audio-player-status.ts

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

package/src/angular/inject-audio-player.ts

@@ -0,0 +1,17 @@
+// Angular twin of `useAudioPlayer`, `injectX` shape matching
+// `@symbiote-native/navigation`'s `injectLinkingIntegration`
+
+import type { Signal } from '@angular/core';
+import { createResourceHook } from '@symbiote-native/angular';
+import { createAudioPlayerController } from '../core/audio-player-controller';
+import type { AudioPlayer } from '../core';
+import type { IAudioPlayerOptions, IAudioSource } from '../core';
+
+const injectPlayerResource = createResourceHook(createAudioPlayerController);
+
+export function injectAudioPlayer(
+  source: () => IAudioSource,
+  options: () => IAudioPlayerOptions = () => ({}),
+): Signal<AudioPlayer> {
+  return injectPlayerResource(() => [source(), options()]);
+}

package/src/angular/inject-audio-playlist-status.ts

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

package/src/angular/inject-audio-playlist.ts

@@ -0,0 +1,16 @@
+import type { Signal } from '@angular/core';
+import { createResourceHook } from '@symbiote-native/angular';
+import { createAudioPlaylistController } from '../core/audio-playlist-controller';
+import type { AudioPlaylist } from '../core';
+import type { IAudioPlaylistOptions } from '../core';
+
+const injectPlaylistResource = createResourceHook(
+  createAudioPlaylistController,
+);
+
+/** Angular twin of `expo-audio`'s `useAudioPlaylist` */
+export function injectAudioPlaylist(
+  getOptions: () => IAudioPlaylistOptions,
+): Signal<AudioPlaylist> {
+  return injectPlaylistResource(() => [getOptions()]);
+}

package/src/angular/inject-audio-recorder-state.ts

@@ -0,0 +1,21 @@
+import { DestroyRef, inject, signal, type Signal } from '@angular/core';
+import { pollRecorderState } from '../core/audio-recorder-polling';
+import type { AudioRecorder } from '../core';
+import type { IRecorderState } from '../core';
+
+const DEFAULT_POLL_INTERVAL_MS = 500;
+
+/** Angular twin of `expo-audio`'s `useAudioRecorderState` */
+export function injectAudioRecorderState(
+  recorder: AudioRecorder,
+  interval: number = DEFAULT_POLL_INTERVAL_MS,
+): Signal<IRecorderState> {
+  const state = signal(recorder.getStatus());
+
+  const stop = pollRecorderState(recorder, interval, updater =>
+    state.set(updater(state())),
+  );
+  inject(DestroyRef).onDestroy(stop);
+
+  return state.asReadonly();
+}

package/src/angular/inject-audio-recorder.ts

@@ -0,0 +1,24 @@
+import { effect, type Signal } from '@angular/core';
+import { createResourceHook } from '@symbiote-native/angular';
+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 injectRecorderResource = createResourceHook(
+  createAudioRecorderController,
+);
+
+/** Angular twin of `expo-audio`'s `useAudioRecorder` */
+export function injectAudioRecorder(
+  getOptions: () => IRecordingOptions,
+  statusListener?: (status: IRecordingStatus) => void,
+): Signal<AudioRecorder> {
+  const recorder = injectRecorderResource(() => [getOptions()]);
+
+  effect(onCleanup => {
+    onCleanup(subscribeRecordingStatus(recorder(), statusListener));
+  });
+
+  return recorder;
+}

package/src/angular/inject-audio-sample-listener.ts

@@ -0,0 +1,13 @@
+import { DestroyRef, inject } from '@angular/core';
+import { subscribeAudioSampleListener } from '../core/audio-sample-listener';
+import type { IAudioSamplePlayer } from '../core/audio-sample-listener';
+import type { IAudioSample } from '../core/types';
+
+/** Angular twin of `expo-audio`'s `useAudioSampleListener` */
+export function injectAudioSampleListener(
+  player: IAudioSamplePlayer,
+  listener: (data: IAudioSample) => void,
+): void {
+  const unsubscribe = subscribeAudioSampleListener(player, listener);
+  inject(DestroyRef).onDestroy(unsubscribe);
+}

package/src/angular/inject-audio-stream.ts

@@ -0,0 +1,41 @@
+import {
+  computed,
+  DestroyRef,
+  effect,
+  inject,
+  type Signal,
+} from '@angular/core';
+import {
+  createResourceHook,
+  createEventValueHook,
+} from '@symbiote-native/angular';
+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,
+);
+
+/** Angular twin of `expo-audio`'s `useAudioStream` */
+export function injectAudioStream(
+  getOptions: () => IUseAudioStreamOptions,
+): Signal<IAudioStreamResult> {
+  const destroyRef = inject(DestroyRef);
+  const stream = useStreamResource(() => [toAudioStreamKey(getOptions())]);
+  const status = useStreamStatus(stream);
+
+  runAudioStreamBufferEffect(
+    stream,
+    () => getOptions().onBuffer,
+    effect,
+    cleanup => destroyRef.onDestroy(cleanup),
+  );
+
+  return computed(() => ({
+    stream: stream(),
+    isStreaming: status().isStreaming,
+  }));
+}

package/src/core/audio-module.ts

@@ -18,7 +18,8 @@ export async function setAudioModeAsync(
       : {
           shouldPlayInBackground: mode.shouldPlayInBackground,
           shouldRouteThroughEarpiece: mode.shouldRouteThroughEarpiece,
-          interruptionMode: mode.interruptionMode,
+          interruptionMode:
+            mode.interruptionMode ?? mode.interruptionModeAndroid,
           allowsBackgroundRecording: mode.allowsBackgroundRecording,
           playsInSilentMode: mode.playsInSilentMode,
         };

package/src/core/audio-player-controller.ts

@@ -0,0 +1,25 @@
+import { createJsonKeyedResourceController } from './json-keyed-resource-controller';
+import { createAudioPlayer, type AudioPlayer } from './audio-player';
+import type { IAudioPlayerOptions, IAudioSource } from './types';
+
+type IAudioPlayerKey = { source: IAudioSource; options: IAudioPlayerOptions };
+
+export function createAudioPlayerController(): {
+  resolve: (source: IAudioSource, options: IAudioPlayerOptions) => AudioPlayer;
+  flushDispose: () => void;
+  dispose: () => void;
+} {
+  const controller = createJsonKeyedResourceController<
+    IAudioPlayerKey,
+    AudioPlayer
+  >(
+    key => createAudioPlayer(key.source, key.options),
+    player => player.remove(),
+  );
+
+  return {
+    resolve: (source, options) => controller.resolve({ source, options }),
+    flushDispose: controller.flushDispose,
+    dispose: controller.dispose,
+  };
+}

package/src/core/audio-player.ts

@@ -1,6 +1,6 @@
 import { Platform } from 'expo-modules-core';
 import { expoAudio } from './native-module';
-import { resolveSource } from './resolve-source';
+import { resolveSource, resolveSourceWithDownload } from './resolve-source';
 import type {
   IAudioPlayerOptions,
   IAudioSource,
@@ -40,14 +40,27 @@ export function createAudioPlayer(
 ): AudioPlayer {
   const {
     updateInterval = 500,
+    downloadFirst = false,
     keepAudioSessionActive = false,
     preferredForwardBufferDuration = 0,
   } = options;
-  const resolvedSource = resolveSource(source);
-  return new AudioPlayer(
-    resolvedSource,
+  const player = new AudioPlayer(
+    downloadFirst ? null : resolveSource(source),
     updateInterval,
     keepAudioSessionActive,
     preferredForwardBufferDuration,
   );
+
+  if (downloadFirst && source) {
+    resolveSourceWithDownload(source)
+      .then(resolved => {
+        if (resolved) player.replace(resolved);
+      })
+      .catch(() => {
+        const fallback = resolveSource(source);
+        if (fallback) player.replace(fallback);
+      });
+  }
+
+  return player;
 }

package/src/core/audio-playlist-controller.ts

@@ -0,0 +1,14 @@
+import type { IResourceController } from '@symbiote-native/engine';
+import { createJsonKeyedResourceController } from './json-keyed-resource-controller';
+import { createAudioPlaylist, type AudioPlaylist } from './audio-playlist';
+import type { IAudioPlaylistOptions } from './types';
+
+export function createAudioPlaylistController(): IResourceController<
+  IAudioPlaylistOptions,
+  AudioPlaylist
+> {
+  return createJsonKeyedResourceController<
+    IAudioPlaylistOptions,
+    AudioPlaylist
+  >(createAudioPlaylist, playlist => playlist.destroy());
+}

package/src/core/audio-recorder-controller.ts

@@ -0,0 +1,14 @@
+import type { IResourceController } from '@symbiote-native/engine';
+import { createJsonKeyedResourceController } from './json-keyed-resource-controller';
+import { createAudioRecorder, type AudioRecorder } from './audio-recorder';
+import type { IRecordingOptions } from './types';
+
+export function createAudioRecorderController(): IResourceController<
+  IRecordingOptions,
+  AudioRecorder
+> {
+  return createJsonKeyedResourceController<IRecordingOptions, AudioRecorder>(
+    createAudioRecorder,
+    recorder => recorder.release(),
+  );
+}

package/src/core/audio-recorder-polling.ts

@@ -0,0 +1,20 @@
+import { shouldUpdateRecorderState } from './audio-recorder-state';
+import type { IRecorderState } from './types';
+
+export type IPollableRecorder = {
+  getStatus: () => IRecorderState;
+};
+
+// Ported from `useAudioRecorderState`'s `setInterval` body; `update` matches every adapter's
+// own state setter (`useState`, Solid's `createSignal`, a plain `(prev) => next` writer, ...)
+export function pollRecorderState(
+  recorder: IPollableRecorder,
+  interval: number,
+  update: (updater: (prev: IRecorderState) => IRecorderState) => void,
+): () => void {
+  const id = setInterval(() => {
+    const next = recorder.getStatus();
+    update(prev => (shouldUpdateRecorderState(prev, next) ? next : prev));
+  }, interval);
+  return () => clearInterval(id);
+}

package/src/core/audio-recorder-state.ts

@@ -0,0 +1,26 @@
+import type { IRecorderState } from './types';
+
+const METERING_EPSILON = 0.1;
+const DURATION_EPSILON_MS = 50;
+
+function meteringChanged(prev: IRecorderState, next: IRecorderState): boolean {
+  if ((prev.metering === undefined) !== (next.metering === undefined))
+    return true;
+  if (prev.metering === undefined || next.metering === undefined) return false;
+  return Math.abs(prev.metering - next.metering) > METERING_EPSILON;
+}
+
+// Ported from `useAudioRecorderState`'s poll-diff `setState` body
+export function shouldUpdateRecorderState(
+  prev: IRecorderState,
+  next: IRecorderState,
+): boolean {
+  return (
+    prev.canRecord !== next.canRecord ||
+    prev.isRecording !== next.isRecording ||
+    prev.mediaServicesDidReset !== next.mediaServicesDidReset ||
+    prev.url !== next.url ||
+    Math.abs(prev.durationMillis - next.durationMillis) > DURATION_EPSILON_MS ||
+    meteringChanged(prev, next)
+  );
+}

package/src/core/audio-recorder-status.ts

@@ -0,0 +1,22 @@
+import { RECORDING_STATUS_UPDATE } from './types';
+import { subscribeSingleEvent } from './subscribe-single-event';
+import type { IRecordingStatus } from './types';
+
+export type IStatusRecorder = {
+  addListener: (
+    event: typeof RECORDING_STATUS_UPDATE,
+    listener: (status: IRecordingStatus) => void,
+  ) => { remove: () => void };
+};
+
+// Ported from `useAudioRecorder`'s status-listener `useEffect` body
+export function subscribeRecordingStatus(
+  recorder: IStatusRecorder,
+  statusListener: ((status: IRecordingStatus) => void) | undefined,
+): () => void {
+  return subscribeSingleEvent(
+    recorder,
+    RECORDING_STATUS_UPDATE,
+    statusListener,
+  );
+}

package/src/core/audio-recorder.ts

@@ -44,3 +44,8 @@ export class AudioRecorder extends expoAudio.AudioRecorder {
     return super.prepareToRecordAsync(processedOptions);
   }
 }
+
+/** Does not release automatically, same lifecycle note as `createAudioPlayer` */
+export function createAudioRecorder(options: IRecordingOptions): AudioRecorder {
+  return new AudioRecorder(createRecordingOptions(options));
+}

package/src/core/audio-sample-listener.ts

@@ -0,0 +1,23 @@
+import { AUDIO_SAMPLE_UPDATE } from './types';
+import type { IAudioSample } from './types';
+
+export type IAudioSamplePlayer = {
+  isAudioSamplingSupported: boolean;
+  setAudioSamplingEnabled: (enabled: boolean) => void;
+  addListener: (
+    event: typeof AUDIO_SAMPLE_UPDATE,
+    listener: (data: IAudioSample) => void,
+  ) => { remove: () => void };
+};
+
+/** Ported from `expo-audio`'s `useAudioSampleListener` (its `useEffect` body factored out) */
+export function subscribeAudioSampleListener(
+  player: IAudioSamplePlayer,
+  listener: (data: IAudioSample) => void,
+): () => void {
+  if (!player.isAudioSamplingSupported) return () => {};
+
+  player.setAudioSamplingEnabled(true);
+  const subscription = player.addListener(AUDIO_SAMPLE_UPDATE, listener);
+  return () => subscription.remove();
+}

package/src/core/audio-stream-controller.ts

@@ -0,0 +1,14 @@
+import type { IResourceController } from '@symbiote-native/engine';
+import { createJsonKeyedResourceController } from './json-keyed-resource-controller';
+import { createAudioStream, type AudioStream } from './audio-stream';
+import type { IAudioStreamOptions } from './types';
+
+export function createAudioStreamController(): IResourceController<
+  IAudioStreamOptions,
+  AudioStream
+> {
+  return createJsonKeyedResourceController<IAudioStreamOptions, AudioStream>(
+    createAudioStream,
+    stream => stream.release(),
+  );
+}

package/src/core/audio-stream-hooks.ts

@@ -0,0 +1,31 @@
+import type { IResourceController } from '@symbiote-native/engine';
+import { createAudioStreamController } from './audio-stream-controller';
+import { AUDIO_STREAM_STATUS } from './types';
+import type { AudioStream } from './audio-stream';
+import type { IAudioStreamOptions, IAudioStreamStatus } from './types';
+
+// Binds `createAudioStreamController`/`AUDIO_STREAM_STATUS` behind the getter-based
+// `createResourceHook`/`createEventValueHook` shape Vue/Solid/Angular share (React keeps its own
+// ref-based wiring, same split as `runAudioStreamBufferEffect`)
+export function createAudioStreamHooks<TResourceBox, TStatusBox>(
+  createResourceHook: (
+    createController: () => IResourceController<
+      IAudioStreamOptions,
+      AudioStream
+    >,
+  ) => (getArgs: () => [IAudioStreamOptions]) => TResourceBox,
+  createEventValueHook: (
+    event: typeof AUDIO_STREAM_STATUS,
+    getValue: (source: AudioStream) => IAudioStreamStatus,
+  ) => (getSource: () => AudioStream) => TStatusBox,
+): {
+  useStreamResource: (getArgs: () => [IAudioStreamOptions]) => TResourceBox;
+  useStreamStatus: (getSource: () => AudioStream) => TStatusBox;
+} {
+  return {
+    useStreamResource: createResourceHook(createAudioStreamController),
+    useStreamStatus: createEventValueHook(AUDIO_STREAM_STATUS, stream => ({
+      isStreaming: stream.isStreaming,
+    })),
+  };
+}

package/src/core/audio-stream-lifecycle.ts

@@ -0,0 +1,19 @@
+import { subscribeAudioStreamBuffer } from './audio-stream-subscription';
+import type { IAudioStreamBufferSource } from './audio-stream-subscription';
+import type { IAudioStreamBuffer } from './types';
+
+// Shared by adapters whose reactivity auto-tracks reads inside a plain effect (Vue's
+// `watchEffect`, Solid's `createEffect`, Angular's `effect`); React's render model doesn't, so
+// it keeps its own ref-based wiring - same split as `createNetworkRequestObserverLifecycle`
+export function runAudioStreamBufferEffect<
+  TStream extends IAudioStreamBufferSource,
+>(
+  getStream: () => TStream,
+  getOnBuffer: () => ((buffer: IAudioStreamBuffer) => void) | undefined,
+  runEffect: (effect: () => void) => void,
+  registerCleanup: (cleanup: () => void) => void,
+): void {
+  runEffect(() => {
+    registerCleanup(subscribeAudioStreamBuffer(getStream(), getOnBuffer()));
+  });
+}

package/src/core/audio-stream-subscription.ts

@@ -0,0 +1,28 @@
+import { AUDIO_STREAM_BUFFER } from './types';
+import { subscribeSingleEvent } from './subscribe-single-event';
+import type { IAudioStreamBuffer, IAudioStreamOptions } from './types';
+import type { IUseAudioStreamOptions } from './audio-stream';
+
+export type IAudioStreamBufferSource = {
+  addListener: (
+    event: typeof AUDIO_STREAM_BUFFER,
+    listener: (buffer: IAudioStreamBuffer) => void,
+  ) => { remove: () => void };
+};
+
+// Ported from `useAudioStream`'s buffer-listener `useEffect` body
+export function subscribeAudioStreamBuffer(
+  stream: IAudioStreamBufferSource,
+  onBuffer: ((buffer: IAudioStreamBuffer) => void) | undefined,
+): () => void {
+  return subscribeSingleEvent(stream, AUDIO_STREAM_BUFFER, onBuffer);
+}
+
+// Drops `onBuffer` so a callback identity change doesn't recreate the native stream - matches
+// upstream's own `[sampleRate, channels, encoding]` dependency array
+export function toAudioStreamKey(
+  options: IUseAudioStreamOptions,
+): IAudioStreamOptions {
+  const { sampleRate, channels, encoding } = options;
+  return { sampleRate, channels, encoding };
+}