### Create and Start StreamerNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/streamer-node.mdx

This example demonstrates how to create a new AudioContext, instantiate a StreamerNode, initialize it with an HLS stream path, connect it to the audio destination, and start playback.

```tsx
import React, { useRef } from 'react';
import {
  AudioContext,
  StreamerNode,
} from 'react-native-audio-api';

function App() {
  const audioContextRef = useRef<AudioContext | null>(null);
  if (!audioContextRef.current) {
    audioContextRef.current = new AudioContext();
  }
  const streamer = audioContextRef.current.createStreamer();
  streamer.initialize('link/to/your/hls/source');
  streamer.connect(audioContextRef.current.destination);
  streamer.start(audioContextRef.current.currentTime);
}
```

--------------------------------

### start Method

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-scheduled-source-node.mdx

Schedules the node to start audio playback at a specified time. If no time is given, it starts immediately. This method can only be invoked once per node.

```APIDOC
## start

### Description
Schedules the node to start audio playback at specified time. If no time is given, it starts immediately. You can invoke this method only once in node's life.

### Parameters
#### Path Parameters
- **when** (number) - The time, in seconds, at which the node will start to play.

#### Errors
- `RangeError`: `when` is negative number.
- `InvalidStateError`: If node has already been started once.

### Returns
`undefined`
```

--------------------------------

### Register New Example in Index

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/CLAUDE.md

Adds a new example screen to the main examples index, providing key details for navigation and display.

```typescript
// apps/common-app/src/examples/index.ts
import MyExample from './MyExample';
import { icons } from 'lucide-react-native';  // pick any icon

export const Examples = [
  // ... existing
  {
    key: 'MyExample',
    title: 'My Example',
    Icon: icons.Zap,
    screen: MyExample,
  },
];
```

--------------------------------

### Create and Start Oscillator

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/oscillator-node.mdx

Demonstrates how to create an AudioContext, instantiate an OscillatorNode, connect it to the destination, and start it.

```tsx
import React, { useRef } from 'react';
import {
  AudioContext,
  OscillatorNode,
} from 'react-native-audio-api';

function App() {
  const audioContextRef = useRef<AudioContext | null>(null);
  if (!audioContextRef.current) {
    audioContextRef.current = new AudioContext();
  }
  const oscillator = audioContextRef.current.createOscillator();
  oscillator.connect(audioContextRef.current.destination);
  oscillator.start(audioContextRef.current.currentTime);
}
```

--------------------------------

### Run Fabric Example iOS Tests

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/fabric-example/README.md

Execute native XCTest targets for the Fabric example. Ensure Pods are installed first.

```sh
bundle exec pod install

xcodebuild test \
  -workspace ios/FabricExample.xcworkspace \
  -scheme FabricExample \
  -destination 'platform=iOS Simulator,name=iPhone 17 pro,OS=26.4' \
  -parallelizeTargets
```

--------------------------------

### start

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/inputs/audio-recorder.mdx

Starts the stream from system audio input device. You can pass an optional object with `fileNameOverride` string, to provide your own file name generation.

```APIDOC
## start

### Description
Starts the stream from system audio input device. You can pass optional object with `fileNameOverride` string, to provide your own fileName generation.

### Parameters
#### Request Body
- **fileNameOverride** (string) - Optional - Allows to provide your own file name generation.

### Usage
```tsx
const result = audioRecorder.start({
  fileNameOverride: `my_audio_${mySessionId}`
});

console.log(result.status);
```

### Response
#### Success Response (200)
- **status** (string) - Indicates the status of the operation ('success' or 'error').
```

--------------------------------

### start

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-buffer-source-node.mdx

Schedules the AudioBufferSourceNode to start playback of audio data contained in the associated AudioBuffer, or starts to play immediately. It inherits methods from AudioBufferBaseSourceNode.

```APIDOC
## start

### Description
Schedules the `AudioBufferSourceNode` to start playback of audio data contained in the associated [`AudioBuffer`](/docs/sources/audio-buffer), or starts to play immediately.

### Method Signature
`start(when?: number, offset?: number, duration?: number): undefined`

### Parameters
#### Optional Parameters
- **when** (`number`) - The time, in seconds, at which playback is scheduled to start. If `when` is less than [`AudioContext.currentTime`](/docs/core/base-audio-context#properties) or set to 0, the node starts playing immediately. Default: `0`.
- **offset** (`number`) - The position, in seconds, within the audio buffer where playback begins. The default value is `0`, which starts playback from the beginning of the buffer. If the offset exceeds the buffer’s [`duration`](/docs/sources/audio-buffer#properties) (or the defined [`loopEnd`](/docs/sources/audio-buffer-source-node#properties) value), it’s automatically clamped to the valid range. Offsets are calculated using the buffer’s natural sample rate rather than the current playback rate.
- **duration** (`number`) - The playback duration, in seconds. If not provided, playback continues until the sound ends naturally or is manually stopped with [`stop() method`](/docs/sources/audio-scheduled-source-node#stop). Equivalent to calling `start(when, offset)` followed by `stop(when + duration)`.

### Errors
- `RangeError`: `when` is a negative number.
- `RangeError`: `offset` is a negative number.
- `RangeError`: `duration` is a negative number.
- `InvalidStateError`: If the node has already been started once.

### Returns
`undefined`
```

--------------------------------

### Create Example Screen Index

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/CLAUDE.md

Defines the index file for an example screen, re-exporting the default component.

```typescript
// index.ts
export { default } from './MyExample';
```

--------------------------------

### GainNode Documentation Example

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/CLAUDE.md

Example of how to document a GainNode, including its constructor, options, properties, and methods, following the MDX format.

```APIDOC
## GainNode

Brief one-line description. `GainNode` extends [`AudioNode`](/docs/core/audio-node).

#### [`AudioNode`](/docs/core/audio-node#properties) properties

<AudioNodePropsTable
  numberOfInputs={1}
  numberOfOutputs={1}
  channelCount={2}
  channelCountMode={\"max\"}
  channelInterpretation={\"speakers\"}
/>

## Constructor

```tsx
constructor(context: BaseAudioContext, options?: GainOptions)
```

### `GainOptions`

Inherits all properties from [`AudioNodeOptions`](/docs/core/audio-node#audionodeoptions).

| Parameter | Type | Default | |
| :---: | :---: | :----: | :---- |
| `gain` <Optional /> | `number` | `1` | Initial gain value. |

Or by using [`BaseAudioContext.createGain()`](/docs/core/base-audio-context#creategain).

## Example

```tsx
import { AudioContext } from 'react-native-audio-api';

const ctx = new AudioContext();
const gain = ctx.createGain();
gain.gain.value = 0.5;
gain.connect(ctx.destination);
```

## Properties

It inherits all properties from [`AudioNode`](/docs/core/audio-node#properties).

| Name | Type | Default | Description |
| :----: | :----: | :-------- | :------- |
| `gain` <ReadOnly /> | `AudioParam` | `1` | Gain applied to the signal. Range: [0, 1] typical. |

## Methods

It inherits all methods from [`AudioNode`](/docs/core/audio-node#methods).

## Remarks

#### `gain`
- Nominal range is [0, 1] for attenuation but accepts any finite value.
- Values > 1 amplify; negative values invert phase.
```

--------------------------------

### GainNode Usage Examples

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/effects/gain-node.mdx

Examples demonstrating how to use GainNode for master volume control and smooth volume transitions.

```APIDOC
## Usage

A common use case is controlling the master volume of an audio graph:

```tsx
const audioContext = new AudioContext();
const gainNode = audioContext.createGain();

// Set volume to 50%
gainNode.gain.setValueAtTime(0.5, audioContext.currentTime);

// Connect source → gain → output
source.connect(gainNode);
gainNode.connect(audioContext.destination);
```

To fade in a sound over 2 seconds:

```tsx
gainNode.gain.setValueAtTime(0, audioContext.currentTime);
gainNode.gain.linearRampToValueAtTime(1, audioContext.currentTime + 2);
```
```

--------------------------------

### Example App Structure

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/CLAUDE.md

Illustrates the directory structure for the React Native Audio API example applications, separating native app shells from shared common code.

```tree
apps/
├── fabric-example/          # RN app shell (native + metro config)
│   ├── App.tsx              # Re-exports App from common-app
│   ├── metro.config.js      # Monorepo-aware Metro (watches workspaces)
│   └── android/ ios/        # Native projects
└── common-app/              # Actual app code — edit this
    └── src/
        ├── App.tsx           # Navigation root (Stack + Bottom Tabs)
        ├── examples/         # "Tests" tab — focused feature examples
        │   └── index.ts      # Exports Examples array — register new screens here
        ├── demos/            # "Demo Apps" tab — full mini-apps
        │   └── index.ts      # Exports demos array — register new screens here
        ├── components/       # Shared UI: Container, Button, Slider, Spacer, Switch, Select
        ├── utils/
        │   ├── soundEngines/ # Reusable synth classes (MetronomeSound, Kick, HiHat, Clap)
        │   └── usePlayer.tsx # Hook for pattern-based scheduled playback
        ├── singletons/       # Global audioContext and audioRecorder instances
        └── styles.ts         # Shared colors and layout constants
```

--------------------------------

### startRendering

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/core/offline-audio-context.mdx

Starts rendering the audio, taking into account the current connections and scheduled changes.

```APIDOC
## startRendering
Starts rendering the audio, taking into account the current connections and the current scheduled changes.

### Method
`startRendering(): Promise<AudioBuffer>`
```

--------------------------------

### Manual Mock Setup for Testing

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/other/testing.mdx

Set up the mock implementation manually in your test setup file for use in tests. This approach allows you to import from the main library path.

```typescript
// In your test setup file
jest.mock('react-native-audio-api',
  () =>
    require('react-native-audio-api/mock')
);

// Then in your tests
import { AudioContext, AudioRecorder } from 'react-native-audio-api';
```

--------------------------------

### Create Example Screen Component

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/CLAUDE.md

A basic React Native component for a new example screen, demonstrating the initialization of AudioContext and cleanup.

```tsx
// MyExample.tsx
import React, { useEffect, useRef, FC } from 'react';
import { AudioContext, GainNode } from 'react-native-audio-api';
import { Container, Button, Slider } from '../../components';

const MyExample: FC = () => {
  const audioContextRef = useRef<AudioContext | null>(null);
  const gainRef = useRef<GainNode | null>(null);

  useEffect(() => {
    audioContextRef.current = new AudioContext();
    return () => {
      audioContextRef.current?.close();
    };
  }, []);

  return (
    <Container centered>
      {/* UI here */}
    </Container>
  );
};

export default MyExample;
```

--------------------------------

### LaTeX Math Examples

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/CLAUDE.md

Illustrates how to render inline and block-level mathematical formulas using LaTeX syntax.

```tex
Inline: `$f = -\frac{\text{sampleRate}}{2}$`
Block: `$$formula$$`
```

--------------------------------

### Development Server and Build Commands

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/CLAUDE.md

Commands to start the development server with hot reloading, build the production site, and serve the built site.

```bash
yarn start   # dev server with hot reload
yarn build   # production build
yarn serve   # serve the built site
```

--------------------------------

### OscillatorNode Example

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/oscillator-node.mdx

A basic example demonstrating how to create and use an OscillatorNode.

```APIDOC
## Example

```tsx
import React, { useRef } from 'react';
import {
  AudioContext,
  OscillatorNode,
} from 'react-native-audio-api';

function App() {
  const audioContextRef = useRef<AudioContext | null>(null);
  if (!audioContextRef.current) {
    audioContextRef.current = new AudioContext();
  }
  const oscillator = audioContextRef.current.createOscillator();
  oscillator.connect(audioContextRef.current.destination);
  oscillator.start(audioContextRef.current.currentTime);
}
```
```

--------------------------------

### Play Audio with AudioBufferSourceNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/guides/lets-make-some-noise.mdx

Create an AudioBufferSourceNode, set its buffer, connect it to the audio context's destination, and start playback. Playback can be controlled with start and stop methods.

```jsx
import React from 'react';
import { View, Button } from 'react-native';
import { AudioContext } from 'react-native-audio-api';

export default function App() {
  const handlePlay = async () => {
    const audioContext = new AudioContext();
    const audioBuffer = await audioContext.decodeAudioData(arrayBuffer);

    const playerNode = audioContext.createBufferSource();
    playerNode.buffer = audioBuffer;

    playerNode.connect(audioContext.destination);
    playerNode.start(audioContext.currentTime);
    playerNode.stop(audioContext.currentTime + 10);
  };

  return (
    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
      <Button onPress={handlePlay} title="Play sound!" />
    </View>
  );
}
```

--------------------------------

### Start Metro Bundler

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/fabric-example/README.md

Run this command to start the Metro JavaScript bundler for React Native development.

```sh
# Using npm
npm start

# OR using Yarn
yarn start
```

--------------------------------

### Start Audio Recording

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/inputs/audio-recorder.mdx

Starts the audio recording stream. Optionally, provide a `fileNameOverride` for custom file naming.

```typescript
const result = audioRecorder.start({
  fileNameOverride: `my_audio_${mySessionId}`
});

console.log(result.status);
```

--------------------------------

### Start Playback

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-buffer-queue-source-node.mdx

Schedules the start of playback for the enqueued audio buffers. Playback can begin immediately or at a specified time, with an optional offset into the first buffer.

```APIDOC
## `start` <Overridden /> {#start}

Schedules the `AudioBufferQueueSourceNode` to start playback of enqueued [`AudioBuffers`](/docs/sources/audio-buffer), or starts to play immediately.

| Parameter | Type | Description |
| :---: | :---: | :---- |
| `when` <Optional /> | `number` | The time, in seconds, at which playback is scheduled to start. If `when` is less than [`AudioContext.currentTime`](/docs/core/base-audio-context#properties) or set to 0, the node starts playing immediately. <br /> Default: `0`. |
| `offset` <Optional /> | `number` | The position, in seconds, within the first enqueued audio buffer where playback begins. <br /> The default value is `0`, which starts playback from the beginning of the first enqueued buffer. If the offset exceeds the buffer’s [`duration`](/docs/sources/audio-buffer#properties), it’s automatically clamped to the valid range. |
```

--------------------------------

### Example: Simple Gain Effect with WorkletProcessingNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/worklets/worklet-processing-node.mdx

This example demonstrates creating a simple gain effect by implementing a worklet function that multiplies input audio samples by a gain value.

```typescript
import { AudioContext, AudioRecorder } from 'react-native-audio-api';

// This example shows how to create a simple gain effect using WorkletProcessingNode
function App() {
    const recorder = new AudioRecorder({
      sampleRate: 16000,
      bufferLengthInSamples: 16000,
    });

    const audioContext = new AudioContext({ sampleRate: 16000 });

    // Create a simple gain worklet that multiplies the input by a gain value
    const gainWorklet = (
        inputData: Array<Float32Array>,
        outputData: Array<Float32Array>,
        framesToProcess: number,
        currentTime: number
    ) => {
        'worklet';
        const gain = 0.5; // 50% volume

        for (let ch = 0; ch < inputData.length; ch++) {
            const input = inputData[ch];
            const output = outputData[ch];

            for (let i = 0; i < framesToProcess; i++) {
                output[i] = input[i] * gain;
            }
        }
    };

    const workletProcessingNode = audioContext.createWorkletProcessingNode(
        gainWorklet,
        'AudioRuntime'
    );
    const adapterNode = audioContext.createRecorderAdapter();

    adapterNode.connect(workletProcessingNode);
    workletProcessingNode.connect(audioContext.destination);
    recorder.connect(adapterNode);
    recorder.start();
}
}
```

--------------------------------

### Create and Use AudioBufferQueueSourceNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-buffer-queue-source-node.mdx

Demonstrates how to create an AudioBufferQueueSourceNode, enqueue audio buffers, and start playback. Ensure AudioContext is initialized before use.

```tsx
import React, { useRef } from 'react';
import {
  AudioContext,
  AudioBufferQueueSourceNode,
} from 'react-native-audio-api';

function App() {
    const audioContextRef = useRef<AudioContext | null>(null);
    if (!audioContextRef.current) {
        audioContextRef.current = new AudioContext();
    }
    const audioBufferQueue = audioContextRef.current.createBufferQueueSource();
    const buffer1 = ...; // Load your audio buffer here
    const buffer2 = ...; // Load another audio buffer if needed
    audioBufferQueue.enqueueBuffer(buffer1);
    audioBufferQueue.enqueueBuffer(buffer2);
    audioBufferQueue.connect(audioContextRef.current.destination);
    audioBufferQueue.start(audioContextRef.current.currentTime);
}
```

--------------------------------

### Registering AudioNode HostObject Methods

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/ghdocs/audio-node.md

Example of registering getters, setters, and functions for an AnalyserNodeHostObject in its C++ constructor.

```cpp
AnalyserNodeHostObject::AnalyserNodeHostObject(const std::shared_ptr<BaseAudioContext>& context, const AnalyserOptions &options)
    : /* ... */ {
  addGetters(JSI_EXPORT_PROPERTY_GETTER(AnalyserNodeHostObject, fftSize));
  addSetters(JSI_EXPORT_PROPERTY_SETTER(AnalyserNodeHostObject, fftSize));
  addFunctions(JSI_EXPORT_FUNCTION(AnalyserNodeHostObject, getByteFrequencyData),);
}
```

--------------------------------

### Install Pods for iOS Development

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/fundamentals/getting-started.mdx

Navigate to the 'ios' directory and install CocoaPods dependencies before running your iOS application.

```sh
cd ios && pod install && cd ..
```

--------------------------------

### AudioBufferBaseSourceNode getLatency Example

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-buffer-base-source-node.mdx

Demonstrates how to use getLatency to compensate for pitch correction delay when scheduling playback.

```tsx
const source = audioContext.createBufferSource({ pitchCorrection: true });
source.buffer = buffer;
source.connect(audioContext.destination);

const latency = source.getLatency();

// Schedule playback slightly earlier to compensate for latency
const startTime = audioContext.currentTime + 1.0; // play in 1 second
source.start(startTime - latency);
```

--------------------------------

### Create and Play AudioBufferSourceNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-buffer-source-node.mdx

Instantiates an AudioContext, creates an AudioBufferSourceNode, assigns an AudioBuffer to it, connects it to the audio context's destination, and starts playback. Ensure an AudioBuffer is loaded before assigning it.

```tsx
import React, { useEffect, useRef, FC } from 'react';
import {
  AudioContext,
  AudioBufferSourceNode,
} from 'react-native-audio-api';

function App() {
  const audioContextRef = useRef<AudioContext | null>(null);
  if (!audioContextRef.current) {
    audioContextRef.current = new AudioContext();
  }
  const audioBufferSource = audioContextRef.current.createBufferSource();
  const buffer = ...; // Load your audio buffer here
  audioBufferSource.buffer = buffer;
  audioBufferSource.connect(audioContextRef.current.destination);
  audioBufferSource.start(audioContextRef.current.currentTime);
}
```

--------------------------------

### Install react-native-audio-api using Package Managers

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/fundamentals/getting-started.mdx

Install the react-native-audio-api package using your preferred package manager (Expo, npm, or yarn).

```sh
npx expo install react-native-audio-api
```

```sh
npm install react-native-audio-api
```

```sh
yarn add react-native-audio-api
```

--------------------------------

### AudioBufferBaseSourceNode onPositionChanged and onPositionChangedInterval Example

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-buffer-base-source-node.mdx

Shows how to set up callbacks for position changes and define the interval for these events, enabling features like pause functionality.

```ts
import { AudioContext, AudioBufferSourceNode } from 'react-native-audio-api';

function App() {
    const ctx = new AudioContext();
    const sourceNode = ctx.createBufferSource();
    sourceNode.buffer = null; //set your buffer
    let offset = 0;

    sourceNode.onPositionChanged = (event) => { //setting callback
        this.offset = event.value;
    };

    sourceNode.onPositionChangedInterval = 100; //setting frequency to ~10Hz

    sourceNode.start();
}
```

--------------------------------

### Web Example: Create MediaElementAudioSourceNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/media-element-audio-source-node.mdx

Demonstrates creating a MediaElementAudioSourceNode from an HTMLMediaElement in a web environment. Ensure the AudioContext is initialized before creating the source node.

```tsx
import React, { useRef } from 'react';
import {
  AudioContext,
  GainNode,
} from 'react-native-audio-api';
import { Audio, AudioTagHandle } from 'react-native-audio-api/development/react';

function WebExample() {
  const audioContextRef = useRef<AudioContext | null>(null);
  if (!audioContextRef.current) {
    audioContextRef.current = new AudioContext();
  }

  const audioElement = document.querySelector('audio')!;
  const sourceNode = audioContextRef.current.createMediaElementSource(audioElement);
  sourceNode.connect(audioContextRef.current.destination);
}
```

--------------------------------

### Example Usage of Custom Audio Node

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/guides/create-your-own-effect.mdx

Demonstrates how to instantiate and use your custom audio node within a React Native component. This example connects an oscillator to your custom processor and then to the audio context's destination.

```tsx
import {
  AudioContext,
  OscillatorNode,
} from 'react-native-audio-api';
import { MyProcessorNode } from './types';

function App() {
  const audioContext = new AudioContext();
  const oscillator = audioContext.createOscillator();
  // constructor is put in global scope
  const processor = new MyProcessorNode(audioContext, global.createCustomProcessorNode(audioContext.context));
  oscillator.connect(processor);
  processor.connect(audioContext.destination);
  oscillator.start(audioContext.currentTime);
}

```

--------------------------------

### Category Folder Configuration

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/CLAUDE.md

Example JSON structure for configuring the position and label of a documentation category folder in the sidebar.

```json
{
  "label": "My Category",
  "position": 6
}
```

--------------------------------

### WorkletNode Usage Example

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/worklets/worklet-node.mdx

An example demonstrating how to use WorkletNode to process microphone audio data in real-time. It sets up an AudioContext, defines a worklet callback, creates a WorkletNode, and connects it within the audio processing graph.

```APIDOC
## Example

```tsx
import { AudioContext, AudioRecorder, AudioManager } from 'react-native-audio-api';

AudioManager.setAudioSessionOptions({
    iosCategory: "playAndRecord",
    iosMode: "measurement",
    iosOptions: ["mixWithOthers"],
})

// This example shows how we can use a WorkletNode to process microphone audio data in real-time.
async function App() {
    const recorder = new AudioRecorder();

    const audioContext = new AudioContext({ sampleRate: 16000 });
    const worklet = (audioData: Array<Float32Array>, inputChannelCount: number) => {
        'worklet';
        // here you have access to the number of input channels and the audio data
        // audio data is a two dimensional array where first index is the channel number and second is buffer of exactly bufferLength size
        // !IMPORTANT: here you can only read audio data any modifications will not be reflected in the audio output of this node
        // !VERY IMPORTANT: please read the Known Issue section below
    };
    const workletNode = audioContext.createWorkletNode(worklet, 1024, 2, 'UIRuntime');
    const adapterNode = audioContext.createRecorderAdapter();

    const canSetAudioSessionActivity = await AudioManager.setAudioSessionActivity(true);
    if (!canSetAudioSessionActivity) {
        throw new Error("Could not activate the audio session");
    }
    adapterNode.connect(workletNode);
    workletNode.connect(audioContext.destination);
    recorder.connect(adapterNode);
    recorder.start();
    audioContext.resume();
}
```
```

--------------------------------

### Verify System Bash Installation on Windows

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/fundamentals/getting-started.mdx

Confirm that a Unix-like bash environment is installed and functional on your Windows machine by running a simple echo command.

```bash
bash -c 'echo Hello World!'
```

--------------------------------

### Start Rendering Audio with OfflineAudioContext

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/core/offline-audio-context.mdx

Initiates the rendering of audio based on the current connections and scheduled changes. Returns a Promise that resolves with the rendered AudioBuffer.

```typescript
const audioCtx = new OfflineAudioContext(2, 44100, 44100);
// ... setup your audio graph ...
const buffer = await audioCtx.startRendering();
```

--------------------------------

### Audio Context and Buffer Setup

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/guides/making-a-piano-keyboard.mdx

Initializes the AudioContext and preloads audio files into AudioBuffer objects. Uses useRef for persistent storage across renders.

```tsx
import { AudioBuffer, AudioContext } from 'react-native-audio-api';
import { useRef, useEffect } from 'react';

type KeyName = 'A' | 'B' | 'C' | 'D' | 'E';

type PR<T> = Partial<Record<KeyName, T>>;

const sourceList: PR<string> = {
  A: 'https://software-mansion.github.io/react-native-audio-api/audio/sounds/C4.mp3',
  C: 'https://software-mansion.github.io/react-native-audio-api/audio/sounds/Ds4.mp3',
  E: 'https://software-mansion.github.io/react-native-audio-api/audio/sounds/Fs4.mp3',
};

export default function SimplePiano() {
  const audioContextRef = useRef<AudioContext | null>(null);
  const bufferMapRef = useRef<PR<AudioBuffer>>({});

  useEffect(() => {
    if (!audioContextRef.current) {
      audioContextRef.current = new AudioContext();
    }

    Object.entries(sourceList).forEach(async ([key, url]) => {
      bufferMapRef.current[key as KeyName] = await audioContextRef.current!.decodeAudioData(url);
    });
  }, []);

  const onKeyPressIn = (which: KeyName) => {};
  const onKeyPressOut = (which: KeyName) => {};

  return (
    <View
      style={{
        flex: 1,
        justifyContent: 'center',
        alignItems: 'center',
        flexDirection: 'row',
      }}
    >
      {['A', 'C', 'E'].map((key) => (
        <Button
          onPressIn={onKeyPressIn}
          onPressOut={onKeyPressOut}
          keyName={key as KeyName}
          key={key}
        />
      ))}
    </View>
  );
}

```

--------------------------------

### RecorderAdapterNode Usage Example

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/recorder-adapter-node.mdx

Demonstrates how to create and connect a RecorderAdapterNode within an audio graph, linking an AudioRecorder to the audio context destination.

```APIDOC
## Example

```tsx
const recorder = new AudioRecorder({
    sampleRate: 48000,
    bufferLengthInSamples: 48000,
});
const audioContext = new AudioContext({ sampleRate: 48000 });
const recorderAdapterNode = aCtxRef.current.createRecorderAdapter();

recorder.connect(recorderAdapterNode);
recorderAdapterNode.connect(audioContext.destination)
```
```

--------------------------------

### GainNode Example with React Native Audio API

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/CLAUDE.md

Demonstrates how to create and configure a GainNode using the AudioContext in React Native.

```tsx
import { AudioContext } from 'react-native-audio-api';

const ctx = new AudioContext();
const gain = ctx.createGain();
gain.gain.value = 0.5;
gain.connect(ctx.destination);
```

--------------------------------

### Create and Use WorkletSourceNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/worklets/worklet-source-node.mdx

Demonstrates creating a WorkletSourceNode with a sine wave generator worklet, connecting it to the audio destination, and controlling playback with start() and stop().

```tsx
import { AudioContext } from 'react-native-audio-api';

function App() {
  const audioContext = new AudioContext({ sampleRate: 44100 });

  // Create a simple sine wave generator worklet
  const sineWaveWorklet = (
    audioData: Array<Float32Array>,
    framesToProcess: number,
    currentTime: number,
    startOffset: number
  ) => {
    'worklet';

    const frequency = 440; // A4 note
    const sampleRate = 44100;

    // Generate audio for each channel
    for (let channel = 0; channel < audioData.length; channel++) {
      for (let i = 0; i < framesToProcess; i++) {
        // Calculate the absolute time for this sample
        const sampleTime = currentTime + (startOffset + i) / sampleRate;

        // Generate sine wave
        const phase = 2 * Math.PI * frequency * sampleTime;
        audioData[channel][i] = Math.sin(phase) * 0.5; // 50% volume
      }
    }
  };

  const workletSourceNode = audioContext.createWorkletSourceNode(
    sineWaveWorklet,
    'AudioRuntime'
  );

  // Connect to output and start playback
  workletSourceNode.connect(audioContext.destination);
  workletSourceNode.start(); // Start immediately

  // Stop after 2 seconds
  setTimeout(() => {
    workletSourceNode.stop();
  }, 2000);
}
```

--------------------------------

### Native Example: Create MediaElementAudioSourceNode with Gain

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/media-element-audio-source-node.mdx

Illustrates creating a MediaElementAudioSourceNode from an AudioTagHandle in a native environment, connecting it through a GainNode, and playing the audio. The routeThroughGraph function should be called after the audio element is loaded.

```tsx
import React, { useRef } from 'react';
import {
  AudioContext,
  GainNode,
} from 'react-native-audio-api';
import { Audio, AudioTagHandle } from 'react-native-audio-api/development/react';

function NativeExample() {
  const audioContextRef = useRef<AudioContext | null>(null);
  const audioRef = useRef<AudioTagHandle>(null);

  if (!audioContextRef.current) {
    audioContextRef.current = new AudioContext();
  }

  const routeThroughGraph = () => {
    if (!audioRef.current || !audioContextRef.current) {
      return;
    }

    const mediaElementSource = audioContextRef.current.createMediaElementSource(
      audioRef.current
    );
    const gain = audioContextRef.current.createGain();
    mediaElementSource.connect(gain);
    gain.connect(audioContextRef.current.destination);
    audioRef.current.play();
  };

  return (
    <Audio
      ref={audioRef}
      source="https://example.com/audio.mp3"
      context={audioContextRef.current}
      onLoad={routeThroughGraph}
    />
  );
}
```

--------------------------------

### Play Sound on Key Press

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/guides/making-a-piano-keyboard.mdx

This function creates and starts an `AudioBufferSourceNode` when a key is pressed. It connects the source to the audio context destination and stores the source node for later use.

```tsx
const onKeyPressIn = (which: KeyName) => {
  const audioContext = audioContextRef.current!;
  const buffer = bufferMapRef.current[which];

  const source = new AudioBufferSourceNode(audioContext, {
    buffer,
  });

  source.connect(audioContext.destination);
  source.start();

  playingNotesRef.current[which] = source;
};
```

--------------------------------

### Install CocoaPods Dependencies

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/fabric-example/README.md

Commands to install CocoaPods dependencies for iOS. Run 'bundle install' once to install CocoaPods itself, then 'bundle exec pod install' after updating native dependencies.

```sh
bundle install

bundle exec pod install
```

--------------------------------

### Setting and Removing onEnded Callback

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/sources/audio-scheduled-source-node.mdx

This example demonstrates how to set a callback function to be executed when the audio playback ends and how to remove that callback using the returned subscription object.

```typescript
const subscription = audioBufferSourceNode.onEnded = () => {
  console.log("audio ended");
};

subscription.remove();
```

--------------------------------

### Understanding startOffset and currentTime

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/worklets/worklet-source-node.mdx

Details on how to use `startOffset` and `currentTime` for precise audio generation and phase continuity.

```APIDOC
## Understanding `startOffset` and `currentTime`

The relationship between `currentTime` and `startOffset` is crucial for generating continuous audio:

```tsx
const worklet = (audioData, framesToProcess, currentTime, startOffset) => {
  'worklet';

  const sampleRate = 44100;

  for (let i = 0; i < framesToProcess; i++) {
    // Calculate the exact time for this sample
    const sampleTime = currentTime + (startOffset + i) / sampleRate;

    // Use sampleTime for phase calculations, LFOs, envelopes, etc.
    const phase = 2 * Math.PI * frequency * sampleTime;
    audioData[0][i] = Math.sin(phase);
  }
};
```

**Key points:**
- `currentTime` represents the audio context time at the start of the processing block
- `startOffset` tells you which sample within the block to start generating audio
- The absolute time for sample `i` is: `currentTime + (startOffset + i) / sampleRate`
- This ensures phase continuity and precise timing across processing blocks
```

--------------------------------

### Enable File Output with M4A and High Preset

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/inputs/audio-recorder.mdx

Initialize the AudioRecorder and enable file output with M4A format and High quality preset. This is a common setup for general-purpose recording.

```tsx
import { AudioRecorder, FileFormat, FilePreset } from 'react-native-audio-api';

const audioRecorder = new AudioRecorder();

audioRecorder.enableFileOutput({
  format: FileFormat.M4A,
  preset: FilePreset.High,
});
```

--------------------------------

### Install react-native-worklets

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/worklets/introduction.mdx

Install the react-native-worklets library to enable worklet features. Supported versions are 0.6.x and 0.7.x.

```bash
npm install react-native-worklets
```

--------------------------------

### Directory Structure Overview

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/CLAUDE.md

Illustrates the organization of the React Native Audio API project, including documentation, source code, and static assets.

```bash
packages/audiodocs/
├── docs/                  # All documentation pages (MDX)
│   ├── fundamentals/      # Getting started, installation, best practices
│   ├── guides/            # Tutorials (piano keyboard, noise, ADSR envelope)
│   ├── core/              # AudioContext, AudioNode, AudioParam, BaseAudioContext
│   ├── sources/           # Oscillator, BufferSource, ConstantSource, MediaElement
│   ├── effects/           # Gain, BiquadFilter, Convolver, Dynamics, StereoPanner, Delay, IIR...
│   ├── analysis/          # AnalyserNode
│   ├── inputs/            # AudioRecorder
│   ├── destinations/      # AudioDestinationNode
│   ├── system/            # AudioManager, PlaybackNotificationManager
│   ├── worklets/          # AudioWorklet setup and nodes
│   ├── types/             # Enum docs (OscillatorType, BiquadFilterType...)
│   ├── utils/             # Utility functions (decoding, time-stretching)
│   ├── react/             # React-specific hooks and helpers
│   └── experimental/      # Experimental APIs (Audio tag / development.react)
├── src/
│   ├── components/        # Custom MDX components
│   ├── examples/          # Standalone interactive demo implementations
│   └── pages/             # Landing page
├── static/                # Images, audio files
├── sidebars.js            # Autogenerated — no manual edits needed
└── docusaurus.config.js   # Site config
```

--------------------------------

### Start and Stop Audio Recording

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/inputs/audio-recorder.mdx

Use `audioRecorder.start()` to begin recording and `audioRecorder.stop()` to end it. Handle potential errors during startup and manage the recording state. Ensure the audio session is properly managed when stopping.

```javascript
const result = audioRecorder.start();

    if (result.status === 'error') {
      console.warn(result.message);
      return;
    }

    setIsRecording(true);
  };

  const onStop = () => {
    if (!isRecording) {
      return;
    }

    audioRecorder.stop();
    audioContext.suspend();
    setIsRecording(false);
    AudioManager.setAudioSessionActivity(false);
```

--------------------------------

### Standard Screen Skeleton with State and Effects

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/apps/CLAUDE.md

Provides a standard skeleton for example screens, demonstrating state management for UI elements like play/stop buttons and volume sliders, along with effect hooks for audio context initialization and cleanup.

```tsx
const MyExample: FC = () => {
  const [isPlaying, setIsPlaying] = useState(false);
  const [volume, setVolume] = useState(1.0);

  const audioContextRef = useRef<AudioContext | null>(null);
  const gainRef = useRef<GainNode | null>(null);

  // Initialize audio context once
  useEffect(() => {
    audioContextRef.current = new AudioContext();
    return () => {
      audioContextRef.current?.close();
    };
  }, []);

  // Real-time parameter update
  const handleVolumeChange = (value: number) => {
    setVolume(value);
    if (gainRef.current) {
      gainRef.current.gain.value = value;
    }
  };

  return (
    <Container centered>
      <Button
        title={isPlaying ? 'Stop' : 'Play'}
        onPress={() => setIsPlaying((p) => !p)} 
      />
      <Slider
        label="Volume"
        min={0} max={1} step={0.01}
        value={volume}
        onValueChange={handleVolumeChange}
      />
    </Container>
  );
};
```

--------------------------------

### Mock Audio API Test Suite

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/other/testing.mdx

This example demonstrates a comprehensive test suite for audio applications using the mock implementation. It covers setting up the AudioContext, creating complex audio processing chains with oscillators and filters, and testing audio file decoding.

```typescript
import {
  AudioContext,
  AudioRecorder,
  FileFormat,
  decodeAudioData
} from 'react-native-audio-api/mock';

describe('Audio Application Tests', () => {
  let context: AudioContext;

  beforeEach(() => {
    context = new AudioContext();
  });

  afterEach(() => {
    // Clean up if needed
    context.close();
  });

  describe('Audio Graph', () => {
    it('should create complex audio processing chain', () => {
      const oscillator = context.createOscillator();
      const filter = context.createBiquadFilter();
      const delay = context.createDelay();
      const gainNode = context.createGain();

      // Configure effects chain
      filter.type = 'lowpass';
      filter.frequency.value = 2000;
      delay.delayTime.value = 0.3;
      gainNode.gain.value = 0.8;

      // Connect the chain
      oscillator.connect(filter);
      filter.connect(delay);
      delay.connect(gainNode);
      gainNode.connect(context.destination);

      // Verify configuration
      expect(filter.type).toBe('lowpass');
      expect(delay.delayTime.value).toBe(0.3);
      expect(gainNode.gain.value).toBe(0.8);
    });
  });

  describe('File Operations', () => {
    it('should handle audio file processing', async () => {
      const mockAudioData = new ArrayBuffer(1024);

      // Test audio decoding
      const decodedBuffer = await decodeAudioData(mockAudioData);
      expect(decodedBuffer.numberOfChannels).toBe(2);
      expect(decodedBuffer.sampleRate).toBe(44100);
    });
  });
});
```

--------------------------------

### setValueAtTime

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/core/audio-param.mdx

Schedules an instant change to the AudioParam's value at a specified start time.

```APIDOC
## `setValueAtTime`

### Description
Schedules an instant change to the `value` at given `startTime`.

:::caution
If you need to call this function many times (especially more than 31 times), it is recommended to use the methods described below (such as [`linearRampToValueAtTime`](/docs/core/audio-param#linearramptovalueattime) or [`exponentialRampToValueAtTime`](/docs/core/audio-param#exponentialramptovalueattime)), as they are more efficient for continuous changes. For more specific use cases, you can schedule multiple value changes using [`setValueCurveAtTime`](/docs/core/audio-param#setvaluecurveattime).
:::

### Parameters
- **`value`** (number) - A float representing the value the `AudioParam` will be set at given time.
- **`startTime`** (number) - The time, in seconds, at which the change in value is going to happen. If it's smaller than [`currentTime`](https://docs.swmansion.com/react-native-audio-api/docs/core/base-audio-context#properties), it will be clamped to [`currentTime`](https://docs.swmansion.com/react-native-audio-api/docs/core/base-audio-context#properties).

### Errors
- `RangeError`: `startTime` is negative number.
- `NotSupportedError`: `startTime` falls within the interval $[T, T+D)$ where $T$ is the time of previously scheduled [`setValueCurveAtTime`](/docs/core/audio-param#setvaluecurveattime) event and $D$ is its duration.

### Returns
`AudioParam`.
```

--------------------------------

### stretch.start / stretch.stop

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/react-native-audio-api/src/web-core/custom/signalsmithStretch/README.md

Starts or stops audio playback/processing. These are convenience methods that internally call `schedule`.

```APIDOC
## stretch.start(?when)

### Description
Starts playback or processing. Can be called with an optional time parameter to schedule the start.

### Parameters
- **when** (number, optional) - The time (in seconds) at which to start playback. Defaults to immediate.
```

```APIDOC
## stretch.stop(?when)

### Description
Stops playback or processing. Can be called with an optional time parameter to schedule the stop.

### Parameters
- **when** (number, optional) - The time (in seconds) at which to stop playback. Defaults to immediate.
```

--------------------------------

### Get FFT Size from AnalyserNode

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/ghdocs/audio-node.md

Retrieves the fftSize property from an AnalyserNode. This is a simple getter operation.

```typescript
const fftSize = analyserNode.fftSize;
```

```cpp
JSI_PROPERTY_GETTER_IMPL(AnalyserNodeHostObject, fftSize) {
  return {fftSize_};
}
```

--------------------------------

### setTargetAtTime

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/core/audio-param.mdx

Schedules a gradual change to a new value at a specified start time, useful for ADSR envelopes.

```APIDOC
## setTargetAtTime

### Description
Schedules a gradual change to the new value at the start time. This method is useful for decay or release portions of ADSR envelopes.

### Parameters
#### Path Parameters
- `target` (number) - Description: A float representing the value to which the `AudioParam` will start transitioning.
- `startTime` (number) - Description: The time, in seconds, at which exponential transition will begin. If it's smaller than `currentTime`, it will be clamped to `currentTime`.
- `timeConstant` (number) - Description: A double representing the time-constant value of an exponential approach to the `target`.

### Errors
- `RangeError`: `startTime` is negative number.
- `RangeError`: `timeConstant` is negative number.
- `NotSupportedError`: `startTime` falls within the interval $[T, T+D)$ where $T$ is the time of previously scheduled `setValueCurveAtTime` event and $D$ is its duration.

### Returns
`AudioParam`
```

--------------------------------

### AudioContext Constructor

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/core/audio-context.mdx

Initializes a new AudioContext instance. It accepts an options object to specify the sample rate.

```APIDOC
## new AudioContext(options: AudioContextOptions)

### Description
Initializes a new AudioContext instance. It accepts an options object to specify the sample rate.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **sampleRate** (number) - The desired sample rate for the audio context. Must be within the nominal range [8000, 96000].

### Errors
- `NotSupportedError`: Thrown if the provided `sampleRate` is outside the nominal range [8000, 96000].
```

--------------------------------

### Create AudioRecorder Instance

Source: https://github.com/software-mansion/react-native-audio-api/blob/main/packages/audiodocs/docs/inputs/audio-recorder.mdx

Instantiates the AudioRecorder. It's recommended to create only one instance for performance and resource management.

```typescript
import { AudioRecorder } from 'react-native-audio-api';

const audioRecorder = new AudioRecorder();
```