remotion 4.0.535 → 4.0.537

package/dist/cjs/effects/run-effect-chain.js

@@ -6,6 +6,8 @@ const effect_internals_js_1 = require("./effect-internals.js");
 const gpu_device_js_1 = require("./gpu-device.js");
 const createEffectChainState = (width, height) => {
     const state = {
+        width,
+        height,
         pool: new canvas_pool_js_1.CanvasPool(width, height, (canvas) => {
             var _a;
             // The GL objects these setups hold died with the context and stay
@@ -62,9 +64,8 @@ const ensureSetup = (state, def, target) => {
 // Runs the effect pipeline imperatively. Returns `true` if the pipeline
 // completed and wrote to `output`, `false` if it was superseded by a newer
 // run (caller should not act on a stale result).
-const runEffectChain = async ({ state, source, effects, output, width, height, }) => {
+const runEffectChainWithoutResize = async ({ state, source, effects, output, width, height }, initialFlipSourceY, runId) => {
     var _a;
-    const runId = ++state.currentRunId;
     const isCancelled = () => state.currentRunId !== runId;
     // Bypass any effect with `disabled: true` before grouping by backend, so
     // disabled effects don't create empty runs or force unnecessary backend
@@ -102,66 +103,77 @@ const runEffectChain = async ({ state, source, effects, output, width, height, }
     // Canvas sources are DOM-oriented. Flip them when uploading into WebGL so
     // texture coordinates match clip-space output. `ImageBitmap` bridges below
     // opt out because they are already oriented for upload.
-    let flipWebGLSourceY = true;
-    for (let runIndex = 0; runIndex < runs.length; runIndex++) {
-        const run = runs[runIndex];
-        let canvasIndex = 0;
-        for (const eff of run.effects) {
-            const dst = state.pool.getCanvas(run.backend, canvasIndex);
-            const def = eff.definition;
-            if (run.backend === 'webgl2') {
-                // Checked before `setup()`: a lost context cannot compile shaders,
-                // and this surfaces the dedicated error instead of an effect's own.
-                state.pool.assertContextNotLost(dst);
-            }
-            const setupState = ensureSetup(state, def, dst);
-            def.apply({
-                source: currentImage,
-                target: dst,
-                state: setupState,
-                params: eff.params,
-                width,
-                height,
-                gpuDevice,
-                flipSourceY: run.backend === 'webgl2' ? flipWebGLSourceY : false,
-            });
-            if (run.backend === 'webgl2') {
-                // Same-backend ping-pong passes feed the previous WebGL canvas back
-                // through `texImage2D()`. That source is still a DOM canvas, so the
-                // next upload also needs to be flipped.
-                flipWebGLSourceY = true;
-            }
-            currentImage = dst;
-            canvasIndex = canvasIndex === 0 ? 1 : 0;
-        }
-        lastTarget = (_a = currentImage) !== null && _a !== void 0 ? _a : lastTarget;
-        const nextRun = runs[runIndex + 1];
-        if (nextRun && nextRun.backend !== run.backend && lastTarget) {
-            // 2D → WebGL: pass the 2D canvas directly so `texImage2D` + `UNPACK_FLIP_Y`
-            // matches blur-only on a raw frame canvas. `createImageBitmap` here changes
-            // upload orientation and produced upside-down stacks (wave + blur).
-            if (run.backend === '2d' && nextRun.backend === 'webgl2') {
-                currentImage = lastTarget;
-                flipWebGLSourceY = true;
+    let flipWebGLSourceY = initialFlipSourceY;
+    // Only bridge bitmaps are owned here; the original source belongs to the caller.
+    let bridgeBitmap = null;
+    try {
+        for (let runIndex = 0; runIndex < runs.length; runIndex++) {
+            const run = runs[runIndex];
+            let canvasIndex = 0;
+            for (const eff of run.effects) {
+                const dst = state.pool.getCanvas(run.backend, canvasIndex);
+                const def = eff.definition;
+                if (run.backend === 'webgl2') {
+                    // Checked before `setup()`: a lost context cannot compile shaders,
+                    // and this surfaces the dedicated error instead of an effect's own.
+                    state.pool.assertContextNotLost(dst);
+                }
+                const setupState = ensureSetup(state, def, dst);
+                def.apply({
+                    source: currentImage,
+                    target: dst,
+                    state: setupState,
+                    params: eff.params,
+                    width: state.width,
+                    height: state.height,
+                    gpuDevice,
+                    flipSourceY: run.backend === 'webgl2' ? flipWebGLSourceY : false,
+                });
+                // Effects consume their source synchronously. Release it before the
+                // next bridge so a run never retains multiple temporary bitmaps.
+                bridgeBitmap === null || bridgeBitmap === void 0 ? void 0 : bridgeBitmap.close();
+                bridgeBitmap = null;
+                if (run.backend === 'webgl2') {
+                    // Same-backend ping-pong passes feed the previous WebGL canvas back
+                    // through `texImage2D()`. That source is still a DOM canvas, so the
+                    // next upload also needs to be flipped.
+                    flipWebGLSourceY = true;
+                }
+                currentImage = dst;
+                canvasIndex = canvasIndex === 0 ? 1 : 0;
             }
-            else {
-                // Other bridges use `createImageBitmap` rather than passing the canvas
-                // straight through. A direct `drawImage(webglCanvas)` in the next
-                // backend's first effect forces an implicit GPU readback / finish on the
-                // consuming context, which empirically blows the per-frame vsync budget and
-                // halves the paint rate. `createImageBitmap` pipelines the GPU work.
-                const bitmap = await createImageBitmap(lastTarget);
-                if (isCancelled()) {
-                    bitmap.close();
-                    return false;
+            lastTarget = (_a = currentImage) !== null && _a !== void 0 ? _a : lastTarget;
+            const nextRun = runs[runIndex + 1];
+            if (nextRun && nextRun.backend !== run.backend && lastTarget) {
+                // 2D → WebGL: pass the 2D canvas directly so `texImage2D` + `UNPACK_FLIP_Y`
+                // matches blur-only on a raw frame canvas. `createImageBitmap` here changes
+                // upload orientation and produced upside-down stacks (wave + blur).
+                if (run.backend === '2d' && nextRun.backend === 'webgl2') {
+                    currentImage = lastTarget;
+                    flipWebGLSourceY = true;
                 }
-                currentImage = bitmap;
-                if (nextRun.backend === 'webgl2') {
-                    flipWebGLSourceY = false;
+                else {
+                    // Other bridges use `createImageBitmap` rather than passing the canvas
+                    // straight through. A direct `drawImage(webglCanvas)` in the next
+                    // backend's first effect forces an implicit GPU readback / finish on the
+                    // consuming context, which empirically blows the per-frame vsync budget and
+                    // halves the paint rate. `createImageBitmap` pipelines the GPU work.
+                    bridgeBitmap = await createImageBitmap(lastTarget);
+                    if (isCancelled()) {
+                        return false;
+                    }
+                    currentImage = bridgeBitmap;
+                    if (nextRun.backend === 'webgl2') {
+                        flipWebGLSourceY = false;
+                    }
                 }
             }
         }
     }
+    finally {
+        // Also release a bridge if setup/apply throws or the run is cancelled.
+        bridgeBitmap === null || bridgeBitmap === void 0 ? void 0 : bridgeBitmap.close();
+    }
     if (!lastTarget) {
         return true;
     }
@@ -173,4 +185,30 @@ const runEffectChain = async ({ state, source, effects, output, width, height, }
     outCtx.drawImage(lastTarget, 0, 0, width, height);
     return true;
 };
+// Keep ownership of the optional resized source until the existing chain settles.
+const runEffectChain = async (options) => {
+    const { state, source, width, height, effects } = options;
+    // Keep one ID across resizing and effect passes so callers can cancel the run.
+    const runId = ++state.currentRunId;
+    if ((state.width === width && state.height === height) ||
+        !effects.some((effect) => !effect.params.disabled)) {
+        return runEffectChainWithoutResize(options, true, runId);
+    }
+    const firstEnabledEffect = effects.find((effect) => !effect.params.disabled);
+    const resized = await createImageBitmap(source, {
+        resizeWidth: state.width,
+        resizeHeight: state.height,
+        // WebGL ignores UNPACK_FLIP_Y_WEBGL for ImageBitmap uploads.
+        imageOrientation: firstEnabledEffect.definition.backend === 'webgl2' ? 'flipY' : 'none',
+    });
+    try {
+        if (state.currentRunId !== runId) {
+            return false;
+        }
+        return await runEffectChainWithoutResize({ ...options, source: resized }, false, runId);
+    }
+    finally {
+        resized.close();
+    }
+};
 exports.runEffectChain = runEffectChain;

package/dist/cjs/effects/use-effect-chain-state.d.ts

@@ -1,4 +1,5 @@
+import type { EffectsOutputSize } from './effect-types.js';
 import type { EffectChainState } from './run-effect-chain.js';
-export declare const useEffectChainState: () => {
+export declare const useEffectChainState: (effectsOutputSize?: EffectsOutputSize | null) => {
     get: (width: number, height: number) => EffectChainState | null;
 };

package/dist/cjs/effects/use-effect-chain-state.js

@@ -2,8 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useEffectChainState = void 0;
 const react_1 = require("react");
+const validate_dimensions_js_1 = require("../validation/validate-dimensions.js");
 const run_effect_chain_js_1 = require("./run-effect-chain.js");
-const useEffectChainState = () => {
+const useEffectChainState = (effectsOutputSize = null) => {
+    const effectWidth = effectsOutputSize === null || effectsOutputSize === void 0 ? void 0 : effectsOutputSize.width;
+    const effectHeight = effectsOutputSize === null || effectsOutputSize === void 0 ? void 0 : effectsOutputSize.height;
+    if (effectsOutputSize) {
+        (0, validate_dimensions_js_1.validateDimension)(effectWidth, 'effectsOutputSize.width', 'on an effect-capable component');
+        (0, validate_dimensions_js_1.validateDimension)(effectHeight, 'effectsOutputSize.height', 'on an effect-capable component');
+    }
     const chainStateRef = (0, react_1.useRef)(null);
     const sizeRef = (0, react_1.useRef)(null);
     const unmountedRef = (0, react_1.useRef)(false);
@@ -22,6 +29,8 @@ const useEffectChainState = () => {
     }, []);
     return (0, react_1.useMemo)(() => ({
         get: (width, height) => {
+            width = effectWidth !== null && effectWidth !== void 0 ? effectWidth : width;
+            height = effectHeight !== null && effectHeight !== void 0 ? effectHeight : height;
             // Async work such as a late decoded video frame can still get here
             // after unmount. Nothing would release a pool created at this point.
             if (unmountedRef.current) {
@@ -38,6 +47,6 @@ const useEffectChainState = () => {
             }
             return chainStateRef.current;
         },
-    }), []);
+    }), [effectWidth, effectHeight]);
 };
 exports.useEffectChainState = useEffectChainState;

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

@@ -39,6 +39,7 @@ const react_1 = __importStar(require("react"));
 const evaluate_source_expressions_js_1 = require("../evaluate-source-expressions.js");
 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 registry_store_js_1 = require("../registry-store.js");
 const runtime_value_store_js_1 = require("../runtime-value-store.js");
 const sequence_activity_context_js_1 = require("../sequence-activity-context.js");
 const sequence_node_path_js_1 = require("../sequence-node-path.js");
@@ -46,6 +47,20 @@ const SequenceManager_js_1 = require("../SequenceManager.js");
 const use_current_frame_js_1 = require("../use-current-frame.js");
 const emptyDragOverrides = {};
 const useCacheCommitEffect = (_a = react_1.default.useInsertionEffect) !== null && _a !== void 0 ? _a : react_1.useLayoutEffect;
+const areEffectParamsEqual = (previous, next) => {
+    if (Object.is(previous, next)) {
+        return true;
+    }
+    if (previous === null ||
+        next === null ||
+        typeof previous !== 'object' ||
+        typeof next !== 'object' ||
+        Object.getPrototypeOf(previous) !== Object.prototype ||
+        Object.getPrototypeOf(next) !== Object.prototype) {
+        return false;
+    }
+    return (0, registry_store_js_1.areRegistryEntriesEqual)(previous, next);
+};
 const mergeOverrides = ({ descriptor, propStatusOverrides, dragOverrides, frame, }) => {
     if (!propStatusOverrides && !dragOverrides) {
         return { params: descriptor.params, effectKey: descriptor.effectKey };
@@ -105,17 +120,16 @@ const resolvePropStatusOverrides = (propStatus, frame) => {
 const useMemoizedEffectDefinitions = (effects) => {
     const activityDormant = (0, react_1.useContext)(sequence_activity_context_js_1.SequenceActivityDormantContext);
     const previousRef = (0, react_1.useRef)(null);
-    const definitions = effects.map((descriptor) => descriptor.definition);
     const previous = previousRef.current;
     const isSame = previous !== null &&
-        previous.definitions.length === definitions.length &&
-        previous.definitions.every((definition, i) => definition === definitions[i]);
+        previous.definitions.length === effects.length &&
+        previous.definitions.every((definition, i) => definition === effects[i].definition);
     const controllers = isSame
         ? previous.controllers
         : effects.map((effect) => (0, runtime_value_store_js_1.createRuntimeValueStore)(effect.params));
     const stableDefinitions = isSame
         ? previous.definitions
-        : Object.assign(definitions, {
+        : Object.assign(effects.map((descriptor) => descriptor.definition), {
             runtimeValues: controllers.map((controller) => controller.store),
         });
     useCacheCommitEffect(() => {
@@ -125,6 +139,12 @@ const useMemoizedEffectDefinitions = (effects) => {
         if (!activityDormant || controllers.length === 0) {
             return;
         }
+        if (controllers.every((controller, index) => {
+            var _a;
+            return areEffectParamsEqual(controller.store.getSnapshot(), (_a = effects[index]) === null || _a === void 0 ? void 0 : _a.params);
+        })) {
+            return;
+        }
         let cancelled = false;
         queueMicrotask(() => {
             if (cancelled) {
@@ -134,21 +154,10 @@ const useMemoizedEffectDefinitions = (effects) => {
                 var _a;
                 const snapshot = (_a = effects[index]) === null || _a === void 0 ? void 0 : _a.params;
                 const currentSnapshot = controller.store.getSnapshot();
-                if (Object.is(snapshot, currentSnapshot)) {
-                    return;
-                }
                 // Equivalent inline params should not notify inspector subscribers on
                 // every dormant render. Preserve changes to keys and leaf references.
-                if (snapshot !== null &&
-                    currentSnapshot !== null &&
-                    typeof snapshot === 'object' &&
-                    typeof currentSnapshot === 'object') {
-                    const keys = Object.keys(snapshot);
-                    if (keys.length === Object.keys(currentSnapshot).length &&
-                        keys.every((key) => Object.prototype.hasOwnProperty.call(currentSnapshot, key) &&
-                            Object.is(snapshot[key], currentSnapshot[key]))) {
-                        return;
-                    }
+                if (areEffectParamsEqual(snapshot, currentSnapshot)) {
+                    return;
                 }
                 controller.setSnapshot(snapshot);
             });
@@ -164,7 +173,9 @@ const useMemoizedEffectDefinitions = (effects) => {
         stableDefinitions.forEach((_definition, index) => {
             var _a;
             const snapshot = (_a = effects[index]) === null || _a === void 0 ? void 0 : _a.params;
-            controllers[index].setSnapshot(snapshot);
+            if (!areEffectParamsEqual(controllers[index].store.getSnapshot(), snapshot)) {
+                controllers[index].setSnapshot(snapshot);
+            }
         });
     }, [controllers, effects, stableDefinitions]);
     return stableDefinitions;
@@ -206,55 +217,86 @@ const useMemoizedEffects = ({ effects, overrideId, videoConfigValues, }) => {
     var _a;
     const previousRef = (0, react_1.useRef)(null);
     const { propStatuses } = (0, react_1.useContext)(SequenceManager_js_1.VisualModePropStatusesContext);
-    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;
     const nodePath = overrideId
         ? ((_a = overrideIdToNodePathMappings[overrideId]) !== null && _a !== void 0 ? _a : null)
         : null;
     const effectDragOverrides = (0, SequenceManager_js_1.useEffectDragOverridesForNodePath)(nodePath);
-    const resolved = effects.map((descriptor, index) => {
-        var _a;
+    const effectPropStatuses = (0, react_1.useMemo)(() => Array.from({ length: effects.length }, (_, effectIndex) => {
         if (nodePath === null) {
-            return {
-                descriptor,
-                params: descriptor.params,
-                effectKey: descriptor.effectKey,
-            };
+            return null;
         }
-        const effectStatus = (0, exports.getEffectPropStatusesCtx)({
+        const status = (0, exports.getEffectPropStatusesCtx)({
             propStatuses,
             nodePath: { ...nodePath, videoConfigValues },
-            effectIndex: index,
+            effectIndex,
         });
-        const propStatusOverrides = effectStatus.type === 'can-update-effect'
-            ? resolvePropStatusOverrides(effectStatus.props, frame)
-            : null;
+        return status.type === 'can-update-effect' ? status.props : null;
+    }), [effects.length, nodePath, propStatuses, videoConfigValues]);
+    const animatedEffects = (0, react_1.useMemo)(() => effectPropStatuses.map((status, index) => {
+        var _a;
+        return Object.values(status !== null && status !== void 0 ? status : {}).some((prop) => prop.status === 'keyframed') ||
+            Object.values((_a = effectDragOverrides[index]) !== null && _a !== void 0 ? _a : emptyDragOverrides).some((override) => override.type === 'keyframed');
+    }), [effectDragOverrides, effectPropStatuses]);
+    // Runtime animations arrive through props. Only source/drag keyframes need
+    // their own clock, and an animated effect must not invalidate static siblings.
+    const frame = (0, use_current_frame_js_1.useCurrentFrameWithOptionalSubscription)(animatedEffects.some(Boolean));
+    const prepared = effects.map((descriptor, index) => {
+        var _a;
+        const propStatus = effectPropStatuses[index];
         const dragOverridesMap = (_a = effectDragOverrides[index]) !== null && _a !== void 0 ? _a : emptyDragOverrides;
         const dragOverrides = Object.keys(dragOverridesMap).length === 0 ? null : dragOverridesMap;
+        const effectFrame = animatedEffects[index] ? frame : null;
+        const cached = previous === null || previous === void 0 ? void 0 : previous.prepared[index];
+        if (cached &&
+            cached.definition === descriptor.definition &&
+            cached.sourceKey === descriptor.effectKey &&
+            areEffectParamsEqual(cached.params, descriptor.params) &&
+            cached.propStatus === propStatus &&
+            cached.dragOverrides === dragOverrides &&
+            cached.frame === effectFrame) {
+            return cached;
+        }
+        const propStatusOverrides = resolvePropStatusOverrides(propStatus !== null && propStatus !== void 0 ? propStatus : undefined, frame);
         const { params, effectKey } = mergeOverrides({
             descriptor,
             propStatusOverrides,
             dragOverrides,
             frame,
         });
-        return { descriptor, params, effectKey };
+        return {
+            definition: descriptor.definition,
+            sourceKey: descriptor.effectKey,
+            // Snapshot plain params so shallow comparisons see in-place field edits.
+            params: descriptor.params !== null &&
+                typeof descriptor.params === 'object' &&
+                Object.getPrototypeOf(descriptor.params) === Object.prototype
+                ? { ...descriptor.params }
+                : descriptor.params,
+            propStatus,
+            dragOverrides,
+            frame: effectFrame,
+            value: (cached === null || cached === void 0 ? void 0 : cached.value.definition) === descriptor.definition &&
+                cached.value.effectKey === effectKey
+                ? cached.value
+                : {
+                    definition: descriptor.definition,
+                    effectKey,
+                    params,
+                    memoized: true,
+                },
+        };
     });
     const isSame = previous !== null &&
-        previous.length === resolved.length &&
-        previous.every((p, i) => p.definition === resolved[i].descriptor.definition &&
-            p.effectKey === resolved[i].effectKey);
+        previous.effects.length === prepared.length &&
+        previous.effects.every((effect, i) => effect === prepared[i].value);
     const next = isSame
-        ? previous
-        : resolved.map(({ descriptor, params, effectKey }) => ({
-            definition: descriptor.definition,
-            effectKey,
-            params,
-            memoized: true,
-        }));
+        ? previous.effects
+        : prepared.map((effect) => effect.value);
     useCacheCommitEffect(() => {
-        previousRef.current = next;
-    }, [next]);
+        previousRef.current = { prepared, effects: next };
+    }, [next, prepared]);
     return next;
 };
 exports.useMemoizedEffects = useMemoizedEffects;

package/dist/cjs/index.d.ts

@@ -98,7 +98,7 @@ export type BundleEvaluationState = {
 export type BundleState = BundleIndexState | BundleEvaluationState | BundleCompositionState;
 export * from './AbsoluteFill.js';
 export * from './animated-image/index.js';
-export { createEffect, type Backend, type EffectApplyParams, type EffectDefinition, type EffectDefinitionAndStack, type EffectDescriptor, type EffectFactory, type EffectsProp, } from './effects/index.js';
+export { createEffect, type Backend, type EffectApplyParams, type EffectDefinition, type EffectDefinitionAndStack, type EffectDescriptor, type EffectFactory, type EffectsProp, type EffectsOutputSize, } from './effects/index.js';
 /**
  * @description Renders a solid-color rectangle on a `<canvas>`.
  * @see [Documentation](https://www.remotion.dev/docs/solid)

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

@@ -450,7 +450,7 @@ export declare const textContentSchema: {
 export declare const premountSchema: {
     readonly premountFor: {
         readonly type: "number";
-        readonly default: 0;
+        readonly default: undefined;
         readonly description: "Premount For";
         readonly min: 0;
         readonly step: 1;
@@ -469,7 +469,7 @@ export declare const premountSchema: {
 export declare const sequencePremountSchema: {
     readonly premountFor: {
         readonly type: "number";
-        readonly default: 0;
+        readonly default: undefined;
         readonly description: "Premount For";
         readonly min: 0;
         readonly step: 1;
@@ -683,7 +683,7 @@ export declare const sequenceStyleSchema: {
     };
     readonly premountFor: {
         readonly type: "number";
-        readonly default: 0;
+        readonly default: undefined;
         readonly description: "Premount For";
         readonly min: 0;
         readonly step: 1;
@@ -1040,7 +1040,7 @@ export declare const sequenceSchema: {
                 };
                 readonly premountFor: {
                     readonly type: "number";
-                    readonly default: 0;
+                    readonly default: undefined;
                     readonly description: "Premount For";
                     readonly min: 0;
                     readonly step: 1;
@@ -1286,7 +1286,7 @@ export declare const sequenceSchemaWithoutFrom: {
                 };
                 readonly premountFor: {
                     readonly type: "number";
-                    readonly default: 0;
+                    readonly default: undefined;
                     readonly description: "Premount For";
                     readonly min: 0;
                     readonly step: 1;

package/dist/cjs/interactivity-schema.js

@@ -245,7 +245,8 @@ exports.textContentSchema = exports.childrenSchema;
 exports.premountSchema = {
     premountFor: {
         type: 'number',
-        default: 0,
+        // Omission inherits the preview's default; zero explicitly disables it.
+        default: undefined,
         description: 'Premount For',
         min: 0,
         step: 1,

package/dist/cjs/internals.d.ts

@@ -133,6 +133,9 @@ export declare const Internals: {
         readonly crossOrigin?: "" | "anonymous" | "use-credentials" | undefined;
     }, "ref"> & import("react").RefAttributes<HTMLVideoElement>>;
     readonly CompositionManager: import("react").Context<CompositionManagerContext>;
+    readonly CompositionManagerRefContext: import("react").Context<{
+        readonly current: CompositionManagerContext;
+    }>;
     readonly CompositionSetters: import("react").Context<import("./CompositionManagerContext.js").CompositionManagerSetters>;
     readonly VisualModePropStatusesContext: import("react").Context<import("./SequenceManager.js").VisualModePropStatuses>;
     readonly VisualModePropStatusesRefContext: import("react").Context<import("./SequenceManager.js").VisualModePropStatusesRef>;
@@ -364,7 +367,7 @@ export declare const Internals: {
                     };
                     readonly premountFor: {
                         readonly type: "number";
-                        readonly default: 0;
+                        readonly default: undefined;
                         readonly description: "Premount For";
                         readonly min: 0;
                         readonly step: 1;
@@ -455,9 +458,8 @@ export declare const Internals: {
     readonly SequenceContent: import("react").FC<{
         readonly children: import("react").ReactNode;
     }>;
-    readonly DEFAULT_SEQUENCE_ACTIVITY_LIMIT: 20;
+    readonly DEFAULT_SEQUENCE_ACTIVITY_LIMIT: number;
     readonly SequenceActivitySettingsContext: import("react").Context<{
-        readonly enabled: boolean;
         readonly limit: number;
     } | null>;
     readonly SequenceWithoutSchema: import("react").ForwardRefExoticComponent<import("./Sequence.js").SequenceProps & import("react").RefAttributes<HTMLDivElement>>;
@@ -575,7 +577,7 @@ export declare const Internals: {
         };
         readonly premountFor: {
             readonly type: "number";
-            readonly default: 0;
+            readonly default: undefined;
             readonly description: "Premount For";
             readonly min: 0;
             readonly step: 1;
@@ -671,7 +673,7 @@ export declare const Internals: {
     readonly sequencePremountSchema: {
         readonly premountFor: {
             readonly type: "number";
-            readonly default: 0;
+            readonly default: undefined;
             readonly description: "Premount For";
             readonly min: 0;
             readonly step: 1;
@@ -833,7 +835,7 @@ export declare const Internals: {
     readonly premountSchema: {
         readonly premountFor: {
             readonly type: "number";
-            readonly default: 0;
+            readonly default: undefined;
             readonly description: "Premount For";
             readonly min: 0;
             readonly step: 1;
@@ -909,7 +911,6 @@ export declare const Internals: {
     readonly truthy: typeof truthy;
     readonly SequenceContext: import("react").Context<import("./SequenceContext.js").SequenceContextType | null>;
     readonly TimelineTrackContext: import("react").Context<import("./timeline-track-context.js").TimelineTrack | null>;
-    readonly ExperimentalTracksEnabledContext: import("react").Context<boolean>;
     readonly TrackWithoutSchema: import("react").FC<import("./Track.js").TrackWithoutSchemaProps>;
     readonly PremountContext: import("react").Context<import("./PremountContext.js").PremountContextValue>;
     readonly usePremounting: ({ from, durationInFrames, premountFor, postmountFor, style, styleWhilePremounted, styleWhilePostmounted, hideWhilePremounted, }: {
@@ -956,7 +957,7 @@ export declare const Internals: {
         resumeAsAutoPlay: () => Promise<void>;
         suspend: () => Promise<void>;
         getIsResumingAudioContext: () => Promise<import("./audio/wait-until-actually-resumed.js").AudioContextResumeResult> | null;
-        unscheduleAudioNode: (node: AudioBufferSourceNode) => void;
+        unscheduleAudioNode: (node: AudioBufferSourceNode) => boolean;
         _experimentalKeepAudioContextAlive: boolean;
     } | null>;
     readonly SharedAudioContextProvider: import("react").FC<{
@@ -1316,12 +1317,12 @@ export declare const Internals: {
         shouldResortToDefaultValueIfUndefined: boolean;
     }) => unknown;
     readonly CompositionRenderErrorContext: import("react").Context<import("./composition-render-error-context.js").CompositionRenderErrorContextType>;
-    readonly useEffectChainState: () => {
+    readonly useEffectChainState: (effectsOutputSize?: import("./index.js").EffectsOutputSize | null) => {
         get: (width: number, height: number) => import("./internals.js").EffectChainState | null;
     };
     readonly createEffectChainState: (width: number, height: number) => import("./internals.js").EffectChainState;
     readonly cleanupEffectChainState: (state: import("./internals.js").EffectChainState) => void;
-    readonly runEffectChain: ({ state, source, effects, output, width, height, }: import("./effects/run-effect-chain.js").RunEffectChainOptions) => Promise<boolean>;
+    readonly runEffectChain: (options: import("./effects/run-effect-chain.js").RunEffectChainOptions) => Promise<boolean>;
     readonly useMemoizedEffects: ({ effects, overrideId, videoConfigValues, }: {
         effects: readonly import("./index.js").EffectDescriptor<unknown>[];
         readonly overrideId: string | null;

package/dist/cjs/internals.js

@@ -180,6 +180,7 @@ exports.Internals = {
     resolveTrimProps: validate_start_from_props_js_1.resolveTrimProps,
     VideoForPreview: VideoForPreview_js_1.VideoForPreview,
     CompositionManager: CompositionManagerContext_js_1.CompositionManager,
+    CompositionManagerRefContext: CompositionManagerContext_js_1.CompositionManagerRefContext,
     CompositionSetters: CompositionManagerContext_js_1.CompositionSetters,
     VisualModePropStatusesContext: SequenceManager_js_1.VisualModePropStatusesContext,
     VisualModePropStatusesRefContext: SequenceManager_js_1.VisualModePropStatusesRefContext,
@@ -228,7 +229,6 @@ exports.Internals = {
     truthy: truthy_js_1.truthy,
     SequenceContext: SequenceContext_js_1.SequenceContext,
     TimelineTrackContext: timeline_track_context_js_1.TimelineTrackContext,
-    ExperimentalTracksEnabledContext: timeline_track_context_js_1.ExperimentalTracksEnabledContext,
     TrackWithoutSchema: Track_js_1.TrackWithoutSchema,
     PremountContext: PremountContext_js_1.PremountContext,
     usePremounting: use_premounting_js_1.usePremounting,

package/dist/cjs/interpolate.js

@@ -288,7 +288,14 @@ const parseStringInterpolationValue = (output, outputType) => {
     }
     const parts = output.trim().split(/\s+/);
     if (parts.length < 1 || parts.length > 3 || parts[0] === '') {
-        throw new TypeError(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
+        // Long text values (for example custom cursor CSS) may use hold easing.
+        // Malformed numeric transforms must still fail instead of becoming text.
+        const ErrorType = outputType === undefined &&
+            parts.some((part) => !cssNumberRegex.test(part) &&
+                !transformOriginKeywords.has(part.toLowerCase()))
+            ? UnsupportedStringInterpolationValueError
+            : TypeError;
+        throw new ErrorType(`String outputRange values must contain 1 to 3 components, but got "${output}"`);
     }
     if (parts.some((part) => transformOriginKeywords.has(part.toLowerCase()))) {
         if (outputType !== undefined) {

package/dist/cjs/no-react.d.ts

@@ -226,7 +226,7 @@ export declare const NoReactInternals: {
                     };
                     readonly premountFor: {
                         readonly type: "number";
-                        readonly default: 0;
+                        readonly default: undefined;
                         readonly description: "Premount For";
                         readonly min: 0;
                         readonly step: 1;