diff --git a/apps/common-app/src/examples/AudioTag/AudioTag.tsx b/apps/common-app/src/examples/AudioTag/AudioTag.tsx
index cea8d89df..99e4876cc 100644
--- a/apps/common-app/src/examples/AudioTag/AudioTag.tsx
+++ b/apps/common-app/src/examples/AudioTag/AudioTag.tsx
@@ -1,15 +1,26 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 import { Text, useWindowDimensions, View } from 'react-native';
 import {
   Audio,
   AudioTagHandle,
 } from 'react-native-audio-api/development/react';
-import { AudioContext, BiquadFilterNode, MediaElementAudioSourceNode } from 'react-native-audio-api';
+import {
+  AudioContext,
+  BiquadFilterNode,
+  MediaElementAudioSourceNode,
+} from 'react-native-audio-api';
 
 import { Button, Container, Slider, Spacer } from '../../components';
 
 // const DEMO_AUDIO_URL = 'https://filesamples.com/samples/audio/m4a/sample4.m4a';
-const DEMO_AUDIO_URL = 'https://filesamples.com/samples/audio/mp3/sample4.mp3';
+const DEMO_AUDIO_URL = 'https://liveradio.timesa.pl/2980-1.aac/playlist.m3u8';
+// const DEMO_AUDIO_URL = 'https://filesamples.com/samples/audio/mp3/sample4.mp3';
 
 const AudioTag: React.FC = () => {
   const { width: screenWidth } = useWindowDimensions();
@@ -27,7 +38,9 @@ const AudioTag: React.FC = () => {
     }
 
     const ctx = audioContextRef.current;
-    mediaElementSourceRef.current = ctx.createMediaElementSource(audioRef.current);
+    mediaElementSourceRef.current = ctx.createMediaElementSource(
+      audioRef.current
+    );
 
     biquadRef.current = ctx.createBiquadFilter();
     biquadRef.current.type = 'lowpass';
@@ -63,12 +76,9 @@ const AudioTag: React.FC = () => {
   const handleError = useCallback((error: Error) => {
     // console.log('onError', error);
   }, []);
-  const handlePositionChange = useCallback(
-    (seconds: number) => {
-      // console.log('onPositionChange', seconds);
-    },
-    []
-  );
+  const handlePositionChange = useCallback((seconds: number) => {
+    // console.log('onPositionChange', seconds);
+  }, []);
   const handleEnded = useCallback(() => {
     // console.log('onEnded');
   }, []);
@@ -78,12 +88,9 @@ const AudioTag: React.FC = () => {
   const handlePause = useCallback(() => {
     // console.log('onPause');
   }, []);
-  const handleVolumeEvent = useCallback(
-    (volume: number) => {
-      // console.log('onVolumeChange', volume);
-    },
-    []
-  );
+  const handleVolumeEvent = useCallback((volume: number) => {
+    // console.log('onVolumeChange', volume);
+  }, []);
 
   const audioTagElement = useMemo(
     () => (
diff --git a/apps/common-app/src/examples/Streaming/Streaming.tsx b/apps/common-app/src/examples/Streaming/Streaming.tsx
deleted file mode 100644
index ab0393004..000000000
--- a/apps/common-app/src/examples/Streaming/Streaming.tsx
+++ /dev/null
@@ -1,75 +0,0 @@
-import React, { FC, useEffect, useRef } from 'react';
-import { AudioContext, GainNode, StreamerNode } from 'react-native-audio-api';
-
-import { View } from 'react-native';
-import { Button, Container } from '../../components';
-
-const SAMPLE_RATE = 44100;
-
-const Streaming: FC = () => {
-  const streamerRef = useRef<StreamerNode | null>(null);
-  const aCtxRef = useRef<AudioContext | null>(null);
-  const gainRef = useRef<GainNode | null>(null);
-
-  useEffect(() => {
-    const actx = new AudioContext({ sampleRate: SAMPLE_RATE });
-    aCtxRef.current = actx;
-    gainRef.current = actx.createGain();
-    return () => {
-      aCtxRef.current?.close();
-      streamerRef.current?.stop();
-    };
-  }, []);
-
-  const startStreaming = () => {
-    if (!aCtxRef.current || !gainRef.current) {
-      console.error('AudioContext or gain or streamer is not initialized');
-      return;
-    }
-    if (streamerRef.current) {
-      console.error('StreamerNode is already initialized');
-      return;
-    }
-    streamerRef.current = aCtxRef.current.createStreamer('https://liveradio.timesa.pl/2980-1.aac/playlist.m3u8');
-
-    streamerRef.current.connect(gainRef.current);
-    gainRef.current.connect(aCtxRef.current.destination);
-    streamerRef.current.start(aCtxRef.current.currentTime);
-  };
-
-  const stopStreaming = () => {
-    if (streamerRef.current) {
-      streamerRef.current.stop(aCtxRef.current!.currentTime);
-      streamerRef.current = null;
-    } else {
-      console.error('StreamerNode is not initialized');
-    }
-  };
-
-  return (
-    <Container style={{ gap: 40 }}>
-      <View style={{ alignItems: 'center', justifyContent: 'center', gap: 5 }}>
-        <Button title="Start streaming" onPress={startStreaming} />
-        <Button title="Stop streaming" onPress={stopStreaming} />
-        <Button
-          title="Volume to 0.5"
-          onPress={() => {
-            if (gainRef.current) {
-              gainRef.current.gain.value = 0.5;
-            }
-          }}
-        />
-        <Button
-          title="Volume to 2.0"
-          onPress={() => {
-            if (gainRef.current) {
-              gainRef.current.gain.value = 2.0;
-            }
-          }}
-        />
-      </View>
-    </Container>
-  );
-};
-
-export default Streaming;
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index 43e84a390..d664f93b1 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -10,7 +10,6 @@ import Oscillator from './Oscillator';
 import Piano from './Piano';
 import PlaybackSpeed from './PlaybackSpeed';
 import Record from './Record/Record';
-import Streaming from './Streaming/Streaming';
 import Worklets from './Worklets/Worklets';
 import AudioStream from './AudioTag/AudioTag';
 import ConvolverIR from './ConvolverIR';
@@ -28,7 +27,6 @@ type NavigationParamList = {
   OfflineRendering: undefined;
   Record: undefined;
   Worklets: undefined;
-  Streamer: undefined;
   AudioTag: undefined;
   ConvolverIR: undefined;
   AudioParamPipeline: undefined;
@@ -111,12 +109,6 @@ export const Examples: Example[] = [
     Icon: icons.Code,
     screen: Worklets,
   },
-  {
-    key: 'Streamer',
-    title: 'Streamer',
-    Icon: icons.Radio,
-    screen: Streaming,
-  },
   {
     key: 'AudioTag',
     title: 'Audio Tag',
diff --git a/apps/fabric-example/ios/FabricExample.xcodeproj/xcshareddata/xcschemes/FabricExample.xcscheme b/apps/fabric-example/ios/FabricExample.xcodeproj/xcshareddata/xcschemes/FabricExample.xcscheme
index ed42faf3d..dbaf06593 100644
--- a/apps/fabric-example/ios/FabricExample.xcodeproj/xcshareddata/xcschemes/FabricExample.xcscheme
+++ b/apps/fabric-example/ios/FabricExample.xcodeproj/xcshareddata/xcschemes/FabricExample.xcscheme
@@ -24,10 +24,10 @@
    </BuildAction>
    <TestAction
       buildConfiguration = "Debug"
-      codeCoverageEnabled = "YES"
       selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
       selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
-      shouldUseLaunchSchemeArgsEnv = "YES">
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      codeCoverageEnabled = "YES">
       <Testables>
          <TestableReference
             skipped = "NO">
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 74a47ec25..45288eaca 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2476,7 +2476,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: c00c20551d40126351a6783c47ce75f5b374851b
-  hermes-engine: 91023181d4bc5948b457de5314623fbfe4f8604e
+  hermes-engine: 146211e12d60a1951d9eb0287be07211e86cf5d5
   RCTDeprecation: 3bb167081b134461cfeb875ff7ae1945f8635257
   RCTRequired: 74839f55d5058a133a0bc4569b0afec750957f64
   RCTSwiftUI: 87a316382f3eab4dd13d2a0d0fd2adcce917361a
@@ -2485,7 +2485,7 @@ SPEC CHECKSUMS:
   React: 1b1536b9099195944034e65b1830f463caaa8390
   React-callinvoker: 6dff6d17d1d6cc8fdf85468a649bafed473c65f5
   React-Core: 00faa4d038298089a1d5a5b21dde8660c4f0820d
-  React-Core-prebuilt: a6d614de037caff7898424dfc22915ec792de921
+  React-Core-prebuilt: ef40616103ee11f8c2517697c3aa4f48ce790549
   React-CoreModules: a17807f849bfd86045b0b9a75ec8c19373b482f6
   React-cxxreact: c7b53ace5827be54048288bce5c55f337c41e95f
   React-debug: e1f00fcd2cef58a2897471a6d76a4ef5f5f90c74
@@ -2549,7 +2549,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: 5787b37b8e2e51dfeab697ec031cc7c4080dcea2
   ReactCodegen: d07ee3c8db75b43d1cbe479ae6affebf9925c733
   ReactCommon: fe2a3af8975e63efa60f95fca8c34dc85deee360
-  ReactNativeDependencies: 4d5ce2683b6d74f7c686bf90a88c7d381295cf3c
+  ReactNativeDependencies: 54189f1570b1308686cb21564e755e1daa77ea03
   RNAudioAPI: 6668f71bdd9850005984acf39a3daef4935cec02
   RNGestureHandler: 187c5c7936abf427bc4d22d6c3b1ac80ad1f63c0
   RNReanimated: 64f4b3b33b48b19e0ba76a352571b52b1e931981
diff --git a/packages/audiodocs/docs/sources/streamer-node.mdx b/packages/audiodocs/docs/sources/streamer-node.mdx
index 22ea4d658..7bdd990d7 100644
--- a/packages/audiodocs/docs/sources/streamer-node.mdx
+++ b/packages/audiodocs/docs/sources/streamer-node.mdx
@@ -7,6 +7,10 @@ import { Optional, ReadOnly } from '@site/src/components/Badges';
 
 # StreamerNode
 
+:::danger
+Deprecated. Use the [`<Audio>`](/docs/experimental/audio-tag) element with [`MediaElementAudioSourceNode`](/docs/sources/media-element-audio-source-node) for streaming audio instead to achieve the same functionality.
+:::
+
 :::caution
 Mobile only.
 :::
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
index da00fb75b..4b32c20b6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.cpp
@@ -1,11 +1,11 @@
 #include <audioapi/HostObjects/sources/AudioFileSourceNodeHostObject.h>
 
+#include <audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h>
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioFileSourceNode.h>
 #include <audioapi/types/NodeOptions.h>
 #include <memory>
 #include <utility>
-#include "audioapi/HostObjects/sources/AudioScheduledSourceNodeHostObject.h"
 
 namespace audioapi {
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h
index 0d83725a6..7927352f7 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/utils/NodeOptionsParser.h
@@ -3,6 +3,7 @@
 #include <audioapi/jsi/RuntimeLifecycleMonitor.h>
 #include <jsi/jsi.h>
 #include <cstddef>
+#include <cstdio>
 #include <memory>
 #include <vector>
 
@@ -297,7 +298,7 @@ inline AudioFileSourceOptions parseAudioFileSourceOptions(
 
   auto loopValue = optionsObject.getProperty(runtime, "loop");
   if (loopValue.isBool()) {
-    options.loop = static_cast<bool>(loopValue.getBool());
+    options.loop = loopValue.getBool();
   }
 
   auto volumeValue = optionsObject.getProperty(runtime, "volume");
@@ -309,7 +310,7 @@ inline AudioFileSourceOptions parseAudioFileSourceOptions(
   if (sourceValue.isString()) {
     options.filePath = sourceValue.asString(runtime).utf8(runtime);
     options.requiresFFmpeg =
-        audiodecoding::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac"});
+        audiodecoding::pathHasExtension(options.filePath, {".mp4", ".m4a", ".aac", ".m3u8"});
   } else if (sourceValue.isObject()) {
     auto sourceObj = sourceValue.asObject(runtime);
     if (sourceObj.isArrayBuffer(runtime)) {
@@ -317,12 +318,21 @@ inline AudioFileSourceOptions parseAudioFileSourceOptions(
       auto *data = arrayBuffer.data(runtime);
       auto size = arrayBuffer.size(runtime);
       auto format = audiodecoding::detectAudioFormat(data, size);
-      options.requiresFFmpeg =
-          format == AudioFormat::MP4 || format == AudioFormat::M4A || format == AudioFormat::AAC;
+      options.requiresFFmpeg = format == AudioFormat::MP4 || format == AudioFormat::M4A ||
+          format == AudioFormat::AAC || format == AudioFormat::M3U8;
       options.data = std::vector<uint8_t>(data, data + size);
     }
   }
 
+#if RN_AUDIO_API_FFMPEG_DISABLED
+  if (options.requiresFFmpeg) {
+    throw jsi::JSError(
+        runtime,
+        "AudioFileSourceNode: source format (.mp4, .m4a, .aac, .m3u8) requires FFmpeg, "
+        "which is disabled in this build.");
+  }
+#endif
+
   return options;
 }
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
index e9516aeba..710bb1a34 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/AudioContext.cpp
@@ -104,6 +104,10 @@ bool AudioContext::isDriverRunning() const {
 std::shared_ptr<MediaElementAudioSourceNode> AudioContext::createMediaElementSource(
     const std::shared_ptr<AudioFileSourceNode> &fileSource) {
 
+  if (fileSource->isRoutedThroughMediaElement()) {
+    return nullptr;
+  }
+
   auto mediaElementSource = std::make_shared<MediaElementAudioSourceNode>(
       shared_from_this(),
       fileSource,
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
index 5962765f7..148b1259a 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.cpp
@@ -9,9 +9,14 @@
 
 #include <audioapi/core/AudioContext.h>
 
+#include <audioapi/core/utils/decoding/SeekDecoderDaemon.h>
+#include <audioapi/utils/SpscChannel.hpp>
 #include <algorithm>
+#include <atomic>
 #include <cassert>
+#include <cstddef>
 #include <memory>
+#include <utility>
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
@@ -23,39 +28,84 @@ AudioFileSourceNode::AudioFileSourceNode(
     const std::shared_ptr<BaseAudioContext> &context,
     const AudioFileSourceOptions &options)
     : AudioScheduledSourceNode(context, options),
+      decoderState_(std::make_shared<AudioFileDecoderState>()),
       volume_(options.volume),
-      requiresFFmpeg_(options.requiresFFmpeg),
       loop_(options.loop),
       onPositionChangedInterval_(
           static_cast<int>(context->getSampleRate() * ON_POSITION_CHANGED_INTERVAL)) {
   const bool useFilePath = !options.filePath.empty();
   const bool useData = !options.data.empty();
 
-  if (useFilePath || useData) {
-    auto state = std::make_shared<AudioFileDecoderState>();
-    if (useData) {
-      state->memoryData = options.data;
-    }
-    if (useFilePath) {
-      state->filePath = options.filePath;
-    }
-    initDecoders(useFilePath, context, state);
+  if (!useFilePath && !useData) {
+    assert(false && "AudioFileSourceNode requires either a file path or memory data to initialize");
+    return;
   }
 
-  if (decoderState_ == nullptr) {
-    assert(false && "cannot initialize decoder");
+  if (!initDecoder(context, options)) {
     return;
   }
 
-  seekOffloader_ = std::make_unique<task_offloader::TaskOffloader<
-      OffloadedSeekRequest,
-      spsc::OverflowStrategy::OVERWRITE_ON_FULL,
-      spsc::WaitStrategy::ATOMIC_WAIT>>(
-      SEEK_OFFLOADER_WORKER_COUNT, [this](OffloadedSeekRequest req) { runOffloadedSeekTask(req); });
-
   isInitialized_.store(true, std::memory_order_release);
 }
 
+AudioFileSourceNode::~AudioFileSourceNode() {
+  // AudioNode::~AudioNode() -> cleanup() does not call the virtual disable(),
+  // so the daemon thread is not guaranteed to have been joined yet. A still
+  // joinable std::thread would call std::terminate() on destruction.
+  stopDaemonThread();
+}
+
+void AudioFileSourceNode::stopDaemonThread() {
+  decoderState_->isDaemonRunning.store(false, std::memory_order_release);
+  // Send a dummy command to unblock the daemon thread if it's waiting.
+  // The command channel uses OVERWRITE_ON_FULL, so this never blocks.
+  commandSender_.send(SeekRequest{0});
+  if (seekDecoderThread_.joinable()) {
+    seekDecoderThread_.join();
+  }
+}
+
+bool AudioFileSourceNode::initDecoder(
+    const std::shared_ptr<BaseAudioContext> &context,
+    const AudioFileSourceOptions &options) {
+  auto [frameSender, frameReceiver] =
+      channels::spsc::channel<DecoderData, FRAME_OVERFLOW_STRATEGY, FRAME_WAIT_STRATEGY>(
+          FRAME_CHANNEL_CAPACITY);
+  frameReceiver_ = std::make_shared<FrameReceiver>(std::move(frameReceiver));
+
+  auto [commandSender, commandReceiver] =
+      channels::spsc::channel<SeekRequest, COMMAND_OVERFLOW_STRATEGY, COMMAND_WAIT_STRATEGY>(
+          COMMAND_CHANNEL_CAPACITY);
+  commandSender_ = std::move(commandSender);
+
+  SeekDecoderDaemonOptions daemonOptions{
+      .requiresFFmpeg = options.requiresFFmpeg,
+      .filePath = options.filePath,
+      .memoryData = options.data,
+      .contextSampleRate = context->getSampleRate(),
+      .loop = options.loop};
+
+  seekDecoderDaemon_ = std::make_unique<SeekDecoderDaemon>(
+      daemonOptions,
+      decoderState_,
+      std::move(commandReceiver),
+      std::move(frameSender),
+      frameReceiver_);
+
+  if (!decoderState_->isReady.load(std::memory_order_acquire)) {
+    return false;
+  }
+
+  channelCount_ = decoderState_->channelCount;
+  sampleRate_ = decoderState_->sampleRate;
+  duration_ = decoderState_->duration;
+
+  audioBuffer_ = std::make_shared<DSPAudioBuffer>(
+      static_cast<size_t>(RENDER_QUANTUM_SIZE), channelCount_, context->getSampleRate());
+
+  return true;
+}
+
 void AudioFileSourceNode::setOnPositionChangedCallbackId(uint64_t callbackId) {
   onPositionChangedCallbackId_ = callbackId;
 }
@@ -65,57 +115,33 @@ void AudioFileSourceNode::unregisterOnPositionChangedCallback(uint64_t callbackI
 }
 
 void AudioFileSourceNode::sendOnPositionChangedEvent(int framesPlayed) {
-  currentTime_.fetch_add(framesPlayed / sampleRate_);
+  const bool flush = decoderState_->onPositionChangedFlush.load(std::memory_order_acquire);
+
+  if (flush && !audioThreadSetFlush_) {
+    // Daemon completed a seek or loop-back - sync audio thread's position to decoder's actual position
+    currentTime_.store(
+        decoderState_->currentTime.load(std::memory_order_acquire) +
+            static_cast<double>(framesPlayed) / sampleRate_,
+        std::memory_order_release);
+  } else {
+    currentTime_.fetch_add(static_cast<double>(framesPlayed) / sampleRate_);
+  }
+
   if (onPositionChangedCallbackId_ != 0 &&
-      (onPositionChangedFlush_.load(std::memory_order_acquire) ||
-       onPositionChangedTime_ > onPositionChangedInterval_)) {
+      (flush || onPositionChangedTime_ > onPositionChangedInterval_)) {
     audioEventHandlerRegistry_->dispatchEvent(
         AudioEvent::POSITION_CHANGED,
         onPositionChangedCallbackId_,
         DoubleValuePayload{.value = getCurrentTime()});
 
     onPositionChangedTime_ = 0;
-    onPositionChangedFlush_.store(false, std::memory_order_release);
+    audioThreadSetFlush_ = false;
+    decoderState_->onPositionChangedFlush.store(false, std::memory_order_release);
   }
 
   onPositionChangedTime_ += framesPlayed;
 }
 
-void AudioFileSourceNode::initDecoders(
-    bool useFilePath,
-    const std::shared_ptr<BaseAudioContext> &context,
-    const std::shared_ptr<AudioFileDecoderState> &state) {
-  decoding::DecoderResult openResult = Ok(None);
-  if (requiresFFmpeg_) {
-#if !RN_AUDIO_API_FFMPEG_DISABLED
-    decoder_ = std::make_unique<ffmpeg_decoder::FFmpegDecoder>();
-#endif // RN_AUDIO_API_FFMPEG_DISABLED
-  } else {
-    decoder_ = std::make_unique<miniaudio_decoder::MiniAudioDecoder>();
-  }
-  if (useFilePath) {
-    openResult = decoder_->openFile(static_cast<int>(context->getSampleRate()), state->filePath);
-  } else {
-    openResult = decoder_->openMemory(
-        static_cast<int>(context->getSampleRate()),
-        state->memoryData.data(),
-        state->memoryData.size());
-  }
-  if (openResult.is_ok()) {
-    state->channels = decoder_->outputChannels();
-    state->sampleRate = static_cast<float>(decoder_->outputSampleRate());
-    duration_ = static_cast<double>(decoder_->getDurationInSeconds());
-  } else {
-    decoder_->close();
-  }
-  state->interleavedBuffer.resize(static_cast<size_t>(RENDER_QUANTUM_SIZE) * state->channels);
-  decoderState_ = state;
-  channelCount_ = decoderState_->channels;
-  sampleRate_ = decoderState_->sampleRate;
-  audioBuffer_ = std::make_shared<DSPAudioBuffer>(
-      static_cast<size_t>(RENDER_QUANTUM_SIZE), channelCount_, context->getSampleRate());
-}
-
 void AudioFileSourceNode::connect(const std::shared_ptr<AudioNode> &node) {
   if (isRoutedThroughMediaElement()) {
     return;
@@ -133,6 +159,11 @@ void AudioFileSourceNode::start(double when) {
 
   AudioScheduledSourceNode::start(when);
   filePaused_ = false;
+
+  if (seekDecoderDaemon_) {
+    seekDecoderThread_ = std::thread(std::move(*seekDecoderDaemon_));
+    seekDecoderDaemon_.reset();
+  }
 }
 
 void AudioFileSourceNode::bindMediaElementSource(uint64_t bindingId) {
@@ -172,35 +203,10 @@ void AudioFileSourceNode::pause() {
 }
 
 void AudioFileSourceNode::disable() {
-  seekOffloader_.reset();
+  stopDaemonThread();
   filePaused_ = false;
-  if (decoder_ != nullptr) {
-    decoder_->close();
-  }
-  AudioScheduledSourceNode::disable();
-}
-
-size_t AudioFileSourceNode::readFrames(float *buf, size_t frameCount) {
-  if (pendingOffloadedSeeks_.load(std::memory_order_acquire) > 0) {
-    return 0;
-  }
-  return decoder_->readPcmFrames(buf, frameCount);
-}
-
-void AudioFileSourceNode::applyPlaybackStateAfterSuccessfulSeek(double seconds) {
-  currentTime_.store(seconds, std::memory_order_release);
-  onPositionChangedFlush_.store(true, std::memory_order_release);
-}
 
-void AudioFileSourceNode::runOffloadedSeekTask(OffloadedSeekRequest req) {
-  if (decoderState_ == nullptr) {
-    pendingOffloadedSeeks_.fetch_sub(1, std::memory_order_acq_rel);
-    return;
-  }
-  if (decoder_->seekToTime(req.seconds).is_ok()) {
-    applyPlaybackStateAfterSuccessfulSeek(req.seconds);
-  }
-  pendingOffloadedSeeks_.fetch_sub(1, std::memory_order_acq_rel);
+  AudioScheduledSourceNode::disable();
 }
 
 void AudioFileSourceNode::seekToTime(double seconds) {
@@ -213,37 +219,31 @@ void AudioFileSourceNode::seekToTime(double seconds) {
   } else {
     seconds = std::max(0.0, seconds);
   }
-  pendingOffloadedSeeks_.fetch_add(1, std::memory_order_acq_rel);
-  seekOffloader_->getSender()->send(OffloadedSeekRequest{seconds});
+  decoderState_->pendingOffloadedSeeks.fetch_add(1, std::memory_order_acq_rel);
+  commandSender_.send(SeekRequest{seconds});
 }
 
-size_t AudioFileSourceNode::handleEof(
-    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-    size_t regionFrames,
-    size_t framesRead,
-    size_t destFrameOffset) {
-  if (!loop_) {
-    return framesRead;
-  }
-
-  if (!decoder_->seekToTime(0).is_ok()) {
-    return framesRead;
+size_t AudioFileSourceNode::readInterleavedFrames(
+    const std::shared_ptr<DSPAudioBuffer> &destBuffer,
+    size_t framesToRead) {
+  if (decoderState_->pendingOffloadedSeeks.load(std::memory_order_acquire) > 0) {
+    return 0;
   }
 
-  const size_t toFill = regionFrames - framesRead;
-  if (toFill == 0) {
-    return framesRead;
-  }
+  // Read from the decoder daemon thread via the SPSC channel
+  DecoderData incoming;
+  if (frameReceiver_->try_receive(incoming) == ResponseStatus::SUCCESS) {
+    size_t framesToCopy = std::min(framesToRead, incoming.size);
+    destBuffer->deinterleaveFrom(incoming.interleavedBuffer.data(), framesToCopy);
 
-  auto &state = *decoderState_;
-  const size_t extra = readFrames(state.interleavedBuffer.data(), toFill);
+    if (volume_ != 1.0f && framesToCopy > 0) {
+      destBuffer->scale(volume_);
+    }
 
-  if (volume_ != 0.0f) {
-    processingBuffer->deinterleaveFrom(state.interleavedBuffer.data(), extra);
-    processingBuffer->scale(volume_);
+    return framesToCopy;
   }
 
-  return framesRead + extra;
+  return 0;
 }
 
 std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
@@ -259,7 +259,7 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processNode(
 std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processDecodedOutput(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     int framesToProcess) {
-  if (decoderState_ == nullptr || decoder_ == nullptr || !decoder_->isOpen() || filePaused_) {
+  if (decoderState_ == nullptr || filePaused_) {
     processingBuffer->zero();
     return processingBuffer;
   }
@@ -270,7 +270,7 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processDecodedOutput(
     return processingBuffer;
   }
 
-  if (pendingOffloadedSeeks_.load(std::memory_order_acquire) > 0) {
+  if (decoderState_->pendingOffloadedSeeks.load(std::memory_order_acquire) > 0) {
     processingBuffer->zero();
     return processingBuffer;
   }
@@ -290,31 +290,29 @@ std::shared_ptr<DSPAudioBuffer> AudioFileSourceNode::processDecodedOutput(
     return processingBuffer;
   }
 
-  auto &state = *decoderState_;
+  if (startOffset > 0) {
+    processingBuffer->zero(0, startOffset);
+  }
 
-  size_t framesRead = readFrames(state.interleavedBuffer.data(), offsetLength);
+  size_t framesRead = readInterleavedFrames(processingBuffer, offsetLength);
   sendOnPositionChangedEvent(static_cast<int>(framesRead));
 
-  if (volume_ != 0.0f && framesRead > 0) {
-    processingBuffer->deinterleaveFrom(state.interleavedBuffer.data(), framesRead);
-    processingBuffer->scale(volume_);
-  }
-
+  // Handle End of Stream / End of File boundaries
   if (framesRead < offsetLength) {
-    if (!loop_) {
+    if (decoderState_->isEof.load(std::memory_order_acquire) &&
+        !decoderState_->loop.load(std::memory_order_acquire)) {
+
       currentTime_.store(duration_, std::memory_order_release);
-      onPositionChangedFlush_.store(true, std::memory_order_release);
+      audioThreadSetFlush_ = true;
+      decoderState_->onPositionChangedFlush.store(true, std::memory_order_release);
       sendOnPositionChangedEvent(static_cast<int>(offsetLength - framesRead));
+
       filePaused_ = true;
       playbackState_ = PlaybackState::STOP_SCHEDULED;
-      processingBuffer->zero(startOffset + framesRead, offsetLength - framesRead);
-    } else {
-      const size_t totalFilled = handleEof(processingBuffer, offsetLength, framesRead, startOffset);
-      onPositionChangedFlush_.store(true, std::memory_order_release);
-      currentTime_.store(0, std::memory_order_release);
-      sendOnPositionChangedEvent(static_cast<int>(totalFilled));
-      processingBuffer->zero(startOffset + totalFilled, offsetLength - totalFilled);
     }
+
+    // fill the rest of the buffer with silence
+    processingBuffer->zero(startOffset + framesRead, offsetLength - framesRead);
   }
 
   if (isStopScheduled()) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
index e2cf2a622..d0a998888 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioFileSourceNode.h
@@ -2,18 +2,18 @@
 
 #include <audioapi/core/AudioNode.h>
 #include <audioapi/core/sources/AudioScheduledSourceNode.h>
+#include <audioapi/core/utils/decoding/SeekDecoderDaemon.h>
 #include <audioapi/libs/decoding/IncrementalAudioDecoder.h>
+#include <cstddef>
+#include <thread>
 #if !RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
 #endif // RN_AUDIO_API_FFMPEG_DISABLED
 #include <audioapi/libs/miniaudio/MiniAudioDecoding.h>
-#include <audioapi/utils/TaskOffloader.hpp>
 
 #include <atomic>
 #include <cstdint>
 #include <memory>
-#include <string>
-#include <vector>
 
 using namespace audioapi::channels;
 
@@ -22,24 +22,12 @@ namespace audioapi {
 struct AudioFileSourceOptions;
 class MediaElementAudioSourceNode;
 
-/// @brief Target time for an offloaded seek task.
-struct OffloadedSeekRequest {
-  double seconds = 0;
-  OffloadedSeekRequest() = default;
-  explicit OffloadedSeekRequest(double t) : seconds(t) {}
-};
-
-/// @brief Decoder input and scratch buffer shared by the file source and media-element routing.
-struct AudioFileDecoderState {
-  std::vector<uint8_t> memoryData;
-  std::string filePath;
-  std::vector<float> interleavedBuffer;
-  int channels = 0;
-  float sampleRate = 0;
-};
+inline constexpr auto ON_POSITION_CHANGED_INTERVAL = 0.25f;
 
 /// @brief Decodes a file or in-memory buffer and plays it as a scheduled source.
 /// @note When routed through MediaElementAudioSourceNode, this node outputs silence and the media node pulls decoded audio.
+/// @note Seek commands are executed from the JS thread and delegated to @ref SeekDecoderDaemon, which performs the seek and decoding on a worker thread,
+// then sends decoded frames back to the audio thread via SPSC channels.
 class AudioFileSourceNode : public AudioScheduledSourceNode {
   friend class MediaElementAudioSourceNode;
 
@@ -47,7 +35,7 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
   explicit AudioFileSourceNode(
       const std::shared_ptr<BaseAudioContext> &context,
       const AudioFileSourceOptions &options);
-  ~AudioFileSourceNode() override = default;
+  ~AudioFileSourceNode() override;
   DELETE_COPY_AND_MOVE(AudioFileSourceNode);
 
   /// @brief Closes the decoder and tears down offloaded seek workers.
@@ -91,6 +79,7 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
   /// @brief Enables looping at end-of-file.
   void setLoop(bool v) {
     loop_ = v;
+    decoderState_->loop.store(v, std::memory_order_release);
   }
 
   /// @brief File duration in seconds (zero if unknown).
@@ -118,55 +107,43 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
       int framesToProcess) override;
 
  private:
+  std::shared_ptr<AudioFileDecoderState> decoderState_;
   /// @brief Decodes and mixes samples for direct or media-element playback.
   /// @note Audio thread only.
   std::shared_ptr<DSPAudioBuffer> processDecodedOutput(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       int framesToProcess);
 
-  /// @brief Opens the decoder from file path or memory and prepares scratch buffers.
-  void initDecoders(
-      bool useFilePath,
-      const std::shared_ptr<BaseAudioContext> &context,
-      const std::shared_ptr<AudioFileDecoderState> &state);
-
-  std::shared_ptr<AudioFileDecoderState> decoderState_;
-  std::unique_ptr<decoding::IncrementalAudioDecoder> decoder_;
-
   float volume_;
-  bool requiresFFmpeg_;
   bool filePaused_{false};
   bool loop_{false};
   double duration_{0};
   double sampleRate_{0};
-
-  std::atomic<uint64_t> activeMediaBindingId_{0};
   std::atomic<double> currentTime_{0};
-
-  static constexpr double ON_POSITION_CHANGED_INTERVAL = 0.25f;
-  static constexpr int SEEK_OFFLOADER_WORKER_COUNT = 16;
-
-  /// @brief Reads up to @p frameCount interleaved PCM frames into @p buf.
-  /// @note Audio thread only.
-  size_t readFrames(float *buf, size_t frameCount);
-
-  /// @brief Fills the remainder of a region after EOF, seeking to start when looping.
-  /// @note Audio thread only.
-  size_t handleEof(
-      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
-      size_t regionFrames,
-      size_t framesRead,
-      size_t destFrameOffset);
+  std::atomic<uint64_t> activeMediaBindingId_{0};
 
   /// @brief Dispatches position-changed events at the configured interval.
   /// @note Audio thread only.
   void sendOnPositionChangedEvent(int framesPlayed);
 
-  /// @brief Updates playback clock after a successful offloaded seek.
-  void applyPlaybackStateAfterSuccessfulSeek(double seconds);
+  /// @brief Sets up SPSC channels, constructs the SeekDecoderDaemon, and initialises metadata from the opened decoder.
+  /// @return false if the source could not be opened; caller must not set isInitialized_.
+  [[nodiscard]] bool initDecoder(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioFileSourceOptions &options);
+
+  /// @brief Reads decoded interleaved frames from the SPSC channel, deinterleaves them into @p destBuffer, and applies volume.
+  [[nodiscard]] size_t readInterleavedFrames(
+      const std::shared_ptr<DSPAudioBuffer> &destBuffer,
+      size_t framesToRead);
+
+  /// @brief Daemon thread for decoding and seeking
+  std::unique_ptr<SeekDecoderDaemon> seekDecoderDaemon_;
+  std::thread seekDecoderThread_;
 
-  /// @brief Worker-thread seek implementation.
-  void runOffloadedSeekTask(OffloadedSeekRequest req);
+  /// @brief Signals the daemon to stop and joins its thread. Idempotent; safe
+  /// to call from both disable() and the destructor.
+  void stopDaemonThread();
 
   /// @brief Connects to the destination when leaving media routing while playback is active.
   /// @note Audio thread only.
@@ -175,16 +152,15 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
   uint64_t onPositionChangedCallbackId_ = 0;
   int onPositionChangedInterval_;
   int onPositionChangedTime_ = 0;
-  std::atomic<bool> onPositionChangedFlush_{true};
+  // True when the audio thread itself wrote onPositionChangedFlush (e.g. EOF),
+  // so sendOnPositionChangedEvent knows not to sync currentTime_ from the daemon.
+  bool audioThreadSetFlush_{false};
 
-  /// Pending offloaded seeks; while > 0 the audio thread must not read the decoder (outputs silence).
-  std::atomic<int> pendingOffloadedSeeks_{0};
+  /// @brief SPSC for JS -> Daemon thread communication (seek event)
+  CommandSender commandSender_;
 
-  std::unique_ptr<task_offloader::TaskOffloader<
-      OffloadedSeekRequest,
-      spsc::OverflowStrategy::OVERWRITE_ON_FULL,
-      spsc::WaitStrategy::ATOMIC_WAIT>>
-      seekOffloader_;
+  /// @brief SPSC for Daemon thread -> Audio thread communication (decoded frames)
+  std::shared_ptr<FrameReceiver> frameReceiver_;
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h
index c881e6843..1f64b134c 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/StreamerNode.h
@@ -71,6 +71,8 @@ namespace audioapi {
 
 struct StreamerOptions;
 
+[[deprecated(
+    "StreamerNode is legacy and will be removed. Use AudioFileSourceNode via the <Audio> component instead.")]];
 class StreamerNode : public AudioScheduledSourceNode {
  public:
   explicit StreamerNode(
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/types/AudioFormat.h b/packages/react-native-audio-api/common/cpp/audioapi/core/types/AudioFormat.h
index 74fd4f9d1..f13a26c8d 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/types/AudioFormat.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/types/AudioFormat.h
@@ -4,5 +4,5 @@
 
 namespace audioapi {
 
-enum class AudioFormat : uint8_t { UNKNOWN, WAV, OGG, FLAC, AAC, MP3, M4A, MP4, MOV };
+enum class AudioFormat : uint8_t { UNKNOWN, WAV, OGG, FLAC, AAC, MP3, M4A, MP4, MOV, M3U8 };
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/decoding/SeekDecoderDaemon.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/decoding/SeekDecoderDaemon.cpp
new file mode 100644
index 000000000..3f9cad730
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/decoding/SeekDecoderDaemon.cpp
@@ -0,0 +1,135 @@
+#include <audioapi/core/utils/decoding/SeekDecoderDaemon.h>
+#include <memory>
+#include <utility>
+
+namespace audioapi {
+
+SeekDecoderDaemon::SeekDecoderDaemon(
+    SeekDecoderDaemonOptions options,
+    std::shared_ptr<AudioFileDecoderState> sharedState,
+    CommandReceiver commandReceiver,
+    FrameSender frameSender,
+    std::shared_ptr<FrameReceiver> frameReceiver)
+    : sharedState_(std::move(sharedState)),
+      commandReceiver_(std::move(commandReceiver)),
+      frameSender_(std::move(frameSender)),
+      frameReceiverForDrain_(std::move(frameReceiver)) {
+  if (options.requiresFFmpeg) {
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+    decoder_ = std::make_unique<ffmpeg_decoder::FFmpegDecoder>();
+#endif
+  } else {
+    decoder_ = std::make_unique<miniaudio_decoder::MiniAudioDecoder>();
+  }
+
+  decoding::DecoderResult openResult = Ok(None);
+
+  int contextSampleRate = static_cast<int>(options.contextSampleRate);
+  if (!options.filePath.empty()) {
+    openResult = decoder_->openFile(contextSampleRate, options.filePath);
+  } else if (!options.memoryData.empty()) {
+    openResult = decoder_->openMemory(
+        contextSampleRate, options.memoryData.data(), options.memoryData.size());
+  }
+
+  if (!openResult.is_ok()) {
+    decoder_->close();
+    sharedState_->isDaemonRunning.store(false, std::memory_order_release);
+    return;
+  }
+
+  sharedState_->channelCount.store(decoder_->outputChannels(), std::memory_order_release);
+  sharedState_->sampleRate.store(
+      static_cast<float>(decoder_->outputSampleRate()), std::memory_order_release);
+  sharedState_->duration.store(decoder_->getDurationInSeconds(), std::memory_order_release);
+  sharedState_->loop.store(options.loop, std::memory_order_release);
+  sharedState_->isReady.store(true, std::memory_order_release);
+}
+
+bool SeekDecoderDaemon::processSeekCommands() {
+  SeekRequest seekReq;
+  SeekRequest latestReq;
+  bool seekHappened = false;
+  int drainedCount = 0;
+
+  // Fast-drain the command SPSC pipe to grab ONLY the final target position
+  while (commandReceiver_.try_receive(seekReq) == ResponseStatus::SUCCESS) {
+    latestReq = seekReq;
+    seekHappened = true;
+    drainedCount++; // Track exactly how many commands we are skipping/consuming
+  }
+
+  if (!seekHappened) {
+    return false; // No seek commands to process
+  }
+
+  if (decoder_ && decoder_->isOpen()) {
+    if (decoder_->seekToTime(latestReq.seconds).is_ok()) {
+      sharedState_->currentTime.store(latestReq.seconds, std::memory_order_release);
+      sharedState_->onPositionChangedFlush.store(true, std::memory_order_release);
+    }
+  }
+
+  // Decrement the atomic gate by the total number of items pulled
+  sharedState_->pendingOffloadedSeeks.fetch_sub(drainedCount, std::memory_order_release);
+
+  // Drain stale pre-seek frames out of the pipe so old audio doesn't play
+  DecoderData drop;
+  while (frameReceiverForDrain_->try_receive(drop) == ResponseStatus::SUCCESS) {}
+
+  return true;
+}
+
+bool SeekDecoderDaemon::decodeNextChunk(DecoderData &data) {
+  if (!decoder_ || !decoder_->isOpen()) {
+    return false;
+  }
+
+  size_t framesRead = decoder_->readPcmFrames(data.interleavedBuffer.data(), RENDER_QUANTUM_SIZE);
+
+  if (framesRead == 0) {
+    if (sharedState_->loop.load(std::memory_order_acquire) && decoder_->seekToTime(0).is_ok()) {
+      sharedState_->currentTime.store(0.0, std::memory_order_release);
+      sharedState_->onPositionChangedFlush.store(true, std::memory_order_release);
+    } else {
+      sharedState_->isEof.store(true, std::memory_order_release);
+    }
+    return false;
+  }
+
+  sharedState_->isEof.store(false, std::memory_order_release);
+  data.size = framesRead;
+  return true;
+}
+
+void SeekDecoderDaemon::operator()() {
+  DecoderData localData;
+  bool hasPendingChunk = false;
+
+  while (sharedState_->isDaemonRunning.load(std::memory_order_acquire)) {
+    if (processSeekCommands()) {
+      hasPendingChunk = false;
+      continue;
+    }
+
+    if (!hasPendingChunk) {
+      hasPendingChunk = decodeNextChunk(localData);
+    }
+
+    if (!hasPendingChunk) {
+      continue;
+    }
+
+    if (frameSender_.try_send(localData) == ResponseStatus::SUCCESS) {
+      hasPendingChunk = false;
+    } else {
+      std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_DURATION_ON_FULL));
+    }
+  }
+
+  if (decoder_) {
+    decoder_->close();
+  }
+}
+
+} // namespace audioapi
\ No newline at end of file
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/utils/decoding/SeekDecoderDaemon.h b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/decoding/SeekDecoderDaemon.h
new file mode 100644
index 000000000..06583cd13
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/utils/decoding/SeekDecoderDaemon.h
@@ -0,0 +1,117 @@
+#pragma once
+
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/libs/decoding/IncrementalAudioDecoder.h>
+#if !RN_AUDIO_API_FFMPEG_DISABLED
+#include <audioapi/libs/ffmpeg/FFmpegDecoding.h>
+#endif // RN_AUDIO_API_FFMPEG_DISABLED
+#include <audioapi/libs/miniaudio/MiniAudioDecoding.h>
+#include <audioapi/utils/SpscChannel.hpp>
+#include <array>
+#include <memory>
+#include <string>
+#include <vector>
+
+using namespace audioapi::channels::spsc;
+
+struct SeekDecoderDaemonOptions {
+  bool requiresFFmpeg;
+  // source
+  std::string filePath;
+  std::vector<uint8_t> memoryData;
+  // playback
+  float contextSampleRate;
+  bool loop;
+};
+
+struct AudioFileDecoderState {
+  // Lifecycle and Sync
+  std::atomic<bool> isDaemonRunning{true};
+  std::atomic<bool> isReady{false}; // True once the decoder opens the file/URL
+  std::atomic<int> pendingOffloadedSeeks{0};
+  std::atomic<bool> isEof{false};
+  std::atomic<bool> onPositionChangedFlush{false};
+
+  // Metadata
+  std::atomic<int> channelCount{0};
+  std::atomic<float> sampleRate{0.0f};
+  std::atomic<double> duration{0.0};
+
+  // Playback state
+  std::atomic<double> currentTime{0.0};
+  std::atomic<bool> loop{false};
+};
+
+struct SeekRequest {
+  double seconds = 0;
+  SeekRequest() = default;
+  explicit SeekRequest(double t) : seconds(t) {}
+};
+
+struct DecoderData {
+  std::array<
+      float,
+      static_cast<size_t>(audioapi::RENDER_QUANTUM_SIZE) *
+          static_cast<size_t>(audioapi::MAX_CHANNEL_COUNT)>
+      interleavedBuffer{};
+  size_t size{};
+};
+
+inline constexpr auto COMMAND_OVERFLOW_STRATEGY = OverflowStrategy::OVERWRITE_ON_FULL;
+inline constexpr auto COMMAND_WAIT_STRATEGY = WaitStrategy::ATOMIC_WAIT;
+inline constexpr auto COMMAND_CHANNEL_CAPACITY = 16;
+
+using CommandSender = Sender<SeekRequest, COMMAND_OVERFLOW_STRATEGY, COMMAND_WAIT_STRATEGY>;
+using CommandReceiver = Receiver<SeekRequest, COMMAND_OVERFLOW_STRATEGY, COMMAND_WAIT_STRATEGY>;
+
+inline constexpr auto FRAME_OVERFLOW_STRATEGY = OverflowStrategy::WAIT_ON_FULL;
+inline constexpr auto FRAME_WAIT_STRATEGY = WaitStrategy::ATOMIC_WAIT;
+inline constexpr auto FRAME_CHANNEL_CAPACITY = 64;
+
+using FrameSender = Sender<DecoderData, FRAME_OVERFLOW_STRATEGY, FRAME_WAIT_STRATEGY>;
+using FrameReceiver = Receiver<DecoderData, FRAME_OVERFLOW_STRATEGY, FRAME_WAIT_STRATEGY>;
+
+inline constexpr auto SLEEP_DURATION_ON_FULL = std::chrono::milliseconds(10);
+
+namespace audioapi {
+
+/// @brief SeekDecoderDaemon is a dedicated thread worker that manages an audio decoder instance (FFmpeg or MiniAudio).
+/// It listens for seek commands from the JS thread, performs seeks on the decoder,
+/// decodes audio frames, and sends decoded planar audio data back to the audio thread via a lock-free SPSC channel.
+class SeekDecoderDaemon {
+ public:
+  SeekDecoderDaemon(
+      SeekDecoderDaemonOptions options,
+      std::shared_ptr<AudioFileDecoderState> sharedState,
+      CommandReceiver commandReceiver,
+      FrameSender frameSender,
+      std::shared_ptr<FrameReceiver> frameReceiver);
+
+  /// @brief Main loop of the daemon thread. Listens for seek commands,
+  /// decodes audio frames, and sends decoded data back to the audio thread
+  /// via the frameSender SPSC channel.
+  void operator()();
+
+ private:
+  std::unique_ptr<decoding::IncrementalAudioDecoder> decoder_;
+
+  /// @brief Shared state with the AudioFileSourceNode, used for communicating decoder status, metadata, and playback position.
+  std::shared_ptr<AudioFileDecoderState> sharedState_;
+  /// @brief Receiving end of seek commands from the JS thread
+  CommandReceiver commandReceiver_;
+  /// @brief Sending end for decoded audio frames back to the audio thread
+  FrameSender frameSender_;
+  /// @brief Pointer to the audio thread's receiver — used only during seek to drain stale frames.
+  /// Safe because the daemon thread is joined before AudioFileSourceNode is destroyed.
+  std::shared_ptr<FrameReceiver> frameReceiverForDrain_;
+
+  /// @brief Drains the command queue and performs all pending seeks.
+  /// @return true if at least one seek command was processed.
+  bool processSeekCommands();
+
+  /// @brief Reads one quantum of frames from the decoder into @p data, handling EOF and loop-back.
+  /// @return true if @p data is filled and ready to send; false if the decoder stalled or looped.
+  bool decodeNextChunk(DecoderData &data);
+};
+
+} // namespace audioapi
\ No newline at end of file
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/decoding/IncrementalAudioDecoder.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/decoding/IncrementalAudioDecoder.h
index cf4550646..552f0f300 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/decoding/IncrementalAudioDecoder.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/decoding/IncrementalAudioDecoder.h
@@ -1,8 +1,9 @@
 #pragma once
+
+#include <audioapi/utils/Macros.h>
+#include <audioapi/utils/Result.hpp>
 #include <cstddef>
 #include <string>
-#include <audioapi/utils/Result.hpp>
-#include <audioapi/utils/Macros.h>
 
 namespace audioapi::decoding {
 using DecoderResult = Result<NoneType, std::string>;
@@ -21,19 +22,15 @@ class IncrementalAudioDecoder {
   /// @param outputSampleRate The output sample rate.
   /// @param path The path to the file.
   /// @return Ok(None) on success or Err(message) on failure.
-  [[nodiscard]] virtual DecoderResult openFile(
-      int outputSampleRate,
-      const std::string &path) = 0;
+  [[nodiscard]] virtual DecoderResult openFile(int outputSampleRate, const std::string &path) = 0;
 
   /// @brief Opens a memory block for decoding.
   /// @param outputSampleRate The output sample rate.
   /// @param data The data to decode.
   /// @param size The size of the data.
   /// @return Ok(None) on success or Err(message) on failure.
-  [[nodiscard]] virtual DecoderResult openMemory(
-      int outputSampleRate,
-      const void *data,
-      size_t size) = 0;
+  [[nodiscard]] virtual DecoderResult
+  openMemory(int outputSampleRate, const void *data, size_t size) = 0;
 
   /// @brief Reads PCM frames from the decoder.
   /// @param outInterleaved The output buffer for the decoded frames.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
index e66517043..6a411deb6 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.cpp
@@ -79,10 +79,8 @@ int findAudioStreamIndex(AVFormatContext *fmt_ctx) {
   return -1;
 }
 
-decoding::DecoderResult openCodec(
-    AVFormatContext *fmt_ctx,
-    int &audio_stream_index,
-    AVCodecContext **out_codec) {
+decoding::DecoderResult
+openCodec(AVFormatContext *fmt_ctx, int &audio_stream_index, AVCodecContext **out_codec) {
   audio_stream_index = findAudioStreamIndex(fmt_ctx);
   if (audio_stream_index < 0) {
     return Err("FFmpegDecoder::openCodec failed: no audio stream found");
@@ -106,7 +104,8 @@ decoding::DecoderResult openCodec(
   const int openResult = avcodec_open2(ctx, codec, nullptr);
   if (openResult < 0) {
     avcodec_free_context(&ctx);
-    return Err("FFmpegDecoder::openCodec failed: avcodec_open2 failed: " + parseFFmpegError(openResult));
+    return Err(
+        "FFmpegDecoder::openCodec failed: avcodec_open2 failed: " + parseFFmpegError(openResult));
   }
   *out_codec = ctx;
   return Ok(None);
@@ -214,8 +213,7 @@ decoding::DecoderResult FFmpegDecoder::openFile(int outputSampleRate, const std:
     return codecResult;
   }
   output_channels_ = codec_ctx_->ch_layout.nb_channels;
-  output_sample_rate_ =
-      (outputSampleRate > 0) ? outputSampleRate : codec_ctx_->sample_rate;
+  output_sample_rate_ = (outputSampleRate > 0) ? outputSampleRate : codec_ctx_->sample_rate;
 
   packet_ = av_packet_alloc();
   frame_ = av_frame_alloc();
@@ -236,10 +234,8 @@ decoding::DecoderResult FFmpegDecoder::openFile(int outputSampleRate, const std:
   return Ok(None);
 }
 
-decoding::DecoderResult FFmpegDecoder::openMemory(
-    int outputSampleRate,
-    const void *data,
-    size_t size) {
+decoding::DecoderResult
+FFmpegDecoder::openMemory(int outputSampleRate, const void *data, size_t size) {
   close();
   if (data == nullptr || size == 0) {
     return Err("FFmpegDecoder::openMemory failed: input data is empty");
@@ -249,20 +245,19 @@ decoding::DecoderResult FFmpegDecoder::openMemory(
   mem_io_->size = size;
   mem_io_->pos = 0;
 
-  auto* io_buf =
-      static_cast<uint8_t *>(av_malloc(decoding::IncrementalAudioDecoder::CHUNK_SIZE));
+  auto *io_buf = static_cast<uint8_t *>(av_malloc(decoding::IncrementalAudioDecoder::CHUNK_SIZE));
   if (io_buf == nullptr) {
     close();
     return Err("FFmpegDecoder::openMemory failed: av_malloc returned null");
   }
   avio_ctx_ = avio_alloc_context(
-    io_buf,
-    static_cast<int>(decoding::IncrementalAudioDecoder::CHUNK_SIZE),
-    0,
-    mem_io_.get(),
-    read_packet,
-    nullptr,
-    seek_packet);
+      io_buf,
+      static_cast<int>(decoding::IncrementalAudioDecoder::CHUNK_SIZE),
+      0,
+      mem_io_.get(),
+      read_packet,
+      nullptr,
+      seek_packet);
   if (avio_ctx_ == nullptr) {
     av_free(io_buf);
     mem_io_.reset();
@@ -296,8 +291,7 @@ decoding::DecoderResult FFmpegDecoder::openMemory(
     return codecResult;
   }
   output_channels_ = codec_ctx_->ch_layout.nb_channels;
-  output_sample_rate_ =
-      (outputSampleRate > 0) ? outputSampleRate : codec_ctx_->sample_rate;
+  output_sample_rate_ = (outputSampleRate > 0) ? outputSampleRate : codec_ctx_->sample_rate;
 
   packet_ = av_packet_alloc();
   frame_ = av_frame_alloc();
@@ -388,8 +382,7 @@ decoding::DecoderResult FFmpegDecoder::feedPipeline() {
     av_packet_unref(packet_);
     if (r < 0) {
       return Err(
-          "FFmpegDecoder::feedPipeline failed: avcodec_send_packet failed: " +
-          parseFFmpegError(r));
+          "FFmpegDecoder::feedPipeline failed: avcodec_send_packet failed: " + parseFFmpegError(r));
     }
   }
 }
@@ -403,7 +396,9 @@ float FFmpegDecoder::getDurationInSeconds() const {
     return 0;
   }
 
-  auto validSeconds = [](double s) -> bool { return s > 0 && std::isfinite(s); };
+  auto validSeconds = [](double s) -> bool {
+    return s > 0 && std::isfinite(s);
+  };
 
   // Prefer per-stream duration (e.g. MP4 mdhd) — often exact vs container-level
   // guesses that trigger AAC “bitrate duration” warnings.
@@ -457,8 +452,8 @@ decoding::DecoderResult FFmpegDecoder::seekToTime(double seconds) {
   avcodec_flush_buffers(codec_ctx_);
   leftover_.clear();
   leftover_offset_ = 0;
-  total_output_frames_ = static_cast<size_t>(
-      std::llround(seconds * static_cast<double>(output_sample_rate_)));
+  total_output_frames_ =
+      static_cast<size_t>(std::llround(seconds * static_cast<double>(output_sample_rate_)));
   return Ok(None);
 }
 
@@ -471,9 +466,8 @@ size_t FFmpegDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
 
   while (delivered < frameCount) {
     size_t need = frameCount - delivered;
-    size_t available_samples = leftover_.size() > leftover_offset_
-        ? leftover_.size() - leftover_offset_
-        : 0;
+    size_t available_samples =
+        leftover_.size() > leftover_offset_ ? leftover_.size() - leftover_offset_ : 0;
     size_t leftover_frames = available_samples / ch;
     if (leftover_frames > 0) {
       size_t take = std::min(need, leftover_frames);
@@ -496,10 +490,8 @@ size_t FFmpegDecoder::readPcmFrames(float *outInterleaved, size_t frameCount) {
   return delivered;
 }
 
-static std::shared_ptr<AudioBuffer> buildAudioBufferFromInterleaved(
-    std::vector<float> &interleaved,
-    int channels,
-    int sample_rate) {
+static std::shared_ptr<AudioBuffer>
+buildAudioBufferFromInterleaved(std::vector<float> &interleaved, int channels, int sample_rate) {
   if (interleaved.empty() || channels <= 0) {
     return nullptr;
   }
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
index 4afbc4a83..e42797cde 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/libs/ffmpeg/FFmpegDecoding.h
@@ -46,14 +46,11 @@ class FFmpegDecoder : public decoding::IncrementalAudioDecoder {
   ~FFmpegDecoder() override;
   DELETE_COPY_AND_MOVE(FFmpegDecoder);
 
-  [[nodiscard]] decoding::DecoderResult openFile(
-      int outputSampleRate,
-      const std::string &path) override;
+  [[nodiscard]] decoding::DecoderResult openFile(int outputSampleRate, const std::string &path)
+      override;
 
-  [[nodiscard]] decoding::DecoderResult openMemory(
-      int outputSampleRate,
-      const void *data,
-      size_t size) override;
+  [[nodiscard]] decoding::DecoderResult
+  openMemory(int outputSampleRate, const void *data, size_t size) override;
 
   [[nodiscard]] size_t readPcmFrames(float *outInterleaved, size_t frameCount) override;
 
@@ -62,8 +59,12 @@ class FFmpegDecoder : public decoding::IncrementalAudioDecoder {
   [[nodiscard]] bool isOpen() const override {
     return fmt_ctx_ != nullptr && codec_ctx_ != nullptr;
   }
-  [[nodiscard]] int outputChannels() const override { return output_channels_; }
-  [[nodiscard]] int outputSampleRate() const override { return output_sample_rate_; }
+  [[nodiscard]] int outputChannels() const override {
+    return output_channels_;
+  }
+  [[nodiscard]] int outputSampleRate() const override {
+    return output_sample_rate_;
+  }
 
   [[nodiscard]] float getDurationInSeconds() const override;
 
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/utils/BoundedPriorityQueue.hpp b/packages/react-native-audio-api/common/cpp/audioapi/utils/BoundedPriorityQueue.hpp
index 63125bd9e..95412e5fe 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/utils/BoundedPriorityQueue.hpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/utils/BoundedPriorityQueue.hpp
@@ -13,7 +13,7 @@ namespace audioapi {
 /// @brief A bounded priority queue with fixed capacity backed by a static pool allocator.
 /// Elements are kept in ascending sorted order (smallest element at front).
 /// All operations avoid heap allocation. Uses std::multiset under the hood
-// to maintain sorted order and provide efficient insertion and removal.
+/// to maintain sorted order and provide efficient insertion and removal.
 /// @tparam T The type of elements stored. Must be move-constructible.
 /// @tparam Capacity The maximum number of elements.
 /// @tparam Compare Comparator type. Defaults to std::less<T> (smallest element at front).
diff --git a/packages/react-native-audio-api/src/core/StreamerNode.ts b/packages/react-native-audio-api/src/core/StreamerNode.ts
index c5a61b45a..1b71a2fe2 100644
--- a/packages/react-native-audio-api/src/core/StreamerNode.ts
+++ b/packages/react-native-audio-api/src/core/StreamerNode.ts
@@ -3,10 +3,26 @@ import { StreamerOptions } from '../types';
 import { NotSupportedError } from '../errors';
 import type BaseAudioContext from './BaseAudioContext';
 
+/**
+ * StreamerNode is an AudioNode that allows you to stream audio from a file or
+ * URL. It uses FFmpeg to decode the audio data and provides it as an audio
+ * source. Note: This node requires the build to use FFmpeg, and will throw an
+ * error if FFmpeg is not available.
+ *
+ * @deprecated Use the `<Audio>` element with MediaElementAudioSourceNode for
+ *   streaming audio instead to achieve the same functionality.
+ */
 export default class StreamerNode extends AudioScheduledSourceNode {
   readonly streamPath: string;
 
   constructor(context: BaseAudioContext, options: StreamerOptions) {
+    if (__DEV__) {
+      console.warn(
+        'StreamerNode is deprecated and will be removed in a future version. ' +
+          'Please migrate to using the <Audio> element for streaming audio.'
+      );
+    }
+
     const node = context.context.createStreamer(options);
     if (!node) {
       throw new NotSupportedError('StreamerNode requires FFmpeg build');
diff --git a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
index d2b2c0e44..f2a26d256 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
+++ b/packages/react-native-audio-api/src/development/react/Audio/Audio.tsx
@@ -59,7 +59,7 @@ const Audio = React.forwardRef<AudioTagHandle, AudioProps>((props, ref) => {
       fileSourceRef.current?.dispose();
       fileSourceRef.current = null;
     };
-  }, []);
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
 
   const effectiveMutedState = useMemo(() => {
     return mutedState ?? muted;
diff --git a/packages/react-native-audio-api/src/development/react/Audio/useAudioSourceLoader.ts b/packages/react-native-audio-api/src/development/react/Audio/useAudioSourceLoader.ts
index 086ad67ef..777eb8cd0 100644
--- a/packages/react-native-audio-api/src/development/react/Audio/useAudioSourceLoader.ts
+++ b/packages/react-native-audio-api/src/development/react/Audio/useAudioSourceLoader.ts
@@ -135,7 +135,7 @@ export function useAudioSourceLoader({
     const headers = getSourceHeaders(source);
 
     try {
-      if (path.startsWith('http')) {
+      if (path.startsWith('http') && !path.endsWith('.m3u8')) {
         const arrayBuffer = await fetch(path, { headers }).then((response) =>
           response.arrayBuffer()
         );