Skip to content

🎥 Make videos programmatically with React

Bound dormant Activity discovery and stabilize hidden scene clocks

Jonny Burger7ca379ac9c2e
diff --cc packages/core/src/Sequence.tsx
index 93b73e091a,7a416b6afa..882c790e80
--- a/packages/core/src/Sequence.tsx
+++ b/packages/core/src/Sequence.tsx
@@@ -47,10 -44,6 +47,11 @@@ import
SequenceOutlineContext,
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 RegularSequenceRefForwardingFunct
parentPlaybackRate,
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 = (
<SequenceContextProvider
value={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.tsx
index c145ace6ce,0000000000..8c774929bc
mode 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.tsx
index 0000000000,0000000000..e77b4ce96b
new 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.tsx
index 6418ff7646,ad9f7cb938..4ff8f8c86b
--- a/packages/core/src/SequenceManager.tsx
+++ b/packages/core/src/SequenceManager.tsx
@@@ -15,7 -15,6 +15,8 @@@ import
reconcileRegistryEntries,
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.Provider
value={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.ts
index 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.tsx
index 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.ts
index 508c21dd61,0000000000..798f951ec6
mode 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.ts
index 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.tsx
index 0000000000,0000000000..2920aa7e70
new 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.tsx
index 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}
++ />
<Composition
id="track-sequence-props"
component={TrackSequenceProps}