🎥 Make videos programmatically with React
Bound dormant Activity discovery and stabilize hidden scene clocks
Jonny Burger7ca379ac9c2e
diff --cc packages/core/src/Sequence.tsxindex 93b73e091a,7a416b6afa..882c790e80--- a/packages/core/src/Sequence.tsx+++ b/packages/core/src/Sequence.tsx@@@ -47,10 -44,6 +47,11 @@@ importSequenceOutlineContext,SequenceOutlineInternals,} from './sequence-outline.js';+import {+ SequenceActivityBoundary,+ SequenceActivityContent,+} from './SequenceActivityBoundary.js';++import {useSequenceActivityAdmission} from './SequenceActivityBudget.js';import type {SequenceContextType} from './SequenceContext.js';import {SequenceContext} from './SequenceContext.js';import {SequenceRegistrationContext} from './SequenceManager.js';@@@ -812,11 -796,12 +813,28 @@@ const RegularSequenceRefForwardingFunctparentPlaybackRate,durationInFrames: effectiveDurationInFrames,});- const content =- !seriesContentVisible || frameInParent - from < -boundaryTolerance- ? null- : frameInParent - endThreshold >= -boundaryTolerance- ? null- : children;+ const contentVisible =+ seriesContentVisible &&+ frameInParent - from >= -boundaryTolerance &&+ frameInParent - endThreshold < -boundaryTolerance;- const content = contentVisible || activityEnabled ? children : null;++ const activityDormant = parentDormant || !contentVisible;++ const admitted = useSequenceActivityAdmission(++ activityEnabled && !hidden++ ? {++ id,++ parent: parentSequence?.id ?? null,++ compositionId: videoConfig.id,++ from: firstFrame,++ end:++ cumulatedFrom +++ (from + actualDurationInFrames) / parentPlaybackRate,++ }++ : null,++ );++ const renderActivity = activityEnabled && (!activityDormant || admitted);++ const content = (activityEnabled ? renderActivity : contentVisible)++ ? children++ : null;const frozenContent =content === null || typeof freeze === 'undefined' || freeze === null ? (content@@@ -901,14 -886,6 +919,13 @@@// Retain resolved scene registrations so Studio can recover the natural end// even when seeking past an explicit wrapper trim. Scene contents stay hidden.const retainSeriesRegistration = env.isStudio && canInferDuration;- const activityDormant = parentDormant || !contentVisible;- const contentForLayout = activityEnabled ? (++ const contentForLayout = renderActivity ? (+ <SequenceActivityContent dormant={activityDormant}>+ {loopedContent}+ </SequenceActivityContent>+ ) : (+ loopedContent+ );const renderedContent =loopedContent === null ? (retainSeriesRegistration ? (@@@ -922,29 -899,20 +939,29 @@@style={defaultStyle}className={other.className}>- {loopedContent}+ {contentForLayout}</AbsoluteFillElement>);- const activityContent = activityEnabled ? (++ const activityContent = renderActivity ? (+ <SequenceActivityBoundary dormant={activityDormant} frame={firstFrame}>+ {renderedContent}+ </SequenceActivityBoundary>+ ) : (+ renderedContent+ );const sequenceContent = (<SequenceContextProvidervalue={contextValue}_remotionCommitMetadata={metadata}>{retainSeriesRegistration ? (- <SeriesContentVisibilityContext.Provider value={content !== null}>- {renderedContent}+ <SeriesContentVisibilityContext.Provider- value={activityEnabled || contentVisible}++ value={renderActivity || contentVisible}+ >+ {activityContent}</SeriesContentVisibilityContext.Provider>) : (- renderedContent+ activityContent)}</SequenceContextProvider>);diff --cc packages/core/src/SequenceActivityBoundary.tsxindex c145ace6ce,0000000000..8c774929bcmode 100644,000000..100644--- a/packages/core/src/SequenceActivityBoundary.tsx+++ b/packages/core/src/SequenceActivityBoundary.tsx@@@ -1,104 -1,0 +1,125 @@@+import React, {useContext, useMemo} from 'react';- import {SequenceActivityDormantContext} from './sequence-activity-context.js';++import {++ SequenceActivityAbsoluteTimeContext,++ SequenceActivityDormantContext,++ SequenceActivityTimelineContext,++} from './sequence-activity-context.js';+import {+ AbsoluteTimeContext,+ TimelineContext,+ type TimelineContextValue,+} from './TimelineContext.js';+import {useVideoConfig} from './use-video-config.js';++const areActivityChildrenEqual = (+ previous: React.ReactNode,+ next: React.ReactNode,+): boolean => {+ if (Object.is(previous, next)) {+ return true;+ }++ if (Array.isArray(previous) && Array.isArray(next)) {+ return (+ previous.length === next.length &&+ previous.every((child, index) =>+ areActivityChildrenEqual(child, next[index]),+ )+ );+ }++ if (+ !React.isValidElement<Record<string, unknown>>(previous) ||+ !React.isValidElement<Record<string, unknown>>(next) ||+ previous.type !== next.type ||+ previous.key !== next.key+ ) {+ return false;+ }++ const keys = Object.keys(previous.props);+ return (+ keys.length === Object.keys(next.props).length &&+ keys.every(+ (key) =>+ Object.prototype.hasOwnProperty.call(next.props, key) &&+ (key === 'children'+ ? areActivityChildrenEqual(+ previous.props.children as React.ReactNode,+ next.props.children as React.ReactNode,+ )+ : Object.is(previous.props[key], next.props[key])),+ )+ );+};++// Parent frame subscriptions often recreate unchanged JSX. Compare element+// structure and all props instead of ignoring changes to dormant scene props.+export const SequenceActivityContent = React.memo<{+ readonly children: React.ReactNode;+ readonly dormant: boolean;+}>(+ ({children}) => children,+ (previous, next) =>+ previous.dormant &&+ next.dormant &&+ areActivityChildrenEqual(previous.children, next.children),+);++export const SequenceActivityBoundary: React.FC<{+ readonly children: React.ReactNode;+ readonly dormant: boolean;+ readonly frame: number;+}> = ({children, dormant, frame}) => {- const timeline = useContext(TimelineContext);- const absoluteTime = useContext(AbsoluteTimeContext);++ const parentDormant = useContext(SequenceActivityDormantContext);++ const timeline = useContext(++ parentDormant ? SequenceActivityTimelineContext : TimelineContext,++ );++ const absoluteTime = useContext(++ parentDormant ? SequenceActivityAbsoluteTimeContext : AbsoluteTimeContext,++ );+ const {id} = useVideoConfig();+ if (timeline === null) {+ throw new Error('TimelineContext is missing');+ }++ const {audioAndVideoTags} = timeline;+ const dormantTimeline = useMemo<TimelineContextValue>(+ () => ({+ frame: {[id]: frame},+ isPlaying: () => false,+ isInsideFreeze: true,+ audioAndVideoTags,+ }),+ [audioAndVideoTags, frame, id],+ );++ // Keep the providers and Activity at the same position when activating a+ // scene. Unlike Freeze, discovery does not reset SequenceContext origins or+ // disable Series duration inference.+ return (+ <SequenceActivityDormantContext.Provider value={dormant}>- <TimelineContext.Provider value={dormant ? dormantTimeline : timeline}>- <AbsoluteTimeContext.Provider- value={dormant ? dormantTimeline : absoluteTime}++ <SequenceActivityTimelineContext.Provider++ value={dormant ? dormantTimeline : null}++ >++ <SequenceActivityAbsoluteTimeContext.Provider++ value={dormant ? dormantTimeline : null}+ >- <React.Activity mode={dormant ? 'hidden' : 'visible'}>- {children}- </React.Activity>- </AbsoluteTimeContext.Provider>- </TimelineContext.Provider>++ <TimelineContext.Provider++ value={dormant ? dormantTimeline : timeline}++ >++ <AbsoluteTimeContext.Provider++ value={dormant ? dormantTimeline : absoluteTime}++ >++ <React.Activity++ mode={dormant && !parentDormant ? 'hidden' : 'visible'}++ >++ {children}++ </React.Activity>++ </AbsoluteTimeContext.Provider>++ </TimelineContext.Provider>++ </SequenceActivityAbsoluteTimeContext.Provider>++ </SequenceActivityTimelineContext.Provider>+ </SequenceActivityDormantContext.Provider>+ );+};diff --cc packages/core/src/SequenceActivityBudget.tsxindex 0000000000,0000000000..e77b4ce96bnew file mode 100644--- /dev/null+++ b/packages/core/src/SequenceActivityBudget.tsx@@@ -1,0 -1,0 +1,166 @@@++import React, {createContext, useContext, useMemo, useState} from 'react';++import {createRegistryStore} from './registry-store.js';++import {SequenceActivityContext} from './sequence-activity-context.js';++import {TimelineContext, type TimelineContextValue} from './TimelineContext.js';++import {useSyncExternalStore} from './use-sync-external-store.js';++++// Count nested dormant content too: one admitted scene must not be able to++// recursively mount another thousand expensive scenes behind its Activity.++const MAX_DORMANT_SEQUENCES = 20;++const useCommitEffect = React.useInsertionEffect ?? React.useLayoutEffect;++++type ActivityCandidate = {++ readonly id: string;++ readonly parent: string | null;++ readonly compositionId: string;++ readonly from: number;++ readonly end: number;++};++++const createActivityBudget = () => {++ const registry = createRegistryStore<ReadonlySet<string>>(new Set());++ const candidates = new Map<string, ActivityCandidate>();++ let frame: Record<string, number> = {};++ let scheduled = false;++ const schedule = () => {++ if (scheduled) {++ return;++ }++++ scheduled = true;++ // Insertion effects run in hidden Activities too. Publish only after the++ // whole commit, once all candidates and the root playhead are current.++ queueMicrotask(() => {++ scheduled = false;++ const ranked = [...candidates.values()]++ .filter((candidate) => candidate.end > candidate.from)++ .map((candidate) => {++ const currentFrame = frame[candidate.compositionId] ?? 0;++ return {++ candidate,++ distance: Math.max(++ 0,++ candidate.from - currentFrame,++ currentFrame - candidate.end,++ ),++ };++ })++ .sort((a, b) => a.distance - b.distance);++ const selected = new Set<string>();++ for (const {candidate} of ranked) {++ const ancestors: string[] = [];++ let ancestor: ActivityCandidate | undefined = candidate;++ while (ancestor && !selected.has(ancestor.id)) {++ ancestors.push(ancestor.id);++ if (selected.size + ancestors.length > MAX_DORMANT_SEQUENCES) {++ break;++ }++++ ancestor =++ ancestor.parent === null++ ? undefined++ : candidates.get(ancestor.parent);++ }++++ if (selected.size + ancestors.length > MAX_DORMANT_SEQUENCES) {++ continue;++ }++++ for (const id of ancestors) {++ selected.add(id);++ }++++ if (selected.size === MAX_DORMANT_SEQUENCES) {++ break;++ }++ }++++ // Reserve nearby visible trees too, so becoming dormant retains their++ // state immediately. All other visible trees bypass admission. At most++ // 20 reserved IDs can become dormant, including during a large seek.++ registry.setSnapshot((previous) =>++ previous.size === selected.size &&++ [...previous].every((id) => selected.has(id))++ ? previous++ : selected,++ );++ });++ };++++ return {++ ...registry,++ setFrame: (next: Record<string, number>) => {++ frame = next;++ schedule();++ },++ register: (candidate: ActivityCandidate) => {++ candidates.set(candidate.id, candidate);++ schedule();++ return () => {++ candidates.delete(candidate.id);++ schedule();++ };++ },++ };++};++++const ActivityBudgetContext = createContext<ReturnType<++ typeof createActivityBudget++> | null>(null);++const InactiveTimelineContext = createContext<TimelineContextValue | null>(++ null,++);++const emptySelection: ReadonlySet<string> = new Set();++const ActivitySelectionContext = createContext(emptySelection);++++export const SequenceActivityBudgetProvider: React.FC<{++ readonly children: React.ReactNode;++}> = ({children}) => {++ const enabled = useContext(SequenceActivityContext);++ const [budget] = useState(createActivityBudget);++ const timeline = useContext(++ enabled ? TimelineContext : InactiveTimelineContext,++ );++ const selected = useSyncExternalStore(++ budget.subscribe,++ budget.getSnapshot,++ budget.getSnapshot,++ );++ useCommitEffect(() => {++ if (enabled && timeline !== null) {++ budget.setFrame(timeline.frame);++ }++ }, [budget, enabled, timeline]);++ return (++ <ActivityBudgetContext.Provider value={enabled ? budget : null}>++ <ActivitySelectionContext.Provider value={selected}>++ {children}++ </ActivitySelectionContext.Provider>++ </ActivityBudgetContext.Provider>++ );++};++++export const useSequenceActivityAdmission = (++ candidate: ActivityCandidate | null,++) => {++ const budget = useContext(ActivityBudgetContext);++ const selected = useContext(ActivitySelectionContext);++ const id = candidate?.id ?? null;++ const parent = candidate?.parent ?? null;++ const compositionId = candidate?.compositionId ?? null;++ const from = candidate?.from ?? null;++ const end = candidate?.end ?? null;++ const committedCandidate = useMemo(++ () =>++ id !== null && compositionId !== null && from !== null && end !== null++ ? {id, parent, compositionId, from, end}++ : null,++ [id, parent, compositionId, from, end],++ );++ useCommitEffect(() => {++ if (budget !== null && committedCandidate !== null) {++ return budget.register(committedCandidate);++ }++ }, [budget, committedCandidate]);++ return id !== null && selected.has(id);++};diff --cc packages/core/src/SequenceManager.tsxindex 6418ff7646,ad9f7cb938..4ff8f8c86b--- a/packages/core/src/SequenceManager.tsx+++ b/packages/core/src/SequenceManager.tsx@@@ -15,7 -15,6 +15,8 @@@ importreconcileRegistryEntries,type RegistryStore,} from './registry-store.js';+import {SequenceActivityContext} from './sequence-activity-context.js';++import {SequenceActivityBudgetProvider} from './SequenceActivityBudget.js';import {useRemotionEnvironment} from './use-remotion-environment.js';import type {CanUpdateSequencePropStatus,@@@ -1158,16 -1146,7 +1159,18 @@@ export const SequenceManagerProvider: R<VisualModeBatchSettersContext.Providervalue={batchSettersContext}>- {children}+ <SequenceActivityContext.Provider+ value={+ activityRequested &&+ isStudio &&+ commitRegistrationEnabled &&+ typeof React.Activity !== 'undefined'+ }+ >- {children}++ <SequenceActivityBudgetProvider>++ {children}++ </SequenceActivityBudgetProvider>+ </SequenceActivityContext.Provider></VisualModeBatchSettersContext.Provider></VisualModeSettersContext.Provider></VisualModeDragOverridesContext.Provider>diff --cc packages/core/src/effects/use-memoized-effects.tsindex d74fb41291,d74fb41291..b4a8077776--- a/packages/core/src/effects/use-memoized-effects.ts+++ b/packages/core/src/effects/use-memoized-effects.ts@@@ -1,4 -1,4 +1,4 @@@--import {useContext, useLayoutEffect, useRef} from 'react';++import React, {useContext, useLayoutEffect, useRef} from 'react';import {evaluateSourcePropStatuses} from '../evaluate-source-expressions.js';import {getFrameInKeyframedStatusClock,@@@ -7,6 -7,6 +7,7 @@@import {interpolateKeyframedStatus} from '../interpolate-keyframed-status.js';import {createRuntimeValueStore} from '../runtime-value-store.js';import type {RuntimeValueStore} from '../runtime-value-store.js';++import {SequenceActivityDormantContext} from '../sequence-activity-context.js';import {OverrideIdsToNodePathsGettersContext} from '../sequence-node-path.js';import type {CannotUpdateEffectReason,@@@ -32,6 -32,6 +33,7 @@@ import type} from './effect-types.js';const emptyDragOverrides: Record<string, DragOverrideValue> = {};++const useCacheCommitEffect = React.useInsertionEffect ?? useLayoutEffect;const mergeOverrides = ({descriptor,@@@ -116,6 -116,6 +118,7 @@@ export const useMemoizedEffectDefinitio): readonly EffectDefinition<unknown>[] & {readonly runtimeValues: readonly RuntimeValueStore[];} => {++ const activityDormant = useContext(SequenceActivityDormantContext);const previousRef = useRef<{readonly definitions: readonly EffectDefinition<unknown>[] & {readonly runtimeValues: readonly RuntimeValueStore[];@@@ -143,9 -143,9 +146,57 @@@runtimeValues: controllers.map((controller) => controller.store),});-- useLayoutEffect(() => {-- // Abandoned renders must not replace the cache used by committed layers.++ useCacheCommitEffect(() => {++ // Insertion effects also run for hidden Activity commits. Store listeners++ // must run after React finishes committing, never inside an insertion effect.previousRef.current = {definitions: stableDefinitions, controllers};++ if (!activityDormant || controllers.length === 0) {++ return;++ }++++ let cancelled = false;++ queueMicrotask(() => {++ if (cancelled) {++ return;++ }++++ controllers.forEach((controller, index) => {++ const snapshot = effects[index]?.params as Record<string, unknown>;++ const currentSnapshot = controller.store.getSnapshot();++ if (Object.is(snapshot, currentSnapshot)) {++ return;++ }++++ // Equivalent inline params should not notify inspector subscribers on++ // every dormant render. Preserve changes to keys and leaf references.++ if (++ snapshot !== null &&++ currentSnapshot !== null &&++ typeof snapshot === 'object' &&++ typeof currentSnapshot === 'object'++ ) {++ const keys = Object.keys(snapshot);++ if (++ keys.length === Object.keys(currentSnapshot).length &&++ keys.every(++ (key) =>++ Object.prototype.hasOwnProperty.call(currentSnapshot, key) &&++ Object.is(snapshot[key], currentSnapshot[key]),++ )++ ) {++ return;++ }++ }++++ controller.setSnapshot(snapshot);++ });++ });++ return () => {++ // A newer commit or unmount supersedes this pending publication.++ cancelled = true;++ };++ }, [activityDormant, controllers, effects, stableDefinitions]);++ useLayoutEffect(() => {// Stores are intentionally updated without changing the registered effect// array, so frame-dependent parameters don't re-register the Sequence.stableDefinitions.forEach((_definition, index) => {@@@ -296,7 -296,7 +347,7 @@@ export const useMemoizedEffects = (params,memoized: true,}));-- useLayoutEffect(() => {++ useCacheCommitEffect(() => {previousRef.current = next;}, [next]);return next;diff --cc packages/core/src/freeze.tsxindex 88767b443e,88767b443e..0826f53c40--- a/packages/core/src/freeze.tsx+++ b/packages/core/src/freeze.tsx@@@ -1,4 -1,4 +1,8 @@@import React, {createContext, useContext, useMemo} from 'react';++import {++ SequenceActivityDormantContext,++ SequenceActivityTimelineContext,++} from './sequence-activity-context.js';import type {SequenceContextType} from './SequenceContext.js';import {SequenceContext} from './SequenceContext.js';import {useTimelineContext} from './timeline-position-state.js';@@@ -67,6 -67,6 +71,7 @@@ export const Freeze: React.FC<FreezePro}, [active, frame]);const timelineContext = useTimelineContext();++ const activityDormant = useContext(SequenceActivityDormantContext);const sequenceContext = useContext(SequenceContext);const isInsideNonPremountFreeze = useIsInsideNonPremountFreeze();@@@ -106,6 -106,6 +111,7 @@@cumulatedFrom: 0,};}, [sequenceContext, isActive]);++ const providedTimeline = isActive ? frozenTimelineValue : timelineContext;return (<NonPremountFreezeContext.Provider@@@ -114,12 -114,12 +120,14 @@@(Boolean(isActive) && !_remotionInternalIsPremounting)}>-- <TimelineContext.Provider-- value={isActive ? frozenTimelineValue : timelineContext}-- >-- <SequenceContext.Provider value={newSequenceContext}>-- {children}-- </SequenceContext.Provider>++ <TimelineContext.Provider value={providedTimeline}>++ <SequenceActivityTimelineContext.Provider++ value={activityDormant ? providedTimeline : null}++ >++ <SequenceContext.Provider value={newSequenceContext}>++ {children}++ </SequenceContext.Provider>++ </SequenceActivityTimelineContext.Provider></TimelineContext.Provider></NonPremountFreezeContext.Provider>);diff --cc packages/core/src/sequence-activity-context.tsindex 508c21dd61,0000000000..798f951ec6mode 100644,000000..100644--- a/packages/core/src/sequence-activity-context.ts+++ b/packages/core/src/sequence-activity-context.ts@@@ -1,12 -1,0 +1,21 @@@+import {createContext, useContext} from 'react';++import type {TimelineContextValue} from './TimelineContext.js';++// Internal Studio experiment. Hidden Activity trees register on commit, so the+// experiment is disabled when the sequence manager falls back to effects.+export const SequenceActivityContext = createContext(false);+export const SequenceActivityDormantContext = createContext(false);+++// React propagates changed ancestor contexts through hidden Activity trees,++// even when a nested provider keeps their value stable. Use separate context++// identities so dormant clocks do not subscribe to the advancing timeline.++export const SequenceActivityTimelineContext =++ createContext<TimelineContextValue | null>(null);++export const SequenceActivityAbsoluteTimeContext =++ createContext<TimelineContextValue | null>(null);+++export const SequenceContent: React.FC<{+ readonly children: React.ReactNode;+}> = ({children}) => {+ return useContext(SequenceActivityDormantContext) ? null : children;+};diff --cc packages/core/src/timeline-position-state.tsindex df8556ad0d,7c54f81863..4c838ec24d--- a/packages/core/src/timeline-position-state.ts+++ b/packages/core/src/timeline-position-state.ts@@@ -1,5 -1,4 +1,9 @@@import {useContext} from 'react';- import {SequenceActivityDormantContext} from './sequence-activity-context.js';++import {++ SequenceActivityAbsoluteTimeContext,++ SequenceActivityDormantContext,++ SequenceActivityTimelineContext,++} from './sequence-activity-context.js';import {AbsoluteTimeContext,PlaybackRateContext,@@@ -79,7 -73,7 +83,10 @@@ const useTimelinePositionFromContext =};export const useTimelineContext = (): TimelineContextValue => {-- const state = useContext(TimelineContext);++ const dormant = useContext(SequenceActivityDormantContext);++ const state = useContext(++ dormant ? SequenceActivityTimelineContext : TimelineContext,++ );if (state === null) {throw new Error('TimelineContext is not available. This hook must be used inside a <Player> or the Remotion Studio.',@@@ -110,7 -104,7 +117,10 @@@ export const useIsInsideFreeze = (): bo};export const useAbsoluteTimelinePosition = (): number => {-- const state = useContext(AbsoluteTimeContext);++ const dormant = useContext(SequenceActivityDormantContext);++ const state = useContext(++ dormant ? SequenceActivityAbsoluteTimeContext : AbsoluteTimeContext,++ );if (state === null) {throw new Error('AbsoluteTimeContext is not available. This hook must be used inside a <Player> or the Remotion Studio.',diff --cc packages/example/src/ActivityStressTest.tsxindex 0000000000,0000000000..2920aa7e70new file mode 100644--- /dev/null+++ b/packages/example/src/ActivityStressTest.tsx@@@ -1,0 -1,0 +1,77 @@@++import React from 'react';++import {Sequence, useCurrentFrame} from 'remotion';++++const SCENE_COUNT = 1000;++const SCENE_DURATION = 30;++const CALCULATION_ITERATIONS = 75000;++++export const ACTIVITY_STRESS_TEST_DURATION = SCENE_COUNT * SCENE_DURATION;++++const ExpensiveScene: React.FC<{readonly sceneIndex: number}> = ({++ sceneIndex,++}) => {++ const frame = useCurrentFrame();++ let seed = sceneIndex + 1;++ let energy = 0;++++ // Deliberately do real render work before returning any scene markup.++ // Stable dormant frames must prevent renders, rather than memoize this work.++ for (let iteration = 0; iteration < CALCULATION_ITERATIONS; iteration++) {++ seed = Math.imul(seed ^ (seed >>> 13), 1664525) + 1013904223;++ const sample = (seed >>> 0) / 0xffffffff;++ energy +=++ Math.sin(sample * Math.PI * 2 + frame * 0.02) *++ Math.cos(iteration * 0.001 + sceneIndex * 0.07) +++ Math.sqrt(sample + 0.01);++ }++++ const checksum = energy / CALCULATION_ITERATIONS;++++ return (++ <div++ data-activity-stress-scene={sceneIndex}++ style={{++ position: 'absolute',++ inset: 0,++ backgroundColor: `hsl(${(sceneIndex * 47) % 360}, 45%, 18%)`,++ color: 'white',++ fontFamily: 'monospace',++ padding: 80,++ }}++ >++ <h1 style={{fontSize: 72}}>++ Scene {sceneIndex + 1} / {SCENE_COUNT}++ </h1>++ <p style={{fontSize: 36}}>Local frame: {frame}</p>++ <Sequence++ name="Calculated checksum"++ durationInFrames={SCENE_DURATION}++ layout="none"++ >++ <p style={{fontSize: 28}}>Checksum: {checksum.toFixed(6)}</p>++ <Sequence++ name="Second half"++ from={15}++ durationInFrames={15}++ layout="none"++ >++ <p style={{fontSize: 28}}>Second half of this scene</p>++ </Sequence>++ </Sequence>++ </div>++ );++};++++// Reuse identical scene elements even if Studio renders the composition root again.++const scenes = Array.from({length: SCENE_COUNT}, (_, sceneIndex) => (++ <Sequence++ key={sceneIndex}++ name={`Expensive scene ${sceneIndex + 1}`}++ from={sceneIndex * SCENE_DURATION}++ durationInFrames={SCENE_DURATION}++ >++ <ExpensiveScene sceneIndex={sceneIndex} />++ </Sequence>++));++++export const ActivityStressTest: React.FC = () => <>{scenes}</>;diff --cc packages/example/src/Root.tsxindex 425054912f,425054912f..f21eec3570--- a/packages/example/src/Root.tsx+++ b/packages/example/src/Root.tsx@@@ -10,6 -10,6 +10,10 @@@ import} from 'remotion';import {z} from 'zod';import {TwentyTwoKHzAudio} from './22KhzAudio';++import {++ ACTIVITY_STRESS_TEST_DURATION,++ ActivityStressTest,++} from './ActivityStressTest';import {UseanimatedEmojis} from './AnimatedEmojis';import {BarChart} from './BarChart';import BetaText, {betaTextSchema} from './BetaText';@@@ -3030,6 -3030,6 +3034,14 @@@ export const Index: React.FC = () =>/></Folder><Folder name="video-editing">++ <Composition++ id="ActivityStressTest"++ component={ActivityStressTest}++ width={1280}++ height={720}++ fps={30}++ durationInFrames={ACTIVITY_STRESS_TEST_DURATION}++ /><Compositionid="track-sequence-props"component={TrackSequenceProps}