remotion 4.0.490 → 4.0.492

package/dist/cjs/internals.d.ts

@@ -6,7 +6,7 @@ import type { JsxComponentIdentity, TCompMetadata, TComposition, TRenderAsset, T
 import type { CompositionManagerContext } from './CompositionManagerContext.js';
 import * as CSSUtils from './default-css.js';
 import type { SerializedJSONWithCustomFields } from './input-props-serialization.js';
-import { type ArrayFieldSchema, type ArrayItemFieldSchema, type InteractivitySchemaField, type InteractivitySchema, type VisibleFieldSchema } from './interactivity-schema.js';
+import { type AssetFieldSchema, type ArrayFieldSchema, type ArrayItemFieldSchema, type InteractivitySchemaField, type InteractivitySchema, type VisibleFieldSchema } from './interactivity-schema.js';
 import type { LoggingContextValue } from './log-level-context.js';
 import type { NonceHistory } from './nonce.js';
 import type { RemotionEnvironment } from './remotion-environment-context.js';
@@ -14,11 +14,11 @@ import type { OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSe
 import { OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext } from './sequence-node-path.js';
 import type { ResolvedStackLocation } from './sequence-stack-traces.js';
 import type { CannotUpdateSequenceReason } from './SequenceManager.js';
-import { type CanUpdateEffectPropsResponse, type CanUpdateEffectPropsResponseFalse, type CanUpdateEffectPropsResponseTrue, type CanUpdateSequencePropsResponse, type CanUpdateSequencePropsResponseFalse, type CanUpdateSequencePropsResponseTrue, type SequenceNodePath, type SequencePropsSubscriptionKey } from './SequenceManager.js';
+import { type CanUpdateEffectPropsResponse, type CanUpdateEffectPropsResponseFalse, type CanUpdateEffectPropsResponseTrue, type CanUpdateSequencePropsResponse, type CanUpdateSequencePropsResponseFalse, type CanUpdateSequencePropsResponseTrue, type SequenceNodePath, type SequencePropsSubscriptionKey, type VideoConfigValues } from './SequenceManager.js';
 import * as TimelinePosition from './timeline-position-state.js';
 import { type PlaybackRateContextValue, type SetTimelineContextValue, type TimelineContextValue } from './TimelineContext.js';
 import { truthy } from './truthy.js';
-import type { CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusEasing, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, DragOverrideValue, GetDragOverrides, GetEffectDragOverrides, GetEffectPropStatuses, GetPropStatuses } from './use-schema.js';
+import type { CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusEasing, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, DragOverrideValue, GetDragOverrides, GetEffectDragOverrides, GetEffectPropStatuses, GetPropStatuses, VideoConfigNumericExpression } from './use-schema.js';
 import { type CanUpdateSequencePropStatus, type DragOverrides, type EffectDragOverrides, type PropStatuses } from './use-schema.js';
 import type { MediaVolumeContextValue, SetMediaVolumeContextValue } from './volume-position-state.js';
 import type { WatchRemotionStaticFilesPayload } from './watch-static-file.js';
@@ -701,6 +701,8 @@ export declare const Internals: {
         buffering: import("react").RefObject<boolean>;
     } | null>;
     readonly getComponentsToAddStacksTo: () => unknown[];
+    readonly getSequenceComponent: () => unknown;
+    readonly getSingleChildComponent: (children: import("react").ReactNode) => unknown;
     readonly CurrentScaleContext: import("react").Context<import("./use-current-scale.js").CurrentScaleContextType | null>;
     readonly PixelDensityContext: import("react").Context<number | null>;
     readonly PreviewSizeContext: import("react").Context<import("./use-current-scale.js").PreviewSizeCtx>;
@@ -930,4 +932,4 @@ export declare const Internals: {
         readonly hiddenFromList: true;
     };
 };
-export type { ArrayFieldSchema, ArrayItemFieldSchema, CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateEffectPropsResponseFalse, CanUpdateEffectPropsResponseTrue, CanUpdateSequencePropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, CanUpdateSequencePropStatusEasing, CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, CompositionManagerContext, CompProps, DragOverrides, DragOverrideValue, EffectDragOverrides, GetDragOverrides, GetEffectDragOverrides, GetEffectPropStatuses, GetPropStatuses, JsxComponentIdentity, LoggingContextValue, MediaVolumeContextValue, NonceHistory, OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext, OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSetters, PlaybackRateContextValue, PropStatuses, RemotionAudioContextState, RemotionEnvironment, ResolvedStackLocation, ScheduleAudioNodeOptions, ScheduleAudioNodeResult, InteractivitySchemaField, SequenceNodePath, SequencePropsSubscriptionKey, InteractivitySchema, SerializedJSONWithCustomFields, SetMediaVolumeContextValue, SetTimelineContextValue, TCompMetadata, TComposition, TimelineContextValue, TRenderAsset, TSequence, VisibleFieldSchema, WatchRemotionStaticFilesPayload, };
+export type { ArrayFieldSchema, AssetFieldSchema, ArrayItemFieldSchema, CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateEffectPropsResponseFalse, CanUpdateEffectPropsResponseTrue, CanUpdateSequencePropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, CanUpdateSequencePropStatusEasing, CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, VideoConfigNumericExpression, CompositionManagerContext, CompProps, DragOverrides, DragOverrideValue, EffectDragOverrides, GetDragOverrides, GetEffectDragOverrides, GetEffectPropStatuses, GetPropStatuses, JsxComponentIdentity, LoggingContextValue, MediaVolumeContextValue, NonceHistory, OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext, OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSetters, PlaybackRateContextValue, PropStatuses, RemotionAudioContextState, RemotionEnvironment, ResolvedStackLocation, ScheduleAudioNodeOptions, ScheduleAudioNodeResult, InteractivitySchemaField, SequenceNodePath, SequencePropsSubscriptionKey, VideoConfigValues, InteractivitySchema, SerializedJSONWithCustomFields, SetMediaVolumeContextValue, SetTimelineContextValue, TCompMetadata, TComposition, TimelineContextValue, TRenderAsset, TSequence, VisibleFieldSchema, WatchRemotionStaticFilesPayload, };

package/dist/cjs/internals.js

@@ -211,6 +211,8 @@ exports.Internals = {
     BufferingProvider: buffering_js_1.BufferingProvider,
     BufferingContextReact: buffering_js_1.BufferingContextReact,
     getComponentsToAddStacksTo: enable_sequence_stack_traces_js_1.getComponentsToAddStacksTo,
+    getSequenceComponent: enable_sequence_stack_traces_js_1.getSequenceComponent,
+    getSingleChildComponent: enable_sequence_stack_traces_js_1.getSingleChildComponent,
     CurrentScaleContext: use_current_scale_js_1.CurrentScaleContext,
     PixelDensityContext: use_pixel_density_js_1.PixelDensityContext,
     PreviewSizeContext: use_current_scale_js_1.PreviewSizeContext,

package/dist/cjs/interpolate-translate.d.ts

@@ -0,0 +1,8 @@
+import { type InterpolateOptions } from './interpolate.js';
+export type InterpolateTranslateOptions = InterpolateOptions;
+export declare const interpolateTranslate: (input: number, inputRange: readonly number[], outputRange: readonly string[], options?: Partial<{
+    easing: import("./interpolate.js").EasingFunction | readonly import("./interpolate.js").EasingFunction[];
+    extrapolateLeft: import("./interpolate.js").ExtrapolateType;
+    extrapolateRight: import("./interpolate.js").ExtrapolateType;
+    posterize: number;
+}> | undefined) => string;

package/dist/cjs/interpolate-translate.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.interpolateTranslate = void 0;
+const interpolate_js_1 = require("./interpolate.js");
+const pixelValueRegex = /^([+-]?(?:\d+\.?\d*|\.\d+))px$/;
+const parseTranslate = (value) => {
+    if (typeof value !== 'string') {
+        throw new TypeError(`outputRange must contain only strings, but got ${typeof value}`);
+    }
+    const parts = value.trim().split(/\s+/);
+    if (parts.length < 1 || parts.length > 3 || parts[0] === '') {
+        throw new TypeError(`translate values must contain 1 to 3 pixel values, but got "${value}"`);
+    }
+    return parts.map((part) => {
+        const match = pixelValueRegex.exec(part);
+        if (match === null) {
+            throw new TypeError(`interpolateTranslate() only supports px values, but got "${part}" in "${value}"`);
+        }
+        return Number(match[1]);
+    });
+};
+/*
+ * @description Allows you to map a range of values to CSS translate values using pixel units.
+ * @see [Documentation](https://remotion.dev/docs/interpolate-translate)
+ */
+const interpolateTranslate = (input, inputRange, outputRange, options) => {
+    var _a;
+    if (typeof input === 'undefined') {
+        throw new TypeError('input can not be undefined');
+    }
+    if (typeof inputRange === 'undefined') {
+        throw new TypeError('inputRange can not be undefined');
+    }
+    if (typeof outputRange === 'undefined') {
+        throw new TypeError('outputRange can not be undefined');
+    }
+    if (inputRange.length !== outputRange.length) {
+        throw new TypeError('inputRange (' +
+            inputRange.length +
+            ' values provided) and outputRange (' +
+            outputRange.length +
+            ' values provided) must have the same length');
+    }
+    const parsedOutputRange = outputRange.map((translateValue) => parseTranslate(translateValue));
+    const firstValueLength = (_a = parsedOutputRange[0]) === null || _a === void 0 ? void 0 : _a.length;
+    if (firstValueLength === undefined) {
+        throw new TypeError('outputRange must have at least 1 element');
+    }
+    for (const parsedTranslate of parsedOutputRange) {
+        if (parsedTranslate.length !== firstValueLength) {
+            throw new TypeError(`All translate values must have the same number of pixel values, but got ${firstValueLength} and ${parsedTranslate.length}`);
+        }
+    }
+    return new Array(firstValueLength)
+        .fill(true)
+        .map((_, index) => {
+        const outputValues = [];
+        for (const translateValue of parsedOutputRange) {
+            const value = translateValue[index];
+            if (value === undefined) {
+                throw new TypeError(`All translate values must have the same number of pixel values, but got ${firstValueLength} and ${translateValue.length}`);
+            }
+            outputValues.push(value);
+        }
+        const interpolatedValue = (0, interpolate_js_1.interpolate)(input, inputRange, outputValues, options);
+        return `${interpolatedValue}px`;
+    })
+        .join(' ');
+};
+exports.interpolateTranslate = interpolateTranslate;

package/dist/cjs/series/index.js

@@ -1,63 +1,136 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Series = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
-const react_1 = require("react");
+const react_1 = __importStar(require("react"));
 const enable_sequence_stack_traces_js_1 = require("../enable-sequence-stack-traces.js");
+const Interactive_js_1 = require("../Interactive.js");
 const interactivity_schema_js_1 = require("../interactivity-schema.js");
 const Sequence_js_1 = require("../Sequence.js");
 const validate_duration_in_frames_js_1 = require("../validation/validate-duration-in-frames.js");
 const with_interactivity_schema_js_1 = require("../with-interactivity-schema.js");
 const flatten_children_js_1 = require("./flatten-children.js");
 const is_inside_series_js_1 = require("./is-inside-series.js");
-const SeriesSequenceRefForwardingFunction = ({ children }, _ref) => {
-    (0, is_inside_series_js_1.useRequireToBeInsideSeries)();
-    // Discard ref
-    return jsx_runtime_1.jsx(is_inside_series_js_1.IsNotInsideSeriesProvider, { children: children });
+const seriesSequenceSchema = {
+    durationInFrames: Interactive_js_1.Interactive.baseSchema.durationInFrames,
+    name: Interactive_js_1.Interactive.sequenceSchema.name,
+    hidden: Interactive_js_1.Interactive.sequenceSchema.hidden,
+    showInTimeline: Interactive_js_1.Interactive.sequenceSchema.showInTimeline,
+    freeze: Interactive_js_1.Interactive.baseSchema.freeze,
+    layout: Interactive_js_1.Interactive.sequenceSchema.layout,
 };
-const SeriesSequence = (0, react_1.forwardRef)(SeriesSequenceRefForwardingFunction);
+const SeriesSequenceInner = (0, react_1.forwardRef)(({ offset = 0, className = '', stack = null, _remotionInternalRender = null, ...props }, ref) => {
+    (0, is_inside_series_js_1.useRequireToBeInsideSeries)();
+    if (_remotionInternalRender) {
+        return _remotionInternalRender({ ...props, offset, className: className || undefined, stack }, ref);
+    }
+    return (jsx_runtime_1.jsx(is_inside_series_js_1.IsNotInsideSeriesProvider, { children: props.children }));
+});
+const SeriesSequence = Interactive_js_1.Interactive.withSchema({
+    Component: SeriesSequenceInner,
+    componentName: '<Series.Sequence>',
+    componentIdentity: 'dev.remotion.remotion.Series.Sequence',
+    schema: seriesSequenceSchema,
+    supportsEffects: false,
+});
 const SequenceWithoutSchemaWithRef = Sequence_js_1.SequenceWithoutSchema;
+const validateSeriesSequenceProps = ({ durationInFrames, offset: offsetProp, index, childrenLength, }) => {
+    const debugInfo = `index = ${index}, duration = ${durationInFrames}`;
+    if (index !== childrenLength - 1 || durationInFrames !== Infinity) {
+        (0, validate_duration_in_frames_js_1.validateDurationInFrames)(durationInFrames, {
+            component: `of a <Series.Sequence /> component`,
+            allowFloats: true,
+        });
+    }
+    const offset = offsetProp !== null && offsetProp !== void 0 ? offsetProp : 0;
+    if (Number.isNaN(offset)) {
+        throw new TypeError(`The "offset" property of a <Series.Sequence /> must not be NaN, but got NaN (${debugInfo}).`);
+    }
+    if (!Number.isFinite(offset)) {
+        throw new TypeError(`The "offset" property of a <Series.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
+    }
+    if (offset % 1 !== 0) {
+        throw new TypeError(`The "offset" property of a <Series.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
+    }
+    return offset;
+};
 const SeriesInner = (props) => {
     const childrenValue = (0, react_1.useMemo)(() => {
-        let startFrame = 0;
         const flattenedChildren = (0, flatten_children_js_1.flattenChildren)(props.children);
-        return react_1.Children.map(flattenedChildren, (child, i) => {
-            var _a;
+        const renderChildren = (i, startFrame) => {
+            if (i === flattenedChildren.length) {
+                return null;
+            }
+            const child = flattenedChildren[i];
             const castedChild = child;
             if (typeof castedChild === 'string') {
                 // Don't throw if it's just some accidential whitespace
                 if (castedChild.trim() === '') {
-                    return null;
+                    return renderChildren(i + 1, startFrame);
                 }
                 throw new TypeError(`The <Series /> component only accepts a list of <Series.Sequence /> components as its children, but you passed a string "${castedChild}"`);
             }
             if (castedChild.type !== SeriesSequence) {
                 throw new TypeError(`The <Series /> component only accepts a list of <Series.Sequence /> components as its children, but got ${castedChild} instead`);
             }
-            const debugInfo = `index = ${i}, duration = ${castedChild.props.durationInFrames}`;
-            const durationInFramesProp = castedChild.props.durationInFrames;
-            const { durationInFrames, children: _children, from, name, ...passedProps } = castedChild.props; // `from` is not accepted and must be filtered out if used in JS
-            if (i !== flattenedChildren.length - 1 ||
-                durationInFramesProp !== Infinity) {
-                (0, validate_duration_in_frames_js_1.validateDurationInFrames)(durationInFramesProp, {
-                    component: `of a <Series.Sequence /> component`,
-                    allowFloats: true,
-                });
-            }
-            const offset = (_a = castedChild.props.offset) !== null && _a !== void 0 ? _a : 0;
-            if (Number.isNaN(offset)) {
-                throw new TypeError(`The "offset" property of a <Series.Sequence /> must not be NaN, but got NaN (${debugInfo}).`);
-            }
-            if (!Number.isFinite(offset)) {
-                throw new TypeError(`The "offset" property of a <Series.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
-            }
-            if (offset % 1 !== 0) {
-                throw new TypeError(`The "offset" property of a <Series.Sequence /> must be finite, but got ${offset} (${debugInfo}).`);
-            }
-            const currentStartFrame = startFrame + offset;
-            startFrame += durationInFramesProp + offset;
-            return (jsx_runtime_1.jsx(SequenceWithoutSchemaWithRef, { ref: castedChild.ref, name: name || '<Series.Sequence>', _remotionInternalDocumentationLink: name ? undefined : 'https://www.remotion.dev/docs/series', from: currentStartFrame, durationInFrames: durationInFramesProp, ...passedProps, children: child }));
-        });
+            const castedElement = castedChild;
+            validateSeriesSequenceProps({
+                durationInFrames: castedElement.props.durationInFrames,
+                offset: castedElement.props.offset,
+                index: i,
+                childrenLength: flattenedChildren.length,
+            });
+            return react_1.default.cloneElement(castedElement, {
+                _remotionInternalRender: (resolvedProps, ref) => {
+                    const durationInFramesProp = resolvedProps.durationInFrames;
+                    const { durationInFrames: _durationInFrames, children: sequenceChildren, offset: offsetProp, controls, stack, from: _from, name, ...passedProps } = resolvedProps; // `from` is not accepted and must be filtered out if used in JS
+                    const offset = validateSeriesSequenceProps({
+                        durationInFrames: durationInFramesProp,
+                        offset: offsetProp,
+                        index: i,
+                        childrenLength: flattenedChildren.length,
+                    });
+                    const currentStartFrame = startFrame + offset;
+                    const nextStartFrame = startFrame + durationInFramesProp + offset;
+                    return (jsx_runtime_1.jsxs(jsx_runtime_1.Fragment, { children: [
+                            jsx_runtime_1.jsx(SequenceWithoutSchemaWithRef, { ref: ref, name: name || '<Series.Sequence>', _remotionInternalDocumentationLink: name ? undefined : 'https://www.remotion.dev/docs/series', _remotionInternalStack: stack !== null && stack !== void 0 ? stack : undefined, controls: controls !== null && controls !== void 0 ? controls : undefined, from: currentStartFrame, durationInFrames: durationInFramesProp, ...passedProps, children: jsx_runtime_1.jsx(is_inside_series_js_1.IsNotInsideSeriesProvider, { children: sequenceChildren }) }), renderChildren(i + 1, nextStartFrame)] }));
+                },
+            });
+        };
+        return renderChildren(0, 0);
     }, [props.children]);
     return (jsx_runtime_1.jsx(is_inside_series_js_1.IsInsideSeriesContainer, { children: jsx_runtime_1.jsx(Sequence_js_1.Sequence, { layout: "none", name: "<Series>", _remotionInternalDocumentationLink: "https://www.remotion.dev/docs/series", ...props, children: childrenValue }) }));
 };

package/dist/cjs/use-media-in-timeline.js

@@ -133,6 +133,7 @@ const useMediaInTimeline = ({ volume, mediaVolume, src, mediaType, playbackRate,
             showInTimeline: true,
             nonce: nonce.get(),
             startMediaFrom: 0 - startsAt,
+            mediaFrameAtSequenceZero: null,
             doesVolumeChange,
             loopDisplay,
             playbackRate,

package/dist/cjs/use-schema.d.ts

@@ -4,10 +4,27 @@ import type { CanUpdateSequencePropsResponse, SequencePropsSubscriptionKey } fro
 export type CanUpdateSequencePropStatusStatic = {
     status: 'static';
     codeValue: unknown;
+    numericExpression?: VideoConfigNumericExpression;
 };
 export type CanUpdateSequencePropStatusKeyframe = {
     frame: number;
     value: unknown;
+    frameExpression?: VideoConfigNumericExpression;
+};
+export type VideoConfigNumericExpression = {
+    type: 'literal';
+    value: number;
+} | {
+    type: 'video-config-value';
+    identifier: string;
+    value: number;
+} | {
+    type: 'video-config-multiplication';
+    identifier: string;
+    multiplier: number;
+    multiplicand: number;
+    factorPosition: 'left' | 'right';
+    value: number;
 };
 export type CanUpdateSequencePropStatusLinearEasing = {
     type: 'linear';

package/dist/cjs/use-schema.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.computeEffectiveSchemaValuesDotNotation = exports.isKeyframedStatus = exports.getStaticDragOverrideValue = exports.makeKeyframedDragOverride = exports.makeStaticDragOverride = exports.DEFAULT_LINEAR_EASING = void 0;
 const find_props_to_delete_js_1 = require("./find-props-to-delete.js");
 const get_effective_visual_mode_value_js_1 = require("./get-effective-visual-mode-value.js");
+const input_props_serialization_js_1 = require("./input-props-serialization.js");
 const interpolate_keyframed_status_js_1 = require("./interpolate-keyframed-status.js");
 exports.DEFAULT_LINEAR_EASING = {
     type: 'linear',
@@ -132,6 +133,11 @@ const computeEffectiveSchemaValuesDotNotation = ({ schema, currentValue, overrid
                 shouldResortToDefaultValueIfUndefined: false,
             });
         }
+        if ((field === null || field === void 0 ? void 0 : field.type) === 'asset' &&
+            typeof value === 'string' &&
+            value.startsWith(input_props_serialization_js_1.FILE_TOKEN)) {
+            value = `${window.remotion_staticBase}/${value.slice(input_props_serialization_js_1.FILE_TOKEN.length)}`;
+        }
         if (value === undefined) {
             propsToDelete.add(key);
         }

package/dist/cjs/version.d.ts

@@ -3,4 +3,4 @@
  * @see [Documentation](https://remotion.dev/docs/version)
  * @returns {string} The current version of the remotion package
  */
-export declare const VERSION = "4.0.490";
+export declare const VERSION = "4.0.492";

package/dist/cjs/version.js

@@ -7,4 +7,4 @@ exports.VERSION = void 0;
  * @see [Documentation](https://remotion.dev/docs/version)
  * @returns {string} The current version of the remotion package
  */
-exports.VERSION = '4.0.490';
+exports.VERSION = '4.0.492';

package/dist/cjs/wrap-in-schema.d.ts

@@ -1,16 +1,16 @@
 import React from 'react';
 import type { SequenceControls } from './CompositionManager.js';
-import { type InteractivitySchema } from './interactivity-schema.js';
+import { type SequenceSchema } from './sequence-field-schema.js';
 export declare const getNestedValue: (obj: Record<string, unknown>, key: string) => unknown;
 export declare const readValuesFromProps: (props: Record<string, unknown>, keys: string[]) => Record<string, unknown>;
-export declare const selectActiveKeys: (schema: InteractivitySchema, values: Record<string, unknown>) => string[];
+export declare const selectActiveKeys: (schema: SequenceSchema, values: Record<string, unknown>) => string[];
 export declare const mergeValues: ({ props, valuesDotNotation, schemaKeys, propsToDelete, }: {
     props: Record<string, unknown>;
     valuesDotNotation: Record<string, unknown>;
     schemaKeys: string[];
     propsToDelete: Set<string>;
 }) => Record<string, unknown>;
-export declare const wrapInSchema: <S extends InteractivitySchema, Props extends object>({ Component, componentIdentity, schema, supportsEffects, }: {
+export declare const wrapInSchema: <S extends SequenceSchema, Props extends object>({ Component, componentIdentity, schema, supportsEffects, }: {
     Component: React.ComponentType<Props & {
         readonly _experimentalControls: SequenceControls | undefined;
     }>;

package/dist/cjs/wrap-in-schema.js

@@ -38,7 +38,7 @@ const react_1 = __importStar(require("react"));
 const delete_nested_key_js_1 = require("./delete-nested-key.js");
 const use_memoized_effects_js_1 = require("./effects/use-memoized-effects.js");
 const flatten_schema_js_1 = require("./flatten-schema.js");
-const interactivity_schema_js_1 = require("./interactivity-schema.js");
+const sequence_field_schema_js_1 = require("./sequence-field-schema.js");
 const sequence_node_path_js_1 = require("./sequence-node-path.js");
 const SequenceManager_js_1 = require("./SequenceManager.js");
 const use_current_frame_js_1 = require("./use-current-frame.js");
@@ -100,7 +100,7 @@ exports.mergeValues = mergeValues;
 const stackToOverrideMap = {};
 const wrapInSchema = ({ Component, componentIdentity, schema, supportsEffects, }) => {
     // Schema is static for a component, so we move this outside
-    const schemaWithSequenceName = (0, interactivity_schema_js_1.extendSchemaWithSequenceName)(schema);
+    const schemaWithSequenceName = (0, sequence_field_schema_js_1.extendSchemaWithSequenceName)(schema);
     const flatSchema = (0, flatten_schema_js_1.getFlatSchemaWithAllKeys)(schemaWithSequenceName);
     const flatKeys = Object.keys(flatSchema);
     const Wrapped = (0, react_1.forwardRef)((props, ref) => {