π₯ Make videos programmatically with React
Publish composition and timeline registries from committed snapshots
Jonny Burgerdab5da299ac7
diff --git a/packages/core/src/Composition.tsx b/packages/core/src/Composition.tsxindex 37c3d6b7ce..1c3d3002d7 100644--- a/packages/core/src/Composition.tsx+++ b/packages/core/src/Composition.tsx@@ -1,5 +1,11 @@import type {ComponentType} from 'react';-import React, {Suspense, useCallback, useContext, useEffect} from 'react';+import React, {+ Suspense,+ useCallback,+ useContext,+ useEffect,+ useMemo,+} from 'react';import {createPortal} from 'react-dom';import type {z} from 'zod';import type {AnyZodObject} from './any-zod-type.js';@@ -10,8 +16,11 @@ import {import type {Codec} from './codec.js';import {CompositionRenderErrorContext} from './composition-render-error-context.js';import {CompositionErrorBoundary} from './CompositionErrorBoundary.js';-import type {TComposition} from './CompositionManager.js';-import {CompositionSetters} from './CompositionManagerContext.js';+import type {AnyComposition, TComposition} from './CompositionManager.js';+import {+ CompositionCommitRegistrationContext,+ CompositionSetters,+} from './CompositionManagerContext.js';import {resolveComponentIdentity} from './enable-sequence-stack-traces.js';import {FolderContext} from './Folder.js';import {serializeThenDeserializeInStudio} from './input-props-serialization.js';@@ -146,6 +155,8 @@ const InnerComposition = <const compManager = useContext(CompositionSetters);const {registerComposition, unregisterComposition} = compManager;+ const commitRegistrationEnabled =+ useContext(CompositionCommitRegistrationContext) === compManager;const video = useVideo();@@ -188,7 +199,7 @@ const InnerComposition = <? resolveComponentIdentity(compProps.component): null;- useEffect(() => {+ const getCompositionForRegistration = useCallback(() => {// Ensure it's a URL safe idif (!id) {throw new Error('No id for composition passed.');@@ -196,7 +207,7 @@ const InnerComposition = <validateCompositionId(id);validateDefaultAndInputProps(defaultProps, 'defaultProps', id);- registerComposition<Schema, Props>({+ return {durationInFrames: durationInFrames ?? undefined,fps: fps ?? undefined,height: height ?? undefined,@@ -213,11 +224,7 @@ const InnerComposition = <schema: schema ?? null,calculateMetadata: compProps.calculateMetadata ?? null,stack,- } as TComposition<Schema, Props>);-- return () => {- unregisterComposition(id);- };+ } as TComposition<Schema, Props>;}, [durationInFrames,fps,@@ -232,6 +239,25 @@ const InnerComposition = <schema,compProps.calculateMetadata,stack,+ ]);+ const registration = useMemo(+ () =>+ commitRegistrationEnabled+ ? (getCompositionForRegistration() as unknown as AnyComposition)+ : null,+ [commitRegistrationEnabled, getCompositionForRegistration],+ );+ useEffect(() => {+ if (commitRegistrationEnabled) {+ return;+ }++ registerComposition<Schema, Props>(getCompositionForRegistration());+ return () => unregisterComposition(id);+ }, [+ commitRegistrationEnabled,+ getCompositionForRegistration,+ id,registerComposition,unregisterComposition,]);@@ -250,6 +276,14 @@ const InnerComposition = <const onClear = useCallback(() => {clearError();}, [clearError]);+ const wrapRegistration = (content: React.ReactNode) =>+ environment.isStudio ? (+ <CompositionOrderMarker compositionId={id} registration={registration}>+ {content}+ </CompositionOrderMarker>+ ) : (+ content+ );if (environment.isStudio &&@@ -263,23 +297,25 @@ const InnerComposition = <(resolved.type !== 'success' &&resolved.type !== 'success-and-refreshing')) {- return null;+ return wrapRegistration(null);}- return createPortal(- <CanUseRemotionHooksProvider>- <CompositionErrorBoundary onError={onError} onClear={onClear}>- <Suspense fallback={<Loading />}>- <Comp- {- // eslint-disable-next-line @typescript-eslint/no-explicit-any- ...((resolved.result.props ?? {}) as any)- }- />- </Suspense>- </CompositionErrorBoundary>- </CanUseRemotionHooksProvider>,- portalNode(),+ return wrapRegistration(+ createPortal(+ <CanUseRemotionHooksProvider>+ <CompositionErrorBoundary onError={onError} onClear={onClear}>+ <Suspense fallback={<Loading />}>+ <Comp+ {+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ ...((resolved.result.props ?? {}) as any)+ }+ />+ </Suspense>+ </CompositionErrorBoundary>+ </CanUseRemotionHooksProvider>,+ portalNode(),+ ),);}@@ -295,25 +331,27 @@ const InnerComposition = <(resolved.type !== 'success' &&resolved.type !== 'success-and-refreshing')) {- return null;+ return wrapRegistration(null);}- return createPortal(- <CanUseRemotionHooksProvider>- <Suspense fallback={<Fallback />}>- <Comp- {- // eslint-disable-next-line @typescript-eslint/no-explicit-any- ...((resolved.result.props ?? {}) as any)- }- />- </Suspense>- </CanUseRemotionHooksProvider>,- portalNode(),+ return wrapRegistration(+ createPortal(+ <CanUseRemotionHooksProvider>+ <Suspense fallback={<Fallback />}>+ <Comp+ {+ // eslint-disable-next-line @typescript-eslint/no-explicit-any+ ...((resolved.result.props ?? {}) as any)+ }+ />+ </Suspense>+ </CanUseRemotionHooksProvider>,+ portalNode(),+ ),);}- return null;+ return wrapRegistration(null);};/*@@ -327,19 +365,11 @@ export const Composition = <props: CompositionProps<Schema, Props>,) => {const {onlyRenderComposition} = useContext(CompositionSetters);- const environment = useRemotionEnvironment();if (onlyRenderComposition && onlyRenderComposition !== props.id) {return null;}// @ts-expect-error- const composition = <InnerComposition {...props} />;- return environment.isStudio ? (- <CompositionOrderMarker compositionId={props.id}>- {composition}- </CompositionOrderMarker>- ) : (- composition- );+ return <InnerComposition {...props} />;};diff --git a/packages/core/src/CompositionManagerContext.tsx b/packages/core/src/CompositionManagerContext.tsxindex ebce566abb..2e79aed46f 100644--- a/packages/core/src/CompositionManagerContext.tsx+++ b/packages/core/src/CompositionManagerContext.tsx@@ -87,6 +87,11 @@ export const CompositionManager = createContext<CompositionManagerContext>({canvasContent: null,});+// Bind commit registration to these setters so custom providers keep using+// their own registration lifecycle, even inside a managed Studio tree.+export const CompositionCommitRegistrationContext =+ createContext<CompositionManagerSetters | null>(null);+export const CompositionSetters = createContext<CompositionManagerSetters>({registerComposition: () => undefined,unregisterComposition: () => undefined,diff --git a/packages/core/src/CompositionManagerProvider.tsx b/packages/core/src/CompositionManagerProvider.tsxindex 33ebc69951..4755233325 100644--- a/packages/core/src/CompositionManagerProvider.tsx+++ b/packages/core/src/CompositionManagerProvider.tsx@@ -18,18 +18,27 @@ import type {} from './CompositionManagerContext';import {CompositionManager,+ CompositionCommitRegistrationContext,CompositionSetters,} from './CompositionManagerContext';import type {BaseMetadata} from './CompositionManagerContext.js';import type {TFolder} from './Folder';import {+ createRegistryStore,+ reconcileRegistryEntries,+} from './registry-store.js';+import {+ COMMIT_REGISTRATION_ERROR_EVENT,CompositionManagerOrderMarker,getCompositionAndFolderOrderKey,getFolderOrderId,+ isCommitRegistrationObserverAvailable,COMMIT_ORDER_EVENT,type CommitOrderEventDetail,+ type CommittedCompositionSnapshot,} from './sequence-order-marker.js';import {useRemotionEnvironment} from './use-remotion-environment.js';+import {useSyncExternalStore} from './use-sync-external-store.js';const useIsomorphicLayoutEffect =typeof window === 'undefined' ? useEffect : useLayoutEffect;@@ -49,6 +58,24 @@ export const CompositionManagerProvider = ({}) => {const {isStudio} = useRemotionEnvironment();const [compositionManagerId] = useState(() => String(Math.random()));+ const [commitRegistrationEnabled, setCommitRegistrationEnabled] = useState(+ () => isStudio && isCommitRegistrationObserverAvailable(),+ );+ const pendingRegistrationsRef = useRef<CommittedCompositionSnapshot | null>(+ null,+ );+ const lastRegistrationsRef = useRef<CommittedCompositionSnapshot | null>(+ null,+ );+ const committedKeysRef = useRef<ReadonlySet<string>>(new Set());+ const committedDescriptorsRef = useRef<+ ReadonlyMap<string, AnyComposition | TFolder>+ >(new Map());+ const observerFailedRef = useRef(false);+ const unmountedRef = useRef(false);+ const [registrationError, setRegistrationError] = useState<Error | null>(+ null,+ );const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);const committedOrderIdsRef = useRef<readonly string[] | null>(null);const internalOrderRef = useRef(@@ -63,27 +90,49 @@ export const CompositionManagerProvider = ({),);const nextInternalOrderRef = useRef(initialCompositions.length);- const [folders, setFolders] = useState<TFolder[]>([]);+ const [registry] = useState(() =>+ createRegistryStore<{+ compositions: AnyComposition[];+ folders: TFolder[];+ }>({+ compositions: initialCompositions.map((composition, order) => ({+ ...composition,+ order,+ })),+ folders: [],+ }),+ );+ const {compositions, folders} = useSyncExternalStore(+ registry.subscribe,+ registry.getSnapshot,+ registry.getSnapshot,+ );const [canvasContent, setCanvasContent] = useState<CanvasContent | null>(initialCanvasContent,);const [currentAssetMetadata, setCurrentAssetMetadata] =useState<AssetPreviewMetadata | null>(null);- const [compositions, setCompositions] = useState<AnyComposition[]>(() =>- initialCompositions.map((composition, order) => ({...composition, order})),- );-- // CompositionManagerProvider state- const currentcompositionsRef = useRef<AnyComposition[]>(compositions);- useIsomorphicLayoutEffect(() => {- currentcompositionsRef.current = compositions;- }, [compositions]);-const updateCompositions = useCallback((updateComps: (comp: AnyComposition[]) => AnyComposition[]) => {- setCompositions(updateComps);+ registry.setSnapshot((previous) => {+ const next = updateComps(previous.compositions);+ return next === previous.compositions+ ? previous+ : {...previous, compositions: next};+ });},- [],+ [registry],+ );+ const setFolders = useCallback(+ (update: (folders: TFolder[]) => TFolder[]) => {+ registry.setSnapshot((previous) => {+ const next = update(previous.folders);+ return next === previous.folders+ ? previous+ : {...previous, folders: next};+ });+ },+ [registry],);const registerComposition = useCallback(@@ -115,14 +164,17 @@ export const CompositionManagerProvider = ({[updateCompositions],);- const unregisterComposition = useCallback((id: string) => {- internalOrderRef.current.delete(- getCompositionAndFolderOrderKey({type: 'composition', id}),- );- setCompositions((comps) => {- return comps.filter((c) => c.id !== id);- });- }, []);+ const unregisterComposition = useCallback(+ (id: string) => {+ internalOrderRef.current.delete(+ getCompositionAndFolderOrderKey({type: 'composition', id}),+ );+ updateCompositions((comps) => {+ return comps.filter((c) => c.id !== id);+ });+ },+ [updateCompositions],+ );const registerFolder = useCallback((name: string, parent: string | null, stack: string | null) => {@@ -144,7 +196,7 @@ export const CompositionManagerProvider = ({];});},- [],+ [setFolders],);const unregisterFolder = useCallback(@@ -161,7 +213,105 @@ export const CompositionManagerProvider = ({);});},- [],+ [setFolders],+ );++ const onCommitRegistrations = useCallback(+ (snapshot: CommittedCompositionSnapshot) => {+ if (observerFailedRef.current || unmountedRef.current) {+ return;+ }++ const previous =+ pendingRegistrationsRef.current ?? lastRegistrationsRef.current;+ if (+ previous?.compositions === snapshot.compositions &&+ previous.folders === snapshot.folders &&+ previous.orderIds === snapshot.orderIds+ ) {+ return;+ }++ const alreadyPending = pendingRegistrationsRef.current !== null;+ pendingRegistrationsRef.current = snapshot;+ if (alreadyPending) {+ return;+ }++ queueMicrotask(() => {+ const pending = pendingRegistrationsRef.current;+ pendingRegistrationsRef.current = null;+ if (+ pending === null ||+ observerFailedRef.current ||+ unmountedRef.current+ ) {+ return;+ }++ const previousKeys = committedKeysRef.current;+ const previousDescriptors = committedDescriptorsRef.current;+ const existingIds = new Set(+ registry+ .getSnapshot()+ .compositions.map((composition) => composition.id),+ );+ const descriptors = new Map<string, AnyComposition | TFolder>();+ for (const composition of pending.compositions) {+ const key = `composition:${composition.id}`;+ if (+ descriptors.has(key) ||+ (!previousKeys.has(key) && existingIds.has(composition.id))+ ) {+ setRegistrationError(+ new Error(+ `Multiple composition with id ${composition.id} are registered.`,+ ),+ );+ return;+ }++ descriptors.set(key, composition);+ }++ for (const folder of pending.folders) {+ descriptors.set(`folder:${getFolderOrderId(folder)}`, folder);+ }++ const nextKeys = new Set(descriptors.keys());+ const order = new Map(pending.orderIds.map((id, index) => [id, index]));+ lastRegistrationsRef.current = pending;+ committedKeysRef.current = nextKeys;+ committedDescriptorsRef.current = descriptors;+ registry.setSnapshot((current) => {+ const nextCompositions = reconcileRegistryEntries({+ current: current.compositions,+ entries: pending.compositions,+ previousDescriptors,+ previousKeys,+ nextKeys,+ getKey: (composition) => `composition:${composition.id}`,+ order,+ orderProperty: 'order',+ });+ const nextFolders = reconcileRegistryEntries({+ current: current.folders,+ entries: pending.folders,+ previousDescriptors,+ previousKeys,+ nextKeys,+ getKey: (folder) => `folder:${getFolderOrderId(folder)}`,+ order,+ orderProperty: 'order',+ });+ return nextCompositions === current.compositions &&+ nextFolders === current.folders+ ? current+ : {compositions: nextCompositions, folders: nextFolders};+ });+ });+ },+ [registry],);useIsomorphicLayoutEffect(() => {@@ -170,6 +320,34 @@ export const CompositionManagerProvider = ({}let unmounted = false;+ unmountedRef.current = false;+ const onRegistrationError = () => {+ if (observerFailedRef.current) {+ return;+ }++ observerFailedRef.current = true;+ pendingRegistrationsRef.current = null;+ queueMicrotask(() => {+ if (unmounted) {+ return;+ }++ const previousKeys = committedKeysRef.current;+ committedKeysRef.current = new Set();+ committedDescriptorsRef.current = new Map();+ registry.setSnapshot((current) => ({+ compositions: current.compositions.filter(+ (composition) => !previousKeys.has(`composition:${composition.id}`),+ ),+ folders: current.folders.filter(+ (folder) => !previousKeys.has(`folder:${getFolderOrderId(folder)}`),+ ),+ }));+ setCommitRegistrationEnabled(false);+ });+ };+const onCommitOrder = (event: Event) => {const {detail} = event as CustomEvent<CommitOrderEventDetail>;const managerOrder = detail.compositionManagers.find(@@ -194,6 +372,10 @@ export const CompositionManagerProvider = ({const order = new Map(orderIds.map((id, index) => [id, index]));committedOrderIdsRef.current = orderIds;committedOrderRef.current = order;+ if (commitRegistrationEnabled) {+ return;+ }+queueMicrotask(() => {if (unmounted) {return;@@ -255,17 +437,35 @@ export const CompositionManagerProvider = ({};window.addEventListener(COMMIT_ORDER_EVENT, onCommitOrder);+ window.addEventListener(+ COMMIT_REGISTRATION_ERROR_EVENT,+ onRegistrationError,+ );+return () => {unmounted = true;+ unmountedRef.current = true;+ pendingRegistrationsRef.current = null;window.removeEventListener(COMMIT_ORDER_EVENT, onCommitOrder);+ window.removeEventListener(+ COMMIT_REGISTRATION_ERROR_EVENT,+ onRegistrationError,+ );};- }, [compositionManagerId, isStudio, updateCompositions]);+ }, [+ compositionManagerId,+ isStudio,+ updateCompositions,+ setFolders,+ registry,+ commitRegistrationEnabled,+ ]);useImperativeHandle(compositionsRef, () => {return {- getCompositions: () => currentcompositionsRef.current,+ getCompositions: () => registry.getSnapshot().compositions,};- }, []);+ }, [registry]);const compositionManagerSetters = useMemo((): CompositionManagerSetters => {return {@@ -305,13 +505,26 @@ export const CompositionManagerProvider = ({const providers = (<CompositionManager.Provider value={compositionManagerContextValue}><CompositionSetters.Provider value={compositionManagerSetters}>- {children}+ <CompositionCommitRegistrationContext.Provider+ value={commitRegistrationEnabled ? compositionManagerSetters : null}+ >+ {children}+ </CompositionCommitRegistrationContext.Provider></CompositionSetters.Provider></CompositionManager.Provider>);+ if (registrationError !== null) {+ throw registrationError;+ }+return isStudio ? (- <CompositionManagerOrderMarker managerId={compositionManagerId}>+ <CompositionManagerOrderMarker+ managerId={compositionManagerId}+ onCommitRegistrations={+ commitRegistrationEnabled ? onCommitRegistrations : null+ }+ >{providers}</CompositionManagerOrderMarker>) : (diff --git a/packages/core/src/Folder.tsx b/packages/core/src/Folder.tsxindex 577d45e7e7..2dc65e609f 100644--- a/packages/core/src/Folder.tsx+++ b/packages/core/src/Folder.tsx@@ -1,6 +1,9 @@import type {FC, ReactNode} from 'react';import {createContext, useContext, useEffect, useMemo} from 'react';-import {CompositionSetters} from './CompositionManagerContext.js';+import {+ CompositionCommitRegistrationContext,+ CompositionSetters,+} from './CompositionManagerContext.js';import {FolderOrderMarker, getFolderOrderId} from './sequence-order-marker.js';import {truthy} from './truthy.js';import {useRemotionEnvironment} from './use-remotion-environment.js';@@ -33,8 +36,11 @@ export const Folder: FC<{}> = (props) => {const {name, children} = props;const parent = useContext(FolderContext);- const {registerFolder, unregisterFolder} = useContext(CompositionSetters);+ const compManager = useContext(CompositionSetters);+ const {registerFolder, unregisterFolder} = compManager;const environment = useRemotionEnvironment();+ const commitRegistrationEnabled =+ useContext(CompositionCommitRegistrationContext) === compManager;const stack =(props as {readonly _remotionInternalStack?: string})._remotionInternalStack ?? null;@@ -52,14 +58,26 @@ export const Folder: FC<{parentName,};}, [name, parentName]);+ const registration = useMemo<TFolder | null>(+ () =>+ commitRegistrationEnabled+ ? {name, parent: parentName, order: null, stack}+ : null,+ [commitRegistrationEnabled, name, parentName, stack],+ );useEffect(() => {+ if (commitRegistrationEnabled) {+ return;+ }+registerFolder(name, parentName, stack);return () => {unregisterFolder(name, parentName);};}, [+ commitRegistrationEnabled,name,parent.folderName,parentName,@@ -72,7 +90,10 @@ export const Folder: FC<{<FolderContext.Provider value={value}>{children}</FolderContext.Provider>);return environment.isStudio ? (- <FolderOrderMarker folderId={getFolderOrderId({name, parent: parentName})}>+ <FolderOrderMarker+ folderId={getFolderOrderId({name, parent: parentName})}+ registration={registration}+ >{folder}</FolderOrderMarker>) : (diff --git a/packages/core/src/SequenceManager.tsx b/packages/core/src/SequenceManager.tsxindex 395c41cc12..16f568c23e 100644--- a/packages/core/src/SequenceManager.tsx+++ b/packages/core/src/SequenceManager.tsx@@ -1,5 +1,11 @@import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';import type {TSequence} from './CompositionManager.js';+import {+ areRegistryEntriesEqual,+ createRegistryStore,+ reconcileRegistryEntries,+ type RegistryStore,+} from './registry-store.js';import {COMMIT_ORDER_EVENT,COMMIT_REGISTRATION_ERROR_EVENT,@@ -25,24 +31,6 @@ import type {VideoConfigValues} from './video-config.js';const useIsomorphicLayoutEffect =typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;-const areSequenceRegistrationsEqual = (- previous: TSequence,- next: TSequence,-) => {- const keys = Object.keys(previous);- return (- keys.length === Object.keys(next).length &&- keys.every(- (key) =>- Object.prototype.hasOwnProperty.call(next, key) &&- Object.is(- previous[key as keyof TSequence],- next[key as keyof TSequence],- ),- )- );-};-export type SequenceManagerContext = {registerSequence: (seq: TSequence) => void;updateSequence: ((seq: TSequence) => void) | null;@@ -80,6 +68,11 @@ export const SequenceManagerActionsContext =});export const SequenceManager = React.createContext(defaultSequenceManager);+export const SequenceRegistryContext = React.createContext<RegistryStore<+ TSequence[]+> | null>(null);+const EmptySequenceManagerContext = React.createContext(defaultSequenceManager);+const subscribeToNoRegistry = () => () => undefined;export const SequenceCommitRegistrationContext = React.createContext(false);const NativeSequenceManagerProvider = SequenceManager.Provider;const SequenceManagerProviderWithActions: React.FC<@@ -96,9 +89,11 @@ const SequenceManagerProviderWithActions: React.FC<return (<SequenceManagerActionsContext.Provider value={actions}><NativeSequenceManagerProvider value={value}>- <SequenceCommitRegistrationContext.Provider value={false}>- {children}- </SequenceCommitRegistrationContext.Provider>+ <SequenceRegistryContext.Provider value={null}>+ <SequenceCommitRegistrationContext.Provider value={false}>+ {children}+ </SequenceCommitRegistrationContext.Provider>+ </SequenceRegistryContext.Provider></NativeSequenceManagerProvider></SequenceManagerActionsContext.Provider>);@@ -111,7 +106,41 @@ Object.defineProperty(SequenceManager, 'Provider', {});export const useSequenceManagerSequences = (): TSequence[] => {- return useContext(SequenceManager).sequences;+ const registry = useContext(SequenceRegistryContext);+ const legacy = useContext(+ registry === null ? SequenceManager : EmptySequenceManagerContext,+ );+ const getSnapshot = useCallback(+ () => registry?.getSnapshot() ?? legacy.sequences,+ [legacy.sequences, registry],+ );+ return useSyncExternalStore(+ registry?.subscribe ?? subscribeToNoRegistry,+ getSnapshot,+ getSnapshot,+ );+};++// Keep the internal legacy context reactive without rendering the manager+// or requiring imperative registry subscribers to wait for this React update.+const SequenceRegistryProvider: React.FC<{+ readonly registry: RegistryStore<TSequence[]>;+ readonly actions: SequenceManagerActions;+ readonly children: React.ReactNode;+}> = ({registry, actions, children}) => {+ const sequences = useSyncExternalStore(+ registry.subscribe,+ registry.getSnapshot,+ registry.getSnapshot,+ );+ const value = useMemo(() => ({...actions, sequences}), [actions, sequences]);+ return (+ <SequenceManager.Provider value={value}>+ <SequenceRegistryContext.Provider value={registry}>+ {children}+ </SequenceRegistryContext.Provider>+ </SequenceManager.Provider>+ );};export const SequenceManagerRefContext =@@ -467,11 +496,16 @@ export const SequenceManagerProvider: React.FC<{const registrationUnmountedRef = useRef(false);const committedOrderRef = useRef<ReadonlyMap<string, number> | null>(null);const committedOrderIdsRef = useRef<readonly string[] | null>(null);- const [sequences, setSequences] = useState<TSequence[]>([]);- const sequencesRef = useRef(sequences);- useIsomorphicLayoutEffect(() => {- sequencesRef.current = sequences;- }, [sequences]);+ 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>(),@@ -854,45 +888,21 @@ export const SequenceManagerProvider: React.FC<{);lastCommittedSequencesRef.current = pending;committedRegistrationIdsRef.current = nextIds;- setSequences((current) => {- const previousById = new Map(- current.map((sequence) => [sequence.id, sequence]),- );- const next = pending.sequences.map((sequence) => {- const previous = previousById.get(sequence.id);- const timelineOrder = order.get(sequence.id) ?? null;- if (- previous &&- previousDescriptors.get(sequence.id) === sequence &&- previous.timelineOrder === timelineOrder- ) {- return previous;- }-- const registeredSequence = {- ...sequence,- timelineOrder,- };- return previous &&- areSequenceRegistrationsEqual(previous, registeredSequence)- ? previous- : registeredSequence;- });- // Custom imperative registrations have their own lifecycle.- next.push(- ...current.filter(- (sequence) =>- !previousIds.has(sequence.id) && !nextIds.has(sequence.id),- ),- );- return next.length === current.length &&- next.every((sequence, index) => sequence === current[index])- ? current- : next;- });+ setSequences((current) =>+ reconcileRegistryEntries({+ current,+ entries: pending.sequences,+ previousDescriptors,+ previousKeys: previousIds,+ nextKeys: nextIds,+ getKey: (sequence) => sequence.id,+ order,+ orderProperty: 'timelineOrder',+ }),+ );});},- [],+ [setSequences],);useIsomorphicLayoutEffect(() => {@@ -990,52 +1000,60 @@ export const SequenceManagerProvider: React.FC<{onRegistrationError,);};- }, [shouldObserveCommits, sequenceManagerId]);+ }, [shouldObserveCommits, sequenceManagerId, setSequences]);++ 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 registerSequence = useCallback((seq: TSequence) => {- setSequences((seqs) => {- return [- ...seqs,- {+ const updatedSequence = {...seq,timelineOrder: committedOrderRef.current?.get(seq.id) ?? null,- },- ];- });- }, []);- 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 (areSequenceRegistrationsEqual(seqs[index], updatedSequence)) {- return seqs;- }+ };+ if (areRegistryEntriesEqual(seqs[index], updatedSequence)) {+ return seqs;+ }- const next = [...seqs];- next[index] = updatedSequence;- return next;- });- }, []);+ const next = [...seqs];+ next[index] = updatedSequence;+ return next;+ });+ },+ [setSequences],+ );- const unregisterSequence = useCallback((seq: string) => {- setSequences((seqs) => seqs.filter((s) => s.id !== seq));- }, []);+ const unregisterSequence = useCallback(+ (seq: string) => {+ setSequences((seqs) => seqs.filter((s) => s.id !== seq));+ },+ [setSequences],+ );- const sequenceContext: SequenceManagerContext = useMemo(() => {+ const actions = useMemo<SequenceManagerActions>(() => {return {registerSequence,- sequences,updateSequence,unregisterSequence,};- }, [registerSequence, sequences, unregisterSequence, updateSequence]);+ }, [registerSequence, unregisterSequence, updateSequence]);const dragOverridesSubscription = useMemo<Omit<DragOverridesSubscription, 'manager'>>(@@ -1108,7 +1126,7 @@ export const SequenceManagerProvider: React.FC<{const providers = (<SequenceManagerRefContext.Provider value={sequencesRef}>- <SequenceManager.Provider value={sequenceContext}>+ <SequenceRegistryProvider registry={registry} actions={actions}><SequenceCommitRegistrationContext.Providervalue={commitRegistrationEnabled}>@@ -1133,7 +1151,7 @@ export const SequenceManagerProvider: React.FC<{</VisualModePropStatusesContext.Provider></VisualModePropStatusesRefContext.Provider></SequenceCommitRegistrationContext.Provider>- </SequenceManager.Provider>+ </SequenceRegistryProvider></SequenceManagerRefContext.Provider>);diff --git a/packages/core/src/internals.ts b/packages/core/src/internals.tsindex 54399be367..0fedeba92e 100644--- a/packages/core/src/internals.ts+++ b/packages/core/src/internals.ts@@ -196,6 +196,7 @@ import {SequenceManager,SequenceManagerProvider,SequenceManagerRefContext,+ SequenceRegistryContext,useActiveFromDragOverrideKeys,useSequenceManagerSequences,SequenceRegistrationContext,@@ -365,6 +366,7 @@ export const Internals = {SequenceManager,SequenceManagerProvider,SequenceManagerRefContext,+ SequenceRegistryContext,useActiveFromDragOverrideKeys,useSequenceManagerSequences,SequenceRegistrationContext,diff --git a/packages/core/src/registry-store.ts b/packages/core/src/registry-store.tsnew file mode 100644index 0000000000..b5b72eef72--- /dev/null+++ b/packages/core/src/registry-store.ts@@ -0,0 +1,103 @@+export type RegistryStore<TSnapshot> = {+ readonly getSnapshot: () => TSnapshot;+ readonly subscribe: (listener: () => void) => () => void;+ readonly setSnapshot: (update: (previous: TSnapshot) => TSnapshot) => void;+};++export const areRegistryEntriesEqual = <T extends object>(+ previous: T,+ next: T,+) => {+ const keys = Object.keys(previous);+ return (+ keys.length === Object.keys(next).length &&+ keys.every(+ (key) =>+ Object.prototype.hasOwnProperty.call(next, key) &&+ Object.is(Reflect.get(previous, key), Reflect.get(next, key)),+ )+ );+};++export const reconcileRegistryEntries = <T extends object>({+ current,+ entries,+ previousDescriptors,+ previousKeys,+ nextKeys,+ getKey,+ order,+ orderProperty,+}: {+ readonly current: T[];+ readonly entries: readonly T[];+ readonly previousDescriptors: ReadonlyMap<string, unknown>;+ readonly previousKeys: ReadonlySet<string>;+ readonly nextKeys: ReadonlySet<string>;+ readonly getKey: (entry: T) => string;+ readonly order: ReadonlyMap<string, number>;+ readonly orderProperty: keyof T;+}): T[] => {+ const previousByKey = new Map(current.map((entry) => [getKey(entry), entry]));+ const next = entries.map((entry) => {+ const key = getKey(entry);+ const previous = previousByKey.get(key);+ const nextOrder = order.get(key) ?? null;+ if (+ previous &&+ previousDescriptors.get(key) === entry &&+ previous[orderProperty] === nextOrder+ ) {+ return previous;+ }++ const registered = {...entry, [orderProperty]: nextOrder};+ return previous && areRegistryEntriesEqual(previous, registered)+ ? previous+ : registered;+ });+ // Preserve imperative registrations, including their committed order.+ for (const entry of current) {+ const key = getKey(entry);+ if (!previousKeys.has(key) && !nextKeys.has(key)) {+ const nextOrder = order.get(key) ?? entry[orderProperty];+ next.push(+ entry[orderProperty] === nextOrder+ ? entry+ : {...entry, [orderProperty]: nextOrder},+ );+ }+ }++ return next.length === current.length &&+ next.every((entry, index) => entry === current[index])+ ? current+ : next;+};++export const createRegistryStore = <TSnapshot>(+ initialSnapshot: TSnapshot,+): RegistryStore<TSnapshot> => {+ let snapshot = initialSnapshot;+ const listeners = new Set<() => void>();+ return {+ getSnapshot: () => snapshot,+ subscribe: (listener) => {+ listeners.add(listener);+ return () => {+ listeners.delete(listener);+ };+ },+ setSnapshot: (update) => {+ const next = update(snapshot);+ if (next === snapshot) {+ return;+ }++ snapshot = next;+ for (const listener of [...listeners]) {+ listener();+ }+ },+ };+};diff --git a/packages/core/src/sequence-order-marker.tsx b/packages/core/src/sequence-order-marker.tsxindex 629a08a7cf..b603c799f9 100644--- a/packages/core/src/sequence-order-marker.tsx+++ b/packages/core/src/sequence-order-marker.tsx@@ -1,5 +1,6 @@import type React from 'react';-import type {TSequence} from './CompositionManager.js';+import type {AnyComposition, TSequence} from './CompositionManager.js';+import type {TFolder} from './Folder.js';export const SEQUENCE_ORDER_MARKER = Symbol.for('remotion.sequence-order-marker',@@ -70,6 +71,12 @@ export type CommittedSequenceSnapshot = {readonly sequenceIds: readonly string[];};+export type CommittedCompositionSnapshot = {+ readonly compositions: readonly AnyComposition[];+ readonly folders: readonly TFolder[];+ readonly orderIds: readonly string[];+};+export const SequenceOrderMarker: React.FC<{readonly children: React.ReactNode;readonly sequenceId: string;@@ -103,6 +110,7 @@ Object.defineProperty(export const CompositionOrderMarker: React.FC<{readonly children: React.ReactNode;readonly compositionId: string;+ readonly registration: AnyComposition | null;}> = ({children}) => children;Object.defineProperty(CompositionOrderMarker, COMPOSITION_ORDER_MARKER, {@@ -112,6 +120,7 @@ Object.defineProperty(CompositionOrderMarker, COMPOSITION_ORDER_MARKER, {export const FolderOrderMarker: React.FC<{readonly children: React.ReactNode;readonly folderId: string;+ readonly registration: TFolder | null;}> = ({children}) => children;Object.defineProperty(FolderOrderMarker, FOLDER_ORDER_MARKER, {@@ -121,6 +130,9 @@ Object.defineProperty(FolderOrderMarker, FOLDER_ORDER_MARKER, {export const CompositionManagerOrderMarker: React.FC<{readonly children: React.ReactNode;readonly managerId: string;+ readonly onCommitRegistrations:+ | ((snapshot: CommittedCompositionSnapshot) => void)+ | null;}> = ({children}) => children;Object.defineProperty(diff --git a/packages/core/src/use-lazy-component.ts b/packages/core/src/use-lazy-component.tsindex 1c732430a6..0eeaf68d91 100644--- a/packages/core/src/use-lazy-component.ts+++ b/packages/core/src/use-lazy-component.ts@@ -3,8 +3,13 @@ import type {ComponentType,ExoticComponent,} from 'react';-import React, {useMemo, useRef} from 'react';+import React, {useEffect, useLayoutEffect, useMemo} from 'react';import type {CompProps} from './Composition.js';+import {createRegistryStore} from './registry-store.js';+import {useSyncExternalStore} from './use-sync-external-store.js';++const useIsomorphicLayoutEffect =+ typeof window === 'undefined' ? useEffect : useLayoutEffect;type LazyExoticComponent<T extends ComponentType<any>> = ExoticComponent<ComponentPropsWithRef<T>@@ -22,7 +27,7 @@ export const useLazyComponent = <Props>({componentName: string;noSuspense: boolean;}): LazyExoticComponent<ComponentType<Props>> | ComponentType<Props> => {- // Why a ref + stable wrapper instead of returning compProps.component directly?+ // Why a store + stable wrapper instead of returning compProps.component directly?//// When a user edits their component and saves, React Fast Refresh re-executes// the module, giving compProps.component a new function reference.@@ -31,20 +36,46 @@ export const useLazyComponent = <Props>({// rendered `<Comp />` where Comp had a different identity, so React unmounted// the old tree and mounted a fresh one β losing all component state.//- // To fix this, we store the latest component in a ref (updated every render)- // and return a stable Wrapper from useMemo (created once). React sees the same- // Wrapper component across Fast Refresh updates, preserves the tree and state,- // while the ref ensures the Wrapper always delegates to the latest code.+ // A stable Wrapper preserves the tree across Fast Refresh updates. Publish its+ // implementation on commit so an abandoned render cannot change the component+ // exposed by an already registered composition. The subscription updates mounted+ // wrappers even when the registration's component identity stays the same.//// To reproduce: use packages/example/src/NewVideo.tsx, edit Component// (e.g. change volume={1} to volume={2}) and save. Without this fix,// Component would fully remount instead of fast-refreshing in place.- const componentRef = useRef<ComponentType<Props> | null>(null);-- if ('component' in compProps) {- componentRef.current = compProps.component as ComponentType<Props>;+ const componentFromProps =+ 'component' in compProps+ ? (compProps.component as ComponentType<Props> | undefined)+ : null;+ if (+ componentFromProps === undefined &&+ typeof document !== 'undefined' &&+ !noSuspense+ ) {+ throw new Error(+ `A value of \`undefined\` was passed to the \`component\` prop. Check the value you are passing to the <${componentName}/> component.`,+ );}+ const lazyComponentFromProps =+ 'lazyComponent' in compProps ? compProps.lazyComponent : null;+ const componentStore = useMemo(+ () =>+ createRegistryStore<ComponentType<Props> | null>(+ componentFromProps ?? null,+ ),+ // A new lazy loader replaces the wrapper too. Component edits only update+ // the existing store on commit, preserving the wrapper identity.+ // eslint-disable-next-line react-hooks/exhaustive-deps+ [lazyComponentFromProps],+ );+ useIsomorphicLayoutEffect(() => {+ if (componentFromProps !== null && componentFromProps !== undefined) {+ componentStore.setSnapshot(() => componentFromProps);+ }+ }, [componentFromProps, componentStore]);+const lazy = useMemo(() => {if ('component' in compProps) {// In SSR, suspense is not yet supported, we cannot use React.lazy@@ -54,14 +85,12 @@ export const useLazyComponent = <Props>({>;}- if (typeof compProps.component === 'undefined') {- throw new Error(- `A value of \`undefined\` was passed to the \`component\` prop. Check the value you are passing to the <${componentName}/> component.`,- );- }-const Wrapper = (props: Props) => {- const Comp = componentRef.current!;+ const Comp = useSyncExternalStore(+ componentStore.subscribe,+ componentStore.getSnapshot,+ componentStore.getSnapshot,+ )!;return React.createElement(Comp as React.ComponentType<{}>,props as {},@@ -93,10 +122,9 @@ export const useLazyComponent = <Props>({// Very important to leave the dependencies as they are, or instead// the player will remount on every frame.// For the 'component' case, we intentionally do NOT depend on- // compProps.component β the stable wrapper reads from componentRef instead.+ // compProps.component β the stable wrapper subscribes to componentStore instead.- // @ts-expect-error// eslint-disable-next-line react-hooks/exhaustive-deps- }, [compProps.lazyComponent]);+ }, [lazyComponentFromProps, componentStore]);return lazy;};diff --git a/packages/player/src/Player.tsx b/packages/player/src/Player.tsxindex e07b2b9a92..a1806e2eef 100644--- a/packages/player/src/Player.tsx+++ b/packages/player/src/Player.tsx@@ -124,11 +124,20 @@ export const componentOrNullIfLazy = <Props,>(const TimelineSequenceObserverComponent: React.FC<{readonly onTimelineSequenceChange: TimelineSequenceObserver;}> = ({onTimelineSequenceChange}) => {- const sequences = Internals.useSequenceManagerSequences();+ const registry = React.useContext(Internals.SequenceRegistryContext);- useEffect(() => {- onTimelineSequenceChange(sequences);- }, [onTimelineSequenceChange, sequences]);+ useLayoutEffect(() => {+ if (registry === null) {+ throw new Error(+ 'Timeline sequence observer requires a sequence registry',+ );+ }++ const publish = () => onTimelineSequenceChange(registry.getSnapshot());+ const unsubscribe = registry.subscribe(publish);+ publish();+ return unsubscribe;+ }, [onTimelineSequenceChange, registry]);return null;};diff --git a/packages/sdk/src/install-fiber-sequence-order-observer.ts b/packages/sdk/src/install-fiber-sequence-order-observer.tsindex 18418f42d7..b70852198e 100644--- a/packages/sdk/src/install-fiber-sequence-order-observer.ts+++ b/packages/sdk/src/install-fiber-sequence-order-observer.ts@@ -1,5 +1,5 @@import type {RefObject} from 'react';-import type {TSequence} from 'remotion';+import type {AnyComposition, TSequence} from 'remotion';import {Internals} from 'remotion';type Fiber = {@@ -45,6 +45,24 @@ type CommittedSequenceRegistration = {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;@@ -99,7 +117,17 @@ export const collectCommitOrderFromFiber = (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)[]@@ -121,7 +149,22 @@ export const collectCommitOrderFromFiber = (>();const compositionsAndFoldersByManager = new Map<string,- CompositionAndFolderOrderItem[]+ {+ readonly order: CompositionAndFolderOrderItem[];+ 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 = (@@ -189,7 +232,33 @@ export const collectCommitOrderFromFiber = (compositionManagerId !== null &&!compositionsAndFoldersByManager.has(compositionManagerId)) {- compositionsAndFoldersByManager.set(compositionManagerId, []);+ const previous =+ previousCompositionRegistrations?.get(compositionManagerId) ?? null;+ const props = fiber.memoizedProps;+ const onCommit =+ typeof props === 'object' && props !== null+ ? Reflect.get(props, 'onCommitRegistrations')+ : null;+ compositionsAndFoldersByManager.set(compositionManagerId, {+ order: [],+ registration:+ compositionRegistrations !== null && typeof onCommit === 'function'+ ? {+ onCommit:+ onCommit as CommittedCompositionRegistration['onCommit'],+ previous,+ compositions: createCommitSnapshotCollector(+ previous?.snapshot.compositions ?? null,+ ),+ folders: createCommitSnapshotCollector(+ previous?.snapshot.folders ?? null,+ ),+ orderIds: createCommitSnapshotCollector(+ previous?.snapshot.orderIds ?? null,+ ),+ }+ : null,+ });}if (hasFiberMarker(fiber, Internals.CommitOrderInternals.sequenceMarker)) {@@ -234,9 +303,21 @@ export const collectCommitOrderFromFiber = () {const id = getStringProp(fiber.memoizedProps, 'compositionId');if (id !== null) {- compositionsAndFoldersByManager- .get(compositionManagerId)- ?.push({type: 'composition', id});+ const manager =+ compositionsAndFoldersByManager.get(compositionManagerId);+ manager?.order.push({type: 'composition', id});+ manager?.registration?.orderIds.push(`composition:${id}`);+ const registration =+ typeof fiber.memoizedProps === 'object' &&+ fiber.memoizedProps !== null+ ? (Reflect.get(+ fiber.memoizedProps,+ 'registration',+ ) as AnyComposition | null)+ : null;+ if (registration) {+ manager?.registration?.compositions.push(registration);+ }}}@@ -246,9 +327,21 @@ export const collectCommitOrderFromFiber = () {const id = getStringProp(fiber.memoizedProps, 'folderId');if (id !== null) {- compositionsAndFoldersByManager- .get(compositionManagerId)- ?.push({type: 'folder', id});+ const manager =+ compositionsAndFoldersByManager.get(compositionManagerId);+ manager?.order.push({type: 'folder', id});+ manager?.registration?.orderIds.push(`folder:${id}`);+ const registration =+ typeof fiber.memoizedProps === 'object' &&+ fiber.memoizedProps !== null+ ? (Reflect.get(+ fiber.memoizedProps,+ 'registration',+ ) as FolderRegistration | null)+ : null;+ if (registration) {+ manager?.registration?.folders.push(registration);+ }}}@@ -306,15 +399,37 @@ export const collectCommitOrderFromFiber = (},);+ const compositionManagers = [...compositionsAndFoldersByManager].map(+ ([managerId, manager]) => {+ 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 {managerId, compositionAndFolderOrder: manager.order};+ },+ );+return {outlineCount: outlineNodesByRef.size,sequenceManagers,- compositionManagers: [...compositionsAndFoldersByManager].map(- ([managerId, compositionAndFolderOrder]) => ({- managerId,- compositionAndFolderOrder,- }),- ),+ compositionManagers,};};@@ -335,18 +450,33 @@ export const installFiberCommitOrderObserver = (FiberRoot,Map<string, CommittedSequenceRegistration>>();+ const compositionRegistrationsByRoot = new WeakMap<+ FiberRoot,+ Map<string, CommittedCompositionRegistration>+ >();hook.onCommitFiberRoot = function (...args) {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);const 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(@@ -364,6 +494,27 @@ export const installFiberCommitOrderObserver = (}}+ 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: [],+ });+ }+ }+ }+if (order.outlineCount > 0 ||order.sequenceManagers.length > 0 ||