remotion 4.0.534 → 4.0.536

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];
-        const [a, b] = state.pool.getPair(run.backend);
-        let dst = a;
-        for (const eff of run.effects) {
-            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;
-            dst = dst === a ? b : a;
-        }
-        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

@@ -1,15 +1,51 @@
 "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;
+    };
+})();
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.useMemoizedEffects = exports.getPropStatusesCtx = exports.getEffectPropStatusesCtx = exports.useMemoizedEffectDefinitions = void 0;
-const react_1 = require("react");
+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 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");
 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 mergeOverrides = ({ descriptor, propStatusOverrides, dragOverrides, frame, }) => {
     if (!propStatusOverrides && !dragOverrides) {
         return { params: descriptor.params, effectKey: descriptor.effectKey };
@@ -67,6 +103,7 @@ const resolvePropStatusOverrides = (propStatus, frame) => {
     return hasAny ? out : null;
 };
 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;
@@ -76,7 +113,51 @@ const useMemoizedEffectDefinitions = (effects) => {
     const controllers = isSame
         ? previous.controllers
         : effects.map((effect) => (0, runtime_value_store_js_1.createRuntimeValueStore)(effect.params));
-    const stableDefinitions = isSame ? previous.definitions : definitions;
+    const stableDefinitions = isSame
+        ? previous.definitions
+        : Object.assign(definitions, {
+            runtimeValues: controllers.map((controller) => controller.store),
+        });
+    useCacheCommitEffect(() => {
+        // Insertion effects also run for hidden Activity commits. Store listeners
+        // must run after React finishes committing, never inside an insertion effect.
+        previousRef.current = { definitions: stableDefinitions, controllers };
+        if (!activityDormant || controllers.length === 0) {
+            return;
+        }
+        let cancelled = false;
+        queueMicrotask(() => {
+            if (cancelled) {
+                return;
+            }
+            controllers.forEach((controller, index) => {
+                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;
+                    }
+                }
+                controller.setSnapshot(snapshot);
+            });
+        });
+        return () => {
+            // A newer commit or unmount supersedes this pending publication.
+            cancelled = true;
+        };
+    }, [activityDormant, controllers, effects, stableDefinitions]);
     (0, react_1.useLayoutEffect)(() => {
         // Stores are intentionally updated without changing the registered effect
         // array, so frame-dependent parameters don't re-register the Sequence.
@@ -86,10 +167,7 @@ const useMemoizedEffectDefinitions = (effects) => {
             controllers[index].setSnapshot(snapshot);
         });
     }, [controllers, effects, stableDefinitions]);
-    previousRef.current = { definitions: stableDefinitions, controllers };
-    return Object.assign(stableDefinitions, {
-        runtimeValues: controllers.map((controller) => controller.store),
-    });
+    return stableDefinitions;
 };
 exports.useMemoizedEffectDefinitions = useMemoizedEffectDefinitions;
 const getEffectPropStatusesCtx = ({ propStatuses, nodePath, effectIndex, }) => {
@@ -134,7 +212,7 @@ const useMemoizedEffects = ({ effects, overrideId, videoConfigValues, }) => {
     const nodePath = overrideId
         ? ((_a = overrideIdToNodePathMappings[overrideId]) !== null && _a !== void 0 ? _a : null)
         : null;
-    const effectDragOverrides = (0, SequenceManager_js_1.useEffectDragOverridesForNodePath)(nodePath, effects.length);
+    const effectDragOverrides = (0, SequenceManager_js_1.useEffectDragOverridesForNodePath)(nodePath);
     const resolved = effects.map((descriptor, index) => {
         var _a;
         if (nodePath === null) {
@@ -166,16 +244,17 @@ const useMemoizedEffects = ({ effects, overrideId, videoConfigValues, }) => {
         previous.length === resolved.length &&
         previous.every((p, i) => p.definition === resolved[i].descriptor.definition &&
             p.effectKey === resolved[i].effectKey);
-    if (isSame) {
-        return previous;
-    }
-    const next = resolved.map(({ descriptor, params, effectKey }) => ({
-        definition: descriptor.definition,
-        effectKey,
-        params,
-        memoized: true,
-    }));
-    previousRef.current = next;
+    const next = isSame
+        ? previous
+        : resolved.map(({ descriptor, params, effectKey }) => ({
+            definition: descriptor.definition,
+            effectKey,
+            params,
+            memoized: true,
+        }));
+    useCacheCommitEffect(() => {
+        previousRef.current = next;
+    }, [next]);
     return next;
 };
 exports.useMemoizedEffects = useMemoizedEffects;

package/dist/cjs/enable-sequence-stack-traces.d.ts

@@ -1,6 +1,6 @@
-import React from 'react';
 import type { SequenceControls } from './CompositionManager.js';
-type ComponentIdentityResolver = (component: unknown) => unknown;
+export declare const setSequenceComponent: (component: unknown) => void;
+export declare const getSequenceComponent: () => unknown;
 export declare const REMOTION_INTERNAL_STACK_PROP = "_remotionInternalStack";
 export type OriginalSourceLocation = {
     fileName: string;
@@ -15,11 +15,5 @@ export declare const makeOriginalSourceStack: ({ fileName, lineNumber, columnNum
 export declare const parseOriginalSourceStack: (stack: string | null) => OriginalSourceLocation | null;
 export declare const getComponentsToAddStacksTo: () => unknown[];
 export declare const addSequenceStackTraces: (component: unknown) => void;
-export declare const setSequenceComponent: (component: unknown) => void;
-export declare const getSequenceComponent: () => unknown;
-export declare const setComponentIdentityResolver: (resolver: ComponentIdentityResolver | null) => void;
-export declare const resolveComponentIdentity: (component: unknown) => unknown;
 export declare const setStackForControls: (controls: SequenceControls, stack: string | undefined) => void;
 export declare const getStackForControls: (controls: SequenceControls) => string | null;
-export declare const getSingleChildComponent: (children: React.ReactNode) => unknown;
-export {};

package/dist/cjs/enable-sequence-stack-traces.js

@@ -1,16 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSingleChildComponent = exports.getStackForControls = exports.setStackForControls = exports.resolveComponentIdentity = exports.setComponentIdentityResolver = exports.getSequenceComponent = exports.setSequenceComponent = exports.addSequenceStackTraces = exports.getComponentsToAddStacksTo = exports.parseOriginalSourceStack = exports.makeOriginalSourceStack = exports.REMOTION_INTERNAL_STACK_PROP = void 0;
-const react_1 = __importDefault(require("react"));
+exports.getStackForControls = exports.setStackForControls = exports.addSequenceStackTraces = exports.getComponentsToAddStacksTo = exports.parseOriginalSourceStack = exports.makeOriginalSourceStack = exports.REMOTION_INTERNAL_STACK_PROP = exports.getSequenceComponent = exports.setSequenceComponent = void 0;
 const componentsToAddStacksTo = [];
 let sequenceComponent = null;
+const setSequenceComponent = (component) => {
+    sequenceComponent = component;
+};
+exports.setSequenceComponent = setSequenceComponent;
+const getSequenceComponent = () => sequenceComponent;
+exports.getSequenceComponent = getSequenceComponent;
 const stacksByControls = new WeakMap();
-// Studio installs a resolver that maps refreshed component implementations to
-// the stable family object maintained by React Refresh.
-let componentIdentityResolver = null;
 exports.REMOTION_INTERNAL_STACK_PROP = '_remotionInternalStack';
 // Bundlers that know where a JSX element was written encode its source
 // location as a synthetic stack frame, so consumers can skip symbolication.
@@ -41,21 +40,6 @@ const addSequenceStackTraces = (component) => {
     componentsToAddStacksTo.push(component);
 };
 exports.addSequenceStackTraces = addSequenceStackTraces;
-const setSequenceComponent = (component) => {
-    sequenceComponent = component;
-};
-exports.setSequenceComponent = setSequenceComponent;
-const getSequenceComponent = () => sequenceComponent;
-exports.getSequenceComponent = getSequenceComponent;
-const setComponentIdentityResolver = (resolver) => {
-    componentIdentityResolver = resolver;
-};
-exports.setComponentIdentityResolver = setComponentIdentityResolver;
-const resolveComponentIdentity = (component) => {
-    var _a;
-    return (_a = componentIdentityResolver === null || componentIdentityResolver === void 0 ? void 0 : componentIdentityResolver(component)) !== null && _a !== void 0 ? _a : component;
-};
-exports.resolveComponentIdentity = resolveComponentIdentity;
 const setStackForControls = (controls, stack) => {
     if (stack === undefined) {
         stacksByControls.delete(controls);
@@ -69,18 +53,3 @@ const getStackForControls = (controls) => {
     return (_a = stacksByControls.get(controls)) !== null && _a !== void 0 ? _a : null;
 };
 exports.getStackForControls = getStackForControls;
-const getSingleChildComponent = (children) => {
-    const mountedChildren = react_1.default.Children.toArray(children);
-    if (mountedChildren.length !== 1) {
-        return null;
-    }
-    const child = mountedChildren[0];
-    if (!react_1.default.isValidElement(child)) {
-        return null;
-    }
-    if (typeof child.type !== 'function' && typeof child.type !== 'object') {
-        return null;
-    }
-    return (0, exports.resolveComponentIdentity)(child.type);
-};
-exports.getSingleChildComponent = getSingleChildComponent;

package/dist/cjs/freeze.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Freeze = exports.useIsInsideNonPremountFreeze = void 0;
 const jsx_runtime_1 = require("react/jsx-runtime");
 const react_1 = require("react");
+const sequence_activity_context_js_1 = require("./sequence-activity-context.js");
 const SequenceContext_js_1 = require("./SequenceContext.js");
 const timeline_position_state_js_1 = require("./timeline-position-state.js");
 const TimelineContext_js_1 = require("./TimelineContext.js");
@@ -40,6 +41,7 @@ const Freeze = ({ frame: frameToFreeze, children, active = true, _remotionIntern
         }
     }, [active, frame]);
     const timelineContext = (0, timeline_position_state_js_1.useTimelineContext)();
+    const activityDormant = (0, react_1.useContext)(sequence_activity_context_js_1.SequenceActivityDormantContext);
     const sequenceContext = (0, react_1.useContext)(SequenceContext_js_1.SequenceContext);
     const isInsideNonPremountFreeze = (0, exports.useIsInsideNonPremountFreeze)();
     const relativeFrom = (_a = sequenceContext === null || sequenceContext === void 0 ? void 0 : sequenceContext.relativeFrom) !== null && _a !== void 0 ? _a : 0;
@@ -74,7 +76,8 @@ const Freeze = ({ frame: frameToFreeze, children, active = true, _remotionIntern
             cumulatedFrom: 0,
         };
     }, [sequenceContext, isActive]);
+    const providedTimeline = isActive ? frozenTimelineValue : timelineContext;
     return (jsx_runtime_1.jsx(NonPremountFreezeContext.Provider, { value: isInsideNonPremountFreeze ||
-            (Boolean(isActive) && !_remotionInternalIsPremounting), children: jsx_runtime_1.jsx(TimelineContext_js_1.TimelineContext.Provider, { value: isActive ? frozenTimelineValue : timelineContext, children: jsx_runtime_1.jsx(SequenceContext_js_1.SequenceContext.Provider, { value: newSequenceContext, children: children }) }) }));
+            (Boolean(isActive) && !_remotionInternalIsPremounting), children: jsx_runtime_1.jsx(TimelineContext_js_1.TimelineContext.Provider, { value: providedTimeline, children: jsx_runtime_1.jsx(sequence_activity_context_js_1.SequenceActivityTimelineContext.Provider, { value: activityDormant ? providedTimeline : null, children: jsx_runtime_1.jsx(SequenceContext_js_1.SequenceContext.Provider, { value: newSequenceContext, children: children }) }) }) }));
 };
 exports.Freeze = Freeze;

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)
@@ -164,12 +164,10 @@ export { watchStaticFile } from './watch-static-file.js';
 export declare const Experimental: {
     /**
      * @description This is a special component that will cause Remotion to only partially capture the frame of the video.
-     * @see [Documentation](https://www.remotion.dev/docs/clipper)
      */
     Clipper: import("react").FC<{}>;
     /**
      * @description This is a special component, that, when rendered, will skip rendering the frame altogether.
-     * @see [Documentation](https://www.remotion.dev/docs/null)
      */
     Null: import("react").FC<{}>;
     useIsPlayer: () => boolean;

package/dist/cjs/index.js

@@ -119,12 +119,10 @@ Object.defineProperty(exports, "watchStaticFile", { enumerable: true, get: funct
 exports.Experimental = {
     /**
      * @description This is a special component that will cause Remotion to only partially capture the frame of the video.
-     * @see [Documentation](https://www.remotion.dev/docs/clipper)
      */
     Clipper: Clipper_js_1.Clipper,
     /**
      * @description This is a special component, that, when rendered, will skip rendering the frame altogether.
-     * @see [Documentation](https://www.remotion.dev/docs/null)
      */
     Null: Null_js_1.Null,
     useIsPlayer: is_player_js_1.useIsPlayer,