diff --git a/.claude/skills/audio-nodes/SKILL.md b/.claude/skills/audio-nodes/SKILL.md
index da108b451..e2b4b56e4 100644
--- a/.claude/skills/audio-nodes/SKILL.md
+++ b/.claude/skills/audio-nodes/SKILL.md
@@ -331,6 +331,16 @@ Do **not** gate `GraphObject::process()` on `isProcessable()` of inputs: CONDITI
 
 Tail-bearing nodes (Delay/Convolver/Biquad) need no special handling: while connected they stay `CONDITIONAL_PROCESSABLE`; after disconnect they stay `isProcessable()` via the tail override until the impulse decays, so settle does not zero them mid-tail.
 
+### WSOLA (pitchCorrection) source invariants
+Hard-won invariants for `AudioBufferBaseSourceNode::processWithPitchCorrection` and back-to-back scheduled joins (`b2.start(t1 + D/pr)`, join compensation L = 0):
+
+- **Feed real PCM only.** Never let `updatePlaybackInfo`-zeroed start-quantum frames enter the WSOLA analysis queue; mid-quantum starts must instead shift WSOLA's rendered output into `startOffset` after synthesis.
+- **EOF drain.** After natural PCM EOF, keep calling `drainOutput` for full quanta while it fills them; stop when a quantum is under-filled (stretcher dry).
+- **WSOLA whenever `pitchCorrection` is on.** Including `playbackRate == 1` — do not bypass to the non-WSOLA path at unity rate (buffer-source priming may still skip `|rate| == 1`).
+- **Queue EOF needs `endOfStream()`.** An empty queue without that signal is only an underrun; with it, the base drain path runs even when `isEmpty()`.
+
+`AudioFileSourceNode` still has its own prime/drain path (not yet shared).
+
 ---
 
 ## Implementing a New Node — Checklist
diff --git a/.claude/skills/utilities/SKILL.md b/.claude/skills/utilities/SKILL.md
index a7d5733e0..d922f03b9 100644
--- a/.claude/skills/utilities/SKILL.md
+++ b/.claude/skills/utilities/SKILL.md
@@ -231,6 +231,22 @@ Higher-level DSP blocks. Read each header before use.
 
 ---
 
+### `WsolaTimeStretcher.h` — pitch-preserving time stretch
+
+Needs ~`getRequiredInputFrames()` of PCM in its internal queue before the first OLA
+iteration.
+
+- **File / AudioTag:** early `SeekDecoderDaemon` fills the SPSC; construction
+  `primeWsolaInputFromDecoder()` waits until the analysis queue is full (no wall-clock
+  deadline). No first-quantum warmup — process only feeds the current quantum.
+- **Buffer sources:** `AudioBufferSourceNode::start` calls `primeWsolaInput()` after
+  setting `vReadIndex_` (advances cursor by frames fed). Prefill happens only there;
+  `processWithPitchCorrection` feeds one quantum's input. Compare cold-start with DC
+  ones sample + abs/relative first-sound logs in `WsolaTimeStretcher`. Scratch sized
+  with `scratchBufferFrames(sampleRate)`.
+
+---
+
 ### `SpectrumAnalyser.h` — shared windowed-FFT magnitude spectrum
 
 Owns FFT scratch state (Blackman window, temp array, complex scratch, magnitude
diff --git a/apps/common-app/src/examples/WavScheduleSplit/WavScheduleSplit.tsx b/apps/common-app/src/examples/WavScheduleSplit/WavScheduleSplit.tsx
new file mode 100644
index 000000000..b3240e00f
--- /dev/null
+++ b/apps/common-app/src/examples/WavScheduleSplit/WavScheduleSplit.tsx
@@ -0,0 +1,614 @@
+import React, { FC, useCallback, useEffect, useRef, useState } from 'react';
+import { Image, StyleSheet, Text, View } from 'react-native';
+import { ScrollView } from 'react-native-gesture-handler';
+import {
+  AudioBuffer,
+  AudioBufferSourceNode,
+  AudioContext,
+  OfflineAudioContext,
+} from 'react-native-audio-api';
+
+import { Button, Container, Slider, Spacer } from '../../components';
+import { colors } from '../../styles';
+
+const START_DELAY_SECONDS = 0.4;
+const MIN_PLAYBACK_RATE = 0.5;
+const MAX_PLAYBACK_RATE = 3;
+const PLAYBACK_RATE_STEP = 0.1;
+/** Join pull-in (ms). Negative starts part2 earlier. Correct value is 0 (see C++ join tests). */
+const MIN_JOIN_COMPENSATION_MS = -100;
+const MAX_JOIN_COMPENSATION_MS = 100;
+const JOIN_COMPENSATION_STEP_MS = 1;
+const DEFAULT_JOIN_COMPENSATION_MS = 0;
+/** Optional gap between part1 end and part2 start when silence break is on. */
+const SILENCE_BREAK_SECONDS = 1;
+/** Each half of the synthetic ones sample (seconds). */
+const ONES_HALF_SECONDS = 5;
+/** Match WsolaTimeStretcher::kFirstOutputFramesToDump. */
+const LEADING_ZERO_PROBE_FRAMES = 255;
+/** Extra offline length so cold-start latency still fits inside the capture. */
+const LEADING_ZERO_CAPTURE_FRAMES = LEADING_ZERO_PROBE_FRAMES * 16;
+const ZERO_THRESHOLD = 1e-6;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const PAD_P1 = require('./ffmpeg-pad-part1.wav') as number;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const PAD_P2 = require('./ffmpeg-pad-part2.wav') as number;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const MUSIC_CONT_P1 = require('./ffmpeg-music-cont-part1.wav') as number;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const MUSIC_CONT_P2 = require('./ffmpeg-music-cont-part2.wav') as number;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const TONE_P1 = require('./ffmpeg-tone-part1.wav') as number;
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const TONE_P2 = require('./ffmpeg-tone-part2.wav') as number;
+
+type SampleKey = 'pad' | 'musicCont' | 'tone' | 'ones';
+
+type WavSample = {
+  label: string;
+  hint: string;
+  part1?: number;
+  part2?: number;
+};
+
+const SAMPLES: Record<SampleKey, WavSample> = {
+  pad: {
+    label: 'Continuous pad',
+    hint: 'steady chord bed — best for hearing a join gap',
+    part1: PAD_P1,
+    part2: PAD_P2,
+  },
+  musicCont: {
+    label: 'Music · track4 (smoother)',
+    hint: 'real track, more continuous',
+    part1: MUSIC_CONT_P1,
+    part2: MUSIC_CONT_P2,
+  },
+  tone: {
+    label: 'Tone 440 Hz',
+    hint: 'pure continuous tone',
+    part1: TONE_P1,
+    part2: TONE_P2,
+  },
+  ones: {
+    label: 'DC ones (1.0)',
+    hint: 'synthetic fill(1) — use “Dump first frames” for printing/debugging the primed output samples',
+  },
+};
+
+function createDcOnesBuffer(
+  context: AudioContext | OfflineAudioContext,
+  durationSeconds: number
+): AudioBuffer {
+  const sampleRate = context.sampleRate;
+  const length = Math.max(1, Math.floor(durationSeconds * sampleRate));
+  const buffer = context.createBuffer(1, length, sampleRate);
+  buffer.getChannelData(0).fill(1);
+  return buffer;
+}
+
+function countLeadingZeros(samples: Float32Array, threshold = ZERO_THRESHOLD): number {
+  let n = 0;
+  while (n < samples.length && Math.abs(samples[n]!) < threshold) {
+    n += 1;
+  }
+  return n;
+}
+
+function formatFrameDump(samples: Float32Array): string {
+  const parts: string[] = [];
+  for (let i = 0; i < samples.length; i += 1) {
+    parts.push(`${i}:${samples[i]!.toFixed(4)}`);
+  }
+  return parts.join(' ');
+}
+
+/**
+ * Experiment:
+ *   ffmpeg-cut encoded WAV parts → decodeAudioData each →
+ *   source1.start(t0); source2.start(t0 + buffer1.duration)
+ */
+const WavScheduleSplit: FC = () => {
+  const [sample, setSample] = useState<SampleKey>('pad');
+  const [playbackRate, setPlaybackRate] = useState(1);
+  const [pitchCorrection, setPitchCorrection] = useState(true);
+  const [silenceBreak, setSilenceBreak] = useState(false);
+  const [joinCompensationMs, setJoinCompensationMs] = useState(
+    DEFAULT_JOIN_COMPENSATION_MS
+  );
+  const [isLoading, setIsLoading] = useState(false);
+  const [isRunning, setIsRunning] = useState(false);
+  const [status, setStatus] = useState(
+    'Ready — continuous WAV parts → decode → start(t0 + buffer1.duration / rate + L)'
+  );
+  const [eventLog, setEventLog] = useState<string[]>([]);
+  const contextRef = useRef<AudioContext | null>(null);
+  const sourcesRef = useRef<AudioBufferSourceNode[]>([]);
+
+  const appendLog = useCallback((line: string) => {
+    setEventLog((prev) => [...prev, line]);
+  }, []);
+
+  const getContext = useCallback(() => {
+    if (!contextRef.current) {
+      contextRef.current = new AudioContext();
+    }
+    return contextRef.current;
+  }, []);
+
+  const stopSources = useCallback(() => {
+    for (const source of sourcesRef.current) {
+      try {
+        source.onEnded = null;
+        source.stop();
+      } catch {
+        // already stopped
+      }
+      try {
+        source.disconnect();
+      } catch {
+        // already disconnected
+      }
+    }
+    sourcesRef.current = [];
+    setIsRunning(false);
+  }, []);
+
+  useEffect(() => {
+    return () => {
+      stopSources();
+      contextRef.current?.close();
+      contextRef.current = null;
+    };
+  }, [stopSources]);
+
+  const loadDecodedPair = useCallback(async () => {
+    const context = getContext();
+    if (context.state === 'suspended') {
+      await context.resume();
+    }
+
+    if (sample === 'ones') {
+      const buffer1 = createDcOnesBuffer(context, ONES_HALF_SECONDS);
+      const buffer2 = createDcOnesBuffer(context, ONES_HALF_SECONDS);
+      return { context, buffer1, buffer2 };
+    }
+
+    const { part1, part2 } = SAMPLES[sample];
+    const uri1 = Image.resolveAssetSource(part1!).uri;
+    const uri2 = Image.resolveAssetSource(part2!).uri;
+
+    const arrayBuffer1 = await fetch(uri1).then((res) => res.arrayBuffer());
+    const arrayBuffer2 = await fetch(uri2).then((res) => res.arrayBuffer());
+
+    const buffer1 = await context.decodeAudioData(arrayBuffer1);
+    const buffer2 = await context.decodeAudioData(arrayBuffer2);
+    return { context, buffer1, buffer2 };
+  }, [getContext, sample]);
+
+  const dumpFirstOnesFrames = useCallback(async () => {
+    setIsLoading(true);
+    setEventLog([]);
+
+    try {
+      const live = getContext();
+      if (live.state === 'suspended') {
+        await live.resume();
+      }
+
+      const rate = playbackRate;
+      const sampleRate = live.sampleRate;
+      const offline = new OfflineAudioContext(
+        1,
+        LEADING_ZERO_CAPTURE_FRAMES,
+        sampleRate
+      );
+      const ones = createDcOnesBuffer(
+        offline,
+        LEADING_ZERO_CAPTURE_FRAMES / sampleRate + 1
+      );
+      const source = offline.createBufferSource({ pitchCorrection });
+      source.buffer = ones;
+      source.playbackRate.value = rate;
+      source.connect(offline.destination);
+      source.start(0);
+
+      const rendered = await offline.startRendering();
+      const channel = rendered.getChannelData(0);
+      const firstFrames = channel.subarray(0, LEADING_ZERO_PROBE_FRAMES);
+      const leadingZeros = countLeadingZeros(firstFrames);
+      const dump = formatFrameDump(firstFrames);
+
+      console.log(
+        `[WavScheduleSplit] first ${LEADING_ZERO_PROBE_FRAMES} frames · rate=${rate.toFixed(1)} · leadingZeros=${leadingZeros} · wsola=${pitchCorrection}`
+      );
+      console.log(`[WavScheduleSplit] frames: ${dump}`);
+
+      setStatus(
+        [
+          `ones probe · rate=${rate.toFixed(1)} pitchCorrection=${pitchCorrection}`,
+          `ctxSr=${sampleRate} capture=${LEADING_ZERO_CAPTURE_FRAMES}`,
+          `leadingZeros in first ${LEADING_ZERO_PROBE_FRAMES}=${leadingZeros}`,
+          `see console + event log for per-frame dump`,
+        ].join('\n')
+      );
+      appendLog(
+        `leadingZeros=${leadingZeros}/${LEADING_ZERO_PROBE_FRAMES} · rate=${rate.toFixed(1)} · wsola=${pitchCorrection}`
+      );
+      appendLog(dump);
+    } catch (error) {
+      console.error(error);
+      setStatus(`Error: ${String(error)}`);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [appendLog, getContext, pitchCorrection, playbackRate]);
+
+  const playGlued = useCallback(async () => {
+    setIsLoading(true);
+    stopSources();
+    setEventLog([]);
+
+    try {
+      const { context, buffer1, buffer2 } = await loadDecodedPair();
+      const rate = playbackRate;
+
+      const sourceNode1 = context.createBufferSource({ pitchCorrection });
+      sourceNode1.buffer = buffer1;
+      sourceNode1.playbackRate.value = rate;
+      const sourceNode2 = context.createBufferSource({ pitchCorrection });
+      sourceNode2.buffer = buffer2;
+      sourceNode2.playbackRate.value = rate;
+
+      const t0 = context.currentTime + START_DELAY_SECONDS;
+      // Wall-clock length of part1 at this rate (content duration / rate).
+      const contentDur = buffer1.duration / rate;
+      // L should be 0, only left for testing.
+      const joinCompensation = pitchCorrection
+        ? joinCompensationMs / 1000
+        : 0;
+      const silenceGap = silenceBreak ? SILENCE_BREAK_SECONDS : 0;
+      const joinAt = t0 + contentDur + joinCompensation + silenceGap;
+
+      sourceNode1.connect(context.destination);
+      sourceNode2.connect(context.destination);
+      sourcesRef.current = [sourceNode1, sourceNode2];
+
+      sourceNode1.onEnded = () => {
+        const now = context.currentTime;
+        const expectedEnd = t0 + contentDur;
+        const deltaMs = (now - expectedEnd) * 1000;
+        try {
+          sourceNode1.disconnect();
+        } catch {
+          // already disconnected
+        }
+        appendLog(
+          `FIRST finished @ ${now.toFixed(3)}s  (content end ${expectedEnd.toFixed(3)}s, Δ ${deltaMs.toFixed(1)} ms; joinAt ${joinAt.toFixed(3)}s)`
+        );
+      };
+      sourceNode2.onEnded = () => {
+        const now = context.currentTime;
+        const contentDur2 = buffer2.duration / rate;
+        const expectedEnd2 = joinAt + contentDur2;
+        const deltaMs2 = (now - expectedEnd2) * 1000;
+        try {
+          sourceNode2.disconnect();
+        } catch {
+          // already disconnected
+        }
+        setIsRunning(false);
+        appendLog(
+          `SECOND finished @ ${now.toFixed(3)}s  (content end ${expectedEnd2.toFixed(3)}s, Δ ${deltaMs2.toFixed(1)} ms; started ${joinAt.toFixed(3)}s)`
+        );
+      };
+
+      sourceNode1.start(t0);
+      sourceNode2.start(joinAt);
+      setIsRunning(true);
+
+      setStatus(
+        [
+          `glued · ${SAMPLES[sample].label} · rate=${rate.toFixed(1)} pitchCorrection=${pitchCorrection}`,
+          SAMPLES[sample].hint,
+          `buffer1.duration=${buffer1.duration.toFixed(4)}s len=${buffer1.length}`,
+          `buffer2.duration=${buffer2.duration.toFixed(4)}s len=${buffer2.length}`,
+          `contentDur=${contentDur.toFixed(4)}s (duration/rate)`,
+          `joinCompensation=${(joinCompensation * 1000).toFixed(1)} ms`,
+          `silenceBreak=${silenceGap.toFixed(1)}s`,
+          `bufSr=${buffer1.sampleRate} ctxSr=${context.sampleRate}`,
+          `source1.start(${t0.toFixed(3)})`,
+          `source2.start(${joinAt.toFixed(3)})  ← joinAt (expected)`,
+          `source2 expected end ${(joinAt + buffer2.duration / rate).toFixed(3)}s`,
+          `Waiting for onEnded…`,
+        ].join('\n')
+      );
+      appendLog(
+        `scheduled · rate=${rate.toFixed(1)} · wsola=${pitchCorrection} · L=${(joinCompensation * 1000).toFixed(1)}ms · gap=${silenceGap.toFixed(1)}s · first→${t0.toFixed(3)}  second→${joinAt.toFixed(3)} · secondEnds~${(joinAt + buffer2.duration / rate).toFixed(3)}`
+      );
+    } catch (error) {
+      console.error(error);
+      setStatus(`Error: ${String(error)}`);
+      setIsRunning(false);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [
+    appendLog,
+    joinCompensationMs,
+    loadDecodedPair,
+    pitchCorrection,
+    playbackRate,
+    sample,
+    silenceBreak,
+    stopSources,
+  ]);
+
+  const playUnbroken = useCallback(async () => {
+    setIsLoading(true);
+    stopSources();
+    setEventLog([]);
+
+    try {
+      const { context, buffer1, buffer2 } = await loadDecodedPair();
+      const rate = playbackRate;
+
+      const length = buffer1.length + buffer2.length;
+      const continuous = context.createBuffer(
+        buffer1.numberOfChannels,
+        length,
+        buffer1.sampleRate
+      );
+      for (let ch = 0; ch < buffer1.numberOfChannels; ch += 1) {
+        const out = continuous.getChannelData(ch);
+        out.set(buffer1.getChannelData(ch), 0);
+        out.set(buffer2.getChannelData(ch), buffer1.length);
+      }
+
+      const source = context.createBufferSource({ pitchCorrection });
+      source.buffer = continuous;
+      source.playbackRate.value = rate;
+      source.connect(context.destination);
+      sourcesRef.current = [source];
+
+      const t0 = context.currentTime + START_DELAY_SECONDS;
+      const joinWouldBe = t0 + buffer1.duration / rate;
+      source.onEnded = () => {
+        const now = context.currentTime;
+        source.disconnect();
+        setIsRunning(false);
+        appendLog(`FULL finished @ ${now.toFixed(3)}s`);
+      };
+      source.start(t0);
+      setIsRunning(true);
+
+      setStatus(
+        [
+          `unbroken · ${SAMPLES[sample].label} · rate=${rate.toFixed(1)} pitchCorrection=${pitchCorrection}`,
+          `duration=${continuous.duration.toFixed(4)}s`,
+          `join would be @ ${joinWouldBe.toFixed(3)}s`,
+          `source.start(${t0.toFixed(3)})`,
+        ].join('\n')
+      );
+      appendLog(
+        `scheduled unbroken · rate=${rate.toFixed(1)} · wsola=${pitchCorrection} · start ${t0.toFixed(3)}`
+      );
+    } catch (error) {
+      console.error(error);
+      setStatus(`Error: ${String(error)}`);
+      setIsRunning(false);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [appendLog, loadDecodedPair, pitchCorrection, playbackRate, sample, stopSources]);
+
+  const busy = isLoading || isRunning;
+  const playLabel = (idle: string) =>
+    isLoading ? 'Loading…' : isRunning ? 'Running…' : idle;
+  const rateLabel = playbackRate.toFixed(1);
+  const joinLabel = `${joinCompensationMs} ms`;
+  const wsolaLabel = pitchCorrection ? 'WSOLA' : 'raw';
+  const gapLabel = silenceBreak ? `gap ${SILENCE_BREAK_SECONDS}s` : 'no gap';
+
+  return (
+    <Container>
+      <ScrollView
+        style={styles.scroll}
+        contentContainerStyle={styles.body}
+        keyboardShouldPersistTaps="handled"
+      >
+        <Text style={styles.title}>WAV schedule split</Text>
+        <Text style={styles.caption}>
+          Continuous sources cut with ffmpeg (5 s + rest) → decode each →
+          source2.start(t0 + duration/rate + L. L should be 0, correctly. Compare with / without WSOLA
+          (especially at rate 1). 
+        </Text>
+
+        <Spacer.Vertical size={20} />
+        <Text style={styles.section}>Sample</Text>
+        {(Object.keys(SAMPLES) as SampleKey[]).map((key) => {
+          const selected = sample === key;
+          return (
+            <View key={key} style={styles.sampleRow}>
+              <Button
+                title={`${selected ? '● ' : '○ '}${SAMPLES[key].label}`}
+                onPress={() => {
+                  if (!busy) {
+                    setSample(key);
+                    setEventLog([]);
+                    setStatus(
+                      `Selected: ${SAMPLES[key].label}\n${SAMPLES[key].hint}`
+                    );
+                  }
+                }}
+                disabled={busy}
+              />
+              <Text style={styles.hint}>{SAMPLES[key].hint}</Text>
+            </View>
+          );
+        })}
+
+        <Spacer.Vertical size={24} />
+        <Text style={styles.section}>WSOLA</Text>
+        <Text style={styles.hint}>
+          pitchCorrection on buffer sources. At rate 1, off = plain playback;
+          on = WSOLA still runs (prime/drain path).
+        </Text>
+        <Spacer.Vertical size={8} />
+        <Button
+          title={pitchCorrection ? '● With WSOLA' : '○ With WSOLA'}
+          onPress={() => setPitchCorrection(true)}
+          disabled={busy}
+        />
+        <Spacer.Vertical size={8} />
+        <Button
+          title={!pitchCorrection ? '● Without WSOLA' : '○ Without WSOLA'}
+          onPress={() => setPitchCorrection(false)}
+          disabled={busy}
+        />
+
+        <Spacer.Vertical size={24} />
+        <Text style={styles.section}>Playback rate</Text>
+        <Slider
+          label="Rate"
+          value={playbackRate}
+          onValueChange={setPlaybackRate}
+          min={MIN_PLAYBACK_RATE}
+          max={MAX_PLAYBACK_RATE}
+          step={PLAYBACK_RATE_STEP}
+          minLabelWidth={40}
+        />
+
+        <Spacer.Vertical size={16} />
+        <Text style={styles.section}>Join compensation L</Text>
+        <Text style={styles.hint}>
+          Applied only when WSOLA is on. L should be 0, correctly.
+        </Text>
+        <Spacer.Vertical size={8} />
+        <Slider
+          label="L ms"
+          value={joinCompensationMs}
+          onValueChange={setJoinCompensationMs}
+          min={MIN_JOIN_COMPENSATION_MS}
+          max={MAX_JOIN_COMPENSATION_MS}
+          step={JOIN_COMPENSATION_STEP_MS}
+          minLabelWidth={40}
+        />
+
+        <Spacer.Vertical size={24} />
+        <Text style={styles.section}>Silence break</Text>
+        <Text style={styles.hint}>
+          Glued only: delay part2 by {SILENCE_BREAK_SECONDS}s after part1’s
+          content end (plus L). Off = back-to-back join.
+        </Text>
+        <Spacer.Vertical size={8} />
+        <Button
+          title={
+            silenceBreak
+              ? `● ${SILENCE_BREAK_SECONDS}s silence between parts`
+              : `○ ${SILENCE_BREAK_SECONDS}s silence between parts`
+          }
+          onPress={() => setSilenceBreak(true)}
+          disabled={busy}
+        />
+        <Spacer.Vertical size={8} />
+        <Button
+          title={!silenceBreak ? '● Back-to-back join' : '○ Back-to-back join'}
+          onPress={() => setSilenceBreak(false)}
+          disabled={busy}
+        />
+
+        <Spacer.Vertical size={24} />
+        <Button
+          title={playLabel(
+            `Play glued (${wsolaLabel}, rate ${rateLabel}, L ${joinLabel}, ${gapLabel})`
+          )}
+          onPress={() => void playGlued()}
+          disabled={busy}
+        />
+        <Spacer.Vertical size={12} />
+        <Button
+          title={playLabel(`Play unbroken (${wsolaLabel}, rate ${rateLabel})`)}
+          onPress={() => void playUnbroken()}
+          disabled={busy}
+        />
+        <Spacer.Vertical size={12} />
+        <Button
+          title={
+            isLoading
+              ? 'Loading…'
+              : `Dump first ${LEADING_ZERO_PROBE_FRAMES} frames (ones, ${wsolaLabel}, rate ${rateLabel})`
+          }
+          onPress={() => void dumpFirstOnesFrames()}
+          disabled={busy}
+        />
+        <Spacer.Vertical size={12} />
+        <Button title="Stop" onPress={stopSources} disabled={!isRunning} />
+
+        <Spacer.Vertical size={24} />
+        <Text style={styles.section}>Event log</Text>
+        <Text style={styles.log}>
+          {eventLog.length === 0
+            ? '(no events yet — play glued and wait for onEnded)'
+            : eventLog.join('\n')}
+        </Text>
+
+        <Spacer.Vertical size={16} />
+        <Text style={styles.section}>Status</Text>
+        <Text style={styles.status}>{status}</Text>
+      </ScrollView>
+    </Container>
+  );
+};
+
+const styles = StyleSheet.create({
+  scroll: {
+    flex: 1,
+  },
+  body: {
+    paddingHorizontal: 20,
+    paddingTop: 24,
+    paddingBottom: 40,
+  },
+  title: {
+    color: colors.white,
+    fontSize: 20,
+    fontWeight: '600',
+  },
+  caption: {
+    color: colors.white,
+    opacity: 0.7,
+    marginTop: 8,
+    lineHeight: 20,
+  },
+  section: {
+    color: colors.white,
+    fontWeight: '600',
+    marginBottom: 8,
+  },
+  sampleRow: {
+    marginBottom: 12,
+  },
+  hint: {
+    color: colors.white,
+    opacity: 0.55,
+    fontSize: 12,
+    marginTop: 4,
+    marginLeft: 4,
+  },
+  log: {
+    color: '#9BE7A0',
+    fontFamily: 'Courier',
+    fontSize: 13,
+    lineHeight: 20,
+    marginBottom: 8,
+  },
+  status: {
+    color: colors.white,
+    fontFamily: 'Courier',
+    fontSize: 12,
+    lineHeight: 18,
+  },
+});
+
+export default WavScheduleSplit;
diff --git a/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-music-cont-part1.wav b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-music-cont-part1.wav
new file mode 100644
index 000000000..360f40801
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-music-cont-part1.wav differ
diff --git a/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-music-cont-part2.wav b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-music-cont-part2.wav
new file mode 100644
index 000000000..4a55a14cd
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-music-cont-part2.wav differ
diff --git a/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-pad-part1.wav b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-pad-part1.wav
new file mode 100644
index 000000000..42a7485d8
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-pad-part1.wav differ
diff --git a/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-pad-part2.wav b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-pad-part2.wav
new file mode 100644
index 000000000..c91898d35
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-pad-part2.wav differ
diff --git a/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-tone-part1.wav b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-tone-part1.wav
new file mode 100644
index 000000000..f8b715a5c
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-tone-part1.wav differ
diff --git a/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-tone-part2.wav b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-tone-part2.wav
new file mode 100644
index 000000000..e5483079a
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/ffmpeg-tone-part2.wav differ
diff --git a/apps/common-app/src/examples/WavScheduleSplit/index.ts b/apps/common-app/src/examples/WavScheduleSplit/index.ts
new file mode 100644
index 000000000..8cfc75df3
--- /dev/null
+++ b/apps/common-app/src/examples/WavScheduleSplit/index.ts
@@ -0,0 +1 @@
+export { default } from './WavScheduleSplit';
diff --git a/apps/common-app/src/examples/WavScheduleSplit/music-track4-15s.wav b/apps/common-app/src/examples/WavScheduleSplit/music-track4-15s.wav
new file mode 100644
index 000000000..64829465a
Binary files /dev/null and b/apps/common-app/src/examples/WavScheduleSplit/music-track4-15s.wav differ
diff --git a/apps/common-app/src/examples/index.ts b/apps/common-app/src/examples/index.ts
index ca0e12773..2cb34421d 100644
--- a/apps/common-app/src/examples/index.ts
+++ b/apps/common-app/src/examples/index.ts
@@ -14,6 +14,7 @@ import Record from './Record/Record';
 import Worklets from './Worklets/Worklets';
 import AudioStream from './AudioTag/AudioTag';
 import ConvolverIR from './ConvolverIR';
+import WavScheduleSplit from './WavScheduleSplit';
 import ChannelMergerSplitter from './ChannelMergerSplitter';
 
 type NavigationParamList = {
@@ -33,6 +34,7 @@ type NavigationParamList = {
   ConvolverIR: undefined;
   ChannelMergerSplitter: undefined;
   ChannelCount: undefined;
+  WavScheduleSplit: undefined;
   AudioParamPipeline: undefined;
   TestScreen: undefined;
   LatencyValidation: undefined;
@@ -138,4 +140,10 @@ export const Examples: Example[] = [
     Icon: icons.Columns3,
     screen: ChannelCount,
   },
+  {
+    key: 'WavScheduleSplit',
+    title: 'WAV Schedule Split',
+    Icon: icons.AudioLines,
+    screen: WavScheduleSplit,
+  },
 ] as const;
diff --git a/apps/fabric-example/ios/Podfile.lock b/apps/fabric-example/ios/Podfile.lock
index 349cbdb51..7037aa838 100644
--- a/apps/fabric-example/ios/Podfile.lock
+++ b/apps/fabric-example/ios/Podfile.lock
@@ -2523,7 +2523,7 @@ EXTERNAL SOURCES:
 
 SPEC CHECKSUMS:
   FBLazyVector: c00c20551d40126351a6783c47ce75f5b374851b
-  hermes-engine: e97e6762d8c64a63b6e1d5cd704577fdd5992f9c
+  hermes-engine: fd79291075647a2216de246626b26b8c068f1039
   RCTDeprecation: 3bb167081b134461cfeb875ff7ae1945f8635257
   RCTRequired: 74839f55d5058a133a0bc4569b0afec750957f64
   RCTSwiftUI: 87a316382f3eab4dd13d2a0d0fd2adcce917361a
@@ -2532,7 +2532,7 @@ SPEC CHECKSUMS:
   React: 1b1536b9099195944034e65b1830f463caaa8390
   React-callinvoker: 6dff6d17d1d6cc8fdf85468a649bafed473c65f5
   React-Core: 00faa4d038298089a1d5a5b21dde8660c4f0820d
-  React-Core-prebuilt: c28e62d9521adb5940a1bf6d8d31c4f70debdbe3
+  React-Core-prebuilt: 6ff532f696eb538a6b1beb5875de609724d9b426
   React-CoreModules: a17807f849bfd86045b0b9a75ec8c19373b482f6
   React-cxxreact: c7b53ace5827be54048288bce5c55f337c41e95f
   React-debug: e1f00fcd2cef58a2897471a6d76a4ef5f5f90c74
@@ -2596,7 +2596,7 @@ SPEC CHECKSUMS:
   ReactAppDependencyProvider: 5787b37b8e2e51dfeab697ec031cc7c4080dcea2
   ReactCodegen: d07ee3c8db75b43d1cbe479ae6affebf9925c733
   ReactCommon: fe2a3af8975e63efa60f95fca8c34dc85deee360
-  ReactNativeDependencies: d78bc47c9d51cd25ac809534164aec0d5dcf46e9
+  ReactNativeDependencies: bdd62b51872418996ef6cb305f40de2b1e95b084
   RNAudioAPI: bf5a0c9caaa6d553c5aaa4e0b024596dea4634f7
   RNAudioWorklets: febe470be646585d9b8b0de320a5fb8684cb012c
   RNGestureHandler: 187c5c7936abf427bc4d22d6c3b1ac80ad1f63c0
diff --git a/packages/audiodocs/docs/sources/audio-buffer-queue-source-node.mdx b/packages/audiodocs/docs/sources/audio-buffer-queue-source-node.mdx
index 01b938b67..0daeb3dc8 100644
--- a/packages/audiodocs/docs/sources/audio-buffer-queue-source-node.mdx
+++ b/packages/audiodocs/docs/sources/audio-buffer-queue-source-node.mdx
@@ -52,6 +52,7 @@ function App() {
     const buffer2 = ...; // Load another audio buffer if needed
     audioBufferQueue.enqueueBuffer(buffer1);
     audioBufferQueue.enqueueBuffer(buffer2);
+    audioBufferQueue.endOfStream();
     audioBufferQueue.connect(audioContextRef.current.destination);
     audioBufferQueue.start(audioContextRef.current.currentTime);
 }
@@ -111,6 +112,21 @@ Adds another buffer to queue. Returns `bufferId` that can be used to identify th
 
 #### Returns `string`.
 
+### `endOfStream`
+
+Declares that no further buffers will be enqueued. Once the queue empties after this call, the node treats that as end-of-stream: with [`pitchCorrection`](#constructor) enabled it flushes the WSOLA OLA tail (same drain path as [`AudioBufferSourceNode`](/docs/sources/audio-buffer-source-node)), then finishes and fires [`onEnded`](/docs/sources/audio-scheduled-source-node#onended). Without this call, an empty queue is only an underrun — the node stays alive and waits for more buffers.
+
+Call after the last `enqueueBuffer` (before or after `start`):
+
+```tsx
+queue.enqueueBuffer(chunk1);
+queue.enqueueBuffer(chunk2);
+queue.endOfStream();
+queue.start();
+```
+
+#### Returns `undefined`.
+
 ### `dequeueBuffer`
 
 Removes a buffer from the queue. Note that [`onBufferEnded`](audio-buffer-queue-source-node#onbufferended) event will not be fired for the removed buffers.
@@ -234,7 +250,7 @@ audioBufferQueueSourceNode.onBufferEnded = (event) => { //setting callback
 - Default value is `1.0`.
 - Nominal range is -∞ to ∞.
 - For example value of `1.0` plays audio at normal speed, whereas value of `2.0` plays audio twice as fast as normal speed.
-- When created with `pitchCorrection` it is clamped to range `-4` to `4` and uses the WSOLA pitch-correction algorithm when the rate is not `1.0`.
+- When created with `pitchCorrection` it is clamped to range `-4` to `4` and uses the WSOLA pitch-correction algorithm (including when the rate is `1.0`).
 
 ### `OnBufferEndEventType`
 
diff --git a/packages/audiodocs/docs/sources/audio-buffer-source-node.mdx b/packages/audiodocs/docs/sources/audio-buffer-source-node.mdx
index 9501a634b..7d5f5cbe9 100644
--- a/packages/audiodocs/docs/sources/audio-buffer-source-node.mdx
+++ b/packages/audiodocs/docs/sources/audio-buffer-source-node.mdx
@@ -206,7 +206,7 @@ subscription.remove(); // removal of the subscription
 - Default value is `1.0`.
 - Nominal range is -∞ to ∞.
 - For example value of `1.0` plays audio at normal speed, whereas value of `2.0` plays audio twice as fast as normal speed.
-- When created with `pitchCorrection` it is clamped to range `-4` to `4` and uses the WSOLA pitch-correction algorithm when the rate is not `1.0`.
+- When created with `pitchCorrection` it is clamped to range `-4` to `4` and uses the WSOLA pitch-correction algorithm (including when the rate is `1.0`).
 
 #### `buffer`
 - If is null, it outputs a single channel of silence (all samples are equal to `0.0`).
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
index f2891e373..0351c6a2f 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferBaseSourceNodeHostObject.cpp
@@ -86,7 +86,7 @@ void AudioBufferBaseSourceNodeHostObject::initStretch(int channelCount, float sa
   outputLatency_ = WsolaTimeStretcher::OUTPUT_LATENCY_MS / 1000.0;
 
   auto playbackRateBuffer = std::make_shared<DSPAudioBuffer>(
-      WsolaTimeStretcher::MAX_PLAYBACK_RATE * RENDER_QUANTUM_SIZE, channelCount, sampleRate);
+      WsolaTimeStretcher::scratchBufferFrames(sampleRate), channelCount, sampleRate);
 
   auto event = [handle, node = bufferBaseSourceNode_, playbackRateBuffer, channelCount, sampleRate](
                    BaseAudioContext &) {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp
index c364e4695..3676381d8 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.cpp
@@ -26,6 +26,7 @@ AudioBufferQueueSourceNodeHostObject::AudioBufferQueueSourceNodeHostObject(
   addFunctions(
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, start),
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, enqueueBuffer),
+      JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, endOfStream),
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, dequeueBuffer),
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, clearBuffers),
       JSI_EXPORT_FUNCTION(AudioBufferQueueSourceNodeHostObject, pause),
@@ -96,35 +97,37 @@ JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, enqueueBuffer) {
 
   copiedBuffer->sum(*audioBufferHostObject->audioBuffer_);
 
-  std::shared_ptr<AudioBuffer> tailBuffer = nullptr;
-
   if (pitchCorrection_ && !stretchHasBeenInit_) {
     initStretch(
         static_cast<int>(copiedBuffer->getNumberOfChannels()), copiedBuffer->getSampleRate());
-    auto extraTailFrames =
-        static_cast<size_t>((inputLatency_ + outputLatency_) * copiedBuffer->getSampleRate());
-    tailBuffer = std::make_shared<AudioBuffer>(
-        extraTailFrames, copiedBuffer->getNumberOfChannels(), copiedBuffer->getSampleRate());
-    tailBuffer->zero();
     stretchHasBeenInit_ = true;
   }
 
   auto event = [node = bufferQueueSourceNode_,
                 copiedBuffer,
                 bufferId = bufferId_,
-                tailBuffer,
                 swapBuffer,
                 channelCount = channelCount_](BaseAudioContext &) {
     if (swapBuffer) {
       node->setChannelCount(static_cast<int>(channelCount));
     }
-    node->enqueueBuffer(copiedBuffer, bufferId, tailBuffer);
+    node->enqueueBuffer(copiedBuffer, bufferId);
   };
   bufferQueueSourceNode_->scheduleAudioEvent(std::move(event));
 
   return jsi::String::createFromUtf8(runtime, std::to_string(bufferId_++));
 }
 
+JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, endOfStream) {
+  auto handle = node_->handle;
+  auto event = [handle, node = bufferQueueSourceNode_](BaseAudioContext &) {
+    node->endOfStream();
+  };
+  bufferQueueSourceNode_->scheduleAudioEvent(std::move(event));
+
+  return jsi::Value::undefined();
+}
+
 JSI_HOST_FUNCTION_IMPL(AudioBufferQueueSourceNodeHostObject, dequeueBuffer) {
   auto handle = node_->handle;
   auto event = [handle,
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h
index c84de7eee..44ed76f9e 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/HostObjects/sources/AudioBufferQueueSourceNodeHostObject.h
@@ -29,6 +29,7 @@ class AudioBufferQueueSourceNodeHostObject : public AudioBufferBaseSourceNodeHos
   JSI_HOST_FUNCTION_DECL(pause);
   JSI_HOST_FUNCTION_DECL(resume);
   JSI_HOST_FUNCTION_DECL(enqueueBuffer);
+  JSI_HOST_FUNCTION_DECL(endOfStream);
   JSI_HOST_FUNCTION_DECL(dequeueBuffer);
   JSI_HOST_FUNCTION_DECL(clearBuffers);
 
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 6eeac0d47..2262119c5 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
@@ -2,6 +2,7 @@
 
 #include <audioapi/jsi/RuntimeObserver.h>
 #include <jsi/jsi.h>
+#include <cmath>
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp
index ed3c56639..4062f5da5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.cpp
@@ -50,6 +50,43 @@ void AudioBufferBaseSourceNode::initStretch(
   playbackRateBuffer_ = playbackRateBuffer;
 }
 
+void AudioBufferBaseSourceNode::primeWsolaInput() {
+  if (!pitchCorrection_ || playbackRateBuffer_ == nullptr || isEmpty()) {
+    return;
+  }
+
+  std::shared_ptr<BaseAudioContext> context = context_.lock();
+  if (context == nullptr) {
+    return;
+  }
+
+  const float rate = std::fabs(playbackRateParam_->processKRateParam(context->getCurrentTime()));
+  if (rate == 0.0f) {
+    return;
+  }
+
+  wsolaDrainPending_ = false;
+  wsolaStretcher_.reset();
+
+  const size_t framesNeeded =
+      std::max(wsolaStretcher_.getRequiredInputFrames(), wsolaStretcher_.getMinInputFramesToRun());
+  if (framesNeeded == 0) {
+    return;
+  }
+
+  const size_t inputFrames = std::min(framesNeeded, playbackRateBuffer_->getSize());
+  playbackRateBuffer_->zero();
+
+  // 1:1 forward copy into WSOLA's analysis queue; advances vReadIndex_ so the
+  // cursor stays aligned with what was fed before the first output quantum.
+  // Preserve playbackState_: runBufferProcessor can mark STOP_SCHEDULED if the
+  // prime consumes through EOF, which would finish the node before first output.
+  const auto savedState = playbackState_;
+  runBufferProcessor(playbackRateBuffer_, 0, inputFrames, 1.0f, false);
+  playbackState_ = savedState;
+  wsolaStretcher_.feedInput(*playbackRateBuffer_, inputFrames);
+}
+
 std::shared_ptr<AudioParam> AudioBufferBaseSourceNode::getDetuneParam() const {
   return detuneParam_;
 }
@@ -67,8 +104,28 @@ void AudioBufferBaseSourceNode::assignOnPositionChangedCallbackId(uint64_t callb
 }
 
 void AudioBufferBaseSourceNode::processNode(int framesToProcess) {
+  // wsolaDrainPending_ must be checked before isEmpty().
+  if (wsolaDrainPending_) {
+    processWsolaDrain(audioBuffer_, framesToProcess);
+    handleStopScheduled();
+    return;
+  }
+
   if (isEmpty()) {
     audioBuffer_->zero();
+
+    if (isStopScheduled() && stopTime_ < 0.0 && pitchCorrection_) {
+      std::shared_ptr<BaseAudioContext> context = context_.lock();
+      if (context != nullptr) {
+        const float absRate =
+            std::fabs(playbackRateParam_->processKRateParam(context->getCurrentTime()));
+        playbackState_ = PlaybackState::PLAYING;
+        wsolaDrainPending_ = true;
+        wsolaEofDrainRate_ = absRate > 0.0f ? absRate : 1.0f;
+        processWsolaDrain(audioBuffer_, framesToProcess);
+      }
+    }
+    handleStopScheduled();
     return;
   }
 
@@ -82,8 +139,8 @@ void AudioBufferBaseSourceNode::processNode(int framesToProcess) {
   // use the same value.
   const double time = context->getCurrentTime();
 
-  // apply pitch correction only if the playback rate is not 1.0
-  if (pitchCorrection_ && computedPlaybackRateParam_->processKRateParam(time) != 1.0f) {
+  // TODO: check if we want to use interpolation path for 1.0 playback speed when pitch correction is disabled
+  if (pitchCorrection_) {
     processWithPitchCorrection(audioBuffer_, framesToProcess, time);
   } else {
     processWithoutPitchCorrection(audioBuffer_, framesToProcess, time);
@@ -111,15 +168,13 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
       playbackRateParam_->processKRateParam(time),
       -WsolaTimeStretcher::MAX_PLAYBACK_RATE,
       WsolaTimeStretcher::MAX_PLAYBACK_RATE);
+  const float absRate = std::fabs(rate);
 
-  const int framesNeededToStretch =
-      std::max(1, static_cast<int>(std::ceil(rate * framesToProcess)));
-
-  playbackRateBuffer_->zero();
-
+  // Output-quantum domain: startOffset/offsetLength describe the audible span of
+  // this quantum, so pre-start and post-stop zeroing lands in the real output.
   updatePlaybackInfo(
-      playbackRateBuffer_,
-      framesNeededToStretch,
+      processingBuffer,
+      framesToProcess,
       startOffset,
       offsetLength,
       context->getSampleRate(),
@@ -135,22 +190,61 @@ void AudioBufferBaseSourceNode::processWithPitchCorrection(
       2.0f, // NOLINT(cppcoreguidelines-avoid-magic-numbers, readability-magic-numbers)
       detune / static_cast<float>(SEMITONES_PER_OCTAVE));
 
-  const float bufferPlaybackRate = rate >= 0.0f ? rate : -rate;
-  runBufferProcessor(playbackRateBuffer_, startOffset, offsetLength, bufferPlaybackRate, false);
+  const size_t requestedInputFrames = std::max(
+      size_t{1}, static_cast<size_t>(std::ceil(absRate * static_cast<float>(offsetLength))));
+  const size_t inputFrames = std::min(requestedInputFrames, playbackRateBuffer_->getSize());
+
+  playbackRateBuffer_->zero();
+
+  const bool stopFromExplicitSchedule = isStopScheduled();
+  runBufferProcessor(playbackRateBuffer_, 0, inputFrames, absRate, false);
 
   wsolaStretcher_.process(
-      *playbackRateBuffer_,
-      static_cast<size_t>(framesNeededToStretch),
-      *processingBuffer,
-      static_cast<size_t>(framesToProcess),
-      rate,
-      pitchFactor);
+      *playbackRateBuffer_, inputFrames, *processingBuffer, offsetLength, rate, pitchFactor);
+
+  if (startOffset > 0) {
+    // Mid-quantum start: WSOLA requires real PCM (no leading zeroes) to compute
+    // phase alignment without audio artifacts. We synthesize clean audio from frame 0,
+    // then shift the output to startOffset and pad the leading gap with silence.
+    for (size_t i = 0; i < processingBuffer->getNumberOfChannels(); ++i) {
+      auto *channel = processingBuffer->getChannel(i);
+      for (size_t j = offsetLength; j > 0; --j) {
+        (*channel)[j - 1 + startOffset] = (*channel)[j - 1];
+      }
+    }
+    processingBuffer->zero(0, startOffset);
+  }
+
+  // Natural EOF: drain the WSOLA OLA tail to prevent truncation clicks.
+  // Explicit stop(when) bypasses draining to cut precisely at scheduled stopTime_.
+  if (isStopScheduled() && !stopFromExplicitSchedule) {
+    playbackState_ = PlaybackState::PLAYING;
+    wsolaDrainPending_ = true;
+    wsolaEofDrainRate_ = absRate > 0.0f ? absRate : 1.0f;
+  }
 
   if (isPlaying()) {
     positionChanged_.advance(RENDER_QUANTUM_SIZE, getCurrentPosition());
   }
 }
 
+void AudioBufferBaseSourceNode::processWsolaDrain(
+    const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+    int framesToProcess) {
+  const auto frames = static_cast<size_t>(framesToProcess);
+  processingBuffer->zero();
+
+  // Same stop condition as AudioFileSourceNode / gaodeng: keep draining while
+  // each quantum is fully filled; stop when the stretcher runs dry.
+  const size_t drained = wsolaStretcher_.drainOutput(*processingBuffer, frames, wsolaEofDrainRate_);
+  if (drained >= frames) {
+    return;
+  }
+
+  wsolaDrainPending_ = false;
+  playbackState_ = PlaybackState::STOP_SCHEDULED;
+}
+
 void AudioBufferBaseSourceNode::processWithoutPitchCorrection(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     int framesToProcess,
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h
index 4650d9e80..90d9cbbba 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferBaseSourceNode.h
@@ -33,6 +33,12 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
       float sampleRate,
       const std::shared_ptr<DSPAudioBuffer> &playbackRateBuffer);
 
+  /// @brief Prefills WSOLA from the current @ref vReadIndex_ until the analysis queue is full.
+  /// Call from @c start() after the read cursor is set. Advances @ref vReadIndex_ by the
+  /// frames fed. This is the only WSOLA prefill path for buffer sources.
+  /// @note Audio Thread only
+  void primeWsolaInput();
+
   [[nodiscard]] std::shared_ptr<AudioParam> getDetuneParam() const;
   [[nodiscard]] std::shared_ptr<AudioParam> getPlaybackRateParam() const;
 
@@ -73,6 +79,11 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
 
   PositionChangedDispatcher positionChanged_;
 
+  /// True after natural PCM EOF while WSOLA still has OLA tail to flush.
+  /// Not armed for explicit stop(when) — that must cut without draining.
+  bool wsolaDrainPending_{false};
+  float wsolaEofDrainRate_{1.0f};
+
   void processWithPitchCorrection(
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       int framesToProcess,
@@ -82,6 +93,11 @@ class AudioBufferBaseSourceNode : public AudioScheduledSourceNode {
       const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
       int framesToProcess,
       double time);
+
+  /// Flush remaining WSOLA output after PCM is exhausted (mirrors AudioFileSourceNode).
+  void processWsolaDrain(
+      const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
+      int framesToProcess);
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
index 5bda58098..71edaf5e5 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.cpp
@@ -2,7 +2,6 @@
 #include <audioapi/core/BaseAudioContext.h>
 #include <audioapi/core/sources/AudioBufferQueueSourceNode.h>
 #include <audioapi/core/utils/Constants.h>
-#include <audioapi/core/utils/Locker.h>
 #include <audioapi/core/utils/buffer/QueueBufferProcessor.h>
 #include <audioapi/dsp/AudioUtils.h>
 #include <audioapi/events/IAudioEventHandlerRegistry.h>
@@ -20,12 +19,6 @@ AudioBufferQueueSourceNode::AudioBufferQueueSourceNode(
     const BaseAudioBufferSourceOptions &options)
     : AudioBufferBaseSourceNode(context, options),
       onBufferEndedEvent_(context->getAudioEventHandlerRegistry()) {
-  if (options.pitchCorrection) {
-    // If pitch correction is enabled, add extra frames at the end
-    // to compensate for processing latency.
-    addExtraTailFrames_ = true;
-  }
-
   auto *disposer = context->getDisposer();
 
   auto onBufferConsumed = [this, disposer](
@@ -52,21 +45,28 @@ void AudioBufferQueueSourceNode::start(double when) {
   isPaused_ = false;
   stopTime_ = -1.0;
   AudioScheduledSourceNode::start(when);
+  primeWsolaInput();
 }
 
 void AudioBufferQueueSourceNode::start(double when, double offset) {
-  start(when);
+  isPaused_ = false;
+  stopTime_ = -1.0;
+  AudioScheduledSourceNode::start(when);
 
-  if (buffers_.empty() || offset < 0) {
-    return;
+  if (!buffers_.empty() && offset >= 0) {
+    offset = std::min(offset, buffers_.front().second->getDuration());
+    vReadIndex_ = static_cast<double>(buffers_.front().second->getSampleRate() * offset);
   }
 
-  offset = std::min(offset, buffers_.front().second->getDuration());
-  vReadIndex_ = static_cast<double>(buffers_.front().second->getSampleRate() * offset);
+  // Prefill after the start cursor is set so priming matches the offset.
+  primeWsolaInput();
 }
 
 void AudioBufferQueueSourceNode::resume(double when) {
-  start(when);
+  // Do not clear endOfStream_ — pause/resume must preserve the EOF signal.
+  isPaused_ = false;
+  stopTime_ = -1.0;
+  AudioScheduledSourceNode::start(when);
 }
 
 void AudioBufferQueueSourceNode::pause() {
@@ -76,17 +76,15 @@ void AudioBufferQueueSourceNode::pause() {
 
 void AudioBufferQueueSourceNode::enqueueBuffer(
     const std::shared_ptr<AudioBuffer> &buffer,
-    size_t bufferId,
-    const std::shared_ptr<AudioBuffer> &tailBuffer) {
+    size_t bufferId) {
   buffers_.emplace_back(bufferId, buffer);
+  // More PCM after an EOS mark means the stream continues.
+  endOfStream_ = false;
+}
 
-  if (tailBuffer != nullptr) {
-    tailBuffer_ = tailBuffer;
-  }
-
-  if (tailBuffer_ != nullptr) {
-    addExtraTailFrames_ = true;
-  }
+void AudioBufferQueueSourceNode::endOfStream() {
+  endOfStream_ = true;
+  armNaturalEofIfNeeded();
 }
 
 void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
@@ -99,6 +97,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
       context->getDisposer()->dispose(std::move(buffers_.front().second));
       buffers_.pop_front();
       vReadIndex_ = 0.0;
+      armNaturalEofIfNeeded();
       return;
     }
 
@@ -108,6 +107,7 @@ void AudioBufferQueueSourceNode::dequeueBuffer(const size_t bufferId) {
       if (it->first == bufferId) {
         context->getDisposer()->dispose(std::move(it->second));
         buffers_.erase(it);
+        armNaturalEofIfNeeded();
         return;
       }
     }
@@ -122,6 +122,7 @@ void AudioBufferQueueSourceNode::clearBuffers() {
 
     buffers_.clear();
     vReadIndex_ = 0.0;
+    armNaturalEofIfNeeded();
   }
 }
 
@@ -169,6 +170,17 @@ bool AudioBufferQueueSourceNode::isEmpty() const {
   return buffers_.empty();
 }
 
+void AudioBufferQueueSourceNode::armNaturalEofIfNeeded() {
+  if (!endOfStream_ || !buffers_.empty()) {
+    return;
+  }
+  if (isFinished() || isStopScheduled() || isUnscheduled()) {
+    return;
+  }
+  // Natural EOF (no explicit stopTime_): base processNode drains WSOLA then finishes.
+  playbackState_ = PlaybackState::STOP_SCHEDULED;
+}
+
 void AudioBufferQueueSourceNode::runBufferProcessor(
     const std::shared_ptr<DSPAudioBuffer> &processingBuffer,
     size_t startOffset,
@@ -181,21 +193,17 @@ void AudioBufferQueueSourceNode::runBufferProcessor(
 
   if (buffers_.empty()) {
     processingBuffer->zero(startOffset, offsetLength);
+    armNaturalEofIfNeeded();
     return;
   }
 
-  if (addExtraTailFrames_ && tailBuffer_ != nullptr) {
-    processor_->setPendingTail(tailBuffer_);
-  }
-
   processor_->setPosition(vReadIndex_);
   processor_->process(processingBuffer, startOffset, offsetLength, playbackRate, interpolate);
+  vReadIndex_ = processor_->getPosition();
 
-  if (processor_->didConsumeTail()) {
-    addExtraTailFrames_ = false;
+  if (processor_->atBoundary() && processor_->shouldStop()) {
+    armNaturalEofIfNeeded();
   }
-
-  vReadIndex_ = processor_->getPosition();
 }
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h
index 2574c0617..754a08a78 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferQueueSourceNode.h
@@ -32,10 +32,14 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
   void resume(double when);
 
   /// @note Audio Thread only
-  void enqueueBuffer(
-      const std::shared_ptr<AudioBuffer> &buffer,
-      size_t bufferId,
-      const std::shared_ptr<AudioBuffer> &tailBuffer);
+  void enqueueBuffer(const std::shared_ptr<AudioBuffer> &buffer, size_t bufferId);
+
+  /// @brief Declares that no further buffers will be enqueued.
+  /// Once the queue empties after this call, playback treats that as natural EOF
+  /// (WSOLA drain when pitch correction is on, then finish). Without this call,
+  /// an empty queue is only an underrun and the node stays alive.
+  /// @note Audio Thread only
+  void endOfStream();
 
   /// @note Audio Thread only
   void dequeueBuffer(size_t bufferId);
@@ -71,14 +75,18 @@ class AudioBufferQueueSourceNode : public AudioBufferBaseSourceNode {
   std::list<std::pair<size_t, std::shared_ptr<AudioBuffer>>> buffers_;
 
   bool isPaused_ = false;
-  bool addExtraTailFrames_ = false;
-  std::shared_ptr<AudioBuffer> tailBuffer_;
+  /// Set to true by @ref endOfStream().
+  /// When true, an empty queue indicates EOF (drain and stop);
+  /// when false, an empty queue is treated as a temporary underrun (keep waiting).
+  bool endOfStream_ = false;
 
   double playedBuffersDuration_ = 0;
 
   EventCaller<AudioEvent::BUFFER_ENDED> onBufferEndedEvent_;
 
   std::unique_ptr<QueueBufferProcessor> processor_;
+
+  void armNaturalEofIfNeeded();
 };
 
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
index 24dbf20f6..835d12f86 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/core/sources/AudioBufferSourceNode.cpp
@@ -104,6 +104,9 @@ void AudioBufferSourceNode::start(double when, double offset, double duration) {
   }
 
   vReadIndex_ = static_cast<double>(buffer_->getSampleRate() * offset);
+
+  // Prefill WSOLA from the start cursor before the first quantum.
+  primeWsolaInput();
 }
 
 void AudioBufferSourceNode::disable() {
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 b78ce4613..34bd126a2 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
@@ -14,10 +14,12 @@
 #include <algorithm>
 #include <atomic>
 #include <cassert>
+#include <chrono>
 #include <cmath>
 #include <cstddef>
 #include <cstring>
 #include <memory>
+#include <thread>
 #include <utility>
 
 #if !RN_AUDIO_API_FFMPEG_DISABLED
@@ -134,9 +136,70 @@ bool AudioFileSourceNode::initDecoder(
       channelCount_,
       context->getSampleRate());
 
+  startDecoderThread();
+  // Fill WSOLA's analysis queue before the audio thread runs (no wall-clock budget).
+  primeWsolaInputFromDecoder();
   return true;
 }
 
+void AudioFileSourceNode::startDecoderThread() {
+  if (seekDecoderDaemon_ == nullptr || seekDecoderThread_.joinable()) {
+    return;
+  }
+
+  seekDecoderThread_ = std::thread(std::move(*seekDecoderDaemon_));
+  seekDecoderDaemon_.reset();
+}
+
+void AudioFileSourceNode::primeWsolaInputFromDecoder() {
+  if (frameReceiver_ == nullptr || playbackRateBuffer_ == nullptr) {
+    return;
+  }
+
+  const size_t framesNeeded =
+      std::max(wsolaStretcher_.getRequiredInputFrames(), wsolaStretcher_.getMinInputFramesToRun());
+  if (framesNeeded == 0) {
+    return;
+  }
+
+  const size_t chunkCapacity = std::max(framesNeeded, static_cast<size_t>(RENDER_QUANTUM_SIZE));
+  if (!ensurePlaybackRateBufferSize(chunkCapacity)) {
+    return;
+  }
+
+  DecoderData chunk;
+  while (wsolaStretcher_.getBufferedInputFrames() < framesNeeded) {
+    if (frameReceiver_->try_receive(chunk) != channels::spsc::ResponseStatus::SUCCESS) {
+      std::this_thread::sleep_for(std::chrono::milliseconds(1));
+      continue;
+    }
+
+    if (chunk.state == StreamState::END_OF_STREAM || chunk.state == StreamState::DISCONTINUOUS) {
+      break;
+    }
+    if (chunk.size == 0) {
+      continue;
+    }
+
+    if (!ensurePlaybackRateBufferSize(chunk.size)) {
+      break;
+    }
+
+    playbackRateBuffer_->zero();
+    size_t totalInputFrames = 0;
+    appendFromInterleaved(
+        chunk.interleavedBuffer.data(), chunk.size, 0, chunk.size, totalInputFrames);
+    if (totalInputFrames == 0) {
+      continue;
+    }
+
+    if (volume_ != 1.0f) {
+      playbackRateBuffer_->scale(volume_);
+    }
+    wsolaStretcher_.feedInput(*playbackRateBuffer_, totalInputFrames);
+  }
+}
+
 void AudioFileSourceNode::setPlaybackRate(float v) {
   if (decoderState_ == nullptr) {
     return;
@@ -385,11 +448,6 @@ void AudioFileSourceNode::start(double when) {
   endOfStreamStopPending_ = false;
   endOfStreamDrainPending_ = false;
   positionChanged_.requestFlush();
-
-  if (seekDecoderDaemon_) {
-    seekDecoderThread_ = std::thread(std::move(*seekDecoderDaemon_));
-    seekDecoderDaemon_.reset();
-  }
 }
 
 void AudioFileSourceNode::bindMediaElementSource(uint64_t bindingId) {
@@ -495,14 +553,12 @@ size_t AudioFileSourceNode::renderWithWsolaPitchPreservation(
     DecoderData &incoming,
     int framesToProcess,
     float activeRate) {
+  // Prefill happens only in primeWsolaInputFromDecoder(); here feed one quantum.
   const auto requestedInputFrames =
       static_cast<size_t>(std::ceil(activeRate * static_cast<float>(framesToProcess)));
-  const size_t bufferedInputFrames = wsolaStretcher_.getBufferedInputFrames();
-  const size_t requiredInputFrames = wsolaStretcher_.getRequiredInputFrames();
-  const size_t warmupFramesNeeded =
-      bufferedInputFrames < requiredInputFrames ? requiredInputFrames - bufferedInputFrames : 0;
-  const size_t inputFrames = accumulateStretchInput(
-      incoming, activeRate, framesToProcess, requestedInputFrames + warmupFramesNeeded);
+
+  const size_t inputFrames =
+      accumulateStretchInput(incoming, activeRate, framesToProcess, requestedInputFrames);
   if (inputFrames == 0) {
     processingBuffer->zero();
     return 0;
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 c38434494..583bdc94e 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
@@ -188,6 +188,15 @@ class AudioFileSourceNode : public AudioScheduledSourceNode {
       const std::shared_ptr<BaseAudioContext> &context,
       AudioFileSourceOptions &options);
 
+  /// @brief Starts the SeekDecoderDaemon worker thread if it is not already running.
+  /// @note JS / construction thread only.
+  void startDecoderThread();
+
+  /// @brief Synchronously pre-fills @ref wsolaStretcher_ with real PCM frames
+  /// so it can perform its first Overlap-Add (OLA) iteration without startup latency.
+  /// @note JS / main thread only — must run before the audio thread begins processing graph quanta.
+  void primeWsolaInputFromDecoder();
+
   /// @brief Attempts to read the next chunk of decoded frames from the daemon.
   /// @param outData decoded frames and metadata; only valid if return value is true.
   /// @return false if no decoded frames are available; true if @p outData is filled and ready to process.
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.cpp b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.cpp
index 0b005bbe4..3f32fc077 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.cpp
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.cpp
@@ -4,6 +4,7 @@
 
 #include <algorithm>
 #include <cmath>
+#include <iostream>
 #include <limits>
 #include <vector>
 
@@ -20,6 +21,14 @@ float periodicHann(size_t n, size_t size) {
 
 } // namespace
 
+size_t WsolaTimeStretcher::scratchBufferFrames(float sampleRate) {
+  const float sr = sampleRate > 0.0f ? sampleRate : DEFAULT_SAMPLE_RATE;
+  size_t window = framesFromMs(sr, OLA_WINDOW_MS);
+  window += window & 1U;
+  return window + framesFromMs(sr, SEARCH_INTERVAL_MS) +
+      static_cast<size_t>(MAX_PLAYBACK_RATE * RENDER_QUANTUM_SIZE);
+}
+
 void WsolaTimeStretcher::configure(size_t channels, float sampleRate) {
   channels_ = channels;
   sampleRate_ = sampleRate > 0.0f ? sampleRate : DEFAULT_SAMPLE_RATE;
@@ -71,6 +80,13 @@ void WsolaTimeStretcher::reset() {
   searchBlockIndex_ = 0;
   outputReadIndex_ = 0;
 
+  firstSampleFound_ = false;
+  totalFramesOutput_ = 0;
+
+  firstFramesDumpPrinted_ = false;
+  firstOutputFramesDump_.clear();
+  firstOutputFramesDump_.reserve(kFirstFramesToDump);
+
   for (auto &channel : inputQueue_) {
     channel.clear();
   }
@@ -82,6 +98,24 @@ void WsolaTimeStretcher::reset() {
   }
 }
 
+size_t WsolaTimeStretcher::getMinInputFramesToRun() const {
+  if (windowSize_ == 0 || searchIntervalFrames_ == 0) {
+    return 0;
+  }
+
+  const int lastCandidateStart = searchBlockIndex_ + static_cast<int>(searchIntervalFrames_) - 1;
+  const int targetNeed = maxSourceIndexForBlock(targetBlockIndex_);
+  const int searchNeed = maxSourceIndexForBlock(lastCandidateStart);
+  return static_cast<size_t>(std::max(targetNeed, searchNeed) + 1);
+}
+
+void WsolaTimeStretcher::feedInput(const DSPAudioBuffer &input, size_t inputFrames) {
+  if (channels_ == 0 || windowSize_ == 0 || inputFrames == 0) {
+    return;
+  }
+  appendInput(input, inputFrames);
+}
+
 void WsolaTimeStretcher::process(
     const DSPAudioBuffer &input,
     size_t inputFrames,
@@ -114,6 +148,60 @@ void WsolaTimeStretcher::process(
       availableOutputFrames() < outputFrames * 2) {
     runOneIteration(playbackRate);
   }
+
+  if (!firstSampleFound_) {
+    constexpr float kAbsoluteThreshold = 1e-6f;
+
+    for (size_t i = 0; i < output.getNumberOfChannels(); ++i) {
+      auto *channel = output.getChannel(i);
+      const size_t framesToScan = std::min(outputFrames, channel->getSize());
+      for (size_t j = 0; j < framesToScan; ++j) {
+        const float absSample = std::abs((*channel)[j]);
+        if (absSample > kAbsoluteThreshold) {
+          firstSampleFound_ = true;
+          const size_t absoluteFrameIndex = totalFramesOutput_ + j;
+          const double latencyMs = (static_cast<double>(absoluteFrameIndex) / sampleRate_) * 1000.0;
+          std::cout << "[WSOLA] Pierwszy dzwiek (abs>1e-6)! "
+                    << "Ramka wyjsciowa: " << absoluteFrameIndex << " | Opoznienie: " << latencyMs
+                    << " ms"
+                    << " | Playback Rate: " << playbackRate << std::endl;
+          break;
+        }
+      }
+      if (firstSampleFound_) {
+        break;
+      }
+    }
+  }
+
+  if (!firstFramesDumpPrinted_ && output.getNumberOfChannels() > 0) {
+    auto *channel = output.getChannel(0);
+    const size_t framesToDump = std::min(outputFrames, channel->getSize());
+    for (size_t j = 0; j < framesToDump && firstOutputFramesDump_.size() < kFirstFramesToDump;
+         ++j) {
+      firstOutputFramesDump_.push_back((*channel)[j]);
+    }
+
+    if (firstOutputFramesDump_.size() >= kFirstFramesToDump) {
+      firstFramesDumpPrinted_ = true;
+      size_t leadingZeros = 0;
+      while (leadingZeros < firstOutputFramesDump_.size() &&
+             std::abs(firstOutputFramesDump_[leadingZeros]) < kDumpZeroThreshold) {
+        ++leadingZeros;
+      }
+
+      std::cout << "[WSOLA] first " << kFirstFramesToDump
+                << " frames · leadingZeros=" << leadingZeros << " · rate=" << playbackRate
+                << std::endl;
+      std::cout << "[WSOLA] output:";
+      for (size_t i = 0; i < firstOutputFramesDump_.size(); ++i) {
+        std::cout << ' ' << i << ':' << firstOutputFramesDump_[i];
+      }
+      std::cout << std::endl;
+    }
+  }
+
+  totalFramesOutput_ += outputFrames;
 }
 
 size_t
@@ -255,13 +343,16 @@ bool WsolaTimeStretcher::canRunIteration() const {
   }
 
   const int inputFrames = static_cast<int>(inputQueue_[0].size());
-  const int searchBlockSize = static_cast<int>(searchIntervalFrames_ + windowSize_ - 1);
 
   if (maxSourceIndexForBlock(targetBlockIndex_) >= inputFrames) {
     return false;
   }
 
-  return maxSourceIndexForBlock(searchBlockIndex_ + searchBlockSize - 1) < inputFrames;
+  if (searchIntervalFrames_ == 0) {
+    return false;
+  }
+  const int lastCandidateStart = searchBlockIndex_ + static_cast<int>(searchIntervalFrames_) - 1;
+  return maxSourceIndexForBlock(lastCandidateStart) < inputFrames;
 }
 
 bool WsolaTimeStretcher::targetIsWithinSearchRegion() const {
diff --git a/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.h b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.h
index 9af54135b..710302f38 100644
--- a/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.h
+++ b/packages/react-native-audio-api/common/cpp/audioapi/dsp/WsolaTimeStretcher.h
@@ -18,6 +18,10 @@ class WsolaTimeStretcher {
     return searchIntervalFrames_ + windowSize_;
   }
 
+  /// Minimum input frames needed for @ref canRunIteration at the current analysis
+  /// pointers (search span + target window, accounting for pitchFactor_).
+  [[nodiscard]] size_t getMinInputFramesToRun() const;
+
   [[nodiscard]] size_t getBufferedInputFrames() const {
     return inputQueue_.empty() ? 0 : inputQueue_[0].size();
   }
@@ -26,6 +30,9 @@ class WsolaTimeStretcher {
     return availableOutputFrames();
   }
 
+  /// Appends PCM to the analysis queue without rendering output (startup prefill).
+  void feedInput(const DSPAudioBuffer &input, size_t inputFrames);
+
   void process(
       const DSPAudioBuffer &input,
       size_t inputFrames,
@@ -45,11 +52,16 @@ class WsolaTimeStretcher {
   static constexpr float INPUT_LATENCY_MS = 20.0f;
   static constexpr float OUTPUT_LATENCY_MS = 10.0f;
 
+  /// Scratch capacity for one cold-start warmup (~window+search) plus one max-rate quantum.
+  [[nodiscard]] static size_t scratchBufferFrames(float sampleRate);
+
  private:
   static constexpr float OLA_WINDOW_MS = 20.0f;
   static constexpr float SEARCH_INTERVAL_MS = 30.0f;
   static constexpr size_t SEARCH_DECIMATION = 12;
   static constexpr size_t QUEUE_COMPACT_THRESHOLD_FRAMES = 4096;
+  static constexpr size_t kFirstFramesToDump = 255;
+  static constexpr float kDumpZeroThreshold = 1e-6f;
 
   size_t channels_{0};
   float sampleRate_{0.0f};
@@ -70,6 +82,14 @@ class WsolaTimeStretcher {
   int searchBlockIndex_{0};
   size_t outputReadIndex_{0};
 
+  /// Startup-latency probe: first absolute non-zero output sample.
+  bool firstSampleFound_{false};
+  size_t totalFramesOutput_{0};
+
+  /// One-shot dump of the first @c kFirstFramesToDump ch0 output samples after reset.
+  bool firstFramesDumpPrinted_{false};
+  std::vector<float> firstOutputFramesDump_;
+
   std::vector<float> olaWindow_;
   std::vector<float> transitionWindow_;
   std::vector<std::vector<float>> inputQueue_;
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioBufferQueueSourceTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioBufferQueueSourceTest.cpp
index 142db68b7..c92e7067f 100644
--- a/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioBufferQueueSourceTest.cpp
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/AudioBufferQueueSourceTest.cpp
@@ -4,11 +4,13 @@
 #include <audioapi/core/utils/Constants.h>
 #include <audioapi/core/utils/graph/Graph.h>
 #include <audioapi/core/utils/graph/HostGraph.h>
+#include <audioapi/dsp/WsolaTimeStretcher.h>
 #include <audioapi/types/NodeOptions.h>
 #include <audioapi/utils/AudioArray.hpp>
 #include <audioapi/utils/AudioBuffer.hpp>
 #include <gtest/gtest.h>
 #include <test/src/MockAudioEventHandlerRegistry.h>
+#include <cmath>
 #include <memory>
 #include <vector>
 
@@ -34,12 +36,25 @@ std::shared_ptr<AudioBuffer> makeRampBuffer(size_t frames, size_t startValue) {
   return buffer;
 }
 
+std::shared_ptr<AudioBuffer> makeOnesBuffer(size_t frames) {
+  auto buffer = std::make_shared<AudioBuffer>(frames, 1, (float)SAMPLE_RATE);
+  auto *data = buffer->getChannel(0)->begin();
+  for (size_t i = 0; i < frames; ++i) {
+    data[i] = 1.0f;
+  }
+  return buffer;
+}
+
 class TestableQueueSourceNode : public AudioBufferQueueSourceNode {
  public:
-  explicit TestableQueueSourceNode(const std::shared_ptr<BaseAudioContext> &context)
-      : AudioBufferQueueSourceNode(context, BaseAudioBufferSourceOptions()) {}
+  explicit TestableQueueSourceNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const BaseAudioBufferSourceOptions &options = BaseAudioBufferSourceOptions())
+      : AudioBufferQueueSourceNode(context, options) {}
 
   using AudioBufferQueueSourceNode::getCurrentPosition;
+  using AudioBufferQueueSourceNode::initStretch;
+  using AudioBufferQueueSourceNode::isFinished;
   using AudioBufferQueueSourceNode::processNode;
 };
 
@@ -87,7 +102,7 @@ TEST_F(AudioBufferQueueSourceTest, ConsumesExactlyOneFramePerRenderedFrame) {
   constexpr size_t BUFFER_FRAMES = 1000;
   constexpr size_t BUFFER_COUNT = 3;
   for (size_t b = 0; b < BUFFER_COUNT; ++b) {
-    node.enqueueBuffer(makeRampBuffer(BUFFER_FRAMES, b * BUFFER_FRAMES), b, nullptr);
+    node.enqueueBuffer(makeRampBuffer(BUFFER_FRAMES, b * BUFFER_FRAMES), b);
   }
 
   node.start(0.0);
@@ -122,7 +137,7 @@ TEST_F(AudioBufferQueueSourceTest, StreamingEnqueueKeepsPaceAndContinuity) {
   size_t produced = 0;
   size_t chunkId = 0;
 
-  node.enqueueBuffer(makeRampBuffer(CHUNK_FRAMES, produced), chunkId++, nullptr);
+  node.enqueueBuffer(makeRampBuffer(CHUNK_FRAMES, produced), chunkId++);
   produced += CHUNK_FRAMES;
 
   node.start(0.0);
@@ -134,7 +149,7 @@ TEST_F(AudioBufferQueueSourceTest, StreamingEnqueueKeepsPaceAndContinuity) {
   for (size_t q = 0; q < TOTAL_QUANTA; ++q) {
     // Keep ~1 chunk of headroom queued, mirroring realtime arrival.
     if (expected + CHUNK_FRAMES > produced) {
-      node.enqueueBuffer(makeRampBuffer(CHUNK_FRAMES, produced), chunkId++, nullptr);
+      node.enqueueBuffer(makeRampBuffer(CHUNK_FRAMES, produced), chunkId++);
       produced += CHUNK_FRAMES;
     }
 
@@ -188,7 +203,7 @@ TEST_F(AudioBufferQueueSourceTest, FullGraphRenderPreservesPaceAndSilence) {
     for (size_t i = 0; i < CHUNK_FRAMES; ++i) {
       channel[i] = ((produced + i) % IMPULSE_PERIOD == 0) ? 1.0f : 0.0f;
     }
-    node->enqueueBuffer(buffer, chunkId++, nullptr);
+    node->enqueueBuffer(buffer, chunkId++);
     produced += CHUNK_FRAMES;
   };
 
@@ -222,4 +237,70 @@ TEST_F(AudioBufferQueueSourceTest, FullGraphRenderPreservesPaceAndSilence) {
   }
 }
 
+/// With pitchCorrection, endOfStream() must flush the WSOLA OLA tail and finish
+/// the node — not hang in PLAYING after the last enqueued buffer is consumed.
+TEST_F(AudioBufferQueueSourceTest, PitchCorrectionEndOfStreamDrainsAndFinishes) {
+  constexpr float kRate = 1.3f;
+  constexpr size_t kPartFrames = 4800; // 200 ms @ 24 kHz
+
+  BaseAudioBufferSourceOptions options;
+  options.pitchCorrection = true;
+  options.playbackRate = kRate;
+
+  TestableQueueSourceNode node(context, options);
+  auto playbackRateBuffer = std::make_shared<DSPAudioBuffer>(
+      WsolaTimeStretcher::scratchBufferFrames(static_cast<float>(SAMPLE_RATE)),
+      1,
+      static_cast<float>(SAMPLE_RATE));
+  node.initStretch(1, static_cast<float>(SAMPLE_RATE), playbackRateBuffer);
+  node.setChannelCount(1);
+
+  node.enqueueBuffer(makeOnesBuffer(kPartFrames), 0);
+  node.endOfStream();
+  node.start(0.0);
+
+  const size_t idealOut = static_cast<size_t>(
+      std::lround(static_cast<double>(kPartFrames) / static_cast<double>(kRate)));
+  const size_t captureQuanta = (idealOut + SAMPLE_RATE / 2) / QUANTUM + 8;
+
+  size_t onesFrames = 0;
+  bool sawOnes = false;
+  for (size_t q = 0; q < captureQuanta; ++q) {
+    auto out = renderQuantum(node);
+    ASSERT_NE(out, nullptr);
+    auto channel = out->getChannel(0)->span();
+    for (int i = 0; i < QUANTUM; ++i) {
+      if (channel[i] > 0.5f) {
+        sawOnes = true;
+        ++onesFrames;
+      }
+    }
+    if (node.isFinished()) {
+      break;
+    }
+  }
+
+  EXPECT_TRUE(sawOnes);
+  EXPECT_TRUE(node.isFinished()) << "endOfStream + empty queue must finish after WSOLA drain";
+  // Allow OLA soft edges / uncapped drain surplus; require most of the content.
+  EXPECT_GE(onesFrames, (idealOut * 85) / 100);
+}
+
+/// Empty queue without endOfStream is an underrun: node must stay alive (not finish).
+TEST_F(AudioBufferQueueSourceTest, EmptyQueueWithoutEndOfStreamDoesNotFinish) {
+  TestableQueueSourceNode node(context);
+  node.enqueueBuffer(makeRampBuffer(QUANTUM, 0), 0);
+  node.start(0.0);
+
+  // Exhaust the single buffer.
+  (void)renderQuantum(node);
+  EXPECT_FALSE(node.isFinished());
+
+  // Several more quanta of underrun silence — still not finished.
+  for (int i = 0; i < 16; ++i) {
+    (void)renderQuantum(node);
+  }
+  EXPECT_FALSE(node.isFinished());
+}
+
 // NOLINTEND
diff --git a/packages/react-native-audio-api/common/cpp/test/src/core/sources/WsolaScheduleJoinLatencyTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/core/sources/WsolaScheduleJoinLatencyTest.cpp
new file mode 100644
index 000000000..044f5c0b7
--- /dev/null
+++ b/packages/react-native-audio-api/common/cpp/test/src/core/sources/WsolaScheduleJoinLatencyTest.cpp
@@ -0,0 +1,420 @@
+#include <audioapi/core/AudioParam.h>
+#include <audioapi/core/OfflineAudioContext.h>
+#include <audioapi/core/destinations/AudioDestinationNode.h>
+#include <audioapi/core/sources/AudioBufferSourceNode.h>
+#include <audioapi/core/utils/Constants.h>
+#include <audioapi/core/utils/graph/Graph.h>
+#include <audioapi/core/utils/graph/HostGraph.h>
+#include <audioapi/dsp/WsolaTimeStretcher.h>
+#include <audioapi/types/NodeOptions.h>
+#include <audioapi/utils/AudioArray.hpp>
+#include <audioapi/utils/AudioBuffer.hpp>
+#include <gtest/gtest.h>
+#include <test/src/MockAudioEventHandlerRegistry.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <cstdlib>
+#include <iostream>
+#include <memory>
+#include <utility>
+#include <vector>
+
+using namespace audioapi;
+
+// NOLINTBEGIN
+
+// This test was created to empirically verify the theoritical join latency calculation.
+// If we have two audio buffers, b1 and b2, and we want to schedule b2 to play after b1,
+// the correct formula is: b1.start(t1) b2.start(t1 + D/pr) where D = x / sr (buffer duration), pr = playbackRate.
+// However, this code was run to test the join latency calculation
+namespace {
+
+constexpr int kSampleRate = 24000;
+constexpr int kQuantum = RENDER_QUANTUM_SIZE;
+constexpr float kPlaybackRate = 1.5f;
+constexpr float kOnesThreshold = 0.5f;
+
+constexpr size_t kScheduleUnitFrames = 128;
+
+/// The correct value is 0.
+/// Override via WSOLA_KL_SECONDS to explore other schedules.
+constexpr double kL = 0.0;
+
+double joinCompensationSeconds() {
+  if (const char *env = std::getenv("WSOLA_KL_SECONDS")) {
+    return std::atof(env);
+  }
+  return kL;
+}
+
+float playbackRateForTest() {
+  if (const char *env = std::getenv("WSOLA_RATE")) {
+    return static_cast<float>(std::atof(env));
+  }
+  return kPlaybackRate;
+}
+
+size_t sufficientPartFrames(float playbackRate) {
+  WsolaTimeStretcher stretcher;
+  stretcher.configure(1, static_cast<float>(kSampleRate));
+  const size_t minIn =
+      std::max(stretcher.getRequiredInputFrames(), stretcher.getMinInputFramesToRun());
+  const size_t needed = static_cast<size_t>(
+      std::ceil(5.0 * static_cast<double>(minIn) * static_cast<double>(playbackRate)));
+  const size_t units = (needed + kScheduleUnitFrames - 1) / kScheduleUnitFrames;
+  return units * kScheduleUnitFrames;
+}
+
+std::shared_ptr<AudioBuffer> makeOnesBuffer(size_t frames) {
+  auto buffer = std::make_shared<AudioBuffer>(frames, 1, static_cast<float>(kSampleRate));
+  auto *ch = buffer->getChannel(0)->begin();
+  for (size_t i = 0; i < frames; ++i) {
+    ch[i] = 1.0f;
+  }
+  return buffer;
+}
+
+std::shared_ptr<AudioBuffer> makeSineBuffer(size_t frames, double phase0, float freqHz) {
+  auto buffer = std::make_shared<AudioBuffer>(frames, 1, static_cast<float>(kSampleRate));
+  auto *ch = buffer->getChannel(0)->begin();
+  const double omega = 2.0 * PI * static_cast<double>(freqHz) / static_cast<double>(kSampleRate);
+  for (size_t i = 0; i < frames; ++i) {
+    ch[i] = static_cast<float>(std::sin(phase0 + omega * static_cast<double>(i)));
+  }
+  return buffer;
+}
+
+constexpr size_t kEnergyWindow = 64;
+constexpr float kEnergyThreshold = 0.05f;
+
+struct EnergyRun {
+  size_t start = 0;
+  size_t length = 0;
+};
+
+float windowRms(const std::vector<float> &samples, size_t start, size_t len) {
+  if (len == 0 || start >= samples.size()) {
+    return 0.0f;
+  }
+  const size_t end = std::min(start + len, samples.size());
+  double sumSq = 0.0;
+  for (size_t i = start; i < end; ++i) {
+    sumSq += static_cast<double>(samples[i]) * static_cast<double>(samples[i]);
+  }
+  return static_cast<float>(std::sqrt(sumSq / static_cast<double>(end - start)));
+}
+
+size_t countEnergyRuns(const std::vector<float> &samples) {
+  size_t runs = 0;
+  bool inRun = false;
+  for (size_t i = 0; i + kEnergyWindow <= samples.size(); i += kEnergyWindow) {
+    const bool active = windowRms(samples, i, kEnergyWindow) >= kEnergyThreshold;
+    if (active && !inRun) {
+      ++runs;
+      inRun = true;
+    } else if (!active) {
+      inRun = false;
+    }
+  }
+  return runs;
+}
+
+EnergyRun longestEnergyRun(const std::vector<float> &samples) {
+  EnergyRun best;
+  size_t i = 0;
+  while (i + kEnergyWindow <= samples.size()) {
+    if (windowRms(samples, i, kEnergyWindow) < kEnergyThreshold) {
+      i += kEnergyWindow;
+      continue;
+    }
+    const size_t start = i;
+    while (i + kEnergyWindow <= samples.size() &&
+           windowRms(samples, i, kEnergyWindow) >= kEnergyThreshold) {
+      i += kEnergyWindow;
+    }
+    const size_t len = i - start;
+    if (len > best.length) {
+      best.start = start;
+      best.length = len;
+    }
+  }
+  return best;
+}
+
+struct OnesRun {
+  size_t start = 0;
+  size_t length = 0;
+};
+
+/// Calculates the longest continuous sequence of ones (values ≥ kOnesThreshold)
+OnesRun longestOnesRun(const std::vector<float> &samples) {
+  OnesRun best;
+  size_t i = 0;
+  while (i < samples.size()) {
+    if (samples[i] < kOnesThreshold) {
+      ++i;
+      continue;
+    }
+    const size_t start = i;
+    while (i < samples.size() && samples[i] >= kOnesThreshold) {
+      ++i;
+    }
+    const size_t len = i - start;
+    if (len > best.length) {
+      best.start = start;
+      best.length = len;
+    }
+  }
+  return best;
+}
+
+size_t countOnesRuns(const std::vector<float> &samples) {
+  size_t runs = 0;
+  size_t i = 0;
+  while (i < samples.size()) {
+    if (samples[i] < kOnesThreshold) {
+      ++i;
+      continue;
+    }
+    ++runs;
+    while (i < samples.size() && samples[i] >= kOnesThreshold) {
+      ++i;
+    }
+  }
+  return runs;
+}
+
+class TestableAudioBufferSourceNode : public AudioBufferSourceNode {
+ public:
+  explicit TestableAudioBufferSourceNode(
+      const std::shared_ptr<BaseAudioContext> &context,
+      const AudioBufferSourceOptions &options)
+      : AudioBufferSourceNode(context, options) {}
+
+  using AudioBufferSourceNode::initStretch;
+  using AudioBufferSourceNode::setBuffer;
+};
+
+template <typename NodeT>
+NodeT *nodeOf(utils::graph::HostGraph::Node *hostNode) {
+  return static_cast<NodeT *>(hostNode->handle->audioNode->asAudioNode());
+}
+
+} // namespace
+
+/// Join schedule:
+///   b1.start(t1)
+///   b2.start(t1 + D / pr + L)
+/// where D = x / sr (buffer duration), pr = playbackRate.
+/// L is an additive join pull-in; the correct value is 0 (see kL).
+/// Pass when output is: leading zeros (WSOLA latency), then ONE contiguous ones
+/// run (no internal gap). A gap ⇒ L is wrong.
+TEST(WsolaScheduleJoinLatencyTest, ContiguousOnesAfterJoin) {
+  const double L = joinCompensationSeconds();
+  const float pr = playbackRateForTest();
+  const size_t x = sufficientPartFrames(pr);
+  // Ideal wall-clock ones from two abutted parts (OLA soft edges ⇒ allow < 100%).
+  const size_t idealOnes =
+      static_cast<size_t>(std::lround(2.0 * static_cast<double>(x) / static_cast<double>(pr)));
+  const size_t minOnes = (idealOnes * 90) / 100;
+  const size_t captureFrames = idealOnes + static_cast<size_t>(kSampleRate / 2); // 0.5s margin
+
+  auto eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+  const size_t safetyMarginSize = 2;
+
+  auto context = std::make_shared<OfflineAudioContext>(
+      1, static_cast<int>(captureFrames * safetyMarginSize), kSampleRate, eventRegistry);
+  auto destination = std::make_unique<AudioDestinationNode>(context);
+  context->initialize(destination.get());
+  auto *destinationHostNode = context->getGraph()->addNode(std::move(destination));
+
+  BaseAudioBufferSourceOptions baseOptions;
+  baseOptions.pitchCorrection = true;
+  baseOptions.playbackRate = pr;
+  baseOptions.detune = 0.0f;
+  AudioBufferSourceOptions options(baseOptions);
+
+  auto makeSource = [&]() {
+    auto node = std::make_unique<TestableAudioBufferSourceNode>(context, options);
+    auto playbackRateBuffer = std::make_shared<DSPAudioBuffer>(
+        WsolaTimeStretcher::scratchBufferFrames(static_cast<float>(kSampleRate)),
+        1,
+        static_cast<float>(kSampleRate));
+    node->initStretch(1, static_cast<float>(kSampleRate), playbackRateBuffer);
+    auto outBuf = std::make_shared<DSPAudioBuffer>(kQuantum, 1, static_cast<float>(kSampleRate));
+    node->setBuffer(makeOnesBuffer(x), outBuf);
+    auto *hostNode = context->getGraph()->addNode(std::move(node));
+    EXPECT_TRUE(context->getGraph()->addEdge(hostNode, destinationHostNode).is_ok());
+    return nodeOf<TestableAudioBufferSourceNode>(hostNode);
+  };
+
+  auto *b1 = makeSource();
+  auto *b2 = makeSource();
+
+  constexpr double t1 = 0.0;
+  const double D = static_cast<double>(x) / static_cast<double>(kSampleRate);
+  const double joinAt = t1 + D / static_cast<double>(pr) + L;
+  b1->start(t1, 0.0);
+  b2->start(joinAt, 0.0);
+
+  std::vector<float> output;
+  output.reserve(captureFrames);
+  auto quantum = std::make_shared<DSPAudioBuffer>(kQuantum, 1, static_cast<float>(kSampleRate));
+  while (output.size() < captureFrames) {
+    quantum->zero();
+    context->processGraph(quantum.get(), kQuantum); // G.render(128)
+    const float *ch = quantum->getChannel(0)->begin();
+    for (int i = 0; i < kQuantum; ++i) {
+      output.push_back(ch[i]);
+    }
+  }
+
+  const OnesRun run = longestOnesRun(output);
+  const size_t runs = countOnesRuns(output);
+
+  {
+    std::cout << "[L search] L=" << L << "s rate=" << pr << " x=" << x << " D=" << D
+              << "s joinAt=" << joinAt << "s runs=" << runs << " ideal=" << idealOnes
+              << " min=" << minOnes << std::endl;
+    size_t i = 0;
+    size_t prevEnd = 0;
+    bool first = true;
+    while (i < output.size()) {
+      if (output[i] < kOnesThreshold) {
+        ++i;
+        continue;
+      }
+      const size_t start = i;
+      while (i < output.size() && output[i] >= kOnesThreshold) {
+        ++i;
+      }
+      std::cout << "[L search]   run [" << start << ", " << i << ") len=" << (i - start);
+      if (!first) {
+        std::cout << " gapBefore=" << (start - prevEnd);
+      }
+      std::cout << std::endl;
+      prevEnd = i;
+      first = false;
+    }
+  }
+
+  EXPECT_EQ(runs, 1u) << "Gap in ones ⇒ L is wrong. L=" << L << "s onesStart=" << run.start
+                      << " onesLen=" << run.length;
+  // First OLA hop fades in from silence (no startup seed); ones cross the
+  // threshold partway through that hop (~10 ms / half-window).
+  const size_t maxLeadingFadeFrames =
+      static_cast<size_t>(std::lround(0.01 * static_cast<double>(kSampleRate))) +
+      static_cast<size_t>(kQuantum);
+  EXPECT_LE(run.start, maxLeadingFadeFrames)
+      << "Ones should begin within the first-hop fade-in. start=" << run.start;
+  EXPECT_GE(run.length, minOnes) << "Contiguous ones too short (need ≥90% of 2*x/rate). L=" << L
+                                 << "s onesLen=" << run.length << " min=" << minOnes
+                                 << " ideal=" << idealOnes;
+}
+
+/// Same schedule as ContiguousOnesAfterJoin (t1 + D/pr + L), but with a
+/// phase-continuous sine split. Pass metric: one contiguous energy run.
+TEST(WsolaScheduleJoinLatencyTest, ContiguousSineEnergyAfterJoin) {
+  const double L = joinCompensationSeconds();
+  const float pr = playbackRateForTest();
+  const size_t x = sufficientPartFrames(pr);
+  const size_t idealActive =
+      static_cast<size_t>(std::lround(2.0 * static_cast<double>(x) / static_cast<double>(pr)));
+  const size_t minActive = (idealActive * 85) / 100;
+  const size_t captureFrames = idealActive + static_cast<size_t>(kSampleRate / 2);
+
+  auto eventRegistry = std::make_shared<MockAudioEventHandlerRegistry>();
+  auto context = std::make_shared<OfflineAudioContext>(
+      1, static_cast<int>(captureFrames * 2), kSampleRate, eventRegistry);
+  auto destination = std::make_unique<AudioDestinationNode>(context);
+  context->initialize(destination.get());
+  auto *destinationHostNode = context->getGraph()->addNode(std::move(destination));
+
+  BaseAudioBufferSourceOptions baseOptions;
+  baseOptions.pitchCorrection = true;
+  baseOptions.playbackRate = pr;
+  baseOptions.detune = 0.0f;
+  AudioBufferSourceOptions options(baseOptions);
+
+  constexpr float kSineHz = 440.0f;
+  const double omega = 2.0 * PI * static_cast<double>(kSineHz) / static_cast<double>(kSampleRate);
+  auto part1 = makeSineBuffer(x, 0.0, kSineHz);
+  auto part2 = makeSineBuffer(x, omega * static_cast<double>(x), kSineHz);
+
+  auto makeSource = [&](const std::shared_ptr<AudioBuffer> &buf) {
+    auto node = std::make_unique<TestableAudioBufferSourceNode>(context, options);
+    auto playbackRateBuffer = std::make_shared<DSPAudioBuffer>(
+        WsolaTimeStretcher::scratchBufferFrames(static_cast<float>(kSampleRate)),
+        1,
+        static_cast<float>(kSampleRate));
+    node->initStretch(1, static_cast<float>(kSampleRate), playbackRateBuffer);
+    auto outBuf = std::make_shared<DSPAudioBuffer>(kQuantum, 1, static_cast<float>(kSampleRate));
+    node->setBuffer(buf, outBuf);
+    auto *hostNode = context->getGraph()->addNode(std::move(node));
+    EXPECT_TRUE(context->getGraph()->addEdge(hostNode, destinationHostNode).is_ok());
+    return nodeOf<TestableAudioBufferSourceNode>(hostNode);
+  };
+
+  auto *b1 = makeSource(part1);
+  auto *b2 = makeSource(part2);
+
+  constexpr double t1 = 0.0;
+  const double D = static_cast<double>(x) / static_cast<double>(kSampleRate);
+  const double joinAt = t1 + D / static_cast<double>(pr) + L;
+  b1->start(t1, 0.0);
+  b2->start(joinAt, 0.0);
+
+  std::vector<float> output;
+  output.reserve(captureFrames);
+  auto quantum = std::make_shared<DSPAudioBuffer>(kQuantum, 1, static_cast<float>(kSampleRate));
+  while (output.size() < captureFrames) {
+    quantum->zero();
+    context->processGraph(quantum.get(), kQuantum);
+    const float *ch = quantum->getChannel(0)->begin();
+    for (int i = 0; i < kQuantum; ++i) {
+      output.push_back(ch[i]);
+    }
+  }
+
+  const EnergyRun run = longestEnergyRun(output);
+  const size_t runs = countEnergyRuns(output);
+
+  {
+    std::cout << "[L search sine] L=" << L << "s rate=" << pr << " x=" << x << " D=" << D
+              << "s joinAt=" << joinAt << "s runs=" << runs << " ideal=" << idealActive
+              << " min=" << minActive << " longest=" << run.length << " start=" << run.start
+              << std::endl;
+    size_t i = 0;
+    size_t prevEnd = 0;
+    bool first = true;
+    while (i + kEnergyWindow <= output.size()) {
+      if (windowRms(output, i, kEnergyWindow) < kEnergyThreshold) {
+        i += kEnergyWindow;
+        continue;
+      }
+      const size_t start = i;
+      while (i + kEnergyWindow <= output.size() &&
+             windowRms(output, i, kEnergyWindow) >= kEnergyThreshold) {
+        i += kEnergyWindow;
+      }
+      std::cout << "[L search sine]   energy [" << start << ", " << i << ") len=" << (i - start);
+      if (!first) {
+        std::cout << " gapBefore=" << (start - prevEnd);
+      }
+      std::cout << std::endl;
+      prevEnd = i;
+      first = false;
+    }
+  }
+
+  EXPECT_EQ(runs, 1u) << "Energy gap ⇒ L is wrong for sine. L=" << L << "s start=" << run.start
+                      << " len=" << run.length;
+  EXPECT_LE(run.start, static_cast<size_t>(kQuantum))
+      << "Sine energy should begin near the scheduled start. start=" << run.start;
+  EXPECT_GE(run.length, minActive) << "Active energy too short. L=" << L << "s len=" << run.length
+                                   << " min=" << minActive << " ideal=" << idealActive;
+}
+
+// NOLINTEND
diff --git a/packages/react-native-audio-api/common/cpp/test/src/utils/WsolaTimeStretcherTest.cpp b/packages/react-native-audio-api/common/cpp/test/src/utils/WsolaTimeStretcherTest.cpp
deleted file mode 100644
index 48e84e7ce..000000000
--- a/packages/react-native-audio-api/common/cpp/test/src/utils/WsolaTimeStretcherTest.cpp
+++ /dev/null
@@ -1,151 +0,0 @@
-#include <audioapi/core/utils/Constants.h>
-#include <audioapi/dsp/WsolaTimeStretcher.h>
-#include <audioapi/utils/AudioBuffer.hpp>
-#include <gtest/gtest.h>
-
-#include <cmath>
-#include <optional>
-
-using namespace audioapi;
-
-// NOLINTBEGIN
-
-namespace {
-
-constexpr float kSampleRate = 44100.0f;
-constexpr float kPlaybackRate = 1.5f;
-constexpr size_t kQuantum = RENDER_QUANTUM_SIZE;
-
-size_t inputFramesForQuantum(float playbackRate) {
-  return static_cast<size_t>(std::max(1, static_cast<int>(std::ceil(playbackRate * kQuantum))));
-}
-
-float schedulingLatencySeconds(float playbackRate) {
-  return (WsolaTimeStretcher::OUTPUT_LATENCY_MS / 1000.0f) +
-      (WsolaTimeStretcher::INPUT_LATENCY_MS / 1000.0f) * playbackRate;
-}
-
-void recordFirstPeakIfAbsent(
-    const DSPAudioBuffer &output,
-    size_t totalOutputFrames,
-    size_t inputFramesFed,
-    std::optional<size_t> &firstPeakAtOutputFrame,
-    size_t &inputFramesWhenPeak,
-    float threshold = 0.01f) {
-  if (firstPeakAtOutputFrame.has_value()) {
-    return;
-  }
-
-  const auto outSpan = output.getChannel(0)->span();
-  for (size_t i = 0; i < outSpan.size(); ++i) {
-    if (std::abs(outSpan[i]) > threshold) {
-      firstPeakAtOutputFrame = totalOutputFrames + i;
-      inputFramesWhenPeak = inputFramesFed;
-      return;
-    }
-  }
-}
-
-size_t fillToneBurstChunk(
-    DSPAudioBuffer &input,
-    size_t inputFrames,
-    size_t inputPos,
-    size_t maxInputFrames,
-    float burstSeconds,
-    float sampleRate) {
-  auto channel = input.getChannel(0)->span();
-  for (size_t i = 0; i < inputFrames && inputPos < maxInputFrames; ++i, ++inputPos) {
-    const float t = static_cast<float>(inputPos) / sampleRate;
-    if (t < burstSeconds) {
-      channel[i] = std::sin(2.0f * PI * 440.0f * t);
-    }
-  }
-  return inputPos;
-}
-
-} // namespace
-
-class WsolaTimeStretcherTest : public ::testing::Test {
- protected:
-  WsolaTimeStretcher stretcher_;
-
-  void SetUp() override {
-    stretcher_.configure(1, kSampleRate);
-  }
-};
-
-TEST_F(WsolaTimeStretcherTest, RequiredInputFramesAt44100Hz) {
-  // OLA window 20ms + search interval 30ms at 44.1 kHz.
-  EXPECT_EQ(stretcher_.getRequiredInputFrames(), 2205u);
-}
-
-TEST_F(WsolaTimeStretcherTest, SchedulingLatencyFormulaMatchesDocumentedConstants) {
-  EXPECT_NEAR(schedulingLatencySeconds(1.0f), 0.03f, 1e-6f);
-  EXPECT_NEAR(schedulingLatencySeconds(kPlaybackRate), 0.04f, 1e-6f);
-}
-
-TEST_F(WsolaTimeStretcherTest, ProducesOutputWhenPlaybackRateIsNotUnity) {
-  DSPAudioBuffer input(inputFramesForQuantum(kPlaybackRate), 1, kSampleRate);
-  DSPAudioBuffer output(kQuantum, 1, kSampleRate);
-
-  float peak = 0.0f;
-  size_t globalInputFrame = 0;
-
-  for (size_t pass = 0; pass < 40 && peak <= 0.01f; ++pass) {
-    for (size_t i = 0; i < input.getSize(); ++i, ++globalInputFrame) {
-      input.getChannel(0)->span()[i] =
-          std::sin(2.0f * PI * 440.0f * static_cast<float>(globalInputFrame) / kSampleRate);
-    }
-
-    stretcher_.process(input, input.getSize(), output, output.getSize(), kPlaybackRate);
-
-    for (size_t i = 0; i < output.getSize(); ++i) {
-      peak = std::max(peak, std::abs(output.getChannel(0)->span()[i]));
-    }
-  }
-
-  EXPECT_GT(peak, 0.01f);
-}
-
-TEST_F(WsolaTimeStretcherTest, ToneBurstPassesThroughWithBoundedLatency) {
-  constexpr size_t kMaxInputFrames = 44100;
-  constexpr float kBurstSeconds = 0.1f;
-  const size_t requiredInput = stretcher_.getRequiredInputFrames();
-
-  size_t inputPos = 0;
-  size_t totalOutputFrames = 0;
-  std::optional<size_t> firstPeakAtOutputFrame;
-  size_t inputFramesWhenPeak = 0;
-
-  while (inputPos < kMaxInputFrames) {
-    const size_t inputFrames = inputFramesForQuantum(kPlaybackRate);
-    DSPAudioBuffer input(inputFrames, 1, kSampleRate);
-    DSPAudioBuffer output(kQuantum, 1, kSampleRate);
-    input.zero();
-
-    inputPos = fillToneBurstChunk(
-        input, inputFrames, inputPos, kMaxInputFrames, kBurstSeconds, kSampleRate);
-
-    stretcher_.process(input, inputFrames, output, kQuantum, kPlaybackRate);
-
-    recordFirstPeakIfAbsent(
-        output, totalOutputFrames, inputPos, firstPeakAtOutputFrame, inputFramesWhenPeak);
-    totalOutputFrames += kQuantum;
-
-    // Break out of the loop if we've detected a peak and the input position is past twice the required input frames.
-    if (firstPeakAtOutputFrame && inputPos > requiredInput * 2) {
-      break;
-    }
-  }
-
-  ASSERT_TRUE(firstPeakAtOutputFrame.has_value()) << "WSOLA never produced tone burst energy";
-
-  const float measuredInputLatencySec = static_cast<float>(inputFramesWhenPeak) / kSampleRate;
-  const float primingLatencySec = static_cast<float>(requiredInput) / kSampleRate;
-
-  // WSOLA must prime its analysis window before emitting audio; delay should stay within
-  // the configured priming budget plus a small processing margin.
-  EXPECT_LT(measuredInputLatencySec, primingLatencySec + 0.15f);
-}
-
-// NOLINTEND
diff --git a/packages/react-native-audio-api/src/core/AudioBufferQueueSourceNode.ts b/packages/react-native-audio-api/src/core/AudioBufferQueueSourceNode.ts
index 0a3a7f957..49ba1ec7c 100644
--- a/packages/react-native-audio-api/src/core/AudioBufferQueueSourceNode.ts
+++ b/packages/react-native-audio-api/src/core/AudioBufferQueueSourceNode.ts
@@ -27,6 +27,16 @@ export default class AudioBufferQueueSourceNode extends AudioBufferBaseSourceNod
     );
   }
 
+  /**
+   * Declares that no further buffers will be enqueued. Once the queue empties
+   * after this call, the node finishes (flushing the WSOLA OLA tail when
+   * pitchCorrection is enabled). Without this call, an empty queue is only an
+   * underrun and playback stays alive.
+   */
+  public endOfStream(): void {
+    (this.node as IAudioBufferQueueSourceNode).endOfStream();
+  }
+
   public dequeueBuffer(bufferId: string): void {
     const id = parseInt(bufferId, 10);
     if (isNaN(id) || id < 0) {
diff --git a/packages/react-native-audio-api/src/core/BaseAudioContext.ts b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
index d47251a11..6fec06dd1 100644
--- a/packages/react-native-audio-api/src/core/BaseAudioContext.ts
+++ b/packages/react-native-audio-api/src/core/BaseAudioContext.ts
@@ -4,6 +4,7 @@ import {
   ContextState,
   DecodeDataInput,
   AudioBufferQueueSourceOptions,
+  AudioBufferSourceOptions,
 } from '../types';
 import AnalyserNode from './AnalyserNode';
 import AudioBuffer from './AudioBuffer';
@@ -95,9 +96,9 @@ export default class BaseAudioContext {
     return new BiquadFilterNode(this);
   }
 
-  createBufferSource(options?: {
-    pitchCorrection: boolean;
-  }): AudioBufferSourceNode {
+  createBufferSource(
+    options?: AudioBufferSourceOptions
+  ): AudioBufferSourceNode {
     if (options !== undefined) {
       return new AudioBufferSourceNode(this, options);
     } else {
diff --git a/packages/react-native-audio-api/src/jsi-interfaces.ts b/packages/react-native-audio-api/src/jsi-interfaces.ts
index 6fb1e6d05..dd42a1840 100644
--- a/packages/react-native-audio-api/src/jsi-interfaces.ts
+++ b/packages/react-native-audio-api/src/jsi-interfaces.ts
@@ -227,6 +227,7 @@ export interface IAudioBufferQueueSourceNode extends IAudioBufferBaseSourceNode
 
   // returns bufferId
   enqueueBuffer: (audioBuffer: IAudioBuffer) => string;
+  endOfStream: () => void;
   start: (when?: number, offset?: number) => void;
   pause: () => void;
   resume: (when?: number) => void;
diff --git a/packages/react-native-audio-api/src/mock/index.ts b/packages/react-native-audio-api/src/mock/index.ts
index 7b85feed3..b0f54885b 100644
--- a/packages/react-native-audio-api/src/mock/index.ts
+++ b/packages/react-native-audio-api/src/mock/index.ts
@@ -609,6 +609,8 @@ class AudioBufferQueueSourceNodeMock extends AudioScheduledSourceNodeMock {
     return Math.random().toString(36).substr(2, 9);
   }
 
+  endOfStream(): void {}
+
   dequeueBuffer(_bufferId: string): void {}
   clearBuffers(): void {}
   pause(): void {}