@remotion/media 4.0.354 → 4.0.356

package/dist/audio/audio-for-rendering.js

@@ -1,9 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
 import { useContext, useLayoutEffect, useState } from 'react';
-import { cancelRender, Internals, useCurrentFrame, useDelayRender, useRemotionEnvironment, } from 'remotion';
+import { Audio, cancelRender, Internals, useCurrentFrame, useDelayRender, useRemotionEnvironment, } from 'remotion';
 import { applyVolume } from '../convert-audiodata/apply-volume';
 import { frameForVolumeProp } from '../looped-frame';
 import { extractFrameViaBroadcastChannel } from '../video-extraction/extract-frame-via-broadcast-channel';
-export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted, loopVolumeCurveBehavior, delayRenderRetries, delayRenderTimeoutInMilliseconds, logLevel = window.remotion_logLevel, loop, }) => {
+export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted, loopVolumeCurveBehavior, delayRenderRetries, delayRenderTimeoutInMilliseconds, logLevel = window.remotion_logLevel, loop, fallbackHtml5AudioProps, audioStreamIndex, showInTimeline, style, name, disallowFallbackToHtml5Audio, }) => {
     const frame = useCurrentFrame();
     const absoluteFrame = Internals.useTimelinePosition();
     const videoConfig = Internals.useUnsafeVideoConfig();
@@ -19,6 +20,7 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
     }
     const { fps } = videoConfig;
     const { delayRender, continueRender } = useDelayRender();
+    const [replaceWithHtml5Audio, setReplaceWithHtml5Audio] = useState(false);
     useLayoutEffect(() => {
         const actualFps = playbackRate ? fps / playbackRate : fps;
         const timestamp = frame / actualFps;
@@ -46,8 +48,34 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
             includeVideo: false,
             isClientSideRendering: environment.isClientSideRendering,
             loop: loop ?? false,
+            audioStreamIndex: audioStreamIndex ?? 0,
         })
-            .then(({ audio, durationInSeconds: assetDurationInSeconds }) => {
+            .then((result) => {
+            if (result === 'unknown-container-format') {
+                if (disallowFallbackToHtml5Audio) {
+                    cancelRender(new Error(`Unknown container format ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
+                }
+                Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Unknown container format for ${src} (Supported formats: https://www.remotion.dev/docs/mediabunny/formats), falling back to <Audio>`);
+                setReplaceWithHtml5Audio(true);
+                return;
+            }
+            if (result === 'cannot-decode') {
+                if (disallowFallbackToHtml5Audio) {
+                    cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
+                }
+                Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Cannot decode ${src}, falling back to <Audio>`);
+                setReplaceWithHtml5Audio(true);
+                return;
+            }
+            if (result === 'network-error') {
+                if (disallowFallbackToHtml5Audio) {
+                    cancelRender(new Error(`Cannot decode ${src}, and 'disallowFallbackToHtml5Audio' was set. Failing the render.`));
+                }
+                Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Network error fetching ${src}, falling back to <Audio>`);
+                setReplaceWithHtml5Audio(true);
+                return;
+            }
+            const { audio, durationInSeconds: assetDurationInSeconds } = result;
             const volumePropsFrame = frameForVolumeProp({
                 behavior: loopVolumeCurveBehavior ?? 'repeat',
                 loop: loop ?? false,
@@ -90,6 +118,7 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
         delayRender,
         delayRenderRetries,
         delayRenderTimeoutInMilliseconds,
+        disallowFallbackToHtml5Audio,
         environment.isClientSideRendering,
         fps,
         frame,
@@ -104,6 +133,11 @@ export const AudioForRendering = ({ volume: volumeProp, playbackRate, src, muted
         startsAt,
         unregisterRenderAsset,
         volumeProp,
+        audioStreamIndex,
     ]);
+    if (replaceWithHtml5Audio) {
+        // TODO: Loop and other props
+        return (_jsx(Audio, { src: src, playbackRate: playbackRate, muted: muted, loop: loop, volume: volumeProp, delayRenderRetries: delayRenderRetries, delayRenderTimeoutInMilliseconds: delayRenderTimeoutInMilliseconds, style: style, loopVolumeCurveBehavior: loopVolumeCurveBehavior, audioStreamIndex: audioStreamIndex, useWebAudioApi: fallbackHtml5AudioProps?.useWebAudioApi, onError: fallbackHtml5AudioProps?.onError, toneFrequency: fallbackHtml5AudioProps?.toneFrequency, acceptableTimeShiftInSeconds: fallbackHtml5AudioProps?.acceptableTimeShiftInSeconds, name: name, showInTimeline: showInTimeline }));
+    }
     return null;
 };

package/dist/audio/audio.js

@@ -52,7 +52,7 @@ export const Audio = (props) => {
         typeof trimAfterValue !== 'undefined') {
         return (_jsx(Sequence, { layout: "none", from: 0 - (trimBeforeValue ?? 0), showInTimeline: false, durationInFrames: trimAfterValue, name: name, children: _jsx(Audio, { pauseWhenBuffering: pauseWhenBuffering ?? false, ...otherProps }) }));
     }
-    validateMediaProps(props, 'Video');
+    validateMediaProps({ playbackRate: props.playbackRate, volume: props.volume }, 'Audio');
     if (environment.isRendering) {
         return _jsx(AudioForRendering, { ...otherProps });
     }

package/dist/audio/props.d.ts

@@ -1,4 +1,11 @@
 import type { LogLevel, LoopVolumeCurveBehavior, VolumeProp } from 'remotion';
+export type FallbackHtml5AudioProps = {
+    offthreadAudioProps: {
+        playbackRate?: number;
+        muted?: boolean;
+        loop?: boolean;
+    };
+};
 export type AudioProps = {
     src: string;
     trimBefore?: number;
@@ -19,5 +26,13 @@ export type AudioProps = {
     stack?: string;
     logLevel?: LogLevel;
     loop?: boolean;
+    audioStreamIndex?: number;
     _remotionInternalNativeLoopPassed?: boolean;
+    fallbackHtml5AudioProps?: {
+        onError?: (err: Error) => void;
+        useWebAudioApi?: boolean;
+        toneFrequency?: number;
+        acceptableTimeShiftInSeconds?: number;
+    };
+    disallowFallbackToHtml5Audio?: boolean;
 };

package/dist/audio-extraction/audio-iterator.d.ts

@@ -1,18 +1,19 @@
 import type { AudioSample, AudioSampleSink } from 'mediabunny';
 import { type LogLevel } from 'remotion';
 import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
-export declare const makeAudioIterator: ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, }: {
+export declare const makeAudioIterator: ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, logLevel, }: {
     audioSampleSink: AudioSampleSink;
     isMatroska: boolean;
     startTimestamp: number;
     src: string;
     actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
+    logLevel: LogLevel;
 }) => {
     src: string;
     getSamples: (ts: number, dur: number) => Promise<AudioSample[]>;
     waitForCompletion: () => Promise<boolean>;
     canSatisfyRequestedTime: (timestamp: number) => boolean;
-    logOpenFrames: (logLevel: LogLevel) => void;
+    logOpenFrames: () => void;
     getCacheStats: () => {
         count: number;
         size: number;

package/dist/audio-extraction/audio-iterator.js

@@ -7,11 +7,22 @@ import { makeAudioCache } from './audio-cache';
 // The worst case seems to be FLAC files with a 65'535 sample window, which would be 1486.0ms at 44.1Khz.
 // So let's set a threshold of 1.5 seconds.
 const extraThreshold = 1.5;
-export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, }) => {
+const warned = {};
+const warnAboutMatroskaOnce = (src, logLevel) => {
+    if (warned[src]) {
+        return;
+    }
+    warned[src] = true;
+    Internals.Log.warn({ logLevel, tag: '@remotion/media' }, `Audio from ${src} will need to be read from the beginning. https://www.remotion.dev/docs/media/support#matroska-limitation`);
+};
+export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp, src, actualMatroskaTimestamps, logLevel, }) => {
     // Matroska timestamps are not accurate unless we start from the beginning
     // So for matroska, we need to decode all samples :(
     // https://github.com/Vanilagy/mediabunny/issues/105
     const sampleIterator = audioSampleSink.samples(isMatroska ? 0 : Math.max(0, startTimestamp - extraThreshold));
+    if (isMatroska) {
+        warnAboutMatroskaOnce(src, logLevel);
+    }
     let fullDuration = null;
     const cache = makeAudioCache();
     let lastUsed = Date.now();
@@ -61,7 +72,7 @@ export const makeAudioIterator = ({ audioSampleSink, isMatroska, startTimestamp,
         }
         return samples;
     };
-    const logOpenFrames = (logLevel) => {
+    const logOpenFrames = () => {
         Internals.Log.verbose({ logLevel, tag: '@remotion/media' }, 'Open audio samples for src', src, cache
             .getOpenTimestamps()
             .map((t) => t.toFixed(3))

package/dist/audio-extraction/audio-manager.d.ts

@@ -2,18 +2,19 @@ import type { AudioSampleSink } from 'mediabunny';
 import type { LogLevel } from 'remotion';
 import type { RememberActualMatroskaTimestamps } from '../video-extraction/remember-actual-matroska-timestamps';
 export declare const makeAudioManager: () => {
-    makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+    makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }: {
         timeInSeconds: number;
         src: string;
         audioSampleSink: AudioSampleSink;
         isMatroska: boolean;
         actualMatroskaTimestamps: RememberActualMatroskaTimestamps;
+        logLevel: LogLevel;
     }) => {
         src: string;
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: LogLevel) => void;
+        logOpenFrames: () => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -34,7 +35,7 @@ export declare const makeAudioManager: () => {
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: LogLevel) => void;
+        logOpenFrames: () => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -52,7 +53,7 @@ export declare const makeAudioManager: () => {
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: LogLevel) => void;
+        logOpenFrames: () => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -61,5 +62,5 @@ export declare const makeAudioManager: () => {
         prepareForDeletion: () => Promise<void>;
         startTimestamp: number;
     } | null;
-    logOpenFrames: (logLevel: LogLevel) => void;
+    logOpenFrames: () => void;
 };

package/dist/audio-extraction/audio-manager.js

@@ -2,13 +2,14 @@ import { getMaxVideoCacheSize, getTotalCacheStats } from '../caches';
 import { makeAudioIterator } from './audio-iterator';
 export const makeAudioManager = () => {
     const iterators = [];
-    const makeIterator = ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }) => {
+    const makeIterator = ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }) => {
         const iterator = makeAudioIterator({
             audioSampleSink,
             isMatroska,
             startTimestamp: timeInSeconds,
             src,
             actualMatroskaTimestamps,
+            logLevel,
         });
         iterators.push(iterator);
         return iterator;
@@ -57,6 +58,7 @@ export const makeAudioManager = () => {
             audioSampleSink,
             isMatroska,
             actualMatroskaTimestamps,
+            logLevel,
         });
     };
     const getCacheStats = () => {
@@ -69,9 +71,9 @@ export const makeAudioManager = () => {
         }
         return { count: totalCount, totalSize };
     };
-    const logOpenFrames = (logLevel) => {
+    const logOpenFrames = () => {
         for (const iterator of iterators) {
-            iterator.logOpenFrames(logLevel);
+            iterator.logOpenFrames();
         }
     };
     return {

package/dist/audio-extraction/extract-audio.d.ts

@@ -1,13 +1,14 @@
 import { type LogLevel } from 'remotion';
 import type { PcmS16AudioData } from '../convert-audiodata/convert-audiodata';
-export declare const extractAudio: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, logLevel, loop, playbackRate, }: {
+export declare const extractAudio: ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, logLevel, loop, playbackRate, audioStreamIndex, }: {
     src: string;
     timeInSeconds: number;
     durationInSeconds: number;
     logLevel: LogLevel;
     loop: boolean;
     playbackRate: number;
+    audioStreamIndex: number;
 }) => Promise<{
     data: PcmS16AudioData | null;
     durationInSeconds: number | null;
-}>;
+} | "cannot-decode" | "unknown-container-format">;

package/dist/audio-extraction/extract-audio.js

@@ -2,20 +2,23 @@ import { audioManager } from '../caches';
 import { combineAudioDataAndClosePrevious } from '../convert-audiodata/combine-audiodata';
 import { convertAudioData } from '../convert-audiodata/convert-audiodata';
 import { TARGET_NUMBER_OF_CHANNELS, TARGET_SAMPLE_RATE, } from '../convert-audiodata/resample-audiodata';
-import { sinkPromises } from '../video-extraction/extract-frame';
-import { getSinks } from '../video-extraction/get-frames-since-keyframe';
-export const extractAudio = async ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, logLevel, loop, playbackRate, }) => {
-    if (!sinkPromises[src]) {
-        sinkPromises[src] = getSinks(src);
-    }
-    const { audio, actualMatroskaTimestamps, isMatroska, getDuration } = await sinkPromises[src];
+import { getSinkWeak } from '../get-sink-weak';
+export const extractAudio = async ({ src, timeInSeconds: unloopedTimeInSeconds, durationInSeconds, logLevel, loop, playbackRate, audioStreamIndex, }) => {
+    const { getAudio, actualMatroskaTimestamps, isMatroska, getDuration } = await getSinkWeak(src, logLevel);
     let duration = null;
     if (loop) {
         duration = await getDuration();
     }
-    if (audio === null) {
+    const audio = await getAudio(audioStreamIndex);
+    if (audio === 'no-audio-track') {
         return { data: null, durationInSeconds: null };
     }
+    if (audio === 'cannot-decode-audio') {
+        return 'cannot-decode';
+    }
+    if (audio === 'unknown-container-format') {
+        return 'unknown-container-format';
+    }
     const timeInSeconds = loop
         ? unloopedTimeInSeconds % duration
         : unloopedTimeInSeconds;
@@ -28,7 +31,7 @@ export const extractAudio = async ({ src, timeInSeconds: unloopedTimeInSeconds,
         logLevel,
     });
     const samples = await sampleIterator.getSamples(timeInSeconds, durationInSeconds);
-    audioManager.logOpenFrames(logLevel);
+    audioManager.logOpenFrames();
     const audioDataArray = [];
     for (let i = 0; i < samples.length; i++) {
         const sample = samples[i];

package/dist/caches.d.ts

@@ -20,18 +20,19 @@ export declare const keyframeManager: {
     clearAll: () => Promise<void>;
 };
 export declare const audioManager: {
-    makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, }: {
+    makeIterator: ({ timeInSeconds, src, audioSampleSink, isMatroska, actualMatroskaTimestamps, logLevel, }: {
         timeInSeconds: number;
         src: string;
         audioSampleSink: import("mediabunny").AudioSampleSink;
         isMatroska: boolean;
         actualMatroskaTimestamps: import("./video-extraction/remember-actual-matroska-timestamps").RememberActualMatroskaTimestamps;
+        logLevel: LogLevel;
     }) => {
         src: string;
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: LogLevel) => void;
+        logOpenFrames: () => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -52,7 +53,7 @@ export declare const audioManager: {
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: LogLevel) => void;
+        logOpenFrames: () => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -70,7 +71,7 @@ export declare const audioManager: {
         getSamples: (ts: number, dur: number) => Promise<import("mediabunny").AudioSample[]>;
         waitForCompletion: () => Promise<boolean>;
         canSatisfyRequestedTime: (timestamp: number) => boolean;
-        logOpenFrames: (logLevel: LogLevel) => void;
+        logOpenFrames: () => void;
         getCacheStats: () => {
             count: number;
             size: number;
@@ -79,7 +80,7 @@ export declare const audioManager: {
         prepareForDeletion: () => Promise<void>;
         startTimestamp: number;
     } | null;
-    logOpenFrames: (logLevel: LogLevel) => void;
+    logOpenFrames: () => void;
 };
 export declare const getTotalCacheStats: () => Promise<{
     count: number;

package/dist/convert-audiodata/apply-tonefrequency.d.ts

@@ -0,0 +1,2 @@
+import { type PcmS16AudioData } from './convert-audiodata';
+export declare const applyToneFrequency: (audioData: PcmS16AudioData, toneFrequency: number) => PcmS16AudioData;

package/dist/convert-audiodata/apply-tonefrequency.js

@@ -0,0 +1,44 @@
+import { FORMAT } from './convert-audiodata';
+import { resampleAudioData, TARGET_SAMPLE_RATE } from './resample-audiodata';
+import { wsolaInt16Interleaved } from './wsola';
+export const applyToneFrequency = (audioData, toneFrequency) => {
+    // In FFmpeg, we apply toneFrequency as follows:
+    // `asetrate=${DEFAULT_SAMPLE_RATE}*${toneFrequency},aresample=${DEFAULT_SAMPLE_RATE},atempo=1/${toneFrequency}`
+    // So there are 2 steps:
+    // 1. Change the assumed sample rate
+    // 2. Resample to 48Khz
+    // 3. Apply playback rate
+    const step1 = {
+        ...audioData,
+        sampleRate: audioData.sampleRate * toneFrequency,
+    };
+    const newNumberOfFrames = Math.round(audioData.numberOfFrames * (TARGET_SAMPLE_RATE / step1.sampleRate));
+    const step2Data = new Int16Array(newNumberOfFrames * audioData.numberOfChannels);
+    const chunkSize = audioData.numberOfFrames / newNumberOfFrames;
+    resampleAudioData({
+        srcNumberOfChannels: step1.numberOfChannels,
+        sourceChannels: step1.data,
+        destination: step2Data,
+        targetFrames: newNumberOfFrames,
+        chunkSize,
+    });
+    const step2AudioData = {
+        data: step2Data,
+        format: FORMAT,
+        numberOfChannels: step1.numberOfChannels,
+        numberOfFrames: newNumberOfFrames,
+        sampleRate: TARGET_SAMPLE_RATE,
+        timestamp: audioData.timestamp,
+    };
+    const step3Data = wsolaInt16Interleaved(step2AudioData.data, step2AudioData.numberOfChannels, toneFrequency);
+    // Target per-channel length and interleave
+    const targetPerChan = Math.max(1, Math.round(step2AudioData.numberOfFrames * toneFrequency));
+    const targetTotal = targetPerChan * step2AudioData.numberOfChannels;
+    return {
+        data: step3Data,
+        numberOfChannels: step2AudioData.numberOfChannels,
+        numberOfFrames: targetTotal,
+        sampleRate: TARGET_SAMPLE_RATE,
+        timestamp: audioData.timestamp,
+    };
+};

package/dist/convert-audiodata/wsola.d.ts

@@ -0,0 +1,13 @@
+/**
+ * WSOLA time-scale modification for interleaved Int16 PCM (multi-channel).
+ * - Preserves pitch approximately while changing tempo by factor f.
+ * - Works for N interleaved channels.
+ * - Mitigates head/tail fade-out via overlap-weight normalization and boundary reinforcement.
+ *
+ * @param input Interleaved Int16 PCM (e.g., LRLRLR... for stereo)
+ * @param channels Number of channels (>=1)
+ * @param f Tempo factor: >1 = faster/shorter, <1 = slower/longer
+ * @param opts Optional tuning parameters
+ * @returns Interleaved Int16Array with length ≈ round(input.length * f)
+ */
+export declare function wsolaInt16Interleaved(input: Int16Array, channels: number, f: number): Int16Array;

package/dist/convert-audiodata/wsola.js

@@ -0,0 +1,197 @@
+function clamp16(x) {
+    const y = Math.round(x);
+    return y < -32768 ? -32768 : y > 32767 ? 32767 : y;
+}
+/**
+ * WSOLA time-scale modification for interleaved Int16 PCM (multi-channel).
+ * - Preserves pitch approximately while changing tempo by factor f.
+ * - Works for N interleaved channels.
+ * - Mitigates head/tail fade-out via overlap-weight normalization and boundary reinforcement.
+ *
+ * @param input Interleaved Int16 PCM (e.g., LRLRLR... for stereo)
+ * @param channels Number of channels (>=1)
+ * @param f Tempo factor: >1 = faster/shorter, <1 = slower/longer
+ * @param opts Optional tuning parameters
+ * @returns Interleaved Int16Array with length ≈ round(input.length * f)
+ */
+export function wsolaInt16Interleaved(input, channels, f) {
+    if (!Number.isFinite(f) || f <= 0)
+        throw new Error('f must be a positive finite number');
+    if (!Number.isInteger(channels) || channels <= 0)
+        throw new Error('channels must be a positive integer');
+    const n = input.length;
+    if (n === 0)
+        return new Int16Array(0);
+    if (n % channels !== 0)
+        throw new Error('input length must be a multiple of channels');
+    // Parameters and sensible defaults
+    const sampleRate = 48000;
+    const frameMs = 30; // 20–40 ms typical
+    const overlapRatio = 0.5;
+    const searchMs = 15; // +/- 8 ms local search
+    const winKind = 'hann';
+    const headReinf = 3;
+    const tailReinf = 3;
+    // Work per-channel
+    const samplesPerChannel = (n / channels) | 0;
+    // Frame and hop sizing
+    const frameSize = Math.max(128, Math.floor((sampleRate * frameMs) / 1000));
+    const overlap = Math.floor(frameSize * overlapRatio);
+    const anaHop = Math.max(1, frameSize - overlap);
+    const synHop = Math.max(1, Math.round(anaHop * f));
+    // Search radius in samples
+    const searchRadius = Math.max(0, Math.floor((sampleRate * searchMs) / 1000));
+    // Window
+    const win = new Float32Array(frameSize);
+    for (let i = 0; i < frameSize; i++) {
+        const x = (Math.PI * 2 * i) / (frameSize - 1);
+        win[i] =
+            winKind === 'hann' ? 0.5 * (1 - Math.cos(x)) : 0.54 - 0.46 * Math.cos(x); // Hamming
+    }
+    // Estimate output length per channel and allocate with extra headroom
+    const estFrames = Math.max(1, Math.ceil(Math.max(0, samplesPerChannel - frameSize) / anaHop) + 1);
+    const estLen = Math.max(0, frameSize + synHop * (estFrames - 1));
+    const extraHead = frameSize * (headReinf + 1);
+    const extraTail = frameSize * (tailReinf + 2);
+    const outLenAlloc = estLen + searchRadius + extraHead + extraTail;
+    const out = Array.from({ length: channels }, () => new Float32Array(outLenAlloc));
+    const outWeight = new Float32Array(outLenAlloc);
+    // Temporary buffers
+    const chanFrames = Array.from({ length: channels }, () => new Float32Array(frameSize));
+    const guideFrame = new Float32Array(frameSize);
+    // Helpers
+    function readChannelFrame(chan, start, dst) {
+        let srcIndex = start * channels + chan;
+        for (let i = 0; i < frameSize; i++) {
+            const pos = start + i;
+            dst[i] = pos >= 0 && pos < samplesPerChannel ? input[srcIndex] : 0;
+            srcIndex += channels;
+        }
+    }
+    function readGuideFrame(start) {
+        for (let i = 0; i < frameSize; i++) {
+            const pos = start + i;
+            if (pos >= 0 && pos < samplesPerChannel) {
+                let sum = 0;
+                const base = pos * channels;
+                for (let c = 0; c < channels; c++)
+                    sum += input[base + c];
+                guideFrame[i] = sum / channels;
+            }
+            else {
+                guideFrame[i] = 0;
+            }
+        }
+    }
+    // Find best local alignment around outPos using normalized cross-correlation
+    function bestAlignment(outPoss) {
+        let bestShift = 0;
+        let bestScore = -Infinity;
+        for (let shift = -searchRadius; shift <= searchRadius; shift++) {
+            const pos = outPoss + shift - overlap;
+            let score = 0;
+            let normA = 0;
+            let normB = 0;
+            for (let i = 0; i < overlap; i++) {
+                const idx = pos + i;
+                const outVal = idx >= 0 && idx < outLenAlloc ? out[0][idx] : 0; // channel 0 proxy
+                const frmVal = guideFrame[i];
+                score += outVal * frmVal;
+                normA += outVal * outVal;
+                normB += frmVal * frmVal;
+            }
+            const denom = Math.sqrt((normA || 1e-9) * (normB || 1e-9));
+            const corr = score / denom;
+            if (corr > bestScore) {
+                bestScore = corr;
+                bestShift = shift;
+            }
+        }
+        return bestShift;
+    }
+    // Overlap-add a frame for all channels at writeStart with windowing
+    function olaAllChannels(writeStart) {
+        for (let c = 0; c < channels; c++) {
+            for (let i = 0; i < frameSize; i++) {
+                const idx = writeStart + i;
+                if (idx >= 0 && idx < outLenAlloc) {
+                    const w = win[i];
+                    out[c][idx] += chanFrames[c][i] * w;
+                    if (c === 0)
+                        outWeight[idx] += w; // track weights once
+                }
+            }
+        }
+    }
+    // 1) Seed: place the first frame at t=0
+    readGuideFrame(0);
+    for (let c = 0; c < channels; c++)
+        readChannelFrame(c, 0, chanFrames[c]);
+    olaAllChannels(0);
+    // 2) Head reinforcement: place extra frames whose writeStart <= 0
+    for (let h = 0; h < headReinf; h++) {
+        // Option 1: reuse the first analysis position to strengthen early region
+        const headIn = Math.min(anaHop * h, Math.max(0, samplesPerChannel - frameSize));
+        readGuideFrame(headIn);
+        for (let c = 0; c < channels; c++)
+            readChannelFrame(c, headIn, chanFrames[c]);
+        // Align around outPos=0 so we bias writeStart near/before 0
+        const shift = bestAlignment(0);
+        const writeStart = shift - overlap; // likely negative; ok, we clamp on write
+        olaAllChannels(writeStart);
+    }
+    // 3) Main WSOLA loop
+    let inPos = anaHop; // next analysis position (we already seeded at 0)
+    let outPos = synHop; // next synthesis position
+    while (inPos < samplesPerChannel - 1) {
+        readGuideFrame(inPos);
+        for (let c = 0; c < channels; c++)
+            readChannelFrame(c, inPos, chanFrames[c]);
+        const shift = bestAlignment(outPos);
+        const writeStart = outPos + shift - overlap;
+        olaAllChannels(writeStart);
+        inPos += anaHop;
+        outPos += synHop;
+        // Safety: if we're very close to capacity, break to handle tail separately
+        if (outPos > outLenAlloc - (frameSize + searchRadius + 8))
+            break;
+    }
+    // 4) Tail reinforcement: ensure the end gets full coverage
+    // Place a few extra frames around the last outPos using the last available input frames.
+    for (let t = 0; t < tailReinf; t++) {
+        const tailIn = Math.max(0, Math.min(samplesPerChannel - frameSize, inPos - anaHop * t));
+        readGuideFrame(tailIn);
+        for (let c = 0; c < channels; c++)
+            readChannelFrame(c, tailIn, chanFrames[c]);
+        const shift = bestAlignment(outPos);
+        const writeStart = outPos + shift - overlap;
+        olaAllChannels(writeStart);
+        outPos += synHop;
+    }
+    // 5) Normalize by accumulated weights BEFORE trimming
+    for (let i = 0; i < outLenAlloc; i++) {
+        const w = outWeight[i];
+        if (w > 1e-9) {
+            const inv = 1 / w;
+            for (let c = 0; c < channels; c++)
+                out[c][i] *= inv;
+        }
+        else {
+            for (let c = 0; c < channels; c++)
+                out[c][i] = 0;
+        }
+    }
+    // 6) Produce final interleaved Int16Array with length ≈ round(n * f)
+    const targetPerChan = Math.max(1, Math.round(samplesPerChannel * f));
+    const targetTotal = targetPerChan * channels;
+    const result = new Int16Array(targetTotal);
+    // Interleave and clamp/round
+    for (let i = 0; i < targetPerChan; i++) {
+        for (let c = 0; c < channels; c++) {
+            const v = i < out[c].length ? out[c][i] : 0;
+            const y = clamp16(v);
+            result[i * channels + c] = y;
+        }
+    }
+    return result;
+}