Skip to content

🎥 Make videos programmatically with React

26.1 KB
Raw Blame
import React, {useCallback, useContext, useMemo, useRef, useState} from 'react';
export * from './sequence-registry-context.js';
import {
	DEFAULT_SEQUENCE_ACTIVITY_LIMIT,
	SequenceActivityContext,
	SequenceActivityDormantContext,
	SequenceActivitySettingsContext,
} from './sequence-activity-context.js';
import {
	SequenceManagerActionsContext,
	SequenceCommitRegistrationContext,
	type SequenceManagerActions,
	type SequenceNodePath,
} from './sequence-registry-context.js';
import {SequenceActivityBudgetProvider} from './SequenceActivityBudget.js';
import {SequenceActivitySuspensionProvider} from './SequenceActivitySuspensionProvider.js';
import {SequenceRegistryProvider} from './SequenceRegistryProvider.js';
import {useRemotionEnvironment} from './use-remotion-environment.js';
import type {
	CanUpdateSequencePropStatus,
	DragOverrideValue,
	DragOverrides,
	EffectDragOverrides,
	GetDragOverrides,
	GetEffectDragOverrides,
	PropStatuses,
} from './use-schema.js';
import type {SourceNumericValue} from './use-schema.js';
import {useSyncExternalStore} from './use-sync-external-store.js';
import type {VideoConfigValues} from './video-config.js';

const useIsomorphicLayoutEffect =
	typeof window === 'undefined' ? React.useEffect : React.useLayoutEffect;
const useCommitEffect = React.useInsertionEffect ?? useIsomorphicLayoutEffect;

export type VisualModePropStatuses = {
	propStatuses: PropStatuses;
};

export type VisualModePropStatusesRef = {
	current: PropStatuses;
};

export type VisualModeDragOverrides = {
	getDragOverrides: GetDragOverrides;
	getEffectDragOverrides: GetEffectDragOverrides;
};

type DragOverridesSubscription = {
	manager: SequenceManagerActions;
	subscribe: (key: string | null, listener: () => void) => () => void;
	getSnapshot: (key: string | null) => Record<string, DragOverrideValue>;
	subscribeEffects: (key: string | null, listener: () => void) => () => void;
	getEffectSnapshot: (
		key: string | null,
	) => Record<string, Record<string, DragOverrideValue>>;
};

export const VisualModeDragOverridesSubscriptionContext =
	React.createContext<DragOverridesSubscription | null>(null);

type ActiveFromDragOverrideKeys = {
	manager: SequenceManagerActions;
	keys: ReadonlySet<string>;
};

const ActiveFromDragOverrideKeysContext =
	React.createContext<ActiveFromDragOverrideKeys | null>(null);

const SequenceManagerScopeProviders: React.FC<{
	readonly children: React.ReactNode;
	readonly dragOverridesSubscription: Omit<
		DragOverridesSubscription,
		'manager'
	>;
	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}),
		[dragOverridesSubscription, manager],
	);
	const activeFromDragOverrideKeys = useMemo<ActiveFromDragOverrideKeys>(
		() => ({manager, keys: fromKeys}),
		[fromKeys, manager],
	);
	return (
		<ActiveFromDragOverrideKeysContext.Provider
			value={activeFromDragOverrideKeys}
		>
			<VisualModeDragOverridesSubscriptionContext.Provider
				value={scopedDragOverridesSubscription}
			>
				<SequenceActivityContext.Provider
					value={
						(activitySettings?.limit ?? DEFAULT_SEQUENCE_ACTIVITY_LIMIT) > 0 &&
						isStudio &&
						commitRegistrationEnabled &&
						typeof React.Activity !== 'undefined'
					}
				>
					<SequenceActivitySuspensionProvider>
						<SequenceActivityBudgetProvider>
							{children}
						</SequenceActivityBudgetProvider>
					</SequenceActivitySuspensionProvider>
				</SequenceActivityContext.Provider>
			</VisualModeDragOverridesSubscriptionContext.Provider>
		</ActiveFromDragOverrideKeysContext.Provider>
	);
};

const emptyDragOverrides: Record<string, DragOverrideValue> = {};
const emptyFromOverrideKeys: ReadonlySet<string> = new Set();
const emptyEffectDragOverrides: Record<
	string,
	Record<string, DragOverrideValue>
> = {};

export type SequencePropsStatusRemapping = {
	previousNodePath: SequencePropsSubscriptionKey;
	nodePath: SequencePropsSubscriptionKey | null;
	result: CanUpdateSequencePropsResponse | null;
};

export type VisualModeSetters = {
	setDragOverrides: (
		nodePath: SequencePropsSubscriptionKey,
		key: string,
		value: DragOverrideValue,
	) => void;
	clearDragOverrides: (nodePath: SequencePropsSubscriptionKey) => void;
	setEffectDragOverrides: (
		nodePath: SequencePropsSubscriptionKey,
		effectIndex: number,
		key: string,
		value: DragOverrideValue,
	) => void;
	clearEffectDragOverrides: (
		nodePath: SequencePropsSubscriptionKey,
		effectIndex: number,
	) => void;
	setPropStatuses: (
		nodePath: SequencePropsSubscriptionKey,
		values: (
			prev: CanUpdateSequencePropsResponse,
		) => CanUpdateSequencePropsResponse,
	) => void;
	remapPropStatuses: (
		remappings: readonly SequencePropsStatusRemapping[],
	) => void;
};

export type VisualModeBatchSetters = {
	setDragOverridesBatch: (
		overrides: readonly {
			readonly nodePath: SequencePropsSubscriptionKey;
			readonly key: string;
			readonly value: DragOverrideValue;
		}[],
	) => void;
	setEffectDragOverridesBatch: (
		overrides: readonly {
			readonly nodePath: SequencePropsSubscriptionKey;
			readonly effectIndex: number;
			readonly key: string;
			readonly value: DragOverrideValue;
		}[],
	) => void;
};

export type CanUpdateEffectPropsResponseTrue<Numeric = SourceNumericValue> = {
	canUpdate: true;
	callee: string;
	importPath: string | null;
	effectIndex: number;
	props: Record<string, CanUpdateSequencePropStatus<Numeric>>;
};

export type CannotUpdateEffectReason =
	| 'not-found'
	| 'computed'
	| 'not-call-expression';

export type CannotUpdateSequenceReason = 'not-found' | 'error';

export type CanUpdateEffectPropsResponseFalse = {
	canUpdate: false;
	effectIndex: number;
	reason: CannotUpdateEffectReason;
};

export type CanUpdateEffectPropsResponse<Numeric = SourceNumericValue> =
	| CanUpdateEffectPropsResponseTrue<Numeric>
	| CanUpdateEffectPropsResponseFalse;

export type CanUpdateSequencePropsResponseTrue<Numeric = SourceNumericValue> = {
	canUpdate: true;
	props: Record<string, CanUpdateSequencePropStatus<Numeric>>;
	effects: CanUpdateEffectPropsResponse<Numeric>[];
	/** Source ranges also include interpolations outside the editable schema. */
	durationDependentKeyframes: {
		readonly scope: SequenceNodePath;
		readonly inputRanges: readonly (readonly SourceNumericValue[] | null)[];
	} | null;
};

export type CanUpdateSequencePropsResponseFalse = {
	canUpdate: false;
	reason: CannotUpdateSequenceReason;
};

export type CanUpdateSequencePropsResponse<Numeric = SourceNumericValue> =
	| CanUpdateSequencePropsResponseTrue<Numeric>
	| CanUpdateSequencePropsResponseFalse;

export const makeSequencePropsSubscriptionKey = (
	key: SequencePropsSubscriptionKey,
): string => {
	return `${key.absolutePath}\0${key.nodePath.join('.')}\0${key.sequenceKeys.join('.')}\0${key.effectKeys.map((keys) => keys.join('.')).join('.')}`;
};

export const VisualModePropStatusesContext =
	React.createContext<VisualModePropStatuses>({
		propStatuses: {},
	});

export const VisualModePropStatusesRefContext =
	React.createContext<VisualModePropStatusesRef>({
		current: {},
	});

export type VisualModePropStatusesSubscription = {
	subscribe: (key: string | null, listener: () => void) => () => void;
	getSnapshot: (key: string | null) => CanUpdateSequencePropsResponse | null;
};

export const VisualModePropStatusesSubscriptionContext =
	React.createContext<VisualModePropStatusesSubscription>({
		subscribe: () => () => undefined,
		getSnapshot: () => null,
	});

const defaultVisualModeDragOverrides: VisualModeDragOverrides = {
	getDragOverrides: () => {
		throw new Error('VisualModeDragOverridesContext not initialized');
	},
	getEffectDragOverrides: () => {
		throw new Error('VisualModeDragOverridesContext not initialized');
	},
};

export const VisualModeDragOverridesContext =
	React.createContext<VisualModeDragOverrides>(defaultVisualModeDragOverrides);

export const VisualModeDragOverridesRefContext = React.createContext<
	React.RefObject<VisualModeDragOverrides>
>({current: defaultVisualModeDragOverrides});

const useVisualModeSnapshot = <T,>(
	subscribe: (listener: () => void) => () => void,
	getSnapshot: () => T,
): T => {
	const dormant = useContext(SequenceActivityDormantContext);
	const [, forceUpdate] = useState(0);
	const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
	useCommitEffect(() => {
		if (!dormant) {
			return;
		}

		// Activity disconnects passive subscriptions, including useSyncExternalStore.
		// Insertion effects stay connected through nested hidden Activities.
		return subscribe(() => forceUpdate((current) => current + 1));
	}, [dormant, subscribe]);
	return snapshot;
};

export const useDragOverridesForNodePath = (
	nodePath: SequencePropsSubscriptionKey | null,
): Record<string, DragOverrideValue> => {
	const subscription = useContext(VisualModeDragOverridesSubscriptionContext);
	const manager = useContext(SequenceManagerActionsContext);
	const scopedSubscription =
		subscription?.manager === manager ? subscription : null;
	const key =
		nodePath === null ? null : makeSequencePropsSubscriptionKey(nodePath);
	const subscribe = useCallback(
		(listener: () => void) =>
			scopedSubscription?.subscribe(key, listener) ?? (() => undefined),
		[key, scopedSubscription],
	);
	const getSnapshot = useCallback(
		() => scopedSubscription?.getSnapshot(key) ?? emptyDragOverrides,
		[key, scopedSubscription],
	);
	return useVisualModeSnapshot(subscribe, getSnapshot);
};

// Every visual element reads its own status. Subscribing to the whole map would
// rerender all of them whenever any status in the project changes.
export const usePropStatusForNodePath = (
	nodePath: SequencePropsSubscriptionKey | null,
): CanUpdateSequencePropsResponse | null => {
	const subscription = useContext(VisualModePropStatusesSubscriptionContext);
	const key =
		nodePath === null ? null : makeSequencePropsSubscriptionKey(nodePath);
	const subscribe = useCallback(
		(listener: () => void) => subscription.subscribe(key, listener),
		[key, subscription],
	);
	const getSnapshot = useCallback(
		() => subscription.getSnapshot(key),
		[key, subscription],
	);
	return useVisualModeSnapshot(subscribe, getSnapshot);
};

export const useActiveFromDragOverrideKeys = (): ReadonlySet<string> => {
	const snapshot = useContext(ActiveFromDragOverrideKeysContext);
	const manager = useContext(SequenceManagerActionsContext);
	return snapshot?.manager === manager ? snapshot.keys : emptyFromOverrideKeys;
};

export const useEffectDragOverridesForNodePath = (
	nodePath: SequencePropsSubscriptionKey | null,
): Record<string, Record<string, DragOverrideValue>> => {
	const subscription = useContext(VisualModeDragOverridesSubscriptionContext);
	const manager = useContext(SequenceManagerActionsContext);
	const scopedSubscription =
		subscription?.manager === manager ? subscription : null;
	const key =
		nodePath === null ? null : makeSequencePropsSubscriptionKey(nodePath);
	const subscribe = useCallback(
		(listener: () => void) =>
			scopedSubscription?.subscribeEffects(key, listener) ?? (() => undefined),
		[key, scopedSubscription],
	);
	const getSnapshot = useCallback(
		() =>
			scopedSubscription?.getEffectSnapshot(key) ?? emptyEffectDragOverrides,
		[key, scopedSubscription],
	);
	return useVisualModeSnapshot(subscribe, getSnapshot);
};

export const VisualModeSettersContext = React.createContext<VisualModeSetters>({
	setDragOverrides: () => {
		throw new Error('VisualModeSettersContext not initialized');
	},
	clearDragOverrides: () => {
		throw new Error('VisualModeSettersContext not initialized');
	},
	setEffectDragOverrides: () => {
		throw new Error('VisualModeSettersContext not initialized');
	},
	clearEffectDragOverrides: () => {
		throw new Error('VisualModeSettersContext not initialized');
	},
	setPropStatuses: () => {
		throw new Error('VisualModeSettersContext not initialized');
	},
	remapPropStatuses: () => {
		throw new Error('VisualModeSettersContext not initialized');
	},
});

export const VisualModeBatchSettersContext =
	React.createContext<VisualModeBatchSetters | null>(null);

export type SequencePropsSubscriptionKey = {
	absolutePath: string;
	nodePath: SequenceNodePath;
	sequenceKeys: string[];
	effectKeys: string[][];
	/** Evaluation context of a rendered instance. Never part of source identity. */
	videoConfigValues: VideoConfigValues | null;
};

export type {VideoConfigValues} from './video-config.js';

const effectDragOverridesKey = (
	nodePath: SequencePropsSubscriptionKey,
	effectIndex: number,
): string =>
	`${makeSequencePropsSubscriptionKey(nodePath)}.effects.${effectIndex}`;

export const SequenceManagerProvider: React.FC<{
	readonly children: React.ReactNode;
}> = ({children}) => {
	const [dragOverrideState, setDragOverrideState] = useState(() => ({
		overrides: {} as DragOverrides,
		fromKeys: new Set<string>(),
	}));
	const dragOverrides = dragOverrideState.overrides;
	const dragOverridesStore = useRef({
		snapshot: dragOverrides,
		listeners: new Map<string, Set<() => void>>(),
	});
	const [effectDragOverridesState, setEffectDragOverridesState] =
		useState<EffectDragOverrides>({});
	const effectDragOverridesStore = useRef({
		snapshot: effectDragOverridesState,
		byNode: new Map<
			string,
			Record<string, Record<string, DragOverrideValue>>
		>(),
		listeners: new Map<string, Set<() => void>>(),
	});
	const [propStatuses, setPropStatusesMapState] = useState<PropStatuses>({});
	const propStatusesRef = useRef(propStatuses);
	// Elements read their own status from the latest requested map, so one that
	// rerenders together with a status update never renders the previous status.
	// The layout effect wakes up the elements that did not rerender.
	const requestedPropStatusesRef = useRef(propStatuses);
	const propStatusListeners = useRef(new Map<string, Set<() => void>>());
	useIsomorphicLayoutEffect(() => {
		const previous = propStatusesRef.current;
		propStatusesRef.current = propStatuses;
		for (const [key, listeners] of propStatusListeners.current) {
			if (previous[key] !== propStatuses[key]) {
				for (const listener of listeners) {
					listener();
				}
			}
		}
	}, [propStatuses]);

	const setDragOverridesBatch = useCallback(
		(
			overrides: readonly {
				readonly nodePath: SequencePropsSubscriptionKey;
				readonly key: string;
				readonly value: DragOverrideValue;
			}[],
		) => {
			setDragOverrideState((prevState) => {
				const prev = prevState.overrides;
				let next: DragOverrides | null = null;
				let nextFromKeys = prevState.fromKeys;
				for (const {nodePath, key, value} of overrides) {
					const mapKey = makeSequencePropsSubscriptionKey(nodePath);
					const existing = (next ?? prev)[mapKey]?.[key];
					if (
						existing === value ||
						(existing?.type === 'static' &&
							value.type === 'static' &&
							Object.is(existing.value, value.value))
					) {
						continue;
					}

					if (next === null) {
						next = {...prev};
					}

					if (next[mapKey] === prev[mapKey]) {
						next[mapKey] = {...prev[mapKey]};
					}

					next[mapKey][key] = value;
					if (key === 'from' && !nextFromKeys.has(mapKey)) {
						nextFromKeys = new Set(nextFromKeys);
						nextFromKeys.add(mapKey);
					}
				}

				return next === null
					? prevState
					: {overrides: next, fromKeys: nextFromKeys};
			});
		},
		[],
	);

	const setDragOverrides = useCallback(
		(
			nodePath: SequencePropsSubscriptionKey,
			key: string,
			value: DragOverrideValue,
		) => setDragOverridesBatch([{nodePath, key, value}]),
		[setDragOverridesBatch],
	);

	const subscribeDragOverrides = useCallback(
		(key: string | null, listener: () => void) => {
			if (key === null) {
				return () => undefined;
			}

			let listeners = dragOverridesStore.current.listeners.get(key);
			if (!listeners) {
				listeners = new Set();
				dragOverridesStore.current.listeners.set(key, listeners);
			}

			listeners.add(listener);
			return () => {
				listeners.delete(listener);
				if (listeners.size === 0) {
					dragOverridesStore.current.listeners.delete(key);
				}
			};
		},
		[],
	);
	const getDragOverridesSnapshot = useCallback((key: string | null) => {
		return key === null
			? emptyDragOverrides
			: (dragOverridesStore.current.snapshot[key] ?? emptyDragOverrides);
	}, []);
	useIsomorphicLayoutEffect(() => {
		const previous = dragOverridesStore.current.snapshot;
		dragOverridesStore.current.snapshot = dragOverrides;
		for (const key of new Set([
			...Object.keys(previous),
			...Object.keys(dragOverrides),
		])) {
			if (previous[key] !== dragOverrides[key]) {
				for (const listener of dragOverridesStore.current.listeners.get(key) ??
					[]) {
					listener();
				}
			}
		}
	}, [dragOverrides]);
	const subscribeEffectDragOverrides = useCallback(
		(key: string | null, listener: () => void) => {
			if (key === null) {
				return () => undefined;
			}

			let listeners = effectDragOverridesStore.current.listeners.get(key);
			if (!listeners) {
				listeners = new Set();
				effectDragOverridesStore.current.listeners.set(key, listeners);
			}

			listeners.add(listener);
			return () => {
				listeners.delete(listener);
				if (listeners.size === 0) {
					effectDragOverridesStore.current.listeners.delete(key);
				}
			};
		},
		[],
	);
	const getEffectDragOverridesSnapshot = useCallback((key: string | null) => {
		return key === null
			? emptyEffectDragOverrides
			: (effectDragOverridesStore.current.byNode.get(key) ??
					emptyEffectDragOverrides);
	}, []);
	useIsomorphicLayoutEffect(() => {
		const previous = effectDragOverridesStore.current.snapshot;
		const byNode = new Map(effectDragOverridesStore.current.byNode);
		const changedNodes = new Set<string>();
		for (const flatKey of new Set([
			...Object.keys(previous),
			...Object.keys(effectDragOverridesState),
		])) {
			if (previous[flatKey] === effectDragOverridesState[flatKey]) {
				continue;
			}

			const separator = flatKey.lastIndexOf('.effects.');
			if (separator === -1) {
				throw new Error('Invalid effect drag override key');
			}

			const nodeKey = flatKey.slice(0, separator);
			const effectIndex = flatKey.slice(separator + '.effects.'.length);
			if (!changedNodes.has(nodeKey)) {
				byNode.set(nodeKey, {...byNode.get(nodeKey)});
				changedNodes.add(nodeKey);
			}

			const next = byNode.get(nodeKey)!;
			if (effectDragOverridesState[flatKey] === undefined) {
				delete next[effectIndex];
			} else {
				next[effectIndex] = effectDragOverridesState[flatKey];
			}
		}

		for (const nodeKey of changedNodes) {
			if (Object.keys(byNode.get(nodeKey)!).length === 0) {
				byNode.delete(nodeKey);
			}
		}

		effectDragOverridesStore.current.snapshot = effectDragOverridesState;
		effectDragOverridesStore.current.byNode = byNode;
		for (const nodeKey of changedNodes) {
			for (const listener of effectDragOverridesStore.current.listeners.get(
				nodeKey,
			) ?? []) {
				listener();
			}
		}
	}, [effectDragOverridesState]);

	const clearDragOverrides = useCallback(
		(nodePath: SequencePropsSubscriptionKey) => {
			setDragOverrideState((prevState) => {
				const prev = prevState.overrides;
				const key = makeSequencePropsSubscriptionKey(nodePath);
				if (!prev[key]) {
					return prevState;
				}

				const next = {...prev};
				delete next[key];
				const nextFromKeys = prevState.fromKeys.has(key)
					? new Set(prevState.fromKeys)
					: prevState.fromKeys;
				nextFromKeys.delete(key);
				return {overrides: next, fromKeys: nextFromKeys};
			});
		},
		[],
	);

	const setEffectDragOverridesBatch = useCallback(
		(
			overrides: readonly {
				readonly nodePath: SequencePropsSubscriptionKey;
				readonly effectIndex: number;
				readonly key: string;
				readonly value: DragOverrideValue;
			}[],
		) => {
			setEffectDragOverridesState((prev) => {
				let next: EffectDragOverrides | null = null;
				for (const {nodePath, effectIndex, key, value} of overrides) {
					const mapKey = effectDragOverridesKey(nodePath, effectIndex);
					const existing = (next ?? prev)[mapKey]?.[key];
					if (
						existing === value ||
						(existing?.type === 'static' &&
							value.type === 'static' &&
							Object.is(existing.value, value.value))
					) {
						continue;
					}

					if (next === null) {
						next = {...prev};
					}

					if (next[mapKey] === prev[mapKey]) {
						next[mapKey] = {...prev[mapKey]};
					}

					next[mapKey][key] = value;
				}

				return next ?? prev;
			});
		},
		[],
	);
	const setEffectDragOverrides = useCallback(
		(
			nodePath: SequencePropsSubscriptionKey,
			effectIndex: number,
			key: string,
			value: DragOverrideValue,
		) => setEffectDragOverridesBatch([{nodePath, effectIndex, key, value}]),
		[setEffectDragOverridesBatch],
	);

	const clearEffectDragOverrides = useCallback(
		(nodePath: SequencePropsSubscriptionKey, effectIndex: number) => {
			setEffectDragOverridesState((prev) => {
				const mapKey = effectDragOverridesKey(nodePath, effectIndex);
				if (!prev[mapKey]) {
					return prev;
				}

				const next = {...prev};
				delete next[mapKey];
				return next;
			});
		},
		[],
	);

	const updatePropStatuses = useCallback(
		(update: (prev: PropStatuses) => PropStatuses) => {
			const previous = requestedPropStatusesRef.current;
			const next = update(previous);
			if (next === previous) {
				return;
			}

			requestedPropStatusesRef.current = next;
			setPropStatusesMapState(next);
		},
		[],
	);
	const setPropStatuses = useCallback(
		(
			nodePath: SequencePropsSubscriptionKey,
			values: (
				prev: CanUpdateSequencePropsResponse,
			) => CanUpdateSequencePropsResponse,
		) => {
			updatePropStatuses((prev) => {
				const key = makeSequencePropsSubscriptionKey(nodePath);

				const prevKey = prev[key];
				const newKey = values(prevKey);

				if (prevKey === newKey) {
					return prev;
				}

				return {...prev, [key]: newKey};
			});
		},
		[updatePropStatuses],
	);
	const remapPropStatuses = useCallback(
		(remappings: readonly SequencePropsStatusRemapping[]) => {
			updatePropStatuses((prev) => {
				const next = {...prev};
				for (const remapping of remappings) {
					delete next[
						makeSequencePropsSubscriptionKey(remapping.previousNodePath)
					];
				}

				for (const remapping of remappings) {
					if (remapping.nodePath !== null && remapping.result !== null) {
						next[makeSequencePropsSubscriptionKey(remapping.nodePath)] =
							remapping.result;
					}
				}

				return next;
			});
		},
		[updatePropStatuses],
	);

	const dragOverridesSubscription = useMemo<
		Omit<DragOverridesSubscription, 'manager'>
	>(
		() => ({
			subscribe: subscribeDragOverrides,
			getSnapshot: getDragOverridesSnapshot,
			subscribeEffects: subscribeEffectDragOverrides,
			getEffectSnapshot: getEffectDragOverridesSnapshot,
		}),
		[
			getDragOverridesSnapshot,
			getEffectDragOverridesSnapshot,
			subscribeDragOverrides,
			subscribeEffectDragOverrides,
		],
	);

	const getDragOverrides = useCallback(
		(nodePath: SequencePropsSubscriptionKey) => {
			return dragOverrides[makeSequencePropsSubscriptionKey(nodePath)] ?? {};
		},
		[dragOverrides],
	);

	const getEffectDragOverrides = useCallback(
		(nodePath: SequencePropsSubscriptionKey, effectIndex: number) => {
			return (
				effectDragOverridesState[
					effectDragOverridesKey(nodePath, effectIndex)
				] ?? {}
			);
		},
		[effectDragOverridesState],
	);

	const propStatusesContext: VisualModePropStatuses = useMemo(() => {
		return {
			propStatuses,
		};
	}, [propStatuses]);
	const propStatusesSubscription = useMemo<VisualModePropStatusesSubscription>(
		() => ({
			subscribe: (key, listener) => {
				if (key === null) {
					return () => undefined;
				}

				let listeners = propStatusListeners.current.get(key);
				if (!listeners) {
					listeners = new Set();
					propStatusListeners.current.set(key, listeners);
				}

				listeners.add(listener);
				return () => {
					listeners.delete(listener);
					if (listeners.size === 0) {
						propStatusListeners.current.delete(key);
					}
				};
			},
			getSnapshot: (key) =>
				key === null ? null : (requestedPropStatusesRef.current[key] ?? null),
		}),
		[],
	);

	const dragOverridesContext: VisualModeDragOverrides = useMemo(() => {
		return {
			getDragOverrides,
			getEffectDragOverrides,
		};
	}, [getDragOverrides, getEffectDragOverrides]);
	const dragOverridesRef = useRef(dragOverridesContext);
	useIsomorphicLayoutEffect(() => {
		// Interaction handlers read the latest committed overrides without subscribing.
		dragOverridesRef.current = dragOverridesContext;
	}, [dragOverridesContext]);

	const settersContext: VisualModeSetters = useMemo(() => {
		return {
			setDragOverrides,
			clearDragOverrides,
			setEffectDragOverrides,
			clearEffectDragOverrides,
			setPropStatuses,
			remapPropStatuses,
		};
	}, [
		setDragOverrides,
		clearDragOverrides,
		setEffectDragOverrides,
		clearEffectDragOverrides,
		setPropStatuses,
		remapPropStatuses,
	]);
	const batchSettersContext = useMemo<VisualModeBatchSetters>(
		() => ({setDragOverridesBatch, setEffectDragOverridesBatch}),
		[setDragOverridesBatch, setEffectDragOverridesBatch],
	);

	return (
		<SequenceRegistryProvider>
			<VisualModePropStatusesRefContext.Provider value={propStatusesRef}>
				<VisualModePropStatusesSubscriptionContext.Provider
					value={propStatusesSubscription}
				>
					<VisualModePropStatusesContext.Provider value={propStatusesContext}>
						<SequenceManagerScopeProviders
							dragOverridesSubscription={dragOverridesSubscription}
							fromKeys={dragOverrideState.fromKeys}
						>
							<VisualModeDragOverridesContext.Provider
								value={dragOverridesContext}
							>
								<VisualModeDragOverridesRefContext.Provider
									value={dragOverridesRef}
								>
									<VisualModeSettersContext.Provider value={settersContext}>
										<VisualModeBatchSettersContext.Provider
											value={batchSettersContext}
										>
											{children}
										</VisualModeBatchSettersContext.Provider>
									</VisualModeSettersContext.Provider>
								</VisualModeDragOverridesRefContext.Provider>
							</VisualModeDragOverridesContext.Provider>
						</SequenceManagerScopeProviders>
					</VisualModePropStatusesContext.Provider>
				</VisualModePropStatusesSubscriptionContext.Provider>
			</VisualModePropStatusesRefContext.Provider>
		</SequenceRegistryProvider>
	);
};