π₯ Make videos programmatically with React
Avoid idle frame waits while preserving canvas paint ordering
Jonny Burgerdb54dde0f3e6
diff --git a/packages/core/src/HtmlInCanvas.tsx b/packages/core/src/HtmlInCanvas.tsxindex b396feac1b..f2417fe106 100644--- a/packages/core/src/HtmlInCanvas.tsx+++ b/packages/core/src/HtmlInCanvas.tsx@@ -459,7 +459,15 @@ export type HtmlInCanvasProps = Omit<InteractiveBaseProps, 'children'> &};/* eslint-enable react/require-default-props */-const HtmlInCanvasAncestorContext = createContext(false);+type HtmlInCanvasPaintState = {+ pendingChildren: number;+ generation: number;+ release: (() => void) | null;+ blockPaint: () => () => void;+};++const HtmlInCanvasAncestorContext =+ createContext<HtmlInCanvasPaintState | null>(null);type HtmlInCanvasContentProps = {readonly width: number;@@ -476,7 +484,7 @@ type HtmlInCanvasContentProps = {const HtmlInCanvasContent = forwardRef<HTMLCanvasElement,- HtmlInCanvasContentProps+ HtmlInCanvasContentProps & {readonly renderFrame: number | null}>(({@@ -490,14 +498,13 @@ const HtmlInCanvasContent = forwardRef<pixelDensity,controls,style,+ renderFrame,},ref,) => {- const isInsideAncestorHtmlInCanvas = useContext(- HtmlInCanvasAncestorContext,- );+ const ancestorPaintState = useContext(HtmlInCanvasAncestorContext);assertHtmlInCanvasDimensions(width, height);- if (isInsideAncestorHtmlInCanvas && !isHtmlInCanvasNestingSupported()) {+ if (ancestorPaintState && !isHtmlInCanvasNestingSupported()) {throw new Error(`Nested <HtmlInCanvas> components require Chrome ${MINIMUM_CHROME_VERSION_FOR_NESTED_HTML_IN_CANVAS} or newer with HTML-in-canvas enabled.`,);@@ -508,8 +515,6 @@ const HtmlInCanvasContent = forwardRef<const canvasHeight = Math.ceil(height * resolvedPixelDensity);const {delayRender, continueRender, cancelRender} = useDelayRender();const {isClientSideRendering, isRendering} = useRemotionEnvironment();- const frame = useCurrentFrame();- const renderFrame = isRendering ? frame : null;const canRetryMissingPaintRecord = !isRendering || isClientSideRendering;const usesDirectLayoutCanvas =onPaint === undefined && onInit === undefined;@@ -528,6 +533,41 @@ const HtmlInCanvasContent = forwardRef<const paintTargetRef = useRef<HtmlInCanvasPaintTarget | null>(null);const divRef = useRef<HTMLDivElement | null>(null);const canvasSizeKey = `${width}x${height}@${resolvedPixelDensity}-${paintTargetMode}`;+ const paintState = useMemo<HtmlInCanvasPaintState>(() => {+ const state: HtmlInCanvasPaintState = {+ pendingChildren: 0,+ generation: 0,+ release: null,+ blockPaint: () => {+ state.pendingChildren++;+ state.generation++;+ if (state.release === null) {+ const handle = delayRender('waiting for nested HtmlInCanvas paint');+ const releaseAncestor = ancestorPaintState?.blockPaint();+ state.release = () => {+ continueRender(handle);+ releaseAncestor?.();+ };+ }++ let released = false;+ return () => {+ if (released) {+ return;+ }++ released = true;+ state.pendingChildren--;+ if (state.pendingChildren === 0) {+ // A child can finish asynchronously after our paint record was+ // taken. Keep capture blocked until we paint its finished pixels.+ canvas2dRef.current?.requestPaint?.();+ }+ };+ },+ };+ return state;+ }, [continueRender, delayRender, ancestorPaintState]);const setVisibleCanvasRef = useCallback((node: HTMLCanvasElement | null) => {@@ -564,8 +604,16 @@ const HtmlInCanvasContent = forwardRef<const initializedRef = useRef(false);const onInitCleanupRef = useRef<HtmlInCanvasOnInitCleanup | null>(null);const unmountedRef = useRef(false);+ const paintingTargets = useRef(+ new WeakMap<HtmlInCanvasPaintTarget, {repaint: boolean}>(),+ );const onPaintCb = useCallback(async () => {+ if (isRendering && paintState.pendingChildren > 0) {+ return;+ }++ const childrenGeneration = paintState.generation;const element = divRef.current;if (!element) {@@ -579,12 +627,29 @@ const HtmlInCanvasContent = forwardRef<);}+ const inProgress = paintingTargets.current.get(paintTarget);+ if (isRendering && inProgress) {+ // In particular, do not run onPaint while an earlier event is still+ // awaiting onInit (e.g. a WebGPU device).+ inProgress.repaint = true;+ return;+ }++ const painting = {repaint: false};+ if (isRendering) {+ paintingTargets.current.set(paintTarget, painting);+ }+resizePaintTarget({target: paintTarget,width: canvasWidth,height: canvasHeight,});+ const releaseAncestor = isRendering+ ? ancestorPaintState?.blockPaint()+ : null;+ let canReleasePaint = false;try {const placeholderCanvas = canvas2dRef.current;if (!placeholderCanvas) {@@ -611,6 +676,7 @@ const HtmlInCanvasContent = forwardRef<) {// The web renderer explicitly drives additional paint cycles, so a// transient missing record can be retried without failing the render.+ canReleasePaint = true;continueRender(handle);return;}@@ -666,6 +732,7 @@ const HtmlInCanvasContent = forwardRef<// element is outside the viewport (no cached paint record).// Skip this paint cycle β the canvas retains its last state.if (isMissingPaintRecordError(error) && canRetryMissingPaintRecord) {+ canReleasePaint = true;continueRender(handle);return;}@@ -739,9 +806,26 @@ const HtmlInCanvasContent = forwardRef<ctx.drawImage(paintTarget, 0, 0);}+ canReleasePaint = true;continueRender(handle);} catch (error) {cancelRender(error);+ } finally {+ if (+ canReleasePaint &&+ paintState.pendingChildren === 0 &&+ paintState.generation === childrenGeneration+ ) {+ const {release} = paintState;+ paintState.release = null;+ release?.();+ }++ releaseAncestor?.();+ paintingTargets.current.delete(paintTarget);+ if (painting.repaint && paintTargetRef.current === paintTarget) {+ canvas2dRef.current?.requestPaint?.();+ }}}, [canvasHeight,@@ -753,8 +837,18 @@ const HtmlInCanvasContent = forwardRef<resolvedPixelDensity,canRetryMissingPaintRecord,paintTargetMode,+ isRendering,+ paintState,+ ancestorPaintState,]);+ useLayoutEffect(() => {+ return () => {+ paintState.release?.();+ paintState.release = null;+ };+ }, [paintState]);+// Default paint handlers draw synchronously on the layout canvas itself.// ElementImage can only be drawn into its associated canvas, so custom// handlers retain a transferred target. Rendering copies it to a separate@@ -820,13 +914,20 @@ const HtmlInCanvasContent = forwardRef<// Block capture before the paint event begins, including updates that// keep the same canvas. onPaintCb holds its own handle through async work.const handle = delayRender('waiting for HtmlInCanvas paint');- const onPainted = () => continueRender(handle);+ const releaseAncestor = isRendering+ ? ancestorPaintState?.blockPaint()+ : null;+ const onPainted = () => {+ continueRender(handle);+ releaseAncestor?.();+ };+canvas.addEventListener('paint', onPainted, {once: true});canvas.requestPaint?.();return () => {canvas.removeEventListener('paint', onPainted);- continueRender(handle);+ onPainted();};}, [width,@@ -835,6 +936,8 @@ const HtmlInCanvasContent = forwardRef<delayRender,canvasSizeKey,renderFrame,+ isRendering,+ ancestorPaintState,]);const innerStyle = useMemo(() => {@@ -853,7 +956,7 @@ const HtmlInCanvasContent = forwardRef<}, [height, style, width]);return (- <HtmlInCanvasAncestorContext.Provider value>+ <HtmlInCanvasAncestorContext.Provider value={paintState}><canvaskey={canvasSizeKey}ref={paintTargetMode === 'copied' ? canvas2dRef : setVisibleCanvasRef}@@ -900,6 +1003,18 @@ const HtmlInCanvasContent = forwardRef<HtmlInCanvasContent.displayName = 'HtmlInCanvasContent';+// Subscribe to frame changes only while rendering. Preview keeps relying on+// the browser's paints and does not need a capture barrier on every frame.+const HtmlInCanvasContentForRendering = forwardRef<+ HTMLCanvasElement,+ HtmlInCanvasContentProps+>((props, ref) => {+ const frame = useCurrentFrame();+ return <HtmlInCanvasContent {...props} ref={ref} renderFrame={frame} />;+});++HtmlInCanvasContentForRendering.displayName = 'HtmlInCanvasContentForRendering';+const HtmlInCanvasInner = forwardRef<HTMLCanvasElement,HtmlInCanvasProps & {@@ -932,6 +1047,10 @@ const HtmlInCanvasInner = forwardRef<},ref,) => {+ const {isRendering} = useRemotionEnvironment();+ const Content = isRendering+ ? HtmlInCanvasContentForRendering+ : HtmlInCanvasContent;const memoizedEffectDefinitions = useMemoizedEffectDefinitions(effects);const actualRef = useRef<HTMLCanvasElement | null>(null);const setCanvasRef = useCallback(@@ -996,8 +1115,9 @@ const HtmlInCanvasInner = forwardRef<_remotionInternalIsPremounting={premountingActive}_remotionInternalIsPostmounting={postmountingActive}>- <HtmlInCanvasContent+ <Contentref={setCanvasRef}+ renderFrame={null}width={width}height={height}effects={effects}@@ -1009,7 +1129,7 @@ const HtmlInCanvasInner = forwardRef<style={croppedStyle ?? undefined}>{children}- </HtmlInCanvasContent>+ </Content></Sequence></Freeze>);diff --git a/packages/core/src/delay-render.ts b/packages/core/src/delay-render.tsindex 8f45714348..01490e839f 100644--- a/packages/core/src/delay-render.ts+++ b/packages/core/src/delay-render.ts@@ -12,6 +12,7 @@ import {getRemotionEnvironment} from './get-remotion-environment.js';import type {LogLevel} from './log.js';import {Log} from './log.js';import type {RemotionEnvironment} from './remotion-environment-context.js';+import {notifyRenderReady} from './render-ready.js';import {truthy} from './truthy.js';export {@@ -194,6 +195,9 @@ export const continueRenderInternal = ({if (scope.remotion_delayRenderHandles.length === 0) {scope.remotion_renderReady = true;+ if (environment.isRendering) {+ notifyRenderReady(scope);+ }}};diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.tsindex 799757d281..764180ed39 100644--- a/packages/core/src/internals.ts+++ b/packages/core/src/internals.ts@@ -158,6 +158,7 @@ import {getRoot, waitForRoot} from './register-root.js';import type {RemotionEnvironment} from './remotion-environment-context.js';import {RemotionEnvironmentContext} from './remotion-environment-context.js';import {RemotionRootContexts} from './RemotionRoot.js';+import {subscribeToRenderReady} from './render-ready.js';import {makeRenderResourceManager,RenderResourceManagerContext,@@ -345,6 +346,7 @@ const compositionSelectorRef = createRef<{// Mark them as Internals so use don't assume this is public// API and are less likely to use itexport const Internals = {+ subscribeToRenderReady,CommittedMetadataProvider,withCommittedMetadata,DefaultPremountContext,diff --git a/packages/core/src/no-react.ts b/packages/core/src/no-react.tsindex 0ee1fc48ef..440c06bbeb 100644--- a/packages/core/src/no-react.ts+++ b/packages/core/src/no-react.ts@@ -2,6 +2,7 @@ import {evaluateSourceNumericValue,evaluateSourcePropStatuses,} from './evaluate-source-expressions.js';+import {RENDER_READY_EVENT} from './render-ready.js';export type {ArtifactAsset,AudioOrVideoAsset,@@ -62,6 +63,7 @@ import {getExpectedMediaFrameUncorrected} from './video/get-current-time';import {getOffthreadVideoSource} from './video/offthread-video-source';export const NoReactInternals = {+ RENDER_READY_EVENT,DEFAULT_PREMOUNT_IN_SECONDS,validateDefaultPremountInSeconds,evaluateSourceNumericValue,diff --git a/packages/core/src/render-ready.ts b/packages/core/src/render-ready.tsnew file mode 100644index 0000000000..707271f605--- /dev/null+++ b/packages/core/src/render-ready.ts@@ -0,0 +1,28 @@+import type {DelayRenderScope} from './delay-render.js';++export const RENDER_READY_EVENT = 'remotion-render-ready';++const listeners = new WeakMap<DelayRenderScope, Set<() => void>>();++export const subscribeToRenderReady = (+ scope: DelayRenderScope,+ listener: () => void,+) => {+ let scopedListeners = listeners.get(scope);+ if (!scopedListeners) {+ scopedListeners = new Set();+ listeners.set(scope, scopedListeners);+ }++ scopedListeners.add(listener);+ return () => {+ scopedListeners.delete(listener);+ };+};++export const notifyRenderReady = (scope: DelayRenderScope) => {+ listeners.get(scope)?.forEach((listener) => listener());+ if (typeof window !== 'undefined' && scope === window) {+ window.dispatchEvent(new Event(RENDER_READY_EVENT));+ }+};diff --git a/packages/core/src/test/html-in-canvas.test.tsx b/packages/core/src/test/html-in-canvas.test.tsxindex 688cff7b2f..6a24524bd9 100644--- a/packages/core/src/test/html-in-canvas.test.tsx+++ b/packages/core/src/test/html-in-canvas.test.tsx@@ -713,12 +713,21 @@ test('<HtmlInCanvas> retries a missing paint record during client-side renderingconst w = window as unknown as {remotion_cancelledError?: string};w.remotion_cancelledError = undefined;+ const originalUserAgent = Object.getOwnPropertyDescriptor(+ navigator,+ 'userAgent',+ );+ Object.defineProperty(navigator, 'userAgent', {+ configurable: true,+ value: 'Chrome/157.0.0.0',+ });+let captureCalls = 0;Object.defineProperty(HTMLCanvasElement.prototype, 'captureElementImage', {configurable: true,value: () => {captureCalls++;- if (captureCalls === 1) {+ if (captureCalls === 2) {throw new DOMException('No cached paint record for element','InvalidStateError',@@ -749,7 +758,9 @@ test('<HtmlInCanvas> retries a missing paint record during client-side renderingpaintCalled = true;}}>- <div>Test</div>+ <HtmlInCanvas width={25} height={25}>+ <div>Test</div>+ </HtmlInCanvas></HtmlInCanvas></SequenceTestWrapper>,);@@ -759,18 +770,28 @@ test('<HtmlInCanvas> retries a missing paint record during client-side rendering});const canvas = container.querySelector('canvas')!;+ canvas.querySelector('canvas')!.dispatchEvent(new Event('paint'));+ await new Promise((resolve) => setTimeout(resolve, 0));canvas.dispatchEvent(new Event('paint'));expect(paintCalled).toBe(false);+ // Skipping an unavailable record must also release the nested paint barrier.+ expect(window.remotion_renderReady).toBe(true);expect(w.remotion_cancelledError).toBeUndefined();canvas.dispatchEvent(new Event('paint'));await waitFor(() => {expect(paintCalled).toBe(true);});- expect(captureCalls).toBe(2);+ expect(captureCalls).toBe(3);expect(w.remotion_cancelledError).toBeUndefined();} finally {+ if (originalUserAgent) {+ Object.defineProperty(navigator, 'userAgent', originalUserAgent);+ } else {+ Reflect.deleteProperty(navigator, 'userAgent');+ }+if (originalDescriptor) {Object.defineProperty(HTMLCanvasElement.prototype,diff --git a/packages/renderer/src/browser/DOMWorld.ts b/packages/renderer/src/browser/DOMWorld.tsindex d760d9d8dd..390437e48d 100644--- a/packages/renderer/src/browser/DOMWorld.ts+++ b/packages/renderer/src/browser/DOMWorld.ts@@ -122,11 +122,13 @@ export class DOMWorld {timeout,pageFunction,title,+ wakeUpEvent,}: {browser: HeadlessBrowser;timeout: number | null;pageFunction: Function | string;title: string;+ wakeUpEvent: string | null;}): WaitTask {return new WaitTask({domWorld: this,@@ -134,6 +136,7 @@ export class DOMWorld {title,timeout,args: [],+ wakeUpEvent,browser,});}@@ -146,6 +149,7 @@ interface WaitTaskOptions {timeout: number | null;browser: HeadlessBrowser;args: SerializableOrJSHandle[];+ wakeUpEvent: string | null;}const noop = (): void => undefined;@@ -155,6 +159,7 @@ class WaitTask {#timeout: number | null;#predicateBody: string;#args: SerializableOrJSHandle[];+ #wakeUpEvent: string | null;#runCount = 0;#resolve: (x: JSHandle) => void = noop;#reject: (x: Error) => void = noop;@@ -177,6 +182,7 @@ class WaitTask {this.#timeout = options.timeout;this.#predicateBody = getPredicateBody(options.predicateBody);this.#args = options.args;+ this.#wakeUpEvent = options.wakeUpEvent;this.#runCount = 0;this.#domWorld._waitTasks.add(this);@@ -238,6 +244,7 @@ class WaitTask {waitForPredicatePageFunction,this.#predicateBody,this.#timeout,+ this.#wakeUpEvent,...this.#args,);} catch (error_) {@@ -347,32 +354,77 @@ class WaitTask {function waitForPredicatePageFunction(predicateBody: string,timeout: number,+ wakeUpEvent: string | null,...args: unknown[]): Promise<unknown> {// eslint-disable-next-line no-new-funcconst predicate = new Function('...args', predicateBody);- let timedOut = false;- if (timeout) {- setTimeout(() => {- timedOut = true;- }, timeout);- }- return new Promise<JSHandle | undefined>((resolve) => {- async function onRaf(): Promise<void> {- if (timedOut) {- resolve(undefined);+ return new Promise<JSHandle | undefined>((resolve, reject) => {+ let finished = false;+ let checking = false;+ let rafId: number | null = null;+ let timeoutId: ReturnType<typeof setTimeout> | null = null;++ const cleanup = () => {+ finished = true;+ if (rafId !== null) {+ cancelAnimationFrame(rafId);+ }++ if (timeoutId !== null) {+ clearTimeout(timeoutId);+ }++ if (wakeUpEvent !== null) {+ window.removeEventListener(wakeUpEvent, onReady);+ }+ };++ const check = async () => {+ if (finished || checking) {return;}- const success = await predicate(...args);- if (success) {- resolve(success);- } else {- requestAnimationFrame(onRaf);+ checking = true;+ try {+ const success = await predicate(...args);+ if (!finished && success) {+ cleanup();+ resolve(success);+ }+ } catch (error) {+ cleanup();+ reject(error);+ } finally {+ checking = false;+ }+ };++ const onReady = () => {+ // Let effects finish replacing handles before testing readiness.+ queueMicrotask(check);+ };++ async function onRaf(): Promise<void> {+ await check();+ if (!finished) {+ rafId = requestAnimationFrame(onRaf);}}+ if (timeout) {+ timeoutId = setTimeout(() => {+ cleanup();+ resolve(undefined);+ }, timeout);+ }++ if (wakeUpEvent !== null) {+ window.addEventListener(wakeUpEvent, onReady);+ }++ // Keep polling for errors and for bundles predating the ready event.onRaf();});}diff --git a/packages/renderer/src/seek-to-frame.ts b/packages/renderer/src/seek-to-frame.tsindex b9f173bcca..8b7135451b 100644--- a/packages/renderer/src/seek-to-frame.ts+++ b/packages/renderer/src/seek-to-frame.ts@@ -1,3 +1,4 @@+import {NoReactInternals} from 'remotion/no-react';import {BrowserEmittedEvents} from './browser/Browser';import type {Page} from './browser/BrowserPage';import {PageEmittedEvents} from './browser/BrowserPage';@@ -67,6 +68,7 @@ export const waitForReady = ({const waitForReadyProm = new Promise<JSHandle>((resolve, reject) => {const waitTask = page.mainFrame()._mainWorld.waitForFunction({browser: page.browser,+ wakeUpEvent: NoReactInternals.RENDER_READY_EVENT,// Increase timeout so the delayRender() timeout fires earliertimeout: timeoutInMilliseconds + 3000,pageFunction: `window.remotion_renderReady === true ? "${readyToken}" : window.remotion_cancelledError !== undefined ? "${cancelledToken}" : false`,diff --git a/packages/web-renderer/src/test/delay-render.test.tsx b/packages/web-renderer/src/test/delay-render.test.tsxindex 15023344f8..64f13735e1 100644--- a/packages/web-renderer/src/test/delay-render.test.tsx+++ b/packages/web-renderer/src/test/delay-render.test.tsx@@ -14,12 +14,18 @@ test('should be able to use delayRender()', async () => {useEffect(() => {setTimeout(() => {- flushSync(() => {- setData(true);- });continueRender(handle);+ // Replacing the last handle in the same task must not expose the+ // intermediate red frame to an event-driven readiness waiter.+ const nextHandle = delayRender('Loading the next piece of data');+ setTimeout(() => {+ flushSync(() => {+ setData(true);+ });+ continueRender(nextHandle);+ }, 50);}, 50);- }, [continueRender, handle]);+ }, [continueRender, delayRender, handle]);return data ? (<svg viewBox="0 0 100 100" style={{backgroundColor: 'green'}} />diff --git a/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx b/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsxindex 8fb65eb0cd..7e2dceb294 100644--- a/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx+++ b/packages/web-renderer/src/test/fixtures/html-in-canvas-frames.tsx@@ -47,10 +47,13 @@ const Paint: React.FC<HtmlInCanvasFramesProps & {readonly frame: number}> = ({);const gpuRef = useRef<{device: GpuDevice; context: GpuContext} | null>(null);const onInit: HtmlInCanvasOnInit = useCallback(- async ({canvas}) => {+ async ({canvas, element}) => {// Exercise asynchronous initialization, including the first mounted frame.await Promise.resolve();if (backend === 'webgpu') {+ // Initialization can span multiple browser paint events.+ (element.parentElement as HTMLCanvasElement).requestPaint?.();+ await new Promise((resolve) => setTimeout(resolve, 30));const {gpu} = navigator as unknown as {gpu: {requestAdapter(): Promise<{@@ -110,6 +113,9 @@ const Paint: React.FC<HtmlInCanvasFramesProps & {readonly frame: number}> = ({const onPaint: HtmlInCanvasOnPaint = useCallback(async ({canvas, elementImage}) => {if (backend === '2d') {+ // Finish outside the paint event's task: a ready notification must+ // still wait for this handler and its pixel copy.+ await new Promise((resolve) => setTimeout(resolve, 5));const ctx = canvas.getContext('2d')!;ctx.reset();ctx.drawElementImage(elementImage, 0, 0);@@ -232,7 +238,9 @@ const paint: HtmlInCanvasOnPaint = ({canvas, elementImage}) => {const Nested: React.FC<HtmlInCanvasFramesProps> = (props) => {return (<HtmlInCanvas width={100} height={100} onPaint={paint} effects={[invert()]}>- <Component {...props} />+ <HtmlInCanvas width={100} height={100}>+ <Component {...props} />+ </HtmlInCanvas></HtmlInCanvas>);};diff --git a/packages/web-renderer/src/wait-for-ready.ts b/packages/web-renderer/src/wait-for-ready.tsindex e77cf1bc9d..2b1d7a52bd 100644--- a/packages/web-renderer/src/wait-for-ready.ts+++ b/packages/web-renderer/src/wait-for-ready.ts@@ -1,5 +1,5 @@/* eslint-disable @typescript-eslint/no-use-before-define */-import type {DelayRenderScope} from 'remotion';+import {Internals, type DelayRenderScope} from 'remotion';import type {BackgroundKeepalive} from './background-keepalive';import type {InternalState} from './internal-state';import {withResolvers} from './with-resolvers';@@ -22,29 +22,43 @@ export const waitForReady = ({const start = performance.now();const {promise, resolve, reject} = withResolvers<void>();- let cancelled = false;+ let completed = false;+ let rafId: number | null = null;+ const unsubscribe = Internals.subscribeToRenderReady(scope, () => {+ // A layout effect may clear an old handle and open a new one in the+ // same commit. Check after that stack has finished.+ queueMicrotask(check);+ });++ const finish = () => {+ completed = true;+ unsubscribe();+ if (rafId !== null) {+ cancelAnimationFrame(rafId);+ }++ internalState?.addWaitForReadyTime(performance.now() - start);+ };const check = () => {- if (cancelled) {+ if (completed) {return;}if (signal?.aborted) {- cancelled = true;- internalState?.addWaitForReadyTime(performance.now() - start);+ finish();reject(new Error(`${apiName}() was cancelled`));return;}if (scope.remotion_renderReady === true) {- internalState?.addWaitForReadyTime(performance.now() - start);+ finish();resolve();return;}if (scope.remotion_cancelledError !== undefined) {- cancelled = true;- internalState?.addWaitForReadyTime(performance.now() - start);+ finish();const stack = scope.remotion_cancelledError;const message = stack.split('\n')[0].replace(/^Error: /, '');const error = new Error(message);@@ -54,8 +68,7 @@ export const waitForReady = ({}if (performance.now() - start > timeoutInMilliseconds + 3000) {- cancelled = true;- internalState?.addWaitForReadyTime(performance.now() - start);+ finish();reject(new Error(Object.values(scope.remotion_delayRenderTimeouts)@@ -63,17 +76,14 @@ export const waitForReady = ({.join(', '),),);- return;}-- scheduleNextCheck();};// schedule both raf and worker timer - whichever fires first wins.// when tab is visible, raf fires first. when backgrounded, worker wins.const scheduleNextCheck = () => {const rafTick = new Promise<void>((res) => {- requestAnimationFrame(() => res());+ rafId = requestAnimationFrame(() => res());});// browsers throttle RAF when tab is backgrounded, so race against worker@@ -81,11 +91,24 @@ export const waitForReady = ({? Promise.race([rafTick, keepalive.waitForTick()]): rafTick;- backgroundSafeTick.then(check);+ backgroundSafeTick.then(() => {+ if (rafId !== null) {+ cancelAnimationFrame(rafId);+ rafId = null;+ }++ check();+ if (!completed) {+ scheduleNextCheck();+ }+ });};// check immediately first - if already ready, don't wait for RAFcheck();+ if (!completed) {+ scheduleNextCheck();+ }return promise;};