@remotion/timeline-utils 4.0.460 → 4.0.462

package/dist/audio-waveform/audio-waveform-worker-types.d.ts

@@ -0,0 +1,28 @@
+import type { TimelineLoopDisplay } from '../loop-display';
+export type AudioWaveformWorkerInitMessage = {
+    readonly type: 'init';
+    readonly canvas: OffscreenCanvas;
+};
+export type AudioWaveformWorkerRenderMessage = {
+    readonly type: 'render';
+    readonly requestId: number;
+    readonly src: string;
+    readonly width: number;
+    readonly height: number;
+    readonly volume: number;
+    readonly startFrom: number;
+    readonly durationInFrames: number;
+    readonly fps: number;
+    readonly playbackRate: number;
+    readonly loopDisplay: TimelineLoopDisplay | undefined;
+};
+export type AudioWaveformWorkerDisposeMessage = {
+    readonly type: 'dispose';
+};
+export type AudioWaveformWorkerIncomingMessage = AudioWaveformWorkerInitMessage | AudioWaveformWorkerRenderMessage | AudioWaveformWorkerDisposeMessage;
+export type AudioWaveformWorkerErrorMessage = {
+    readonly type: 'error';
+    readonly requestId: number;
+    readonly message: string;
+};
+export type AudioWaveformWorkerOutgoingMessage = AudioWaveformWorkerErrorMessage;

package/dist/audio-waveform/audio-waveform-worker-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/audio-waveform/constants.d.ts

@@ -0,0 +1 @@
+export declare const TARGET_SAMPLE_RATE = 100;

package/dist/audio-waveform/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TARGET_SAMPLE_RATE = void 0;
+exports.TARGET_SAMPLE_RATE = 100;

package/dist/audio-waveform/draw-peaks.d.ts

@@ -0,0 +1,7 @@
+export declare const drawBars: ({ canvas, color, peaks, volume, width, }: {
+    readonly canvas: HTMLCanvasElement | OffscreenCanvas;
+    readonly peaks: Float32Array<ArrayBufferLike>;
+    readonly color: string;
+    readonly volume: number;
+    readonly width: number;
+}) => void;

package/dist/audio-waveform/draw-peaks.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawBars = void 0;
+const parse_color_1 = require("./parse-color");
+const CLIPPING_COLOR = '#FF7F50';
+const drawBars = ({ canvas, color, peaks, volume, width, }) => {
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to get canvas context');
+    }
+    const { height } = canvas;
+    const w = canvas.width;
+    // Skip drawing when the target canvas has not been laid out yet.
+    // `createImageData(0, h)` / `(w, 0)` throws a DOMException, which
+    // surfaces in Studio's console for compositions with many audio
+    // sequences — some segments are 0 px wide at certain zoom levels.
+    if (w === 0 || height === 0) {
+        return;
+    }
+    ctx.clearRect(0, 0, w, height);
+    if (volume === 0)
+        return;
+    const [r, g, b, a] = (0, parse_color_1.parseColor)(color);
+    const [cr, cg, cb, ca] = (0, parse_color_1.parseColor)(CLIPPING_COLOR);
+    const imageData = ctx.createImageData(w, height);
+    const { data } = imageData;
+    const numBars = width;
+    for (let barIndex = 0; barIndex < numBars; barIndex++) {
+        const x = barIndex;
+        if (x >= w)
+            break;
+        const peakIndex = Math.floor((barIndex / numBars) * peaks.length);
+        const peak = peaks[peakIndex] || 0;
+        const scaledPeak = peak * volume;
+        const halfBar = Math.max(0, Math.min(height / 2, (scaledPeak * height) / 2));
+        if (halfBar === 0)
+            continue;
+        const mid = height / 2;
+        const barY = Math.round(mid - halfBar);
+        const barEnd = Math.round(mid + halfBar);
+        const isClipping = scaledPeak > 1;
+        const clipTopEnd = isClipping ? Math.min(barY + 2, barEnd) : barY;
+        const clipBotStart = isClipping ? Math.max(barEnd - 2, barY) : barEnd;
+        for (let y = barY; y < clipTopEnd; y++) {
+            const idx = (y * w + x) * 4;
+            data[idx] = cr;
+            data[idx + 1] = cg;
+            data[idx + 2] = cb;
+            data[idx + 3] = ca;
+        }
+        for (let y = clipTopEnd; y < clipBotStart; y++) {
+            const idx = (y * w + x) * 4;
+            data[idx] = r;
+            data[idx + 1] = g;
+            data[idx + 2] = b;
+            data[idx + 3] = a;
+        }
+        for (let y = clipBotStart; y < barEnd; y++) {
+            const idx = (y * w + x) * 4;
+            data[idx] = cr;
+            data[idx + 1] = cg;
+            data[idx + 2] = cb;
+            data[idx + 3] = ca;
+        }
+    }
+    ctx.putImageData(imageData, 0, 0);
+};
+exports.drawBars = drawBars;

package/dist/audio-waveform/load-waveform-peaks.d.ts

@@ -0,0 +1,13 @@
+import { TARGET_SAMPLE_RATE } from './constants';
+export { TARGET_SAMPLE_RATE };
+type Progress = {
+    readonly peaks: Float32Array;
+    readonly completedPeaks: number;
+    readonly totalPeaks: number;
+    readonly final: boolean;
+};
+type LoadWaveformPeaksOptions = {
+    readonly onProgress?: (progress: Progress) => void;
+    readonly progressIntervalInMs?: number;
+};
+export declare function loadWaveformPeaks(url: string, signal: AbortSignal, options?: LoadWaveformPeaksOptions): Promise<Float32Array>;

package/dist/audio-waveform/load-waveform-peaks.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TARGET_SAMPLE_RATE = void 0;
+exports.loadWaveformPeaks = loadWaveformPeaks;
+const mediabunny_1 = require("mediabunny");
+const constants_1 = require("./constants");
+Object.defineProperty(exports, "TARGET_SAMPLE_RATE", { enumerable: true, get: function () { return constants_1.TARGET_SAMPLE_RATE; } });
+const waveform_peak_processor_1 = require("./waveform-peak-processor");
+const DEFAULT_PROGRESS_INTERVAL_IN_MS = 50;
+const peaksCache = new Map();
+async function loadWaveformPeaks(url, signal, options) {
+    var _a, _b;
+    const cached = peaksCache.get(url);
+    if (cached) {
+        (0, waveform_peak_processor_1.emitWaveformProgress)({
+            peaks: cached,
+            completedPeaks: cached.length,
+            totalPeaks: cached.length,
+            final: true,
+            onProgress: options === null || options === void 0 ? void 0 : options.onProgress,
+        });
+        return cached;
+    }
+    const input = new mediabunny_1.Input({
+        formats: mediabunny_1.ALL_FORMATS,
+        source: new mediabunny_1.UrlSource(url),
+    });
+    try {
+        const audioTrack = await input.getPrimaryAudioTrack();
+        if (!audioTrack) {
+            return new Float32Array(0);
+        }
+        if (await audioTrack.isLive()) {
+            throw new Error('Live streams are not currently supported by Remotion. Sorry! Source: ' +
+                url);
+        }
+        if (await audioTrack.isRelativeToUnixEpoch()) {
+            throw new Error('Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: ' +
+                url);
+        }
+        const sampleRate = await audioTrack.getSampleRate();
+        const durationInSeconds = (_a = (await audioTrack.getDurationFromMetadata({ skipLiveWait: true }))) !== null && _a !== void 0 ? _a : (await audioTrack.computeDuration({ skipLiveWait: true }));
+        const totalPeaks = Math.ceil(durationInSeconds * constants_1.TARGET_SAMPLE_RATE);
+        const samplesPerPeak = Math.max(1, Math.floor(sampleRate / constants_1.TARGET_SAMPLE_RATE));
+        const sink = new mediabunny_1.AudioSampleSink(audioTrack);
+        const processor = (0, waveform_peak_processor_1.createWaveformPeakProcessor)({
+            totalPeaks,
+            samplesPerPeak,
+            onProgress: options === null || options === void 0 ? void 0 : options.onProgress,
+            progressIntervalInMs: (_b = options === null || options === void 0 ? void 0 : options.progressIntervalInMs) !== null && _b !== void 0 ? _b : DEFAULT_PROGRESS_INTERVAL_IN_MS,
+            now: () => Date.now(),
+        });
+        for await (const sample of sink.samples()) {
+            if (signal.aborted) {
+                sample.close();
+                return new Float32Array(0);
+            }
+            const bytesNeeded = sample.allocationSize({
+                format: 'f32',
+                planeIndex: 0,
+            });
+            const floats = new Float32Array(bytesNeeded / 4);
+            sample.copyTo(floats, { format: 'f32', planeIndex: 0 });
+            const channels = Math.max(1, sample.numberOfChannels);
+            sample.close();
+            processor.processSampleChunk(floats, channels);
+        }
+        processor.finalize();
+        const { peaks } = processor;
+        peaksCache.set(url, peaks);
+        return peaks;
+    }
+    finally {
+        input.dispose();
+    }
+}

package/dist/audio-waveform/make-audio-waveform-worker.d.ts

@@ -0,0 +1 @@
+export declare const makeAudioWaveformWorker: () => Worker;

package/dist/audio-waveform/make-audio-waveform-worker.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeAudioWaveformWorker = void 0;
+const makeAudioWaveformWorker = () => {
+    // @ts-expect-error `import.meta.url` is required for bundling the worker entry.
+    return new Worker(new URL('./audio-waveform-worker.mjs', import.meta.url), {
+        type: 'module',
+    });
+};
+exports.makeAudioWaveformWorker = makeAudioWaveformWorker;

package/dist/audio-waveform/parse-color.d.ts

@@ -0,0 +1 @@
+export declare const parseColor: (color: string) => [number, number, number, number];

package/dist/audio-waveform/parse-color.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseColor = void 0;
+const colorCache = new Map();
+const parseColor = (color) => {
+    const cached = colorCache.get(color);
+    if (cached)
+        return cached;
+    const ctx = new OffscreenCanvas(1, 1).getContext('2d');
+    ctx.fillStyle = color;
+    ctx.fillRect(0, 0, 1, 1);
+    const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data;
+    const result = [r, g, b, a];
+    colorCache.set(color, result);
+    return result;
+};
+exports.parseColor = parseColor;

package/dist/audio-waveform/slice-waveform-peaks.d.ts

@@ -0,0 +1,7 @@
+export declare const sliceWaveformPeaks: ({ durationInFrames, fps, peaks, playbackRate, startFrom, }: {
+    readonly peaks: Float32Array<ArrayBufferLike>;
+    readonly startFrom: number;
+    readonly durationInFrames: number;
+    readonly fps: number;
+    readonly playbackRate: number;
+}) => Float32Array<ArrayBufferLike>;

package/dist/audio-waveform/slice-waveform-peaks.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceWaveformPeaks = void 0;
+const constants_1 = require("./constants");
+const sliceWaveformPeaks = ({ durationInFrames, fps, peaks, playbackRate, startFrom, }) => {
+    if (peaks.length === 0) {
+        return peaks;
+    }
+    const startTimeInSeconds = startFrom / fps;
+    const durationInSeconds = (durationInFrames / fps) * playbackRate;
+    const startPeakIndex = Math.floor(startTimeInSeconds * constants_1.TARGET_SAMPLE_RATE);
+    const endPeakIndex = Math.ceil((startTimeInSeconds + durationInSeconds) * constants_1.TARGET_SAMPLE_RATE);
+    return peaks.subarray(Math.max(0, startPeakIndex), Math.min(peaks.length, endPeakIndex));
+};
+exports.sliceWaveformPeaks = sliceWaveformPeaks;

package/dist/audio-waveform/waveform-peak-processor.d.ts

@@ -0,0 +1,23 @@
+type Progress = {
+    readonly peaks: Float32Array;
+    readonly completedPeaks: number;
+    readonly totalPeaks: number;
+    readonly final: boolean;
+};
+type WaveformPeakProcessorOptions = {
+    readonly totalPeaks: number;
+    readonly samplesPerPeak: number;
+    readonly onProgress?: (progress: Progress) => void;
+    readonly progressIntervalInMs: number;
+    readonly now: () => number;
+};
+type WaveformPeakProcessor = {
+    readonly peaks: Float32Array;
+    processSampleChunk: (floats: Float32Array, channels: number) => void;
+    finalize: () => void;
+};
+export declare const emitWaveformProgress: ({ completedPeaks, final, onProgress, peaks, totalPeaks, }: Progress & {
+    readonly onProgress?: ((progress: Progress) => void) | undefined;
+}) => void;
+export declare const createWaveformPeakProcessor: ({ totalPeaks, samplesPerPeak, onProgress, progressIntervalInMs, now, }: WaveformPeakProcessorOptions) => WaveformPeakProcessor;
+export {};

package/dist/audio-waveform/waveform-peak-processor.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWaveformPeakProcessor = exports.emitWaveformProgress = void 0;
+const emitWaveformProgress = ({ completedPeaks, final, onProgress, peaks, totalPeaks, }) => {
+    onProgress === null || onProgress === void 0 ? void 0 : onProgress({
+        peaks,
+        completedPeaks,
+        totalPeaks,
+        final,
+    });
+};
+exports.emitWaveformProgress = emitWaveformProgress;
+const createWaveformPeakProcessor = ({ totalPeaks, samplesPerPeak, onProgress, progressIntervalInMs, now, }) => {
+    const peaks = new Float32Array(totalPeaks);
+    let peakIndex = 0;
+    let peakMax = 0;
+    let sampleInPeak = 0;
+    let lastProgressAt = 0;
+    let lastProgressPeak = 0;
+    const emitProgress = (force) => {
+        const timestamp = now();
+        if (!force && peakIndex === lastProgressPeak && sampleInPeak === 0) {
+            return;
+        }
+        if (!force && timestamp - lastProgressAt < progressIntervalInMs) {
+            return;
+        }
+        lastProgressAt = timestamp;
+        lastProgressPeak = peakIndex;
+        (0, exports.emitWaveformProgress)({
+            peaks,
+            completedPeaks: peakIndex,
+            totalPeaks,
+            final: force,
+            onProgress,
+        });
+    };
+    return {
+        peaks,
+        processSampleChunk: (floats, channels) => {
+            var _a;
+            const frameCount = Math.floor(floats.length / Math.max(1, channels));
+            for (let frame = 0; frame < frameCount; frame++) {
+                // `f32` copies are interleaved, so timing advances per frame.
+                let framePeak = 0;
+                for (let channel = 0; channel < channels; channel++) {
+                    const sampleIndex = frame * channels + channel;
+                    const abs = Math.abs((_a = floats[sampleIndex]) !== null && _a !== void 0 ? _a : 0);
+                    if (abs > framePeak) {
+                        framePeak = abs;
+                    }
+                }
+                if (framePeak > peakMax) {
+                    peakMax = framePeak;
+                }
+                sampleInPeak++;
+                if (sampleInPeak >= samplesPerPeak) {
+                    if (peakIndex < totalPeaks) {
+                        peaks[peakIndex] = peakMax;
+                    }
+                    peakIndex++;
+                    peakMax = 0;
+                    sampleInPeak = 0;
+                }
+            }
+            emitProgress(false);
+        },
+        finalize: () => {
+            if (sampleInPeak > 0 && peakIndex < totalPeaks) {
+                peaks[peakIndex] = peakMax;
+                peakIndex++;
+            }
+            emitProgress(true);
+        },
+    };
+};
+exports.createWaveformPeakProcessor = createWaveformPeakProcessor;

package/dist/audio-waveform-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/audio-waveform-worker.js

@@ -0,0 +1,114 @@
+"use strict";
+/// <reference lib="webworker" />
+Object.defineProperty(exports, "__esModule", { value: true });
+const draw_peaks_1 = require("./audio-waveform/draw-peaks");
+const load_waveform_peaks_1 = require("./audio-waveform/load-waveform-peaks");
+const slice_waveform_peaks_1 = require("./audio-waveform/slice-waveform-peaks");
+const loop_display_1 = require("./loop-display");
+let canvas = null;
+let currentController = null;
+let latestRequestId = 0;
+const postError = (requestId, error) => {
+    const message = error instanceof Error ? error.message : 'Failed to render waveform';
+    const payload = {
+        type: 'error',
+        requestId,
+        message,
+    };
+    self.postMessage(payload);
+};
+const drawPartialWaveform = (message, peaks) => {
+    if (!canvas) {
+        return;
+    }
+    const portionPeaks = (0, slice_waveform_peaks_1.sliceWaveformPeaks)({
+        durationInFrames: (0, loop_display_1.shouldTileLoopDisplay)(message.loopDisplay)
+            ? message.loopDisplay.durationInFrames
+            : message.durationInFrames,
+        fps: message.fps,
+        peaks,
+        playbackRate: message.playbackRate,
+        startFrom: message.startFrom,
+    });
+    if (!(0, loop_display_1.shouldTileLoopDisplay)(message.loopDisplay)) {
+        (0, draw_peaks_1.drawBars)({
+            canvas,
+            peaks: portionPeaks,
+            color: 'rgba(255, 255, 255, 0.6)',
+            volume: message.volume,
+            width: message.width,
+        });
+        return;
+    }
+    const loopWidth = (0, loop_display_1.getLoopDisplayWidth)({
+        visualizationWidth: message.width,
+        loopDisplay: message.loopDisplay,
+    });
+    const targetCanvas = new OffscreenCanvas(Math.max(1, Math.ceil(loopWidth)), message.height);
+    (0, draw_peaks_1.drawBars)({
+        canvas: targetCanvas,
+        peaks: portionPeaks,
+        color: 'rgba(255, 255, 255, 0.6)',
+        volume: message.volume,
+        width: targetCanvas.width,
+    });
+    const ctx = canvas.getContext('2d');
+    if (!ctx) {
+        throw new Error('Failed to get canvas context');
+    }
+    const pattern = ctx.createPattern(targetCanvas, 'repeat-x');
+    if (!pattern) {
+        return;
+    }
+    pattern.setTransform(new DOMMatrix().scaleSelf(loopWidth / targetCanvas.width, 1));
+    ctx.clearRect(0, 0, message.width, message.height);
+    ctx.fillStyle = pattern;
+    ctx.fillRect(0, 0, message.width, message.height);
+};
+const renderWaveform = async (message) => {
+    if (!canvas) {
+        postError(message.requestId, new Error('Waveform canvas not initialized'));
+        return;
+    }
+    const controller = new AbortController();
+    currentController === null || currentController === void 0 ? void 0 : currentController.abort();
+    currentController = controller;
+    latestRequestId = message.requestId;
+    try {
+        canvas.width = message.width;
+        canvas.height = message.height;
+        const peaks = await (0, load_waveform_peaks_1.loadWaveformPeaks)(message.src, controller.signal, {
+            onProgress: ({ peaks: nextPeaks }) => {
+                if (controller.signal.aborted ||
+                    latestRequestId !== message.requestId) {
+                    return;
+                }
+                drawPartialWaveform(message, nextPeaks);
+            },
+        });
+        if (controller.signal.aborted || latestRequestId !== message.requestId) {
+            return;
+        }
+        drawPartialWaveform(message, peaks);
+    }
+    catch (error) {
+        if (controller.signal.aborted || latestRequestId !== message.requestId) {
+            return;
+        }
+        postError(message.requestId, error);
+    }
+};
+self.addEventListener('message', (event) => {
+    const message = event.data;
+    if (message.type === 'init') {
+        canvas = message.canvas;
+        return;
+    }
+    if (message.type === 'dispose') {
+        currentController === null || currentController === void 0 ? void 0 : currentController.abort();
+        currentController = null;
+        canvas = null;
+        return;
+    }
+    renderWaveform(message);
+});

package/dist/esm/audio-waveform-worker.mjs

@@ -0,0 +1,374 @@
+// src/audio-waveform/parse-color.ts
+var colorCache = new Map;
+var parseColor = (color) => {
+  const cached = colorCache.get(color);
+  if (cached)
+    return cached;
+  const ctx = new OffscreenCanvas(1, 1).getContext("2d");
+  ctx.fillStyle = color;
+  ctx.fillRect(0, 0, 1, 1);
+  const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data;
+  const result = [r, g, b, a];
+  colorCache.set(color, result);
+  return result;
+};
+
+// src/audio-waveform/draw-peaks.ts
+var CLIPPING_COLOR = "#FF7F50";
+var drawBars = ({
+  canvas,
+  color,
+  peaks,
+  volume,
+  width
+}) => {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get canvas context");
+  }
+  const { height } = canvas;
+  const w = canvas.width;
+  if (w === 0 || height === 0) {
+    return;
+  }
+  ctx.clearRect(0, 0, w, height);
+  if (volume === 0)
+    return;
+  const [r, g, b, a] = parseColor(color);
+  const [cr, cg, cb, ca] = parseColor(CLIPPING_COLOR);
+  const imageData = ctx.createImageData(w, height);
+  const { data } = imageData;
+  const numBars = width;
+  for (let barIndex = 0;barIndex < numBars; barIndex++) {
+    const x = barIndex;
+    if (x >= w)
+      break;
+    const peakIndex = Math.floor(barIndex / numBars * peaks.length);
+    const peak = peaks[peakIndex] || 0;
+    const scaledPeak = peak * volume;
+    const halfBar = Math.max(0, Math.min(height / 2, scaledPeak * height / 2));
+    if (halfBar === 0)
+      continue;
+    const mid = height / 2;
+    const barY = Math.round(mid - halfBar);
+    const barEnd = Math.round(mid + halfBar);
+    const isClipping = scaledPeak > 1;
+    const clipTopEnd = isClipping ? Math.min(barY + 2, barEnd) : barY;
+    const clipBotStart = isClipping ? Math.max(barEnd - 2, barY) : barEnd;
+    for (let y = barY;y < clipTopEnd; y++) {
+      const idx = (y * w + x) * 4;
+      data[idx] = cr;
+      data[idx + 1] = cg;
+      data[idx + 2] = cb;
+      data[idx + 3] = ca;
+    }
+    for (let y = clipTopEnd;y < clipBotStart; y++) {
+      const idx = (y * w + x) * 4;
+      data[idx] = r;
+      data[idx + 1] = g;
+      data[idx + 2] = b;
+      data[idx + 3] = a;
+    }
+    for (let y = clipBotStart;y < barEnd; y++) {
+      const idx = (y * w + x) * 4;
+      data[idx] = cr;
+      data[idx + 1] = cg;
+      data[idx + 2] = cb;
+      data[idx + 3] = ca;
+    }
+  }
+  ctx.putImageData(imageData, 0, 0);
+};
+
+// src/audio-waveform/load-waveform-peaks.ts
+import { ALL_FORMATS, AudioSampleSink, Input, UrlSource } from "mediabunny";
+
+// src/audio-waveform/constants.ts
+var TARGET_SAMPLE_RATE = 100;
+
+// src/audio-waveform/waveform-peak-processor.ts
+var emitWaveformProgress = ({
+  completedPeaks,
+  final,
+  onProgress,
+  peaks,
+  totalPeaks
+}) => {
+  onProgress?.({
+    peaks,
+    completedPeaks,
+    totalPeaks,
+    final
+  });
+};
+var createWaveformPeakProcessor = ({
+  totalPeaks,
+  samplesPerPeak,
+  onProgress,
+  progressIntervalInMs,
+  now
+}) => {
+  const peaks = new Float32Array(totalPeaks);
+  let peakIndex = 0;
+  let peakMax = 0;
+  let sampleInPeak = 0;
+  let lastProgressAt = 0;
+  let lastProgressPeak = 0;
+  const emitProgress = (force) => {
+    const timestamp = now();
+    if (!force && peakIndex === lastProgressPeak && sampleInPeak === 0) {
+      return;
+    }
+    if (!force && timestamp - lastProgressAt < progressIntervalInMs) {
+      return;
+    }
+    lastProgressAt = timestamp;
+    lastProgressPeak = peakIndex;
+    emitWaveformProgress({
+      peaks,
+      completedPeaks: peakIndex,
+      totalPeaks,
+      final: force,
+      onProgress
+    });
+  };
+  return {
+    peaks,
+    processSampleChunk: (floats, channels) => {
+      const frameCount = Math.floor(floats.length / Math.max(1, channels));
+      for (let frame = 0;frame < frameCount; frame++) {
+        let framePeak = 0;
+        for (let channel = 0;channel < channels; channel++) {
+          const sampleIndex = frame * channels + channel;
+          const abs = Math.abs(floats[sampleIndex] ?? 0);
+          if (abs > framePeak) {
+            framePeak = abs;
+          }
+        }
+        if (framePeak > peakMax) {
+          peakMax = framePeak;
+        }
+        sampleInPeak++;
+        if (sampleInPeak >= samplesPerPeak) {
+          if (peakIndex < totalPeaks) {
+            peaks[peakIndex] = peakMax;
+          }
+          peakIndex++;
+          peakMax = 0;
+          sampleInPeak = 0;
+        }
+      }
+      emitProgress(false);
+    },
+    finalize: () => {
+      if (sampleInPeak > 0 && peakIndex < totalPeaks) {
+        peaks[peakIndex] = peakMax;
+        peakIndex++;
+      }
+      emitProgress(true);
+    }
+  };
+};
+
+// src/audio-waveform/load-waveform-peaks.ts
+var DEFAULT_PROGRESS_INTERVAL_IN_MS = 50;
+var peaksCache = new Map;
+async function loadWaveformPeaks(url, signal, options) {
+  const cached = peaksCache.get(url);
+  if (cached) {
+    emitWaveformProgress({
+      peaks: cached,
+      completedPeaks: cached.length,
+      totalPeaks: cached.length,
+      final: true,
+      onProgress: options?.onProgress
+    });
+    return cached;
+  }
+  const input = new Input({
+    formats: ALL_FORMATS,
+    source: new UrlSource(url)
+  });
+  try {
+    const audioTrack = await input.getPrimaryAudioTrack();
+    if (!audioTrack) {
+      return new Float32Array(0);
+    }
+    if (await audioTrack.isLive()) {
+      throw new Error("Live streams are not currently supported by Remotion. Sorry! Source: " + url);
+    }
+    if (await audioTrack.isRelativeToUnixEpoch()) {
+      throw new Error("Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: " + url);
+    }
+    const sampleRate = await audioTrack.getSampleRate();
+    const durationInSeconds = await audioTrack.getDurationFromMetadata({ skipLiveWait: true }) ?? await audioTrack.computeDuration({ skipLiveWait: true });
+    const totalPeaks = Math.ceil(durationInSeconds * TARGET_SAMPLE_RATE);
+    const samplesPerPeak = Math.max(1, Math.floor(sampleRate / TARGET_SAMPLE_RATE));
+    const sink = new AudioSampleSink(audioTrack);
+    const processor = createWaveformPeakProcessor({
+      totalPeaks,
+      samplesPerPeak,
+      onProgress: options?.onProgress,
+      progressIntervalInMs: options?.progressIntervalInMs ?? DEFAULT_PROGRESS_INTERVAL_IN_MS,
+      now: () => Date.now()
+    });
+    for await (const sample of sink.samples()) {
+      if (signal.aborted) {
+        sample.close();
+        return new Float32Array(0);
+      }
+      const bytesNeeded = sample.allocationSize({
+        format: "f32",
+        planeIndex: 0
+      });
+      const floats = new Float32Array(bytesNeeded / 4);
+      sample.copyTo(floats, { format: "f32", planeIndex: 0 });
+      const channels = Math.max(1, sample.numberOfChannels);
+      sample.close();
+      processor.processSampleChunk(floats, channels);
+    }
+    processor.finalize();
+    const { peaks } = processor;
+    peaksCache.set(url, peaks);
+    return peaks;
+  } finally {
+    input.dispose();
+  }
+}
+
+// src/audio-waveform/slice-waveform-peaks.ts
+var sliceWaveformPeaks = ({
+  durationInFrames,
+  fps,
+  peaks,
+  playbackRate,
+  startFrom
+}) => {
+  if (peaks.length === 0) {
+    return peaks;
+  }
+  const startTimeInSeconds = startFrom / fps;
+  const durationInSeconds = durationInFrames / fps * playbackRate;
+  const startPeakIndex = Math.floor(startTimeInSeconds * TARGET_SAMPLE_RATE);
+  const endPeakIndex = Math.ceil((startTimeInSeconds + durationInSeconds) * TARGET_SAMPLE_RATE);
+  return peaks.subarray(Math.max(0, startPeakIndex), Math.min(peaks.length, endPeakIndex));
+};
+
+// src/loop-display.ts
+var shouldTileLoopDisplay = (loopDisplay) => {
+  return loopDisplay !== undefined && loopDisplay.numberOfTimes > 1;
+};
+var getLoopDisplayWidth = ({
+  visualizationWidth,
+  loopDisplay
+}) => {
+  if (!shouldTileLoopDisplay(loopDisplay)) {
+    return visualizationWidth;
+  }
+  return visualizationWidth / loopDisplay.numberOfTimes;
+};
+
+// src/audio-waveform-worker.ts
+var canvas = null;
+var currentController = null;
+var latestRequestId = 0;
+var postError = (requestId, error) => {
+  const message = error instanceof Error ? error.message : "Failed to render waveform";
+  const payload = {
+    type: "error",
+    requestId,
+    message
+  };
+  self.postMessage(payload);
+};
+var drawPartialWaveform = (message, peaks) => {
+  if (!canvas) {
+    return;
+  }
+  const portionPeaks = sliceWaveformPeaks({
+    durationInFrames: shouldTileLoopDisplay(message.loopDisplay) ? message.loopDisplay.durationInFrames : message.durationInFrames,
+    fps: message.fps,
+    peaks,
+    playbackRate: message.playbackRate,
+    startFrom: message.startFrom
+  });
+  if (!shouldTileLoopDisplay(message.loopDisplay)) {
+    drawBars({
+      canvas,
+      peaks: portionPeaks,
+      color: "rgba(255, 255, 255, 0.6)",
+      volume: message.volume,
+      width: message.width
+    });
+    return;
+  }
+  const loopWidth = getLoopDisplayWidth({
+    visualizationWidth: message.width,
+    loopDisplay: message.loopDisplay
+  });
+  const targetCanvas = new OffscreenCanvas(Math.max(1, Math.ceil(loopWidth)), message.height);
+  drawBars({
+    canvas: targetCanvas,
+    peaks: portionPeaks,
+    color: "rgba(255, 255, 255, 0.6)",
+    volume: message.volume,
+    width: targetCanvas.width
+  });
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get canvas context");
+  }
+  const pattern = ctx.createPattern(targetCanvas, "repeat-x");
+  if (!pattern) {
+    return;
+  }
+  pattern.setTransform(new DOMMatrix().scaleSelf(loopWidth / targetCanvas.width, 1));
+  ctx.clearRect(0, 0, message.width, message.height);
+  ctx.fillStyle = pattern;
+  ctx.fillRect(0, 0, message.width, message.height);
+};
+var renderWaveform = async (message) => {
+  if (!canvas) {
+    postError(message.requestId, new Error("Waveform canvas not initialized"));
+    return;
+  }
+  const controller = new AbortController;
+  currentController?.abort();
+  currentController = controller;
+  latestRequestId = message.requestId;
+  try {
+    canvas.width = message.width;
+    canvas.height = message.height;
+    const peaks = await loadWaveformPeaks(message.src, controller.signal, {
+      onProgress: ({ peaks: nextPeaks }) => {
+        if (controller.signal.aborted || latestRequestId !== message.requestId) {
+          return;
+        }
+        drawPartialWaveform(message, nextPeaks);
+      }
+    });
+    if (controller.signal.aborted || latestRequestId !== message.requestId) {
+      return;
+    }
+    drawPartialWaveform(message, peaks);
+  } catch (error) {
+    if (controller.signal.aborted || latestRequestId !== message.requestId) {
+      return;
+    }
+    postError(message.requestId, error);
+  }
+};
+self.addEventListener("message", (event) => {
+  const message = event.data;
+  if (message.type === "init") {
+    canvas = message.canvas;
+    return;
+  }
+  if (message.type === "dispose") {
+    currentController?.abort();
+    currentController = null;
+    canvas = null;
+    return;
+  }
+  renderWaveform(message);
+});

package/dist/esm/index.mjs

@@ -1,9 +1,267 @@
+// src/audio-waveform/constants.ts
+var TARGET_SAMPLE_RATE = 100;
+// src/audio-waveform/parse-color.ts
+var colorCache = new Map;
+var parseColor = (color) => {
+  const cached = colorCache.get(color);
+  if (cached)
+    return cached;
+  const ctx = new OffscreenCanvas(1, 1).getContext("2d");
+  ctx.fillStyle = color;
+  ctx.fillRect(0, 0, 1, 1);
+  const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data;
+  const result = [r, g, b, a];
+  colorCache.set(color, result);
+  return result;
+};
+
+// src/audio-waveform/draw-peaks.ts
+var CLIPPING_COLOR = "#FF7F50";
+var drawBars = ({
+  canvas,
+  color,
+  peaks,
+  volume,
+  width
+}) => {
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("Failed to get canvas context");
+  }
+  const { height } = canvas;
+  const w = canvas.width;
+  if (w === 0 || height === 0) {
+    return;
+  }
+  ctx.clearRect(0, 0, w, height);
+  if (volume === 0)
+    return;
+  const [r, g, b, a] = parseColor(color);
+  const [cr, cg, cb, ca] = parseColor(CLIPPING_COLOR);
+  const imageData = ctx.createImageData(w, height);
+  const { data } = imageData;
+  const numBars = width;
+  for (let barIndex = 0;barIndex < numBars; barIndex++) {
+    const x = barIndex;
+    if (x >= w)
+      break;
+    const peakIndex = Math.floor(barIndex / numBars * peaks.length);
+    const peak = peaks[peakIndex] || 0;
+    const scaledPeak = peak * volume;
+    const halfBar = Math.max(0, Math.min(height / 2, scaledPeak * height / 2));
+    if (halfBar === 0)
+      continue;
+    const mid = height / 2;
+    const barY = Math.round(mid - halfBar);
+    const barEnd = Math.round(mid + halfBar);
+    const isClipping = scaledPeak > 1;
+    const clipTopEnd = isClipping ? Math.min(barY + 2, barEnd) : barY;
+    const clipBotStart = isClipping ? Math.max(barEnd - 2, barY) : barEnd;
+    for (let y = barY;y < clipTopEnd; y++) {
+      const idx = (y * w + x) * 4;
+      data[idx] = cr;
+      data[idx + 1] = cg;
+      data[idx + 2] = cb;
+      data[idx + 3] = ca;
+    }
+    for (let y = clipTopEnd;y < clipBotStart; y++) {
+      const idx = (y * w + x) * 4;
+      data[idx] = r;
+      data[idx + 1] = g;
+      data[idx + 2] = b;
+      data[idx + 3] = a;
+    }
+    for (let y = clipBotStart;y < barEnd; y++) {
+      const idx = (y * w + x) * 4;
+      data[idx] = cr;
+      data[idx + 1] = cg;
+      data[idx + 2] = cb;
+      data[idx + 3] = ca;
+    }
+  }
+  ctx.putImageData(imageData, 0, 0);
+};
+// src/audio-waveform/load-waveform-peaks.ts
+import { ALL_FORMATS, AudioSampleSink, Input, UrlSource } from "mediabunny";
+
+// src/audio-waveform/waveform-peak-processor.ts
+var emitWaveformProgress = ({
+  completedPeaks,
+  final,
+  onProgress,
+  peaks,
+  totalPeaks
+}) => {
+  onProgress?.({
+    peaks,
+    completedPeaks,
+    totalPeaks,
+    final
+  });
+};
+var createWaveformPeakProcessor = ({
+  totalPeaks,
+  samplesPerPeak,
+  onProgress,
+  progressIntervalInMs,
+  now
+}) => {
+  const peaks = new Float32Array(totalPeaks);
+  let peakIndex = 0;
+  let peakMax = 0;
+  let sampleInPeak = 0;
+  let lastProgressAt = 0;
+  let lastProgressPeak = 0;
+  const emitProgress = (force) => {
+    const timestamp = now();
+    if (!force && peakIndex === lastProgressPeak && sampleInPeak === 0) {
+      return;
+    }
+    if (!force && timestamp - lastProgressAt < progressIntervalInMs) {
+      return;
+    }
+    lastProgressAt = timestamp;
+    lastProgressPeak = peakIndex;
+    emitWaveformProgress({
+      peaks,
+      completedPeaks: peakIndex,
+      totalPeaks,
+      final: force,
+      onProgress
+    });
+  };
+  return {
+    peaks,
+    processSampleChunk: (floats, channels) => {
+      const frameCount = Math.floor(floats.length / Math.max(1, channels));
+      for (let frame = 0;frame < frameCount; frame++) {
+        let framePeak = 0;
+        for (let channel = 0;channel < channels; channel++) {
+          const sampleIndex = frame * channels + channel;
+          const abs = Math.abs(floats[sampleIndex] ?? 0);
+          if (abs > framePeak) {
+            framePeak = abs;
+          }
+        }
+        if (framePeak > peakMax) {
+          peakMax = framePeak;
+        }
+        sampleInPeak++;
+        if (sampleInPeak >= samplesPerPeak) {
+          if (peakIndex < totalPeaks) {
+            peaks[peakIndex] = peakMax;
+          }
+          peakIndex++;
+          peakMax = 0;
+          sampleInPeak = 0;
+        }
+      }
+      emitProgress(false);
+    },
+    finalize: () => {
+      if (sampleInPeak > 0 && peakIndex < totalPeaks) {
+        peaks[peakIndex] = peakMax;
+        peakIndex++;
+      }
+      emitProgress(true);
+    }
+  };
+};
+
+// src/audio-waveform/load-waveform-peaks.ts
+var DEFAULT_PROGRESS_INTERVAL_IN_MS = 50;
+var peaksCache = new Map;
+async function loadWaveformPeaks(url, signal, options) {
+  const cached = peaksCache.get(url);
+  if (cached) {
+    emitWaveformProgress({
+      peaks: cached,
+      completedPeaks: cached.length,
+      totalPeaks: cached.length,
+      final: true,
+      onProgress: options?.onProgress
+    });
+    return cached;
+  }
+  const input = new Input({
+    formats: ALL_FORMATS,
+    source: new UrlSource(url)
+  });
+  try {
+    const audioTrack = await input.getPrimaryAudioTrack();
+    if (!audioTrack) {
+      return new Float32Array(0);
+    }
+    if (await audioTrack.isLive()) {
+      throw new Error("Live streams are not currently supported by Remotion. Sorry! Source: " + url);
+    }
+    if (await audioTrack.isRelativeToUnixEpoch()) {
+      throw new Error("Streams with UNIX timestamps are not currently supported by Remotion. Sorry! Source: " + url);
+    }
+    const sampleRate = await audioTrack.getSampleRate();
+    const durationInSeconds = await audioTrack.getDurationFromMetadata({ skipLiveWait: true }) ?? await audioTrack.computeDuration({ skipLiveWait: true });
+    const totalPeaks = Math.ceil(durationInSeconds * TARGET_SAMPLE_RATE);
+    const samplesPerPeak = Math.max(1, Math.floor(sampleRate / TARGET_SAMPLE_RATE));
+    const sink = new AudioSampleSink(audioTrack);
+    const processor = createWaveformPeakProcessor({
+      totalPeaks,
+      samplesPerPeak,
+      onProgress: options?.onProgress,
+      progressIntervalInMs: options?.progressIntervalInMs ?? DEFAULT_PROGRESS_INTERVAL_IN_MS,
+      now: () => Date.now()
+    });
+    for await (const sample of sink.samples()) {
+      if (signal.aborted) {
+        sample.close();
+        return new Float32Array(0);
+      }
+      const bytesNeeded = sample.allocationSize({
+        format: "f32",
+        planeIndex: 0
+      });
+      const floats = new Float32Array(bytesNeeded / 4);
+      sample.copyTo(floats, { format: "f32", planeIndex: 0 });
+      const channels = Math.max(1, sample.numberOfChannels);
+      sample.close();
+      processor.processSampleChunk(floats, channels);
+    }
+    processor.finalize();
+    const { peaks } = processor;
+    peaksCache.set(url, peaks);
+    return peaks;
+  } finally {
+    input.dispose();
+  }
+}
+// src/audio-waveform/make-audio-waveform-worker.ts
+var makeAudioWaveformWorker = () => {
+  return new Worker(new URL("./audio-waveform-worker.mjs", import.meta.url), {
+    type: "module"
+  });
+};
+// src/audio-waveform/slice-waveform-peaks.ts
+var sliceWaveformPeaks = ({
+  durationInFrames,
+  fps,
+  peaks,
+  playbackRate,
+  startFrom
+}) => {
+  if (peaks.length === 0) {
+    return peaks;
+  }
+  const startTimeInSeconds = startFrom / fps;
+  const durationInSeconds = durationInFrames / fps * playbackRate;
+  const startPeakIndex = Math.floor(startTimeInSeconds * TARGET_SAMPLE_RATE);
+  const endPeakIndex = Math.ceil((startTimeInSeconds + durationInSeconds) * TARGET_SAMPLE_RATE);
+  return peaks.subarray(Math.max(0, startPeakIndex), Math.min(peaks.length, endPeakIndex));
+};
 // src/extract-frames.ts
 import {
-  ALL_FORMATS,
-  Input,
+  ALL_FORMATS as ALL_FORMATS2,
+  Input as Input2,
   InputDisposedError,
-  UrlSource,
+  UrlSource as UrlSource2,
   VideoSampleSink
 } from "mediabunny";
 
@@ -21,9 +279,9 @@ async function extractFrames({
   onVideoSample,
   signal
 }) {
-  const input = new Input({
-    formats: ALL_FORMATS,
-    source: new UrlSource(src)
+  const input = new Input2({
+    formats: ALL_FORMATS2,
+    source: new UrlSource2(src)
   });
   const dispose = () => {
     input.dispose();
@@ -368,9 +626,12 @@ var resizeVideoFrame = ({
   });
 };
 export {
+  sliceWaveformPeaks,
   shouldTileLoopDisplay,
   resizeVideoFrame,
   makeFrameDatabaseKey,
+  makeAudioWaveformWorker,
+  loadWaveformPeaks,
   getTimestampFromFrameDatabaseKey,
   getLoopDisplayWidth,
   getFrameDatabaseKeyPrefix,
@@ -381,9 +642,13 @@ export {
   fillFrameWhereItFits,
   extractFrames,
   ensureSlots,
+  emitWaveformProgress,
   drawSlot,
+  drawBars,
+  createWaveformPeakProcessor,
   calculateTimestampSlots,
   aspectRatioCache,
   addFrameToCache,
-  WEBCODECS_TIMESCALE
+  WEBCODECS_TIMESCALE,
+  TARGET_SAMPLE_RATE
 };

package/dist/index.d.ts

@@ -1,3 +1,10 @@
+export type { AudioWaveformWorkerIncomingMessage, AudioWaveformWorkerOutgoingMessage, AudioWaveformWorkerRenderMessage, } from './audio-waveform/audio-waveform-worker-types';
+export { TARGET_SAMPLE_RATE } from './audio-waveform/constants';
+export { drawBars } from './audio-waveform/draw-peaks';
+export { loadWaveformPeaks } from './audio-waveform/load-waveform-peaks';
+export { makeAudioWaveformWorker } from './audio-waveform/make-audio-waveform-worker';
+export { sliceWaveformPeaks } from './audio-waveform/slice-waveform-peaks';
+export { createWaveformPeakProcessor, emitWaveformProgress, } from './audio-waveform/waveform-peak-processor';
 export { extractFrames } from './extract-frames';
 export type { ExtractFramesProps, ExtractFramesTimestampsInSecondsFn, } from './extract-frames';
 export { addFrameToCache, aspectRatioCache, frameDatabase, getAspectRatioFromCache, getFrameDatabaseKeyPrefix, getTimestampFromFrameDatabaseKey, makeFrameDatabaseKey, } from './frame-database';

package/dist/index.js

@@ -1,6 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.resizeVideoFrame = exports.WEBCODECS_TIMESCALE = exports.getDurationOfOneFrame = exports.fillWithCachedFrames = exports.fillFrameWhereItFits = exports.ensureSlots = exports.drawSlot = exports.calculateTimestampSlots = exports.shouldTileLoopDisplay = exports.getLoopDisplayWidth = exports.makeFrameDatabaseKey = exports.getTimestampFromFrameDatabaseKey = exports.getFrameDatabaseKeyPrefix = exports.getAspectRatioFromCache = exports.frameDatabase = exports.aspectRatioCache = exports.addFrameToCache = exports.extractFrames = void 0;
+exports.resizeVideoFrame = exports.WEBCODECS_TIMESCALE = exports.getDurationOfOneFrame = exports.fillWithCachedFrames = exports.fillFrameWhereItFits = exports.ensureSlots = exports.drawSlot = exports.calculateTimestampSlots = exports.shouldTileLoopDisplay = exports.getLoopDisplayWidth = exports.makeFrameDatabaseKey = exports.getTimestampFromFrameDatabaseKey = exports.getFrameDatabaseKeyPrefix = exports.getAspectRatioFromCache = exports.frameDatabase = exports.aspectRatioCache = exports.addFrameToCache = exports.extractFrames = exports.emitWaveformProgress = exports.createWaveformPeakProcessor = exports.sliceWaveformPeaks = exports.makeAudioWaveformWorker = exports.loadWaveformPeaks = exports.drawBars = exports.TARGET_SAMPLE_RATE = void 0;
+const constants_1 = require("./audio-waveform/constants");
+Object.defineProperty(exports, "TARGET_SAMPLE_RATE", { enumerable: true, get: function () { return constants_1.TARGET_SAMPLE_RATE; } });
+const draw_peaks_1 = require("./audio-waveform/draw-peaks");
+Object.defineProperty(exports, "drawBars", { enumerable: true, get: function () { return draw_peaks_1.drawBars; } });
+const load_waveform_peaks_1 = require("./audio-waveform/load-waveform-peaks");
+Object.defineProperty(exports, "loadWaveformPeaks", { enumerable: true, get: function () { return load_waveform_peaks_1.loadWaveformPeaks; } });
+const make_audio_waveform_worker_1 = require("./audio-waveform/make-audio-waveform-worker");
+Object.defineProperty(exports, "makeAudioWaveformWorker", { enumerable: true, get: function () { return make_audio_waveform_worker_1.makeAudioWaveformWorker; } });
+const slice_waveform_peaks_1 = require("./audio-waveform/slice-waveform-peaks");
+Object.defineProperty(exports, "sliceWaveformPeaks", { enumerable: true, get: function () { return slice_waveform_peaks_1.sliceWaveformPeaks; } });
+const waveform_peak_processor_1 = require("./audio-waveform/waveform-peak-processor");
+Object.defineProperty(exports, "createWaveformPeakProcessor", { enumerable: true, get: function () { return waveform_peak_processor_1.createWaveformPeakProcessor; } });
+Object.defineProperty(exports, "emitWaveformProgress", { enumerable: true, get: function () { return waveform_peak_processor_1.emitWaveformProgress; } });
 const extract_frames_1 = require("./extract-frames");
 Object.defineProperty(exports, "extractFrames", { enumerable: true, get: function () { return extract_frames_1.extractFrames; } });
 const frame_database_1 = require("./frame-database");

package/package.json

@@ -3,15 +3,15 @@
 		"url": "https://github.com/remotion-dev/remotion/tree/main/packages/timeline-utils"
 	},
 	"name": "@remotion/timeline-utils",
-	"version": "4.0.460",
+	"version": "4.0.462",
 	"description": "Internal utilities for rendering Remotion timelines",
 	"main": "dist/index.js",
-	"sideEffects": false,
 	"scripts": {
 		"formatting": "oxfmt src --check",
 		"format": "oxfmt src",
 		"lint": "eslint src",
-		"make": "tsgo -d && bun --env-file=../.env.bundle bundle.ts"
+		"make": "tsgo -d && bun --env-file=../.env.bundle bundle.ts",
+		"test": "bun test src"
 	},
 	"types": "dist/index.d.ts",
 	"module": "dist/esm/index.mjs",
@@ -21,10 +21,11 @@
 		"url": "https://github.com/remotion-dev/remotion/issues"
 	},
 	"dependencies": {
-		"mediabunny": "1.42.0"
+		"mediabunny": "1.45.0"
 	},
 	"devDependencies": {
-		"@remotion/eslint-config-internal": "4.0.460",
+		"@mediabunny/server": "1.45.0",
+		"@remotion/eslint-config-internal": "4.0.462",
 		"eslint": "9.19.0",
 		"@typescript/native-preview": "7.0.0-dev.20260217.1"
 	},
@@ -38,6 +39,19 @@
 			"module": "./dist/esm/index.mjs",
 			"import": "./dist/esm/index.mjs",
 			"require": "./dist/index.js"
+		},
+		"./audio-waveform-worker": {
+			"types": "./dist/audio-waveform-worker.d.ts",
+			"module": "./dist/esm/audio-waveform-worker.mjs",
+			"import": "./dist/esm/audio-waveform-worker.mjs",
+			"require": "./dist/audio-waveform-worker.js"
+		}
+	},
+	"typesVersions": {
+		">=1.0": {
+			"audio-waveform-worker": [
+				"./dist/audio-waveform-worker.d.ts"
+			]
 		}
 	}
 }