@remotion/web-renderer 4.0.429 → 4.0.430

package/dist/render-media-on-web.js

@@ -0,0 +1,304 @@
+import { AudioSampleSource, BufferTarget, Output, StreamTarget, VideoSampleSource, } from 'mediabunny';
+import { Internals } from 'remotion';
+import { addAudioSample, addVideoSampleAndCloseFrame } from './add-sample';
+import { handleArtifacts } from './artifact';
+import { onlyInlineAudio } from './audio';
+import { canUseWebFsWriter } from './can-use-webfs-target';
+import { createScaffold } from './create-scaffold';
+import { getRealFrameRange } from './frame-range';
+import { getDefaultAudioEncodingConfig } from './get-audio-encoding-config';
+import { makeInternalState } from './internal-state';
+import { codecToMediabunnyCodec, containerToMediabunnyContainer, getDefaultVideoCodecForContainer, getMimeType, getQualityForWebRendererQuality, } from './mediabunny-mappings';
+import { onlyOneRenderAtATimeQueue } from './render-operations-queue';
+import { sendUsageEvent } from './send-telemetry-event';
+import { createFrame } from './take-screenshot';
+import { createThrottledProgressCallback } from './throttle-progress';
+import { validateVideoFrame } from './validate-video-frame';
+import { waitForReady } from './wait-for-ready';
+import { cleanupStaleOpfsFiles, createWebFsTarget } from './web-fs-target';
+// TODO: More containers
+// TODO: Audio
+// TODO: Metadata
+// TODO: Validating inputs
+// TODO: Apply defaultCodec
+const internalRenderMediaOnWeb = async ({ composition, inputProps, delayRenderTimeoutInMilliseconds, logLevel, mediaCacheSizeInBytes, schema, videoCodec: codec, container, signal, onProgress, hardwareAcceleration, keyframeIntervalInSeconds, videoBitrate, frameRange, transparent, onArtifact, onFrame, outputTarget: userDesiredOutputTarget, licenseKey, muted, }) => {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const outputTarget = userDesiredOutputTarget === null
+        ? (await canUseWebFsWriter())
+            ? 'web-fs'
+            : 'arraybuffer'
+        : userDesiredOutputTarget;
+    if (outputTarget === 'web-fs') {
+        await cleanupStaleOpfsFiles();
+    }
+    const cleanupFns = [];
+    const format = containerToMediabunnyContainer(container);
+    if (codec &&
+        !format.getSupportedCodecs().includes(codecToMediabunnyCodec(codec))) {
+        return Promise.reject(new Error(`Codec ${codec} is not supported for container ${container}`));
+    }
+    const resolved = await Internals.resolveVideoConfig({
+        calculateMetadata: (_a = composition.calculateMetadata) !== null && _a !== void 0 ? _a : null,
+        signal: signal !== null && signal !== void 0 ? signal : new AbortController().signal,
+        defaultProps: (_b = composition.defaultProps) !== null && _b !== void 0 ? _b : {},
+        inputProps: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+        compositionId: composition.id,
+        compositionDurationInFrames: (_c = composition.durationInFrames) !== null && _c !== void 0 ? _c : null,
+        compositionFps: (_d = composition.fps) !== null && _d !== void 0 ? _d : null,
+        compositionHeight: (_e = composition.height) !== null && _e !== void 0 ? _e : null,
+        compositionWidth: (_f = composition.width) !== null && _f !== void 0 ? _f : null,
+    });
+    const realFrameRange = getRealFrameRange(resolved.durationInFrames, frameRange);
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        return Promise.reject(new Error('renderMediaOnWeb() was cancelled'));
+    }
+    const { delayRenderScope, div, cleanupScaffold, timeUpdater, collectAssets } = await createScaffold({
+        width: resolved.width,
+        height: resolved.height,
+        fps: resolved.fps,
+        durationInFrames: resolved.durationInFrames,
+        Component: composition.component,
+        resolvedProps: resolved.props,
+        id: resolved.id,
+        delayRenderTimeoutInMilliseconds,
+        logLevel,
+        mediaCacheSizeInBytes,
+        schema: schema !== null && schema !== void 0 ? schema : null,
+        audioEnabled: !muted,
+        videoEnabled: true,
+        initialFrame: 0,
+        defaultCodec: resolved.defaultCodec,
+        defaultOutName: resolved.defaultOutName,
+    });
+    const internalState = makeInternalState();
+    const artifactsHandler = handleArtifacts();
+    cleanupFns.push(() => {
+        cleanupScaffold();
+    });
+    const webFsTarget = outputTarget === 'web-fs' ? await createWebFsTarget() : null;
+    const target = webFsTarget
+        ? new StreamTarget(webFsTarget.stream)
+        : new BufferTarget();
+    const output = new Output({
+        format,
+        target,
+    });
+    try {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('renderMediaOnWeb() was cancelled');
+        }
+        await waitForReady({
+            timeoutInMilliseconds: delayRenderTimeoutInMilliseconds,
+            scope: delayRenderScope,
+            signal,
+            apiName: 'renderMediaOnWeb',
+            internalState,
+        });
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('renderMediaOnWeb() was cancelled');
+        }
+        cleanupFns.push(() => {
+            if (output.state === 'finalized' || output.state === 'canceled') {
+                return;
+            }
+            output.cancel();
+        });
+        const videoSampleSource = new VideoSampleSource({
+            codec: codecToMediabunnyCodec(codec),
+            bitrate: typeof videoBitrate === 'number'
+                ? videoBitrate
+                : getQualityForWebRendererQuality(videoBitrate),
+            sizeChangeBehavior: 'deny',
+            hardwareAcceleration,
+            latencyMode: 'quality',
+            keyFrameInterval: keyframeIntervalInSeconds,
+            alpha: transparent ? 'keep' : 'discard',
+        });
+        cleanupFns.push(() => {
+            videoSampleSource.close();
+        });
+        output.addVideoTrack(videoSampleSource);
+        // TODO: Should be able to customize
+        let audioSampleSource = null;
+        if (!muted) {
+            const defaultAudioEncodingConfig = await getDefaultAudioEncodingConfig();
+            if (!defaultAudioEncodingConfig) {
+                return Promise.reject(new Error('No default audio encoding config found'));
+            }
+            audioSampleSource = new AudioSampleSource(defaultAudioEncodingConfig);
+            cleanupFns.push(() => {
+                audioSampleSource === null || audioSampleSource === void 0 ? void 0 : audioSampleSource.close();
+            });
+            output.addAudioTrack(audioSampleSource);
+        }
+        await output.start();
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('renderMediaOnWeb() was cancelled');
+        }
+        const progress = {
+            renderedFrames: 0,
+            encodedFrames: 0,
+        };
+        const throttledOnProgress = createThrottledProgressCallback(onProgress);
+        for (let frame = realFrameRange[0]; frame <= realFrameRange[1]; frame++) {
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('renderMediaOnWeb() was cancelled');
+            }
+            (_g = timeUpdater.current) === null || _g === void 0 ? void 0 : _g.update(frame);
+            await waitForReady({
+                timeoutInMilliseconds: delayRenderTimeoutInMilliseconds,
+                scope: delayRenderScope,
+                signal,
+                apiName: 'renderMediaOnWeb',
+                internalState,
+            });
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('renderMediaOnWeb() was cancelled');
+            }
+            const createFrameStart = performance.now();
+            const imageData = await createFrame({
+                div,
+                width: resolved.width,
+                height: resolved.height,
+                logLevel,
+                internalState,
+            });
+            internalState.addCreateFrameTime(performance.now() - createFrameStart);
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('renderMediaOnWeb() was cancelled');
+            }
+            const assets = collectAssets.current.collectAssets();
+            if (onArtifact) {
+                await artifactsHandler.handle({
+                    imageData,
+                    frame,
+                    assets,
+                    onArtifact,
+                });
+            }
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('renderMediaOnWeb() was cancelled');
+            }
+            const audio = muted
+                ? null
+                : onlyInlineAudio({ assets, fps: resolved.fps, frame });
+            const timestamp = Math.round(((frame - realFrameRange[0]) / resolved.fps) * 1000000);
+            const videoFrame = new VideoFrame(imageData, {
+                timestamp,
+            });
+            progress.renderedFrames++;
+            throttledOnProgress === null || throttledOnProgress === void 0 ? void 0 : throttledOnProgress({ ...progress });
+            // Process frame through onFrame callback if provided
+            let frameToEncode = videoFrame;
+            if (onFrame) {
+                const returnedFrame = await onFrame(videoFrame);
+                if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                    throw new Error('renderMediaOnWeb() was cancelled');
+                }
+                frameToEncode = validateVideoFrame({
+                    originalFrame: videoFrame,
+                    returnedFrame,
+                    expectedWidth: resolved.width,
+                    expectedHeight: resolved.height,
+                    expectedTimestamp: timestamp,
+                });
+            }
+            const addSampleStart = performance.now();
+            await Promise.all([
+                addVideoSampleAndCloseFrame(frameToEncode, videoSampleSource),
+                audio && audioSampleSource
+                    ? addAudioSample(audio, audioSampleSource)
+                    : Promise.resolve(),
+            ]);
+            internalState.addAddSampleTime(performance.now() - addSampleStart);
+            progress.encodedFrames++;
+            throttledOnProgress === null || throttledOnProgress === void 0 ? void 0 : throttledOnProgress({ ...progress });
+            if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+                throw new Error('renderMediaOnWeb() was cancelled');
+            }
+        }
+        // Call progress one final time to ensure final state is reported
+        onProgress === null || onProgress === void 0 ? void 0 : onProgress({ ...progress });
+        videoSampleSource.close();
+        audioSampleSource === null || audioSampleSource === void 0 ? void 0 : audioSampleSource.close();
+        await output.finalize();
+        Internals.Log.verbose({ logLevel, tag: 'web-renderer' }, `Render timings: waitForReady=${internalState.getWaitForReadyTime().toFixed(2)}ms, createFrame=${internalState.getCreateFrameTime().toFixed(2)}ms, addSample=${internalState.getAddSampleTime().toFixed(2)}ms`);
+        const mimeType = getMimeType(container);
+        if (webFsTarget) {
+            sendUsageEvent({
+                licenseKey: licenseKey !== null && licenseKey !== void 0 ? licenseKey : null,
+                succeeded: true,
+                apiName: 'renderMediaOnWeb',
+            });
+            await webFsTarget.close();
+            return {
+                getBlob: () => {
+                    return webFsTarget.getBlob();
+                },
+                internalState,
+            };
+        }
+        if (!(target instanceof BufferTarget)) {
+            throw new Error('Expected target to be a BufferTarget');
+        }
+        sendUsageEvent({
+            licenseKey: licenseKey !== null && licenseKey !== void 0 ? licenseKey : null,
+            succeeded: true,
+            apiName: 'renderMediaOnWeb',
+        });
+        return {
+            getBlob: () => {
+                if (!target.buffer) {
+                    throw new Error('The resulting buffer is empty');
+                }
+                return Promise.resolve(new Blob([target.buffer], { type: mimeType }));
+            },
+            internalState,
+        };
+    }
+    catch (err) {
+        sendUsageEvent({
+            succeeded: false,
+            licenseKey: licenseKey !== null && licenseKey !== void 0 ? licenseKey : null,
+            apiName: 'renderMediaOnWeb',
+        }).catch((err2) => {
+            Internals.Log.error({ logLevel: 'error', tag: 'web-renderer' }, 'Failed to send usage event', err2);
+        });
+        throw err;
+    }
+    finally {
+        cleanupFns.forEach((fn) => fn());
+    }
+};
+export const renderMediaOnWeb = (options) => {
+    var _a, _b;
+    const container = (_a = options.container) !== null && _a !== void 0 ? _a : 'mp4';
+    const codec = (_b = options.videoCodec) !== null && _b !== void 0 ? _b : getDefaultVideoCodecForContainer(container);
+    onlyOneRenderAtATimeQueue.ref = onlyOneRenderAtATimeQueue.ref
+        .catch(() => Promise.resolve())
+        .then(() => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        return internalRenderMediaOnWeb({
+            ...options,
+            delayRenderTimeoutInMilliseconds: (_a = options.delayRenderTimeoutInMilliseconds) !== null && _a !== void 0 ? _a : 30000,
+            logLevel: (_c = (_b = options.logLevel) !== null && _b !== void 0 ? _b : window.remotion_logLevel) !== null && _c !== void 0 ? _c : 'info',
+            schema: (_d = options.schema) !== null && _d !== void 0 ? _d : undefined,
+            mediaCacheSizeInBytes: (_e = options.mediaCacheSizeInBytes) !== null && _e !== void 0 ? _e : null,
+            videoCodec: codec,
+            container,
+            signal: (_f = options.signal) !== null && _f !== void 0 ? _f : null,
+            onProgress: (_g = options.onProgress) !== null && _g !== void 0 ? _g : null,
+            hardwareAcceleration: (_h = options.hardwareAcceleration) !== null && _h !== void 0 ? _h : 'no-preference',
+            keyframeIntervalInSeconds: (_j = options.keyframeIntervalInSeconds) !== null && _j !== void 0 ? _j : 5,
+            videoBitrate: (_k = options.videoBitrate) !== null && _k !== void 0 ? _k : 'medium',
+            frameRange: (_l = options.frameRange) !== null && _l !== void 0 ? _l : null,
+            transparent: (_m = options.transparent) !== null && _m !== void 0 ? _m : false,
+            onArtifact: (_o = options.onArtifact) !== null && _o !== void 0 ? _o : null,
+            onFrame: (_p = options.onFrame) !== null && _p !== void 0 ? _p : null,
+            outputTarget: (_q = options.outputTarget) !== null && _q !== void 0 ? _q : null,
+            licenseKey: (_r = options.licenseKey) !== null && _r !== void 0 ? _r : undefined,
+            muted: (_s = options.muted) !== null && _s !== void 0 ? _s : false,
+        });
+    });
+    return onlyOneRenderAtATimeQueue.ref;
+};

package/dist/render-operations-queue.js

@@ -0,0 +1,3 @@
+export const onlyOneRenderAtATimeQueue = {
+    ref: Promise.resolve(),
+};

package/dist/render-still-on-web.js

@@ -0,0 +1,110 @@
+import { Internals, } from 'remotion';
+import { handleArtifacts } from './artifact';
+import { createScaffold } from './create-scaffold';
+import { makeInternalState } from './internal-state';
+import { onlyOneRenderAtATimeQueue } from './render-operations-queue';
+import { sendUsageEvent } from './send-telemetry-event';
+import { takeScreenshot } from './take-screenshot';
+import { waitForReady } from './wait-for-ready';
+async function internalRenderStillOnWeb({ frame, delayRenderTimeoutInMilliseconds, logLevel, inputProps, schema, imageFormat, mediaCacheSizeInBytes, composition, signal, onArtifact, licenseKey, }) {
+    var _a, _b, _c, _d, _e, _f;
+    const resolved = await Internals.resolveVideoConfig({
+        calculateMetadata: (_a = composition.calculateMetadata) !== null && _a !== void 0 ? _a : null,
+        signal: signal !== null && signal !== void 0 ? signal : new AbortController().signal,
+        defaultProps: (_b = composition.defaultProps) !== null && _b !== void 0 ? _b : {},
+        inputProps: inputProps !== null && inputProps !== void 0 ? inputProps : {},
+        compositionId: composition.id,
+        compositionDurationInFrames: (_c = composition.durationInFrames) !== null && _c !== void 0 ? _c : null,
+        compositionFps: (_d = composition.fps) !== null && _d !== void 0 ? _d : null,
+        compositionHeight: (_e = composition.height) !== null && _e !== void 0 ? _e : null,
+        compositionWidth: (_f = composition.width) !== null && _f !== void 0 ? _f : null,
+    });
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+        return Promise.reject(new Error('renderStillOnWeb() was cancelled'));
+    }
+    const internalState = makeInternalState();
+    const { delayRenderScope, div, cleanupScaffold, collectAssets } = await createScaffold({
+        width: resolved.width,
+        height: resolved.height,
+        delayRenderTimeoutInMilliseconds,
+        logLevel,
+        resolvedProps: resolved.props,
+        id: resolved.id,
+        mediaCacheSizeInBytes,
+        audioEnabled: false,
+        Component: composition.component,
+        videoEnabled: true,
+        durationInFrames: resolved.durationInFrames,
+        fps: resolved.fps,
+        schema: schema !== null && schema !== void 0 ? schema : null,
+        initialFrame: frame,
+        defaultCodec: resolved.defaultCodec,
+        defaultOutName: resolved.defaultOutName,
+    });
+    const artifactsHandler = handleArtifacts();
+    try {
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('renderStillOnWeb() was cancelled');
+        }
+        await waitForReady({
+            timeoutInMilliseconds: delayRenderTimeoutInMilliseconds,
+            scope: delayRenderScope,
+            signal,
+            apiName: 'renderStillOnWeb',
+            internalState: null,
+        });
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            throw new Error('renderStillOnWeb() was cancelled');
+        }
+        const imageData = await takeScreenshot({
+            div,
+            width: resolved.width,
+            height: resolved.height,
+            imageFormat,
+            logLevel,
+            internalState,
+        });
+        const assets = collectAssets.current.collectAssets();
+        if (onArtifact) {
+            await artifactsHandler.handle({ imageData, frame, assets, onArtifact });
+        }
+        sendUsageEvent({
+            licenseKey: licenseKey !== null && licenseKey !== void 0 ? licenseKey : null,
+            succeeded: true,
+            apiName: 'renderStillOnWeb',
+        });
+        return { blob: imageData, internalState };
+    }
+    catch (err) {
+        sendUsageEvent({
+            succeeded: false,
+            licenseKey: licenseKey !== null && licenseKey !== void 0 ? licenseKey : null,
+            apiName: 'renderStillOnWeb',
+        }).catch((err2) => {
+            Internals.Log.error({ logLevel: 'error', tag: 'web-renderer' }, 'Failed to send usage event', err2);
+        });
+        throw err;
+    }
+    finally {
+        internalState.cleanup();
+        cleanupScaffold();
+    }
+}
+export const renderStillOnWeb = (options) => {
+    onlyOneRenderAtATimeQueue.ref = onlyOneRenderAtATimeQueue.ref
+        .catch(() => Promise.resolve())
+        .then(() => {
+        var _a, _b, _c, _d, _e, _f, _g, _h;
+        return internalRenderStillOnWeb({
+            ...options,
+            delayRenderTimeoutInMilliseconds: (_a = options.delayRenderTimeoutInMilliseconds) !== null && _a !== void 0 ? _a : 30000,
+            logLevel: (_c = (_b = options.logLevel) !== null && _b !== void 0 ? _b : window.remotion_logLevel) !== null && _c !== void 0 ? _c : 'info',
+            schema: (_d = options.schema) !== null && _d !== void 0 ? _d : undefined,
+            mediaCacheSizeInBytes: (_e = options.mediaCacheSizeInBytes) !== null && _e !== void 0 ? _e : null,
+            signal: (_f = options.signal) !== null && _f !== void 0 ? _f : null,
+            onArtifact: (_g = options.onArtifact) !== null && _g !== void 0 ? _g : null,
+            licenseKey: (_h = options.licenseKey) !== null && _h !== void 0 ? _h : undefined,
+        });
+    });
+    return onlyOneRenderAtATimeQueue.ref;
+};

package/dist/send-telemetry-event.js

@@ -0,0 +1,22 @@
+import { registerUsageEvent } from '@remotion/licensing';
+import { Internals } from 'remotion';
+export const sendUsageEvent = async ({ licenseKey, succeeded, apiName, }) => {
+    var _a;
+    const host = typeof window === 'undefined'
+        ? null
+        : typeof window.location === 'undefined'
+            ? null
+            : ((_a = window.location.origin) !== null && _a !== void 0 ? _a : null);
+    if (host === null) {
+        return;
+    }
+    if (licenseKey === null) {
+        Internals.Log.warn({ logLevel: 'warn', tag: 'web-renderer' }, `Pass "licenseKey" to ${apiName}(). If you qualify for the Free License (https://remotion.dev/license), pass "free-license" instead.`);
+    }
+    await registerUsageEvent({
+        licenseKey: licenseKey === 'free-license' ? null : licenseKey,
+        event: 'webcodec-conversion',
+        host,
+        succeeded,
+    });
+};

package/dist/take-screenshot.js

@@ -0,0 +1,30 @@
+import { compose } from './compose';
+export const createFrame = async ({ div, width, height, logLevel, internalState, }) => {
+    const canvas = new OffscreenCanvas(width, height);
+    const context = canvas.getContext('2d');
+    if (!context) {
+        throw new Error('Could not get context');
+    }
+    await compose({
+        element: div,
+        context,
+        logLevel,
+        parentRect: new DOMRect(0, 0, width, height),
+        internalState,
+        onlyBackgroundClip: false,
+    });
+    return canvas;
+};
+export const takeScreenshot = async ({ div, width, height, imageFormat, logLevel, internalState, }) => {
+    const frame = await createFrame({
+        div,
+        width,
+        height,
+        logLevel,
+        internalState,
+    });
+    const imageData = await frame.convertToBlob({
+        type: `image/${imageFormat}`,
+    });
+    return imageData;
+};

package/dist/throttle-progress.js

@@ -0,0 +1,43 @@
+const DEFAULT_THROTTLE_MS = 250;
+/**
+ * Creates a throttled version of a progress callback that ensures it's not called
+ * more frequently than the specified interval (default: 250ms)
+ */
+export const createThrottledProgressCallback = (callback, throttleMs = DEFAULT_THROTTLE_MS) => {
+    if (!callback) {
+        return null;
+    }
+    let lastCallTime = 0;
+    let pendingUpdate = null;
+    let timeoutId = null;
+    const throttled = (progress) => {
+        const now = Date.now();
+        const timeSinceLastCall = now - lastCallTime;
+        // Always store the latest progress
+        pendingUpdate = progress;
+        // If enough time has passed, call immediately
+        if (timeSinceLastCall >= throttleMs) {
+            lastCallTime = now;
+            callback(progress);
+            pendingUpdate = null;
+            // Clear any pending timeout
+            if (timeoutId !== null) {
+                clearTimeout(timeoutId);
+                timeoutId = null;
+            }
+        }
+        else if (timeoutId === null) {
+            // Schedule a call for when the throttle period expires
+            const remainingTime = throttleMs - timeSinceLastCall;
+            timeoutId = setTimeout(() => {
+                if (pendingUpdate !== null) {
+                    lastCallTime = Date.now();
+                    callback(pendingUpdate);
+                    pendingUpdate = null;
+                }
+                timeoutId = null;
+            }, remainingTime);
+        }
+    };
+    return throttled;
+};

package/dist/tree-walker-cleanup-after-children.js

@@ -0,0 +1,33 @@
+export const createTreeWalkerCleanupAfterChildren = (treeWalker) => {
+    const cleanupAfterChildren = [];
+    const checkCleanUpAtBeginningOfIteration = () => {
+        for (let i = 0; i < cleanupAfterChildren.length;) {
+            const cleanup = cleanupAfterChildren[i];
+            if (!(cleanup.element === treeWalker.currentNode ||
+                cleanup.element.contains(treeWalker.currentNode))) {
+                cleanup.cleanupFn();
+                cleanupAfterChildren.splice(i, 1);
+            }
+            else {
+                i++;
+            }
+        }
+    };
+    const addCleanup = (element, cleanupFn) => {
+        // Last registered must be cleaned up first
+        cleanupAfterChildren.unshift({
+            element,
+            cleanupFn,
+        });
+    };
+    const cleanupInTheEndOfTheIteration = () => {
+        for (const cleanup of cleanupAfterChildren) {
+            cleanup.cleanupFn();
+        }
+    };
+    return {
+        checkCleanUpAtBeginningOfIteration,
+        addCleanup,
+        cleanupInTheEndOfTheIteration,
+    };
+};

package/dist/update-time.js

@@ -0,0 +1,17 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useImperativeHandle, useState } from 'react';
+import { flushSync } from 'react-dom';
+import { Internals } from 'remotion';
+export const UpdateTime = ({ children, audioEnabled, videoEnabled, logLevel, compId, initialFrame, timeUpdater, }) => {
+    const [frame, setFrame] = useState(initialFrame);
+    useImperativeHandle(timeUpdater, () => ({
+        update: (f) => {
+            flushSync(() => {
+                setFrame(f);
+            });
+        },
+    }));
+    return (_jsx(Internals.RemotionRootContexts, { audioEnabled: audioEnabled, videoEnabled: videoEnabled, logLevel: logLevel, numberOfAudioTags: 0, audioLatencyHint: "interactive", frameState: {
+            [compId]: frame,
+        }, children: children }));
+};

package/dist/validate-video-frame.js

@@ -0,0 +1,34 @@
+/**
+ * Validates and processes a VideoFrame returned from an onFrame callback
+ */
+/**
+ * Validates that a VideoFrame returned from onFrame callback matches expected dimensions and timestamp
+ * If validation fails, closes both frames and throws an error
+ */
+export const validateVideoFrame = ({ originalFrame, returnedFrame, expectedWidth, expectedHeight, expectedTimestamp, }) => {
+    // Validate that the returned frame is actually a VideoFrame
+    if (!(returnedFrame instanceof VideoFrame)) {
+        originalFrame.close();
+        throw new Error('onFrame callback must return a VideoFrame or void');
+    }
+    // Check if it's the same frame (no validation needed)
+    if (returnedFrame === originalFrame) {
+        return returnedFrame;
+    }
+    // Validate dimensions
+    if (returnedFrame.displayWidth !== expectedWidth ||
+        returnedFrame.displayHeight !== expectedHeight) {
+        originalFrame.close();
+        returnedFrame.close();
+        throw new Error(`VideoFrame dimensions mismatch: expected ${expectedWidth}x${expectedHeight}, got ${returnedFrame.displayWidth}x${returnedFrame.displayHeight}`);
+    }
+    // Validate timestamp
+    if (returnedFrame.timestamp !== expectedTimestamp) {
+        originalFrame.close();
+        returnedFrame.close();
+        throw new Error(`VideoFrame timestamp mismatch: expected ${expectedTimestamp}, got ${returnedFrame.timestamp}`);
+    }
+    // If we got a different frame but it's valid, close the original and use the new one
+    originalFrame.close();
+    return returnedFrame;
+};

package/dist/wait-for-ready.js

@@ -0,0 +1,39 @@
+import { withResolvers } from './with-resolvers';
+export const waitForReady = ({ timeoutInMilliseconds, scope, signal, apiName, internalState, }) => {
+    const start = performance.now();
+    const { promise, resolve, reject } = withResolvers();
+    let cancelled = false;
+    const check = () => {
+        if (cancelled) {
+            return;
+        }
+        if (signal === null || signal === void 0 ? void 0 : signal.aborted) {
+            cancelled = true;
+            internalState === null || internalState === void 0 ? void 0 : internalState.addWaitForReadyTime(performance.now() - start);
+            reject(new Error(`${apiName}() was cancelled`));
+            return;
+        }
+        if (scope.remotion_renderReady === true) {
+            internalState === null || internalState === void 0 ? void 0 : internalState.addWaitForReadyTime(performance.now() - start);
+            resolve();
+            return;
+        }
+        if (scope.remotion_cancelledError !== undefined) {
+            cancelled = true;
+            internalState === null || internalState === void 0 ? void 0 : internalState.addWaitForReadyTime(performance.now() - start);
+            reject(scope.remotion_cancelledError);
+            return;
+        }
+        if (performance.now() - start > timeoutInMilliseconds + 3000) {
+            cancelled = true;
+            internalState === null || internalState === void 0 ? void 0 : internalState.addWaitForReadyTime(performance.now() - start);
+            reject(new Error(Object.values(scope.remotion_delayRenderTimeouts)
+                .map((d) => d.label)
+                .join(', ')));
+            return;
+        }
+        requestAnimationFrame(check);
+    };
+    requestAnimationFrame(check);
+    return promise;
+};

package/dist/walk-tree.js

@@ -0,0 +1,14 @@
+export function skipToNextNonDescendant(treeWalker) {
+    // Try to go to next sibling
+    if (treeWalker.nextSibling()) {
+        return true;
+    }
+    // No sibling, go up to parent and try to find ancestor's sibling
+    while (treeWalker.parentNode()) {
+        if (treeWalker.nextSibling()) {
+            return true;
+        }
+    }
+    // No more nodes
+    return false;
+}