Skip to content

🎥 Make videos programmatically with React

refactor sequence source capture and commit registration

Jonny Burger45ac264f775c
diff --git a/packages/browser-bundler/src/source-location-jsx.ts b/packages/browser-bundler/src/source-location-jsx.ts
index 2e8bde1995..4f7d26233d 100644
--- a/packages/browser-bundler/src/source-location-jsx.ts
+++ b/packages/browser-bundler/src/source-location-jsx.ts
@@ -3,79 +3,6 @@ import type * as JSXDevRuntime from 'react/jsx-dev-runtime';
import type * as JSXRuntime from 'react/jsx-runtime';
import {Internals} from 'remotion';
-type JsxFactory =
- | typeof React.createElement
- | typeof JSXRuntime.jsx
- | typeof JSXDevRuntime.jsxDEV;
-
-type JsxSource = {
- fileName?: unknown;
- lineNumber?: unknown;
- columnNumber?: unknown;
-};
-
-// Mirrors the Studio bundler: Remotion components receive the source
-// location of their JSX element so mounted sequences can be traced back to
-// their source node. The development JSX transform passes the location as
-// the fifth argument of jsxDEV(); other factories fall back to a stack trace.
-const withSourceLocation = <T extends JsxFactory>(
- factory: T,
- {
- isCreateElement,
- sourceArgumentIndex,
- }: {
- isCreateElement: boolean;
- sourceArgumentIndex: number | null;
- },
-): T => {
- const componentsToAddStacksTo = Internals.getComponentsToAddStacksTo();
- const sequenceComponent = Internals.getSequenceComponent();
- const internalStackProp = Internals.REMOTION_INTERNAL_STACK_PROP;
-
- return new Proxy(factory, {
- apply(target, thisArg, argArray) {
- const [component, props, ...rest] = argArray as [
- unknown,
- Record<string, unknown> | null | undefined,
- ...unknown[],
- ];
- if (!componentsToAddStacksTo.includes(component)) {
- return Reflect.apply(target, thisArg, argArray);
- }
-
- const source =
- sourceArgumentIndex === null
- ? null
- : (argArray[sourceArgumentIndex] as JsxSource | null | undefined);
- const stack =
- source &&
- typeof source.fileName === 'string' &&
- typeof source.lineNumber === 'number' &&
- typeof source.columnNumber === 'number'
- ? Internals.makeOriginalSourceStack({
- fileName: source.fileName,
- lineNumber: source.lineNumber,
- columnNumber: source.columnNumber,
- })
- : new Error().stack;
- const newProps: Record<string, unknown> = props?.[internalStackProp]
- ? {...props}
- : {...(props ?? {}), [internalStackProp]: stack};
- if (component === sequenceComponent) {
- const children = isCreateElement
- ? rest.length === 0
- ? newProps.children
- : rest
- : newProps.children;
- newProps._remotionInternalSingleChildComponent =
- Internals.getSingleChildComponent(children as React.ReactNode);
- }
-
- return Reflect.apply(target, thisArg, [component, newProps, ...rest]);
- },
- });
-};
-
type ModuleRecord = Record<string, unknown> & {default?: unknown};
// Shared module namespaces are frozen and may expose the CommonJS export as
@@ -104,26 +31,30 @@ export const addSourceLocationsToJsxModules = ({
}) => {
return {
react: withOverrides(react as unknown as ModuleRecord, {
- createElement: withSourceLocation(react.createElement, {
- isCreateElement: true,
- sourceArgumentIndex: null,
- }),
+ createElement: Internals.createElementSourceProxy(
+ react.createElement,
+ null,
+ (fileName) => fileName,
+ ),
}),
jsxRuntime: withOverrides(jsxRuntime as unknown as ModuleRecord, {
- jsx: withSourceLocation(jsxRuntime.jsx, {
- isCreateElement: false,
- sourceArgumentIndex: null,
- }),
- jsxs: withSourceLocation(jsxRuntime.jsxs, {
- isCreateElement: false,
- sourceArgumentIndex: null,
- }),
+ jsx: Internals.createElementSourceProxy(
+ jsxRuntime.jsx,
+ null,
+ (fileName) => fileName,
+ ),
+ jsxs: Internals.createElementSourceProxy(
+ jsxRuntime.jsxs,
+ null,
+ (fileName) => fileName,
+ ),
}),
jsxDevRuntime: withOverrides(jsxDevRuntime as unknown as ModuleRecord, {
- jsxDEV: withSourceLocation(jsxDevRuntime.jsxDEV, {
- isCreateElement: false,
- sourceArgumentIndex: 4,
- }),
+ jsxDEV: Internals.createElementSourceProxy(
+ jsxDevRuntime.jsxDEV,
+ 4,
+ (fileName) => fileName,
+ ),
}),
};
};
diff --git a/packages/browser-studio/src/virtual-files.ts b/packages/browser-studio/src/virtual-files.ts
index 75e2674967..d956a5dadb 100644
--- a/packages/browser-studio/src/virtual-files.ts
+++ b/packages/browser-studio/src/virtual-files.ts
@@ -58,52 +58,10 @@ Internals.setComponentIdentityResolver((component) => {
return RefreshRuntime.getFamilyByType(component) ?? component;
});
-const componentsToAddStacksTo = Internals.getComponentsToAddStacksTo();
-const sequenceComponent = Internals.getSequenceComponent();
-const internalStackProp = Internals.REMOTION_INTERNAL_STACK_PROP;
-
-const originalCreateElement = React.createElement;
-
-export const enableProxy = (api, isCreateElement, sourceArgumentIndex) => {
- return new Proxy(api, {
- apply(target, thisArg, argArray) {
- if (componentsToAddStacksTo.includes(argArray[0])) {
- const [first, props, ...rest] = argArray;
- const children = isCreateElement
- ? rest.length === 0
- ? props?.children
- : rest
- : props?.children;
- const source =
- sourceArgumentIndex === null ? null : argArray[sourceArgumentIndex];
- const stack =
- source &&
- typeof source.fileName === 'string' &&
- typeof source.lineNumber === 'number' &&
- typeof source.columnNumber === 'number'
- ? Internals.makeOriginalSourceStack({
- fileName: source.fileName,
- lineNumber: source.lineNumber,
- columnNumber: source.columnNumber,
- })
- : new Error().stack;
- const newProps = props?.[internalStackProp]
- ? {...props}
- : {...(props ?? {}), [internalStackProp]: stack};
- if (first === sequenceComponent) {
- newProps._remotionInternalSingleChildComponent =
- Internals.getSingleChildComponent(children);
- }
-
- return Reflect.apply(target, thisArg, [first, newProps, ...rest]);
- }
-
- return Reflect.apply(target, thisArg, argArray);
- },
- });
-};
+export const enableProxy = (api, sourceArgumentIndex) =>
+ Internals.createElementSourceProxy(api, sourceArgumentIndex, (fileName) => fileName);
-React.createElement = enableProxy(originalCreateElement, true, null);
+React.createElement = enableProxy(React.createElement, null);
`;
const jsxRuntime = `import {
@@ -114,8 +72,8 @@ const jsxRuntime = `import {
import {enableProxy} from './setup-sequence-stack-traces';
export {Fragment};
-export const jsx = enableProxy(originalJsx, false, null);
-export const jsxs = enableProxy(originalJsxs, false, null);
+export const jsx = enableProxy(originalJsx, null);
+export const jsxs = enableProxy(originalJsxs, null);
`;
const jsxDevRuntime = `import {
@@ -125,7 +83,7 @@ const jsxDevRuntime = `import {
import {enableProxy} from './setup-sequence-stack-traces';
export {Fragment};
-export const jsxDEV = enableProxy(originalJsxDev, false, 4);
+export const jsxDEV = enableProxy(originalJsxDev, 4);
`;
const reactShim = `import * as React from 'react';
diff --git a/packages/bundler/src/setup-sequence-stack-traces.ts b/packages/bundler/src/setup-sequence-stack-traces.ts
index b117c0de92..7f1809728c 100644
--- a/packages/bundler/src/setup-sequence-stack-traces.ts
+++ b/packages/bundler/src/setup-sequence-stack-traces.ts
@@ -7,10 +7,6 @@ type ReactRefreshRuntime = {
getFamilyByType: (component: unknown) => unknown;
};
-const componentsToAddStacksTo = Internals.getComponentsToAddStacksTo();
-const sequenceComponent = Internals.getSequenceComponent();
-const internalStackProp = Internals.REMOTION_INTERNAL_STACK_PROP;
-
const originalCreateElement = React.createElement;
const originalJsx = JsxRuntime.jsx;
const originalJsxs = JsxRuntime.jsxs;
@@ -41,60 +37,6 @@ const getSourceFileName = (fileName: string) => {
return `./${normalizedFileName.slice(normalizedRoot.length + 1)}`;
};
-const enableProxy = <
- T extends
- | typeof React.createElement
- | typeof JsxRuntime.jsx
- | typeof JsxRuntimeDev.jsxDEV,
->(
- api: T,
- isCreateElement: boolean,
- sourceArgumentIndex: number | null,
-): T => {
- return new Proxy(api, {
- apply(target, thisArg, argArray) {
- const component = argArray[0];
- if (componentsToAddStacksTo.includes(component)) {
- const [first, props, ...rest] = argArray;
- const children = isCreateElement
- ? rest.length === 0
- ? props?.children
- : rest
- : props?.children;
- const source =
- sourceArgumentIndex === null ? null : argArray[sourceArgumentIndex];
- const existingStack = props?.[internalStackProp];
- const stack =
- existingStack ||
- (source &&
- typeof source.fileName === 'string' &&
- typeof source.lineNumber === 'number' &&
- typeof source.columnNumber === 'number'
- ? Internals.makeOriginalSourceStack({
- fileName: getSourceFileName(source.fileName),
- lineNumber: source.lineNumber,
- columnNumber: source.columnNumber,
- })
- : new Error().stack);
- const newProps = existingStack
- ? {...props}
- : {
- ...(props ?? {}),
- [internalStackProp]: stack,
- };
- if (first === sequenceComponent) {
- newProps._remotionInternalSingleChildComponent =
- Internals.getSingleChildComponent(children);
- }
-
- return Reflect.apply(target, thisArg, [first, newProps, ...rest]);
- }
-
- return Reflect.apply(target, thisArg, argArray);
- },
- });
-};
-
let stackTracesEnabled = false;
const enableSequenceStackTraces = () => {
@@ -103,11 +45,27 @@ const enableSequenceStackTraces = () => {
}
stackTracesEnabled = true;
- React.createElement = enableProxy(originalCreateElement, true, null);
- JsxRuntime.jsx = enableProxy(originalJsx, false, null);
- JsxRuntime.jsxs = enableProxy(originalJsxs, false, null);
+ React.createElement = Internals.createElementSourceProxy(
+ originalCreateElement,
+ null,
+ getSourceFileName,
+ );
+ JsxRuntime.jsx = Internals.createElementSourceProxy(
+ originalJsx,
+ null,
+ getSourceFileName,
+ );
+ JsxRuntime.jsxs = Internals.createElementSourceProxy(
+ originalJsxs,
+ null,
+ getSourceFileName,
+ );
if (originalJsxDev) {
- JsxRuntimeDev.jsxDEV = enableProxy(originalJsxDev, false, 4);
+ JsxRuntimeDev.jsxDEV = Internals.createElementSourceProxy(
+ originalJsxDev,
+ 4,
+ getSourceFileName,
+ );
}
};
diff --git a/packages/core/src/Composition.tsx b/packages/core/src/Composition.tsx
index eea90cd96e..8e772698cf 100644
--- a/packages/core/src/Composition.tsx
+++ b/packages/core/src/Composition.tsx
@@ -18,12 +18,12 @@ import {
CommittedMetadataProvider,
type CommittedMetadata,
} from './committed-metadata.js';
+import {resolveComponentIdentity} from './component-identity.js';
import {useCommittedCompositionEntry} from './composition-registry-fallback.js';
import {CompositionRenderErrorContext} from './composition-render-error-context.js';
import {CompositionErrorBoundary} from './CompositionErrorBoundary.js';
import type {AnyComposition, TComposition} from './CompositionManager.js';
import {CompositionSetters} from './CompositionManagerContext.js';
-import {resolveComponentIdentity} from './enable-sequence-stack-traces.js';
import {FolderContext} from './Folder.js';
import {serializeThenDeserializeInStudio} from './input-props-serialization.js';
import {useIsPlayer} from './is-player.js';
diff --git a/packages/core/src/Interactive.tsx b/packages/core/src/Interactive.tsx
index e20175f4bd..cb3ce704c8 100644
--- a/packages/core/src/Interactive.tsx
+++ b/packages/core/src/Interactive.tsx
@@ -1,13 +1,11 @@
import React, {forwardRef, useCallback, useContext} from 'react';
+import {resolveComponentIdentity} from './component-identity.js';
import type {
JsxComponentIdentity,
SequenceControls,
} from './CompositionManager.js';
import {CompositionManager} from './CompositionManagerContext.js';
-import {
- addSequenceStackTraces,
- resolveComponentIdentity,
-} from './enable-sequence-stack-traces.js';
+import {addSequenceStackTraces} from './enable-sequence-stack-traces.js';
import {Freeze} from './freeze.js';
import {
backgroundSchema,
diff --git a/packages/core/src/Sequence.tsx b/packages/core/src/Sequence.tsx
index 1528b3061a..863a02f82b 100644
--- a/packages/core/src/Sequence.tsx
+++ b/packages/core/src/Sequence.tsx
@@ -13,6 +13,7 @@ import {
withCommittedMetadata,
type CommittedMetadata,
} from './committed-metadata.js';
+import {getSingleChildComponent} from './component-identity.js';
import type {
LoopDisplay,
SequenceControls,
@@ -195,8 +196,8 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
_remotionInternalTimelineTrack: timelineTrackItem,
_remotionInternalLoopDisplay: loopDisplay,
_remotionInternalStack: stack,
+ _remotionInternalSingleChildComponent: childComponentOverride,
_remotionInternalDocumentationLink: documentationLink,
- _remotionInternalSingleChildComponent: singleChildComponent,
_remotionInternalPremountDisplay: premountDisplay,
_remotionInternalPostmountDisplay: postmountDisplay,
_remotionInternalIsMedia: isMedia,
@@ -558,6 +559,13 @@ const RegularSequenceRefForwardingFunction: React.ForwardRefRenderFunction<
const isInsideSeries = useContext(IsInsideSeriesContext);
+ const singleChildComponent = useMemo(
+ () =>
+ childComponentOverride === undefined
+ ? getSingleChildComponent(children)
+ : childComponentOverride,
+ [children, childComponentOverride],
+ );
const registrationStack = controls
? (getStackForControls(controls) ?? stack ?? null)
: (stack ?? null);
diff --git a/packages/core/src/SequenceManager.tsx b/packages/core/src/SequenceManager.tsx
index 4b437d9c95..7938f325cf 100644
--- a/packages/core/src/SequenceManager.tsx
+++ b/packages/core/src/SequenceManager.tsx
@@ -1,25 +1,17 @@
import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
-import {
- COMMIT_ORDER_EVENT,
- COMMIT_REGISTRATION_ERROR_EVENT,
- isCommitRegistrationObserverInstalled,
- withCommittedMetadata,
- type CommittedMetadata,
- type CommitOrderEventDetail,
- type CommittedSequenceSnapshot,
-} from './committed-metadata.js';
-import type {TSequence} from './CompositionManager.js';
-import {
- areRegistryEntriesEqual,
- createRegistryStore,
- reconcileRegistryEntries,
- type RegistryStore,
-} from './registry-store.js';
+export * from './sequence-registry-context.js';
import {
SequenceActivityContext,
SequenceActivitySettingsContext,
} from './sequence-activity-context.js';
+import {
+ SequenceManagerActionsContext,
+ SequenceCommitRegistrationContext,
+ type SequenceManagerActions,
+ type SequenceNodePath,
+} from './sequence-registry-context.js';
import {SequenceActivityBudgetProvider} from './SequenceActivityBudget.js';
+import {SequenceRegistryProvider} from './SequenceRegistryProvider.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
import type {
CanUpdateSequencePropStatus,
@@ -37,80 +29,6 @@ import type {VideoConfigValues} from './video-config.js';
const useIsomorphicLayoutEffect =
typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;
-type SequenceManagerActions = {
- registerSequence: (seq: TSequence) => void;
- updateSequence: (seq: TSequence) => void;
- unregisterSequence: (id: string) => void;
-};
-
-export type SequenceManagerRef = {
- current: TSequence[];
-};
-
-export type SequenceNodePath = Array<string | number>;
-
-const defaultSequenceManagerActions: SequenceManagerActions = {
- registerSequence: () => {
- throw new Error('SequenceManagerActionsContext not initialized');
- },
- updateSequence: () => {
- throw new Error('SequenceManagerActionsContext not initialized');
- },
- unregisterSequence: () => {
- throw new Error('SequenceManagerActionsContext not initialized');
- },
-};
-
-export const SequenceManagerActionsContext = React.createContext(
- defaultSequenceManagerActions,
-);
-
-export const SequenceRegistryContext = React.createContext<RegistryStore<
- TSequence[]
-> | null>(null);
-const subscribeToNoRegistry = () => () => undefined;
-const emptySequences: TSequence[] = [];
-const getEmptySequences = () => emptySequences;
-export const SequenceCommitRegistrationContext = React.createContext(false);
-export const SequenceRegistryScopeContext = React.createContext<{
- readonly commitRegistrationRequested: boolean;
- readonly onCommitSequences: (
- scopeId: string,
- sequences: readonly TSequence[],
- sequenceIds: readonly string[],
- ) => void;
-} | null>(null);
-export const useSequenceManagerSequences = (): TSequence[] => {
- const registry = useContext(SequenceRegistryContext);
- return useSyncExternalStore(
- registry?.subscribe ?? subscribeToNoRegistry,
- registry?.getSnapshot ?? getEmptySequences,
- registry?.getSnapshot ?? getEmptySequences,
- );
-};
-
-export const SequenceManagerRefContext =
- React.createContext<SequenceManagerRef>({
- current: [],
- });
-const SequenceManagerRefProvider = withCommittedMetadata(
- SequenceManagerRefContext.Provider,
-);
-
-export const SequenceRegistrationContext = React.createContext(false);
-
-export const DisableSequenceRegistrationContext = React.createContext(false);
-
-export const DisableSequenceRegistrationProvider: React.FC<{
- readonly children: React.ReactNode;
-}> = ({children}) => {
- return React.createElement(
- DisableSequenceRegistrationContext.Provider,
- {value: true},
- children,
- );
-};
-
export type VisualModePropStatuses = {
propStatuses: PropStatuses;
};
@@ -153,6 +71,11 @@ const SequenceManagerScopeProviders: React.FC<{
>;
readonly fromKeys: ReadonlySet<string>;
}> = ({children, dragOverridesSubscription, fromKeys}) => {
+ const {isStudio} = useRemotionEnvironment();
+ const activitySettings = useContext(SequenceActivitySettingsContext);
+ const commitRegistrationEnabled = useContext(
+ SequenceCommitRegistrationContext,
+ );
const manager = useContext(SequenceManagerActionsContext);
const scopedDragOverridesSubscription = useMemo<DragOverridesSubscription>(
() => ({...dragOverridesSubscription, manager}),
@@ -169,7 +92,18 @@ const SequenceManagerScopeProviders: React.FC<{
<VisualModeDragOverridesSubscriptionContext.Provider
value={scopedDragOverridesSubscription}
>
- {children}
+ <SequenceActivityContext.Provider
+ value={
+ activitySettings?.enabled === true &&
+ isStudio &&
+ commitRegistrationEnabled &&
+ typeof React.Activity !== 'undefined'
+ }
+ >
+ <SequenceActivityBudgetProvider>
+ {children}
+ </SequenceActivityBudgetProvider>
+ </SequenceActivityContext.Provider>
</VisualModeDragOverridesSubscriptionContext.Provider>
</ActiveFromDragOverrideKeysContext.Provider>
);
@@ -393,43 +327,6 @@ const effectDragOverridesKey = (
export const SequenceManagerProvider: React.FC<{
readonly children: React.ReactNode;
}> = ({children}) => {
- const {isStudio} = useRemotionEnvironment();
- const activitySettings = useContext(SequenceActivitySettingsContext);
-
- const sequenceRegistrationEnabled = useContext(SequenceRegistrationContext);
- const shouldObserveCommits = isStudio || sequenceRegistrationEnabled;
- const [sequenceManagerId] = useState(() => String(Math.random()));
- const [commitRegistrationEnabled, setCommitRegistrationEnabled] = useState(
- () => shouldObserveCommits && isCommitRegistrationObserverInstalled(),
- );
- const observedCommitRef = useRef(false);
- const rootObservationFailedRef = useRef(false);
- const committedRegistrationIdsRef = useRef<ReadonlySet<string>>(new Set());
- const committedDescriptorsRef = useRef<ReadonlyMap<string, TSequence>>(
- new Map(),
- );
- const pendingCommittedSequencesRef = useRef(
- new Map<string, CommittedSequenceSnapshot>(),
- );
- const committedScopesRef = useRef(
- new Map<string, CommittedSequenceSnapshot>([
- [sequenceManagerId, {sequences: [], sequenceIds: []}],
- ]),
- );
- const registrationObserverFailedRef = useRef(false);
- const registrationUnmountedRef = useRef(false);
- const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);
- const committedOrderIdsRef = useRef<readonly string[] | null>(null);
- const [registry] = useState(() => createRegistryStore<TSequence[]>([]));
- const setSequences = registry.setSnapshot;
- const sequencesRef = useMemo<SequenceManagerRef>(
- () => ({
- get current() {
- return registry.getSnapshot();
- },
- }),
- [registry],
- );
const [dragOverrideState, setDragOverrideState] = useState(() => ({
overrides: {} as DragOverrides,
fromKeys: new Set<string>(),
@@ -761,284 +658,6 @@ export const SequenceManagerProvider: React.FC<{
[],
);
- const onCommitSequences = useCallback(
- (
- scopeId: string,
- snapshot: readonly TSequence[],
- sequenceIds: readonly string[],
- ) => {
- if (
- registrationObserverFailedRef.current ||
- registrationUnmountedRef.current
- ) {
- return;
- }
-
- const previousSnapshot =
- pendingCommittedSequencesRef.current.get(scopeId) ??
- committedScopesRef.current.get(scopeId);
- if (
- previousSnapshot?.sequences === snapshot &&
- previousSnapshot.sequenceIds === sequenceIds
- ) {
- return;
- }
-
- const alreadyPending = pendingCommittedSequencesRef.current.size > 0;
- pendingCommittedSequencesRef.current.set(scopeId, {
- sequences: snapshot,
- sequenceIds,
- });
- if (alreadyPending) {
- return;
- }
-
- // Publish after React finishes committing, and coalesce successive snapshots.
- queueMicrotask(() => {
- const pending = pendingCommittedSequencesRef.current;
- pendingCommittedSequencesRef.current = new Map();
- if (
- pending.size === 0 ||
- registrationObserverFailedRef.current ||
- registrationUnmountedRef.current
- ) {
- return;
- }
-
- const previousIds = committedRegistrationIdsRef.current;
- const previousDescriptors = committedDescriptorsRef.current;
- for (const [id, scope] of pending) {
- if (id !== sequenceManagerId && scope.sequenceIds.length === 0) {
- committedScopesRef.current.delete(id);
- } else {
- committedScopesRef.current.set(id, scope);
- }
- }
-
- // A forwarded renderer owns only its fragment. Publishing or removing it
- // must never replace the descriptors committed by the other roots.
- const scopes = [...committedScopesRef.current.values()];
- const sequences = scopes.flatMap((scope) => scope.sequences);
- const ids = scopes.flatMap((scope) => scope.sequenceIds);
- committedDescriptorsRef.current = new Map(
- sequences.map((sequence) => [sequence.id, sequence]),
- );
- const nextIds = new Set(sequences.map((sequence) => sequence.id));
- const order = new Map(ids.map((id, index) => [id, index]));
- committedOrderIdsRef.current = ids;
- committedOrderRef.current = order;
- committedRegistrationIdsRef.current = nextIds;
- setSequences((current) =>
- reconcileRegistryEntries({
- current,
- entries: sequences,
- previousDescriptors,
- previousKeys: previousIds,
- nextKeys: nextIds,
- getKey: (sequence) => sequence.id,
- order,
- orderProperty: 'timelineOrder',
- }),
- );
- });
- },
- [sequenceManagerId, setSequences],
- );
- const onCommitRootSequences = useCallback(
- (sequences: readonly TSequence[], sequenceIds: readonly string[]) => {
- if (!rootObservationFailedRef.current) {
- observedCommitRef.current = true;
- onCommitSequences(sequenceManagerId, sequences, sequenceIds);
- }
- },
- [onCommitSequences, sequenceManagerId],
- );
- const registryScope = useMemo(
- () => ({
- onCommitSequences,
- commitRegistrationRequested: shouldObserveCommits,
- }),
- [onCommitSequences, shouldObserveCommits],
- );
-
- useIsomorphicLayoutEffect(() => {
- if (!shouldObserveCommits) {
- return;
- }
-
- let unmounted = false;
- registrationUnmountedRef.current = false;
- const onRegistrationError = () => {
- if (registrationObserverFailedRef.current) {
- return;
- }
-
- registrationObserverFailedRef.current = true;
- pendingCommittedSequencesRef.current.clear();
- queueMicrotask(() => {
- if (registrationUnmountedRef.current) {
- return;
- }
-
- const previousIds = committedRegistrationIdsRef.current;
- committedRegistrationIdsRef.current = new Set();
- committedScopesRef.current.clear();
- setSequences((current) =>
- current.filter((sequence) => !previousIds.has(sequence.id)),
- );
- setCommitRegistrationEnabled(false);
- });
- };
-
- const onCommitOrder = (event: Event) => {
- const {detail} = event as CustomEvent<CommitOrderEventDetail>;
- const managerOrder = detail.sequenceManagers.find(
- (item) => item.managerId === sequenceManagerId,
- );
- if (!managerOrder) {
- return;
- }
-
- if (commitRegistrationEnabled) {
- return;
- }
-
- const previousOrder = committedOrderIdsRef.current;
- if (
- previousOrder === managerOrder.sequenceIds ||
- (previousOrder !== null &&
- previousOrder.length === managerOrder.sequenceIds.length &&
- previousOrder.every(
- (sequenceId, index) =>
- sequenceId === managerOrder.sequenceIds[index],
- ))
- ) {
- return;
- }
-
- const order = new Map(
- managerOrder.sequenceIds.map((sequenceId, index) => [
- sequenceId,
- index,
- ]),
- );
- committedOrderIdsRef.current = managerOrder.sequenceIds;
- committedOrderRef.current = order;
- queueMicrotask(() => {
- if (unmounted) {
- return;
- }
-
- setSequences((currentSequences) => {
- let changed = false;
- const nextSequences = currentSequences.map((sequence) => {
- const timelineOrder = order.get(sequence.id) ?? null;
- if (sequence.timelineOrder === timelineOrder) {
- return sequence;
- }
-
- changed = true;
- return {...sequence, timelineOrder};
- });
-
- return changed ? nextSequences : currentSequences;
- });
- });
- };
-
- window.addEventListener(COMMIT_ORDER_EVENT, onCommitOrder);
- window.addEventListener(
- COMMIT_REGISTRATION_ERROR_EVENT,
- onRegistrationError,
- );
- if (commitRegistrationEnabled) {
- // React invokes its commit hook after layout effects. Installation alone
- // does not prove this renderer connected to the hook during initialization.
- queueMicrotask(() => {
- if (
- unmounted ||
- observedCommitRef.current ||
- registrationObserverFailedRef.current
- ) {
- return;
- }
-
- rootObservationFailedRef.current = true;
- onCommitSequences(sequenceManagerId, [], []);
- setCommitRegistrationEnabled(false);
- });
- }
-
- return () => {
- unmounted = true;
- registrationUnmountedRef.current = true;
- // Effect replay must not discard a snapshot already collected by React.
- window.removeEventListener(COMMIT_ORDER_EVENT, onCommitOrder);
- window.removeEventListener(
- COMMIT_REGISTRATION_ERROR_EVENT,
- onRegistrationError,
- );
- };
- }, [
- shouldObserveCommits,
- sequenceManagerId,
- setSequences,
- commitRegistrationEnabled,
- onCommitSequences,
- ]);
-
- const registerSequence = useCallback(
- (seq: TSequence) => {
- setSequences((seqs) => {
- return [
- ...seqs,
- {
- ...seq,
- timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
- },
- ];
- });
- },
- [setSequences],
- );
- const updateSequence = useCallback(
- (seq: TSequence) => {
- setSequences((seqs) => {
- const index = seqs.findIndex((item) => item.id === seq.id);
- if (index === -1) {
- return seqs;
- }
-
- const updatedSequence = {
- ...seq,
- timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
- };
- if (areRegistryEntriesEqual(seqs[index], updatedSequence)) {
- return seqs;
- }
-
- const next = [...seqs];
- next[index] = updatedSequence;
- return next;
- });
- },
- [setSequences],
- );
-
- const unregisterSequence = useCallback(
- (seq: string) => {
- setSequences((seqs) => seqs.filter((s) => s.id !== seq));
- },
- [setSequences],
- );
-
- const actions = useMemo<SequenceManagerActions>(() => {
- return {
- registerSequence,
- updateSequence,
- unregisterSequence,
- };
- }, [registerSequence, unregisterSequence, updateSequence]);
const dragOverridesSubscription = useMemo<
Omit<DragOverridesSubscription, 'manager'>
>(
@@ -1109,72 +728,28 @@ export const SequenceManagerProvider: React.FC<{
[setDragOverridesBatch, setEffectDragOverridesBatch],
);
- const metadata = useMemo<CommittedMetadata | null>(
- () =>
- shouldObserveCommits
- ? {
- type: 'sequence-manager',
- id: sequenceManagerId,
- onCommit: commitRegistrationEnabled ? onCommitRootSequences : null,
- }
- : null,
- [
- commitRegistrationEnabled,
- onCommitRootSequences,
- sequenceManagerId,
- shouldObserveCommits,
- ],
- );
return (
- <SequenceManagerRefProvider
- value={sequencesRef}
- _remotionCommitMetadata={metadata}
- >
- <SequenceRegistryScopeContext.Provider value={registryScope}>
- <SequenceManagerActionsContext.Provider value={actions}>
- <SequenceRegistryContext.Provider value={registry}>
- <SequenceCommitRegistrationContext.Provider
- value={commitRegistrationEnabled}
+ <SequenceRegistryProvider>
+ <VisualModePropStatusesRefContext.Provider value={propStatusesRef}>
+ <VisualModePropStatusesContext.Provider value={propStatusesContext}>
+ <SequenceManagerScopeProviders
+ dragOverridesSubscription={dragOverridesSubscription}
+ fromKeys={dragOverrideState.fromKeys}
+ >
+ <VisualModeDragOverridesContext.Provider
+ value={dragOverridesContext}
>
- <VisualModePropStatusesRefContext.Provider
- value={propStatusesRef}
- >
- <VisualModePropStatusesContext.Provider
- value={propStatusesContext}
+ <VisualModeSettersContext.Provider value={settersContext}>
+ <VisualModeBatchSettersContext.Provider
+ value={batchSettersContext}
>
- <SequenceManagerScopeProviders
- dragOverridesSubscription={dragOverridesSubscription}
- fromKeys={dragOverrideState.fromKeys}
- >
- <VisualModeDragOverridesContext.Provider
- value={dragOverridesContext}
- >
- <VisualModeSettersContext.Provider value={settersContext}>
- <VisualModeBatchSettersContext.Provider
- value={batchSettersContext}
- >
- <SequenceActivityContext.Provider
- value={
- activitySettings?.enabled === true &&
- isStudio &&
- commitRegistrationEnabled &&
- typeof React.Activity !== 'undefined'
- }
- >
- <SequenceActivityBudgetProvider>
- {children}
- </SequenceActivityBudgetProvider>
- </SequenceActivityContext.Provider>
- </VisualModeBatchSettersContext.Provider>
- </VisualModeSettersContext.Provider>
- </VisualModeDragOverridesContext.Provider>
- </SequenceManagerScopeProviders>
- </VisualModePropStatusesContext.Provider>
- </VisualModePropStatusesRefContext.Provider>
- </SequenceCommitRegistrationContext.Provider>
- </SequenceRegistryContext.Provider>
- </SequenceManagerActionsContext.Provider>
- </SequenceRegistryScopeContext.Provider>
- </SequenceManagerRefProvider>
+ {children}
+ </VisualModeBatchSettersContext.Provider>
+ </VisualModeSettersContext.Provider>
+ </VisualModeDragOverridesContext.Provider>
+ </SequenceManagerScopeProviders>
+ </VisualModePropStatusesContext.Provider>
+ </VisualModePropStatusesRefContext.Provider>
+ </SequenceRegistryProvider>
);
};
diff --git a/packages/core/src/SequenceRegistryProvider.tsx b/packages/core/src/SequenceRegistryProvider.tsx
new file mode 100644
index 0000000000..bc5d51b766
--- /dev/null
+++ b/packages/core/src/SequenceRegistryProvider.tsx
@@ -0,0 +1,384 @@
+import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
+import {
+ COMMIT_ORDER_EVENT,
+ COMMIT_REGISTRATION_ERROR_EVENT,
+ isCommitRegistrationObserverInstalled,
+ withCommittedMetadata,
+ type CommittedMetadata,
+ type CommitOrderEventDetail,
+ type CommittedSequenceSnapshot,
+} from './committed-metadata.js';
+import type {TSequence} from './CompositionManager.js';
+import {
+ areRegistryEntriesEqual,
+ createRegistryStore,
+ reconcileRegistryEntries,
+} from './registry-store.js';
+import {
+ SequenceManagerRefContext,
+ SequenceManagerActionsContext,
+ SequenceRegistryScopeContext,
+ SequenceRegistryContext,
+ SequenceCommitRegistrationContext,
+ SequenceRegistrationContext,
+ type SequenceManagerRef,
+ type SequenceManagerActions,
+} from './sequence-registry-context.js';
+import {useRemotionEnvironment} from './use-remotion-environment.js';
+const useIsomorphicLayoutEffect =
+ typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;
+const SequenceManagerRefProvider = withCommittedMetadata(
+ SequenceManagerRefContext.Provider,
+);
+
+export const SequenceRegistryProvider: React.FC<{
+ readonly children: React.ReactNode;
+}> = ({children}) => {
+ const {isStudio} = useRemotionEnvironment();
+ const sequenceRegistrationEnabled = useContext(SequenceRegistrationContext);
+ const shouldObserveCommits = isStudio || sequenceRegistrationEnabled;
+ const [sequenceManagerId] = useState(() => String(Math.random()));
+ const [commitRegistrationEnabled, setCommitRegistrationEnabled] = useState(
+ () => shouldObserveCommits && isCommitRegistrationObserverInstalled(),
+ );
+ const observedCommitRef = useRef(false);
+ const rootObservationFailedRef = useRef(false);
+ const committedRegistrationIdsRef = useRef<ReadonlySet<string>>(new Set());
+ const committedDescriptorsRef = useRef<ReadonlyMap<string, TSequence>>(
+ new Map(),
+ );
+ const pendingCommittedSequencesRef = useRef(
+ new Map<string, CommittedSequenceSnapshot>(),
+ );
+ const committedScopesRef = useRef(
+ new Map<string, CommittedSequenceSnapshot>([
+ [sequenceManagerId, {sequences: [], sequenceIds: []}],
+ ]),
+ );
+ const registrationObserverFailedRef = useRef(false);
+ const registrationUnmountedRef = useRef(false);
+ const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);
+ const committedOrderIdsRef = useRef<readonly string[] | null>(null);
+ const [registry] = useState(() => createRegistryStore<TSequence[]>([]));
+ const setSequences = registry.setSnapshot;
+ const sequencesRef = useMemo<SequenceManagerRef>(
+ () => ({
+ get current() {
+ return registry.getSnapshot();
+ },
+ }),
+ [registry],
+ );
+ const onCommitSequences = useCallback(
+ (
+ scopeId: string,
+ snapshot: readonly TSequence[],
+ sequenceIds: readonly string[],
+ ) => {
+ if (
+ registrationObserverFailedRef.current ||
+ registrationUnmountedRef.current
+ ) {
+ return;
+ }
+
+ const previousSnapshot =
+ pendingCommittedSequencesRef.current.get(scopeId) ??
+ committedScopesRef.current.get(scopeId);
+ if (
+ previousSnapshot?.sequences === snapshot &&
+ previousSnapshot.sequenceIds === sequenceIds
+ ) {
+ return;
+ }
+
+ const alreadyPending = pendingCommittedSequencesRef.current.size > 0;
+ pendingCommittedSequencesRef.current.set(scopeId, {
+ sequences: snapshot,
+ sequenceIds,
+ });
+ if (alreadyPending) {
+ return;
+ }
+
+ // Publish after React finishes committing, and coalesce successive snapshots.
+ queueMicrotask(() => {
+ const pending = pendingCommittedSequencesRef.current;
+ pendingCommittedSequencesRef.current = new Map();
+ if (
+ pending.size === 0 ||
+ registrationObserverFailedRef.current ||
+ registrationUnmountedRef.current
+ ) {
+ return;
+ }
+
+ const previousIds = committedRegistrationIdsRef.current;
+ const previousDescriptors = committedDescriptorsRef.current;
+ for (const [id, scope] of pending) {
+ if (id !== sequenceManagerId && scope.sequenceIds.length === 0) {
+ committedScopesRef.current.delete(id);
+ } else {
+ committedScopesRef.current.set(id, scope);
+ }
+ }
+
+ // A forwarded renderer owns only its fragment. Publishing or removing it
+ // must never replace the descriptors committed by the other roots.
+ const scopes = [...committedScopesRef.current.values()];
+ const sequences = scopes.flatMap((scope) => scope.sequences);
+ const ids = scopes.flatMap((scope) => scope.sequenceIds);
+ committedDescriptorsRef.current = new Map(
+ sequences.map((sequence) => [sequence.id, sequence]),
+ );
+ const nextIds = new Set(sequences.map((sequence) => sequence.id));
+ const order = new Map(ids.map((id, index) => [id, index]));
+ committedOrderIdsRef.current = ids;
+ committedOrderRef.current = order;
+ committedRegistrationIdsRef.current = nextIds;
+ setSequences((current) =>
+ reconcileRegistryEntries({
+ current,
+ entries: sequences,
+ previousDescriptors,
+ previousKeys: previousIds,
+ nextKeys: nextIds,
+ getKey: (sequence) => sequence.id,
+ order,
+ orderProperty: 'timelineOrder',
+ }),
+ );
+ });
+ },
+ [sequenceManagerId, setSequences],
+ );
+ const onCommitRootSequences = useCallback(
+ (sequences: readonly TSequence[], sequenceIds: readonly string[]) => {
+ if (!rootObservationFailedRef.current) {
+ observedCommitRef.current = true;
+ onCommitSequences(sequenceManagerId, sequences, sequenceIds);
+ }
+ },
+ [onCommitSequences, sequenceManagerId],
+ );
+ const registryScope = useMemo(
+ () => ({
+ onCommitSequences,
+ commitRegistrationRequested: shouldObserveCommits,
+ }),
+ [onCommitSequences, shouldObserveCommits],
+ );
+
+ useIsomorphicLayoutEffect(() => {
+ if (!shouldObserveCommits) {
+ return;
+ }
+
+ let unmounted = false;
+ registrationUnmountedRef.current = false;
+ const onRegistrationError = () => {
+ if (registrationObserverFailedRef.current) {
+ return;
+ }
+
+ registrationObserverFailedRef.current = true;
+ pendingCommittedSequencesRef.current.clear();
+ queueMicrotask(() => {
+ if (registrationUnmountedRef.current) {
+ return;
+ }
+
+ const previousIds = committedRegistrationIdsRef.current;
+ committedRegistrationIdsRef.current = new Set();
+ committedScopesRef.current.clear();
+ setSequences((current) =>
+ current.filter((sequence) => !previousIds.has(sequence.id)),
+ );
+ setCommitRegistrationEnabled(false);
+ });
+ };
+
+ const onCommitOrder = (event: Event) => {
+ const {detail} = event as CustomEvent<CommitOrderEventDetail>;
+ const managerOrder = detail.sequenceManagers.find(
+ (item) => item.managerId === sequenceManagerId,
+ );
+ if (!managerOrder) {
+ return;
+ }
+
+ if (commitRegistrationEnabled) {
+ return;
+ }
+
+ const previousOrder = committedOrderIdsRef.current;
+ if (
+ previousOrder === managerOrder.sequenceIds ||
+ (previousOrder !== null &&
+ previousOrder.length === managerOrder.sequenceIds.length &&
+ previousOrder.every(
+ (sequenceId, index) =>
+ sequenceId === managerOrder.sequenceIds[index],
+ ))
+ ) {
+ return;
+ }
+
+ const order = new Map(
+ managerOrder.sequenceIds.map((sequenceId, index) => [
+ sequenceId,
+ index,
+ ]),
+ );
+ committedOrderIdsRef.current = managerOrder.sequenceIds;
+ committedOrderRef.current = order;
+ queueMicrotask(() => {
+ if (unmounted) {
+ return;
+ }
+
+ setSequences((currentSequences) => {
+ let changed = false;
+ const nextSequences = currentSequences.map((sequence) => {
+ const timelineOrder = order.get(sequence.id) ?? null;
+ if (sequence.timelineOrder === timelineOrder) {
+ return sequence;
+ }
+
+ changed = true;
+ return {...sequence, timelineOrder};
+ });
+
+ return changed ? nextSequences : currentSequences;
+ });
+ });
+ };
+
+ window.addEventListener(COMMIT_ORDER_EVENT, onCommitOrder);
+ window.addEventListener(
+ COMMIT_REGISTRATION_ERROR_EVENT,
+ onRegistrationError,
+ );
+ if (commitRegistrationEnabled) {
+ // React invokes its commit hook after layout effects. Installation alone
+ // does not prove this renderer connected to the hook during initialization.
+ queueMicrotask(() => {
+ if (
+ unmounted ||
+ observedCommitRef.current ||
+ registrationObserverFailedRef.current
+ ) {
+ return;
+ }
+
+ rootObservationFailedRef.current = true;
+ onCommitSequences(sequenceManagerId, [], []);
+ setCommitRegistrationEnabled(false);
+ });
+ }
+
+ return () => {
+ unmounted = true;
+ registrationUnmountedRef.current = true;
+ // Effect replay must not discard a snapshot already collected by React.
+ window.removeEventListener(COMMIT_ORDER_EVENT, onCommitOrder);
+ window.removeEventListener(
+ COMMIT_REGISTRATION_ERROR_EVENT,
+ onRegistrationError,
+ );
+ };
+ }, [
+ shouldObserveCommits,
+ sequenceManagerId,
+ setSequences,
+ commitRegistrationEnabled,
+ onCommitSequences,
+ ]);
+
+ const registerSequence = useCallback(
+ (seq: TSequence) => {
+ setSequences((seqs) => {
+ return [
+ ...seqs,
+ {
+ ...seq,
+ timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
+ },
+ ];
+ });
+ },
+ [setSequences],
+ );
+ const updateSequence = useCallback(
+ (seq: TSequence) => {
+ setSequences((seqs) => {
+ const index = seqs.findIndex((item) => item.id === seq.id);
+ if (index === -1) {
+ return seqs;
+ }
+
+ const updatedSequence = {
+ ...seq,
+ timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,
+ };
+ if (areRegistryEntriesEqual(seqs[index], updatedSequence)) {
+ return seqs;
+ }
+
+ const next = [...seqs];
+ next[index] = updatedSequence;
+ return next;
+ });
+ },
+ [setSequences],
+ );
+
+ const unregisterSequence = useCallback(
+ (seq: string) => {
+ setSequences((seqs) => seqs.filter((s) => s.id !== seq));
+ },
+ [setSequences],
+ );
+
+ const actions = useMemo<SequenceManagerActions>(() => {
+ return {
+ registerSequence,
+ updateSequence,
+ unregisterSequence,
+ };
+ }, [registerSequence, unregisterSequence, updateSequence]);
+ const metadata = useMemo<CommittedMetadata | null>(
+ () =>
+ shouldObserveCommits
+ ? {
+ type: 'sequence-manager',
+ id: sequenceManagerId,
+ onCommit: commitRegistrationEnabled ? onCommitRootSequences : null,
+ }
+ : null,
+ [
+ commitRegistrationEnabled,
+ onCommitRootSequences,
+ sequenceManagerId,
+ shouldObserveCommits,
+ ],
+ );
+ return (
+ <SequenceManagerRefProvider
+ value={sequencesRef}
+ _remotionCommitMetadata={metadata}
+ >
+ <SequenceRegistryScopeContext.Provider value={registryScope}>
+ <SequenceManagerActionsContext.Provider value={actions}>
+ <SequenceRegistryContext.Provider value={registry}>
+ <SequenceCommitRegistrationContext.Provider
+ value={commitRegistrationEnabled}
+ >
+ {children}
+ </SequenceCommitRegistrationContext.Provider>
+ </SequenceRegistryContext.Provider>
+ </SequenceManagerActionsContext.Provider>
+ </SequenceRegistryScopeContext.Provider>
+ </SequenceManagerRefProvider>
+ );
+};
diff --git a/packages/core/src/component-identity.ts b/packages/core/src/component-identity.ts
new file mode 100644
index 0000000000..693260e9cb
--- /dev/null
+++ b/packages/core/src/component-identity.ts
@@ -0,0 +1,42 @@
+import React from 'react';
+import {IsNotInsideSeriesProvider} from './series/is-inside-series.js';
+
+type ComponentIdentityResolver = (component: unknown) => unknown;
+// Studio installs a resolver that maps refreshed component implementations to
+// the stable family object maintained by React Refresh.
+let componentIdentityResolver: ComponentIdentityResolver | null = null;
+
+export const setComponentIdentityResolver = (
+ resolver: ComponentIdentityResolver | null,
+) => {
+ componentIdentityResolver = resolver;
+};
+
+export const resolveComponentIdentity = (component: unknown): unknown => {
+ return componentIdentityResolver?.(component) ?? component;
+};
+
+export const getSingleChildComponent = (children: React.ReactNode): unknown => {
+ const mountedChildren = React.Children.toArray(children);
+ if (mountedChildren.length !== 1) {
+ return null;
+ }
+
+ const child = mountedChildren[0];
+ if (!React.isValidElement(child)) {
+ return null;
+ }
+
+ // Series inserts this transparent context boundary around its authored children.
+ if (child.type === IsNotInsideSeriesProvider) {
+ return getSingleChildComponent(
+ (child.props as {children: React.ReactNode}).children,
+ );
+ }
+
+ if (typeof child.type !== 'function' && typeof child.type !== 'object') {
+ return null;
+ }
+
+ return resolveComponentIdentity(child.type);
+};
diff --git a/packages/core/src/create-element-source-proxy.ts b/packages/core/src/create-element-source-proxy.ts
new file mode 100644
index 0000000000..d3d6ee153b
--- /dev/null
+++ b/packages/core/src/create-element-source-proxy.ts
@@ -0,0 +1,56 @@
+import type React from 'react';
+import type JsxRuntimeDev from 'react/jsx-dev-runtime';
+import type JsxRuntime from 'react/jsx-runtime';
+import {
+ getComponentsToAddStacksTo,
+ makeOriginalSourceStack,
+ REMOTION_INTERNAL_STACK_PROP,
+} from './enable-sequence-stack-traces.js';
+
+const componentsToAddStacksTo = getComponentsToAddStacksTo();
+const internalStackProp = REMOTION_INTERNAL_STACK_PROP;
+
+export const createElementSourceProxy = <
+ T extends
+ | typeof React.createElement
+ | typeof JsxRuntime.jsx
+ | typeof JsxRuntimeDev.jsxDEV,
+>(
+ api: T,
+ sourceArgumentIndex: number | null,
+ getSourceFileName: (fileName: string) => string,
+): T => {
+ return new Proxy(api, {
+ apply(target, thisArg, argArray) {
+ const component = argArray[0];
+ if (componentsToAddStacksTo.includes(component)) {
+ const [first, props, ...rest] = argArray;
+ const source =
+ sourceArgumentIndex === null ? null : argArray[sourceArgumentIndex];
+ const existingStack = props?.[internalStackProp];
+ const stack =
+ existingStack ||
+ (source &&
+ typeof source.fileName === 'string' &&
+ typeof source.lineNumber === 'number' &&
+ typeof source.columnNumber === 'number'
+ ? makeOriginalSourceStack({
+ fileName: getSourceFileName(source.fileName),
+ lineNumber: source.lineNumber,
+ columnNumber: source.columnNumber,
+ })
+ : new Error().stack);
+ const newProps = existingStack
+ ? {...props}
+ : {
+ ...(props ?? {}),
+ [internalStackProp]: stack,
+ };
+
+ return Reflect.apply(target, thisArg, [first, newProps, ...rest]);
+ }
+
+ return Reflect.apply(target, thisArg, argArray);
+ },
+ });
+};
diff --git a/packages/core/src/enable-sequence-stack-traces.ts b/packages/core/src/enable-sequence-stack-traces.ts
index a3da9963b4..cba3278e2c 100644
--- a/packages/core/src/enable-sequence-stack-traces.ts
+++ b/packages/core/src/enable-sequence-stack-traces.ts
@@ -1,14 +1,7 @@
-import React from 'react';
import type {SequenceControls} from './CompositionManager.js';
const componentsToAddStacksTo: unknown[] = [];
-let sequenceComponent: unknown = null;
const stacksByControls = new WeakMap<SequenceControls, string>();
-type ComponentIdentityResolver = (component: unknown) => unknown;
-// Studio installs a resolver that maps refreshed component implementations to
-// the stable family object maintained by React Refresh.
-let componentIdentityResolver: ComponentIdentityResolver | null = null;
-
export const REMOTION_INTERNAL_STACK_PROP = '_remotionInternalStack';
// Bundlers that know where a JSX element was written encode its source
@@ -60,22 +53,6 @@ export const addSequenceStackTraces = (component: unknown) => {
componentsToAddStacksTo.push(component);
};
-export const setSequenceComponent = (component: unknown) => {
- sequenceComponent = component;
-};
-
-export const getSequenceComponent = () => sequenceComponent;
-
-export const setComponentIdentityResolver = (
- resolver: ComponentIdentityResolver | null,
-) => {
- componentIdentityResolver = resolver;
-};
-
-export const resolveComponentIdentity = (component: unknown): unknown => {
- return componentIdentityResolver?.(component) ?? component;
-};
-
export const setStackForControls = (
controls: SequenceControls,
stack: string | undefined,
@@ -93,21 +70,3 @@ export const getStackForControls = (
): string | null => {
return stacksByControls.get(controls) ?? null;
};
-
-export const getSingleChildComponent = (children: React.ReactNode): unknown => {
- const mountedChildren = React.Children.toArray(children);
- if (mountedChildren.length !== 1) {
- return null;
- }
-
- const child = mountedChildren[0];
- if (!React.isValidElement(child)) {
- return null;
- }
-
- if (typeof child.type !== 'function' && typeof child.type !== 'object') {
- return null;
- }
-
- return resolveComponentIdentity(child.type);
-};
diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index bbd877224f..ff246993df 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -14,10 +14,7 @@ import type {
TRenderAsset,
} from './CompositionManager.js';
import type {DelayRenderScope} from './delay-render.js';
-import {
- addSequenceStackTraces,
- setSequenceComponent,
-} from './enable-sequence-stack-traces.js';
+import {addSequenceStackTraces} from './enable-sequence-stack-traces.js';
import {Folder, type TFolder} from './Folder.js';
import type {StaticFile} from './get-static-files.js';
import type {
@@ -332,7 +329,6 @@ export const Config = new Proxy(proxyObj, {
Sequence.displayName = 'Sequence';
addSequenceStackTraces(Sequence);
-setSequenceComponent(Sequence);
addSequenceStackTraces(Composition);
addSequenceStackTraces(Folder);
diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.ts
index 799757d281..049a823b47 100644
--- a/packages/core/src/internals.ts
+++ b/packages/core/src/internals.ts
@@ -29,6 +29,10 @@ import {
CommittedMetadataProvider,
withCommittedMetadata,
} from './committed-metadata.js';
+import {
+ getSingleChildComponent,
+ setComponentIdentityResolver,
+} from './component-identity.js';
import {CompositionRenderErrorContext} from './composition-render-error-context.js';
import {type CompProps} from './Composition.js';
import type {
@@ -46,6 +50,7 @@ import {
} from './CompositionManagerContext.js';
import {CompositionManagerProvider} from './CompositionManagerProvider.js';
import {CompositionRegistryProvider} from './CompositionRegistryProvider.js';
+import {createElementSourceProxy} from './create-element-source-proxy.js';
import * as CSSUtils from './default-css.js';
import {OBJECTFIT_CONTAIN_CLASS_NAME} from './default-css.js';
import {DefaultPremountContext} from './DefaultPremountContext.js';
@@ -74,13 +79,10 @@ import {
import {
addSequenceStackTraces,
getComponentsToAddStacksTo,
- getSequenceComponent,
- getSingleChildComponent,
getStackForControls,
makeOriginalSourceStack,
parseOriginalSourceStack,
REMOTION_INTERNAL_STACK_PROP,
- setComponentIdentityResolver,
type OriginalSourceLocation,
} from './enable-sequence-stack-traces.js';
import {
@@ -345,6 +347,7 @@ const compositionSelectorRef = createRef<{
// Mark them as Internals so use don't assume this is public
// API and are less likely to use it
export const Internals = {
+ createElementSourceProxy,
CommittedMetadataProvider,
withCommittedMetadata,
DefaultPremountContext,
@@ -480,7 +483,6 @@ export const Internals = {
BufferingProvider,
BufferingContextReact,
getComponentsToAddStacksTo,
- getSequenceComponent,
getSingleChildComponent,
getStackForControls,
makeOriginalSourceStack,
diff --git a/packages/core/src/sequence-registry-context.tsx b/packages/core/src/sequence-registry-context.tsx
new file mode 100644
index 0000000000..4f051d7536
--- /dev/null
+++ b/packages/core/src/sequence-registry-context.tsx
@@ -0,0 +1,74 @@
+import React, {useContext} from 'react';
+import type {TSequence} from './CompositionManager.js';
+import type {RegistryStore} from './registry-store.js';
+import {useSyncExternalStore} from './use-sync-external-store.js';
+
+export type SequenceManagerActions = {
+ registerSequence: (seq: TSequence) => void;
+ updateSequence: (seq: TSequence) => void;
+ unregisterSequence: (id: string) => void;
+};
+
+export type SequenceManagerRef = {
+ current: TSequence[];
+};
+
+export type SequenceNodePath = Array<string | number>;
+
+const defaultSequenceManagerActions: SequenceManagerActions = {
+ registerSequence: () => {
+ throw new Error('SequenceManagerActionsContext not initialized');
+ },
+ updateSequence: () => {
+ throw new Error('SequenceManagerActionsContext not initialized');
+ },
+ unregisterSequence: () => {
+ throw new Error('SequenceManagerActionsContext not initialized');
+ },
+};
+
+export const SequenceManagerActionsContext = React.createContext(
+ defaultSequenceManagerActions,
+);
+
+export const SequenceRegistryContext = React.createContext<RegistryStore<
+ TSequence[]
+> | null>(null);
+const subscribeToNoRegistry = () => () => undefined;
+const emptySequences: TSequence[] = [];
+const getEmptySequences = () => emptySequences;
+export const SequenceCommitRegistrationContext = React.createContext(false);
+export const SequenceRegistryScopeContext = React.createContext<{
+ readonly commitRegistrationRequested: boolean;
+ readonly onCommitSequences: (
+ scopeId: string,
+ sequences: readonly TSequence[],
+ sequenceIds: readonly string[],
+ ) => void;
+} | null>(null);
+export const useSequenceManagerSequences = (): TSequence[] => {
+ const registry = useContext(SequenceRegistryContext);
+ return useSyncExternalStore(
+ registry?.subscribe ?? subscribeToNoRegistry,
+ registry?.getSnapshot ?? getEmptySequences,
+ registry?.getSnapshot ?? getEmptySequences,
+ );
+};
+
+export const SequenceManagerRefContext =
+ React.createContext<SequenceManagerRef>({
+ current: [],
+ });
+export const SequenceRegistrationContext = React.createContext(false);
+
+export const DisableSequenceRegistrationContext = React.createContext(false);
+
+export const DisableSequenceRegistrationProvider: React.FC<{
+ readonly children: React.ReactNode;
+}> = ({children}) => {
+ return React.createElement(
+ DisableSequenceRegistrationContext.Provider,
+ {value: true},
+ children,
+ );
+};
diff --git a/packages/core/src/series/index.tsx b/packages/core/src/series/index.tsx
index 9663fc4cc2..5194add8f9 100644
--- a/packages/core/src/series/index.tsx
+++ b/packages/core/src/series/index.tsx
@@ -5,10 +5,7 @@ import React, {
type PropsWithChildren,
} from 'react';
import type {SequenceControls} from '../CompositionManager.js';
-import {
- addSequenceStackTraces,
- getSingleChildComponent,
-} from '../enable-sequence-stack-traces.js';
+import {addSequenceStackTraces} from '../enable-sequence-stack-traces.js';
import {Interactive} from '../Interactive.js';
import {
sequenceSchemaDefaultLayoutNone,
@@ -243,9 +240,6 @@ const SeriesInner: FC<SeriesProps> = (props) => {
role: 'clip',
seriesOffset: offset,
}}
- _remotionInternalSingleChildComponent={getSingleChildComponent(
- sequenceChildren,
- )}
>
<IsNotInsideSeriesProvider>
{sequenceChildren}
diff --git a/packages/core/src/test/single-child-component.test.tsx b/packages/core/src/test/single-child-component.test.tsx
index c306e2ecfd..1b7e091912 100644
--- a/packages/core/src/test/single-child-component.test.tsx
+++ b/packages/core/src/test/single-child-component.test.tsx
@@ -3,7 +3,7 @@ import React from 'react';
import {
getSingleChildComponent,
setComponentIdentityResolver,
-} from '../enable-sequence-stack-traces';
+} from '../component-identity';
const Child: React.FC = () => null;
const OtherChild: React.FC = () => null;
diff --git a/packages/core/src/test/still-stack.test.tsx b/packages/core/src/test/still-stack.test.tsx
index eaaf01ebac..a3ea3932a3 100644
--- a/packages/core/src/test/still-stack.test.tsx
+++ b/packages/core/src/test/still-stack.test.tsx
@@ -1,9 +1,9 @@
import {afterEach, expect, test} from 'bun:test';
import {cleanup, render, waitFor} from '@testing-library/react';
import React from 'react';
+import {setComponentIdentityResolver} from '../component-identity.js';
import type {AnyComposition} from '../CompositionManager.js';
import {CompositionRegistryProvider} from '../CompositionRegistryProvider.js';
-import {setComponentIdentityResolver} from '../enable-sequence-stack-traces.js';
import {Internals} from '../internals.js';
import {Still} from '../Still.js';
diff --git a/packages/sdk/src/canvas-internals.ts b/packages/sdk/src/canvas-internals.ts
index 2e552182d7..2e7f7fb959 100644
--- a/packages/sdk/src/canvas-internals.ts
+++ b/packages/sdk/src/canvas-internals.ts
@@ -1,8 +1,8 @@
// Shared with Remotion Studio through CanvasInternals on the package root.
export {
- collectCommitOrderFromFiber,
- installFiberCommitOrderObserver,
-} from './install-fiber-sequence-order-observer';
+ collectReactCommit,
+ installReactCommitObserver,
+} from './react-commit-adapter';
export {calculateTimeline} from './calculate-timeline';
export {useIsCanvasSequenceHovered} from './hover';
export type {
diff --git a/packages/sdk/src/canvas.tsx b/packages/sdk/src/canvas.tsx
index 7e95914bcf..3e0585c696 100644
--- a/packages/sdk/src/canvas.tsx
+++ b/packages/sdk/src/canvas.tsx
@@ -13,7 +13,7 @@ import {Internals} from 'remotion';
import type {CanvasController} from './canvas-controller';
import {getCanvasControllerInternals} from './canvas-controller';
import {CanvasOutlineOverlay} from './canvas-outline-overlay';
-import {installFiberCommitOrderObserver} from './install-fiber-sequence-order-observer';
+import {installReactCommitObserver} from './react-commit-adapter';
import type {CanvasSequenceNodePathResolver} from './sequence-node-path';
import {getCanvasSequenceNodePathInfo} from './sequence-node-path';
import type {
@@ -81,7 +81,7 @@ const CanvasFn = <
// observer when outlines are hidden. Installation is idempotent and reads
// sequence descriptors only after React commits the tree.
if (typeof window !== 'undefined') {
- installFiberCommitOrderObserver(window);
+ installReactCommitObserver(window);
}
const internals = getCanvasControllerInternals(controller);
diff --git a/packages/sdk/src/commit-outline-collector.ts b/packages/sdk/src/commit-outline-collector.ts
new file mode 100644
index 0000000000..9bfc531ad6
--- /dev/null
+++ b/packages/sdk/src/commit-outline-collector.ts
@@ -0,0 +1,83 @@
+import type {RefObject} from 'react';
+import {Internals} from 'remotion';
+import type {Fiber, CommittedMetadata} from './react-commit-types';
+
+export type OutlineCollectors = readonly (Element | Text)[][] | null;
+
+export const createCommitOutlineCollector = () => {
+ const outlineNodesByRef = new Map<
+ RefObject<Element | null>,
+ (Element | Text)[]
+ >();
+ let outlineCollectionFailed = false;
+ return {
+ visit: (
+ fiber: Fiber,
+ metadata: CommittedMetadata | null,
+ outlineCollectors: OutlineCollectors,
+ ): OutlineCollectors => {
+ let childOutlineCollectors = outlineCollectors;
+ if (outlineCollectionFailed) {
+ childOutlineCollectors = null;
+ } else {
+ try {
+ // A portal ends the current DOM group, but can contain new sequences.
+ // Hidden Offscreen trees must not contribute geometry, including new groups.
+ const {tag} = fiber;
+ const skipOutline =
+ outlineCollectors === null ||
+ (tag === 22 && fiber.memoizedState !== null);
+ childOutlineCollectors = skipOutline
+ ? null
+ : tag === 4
+ ? []
+ : outlineCollectors;
+ if (metadata?.type === 'sequence') {
+ const outlineRef = metadata.outlineChildrenRef;
+ if (outlineRef !== null) {
+ const nodes: (Element | Text)[] = [];
+ outlineNodesByRef.set(outlineRef, nodes);
+ if (childOutlineCollectors !== null) {
+ childOutlineCollectors = [...childOutlineCollectors, nodes];
+ }
+ }
+ }
+
+ if (
+ childOutlineCollectors !== null &&
+ childOutlineCollectors.length > 0 &&
+ (tag === 5 || tag === 6) &&
+ fiber.stateNode !== null
+ ) {
+ for (const collector of childOutlineCollectors) {
+ collector.push(fiber.stateNode as Element | Text);
+ }
+
+ // Only first-level DOM nodes belong to this group. Keep traversing
+ // for sequence order and for new groups nested inside this element.
+ childOutlineCollectors = [];
+ }
+ } catch {
+ // Discard incomplete geometry for this commit without losing registrations.
+ // The next commit retries outline collection with a fresh map.
+ outlineCollectionFailed = true;
+ outlineNodesByRef.clear();
+ childOutlineCollectors = null;
+ }
+ }
+
+ return childOutlineCollectors;
+ },
+ publish: () => {
+ for (const [ref, nodes] of outlineNodesByRef) {
+ try {
+ Internals.SequenceOutlineInternals.setNodes(ref, nodes);
+ } catch {
+ // A failed outline publication is retried on the next commit.
+ }
+ }
+
+ return outlineNodesByRef.size;
+ },
+ };
+};
diff --git a/packages/sdk/src/commit-registry-collector.ts b/packages/sdk/src/commit-registry-collector.ts
new file mode 100644
index 0000000000..a4c12aceb8
--- /dev/null
+++ b/packages/sdk/src/commit-registry-collector.ts
@@ -0,0 +1,234 @@
+import type {AnyComposition, TSequence} from 'remotion';
+import type {CommittedMetadata} from './react-commit-types';
+export type CommittedSequenceRegistration = {
+ readonly onCommit: (
+ sequences: readonly TSequence[],
+ sequenceIds: readonly string[],
+ ) => void;
+ readonly sequences: readonly TSequence[];
+ readonly sequenceIds: readonly string[];
+};
+
+type FolderRegistration = {
+ readonly name: string;
+ readonly parent: string | null;
+ readonly order: number | null;
+ readonly stack: string | null;
+};
+
+type CommittedCompositionSnapshot = {
+ readonly compositions: readonly AnyComposition[];
+ readonly folders: readonly FolderRegistration[];
+ readonly orderIds: readonly string[];
+};
+
+export type CommittedCompositionRegistration = {
+ readonly onCommit: (snapshot: CommittedCompositionSnapshot) => void;
+ readonly snapshot: CommittedCompositionSnapshot;
+};
+
+// Compare while traversing, and allocate only after the first changed entry.
+const createCommitSnapshotCollector = <T>(previous: readonly T[] | null) => {
+ let count = 0;
+ let values: T[] | null = null;
+ return {
+ push: (value: T) => {
+ if (values !== null) {
+ values.push(value);
+ } else if (previous?.[count] !== value) {
+ values = previous?.slice(0, count) ?? [];
+ values.push(value);
+ }
+
+ count++;
+ },
+ getSnapshot: (): readonly T[] =>
+ values ??
+ (previous?.length === count
+ ? previous
+ : (previous?.slice(0, count) ?? [])),
+ };
+};
+
+export const createCommitRegistryCollector = (
+ registrations: Map<string, CommittedSequenceRegistration> | null = null,
+ previousRegistrations: ReadonlyMap<
+ string,
+ CommittedSequenceRegistration
+ > | null = null,
+ compositionRegistry: {
+ readonly registrations: Map<string, CommittedCompositionRegistration>;
+ readonly previous: ReadonlyMap<
+ string,
+ CommittedCompositionRegistration
+ > | null;
+ } | null = null,
+) => {
+ const compositionRegistrations = compositionRegistry?.registrations ?? null;
+ const previousCompositionRegistrations =
+ compositionRegistry?.previous ?? null;
+ const sequencesByManager = new Map<
+ string,
+ {
+ readonly sequenceIds: ReturnType<
+ typeof createCommitSnapshotCollector<string>
+ >;
+ readonly registration: {
+ readonly onCommit: CommittedSequenceRegistration['onCommit'];
+ readonly sequences: ReturnType<
+ typeof createCommitSnapshotCollector<TSequence>
+ >;
+ readonly previous: CommittedSequenceRegistration | null;
+ } | null;
+ }
+ >();
+ const compositionsAndFoldersByManager = new Map<
+ string,
+ {
+ readonly registration: {
+ readonly onCommit: CommittedCompositionRegistration['onCommit'];
+ readonly previous: CommittedCompositionRegistration | null;
+ readonly compositions: ReturnType<
+ typeof createCommitSnapshotCollector<AnyComposition>
+ >;
+ readonly folders: ReturnType<
+ typeof createCommitSnapshotCollector<FolderRegistration>
+ >;
+ readonly orderIds: ReturnType<
+ typeof createCommitSnapshotCollector<string>
+ >;
+ } | null;
+ }
+ >();
+
+ const visit = (
+ metadata: CommittedMetadata | null,
+ sequenceManagerId: string | null,
+ compositionManagerId: string | null,
+ ) => {
+ if (
+ metadata?.type === 'sequence-manager' &&
+ !sequencesByManager.has(metadata.id)
+ ) {
+ const previous = previousRegistrations?.get(metadata.id) ?? null;
+ const {onCommit} = metadata;
+ sequencesByManager.set(metadata.id, {
+ sequenceIds: createCommitSnapshotCollector(
+ previous?.sequenceIds ?? null,
+ ),
+ registration:
+ registrations !== null && onCommit !== null
+ ? {
+ onCommit,
+ sequences: createCommitSnapshotCollector(
+ previous?.sequences ?? null,
+ ),
+ previous,
+ }
+ : null,
+ });
+ }
+
+ if (
+ metadata?.type === 'composition-manager' &&
+ !compositionsAndFoldersByManager.has(metadata.id)
+ ) {
+ const previous =
+ previousCompositionRegistrations?.get(metadata.id) ?? null;
+ const {onCommit} = metadata;
+ compositionsAndFoldersByManager.set(metadata.id, {
+ registration:
+ compositionRegistrations !== null && onCommit !== null
+ ? {
+ onCommit,
+ previous,
+ compositions: createCommitSnapshotCollector(
+ previous?.snapshot.compositions ?? null,
+ ),
+ folders: createCommitSnapshotCollector(
+ previous?.snapshot.folders ?? null,
+ ),
+ orderIds: createCommitSnapshotCollector(
+ previous?.snapshot.orderIds ?? null,
+ ),
+ }
+ : null,
+ });
+ }
+
+ if (metadata?.type === 'sequence' && sequenceManagerId !== null) {
+ const manager = sequencesByManager.get(sequenceManagerId);
+ manager?.sequenceIds.push(metadata.id);
+ if (metadata.value !== null) {
+ manager?.registration?.sequences.push(metadata.value);
+ }
+ }
+
+ if (
+ (metadata?.type === 'composition' || metadata?.type === 'folder') &&
+ compositionManagerId !== null
+ ) {
+ const manager = compositionsAndFoldersByManager.get(compositionManagerId);
+ manager?.registration?.orderIds.push(`${metadata.type}:${metadata.id}`);
+ if (metadata.type === 'composition') {
+ manager?.registration?.compositions.push(metadata.value);
+ } else {
+ manager?.registration?.folders.push(metadata.value);
+ }
+ }
+ };
+
+ return {
+ visit,
+ getSnapshot: () => {
+ const sequenceManagers = [...sequencesByManager].map(
+ ([managerId, manager]) => {
+ const sequenceIds = manager.sequenceIds.getSnapshot();
+ const {registration} = manager;
+ if (registration !== null && registrations !== null) {
+ const sequences = registration.sequences.getSnapshot();
+ const {previous} = registration;
+ registrations.set(
+ managerId,
+ previous !== null &&
+ previous.onCommit === registration.onCommit &&
+ previous.sequences === sequences &&
+ previous.sequenceIds === sequenceIds
+ ? previous
+ : {onCommit: registration.onCommit, sequences, sequenceIds},
+ );
+ }
+
+ return {managerId, sequenceIds};
+ },
+ );
+
+ for (const [managerId, manager] of compositionsAndFoldersByManager) {
+ const {registration} = manager;
+ if (registration !== null && compositionRegistrations !== null) {
+ const compositions = registration.compositions.getSnapshot();
+ const folders = registration.folders.getSnapshot();
+ const orderIds = registration.orderIds.getSnapshot();
+ const {previous} = registration;
+ compositionRegistrations.set(
+ managerId,
+ previous !== null &&
+ previous.onCommit === registration.onCommit &&
+ previous.snapshot.compositions === compositions &&
+ previous.snapshot.folders === folders &&
+ previous.snapshot.orderIds === orderIds
+ ? previous
+ : {
+ onCommit: registration.onCommit,
+ snapshot: {compositions, folders, orderIds},
+ },
+ );
+ }
+ }
+
+ return {
+ sequenceManagers,
+ };
+ },
+ };
+};
diff --git a/packages/sdk/src/install-fiber-sequence-order-observer.ts b/packages/sdk/src/install-fiber-sequence-order-observer.ts
deleted file mode 100644
index 7d73620895..0000000000
--- a/packages/sdk/src/install-fiber-sequence-order-observer.ts
+++ /dev/null
@@ -1,506 +0,0 @@
-import type {ComponentProps, RefObject} from 'react';
-import type {AnyComposition, TSequence} from 'remotion';
-import {Internals} from 'remotion';
-
-type Fiber = {
- readonly child: Fiber | null;
- readonly memoizedProps: unknown;
- readonly sibling: Fiber | null;
- readonly tag: number | null;
- readonly stateNode: unknown;
- readonly memoizedState: unknown;
-};
-
-type FiberRoot = {
- readonly current: Fiber;
-};
-
-type DevToolsHook = {
- readonly supportsFiber?: boolean;
- onCommitFiberRoot?: (
- this: DevToolsHook,
- rendererId: number,
- root: FiberRoot,
- priorityLevel: unknown,
- didError: boolean,
- ) => unknown;
- [key: symbol]: unknown;
-};
-
-type HookTarget = Window &
- typeof globalThis & {
- __REACT_DEVTOOLS_GLOBAL_HOOK__?: DevToolsHook;
- };
-
-const {installationMarker, metadataProp} = Internals.CommittedMetadataInternals;
-
-type CommittedMetadata = NonNullable<
- ComponentProps<
- typeof Internals.CommittedMetadataProvider
- >[typeof metadataProp]
->;
-
-const getCommittedMetadata = (props: unknown): CommittedMetadata | null => {
- if (typeof props !== 'object' || props === null) {
- return null;
- }
-
- const metadata: unknown = Reflect.get(props, metadataProp);
- return typeof metadata === 'object' && metadata !== null
- ? (metadata as CommittedMetadata)
- : null;
-};
-
-type CommittedSequenceRegistration = {
- readonly onCommit: (
- sequences: readonly TSequence[],
- sequenceIds: readonly string[],
- ) => void;
- readonly sequences: readonly TSequence[];
- readonly sequenceIds: readonly string[];
-};
-
-type FolderRegistration = {
- readonly name: string;
- readonly parent: string | null;
- readonly order: number | null;
- readonly stack: string | null;
-};
-
-type CommittedCompositionSnapshot = {
- readonly compositions: readonly AnyComposition[];
- readonly folders: readonly FolderRegistration[];
- readonly orderIds: readonly string[];
-};
-
-type CommittedCompositionRegistration = {
- readonly onCommit: (snapshot: CommittedCompositionSnapshot) => void;
- readonly snapshot: CommittedCompositionSnapshot;
-};
-
-// Compare while traversing, and allocate only after the first changed entry.
-const createCommitSnapshotCollector = <T>(previous: readonly T[] | null) => {
- let count = 0;
- let values: T[] | null = null;
- return {
- push: (value: T) => {
- if (values !== null) {
- values.push(value);
- } else if (previous?.[count] !== value) {
- values = previous?.slice(0, count) ?? [];
- values.push(value);
- }
-
- count++;
- },
- getSnapshot: (): readonly T[] =>
- values ??
- (previous?.length === count
- ? previous
- : (previous?.slice(0, count) ?? [])),
- };
-};
-
-export const collectCommitOrderFromFiber = (
- root: FiberRoot,
- registrations: Map<string, CommittedSequenceRegistration> | null = null,
- previousRegistrations: ReadonlyMap<
- string,
- CommittedSequenceRegistration
- > | null = null,
- compositionRegistry: {
- readonly registrations: Map<string, CommittedCompositionRegistration>;
- readonly previous: ReadonlyMap<
- string,
- CommittedCompositionRegistration
- > | null;
- } | null = null,
-) => {
- const compositionRegistrations = compositionRegistry?.registrations ?? null;
- const previousCompositionRegistrations =
- compositionRegistry?.previous ?? null;
- const outlineNodesByRef = new Map<
- RefObject<Element | null>,
- (Element | Text)[]
- >();
- let outlineCollectionFailed = false;
- const sequencesByManager = new Map<
- string,
- {
- readonly sequenceIds: ReturnType<
- typeof createCommitSnapshotCollector<string>
- >;
- readonly registration: {
- readonly onCommit: CommittedSequenceRegistration['onCommit'];
- readonly sequences: ReturnType<
- typeof createCommitSnapshotCollector<TSequence>
- >;
- readonly previous: CommittedSequenceRegistration | null;
- } | null;
- }
- >();
- const compositionsAndFoldersByManager = new Map<
- string,
- {
- readonly registration: {
- readonly onCommit: CommittedCompositionRegistration['onCommit'];
- readonly previous: CommittedCompositionRegistration | null;
- readonly compositions: ReturnType<
- typeof createCommitSnapshotCollector<AnyComposition>
- >;
- readonly folders: ReturnType<
- typeof createCommitSnapshotCollector<FolderRegistration>
- >;
- readonly orderIds: ReturnType<
- typeof createCommitSnapshotCollector<string>
- >;
- } | null;
- }
- >();
-
- const visit = (
- fiber: Fiber,
- currentSequenceManagerId: string | null,
- currentCompositionManagerId: string | null,
- outlineCollectors: readonly (Element | Text)[][] | null,
- ) => {
- const metadata = getCommittedMetadata(fiber.memoizedProps);
- if (outlineCollectors === null && metadata === null) {
- // No metadata or geometry starts here inside an already hidden tree.
- // Keep visiting descendants for registrations without rebuilding outlines.
- let hiddenChild = fiber.child;
- while (hiddenChild !== null) {
- visit(
- hiddenChild,
- currentSequenceManagerId,
- currentCompositionManagerId,
- null,
- );
- hiddenChild = hiddenChild.sibling;
- }
-
- return;
- }
-
- const sequenceManagerId =
- metadata?.type === 'sequence-manager'
- ? metadata.id
- : currentSequenceManagerId;
- if (
- metadata?.type === 'sequence-manager' &&
- !sequencesByManager.has(metadata.id)
- ) {
- const previous = previousRegistrations?.get(metadata.id) ?? null;
- const {onCommit} = metadata;
- sequencesByManager.set(metadata.id, {
- sequenceIds: createCommitSnapshotCollector(
- previous?.sequenceIds ?? null,
- ),
- registration:
- registrations !== null && onCommit !== null
- ? {
- onCommit,
- sequences: createCommitSnapshotCollector(
- previous?.sequences ?? null,
- ),
- previous,
- }
- : null,
- });
- }
-
- const compositionManagerId =
- metadata?.type === 'composition-manager'
- ? metadata.id
- : currentCompositionManagerId;
- if (
- metadata?.type === 'composition-manager' &&
- !compositionsAndFoldersByManager.has(metadata.id)
- ) {
- const previous =
- previousCompositionRegistrations?.get(metadata.id) ?? null;
- const {onCommit} = metadata;
- compositionsAndFoldersByManager.set(metadata.id, {
- registration:
- compositionRegistrations !== null && onCommit !== null
- ? {
- onCommit,
- previous,
- compositions: createCommitSnapshotCollector(
- previous?.snapshot.compositions ?? null,
- ),
- folders: createCommitSnapshotCollector(
- previous?.snapshot.folders ?? null,
- ),
- orderIds: createCommitSnapshotCollector(
- previous?.snapshot.orderIds ?? null,
- ),
- }
- : null,
- });
- }
-
- if (metadata?.type === 'sequence' && sequenceManagerId !== null) {
- const manager = sequencesByManager.get(sequenceManagerId);
- manager?.sequenceIds.push(metadata.id);
- if (metadata.value !== null) {
- manager?.registration?.sequences.push(metadata.value);
- }
- }
-
- if (
- (metadata?.type === 'composition' || metadata?.type === 'folder') &&
- compositionManagerId !== null
- ) {
- const manager = compositionsAndFoldersByManager.get(compositionManagerId);
- manager?.registration?.orderIds.push(`${metadata.type}:${metadata.id}`);
- if (metadata.type === 'composition') {
- manager?.registration?.compositions.push(metadata.value);
- } else {
- manager?.registration?.folders.push(metadata.value);
- }
- }
-
- let childOutlineCollectors = outlineCollectors;
- if (outlineCollectionFailed) {
- childOutlineCollectors = null;
- } else {
- try {
- // A portal ends the current DOM group, but can contain new sequences.
- // Hidden Offscreen trees must not contribute geometry, including new groups.
- const {tag} = fiber;
- const skipOutline =
- outlineCollectors === null ||
- (tag === 22 && fiber.memoizedState !== null);
- childOutlineCollectors = skipOutline
- ? null
- : tag === 4
- ? []
- : outlineCollectors;
- if (metadata?.type === 'sequence') {
- const outlineRef = metadata.outlineChildrenRef;
- if (outlineRef !== null) {
- const nodes: (Element | Text)[] = [];
- outlineNodesByRef.set(outlineRef, nodes);
- if (childOutlineCollectors !== null) {
- childOutlineCollectors = [...childOutlineCollectors, nodes];
- }
- }
- }
-
- if (
- childOutlineCollectors !== null &&
- childOutlineCollectors.length > 0 &&
- (tag === 5 || tag === 6) &&
- fiber.stateNode !== null
- ) {
- for (const collector of childOutlineCollectors) {
- collector.push(fiber.stateNode as Element | Text);
- }
-
- // Only first-level DOM nodes belong to this group. Keep traversing
- // for sequence order and for new groups nested inside this element.
- childOutlineCollectors = [];
- }
- } catch {
- // Discard incomplete geometry for this commit without losing registrations.
- // The next commit retries outline collection with a fresh map.
- outlineCollectionFailed = true;
- outlineNodesByRef.clear();
- childOutlineCollectors = null;
- }
- }
-
- let {child} = fiber;
- while (child !== null) {
- visit(
- child,
- sequenceManagerId,
- compositionManagerId,
- childOutlineCollectors,
- );
- child = child.sibling;
- }
- };
-
- visit(root.current, null, null, []);
- for (const [ref, nodes] of outlineNodesByRef) {
- try {
- Internals.SequenceOutlineInternals.setNodes(ref, nodes);
- } catch {
- // A failed outline publication is retried on the next commit.
- }
- }
-
- const sequenceManagers = [...sequencesByManager].map(
- ([managerId, manager]) => {
- const sequenceIds = manager.sequenceIds.getSnapshot();
- const {registration} = manager;
- if (registration !== null && registrations !== null) {
- const sequences = registration.sequences.getSnapshot();
- const {previous} = registration;
- registrations.set(
- managerId,
- previous !== null &&
- previous.onCommit === registration.onCommit &&
- previous.sequences === sequences &&
- previous.sequenceIds === sequenceIds
- ? previous
- : {onCommit: registration.onCommit, sequences, sequenceIds},
- );
- }
-
- return {managerId, sequenceIds};
- },
- );
-
- for (const [managerId, manager] of compositionsAndFoldersByManager) {
- const {registration} = manager;
- if (registration !== null && compositionRegistrations !== null) {
- const compositions = registration.compositions.getSnapshot();
- const folders = registration.folders.getSnapshot();
- const orderIds = registration.orderIds.getSnapshot();
- const {previous} = registration;
- compositionRegistrations.set(
- managerId,
- previous !== null &&
- previous.onCommit === registration.onCommit &&
- previous.snapshot.compositions === compositions &&
- previous.snapshot.folders === folders &&
- previous.snapshot.orderIds === orderIds
- ? previous
- : {
- onCommit: registration.onCommit,
- snapshot: {compositions, folders, orderIds},
- },
- );
- }
- }
-
- return {
- outlineCount: outlineNodesByRef.size,
- sequenceManagers,
- };
-};
-
-export const installFiberCommitOrderObserver = (
- target: HookTarget,
-): boolean => {
- const hook = target.__REACT_DEVTOOLS_GLOBAL_HOOK__;
- if (!hook?.supportsFiber) {
- return false;
- }
-
- if (hook[installationMarker] === true) {
- return true;
- }
-
- const previousOnCommitFiberRoot = hook.onCommitFiberRoot;
- const registrationsByRoot = new WeakMap<
- FiberRoot,
- Map<string, CommittedSequenceRegistration>
- >();
- const compositionRegistrationsByRoot = new WeakMap<
- FiberRoot,
- Map<string, CommittedCompositionRegistration>
- >();
-
- hook.onCommitFiberRoot = function (...args) {
- let order: ReturnType<typeof collectCommitOrderFromFiber> | null = null;
- try {
- const [, root] = args;
- const registrations = new Map<string, CommittedSequenceRegistration>();
- const previousRegistrations = registrationsByRoot.get(root);
- const compositionRegistrations = new Map<
- string,
- CommittedCompositionRegistration
- >();
- const previousCompositionRegistrations =
- compositionRegistrationsByRoot.get(root);
- order = collectCommitOrderFromFiber(
- root,
- registrations,
- previousRegistrations ?? null,
- {
- registrations: compositionRegistrations,
- previous: previousCompositionRegistrations ?? null,
- },
- );
- registrationsByRoot.set(root, registrations);
- compositionRegistrationsByRoot.set(root, compositionRegistrations);
- for (const [managerId, registration] of registrations) {
- if (registration !== previousRegistrations?.get(managerId)) {
- registration.onCommit(
- registration.sequences,
- registration.sequenceIds,
- );
- }
- }
-
- if (previousRegistrations) {
- for (const [managerId, registration] of previousRegistrations) {
- if (!registrations.has(managerId)) {
- registration.onCommit([], []);
- }
- }
- }
-
- for (const [managerId, registration] of compositionRegistrations) {
- if (registration !== previousCompositionRegistrations?.get(managerId)) {
- registration.onCommit(registration.snapshot);
- }
- }
-
- if (previousCompositionRegistrations) {
- for (const [
- managerId,
- registration,
- ] of previousCompositionRegistrations) {
- if (!compositionRegistrations.has(managerId)) {
- registration.onCommit({
- compositions: [],
- folders: [],
- orderIds: [],
- });
- }
- }
- }
- } catch {
- // A registration collection or delivery failure permanently selects effect
- // fallback for this hook. Retrying registration would risk repeated teardown.
- hook[Internals.CommittedMetadataInternals.failureMarker] = true;
- order = null;
- try {
- target.dispatchEvent(
- new CustomEvent(
- Internals.CommittedMetadataInternals.registrationErrorEventName,
- ),
- );
- } catch {
- // Notification failure must not prevent the previous hook from running.
- }
- }
-
- if (
- order !== null &&
- (order.outlineCount > 0 || order.sequenceManagers.length > 0)
- ) {
- try {
- target.dispatchEvent(
- new CustomEvent(Internals.CommittedMetadataInternals.eventName, {
- detail: {
- sequenceManagers: order.sequenceManagers,
- },
- }),
- );
- } catch {
- // Order notifications are independent of registration and retry next commit.
- }
- }
-
- return previousOnCommitFiberRoot?.apply(this, args);
- };
-
- hook[installationMarker] = true;
- return true;
-};
diff --git a/packages/sdk/src/react-commit-adapter.ts b/packages/sdk/src/react-commit-adapter.ts
new file mode 100644
index 0000000000..3a7167725e
--- /dev/null
+++ b/packages/sdk/src/react-commit-adapter.ts
@@ -0,0 +1,175 @@
+import {Internals} from 'remotion';
+import {
+ createCommitOutlineCollector,
+ type OutlineCollectors,
+} from './commit-outline-collector';
+import {
+ createCommitRegistryCollector,
+ type CommittedSequenceRegistration,
+ type CommittedCompositionRegistration,
+} from './commit-registry-collector';
+import {
+ getCommittedMetadata,
+ type Fiber,
+ type FiberRoot,
+ type HookTarget,
+} from './react-commit-types';
+const {installationMarker} = Internals.CommittedMetadataInternals;
+// Share one committed-tree traversal between registration and DOM discovery.
+export const collectReactCommit = (
+ root: FiberRoot,
+ ...args: Parameters<typeof createCommitRegistryCollector>
+) => {
+ const registry = createCommitRegistryCollector(...args);
+ const outlines = createCommitOutlineCollector();
+ const visit = (
+ fiber: Fiber,
+ currentSequenceManagerId: string | null,
+ currentCompositionManagerId: string | null,
+ outlineCollectors: OutlineCollectors,
+ ) => {
+ const metadata = getCommittedMetadata(fiber.memoizedProps);
+ const sequenceManagerId =
+ metadata?.type === 'sequence-manager'
+ ? metadata.id
+ : currentSequenceManagerId;
+ const compositionManagerId =
+ metadata?.type === 'composition-manager'
+ ? metadata.id
+ : currentCompositionManagerId;
+ registry.visit(metadata, sequenceManagerId, compositionManagerId);
+ const childOutlines =
+ outlineCollectors === null && metadata === null
+ ? null
+ : outlines.visit(fiber, metadata, outlineCollectors);
+ let {child} = fiber;
+ while (child !== null) {
+ visit(child, sequenceManagerId, compositionManagerId, childOutlines);
+ child = child.sibling;
+ }
+ };
+
+ visit(root.current, null, null, []);
+
+ return {...registry.getSnapshot(), outlineCount: outlines.publish()};
+};
+
+export const installReactCommitObserver = (target: HookTarget): boolean => {
+ const hook = target.__REACT_DEVTOOLS_GLOBAL_HOOK__;
+ if (!hook?.supportsFiber) {
+ return false;
+ }
+
+ if (hook[installationMarker] === true) {
+ return true;
+ }
+
+ const previousOnCommitFiberRoot = hook.onCommitFiberRoot;
+ const registrationsByRoot = new WeakMap<
+ FiberRoot,
+ Map<string, CommittedSequenceRegistration>
+ >();
+ const compositionRegistrationsByRoot = new WeakMap<
+ FiberRoot,
+ Map<string, CommittedCompositionRegistration>
+ >();
+
+ hook.onCommitFiberRoot = function (...args) {
+ let order: ReturnType<typeof collectReactCommit> | null = null;
+ try {
+ const [, root] = args;
+ const registrations = new Map<string, CommittedSequenceRegistration>();
+ const previousRegistrations = registrationsByRoot.get(root);
+ const compositionRegistrations = new Map<
+ string,
+ CommittedCompositionRegistration
+ >();
+ const previousCompositionRegistrations =
+ compositionRegistrationsByRoot.get(root);
+ order = collectReactCommit(
+ root,
+ registrations,
+ previousRegistrations ?? null,
+ {
+ registrations: compositionRegistrations,
+ previous: previousCompositionRegistrations ?? null,
+ },
+ );
+ registrationsByRoot.set(root, registrations);
+ compositionRegistrationsByRoot.set(root, compositionRegistrations);
+ for (const [managerId, registration] of registrations) {
+ if (registration !== previousRegistrations?.get(managerId)) {
+ registration.onCommit(
+ registration.sequences,
+ registration.sequenceIds,
+ );
+ }
+ }
+
+ if (previousRegistrations) {
+ for (const [managerId, registration] of previousRegistrations) {
+ if (!registrations.has(managerId)) {
+ registration.onCommit([], []);
+ }
+ }
+ }
+
+ for (const [managerId, registration] of compositionRegistrations) {
+ if (registration !== previousCompositionRegistrations?.get(managerId)) {
+ registration.onCommit(registration.snapshot);
+ }
+ }
+
+ if (previousCompositionRegistrations) {
+ for (const [
+ managerId,
+ registration,
+ ] of previousCompositionRegistrations) {
+ if (!compositionRegistrations.has(managerId)) {
+ registration.onCommit({
+ compositions: [],
+ folders: [],
+ orderIds: [],
+ });
+ }
+ }
+ }
+ } catch {
+ // A registration collection or delivery failure permanently selects effect
+ // fallback for this hook. Retrying registration would risk repeated teardown.
+ hook[Internals.CommittedMetadataInternals.failureMarker] = true;
+ order = null;
+ try {
+ target.dispatchEvent(
+ new CustomEvent(
+ Internals.CommittedMetadataInternals.registrationErrorEventName,
+ ),
+ );
+ } catch {
+ // Notification failure must not prevent the previous hook from running.
+ }
+ }
+
+ if (
+ order !== null &&
+ (order.outlineCount > 0 || order.sequenceManagers.length > 0)
+ ) {
+ try {
+ target.dispatchEvent(
+ new CustomEvent(Internals.CommittedMetadataInternals.eventName, {
+ detail: {
+ sequenceManagers: order.sequenceManagers,
+ },
+ }),
+ );
+ } catch {
+ // Order notifications are independent of registration and retry next commit.
+ }
+ }
+
+ return previousOnCommitFiberRoot?.apply(this, args);
+ };
+
+ hook[installationMarker] = true;
+ return true;
+};
diff --git a/packages/sdk/src/react-commit-types.ts b/packages/sdk/src/react-commit-types.ts
new file mode 100644
index 0000000000..ef503ee2e4
--- /dev/null
+++ b/packages/sdk/src/react-commit-types.ts
@@ -0,0 +1,52 @@
+import type {ComponentProps} from 'react';
+import {Internals} from 'remotion';
+export type Fiber = {
+ readonly child: Fiber | null;
+ readonly memoizedProps: unknown;
+ readonly sibling: Fiber | null;
+ readonly tag: number | null;
+ readonly stateNode: unknown;
+ readonly memoizedState: unknown;
+};
+
+export type FiberRoot = {
+ readonly current: Fiber;
+};
+
+type DevToolsHook = {
+ readonly supportsFiber?: boolean;
+ onCommitFiberRoot?: (
+ this: DevToolsHook,
+ rendererId: number,
+ root: FiberRoot,
+ priorityLevel: unknown,
+ didError: boolean,
+ ) => unknown;
+ [key: symbol]: unknown;
+};
+
+export type HookTarget = Window &
+ typeof globalThis & {
+ __REACT_DEVTOOLS_GLOBAL_HOOK__?: DevToolsHook;
+ };
+
+const {metadataProp} = Internals.CommittedMetadataInternals;
+
+export type CommittedMetadata = NonNullable<
+ ComponentProps<
+ typeof Internals.CommittedMetadataProvider
+ >[typeof metadataProp]
+>;
+
+export const getCommittedMetadata = (
+ props: unknown,
+): CommittedMetadata | null => {
+ if (typeof props !== 'object' || props === null) {
+ return null;
+ }
+
+ const metadata: unknown = Reflect.get(props, metadataProp);
+ return typeof metadata === 'object' && metadata !== null
+ ? (metadata as CommittedMetadata)
+ : null;
+};
diff --git a/packages/studio/src/initialize-studio-preview.ts b/packages/studio/src/initialize-studio-preview.ts
index 990f4e631a..4cf02bd25e 100644
--- a/packages/studio/src/initialize-studio-preview.ts
+++ b/packages/studio/src/initialize-studio-preview.ts
@@ -20,7 +20,7 @@ export const initializeStudioPreview = () => {
return;
}
- CanvasInternals.installFiberCommitOrderObserver(window);
+ CanvasInternals.installReactCommitObserver(window);
Internals.CSSUtils.injectCSS(studioCssVariables);
Internals.CSSUtils.injectCSS(
Internals.CSSUtils.makeDefaultPreviewCSS(null, BACKGROUND_HEX),
diff --git a/packages/studio/src/test/fiber-sequence-order-observer.test.ts b/packages/studio/src/test/fiber-sequence-order-observer.test.ts
index 40161af6be..3c2b51d65b 100644
--- a/packages/studio/src/test/fiber-sequence-order-observer.test.ts
+++ b/packages/studio/src/test/fiber-sequence-order-observer.test.ts
@@ -2,8 +2,7 @@ import {afterEach, expect, test} from 'bun:test';
import {CanvasInternals} from '@remotion/sdk';
import {Internals} from 'remotion';
-const {collectCommitOrderFromFiber, installFiberCommitOrderObserver} =
- CanvasInternals;
+const {collectReactCommit, installReactCommitObserver} = CanvasInternals;
type TestFiber = {
child: TestFiber | null;
@@ -130,10 +129,10 @@ test('collects sequence, composition, and folder order per manager', () => {
};
const compositionRegistrations: NonNullable<
- Parameters<typeof collectCommitOrderFromFiber>[3]
+ Parameters<typeof collectReactCommit>[3]
>['registrations'] = new Map();
expect(
- collectCommitOrderFromFiber(root, null, null, {
+ collectReactCommit(root, null, null, {
registrations: compositionRegistrations,
previous: null,
}),
@@ -206,8 +205,8 @@ test('chains the existing commit hook and emits the committed order once', () =>
);
try {
- expect(installFiberCommitOrderObserver(window)).toBe(true);
- expect(installFiberCommitOrderObserver(window)).toBe(true);
+ expect(installReactCommitObserver(window)).toBe(true);
+ expect(installReactCommitObserver(window)).toBe(true);
hook.onCommitFiberRoot(1, {current: makeFiber()}, null, false);
hook.onCommitFiberRoot(1, root, null, false);
} finally {