Skip to content

🎥 Make videos programmatically with React

fix(core): release replaced Sequence children from callback scopes

Alec Wattsaed3bf984b10
diff --git a/packages/browser-studio/e2e/sequence-retention-app.tsx b/packages/browser-studio/e2e/sequence-retention-app.tsx
new file mode 100644
index 0000000000..908a62929b
--- /dev/null
+++ b/packages/browser-studio/e2e/sequence-retention-app.tsx
@@ -0,0 +1,69 @@
+import {Player} from '@remotion/player';
+import React, {useLayoutEffect, useState} from 'react';
+import {createRoot} from 'react-dom/client';
+import {Sequence} from 'remotion';
+
+declare global {
+ interface Window {
+ sequenceRetentionOptions: {
+ layout: 'none' | 'absolute-fill';
+ registration: boolean;
+ };
+ sequenceRetention: {
+ refs: WeakRef<React.FC>[];
+ replace: (revision: number) => void;
+ flush: () => void;
+ unmount: () => void;
+ };
+ }
+}
+
+const refs: WeakRef<React.FC>[] = [];
+const makeChild = (revision: number): React.FC => {
+ const buffer = new Uint8Array(1024 * 1024);
+ buffer[0] = revision;
+ const Child = () => <span id="revision">{buffer[0]}</span>;
+ refs.push(new WeakRef(Child));
+ return Child;
+};
+
+const Composition = () => {
+ const [state, setState] = useState(() => ({Child: makeChild(0), nonce: 0}));
+ useLayoutEffect(() => {
+ window.sequenceRetention.replace = (revision) =>
+ setState({Child: makeChild(revision), nonce: revision});
+ window.sequenceRetention.flush = () =>
+ setState((previous) => ({...previous, nonce: previous.nonce + 1}));
+ }, []);
+ return (
+ <Sequence layout={window.sequenceRetentionOptions.layout}>
+ <div>
+ <state.Child />
+ </div>
+ </Sequence>
+ );
+};
+
+const root = createRoot(document.getElementById('root')!);
+window.sequenceRetention = {
+ refs,
+ replace: () => {
+ throw new Error('Not mounted');
+ },
+ flush: () => {
+ throw new Error('Not mounted');
+ },
+ unmount: () => root.unmount(),
+};
+root.render(
+ <Player
+ component={Composition}
+ onTimelineSequenceChange={
+ window.sequenceRetentionOptions.registration ? () => undefined : undefined
+ }
+ durationInFrames={100}
+ fps={30}
+ compositionWidth={100}
+ compositionHeight={100}
+ />,
+);
diff --git a/packages/browser-studio/e2e/sequence-retention.test.ts b/packages/browser-studio/e2e/sequence-retention.test.ts
new file mode 100644
index 0000000000..418e7fe5fd
--- /dev/null
+++ b/packages/browser-studio/e2e/sequence-retention.test.ts
@@ -0,0 +1,119 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import {expect, test} from '@playwright/test';
+import {rspack} from '@rspack/core';
+
+// Use production React: development Fibers can retain debug owners independently
+// of Sequence. Compile workspace sources so this tests the proposed core change.
+for (const layout of ['none', 'absolute-fill'] as const) {
+ for (const registration of [false, true]) {
+ test(`Sequence releases replaced children (${layout}, registration=${registration})`, async ({
+ page,
+ }) => {
+ const output = await fs.mkdtemp(
+ path.join(os.tmpdir(), 'sequence-retention-'),
+ );
+ try {
+ await new Promise<void>((resolve, reject) => {
+ const compiler = rspack({
+ context: import.meta.dirname,
+ entry: './sequence-retention-app.tsx',
+ mode: 'production',
+ optimization: {minimize: false},
+ output: {path: output, filename: 'app.js'},
+ resolve: {
+ extensions: ['.tsx', '.ts', '.js'],
+ extensionAlias: {'.js': ['.ts', '.tsx', '.js']},
+ alias: {
+ 'remotion/no-react$': path.resolve(
+ import.meta.dirname,
+ '../../core/src/no-react.ts',
+ ),
+ remotion$: path.resolve(
+ import.meta.dirname,
+ '../../core/src/index.ts',
+ ),
+ '@remotion/player$': path.resolve(
+ import.meta.dirname,
+ '../../player/src/index.ts',
+ ),
+ },
+ },
+ module: {
+ rules: [
+ {
+ test: /\.tsx?$/,
+ use: [
+ {
+ loader: 'builtin:swc-loader',
+ options: {
+ jsc: {
+ parser: {syntax: 'typescript', tsx: true},
+ transform: {react: {runtime: 'automatic'}},
+ },
+ },
+ },
+ ],
+ },
+ ],
+ },
+ });
+ compiler.run((error, stats) => {
+ compiler.close(() => undefined);
+ if (error || stats?.hasErrors())
+ reject(error ?? new Error(stats?.toString()));
+ else resolve();
+ });
+ });
+ await page.setContent('<div id="root"></div>');
+ await page.evaluate(
+ (options) => {
+ window.sequenceRetentionOptions = options;
+ },
+ {layout, registration},
+ );
+ await page.addScriptTag({
+ content: await fs.readFile(path.join(output, 'app.js'), 'utf8'),
+ });
+ await expect(page.locator('#revision')).toHaveText('0');
+ for (let revision = 1; revision <= 5; revision++) {
+ await page.evaluate(
+ (value) => window.sequenceRetention.replace(value),
+ revision,
+ );
+ await expect(page.locator('#revision')).toHaveText(String(revision));
+ }
+
+ // Both the current and alternate React trees must have the final child.
+ for (let i = 0; i < 2; i++) {
+ await page.evaluate(() => window.sequenceRetention.flush());
+ await page.evaluate(
+ () =>
+ new Promise((resolve) =>
+ requestAnimationFrame(() => requestAnimationFrame(resolve)),
+ ),
+ );
+ }
+
+ const cdp = await page.context().newCDPSession(page);
+ try {
+ await cdp.send('HeapProfiler.collectGarbage');
+ await cdp.send('HeapProfiler.collectGarbage');
+ expect(
+ await page.evaluate(() =>
+ window.sequenceRetention.refs.flatMap((ref, index) =>
+ ref.deref() ? [index] : [],
+ ),
+ ),
+ ).toEqual([5]);
+ } finally {
+ await page.evaluate(() => window.sequenceRetention.unmount());
+ await cdp.detach();
+ }
+ } finally {
+ await fs.rm(output, {recursive: true, force: true});
+ }
+ });
+ }
+}
diff --git a/packages/core/src/Sequence.tsx b/packages/core/src/Sequence.tsx
index bb4f5a0012..71e8a777ff 100644
--- a/packages/core/src/Sequence.tsx
+++ b/packages/core/src/Sequence.tsx
@@ -173,6 +173,33 @@ export type SequenceProps = {
readonly durationInFrames?: number;
} & SequencePropsWithoutDuration;
+// These callbacks can survive many renders. Keep their closure scopes separate
+// from the render scope, which also captures children in memo factories.
+const useSequenceValueGetter = <T,>(value: T) => {
+ return useCallback(() => value, [value]);
+};
+
+const useSequenceRefGetter = <T,>(ref: React.RefObject<T>) => {
+ return useCallback(() => ref.current, [ref]);
+};
+
+const useSequenceWrapperRef = (
+ ref: React.ForwardedRef<HTMLDivElement>,
+ wrapperRef: React.RefObject<HTMLDivElement | null>,
+) => {
+ return useCallback(
+ (node: HTMLDivElement | null) => {
+ wrapperRef.current = node;
+ if (typeof ref === 'function') {
+ ref(node);
+ } else if (ref) {
+ ref.current = node;
+ }
+ },
+ [ref, wrapperRef],
+ );
+};
+
const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
HTMLDivElement,
SequenceProps
@@ -565,7 +592,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
const registrationStack = controls
? (getStackForControls(controls) ?? stack ?? null)
: (stack ?? null);
- const getStack = useCallback(() => registrationStack, [registrationStack]);
+ const getStack = useSequenceValueGetter(registrationStack);
const registeredFrozenFrame = typeof freeze === 'number' ? freeze : null;
const currentFrame =
registeredFrozenFrame ??
@@ -574,7 +601,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
useLayoutEffect(() => {
currentFrameRef.current = currentFrame;
}, [currentFrame]);
- const getCurrentFrame = useCallback(() => currentFrameRef.current, []);
+ const getCurrentFrame = useSequenceRefGetter(currentFrameRef);
const registeredTrimBefore = trimBefore === 0 ? null : trimBefore;
const parentCumulatedNegativeFrom =
parentSequence?.cumulatedNegativeFrom ?? 0;
@@ -666,7 +693,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
controlsSupportsEffects,
]);
- const getSequenceForRegistration = useCallback((): TSequence => {
+ const sequenceForRegistration = useMemo((): TSequence => {
const trackRegistration = timelineTrack
? {
timelineTrack: {
@@ -804,6 +831,9 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
frozenMediaFrame,
singleChildComponent,
]);
+ const getSequenceForRegistration = useSequenceValueGetter(
+ sequenceForRegistration,
+ );
const registration = useSequenceRegistration({
getSequence:
env.isStudio || sequenceRegistrationEnabled
@@ -867,18 +897,7 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
style: styleIfThere,
});
- const sequenceRef = useCallback(
- (node: HTMLDivElement | null) => {
- wrapperRefForOutline.current = node;
-
- if (typeof ref === 'function') {
- ref(node);
- } else if (ref) {
- ref.current = node;
- }
- },
- [ref],
- );
+ const sequenceRef = useSequenceWrapperRef(ref, wrapperRefForOutline);
const defaultStyle: React.CSSProperties = useMemo(() => {
return {