remotion 4.0.472 → 4.0.474

package/dist/cjs/CompositionManager.d.ts

@@ -71,7 +71,7 @@ export type TSequence = {
     premountDisplay: number | null;
     postmountDisplay: number | null;
     controls: SequenceControls | null;
-    refForOutline: React.RefObject<HTMLElement | null> | null;
+    refForOutline: React.RefObject<Element | null> | null;
     effects: readonly EffectDefinition<unknown>[];
     isInsideSeries: boolean;
 } & EnhancedTSequenceData;

package/dist/cjs/Img.d.ts

@@ -26,7 +26,6 @@ export declare const imgSchema: {
     };
     readonly 'style.scale': {
         readonly type: "scale";
-        readonly min: 0.05;
         readonly max: 100;
         readonly step: 0.01;
         readonly default: 1;

package/dist/cjs/Sequence.d.ts

@@ -65,9 +65,11 @@ export type SequencePropsWithoutDuration = {
     /**
      * @deprecated For internal use only.
      */
-    readonly _remotionInternalRefForOutline?: React.RefObject<HTMLElement | null> | null;
+    readonly _remotionInternalRefForOutline?: React.RefObject<Element | null> | null;
 } & LayoutAndStyle;
 export type SequenceProps = {
     readonly durationInFrames?: number;
 } & SequencePropsWithoutDuration;
+export declare const SequenceWithoutSchema: React.ForwardRefExoticComponent<SequenceProps & React.RefAttributes<HTMLDivElement>>;
 export declare const Sequence: React.ComponentType<SequenceProps & React.RefAttributes<HTMLDivElement>>;
+export declare const SequenceWithoutFrom: React.ComponentType<SequenceProps & React.RefAttributes<HTMLDivElement>>;

package/dist/cjs/Sequence.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sequence = void 0;
+exports.SequenceWithoutFrom = exports.Sequence = exports.SequenceWithoutSchema = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 /* eslint-disable @typescript-eslint/no-use-before-define */
 const react_1 = require("react");
@@ -316,6 +316,7 @@ const SequenceRefForwardingFunction = (props, ref) => {
     return jsx_runtime_1.jsx(RegularSequence, { ...props, ref: ref });
 };
 const SequenceInner = (0, react_1.forwardRef)(SequenceRefForwardingFunction);
+exports.SequenceWithoutSchema = SequenceInner;
 /*
  * @description A component that time-shifts its children and wraps them in an absolutely positioned <div>.
  * @see [Documentation](https://www.remotion.dev/docs/sequence)
@@ -325,3 +326,8 @@ exports.Sequence = (0, wrap_in_schema_js_1.wrapInSchema)({
     schema: sequence_field_schema_js_1.sequenceSchema,
     supportsEffects: false,
 });
+exports.SequenceWithoutFrom = (0, wrap_in_schema_js_1.wrapInSchema)({
+    Component: SequenceInner,
+    schema: sequence_field_schema_js_1.sequenceSchemaWithoutFrom,
+    supportsEffects: false,
+});

package/dist/cjs/SequenceManager.d.ts

@@ -1,15 +1,22 @@
 import React from 'react';
 import type { TSequence } from './CompositionManager.js';
-import type { CanUpdateSequencePropStatus, CodeValues, DragOverrideValue, GetDragOverrides, GetEffectDragOverrides } from './use-schema.js';
+import type { CanUpdateSequencePropStatus, DragOverrideValue, GetDragOverrides, GetEffectDragOverrides, PropStatuses } from './use-schema.js';
 export type SequenceManagerContext = {
     registerSequence: (seq: TSequence) => void;
     unregisterSequence: (id: string) => void;
     sequences: TSequence[];
 };
+export type SequenceManagerRef = {
+    current: TSequence[];
+};
 export type SequenceNodePath = Array<string | number>;
 export declare const SequenceManager: React.Context<SequenceManagerContext>;
-export type VisualModeCodeValues = {
-    codeValues: CodeValues;
+export declare const SequenceManagerRefContext: React.Context<SequenceManagerRef>;
+export type VisualModePropStatuses = {
+    propStatuses: PropStatuses;
+};
+export type VisualModePropStatusesRef = {
+    current: PropStatuses;
 };
 export type VisualModeDragOverrides = {
     getDragOverrides: GetDragOverrides;
@@ -20,7 +27,7 @@ export type VisualModeSetters = {
     clearDragOverrides: (nodePath: SequencePropsSubscriptionKey) => void;
     setEffectDragOverrides: (nodePath: SequencePropsSubscriptionKey, effectIndex: number, key: string, value: DragOverrideValue) => void;
     clearEffectDragOverrides: (nodePath: SequencePropsSubscriptionKey, effectIndex: number) => void;
-    setCodeValues: (nodePath: SequencePropsSubscriptionKey, values: (prev: CanUpdateSequencePropsResponse) => CanUpdateSequencePropsResponse) => void;
+    setPropStatuses: (nodePath: SequencePropsSubscriptionKey, values: (prev: CanUpdateSequencePropsResponse) => CanUpdateSequencePropsResponse) => void;
 };
 export type CanUpdateEffectPropsResponseTrue = {
     canUpdate: true;
@@ -48,7 +55,8 @@ export type CanUpdateSequencePropsResponseFalse = {
 };
 export type CanUpdateSequencePropsResponse = CanUpdateSequencePropsResponseTrue | CanUpdateSequencePropsResponseFalse;
 export declare const makeSequencePropsSubscriptionKey: (key: SequencePropsSubscriptionKey) => string;
-export declare const VisualModeCodeValuesContext: React.Context<VisualModeCodeValues>;
+export declare const VisualModePropStatusesContext: React.Context<VisualModePropStatuses>;
+export declare const VisualModePropStatusesRefContext: React.Context<VisualModePropStatusesRef>;
 export declare const VisualModeDragOverridesContext: React.Context<VisualModeDragOverrides>;
 export declare const VisualModeSettersContext: React.Context<VisualModeSetters>;
 export type SequencePropsSubscriptionKey = {

package/dist/cjs/SequenceManager.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SequenceManagerProvider = exports.VisualModeSettersContext = exports.VisualModeDragOverridesContext = exports.VisualModeCodeValuesContext = exports.makeSequencePropsSubscriptionKey = exports.SequenceManager = void 0;
+exports.SequenceManagerProvider = exports.VisualModeSettersContext = exports.VisualModeDragOverridesContext = exports.VisualModePropStatusesRefContext = exports.VisualModePropStatusesContext = exports.makeSequencePropsSubscriptionKey = exports.SequenceManagerRefContext = exports.SequenceManager = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = __importStar(require("react"));
 exports.SequenceManager = react_1.default.createContext({
@@ -45,12 +45,18 @@ exports.SequenceManager = react_1.default.createContext({
     },
     sequences: [],
 });
+exports.SequenceManagerRefContext = react_1.default.createContext({
+    current: [],
+});
 const makeSequencePropsSubscriptionKey = (key) => {
     return `${key.nodePath.join('.')}.${key.sequenceKeys.join('.')}.${key.effectKeys.map((keys) => keys.join('.')).join('.')}`;
 };
 exports.makeSequencePropsSubscriptionKey = makeSequencePropsSubscriptionKey;
-exports.VisualModeCodeValuesContext = react_1.default.createContext({
-    codeValues: {},
+exports.VisualModePropStatusesContext = react_1.default.createContext({
+    propStatuses: {},
+});
+exports.VisualModePropStatusesRefContext = react_1.default.createContext({
+    current: {},
 });
 exports.VisualModeDragOverridesContext = react_1.default.createContext({
     getDragOverrides: () => {
@@ -73,18 +79,22 @@ exports.VisualModeSettersContext = react_1.default.createContext({
     clearEffectDragOverrides: () => {
         throw new Error('VisualModeSettersContext not initialized');
     },
-    setCodeValues: () => {
+    setPropStatuses: () => {
         throw new Error('VisualModeSettersContext not initialized');
     },
 });
 const effectDragOverridesKey = (nodePath, effectIndex) => `${(0, exports.makeSequencePropsSubscriptionKey)(nodePath)}.effects.${effectIndex}`;
 const SequenceManagerProvider = ({ children }) => {
     const [sequences, setSequences] = (0, react_1.useState)([]);
+    const sequencesRef = (0, react_1.useRef)(sequences);
+    sequencesRef.current = sequences;
     const [dragOverrides, setControlOverrides] = (0, react_1.useState)({});
     const controlOverridesRef = (0, react_1.useRef)(dragOverrides);
     controlOverridesRef.current = dragOverrides;
     const [effectDragOverridesState, setEffectDragOverridesState] = (0, react_1.useState)({});
-    const [codeValues, setCodeValuesMapState] = (0, react_1.useState)({});
+    const [propStatuses, setPropStatusesMapState] = (0, react_1.useState)({});
+    const propStatusesRef = (0, react_1.useRef)(propStatuses);
+    propStatusesRef.current = propStatuses;
     const setDragOverrides = (0, react_1.useCallback)((nodePath, key, value) => {
         setControlOverrides((prev) => ({
             ...prev,
@@ -128,8 +138,8 @@ const SequenceManagerProvider = ({ children }) => {
             return next;
         });
     }, []);
-    const setCodeValues = (0, react_1.useCallback)((nodePath, values) => {
-        setCodeValuesMapState((prev) => {
+    const setPropStatuses = (0, react_1.useCallback)((nodePath, values) => {
+        setPropStatusesMapState((prev) => {
             const key = (0, exports.makeSequencePropsSubscriptionKey)(nodePath);
             const prevKey = prev[key];
             const newKey = values(prevKey);
@@ -162,11 +172,11 @@ const SequenceManagerProvider = ({ children }) => {
         var _a;
         return ((_a = effectDragOverridesState[effectDragOverridesKey(nodePath, effectIndex)]) !== null && _a !== void 0 ? _a : {});
     }, [effectDragOverridesState]);
-    const codeValuesContext = (0, react_1.useMemo)(() => {
+    const propStatusesContext = (0, react_1.useMemo)(() => {
         return {
-            codeValues,
+            propStatuses,
         };
-    }, [codeValues]);
+    }, [propStatuses]);
     const dragOverridesContext = (0, react_1.useMemo)(() => {
         return {
             getDragOverrides,
@@ -179,15 +189,15 @@ const SequenceManagerProvider = ({ children }) => {
             clearDragOverrides,
             setEffectDragOverrides,
             clearEffectDragOverrides,
-            setCodeValues,
+            setPropStatuses,
         };
     }, [
         setDragOverrides,
         clearDragOverrides,
         setEffectDragOverrides,
         clearEffectDragOverrides,
-        setCodeValues,
+        setPropStatuses,
     ]);
-    return (jsx_runtime_1.jsx(exports.SequenceManager.Provider, { value: sequenceContext, children: jsx_runtime_1.jsx(exports.VisualModeCodeValuesContext.Provider, { value: codeValuesContext, children: jsx_runtime_1.jsx(exports.VisualModeDragOverridesContext.Provider, { value: dragOverridesContext, children: jsx_runtime_1.jsx(exports.VisualModeSettersContext.Provider, { value: settersContext, children: children }) }) }) }));
+    return (jsx_runtime_1.jsx(exports.SequenceManagerRefContext.Provider, { value: sequencesRef, children: jsx_runtime_1.jsx(exports.SequenceManager.Provider, { value: sequenceContext, children: jsx_runtime_1.jsx(exports.VisualModePropStatusesRefContext.Provider, { value: propStatusesRef, children: jsx_runtime_1.jsx(exports.VisualModePropStatusesContext.Provider, { value: propStatusesContext, children: jsx_runtime_1.jsx(exports.VisualModeDragOverridesContext.Provider, { value: dragOverridesContext, children: jsx_runtime_1.jsx(exports.VisualModeSettersContext.Provider, { value: settersContext, children: children }) }) }) }) }) }));
 };
 exports.SequenceManagerProvider = SequenceManagerProvider;

package/dist/cjs/calculate-media-duration.js

@@ -12,6 +12,6 @@ const calculateMediaDuration = ({ trimAfter, mediaDurationInFrames, playbackRate
         duration -= trimBefore;
     }
     const actualDuration = duration / playbackRate;
-    return Math.floor(actualDuration);
+    return Number(actualDuration.toFixed(10));
 };
 exports.calculateMediaDuration = calculateMediaDuration;

package/dist/cjs/canvas-image/CanvasImage.d.ts

@@ -10,7 +10,6 @@ export declare const canvasImageSchema: {
     };
     readonly 'style.scale': {
         readonly type: "scale";
-        readonly min: 0.05;
         readonly max: 100;
         readonly step: 0.01;
         readonly default: 1;

package/dist/cjs/effects/use-memoized-effects.d.ts

@@ -1,6 +1,6 @@
 import type { CannotUpdateEffectReason, CannotUpdateSequenceReason } from '../SequenceManager.js';
 import { type SequencePropsSubscriptionKey } from '../SequenceManager.js';
-import { type CanUpdateSequencePropStatus, type CodeValues } from '../use-schema.js';
+import { type CanUpdateSequencePropStatus, type PropStatuses } from '../use-schema.js';
 import type { EffectDefinition, EffectDefinitionAndStack, EffectDescriptor } from './effect-types.js';
 export declare const useMemoizedEffectDefinitions: (effects: readonly EffectDescriptor<unknown>[]) => readonly EffectDefinition<unknown>[];
 type EffectStatus = {
@@ -13,13 +13,13 @@ type EffectStatus = {
     type: 'can-update-effect';
     props: Record<string, CanUpdateSequencePropStatus>;
 };
-export declare const getEffectCodeValuesCtx: ({ codeValues, nodePath, effectIndex, }: {
-    codeValues: CodeValues;
+export declare const getEffectPropStatusesCtx: ({ propStatuses, nodePath, effectIndex, }: {
+    propStatuses: PropStatuses;
     nodePath: SequencePropsSubscriptionKey;
     effectIndex: number;
 }) => EffectStatus;
-export declare const getCodeValuesCtx: (codeValues: CodeValues, nodePath: SequencePropsSubscriptionKey) => Record<string, CanUpdateSequencePropStatus> | undefined;
-export type GetCodeValuesType = typeof getCodeValuesCtx;
+export declare const getPropStatusesCtx: (propStatuses: PropStatuses, nodePath: SequencePropsSubscriptionKey) => Record<string, CanUpdateSequencePropStatus> | undefined;
+export type GetPropStatusesType = typeof getPropStatusesCtx;
 export declare const useMemoizedEffects: ({ effects, overrideId, }: {
     effects: readonly EffectDescriptor<unknown>[];
     readonly overrideId: string | null;

package/dist/cjs/effects/use-memoized-effects.js

@@ -1,21 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useMemoizedEffects = exports.getCodeValuesCtx = exports.getEffectCodeValuesCtx = exports.useMemoizedEffectDefinitions = void 0;
+exports.useMemoizedEffects = exports.getPropStatusesCtx = exports.getEffectPropStatusesCtx = exports.useMemoizedEffectDefinitions = void 0;
 const react_1 = require("react");
 const get_effective_visual_mode_value_js_1 = require("../get-effective-visual-mode-value.js");
+const interpolate_keyframed_status_js_1 = require("../interpolate-keyframed-status.js");
 const sequence_node_path_js_1 = require("../sequence-node-path.js");
 const SequenceManager_js_1 = require("../SequenceManager.js");
-const SequenceManager_js_2 = require("../SequenceManager.js");
 const use_current_frame_js_1 = require("../use-current-frame.js");
-const mergeOverrides = ({ descriptor, codeOverrides, dragOverrides, frame, }) => {
-    if (!codeOverrides && !dragOverrides) {
+const mergeOverrides = ({ descriptor, propStatusOverrides, dragOverrides, frame, }) => {
+    if (!propStatusOverrides && !dragOverrides) {
         return { params: descriptor.params, effectKey: descriptor.effectKey };
     }
     const merged = {
         ...descriptor.params,
     };
-    if (codeOverrides) {
-        for (const [key, value] of Object.entries(codeOverrides)) {
+    if (propStatusOverrides) {
+        for (const [key, value] of Object.entries(propStatusOverrides)) {
             if (value !== undefined) {
                 merged[key] = value;
             }
@@ -37,16 +37,27 @@ const mergeOverrides = ({ descriptor, codeOverrides, dragOverrides, frame, }) =>
         effectKey: descriptor.definition.calculateKey(merged),
     };
 };
-const extractCodeOverrides = (propStatus) => {
+const resolvePropStatusOverrides = (propStatus, frame) => {
     if (!propStatus) {
         return null;
     }
     const out = {};
     let hasAny = false;
     for (const [key, status] of Object.entries(propStatus)) {
-        if (status.status !== 'computed') {
+        if (status.status === 'static') {
             out[key] = status.codeValue;
             hasAny = true;
+            continue;
+        }
+        if (status.status === 'keyframed') {
+            const value = (0, interpolate_keyframed_status_js_1.interpolateKeyframedStatus)({
+                frame,
+                status,
+            });
+            if (value !== null) {
+                out[key] = value;
+                hasAny = true;
+            }
         }
     }
     return hasAny ? out : null;
@@ -65,8 +76,8 @@ const useMemoizedEffectDefinitions = (effects) => {
     return definitions;
 };
 exports.useMemoizedEffectDefinitions = useMemoizedEffectDefinitions;
-const getEffectCodeValuesCtx = ({ codeValues, nodePath, effectIndex, }) => {
-    const status = codeValues[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)];
+const getEffectPropStatusesCtx = ({ propStatuses, nodePath, effectIndex, }) => {
+    const status = propStatuses[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)];
     if (!status) {
         return { type: 'cannot-update-sequence', reason: 'not-found' };
     }
@@ -82,9 +93,9 @@ const getEffectCodeValuesCtx = ({ codeValues, nodePath, effectIndex, }) => {
     }
     return { type: 'can-update-effect', props: effect.props };
 };
-exports.getEffectCodeValuesCtx = getEffectCodeValuesCtx;
-const getCodeValuesCtx = (codeValues, nodePath) => {
-    const status = codeValues[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)];
+exports.getEffectPropStatusesCtx = getEffectPropStatusesCtx;
+const getPropStatusesCtx = (propStatuses, nodePath) => {
+    const status = propStatuses[(0, SequenceManager_js_1.makeSequencePropsSubscriptionKey)(nodePath)];
     if (!status) {
         return undefined;
     }
@@ -93,12 +104,12 @@ const getCodeValuesCtx = (codeValues, nodePath) => {
     }
     return status.props;
 };
-exports.getCodeValuesCtx = getCodeValuesCtx;
+exports.getPropStatusesCtx = getPropStatusesCtx;
 const useMemoizedEffects = ({ effects, overrideId, }) => {
     var _a;
     const previousRef = (0, react_1.useRef)(null);
-    const { codeValues } = (0, react_1.useContext)(SequenceManager_js_2.VisualModeCodeValuesContext);
-    const { getEffectDragOverrides } = (0, react_1.useContext)(SequenceManager_js_2.VisualModeDragOverridesContext);
+    const { propStatuses } = (0, react_1.useContext)(SequenceManager_js_1.VisualModePropStatusesContext);
+    const { getEffectDragOverrides } = (0, react_1.useContext)(SequenceManager_js_1.VisualModeDragOverridesContext);
     const frame = (0, use_current_frame_js_1.useCurrentFrame)();
     const { overrideIdToNodePathMappings } = (0, react_1.useContext)(sequence_node_path_js_1.OverrideIdsToNodePathsGettersContext);
     const previous = previousRef.current;
@@ -113,19 +124,19 @@ const useMemoizedEffects = ({ effects, overrideId, }) => {
                 effectKey: descriptor.effectKey,
             };
         }
-        const effectStatus = (0, exports.getEffectCodeValuesCtx)({
-            codeValues,
+        const effectStatus = (0, exports.getEffectPropStatusesCtx)({
+            propStatuses,
             nodePath,
             effectIndex: index,
         });
-        const codeOverrides = effectStatus.type === 'can-update-effect'
-            ? extractCodeOverrides(effectStatus.props)
+        const propStatusOverrides = effectStatus.type === 'can-update-effect'
+            ? resolvePropStatusOverrides(effectStatus.props, frame)
             : null;
         const dragOverridesMap = getEffectDragOverrides(nodePath, index);
         const dragOverrides = Object.keys(dragOverridesMap).length === 0 ? null : dragOverridesMap;
         const { params, effectKey } = mergeOverrides({
             descriptor,
-            codeOverrides,
+            propStatusOverrides,
             dragOverrides,
             frame,
         });

package/dist/cjs/get-effective-visual-mode-value.d.ts

@@ -9,8 +9,8 @@ export declare const resolveDragOverrideValue: ({ dragOverrideValue, frame, }: {
     dragOverrideValue: DragOverrideValue | undefined;
     frame: number | null;
 }) => ResolvedDragOverrideValue;
-export declare const getEffectiveVisualModeValue: ({ codeValue, dragOverrideValue, defaultValue, frame, shouldResortToDefaultValueIfUndefined, }: {
-    codeValue: CanUpdateSequencePropStatusKeyframed | CanUpdateSequencePropStatusStatic;
+export declare const getEffectiveVisualModeValue: ({ propStatus, dragOverrideValue, defaultValue, frame, shouldResortToDefaultValueIfUndefined, }: {
+    propStatus: CanUpdateSequencePropStatusKeyframed | CanUpdateSequencePropStatusStatic;
     dragOverrideValue: DragOverrideValue | undefined;
     defaultValue: unknown;
     frame?: number | null | undefined;

package/dist/cjs/get-effective-visual-mode-value.js

@@ -22,7 +22,7 @@ const resolveDragOverrideValue = ({ dragOverrideValue, frame, }) => {
     return { type: 'resolved', value: interpolated };
 };
 exports.resolveDragOverrideValue = resolveDragOverrideValue;
-const getEffectiveVisualModeValue = ({ codeValue, dragOverrideValue, defaultValue, frame = null, shouldResortToDefaultValueIfUndefined = false, }) => {
+const getEffectiveVisualModeValue = ({ propStatus, dragOverrideValue, defaultValue, frame = null, shouldResortToDefaultValueIfUndefined = false, }) => {
     const dragOverride = (0, exports.resolveDragOverrideValue)({
         dragOverrideValue,
         frame,
@@ -30,16 +30,19 @@ const getEffectiveVisualModeValue = ({ codeValue, dragOverrideValue, defaultValu
     if (dragOverride.type === 'resolved' && dragOverride.value !== undefined) {
         return dragOverride.value;
     }
-    if (codeValue.status === 'keyframed' && frame !== null) {
-        return (0, interpolate_keyframed_status_1.interpolateKeyframedStatus)({
-            frame,
-            status: codeValue,
-        });
+    if (propStatus.status === 'keyframed') {
+        if (frame !== null) {
+            return (0, interpolate_keyframed_status_1.interpolateKeyframedStatus)({
+                frame,
+                status: propStatus,
+            });
+        }
+        return shouldResortToDefaultValueIfUndefined ? defaultValue : undefined;
     }
-    if (codeValue.codeValue === undefined &&
+    if (propStatus.codeValue === undefined &&
         shouldResortToDefaultValueIfUndefined) {
         return defaultValue;
     }
-    return codeValue.codeValue;
+    return propStatus.codeValue;
 };
 exports.getEffectiveVisualModeValue = getEffectiveVisualModeValue;

package/dist/cjs/internals.d.ts

@@ -18,8 +18,8 @@ import { type CanUpdateEffectPropsResponse, type CanUpdateEffectPropsResponseFal
 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, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, DragOverrideValue, GetCodeValues, GetDragOverrides, GetEffectCodeValues, GetEffectDragOverrides } from './use-schema.js';
-import { type CanUpdateSequencePropStatus, type CodeValues, type DragOverrides, type EffectDragOverrides } from './use-schema.js';
+import type { CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, DragOverrideValue, GetDragOverrides, GetEffectDragOverrides, GetEffectPropStatuses, GetPropStatuses } 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';
 import { useRemotionContexts } from './wrap-remotion-context.js';
@@ -70,10 +70,12 @@ export declare const Internals: {
     }, "ref"> & import("react").RefAttributes<HTMLVideoElement>>;
     readonly CompositionManager: import("react").Context<CompositionManagerContext>;
     readonly CompositionSetters: import("react").Context<import("./CompositionManagerContext.js").CompositionManagerSetters>;
-    readonly VisualModeCodeValuesContext: import("react").Context<import("./SequenceManager.js").VisualModeCodeValues>;
+    readonly VisualModePropStatusesContext: import("react").Context<import("./SequenceManager.js").VisualModePropStatuses>;
+    readonly VisualModePropStatusesRefContext: import("react").Context<import("./SequenceManager.js").VisualModePropStatusesRef>;
     readonly VisualModeDragOverridesContext: import("react").Context<import("./SequenceManager.js").VisualModeDragOverrides>;
     readonly VisualModeSettersContext: import("react").Context<import("./SequenceManager.js").VisualModeSetters>;
     readonly SequenceManager: import("react").Context<import("./SequenceManager.js").SequenceManagerContext>;
+    readonly SequenceManagerRefContext: import("react").Context<import("./SequenceManager.js").SequenceManagerRef>;
     readonly SequenceStackTracesUpdateContext: import("react").Context<import("./sequence-stack-traces.js").UpdateResolvedStackTraceFn>;
     readonly wrapInSchema: <S extends SequenceSchema, Props extends object>({ Component, schema, supportsEffects, }: {
         Component: import("react").ComponentType<Props & {
@@ -111,7 +113,6 @@ export declare const Internals: {
                     };
                     readonly 'style.scale': {
                         readonly type: "scale";
-                        readonly min: 0.05;
                         readonly max: 100;
                         readonly step: 0.01;
                         readonly default: 1;
@@ -158,6 +159,7 @@ export declare const Internals: {
             };
         };
     };
+    readonly SequenceWithoutSchema: import("react").ForwardRefExoticComponent<import("./Sequence.js").SequenceProps & import("react").RefAttributes<HTMLDivElement>>;
     readonly sequenceStyleSchema: {
         readonly 'style.translate': {
             readonly type: "translate";
@@ -167,7 +169,6 @@ export declare const Internals: {
         };
         readonly 'style.scale': {
             readonly type: "scale";
-            readonly min: 0.05;
             readonly max: 100;
             readonly step: 0.01;
             readonly default: 1;
@@ -219,7 +220,6 @@ export declare const Internals: {
         };
         readonly 'style.scale': {
             readonly type: "scale";
-            readonly min: 0.05;
             readonly max: 100;
             readonly step: 0.01;
             readonly default: 1;
@@ -303,7 +303,7 @@ export declare const Internals: {
         postmountDisplay: number | null;
         loopDisplay: import("./CompositionManager.js").LoopDisplay | undefined;
         documentationLink: string | null;
-        refForOutline: import("react").RefObject<HTMLElement | null> | null;
+        refForOutline: import("react").RefObject<Element | null> | null;
     }) => void;
     readonly useLazyComponent: <Props>({ compProps, componentName, noSuspense, }: {
         compProps: CompProps<Props>;
@@ -640,8 +640,8 @@ export declare const Internals: {
         children: import("react").ReactNode;
         collectAssets: import("react").RefObject<import("./RenderAssetManager.js").CollectAssetsRef | null> | null;
     }>;
-    readonly getEffectiveVisualModeValue: ({ codeValue, dragOverrideValue, defaultValue, frame, shouldResortToDefaultValueIfUndefined, }: {
-        codeValue: CanUpdateSequencePropStatusKeyframed | CanUpdateSequencePropStatusStatic;
+    readonly getEffectiveVisualModeValue: ({ propStatus, dragOverrideValue, defaultValue, frame, shouldResortToDefaultValueIfUndefined, }: {
+        propStatus: CanUpdateSequencePropStatusKeyframed | CanUpdateSequencePropStatusStatic;
         dragOverrideValue: DragOverrideValue | undefined;
         defaultValue: unknown;
         frame?: number | null | undefined;
@@ -675,7 +675,7 @@ export declare const Internals: {
     readonly interpolateKeyframedStatus: ({ frame, status, }: {
         frame: number;
         status: CanUpdateSequencePropStatusKeyframed;
-    }) => string | number | null;
+    }) => string | number | readonly number[] | null;
     readonly makeStaticDragOverride: (value: unknown) => DragOverrideValue;
     readonly makeKeyframedDragOverride: ({ status, frame, value, }: {
         status: CanUpdateSequencePropStatusKeyframed;
@@ -695,9 +695,9 @@ export declare const Internals: {
         value: unknown;
     }) => string[];
     readonly makeSequencePropsSubscriptionKey: (key: SequencePropsSubscriptionKey) => string;
-    readonly getCodeValuesCtx: (codeValues: CodeValues, nodePath: SequencePropsSubscriptionKey) => Record<string, CanUpdateSequencePropStatus> | undefined;
-    readonly getEffectCodeValuesCtx: ({ codeValues, nodePath, effectIndex, }: {
-        codeValues: CodeValues;
+    readonly getPropStatusesCtx: (propStatuses: PropStatuses, nodePath: SequencePropsSubscriptionKey) => Record<string, CanUpdateSequencePropStatus> | undefined;
+    readonly getEffectPropStatusesCtx: ({ propStatuses, nodePath, effectIndex, }: {
+        propStatuses: PropStatuses;
         nodePath: SequencePropsSubscriptionKey;
         effectIndex: number;
     }) => {
@@ -725,4 +725,4 @@ export declare const Internals: {
         readonly hiddenFromList: true;
     };
 };
-export type { ArrayFieldSchema, ArrayItemFieldSchema, CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateEffectPropsResponseFalse, CanUpdateEffectPropsResponseTrue, CanUpdateSequencePropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, CodeValues, CompositionManagerContext, CompProps, DragOverrides, DragOverrideValue, EffectDragOverrides, GetCodeValues, GetDragOverrides, GetEffectCodeValues, GetEffectDragOverrides, LoggingContextValue, MediaVolumeContextValue, NonceHistory, OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext, OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSetters, PlaybackRateContextValue, RemotionAudioContextState, RemotionEnvironment, ResolvedStackLocation, ScheduleAudioNodeOptions, ScheduleAudioNodeResult, SequenceFieldSchema, SequenceNodePath, SequencePropsSubscriptionKey, SequenceSchema, SerializedJSONWithCustomFields, SetMediaVolumeContextValue, SetTimelineContextValue, TCompMetadata, TComposition, TimelineContextValue, TRenderAsset, TSequence, VisibleFieldSchema, WatchRemotionStaticFilesPayload, };
+export type { ArrayFieldSchema, ArrayItemFieldSchema, CannotUpdateSequenceReason, CanUpdateEffectPropsResponse, CanUpdateEffectPropsResponseFalse, CanUpdateEffectPropsResponseTrue, CanUpdateSequencePropsResponse, CanUpdateSequencePropsResponseFalse, CanUpdateSequencePropsResponseTrue, CanUpdateSequencePropStatus, CanUpdateSequencePropStatusFalse, CanUpdateSequencePropStatusKeyframed, CanUpdateSequencePropStatusStatic, CompositionManagerContext, CompProps, DragOverrides, DragOverrideValue, EffectDragOverrides, GetDragOverrides, GetEffectDragOverrides, GetEffectPropStatuses, GetPropStatuses, LoggingContextValue, MediaVolumeContextValue, NonceHistory, OverrideIdsToNodePathsGettersContext, OverrideIdsToNodePathsSettersContext, OverrideIdToNodePaths, OverrideToNodePathGetters, OverrideToNodeSetters, PlaybackRateContextValue, PropStatuses, RemotionAudioContextState, RemotionEnvironment, ResolvedStackLocation, ScheduleAudioNodeOptions, ScheduleAudioNodeResult, SequenceFieldSchema, SequenceNodePath, SequencePropsSubscriptionKey, SequenceSchema, SerializedJSONWithCustomFields, SetMediaVolumeContextValue, SetTimelineContextValue, TCompMetadata, TComposition, TimelineContextValue, TRenderAsset, TSequence, VisibleFieldSchema, WatchRemotionStaticFilesPayload, };

package/dist/cjs/internals.js

@@ -82,6 +82,7 @@ const ResolveCompositionConfig_js_1 = require("./ResolveCompositionConfig.js");
 const sequence_field_schema_js_1 = require("./sequence-field-schema.js");
 const sequence_node_path_js_1 = require("./sequence-node-path.js");
 const sequence_stack_traces_js_1 = require("./sequence-stack-traces.js");
+const Sequence_js_1 = require("./Sequence.js");
 const SequenceContext_js_1 = require("./SequenceContext.js");
 const SequenceManager_js_1 = require("./SequenceManager.js");
 const setup_env_variables_js_1 = require("./setup-env-variables.js");
@@ -133,13 +134,16 @@ exports.Internals = {
     VideoForPreview: VideoForPreview_js_1.VideoForPreview,
     CompositionManager: CompositionManagerContext_js_1.CompositionManager,
     CompositionSetters: CompositionManagerContext_js_1.CompositionSetters,
-    VisualModeCodeValuesContext: SequenceManager_js_1.VisualModeCodeValuesContext,
+    VisualModePropStatusesContext: SequenceManager_js_1.VisualModePropStatusesContext,
+    VisualModePropStatusesRefContext: SequenceManager_js_1.VisualModePropStatusesRefContext,
     VisualModeDragOverridesContext: SequenceManager_js_1.VisualModeDragOverridesContext,
     VisualModeSettersContext: SequenceManager_js_1.VisualModeSettersContext,
     SequenceManager: SequenceManager_js_1.SequenceManager,
+    SequenceManagerRefContext: SequenceManager_js_1.SequenceManagerRefContext,
     SequenceStackTracesUpdateContext: sequence_stack_traces_js_1.SequenceStackTracesUpdateContext,
     wrapInSchema: wrap_in_schema_js_1.wrapInSchema,
     sequenceSchema: sequence_field_schema_js_1.sequenceSchema,
+    SequenceWithoutSchema: Sequence_js_1.SequenceWithoutSchema,
     sequenceStyleSchema: sequence_field_schema_js_1.sequenceStyleSchema,
     sequenceVisualStyleSchema: sequence_field_schema_js_1.sequenceVisualStyleSchema,
     sequencePremountSchema: sequence_field_schema_js_1.sequencePremountSchema,
@@ -254,8 +258,8 @@ exports.Internals = {
     OverrideIdsToNodePathsSettersContext: sequence_node_path_js_1.OverrideIdsToNodePathsSettersContext,
     findPropsToDelete: find_props_to_delete_js_1.findPropsToDelete,
     makeSequencePropsSubscriptionKey: SequenceManager_js_1.makeSequencePropsSubscriptionKey,
-    getCodeValuesCtx: use_memoized_effects_js_1.getCodeValuesCtx,
-    getEffectCodeValuesCtx: use_memoized_effects_js_1.getEffectCodeValuesCtx,
+    getPropStatusesCtx: use_memoized_effects_js_1.getPropStatusesCtx,
+    getEffectPropStatusesCtx: use_memoized_effects_js_1.getEffectPropStatusesCtx,
     hiddenField: sequence_field_schema_js_1.hiddenField,
     durationInFramesField: sequence_field_schema_js_1.durationInFramesField,
     fromField: sequence_field_schema_js_1.fromField,

package/dist/cjs/interpolate-keyframed-status.d.ts

@@ -1,5 +1,7 @@
 import type { CanUpdateSequencePropStatusKeyframed } from './use-schema.js';
+type InterpolateKeyframedStatusResult = number | string | readonly number[] | null;
 export declare const interpolateKeyframedStatus: ({ frame, status, }: {
     frame: number;
     status: CanUpdateSequencePropStatusKeyframed;
-}) => string | number | null;
+}) => InterpolateKeyframedStatusResult;
+export {};

package/dist/cjs/interpolate-keyframed-status.js

@@ -16,8 +16,9 @@ const interpolateKeyframedStatus = ({ frame, status, }) => {
     if (keyframes.length === 0) {
         return null;
     }
-    const inputRange = keyframes.map((k) => k.frame);
-    const outputs = keyframes.map((k) => k.value);
+    const sortedKeyframes = [...keyframes].sort((a, b) => a.frame - b.frame);
+    const inputRange = sortedKeyframes.map((k) => k.frame);
+    const outputs = sortedKeyframes.map((k) => k.value);
     if (interpolationFunction === 'interpolateColors') {
         if (!outputs.every((v) => typeof v === 'string')) {
             return null;

package/dist/cjs/interpolate.d.ts

@@ -10,8 +10,15 @@ export type InterpolateOptions = Partial<{
     extrapolateRight: ExtrapolateType;
     posterize: number;
 }>;
+type NumericTuple = readonly [number, ...number[]];
+type WidenNumericTuple<T extends readonly number[]> = {
+    readonly [Key in keyof T]: number;
+};
 export declare function assertValidInterpolateEasingOption(easing: EasingFunction | readonly EasingFunction[] | undefined, inputRangeLength: number): void;
 export declare function assertValidInterpolatePosterizeOption(posterize: number | undefined): void;
 export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly number[], options?: InterpolateOptions): number;
 export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly string[], options?: InterpolateOptions): string;
-export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly (number | string)[], options?: InterpolateOptions): number | string;
+export declare function interpolate<const Tuple extends NumericTuple>(input: number, inputRange: readonly number[], outputRange: readonly Tuple[], options?: InterpolateOptions): WidenNumericTuple<Tuple>;
+export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly (readonly number[])[], options?: InterpolateOptions): number[];
+export declare function interpolate(input: number, inputRange: readonly number[], outputRange: readonly (number | string | readonly number[])[], options?: InterpolateOptions): number | string | readonly number[];
+export {};